00001 #include <Python.h>
00002 #include <iostream>
00003 #include "theano_mod_helper.h"
00004 #include <math.h>
00005 #include <numpy/arrayobject.h>
00006 #include <numpy/arrayscalars.h>
00007 //////////////////////
00008 //// Support Code
00009 //////////////////////
00010
00011
00012 namespace {
00013 struct __struct_compiled_op_m60e56977ddfb69ae27ec355d8781d656 {
00014 PyObject* __ERROR;
00015
00016 PyObject* storage_V3;
00017 PyObject* storage_V5;
00018 PyObject* storage_V7;
00019 PyObject* storage_V9;
00020 PyObject* storage_V11;
00021 PyObject* storage_V13;
00022 PyObject* storage_V15;
00023 PyObject* storage_V17;
00024 PyObject* storage_V19;
00025 PyObject* storage_V21;
00026 PyObject* storage_V23;
00027 PyObject* storage_V25;
00028 PyObject* storage_V27;
00029 PyObject* storage_V29;
00030 PyObject* storage_V31;
00031 PyObject* storage_V33;
00032 PyObject* storage_V35;
00033 PyObject* storage_V37;
00034 PyObject* storage_V39;
00035 PyObject* storage_V41;
00036 PyObject* storage_V43;
00037 PyObject* storage_V45;
00038 PyObject* storage_V47;
00039 PyObject* storage_V49;
00040 PyObject* storage_V51;
00041 PyObject* storage_V53;
00042 PyObject* storage_V55;
00043 PyObject* storage_V57;
00044 PyObject* storage_V59;
00045 PyObject* storage_V61;
00046 PyObject* storage_V63;
00047 PyObject* storage_V65;
00048 PyObject* storage_V67;
00049 PyObject* storage_V69;
00050 PyObject* storage_V71;
00051 PyObject* storage_V73;
00052 PyObject* storage_V75;
00053 PyObject* storage_V77;
00054 PyObject* storage_V79;
00055 PyObject* storage_V81;
00056 PyObject* storage_V83;
00057 PyObject* storage_V85;
00058 PyObject* storage_V87;
00059 PyObject* storage_V89;
00060 PyObject* storage_V91;
00061 PyObject* storage_V93;
00062 PyObject* storage_V95;
00063 PyObject* storage_V97;
00064 PyObject* storage_V99;
00065 PyObject* storage_V101;
00066 PyObject* storage_V103;
00067 PyObject* storage_V105;
00068 PyObject* storage_V107;
00069 PyObject* storage_V109;
00070 PyObject* storage_V111;
00071 PyObject* storage_V113;
00072 PyObject* storage_V115;
00073 PyObject* storage_V117;
00074 PyObject* storage_V119;
00075 PyObject* storage_V121;
00076 PyObject* storage_V123;
00077 PyObject* storage_V125;
00078 PyObject* storage_V127;
00079 PyObject* storage_V129;
00080 PyObject* storage_V131;
00081 PyObject* storage_V133;
00082 PyObject* storage_V135;
00083 PyObject* storage_V137;
00084 PyObject* storage_V139;
00085 PyObject* storage_V141;
00086 PyObject* storage_V143;
00087 PyObject* storage_V145;
00088 PyObject* storage_V147;
00089 PyObject* storage_V149;
00090 PyObject* storage_V151;
00091 PyObject* storage_V153;
00092 PyObject* storage_V155;
00093 PyObject* storage_V157;
00094 PyObject* storage_V159;
00095 PyObject* storage_V161;
00096 PyObject* storage_V163;
00097 PyObject* storage_V165;
00098 PyObject* storage_V167;
00099 PyObject* storage_V169;
00100 PyObject* storage_V171;
00101 PyObject* storage_V173;
00102 PyObject* storage_V175;
00103 PyObject* storage_V177;
00104 PyObject* storage_V179;
00105 PyObject* storage_V181;
00106 PyObject* storage_V183;
00107 PyObject* storage_V185;
00108 PyObject* storage_V187;
00109 PyObject* storage_V189;
00110 PyObject* storage_V191;
00111 PyObject* storage_V193;
00112 PyObject* storage_V195;
00113 PyObject* storage_V197;
00114 PyObject* storage_V199;
00115 PyObject* storage_V201;
00116 PyObject* storage_V203;
00117 PyObject* storage_V205;
00118 PyObject* storage_V207;
00119 PyObject* storage_V209;
00120 PyObject* storage_V211;
00121 PyObject* storage_V213;
00122 PyObject* storage_V215;
00123 PyObject* storage_V217;
00124 PyObject* storage_V219;
00125 PyObject* storage_V221;
00126 PyObject* storage_V223;
00127 PyObject* storage_V225;
00128 PyObject* storage_V227;
00129 PyObject* storage_V229;
00130 PyObject* storage_V231;
00131 PyObject* storage_V233;
00132 PyObject* storage_V235;
00133 PyObject* storage_V237;
00134 PyObject* storage_V239;
00135 PyObject* storage_V241;
00136 PyObject* storage_V243;
00137 PyObject* storage_V245;
00138 PyObject* storage_V247;
00139 PyObject* storage_V249;
00140 PyObject* storage_V251;
00141 PyObject* storage_V253;
00142 PyObject* storage_V255;
00143 PyObject* storage_V257;
00144 PyObject* storage_V259;
00145 PyObject* storage_V261;
00146 PyObject* storage_V263;
00147 PyObject* storage_V265;
00148 PyObject* storage_V267;
00149 PyObject* storage_V269;
00150 PyObject* storage_V271;
00151 PyObject* storage_V273;
00152 PyObject* storage_V275;
00153 PyObject* storage_V277;
00154 PyObject* storage_V279;
00155 PyObject* storage_V281;
00156 PyObject* storage_V283;
00157 PyObject* storage_V285;
00158 PyObject* storage_V287;
00159 PyObject* storage_V289;
00160 PyObject* storage_V291;
00161 PyObject* storage_V293;
00162 PyObject* storage_V295;
00163 PyObject* storage_V297;
00164 PyObject* storage_V299;
00165 PyObject* storage_V301;
00166 PyObject* storage_V303;
00167 PyObject* storage_V305;
00168 PyObject* storage_V307;
00169 PyObject* storage_V309;
00170 PyObject* storage_V311;
00171 PyObject* storage_V313;
00172 PyObject* storage_V315;
00173 PyObject* storage_V317;
00174 PyObject* storage_V319;
00175 PyObject* storage_V321;
00176 PyObject* storage_V323;
00177 PyObject* storage_V325;
00178 PyObject* storage_V327;
00179 PyObject* storage_V329;
00180 PyObject* storage_V331;
00181 PyObject* storage_V333;
00182 PyObject* storage_V335;
00183 PyObject* storage_V337;
00184 PyObject* storage_V339;
00185 PyObject* storage_V341;
00186 PyObject* storage_V343;
00187 PyObject* storage_V345;
00188 PyObject* storage_V347;
00189 PyObject* storage_V349;
00190 PyObject* storage_V351;
00191 PyObject* storage_V353;
00192 PyObject* storage_V355;
00193 PyObject* storage_V357;
00194 PyObject* storage_V359;
00195 PyObject* storage_V361;
00196 PyObject* storage_V363;
00197 PyObject* storage_V365;
00198 PyObject* storage_V367;
00199 PyObject* storage_V369;
00200 PyObject* storage_V371;
00201 PyObject* storage_V373;
00202 PyObject* storage_V375;
00203 PyObject* storage_V377;
00204 PyObject* storage_V379;
00205 PyObject* storage_V381;
00206 PyObject* storage_V383;
00207 PyObject* storage_V385;
00208 PyObject* storage_V387;
00209 PyObject* storage_V389;
00210 PyObject* storage_V391;
00211 PyObject* storage_V393;
00212 PyObject* storage_V395;
00213 PyObject* storage_V397;
00214 PyObject* storage_V399;
00215 PyObject* storage_V401;
00216 PyObject* storage_V403;
00217 PyObject* storage_V405;
00218 PyObject* storage_V407;
00219 PyObject* storage_V409;
00220 PyObject* storage_V411;
00221 PyObject* storage_V413;
00222 PyObject* storage_V415;
00223 PyObject* storage_V417;
00224 PyObject* storage_V419;
00225 PyObject* storage_V421;
00226 PyObject* storage_V423;
00227 PyObject* storage_V425;
00228 PyObject* storage_V427;
00229 PyObject* storage_V429;
00230 PyObject* storage_V431;
00231 PyObject* storage_V433;
00232 PyObject* storage_V435;
00233 PyObject* storage_V437;
00234 PyObject* storage_V439;
00235 PyObject* storage_V441;
00236 PyObject* storage_V443;
00237 PyObject* storage_V445;
00238 PyObject* storage_V447;
00239 PyObject* storage_V449;
00240 PyObject* storage_V451;
00241 PyObject* storage_V453;
00242 PyObject* storage_V455;
00243 PyObject* storage_V457;
00244 PyObject* storage_V459;
00245 PyObject* storage_V461;
00246 PyObject* storage_V463;
00247 PyObject* storage_V465;
00248 PyObject* storage_V467;
00249 PyObject* storage_V469;
00250 PyObject* storage_V471;
00251 PyObject* storage_V473;
00252 PyObject* storage_V475;
00253 PyObject* storage_V477;
00254 PyObject* storage_V479;
00255 PyObject* storage_V481;
00256 PyObject* storage_V483;
00257 PyObject* storage_V485;
00258 PyObject* storage_V487;
00259 PyObject* storage_V489;
00260 PyObject* storage_V491;
00261 PyObject* storage_V493;
00262 PyObject* storage_V495;
00263 PyObject* storage_V497;
00264 PyObject* storage_V499;
00265 PyObject* storage_V501;
00266 PyObject* storage_V503;
00267 PyObject* storage_V505;
00268 PyObject* storage_V507;
00269 PyObject* storage_V509;
00270 PyObject* storage_V511;
00271 PyObject* storage_V513;
00272 PyObject* storage_V515;
00273 PyObject* storage_V517;
00274 PyObject* storage_V519;
00275 PyObject* storage_V521;
00276 PyObject* storage_V523;
00277 PyObject* storage_V525;
00278 PyObject* storage_V527;
00279 PyObject* storage_V529;
00280 PyObject* storage_V531;
00281 PyObject* storage_V533;
00282 PyObject* storage_V535;
00283 PyObject* storage_V537;
00284 PyObject* storage_V539;
00285 PyObject* storage_V541;
00286 PyObject* storage_V543;
00287 PyObject* storage_V545;
00288 PyObject* storage_V547;
00289 PyObject* storage_V549;
00290 PyObject* storage_V551;
00291 PyObject* storage_V553;
00292 PyObject* storage_V555;
00293 PyObject* storage_V557;
00294 PyObject* storage_V559;
00295 PyObject* storage_V561;
00296 PyObject* storage_V563;
00297 PyObject* storage_V565;
00298 PyObject* storage_V567;
00299 PyObject* storage_V569;
00300 PyObject* storage_V571;
00301 PyObject* storage_V573;
00302 PyObject* storage_V575;
00303 PyObject* storage_V577;
00304 PyObject* storage_V579;
00305 PyObject* storage_V581;
00306 PyObject* storage_V583;
00307 PyObject* storage_V585;
00308 PyObject* storage_V587;
00309 PyObject* storage_V589;
00310 PyObject* storage_V591;
00311 PyObject* storage_V593;
00312 PyObject* storage_V595;
00313 PyObject* storage_V597;
00314 PyObject* storage_V599;
00315 PyObject* storage_V601;
00316 PyObject* storage_V603;
00317 PyObject* storage_V1;
00318
00319
00320 __struct_compiled_op_m60e56977ddfb69ae27ec355d8781d656() {
00321 // This is only somewhat safe because we:
00322 // 1) Are not a virtual class
00323 // 2) Do not use any virtual classes in the members
00324 // 3) Deal with mostly POD and pointers
00325
00326 // If this changes, we would have to revise this, but for
00327 // now I am tired of chasing segfaults because
00328 // initialization code had an error and some pointer has
00329 // a junk value.
00330 memset(this, 0, sizeof(*this));
00331 }
00332 ~__struct_compiled_op_m60e56977ddfb69ae27ec355d8781d656(void) {
00333 cleanup();
00334 }
00335
00336 int init(PyObject* __ERROR, PyObject* storage_V3, PyObject* storage_V5, PyObject* storage_V7, PyObject* storage_V9, PyObject* storage_V11, PyObject* storage_V13, PyObject* storage_V15, PyObject* storage_V17, PyObject* storage_V19, PyObject* storage_V21, PyObject* storage_V23, PyObject* storage_V25, PyObject* storage_V27, PyObject* storage_V29, PyObject* storage_V31, PyObject* storage_V33, PyObject* storage_V35, PyObject* storage_V37, PyObject* storage_V39, PyObject* storage_V41, PyObject* storage_V43, PyObject* storage_V45, PyObject* storage_V47, PyObject* storage_V49, PyObject* storage_V51, PyObject* storage_V53, PyObject* storage_V55, PyObject* storage_V57, PyObject* storage_V59, PyObject* storage_V61, PyObject* storage_V63, PyObject* storage_V65, PyObject* storage_V67, PyObject* storage_V69, PyObject* storage_V71, PyObject* storage_V73, PyObject* storage_V75, PyObject* storage_V77, PyObject* storage_V79, PyObject* storage_V81, PyObject* storage_V83, PyObject* storage_V85, PyObject* storage_V87, PyObject* storage_V89, PyObject* storage_V91, PyObject* storage_V93, PyObject* storage_V95, PyObject* storage_V97, PyObject* storage_V99, PyObject* storage_V101, PyObject* storage_V103, PyObject* storage_V105, PyObject* storage_V107, PyObject* storage_V109, PyObject* storage_V111, PyObject* storage_V113, PyObject* storage_V115, PyObject* storage_V117, PyObject* storage_V119, PyObject* storage_V121, PyObject* storage_V123, PyObject* storage_V125, PyObject* storage_V127, PyObject* storage_V129, PyObject* storage_V131, PyObject* storage_V133, PyObject* storage_V135, PyObject* storage_V137, PyObject* storage_V139, PyObject* storage_V141, PyObject* storage_V143, PyObject* storage_V145, PyObject* storage_V147, PyObject* storage_V149, PyObject* storage_V151, PyObject* storage_V153, PyObject* storage_V155, PyObject* storage_V157, PyObject* storage_V159, PyObject* storage_V161, PyObject* storage_V163, PyObject* storage_V165, PyObject* storage_V167, PyObject* storage_V169, PyObject* storage_V171, PyObject* storage_V173, PyObject* storage_V175, PyObject* storage_V177, PyObject* storage_V179, PyObject* storage_V181, PyObject* storage_V183, PyObject* storage_V185, PyObject* storage_V187, PyObject* storage_V189, PyObject* storage_V191, PyObject* storage_V193, PyObject* storage_V195, PyObject* storage_V197, PyObject* storage_V199, PyObject* storage_V201, PyObject* storage_V203, PyObject* storage_V205, PyObject* storage_V207, PyObject* storage_V209, PyObject* storage_V211, PyObject* storage_V213, PyObject* storage_V215, PyObject* storage_V217, PyObject* storage_V219, PyObject* storage_V221, PyObject* storage_V223, PyObject* storage_V225, PyObject* storage_V227, PyObject* storage_V229, PyObject* storage_V231, PyObject* storage_V233, PyObject* storage_V235, PyObject* storage_V237, PyObject* storage_V239, PyObject* storage_V241, PyObject* storage_V243, PyObject* storage_V245, PyObject* storage_V247, PyObject* storage_V249, PyObject* storage_V251, PyObject* storage_V253, PyObject* storage_V255, PyObject* storage_V257, PyObject* storage_V259, PyObject* storage_V261, PyObject* storage_V263, PyObject* storage_V265, PyObject* storage_V267, PyObject* storage_V269, PyObject* storage_V271, PyObject* storage_V273, PyObject* storage_V275, PyObject* storage_V277, PyObject* storage_V279, PyObject* storage_V281, PyObject* storage_V283, PyObject* storage_V285, PyObject* storage_V287, PyObject* storage_V289, PyObject* storage_V291, PyObject* storage_V293, PyObject* storage_V295, PyObject* storage_V297, PyObject* storage_V299, PyObject* storage_V301, PyObject* storage_V303, PyObject* storage_V305, PyObject* storage_V307, PyObject* storage_V309, PyObject* storage_V311, PyObject* storage_V313, PyObject* storage_V315, PyObject* storage_V317, PyObject* storage_V319, PyObject* storage_V321, PyObject* storage_V323, PyObject* storage_V325, PyObject* storage_V327, PyObject* storage_V329, PyObject* storage_V331, PyObject* storage_V333, PyObject* storage_V335, PyObject* storage_V337, PyObject* storage_V339, PyObject* storage_V341, PyObject* storage_V343, PyObject* storage_V345, PyObject* storage_V347, PyObject* storage_V349, PyObject* storage_V351, PyObject* storage_V353, PyObject* storage_V355, PyObject* storage_V357, PyObject* storage_V359, PyObject* storage_V361, PyObject* storage_V363, PyObject* storage_V365, PyObject* storage_V367, PyObject* storage_V369, PyObject* storage_V371, PyObject* storage_V373, PyObject* storage_V375, PyObject* storage_V377, PyObject* storage_V379, PyObject* storage_V381, PyObject* storage_V383, PyObject* storage_V385, PyObject* storage_V387, PyObject* storage_V389, PyObject* storage_V391, PyObject* storage_V393, PyObject* storage_V395, PyObject* storage_V397, PyObject* storage_V399, PyObject* storage_V401, PyObject* storage_V403, PyObject* storage_V405, PyObject* storage_V407, PyObject* storage_V409, PyObject* storage_V411, PyObject* storage_V413, PyObject* storage_V415, PyObject* storage_V417, PyObject* storage_V419, PyObject* storage_V421, PyObject* storage_V423, PyObject* storage_V425, PyObject* storage_V427, PyObject* storage_V429, PyObject* storage_V431, PyObject* storage_V433, PyObject* storage_V435, PyObject* storage_V437, PyObject* storage_V439, PyObject* storage_V441, PyObject* storage_V443, PyObject* storage_V445, PyObject* storage_V447, PyObject* storage_V449, PyObject* storage_V451, PyObject* storage_V453, PyObject* storage_V455, PyObject* storage_V457, PyObject* storage_V459, PyObject* storage_V461, PyObject* storage_V463, PyObject* storage_V465, PyObject* storage_V467, PyObject* storage_V469, PyObject* storage_V471, PyObject* storage_V473, PyObject* storage_V475, PyObject* storage_V477, PyObject* storage_V479, PyObject* storage_V481, PyObject* storage_V483, PyObject* storage_V485, PyObject* storage_V487, PyObject* storage_V489, PyObject* storage_V491, PyObject* storage_V493, PyObject* storage_V495, PyObject* storage_V497, PyObject* storage_V499, PyObject* storage_V501, PyObject* storage_V503, PyObject* storage_V505, PyObject* storage_V507, PyObject* storage_V509, PyObject* storage_V511, PyObject* storage_V513, PyObject* storage_V515, PyObject* storage_V517, PyObject* storage_V519, PyObject* storage_V521, PyObject* storage_V523, PyObject* storage_V525, PyObject* storage_V527, PyObject* storage_V529, PyObject* storage_V531, PyObject* storage_V533, PyObject* storage_V535, PyObject* storage_V537, PyObject* storage_V539, PyObject* storage_V541, PyObject* storage_V543, PyObject* storage_V545, PyObject* storage_V547, PyObject* storage_V549, PyObject* storage_V551, PyObject* storage_V553, PyObject* storage_V555, PyObject* storage_V557, PyObject* storage_V559, PyObject* storage_V561, PyObject* storage_V563, PyObject* storage_V565, PyObject* storage_V567, PyObject* storage_V569, PyObject* storage_V571, PyObject* storage_V573, PyObject* storage_V575, PyObject* storage_V577, PyObject* storage_V579, PyObject* storage_V581, PyObject* storage_V583, PyObject* storage_V585, PyObject* storage_V587, PyObject* storage_V589, PyObject* storage_V591, PyObject* storage_V593, PyObject* storage_V595, PyObject* storage_V597, PyObject* storage_V599, PyObject* storage_V601, PyObject* storage_V603, PyObject* storage_V1) {
00337 Py_XINCREF(storage_V3);
00338 Py_XINCREF(storage_V5);
00339 Py_XINCREF(storage_V7);
00340 Py_XINCREF(storage_V9);
00341 Py_XINCREF(storage_V11);
00342 Py_XINCREF(storage_V13);
00343 Py_XINCREF(storage_V15);
00344 Py_XINCREF(storage_V17);
00345 Py_XINCREF(storage_V19);
00346 Py_XINCREF(storage_V21);
00347 Py_XINCREF(storage_V23);
00348 Py_XINCREF(storage_V25);
00349 Py_XINCREF(storage_V27);
00350 Py_XINCREF(storage_V29);
00351 Py_XINCREF(storage_V31);
00352 Py_XINCREF(storage_V33);
00353 Py_XINCREF(storage_V35);
00354 Py_XINCREF(storage_V37);
00355 Py_XINCREF(storage_V39);
00356 Py_XINCREF(storage_V41);
00357 Py_XINCREF(storage_V43);
00358 Py_XINCREF(storage_V45);
00359 Py_XINCREF(storage_V47);
00360 Py_XINCREF(storage_V49);
00361 Py_XINCREF(storage_V51);
00362 Py_XINCREF(storage_V53);
00363 Py_XINCREF(storage_V55);
00364 Py_XINCREF(storage_V57);
00365 Py_XINCREF(storage_V59);
00366 Py_XINCREF(storage_V61);
00367 Py_XINCREF(storage_V63);
00368 Py_XINCREF(storage_V65);
00369 Py_XINCREF(storage_V67);
00370 Py_XINCREF(storage_V69);
00371 Py_XINCREF(storage_V71);
00372 Py_XINCREF(storage_V73);
00373 Py_XINCREF(storage_V75);
00374 Py_XINCREF(storage_V77);
00375 Py_XINCREF(storage_V79);
00376 Py_XINCREF(storage_V81);
00377 Py_XINCREF(storage_V83);
00378 Py_XINCREF(storage_V85);
00379 Py_XINCREF(storage_V87);
00380 Py_XINCREF(storage_V89);
00381 Py_XINCREF(storage_V91);
00382 Py_XINCREF(storage_V93);
00383 Py_XINCREF(storage_V95);
00384 Py_XINCREF(storage_V97);
00385 Py_XINCREF(storage_V99);
00386 Py_XINCREF(storage_V101);
00387 Py_XINCREF(storage_V103);
00388 Py_XINCREF(storage_V105);
00389 Py_XINCREF(storage_V107);
00390 Py_XINCREF(storage_V109);
00391 Py_XINCREF(storage_V111);
00392 Py_XINCREF(storage_V113);
00393 Py_XINCREF(storage_V115);
00394 Py_XINCREF(storage_V117);
00395 Py_XINCREF(storage_V119);
00396 Py_XINCREF(storage_V121);
00397 Py_XINCREF(storage_V123);
00398 Py_XINCREF(storage_V125);
00399 Py_XINCREF(storage_V127);
00400 Py_XINCREF(storage_V129);
00401 Py_XINCREF(storage_V131);
00402 Py_XINCREF(storage_V133);
00403 Py_XINCREF(storage_V135);
00404 Py_XINCREF(storage_V137);
00405 Py_XINCREF(storage_V139);
00406 Py_XINCREF(storage_V141);
00407 Py_XINCREF(storage_V143);
00408 Py_XINCREF(storage_V145);
00409 Py_XINCREF(storage_V147);
00410 Py_XINCREF(storage_V149);
00411 Py_XINCREF(storage_V151);
00412 Py_XINCREF(storage_V153);
00413 Py_XINCREF(storage_V155);
00414 Py_XINCREF(storage_V157);
00415 Py_XINCREF(storage_V159);
00416 Py_XINCREF(storage_V161);
00417 Py_XINCREF(storage_V163);
00418 Py_XINCREF(storage_V165);
00419 Py_XINCREF(storage_V167);
00420 Py_XINCREF(storage_V169);
00421 Py_XINCREF(storage_V171);
00422 Py_XINCREF(storage_V173);
00423 Py_XINCREF(storage_V175);
00424 Py_XINCREF(storage_V177);
00425 Py_XINCREF(storage_V179);
00426 Py_XINCREF(storage_V181);
00427 Py_XINCREF(storage_V183);
00428 Py_XINCREF(storage_V185);
00429 Py_XINCREF(storage_V187);
00430 Py_XINCREF(storage_V189);
00431 Py_XINCREF(storage_V191);
00432 Py_XINCREF(storage_V193);
00433 Py_XINCREF(storage_V195);
00434 Py_XINCREF(storage_V197);
00435 Py_XINCREF(storage_V199);
00436 Py_XINCREF(storage_V201);
00437 Py_XINCREF(storage_V203);
00438 Py_XINCREF(storage_V205);
00439 Py_XINCREF(storage_V207);
00440 Py_XINCREF(storage_V209);
00441 Py_XINCREF(storage_V211);
00442 Py_XINCREF(storage_V213);
00443 Py_XINCREF(storage_V215);
00444 Py_XINCREF(storage_V217);
00445 Py_XINCREF(storage_V219);
00446 Py_XINCREF(storage_V221);
00447 Py_XINCREF(storage_V223);
00448 Py_XINCREF(storage_V225);
00449 Py_XINCREF(storage_V227);
00450 Py_XINCREF(storage_V229);
00451 Py_XINCREF(storage_V231);
00452 Py_XINCREF(storage_V233);
00453 Py_XINCREF(storage_V235);
00454 Py_XINCREF(storage_V237);
00455 Py_XINCREF(storage_V239);
00456 Py_XINCREF(storage_V241);
00457 Py_XINCREF(storage_V243);
00458 Py_XINCREF(storage_V245);
00459 Py_XINCREF(storage_V247);
00460 Py_XINCREF(storage_V249);
00461 Py_XINCREF(storage_V251);
00462 Py_XINCREF(storage_V253);
00463 Py_XINCREF(storage_V255);
00464 Py_XINCREF(storage_V257);
00465 Py_XINCREF(storage_V259);
00466 Py_XINCREF(storage_V261);
00467 Py_XINCREF(storage_V263);
00468 Py_XINCREF(storage_V265);
00469 Py_XINCREF(storage_V267);
00470 Py_XINCREF(storage_V269);
00471 Py_XINCREF(storage_V271);
00472 Py_XINCREF(storage_V273);
00473 Py_XINCREF(storage_V275);
00474 Py_XINCREF(storage_V277);
00475 Py_XINCREF(storage_V279);
00476 Py_XINCREF(storage_V281);
00477 Py_XINCREF(storage_V283);
00478 Py_XINCREF(storage_V285);
00479 Py_XINCREF(storage_V287);
00480 Py_XINCREF(storage_V289);
00481 Py_XINCREF(storage_V291);
00482 Py_XINCREF(storage_V293);
00483 Py_XINCREF(storage_V295);
00484 Py_XINCREF(storage_V297);
00485 Py_XINCREF(storage_V299);
00486 Py_XINCREF(storage_V301);
00487 Py_XINCREF(storage_V303);
00488 Py_XINCREF(storage_V305);
00489 Py_XINCREF(storage_V307);
00490 Py_XINCREF(storage_V309);
00491 Py_XINCREF(storage_V311);
00492 Py_XINCREF(storage_V313);
00493 Py_XINCREF(storage_V315);
00494 Py_XINCREF(storage_V317);
00495 Py_XINCREF(storage_V319);
00496 Py_XINCREF(storage_V321);
00497 Py_XINCREF(storage_V323);
00498 Py_XINCREF(storage_V325);
00499 Py_XINCREF(storage_V327);
00500 Py_XINCREF(storage_V329);
00501 Py_XINCREF(storage_V331);
00502 Py_XINCREF(storage_V333);
00503 Py_XINCREF(storage_V335);
00504 Py_XINCREF(storage_V337);
00505 Py_XINCREF(storage_V339);
00506 Py_XINCREF(storage_V341);
00507 Py_XINCREF(storage_V343);
00508 Py_XINCREF(storage_V345);
00509 Py_XINCREF(storage_V347);
00510 Py_XINCREF(storage_V349);
00511 Py_XINCREF(storage_V351);
00512 Py_XINCREF(storage_V353);
00513 Py_XINCREF(storage_V355);
00514 Py_XINCREF(storage_V357);
00515 Py_XINCREF(storage_V359);
00516 Py_XINCREF(storage_V361);
00517 Py_XINCREF(storage_V363);
00518 Py_XINCREF(storage_V365);
00519 Py_XINCREF(storage_V367);
00520 Py_XINCREF(storage_V369);
00521 Py_XINCREF(storage_V371);
00522 Py_XINCREF(storage_V373);
00523 Py_XINCREF(storage_V375);
00524 Py_XINCREF(storage_V377);
00525 Py_XINCREF(storage_V379);
00526 Py_XINCREF(storage_V381);
00527 Py_XINCREF(storage_V383);
00528 Py_XINCREF(storage_V385);
00529 Py_XINCREF(storage_V387);
00530 Py_XINCREF(storage_V389);
00531 Py_XINCREF(storage_V391);
00532 Py_XINCREF(storage_V393);
00533 Py_XINCREF(storage_V395);
00534 Py_XINCREF(storage_V397);
00535 Py_XINCREF(storage_V399);
00536 Py_XINCREF(storage_V401);
00537 Py_XINCREF(storage_V403);
00538 Py_XINCREF(storage_V405);
00539 Py_XINCREF(storage_V407);
00540 Py_XINCREF(storage_V409);
00541 Py_XINCREF(storage_V411);
00542 Py_XINCREF(storage_V413);
00543 Py_XINCREF(storage_V415);
00544 Py_XINCREF(storage_V417);
00545 Py_XINCREF(storage_V419);
00546 Py_XINCREF(storage_V421);
00547 Py_XINCREF(storage_V423);
00548 Py_XINCREF(storage_V425);
00549 Py_XINCREF(storage_V427);
00550 Py_XINCREF(storage_V429);
00551 Py_XINCREF(storage_V431);
00552 Py_XINCREF(storage_V433);
00553 Py_XINCREF(storage_V435);
00554 Py_XINCREF(storage_V437);
00555 Py_XINCREF(storage_V439);
00556 Py_XINCREF(storage_V441);
00557 Py_XINCREF(storage_V443);
00558 Py_XINCREF(storage_V445);
00559 Py_XINCREF(storage_V447);
00560 Py_XINCREF(storage_V449);
00561 Py_XINCREF(storage_V451);
00562 Py_XINCREF(storage_V453);
00563 Py_XINCREF(storage_V455);
00564 Py_XINCREF(storage_V457);
00565 Py_XINCREF(storage_V459);
00566 Py_XINCREF(storage_V461);
00567 Py_XINCREF(storage_V463);
00568 Py_XINCREF(storage_V465);
00569 Py_XINCREF(storage_V467);
00570 Py_XINCREF(storage_V469);
00571 Py_XINCREF(storage_V471);
00572 Py_XINCREF(storage_V473);
00573 Py_XINCREF(storage_V475);
00574 Py_XINCREF(storage_V477);
00575 Py_XINCREF(storage_V479);
00576 Py_XINCREF(storage_V481);
00577 Py_XINCREF(storage_V483);
00578 Py_XINCREF(storage_V485);
00579 Py_XINCREF(storage_V487);
00580 Py_XINCREF(storage_V489);
00581 Py_XINCREF(storage_V491);
00582 Py_XINCREF(storage_V493);
00583 Py_XINCREF(storage_V495);
00584 Py_XINCREF(storage_V497);
00585 Py_XINCREF(storage_V499);
00586 Py_XINCREF(storage_V501);
00587 Py_XINCREF(storage_V503);
00588 Py_XINCREF(storage_V505);
00589 Py_XINCREF(storage_V507);
00590 Py_XINCREF(storage_V509);
00591 Py_XINCREF(storage_V511);
00592 Py_XINCREF(storage_V513);
00593 Py_XINCREF(storage_V515);
00594 Py_XINCREF(storage_V517);
00595 Py_XINCREF(storage_V519);
00596 Py_XINCREF(storage_V521);
00597 Py_XINCREF(storage_V523);
00598 Py_XINCREF(storage_V525);
00599 Py_XINCREF(storage_V527);
00600 Py_XINCREF(storage_V529);
00601 Py_XINCREF(storage_V531);
00602 Py_XINCREF(storage_V533);
00603 Py_XINCREF(storage_V535);
00604 Py_XINCREF(storage_V537);
00605 Py_XINCREF(storage_V539);
00606 Py_XINCREF(storage_V541);
00607 Py_XINCREF(storage_V543);
00608 Py_XINCREF(storage_V545);
00609 Py_XINCREF(storage_V547);
00610 Py_XINCREF(storage_V549);
00611 Py_XINCREF(storage_V551);
00612 Py_XINCREF(storage_V553);
00613 Py_XINCREF(storage_V555);
00614 Py_XINCREF(storage_V557);
00615 Py_XINCREF(storage_V559);
00616 Py_XINCREF(storage_V561);
00617 Py_XINCREF(storage_V563);
00618 Py_XINCREF(storage_V565);
00619 Py_XINCREF(storage_V567);
00620 Py_XINCREF(storage_V569);
00621 Py_XINCREF(storage_V571);
00622 Py_XINCREF(storage_V573);
00623 Py_XINCREF(storage_V575);
00624 Py_XINCREF(storage_V577);
00625 Py_XINCREF(storage_V579);
00626 Py_XINCREF(storage_V581);
00627 Py_XINCREF(storage_V583);
00628 Py_XINCREF(storage_V585);
00629 Py_XINCREF(storage_V587);
00630 Py_XINCREF(storage_V589);
00631 Py_XINCREF(storage_V591);
00632 Py_XINCREF(storage_V593);
00633 Py_XINCREF(storage_V595);
00634 Py_XINCREF(storage_V597);
00635 Py_XINCREF(storage_V599);
00636 Py_XINCREF(storage_V601);
00637 Py_XINCREF(storage_V603);
00638 Py_XINCREF(storage_V1);
00639 this->storage_V3 = storage_V3;
00640 this->storage_V5 = storage_V5;
00641 this->storage_V7 = storage_V7;
00642 this->storage_V9 = storage_V9;
00643 this->storage_V11 = storage_V11;
00644 this->storage_V13 = storage_V13;
00645 this->storage_V15 = storage_V15;
00646 this->storage_V17 = storage_V17;
00647 this->storage_V19 = storage_V19;
00648 this->storage_V21 = storage_V21;
00649 this->storage_V23 = storage_V23;
00650 this->storage_V25 = storage_V25;
00651 this->storage_V27 = storage_V27;
00652 this->storage_V29 = storage_V29;
00653 this->storage_V31 = storage_V31;
00654 this->storage_V33 = storage_V33;
00655 this->storage_V35 = storage_V35;
00656 this->storage_V37 = storage_V37;
00657 this->storage_V39 = storage_V39;
00658 this->storage_V41 = storage_V41;
00659 this->storage_V43 = storage_V43;
00660 this->storage_V45 = storage_V45;
00661 this->storage_V47 = storage_V47;
00662 this->storage_V49 = storage_V49;
00663 this->storage_V51 = storage_V51;
00664 this->storage_V53 = storage_V53;
00665 this->storage_V55 = storage_V55;
00666 this->storage_V57 = storage_V57;
00667 this->storage_V59 = storage_V59;
00668 this->storage_V61 = storage_V61;
00669 this->storage_V63 = storage_V63;
00670 this->storage_V65 = storage_V65;
00671 this->storage_V67 = storage_V67;
00672 this->storage_V69 = storage_V69;
00673 this->storage_V71 = storage_V71;
00674 this->storage_V73 = storage_V73;
00675 this->storage_V75 = storage_V75;
00676 this->storage_V77 = storage_V77;
00677 this->storage_V79 = storage_V79;
00678 this->storage_V81 = storage_V81;
00679 this->storage_V83 = storage_V83;
00680 this->storage_V85 = storage_V85;
00681 this->storage_V87 = storage_V87;
00682 this->storage_V89 = storage_V89;
00683 this->storage_V91 = storage_V91;
00684 this->storage_V93 = storage_V93;
00685 this->storage_V95 = storage_V95;
00686 this->storage_V97 = storage_V97;
00687 this->storage_V99 = storage_V99;
00688 this->storage_V101 = storage_V101;
00689 this->storage_V103 = storage_V103;
00690 this->storage_V105 = storage_V105;
00691 this->storage_V107 = storage_V107;
00692 this->storage_V109 = storage_V109;
00693 this->storage_V111 = storage_V111;
00694 this->storage_V113 = storage_V113;
00695 this->storage_V115 = storage_V115;
00696 this->storage_V117 = storage_V117;
00697 this->storage_V119 = storage_V119;
00698 this->storage_V121 = storage_V121;
00699 this->storage_V123 = storage_V123;
00700 this->storage_V125 = storage_V125;
00701 this->storage_V127 = storage_V127;
00702 this->storage_V129 = storage_V129;
00703 this->storage_V131 = storage_V131;
00704 this->storage_V133 = storage_V133;
00705 this->storage_V135 = storage_V135;
00706 this->storage_V137 = storage_V137;
00707 this->storage_V139 = storage_V139;
00708 this->storage_V141 = storage_V141;
00709 this->storage_V143 = storage_V143;
00710 this->storage_V145 = storage_V145;
00711 this->storage_V147 = storage_V147;
00712 this->storage_V149 = storage_V149;
00713 this->storage_V151 = storage_V151;
00714 this->storage_V153 = storage_V153;
00715 this->storage_V155 = storage_V155;
00716 this->storage_V157 = storage_V157;
00717 this->storage_V159 = storage_V159;
00718 this->storage_V161 = storage_V161;
00719 this->storage_V163 = storage_V163;
00720 this->storage_V165 = storage_V165;
00721 this->storage_V167 = storage_V167;
00722 this->storage_V169 = storage_V169;
00723 this->storage_V171 = storage_V171;
00724 this->storage_V173 = storage_V173;
00725 this->storage_V175 = storage_V175;
00726 this->storage_V177 = storage_V177;
00727 this->storage_V179 = storage_V179;
00728 this->storage_V181 = storage_V181;
00729 this->storage_V183 = storage_V183;
00730 this->storage_V185 = storage_V185;
00731 this->storage_V187 = storage_V187;
00732 this->storage_V189 = storage_V189;
00733 this->storage_V191 = storage_V191;
00734 this->storage_V193 = storage_V193;
00735 this->storage_V195 = storage_V195;
00736 this->storage_V197 = storage_V197;
00737 this->storage_V199 = storage_V199;
00738 this->storage_V201 = storage_V201;
00739 this->storage_V203 = storage_V203;
00740 this->storage_V205 = storage_V205;
00741 this->storage_V207 = storage_V207;
00742 this->storage_V209 = storage_V209;
00743 this->storage_V211 = storage_V211;
00744 this->storage_V213 = storage_V213;
00745 this->storage_V215 = storage_V215;
00746 this->storage_V217 = storage_V217;
00747 this->storage_V219 = storage_V219;
00748 this->storage_V221 = storage_V221;
00749 this->storage_V223 = storage_V223;
00750 this->storage_V225 = storage_V225;
00751 this->storage_V227 = storage_V227;
00752 this->storage_V229 = storage_V229;
00753 this->storage_V231 = storage_V231;
00754 this->storage_V233 = storage_V233;
00755 this->storage_V235 = storage_V235;
00756 this->storage_V237 = storage_V237;
00757 this->storage_V239 = storage_V239;
00758 this->storage_V241 = storage_V241;
00759 this->storage_V243 = storage_V243;
00760 this->storage_V245 = storage_V245;
00761 this->storage_V247 = storage_V247;
00762 this->storage_V249 = storage_V249;
00763 this->storage_V251 = storage_V251;
00764 this->storage_V253 = storage_V253;
00765 this->storage_V255 = storage_V255;
00766 this->storage_V257 = storage_V257;
00767 this->storage_V259 = storage_V259;
00768 this->storage_V261 = storage_V261;
00769 this->storage_V263 = storage_V263;
00770 this->storage_V265 = storage_V265;
00771 this->storage_V267 = storage_V267;
00772 this->storage_V269 = storage_V269;
00773 this->storage_V271 = storage_V271;
00774 this->storage_V273 = storage_V273;
00775 this->storage_V275 = storage_V275;
00776 this->storage_V277 = storage_V277;
00777 this->storage_V279 = storage_V279;
00778 this->storage_V281 = storage_V281;
00779 this->storage_V283 = storage_V283;
00780 this->storage_V285 = storage_V285;
00781 this->storage_V287 = storage_V287;
00782 this->storage_V289 = storage_V289;
00783 this->storage_V291 = storage_V291;
00784 this->storage_V293 = storage_V293;
00785 this->storage_V295 = storage_V295;
00786 this->storage_V297 = storage_V297;
00787 this->storage_V299 = storage_V299;
00788 this->storage_V301 = storage_V301;
00789 this->storage_V303 = storage_V303;
00790 this->storage_V305 = storage_V305;
00791 this->storage_V307 = storage_V307;
00792 this->storage_V309 = storage_V309;
00793 this->storage_V311 = storage_V311;
00794 this->storage_V313 = storage_V313;
00795 this->storage_V315 = storage_V315;
00796 this->storage_V317 = storage_V317;
00797 this->storage_V319 = storage_V319;
00798 this->storage_V321 = storage_V321;
00799 this->storage_V323 = storage_V323;
00800 this->storage_V325 = storage_V325;
00801 this->storage_V327 = storage_V327;
00802 this->storage_V329 = storage_V329;
00803 this->storage_V331 = storage_V331;
00804 this->storage_V333 = storage_V333;
00805 this->storage_V335 = storage_V335;
00806 this->storage_V337 = storage_V337;
00807 this->storage_V339 = storage_V339;
00808 this->storage_V341 = storage_V341;
00809 this->storage_V343 = storage_V343;
00810 this->storage_V345 = storage_V345;
00811 this->storage_V347 = storage_V347;
00812 this->storage_V349 = storage_V349;
00813 this->storage_V351 = storage_V351;
00814 this->storage_V353 = storage_V353;
00815 this->storage_V355 = storage_V355;
00816 this->storage_V357 = storage_V357;
00817 this->storage_V359 = storage_V359;
00818 this->storage_V361 = storage_V361;
00819 this->storage_V363 = storage_V363;
00820 this->storage_V365 = storage_V365;
00821 this->storage_V367 = storage_V367;
00822 this->storage_V369 = storage_V369;
00823 this->storage_V371 = storage_V371;
00824 this->storage_V373 = storage_V373;
00825 this->storage_V375 = storage_V375;
00826 this->storage_V377 = storage_V377;
00827 this->storage_V379 = storage_V379;
00828 this->storage_V381 = storage_V381;
00829 this->storage_V383 = storage_V383;
00830 this->storage_V385 = storage_V385;
00831 this->storage_V387 = storage_V387;
00832 this->storage_V389 = storage_V389;
00833 this->storage_V391 = storage_V391;
00834 this->storage_V393 = storage_V393;
00835 this->storage_V395 = storage_V395;
00836 this->storage_V397 = storage_V397;
00837 this->storage_V399 = storage_V399;
00838 this->storage_V401 = storage_V401;
00839 this->storage_V403 = storage_V403;
00840 this->storage_V405 = storage_V405;
00841 this->storage_V407 = storage_V407;
00842 this->storage_V409 = storage_V409;
00843 this->storage_V411 = storage_V411;
00844 this->storage_V413 = storage_V413;
00845 this->storage_V415 = storage_V415;
00846 this->storage_V417 = storage_V417;
00847 this->storage_V419 = storage_V419;
00848 this->storage_V421 = storage_V421;
00849 this->storage_V423 = storage_V423;
00850 this->storage_V425 = storage_V425;
00851 this->storage_V427 = storage_V427;
00852 this->storage_V429 = storage_V429;
00853 this->storage_V431 = storage_V431;
00854 this->storage_V433 = storage_V433;
00855 this->storage_V435 = storage_V435;
00856 this->storage_V437 = storage_V437;
00857 this->storage_V439 = storage_V439;
00858 this->storage_V441 = storage_V441;
00859 this->storage_V443 = storage_V443;
00860 this->storage_V445 = storage_V445;
00861 this->storage_V447 = storage_V447;
00862 this->storage_V449 = storage_V449;
00863 this->storage_V451 = storage_V451;
00864 this->storage_V453 = storage_V453;
00865 this->storage_V455 = storage_V455;
00866 this->storage_V457 = storage_V457;
00867 this->storage_V459 = storage_V459;
00868 this->storage_V461 = storage_V461;
00869 this->storage_V463 = storage_V463;
00870 this->storage_V465 = storage_V465;
00871 this->storage_V467 = storage_V467;
00872 this->storage_V469 = storage_V469;
00873 this->storage_V471 = storage_V471;
00874 this->storage_V473 = storage_V473;
00875 this->storage_V475 = storage_V475;
00876 this->storage_V477 = storage_V477;
00877 this->storage_V479 = storage_V479;
00878 this->storage_V481 = storage_V481;
00879 this->storage_V483 = storage_V483;
00880 this->storage_V485 = storage_V485;
00881 this->storage_V487 = storage_V487;
00882 this->storage_V489 = storage_V489;
00883 this->storage_V491 = storage_V491;
00884 this->storage_V493 = storage_V493;
00885 this->storage_V495 = storage_V495;
00886 this->storage_V497 = storage_V497;
00887 this->storage_V499 = storage_V499;
00888 this->storage_V501 = storage_V501;
00889 this->storage_V503 = storage_V503;
00890 this->storage_V505 = storage_V505;
00891 this->storage_V507 = storage_V507;
00892 this->storage_V509 = storage_V509;
00893 this->storage_V511 = storage_V511;
00894 this->storage_V513 = storage_V513;
00895 this->storage_V515 = storage_V515;
00896 this->storage_V517 = storage_V517;
00897 this->storage_V519 = storage_V519;
00898 this->storage_V521 = storage_V521;
00899 this->storage_V523 = storage_V523;
00900 this->storage_V525 = storage_V525;
00901 this->storage_V527 = storage_V527;
00902 this->storage_V529 = storage_V529;
00903 this->storage_V531 = storage_V531;
00904 this->storage_V533 = storage_V533;
00905 this->storage_V535 = storage_V535;
00906 this->storage_V537 = storage_V537;
00907 this->storage_V539 = storage_V539;
00908 this->storage_V541 = storage_V541;
00909 this->storage_V543 = storage_V543;
00910 this->storage_V545 = storage_V545;
00911 this->storage_V547 = storage_V547;
00912 this->storage_V549 = storage_V549;
00913 this->storage_V551 = storage_V551;
00914 this->storage_V553 = storage_V553;
00915 this->storage_V555 = storage_V555;
00916 this->storage_V557 = storage_V557;
00917 this->storage_V559 = storage_V559;
00918 this->storage_V561 = storage_V561;
00919 this->storage_V563 = storage_V563;
00920 this->storage_V565 = storage_V565;
00921 this->storage_V567 = storage_V567;
00922 this->storage_V569 = storage_V569;
00923 this->storage_V571 = storage_V571;
00924 this->storage_V573 = storage_V573;
00925 this->storage_V575 = storage_V575;
00926 this->storage_V577 = storage_V577;
00927 this->storage_V579 = storage_V579;
00928 this->storage_V581 = storage_V581;
00929 this->storage_V583 = storage_V583;
00930 this->storage_V585 = storage_V585;
00931 this->storage_V587 = storage_V587;
00932 this->storage_V589 = storage_V589;
00933 this->storage_V591 = storage_V591;
00934 this->storage_V593 = storage_V593;
00935 this->storage_V595 = storage_V595;
00936 this->storage_V597 = storage_V597;
00937 this->storage_V599 = storage_V599;
00938 this->storage_V601 = storage_V601;
00939 this->storage_V603 = storage_V603;
00940 this->storage_V1 = storage_V1;
00941
00942
00943
00944
00945
00946
00947
00948
00949
00950
00951
00952
00953
00954
00955
00956
00957
00958
00959
00960
00961
00962
00963
00964
00965
00966
00967
00968
00969
00970
00971
00972
00973
00974
00975
00976
00977
00978
00979
00980
00981
00982
00983
00984
00985
00986
00987
00988
00989
00990
00991
00992
00993
00994
00995
00996
00997
00998
00999
01000
01001
01002
01003
01004
01005
01006
01007
01008
01009
01010
01011
01012
01013
01014
01015
01016
01017
01018
01019
01020
01021
01022
01023
01024
01025
01026
01027
01028
01029
01030
01031
01032
01033
01034
01035
01036
01037
01038
01039
01040
01041
01042
01043
01044
01045
01046
01047
01048
01049
01050
01051
01052
01053
01054
01055
01056
01057
01058
01059
01060
01061
01062
01063
01064
01065
01066
01067
01068
01069
01070
01071
01072
01073
01074
01075
01076
01077
01078
01079
01080
01081
01082
01083
01084
01085
01086
01087
01088
01089
01090
01091
01092
01093
01094
01095
01096
01097
01098
01099
01100
01101
01102
01103
01104
01105
01106
01107
01108
01109
01110
01111
01112
01113
01114
01115
01116
01117
01118
01119
01120
01121
01122
01123
01124
01125
01126
01127
01128
01129
01130
01131
01132
01133
01134
01135
01136
01137
01138
01139
01140
01141
01142
01143
01144
01145
01146
01147
01148
01149
01150
01151
01152
01153
01154
01155
01156
01157
01158
01159
01160
01161
01162
01163
01164
01165
01166
01167
01168
01169
01170
01171
01172
01173
01174
01175
01176
01177
01178
01179
01180
01181
01182
01183
01184
01185
01186
01187
01188
01189
01190
01191
01192
01193
01194
01195
01196
01197
01198
01199
01200
01201
01202
01203
01204
01205
01206
01207
01208
01209
01210
01211
01212
01213
01214
01215
01216
01217
01218
01219
01220
01221
01222
01223
01224
01225
01226
01227
01228
01229
01230
01231
01232
01233
01234
01235
01236
01237
01238
01239
01240
01241
01242
01243
01244
01245 this->__ERROR = __ERROR;
01246 return 0;
01247 }
01248 void cleanup(void) {
01249 __label_1:
01250
01251 double __DUMMY_1;
01252 __label_3:
01253
01254 double __DUMMY_3;
01255 __label_5:
01256
01257 double __DUMMY_5;
01258 __label_7:
01259
01260 double __DUMMY_7;
01261 __label_9:
01262
01263 double __DUMMY_9;
01264 __label_11:
01265
01266 double __DUMMY_11;
01267 __label_13:
01268
01269 double __DUMMY_13;
01270 __label_15:
01271
01272 double __DUMMY_15;
01273 __label_17:
01274
01275 double __DUMMY_17;
01276 __label_19:
01277
01278 double __DUMMY_19;
01279 __label_21:
01280
01281 double __DUMMY_21;
01282 __label_23:
01283
01284 double __DUMMY_23;
01285 __label_25:
01286
01287 double __DUMMY_25;
01288 __label_27:
01289
01290 double __DUMMY_27;
01291 __label_29:
01292
01293 double __DUMMY_29;
01294 __label_31:
01295
01296 double __DUMMY_31;
01297 __label_33:
01298
01299 double __DUMMY_33;
01300 __label_35:
01301
01302 double __DUMMY_35;
01303 __label_37:
01304
01305 double __DUMMY_37;
01306 __label_39:
01307
01308 double __DUMMY_39;
01309 __label_41:
01310
01311 double __DUMMY_41;
01312 __label_43:
01313
01314 double __DUMMY_43;
01315 __label_45:
01316
01317 double __DUMMY_45;
01318 __label_47:
01319
01320 double __DUMMY_47;
01321 __label_49:
01322
01323 double __DUMMY_49;
01324 __label_51:
01325
01326 double __DUMMY_51;
01327 __label_53:
01328
01329 double __DUMMY_53;
01330 __label_55:
01331
01332 double __DUMMY_55;
01333 __label_57:
01334
01335 double __DUMMY_57;
01336 __label_59:
01337
01338 double __DUMMY_59;
01339 __label_61:
01340
01341 double __DUMMY_61;
01342 __label_63:
01343
01344 double __DUMMY_63;
01345 __label_65:
01346
01347 double __DUMMY_65;
01348 __label_67:
01349
01350 double __DUMMY_67;
01351 __label_69:
01352
01353 double __DUMMY_69;
01354 __label_71:
01355
01356 double __DUMMY_71;
01357 __label_73:
01358
01359 double __DUMMY_73;
01360 __label_75:
01361
01362 double __DUMMY_75;
01363 __label_77:
01364
01365 double __DUMMY_77;
01366 __label_79:
01367
01368 double __DUMMY_79;
01369 __label_81:
01370
01371 double __DUMMY_81;
01372 __label_83:
01373
01374 double __DUMMY_83;
01375 __label_85:
01376
01377 double __DUMMY_85;
01378 __label_87:
01379
01380 double __DUMMY_87;
01381 __label_89:
01382
01383 double __DUMMY_89;
01384 __label_91:
01385
01386 double __DUMMY_91;
01387 __label_93:
01388
01389 double __DUMMY_93;
01390 __label_95:
01391
01392 double __DUMMY_95;
01393 __label_97:
01394
01395 double __DUMMY_97;
01396 __label_99:
01397
01398 double __DUMMY_99;
01399 __label_101:
01400
01401 double __DUMMY_101;
01402 __label_103:
01403
01404 double __DUMMY_103;
01405 __label_105:
01406
01407 double __DUMMY_105;
01408 __label_107:
01409
01410 double __DUMMY_107;
01411 __label_109:
01412
01413 double __DUMMY_109;
01414 __label_111:
01415
01416 double __DUMMY_111;
01417 __label_113:
01418
01419 double __DUMMY_113;
01420 __label_115:
01421
01422 double __DUMMY_115;
01423 __label_117:
01424
01425 double __DUMMY_117;
01426 __label_119:
01427
01428 double __DUMMY_119;
01429 __label_121:
01430
01431 double __DUMMY_121;
01432 __label_123:
01433
01434 double __DUMMY_123;
01435 __label_125:
01436
01437 double __DUMMY_125;
01438 __label_127:
01439
01440 double __DUMMY_127;
01441 __label_129:
01442
01443 double __DUMMY_129;
01444 __label_131:
01445
01446 double __DUMMY_131;
01447 __label_133:
01448
01449 double __DUMMY_133;
01450 __label_135:
01451
01452 double __DUMMY_135;
01453 __label_137:
01454
01455 double __DUMMY_137;
01456 __label_139:
01457
01458 double __DUMMY_139;
01459 __label_141:
01460
01461 double __DUMMY_141;
01462 __label_143:
01463
01464 double __DUMMY_143;
01465 __label_145:
01466
01467 double __DUMMY_145;
01468 __label_147:
01469
01470 double __DUMMY_147;
01471 __label_149:
01472
01473 double __DUMMY_149;
01474 __label_151:
01475
01476 double __DUMMY_151;
01477 __label_153:
01478
01479 double __DUMMY_153;
01480 __label_155:
01481
01482 double __DUMMY_155;
01483 __label_157:
01484
01485 double __DUMMY_157;
01486 __label_159:
01487
01488 double __DUMMY_159;
01489 __label_161:
01490
01491 double __DUMMY_161;
01492 __label_163:
01493
01494 double __DUMMY_163;
01495 __label_165:
01496
01497 double __DUMMY_165;
01498 __label_167:
01499
01500 double __DUMMY_167;
01501 __label_169:
01502
01503 double __DUMMY_169;
01504 __label_171:
01505
01506 double __DUMMY_171;
01507 __label_173:
01508
01509 double __DUMMY_173;
01510 __label_175:
01511
01512 double __DUMMY_175;
01513 __label_177:
01514
01515 double __DUMMY_177;
01516 __label_179:
01517
01518 double __DUMMY_179;
01519 __label_181:
01520
01521 double __DUMMY_181;
01522 __label_183:
01523
01524 double __DUMMY_183;
01525 __label_185:
01526
01527 double __DUMMY_185;
01528 __label_187:
01529
01530 double __DUMMY_187;
01531 __label_189:
01532
01533 double __DUMMY_189;
01534 __label_191:
01535
01536 double __DUMMY_191;
01537 __label_193:
01538
01539 double __DUMMY_193;
01540 __label_195:
01541
01542 double __DUMMY_195;
01543 __label_197:
01544
01545 double __DUMMY_197;
01546 __label_199:
01547
01548 double __DUMMY_199;
01549 __label_201:
01550
01551 double __DUMMY_201;
01552 __label_203:
01553
01554 double __DUMMY_203;
01555 __label_205:
01556
01557 double __DUMMY_205;
01558 __label_207:
01559
01560 double __DUMMY_207;
01561 __label_209:
01562
01563 double __DUMMY_209;
01564 __label_211:
01565
01566 double __DUMMY_211;
01567 __label_213:
01568
01569 double __DUMMY_213;
01570 __label_215:
01571
01572 double __DUMMY_215;
01573 __label_217:
01574
01575 double __DUMMY_217;
01576 __label_219:
01577
01578 double __DUMMY_219;
01579 __label_221:
01580
01581 double __DUMMY_221;
01582 __label_223:
01583
01584 double __DUMMY_223;
01585 __label_225:
01586
01587 double __DUMMY_225;
01588 __label_227:
01589
01590 double __DUMMY_227;
01591 __label_229:
01592
01593 double __DUMMY_229;
01594 __label_231:
01595
01596 double __DUMMY_231;
01597 __label_233:
01598
01599 double __DUMMY_233;
01600 __label_235:
01601
01602 double __DUMMY_235;
01603 __label_237:
01604
01605 double __DUMMY_237;
01606 __label_239:
01607
01608 double __DUMMY_239;
01609 __label_241:
01610
01611 double __DUMMY_241;
01612 __label_243:
01613
01614 double __DUMMY_243;
01615 __label_245:
01616
01617 double __DUMMY_245;
01618 __label_247:
01619
01620 double __DUMMY_247;
01621 __label_249:
01622
01623 double __DUMMY_249;
01624 __label_251:
01625
01626 double __DUMMY_251;
01627 __label_253:
01628
01629 double __DUMMY_253;
01630 __label_255:
01631
01632 double __DUMMY_255;
01633 __label_257:
01634
01635 double __DUMMY_257;
01636 __label_259:
01637
01638 double __DUMMY_259;
01639 __label_261:
01640
01641 double __DUMMY_261;
01642 __label_263:
01643
01644 double __DUMMY_263;
01645 __label_265:
01646
01647 double __DUMMY_265;
01648 __label_267:
01649
01650 double __DUMMY_267;
01651 __label_269:
01652
01653 double __DUMMY_269;
01654 __label_271:
01655
01656 double __DUMMY_271;
01657 __label_273:
01658
01659 double __DUMMY_273;
01660 __label_275:
01661
01662 double __DUMMY_275;
01663 __label_277:
01664
01665 double __DUMMY_277;
01666 __label_279:
01667
01668 double __DUMMY_279;
01669 __label_281:
01670
01671 double __DUMMY_281;
01672 __label_283:
01673
01674 double __DUMMY_283;
01675 __label_285:
01676
01677 double __DUMMY_285;
01678 __label_287:
01679
01680 double __DUMMY_287;
01681 __label_289:
01682
01683 double __DUMMY_289;
01684 __label_291:
01685
01686 double __DUMMY_291;
01687 __label_293:
01688
01689 double __DUMMY_293;
01690 __label_295:
01691
01692 double __DUMMY_295;
01693 __label_297:
01694
01695 double __DUMMY_297;
01696 __label_299:
01697
01698 double __DUMMY_299;
01699 __label_301:
01700
01701 double __DUMMY_301;
01702 __label_303:
01703
01704 double __DUMMY_303;
01705 __label_305:
01706
01707 double __DUMMY_305;
01708 __label_307:
01709
01710 double __DUMMY_307;
01711 __label_309:
01712
01713 double __DUMMY_309;
01714 __label_311:
01715
01716 double __DUMMY_311;
01717 __label_313:
01718
01719 double __DUMMY_313;
01720 __label_315:
01721
01722 double __DUMMY_315;
01723 __label_317:
01724
01725 double __DUMMY_317;
01726 __label_319:
01727
01728 double __DUMMY_319;
01729 __label_321:
01730
01731 double __DUMMY_321;
01732 __label_323:
01733
01734 double __DUMMY_323;
01735 __label_325:
01736
01737 double __DUMMY_325;
01738 __label_327:
01739
01740 double __DUMMY_327;
01741 __label_329:
01742
01743 double __DUMMY_329;
01744 __label_331:
01745
01746 double __DUMMY_331;
01747 __label_333:
01748
01749 double __DUMMY_333;
01750 __label_335:
01751
01752 double __DUMMY_335;
01753 __label_337:
01754
01755 double __DUMMY_337;
01756 __label_339:
01757
01758 double __DUMMY_339;
01759 __label_341:
01760
01761 double __DUMMY_341;
01762 __label_343:
01763
01764 double __DUMMY_343;
01765 __label_345:
01766
01767 double __DUMMY_345;
01768 __label_347:
01769
01770 double __DUMMY_347;
01771 __label_349:
01772
01773 double __DUMMY_349;
01774 __label_351:
01775
01776 double __DUMMY_351;
01777 __label_353:
01778
01779 double __DUMMY_353;
01780 __label_355:
01781
01782 double __DUMMY_355;
01783 __label_357:
01784
01785 double __DUMMY_357;
01786 __label_359:
01787
01788 double __DUMMY_359;
01789 __label_361:
01790
01791 double __DUMMY_361;
01792 __label_363:
01793
01794 double __DUMMY_363;
01795 __label_365:
01796
01797 double __DUMMY_365;
01798 __label_367:
01799
01800 double __DUMMY_367;
01801 __label_369:
01802
01803 double __DUMMY_369;
01804 __label_371:
01805
01806 double __DUMMY_371;
01807 __label_373:
01808
01809 double __DUMMY_373;
01810 __label_375:
01811
01812 double __DUMMY_375;
01813 __label_377:
01814
01815 double __DUMMY_377;
01816 __label_379:
01817
01818 double __DUMMY_379;
01819 __label_381:
01820
01821 double __DUMMY_381;
01822 __label_383:
01823
01824 double __DUMMY_383;
01825 __label_385:
01826
01827 double __DUMMY_385;
01828 __label_387:
01829
01830 double __DUMMY_387;
01831 __label_389:
01832
01833 double __DUMMY_389;
01834 __label_391:
01835
01836 double __DUMMY_391;
01837 __label_393:
01838
01839 double __DUMMY_393;
01840 __label_395:
01841
01842 double __DUMMY_395;
01843 __label_397:
01844
01845 double __DUMMY_397;
01846 __label_399:
01847
01848 double __DUMMY_399;
01849 __label_401:
01850
01851 double __DUMMY_401;
01852 __label_403:
01853
01854 double __DUMMY_403;
01855 __label_405:
01856
01857 double __DUMMY_405;
01858 __label_407:
01859
01860 double __DUMMY_407;
01861 __label_409:
01862
01863 double __DUMMY_409;
01864 __label_411:
01865
01866 double __DUMMY_411;
01867 __label_413:
01868
01869 double __DUMMY_413;
01870 __label_415:
01871
01872 double __DUMMY_415;
01873 __label_417:
01874
01875 double __DUMMY_417;
01876 __label_419:
01877
01878 double __DUMMY_419;
01879 __label_421:
01880
01881 double __DUMMY_421;
01882 __label_423:
01883
01884 double __DUMMY_423;
01885 __label_425:
01886
01887 double __DUMMY_425;
01888 __label_427:
01889
01890 double __DUMMY_427;
01891 __label_429:
01892
01893 double __DUMMY_429;
01894 __label_431:
01895
01896 double __DUMMY_431;
01897 __label_433:
01898
01899 double __DUMMY_433;
01900 __label_435:
01901
01902 double __DUMMY_435;
01903 __label_437:
01904
01905 double __DUMMY_437;
01906 __label_439:
01907
01908 double __DUMMY_439;
01909 __label_441:
01910
01911 double __DUMMY_441;
01912 __label_443:
01913
01914 double __DUMMY_443;
01915 __label_445:
01916
01917 double __DUMMY_445;
01918 __label_447:
01919
01920 double __DUMMY_447;
01921 __label_449:
01922
01923 double __DUMMY_449;
01924 __label_451:
01925
01926 double __DUMMY_451;
01927 __label_453:
01928
01929 double __DUMMY_453;
01930 __label_455:
01931
01932 double __DUMMY_455;
01933 __label_457:
01934
01935 double __DUMMY_457;
01936 __label_459:
01937
01938 double __DUMMY_459;
01939 __label_461:
01940
01941 double __DUMMY_461;
01942 __label_463:
01943
01944 double __DUMMY_463;
01945 __label_465:
01946
01947 double __DUMMY_465;
01948 __label_467:
01949
01950 double __DUMMY_467;
01951 __label_469:
01952
01953 double __DUMMY_469;
01954 __label_471:
01955
01956 double __DUMMY_471;
01957 __label_473:
01958
01959 double __DUMMY_473;
01960 __label_475:
01961
01962 double __DUMMY_475;
01963 __label_477:
01964
01965 double __DUMMY_477;
01966 __label_479:
01967
01968 double __DUMMY_479;
01969 __label_481:
01970
01971 double __DUMMY_481;
01972 __label_483:
01973
01974 double __DUMMY_483;
01975 __label_485:
01976
01977 double __DUMMY_485;
01978 __label_487:
01979
01980 double __DUMMY_487;
01981 __label_489:
01982
01983 double __DUMMY_489;
01984 __label_491:
01985
01986 double __DUMMY_491;
01987 __label_493:
01988
01989 double __DUMMY_493;
01990 __label_495:
01991
01992 double __DUMMY_495;
01993 __label_497:
01994
01995 double __DUMMY_497;
01996 __label_499:
01997
01998 double __DUMMY_499;
01999 __label_501:
02000
02001 double __DUMMY_501;
02002 __label_503:
02003
02004 double __DUMMY_503;
02005 __label_505:
02006
02007 double __DUMMY_505;
02008 __label_507:
02009
02010 double __DUMMY_507;
02011 __label_509:
02012
02013 double __DUMMY_509;
02014 __label_511:
02015
02016 double __DUMMY_511;
02017 __label_513:
02018
02019 double __DUMMY_513;
02020 __label_515:
02021
02022 double __DUMMY_515;
02023 __label_517:
02024
02025 double __DUMMY_517;
02026 __label_519:
02027
02028 double __DUMMY_519;
02029 __label_521:
02030
02031 double __DUMMY_521;
02032 __label_523:
02033
02034 double __DUMMY_523;
02035 __label_525:
02036
02037 double __DUMMY_525;
02038 __label_527:
02039
02040 double __DUMMY_527;
02041 __label_529:
02042
02043 double __DUMMY_529;
02044 __label_531:
02045
02046 double __DUMMY_531;
02047 __label_533:
02048
02049 double __DUMMY_533;
02050 __label_535:
02051
02052 double __DUMMY_535;
02053 __label_537:
02054
02055 double __DUMMY_537;
02056 __label_539:
02057
02058 double __DUMMY_539;
02059 __label_541:
02060
02061 double __DUMMY_541;
02062 __label_543:
02063
02064 double __DUMMY_543;
02065 __label_545:
02066
02067 double __DUMMY_545;
02068 __label_547:
02069
02070 double __DUMMY_547;
02071 __label_549:
02072
02073 double __DUMMY_549;
02074 __label_551:
02075
02076 double __DUMMY_551;
02077 __label_553:
02078
02079 double __DUMMY_553;
02080 __label_555:
02081
02082 double __DUMMY_555;
02083 __label_557:
02084
02085 double __DUMMY_557;
02086 __label_559:
02087
02088 double __DUMMY_559;
02089 __label_561:
02090
02091 double __DUMMY_561;
02092 __label_563:
02093
02094 double __DUMMY_563;
02095 __label_565:
02096
02097 double __DUMMY_565;
02098 __label_567:
02099
02100 double __DUMMY_567;
02101 __label_569:
02102
02103 double __DUMMY_569;
02104 __label_571:
02105
02106 double __DUMMY_571;
02107 __label_573:
02108
02109 double __DUMMY_573;
02110 __label_575:
02111
02112 double __DUMMY_575;
02113 __label_577:
02114
02115 double __DUMMY_577;
02116 __label_579:
02117
02118 double __DUMMY_579;
02119 __label_581:
02120
02121 double __DUMMY_581;
02122 __label_583:
02123
02124 double __DUMMY_583;
02125 __label_585:
02126
02127 double __DUMMY_585;
02128 __label_587:
02129
02130 double __DUMMY_587;
02131 __label_589:
02132
02133 double __DUMMY_589;
02134 __label_591:
02135
02136 double __DUMMY_591;
02137 __label_593:
02138
02139 double __DUMMY_593;
02140 __label_595:
02141
02142 double __DUMMY_595;
02143 __label_597:
02144
02145 double __DUMMY_597;
02146 __label_599:
02147
02148 double __DUMMY_599;
02149 __label_601:
02150
02151 double __DUMMY_601;
02152 __label_603:
02153
02154 double __DUMMY_603;
02155 __label_606:
02156
02157 double __DUMMY_606;
02158
02159 Py_XDECREF(this->storage_V3);
02160 Py_XDECREF(this->storage_V5);
02161 Py_XDECREF(this->storage_V7);
02162 Py_XDECREF(this->storage_V9);
02163 Py_XDECREF(this->storage_V11);
02164 Py_XDECREF(this->storage_V13);
02165 Py_XDECREF(this->storage_V15);
02166 Py_XDECREF(this->storage_V17);
02167 Py_XDECREF(this->storage_V19);
02168 Py_XDECREF(this->storage_V21);
02169 Py_XDECREF(this->storage_V23);
02170 Py_XDECREF(this->storage_V25);
02171 Py_XDECREF(this->storage_V27);
02172 Py_XDECREF(this->storage_V29);
02173 Py_XDECREF(this->storage_V31);
02174 Py_XDECREF(this->storage_V33);
02175 Py_XDECREF(this->storage_V35);
02176 Py_XDECREF(this->storage_V37);
02177 Py_XDECREF(this->storage_V39);
02178 Py_XDECREF(this->storage_V41);
02179 Py_XDECREF(this->storage_V43);
02180 Py_XDECREF(this->storage_V45);
02181 Py_XDECREF(this->storage_V47);
02182 Py_XDECREF(this->storage_V49);
02183 Py_XDECREF(this->storage_V51);
02184 Py_XDECREF(this->storage_V53);
02185 Py_XDECREF(this->storage_V55);
02186 Py_XDECREF(this->storage_V57);
02187 Py_XDECREF(this->storage_V59);
02188 Py_XDECREF(this->storage_V61);
02189 Py_XDECREF(this->storage_V63);
02190 Py_XDECREF(this->storage_V65);
02191 Py_XDECREF(this->storage_V67);
02192 Py_XDECREF(this->storage_V69);
02193 Py_XDECREF(this->storage_V71);
02194 Py_XDECREF(this->storage_V73);
02195 Py_XDECREF(this->storage_V75);
02196 Py_XDECREF(this->storage_V77);
02197 Py_XDECREF(this->storage_V79);
02198 Py_XDECREF(this->storage_V81);
02199 Py_XDECREF(this->storage_V83);
02200 Py_XDECREF(this->storage_V85);
02201 Py_XDECREF(this->storage_V87);
02202 Py_XDECREF(this->storage_V89);
02203 Py_XDECREF(this->storage_V91);
02204 Py_XDECREF(this->storage_V93);
02205 Py_XDECREF(this->storage_V95);
02206 Py_XDECREF(this->storage_V97);
02207 Py_XDECREF(this->storage_V99);
02208 Py_XDECREF(this->storage_V101);
02209 Py_XDECREF(this->storage_V103);
02210 Py_XDECREF(this->storage_V105);
02211 Py_XDECREF(this->storage_V107);
02212 Py_XDECREF(this->storage_V109);
02213 Py_XDECREF(this->storage_V111);
02214 Py_XDECREF(this->storage_V113);
02215 Py_XDECREF(this->storage_V115);
02216 Py_XDECREF(this->storage_V117);
02217 Py_XDECREF(this->storage_V119);
02218 Py_XDECREF(this->storage_V121);
02219 Py_XDECREF(this->storage_V123);
02220 Py_XDECREF(this->storage_V125);
02221 Py_XDECREF(this->storage_V127);
02222 Py_XDECREF(this->storage_V129);
02223 Py_XDECREF(this->storage_V131);
02224 Py_XDECREF(this->storage_V133);
02225 Py_XDECREF(this->storage_V135);
02226 Py_XDECREF(this->storage_V137);
02227 Py_XDECREF(this->storage_V139);
02228 Py_XDECREF(this->storage_V141);
02229 Py_XDECREF(this->storage_V143);
02230 Py_XDECREF(this->storage_V145);
02231 Py_XDECREF(this->storage_V147);
02232 Py_XDECREF(this->storage_V149);
02233 Py_XDECREF(this->storage_V151);
02234 Py_XDECREF(this->storage_V153);
02235 Py_XDECREF(this->storage_V155);
02236 Py_XDECREF(this->storage_V157);
02237 Py_XDECREF(this->storage_V159);
02238 Py_XDECREF(this->storage_V161);
02239 Py_XDECREF(this->storage_V163);
02240 Py_XDECREF(this->storage_V165);
02241 Py_XDECREF(this->storage_V167);
02242 Py_XDECREF(this->storage_V169);
02243 Py_XDECREF(this->storage_V171);
02244 Py_XDECREF(this->storage_V173);
02245 Py_XDECREF(this->storage_V175);
02246 Py_XDECREF(this->storage_V177);
02247 Py_XDECREF(this->storage_V179);
02248 Py_XDECREF(this->storage_V181);
02249 Py_XDECREF(this->storage_V183);
02250 Py_XDECREF(this->storage_V185);
02251 Py_XDECREF(this->storage_V187);
02252 Py_XDECREF(this->storage_V189);
02253 Py_XDECREF(this->storage_V191);
02254 Py_XDECREF(this->storage_V193);
02255 Py_XDECREF(this->storage_V195);
02256 Py_XDECREF(this->storage_V197);
02257 Py_XDECREF(this->storage_V199);
02258 Py_XDECREF(this->storage_V201);
02259 Py_XDECREF(this->storage_V203);
02260 Py_XDECREF(this->storage_V205);
02261 Py_XDECREF(this->storage_V207);
02262 Py_XDECREF(this->storage_V209);
02263 Py_XDECREF(this->storage_V211);
02264 Py_XDECREF(this->storage_V213);
02265 Py_XDECREF(this->storage_V215);
02266 Py_XDECREF(this->storage_V217);
02267 Py_XDECREF(this->storage_V219);
02268 Py_XDECREF(this->storage_V221);
02269 Py_XDECREF(this->storage_V223);
02270 Py_XDECREF(this->storage_V225);
02271 Py_XDECREF(this->storage_V227);
02272 Py_XDECREF(this->storage_V229);
02273 Py_XDECREF(this->storage_V231);
02274 Py_XDECREF(this->storage_V233);
02275 Py_XDECREF(this->storage_V235);
02276 Py_XDECREF(this->storage_V237);
02277 Py_XDECREF(this->storage_V239);
02278 Py_XDECREF(this->storage_V241);
02279 Py_XDECREF(this->storage_V243);
02280 Py_XDECREF(this->storage_V245);
02281 Py_XDECREF(this->storage_V247);
02282 Py_XDECREF(this->storage_V249);
02283 Py_XDECREF(this->storage_V251);
02284 Py_XDECREF(this->storage_V253);
02285 Py_XDECREF(this->storage_V255);
02286 Py_XDECREF(this->storage_V257);
02287 Py_XDECREF(this->storage_V259);
02288 Py_XDECREF(this->storage_V261);
02289 Py_XDECREF(this->storage_V263);
02290 Py_XDECREF(this->storage_V265);
02291 Py_XDECREF(this->storage_V267);
02292 Py_XDECREF(this->storage_V269);
02293 Py_XDECREF(this->storage_V271);
02294 Py_XDECREF(this->storage_V273);
02295 Py_XDECREF(this->storage_V275);
02296 Py_XDECREF(this->storage_V277);
02297 Py_XDECREF(this->storage_V279);
02298 Py_XDECREF(this->storage_V281);
02299 Py_XDECREF(this->storage_V283);
02300 Py_XDECREF(this->storage_V285);
02301 Py_XDECREF(this->storage_V287);
02302 Py_XDECREF(this->storage_V289);
02303 Py_XDECREF(this->storage_V291);
02304 Py_XDECREF(this->storage_V293);
02305 Py_XDECREF(this->storage_V295);
02306 Py_XDECREF(this->storage_V297);
02307 Py_XDECREF(this->storage_V299);
02308 Py_XDECREF(this->storage_V301);
02309 Py_XDECREF(this->storage_V303);
02310 Py_XDECREF(this->storage_V305);
02311 Py_XDECREF(this->storage_V307);
02312 Py_XDECREF(this->storage_V309);
02313 Py_XDECREF(this->storage_V311);
02314 Py_XDECREF(this->storage_V313);
02315 Py_XDECREF(this->storage_V315);
02316 Py_XDECREF(this->storage_V317);
02317 Py_XDECREF(this->storage_V319);
02318 Py_XDECREF(this->storage_V321);
02319 Py_XDECREF(this->storage_V323);
02320 Py_XDECREF(this->storage_V325);
02321 Py_XDECREF(this->storage_V327);
02322 Py_XDECREF(this->storage_V329);
02323 Py_XDECREF(this->storage_V331);
02324 Py_XDECREF(this->storage_V333);
02325 Py_XDECREF(this->storage_V335);
02326 Py_XDECREF(this->storage_V337);
02327 Py_XDECREF(this->storage_V339);
02328 Py_XDECREF(this->storage_V341);
02329 Py_XDECREF(this->storage_V343);
02330 Py_XDECREF(this->storage_V345);
02331 Py_XDECREF(this->storage_V347);
02332 Py_XDECREF(this->storage_V349);
02333 Py_XDECREF(this->storage_V351);
02334 Py_XDECREF(this->storage_V353);
02335 Py_XDECREF(this->storage_V355);
02336 Py_XDECREF(this->storage_V357);
02337 Py_XDECREF(this->storage_V359);
02338 Py_XDECREF(this->storage_V361);
02339 Py_XDECREF(this->storage_V363);
02340 Py_XDECREF(this->storage_V365);
02341 Py_XDECREF(this->storage_V367);
02342 Py_XDECREF(this->storage_V369);
02343 Py_XDECREF(this->storage_V371);
02344 Py_XDECREF(this->storage_V373);
02345 Py_XDECREF(this->storage_V375);
02346 Py_XDECREF(this->storage_V377);
02347 Py_XDECREF(this->storage_V379);
02348 Py_XDECREF(this->storage_V381);
02349 Py_XDECREF(this->storage_V383);
02350 Py_XDECREF(this->storage_V385);
02351 Py_XDECREF(this->storage_V387);
02352 Py_XDECREF(this->storage_V389);
02353 Py_XDECREF(this->storage_V391);
02354 Py_XDECREF(this->storage_V393);
02355 Py_XDECREF(this->storage_V395);
02356 Py_XDECREF(this->storage_V397);
02357 Py_XDECREF(this->storage_V399);
02358 Py_XDECREF(this->storage_V401);
02359 Py_XDECREF(this->storage_V403);
02360 Py_XDECREF(this->storage_V405);
02361 Py_XDECREF(this->storage_V407);
02362 Py_XDECREF(this->storage_V409);
02363 Py_XDECREF(this->storage_V411);
02364 Py_XDECREF(this->storage_V413);
02365 Py_XDECREF(this->storage_V415);
02366 Py_XDECREF(this->storage_V417);
02367 Py_XDECREF(this->storage_V419);
02368 Py_XDECREF(this->storage_V421);
02369 Py_XDECREF(this->storage_V423);
02370 Py_XDECREF(this->storage_V425);
02371 Py_XDECREF(this->storage_V427);
02372 Py_XDECREF(this->storage_V429);
02373 Py_XDECREF(this->storage_V431);
02374 Py_XDECREF(this->storage_V433);
02375 Py_XDECREF(this->storage_V435);
02376 Py_XDECREF(this->storage_V437);
02377 Py_XDECREF(this->storage_V439);
02378 Py_XDECREF(this->storage_V441);
02379 Py_XDECREF(this->storage_V443);
02380 Py_XDECREF(this->storage_V445);
02381 Py_XDECREF(this->storage_V447);
02382 Py_XDECREF(this->storage_V449);
02383 Py_XDECREF(this->storage_V451);
02384 Py_XDECREF(this->storage_V453);
02385 Py_XDECREF(this->storage_V455);
02386 Py_XDECREF(this->storage_V457);
02387 Py_XDECREF(this->storage_V459);
02388 Py_XDECREF(this->storage_V461);
02389 Py_XDECREF(this->storage_V463);
02390 Py_XDECREF(this->storage_V465);
02391 Py_XDECREF(this->storage_V467);
02392 Py_XDECREF(this->storage_V469);
02393 Py_XDECREF(this->storage_V471);
02394 Py_XDECREF(this->storage_V473);
02395 Py_XDECREF(this->storage_V475);
02396 Py_XDECREF(this->storage_V477);
02397 Py_XDECREF(this->storage_V479);
02398 Py_XDECREF(this->storage_V481);
02399 Py_XDECREF(this->storage_V483);
02400 Py_XDECREF(this->storage_V485);
02401 Py_XDECREF(this->storage_V487);
02402 Py_XDECREF(this->storage_V489);
02403 Py_XDECREF(this->storage_V491);
02404 Py_XDECREF(this->storage_V493);
02405 Py_XDECREF(this->storage_V495);
02406 Py_XDECREF(this->storage_V497);
02407 Py_XDECREF(this->storage_V499);
02408 Py_XDECREF(this->storage_V501);
02409 Py_XDECREF(this->storage_V503);
02410 Py_XDECREF(this->storage_V505);
02411 Py_XDECREF(this->storage_V507);
02412 Py_XDECREF(this->storage_V509);
02413 Py_XDECREF(this->storage_V511);
02414 Py_XDECREF(this->storage_V513);
02415 Py_XDECREF(this->storage_V515);
02416 Py_XDECREF(this->storage_V517);
02417 Py_XDECREF(this->storage_V519);
02418 Py_XDECREF(this->storage_V521);
02419 Py_XDECREF(this->storage_V523);
02420 Py_XDECREF(this->storage_V525);
02421 Py_XDECREF(this->storage_V527);
02422 Py_XDECREF(this->storage_V529);
02423 Py_XDECREF(this->storage_V531);
02424 Py_XDECREF(this->storage_V533);
02425 Py_XDECREF(this->storage_V535);
02426 Py_XDECREF(this->storage_V537);
02427 Py_XDECREF(this->storage_V539);
02428 Py_XDECREF(this->storage_V541);
02429 Py_XDECREF(this->storage_V543);
02430 Py_XDECREF(this->storage_V545);
02431 Py_XDECREF(this->storage_V547);
02432 Py_XDECREF(this->storage_V549);
02433 Py_XDECREF(this->storage_V551);
02434 Py_XDECREF(this->storage_V553);
02435 Py_XDECREF(this->storage_V555);
02436 Py_XDECREF(this->storage_V557);
02437 Py_XDECREF(this->storage_V559);
02438 Py_XDECREF(this->storage_V561);
02439 Py_XDECREF(this->storage_V563);
02440 Py_XDECREF(this->storage_V565);
02441 Py_XDECREF(this->storage_V567);
02442 Py_XDECREF(this->storage_V569);
02443 Py_XDECREF(this->storage_V571);
02444 Py_XDECREF(this->storage_V573);
02445 Py_XDECREF(this->storage_V575);
02446 Py_XDECREF(this->storage_V577);
02447 Py_XDECREF(this->storage_V579);
02448 Py_XDECREF(this->storage_V581);
02449 Py_XDECREF(this->storage_V583);
02450 Py_XDECREF(this->storage_V585);
02451 Py_XDECREF(this->storage_V587);
02452 Py_XDECREF(this->storage_V589);
02453 Py_XDECREF(this->storage_V591);
02454 Py_XDECREF(this->storage_V593);
02455 Py_XDECREF(this->storage_V595);
02456 Py_XDECREF(this->storage_V597);
02457 Py_XDECREF(this->storage_V599);
02458 Py_XDECREF(this->storage_V601);
02459 Py_XDECREF(this->storage_V603);
02460 Py_XDECREF(this->storage_V1);
02461 }
02462 int run(void) {
02463 int __failure = 0;
02464
02465 PyObject* py_V1;
02466
02467 PyArrayObject* V1;
02468
02469 typedef npy_float64 dtype_V1;
02470
02471 PyObject* py_V3;
02472
02473 PyArrayObject* V3;
02474
02475 typedef npy_float64 dtype_V3;
02476
02477 PyObject* py_V5;
02478
02479 PyArrayObject* V5;
02480
02481 typedef npy_float64 dtype_V5;
02482
02483 PyObject* py_V7;
02484
02485 PyArrayObject* V7;
02486
02487 typedef npy_float64 dtype_V7;
02488
02489 PyObject* py_V9;
02490
02491 PyArrayObject* V9;
02492
02493 typedef npy_float64 dtype_V9;
02494
02495 PyObject* py_V11;
02496
02497 PyArrayObject* V11;
02498
02499 typedef npy_float64 dtype_V11;
02500
02501 PyObject* py_V13;
02502
02503 PyArrayObject* V13;
02504
02505 typedef npy_float64 dtype_V13;
02506
02507 PyObject* py_V15;
02508
02509 PyArrayObject* V15;
02510
02511 typedef npy_float64 dtype_V15;
02512
02513 PyObject* py_V17;
02514
02515 PyArrayObject* V17;
02516
02517 typedef npy_float64 dtype_V17;
02518
02519 PyObject* py_V19;
02520
02521 PyArrayObject* V19;
02522
02523 typedef npy_float64 dtype_V19;
02524
02525 PyObject* py_V21;
02526
02527 PyArrayObject* V21;
02528
02529 typedef npy_float64 dtype_V21;
02530
02531 PyObject* py_V23;
02532
02533 PyArrayObject* V23;
02534
02535 typedef npy_float64 dtype_V23;
02536
02537 PyObject* py_V25;
02538
02539 PyArrayObject* V25;
02540
02541 typedef npy_float64 dtype_V25;
02542
02543 PyObject* py_V27;
02544
02545 PyArrayObject* V27;
02546
02547 typedef npy_float64 dtype_V27;
02548
02549 PyObject* py_V29;
02550
02551 PyArrayObject* V29;
02552
02553 typedef npy_float64 dtype_V29;
02554
02555 PyObject* py_V31;
02556
02557 PyArrayObject* V31;
02558
02559 typedef npy_float64 dtype_V31;
02560
02561 PyObject* py_V33;
02562
02563 PyArrayObject* V33;
02564
02565 typedef npy_float64 dtype_V33;
02566
02567 PyObject* py_V35;
02568
02569 PyArrayObject* V35;
02570
02571 typedef npy_float64 dtype_V35;
02572
02573 PyObject* py_V37;
02574
02575 PyArrayObject* V37;
02576
02577 typedef npy_float64 dtype_V37;
02578
02579 PyObject* py_V39;
02580
02581 PyArrayObject* V39;
02582
02583 typedef npy_float64 dtype_V39;
02584
02585 PyObject* py_V41;
02586
02587 PyArrayObject* V41;
02588
02589 typedef npy_float64 dtype_V41;
02590
02591 PyObject* py_V43;
02592
02593 PyArrayObject* V43;
02594
02595 typedef npy_float64 dtype_V43;
02596
02597 PyObject* py_V45;
02598
02599 PyArrayObject* V45;
02600
02601 typedef npy_float64 dtype_V45;
02602
02603 PyObject* py_V47;
02604
02605 PyArrayObject* V47;
02606
02607 typedef npy_float64 dtype_V47;
02608
02609 PyObject* py_V49;
02610
02611 PyArrayObject* V49;
02612
02613 typedef npy_float64 dtype_V49;
02614
02615 PyObject* py_V51;
02616
02617 PyArrayObject* V51;
02618
02619 typedef npy_float64 dtype_V51;
02620
02621 PyObject* py_V53;
02622
02623 PyArrayObject* V53;
02624
02625 typedef npy_float64 dtype_V53;
02626
02627 PyObject* py_V55;
02628
02629 PyArrayObject* V55;
02630
02631 typedef npy_float64 dtype_V55;
02632
02633 PyObject* py_V57;
02634
02635 PyArrayObject* V57;
02636
02637 typedef npy_float64 dtype_V57;
02638
02639 PyObject* py_V59;
02640
02641 PyArrayObject* V59;
02642
02643 typedef npy_float64 dtype_V59;
02644
02645 PyObject* py_V61;
02646
02647 PyArrayObject* V61;
02648
02649 typedef npy_float64 dtype_V61;
02650
02651 PyObject* py_V63;
02652
02653 PyArrayObject* V63;
02654
02655 typedef npy_float64 dtype_V63;
02656
02657 PyObject* py_V65;
02658
02659 PyArrayObject* V65;
02660
02661 typedef npy_float64 dtype_V65;
02662
02663 PyObject* py_V67;
02664
02665 PyArrayObject* V67;
02666
02667 typedef npy_float64 dtype_V67;
02668
02669 PyObject* py_V69;
02670
02671 PyArrayObject* V69;
02672
02673 typedef npy_float64 dtype_V69;
02674
02675 PyObject* py_V71;
02676
02677 PyArrayObject* V71;
02678
02679 typedef npy_float64 dtype_V71;
02680
02681 PyObject* py_V73;
02682
02683 PyArrayObject* V73;
02684
02685 typedef npy_float64 dtype_V73;
02686
02687 PyObject* py_V75;
02688
02689 PyArrayObject* V75;
02690
02691 typedef npy_float64 dtype_V75;
02692
02693 PyObject* py_V77;
02694
02695 PyArrayObject* V77;
02696
02697 typedef npy_float64 dtype_V77;
02698
02699 PyObject* py_V79;
02700
02701 PyArrayObject* V79;
02702
02703 typedef npy_float64 dtype_V79;
02704
02705 PyObject* py_V81;
02706
02707 PyArrayObject* V81;
02708
02709 typedef npy_float64 dtype_V81;
02710
02711 PyObject* py_V83;
02712
02713 PyArrayObject* V83;
02714
02715 typedef npy_float64 dtype_V83;
02716
02717 PyObject* py_V85;
02718
02719 PyArrayObject* V85;
02720
02721 typedef npy_float64 dtype_V85;
02722
02723 PyObject* py_V87;
02724
02725 PyArrayObject* V87;
02726
02727 typedef npy_float64 dtype_V87;
02728
02729 PyObject* py_V89;
02730
02731 PyArrayObject* V89;
02732
02733 typedef npy_float64 dtype_V89;
02734
02735 PyObject* py_V91;
02736
02737 PyArrayObject* V91;
02738
02739 typedef npy_float64 dtype_V91;
02740
02741 PyObject* py_V93;
02742
02743 PyArrayObject* V93;
02744
02745 typedef npy_float64 dtype_V93;
02746
02747 PyObject* py_V95;
02748
02749 PyArrayObject* V95;
02750
02751 typedef npy_float64 dtype_V95;
02752
02753 PyObject* py_V97;
02754
02755 PyArrayObject* V97;
02756
02757 typedef npy_float64 dtype_V97;
02758
02759 PyObject* py_V99;
02760
02761 PyArrayObject* V99;
02762
02763 typedef npy_float64 dtype_V99;
02764
02765 PyObject* py_V101;
02766
02767 PyArrayObject* V101;
02768
02769 typedef npy_float64 dtype_V101;
02770
02771 PyObject* py_V103;
02772
02773 PyArrayObject* V103;
02774
02775 typedef npy_float64 dtype_V103;
02776
02777 PyObject* py_V105;
02778
02779 PyArrayObject* V105;
02780
02781 typedef npy_float64 dtype_V105;
02782
02783 PyObject* py_V107;
02784
02785 PyArrayObject* V107;
02786
02787 typedef npy_float64 dtype_V107;
02788
02789 PyObject* py_V109;
02790
02791 PyArrayObject* V109;
02792
02793 typedef npy_float64 dtype_V109;
02794
02795 PyObject* py_V111;
02796
02797 PyArrayObject* V111;
02798
02799 typedef npy_float64 dtype_V111;
02800
02801 PyObject* py_V113;
02802
02803 PyArrayObject* V113;
02804
02805 typedef npy_float64 dtype_V113;
02806
02807 PyObject* py_V115;
02808
02809 PyArrayObject* V115;
02810
02811 typedef npy_float64 dtype_V115;
02812
02813 PyObject* py_V117;
02814
02815 PyArrayObject* V117;
02816
02817 typedef npy_float64 dtype_V117;
02818
02819 PyObject* py_V119;
02820
02821 PyArrayObject* V119;
02822
02823 typedef npy_float64 dtype_V119;
02824
02825 PyObject* py_V121;
02826
02827 PyArrayObject* V121;
02828
02829 typedef npy_float64 dtype_V121;
02830
02831 PyObject* py_V123;
02832
02833 PyArrayObject* V123;
02834
02835 typedef npy_float64 dtype_V123;
02836
02837 PyObject* py_V125;
02838
02839 PyArrayObject* V125;
02840
02841 typedef npy_float64 dtype_V125;
02842
02843 PyObject* py_V127;
02844
02845 PyArrayObject* V127;
02846
02847 typedef npy_float64 dtype_V127;
02848
02849 PyObject* py_V129;
02850
02851 PyArrayObject* V129;
02852
02853 typedef npy_float64 dtype_V129;
02854
02855 PyObject* py_V131;
02856
02857 PyArrayObject* V131;
02858
02859 typedef npy_float64 dtype_V131;
02860
02861 PyObject* py_V133;
02862
02863 PyArrayObject* V133;
02864
02865 typedef npy_float64 dtype_V133;
02866
02867 PyObject* py_V135;
02868
02869 PyArrayObject* V135;
02870
02871 typedef npy_float64 dtype_V135;
02872
02873 PyObject* py_V137;
02874
02875 PyArrayObject* V137;
02876
02877 typedef npy_float64 dtype_V137;
02878
02879 PyObject* py_V139;
02880
02881 PyArrayObject* V139;
02882
02883 typedef npy_float64 dtype_V139;
02884
02885 PyObject* py_V141;
02886
02887 PyArrayObject* V141;
02888
02889 typedef npy_float64 dtype_V141;
02890
02891 PyObject* py_V143;
02892
02893 PyArrayObject* V143;
02894
02895 typedef npy_float64 dtype_V143;
02896
02897 PyObject* py_V145;
02898
02899 PyArrayObject* V145;
02900
02901 typedef npy_float64 dtype_V145;
02902
02903 PyObject* py_V147;
02904
02905 PyArrayObject* V147;
02906
02907 typedef npy_float64 dtype_V147;
02908
02909 PyObject* py_V149;
02910
02911 PyArrayObject* V149;
02912
02913 typedef npy_float64 dtype_V149;
02914
02915 PyObject* py_V151;
02916
02917 PyArrayObject* V151;
02918
02919 typedef npy_float64 dtype_V151;
02920
02921 PyObject* py_V153;
02922
02923 PyArrayObject* V153;
02924
02925 typedef npy_float64 dtype_V153;
02926
02927 PyObject* py_V155;
02928
02929 PyArrayObject* V155;
02930
02931 typedef npy_float64 dtype_V155;
02932
02933 PyObject* py_V157;
02934
02935 PyArrayObject* V157;
02936
02937 typedef npy_float64 dtype_V157;
02938
02939 PyObject* py_V159;
02940
02941 PyArrayObject* V159;
02942
02943 typedef npy_float64 dtype_V159;
02944
02945 PyObject* py_V161;
02946
02947 PyArrayObject* V161;
02948
02949 typedef npy_float64 dtype_V161;
02950
02951 PyObject* py_V163;
02952
02953 PyArrayObject* V163;
02954
02955 typedef npy_float64 dtype_V163;
02956
02957 PyObject* py_V165;
02958
02959 PyArrayObject* V165;
02960
02961 typedef npy_float64 dtype_V165;
02962
02963 PyObject* py_V167;
02964
02965 PyArrayObject* V167;
02966
02967 typedef npy_float64 dtype_V167;
02968
02969 PyObject* py_V169;
02970
02971 PyArrayObject* V169;
02972
02973 typedef npy_float64 dtype_V169;
02974
02975 PyObject* py_V171;
02976
02977 PyArrayObject* V171;
02978
02979 typedef npy_float64 dtype_V171;
02980
02981 PyObject* py_V173;
02982
02983 PyArrayObject* V173;
02984
02985 typedef npy_float64 dtype_V173;
02986
02987 PyObject* py_V175;
02988
02989 PyArrayObject* V175;
02990
02991 typedef npy_float64 dtype_V175;
02992
02993 PyObject* py_V177;
02994
02995 PyArrayObject* V177;
02996
02997 typedef npy_float64 dtype_V177;
02998
02999 PyObject* py_V179;
03000
03001 PyArrayObject* V179;
03002
03003 typedef npy_float64 dtype_V179;
03004
03005 PyObject* py_V181;
03006
03007 PyArrayObject* V181;
03008
03009 typedef npy_float64 dtype_V181;
03010
03011 PyObject* py_V183;
03012
03013 PyArrayObject* V183;
03014
03015 typedef npy_float64 dtype_V183;
03016
03017 PyObject* py_V185;
03018
03019 PyArrayObject* V185;
03020
03021 typedef npy_float64 dtype_V185;
03022
03023 PyObject* py_V187;
03024
03025 PyArrayObject* V187;
03026
03027 typedef npy_float64 dtype_V187;
03028
03029 PyObject* py_V189;
03030
03031 PyArrayObject* V189;
03032
03033 typedef npy_float64 dtype_V189;
03034
03035 PyObject* py_V191;
03036
03037 PyArrayObject* V191;
03038
03039 typedef npy_float64 dtype_V191;
03040
03041 PyObject* py_V193;
03042
03043 PyArrayObject* V193;
03044
03045 typedef npy_float64 dtype_V193;
03046
03047 PyObject* py_V195;
03048
03049 PyArrayObject* V195;
03050
03051 typedef npy_float64 dtype_V195;
03052
03053 PyObject* py_V197;
03054
03055 PyArrayObject* V197;
03056
03057 typedef npy_float64 dtype_V197;
03058
03059 PyObject* py_V199;
03060
03061 PyArrayObject* V199;
03062
03063 typedef npy_float64 dtype_V199;
03064
03065 PyObject* py_V201;
03066
03067 PyArrayObject* V201;
03068
03069 typedef npy_float64 dtype_V201;
03070
03071 PyObject* py_V203;
03072
03073 PyArrayObject* V203;
03074
03075 typedef npy_float64 dtype_V203;
03076
03077 PyObject* py_V205;
03078
03079 PyArrayObject* V205;
03080
03081 typedef npy_float64 dtype_V205;
03082
03083 PyObject* py_V207;
03084
03085 PyArrayObject* V207;
03086
03087 typedef npy_float64 dtype_V207;
03088
03089 PyObject* py_V209;
03090
03091 PyArrayObject* V209;
03092
03093 typedef npy_float64 dtype_V209;
03094
03095 PyObject* py_V211;
03096
03097 PyArrayObject* V211;
03098
03099 typedef npy_float64 dtype_V211;
03100
03101 PyObject* py_V213;
03102
03103 PyArrayObject* V213;
03104
03105 typedef npy_float64 dtype_V213;
03106
03107 PyObject* py_V215;
03108
03109 PyArrayObject* V215;
03110
03111 typedef npy_float64 dtype_V215;
03112
03113 PyObject* py_V217;
03114
03115 PyArrayObject* V217;
03116
03117 typedef npy_float64 dtype_V217;
03118
03119 PyObject* py_V219;
03120
03121 PyArrayObject* V219;
03122
03123 typedef npy_float64 dtype_V219;
03124
03125 PyObject* py_V221;
03126
03127 PyArrayObject* V221;
03128
03129 typedef npy_float64 dtype_V221;
03130
03131 PyObject* py_V223;
03132
03133 PyArrayObject* V223;
03134
03135 typedef npy_float64 dtype_V223;
03136
03137 PyObject* py_V225;
03138
03139 PyArrayObject* V225;
03140
03141 typedef npy_float64 dtype_V225;
03142
03143 PyObject* py_V227;
03144
03145 PyArrayObject* V227;
03146
03147 typedef npy_float64 dtype_V227;
03148
03149 PyObject* py_V229;
03150
03151 PyArrayObject* V229;
03152
03153 typedef npy_float64 dtype_V229;
03154
03155 PyObject* py_V231;
03156
03157 PyArrayObject* V231;
03158
03159 typedef npy_float64 dtype_V231;
03160
03161 PyObject* py_V233;
03162
03163 PyArrayObject* V233;
03164
03165 typedef npy_float64 dtype_V233;
03166
03167 PyObject* py_V235;
03168
03169 PyArrayObject* V235;
03170
03171 typedef npy_float64 dtype_V235;
03172
03173 PyObject* py_V237;
03174
03175 PyArrayObject* V237;
03176
03177 typedef npy_float64 dtype_V237;
03178
03179 PyObject* py_V239;
03180
03181 PyArrayObject* V239;
03182
03183 typedef npy_float64 dtype_V239;
03184
03185 PyObject* py_V241;
03186
03187 PyArrayObject* V241;
03188
03189 typedef npy_float64 dtype_V241;
03190
03191 PyObject* py_V243;
03192
03193 PyArrayObject* V243;
03194
03195 typedef npy_float64 dtype_V243;
03196
03197 PyObject* py_V245;
03198
03199 PyArrayObject* V245;
03200
03201 typedef npy_float64 dtype_V245;
03202
03203 PyObject* py_V247;
03204
03205 PyArrayObject* V247;
03206
03207 typedef npy_float64 dtype_V247;
03208
03209 PyObject* py_V249;
03210
03211 PyArrayObject* V249;
03212
03213 typedef npy_float64 dtype_V249;
03214
03215 PyObject* py_V251;
03216
03217 PyArrayObject* V251;
03218
03219 typedef npy_float64 dtype_V251;
03220
03221 PyObject* py_V253;
03222
03223 PyArrayObject* V253;
03224
03225 typedef npy_float64 dtype_V253;
03226
03227 PyObject* py_V255;
03228
03229 PyArrayObject* V255;
03230
03231 typedef npy_float64 dtype_V255;
03232
03233 PyObject* py_V257;
03234
03235 PyArrayObject* V257;
03236
03237 typedef npy_float64 dtype_V257;
03238
03239 PyObject* py_V259;
03240
03241 PyArrayObject* V259;
03242
03243 typedef npy_float64 dtype_V259;
03244
03245 PyObject* py_V261;
03246
03247 PyArrayObject* V261;
03248
03249 typedef npy_float64 dtype_V261;
03250
03251 PyObject* py_V263;
03252
03253 PyArrayObject* V263;
03254
03255 typedef npy_float64 dtype_V263;
03256
03257 PyObject* py_V265;
03258
03259 PyArrayObject* V265;
03260
03261 typedef npy_float64 dtype_V265;
03262
03263 PyObject* py_V267;
03264
03265 PyArrayObject* V267;
03266
03267 typedef npy_float64 dtype_V267;
03268
03269 PyObject* py_V269;
03270
03271 PyArrayObject* V269;
03272
03273 typedef npy_float64 dtype_V269;
03274
03275 PyObject* py_V271;
03276
03277 PyArrayObject* V271;
03278
03279 typedef npy_float64 dtype_V271;
03280
03281 PyObject* py_V273;
03282
03283 PyArrayObject* V273;
03284
03285 typedef npy_float64 dtype_V273;
03286
03287 PyObject* py_V275;
03288
03289 PyArrayObject* V275;
03290
03291 typedef npy_float64 dtype_V275;
03292
03293 PyObject* py_V277;
03294
03295 PyArrayObject* V277;
03296
03297 typedef npy_float64 dtype_V277;
03298
03299 PyObject* py_V279;
03300
03301 PyArrayObject* V279;
03302
03303 typedef npy_float64 dtype_V279;
03304
03305 PyObject* py_V281;
03306
03307 PyArrayObject* V281;
03308
03309 typedef npy_float64 dtype_V281;
03310
03311 PyObject* py_V283;
03312
03313 PyArrayObject* V283;
03314
03315 typedef npy_float64 dtype_V283;
03316
03317 PyObject* py_V285;
03318
03319 PyArrayObject* V285;
03320
03321 typedef npy_float64 dtype_V285;
03322
03323 PyObject* py_V287;
03324
03325 PyArrayObject* V287;
03326
03327 typedef npy_float64 dtype_V287;
03328
03329 PyObject* py_V289;
03330
03331 PyArrayObject* V289;
03332
03333 typedef npy_float64 dtype_V289;
03334
03335 PyObject* py_V291;
03336
03337 PyArrayObject* V291;
03338
03339 typedef npy_float64 dtype_V291;
03340
03341 PyObject* py_V293;
03342
03343 PyArrayObject* V293;
03344
03345 typedef npy_float64 dtype_V293;
03346
03347 PyObject* py_V295;
03348
03349 PyArrayObject* V295;
03350
03351 typedef npy_float64 dtype_V295;
03352
03353 PyObject* py_V297;
03354
03355 PyArrayObject* V297;
03356
03357 typedef npy_float64 dtype_V297;
03358
03359 PyObject* py_V299;
03360
03361 PyArrayObject* V299;
03362
03363 typedef npy_float64 dtype_V299;
03364
03365 PyObject* py_V301;
03366
03367 PyArrayObject* V301;
03368
03369 typedef npy_float64 dtype_V301;
03370
03371 PyObject* py_V303;
03372
03373 PyArrayObject* V303;
03374
03375 typedef npy_float64 dtype_V303;
03376
03377 PyObject* py_V305;
03378
03379 PyArrayObject* V305;
03380
03381 typedef npy_float64 dtype_V305;
03382
03383 PyObject* py_V307;
03384
03385 PyArrayObject* V307;
03386
03387 typedef npy_float64 dtype_V307;
03388
03389 PyObject* py_V309;
03390
03391 PyArrayObject* V309;
03392
03393 typedef npy_float64 dtype_V309;
03394
03395 PyObject* py_V311;
03396
03397 PyArrayObject* V311;
03398
03399 typedef npy_float64 dtype_V311;
03400
03401 PyObject* py_V313;
03402
03403 PyArrayObject* V313;
03404
03405 typedef npy_float64 dtype_V313;
03406
03407 PyObject* py_V315;
03408
03409 PyArrayObject* V315;
03410
03411 typedef npy_float64 dtype_V315;
03412
03413 PyObject* py_V317;
03414
03415 PyArrayObject* V317;
03416
03417 typedef npy_float64 dtype_V317;
03418
03419 PyObject* py_V319;
03420
03421 PyArrayObject* V319;
03422
03423 typedef npy_float64 dtype_V319;
03424
03425 PyObject* py_V321;
03426
03427 PyArrayObject* V321;
03428
03429 typedef npy_float64 dtype_V321;
03430
03431 PyObject* py_V323;
03432
03433 PyArrayObject* V323;
03434
03435 typedef npy_float64 dtype_V323;
03436
03437 PyObject* py_V325;
03438
03439 PyArrayObject* V325;
03440
03441 typedef npy_float64 dtype_V325;
03442
03443 PyObject* py_V327;
03444
03445 PyArrayObject* V327;
03446
03447 typedef npy_float64 dtype_V327;
03448
03449 PyObject* py_V329;
03450
03451 PyArrayObject* V329;
03452
03453 typedef npy_float64 dtype_V329;
03454
03455 PyObject* py_V331;
03456
03457 PyArrayObject* V331;
03458
03459 typedef npy_float64 dtype_V331;
03460
03461 PyObject* py_V333;
03462
03463 PyArrayObject* V333;
03464
03465 typedef npy_float64 dtype_V333;
03466
03467 PyObject* py_V335;
03468
03469 PyArrayObject* V335;
03470
03471 typedef npy_float64 dtype_V335;
03472
03473 PyObject* py_V337;
03474
03475 PyArrayObject* V337;
03476
03477 typedef npy_float64 dtype_V337;
03478
03479 PyObject* py_V339;
03480
03481 PyArrayObject* V339;
03482
03483 typedef npy_float64 dtype_V339;
03484
03485 PyObject* py_V341;
03486
03487 PyArrayObject* V341;
03488
03489 typedef npy_float64 dtype_V341;
03490
03491 PyObject* py_V343;
03492
03493 PyArrayObject* V343;
03494
03495 typedef npy_float64 dtype_V343;
03496
03497 PyObject* py_V345;
03498
03499 PyArrayObject* V345;
03500
03501 typedef npy_float64 dtype_V345;
03502
03503 PyObject* py_V347;
03504
03505 PyArrayObject* V347;
03506
03507 typedef npy_float64 dtype_V347;
03508
03509 PyObject* py_V349;
03510
03511 PyArrayObject* V349;
03512
03513 typedef npy_float64 dtype_V349;
03514
03515 PyObject* py_V351;
03516
03517 PyArrayObject* V351;
03518
03519 typedef npy_float64 dtype_V351;
03520
03521 PyObject* py_V353;
03522
03523 PyArrayObject* V353;
03524
03525 typedef npy_float64 dtype_V353;
03526
03527 PyObject* py_V355;
03528
03529 PyArrayObject* V355;
03530
03531 typedef npy_float64 dtype_V355;
03532
03533 PyObject* py_V357;
03534
03535 PyArrayObject* V357;
03536
03537 typedef npy_float64 dtype_V357;
03538
03539 PyObject* py_V359;
03540
03541 PyArrayObject* V359;
03542
03543 typedef npy_float64 dtype_V359;
03544
03545 PyObject* py_V361;
03546
03547 PyArrayObject* V361;
03548
03549 typedef npy_float64 dtype_V361;
03550
03551 PyObject* py_V363;
03552
03553 PyArrayObject* V363;
03554
03555 typedef npy_float64 dtype_V363;
03556
03557 PyObject* py_V365;
03558
03559 PyArrayObject* V365;
03560
03561 typedef npy_float64 dtype_V365;
03562
03563 PyObject* py_V367;
03564
03565 PyArrayObject* V367;
03566
03567 typedef npy_float64 dtype_V367;
03568
03569 PyObject* py_V369;
03570
03571 PyArrayObject* V369;
03572
03573 typedef npy_float64 dtype_V369;
03574
03575 PyObject* py_V371;
03576
03577 PyArrayObject* V371;
03578
03579 typedef npy_float64 dtype_V371;
03580
03581 PyObject* py_V373;
03582
03583 PyArrayObject* V373;
03584
03585 typedef npy_float64 dtype_V373;
03586
03587 PyObject* py_V375;
03588
03589 PyArrayObject* V375;
03590
03591 typedef npy_float64 dtype_V375;
03592
03593 PyObject* py_V377;
03594
03595 PyArrayObject* V377;
03596
03597 typedef npy_float64 dtype_V377;
03598
03599 PyObject* py_V379;
03600
03601 PyArrayObject* V379;
03602
03603 typedef npy_float64 dtype_V379;
03604
03605 PyObject* py_V381;
03606
03607 PyArrayObject* V381;
03608
03609 typedef npy_float64 dtype_V381;
03610
03611 PyObject* py_V383;
03612
03613 PyArrayObject* V383;
03614
03615 typedef npy_float64 dtype_V383;
03616
03617 PyObject* py_V385;
03618
03619 PyArrayObject* V385;
03620
03621 typedef npy_float64 dtype_V385;
03622
03623 PyObject* py_V387;
03624
03625 PyArrayObject* V387;
03626
03627 typedef npy_float64 dtype_V387;
03628
03629 PyObject* py_V389;
03630
03631 PyArrayObject* V389;
03632
03633 typedef npy_float64 dtype_V389;
03634
03635 PyObject* py_V391;
03636
03637 PyArrayObject* V391;
03638
03639 typedef npy_float64 dtype_V391;
03640
03641 PyObject* py_V393;
03642
03643 PyArrayObject* V393;
03644
03645 typedef npy_float64 dtype_V393;
03646
03647 PyObject* py_V395;
03648
03649 PyArrayObject* V395;
03650
03651 typedef npy_float64 dtype_V395;
03652
03653 PyObject* py_V397;
03654
03655 PyArrayObject* V397;
03656
03657 typedef npy_float64 dtype_V397;
03658
03659 PyObject* py_V399;
03660
03661 PyArrayObject* V399;
03662
03663 typedef npy_float64 dtype_V399;
03664
03665 PyObject* py_V401;
03666
03667 PyArrayObject* V401;
03668
03669 typedef npy_float64 dtype_V401;
03670
03671 PyObject* py_V403;
03672
03673 PyArrayObject* V403;
03674
03675 typedef npy_float64 dtype_V403;
03676
03677 PyObject* py_V405;
03678
03679 PyArrayObject* V405;
03680
03681 typedef npy_float64 dtype_V405;
03682
03683 PyObject* py_V407;
03684
03685 PyArrayObject* V407;
03686
03687 typedef npy_float64 dtype_V407;
03688
03689 PyObject* py_V409;
03690
03691 PyArrayObject* V409;
03692
03693 typedef npy_float64 dtype_V409;
03694
03695 PyObject* py_V411;
03696
03697 PyArrayObject* V411;
03698
03699 typedef npy_float64 dtype_V411;
03700
03701 PyObject* py_V413;
03702
03703 PyArrayObject* V413;
03704
03705 typedef npy_float64 dtype_V413;
03706
03707 PyObject* py_V415;
03708
03709 PyArrayObject* V415;
03710
03711 typedef npy_float64 dtype_V415;
03712
03713 PyObject* py_V417;
03714
03715 PyArrayObject* V417;
03716
03717 typedef npy_float64 dtype_V417;
03718
03719 PyObject* py_V419;
03720
03721 PyArrayObject* V419;
03722
03723 typedef npy_float64 dtype_V419;
03724
03725 PyObject* py_V421;
03726
03727 PyArrayObject* V421;
03728
03729 typedef npy_float64 dtype_V421;
03730
03731 PyObject* py_V423;
03732
03733 PyArrayObject* V423;
03734
03735 typedef npy_float64 dtype_V423;
03736
03737 PyObject* py_V425;
03738
03739 PyArrayObject* V425;
03740
03741 typedef npy_float64 dtype_V425;
03742
03743 PyObject* py_V427;
03744
03745 PyArrayObject* V427;
03746
03747 typedef npy_float64 dtype_V427;
03748
03749 PyObject* py_V429;
03750
03751 PyArrayObject* V429;
03752
03753 typedef npy_float64 dtype_V429;
03754
03755 PyObject* py_V431;
03756
03757 PyArrayObject* V431;
03758
03759 typedef npy_float64 dtype_V431;
03760
03761 PyObject* py_V433;
03762
03763 PyArrayObject* V433;
03764
03765 typedef npy_float64 dtype_V433;
03766
03767 PyObject* py_V435;
03768
03769 PyArrayObject* V435;
03770
03771 typedef npy_float64 dtype_V435;
03772
03773 PyObject* py_V437;
03774
03775 PyArrayObject* V437;
03776
03777 typedef npy_float64 dtype_V437;
03778
03779 PyObject* py_V439;
03780
03781 PyArrayObject* V439;
03782
03783 typedef npy_float64 dtype_V439;
03784
03785 PyObject* py_V441;
03786
03787 PyArrayObject* V441;
03788
03789 typedef npy_float64 dtype_V441;
03790
03791 PyObject* py_V443;
03792
03793 PyArrayObject* V443;
03794
03795 typedef npy_float64 dtype_V443;
03796
03797 PyObject* py_V445;
03798
03799 PyArrayObject* V445;
03800
03801 typedef npy_float64 dtype_V445;
03802
03803 PyObject* py_V447;
03804
03805 PyArrayObject* V447;
03806
03807 typedef npy_float64 dtype_V447;
03808
03809 PyObject* py_V449;
03810
03811 PyArrayObject* V449;
03812
03813 typedef npy_float64 dtype_V449;
03814
03815 PyObject* py_V451;
03816
03817 PyArrayObject* V451;
03818
03819 typedef npy_float64 dtype_V451;
03820
03821 PyObject* py_V453;
03822
03823 PyArrayObject* V453;
03824
03825 typedef npy_float64 dtype_V453;
03826
03827 PyObject* py_V455;
03828
03829 PyArrayObject* V455;
03830
03831 typedef npy_float64 dtype_V455;
03832
03833 PyObject* py_V457;
03834
03835 PyArrayObject* V457;
03836
03837 typedef npy_float64 dtype_V457;
03838
03839 PyObject* py_V459;
03840
03841 PyArrayObject* V459;
03842
03843 typedef npy_float64 dtype_V459;
03844
03845 PyObject* py_V461;
03846
03847 PyArrayObject* V461;
03848
03849 typedef npy_float64 dtype_V461;
03850
03851 PyObject* py_V463;
03852
03853 PyArrayObject* V463;
03854
03855 typedef npy_float64 dtype_V463;
03856
03857 PyObject* py_V465;
03858
03859 PyArrayObject* V465;
03860
03861 typedef npy_float64 dtype_V465;
03862
03863 PyObject* py_V467;
03864
03865 PyArrayObject* V467;
03866
03867 typedef npy_float64 dtype_V467;
03868
03869 PyObject* py_V469;
03870
03871 PyArrayObject* V469;
03872
03873 typedef npy_float64 dtype_V469;
03874
03875 PyObject* py_V471;
03876
03877 PyArrayObject* V471;
03878
03879 typedef npy_float64 dtype_V471;
03880
03881 PyObject* py_V473;
03882
03883 PyArrayObject* V473;
03884
03885 typedef npy_float64 dtype_V473;
03886
03887 PyObject* py_V475;
03888
03889 PyArrayObject* V475;
03890
03891 typedef npy_float64 dtype_V475;
03892
03893 PyObject* py_V477;
03894
03895 PyArrayObject* V477;
03896
03897 typedef npy_float64 dtype_V477;
03898
03899 PyObject* py_V479;
03900
03901 PyArrayObject* V479;
03902
03903 typedef npy_float64 dtype_V479;
03904
03905 PyObject* py_V481;
03906
03907 PyArrayObject* V481;
03908
03909 typedef npy_float64 dtype_V481;
03910
03911 PyObject* py_V483;
03912
03913 PyArrayObject* V483;
03914
03915 typedef npy_float64 dtype_V483;
03916
03917 PyObject* py_V485;
03918
03919 PyArrayObject* V485;
03920
03921 typedef npy_float64 dtype_V485;
03922
03923 PyObject* py_V487;
03924
03925 PyArrayObject* V487;
03926
03927 typedef npy_float64 dtype_V487;
03928
03929 PyObject* py_V489;
03930
03931 PyArrayObject* V489;
03932
03933 typedef npy_float64 dtype_V489;
03934
03935 PyObject* py_V491;
03936
03937 PyArrayObject* V491;
03938
03939 typedef npy_float64 dtype_V491;
03940
03941 PyObject* py_V493;
03942
03943 PyArrayObject* V493;
03944
03945 typedef npy_float64 dtype_V493;
03946
03947 PyObject* py_V495;
03948
03949 PyArrayObject* V495;
03950
03951 typedef npy_float64 dtype_V495;
03952
03953 PyObject* py_V497;
03954
03955 PyArrayObject* V497;
03956
03957 typedef npy_float64 dtype_V497;
03958
03959 PyObject* py_V499;
03960
03961 PyArrayObject* V499;
03962
03963 typedef npy_float64 dtype_V499;
03964
03965 PyObject* py_V501;
03966
03967 PyArrayObject* V501;
03968
03969 typedef npy_float64 dtype_V501;
03970
03971 PyObject* py_V503;
03972
03973 PyArrayObject* V503;
03974
03975 typedef npy_float64 dtype_V503;
03976
03977 PyObject* py_V505;
03978
03979 PyArrayObject* V505;
03980
03981 typedef npy_float64 dtype_V505;
03982
03983 PyObject* py_V507;
03984
03985 PyArrayObject* V507;
03986
03987 typedef npy_float64 dtype_V507;
03988
03989 PyObject* py_V509;
03990
03991 PyArrayObject* V509;
03992
03993 typedef npy_float64 dtype_V509;
03994
03995 PyObject* py_V511;
03996
03997 PyArrayObject* V511;
03998
03999 typedef npy_float64 dtype_V511;
04000
04001 PyObject* py_V513;
04002
04003 PyArrayObject* V513;
04004
04005 typedef npy_float64 dtype_V513;
04006
04007 PyObject* py_V515;
04008
04009 PyArrayObject* V515;
04010
04011 typedef npy_float64 dtype_V515;
04012
04013 PyObject* py_V517;
04014
04015 PyArrayObject* V517;
04016
04017 typedef npy_float64 dtype_V517;
04018
04019 PyObject* py_V519;
04020
04021 PyArrayObject* V519;
04022
04023 typedef npy_float64 dtype_V519;
04024
04025 PyObject* py_V521;
04026
04027 PyArrayObject* V521;
04028
04029 typedef npy_float64 dtype_V521;
04030
04031 PyObject* py_V523;
04032
04033 PyArrayObject* V523;
04034
04035 typedef npy_float64 dtype_V523;
04036
04037 PyObject* py_V525;
04038
04039 PyArrayObject* V525;
04040
04041 typedef npy_float64 dtype_V525;
04042
04043 PyObject* py_V527;
04044
04045 PyArrayObject* V527;
04046
04047 typedef npy_float64 dtype_V527;
04048
04049 PyObject* py_V529;
04050
04051 PyArrayObject* V529;
04052
04053 typedef npy_float64 dtype_V529;
04054
04055 PyObject* py_V531;
04056
04057 PyArrayObject* V531;
04058
04059 typedef npy_float64 dtype_V531;
04060
04061 PyObject* py_V533;
04062
04063 PyArrayObject* V533;
04064
04065 typedef npy_float64 dtype_V533;
04066
04067 PyObject* py_V535;
04068
04069 PyArrayObject* V535;
04070
04071 typedef npy_float64 dtype_V535;
04072
04073 PyObject* py_V537;
04074
04075 PyArrayObject* V537;
04076
04077 typedef npy_float64 dtype_V537;
04078
04079 PyObject* py_V539;
04080
04081 PyArrayObject* V539;
04082
04083 typedef npy_float64 dtype_V539;
04084
04085 PyObject* py_V541;
04086
04087 PyArrayObject* V541;
04088
04089 typedef npy_float64 dtype_V541;
04090
04091 PyObject* py_V543;
04092
04093 PyArrayObject* V543;
04094
04095 typedef npy_float64 dtype_V543;
04096
04097 PyObject* py_V545;
04098
04099 PyArrayObject* V545;
04100
04101 typedef npy_float64 dtype_V545;
04102
04103 PyObject* py_V547;
04104
04105 PyArrayObject* V547;
04106
04107 typedef npy_float64 dtype_V547;
04108
04109 PyObject* py_V549;
04110
04111 PyArrayObject* V549;
04112
04113 typedef npy_float64 dtype_V549;
04114
04115 PyObject* py_V551;
04116
04117 PyArrayObject* V551;
04118
04119 typedef npy_float64 dtype_V551;
04120
04121 PyObject* py_V553;
04122
04123 PyArrayObject* V553;
04124
04125 typedef npy_float64 dtype_V553;
04126
04127 PyObject* py_V555;
04128
04129 PyArrayObject* V555;
04130
04131 typedef npy_float64 dtype_V555;
04132
04133 PyObject* py_V557;
04134
04135 PyArrayObject* V557;
04136
04137 typedef npy_float64 dtype_V557;
04138
04139 PyObject* py_V559;
04140
04141 PyArrayObject* V559;
04142
04143 typedef npy_float64 dtype_V559;
04144
04145 PyObject* py_V561;
04146
04147 PyArrayObject* V561;
04148
04149 typedef npy_float64 dtype_V561;
04150
04151 PyObject* py_V563;
04152
04153 PyArrayObject* V563;
04154
04155 typedef npy_float64 dtype_V563;
04156
04157 PyObject* py_V565;
04158
04159 PyArrayObject* V565;
04160
04161 typedef npy_float64 dtype_V565;
04162
04163 PyObject* py_V567;
04164
04165 PyArrayObject* V567;
04166
04167 typedef npy_float64 dtype_V567;
04168
04169 PyObject* py_V569;
04170
04171 PyArrayObject* V569;
04172
04173 typedef npy_float64 dtype_V569;
04174
04175 PyObject* py_V571;
04176
04177 PyArrayObject* V571;
04178
04179 typedef npy_float64 dtype_V571;
04180
04181 PyObject* py_V573;
04182
04183 PyArrayObject* V573;
04184
04185 typedef npy_float64 dtype_V573;
04186
04187 PyObject* py_V575;
04188
04189 PyArrayObject* V575;
04190
04191 typedef npy_float64 dtype_V575;
04192
04193 PyObject* py_V577;
04194
04195 PyArrayObject* V577;
04196
04197 typedef npy_float64 dtype_V577;
04198
04199 PyObject* py_V579;
04200
04201 PyArrayObject* V579;
04202
04203 typedef npy_float64 dtype_V579;
04204
04205 PyObject* py_V581;
04206
04207 PyArrayObject* V581;
04208
04209 typedef npy_float64 dtype_V581;
04210
04211 PyObject* py_V583;
04212
04213 PyArrayObject* V583;
04214
04215 typedef npy_float64 dtype_V583;
04216
04217 PyObject* py_V585;
04218
04219 PyArrayObject* V585;
04220
04221 typedef npy_float64 dtype_V585;
04222
04223 PyObject* py_V587;
04224
04225 PyArrayObject* V587;
04226
04227 typedef npy_float64 dtype_V587;
04228
04229 PyObject* py_V589;
04230
04231 PyArrayObject* V589;
04232
04233 typedef npy_float64 dtype_V589;
04234
04235 PyObject* py_V591;
04236
04237 PyArrayObject* V591;
04238
04239 typedef npy_float64 dtype_V591;
04240
04241 PyObject* py_V593;
04242
04243 PyArrayObject* V593;
04244
04245 typedef npy_float64 dtype_V593;
04246
04247 PyObject* py_V595;
04248
04249 PyArrayObject* V595;
04250
04251 typedef npy_float64 dtype_V595;
04252
04253 PyObject* py_V597;
04254
04255 PyArrayObject* V597;
04256
04257 typedef npy_float64 dtype_V597;
04258
04259 PyObject* py_V599;
04260
04261 PyArrayObject* V599;
04262
04263 typedef npy_float64 dtype_V599;
04264
04265 PyObject* py_V601;
04266
04267 PyArrayObject* V601;
04268
04269 typedef npy_float64 dtype_V601;
04270
04271 PyObject* py_V603;
04272
04273 PyArrayObject* V603;
04274
04275 typedef npy_float64 dtype_V603;
04276
04277 {
04278
04279 py_V1 = PyList_GET_ITEM(storage_V1, 0);
04280 {Py_XINCREF(py_V1);}
04281
04282 if (py_V1 == Py_None)
04283 {
04284
04285 V1 = NULL;
04286
04287 }
04288 else
04289 {
04290
04291 V1 = NULL;
04292 if (py_V1 == Py_None) {
04293 // We can either fail here or set V1 to NULL and rely on Ops
04294 // using tensors to handle the NULL case, but if they fail to do so
04295 // they'll end up with nasty segfaults, so this is public service.
04296 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
04297 {
04298 __failure = 2;
04299 if (!PyErr_Occurred()) {
04300 PyErr_SetString(PyExc_RuntimeError,
04301 "Unexpected error in an Op's C code. "
04302 "No Python exception was set.");
04303 }
04304 goto __label_2;}
04305 }
04306 if (!PyArray_Check(py_V1)) {
04307 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
04308 {
04309 __failure = 2;
04310 if (!PyErr_Occurred()) {
04311 PyErr_SetString(PyExc_RuntimeError,
04312 "Unexpected error in an Op's C code. "
04313 "No Python exception was set.");
04314 }
04315 goto __label_2;}
04316 }
04317 // We expect NPY_FLOAT64
04318 if (!PyArray_ISALIGNED((PyArrayObject*) py_V1)) {
04319 PyArrayObject * tmp = (PyArrayObject*) py_V1;
04320 PyErr_Format(PyExc_NotImplementedError,
04321 "expected an aligned array of type %ld "
04322 "(NPY_FLOAT64), got non-aligned array of type %ld"
04323 " with %ld dimensions, with 3 last dims "
04324 "%ld, %ld, %ld"
04325 " and 3 last strides %ld %ld, %ld.",
04326 (long int) NPY_FLOAT64,
04327 (long int) PyArray_TYPE((PyArrayObject*) py_V1),
04328 (long int) PyArray_NDIM(tmp),
04329 (long int) (PyArray_NDIM(tmp) >= 3 ?
04330 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
04331 (long int) (PyArray_NDIM(tmp) >= 2 ?
04332 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
04333 (long int) (PyArray_NDIM(tmp) >= 1 ?
04334 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
04335 (long int) (PyArray_NDIM(tmp) >= 3 ?
04336 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
04337 (long int) (PyArray_NDIM(tmp) >= 2 ?
04338 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
04339 (long int) (PyArray_NDIM(tmp) >= 1 ?
04340 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
04341 );
04342 {
04343 __failure = 2;
04344 if (!PyErr_Occurred()) {
04345 PyErr_SetString(PyExc_RuntimeError,
04346 "Unexpected error in an Op's C code. "
04347 "No Python exception was set.");
04348 }
04349 goto __label_2;}
04350 }
04351 // This is a TypeError to be consistent with DEBUG_MODE
04352 // Note: DEBUG_MODE also tells the name of the container
04353 if (PyArray_TYPE((PyArrayObject*) py_V1) != NPY_FLOAT64) {
04354 PyErr_Format(PyExc_TypeError,
04355 "expected type_num %d (NPY_FLOAT64) got %d",
04356 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V1));
04357 {
04358 __failure = 2;
04359 if (!PyErr_Occurred()) {
04360 PyErr_SetString(PyExc_RuntimeError,
04361 "Unexpected error in an Op's C code. "
04362 "No Python exception was set.");
04363 }
04364 goto __label_2;}
04365 }
04366
04367 V1 = (PyArrayObject*)(py_V1);
04368 Py_XINCREF(V1);
04369
04370 }
04371
04372 {
04373
04374 py_V3 = PyList_GET_ITEM(storage_V3, 0);
04375 {Py_XINCREF(py_V3);}
04376
04377 V3 = NULL;
04378 if (py_V3 == Py_None) {
04379 // We can either fail here or set V3 to NULL and rely on Ops
04380 // using tensors to handle the NULL case, but if they fail to do so
04381 // they'll end up with nasty segfaults, so this is public service.
04382 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
04383 {
04384 __failure = 4;
04385 if (!PyErr_Occurred()) {
04386 PyErr_SetString(PyExc_RuntimeError,
04387 "Unexpected error in an Op's C code. "
04388 "No Python exception was set.");
04389 }
04390 goto __label_4;}
04391 }
04392 if (!PyArray_Check(py_V3)) {
04393 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
04394 {
04395 __failure = 4;
04396 if (!PyErr_Occurred()) {
04397 PyErr_SetString(PyExc_RuntimeError,
04398 "Unexpected error in an Op's C code. "
04399 "No Python exception was set.");
04400 }
04401 goto __label_4;}
04402 }
04403 // We expect NPY_FLOAT64
04404 if (!PyArray_ISALIGNED((PyArrayObject*) py_V3)) {
04405 PyArrayObject * tmp = (PyArrayObject*) py_V3;
04406 PyErr_Format(PyExc_NotImplementedError,
04407 "expected an aligned array of type %ld "
04408 "(NPY_FLOAT64), got non-aligned array of type %ld"
04409 " with %ld dimensions, with 3 last dims "
04410 "%ld, %ld, %ld"
04411 " and 3 last strides %ld %ld, %ld.",
04412 (long int) NPY_FLOAT64,
04413 (long int) PyArray_TYPE((PyArrayObject*) py_V3),
04414 (long int) PyArray_NDIM(tmp),
04415 (long int) (PyArray_NDIM(tmp) >= 3 ?
04416 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
04417 (long int) (PyArray_NDIM(tmp) >= 2 ?
04418 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
04419 (long int) (PyArray_NDIM(tmp) >= 1 ?
04420 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
04421 (long int) (PyArray_NDIM(tmp) >= 3 ?
04422 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
04423 (long int) (PyArray_NDIM(tmp) >= 2 ?
04424 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
04425 (long int) (PyArray_NDIM(tmp) >= 1 ?
04426 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
04427 );
04428 {
04429 __failure = 4;
04430 if (!PyErr_Occurred()) {
04431 PyErr_SetString(PyExc_RuntimeError,
04432 "Unexpected error in an Op's C code. "
04433 "No Python exception was set.");
04434 }
04435 goto __label_4;}
04436 }
04437 // This is a TypeError to be consistent with DEBUG_MODE
04438 // Note: DEBUG_MODE also tells the name of the container
04439 if (PyArray_TYPE((PyArrayObject*) py_V3) != NPY_FLOAT64) {
04440 PyErr_Format(PyExc_TypeError,
04441 "expected type_num %d (NPY_FLOAT64) got %d",
04442 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V3));
04443 {
04444 __failure = 4;
04445 if (!PyErr_Occurred()) {
04446 PyErr_SetString(PyExc_RuntimeError,
04447 "Unexpected error in an Op's C code. "
04448 "No Python exception was set.");
04449 }
04450 goto __label_4;}
04451 }
04452
04453 V3 = (PyArrayObject*)(py_V3);
04454 Py_XINCREF(V3);
04455
04456 {
04457
04458 py_V5 = PyList_GET_ITEM(storage_V5, 0);
04459 {Py_XINCREF(py_V5);}
04460
04461 V5 = NULL;
04462 if (py_V5 == Py_None) {
04463 // We can either fail here or set V5 to NULL and rely on Ops
04464 // using tensors to handle the NULL case, but if they fail to do so
04465 // they'll end up with nasty segfaults, so this is public service.
04466 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
04467 {
04468 __failure = 6;
04469 if (!PyErr_Occurred()) {
04470 PyErr_SetString(PyExc_RuntimeError,
04471 "Unexpected error in an Op's C code. "
04472 "No Python exception was set.");
04473 }
04474 goto __label_6;}
04475 }
04476 if (!PyArray_Check(py_V5)) {
04477 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
04478 {
04479 __failure = 6;
04480 if (!PyErr_Occurred()) {
04481 PyErr_SetString(PyExc_RuntimeError,
04482 "Unexpected error in an Op's C code. "
04483 "No Python exception was set.");
04484 }
04485 goto __label_6;}
04486 }
04487 // We expect NPY_FLOAT64
04488 if (!PyArray_ISALIGNED((PyArrayObject*) py_V5)) {
04489 PyArrayObject * tmp = (PyArrayObject*) py_V5;
04490 PyErr_Format(PyExc_NotImplementedError,
04491 "expected an aligned array of type %ld "
04492 "(NPY_FLOAT64), got non-aligned array of type %ld"
04493 " with %ld dimensions, with 3 last dims "
04494 "%ld, %ld, %ld"
04495 " and 3 last strides %ld %ld, %ld.",
04496 (long int) NPY_FLOAT64,
04497 (long int) PyArray_TYPE((PyArrayObject*) py_V5),
04498 (long int) PyArray_NDIM(tmp),
04499 (long int) (PyArray_NDIM(tmp) >= 3 ?
04500 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
04501 (long int) (PyArray_NDIM(tmp) >= 2 ?
04502 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
04503 (long int) (PyArray_NDIM(tmp) >= 1 ?
04504 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
04505 (long int) (PyArray_NDIM(tmp) >= 3 ?
04506 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
04507 (long int) (PyArray_NDIM(tmp) >= 2 ?
04508 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
04509 (long int) (PyArray_NDIM(tmp) >= 1 ?
04510 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
04511 );
04512 {
04513 __failure = 6;
04514 if (!PyErr_Occurred()) {
04515 PyErr_SetString(PyExc_RuntimeError,
04516 "Unexpected error in an Op's C code. "
04517 "No Python exception was set.");
04518 }
04519 goto __label_6;}
04520 }
04521 // This is a TypeError to be consistent with DEBUG_MODE
04522 // Note: DEBUG_MODE also tells the name of the container
04523 if (PyArray_TYPE((PyArrayObject*) py_V5) != NPY_FLOAT64) {
04524 PyErr_Format(PyExc_TypeError,
04525 "expected type_num %d (NPY_FLOAT64) got %d",
04526 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V5));
04527 {
04528 __failure = 6;
04529 if (!PyErr_Occurred()) {
04530 PyErr_SetString(PyExc_RuntimeError,
04531 "Unexpected error in an Op's C code. "
04532 "No Python exception was set.");
04533 }
04534 goto __label_6;}
04535 }
04536
04537 V5 = (PyArrayObject*)(py_V5);
04538 Py_XINCREF(V5);
04539
04540 {
04541
04542 py_V7 = PyList_GET_ITEM(storage_V7, 0);
04543 {Py_XINCREF(py_V7);}
04544
04545 V7 = NULL;
04546 if (py_V7 == Py_None) {
04547 // We can either fail here or set V7 to NULL and rely on Ops
04548 // using tensors to handle the NULL case, but if they fail to do so
04549 // they'll end up with nasty segfaults, so this is public service.
04550 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
04551 {
04552 __failure = 8;
04553 if (!PyErr_Occurred()) {
04554 PyErr_SetString(PyExc_RuntimeError,
04555 "Unexpected error in an Op's C code. "
04556 "No Python exception was set.");
04557 }
04558 goto __label_8;}
04559 }
04560 if (!PyArray_Check(py_V7)) {
04561 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
04562 {
04563 __failure = 8;
04564 if (!PyErr_Occurred()) {
04565 PyErr_SetString(PyExc_RuntimeError,
04566 "Unexpected error in an Op's C code. "
04567 "No Python exception was set.");
04568 }
04569 goto __label_8;}
04570 }
04571 // We expect NPY_FLOAT64
04572 if (!PyArray_ISALIGNED((PyArrayObject*) py_V7)) {
04573 PyArrayObject * tmp = (PyArrayObject*) py_V7;
04574 PyErr_Format(PyExc_NotImplementedError,
04575 "expected an aligned array of type %ld "
04576 "(NPY_FLOAT64), got non-aligned array of type %ld"
04577 " with %ld dimensions, with 3 last dims "
04578 "%ld, %ld, %ld"
04579 " and 3 last strides %ld %ld, %ld.",
04580 (long int) NPY_FLOAT64,
04581 (long int) PyArray_TYPE((PyArrayObject*) py_V7),
04582 (long int) PyArray_NDIM(tmp),
04583 (long int) (PyArray_NDIM(tmp) >= 3 ?
04584 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
04585 (long int) (PyArray_NDIM(tmp) >= 2 ?
04586 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
04587 (long int) (PyArray_NDIM(tmp) >= 1 ?
04588 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
04589 (long int) (PyArray_NDIM(tmp) >= 3 ?
04590 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
04591 (long int) (PyArray_NDIM(tmp) >= 2 ?
04592 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
04593 (long int) (PyArray_NDIM(tmp) >= 1 ?
04594 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
04595 );
04596 {
04597 __failure = 8;
04598 if (!PyErr_Occurred()) {
04599 PyErr_SetString(PyExc_RuntimeError,
04600 "Unexpected error in an Op's C code. "
04601 "No Python exception was set.");
04602 }
04603 goto __label_8;}
04604 }
04605 // This is a TypeError to be consistent with DEBUG_MODE
04606 // Note: DEBUG_MODE also tells the name of the container
04607 if (PyArray_TYPE((PyArrayObject*) py_V7) != NPY_FLOAT64) {
04608 PyErr_Format(PyExc_TypeError,
04609 "expected type_num %d (NPY_FLOAT64) got %d",
04610 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V7));
04611 {
04612 __failure = 8;
04613 if (!PyErr_Occurred()) {
04614 PyErr_SetString(PyExc_RuntimeError,
04615 "Unexpected error in an Op's C code. "
04616 "No Python exception was set.");
04617 }
04618 goto __label_8;}
04619 }
04620
04621 V7 = (PyArrayObject*)(py_V7);
04622 Py_XINCREF(V7);
04623
04624 {
04625
04626 py_V9 = PyList_GET_ITEM(storage_V9, 0);
04627 {Py_XINCREF(py_V9);}
04628
04629 V9 = NULL;
04630 if (py_V9 == Py_None) {
04631 // We can either fail here or set V9 to NULL and rely on Ops
04632 // using tensors to handle the NULL case, but if they fail to do so
04633 // they'll end up with nasty segfaults, so this is public service.
04634 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
04635 {
04636 __failure = 10;
04637 if (!PyErr_Occurred()) {
04638 PyErr_SetString(PyExc_RuntimeError,
04639 "Unexpected error in an Op's C code. "
04640 "No Python exception was set.");
04641 }
04642 goto __label_10;}
04643 }
04644 if (!PyArray_Check(py_V9)) {
04645 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
04646 {
04647 __failure = 10;
04648 if (!PyErr_Occurred()) {
04649 PyErr_SetString(PyExc_RuntimeError,
04650 "Unexpected error in an Op's C code. "
04651 "No Python exception was set.");
04652 }
04653 goto __label_10;}
04654 }
04655 // We expect NPY_FLOAT64
04656 if (!PyArray_ISALIGNED((PyArrayObject*) py_V9)) {
04657 PyArrayObject * tmp = (PyArrayObject*) py_V9;
04658 PyErr_Format(PyExc_NotImplementedError,
04659 "expected an aligned array of type %ld "
04660 "(NPY_FLOAT64), got non-aligned array of type %ld"
04661 " with %ld dimensions, with 3 last dims "
04662 "%ld, %ld, %ld"
04663 " and 3 last strides %ld %ld, %ld.",
04664 (long int) NPY_FLOAT64,
04665 (long int) PyArray_TYPE((PyArrayObject*) py_V9),
04666 (long int) PyArray_NDIM(tmp),
04667 (long int) (PyArray_NDIM(tmp) >= 3 ?
04668 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
04669 (long int) (PyArray_NDIM(tmp) >= 2 ?
04670 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
04671 (long int) (PyArray_NDIM(tmp) >= 1 ?
04672 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
04673 (long int) (PyArray_NDIM(tmp) >= 3 ?
04674 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
04675 (long int) (PyArray_NDIM(tmp) >= 2 ?
04676 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
04677 (long int) (PyArray_NDIM(tmp) >= 1 ?
04678 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
04679 );
04680 {
04681 __failure = 10;
04682 if (!PyErr_Occurred()) {
04683 PyErr_SetString(PyExc_RuntimeError,
04684 "Unexpected error in an Op's C code. "
04685 "No Python exception was set.");
04686 }
04687 goto __label_10;}
04688 }
04689 // This is a TypeError to be consistent with DEBUG_MODE
04690 // Note: DEBUG_MODE also tells the name of the container
04691 if (PyArray_TYPE((PyArrayObject*) py_V9) != NPY_FLOAT64) {
04692 PyErr_Format(PyExc_TypeError,
04693 "expected type_num %d (NPY_FLOAT64) got %d",
04694 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V9));
04695 {
04696 __failure = 10;
04697 if (!PyErr_Occurred()) {
04698 PyErr_SetString(PyExc_RuntimeError,
04699 "Unexpected error in an Op's C code. "
04700 "No Python exception was set.");
04701 }
04702 goto __label_10;}
04703 }
04704
04705 V9 = (PyArrayObject*)(py_V9);
04706 Py_XINCREF(V9);
04707
04708 {
04709
04710 py_V11 = PyList_GET_ITEM(storage_V11, 0);
04711 {Py_XINCREF(py_V11);}
04712
04713 V11 = NULL;
04714 if (py_V11 == Py_None) {
04715 // We can either fail here or set V11 to NULL and rely on Ops
04716 // using tensors to handle the NULL case, but if they fail to do so
04717 // they'll end up with nasty segfaults, so this is public service.
04718 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
04719 {
04720 __failure = 12;
04721 if (!PyErr_Occurred()) {
04722 PyErr_SetString(PyExc_RuntimeError,
04723 "Unexpected error in an Op's C code. "
04724 "No Python exception was set.");
04725 }
04726 goto __label_12;}
04727 }
04728 if (!PyArray_Check(py_V11)) {
04729 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
04730 {
04731 __failure = 12;
04732 if (!PyErr_Occurred()) {
04733 PyErr_SetString(PyExc_RuntimeError,
04734 "Unexpected error in an Op's C code. "
04735 "No Python exception was set.");
04736 }
04737 goto __label_12;}
04738 }
04739 // We expect NPY_FLOAT64
04740 if (!PyArray_ISALIGNED((PyArrayObject*) py_V11)) {
04741 PyArrayObject * tmp = (PyArrayObject*) py_V11;
04742 PyErr_Format(PyExc_NotImplementedError,
04743 "expected an aligned array of type %ld "
04744 "(NPY_FLOAT64), got non-aligned array of type %ld"
04745 " with %ld dimensions, with 3 last dims "
04746 "%ld, %ld, %ld"
04747 " and 3 last strides %ld %ld, %ld.",
04748 (long int) NPY_FLOAT64,
04749 (long int) PyArray_TYPE((PyArrayObject*) py_V11),
04750 (long int) PyArray_NDIM(tmp),
04751 (long int) (PyArray_NDIM(tmp) >= 3 ?
04752 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
04753 (long int) (PyArray_NDIM(tmp) >= 2 ?
04754 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
04755 (long int) (PyArray_NDIM(tmp) >= 1 ?
04756 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
04757 (long int) (PyArray_NDIM(tmp) >= 3 ?
04758 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
04759 (long int) (PyArray_NDIM(tmp) >= 2 ?
04760 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
04761 (long int) (PyArray_NDIM(tmp) >= 1 ?
04762 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
04763 );
04764 {
04765 __failure = 12;
04766 if (!PyErr_Occurred()) {
04767 PyErr_SetString(PyExc_RuntimeError,
04768 "Unexpected error in an Op's C code. "
04769 "No Python exception was set.");
04770 }
04771 goto __label_12;}
04772 }
04773 // This is a TypeError to be consistent with DEBUG_MODE
04774 // Note: DEBUG_MODE also tells the name of the container
04775 if (PyArray_TYPE((PyArrayObject*) py_V11) != NPY_FLOAT64) {
04776 PyErr_Format(PyExc_TypeError,
04777 "expected type_num %d (NPY_FLOAT64) got %d",
04778 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V11));
04779 {
04780 __failure = 12;
04781 if (!PyErr_Occurred()) {
04782 PyErr_SetString(PyExc_RuntimeError,
04783 "Unexpected error in an Op's C code. "
04784 "No Python exception was set.");
04785 }
04786 goto __label_12;}
04787 }
04788
04789 V11 = (PyArrayObject*)(py_V11);
04790 Py_XINCREF(V11);
04791
04792 {
04793
04794 py_V13 = PyList_GET_ITEM(storage_V13, 0);
04795 {Py_XINCREF(py_V13);}
04796
04797 V13 = NULL;
04798 if (py_V13 == Py_None) {
04799 // We can either fail here or set V13 to NULL and rely on Ops
04800 // using tensors to handle the NULL case, but if they fail to do so
04801 // they'll end up with nasty segfaults, so this is public service.
04802 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
04803 {
04804 __failure = 14;
04805 if (!PyErr_Occurred()) {
04806 PyErr_SetString(PyExc_RuntimeError,
04807 "Unexpected error in an Op's C code. "
04808 "No Python exception was set.");
04809 }
04810 goto __label_14;}
04811 }
04812 if (!PyArray_Check(py_V13)) {
04813 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
04814 {
04815 __failure = 14;
04816 if (!PyErr_Occurred()) {
04817 PyErr_SetString(PyExc_RuntimeError,
04818 "Unexpected error in an Op's C code. "
04819 "No Python exception was set.");
04820 }
04821 goto __label_14;}
04822 }
04823 // We expect NPY_FLOAT64
04824 if (!PyArray_ISALIGNED((PyArrayObject*) py_V13)) {
04825 PyArrayObject * tmp = (PyArrayObject*) py_V13;
04826 PyErr_Format(PyExc_NotImplementedError,
04827 "expected an aligned array of type %ld "
04828 "(NPY_FLOAT64), got non-aligned array of type %ld"
04829 " with %ld dimensions, with 3 last dims "
04830 "%ld, %ld, %ld"
04831 " and 3 last strides %ld %ld, %ld.",
04832 (long int) NPY_FLOAT64,
04833 (long int) PyArray_TYPE((PyArrayObject*) py_V13),
04834 (long int) PyArray_NDIM(tmp),
04835 (long int) (PyArray_NDIM(tmp) >= 3 ?
04836 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
04837 (long int) (PyArray_NDIM(tmp) >= 2 ?
04838 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
04839 (long int) (PyArray_NDIM(tmp) >= 1 ?
04840 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
04841 (long int) (PyArray_NDIM(tmp) >= 3 ?
04842 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
04843 (long int) (PyArray_NDIM(tmp) >= 2 ?
04844 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
04845 (long int) (PyArray_NDIM(tmp) >= 1 ?
04846 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
04847 );
04848 {
04849 __failure = 14;
04850 if (!PyErr_Occurred()) {
04851 PyErr_SetString(PyExc_RuntimeError,
04852 "Unexpected error in an Op's C code. "
04853 "No Python exception was set.");
04854 }
04855 goto __label_14;}
04856 }
04857 // This is a TypeError to be consistent with DEBUG_MODE
04858 // Note: DEBUG_MODE also tells the name of the container
04859 if (PyArray_TYPE((PyArrayObject*) py_V13) != NPY_FLOAT64) {
04860 PyErr_Format(PyExc_TypeError,
04861 "expected type_num %d (NPY_FLOAT64) got %d",
04862 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V13));
04863 {
04864 __failure = 14;
04865 if (!PyErr_Occurred()) {
04866 PyErr_SetString(PyExc_RuntimeError,
04867 "Unexpected error in an Op's C code. "
04868 "No Python exception was set.");
04869 }
04870 goto __label_14;}
04871 }
04872
04873 V13 = (PyArrayObject*)(py_V13);
04874 Py_XINCREF(V13);
04875
04876 {
04877
04878 py_V15 = PyList_GET_ITEM(storage_V15, 0);
04879 {Py_XINCREF(py_V15);}
04880
04881 V15 = NULL;
04882 if (py_V15 == Py_None) {
04883 // We can either fail here or set V15 to NULL and rely on Ops
04884 // using tensors to handle the NULL case, but if they fail to do so
04885 // they'll end up with nasty segfaults, so this is public service.
04886 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
04887 {
04888 __failure = 16;
04889 if (!PyErr_Occurred()) {
04890 PyErr_SetString(PyExc_RuntimeError,
04891 "Unexpected error in an Op's C code. "
04892 "No Python exception was set.");
04893 }
04894 goto __label_16;}
04895 }
04896 if (!PyArray_Check(py_V15)) {
04897 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
04898 {
04899 __failure = 16;
04900 if (!PyErr_Occurred()) {
04901 PyErr_SetString(PyExc_RuntimeError,
04902 "Unexpected error in an Op's C code. "
04903 "No Python exception was set.");
04904 }
04905 goto __label_16;}
04906 }
04907 // We expect NPY_FLOAT64
04908 if (!PyArray_ISALIGNED((PyArrayObject*) py_V15)) {
04909 PyArrayObject * tmp = (PyArrayObject*) py_V15;
04910 PyErr_Format(PyExc_NotImplementedError,
04911 "expected an aligned array of type %ld "
04912 "(NPY_FLOAT64), got non-aligned array of type %ld"
04913 " with %ld dimensions, with 3 last dims "
04914 "%ld, %ld, %ld"
04915 " and 3 last strides %ld %ld, %ld.",
04916 (long int) NPY_FLOAT64,
04917 (long int) PyArray_TYPE((PyArrayObject*) py_V15),
04918 (long int) PyArray_NDIM(tmp),
04919 (long int) (PyArray_NDIM(tmp) >= 3 ?
04920 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
04921 (long int) (PyArray_NDIM(tmp) >= 2 ?
04922 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
04923 (long int) (PyArray_NDIM(tmp) >= 1 ?
04924 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
04925 (long int) (PyArray_NDIM(tmp) >= 3 ?
04926 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
04927 (long int) (PyArray_NDIM(tmp) >= 2 ?
04928 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
04929 (long int) (PyArray_NDIM(tmp) >= 1 ?
04930 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
04931 );
04932 {
04933 __failure = 16;
04934 if (!PyErr_Occurred()) {
04935 PyErr_SetString(PyExc_RuntimeError,
04936 "Unexpected error in an Op's C code. "
04937 "No Python exception was set.");
04938 }
04939 goto __label_16;}
04940 }
04941 // This is a TypeError to be consistent with DEBUG_MODE
04942 // Note: DEBUG_MODE also tells the name of the container
04943 if (PyArray_TYPE((PyArrayObject*) py_V15) != NPY_FLOAT64) {
04944 PyErr_Format(PyExc_TypeError,
04945 "expected type_num %d (NPY_FLOAT64) got %d",
04946 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V15));
04947 {
04948 __failure = 16;
04949 if (!PyErr_Occurred()) {
04950 PyErr_SetString(PyExc_RuntimeError,
04951 "Unexpected error in an Op's C code. "
04952 "No Python exception was set.");
04953 }
04954 goto __label_16;}
04955 }
04956
04957 V15 = (PyArrayObject*)(py_V15);
04958 Py_XINCREF(V15);
04959
04960 {
04961
04962 py_V17 = PyList_GET_ITEM(storage_V17, 0);
04963 {Py_XINCREF(py_V17);}
04964
04965 V17 = NULL;
04966 if (py_V17 == Py_None) {
04967 // We can either fail here or set V17 to NULL and rely on Ops
04968 // using tensors to handle the NULL case, but if they fail to do so
04969 // they'll end up with nasty segfaults, so this is public service.
04970 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
04971 {
04972 __failure = 18;
04973 if (!PyErr_Occurred()) {
04974 PyErr_SetString(PyExc_RuntimeError,
04975 "Unexpected error in an Op's C code. "
04976 "No Python exception was set.");
04977 }
04978 goto __label_18;}
04979 }
04980 if (!PyArray_Check(py_V17)) {
04981 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
04982 {
04983 __failure = 18;
04984 if (!PyErr_Occurred()) {
04985 PyErr_SetString(PyExc_RuntimeError,
04986 "Unexpected error in an Op's C code. "
04987 "No Python exception was set.");
04988 }
04989 goto __label_18;}
04990 }
04991 // We expect NPY_FLOAT64
04992 if (!PyArray_ISALIGNED((PyArrayObject*) py_V17)) {
04993 PyArrayObject * tmp = (PyArrayObject*) py_V17;
04994 PyErr_Format(PyExc_NotImplementedError,
04995 "expected an aligned array of type %ld "
04996 "(NPY_FLOAT64), got non-aligned array of type %ld"
04997 " with %ld dimensions, with 3 last dims "
04998 "%ld, %ld, %ld"
04999 " and 3 last strides %ld %ld, %ld.",
05000 (long int) NPY_FLOAT64,
05001 (long int) PyArray_TYPE((PyArrayObject*) py_V17),
05002 (long int) PyArray_NDIM(tmp),
05003 (long int) (PyArray_NDIM(tmp) >= 3 ?
05004 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
05005 (long int) (PyArray_NDIM(tmp) >= 2 ?
05006 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
05007 (long int) (PyArray_NDIM(tmp) >= 1 ?
05008 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
05009 (long int) (PyArray_NDIM(tmp) >= 3 ?
05010 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
05011 (long int) (PyArray_NDIM(tmp) >= 2 ?
05012 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
05013 (long int) (PyArray_NDIM(tmp) >= 1 ?
05014 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
05015 );
05016 {
05017 __failure = 18;
05018 if (!PyErr_Occurred()) {
05019 PyErr_SetString(PyExc_RuntimeError,
05020 "Unexpected error in an Op's C code. "
05021 "No Python exception was set.");
05022 }
05023 goto __label_18;}
05024 }
05025 // This is a TypeError to be consistent with DEBUG_MODE
05026 // Note: DEBUG_MODE also tells the name of the container
05027 if (PyArray_TYPE((PyArrayObject*) py_V17) != NPY_FLOAT64) {
05028 PyErr_Format(PyExc_TypeError,
05029 "expected type_num %d (NPY_FLOAT64) got %d",
05030 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V17));
05031 {
05032 __failure = 18;
05033 if (!PyErr_Occurred()) {
05034 PyErr_SetString(PyExc_RuntimeError,
05035 "Unexpected error in an Op's C code. "
05036 "No Python exception was set.");
05037 }
05038 goto __label_18;}
05039 }
05040
05041 V17 = (PyArrayObject*)(py_V17);
05042 Py_XINCREF(V17);
05043
05044 {
05045
05046 py_V19 = PyList_GET_ITEM(storage_V19, 0);
05047 {Py_XINCREF(py_V19);}
05048
05049 V19 = NULL;
05050 if (py_V19 == Py_None) {
05051 // We can either fail here or set V19 to NULL and rely on Ops
05052 // using tensors to handle the NULL case, but if they fail to do so
05053 // they'll end up with nasty segfaults, so this is public service.
05054 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
05055 {
05056 __failure = 20;
05057 if (!PyErr_Occurred()) {
05058 PyErr_SetString(PyExc_RuntimeError,
05059 "Unexpected error in an Op's C code. "
05060 "No Python exception was set.");
05061 }
05062 goto __label_20;}
05063 }
05064 if (!PyArray_Check(py_V19)) {
05065 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
05066 {
05067 __failure = 20;
05068 if (!PyErr_Occurred()) {
05069 PyErr_SetString(PyExc_RuntimeError,
05070 "Unexpected error in an Op's C code. "
05071 "No Python exception was set.");
05072 }
05073 goto __label_20;}
05074 }
05075 // We expect NPY_FLOAT64
05076 if (!PyArray_ISALIGNED((PyArrayObject*) py_V19)) {
05077 PyArrayObject * tmp = (PyArrayObject*) py_V19;
05078 PyErr_Format(PyExc_NotImplementedError,
05079 "expected an aligned array of type %ld "
05080 "(NPY_FLOAT64), got non-aligned array of type %ld"
05081 " with %ld dimensions, with 3 last dims "
05082 "%ld, %ld, %ld"
05083 " and 3 last strides %ld %ld, %ld.",
05084 (long int) NPY_FLOAT64,
05085 (long int) PyArray_TYPE((PyArrayObject*) py_V19),
05086 (long int) PyArray_NDIM(tmp),
05087 (long int) (PyArray_NDIM(tmp) >= 3 ?
05088 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
05089 (long int) (PyArray_NDIM(tmp) >= 2 ?
05090 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
05091 (long int) (PyArray_NDIM(tmp) >= 1 ?
05092 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
05093 (long int) (PyArray_NDIM(tmp) >= 3 ?
05094 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
05095 (long int) (PyArray_NDIM(tmp) >= 2 ?
05096 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
05097 (long int) (PyArray_NDIM(tmp) >= 1 ?
05098 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
05099 );
05100 {
05101 __failure = 20;
05102 if (!PyErr_Occurred()) {
05103 PyErr_SetString(PyExc_RuntimeError,
05104 "Unexpected error in an Op's C code. "
05105 "No Python exception was set.");
05106 }
05107 goto __label_20;}
05108 }
05109 // This is a TypeError to be consistent with DEBUG_MODE
05110 // Note: DEBUG_MODE also tells the name of the container
05111 if (PyArray_TYPE((PyArrayObject*) py_V19) != NPY_FLOAT64) {
05112 PyErr_Format(PyExc_TypeError,
05113 "expected type_num %d (NPY_FLOAT64) got %d",
05114 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V19));
05115 {
05116 __failure = 20;
05117 if (!PyErr_Occurred()) {
05118 PyErr_SetString(PyExc_RuntimeError,
05119 "Unexpected error in an Op's C code. "
05120 "No Python exception was set.");
05121 }
05122 goto __label_20;}
05123 }
05124
05125 V19 = (PyArrayObject*)(py_V19);
05126 Py_XINCREF(V19);
05127
05128 {
05129
05130 py_V21 = PyList_GET_ITEM(storage_V21, 0);
05131 {Py_XINCREF(py_V21);}
05132
05133 V21 = NULL;
05134 if (py_V21 == Py_None) {
05135 // We can either fail here or set V21 to NULL and rely on Ops
05136 // using tensors to handle the NULL case, but if they fail to do so
05137 // they'll end up with nasty segfaults, so this is public service.
05138 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
05139 {
05140 __failure = 22;
05141 if (!PyErr_Occurred()) {
05142 PyErr_SetString(PyExc_RuntimeError,
05143 "Unexpected error in an Op's C code. "
05144 "No Python exception was set.");
05145 }
05146 goto __label_22;}
05147 }
05148 if (!PyArray_Check(py_V21)) {
05149 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
05150 {
05151 __failure = 22;
05152 if (!PyErr_Occurred()) {
05153 PyErr_SetString(PyExc_RuntimeError,
05154 "Unexpected error in an Op's C code. "
05155 "No Python exception was set.");
05156 }
05157 goto __label_22;}
05158 }
05159 // We expect NPY_FLOAT64
05160 if (!PyArray_ISALIGNED((PyArrayObject*) py_V21)) {
05161 PyArrayObject * tmp = (PyArrayObject*) py_V21;
05162 PyErr_Format(PyExc_NotImplementedError,
05163 "expected an aligned array of type %ld "
05164 "(NPY_FLOAT64), got non-aligned array of type %ld"
05165 " with %ld dimensions, with 3 last dims "
05166 "%ld, %ld, %ld"
05167 " and 3 last strides %ld %ld, %ld.",
05168 (long int) NPY_FLOAT64,
05169 (long int) PyArray_TYPE((PyArrayObject*) py_V21),
05170 (long int) PyArray_NDIM(tmp),
05171 (long int) (PyArray_NDIM(tmp) >= 3 ?
05172 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
05173 (long int) (PyArray_NDIM(tmp) >= 2 ?
05174 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
05175 (long int) (PyArray_NDIM(tmp) >= 1 ?
05176 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
05177 (long int) (PyArray_NDIM(tmp) >= 3 ?
05178 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
05179 (long int) (PyArray_NDIM(tmp) >= 2 ?
05180 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
05181 (long int) (PyArray_NDIM(tmp) >= 1 ?
05182 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
05183 );
05184 {
05185 __failure = 22;
05186 if (!PyErr_Occurred()) {
05187 PyErr_SetString(PyExc_RuntimeError,
05188 "Unexpected error in an Op's C code. "
05189 "No Python exception was set.");
05190 }
05191 goto __label_22;}
05192 }
05193 // This is a TypeError to be consistent with DEBUG_MODE
05194 // Note: DEBUG_MODE also tells the name of the container
05195 if (PyArray_TYPE((PyArrayObject*) py_V21) != NPY_FLOAT64) {
05196 PyErr_Format(PyExc_TypeError,
05197 "expected type_num %d (NPY_FLOAT64) got %d",
05198 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V21));
05199 {
05200 __failure = 22;
05201 if (!PyErr_Occurred()) {
05202 PyErr_SetString(PyExc_RuntimeError,
05203 "Unexpected error in an Op's C code. "
05204 "No Python exception was set.");
05205 }
05206 goto __label_22;}
05207 }
05208
05209 V21 = (PyArrayObject*)(py_V21);
05210 Py_XINCREF(V21);
05211
05212 {
05213
05214 py_V23 = PyList_GET_ITEM(storage_V23, 0);
05215 {Py_XINCREF(py_V23);}
05216
05217 V23 = NULL;
05218 if (py_V23 == Py_None) {
05219 // We can either fail here or set V23 to NULL and rely on Ops
05220 // using tensors to handle the NULL case, but if they fail to do so
05221 // they'll end up with nasty segfaults, so this is public service.
05222 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
05223 {
05224 __failure = 24;
05225 if (!PyErr_Occurred()) {
05226 PyErr_SetString(PyExc_RuntimeError,
05227 "Unexpected error in an Op's C code. "
05228 "No Python exception was set.");
05229 }
05230 goto __label_24;}
05231 }
05232 if (!PyArray_Check(py_V23)) {
05233 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
05234 {
05235 __failure = 24;
05236 if (!PyErr_Occurred()) {
05237 PyErr_SetString(PyExc_RuntimeError,
05238 "Unexpected error in an Op's C code. "
05239 "No Python exception was set.");
05240 }
05241 goto __label_24;}
05242 }
05243 // We expect NPY_FLOAT64
05244 if (!PyArray_ISALIGNED((PyArrayObject*) py_V23)) {
05245 PyArrayObject * tmp = (PyArrayObject*) py_V23;
05246 PyErr_Format(PyExc_NotImplementedError,
05247 "expected an aligned array of type %ld "
05248 "(NPY_FLOAT64), got non-aligned array of type %ld"
05249 " with %ld dimensions, with 3 last dims "
05250 "%ld, %ld, %ld"
05251 " and 3 last strides %ld %ld, %ld.",
05252 (long int) NPY_FLOAT64,
05253 (long int) PyArray_TYPE((PyArrayObject*) py_V23),
05254 (long int) PyArray_NDIM(tmp),
05255 (long int) (PyArray_NDIM(tmp) >= 3 ?
05256 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
05257 (long int) (PyArray_NDIM(tmp) >= 2 ?
05258 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
05259 (long int) (PyArray_NDIM(tmp) >= 1 ?
05260 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
05261 (long int) (PyArray_NDIM(tmp) >= 3 ?
05262 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
05263 (long int) (PyArray_NDIM(tmp) >= 2 ?
05264 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
05265 (long int) (PyArray_NDIM(tmp) >= 1 ?
05266 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
05267 );
05268 {
05269 __failure = 24;
05270 if (!PyErr_Occurred()) {
05271 PyErr_SetString(PyExc_RuntimeError,
05272 "Unexpected error in an Op's C code. "
05273 "No Python exception was set.");
05274 }
05275 goto __label_24;}
05276 }
05277 // This is a TypeError to be consistent with DEBUG_MODE
05278 // Note: DEBUG_MODE also tells the name of the container
05279 if (PyArray_TYPE((PyArrayObject*) py_V23) != NPY_FLOAT64) {
05280 PyErr_Format(PyExc_TypeError,
05281 "expected type_num %d (NPY_FLOAT64) got %d",
05282 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V23));
05283 {
05284 __failure = 24;
05285 if (!PyErr_Occurred()) {
05286 PyErr_SetString(PyExc_RuntimeError,
05287 "Unexpected error in an Op's C code. "
05288 "No Python exception was set.");
05289 }
05290 goto __label_24;}
05291 }
05292
05293 V23 = (PyArrayObject*)(py_V23);
05294 Py_XINCREF(V23);
05295
05296 {
05297
05298 py_V25 = PyList_GET_ITEM(storage_V25, 0);
05299 {Py_XINCREF(py_V25);}
05300
05301 V25 = NULL;
05302 if (py_V25 == Py_None) {
05303 // We can either fail here or set V25 to NULL and rely on Ops
05304 // using tensors to handle the NULL case, but if they fail to do so
05305 // they'll end up with nasty segfaults, so this is public service.
05306 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
05307 {
05308 __failure = 26;
05309 if (!PyErr_Occurred()) {
05310 PyErr_SetString(PyExc_RuntimeError,
05311 "Unexpected error in an Op's C code. "
05312 "No Python exception was set.");
05313 }
05314 goto __label_26;}
05315 }
05316 if (!PyArray_Check(py_V25)) {
05317 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
05318 {
05319 __failure = 26;
05320 if (!PyErr_Occurred()) {
05321 PyErr_SetString(PyExc_RuntimeError,
05322 "Unexpected error in an Op's C code. "
05323 "No Python exception was set.");
05324 }
05325 goto __label_26;}
05326 }
05327 // We expect NPY_FLOAT64
05328 if (!PyArray_ISALIGNED((PyArrayObject*) py_V25)) {
05329 PyArrayObject * tmp = (PyArrayObject*) py_V25;
05330 PyErr_Format(PyExc_NotImplementedError,
05331 "expected an aligned array of type %ld "
05332 "(NPY_FLOAT64), got non-aligned array of type %ld"
05333 " with %ld dimensions, with 3 last dims "
05334 "%ld, %ld, %ld"
05335 " and 3 last strides %ld %ld, %ld.",
05336 (long int) NPY_FLOAT64,
05337 (long int) PyArray_TYPE((PyArrayObject*) py_V25),
05338 (long int) PyArray_NDIM(tmp),
05339 (long int) (PyArray_NDIM(tmp) >= 3 ?
05340 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
05341 (long int) (PyArray_NDIM(tmp) >= 2 ?
05342 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
05343 (long int) (PyArray_NDIM(tmp) >= 1 ?
05344 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
05345 (long int) (PyArray_NDIM(tmp) >= 3 ?
05346 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
05347 (long int) (PyArray_NDIM(tmp) >= 2 ?
05348 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
05349 (long int) (PyArray_NDIM(tmp) >= 1 ?
05350 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
05351 );
05352 {
05353 __failure = 26;
05354 if (!PyErr_Occurred()) {
05355 PyErr_SetString(PyExc_RuntimeError,
05356 "Unexpected error in an Op's C code. "
05357 "No Python exception was set.");
05358 }
05359 goto __label_26;}
05360 }
05361 // This is a TypeError to be consistent with DEBUG_MODE
05362 // Note: DEBUG_MODE also tells the name of the container
05363 if (PyArray_TYPE((PyArrayObject*) py_V25) != NPY_FLOAT64) {
05364 PyErr_Format(PyExc_TypeError,
05365 "expected type_num %d (NPY_FLOAT64) got %d",
05366 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V25));
05367 {
05368 __failure = 26;
05369 if (!PyErr_Occurred()) {
05370 PyErr_SetString(PyExc_RuntimeError,
05371 "Unexpected error in an Op's C code. "
05372 "No Python exception was set.");
05373 }
05374 goto __label_26;}
05375 }
05376
05377 V25 = (PyArrayObject*)(py_V25);
05378 Py_XINCREF(V25);
05379
05380 {
05381
05382 py_V27 = PyList_GET_ITEM(storage_V27, 0);
05383 {Py_XINCREF(py_V27);}
05384
05385 V27 = NULL;
05386 if (py_V27 == Py_None) {
05387 // We can either fail here or set V27 to NULL and rely on Ops
05388 // using tensors to handle the NULL case, but if they fail to do so
05389 // they'll end up with nasty segfaults, so this is public service.
05390 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
05391 {
05392 __failure = 28;
05393 if (!PyErr_Occurred()) {
05394 PyErr_SetString(PyExc_RuntimeError,
05395 "Unexpected error in an Op's C code. "
05396 "No Python exception was set.");
05397 }
05398 goto __label_28;}
05399 }
05400 if (!PyArray_Check(py_V27)) {
05401 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
05402 {
05403 __failure = 28;
05404 if (!PyErr_Occurred()) {
05405 PyErr_SetString(PyExc_RuntimeError,
05406 "Unexpected error in an Op's C code. "
05407 "No Python exception was set.");
05408 }
05409 goto __label_28;}
05410 }
05411 // We expect NPY_FLOAT64
05412 if (!PyArray_ISALIGNED((PyArrayObject*) py_V27)) {
05413 PyArrayObject * tmp = (PyArrayObject*) py_V27;
05414 PyErr_Format(PyExc_NotImplementedError,
05415 "expected an aligned array of type %ld "
05416 "(NPY_FLOAT64), got non-aligned array of type %ld"
05417 " with %ld dimensions, with 3 last dims "
05418 "%ld, %ld, %ld"
05419 " and 3 last strides %ld %ld, %ld.",
05420 (long int) NPY_FLOAT64,
05421 (long int) PyArray_TYPE((PyArrayObject*) py_V27),
05422 (long int) PyArray_NDIM(tmp),
05423 (long int) (PyArray_NDIM(tmp) >= 3 ?
05424 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
05425 (long int) (PyArray_NDIM(tmp) >= 2 ?
05426 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
05427 (long int) (PyArray_NDIM(tmp) >= 1 ?
05428 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
05429 (long int) (PyArray_NDIM(tmp) >= 3 ?
05430 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
05431 (long int) (PyArray_NDIM(tmp) >= 2 ?
05432 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
05433 (long int) (PyArray_NDIM(tmp) >= 1 ?
05434 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
05435 );
05436 {
05437 __failure = 28;
05438 if (!PyErr_Occurred()) {
05439 PyErr_SetString(PyExc_RuntimeError,
05440 "Unexpected error in an Op's C code. "
05441 "No Python exception was set.");
05442 }
05443 goto __label_28;}
05444 }
05445 // This is a TypeError to be consistent with DEBUG_MODE
05446 // Note: DEBUG_MODE also tells the name of the container
05447 if (PyArray_TYPE((PyArrayObject*) py_V27) != NPY_FLOAT64) {
05448 PyErr_Format(PyExc_TypeError,
05449 "expected type_num %d (NPY_FLOAT64) got %d",
05450 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V27));
05451 {
05452 __failure = 28;
05453 if (!PyErr_Occurred()) {
05454 PyErr_SetString(PyExc_RuntimeError,
05455 "Unexpected error in an Op's C code. "
05456 "No Python exception was set.");
05457 }
05458 goto __label_28;}
05459 }
05460
05461 V27 = (PyArrayObject*)(py_V27);
05462 Py_XINCREF(V27);
05463
05464 {
05465
05466 py_V29 = PyList_GET_ITEM(storage_V29, 0);
05467 {Py_XINCREF(py_V29);}
05468
05469 V29 = NULL;
05470 if (py_V29 == Py_None) {
05471 // We can either fail here or set V29 to NULL and rely on Ops
05472 // using tensors to handle the NULL case, but if they fail to do so
05473 // they'll end up with nasty segfaults, so this is public service.
05474 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
05475 {
05476 __failure = 30;
05477 if (!PyErr_Occurred()) {
05478 PyErr_SetString(PyExc_RuntimeError,
05479 "Unexpected error in an Op's C code. "
05480 "No Python exception was set.");
05481 }
05482 goto __label_30;}
05483 }
05484 if (!PyArray_Check(py_V29)) {
05485 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
05486 {
05487 __failure = 30;
05488 if (!PyErr_Occurred()) {
05489 PyErr_SetString(PyExc_RuntimeError,
05490 "Unexpected error in an Op's C code. "
05491 "No Python exception was set.");
05492 }
05493 goto __label_30;}
05494 }
05495 // We expect NPY_FLOAT64
05496 if (!PyArray_ISALIGNED((PyArrayObject*) py_V29)) {
05497 PyArrayObject * tmp = (PyArrayObject*) py_V29;
05498 PyErr_Format(PyExc_NotImplementedError,
05499 "expected an aligned array of type %ld "
05500 "(NPY_FLOAT64), got non-aligned array of type %ld"
05501 " with %ld dimensions, with 3 last dims "
05502 "%ld, %ld, %ld"
05503 " and 3 last strides %ld %ld, %ld.",
05504 (long int) NPY_FLOAT64,
05505 (long int) PyArray_TYPE((PyArrayObject*) py_V29),
05506 (long int) PyArray_NDIM(tmp),
05507 (long int) (PyArray_NDIM(tmp) >= 3 ?
05508 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
05509 (long int) (PyArray_NDIM(tmp) >= 2 ?
05510 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
05511 (long int) (PyArray_NDIM(tmp) >= 1 ?
05512 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
05513 (long int) (PyArray_NDIM(tmp) >= 3 ?
05514 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
05515 (long int) (PyArray_NDIM(tmp) >= 2 ?
05516 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
05517 (long int) (PyArray_NDIM(tmp) >= 1 ?
05518 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
05519 );
05520 {
05521 __failure = 30;
05522 if (!PyErr_Occurred()) {
05523 PyErr_SetString(PyExc_RuntimeError,
05524 "Unexpected error in an Op's C code. "
05525 "No Python exception was set.");
05526 }
05527 goto __label_30;}
05528 }
05529 // This is a TypeError to be consistent with DEBUG_MODE
05530 // Note: DEBUG_MODE also tells the name of the container
05531 if (PyArray_TYPE((PyArrayObject*) py_V29) != NPY_FLOAT64) {
05532 PyErr_Format(PyExc_TypeError,
05533 "expected type_num %d (NPY_FLOAT64) got %d",
05534 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V29));
05535 {
05536 __failure = 30;
05537 if (!PyErr_Occurred()) {
05538 PyErr_SetString(PyExc_RuntimeError,
05539 "Unexpected error in an Op's C code. "
05540 "No Python exception was set.");
05541 }
05542 goto __label_30;}
05543 }
05544
05545 V29 = (PyArrayObject*)(py_V29);
05546 Py_XINCREF(V29);
05547
05548 {
05549
05550 py_V31 = PyList_GET_ITEM(storage_V31, 0);
05551 {Py_XINCREF(py_V31);}
05552
05553 V31 = NULL;
05554 if (py_V31 == Py_None) {
05555 // We can either fail here or set V31 to NULL and rely on Ops
05556 // using tensors to handle the NULL case, but if they fail to do so
05557 // they'll end up with nasty segfaults, so this is public service.
05558 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
05559 {
05560 __failure = 32;
05561 if (!PyErr_Occurred()) {
05562 PyErr_SetString(PyExc_RuntimeError,
05563 "Unexpected error in an Op's C code. "
05564 "No Python exception was set.");
05565 }
05566 goto __label_32;}
05567 }
05568 if (!PyArray_Check(py_V31)) {
05569 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
05570 {
05571 __failure = 32;
05572 if (!PyErr_Occurred()) {
05573 PyErr_SetString(PyExc_RuntimeError,
05574 "Unexpected error in an Op's C code. "
05575 "No Python exception was set.");
05576 }
05577 goto __label_32;}
05578 }
05579 // We expect NPY_FLOAT64
05580 if (!PyArray_ISALIGNED((PyArrayObject*) py_V31)) {
05581 PyArrayObject * tmp = (PyArrayObject*) py_V31;
05582 PyErr_Format(PyExc_NotImplementedError,
05583 "expected an aligned array of type %ld "
05584 "(NPY_FLOAT64), got non-aligned array of type %ld"
05585 " with %ld dimensions, with 3 last dims "
05586 "%ld, %ld, %ld"
05587 " and 3 last strides %ld %ld, %ld.",
05588 (long int) NPY_FLOAT64,
05589 (long int) PyArray_TYPE((PyArrayObject*) py_V31),
05590 (long int) PyArray_NDIM(tmp),
05591 (long int) (PyArray_NDIM(tmp) >= 3 ?
05592 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
05593 (long int) (PyArray_NDIM(tmp) >= 2 ?
05594 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
05595 (long int) (PyArray_NDIM(tmp) >= 1 ?
05596 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
05597 (long int) (PyArray_NDIM(tmp) >= 3 ?
05598 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
05599 (long int) (PyArray_NDIM(tmp) >= 2 ?
05600 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
05601 (long int) (PyArray_NDIM(tmp) >= 1 ?
05602 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
05603 );
05604 {
05605 __failure = 32;
05606 if (!PyErr_Occurred()) {
05607 PyErr_SetString(PyExc_RuntimeError,
05608 "Unexpected error in an Op's C code. "
05609 "No Python exception was set.");
05610 }
05611 goto __label_32;}
05612 }
05613 // This is a TypeError to be consistent with DEBUG_MODE
05614 // Note: DEBUG_MODE also tells the name of the container
05615 if (PyArray_TYPE((PyArrayObject*) py_V31) != NPY_FLOAT64) {
05616 PyErr_Format(PyExc_TypeError,
05617 "expected type_num %d (NPY_FLOAT64) got %d",
05618 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V31));
05619 {
05620 __failure = 32;
05621 if (!PyErr_Occurred()) {
05622 PyErr_SetString(PyExc_RuntimeError,
05623 "Unexpected error in an Op's C code. "
05624 "No Python exception was set.");
05625 }
05626 goto __label_32;}
05627 }
05628
05629 V31 = (PyArrayObject*)(py_V31);
05630 Py_XINCREF(V31);
05631
05632 {
05633
05634 py_V33 = PyList_GET_ITEM(storage_V33, 0);
05635 {Py_XINCREF(py_V33);}
05636
05637 V33 = NULL;
05638 if (py_V33 == Py_None) {
05639 // We can either fail here or set V33 to NULL and rely on Ops
05640 // using tensors to handle the NULL case, but if they fail to do so
05641 // they'll end up with nasty segfaults, so this is public service.
05642 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
05643 {
05644 __failure = 34;
05645 if (!PyErr_Occurred()) {
05646 PyErr_SetString(PyExc_RuntimeError,
05647 "Unexpected error in an Op's C code. "
05648 "No Python exception was set.");
05649 }
05650 goto __label_34;}
05651 }
05652 if (!PyArray_Check(py_V33)) {
05653 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
05654 {
05655 __failure = 34;
05656 if (!PyErr_Occurred()) {
05657 PyErr_SetString(PyExc_RuntimeError,
05658 "Unexpected error in an Op's C code. "
05659 "No Python exception was set.");
05660 }
05661 goto __label_34;}
05662 }
05663 // We expect NPY_FLOAT64
05664 if (!PyArray_ISALIGNED((PyArrayObject*) py_V33)) {
05665 PyArrayObject * tmp = (PyArrayObject*) py_V33;
05666 PyErr_Format(PyExc_NotImplementedError,
05667 "expected an aligned array of type %ld "
05668 "(NPY_FLOAT64), got non-aligned array of type %ld"
05669 " with %ld dimensions, with 3 last dims "
05670 "%ld, %ld, %ld"
05671 " and 3 last strides %ld %ld, %ld.",
05672 (long int) NPY_FLOAT64,
05673 (long int) PyArray_TYPE((PyArrayObject*) py_V33),
05674 (long int) PyArray_NDIM(tmp),
05675 (long int) (PyArray_NDIM(tmp) >= 3 ?
05676 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
05677 (long int) (PyArray_NDIM(tmp) >= 2 ?
05678 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
05679 (long int) (PyArray_NDIM(tmp) >= 1 ?
05680 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
05681 (long int) (PyArray_NDIM(tmp) >= 3 ?
05682 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
05683 (long int) (PyArray_NDIM(tmp) >= 2 ?
05684 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
05685 (long int) (PyArray_NDIM(tmp) >= 1 ?
05686 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
05687 );
05688 {
05689 __failure = 34;
05690 if (!PyErr_Occurred()) {
05691 PyErr_SetString(PyExc_RuntimeError,
05692 "Unexpected error in an Op's C code. "
05693 "No Python exception was set.");
05694 }
05695 goto __label_34;}
05696 }
05697 // This is a TypeError to be consistent with DEBUG_MODE
05698 // Note: DEBUG_MODE also tells the name of the container
05699 if (PyArray_TYPE((PyArrayObject*) py_V33) != NPY_FLOAT64) {
05700 PyErr_Format(PyExc_TypeError,
05701 "expected type_num %d (NPY_FLOAT64) got %d",
05702 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V33));
05703 {
05704 __failure = 34;
05705 if (!PyErr_Occurred()) {
05706 PyErr_SetString(PyExc_RuntimeError,
05707 "Unexpected error in an Op's C code. "
05708 "No Python exception was set.");
05709 }
05710 goto __label_34;}
05711 }
05712
05713 V33 = (PyArrayObject*)(py_V33);
05714 Py_XINCREF(V33);
05715
05716 {
05717
05718 py_V35 = PyList_GET_ITEM(storage_V35, 0);
05719 {Py_XINCREF(py_V35);}
05720
05721 V35 = NULL;
05722 if (py_V35 == Py_None) {
05723 // We can either fail here or set V35 to NULL and rely on Ops
05724 // using tensors to handle the NULL case, but if they fail to do so
05725 // they'll end up with nasty segfaults, so this is public service.
05726 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
05727 {
05728 __failure = 36;
05729 if (!PyErr_Occurred()) {
05730 PyErr_SetString(PyExc_RuntimeError,
05731 "Unexpected error in an Op's C code. "
05732 "No Python exception was set.");
05733 }
05734 goto __label_36;}
05735 }
05736 if (!PyArray_Check(py_V35)) {
05737 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
05738 {
05739 __failure = 36;
05740 if (!PyErr_Occurred()) {
05741 PyErr_SetString(PyExc_RuntimeError,
05742 "Unexpected error in an Op's C code. "
05743 "No Python exception was set.");
05744 }
05745 goto __label_36;}
05746 }
05747 // We expect NPY_FLOAT64
05748 if (!PyArray_ISALIGNED((PyArrayObject*) py_V35)) {
05749 PyArrayObject * tmp = (PyArrayObject*) py_V35;
05750 PyErr_Format(PyExc_NotImplementedError,
05751 "expected an aligned array of type %ld "
05752 "(NPY_FLOAT64), got non-aligned array of type %ld"
05753 " with %ld dimensions, with 3 last dims "
05754 "%ld, %ld, %ld"
05755 " and 3 last strides %ld %ld, %ld.",
05756 (long int) NPY_FLOAT64,
05757 (long int) PyArray_TYPE((PyArrayObject*) py_V35),
05758 (long int) PyArray_NDIM(tmp),
05759 (long int) (PyArray_NDIM(tmp) >= 3 ?
05760 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
05761 (long int) (PyArray_NDIM(tmp) >= 2 ?
05762 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
05763 (long int) (PyArray_NDIM(tmp) >= 1 ?
05764 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
05765 (long int) (PyArray_NDIM(tmp) >= 3 ?
05766 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
05767 (long int) (PyArray_NDIM(tmp) >= 2 ?
05768 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
05769 (long int) (PyArray_NDIM(tmp) >= 1 ?
05770 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
05771 );
05772 {
05773 __failure = 36;
05774 if (!PyErr_Occurred()) {
05775 PyErr_SetString(PyExc_RuntimeError,
05776 "Unexpected error in an Op's C code. "
05777 "No Python exception was set.");
05778 }
05779 goto __label_36;}
05780 }
05781 // This is a TypeError to be consistent with DEBUG_MODE
05782 // Note: DEBUG_MODE also tells the name of the container
05783 if (PyArray_TYPE((PyArrayObject*) py_V35) != NPY_FLOAT64) {
05784 PyErr_Format(PyExc_TypeError,
05785 "expected type_num %d (NPY_FLOAT64) got %d",
05786 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V35));
05787 {
05788 __failure = 36;
05789 if (!PyErr_Occurred()) {
05790 PyErr_SetString(PyExc_RuntimeError,
05791 "Unexpected error in an Op's C code. "
05792 "No Python exception was set.");
05793 }
05794 goto __label_36;}
05795 }
05796
05797 V35 = (PyArrayObject*)(py_V35);
05798 Py_XINCREF(V35);
05799
05800 {
05801
05802 py_V37 = PyList_GET_ITEM(storage_V37, 0);
05803 {Py_XINCREF(py_V37);}
05804
05805 V37 = NULL;
05806 if (py_V37 == Py_None) {
05807 // We can either fail here or set V37 to NULL and rely on Ops
05808 // using tensors to handle the NULL case, but if they fail to do so
05809 // they'll end up with nasty segfaults, so this is public service.
05810 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
05811 {
05812 __failure = 38;
05813 if (!PyErr_Occurred()) {
05814 PyErr_SetString(PyExc_RuntimeError,
05815 "Unexpected error in an Op's C code. "
05816 "No Python exception was set.");
05817 }
05818 goto __label_38;}
05819 }
05820 if (!PyArray_Check(py_V37)) {
05821 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
05822 {
05823 __failure = 38;
05824 if (!PyErr_Occurred()) {
05825 PyErr_SetString(PyExc_RuntimeError,
05826 "Unexpected error in an Op's C code. "
05827 "No Python exception was set.");
05828 }
05829 goto __label_38;}
05830 }
05831 // We expect NPY_FLOAT64
05832 if (!PyArray_ISALIGNED((PyArrayObject*) py_V37)) {
05833 PyArrayObject * tmp = (PyArrayObject*) py_V37;
05834 PyErr_Format(PyExc_NotImplementedError,
05835 "expected an aligned array of type %ld "
05836 "(NPY_FLOAT64), got non-aligned array of type %ld"
05837 " with %ld dimensions, with 3 last dims "
05838 "%ld, %ld, %ld"
05839 " and 3 last strides %ld %ld, %ld.",
05840 (long int) NPY_FLOAT64,
05841 (long int) PyArray_TYPE((PyArrayObject*) py_V37),
05842 (long int) PyArray_NDIM(tmp),
05843 (long int) (PyArray_NDIM(tmp) >= 3 ?
05844 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
05845 (long int) (PyArray_NDIM(tmp) >= 2 ?
05846 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
05847 (long int) (PyArray_NDIM(tmp) >= 1 ?
05848 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
05849 (long int) (PyArray_NDIM(tmp) >= 3 ?
05850 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
05851 (long int) (PyArray_NDIM(tmp) >= 2 ?
05852 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
05853 (long int) (PyArray_NDIM(tmp) >= 1 ?
05854 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
05855 );
05856 {
05857 __failure = 38;
05858 if (!PyErr_Occurred()) {
05859 PyErr_SetString(PyExc_RuntimeError,
05860 "Unexpected error in an Op's C code. "
05861 "No Python exception was set.");
05862 }
05863 goto __label_38;}
05864 }
05865 // This is a TypeError to be consistent with DEBUG_MODE
05866 // Note: DEBUG_MODE also tells the name of the container
05867 if (PyArray_TYPE((PyArrayObject*) py_V37) != NPY_FLOAT64) {
05868 PyErr_Format(PyExc_TypeError,
05869 "expected type_num %d (NPY_FLOAT64) got %d",
05870 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V37));
05871 {
05872 __failure = 38;
05873 if (!PyErr_Occurred()) {
05874 PyErr_SetString(PyExc_RuntimeError,
05875 "Unexpected error in an Op's C code. "
05876 "No Python exception was set.");
05877 }
05878 goto __label_38;}
05879 }
05880
05881 V37 = (PyArrayObject*)(py_V37);
05882 Py_XINCREF(V37);
05883
05884 {
05885
05886 py_V39 = PyList_GET_ITEM(storage_V39, 0);
05887 {Py_XINCREF(py_V39);}
05888
05889 V39 = NULL;
05890 if (py_V39 == Py_None) {
05891 // We can either fail here or set V39 to NULL and rely on Ops
05892 // using tensors to handle the NULL case, but if they fail to do so
05893 // they'll end up with nasty segfaults, so this is public service.
05894 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
05895 {
05896 __failure = 40;
05897 if (!PyErr_Occurred()) {
05898 PyErr_SetString(PyExc_RuntimeError,
05899 "Unexpected error in an Op's C code. "
05900 "No Python exception was set.");
05901 }
05902 goto __label_40;}
05903 }
05904 if (!PyArray_Check(py_V39)) {
05905 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
05906 {
05907 __failure = 40;
05908 if (!PyErr_Occurred()) {
05909 PyErr_SetString(PyExc_RuntimeError,
05910 "Unexpected error in an Op's C code. "
05911 "No Python exception was set.");
05912 }
05913 goto __label_40;}
05914 }
05915 // We expect NPY_FLOAT64
05916 if (!PyArray_ISALIGNED((PyArrayObject*) py_V39)) {
05917 PyArrayObject * tmp = (PyArrayObject*) py_V39;
05918 PyErr_Format(PyExc_NotImplementedError,
05919 "expected an aligned array of type %ld "
05920 "(NPY_FLOAT64), got non-aligned array of type %ld"
05921 " with %ld dimensions, with 3 last dims "
05922 "%ld, %ld, %ld"
05923 " and 3 last strides %ld %ld, %ld.",
05924 (long int) NPY_FLOAT64,
05925 (long int) PyArray_TYPE((PyArrayObject*) py_V39),
05926 (long int) PyArray_NDIM(tmp),
05927 (long int) (PyArray_NDIM(tmp) >= 3 ?
05928 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
05929 (long int) (PyArray_NDIM(tmp) >= 2 ?
05930 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
05931 (long int) (PyArray_NDIM(tmp) >= 1 ?
05932 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
05933 (long int) (PyArray_NDIM(tmp) >= 3 ?
05934 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
05935 (long int) (PyArray_NDIM(tmp) >= 2 ?
05936 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
05937 (long int) (PyArray_NDIM(tmp) >= 1 ?
05938 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
05939 );
05940 {
05941 __failure = 40;
05942 if (!PyErr_Occurred()) {
05943 PyErr_SetString(PyExc_RuntimeError,
05944 "Unexpected error in an Op's C code. "
05945 "No Python exception was set.");
05946 }
05947 goto __label_40;}
05948 }
05949 // This is a TypeError to be consistent with DEBUG_MODE
05950 // Note: DEBUG_MODE also tells the name of the container
05951 if (PyArray_TYPE((PyArrayObject*) py_V39) != NPY_FLOAT64) {
05952 PyErr_Format(PyExc_TypeError,
05953 "expected type_num %d (NPY_FLOAT64) got %d",
05954 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V39));
05955 {
05956 __failure = 40;
05957 if (!PyErr_Occurred()) {
05958 PyErr_SetString(PyExc_RuntimeError,
05959 "Unexpected error in an Op's C code. "
05960 "No Python exception was set.");
05961 }
05962 goto __label_40;}
05963 }
05964
05965 V39 = (PyArrayObject*)(py_V39);
05966 Py_XINCREF(V39);
05967
05968 {
05969
05970 py_V41 = PyList_GET_ITEM(storage_V41, 0);
05971 {Py_XINCREF(py_V41);}
05972
05973 V41 = NULL;
05974 if (py_V41 == Py_None) {
05975 // We can either fail here or set V41 to NULL and rely on Ops
05976 // using tensors to handle the NULL case, but if they fail to do so
05977 // they'll end up with nasty segfaults, so this is public service.
05978 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
05979 {
05980 __failure = 42;
05981 if (!PyErr_Occurred()) {
05982 PyErr_SetString(PyExc_RuntimeError,
05983 "Unexpected error in an Op's C code. "
05984 "No Python exception was set.");
05985 }
05986 goto __label_42;}
05987 }
05988 if (!PyArray_Check(py_V41)) {
05989 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
05990 {
05991 __failure = 42;
05992 if (!PyErr_Occurred()) {
05993 PyErr_SetString(PyExc_RuntimeError,
05994 "Unexpected error in an Op's C code. "
05995 "No Python exception was set.");
05996 }
05997 goto __label_42;}
05998 }
05999 // We expect NPY_FLOAT64
06000 if (!PyArray_ISALIGNED((PyArrayObject*) py_V41)) {
06001 PyArrayObject * tmp = (PyArrayObject*) py_V41;
06002 PyErr_Format(PyExc_NotImplementedError,
06003 "expected an aligned array of type %ld "
06004 "(NPY_FLOAT64), got non-aligned array of type %ld"
06005 " with %ld dimensions, with 3 last dims "
06006 "%ld, %ld, %ld"
06007 " and 3 last strides %ld %ld, %ld.",
06008 (long int) NPY_FLOAT64,
06009 (long int) PyArray_TYPE((PyArrayObject*) py_V41),
06010 (long int) PyArray_NDIM(tmp),
06011 (long int) (PyArray_NDIM(tmp) >= 3 ?
06012 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
06013 (long int) (PyArray_NDIM(tmp) >= 2 ?
06014 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
06015 (long int) (PyArray_NDIM(tmp) >= 1 ?
06016 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
06017 (long int) (PyArray_NDIM(tmp) >= 3 ?
06018 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
06019 (long int) (PyArray_NDIM(tmp) >= 2 ?
06020 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
06021 (long int) (PyArray_NDIM(tmp) >= 1 ?
06022 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
06023 );
06024 {
06025 __failure = 42;
06026 if (!PyErr_Occurred()) {
06027 PyErr_SetString(PyExc_RuntimeError,
06028 "Unexpected error in an Op's C code. "
06029 "No Python exception was set.");
06030 }
06031 goto __label_42;}
06032 }
06033 // This is a TypeError to be consistent with DEBUG_MODE
06034 // Note: DEBUG_MODE also tells the name of the container
06035 if (PyArray_TYPE((PyArrayObject*) py_V41) != NPY_FLOAT64) {
06036 PyErr_Format(PyExc_TypeError,
06037 "expected type_num %d (NPY_FLOAT64) got %d",
06038 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V41));
06039 {
06040 __failure = 42;
06041 if (!PyErr_Occurred()) {
06042 PyErr_SetString(PyExc_RuntimeError,
06043 "Unexpected error in an Op's C code. "
06044 "No Python exception was set.");
06045 }
06046 goto __label_42;}
06047 }
06048
06049 V41 = (PyArrayObject*)(py_V41);
06050 Py_XINCREF(V41);
06051
06052 {
06053
06054 py_V43 = PyList_GET_ITEM(storage_V43, 0);
06055 {Py_XINCREF(py_V43);}
06056
06057 V43 = NULL;
06058 if (py_V43 == Py_None) {
06059 // We can either fail here or set V43 to NULL and rely on Ops
06060 // using tensors to handle the NULL case, but if they fail to do so
06061 // they'll end up with nasty segfaults, so this is public service.
06062 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
06063 {
06064 __failure = 44;
06065 if (!PyErr_Occurred()) {
06066 PyErr_SetString(PyExc_RuntimeError,
06067 "Unexpected error in an Op's C code. "
06068 "No Python exception was set.");
06069 }
06070 goto __label_44;}
06071 }
06072 if (!PyArray_Check(py_V43)) {
06073 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
06074 {
06075 __failure = 44;
06076 if (!PyErr_Occurred()) {
06077 PyErr_SetString(PyExc_RuntimeError,
06078 "Unexpected error in an Op's C code. "
06079 "No Python exception was set.");
06080 }
06081 goto __label_44;}
06082 }
06083 // We expect NPY_FLOAT64
06084 if (!PyArray_ISALIGNED((PyArrayObject*) py_V43)) {
06085 PyArrayObject * tmp = (PyArrayObject*) py_V43;
06086 PyErr_Format(PyExc_NotImplementedError,
06087 "expected an aligned array of type %ld "
06088 "(NPY_FLOAT64), got non-aligned array of type %ld"
06089 " with %ld dimensions, with 3 last dims "
06090 "%ld, %ld, %ld"
06091 " and 3 last strides %ld %ld, %ld.",
06092 (long int) NPY_FLOAT64,
06093 (long int) PyArray_TYPE((PyArrayObject*) py_V43),
06094 (long int) PyArray_NDIM(tmp),
06095 (long int) (PyArray_NDIM(tmp) >= 3 ?
06096 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
06097 (long int) (PyArray_NDIM(tmp) >= 2 ?
06098 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
06099 (long int) (PyArray_NDIM(tmp) >= 1 ?
06100 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
06101 (long int) (PyArray_NDIM(tmp) >= 3 ?
06102 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
06103 (long int) (PyArray_NDIM(tmp) >= 2 ?
06104 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
06105 (long int) (PyArray_NDIM(tmp) >= 1 ?
06106 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
06107 );
06108 {
06109 __failure = 44;
06110 if (!PyErr_Occurred()) {
06111 PyErr_SetString(PyExc_RuntimeError,
06112 "Unexpected error in an Op's C code. "
06113 "No Python exception was set.");
06114 }
06115 goto __label_44;}
06116 }
06117 // This is a TypeError to be consistent with DEBUG_MODE
06118 // Note: DEBUG_MODE also tells the name of the container
06119 if (PyArray_TYPE((PyArrayObject*) py_V43) != NPY_FLOAT64) {
06120 PyErr_Format(PyExc_TypeError,
06121 "expected type_num %d (NPY_FLOAT64) got %d",
06122 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V43));
06123 {
06124 __failure = 44;
06125 if (!PyErr_Occurred()) {
06126 PyErr_SetString(PyExc_RuntimeError,
06127 "Unexpected error in an Op's C code. "
06128 "No Python exception was set.");
06129 }
06130 goto __label_44;}
06131 }
06132
06133 V43 = (PyArrayObject*)(py_V43);
06134 Py_XINCREF(V43);
06135
06136 {
06137
06138 py_V45 = PyList_GET_ITEM(storage_V45, 0);
06139 {Py_XINCREF(py_V45);}
06140
06141 V45 = NULL;
06142 if (py_V45 == Py_None) {
06143 // We can either fail here or set V45 to NULL and rely on Ops
06144 // using tensors to handle the NULL case, but if they fail to do so
06145 // they'll end up with nasty segfaults, so this is public service.
06146 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
06147 {
06148 __failure = 46;
06149 if (!PyErr_Occurred()) {
06150 PyErr_SetString(PyExc_RuntimeError,
06151 "Unexpected error in an Op's C code. "
06152 "No Python exception was set.");
06153 }
06154 goto __label_46;}
06155 }
06156 if (!PyArray_Check(py_V45)) {
06157 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
06158 {
06159 __failure = 46;
06160 if (!PyErr_Occurred()) {
06161 PyErr_SetString(PyExc_RuntimeError,
06162 "Unexpected error in an Op's C code. "
06163 "No Python exception was set.");
06164 }
06165 goto __label_46;}
06166 }
06167 // We expect NPY_FLOAT64
06168 if (!PyArray_ISALIGNED((PyArrayObject*) py_V45)) {
06169 PyArrayObject * tmp = (PyArrayObject*) py_V45;
06170 PyErr_Format(PyExc_NotImplementedError,
06171 "expected an aligned array of type %ld "
06172 "(NPY_FLOAT64), got non-aligned array of type %ld"
06173 " with %ld dimensions, with 3 last dims "
06174 "%ld, %ld, %ld"
06175 " and 3 last strides %ld %ld, %ld.",
06176 (long int) NPY_FLOAT64,
06177 (long int) PyArray_TYPE((PyArrayObject*) py_V45),
06178 (long int) PyArray_NDIM(tmp),
06179 (long int) (PyArray_NDIM(tmp) >= 3 ?
06180 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
06181 (long int) (PyArray_NDIM(tmp) >= 2 ?
06182 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
06183 (long int) (PyArray_NDIM(tmp) >= 1 ?
06184 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
06185 (long int) (PyArray_NDIM(tmp) >= 3 ?
06186 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
06187 (long int) (PyArray_NDIM(tmp) >= 2 ?
06188 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
06189 (long int) (PyArray_NDIM(tmp) >= 1 ?
06190 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
06191 );
06192 {
06193 __failure = 46;
06194 if (!PyErr_Occurred()) {
06195 PyErr_SetString(PyExc_RuntimeError,
06196 "Unexpected error in an Op's C code. "
06197 "No Python exception was set.");
06198 }
06199 goto __label_46;}
06200 }
06201 // This is a TypeError to be consistent with DEBUG_MODE
06202 // Note: DEBUG_MODE also tells the name of the container
06203 if (PyArray_TYPE((PyArrayObject*) py_V45) != NPY_FLOAT64) {
06204 PyErr_Format(PyExc_TypeError,
06205 "expected type_num %d (NPY_FLOAT64) got %d",
06206 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V45));
06207 {
06208 __failure = 46;
06209 if (!PyErr_Occurred()) {
06210 PyErr_SetString(PyExc_RuntimeError,
06211 "Unexpected error in an Op's C code. "
06212 "No Python exception was set.");
06213 }
06214 goto __label_46;}
06215 }
06216
06217 V45 = (PyArrayObject*)(py_V45);
06218 Py_XINCREF(V45);
06219
06220 {
06221
06222 py_V47 = PyList_GET_ITEM(storage_V47, 0);
06223 {Py_XINCREF(py_V47);}
06224
06225 V47 = NULL;
06226 if (py_V47 == Py_None) {
06227 // We can either fail here or set V47 to NULL and rely on Ops
06228 // using tensors to handle the NULL case, but if they fail to do so
06229 // they'll end up with nasty segfaults, so this is public service.
06230 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
06231 {
06232 __failure = 48;
06233 if (!PyErr_Occurred()) {
06234 PyErr_SetString(PyExc_RuntimeError,
06235 "Unexpected error in an Op's C code. "
06236 "No Python exception was set.");
06237 }
06238 goto __label_48;}
06239 }
06240 if (!PyArray_Check(py_V47)) {
06241 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
06242 {
06243 __failure = 48;
06244 if (!PyErr_Occurred()) {
06245 PyErr_SetString(PyExc_RuntimeError,
06246 "Unexpected error in an Op's C code. "
06247 "No Python exception was set.");
06248 }
06249 goto __label_48;}
06250 }
06251 // We expect NPY_FLOAT64
06252 if (!PyArray_ISALIGNED((PyArrayObject*) py_V47)) {
06253 PyArrayObject * tmp = (PyArrayObject*) py_V47;
06254 PyErr_Format(PyExc_NotImplementedError,
06255 "expected an aligned array of type %ld "
06256 "(NPY_FLOAT64), got non-aligned array of type %ld"
06257 " with %ld dimensions, with 3 last dims "
06258 "%ld, %ld, %ld"
06259 " and 3 last strides %ld %ld, %ld.",
06260 (long int) NPY_FLOAT64,
06261 (long int) PyArray_TYPE((PyArrayObject*) py_V47),
06262 (long int) PyArray_NDIM(tmp),
06263 (long int) (PyArray_NDIM(tmp) >= 3 ?
06264 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
06265 (long int) (PyArray_NDIM(tmp) >= 2 ?
06266 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
06267 (long int) (PyArray_NDIM(tmp) >= 1 ?
06268 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
06269 (long int) (PyArray_NDIM(tmp) >= 3 ?
06270 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
06271 (long int) (PyArray_NDIM(tmp) >= 2 ?
06272 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
06273 (long int) (PyArray_NDIM(tmp) >= 1 ?
06274 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
06275 );
06276 {
06277 __failure = 48;
06278 if (!PyErr_Occurred()) {
06279 PyErr_SetString(PyExc_RuntimeError,
06280 "Unexpected error in an Op's C code. "
06281 "No Python exception was set.");
06282 }
06283 goto __label_48;}
06284 }
06285 // This is a TypeError to be consistent with DEBUG_MODE
06286 // Note: DEBUG_MODE also tells the name of the container
06287 if (PyArray_TYPE((PyArrayObject*) py_V47) != NPY_FLOAT64) {
06288 PyErr_Format(PyExc_TypeError,
06289 "expected type_num %d (NPY_FLOAT64) got %d",
06290 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V47));
06291 {
06292 __failure = 48;
06293 if (!PyErr_Occurred()) {
06294 PyErr_SetString(PyExc_RuntimeError,
06295 "Unexpected error in an Op's C code. "
06296 "No Python exception was set.");
06297 }
06298 goto __label_48;}
06299 }
06300
06301 V47 = (PyArrayObject*)(py_V47);
06302 Py_XINCREF(V47);
06303
06304 {
06305
06306 py_V49 = PyList_GET_ITEM(storage_V49, 0);
06307 {Py_XINCREF(py_V49);}
06308
06309 V49 = NULL;
06310 if (py_V49 == Py_None) {
06311 // We can either fail here or set V49 to NULL and rely on Ops
06312 // using tensors to handle the NULL case, but if they fail to do so
06313 // they'll end up with nasty segfaults, so this is public service.
06314 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
06315 {
06316 __failure = 50;
06317 if (!PyErr_Occurred()) {
06318 PyErr_SetString(PyExc_RuntimeError,
06319 "Unexpected error in an Op's C code. "
06320 "No Python exception was set.");
06321 }
06322 goto __label_50;}
06323 }
06324 if (!PyArray_Check(py_V49)) {
06325 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
06326 {
06327 __failure = 50;
06328 if (!PyErr_Occurred()) {
06329 PyErr_SetString(PyExc_RuntimeError,
06330 "Unexpected error in an Op's C code. "
06331 "No Python exception was set.");
06332 }
06333 goto __label_50;}
06334 }
06335 // We expect NPY_FLOAT64
06336 if (!PyArray_ISALIGNED((PyArrayObject*) py_V49)) {
06337 PyArrayObject * tmp = (PyArrayObject*) py_V49;
06338 PyErr_Format(PyExc_NotImplementedError,
06339 "expected an aligned array of type %ld "
06340 "(NPY_FLOAT64), got non-aligned array of type %ld"
06341 " with %ld dimensions, with 3 last dims "
06342 "%ld, %ld, %ld"
06343 " and 3 last strides %ld %ld, %ld.",
06344 (long int) NPY_FLOAT64,
06345 (long int) PyArray_TYPE((PyArrayObject*) py_V49),
06346 (long int) PyArray_NDIM(tmp),
06347 (long int) (PyArray_NDIM(tmp) >= 3 ?
06348 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
06349 (long int) (PyArray_NDIM(tmp) >= 2 ?
06350 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
06351 (long int) (PyArray_NDIM(tmp) >= 1 ?
06352 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
06353 (long int) (PyArray_NDIM(tmp) >= 3 ?
06354 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
06355 (long int) (PyArray_NDIM(tmp) >= 2 ?
06356 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
06357 (long int) (PyArray_NDIM(tmp) >= 1 ?
06358 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
06359 );
06360 {
06361 __failure = 50;
06362 if (!PyErr_Occurred()) {
06363 PyErr_SetString(PyExc_RuntimeError,
06364 "Unexpected error in an Op's C code. "
06365 "No Python exception was set.");
06366 }
06367 goto __label_50;}
06368 }
06369 // This is a TypeError to be consistent with DEBUG_MODE
06370 // Note: DEBUG_MODE also tells the name of the container
06371 if (PyArray_TYPE((PyArrayObject*) py_V49) != NPY_FLOAT64) {
06372 PyErr_Format(PyExc_TypeError,
06373 "expected type_num %d (NPY_FLOAT64) got %d",
06374 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V49));
06375 {
06376 __failure = 50;
06377 if (!PyErr_Occurred()) {
06378 PyErr_SetString(PyExc_RuntimeError,
06379 "Unexpected error in an Op's C code. "
06380 "No Python exception was set.");
06381 }
06382 goto __label_50;}
06383 }
06384
06385 V49 = (PyArrayObject*)(py_V49);
06386 Py_XINCREF(V49);
06387
06388 {
06389
06390 py_V51 = PyList_GET_ITEM(storage_V51, 0);
06391 {Py_XINCREF(py_V51);}
06392
06393 V51 = NULL;
06394 if (py_V51 == Py_None) {
06395 // We can either fail here or set V51 to NULL and rely on Ops
06396 // using tensors to handle the NULL case, but if they fail to do so
06397 // they'll end up with nasty segfaults, so this is public service.
06398 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
06399 {
06400 __failure = 52;
06401 if (!PyErr_Occurred()) {
06402 PyErr_SetString(PyExc_RuntimeError,
06403 "Unexpected error in an Op's C code. "
06404 "No Python exception was set.");
06405 }
06406 goto __label_52;}
06407 }
06408 if (!PyArray_Check(py_V51)) {
06409 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
06410 {
06411 __failure = 52;
06412 if (!PyErr_Occurred()) {
06413 PyErr_SetString(PyExc_RuntimeError,
06414 "Unexpected error in an Op's C code. "
06415 "No Python exception was set.");
06416 }
06417 goto __label_52;}
06418 }
06419 // We expect NPY_FLOAT64
06420 if (!PyArray_ISALIGNED((PyArrayObject*) py_V51)) {
06421 PyArrayObject * tmp = (PyArrayObject*) py_V51;
06422 PyErr_Format(PyExc_NotImplementedError,
06423 "expected an aligned array of type %ld "
06424 "(NPY_FLOAT64), got non-aligned array of type %ld"
06425 " with %ld dimensions, with 3 last dims "
06426 "%ld, %ld, %ld"
06427 " and 3 last strides %ld %ld, %ld.",
06428 (long int) NPY_FLOAT64,
06429 (long int) PyArray_TYPE((PyArrayObject*) py_V51),
06430 (long int) PyArray_NDIM(tmp),
06431 (long int) (PyArray_NDIM(tmp) >= 3 ?
06432 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
06433 (long int) (PyArray_NDIM(tmp) >= 2 ?
06434 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
06435 (long int) (PyArray_NDIM(tmp) >= 1 ?
06436 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
06437 (long int) (PyArray_NDIM(tmp) >= 3 ?
06438 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
06439 (long int) (PyArray_NDIM(tmp) >= 2 ?
06440 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
06441 (long int) (PyArray_NDIM(tmp) >= 1 ?
06442 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
06443 );
06444 {
06445 __failure = 52;
06446 if (!PyErr_Occurred()) {
06447 PyErr_SetString(PyExc_RuntimeError,
06448 "Unexpected error in an Op's C code. "
06449 "No Python exception was set.");
06450 }
06451 goto __label_52;}
06452 }
06453 // This is a TypeError to be consistent with DEBUG_MODE
06454 // Note: DEBUG_MODE also tells the name of the container
06455 if (PyArray_TYPE((PyArrayObject*) py_V51) != NPY_FLOAT64) {
06456 PyErr_Format(PyExc_TypeError,
06457 "expected type_num %d (NPY_FLOAT64) got %d",
06458 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V51));
06459 {
06460 __failure = 52;
06461 if (!PyErr_Occurred()) {
06462 PyErr_SetString(PyExc_RuntimeError,
06463 "Unexpected error in an Op's C code. "
06464 "No Python exception was set.");
06465 }
06466 goto __label_52;}
06467 }
06468
06469 V51 = (PyArrayObject*)(py_V51);
06470 Py_XINCREF(V51);
06471
06472 {
06473
06474 py_V53 = PyList_GET_ITEM(storage_V53, 0);
06475 {Py_XINCREF(py_V53);}
06476
06477 V53 = NULL;
06478 if (py_V53 == Py_None) {
06479 // We can either fail here or set V53 to NULL and rely on Ops
06480 // using tensors to handle the NULL case, but if they fail to do so
06481 // they'll end up with nasty segfaults, so this is public service.
06482 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
06483 {
06484 __failure = 54;
06485 if (!PyErr_Occurred()) {
06486 PyErr_SetString(PyExc_RuntimeError,
06487 "Unexpected error in an Op's C code. "
06488 "No Python exception was set.");
06489 }
06490 goto __label_54;}
06491 }
06492 if (!PyArray_Check(py_V53)) {
06493 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
06494 {
06495 __failure = 54;
06496 if (!PyErr_Occurred()) {
06497 PyErr_SetString(PyExc_RuntimeError,
06498 "Unexpected error in an Op's C code. "
06499 "No Python exception was set.");
06500 }
06501 goto __label_54;}
06502 }
06503 // We expect NPY_FLOAT64
06504 if (!PyArray_ISALIGNED((PyArrayObject*) py_V53)) {
06505 PyArrayObject * tmp = (PyArrayObject*) py_V53;
06506 PyErr_Format(PyExc_NotImplementedError,
06507 "expected an aligned array of type %ld "
06508 "(NPY_FLOAT64), got non-aligned array of type %ld"
06509 " with %ld dimensions, with 3 last dims "
06510 "%ld, %ld, %ld"
06511 " and 3 last strides %ld %ld, %ld.",
06512 (long int) NPY_FLOAT64,
06513 (long int) PyArray_TYPE((PyArrayObject*) py_V53),
06514 (long int) PyArray_NDIM(tmp),
06515 (long int) (PyArray_NDIM(tmp) >= 3 ?
06516 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
06517 (long int) (PyArray_NDIM(tmp) >= 2 ?
06518 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
06519 (long int) (PyArray_NDIM(tmp) >= 1 ?
06520 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
06521 (long int) (PyArray_NDIM(tmp) >= 3 ?
06522 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
06523 (long int) (PyArray_NDIM(tmp) >= 2 ?
06524 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
06525 (long int) (PyArray_NDIM(tmp) >= 1 ?
06526 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
06527 );
06528 {
06529 __failure = 54;
06530 if (!PyErr_Occurred()) {
06531 PyErr_SetString(PyExc_RuntimeError,
06532 "Unexpected error in an Op's C code. "
06533 "No Python exception was set.");
06534 }
06535 goto __label_54;}
06536 }
06537 // This is a TypeError to be consistent with DEBUG_MODE
06538 // Note: DEBUG_MODE also tells the name of the container
06539 if (PyArray_TYPE((PyArrayObject*) py_V53) != NPY_FLOAT64) {
06540 PyErr_Format(PyExc_TypeError,
06541 "expected type_num %d (NPY_FLOAT64) got %d",
06542 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V53));
06543 {
06544 __failure = 54;
06545 if (!PyErr_Occurred()) {
06546 PyErr_SetString(PyExc_RuntimeError,
06547 "Unexpected error in an Op's C code. "
06548 "No Python exception was set.");
06549 }
06550 goto __label_54;}
06551 }
06552
06553 V53 = (PyArrayObject*)(py_V53);
06554 Py_XINCREF(V53);
06555
06556 {
06557
06558 py_V55 = PyList_GET_ITEM(storage_V55, 0);
06559 {Py_XINCREF(py_V55);}
06560
06561 V55 = NULL;
06562 if (py_V55 == Py_None) {
06563 // We can either fail here or set V55 to NULL and rely on Ops
06564 // using tensors to handle the NULL case, but if they fail to do so
06565 // they'll end up with nasty segfaults, so this is public service.
06566 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
06567 {
06568 __failure = 56;
06569 if (!PyErr_Occurred()) {
06570 PyErr_SetString(PyExc_RuntimeError,
06571 "Unexpected error in an Op's C code. "
06572 "No Python exception was set.");
06573 }
06574 goto __label_56;}
06575 }
06576 if (!PyArray_Check(py_V55)) {
06577 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
06578 {
06579 __failure = 56;
06580 if (!PyErr_Occurred()) {
06581 PyErr_SetString(PyExc_RuntimeError,
06582 "Unexpected error in an Op's C code. "
06583 "No Python exception was set.");
06584 }
06585 goto __label_56;}
06586 }
06587 // We expect NPY_FLOAT64
06588 if (!PyArray_ISALIGNED((PyArrayObject*) py_V55)) {
06589 PyArrayObject * tmp = (PyArrayObject*) py_V55;
06590 PyErr_Format(PyExc_NotImplementedError,
06591 "expected an aligned array of type %ld "
06592 "(NPY_FLOAT64), got non-aligned array of type %ld"
06593 " with %ld dimensions, with 3 last dims "
06594 "%ld, %ld, %ld"
06595 " and 3 last strides %ld %ld, %ld.",
06596 (long int) NPY_FLOAT64,
06597 (long int) PyArray_TYPE((PyArrayObject*) py_V55),
06598 (long int) PyArray_NDIM(tmp),
06599 (long int) (PyArray_NDIM(tmp) >= 3 ?
06600 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
06601 (long int) (PyArray_NDIM(tmp) >= 2 ?
06602 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
06603 (long int) (PyArray_NDIM(tmp) >= 1 ?
06604 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
06605 (long int) (PyArray_NDIM(tmp) >= 3 ?
06606 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
06607 (long int) (PyArray_NDIM(tmp) >= 2 ?
06608 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
06609 (long int) (PyArray_NDIM(tmp) >= 1 ?
06610 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
06611 );
06612 {
06613 __failure = 56;
06614 if (!PyErr_Occurred()) {
06615 PyErr_SetString(PyExc_RuntimeError,
06616 "Unexpected error in an Op's C code. "
06617 "No Python exception was set.");
06618 }
06619 goto __label_56;}
06620 }
06621 // This is a TypeError to be consistent with DEBUG_MODE
06622 // Note: DEBUG_MODE also tells the name of the container
06623 if (PyArray_TYPE((PyArrayObject*) py_V55) != NPY_FLOAT64) {
06624 PyErr_Format(PyExc_TypeError,
06625 "expected type_num %d (NPY_FLOAT64) got %d",
06626 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V55));
06627 {
06628 __failure = 56;
06629 if (!PyErr_Occurred()) {
06630 PyErr_SetString(PyExc_RuntimeError,
06631 "Unexpected error in an Op's C code. "
06632 "No Python exception was set.");
06633 }
06634 goto __label_56;}
06635 }
06636
06637 V55 = (PyArrayObject*)(py_V55);
06638 Py_XINCREF(V55);
06639
06640 {
06641
06642 py_V57 = PyList_GET_ITEM(storage_V57, 0);
06643 {Py_XINCREF(py_V57);}
06644
06645 V57 = NULL;
06646 if (py_V57 == Py_None) {
06647 // We can either fail here or set V57 to NULL and rely on Ops
06648 // using tensors to handle the NULL case, but if they fail to do so
06649 // they'll end up with nasty segfaults, so this is public service.
06650 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
06651 {
06652 __failure = 58;
06653 if (!PyErr_Occurred()) {
06654 PyErr_SetString(PyExc_RuntimeError,
06655 "Unexpected error in an Op's C code. "
06656 "No Python exception was set.");
06657 }
06658 goto __label_58;}
06659 }
06660 if (!PyArray_Check(py_V57)) {
06661 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
06662 {
06663 __failure = 58;
06664 if (!PyErr_Occurred()) {
06665 PyErr_SetString(PyExc_RuntimeError,
06666 "Unexpected error in an Op's C code. "
06667 "No Python exception was set.");
06668 }
06669 goto __label_58;}
06670 }
06671 // We expect NPY_FLOAT64
06672 if (!PyArray_ISALIGNED((PyArrayObject*) py_V57)) {
06673 PyArrayObject * tmp = (PyArrayObject*) py_V57;
06674 PyErr_Format(PyExc_NotImplementedError,
06675 "expected an aligned array of type %ld "
06676 "(NPY_FLOAT64), got non-aligned array of type %ld"
06677 " with %ld dimensions, with 3 last dims "
06678 "%ld, %ld, %ld"
06679 " and 3 last strides %ld %ld, %ld.",
06680 (long int) NPY_FLOAT64,
06681 (long int) PyArray_TYPE((PyArrayObject*) py_V57),
06682 (long int) PyArray_NDIM(tmp),
06683 (long int) (PyArray_NDIM(tmp) >= 3 ?
06684 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
06685 (long int) (PyArray_NDIM(tmp) >= 2 ?
06686 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
06687 (long int) (PyArray_NDIM(tmp) >= 1 ?
06688 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
06689 (long int) (PyArray_NDIM(tmp) >= 3 ?
06690 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
06691 (long int) (PyArray_NDIM(tmp) >= 2 ?
06692 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
06693 (long int) (PyArray_NDIM(tmp) >= 1 ?
06694 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
06695 );
06696 {
06697 __failure = 58;
06698 if (!PyErr_Occurred()) {
06699 PyErr_SetString(PyExc_RuntimeError,
06700 "Unexpected error in an Op's C code. "
06701 "No Python exception was set.");
06702 }
06703 goto __label_58;}
06704 }
06705 // This is a TypeError to be consistent with DEBUG_MODE
06706 // Note: DEBUG_MODE also tells the name of the container
06707 if (PyArray_TYPE((PyArrayObject*) py_V57) != NPY_FLOAT64) {
06708 PyErr_Format(PyExc_TypeError,
06709 "expected type_num %d (NPY_FLOAT64) got %d",
06710 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V57));
06711 {
06712 __failure = 58;
06713 if (!PyErr_Occurred()) {
06714 PyErr_SetString(PyExc_RuntimeError,
06715 "Unexpected error in an Op's C code. "
06716 "No Python exception was set.");
06717 }
06718 goto __label_58;}
06719 }
06720
06721 V57 = (PyArrayObject*)(py_V57);
06722 Py_XINCREF(V57);
06723
06724 {
06725
06726 py_V59 = PyList_GET_ITEM(storage_V59, 0);
06727 {Py_XINCREF(py_V59);}
06728
06729 V59 = NULL;
06730 if (py_V59 == Py_None) {
06731 // We can either fail here or set V59 to NULL and rely on Ops
06732 // using tensors to handle the NULL case, but if they fail to do so
06733 // they'll end up with nasty segfaults, so this is public service.
06734 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
06735 {
06736 __failure = 60;
06737 if (!PyErr_Occurred()) {
06738 PyErr_SetString(PyExc_RuntimeError,
06739 "Unexpected error in an Op's C code. "
06740 "No Python exception was set.");
06741 }
06742 goto __label_60;}
06743 }
06744 if (!PyArray_Check(py_V59)) {
06745 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
06746 {
06747 __failure = 60;
06748 if (!PyErr_Occurred()) {
06749 PyErr_SetString(PyExc_RuntimeError,
06750 "Unexpected error in an Op's C code. "
06751 "No Python exception was set.");
06752 }
06753 goto __label_60;}
06754 }
06755 // We expect NPY_FLOAT64
06756 if (!PyArray_ISALIGNED((PyArrayObject*) py_V59)) {
06757 PyArrayObject * tmp = (PyArrayObject*) py_V59;
06758 PyErr_Format(PyExc_NotImplementedError,
06759 "expected an aligned array of type %ld "
06760 "(NPY_FLOAT64), got non-aligned array of type %ld"
06761 " with %ld dimensions, with 3 last dims "
06762 "%ld, %ld, %ld"
06763 " and 3 last strides %ld %ld, %ld.",
06764 (long int) NPY_FLOAT64,
06765 (long int) PyArray_TYPE((PyArrayObject*) py_V59),
06766 (long int) PyArray_NDIM(tmp),
06767 (long int) (PyArray_NDIM(tmp) >= 3 ?
06768 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
06769 (long int) (PyArray_NDIM(tmp) >= 2 ?
06770 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
06771 (long int) (PyArray_NDIM(tmp) >= 1 ?
06772 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
06773 (long int) (PyArray_NDIM(tmp) >= 3 ?
06774 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
06775 (long int) (PyArray_NDIM(tmp) >= 2 ?
06776 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
06777 (long int) (PyArray_NDIM(tmp) >= 1 ?
06778 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
06779 );
06780 {
06781 __failure = 60;
06782 if (!PyErr_Occurred()) {
06783 PyErr_SetString(PyExc_RuntimeError,
06784 "Unexpected error in an Op's C code. "
06785 "No Python exception was set.");
06786 }
06787 goto __label_60;}
06788 }
06789 // This is a TypeError to be consistent with DEBUG_MODE
06790 // Note: DEBUG_MODE also tells the name of the container
06791 if (PyArray_TYPE((PyArrayObject*) py_V59) != NPY_FLOAT64) {
06792 PyErr_Format(PyExc_TypeError,
06793 "expected type_num %d (NPY_FLOAT64) got %d",
06794 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V59));
06795 {
06796 __failure = 60;
06797 if (!PyErr_Occurred()) {
06798 PyErr_SetString(PyExc_RuntimeError,
06799 "Unexpected error in an Op's C code. "
06800 "No Python exception was set.");
06801 }
06802 goto __label_60;}
06803 }
06804
06805 V59 = (PyArrayObject*)(py_V59);
06806 Py_XINCREF(V59);
06807
06808 {
06809
06810 py_V61 = PyList_GET_ITEM(storage_V61, 0);
06811 {Py_XINCREF(py_V61);}
06812
06813 V61 = NULL;
06814 if (py_V61 == Py_None) {
06815 // We can either fail here or set V61 to NULL and rely on Ops
06816 // using tensors to handle the NULL case, but if they fail to do so
06817 // they'll end up with nasty segfaults, so this is public service.
06818 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
06819 {
06820 __failure = 62;
06821 if (!PyErr_Occurred()) {
06822 PyErr_SetString(PyExc_RuntimeError,
06823 "Unexpected error in an Op's C code. "
06824 "No Python exception was set.");
06825 }
06826 goto __label_62;}
06827 }
06828 if (!PyArray_Check(py_V61)) {
06829 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
06830 {
06831 __failure = 62;
06832 if (!PyErr_Occurred()) {
06833 PyErr_SetString(PyExc_RuntimeError,
06834 "Unexpected error in an Op's C code. "
06835 "No Python exception was set.");
06836 }
06837 goto __label_62;}
06838 }
06839 // We expect NPY_FLOAT64
06840 if (!PyArray_ISALIGNED((PyArrayObject*) py_V61)) {
06841 PyArrayObject * tmp = (PyArrayObject*) py_V61;
06842 PyErr_Format(PyExc_NotImplementedError,
06843 "expected an aligned array of type %ld "
06844 "(NPY_FLOAT64), got non-aligned array of type %ld"
06845 " with %ld dimensions, with 3 last dims "
06846 "%ld, %ld, %ld"
06847 " and 3 last strides %ld %ld, %ld.",
06848 (long int) NPY_FLOAT64,
06849 (long int) PyArray_TYPE((PyArrayObject*) py_V61),
06850 (long int) PyArray_NDIM(tmp),
06851 (long int) (PyArray_NDIM(tmp) >= 3 ?
06852 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
06853 (long int) (PyArray_NDIM(tmp) >= 2 ?
06854 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
06855 (long int) (PyArray_NDIM(tmp) >= 1 ?
06856 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
06857 (long int) (PyArray_NDIM(tmp) >= 3 ?
06858 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
06859 (long int) (PyArray_NDIM(tmp) >= 2 ?
06860 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
06861 (long int) (PyArray_NDIM(tmp) >= 1 ?
06862 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
06863 );
06864 {
06865 __failure = 62;
06866 if (!PyErr_Occurred()) {
06867 PyErr_SetString(PyExc_RuntimeError,
06868 "Unexpected error in an Op's C code. "
06869 "No Python exception was set.");
06870 }
06871 goto __label_62;}
06872 }
06873 // This is a TypeError to be consistent with DEBUG_MODE
06874 // Note: DEBUG_MODE also tells the name of the container
06875 if (PyArray_TYPE((PyArrayObject*) py_V61) != NPY_FLOAT64) {
06876 PyErr_Format(PyExc_TypeError,
06877 "expected type_num %d (NPY_FLOAT64) got %d",
06878 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V61));
06879 {
06880 __failure = 62;
06881 if (!PyErr_Occurred()) {
06882 PyErr_SetString(PyExc_RuntimeError,
06883 "Unexpected error in an Op's C code. "
06884 "No Python exception was set.");
06885 }
06886 goto __label_62;}
06887 }
06888
06889 V61 = (PyArrayObject*)(py_V61);
06890 Py_XINCREF(V61);
06891
06892 {
06893
06894 py_V63 = PyList_GET_ITEM(storage_V63, 0);
06895 {Py_XINCREF(py_V63);}
06896
06897 V63 = NULL;
06898 if (py_V63 == Py_None) {
06899 // We can either fail here or set V63 to NULL and rely on Ops
06900 // using tensors to handle the NULL case, but if they fail to do so
06901 // they'll end up with nasty segfaults, so this is public service.
06902 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
06903 {
06904 __failure = 64;
06905 if (!PyErr_Occurred()) {
06906 PyErr_SetString(PyExc_RuntimeError,
06907 "Unexpected error in an Op's C code. "
06908 "No Python exception was set.");
06909 }
06910 goto __label_64;}
06911 }
06912 if (!PyArray_Check(py_V63)) {
06913 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
06914 {
06915 __failure = 64;
06916 if (!PyErr_Occurred()) {
06917 PyErr_SetString(PyExc_RuntimeError,
06918 "Unexpected error in an Op's C code. "
06919 "No Python exception was set.");
06920 }
06921 goto __label_64;}
06922 }
06923 // We expect NPY_FLOAT64
06924 if (!PyArray_ISALIGNED((PyArrayObject*) py_V63)) {
06925 PyArrayObject * tmp = (PyArrayObject*) py_V63;
06926 PyErr_Format(PyExc_NotImplementedError,
06927 "expected an aligned array of type %ld "
06928 "(NPY_FLOAT64), got non-aligned array of type %ld"
06929 " with %ld dimensions, with 3 last dims "
06930 "%ld, %ld, %ld"
06931 " and 3 last strides %ld %ld, %ld.",
06932 (long int) NPY_FLOAT64,
06933 (long int) PyArray_TYPE((PyArrayObject*) py_V63),
06934 (long int) PyArray_NDIM(tmp),
06935 (long int) (PyArray_NDIM(tmp) >= 3 ?
06936 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
06937 (long int) (PyArray_NDIM(tmp) >= 2 ?
06938 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
06939 (long int) (PyArray_NDIM(tmp) >= 1 ?
06940 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
06941 (long int) (PyArray_NDIM(tmp) >= 3 ?
06942 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
06943 (long int) (PyArray_NDIM(tmp) >= 2 ?
06944 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
06945 (long int) (PyArray_NDIM(tmp) >= 1 ?
06946 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
06947 );
06948 {
06949 __failure = 64;
06950 if (!PyErr_Occurred()) {
06951 PyErr_SetString(PyExc_RuntimeError,
06952 "Unexpected error in an Op's C code. "
06953 "No Python exception was set.");
06954 }
06955 goto __label_64;}
06956 }
06957 // This is a TypeError to be consistent with DEBUG_MODE
06958 // Note: DEBUG_MODE also tells the name of the container
06959 if (PyArray_TYPE((PyArrayObject*) py_V63) != NPY_FLOAT64) {
06960 PyErr_Format(PyExc_TypeError,
06961 "expected type_num %d (NPY_FLOAT64) got %d",
06962 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V63));
06963 {
06964 __failure = 64;
06965 if (!PyErr_Occurred()) {
06966 PyErr_SetString(PyExc_RuntimeError,
06967 "Unexpected error in an Op's C code. "
06968 "No Python exception was set.");
06969 }
06970 goto __label_64;}
06971 }
06972
06973 V63 = (PyArrayObject*)(py_V63);
06974 Py_XINCREF(V63);
06975
06976 {
06977
06978 py_V65 = PyList_GET_ITEM(storage_V65, 0);
06979 {Py_XINCREF(py_V65);}
06980
06981 V65 = NULL;
06982 if (py_V65 == Py_None) {
06983 // We can either fail here or set V65 to NULL and rely on Ops
06984 // using tensors to handle the NULL case, but if they fail to do so
06985 // they'll end up with nasty segfaults, so this is public service.
06986 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
06987 {
06988 __failure = 66;
06989 if (!PyErr_Occurred()) {
06990 PyErr_SetString(PyExc_RuntimeError,
06991 "Unexpected error in an Op's C code. "
06992 "No Python exception was set.");
06993 }
06994 goto __label_66;}
06995 }
06996 if (!PyArray_Check(py_V65)) {
06997 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
06998 {
06999 __failure = 66;
07000 if (!PyErr_Occurred()) {
07001 PyErr_SetString(PyExc_RuntimeError,
07002 "Unexpected error in an Op's C code. "
07003 "No Python exception was set.");
07004 }
07005 goto __label_66;}
07006 }
07007 // We expect NPY_FLOAT64
07008 if (!PyArray_ISALIGNED((PyArrayObject*) py_V65)) {
07009 PyArrayObject * tmp = (PyArrayObject*) py_V65;
07010 PyErr_Format(PyExc_NotImplementedError,
07011 "expected an aligned array of type %ld "
07012 "(NPY_FLOAT64), got non-aligned array of type %ld"
07013 " with %ld dimensions, with 3 last dims "
07014 "%ld, %ld, %ld"
07015 " and 3 last strides %ld %ld, %ld.",
07016 (long int) NPY_FLOAT64,
07017 (long int) PyArray_TYPE((PyArrayObject*) py_V65),
07018 (long int) PyArray_NDIM(tmp),
07019 (long int) (PyArray_NDIM(tmp) >= 3 ?
07020 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
07021 (long int) (PyArray_NDIM(tmp) >= 2 ?
07022 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
07023 (long int) (PyArray_NDIM(tmp) >= 1 ?
07024 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
07025 (long int) (PyArray_NDIM(tmp) >= 3 ?
07026 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
07027 (long int) (PyArray_NDIM(tmp) >= 2 ?
07028 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
07029 (long int) (PyArray_NDIM(tmp) >= 1 ?
07030 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
07031 );
07032 {
07033 __failure = 66;
07034 if (!PyErr_Occurred()) {
07035 PyErr_SetString(PyExc_RuntimeError,
07036 "Unexpected error in an Op's C code. "
07037 "No Python exception was set.");
07038 }
07039 goto __label_66;}
07040 }
07041 // This is a TypeError to be consistent with DEBUG_MODE
07042 // Note: DEBUG_MODE also tells the name of the container
07043 if (PyArray_TYPE((PyArrayObject*) py_V65) != NPY_FLOAT64) {
07044 PyErr_Format(PyExc_TypeError,
07045 "expected type_num %d (NPY_FLOAT64) got %d",
07046 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V65));
07047 {
07048 __failure = 66;
07049 if (!PyErr_Occurred()) {
07050 PyErr_SetString(PyExc_RuntimeError,
07051 "Unexpected error in an Op's C code. "
07052 "No Python exception was set.");
07053 }
07054 goto __label_66;}
07055 }
07056
07057 V65 = (PyArrayObject*)(py_V65);
07058 Py_XINCREF(V65);
07059
07060 {
07061
07062 py_V67 = PyList_GET_ITEM(storage_V67, 0);
07063 {Py_XINCREF(py_V67);}
07064
07065 V67 = NULL;
07066 if (py_V67 == Py_None) {
07067 // We can either fail here or set V67 to NULL and rely on Ops
07068 // using tensors to handle the NULL case, but if they fail to do so
07069 // they'll end up with nasty segfaults, so this is public service.
07070 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
07071 {
07072 __failure = 68;
07073 if (!PyErr_Occurred()) {
07074 PyErr_SetString(PyExc_RuntimeError,
07075 "Unexpected error in an Op's C code. "
07076 "No Python exception was set.");
07077 }
07078 goto __label_68;}
07079 }
07080 if (!PyArray_Check(py_V67)) {
07081 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
07082 {
07083 __failure = 68;
07084 if (!PyErr_Occurred()) {
07085 PyErr_SetString(PyExc_RuntimeError,
07086 "Unexpected error in an Op's C code. "
07087 "No Python exception was set.");
07088 }
07089 goto __label_68;}
07090 }
07091 // We expect NPY_FLOAT64
07092 if (!PyArray_ISALIGNED((PyArrayObject*) py_V67)) {
07093 PyArrayObject * tmp = (PyArrayObject*) py_V67;
07094 PyErr_Format(PyExc_NotImplementedError,
07095 "expected an aligned array of type %ld "
07096 "(NPY_FLOAT64), got non-aligned array of type %ld"
07097 " with %ld dimensions, with 3 last dims "
07098 "%ld, %ld, %ld"
07099 " and 3 last strides %ld %ld, %ld.",
07100 (long int) NPY_FLOAT64,
07101 (long int) PyArray_TYPE((PyArrayObject*) py_V67),
07102 (long int) PyArray_NDIM(tmp),
07103 (long int) (PyArray_NDIM(tmp) >= 3 ?
07104 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
07105 (long int) (PyArray_NDIM(tmp) >= 2 ?
07106 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
07107 (long int) (PyArray_NDIM(tmp) >= 1 ?
07108 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
07109 (long int) (PyArray_NDIM(tmp) >= 3 ?
07110 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
07111 (long int) (PyArray_NDIM(tmp) >= 2 ?
07112 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
07113 (long int) (PyArray_NDIM(tmp) >= 1 ?
07114 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
07115 );
07116 {
07117 __failure = 68;
07118 if (!PyErr_Occurred()) {
07119 PyErr_SetString(PyExc_RuntimeError,
07120 "Unexpected error in an Op's C code. "
07121 "No Python exception was set.");
07122 }
07123 goto __label_68;}
07124 }
07125 // This is a TypeError to be consistent with DEBUG_MODE
07126 // Note: DEBUG_MODE also tells the name of the container
07127 if (PyArray_TYPE((PyArrayObject*) py_V67) != NPY_FLOAT64) {
07128 PyErr_Format(PyExc_TypeError,
07129 "expected type_num %d (NPY_FLOAT64) got %d",
07130 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V67));
07131 {
07132 __failure = 68;
07133 if (!PyErr_Occurred()) {
07134 PyErr_SetString(PyExc_RuntimeError,
07135 "Unexpected error in an Op's C code. "
07136 "No Python exception was set.");
07137 }
07138 goto __label_68;}
07139 }
07140
07141 V67 = (PyArrayObject*)(py_V67);
07142 Py_XINCREF(V67);
07143
07144 {
07145
07146 py_V69 = PyList_GET_ITEM(storage_V69, 0);
07147 {Py_XINCREF(py_V69);}
07148
07149 V69 = NULL;
07150 if (py_V69 == Py_None) {
07151 // We can either fail here or set V69 to NULL and rely on Ops
07152 // using tensors to handle the NULL case, but if they fail to do so
07153 // they'll end up with nasty segfaults, so this is public service.
07154 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
07155 {
07156 __failure = 70;
07157 if (!PyErr_Occurred()) {
07158 PyErr_SetString(PyExc_RuntimeError,
07159 "Unexpected error in an Op's C code. "
07160 "No Python exception was set.");
07161 }
07162 goto __label_70;}
07163 }
07164 if (!PyArray_Check(py_V69)) {
07165 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
07166 {
07167 __failure = 70;
07168 if (!PyErr_Occurred()) {
07169 PyErr_SetString(PyExc_RuntimeError,
07170 "Unexpected error in an Op's C code. "
07171 "No Python exception was set.");
07172 }
07173 goto __label_70;}
07174 }
07175 // We expect NPY_FLOAT64
07176 if (!PyArray_ISALIGNED((PyArrayObject*) py_V69)) {
07177 PyArrayObject * tmp = (PyArrayObject*) py_V69;
07178 PyErr_Format(PyExc_NotImplementedError,
07179 "expected an aligned array of type %ld "
07180 "(NPY_FLOAT64), got non-aligned array of type %ld"
07181 " with %ld dimensions, with 3 last dims "
07182 "%ld, %ld, %ld"
07183 " and 3 last strides %ld %ld, %ld.",
07184 (long int) NPY_FLOAT64,
07185 (long int) PyArray_TYPE((PyArrayObject*) py_V69),
07186 (long int) PyArray_NDIM(tmp),
07187 (long int) (PyArray_NDIM(tmp) >= 3 ?
07188 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
07189 (long int) (PyArray_NDIM(tmp) >= 2 ?
07190 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
07191 (long int) (PyArray_NDIM(tmp) >= 1 ?
07192 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
07193 (long int) (PyArray_NDIM(tmp) >= 3 ?
07194 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
07195 (long int) (PyArray_NDIM(tmp) >= 2 ?
07196 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
07197 (long int) (PyArray_NDIM(tmp) >= 1 ?
07198 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
07199 );
07200 {
07201 __failure = 70;
07202 if (!PyErr_Occurred()) {
07203 PyErr_SetString(PyExc_RuntimeError,
07204 "Unexpected error in an Op's C code. "
07205 "No Python exception was set.");
07206 }
07207 goto __label_70;}
07208 }
07209 // This is a TypeError to be consistent with DEBUG_MODE
07210 // Note: DEBUG_MODE also tells the name of the container
07211 if (PyArray_TYPE((PyArrayObject*) py_V69) != NPY_FLOAT64) {
07212 PyErr_Format(PyExc_TypeError,
07213 "expected type_num %d (NPY_FLOAT64) got %d",
07214 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V69));
07215 {
07216 __failure = 70;
07217 if (!PyErr_Occurred()) {
07218 PyErr_SetString(PyExc_RuntimeError,
07219 "Unexpected error in an Op's C code. "
07220 "No Python exception was set.");
07221 }
07222 goto __label_70;}
07223 }
07224
07225 V69 = (PyArrayObject*)(py_V69);
07226 Py_XINCREF(V69);
07227
07228 {
07229
07230 py_V71 = PyList_GET_ITEM(storage_V71, 0);
07231 {Py_XINCREF(py_V71);}
07232
07233 V71 = NULL;
07234 if (py_V71 == Py_None) {
07235 // We can either fail here or set V71 to NULL and rely on Ops
07236 // using tensors to handle the NULL case, but if they fail to do so
07237 // they'll end up with nasty segfaults, so this is public service.
07238 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
07239 {
07240 __failure = 72;
07241 if (!PyErr_Occurred()) {
07242 PyErr_SetString(PyExc_RuntimeError,
07243 "Unexpected error in an Op's C code. "
07244 "No Python exception was set.");
07245 }
07246 goto __label_72;}
07247 }
07248 if (!PyArray_Check(py_V71)) {
07249 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
07250 {
07251 __failure = 72;
07252 if (!PyErr_Occurred()) {
07253 PyErr_SetString(PyExc_RuntimeError,
07254 "Unexpected error in an Op's C code. "
07255 "No Python exception was set.");
07256 }
07257 goto __label_72;}
07258 }
07259 // We expect NPY_FLOAT64
07260 if (!PyArray_ISALIGNED((PyArrayObject*) py_V71)) {
07261 PyArrayObject * tmp = (PyArrayObject*) py_V71;
07262 PyErr_Format(PyExc_NotImplementedError,
07263 "expected an aligned array of type %ld "
07264 "(NPY_FLOAT64), got non-aligned array of type %ld"
07265 " with %ld dimensions, with 3 last dims "
07266 "%ld, %ld, %ld"
07267 " and 3 last strides %ld %ld, %ld.",
07268 (long int) NPY_FLOAT64,
07269 (long int) PyArray_TYPE((PyArrayObject*) py_V71),
07270 (long int) PyArray_NDIM(tmp),
07271 (long int) (PyArray_NDIM(tmp) >= 3 ?
07272 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
07273 (long int) (PyArray_NDIM(tmp) >= 2 ?
07274 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
07275 (long int) (PyArray_NDIM(tmp) >= 1 ?
07276 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
07277 (long int) (PyArray_NDIM(tmp) >= 3 ?
07278 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
07279 (long int) (PyArray_NDIM(tmp) >= 2 ?
07280 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
07281 (long int) (PyArray_NDIM(tmp) >= 1 ?
07282 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
07283 );
07284 {
07285 __failure = 72;
07286 if (!PyErr_Occurred()) {
07287 PyErr_SetString(PyExc_RuntimeError,
07288 "Unexpected error in an Op's C code. "
07289 "No Python exception was set.");
07290 }
07291 goto __label_72;}
07292 }
07293 // This is a TypeError to be consistent with DEBUG_MODE
07294 // Note: DEBUG_MODE also tells the name of the container
07295 if (PyArray_TYPE((PyArrayObject*) py_V71) != NPY_FLOAT64) {
07296 PyErr_Format(PyExc_TypeError,
07297 "expected type_num %d (NPY_FLOAT64) got %d",
07298 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V71));
07299 {
07300 __failure = 72;
07301 if (!PyErr_Occurred()) {
07302 PyErr_SetString(PyExc_RuntimeError,
07303 "Unexpected error in an Op's C code. "
07304 "No Python exception was set.");
07305 }
07306 goto __label_72;}
07307 }
07308
07309 V71 = (PyArrayObject*)(py_V71);
07310 Py_XINCREF(V71);
07311
07312 {
07313
07314 py_V73 = PyList_GET_ITEM(storage_V73, 0);
07315 {Py_XINCREF(py_V73);}
07316
07317 V73 = NULL;
07318 if (py_V73 == Py_None) {
07319 // We can either fail here or set V73 to NULL and rely on Ops
07320 // using tensors to handle the NULL case, but if they fail to do so
07321 // they'll end up with nasty segfaults, so this is public service.
07322 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
07323 {
07324 __failure = 74;
07325 if (!PyErr_Occurred()) {
07326 PyErr_SetString(PyExc_RuntimeError,
07327 "Unexpected error in an Op's C code. "
07328 "No Python exception was set.");
07329 }
07330 goto __label_74;}
07331 }
07332 if (!PyArray_Check(py_V73)) {
07333 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
07334 {
07335 __failure = 74;
07336 if (!PyErr_Occurred()) {
07337 PyErr_SetString(PyExc_RuntimeError,
07338 "Unexpected error in an Op's C code. "
07339 "No Python exception was set.");
07340 }
07341 goto __label_74;}
07342 }
07343 // We expect NPY_FLOAT64
07344 if (!PyArray_ISALIGNED((PyArrayObject*) py_V73)) {
07345 PyArrayObject * tmp = (PyArrayObject*) py_V73;
07346 PyErr_Format(PyExc_NotImplementedError,
07347 "expected an aligned array of type %ld "
07348 "(NPY_FLOAT64), got non-aligned array of type %ld"
07349 " with %ld dimensions, with 3 last dims "
07350 "%ld, %ld, %ld"
07351 " and 3 last strides %ld %ld, %ld.",
07352 (long int) NPY_FLOAT64,
07353 (long int) PyArray_TYPE((PyArrayObject*) py_V73),
07354 (long int) PyArray_NDIM(tmp),
07355 (long int) (PyArray_NDIM(tmp) >= 3 ?
07356 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
07357 (long int) (PyArray_NDIM(tmp) >= 2 ?
07358 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
07359 (long int) (PyArray_NDIM(tmp) >= 1 ?
07360 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
07361 (long int) (PyArray_NDIM(tmp) >= 3 ?
07362 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
07363 (long int) (PyArray_NDIM(tmp) >= 2 ?
07364 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
07365 (long int) (PyArray_NDIM(tmp) >= 1 ?
07366 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
07367 );
07368 {
07369 __failure = 74;
07370 if (!PyErr_Occurred()) {
07371 PyErr_SetString(PyExc_RuntimeError,
07372 "Unexpected error in an Op's C code. "
07373 "No Python exception was set.");
07374 }
07375 goto __label_74;}
07376 }
07377 // This is a TypeError to be consistent with DEBUG_MODE
07378 // Note: DEBUG_MODE also tells the name of the container
07379 if (PyArray_TYPE((PyArrayObject*) py_V73) != NPY_FLOAT64) {
07380 PyErr_Format(PyExc_TypeError,
07381 "expected type_num %d (NPY_FLOAT64) got %d",
07382 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V73));
07383 {
07384 __failure = 74;
07385 if (!PyErr_Occurred()) {
07386 PyErr_SetString(PyExc_RuntimeError,
07387 "Unexpected error in an Op's C code. "
07388 "No Python exception was set.");
07389 }
07390 goto __label_74;}
07391 }
07392
07393 V73 = (PyArrayObject*)(py_V73);
07394 Py_XINCREF(V73);
07395
07396 {
07397
07398 py_V75 = PyList_GET_ITEM(storage_V75, 0);
07399 {Py_XINCREF(py_V75);}
07400
07401 V75 = NULL;
07402 if (py_V75 == Py_None) {
07403 // We can either fail here or set V75 to NULL and rely on Ops
07404 // using tensors to handle the NULL case, but if they fail to do so
07405 // they'll end up with nasty segfaults, so this is public service.
07406 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
07407 {
07408 __failure = 76;
07409 if (!PyErr_Occurred()) {
07410 PyErr_SetString(PyExc_RuntimeError,
07411 "Unexpected error in an Op's C code. "
07412 "No Python exception was set.");
07413 }
07414 goto __label_76;}
07415 }
07416 if (!PyArray_Check(py_V75)) {
07417 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
07418 {
07419 __failure = 76;
07420 if (!PyErr_Occurred()) {
07421 PyErr_SetString(PyExc_RuntimeError,
07422 "Unexpected error in an Op's C code. "
07423 "No Python exception was set.");
07424 }
07425 goto __label_76;}
07426 }
07427 // We expect NPY_FLOAT64
07428 if (!PyArray_ISALIGNED((PyArrayObject*) py_V75)) {
07429 PyArrayObject * tmp = (PyArrayObject*) py_V75;
07430 PyErr_Format(PyExc_NotImplementedError,
07431 "expected an aligned array of type %ld "
07432 "(NPY_FLOAT64), got non-aligned array of type %ld"
07433 " with %ld dimensions, with 3 last dims "
07434 "%ld, %ld, %ld"
07435 " and 3 last strides %ld %ld, %ld.",
07436 (long int) NPY_FLOAT64,
07437 (long int) PyArray_TYPE((PyArrayObject*) py_V75),
07438 (long int) PyArray_NDIM(tmp),
07439 (long int) (PyArray_NDIM(tmp) >= 3 ?
07440 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
07441 (long int) (PyArray_NDIM(tmp) >= 2 ?
07442 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
07443 (long int) (PyArray_NDIM(tmp) >= 1 ?
07444 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
07445 (long int) (PyArray_NDIM(tmp) >= 3 ?
07446 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
07447 (long int) (PyArray_NDIM(tmp) >= 2 ?
07448 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
07449 (long int) (PyArray_NDIM(tmp) >= 1 ?
07450 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
07451 );
07452 {
07453 __failure = 76;
07454 if (!PyErr_Occurred()) {
07455 PyErr_SetString(PyExc_RuntimeError,
07456 "Unexpected error in an Op's C code. "
07457 "No Python exception was set.");
07458 }
07459 goto __label_76;}
07460 }
07461 // This is a TypeError to be consistent with DEBUG_MODE
07462 // Note: DEBUG_MODE also tells the name of the container
07463 if (PyArray_TYPE((PyArrayObject*) py_V75) != NPY_FLOAT64) {
07464 PyErr_Format(PyExc_TypeError,
07465 "expected type_num %d (NPY_FLOAT64) got %d",
07466 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V75));
07467 {
07468 __failure = 76;
07469 if (!PyErr_Occurred()) {
07470 PyErr_SetString(PyExc_RuntimeError,
07471 "Unexpected error in an Op's C code. "
07472 "No Python exception was set.");
07473 }
07474 goto __label_76;}
07475 }
07476
07477 V75 = (PyArrayObject*)(py_V75);
07478 Py_XINCREF(V75);
07479
07480 {
07481
07482 py_V77 = PyList_GET_ITEM(storage_V77, 0);
07483 {Py_XINCREF(py_V77);}
07484
07485 V77 = NULL;
07486 if (py_V77 == Py_None) {
07487 // We can either fail here or set V77 to NULL and rely on Ops
07488 // using tensors to handle the NULL case, but if they fail to do so
07489 // they'll end up with nasty segfaults, so this is public service.
07490 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
07491 {
07492 __failure = 78;
07493 if (!PyErr_Occurred()) {
07494 PyErr_SetString(PyExc_RuntimeError,
07495 "Unexpected error in an Op's C code. "
07496 "No Python exception was set.");
07497 }
07498 goto __label_78;}
07499 }
07500 if (!PyArray_Check(py_V77)) {
07501 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
07502 {
07503 __failure = 78;
07504 if (!PyErr_Occurred()) {
07505 PyErr_SetString(PyExc_RuntimeError,
07506 "Unexpected error in an Op's C code. "
07507 "No Python exception was set.");
07508 }
07509 goto __label_78;}
07510 }
07511 // We expect NPY_FLOAT64
07512 if (!PyArray_ISALIGNED((PyArrayObject*) py_V77)) {
07513 PyArrayObject * tmp = (PyArrayObject*) py_V77;
07514 PyErr_Format(PyExc_NotImplementedError,
07515 "expected an aligned array of type %ld "
07516 "(NPY_FLOAT64), got non-aligned array of type %ld"
07517 " with %ld dimensions, with 3 last dims "
07518 "%ld, %ld, %ld"
07519 " and 3 last strides %ld %ld, %ld.",
07520 (long int) NPY_FLOAT64,
07521 (long int) PyArray_TYPE((PyArrayObject*) py_V77),
07522 (long int) PyArray_NDIM(tmp),
07523 (long int) (PyArray_NDIM(tmp) >= 3 ?
07524 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
07525 (long int) (PyArray_NDIM(tmp) >= 2 ?
07526 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
07527 (long int) (PyArray_NDIM(tmp) >= 1 ?
07528 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
07529 (long int) (PyArray_NDIM(tmp) >= 3 ?
07530 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
07531 (long int) (PyArray_NDIM(tmp) >= 2 ?
07532 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
07533 (long int) (PyArray_NDIM(tmp) >= 1 ?
07534 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
07535 );
07536 {
07537 __failure = 78;
07538 if (!PyErr_Occurred()) {
07539 PyErr_SetString(PyExc_RuntimeError,
07540 "Unexpected error in an Op's C code. "
07541 "No Python exception was set.");
07542 }
07543 goto __label_78;}
07544 }
07545 // This is a TypeError to be consistent with DEBUG_MODE
07546 // Note: DEBUG_MODE also tells the name of the container
07547 if (PyArray_TYPE((PyArrayObject*) py_V77) != NPY_FLOAT64) {
07548 PyErr_Format(PyExc_TypeError,
07549 "expected type_num %d (NPY_FLOAT64) got %d",
07550 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V77));
07551 {
07552 __failure = 78;
07553 if (!PyErr_Occurred()) {
07554 PyErr_SetString(PyExc_RuntimeError,
07555 "Unexpected error in an Op's C code. "
07556 "No Python exception was set.");
07557 }
07558 goto __label_78;}
07559 }
07560
07561 V77 = (PyArrayObject*)(py_V77);
07562 Py_XINCREF(V77);
07563
07564 {
07565
07566 py_V79 = PyList_GET_ITEM(storage_V79, 0);
07567 {Py_XINCREF(py_V79);}
07568
07569 V79 = NULL;
07570 if (py_V79 == Py_None) {
07571 // We can either fail here or set V79 to NULL and rely on Ops
07572 // using tensors to handle the NULL case, but if they fail to do so
07573 // they'll end up with nasty segfaults, so this is public service.
07574 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
07575 {
07576 __failure = 80;
07577 if (!PyErr_Occurred()) {
07578 PyErr_SetString(PyExc_RuntimeError,
07579 "Unexpected error in an Op's C code. "
07580 "No Python exception was set.");
07581 }
07582 goto __label_80;}
07583 }
07584 if (!PyArray_Check(py_V79)) {
07585 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
07586 {
07587 __failure = 80;
07588 if (!PyErr_Occurred()) {
07589 PyErr_SetString(PyExc_RuntimeError,
07590 "Unexpected error in an Op's C code. "
07591 "No Python exception was set.");
07592 }
07593 goto __label_80;}
07594 }
07595 // We expect NPY_FLOAT64
07596 if (!PyArray_ISALIGNED((PyArrayObject*) py_V79)) {
07597 PyArrayObject * tmp = (PyArrayObject*) py_V79;
07598 PyErr_Format(PyExc_NotImplementedError,
07599 "expected an aligned array of type %ld "
07600 "(NPY_FLOAT64), got non-aligned array of type %ld"
07601 " with %ld dimensions, with 3 last dims "
07602 "%ld, %ld, %ld"
07603 " and 3 last strides %ld %ld, %ld.",
07604 (long int) NPY_FLOAT64,
07605 (long int) PyArray_TYPE((PyArrayObject*) py_V79),
07606 (long int) PyArray_NDIM(tmp),
07607 (long int) (PyArray_NDIM(tmp) >= 3 ?
07608 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
07609 (long int) (PyArray_NDIM(tmp) >= 2 ?
07610 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
07611 (long int) (PyArray_NDIM(tmp) >= 1 ?
07612 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
07613 (long int) (PyArray_NDIM(tmp) >= 3 ?
07614 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
07615 (long int) (PyArray_NDIM(tmp) >= 2 ?
07616 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
07617 (long int) (PyArray_NDIM(tmp) >= 1 ?
07618 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
07619 );
07620 {
07621 __failure = 80;
07622 if (!PyErr_Occurred()) {
07623 PyErr_SetString(PyExc_RuntimeError,
07624 "Unexpected error in an Op's C code. "
07625 "No Python exception was set.");
07626 }
07627 goto __label_80;}
07628 }
07629 // This is a TypeError to be consistent with DEBUG_MODE
07630 // Note: DEBUG_MODE also tells the name of the container
07631 if (PyArray_TYPE((PyArrayObject*) py_V79) != NPY_FLOAT64) {
07632 PyErr_Format(PyExc_TypeError,
07633 "expected type_num %d (NPY_FLOAT64) got %d",
07634 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V79));
07635 {
07636 __failure = 80;
07637 if (!PyErr_Occurred()) {
07638 PyErr_SetString(PyExc_RuntimeError,
07639 "Unexpected error in an Op's C code. "
07640 "No Python exception was set.");
07641 }
07642 goto __label_80;}
07643 }
07644
07645 V79 = (PyArrayObject*)(py_V79);
07646 Py_XINCREF(V79);
07647
07648 {
07649
07650 py_V81 = PyList_GET_ITEM(storage_V81, 0);
07651 {Py_XINCREF(py_V81);}
07652
07653 V81 = NULL;
07654 if (py_V81 == Py_None) {
07655 // We can either fail here or set V81 to NULL and rely on Ops
07656 // using tensors to handle the NULL case, but if they fail to do so
07657 // they'll end up with nasty segfaults, so this is public service.
07658 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
07659 {
07660 __failure = 82;
07661 if (!PyErr_Occurred()) {
07662 PyErr_SetString(PyExc_RuntimeError,
07663 "Unexpected error in an Op's C code. "
07664 "No Python exception was set.");
07665 }
07666 goto __label_82;}
07667 }
07668 if (!PyArray_Check(py_V81)) {
07669 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
07670 {
07671 __failure = 82;
07672 if (!PyErr_Occurred()) {
07673 PyErr_SetString(PyExc_RuntimeError,
07674 "Unexpected error in an Op's C code. "
07675 "No Python exception was set.");
07676 }
07677 goto __label_82;}
07678 }
07679 // We expect NPY_FLOAT64
07680 if (!PyArray_ISALIGNED((PyArrayObject*) py_V81)) {
07681 PyArrayObject * tmp = (PyArrayObject*) py_V81;
07682 PyErr_Format(PyExc_NotImplementedError,
07683 "expected an aligned array of type %ld "
07684 "(NPY_FLOAT64), got non-aligned array of type %ld"
07685 " with %ld dimensions, with 3 last dims "
07686 "%ld, %ld, %ld"
07687 " and 3 last strides %ld %ld, %ld.",
07688 (long int) NPY_FLOAT64,
07689 (long int) PyArray_TYPE((PyArrayObject*) py_V81),
07690 (long int) PyArray_NDIM(tmp),
07691 (long int) (PyArray_NDIM(tmp) >= 3 ?
07692 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
07693 (long int) (PyArray_NDIM(tmp) >= 2 ?
07694 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
07695 (long int) (PyArray_NDIM(tmp) >= 1 ?
07696 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
07697 (long int) (PyArray_NDIM(tmp) >= 3 ?
07698 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
07699 (long int) (PyArray_NDIM(tmp) >= 2 ?
07700 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
07701 (long int) (PyArray_NDIM(tmp) >= 1 ?
07702 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
07703 );
07704 {
07705 __failure = 82;
07706 if (!PyErr_Occurred()) {
07707 PyErr_SetString(PyExc_RuntimeError,
07708 "Unexpected error in an Op's C code. "
07709 "No Python exception was set.");
07710 }
07711 goto __label_82;}
07712 }
07713 // This is a TypeError to be consistent with DEBUG_MODE
07714 // Note: DEBUG_MODE also tells the name of the container
07715 if (PyArray_TYPE((PyArrayObject*) py_V81) != NPY_FLOAT64) {
07716 PyErr_Format(PyExc_TypeError,
07717 "expected type_num %d (NPY_FLOAT64) got %d",
07718 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V81));
07719 {
07720 __failure = 82;
07721 if (!PyErr_Occurred()) {
07722 PyErr_SetString(PyExc_RuntimeError,
07723 "Unexpected error in an Op's C code. "
07724 "No Python exception was set.");
07725 }
07726 goto __label_82;}
07727 }
07728
07729 V81 = (PyArrayObject*)(py_V81);
07730 Py_XINCREF(V81);
07731
07732 {
07733
07734 py_V83 = PyList_GET_ITEM(storage_V83, 0);
07735 {Py_XINCREF(py_V83);}
07736
07737 V83 = NULL;
07738 if (py_V83 == Py_None) {
07739 // We can either fail here or set V83 to NULL and rely on Ops
07740 // using tensors to handle the NULL case, but if they fail to do so
07741 // they'll end up with nasty segfaults, so this is public service.
07742 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
07743 {
07744 __failure = 84;
07745 if (!PyErr_Occurred()) {
07746 PyErr_SetString(PyExc_RuntimeError,
07747 "Unexpected error in an Op's C code. "
07748 "No Python exception was set.");
07749 }
07750 goto __label_84;}
07751 }
07752 if (!PyArray_Check(py_V83)) {
07753 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
07754 {
07755 __failure = 84;
07756 if (!PyErr_Occurred()) {
07757 PyErr_SetString(PyExc_RuntimeError,
07758 "Unexpected error in an Op's C code. "
07759 "No Python exception was set.");
07760 }
07761 goto __label_84;}
07762 }
07763 // We expect NPY_FLOAT64
07764 if (!PyArray_ISALIGNED((PyArrayObject*) py_V83)) {
07765 PyArrayObject * tmp = (PyArrayObject*) py_V83;
07766 PyErr_Format(PyExc_NotImplementedError,
07767 "expected an aligned array of type %ld "
07768 "(NPY_FLOAT64), got non-aligned array of type %ld"
07769 " with %ld dimensions, with 3 last dims "
07770 "%ld, %ld, %ld"
07771 " and 3 last strides %ld %ld, %ld.",
07772 (long int) NPY_FLOAT64,
07773 (long int) PyArray_TYPE((PyArrayObject*) py_V83),
07774 (long int) PyArray_NDIM(tmp),
07775 (long int) (PyArray_NDIM(tmp) >= 3 ?
07776 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
07777 (long int) (PyArray_NDIM(tmp) >= 2 ?
07778 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
07779 (long int) (PyArray_NDIM(tmp) >= 1 ?
07780 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
07781 (long int) (PyArray_NDIM(tmp) >= 3 ?
07782 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
07783 (long int) (PyArray_NDIM(tmp) >= 2 ?
07784 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
07785 (long int) (PyArray_NDIM(tmp) >= 1 ?
07786 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
07787 );
07788 {
07789 __failure = 84;
07790 if (!PyErr_Occurred()) {
07791 PyErr_SetString(PyExc_RuntimeError,
07792 "Unexpected error in an Op's C code. "
07793 "No Python exception was set.");
07794 }
07795 goto __label_84;}
07796 }
07797 // This is a TypeError to be consistent with DEBUG_MODE
07798 // Note: DEBUG_MODE also tells the name of the container
07799 if (PyArray_TYPE((PyArrayObject*) py_V83) != NPY_FLOAT64) {
07800 PyErr_Format(PyExc_TypeError,
07801 "expected type_num %d (NPY_FLOAT64) got %d",
07802 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V83));
07803 {
07804 __failure = 84;
07805 if (!PyErr_Occurred()) {
07806 PyErr_SetString(PyExc_RuntimeError,
07807 "Unexpected error in an Op's C code. "
07808 "No Python exception was set.");
07809 }
07810 goto __label_84;}
07811 }
07812
07813 V83 = (PyArrayObject*)(py_V83);
07814 Py_XINCREF(V83);
07815
07816 {
07817
07818 py_V85 = PyList_GET_ITEM(storage_V85, 0);
07819 {Py_XINCREF(py_V85);}
07820
07821 V85 = NULL;
07822 if (py_V85 == Py_None) {
07823 // We can either fail here or set V85 to NULL and rely on Ops
07824 // using tensors to handle the NULL case, but if they fail to do so
07825 // they'll end up with nasty segfaults, so this is public service.
07826 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
07827 {
07828 __failure = 86;
07829 if (!PyErr_Occurred()) {
07830 PyErr_SetString(PyExc_RuntimeError,
07831 "Unexpected error in an Op's C code. "
07832 "No Python exception was set.");
07833 }
07834 goto __label_86;}
07835 }
07836 if (!PyArray_Check(py_V85)) {
07837 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
07838 {
07839 __failure = 86;
07840 if (!PyErr_Occurred()) {
07841 PyErr_SetString(PyExc_RuntimeError,
07842 "Unexpected error in an Op's C code. "
07843 "No Python exception was set.");
07844 }
07845 goto __label_86;}
07846 }
07847 // We expect NPY_FLOAT64
07848 if (!PyArray_ISALIGNED((PyArrayObject*) py_V85)) {
07849 PyArrayObject * tmp = (PyArrayObject*) py_V85;
07850 PyErr_Format(PyExc_NotImplementedError,
07851 "expected an aligned array of type %ld "
07852 "(NPY_FLOAT64), got non-aligned array of type %ld"
07853 " with %ld dimensions, with 3 last dims "
07854 "%ld, %ld, %ld"
07855 " and 3 last strides %ld %ld, %ld.",
07856 (long int) NPY_FLOAT64,
07857 (long int) PyArray_TYPE((PyArrayObject*) py_V85),
07858 (long int) PyArray_NDIM(tmp),
07859 (long int) (PyArray_NDIM(tmp) >= 3 ?
07860 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
07861 (long int) (PyArray_NDIM(tmp) >= 2 ?
07862 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
07863 (long int) (PyArray_NDIM(tmp) >= 1 ?
07864 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
07865 (long int) (PyArray_NDIM(tmp) >= 3 ?
07866 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
07867 (long int) (PyArray_NDIM(tmp) >= 2 ?
07868 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
07869 (long int) (PyArray_NDIM(tmp) >= 1 ?
07870 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
07871 );
07872 {
07873 __failure = 86;
07874 if (!PyErr_Occurred()) {
07875 PyErr_SetString(PyExc_RuntimeError,
07876 "Unexpected error in an Op's C code. "
07877 "No Python exception was set.");
07878 }
07879 goto __label_86;}
07880 }
07881 // This is a TypeError to be consistent with DEBUG_MODE
07882 // Note: DEBUG_MODE also tells the name of the container
07883 if (PyArray_TYPE((PyArrayObject*) py_V85) != NPY_FLOAT64) {
07884 PyErr_Format(PyExc_TypeError,
07885 "expected type_num %d (NPY_FLOAT64) got %d",
07886 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V85));
07887 {
07888 __failure = 86;
07889 if (!PyErr_Occurred()) {
07890 PyErr_SetString(PyExc_RuntimeError,
07891 "Unexpected error in an Op's C code. "
07892 "No Python exception was set.");
07893 }
07894 goto __label_86;}
07895 }
07896
07897 V85 = (PyArrayObject*)(py_V85);
07898 Py_XINCREF(V85);
07899
07900 {
07901
07902 py_V87 = PyList_GET_ITEM(storage_V87, 0);
07903 {Py_XINCREF(py_V87);}
07904
07905 V87 = NULL;
07906 if (py_V87 == Py_None) {
07907 // We can either fail here or set V87 to NULL and rely on Ops
07908 // using tensors to handle the NULL case, but if they fail to do so
07909 // they'll end up with nasty segfaults, so this is public service.
07910 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
07911 {
07912 __failure = 88;
07913 if (!PyErr_Occurred()) {
07914 PyErr_SetString(PyExc_RuntimeError,
07915 "Unexpected error in an Op's C code. "
07916 "No Python exception was set.");
07917 }
07918 goto __label_88;}
07919 }
07920 if (!PyArray_Check(py_V87)) {
07921 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
07922 {
07923 __failure = 88;
07924 if (!PyErr_Occurred()) {
07925 PyErr_SetString(PyExc_RuntimeError,
07926 "Unexpected error in an Op's C code. "
07927 "No Python exception was set.");
07928 }
07929 goto __label_88;}
07930 }
07931 // We expect NPY_FLOAT64
07932 if (!PyArray_ISALIGNED((PyArrayObject*) py_V87)) {
07933 PyArrayObject * tmp = (PyArrayObject*) py_V87;
07934 PyErr_Format(PyExc_NotImplementedError,
07935 "expected an aligned array of type %ld "
07936 "(NPY_FLOAT64), got non-aligned array of type %ld"
07937 " with %ld dimensions, with 3 last dims "
07938 "%ld, %ld, %ld"
07939 " and 3 last strides %ld %ld, %ld.",
07940 (long int) NPY_FLOAT64,
07941 (long int) PyArray_TYPE((PyArrayObject*) py_V87),
07942 (long int) PyArray_NDIM(tmp),
07943 (long int) (PyArray_NDIM(tmp) >= 3 ?
07944 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
07945 (long int) (PyArray_NDIM(tmp) >= 2 ?
07946 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
07947 (long int) (PyArray_NDIM(tmp) >= 1 ?
07948 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
07949 (long int) (PyArray_NDIM(tmp) >= 3 ?
07950 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
07951 (long int) (PyArray_NDIM(tmp) >= 2 ?
07952 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
07953 (long int) (PyArray_NDIM(tmp) >= 1 ?
07954 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
07955 );
07956 {
07957 __failure = 88;
07958 if (!PyErr_Occurred()) {
07959 PyErr_SetString(PyExc_RuntimeError,
07960 "Unexpected error in an Op's C code. "
07961 "No Python exception was set.");
07962 }
07963 goto __label_88;}
07964 }
07965 // This is a TypeError to be consistent with DEBUG_MODE
07966 // Note: DEBUG_MODE also tells the name of the container
07967 if (PyArray_TYPE((PyArrayObject*) py_V87) != NPY_FLOAT64) {
07968 PyErr_Format(PyExc_TypeError,
07969 "expected type_num %d (NPY_FLOAT64) got %d",
07970 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V87));
07971 {
07972 __failure = 88;
07973 if (!PyErr_Occurred()) {
07974 PyErr_SetString(PyExc_RuntimeError,
07975 "Unexpected error in an Op's C code. "
07976 "No Python exception was set.");
07977 }
07978 goto __label_88;}
07979 }
07980
07981 V87 = (PyArrayObject*)(py_V87);
07982 Py_XINCREF(V87);
07983
07984 {
07985
07986 py_V89 = PyList_GET_ITEM(storage_V89, 0);
07987 {Py_XINCREF(py_V89);}
07988
07989 V89 = NULL;
07990 if (py_V89 == Py_None) {
07991 // We can either fail here or set V89 to NULL and rely on Ops
07992 // using tensors to handle the NULL case, but if they fail to do so
07993 // they'll end up with nasty segfaults, so this is public service.
07994 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
07995 {
07996 __failure = 90;
07997 if (!PyErr_Occurred()) {
07998 PyErr_SetString(PyExc_RuntimeError,
07999 "Unexpected error in an Op's C code. "
08000 "No Python exception was set.");
08001 }
08002 goto __label_90;}
08003 }
08004 if (!PyArray_Check(py_V89)) {
08005 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
08006 {
08007 __failure = 90;
08008 if (!PyErr_Occurred()) {
08009 PyErr_SetString(PyExc_RuntimeError,
08010 "Unexpected error in an Op's C code. "
08011 "No Python exception was set.");
08012 }
08013 goto __label_90;}
08014 }
08015 // We expect NPY_FLOAT64
08016 if (!PyArray_ISALIGNED((PyArrayObject*) py_V89)) {
08017 PyArrayObject * tmp = (PyArrayObject*) py_V89;
08018 PyErr_Format(PyExc_NotImplementedError,
08019 "expected an aligned array of type %ld "
08020 "(NPY_FLOAT64), got non-aligned array of type %ld"
08021 " with %ld dimensions, with 3 last dims "
08022 "%ld, %ld, %ld"
08023 " and 3 last strides %ld %ld, %ld.",
08024 (long int) NPY_FLOAT64,
08025 (long int) PyArray_TYPE((PyArrayObject*) py_V89),
08026 (long int) PyArray_NDIM(tmp),
08027 (long int) (PyArray_NDIM(tmp) >= 3 ?
08028 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
08029 (long int) (PyArray_NDIM(tmp) >= 2 ?
08030 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
08031 (long int) (PyArray_NDIM(tmp) >= 1 ?
08032 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
08033 (long int) (PyArray_NDIM(tmp) >= 3 ?
08034 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
08035 (long int) (PyArray_NDIM(tmp) >= 2 ?
08036 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
08037 (long int) (PyArray_NDIM(tmp) >= 1 ?
08038 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
08039 );
08040 {
08041 __failure = 90;
08042 if (!PyErr_Occurred()) {
08043 PyErr_SetString(PyExc_RuntimeError,
08044 "Unexpected error in an Op's C code. "
08045 "No Python exception was set.");
08046 }
08047 goto __label_90;}
08048 }
08049 // This is a TypeError to be consistent with DEBUG_MODE
08050 // Note: DEBUG_MODE also tells the name of the container
08051 if (PyArray_TYPE((PyArrayObject*) py_V89) != NPY_FLOAT64) {
08052 PyErr_Format(PyExc_TypeError,
08053 "expected type_num %d (NPY_FLOAT64) got %d",
08054 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V89));
08055 {
08056 __failure = 90;
08057 if (!PyErr_Occurred()) {
08058 PyErr_SetString(PyExc_RuntimeError,
08059 "Unexpected error in an Op's C code. "
08060 "No Python exception was set.");
08061 }
08062 goto __label_90;}
08063 }
08064
08065 V89 = (PyArrayObject*)(py_V89);
08066 Py_XINCREF(V89);
08067
08068 {
08069
08070 py_V91 = PyList_GET_ITEM(storage_V91, 0);
08071 {Py_XINCREF(py_V91);}
08072
08073 V91 = NULL;
08074 if (py_V91 == Py_None) {
08075 // We can either fail here or set V91 to NULL and rely on Ops
08076 // using tensors to handle the NULL case, but if they fail to do so
08077 // they'll end up with nasty segfaults, so this is public service.
08078 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
08079 {
08080 __failure = 92;
08081 if (!PyErr_Occurred()) {
08082 PyErr_SetString(PyExc_RuntimeError,
08083 "Unexpected error in an Op's C code. "
08084 "No Python exception was set.");
08085 }
08086 goto __label_92;}
08087 }
08088 if (!PyArray_Check(py_V91)) {
08089 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
08090 {
08091 __failure = 92;
08092 if (!PyErr_Occurred()) {
08093 PyErr_SetString(PyExc_RuntimeError,
08094 "Unexpected error in an Op's C code. "
08095 "No Python exception was set.");
08096 }
08097 goto __label_92;}
08098 }
08099 // We expect NPY_FLOAT64
08100 if (!PyArray_ISALIGNED((PyArrayObject*) py_V91)) {
08101 PyArrayObject * tmp = (PyArrayObject*) py_V91;
08102 PyErr_Format(PyExc_NotImplementedError,
08103 "expected an aligned array of type %ld "
08104 "(NPY_FLOAT64), got non-aligned array of type %ld"
08105 " with %ld dimensions, with 3 last dims "
08106 "%ld, %ld, %ld"
08107 " and 3 last strides %ld %ld, %ld.",
08108 (long int) NPY_FLOAT64,
08109 (long int) PyArray_TYPE((PyArrayObject*) py_V91),
08110 (long int) PyArray_NDIM(tmp),
08111 (long int) (PyArray_NDIM(tmp) >= 3 ?
08112 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
08113 (long int) (PyArray_NDIM(tmp) >= 2 ?
08114 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
08115 (long int) (PyArray_NDIM(tmp) >= 1 ?
08116 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
08117 (long int) (PyArray_NDIM(tmp) >= 3 ?
08118 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
08119 (long int) (PyArray_NDIM(tmp) >= 2 ?
08120 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
08121 (long int) (PyArray_NDIM(tmp) >= 1 ?
08122 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
08123 );
08124 {
08125 __failure = 92;
08126 if (!PyErr_Occurred()) {
08127 PyErr_SetString(PyExc_RuntimeError,
08128 "Unexpected error in an Op's C code. "
08129 "No Python exception was set.");
08130 }
08131 goto __label_92;}
08132 }
08133 // This is a TypeError to be consistent with DEBUG_MODE
08134 // Note: DEBUG_MODE also tells the name of the container
08135 if (PyArray_TYPE((PyArrayObject*) py_V91) != NPY_FLOAT64) {
08136 PyErr_Format(PyExc_TypeError,
08137 "expected type_num %d (NPY_FLOAT64) got %d",
08138 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V91));
08139 {
08140 __failure = 92;
08141 if (!PyErr_Occurred()) {
08142 PyErr_SetString(PyExc_RuntimeError,
08143 "Unexpected error in an Op's C code. "
08144 "No Python exception was set.");
08145 }
08146 goto __label_92;}
08147 }
08148
08149 V91 = (PyArrayObject*)(py_V91);
08150 Py_XINCREF(V91);
08151
08152 {
08153
08154 py_V93 = PyList_GET_ITEM(storage_V93, 0);
08155 {Py_XINCREF(py_V93);}
08156
08157 V93 = NULL;
08158 if (py_V93 == Py_None) {
08159 // We can either fail here or set V93 to NULL and rely on Ops
08160 // using tensors to handle the NULL case, but if they fail to do so
08161 // they'll end up with nasty segfaults, so this is public service.
08162 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
08163 {
08164 __failure = 94;
08165 if (!PyErr_Occurred()) {
08166 PyErr_SetString(PyExc_RuntimeError,
08167 "Unexpected error in an Op's C code. "
08168 "No Python exception was set.");
08169 }
08170 goto __label_94;}
08171 }
08172 if (!PyArray_Check(py_V93)) {
08173 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
08174 {
08175 __failure = 94;
08176 if (!PyErr_Occurred()) {
08177 PyErr_SetString(PyExc_RuntimeError,
08178 "Unexpected error in an Op's C code. "
08179 "No Python exception was set.");
08180 }
08181 goto __label_94;}
08182 }
08183 // We expect NPY_FLOAT64
08184 if (!PyArray_ISALIGNED((PyArrayObject*) py_V93)) {
08185 PyArrayObject * tmp = (PyArrayObject*) py_V93;
08186 PyErr_Format(PyExc_NotImplementedError,
08187 "expected an aligned array of type %ld "
08188 "(NPY_FLOAT64), got non-aligned array of type %ld"
08189 " with %ld dimensions, with 3 last dims "
08190 "%ld, %ld, %ld"
08191 " and 3 last strides %ld %ld, %ld.",
08192 (long int) NPY_FLOAT64,
08193 (long int) PyArray_TYPE((PyArrayObject*) py_V93),
08194 (long int) PyArray_NDIM(tmp),
08195 (long int) (PyArray_NDIM(tmp) >= 3 ?
08196 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
08197 (long int) (PyArray_NDIM(tmp) >= 2 ?
08198 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
08199 (long int) (PyArray_NDIM(tmp) >= 1 ?
08200 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
08201 (long int) (PyArray_NDIM(tmp) >= 3 ?
08202 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
08203 (long int) (PyArray_NDIM(tmp) >= 2 ?
08204 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
08205 (long int) (PyArray_NDIM(tmp) >= 1 ?
08206 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
08207 );
08208 {
08209 __failure = 94;
08210 if (!PyErr_Occurred()) {
08211 PyErr_SetString(PyExc_RuntimeError,
08212 "Unexpected error in an Op's C code. "
08213 "No Python exception was set.");
08214 }
08215 goto __label_94;}
08216 }
08217 // This is a TypeError to be consistent with DEBUG_MODE
08218 // Note: DEBUG_MODE also tells the name of the container
08219 if (PyArray_TYPE((PyArrayObject*) py_V93) != NPY_FLOAT64) {
08220 PyErr_Format(PyExc_TypeError,
08221 "expected type_num %d (NPY_FLOAT64) got %d",
08222 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V93));
08223 {
08224 __failure = 94;
08225 if (!PyErr_Occurred()) {
08226 PyErr_SetString(PyExc_RuntimeError,
08227 "Unexpected error in an Op's C code. "
08228 "No Python exception was set.");
08229 }
08230 goto __label_94;}
08231 }
08232
08233 V93 = (PyArrayObject*)(py_V93);
08234 Py_XINCREF(V93);
08235
08236 {
08237
08238 py_V95 = PyList_GET_ITEM(storage_V95, 0);
08239 {Py_XINCREF(py_V95);}
08240
08241 V95 = NULL;
08242 if (py_V95 == Py_None) {
08243 // We can either fail here or set V95 to NULL and rely on Ops
08244 // using tensors to handle the NULL case, but if they fail to do so
08245 // they'll end up with nasty segfaults, so this is public service.
08246 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
08247 {
08248 __failure = 96;
08249 if (!PyErr_Occurred()) {
08250 PyErr_SetString(PyExc_RuntimeError,
08251 "Unexpected error in an Op's C code. "
08252 "No Python exception was set.");
08253 }
08254 goto __label_96;}
08255 }
08256 if (!PyArray_Check(py_V95)) {
08257 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
08258 {
08259 __failure = 96;
08260 if (!PyErr_Occurred()) {
08261 PyErr_SetString(PyExc_RuntimeError,
08262 "Unexpected error in an Op's C code. "
08263 "No Python exception was set.");
08264 }
08265 goto __label_96;}
08266 }
08267 // We expect NPY_FLOAT64
08268 if (!PyArray_ISALIGNED((PyArrayObject*) py_V95)) {
08269 PyArrayObject * tmp = (PyArrayObject*) py_V95;
08270 PyErr_Format(PyExc_NotImplementedError,
08271 "expected an aligned array of type %ld "
08272 "(NPY_FLOAT64), got non-aligned array of type %ld"
08273 " with %ld dimensions, with 3 last dims "
08274 "%ld, %ld, %ld"
08275 " and 3 last strides %ld %ld, %ld.",
08276 (long int) NPY_FLOAT64,
08277 (long int) PyArray_TYPE((PyArrayObject*) py_V95),
08278 (long int) PyArray_NDIM(tmp),
08279 (long int) (PyArray_NDIM(tmp) >= 3 ?
08280 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
08281 (long int) (PyArray_NDIM(tmp) >= 2 ?
08282 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
08283 (long int) (PyArray_NDIM(tmp) >= 1 ?
08284 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
08285 (long int) (PyArray_NDIM(tmp) >= 3 ?
08286 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
08287 (long int) (PyArray_NDIM(tmp) >= 2 ?
08288 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
08289 (long int) (PyArray_NDIM(tmp) >= 1 ?
08290 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
08291 );
08292 {
08293 __failure = 96;
08294 if (!PyErr_Occurred()) {
08295 PyErr_SetString(PyExc_RuntimeError,
08296 "Unexpected error in an Op's C code. "
08297 "No Python exception was set.");
08298 }
08299 goto __label_96;}
08300 }
08301 // This is a TypeError to be consistent with DEBUG_MODE
08302 // Note: DEBUG_MODE also tells the name of the container
08303 if (PyArray_TYPE((PyArrayObject*) py_V95) != NPY_FLOAT64) {
08304 PyErr_Format(PyExc_TypeError,
08305 "expected type_num %d (NPY_FLOAT64) got %d",
08306 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V95));
08307 {
08308 __failure = 96;
08309 if (!PyErr_Occurred()) {
08310 PyErr_SetString(PyExc_RuntimeError,
08311 "Unexpected error in an Op's C code. "
08312 "No Python exception was set.");
08313 }
08314 goto __label_96;}
08315 }
08316
08317 V95 = (PyArrayObject*)(py_V95);
08318 Py_XINCREF(V95);
08319
08320 {
08321
08322 py_V97 = PyList_GET_ITEM(storage_V97, 0);
08323 {Py_XINCREF(py_V97);}
08324
08325 V97 = NULL;
08326 if (py_V97 == Py_None) {
08327 // We can either fail here or set V97 to NULL and rely on Ops
08328 // using tensors to handle the NULL case, but if they fail to do so
08329 // they'll end up with nasty segfaults, so this is public service.
08330 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
08331 {
08332 __failure = 98;
08333 if (!PyErr_Occurred()) {
08334 PyErr_SetString(PyExc_RuntimeError,
08335 "Unexpected error in an Op's C code. "
08336 "No Python exception was set.");
08337 }
08338 goto __label_98;}
08339 }
08340 if (!PyArray_Check(py_V97)) {
08341 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
08342 {
08343 __failure = 98;
08344 if (!PyErr_Occurred()) {
08345 PyErr_SetString(PyExc_RuntimeError,
08346 "Unexpected error in an Op's C code. "
08347 "No Python exception was set.");
08348 }
08349 goto __label_98;}
08350 }
08351 // We expect NPY_FLOAT64
08352 if (!PyArray_ISALIGNED((PyArrayObject*) py_V97)) {
08353 PyArrayObject * tmp = (PyArrayObject*) py_V97;
08354 PyErr_Format(PyExc_NotImplementedError,
08355 "expected an aligned array of type %ld "
08356 "(NPY_FLOAT64), got non-aligned array of type %ld"
08357 " with %ld dimensions, with 3 last dims "
08358 "%ld, %ld, %ld"
08359 " and 3 last strides %ld %ld, %ld.",
08360 (long int) NPY_FLOAT64,
08361 (long int) PyArray_TYPE((PyArrayObject*) py_V97),
08362 (long int) PyArray_NDIM(tmp),
08363 (long int) (PyArray_NDIM(tmp) >= 3 ?
08364 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
08365 (long int) (PyArray_NDIM(tmp) >= 2 ?
08366 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
08367 (long int) (PyArray_NDIM(tmp) >= 1 ?
08368 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
08369 (long int) (PyArray_NDIM(tmp) >= 3 ?
08370 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
08371 (long int) (PyArray_NDIM(tmp) >= 2 ?
08372 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
08373 (long int) (PyArray_NDIM(tmp) >= 1 ?
08374 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
08375 );
08376 {
08377 __failure = 98;
08378 if (!PyErr_Occurred()) {
08379 PyErr_SetString(PyExc_RuntimeError,
08380 "Unexpected error in an Op's C code. "
08381 "No Python exception was set.");
08382 }
08383 goto __label_98;}
08384 }
08385 // This is a TypeError to be consistent with DEBUG_MODE
08386 // Note: DEBUG_MODE also tells the name of the container
08387 if (PyArray_TYPE((PyArrayObject*) py_V97) != NPY_FLOAT64) {
08388 PyErr_Format(PyExc_TypeError,
08389 "expected type_num %d (NPY_FLOAT64) got %d",
08390 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V97));
08391 {
08392 __failure = 98;
08393 if (!PyErr_Occurred()) {
08394 PyErr_SetString(PyExc_RuntimeError,
08395 "Unexpected error in an Op's C code. "
08396 "No Python exception was set.");
08397 }
08398 goto __label_98;}
08399 }
08400
08401 V97 = (PyArrayObject*)(py_V97);
08402 Py_XINCREF(V97);
08403
08404 {
08405
08406 py_V99 = PyList_GET_ITEM(storage_V99, 0);
08407 {Py_XINCREF(py_V99);}
08408
08409 V99 = NULL;
08410 if (py_V99 == Py_None) {
08411 // We can either fail here or set V99 to NULL and rely on Ops
08412 // using tensors to handle the NULL case, but if they fail to do so
08413 // they'll end up with nasty segfaults, so this is public service.
08414 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
08415 {
08416 __failure = 100;
08417 if (!PyErr_Occurred()) {
08418 PyErr_SetString(PyExc_RuntimeError,
08419 "Unexpected error in an Op's C code. "
08420 "No Python exception was set.");
08421 }
08422 goto __label_100;}
08423 }
08424 if (!PyArray_Check(py_V99)) {
08425 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
08426 {
08427 __failure = 100;
08428 if (!PyErr_Occurred()) {
08429 PyErr_SetString(PyExc_RuntimeError,
08430 "Unexpected error in an Op's C code. "
08431 "No Python exception was set.");
08432 }
08433 goto __label_100;}
08434 }
08435 // We expect NPY_FLOAT64
08436 if (!PyArray_ISALIGNED((PyArrayObject*) py_V99)) {
08437 PyArrayObject * tmp = (PyArrayObject*) py_V99;
08438 PyErr_Format(PyExc_NotImplementedError,
08439 "expected an aligned array of type %ld "
08440 "(NPY_FLOAT64), got non-aligned array of type %ld"
08441 " with %ld dimensions, with 3 last dims "
08442 "%ld, %ld, %ld"
08443 " and 3 last strides %ld %ld, %ld.",
08444 (long int) NPY_FLOAT64,
08445 (long int) PyArray_TYPE((PyArrayObject*) py_V99),
08446 (long int) PyArray_NDIM(tmp),
08447 (long int) (PyArray_NDIM(tmp) >= 3 ?
08448 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
08449 (long int) (PyArray_NDIM(tmp) >= 2 ?
08450 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
08451 (long int) (PyArray_NDIM(tmp) >= 1 ?
08452 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
08453 (long int) (PyArray_NDIM(tmp) >= 3 ?
08454 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
08455 (long int) (PyArray_NDIM(tmp) >= 2 ?
08456 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
08457 (long int) (PyArray_NDIM(tmp) >= 1 ?
08458 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
08459 );
08460 {
08461 __failure = 100;
08462 if (!PyErr_Occurred()) {
08463 PyErr_SetString(PyExc_RuntimeError,
08464 "Unexpected error in an Op's C code. "
08465 "No Python exception was set.");
08466 }
08467 goto __label_100;}
08468 }
08469 // This is a TypeError to be consistent with DEBUG_MODE
08470 // Note: DEBUG_MODE also tells the name of the container
08471 if (PyArray_TYPE((PyArrayObject*) py_V99) != NPY_FLOAT64) {
08472 PyErr_Format(PyExc_TypeError,
08473 "expected type_num %d (NPY_FLOAT64) got %d",
08474 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V99));
08475 {
08476 __failure = 100;
08477 if (!PyErr_Occurred()) {
08478 PyErr_SetString(PyExc_RuntimeError,
08479 "Unexpected error in an Op's C code. "
08480 "No Python exception was set.");
08481 }
08482 goto __label_100;}
08483 }
08484
08485 V99 = (PyArrayObject*)(py_V99);
08486 Py_XINCREF(V99);
08487
08488 {
08489
08490 py_V101 = PyList_GET_ITEM(storage_V101, 0);
08491 {Py_XINCREF(py_V101);}
08492
08493 V101 = NULL;
08494 if (py_V101 == Py_None) {
08495 // We can either fail here or set V101 to NULL and rely on Ops
08496 // using tensors to handle the NULL case, but if they fail to do so
08497 // they'll end up with nasty segfaults, so this is public service.
08498 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
08499 {
08500 __failure = 102;
08501 if (!PyErr_Occurred()) {
08502 PyErr_SetString(PyExc_RuntimeError,
08503 "Unexpected error in an Op's C code. "
08504 "No Python exception was set.");
08505 }
08506 goto __label_102;}
08507 }
08508 if (!PyArray_Check(py_V101)) {
08509 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
08510 {
08511 __failure = 102;
08512 if (!PyErr_Occurred()) {
08513 PyErr_SetString(PyExc_RuntimeError,
08514 "Unexpected error in an Op's C code. "
08515 "No Python exception was set.");
08516 }
08517 goto __label_102;}
08518 }
08519 // We expect NPY_FLOAT64
08520 if (!PyArray_ISALIGNED((PyArrayObject*) py_V101)) {
08521 PyArrayObject * tmp = (PyArrayObject*) py_V101;
08522 PyErr_Format(PyExc_NotImplementedError,
08523 "expected an aligned array of type %ld "
08524 "(NPY_FLOAT64), got non-aligned array of type %ld"
08525 " with %ld dimensions, with 3 last dims "
08526 "%ld, %ld, %ld"
08527 " and 3 last strides %ld %ld, %ld.",
08528 (long int) NPY_FLOAT64,
08529 (long int) PyArray_TYPE((PyArrayObject*) py_V101),
08530 (long int) PyArray_NDIM(tmp),
08531 (long int) (PyArray_NDIM(tmp) >= 3 ?
08532 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
08533 (long int) (PyArray_NDIM(tmp) >= 2 ?
08534 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
08535 (long int) (PyArray_NDIM(tmp) >= 1 ?
08536 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
08537 (long int) (PyArray_NDIM(tmp) >= 3 ?
08538 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
08539 (long int) (PyArray_NDIM(tmp) >= 2 ?
08540 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
08541 (long int) (PyArray_NDIM(tmp) >= 1 ?
08542 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
08543 );
08544 {
08545 __failure = 102;
08546 if (!PyErr_Occurred()) {
08547 PyErr_SetString(PyExc_RuntimeError,
08548 "Unexpected error in an Op's C code. "
08549 "No Python exception was set.");
08550 }
08551 goto __label_102;}
08552 }
08553 // This is a TypeError to be consistent with DEBUG_MODE
08554 // Note: DEBUG_MODE also tells the name of the container
08555 if (PyArray_TYPE((PyArrayObject*) py_V101) != NPY_FLOAT64) {
08556 PyErr_Format(PyExc_TypeError,
08557 "expected type_num %d (NPY_FLOAT64) got %d",
08558 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V101));
08559 {
08560 __failure = 102;
08561 if (!PyErr_Occurred()) {
08562 PyErr_SetString(PyExc_RuntimeError,
08563 "Unexpected error in an Op's C code. "
08564 "No Python exception was set.");
08565 }
08566 goto __label_102;}
08567 }
08568
08569 V101 = (PyArrayObject*)(py_V101);
08570 Py_XINCREF(V101);
08571
08572 {
08573
08574 py_V103 = PyList_GET_ITEM(storage_V103, 0);
08575 {Py_XINCREF(py_V103);}
08576
08577 V103 = NULL;
08578 if (py_V103 == Py_None) {
08579 // We can either fail here or set V103 to NULL and rely on Ops
08580 // using tensors to handle the NULL case, but if they fail to do so
08581 // they'll end up with nasty segfaults, so this is public service.
08582 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
08583 {
08584 __failure = 104;
08585 if (!PyErr_Occurred()) {
08586 PyErr_SetString(PyExc_RuntimeError,
08587 "Unexpected error in an Op's C code. "
08588 "No Python exception was set.");
08589 }
08590 goto __label_104;}
08591 }
08592 if (!PyArray_Check(py_V103)) {
08593 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
08594 {
08595 __failure = 104;
08596 if (!PyErr_Occurred()) {
08597 PyErr_SetString(PyExc_RuntimeError,
08598 "Unexpected error in an Op's C code. "
08599 "No Python exception was set.");
08600 }
08601 goto __label_104;}
08602 }
08603 // We expect NPY_FLOAT64
08604 if (!PyArray_ISALIGNED((PyArrayObject*) py_V103)) {
08605 PyArrayObject * tmp = (PyArrayObject*) py_V103;
08606 PyErr_Format(PyExc_NotImplementedError,
08607 "expected an aligned array of type %ld "
08608 "(NPY_FLOAT64), got non-aligned array of type %ld"
08609 " with %ld dimensions, with 3 last dims "
08610 "%ld, %ld, %ld"
08611 " and 3 last strides %ld %ld, %ld.",
08612 (long int) NPY_FLOAT64,
08613 (long int) PyArray_TYPE((PyArrayObject*) py_V103),
08614 (long int) PyArray_NDIM(tmp),
08615 (long int) (PyArray_NDIM(tmp) >= 3 ?
08616 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
08617 (long int) (PyArray_NDIM(tmp) >= 2 ?
08618 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
08619 (long int) (PyArray_NDIM(tmp) >= 1 ?
08620 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
08621 (long int) (PyArray_NDIM(tmp) >= 3 ?
08622 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
08623 (long int) (PyArray_NDIM(tmp) >= 2 ?
08624 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
08625 (long int) (PyArray_NDIM(tmp) >= 1 ?
08626 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
08627 );
08628 {
08629 __failure = 104;
08630 if (!PyErr_Occurred()) {
08631 PyErr_SetString(PyExc_RuntimeError,
08632 "Unexpected error in an Op's C code. "
08633 "No Python exception was set.");
08634 }
08635 goto __label_104;}
08636 }
08637 // This is a TypeError to be consistent with DEBUG_MODE
08638 // Note: DEBUG_MODE also tells the name of the container
08639 if (PyArray_TYPE((PyArrayObject*) py_V103) != NPY_FLOAT64) {
08640 PyErr_Format(PyExc_TypeError,
08641 "expected type_num %d (NPY_FLOAT64) got %d",
08642 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V103));
08643 {
08644 __failure = 104;
08645 if (!PyErr_Occurred()) {
08646 PyErr_SetString(PyExc_RuntimeError,
08647 "Unexpected error in an Op's C code. "
08648 "No Python exception was set.");
08649 }
08650 goto __label_104;}
08651 }
08652
08653 V103 = (PyArrayObject*)(py_V103);
08654 Py_XINCREF(V103);
08655
08656 {
08657
08658 py_V105 = PyList_GET_ITEM(storage_V105, 0);
08659 {Py_XINCREF(py_V105);}
08660
08661 V105 = NULL;
08662 if (py_V105 == Py_None) {
08663 // We can either fail here or set V105 to NULL and rely on Ops
08664 // using tensors to handle the NULL case, but if they fail to do so
08665 // they'll end up with nasty segfaults, so this is public service.
08666 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
08667 {
08668 __failure = 106;
08669 if (!PyErr_Occurred()) {
08670 PyErr_SetString(PyExc_RuntimeError,
08671 "Unexpected error in an Op's C code. "
08672 "No Python exception was set.");
08673 }
08674 goto __label_106;}
08675 }
08676 if (!PyArray_Check(py_V105)) {
08677 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
08678 {
08679 __failure = 106;
08680 if (!PyErr_Occurred()) {
08681 PyErr_SetString(PyExc_RuntimeError,
08682 "Unexpected error in an Op's C code. "
08683 "No Python exception was set.");
08684 }
08685 goto __label_106;}
08686 }
08687 // We expect NPY_FLOAT64
08688 if (!PyArray_ISALIGNED((PyArrayObject*) py_V105)) {
08689 PyArrayObject * tmp = (PyArrayObject*) py_V105;
08690 PyErr_Format(PyExc_NotImplementedError,
08691 "expected an aligned array of type %ld "
08692 "(NPY_FLOAT64), got non-aligned array of type %ld"
08693 " with %ld dimensions, with 3 last dims "
08694 "%ld, %ld, %ld"
08695 " and 3 last strides %ld %ld, %ld.",
08696 (long int) NPY_FLOAT64,
08697 (long int) PyArray_TYPE((PyArrayObject*) py_V105),
08698 (long int) PyArray_NDIM(tmp),
08699 (long int) (PyArray_NDIM(tmp) >= 3 ?
08700 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
08701 (long int) (PyArray_NDIM(tmp) >= 2 ?
08702 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
08703 (long int) (PyArray_NDIM(tmp) >= 1 ?
08704 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
08705 (long int) (PyArray_NDIM(tmp) >= 3 ?
08706 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
08707 (long int) (PyArray_NDIM(tmp) >= 2 ?
08708 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
08709 (long int) (PyArray_NDIM(tmp) >= 1 ?
08710 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
08711 );
08712 {
08713 __failure = 106;
08714 if (!PyErr_Occurred()) {
08715 PyErr_SetString(PyExc_RuntimeError,
08716 "Unexpected error in an Op's C code. "
08717 "No Python exception was set.");
08718 }
08719 goto __label_106;}
08720 }
08721 // This is a TypeError to be consistent with DEBUG_MODE
08722 // Note: DEBUG_MODE also tells the name of the container
08723 if (PyArray_TYPE((PyArrayObject*) py_V105) != NPY_FLOAT64) {
08724 PyErr_Format(PyExc_TypeError,
08725 "expected type_num %d (NPY_FLOAT64) got %d",
08726 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V105));
08727 {
08728 __failure = 106;
08729 if (!PyErr_Occurred()) {
08730 PyErr_SetString(PyExc_RuntimeError,
08731 "Unexpected error in an Op's C code. "
08732 "No Python exception was set.");
08733 }
08734 goto __label_106;}
08735 }
08736
08737 V105 = (PyArrayObject*)(py_V105);
08738 Py_XINCREF(V105);
08739
08740 {
08741
08742 py_V107 = PyList_GET_ITEM(storage_V107, 0);
08743 {Py_XINCREF(py_V107);}
08744
08745 V107 = NULL;
08746 if (py_V107 == Py_None) {
08747 // We can either fail here or set V107 to NULL and rely on Ops
08748 // using tensors to handle the NULL case, but if they fail to do so
08749 // they'll end up with nasty segfaults, so this is public service.
08750 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
08751 {
08752 __failure = 108;
08753 if (!PyErr_Occurred()) {
08754 PyErr_SetString(PyExc_RuntimeError,
08755 "Unexpected error in an Op's C code. "
08756 "No Python exception was set.");
08757 }
08758 goto __label_108;}
08759 }
08760 if (!PyArray_Check(py_V107)) {
08761 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
08762 {
08763 __failure = 108;
08764 if (!PyErr_Occurred()) {
08765 PyErr_SetString(PyExc_RuntimeError,
08766 "Unexpected error in an Op's C code. "
08767 "No Python exception was set.");
08768 }
08769 goto __label_108;}
08770 }
08771 // We expect NPY_FLOAT64
08772 if (!PyArray_ISALIGNED((PyArrayObject*) py_V107)) {
08773 PyArrayObject * tmp = (PyArrayObject*) py_V107;
08774 PyErr_Format(PyExc_NotImplementedError,
08775 "expected an aligned array of type %ld "
08776 "(NPY_FLOAT64), got non-aligned array of type %ld"
08777 " with %ld dimensions, with 3 last dims "
08778 "%ld, %ld, %ld"
08779 " and 3 last strides %ld %ld, %ld.",
08780 (long int) NPY_FLOAT64,
08781 (long int) PyArray_TYPE((PyArrayObject*) py_V107),
08782 (long int) PyArray_NDIM(tmp),
08783 (long int) (PyArray_NDIM(tmp) >= 3 ?
08784 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
08785 (long int) (PyArray_NDIM(tmp) >= 2 ?
08786 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
08787 (long int) (PyArray_NDIM(tmp) >= 1 ?
08788 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
08789 (long int) (PyArray_NDIM(tmp) >= 3 ?
08790 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
08791 (long int) (PyArray_NDIM(tmp) >= 2 ?
08792 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
08793 (long int) (PyArray_NDIM(tmp) >= 1 ?
08794 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
08795 );
08796 {
08797 __failure = 108;
08798 if (!PyErr_Occurred()) {
08799 PyErr_SetString(PyExc_RuntimeError,
08800 "Unexpected error in an Op's C code. "
08801 "No Python exception was set.");
08802 }
08803 goto __label_108;}
08804 }
08805 // This is a TypeError to be consistent with DEBUG_MODE
08806 // Note: DEBUG_MODE also tells the name of the container
08807 if (PyArray_TYPE((PyArrayObject*) py_V107) != NPY_FLOAT64) {
08808 PyErr_Format(PyExc_TypeError,
08809 "expected type_num %d (NPY_FLOAT64) got %d",
08810 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V107));
08811 {
08812 __failure = 108;
08813 if (!PyErr_Occurred()) {
08814 PyErr_SetString(PyExc_RuntimeError,
08815 "Unexpected error in an Op's C code. "
08816 "No Python exception was set.");
08817 }
08818 goto __label_108;}
08819 }
08820
08821 V107 = (PyArrayObject*)(py_V107);
08822 Py_XINCREF(V107);
08823
08824 {
08825
08826 py_V109 = PyList_GET_ITEM(storage_V109, 0);
08827 {Py_XINCREF(py_V109);}
08828
08829 V109 = NULL;
08830 if (py_V109 == Py_None) {
08831 // We can either fail here or set V109 to NULL and rely on Ops
08832 // using tensors to handle the NULL case, but if they fail to do so
08833 // they'll end up with nasty segfaults, so this is public service.
08834 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
08835 {
08836 __failure = 110;
08837 if (!PyErr_Occurred()) {
08838 PyErr_SetString(PyExc_RuntimeError,
08839 "Unexpected error in an Op's C code. "
08840 "No Python exception was set.");
08841 }
08842 goto __label_110;}
08843 }
08844 if (!PyArray_Check(py_V109)) {
08845 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
08846 {
08847 __failure = 110;
08848 if (!PyErr_Occurred()) {
08849 PyErr_SetString(PyExc_RuntimeError,
08850 "Unexpected error in an Op's C code. "
08851 "No Python exception was set.");
08852 }
08853 goto __label_110;}
08854 }
08855 // We expect NPY_FLOAT64
08856 if (!PyArray_ISALIGNED((PyArrayObject*) py_V109)) {
08857 PyArrayObject * tmp = (PyArrayObject*) py_V109;
08858 PyErr_Format(PyExc_NotImplementedError,
08859 "expected an aligned array of type %ld "
08860 "(NPY_FLOAT64), got non-aligned array of type %ld"
08861 " with %ld dimensions, with 3 last dims "
08862 "%ld, %ld, %ld"
08863 " and 3 last strides %ld %ld, %ld.",
08864 (long int) NPY_FLOAT64,
08865 (long int) PyArray_TYPE((PyArrayObject*) py_V109),
08866 (long int) PyArray_NDIM(tmp),
08867 (long int) (PyArray_NDIM(tmp) >= 3 ?
08868 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
08869 (long int) (PyArray_NDIM(tmp) >= 2 ?
08870 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
08871 (long int) (PyArray_NDIM(tmp) >= 1 ?
08872 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
08873 (long int) (PyArray_NDIM(tmp) >= 3 ?
08874 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
08875 (long int) (PyArray_NDIM(tmp) >= 2 ?
08876 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
08877 (long int) (PyArray_NDIM(tmp) >= 1 ?
08878 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
08879 );
08880 {
08881 __failure = 110;
08882 if (!PyErr_Occurred()) {
08883 PyErr_SetString(PyExc_RuntimeError,
08884 "Unexpected error in an Op's C code. "
08885 "No Python exception was set.");
08886 }
08887 goto __label_110;}
08888 }
08889 // This is a TypeError to be consistent with DEBUG_MODE
08890 // Note: DEBUG_MODE also tells the name of the container
08891 if (PyArray_TYPE((PyArrayObject*) py_V109) != NPY_FLOAT64) {
08892 PyErr_Format(PyExc_TypeError,
08893 "expected type_num %d (NPY_FLOAT64) got %d",
08894 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V109));
08895 {
08896 __failure = 110;
08897 if (!PyErr_Occurred()) {
08898 PyErr_SetString(PyExc_RuntimeError,
08899 "Unexpected error in an Op's C code. "
08900 "No Python exception was set.");
08901 }
08902 goto __label_110;}
08903 }
08904
08905 V109 = (PyArrayObject*)(py_V109);
08906 Py_XINCREF(V109);
08907
08908 {
08909
08910 py_V111 = PyList_GET_ITEM(storage_V111, 0);
08911 {Py_XINCREF(py_V111);}
08912
08913 V111 = NULL;
08914 if (py_V111 == Py_None) {
08915 // We can either fail here or set V111 to NULL and rely on Ops
08916 // using tensors to handle the NULL case, but if they fail to do so
08917 // they'll end up with nasty segfaults, so this is public service.
08918 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
08919 {
08920 __failure = 112;
08921 if (!PyErr_Occurred()) {
08922 PyErr_SetString(PyExc_RuntimeError,
08923 "Unexpected error in an Op's C code. "
08924 "No Python exception was set.");
08925 }
08926 goto __label_112;}
08927 }
08928 if (!PyArray_Check(py_V111)) {
08929 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
08930 {
08931 __failure = 112;
08932 if (!PyErr_Occurred()) {
08933 PyErr_SetString(PyExc_RuntimeError,
08934 "Unexpected error in an Op's C code. "
08935 "No Python exception was set.");
08936 }
08937 goto __label_112;}
08938 }
08939 // We expect NPY_FLOAT64
08940 if (!PyArray_ISALIGNED((PyArrayObject*) py_V111)) {
08941 PyArrayObject * tmp = (PyArrayObject*) py_V111;
08942 PyErr_Format(PyExc_NotImplementedError,
08943 "expected an aligned array of type %ld "
08944 "(NPY_FLOAT64), got non-aligned array of type %ld"
08945 " with %ld dimensions, with 3 last dims "
08946 "%ld, %ld, %ld"
08947 " and 3 last strides %ld %ld, %ld.",
08948 (long int) NPY_FLOAT64,
08949 (long int) PyArray_TYPE((PyArrayObject*) py_V111),
08950 (long int) PyArray_NDIM(tmp),
08951 (long int) (PyArray_NDIM(tmp) >= 3 ?
08952 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
08953 (long int) (PyArray_NDIM(tmp) >= 2 ?
08954 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
08955 (long int) (PyArray_NDIM(tmp) >= 1 ?
08956 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
08957 (long int) (PyArray_NDIM(tmp) >= 3 ?
08958 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
08959 (long int) (PyArray_NDIM(tmp) >= 2 ?
08960 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
08961 (long int) (PyArray_NDIM(tmp) >= 1 ?
08962 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
08963 );
08964 {
08965 __failure = 112;
08966 if (!PyErr_Occurred()) {
08967 PyErr_SetString(PyExc_RuntimeError,
08968 "Unexpected error in an Op's C code. "
08969 "No Python exception was set.");
08970 }
08971 goto __label_112;}
08972 }
08973 // This is a TypeError to be consistent with DEBUG_MODE
08974 // Note: DEBUG_MODE also tells the name of the container
08975 if (PyArray_TYPE((PyArrayObject*) py_V111) != NPY_FLOAT64) {
08976 PyErr_Format(PyExc_TypeError,
08977 "expected type_num %d (NPY_FLOAT64) got %d",
08978 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V111));
08979 {
08980 __failure = 112;
08981 if (!PyErr_Occurred()) {
08982 PyErr_SetString(PyExc_RuntimeError,
08983 "Unexpected error in an Op's C code. "
08984 "No Python exception was set.");
08985 }
08986 goto __label_112;}
08987 }
08988
08989 V111 = (PyArrayObject*)(py_V111);
08990 Py_XINCREF(V111);
08991
08992 {
08993
08994 py_V113 = PyList_GET_ITEM(storage_V113, 0);
08995 {Py_XINCREF(py_V113);}
08996
08997 V113 = NULL;
08998 if (py_V113 == Py_None) {
08999 // We can either fail here or set V113 to NULL and rely on Ops
09000 // using tensors to handle the NULL case, but if they fail to do so
09001 // they'll end up with nasty segfaults, so this is public service.
09002 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
09003 {
09004 __failure = 114;
09005 if (!PyErr_Occurred()) {
09006 PyErr_SetString(PyExc_RuntimeError,
09007 "Unexpected error in an Op's C code. "
09008 "No Python exception was set.");
09009 }
09010 goto __label_114;}
09011 }
09012 if (!PyArray_Check(py_V113)) {
09013 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
09014 {
09015 __failure = 114;
09016 if (!PyErr_Occurred()) {
09017 PyErr_SetString(PyExc_RuntimeError,
09018 "Unexpected error in an Op's C code. "
09019 "No Python exception was set.");
09020 }
09021 goto __label_114;}
09022 }
09023 // We expect NPY_FLOAT64
09024 if (!PyArray_ISALIGNED((PyArrayObject*) py_V113)) {
09025 PyArrayObject * tmp = (PyArrayObject*) py_V113;
09026 PyErr_Format(PyExc_NotImplementedError,
09027 "expected an aligned array of type %ld "
09028 "(NPY_FLOAT64), got non-aligned array of type %ld"
09029 " with %ld dimensions, with 3 last dims "
09030 "%ld, %ld, %ld"
09031 " and 3 last strides %ld %ld, %ld.",
09032 (long int) NPY_FLOAT64,
09033 (long int) PyArray_TYPE((PyArrayObject*) py_V113),
09034 (long int) PyArray_NDIM(tmp),
09035 (long int) (PyArray_NDIM(tmp) >= 3 ?
09036 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
09037 (long int) (PyArray_NDIM(tmp) >= 2 ?
09038 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
09039 (long int) (PyArray_NDIM(tmp) >= 1 ?
09040 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
09041 (long int) (PyArray_NDIM(tmp) >= 3 ?
09042 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
09043 (long int) (PyArray_NDIM(tmp) >= 2 ?
09044 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
09045 (long int) (PyArray_NDIM(tmp) >= 1 ?
09046 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
09047 );
09048 {
09049 __failure = 114;
09050 if (!PyErr_Occurred()) {
09051 PyErr_SetString(PyExc_RuntimeError,
09052 "Unexpected error in an Op's C code. "
09053 "No Python exception was set.");
09054 }
09055 goto __label_114;}
09056 }
09057 // This is a TypeError to be consistent with DEBUG_MODE
09058 // Note: DEBUG_MODE also tells the name of the container
09059 if (PyArray_TYPE((PyArrayObject*) py_V113) != NPY_FLOAT64) {
09060 PyErr_Format(PyExc_TypeError,
09061 "expected type_num %d (NPY_FLOAT64) got %d",
09062 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V113));
09063 {
09064 __failure = 114;
09065 if (!PyErr_Occurred()) {
09066 PyErr_SetString(PyExc_RuntimeError,
09067 "Unexpected error in an Op's C code. "
09068 "No Python exception was set.");
09069 }
09070 goto __label_114;}
09071 }
09072
09073 V113 = (PyArrayObject*)(py_V113);
09074 Py_XINCREF(V113);
09075
09076 {
09077
09078 py_V115 = PyList_GET_ITEM(storage_V115, 0);
09079 {Py_XINCREF(py_V115);}
09080
09081 V115 = NULL;
09082 if (py_V115 == Py_None) {
09083 // We can either fail here or set V115 to NULL and rely on Ops
09084 // using tensors to handle the NULL case, but if they fail to do so
09085 // they'll end up with nasty segfaults, so this is public service.
09086 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
09087 {
09088 __failure = 116;
09089 if (!PyErr_Occurred()) {
09090 PyErr_SetString(PyExc_RuntimeError,
09091 "Unexpected error in an Op's C code. "
09092 "No Python exception was set.");
09093 }
09094 goto __label_116;}
09095 }
09096 if (!PyArray_Check(py_V115)) {
09097 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
09098 {
09099 __failure = 116;
09100 if (!PyErr_Occurred()) {
09101 PyErr_SetString(PyExc_RuntimeError,
09102 "Unexpected error in an Op's C code. "
09103 "No Python exception was set.");
09104 }
09105 goto __label_116;}
09106 }
09107 // We expect NPY_FLOAT64
09108 if (!PyArray_ISALIGNED((PyArrayObject*) py_V115)) {
09109 PyArrayObject * tmp = (PyArrayObject*) py_V115;
09110 PyErr_Format(PyExc_NotImplementedError,
09111 "expected an aligned array of type %ld "
09112 "(NPY_FLOAT64), got non-aligned array of type %ld"
09113 " with %ld dimensions, with 3 last dims "
09114 "%ld, %ld, %ld"
09115 " and 3 last strides %ld %ld, %ld.",
09116 (long int) NPY_FLOAT64,
09117 (long int) PyArray_TYPE((PyArrayObject*) py_V115),
09118 (long int) PyArray_NDIM(tmp),
09119 (long int) (PyArray_NDIM(tmp) >= 3 ?
09120 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
09121 (long int) (PyArray_NDIM(tmp) >= 2 ?
09122 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
09123 (long int) (PyArray_NDIM(tmp) >= 1 ?
09124 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
09125 (long int) (PyArray_NDIM(tmp) >= 3 ?
09126 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
09127 (long int) (PyArray_NDIM(tmp) >= 2 ?
09128 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
09129 (long int) (PyArray_NDIM(tmp) >= 1 ?
09130 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
09131 );
09132 {
09133 __failure = 116;
09134 if (!PyErr_Occurred()) {
09135 PyErr_SetString(PyExc_RuntimeError,
09136 "Unexpected error in an Op's C code. "
09137 "No Python exception was set.");
09138 }
09139 goto __label_116;}
09140 }
09141 // This is a TypeError to be consistent with DEBUG_MODE
09142 // Note: DEBUG_MODE also tells the name of the container
09143 if (PyArray_TYPE((PyArrayObject*) py_V115) != NPY_FLOAT64) {
09144 PyErr_Format(PyExc_TypeError,
09145 "expected type_num %d (NPY_FLOAT64) got %d",
09146 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V115));
09147 {
09148 __failure = 116;
09149 if (!PyErr_Occurred()) {
09150 PyErr_SetString(PyExc_RuntimeError,
09151 "Unexpected error in an Op's C code. "
09152 "No Python exception was set.");
09153 }
09154 goto __label_116;}
09155 }
09156
09157 V115 = (PyArrayObject*)(py_V115);
09158 Py_XINCREF(V115);
09159
09160 {
09161
09162 py_V117 = PyList_GET_ITEM(storage_V117, 0);
09163 {Py_XINCREF(py_V117);}
09164
09165 V117 = NULL;
09166 if (py_V117 == Py_None) {
09167 // We can either fail here or set V117 to NULL and rely on Ops
09168 // using tensors to handle the NULL case, but if they fail to do so
09169 // they'll end up with nasty segfaults, so this is public service.
09170 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
09171 {
09172 __failure = 118;
09173 if (!PyErr_Occurred()) {
09174 PyErr_SetString(PyExc_RuntimeError,
09175 "Unexpected error in an Op's C code. "
09176 "No Python exception was set.");
09177 }
09178 goto __label_118;}
09179 }
09180 if (!PyArray_Check(py_V117)) {
09181 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
09182 {
09183 __failure = 118;
09184 if (!PyErr_Occurred()) {
09185 PyErr_SetString(PyExc_RuntimeError,
09186 "Unexpected error in an Op's C code. "
09187 "No Python exception was set.");
09188 }
09189 goto __label_118;}
09190 }
09191 // We expect NPY_FLOAT64
09192 if (!PyArray_ISALIGNED((PyArrayObject*) py_V117)) {
09193 PyArrayObject * tmp = (PyArrayObject*) py_V117;
09194 PyErr_Format(PyExc_NotImplementedError,
09195 "expected an aligned array of type %ld "
09196 "(NPY_FLOAT64), got non-aligned array of type %ld"
09197 " with %ld dimensions, with 3 last dims "
09198 "%ld, %ld, %ld"
09199 " and 3 last strides %ld %ld, %ld.",
09200 (long int) NPY_FLOAT64,
09201 (long int) PyArray_TYPE((PyArrayObject*) py_V117),
09202 (long int) PyArray_NDIM(tmp),
09203 (long int) (PyArray_NDIM(tmp) >= 3 ?
09204 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
09205 (long int) (PyArray_NDIM(tmp) >= 2 ?
09206 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
09207 (long int) (PyArray_NDIM(tmp) >= 1 ?
09208 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
09209 (long int) (PyArray_NDIM(tmp) >= 3 ?
09210 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
09211 (long int) (PyArray_NDIM(tmp) >= 2 ?
09212 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
09213 (long int) (PyArray_NDIM(tmp) >= 1 ?
09214 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
09215 );
09216 {
09217 __failure = 118;
09218 if (!PyErr_Occurred()) {
09219 PyErr_SetString(PyExc_RuntimeError,
09220 "Unexpected error in an Op's C code. "
09221 "No Python exception was set.");
09222 }
09223 goto __label_118;}
09224 }
09225 // This is a TypeError to be consistent with DEBUG_MODE
09226 // Note: DEBUG_MODE also tells the name of the container
09227 if (PyArray_TYPE((PyArrayObject*) py_V117) != NPY_FLOAT64) {
09228 PyErr_Format(PyExc_TypeError,
09229 "expected type_num %d (NPY_FLOAT64) got %d",
09230 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V117));
09231 {
09232 __failure = 118;
09233 if (!PyErr_Occurred()) {
09234 PyErr_SetString(PyExc_RuntimeError,
09235 "Unexpected error in an Op's C code. "
09236 "No Python exception was set.");
09237 }
09238 goto __label_118;}
09239 }
09240
09241 V117 = (PyArrayObject*)(py_V117);
09242 Py_XINCREF(V117);
09243
09244 {
09245
09246 py_V119 = PyList_GET_ITEM(storage_V119, 0);
09247 {Py_XINCREF(py_V119);}
09248
09249 V119 = NULL;
09250 if (py_V119 == Py_None) {
09251 // We can either fail here or set V119 to NULL and rely on Ops
09252 // using tensors to handle the NULL case, but if they fail to do so
09253 // they'll end up with nasty segfaults, so this is public service.
09254 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
09255 {
09256 __failure = 120;
09257 if (!PyErr_Occurred()) {
09258 PyErr_SetString(PyExc_RuntimeError,
09259 "Unexpected error in an Op's C code. "
09260 "No Python exception was set.");
09261 }
09262 goto __label_120;}
09263 }
09264 if (!PyArray_Check(py_V119)) {
09265 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
09266 {
09267 __failure = 120;
09268 if (!PyErr_Occurred()) {
09269 PyErr_SetString(PyExc_RuntimeError,
09270 "Unexpected error in an Op's C code. "
09271 "No Python exception was set.");
09272 }
09273 goto __label_120;}
09274 }
09275 // We expect NPY_FLOAT64
09276 if (!PyArray_ISALIGNED((PyArrayObject*) py_V119)) {
09277 PyArrayObject * tmp = (PyArrayObject*) py_V119;
09278 PyErr_Format(PyExc_NotImplementedError,
09279 "expected an aligned array of type %ld "
09280 "(NPY_FLOAT64), got non-aligned array of type %ld"
09281 " with %ld dimensions, with 3 last dims "
09282 "%ld, %ld, %ld"
09283 " and 3 last strides %ld %ld, %ld.",
09284 (long int) NPY_FLOAT64,
09285 (long int) PyArray_TYPE((PyArrayObject*) py_V119),
09286 (long int) PyArray_NDIM(tmp),
09287 (long int) (PyArray_NDIM(tmp) >= 3 ?
09288 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
09289 (long int) (PyArray_NDIM(tmp) >= 2 ?
09290 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
09291 (long int) (PyArray_NDIM(tmp) >= 1 ?
09292 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
09293 (long int) (PyArray_NDIM(tmp) >= 3 ?
09294 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
09295 (long int) (PyArray_NDIM(tmp) >= 2 ?
09296 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
09297 (long int) (PyArray_NDIM(tmp) >= 1 ?
09298 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
09299 );
09300 {
09301 __failure = 120;
09302 if (!PyErr_Occurred()) {
09303 PyErr_SetString(PyExc_RuntimeError,
09304 "Unexpected error in an Op's C code. "
09305 "No Python exception was set.");
09306 }
09307 goto __label_120;}
09308 }
09309 // This is a TypeError to be consistent with DEBUG_MODE
09310 // Note: DEBUG_MODE also tells the name of the container
09311 if (PyArray_TYPE((PyArrayObject*) py_V119) != NPY_FLOAT64) {
09312 PyErr_Format(PyExc_TypeError,
09313 "expected type_num %d (NPY_FLOAT64) got %d",
09314 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V119));
09315 {
09316 __failure = 120;
09317 if (!PyErr_Occurred()) {
09318 PyErr_SetString(PyExc_RuntimeError,
09319 "Unexpected error in an Op's C code. "
09320 "No Python exception was set.");
09321 }
09322 goto __label_120;}
09323 }
09324
09325 V119 = (PyArrayObject*)(py_V119);
09326 Py_XINCREF(V119);
09327
09328 {
09329
09330 py_V121 = PyList_GET_ITEM(storage_V121, 0);
09331 {Py_XINCREF(py_V121);}
09332
09333 V121 = NULL;
09334 if (py_V121 == Py_None) {
09335 // We can either fail here or set V121 to NULL and rely on Ops
09336 // using tensors to handle the NULL case, but if they fail to do so
09337 // they'll end up with nasty segfaults, so this is public service.
09338 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
09339 {
09340 __failure = 122;
09341 if (!PyErr_Occurred()) {
09342 PyErr_SetString(PyExc_RuntimeError,
09343 "Unexpected error in an Op's C code. "
09344 "No Python exception was set.");
09345 }
09346 goto __label_122;}
09347 }
09348 if (!PyArray_Check(py_V121)) {
09349 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
09350 {
09351 __failure = 122;
09352 if (!PyErr_Occurred()) {
09353 PyErr_SetString(PyExc_RuntimeError,
09354 "Unexpected error in an Op's C code. "
09355 "No Python exception was set.");
09356 }
09357 goto __label_122;}
09358 }
09359 // We expect NPY_FLOAT64
09360 if (!PyArray_ISALIGNED((PyArrayObject*) py_V121)) {
09361 PyArrayObject * tmp = (PyArrayObject*) py_V121;
09362 PyErr_Format(PyExc_NotImplementedError,
09363 "expected an aligned array of type %ld "
09364 "(NPY_FLOAT64), got non-aligned array of type %ld"
09365 " with %ld dimensions, with 3 last dims "
09366 "%ld, %ld, %ld"
09367 " and 3 last strides %ld %ld, %ld.",
09368 (long int) NPY_FLOAT64,
09369 (long int) PyArray_TYPE((PyArrayObject*) py_V121),
09370 (long int) PyArray_NDIM(tmp),
09371 (long int) (PyArray_NDIM(tmp) >= 3 ?
09372 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
09373 (long int) (PyArray_NDIM(tmp) >= 2 ?
09374 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
09375 (long int) (PyArray_NDIM(tmp) >= 1 ?
09376 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
09377 (long int) (PyArray_NDIM(tmp) >= 3 ?
09378 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
09379 (long int) (PyArray_NDIM(tmp) >= 2 ?
09380 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
09381 (long int) (PyArray_NDIM(tmp) >= 1 ?
09382 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
09383 );
09384 {
09385 __failure = 122;
09386 if (!PyErr_Occurred()) {
09387 PyErr_SetString(PyExc_RuntimeError,
09388 "Unexpected error in an Op's C code. "
09389 "No Python exception was set.");
09390 }
09391 goto __label_122;}
09392 }
09393 // This is a TypeError to be consistent with DEBUG_MODE
09394 // Note: DEBUG_MODE also tells the name of the container
09395 if (PyArray_TYPE((PyArrayObject*) py_V121) != NPY_FLOAT64) {
09396 PyErr_Format(PyExc_TypeError,
09397 "expected type_num %d (NPY_FLOAT64) got %d",
09398 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V121));
09399 {
09400 __failure = 122;
09401 if (!PyErr_Occurred()) {
09402 PyErr_SetString(PyExc_RuntimeError,
09403 "Unexpected error in an Op's C code. "
09404 "No Python exception was set.");
09405 }
09406 goto __label_122;}
09407 }
09408
09409 V121 = (PyArrayObject*)(py_V121);
09410 Py_XINCREF(V121);
09411
09412 {
09413
09414 py_V123 = PyList_GET_ITEM(storage_V123, 0);
09415 {Py_XINCREF(py_V123);}
09416
09417 V123 = NULL;
09418 if (py_V123 == Py_None) {
09419 // We can either fail here or set V123 to NULL and rely on Ops
09420 // using tensors to handle the NULL case, but if they fail to do so
09421 // they'll end up with nasty segfaults, so this is public service.
09422 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
09423 {
09424 __failure = 124;
09425 if (!PyErr_Occurred()) {
09426 PyErr_SetString(PyExc_RuntimeError,
09427 "Unexpected error in an Op's C code. "
09428 "No Python exception was set.");
09429 }
09430 goto __label_124;}
09431 }
09432 if (!PyArray_Check(py_V123)) {
09433 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
09434 {
09435 __failure = 124;
09436 if (!PyErr_Occurred()) {
09437 PyErr_SetString(PyExc_RuntimeError,
09438 "Unexpected error in an Op's C code. "
09439 "No Python exception was set.");
09440 }
09441 goto __label_124;}
09442 }
09443 // We expect NPY_FLOAT64
09444 if (!PyArray_ISALIGNED((PyArrayObject*) py_V123)) {
09445 PyArrayObject * tmp = (PyArrayObject*) py_V123;
09446 PyErr_Format(PyExc_NotImplementedError,
09447 "expected an aligned array of type %ld "
09448 "(NPY_FLOAT64), got non-aligned array of type %ld"
09449 " with %ld dimensions, with 3 last dims "
09450 "%ld, %ld, %ld"
09451 " and 3 last strides %ld %ld, %ld.",
09452 (long int) NPY_FLOAT64,
09453 (long int) PyArray_TYPE((PyArrayObject*) py_V123),
09454 (long int) PyArray_NDIM(tmp),
09455 (long int) (PyArray_NDIM(tmp) >= 3 ?
09456 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
09457 (long int) (PyArray_NDIM(tmp) >= 2 ?
09458 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
09459 (long int) (PyArray_NDIM(tmp) >= 1 ?
09460 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
09461 (long int) (PyArray_NDIM(tmp) >= 3 ?
09462 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
09463 (long int) (PyArray_NDIM(tmp) >= 2 ?
09464 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
09465 (long int) (PyArray_NDIM(tmp) >= 1 ?
09466 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
09467 );
09468 {
09469 __failure = 124;
09470 if (!PyErr_Occurred()) {
09471 PyErr_SetString(PyExc_RuntimeError,
09472 "Unexpected error in an Op's C code. "
09473 "No Python exception was set.");
09474 }
09475 goto __label_124;}
09476 }
09477 // This is a TypeError to be consistent with DEBUG_MODE
09478 // Note: DEBUG_MODE also tells the name of the container
09479 if (PyArray_TYPE((PyArrayObject*) py_V123) != NPY_FLOAT64) {
09480 PyErr_Format(PyExc_TypeError,
09481 "expected type_num %d (NPY_FLOAT64) got %d",
09482 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V123));
09483 {
09484 __failure = 124;
09485 if (!PyErr_Occurred()) {
09486 PyErr_SetString(PyExc_RuntimeError,
09487 "Unexpected error in an Op's C code. "
09488 "No Python exception was set.");
09489 }
09490 goto __label_124;}
09491 }
09492
09493 V123 = (PyArrayObject*)(py_V123);
09494 Py_XINCREF(V123);
09495
09496 {
09497
09498 py_V125 = PyList_GET_ITEM(storage_V125, 0);
09499 {Py_XINCREF(py_V125);}
09500
09501 V125 = NULL;
09502 if (py_V125 == Py_None) {
09503 // We can either fail here or set V125 to NULL and rely on Ops
09504 // using tensors to handle the NULL case, but if they fail to do so
09505 // they'll end up with nasty segfaults, so this is public service.
09506 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
09507 {
09508 __failure = 126;
09509 if (!PyErr_Occurred()) {
09510 PyErr_SetString(PyExc_RuntimeError,
09511 "Unexpected error in an Op's C code. "
09512 "No Python exception was set.");
09513 }
09514 goto __label_126;}
09515 }
09516 if (!PyArray_Check(py_V125)) {
09517 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
09518 {
09519 __failure = 126;
09520 if (!PyErr_Occurred()) {
09521 PyErr_SetString(PyExc_RuntimeError,
09522 "Unexpected error in an Op's C code. "
09523 "No Python exception was set.");
09524 }
09525 goto __label_126;}
09526 }
09527 // We expect NPY_FLOAT64
09528 if (!PyArray_ISALIGNED((PyArrayObject*) py_V125)) {
09529 PyArrayObject * tmp = (PyArrayObject*) py_V125;
09530 PyErr_Format(PyExc_NotImplementedError,
09531 "expected an aligned array of type %ld "
09532 "(NPY_FLOAT64), got non-aligned array of type %ld"
09533 " with %ld dimensions, with 3 last dims "
09534 "%ld, %ld, %ld"
09535 " and 3 last strides %ld %ld, %ld.",
09536 (long int) NPY_FLOAT64,
09537 (long int) PyArray_TYPE((PyArrayObject*) py_V125),
09538 (long int) PyArray_NDIM(tmp),
09539 (long int) (PyArray_NDIM(tmp) >= 3 ?
09540 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
09541 (long int) (PyArray_NDIM(tmp) >= 2 ?
09542 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
09543 (long int) (PyArray_NDIM(tmp) >= 1 ?
09544 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
09545 (long int) (PyArray_NDIM(tmp) >= 3 ?
09546 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
09547 (long int) (PyArray_NDIM(tmp) >= 2 ?
09548 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
09549 (long int) (PyArray_NDIM(tmp) >= 1 ?
09550 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
09551 );
09552 {
09553 __failure = 126;
09554 if (!PyErr_Occurred()) {
09555 PyErr_SetString(PyExc_RuntimeError,
09556 "Unexpected error in an Op's C code. "
09557 "No Python exception was set.");
09558 }
09559 goto __label_126;}
09560 }
09561 // This is a TypeError to be consistent with DEBUG_MODE
09562 // Note: DEBUG_MODE also tells the name of the container
09563 if (PyArray_TYPE((PyArrayObject*) py_V125) != NPY_FLOAT64) {
09564 PyErr_Format(PyExc_TypeError,
09565 "expected type_num %d (NPY_FLOAT64) got %d",
09566 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V125));
09567 {
09568 __failure = 126;
09569 if (!PyErr_Occurred()) {
09570 PyErr_SetString(PyExc_RuntimeError,
09571 "Unexpected error in an Op's C code. "
09572 "No Python exception was set.");
09573 }
09574 goto __label_126;}
09575 }
09576
09577 V125 = (PyArrayObject*)(py_V125);
09578 Py_XINCREF(V125);
09579
09580 {
09581
09582 py_V127 = PyList_GET_ITEM(storage_V127, 0);
09583 {Py_XINCREF(py_V127);}
09584
09585 V127 = NULL;
09586 if (py_V127 == Py_None) {
09587 // We can either fail here or set V127 to NULL and rely on Ops
09588 // using tensors to handle the NULL case, but if they fail to do so
09589 // they'll end up with nasty segfaults, so this is public service.
09590 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
09591 {
09592 __failure = 128;
09593 if (!PyErr_Occurred()) {
09594 PyErr_SetString(PyExc_RuntimeError,
09595 "Unexpected error in an Op's C code. "
09596 "No Python exception was set.");
09597 }
09598 goto __label_128;}
09599 }
09600 if (!PyArray_Check(py_V127)) {
09601 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
09602 {
09603 __failure = 128;
09604 if (!PyErr_Occurred()) {
09605 PyErr_SetString(PyExc_RuntimeError,
09606 "Unexpected error in an Op's C code. "
09607 "No Python exception was set.");
09608 }
09609 goto __label_128;}
09610 }
09611 // We expect NPY_FLOAT64
09612 if (!PyArray_ISALIGNED((PyArrayObject*) py_V127)) {
09613 PyArrayObject * tmp = (PyArrayObject*) py_V127;
09614 PyErr_Format(PyExc_NotImplementedError,
09615 "expected an aligned array of type %ld "
09616 "(NPY_FLOAT64), got non-aligned array of type %ld"
09617 " with %ld dimensions, with 3 last dims "
09618 "%ld, %ld, %ld"
09619 " and 3 last strides %ld %ld, %ld.",
09620 (long int) NPY_FLOAT64,
09621 (long int) PyArray_TYPE((PyArrayObject*) py_V127),
09622 (long int) PyArray_NDIM(tmp),
09623 (long int) (PyArray_NDIM(tmp) >= 3 ?
09624 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
09625 (long int) (PyArray_NDIM(tmp) >= 2 ?
09626 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
09627 (long int) (PyArray_NDIM(tmp) >= 1 ?
09628 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
09629 (long int) (PyArray_NDIM(tmp) >= 3 ?
09630 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
09631 (long int) (PyArray_NDIM(tmp) >= 2 ?
09632 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
09633 (long int) (PyArray_NDIM(tmp) >= 1 ?
09634 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
09635 );
09636 {
09637 __failure = 128;
09638 if (!PyErr_Occurred()) {
09639 PyErr_SetString(PyExc_RuntimeError,
09640 "Unexpected error in an Op's C code. "
09641 "No Python exception was set.");
09642 }
09643 goto __label_128;}
09644 }
09645 // This is a TypeError to be consistent with DEBUG_MODE
09646 // Note: DEBUG_MODE also tells the name of the container
09647 if (PyArray_TYPE((PyArrayObject*) py_V127) != NPY_FLOAT64) {
09648 PyErr_Format(PyExc_TypeError,
09649 "expected type_num %d (NPY_FLOAT64) got %d",
09650 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V127));
09651 {
09652 __failure = 128;
09653 if (!PyErr_Occurred()) {
09654 PyErr_SetString(PyExc_RuntimeError,
09655 "Unexpected error in an Op's C code. "
09656 "No Python exception was set.");
09657 }
09658 goto __label_128;}
09659 }
09660
09661 V127 = (PyArrayObject*)(py_V127);
09662 Py_XINCREF(V127);
09663
09664 {
09665
09666 py_V129 = PyList_GET_ITEM(storage_V129, 0);
09667 {Py_XINCREF(py_V129);}
09668
09669 V129 = NULL;
09670 if (py_V129 == Py_None) {
09671 // We can either fail here or set V129 to NULL and rely on Ops
09672 // using tensors to handle the NULL case, but if they fail to do so
09673 // they'll end up with nasty segfaults, so this is public service.
09674 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
09675 {
09676 __failure = 130;
09677 if (!PyErr_Occurred()) {
09678 PyErr_SetString(PyExc_RuntimeError,
09679 "Unexpected error in an Op's C code. "
09680 "No Python exception was set.");
09681 }
09682 goto __label_130;}
09683 }
09684 if (!PyArray_Check(py_V129)) {
09685 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
09686 {
09687 __failure = 130;
09688 if (!PyErr_Occurred()) {
09689 PyErr_SetString(PyExc_RuntimeError,
09690 "Unexpected error in an Op's C code. "
09691 "No Python exception was set.");
09692 }
09693 goto __label_130;}
09694 }
09695 // We expect NPY_FLOAT64
09696 if (!PyArray_ISALIGNED((PyArrayObject*) py_V129)) {
09697 PyArrayObject * tmp = (PyArrayObject*) py_V129;
09698 PyErr_Format(PyExc_NotImplementedError,
09699 "expected an aligned array of type %ld "
09700 "(NPY_FLOAT64), got non-aligned array of type %ld"
09701 " with %ld dimensions, with 3 last dims "
09702 "%ld, %ld, %ld"
09703 " and 3 last strides %ld %ld, %ld.",
09704 (long int) NPY_FLOAT64,
09705 (long int) PyArray_TYPE((PyArrayObject*) py_V129),
09706 (long int) PyArray_NDIM(tmp),
09707 (long int) (PyArray_NDIM(tmp) >= 3 ?
09708 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
09709 (long int) (PyArray_NDIM(tmp) >= 2 ?
09710 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
09711 (long int) (PyArray_NDIM(tmp) >= 1 ?
09712 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
09713 (long int) (PyArray_NDIM(tmp) >= 3 ?
09714 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
09715 (long int) (PyArray_NDIM(tmp) >= 2 ?
09716 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
09717 (long int) (PyArray_NDIM(tmp) >= 1 ?
09718 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
09719 );
09720 {
09721 __failure = 130;
09722 if (!PyErr_Occurred()) {
09723 PyErr_SetString(PyExc_RuntimeError,
09724 "Unexpected error in an Op's C code. "
09725 "No Python exception was set.");
09726 }
09727 goto __label_130;}
09728 }
09729 // This is a TypeError to be consistent with DEBUG_MODE
09730 // Note: DEBUG_MODE also tells the name of the container
09731 if (PyArray_TYPE((PyArrayObject*) py_V129) != NPY_FLOAT64) {
09732 PyErr_Format(PyExc_TypeError,
09733 "expected type_num %d (NPY_FLOAT64) got %d",
09734 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V129));
09735 {
09736 __failure = 130;
09737 if (!PyErr_Occurred()) {
09738 PyErr_SetString(PyExc_RuntimeError,
09739 "Unexpected error in an Op's C code. "
09740 "No Python exception was set.");
09741 }
09742 goto __label_130;}
09743 }
09744
09745 V129 = (PyArrayObject*)(py_V129);
09746 Py_XINCREF(V129);
09747
09748 {
09749
09750 py_V131 = PyList_GET_ITEM(storage_V131, 0);
09751 {Py_XINCREF(py_V131);}
09752
09753 V131 = NULL;
09754 if (py_V131 == Py_None) {
09755 // We can either fail here or set V131 to NULL and rely on Ops
09756 // using tensors to handle the NULL case, but if they fail to do so
09757 // they'll end up with nasty segfaults, so this is public service.
09758 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
09759 {
09760 __failure = 132;
09761 if (!PyErr_Occurred()) {
09762 PyErr_SetString(PyExc_RuntimeError,
09763 "Unexpected error in an Op's C code. "
09764 "No Python exception was set.");
09765 }
09766 goto __label_132;}
09767 }
09768 if (!PyArray_Check(py_V131)) {
09769 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
09770 {
09771 __failure = 132;
09772 if (!PyErr_Occurred()) {
09773 PyErr_SetString(PyExc_RuntimeError,
09774 "Unexpected error in an Op's C code. "
09775 "No Python exception was set.");
09776 }
09777 goto __label_132;}
09778 }
09779 // We expect NPY_FLOAT64
09780 if (!PyArray_ISALIGNED((PyArrayObject*) py_V131)) {
09781 PyArrayObject * tmp = (PyArrayObject*) py_V131;
09782 PyErr_Format(PyExc_NotImplementedError,
09783 "expected an aligned array of type %ld "
09784 "(NPY_FLOAT64), got non-aligned array of type %ld"
09785 " with %ld dimensions, with 3 last dims "
09786 "%ld, %ld, %ld"
09787 " and 3 last strides %ld %ld, %ld.",
09788 (long int) NPY_FLOAT64,
09789 (long int) PyArray_TYPE((PyArrayObject*) py_V131),
09790 (long int) PyArray_NDIM(tmp),
09791 (long int) (PyArray_NDIM(tmp) >= 3 ?
09792 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
09793 (long int) (PyArray_NDIM(tmp) >= 2 ?
09794 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
09795 (long int) (PyArray_NDIM(tmp) >= 1 ?
09796 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
09797 (long int) (PyArray_NDIM(tmp) >= 3 ?
09798 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
09799 (long int) (PyArray_NDIM(tmp) >= 2 ?
09800 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
09801 (long int) (PyArray_NDIM(tmp) >= 1 ?
09802 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
09803 );
09804 {
09805 __failure = 132;
09806 if (!PyErr_Occurred()) {
09807 PyErr_SetString(PyExc_RuntimeError,
09808 "Unexpected error in an Op's C code. "
09809 "No Python exception was set.");
09810 }
09811 goto __label_132;}
09812 }
09813 // This is a TypeError to be consistent with DEBUG_MODE
09814 // Note: DEBUG_MODE also tells the name of the container
09815 if (PyArray_TYPE((PyArrayObject*) py_V131) != NPY_FLOAT64) {
09816 PyErr_Format(PyExc_TypeError,
09817 "expected type_num %d (NPY_FLOAT64) got %d",
09818 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V131));
09819 {
09820 __failure = 132;
09821 if (!PyErr_Occurred()) {
09822 PyErr_SetString(PyExc_RuntimeError,
09823 "Unexpected error in an Op's C code. "
09824 "No Python exception was set.");
09825 }
09826 goto __label_132;}
09827 }
09828
09829 V131 = (PyArrayObject*)(py_V131);
09830 Py_XINCREF(V131);
09831
09832 {
09833
09834 py_V133 = PyList_GET_ITEM(storage_V133, 0);
09835 {Py_XINCREF(py_V133);}
09836
09837 V133 = NULL;
09838 if (py_V133 == Py_None) {
09839 // We can either fail here or set V133 to NULL and rely on Ops
09840 // using tensors to handle the NULL case, but if they fail to do so
09841 // they'll end up with nasty segfaults, so this is public service.
09842 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
09843 {
09844 __failure = 134;
09845 if (!PyErr_Occurred()) {
09846 PyErr_SetString(PyExc_RuntimeError,
09847 "Unexpected error in an Op's C code. "
09848 "No Python exception was set.");
09849 }
09850 goto __label_134;}
09851 }
09852 if (!PyArray_Check(py_V133)) {
09853 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
09854 {
09855 __failure = 134;
09856 if (!PyErr_Occurred()) {
09857 PyErr_SetString(PyExc_RuntimeError,
09858 "Unexpected error in an Op's C code. "
09859 "No Python exception was set.");
09860 }
09861 goto __label_134;}
09862 }
09863 // We expect NPY_FLOAT64
09864 if (!PyArray_ISALIGNED((PyArrayObject*) py_V133)) {
09865 PyArrayObject * tmp = (PyArrayObject*) py_V133;
09866 PyErr_Format(PyExc_NotImplementedError,
09867 "expected an aligned array of type %ld "
09868 "(NPY_FLOAT64), got non-aligned array of type %ld"
09869 " with %ld dimensions, with 3 last dims "
09870 "%ld, %ld, %ld"
09871 " and 3 last strides %ld %ld, %ld.",
09872 (long int) NPY_FLOAT64,
09873 (long int) PyArray_TYPE((PyArrayObject*) py_V133),
09874 (long int) PyArray_NDIM(tmp),
09875 (long int) (PyArray_NDIM(tmp) >= 3 ?
09876 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
09877 (long int) (PyArray_NDIM(tmp) >= 2 ?
09878 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
09879 (long int) (PyArray_NDIM(tmp) >= 1 ?
09880 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
09881 (long int) (PyArray_NDIM(tmp) >= 3 ?
09882 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
09883 (long int) (PyArray_NDIM(tmp) >= 2 ?
09884 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
09885 (long int) (PyArray_NDIM(tmp) >= 1 ?
09886 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
09887 );
09888 {
09889 __failure = 134;
09890 if (!PyErr_Occurred()) {
09891 PyErr_SetString(PyExc_RuntimeError,
09892 "Unexpected error in an Op's C code. "
09893 "No Python exception was set.");
09894 }
09895 goto __label_134;}
09896 }
09897 // This is a TypeError to be consistent with DEBUG_MODE
09898 // Note: DEBUG_MODE also tells the name of the container
09899 if (PyArray_TYPE((PyArrayObject*) py_V133) != NPY_FLOAT64) {
09900 PyErr_Format(PyExc_TypeError,
09901 "expected type_num %d (NPY_FLOAT64) got %d",
09902 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V133));
09903 {
09904 __failure = 134;
09905 if (!PyErr_Occurred()) {
09906 PyErr_SetString(PyExc_RuntimeError,
09907 "Unexpected error in an Op's C code. "
09908 "No Python exception was set.");
09909 }
09910 goto __label_134;}
09911 }
09912
09913 V133 = (PyArrayObject*)(py_V133);
09914 Py_XINCREF(V133);
09915
09916 {
09917
09918 py_V135 = PyList_GET_ITEM(storage_V135, 0);
09919 {Py_XINCREF(py_V135);}
09920
09921 V135 = NULL;
09922 if (py_V135 == Py_None) {
09923 // We can either fail here or set V135 to NULL and rely on Ops
09924 // using tensors to handle the NULL case, but if they fail to do so
09925 // they'll end up with nasty segfaults, so this is public service.
09926 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
09927 {
09928 __failure = 136;
09929 if (!PyErr_Occurred()) {
09930 PyErr_SetString(PyExc_RuntimeError,
09931 "Unexpected error in an Op's C code. "
09932 "No Python exception was set.");
09933 }
09934 goto __label_136;}
09935 }
09936 if (!PyArray_Check(py_V135)) {
09937 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
09938 {
09939 __failure = 136;
09940 if (!PyErr_Occurred()) {
09941 PyErr_SetString(PyExc_RuntimeError,
09942 "Unexpected error in an Op's C code. "
09943 "No Python exception was set.");
09944 }
09945 goto __label_136;}
09946 }
09947 // We expect NPY_FLOAT64
09948 if (!PyArray_ISALIGNED((PyArrayObject*) py_V135)) {
09949 PyArrayObject * tmp = (PyArrayObject*) py_V135;
09950 PyErr_Format(PyExc_NotImplementedError,
09951 "expected an aligned array of type %ld "
09952 "(NPY_FLOAT64), got non-aligned array of type %ld"
09953 " with %ld dimensions, with 3 last dims "
09954 "%ld, %ld, %ld"
09955 " and 3 last strides %ld %ld, %ld.",
09956 (long int) NPY_FLOAT64,
09957 (long int) PyArray_TYPE((PyArrayObject*) py_V135),
09958 (long int) PyArray_NDIM(tmp),
09959 (long int) (PyArray_NDIM(tmp) >= 3 ?
09960 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
09961 (long int) (PyArray_NDIM(tmp) >= 2 ?
09962 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
09963 (long int) (PyArray_NDIM(tmp) >= 1 ?
09964 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
09965 (long int) (PyArray_NDIM(tmp) >= 3 ?
09966 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
09967 (long int) (PyArray_NDIM(tmp) >= 2 ?
09968 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
09969 (long int) (PyArray_NDIM(tmp) >= 1 ?
09970 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
09971 );
09972 {
09973 __failure = 136;
09974 if (!PyErr_Occurred()) {
09975 PyErr_SetString(PyExc_RuntimeError,
09976 "Unexpected error in an Op's C code. "
09977 "No Python exception was set.");
09978 }
09979 goto __label_136;}
09980 }
09981 // This is a TypeError to be consistent with DEBUG_MODE
09982 // Note: DEBUG_MODE also tells the name of the container
09983 if (PyArray_TYPE((PyArrayObject*) py_V135) != NPY_FLOAT64) {
09984 PyErr_Format(PyExc_TypeError,
09985 "expected type_num %d (NPY_FLOAT64) got %d",
09986 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V135));
09987 {
09988 __failure = 136;
09989 if (!PyErr_Occurred()) {
09990 PyErr_SetString(PyExc_RuntimeError,
09991 "Unexpected error in an Op's C code. "
09992 "No Python exception was set.");
09993 }
09994 goto __label_136;}
09995 }
09996
09997 V135 = (PyArrayObject*)(py_V135);
09998 Py_XINCREF(V135);
09999
10000 {
10001
10002 py_V137 = PyList_GET_ITEM(storage_V137, 0);
10003 {Py_XINCREF(py_V137);}
10004
10005 V137 = NULL;
10006 if (py_V137 == Py_None) {
10007 // We can either fail here or set V137 to NULL and rely on Ops
10008 // using tensors to handle the NULL case, but if they fail to do so
10009 // they'll end up with nasty segfaults, so this is public service.
10010 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
10011 {
10012 __failure = 138;
10013 if (!PyErr_Occurred()) {
10014 PyErr_SetString(PyExc_RuntimeError,
10015 "Unexpected error in an Op's C code. "
10016 "No Python exception was set.");
10017 }
10018 goto __label_138;}
10019 }
10020 if (!PyArray_Check(py_V137)) {
10021 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
10022 {
10023 __failure = 138;
10024 if (!PyErr_Occurred()) {
10025 PyErr_SetString(PyExc_RuntimeError,
10026 "Unexpected error in an Op's C code. "
10027 "No Python exception was set.");
10028 }
10029 goto __label_138;}
10030 }
10031 // We expect NPY_FLOAT64
10032 if (!PyArray_ISALIGNED((PyArrayObject*) py_V137)) {
10033 PyArrayObject * tmp = (PyArrayObject*) py_V137;
10034 PyErr_Format(PyExc_NotImplementedError,
10035 "expected an aligned array of type %ld "
10036 "(NPY_FLOAT64), got non-aligned array of type %ld"
10037 " with %ld dimensions, with 3 last dims "
10038 "%ld, %ld, %ld"
10039 " and 3 last strides %ld %ld, %ld.",
10040 (long int) NPY_FLOAT64,
10041 (long int) PyArray_TYPE((PyArrayObject*) py_V137),
10042 (long int) PyArray_NDIM(tmp),
10043 (long int) (PyArray_NDIM(tmp) >= 3 ?
10044 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
10045 (long int) (PyArray_NDIM(tmp) >= 2 ?
10046 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
10047 (long int) (PyArray_NDIM(tmp) >= 1 ?
10048 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
10049 (long int) (PyArray_NDIM(tmp) >= 3 ?
10050 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
10051 (long int) (PyArray_NDIM(tmp) >= 2 ?
10052 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
10053 (long int) (PyArray_NDIM(tmp) >= 1 ?
10054 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
10055 );
10056 {
10057 __failure = 138;
10058 if (!PyErr_Occurred()) {
10059 PyErr_SetString(PyExc_RuntimeError,
10060 "Unexpected error in an Op's C code. "
10061 "No Python exception was set.");
10062 }
10063 goto __label_138;}
10064 }
10065 // This is a TypeError to be consistent with DEBUG_MODE
10066 // Note: DEBUG_MODE also tells the name of the container
10067 if (PyArray_TYPE((PyArrayObject*) py_V137) != NPY_FLOAT64) {
10068 PyErr_Format(PyExc_TypeError,
10069 "expected type_num %d (NPY_FLOAT64) got %d",
10070 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V137));
10071 {
10072 __failure = 138;
10073 if (!PyErr_Occurred()) {
10074 PyErr_SetString(PyExc_RuntimeError,
10075 "Unexpected error in an Op's C code. "
10076 "No Python exception was set.");
10077 }
10078 goto __label_138;}
10079 }
10080
10081 V137 = (PyArrayObject*)(py_V137);
10082 Py_XINCREF(V137);
10083
10084 {
10085
10086 py_V139 = PyList_GET_ITEM(storage_V139, 0);
10087 {Py_XINCREF(py_V139);}
10088
10089 V139 = NULL;
10090 if (py_V139 == Py_None) {
10091 // We can either fail here or set V139 to NULL and rely on Ops
10092 // using tensors to handle the NULL case, but if they fail to do so
10093 // they'll end up with nasty segfaults, so this is public service.
10094 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
10095 {
10096 __failure = 140;
10097 if (!PyErr_Occurred()) {
10098 PyErr_SetString(PyExc_RuntimeError,
10099 "Unexpected error in an Op's C code. "
10100 "No Python exception was set.");
10101 }
10102 goto __label_140;}
10103 }
10104 if (!PyArray_Check(py_V139)) {
10105 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
10106 {
10107 __failure = 140;
10108 if (!PyErr_Occurred()) {
10109 PyErr_SetString(PyExc_RuntimeError,
10110 "Unexpected error in an Op's C code. "
10111 "No Python exception was set.");
10112 }
10113 goto __label_140;}
10114 }
10115 // We expect NPY_FLOAT64
10116 if (!PyArray_ISALIGNED((PyArrayObject*) py_V139)) {
10117 PyArrayObject * tmp = (PyArrayObject*) py_V139;
10118 PyErr_Format(PyExc_NotImplementedError,
10119 "expected an aligned array of type %ld "
10120 "(NPY_FLOAT64), got non-aligned array of type %ld"
10121 " with %ld dimensions, with 3 last dims "
10122 "%ld, %ld, %ld"
10123 " and 3 last strides %ld %ld, %ld.",
10124 (long int) NPY_FLOAT64,
10125 (long int) PyArray_TYPE((PyArrayObject*) py_V139),
10126 (long int) PyArray_NDIM(tmp),
10127 (long int) (PyArray_NDIM(tmp) >= 3 ?
10128 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
10129 (long int) (PyArray_NDIM(tmp) >= 2 ?
10130 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
10131 (long int) (PyArray_NDIM(tmp) >= 1 ?
10132 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
10133 (long int) (PyArray_NDIM(tmp) >= 3 ?
10134 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
10135 (long int) (PyArray_NDIM(tmp) >= 2 ?
10136 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
10137 (long int) (PyArray_NDIM(tmp) >= 1 ?
10138 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
10139 );
10140 {
10141 __failure = 140;
10142 if (!PyErr_Occurred()) {
10143 PyErr_SetString(PyExc_RuntimeError,
10144 "Unexpected error in an Op's C code. "
10145 "No Python exception was set.");
10146 }
10147 goto __label_140;}
10148 }
10149 // This is a TypeError to be consistent with DEBUG_MODE
10150 // Note: DEBUG_MODE also tells the name of the container
10151 if (PyArray_TYPE((PyArrayObject*) py_V139) != NPY_FLOAT64) {
10152 PyErr_Format(PyExc_TypeError,
10153 "expected type_num %d (NPY_FLOAT64) got %d",
10154 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V139));
10155 {
10156 __failure = 140;
10157 if (!PyErr_Occurred()) {
10158 PyErr_SetString(PyExc_RuntimeError,
10159 "Unexpected error in an Op's C code. "
10160 "No Python exception was set.");
10161 }
10162 goto __label_140;}
10163 }
10164
10165 V139 = (PyArrayObject*)(py_V139);
10166 Py_XINCREF(V139);
10167
10168 {
10169
10170 py_V141 = PyList_GET_ITEM(storage_V141, 0);
10171 {Py_XINCREF(py_V141);}
10172
10173 V141 = NULL;
10174 if (py_V141 == Py_None) {
10175 // We can either fail here or set V141 to NULL and rely on Ops
10176 // using tensors to handle the NULL case, but if they fail to do so
10177 // they'll end up with nasty segfaults, so this is public service.
10178 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
10179 {
10180 __failure = 142;
10181 if (!PyErr_Occurred()) {
10182 PyErr_SetString(PyExc_RuntimeError,
10183 "Unexpected error in an Op's C code. "
10184 "No Python exception was set.");
10185 }
10186 goto __label_142;}
10187 }
10188 if (!PyArray_Check(py_V141)) {
10189 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
10190 {
10191 __failure = 142;
10192 if (!PyErr_Occurred()) {
10193 PyErr_SetString(PyExc_RuntimeError,
10194 "Unexpected error in an Op's C code. "
10195 "No Python exception was set.");
10196 }
10197 goto __label_142;}
10198 }
10199 // We expect NPY_FLOAT64
10200 if (!PyArray_ISALIGNED((PyArrayObject*) py_V141)) {
10201 PyArrayObject * tmp = (PyArrayObject*) py_V141;
10202 PyErr_Format(PyExc_NotImplementedError,
10203 "expected an aligned array of type %ld "
10204 "(NPY_FLOAT64), got non-aligned array of type %ld"
10205 " with %ld dimensions, with 3 last dims "
10206 "%ld, %ld, %ld"
10207 " and 3 last strides %ld %ld, %ld.",
10208 (long int) NPY_FLOAT64,
10209 (long int) PyArray_TYPE((PyArrayObject*) py_V141),
10210 (long int) PyArray_NDIM(tmp),
10211 (long int) (PyArray_NDIM(tmp) >= 3 ?
10212 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
10213 (long int) (PyArray_NDIM(tmp) >= 2 ?
10214 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
10215 (long int) (PyArray_NDIM(tmp) >= 1 ?
10216 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
10217 (long int) (PyArray_NDIM(tmp) >= 3 ?
10218 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
10219 (long int) (PyArray_NDIM(tmp) >= 2 ?
10220 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
10221 (long int) (PyArray_NDIM(tmp) >= 1 ?
10222 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
10223 );
10224 {
10225 __failure = 142;
10226 if (!PyErr_Occurred()) {
10227 PyErr_SetString(PyExc_RuntimeError,
10228 "Unexpected error in an Op's C code. "
10229 "No Python exception was set.");
10230 }
10231 goto __label_142;}
10232 }
10233 // This is a TypeError to be consistent with DEBUG_MODE
10234 // Note: DEBUG_MODE also tells the name of the container
10235 if (PyArray_TYPE((PyArrayObject*) py_V141) != NPY_FLOAT64) {
10236 PyErr_Format(PyExc_TypeError,
10237 "expected type_num %d (NPY_FLOAT64) got %d",
10238 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V141));
10239 {
10240 __failure = 142;
10241 if (!PyErr_Occurred()) {
10242 PyErr_SetString(PyExc_RuntimeError,
10243 "Unexpected error in an Op's C code. "
10244 "No Python exception was set.");
10245 }
10246 goto __label_142;}
10247 }
10248
10249 V141 = (PyArrayObject*)(py_V141);
10250 Py_XINCREF(V141);
10251
10252 {
10253
10254 py_V143 = PyList_GET_ITEM(storage_V143, 0);
10255 {Py_XINCREF(py_V143);}
10256
10257 V143 = NULL;
10258 if (py_V143 == Py_None) {
10259 // We can either fail here or set V143 to NULL and rely on Ops
10260 // using tensors to handle the NULL case, but if they fail to do so
10261 // they'll end up with nasty segfaults, so this is public service.
10262 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
10263 {
10264 __failure = 144;
10265 if (!PyErr_Occurred()) {
10266 PyErr_SetString(PyExc_RuntimeError,
10267 "Unexpected error in an Op's C code. "
10268 "No Python exception was set.");
10269 }
10270 goto __label_144;}
10271 }
10272 if (!PyArray_Check(py_V143)) {
10273 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
10274 {
10275 __failure = 144;
10276 if (!PyErr_Occurred()) {
10277 PyErr_SetString(PyExc_RuntimeError,
10278 "Unexpected error in an Op's C code. "
10279 "No Python exception was set.");
10280 }
10281 goto __label_144;}
10282 }
10283 // We expect NPY_FLOAT64
10284 if (!PyArray_ISALIGNED((PyArrayObject*) py_V143)) {
10285 PyArrayObject * tmp = (PyArrayObject*) py_V143;
10286 PyErr_Format(PyExc_NotImplementedError,
10287 "expected an aligned array of type %ld "
10288 "(NPY_FLOAT64), got non-aligned array of type %ld"
10289 " with %ld dimensions, with 3 last dims "
10290 "%ld, %ld, %ld"
10291 " and 3 last strides %ld %ld, %ld.",
10292 (long int) NPY_FLOAT64,
10293 (long int) PyArray_TYPE((PyArrayObject*) py_V143),
10294 (long int) PyArray_NDIM(tmp),
10295 (long int) (PyArray_NDIM(tmp) >= 3 ?
10296 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
10297 (long int) (PyArray_NDIM(tmp) >= 2 ?
10298 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
10299 (long int) (PyArray_NDIM(tmp) >= 1 ?
10300 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
10301 (long int) (PyArray_NDIM(tmp) >= 3 ?
10302 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
10303 (long int) (PyArray_NDIM(tmp) >= 2 ?
10304 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
10305 (long int) (PyArray_NDIM(tmp) >= 1 ?
10306 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
10307 );
10308 {
10309 __failure = 144;
10310 if (!PyErr_Occurred()) {
10311 PyErr_SetString(PyExc_RuntimeError,
10312 "Unexpected error in an Op's C code. "
10313 "No Python exception was set.");
10314 }
10315 goto __label_144;}
10316 }
10317 // This is a TypeError to be consistent with DEBUG_MODE
10318 // Note: DEBUG_MODE also tells the name of the container
10319 if (PyArray_TYPE((PyArrayObject*) py_V143) != NPY_FLOAT64) {
10320 PyErr_Format(PyExc_TypeError,
10321 "expected type_num %d (NPY_FLOAT64) got %d",
10322 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V143));
10323 {
10324 __failure = 144;
10325 if (!PyErr_Occurred()) {
10326 PyErr_SetString(PyExc_RuntimeError,
10327 "Unexpected error in an Op's C code. "
10328 "No Python exception was set.");
10329 }
10330 goto __label_144;}
10331 }
10332
10333 V143 = (PyArrayObject*)(py_V143);
10334 Py_XINCREF(V143);
10335
10336 {
10337
10338 py_V145 = PyList_GET_ITEM(storage_V145, 0);
10339 {Py_XINCREF(py_V145);}
10340
10341 V145 = NULL;
10342 if (py_V145 == Py_None) {
10343 // We can either fail here or set V145 to NULL and rely on Ops
10344 // using tensors to handle the NULL case, but if they fail to do so
10345 // they'll end up with nasty segfaults, so this is public service.
10346 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
10347 {
10348 __failure = 146;
10349 if (!PyErr_Occurred()) {
10350 PyErr_SetString(PyExc_RuntimeError,
10351 "Unexpected error in an Op's C code. "
10352 "No Python exception was set.");
10353 }
10354 goto __label_146;}
10355 }
10356 if (!PyArray_Check(py_V145)) {
10357 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
10358 {
10359 __failure = 146;
10360 if (!PyErr_Occurred()) {
10361 PyErr_SetString(PyExc_RuntimeError,
10362 "Unexpected error in an Op's C code. "
10363 "No Python exception was set.");
10364 }
10365 goto __label_146;}
10366 }
10367 // We expect NPY_FLOAT64
10368 if (!PyArray_ISALIGNED((PyArrayObject*) py_V145)) {
10369 PyArrayObject * tmp = (PyArrayObject*) py_V145;
10370 PyErr_Format(PyExc_NotImplementedError,
10371 "expected an aligned array of type %ld "
10372 "(NPY_FLOAT64), got non-aligned array of type %ld"
10373 " with %ld dimensions, with 3 last dims "
10374 "%ld, %ld, %ld"
10375 " and 3 last strides %ld %ld, %ld.",
10376 (long int) NPY_FLOAT64,
10377 (long int) PyArray_TYPE((PyArrayObject*) py_V145),
10378 (long int) PyArray_NDIM(tmp),
10379 (long int) (PyArray_NDIM(tmp) >= 3 ?
10380 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
10381 (long int) (PyArray_NDIM(tmp) >= 2 ?
10382 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
10383 (long int) (PyArray_NDIM(tmp) >= 1 ?
10384 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
10385 (long int) (PyArray_NDIM(tmp) >= 3 ?
10386 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
10387 (long int) (PyArray_NDIM(tmp) >= 2 ?
10388 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
10389 (long int) (PyArray_NDIM(tmp) >= 1 ?
10390 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
10391 );
10392 {
10393 __failure = 146;
10394 if (!PyErr_Occurred()) {
10395 PyErr_SetString(PyExc_RuntimeError,
10396 "Unexpected error in an Op's C code. "
10397 "No Python exception was set.");
10398 }
10399 goto __label_146;}
10400 }
10401 // This is a TypeError to be consistent with DEBUG_MODE
10402 // Note: DEBUG_MODE also tells the name of the container
10403 if (PyArray_TYPE((PyArrayObject*) py_V145) != NPY_FLOAT64) {
10404 PyErr_Format(PyExc_TypeError,
10405 "expected type_num %d (NPY_FLOAT64) got %d",
10406 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V145));
10407 {
10408 __failure = 146;
10409 if (!PyErr_Occurred()) {
10410 PyErr_SetString(PyExc_RuntimeError,
10411 "Unexpected error in an Op's C code. "
10412 "No Python exception was set.");
10413 }
10414 goto __label_146;}
10415 }
10416
10417 V145 = (PyArrayObject*)(py_V145);
10418 Py_XINCREF(V145);
10419
10420 {
10421
10422 py_V147 = PyList_GET_ITEM(storage_V147, 0);
10423 {Py_XINCREF(py_V147);}
10424
10425 V147 = NULL;
10426 if (py_V147 == Py_None) {
10427 // We can either fail here or set V147 to NULL and rely on Ops
10428 // using tensors to handle the NULL case, but if they fail to do so
10429 // they'll end up with nasty segfaults, so this is public service.
10430 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
10431 {
10432 __failure = 148;
10433 if (!PyErr_Occurred()) {
10434 PyErr_SetString(PyExc_RuntimeError,
10435 "Unexpected error in an Op's C code. "
10436 "No Python exception was set.");
10437 }
10438 goto __label_148;}
10439 }
10440 if (!PyArray_Check(py_V147)) {
10441 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
10442 {
10443 __failure = 148;
10444 if (!PyErr_Occurred()) {
10445 PyErr_SetString(PyExc_RuntimeError,
10446 "Unexpected error in an Op's C code. "
10447 "No Python exception was set.");
10448 }
10449 goto __label_148;}
10450 }
10451 // We expect NPY_FLOAT64
10452 if (!PyArray_ISALIGNED((PyArrayObject*) py_V147)) {
10453 PyArrayObject * tmp = (PyArrayObject*) py_V147;
10454 PyErr_Format(PyExc_NotImplementedError,
10455 "expected an aligned array of type %ld "
10456 "(NPY_FLOAT64), got non-aligned array of type %ld"
10457 " with %ld dimensions, with 3 last dims "
10458 "%ld, %ld, %ld"
10459 " and 3 last strides %ld %ld, %ld.",
10460 (long int) NPY_FLOAT64,
10461 (long int) PyArray_TYPE((PyArrayObject*) py_V147),
10462 (long int) PyArray_NDIM(tmp),
10463 (long int) (PyArray_NDIM(tmp) >= 3 ?
10464 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
10465 (long int) (PyArray_NDIM(tmp) >= 2 ?
10466 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
10467 (long int) (PyArray_NDIM(tmp) >= 1 ?
10468 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
10469 (long int) (PyArray_NDIM(tmp) >= 3 ?
10470 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
10471 (long int) (PyArray_NDIM(tmp) >= 2 ?
10472 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
10473 (long int) (PyArray_NDIM(tmp) >= 1 ?
10474 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
10475 );
10476 {
10477 __failure = 148;
10478 if (!PyErr_Occurred()) {
10479 PyErr_SetString(PyExc_RuntimeError,
10480 "Unexpected error in an Op's C code. "
10481 "No Python exception was set.");
10482 }
10483 goto __label_148;}
10484 }
10485 // This is a TypeError to be consistent with DEBUG_MODE
10486 // Note: DEBUG_MODE also tells the name of the container
10487 if (PyArray_TYPE((PyArrayObject*) py_V147) != NPY_FLOAT64) {
10488 PyErr_Format(PyExc_TypeError,
10489 "expected type_num %d (NPY_FLOAT64) got %d",
10490 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V147));
10491 {
10492 __failure = 148;
10493 if (!PyErr_Occurred()) {
10494 PyErr_SetString(PyExc_RuntimeError,
10495 "Unexpected error in an Op's C code. "
10496 "No Python exception was set.");
10497 }
10498 goto __label_148;}
10499 }
10500
10501 V147 = (PyArrayObject*)(py_V147);
10502 Py_XINCREF(V147);
10503
10504 {
10505
10506 py_V149 = PyList_GET_ITEM(storage_V149, 0);
10507 {Py_XINCREF(py_V149);}
10508
10509 V149 = NULL;
10510 if (py_V149 == Py_None) {
10511 // We can either fail here or set V149 to NULL and rely on Ops
10512 // using tensors to handle the NULL case, but if they fail to do so
10513 // they'll end up with nasty segfaults, so this is public service.
10514 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
10515 {
10516 __failure = 150;
10517 if (!PyErr_Occurred()) {
10518 PyErr_SetString(PyExc_RuntimeError,
10519 "Unexpected error in an Op's C code. "
10520 "No Python exception was set.");
10521 }
10522 goto __label_150;}
10523 }
10524 if (!PyArray_Check(py_V149)) {
10525 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
10526 {
10527 __failure = 150;
10528 if (!PyErr_Occurred()) {
10529 PyErr_SetString(PyExc_RuntimeError,
10530 "Unexpected error in an Op's C code. "
10531 "No Python exception was set.");
10532 }
10533 goto __label_150;}
10534 }
10535 // We expect NPY_FLOAT64
10536 if (!PyArray_ISALIGNED((PyArrayObject*) py_V149)) {
10537 PyArrayObject * tmp = (PyArrayObject*) py_V149;
10538 PyErr_Format(PyExc_NotImplementedError,
10539 "expected an aligned array of type %ld "
10540 "(NPY_FLOAT64), got non-aligned array of type %ld"
10541 " with %ld dimensions, with 3 last dims "
10542 "%ld, %ld, %ld"
10543 " and 3 last strides %ld %ld, %ld.",
10544 (long int) NPY_FLOAT64,
10545 (long int) PyArray_TYPE((PyArrayObject*) py_V149),
10546 (long int) PyArray_NDIM(tmp),
10547 (long int) (PyArray_NDIM(tmp) >= 3 ?
10548 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
10549 (long int) (PyArray_NDIM(tmp) >= 2 ?
10550 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
10551 (long int) (PyArray_NDIM(tmp) >= 1 ?
10552 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
10553 (long int) (PyArray_NDIM(tmp) >= 3 ?
10554 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
10555 (long int) (PyArray_NDIM(tmp) >= 2 ?
10556 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
10557 (long int) (PyArray_NDIM(tmp) >= 1 ?
10558 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
10559 );
10560 {
10561 __failure = 150;
10562 if (!PyErr_Occurred()) {
10563 PyErr_SetString(PyExc_RuntimeError,
10564 "Unexpected error in an Op's C code. "
10565 "No Python exception was set.");
10566 }
10567 goto __label_150;}
10568 }
10569 // This is a TypeError to be consistent with DEBUG_MODE
10570 // Note: DEBUG_MODE also tells the name of the container
10571 if (PyArray_TYPE((PyArrayObject*) py_V149) != NPY_FLOAT64) {
10572 PyErr_Format(PyExc_TypeError,
10573 "expected type_num %d (NPY_FLOAT64) got %d",
10574 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V149));
10575 {
10576 __failure = 150;
10577 if (!PyErr_Occurred()) {
10578 PyErr_SetString(PyExc_RuntimeError,
10579 "Unexpected error in an Op's C code. "
10580 "No Python exception was set.");
10581 }
10582 goto __label_150;}
10583 }
10584
10585 V149 = (PyArrayObject*)(py_V149);
10586 Py_XINCREF(V149);
10587
10588 {
10589
10590 py_V151 = PyList_GET_ITEM(storage_V151, 0);
10591 {Py_XINCREF(py_V151);}
10592
10593 V151 = NULL;
10594 if (py_V151 == Py_None) {
10595 // We can either fail here or set V151 to NULL and rely on Ops
10596 // using tensors to handle the NULL case, but if they fail to do so
10597 // they'll end up with nasty segfaults, so this is public service.
10598 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
10599 {
10600 __failure = 152;
10601 if (!PyErr_Occurred()) {
10602 PyErr_SetString(PyExc_RuntimeError,
10603 "Unexpected error in an Op's C code. "
10604 "No Python exception was set.");
10605 }
10606 goto __label_152;}
10607 }
10608 if (!PyArray_Check(py_V151)) {
10609 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
10610 {
10611 __failure = 152;
10612 if (!PyErr_Occurred()) {
10613 PyErr_SetString(PyExc_RuntimeError,
10614 "Unexpected error in an Op's C code. "
10615 "No Python exception was set.");
10616 }
10617 goto __label_152;}
10618 }
10619 // We expect NPY_FLOAT64
10620 if (!PyArray_ISALIGNED((PyArrayObject*) py_V151)) {
10621 PyArrayObject * tmp = (PyArrayObject*) py_V151;
10622 PyErr_Format(PyExc_NotImplementedError,
10623 "expected an aligned array of type %ld "
10624 "(NPY_FLOAT64), got non-aligned array of type %ld"
10625 " with %ld dimensions, with 3 last dims "
10626 "%ld, %ld, %ld"
10627 " and 3 last strides %ld %ld, %ld.",
10628 (long int) NPY_FLOAT64,
10629 (long int) PyArray_TYPE((PyArrayObject*) py_V151),
10630 (long int) PyArray_NDIM(tmp),
10631 (long int) (PyArray_NDIM(tmp) >= 3 ?
10632 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
10633 (long int) (PyArray_NDIM(tmp) >= 2 ?
10634 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
10635 (long int) (PyArray_NDIM(tmp) >= 1 ?
10636 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
10637 (long int) (PyArray_NDIM(tmp) >= 3 ?
10638 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
10639 (long int) (PyArray_NDIM(tmp) >= 2 ?
10640 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
10641 (long int) (PyArray_NDIM(tmp) >= 1 ?
10642 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
10643 );
10644 {
10645 __failure = 152;
10646 if (!PyErr_Occurred()) {
10647 PyErr_SetString(PyExc_RuntimeError,
10648 "Unexpected error in an Op's C code. "
10649 "No Python exception was set.");
10650 }
10651 goto __label_152;}
10652 }
10653 // This is a TypeError to be consistent with DEBUG_MODE
10654 // Note: DEBUG_MODE also tells the name of the container
10655 if (PyArray_TYPE((PyArrayObject*) py_V151) != NPY_FLOAT64) {
10656 PyErr_Format(PyExc_TypeError,
10657 "expected type_num %d (NPY_FLOAT64) got %d",
10658 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V151));
10659 {
10660 __failure = 152;
10661 if (!PyErr_Occurred()) {
10662 PyErr_SetString(PyExc_RuntimeError,
10663 "Unexpected error in an Op's C code. "
10664 "No Python exception was set.");
10665 }
10666 goto __label_152;}
10667 }
10668
10669 V151 = (PyArrayObject*)(py_V151);
10670 Py_XINCREF(V151);
10671
10672 {
10673
10674 py_V153 = PyList_GET_ITEM(storage_V153, 0);
10675 {Py_XINCREF(py_V153);}
10676
10677 V153 = NULL;
10678 if (py_V153 == Py_None) {
10679 // We can either fail here or set V153 to NULL and rely on Ops
10680 // using tensors to handle the NULL case, but if they fail to do so
10681 // they'll end up with nasty segfaults, so this is public service.
10682 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
10683 {
10684 __failure = 154;
10685 if (!PyErr_Occurred()) {
10686 PyErr_SetString(PyExc_RuntimeError,
10687 "Unexpected error in an Op's C code. "
10688 "No Python exception was set.");
10689 }
10690 goto __label_154;}
10691 }
10692 if (!PyArray_Check(py_V153)) {
10693 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
10694 {
10695 __failure = 154;
10696 if (!PyErr_Occurred()) {
10697 PyErr_SetString(PyExc_RuntimeError,
10698 "Unexpected error in an Op's C code. "
10699 "No Python exception was set.");
10700 }
10701 goto __label_154;}
10702 }
10703 // We expect NPY_FLOAT64
10704 if (!PyArray_ISALIGNED((PyArrayObject*) py_V153)) {
10705 PyArrayObject * tmp = (PyArrayObject*) py_V153;
10706 PyErr_Format(PyExc_NotImplementedError,
10707 "expected an aligned array of type %ld "
10708 "(NPY_FLOAT64), got non-aligned array of type %ld"
10709 " with %ld dimensions, with 3 last dims "
10710 "%ld, %ld, %ld"
10711 " and 3 last strides %ld %ld, %ld.",
10712 (long int) NPY_FLOAT64,
10713 (long int) PyArray_TYPE((PyArrayObject*) py_V153),
10714 (long int) PyArray_NDIM(tmp),
10715 (long int) (PyArray_NDIM(tmp) >= 3 ?
10716 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
10717 (long int) (PyArray_NDIM(tmp) >= 2 ?
10718 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
10719 (long int) (PyArray_NDIM(tmp) >= 1 ?
10720 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
10721 (long int) (PyArray_NDIM(tmp) >= 3 ?
10722 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
10723 (long int) (PyArray_NDIM(tmp) >= 2 ?
10724 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
10725 (long int) (PyArray_NDIM(tmp) >= 1 ?
10726 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
10727 );
10728 {
10729 __failure = 154;
10730 if (!PyErr_Occurred()) {
10731 PyErr_SetString(PyExc_RuntimeError,
10732 "Unexpected error in an Op's C code. "
10733 "No Python exception was set.");
10734 }
10735 goto __label_154;}
10736 }
10737 // This is a TypeError to be consistent with DEBUG_MODE
10738 // Note: DEBUG_MODE also tells the name of the container
10739 if (PyArray_TYPE((PyArrayObject*) py_V153) != NPY_FLOAT64) {
10740 PyErr_Format(PyExc_TypeError,
10741 "expected type_num %d (NPY_FLOAT64) got %d",
10742 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V153));
10743 {
10744 __failure = 154;
10745 if (!PyErr_Occurred()) {
10746 PyErr_SetString(PyExc_RuntimeError,
10747 "Unexpected error in an Op's C code. "
10748 "No Python exception was set.");
10749 }
10750 goto __label_154;}
10751 }
10752
10753 V153 = (PyArrayObject*)(py_V153);
10754 Py_XINCREF(V153);
10755
10756 {
10757
10758 py_V155 = PyList_GET_ITEM(storage_V155, 0);
10759 {Py_XINCREF(py_V155);}
10760
10761 V155 = NULL;
10762 if (py_V155 == Py_None) {
10763 // We can either fail here or set V155 to NULL and rely on Ops
10764 // using tensors to handle the NULL case, but if they fail to do so
10765 // they'll end up with nasty segfaults, so this is public service.
10766 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
10767 {
10768 __failure = 156;
10769 if (!PyErr_Occurred()) {
10770 PyErr_SetString(PyExc_RuntimeError,
10771 "Unexpected error in an Op's C code. "
10772 "No Python exception was set.");
10773 }
10774 goto __label_156;}
10775 }
10776 if (!PyArray_Check(py_V155)) {
10777 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
10778 {
10779 __failure = 156;
10780 if (!PyErr_Occurred()) {
10781 PyErr_SetString(PyExc_RuntimeError,
10782 "Unexpected error in an Op's C code. "
10783 "No Python exception was set.");
10784 }
10785 goto __label_156;}
10786 }
10787 // We expect NPY_FLOAT64
10788 if (!PyArray_ISALIGNED((PyArrayObject*) py_V155)) {
10789 PyArrayObject * tmp = (PyArrayObject*) py_V155;
10790 PyErr_Format(PyExc_NotImplementedError,
10791 "expected an aligned array of type %ld "
10792 "(NPY_FLOAT64), got non-aligned array of type %ld"
10793 " with %ld dimensions, with 3 last dims "
10794 "%ld, %ld, %ld"
10795 " and 3 last strides %ld %ld, %ld.",
10796 (long int) NPY_FLOAT64,
10797 (long int) PyArray_TYPE((PyArrayObject*) py_V155),
10798 (long int) PyArray_NDIM(tmp),
10799 (long int) (PyArray_NDIM(tmp) >= 3 ?
10800 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
10801 (long int) (PyArray_NDIM(tmp) >= 2 ?
10802 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
10803 (long int) (PyArray_NDIM(tmp) >= 1 ?
10804 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
10805 (long int) (PyArray_NDIM(tmp) >= 3 ?
10806 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
10807 (long int) (PyArray_NDIM(tmp) >= 2 ?
10808 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
10809 (long int) (PyArray_NDIM(tmp) >= 1 ?
10810 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
10811 );
10812 {
10813 __failure = 156;
10814 if (!PyErr_Occurred()) {
10815 PyErr_SetString(PyExc_RuntimeError,
10816 "Unexpected error in an Op's C code. "
10817 "No Python exception was set.");
10818 }
10819 goto __label_156;}
10820 }
10821 // This is a TypeError to be consistent with DEBUG_MODE
10822 // Note: DEBUG_MODE also tells the name of the container
10823 if (PyArray_TYPE((PyArrayObject*) py_V155) != NPY_FLOAT64) {
10824 PyErr_Format(PyExc_TypeError,
10825 "expected type_num %d (NPY_FLOAT64) got %d",
10826 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V155));
10827 {
10828 __failure = 156;
10829 if (!PyErr_Occurred()) {
10830 PyErr_SetString(PyExc_RuntimeError,
10831 "Unexpected error in an Op's C code. "
10832 "No Python exception was set.");
10833 }
10834 goto __label_156;}
10835 }
10836
10837 V155 = (PyArrayObject*)(py_V155);
10838 Py_XINCREF(V155);
10839
10840 {
10841
10842 py_V157 = PyList_GET_ITEM(storage_V157, 0);
10843 {Py_XINCREF(py_V157);}
10844
10845 V157 = NULL;
10846 if (py_V157 == Py_None) {
10847 // We can either fail here or set V157 to NULL and rely on Ops
10848 // using tensors to handle the NULL case, but if they fail to do so
10849 // they'll end up with nasty segfaults, so this is public service.
10850 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
10851 {
10852 __failure = 158;
10853 if (!PyErr_Occurred()) {
10854 PyErr_SetString(PyExc_RuntimeError,
10855 "Unexpected error in an Op's C code. "
10856 "No Python exception was set.");
10857 }
10858 goto __label_158;}
10859 }
10860 if (!PyArray_Check(py_V157)) {
10861 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
10862 {
10863 __failure = 158;
10864 if (!PyErr_Occurred()) {
10865 PyErr_SetString(PyExc_RuntimeError,
10866 "Unexpected error in an Op's C code. "
10867 "No Python exception was set.");
10868 }
10869 goto __label_158;}
10870 }
10871 // We expect NPY_FLOAT64
10872 if (!PyArray_ISALIGNED((PyArrayObject*) py_V157)) {
10873 PyArrayObject * tmp = (PyArrayObject*) py_V157;
10874 PyErr_Format(PyExc_NotImplementedError,
10875 "expected an aligned array of type %ld "
10876 "(NPY_FLOAT64), got non-aligned array of type %ld"
10877 " with %ld dimensions, with 3 last dims "
10878 "%ld, %ld, %ld"
10879 " and 3 last strides %ld %ld, %ld.",
10880 (long int) NPY_FLOAT64,
10881 (long int) PyArray_TYPE((PyArrayObject*) py_V157),
10882 (long int) PyArray_NDIM(tmp),
10883 (long int) (PyArray_NDIM(tmp) >= 3 ?
10884 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
10885 (long int) (PyArray_NDIM(tmp) >= 2 ?
10886 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
10887 (long int) (PyArray_NDIM(tmp) >= 1 ?
10888 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
10889 (long int) (PyArray_NDIM(tmp) >= 3 ?
10890 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
10891 (long int) (PyArray_NDIM(tmp) >= 2 ?
10892 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
10893 (long int) (PyArray_NDIM(tmp) >= 1 ?
10894 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
10895 );
10896 {
10897 __failure = 158;
10898 if (!PyErr_Occurred()) {
10899 PyErr_SetString(PyExc_RuntimeError,
10900 "Unexpected error in an Op's C code. "
10901 "No Python exception was set.");
10902 }
10903 goto __label_158;}
10904 }
10905 // This is a TypeError to be consistent with DEBUG_MODE
10906 // Note: DEBUG_MODE also tells the name of the container
10907 if (PyArray_TYPE((PyArrayObject*) py_V157) != NPY_FLOAT64) {
10908 PyErr_Format(PyExc_TypeError,
10909 "expected type_num %d (NPY_FLOAT64) got %d",
10910 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V157));
10911 {
10912 __failure = 158;
10913 if (!PyErr_Occurred()) {
10914 PyErr_SetString(PyExc_RuntimeError,
10915 "Unexpected error in an Op's C code. "
10916 "No Python exception was set.");
10917 }
10918 goto __label_158;}
10919 }
10920
10921 V157 = (PyArrayObject*)(py_V157);
10922 Py_XINCREF(V157);
10923
10924 {
10925
10926 py_V159 = PyList_GET_ITEM(storage_V159, 0);
10927 {Py_XINCREF(py_V159);}
10928
10929 V159 = NULL;
10930 if (py_V159 == Py_None) {
10931 // We can either fail here or set V159 to NULL and rely on Ops
10932 // using tensors to handle the NULL case, but if they fail to do so
10933 // they'll end up with nasty segfaults, so this is public service.
10934 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
10935 {
10936 __failure = 160;
10937 if (!PyErr_Occurred()) {
10938 PyErr_SetString(PyExc_RuntimeError,
10939 "Unexpected error in an Op's C code. "
10940 "No Python exception was set.");
10941 }
10942 goto __label_160;}
10943 }
10944 if (!PyArray_Check(py_V159)) {
10945 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
10946 {
10947 __failure = 160;
10948 if (!PyErr_Occurred()) {
10949 PyErr_SetString(PyExc_RuntimeError,
10950 "Unexpected error in an Op's C code. "
10951 "No Python exception was set.");
10952 }
10953 goto __label_160;}
10954 }
10955 // We expect NPY_FLOAT64
10956 if (!PyArray_ISALIGNED((PyArrayObject*) py_V159)) {
10957 PyArrayObject * tmp = (PyArrayObject*) py_V159;
10958 PyErr_Format(PyExc_NotImplementedError,
10959 "expected an aligned array of type %ld "
10960 "(NPY_FLOAT64), got non-aligned array of type %ld"
10961 " with %ld dimensions, with 3 last dims "
10962 "%ld, %ld, %ld"
10963 " and 3 last strides %ld %ld, %ld.",
10964 (long int) NPY_FLOAT64,
10965 (long int) PyArray_TYPE((PyArrayObject*) py_V159),
10966 (long int) PyArray_NDIM(tmp),
10967 (long int) (PyArray_NDIM(tmp) >= 3 ?
10968 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
10969 (long int) (PyArray_NDIM(tmp) >= 2 ?
10970 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
10971 (long int) (PyArray_NDIM(tmp) >= 1 ?
10972 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
10973 (long int) (PyArray_NDIM(tmp) >= 3 ?
10974 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
10975 (long int) (PyArray_NDIM(tmp) >= 2 ?
10976 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
10977 (long int) (PyArray_NDIM(tmp) >= 1 ?
10978 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
10979 );
10980 {
10981 __failure = 160;
10982 if (!PyErr_Occurred()) {
10983 PyErr_SetString(PyExc_RuntimeError,
10984 "Unexpected error in an Op's C code. "
10985 "No Python exception was set.");
10986 }
10987 goto __label_160;}
10988 }
10989 // This is a TypeError to be consistent with DEBUG_MODE
10990 // Note: DEBUG_MODE also tells the name of the container
10991 if (PyArray_TYPE((PyArrayObject*) py_V159) != NPY_FLOAT64) {
10992 PyErr_Format(PyExc_TypeError,
10993 "expected type_num %d (NPY_FLOAT64) got %d",
10994 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V159));
10995 {
10996 __failure = 160;
10997 if (!PyErr_Occurred()) {
10998 PyErr_SetString(PyExc_RuntimeError,
10999 "Unexpected error in an Op's C code. "
11000 "No Python exception was set.");
11001 }
11002 goto __label_160;}
11003 }
11004
11005 V159 = (PyArrayObject*)(py_V159);
11006 Py_XINCREF(V159);
11007
11008 {
11009
11010 py_V161 = PyList_GET_ITEM(storage_V161, 0);
11011 {Py_XINCREF(py_V161);}
11012
11013 V161 = NULL;
11014 if (py_V161 == Py_None) {
11015 // We can either fail here or set V161 to NULL and rely on Ops
11016 // using tensors to handle the NULL case, but if they fail to do so
11017 // they'll end up with nasty segfaults, so this is public service.
11018 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
11019 {
11020 __failure = 162;
11021 if (!PyErr_Occurred()) {
11022 PyErr_SetString(PyExc_RuntimeError,
11023 "Unexpected error in an Op's C code. "
11024 "No Python exception was set.");
11025 }
11026 goto __label_162;}
11027 }
11028 if (!PyArray_Check(py_V161)) {
11029 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
11030 {
11031 __failure = 162;
11032 if (!PyErr_Occurred()) {
11033 PyErr_SetString(PyExc_RuntimeError,
11034 "Unexpected error in an Op's C code. "
11035 "No Python exception was set.");
11036 }
11037 goto __label_162;}
11038 }
11039 // We expect NPY_FLOAT64
11040 if (!PyArray_ISALIGNED((PyArrayObject*) py_V161)) {
11041 PyArrayObject * tmp = (PyArrayObject*) py_V161;
11042 PyErr_Format(PyExc_NotImplementedError,
11043 "expected an aligned array of type %ld "
11044 "(NPY_FLOAT64), got non-aligned array of type %ld"
11045 " with %ld dimensions, with 3 last dims "
11046 "%ld, %ld, %ld"
11047 " and 3 last strides %ld %ld, %ld.",
11048 (long int) NPY_FLOAT64,
11049 (long int) PyArray_TYPE((PyArrayObject*) py_V161),
11050 (long int) PyArray_NDIM(tmp),
11051 (long int) (PyArray_NDIM(tmp) >= 3 ?
11052 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
11053 (long int) (PyArray_NDIM(tmp) >= 2 ?
11054 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
11055 (long int) (PyArray_NDIM(tmp) >= 1 ?
11056 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
11057 (long int) (PyArray_NDIM(tmp) >= 3 ?
11058 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
11059 (long int) (PyArray_NDIM(tmp) >= 2 ?
11060 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
11061 (long int) (PyArray_NDIM(tmp) >= 1 ?
11062 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
11063 );
11064 {
11065 __failure = 162;
11066 if (!PyErr_Occurred()) {
11067 PyErr_SetString(PyExc_RuntimeError,
11068 "Unexpected error in an Op's C code. "
11069 "No Python exception was set.");
11070 }
11071 goto __label_162;}
11072 }
11073 // This is a TypeError to be consistent with DEBUG_MODE
11074 // Note: DEBUG_MODE also tells the name of the container
11075 if (PyArray_TYPE((PyArrayObject*) py_V161) != NPY_FLOAT64) {
11076 PyErr_Format(PyExc_TypeError,
11077 "expected type_num %d (NPY_FLOAT64) got %d",
11078 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V161));
11079 {
11080 __failure = 162;
11081 if (!PyErr_Occurred()) {
11082 PyErr_SetString(PyExc_RuntimeError,
11083 "Unexpected error in an Op's C code. "
11084 "No Python exception was set.");
11085 }
11086 goto __label_162;}
11087 }
11088
11089 V161 = (PyArrayObject*)(py_V161);
11090 Py_XINCREF(V161);
11091
11092 {
11093
11094 py_V163 = PyList_GET_ITEM(storage_V163, 0);
11095 {Py_XINCREF(py_V163);}
11096
11097 V163 = NULL;
11098 if (py_V163 == Py_None) {
11099 // We can either fail here or set V163 to NULL and rely on Ops
11100 // using tensors to handle the NULL case, but if they fail to do so
11101 // they'll end up with nasty segfaults, so this is public service.
11102 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
11103 {
11104 __failure = 164;
11105 if (!PyErr_Occurred()) {
11106 PyErr_SetString(PyExc_RuntimeError,
11107 "Unexpected error in an Op's C code. "
11108 "No Python exception was set.");
11109 }
11110 goto __label_164;}
11111 }
11112 if (!PyArray_Check(py_V163)) {
11113 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
11114 {
11115 __failure = 164;
11116 if (!PyErr_Occurred()) {
11117 PyErr_SetString(PyExc_RuntimeError,
11118 "Unexpected error in an Op's C code. "
11119 "No Python exception was set.");
11120 }
11121 goto __label_164;}
11122 }
11123 // We expect NPY_FLOAT64
11124 if (!PyArray_ISALIGNED((PyArrayObject*) py_V163)) {
11125 PyArrayObject * tmp = (PyArrayObject*) py_V163;
11126 PyErr_Format(PyExc_NotImplementedError,
11127 "expected an aligned array of type %ld "
11128 "(NPY_FLOAT64), got non-aligned array of type %ld"
11129 " with %ld dimensions, with 3 last dims "
11130 "%ld, %ld, %ld"
11131 " and 3 last strides %ld %ld, %ld.",
11132 (long int) NPY_FLOAT64,
11133 (long int) PyArray_TYPE((PyArrayObject*) py_V163),
11134 (long int) PyArray_NDIM(tmp),
11135 (long int) (PyArray_NDIM(tmp) >= 3 ?
11136 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
11137 (long int) (PyArray_NDIM(tmp) >= 2 ?
11138 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
11139 (long int) (PyArray_NDIM(tmp) >= 1 ?
11140 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
11141 (long int) (PyArray_NDIM(tmp) >= 3 ?
11142 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
11143 (long int) (PyArray_NDIM(tmp) >= 2 ?
11144 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
11145 (long int) (PyArray_NDIM(tmp) >= 1 ?
11146 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
11147 );
11148 {
11149 __failure = 164;
11150 if (!PyErr_Occurred()) {
11151 PyErr_SetString(PyExc_RuntimeError,
11152 "Unexpected error in an Op's C code. "
11153 "No Python exception was set.");
11154 }
11155 goto __label_164;}
11156 }
11157 // This is a TypeError to be consistent with DEBUG_MODE
11158 // Note: DEBUG_MODE also tells the name of the container
11159 if (PyArray_TYPE((PyArrayObject*) py_V163) != NPY_FLOAT64) {
11160 PyErr_Format(PyExc_TypeError,
11161 "expected type_num %d (NPY_FLOAT64) got %d",
11162 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V163));
11163 {
11164 __failure = 164;
11165 if (!PyErr_Occurred()) {
11166 PyErr_SetString(PyExc_RuntimeError,
11167 "Unexpected error in an Op's C code. "
11168 "No Python exception was set.");
11169 }
11170 goto __label_164;}
11171 }
11172
11173 V163 = (PyArrayObject*)(py_V163);
11174 Py_XINCREF(V163);
11175
11176 {
11177
11178 py_V165 = PyList_GET_ITEM(storage_V165, 0);
11179 {Py_XINCREF(py_V165);}
11180
11181 V165 = NULL;
11182 if (py_V165 == Py_None) {
11183 // We can either fail here or set V165 to NULL and rely on Ops
11184 // using tensors to handle the NULL case, but if they fail to do so
11185 // they'll end up with nasty segfaults, so this is public service.
11186 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
11187 {
11188 __failure = 166;
11189 if (!PyErr_Occurred()) {
11190 PyErr_SetString(PyExc_RuntimeError,
11191 "Unexpected error in an Op's C code. "
11192 "No Python exception was set.");
11193 }
11194 goto __label_166;}
11195 }
11196 if (!PyArray_Check(py_V165)) {
11197 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
11198 {
11199 __failure = 166;
11200 if (!PyErr_Occurred()) {
11201 PyErr_SetString(PyExc_RuntimeError,
11202 "Unexpected error in an Op's C code. "
11203 "No Python exception was set.");
11204 }
11205 goto __label_166;}
11206 }
11207 // We expect NPY_FLOAT64
11208 if (!PyArray_ISALIGNED((PyArrayObject*) py_V165)) {
11209 PyArrayObject * tmp = (PyArrayObject*) py_V165;
11210 PyErr_Format(PyExc_NotImplementedError,
11211 "expected an aligned array of type %ld "
11212 "(NPY_FLOAT64), got non-aligned array of type %ld"
11213 " with %ld dimensions, with 3 last dims "
11214 "%ld, %ld, %ld"
11215 " and 3 last strides %ld %ld, %ld.",
11216 (long int) NPY_FLOAT64,
11217 (long int) PyArray_TYPE((PyArrayObject*) py_V165),
11218 (long int) PyArray_NDIM(tmp),
11219 (long int) (PyArray_NDIM(tmp) >= 3 ?
11220 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
11221 (long int) (PyArray_NDIM(tmp) >= 2 ?
11222 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
11223 (long int) (PyArray_NDIM(tmp) >= 1 ?
11224 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
11225 (long int) (PyArray_NDIM(tmp) >= 3 ?
11226 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
11227 (long int) (PyArray_NDIM(tmp) >= 2 ?
11228 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
11229 (long int) (PyArray_NDIM(tmp) >= 1 ?
11230 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
11231 );
11232 {
11233 __failure = 166;
11234 if (!PyErr_Occurred()) {
11235 PyErr_SetString(PyExc_RuntimeError,
11236 "Unexpected error in an Op's C code. "
11237 "No Python exception was set.");
11238 }
11239 goto __label_166;}
11240 }
11241 // This is a TypeError to be consistent with DEBUG_MODE
11242 // Note: DEBUG_MODE also tells the name of the container
11243 if (PyArray_TYPE((PyArrayObject*) py_V165) != NPY_FLOAT64) {
11244 PyErr_Format(PyExc_TypeError,
11245 "expected type_num %d (NPY_FLOAT64) got %d",
11246 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V165));
11247 {
11248 __failure = 166;
11249 if (!PyErr_Occurred()) {
11250 PyErr_SetString(PyExc_RuntimeError,
11251 "Unexpected error in an Op's C code. "
11252 "No Python exception was set.");
11253 }
11254 goto __label_166;}
11255 }
11256
11257 V165 = (PyArrayObject*)(py_V165);
11258 Py_XINCREF(V165);
11259
11260 {
11261
11262 py_V167 = PyList_GET_ITEM(storage_V167, 0);
11263 {Py_XINCREF(py_V167);}
11264
11265 V167 = NULL;
11266 if (py_V167 == Py_None) {
11267 // We can either fail here or set V167 to NULL and rely on Ops
11268 // using tensors to handle the NULL case, but if they fail to do so
11269 // they'll end up with nasty segfaults, so this is public service.
11270 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
11271 {
11272 __failure = 168;
11273 if (!PyErr_Occurred()) {
11274 PyErr_SetString(PyExc_RuntimeError,
11275 "Unexpected error in an Op's C code. "
11276 "No Python exception was set.");
11277 }
11278 goto __label_168;}
11279 }
11280 if (!PyArray_Check(py_V167)) {
11281 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
11282 {
11283 __failure = 168;
11284 if (!PyErr_Occurred()) {
11285 PyErr_SetString(PyExc_RuntimeError,
11286 "Unexpected error in an Op's C code. "
11287 "No Python exception was set.");
11288 }
11289 goto __label_168;}
11290 }
11291 // We expect NPY_FLOAT64
11292 if (!PyArray_ISALIGNED((PyArrayObject*) py_V167)) {
11293 PyArrayObject * tmp = (PyArrayObject*) py_V167;
11294 PyErr_Format(PyExc_NotImplementedError,
11295 "expected an aligned array of type %ld "
11296 "(NPY_FLOAT64), got non-aligned array of type %ld"
11297 " with %ld dimensions, with 3 last dims "
11298 "%ld, %ld, %ld"
11299 " and 3 last strides %ld %ld, %ld.",
11300 (long int) NPY_FLOAT64,
11301 (long int) PyArray_TYPE((PyArrayObject*) py_V167),
11302 (long int) PyArray_NDIM(tmp),
11303 (long int) (PyArray_NDIM(tmp) >= 3 ?
11304 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
11305 (long int) (PyArray_NDIM(tmp) >= 2 ?
11306 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
11307 (long int) (PyArray_NDIM(tmp) >= 1 ?
11308 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
11309 (long int) (PyArray_NDIM(tmp) >= 3 ?
11310 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
11311 (long int) (PyArray_NDIM(tmp) >= 2 ?
11312 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
11313 (long int) (PyArray_NDIM(tmp) >= 1 ?
11314 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
11315 );
11316 {
11317 __failure = 168;
11318 if (!PyErr_Occurred()) {
11319 PyErr_SetString(PyExc_RuntimeError,
11320 "Unexpected error in an Op's C code. "
11321 "No Python exception was set.");
11322 }
11323 goto __label_168;}
11324 }
11325 // This is a TypeError to be consistent with DEBUG_MODE
11326 // Note: DEBUG_MODE also tells the name of the container
11327 if (PyArray_TYPE((PyArrayObject*) py_V167) != NPY_FLOAT64) {
11328 PyErr_Format(PyExc_TypeError,
11329 "expected type_num %d (NPY_FLOAT64) got %d",
11330 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V167));
11331 {
11332 __failure = 168;
11333 if (!PyErr_Occurred()) {
11334 PyErr_SetString(PyExc_RuntimeError,
11335 "Unexpected error in an Op's C code. "
11336 "No Python exception was set.");
11337 }
11338 goto __label_168;}
11339 }
11340
11341 V167 = (PyArrayObject*)(py_V167);
11342 Py_XINCREF(V167);
11343
11344 {
11345
11346 py_V169 = PyList_GET_ITEM(storage_V169, 0);
11347 {Py_XINCREF(py_V169);}
11348
11349 V169 = NULL;
11350 if (py_V169 == Py_None) {
11351 // We can either fail here or set V169 to NULL and rely on Ops
11352 // using tensors to handle the NULL case, but if they fail to do so
11353 // they'll end up with nasty segfaults, so this is public service.
11354 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
11355 {
11356 __failure = 170;
11357 if (!PyErr_Occurred()) {
11358 PyErr_SetString(PyExc_RuntimeError,
11359 "Unexpected error in an Op's C code. "
11360 "No Python exception was set.");
11361 }
11362 goto __label_170;}
11363 }
11364 if (!PyArray_Check(py_V169)) {
11365 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
11366 {
11367 __failure = 170;
11368 if (!PyErr_Occurred()) {
11369 PyErr_SetString(PyExc_RuntimeError,
11370 "Unexpected error in an Op's C code. "
11371 "No Python exception was set.");
11372 }
11373 goto __label_170;}
11374 }
11375 // We expect NPY_FLOAT64
11376 if (!PyArray_ISALIGNED((PyArrayObject*) py_V169)) {
11377 PyArrayObject * tmp = (PyArrayObject*) py_V169;
11378 PyErr_Format(PyExc_NotImplementedError,
11379 "expected an aligned array of type %ld "
11380 "(NPY_FLOAT64), got non-aligned array of type %ld"
11381 " with %ld dimensions, with 3 last dims "
11382 "%ld, %ld, %ld"
11383 " and 3 last strides %ld %ld, %ld.",
11384 (long int) NPY_FLOAT64,
11385 (long int) PyArray_TYPE((PyArrayObject*) py_V169),
11386 (long int) PyArray_NDIM(tmp),
11387 (long int) (PyArray_NDIM(tmp) >= 3 ?
11388 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
11389 (long int) (PyArray_NDIM(tmp) >= 2 ?
11390 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
11391 (long int) (PyArray_NDIM(tmp) >= 1 ?
11392 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
11393 (long int) (PyArray_NDIM(tmp) >= 3 ?
11394 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
11395 (long int) (PyArray_NDIM(tmp) >= 2 ?
11396 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
11397 (long int) (PyArray_NDIM(tmp) >= 1 ?
11398 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
11399 );
11400 {
11401 __failure = 170;
11402 if (!PyErr_Occurred()) {
11403 PyErr_SetString(PyExc_RuntimeError,
11404 "Unexpected error in an Op's C code. "
11405 "No Python exception was set.");
11406 }
11407 goto __label_170;}
11408 }
11409 // This is a TypeError to be consistent with DEBUG_MODE
11410 // Note: DEBUG_MODE also tells the name of the container
11411 if (PyArray_TYPE((PyArrayObject*) py_V169) != NPY_FLOAT64) {
11412 PyErr_Format(PyExc_TypeError,
11413 "expected type_num %d (NPY_FLOAT64) got %d",
11414 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V169));
11415 {
11416 __failure = 170;
11417 if (!PyErr_Occurred()) {
11418 PyErr_SetString(PyExc_RuntimeError,
11419 "Unexpected error in an Op's C code. "
11420 "No Python exception was set.");
11421 }
11422 goto __label_170;}
11423 }
11424
11425 V169 = (PyArrayObject*)(py_V169);
11426 Py_XINCREF(V169);
11427
11428 {
11429
11430 py_V171 = PyList_GET_ITEM(storage_V171, 0);
11431 {Py_XINCREF(py_V171);}
11432
11433 V171 = NULL;
11434 if (py_V171 == Py_None) {
11435 // We can either fail here or set V171 to NULL and rely on Ops
11436 // using tensors to handle the NULL case, but if they fail to do so
11437 // they'll end up with nasty segfaults, so this is public service.
11438 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
11439 {
11440 __failure = 172;
11441 if (!PyErr_Occurred()) {
11442 PyErr_SetString(PyExc_RuntimeError,
11443 "Unexpected error in an Op's C code. "
11444 "No Python exception was set.");
11445 }
11446 goto __label_172;}
11447 }
11448 if (!PyArray_Check(py_V171)) {
11449 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
11450 {
11451 __failure = 172;
11452 if (!PyErr_Occurred()) {
11453 PyErr_SetString(PyExc_RuntimeError,
11454 "Unexpected error in an Op's C code. "
11455 "No Python exception was set.");
11456 }
11457 goto __label_172;}
11458 }
11459 // We expect NPY_FLOAT64
11460 if (!PyArray_ISALIGNED((PyArrayObject*) py_V171)) {
11461 PyArrayObject * tmp = (PyArrayObject*) py_V171;
11462 PyErr_Format(PyExc_NotImplementedError,
11463 "expected an aligned array of type %ld "
11464 "(NPY_FLOAT64), got non-aligned array of type %ld"
11465 " with %ld dimensions, with 3 last dims "
11466 "%ld, %ld, %ld"
11467 " and 3 last strides %ld %ld, %ld.",
11468 (long int) NPY_FLOAT64,
11469 (long int) PyArray_TYPE((PyArrayObject*) py_V171),
11470 (long int) PyArray_NDIM(tmp),
11471 (long int) (PyArray_NDIM(tmp) >= 3 ?
11472 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
11473 (long int) (PyArray_NDIM(tmp) >= 2 ?
11474 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
11475 (long int) (PyArray_NDIM(tmp) >= 1 ?
11476 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
11477 (long int) (PyArray_NDIM(tmp) >= 3 ?
11478 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
11479 (long int) (PyArray_NDIM(tmp) >= 2 ?
11480 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
11481 (long int) (PyArray_NDIM(tmp) >= 1 ?
11482 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
11483 );
11484 {
11485 __failure = 172;
11486 if (!PyErr_Occurred()) {
11487 PyErr_SetString(PyExc_RuntimeError,
11488 "Unexpected error in an Op's C code. "
11489 "No Python exception was set.");
11490 }
11491 goto __label_172;}
11492 }
11493 // This is a TypeError to be consistent with DEBUG_MODE
11494 // Note: DEBUG_MODE also tells the name of the container
11495 if (PyArray_TYPE((PyArrayObject*) py_V171) != NPY_FLOAT64) {
11496 PyErr_Format(PyExc_TypeError,
11497 "expected type_num %d (NPY_FLOAT64) got %d",
11498 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V171));
11499 {
11500 __failure = 172;
11501 if (!PyErr_Occurred()) {
11502 PyErr_SetString(PyExc_RuntimeError,
11503 "Unexpected error in an Op's C code. "
11504 "No Python exception was set.");
11505 }
11506 goto __label_172;}
11507 }
11508
11509 V171 = (PyArrayObject*)(py_V171);
11510 Py_XINCREF(V171);
11511
11512 {
11513
11514 py_V173 = PyList_GET_ITEM(storage_V173, 0);
11515 {Py_XINCREF(py_V173);}
11516
11517 V173 = NULL;
11518 if (py_V173 == Py_None) {
11519 // We can either fail here or set V173 to NULL and rely on Ops
11520 // using tensors to handle the NULL case, but if they fail to do so
11521 // they'll end up with nasty segfaults, so this is public service.
11522 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
11523 {
11524 __failure = 174;
11525 if (!PyErr_Occurred()) {
11526 PyErr_SetString(PyExc_RuntimeError,
11527 "Unexpected error in an Op's C code. "
11528 "No Python exception was set.");
11529 }
11530 goto __label_174;}
11531 }
11532 if (!PyArray_Check(py_V173)) {
11533 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
11534 {
11535 __failure = 174;
11536 if (!PyErr_Occurred()) {
11537 PyErr_SetString(PyExc_RuntimeError,
11538 "Unexpected error in an Op's C code. "
11539 "No Python exception was set.");
11540 }
11541 goto __label_174;}
11542 }
11543 // We expect NPY_FLOAT64
11544 if (!PyArray_ISALIGNED((PyArrayObject*) py_V173)) {
11545 PyArrayObject * tmp = (PyArrayObject*) py_V173;
11546 PyErr_Format(PyExc_NotImplementedError,
11547 "expected an aligned array of type %ld "
11548 "(NPY_FLOAT64), got non-aligned array of type %ld"
11549 " with %ld dimensions, with 3 last dims "
11550 "%ld, %ld, %ld"
11551 " and 3 last strides %ld %ld, %ld.",
11552 (long int) NPY_FLOAT64,
11553 (long int) PyArray_TYPE((PyArrayObject*) py_V173),
11554 (long int) PyArray_NDIM(tmp),
11555 (long int) (PyArray_NDIM(tmp) >= 3 ?
11556 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
11557 (long int) (PyArray_NDIM(tmp) >= 2 ?
11558 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
11559 (long int) (PyArray_NDIM(tmp) >= 1 ?
11560 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
11561 (long int) (PyArray_NDIM(tmp) >= 3 ?
11562 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
11563 (long int) (PyArray_NDIM(tmp) >= 2 ?
11564 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
11565 (long int) (PyArray_NDIM(tmp) >= 1 ?
11566 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
11567 );
11568 {
11569 __failure = 174;
11570 if (!PyErr_Occurred()) {
11571 PyErr_SetString(PyExc_RuntimeError,
11572 "Unexpected error in an Op's C code. "
11573 "No Python exception was set.");
11574 }
11575 goto __label_174;}
11576 }
11577 // This is a TypeError to be consistent with DEBUG_MODE
11578 // Note: DEBUG_MODE also tells the name of the container
11579 if (PyArray_TYPE((PyArrayObject*) py_V173) != NPY_FLOAT64) {
11580 PyErr_Format(PyExc_TypeError,
11581 "expected type_num %d (NPY_FLOAT64) got %d",
11582 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V173));
11583 {
11584 __failure = 174;
11585 if (!PyErr_Occurred()) {
11586 PyErr_SetString(PyExc_RuntimeError,
11587 "Unexpected error in an Op's C code. "
11588 "No Python exception was set.");
11589 }
11590 goto __label_174;}
11591 }
11592
11593 V173 = (PyArrayObject*)(py_V173);
11594 Py_XINCREF(V173);
11595
11596 {
11597
11598 py_V175 = PyList_GET_ITEM(storage_V175, 0);
11599 {Py_XINCREF(py_V175);}
11600
11601 V175 = NULL;
11602 if (py_V175 == Py_None) {
11603 // We can either fail here or set V175 to NULL and rely on Ops
11604 // using tensors to handle the NULL case, but if they fail to do so
11605 // they'll end up with nasty segfaults, so this is public service.
11606 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
11607 {
11608 __failure = 176;
11609 if (!PyErr_Occurred()) {
11610 PyErr_SetString(PyExc_RuntimeError,
11611 "Unexpected error in an Op's C code. "
11612 "No Python exception was set.");
11613 }
11614 goto __label_176;}
11615 }
11616 if (!PyArray_Check(py_V175)) {
11617 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
11618 {
11619 __failure = 176;
11620 if (!PyErr_Occurred()) {
11621 PyErr_SetString(PyExc_RuntimeError,
11622 "Unexpected error in an Op's C code. "
11623 "No Python exception was set.");
11624 }
11625 goto __label_176;}
11626 }
11627 // We expect NPY_FLOAT64
11628 if (!PyArray_ISALIGNED((PyArrayObject*) py_V175)) {
11629 PyArrayObject * tmp = (PyArrayObject*) py_V175;
11630 PyErr_Format(PyExc_NotImplementedError,
11631 "expected an aligned array of type %ld "
11632 "(NPY_FLOAT64), got non-aligned array of type %ld"
11633 " with %ld dimensions, with 3 last dims "
11634 "%ld, %ld, %ld"
11635 " and 3 last strides %ld %ld, %ld.",
11636 (long int) NPY_FLOAT64,
11637 (long int) PyArray_TYPE((PyArrayObject*) py_V175),
11638 (long int) PyArray_NDIM(tmp),
11639 (long int) (PyArray_NDIM(tmp) >= 3 ?
11640 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
11641 (long int) (PyArray_NDIM(tmp) >= 2 ?
11642 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
11643 (long int) (PyArray_NDIM(tmp) >= 1 ?
11644 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
11645 (long int) (PyArray_NDIM(tmp) >= 3 ?
11646 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
11647 (long int) (PyArray_NDIM(tmp) >= 2 ?
11648 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
11649 (long int) (PyArray_NDIM(tmp) >= 1 ?
11650 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
11651 );
11652 {
11653 __failure = 176;
11654 if (!PyErr_Occurred()) {
11655 PyErr_SetString(PyExc_RuntimeError,
11656 "Unexpected error in an Op's C code. "
11657 "No Python exception was set.");
11658 }
11659 goto __label_176;}
11660 }
11661 // This is a TypeError to be consistent with DEBUG_MODE
11662 // Note: DEBUG_MODE also tells the name of the container
11663 if (PyArray_TYPE((PyArrayObject*) py_V175) != NPY_FLOAT64) {
11664 PyErr_Format(PyExc_TypeError,
11665 "expected type_num %d (NPY_FLOAT64) got %d",
11666 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V175));
11667 {
11668 __failure = 176;
11669 if (!PyErr_Occurred()) {
11670 PyErr_SetString(PyExc_RuntimeError,
11671 "Unexpected error in an Op's C code. "
11672 "No Python exception was set.");
11673 }
11674 goto __label_176;}
11675 }
11676
11677 V175 = (PyArrayObject*)(py_V175);
11678 Py_XINCREF(V175);
11679
11680 {
11681
11682 py_V177 = PyList_GET_ITEM(storage_V177, 0);
11683 {Py_XINCREF(py_V177);}
11684
11685 V177 = NULL;
11686 if (py_V177 == Py_None) {
11687 // We can either fail here or set V177 to NULL and rely on Ops
11688 // using tensors to handle the NULL case, but if they fail to do so
11689 // they'll end up with nasty segfaults, so this is public service.
11690 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
11691 {
11692 __failure = 178;
11693 if (!PyErr_Occurred()) {
11694 PyErr_SetString(PyExc_RuntimeError,
11695 "Unexpected error in an Op's C code. "
11696 "No Python exception was set.");
11697 }
11698 goto __label_178;}
11699 }
11700 if (!PyArray_Check(py_V177)) {
11701 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
11702 {
11703 __failure = 178;
11704 if (!PyErr_Occurred()) {
11705 PyErr_SetString(PyExc_RuntimeError,
11706 "Unexpected error in an Op's C code. "
11707 "No Python exception was set.");
11708 }
11709 goto __label_178;}
11710 }
11711 // We expect NPY_FLOAT64
11712 if (!PyArray_ISALIGNED((PyArrayObject*) py_V177)) {
11713 PyArrayObject * tmp = (PyArrayObject*) py_V177;
11714 PyErr_Format(PyExc_NotImplementedError,
11715 "expected an aligned array of type %ld "
11716 "(NPY_FLOAT64), got non-aligned array of type %ld"
11717 " with %ld dimensions, with 3 last dims "
11718 "%ld, %ld, %ld"
11719 " and 3 last strides %ld %ld, %ld.",
11720 (long int) NPY_FLOAT64,
11721 (long int) PyArray_TYPE((PyArrayObject*) py_V177),
11722 (long int) PyArray_NDIM(tmp),
11723 (long int) (PyArray_NDIM(tmp) >= 3 ?
11724 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
11725 (long int) (PyArray_NDIM(tmp) >= 2 ?
11726 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
11727 (long int) (PyArray_NDIM(tmp) >= 1 ?
11728 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
11729 (long int) (PyArray_NDIM(tmp) >= 3 ?
11730 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
11731 (long int) (PyArray_NDIM(tmp) >= 2 ?
11732 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
11733 (long int) (PyArray_NDIM(tmp) >= 1 ?
11734 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
11735 );
11736 {
11737 __failure = 178;
11738 if (!PyErr_Occurred()) {
11739 PyErr_SetString(PyExc_RuntimeError,
11740 "Unexpected error in an Op's C code. "
11741 "No Python exception was set.");
11742 }
11743 goto __label_178;}
11744 }
11745 // This is a TypeError to be consistent with DEBUG_MODE
11746 // Note: DEBUG_MODE also tells the name of the container
11747 if (PyArray_TYPE((PyArrayObject*) py_V177) != NPY_FLOAT64) {
11748 PyErr_Format(PyExc_TypeError,
11749 "expected type_num %d (NPY_FLOAT64) got %d",
11750 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V177));
11751 {
11752 __failure = 178;
11753 if (!PyErr_Occurred()) {
11754 PyErr_SetString(PyExc_RuntimeError,
11755 "Unexpected error in an Op's C code. "
11756 "No Python exception was set.");
11757 }
11758 goto __label_178;}
11759 }
11760
11761 V177 = (PyArrayObject*)(py_V177);
11762 Py_XINCREF(V177);
11763
11764 {
11765
11766 py_V179 = PyList_GET_ITEM(storage_V179, 0);
11767 {Py_XINCREF(py_V179);}
11768
11769 V179 = NULL;
11770 if (py_V179 == Py_None) {
11771 // We can either fail here or set V179 to NULL and rely on Ops
11772 // using tensors to handle the NULL case, but if they fail to do so
11773 // they'll end up with nasty segfaults, so this is public service.
11774 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
11775 {
11776 __failure = 180;
11777 if (!PyErr_Occurred()) {
11778 PyErr_SetString(PyExc_RuntimeError,
11779 "Unexpected error in an Op's C code. "
11780 "No Python exception was set.");
11781 }
11782 goto __label_180;}
11783 }
11784 if (!PyArray_Check(py_V179)) {
11785 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
11786 {
11787 __failure = 180;
11788 if (!PyErr_Occurred()) {
11789 PyErr_SetString(PyExc_RuntimeError,
11790 "Unexpected error in an Op's C code. "
11791 "No Python exception was set.");
11792 }
11793 goto __label_180;}
11794 }
11795 // We expect NPY_FLOAT64
11796 if (!PyArray_ISALIGNED((PyArrayObject*) py_V179)) {
11797 PyArrayObject * tmp = (PyArrayObject*) py_V179;
11798 PyErr_Format(PyExc_NotImplementedError,
11799 "expected an aligned array of type %ld "
11800 "(NPY_FLOAT64), got non-aligned array of type %ld"
11801 " with %ld dimensions, with 3 last dims "
11802 "%ld, %ld, %ld"
11803 " and 3 last strides %ld %ld, %ld.",
11804 (long int) NPY_FLOAT64,
11805 (long int) PyArray_TYPE((PyArrayObject*) py_V179),
11806 (long int) PyArray_NDIM(tmp),
11807 (long int) (PyArray_NDIM(tmp) >= 3 ?
11808 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
11809 (long int) (PyArray_NDIM(tmp) >= 2 ?
11810 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
11811 (long int) (PyArray_NDIM(tmp) >= 1 ?
11812 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
11813 (long int) (PyArray_NDIM(tmp) >= 3 ?
11814 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
11815 (long int) (PyArray_NDIM(tmp) >= 2 ?
11816 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
11817 (long int) (PyArray_NDIM(tmp) >= 1 ?
11818 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
11819 );
11820 {
11821 __failure = 180;
11822 if (!PyErr_Occurred()) {
11823 PyErr_SetString(PyExc_RuntimeError,
11824 "Unexpected error in an Op's C code. "
11825 "No Python exception was set.");
11826 }
11827 goto __label_180;}
11828 }
11829 // This is a TypeError to be consistent with DEBUG_MODE
11830 // Note: DEBUG_MODE also tells the name of the container
11831 if (PyArray_TYPE((PyArrayObject*) py_V179) != NPY_FLOAT64) {
11832 PyErr_Format(PyExc_TypeError,
11833 "expected type_num %d (NPY_FLOAT64) got %d",
11834 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V179));
11835 {
11836 __failure = 180;
11837 if (!PyErr_Occurred()) {
11838 PyErr_SetString(PyExc_RuntimeError,
11839 "Unexpected error in an Op's C code. "
11840 "No Python exception was set.");
11841 }
11842 goto __label_180;}
11843 }
11844
11845 V179 = (PyArrayObject*)(py_V179);
11846 Py_XINCREF(V179);
11847
11848 {
11849
11850 py_V181 = PyList_GET_ITEM(storage_V181, 0);
11851 {Py_XINCREF(py_V181);}
11852
11853 V181 = NULL;
11854 if (py_V181 == Py_None) {
11855 // We can either fail here or set V181 to NULL and rely on Ops
11856 // using tensors to handle the NULL case, but if they fail to do so
11857 // they'll end up with nasty segfaults, so this is public service.
11858 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
11859 {
11860 __failure = 182;
11861 if (!PyErr_Occurred()) {
11862 PyErr_SetString(PyExc_RuntimeError,
11863 "Unexpected error in an Op's C code. "
11864 "No Python exception was set.");
11865 }
11866 goto __label_182;}
11867 }
11868 if (!PyArray_Check(py_V181)) {
11869 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
11870 {
11871 __failure = 182;
11872 if (!PyErr_Occurred()) {
11873 PyErr_SetString(PyExc_RuntimeError,
11874 "Unexpected error in an Op's C code. "
11875 "No Python exception was set.");
11876 }
11877 goto __label_182;}
11878 }
11879 // We expect NPY_FLOAT64
11880 if (!PyArray_ISALIGNED((PyArrayObject*) py_V181)) {
11881 PyArrayObject * tmp = (PyArrayObject*) py_V181;
11882 PyErr_Format(PyExc_NotImplementedError,
11883 "expected an aligned array of type %ld "
11884 "(NPY_FLOAT64), got non-aligned array of type %ld"
11885 " with %ld dimensions, with 3 last dims "
11886 "%ld, %ld, %ld"
11887 " and 3 last strides %ld %ld, %ld.",
11888 (long int) NPY_FLOAT64,
11889 (long int) PyArray_TYPE((PyArrayObject*) py_V181),
11890 (long int) PyArray_NDIM(tmp),
11891 (long int) (PyArray_NDIM(tmp) >= 3 ?
11892 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
11893 (long int) (PyArray_NDIM(tmp) >= 2 ?
11894 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
11895 (long int) (PyArray_NDIM(tmp) >= 1 ?
11896 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
11897 (long int) (PyArray_NDIM(tmp) >= 3 ?
11898 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
11899 (long int) (PyArray_NDIM(tmp) >= 2 ?
11900 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
11901 (long int) (PyArray_NDIM(tmp) >= 1 ?
11902 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
11903 );
11904 {
11905 __failure = 182;
11906 if (!PyErr_Occurred()) {
11907 PyErr_SetString(PyExc_RuntimeError,
11908 "Unexpected error in an Op's C code. "
11909 "No Python exception was set.");
11910 }
11911 goto __label_182;}
11912 }
11913 // This is a TypeError to be consistent with DEBUG_MODE
11914 // Note: DEBUG_MODE also tells the name of the container
11915 if (PyArray_TYPE((PyArrayObject*) py_V181) != NPY_FLOAT64) {
11916 PyErr_Format(PyExc_TypeError,
11917 "expected type_num %d (NPY_FLOAT64) got %d",
11918 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V181));
11919 {
11920 __failure = 182;
11921 if (!PyErr_Occurred()) {
11922 PyErr_SetString(PyExc_RuntimeError,
11923 "Unexpected error in an Op's C code. "
11924 "No Python exception was set.");
11925 }
11926 goto __label_182;}
11927 }
11928
11929 V181 = (PyArrayObject*)(py_V181);
11930 Py_XINCREF(V181);
11931
11932 {
11933
11934 py_V183 = PyList_GET_ITEM(storage_V183, 0);
11935 {Py_XINCREF(py_V183);}
11936
11937 V183 = NULL;
11938 if (py_V183 == Py_None) {
11939 // We can either fail here or set V183 to NULL and rely on Ops
11940 // using tensors to handle the NULL case, but if they fail to do so
11941 // they'll end up with nasty segfaults, so this is public service.
11942 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
11943 {
11944 __failure = 184;
11945 if (!PyErr_Occurred()) {
11946 PyErr_SetString(PyExc_RuntimeError,
11947 "Unexpected error in an Op's C code. "
11948 "No Python exception was set.");
11949 }
11950 goto __label_184;}
11951 }
11952 if (!PyArray_Check(py_V183)) {
11953 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
11954 {
11955 __failure = 184;
11956 if (!PyErr_Occurred()) {
11957 PyErr_SetString(PyExc_RuntimeError,
11958 "Unexpected error in an Op's C code. "
11959 "No Python exception was set.");
11960 }
11961 goto __label_184;}
11962 }
11963 // We expect NPY_FLOAT64
11964 if (!PyArray_ISALIGNED((PyArrayObject*) py_V183)) {
11965 PyArrayObject * tmp = (PyArrayObject*) py_V183;
11966 PyErr_Format(PyExc_NotImplementedError,
11967 "expected an aligned array of type %ld "
11968 "(NPY_FLOAT64), got non-aligned array of type %ld"
11969 " with %ld dimensions, with 3 last dims "
11970 "%ld, %ld, %ld"
11971 " and 3 last strides %ld %ld, %ld.",
11972 (long int) NPY_FLOAT64,
11973 (long int) PyArray_TYPE((PyArrayObject*) py_V183),
11974 (long int) PyArray_NDIM(tmp),
11975 (long int) (PyArray_NDIM(tmp) >= 3 ?
11976 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
11977 (long int) (PyArray_NDIM(tmp) >= 2 ?
11978 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
11979 (long int) (PyArray_NDIM(tmp) >= 1 ?
11980 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
11981 (long int) (PyArray_NDIM(tmp) >= 3 ?
11982 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
11983 (long int) (PyArray_NDIM(tmp) >= 2 ?
11984 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
11985 (long int) (PyArray_NDIM(tmp) >= 1 ?
11986 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
11987 );
11988 {
11989 __failure = 184;
11990 if (!PyErr_Occurred()) {
11991 PyErr_SetString(PyExc_RuntimeError,
11992 "Unexpected error in an Op's C code. "
11993 "No Python exception was set.");
11994 }
11995 goto __label_184;}
11996 }
11997 // This is a TypeError to be consistent with DEBUG_MODE
11998 // Note: DEBUG_MODE also tells the name of the container
11999 if (PyArray_TYPE((PyArrayObject*) py_V183) != NPY_FLOAT64) {
12000 PyErr_Format(PyExc_TypeError,
12001 "expected type_num %d (NPY_FLOAT64) got %d",
12002 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V183));
12003 {
12004 __failure = 184;
12005 if (!PyErr_Occurred()) {
12006 PyErr_SetString(PyExc_RuntimeError,
12007 "Unexpected error in an Op's C code. "
12008 "No Python exception was set.");
12009 }
12010 goto __label_184;}
12011 }
12012
12013 V183 = (PyArrayObject*)(py_V183);
12014 Py_XINCREF(V183);
12015
12016 {
12017
12018 py_V185 = PyList_GET_ITEM(storage_V185, 0);
12019 {Py_XINCREF(py_V185);}
12020
12021 V185 = NULL;
12022 if (py_V185 == Py_None) {
12023 // We can either fail here or set V185 to NULL and rely on Ops
12024 // using tensors to handle the NULL case, but if they fail to do so
12025 // they'll end up with nasty segfaults, so this is public service.
12026 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
12027 {
12028 __failure = 186;
12029 if (!PyErr_Occurred()) {
12030 PyErr_SetString(PyExc_RuntimeError,
12031 "Unexpected error in an Op's C code. "
12032 "No Python exception was set.");
12033 }
12034 goto __label_186;}
12035 }
12036 if (!PyArray_Check(py_V185)) {
12037 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
12038 {
12039 __failure = 186;
12040 if (!PyErr_Occurred()) {
12041 PyErr_SetString(PyExc_RuntimeError,
12042 "Unexpected error in an Op's C code. "
12043 "No Python exception was set.");
12044 }
12045 goto __label_186;}
12046 }
12047 // We expect NPY_FLOAT64
12048 if (!PyArray_ISALIGNED((PyArrayObject*) py_V185)) {
12049 PyArrayObject * tmp = (PyArrayObject*) py_V185;
12050 PyErr_Format(PyExc_NotImplementedError,
12051 "expected an aligned array of type %ld "
12052 "(NPY_FLOAT64), got non-aligned array of type %ld"
12053 " with %ld dimensions, with 3 last dims "
12054 "%ld, %ld, %ld"
12055 " and 3 last strides %ld %ld, %ld.",
12056 (long int) NPY_FLOAT64,
12057 (long int) PyArray_TYPE((PyArrayObject*) py_V185),
12058 (long int) PyArray_NDIM(tmp),
12059 (long int) (PyArray_NDIM(tmp) >= 3 ?
12060 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
12061 (long int) (PyArray_NDIM(tmp) >= 2 ?
12062 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
12063 (long int) (PyArray_NDIM(tmp) >= 1 ?
12064 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
12065 (long int) (PyArray_NDIM(tmp) >= 3 ?
12066 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
12067 (long int) (PyArray_NDIM(tmp) >= 2 ?
12068 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
12069 (long int) (PyArray_NDIM(tmp) >= 1 ?
12070 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
12071 );
12072 {
12073 __failure = 186;
12074 if (!PyErr_Occurred()) {
12075 PyErr_SetString(PyExc_RuntimeError,
12076 "Unexpected error in an Op's C code. "
12077 "No Python exception was set.");
12078 }
12079 goto __label_186;}
12080 }
12081 // This is a TypeError to be consistent with DEBUG_MODE
12082 // Note: DEBUG_MODE also tells the name of the container
12083 if (PyArray_TYPE((PyArrayObject*) py_V185) != NPY_FLOAT64) {
12084 PyErr_Format(PyExc_TypeError,
12085 "expected type_num %d (NPY_FLOAT64) got %d",
12086 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V185));
12087 {
12088 __failure = 186;
12089 if (!PyErr_Occurred()) {
12090 PyErr_SetString(PyExc_RuntimeError,
12091 "Unexpected error in an Op's C code. "
12092 "No Python exception was set.");
12093 }
12094 goto __label_186;}
12095 }
12096
12097 V185 = (PyArrayObject*)(py_V185);
12098 Py_XINCREF(V185);
12099
12100 {
12101
12102 py_V187 = PyList_GET_ITEM(storage_V187, 0);
12103 {Py_XINCREF(py_V187);}
12104
12105 V187 = NULL;
12106 if (py_V187 == Py_None) {
12107 // We can either fail here or set V187 to NULL and rely on Ops
12108 // using tensors to handle the NULL case, but if they fail to do so
12109 // they'll end up with nasty segfaults, so this is public service.
12110 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
12111 {
12112 __failure = 188;
12113 if (!PyErr_Occurred()) {
12114 PyErr_SetString(PyExc_RuntimeError,
12115 "Unexpected error in an Op's C code. "
12116 "No Python exception was set.");
12117 }
12118 goto __label_188;}
12119 }
12120 if (!PyArray_Check(py_V187)) {
12121 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
12122 {
12123 __failure = 188;
12124 if (!PyErr_Occurred()) {
12125 PyErr_SetString(PyExc_RuntimeError,
12126 "Unexpected error in an Op's C code. "
12127 "No Python exception was set.");
12128 }
12129 goto __label_188;}
12130 }
12131 // We expect NPY_FLOAT64
12132 if (!PyArray_ISALIGNED((PyArrayObject*) py_V187)) {
12133 PyArrayObject * tmp = (PyArrayObject*) py_V187;
12134 PyErr_Format(PyExc_NotImplementedError,
12135 "expected an aligned array of type %ld "
12136 "(NPY_FLOAT64), got non-aligned array of type %ld"
12137 " with %ld dimensions, with 3 last dims "
12138 "%ld, %ld, %ld"
12139 " and 3 last strides %ld %ld, %ld.",
12140 (long int) NPY_FLOAT64,
12141 (long int) PyArray_TYPE((PyArrayObject*) py_V187),
12142 (long int) PyArray_NDIM(tmp),
12143 (long int) (PyArray_NDIM(tmp) >= 3 ?
12144 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
12145 (long int) (PyArray_NDIM(tmp) >= 2 ?
12146 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
12147 (long int) (PyArray_NDIM(tmp) >= 1 ?
12148 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
12149 (long int) (PyArray_NDIM(tmp) >= 3 ?
12150 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
12151 (long int) (PyArray_NDIM(tmp) >= 2 ?
12152 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
12153 (long int) (PyArray_NDIM(tmp) >= 1 ?
12154 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
12155 );
12156 {
12157 __failure = 188;
12158 if (!PyErr_Occurred()) {
12159 PyErr_SetString(PyExc_RuntimeError,
12160 "Unexpected error in an Op's C code. "
12161 "No Python exception was set.");
12162 }
12163 goto __label_188;}
12164 }
12165 // This is a TypeError to be consistent with DEBUG_MODE
12166 // Note: DEBUG_MODE also tells the name of the container
12167 if (PyArray_TYPE((PyArrayObject*) py_V187) != NPY_FLOAT64) {
12168 PyErr_Format(PyExc_TypeError,
12169 "expected type_num %d (NPY_FLOAT64) got %d",
12170 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V187));
12171 {
12172 __failure = 188;
12173 if (!PyErr_Occurred()) {
12174 PyErr_SetString(PyExc_RuntimeError,
12175 "Unexpected error in an Op's C code. "
12176 "No Python exception was set.");
12177 }
12178 goto __label_188;}
12179 }
12180
12181 V187 = (PyArrayObject*)(py_V187);
12182 Py_XINCREF(V187);
12183
12184 {
12185
12186 py_V189 = PyList_GET_ITEM(storage_V189, 0);
12187 {Py_XINCREF(py_V189);}
12188
12189 V189 = NULL;
12190 if (py_V189 == Py_None) {
12191 // We can either fail here or set V189 to NULL and rely on Ops
12192 // using tensors to handle the NULL case, but if they fail to do so
12193 // they'll end up with nasty segfaults, so this is public service.
12194 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
12195 {
12196 __failure = 190;
12197 if (!PyErr_Occurred()) {
12198 PyErr_SetString(PyExc_RuntimeError,
12199 "Unexpected error in an Op's C code. "
12200 "No Python exception was set.");
12201 }
12202 goto __label_190;}
12203 }
12204 if (!PyArray_Check(py_V189)) {
12205 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
12206 {
12207 __failure = 190;
12208 if (!PyErr_Occurred()) {
12209 PyErr_SetString(PyExc_RuntimeError,
12210 "Unexpected error in an Op's C code. "
12211 "No Python exception was set.");
12212 }
12213 goto __label_190;}
12214 }
12215 // We expect NPY_FLOAT64
12216 if (!PyArray_ISALIGNED((PyArrayObject*) py_V189)) {
12217 PyArrayObject * tmp = (PyArrayObject*) py_V189;
12218 PyErr_Format(PyExc_NotImplementedError,
12219 "expected an aligned array of type %ld "
12220 "(NPY_FLOAT64), got non-aligned array of type %ld"
12221 " with %ld dimensions, with 3 last dims "
12222 "%ld, %ld, %ld"
12223 " and 3 last strides %ld %ld, %ld.",
12224 (long int) NPY_FLOAT64,
12225 (long int) PyArray_TYPE((PyArrayObject*) py_V189),
12226 (long int) PyArray_NDIM(tmp),
12227 (long int) (PyArray_NDIM(tmp) >= 3 ?
12228 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
12229 (long int) (PyArray_NDIM(tmp) >= 2 ?
12230 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
12231 (long int) (PyArray_NDIM(tmp) >= 1 ?
12232 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
12233 (long int) (PyArray_NDIM(tmp) >= 3 ?
12234 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
12235 (long int) (PyArray_NDIM(tmp) >= 2 ?
12236 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
12237 (long int) (PyArray_NDIM(tmp) >= 1 ?
12238 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
12239 );
12240 {
12241 __failure = 190;
12242 if (!PyErr_Occurred()) {
12243 PyErr_SetString(PyExc_RuntimeError,
12244 "Unexpected error in an Op's C code. "
12245 "No Python exception was set.");
12246 }
12247 goto __label_190;}
12248 }
12249 // This is a TypeError to be consistent with DEBUG_MODE
12250 // Note: DEBUG_MODE also tells the name of the container
12251 if (PyArray_TYPE((PyArrayObject*) py_V189) != NPY_FLOAT64) {
12252 PyErr_Format(PyExc_TypeError,
12253 "expected type_num %d (NPY_FLOAT64) got %d",
12254 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V189));
12255 {
12256 __failure = 190;
12257 if (!PyErr_Occurred()) {
12258 PyErr_SetString(PyExc_RuntimeError,
12259 "Unexpected error in an Op's C code. "
12260 "No Python exception was set.");
12261 }
12262 goto __label_190;}
12263 }
12264
12265 V189 = (PyArrayObject*)(py_V189);
12266 Py_XINCREF(V189);
12267
12268 {
12269
12270 py_V191 = PyList_GET_ITEM(storage_V191, 0);
12271 {Py_XINCREF(py_V191);}
12272
12273 V191 = NULL;
12274 if (py_V191 == Py_None) {
12275 // We can either fail here or set V191 to NULL and rely on Ops
12276 // using tensors to handle the NULL case, but if they fail to do so
12277 // they'll end up with nasty segfaults, so this is public service.
12278 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
12279 {
12280 __failure = 192;
12281 if (!PyErr_Occurred()) {
12282 PyErr_SetString(PyExc_RuntimeError,
12283 "Unexpected error in an Op's C code. "
12284 "No Python exception was set.");
12285 }
12286 goto __label_192;}
12287 }
12288 if (!PyArray_Check(py_V191)) {
12289 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
12290 {
12291 __failure = 192;
12292 if (!PyErr_Occurred()) {
12293 PyErr_SetString(PyExc_RuntimeError,
12294 "Unexpected error in an Op's C code. "
12295 "No Python exception was set.");
12296 }
12297 goto __label_192;}
12298 }
12299 // We expect NPY_FLOAT64
12300 if (!PyArray_ISALIGNED((PyArrayObject*) py_V191)) {
12301 PyArrayObject * tmp = (PyArrayObject*) py_V191;
12302 PyErr_Format(PyExc_NotImplementedError,
12303 "expected an aligned array of type %ld "
12304 "(NPY_FLOAT64), got non-aligned array of type %ld"
12305 " with %ld dimensions, with 3 last dims "
12306 "%ld, %ld, %ld"
12307 " and 3 last strides %ld %ld, %ld.",
12308 (long int) NPY_FLOAT64,
12309 (long int) PyArray_TYPE((PyArrayObject*) py_V191),
12310 (long int) PyArray_NDIM(tmp),
12311 (long int) (PyArray_NDIM(tmp) >= 3 ?
12312 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
12313 (long int) (PyArray_NDIM(tmp) >= 2 ?
12314 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
12315 (long int) (PyArray_NDIM(tmp) >= 1 ?
12316 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
12317 (long int) (PyArray_NDIM(tmp) >= 3 ?
12318 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
12319 (long int) (PyArray_NDIM(tmp) >= 2 ?
12320 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
12321 (long int) (PyArray_NDIM(tmp) >= 1 ?
12322 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
12323 );
12324 {
12325 __failure = 192;
12326 if (!PyErr_Occurred()) {
12327 PyErr_SetString(PyExc_RuntimeError,
12328 "Unexpected error in an Op's C code. "
12329 "No Python exception was set.");
12330 }
12331 goto __label_192;}
12332 }
12333 // This is a TypeError to be consistent with DEBUG_MODE
12334 // Note: DEBUG_MODE also tells the name of the container
12335 if (PyArray_TYPE((PyArrayObject*) py_V191) != NPY_FLOAT64) {
12336 PyErr_Format(PyExc_TypeError,
12337 "expected type_num %d (NPY_FLOAT64) got %d",
12338 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V191));
12339 {
12340 __failure = 192;
12341 if (!PyErr_Occurred()) {
12342 PyErr_SetString(PyExc_RuntimeError,
12343 "Unexpected error in an Op's C code. "
12344 "No Python exception was set.");
12345 }
12346 goto __label_192;}
12347 }
12348
12349 V191 = (PyArrayObject*)(py_V191);
12350 Py_XINCREF(V191);
12351
12352 {
12353
12354 py_V193 = PyList_GET_ITEM(storage_V193, 0);
12355 {Py_XINCREF(py_V193);}
12356
12357 V193 = NULL;
12358 if (py_V193 == Py_None) {
12359 // We can either fail here or set V193 to NULL and rely on Ops
12360 // using tensors to handle the NULL case, but if they fail to do so
12361 // they'll end up with nasty segfaults, so this is public service.
12362 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
12363 {
12364 __failure = 194;
12365 if (!PyErr_Occurred()) {
12366 PyErr_SetString(PyExc_RuntimeError,
12367 "Unexpected error in an Op's C code. "
12368 "No Python exception was set.");
12369 }
12370 goto __label_194;}
12371 }
12372 if (!PyArray_Check(py_V193)) {
12373 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
12374 {
12375 __failure = 194;
12376 if (!PyErr_Occurred()) {
12377 PyErr_SetString(PyExc_RuntimeError,
12378 "Unexpected error in an Op's C code. "
12379 "No Python exception was set.");
12380 }
12381 goto __label_194;}
12382 }
12383 // We expect NPY_FLOAT64
12384 if (!PyArray_ISALIGNED((PyArrayObject*) py_V193)) {
12385 PyArrayObject * tmp = (PyArrayObject*) py_V193;
12386 PyErr_Format(PyExc_NotImplementedError,
12387 "expected an aligned array of type %ld "
12388 "(NPY_FLOAT64), got non-aligned array of type %ld"
12389 " with %ld dimensions, with 3 last dims "
12390 "%ld, %ld, %ld"
12391 " and 3 last strides %ld %ld, %ld.",
12392 (long int) NPY_FLOAT64,
12393 (long int) PyArray_TYPE((PyArrayObject*) py_V193),
12394 (long int) PyArray_NDIM(tmp),
12395 (long int) (PyArray_NDIM(tmp) >= 3 ?
12396 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
12397 (long int) (PyArray_NDIM(tmp) >= 2 ?
12398 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
12399 (long int) (PyArray_NDIM(tmp) >= 1 ?
12400 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
12401 (long int) (PyArray_NDIM(tmp) >= 3 ?
12402 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
12403 (long int) (PyArray_NDIM(tmp) >= 2 ?
12404 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
12405 (long int) (PyArray_NDIM(tmp) >= 1 ?
12406 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
12407 );
12408 {
12409 __failure = 194;
12410 if (!PyErr_Occurred()) {
12411 PyErr_SetString(PyExc_RuntimeError,
12412 "Unexpected error in an Op's C code. "
12413 "No Python exception was set.");
12414 }
12415 goto __label_194;}
12416 }
12417 // This is a TypeError to be consistent with DEBUG_MODE
12418 // Note: DEBUG_MODE also tells the name of the container
12419 if (PyArray_TYPE((PyArrayObject*) py_V193) != NPY_FLOAT64) {
12420 PyErr_Format(PyExc_TypeError,
12421 "expected type_num %d (NPY_FLOAT64) got %d",
12422 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V193));
12423 {
12424 __failure = 194;
12425 if (!PyErr_Occurred()) {
12426 PyErr_SetString(PyExc_RuntimeError,
12427 "Unexpected error in an Op's C code. "
12428 "No Python exception was set.");
12429 }
12430 goto __label_194;}
12431 }
12432
12433 V193 = (PyArrayObject*)(py_V193);
12434 Py_XINCREF(V193);
12435
12436 {
12437
12438 py_V195 = PyList_GET_ITEM(storage_V195, 0);
12439 {Py_XINCREF(py_V195);}
12440
12441 V195 = NULL;
12442 if (py_V195 == Py_None) {
12443 // We can either fail here or set V195 to NULL and rely on Ops
12444 // using tensors to handle the NULL case, but if they fail to do so
12445 // they'll end up with nasty segfaults, so this is public service.
12446 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
12447 {
12448 __failure = 196;
12449 if (!PyErr_Occurred()) {
12450 PyErr_SetString(PyExc_RuntimeError,
12451 "Unexpected error in an Op's C code. "
12452 "No Python exception was set.");
12453 }
12454 goto __label_196;}
12455 }
12456 if (!PyArray_Check(py_V195)) {
12457 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
12458 {
12459 __failure = 196;
12460 if (!PyErr_Occurred()) {
12461 PyErr_SetString(PyExc_RuntimeError,
12462 "Unexpected error in an Op's C code. "
12463 "No Python exception was set.");
12464 }
12465 goto __label_196;}
12466 }
12467 // We expect NPY_FLOAT64
12468 if (!PyArray_ISALIGNED((PyArrayObject*) py_V195)) {
12469 PyArrayObject * tmp = (PyArrayObject*) py_V195;
12470 PyErr_Format(PyExc_NotImplementedError,
12471 "expected an aligned array of type %ld "
12472 "(NPY_FLOAT64), got non-aligned array of type %ld"
12473 " with %ld dimensions, with 3 last dims "
12474 "%ld, %ld, %ld"
12475 " and 3 last strides %ld %ld, %ld.",
12476 (long int) NPY_FLOAT64,
12477 (long int) PyArray_TYPE((PyArrayObject*) py_V195),
12478 (long int) PyArray_NDIM(tmp),
12479 (long int) (PyArray_NDIM(tmp) >= 3 ?
12480 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
12481 (long int) (PyArray_NDIM(tmp) >= 2 ?
12482 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
12483 (long int) (PyArray_NDIM(tmp) >= 1 ?
12484 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
12485 (long int) (PyArray_NDIM(tmp) >= 3 ?
12486 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
12487 (long int) (PyArray_NDIM(tmp) >= 2 ?
12488 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
12489 (long int) (PyArray_NDIM(tmp) >= 1 ?
12490 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
12491 );
12492 {
12493 __failure = 196;
12494 if (!PyErr_Occurred()) {
12495 PyErr_SetString(PyExc_RuntimeError,
12496 "Unexpected error in an Op's C code. "
12497 "No Python exception was set.");
12498 }
12499 goto __label_196;}
12500 }
12501 // This is a TypeError to be consistent with DEBUG_MODE
12502 // Note: DEBUG_MODE also tells the name of the container
12503 if (PyArray_TYPE((PyArrayObject*) py_V195) != NPY_FLOAT64) {
12504 PyErr_Format(PyExc_TypeError,
12505 "expected type_num %d (NPY_FLOAT64) got %d",
12506 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V195));
12507 {
12508 __failure = 196;
12509 if (!PyErr_Occurred()) {
12510 PyErr_SetString(PyExc_RuntimeError,
12511 "Unexpected error in an Op's C code. "
12512 "No Python exception was set.");
12513 }
12514 goto __label_196;}
12515 }
12516
12517 V195 = (PyArrayObject*)(py_V195);
12518 Py_XINCREF(V195);
12519
12520 {
12521
12522 py_V197 = PyList_GET_ITEM(storage_V197, 0);
12523 {Py_XINCREF(py_V197);}
12524
12525 V197 = NULL;
12526 if (py_V197 == Py_None) {
12527 // We can either fail here or set V197 to NULL and rely on Ops
12528 // using tensors to handle the NULL case, but if they fail to do so
12529 // they'll end up with nasty segfaults, so this is public service.
12530 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
12531 {
12532 __failure = 198;
12533 if (!PyErr_Occurred()) {
12534 PyErr_SetString(PyExc_RuntimeError,
12535 "Unexpected error in an Op's C code. "
12536 "No Python exception was set.");
12537 }
12538 goto __label_198;}
12539 }
12540 if (!PyArray_Check(py_V197)) {
12541 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
12542 {
12543 __failure = 198;
12544 if (!PyErr_Occurred()) {
12545 PyErr_SetString(PyExc_RuntimeError,
12546 "Unexpected error in an Op's C code. "
12547 "No Python exception was set.");
12548 }
12549 goto __label_198;}
12550 }
12551 // We expect NPY_FLOAT64
12552 if (!PyArray_ISALIGNED((PyArrayObject*) py_V197)) {
12553 PyArrayObject * tmp = (PyArrayObject*) py_V197;
12554 PyErr_Format(PyExc_NotImplementedError,
12555 "expected an aligned array of type %ld "
12556 "(NPY_FLOAT64), got non-aligned array of type %ld"
12557 " with %ld dimensions, with 3 last dims "
12558 "%ld, %ld, %ld"
12559 " and 3 last strides %ld %ld, %ld.",
12560 (long int) NPY_FLOAT64,
12561 (long int) PyArray_TYPE((PyArrayObject*) py_V197),
12562 (long int) PyArray_NDIM(tmp),
12563 (long int) (PyArray_NDIM(tmp) >= 3 ?
12564 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
12565 (long int) (PyArray_NDIM(tmp) >= 2 ?
12566 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
12567 (long int) (PyArray_NDIM(tmp) >= 1 ?
12568 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
12569 (long int) (PyArray_NDIM(tmp) >= 3 ?
12570 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
12571 (long int) (PyArray_NDIM(tmp) >= 2 ?
12572 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
12573 (long int) (PyArray_NDIM(tmp) >= 1 ?
12574 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
12575 );
12576 {
12577 __failure = 198;
12578 if (!PyErr_Occurred()) {
12579 PyErr_SetString(PyExc_RuntimeError,
12580 "Unexpected error in an Op's C code. "
12581 "No Python exception was set.");
12582 }
12583 goto __label_198;}
12584 }
12585 // This is a TypeError to be consistent with DEBUG_MODE
12586 // Note: DEBUG_MODE also tells the name of the container
12587 if (PyArray_TYPE((PyArrayObject*) py_V197) != NPY_FLOAT64) {
12588 PyErr_Format(PyExc_TypeError,
12589 "expected type_num %d (NPY_FLOAT64) got %d",
12590 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V197));
12591 {
12592 __failure = 198;
12593 if (!PyErr_Occurred()) {
12594 PyErr_SetString(PyExc_RuntimeError,
12595 "Unexpected error in an Op's C code. "
12596 "No Python exception was set.");
12597 }
12598 goto __label_198;}
12599 }
12600
12601 V197 = (PyArrayObject*)(py_V197);
12602 Py_XINCREF(V197);
12603
12604 {
12605
12606 py_V199 = PyList_GET_ITEM(storage_V199, 0);
12607 {Py_XINCREF(py_V199);}
12608
12609 V199 = NULL;
12610 if (py_V199 == Py_None) {
12611 // We can either fail here or set V199 to NULL and rely on Ops
12612 // using tensors to handle the NULL case, but if they fail to do so
12613 // they'll end up with nasty segfaults, so this is public service.
12614 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
12615 {
12616 __failure = 200;
12617 if (!PyErr_Occurred()) {
12618 PyErr_SetString(PyExc_RuntimeError,
12619 "Unexpected error in an Op's C code. "
12620 "No Python exception was set.");
12621 }
12622 goto __label_200;}
12623 }
12624 if (!PyArray_Check(py_V199)) {
12625 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
12626 {
12627 __failure = 200;
12628 if (!PyErr_Occurred()) {
12629 PyErr_SetString(PyExc_RuntimeError,
12630 "Unexpected error in an Op's C code. "
12631 "No Python exception was set.");
12632 }
12633 goto __label_200;}
12634 }
12635 // We expect NPY_FLOAT64
12636 if (!PyArray_ISALIGNED((PyArrayObject*) py_V199)) {
12637 PyArrayObject * tmp = (PyArrayObject*) py_V199;
12638 PyErr_Format(PyExc_NotImplementedError,
12639 "expected an aligned array of type %ld "
12640 "(NPY_FLOAT64), got non-aligned array of type %ld"
12641 " with %ld dimensions, with 3 last dims "
12642 "%ld, %ld, %ld"
12643 " and 3 last strides %ld %ld, %ld.",
12644 (long int) NPY_FLOAT64,
12645 (long int) PyArray_TYPE((PyArrayObject*) py_V199),
12646 (long int) PyArray_NDIM(tmp),
12647 (long int) (PyArray_NDIM(tmp) >= 3 ?
12648 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
12649 (long int) (PyArray_NDIM(tmp) >= 2 ?
12650 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
12651 (long int) (PyArray_NDIM(tmp) >= 1 ?
12652 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
12653 (long int) (PyArray_NDIM(tmp) >= 3 ?
12654 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
12655 (long int) (PyArray_NDIM(tmp) >= 2 ?
12656 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
12657 (long int) (PyArray_NDIM(tmp) >= 1 ?
12658 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
12659 );
12660 {
12661 __failure = 200;
12662 if (!PyErr_Occurred()) {
12663 PyErr_SetString(PyExc_RuntimeError,
12664 "Unexpected error in an Op's C code. "
12665 "No Python exception was set.");
12666 }
12667 goto __label_200;}
12668 }
12669 // This is a TypeError to be consistent with DEBUG_MODE
12670 // Note: DEBUG_MODE also tells the name of the container
12671 if (PyArray_TYPE((PyArrayObject*) py_V199) != NPY_FLOAT64) {
12672 PyErr_Format(PyExc_TypeError,
12673 "expected type_num %d (NPY_FLOAT64) got %d",
12674 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V199));
12675 {
12676 __failure = 200;
12677 if (!PyErr_Occurred()) {
12678 PyErr_SetString(PyExc_RuntimeError,
12679 "Unexpected error in an Op's C code. "
12680 "No Python exception was set.");
12681 }
12682 goto __label_200;}
12683 }
12684
12685 V199 = (PyArrayObject*)(py_V199);
12686 Py_XINCREF(V199);
12687
12688 {
12689
12690 py_V201 = PyList_GET_ITEM(storage_V201, 0);
12691 {Py_XINCREF(py_V201);}
12692
12693 V201 = NULL;
12694 if (py_V201 == Py_None) {
12695 // We can either fail here or set V201 to NULL and rely on Ops
12696 // using tensors to handle the NULL case, but if they fail to do so
12697 // they'll end up with nasty segfaults, so this is public service.
12698 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
12699 {
12700 __failure = 202;
12701 if (!PyErr_Occurred()) {
12702 PyErr_SetString(PyExc_RuntimeError,
12703 "Unexpected error in an Op's C code. "
12704 "No Python exception was set.");
12705 }
12706 goto __label_202;}
12707 }
12708 if (!PyArray_Check(py_V201)) {
12709 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
12710 {
12711 __failure = 202;
12712 if (!PyErr_Occurred()) {
12713 PyErr_SetString(PyExc_RuntimeError,
12714 "Unexpected error in an Op's C code. "
12715 "No Python exception was set.");
12716 }
12717 goto __label_202;}
12718 }
12719 // We expect NPY_FLOAT64
12720 if (!PyArray_ISALIGNED((PyArrayObject*) py_V201)) {
12721 PyArrayObject * tmp = (PyArrayObject*) py_V201;
12722 PyErr_Format(PyExc_NotImplementedError,
12723 "expected an aligned array of type %ld "
12724 "(NPY_FLOAT64), got non-aligned array of type %ld"
12725 " with %ld dimensions, with 3 last dims "
12726 "%ld, %ld, %ld"
12727 " and 3 last strides %ld %ld, %ld.",
12728 (long int) NPY_FLOAT64,
12729 (long int) PyArray_TYPE((PyArrayObject*) py_V201),
12730 (long int) PyArray_NDIM(tmp),
12731 (long int) (PyArray_NDIM(tmp) >= 3 ?
12732 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
12733 (long int) (PyArray_NDIM(tmp) >= 2 ?
12734 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
12735 (long int) (PyArray_NDIM(tmp) >= 1 ?
12736 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
12737 (long int) (PyArray_NDIM(tmp) >= 3 ?
12738 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
12739 (long int) (PyArray_NDIM(tmp) >= 2 ?
12740 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
12741 (long int) (PyArray_NDIM(tmp) >= 1 ?
12742 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
12743 );
12744 {
12745 __failure = 202;
12746 if (!PyErr_Occurred()) {
12747 PyErr_SetString(PyExc_RuntimeError,
12748 "Unexpected error in an Op's C code. "
12749 "No Python exception was set.");
12750 }
12751 goto __label_202;}
12752 }
12753 // This is a TypeError to be consistent with DEBUG_MODE
12754 // Note: DEBUG_MODE also tells the name of the container
12755 if (PyArray_TYPE((PyArrayObject*) py_V201) != NPY_FLOAT64) {
12756 PyErr_Format(PyExc_TypeError,
12757 "expected type_num %d (NPY_FLOAT64) got %d",
12758 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V201));
12759 {
12760 __failure = 202;
12761 if (!PyErr_Occurred()) {
12762 PyErr_SetString(PyExc_RuntimeError,
12763 "Unexpected error in an Op's C code. "
12764 "No Python exception was set.");
12765 }
12766 goto __label_202;}
12767 }
12768
12769 V201 = (PyArrayObject*)(py_V201);
12770 Py_XINCREF(V201);
12771
12772 {
12773
12774 py_V203 = PyList_GET_ITEM(storage_V203, 0);
12775 {Py_XINCREF(py_V203);}
12776
12777 V203 = NULL;
12778 if (py_V203 == Py_None) {
12779 // We can either fail here or set V203 to NULL and rely on Ops
12780 // using tensors to handle the NULL case, but if they fail to do so
12781 // they'll end up with nasty segfaults, so this is public service.
12782 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
12783 {
12784 __failure = 204;
12785 if (!PyErr_Occurred()) {
12786 PyErr_SetString(PyExc_RuntimeError,
12787 "Unexpected error in an Op's C code. "
12788 "No Python exception was set.");
12789 }
12790 goto __label_204;}
12791 }
12792 if (!PyArray_Check(py_V203)) {
12793 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
12794 {
12795 __failure = 204;
12796 if (!PyErr_Occurred()) {
12797 PyErr_SetString(PyExc_RuntimeError,
12798 "Unexpected error in an Op's C code. "
12799 "No Python exception was set.");
12800 }
12801 goto __label_204;}
12802 }
12803 // We expect NPY_FLOAT64
12804 if (!PyArray_ISALIGNED((PyArrayObject*) py_V203)) {
12805 PyArrayObject * tmp = (PyArrayObject*) py_V203;
12806 PyErr_Format(PyExc_NotImplementedError,
12807 "expected an aligned array of type %ld "
12808 "(NPY_FLOAT64), got non-aligned array of type %ld"
12809 " with %ld dimensions, with 3 last dims "
12810 "%ld, %ld, %ld"
12811 " and 3 last strides %ld %ld, %ld.",
12812 (long int) NPY_FLOAT64,
12813 (long int) PyArray_TYPE((PyArrayObject*) py_V203),
12814 (long int) PyArray_NDIM(tmp),
12815 (long int) (PyArray_NDIM(tmp) >= 3 ?
12816 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
12817 (long int) (PyArray_NDIM(tmp) >= 2 ?
12818 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
12819 (long int) (PyArray_NDIM(tmp) >= 1 ?
12820 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
12821 (long int) (PyArray_NDIM(tmp) >= 3 ?
12822 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
12823 (long int) (PyArray_NDIM(tmp) >= 2 ?
12824 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
12825 (long int) (PyArray_NDIM(tmp) >= 1 ?
12826 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
12827 );
12828 {
12829 __failure = 204;
12830 if (!PyErr_Occurred()) {
12831 PyErr_SetString(PyExc_RuntimeError,
12832 "Unexpected error in an Op's C code. "
12833 "No Python exception was set.");
12834 }
12835 goto __label_204;}
12836 }
12837 // This is a TypeError to be consistent with DEBUG_MODE
12838 // Note: DEBUG_MODE also tells the name of the container
12839 if (PyArray_TYPE((PyArrayObject*) py_V203) != NPY_FLOAT64) {
12840 PyErr_Format(PyExc_TypeError,
12841 "expected type_num %d (NPY_FLOAT64) got %d",
12842 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V203));
12843 {
12844 __failure = 204;
12845 if (!PyErr_Occurred()) {
12846 PyErr_SetString(PyExc_RuntimeError,
12847 "Unexpected error in an Op's C code. "
12848 "No Python exception was set.");
12849 }
12850 goto __label_204;}
12851 }
12852
12853 V203 = (PyArrayObject*)(py_V203);
12854 Py_XINCREF(V203);
12855
12856 {
12857
12858 py_V205 = PyList_GET_ITEM(storage_V205, 0);
12859 {Py_XINCREF(py_V205);}
12860
12861 V205 = NULL;
12862 if (py_V205 == Py_None) {
12863 // We can either fail here or set V205 to NULL and rely on Ops
12864 // using tensors to handle the NULL case, but if they fail to do so
12865 // they'll end up with nasty segfaults, so this is public service.
12866 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
12867 {
12868 __failure = 206;
12869 if (!PyErr_Occurred()) {
12870 PyErr_SetString(PyExc_RuntimeError,
12871 "Unexpected error in an Op's C code. "
12872 "No Python exception was set.");
12873 }
12874 goto __label_206;}
12875 }
12876 if (!PyArray_Check(py_V205)) {
12877 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
12878 {
12879 __failure = 206;
12880 if (!PyErr_Occurred()) {
12881 PyErr_SetString(PyExc_RuntimeError,
12882 "Unexpected error in an Op's C code. "
12883 "No Python exception was set.");
12884 }
12885 goto __label_206;}
12886 }
12887 // We expect NPY_FLOAT64
12888 if (!PyArray_ISALIGNED((PyArrayObject*) py_V205)) {
12889 PyArrayObject * tmp = (PyArrayObject*) py_V205;
12890 PyErr_Format(PyExc_NotImplementedError,
12891 "expected an aligned array of type %ld "
12892 "(NPY_FLOAT64), got non-aligned array of type %ld"
12893 " with %ld dimensions, with 3 last dims "
12894 "%ld, %ld, %ld"
12895 " and 3 last strides %ld %ld, %ld.",
12896 (long int) NPY_FLOAT64,
12897 (long int) PyArray_TYPE((PyArrayObject*) py_V205),
12898 (long int) PyArray_NDIM(tmp),
12899 (long int) (PyArray_NDIM(tmp) >= 3 ?
12900 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
12901 (long int) (PyArray_NDIM(tmp) >= 2 ?
12902 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
12903 (long int) (PyArray_NDIM(tmp) >= 1 ?
12904 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
12905 (long int) (PyArray_NDIM(tmp) >= 3 ?
12906 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
12907 (long int) (PyArray_NDIM(tmp) >= 2 ?
12908 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
12909 (long int) (PyArray_NDIM(tmp) >= 1 ?
12910 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
12911 );
12912 {
12913 __failure = 206;
12914 if (!PyErr_Occurred()) {
12915 PyErr_SetString(PyExc_RuntimeError,
12916 "Unexpected error in an Op's C code. "
12917 "No Python exception was set.");
12918 }
12919 goto __label_206;}
12920 }
12921 // This is a TypeError to be consistent with DEBUG_MODE
12922 // Note: DEBUG_MODE also tells the name of the container
12923 if (PyArray_TYPE((PyArrayObject*) py_V205) != NPY_FLOAT64) {
12924 PyErr_Format(PyExc_TypeError,
12925 "expected type_num %d (NPY_FLOAT64) got %d",
12926 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V205));
12927 {
12928 __failure = 206;
12929 if (!PyErr_Occurred()) {
12930 PyErr_SetString(PyExc_RuntimeError,
12931 "Unexpected error in an Op's C code. "
12932 "No Python exception was set.");
12933 }
12934 goto __label_206;}
12935 }
12936
12937 V205 = (PyArrayObject*)(py_V205);
12938 Py_XINCREF(V205);
12939
12940 {
12941
12942 py_V207 = PyList_GET_ITEM(storage_V207, 0);
12943 {Py_XINCREF(py_V207);}
12944
12945 V207 = NULL;
12946 if (py_V207 == Py_None) {
12947 // We can either fail here or set V207 to NULL and rely on Ops
12948 // using tensors to handle the NULL case, but if they fail to do so
12949 // they'll end up with nasty segfaults, so this is public service.
12950 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
12951 {
12952 __failure = 208;
12953 if (!PyErr_Occurred()) {
12954 PyErr_SetString(PyExc_RuntimeError,
12955 "Unexpected error in an Op's C code. "
12956 "No Python exception was set.");
12957 }
12958 goto __label_208;}
12959 }
12960 if (!PyArray_Check(py_V207)) {
12961 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
12962 {
12963 __failure = 208;
12964 if (!PyErr_Occurred()) {
12965 PyErr_SetString(PyExc_RuntimeError,
12966 "Unexpected error in an Op's C code. "
12967 "No Python exception was set.");
12968 }
12969 goto __label_208;}
12970 }
12971 // We expect NPY_FLOAT64
12972 if (!PyArray_ISALIGNED((PyArrayObject*) py_V207)) {
12973 PyArrayObject * tmp = (PyArrayObject*) py_V207;
12974 PyErr_Format(PyExc_NotImplementedError,
12975 "expected an aligned array of type %ld "
12976 "(NPY_FLOAT64), got non-aligned array of type %ld"
12977 " with %ld dimensions, with 3 last dims "
12978 "%ld, %ld, %ld"
12979 " and 3 last strides %ld %ld, %ld.",
12980 (long int) NPY_FLOAT64,
12981 (long int) PyArray_TYPE((PyArrayObject*) py_V207),
12982 (long int) PyArray_NDIM(tmp),
12983 (long int) (PyArray_NDIM(tmp) >= 3 ?
12984 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
12985 (long int) (PyArray_NDIM(tmp) >= 2 ?
12986 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
12987 (long int) (PyArray_NDIM(tmp) >= 1 ?
12988 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
12989 (long int) (PyArray_NDIM(tmp) >= 3 ?
12990 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
12991 (long int) (PyArray_NDIM(tmp) >= 2 ?
12992 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
12993 (long int) (PyArray_NDIM(tmp) >= 1 ?
12994 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
12995 );
12996 {
12997 __failure = 208;
12998 if (!PyErr_Occurred()) {
12999 PyErr_SetString(PyExc_RuntimeError,
13000 "Unexpected error in an Op's C code. "
13001 "No Python exception was set.");
13002 }
13003 goto __label_208;}
13004 }
13005 // This is a TypeError to be consistent with DEBUG_MODE
13006 // Note: DEBUG_MODE also tells the name of the container
13007 if (PyArray_TYPE((PyArrayObject*) py_V207) != NPY_FLOAT64) {
13008 PyErr_Format(PyExc_TypeError,
13009 "expected type_num %d (NPY_FLOAT64) got %d",
13010 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V207));
13011 {
13012 __failure = 208;
13013 if (!PyErr_Occurred()) {
13014 PyErr_SetString(PyExc_RuntimeError,
13015 "Unexpected error in an Op's C code. "
13016 "No Python exception was set.");
13017 }
13018 goto __label_208;}
13019 }
13020
13021 V207 = (PyArrayObject*)(py_V207);
13022 Py_XINCREF(V207);
13023
13024 {
13025
13026 py_V209 = PyList_GET_ITEM(storage_V209, 0);
13027 {Py_XINCREF(py_V209);}
13028
13029 V209 = NULL;
13030 if (py_V209 == Py_None) {
13031 // We can either fail here or set V209 to NULL and rely on Ops
13032 // using tensors to handle the NULL case, but if they fail to do so
13033 // they'll end up with nasty segfaults, so this is public service.
13034 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
13035 {
13036 __failure = 210;
13037 if (!PyErr_Occurred()) {
13038 PyErr_SetString(PyExc_RuntimeError,
13039 "Unexpected error in an Op's C code. "
13040 "No Python exception was set.");
13041 }
13042 goto __label_210;}
13043 }
13044 if (!PyArray_Check(py_V209)) {
13045 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
13046 {
13047 __failure = 210;
13048 if (!PyErr_Occurred()) {
13049 PyErr_SetString(PyExc_RuntimeError,
13050 "Unexpected error in an Op's C code. "
13051 "No Python exception was set.");
13052 }
13053 goto __label_210;}
13054 }
13055 // We expect NPY_FLOAT64
13056 if (!PyArray_ISALIGNED((PyArrayObject*) py_V209)) {
13057 PyArrayObject * tmp = (PyArrayObject*) py_V209;
13058 PyErr_Format(PyExc_NotImplementedError,
13059 "expected an aligned array of type %ld "
13060 "(NPY_FLOAT64), got non-aligned array of type %ld"
13061 " with %ld dimensions, with 3 last dims "
13062 "%ld, %ld, %ld"
13063 " and 3 last strides %ld %ld, %ld.",
13064 (long int) NPY_FLOAT64,
13065 (long int) PyArray_TYPE((PyArrayObject*) py_V209),
13066 (long int) PyArray_NDIM(tmp),
13067 (long int) (PyArray_NDIM(tmp) >= 3 ?
13068 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
13069 (long int) (PyArray_NDIM(tmp) >= 2 ?
13070 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
13071 (long int) (PyArray_NDIM(tmp) >= 1 ?
13072 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
13073 (long int) (PyArray_NDIM(tmp) >= 3 ?
13074 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
13075 (long int) (PyArray_NDIM(tmp) >= 2 ?
13076 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
13077 (long int) (PyArray_NDIM(tmp) >= 1 ?
13078 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
13079 );
13080 {
13081 __failure = 210;
13082 if (!PyErr_Occurred()) {
13083 PyErr_SetString(PyExc_RuntimeError,
13084 "Unexpected error in an Op's C code. "
13085 "No Python exception was set.");
13086 }
13087 goto __label_210;}
13088 }
13089 // This is a TypeError to be consistent with DEBUG_MODE
13090 // Note: DEBUG_MODE also tells the name of the container
13091 if (PyArray_TYPE((PyArrayObject*) py_V209) != NPY_FLOAT64) {
13092 PyErr_Format(PyExc_TypeError,
13093 "expected type_num %d (NPY_FLOAT64) got %d",
13094 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V209));
13095 {
13096 __failure = 210;
13097 if (!PyErr_Occurred()) {
13098 PyErr_SetString(PyExc_RuntimeError,
13099 "Unexpected error in an Op's C code. "
13100 "No Python exception was set.");
13101 }
13102 goto __label_210;}
13103 }
13104
13105 V209 = (PyArrayObject*)(py_V209);
13106 Py_XINCREF(V209);
13107
13108 {
13109
13110 py_V211 = PyList_GET_ITEM(storage_V211, 0);
13111 {Py_XINCREF(py_V211);}
13112
13113 V211 = NULL;
13114 if (py_V211 == Py_None) {
13115 // We can either fail here or set V211 to NULL and rely on Ops
13116 // using tensors to handle the NULL case, but if they fail to do so
13117 // they'll end up with nasty segfaults, so this is public service.
13118 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
13119 {
13120 __failure = 212;
13121 if (!PyErr_Occurred()) {
13122 PyErr_SetString(PyExc_RuntimeError,
13123 "Unexpected error in an Op's C code. "
13124 "No Python exception was set.");
13125 }
13126 goto __label_212;}
13127 }
13128 if (!PyArray_Check(py_V211)) {
13129 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
13130 {
13131 __failure = 212;
13132 if (!PyErr_Occurred()) {
13133 PyErr_SetString(PyExc_RuntimeError,
13134 "Unexpected error in an Op's C code. "
13135 "No Python exception was set.");
13136 }
13137 goto __label_212;}
13138 }
13139 // We expect NPY_FLOAT64
13140 if (!PyArray_ISALIGNED((PyArrayObject*) py_V211)) {
13141 PyArrayObject * tmp = (PyArrayObject*) py_V211;
13142 PyErr_Format(PyExc_NotImplementedError,
13143 "expected an aligned array of type %ld "
13144 "(NPY_FLOAT64), got non-aligned array of type %ld"
13145 " with %ld dimensions, with 3 last dims "
13146 "%ld, %ld, %ld"
13147 " and 3 last strides %ld %ld, %ld.",
13148 (long int) NPY_FLOAT64,
13149 (long int) PyArray_TYPE((PyArrayObject*) py_V211),
13150 (long int) PyArray_NDIM(tmp),
13151 (long int) (PyArray_NDIM(tmp) >= 3 ?
13152 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
13153 (long int) (PyArray_NDIM(tmp) >= 2 ?
13154 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
13155 (long int) (PyArray_NDIM(tmp) >= 1 ?
13156 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
13157 (long int) (PyArray_NDIM(tmp) >= 3 ?
13158 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
13159 (long int) (PyArray_NDIM(tmp) >= 2 ?
13160 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
13161 (long int) (PyArray_NDIM(tmp) >= 1 ?
13162 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
13163 );
13164 {
13165 __failure = 212;
13166 if (!PyErr_Occurred()) {
13167 PyErr_SetString(PyExc_RuntimeError,
13168 "Unexpected error in an Op's C code. "
13169 "No Python exception was set.");
13170 }
13171 goto __label_212;}
13172 }
13173 // This is a TypeError to be consistent with DEBUG_MODE
13174 // Note: DEBUG_MODE also tells the name of the container
13175 if (PyArray_TYPE((PyArrayObject*) py_V211) != NPY_FLOAT64) {
13176 PyErr_Format(PyExc_TypeError,
13177 "expected type_num %d (NPY_FLOAT64) got %d",
13178 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V211));
13179 {
13180 __failure = 212;
13181 if (!PyErr_Occurred()) {
13182 PyErr_SetString(PyExc_RuntimeError,
13183 "Unexpected error in an Op's C code. "
13184 "No Python exception was set.");
13185 }
13186 goto __label_212;}
13187 }
13188
13189 V211 = (PyArrayObject*)(py_V211);
13190 Py_XINCREF(V211);
13191
13192 {
13193
13194 py_V213 = PyList_GET_ITEM(storage_V213, 0);
13195 {Py_XINCREF(py_V213);}
13196
13197 V213 = NULL;
13198 if (py_V213 == Py_None) {
13199 // We can either fail here or set V213 to NULL and rely on Ops
13200 // using tensors to handle the NULL case, but if they fail to do so
13201 // they'll end up with nasty segfaults, so this is public service.
13202 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
13203 {
13204 __failure = 214;
13205 if (!PyErr_Occurred()) {
13206 PyErr_SetString(PyExc_RuntimeError,
13207 "Unexpected error in an Op's C code. "
13208 "No Python exception was set.");
13209 }
13210 goto __label_214;}
13211 }
13212 if (!PyArray_Check(py_V213)) {
13213 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
13214 {
13215 __failure = 214;
13216 if (!PyErr_Occurred()) {
13217 PyErr_SetString(PyExc_RuntimeError,
13218 "Unexpected error in an Op's C code. "
13219 "No Python exception was set.");
13220 }
13221 goto __label_214;}
13222 }
13223 // We expect NPY_FLOAT64
13224 if (!PyArray_ISALIGNED((PyArrayObject*) py_V213)) {
13225 PyArrayObject * tmp = (PyArrayObject*) py_V213;
13226 PyErr_Format(PyExc_NotImplementedError,
13227 "expected an aligned array of type %ld "
13228 "(NPY_FLOAT64), got non-aligned array of type %ld"
13229 " with %ld dimensions, with 3 last dims "
13230 "%ld, %ld, %ld"
13231 " and 3 last strides %ld %ld, %ld.",
13232 (long int) NPY_FLOAT64,
13233 (long int) PyArray_TYPE((PyArrayObject*) py_V213),
13234 (long int) PyArray_NDIM(tmp),
13235 (long int) (PyArray_NDIM(tmp) >= 3 ?
13236 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
13237 (long int) (PyArray_NDIM(tmp) >= 2 ?
13238 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
13239 (long int) (PyArray_NDIM(tmp) >= 1 ?
13240 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
13241 (long int) (PyArray_NDIM(tmp) >= 3 ?
13242 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
13243 (long int) (PyArray_NDIM(tmp) >= 2 ?
13244 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
13245 (long int) (PyArray_NDIM(tmp) >= 1 ?
13246 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
13247 );
13248 {
13249 __failure = 214;
13250 if (!PyErr_Occurred()) {
13251 PyErr_SetString(PyExc_RuntimeError,
13252 "Unexpected error in an Op's C code. "
13253 "No Python exception was set.");
13254 }
13255 goto __label_214;}
13256 }
13257 // This is a TypeError to be consistent with DEBUG_MODE
13258 // Note: DEBUG_MODE also tells the name of the container
13259 if (PyArray_TYPE((PyArrayObject*) py_V213) != NPY_FLOAT64) {
13260 PyErr_Format(PyExc_TypeError,
13261 "expected type_num %d (NPY_FLOAT64) got %d",
13262 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V213));
13263 {
13264 __failure = 214;
13265 if (!PyErr_Occurred()) {
13266 PyErr_SetString(PyExc_RuntimeError,
13267 "Unexpected error in an Op's C code. "
13268 "No Python exception was set.");
13269 }
13270 goto __label_214;}
13271 }
13272
13273 V213 = (PyArrayObject*)(py_V213);
13274 Py_XINCREF(V213);
13275
13276 {
13277
13278 py_V215 = PyList_GET_ITEM(storage_V215, 0);
13279 {Py_XINCREF(py_V215);}
13280
13281 V215 = NULL;
13282 if (py_V215 == Py_None) {
13283 // We can either fail here or set V215 to NULL and rely on Ops
13284 // using tensors to handle the NULL case, but if they fail to do so
13285 // they'll end up with nasty segfaults, so this is public service.
13286 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
13287 {
13288 __failure = 216;
13289 if (!PyErr_Occurred()) {
13290 PyErr_SetString(PyExc_RuntimeError,
13291 "Unexpected error in an Op's C code. "
13292 "No Python exception was set.");
13293 }
13294 goto __label_216;}
13295 }
13296 if (!PyArray_Check(py_V215)) {
13297 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
13298 {
13299 __failure = 216;
13300 if (!PyErr_Occurred()) {
13301 PyErr_SetString(PyExc_RuntimeError,
13302 "Unexpected error in an Op's C code. "
13303 "No Python exception was set.");
13304 }
13305 goto __label_216;}
13306 }
13307 // We expect NPY_FLOAT64
13308 if (!PyArray_ISALIGNED((PyArrayObject*) py_V215)) {
13309 PyArrayObject * tmp = (PyArrayObject*) py_V215;
13310 PyErr_Format(PyExc_NotImplementedError,
13311 "expected an aligned array of type %ld "
13312 "(NPY_FLOAT64), got non-aligned array of type %ld"
13313 " with %ld dimensions, with 3 last dims "
13314 "%ld, %ld, %ld"
13315 " and 3 last strides %ld %ld, %ld.",
13316 (long int) NPY_FLOAT64,
13317 (long int) PyArray_TYPE((PyArrayObject*) py_V215),
13318 (long int) PyArray_NDIM(tmp),
13319 (long int) (PyArray_NDIM(tmp) >= 3 ?
13320 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
13321 (long int) (PyArray_NDIM(tmp) >= 2 ?
13322 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
13323 (long int) (PyArray_NDIM(tmp) >= 1 ?
13324 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
13325 (long int) (PyArray_NDIM(tmp) >= 3 ?
13326 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
13327 (long int) (PyArray_NDIM(tmp) >= 2 ?
13328 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
13329 (long int) (PyArray_NDIM(tmp) >= 1 ?
13330 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
13331 );
13332 {
13333 __failure = 216;
13334 if (!PyErr_Occurred()) {
13335 PyErr_SetString(PyExc_RuntimeError,
13336 "Unexpected error in an Op's C code. "
13337 "No Python exception was set.");
13338 }
13339 goto __label_216;}
13340 }
13341 // This is a TypeError to be consistent with DEBUG_MODE
13342 // Note: DEBUG_MODE also tells the name of the container
13343 if (PyArray_TYPE((PyArrayObject*) py_V215) != NPY_FLOAT64) {
13344 PyErr_Format(PyExc_TypeError,
13345 "expected type_num %d (NPY_FLOAT64) got %d",
13346 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V215));
13347 {
13348 __failure = 216;
13349 if (!PyErr_Occurred()) {
13350 PyErr_SetString(PyExc_RuntimeError,
13351 "Unexpected error in an Op's C code. "
13352 "No Python exception was set.");
13353 }
13354 goto __label_216;}
13355 }
13356
13357 V215 = (PyArrayObject*)(py_V215);
13358 Py_XINCREF(V215);
13359
13360 {
13361
13362 py_V217 = PyList_GET_ITEM(storage_V217, 0);
13363 {Py_XINCREF(py_V217);}
13364
13365 V217 = NULL;
13366 if (py_V217 == Py_None) {
13367 // We can either fail here or set V217 to NULL and rely on Ops
13368 // using tensors to handle the NULL case, but if they fail to do so
13369 // they'll end up with nasty segfaults, so this is public service.
13370 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
13371 {
13372 __failure = 218;
13373 if (!PyErr_Occurred()) {
13374 PyErr_SetString(PyExc_RuntimeError,
13375 "Unexpected error in an Op's C code. "
13376 "No Python exception was set.");
13377 }
13378 goto __label_218;}
13379 }
13380 if (!PyArray_Check(py_V217)) {
13381 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
13382 {
13383 __failure = 218;
13384 if (!PyErr_Occurred()) {
13385 PyErr_SetString(PyExc_RuntimeError,
13386 "Unexpected error in an Op's C code. "
13387 "No Python exception was set.");
13388 }
13389 goto __label_218;}
13390 }
13391 // We expect NPY_FLOAT64
13392 if (!PyArray_ISALIGNED((PyArrayObject*) py_V217)) {
13393 PyArrayObject * tmp = (PyArrayObject*) py_V217;
13394 PyErr_Format(PyExc_NotImplementedError,
13395 "expected an aligned array of type %ld "
13396 "(NPY_FLOAT64), got non-aligned array of type %ld"
13397 " with %ld dimensions, with 3 last dims "
13398 "%ld, %ld, %ld"
13399 " and 3 last strides %ld %ld, %ld.",
13400 (long int) NPY_FLOAT64,
13401 (long int) PyArray_TYPE((PyArrayObject*) py_V217),
13402 (long int) PyArray_NDIM(tmp),
13403 (long int) (PyArray_NDIM(tmp) >= 3 ?
13404 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
13405 (long int) (PyArray_NDIM(tmp) >= 2 ?
13406 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
13407 (long int) (PyArray_NDIM(tmp) >= 1 ?
13408 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
13409 (long int) (PyArray_NDIM(tmp) >= 3 ?
13410 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
13411 (long int) (PyArray_NDIM(tmp) >= 2 ?
13412 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
13413 (long int) (PyArray_NDIM(tmp) >= 1 ?
13414 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
13415 );
13416 {
13417 __failure = 218;
13418 if (!PyErr_Occurred()) {
13419 PyErr_SetString(PyExc_RuntimeError,
13420 "Unexpected error in an Op's C code. "
13421 "No Python exception was set.");
13422 }
13423 goto __label_218;}
13424 }
13425 // This is a TypeError to be consistent with DEBUG_MODE
13426 // Note: DEBUG_MODE also tells the name of the container
13427 if (PyArray_TYPE((PyArrayObject*) py_V217) != NPY_FLOAT64) {
13428 PyErr_Format(PyExc_TypeError,
13429 "expected type_num %d (NPY_FLOAT64) got %d",
13430 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V217));
13431 {
13432 __failure = 218;
13433 if (!PyErr_Occurred()) {
13434 PyErr_SetString(PyExc_RuntimeError,
13435 "Unexpected error in an Op's C code. "
13436 "No Python exception was set.");
13437 }
13438 goto __label_218;}
13439 }
13440
13441 V217 = (PyArrayObject*)(py_V217);
13442 Py_XINCREF(V217);
13443
13444 {
13445
13446 py_V219 = PyList_GET_ITEM(storage_V219, 0);
13447 {Py_XINCREF(py_V219);}
13448
13449 V219 = NULL;
13450 if (py_V219 == Py_None) {
13451 // We can either fail here or set V219 to NULL and rely on Ops
13452 // using tensors to handle the NULL case, but if they fail to do so
13453 // they'll end up with nasty segfaults, so this is public service.
13454 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
13455 {
13456 __failure = 220;
13457 if (!PyErr_Occurred()) {
13458 PyErr_SetString(PyExc_RuntimeError,
13459 "Unexpected error in an Op's C code. "
13460 "No Python exception was set.");
13461 }
13462 goto __label_220;}
13463 }
13464 if (!PyArray_Check(py_V219)) {
13465 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
13466 {
13467 __failure = 220;
13468 if (!PyErr_Occurred()) {
13469 PyErr_SetString(PyExc_RuntimeError,
13470 "Unexpected error in an Op's C code. "
13471 "No Python exception was set.");
13472 }
13473 goto __label_220;}
13474 }
13475 // We expect NPY_FLOAT64
13476 if (!PyArray_ISALIGNED((PyArrayObject*) py_V219)) {
13477 PyArrayObject * tmp = (PyArrayObject*) py_V219;
13478 PyErr_Format(PyExc_NotImplementedError,
13479 "expected an aligned array of type %ld "
13480 "(NPY_FLOAT64), got non-aligned array of type %ld"
13481 " with %ld dimensions, with 3 last dims "
13482 "%ld, %ld, %ld"
13483 " and 3 last strides %ld %ld, %ld.",
13484 (long int) NPY_FLOAT64,
13485 (long int) PyArray_TYPE((PyArrayObject*) py_V219),
13486 (long int) PyArray_NDIM(tmp),
13487 (long int) (PyArray_NDIM(tmp) >= 3 ?
13488 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
13489 (long int) (PyArray_NDIM(tmp) >= 2 ?
13490 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
13491 (long int) (PyArray_NDIM(tmp) >= 1 ?
13492 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
13493 (long int) (PyArray_NDIM(tmp) >= 3 ?
13494 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
13495 (long int) (PyArray_NDIM(tmp) >= 2 ?
13496 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
13497 (long int) (PyArray_NDIM(tmp) >= 1 ?
13498 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
13499 );
13500 {
13501 __failure = 220;
13502 if (!PyErr_Occurred()) {
13503 PyErr_SetString(PyExc_RuntimeError,
13504 "Unexpected error in an Op's C code. "
13505 "No Python exception was set.");
13506 }
13507 goto __label_220;}
13508 }
13509 // This is a TypeError to be consistent with DEBUG_MODE
13510 // Note: DEBUG_MODE also tells the name of the container
13511 if (PyArray_TYPE((PyArrayObject*) py_V219) != NPY_FLOAT64) {
13512 PyErr_Format(PyExc_TypeError,
13513 "expected type_num %d (NPY_FLOAT64) got %d",
13514 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V219));
13515 {
13516 __failure = 220;
13517 if (!PyErr_Occurred()) {
13518 PyErr_SetString(PyExc_RuntimeError,
13519 "Unexpected error in an Op's C code. "
13520 "No Python exception was set.");
13521 }
13522 goto __label_220;}
13523 }
13524
13525 V219 = (PyArrayObject*)(py_V219);
13526 Py_XINCREF(V219);
13527
13528 {
13529
13530 py_V221 = PyList_GET_ITEM(storage_V221, 0);
13531 {Py_XINCREF(py_V221);}
13532
13533 V221 = NULL;
13534 if (py_V221 == Py_None) {
13535 // We can either fail here or set V221 to NULL and rely on Ops
13536 // using tensors to handle the NULL case, but if they fail to do so
13537 // they'll end up with nasty segfaults, so this is public service.
13538 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
13539 {
13540 __failure = 222;
13541 if (!PyErr_Occurred()) {
13542 PyErr_SetString(PyExc_RuntimeError,
13543 "Unexpected error in an Op's C code. "
13544 "No Python exception was set.");
13545 }
13546 goto __label_222;}
13547 }
13548 if (!PyArray_Check(py_V221)) {
13549 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
13550 {
13551 __failure = 222;
13552 if (!PyErr_Occurred()) {
13553 PyErr_SetString(PyExc_RuntimeError,
13554 "Unexpected error in an Op's C code. "
13555 "No Python exception was set.");
13556 }
13557 goto __label_222;}
13558 }
13559 // We expect NPY_FLOAT64
13560 if (!PyArray_ISALIGNED((PyArrayObject*) py_V221)) {
13561 PyArrayObject * tmp = (PyArrayObject*) py_V221;
13562 PyErr_Format(PyExc_NotImplementedError,
13563 "expected an aligned array of type %ld "
13564 "(NPY_FLOAT64), got non-aligned array of type %ld"
13565 " with %ld dimensions, with 3 last dims "
13566 "%ld, %ld, %ld"
13567 " and 3 last strides %ld %ld, %ld.",
13568 (long int) NPY_FLOAT64,
13569 (long int) PyArray_TYPE((PyArrayObject*) py_V221),
13570 (long int) PyArray_NDIM(tmp),
13571 (long int) (PyArray_NDIM(tmp) >= 3 ?
13572 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
13573 (long int) (PyArray_NDIM(tmp) >= 2 ?
13574 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
13575 (long int) (PyArray_NDIM(tmp) >= 1 ?
13576 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
13577 (long int) (PyArray_NDIM(tmp) >= 3 ?
13578 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
13579 (long int) (PyArray_NDIM(tmp) >= 2 ?
13580 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
13581 (long int) (PyArray_NDIM(tmp) >= 1 ?
13582 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
13583 );
13584 {
13585 __failure = 222;
13586 if (!PyErr_Occurred()) {
13587 PyErr_SetString(PyExc_RuntimeError,
13588 "Unexpected error in an Op's C code. "
13589 "No Python exception was set.");
13590 }
13591 goto __label_222;}
13592 }
13593 // This is a TypeError to be consistent with DEBUG_MODE
13594 // Note: DEBUG_MODE also tells the name of the container
13595 if (PyArray_TYPE((PyArrayObject*) py_V221) != NPY_FLOAT64) {
13596 PyErr_Format(PyExc_TypeError,
13597 "expected type_num %d (NPY_FLOAT64) got %d",
13598 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V221));
13599 {
13600 __failure = 222;
13601 if (!PyErr_Occurred()) {
13602 PyErr_SetString(PyExc_RuntimeError,
13603 "Unexpected error in an Op's C code. "
13604 "No Python exception was set.");
13605 }
13606 goto __label_222;}
13607 }
13608
13609 V221 = (PyArrayObject*)(py_V221);
13610 Py_XINCREF(V221);
13611
13612 {
13613
13614 py_V223 = PyList_GET_ITEM(storage_V223, 0);
13615 {Py_XINCREF(py_V223);}
13616
13617 V223 = NULL;
13618 if (py_V223 == Py_None) {
13619 // We can either fail here or set V223 to NULL and rely on Ops
13620 // using tensors to handle the NULL case, but if they fail to do so
13621 // they'll end up with nasty segfaults, so this is public service.
13622 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
13623 {
13624 __failure = 224;
13625 if (!PyErr_Occurred()) {
13626 PyErr_SetString(PyExc_RuntimeError,
13627 "Unexpected error in an Op's C code. "
13628 "No Python exception was set.");
13629 }
13630 goto __label_224;}
13631 }
13632 if (!PyArray_Check(py_V223)) {
13633 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
13634 {
13635 __failure = 224;
13636 if (!PyErr_Occurred()) {
13637 PyErr_SetString(PyExc_RuntimeError,
13638 "Unexpected error in an Op's C code. "
13639 "No Python exception was set.");
13640 }
13641 goto __label_224;}
13642 }
13643 // We expect NPY_FLOAT64
13644 if (!PyArray_ISALIGNED((PyArrayObject*) py_V223)) {
13645 PyArrayObject * tmp = (PyArrayObject*) py_V223;
13646 PyErr_Format(PyExc_NotImplementedError,
13647 "expected an aligned array of type %ld "
13648 "(NPY_FLOAT64), got non-aligned array of type %ld"
13649 " with %ld dimensions, with 3 last dims "
13650 "%ld, %ld, %ld"
13651 " and 3 last strides %ld %ld, %ld.",
13652 (long int) NPY_FLOAT64,
13653 (long int) PyArray_TYPE((PyArrayObject*) py_V223),
13654 (long int) PyArray_NDIM(tmp),
13655 (long int) (PyArray_NDIM(tmp) >= 3 ?
13656 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
13657 (long int) (PyArray_NDIM(tmp) >= 2 ?
13658 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
13659 (long int) (PyArray_NDIM(tmp) >= 1 ?
13660 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
13661 (long int) (PyArray_NDIM(tmp) >= 3 ?
13662 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
13663 (long int) (PyArray_NDIM(tmp) >= 2 ?
13664 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
13665 (long int) (PyArray_NDIM(tmp) >= 1 ?
13666 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
13667 );
13668 {
13669 __failure = 224;
13670 if (!PyErr_Occurred()) {
13671 PyErr_SetString(PyExc_RuntimeError,
13672 "Unexpected error in an Op's C code. "
13673 "No Python exception was set.");
13674 }
13675 goto __label_224;}
13676 }
13677 // This is a TypeError to be consistent with DEBUG_MODE
13678 // Note: DEBUG_MODE also tells the name of the container
13679 if (PyArray_TYPE((PyArrayObject*) py_V223) != NPY_FLOAT64) {
13680 PyErr_Format(PyExc_TypeError,
13681 "expected type_num %d (NPY_FLOAT64) got %d",
13682 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V223));
13683 {
13684 __failure = 224;
13685 if (!PyErr_Occurred()) {
13686 PyErr_SetString(PyExc_RuntimeError,
13687 "Unexpected error in an Op's C code. "
13688 "No Python exception was set.");
13689 }
13690 goto __label_224;}
13691 }
13692
13693 V223 = (PyArrayObject*)(py_V223);
13694 Py_XINCREF(V223);
13695
13696 {
13697
13698 py_V225 = PyList_GET_ITEM(storage_V225, 0);
13699 {Py_XINCREF(py_V225);}
13700
13701 V225 = NULL;
13702 if (py_V225 == Py_None) {
13703 // We can either fail here or set V225 to NULL and rely on Ops
13704 // using tensors to handle the NULL case, but if they fail to do so
13705 // they'll end up with nasty segfaults, so this is public service.
13706 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
13707 {
13708 __failure = 226;
13709 if (!PyErr_Occurred()) {
13710 PyErr_SetString(PyExc_RuntimeError,
13711 "Unexpected error in an Op's C code. "
13712 "No Python exception was set.");
13713 }
13714 goto __label_226;}
13715 }
13716 if (!PyArray_Check(py_V225)) {
13717 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
13718 {
13719 __failure = 226;
13720 if (!PyErr_Occurred()) {
13721 PyErr_SetString(PyExc_RuntimeError,
13722 "Unexpected error in an Op's C code. "
13723 "No Python exception was set.");
13724 }
13725 goto __label_226;}
13726 }
13727 // We expect NPY_FLOAT64
13728 if (!PyArray_ISALIGNED((PyArrayObject*) py_V225)) {
13729 PyArrayObject * tmp = (PyArrayObject*) py_V225;
13730 PyErr_Format(PyExc_NotImplementedError,
13731 "expected an aligned array of type %ld "
13732 "(NPY_FLOAT64), got non-aligned array of type %ld"
13733 " with %ld dimensions, with 3 last dims "
13734 "%ld, %ld, %ld"
13735 " and 3 last strides %ld %ld, %ld.",
13736 (long int) NPY_FLOAT64,
13737 (long int) PyArray_TYPE((PyArrayObject*) py_V225),
13738 (long int) PyArray_NDIM(tmp),
13739 (long int) (PyArray_NDIM(tmp) >= 3 ?
13740 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
13741 (long int) (PyArray_NDIM(tmp) >= 2 ?
13742 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
13743 (long int) (PyArray_NDIM(tmp) >= 1 ?
13744 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
13745 (long int) (PyArray_NDIM(tmp) >= 3 ?
13746 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
13747 (long int) (PyArray_NDIM(tmp) >= 2 ?
13748 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
13749 (long int) (PyArray_NDIM(tmp) >= 1 ?
13750 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
13751 );
13752 {
13753 __failure = 226;
13754 if (!PyErr_Occurred()) {
13755 PyErr_SetString(PyExc_RuntimeError,
13756 "Unexpected error in an Op's C code. "
13757 "No Python exception was set.");
13758 }
13759 goto __label_226;}
13760 }
13761 // This is a TypeError to be consistent with DEBUG_MODE
13762 // Note: DEBUG_MODE also tells the name of the container
13763 if (PyArray_TYPE((PyArrayObject*) py_V225) != NPY_FLOAT64) {
13764 PyErr_Format(PyExc_TypeError,
13765 "expected type_num %d (NPY_FLOAT64) got %d",
13766 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V225));
13767 {
13768 __failure = 226;
13769 if (!PyErr_Occurred()) {
13770 PyErr_SetString(PyExc_RuntimeError,
13771 "Unexpected error in an Op's C code. "
13772 "No Python exception was set.");
13773 }
13774 goto __label_226;}
13775 }
13776
13777 V225 = (PyArrayObject*)(py_V225);
13778 Py_XINCREF(V225);
13779
13780 {
13781
13782 py_V227 = PyList_GET_ITEM(storage_V227, 0);
13783 {Py_XINCREF(py_V227);}
13784
13785 V227 = NULL;
13786 if (py_V227 == Py_None) {
13787 // We can either fail here or set V227 to NULL and rely on Ops
13788 // using tensors to handle the NULL case, but if they fail to do so
13789 // they'll end up with nasty segfaults, so this is public service.
13790 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
13791 {
13792 __failure = 228;
13793 if (!PyErr_Occurred()) {
13794 PyErr_SetString(PyExc_RuntimeError,
13795 "Unexpected error in an Op's C code. "
13796 "No Python exception was set.");
13797 }
13798 goto __label_228;}
13799 }
13800 if (!PyArray_Check(py_V227)) {
13801 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
13802 {
13803 __failure = 228;
13804 if (!PyErr_Occurred()) {
13805 PyErr_SetString(PyExc_RuntimeError,
13806 "Unexpected error in an Op's C code. "
13807 "No Python exception was set.");
13808 }
13809 goto __label_228;}
13810 }
13811 // We expect NPY_FLOAT64
13812 if (!PyArray_ISALIGNED((PyArrayObject*) py_V227)) {
13813 PyArrayObject * tmp = (PyArrayObject*) py_V227;
13814 PyErr_Format(PyExc_NotImplementedError,
13815 "expected an aligned array of type %ld "
13816 "(NPY_FLOAT64), got non-aligned array of type %ld"
13817 " with %ld dimensions, with 3 last dims "
13818 "%ld, %ld, %ld"
13819 " and 3 last strides %ld %ld, %ld.",
13820 (long int) NPY_FLOAT64,
13821 (long int) PyArray_TYPE((PyArrayObject*) py_V227),
13822 (long int) PyArray_NDIM(tmp),
13823 (long int) (PyArray_NDIM(tmp) >= 3 ?
13824 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
13825 (long int) (PyArray_NDIM(tmp) >= 2 ?
13826 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
13827 (long int) (PyArray_NDIM(tmp) >= 1 ?
13828 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
13829 (long int) (PyArray_NDIM(tmp) >= 3 ?
13830 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
13831 (long int) (PyArray_NDIM(tmp) >= 2 ?
13832 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
13833 (long int) (PyArray_NDIM(tmp) >= 1 ?
13834 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
13835 );
13836 {
13837 __failure = 228;
13838 if (!PyErr_Occurred()) {
13839 PyErr_SetString(PyExc_RuntimeError,
13840 "Unexpected error in an Op's C code. "
13841 "No Python exception was set.");
13842 }
13843 goto __label_228;}
13844 }
13845 // This is a TypeError to be consistent with DEBUG_MODE
13846 // Note: DEBUG_MODE also tells the name of the container
13847 if (PyArray_TYPE((PyArrayObject*) py_V227) != NPY_FLOAT64) {
13848 PyErr_Format(PyExc_TypeError,
13849 "expected type_num %d (NPY_FLOAT64) got %d",
13850 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V227));
13851 {
13852 __failure = 228;
13853 if (!PyErr_Occurred()) {
13854 PyErr_SetString(PyExc_RuntimeError,
13855 "Unexpected error in an Op's C code. "
13856 "No Python exception was set.");
13857 }
13858 goto __label_228;}
13859 }
13860
13861 V227 = (PyArrayObject*)(py_V227);
13862 Py_XINCREF(V227);
13863
13864 {
13865
13866 py_V229 = PyList_GET_ITEM(storage_V229, 0);
13867 {Py_XINCREF(py_V229);}
13868
13869 V229 = NULL;
13870 if (py_V229 == Py_None) {
13871 // We can either fail here or set V229 to NULL and rely on Ops
13872 // using tensors to handle the NULL case, but if they fail to do so
13873 // they'll end up with nasty segfaults, so this is public service.
13874 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
13875 {
13876 __failure = 230;
13877 if (!PyErr_Occurred()) {
13878 PyErr_SetString(PyExc_RuntimeError,
13879 "Unexpected error in an Op's C code. "
13880 "No Python exception was set.");
13881 }
13882 goto __label_230;}
13883 }
13884 if (!PyArray_Check(py_V229)) {
13885 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
13886 {
13887 __failure = 230;
13888 if (!PyErr_Occurred()) {
13889 PyErr_SetString(PyExc_RuntimeError,
13890 "Unexpected error in an Op's C code. "
13891 "No Python exception was set.");
13892 }
13893 goto __label_230;}
13894 }
13895 // We expect NPY_FLOAT64
13896 if (!PyArray_ISALIGNED((PyArrayObject*) py_V229)) {
13897 PyArrayObject * tmp = (PyArrayObject*) py_V229;
13898 PyErr_Format(PyExc_NotImplementedError,
13899 "expected an aligned array of type %ld "
13900 "(NPY_FLOAT64), got non-aligned array of type %ld"
13901 " with %ld dimensions, with 3 last dims "
13902 "%ld, %ld, %ld"
13903 " and 3 last strides %ld %ld, %ld.",
13904 (long int) NPY_FLOAT64,
13905 (long int) PyArray_TYPE((PyArrayObject*) py_V229),
13906 (long int) PyArray_NDIM(tmp),
13907 (long int) (PyArray_NDIM(tmp) >= 3 ?
13908 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
13909 (long int) (PyArray_NDIM(tmp) >= 2 ?
13910 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
13911 (long int) (PyArray_NDIM(tmp) >= 1 ?
13912 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
13913 (long int) (PyArray_NDIM(tmp) >= 3 ?
13914 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
13915 (long int) (PyArray_NDIM(tmp) >= 2 ?
13916 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
13917 (long int) (PyArray_NDIM(tmp) >= 1 ?
13918 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
13919 );
13920 {
13921 __failure = 230;
13922 if (!PyErr_Occurred()) {
13923 PyErr_SetString(PyExc_RuntimeError,
13924 "Unexpected error in an Op's C code. "
13925 "No Python exception was set.");
13926 }
13927 goto __label_230;}
13928 }
13929 // This is a TypeError to be consistent with DEBUG_MODE
13930 // Note: DEBUG_MODE also tells the name of the container
13931 if (PyArray_TYPE((PyArrayObject*) py_V229) != NPY_FLOAT64) {
13932 PyErr_Format(PyExc_TypeError,
13933 "expected type_num %d (NPY_FLOAT64) got %d",
13934 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V229));
13935 {
13936 __failure = 230;
13937 if (!PyErr_Occurred()) {
13938 PyErr_SetString(PyExc_RuntimeError,
13939 "Unexpected error in an Op's C code. "
13940 "No Python exception was set.");
13941 }
13942 goto __label_230;}
13943 }
13944
13945 V229 = (PyArrayObject*)(py_V229);
13946 Py_XINCREF(V229);
13947
13948 {
13949
13950 py_V231 = PyList_GET_ITEM(storage_V231, 0);
13951 {Py_XINCREF(py_V231);}
13952
13953 V231 = NULL;
13954 if (py_V231 == Py_None) {
13955 // We can either fail here or set V231 to NULL and rely on Ops
13956 // using tensors to handle the NULL case, but if they fail to do so
13957 // they'll end up with nasty segfaults, so this is public service.
13958 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
13959 {
13960 __failure = 232;
13961 if (!PyErr_Occurred()) {
13962 PyErr_SetString(PyExc_RuntimeError,
13963 "Unexpected error in an Op's C code. "
13964 "No Python exception was set.");
13965 }
13966 goto __label_232;}
13967 }
13968 if (!PyArray_Check(py_V231)) {
13969 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
13970 {
13971 __failure = 232;
13972 if (!PyErr_Occurred()) {
13973 PyErr_SetString(PyExc_RuntimeError,
13974 "Unexpected error in an Op's C code. "
13975 "No Python exception was set.");
13976 }
13977 goto __label_232;}
13978 }
13979 // We expect NPY_FLOAT64
13980 if (!PyArray_ISALIGNED((PyArrayObject*) py_V231)) {
13981 PyArrayObject * tmp = (PyArrayObject*) py_V231;
13982 PyErr_Format(PyExc_NotImplementedError,
13983 "expected an aligned array of type %ld "
13984 "(NPY_FLOAT64), got non-aligned array of type %ld"
13985 " with %ld dimensions, with 3 last dims "
13986 "%ld, %ld, %ld"
13987 " and 3 last strides %ld %ld, %ld.",
13988 (long int) NPY_FLOAT64,
13989 (long int) PyArray_TYPE((PyArrayObject*) py_V231),
13990 (long int) PyArray_NDIM(tmp),
13991 (long int) (PyArray_NDIM(tmp) >= 3 ?
13992 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
13993 (long int) (PyArray_NDIM(tmp) >= 2 ?
13994 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
13995 (long int) (PyArray_NDIM(tmp) >= 1 ?
13996 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
13997 (long int) (PyArray_NDIM(tmp) >= 3 ?
13998 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
13999 (long int) (PyArray_NDIM(tmp) >= 2 ?
14000 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
14001 (long int) (PyArray_NDIM(tmp) >= 1 ?
14002 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
14003 );
14004 {
14005 __failure = 232;
14006 if (!PyErr_Occurred()) {
14007 PyErr_SetString(PyExc_RuntimeError,
14008 "Unexpected error in an Op's C code. "
14009 "No Python exception was set.");
14010 }
14011 goto __label_232;}
14012 }
14013 // This is a TypeError to be consistent with DEBUG_MODE
14014 // Note: DEBUG_MODE also tells the name of the container
14015 if (PyArray_TYPE((PyArrayObject*) py_V231) != NPY_FLOAT64) {
14016 PyErr_Format(PyExc_TypeError,
14017 "expected type_num %d (NPY_FLOAT64) got %d",
14018 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V231));
14019 {
14020 __failure = 232;
14021 if (!PyErr_Occurred()) {
14022 PyErr_SetString(PyExc_RuntimeError,
14023 "Unexpected error in an Op's C code. "
14024 "No Python exception was set.");
14025 }
14026 goto __label_232;}
14027 }
14028
14029 V231 = (PyArrayObject*)(py_V231);
14030 Py_XINCREF(V231);
14031
14032 {
14033
14034 py_V233 = PyList_GET_ITEM(storage_V233, 0);
14035 {Py_XINCREF(py_V233);}
14036
14037 V233 = NULL;
14038 if (py_V233 == Py_None) {
14039 // We can either fail here or set V233 to NULL and rely on Ops
14040 // using tensors to handle the NULL case, but if they fail to do so
14041 // they'll end up with nasty segfaults, so this is public service.
14042 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
14043 {
14044 __failure = 234;
14045 if (!PyErr_Occurred()) {
14046 PyErr_SetString(PyExc_RuntimeError,
14047 "Unexpected error in an Op's C code. "
14048 "No Python exception was set.");
14049 }
14050 goto __label_234;}
14051 }
14052 if (!PyArray_Check(py_V233)) {
14053 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
14054 {
14055 __failure = 234;
14056 if (!PyErr_Occurred()) {
14057 PyErr_SetString(PyExc_RuntimeError,
14058 "Unexpected error in an Op's C code. "
14059 "No Python exception was set.");
14060 }
14061 goto __label_234;}
14062 }
14063 // We expect NPY_FLOAT64
14064 if (!PyArray_ISALIGNED((PyArrayObject*) py_V233)) {
14065 PyArrayObject * tmp = (PyArrayObject*) py_V233;
14066 PyErr_Format(PyExc_NotImplementedError,
14067 "expected an aligned array of type %ld "
14068 "(NPY_FLOAT64), got non-aligned array of type %ld"
14069 " with %ld dimensions, with 3 last dims "
14070 "%ld, %ld, %ld"
14071 " and 3 last strides %ld %ld, %ld.",
14072 (long int) NPY_FLOAT64,
14073 (long int) PyArray_TYPE((PyArrayObject*) py_V233),
14074 (long int) PyArray_NDIM(tmp),
14075 (long int) (PyArray_NDIM(tmp) >= 3 ?
14076 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
14077 (long int) (PyArray_NDIM(tmp) >= 2 ?
14078 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
14079 (long int) (PyArray_NDIM(tmp) >= 1 ?
14080 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
14081 (long int) (PyArray_NDIM(tmp) >= 3 ?
14082 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
14083 (long int) (PyArray_NDIM(tmp) >= 2 ?
14084 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
14085 (long int) (PyArray_NDIM(tmp) >= 1 ?
14086 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
14087 );
14088 {
14089 __failure = 234;
14090 if (!PyErr_Occurred()) {
14091 PyErr_SetString(PyExc_RuntimeError,
14092 "Unexpected error in an Op's C code. "
14093 "No Python exception was set.");
14094 }
14095 goto __label_234;}
14096 }
14097 // This is a TypeError to be consistent with DEBUG_MODE
14098 // Note: DEBUG_MODE also tells the name of the container
14099 if (PyArray_TYPE((PyArrayObject*) py_V233) != NPY_FLOAT64) {
14100 PyErr_Format(PyExc_TypeError,
14101 "expected type_num %d (NPY_FLOAT64) got %d",
14102 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V233));
14103 {
14104 __failure = 234;
14105 if (!PyErr_Occurred()) {
14106 PyErr_SetString(PyExc_RuntimeError,
14107 "Unexpected error in an Op's C code. "
14108 "No Python exception was set.");
14109 }
14110 goto __label_234;}
14111 }
14112
14113 V233 = (PyArrayObject*)(py_V233);
14114 Py_XINCREF(V233);
14115
14116 {
14117
14118 py_V235 = PyList_GET_ITEM(storage_V235, 0);
14119 {Py_XINCREF(py_V235);}
14120
14121 V235 = NULL;
14122 if (py_V235 == Py_None) {
14123 // We can either fail here or set V235 to NULL and rely on Ops
14124 // using tensors to handle the NULL case, but if they fail to do so
14125 // they'll end up with nasty segfaults, so this is public service.
14126 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
14127 {
14128 __failure = 236;
14129 if (!PyErr_Occurred()) {
14130 PyErr_SetString(PyExc_RuntimeError,
14131 "Unexpected error in an Op's C code. "
14132 "No Python exception was set.");
14133 }
14134 goto __label_236;}
14135 }
14136 if (!PyArray_Check(py_V235)) {
14137 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
14138 {
14139 __failure = 236;
14140 if (!PyErr_Occurred()) {
14141 PyErr_SetString(PyExc_RuntimeError,
14142 "Unexpected error in an Op's C code. "
14143 "No Python exception was set.");
14144 }
14145 goto __label_236;}
14146 }
14147 // We expect NPY_FLOAT64
14148 if (!PyArray_ISALIGNED((PyArrayObject*) py_V235)) {
14149 PyArrayObject * tmp = (PyArrayObject*) py_V235;
14150 PyErr_Format(PyExc_NotImplementedError,
14151 "expected an aligned array of type %ld "
14152 "(NPY_FLOAT64), got non-aligned array of type %ld"
14153 " with %ld dimensions, with 3 last dims "
14154 "%ld, %ld, %ld"
14155 " and 3 last strides %ld %ld, %ld.",
14156 (long int) NPY_FLOAT64,
14157 (long int) PyArray_TYPE((PyArrayObject*) py_V235),
14158 (long int) PyArray_NDIM(tmp),
14159 (long int) (PyArray_NDIM(tmp) >= 3 ?
14160 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
14161 (long int) (PyArray_NDIM(tmp) >= 2 ?
14162 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
14163 (long int) (PyArray_NDIM(tmp) >= 1 ?
14164 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
14165 (long int) (PyArray_NDIM(tmp) >= 3 ?
14166 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
14167 (long int) (PyArray_NDIM(tmp) >= 2 ?
14168 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
14169 (long int) (PyArray_NDIM(tmp) >= 1 ?
14170 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
14171 );
14172 {
14173 __failure = 236;
14174 if (!PyErr_Occurred()) {
14175 PyErr_SetString(PyExc_RuntimeError,
14176 "Unexpected error in an Op's C code. "
14177 "No Python exception was set.");
14178 }
14179 goto __label_236;}
14180 }
14181 // This is a TypeError to be consistent with DEBUG_MODE
14182 // Note: DEBUG_MODE also tells the name of the container
14183 if (PyArray_TYPE((PyArrayObject*) py_V235) != NPY_FLOAT64) {
14184 PyErr_Format(PyExc_TypeError,
14185 "expected type_num %d (NPY_FLOAT64) got %d",
14186 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V235));
14187 {
14188 __failure = 236;
14189 if (!PyErr_Occurred()) {
14190 PyErr_SetString(PyExc_RuntimeError,
14191 "Unexpected error in an Op's C code. "
14192 "No Python exception was set.");
14193 }
14194 goto __label_236;}
14195 }
14196
14197 V235 = (PyArrayObject*)(py_V235);
14198 Py_XINCREF(V235);
14199
14200 {
14201
14202 py_V237 = PyList_GET_ITEM(storage_V237, 0);
14203 {Py_XINCREF(py_V237);}
14204
14205 V237 = NULL;
14206 if (py_V237 == Py_None) {
14207 // We can either fail here or set V237 to NULL and rely on Ops
14208 // using tensors to handle the NULL case, but if they fail to do so
14209 // they'll end up with nasty segfaults, so this is public service.
14210 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
14211 {
14212 __failure = 238;
14213 if (!PyErr_Occurred()) {
14214 PyErr_SetString(PyExc_RuntimeError,
14215 "Unexpected error in an Op's C code. "
14216 "No Python exception was set.");
14217 }
14218 goto __label_238;}
14219 }
14220 if (!PyArray_Check(py_V237)) {
14221 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
14222 {
14223 __failure = 238;
14224 if (!PyErr_Occurred()) {
14225 PyErr_SetString(PyExc_RuntimeError,
14226 "Unexpected error in an Op's C code. "
14227 "No Python exception was set.");
14228 }
14229 goto __label_238;}
14230 }
14231 // We expect NPY_FLOAT64
14232 if (!PyArray_ISALIGNED((PyArrayObject*) py_V237)) {
14233 PyArrayObject * tmp = (PyArrayObject*) py_V237;
14234 PyErr_Format(PyExc_NotImplementedError,
14235 "expected an aligned array of type %ld "
14236 "(NPY_FLOAT64), got non-aligned array of type %ld"
14237 " with %ld dimensions, with 3 last dims "
14238 "%ld, %ld, %ld"
14239 " and 3 last strides %ld %ld, %ld.",
14240 (long int) NPY_FLOAT64,
14241 (long int) PyArray_TYPE((PyArrayObject*) py_V237),
14242 (long int) PyArray_NDIM(tmp),
14243 (long int) (PyArray_NDIM(tmp) >= 3 ?
14244 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
14245 (long int) (PyArray_NDIM(tmp) >= 2 ?
14246 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
14247 (long int) (PyArray_NDIM(tmp) >= 1 ?
14248 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
14249 (long int) (PyArray_NDIM(tmp) >= 3 ?
14250 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
14251 (long int) (PyArray_NDIM(tmp) >= 2 ?
14252 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
14253 (long int) (PyArray_NDIM(tmp) >= 1 ?
14254 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
14255 );
14256 {
14257 __failure = 238;
14258 if (!PyErr_Occurred()) {
14259 PyErr_SetString(PyExc_RuntimeError,
14260 "Unexpected error in an Op's C code. "
14261 "No Python exception was set.");
14262 }
14263 goto __label_238;}
14264 }
14265 // This is a TypeError to be consistent with DEBUG_MODE
14266 // Note: DEBUG_MODE also tells the name of the container
14267 if (PyArray_TYPE((PyArrayObject*) py_V237) != NPY_FLOAT64) {
14268 PyErr_Format(PyExc_TypeError,
14269 "expected type_num %d (NPY_FLOAT64) got %d",
14270 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V237));
14271 {
14272 __failure = 238;
14273 if (!PyErr_Occurred()) {
14274 PyErr_SetString(PyExc_RuntimeError,
14275 "Unexpected error in an Op's C code. "
14276 "No Python exception was set.");
14277 }
14278 goto __label_238;}
14279 }
14280
14281 V237 = (PyArrayObject*)(py_V237);
14282 Py_XINCREF(V237);
14283
14284 {
14285
14286 py_V239 = PyList_GET_ITEM(storage_V239, 0);
14287 {Py_XINCREF(py_V239);}
14288
14289 V239 = NULL;
14290 if (py_V239 == Py_None) {
14291 // We can either fail here or set V239 to NULL and rely on Ops
14292 // using tensors to handle the NULL case, but if they fail to do so
14293 // they'll end up with nasty segfaults, so this is public service.
14294 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
14295 {
14296 __failure = 240;
14297 if (!PyErr_Occurred()) {
14298 PyErr_SetString(PyExc_RuntimeError,
14299 "Unexpected error in an Op's C code. "
14300 "No Python exception was set.");
14301 }
14302 goto __label_240;}
14303 }
14304 if (!PyArray_Check(py_V239)) {
14305 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
14306 {
14307 __failure = 240;
14308 if (!PyErr_Occurred()) {
14309 PyErr_SetString(PyExc_RuntimeError,
14310 "Unexpected error in an Op's C code. "
14311 "No Python exception was set.");
14312 }
14313 goto __label_240;}
14314 }
14315 // We expect NPY_FLOAT64
14316 if (!PyArray_ISALIGNED((PyArrayObject*) py_V239)) {
14317 PyArrayObject * tmp = (PyArrayObject*) py_V239;
14318 PyErr_Format(PyExc_NotImplementedError,
14319 "expected an aligned array of type %ld "
14320 "(NPY_FLOAT64), got non-aligned array of type %ld"
14321 " with %ld dimensions, with 3 last dims "
14322 "%ld, %ld, %ld"
14323 " and 3 last strides %ld %ld, %ld.",
14324 (long int) NPY_FLOAT64,
14325 (long int) PyArray_TYPE((PyArrayObject*) py_V239),
14326 (long int) PyArray_NDIM(tmp),
14327 (long int) (PyArray_NDIM(tmp) >= 3 ?
14328 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
14329 (long int) (PyArray_NDIM(tmp) >= 2 ?
14330 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
14331 (long int) (PyArray_NDIM(tmp) >= 1 ?
14332 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
14333 (long int) (PyArray_NDIM(tmp) >= 3 ?
14334 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
14335 (long int) (PyArray_NDIM(tmp) >= 2 ?
14336 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
14337 (long int) (PyArray_NDIM(tmp) >= 1 ?
14338 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
14339 );
14340 {
14341 __failure = 240;
14342 if (!PyErr_Occurred()) {
14343 PyErr_SetString(PyExc_RuntimeError,
14344 "Unexpected error in an Op's C code. "
14345 "No Python exception was set.");
14346 }
14347 goto __label_240;}
14348 }
14349 // This is a TypeError to be consistent with DEBUG_MODE
14350 // Note: DEBUG_MODE also tells the name of the container
14351 if (PyArray_TYPE((PyArrayObject*) py_V239) != NPY_FLOAT64) {
14352 PyErr_Format(PyExc_TypeError,
14353 "expected type_num %d (NPY_FLOAT64) got %d",
14354 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V239));
14355 {
14356 __failure = 240;
14357 if (!PyErr_Occurred()) {
14358 PyErr_SetString(PyExc_RuntimeError,
14359 "Unexpected error in an Op's C code. "
14360 "No Python exception was set.");
14361 }
14362 goto __label_240;}
14363 }
14364
14365 V239 = (PyArrayObject*)(py_V239);
14366 Py_XINCREF(V239);
14367
14368 {
14369
14370 py_V241 = PyList_GET_ITEM(storage_V241, 0);
14371 {Py_XINCREF(py_V241);}
14372
14373 V241 = NULL;
14374 if (py_V241 == Py_None) {
14375 // We can either fail here or set V241 to NULL and rely on Ops
14376 // using tensors to handle the NULL case, but if they fail to do so
14377 // they'll end up with nasty segfaults, so this is public service.
14378 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
14379 {
14380 __failure = 242;
14381 if (!PyErr_Occurred()) {
14382 PyErr_SetString(PyExc_RuntimeError,
14383 "Unexpected error in an Op's C code. "
14384 "No Python exception was set.");
14385 }
14386 goto __label_242;}
14387 }
14388 if (!PyArray_Check(py_V241)) {
14389 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
14390 {
14391 __failure = 242;
14392 if (!PyErr_Occurred()) {
14393 PyErr_SetString(PyExc_RuntimeError,
14394 "Unexpected error in an Op's C code. "
14395 "No Python exception was set.");
14396 }
14397 goto __label_242;}
14398 }
14399 // We expect NPY_FLOAT64
14400 if (!PyArray_ISALIGNED((PyArrayObject*) py_V241)) {
14401 PyArrayObject * tmp = (PyArrayObject*) py_V241;
14402 PyErr_Format(PyExc_NotImplementedError,
14403 "expected an aligned array of type %ld "
14404 "(NPY_FLOAT64), got non-aligned array of type %ld"
14405 " with %ld dimensions, with 3 last dims "
14406 "%ld, %ld, %ld"
14407 " and 3 last strides %ld %ld, %ld.",
14408 (long int) NPY_FLOAT64,
14409 (long int) PyArray_TYPE((PyArrayObject*) py_V241),
14410 (long int) PyArray_NDIM(tmp),
14411 (long int) (PyArray_NDIM(tmp) >= 3 ?
14412 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
14413 (long int) (PyArray_NDIM(tmp) >= 2 ?
14414 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
14415 (long int) (PyArray_NDIM(tmp) >= 1 ?
14416 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
14417 (long int) (PyArray_NDIM(tmp) >= 3 ?
14418 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
14419 (long int) (PyArray_NDIM(tmp) >= 2 ?
14420 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
14421 (long int) (PyArray_NDIM(tmp) >= 1 ?
14422 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
14423 );
14424 {
14425 __failure = 242;
14426 if (!PyErr_Occurred()) {
14427 PyErr_SetString(PyExc_RuntimeError,
14428 "Unexpected error in an Op's C code. "
14429 "No Python exception was set.");
14430 }
14431 goto __label_242;}
14432 }
14433 // This is a TypeError to be consistent with DEBUG_MODE
14434 // Note: DEBUG_MODE also tells the name of the container
14435 if (PyArray_TYPE((PyArrayObject*) py_V241) != NPY_FLOAT64) {
14436 PyErr_Format(PyExc_TypeError,
14437 "expected type_num %d (NPY_FLOAT64) got %d",
14438 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V241));
14439 {
14440 __failure = 242;
14441 if (!PyErr_Occurred()) {
14442 PyErr_SetString(PyExc_RuntimeError,
14443 "Unexpected error in an Op's C code. "
14444 "No Python exception was set.");
14445 }
14446 goto __label_242;}
14447 }
14448
14449 V241 = (PyArrayObject*)(py_V241);
14450 Py_XINCREF(V241);
14451
14452 {
14453
14454 py_V243 = PyList_GET_ITEM(storage_V243, 0);
14455 {Py_XINCREF(py_V243);}
14456
14457 V243 = NULL;
14458 if (py_V243 == Py_None) {
14459 // We can either fail here or set V243 to NULL and rely on Ops
14460 // using tensors to handle the NULL case, but if they fail to do so
14461 // they'll end up with nasty segfaults, so this is public service.
14462 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
14463 {
14464 __failure = 244;
14465 if (!PyErr_Occurred()) {
14466 PyErr_SetString(PyExc_RuntimeError,
14467 "Unexpected error in an Op's C code. "
14468 "No Python exception was set.");
14469 }
14470 goto __label_244;}
14471 }
14472 if (!PyArray_Check(py_V243)) {
14473 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
14474 {
14475 __failure = 244;
14476 if (!PyErr_Occurred()) {
14477 PyErr_SetString(PyExc_RuntimeError,
14478 "Unexpected error in an Op's C code. "
14479 "No Python exception was set.");
14480 }
14481 goto __label_244;}
14482 }
14483 // We expect NPY_FLOAT64
14484 if (!PyArray_ISALIGNED((PyArrayObject*) py_V243)) {
14485 PyArrayObject * tmp = (PyArrayObject*) py_V243;
14486 PyErr_Format(PyExc_NotImplementedError,
14487 "expected an aligned array of type %ld "
14488 "(NPY_FLOAT64), got non-aligned array of type %ld"
14489 " with %ld dimensions, with 3 last dims "
14490 "%ld, %ld, %ld"
14491 " and 3 last strides %ld %ld, %ld.",
14492 (long int) NPY_FLOAT64,
14493 (long int) PyArray_TYPE((PyArrayObject*) py_V243),
14494 (long int) PyArray_NDIM(tmp),
14495 (long int) (PyArray_NDIM(tmp) >= 3 ?
14496 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
14497 (long int) (PyArray_NDIM(tmp) >= 2 ?
14498 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
14499 (long int) (PyArray_NDIM(tmp) >= 1 ?
14500 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
14501 (long int) (PyArray_NDIM(tmp) >= 3 ?
14502 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
14503 (long int) (PyArray_NDIM(tmp) >= 2 ?
14504 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
14505 (long int) (PyArray_NDIM(tmp) >= 1 ?
14506 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
14507 );
14508 {
14509 __failure = 244;
14510 if (!PyErr_Occurred()) {
14511 PyErr_SetString(PyExc_RuntimeError,
14512 "Unexpected error in an Op's C code. "
14513 "No Python exception was set.");
14514 }
14515 goto __label_244;}
14516 }
14517 // This is a TypeError to be consistent with DEBUG_MODE
14518 // Note: DEBUG_MODE also tells the name of the container
14519 if (PyArray_TYPE((PyArrayObject*) py_V243) != NPY_FLOAT64) {
14520 PyErr_Format(PyExc_TypeError,
14521 "expected type_num %d (NPY_FLOAT64) got %d",
14522 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V243));
14523 {
14524 __failure = 244;
14525 if (!PyErr_Occurred()) {
14526 PyErr_SetString(PyExc_RuntimeError,
14527 "Unexpected error in an Op's C code. "
14528 "No Python exception was set.");
14529 }
14530 goto __label_244;}
14531 }
14532
14533 V243 = (PyArrayObject*)(py_V243);
14534 Py_XINCREF(V243);
14535
14536 {
14537
14538 py_V245 = PyList_GET_ITEM(storage_V245, 0);
14539 {Py_XINCREF(py_V245);}
14540
14541 V245 = NULL;
14542 if (py_V245 == Py_None) {
14543 // We can either fail here or set V245 to NULL and rely on Ops
14544 // using tensors to handle the NULL case, but if they fail to do so
14545 // they'll end up with nasty segfaults, so this is public service.
14546 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
14547 {
14548 __failure = 246;
14549 if (!PyErr_Occurred()) {
14550 PyErr_SetString(PyExc_RuntimeError,
14551 "Unexpected error in an Op's C code. "
14552 "No Python exception was set.");
14553 }
14554 goto __label_246;}
14555 }
14556 if (!PyArray_Check(py_V245)) {
14557 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
14558 {
14559 __failure = 246;
14560 if (!PyErr_Occurred()) {
14561 PyErr_SetString(PyExc_RuntimeError,
14562 "Unexpected error in an Op's C code. "
14563 "No Python exception was set.");
14564 }
14565 goto __label_246;}
14566 }
14567 // We expect NPY_FLOAT64
14568 if (!PyArray_ISALIGNED((PyArrayObject*) py_V245)) {
14569 PyArrayObject * tmp = (PyArrayObject*) py_V245;
14570 PyErr_Format(PyExc_NotImplementedError,
14571 "expected an aligned array of type %ld "
14572 "(NPY_FLOAT64), got non-aligned array of type %ld"
14573 " with %ld dimensions, with 3 last dims "
14574 "%ld, %ld, %ld"
14575 " and 3 last strides %ld %ld, %ld.",
14576 (long int) NPY_FLOAT64,
14577 (long int) PyArray_TYPE((PyArrayObject*) py_V245),
14578 (long int) PyArray_NDIM(tmp),
14579 (long int) (PyArray_NDIM(tmp) >= 3 ?
14580 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
14581 (long int) (PyArray_NDIM(tmp) >= 2 ?
14582 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
14583 (long int) (PyArray_NDIM(tmp) >= 1 ?
14584 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
14585 (long int) (PyArray_NDIM(tmp) >= 3 ?
14586 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
14587 (long int) (PyArray_NDIM(tmp) >= 2 ?
14588 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
14589 (long int) (PyArray_NDIM(tmp) >= 1 ?
14590 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
14591 );
14592 {
14593 __failure = 246;
14594 if (!PyErr_Occurred()) {
14595 PyErr_SetString(PyExc_RuntimeError,
14596 "Unexpected error in an Op's C code. "
14597 "No Python exception was set.");
14598 }
14599 goto __label_246;}
14600 }
14601 // This is a TypeError to be consistent with DEBUG_MODE
14602 // Note: DEBUG_MODE also tells the name of the container
14603 if (PyArray_TYPE((PyArrayObject*) py_V245) != NPY_FLOAT64) {
14604 PyErr_Format(PyExc_TypeError,
14605 "expected type_num %d (NPY_FLOAT64) got %d",
14606 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V245));
14607 {
14608 __failure = 246;
14609 if (!PyErr_Occurred()) {
14610 PyErr_SetString(PyExc_RuntimeError,
14611 "Unexpected error in an Op's C code. "
14612 "No Python exception was set.");
14613 }
14614 goto __label_246;}
14615 }
14616
14617 V245 = (PyArrayObject*)(py_V245);
14618 Py_XINCREF(V245);
14619
14620 {
14621
14622 py_V247 = PyList_GET_ITEM(storage_V247, 0);
14623 {Py_XINCREF(py_V247);}
14624
14625 V247 = NULL;
14626 if (py_V247 == Py_None) {
14627 // We can either fail here or set V247 to NULL and rely on Ops
14628 // using tensors to handle the NULL case, but if they fail to do so
14629 // they'll end up with nasty segfaults, so this is public service.
14630 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
14631 {
14632 __failure = 248;
14633 if (!PyErr_Occurred()) {
14634 PyErr_SetString(PyExc_RuntimeError,
14635 "Unexpected error in an Op's C code. "
14636 "No Python exception was set.");
14637 }
14638 goto __label_248;}
14639 }
14640 if (!PyArray_Check(py_V247)) {
14641 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
14642 {
14643 __failure = 248;
14644 if (!PyErr_Occurred()) {
14645 PyErr_SetString(PyExc_RuntimeError,
14646 "Unexpected error in an Op's C code. "
14647 "No Python exception was set.");
14648 }
14649 goto __label_248;}
14650 }
14651 // We expect NPY_FLOAT64
14652 if (!PyArray_ISALIGNED((PyArrayObject*) py_V247)) {
14653 PyArrayObject * tmp = (PyArrayObject*) py_V247;
14654 PyErr_Format(PyExc_NotImplementedError,
14655 "expected an aligned array of type %ld "
14656 "(NPY_FLOAT64), got non-aligned array of type %ld"
14657 " with %ld dimensions, with 3 last dims "
14658 "%ld, %ld, %ld"
14659 " and 3 last strides %ld %ld, %ld.",
14660 (long int) NPY_FLOAT64,
14661 (long int) PyArray_TYPE((PyArrayObject*) py_V247),
14662 (long int) PyArray_NDIM(tmp),
14663 (long int) (PyArray_NDIM(tmp) >= 3 ?
14664 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
14665 (long int) (PyArray_NDIM(tmp) >= 2 ?
14666 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
14667 (long int) (PyArray_NDIM(tmp) >= 1 ?
14668 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
14669 (long int) (PyArray_NDIM(tmp) >= 3 ?
14670 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
14671 (long int) (PyArray_NDIM(tmp) >= 2 ?
14672 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
14673 (long int) (PyArray_NDIM(tmp) >= 1 ?
14674 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
14675 );
14676 {
14677 __failure = 248;
14678 if (!PyErr_Occurred()) {
14679 PyErr_SetString(PyExc_RuntimeError,
14680 "Unexpected error in an Op's C code. "
14681 "No Python exception was set.");
14682 }
14683 goto __label_248;}
14684 }
14685 // This is a TypeError to be consistent with DEBUG_MODE
14686 // Note: DEBUG_MODE also tells the name of the container
14687 if (PyArray_TYPE((PyArrayObject*) py_V247) != NPY_FLOAT64) {
14688 PyErr_Format(PyExc_TypeError,
14689 "expected type_num %d (NPY_FLOAT64) got %d",
14690 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V247));
14691 {
14692 __failure = 248;
14693 if (!PyErr_Occurred()) {
14694 PyErr_SetString(PyExc_RuntimeError,
14695 "Unexpected error in an Op's C code. "
14696 "No Python exception was set.");
14697 }
14698 goto __label_248;}
14699 }
14700
14701 V247 = (PyArrayObject*)(py_V247);
14702 Py_XINCREF(V247);
14703
14704 {
14705
14706 py_V249 = PyList_GET_ITEM(storage_V249, 0);
14707 {Py_XINCREF(py_V249);}
14708
14709 V249 = NULL;
14710 if (py_V249 == Py_None) {
14711 // We can either fail here or set V249 to NULL and rely on Ops
14712 // using tensors to handle the NULL case, but if they fail to do so
14713 // they'll end up with nasty segfaults, so this is public service.
14714 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
14715 {
14716 __failure = 250;
14717 if (!PyErr_Occurred()) {
14718 PyErr_SetString(PyExc_RuntimeError,
14719 "Unexpected error in an Op's C code. "
14720 "No Python exception was set.");
14721 }
14722 goto __label_250;}
14723 }
14724 if (!PyArray_Check(py_V249)) {
14725 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
14726 {
14727 __failure = 250;
14728 if (!PyErr_Occurred()) {
14729 PyErr_SetString(PyExc_RuntimeError,
14730 "Unexpected error in an Op's C code. "
14731 "No Python exception was set.");
14732 }
14733 goto __label_250;}
14734 }
14735 // We expect NPY_FLOAT64
14736 if (!PyArray_ISALIGNED((PyArrayObject*) py_V249)) {
14737 PyArrayObject * tmp = (PyArrayObject*) py_V249;
14738 PyErr_Format(PyExc_NotImplementedError,
14739 "expected an aligned array of type %ld "
14740 "(NPY_FLOAT64), got non-aligned array of type %ld"
14741 " with %ld dimensions, with 3 last dims "
14742 "%ld, %ld, %ld"
14743 " and 3 last strides %ld %ld, %ld.",
14744 (long int) NPY_FLOAT64,
14745 (long int) PyArray_TYPE((PyArrayObject*) py_V249),
14746 (long int) PyArray_NDIM(tmp),
14747 (long int) (PyArray_NDIM(tmp) >= 3 ?
14748 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
14749 (long int) (PyArray_NDIM(tmp) >= 2 ?
14750 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
14751 (long int) (PyArray_NDIM(tmp) >= 1 ?
14752 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
14753 (long int) (PyArray_NDIM(tmp) >= 3 ?
14754 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
14755 (long int) (PyArray_NDIM(tmp) >= 2 ?
14756 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
14757 (long int) (PyArray_NDIM(tmp) >= 1 ?
14758 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
14759 );
14760 {
14761 __failure = 250;
14762 if (!PyErr_Occurred()) {
14763 PyErr_SetString(PyExc_RuntimeError,
14764 "Unexpected error in an Op's C code. "
14765 "No Python exception was set.");
14766 }
14767 goto __label_250;}
14768 }
14769 // This is a TypeError to be consistent with DEBUG_MODE
14770 // Note: DEBUG_MODE also tells the name of the container
14771 if (PyArray_TYPE((PyArrayObject*) py_V249) != NPY_FLOAT64) {
14772 PyErr_Format(PyExc_TypeError,
14773 "expected type_num %d (NPY_FLOAT64) got %d",
14774 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V249));
14775 {
14776 __failure = 250;
14777 if (!PyErr_Occurred()) {
14778 PyErr_SetString(PyExc_RuntimeError,
14779 "Unexpected error in an Op's C code. "
14780 "No Python exception was set.");
14781 }
14782 goto __label_250;}
14783 }
14784
14785 V249 = (PyArrayObject*)(py_V249);
14786 Py_XINCREF(V249);
14787
14788 {
14789
14790 py_V251 = PyList_GET_ITEM(storage_V251, 0);
14791 {Py_XINCREF(py_V251);}
14792
14793 V251 = NULL;
14794 if (py_V251 == Py_None) {
14795 // We can either fail here or set V251 to NULL and rely on Ops
14796 // using tensors to handle the NULL case, but if they fail to do so
14797 // they'll end up with nasty segfaults, so this is public service.
14798 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
14799 {
14800 __failure = 252;
14801 if (!PyErr_Occurred()) {
14802 PyErr_SetString(PyExc_RuntimeError,
14803 "Unexpected error in an Op's C code. "
14804 "No Python exception was set.");
14805 }
14806 goto __label_252;}
14807 }
14808 if (!PyArray_Check(py_V251)) {
14809 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
14810 {
14811 __failure = 252;
14812 if (!PyErr_Occurred()) {
14813 PyErr_SetString(PyExc_RuntimeError,
14814 "Unexpected error in an Op's C code. "
14815 "No Python exception was set.");
14816 }
14817 goto __label_252;}
14818 }
14819 // We expect NPY_FLOAT64
14820 if (!PyArray_ISALIGNED((PyArrayObject*) py_V251)) {
14821 PyArrayObject * tmp = (PyArrayObject*) py_V251;
14822 PyErr_Format(PyExc_NotImplementedError,
14823 "expected an aligned array of type %ld "
14824 "(NPY_FLOAT64), got non-aligned array of type %ld"
14825 " with %ld dimensions, with 3 last dims "
14826 "%ld, %ld, %ld"
14827 " and 3 last strides %ld %ld, %ld.",
14828 (long int) NPY_FLOAT64,
14829 (long int) PyArray_TYPE((PyArrayObject*) py_V251),
14830 (long int) PyArray_NDIM(tmp),
14831 (long int) (PyArray_NDIM(tmp) >= 3 ?
14832 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
14833 (long int) (PyArray_NDIM(tmp) >= 2 ?
14834 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
14835 (long int) (PyArray_NDIM(tmp) >= 1 ?
14836 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
14837 (long int) (PyArray_NDIM(tmp) >= 3 ?
14838 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
14839 (long int) (PyArray_NDIM(tmp) >= 2 ?
14840 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
14841 (long int) (PyArray_NDIM(tmp) >= 1 ?
14842 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
14843 );
14844 {
14845 __failure = 252;
14846 if (!PyErr_Occurred()) {
14847 PyErr_SetString(PyExc_RuntimeError,
14848 "Unexpected error in an Op's C code. "
14849 "No Python exception was set.");
14850 }
14851 goto __label_252;}
14852 }
14853 // This is a TypeError to be consistent with DEBUG_MODE
14854 // Note: DEBUG_MODE also tells the name of the container
14855 if (PyArray_TYPE((PyArrayObject*) py_V251) != NPY_FLOAT64) {
14856 PyErr_Format(PyExc_TypeError,
14857 "expected type_num %d (NPY_FLOAT64) got %d",
14858 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V251));
14859 {
14860 __failure = 252;
14861 if (!PyErr_Occurred()) {
14862 PyErr_SetString(PyExc_RuntimeError,
14863 "Unexpected error in an Op's C code. "
14864 "No Python exception was set.");
14865 }
14866 goto __label_252;}
14867 }
14868
14869 V251 = (PyArrayObject*)(py_V251);
14870 Py_XINCREF(V251);
14871
14872 {
14873
14874 py_V253 = PyList_GET_ITEM(storage_V253, 0);
14875 {Py_XINCREF(py_V253);}
14876
14877 V253 = NULL;
14878 if (py_V253 == Py_None) {
14879 // We can either fail here or set V253 to NULL and rely on Ops
14880 // using tensors to handle the NULL case, but if they fail to do so
14881 // they'll end up with nasty segfaults, so this is public service.
14882 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
14883 {
14884 __failure = 254;
14885 if (!PyErr_Occurred()) {
14886 PyErr_SetString(PyExc_RuntimeError,
14887 "Unexpected error in an Op's C code. "
14888 "No Python exception was set.");
14889 }
14890 goto __label_254;}
14891 }
14892 if (!PyArray_Check(py_V253)) {
14893 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
14894 {
14895 __failure = 254;
14896 if (!PyErr_Occurred()) {
14897 PyErr_SetString(PyExc_RuntimeError,
14898 "Unexpected error in an Op's C code. "
14899 "No Python exception was set.");
14900 }
14901 goto __label_254;}
14902 }
14903 // We expect NPY_FLOAT64
14904 if (!PyArray_ISALIGNED((PyArrayObject*) py_V253)) {
14905 PyArrayObject * tmp = (PyArrayObject*) py_V253;
14906 PyErr_Format(PyExc_NotImplementedError,
14907 "expected an aligned array of type %ld "
14908 "(NPY_FLOAT64), got non-aligned array of type %ld"
14909 " with %ld dimensions, with 3 last dims "
14910 "%ld, %ld, %ld"
14911 " and 3 last strides %ld %ld, %ld.",
14912 (long int) NPY_FLOAT64,
14913 (long int) PyArray_TYPE((PyArrayObject*) py_V253),
14914 (long int) PyArray_NDIM(tmp),
14915 (long int) (PyArray_NDIM(tmp) >= 3 ?
14916 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
14917 (long int) (PyArray_NDIM(tmp) >= 2 ?
14918 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
14919 (long int) (PyArray_NDIM(tmp) >= 1 ?
14920 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
14921 (long int) (PyArray_NDIM(tmp) >= 3 ?
14922 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
14923 (long int) (PyArray_NDIM(tmp) >= 2 ?
14924 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
14925 (long int) (PyArray_NDIM(tmp) >= 1 ?
14926 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
14927 );
14928 {
14929 __failure = 254;
14930 if (!PyErr_Occurred()) {
14931 PyErr_SetString(PyExc_RuntimeError,
14932 "Unexpected error in an Op's C code. "
14933 "No Python exception was set.");
14934 }
14935 goto __label_254;}
14936 }
14937 // This is a TypeError to be consistent with DEBUG_MODE
14938 // Note: DEBUG_MODE also tells the name of the container
14939 if (PyArray_TYPE((PyArrayObject*) py_V253) != NPY_FLOAT64) {
14940 PyErr_Format(PyExc_TypeError,
14941 "expected type_num %d (NPY_FLOAT64) got %d",
14942 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V253));
14943 {
14944 __failure = 254;
14945 if (!PyErr_Occurred()) {
14946 PyErr_SetString(PyExc_RuntimeError,
14947 "Unexpected error in an Op's C code. "
14948 "No Python exception was set.");
14949 }
14950 goto __label_254;}
14951 }
14952
14953 V253 = (PyArrayObject*)(py_V253);
14954 Py_XINCREF(V253);
14955
14956 {
14957
14958 py_V255 = PyList_GET_ITEM(storage_V255, 0);
14959 {Py_XINCREF(py_V255);}
14960
14961 V255 = NULL;
14962 if (py_V255 == Py_None) {
14963 // We can either fail here or set V255 to NULL and rely on Ops
14964 // using tensors to handle the NULL case, but if they fail to do so
14965 // they'll end up with nasty segfaults, so this is public service.
14966 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
14967 {
14968 __failure = 256;
14969 if (!PyErr_Occurred()) {
14970 PyErr_SetString(PyExc_RuntimeError,
14971 "Unexpected error in an Op's C code. "
14972 "No Python exception was set.");
14973 }
14974 goto __label_256;}
14975 }
14976 if (!PyArray_Check(py_V255)) {
14977 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
14978 {
14979 __failure = 256;
14980 if (!PyErr_Occurred()) {
14981 PyErr_SetString(PyExc_RuntimeError,
14982 "Unexpected error in an Op's C code. "
14983 "No Python exception was set.");
14984 }
14985 goto __label_256;}
14986 }
14987 // We expect NPY_FLOAT64
14988 if (!PyArray_ISALIGNED((PyArrayObject*) py_V255)) {
14989 PyArrayObject * tmp = (PyArrayObject*) py_V255;
14990 PyErr_Format(PyExc_NotImplementedError,
14991 "expected an aligned array of type %ld "
14992 "(NPY_FLOAT64), got non-aligned array of type %ld"
14993 " with %ld dimensions, with 3 last dims "
14994 "%ld, %ld, %ld"
14995 " and 3 last strides %ld %ld, %ld.",
14996 (long int) NPY_FLOAT64,
14997 (long int) PyArray_TYPE((PyArrayObject*) py_V255),
14998 (long int) PyArray_NDIM(tmp),
14999 (long int) (PyArray_NDIM(tmp) >= 3 ?
15000 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
15001 (long int) (PyArray_NDIM(tmp) >= 2 ?
15002 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
15003 (long int) (PyArray_NDIM(tmp) >= 1 ?
15004 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
15005 (long int) (PyArray_NDIM(tmp) >= 3 ?
15006 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
15007 (long int) (PyArray_NDIM(tmp) >= 2 ?
15008 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
15009 (long int) (PyArray_NDIM(tmp) >= 1 ?
15010 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
15011 );
15012 {
15013 __failure = 256;
15014 if (!PyErr_Occurred()) {
15015 PyErr_SetString(PyExc_RuntimeError,
15016 "Unexpected error in an Op's C code. "
15017 "No Python exception was set.");
15018 }
15019 goto __label_256;}
15020 }
15021 // This is a TypeError to be consistent with DEBUG_MODE
15022 // Note: DEBUG_MODE also tells the name of the container
15023 if (PyArray_TYPE((PyArrayObject*) py_V255) != NPY_FLOAT64) {
15024 PyErr_Format(PyExc_TypeError,
15025 "expected type_num %d (NPY_FLOAT64) got %d",
15026 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V255));
15027 {
15028 __failure = 256;
15029 if (!PyErr_Occurred()) {
15030 PyErr_SetString(PyExc_RuntimeError,
15031 "Unexpected error in an Op's C code. "
15032 "No Python exception was set.");
15033 }
15034 goto __label_256;}
15035 }
15036
15037 V255 = (PyArrayObject*)(py_V255);
15038 Py_XINCREF(V255);
15039
15040 {
15041
15042 py_V257 = PyList_GET_ITEM(storage_V257, 0);
15043 {Py_XINCREF(py_V257);}
15044
15045 V257 = NULL;
15046 if (py_V257 == Py_None) {
15047 // We can either fail here or set V257 to NULL and rely on Ops
15048 // using tensors to handle the NULL case, but if they fail to do so
15049 // they'll end up with nasty segfaults, so this is public service.
15050 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
15051 {
15052 __failure = 258;
15053 if (!PyErr_Occurred()) {
15054 PyErr_SetString(PyExc_RuntimeError,
15055 "Unexpected error in an Op's C code. "
15056 "No Python exception was set.");
15057 }
15058 goto __label_258;}
15059 }
15060 if (!PyArray_Check(py_V257)) {
15061 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
15062 {
15063 __failure = 258;
15064 if (!PyErr_Occurred()) {
15065 PyErr_SetString(PyExc_RuntimeError,
15066 "Unexpected error in an Op's C code. "
15067 "No Python exception was set.");
15068 }
15069 goto __label_258;}
15070 }
15071 // We expect NPY_FLOAT64
15072 if (!PyArray_ISALIGNED((PyArrayObject*) py_V257)) {
15073 PyArrayObject * tmp = (PyArrayObject*) py_V257;
15074 PyErr_Format(PyExc_NotImplementedError,
15075 "expected an aligned array of type %ld "
15076 "(NPY_FLOAT64), got non-aligned array of type %ld"
15077 " with %ld dimensions, with 3 last dims "
15078 "%ld, %ld, %ld"
15079 " and 3 last strides %ld %ld, %ld.",
15080 (long int) NPY_FLOAT64,
15081 (long int) PyArray_TYPE((PyArrayObject*) py_V257),
15082 (long int) PyArray_NDIM(tmp),
15083 (long int) (PyArray_NDIM(tmp) >= 3 ?
15084 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
15085 (long int) (PyArray_NDIM(tmp) >= 2 ?
15086 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
15087 (long int) (PyArray_NDIM(tmp) >= 1 ?
15088 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
15089 (long int) (PyArray_NDIM(tmp) >= 3 ?
15090 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
15091 (long int) (PyArray_NDIM(tmp) >= 2 ?
15092 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
15093 (long int) (PyArray_NDIM(tmp) >= 1 ?
15094 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
15095 );
15096 {
15097 __failure = 258;
15098 if (!PyErr_Occurred()) {
15099 PyErr_SetString(PyExc_RuntimeError,
15100 "Unexpected error in an Op's C code. "
15101 "No Python exception was set.");
15102 }
15103 goto __label_258;}
15104 }
15105 // This is a TypeError to be consistent with DEBUG_MODE
15106 // Note: DEBUG_MODE also tells the name of the container
15107 if (PyArray_TYPE((PyArrayObject*) py_V257) != NPY_FLOAT64) {
15108 PyErr_Format(PyExc_TypeError,
15109 "expected type_num %d (NPY_FLOAT64) got %d",
15110 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V257));
15111 {
15112 __failure = 258;
15113 if (!PyErr_Occurred()) {
15114 PyErr_SetString(PyExc_RuntimeError,
15115 "Unexpected error in an Op's C code. "
15116 "No Python exception was set.");
15117 }
15118 goto __label_258;}
15119 }
15120
15121 V257 = (PyArrayObject*)(py_V257);
15122 Py_XINCREF(V257);
15123
15124 {
15125
15126 py_V259 = PyList_GET_ITEM(storage_V259, 0);
15127 {Py_XINCREF(py_V259);}
15128
15129 V259 = NULL;
15130 if (py_V259 == Py_None) {
15131 // We can either fail here or set V259 to NULL and rely on Ops
15132 // using tensors to handle the NULL case, but if they fail to do so
15133 // they'll end up with nasty segfaults, so this is public service.
15134 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
15135 {
15136 __failure = 260;
15137 if (!PyErr_Occurred()) {
15138 PyErr_SetString(PyExc_RuntimeError,
15139 "Unexpected error in an Op's C code. "
15140 "No Python exception was set.");
15141 }
15142 goto __label_260;}
15143 }
15144 if (!PyArray_Check(py_V259)) {
15145 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
15146 {
15147 __failure = 260;
15148 if (!PyErr_Occurred()) {
15149 PyErr_SetString(PyExc_RuntimeError,
15150 "Unexpected error in an Op's C code. "
15151 "No Python exception was set.");
15152 }
15153 goto __label_260;}
15154 }
15155 // We expect NPY_FLOAT64
15156 if (!PyArray_ISALIGNED((PyArrayObject*) py_V259)) {
15157 PyArrayObject * tmp = (PyArrayObject*) py_V259;
15158 PyErr_Format(PyExc_NotImplementedError,
15159 "expected an aligned array of type %ld "
15160 "(NPY_FLOAT64), got non-aligned array of type %ld"
15161 " with %ld dimensions, with 3 last dims "
15162 "%ld, %ld, %ld"
15163 " and 3 last strides %ld %ld, %ld.",
15164 (long int) NPY_FLOAT64,
15165 (long int) PyArray_TYPE((PyArrayObject*) py_V259),
15166 (long int) PyArray_NDIM(tmp),
15167 (long int) (PyArray_NDIM(tmp) >= 3 ?
15168 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
15169 (long int) (PyArray_NDIM(tmp) >= 2 ?
15170 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
15171 (long int) (PyArray_NDIM(tmp) >= 1 ?
15172 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
15173 (long int) (PyArray_NDIM(tmp) >= 3 ?
15174 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
15175 (long int) (PyArray_NDIM(tmp) >= 2 ?
15176 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
15177 (long int) (PyArray_NDIM(tmp) >= 1 ?
15178 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
15179 );
15180 {
15181 __failure = 260;
15182 if (!PyErr_Occurred()) {
15183 PyErr_SetString(PyExc_RuntimeError,
15184 "Unexpected error in an Op's C code. "
15185 "No Python exception was set.");
15186 }
15187 goto __label_260;}
15188 }
15189 // This is a TypeError to be consistent with DEBUG_MODE
15190 // Note: DEBUG_MODE also tells the name of the container
15191 if (PyArray_TYPE((PyArrayObject*) py_V259) != NPY_FLOAT64) {
15192 PyErr_Format(PyExc_TypeError,
15193 "expected type_num %d (NPY_FLOAT64) got %d",
15194 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V259));
15195 {
15196 __failure = 260;
15197 if (!PyErr_Occurred()) {
15198 PyErr_SetString(PyExc_RuntimeError,
15199 "Unexpected error in an Op's C code. "
15200 "No Python exception was set.");
15201 }
15202 goto __label_260;}
15203 }
15204
15205 V259 = (PyArrayObject*)(py_V259);
15206 Py_XINCREF(V259);
15207
15208 {
15209
15210 py_V261 = PyList_GET_ITEM(storage_V261, 0);
15211 {Py_XINCREF(py_V261);}
15212
15213 V261 = NULL;
15214 if (py_V261 == Py_None) {
15215 // We can either fail here or set V261 to NULL and rely on Ops
15216 // using tensors to handle the NULL case, but if they fail to do so
15217 // they'll end up with nasty segfaults, so this is public service.
15218 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
15219 {
15220 __failure = 262;
15221 if (!PyErr_Occurred()) {
15222 PyErr_SetString(PyExc_RuntimeError,
15223 "Unexpected error in an Op's C code. "
15224 "No Python exception was set.");
15225 }
15226 goto __label_262;}
15227 }
15228 if (!PyArray_Check(py_V261)) {
15229 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
15230 {
15231 __failure = 262;
15232 if (!PyErr_Occurred()) {
15233 PyErr_SetString(PyExc_RuntimeError,
15234 "Unexpected error in an Op's C code. "
15235 "No Python exception was set.");
15236 }
15237 goto __label_262;}
15238 }
15239 // We expect NPY_FLOAT64
15240 if (!PyArray_ISALIGNED((PyArrayObject*) py_V261)) {
15241 PyArrayObject * tmp = (PyArrayObject*) py_V261;
15242 PyErr_Format(PyExc_NotImplementedError,
15243 "expected an aligned array of type %ld "
15244 "(NPY_FLOAT64), got non-aligned array of type %ld"
15245 " with %ld dimensions, with 3 last dims "
15246 "%ld, %ld, %ld"
15247 " and 3 last strides %ld %ld, %ld.",
15248 (long int) NPY_FLOAT64,
15249 (long int) PyArray_TYPE((PyArrayObject*) py_V261),
15250 (long int) PyArray_NDIM(tmp),
15251 (long int) (PyArray_NDIM(tmp) >= 3 ?
15252 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
15253 (long int) (PyArray_NDIM(tmp) >= 2 ?
15254 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
15255 (long int) (PyArray_NDIM(tmp) >= 1 ?
15256 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
15257 (long int) (PyArray_NDIM(tmp) >= 3 ?
15258 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
15259 (long int) (PyArray_NDIM(tmp) >= 2 ?
15260 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
15261 (long int) (PyArray_NDIM(tmp) >= 1 ?
15262 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
15263 );
15264 {
15265 __failure = 262;
15266 if (!PyErr_Occurred()) {
15267 PyErr_SetString(PyExc_RuntimeError,
15268 "Unexpected error in an Op's C code. "
15269 "No Python exception was set.");
15270 }
15271 goto __label_262;}
15272 }
15273 // This is a TypeError to be consistent with DEBUG_MODE
15274 // Note: DEBUG_MODE also tells the name of the container
15275 if (PyArray_TYPE((PyArrayObject*) py_V261) != NPY_FLOAT64) {
15276 PyErr_Format(PyExc_TypeError,
15277 "expected type_num %d (NPY_FLOAT64) got %d",
15278 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V261));
15279 {
15280 __failure = 262;
15281 if (!PyErr_Occurred()) {
15282 PyErr_SetString(PyExc_RuntimeError,
15283 "Unexpected error in an Op's C code. "
15284 "No Python exception was set.");
15285 }
15286 goto __label_262;}
15287 }
15288
15289 V261 = (PyArrayObject*)(py_V261);
15290 Py_XINCREF(V261);
15291
15292 {
15293
15294 py_V263 = PyList_GET_ITEM(storage_V263, 0);
15295 {Py_XINCREF(py_V263);}
15296
15297 V263 = NULL;
15298 if (py_V263 == Py_None) {
15299 // We can either fail here or set V263 to NULL and rely on Ops
15300 // using tensors to handle the NULL case, but if they fail to do so
15301 // they'll end up with nasty segfaults, so this is public service.
15302 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
15303 {
15304 __failure = 264;
15305 if (!PyErr_Occurred()) {
15306 PyErr_SetString(PyExc_RuntimeError,
15307 "Unexpected error in an Op's C code. "
15308 "No Python exception was set.");
15309 }
15310 goto __label_264;}
15311 }
15312 if (!PyArray_Check(py_V263)) {
15313 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
15314 {
15315 __failure = 264;
15316 if (!PyErr_Occurred()) {
15317 PyErr_SetString(PyExc_RuntimeError,
15318 "Unexpected error in an Op's C code. "
15319 "No Python exception was set.");
15320 }
15321 goto __label_264;}
15322 }
15323 // We expect NPY_FLOAT64
15324 if (!PyArray_ISALIGNED((PyArrayObject*) py_V263)) {
15325 PyArrayObject * tmp = (PyArrayObject*) py_V263;
15326 PyErr_Format(PyExc_NotImplementedError,
15327 "expected an aligned array of type %ld "
15328 "(NPY_FLOAT64), got non-aligned array of type %ld"
15329 " with %ld dimensions, with 3 last dims "
15330 "%ld, %ld, %ld"
15331 " and 3 last strides %ld %ld, %ld.",
15332 (long int) NPY_FLOAT64,
15333 (long int) PyArray_TYPE((PyArrayObject*) py_V263),
15334 (long int) PyArray_NDIM(tmp),
15335 (long int) (PyArray_NDIM(tmp) >= 3 ?
15336 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
15337 (long int) (PyArray_NDIM(tmp) >= 2 ?
15338 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
15339 (long int) (PyArray_NDIM(tmp) >= 1 ?
15340 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
15341 (long int) (PyArray_NDIM(tmp) >= 3 ?
15342 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
15343 (long int) (PyArray_NDIM(tmp) >= 2 ?
15344 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
15345 (long int) (PyArray_NDIM(tmp) >= 1 ?
15346 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
15347 );
15348 {
15349 __failure = 264;
15350 if (!PyErr_Occurred()) {
15351 PyErr_SetString(PyExc_RuntimeError,
15352 "Unexpected error in an Op's C code. "
15353 "No Python exception was set.");
15354 }
15355 goto __label_264;}
15356 }
15357 // This is a TypeError to be consistent with DEBUG_MODE
15358 // Note: DEBUG_MODE also tells the name of the container
15359 if (PyArray_TYPE((PyArrayObject*) py_V263) != NPY_FLOAT64) {
15360 PyErr_Format(PyExc_TypeError,
15361 "expected type_num %d (NPY_FLOAT64) got %d",
15362 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V263));
15363 {
15364 __failure = 264;
15365 if (!PyErr_Occurred()) {
15366 PyErr_SetString(PyExc_RuntimeError,
15367 "Unexpected error in an Op's C code. "
15368 "No Python exception was set.");
15369 }
15370 goto __label_264;}
15371 }
15372
15373 V263 = (PyArrayObject*)(py_V263);
15374 Py_XINCREF(V263);
15375
15376 {
15377
15378 py_V265 = PyList_GET_ITEM(storage_V265, 0);
15379 {Py_XINCREF(py_V265);}
15380
15381 V265 = NULL;
15382 if (py_V265 == Py_None) {
15383 // We can either fail here or set V265 to NULL and rely on Ops
15384 // using tensors to handle the NULL case, but if they fail to do so
15385 // they'll end up with nasty segfaults, so this is public service.
15386 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
15387 {
15388 __failure = 266;
15389 if (!PyErr_Occurred()) {
15390 PyErr_SetString(PyExc_RuntimeError,
15391 "Unexpected error in an Op's C code. "
15392 "No Python exception was set.");
15393 }
15394 goto __label_266;}
15395 }
15396 if (!PyArray_Check(py_V265)) {
15397 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
15398 {
15399 __failure = 266;
15400 if (!PyErr_Occurred()) {
15401 PyErr_SetString(PyExc_RuntimeError,
15402 "Unexpected error in an Op's C code. "
15403 "No Python exception was set.");
15404 }
15405 goto __label_266;}
15406 }
15407 // We expect NPY_FLOAT64
15408 if (!PyArray_ISALIGNED((PyArrayObject*) py_V265)) {
15409 PyArrayObject * tmp = (PyArrayObject*) py_V265;
15410 PyErr_Format(PyExc_NotImplementedError,
15411 "expected an aligned array of type %ld "
15412 "(NPY_FLOAT64), got non-aligned array of type %ld"
15413 " with %ld dimensions, with 3 last dims "
15414 "%ld, %ld, %ld"
15415 " and 3 last strides %ld %ld, %ld.",
15416 (long int) NPY_FLOAT64,
15417 (long int) PyArray_TYPE((PyArrayObject*) py_V265),
15418 (long int) PyArray_NDIM(tmp),
15419 (long int) (PyArray_NDIM(tmp) >= 3 ?
15420 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
15421 (long int) (PyArray_NDIM(tmp) >= 2 ?
15422 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
15423 (long int) (PyArray_NDIM(tmp) >= 1 ?
15424 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
15425 (long int) (PyArray_NDIM(tmp) >= 3 ?
15426 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
15427 (long int) (PyArray_NDIM(tmp) >= 2 ?
15428 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
15429 (long int) (PyArray_NDIM(tmp) >= 1 ?
15430 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
15431 );
15432 {
15433 __failure = 266;
15434 if (!PyErr_Occurred()) {
15435 PyErr_SetString(PyExc_RuntimeError,
15436 "Unexpected error in an Op's C code. "
15437 "No Python exception was set.");
15438 }
15439 goto __label_266;}
15440 }
15441 // This is a TypeError to be consistent with DEBUG_MODE
15442 // Note: DEBUG_MODE also tells the name of the container
15443 if (PyArray_TYPE((PyArrayObject*) py_V265) != NPY_FLOAT64) {
15444 PyErr_Format(PyExc_TypeError,
15445 "expected type_num %d (NPY_FLOAT64) got %d",
15446 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V265));
15447 {
15448 __failure = 266;
15449 if (!PyErr_Occurred()) {
15450 PyErr_SetString(PyExc_RuntimeError,
15451 "Unexpected error in an Op's C code. "
15452 "No Python exception was set.");
15453 }
15454 goto __label_266;}
15455 }
15456
15457 V265 = (PyArrayObject*)(py_V265);
15458 Py_XINCREF(V265);
15459
15460 {
15461
15462 py_V267 = PyList_GET_ITEM(storage_V267, 0);
15463 {Py_XINCREF(py_V267);}
15464
15465 V267 = NULL;
15466 if (py_V267 == Py_None) {
15467 // We can either fail here or set V267 to NULL and rely on Ops
15468 // using tensors to handle the NULL case, but if they fail to do so
15469 // they'll end up with nasty segfaults, so this is public service.
15470 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
15471 {
15472 __failure = 268;
15473 if (!PyErr_Occurred()) {
15474 PyErr_SetString(PyExc_RuntimeError,
15475 "Unexpected error in an Op's C code. "
15476 "No Python exception was set.");
15477 }
15478 goto __label_268;}
15479 }
15480 if (!PyArray_Check(py_V267)) {
15481 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
15482 {
15483 __failure = 268;
15484 if (!PyErr_Occurred()) {
15485 PyErr_SetString(PyExc_RuntimeError,
15486 "Unexpected error in an Op's C code. "
15487 "No Python exception was set.");
15488 }
15489 goto __label_268;}
15490 }
15491 // We expect NPY_FLOAT64
15492 if (!PyArray_ISALIGNED((PyArrayObject*) py_V267)) {
15493 PyArrayObject * tmp = (PyArrayObject*) py_V267;
15494 PyErr_Format(PyExc_NotImplementedError,
15495 "expected an aligned array of type %ld "
15496 "(NPY_FLOAT64), got non-aligned array of type %ld"
15497 " with %ld dimensions, with 3 last dims "
15498 "%ld, %ld, %ld"
15499 " and 3 last strides %ld %ld, %ld.",
15500 (long int) NPY_FLOAT64,
15501 (long int) PyArray_TYPE((PyArrayObject*) py_V267),
15502 (long int) PyArray_NDIM(tmp),
15503 (long int) (PyArray_NDIM(tmp) >= 3 ?
15504 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
15505 (long int) (PyArray_NDIM(tmp) >= 2 ?
15506 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
15507 (long int) (PyArray_NDIM(tmp) >= 1 ?
15508 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
15509 (long int) (PyArray_NDIM(tmp) >= 3 ?
15510 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
15511 (long int) (PyArray_NDIM(tmp) >= 2 ?
15512 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
15513 (long int) (PyArray_NDIM(tmp) >= 1 ?
15514 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
15515 );
15516 {
15517 __failure = 268;
15518 if (!PyErr_Occurred()) {
15519 PyErr_SetString(PyExc_RuntimeError,
15520 "Unexpected error in an Op's C code. "
15521 "No Python exception was set.");
15522 }
15523 goto __label_268;}
15524 }
15525 // This is a TypeError to be consistent with DEBUG_MODE
15526 // Note: DEBUG_MODE also tells the name of the container
15527 if (PyArray_TYPE((PyArrayObject*) py_V267) != NPY_FLOAT64) {
15528 PyErr_Format(PyExc_TypeError,
15529 "expected type_num %d (NPY_FLOAT64) got %d",
15530 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V267));
15531 {
15532 __failure = 268;
15533 if (!PyErr_Occurred()) {
15534 PyErr_SetString(PyExc_RuntimeError,
15535 "Unexpected error in an Op's C code. "
15536 "No Python exception was set.");
15537 }
15538 goto __label_268;}
15539 }
15540
15541 V267 = (PyArrayObject*)(py_V267);
15542 Py_XINCREF(V267);
15543
15544 {
15545
15546 py_V269 = PyList_GET_ITEM(storage_V269, 0);
15547 {Py_XINCREF(py_V269);}
15548
15549 V269 = NULL;
15550 if (py_V269 == Py_None) {
15551 // We can either fail here or set V269 to NULL and rely on Ops
15552 // using tensors to handle the NULL case, but if they fail to do so
15553 // they'll end up with nasty segfaults, so this is public service.
15554 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
15555 {
15556 __failure = 270;
15557 if (!PyErr_Occurred()) {
15558 PyErr_SetString(PyExc_RuntimeError,
15559 "Unexpected error in an Op's C code. "
15560 "No Python exception was set.");
15561 }
15562 goto __label_270;}
15563 }
15564 if (!PyArray_Check(py_V269)) {
15565 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
15566 {
15567 __failure = 270;
15568 if (!PyErr_Occurred()) {
15569 PyErr_SetString(PyExc_RuntimeError,
15570 "Unexpected error in an Op's C code. "
15571 "No Python exception was set.");
15572 }
15573 goto __label_270;}
15574 }
15575 // We expect NPY_FLOAT64
15576 if (!PyArray_ISALIGNED((PyArrayObject*) py_V269)) {
15577 PyArrayObject * tmp = (PyArrayObject*) py_V269;
15578 PyErr_Format(PyExc_NotImplementedError,
15579 "expected an aligned array of type %ld "
15580 "(NPY_FLOAT64), got non-aligned array of type %ld"
15581 " with %ld dimensions, with 3 last dims "
15582 "%ld, %ld, %ld"
15583 " and 3 last strides %ld %ld, %ld.",
15584 (long int) NPY_FLOAT64,
15585 (long int) PyArray_TYPE((PyArrayObject*) py_V269),
15586 (long int) PyArray_NDIM(tmp),
15587 (long int) (PyArray_NDIM(tmp) >= 3 ?
15588 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
15589 (long int) (PyArray_NDIM(tmp) >= 2 ?
15590 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
15591 (long int) (PyArray_NDIM(tmp) >= 1 ?
15592 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
15593 (long int) (PyArray_NDIM(tmp) >= 3 ?
15594 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
15595 (long int) (PyArray_NDIM(tmp) >= 2 ?
15596 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
15597 (long int) (PyArray_NDIM(tmp) >= 1 ?
15598 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
15599 );
15600 {
15601 __failure = 270;
15602 if (!PyErr_Occurred()) {
15603 PyErr_SetString(PyExc_RuntimeError,
15604 "Unexpected error in an Op's C code. "
15605 "No Python exception was set.");
15606 }
15607 goto __label_270;}
15608 }
15609 // This is a TypeError to be consistent with DEBUG_MODE
15610 // Note: DEBUG_MODE also tells the name of the container
15611 if (PyArray_TYPE((PyArrayObject*) py_V269) != NPY_FLOAT64) {
15612 PyErr_Format(PyExc_TypeError,
15613 "expected type_num %d (NPY_FLOAT64) got %d",
15614 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V269));
15615 {
15616 __failure = 270;
15617 if (!PyErr_Occurred()) {
15618 PyErr_SetString(PyExc_RuntimeError,
15619 "Unexpected error in an Op's C code. "
15620 "No Python exception was set.");
15621 }
15622 goto __label_270;}
15623 }
15624
15625 V269 = (PyArrayObject*)(py_V269);
15626 Py_XINCREF(V269);
15627
15628 {
15629
15630 py_V271 = PyList_GET_ITEM(storage_V271, 0);
15631 {Py_XINCREF(py_V271);}
15632
15633 V271 = NULL;
15634 if (py_V271 == Py_None) {
15635 // We can either fail here or set V271 to NULL and rely on Ops
15636 // using tensors to handle the NULL case, but if they fail to do so
15637 // they'll end up with nasty segfaults, so this is public service.
15638 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
15639 {
15640 __failure = 272;
15641 if (!PyErr_Occurred()) {
15642 PyErr_SetString(PyExc_RuntimeError,
15643 "Unexpected error in an Op's C code. "
15644 "No Python exception was set.");
15645 }
15646 goto __label_272;}
15647 }
15648 if (!PyArray_Check(py_V271)) {
15649 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
15650 {
15651 __failure = 272;
15652 if (!PyErr_Occurred()) {
15653 PyErr_SetString(PyExc_RuntimeError,
15654 "Unexpected error in an Op's C code. "
15655 "No Python exception was set.");
15656 }
15657 goto __label_272;}
15658 }
15659 // We expect NPY_FLOAT64
15660 if (!PyArray_ISALIGNED((PyArrayObject*) py_V271)) {
15661 PyArrayObject * tmp = (PyArrayObject*) py_V271;
15662 PyErr_Format(PyExc_NotImplementedError,
15663 "expected an aligned array of type %ld "
15664 "(NPY_FLOAT64), got non-aligned array of type %ld"
15665 " with %ld dimensions, with 3 last dims "
15666 "%ld, %ld, %ld"
15667 " and 3 last strides %ld %ld, %ld.",
15668 (long int) NPY_FLOAT64,
15669 (long int) PyArray_TYPE((PyArrayObject*) py_V271),
15670 (long int) PyArray_NDIM(tmp),
15671 (long int) (PyArray_NDIM(tmp) >= 3 ?
15672 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
15673 (long int) (PyArray_NDIM(tmp) >= 2 ?
15674 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
15675 (long int) (PyArray_NDIM(tmp) >= 1 ?
15676 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
15677 (long int) (PyArray_NDIM(tmp) >= 3 ?
15678 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
15679 (long int) (PyArray_NDIM(tmp) >= 2 ?
15680 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
15681 (long int) (PyArray_NDIM(tmp) >= 1 ?
15682 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
15683 );
15684 {
15685 __failure = 272;
15686 if (!PyErr_Occurred()) {
15687 PyErr_SetString(PyExc_RuntimeError,
15688 "Unexpected error in an Op's C code. "
15689 "No Python exception was set.");
15690 }
15691 goto __label_272;}
15692 }
15693 // This is a TypeError to be consistent with DEBUG_MODE
15694 // Note: DEBUG_MODE also tells the name of the container
15695 if (PyArray_TYPE((PyArrayObject*) py_V271) != NPY_FLOAT64) {
15696 PyErr_Format(PyExc_TypeError,
15697 "expected type_num %d (NPY_FLOAT64) got %d",
15698 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V271));
15699 {
15700 __failure = 272;
15701 if (!PyErr_Occurred()) {
15702 PyErr_SetString(PyExc_RuntimeError,
15703 "Unexpected error in an Op's C code. "
15704 "No Python exception was set.");
15705 }
15706 goto __label_272;}
15707 }
15708
15709 V271 = (PyArrayObject*)(py_V271);
15710 Py_XINCREF(V271);
15711
15712 {
15713
15714 py_V273 = PyList_GET_ITEM(storage_V273, 0);
15715 {Py_XINCREF(py_V273);}
15716
15717 V273 = NULL;
15718 if (py_V273 == Py_None) {
15719 // We can either fail here or set V273 to NULL and rely on Ops
15720 // using tensors to handle the NULL case, but if they fail to do so
15721 // they'll end up with nasty segfaults, so this is public service.
15722 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
15723 {
15724 __failure = 274;
15725 if (!PyErr_Occurred()) {
15726 PyErr_SetString(PyExc_RuntimeError,
15727 "Unexpected error in an Op's C code. "
15728 "No Python exception was set.");
15729 }
15730 goto __label_274;}
15731 }
15732 if (!PyArray_Check(py_V273)) {
15733 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
15734 {
15735 __failure = 274;
15736 if (!PyErr_Occurred()) {
15737 PyErr_SetString(PyExc_RuntimeError,
15738 "Unexpected error in an Op's C code. "
15739 "No Python exception was set.");
15740 }
15741 goto __label_274;}
15742 }
15743 // We expect NPY_FLOAT64
15744 if (!PyArray_ISALIGNED((PyArrayObject*) py_V273)) {
15745 PyArrayObject * tmp = (PyArrayObject*) py_V273;
15746 PyErr_Format(PyExc_NotImplementedError,
15747 "expected an aligned array of type %ld "
15748 "(NPY_FLOAT64), got non-aligned array of type %ld"
15749 " with %ld dimensions, with 3 last dims "
15750 "%ld, %ld, %ld"
15751 " and 3 last strides %ld %ld, %ld.",
15752 (long int) NPY_FLOAT64,
15753 (long int) PyArray_TYPE((PyArrayObject*) py_V273),
15754 (long int) PyArray_NDIM(tmp),
15755 (long int) (PyArray_NDIM(tmp) >= 3 ?
15756 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
15757 (long int) (PyArray_NDIM(tmp) >= 2 ?
15758 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
15759 (long int) (PyArray_NDIM(tmp) >= 1 ?
15760 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
15761 (long int) (PyArray_NDIM(tmp) >= 3 ?
15762 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
15763 (long int) (PyArray_NDIM(tmp) >= 2 ?
15764 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
15765 (long int) (PyArray_NDIM(tmp) >= 1 ?
15766 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
15767 );
15768 {
15769 __failure = 274;
15770 if (!PyErr_Occurred()) {
15771 PyErr_SetString(PyExc_RuntimeError,
15772 "Unexpected error in an Op's C code. "
15773 "No Python exception was set.");
15774 }
15775 goto __label_274;}
15776 }
15777 // This is a TypeError to be consistent with DEBUG_MODE
15778 // Note: DEBUG_MODE also tells the name of the container
15779 if (PyArray_TYPE((PyArrayObject*) py_V273) != NPY_FLOAT64) {
15780 PyErr_Format(PyExc_TypeError,
15781 "expected type_num %d (NPY_FLOAT64) got %d",
15782 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V273));
15783 {
15784 __failure = 274;
15785 if (!PyErr_Occurred()) {
15786 PyErr_SetString(PyExc_RuntimeError,
15787 "Unexpected error in an Op's C code. "
15788 "No Python exception was set.");
15789 }
15790 goto __label_274;}
15791 }
15792
15793 V273 = (PyArrayObject*)(py_V273);
15794 Py_XINCREF(V273);
15795
15796 {
15797
15798 py_V275 = PyList_GET_ITEM(storage_V275, 0);
15799 {Py_XINCREF(py_V275);}
15800
15801 V275 = NULL;
15802 if (py_V275 == Py_None) {
15803 // We can either fail here or set V275 to NULL and rely on Ops
15804 // using tensors to handle the NULL case, but if they fail to do so
15805 // they'll end up with nasty segfaults, so this is public service.
15806 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
15807 {
15808 __failure = 276;
15809 if (!PyErr_Occurred()) {
15810 PyErr_SetString(PyExc_RuntimeError,
15811 "Unexpected error in an Op's C code. "
15812 "No Python exception was set.");
15813 }
15814 goto __label_276;}
15815 }
15816 if (!PyArray_Check(py_V275)) {
15817 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
15818 {
15819 __failure = 276;
15820 if (!PyErr_Occurred()) {
15821 PyErr_SetString(PyExc_RuntimeError,
15822 "Unexpected error in an Op's C code. "
15823 "No Python exception was set.");
15824 }
15825 goto __label_276;}
15826 }
15827 // We expect NPY_FLOAT64
15828 if (!PyArray_ISALIGNED((PyArrayObject*) py_V275)) {
15829 PyArrayObject * tmp = (PyArrayObject*) py_V275;
15830 PyErr_Format(PyExc_NotImplementedError,
15831 "expected an aligned array of type %ld "
15832 "(NPY_FLOAT64), got non-aligned array of type %ld"
15833 " with %ld dimensions, with 3 last dims "
15834 "%ld, %ld, %ld"
15835 " and 3 last strides %ld %ld, %ld.",
15836 (long int) NPY_FLOAT64,
15837 (long int) PyArray_TYPE((PyArrayObject*) py_V275),
15838 (long int) PyArray_NDIM(tmp),
15839 (long int) (PyArray_NDIM(tmp) >= 3 ?
15840 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
15841 (long int) (PyArray_NDIM(tmp) >= 2 ?
15842 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
15843 (long int) (PyArray_NDIM(tmp) >= 1 ?
15844 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
15845 (long int) (PyArray_NDIM(tmp) >= 3 ?
15846 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
15847 (long int) (PyArray_NDIM(tmp) >= 2 ?
15848 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
15849 (long int) (PyArray_NDIM(tmp) >= 1 ?
15850 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
15851 );
15852 {
15853 __failure = 276;
15854 if (!PyErr_Occurred()) {
15855 PyErr_SetString(PyExc_RuntimeError,
15856 "Unexpected error in an Op's C code. "
15857 "No Python exception was set.");
15858 }
15859 goto __label_276;}
15860 }
15861 // This is a TypeError to be consistent with DEBUG_MODE
15862 // Note: DEBUG_MODE also tells the name of the container
15863 if (PyArray_TYPE((PyArrayObject*) py_V275) != NPY_FLOAT64) {
15864 PyErr_Format(PyExc_TypeError,
15865 "expected type_num %d (NPY_FLOAT64) got %d",
15866 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V275));
15867 {
15868 __failure = 276;
15869 if (!PyErr_Occurred()) {
15870 PyErr_SetString(PyExc_RuntimeError,
15871 "Unexpected error in an Op's C code. "
15872 "No Python exception was set.");
15873 }
15874 goto __label_276;}
15875 }
15876
15877 V275 = (PyArrayObject*)(py_V275);
15878 Py_XINCREF(V275);
15879
15880 {
15881
15882 py_V277 = PyList_GET_ITEM(storage_V277, 0);
15883 {Py_XINCREF(py_V277);}
15884
15885 V277 = NULL;
15886 if (py_V277 == Py_None) {
15887 // We can either fail here or set V277 to NULL and rely on Ops
15888 // using tensors to handle the NULL case, but if they fail to do so
15889 // they'll end up with nasty segfaults, so this is public service.
15890 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
15891 {
15892 __failure = 278;
15893 if (!PyErr_Occurred()) {
15894 PyErr_SetString(PyExc_RuntimeError,
15895 "Unexpected error in an Op's C code. "
15896 "No Python exception was set.");
15897 }
15898 goto __label_278;}
15899 }
15900 if (!PyArray_Check(py_V277)) {
15901 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
15902 {
15903 __failure = 278;
15904 if (!PyErr_Occurred()) {
15905 PyErr_SetString(PyExc_RuntimeError,
15906 "Unexpected error in an Op's C code. "
15907 "No Python exception was set.");
15908 }
15909 goto __label_278;}
15910 }
15911 // We expect NPY_FLOAT64
15912 if (!PyArray_ISALIGNED((PyArrayObject*) py_V277)) {
15913 PyArrayObject * tmp = (PyArrayObject*) py_V277;
15914 PyErr_Format(PyExc_NotImplementedError,
15915 "expected an aligned array of type %ld "
15916 "(NPY_FLOAT64), got non-aligned array of type %ld"
15917 " with %ld dimensions, with 3 last dims "
15918 "%ld, %ld, %ld"
15919 " and 3 last strides %ld %ld, %ld.",
15920 (long int) NPY_FLOAT64,
15921 (long int) PyArray_TYPE((PyArrayObject*) py_V277),
15922 (long int) PyArray_NDIM(tmp),
15923 (long int) (PyArray_NDIM(tmp) >= 3 ?
15924 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
15925 (long int) (PyArray_NDIM(tmp) >= 2 ?
15926 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
15927 (long int) (PyArray_NDIM(tmp) >= 1 ?
15928 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
15929 (long int) (PyArray_NDIM(tmp) >= 3 ?
15930 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
15931 (long int) (PyArray_NDIM(tmp) >= 2 ?
15932 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
15933 (long int) (PyArray_NDIM(tmp) >= 1 ?
15934 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
15935 );
15936 {
15937 __failure = 278;
15938 if (!PyErr_Occurred()) {
15939 PyErr_SetString(PyExc_RuntimeError,
15940 "Unexpected error in an Op's C code. "
15941 "No Python exception was set.");
15942 }
15943 goto __label_278;}
15944 }
15945 // This is a TypeError to be consistent with DEBUG_MODE
15946 // Note: DEBUG_MODE also tells the name of the container
15947 if (PyArray_TYPE((PyArrayObject*) py_V277) != NPY_FLOAT64) {
15948 PyErr_Format(PyExc_TypeError,
15949 "expected type_num %d (NPY_FLOAT64) got %d",
15950 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V277));
15951 {
15952 __failure = 278;
15953 if (!PyErr_Occurred()) {
15954 PyErr_SetString(PyExc_RuntimeError,
15955 "Unexpected error in an Op's C code. "
15956 "No Python exception was set.");
15957 }
15958 goto __label_278;}
15959 }
15960
15961 V277 = (PyArrayObject*)(py_V277);
15962 Py_XINCREF(V277);
15963
15964 {
15965
15966 py_V279 = PyList_GET_ITEM(storage_V279, 0);
15967 {Py_XINCREF(py_V279);}
15968
15969 V279 = NULL;
15970 if (py_V279 == Py_None) {
15971 // We can either fail here or set V279 to NULL and rely on Ops
15972 // using tensors to handle the NULL case, but if they fail to do so
15973 // they'll end up with nasty segfaults, so this is public service.
15974 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
15975 {
15976 __failure = 280;
15977 if (!PyErr_Occurred()) {
15978 PyErr_SetString(PyExc_RuntimeError,
15979 "Unexpected error in an Op's C code. "
15980 "No Python exception was set.");
15981 }
15982 goto __label_280;}
15983 }
15984 if (!PyArray_Check(py_V279)) {
15985 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
15986 {
15987 __failure = 280;
15988 if (!PyErr_Occurred()) {
15989 PyErr_SetString(PyExc_RuntimeError,
15990 "Unexpected error in an Op's C code. "
15991 "No Python exception was set.");
15992 }
15993 goto __label_280;}
15994 }
15995 // We expect NPY_FLOAT64
15996 if (!PyArray_ISALIGNED((PyArrayObject*) py_V279)) {
15997 PyArrayObject * tmp = (PyArrayObject*) py_V279;
15998 PyErr_Format(PyExc_NotImplementedError,
15999 "expected an aligned array of type %ld "
16000 "(NPY_FLOAT64), got non-aligned array of type %ld"
16001 " with %ld dimensions, with 3 last dims "
16002 "%ld, %ld, %ld"
16003 " and 3 last strides %ld %ld, %ld.",
16004 (long int) NPY_FLOAT64,
16005 (long int) PyArray_TYPE((PyArrayObject*) py_V279),
16006 (long int) PyArray_NDIM(tmp),
16007 (long int) (PyArray_NDIM(tmp) >= 3 ?
16008 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
16009 (long int) (PyArray_NDIM(tmp) >= 2 ?
16010 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
16011 (long int) (PyArray_NDIM(tmp) >= 1 ?
16012 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
16013 (long int) (PyArray_NDIM(tmp) >= 3 ?
16014 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
16015 (long int) (PyArray_NDIM(tmp) >= 2 ?
16016 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
16017 (long int) (PyArray_NDIM(tmp) >= 1 ?
16018 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
16019 );
16020 {
16021 __failure = 280;
16022 if (!PyErr_Occurred()) {
16023 PyErr_SetString(PyExc_RuntimeError,
16024 "Unexpected error in an Op's C code. "
16025 "No Python exception was set.");
16026 }
16027 goto __label_280;}
16028 }
16029 // This is a TypeError to be consistent with DEBUG_MODE
16030 // Note: DEBUG_MODE also tells the name of the container
16031 if (PyArray_TYPE((PyArrayObject*) py_V279) != NPY_FLOAT64) {
16032 PyErr_Format(PyExc_TypeError,
16033 "expected type_num %d (NPY_FLOAT64) got %d",
16034 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V279));
16035 {
16036 __failure = 280;
16037 if (!PyErr_Occurred()) {
16038 PyErr_SetString(PyExc_RuntimeError,
16039 "Unexpected error in an Op's C code. "
16040 "No Python exception was set.");
16041 }
16042 goto __label_280;}
16043 }
16044
16045 V279 = (PyArrayObject*)(py_V279);
16046 Py_XINCREF(V279);
16047
16048 {
16049
16050 py_V281 = PyList_GET_ITEM(storage_V281, 0);
16051 {Py_XINCREF(py_V281);}
16052
16053 V281 = NULL;
16054 if (py_V281 == Py_None) {
16055 // We can either fail here or set V281 to NULL and rely on Ops
16056 // using tensors to handle the NULL case, but if they fail to do so
16057 // they'll end up with nasty segfaults, so this is public service.
16058 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
16059 {
16060 __failure = 282;
16061 if (!PyErr_Occurred()) {
16062 PyErr_SetString(PyExc_RuntimeError,
16063 "Unexpected error in an Op's C code. "
16064 "No Python exception was set.");
16065 }
16066 goto __label_282;}
16067 }
16068 if (!PyArray_Check(py_V281)) {
16069 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
16070 {
16071 __failure = 282;
16072 if (!PyErr_Occurred()) {
16073 PyErr_SetString(PyExc_RuntimeError,
16074 "Unexpected error in an Op's C code. "
16075 "No Python exception was set.");
16076 }
16077 goto __label_282;}
16078 }
16079 // We expect NPY_FLOAT64
16080 if (!PyArray_ISALIGNED((PyArrayObject*) py_V281)) {
16081 PyArrayObject * tmp = (PyArrayObject*) py_V281;
16082 PyErr_Format(PyExc_NotImplementedError,
16083 "expected an aligned array of type %ld "
16084 "(NPY_FLOAT64), got non-aligned array of type %ld"
16085 " with %ld dimensions, with 3 last dims "
16086 "%ld, %ld, %ld"
16087 " and 3 last strides %ld %ld, %ld.",
16088 (long int) NPY_FLOAT64,
16089 (long int) PyArray_TYPE((PyArrayObject*) py_V281),
16090 (long int) PyArray_NDIM(tmp),
16091 (long int) (PyArray_NDIM(tmp) >= 3 ?
16092 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
16093 (long int) (PyArray_NDIM(tmp) >= 2 ?
16094 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
16095 (long int) (PyArray_NDIM(tmp) >= 1 ?
16096 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
16097 (long int) (PyArray_NDIM(tmp) >= 3 ?
16098 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
16099 (long int) (PyArray_NDIM(tmp) >= 2 ?
16100 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
16101 (long int) (PyArray_NDIM(tmp) >= 1 ?
16102 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
16103 );
16104 {
16105 __failure = 282;
16106 if (!PyErr_Occurred()) {
16107 PyErr_SetString(PyExc_RuntimeError,
16108 "Unexpected error in an Op's C code. "
16109 "No Python exception was set.");
16110 }
16111 goto __label_282;}
16112 }
16113 // This is a TypeError to be consistent with DEBUG_MODE
16114 // Note: DEBUG_MODE also tells the name of the container
16115 if (PyArray_TYPE((PyArrayObject*) py_V281) != NPY_FLOAT64) {
16116 PyErr_Format(PyExc_TypeError,
16117 "expected type_num %d (NPY_FLOAT64) got %d",
16118 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V281));
16119 {
16120 __failure = 282;
16121 if (!PyErr_Occurred()) {
16122 PyErr_SetString(PyExc_RuntimeError,
16123 "Unexpected error in an Op's C code. "
16124 "No Python exception was set.");
16125 }
16126 goto __label_282;}
16127 }
16128
16129 V281 = (PyArrayObject*)(py_V281);
16130 Py_XINCREF(V281);
16131
16132 {
16133
16134 py_V283 = PyList_GET_ITEM(storage_V283, 0);
16135 {Py_XINCREF(py_V283);}
16136
16137 V283 = NULL;
16138 if (py_V283 == Py_None) {
16139 // We can either fail here or set V283 to NULL and rely on Ops
16140 // using tensors to handle the NULL case, but if they fail to do so
16141 // they'll end up with nasty segfaults, so this is public service.
16142 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
16143 {
16144 __failure = 284;
16145 if (!PyErr_Occurred()) {
16146 PyErr_SetString(PyExc_RuntimeError,
16147 "Unexpected error in an Op's C code. "
16148 "No Python exception was set.");
16149 }
16150 goto __label_284;}
16151 }
16152 if (!PyArray_Check(py_V283)) {
16153 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
16154 {
16155 __failure = 284;
16156 if (!PyErr_Occurred()) {
16157 PyErr_SetString(PyExc_RuntimeError,
16158 "Unexpected error in an Op's C code. "
16159 "No Python exception was set.");
16160 }
16161 goto __label_284;}
16162 }
16163 // We expect NPY_FLOAT64
16164 if (!PyArray_ISALIGNED((PyArrayObject*) py_V283)) {
16165 PyArrayObject * tmp = (PyArrayObject*) py_V283;
16166 PyErr_Format(PyExc_NotImplementedError,
16167 "expected an aligned array of type %ld "
16168 "(NPY_FLOAT64), got non-aligned array of type %ld"
16169 " with %ld dimensions, with 3 last dims "
16170 "%ld, %ld, %ld"
16171 " and 3 last strides %ld %ld, %ld.",
16172 (long int) NPY_FLOAT64,
16173 (long int) PyArray_TYPE((PyArrayObject*) py_V283),
16174 (long int) PyArray_NDIM(tmp),
16175 (long int) (PyArray_NDIM(tmp) >= 3 ?
16176 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
16177 (long int) (PyArray_NDIM(tmp) >= 2 ?
16178 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
16179 (long int) (PyArray_NDIM(tmp) >= 1 ?
16180 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
16181 (long int) (PyArray_NDIM(tmp) >= 3 ?
16182 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
16183 (long int) (PyArray_NDIM(tmp) >= 2 ?
16184 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
16185 (long int) (PyArray_NDIM(tmp) >= 1 ?
16186 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
16187 );
16188 {
16189 __failure = 284;
16190 if (!PyErr_Occurred()) {
16191 PyErr_SetString(PyExc_RuntimeError,
16192 "Unexpected error in an Op's C code. "
16193 "No Python exception was set.");
16194 }
16195 goto __label_284;}
16196 }
16197 // This is a TypeError to be consistent with DEBUG_MODE
16198 // Note: DEBUG_MODE also tells the name of the container
16199 if (PyArray_TYPE((PyArrayObject*) py_V283) != NPY_FLOAT64) {
16200 PyErr_Format(PyExc_TypeError,
16201 "expected type_num %d (NPY_FLOAT64) got %d",
16202 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V283));
16203 {
16204 __failure = 284;
16205 if (!PyErr_Occurred()) {
16206 PyErr_SetString(PyExc_RuntimeError,
16207 "Unexpected error in an Op's C code. "
16208 "No Python exception was set.");
16209 }
16210 goto __label_284;}
16211 }
16212
16213 V283 = (PyArrayObject*)(py_V283);
16214 Py_XINCREF(V283);
16215
16216 {
16217
16218 py_V285 = PyList_GET_ITEM(storage_V285, 0);
16219 {Py_XINCREF(py_V285);}
16220
16221 V285 = NULL;
16222 if (py_V285 == Py_None) {
16223 // We can either fail here or set V285 to NULL and rely on Ops
16224 // using tensors to handle the NULL case, but if they fail to do so
16225 // they'll end up with nasty segfaults, so this is public service.
16226 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
16227 {
16228 __failure = 286;
16229 if (!PyErr_Occurred()) {
16230 PyErr_SetString(PyExc_RuntimeError,
16231 "Unexpected error in an Op's C code. "
16232 "No Python exception was set.");
16233 }
16234 goto __label_286;}
16235 }
16236 if (!PyArray_Check(py_V285)) {
16237 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
16238 {
16239 __failure = 286;
16240 if (!PyErr_Occurred()) {
16241 PyErr_SetString(PyExc_RuntimeError,
16242 "Unexpected error in an Op's C code. "
16243 "No Python exception was set.");
16244 }
16245 goto __label_286;}
16246 }
16247 // We expect NPY_FLOAT64
16248 if (!PyArray_ISALIGNED((PyArrayObject*) py_V285)) {
16249 PyArrayObject * tmp = (PyArrayObject*) py_V285;
16250 PyErr_Format(PyExc_NotImplementedError,
16251 "expected an aligned array of type %ld "
16252 "(NPY_FLOAT64), got non-aligned array of type %ld"
16253 " with %ld dimensions, with 3 last dims "
16254 "%ld, %ld, %ld"
16255 " and 3 last strides %ld %ld, %ld.",
16256 (long int) NPY_FLOAT64,
16257 (long int) PyArray_TYPE((PyArrayObject*) py_V285),
16258 (long int) PyArray_NDIM(tmp),
16259 (long int) (PyArray_NDIM(tmp) >= 3 ?
16260 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
16261 (long int) (PyArray_NDIM(tmp) >= 2 ?
16262 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
16263 (long int) (PyArray_NDIM(tmp) >= 1 ?
16264 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
16265 (long int) (PyArray_NDIM(tmp) >= 3 ?
16266 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
16267 (long int) (PyArray_NDIM(tmp) >= 2 ?
16268 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
16269 (long int) (PyArray_NDIM(tmp) >= 1 ?
16270 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
16271 );
16272 {
16273 __failure = 286;
16274 if (!PyErr_Occurred()) {
16275 PyErr_SetString(PyExc_RuntimeError,
16276 "Unexpected error in an Op's C code. "
16277 "No Python exception was set.");
16278 }
16279 goto __label_286;}
16280 }
16281 // This is a TypeError to be consistent with DEBUG_MODE
16282 // Note: DEBUG_MODE also tells the name of the container
16283 if (PyArray_TYPE((PyArrayObject*) py_V285) != NPY_FLOAT64) {
16284 PyErr_Format(PyExc_TypeError,
16285 "expected type_num %d (NPY_FLOAT64) got %d",
16286 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V285));
16287 {
16288 __failure = 286;
16289 if (!PyErr_Occurred()) {
16290 PyErr_SetString(PyExc_RuntimeError,
16291 "Unexpected error in an Op's C code. "
16292 "No Python exception was set.");
16293 }
16294 goto __label_286;}
16295 }
16296
16297 V285 = (PyArrayObject*)(py_V285);
16298 Py_XINCREF(V285);
16299
16300 {
16301
16302 py_V287 = PyList_GET_ITEM(storage_V287, 0);
16303 {Py_XINCREF(py_V287);}
16304
16305 V287 = NULL;
16306 if (py_V287 == Py_None) {
16307 // We can either fail here or set V287 to NULL and rely on Ops
16308 // using tensors to handle the NULL case, but if they fail to do so
16309 // they'll end up with nasty segfaults, so this is public service.
16310 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
16311 {
16312 __failure = 288;
16313 if (!PyErr_Occurred()) {
16314 PyErr_SetString(PyExc_RuntimeError,
16315 "Unexpected error in an Op's C code. "
16316 "No Python exception was set.");
16317 }
16318 goto __label_288;}
16319 }
16320 if (!PyArray_Check(py_V287)) {
16321 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
16322 {
16323 __failure = 288;
16324 if (!PyErr_Occurred()) {
16325 PyErr_SetString(PyExc_RuntimeError,
16326 "Unexpected error in an Op's C code. "
16327 "No Python exception was set.");
16328 }
16329 goto __label_288;}
16330 }
16331 // We expect NPY_FLOAT64
16332 if (!PyArray_ISALIGNED((PyArrayObject*) py_V287)) {
16333 PyArrayObject * tmp = (PyArrayObject*) py_V287;
16334 PyErr_Format(PyExc_NotImplementedError,
16335 "expected an aligned array of type %ld "
16336 "(NPY_FLOAT64), got non-aligned array of type %ld"
16337 " with %ld dimensions, with 3 last dims "
16338 "%ld, %ld, %ld"
16339 " and 3 last strides %ld %ld, %ld.",
16340 (long int) NPY_FLOAT64,
16341 (long int) PyArray_TYPE((PyArrayObject*) py_V287),
16342 (long int) PyArray_NDIM(tmp),
16343 (long int) (PyArray_NDIM(tmp) >= 3 ?
16344 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
16345 (long int) (PyArray_NDIM(tmp) >= 2 ?
16346 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
16347 (long int) (PyArray_NDIM(tmp) >= 1 ?
16348 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
16349 (long int) (PyArray_NDIM(tmp) >= 3 ?
16350 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
16351 (long int) (PyArray_NDIM(tmp) >= 2 ?
16352 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
16353 (long int) (PyArray_NDIM(tmp) >= 1 ?
16354 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
16355 );
16356 {
16357 __failure = 288;
16358 if (!PyErr_Occurred()) {
16359 PyErr_SetString(PyExc_RuntimeError,
16360 "Unexpected error in an Op's C code. "
16361 "No Python exception was set.");
16362 }
16363 goto __label_288;}
16364 }
16365 // This is a TypeError to be consistent with DEBUG_MODE
16366 // Note: DEBUG_MODE also tells the name of the container
16367 if (PyArray_TYPE((PyArrayObject*) py_V287) != NPY_FLOAT64) {
16368 PyErr_Format(PyExc_TypeError,
16369 "expected type_num %d (NPY_FLOAT64) got %d",
16370 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V287));
16371 {
16372 __failure = 288;
16373 if (!PyErr_Occurred()) {
16374 PyErr_SetString(PyExc_RuntimeError,
16375 "Unexpected error in an Op's C code. "
16376 "No Python exception was set.");
16377 }
16378 goto __label_288;}
16379 }
16380
16381 V287 = (PyArrayObject*)(py_V287);
16382 Py_XINCREF(V287);
16383
16384 {
16385
16386 py_V289 = PyList_GET_ITEM(storage_V289, 0);
16387 {Py_XINCREF(py_V289);}
16388
16389 V289 = NULL;
16390 if (py_V289 == Py_None) {
16391 // We can either fail here or set V289 to NULL and rely on Ops
16392 // using tensors to handle the NULL case, but if they fail to do so
16393 // they'll end up with nasty segfaults, so this is public service.
16394 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
16395 {
16396 __failure = 290;
16397 if (!PyErr_Occurred()) {
16398 PyErr_SetString(PyExc_RuntimeError,
16399 "Unexpected error in an Op's C code. "
16400 "No Python exception was set.");
16401 }
16402 goto __label_290;}
16403 }
16404 if (!PyArray_Check(py_V289)) {
16405 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
16406 {
16407 __failure = 290;
16408 if (!PyErr_Occurred()) {
16409 PyErr_SetString(PyExc_RuntimeError,
16410 "Unexpected error in an Op's C code. "
16411 "No Python exception was set.");
16412 }
16413 goto __label_290;}
16414 }
16415 // We expect NPY_FLOAT64
16416 if (!PyArray_ISALIGNED((PyArrayObject*) py_V289)) {
16417 PyArrayObject * tmp = (PyArrayObject*) py_V289;
16418 PyErr_Format(PyExc_NotImplementedError,
16419 "expected an aligned array of type %ld "
16420 "(NPY_FLOAT64), got non-aligned array of type %ld"
16421 " with %ld dimensions, with 3 last dims "
16422 "%ld, %ld, %ld"
16423 " and 3 last strides %ld %ld, %ld.",
16424 (long int) NPY_FLOAT64,
16425 (long int) PyArray_TYPE((PyArrayObject*) py_V289),
16426 (long int) PyArray_NDIM(tmp),
16427 (long int) (PyArray_NDIM(tmp) >= 3 ?
16428 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
16429 (long int) (PyArray_NDIM(tmp) >= 2 ?
16430 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
16431 (long int) (PyArray_NDIM(tmp) >= 1 ?
16432 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
16433 (long int) (PyArray_NDIM(tmp) >= 3 ?
16434 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
16435 (long int) (PyArray_NDIM(tmp) >= 2 ?
16436 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
16437 (long int) (PyArray_NDIM(tmp) >= 1 ?
16438 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
16439 );
16440 {
16441 __failure = 290;
16442 if (!PyErr_Occurred()) {
16443 PyErr_SetString(PyExc_RuntimeError,
16444 "Unexpected error in an Op's C code. "
16445 "No Python exception was set.");
16446 }
16447 goto __label_290;}
16448 }
16449 // This is a TypeError to be consistent with DEBUG_MODE
16450 // Note: DEBUG_MODE also tells the name of the container
16451 if (PyArray_TYPE((PyArrayObject*) py_V289) != NPY_FLOAT64) {
16452 PyErr_Format(PyExc_TypeError,
16453 "expected type_num %d (NPY_FLOAT64) got %d",
16454 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V289));
16455 {
16456 __failure = 290;
16457 if (!PyErr_Occurred()) {
16458 PyErr_SetString(PyExc_RuntimeError,
16459 "Unexpected error in an Op's C code. "
16460 "No Python exception was set.");
16461 }
16462 goto __label_290;}
16463 }
16464
16465 V289 = (PyArrayObject*)(py_V289);
16466 Py_XINCREF(V289);
16467
16468 {
16469
16470 py_V291 = PyList_GET_ITEM(storage_V291, 0);
16471 {Py_XINCREF(py_V291);}
16472
16473 V291 = NULL;
16474 if (py_V291 == Py_None) {
16475 // We can either fail here or set V291 to NULL and rely on Ops
16476 // using tensors to handle the NULL case, but if they fail to do so
16477 // they'll end up with nasty segfaults, so this is public service.
16478 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
16479 {
16480 __failure = 292;
16481 if (!PyErr_Occurred()) {
16482 PyErr_SetString(PyExc_RuntimeError,
16483 "Unexpected error in an Op's C code. "
16484 "No Python exception was set.");
16485 }
16486 goto __label_292;}
16487 }
16488 if (!PyArray_Check(py_V291)) {
16489 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
16490 {
16491 __failure = 292;
16492 if (!PyErr_Occurred()) {
16493 PyErr_SetString(PyExc_RuntimeError,
16494 "Unexpected error in an Op's C code. "
16495 "No Python exception was set.");
16496 }
16497 goto __label_292;}
16498 }
16499 // We expect NPY_FLOAT64
16500 if (!PyArray_ISALIGNED((PyArrayObject*) py_V291)) {
16501 PyArrayObject * tmp = (PyArrayObject*) py_V291;
16502 PyErr_Format(PyExc_NotImplementedError,
16503 "expected an aligned array of type %ld "
16504 "(NPY_FLOAT64), got non-aligned array of type %ld"
16505 " with %ld dimensions, with 3 last dims "
16506 "%ld, %ld, %ld"
16507 " and 3 last strides %ld %ld, %ld.",
16508 (long int) NPY_FLOAT64,
16509 (long int) PyArray_TYPE((PyArrayObject*) py_V291),
16510 (long int) PyArray_NDIM(tmp),
16511 (long int) (PyArray_NDIM(tmp) >= 3 ?
16512 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
16513 (long int) (PyArray_NDIM(tmp) >= 2 ?
16514 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
16515 (long int) (PyArray_NDIM(tmp) >= 1 ?
16516 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
16517 (long int) (PyArray_NDIM(tmp) >= 3 ?
16518 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
16519 (long int) (PyArray_NDIM(tmp) >= 2 ?
16520 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
16521 (long int) (PyArray_NDIM(tmp) >= 1 ?
16522 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
16523 );
16524 {
16525 __failure = 292;
16526 if (!PyErr_Occurred()) {
16527 PyErr_SetString(PyExc_RuntimeError,
16528 "Unexpected error in an Op's C code. "
16529 "No Python exception was set.");
16530 }
16531 goto __label_292;}
16532 }
16533 // This is a TypeError to be consistent with DEBUG_MODE
16534 // Note: DEBUG_MODE also tells the name of the container
16535 if (PyArray_TYPE((PyArrayObject*) py_V291) != NPY_FLOAT64) {
16536 PyErr_Format(PyExc_TypeError,
16537 "expected type_num %d (NPY_FLOAT64) got %d",
16538 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V291));
16539 {
16540 __failure = 292;
16541 if (!PyErr_Occurred()) {
16542 PyErr_SetString(PyExc_RuntimeError,
16543 "Unexpected error in an Op's C code. "
16544 "No Python exception was set.");
16545 }
16546 goto __label_292;}
16547 }
16548
16549 V291 = (PyArrayObject*)(py_V291);
16550 Py_XINCREF(V291);
16551
16552 {
16553
16554 py_V293 = PyList_GET_ITEM(storage_V293, 0);
16555 {Py_XINCREF(py_V293);}
16556
16557 V293 = NULL;
16558 if (py_V293 == Py_None) {
16559 // We can either fail here or set V293 to NULL and rely on Ops
16560 // using tensors to handle the NULL case, but if they fail to do so
16561 // they'll end up with nasty segfaults, so this is public service.
16562 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
16563 {
16564 __failure = 294;
16565 if (!PyErr_Occurred()) {
16566 PyErr_SetString(PyExc_RuntimeError,
16567 "Unexpected error in an Op's C code. "
16568 "No Python exception was set.");
16569 }
16570 goto __label_294;}
16571 }
16572 if (!PyArray_Check(py_V293)) {
16573 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
16574 {
16575 __failure = 294;
16576 if (!PyErr_Occurred()) {
16577 PyErr_SetString(PyExc_RuntimeError,
16578 "Unexpected error in an Op's C code. "
16579 "No Python exception was set.");
16580 }
16581 goto __label_294;}
16582 }
16583 // We expect NPY_FLOAT64
16584 if (!PyArray_ISALIGNED((PyArrayObject*) py_V293)) {
16585 PyArrayObject * tmp = (PyArrayObject*) py_V293;
16586 PyErr_Format(PyExc_NotImplementedError,
16587 "expected an aligned array of type %ld "
16588 "(NPY_FLOAT64), got non-aligned array of type %ld"
16589 " with %ld dimensions, with 3 last dims "
16590 "%ld, %ld, %ld"
16591 " and 3 last strides %ld %ld, %ld.",
16592 (long int) NPY_FLOAT64,
16593 (long int) PyArray_TYPE((PyArrayObject*) py_V293),
16594 (long int) PyArray_NDIM(tmp),
16595 (long int) (PyArray_NDIM(tmp) >= 3 ?
16596 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
16597 (long int) (PyArray_NDIM(tmp) >= 2 ?
16598 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
16599 (long int) (PyArray_NDIM(tmp) >= 1 ?
16600 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
16601 (long int) (PyArray_NDIM(tmp) >= 3 ?
16602 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
16603 (long int) (PyArray_NDIM(tmp) >= 2 ?
16604 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
16605 (long int) (PyArray_NDIM(tmp) >= 1 ?
16606 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
16607 );
16608 {
16609 __failure = 294;
16610 if (!PyErr_Occurred()) {
16611 PyErr_SetString(PyExc_RuntimeError,
16612 "Unexpected error in an Op's C code. "
16613 "No Python exception was set.");
16614 }
16615 goto __label_294;}
16616 }
16617 // This is a TypeError to be consistent with DEBUG_MODE
16618 // Note: DEBUG_MODE also tells the name of the container
16619 if (PyArray_TYPE((PyArrayObject*) py_V293) != NPY_FLOAT64) {
16620 PyErr_Format(PyExc_TypeError,
16621 "expected type_num %d (NPY_FLOAT64) got %d",
16622 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V293));
16623 {
16624 __failure = 294;
16625 if (!PyErr_Occurred()) {
16626 PyErr_SetString(PyExc_RuntimeError,
16627 "Unexpected error in an Op's C code. "
16628 "No Python exception was set.");
16629 }
16630 goto __label_294;}
16631 }
16632
16633 V293 = (PyArrayObject*)(py_V293);
16634 Py_XINCREF(V293);
16635
16636 {
16637
16638 py_V295 = PyList_GET_ITEM(storage_V295, 0);
16639 {Py_XINCREF(py_V295);}
16640
16641 V295 = NULL;
16642 if (py_V295 == Py_None) {
16643 // We can either fail here or set V295 to NULL and rely on Ops
16644 // using tensors to handle the NULL case, but if they fail to do so
16645 // they'll end up with nasty segfaults, so this is public service.
16646 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
16647 {
16648 __failure = 296;
16649 if (!PyErr_Occurred()) {
16650 PyErr_SetString(PyExc_RuntimeError,
16651 "Unexpected error in an Op's C code. "
16652 "No Python exception was set.");
16653 }
16654 goto __label_296;}
16655 }
16656 if (!PyArray_Check(py_V295)) {
16657 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
16658 {
16659 __failure = 296;
16660 if (!PyErr_Occurred()) {
16661 PyErr_SetString(PyExc_RuntimeError,
16662 "Unexpected error in an Op's C code. "
16663 "No Python exception was set.");
16664 }
16665 goto __label_296;}
16666 }
16667 // We expect NPY_FLOAT64
16668 if (!PyArray_ISALIGNED((PyArrayObject*) py_V295)) {
16669 PyArrayObject * tmp = (PyArrayObject*) py_V295;
16670 PyErr_Format(PyExc_NotImplementedError,
16671 "expected an aligned array of type %ld "
16672 "(NPY_FLOAT64), got non-aligned array of type %ld"
16673 " with %ld dimensions, with 3 last dims "
16674 "%ld, %ld, %ld"
16675 " and 3 last strides %ld %ld, %ld.",
16676 (long int) NPY_FLOAT64,
16677 (long int) PyArray_TYPE((PyArrayObject*) py_V295),
16678 (long int) PyArray_NDIM(tmp),
16679 (long int) (PyArray_NDIM(tmp) >= 3 ?
16680 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
16681 (long int) (PyArray_NDIM(tmp) >= 2 ?
16682 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
16683 (long int) (PyArray_NDIM(tmp) >= 1 ?
16684 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
16685 (long int) (PyArray_NDIM(tmp) >= 3 ?
16686 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
16687 (long int) (PyArray_NDIM(tmp) >= 2 ?
16688 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
16689 (long int) (PyArray_NDIM(tmp) >= 1 ?
16690 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
16691 );
16692 {
16693 __failure = 296;
16694 if (!PyErr_Occurred()) {
16695 PyErr_SetString(PyExc_RuntimeError,
16696 "Unexpected error in an Op's C code. "
16697 "No Python exception was set.");
16698 }
16699 goto __label_296;}
16700 }
16701 // This is a TypeError to be consistent with DEBUG_MODE
16702 // Note: DEBUG_MODE also tells the name of the container
16703 if (PyArray_TYPE((PyArrayObject*) py_V295) != NPY_FLOAT64) {
16704 PyErr_Format(PyExc_TypeError,
16705 "expected type_num %d (NPY_FLOAT64) got %d",
16706 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V295));
16707 {
16708 __failure = 296;
16709 if (!PyErr_Occurred()) {
16710 PyErr_SetString(PyExc_RuntimeError,
16711 "Unexpected error in an Op's C code. "
16712 "No Python exception was set.");
16713 }
16714 goto __label_296;}
16715 }
16716
16717 V295 = (PyArrayObject*)(py_V295);
16718 Py_XINCREF(V295);
16719
16720 {
16721
16722 py_V297 = PyList_GET_ITEM(storage_V297, 0);
16723 {Py_XINCREF(py_V297);}
16724
16725 V297 = NULL;
16726 if (py_V297 == Py_None) {
16727 // We can either fail here or set V297 to NULL and rely on Ops
16728 // using tensors to handle the NULL case, but if they fail to do so
16729 // they'll end up with nasty segfaults, so this is public service.
16730 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
16731 {
16732 __failure = 298;
16733 if (!PyErr_Occurred()) {
16734 PyErr_SetString(PyExc_RuntimeError,
16735 "Unexpected error in an Op's C code. "
16736 "No Python exception was set.");
16737 }
16738 goto __label_298;}
16739 }
16740 if (!PyArray_Check(py_V297)) {
16741 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
16742 {
16743 __failure = 298;
16744 if (!PyErr_Occurred()) {
16745 PyErr_SetString(PyExc_RuntimeError,
16746 "Unexpected error in an Op's C code. "
16747 "No Python exception was set.");
16748 }
16749 goto __label_298;}
16750 }
16751 // We expect NPY_FLOAT64
16752 if (!PyArray_ISALIGNED((PyArrayObject*) py_V297)) {
16753 PyArrayObject * tmp = (PyArrayObject*) py_V297;
16754 PyErr_Format(PyExc_NotImplementedError,
16755 "expected an aligned array of type %ld "
16756 "(NPY_FLOAT64), got non-aligned array of type %ld"
16757 " with %ld dimensions, with 3 last dims "
16758 "%ld, %ld, %ld"
16759 " and 3 last strides %ld %ld, %ld.",
16760 (long int) NPY_FLOAT64,
16761 (long int) PyArray_TYPE((PyArrayObject*) py_V297),
16762 (long int) PyArray_NDIM(tmp),
16763 (long int) (PyArray_NDIM(tmp) >= 3 ?
16764 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
16765 (long int) (PyArray_NDIM(tmp) >= 2 ?
16766 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
16767 (long int) (PyArray_NDIM(tmp) >= 1 ?
16768 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
16769 (long int) (PyArray_NDIM(tmp) >= 3 ?
16770 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
16771 (long int) (PyArray_NDIM(tmp) >= 2 ?
16772 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
16773 (long int) (PyArray_NDIM(tmp) >= 1 ?
16774 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
16775 );
16776 {
16777 __failure = 298;
16778 if (!PyErr_Occurred()) {
16779 PyErr_SetString(PyExc_RuntimeError,
16780 "Unexpected error in an Op's C code. "
16781 "No Python exception was set.");
16782 }
16783 goto __label_298;}
16784 }
16785 // This is a TypeError to be consistent with DEBUG_MODE
16786 // Note: DEBUG_MODE also tells the name of the container
16787 if (PyArray_TYPE((PyArrayObject*) py_V297) != NPY_FLOAT64) {
16788 PyErr_Format(PyExc_TypeError,
16789 "expected type_num %d (NPY_FLOAT64) got %d",
16790 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V297));
16791 {
16792 __failure = 298;
16793 if (!PyErr_Occurred()) {
16794 PyErr_SetString(PyExc_RuntimeError,
16795 "Unexpected error in an Op's C code. "
16796 "No Python exception was set.");
16797 }
16798 goto __label_298;}
16799 }
16800
16801 V297 = (PyArrayObject*)(py_V297);
16802 Py_XINCREF(V297);
16803
16804 {
16805
16806 py_V299 = PyList_GET_ITEM(storage_V299, 0);
16807 {Py_XINCREF(py_V299);}
16808
16809 V299 = NULL;
16810 if (py_V299 == Py_None) {
16811 // We can either fail here or set V299 to NULL and rely on Ops
16812 // using tensors to handle the NULL case, but if they fail to do so
16813 // they'll end up with nasty segfaults, so this is public service.
16814 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
16815 {
16816 __failure = 300;
16817 if (!PyErr_Occurred()) {
16818 PyErr_SetString(PyExc_RuntimeError,
16819 "Unexpected error in an Op's C code. "
16820 "No Python exception was set.");
16821 }
16822 goto __label_300;}
16823 }
16824 if (!PyArray_Check(py_V299)) {
16825 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
16826 {
16827 __failure = 300;
16828 if (!PyErr_Occurred()) {
16829 PyErr_SetString(PyExc_RuntimeError,
16830 "Unexpected error in an Op's C code. "
16831 "No Python exception was set.");
16832 }
16833 goto __label_300;}
16834 }
16835 // We expect NPY_FLOAT64
16836 if (!PyArray_ISALIGNED((PyArrayObject*) py_V299)) {
16837 PyArrayObject * tmp = (PyArrayObject*) py_V299;
16838 PyErr_Format(PyExc_NotImplementedError,
16839 "expected an aligned array of type %ld "
16840 "(NPY_FLOAT64), got non-aligned array of type %ld"
16841 " with %ld dimensions, with 3 last dims "
16842 "%ld, %ld, %ld"
16843 " and 3 last strides %ld %ld, %ld.",
16844 (long int) NPY_FLOAT64,
16845 (long int) PyArray_TYPE((PyArrayObject*) py_V299),
16846 (long int) PyArray_NDIM(tmp),
16847 (long int) (PyArray_NDIM(tmp) >= 3 ?
16848 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
16849 (long int) (PyArray_NDIM(tmp) >= 2 ?
16850 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
16851 (long int) (PyArray_NDIM(tmp) >= 1 ?
16852 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
16853 (long int) (PyArray_NDIM(tmp) >= 3 ?
16854 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
16855 (long int) (PyArray_NDIM(tmp) >= 2 ?
16856 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
16857 (long int) (PyArray_NDIM(tmp) >= 1 ?
16858 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
16859 );
16860 {
16861 __failure = 300;
16862 if (!PyErr_Occurred()) {
16863 PyErr_SetString(PyExc_RuntimeError,
16864 "Unexpected error in an Op's C code. "
16865 "No Python exception was set.");
16866 }
16867 goto __label_300;}
16868 }
16869 // This is a TypeError to be consistent with DEBUG_MODE
16870 // Note: DEBUG_MODE also tells the name of the container
16871 if (PyArray_TYPE((PyArrayObject*) py_V299) != NPY_FLOAT64) {
16872 PyErr_Format(PyExc_TypeError,
16873 "expected type_num %d (NPY_FLOAT64) got %d",
16874 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V299));
16875 {
16876 __failure = 300;
16877 if (!PyErr_Occurred()) {
16878 PyErr_SetString(PyExc_RuntimeError,
16879 "Unexpected error in an Op's C code. "
16880 "No Python exception was set.");
16881 }
16882 goto __label_300;}
16883 }
16884
16885 V299 = (PyArrayObject*)(py_V299);
16886 Py_XINCREF(V299);
16887
16888 {
16889
16890 py_V301 = PyList_GET_ITEM(storage_V301, 0);
16891 {Py_XINCREF(py_V301);}
16892
16893 V301 = NULL;
16894 if (py_V301 == Py_None) {
16895 // We can either fail here or set V301 to NULL and rely on Ops
16896 // using tensors to handle the NULL case, but if they fail to do so
16897 // they'll end up with nasty segfaults, so this is public service.
16898 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
16899 {
16900 __failure = 302;
16901 if (!PyErr_Occurred()) {
16902 PyErr_SetString(PyExc_RuntimeError,
16903 "Unexpected error in an Op's C code. "
16904 "No Python exception was set.");
16905 }
16906 goto __label_302;}
16907 }
16908 if (!PyArray_Check(py_V301)) {
16909 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
16910 {
16911 __failure = 302;
16912 if (!PyErr_Occurred()) {
16913 PyErr_SetString(PyExc_RuntimeError,
16914 "Unexpected error in an Op's C code. "
16915 "No Python exception was set.");
16916 }
16917 goto __label_302;}
16918 }
16919 // We expect NPY_FLOAT64
16920 if (!PyArray_ISALIGNED((PyArrayObject*) py_V301)) {
16921 PyArrayObject * tmp = (PyArrayObject*) py_V301;
16922 PyErr_Format(PyExc_NotImplementedError,
16923 "expected an aligned array of type %ld "
16924 "(NPY_FLOAT64), got non-aligned array of type %ld"
16925 " with %ld dimensions, with 3 last dims "
16926 "%ld, %ld, %ld"
16927 " and 3 last strides %ld %ld, %ld.",
16928 (long int) NPY_FLOAT64,
16929 (long int) PyArray_TYPE((PyArrayObject*) py_V301),
16930 (long int) PyArray_NDIM(tmp),
16931 (long int) (PyArray_NDIM(tmp) >= 3 ?
16932 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
16933 (long int) (PyArray_NDIM(tmp) >= 2 ?
16934 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
16935 (long int) (PyArray_NDIM(tmp) >= 1 ?
16936 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
16937 (long int) (PyArray_NDIM(tmp) >= 3 ?
16938 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
16939 (long int) (PyArray_NDIM(tmp) >= 2 ?
16940 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
16941 (long int) (PyArray_NDIM(tmp) >= 1 ?
16942 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
16943 );
16944 {
16945 __failure = 302;
16946 if (!PyErr_Occurred()) {
16947 PyErr_SetString(PyExc_RuntimeError,
16948 "Unexpected error in an Op's C code. "
16949 "No Python exception was set.");
16950 }
16951 goto __label_302;}
16952 }
16953 // This is a TypeError to be consistent with DEBUG_MODE
16954 // Note: DEBUG_MODE also tells the name of the container
16955 if (PyArray_TYPE((PyArrayObject*) py_V301) != NPY_FLOAT64) {
16956 PyErr_Format(PyExc_TypeError,
16957 "expected type_num %d (NPY_FLOAT64) got %d",
16958 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V301));
16959 {
16960 __failure = 302;
16961 if (!PyErr_Occurred()) {
16962 PyErr_SetString(PyExc_RuntimeError,
16963 "Unexpected error in an Op's C code. "
16964 "No Python exception was set.");
16965 }
16966 goto __label_302;}
16967 }
16968
16969 V301 = (PyArrayObject*)(py_V301);
16970 Py_XINCREF(V301);
16971
16972 {
16973
16974 py_V303 = PyList_GET_ITEM(storage_V303, 0);
16975 {Py_XINCREF(py_V303);}
16976
16977 V303 = NULL;
16978 if (py_V303 == Py_None) {
16979 // We can either fail here or set V303 to NULL and rely on Ops
16980 // using tensors to handle the NULL case, but if they fail to do so
16981 // they'll end up with nasty segfaults, so this is public service.
16982 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
16983 {
16984 __failure = 304;
16985 if (!PyErr_Occurred()) {
16986 PyErr_SetString(PyExc_RuntimeError,
16987 "Unexpected error in an Op's C code. "
16988 "No Python exception was set.");
16989 }
16990 goto __label_304;}
16991 }
16992 if (!PyArray_Check(py_V303)) {
16993 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
16994 {
16995 __failure = 304;
16996 if (!PyErr_Occurred()) {
16997 PyErr_SetString(PyExc_RuntimeError,
16998 "Unexpected error in an Op's C code. "
16999 "No Python exception was set.");
17000 }
17001 goto __label_304;}
17002 }
17003 // We expect NPY_FLOAT64
17004 if (!PyArray_ISALIGNED((PyArrayObject*) py_V303)) {
17005 PyArrayObject * tmp = (PyArrayObject*) py_V303;
17006 PyErr_Format(PyExc_NotImplementedError,
17007 "expected an aligned array of type %ld "
17008 "(NPY_FLOAT64), got non-aligned array of type %ld"
17009 " with %ld dimensions, with 3 last dims "
17010 "%ld, %ld, %ld"
17011 " and 3 last strides %ld %ld, %ld.",
17012 (long int) NPY_FLOAT64,
17013 (long int) PyArray_TYPE((PyArrayObject*) py_V303),
17014 (long int) PyArray_NDIM(tmp),
17015 (long int) (PyArray_NDIM(tmp) >= 3 ?
17016 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
17017 (long int) (PyArray_NDIM(tmp) >= 2 ?
17018 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
17019 (long int) (PyArray_NDIM(tmp) >= 1 ?
17020 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
17021 (long int) (PyArray_NDIM(tmp) >= 3 ?
17022 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
17023 (long int) (PyArray_NDIM(tmp) >= 2 ?
17024 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
17025 (long int) (PyArray_NDIM(tmp) >= 1 ?
17026 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
17027 );
17028 {
17029 __failure = 304;
17030 if (!PyErr_Occurred()) {
17031 PyErr_SetString(PyExc_RuntimeError,
17032 "Unexpected error in an Op's C code. "
17033 "No Python exception was set.");
17034 }
17035 goto __label_304;}
17036 }
17037 // This is a TypeError to be consistent with DEBUG_MODE
17038 // Note: DEBUG_MODE also tells the name of the container
17039 if (PyArray_TYPE((PyArrayObject*) py_V303) != NPY_FLOAT64) {
17040 PyErr_Format(PyExc_TypeError,
17041 "expected type_num %d (NPY_FLOAT64) got %d",
17042 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V303));
17043 {
17044 __failure = 304;
17045 if (!PyErr_Occurred()) {
17046 PyErr_SetString(PyExc_RuntimeError,
17047 "Unexpected error in an Op's C code. "
17048 "No Python exception was set.");
17049 }
17050 goto __label_304;}
17051 }
17052
17053 V303 = (PyArrayObject*)(py_V303);
17054 Py_XINCREF(V303);
17055
17056 {
17057
17058 py_V305 = PyList_GET_ITEM(storage_V305, 0);
17059 {Py_XINCREF(py_V305);}
17060
17061 V305 = NULL;
17062 if (py_V305 == Py_None) {
17063 // We can either fail here or set V305 to NULL and rely on Ops
17064 // using tensors to handle the NULL case, but if they fail to do so
17065 // they'll end up with nasty segfaults, so this is public service.
17066 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
17067 {
17068 __failure = 306;
17069 if (!PyErr_Occurred()) {
17070 PyErr_SetString(PyExc_RuntimeError,
17071 "Unexpected error in an Op's C code. "
17072 "No Python exception was set.");
17073 }
17074 goto __label_306;}
17075 }
17076 if (!PyArray_Check(py_V305)) {
17077 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
17078 {
17079 __failure = 306;
17080 if (!PyErr_Occurred()) {
17081 PyErr_SetString(PyExc_RuntimeError,
17082 "Unexpected error in an Op's C code. "
17083 "No Python exception was set.");
17084 }
17085 goto __label_306;}
17086 }
17087 // We expect NPY_FLOAT64
17088 if (!PyArray_ISALIGNED((PyArrayObject*) py_V305)) {
17089 PyArrayObject * tmp = (PyArrayObject*) py_V305;
17090 PyErr_Format(PyExc_NotImplementedError,
17091 "expected an aligned array of type %ld "
17092 "(NPY_FLOAT64), got non-aligned array of type %ld"
17093 " with %ld dimensions, with 3 last dims "
17094 "%ld, %ld, %ld"
17095 " and 3 last strides %ld %ld, %ld.",
17096 (long int) NPY_FLOAT64,
17097 (long int) PyArray_TYPE((PyArrayObject*) py_V305),
17098 (long int) PyArray_NDIM(tmp),
17099 (long int) (PyArray_NDIM(tmp) >= 3 ?
17100 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
17101 (long int) (PyArray_NDIM(tmp) >= 2 ?
17102 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
17103 (long int) (PyArray_NDIM(tmp) >= 1 ?
17104 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
17105 (long int) (PyArray_NDIM(tmp) >= 3 ?
17106 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
17107 (long int) (PyArray_NDIM(tmp) >= 2 ?
17108 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
17109 (long int) (PyArray_NDIM(tmp) >= 1 ?
17110 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
17111 );
17112 {
17113 __failure = 306;
17114 if (!PyErr_Occurred()) {
17115 PyErr_SetString(PyExc_RuntimeError,
17116 "Unexpected error in an Op's C code. "
17117 "No Python exception was set.");
17118 }
17119 goto __label_306;}
17120 }
17121 // This is a TypeError to be consistent with DEBUG_MODE
17122 // Note: DEBUG_MODE also tells the name of the container
17123 if (PyArray_TYPE((PyArrayObject*) py_V305) != NPY_FLOAT64) {
17124 PyErr_Format(PyExc_TypeError,
17125 "expected type_num %d (NPY_FLOAT64) got %d",
17126 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V305));
17127 {
17128 __failure = 306;
17129 if (!PyErr_Occurred()) {
17130 PyErr_SetString(PyExc_RuntimeError,
17131 "Unexpected error in an Op's C code. "
17132 "No Python exception was set.");
17133 }
17134 goto __label_306;}
17135 }
17136
17137 V305 = (PyArrayObject*)(py_V305);
17138 Py_XINCREF(V305);
17139
17140 {
17141
17142 py_V307 = PyList_GET_ITEM(storage_V307, 0);
17143 {Py_XINCREF(py_V307);}
17144
17145 V307 = NULL;
17146 if (py_V307 == Py_None) {
17147 // We can either fail here or set V307 to NULL and rely on Ops
17148 // using tensors to handle the NULL case, but if they fail to do so
17149 // they'll end up with nasty segfaults, so this is public service.
17150 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
17151 {
17152 __failure = 308;
17153 if (!PyErr_Occurred()) {
17154 PyErr_SetString(PyExc_RuntimeError,
17155 "Unexpected error in an Op's C code. "
17156 "No Python exception was set.");
17157 }
17158 goto __label_308;}
17159 }
17160 if (!PyArray_Check(py_V307)) {
17161 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
17162 {
17163 __failure = 308;
17164 if (!PyErr_Occurred()) {
17165 PyErr_SetString(PyExc_RuntimeError,
17166 "Unexpected error in an Op's C code. "
17167 "No Python exception was set.");
17168 }
17169 goto __label_308;}
17170 }
17171 // We expect NPY_FLOAT64
17172 if (!PyArray_ISALIGNED((PyArrayObject*) py_V307)) {
17173 PyArrayObject * tmp = (PyArrayObject*) py_V307;
17174 PyErr_Format(PyExc_NotImplementedError,
17175 "expected an aligned array of type %ld "
17176 "(NPY_FLOAT64), got non-aligned array of type %ld"
17177 " with %ld dimensions, with 3 last dims "
17178 "%ld, %ld, %ld"
17179 " and 3 last strides %ld %ld, %ld.",
17180 (long int) NPY_FLOAT64,
17181 (long int) PyArray_TYPE((PyArrayObject*) py_V307),
17182 (long int) PyArray_NDIM(tmp),
17183 (long int) (PyArray_NDIM(tmp) >= 3 ?
17184 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
17185 (long int) (PyArray_NDIM(tmp) >= 2 ?
17186 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
17187 (long int) (PyArray_NDIM(tmp) >= 1 ?
17188 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
17189 (long int) (PyArray_NDIM(tmp) >= 3 ?
17190 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
17191 (long int) (PyArray_NDIM(tmp) >= 2 ?
17192 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
17193 (long int) (PyArray_NDIM(tmp) >= 1 ?
17194 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
17195 );
17196 {
17197 __failure = 308;
17198 if (!PyErr_Occurred()) {
17199 PyErr_SetString(PyExc_RuntimeError,
17200 "Unexpected error in an Op's C code. "
17201 "No Python exception was set.");
17202 }
17203 goto __label_308;}
17204 }
17205 // This is a TypeError to be consistent with DEBUG_MODE
17206 // Note: DEBUG_MODE also tells the name of the container
17207 if (PyArray_TYPE((PyArrayObject*) py_V307) != NPY_FLOAT64) {
17208 PyErr_Format(PyExc_TypeError,
17209 "expected type_num %d (NPY_FLOAT64) got %d",
17210 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V307));
17211 {
17212 __failure = 308;
17213 if (!PyErr_Occurred()) {
17214 PyErr_SetString(PyExc_RuntimeError,
17215 "Unexpected error in an Op's C code. "
17216 "No Python exception was set.");
17217 }
17218 goto __label_308;}
17219 }
17220
17221 V307 = (PyArrayObject*)(py_V307);
17222 Py_XINCREF(V307);
17223
17224 {
17225
17226 py_V309 = PyList_GET_ITEM(storage_V309, 0);
17227 {Py_XINCREF(py_V309);}
17228
17229 V309 = NULL;
17230 if (py_V309 == Py_None) {
17231 // We can either fail here or set V309 to NULL and rely on Ops
17232 // using tensors to handle the NULL case, but if they fail to do so
17233 // they'll end up with nasty segfaults, so this is public service.
17234 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
17235 {
17236 __failure = 310;
17237 if (!PyErr_Occurred()) {
17238 PyErr_SetString(PyExc_RuntimeError,
17239 "Unexpected error in an Op's C code. "
17240 "No Python exception was set.");
17241 }
17242 goto __label_310;}
17243 }
17244 if (!PyArray_Check(py_V309)) {
17245 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
17246 {
17247 __failure = 310;
17248 if (!PyErr_Occurred()) {
17249 PyErr_SetString(PyExc_RuntimeError,
17250 "Unexpected error in an Op's C code. "
17251 "No Python exception was set.");
17252 }
17253 goto __label_310;}
17254 }
17255 // We expect NPY_FLOAT64
17256 if (!PyArray_ISALIGNED((PyArrayObject*) py_V309)) {
17257 PyArrayObject * tmp = (PyArrayObject*) py_V309;
17258 PyErr_Format(PyExc_NotImplementedError,
17259 "expected an aligned array of type %ld "
17260 "(NPY_FLOAT64), got non-aligned array of type %ld"
17261 " with %ld dimensions, with 3 last dims "
17262 "%ld, %ld, %ld"
17263 " and 3 last strides %ld %ld, %ld.",
17264 (long int) NPY_FLOAT64,
17265 (long int) PyArray_TYPE((PyArrayObject*) py_V309),
17266 (long int) PyArray_NDIM(tmp),
17267 (long int) (PyArray_NDIM(tmp) >= 3 ?
17268 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
17269 (long int) (PyArray_NDIM(tmp) >= 2 ?
17270 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
17271 (long int) (PyArray_NDIM(tmp) >= 1 ?
17272 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
17273 (long int) (PyArray_NDIM(tmp) >= 3 ?
17274 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
17275 (long int) (PyArray_NDIM(tmp) >= 2 ?
17276 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
17277 (long int) (PyArray_NDIM(tmp) >= 1 ?
17278 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
17279 );
17280 {
17281 __failure = 310;
17282 if (!PyErr_Occurred()) {
17283 PyErr_SetString(PyExc_RuntimeError,
17284 "Unexpected error in an Op's C code. "
17285 "No Python exception was set.");
17286 }
17287 goto __label_310;}
17288 }
17289 // This is a TypeError to be consistent with DEBUG_MODE
17290 // Note: DEBUG_MODE also tells the name of the container
17291 if (PyArray_TYPE((PyArrayObject*) py_V309) != NPY_FLOAT64) {
17292 PyErr_Format(PyExc_TypeError,
17293 "expected type_num %d (NPY_FLOAT64) got %d",
17294 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V309));
17295 {
17296 __failure = 310;
17297 if (!PyErr_Occurred()) {
17298 PyErr_SetString(PyExc_RuntimeError,
17299 "Unexpected error in an Op's C code. "
17300 "No Python exception was set.");
17301 }
17302 goto __label_310;}
17303 }
17304
17305 V309 = (PyArrayObject*)(py_V309);
17306 Py_XINCREF(V309);
17307
17308 {
17309
17310 py_V311 = PyList_GET_ITEM(storage_V311, 0);
17311 {Py_XINCREF(py_V311);}
17312
17313 V311 = NULL;
17314 if (py_V311 == Py_None) {
17315 // We can either fail here or set V311 to NULL and rely on Ops
17316 // using tensors to handle the NULL case, but if they fail to do so
17317 // they'll end up with nasty segfaults, so this is public service.
17318 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
17319 {
17320 __failure = 312;
17321 if (!PyErr_Occurred()) {
17322 PyErr_SetString(PyExc_RuntimeError,
17323 "Unexpected error in an Op's C code. "
17324 "No Python exception was set.");
17325 }
17326 goto __label_312;}
17327 }
17328 if (!PyArray_Check(py_V311)) {
17329 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
17330 {
17331 __failure = 312;
17332 if (!PyErr_Occurred()) {
17333 PyErr_SetString(PyExc_RuntimeError,
17334 "Unexpected error in an Op's C code. "
17335 "No Python exception was set.");
17336 }
17337 goto __label_312;}
17338 }
17339 // We expect NPY_FLOAT64
17340 if (!PyArray_ISALIGNED((PyArrayObject*) py_V311)) {
17341 PyArrayObject * tmp = (PyArrayObject*) py_V311;
17342 PyErr_Format(PyExc_NotImplementedError,
17343 "expected an aligned array of type %ld "
17344 "(NPY_FLOAT64), got non-aligned array of type %ld"
17345 " with %ld dimensions, with 3 last dims "
17346 "%ld, %ld, %ld"
17347 " and 3 last strides %ld %ld, %ld.",
17348 (long int) NPY_FLOAT64,
17349 (long int) PyArray_TYPE((PyArrayObject*) py_V311),
17350 (long int) PyArray_NDIM(tmp),
17351 (long int) (PyArray_NDIM(tmp) >= 3 ?
17352 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
17353 (long int) (PyArray_NDIM(tmp) >= 2 ?
17354 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
17355 (long int) (PyArray_NDIM(tmp) >= 1 ?
17356 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
17357 (long int) (PyArray_NDIM(tmp) >= 3 ?
17358 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
17359 (long int) (PyArray_NDIM(tmp) >= 2 ?
17360 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
17361 (long int) (PyArray_NDIM(tmp) >= 1 ?
17362 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
17363 );
17364 {
17365 __failure = 312;
17366 if (!PyErr_Occurred()) {
17367 PyErr_SetString(PyExc_RuntimeError,
17368 "Unexpected error in an Op's C code. "
17369 "No Python exception was set.");
17370 }
17371 goto __label_312;}
17372 }
17373 // This is a TypeError to be consistent with DEBUG_MODE
17374 // Note: DEBUG_MODE also tells the name of the container
17375 if (PyArray_TYPE((PyArrayObject*) py_V311) != NPY_FLOAT64) {
17376 PyErr_Format(PyExc_TypeError,
17377 "expected type_num %d (NPY_FLOAT64) got %d",
17378 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V311));
17379 {
17380 __failure = 312;
17381 if (!PyErr_Occurred()) {
17382 PyErr_SetString(PyExc_RuntimeError,
17383 "Unexpected error in an Op's C code. "
17384 "No Python exception was set.");
17385 }
17386 goto __label_312;}
17387 }
17388
17389 V311 = (PyArrayObject*)(py_V311);
17390 Py_XINCREF(V311);
17391
17392 {
17393
17394 py_V313 = PyList_GET_ITEM(storage_V313, 0);
17395 {Py_XINCREF(py_V313);}
17396
17397 V313 = NULL;
17398 if (py_V313 == Py_None) {
17399 // We can either fail here or set V313 to NULL and rely on Ops
17400 // using tensors to handle the NULL case, but if they fail to do so
17401 // they'll end up with nasty segfaults, so this is public service.
17402 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
17403 {
17404 __failure = 314;
17405 if (!PyErr_Occurred()) {
17406 PyErr_SetString(PyExc_RuntimeError,
17407 "Unexpected error in an Op's C code. "
17408 "No Python exception was set.");
17409 }
17410 goto __label_314;}
17411 }
17412 if (!PyArray_Check(py_V313)) {
17413 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
17414 {
17415 __failure = 314;
17416 if (!PyErr_Occurred()) {
17417 PyErr_SetString(PyExc_RuntimeError,
17418 "Unexpected error in an Op's C code. "
17419 "No Python exception was set.");
17420 }
17421 goto __label_314;}
17422 }
17423 // We expect NPY_FLOAT64
17424 if (!PyArray_ISALIGNED((PyArrayObject*) py_V313)) {
17425 PyArrayObject * tmp = (PyArrayObject*) py_V313;
17426 PyErr_Format(PyExc_NotImplementedError,
17427 "expected an aligned array of type %ld "
17428 "(NPY_FLOAT64), got non-aligned array of type %ld"
17429 " with %ld dimensions, with 3 last dims "
17430 "%ld, %ld, %ld"
17431 " and 3 last strides %ld %ld, %ld.",
17432 (long int) NPY_FLOAT64,
17433 (long int) PyArray_TYPE((PyArrayObject*) py_V313),
17434 (long int) PyArray_NDIM(tmp),
17435 (long int) (PyArray_NDIM(tmp) >= 3 ?
17436 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
17437 (long int) (PyArray_NDIM(tmp) >= 2 ?
17438 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
17439 (long int) (PyArray_NDIM(tmp) >= 1 ?
17440 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
17441 (long int) (PyArray_NDIM(tmp) >= 3 ?
17442 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
17443 (long int) (PyArray_NDIM(tmp) >= 2 ?
17444 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
17445 (long int) (PyArray_NDIM(tmp) >= 1 ?
17446 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
17447 );
17448 {
17449 __failure = 314;
17450 if (!PyErr_Occurred()) {
17451 PyErr_SetString(PyExc_RuntimeError,
17452 "Unexpected error in an Op's C code. "
17453 "No Python exception was set.");
17454 }
17455 goto __label_314;}
17456 }
17457 // This is a TypeError to be consistent with DEBUG_MODE
17458 // Note: DEBUG_MODE also tells the name of the container
17459 if (PyArray_TYPE((PyArrayObject*) py_V313) != NPY_FLOAT64) {
17460 PyErr_Format(PyExc_TypeError,
17461 "expected type_num %d (NPY_FLOAT64) got %d",
17462 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V313));
17463 {
17464 __failure = 314;
17465 if (!PyErr_Occurred()) {
17466 PyErr_SetString(PyExc_RuntimeError,
17467 "Unexpected error in an Op's C code. "
17468 "No Python exception was set.");
17469 }
17470 goto __label_314;}
17471 }
17472
17473 V313 = (PyArrayObject*)(py_V313);
17474 Py_XINCREF(V313);
17475
17476 {
17477
17478 py_V315 = PyList_GET_ITEM(storage_V315, 0);
17479 {Py_XINCREF(py_V315);}
17480
17481 V315 = NULL;
17482 if (py_V315 == Py_None) {
17483 // We can either fail here or set V315 to NULL and rely on Ops
17484 // using tensors to handle the NULL case, but if they fail to do so
17485 // they'll end up with nasty segfaults, so this is public service.
17486 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
17487 {
17488 __failure = 316;
17489 if (!PyErr_Occurred()) {
17490 PyErr_SetString(PyExc_RuntimeError,
17491 "Unexpected error in an Op's C code. "
17492 "No Python exception was set.");
17493 }
17494 goto __label_316;}
17495 }
17496 if (!PyArray_Check(py_V315)) {
17497 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
17498 {
17499 __failure = 316;
17500 if (!PyErr_Occurred()) {
17501 PyErr_SetString(PyExc_RuntimeError,
17502 "Unexpected error in an Op's C code. "
17503 "No Python exception was set.");
17504 }
17505 goto __label_316;}
17506 }
17507 // We expect NPY_FLOAT64
17508 if (!PyArray_ISALIGNED((PyArrayObject*) py_V315)) {
17509 PyArrayObject * tmp = (PyArrayObject*) py_V315;
17510 PyErr_Format(PyExc_NotImplementedError,
17511 "expected an aligned array of type %ld "
17512 "(NPY_FLOAT64), got non-aligned array of type %ld"
17513 " with %ld dimensions, with 3 last dims "
17514 "%ld, %ld, %ld"
17515 " and 3 last strides %ld %ld, %ld.",
17516 (long int) NPY_FLOAT64,
17517 (long int) PyArray_TYPE((PyArrayObject*) py_V315),
17518 (long int) PyArray_NDIM(tmp),
17519 (long int) (PyArray_NDIM(tmp) >= 3 ?
17520 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
17521 (long int) (PyArray_NDIM(tmp) >= 2 ?
17522 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
17523 (long int) (PyArray_NDIM(tmp) >= 1 ?
17524 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
17525 (long int) (PyArray_NDIM(tmp) >= 3 ?
17526 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
17527 (long int) (PyArray_NDIM(tmp) >= 2 ?
17528 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
17529 (long int) (PyArray_NDIM(tmp) >= 1 ?
17530 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
17531 );
17532 {
17533 __failure = 316;
17534 if (!PyErr_Occurred()) {
17535 PyErr_SetString(PyExc_RuntimeError,
17536 "Unexpected error in an Op's C code. "
17537 "No Python exception was set.");
17538 }
17539 goto __label_316;}
17540 }
17541 // This is a TypeError to be consistent with DEBUG_MODE
17542 // Note: DEBUG_MODE also tells the name of the container
17543 if (PyArray_TYPE((PyArrayObject*) py_V315) != NPY_FLOAT64) {
17544 PyErr_Format(PyExc_TypeError,
17545 "expected type_num %d (NPY_FLOAT64) got %d",
17546 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V315));
17547 {
17548 __failure = 316;
17549 if (!PyErr_Occurred()) {
17550 PyErr_SetString(PyExc_RuntimeError,
17551 "Unexpected error in an Op's C code. "
17552 "No Python exception was set.");
17553 }
17554 goto __label_316;}
17555 }
17556
17557 V315 = (PyArrayObject*)(py_V315);
17558 Py_XINCREF(V315);
17559
17560 {
17561
17562 py_V317 = PyList_GET_ITEM(storage_V317, 0);
17563 {Py_XINCREF(py_V317);}
17564
17565 V317 = NULL;
17566 if (py_V317 == Py_None) {
17567 // We can either fail here or set V317 to NULL and rely on Ops
17568 // using tensors to handle the NULL case, but if they fail to do so
17569 // they'll end up with nasty segfaults, so this is public service.
17570 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
17571 {
17572 __failure = 318;
17573 if (!PyErr_Occurred()) {
17574 PyErr_SetString(PyExc_RuntimeError,
17575 "Unexpected error in an Op's C code. "
17576 "No Python exception was set.");
17577 }
17578 goto __label_318;}
17579 }
17580 if (!PyArray_Check(py_V317)) {
17581 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
17582 {
17583 __failure = 318;
17584 if (!PyErr_Occurred()) {
17585 PyErr_SetString(PyExc_RuntimeError,
17586 "Unexpected error in an Op's C code. "
17587 "No Python exception was set.");
17588 }
17589 goto __label_318;}
17590 }
17591 // We expect NPY_FLOAT64
17592 if (!PyArray_ISALIGNED((PyArrayObject*) py_V317)) {
17593 PyArrayObject * tmp = (PyArrayObject*) py_V317;
17594 PyErr_Format(PyExc_NotImplementedError,
17595 "expected an aligned array of type %ld "
17596 "(NPY_FLOAT64), got non-aligned array of type %ld"
17597 " with %ld dimensions, with 3 last dims "
17598 "%ld, %ld, %ld"
17599 " and 3 last strides %ld %ld, %ld.",
17600 (long int) NPY_FLOAT64,
17601 (long int) PyArray_TYPE((PyArrayObject*) py_V317),
17602 (long int) PyArray_NDIM(tmp),
17603 (long int) (PyArray_NDIM(tmp) >= 3 ?
17604 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
17605 (long int) (PyArray_NDIM(tmp) >= 2 ?
17606 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
17607 (long int) (PyArray_NDIM(tmp) >= 1 ?
17608 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
17609 (long int) (PyArray_NDIM(tmp) >= 3 ?
17610 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
17611 (long int) (PyArray_NDIM(tmp) >= 2 ?
17612 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
17613 (long int) (PyArray_NDIM(tmp) >= 1 ?
17614 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
17615 );
17616 {
17617 __failure = 318;
17618 if (!PyErr_Occurred()) {
17619 PyErr_SetString(PyExc_RuntimeError,
17620 "Unexpected error in an Op's C code. "
17621 "No Python exception was set.");
17622 }
17623 goto __label_318;}
17624 }
17625 // This is a TypeError to be consistent with DEBUG_MODE
17626 // Note: DEBUG_MODE also tells the name of the container
17627 if (PyArray_TYPE((PyArrayObject*) py_V317) != NPY_FLOAT64) {
17628 PyErr_Format(PyExc_TypeError,
17629 "expected type_num %d (NPY_FLOAT64) got %d",
17630 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V317));
17631 {
17632 __failure = 318;
17633 if (!PyErr_Occurred()) {
17634 PyErr_SetString(PyExc_RuntimeError,
17635 "Unexpected error in an Op's C code. "
17636 "No Python exception was set.");
17637 }
17638 goto __label_318;}
17639 }
17640
17641 V317 = (PyArrayObject*)(py_V317);
17642 Py_XINCREF(V317);
17643
17644 {
17645
17646 py_V319 = PyList_GET_ITEM(storage_V319, 0);
17647 {Py_XINCREF(py_V319);}
17648
17649 V319 = NULL;
17650 if (py_V319 == Py_None) {
17651 // We can either fail here or set V319 to NULL and rely on Ops
17652 // using tensors to handle the NULL case, but if they fail to do so
17653 // they'll end up with nasty segfaults, so this is public service.
17654 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
17655 {
17656 __failure = 320;
17657 if (!PyErr_Occurred()) {
17658 PyErr_SetString(PyExc_RuntimeError,
17659 "Unexpected error in an Op's C code. "
17660 "No Python exception was set.");
17661 }
17662 goto __label_320;}
17663 }
17664 if (!PyArray_Check(py_V319)) {
17665 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
17666 {
17667 __failure = 320;
17668 if (!PyErr_Occurred()) {
17669 PyErr_SetString(PyExc_RuntimeError,
17670 "Unexpected error in an Op's C code. "
17671 "No Python exception was set.");
17672 }
17673 goto __label_320;}
17674 }
17675 // We expect NPY_FLOAT64
17676 if (!PyArray_ISALIGNED((PyArrayObject*) py_V319)) {
17677 PyArrayObject * tmp = (PyArrayObject*) py_V319;
17678 PyErr_Format(PyExc_NotImplementedError,
17679 "expected an aligned array of type %ld "
17680 "(NPY_FLOAT64), got non-aligned array of type %ld"
17681 " with %ld dimensions, with 3 last dims "
17682 "%ld, %ld, %ld"
17683 " and 3 last strides %ld %ld, %ld.",
17684 (long int) NPY_FLOAT64,
17685 (long int) PyArray_TYPE((PyArrayObject*) py_V319),
17686 (long int) PyArray_NDIM(tmp),
17687 (long int) (PyArray_NDIM(tmp) >= 3 ?
17688 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
17689 (long int) (PyArray_NDIM(tmp) >= 2 ?
17690 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
17691 (long int) (PyArray_NDIM(tmp) >= 1 ?
17692 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
17693 (long int) (PyArray_NDIM(tmp) >= 3 ?
17694 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
17695 (long int) (PyArray_NDIM(tmp) >= 2 ?
17696 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
17697 (long int) (PyArray_NDIM(tmp) >= 1 ?
17698 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
17699 );
17700 {
17701 __failure = 320;
17702 if (!PyErr_Occurred()) {
17703 PyErr_SetString(PyExc_RuntimeError,
17704 "Unexpected error in an Op's C code. "
17705 "No Python exception was set.");
17706 }
17707 goto __label_320;}
17708 }
17709 // This is a TypeError to be consistent with DEBUG_MODE
17710 // Note: DEBUG_MODE also tells the name of the container
17711 if (PyArray_TYPE((PyArrayObject*) py_V319) != NPY_FLOAT64) {
17712 PyErr_Format(PyExc_TypeError,
17713 "expected type_num %d (NPY_FLOAT64) got %d",
17714 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V319));
17715 {
17716 __failure = 320;
17717 if (!PyErr_Occurred()) {
17718 PyErr_SetString(PyExc_RuntimeError,
17719 "Unexpected error in an Op's C code. "
17720 "No Python exception was set.");
17721 }
17722 goto __label_320;}
17723 }
17724
17725 V319 = (PyArrayObject*)(py_V319);
17726 Py_XINCREF(V319);
17727
17728 {
17729
17730 py_V321 = PyList_GET_ITEM(storage_V321, 0);
17731 {Py_XINCREF(py_V321);}
17732
17733 V321 = NULL;
17734 if (py_V321 == Py_None) {
17735 // We can either fail here or set V321 to NULL and rely on Ops
17736 // using tensors to handle the NULL case, but if they fail to do so
17737 // they'll end up with nasty segfaults, so this is public service.
17738 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
17739 {
17740 __failure = 322;
17741 if (!PyErr_Occurred()) {
17742 PyErr_SetString(PyExc_RuntimeError,
17743 "Unexpected error in an Op's C code. "
17744 "No Python exception was set.");
17745 }
17746 goto __label_322;}
17747 }
17748 if (!PyArray_Check(py_V321)) {
17749 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
17750 {
17751 __failure = 322;
17752 if (!PyErr_Occurred()) {
17753 PyErr_SetString(PyExc_RuntimeError,
17754 "Unexpected error in an Op's C code. "
17755 "No Python exception was set.");
17756 }
17757 goto __label_322;}
17758 }
17759 // We expect NPY_FLOAT64
17760 if (!PyArray_ISALIGNED((PyArrayObject*) py_V321)) {
17761 PyArrayObject * tmp = (PyArrayObject*) py_V321;
17762 PyErr_Format(PyExc_NotImplementedError,
17763 "expected an aligned array of type %ld "
17764 "(NPY_FLOAT64), got non-aligned array of type %ld"
17765 " with %ld dimensions, with 3 last dims "
17766 "%ld, %ld, %ld"
17767 " and 3 last strides %ld %ld, %ld.",
17768 (long int) NPY_FLOAT64,
17769 (long int) PyArray_TYPE((PyArrayObject*) py_V321),
17770 (long int) PyArray_NDIM(tmp),
17771 (long int) (PyArray_NDIM(tmp) >= 3 ?
17772 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
17773 (long int) (PyArray_NDIM(tmp) >= 2 ?
17774 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
17775 (long int) (PyArray_NDIM(tmp) >= 1 ?
17776 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
17777 (long int) (PyArray_NDIM(tmp) >= 3 ?
17778 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
17779 (long int) (PyArray_NDIM(tmp) >= 2 ?
17780 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
17781 (long int) (PyArray_NDIM(tmp) >= 1 ?
17782 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
17783 );
17784 {
17785 __failure = 322;
17786 if (!PyErr_Occurred()) {
17787 PyErr_SetString(PyExc_RuntimeError,
17788 "Unexpected error in an Op's C code. "
17789 "No Python exception was set.");
17790 }
17791 goto __label_322;}
17792 }
17793 // This is a TypeError to be consistent with DEBUG_MODE
17794 // Note: DEBUG_MODE also tells the name of the container
17795 if (PyArray_TYPE((PyArrayObject*) py_V321) != NPY_FLOAT64) {
17796 PyErr_Format(PyExc_TypeError,
17797 "expected type_num %d (NPY_FLOAT64) got %d",
17798 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V321));
17799 {
17800 __failure = 322;
17801 if (!PyErr_Occurred()) {
17802 PyErr_SetString(PyExc_RuntimeError,
17803 "Unexpected error in an Op's C code. "
17804 "No Python exception was set.");
17805 }
17806 goto __label_322;}
17807 }
17808
17809 V321 = (PyArrayObject*)(py_V321);
17810 Py_XINCREF(V321);
17811
17812 {
17813
17814 py_V323 = PyList_GET_ITEM(storage_V323, 0);
17815 {Py_XINCREF(py_V323);}
17816
17817 V323 = NULL;
17818 if (py_V323 == Py_None) {
17819 // We can either fail here or set V323 to NULL and rely on Ops
17820 // using tensors to handle the NULL case, but if they fail to do so
17821 // they'll end up with nasty segfaults, so this is public service.
17822 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
17823 {
17824 __failure = 324;
17825 if (!PyErr_Occurred()) {
17826 PyErr_SetString(PyExc_RuntimeError,
17827 "Unexpected error in an Op's C code. "
17828 "No Python exception was set.");
17829 }
17830 goto __label_324;}
17831 }
17832 if (!PyArray_Check(py_V323)) {
17833 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
17834 {
17835 __failure = 324;
17836 if (!PyErr_Occurred()) {
17837 PyErr_SetString(PyExc_RuntimeError,
17838 "Unexpected error in an Op's C code. "
17839 "No Python exception was set.");
17840 }
17841 goto __label_324;}
17842 }
17843 // We expect NPY_FLOAT64
17844 if (!PyArray_ISALIGNED((PyArrayObject*) py_V323)) {
17845 PyArrayObject * tmp = (PyArrayObject*) py_V323;
17846 PyErr_Format(PyExc_NotImplementedError,
17847 "expected an aligned array of type %ld "
17848 "(NPY_FLOAT64), got non-aligned array of type %ld"
17849 " with %ld dimensions, with 3 last dims "
17850 "%ld, %ld, %ld"
17851 " and 3 last strides %ld %ld, %ld.",
17852 (long int) NPY_FLOAT64,
17853 (long int) PyArray_TYPE((PyArrayObject*) py_V323),
17854 (long int) PyArray_NDIM(tmp),
17855 (long int) (PyArray_NDIM(tmp) >= 3 ?
17856 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
17857 (long int) (PyArray_NDIM(tmp) >= 2 ?
17858 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
17859 (long int) (PyArray_NDIM(tmp) >= 1 ?
17860 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
17861 (long int) (PyArray_NDIM(tmp) >= 3 ?
17862 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
17863 (long int) (PyArray_NDIM(tmp) >= 2 ?
17864 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
17865 (long int) (PyArray_NDIM(tmp) >= 1 ?
17866 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
17867 );
17868 {
17869 __failure = 324;
17870 if (!PyErr_Occurred()) {
17871 PyErr_SetString(PyExc_RuntimeError,
17872 "Unexpected error in an Op's C code. "
17873 "No Python exception was set.");
17874 }
17875 goto __label_324;}
17876 }
17877 // This is a TypeError to be consistent with DEBUG_MODE
17878 // Note: DEBUG_MODE also tells the name of the container
17879 if (PyArray_TYPE((PyArrayObject*) py_V323) != NPY_FLOAT64) {
17880 PyErr_Format(PyExc_TypeError,
17881 "expected type_num %d (NPY_FLOAT64) got %d",
17882 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V323));
17883 {
17884 __failure = 324;
17885 if (!PyErr_Occurred()) {
17886 PyErr_SetString(PyExc_RuntimeError,
17887 "Unexpected error in an Op's C code. "
17888 "No Python exception was set.");
17889 }
17890 goto __label_324;}
17891 }
17892
17893 V323 = (PyArrayObject*)(py_V323);
17894 Py_XINCREF(V323);
17895
17896 {
17897
17898 py_V325 = PyList_GET_ITEM(storage_V325, 0);
17899 {Py_XINCREF(py_V325);}
17900
17901 V325 = NULL;
17902 if (py_V325 == Py_None) {
17903 // We can either fail here or set V325 to NULL and rely on Ops
17904 // using tensors to handle the NULL case, but if they fail to do so
17905 // they'll end up with nasty segfaults, so this is public service.
17906 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
17907 {
17908 __failure = 326;
17909 if (!PyErr_Occurred()) {
17910 PyErr_SetString(PyExc_RuntimeError,
17911 "Unexpected error in an Op's C code. "
17912 "No Python exception was set.");
17913 }
17914 goto __label_326;}
17915 }
17916 if (!PyArray_Check(py_V325)) {
17917 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
17918 {
17919 __failure = 326;
17920 if (!PyErr_Occurred()) {
17921 PyErr_SetString(PyExc_RuntimeError,
17922 "Unexpected error in an Op's C code. "
17923 "No Python exception was set.");
17924 }
17925 goto __label_326;}
17926 }
17927 // We expect NPY_FLOAT64
17928 if (!PyArray_ISALIGNED((PyArrayObject*) py_V325)) {
17929 PyArrayObject * tmp = (PyArrayObject*) py_V325;
17930 PyErr_Format(PyExc_NotImplementedError,
17931 "expected an aligned array of type %ld "
17932 "(NPY_FLOAT64), got non-aligned array of type %ld"
17933 " with %ld dimensions, with 3 last dims "
17934 "%ld, %ld, %ld"
17935 " and 3 last strides %ld %ld, %ld.",
17936 (long int) NPY_FLOAT64,
17937 (long int) PyArray_TYPE((PyArrayObject*) py_V325),
17938 (long int) PyArray_NDIM(tmp),
17939 (long int) (PyArray_NDIM(tmp) >= 3 ?
17940 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
17941 (long int) (PyArray_NDIM(tmp) >= 2 ?
17942 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
17943 (long int) (PyArray_NDIM(tmp) >= 1 ?
17944 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
17945 (long int) (PyArray_NDIM(tmp) >= 3 ?
17946 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
17947 (long int) (PyArray_NDIM(tmp) >= 2 ?
17948 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
17949 (long int) (PyArray_NDIM(tmp) >= 1 ?
17950 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
17951 );
17952 {
17953 __failure = 326;
17954 if (!PyErr_Occurred()) {
17955 PyErr_SetString(PyExc_RuntimeError,
17956 "Unexpected error in an Op's C code. "
17957 "No Python exception was set.");
17958 }
17959 goto __label_326;}
17960 }
17961 // This is a TypeError to be consistent with DEBUG_MODE
17962 // Note: DEBUG_MODE also tells the name of the container
17963 if (PyArray_TYPE((PyArrayObject*) py_V325) != NPY_FLOAT64) {
17964 PyErr_Format(PyExc_TypeError,
17965 "expected type_num %d (NPY_FLOAT64) got %d",
17966 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V325));
17967 {
17968 __failure = 326;
17969 if (!PyErr_Occurred()) {
17970 PyErr_SetString(PyExc_RuntimeError,
17971 "Unexpected error in an Op's C code. "
17972 "No Python exception was set.");
17973 }
17974 goto __label_326;}
17975 }
17976
17977 V325 = (PyArrayObject*)(py_V325);
17978 Py_XINCREF(V325);
17979
17980 {
17981
17982 py_V327 = PyList_GET_ITEM(storage_V327, 0);
17983 {Py_XINCREF(py_V327);}
17984
17985 V327 = NULL;
17986 if (py_V327 == Py_None) {
17987 // We can either fail here or set V327 to NULL and rely on Ops
17988 // using tensors to handle the NULL case, but if they fail to do so
17989 // they'll end up with nasty segfaults, so this is public service.
17990 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
17991 {
17992 __failure = 328;
17993 if (!PyErr_Occurred()) {
17994 PyErr_SetString(PyExc_RuntimeError,
17995 "Unexpected error in an Op's C code. "
17996 "No Python exception was set.");
17997 }
17998 goto __label_328;}
17999 }
18000 if (!PyArray_Check(py_V327)) {
18001 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
18002 {
18003 __failure = 328;
18004 if (!PyErr_Occurred()) {
18005 PyErr_SetString(PyExc_RuntimeError,
18006 "Unexpected error in an Op's C code. "
18007 "No Python exception was set.");
18008 }
18009 goto __label_328;}
18010 }
18011 // We expect NPY_FLOAT64
18012 if (!PyArray_ISALIGNED((PyArrayObject*) py_V327)) {
18013 PyArrayObject * tmp = (PyArrayObject*) py_V327;
18014 PyErr_Format(PyExc_NotImplementedError,
18015 "expected an aligned array of type %ld "
18016 "(NPY_FLOAT64), got non-aligned array of type %ld"
18017 " with %ld dimensions, with 3 last dims "
18018 "%ld, %ld, %ld"
18019 " and 3 last strides %ld %ld, %ld.",
18020 (long int) NPY_FLOAT64,
18021 (long int) PyArray_TYPE((PyArrayObject*) py_V327),
18022 (long int) PyArray_NDIM(tmp),
18023 (long int) (PyArray_NDIM(tmp) >= 3 ?
18024 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
18025 (long int) (PyArray_NDIM(tmp) >= 2 ?
18026 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
18027 (long int) (PyArray_NDIM(tmp) >= 1 ?
18028 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
18029 (long int) (PyArray_NDIM(tmp) >= 3 ?
18030 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
18031 (long int) (PyArray_NDIM(tmp) >= 2 ?
18032 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
18033 (long int) (PyArray_NDIM(tmp) >= 1 ?
18034 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
18035 );
18036 {
18037 __failure = 328;
18038 if (!PyErr_Occurred()) {
18039 PyErr_SetString(PyExc_RuntimeError,
18040 "Unexpected error in an Op's C code. "
18041 "No Python exception was set.");
18042 }
18043 goto __label_328;}
18044 }
18045 // This is a TypeError to be consistent with DEBUG_MODE
18046 // Note: DEBUG_MODE also tells the name of the container
18047 if (PyArray_TYPE((PyArrayObject*) py_V327) != NPY_FLOAT64) {
18048 PyErr_Format(PyExc_TypeError,
18049 "expected type_num %d (NPY_FLOAT64) got %d",
18050 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V327));
18051 {
18052 __failure = 328;
18053 if (!PyErr_Occurred()) {
18054 PyErr_SetString(PyExc_RuntimeError,
18055 "Unexpected error in an Op's C code. "
18056 "No Python exception was set.");
18057 }
18058 goto __label_328;}
18059 }
18060
18061 V327 = (PyArrayObject*)(py_V327);
18062 Py_XINCREF(V327);
18063
18064 {
18065
18066 py_V329 = PyList_GET_ITEM(storage_V329, 0);
18067 {Py_XINCREF(py_V329);}
18068
18069 V329 = NULL;
18070 if (py_V329 == Py_None) {
18071 // We can either fail here or set V329 to NULL and rely on Ops
18072 // using tensors to handle the NULL case, but if they fail to do so
18073 // they'll end up with nasty segfaults, so this is public service.
18074 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
18075 {
18076 __failure = 330;
18077 if (!PyErr_Occurred()) {
18078 PyErr_SetString(PyExc_RuntimeError,
18079 "Unexpected error in an Op's C code. "
18080 "No Python exception was set.");
18081 }
18082 goto __label_330;}
18083 }
18084 if (!PyArray_Check(py_V329)) {
18085 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
18086 {
18087 __failure = 330;
18088 if (!PyErr_Occurred()) {
18089 PyErr_SetString(PyExc_RuntimeError,
18090 "Unexpected error in an Op's C code. "
18091 "No Python exception was set.");
18092 }
18093 goto __label_330;}
18094 }
18095 // We expect NPY_FLOAT64
18096 if (!PyArray_ISALIGNED((PyArrayObject*) py_V329)) {
18097 PyArrayObject * tmp = (PyArrayObject*) py_V329;
18098 PyErr_Format(PyExc_NotImplementedError,
18099 "expected an aligned array of type %ld "
18100 "(NPY_FLOAT64), got non-aligned array of type %ld"
18101 " with %ld dimensions, with 3 last dims "
18102 "%ld, %ld, %ld"
18103 " and 3 last strides %ld %ld, %ld.",
18104 (long int) NPY_FLOAT64,
18105 (long int) PyArray_TYPE((PyArrayObject*) py_V329),
18106 (long int) PyArray_NDIM(tmp),
18107 (long int) (PyArray_NDIM(tmp) >= 3 ?
18108 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
18109 (long int) (PyArray_NDIM(tmp) >= 2 ?
18110 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
18111 (long int) (PyArray_NDIM(tmp) >= 1 ?
18112 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
18113 (long int) (PyArray_NDIM(tmp) >= 3 ?
18114 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
18115 (long int) (PyArray_NDIM(tmp) >= 2 ?
18116 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
18117 (long int) (PyArray_NDIM(tmp) >= 1 ?
18118 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
18119 );
18120 {
18121 __failure = 330;
18122 if (!PyErr_Occurred()) {
18123 PyErr_SetString(PyExc_RuntimeError,
18124 "Unexpected error in an Op's C code. "
18125 "No Python exception was set.");
18126 }
18127 goto __label_330;}
18128 }
18129 // This is a TypeError to be consistent with DEBUG_MODE
18130 // Note: DEBUG_MODE also tells the name of the container
18131 if (PyArray_TYPE((PyArrayObject*) py_V329) != NPY_FLOAT64) {
18132 PyErr_Format(PyExc_TypeError,
18133 "expected type_num %d (NPY_FLOAT64) got %d",
18134 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V329));
18135 {
18136 __failure = 330;
18137 if (!PyErr_Occurred()) {
18138 PyErr_SetString(PyExc_RuntimeError,
18139 "Unexpected error in an Op's C code. "
18140 "No Python exception was set.");
18141 }
18142 goto __label_330;}
18143 }
18144
18145 V329 = (PyArrayObject*)(py_V329);
18146 Py_XINCREF(V329);
18147
18148 {
18149
18150 py_V331 = PyList_GET_ITEM(storage_V331, 0);
18151 {Py_XINCREF(py_V331);}
18152
18153 V331 = NULL;
18154 if (py_V331 == Py_None) {
18155 // We can either fail here or set V331 to NULL and rely on Ops
18156 // using tensors to handle the NULL case, but if they fail to do so
18157 // they'll end up with nasty segfaults, so this is public service.
18158 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
18159 {
18160 __failure = 332;
18161 if (!PyErr_Occurred()) {
18162 PyErr_SetString(PyExc_RuntimeError,
18163 "Unexpected error in an Op's C code. "
18164 "No Python exception was set.");
18165 }
18166 goto __label_332;}
18167 }
18168 if (!PyArray_Check(py_V331)) {
18169 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
18170 {
18171 __failure = 332;
18172 if (!PyErr_Occurred()) {
18173 PyErr_SetString(PyExc_RuntimeError,
18174 "Unexpected error in an Op's C code. "
18175 "No Python exception was set.");
18176 }
18177 goto __label_332;}
18178 }
18179 // We expect NPY_FLOAT64
18180 if (!PyArray_ISALIGNED((PyArrayObject*) py_V331)) {
18181 PyArrayObject * tmp = (PyArrayObject*) py_V331;
18182 PyErr_Format(PyExc_NotImplementedError,
18183 "expected an aligned array of type %ld "
18184 "(NPY_FLOAT64), got non-aligned array of type %ld"
18185 " with %ld dimensions, with 3 last dims "
18186 "%ld, %ld, %ld"
18187 " and 3 last strides %ld %ld, %ld.",
18188 (long int) NPY_FLOAT64,
18189 (long int) PyArray_TYPE((PyArrayObject*) py_V331),
18190 (long int) PyArray_NDIM(tmp),
18191 (long int) (PyArray_NDIM(tmp) >= 3 ?
18192 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
18193 (long int) (PyArray_NDIM(tmp) >= 2 ?
18194 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
18195 (long int) (PyArray_NDIM(tmp) >= 1 ?
18196 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
18197 (long int) (PyArray_NDIM(tmp) >= 3 ?
18198 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
18199 (long int) (PyArray_NDIM(tmp) >= 2 ?
18200 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
18201 (long int) (PyArray_NDIM(tmp) >= 1 ?
18202 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
18203 );
18204 {
18205 __failure = 332;
18206 if (!PyErr_Occurred()) {
18207 PyErr_SetString(PyExc_RuntimeError,
18208 "Unexpected error in an Op's C code. "
18209 "No Python exception was set.");
18210 }
18211 goto __label_332;}
18212 }
18213 // This is a TypeError to be consistent with DEBUG_MODE
18214 // Note: DEBUG_MODE also tells the name of the container
18215 if (PyArray_TYPE((PyArrayObject*) py_V331) != NPY_FLOAT64) {
18216 PyErr_Format(PyExc_TypeError,
18217 "expected type_num %d (NPY_FLOAT64) got %d",
18218 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V331));
18219 {
18220 __failure = 332;
18221 if (!PyErr_Occurred()) {
18222 PyErr_SetString(PyExc_RuntimeError,
18223 "Unexpected error in an Op's C code. "
18224 "No Python exception was set.");
18225 }
18226 goto __label_332;}
18227 }
18228
18229 V331 = (PyArrayObject*)(py_V331);
18230 Py_XINCREF(V331);
18231
18232 {
18233
18234 py_V333 = PyList_GET_ITEM(storage_V333, 0);
18235 {Py_XINCREF(py_V333);}
18236
18237 V333 = NULL;
18238 if (py_V333 == Py_None) {
18239 // We can either fail here or set V333 to NULL and rely on Ops
18240 // using tensors to handle the NULL case, but if they fail to do so
18241 // they'll end up with nasty segfaults, so this is public service.
18242 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
18243 {
18244 __failure = 334;
18245 if (!PyErr_Occurred()) {
18246 PyErr_SetString(PyExc_RuntimeError,
18247 "Unexpected error in an Op's C code. "
18248 "No Python exception was set.");
18249 }
18250 goto __label_334;}
18251 }
18252 if (!PyArray_Check(py_V333)) {
18253 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
18254 {
18255 __failure = 334;
18256 if (!PyErr_Occurred()) {
18257 PyErr_SetString(PyExc_RuntimeError,
18258 "Unexpected error in an Op's C code. "
18259 "No Python exception was set.");
18260 }
18261 goto __label_334;}
18262 }
18263 // We expect NPY_FLOAT64
18264 if (!PyArray_ISALIGNED((PyArrayObject*) py_V333)) {
18265 PyArrayObject * tmp = (PyArrayObject*) py_V333;
18266 PyErr_Format(PyExc_NotImplementedError,
18267 "expected an aligned array of type %ld "
18268 "(NPY_FLOAT64), got non-aligned array of type %ld"
18269 " with %ld dimensions, with 3 last dims "
18270 "%ld, %ld, %ld"
18271 " and 3 last strides %ld %ld, %ld.",
18272 (long int) NPY_FLOAT64,
18273 (long int) PyArray_TYPE((PyArrayObject*) py_V333),
18274 (long int) PyArray_NDIM(tmp),
18275 (long int) (PyArray_NDIM(tmp) >= 3 ?
18276 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
18277 (long int) (PyArray_NDIM(tmp) >= 2 ?
18278 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
18279 (long int) (PyArray_NDIM(tmp) >= 1 ?
18280 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
18281 (long int) (PyArray_NDIM(tmp) >= 3 ?
18282 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
18283 (long int) (PyArray_NDIM(tmp) >= 2 ?
18284 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
18285 (long int) (PyArray_NDIM(tmp) >= 1 ?
18286 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
18287 );
18288 {
18289 __failure = 334;
18290 if (!PyErr_Occurred()) {
18291 PyErr_SetString(PyExc_RuntimeError,
18292 "Unexpected error in an Op's C code. "
18293 "No Python exception was set.");
18294 }
18295 goto __label_334;}
18296 }
18297 // This is a TypeError to be consistent with DEBUG_MODE
18298 // Note: DEBUG_MODE also tells the name of the container
18299 if (PyArray_TYPE((PyArrayObject*) py_V333) != NPY_FLOAT64) {
18300 PyErr_Format(PyExc_TypeError,
18301 "expected type_num %d (NPY_FLOAT64) got %d",
18302 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V333));
18303 {
18304 __failure = 334;
18305 if (!PyErr_Occurred()) {
18306 PyErr_SetString(PyExc_RuntimeError,
18307 "Unexpected error in an Op's C code. "
18308 "No Python exception was set.");
18309 }
18310 goto __label_334;}
18311 }
18312
18313 V333 = (PyArrayObject*)(py_V333);
18314 Py_XINCREF(V333);
18315
18316 {
18317
18318 py_V335 = PyList_GET_ITEM(storage_V335, 0);
18319 {Py_XINCREF(py_V335);}
18320
18321 V335 = NULL;
18322 if (py_V335 == Py_None) {
18323 // We can either fail here or set V335 to NULL and rely on Ops
18324 // using tensors to handle the NULL case, but if they fail to do so
18325 // they'll end up with nasty segfaults, so this is public service.
18326 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
18327 {
18328 __failure = 336;
18329 if (!PyErr_Occurred()) {
18330 PyErr_SetString(PyExc_RuntimeError,
18331 "Unexpected error in an Op's C code. "
18332 "No Python exception was set.");
18333 }
18334 goto __label_336;}
18335 }
18336 if (!PyArray_Check(py_V335)) {
18337 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
18338 {
18339 __failure = 336;
18340 if (!PyErr_Occurred()) {
18341 PyErr_SetString(PyExc_RuntimeError,
18342 "Unexpected error in an Op's C code. "
18343 "No Python exception was set.");
18344 }
18345 goto __label_336;}
18346 }
18347 // We expect NPY_FLOAT64
18348 if (!PyArray_ISALIGNED((PyArrayObject*) py_V335)) {
18349 PyArrayObject * tmp = (PyArrayObject*) py_V335;
18350 PyErr_Format(PyExc_NotImplementedError,
18351 "expected an aligned array of type %ld "
18352 "(NPY_FLOAT64), got non-aligned array of type %ld"
18353 " with %ld dimensions, with 3 last dims "
18354 "%ld, %ld, %ld"
18355 " and 3 last strides %ld %ld, %ld.",
18356 (long int) NPY_FLOAT64,
18357 (long int) PyArray_TYPE((PyArrayObject*) py_V335),
18358 (long int) PyArray_NDIM(tmp),
18359 (long int) (PyArray_NDIM(tmp) >= 3 ?
18360 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
18361 (long int) (PyArray_NDIM(tmp) >= 2 ?
18362 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
18363 (long int) (PyArray_NDIM(tmp) >= 1 ?
18364 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
18365 (long int) (PyArray_NDIM(tmp) >= 3 ?
18366 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
18367 (long int) (PyArray_NDIM(tmp) >= 2 ?
18368 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
18369 (long int) (PyArray_NDIM(tmp) >= 1 ?
18370 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
18371 );
18372 {
18373 __failure = 336;
18374 if (!PyErr_Occurred()) {
18375 PyErr_SetString(PyExc_RuntimeError,
18376 "Unexpected error in an Op's C code. "
18377 "No Python exception was set.");
18378 }
18379 goto __label_336;}
18380 }
18381 // This is a TypeError to be consistent with DEBUG_MODE
18382 // Note: DEBUG_MODE also tells the name of the container
18383 if (PyArray_TYPE((PyArrayObject*) py_V335) != NPY_FLOAT64) {
18384 PyErr_Format(PyExc_TypeError,
18385 "expected type_num %d (NPY_FLOAT64) got %d",
18386 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V335));
18387 {
18388 __failure = 336;
18389 if (!PyErr_Occurred()) {
18390 PyErr_SetString(PyExc_RuntimeError,
18391 "Unexpected error in an Op's C code. "
18392 "No Python exception was set.");
18393 }
18394 goto __label_336;}
18395 }
18396
18397 V335 = (PyArrayObject*)(py_V335);
18398 Py_XINCREF(V335);
18399
18400 {
18401
18402 py_V337 = PyList_GET_ITEM(storage_V337, 0);
18403 {Py_XINCREF(py_V337);}
18404
18405 V337 = NULL;
18406 if (py_V337 == Py_None) {
18407 // We can either fail here or set V337 to NULL and rely on Ops
18408 // using tensors to handle the NULL case, but if they fail to do so
18409 // they'll end up with nasty segfaults, so this is public service.
18410 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
18411 {
18412 __failure = 338;
18413 if (!PyErr_Occurred()) {
18414 PyErr_SetString(PyExc_RuntimeError,
18415 "Unexpected error in an Op's C code. "
18416 "No Python exception was set.");
18417 }
18418 goto __label_338;}
18419 }
18420 if (!PyArray_Check(py_V337)) {
18421 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
18422 {
18423 __failure = 338;
18424 if (!PyErr_Occurred()) {
18425 PyErr_SetString(PyExc_RuntimeError,
18426 "Unexpected error in an Op's C code. "
18427 "No Python exception was set.");
18428 }
18429 goto __label_338;}
18430 }
18431 // We expect NPY_FLOAT64
18432 if (!PyArray_ISALIGNED((PyArrayObject*) py_V337)) {
18433 PyArrayObject * tmp = (PyArrayObject*) py_V337;
18434 PyErr_Format(PyExc_NotImplementedError,
18435 "expected an aligned array of type %ld "
18436 "(NPY_FLOAT64), got non-aligned array of type %ld"
18437 " with %ld dimensions, with 3 last dims "
18438 "%ld, %ld, %ld"
18439 " and 3 last strides %ld %ld, %ld.",
18440 (long int) NPY_FLOAT64,
18441 (long int) PyArray_TYPE((PyArrayObject*) py_V337),
18442 (long int) PyArray_NDIM(tmp),
18443 (long int) (PyArray_NDIM(tmp) >= 3 ?
18444 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
18445 (long int) (PyArray_NDIM(tmp) >= 2 ?
18446 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
18447 (long int) (PyArray_NDIM(tmp) >= 1 ?
18448 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
18449 (long int) (PyArray_NDIM(tmp) >= 3 ?
18450 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
18451 (long int) (PyArray_NDIM(tmp) >= 2 ?
18452 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
18453 (long int) (PyArray_NDIM(tmp) >= 1 ?
18454 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
18455 );
18456 {
18457 __failure = 338;
18458 if (!PyErr_Occurred()) {
18459 PyErr_SetString(PyExc_RuntimeError,
18460 "Unexpected error in an Op's C code. "
18461 "No Python exception was set.");
18462 }
18463 goto __label_338;}
18464 }
18465 // This is a TypeError to be consistent with DEBUG_MODE
18466 // Note: DEBUG_MODE also tells the name of the container
18467 if (PyArray_TYPE((PyArrayObject*) py_V337) != NPY_FLOAT64) {
18468 PyErr_Format(PyExc_TypeError,
18469 "expected type_num %d (NPY_FLOAT64) got %d",
18470 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V337));
18471 {
18472 __failure = 338;
18473 if (!PyErr_Occurred()) {
18474 PyErr_SetString(PyExc_RuntimeError,
18475 "Unexpected error in an Op's C code. "
18476 "No Python exception was set.");
18477 }
18478 goto __label_338;}
18479 }
18480
18481 V337 = (PyArrayObject*)(py_V337);
18482 Py_XINCREF(V337);
18483
18484 {
18485
18486 py_V339 = PyList_GET_ITEM(storage_V339, 0);
18487 {Py_XINCREF(py_V339);}
18488
18489 V339 = NULL;
18490 if (py_V339 == Py_None) {
18491 // We can either fail here or set V339 to NULL and rely on Ops
18492 // using tensors to handle the NULL case, but if they fail to do so
18493 // they'll end up with nasty segfaults, so this is public service.
18494 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
18495 {
18496 __failure = 340;
18497 if (!PyErr_Occurred()) {
18498 PyErr_SetString(PyExc_RuntimeError,
18499 "Unexpected error in an Op's C code. "
18500 "No Python exception was set.");
18501 }
18502 goto __label_340;}
18503 }
18504 if (!PyArray_Check(py_V339)) {
18505 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
18506 {
18507 __failure = 340;
18508 if (!PyErr_Occurred()) {
18509 PyErr_SetString(PyExc_RuntimeError,
18510 "Unexpected error in an Op's C code. "
18511 "No Python exception was set.");
18512 }
18513 goto __label_340;}
18514 }
18515 // We expect NPY_FLOAT64
18516 if (!PyArray_ISALIGNED((PyArrayObject*) py_V339)) {
18517 PyArrayObject * tmp = (PyArrayObject*) py_V339;
18518 PyErr_Format(PyExc_NotImplementedError,
18519 "expected an aligned array of type %ld "
18520 "(NPY_FLOAT64), got non-aligned array of type %ld"
18521 " with %ld dimensions, with 3 last dims "
18522 "%ld, %ld, %ld"
18523 " and 3 last strides %ld %ld, %ld.",
18524 (long int) NPY_FLOAT64,
18525 (long int) PyArray_TYPE((PyArrayObject*) py_V339),
18526 (long int) PyArray_NDIM(tmp),
18527 (long int) (PyArray_NDIM(tmp) >= 3 ?
18528 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
18529 (long int) (PyArray_NDIM(tmp) >= 2 ?
18530 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
18531 (long int) (PyArray_NDIM(tmp) >= 1 ?
18532 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
18533 (long int) (PyArray_NDIM(tmp) >= 3 ?
18534 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
18535 (long int) (PyArray_NDIM(tmp) >= 2 ?
18536 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
18537 (long int) (PyArray_NDIM(tmp) >= 1 ?
18538 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
18539 );
18540 {
18541 __failure = 340;
18542 if (!PyErr_Occurred()) {
18543 PyErr_SetString(PyExc_RuntimeError,
18544 "Unexpected error in an Op's C code. "
18545 "No Python exception was set.");
18546 }
18547 goto __label_340;}
18548 }
18549 // This is a TypeError to be consistent with DEBUG_MODE
18550 // Note: DEBUG_MODE also tells the name of the container
18551 if (PyArray_TYPE((PyArrayObject*) py_V339) != NPY_FLOAT64) {
18552 PyErr_Format(PyExc_TypeError,
18553 "expected type_num %d (NPY_FLOAT64) got %d",
18554 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V339));
18555 {
18556 __failure = 340;
18557 if (!PyErr_Occurred()) {
18558 PyErr_SetString(PyExc_RuntimeError,
18559 "Unexpected error in an Op's C code. "
18560 "No Python exception was set.");
18561 }
18562 goto __label_340;}
18563 }
18564
18565 V339 = (PyArrayObject*)(py_V339);
18566 Py_XINCREF(V339);
18567
18568 {
18569
18570 py_V341 = PyList_GET_ITEM(storage_V341, 0);
18571 {Py_XINCREF(py_V341);}
18572
18573 V341 = NULL;
18574 if (py_V341 == Py_None) {
18575 // We can either fail here or set V341 to NULL and rely on Ops
18576 // using tensors to handle the NULL case, but if they fail to do so
18577 // they'll end up with nasty segfaults, so this is public service.
18578 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
18579 {
18580 __failure = 342;
18581 if (!PyErr_Occurred()) {
18582 PyErr_SetString(PyExc_RuntimeError,
18583 "Unexpected error in an Op's C code. "
18584 "No Python exception was set.");
18585 }
18586 goto __label_342;}
18587 }
18588 if (!PyArray_Check(py_V341)) {
18589 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
18590 {
18591 __failure = 342;
18592 if (!PyErr_Occurred()) {
18593 PyErr_SetString(PyExc_RuntimeError,
18594 "Unexpected error in an Op's C code. "
18595 "No Python exception was set.");
18596 }
18597 goto __label_342;}
18598 }
18599 // We expect NPY_FLOAT64
18600 if (!PyArray_ISALIGNED((PyArrayObject*) py_V341)) {
18601 PyArrayObject * tmp = (PyArrayObject*) py_V341;
18602 PyErr_Format(PyExc_NotImplementedError,
18603 "expected an aligned array of type %ld "
18604 "(NPY_FLOAT64), got non-aligned array of type %ld"
18605 " with %ld dimensions, with 3 last dims "
18606 "%ld, %ld, %ld"
18607 " and 3 last strides %ld %ld, %ld.",
18608 (long int) NPY_FLOAT64,
18609 (long int) PyArray_TYPE((PyArrayObject*) py_V341),
18610 (long int) PyArray_NDIM(tmp),
18611 (long int) (PyArray_NDIM(tmp) >= 3 ?
18612 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
18613 (long int) (PyArray_NDIM(tmp) >= 2 ?
18614 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
18615 (long int) (PyArray_NDIM(tmp) >= 1 ?
18616 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
18617 (long int) (PyArray_NDIM(tmp) >= 3 ?
18618 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
18619 (long int) (PyArray_NDIM(tmp) >= 2 ?
18620 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
18621 (long int) (PyArray_NDIM(tmp) >= 1 ?
18622 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
18623 );
18624 {
18625 __failure = 342;
18626 if (!PyErr_Occurred()) {
18627 PyErr_SetString(PyExc_RuntimeError,
18628 "Unexpected error in an Op's C code. "
18629 "No Python exception was set.");
18630 }
18631 goto __label_342;}
18632 }
18633 // This is a TypeError to be consistent with DEBUG_MODE
18634 // Note: DEBUG_MODE also tells the name of the container
18635 if (PyArray_TYPE((PyArrayObject*) py_V341) != NPY_FLOAT64) {
18636 PyErr_Format(PyExc_TypeError,
18637 "expected type_num %d (NPY_FLOAT64) got %d",
18638 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V341));
18639 {
18640 __failure = 342;
18641 if (!PyErr_Occurred()) {
18642 PyErr_SetString(PyExc_RuntimeError,
18643 "Unexpected error in an Op's C code. "
18644 "No Python exception was set.");
18645 }
18646 goto __label_342;}
18647 }
18648
18649 V341 = (PyArrayObject*)(py_V341);
18650 Py_XINCREF(V341);
18651
18652 {
18653
18654 py_V343 = PyList_GET_ITEM(storage_V343, 0);
18655 {Py_XINCREF(py_V343);}
18656
18657 V343 = NULL;
18658 if (py_V343 == Py_None) {
18659 // We can either fail here or set V343 to NULL and rely on Ops
18660 // using tensors to handle the NULL case, but if they fail to do so
18661 // they'll end up with nasty segfaults, so this is public service.
18662 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
18663 {
18664 __failure = 344;
18665 if (!PyErr_Occurred()) {
18666 PyErr_SetString(PyExc_RuntimeError,
18667 "Unexpected error in an Op's C code. "
18668 "No Python exception was set.");
18669 }
18670 goto __label_344;}
18671 }
18672 if (!PyArray_Check(py_V343)) {
18673 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
18674 {
18675 __failure = 344;
18676 if (!PyErr_Occurred()) {
18677 PyErr_SetString(PyExc_RuntimeError,
18678 "Unexpected error in an Op's C code. "
18679 "No Python exception was set.");
18680 }
18681 goto __label_344;}
18682 }
18683 // We expect NPY_FLOAT64
18684 if (!PyArray_ISALIGNED((PyArrayObject*) py_V343)) {
18685 PyArrayObject * tmp = (PyArrayObject*) py_V343;
18686 PyErr_Format(PyExc_NotImplementedError,
18687 "expected an aligned array of type %ld "
18688 "(NPY_FLOAT64), got non-aligned array of type %ld"
18689 " with %ld dimensions, with 3 last dims "
18690 "%ld, %ld, %ld"
18691 " and 3 last strides %ld %ld, %ld.",
18692 (long int) NPY_FLOAT64,
18693 (long int) PyArray_TYPE((PyArrayObject*) py_V343),
18694 (long int) PyArray_NDIM(tmp),
18695 (long int) (PyArray_NDIM(tmp) >= 3 ?
18696 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
18697 (long int) (PyArray_NDIM(tmp) >= 2 ?
18698 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
18699 (long int) (PyArray_NDIM(tmp) >= 1 ?
18700 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
18701 (long int) (PyArray_NDIM(tmp) >= 3 ?
18702 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
18703 (long int) (PyArray_NDIM(tmp) >= 2 ?
18704 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
18705 (long int) (PyArray_NDIM(tmp) >= 1 ?
18706 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
18707 );
18708 {
18709 __failure = 344;
18710 if (!PyErr_Occurred()) {
18711 PyErr_SetString(PyExc_RuntimeError,
18712 "Unexpected error in an Op's C code. "
18713 "No Python exception was set.");
18714 }
18715 goto __label_344;}
18716 }
18717 // This is a TypeError to be consistent with DEBUG_MODE
18718 // Note: DEBUG_MODE also tells the name of the container
18719 if (PyArray_TYPE((PyArrayObject*) py_V343) != NPY_FLOAT64) {
18720 PyErr_Format(PyExc_TypeError,
18721 "expected type_num %d (NPY_FLOAT64) got %d",
18722 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V343));
18723 {
18724 __failure = 344;
18725 if (!PyErr_Occurred()) {
18726 PyErr_SetString(PyExc_RuntimeError,
18727 "Unexpected error in an Op's C code. "
18728 "No Python exception was set.");
18729 }
18730 goto __label_344;}
18731 }
18732
18733 V343 = (PyArrayObject*)(py_V343);
18734 Py_XINCREF(V343);
18735
18736 {
18737
18738 py_V345 = PyList_GET_ITEM(storage_V345, 0);
18739 {Py_XINCREF(py_V345);}
18740
18741 V345 = NULL;
18742 if (py_V345 == Py_None) {
18743 // We can either fail here or set V345 to NULL and rely on Ops
18744 // using tensors to handle the NULL case, but if they fail to do so
18745 // they'll end up with nasty segfaults, so this is public service.
18746 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
18747 {
18748 __failure = 346;
18749 if (!PyErr_Occurred()) {
18750 PyErr_SetString(PyExc_RuntimeError,
18751 "Unexpected error in an Op's C code. "
18752 "No Python exception was set.");
18753 }
18754 goto __label_346;}
18755 }
18756 if (!PyArray_Check(py_V345)) {
18757 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
18758 {
18759 __failure = 346;
18760 if (!PyErr_Occurred()) {
18761 PyErr_SetString(PyExc_RuntimeError,
18762 "Unexpected error in an Op's C code. "
18763 "No Python exception was set.");
18764 }
18765 goto __label_346;}
18766 }
18767 // We expect NPY_FLOAT64
18768 if (!PyArray_ISALIGNED((PyArrayObject*) py_V345)) {
18769 PyArrayObject * tmp = (PyArrayObject*) py_V345;
18770 PyErr_Format(PyExc_NotImplementedError,
18771 "expected an aligned array of type %ld "
18772 "(NPY_FLOAT64), got non-aligned array of type %ld"
18773 " with %ld dimensions, with 3 last dims "
18774 "%ld, %ld, %ld"
18775 " and 3 last strides %ld %ld, %ld.",
18776 (long int) NPY_FLOAT64,
18777 (long int) PyArray_TYPE((PyArrayObject*) py_V345),
18778 (long int) PyArray_NDIM(tmp),
18779 (long int) (PyArray_NDIM(tmp) >= 3 ?
18780 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
18781 (long int) (PyArray_NDIM(tmp) >= 2 ?
18782 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
18783 (long int) (PyArray_NDIM(tmp) >= 1 ?
18784 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
18785 (long int) (PyArray_NDIM(tmp) >= 3 ?
18786 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
18787 (long int) (PyArray_NDIM(tmp) >= 2 ?
18788 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
18789 (long int) (PyArray_NDIM(tmp) >= 1 ?
18790 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
18791 );
18792 {
18793 __failure = 346;
18794 if (!PyErr_Occurred()) {
18795 PyErr_SetString(PyExc_RuntimeError,
18796 "Unexpected error in an Op's C code. "
18797 "No Python exception was set.");
18798 }
18799 goto __label_346;}
18800 }
18801 // This is a TypeError to be consistent with DEBUG_MODE
18802 // Note: DEBUG_MODE also tells the name of the container
18803 if (PyArray_TYPE((PyArrayObject*) py_V345) != NPY_FLOAT64) {
18804 PyErr_Format(PyExc_TypeError,
18805 "expected type_num %d (NPY_FLOAT64) got %d",
18806 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V345));
18807 {
18808 __failure = 346;
18809 if (!PyErr_Occurred()) {
18810 PyErr_SetString(PyExc_RuntimeError,
18811 "Unexpected error in an Op's C code. "
18812 "No Python exception was set.");
18813 }
18814 goto __label_346;}
18815 }
18816
18817 V345 = (PyArrayObject*)(py_V345);
18818 Py_XINCREF(V345);
18819
18820 {
18821
18822 py_V347 = PyList_GET_ITEM(storage_V347, 0);
18823 {Py_XINCREF(py_V347);}
18824
18825 V347 = NULL;
18826 if (py_V347 == Py_None) {
18827 // We can either fail here or set V347 to NULL and rely on Ops
18828 // using tensors to handle the NULL case, but if they fail to do so
18829 // they'll end up with nasty segfaults, so this is public service.
18830 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
18831 {
18832 __failure = 348;
18833 if (!PyErr_Occurred()) {
18834 PyErr_SetString(PyExc_RuntimeError,
18835 "Unexpected error in an Op's C code. "
18836 "No Python exception was set.");
18837 }
18838 goto __label_348;}
18839 }
18840 if (!PyArray_Check(py_V347)) {
18841 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
18842 {
18843 __failure = 348;
18844 if (!PyErr_Occurred()) {
18845 PyErr_SetString(PyExc_RuntimeError,
18846 "Unexpected error in an Op's C code. "
18847 "No Python exception was set.");
18848 }
18849 goto __label_348;}
18850 }
18851 // We expect NPY_FLOAT64
18852 if (!PyArray_ISALIGNED((PyArrayObject*) py_V347)) {
18853 PyArrayObject * tmp = (PyArrayObject*) py_V347;
18854 PyErr_Format(PyExc_NotImplementedError,
18855 "expected an aligned array of type %ld "
18856 "(NPY_FLOAT64), got non-aligned array of type %ld"
18857 " with %ld dimensions, with 3 last dims "
18858 "%ld, %ld, %ld"
18859 " and 3 last strides %ld %ld, %ld.",
18860 (long int) NPY_FLOAT64,
18861 (long int) PyArray_TYPE((PyArrayObject*) py_V347),
18862 (long int) PyArray_NDIM(tmp),
18863 (long int) (PyArray_NDIM(tmp) >= 3 ?
18864 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
18865 (long int) (PyArray_NDIM(tmp) >= 2 ?
18866 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
18867 (long int) (PyArray_NDIM(tmp) >= 1 ?
18868 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
18869 (long int) (PyArray_NDIM(tmp) >= 3 ?
18870 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
18871 (long int) (PyArray_NDIM(tmp) >= 2 ?
18872 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
18873 (long int) (PyArray_NDIM(tmp) >= 1 ?
18874 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
18875 );
18876 {
18877 __failure = 348;
18878 if (!PyErr_Occurred()) {
18879 PyErr_SetString(PyExc_RuntimeError,
18880 "Unexpected error in an Op's C code. "
18881 "No Python exception was set.");
18882 }
18883 goto __label_348;}
18884 }
18885 // This is a TypeError to be consistent with DEBUG_MODE
18886 // Note: DEBUG_MODE also tells the name of the container
18887 if (PyArray_TYPE((PyArrayObject*) py_V347) != NPY_FLOAT64) {
18888 PyErr_Format(PyExc_TypeError,
18889 "expected type_num %d (NPY_FLOAT64) got %d",
18890 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V347));
18891 {
18892 __failure = 348;
18893 if (!PyErr_Occurred()) {
18894 PyErr_SetString(PyExc_RuntimeError,
18895 "Unexpected error in an Op's C code. "
18896 "No Python exception was set.");
18897 }
18898 goto __label_348;}
18899 }
18900
18901 V347 = (PyArrayObject*)(py_V347);
18902 Py_XINCREF(V347);
18903
18904 {
18905
18906 py_V349 = PyList_GET_ITEM(storage_V349, 0);
18907 {Py_XINCREF(py_V349);}
18908
18909 V349 = NULL;
18910 if (py_V349 == Py_None) {
18911 // We can either fail here or set V349 to NULL and rely on Ops
18912 // using tensors to handle the NULL case, but if they fail to do so
18913 // they'll end up with nasty segfaults, so this is public service.
18914 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
18915 {
18916 __failure = 350;
18917 if (!PyErr_Occurred()) {
18918 PyErr_SetString(PyExc_RuntimeError,
18919 "Unexpected error in an Op's C code. "
18920 "No Python exception was set.");
18921 }
18922 goto __label_350;}
18923 }
18924 if (!PyArray_Check(py_V349)) {
18925 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
18926 {
18927 __failure = 350;
18928 if (!PyErr_Occurred()) {
18929 PyErr_SetString(PyExc_RuntimeError,
18930 "Unexpected error in an Op's C code. "
18931 "No Python exception was set.");
18932 }
18933 goto __label_350;}
18934 }
18935 // We expect NPY_FLOAT64
18936 if (!PyArray_ISALIGNED((PyArrayObject*) py_V349)) {
18937 PyArrayObject * tmp = (PyArrayObject*) py_V349;
18938 PyErr_Format(PyExc_NotImplementedError,
18939 "expected an aligned array of type %ld "
18940 "(NPY_FLOAT64), got non-aligned array of type %ld"
18941 " with %ld dimensions, with 3 last dims "
18942 "%ld, %ld, %ld"
18943 " and 3 last strides %ld %ld, %ld.",
18944 (long int) NPY_FLOAT64,
18945 (long int) PyArray_TYPE((PyArrayObject*) py_V349),
18946 (long int) PyArray_NDIM(tmp),
18947 (long int) (PyArray_NDIM(tmp) >= 3 ?
18948 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
18949 (long int) (PyArray_NDIM(tmp) >= 2 ?
18950 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
18951 (long int) (PyArray_NDIM(tmp) >= 1 ?
18952 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
18953 (long int) (PyArray_NDIM(tmp) >= 3 ?
18954 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
18955 (long int) (PyArray_NDIM(tmp) >= 2 ?
18956 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
18957 (long int) (PyArray_NDIM(tmp) >= 1 ?
18958 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
18959 );
18960 {
18961 __failure = 350;
18962 if (!PyErr_Occurred()) {
18963 PyErr_SetString(PyExc_RuntimeError,
18964 "Unexpected error in an Op's C code. "
18965 "No Python exception was set.");
18966 }
18967 goto __label_350;}
18968 }
18969 // This is a TypeError to be consistent with DEBUG_MODE
18970 // Note: DEBUG_MODE also tells the name of the container
18971 if (PyArray_TYPE((PyArrayObject*) py_V349) != NPY_FLOAT64) {
18972 PyErr_Format(PyExc_TypeError,
18973 "expected type_num %d (NPY_FLOAT64) got %d",
18974 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V349));
18975 {
18976 __failure = 350;
18977 if (!PyErr_Occurred()) {
18978 PyErr_SetString(PyExc_RuntimeError,
18979 "Unexpected error in an Op's C code. "
18980 "No Python exception was set.");
18981 }
18982 goto __label_350;}
18983 }
18984
18985 V349 = (PyArrayObject*)(py_V349);
18986 Py_XINCREF(V349);
18987
18988 {
18989
18990 py_V351 = PyList_GET_ITEM(storage_V351, 0);
18991 {Py_XINCREF(py_V351);}
18992
18993 V351 = NULL;
18994 if (py_V351 == Py_None) {
18995 // We can either fail here or set V351 to NULL and rely on Ops
18996 // using tensors to handle the NULL case, but if they fail to do so
18997 // they'll end up with nasty segfaults, so this is public service.
18998 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
18999 {
19000 __failure = 352;
19001 if (!PyErr_Occurred()) {
19002 PyErr_SetString(PyExc_RuntimeError,
19003 "Unexpected error in an Op's C code. "
19004 "No Python exception was set.");
19005 }
19006 goto __label_352;}
19007 }
19008 if (!PyArray_Check(py_V351)) {
19009 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
19010 {
19011 __failure = 352;
19012 if (!PyErr_Occurred()) {
19013 PyErr_SetString(PyExc_RuntimeError,
19014 "Unexpected error in an Op's C code. "
19015 "No Python exception was set.");
19016 }
19017 goto __label_352;}
19018 }
19019 // We expect NPY_FLOAT64
19020 if (!PyArray_ISALIGNED((PyArrayObject*) py_V351)) {
19021 PyArrayObject * tmp = (PyArrayObject*) py_V351;
19022 PyErr_Format(PyExc_NotImplementedError,
19023 "expected an aligned array of type %ld "
19024 "(NPY_FLOAT64), got non-aligned array of type %ld"
19025 " with %ld dimensions, with 3 last dims "
19026 "%ld, %ld, %ld"
19027 " and 3 last strides %ld %ld, %ld.",
19028 (long int) NPY_FLOAT64,
19029 (long int) PyArray_TYPE((PyArrayObject*) py_V351),
19030 (long int) PyArray_NDIM(tmp),
19031 (long int) (PyArray_NDIM(tmp) >= 3 ?
19032 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
19033 (long int) (PyArray_NDIM(tmp) >= 2 ?
19034 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
19035 (long int) (PyArray_NDIM(tmp) >= 1 ?
19036 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
19037 (long int) (PyArray_NDIM(tmp) >= 3 ?
19038 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
19039 (long int) (PyArray_NDIM(tmp) >= 2 ?
19040 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
19041 (long int) (PyArray_NDIM(tmp) >= 1 ?
19042 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
19043 );
19044 {
19045 __failure = 352;
19046 if (!PyErr_Occurred()) {
19047 PyErr_SetString(PyExc_RuntimeError,
19048 "Unexpected error in an Op's C code. "
19049 "No Python exception was set.");
19050 }
19051 goto __label_352;}
19052 }
19053 // This is a TypeError to be consistent with DEBUG_MODE
19054 // Note: DEBUG_MODE also tells the name of the container
19055 if (PyArray_TYPE((PyArrayObject*) py_V351) != NPY_FLOAT64) {
19056 PyErr_Format(PyExc_TypeError,
19057 "expected type_num %d (NPY_FLOAT64) got %d",
19058 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V351));
19059 {
19060 __failure = 352;
19061 if (!PyErr_Occurred()) {
19062 PyErr_SetString(PyExc_RuntimeError,
19063 "Unexpected error in an Op's C code. "
19064 "No Python exception was set.");
19065 }
19066 goto __label_352;}
19067 }
19068
19069 V351 = (PyArrayObject*)(py_V351);
19070 Py_XINCREF(V351);
19071
19072 {
19073
19074 py_V353 = PyList_GET_ITEM(storage_V353, 0);
19075 {Py_XINCREF(py_V353);}
19076
19077 V353 = NULL;
19078 if (py_V353 == Py_None) {
19079 // We can either fail here or set V353 to NULL and rely on Ops
19080 // using tensors to handle the NULL case, but if they fail to do so
19081 // they'll end up with nasty segfaults, so this is public service.
19082 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
19083 {
19084 __failure = 354;
19085 if (!PyErr_Occurred()) {
19086 PyErr_SetString(PyExc_RuntimeError,
19087 "Unexpected error in an Op's C code. "
19088 "No Python exception was set.");
19089 }
19090 goto __label_354;}
19091 }
19092 if (!PyArray_Check(py_V353)) {
19093 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
19094 {
19095 __failure = 354;
19096 if (!PyErr_Occurred()) {
19097 PyErr_SetString(PyExc_RuntimeError,
19098 "Unexpected error in an Op's C code. "
19099 "No Python exception was set.");
19100 }
19101 goto __label_354;}
19102 }
19103 // We expect NPY_FLOAT64
19104 if (!PyArray_ISALIGNED((PyArrayObject*) py_V353)) {
19105 PyArrayObject * tmp = (PyArrayObject*) py_V353;
19106 PyErr_Format(PyExc_NotImplementedError,
19107 "expected an aligned array of type %ld "
19108 "(NPY_FLOAT64), got non-aligned array of type %ld"
19109 " with %ld dimensions, with 3 last dims "
19110 "%ld, %ld, %ld"
19111 " and 3 last strides %ld %ld, %ld.",
19112 (long int) NPY_FLOAT64,
19113 (long int) PyArray_TYPE((PyArrayObject*) py_V353),
19114 (long int) PyArray_NDIM(tmp),
19115 (long int) (PyArray_NDIM(tmp) >= 3 ?
19116 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
19117 (long int) (PyArray_NDIM(tmp) >= 2 ?
19118 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
19119 (long int) (PyArray_NDIM(tmp) >= 1 ?
19120 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
19121 (long int) (PyArray_NDIM(tmp) >= 3 ?
19122 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
19123 (long int) (PyArray_NDIM(tmp) >= 2 ?
19124 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
19125 (long int) (PyArray_NDIM(tmp) >= 1 ?
19126 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
19127 );
19128 {
19129 __failure = 354;
19130 if (!PyErr_Occurred()) {
19131 PyErr_SetString(PyExc_RuntimeError,
19132 "Unexpected error in an Op's C code. "
19133 "No Python exception was set.");
19134 }
19135 goto __label_354;}
19136 }
19137 // This is a TypeError to be consistent with DEBUG_MODE
19138 // Note: DEBUG_MODE also tells the name of the container
19139 if (PyArray_TYPE((PyArrayObject*) py_V353) != NPY_FLOAT64) {
19140 PyErr_Format(PyExc_TypeError,
19141 "expected type_num %d (NPY_FLOAT64) got %d",
19142 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V353));
19143 {
19144 __failure = 354;
19145 if (!PyErr_Occurred()) {
19146 PyErr_SetString(PyExc_RuntimeError,
19147 "Unexpected error in an Op's C code. "
19148 "No Python exception was set.");
19149 }
19150 goto __label_354;}
19151 }
19152
19153 V353 = (PyArrayObject*)(py_V353);
19154 Py_XINCREF(V353);
19155
19156 {
19157
19158 py_V355 = PyList_GET_ITEM(storage_V355, 0);
19159 {Py_XINCREF(py_V355);}
19160
19161 V355 = NULL;
19162 if (py_V355 == Py_None) {
19163 // We can either fail here or set V355 to NULL and rely on Ops
19164 // using tensors to handle the NULL case, but if they fail to do so
19165 // they'll end up with nasty segfaults, so this is public service.
19166 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
19167 {
19168 __failure = 356;
19169 if (!PyErr_Occurred()) {
19170 PyErr_SetString(PyExc_RuntimeError,
19171 "Unexpected error in an Op's C code. "
19172 "No Python exception was set.");
19173 }
19174 goto __label_356;}
19175 }
19176 if (!PyArray_Check(py_V355)) {
19177 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
19178 {
19179 __failure = 356;
19180 if (!PyErr_Occurred()) {
19181 PyErr_SetString(PyExc_RuntimeError,
19182 "Unexpected error in an Op's C code. "
19183 "No Python exception was set.");
19184 }
19185 goto __label_356;}
19186 }
19187 // We expect NPY_FLOAT64
19188 if (!PyArray_ISALIGNED((PyArrayObject*) py_V355)) {
19189 PyArrayObject * tmp = (PyArrayObject*) py_V355;
19190 PyErr_Format(PyExc_NotImplementedError,
19191 "expected an aligned array of type %ld "
19192 "(NPY_FLOAT64), got non-aligned array of type %ld"
19193 " with %ld dimensions, with 3 last dims "
19194 "%ld, %ld, %ld"
19195 " and 3 last strides %ld %ld, %ld.",
19196 (long int) NPY_FLOAT64,
19197 (long int) PyArray_TYPE((PyArrayObject*) py_V355),
19198 (long int) PyArray_NDIM(tmp),
19199 (long int) (PyArray_NDIM(tmp) >= 3 ?
19200 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
19201 (long int) (PyArray_NDIM(tmp) >= 2 ?
19202 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
19203 (long int) (PyArray_NDIM(tmp) >= 1 ?
19204 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
19205 (long int) (PyArray_NDIM(tmp) >= 3 ?
19206 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
19207 (long int) (PyArray_NDIM(tmp) >= 2 ?
19208 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
19209 (long int) (PyArray_NDIM(tmp) >= 1 ?
19210 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
19211 );
19212 {
19213 __failure = 356;
19214 if (!PyErr_Occurred()) {
19215 PyErr_SetString(PyExc_RuntimeError,
19216 "Unexpected error in an Op's C code. "
19217 "No Python exception was set.");
19218 }
19219 goto __label_356;}
19220 }
19221 // This is a TypeError to be consistent with DEBUG_MODE
19222 // Note: DEBUG_MODE also tells the name of the container
19223 if (PyArray_TYPE((PyArrayObject*) py_V355) != NPY_FLOAT64) {
19224 PyErr_Format(PyExc_TypeError,
19225 "expected type_num %d (NPY_FLOAT64) got %d",
19226 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V355));
19227 {
19228 __failure = 356;
19229 if (!PyErr_Occurred()) {
19230 PyErr_SetString(PyExc_RuntimeError,
19231 "Unexpected error in an Op's C code. "
19232 "No Python exception was set.");
19233 }
19234 goto __label_356;}
19235 }
19236
19237 V355 = (PyArrayObject*)(py_V355);
19238 Py_XINCREF(V355);
19239
19240 {
19241
19242 py_V357 = PyList_GET_ITEM(storage_V357, 0);
19243 {Py_XINCREF(py_V357);}
19244
19245 V357 = NULL;
19246 if (py_V357 == Py_None) {
19247 // We can either fail here or set V357 to NULL and rely on Ops
19248 // using tensors to handle the NULL case, but if they fail to do so
19249 // they'll end up with nasty segfaults, so this is public service.
19250 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
19251 {
19252 __failure = 358;
19253 if (!PyErr_Occurred()) {
19254 PyErr_SetString(PyExc_RuntimeError,
19255 "Unexpected error in an Op's C code. "
19256 "No Python exception was set.");
19257 }
19258 goto __label_358;}
19259 }
19260 if (!PyArray_Check(py_V357)) {
19261 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
19262 {
19263 __failure = 358;
19264 if (!PyErr_Occurred()) {
19265 PyErr_SetString(PyExc_RuntimeError,
19266 "Unexpected error in an Op's C code. "
19267 "No Python exception was set.");
19268 }
19269 goto __label_358;}
19270 }
19271 // We expect NPY_FLOAT64
19272 if (!PyArray_ISALIGNED((PyArrayObject*) py_V357)) {
19273 PyArrayObject * tmp = (PyArrayObject*) py_V357;
19274 PyErr_Format(PyExc_NotImplementedError,
19275 "expected an aligned array of type %ld "
19276 "(NPY_FLOAT64), got non-aligned array of type %ld"
19277 " with %ld dimensions, with 3 last dims "
19278 "%ld, %ld, %ld"
19279 " and 3 last strides %ld %ld, %ld.",
19280 (long int) NPY_FLOAT64,
19281 (long int) PyArray_TYPE((PyArrayObject*) py_V357),
19282 (long int) PyArray_NDIM(tmp),
19283 (long int) (PyArray_NDIM(tmp) >= 3 ?
19284 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
19285 (long int) (PyArray_NDIM(tmp) >= 2 ?
19286 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
19287 (long int) (PyArray_NDIM(tmp) >= 1 ?
19288 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
19289 (long int) (PyArray_NDIM(tmp) >= 3 ?
19290 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
19291 (long int) (PyArray_NDIM(tmp) >= 2 ?
19292 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
19293 (long int) (PyArray_NDIM(tmp) >= 1 ?
19294 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
19295 );
19296 {
19297 __failure = 358;
19298 if (!PyErr_Occurred()) {
19299 PyErr_SetString(PyExc_RuntimeError,
19300 "Unexpected error in an Op's C code. "
19301 "No Python exception was set.");
19302 }
19303 goto __label_358;}
19304 }
19305 // This is a TypeError to be consistent with DEBUG_MODE
19306 // Note: DEBUG_MODE also tells the name of the container
19307 if (PyArray_TYPE((PyArrayObject*) py_V357) != NPY_FLOAT64) {
19308 PyErr_Format(PyExc_TypeError,
19309 "expected type_num %d (NPY_FLOAT64) got %d",
19310 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V357));
19311 {
19312 __failure = 358;
19313 if (!PyErr_Occurred()) {
19314 PyErr_SetString(PyExc_RuntimeError,
19315 "Unexpected error in an Op's C code. "
19316 "No Python exception was set.");
19317 }
19318 goto __label_358;}
19319 }
19320
19321 V357 = (PyArrayObject*)(py_V357);
19322 Py_XINCREF(V357);
19323
19324 {
19325
19326 py_V359 = PyList_GET_ITEM(storage_V359, 0);
19327 {Py_XINCREF(py_V359);}
19328
19329 V359 = NULL;
19330 if (py_V359 == Py_None) {
19331 // We can either fail here or set V359 to NULL and rely on Ops
19332 // using tensors to handle the NULL case, but if they fail to do so
19333 // they'll end up with nasty segfaults, so this is public service.
19334 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
19335 {
19336 __failure = 360;
19337 if (!PyErr_Occurred()) {
19338 PyErr_SetString(PyExc_RuntimeError,
19339 "Unexpected error in an Op's C code. "
19340 "No Python exception was set.");
19341 }
19342 goto __label_360;}
19343 }
19344 if (!PyArray_Check(py_V359)) {
19345 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
19346 {
19347 __failure = 360;
19348 if (!PyErr_Occurred()) {
19349 PyErr_SetString(PyExc_RuntimeError,
19350 "Unexpected error in an Op's C code. "
19351 "No Python exception was set.");
19352 }
19353 goto __label_360;}
19354 }
19355 // We expect NPY_FLOAT64
19356 if (!PyArray_ISALIGNED((PyArrayObject*) py_V359)) {
19357 PyArrayObject * tmp = (PyArrayObject*) py_V359;
19358 PyErr_Format(PyExc_NotImplementedError,
19359 "expected an aligned array of type %ld "
19360 "(NPY_FLOAT64), got non-aligned array of type %ld"
19361 " with %ld dimensions, with 3 last dims "
19362 "%ld, %ld, %ld"
19363 " and 3 last strides %ld %ld, %ld.",
19364 (long int) NPY_FLOAT64,
19365 (long int) PyArray_TYPE((PyArrayObject*) py_V359),
19366 (long int) PyArray_NDIM(tmp),
19367 (long int) (PyArray_NDIM(tmp) >= 3 ?
19368 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
19369 (long int) (PyArray_NDIM(tmp) >= 2 ?
19370 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
19371 (long int) (PyArray_NDIM(tmp) >= 1 ?
19372 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
19373 (long int) (PyArray_NDIM(tmp) >= 3 ?
19374 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
19375 (long int) (PyArray_NDIM(tmp) >= 2 ?
19376 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
19377 (long int) (PyArray_NDIM(tmp) >= 1 ?
19378 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
19379 );
19380 {
19381 __failure = 360;
19382 if (!PyErr_Occurred()) {
19383 PyErr_SetString(PyExc_RuntimeError,
19384 "Unexpected error in an Op's C code. "
19385 "No Python exception was set.");
19386 }
19387 goto __label_360;}
19388 }
19389 // This is a TypeError to be consistent with DEBUG_MODE
19390 // Note: DEBUG_MODE also tells the name of the container
19391 if (PyArray_TYPE((PyArrayObject*) py_V359) != NPY_FLOAT64) {
19392 PyErr_Format(PyExc_TypeError,
19393 "expected type_num %d (NPY_FLOAT64) got %d",
19394 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V359));
19395 {
19396 __failure = 360;
19397 if (!PyErr_Occurred()) {
19398 PyErr_SetString(PyExc_RuntimeError,
19399 "Unexpected error in an Op's C code. "
19400 "No Python exception was set.");
19401 }
19402 goto __label_360;}
19403 }
19404
19405 V359 = (PyArrayObject*)(py_V359);
19406 Py_XINCREF(V359);
19407
19408 {
19409
19410 py_V361 = PyList_GET_ITEM(storage_V361, 0);
19411 {Py_XINCREF(py_V361);}
19412
19413 V361 = NULL;
19414 if (py_V361 == Py_None) {
19415 // We can either fail here or set V361 to NULL and rely on Ops
19416 // using tensors to handle the NULL case, but if they fail to do so
19417 // they'll end up with nasty segfaults, so this is public service.
19418 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
19419 {
19420 __failure = 362;
19421 if (!PyErr_Occurred()) {
19422 PyErr_SetString(PyExc_RuntimeError,
19423 "Unexpected error in an Op's C code. "
19424 "No Python exception was set.");
19425 }
19426 goto __label_362;}
19427 }
19428 if (!PyArray_Check(py_V361)) {
19429 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
19430 {
19431 __failure = 362;
19432 if (!PyErr_Occurred()) {
19433 PyErr_SetString(PyExc_RuntimeError,
19434 "Unexpected error in an Op's C code. "
19435 "No Python exception was set.");
19436 }
19437 goto __label_362;}
19438 }
19439 // We expect NPY_FLOAT64
19440 if (!PyArray_ISALIGNED((PyArrayObject*) py_V361)) {
19441 PyArrayObject * tmp = (PyArrayObject*) py_V361;
19442 PyErr_Format(PyExc_NotImplementedError,
19443 "expected an aligned array of type %ld "
19444 "(NPY_FLOAT64), got non-aligned array of type %ld"
19445 " with %ld dimensions, with 3 last dims "
19446 "%ld, %ld, %ld"
19447 " and 3 last strides %ld %ld, %ld.",
19448 (long int) NPY_FLOAT64,
19449 (long int) PyArray_TYPE((PyArrayObject*) py_V361),
19450 (long int) PyArray_NDIM(tmp),
19451 (long int) (PyArray_NDIM(tmp) >= 3 ?
19452 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
19453 (long int) (PyArray_NDIM(tmp) >= 2 ?
19454 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
19455 (long int) (PyArray_NDIM(tmp) >= 1 ?
19456 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
19457 (long int) (PyArray_NDIM(tmp) >= 3 ?
19458 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
19459 (long int) (PyArray_NDIM(tmp) >= 2 ?
19460 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
19461 (long int) (PyArray_NDIM(tmp) >= 1 ?
19462 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
19463 );
19464 {
19465 __failure = 362;
19466 if (!PyErr_Occurred()) {
19467 PyErr_SetString(PyExc_RuntimeError,
19468 "Unexpected error in an Op's C code. "
19469 "No Python exception was set.");
19470 }
19471 goto __label_362;}
19472 }
19473 // This is a TypeError to be consistent with DEBUG_MODE
19474 // Note: DEBUG_MODE also tells the name of the container
19475 if (PyArray_TYPE((PyArrayObject*) py_V361) != NPY_FLOAT64) {
19476 PyErr_Format(PyExc_TypeError,
19477 "expected type_num %d (NPY_FLOAT64) got %d",
19478 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V361));
19479 {
19480 __failure = 362;
19481 if (!PyErr_Occurred()) {
19482 PyErr_SetString(PyExc_RuntimeError,
19483 "Unexpected error in an Op's C code. "
19484 "No Python exception was set.");
19485 }
19486 goto __label_362;}
19487 }
19488
19489 V361 = (PyArrayObject*)(py_V361);
19490 Py_XINCREF(V361);
19491
19492 {
19493
19494 py_V363 = PyList_GET_ITEM(storage_V363, 0);
19495 {Py_XINCREF(py_V363);}
19496
19497 V363 = NULL;
19498 if (py_V363 == Py_None) {
19499 // We can either fail here or set V363 to NULL and rely on Ops
19500 // using tensors to handle the NULL case, but if they fail to do so
19501 // they'll end up with nasty segfaults, so this is public service.
19502 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
19503 {
19504 __failure = 364;
19505 if (!PyErr_Occurred()) {
19506 PyErr_SetString(PyExc_RuntimeError,
19507 "Unexpected error in an Op's C code. "
19508 "No Python exception was set.");
19509 }
19510 goto __label_364;}
19511 }
19512 if (!PyArray_Check(py_V363)) {
19513 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
19514 {
19515 __failure = 364;
19516 if (!PyErr_Occurred()) {
19517 PyErr_SetString(PyExc_RuntimeError,
19518 "Unexpected error in an Op's C code. "
19519 "No Python exception was set.");
19520 }
19521 goto __label_364;}
19522 }
19523 // We expect NPY_FLOAT64
19524 if (!PyArray_ISALIGNED((PyArrayObject*) py_V363)) {
19525 PyArrayObject * tmp = (PyArrayObject*) py_V363;
19526 PyErr_Format(PyExc_NotImplementedError,
19527 "expected an aligned array of type %ld "
19528 "(NPY_FLOAT64), got non-aligned array of type %ld"
19529 " with %ld dimensions, with 3 last dims "
19530 "%ld, %ld, %ld"
19531 " and 3 last strides %ld %ld, %ld.",
19532 (long int) NPY_FLOAT64,
19533 (long int) PyArray_TYPE((PyArrayObject*) py_V363),
19534 (long int) PyArray_NDIM(tmp),
19535 (long int) (PyArray_NDIM(tmp) >= 3 ?
19536 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
19537 (long int) (PyArray_NDIM(tmp) >= 2 ?
19538 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
19539 (long int) (PyArray_NDIM(tmp) >= 1 ?
19540 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
19541 (long int) (PyArray_NDIM(tmp) >= 3 ?
19542 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
19543 (long int) (PyArray_NDIM(tmp) >= 2 ?
19544 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
19545 (long int) (PyArray_NDIM(tmp) >= 1 ?
19546 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
19547 );
19548 {
19549 __failure = 364;
19550 if (!PyErr_Occurred()) {
19551 PyErr_SetString(PyExc_RuntimeError,
19552 "Unexpected error in an Op's C code. "
19553 "No Python exception was set.");
19554 }
19555 goto __label_364;}
19556 }
19557 // This is a TypeError to be consistent with DEBUG_MODE
19558 // Note: DEBUG_MODE also tells the name of the container
19559 if (PyArray_TYPE((PyArrayObject*) py_V363) != NPY_FLOAT64) {
19560 PyErr_Format(PyExc_TypeError,
19561 "expected type_num %d (NPY_FLOAT64) got %d",
19562 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V363));
19563 {
19564 __failure = 364;
19565 if (!PyErr_Occurred()) {
19566 PyErr_SetString(PyExc_RuntimeError,
19567 "Unexpected error in an Op's C code. "
19568 "No Python exception was set.");
19569 }
19570 goto __label_364;}
19571 }
19572
19573 V363 = (PyArrayObject*)(py_V363);
19574 Py_XINCREF(V363);
19575
19576 {
19577
19578 py_V365 = PyList_GET_ITEM(storage_V365, 0);
19579 {Py_XINCREF(py_V365);}
19580
19581 V365 = NULL;
19582 if (py_V365 == Py_None) {
19583 // We can either fail here or set V365 to NULL and rely on Ops
19584 // using tensors to handle the NULL case, but if they fail to do so
19585 // they'll end up with nasty segfaults, so this is public service.
19586 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
19587 {
19588 __failure = 366;
19589 if (!PyErr_Occurred()) {
19590 PyErr_SetString(PyExc_RuntimeError,
19591 "Unexpected error in an Op's C code. "
19592 "No Python exception was set.");
19593 }
19594 goto __label_366;}
19595 }
19596 if (!PyArray_Check(py_V365)) {
19597 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
19598 {
19599 __failure = 366;
19600 if (!PyErr_Occurred()) {
19601 PyErr_SetString(PyExc_RuntimeError,
19602 "Unexpected error in an Op's C code. "
19603 "No Python exception was set.");
19604 }
19605 goto __label_366;}
19606 }
19607 // We expect NPY_FLOAT64
19608 if (!PyArray_ISALIGNED((PyArrayObject*) py_V365)) {
19609 PyArrayObject * tmp = (PyArrayObject*) py_V365;
19610 PyErr_Format(PyExc_NotImplementedError,
19611 "expected an aligned array of type %ld "
19612 "(NPY_FLOAT64), got non-aligned array of type %ld"
19613 " with %ld dimensions, with 3 last dims "
19614 "%ld, %ld, %ld"
19615 " and 3 last strides %ld %ld, %ld.",
19616 (long int) NPY_FLOAT64,
19617 (long int) PyArray_TYPE((PyArrayObject*) py_V365),
19618 (long int) PyArray_NDIM(tmp),
19619 (long int) (PyArray_NDIM(tmp) >= 3 ?
19620 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
19621 (long int) (PyArray_NDIM(tmp) >= 2 ?
19622 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
19623 (long int) (PyArray_NDIM(tmp) >= 1 ?
19624 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
19625 (long int) (PyArray_NDIM(tmp) >= 3 ?
19626 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
19627 (long int) (PyArray_NDIM(tmp) >= 2 ?
19628 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
19629 (long int) (PyArray_NDIM(tmp) >= 1 ?
19630 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
19631 );
19632 {
19633 __failure = 366;
19634 if (!PyErr_Occurred()) {
19635 PyErr_SetString(PyExc_RuntimeError,
19636 "Unexpected error in an Op's C code. "
19637 "No Python exception was set.");
19638 }
19639 goto __label_366;}
19640 }
19641 // This is a TypeError to be consistent with DEBUG_MODE
19642 // Note: DEBUG_MODE also tells the name of the container
19643 if (PyArray_TYPE((PyArrayObject*) py_V365) != NPY_FLOAT64) {
19644 PyErr_Format(PyExc_TypeError,
19645 "expected type_num %d (NPY_FLOAT64) got %d",
19646 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V365));
19647 {
19648 __failure = 366;
19649 if (!PyErr_Occurred()) {
19650 PyErr_SetString(PyExc_RuntimeError,
19651 "Unexpected error in an Op's C code. "
19652 "No Python exception was set.");
19653 }
19654 goto __label_366;}
19655 }
19656
19657 V365 = (PyArrayObject*)(py_V365);
19658 Py_XINCREF(V365);
19659
19660 {
19661
19662 py_V367 = PyList_GET_ITEM(storage_V367, 0);
19663 {Py_XINCREF(py_V367);}
19664
19665 V367 = NULL;
19666 if (py_V367 == Py_None) {
19667 // We can either fail here or set V367 to NULL and rely on Ops
19668 // using tensors to handle the NULL case, but if they fail to do so
19669 // they'll end up with nasty segfaults, so this is public service.
19670 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
19671 {
19672 __failure = 368;
19673 if (!PyErr_Occurred()) {
19674 PyErr_SetString(PyExc_RuntimeError,
19675 "Unexpected error in an Op's C code. "
19676 "No Python exception was set.");
19677 }
19678 goto __label_368;}
19679 }
19680 if (!PyArray_Check(py_V367)) {
19681 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
19682 {
19683 __failure = 368;
19684 if (!PyErr_Occurred()) {
19685 PyErr_SetString(PyExc_RuntimeError,
19686 "Unexpected error in an Op's C code. "
19687 "No Python exception was set.");
19688 }
19689 goto __label_368;}
19690 }
19691 // We expect NPY_FLOAT64
19692 if (!PyArray_ISALIGNED((PyArrayObject*) py_V367)) {
19693 PyArrayObject * tmp = (PyArrayObject*) py_V367;
19694 PyErr_Format(PyExc_NotImplementedError,
19695 "expected an aligned array of type %ld "
19696 "(NPY_FLOAT64), got non-aligned array of type %ld"
19697 " with %ld dimensions, with 3 last dims "
19698 "%ld, %ld, %ld"
19699 " and 3 last strides %ld %ld, %ld.",
19700 (long int) NPY_FLOAT64,
19701 (long int) PyArray_TYPE((PyArrayObject*) py_V367),
19702 (long int) PyArray_NDIM(tmp),
19703 (long int) (PyArray_NDIM(tmp) >= 3 ?
19704 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
19705 (long int) (PyArray_NDIM(tmp) >= 2 ?
19706 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
19707 (long int) (PyArray_NDIM(tmp) >= 1 ?
19708 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
19709 (long int) (PyArray_NDIM(tmp) >= 3 ?
19710 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
19711 (long int) (PyArray_NDIM(tmp) >= 2 ?
19712 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
19713 (long int) (PyArray_NDIM(tmp) >= 1 ?
19714 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
19715 );
19716 {
19717 __failure = 368;
19718 if (!PyErr_Occurred()) {
19719 PyErr_SetString(PyExc_RuntimeError,
19720 "Unexpected error in an Op's C code. "
19721 "No Python exception was set.");
19722 }
19723 goto __label_368;}
19724 }
19725 // This is a TypeError to be consistent with DEBUG_MODE
19726 // Note: DEBUG_MODE also tells the name of the container
19727 if (PyArray_TYPE((PyArrayObject*) py_V367) != NPY_FLOAT64) {
19728 PyErr_Format(PyExc_TypeError,
19729 "expected type_num %d (NPY_FLOAT64) got %d",
19730 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V367));
19731 {
19732 __failure = 368;
19733 if (!PyErr_Occurred()) {
19734 PyErr_SetString(PyExc_RuntimeError,
19735 "Unexpected error in an Op's C code. "
19736 "No Python exception was set.");
19737 }
19738 goto __label_368;}
19739 }
19740
19741 V367 = (PyArrayObject*)(py_V367);
19742 Py_XINCREF(V367);
19743
19744 {
19745
19746 py_V369 = PyList_GET_ITEM(storage_V369, 0);
19747 {Py_XINCREF(py_V369);}
19748
19749 V369 = NULL;
19750 if (py_V369 == Py_None) {
19751 // We can either fail here or set V369 to NULL and rely on Ops
19752 // using tensors to handle the NULL case, but if they fail to do so
19753 // they'll end up with nasty segfaults, so this is public service.
19754 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
19755 {
19756 __failure = 370;
19757 if (!PyErr_Occurred()) {
19758 PyErr_SetString(PyExc_RuntimeError,
19759 "Unexpected error in an Op's C code. "
19760 "No Python exception was set.");
19761 }
19762 goto __label_370;}
19763 }
19764 if (!PyArray_Check(py_V369)) {
19765 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
19766 {
19767 __failure = 370;
19768 if (!PyErr_Occurred()) {
19769 PyErr_SetString(PyExc_RuntimeError,
19770 "Unexpected error in an Op's C code. "
19771 "No Python exception was set.");
19772 }
19773 goto __label_370;}
19774 }
19775 // We expect NPY_FLOAT64
19776 if (!PyArray_ISALIGNED((PyArrayObject*) py_V369)) {
19777 PyArrayObject * tmp = (PyArrayObject*) py_V369;
19778 PyErr_Format(PyExc_NotImplementedError,
19779 "expected an aligned array of type %ld "
19780 "(NPY_FLOAT64), got non-aligned array of type %ld"
19781 " with %ld dimensions, with 3 last dims "
19782 "%ld, %ld, %ld"
19783 " and 3 last strides %ld %ld, %ld.",
19784 (long int) NPY_FLOAT64,
19785 (long int) PyArray_TYPE((PyArrayObject*) py_V369),
19786 (long int) PyArray_NDIM(tmp),
19787 (long int) (PyArray_NDIM(tmp) >= 3 ?
19788 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
19789 (long int) (PyArray_NDIM(tmp) >= 2 ?
19790 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
19791 (long int) (PyArray_NDIM(tmp) >= 1 ?
19792 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
19793 (long int) (PyArray_NDIM(tmp) >= 3 ?
19794 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
19795 (long int) (PyArray_NDIM(tmp) >= 2 ?
19796 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
19797 (long int) (PyArray_NDIM(tmp) >= 1 ?
19798 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
19799 );
19800 {
19801 __failure = 370;
19802 if (!PyErr_Occurred()) {
19803 PyErr_SetString(PyExc_RuntimeError,
19804 "Unexpected error in an Op's C code. "
19805 "No Python exception was set.");
19806 }
19807 goto __label_370;}
19808 }
19809 // This is a TypeError to be consistent with DEBUG_MODE
19810 // Note: DEBUG_MODE also tells the name of the container
19811 if (PyArray_TYPE((PyArrayObject*) py_V369) != NPY_FLOAT64) {
19812 PyErr_Format(PyExc_TypeError,
19813 "expected type_num %d (NPY_FLOAT64) got %d",
19814 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V369));
19815 {
19816 __failure = 370;
19817 if (!PyErr_Occurred()) {
19818 PyErr_SetString(PyExc_RuntimeError,
19819 "Unexpected error in an Op's C code. "
19820 "No Python exception was set.");
19821 }
19822 goto __label_370;}
19823 }
19824
19825 V369 = (PyArrayObject*)(py_V369);
19826 Py_XINCREF(V369);
19827
19828 {
19829
19830 py_V371 = PyList_GET_ITEM(storage_V371, 0);
19831 {Py_XINCREF(py_V371);}
19832
19833 V371 = NULL;
19834 if (py_V371 == Py_None) {
19835 // We can either fail here or set V371 to NULL and rely on Ops
19836 // using tensors to handle the NULL case, but if they fail to do so
19837 // they'll end up with nasty segfaults, so this is public service.
19838 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
19839 {
19840 __failure = 372;
19841 if (!PyErr_Occurred()) {
19842 PyErr_SetString(PyExc_RuntimeError,
19843 "Unexpected error in an Op's C code. "
19844 "No Python exception was set.");
19845 }
19846 goto __label_372;}
19847 }
19848 if (!PyArray_Check(py_V371)) {
19849 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
19850 {
19851 __failure = 372;
19852 if (!PyErr_Occurred()) {
19853 PyErr_SetString(PyExc_RuntimeError,
19854 "Unexpected error in an Op's C code. "
19855 "No Python exception was set.");
19856 }
19857 goto __label_372;}
19858 }
19859 // We expect NPY_FLOAT64
19860 if (!PyArray_ISALIGNED((PyArrayObject*) py_V371)) {
19861 PyArrayObject * tmp = (PyArrayObject*) py_V371;
19862 PyErr_Format(PyExc_NotImplementedError,
19863 "expected an aligned array of type %ld "
19864 "(NPY_FLOAT64), got non-aligned array of type %ld"
19865 " with %ld dimensions, with 3 last dims "
19866 "%ld, %ld, %ld"
19867 " and 3 last strides %ld %ld, %ld.",
19868 (long int) NPY_FLOAT64,
19869 (long int) PyArray_TYPE((PyArrayObject*) py_V371),
19870 (long int) PyArray_NDIM(tmp),
19871 (long int) (PyArray_NDIM(tmp) >= 3 ?
19872 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
19873 (long int) (PyArray_NDIM(tmp) >= 2 ?
19874 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
19875 (long int) (PyArray_NDIM(tmp) >= 1 ?
19876 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
19877 (long int) (PyArray_NDIM(tmp) >= 3 ?
19878 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
19879 (long int) (PyArray_NDIM(tmp) >= 2 ?
19880 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
19881 (long int) (PyArray_NDIM(tmp) >= 1 ?
19882 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
19883 );
19884 {
19885 __failure = 372;
19886 if (!PyErr_Occurred()) {
19887 PyErr_SetString(PyExc_RuntimeError,
19888 "Unexpected error in an Op's C code. "
19889 "No Python exception was set.");
19890 }
19891 goto __label_372;}
19892 }
19893 // This is a TypeError to be consistent with DEBUG_MODE
19894 // Note: DEBUG_MODE also tells the name of the container
19895 if (PyArray_TYPE((PyArrayObject*) py_V371) != NPY_FLOAT64) {
19896 PyErr_Format(PyExc_TypeError,
19897 "expected type_num %d (NPY_FLOAT64) got %d",
19898 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V371));
19899 {
19900 __failure = 372;
19901 if (!PyErr_Occurred()) {
19902 PyErr_SetString(PyExc_RuntimeError,
19903 "Unexpected error in an Op's C code. "
19904 "No Python exception was set.");
19905 }
19906 goto __label_372;}
19907 }
19908
19909 V371 = (PyArrayObject*)(py_V371);
19910 Py_XINCREF(V371);
19911
19912 {
19913
19914 py_V373 = PyList_GET_ITEM(storage_V373, 0);
19915 {Py_XINCREF(py_V373);}
19916
19917 V373 = NULL;
19918 if (py_V373 == Py_None) {
19919 // We can either fail here or set V373 to NULL and rely on Ops
19920 // using tensors to handle the NULL case, but if they fail to do so
19921 // they'll end up with nasty segfaults, so this is public service.
19922 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
19923 {
19924 __failure = 374;
19925 if (!PyErr_Occurred()) {
19926 PyErr_SetString(PyExc_RuntimeError,
19927 "Unexpected error in an Op's C code. "
19928 "No Python exception was set.");
19929 }
19930 goto __label_374;}
19931 }
19932 if (!PyArray_Check(py_V373)) {
19933 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
19934 {
19935 __failure = 374;
19936 if (!PyErr_Occurred()) {
19937 PyErr_SetString(PyExc_RuntimeError,
19938 "Unexpected error in an Op's C code. "
19939 "No Python exception was set.");
19940 }
19941 goto __label_374;}
19942 }
19943 // We expect NPY_FLOAT64
19944 if (!PyArray_ISALIGNED((PyArrayObject*) py_V373)) {
19945 PyArrayObject * tmp = (PyArrayObject*) py_V373;
19946 PyErr_Format(PyExc_NotImplementedError,
19947 "expected an aligned array of type %ld "
19948 "(NPY_FLOAT64), got non-aligned array of type %ld"
19949 " with %ld dimensions, with 3 last dims "
19950 "%ld, %ld, %ld"
19951 " and 3 last strides %ld %ld, %ld.",
19952 (long int) NPY_FLOAT64,
19953 (long int) PyArray_TYPE((PyArrayObject*) py_V373),
19954 (long int) PyArray_NDIM(tmp),
19955 (long int) (PyArray_NDIM(tmp) >= 3 ?
19956 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
19957 (long int) (PyArray_NDIM(tmp) >= 2 ?
19958 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
19959 (long int) (PyArray_NDIM(tmp) >= 1 ?
19960 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
19961 (long int) (PyArray_NDIM(tmp) >= 3 ?
19962 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
19963 (long int) (PyArray_NDIM(tmp) >= 2 ?
19964 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
19965 (long int) (PyArray_NDIM(tmp) >= 1 ?
19966 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
19967 );
19968 {
19969 __failure = 374;
19970 if (!PyErr_Occurred()) {
19971 PyErr_SetString(PyExc_RuntimeError,
19972 "Unexpected error in an Op's C code. "
19973 "No Python exception was set.");
19974 }
19975 goto __label_374;}
19976 }
19977 // This is a TypeError to be consistent with DEBUG_MODE
19978 // Note: DEBUG_MODE also tells the name of the container
19979 if (PyArray_TYPE((PyArrayObject*) py_V373) != NPY_FLOAT64) {
19980 PyErr_Format(PyExc_TypeError,
19981 "expected type_num %d (NPY_FLOAT64) got %d",
19982 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V373));
19983 {
19984 __failure = 374;
19985 if (!PyErr_Occurred()) {
19986 PyErr_SetString(PyExc_RuntimeError,
19987 "Unexpected error in an Op's C code. "
19988 "No Python exception was set.");
19989 }
19990 goto __label_374;}
19991 }
19992
19993 V373 = (PyArrayObject*)(py_V373);
19994 Py_XINCREF(V373);
19995
19996 {
19997
19998 py_V375 = PyList_GET_ITEM(storage_V375, 0);
19999 {Py_XINCREF(py_V375);}
20000
20001 V375 = NULL;
20002 if (py_V375 == Py_None) {
20003 // We can either fail here or set V375 to NULL and rely on Ops
20004 // using tensors to handle the NULL case, but if they fail to do so
20005 // they'll end up with nasty segfaults, so this is public service.
20006 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
20007 {
20008 __failure = 376;
20009 if (!PyErr_Occurred()) {
20010 PyErr_SetString(PyExc_RuntimeError,
20011 "Unexpected error in an Op's C code. "
20012 "No Python exception was set.");
20013 }
20014 goto __label_376;}
20015 }
20016 if (!PyArray_Check(py_V375)) {
20017 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
20018 {
20019 __failure = 376;
20020 if (!PyErr_Occurred()) {
20021 PyErr_SetString(PyExc_RuntimeError,
20022 "Unexpected error in an Op's C code. "
20023 "No Python exception was set.");
20024 }
20025 goto __label_376;}
20026 }
20027 // We expect NPY_FLOAT64
20028 if (!PyArray_ISALIGNED((PyArrayObject*) py_V375)) {
20029 PyArrayObject * tmp = (PyArrayObject*) py_V375;
20030 PyErr_Format(PyExc_NotImplementedError,
20031 "expected an aligned array of type %ld "
20032 "(NPY_FLOAT64), got non-aligned array of type %ld"
20033 " with %ld dimensions, with 3 last dims "
20034 "%ld, %ld, %ld"
20035 " and 3 last strides %ld %ld, %ld.",
20036 (long int) NPY_FLOAT64,
20037 (long int) PyArray_TYPE((PyArrayObject*) py_V375),
20038 (long int) PyArray_NDIM(tmp),
20039 (long int) (PyArray_NDIM(tmp) >= 3 ?
20040 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
20041 (long int) (PyArray_NDIM(tmp) >= 2 ?
20042 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
20043 (long int) (PyArray_NDIM(tmp) >= 1 ?
20044 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
20045 (long int) (PyArray_NDIM(tmp) >= 3 ?
20046 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
20047 (long int) (PyArray_NDIM(tmp) >= 2 ?
20048 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
20049 (long int) (PyArray_NDIM(tmp) >= 1 ?
20050 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
20051 );
20052 {
20053 __failure = 376;
20054 if (!PyErr_Occurred()) {
20055 PyErr_SetString(PyExc_RuntimeError,
20056 "Unexpected error in an Op's C code. "
20057 "No Python exception was set.");
20058 }
20059 goto __label_376;}
20060 }
20061 // This is a TypeError to be consistent with DEBUG_MODE
20062 // Note: DEBUG_MODE also tells the name of the container
20063 if (PyArray_TYPE((PyArrayObject*) py_V375) != NPY_FLOAT64) {
20064 PyErr_Format(PyExc_TypeError,
20065 "expected type_num %d (NPY_FLOAT64) got %d",
20066 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V375));
20067 {
20068 __failure = 376;
20069 if (!PyErr_Occurred()) {
20070 PyErr_SetString(PyExc_RuntimeError,
20071 "Unexpected error in an Op's C code. "
20072 "No Python exception was set.");
20073 }
20074 goto __label_376;}
20075 }
20076
20077 V375 = (PyArrayObject*)(py_V375);
20078 Py_XINCREF(V375);
20079
20080 {
20081
20082 py_V377 = PyList_GET_ITEM(storage_V377, 0);
20083 {Py_XINCREF(py_V377);}
20084
20085 V377 = NULL;
20086 if (py_V377 == Py_None) {
20087 // We can either fail here or set V377 to NULL and rely on Ops
20088 // using tensors to handle the NULL case, but if they fail to do so
20089 // they'll end up with nasty segfaults, so this is public service.
20090 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
20091 {
20092 __failure = 378;
20093 if (!PyErr_Occurred()) {
20094 PyErr_SetString(PyExc_RuntimeError,
20095 "Unexpected error in an Op's C code. "
20096 "No Python exception was set.");
20097 }
20098 goto __label_378;}
20099 }
20100 if (!PyArray_Check(py_V377)) {
20101 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
20102 {
20103 __failure = 378;
20104 if (!PyErr_Occurred()) {
20105 PyErr_SetString(PyExc_RuntimeError,
20106 "Unexpected error in an Op's C code. "
20107 "No Python exception was set.");
20108 }
20109 goto __label_378;}
20110 }
20111 // We expect NPY_FLOAT64
20112 if (!PyArray_ISALIGNED((PyArrayObject*) py_V377)) {
20113 PyArrayObject * tmp = (PyArrayObject*) py_V377;
20114 PyErr_Format(PyExc_NotImplementedError,
20115 "expected an aligned array of type %ld "
20116 "(NPY_FLOAT64), got non-aligned array of type %ld"
20117 " with %ld dimensions, with 3 last dims "
20118 "%ld, %ld, %ld"
20119 " and 3 last strides %ld %ld, %ld.",
20120 (long int) NPY_FLOAT64,
20121 (long int) PyArray_TYPE((PyArrayObject*) py_V377),
20122 (long int) PyArray_NDIM(tmp),
20123 (long int) (PyArray_NDIM(tmp) >= 3 ?
20124 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
20125 (long int) (PyArray_NDIM(tmp) >= 2 ?
20126 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
20127 (long int) (PyArray_NDIM(tmp) >= 1 ?
20128 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
20129 (long int) (PyArray_NDIM(tmp) >= 3 ?
20130 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
20131 (long int) (PyArray_NDIM(tmp) >= 2 ?
20132 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
20133 (long int) (PyArray_NDIM(tmp) >= 1 ?
20134 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
20135 );
20136 {
20137 __failure = 378;
20138 if (!PyErr_Occurred()) {
20139 PyErr_SetString(PyExc_RuntimeError,
20140 "Unexpected error in an Op's C code. "
20141 "No Python exception was set.");
20142 }
20143 goto __label_378;}
20144 }
20145 // This is a TypeError to be consistent with DEBUG_MODE
20146 // Note: DEBUG_MODE also tells the name of the container
20147 if (PyArray_TYPE((PyArrayObject*) py_V377) != NPY_FLOAT64) {
20148 PyErr_Format(PyExc_TypeError,
20149 "expected type_num %d (NPY_FLOAT64) got %d",
20150 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V377));
20151 {
20152 __failure = 378;
20153 if (!PyErr_Occurred()) {
20154 PyErr_SetString(PyExc_RuntimeError,
20155 "Unexpected error in an Op's C code. "
20156 "No Python exception was set.");
20157 }
20158 goto __label_378;}
20159 }
20160
20161 V377 = (PyArrayObject*)(py_V377);
20162 Py_XINCREF(V377);
20163
20164 {
20165
20166 py_V379 = PyList_GET_ITEM(storage_V379, 0);
20167 {Py_XINCREF(py_V379);}
20168
20169 V379 = NULL;
20170 if (py_V379 == Py_None) {
20171 // We can either fail here or set V379 to NULL and rely on Ops
20172 // using tensors to handle the NULL case, but if they fail to do so
20173 // they'll end up with nasty segfaults, so this is public service.
20174 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
20175 {
20176 __failure = 380;
20177 if (!PyErr_Occurred()) {
20178 PyErr_SetString(PyExc_RuntimeError,
20179 "Unexpected error in an Op's C code. "
20180 "No Python exception was set.");
20181 }
20182 goto __label_380;}
20183 }
20184 if (!PyArray_Check(py_V379)) {
20185 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
20186 {
20187 __failure = 380;
20188 if (!PyErr_Occurred()) {
20189 PyErr_SetString(PyExc_RuntimeError,
20190 "Unexpected error in an Op's C code. "
20191 "No Python exception was set.");
20192 }
20193 goto __label_380;}
20194 }
20195 // We expect NPY_FLOAT64
20196 if (!PyArray_ISALIGNED((PyArrayObject*) py_V379)) {
20197 PyArrayObject * tmp = (PyArrayObject*) py_V379;
20198 PyErr_Format(PyExc_NotImplementedError,
20199 "expected an aligned array of type %ld "
20200 "(NPY_FLOAT64), got non-aligned array of type %ld"
20201 " with %ld dimensions, with 3 last dims "
20202 "%ld, %ld, %ld"
20203 " and 3 last strides %ld %ld, %ld.",
20204 (long int) NPY_FLOAT64,
20205 (long int) PyArray_TYPE((PyArrayObject*) py_V379),
20206 (long int) PyArray_NDIM(tmp),
20207 (long int) (PyArray_NDIM(tmp) >= 3 ?
20208 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
20209 (long int) (PyArray_NDIM(tmp) >= 2 ?
20210 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
20211 (long int) (PyArray_NDIM(tmp) >= 1 ?
20212 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
20213 (long int) (PyArray_NDIM(tmp) >= 3 ?
20214 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
20215 (long int) (PyArray_NDIM(tmp) >= 2 ?
20216 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
20217 (long int) (PyArray_NDIM(tmp) >= 1 ?
20218 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
20219 );
20220 {
20221 __failure = 380;
20222 if (!PyErr_Occurred()) {
20223 PyErr_SetString(PyExc_RuntimeError,
20224 "Unexpected error in an Op's C code. "
20225 "No Python exception was set.");
20226 }
20227 goto __label_380;}
20228 }
20229 // This is a TypeError to be consistent with DEBUG_MODE
20230 // Note: DEBUG_MODE also tells the name of the container
20231 if (PyArray_TYPE((PyArrayObject*) py_V379) != NPY_FLOAT64) {
20232 PyErr_Format(PyExc_TypeError,
20233 "expected type_num %d (NPY_FLOAT64) got %d",
20234 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V379));
20235 {
20236 __failure = 380;
20237 if (!PyErr_Occurred()) {
20238 PyErr_SetString(PyExc_RuntimeError,
20239 "Unexpected error in an Op's C code. "
20240 "No Python exception was set.");
20241 }
20242 goto __label_380;}
20243 }
20244
20245 V379 = (PyArrayObject*)(py_V379);
20246 Py_XINCREF(V379);
20247
20248 {
20249
20250 py_V381 = PyList_GET_ITEM(storage_V381, 0);
20251 {Py_XINCREF(py_V381);}
20252
20253 V381 = NULL;
20254 if (py_V381 == Py_None) {
20255 // We can either fail here or set V381 to NULL and rely on Ops
20256 // using tensors to handle the NULL case, but if they fail to do so
20257 // they'll end up with nasty segfaults, so this is public service.
20258 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
20259 {
20260 __failure = 382;
20261 if (!PyErr_Occurred()) {
20262 PyErr_SetString(PyExc_RuntimeError,
20263 "Unexpected error in an Op's C code. "
20264 "No Python exception was set.");
20265 }
20266 goto __label_382;}
20267 }
20268 if (!PyArray_Check(py_V381)) {
20269 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
20270 {
20271 __failure = 382;
20272 if (!PyErr_Occurred()) {
20273 PyErr_SetString(PyExc_RuntimeError,
20274 "Unexpected error in an Op's C code. "
20275 "No Python exception was set.");
20276 }
20277 goto __label_382;}
20278 }
20279 // We expect NPY_FLOAT64
20280 if (!PyArray_ISALIGNED((PyArrayObject*) py_V381)) {
20281 PyArrayObject * tmp = (PyArrayObject*) py_V381;
20282 PyErr_Format(PyExc_NotImplementedError,
20283 "expected an aligned array of type %ld "
20284 "(NPY_FLOAT64), got non-aligned array of type %ld"
20285 " with %ld dimensions, with 3 last dims "
20286 "%ld, %ld, %ld"
20287 " and 3 last strides %ld %ld, %ld.",
20288 (long int) NPY_FLOAT64,
20289 (long int) PyArray_TYPE((PyArrayObject*) py_V381),
20290 (long int) PyArray_NDIM(tmp),
20291 (long int) (PyArray_NDIM(tmp) >= 3 ?
20292 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
20293 (long int) (PyArray_NDIM(tmp) >= 2 ?
20294 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
20295 (long int) (PyArray_NDIM(tmp) >= 1 ?
20296 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
20297 (long int) (PyArray_NDIM(tmp) >= 3 ?
20298 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
20299 (long int) (PyArray_NDIM(tmp) >= 2 ?
20300 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
20301 (long int) (PyArray_NDIM(tmp) >= 1 ?
20302 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
20303 );
20304 {
20305 __failure = 382;
20306 if (!PyErr_Occurred()) {
20307 PyErr_SetString(PyExc_RuntimeError,
20308 "Unexpected error in an Op's C code. "
20309 "No Python exception was set.");
20310 }
20311 goto __label_382;}
20312 }
20313 // This is a TypeError to be consistent with DEBUG_MODE
20314 // Note: DEBUG_MODE also tells the name of the container
20315 if (PyArray_TYPE((PyArrayObject*) py_V381) != NPY_FLOAT64) {
20316 PyErr_Format(PyExc_TypeError,
20317 "expected type_num %d (NPY_FLOAT64) got %d",
20318 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V381));
20319 {
20320 __failure = 382;
20321 if (!PyErr_Occurred()) {
20322 PyErr_SetString(PyExc_RuntimeError,
20323 "Unexpected error in an Op's C code. "
20324 "No Python exception was set.");
20325 }
20326 goto __label_382;}
20327 }
20328
20329 V381 = (PyArrayObject*)(py_V381);
20330 Py_XINCREF(V381);
20331
20332 {
20333
20334 py_V383 = PyList_GET_ITEM(storage_V383, 0);
20335 {Py_XINCREF(py_V383);}
20336
20337 V383 = NULL;
20338 if (py_V383 == Py_None) {
20339 // We can either fail here or set V383 to NULL and rely on Ops
20340 // using tensors to handle the NULL case, but if they fail to do so
20341 // they'll end up with nasty segfaults, so this is public service.
20342 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
20343 {
20344 __failure = 384;
20345 if (!PyErr_Occurred()) {
20346 PyErr_SetString(PyExc_RuntimeError,
20347 "Unexpected error in an Op's C code. "
20348 "No Python exception was set.");
20349 }
20350 goto __label_384;}
20351 }
20352 if (!PyArray_Check(py_V383)) {
20353 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
20354 {
20355 __failure = 384;
20356 if (!PyErr_Occurred()) {
20357 PyErr_SetString(PyExc_RuntimeError,
20358 "Unexpected error in an Op's C code. "
20359 "No Python exception was set.");
20360 }
20361 goto __label_384;}
20362 }
20363 // We expect NPY_FLOAT64
20364 if (!PyArray_ISALIGNED((PyArrayObject*) py_V383)) {
20365 PyArrayObject * tmp = (PyArrayObject*) py_V383;
20366 PyErr_Format(PyExc_NotImplementedError,
20367 "expected an aligned array of type %ld "
20368 "(NPY_FLOAT64), got non-aligned array of type %ld"
20369 " with %ld dimensions, with 3 last dims "
20370 "%ld, %ld, %ld"
20371 " and 3 last strides %ld %ld, %ld.",
20372 (long int) NPY_FLOAT64,
20373 (long int) PyArray_TYPE((PyArrayObject*) py_V383),
20374 (long int) PyArray_NDIM(tmp),
20375 (long int) (PyArray_NDIM(tmp) >= 3 ?
20376 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
20377 (long int) (PyArray_NDIM(tmp) >= 2 ?
20378 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
20379 (long int) (PyArray_NDIM(tmp) >= 1 ?
20380 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
20381 (long int) (PyArray_NDIM(tmp) >= 3 ?
20382 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
20383 (long int) (PyArray_NDIM(tmp) >= 2 ?
20384 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
20385 (long int) (PyArray_NDIM(tmp) >= 1 ?
20386 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
20387 );
20388 {
20389 __failure = 384;
20390 if (!PyErr_Occurred()) {
20391 PyErr_SetString(PyExc_RuntimeError,
20392 "Unexpected error in an Op's C code. "
20393 "No Python exception was set.");
20394 }
20395 goto __label_384;}
20396 }
20397 // This is a TypeError to be consistent with DEBUG_MODE
20398 // Note: DEBUG_MODE also tells the name of the container
20399 if (PyArray_TYPE((PyArrayObject*) py_V383) != NPY_FLOAT64) {
20400 PyErr_Format(PyExc_TypeError,
20401 "expected type_num %d (NPY_FLOAT64) got %d",
20402 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V383));
20403 {
20404 __failure = 384;
20405 if (!PyErr_Occurred()) {
20406 PyErr_SetString(PyExc_RuntimeError,
20407 "Unexpected error in an Op's C code. "
20408 "No Python exception was set.");
20409 }
20410 goto __label_384;}
20411 }
20412
20413 V383 = (PyArrayObject*)(py_V383);
20414 Py_XINCREF(V383);
20415
20416 {
20417
20418 py_V385 = PyList_GET_ITEM(storage_V385, 0);
20419 {Py_XINCREF(py_V385);}
20420
20421 V385 = NULL;
20422 if (py_V385 == Py_None) {
20423 // We can either fail here or set V385 to NULL and rely on Ops
20424 // using tensors to handle the NULL case, but if they fail to do so
20425 // they'll end up with nasty segfaults, so this is public service.
20426 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
20427 {
20428 __failure = 386;
20429 if (!PyErr_Occurred()) {
20430 PyErr_SetString(PyExc_RuntimeError,
20431 "Unexpected error in an Op's C code. "
20432 "No Python exception was set.");
20433 }
20434 goto __label_386;}
20435 }
20436 if (!PyArray_Check(py_V385)) {
20437 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
20438 {
20439 __failure = 386;
20440 if (!PyErr_Occurred()) {
20441 PyErr_SetString(PyExc_RuntimeError,
20442 "Unexpected error in an Op's C code. "
20443 "No Python exception was set.");
20444 }
20445 goto __label_386;}
20446 }
20447 // We expect NPY_FLOAT64
20448 if (!PyArray_ISALIGNED((PyArrayObject*) py_V385)) {
20449 PyArrayObject * tmp = (PyArrayObject*) py_V385;
20450 PyErr_Format(PyExc_NotImplementedError,
20451 "expected an aligned array of type %ld "
20452 "(NPY_FLOAT64), got non-aligned array of type %ld"
20453 " with %ld dimensions, with 3 last dims "
20454 "%ld, %ld, %ld"
20455 " and 3 last strides %ld %ld, %ld.",
20456 (long int) NPY_FLOAT64,
20457 (long int) PyArray_TYPE((PyArrayObject*) py_V385),
20458 (long int) PyArray_NDIM(tmp),
20459 (long int) (PyArray_NDIM(tmp) >= 3 ?
20460 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
20461 (long int) (PyArray_NDIM(tmp) >= 2 ?
20462 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
20463 (long int) (PyArray_NDIM(tmp) >= 1 ?
20464 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
20465 (long int) (PyArray_NDIM(tmp) >= 3 ?
20466 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
20467 (long int) (PyArray_NDIM(tmp) >= 2 ?
20468 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
20469 (long int) (PyArray_NDIM(tmp) >= 1 ?
20470 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
20471 );
20472 {
20473 __failure = 386;
20474 if (!PyErr_Occurred()) {
20475 PyErr_SetString(PyExc_RuntimeError,
20476 "Unexpected error in an Op's C code. "
20477 "No Python exception was set.");
20478 }
20479 goto __label_386;}
20480 }
20481 // This is a TypeError to be consistent with DEBUG_MODE
20482 // Note: DEBUG_MODE also tells the name of the container
20483 if (PyArray_TYPE((PyArrayObject*) py_V385) != NPY_FLOAT64) {
20484 PyErr_Format(PyExc_TypeError,
20485 "expected type_num %d (NPY_FLOAT64) got %d",
20486 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V385));
20487 {
20488 __failure = 386;
20489 if (!PyErr_Occurred()) {
20490 PyErr_SetString(PyExc_RuntimeError,
20491 "Unexpected error in an Op's C code. "
20492 "No Python exception was set.");
20493 }
20494 goto __label_386;}
20495 }
20496
20497 V385 = (PyArrayObject*)(py_V385);
20498 Py_XINCREF(V385);
20499
20500 {
20501
20502 py_V387 = PyList_GET_ITEM(storage_V387, 0);
20503 {Py_XINCREF(py_V387);}
20504
20505 V387 = NULL;
20506 if (py_V387 == Py_None) {
20507 // We can either fail here or set V387 to NULL and rely on Ops
20508 // using tensors to handle the NULL case, but if they fail to do so
20509 // they'll end up with nasty segfaults, so this is public service.
20510 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
20511 {
20512 __failure = 388;
20513 if (!PyErr_Occurred()) {
20514 PyErr_SetString(PyExc_RuntimeError,
20515 "Unexpected error in an Op's C code. "
20516 "No Python exception was set.");
20517 }
20518 goto __label_388;}
20519 }
20520 if (!PyArray_Check(py_V387)) {
20521 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
20522 {
20523 __failure = 388;
20524 if (!PyErr_Occurred()) {
20525 PyErr_SetString(PyExc_RuntimeError,
20526 "Unexpected error in an Op's C code. "
20527 "No Python exception was set.");
20528 }
20529 goto __label_388;}
20530 }
20531 // We expect NPY_FLOAT64
20532 if (!PyArray_ISALIGNED((PyArrayObject*) py_V387)) {
20533 PyArrayObject * tmp = (PyArrayObject*) py_V387;
20534 PyErr_Format(PyExc_NotImplementedError,
20535 "expected an aligned array of type %ld "
20536 "(NPY_FLOAT64), got non-aligned array of type %ld"
20537 " with %ld dimensions, with 3 last dims "
20538 "%ld, %ld, %ld"
20539 " and 3 last strides %ld %ld, %ld.",
20540 (long int) NPY_FLOAT64,
20541 (long int) PyArray_TYPE((PyArrayObject*) py_V387),
20542 (long int) PyArray_NDIM(tmp),
20543 (long int) (PyArray_NDIM(tmp) >= 3 ?
20544 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
20545 (long int) (PyArray_NDIM(tmp) >= 2 ?
20546 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
20547 (long int) (PyArray_NDIM(tmp) >= 1 ?
20548 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
20549 (long int) (PyArray_NDIM(tmp) >= 3 ?
20550 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
20551 (long int) (PyArray_NDIM(tmp) >= 2 ?
20552 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
20553 (long int) (PyArray_NDIM(tmp) >= 1 ?
20554 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
20555 );
20556 {
20557 __failure = 388;
20558 if (!PyErr_Occurred()) {
20559 PyErr_SetString(PyExc_RuntimeError,
20560 "Unexpected error in an Op's C code. "
20561 "No Python exception was set.");
20562 }
20563 goto __label_388;}
20564 }
20565 // This is a TypeError to be consistent with DEBUG_MODE
20566 // Note: DEBUG_MODE also tells the name of the container
20567 if (PyArray_TYPE((PyArrayObject*) py_V387) != NPY_FLOAT64) {
20568 PyErr_Format(PyExc_TypeError,
20569 "expected type_num %d (NPY_FLOAT64) got %d",
20570 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V387));
20571 {
20572 __failure = 388;
20573 if (!PyErr_Occurred()) {
20574 PyErr_SetString(PyExc_RuntimeError,
20575 "Unexpected error in an Op's C code. "
20576 "No Python exception was set.");
20577 }
20578 goto __label_388;}
20579 }
20580
20581 V387 = (PyArrayObject*)(py_V387);
20582 Py_XINCREF(V387);
20583
20584 {
20585
20586 py_V389 = PyList_GET_ITEM(storage_V389, 0);
20587 {Py_XINCREF(py_V389);}
20588
20589 V389 = NULL;
20590 if (py_V389 == Py_None) {
20591 // We can either fail here or set V389 to NULL and rely on Ops
20592 // using tensors to handle the NULL case, but if they fail to do so
20593 // they'll end up with nasty segfaults, so this is public service.
20594 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
20595 {
20596 __failure = 390;
20597 if (!PyErr_Occurred()) {
20598 PyErr_SetString(PyExc_RuntimeError,
20599 "Unexpected error in an Op's C code. "
20600 "No Python exception was set.");
20601 }
20602 goto __label_390;}
20603 }
20604 if (!PyArray_Check(py_V389)) {
20605 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
20606 {
20607 __failure = 390;
20608 if (!PyErr_Occurred()) {
20609 PyErr_SetString(PyExc_RuntimeError,
20610 "Unexpected error in an Op's C code. "
20611 "No Python exception was set.");
20612 }
20613 goto __label_390;}
20614 }
20615 // We expect NPY_FLOAT64
20616 if (!PyArray_ISALIGNED((PyArrayObject*) py_V389)) {
20617 PyArrayObject * tmp = (PyArrayObject*) py_V389;
20618 PyErr_Format(PyExc_NotImplementedError,
20619 "expected an aligned array of type %ld "
20620 "(NPY_FLOAT64), got non-aligned array of type %ld"
20621 " with %ld dimensions, with 3 last dims "
20622 "%ld, %ld, %ld"
20623 " and 3 last strides %ld %ld, %ld.",
20624 (long int) NPY_FLOAT64,
20625 (long int) PyArray_TYPE((PyArrayObject*) py_V389),
20626 (long int) PyArray_NDIM(tmp),
20627 (long int) (PyArray_NDIM(tmp) >= 3 ?
20628 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
20629 (long int) (PyArray_NDIM(tmp) >= 2 ?
20630 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
20631 (long int) (PyArray_NDIM(tmp) >= 1 ?
20632 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
20633 (long int) (PyArray_NDIM(tmp) >= 3 ?
20634 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
20635 (long int) (PyArray_NDIM(tmp) >= 2 ?
20636 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
20637 (long int) (PyArray_NDIM(tmp) >= 1 ?
20638 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
20639 );
20640 {
20641 __failure = 390;
20642 if (!PyErr_Occurred()) {
20643 PyErr_SetString(PyExc_RuntimeError,
20644 "Unexpected error in an Op's C code. "
20645 "No Python exception was set.");
20646 }
20647 goto __label_390;}
20648 }
20649 // This is a TypeError to be consistent with DEBUG_MODE
20650 // Note: DEBUG_MODE also tells the name of the container
20651 if (PyArray_TYPE((PyArrayObject*) py_V389) != NPY_FLOAT64) {
20652 PyErr_Format(PyExc_TypeError,
20653 "expected type_num %d (NPY_FLOAT64) got %d",
20654 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V389));
20655 {
20656 __failure = 390;
20657 if (!PyErr_Occurred()) {
20658 PyErr_SetString(PyExc_RuntimeError,
20659 "Unexpected error in an Op's C code. "
20660 "No Python exception was set.");
20661 }
20662 goto __label_390;}
20663 }
20664
20665 V389 = (PyArrayObject*)(py_V389);
20666 Py_XINCREF(V389);
20667
20668 {
20669
20670 py_V391 = PyList_GET_ITEM(storage_V391, 0);
20671 {Py_XINCREF(py_V391);}
20672
20673 V391 = NULL;
20674 if (py_V391 == Py_None) {
20675 // We can either fail here or set V391 to NULL and rely on Ops
20676 // using tensors to handle the NULL case, but if they fail to do so
20677 // they'll end up with nasty segfaults, so this is public service.
20678 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
20679 {
20680 __failure = 392;
20681 if (!PyErr_Occurred()) {
20682 PyErr_SetString(PyExc_RuntimeError,
20683 "Unexpected error in an Op's C code. "
20684 "No Python exception was set.");
20685 }
20686 goto __label_392;}
20687 }
20688 if (!PyArray_Check(py_V391)) {
20689 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
20690 {
20691 __failure = 392;
20692 if (!PyErr_Occurred()) {
20693 PyErr_SetString(PyExc_RuntimeError,
20694 "Unexpected error in an Op's C code. "
20695 "No Python exception was set.");
20696 }
20697 goto __label_392;}
20698 }
20699 // We expect NPY_FLOAT64
20700 if (!PyArray_ISALIGNED((PyArrayObject*) py_V391)) {
20701 PyArrayObject * tmp = (PyArrayObject*) py_V391;
20702 PyErr_Format(PyExc_NotImplementedError,
20703 "expected an aligned array of type %ld "
20704 "(NPY_FLOAT64), got non-aligned array of type %ld"
20705 " with %ld dimensions, with 3 last dims "
20706 "%ld, %ld, %ld"
20707 " and 3 last strides %ld %ld, %ld.",
20708 (long int) NPY_FLOAT64,
20709 (long int) PyArray_TYPE((PyArrayObject*) py_V391),
20710 (long int) PyArray_NDIM(tmp),
20711 (long int) (PyArray_NDIM(tmp) >= 3 ?
20712 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
20713 (long int) (PyArray_NDIM(tmp) >= 2 ?
20714 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
20715 (long int) (PyArray_NDIM(tmp) >= 1 ?
20716 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
20717 (long int) (PyArray_NDIM(tmp) >= 3 ?
20718 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
20719 (long int) (PyArray_NDIM(tmp) >= 2 ?
20720 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
20721 (long int) (PyArray_NDIM(tmp) >= 1 ?
20722 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
20723 );
20724 {
20725 __failure = 392;
20726 if (!PyErr_Occurred()) {
20727 PyErr_SetString(PyExc_RuntimeError,
20728 "Unexpected error in an Op's C code. "
20729 "No Python exception was set.");
20730 }
20731 goto __label_392;}
20732 }
20733 // This is a TypeError to be consistent with DEBUG_MODE
20734 // Note: DEBUG_MODE also tells the name of the container
20735 if (PyArray_TYPE((PyArrayObject*) py_V391) != NPY_FLOAT64) {
20736 PyErr_Format(PyExc_TypeError,
20737 "expected type_num %d (NPY_FLOAT64) got %d",
20738 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V391));
20739 {
20740 __failure = 392;
20741 if (!PyErr_Occurred()) {
20742 PyErr_SetString(PyExc_RuntimeError,
20743 "Unexpected error in an Op's C code. "
20744 "No Python exception was set.");
20745 }
20746 goto __label_392;}
20747 }
20748
20749 V391 = (PyArrayObject*)(py_V391);
20750 Py_XINCREF(V391);
20751
20752 {
20753
20754 py_V393 = PyList_GET_ITEM(storage_V393, 0);
20755 {Py_XINCREF(py_V393);}
20756
20757 V393 = NULL;
20758 if (py_V393 == Py_None) {
20759 // We can either fail here or set V393 to NULL and rely on Ops
20760 // using tensors to handle the NULL case, but if they fail to do so
20761 // they'll end up with nasty segfaults, so this is public service.
20762 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
20763 {
20764 __failure = 394;
20765 if (!PyErr_Occurred()) {
20766 PyErr_SetString(PyExc_RuntimeError,
20767 "Unexpected error in an Op's C code. "
20768 "No Python exception was set.");
20769 }
20770 goto __label_394;}
20771 }
20772 if (!PyArray_Check(py_V393)) {
20773 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
20774 {
20775 __failure = 394;
20776 if (!PyErr_Occurred()) {
20777 PyErr_SetString(PyExc_RuntimeError,
20778 "Unexpected error in an Op's C code. "
20779 "No Python exception was set.");
20780 }
20781 goto __label_394;}
20782 }
20783 // We expect NPY_FLOAT64
20784 if (!PyArray_ISALIGNED((PyArrayObject*) py_V393)) {
20785 PyArrayObject * tmp = (PyArrayObject*) py_V393;
20786 PyErr_Format(PyExc_NotImplementedError,
20787 "expected an aligned array of type %ld "
20788 "(NPY_FLOAT64), got non-aligned array of type %ld"
20789 " with %ld dimensions, with 3 last dims "
20790 "%ld, %ld, %ld"
20791 " and 3 last strides %ld %ld, %ld.",
20792 (long int) NPY_FLOAT64,
20793 (long int) PyArray_TYPE((PyArrayObject*) py_V393),
20794 (long int) PyArray_NDIM(tmp),
20795 (long int) (PyArray_NDIM(tmp) >= 3 ?
20796 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
20797 (long int) (PyArray_NDIM(tmp) >= 2 ?
20798 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
20799 (long int) (PyArray_NDIM(tmp) >= 1 ?
20800 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
20801 (long int) (PyArray_NDIM(tmp) >= 3 ?
20802 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
20803 (long int) (PyArray_NDIM(tmp) >= 2 ?
20804 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
20805 (long int) (PyArray_NDIM(tmp) >= 1 ?
20806 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
20807 );
20808 {
20809 __failure = 394;
20810 if (!PyErr_Occurred()) {
20811 PyErr_SetString(PyExc_RuntimeError,
20812 "Unexpected error in an Op's C code. "
20813 "No Python exception was set.");
20814 }
20815 goto __label_394;}
20816 }
20817 // This is a TypeError to be consistent with DEBUG_MODE
20818 // Note: DEBUG_MODE also tells the name of the container
20819 if (PyArray_TYPE((PyArrayObject*) py_V393) != NPY_FLOAT64) {
20820 PyErr_Format(PyExc_TypeError,
20821 "expected type_num %d (NPY_FLOAT64) got %d",
20822 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V393));
20823 {
20824 __failure = 394;
20825 if (!PyErr_Occurred()) {
20826 PyErr_SetString(PyExc_RuntimeError,
20827 "Unexpected error in an Op's C code. "
20828 "No Python exception was set.");
20829 }
20830 goto __label_394;}
20831 }
20832
20833 V393 = (PyArrayObject*)(py_V393);
20834 Py_XINCREF(V393);
20835
20836 {
20837
20838 py_V395 = PyList_GET_ITEM(storage_V395, 0);
20839 {Py_XINCREF(py_V395);}
20840
20841 V395 = NULL;
20842 if (py_V395 == Py_None) {
20843 // We can either fail here or set V395 to NULL and rely on Ops
20844 // using tensors to handle the NULL case, but if they fail to do so
20845 // they'll end up with nasty segfaults, so this is public service.
20846 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
20847 {
20848 __failure = 396;
20849 if (!PyErr_Occurred()) {
20850 PyErr_SetString(PyExc_RuntimeError,
20851 "Unexpected error in an Op's C code. "
20852 "No Python exception was set.");
20853 }
20854 goto __label_396;}
20855 }
20856 if (!PyArray_Check(py_V395)) {
20857 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
20858 {
20859 __failure = 396;
20860 if (!PyErr_Occurred()) {
20861 PyErr_SetString(PyExc_RuntimeError,
20862 "Unexpected error in an Op's C code. "
20863 "No Python exception was set.");
20864 }
20865 goto __label_396;}
20866 }
20867 // We expect NPY_FLOAT64
20868 if (!PyArray_ISALIGNED((PyArrayObject*) py_V395)) {
20869 PyArrayObject * tmp = (PyArrayObject*) py_V395;
20870 PyErr_Format(PyExc_NotImplementedError,
20871 "expected an aligned array of type %ld "
20872 "(NPY_FLOAT64), got non-aligned array of type %ld"
20873 " with %ld dimensions, with 3 last dims "
20874 "%ld, %ld, %ld"
20875 " and 3 last strides %ld %ld, %ld.",
20876 (long int) NPY_FLOAT64,
20877 (long int) PyArray_TYPE((PyArrayObject*) py_V395),
20878 (long int) PyArray_NDIM(tmp),
20879 (long int) (PyArray_NDIM(tmp) >= 3 ?
20880 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
20881 (long int) (PyArray_NDIM(tmp) >= 2 ?
20882 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
20883 (long int) (PyArray_NDIM(tmp) >= 1 ?
20884 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
20885 (long int) (PyArray_NDIM(tmp) >= 3 ?
20886 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
20887 (long int) (PyArray_NDIM(tmp) >= 2 ?
20888 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
20889 (long int) (PyArray_NDIM(tmp) >= 1 ?
20890 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
20891 );
20892 {
20893 __failure = 396;
20894 if (!PyErr_Occurred()) {
20895 PyErr_SetString(PyExc_RuntimeError,
20896 "Unexpected error in an Op's C code. "
20897 "No Python exception was set.");
20898 }
20899 goto __label_396;}
20900 }
20901 // This is a TypeError to be consistent with DEBUG_MODE
20902 // Note: DEBUG_MODE also tells the name of the container
20903 if (PyArray_TYPE((PyArrayObject*) py_V395) != NPY_FLOAT64) {
20904 PyErr_Format(PyExc_TypeError,
20905 "expected type_num %d (NPY_FLOAT64) got %d",
20906 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V395));
20907 {
20908 __failure = 396;
20909 if (!PyErr_Occurred()) {
20910 PyErr_SetString(PyExc_RuntimeError,
20911 "Unexpected error in an Op's C code. "
20912 "No Python exception was set.");
20913 }
20914 goto __label_396;}
20915 }
20916
20917 V395 = (PyArrayObject*)(py_V395);
20918 Py_XINCREF(V395);
20919
20920 {
20921
20922 py_V397 = PyList_GET_ITEM(storage_V397, 0);
20923 {Py_XINCREF(py_V397);}
20924
20925 V397 = NULL;
20926 if (py_V397 == Py_None) {
20927 // We can either fail here or set V397 to NULL and rely on Ops
20928 // using tensors to handle the NULL case, but if they fail to do so
20929 // they'll end up with nasty segfaults, so this is public service.
20930 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
20931 {
20932 __failure = 398;
20933 if (!PyErr_Occurred()) {
20934 PyErr_SetString(PyExc_RuntimeError,
20935 "Unexpected error in an Op's C code. "
20936 "No Python exception was set.");
20937 }
20938 goto __label_398;}
20939 }
20940 if (!PyArray_Check(py_V397)) {
20941 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
20942 {
20943 __failure = 398;
20944 if (!PyErr_Occurred()) {
20945 PyErr_SetString(PyExc_RuntimeError,
20946 "Unexpected error in an Op's C code. "
20947 "No Python exception was set.");
20948 }
20949 goto __label_398;}
20950 }
20951 // We expect NPY_FLOAT64
20952 if (!PyArray_ISALIGNED((PyArrayObject*) py_V397)) {
20953 PyArrayObject * tmp = (PyArrayObject*) py_V397;
20954 PyErr_Format(PyExc_NotImplementedError,
20955 "expected an aligned array of type %ld "
20956 "(NPY_FLOAT64), got non-aligned array of type %ld"
20957 " with %ld dimensions, with 3 last dims "
20958 "%ld, %ld, %ld"
20959 " and 3 last strides %ld %ld, %ld.",
20960 (long int) NPY_FLOAT64,
20961 (long int) PyArray_TYPE((PyArrayObject*) py_V397),
20962 (long int) PyArray_NDIM(tmp),
20963 (long int) (PyArray_NDIM(tmp) >= 3 ?
20964 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
20965 (long int) (PyArray_NDIM(tmp) >= 2 ?
20966 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
20967 (long int) (PyArray_NDIM(tmp) >= 1 ?
20968 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
20969 (long int) (PyArray_NDIM(tmp) >= 3 ?
20970 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
20971 (long int) (PyArray_NDIM(tmp) >= 2 ?
20972 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
20973 (long int) (PyArray_NDIM(tmp) >= 1 ?
20974 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
20975 );
20976 {
20977 __failure = 398;
20978 if (!PyErr_Occurred()) {
20979 PyErr_SetString(PyExc_RuntimeError,
20980 "Unexpected error in an Op's C code. "
20981 "No Python exception was set.");
20982 }
20983 goto __label_398;}
20984 }
20985 // This is a TypeError to be consistent with DEBUG_MODE
20986 // Note: DEBUG_MODE also tells the name of the container
20987 if (PyArray_TYPE((PyArrayObject*) py_V397) != NPY_FLOAT64) {
20988 PyErr_Format(PyExc_TypeError,
20989 "expected type_num %d (NPY_FLOAT64) got %d",
20990 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V397));
20991 {
20992 __failure = 398;
20993 if (!PyErr_Occurred()) {
20994 PyErr_SetString(PyExc_RuntimeError,
20995 "Unexpected error in an Op's C code. "
20996 "No Python exception was set.");
20997 }
20998 goto __label_398;}
20999 }
21000
21001 V397 = (PyArrayObject*)(py_V397);
21002 Py_XINCREF(V397);
21003
21004 {
21005
21006 py_V399 = PyList_GET_ITEM(storage_V399, 0);
21007 {Py_XINCREF(py_V399);}
21008
21009 V399 = NULL;
21010 if (py_V399 == Py_None) {
21011 // We can either fail here or set V399 to NULL and rely on Ops
21012 // using tensors to handle the NULL case, but if they fail to do so
21013 // they'll end up with nasty segfaults, so this is public service.
21014 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
21015 {
21016 __failure = 400;
21017 if (!PyErr_Occurred()) {
21018 PyErr_SetString(PyExc_RuntimeError,
21019 "Unexpected error in an Op's C code. "
21020 "No Python exception was set.");
21021 }
21022 goto __label_400;}
21023 }
21024 if (!PyArray_Check(py_V399)) {
21025 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
21026 {
21027 __failure = 400;
21028 if (!PyErr_Occurred()) {
21029 PyErr_SetString(PyExc_RuntimeError,
21030 "Unexpected error in an Op's C code. "
21031 "No Python exception was set.");
21032 }
21033 goto __label_400;}
21034 }
21035 // We expect NPY_FLOAT64
21036 if (!PyArray_ISALIGNED((PyArrayObject*) py_V399)) {
21037 PyArrayObject * tmp = (PyArrayObject*) py_V399;
21038 PyErr_Format(PyExc_NotImplementedError,
21039 "expected an aligned array of type %ld "
21040 "(NPY_FLOAT64), got non-aligned array of type %ld"
21041 " with %ld dimensions, with 3 last dims "
21042 "%ld, %ld, %ld"
21043 " and 3 last strides %ld %ld, %ld.",
21044 (long int) NPY_FLOAT64,
21045 (long int) PyArray_TYPE((PyArrayObject*) py_V399),
21046 (long int) PyArray_NDIM(tmp),
21047 (long int) (PyArray_NDIM(tmp) >= 3 ?
21048 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
21049 (long int) (PyArray_NDIM(tmp) >= 2 ?
21050 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
21051 (long int) (PyArray_NDIM(tmp) >= 1 ?
21052 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
21053 (long int) (PyArray_NDIM(tmp) >= 3 ?
21054 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
21055 (long int) (PyArray_NDIM(tmp) >= 2 ?
21056 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
21057 (long int) (PyArray_NDIM(tmp) >= 1 ?
21058 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
21059 );
21060 {
21061 __failure = 400;
21062 if (!PyErr_Occurred()) {
21063 PyErr_SetString(PyExc_RuntimeError,
21064 "Unexpected error in an Op's C code. "
21065 "No Python exception was set.");
21066 }
21067 goto __label_400;}
21068 }
21069 // This is a TypeError to be consistent with DEBUG_MODE
21070 // Note: DEBUG_MODE also tells the name of the container
21071 if (PyArray_TYPE((PyArrayObject*) py_V399) != NPY_FLOAT64) {
21072 PyErr_Format(PyExc_TypeError,
21073 "expected type_num %d (NPY_FLOAT64) got %d",
21074 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V399));
21075 {
21076 __failure = 400;
21077 if (!PyErr_Occurred()) {
21078 PyErr_SetString(PyExc_RuntimeError,
21079 "Unexpected error in an Op's C code. "
21080 "No Python exception was set.");
21081 }
21082 goto __label_400;}
21083 }
21084
21085 V399 = (PyArrayObject*)(py_V399);
21086 Py_XINCREF(V399);
21087
21088 {
21089
21090 py_V401 = PyList_GET_ITEM(storage_V401, 0);
21091 {Py_XINCREF(py_V401);}
21092
21093 V401 = NULL;
21094 if (py_V401 == Py_None) {
21095 // We can either fail here or set V401 to NULL and rely on Ops
21096 // using tensors to handle the NULL case, but if they fail to do so
21097 // they'll end up with nasty segfaults, so this is public service.
21098 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
21099 {
21100 __failure = 402;
21101 if (!PyErr_Occurred()) {
21102 PyErr_SetString(PyExc_RuntimeError,
21103 "Unexpected error in an Op's C code. "
21104 "No Python exception was set.");
21105 }
21106 goto __label_402;}
21107 }
21108 if (!PyArray_Check(py_V401)) {
21109 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
21110 {
21111 __failure = 402;
21112 if (!PyErr_Occurred()) {
21113 PyErr_SetString(PyExc_RuntimeError,
21114 "Unexpected error in an Op's C code. "
21115 "No Python exception was set.");
21116 }
21117 goto __label_402;}
21118 }
21119 // We expect NPY_FLOAT64
21120 if (!PyArray_ISALIGNED((PyArrayObject*) py_V401)) {
21121 PyArrayObject * tmp = (PyArrayObject*) py_V401;
21122 PyErr_Format(PyExc_NotImplementedError,
21123 "expected an aligned array of type %ld "
21124 "(NPY_FLOAT64), got non-aligned array of type %ld"
21125 " with %ld dimensions, with 3 last dims "
21126 "%ld, %ld, %ld"
21127 " and 3 last strides %ld %ld, %ld.",
21128 (long int) NPY_FLOAT64,
21129 (long int) PyArray_TYPE((PyArrayObject*) py_V401),
21130 (long int) PyArray_NDIM(tmp),
21131 (long int) (PyArray_NDIM(tmp) >= 3 ?
21132 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
21133 (long int) (PyArray_NDIM(tmp) >= 2 ?
21134 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
21135 (long int) (PyArray_NDIM(tmp) >= 1 ?
21136 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
21137 (long int) (PyArray_NDIM(tmp) >= 3 ?
21138 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
21139 (long int) (PyArray_NDIM(tmp) >= 2 ?
21140 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
21141 (long int) (PyArray_NDIM(tmp) >= 1 ?
21142 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
21143 );
21144 {
21145 __failure = 402;
21146 if (!PyErr_Occurred()) {
21147 PyErr_SetString(PyExc_RuntimeError,
21148 "Unexpected error in an Op's C code. "
21149 "No Python exception was set.");
21150 }
21151 goto __label_402;}
21152 }
21153 // This is a TypeError to be consistent with DEBUG_MODE
21154 // Note: DEBUG_MODE also tells the name of the container
21155 if (PyArray_TYPE((PyArrayObject*) py_V401) != NPY_FLOAT64) {
21156 PyErr_Format(PyExc_TypeError,
21157 "expected type_num %d (NPY_FLOAT64) got %d",
21158 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V401));
21159 {
21160 __failure = 402;
21161 if (!PyErr_Occurred()) {
21162 PyErr_SetString(PyExc_RuntimeError,
21163 "Unexpected error in an Op's C code. "
21164 "No Python exception was set.");
21165 }
21166 goto __label_402;}
21167 }
21168
21169 V401 = (PyArrayObject*)(py_V401);
21170 Py_XINCREF(V401);
21171
21172 {
21173
21174 py_V403 = PyList_GET_ITEM(storage_V403, 0);
21175 {Py_XINCREF(py_V403);}
21176
21177 V403 = NULL;
21178 if (py_V403 == Py_None) {
21179 // We can either fail here or set V403 to NULL and rely on Ops
21180 // using tensors to handle the NULL case, but if they fail to do so
21181 // they'll end up with nasty segfaults, so this is public service.
21182 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
21183 {
21184 __failure = 404;
21185 if (!PyErr_Occurred()) {
21186 PyErr_SetString(PyExc_RuntimeError,
21187 "Unexpected error in an Op's C code. "
21188 "No Python exception was set.");
21189 }
21190 goto __label_404;}
21191 }
21192 if (!PyArray_Check(py_V403)) {
21193 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
21194 {
21195 __failure = 404;
21196 if (!PyErr_Occurred()) {
21197 PyErr_SetString(PyExc_RuntimeError,
21198 "Unexpected error in an Op's C code. "
21199 "No Python exception was set.");
21200 }
21201 goto __label_404;}
21202 }
21203 // We expect NPY_FLOAT64
21204 if (!PyArray_ISALIGNED((PyArrayObject*) py_V403)) {
21205 PyArrayObject * tmp = (PyArrayObject*) py_V403;
21206 PyErr_Format(PyExc_NotImplementedError,
21207 "expected an aligned array of type %ld "
21208 "(NPY_FLOAT64), got non-aligned array of type %ld"
21209 " with %ld dimensions, with 3 last dims "
21210 "%ld, %ld, %ld"
21211 " and 3 last strides %ld %ld, %ld.",
21212 (long int) NPY_FLOAT64,
21213 (long int) PyArray_TYPE((PyArrayObject*) py_V403),
21214 (long int) PyArray_NDIM(tmp),
21215 (long int) (PyArray_NDIM(tmp) >= 3 ?
21216 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
21217 (long int) (PyArray_NDIM(tmp) >= 2 ?
21218 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
21219 (long int) (PyArray_NDIM(tmp) >= 1 ?
21220 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
21221 (long int) (PyArray_NDIM(tmp) >= 3 ?
21222 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
21223 (long int) (PyArray_NDIM(tmp) >= 2 ?
21224 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
21225 (long int) (PyArray_NDIM(tmp) >= 1 ?
21226 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
21227 );
21228 {
21229 __failure = 404;
21230 if (!PyErr_Occurred()) {
21231 PyErr_SetString(PyExc_RuntimeError,
21232 "Unexpected error in an Op's C code. "
21233 "No Python exception was set.");
21234 }
21235 goto __label_404;}
21236 }
21237 // This is a TypeError to be consistent with DEBUG_MODE
21238 // Note: DEBUG_MODE also tells the name of the container
21239 if (PyArray_TYPE((PyArrayObject*) py_V403) != NPY_FLOAT64) {
21240 PyErr_Format(PyExc_TypeError,
21241 "expected type_num %d (NPY_FLOAT64) got %d",
21242 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V403));
21243 {
21244 __failure = 404;
21245 if (!PyErr_Occurred()) {
21246 PyErr_SetString(PyExc_RuntimeError,
21247 "Unexpected error in an Op's C code. "
21248 "No Python exception was set.");
21249 }
21250 goto __label_404;}
21251 }
21252
21253 V403 = (PyArrayObject*)(py_V403);
21254 Py_XINCREF(V403);
21255
21256 {
21257
21258 py_V405 = PyList_GET_ITEM(storage_V405, 0);
21259 {Py_XINCREF(py_V405);}
21260
21261 V405 = NULL;
21262 if (py_V405 == Py_None) {
21263 // We can either fail here or set V405 to NULL and rely on Ops
21264 // using tensors to handle the NULL case, but if they fail to do so
21265 // they'll end up with nasty segfaults, so this is public service.
21266 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
21267 {
21268 __failure = 406;
21269 if (!PyErr_Occurred()) {
21270 PyErr_SetString(PyExc_RuntimeError,
21271 "Unexpected error in an Op's C code. "
21272 "No Python exception was set.");
21273 }
21274 goto __label_406;}
21275 }
21276 if (!PyArray_Check(py_V405)) {
21277 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
21278 {
21279 __failure = 406;
21280 if (!PyErr_Occurred()) {
21281 PyErr_SetString(PyExc_RuntimeError,
21282 "Unexpected error in an Op's C code. "
21283 "No Python exception was set.");
21284 }
21285 goto __label_406;}
21286 }
21287 // We expect NPY_FLOAT64
21288 if (!PyArray_ISALIGNED((PyArrayObject*) py_V405)) {
21289 PyArrayObject * tmp = (PyArrayObject*) py_V405;
21290 PyErr_Format(PyExc_NotImplementedError,
21291 "expected an aligned array of type %ld "
21292 "(NPY_FLOAT64), got non-aligned array of type %ld"
21293 " with %ld dimensions, with 3 last dims "
21294 "%ld, %ld, %ld"
21295 " and 3 last strides %ld %ld, %ld.",
21296 (long int) NPY_FLOAT64,
21297 (long int) PyArray_TYPE((PyArrayObject*) py_V405),
21298 (long int) PyArray_NDIM(tmp),
21299 (long int) (PyArray_NDIM(tmp) >= 3 ?
21300 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
21301 (long int) (PyArray_NDIM(tmp) >= 2 ?
21302 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
21303 (long int) (PyArray_NDIM(tmp) >= 1 ?
21304 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
21305 (long int) (PyArray_NDIM(tmp) >= 3 ?
21306 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
21307 (long int) (PyArray_NDIM(tmp) >= 2 ?
21308 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
21309 (long int) (PyArray_NDIM(tmp) >= 1 ?
21310 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
21311 );
21312 {
21313 __failure = 406;
21314 if (!PyErr_Occurred()) {
21315 PyErr_SetString(PyExc_RuntimeError,
21316 "Unexpected error in an Op's C code. "
21317 "No Python exception was set.");
21318 }
21319 goto __label_406;}
21320 }
21321 // This is a TypeError to be consistent with DEBUG_MODE
21322 // Note: DEBUG_MODE also tells the name of the container
21323 if (PyArray_TYPE((PyArrayObject*) py_V405) != NPY_FLOAT64) {
21324 PyErr_Format(PyExc_TypeError,
21325 "expected type_num %d (NPY_FLOAT64) got %d",
21326 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V405));
21327 {
21328 __failure = 406;
21329 if (!PyErr_Occurred()) {
21330 PyErr_SetString(PyExc_RuntimeError,
21331 "Unexpected error in an Op's C code. "
21332 "No Python exception was set.");
21333 }
21334 goto __label_406;}
21335 }
21336
21337 V405 = (PyArrayObject*)(py_V405);
21338 Py_XINCREF(V405);
21339
21340 {
21341
21342 py_V407 = PyList_GET_ITEM(storage_V407, 0);
21343 {Py_XINCREF(py_V407);}
21344
21345 V407 = NULL;
21346 if (py_V407 == Py_None) {
21347 // We can either fail here or set V407 to NULL and rely on Ops
21348 // using tensors to handle the NULL case, but if they fail to do so
21349 // they'll end up with nasty segfaults, so this is public service.
21350 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
21351 {
21352 __failure = 408;
21353 if (!PyErr_Occurred()) {
21354 PyErr_SetString(PyExc_RuntimeError,
21355 "Unexpected error in an Op's C code. "
21356 "No Python exception was set.");
21357 }
21358 goto __label_408;}
21359 }
21360 if (!PyArray_Check(py_V407)) {
21361 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
21362 {
21363 __failure = 408;
21364 if (!PyErr_Occurred()) {
21365 PyErr_SetString(PyExc_RuntimeError,
21366 "Unexpected error in an Op's C code. "
21367 "No Python exception was set.");
21368 }
21369 goto __label_408;}
21370 }
21371 // We expect NPY_FLOAT64
21372 if (!PyArray_ISALIGNED((PyArrayObject*) py_V407)) {
21373 PyArrayObject * tmp = (PyArrayObject*) py_V407;
21374 PyErr_Format(PyExc_NotImplementedError,
21375 "expected an aligned array of type %ld "
21376 "(NPY_FLOAT64), got non-aligned array of type %ld"
21377 " with %ld dimensions, with 3 last dims "
21378 "%ld, %ld, %ld"
21379 " and 3 last strides %ld %ld, %ld.",
21380 (long int) NPY_FLOAT64,
21381 (long int) PyArray_TYPE((PyArrayObject*) py_V407),
21382 (long int) PyArray_NDIM(tmp),
21383 (long int) (PyArray_NDIM(tmp) >= 3 ?
21384 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
21385 (long int) (PyArray_NDIM(tmp) >= 2 ?
21386 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
21387 (long int) (PyArray_NDIM(tmp) >= 1 ?
21388 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
21389 (long int) (PyArray_NDIM(tmp) >= 3 ?
21390 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
21391 (long int) (PyArray_NDIM(tmp) >= 2 ?
21392 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
21393 (long int) (PyArray_NDIM(tmp) >= 1 ?
21394 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
21395 );
21396 {
21397 __failure = 408;
21398 if (!PyErr_Occurred()) {
21399 PyErr_SetString(PyExc_RuntimeError,
21400 "Unexpected error in an Op's C code. "
21401 "No Python exception was set.");
21402 }
21403 goto __label_408;}
21404 }
21405 // This is a TypeError to be consistent with DEBUG_MODE
21406 // Note: DEBUG_MODE also tells the name of the container
21407 if (PyArray_TYPE((PyArrayObject*) py_V407) != NPY_FLOAT64) {
21408 PyErr_Format(PyExc_TypeError,
21409 "expected type_num %d (NPY_FLOAT64) got %d",
21410 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V407));
21411 {
21412 __failure = 408;
21413 if (!PyErr_Occurred()) {
21414 PyErr_SetString(PyExc_RuntimeError,
21415 "Unexpected error in an Op's C code. "
21416 "No Python exception was set.");
21417 }
21418 goto __label_408;}
21419 }
21420
21421 V407 = (PyArrayObject*)(py_V407);
21422 Py_XINCREF(V407);
21423
21424 {
21425
21426 py_V409 = PyList_GET_ITEM(storage_V409, 0);
21427 {Py_XINCREF(py_V409);}
21428
21429 V409 = NULL;
21430 if (py_V409 == Py_None) {
21431 // We can either fail here or set V409 to NULL and rely on Ops
21432 // using tensors to handle the NULL case, but if they fail to do so
21433 // they'll end up with nasty segfaults, so this is public service.
21434 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
21435 {
21436 __failure = 410;
21437 if (!PyErr_Occurred()) {
21438 PyErr_SetString(PyExc_RuntimeError,
21439 "Unexpected error in an Op's C code. "
21440 "No Python exception was set.");
21441 }
21442 goto __label_410;}
21443 }
21444 if (!PyArray_Check(py_V409)) {
21445 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
21446 {
21447 __failure = 410;
21448 if (!PyErr_Occurred()) {
21449 PyErr_SetString(PyExc_RuntimeError,
21450 "Unexpected error in an Op's C code. "
21451 "No Python exception was set.");
21452 }
21453 goto __label_410;}
21454 }
21455 // We expect NPY_FLOAT64
21456 if (!PyArray_ISALIGNED((PyArrayObject*) py_V409)) {
21457 PyArrayObject * tmp = (PyArrayObject*) py_V409;
21458 PyErr_Format(PyExc_NotImplementedError,
21459 "expected an aligned array of type %ld "
21460 "(NPY_FLOAT64), got non-aligned array of type %ld"
21461 " with %ld dimensions, with 3 last dims "
21462 "%ld, %ld, %ld"
21463 " and 3 last strides %ld %ld, %ld.",
21464 (long int) NPY_FLOAT64,
21465 (long int) PyArray_TYPE((PyArrayObject*) py_V409),
21466 (long int) PyArray_NDIM(tmp),
21467 (long int) (PyArray_NDIM(tmp) >= 3 ?
21468 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
21469 (long int) (PyArray_NDIM(tmp) >= 2 ?
21470 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
21471 (long int) (PyArray_NDIM(tmp) >= 1 ?
21472 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
21473 (long int) (PyArray_NDIM(tmp) >= 3 ?
21474 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
21475 (long int) (PyArray_NDIM(tmp) >= 2 ?
21476 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
21477 (long int) (PyArray_NDIM(tmp) >= 1 ?
21478 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
21479 );
21480 {
21481 __failure = 410;
21482 if (!PyErr_Occurred()) {
21483 PyErr_SetString(PyExc_RuntimeError,
21484 "Unexpected error in an Op's C code. "
21485 "No Python exception was set.");
21486 }
21487 goto __label_410;}
21488 }
21489 // This is a TypeError to be consistent with DEBUG_MODE
21490 // Note: DEBUG_MODE also tells the name of the container
21491 if (PyArray_TYPE((PyArrayObject*) py_V409) != NPY_FLOAT64) {
21492 PyErr_Format(PyExc_TypeError,
21493 "expected type_num %d (NPY_FLOAT64) got %d",
21494 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V409));
21495 {
21496 __failure = 410;
21497 if (!PyErr_Occurred()) {
21498 PyErr_SetString(PyExc_RuntimeError,
21499 "Unexpected error in an Op's C code. "
21500 "No Python exception was set.");
21501 }
21502 goto __label_410;}
21503 }
21504
21505 V409 = (PyArrayObject*)(py_V409);
21506 Py_XINCREF(V409);
21507
21508 {
21509
21510 py_V411 = PyList_GET_ITEM(storage_V411, 0);
21511 {Py_XINCREF(py_V411);}
21512
21513 V411 = NULL;
21514 if (py_V411 == Py_None) {
21515 // We can either fail here or set V411 to NULL and rely on Ops
21516 // using tensors to handle the NULL case, but if they fail to do so
21517 // they'll end up with nasty segfaults, so this is public service.
21518 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
21519 {
21520 __failure = 412;
21521 if (!PyErr_Occurred()) {
21522 PyErr_SetString(PyExc_RuntimeError,
21523 "Unexpected error in an Op's C code. "
21524 "No Python exception was set.");
21525 }
21526 goto __label_412;}
21527 }
21528 if (!PyArray_Check(py_V411)) {
21529 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
21530 {
21531 __failure = 412;
21532 if (!PyErr_Occurred()) {
21533 PyErr_SetString(PyExc_RuntimeError,
21534 "Unexpected error in an Op's C code. "
21535 "No Python exception was set.");
21536 }
21537 goto __label_412;}
21538 }
21539 // We expect NPY_FLOAT64
21540 if (!PyArray_ISALIGNED((PyArrayObject*) py_V411)) {
21541 PyArrayObject * tmp = (PyArrayObject*) py_V411;
21542 PyErr_Format(PyExc_NotImplementedError,
21543 "expected an aligned array of type %ld "
21544 "(NPY_FLOAT64), got non-aligned array of type %ld"
21545 " with %ld dimensions, with 3 last dims "
21546 "%ld, %ld, %ld"
21547 " and 3 last strides %ld %ld, %ld.",
21548 (long int) NPY_FLOAT64,
21549 (long int) PyArray_TYPE((PyArrayObject*) py_V411),
21550 (long int) PyArray_NDIM(tmp),
21551 (long int) (PyArray_NDIM(tmp) >= 3 ?
21552 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
21553 (long int) (PyArray_NDIM(tmp) >= 2 ?
21554 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
21555 (long int) (PyArray_NDIM(tmp) >= 1 ?
21556 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
21557 (long int) (PyArray_NDIM(tmp) >= 3 ?
21558 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
21559 (long int) (PyArray_NDIM(tmp) >= 2 ?
21560 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
21561 (long int) (PyArray_NDIM(tmp) >= 1 ?
21562 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
21563 );
21564 {
21565 __failure = 412;
21566 if (!PyErr_Occurred()) {
21567 PyErr_SetString(PyExc_RuntimeError,
21568 "Unexpected error in an Op's C code. "
21569 "No Python exception was set.");
21570 }
21571 goto __label_412;}
21572 }
21573 // This is a TypeError to be consistent with DEBUG_MODE
21574 // Note: DEBUG_MODE also tells the name of the container
21575 if (PyArray_TYPE((PyArrayObject*) py_V411) != NPY_FLOAT64) {
21576 PyErr_Format(PyExc_TypeError,
21577 "expected type_num %d (NPY_FLOAT64) got %d",
21578 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V411));
21579 {
21580 __failure = 412;
21581 if (!PyErr_Occurred()) {
21582 PyErr_SetString(PyExc_RuntimeError,
21583 "Unexpected error in an Op's C code. "
21584 "No Python exception was set.");
21585 }
21586 goto __label_412;}
21587 }
21588
21589 V411 = (PyArrayObject*)(py_V411);
21590 Py_XINCREF(V411);
21591
21592 {
21593
21594 py_V413 = PyList_GET_ITEM(storage_V413, 0);
21595 {Py_XINCREF(py_V413);}
21596
21597 V413 = NULL;
21598 if (py_V413 == Py_None) {
21599 // We can either fail here or set V413 to NULL and rely on Ops
21600 // using tensors to handle the NULL case, but if they fail to do so
21601 // they'll end up with nasty segfaults, so this is public service.
21602 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
21603 {
21604 __failure = 414;
21605 if (!PyErr_Occurred()) {
21606 PyErr_SetString(PyExc_RuntimeError,
21607 "Unexpected error in an Op's C code. "
21608 "No Python exception was set.");
21609 }
21610 goto __label_414;}
21611 }
21612 if (!PyArray_Check(py_V413)) {
21613 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
21614 {
21615 __failure = 414;
21616 if (!PyErr_Occurred()) {
21617 PyErr_SetString(PyExc_RuntimeError,
21618 "Unexpected error in an Op's C code. "
21619 "No Python exception was set.");
21620 }
21621 goto __label_414;}
21622 }
21623 // We expect NPY_FLOAT64
21624 if (!PyArray_ISALIGNED((PyArrayObject*) py_V413)) {
21625 PyArrayObject * tmp = (PyArrayObject*) py_V413;
21626 PyErr_Format(PyExc_NotImplementedError,
21627 "expected an aligned array of type %ld "
21628 "(NPY_FLOAT64), got non-aligned array of type %ld"
21629 " with %ld dimensions, with 3 last dims "
21630 "%ld, %ld, %ld"
21631 " and 3 last strides %ld %ld, %ld.",
21632 (long int) NPY_FLOAT64,
21633 (long int) PyArray_TYPE((PyArrayObject*) py_V413),
21634 (long int) PyArray_NDIM(tmp),
21635 (long int) (PyArray_NDIM(tmp) >= 3 ?
21636 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
21637 (long int) (PyArray_NDIM(tmp) >= 2 ?
21638 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
21639 (long int) (PyArray_NDIM(tmp) >= 1 ?
21640 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
21641 (long int) (PyArray_NDIM(tmp) >= 3 ?
21642 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
21643 (long int) (PyArray_NDIM(tmp) >= 2 ?
21644 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
21645 (long int) (PyArray_NDIM(tmp) >= 1 ?
21646 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
21647 );
21648 {
21649 __failure = 414;
21650 if (!PyErr_Occurred()) {
21651 PyErr_SetString(PyExc_RuntimeError,
21652 "Unexpected error in an Op's C code. "
21653 "No Python exception was set.");
21654 }
21655 goto __label_414;}
21656 }
21657 // This is a TypeError to be consistent with DEBUG_MODE
21658 // Note: DEBUG_MODE also tells the name of the container
21659 if (PyArray_TYPE((PyArrayObject*) py_V413) != NPY_FLOAT64) {
21660 PyErr_Format(PyExc_TypeError,
21661 "expected type_num %d (NPY_FLOAT64) got %d",
21662 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V413));
21663 {
21664 __failure = 414;
21665 if (!PyErr_Occurred()) {
21666 PyErr_SetString(PyExc_RuntimeError,
21667 "Unexpected error in an Op's C code. "
21668 "No Python exception was set.");
21669 }
21670 goto __label_414;}
21671 }
21672
21673 V413 = (PyArrayObject*)(py_V413);
21674 Py_XINCREF(V413);
21675
21676 {
21677
21678 py_V415 = PyList_GET_ITEM(storage_V415, 0);
21679 {Py_XINCREF(py_V415);}
21680
21681 V415 = NULL;
21682 if (py_V415 == Py_None) {
21683 // We can either fail here or set V415 to NULL and rely on Ops
21684 // using tensors to handle the NULL case, but if they fail to do so
21685 // they'll end up with nasty segfaults, so this is public service.
21686 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
21687 {
21688 __failure = 416;
21689 if (!PyErr_Occurred()) {
21690 PyErr_SetString(PyExc_RuntimeError,
21691 "Unexpected error in an Op's C code. "
21692 "No Python exception was set.");
21693 }
21694 goto __label_416;}
21695 }
21696 if (!PyArray_Check(py_V415)) {
21697 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
21698 {
21699 __failure = 416;
21700 if (!PyErr_Occurred()) {
21701 PyErr_SetString(PyExc_RuntimeError,
21702 "Unexpected error in an Op's C code. "
21703 "No Python exception was set.");
21704 }
21705 goto __label_416;}
21706 }
21707 // We expect NPY_FLOAT64
21708 if (!PyArray_ISALIGNED((PyArrayObject*) py_V415)) {
21709 PyArrayObject * tmp = (PyArrayObject*) py_V415;
21710 PyErr_Format(PyExc_NotImplementedError,
21711 "expected an aligned array of type %ld "
21712 "(NPY_FLOAT64), got non-aligned array of type %ld"
21713 " with %ld dimensions, with 3 last dims "
21714 "%ld, %ld, %ld"
21715 " and 3 last strides %ld %ld, %ld.",
21716 (long int) NPY_FLOAT64,
21717 (long int) PyArray_TYPE((PyArrayObject*) py_V415),
21718 (long int) PyArray_NDIM(tmp),
21719 (long int) (PyArray_NDIM(tmp) >= 3 ?
21720 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
21721 (long int) (PyArray_NDIM(tmp) >= 2 ?
21722 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
21723 (long int) (PyArray_NDIM(tmp) >= 1 ?
21724 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
21725 (long int) (PyArray_NDIM(tmp) >= 3 ?
21726 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
21727 (long int) (PyArray_NDIM(tmp) >= 2 ?
21728 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
21729 (long int) (PyArray_NDIM(tmp) >= 1 ?
21730 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
21731 );
21732 {
21733 __failure = 416;
21734 if (!PyErr_Occurred()) {
21735 PyErr_SetString(PyExc_RuntimeError,
21736 "Unexpected error in an Op's C code. "
21737 "No Python exception was set.");
21738 }
21739 goto __label_416;}
21740 }
21741 // This is a TypeError to be consistent with DEBUG_MODE
21742 // Note: DEBUG_MODE also tells the name of the container
21743 if (PyArray_TYPE((PyArrayObject*) py_V415) != NPY_FLOAT64) {
21744 PyErr_Format(PyExc_TypeError,
21745 "expected type_num %d (NPY_FLOAT64) got %d",
21746 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V415));
21747 {
21748 __failure = 416;
21749 if (!PyErr_Occurred()) {
21750 PyErr_SetString(PyExc_RuntimeError,
21751 "Unexpected error in an Op's C code. "
21752 "No Python exception was set.");
21753 }
21754 goto __label_416;}
21755 }
21756
21757 V415 = (PyArrayObject*)(py_V415);
21758 Py_XINCREF(V415);
21759
21760 {
21761
21762 py_V417 = PyList_GET_ITEM(storage_V417, 0);
21763 {Py_XINCREF(py_V417);}
21764
21765 V417 = NULL;
21766 if (py_V417 == Py_None) {
21767 // We can either fail here or set V417 to NULL and rely on Ops
21768 // using tensors to handle the NULL case, but if they fail to do so
21769 // they'll end up with nasty segfaults, so this is public service.
21770 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
21771 {
21772 __failure = 418;
21773 if (!PyErr_Occurred()) {
21774 PyErr_SetString(PyExc_RuntimeError,
21775 "Unexpected error in an Op's C code. "
21776 "No Python exception was set.");
21777 }
21778 goto __label_418;}
21779 }
21780 if (!PyArray_Check(py_V417)) {
21781 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
21782 {
21783 __failure = 418;
21784 if (!PyErr_Occurred()) {
21785 PyErr_SetString(PyExc_RuntimeError,
21786 "Unexpected error in an Op's C code. "
21787 "No Python exception was set.");
21788 }
21789 goto __label_418;}
21790 }
21791 // We expect NPY_FLOAT64
21792 if (!PyArray_ISALIGNED((PyArrayObject*) py_V417)) {
21793 PyArrayObject * tmp = (PyArrayObject*) py_V417;
21794 PyErr_Format(PyExc_NotImplementedError,
21795 "expected an aligned array of type %ld "
21796 "(NPY_FLOAT64), got non-aligned array of type %ld"
21797 " with %ld dimensions, with 3 last dims "
21798 "%ld, %ld, %ld"
21799 " and 3 last strides %ld %ld, %ld.",
21800 (long int) NPY_FLOAT64,
21801 (long int) PyArray_TYPE((PyArrayObject*) py_V417),
21802 (long int) PyArray_NDIM(tmp),
21803 (long int) (PyArray_NDIM(tmp) >= 3 ?
21804 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
21805 (long int) (PyArray_NDIM(tmp) >= 2 ?
21806 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
21807 (long int) (PyArray_NDIM(tmp) >= 1 ?
21808 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
21809 (long int) (PyArray_NDIM(tmp) >= 3 ?
21810 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
21811 (long int) (PyArray_NDIM(tmp) >= 2 ?
21812 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
21813 (long int) (PyArray_NDIM(tmp) >= 1 ?
21814 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
21815 );
21816 {
21817 __failure = 418;
21818 if (!PyErr_Occurred()) {
21819 PyErr_SetString(PyExc_RuntimeError,
21820 "Unexpected error in an Op's C code. "
21821 "No Python exception was set.");
21822 }
21823 goto __label_418;}
21824 }
21825 // This is a TypeError to be consistent with DEBUG_MODE
21826 // Note: DEBUG_MODE also tells the name of the container
21827 if (PyArray_TYPE((PyArrayObject*) py_V417) != NPY_FLOAT64) {
21828 PyErr_Format(PyExc_TypeError,
21829 "expected type_num %d (NPY_FLOAT64) got %d",
21830 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V417));
21831 {
21832 __failure = 418;
21833 if (!PyErr_Occurred()) {
21834 PyErr_SetString(PyExc_RuntimeError,
21835 "Unexpected error in an Op's C code. "
21836 "No Python exception was set.");
21837 }
21838 goto __label_418;}
21839 }
21840
21841 V417 = (PyArrayObject*)(py_V417);
21842 Py_XINCREF(V417);
21843
21844 {
21845
21846 py_V419 = PyList_GET_ITEM(storage_V419, 0);
21847 {Py_XINCREF(py_V419);}
21848
21849 V419 = NULL;
21850 if (py_V419 == Py_None) {
21851 // We can either fail here or set V419 to NULL and rely on Ops
21852 // using tensors to handle the NULL case, but if they fail to do so
21853 // they'll end up with nasty segfaults, so this is public service.
21854 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
21855 {
21856 __failure = 420;
21857 if (!PyErr_Occurred()) {
21858 PyErr_SetString(PyExc_RuntimeError,
21859 "Unexpected error in an Op's C code. "
21860 "No Python exception was set.");
21861 }
21862 goto __label_420;}
21863 }
21864 if (!PyArray_Check(py_V419)) {
21865 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
21866 {
21867 __failure = 420;
21868 if (!PyErr_Occurred()) {
21869 PyErr_SetString(PyExc_RuntimeError,
21870 "Unexpected error in an Op's C code. "
21871 "No Python exception was set.");
21872 }
21873 goto __label_420;}
21874 }
21875 // We expect NPY_FLOAT64
21876 if (!PyArray_ISALIGNED((PyArrayObject*) py_V419)) {
21877 PyArrayObject * tmp = (PyArrayObject*) py_V419;
21878 PyErr_Format(PyExc_NotImplementedError,
21879 "expected an aligned array of type %ld "
21880 "(NPY_FLOAT64), got non-aligned array of type %ld"
21881 " with %ld dimensions, with 3 last dims "
21882 "%ld, %ld, %ld"
21883 " and 3 last strides %ld %ld, %ld.",
21884 (long int) NPY_FLOAT64,
21885 (long int) PyArray_TYPE((PyArrayObject*) py_V419),
21886 (long int) PyArray_NDIM(tmp),
21887 (long int) (PyArray_NDIM(tmp) >= 3 ?
21888 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
21889 (long int) (PyArray_NDIM(tmp) >= 2 ?
21890 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
21891 (long int) (PyArray_NDIM(tmp) >= 1 ?
21892 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
21893 (long int) (PyArray_NDIM(tmp) >= 3 ?
21894 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
21895 (long int) (PyArray_NDIM(tmp) >= 2 ?
21896 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
21897 (long int) (PyArray_NDIM(tmp) >= 1 ?
21898 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
21899 );
21900 {
21901 __failure = 420;
21902 if (!PyErr_Occurred()) {
21903 PyErr_SetString(PyExc_RuntimeError,
21904 "Unexpected error in an Op's C code. "
21905 "No Python exception was set.");
21906 }
21907 goto __label_420;}
21908 }
21909 // This is a TypeError to be consistent with DEBUG_MODE
21910 // Note: DEBUG_MODE also tells the name of the container
21911 if (PyArray_TYPE((PyArrayObject*) py_V419) != NPY_FLOAT64) {
21912 PyErr_Format(PyExc_TypeError,
21913 "expected type_num %d (NPY_FLOAT64) got %d",
21914 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V419));
21915 {
21916 __failure = 420;
21917 if (!PyErr_Occurred()) {
21918 PyErr_SetString(PyExc_RuntimeError,
21919 "Unexpected error in an Op's C code. "
21920 "No Python exception was set.");
21921 }
21922 goto __label_420;}
21923 }
21924
21925 V419 = (PyArrayObject*)(py_V419);
21926 Py_XINCREF(V419);
21927
21928 {
21929
21930 py_V421 = PyList_GET_ITEM(storage_V421, 0);
21931 {Py_XINCREF(py_V421);}
21932
21933 V421 = NULL;
21934 if (py_V421 == Py_None) {
21935 // We can either fail here or set V421 to NULL and rely on Ops
21936 // using tensors to handle the NULL case, but if they fail to do so
21937 // they'll end up with nasty segfaults, so this is public service.
21938 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
21939 {
21940 __failure = 422;
21941 if (!PyErr_Occurred()) {
21942 PyErr_SetString(PyExc_RuntimeError,
21943 "Unexpected error in an Op's C code. "
21944 "No Python exception was set.");
21945 }
21946 goto __label_422;}
21947 }
21948 if (!PyArray_Check(py_V421)) {
21949 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
21950 {
21951 __failure = 422;
21952 if (!PyErr_Occurred()) {
21953 PyErr_SetString(PyExc_RuntimeError,
21954 "Unexpected error in an Op's C code. "
21955 "No Python exception was set.");
21956 }
21957 goto __label_422;}
21958 }
21959 // We expect NPY_FLOAT64
21960 if (!PyArray_ISALIGNED((PyArrayObject*) py_V421)) {
21961 PyArrayObject * tmp = (PyArrayObject*) py_V421;
21962 PyErr_Format(PyExc_NotImplementedError,
21963 "expected an aligned array of type %ld "
21964 "(NPY_FLOAT64), got non-aligned array of type %ld"
21965 " with %ld dimensions, with 3 last dims "
21966 "%ld, %ld, %ld"
21967 " and 3 last strides %ld %ld, %ld.",
21968 (long int) NPY_FLOAT64,
21969 (long int) PyArray_TYPE((PyArrayObject*) py_V421),
21970 (long int) PyArray_NDIM(tmp),
21971 (long int) (PyArray_NDIM(tmp) >= 3 ?
21972 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
21973 (long int) (PyArray_NDIM(tmp) >= 2 ?
21974 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
21975 (long int) (PyArray_NDIM(tmp) >= 1 ?
21976 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
21977 (long int) (PyArray_NDIM(tmp) >= 3 ?
21978 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
21979 (long int) (PyArray_NDIM(tmp) >= 2 ?
21980 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
21981 (long int) (PyArray_NDIM(tmp) >= 1 ?
21982 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
21983 );
21984 {
21985 __failure = 422;
21986 if (!PyErr_Occurred()) {
21987 PyErr_SetString(PyExc_RuntimeError,
21988 "Unexpected error in an Op's C code. "
21989 "No Python exception was set.");
21990 }
21991 goto __label_422;}
21992 }
21993 // This is a TypeError to be consistent with DEBUG_MODE
21994 // Note: DEBUG_MODE also tells the name of the container
21995 if (PyArray_TYPE((PyArrayObject*) py_V421) != NPY_FLOAT64) {
21996 PyErr_Format(PyExc_TypeError,
21997 "expected type_num %d (NPY_FLOAT64) got %d",
21998 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V421));
21999 {
22000 __failure = 422;
22001 if (!PyErr_Occurred()) {
22002 PyErr_SetString(PyExc_RuntimeError,
22003 "Unexpected error in an Op's C code. "
22004 "No Python exception was set.");
22005 }
22006 goto __label_422;}
22007 }
22008
22009 V421 = (PyArrayObject*)(py_V421);
22010 Py_XINCREF(V421);
22011
22012 {
22013
22014 py_V423 = PyList_GET_ITEM(storage_V423, 0);
22015 {Py_XINCREF(py_V423);}
22016
22017 V423 = NULL;
22018 if (py_V423 == Py_None) {
22019 // We can either fail here or set V423 to NULL and rely on Ops
22020 // using tensors to handle the NULL case, but if they fail to do so
22021 // they'll end up with nasty segfaults, so this is public service.
22022 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
22023 {
22024 __failure = 424;
22025 if (!PyErr_Occurred()) {
22026 PyErr_SetString(PyExc_RuntimeError,
22027 "Unexpected error in an Op's C code. "
22028 "No Python exception was set.");
22029 }
22030 goto __label_424;}
22031 }
22032 if (!PyArray_Check(py_V423)) {
22033 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
22034 {
22035 __failure = 424;
22036 if (!PyErr_Occurred()) {
22037 PyErr_SetString(PyExc_RuntimeError,
22038 "Unexpected error in an Op's C code. "
22039 "No Python exception was set.");
22040 }
22041 goto __label_424;}
22042 }
22043 // We expect NPY_FLOAT64
22044 if (!PyArray_ISALIGNED((PyArrayObject*) py_V423)) {
22045 PyArrayObject * tmp = (PyArrayObject*) py_V423;
22046 PyErr_Format(PyExc_NotImplementedError,
22047 "expected an aligned array of type %ld "
22048 "(NPY_FLOAT64), got non-aligned array of type %ld"
22049 " with %ld dimensions, with 3 last dims "
22050 "%ld, %ld, %ld"
22051 " and 3 last strides %ld %ld, %ld.",
22052 (long int) NPY_FLOAT64,
22053 (long int) PyArray_TYPE((PyArrayObject*) py_V423),
22054 (long int) PyArray_NDIM(tmp),
22055 (long int) (PyArray_NDIM(tmp) >= 3 ?
22056 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
22057 (long int) (PyArray_NDIM(tmp) >= 2 ?
22058 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
22059 (long int) (PyArray_NDIM(tmp) >= 1 ?
22060 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
22061 (long int) (PyArray_NDIM(tmp) >= 3 ?
22062 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
22063 (long int) (PyArray_NDIM(tmp) >= 2 ?
22064 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
22065 (long int) (PyArray_NDIM(tmp) >= 1 ?
22066 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
22067 );
22068 {
22069 __failure = 424;
22070 if (!PyErr_Occurred()) {
22071 PyErr_SetString(PyExc_RuntimeError,
22072 "Unexpected error in an Op's C code. "
22073 "No Python exception was set.");
22074 }
22075 goto __label_424;}
22076 }
22077 // This is a TypeError to be consistent with DEBUG_MODE
22078 // Note: DEBUG_MODE also tells the name of the container
22079 if (PyArray_TYPE((PyArrayObject*) py_V423) != NPY_FLOAT64) {
22080 PyErr_Format(PyExc_TypeError,
22081 "expected type_num %d (NPY_FLOAT64) got %d",
22082 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V423));
22083 {
22084 __failure = 424;
22085 if (!PyErr_Occurred()) {
22086 PyErr_SetString(PyExc_RuntimeError,
22087 "Unexpected error in an Op's C code. "
22088 "No Python exception was set.");
22089 }
22090 goto __label_424;}
22091 }
22092
22093 V423 = (PyArrayObject*)(py_V423);
22094 Py_XINCREF(V423);
22095
22096 {
22097
22098 py_V425 = PyList_GET_ITEM(storage_V425, 0);
22099 {Py_XINCREF(py_V425);}
22100
22101 V425 = NULL;
22102 if (py_V425 == Py_None) {
22103 // We can either fail here or set V425 to NULL and rely on Ops
22104 // using tensors to handle the NULL case, but if they fail to do so
22105 // they'll end up with nasty segfaults, so this is public service.
22106 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
22107 {
22108 __failure = 426;
22109 if (!PyErr_Occurred()) {
22110 PyErr_SetString(PyExc_RuntimeError,
22111 "Unexpected error in an Op's C code. "
22112 "No Python exception was set.");
22113 }
22114 goto __label_426;}
22115 }
22116 if (!PyArray_Check(py_V425)) {
22117 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
22118 {
22119 __failure = 426;
22120 if (!PyErr_Occurred()) {
22121 PyErr_SetString(PyExc_RuntimeError,
22122 "Unexpected error in an Op's C code. "
22123 "No Python exception was set.");
22124 }
22125 goto __label_426;}
22126 }
22127 // We expect NPY_FLOAT64
22128 if (!PyArray_ISALIGNED((PyArrayObject*) py_V425)) {
22129 PyArrayObject * tmp = (PyArrayObject*) py_V425;
22130 PyErr_Format(PyExc_NotImplementedError,
22131 "expected an aligned array of type %ld "
22132 "(NPY_FLOAT64), got non-aligned array of type %ld"
22133 " with %ld dimensions, with 3 last dims "
22134 "%ld, %ld, %ld"
22135 " and 3 last strides %ld %ld, %ld.",
22136 (long int) NPY_FLOAT64,
22137 (long int) PyArray_TYPE((PyArrayObject*) py_V425),
22138 (long int) PyArray_NDIM(tmp),
22139 (long int) (PyArray_NDIM(tmp) >= 3 ?
22140 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
22141 (long int) (PyArray_NDIM(tmp) >= 2 ?
22142 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
22143 (long int) (PyArray_NDIM(tmp) >= 1 ?
22144 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
22145 (long int) (PyArray_NDIM(tmp) >= 3 ?
22146 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
22147 (long int) (PyArray_NDIM(tmp) >= 2 ?
22148 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
22149 (long int) (PyArray_NDIM(tmp) >= 1 ?
22150 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
22151 );
22152 {
22153 __failure = 426;
22154 if (!PyErr_Occurred()) {
22155 PyErr_SetString(PyExc_RuntimeError,
22156 "Unexpected error in an Op's C code. "
22157 "No Python exception was set.");
22158 }
22159 goto __label_426;}
22160 }
22161 // This is a TypeError to be consistent with DEBUG_MODE
22162 // Note: DEBUG_MODE also tells the name of the container
22163 if (PyArray_TYPE((PyArrayObject*) py_V425) != NPY_FLOAT64) {
22164 PyErr_Format(PyExc_TypeError,
22165 "expected type_num %d (NPY_FLOAT64) got %d",
22166 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V425));
22167 {
22168 __failure = 426;
22169 if (!PyErr_Occurred()) {
22170 PyErr_SetString(PyExc_RuntimeError,
22171 "Unexpected error in an Op's C code. "
22172 "No Python exception was set.");
22173 }
22174 goto __label_426;}
22175 }
22176
22177 V425 = (PyArrayObject*)(py_V425);
22178 Py_XINCREF(V425);
22179
22180 {
22181
22182 py_V427 = PyList_GET_ITEM(storage_V427, 0);
22183 {Py_XINCREF(py_V427);}
22184
22185 V427 = NULL;
22186 if (py_V427 == Py_None) {
22187 // We can either fail here or set V427 to NULL and rely on Ops
22188 // using tensors to handle the NULL case, but if they fail to do so
22189 // they'll end up with nasty segfaults, so this is public service.
22190 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
22191 {
22192 __failure = 428;
22193 if (!PyErr_Occurred()) {
22194 PyErr_SetString(PyExc_RuntimeError,
22195 "Unexpected error in an Op's C code. "
22196 "No Python exception was set.");
22197 }
22198 goto __label_428;}
22199 }
22200 if (!PyArray_Check(py_V427)) {
22201 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
22202 {
22203 __failure = 428;
22204 if (!PyErr_Occurred()) {
22205 PyErr_SetString(PyExc_RuntimeError,
22206 "Unexpected error in an Op's C code. "
22207 "No Python exception was set.");
22208 }
22209 goto __label_428;}
22210 }
22211 // We expect NPY_FLOAT64
22212 if (!PyArray_ISALIGNED((PyArrayObject*) py_V427)) {
22213 PyArrayObject * tmp = (PyArrayObject*) py_V427;
22214 PyErr_Format(PyExc_NotImplementedError,
22215 "expected an aligned array of type %ld "
22216 "(NPY_FLOAT64), got non-aligned array of type %ld"
22217 " with %ld dimensions, with 3 last dims "
22218 "%ld, %ld, %ld"
22219 " and 3 last strides %ld %ld, %ld.",
22220 (long int) NPY_FLOAT64,
22221 (long int) PyArray_TYPE((PyArrayObject*) py_V427),
22222 (long int) PyArray_NDIM(tmp),
22223 (long int) (PyArray_NDIM(tmp) >= 3 ?
22224 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
22225 (long int) (PyArray_NDIM(tmp) >= 2 ?
22226 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
22227 (long int) (PyArray_NDIM(tmp) >= 1 ?
22228 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
22229 (long int) (PyArray_NDIM(tmp) >= 3 ?
22230 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
22231 (long int) (PyArray_NDIM(tmp) >= 2 ?
22232 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
22233 (long int) (PyArray_NDIM(tmp) >= 1 ?
22234 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
22235 );
22236 {
22237 __failure = 428;
22238 if (!PyErr_Occurred()) {
22239 PyErr_SetString(PyExc_RuntimeError,
22240 "Unexpected error in an Op's C code. "
22241 "No Python exception was set.");
22242 }
22243 goto __label_428;}
22244 }
22245 // This is a TypeError to be consistent with DEBUG_MODE
22246 // Note: DEBUG_MODE also tells the name of the container
22247 if (PyArray_TYPE((PyArrayObject*) py_V427) != NPY_FLOAT64) {
22248 PyErr_Format(PyExc_TypeError,
22249 "expected type_num %d (NPY_FLOAT64) got %d",
22250 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V427));
22251 {
22252 __failure = 428;
22253 if (!PyErr_Occurred()) {
22254 PyErr_SetString(PyExc_RuntimeError,
22255 "Unexpected error in an Op's C code. "
22256 "No Python exception was set.");
22257 }
22258 goto __label_428;}
22259 }
22260
22261 V427 = (PyArrayObject*)(py_V427);
22262 Py_XINCREF(V427);
22263
22264 {
22265
22266 py_V429 = PyList_GET_ITEM(storage_V429, 0);
22267 {Py_XINCREF(py_V429);}
22268
22269 V429 = NULL;
22270 if (py_V429 == Py_None) {
22271 // We can either fail here or set V429 to NULL and rely on Ops
22272 // using tensors to handle the NULL case, but if they fail to do so
22273 // they'll end up with nasty segfaults, so this is public service.
22274 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
22275 {
22276 __failure = 430;
22277 if (!PyErr_Occurred()) {
22278 PyErr_SetString(PyExc_RuntimeError,
22279 "Unexpected error in an Op's C code. "
22280 "No Python exception was set.");
22281 }
22282 goto __label_430;}
22283 }
22284 if (!PyArray_Check(py_V429)) {
22285 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
22286 {
22287 __failure = 430;
22288 if (!PyErr_Occurred()) {
22289 PyErr_SetString(PyExc_RuntimeError,
22290 "Unexpected error in an Op's C code. "
22291 "No Python exception was set.");
22292 }
22293 goto __label_430;}
22294 }
22295 // We expect NPY_FLOAT64
22296 if (!PyArray_ISALIGNED((PyArrayObject*) py_V429)) {
22297 PyArrayObject * tmp = (PyArrayObject*) py_V429;
22298 PyErr_Format(PyExc_NotImplementedError,
22299 "expected an aligned array of type %ld "
22300 "(NPY_FLOAT64), got non-aligned array of type %ld"
22301 " with %ld dimensions, with 3 last dims "
22302 "%ld, %ld, %ld"
22303 " and 3 last strides %ld %ld, %ld.",
22304 (long int) NPY_FLOAT64,
22305 (long int) PyArray_TYPE((PyArrayObject*) py_V429),
22306 (long int) PyArray_NDIM(tmp),
22307 (long int) (PyArray_NDIM(tmp) >= 3 ?
22308 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
22309 (long int) (PyArray_NDIM(tmp) >= 2 ?
22310 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
22311 (long int) (PyArray_NDIM(tmp) >= 1 ?
22312 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
22313 (long int) (PyArray_NDIM(tmp) >= 3 ?
22314 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
22315 (long int) (PyArray_NDIM(tmp) >= 2 ?
22316 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
22317 (long int) (PyArray_NDIM(tmp) >= 1 ?
22318 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
22319 );
22320 {
22321 __failure = 430;
22322 if (!PyErr_Occurred()) {
22323 PyErr_SetString(PyExc_RuntimeError,
22324 "Unexpected error in an Op's C code. "
22325 "No Python exception was set.");
22326 }
22327 goto __label_430;}
22328 }
22329 // This is a TypeError to be consistent with DEBUG_MODE
22330 // Note: DEBUG_MODE also tells the name of the container
22331 if (PyArray_TYPE((PyArrayObject*) py_V429) != NPY_FLOAT64) {
22332 PyErr_Format(PyExc_TypeError,
22333 "expected type_num %d (NPY_FLOAT64) got %d",
22334 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V429));
22335 {
22336 __failure = 430;
22337 if (!PyErr_Occurred()) {
22338 PyErr_SetString(PyExc_RuntimeError,
22339 "Unexpected error in an Op's C code. "
22340 "No Python exception was set.");
22341 }
22342 goto __label_430;}
22343 }
22344
22345 V429 = (PyArrayObject*)(py_V429);
22346 Py_XINCREF(V429);
22347
22348 {
22349
22350 py_V431 = PyList_GET_ITEM(storage_V431, 0);
22351 {Py_XINCREF(py_V431);}
22352
22353 V431 = NULL;
22354 if (py_V431 == Py_None) {
22355 // We can either fail here or set V431 to NULL and rely on Ops
22356 // using tensors to handle the NULL case, but if they fail to do so
22357 // they'll end up with nasty segfaults, so this is public service.
22358 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
22359 {
22360 __failure = 432;
22361 if (!PyErr_Occurred()) {
22362 PyErr_SetString(PyExc_RuntimeError,
22363 "Unexpected error in an Op's C code. "
22364 "No Python exception was set.");
22365 }
22366 goto __label_432;}
22367 }
22368 if (!PyArray_Check(py_V431)) {
22369 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
22370 {
22371 __failure = 432;
22372 if (!PyErr_Occurred()) {
22373 PyErr_SetString(PyExc_RuntimeError,
22374 "Unexpected error in an Op's C code. "
22375 "No Python exception was set.");
22376 }
22377 goto __label_432;}
22378 }
22379 // We expect NPY_FLOAT64
22380 if (!PyArray_ISALIGNED((PyArrayObject*) py_V431)) {
22381 PyArrayObject * tmp = (PyArrayObject*) py_V431;
22382 PyErr_Format(PyExc_NotImplementedError,
22383 "expected an aligned array of type %ld "
22384 "(NPY_FLOAT64), got non-aligned array of type %ld"
22385 " with %ld dimensions, with 3 last dims "
22386 "%ld, %ld, %ld"
22387 " and 3 last strides %ld %ld, %ld.",
22388 (long int) NPY_FLOAT64,
22389 (long int) PyArray_TYPE((PyArrayObject*) py_V431),
22390 (long int) PyArray_NDIM(tmp),
22391 (long int) (PyArray_NDIM(tmp) >= 3 ?
22392 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
22393 (long int) (PyArray_NDIM(tmp) >= 2 ?
22394 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
22395 (long int) (PyArray_NDIM(tmp) >= 1 ?
22396 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
22397 (long int) (PyArray_NDIM(tmp) >= 3 ?
22398 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
22399 (long int) (PyArray_NDIM(tmp) >= 2 ?
22400 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
22401 (long int) (PyArray_NDIM(tmp) >= 1 ?
22402 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
22403 );
22404 {
22405 __failure = 432;
22406 if (!PyErr_Occurred()) {
22407 PyErr_SetString(PyExc_RuntimeError,
22408 "Unexpected error in an Op's C code. "
22409 "No Python exception was set.");
22410 }
22411 goto __label_432;}
22412 }
22413 // This is a TypeError to be consistent with DEBUG_MODE
22414 // Note: DEBUG_MODE also tells the name of the container
22415 if (PyArray_TYPE((PyArrayObject*) py_V431) != NPY_FLOAT64) {
22416 PyErr_Format(PyExc_TypeError,
22417 "expected type_num %d (NPY_FLOAT64) got %d",
22418 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V431));
22419 {
22420 __failure = 432;
22421 if (!PyErr_Occurred()) {
22422 PyErr_SetString(PyExc_RuntimeError,
22423 "Unexpected error in an Op's C code. "
22424 "No Python exception was set.");
22425 }
22426 goto __label_432;}
22427 }
22428
22429 V431 = (PyArrayObject*)(py_V431);
22430 Py_XINCREF(V431);
22431
22432 {
22433
22434 py_V433 = PyList_GET_ITEM(storage_V433, 0);
22435 {Py_XINCREF(py_V433);}
22436
22437 V433 = NULL;
22438 if (py_V433 == Py_None) {
22439 // We can either fail here or set V433 to NULL and rely on Ops
22440 // using tensors to handle the NULL case, but if they fail to do so
22441 // they'll end up with nasty segfaults, so this is public service.
22442 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
22443 {
22444 __failure = 434;
22445 if (!PyErr_Occurred()) {
22446 PyErr_SetString(PyExc_RuntimeError,
22447 "Unexpected error in an Op's C code. "
22448 "No Python exception was set.");
22449 }
22450 goto __label_434;}
22451 }
22452 if (!PyArray_Check(py_V433)) {
22453 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
22454 {
22455 __failure = 434;
22456 if (!PyErr_Occurred()) {
22457 PyErr_SetString(PyExc_RuntimeError,
22458 "Unexpected error in an Op's C code. "
22459 "No Python exception was set.");
22460 }
22461 goto __label_434;}
22462 }
22463 // We expect NPY_FLOAT64
22464 if (!PyArray_ISALIGNED((PyArrayObject*) py_V433)) {
22465 PyArrayObject * tmp = (PyArrayObject*) py_V433;
22466 PyErr_Format(PyExc_NotImplementedError,
22467 "expected an aligned array of type %ld "
22468 "(NPY_FLOAT64), got non-aligned array of type %ld"
22469 " with %ld dimensions, with 3 last dims "
22470 "%ld, %ld, %ld"
22471 " and 3 last strides %ld %ld, %ld.",
22472 (long int) NPY_FLOAT64,
22473 (long int) PyArray_TYPE((PyArrayObject*) py_V433),
22474 (long int) PyArray_NDIM(tmp),
22475 (long int) (PyArray_NDIM(tmp) >= 3 ?
22476 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
22477 (long int) (PyArray_NDIM(tmp) >= 2 ?
22478 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
22479 (long int) (PyArray_NDIM(tmp) >= 1 ?
22480 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
22481 (long int) (PyArray_NDIM(tmp) >= 3 ?
22482 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
22483 (long int) (PyArray_NDIM(tmp) >= 2 ?
22484 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
22485 (long int) (PyArray_NDIM(tmp) >= 1 ?
22486 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
22487 );
22488 {
22489 __failure = 434;
22490 if (!PyErr_Occurred()) {
22491 PyErr_SetString(PyExc_RuntimeError,
22492 "Unexpected error in an Op's C code. "
22493 "No Python exception was set.");
22494 }
22495 goto __label_434;}
22496 }
22497 // This is a TypeError to be consistent with DEBUG_MODE
22498 // Note: DEBUG_MODE also tells the name of the container
22499 if (PyArray_TYPE((PyArrayObject*) py_V433) != NPY_FLOAT64) {
22500 PyErr_Format(PyExc_TypeError,
22501 "expected type_num %d (NPY_FLOAT64) got %d",
22502 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V433));
22503 {
22504 __failure = 434;
22505 if (!PyErr_Occurred()) {
22506 PyErr_SetString(PyExc_RuntimeError,
22507 "Unexpected error in an Op's C code. "
22508 "No Python exception was set.");
22509 }
22510 goto __label_434;}
22511 }
22512
22513 V433 = (PyArrayObject*)(py_V433);
22514 Py_XINCREF(V433);
22515
22516 {
22517
22518 py_V435 = PyList_GET_ITEM(storage_V435, 0);
22519 {Py_XINCREF(py_V435);}
22520
22521 V435 = NULL;
22522 if (py_V435 == Py_None) {
22523 // We can either fail here or set V435 to NULL and rely on Ops
22524 // using tensors to handle the NULL case, but if they fail to do so
22525 // they'll end up with nasty segfaults, so this is public service.
22526 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
22527 {
22528 __failure = 436;
22529 if (!PyErr_Occurred()) {
22530 PyErr_SetString(PyExc_RuntimeError,
22531 "Unexpected error in an Op's C code. "
22532 "No Python exception was set.");
22533 }
22534 goto __label_436;}
22535 }
22536 if (!PyArray_Check(py_V435)) {
22537 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
22538 {
22539 __failure = 436;
22540 if (!PyErr_Occurred()) {
22541 PyErr_SetString(PyExc_RuntimeError,
22542 "Unexpected error in an Op's C code. "
22543 "No Python exception was set.");
22544 }
22545 goto __label_436;}
22546 }
22547 // We expect NPY_FLOAT64
22548 if (!PyArray_ISALIGNED((PyArrayObject*) py_V435)) {
22549 PyArrayObject * tmp = (PyArrayObject*) py_V435;
22550 PyErr_Format(PyExc_NotImplementedError,
22551 "expected an aligned array of type %ld "
22552 "(NPY_FLOAT64), got non-aligned array of type %ld"
22553 " with %ld dimensions, with 3 last dims "
22554 "%ld, %ld, %ld"
22555 " and 3 last strides %ld %ld, %ld.",
22556 (long int) NPY_FLOAT64,
22557 (long int) PyArray_TYPE((PyArrayObject*) py_V435),
22558 (long int) PyArray_NDIM(tmp),
22559 (long int) (PyArray_NDIM(tmp) >= 3 ?
22560 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
22561 (long int) (PyArray_NDIM(tmp) >= 2 ?
22562 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
22563 (long int) (PyArray_NDIM(tmp) >= 1 ?
22564 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
22565 (long int) (PyArray_NDIM(tmp) >= 3 ?
22566 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
22567 (long int) (PyArray_NDIM(tmp) >= 2 ?
22568 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
22569 (long int) (PyArray_NDIM(tmp) >= 1 ?
22570 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
22571 );
22572 {
22573 __failure = 436;
22574 if (!PyErr_Occurred()) {
22575 PyErr_SetString(PyExc_RuntimeError,
22576 "Unexpected error in an Op's C code. "
22577 "No Python exception was set.");
22578 }
22579 goto __label_436;}
22580 }
22581 // This is a TypeError to be consistent with DEBUG_MODE
22582 // Note: DEBUG_MODE also tells the name of the container
22583 if (PyArray_TYPE((PyArrayObject*) py_V435) != NPY_FLOAT64) {
22584 PyErr_Format(PyExc_TypeError,
22585 "expected type_num %d (NPY_FLOAT64) got %d",
22586 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V435));
22587 {
22588 __failure = 436;
22589 if (!PyErr_Occurred()) {
22590 PyErr_SetString(PyExc_RuntimeError,
22591 "Unexpected error in an Op's C code. "
22592 "No Python exception was set.");
22593 }
22594 goto __label_436;}
22595 }
22596
22597 V435 = (PyArrayObject*)(py_V435);
22598 Py_XINCREF(V435);
22599
22600 {
22601
22602 py_V437 = PyList_GET_ITEM(storage_V437, 0);
22603 {Py_XINCREF(py_V437);}
22604
22605 V437 = NULL;
22606 if (py_V437 == Py_None) {
22607 // We can either fail here or set V437 to NULL and rely on Ops
22608 // using tensors to handle the NULL case, but if they fail to do so
22609 // they'll end up with nasty segfaults, so this is public service.
22610 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
22611 {
22612 __failure = 438;
22613 if (!PyErr_Occurred()) {
22614 PyErr_SetString(PyExc_RuntimeError,
22615 "Unexpected error in an Op's C code. "
22616 "No Python exception was set.");
22617 }
22618 goto __label_438;}
22619 }
22620 if (!PyArray_Check(py_V437)) {
22621 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
22622 {
22623 __failure = 438;
22624 if (!PyErr_Occurred()) {
22625 PyErr_SetString(PyExc_RuntimeError,
22626 "Unexpected error in an Op's C code. "
22627 "No Python exception was set.");
22628 }
22629 goto __label_438;}
22630 }
22631 // We expect NPY_FLOAT64
22632 if (!PyArray_ISALIGNED((PyArrayObject*) py_V437)) {
22633 PyArrayObject * tmp = (PyArrayObject*) py_V437;
22634 PyErr_Format(PyExc_NotImplementedError,
22635 "expected an aligned array of type %ld "
22636 "(NPY_FLOAT64), got non-aligned array of type %ld"
22637 " with %ld dimensions, with 3 last dims "
22638 "%ld, %ld, %ld"
22639 " and 3 last strides %ld %ld, %ld.",
22640 (long int) NPY_FLOAT64,
22641 (long int) PyArray_TYPE((PyArrayObject*) py_V437),
22642 (long int) PyArray_NDIM(tmp),
22643 (long int) (PyArray_NDIM(tmp) >= 3 ?
22644 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
22645 (long int) (PyArray_NDIM(tmp) >= 2 ?
22646 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
22647 (long int) (PyArray_NDIM(tmp) >= 1 ?
22648 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
22649 (long int) (PyArray_NDIM(tmp) >= 3 ?
22650 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
22651 (long int) (PyArray_NDIM(tmp) >= 2 ?
22652 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
22653 (long int) (PyArray_NDIM(tmp) >= 1 ?
22654 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
22655 );
22656 {
22657 __failure = 438;
22658 if (!PyErr_Occurred()) {
22659 PyErr_SetString(PyExc_RuntimeError,
22660 "Unexpected error in an Op's C code. "
22661 "No Python exception was set.");
22662 }
22663 goto __label_438;}
22664 }
22665 // This is a TypeError to be consistent with DEBUG_MODE
22666 // Note: DEBUG_MODE also tells the name of the container
22667 if (PyArray_TYPE((PyArrayObject*) py_V437) != NPY_FLOAT64) {
22668 PyErr_Format(PyExc_TypeError,
22669 "expected type_num %d (NPY_FLOAT64) got %d",
22670 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V437));
22671 {
22672 __failure = 438;
22673 if (!PyErr_Occurred()) {
22674 PyErr_SetString(PyExc_RuntimeError,
22675 "Unexpected error in an Op's C code. "
22676 "No Python exception was set.");
22677 }
22678 goto __label_438;}
22679 }
22680
22681 V437 = (PyArrayObject*)(py_V437);
22682 Py_XINCREF(V437);
22683
22684 {
22685
22686 py_V439 = PyList_GET_ITEM(storage_V439, 0);
22687 {Py_XINCREF(py_V439);}
22688
22689 V439 = NULL;
22690 if (py_V439 == Py_None) {
22691 // We can either fail here or set V439 to NULL and rely on Ops
22692 // using tensors to handle the NULL case, but if they fail to do so
22693 // they'll end up with nasty segfaults, so this is public service.
22694 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
22695 {
22696 __failure = 440;
22697 if (!PyErr_Occurred()) {
22698 PyErr_SetString(PyExc_RuntimeError,
22699 "Unexpected error in an Op's C code. "
22700 "No Python exception was set.");
22701 }
22702 goto __label_440;}
22703 }
22704 if (!PyArray_Check(py_V439)) {
22705 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
22706 {
22707 __failure = 440;
22708 if (!PyErr_Occurred()) {
22709 PyErr_SetString(PyExc_RuntimeError,
22710 "Unexpected error in an Op's C code. "
22711 "No Python exception was set.");
22712 }
22713 goto __label_440;}
22714 }
22715 // We expect NPY_FLOAT64
22716 if (!PyArray_ISALIGNED((PyArrayObject*) py_V439)) {
22717 PyArrayObject * tmp = (PyArrayObject*) py_V439;
22718 PyErr_Format(PyExc_NotImplementedError,
22719 "expected an aligned array of type %ld "
22720 "(NPY_FLOAT64), got non-aligned array of type %ld"
22721 " with %ld dimensions, with 3 last dims "
22722 "%ld, %ld, %ld"
22723 " and 3 last strides %ld %ld, %ld.",
22724 (long int) NPY_FLOAT64,
22725 (long int) PyArray_TYPE((PyArrayObject*) py_V439),
22726 (long int) PyArray_NDIM(tmp),
22727 (long int) (PyArray_NDIM(tmp) >= 3 ?
22728 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
22729 (long int) (PyArray_NDIM(tmp) >= 2 ?
22730 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
22731 (long int) (PyArray_NDIM(tmp) >= 1 ?
22732 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
22733 (long int) (PyArray_NDIM(tmp) >= 3 ?
22734 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
22735 (long int) (PyArray_NDIM(tmp) >= 2 ?
22736 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
22737 (long int) (PyArray_NDIM(tmp) >= 1 ?
22738 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
22739 );
22740 {
22741 __failure = 440;
22742 if (!PyErr_Occurred()) {
22743 PyErr_SetString(PyExc_RuntimeError,
22744 "Unexpected error in an Op's C code. "
22745 "No Python exception was set.");
22746 }
22747 goto __label_440;}
22748 }
22749 // This is a TypeError to be consistent with DEBUG_MODE
22750 // Note: DEBUG_MODE also tells the name of the container
22751 if (PyArray_TYPE((PyArrayObject*) py_V439) != NPY_FLOAT64) {
22752 PyErr_Format(PyExc_TypeError,
22753 "expected type_num %d (NPY_FLOAT64) got %d",
22754 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V439));
22755 {
22756 __failure = 440;
22757 if (!PyErr_Occurred()) {
22758 PyErr_SetString(PyExc_RuntimeError,
22759 "Unexpected error in an Op's C code. "
22760 "No Python exception was set.");
22761 }
22762 goto __label_440;}
22763 }
22764
22765 V439 = (PyArrayObject*)(py_V439);
22766 Py_XINCREF(V439);
22767
22768 {
22769
22770 py_V441 = PyList_GET_ITEM(storage_V441, 0);
22771 {Py_XINCREF(py_V441);}
22772
22773 V441 = NULL;
22774 if (py_V441 == Py_None) {
22775 // We can either fail here or set V441 to NULL and rely on Ops
22776 // using tensors to handle the NULL case, but if they fail to do so
22777 // they'll end up with nasty segfaults, so this is public service.
22778 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
22779 {
22780 __failure = 442;
22781 if (!PyErr_Occurred()) {
22782 PyErr_SetString(PyExc_RuntimeError,
22783 "Unexpected error in an Op's C code. "
22784 "No Python exception was set.");
22785 }
22786 goto __label_442;}
22787 }
22788 if (!PyArray_Check(py_V441)) {
22789 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
22790 {
22791 __failure = 442;
22792 if (!PyErr_Occurred()) {
22793 PyErr_SetString(PyExc_RuntimeError,
22794 "Unexpected error in an Op's C code. "
22795 "No Python exception was set.");
22796 }
22797 goto __label_442;}
22798 }
22799 // We expect NPY_FLOAT64
22800 if (!PyArray_ISALIGNED((PyArrayObject*) py_V441)) {
22801 PyArrayObject * tmp = (PyArrayObject*) py_V441;
22802 PyErr_Format(PyExc_NotImplementedError,
22803 "expected an aligned array of type %ld "
22804 "(NPY_FLOAT64), got non-aligned array of type %ld"
22805 " with %ld dimensions, with 3 last dims "
22806 "%ld, %ld, %ld"
22807 " and 3 last strides %ld %ld, %ld.",
22808 (long int) NPY_FLOAT64,
22809 (long int) PyArray_TYPE((PyArrayObject*) py_V441),
22810 (long int) PyArray_NDIM(tmp),
22811 (long int) (PyArray_NDIM(tmp) >= 3 ?
22812 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
22813 (long int) (PyArray_NDIM(tmp) >= 2 ?
22814 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
22815 (long int) (PyArray_NDIM(tmp) >= 1 ?
22816 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
22817 (long int) (PyArray_NDIM(tmp) >= 3 ?
22818 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
22819 (long int) (PyArray_NDIM(tmp) >= 2 ?
22820 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
22821 (long int) (PyArray_NDIM(tmp) >= 1 ?
22822 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
22823 );
22824 {
22825 __failure = 442;
22826 if (!PyErr_Occurred()) {
22827 PyErr_SetString(PyExc_RuntimeError,
22828 "Unexpected error in an Op's C code. "
22829 "No Python exception was set.");
22830 }
22831 goto __label_442;}
22832 }
22833 // This is a TypeError to be consistent with DEBUG_MODE
22834 // Note: DEBUG_MODE also tells the name of the container
22835 if (PyArray_TYPE((PyArrayObject*) py_V441) != NPY_FLOAT64) {
22836 PyErr_Format(PyExc_TypeError,
22837 "expected type_num %d (NPY_FLOAT64) got %d",
22838 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V441));
22839 {
22840 __failure = 442;
22841 if (!PyErr_Occurred()) {
22842 PyErr_SetString(PyExc_RuntimeError,
22843 "Unexpected error in an Op's C code. "
22844 "No Python exception was set.");
22845 }
22846 goto __label_442;}
22847 }
22848
22849 V441 = (PyArrayObject*)(py_V441);
22850 Py_XINCREF(V441);
22851
22852 {
22853
22854 py_V443 = PyList_GET_ITEM(storage_V443, 0);
22855 {Py_XINCREF(py_V443);}
22856
22857 V443 = NULL;
22858 if (py_V443 == Py_None) {
22859 // We can either fail here or set V443 to NULL and rely on Ops
22860 // using tensors to handle the NULL case, but if they fail to do so
22861 // they'll end up with nasty segfaults, so this is public service.
22862 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
22863 {
22864 __failure = 444;
22865 if (!PyErr_Occurred()) {
22866 PyErr_SetString(PyExc_RuntimeError,
22867 "Unexpected error in an Op's C code. "
22868 "No Python exception was set.");
22869 }
22870 goto __label_444;}
22871 }
22872 if (!PyArray_Check(py_V443)) {
22873 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
22874 {
22875 __failure = 444;
22876 if (!PyErr_Occurred()) {
22877 PyErr_SetString(PyExc_RuntimeError,
22878 "Unexpected error in an Op's C code. "
22879 "No Python exception was set.");
22880 }
22881 goto __label_444;}
22882 }
22883 // We expect NPY_FLOAT64
22884 if (!PyArray_ISALIGNED((PyArrayObject*) py_V443)) {
22885 PyArrayObject * tmp = (PyArrayObject*) py_V443;
22886 PyErr_Format(PyExc_NotImplementedError,
22887 "expected an aligned array of type %ld "
22888 "(NPY_FLOAT64), got non-aligned array of type %ld"
22889 " with %ld dimensions, with 3 last dims "
22890 "%ld, %ld, %ld"
22891 " and 3 last strides %ld %ld, %ld.",
22892 (long int) NPY_FLOAT64,
22893 (long int) PyArray_TYPE((PyArrayObject*) py_V443),
22894 (long int) PyArray_NDIM(tmp),
22895 (long int) (PyArray_NDIM(tmp) >= 3 ?
22896 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
22897 (long int) (PyArray_NDIM(tmp) >= 2 ?
22898 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
22899 (long int) (PyArray_NDIM(tmp) >= 1 ?
22900 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
22901 (long int) (PyArray_NDIM(tmp) >= 3 ?
22902 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
22903 (long int) (PyArray_NDIM(tmp) >= 2 ?
22904 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
22905 (long int) (PyArray_NDIM(tmp) >= 1 ?
22906 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
22907 );
22908 {
22909 __failure = 444;
22910 if (!PyErr_Occurred()) {
22911 PyErr_SetString(PyExc_RuntimeError,
22912 "Unexpected error in an Op's C code. "
22913 "No Python exception was set.");
22914 }
22915 goto __label_444;}
22916 }
22917 // This is a TypeError to be consistent with DEBUG_MODE
22918 // Note: DEBUG_MODE also tells the name of the container
22919 if (PyArray_TYPE((PyArrayObject*) py_V443) != NPY_FLOAT64) {
22920 PyErr_Format(PyExc_TypeError,
22921 "expected type_num %d (NPY_FLOAT64) got %d",
22922 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V443));
22923 {
22924 __failure = 444;
22925 if (!PyErr_Occurred()) {
22926 PyErr_SetString(PyExc_RuntimeError,
22927 "Unexpected error in an Op's C code. "
22928 "No Python exception was set.");
22929 }
22930 goto __label_444;}
22931 }
22932
22933 V443 = (PyArrayObject*)(py_V443);
22934 Py_XINCREF(V443);
22935
22936 {
22937
22938 py_V445 = PyList_GET_ITEM(storage_V445, 0);
22939 {Py_XINCREF(py_V445);}
22940
22941 V445 = NULL;
22942 if (py_V445 == Py_None) {
22943 // We can either fail here or set V445 to NULL and rely on Ops
22944 // using tensors to handle the NULL case, but if they fail to do so
22945 // they'll end up with nasty segfaults, so this is public service.
22946 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
22947 {
22948 __failure = 446;
22949 if (!PyErr_Occurred()) {
22950 PyErr_SetString(PyExc_RuntimeError,
22951 "Unexpected error in an Op's C code. "
22952 "No Python exception was set.");
22953 }
22954 goto __label_446;}
22955 }
22956 if (!PyArray_Check(py_V445)) {
22957 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
22958 {
22959 __failure = 446;
22960 if (!PyErr_Occurred()) {
22961 PyErr_SetString(PyExc_RuntimeError,
22962 "Unexpected error in an Op's C code. "
22963 "No Python exception was set.");
22964 }
22965 goto __label_446;}
22966 }
22967 // We expect NPY_FLOAT64
22968 if (!PyArray_ISALIGNED((PyArrayObject*) py_V445)) {
22969 PyArrayObject * tmp = (PyArrayObject*) py_V445;
22970 PyErr_Format(PyExc_NotImplementedError,
22971 "expected an aligned array of type %ld "
22972 "(NPY_FLOAT64), got non-aligned array of type %ld"
22973 " with %ld dimensions, with 3 last dims "
22974 "%ld, %ld, %ld"
22975 " and 3 last strides %ld %ld, %ld.",
22976 (long int) NPY_FLOAT64,
22977 (long int) PyArray_TYPE((PyArrayObject*) py_V445),
22978 (long int) PyArray_NDIM(tmp),
22979 (long int) (PyArray_NDIM(tmp) >= 3 ?
22980 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
22981 (long int) (PyArray_NDIM(tmp) >= 2 ?
22982 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
22983 (long int) (PyArray_NDIM(tmp) >= 1 ?
22984 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
22985 (long int) (PyArray_NDIM(tmp) >= 3 ?
22986 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
22987 (long int) (PyArray_NDIM(tmp) >= 2 ?
22988 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
22989 (long int) (PyArray_NDIM(tmp) >= 1 ?
22990 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
22991 );
22992 {
22993 __failure = 446;
22994 if (!PyErr_Occurred()) {
22995 PyErr_SetString(PyExc_RuntimeError,
22996 "Unexpected error in an Op's C code. "
22997 "No Python exception was set.");
22998 }
22999 goto __label_446;}
23000 }
23001 // This is a TypeError to be consistent with DEBUG_MODE
23002 // Note: DEBUG_MODE also tells the name of the container
23003 if (PyArray_TYPE((PyArrayObject*) py_V445) != NPY_FLOAT64) {
23004 PyErr_Format(PyExc_TypeError,
23005 "expected type_num %d (NPY_FLOAT64) got %d",
23006 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V445));
23007 {
23008 __failure = 446;
23009 if (!PyErr_Occurred()) {
23010 PyErr_SetString(PyExc_RuntimeError,
23011 "Unexpected error in an Op's C code. "
23012 "No Python exception was set.");
23013 }
23014 goto __label_446;}
23015 }
23016
23017 V445 = (PyArrayObject*)(py_V445);
23018 Py_XINCREF(V445);
23019
23020 {
23021
23022 py_V447 = PyList_GET_ITEM(storage_V447, 0);
23023 {Py_XINCREF(py_V447);}
23024
23025 V447 = NULL;
23026 if (py_V447 == Py_None) {
23027 // We can either fail here or set V447 to NULL and rely on Ops
23028 // using tensors to handle the NULL case, but if they fail to do so
23029 // they'll end up with nasty segfaults, so this is public service.
23030 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
23031 {
23032 __failure = 448;
23033 if (!PyErr_Occurred()) {
23034 PyErr_SetString(PyExc_RuntimeError,
23035 "Unexpected error in an Op's C code. "
23036 "No Python exception was set.");
23037 }
23038 goto __label_448;}
23039 }
23040 if (!PyArray_Check(py_V447)) {
23041 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
23042 {
23043 __failure = 448;
23044 if (!PyErr_Occurred()) {
23045 PyErr_SetString(PyExc_RuntimeError,
23046 "Unexpected error in an Op's C code. "
23047 "No Python exception was set.");
23048 }
23049 goto __label_448;}
23050 }
23051 // We expect NPY_FLOAT64
23052 if (!PyArray_ISALIGNED((PyArrayObject*) py_V447)) {
23053 PyArrayObject * tmp = (PyArrayObject*) py_V447;
23054 PyErr_Format(PyExc_NotImplementedError,
23055 "expected an aligned array of type %ld "
23056 "(NPY_FLOAT64), got non-aligned array of type %ld"
23057 " with %ld dimensions, with 3 last dims "
23058 "%ld, %ld, %ld"
23059 " and 3 last strides %ld %ld, %ld.",
23060 (long int) NPY_FLOAT64,
23061 (long int) PyArray_TYPE((PyArrayObject*) py_V447),
23062 (long int) PyArray_NDIM(tmp),
23063 (long int) (PyArray_NDIM(tmp) >= 3 ?
23064 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
23065 (long int) (PyArray_NDIM(tmp) >= 2 ?
23066 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
23067 (long int) (PyArray_NDIM(tmp) >= 1 ?
23068 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
23069 (long int) (PyArray_NDIM(tmp) >= 3 ?
23070 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
23071 (long int) (PyArray_NDIM(tmp) >= 2 ?
23072 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
23073 (long int) (PyArray_NDIM(tmp) >= 1 ?
23074 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
23075 );
23076 {
23077 __failure = 448;
23078 if (!PyErr_Occurred()) {
23079 PyErr_SetString(PyExc_RuntimeError,
23080 "Unexpected error in an Op's C code. "
23081 "No Python exception was set.");
23082 }
23083 goto __label_448;}
23084 }
23085 // This is a TypeError to be consistent with DEBUG_MODE
23086 // Note: DEBUG_MODE also tells the name of the container
23087 if (PyArray_TYPE((PyArrayObject*) py_V447) != NPY_FLOAT64) {
23088 PyErr_Format(PyExc_TypeError,
23089 "expected type_num %d (NPY_FLOAT64) got %d",
23090 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V447));
23091 {
23092 __failure = 448;
23093 if (!PyErr_Occurred()) {
23094 PyErr_SetString(PyExc_RuntimeError,
23095 "Unexpected error in an Op's C code. "
23096 "No Python exception was set.");
23097 }
23098 goto __label_448;}
23099 }
23100
23101 V447 = (PyArrayObject*)(py_V447);
23102 Py_XINCREF(V447);
23103
23104 {
23105
23106 py_V449 = PyList_GET_ITEM(storage_V449, 0);
23107 {Py_XINCREF(py_V449);}
23108
23109 V449 = NULL;
23110 if (py_V449 == Py_None) {
23111 // We can either fail here or set V449 to NULL and rely on Ops
23112 // using tensors to handle the NULL case, but if they fail to do so
23113 // they'll end up with nasty segfaults, so this is public service.
23114 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
23115 {
23116 __failure = 450;
23117 if (!PyErr_Occurred()) {
23118 PyErr_SetString(PyExc_RuntimeError,
23119 "Unexpected error in an Op's C code. "
23120 "No Python exception was set.");
23121 }
23122 goto __label_450;}
23123 }
23124 if (!PyArray_Check(py_V449)) {
23125 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
23126 {
23127 __failure = 450;
23128 if (!PyErr_Occurred()) {
23129 PyErr_SetString(PyExc_RuntimeError,
23130 "Unexpected error in an Op's C code. "
23131 "No Python exception was set.");
23132 }
23133 goto __label_450;}
23134 }
23135 // We expect NPY_FLOAT64
23136 if (!PyArray_ISALIGNED((PyArrayObject*) py_V449)) {
23137 PyArrayObject * tmp = (PyArrayObject*) py_V449;
23138 PyErr_Format(PyExc_NotImplementedError,
23139 "expected an aligned array of type %ld "
23140 "(NPY_FLOAT64), got non-aligned array of type %ld"
23141 " with %ld dimensions, with 3 last dims "
23142 "%ld, %ld, %ld"
23143 " and 3 last strides %ld %ld, %ld.",
23144 (long int) NPY_FLOAT64,
23145 (long int) PyArray_TYPE((PyArrayObject*) py_V449),
23146 (long int) PyArray_NDIM(tmp),
23147 (long int) (PyArray_NDIM(tmp) >= 3 ?
23148 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
23149 (long int) (PyArray_NDIM(tmp) >= 2 ?
23150 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
23151 (long int) (PyArray_NDIM(tmp) >= 1 ?
23152 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
23153 (long int) (PyArray_NDIM(tmp) >= 3 ?
23154 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
23155 (long int) (PyArray_NDIM(tmp) >= 2 ?
23156 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
23157 (long int) (PyArray_NDIM(tmp) >= 1 ?
23158 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
23159 );
23160 {
23161 __failure = 450;
23162 if (!PyErr_Occurred()) {
23163 PyErr_SetString(PyExc_RuntimeError,
23164 "Unexpected error in an Op's C code. "
23165 "No Python exception was set.");
23166 }
23167 goto __label_450;}
23168 }
23169 // This is a TypeError to be consistent with DEBUG_MODE
23170 // Note: DEBUG_MODE also tells the name of the container
23171 if (PyArray_TYPE((PyArrayObject*) py_V449) != NPY_FLOAT64) {
23172 PyErr_Format(PyExc_TypeError,
23173 "expected type_num %d (NPY_FLOAT64) got %d",
23174 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V449));
23175 {
23176 __failure = 450;
23177 if (!PyErr_Occurred()) {
23178 PyErr_SetString(PyExc_RuntimeError,
23179 "Unexpected error in an Op's C code. "
23180 "No Python exception was set.");
23181 }
23182 goto __label_450;}
23183 }
23184
23185 V449 = (PyArrayObject*)(py_V449);
23186 Py_XINCREF(V449);
23187
23188 {
23189
23190 py_V451 = PyList_GET_ITEM(storage_V451, 0);
23191 {Py_XINCREF(py_V451);}
23192
23193 V451 = NULL;
23194 if (py_V451 == Py_None) {
23195 // We can either fail here or set V451 to NULL and rely on Ops
23196 // using tensors to handle the NULL case, but if they fail to do so
23197 // they'll end up with nasty segfaults, so this is public service.
23198 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
23199 {
23200 __failure = 452;
23201 if (!PyErr_Occurred()) {
23202 PyErr_SetString(PyExc_RuntimeError,
23203 "Unexpected error in an Op's C code. "
23204 "No Python exception was set.");
23205 }
23206 goto __label_452;}
23207 }
23208 if (!PyArray_Check(py_V451)) {
23209 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
23210 {
23211 __failure = 452;
23212 if (!PyErr_Occurred()) {
23213 PyErr_SetString(PyExc_RuntimeError,
23214 "Unexpected error in an Op's C code. "
23215 "No Python exception was set.");
23216 }
23217 goto __label_452;}
23218 }
23219 // We expect NPY_FLOAT64
23220 if (!PyArray_ISALIGNED((PyArrayObject*) py_V451)) {
23221 PyArrayObject * tmp = (PyArrayObject*) py_V451;
23222 PyErr_Format(PyExc_NotImplementedError,
23223 "expected an aligned array of type %ld "
23224 "(NPY_FLOAT64), got non-aligned array of type %ld"
23225 " with %ld dimensions, with 3 last dims "
23226 "%ld, %ld, %ld"
23227 " and 3 last strides %ld %ld, %ld.",
23228 (long int) NPY_FLOAT64,
23229 (long int) PyArray_TYPE((PyArrayObject*) py_V451),
23230 (long int) PyArray_NDIM(tmp),
23231 (long int) (PyArray_NDIM(tmp) >= 3 ?
23232 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
23233 (long int) (PyArray_NDIM(tmp) >= 2 ?
23234 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
23235 (long int) (PyArray_NDIM(tmp) >= 1 ?
23236 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
23237 (long int) (PyArray_NDIM(tmp) >= 3 ?
23238 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
23239 (long int) (PyArray_NDIM(tmp) >= 2 ?
23240 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
23241 (long int) (PyArray_NDIM(tmp) >= 1 ?
23242 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
23243 );
23244 {
23245 __failure = 452;
23246 if (!PyErr_Occurred()) {
23247 PyErr_SetString(PyExc_RuntimeError,
23248 "Unexpected error in an Op's C code. "
23249 "No Python exception was set.");
23250 }
23251 goto __label_452;}
23252 }
23253 // This is a TypeError to be consistent with DEBUG_MODE
23254 // Note: DEBUG_MODE also tells the name of the container
23255 if (PyArray_TYPE((PyArrayObject*) py_V451) != NPY_FLOAT64) {
23256 PyErr_Format(PyExc_TypeError,
23257 "expected type_num %d (NPY_FLOAT64) got %d",
23258 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V451));
23259 {
23260 __failure = 452;
23261 if (!PyErr_Occurred()) {
23262 PyErr_SetString(PyExc_RuntimeError,
23263 "Unexpected error in an Op's C code. "
23264 "No Python exception was set.");
23265 }
23266 goto __label_452;}
23267 }
23268
23269 V451 = (PyArrayObject*)(py_V451);
23270 Py_XINCREF(V451);
23271
23272 {
23273
23274 py_V453 = PyList_GET_ITEM(storage_V453, 0);
23275 {Py_XINCREF(py_V453);}
23276
23277 V453 = NULL;
23278 if (py_V453 == Py_None) {
23279 // We can either fail here or set V453 to NULL and rely on Ops
23280 // using tensors to handle the NULL case, but if they fail to do so
23281 // they'll end up with nasty segfaults, so this is public service.
23282 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
23283 {
23284 __failure = 454;
23285 if (!PyErr_Occurred()) {
23286 PyErr_SetString(PyExc_RuntimeError,
23287 "Unexpected error in an Op's C code. "
23288 "No Python exception was set.");
23289 }
23290 goto __label_454;}
23291 }
23292 if (!PyArray_Check(py_V453)) {
23293 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
23294 {
23295 __failure = 454;
23296 if (!PyErr_Occurred()) {
23297 PyErr_SetString(PyExc_RuntimeError,
23298 "Unexpected error in an Op's C code. "
23299 "No Python exception was set.");
23300 }
23301 goto __label_454;}
23302 }
23303 // We expect NPY_FLOAT64
23304 if (!PyArray_ISALIGNED((PyArrayObject*) py_V453)) {
23305 PyArrayObject * tmp = (PyArrayObject*) py_V453;
23306 PyErr_Format(PyExc_NotImplementedError,
23307 "expected an aligned array of type %ld "
23308 "(NPY_FLOAT64), got non-aligned array of type %ld"
23309 " with %ld dimensions, with 3 last dims "
23310 "%ld, %ld, %ld"
23311 " and 3 last strides %ld %ld, %ld.",
23312 (long int) NPY_FLOAT64,
23313 (long int) PyArray_TYPE((PyArrayObject*) py_V453),
23314 (long int) PyArray_NDIM(tmp),
23315 (long int) (PyArray_NDIM(tmp) >= 3 ?
23316 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
23317 (long int) (PyArray_NDIM(tmp) >= 2 ?
23318 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
23319 (long int) (PyArray_NDIM(tmp) >= 1 ?
23320 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
23321 (long int) (PyArray_NDIM(tmp) >= 3 ?
23322 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
23323 (long int) (PyArray_NDIM(tmp) >= 2 ?
23324 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
23325 (long int) (PyArray_NDIM(tmp) >= 1 ?
23326 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
23327 );
23328 {
23329 __failure = 454;
23330 if (!PyErr_Occurred()) {
23331 PyErr_SetString(PyExc_RuntimeError,
23332 "Unexpected error in an Op's C code. "
23333 "No Python exception was set.");
23334 }
23335 goto __label_454;}
23336 }
23337 // This is a TypeError to be consistent with DEBUG_MODE
23338 // Note: DEBUG_MODE also tells the name of the container
23339 if (PyArray_TYPE((PyArrayObject*) py_V453) != NPY_FLOAT64) {
23340 PyErr_Format(PyExc_TypeError,
23341 "expected type_num %d (NPY_FLOAT64) got %d",
23342 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V453));
23343 {
23344 __failure = 454;
23345 if (!PyErr_Occurred()) {
23346 PyErr_SetString(PyExc_RuntimeError,
23347 "Unexpected error in an Op's C code. "
23348 "No Python exception was set.");
23349 }
23350 goto __label_454;}
23351 }
23352
23353 V453 = (PyArrayObject*)(py_V453);
23354 Py_XINCREF(V453);
23355
23356 {
23357
23358 py_V455 = PyList_GET_ITEM(storage_V455, 0);
23359 {Py_XINCREF(py_V455);}
23360
23361 V455 = NULL;
23362 if (py_V455 == Py_None) {
23363 // We can either fail here or set V455 to NULL and rely on Ops
23364 // using tensors to handle the NULL case, but if they fail to do so
23365 // they'll end up with nasty segfaults, so this is public service.
23366 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
23367 {
23368 __failure = 456;
23369 if (!PyErr_Occurred()) {
23370 PyErr_SetString(PyExc_RuntimeError,
23371 "Unexpected error in an Op's C code. "
23372 "No Python exception was set.");
23373 }
23374 goto __label_456;}
23375 }
23376 if (!PyArray_Check(py_V455)) {
23377 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
23378 {
23379 __failure = 456;
23380 if (!PyErr_Occurred()) {
23381 PyErr_SetString(PyExc_RuntimeError,
23382 "Unexpected error in an Op's C code. "
23383 "No Python exception was set.");
23384 }
23385 goto __label_456;}
23386 }
23387 // We expect NPY_FLOAT64
23388 if (!PyArray_ISALIGNED((PyArrayObject*) py_V455)) {
23389 PyArrayObject * tmp = (PyArrayObject*) py_V455;
23390 PyErr_Format(PyExc_NotImplementedError,
23391 "expected an aligned array of type %ld "
23392 "(NPY_FLOAT64), got non-aligned array of type %ld"
23393 " with %ld dimensions, with 3 last dims "
23394 "%ld, %ld, %ld"
23395 " and 3 last strides %ld %ld, %ld.",
23396 (long int) NPY_FLOAT64,
23397 (long int) PyArray_TYPE((PyArrayObject*) py_V455),
23398 (long int) PyArray_NDIM(tmp),
23399 (long int) (PyArray_NDIM(tmp) >= 3 ?
23400 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
23401 (long int) (PyArray_NDIM(tmp) >= 2 ?
23402 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
23403 (long int) (PyArray_NDIM(tmp) >= 1 ?
23404 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
23405 (long int) (PyArray_NDIM(tmp) >= 3 ?
23406 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
23407 (long int) (PyArray_NDIM(tmp) >= 2 ?
23408 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
23409 (long int) (PyArray_NDIM(tmp) >= 1 ?
23410 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
23411 );
23412 {
23413 __failure = 456;
23414 if (!PyErr_Occurred()) {
23415 PyErr_SetString(PyExc_RuntimeError,
23416 "Unexpected error in an Op's C code. "
23417 "No Python exception was set.");
23418 }
23419 goto __label_456;}
23420 }
23421 // This is a TypeError to be consistent with DEBUG_MODE
23422 // Note: DEBUG_MODE also tells the name of the container
23423 if (PyArray_TYPE((PyArrayObject*) py_V455) != NPY_FLOAT64) {
23424 PyErr_Format(PyExc_TypeError,
23425 "expected type_num %d (NPY_FLOAT64) got %d",
23426 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V455));
23427 {
23428 __failure = 456;
23429 if (!PyErr_Occurred()) {
23430 PyErr_SetString(PyExc_RuntimeError,
23431 "Unexpected error in an Op's C code. "
23432 "No Python exception was set.");
23433 }
23434 goto __label_456;}
23435 }
23436
23437 V455 = (PyArrayObject*)(py_V455);
23438 Py_XINCREF(V455);
23439
23440 {
23441
23442 py_V457 = PyList_GET_ITEM(storage_V457, 0);
23443 {Py_XINCREF(py_V457);}
23444
23445 V457 = NULL;
23446 if (py_V457 == Py_None) {
23447 // We can either fail here or set V457 to NULL and rely on Ops
23448 // using tensors to handle the NULL case, but if they fail to do so
23449 // they'll end up with nasty segfaults, so this is public service.
23450 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
23451 {
23452 __failure = 458;
23453 if (!PyErr_Occurred()) {
23454 PyErr_SetString(PyExc_RuntimeError,
23455 "Unexpected error in an Op's C code. "
23456 "No Python exception was set.");
23457 }
23458 goto __label_458;}
23459 }
23460 if (!PyArray_Check(py_V457)) {
23461 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
23462 {
23463 __failure = 458;
23464 if (!PyErr_Occurred()) {
23465 PyErr_SetString(PyExc_RuntimeError,
23466 "Unexpected error in an Op's C code. "
23467 "No Python exception was set.");
23468 }
23469 goto __label_458;}
23470 }
23471 // We expect NPY_FLOAT64
23472 if (!PyArray_ISALIGNED((PyArrayObject*) py_V457)) {
23473 PyArrayObject * tmp = (PyArrayObject*) py_V457;
23474 PyErr_Format(PyExc_NotImplementedError,
23475 "expected an aligned array of type %ld "
23476 "(NPY_FLOAT64), got non-aligned array of type %ld"
23477 " with %ld dimensions, with 3 last dims "
23478 "%ld, %ld, %ld"
23479 " and 3 last strides %ld %ld, %ld.",
23480 (long int) NPY_FLOAT64,
23481 (long int) PyArray_TYPE((PyArrayObject*) py_V457),
23482 (long int) PyArray_NDIM(tmp),
23483 (long int) (PyArray_NDIM(tmp) >= 3 ?
23484 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
23485 (long int) (PyArray_NDIM(tmp) >= 2 ?
23486 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
23487 (long int) (PyArray_NDIM(tmp) >= 1 ?
23488 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
23489 (long int) (PyArray_NDIM(tmp) >= 3 ?
23490 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
23491 (long int) (PyArray_NDIM(tmp) >= 2 ?
23492 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
23493 (long int) (PyArray_NDIM(tmp) >= 1 ?
23494 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
23495 );
23496 {
23497 __failure = 458;
23498 if (!PyErr_Occurred()) {
23499 PyErr_SetString(PyExc_RuntimeError,
23500 "Unexpected error in an Op's C code. "
23501 "No Python exception was set.");
23502 }
23503 goto __label_458;}
23504 }
23505 // This is a TypeError to be consistent with DEBUG_MODE
23506 // Note: DEBUG_MODE also tells the name of the container
23507 if (PyArray_TYPE((PyArrayObject*) py_V457) != NPY_FLOAT64) {
23508 PyErr_Format(PyExc_TypeError,
23509 "expected type_num %d (NPY_FLOAT64) got %d",
23510 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V457));
23511 {
23512 __failure = 458;
23513 if (!PyErr_Occurred()) {
23514 PyErr_SetString(PyExc_RuntimeError,
23515 "Unexpected error in an Op's C code. "
23516 "No Python exception was set.");
23517 }
23518 goto __label_458;}
23519 }
23520
23521 V457 = (PyArrayObject*)(py_V457);
23522 Py_XINCREF(V457);
23523
23524 {
23525
23526 py_V459 = PyList_GET_ITEM(storage_V459, 0);
23527 {Py_XINCREF(py_V459);}
23528
23529 V459 = NULL;
23530 if (py_V459 == Py_None) {
23531 // We can either fail here or set V459 to NULL and rely on Ops
23532 // using tensors to handle the NULL case, but if they fail to do so
23533 // they'll end up with nasty segfaults, so this is public service.
23534 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
23535 {
23536 __failure = 460;
23537 if (!PyErr_Occurred()) {
23538 PyErr_SetString(PyExc_RuntimeError,
23539 "Unexpected error in an Op's C code. "
23540 "No Python exception was set.");
23541 }
23542 goto __label_460;}
23543 }
23544 if (!PyArray_Check(py_V459)) {
23545 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
23546 {
23547 __failure = 460;
23548 if (!PyErr_Occurred()) {
23549 PyErr_SetString(PyExc_RuntimeError,
23550 "Unexpected error in an Op's C code. "
23551 "No Python exception was set.");
23552 }
23553 goto __label_460;}
23554 }
23555 // We expect NPY_FLOAT64
23556 if (!PyArray_ISALIGNED((PyArrayObject*) py_V459)) {
23557 PyArrayObject * tmp = (PyArrayObject*) py_V459;
23558 PyErr_Format(PyExc_NotImplementedError,
23559 "expected an aligned array of type %ld "
23560 "(NPY_FLOAT64), got non-aligned array of type %ld"
23561 " with %ld dimensions, with 3 last dims "
23562 "%ld, %ld, %ld"
23563 " and 3 last strides %ld %ld, %ld.",
23564 (long int) NPY_FLOAT64,
23565 (long int) PyArray_TYPE((PyArrayObject*) py_V459),
23566 (long int) PyArray_NDIM(tmp),
23567 (long int) (PyArray_NDIM(tmp) >= 3 ?
23568 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
23569 (long int) (PyArray_NDIM(tmp) >= 2 ?
23570 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
23571 (long int) (PyArray_NDIM(tmp) >= 1 ?
23572 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
23573 (long int) (PyArray_NDIM(tmp) >= 3 ?
23574 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
23575 (long int) (PyArray_NDIM(tmp) >= 2 ?
23576 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
23577 (long int) (PyArray_NDIM(tmp) >= 1 ?
23578 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
23579 );
23580 {
23581 __failure = 460;
23582 if (!PyErr_Occurred()) {
23583 PyErr_SetString(PyExc_RuntimeError,
23584 "Unexpected error in an Op's C code. "
23585 "No Python exception was set.");
23586 }
23587 goto __label_460;}
23588 }
23589 // This is a TypeError to be consistent with DEBUG_MODE
23590 // Note: DEBUG_MODE also tells the name of the container
23591 if (PyArray_TYPE((PyArrayObject*) py_V459) != NPY_FLOAT64) {
23592 PyErr_Format(PyExc_TypeError,
23593 "expected type_num %d (NPY_FLOAT64) got %d",
23594 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V459));
23595 {
23596 __failure = 460;
23597 if (!PyErr_Occurred()) {
23598 PyErr_SetString(PyExc_RuntimeError,
23599 "Unexpected error in an Op's C code. "
23600 "No Python exception was set.");
23601 }
23602 goto __label_460;}
23603 }
23604
23605 V459 = (PyArrayObject*)(py_V459);
23606 Py_XINCREF(V459);
23607
23608 {
23609
23610 py_V461 = PyList_GET_ITEM(storage_V461, 0);
23611 {Py_XINCREF(py_V461);}
23612
23613 V461 = NULL;
23614 if (py_V461 == Py_None) {
23615 // We can either fail here or set V461 to NULL and rely on Ops
23616 // using tensors to handle the NULL case, but if they fail to do so
23617 // they'll end up with nasty segfaults, so this is public service.
23618 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
23619 {
23620 __failure = 462;
23621 if (!PyErr_Occurred()) {
23622 PyErr_SetString(PyExc_RuntimeError,
23623 "Unexpected error in an Op's C code. "
23624 "No Python exception was set.");
23625 }
23626 goto __label_462;}
23627 }
23628 if (!PyArray_Check(py_V461)) {
23629 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
23630 {
23631 __failure = 462;
23632 if (!PyErr_Occurred()) {
23633 PyErr_SetString(PyExc_RuntimeError,
23634 "Unexpected error in an Op's C code. "
23635 "No Python exception was set.");
23636 }
23637 goto __label_462;}
23638 }
23639 // We expect NPY_FLOAT64
23640 if (!PyArray_ISALIGNED((PyArrayObject*) py_V461)) {
23641 PyArrayObject * tmp = (PyArrayObject*) py_V461;
23642 PyErr_Format(PyExc_NotImplementedError,
23643 "expected an aligned array of type %ld "
23644 "(NPY_FLOAT64), got non-aligned array of type %ld"
23645 " with %ld dimensions, with 3 last dims "
23646 "%ld, %ld, %ld"
23647 " and 3 last strides %ld %ld, %ld.",
23648 (long int) NPY_FLOAT64,
23649 (long int) PyArray_TYPE((PyArrayObject*) py_V461),
23650 (long int) PyArray_NDIM(tmp),
23651 (long int) (PyArray_NDIM(tmp) >= 3 ?
23652 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
23653 (long int) (PyArray_NDIM(tmp) >= 2 ?
23654 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
23655 (long int) (PyArray_NDIM(tmp) >= 1 ?
23656 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
23657 (long int) (PyArray_NDIM(tmp) >= 3 ?
23658 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
23659 (long int) (PyArray_NDIM(tmp) >= 2 ?
23660 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
23661 (long int) (PyArray_NDIM(tmp) >= 1 ?
23662 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
23663 );
23664 {
23665 __failure = 462;
23666 if (!PyErr_Occurred()) {
23667 PyErr_SetString(PyExc_RuntimeError,
23668 "Unexpected error in an Op's C code. "
23669 "No Python exception was set.");
23670 }
23671 goto __label_462;}
23672 }
23673 // This is a TypeError to be consistent with DEBUG_MODE
23674 // Note: DEBUG_MODE also tells the name of the container
23675 if (PyArray_TYPE((PyArrayObject*) py_V461) != NPY_FLOAT64) {
23676 PyErr_Format(PyExc_TypeError,
23677 "expected type_num %d (NPY_FLOAT64) got %d",
23678 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V461));
23679 {
23680 __failure = 462;
23681 if (!PyErr_Occurred()) {
23682 PyErr_SetString(PyExc_RuntimeError,
23683 "Unexpected error in an Op's C code. "
23684 "No Python exception was set.");
23685 }
23686 goto __label_462;}
23687 }
23688
23689 V461 = (PyArrayObject*)(py_V461);
23690 Py_XINCREF(V461);
23691
23692 {
23693
23694 py_V463 = PyList_GET_ITEM(storage_V463, 0);
23695 {Py_XINCREF(py_V463);}
23696
23697 V463 = NULL;
23698 if (py_V463 == Py_None) {
23699 // We can either fail here or set V463 to NULL and rely on Ops
23700 // using tensors to handle the NULL case, but if they fail to do so
23701 // they'll end up with nasty segfaults, so this is public service.
23702 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
23703 {
23704 __failure = 464;
23705 if (!PyErr_Occurred()) {
23706 PyErr_SetString(PyExc_RuntimeError,
23707 "Unexpected error in an Op's C code. "
23708 "No Python exception was set.");
23709 }
23710 goto __label_464;}
23711 }
23712 if (!PyArray_Check(py_V463)) {
23713 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
23714 {
23715 __failure = 464;
23716 if (!PyErr_Occurred()) {
23717 PyErr_SetString(PyExc_RuntimeError,
23718 "Unexpected error in an Op's C code. "
23719 "No Python exception was set.");
23720 }
23721 goto __label_464;}
23722 }
23723 // We expect NPY_FLOAT64
23724 if (!PyArray_ISALIGNED((PyArrayObject*) py_V463)) {
23725 PyArrayObject * tmp = (PyArrayObject*) py_V463;
23726 PyErr_Format(PyExc_NotImplementedError,
23727 "expected an aligned array of type %ld "
23728 "(NPY_FLOAT64), got non-aligned array of type %ld"
23729 " with %ld dimensions, with 3 last dims "
23730 "%ld, %ld, %ld"
23731 " and 3 last strides %ld %ld, %ld.",
23732 (long int) NPY_FLOAT64,
23733 (long int) PyArray_TYPE((PyArrayObject*) py_V463),
23734 (long int) PyArray_NDIM(tmp),
23735 (long int) (PyArray_NDIM(tmp) >= 3 ?
23736 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
23737 (long int) (PyArray_NDIM(tmp) >= 2 ?
23738 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
23739 (long int) (PyArray_NDIM(tmp) >= 1 ?
23740 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
23741 (long int) (PyArray_NDIM(tmp) >= 3 ?
23742 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
23743 (long int) (PyArray_NDIM(tmp) >= 2 ?
23744 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
23745 (long int) (PyArray_NDIM(tmp) >= 1 ?
23746 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
23747 );
23748 {
23749 __failure = 464;
23750 if (!PyErr_Occurred()) {
23751 PyErr_SetString(PyExc_RuntimeError,
23752 "Unexpected error in an Op's C code. "
23753 "No Python exception was set.");
23754 }
23755 goto __label_464;}
23756 }
23757 // This is a TypeError to be consistent with DEBUG_MODE
23758 // Note: DEBUG_MODE also tells the name of the container
23759 if (PyArray_TYPE((PyArrayObject*) py_V463) != NPY_FLOAT64) {
23760 PyErr_Format(PyExc_TypeError,
23761 "expected type_num %d (NPY_FLOAT64) got %d",
23762 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V463));
23763 {
23764 __failure = 464;
23765 if (!PyErr_Occurred()) {
23766 PyErr_SetString(PyExc_RuntimeError,
23767 "Unexpected error in an Op's C code. "
23768 "No Python exception was set.");
23769 }
23770 goto __label_464;}
23771 }
23772
23773 V463 = (PyArrayObject*)(py_V463);
23774 Py_XINCREF(V463);
23775
23776 {
23777
23778 py_V465 = PyList_GET_ITEM(storage_V465, 0);
23779 {Py_XINCREF(py_V465);}
23780
23781 V465 = NULL;
23782 if (py_V465 == Py_None) {
23783 // We can either fail here or set V465 to NULL and rely on Ops
23784 // using tensors to handle the NULL case, but if they fail to do so
23785 // they'll end up with nasty segfaults, so this is public service.
23786 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
23787 {
23788 __failure = 466;
23789 if (!PyErr_Occurred()) {
23790 PyErr_SetString(PyExc_RuntimeError,
23791 "Unexpected error in an Op's C code. "
23792 "No Python exception was set.");
23793 }
23794 goto __label_466;}
23795 }
23796 if (!PyArray_Check(py_V465)) {
23797 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
23798 {
23799 __failure = 466;
23800 if (!PyErr_Occurred()) {
23801 PyErr_SetString(PyExc_RuntimeError,
23802 "Unexpected error in an Op's C code. "
23803 "No Python exception was set.");
23804 }
23805 goto __label_466;}
23806 }
23807 // We expect NPY_FLOAT64
23808 if (!PyArray_ISALIGNED((PyArrayObject*) py_V465)) {
23809 PyArrayObject * tmp = (PyArrayObject*) py_V465;
23810 PyErr_Format(PyExc_NotImplementedError,
23811 "expected an aligned array of type %ld "
23812 "(NPY_FLOAT64), got non-aligned array of type %ld"
23813 " with %ld dimensions, with 3 last dims "
23814 "%ld, %ld, %ld"
23815 " and 3 last strides %ld %ld, %ld.",
23816 (long int) NPY_FLOAT64,
23817 (long int) PyArray_TYPE((PyArrayObject*) py_V465),
23818 (long int) PyArray_NDIM(tmp),
23819 (long int) (PyArray_NDIM(tmp) >= 3 ?
23820 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
23821 (long int) (PyArray_NDIM(tmp) >= 2 ?
23822 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
23823 (long int) (PyArray_NDIM(tmp) >= 1 ?
23824 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
23825 (long int) (PyArray_NDIM(tmp) >= 3 ?
23826 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
23827 (long int) (PyArray_NDIM(tmp) >= 2 ?
23828 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
23829 (long int) (PyArray_NDIM(tmp) >= 1 ?
23830 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
23831 );
23832 {
23833 __failure = 466;
23834 if (!PyErr_Occurred()) {
23835 PyErr_SetString(PyExc_RuntimeError,
23836 "Unexpected error in an Op's C code. "
23837 "No Python exception was set.");
23838 }
23839 goto __label_466;}
23840 }
23841 // This is a TypeError to be consistent with DEBUG_MODE
23842 // Note: DEBUG_MODE also tells the name of the container
23843 if (PyArray_TYPE((PyArrayObject*) py_V465) != NPY_FLOAT64) {
23844 PyErr_Format(PyExc_TypeError,
23845 "expected type_num %d (NPY_FLOAT64) got %d",
23846 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V465));
23847 {
23848 __failure = 466;
23849 if (!PyErr_Occurred()) {
23850 PyErr_SetString(PyExc_RuntimeError,
23851 "Unexpected error in an Op's C code. "
23852 "No Python exception was set.");
23853 }
23854 goto __label_466;}
23855 }
23856
23857 V465 = (PyArrayObject*)(py_V465);
23858 Py_XINCREF(V465);
23859
23860 {
23861
23862 py_V467 = PyList_GET_ITEM(storage_V467, 0);
23863 {Py_XINCREF(py_V467);}
23864
23865 V467 = NULL;
23866 if (py_V467 == Py_None) {
23867 // We can either fail here or set V467 to NULL and rely on Ops
23868 // using tensors to handle the NULL case, but if they fail to do so
23869 // they'll end up with nasty segfaults, so this is public service.
23870 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
23871 {
23872 __failure = 468;
23873 if (!PyErr_Occurred()) {
23874 PyErr_SetString(PyExc_RuntimeError,
23875 "Unexpected error in an Op's C code. "
23876 "No Python exception was set.");
23877 }
23878 goto __label_468;}
23879 }
23880 if (!PyArray_Check(py_V467)) {
23881 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
23882 {
23883 __failure = 468;
23884 if (!PyErr_Occurred()) {
23885 PyErr_SetString(PyExc_RuntimeError,
23886 "Unexpected error in an Op's C code. "
23887 "No Python exception was set.");
23888 }
23889 goto __label_468;}
23890 }
23891 // We expect NPY_FLOAT64
23892 if (!PyArray_ISALIGNED((PyArrayObject*) py_V467)) {
23893 PyArrayObject * tmp = (PyArrayObject*) py_V467;
23894 PyErr_Format(PyExc_NotImplementedError,
23895 "expected an aligned array of type %ld "
23896 "(NPY_FLOAT64), got non-aligned array of type %ld"
23897 " with %ld dimensions, with 3 last dims "
23898 "%ld, %ld, %ld"
23899 " and 3 last strides %ld %ld, %ld.",
23900 (long int) NPY_FLOAT64,
23901 (long int) PyArray_TYPE((PyArrayObject*) py_V467),
23902 (long int) PyArray_NDIM(tmp),
23903 (long int) (PyArray_NDIM(tmp) >= 3 ?
23904 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
23905 (long int) (PyArray_NDIM(tmp) >= 2 ?
23906 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
23907 (long int) (PyArray_NDIM(tmp) >= 1 ?
23908 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
23909 (long int) (PyArray_NDIM(tmp) >= 3 ?
23910 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
23911 (long int) (PyArray_NDIM(tmp) >= 2 ?
23912 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
23913 (long int) (PyArray_NDIM(tmp) >= 1 ?
23914 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
23915 );
23916 {
23917 __failure = 468;
23918 if (!PyErr_Occurred()) {
23919 PyErr_SetString(PyExc_RuntimeError,
23920 "Unexpected error in an Op's C code. "
23921 "No Python exception was set.");
23922 }
23923 goto __label_468;}
23924 }
23925 // This is a TypeError to be consistent with DEBUG_MODE
23926 // Note: DEBUG_MODE also tells the name of the container
23927 if (PyArray_TYPE((PyArrayObject*) py_V467) != NPY_FLOAT64) {
23928 PyErr_Format(PyExc_TypeError,
23929 "expected type_num %d (NPY_FLOAT64) got %d",
23930 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V467));
23931 {
23932 __failure = 468;
23933 if (!PyErr_Occurred()) {
23934 PyErr_SetString(PyExc_RuntimeError,
23935 "Unexpected error in an Op's C code. "
23936 "No Python exception was set.");
23937 }
23938 goto __label_468;}
23939 }
23940
23941 V467 = (PyArrayObject*)(py_V467);
23942 Py_XINCREF(V467);
23943
23944 {
23945
23946 py_V469 = PyList_GET_ITEM(storage_V469, 0);
23947 {Py_XINCREF(py_V469);}
23948
23949 V469 = NULL;
23950 if (py_V469 == Py_None) {
23951 // We can either fail here or set V469 to NULL and rely on Ops
23952 // using tensors to handle the NULL case, but if they fail to do so
23953 // they'll end up with nasty segfaults, so this is public service.
23954 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
23955 {
23956 __failure = 470;
23957 if (!PyErr_Occurred()) {
23958 PyErr_SetString(PyExc_RuntimeError,
23959 "Unexpected error in an Op's C code. "
23960 "No Python exception was set.");
23961 }
23962 goto __label_470;}
23963 }
23964 if (!PyArray_Check(py_V469)) {
23965 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
23966 {
23967 __failure = 470;
23968 if (!PyErr_Occurred()) {
23969 PyErr_SetString(PyExc_RuntimeError,
23970 "Unexpected error in an Op's C code. "
23971 "No Python exception was set.");
23972 }
23973 goto __label_470;}
23974 }
23975 // We expect NPY_FLOAT64
23976 if (!PyArray_ISALIGNED((PyArrayObject*) py_V469)) {
23977 PyArrayObject * tmp = (PyArrayObject*) py_V469;
23978 PyErr_Format(PyExc_NotImplementedError,
23979 "expected an aligned array of type %ld "
23980 "(NPY_FLOAT64), got non-aligned array of type %ld"
23981 " with %ld dimensions, with 3 last dims "
23982 "%ld, %ld, %ld"
23983 " and 3 last strides %ld %ld, %ld.",
23984 (long int) NPY_FLOAT64,
23985 (long int) PyArray_TYPE((PyArrayObject*) py_V469),
23986 (long int) PyArray_NDIM(tmp),
23987 (long int) (PyArray_NDIM(tmp) >= 3 ?
23988 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
23989 (long int) (PyArray_NDIM(tmp) >= 2 ?
23990 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
23991 (long int) (PyArray_NDIM(tmp) >= 1 ?
23992 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
23993 (long int) (PyArray_NDIM(tmp) >= 3 ?
23994 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
23995 (long int) (PyArray_NDIM(tmp) >= 2 ?
23996 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
23997 (long int) (PyArray_NDIM(tmp) >= 1 ?
23998 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
23999 );
24000 {
24001 __failure = 470;
24002 if (!PyErr_Occurred()) {
24003 PyErr_SetString(PyExc_RuntimeError,
24004 "Unexpected error in an Op's C code. "
24005 "No Python exception was set.");
24006 }
24007 goto __label_470;}
24008 }
24009 // This is a TypeError to be consistent with DEBUG_MODE
24010 // Note: DEBUG_MODE also tells the name of the container
24011 if (PyArray_TYPE((PyArrayObject*) py_V469) != NPY_FLOAT64) {
24012 PyErr_Format(PyExc_TypeError,
24013 "expected type_num %d (NPY_FLOAT64) got %d",
24014 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V469));
24015 {
24016 __failure = 470;
24017 if (!PyErr_Occurred()) {
24018 PyErr_SetString(PyExc_RuntimeError,
24019 "Unexpected error in an Op's C code. "
24020 "No Python exception was set.");
24021 }
24022 goto __label_470;}
24023 }
24024
24025 V469 = (PyArrayObject*)(py_V469);
24026 Py_XINCREF(V469);
24027
24028 {
24029
24030 py_V471 = PyList_GET_ITEM(storage_V471, 0);
24031 {Py_XINCREF(py_V471);}
24032
24033 V471 = NULL;
24034 if (py_V471 == Py_None) {
24035 // We can either fail here or set V471 to NULL and rely on Ops
24036 // using tensors to handle the NULL case, but if they fail to do so
24037 // they'll end up with nasty segfaults, so this is public service.
24038 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
24039 {
24040 __failure = 472;
24041 if (!PyErr_Occurred()) {
24042 PyErr_SetString(PyExc_RuntimeError,
24043 "Unexpected error in an Op's C code. "
24044 "No Python exception was set.");
24045 }
24046 goto __label_472;}
24047 }
24048 if (!PyArray_Check(py_V471)) {
24049 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
24050 {
24051 __failure = 472;
24052 if (!PyErr_Occurred()) {
24053 PyErr_SetString(PyExc_RuntimeError,
24054 "Unexpected error in an Op's C code. "
24055 "No Python exception was set.");
24056 }
24057 goto __label_472;}
24058 }
24059 // We expect NPY_FLOAT64
24060 if (!PyArray_ISALIGNED((PyArrayObject*) py_V471)) {
24061 PyArrayObject * tmp = (PyArrayObject*) py_V471;
24062 PyErr_Format(PyExc_NotImplementedError,
24063 "expected an aligned array of type %ld "
24064 "(NPY_FLOAT64), got non-aligned array of type %ld"
24065 " with %ld dimensions, with 3 last dims "
24066 "%ld, %ld, %ld"
24067 " and 3 last strides %ld %ld, %ld.",
24068 (long int) NPY_FLOAT64,
24069 (long int) PyArray_TYPE((PyArrayObject*) py_V471),
24070 (long int) PyArray_NDIM(tmp),
24071 (long int) (PyArray_NDIM(tmp) >= 3 ?
24072 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
24073 (long int) (PyArray_NDIM(tmp) >= 2 ?
24074 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
24075 (long int) (PyArray_NDIM(tmp) >= 1 ?
24076 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
24077 (long int) (PyArray_NDIM(tmp) >= 3 ?
24078 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
24079 (long int) (PyArray_NDIM(tmp) >= 2 ?
24080 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
24081 (long int) (PyArray_NDIM(tmp) >= 1 ?
24082 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
24083 );
24084 {
24085 __failure = 472;
24086 if (!PyErr_Occurred()) {
24087 PyErr_SetString(PyExc_RuntimeError,
24088 "Unexpected error in an Op's C code. "
24089 "No Python exception was set.");
24090 }
24091 goto __label_472;}
24092 }
24093 // This is a TypeError to be consistent with DEBUG_MODE
24094 // Note: DEBUG_MODE also tells the name of the container
24095 if (PyArray_TYPE((PyArrayObject*) py_V471) != NPY_FLOAT64) {
24096 PyErr_Format(PyExc_TypeError,
24097 "expected type_num %d (NPY_FLOAT64) got %d",
24098 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V471));
24099 {
24100 __failure = 472;
24101 if (!PyErr_Occurred()) {
24102 PyErr_SetString(PyExc_RuntimeError,
24103 "Unexpected error in an Op's C code. "
24104 "No Python exception was set.");
24105 }
24106 goto __label_472;}
24107 }
24108
24109 V471 = (PyArrayObject*)(py_V471);
24110 Py_XINCREF(V471);
24111
24112 {
24113
24114 py_V473 = PyList_GET_ITEM(storage_V473, 0);
24115 {Py_XINCREF(py_V473);}
24116
24117 V473 = NULL;
24118 if (py_V473 == Py_None) {
24119 // We can either fail here or set V473 to NULL and rely on Ops
24120 // using tensors to handle the NULL case, but if they fail to do so
24121 // they'll end up with nasty segfaults, so this is public service.
24122 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
24123 {
24124 __failure = 474;
24125 if (!PyErr_Occurred()) {
24126 PyErr_SetString(PyExc_RuntimeError,
24127 "Unexpected error in an Op's C code. "
24128 "No Python exception was set.");
24129 }
24130 goto __label_474;}
24131 }
24132 if (!PyArray_Check(py_V473)) {
24133 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
24134 {
24135 __failure = 474;
24136 if (!PyErr_Occurred()) {
24137 PyErr_SetString(PyExc_RuntimeError,
24138 "Unexpected error in an Op's C code. "
24139 "No Python exception was set.");
24140 }
24141 goto __label_474;}
24142 }
24143 // We expect NPY_FLOAT64
24144 if (!PyArray_ISALIGNED((PyArrayObject*) py_V473)) {
24145 PyArrayObject * tmp = (PyArrayObject*) py_V473;
24146 PyErr_Format(PyExc_NotImplementedError,
24147 "expected an aligned array of type %ld "
24148 "(NPY_FLOAT64), got non-aligned array of type %ld"
24149 " with %ld dimensions, with 3 last dims "
24150 "%ld, %ld, %ld"
24151 " and 3 last strides %ld %ld, %ld.",
24152 (long int) NPY_FLOAT64,
24153 (long int) PyArray_TYPE((PyArrayObject*) py_V473),
24154 (long int) PyArray_NDIM(tmp),
24155 (long int) (PyArray_NDIM(tmp) >= 3 ?
24156 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
24157 (long int) (PyArray_NDIM(tmp) >= 2 ?
24158 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
24159 (long int) (PyArray_NDIM(tmp) >= 1 ?
24160 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
24161 (long int) (PyArray_NDIM(tmp) >= 3 ?
24162 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
24163 (long int) (PyArray_NDIM(tmp) >= 2 ?
24164 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
24165 (long int) (PyArray_NDIM(tmp) >= 1 ?
24166 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
24167 );
24168 {
24169 __failure = 474;
24170 if (!PyErr_Occurred()) {
24171 PyErr_SetString(PyExc_RuntimeError,
24172 "Unexpected error in an Op's C code. "
24173 "No Python exception was set.");
24174 }
24175 goto __label_474;}
24176 }
24177 // This is a TypeError to be consistent with DEBUG_MODE
24178 // Note: DEBUG_MODE also tells the name of the container
24179 if (PyArray_TYPE((PyArrayObject*) py_V473) != NPY_FLOAT64) {
24180 PyErr_Format(PyExc_TypeError,
24181 "expected type_num %d (NPY_FLOAT64) got %d",
24182 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V473));
24183 {
24184 __failure = 474;
24185 if (!PyErr_Occurred()) {
24186 PyErr_SetString(PyExc_RuntimeError,
24187 "Unexpected error in an Op's C code. "
24188 "No Python exception was set.");
24189 }
24190 goto __label_474;}
24191 }
24192
24193 V473 = (PyArrayObject*)(py_V473);
24194 Py_XINCREF(V473);
24195
24196 {
24197
24198 py_V475 = PyList_GET_ITEM(storage_V475, 0);
24199 {Py_XINCREF(py_V475);}
24200
24201 V475 = NULL;
24202 if (py_V475 == Py_None) {
24203 // We can either fail here or set V475 to NULL and rely on Ops
24204 // using tensors to handle the NULL case, but if they fail to do so
24205 // they'll end up with nasty segfaults, so this is public service.
24206 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
24207 {
24208 __failure = 476;
24209 if (!PyErr_Occurred()) {
24210 PyErr_SetString(PyExc_RuntimeError,
24211 "Unexpected error in an Op's C code. "
24212 "No Python exception was set.");
24213 }
24214 goto __label_476;}
24215 }
24216 if (!PyArray_Check(py_V475)) {
24217 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
24218 {
24219 __failure = 476;
24220 if (!PyErr_Occurred()) {
24221 PyErr_SetString(PyExc_RuntimeError,
24222 "Unexpected error in an Op's C code. "
24223 "No Python exception was set.");
24224 }
24225 goto __label_476;}
24226 }
24227 // We expect NPY_FLOAT64
24228 if (!PyArray_ISALIGNED((PyArrayObject*) py_V475)) {
24229 PyArrayObject * tmp = (PyArrayObject*) py_V475;
24230 PyErr_Format(PyExc_NotImplementedError,
24231 "expected an aligned array of type %ld "
24232 "(NPY_FLOAT64), got non-aligned array of type %ld"
24233 " with %ld dimensions, with 3 last dims "
24234 "%ld, %ld, %ld"
24235 " and 3 last strides %ld %ld, %ld.",
24236 (long int) NPY_FLOAT64,
24237 (long int) PyArray_TYPE((PyArrayObject*) py_V475),
24238 (long int) PyArray_NDIM(tmp),
24239 (long int) (PyArray_NDIM(tmp) >= 3 ?
24240 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
24241 (long int) (PyArray_NDIM(tmp) >= 2 ?
24242 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
24243 (long int) (PyArray_NDIM(tmp) >= 1 ?
24244 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
24245 (long int) (PyArray_NDIM(tmp) >= 3 ?
24246 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
24247 (long int) (PyArray_NDIM(tmp) >= 2 ?
24248 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
24249 (long int) (PyArray_NDIM(tmp) >= 1 ?
24250 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
24251 );
24252 {
24253 __failure = 476;
24254 if (!PyErr_Occurred()) {
24255 PyErr_SetString(PyExc_RuntimeError,
24256 "Unexpected error in an Op's C code. "
24257 "No Python exception was set.");
24258 }
24259 goto __label_476;}
24260 }
24261 // This is a TypeError to be consistent with DEBUG_MODE
24262 // Note: DEBUG_MODE also tells the name of the container
24263 if (PyArray_TYPE((PyArrayObject*) py_V475) != NPY_FLOAT64) {
24264 PyErr_Format(PyExc_TypeError,
24265 "expected type_num %d (NPY_FLOAT64) got %d",
24266 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V475));
24267 {
24268 __failure = 476;
24269 if (!PyErr_Occurred()) {
24270 PyErr_SetString(PyExc_RuntimeError,
24271 "Unexpected error in an Op's C code. "
24272 "No Python exception was set.");
24273 }
24274 goto __label_476;}
24275 }
24276
24277 V475 = (PyArrayObject*)(py_V475);
24278 Py_XINCREF(V475);
24279
24280 {
24281
24282 py_V477 = PyList_GET_ITEM(storage_V477, 0);
24283 {Py_XINCREF(py_V477);}
24284
24285 V477 = NULL;
24286 if (py_V477 == Py_None) {
24287 // We can either fail here or set V477 to NULL and rely on Ops
24288 // using tensors to handle the NULL case, but if they fail to do so
24289 // they'll end up with nasty segfaults, so this is public service.
24290 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
24291 {
24292 __failure = 478;
24293 if (!PyErr_Occurred()) {
24294 PyErr_SetString(PyExc_RuntimeError,
24295 "Unexpected error in an Op's C code. "
24296 "No Python exception was set.");
24297 }
24298 goto __label_478;}
24299 }
24300 if (!PyArray_Check(py_V477)) {
24301 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
24302 {
24303 __failure = 478;
24304 if (!PyErr_Occurred()) {
24305 PyErr_SetString(PyExc_RuntimeError,
24306 "Unexpected error in an Op's C code. "
24307 "No Python exception was set.");
24308 }
24309 goto __label_478;}
24310 }
24311 // We expect NPY_FLOAT64
24312 if (!PyArray_ISALIGNED((PyArrayObject*) py_V477)) {
24313 PyArrayObject * tmp = (PyArrayObject*) py_V477;
24314 PyErr_Format(PyExc_NotImplementedError,
24315 "expected an aligned array of type %ld "
24316 "(NPY_FLOAT64), got non-aligned array of type %ld"
24317 " with %ld dimensions, with 3 last dims "
24318 "%ld, %ld, %ld"
24319 " and 3 last strides %ld %ld, %ld.",
24320 (long int) NPY_FLOAT64,
24321 (long int) PyArray_TYPE((PyArrayObject*) py_V477),
24322 (long int) PyArray_NDIM(tmp),
24323 (long int) (PyArray_NDIM(tmp) >= 3 ?
24324 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
24325 (long int) (PyArray_NDIM(tmp) >= 2 ?
24326 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
24327 (long int) (PyArray_NDIM(tmp) >= 1 ?
24328 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
24329 (long int) (PyArray_NDIM(tmp) >= 3 ?
24330 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
24331 (long int) (PyArray_NDIM(tmp) >= 2 ?
24332 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
24333 (long int) (PyArray_NDIM(tmp) >= 1 ?
24334 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
24335 );
24336 {
24337 __failure = 478;
24338 if (!PyErr_Occurred()) {
24339 PyErr_SetString(PyExc_RuntimeError,
24340 "Unexpected error in an Op's C code. "
24341 "No Python exception was set.");
24342 }
24343 goto __label_478;}
24344 }
24345 // This is a TypeError to be consistent with DEBUG_MODE
24346 // Note: DEBUG_MODE also tells the name of the container
24347 if (PyArray_TYPE((PyArrayObject*) py_V477) != NPY_FLOAT64) {
24348 PyErr_Format(PyExc_TypeError,
24349 "expected type_num %d (NPY_FLOAT64) got %d",
24350 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V477));
24351 {
24352 __failure = 478;
24353 if (!PyErr_Occurred()) {
24354 PyErr_SetString(PyExc_RuntimeError,
24355 "Unexpected error in an Op's C code. "
24356 "No Python exception was set.");
24357 }
24358 goto __label_478;}
24359 }
24360
24361 V477 = (PyArrayObject*)(py_V477);
24362 Py_XINCREF(V477);
24363
24364 {
24365
24366 py_V479 = PyList_GET_ITEM(storage_V479, 0);
24367 {Py_XINCREF(py_V479);}
24368
24369 V479 = NULL;
24370 if (py_V479 == Py_None) {
24371 // We can either fail here or set V479 to NULL and rely on Ops
24372 // using tensors to handle the NULL case, but if they fail to do so
24373 // they'll end up with nasty segfaults, so this is public service.
24374 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
24375 {
24376 __failure = 480;
24377 if (!PyErr_Occurred()) {
24378 PyErr_SetString(PyExc_RuntimeError,
24379 "Unexpected error in an Op's C code. "
24380 "No Python exception was set.");
24381 }
24382 goto __label_480;}
24383 }
24384 if (!PyArray_Check(py_V479)) {
24385 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
24386 {
24387 __failure = 480;
24388 if (!PyErr_Occurred()) {
24389 PyErr_SetString(PyExc_RuntimeError,
24390 "Unexpected error in an Op's C code. "
24391 "No Python exception was set.");
24392 }
24393 goto __label_480;}
24394 }
24395 // We expect NPY_FLOAT64
24396 if (!PyArray_ISALIGNED((PyArrayObject*) py_V479)) {
24397 PyArrayObject * tmp = (PyArrayObject*) py_V479;
24398 PyErr_Format(PyExc_NotImplementedError,
24399 "expected an aligned array of type %ld "
24400 "(NPY_FLOAT64), got non-aligned array of type %ld"
24401 " with %ld dimensions, with 3 last dims "
24402 "%ld, %ld, %ld"
24403 " and 3 last strides %ld %ld, %ld.",
24404 (long int) NPY_FLOAT64,
24405 (long int) PyArray_TYPE((PyArrayObject*) py_V479),
24406 (long int) PyArray_NDIM(tmp),
24407 (long int) (PyArray_NDIM(tmp) >= 3 ?
24408 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
24409 (long int) (PyArray_NDIM(tmp) >= 2 ?
24410 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
24411 (long int) (PyArray_NDIM(tmp) >= 1 ?
24412 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
24413 (long int) (PyArray_NDIM(tmp) >= 3 ?
24414 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
24415 (long int) (PyArray_NDIM(tmp) >= 2 ?
24416 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
24417 (long int) (PyArray_NDIM(tmp) >= 1 ?
24418 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
24419 );
24420 {
24421 __failure = 480;
24422 if (!PyErr_Occurred()) {
24423 PyErr_SetString(PyExc_RuntimeError,
24424 "Unexpected error in an Op's C code. "
24425 "No Python exception was set.");
24426 }
24427 goto __label_480;}
24428 }
24429 // This is a TypeError to be consistent with DEBUG_MODE
24430 // Note: DEBUG_MODE also tells the name of the container
24431 if (PyArray_TYPE((PyArrayObject*) py_V479) != NPY_FLOAT64) {
24432 PyErr_Format(PyExc_TypeError,
24433 "expected type_num %d (NPY_FLOAT64) got %d",
24434 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V479));
24435 {
24436 __failure = 480;
24437 if (!PyErr_Occurred()) {
24438 PyErr_SetString(PyExc_RuntimeError,
24439 "Unexpected error in an Op's C code. "
24440 "No Python exception was set.");
24441 }
24442 goto __label_480;}
24443 }
24444
24445 V479 = (PyArrayObject*)(py_V479);
24446 Py_XINCREF(V479);
24447
24448 {
24449
24450 py_V481 = PyList_GET_ITEM(storage_V481, 0);
24451 {Py_XINCREF(py_V481);}
24452
24453 V481 = NULL;
24454 if (py_V481 == Py_None) {
24455 // We can either fail here or set V481 to NULL and rely on Ops
24456 // using tensors to handle the NULL case, but if they fail to do so
24457 // they'll end up with nasty segfaults, so this is public service.
24458 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
24459 {
24460 __failure = 482;
24461 if (!PyErr_Occurred()) {
24462 PyErr_SetString(PyExc_RuntimeError,
24463 "Unexpected error in an Op's C code. "
24464 "No Python exception was set.");
24465 }
24466 goto __label_482;}
24467 }
24468 if (!PyArray_Check(py_V481)) {
24469 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
24470 {
24471 __failure = 482;
24472 if (!PyErr_Occurred()) {
24473 PyErr_SetString(PyExc_RuntimeError,
24474 "Unexpected error in an Op's C code. "
24475 "No Python exception was set.");
24476 }
24477 goto __label_482;}
24478 }
24479 // We expect NPY_FLOAT64
24480 if (!PyArray_ISALIGNED((PyArrayObject*) py_V481)) {
24481 PyArrayObject * tmp = (PyArrayObject*) py_V481;
24482 PyErr_Format(PyExc_NotImplementedError,
24483 "expected an aligned array of type %ld "
24484 "(NPY_FLOAT64), got non-aligned array of type %ld"
24485 " with %ld dimensions, with 3 last dims "
24486 "%ld, %ld, %ld"
24487 " and 3 last strides %ld %ld, %ld.",
24488 (long int) NPY_FLOAT64,
24489 (long int) PyArray_TYPE((PyArrayObject*) py_V481),
24490 (long int) PyArray_NDIM(tmp),
24491 (long int) (PyArray_NDIM(tmp) >= 3 ?
24492 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
24493 (long int) (PyArray_NDIM(tmp) >= 2 ?
24494 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
24495 (long int) (PyArray_NDIM(tmp) >= 1 ?
24496 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
24497 (long int) (PyArray_NDIM(tmp) >= 3 ?
24498 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
24499 (long int) (PyArray_NDIM(tmp) >= 2 ?
24500 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
24501 (long int) (PyArray_NDIM(tmp) >= 1 ?
24502 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
24503 );
24504 {
24505 __failure = 482;
24506 if (!PyErr_Occurred()) {
24507 PyErr_SetString(PyExc_RuntimeError,
24508 "Unexpected error in an Op's C code. "
24509 "No Python exception was set.");
24510 }
24511 goto __label_482;}
24512 }
24513 // This is a TypeError to be consistent with DEBUG_MODE
24514 // Note: DEBUG_MODE also tells the name of the container
24515 if (PyArray_TYPE((PyArrayObject*) py_V481) != NPY_FLOAT64) {
24516 PyErr_Format(PyExc_TypeError,
24517 "expected type_num %d (NPY_FLOAT64) got %d",
24518 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V481));
24519 {
24520 __failure = 482;
24521 if (!PyErr_Occurred()) {
24522 PyErr_SetString(PyExc_RuntimeError,
24523 "Unexpected error in an Op's C code. "
24524 "No Python exception was set.");
24525 }
24526 goto __label_482;}
24527 }
24528
24529 V481 = (PyArrayObject*)(py_V481);
24530 Py_XINCREF(V481);
24531
24532 {
24533
24534 py_V483 = PyList_GET_ITEM(storage_V483, 0);
24535 {Py_XINCREF(py_V483);}
24536
24537 V483 = NULL;
24538 if (py_V483 == Py_None) {
24539 // We can either fail here or set V483 to NULL and rely on Ops
24540 // using tensors to handle the NULL case, but if they fail to do so
24541 // they'll end up with nasty segfaults, so this is public service.
24542 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
24543 {
24544 __failure = 484;
24545 if (!PyErr_Occurred()) {
24546 PyErr_SetString(PyExc_RuntimeError,
24547 "Unexpected error in an Op's C code. "
24548 "No Python exception was set.");
24549 }
24550 goto __label_484;}
24551 }
24552 if (!PyArray_Check(py_V483)) {
24553 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
24554 {
24555 __failure = 484;
24556 if (!PyErr_Occurred()) {
24557 PyErr_SetString(PyExc_RuntimeError,
24558 "Unexpected error in an Op's C code. "
24559 "No Python exception was set.");
24560 }
24561 goto __label_484;}
24562 }
24563 // We expect NPY_FLOAT64
24564 if (!PyArray_ISALIGNED((PyArrayObject*) py_V483)) {
24565 PyArrayObject * tmp = (PyArrayObject*) py_V483;
24566 PyErr_Format(PyExc_NotImplementedError,
24567 "expected an aligned array of type %ld "
24568 "(NPY_FLOAT64), got non-aligned array of type %ld"
24569 " with %ld dimensions, with 3 last dims "
24570 "%ld, %ld, %ld"
24571 " and 3 last strides %ld %ld, %ld.",
24572 (long int) NPY_FLOAT64,
24573 (long int) PyArray_TYPE((PyArrayObject*) py_V483),
24574 (long int) PyArray_NDIM(tmp),
24575 (long int) (PyArray_NDIM(tmp) >= 3 ?
24576 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
24577 (long int) (PyArray_NDIM(tmp) >= 2 ?
24578 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
24579 (long int) (PyArray_NDIM(tmp) >= 1 ?
24580 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
24581 (long int) (PyArray_NDIM(tmp) >= 3 ?
24582 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
24583 (long int) (PyArray_NDIM(tmp) >= 2 ?
24584 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
24585 (long int) (PyArray_NDIM(tmp) >= 1 ?
24586 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
24587 );
24588 {
24589 __failure = 484;
24590 if (!PyErr_Occurred()) {
24591 PyErr_SetString(PyExc_RuntimeError,
24592 "Unexpected error in an Op's C code. "
24593 "No Python exception was set.");
24594 }
24595 goto __label_484;}
24596 }
24597 // This is a TypeError to be consistent with DEBUG_MODE
24598 // Note: DEBUG_MODE also tells the name of the container
24599 if (PyArray_TYPE((PyArrayObject*) py_V483) != NPY_FLOAT64) {
24600 PyErr_Format(PyExc_TypeError,
24601 "expected type_num %d (NPY_FLOAT64) got %d",
24602 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V483));
24603 {
24604 __failure = 484;
24605 if (!PyErr_Occurred()) {
24606 PyErr_SetString(PyExc_RuntimeError,
24607 "Unexpected error in an Op's C code. "
24608 "No Python exception was set.");
24609 }
24610 goto __label_484;}
24611 }
24612
24613 V483 = (PyArrayObject*)(py_V483);
24614 Py_XINCREF(V483);
24615
24616 {
24617
24618 py_V485 = PyList_GET_ITEM(storage_V485, 0);
24619 {Py_XINCREF(py_V485);}
24620
24621 V485 = NULL;
24622 if (py_V485 == Py_None) {
24623 // We can either fail here or set V485 to NULL and rely on Ops
24624 // using tensors to handle the NULL case, but if they fail to do so
24625 // they'll end up with nasty segfaults, so this is public service.
24626 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
24627 {
24628 __failure = 486;
24629 if (!PyErr_Occurred()) {
24630 PyErr_SetString(PyExc_RuntimeError,
24631 "Unexpected error in an Op's C code. "
24632 "No Python exception was set.");
24633 }
24634 goto __label_486;}
24635 }
24636 if (!PyArray_Check(py_V485)) {
24637 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
24638 {
24639 __failure = 486;
24640 if (!PyErr_Occurred()) {
24641 PyErr_SetString(PyExc_RuntimeError,
24642 "Unexpected error in an Op's C code. "
24643 "No Python exception was set.");
24644 }
24645 goto __label_486;}
24646 }
24647 // We expect NPY_FLOAT64
24648 if (!PyArray_ISALIGNED((PyArrayObject*) py_V485)) {
24649 PyArrayObject * tmp = (PyArrayObject*) py_V485;
24650 PyErr_Format(PyExc_NotImplementedError,
24651 "expected an aligned array of type %ld "
24652 "(NPY_FLOAT64), got non-aligned array of type %ld"
24653 " with %ld dimensions, with 3 last dims "
24654 "%ld, %ld, %ld"
24655 " and 3 last strides %ld %ld, %ld.",
24656 (long int) NPY_FLOAT64,
24657 (long int) PyArray_TYPE((PyArrayObject*) py_V485),
24658 (long int) PyArray_NDIM(tmp),
24659 (long int) (PyArray_NDIM(tmp) >= 3 ?
24660 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
24661 (long int) (PyArray_NDIM(tmp) >= 2 ?
24662 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
24663 (long int) (PyArray_NDIM(tmp) >= 1 ?
24664 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
24665 (long int) (PyArray_NDIM(tmp) >= 3 ?
24666 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
24667 (long int) (PyArray_NDIM(tmp) >= 2 ?
24668 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
24669 (long int) (PyArray_NDIM(tmp) >= 1 ?
24670 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
24671 );
24672 {
24673 __failure = 486;
24674 if (!PyErr_Occurred()) {
24675 PyErr_SetString(PyExc_RuntimeError,
24676 "Unexpected error in an Op's C code. "
24677 "No Python exception was set.");
24678 }
24679 goto __label_486;}
24680 }
24681 // This is a TypeError to be consistent with DEBUG_MODE
24682 // Note: DEBUG_MODE also tells the name of the container
24683 if (PyArray_TYPE((PyArrayObject*) py_V485) != NPY_FLOAT64) {
24684 PyErr_Format(PyExc_TypeError,
24685 "expected type_num %d (NPY_FLOAT64) got %d",
24686 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V485));
24687 {
24688 __failure = 486;
24689 if (!PyErr_Occurred()) {
24690 PyErr_SetString(PyExc_RuntimeError,
24691 "Unexpected error in an Op's C code. "
24692 "No Python exception was set.");
24693 }
24694 goto __label_486;}
24695 }
24696
24697 V485 = (PyArrayObject*)(py_V485);
24698 Py_XINCREF(V485);
24699
24700 {
24701
24702 py_V487 = PyList_GET_ITEM(storage_V487, 0);
24703 {Py_XINCREF(py_V487);}
24704
24705 V487 = NULL;
24706 if (py_V487 == Py_None) {
24707 // We can either fail here or set V487 to NULL and rely on Ops
24708 // using tensors to handle the NULL case, but if they fail to do so
24709 // they'll end up with nasty segfaults, so this is public service.
24710 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
24711 {
24712 __failure = 488;
24713 if (!PyErr_Occurred()) {
24714 PyErr_SetString(PyExc_RuntimeError,
24715 "Unexpected error in an Op's C code. "
24716 "No Python exception was set.");
24717 }
24718 goto __label_488;}
24719 }
24720 if (!PyArray_Check(py_V487)) {
24721 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
24722 {
24723 __failure = 488;
24724 if (!PyErr_Occurred()) {
24725 PyErr_SetString(PyExc_RuntimeError,
24726 "Unexpected error in an Op's C code. "
24727 "No Python exception was set.");
24728 }
24729 goto __label_488;}
24730 }
24731 // We expect NPY_FLOAT64
24732 if (!PyArray_ISALIGNED((PyArrayObject*) py_V487)) {
24733 PyArrayObject * tmp = (PyArrayObject*) py_V487;
24734 PyErr_Format(PyExc_NotImplementedError,
24735 "expected an aligned array of type %ld "
24736 "(NPY_FLOAT64), got non-aligned array of type %ld"
24737 " with %ld dimensions, with 3 last dims "
24738 "%ld, %ld, %ld"
24739 " and 3 last strides %ld %ld, %ld.",
24740 (long int) NPY_FLOAT64,
24741 (long int) PyArray_TYPE((PyArrayObject*) py_V487),
24742 (long int) PyArray_NDIM(tmp),
24743 (long int) (PyArray_NDIM(tmp) >= 3 ?
24744 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
24745 (long int) (PyArray_NDIM(tmp) >= 2 ?
24746 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
24747 (long int) (PyArray_NDIM(tmp) >= 1 ?
24748 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
24749 (long int) (PyArray_NDIM(tmp) >= 3 ?
24750 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
24751 (long int) (PyArray_NDIM(tmp) >= 2 ?
24752 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
24753 (long int) (PyArray_NDIM(tmp) >= 1 ?
24754 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
24755 );
24756 {
24757 __failure = 488;
24758 if (!PyErr_Occurred()) {
24759 PyErr_SetString(PyExc_RuntimeError,
24760 "Unexpected error in an Op's C code. "
24761 "No Python exception was set.");
24762 }
24763 goto __label_488;}
24764 }
24765 // This is a TypeError to be consistent with DEBUG_MODE
24766 // Note: DEBUG_MODE also tells the name of the container
24767 if (PyArray_TYPE((PyArrayObject*) py_V487) != NPY_FLOAT64) {
24768 PyErr_Format(PyExc_TypeError,
24769 "expected type_num %d (NPY_FLOAT64) got %d",
24770 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V487));
24771 {
24772 __failure = 488;
24773 if (!PyErr_Occurred()) {
24774 PyErr_SetString(PyExc_RuntimeError,
24775 "Unexpected error in an Op's C code. "
24776 "No Python exception was set.");
24777 }
24778 goto __label_488;}
24779 }
24780
24781 V487 = (PyArrayObject*)(py_V487);
24782 Py_XINCREF(V487);
24783
24784 {
24785
24786 py_V489 = PyList_GET_ITEM(storage_V489, 0);
24787 {Py_XINCREF(py_V489);}
24788
24789 V489 = NULL;
24790 if (py_V489 == Py_None) {
24791 // We can either fail here or set V489 to NULL and rely on Ops
24792 // using tensors to handle the NULL case, but if they fail to do so
24793 // they'll end up with nasty segfaults, so this is public service.
24794 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
24795 {
24796 __failure = 490;
24797 if (!PyErr_Occurred()) {
24798 PyErr_SetString(PyExc_RuntimeError,
24799 "Unexpected error in an Op's C code. "
24800 "No Python exception was set.");
24801 }
24802 goto __label_490;}
24803 }
24804 if (!PyArray_Check(py_V489)) {
24805 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
24806 {
24807 __failure = 490;
24808 if (!PyErr_Occurred()) {
24809 PyErr_SetString(PyExc_RuntimeError,
24810 "Unexpected error in an Op's C code. "
24811 "No Python exception was set.");
24812 }
24813 goto __label_490;}
24814 }
24815 // We expect NPY_FLOAT64
24816 if (!PyArray_ISALIGNED((PyArrayObject*) py_V489)) {
24817 PyArrayObject * tmp = (PyArrayObject*) py_V489;
24818 PyErr_Format(PyExc_NotImplementedError,
24819 "expected an aligned array of type %ld "
24820 "(NPY_FLOAT64), got non-aligned array of type %ld"
24821 " with %ld dimensions, with 3 last dims "
24822 "%ld, %ld, %ld"
24823 " and 3 last strides %ld %ld, %ld.",
24824 (long int) NPY_FLOAT64,
24825 (long int) PyArray_TYPE((PyArrayObject*) py_V489),
24826 (long int) PyArray_NDIM(tmp),
24827 (long int) (PyArray_NDIM(tmp) >= 3 ?
24828 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
24829 (long int) (PyArray_NDIM(tmp) >= 2 ?
24830 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
24831 (long int) (PyArray_NDIM(tmp) >= 1 ?
24832 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
24833 (long int) (PyArray_NDIM(tmp) >= 3 ?
24834 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
24835 (long int) (PyArray_NDIM(tmp) >= 2 ?
24836 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
24837 (long int) (PyArray_NDIM(tmp) >= 1 ?
24838 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
24839 );
24840 {
24841 __failure = 490;
24842 if (!PyErr_Occurred()) {
24843 PyErr_SetString(PyExc_RuntimeError,
24844 "Unexpected error in an Op's C code. "
24845 "No Python exception was set.");
24846 }
24847 goto __label_490;}
24848 }
24849 // This is a TypeError to be consistent with DEBUG_MODE
24850 // Note: DEBUG_MODE also tells the name of the container
24851 if (PyArray_TYPE((PyArrayObject*) py_V489) != NPY_FLOAT64) {
24852 PyErr_Format(PyExc_TypeError,
24853 "expected type_num %d (NPY_FLOAT64) got %d",
24854 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V489));
24855 {
24856 __failure = 490;
24857 if (!PyErr_Occurred()) {
24858 PyErr_SetString(PyExc_RuntimeError,
24859 "Unexpected error in an Op's C code. "
24860 "No Python exception was set.");
24861 }
24862 goto __label_490;}
24863 }
24864
24865 V489 = (PyArrayObject*)(py_V489);
24866 Py_XINCREF(V489);
24867
24868 {
24869
24870 py_V491 = PyList_GET_ITEM(storage_V491, 0);
24871 {Py_XINCREF(py_V491);}
24872
24873 V491 = NULL;
24874 if (py_V491 == Py_None) {
24875 // We can either fail here or set V491 to NULL and rely on Ops
24876 // using tensors to handle the NULL case, but if they fail to do so
24877 // they'll end up with nasty segfaults, so this is public service.
24878 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
24879 {
24880 __failure = 492;
24881 if (!PyErr_Occurred()) {
24882 PyErr_SetString(PyExc_RuntimeError,
24883 "Unexpected error in an Op's C code. "
24884 "No Python exception was set.");
24885 }
24886 goto __label_492;}
24887 }
24888 if (!PyArray_Check(py_V491)) {
24889 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
24890 {
24891 __failure = 492;
24892 if (!PyErr_Occurred()) {
24893 PyErr_SetString(PyExc_RuntimeError,
24894 "Unexpected error in an Op's C code. "
24895 "No Python exception was set.");
24896 }
24897 goto __label_492;}
24898 }
24899 // We expect NPY_FLOAT64
24900 if (!PyArray_ISALIGNED((PyArrayObject*) py_V491)) {
24901 PyArrayObject * tmp = (PyArrayObject*) py_V491;
24902 PyErr_Format(PyExc_NotImplementedError,
24903 "expected an aligned array of type %ld "
24904 "(NPY_FLOAT64), got non-aligned array of type %ld"
24905 " with %ld dimensions, with 3 last dims "
24906 "%ld, %ld, %ld"
24907 " and 3 last strides %ld %ld, %ld.",
24908 (long int) NPY_FLOAT64,
24909 (long int) PyArray_TYPE((PyArrayObject*) py_V491),
24910 (long int) PyArray_NDIM(tmp),
24911 (long int) (PyArray_NDIM(tmp) >= 3 ?
24912 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
24913 (long int) (PyArray_NDIM(tmp) >= 2 ?
24914 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
24915 (long int) (PyArray_NDIM(tmp) >= 1 ?
24916 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
24917 (long int) (PyArray_NDIM(tmp) >= 3 ?
24918 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
24919 (long int) (PyArray_NDIM(tmp) >= 2 ?
24920 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
24921 (long int) (PyArray_NDIM(tmp) >= 1 ?
24922 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
24923 );
24924 {
24925 __failure = 492;
24926 if (!PyErr_Occurred()) {
24927 PyErr_SetString(PyExc_RuntimeError,
24928 "Unexpected error in an Op's C code. "
24929 "No Python exception was set.");
24930 }
24931 goto __label_492;}
24932 }
24933 // This is a TypeError to be consistent with DEBUG_MODE
24934 // Note: DEBUG_MODE also tells the name of the container
24935 if (PyArray_TYPE((PyArrayObject*) py_V491) != NPY_FLOAT64) {
24936 PyErr_Format(PyExc_TypeError,
24937 "expected type_num %d (NPY_FLOAT64) got %d",
24938 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V491));
24939 {
24940 __failure = 492;
24941 if (!PyErr_Occurred()) {
24942 PyErr_SetString(PyExc_RuntimeError,
24943 "Unexpected error in an Op's C code. "
24944 "No Python exception was set.");
24945 }
24946 goto __label_492;}
24947 }
24948
24949 V491 = (PyArrayObject*)(py_V491);
24950 Py_XINCREF(V491);
24951
24952 {
24953
24954 py_V493 = PyList_GET_ITEM(storage_V493, 0);
24955 {Py_XINCREF(py_V493);}
24956
24957 V493 = NULL;
24958 if (py_V493 == Py_None) {
24959 // We can either fail here or set V493 to NULL and rely on Ops
24960 // using tensors to handle the NULL case, but if they fail to do so
24961 // they'll end up with nasty segfaults, so this is public service.
24962 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
24963 {
24964 __failure = 494;
24965 if (!PyErr_Occurred()) {
24966 PyErr_SetString(PyExc_RuntimeError,
24967 "Unexpected error in an Op's C code. "
24968 "No Python exception was set.");
24969 }
24970 goto __label_494;}
24971 }
24972 if (!PyArray_Check(py_V493)) {
24973 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
24974 {
24975 __failure = 494;
24976 if (!PyErr_Occurred()) {
24977 PyErr_SetString(PyExc_RuntimeError,
24978 "Unexpected error in an Op's C code. "
24979 "No Python exception was set.");
24980 }
24981 goto __label_494;}
24982 }
24983 // We expect NPY_FLOAT64
24984 if (!PyArray_ISALIGNED((PyArrayObject*) py_V493)) {
24985 PyArrayObject * tmp = (PyArrayObject*) py_V493;
24986 PyErr_Format(PyExc_NotImplementedError,
24987 "expected an aligned array of type %ld "
24988 "(NPY_FLOAT64), got non-aligned array of type %ld"
24989 " with %ld dimensions, with 3 last dims "
24990 "%ld, %ld, %ld"
24991 " and 3 last strides %ld %ld, %ld.",
24992 (long int) NPY_FLOAT64,
24993 (long int) PyArray_TYPE((PyArrayObject*) py_V493),
24994 (long int) PyArray_NDIM(tmp),
24995 (long int) (PyArray_NDIM(tmp) >= 3 ?
24996 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
24997 (long int) (PyArray_NDIM(tmp) >= 2 ?
24998 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
24999 (long int) (PyArray_NDIM(tmp) >= 1 ?
25000 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
25001 (long int) (PyArray_NDIM(tmp) >= 3 ?
25002 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
25003 (long int) (PyArray_NDIM(tmp) >= 2 ?
25004 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
25005 (long int) (PyArray_NDIM(tmp) >= 1 ?
25006 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
25007 );
25008 {
25009 __failure = 494;
25010 if (!PyErr_Occurred()) {
25011 PyErr_SetString(PyExc_RuntimeError,
25012 "Unexpected error in an Op's C code. "
25013 "No Python exception was set.");
25014 }
25015 goto __label_494;}
25016 }
25017 // This is a TypeError to be consistent with DEBUG_MODE
25018 // Note: DEBUG_MODE also tells the name of the container
25019 if (PyArray_TYPE((PyArrayObject*) py_V493) != NPY_FLOAT64) {
25020 PyErr_Format(PyExc_TypeError,
25021 "expected type_num %d (NPY_FLOAT64) got %d",
25022 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V493));
25023 {
25024 __failure = 494;
25025 if (!PyErr_Occurred()) {
25026 PyErr_SetString(PyExc_RuntimeError,
25027 "Unexpected error in an Op's C code. "
25028 "No Python exception was set.");
25029 }
25030 goto __label_494;}
25031 }
25032
25033 V493 = (PyArrayObject*)(py_V493);
25034 Py_XINCREF(V493);
25035
25036 {
25037
25038 py_V495 = PyList_GET_ITEM(storage_V495, 0);
25039 {Py_XINCREF(py_V495);}
25040
25041 V495 = NULL;
25042 if (py_V495 == Py_None) {
25043 // We can either fail here or set V495 to NULL and rely on Ops
25044 // using tensors to handle the NULL case, but if they fail to do so
25045 // they'll end up with nasty segfaults, so this is public service.
25046 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
25047 {
25048 __failure = 496;
25049 if (!PyErr_Occurred()) {
25050 PyErr_SetString(PyExc_RuntimeError,
25051 "Unexpected error in an Op's C code. "
25052 "No Python exception was set.");
25053 }
25054 goto __label_496;}
25055 }
25056 if (!PyArray_Check(py_V495)) {
25057 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
25058 {
25059 __failure = 496;
25060 if (!PyErr_Occurred()) {
25061 PyErr_SetString(PyExc_RuntimeError,
25062 "Unexpected error in an Op's C code. "
25063 "No Python exception was set.");
25064 }
25065 goto __label_496;}
25066 }
25067 // We expect NPY_FLOAT64
25068 if (!PyArray_ISALIGNED((PyArrayObject*) py_V495)) {
25069 PyArrayObject * tmp = (PyArrayObject*) py_V495;
25070 PyErr_Format(PyExc_NotImplementedError,
25071 "expected an aligned array of type %ld "
25072 "(NPY_FLOAT64), got non-aligned array of type %ld"
25073 " with %ld dimensions, with 3 last dims "
25074 "%ld, %ld, %ld"
25075 " and 3 last strides %ld %ld, %ld.",
25076 (long int) NPY_FLOAT64,
25077 (long int) PyArray_TYPE((PyArrayObject*) py_V495),
25078 (long int) PyArray_NDIM(tmp),
25079 (long int) (PyArray_NDIM(tmp) >= 3 ?
25080 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
25081 (long int) (PyArray_NDIM(tmp) >= 2 ?
25082 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
25083 (long int) (PyArray_NDIM(tmp) >= 1 ?
25084 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
25085 (long int) (PyArray_NDIM(tmp) >= 3 ?
25086 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
25087 (long int) (PyArray_NDIM(tmp) >= 2 ?
25088 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
25089 (long int) (PyArray_NDIM(tmp) >= 1 ?
25090 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
25091 );
25092 {
25093 __failure = 496;
25094 if (!PyErr_Occurred()) {
25095 PyErr_SetString(PyExc_RuntimeError,
25096 "Unexpected error in an Op's C code. "
25097 "No Python exception was set.");
25098 }
25099 goto __label_496;}
25100 }
25101 // This is a TypeError to be consistent with DEBUG_MODE
25102 // Note: DEBUG_MODE also tells the name of the container
25103 if (PyArray_TYPE((PyArrayObject*) py_V495) != NPY_FLOAT64) {
25104 PyErr_Format(PyExc_TypeError,
25105 "expected type_num %d (NPY_FLOAT64) got %d",
25106 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V495));
25107 {
25108 __failure = 496;
25109 if (!PyErr_Occurred()) {
25110 PyErr_SetString(PyExc_RuntimeError,
25111 "Unexpected error in an Op's C code. "
25112 "No Python exception was set.");
25113 }
25114 goto __label_496;}
25115 }
25116
25117 V495 = (PyArrayObject*)(py_V495);
25118 Py_XINCREF(V495);
25119
25120 {
25121
25122 py_V497 = PyList_GET_ITEM(storage_V497, 0);
25123 {Py_XINCREF(py_V497);}
25124
25125 V497 = NULL;
25126 if (py_V497 == Py_None) {
25127 // We can either fail here or set V497 to NULL and rely on Ops
25128 // using tensors to handle the NULL case, but if they fail to do so
25129 // they'll end up with nasty segfaults, so this is public service.
25130 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
25131 {
25132 __failure = 498;
25133 if (!PyErr_Occurred()) {
25134 PyErr_SetString(PyExc_RuntimeError,
25135 "Unexpected error in an Op's C code. "
25136 "No Python exception was set.");
25137 }
25138 goto __label_498;}
25139 }
25140 if (!PyArray_Check(py_V497)) {
25141 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
25142 {
25143 __failure = 498;
25144 if (!PyErr_Occurred()) {
25145 PyErr_SetString(PyExc_RuntimeError,
25146 "Unexpected error in an Op's C code. "
25147 "No Python exception was set.");
25148 }
25149 goto __label_498;}
25150 }
25151 // We expect NPY_FLOAT64
25152 if (!PyArray_ISALIGNED((PyArrayObject*) py_V497)) {
25153 PyArrayObject * tmp = (PyArrayObject*) py_V497;
25154 PyErr_Format(PyExc_NotImplementedError,
25155 "expected an aligned array of type %ld "
25156 "(NPY_FLOAT64), got non-aligned array of type %ld"
25157 " with %ld dimensions, with 3 last dims "
25158 "%ld, %ld, %ld"
25159 " and 3 last strides %ld %ld, %ld.",
25160 (long int) NPY_FLOAT64,
25161 (long int) PyArray_TYPE((PyArrayObject*) py_V497),
25162 (long int) PyArray_NDIM(tmp),
25163 (long int) (PyArray_NDIM(tmp) >= 3 ?
25164 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
25165 (long int) (PyArray_NDIM(tmp) >= 2 ?
25166 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
25167 (long int) (PyArray_NDIM(tmp) >= 1 ?
25168 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
25169 (long int) (PyArray_NDIM(tmp) >= 3 ?
25170 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
25171 (long int) (PyArray_NDIM(tmp) >= 2 ?
25172 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
25173 (long int) (PyArray_NDIM(tmp) >= 1 ?
25174 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
25175 );
25176 {
25177 __failure = 498;
25178 if (!PyErr_Occurred()) {
25179 PyErr_SetString(PyExc_RuntimeError,
25180 "Unexpected error in an Op's C code. "
25181 "No Python exception was set.");
25182 }
25183 goto __label_498;}
25184 }
25185 // This is a TypeError to be consistent with DEBUG_MODE
25186 // Note: DEBUG_MODE also tells the name of the container
25187 if (PyArray_TYPE((PyArrayObject*) py_V497) != NPY_FLOAT64) {
25188 PyErr_Format(PyExc_TypeError,
25189 "expected type_num %d (NPY_FLOAT64) got %d",
25190 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V497));
25191 {
25192 __failure = 498;
25193 if (!PyErr_Occurred()) {
25194 PyErr_SetString(PyExc_RuntimeError,
25195 "Unexpected error in an Op's C code. "
25196 "No Python exception was set.");
25197 }
25198 goto __label_498;}
25199 }
25200
25201 V497 = (PyArrayObject*)(py_V497);
25202 Py_XINCREF(V497);
25203
25204 {
25205
25206 py_V499 = PyList_GET_ITEM(storage_V499, 0);
25207 {Py_XINCREF(py_V499);}
25208
25209 V499 = NULL;
25210 if (py_V499 == Py_None) {
25211 // We can either fail here or set V499 to NULL and rely on Ops
25212 // using tensors to handle the NULL case, but if they fail to do so
25213 // they'll end up with nasty segfaults, so this is public service.
25214 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
25215 {
25216 __failure = 500;
25217 if (!PyErr_Occurred()) {
25218 PyErr_SetString(PyExc_RuntimeError,
25219 "Unexpected error in an Op's C code. "
25220 "No Python exception was set.");
25221 }
25222 goto __label_500;}
25223 }
25224 if (!PyArray_Check(py_V499)) {
25225 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
25226 {
25227 __failure = 500;
25228 if (!PyErr_Occurred()) {
25229 PyErr_SetString(PyExc_RuntimeError,
25230 "Unexpected error in an Op's C code. "
25231 "No Python exception was set.");
25232 }
25233 goto __label_500;}
25234 }
25235 // We expect NPY_FLOAT64
25236 if (!PyArray_ISALIGNED((PyArrayObject*) py_V499)) {
25237 PyArrayObject * tmp = (PyArrayObject*) py_V499;
25238 PyErr_Format(PyExc_NotImplementedError,
25239 "expected an aligned array of type %ld "
25240 "(NPY_FLOAT64), got non-aligned array of type %ld"
25241 " with %ld dimensions, with 3 last dims "
25242 "%ld, %ld, %ld"
25243 " and 3 last strides %ld %ld, %ld.",
25244 (long int) NPY_FLOAT64,
25245 (long int) PyArray_TYPE((PyArrayObject*) py_V499),
25246 (long int) PyArray_NDIM(tmp),
25247 (long int) (PyArray_NDIM(tmp) >= 3 ?
25248 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
25249 (long int) (PyArray_NDIM(tmp) >= 2 ?
25250 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
25251 (long int) (PyArray_NDIM(tmp) >= 1 ?
25252 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
25253 (long int) (PyArray_NDIM(tmp) >= 3 ?
25254 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
25255 (long int) (PyArray_NDIM(tmp) >= 2 ?
25256 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
25257 (long int) (PyArray_NDIM(tmp) >= 1 ?
25258 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
25259 );
25260 {
25261 __failure = 500;
25262 if (!PyErr_Occurred()) {
25263 PyErr_SetString(PyExc_RuntimeError,
25264 "Unexpected error in an Op's C code. "
25265 "No Python exception was set.");
25266 }
25267 goto __label_500;}
25268 }
25269 // This is a TypeError to be consistent with DEBUG_MODE
25270 // Note: DEBUG_MODE also tells the name of the container
25271 if (PyArray_TYPE((PyArrayObject*) py_V499) != NPY_FLOAT64) {
25272 PyErr_Format(PyExc_TypeError,
25273 "expected type_num %d (NPY_FLOAT64) got %d",
25274 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V499));
25275 {
25276 __failure = 500;
25277 if (!PyErr_Occurred()) {
25278 PyErr_SetString(PyExc_RuntimeError,
25279 "Unexpected error in an Op's C code. "
25280 "No Python exception was set.");
25281 }
25282 goto __label_500;}
25283 }
25284
25285 V499 = (PyArrayObject*)(py_V499);
25286 Py_XINCREF(V499);
25287
25288 {
25289
25290 py_V501 = PyList_GET_ITEM(storage_V501, 0);
25291 {Py_XINCREF(py_V501);}
25292
25293 V501 = NULL;
25294 if (py_V501 == Py_None) {
25295 // We can either fail here or set V501 to NULL and rely on Ops
25296 // using tensors to handle the NULL case, but if they fail to do so
25297 // they'll end up with nasty segfaults, so this is public service.
25298 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
25299 {
25300 __failure = 502;
25301 if (!PyErr_Occurred()) {
25302 PyErr_SetString(PyExc_RuntimeError,
25303 "Unexpected error in an Op's C code. "
25304 "No Python exception was set.");
25305 }
25306 goto __label_502;}
25307 }
25308 if (!PyArray_Check(py_V501)) {
25309 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
25310 {
25311 __failure = 502;
25312 if (!PyErr_Occurred()) {
25313 PyErr_SetString(PyExc_RuntimeError,
25314 "Unexpected error in an Op's C code. "
25315 "No Python exception was set.");
25316 }
25317 goto __label_502;}
25318 }
25319 // We expect NPY_FLOAT64
25320 if (!PyArray_ISALIGNED((PyArrayObject*) py_V501)) {
25321 PyArrayObject * tmp = (PyArrayObject*) py_V501;
25322 PyErr_Format(PyExc_NotImplementedError,
25323 "expected an aligned array of type %ld "
25324 "(NPY_FLOAT64), got non-aligned array of type %ld"
25325 " with %ld dimensions, with 3 last dims "
25326 "%ld, %ld, %ld"
25327 " and 3 last strides %ld %ld, %ld.",
25328 (long int) NPY_FLOAT64,
25329 (long int) PyArray_TYPE((PyArrayObject*) py_V501),
25330 (long int) PyArray_NDIM(tmp),
25331 (long int) (PyArray_NDIM(tmp) >= 3 ?
25332 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
25333 (long int) (PyArray_NDIM(tmp) >= 2 ?
25334 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
25335 (long int) (PyArray_NDIM(tmp) >= 1 ?
25336 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
25337 (long int) (PyArray_NDIM(tmp) >= 3 ?
25338 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
25339 (long int) (PyArray_NDIM(tmp) >= 2 ?
25340 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
25341 (long int) (PyArray_NDIM(tmp) >= 1 ?
25342 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
25343 );
25344 {
25345 __failure = 502;
25346 if (!PyErr_Occurred()) {
25347 PyErr_SetString(PyExc_RuntimeError,
25348 "Unexpected error in an Op's C code. "
25349 "No Python exception was set.");
25350 }
25351 goto __label_502;}
25352 }
25353 // This is a TypeError to be consistent with DEBUG_MODE
25354 // Note: DEBUG_MODE also tells the name of the container
25355 if (PyArray_TYPE((PyArrayObject*) py_V501) != NPY_FLOAT64) {
25356 PyErr_Format(PyExc_TypeError,
25357 "expected type_num %d (NPY_FLOAT64) got %d",
25358 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V501));
25359 {
25360 __failure = 502;
25361 if (!PyErr_Occurred()) {
25362 PyErr_SetString(PyExc_RuntimeError,
25363 "Unexpected error in an Op's C code. "
25364 "No Python exception was set.");
25365 }
25366 goto __label_502;}
25367 }
25368
25369 V501 = (PyArrayObject*)(py_V501);
25370 Py_XINCREF(V501);
25371
25372 {
25373
25374 py_V503 = PyList_GET_ITEM(storage_V503, 0);
25375 {Py_XINCREF(py_V503);}
25376
25377 V503 = NULL;
25378 if (py_V503 == Py_None) {
25379 // We can either fail here or set V503 to NULL and rely on Ops
25380 // using tensors to handle the NULL case, but if they fail to do so
25381 // they'll end up with nasty segfaults, so this is public service.
25382 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
25383 {
25384 __failure = 504;
25385 if (!PyErr_Occurred()) {
25386 PyErr_SetString(PyExc_RuntimeError,
25387 "Unexpected error in an Op's C code. "
25388 "No Python exception was set.");
25389 }
25390 goto __label_504;}
25391 }
25392 if (!PyArray_Check(py_V503)) {
25393 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
25394 {
25395 __failure = 504;
25396 if (!PyErr_Occurred()) {
25397 PyErr_SetString(PyExc_RuntimeError,
25398 "Unexpected error in an Op's C code. "
25399 "No Python exception was set.");
25400 }
25401 goto __label_504;}
25402 }
25403 // We expect NPY_FLOAT64
25404 if (!PyArray_ISALIGNED((PyArrayObject*) py_V503)) {
25405 PyArrayObject * tmp = (PyArrayObject*) py_V503;
25406 PyErr_Format(PyExc_NotImplementedError,
25407 "expected an aligned array of type %ld "
25408 "(NPY_FLOAT64), got non-aligned array of type %ld"
25409 " with %ld dimensions, with 3 last dims "
25410 "%ld, %ld, %ld"
25411 " and 3 last strides %ld %ld, %ld.",
25412 (long int) NPY_FLOAT64,
25413 (long int) PyArray_TYPE((PyArrayObject*) py_V503),
25414 (long int) PyArray_NDIM(tmp),
25415 (long int) (PyArray_NDIM(tmp) >= 3 ?
25416 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
25417 (long int) (PyArray_NDIM(tmp) >= 2 ?
25418 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
25419 (long int) (PyArray_NDIM(tmp) >= 1 ?
25420 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
25421 (long int) (PyArray_NDIM(tmp) >= 3 ?
25422 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
25423 (long int) (PyArray_NDIM(tmp) >= 2 ?
25424 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
25425 (long int) (PyArray_NDIM(tmp) >= 1 ?
25426 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
25427 );
25428 {
25429 __failure = 504;
25430 if (!PyErr_Occurred()) {
25431 PyErr_SetString(PyExc_RuntimeError,
25432 "Unexpected error in an Op's C code. "
25433 "No Python exception was set.");
25434 }
25435 goto __label_504;}
25436 }
25437 // This is a TypeError to be consistent with DEBUG_MODE
25438 // Note: DEBUG_MODE also tells the name of the container
25439 if (PyArray_TYPE((PyArrayObject*) py_V503) != NPY_FLOAT64) {
25440 PyErr_Format(PyExc_TypeError,
25441 "expected type_num %d (NPY_FLOAT64) got %d",
25442 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V503));
25443 {
25444 __failure = 504;
25445 if (!PyErr_Occurred()) {
25446 PyErr_SetString(PyExc_RuntimeError,
25447 "Unexpected error in an Op's C code. "
25448 "No Python exception was set.");
25449 }
25450 goto __label_504;}
25451 }
25452
25453 V503 = (PyArrayObject*)(py_V503);
25454 Py_XINCREF(V503);
25455
25456 {
25457
25458 py_V505 = PyList_GET_ITEM(storage_V505, 0);
25459 {Py_XINCREF(py_V505);}
25460
25461 V505 = NULL;
25462 if (py_V505 == Py_None) {
25463 // We can either fail here or set V505 to NULL and rely on Ops
25464 // using tensors to handle the NULL case, but if they fail to do so
25465 // they'll end up with nasty segfaults, so this is public service.
25466 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
25467 {
25468 __failure = 506;
25469 if (!PyErr_Occurred()) {
25470 PyErr_SetString(PyExc_RuntimeError,
25471 "Unexpected error in an Op's C code. "
25472 "No Python exception was set.");
25473 }
25474 goto __label_506;}
25475 }
25476 if (!PyArray_Check(py_V505)) {
25477 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
25478 {
25479 __failure = 506;
25480 if (!PyErr_Occurred()) {
25481 PyErr_SetString(PyExc_RuntimeError,
25482 "Unexpected error in an Op's C code. "
25483 "No Python exception was set.");
25484 }
25485 goto __label_506;}
25486 }
25487 // We expect NPY_FLOAT64
25488 if (!PyArray_ISALIGNED((PyArrayObject*) py_V505)) {
25489 PyArrayObject * tmp = (PyArrayObject*) py_V505;
25490 PyErr_Format(PyExc_NotImplementedError,
25491 "expected an aligned array of type %ld "
25492 "(NPY_FLOAT64), got non-aligned array of type %ld"
25493 " with %ld dimensions, with 3 last dims "
25494 "%ld, %ld, %ld"
25495 " and 3 last strides %ld %ld, %ld.",
25496 (long int) NPY_FLOAT64,
25497 (long int) PyArray_TYPE((PyArrayObject*) py_V505),
25498 (long int) PyArray_NDIM(tmp),
25499 (long int) (PyArray_NDIM(tmp) >= 3 ?
25500 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
25501 (long int) (PyArray_NDIM(tmp) >= 2 ?
25502 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
25503 (long int) (PyArray_NDIM(tmp) >= 1 ?
25504 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
25505 (long int) (PyArray_NDIM(tmp) >= 3 ?
25506 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
25507 (long int) (PyArray_NDIM(tmp) >= 2 ?
25508 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
25509 (long int) (PyArray_NDIM(tmp) >= 1 ?
25510 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
25511 );
25512 {
25513 __failure = 506;
25514 if (!PyErr_Occurred()) {
25515 PyErr_SetString(PyExc_RuntimeError,
25516 "Unexpected error in an Op's C code. "
25517 "No Python exception was set.");
25518 }
25519 goto __label_506;}
25520 }
25521 // This is a TypeError to be consistent with DEBUG_MODE
25522 // Note: DEBUG_MODE also tells the name of the container
25523 if (PyArray_TYPE((PyArrayObject*) py_V505) != NPY_FLOAT64) {
25524 PyErr_Format(PyExc_TypeError,
25525 "expected type_num %d (NPY_FLOAT64) got %d",
25526 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V505));
25527 {
25528 __failure = 506;
25529 if (!PyErr_Occurred()) {
25530 PyErr_SetString(PyExc_RuntimeError,
25531 "Unexpected error in an Op's C code. "
25532 "No Python exception was set.");
25533 }
25534 goto __label_506;}
25535 }
25536
25537 V505 = (PyArrayObject*)(py_V505);
25538 Py_XINCREF(V505);
25539
25540 {
25541
25542 py_V507 = PyList_GET_ITEM(storage_V507, 0);
25543 {Py_XINCREF(py_V507);}
25544
25545 V507 = NULL;
25546 if (py_V507 == Py_None) {
25547 // We can either fail here or set V507 to NULL and rely on Ops
25548 // using tensors to handle the NULL case, but if they fail to do so
25549 // they'll end up with nasty segfaults, so this is public service.
25550 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
25551 {
25552 __failure = 508;
25553 if (!PyErr_Occurred()) {
25554 PyErr_SetString(PyExc_RuntimeError,
25555 "Unexpected error in an Op's C code. "
25556 "No Python exception was set.");
25557 }
25558 goto __label_508;}
25559 }
25560 if (!PyArray_Check(py_V507)) {
25561 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
25562 {
25563 __failure = 508;
25564 if (!PyErr_Occurred()) {
25565 PyErr_SetString(PyExc_RuntimeError,
25566 "Unexpected error in an Op's C code. "
25567 "No Python exception was set.");
25568 }
25569 goto __label_508;}
25570 }
25571 // We expect NPY_FLOAT64
25572 if (!PyArray_ISALIGNED((PyArrayObject*) py_V507)) {
25573 PyArrayObject * tmp = (PyArrayObject*) py_V507;
25574 PyErr_Format(PyExc_NotImplementedError,
25575 "expected an aligned array of type %ld "
25576 "(NPY_FLOAT64), got non-aligned array of type %ld"
25577 " with %ld dimensions, with 3 last dims "
25578 "%ld, %ld, %ld"
25579 " and 3 last strides %ld %ld, %ld.",
25580 (long int) NPY_FLOAT64,
25581 (long int) PyArray_TYPE((PyArrayObject*) py_V507),
25582 (long int) PyArray_NDIM(tmp),
25583 (long int) (PyArray_NDIM(tmp) >= 3 ?
25584 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
25585 (long int) (PyArray_NDIM(tmp) >= 2 ?
25586 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
25587 (long int) (PyArray_NDIM(tmp) >= 1 ?
25588 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
25589 (long int) (PyArray_NDIM(tmp) >= 3 ?
25590 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
25591 (long int) (PyArray_NDIM(tmp) >= 2 ?
25592 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
25593 (long int) (PyArray_NDIM(tmp) >= 1 ?
25594 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
25595 );
25596 {
25597 __failure = 508;
25598 if (!PyErr_Occurred()) {
25599 PyErr_SetString(PyExc_RuntimeError,
25600 "Unexpected error in an Op's C code. "
25601 "No Python exception was set.");
25602 }
25603 goto __label_508;}
25604 }
25605 // This is a TypeError to be consistent with DEBUG_MODE
25606 // Note: DEBUG_MODE also tells the name of the container
25607 if (PyArray_TYPE((PyArrayObject*) py_V507) != NPY_FLOAT64) {
25608 PyErr_Format(PyExc_TypeError,
25609 "expected type_num %d (NPY_FLOAT64) got %d",
25610 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V507));
25611 {
25612 __failure = 508;
25613 if (!PyErr_Occurred()) {
25614 PyErr_SetString(PyExc_RuntimeError,
25615 "Unexpected error in an Op's C code. "
25616 "No Python exception was set.");
25617 }
25618 goto __label_508;}
25619 }
25620
25621 V507 = (PyArrayObject*)(py_V507);
25622 Py_XINCREF(V507);
25623
25624 {
25625
25626 py_V509 = PyList_GET_ITEM(storage_V509, 0);
25627 {Py_XINCREF(py_V509);}
25628
25629 V509 = NULL;
25630 if (py_V509 == Py_None) {
25631 // We can either fail here or set V509 to NULL and rely on Ops
25632 // using tensors to handle the NULL case, but if they fail to do so
25633 // they'll end up with nasty segfaults, so this is public service.
25634 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
25635 {
25636 __failure = 510;
25637 if (!PyErr_Occurred()) {
25638 PyErr_SetString(PyExc_RuntimeError,
25639 "Unexpected error in an Op's C code. "
25640 "No Python exception was set.");
25641 }
25642 goto __label_510;}
25643 }
25644 if (!PyArray_Check(py_V509)) {
25645 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
25646 {
25647 __failure = 510;
25648 if (!PyErr_Occurred()) {
25649 PyErr_SetString(PyExc_RuntimeError,
25650 "Unexpected error in an Op's C code. "
25651 "No Python exception was set.");
25652 }
25653 goto __label_510;}
25654 }
25655 // We expect NPY_FLOAT64
25656 if (!PyArray_ISALIGNED((PyArrayObject*) py_V509)) {
25657 PyArrayObject * tmp = (PyArrayObject*) py_V509;
25658 PyErr_Format(PyExc_NotImplementedError,
25659 "expected an aligned array of type %ld "
25660 "(NPY_FLOAT64), got non-aligned array of type %ld"
25661 " with %ld dimensions, with 3 last dims "
25662 "%ld, %ld, %ld"
25663 " and 3 last strides %ld %ld, %ld.",
25664 (long int) NPY_FLOAT64,
25665 (long int) PyArray_TYPE((PyArrayObject*) py_V509),
25666 (long int) PyArray_NDIM(tmp),
25667 (long int) (PyArray_NDIM(tmp) >= 3 ?
25668 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
25669 (long int) (PyArray_NDIM(tmp) >= 2 ?
25670 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
25671 (long int) (PyArray_NDIM(tmp) >= 1 ?
25672 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
25673 (long int) (PyArray_NDIM(tmp) >= 3 ?
25674 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
25675 (long int) (PyArray_NDIM(tmp) >= 2 ?
25676 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
25677 (long int) (PyArray_NDIM(tmp) >= 1 ?
25678 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
25679 );
25680 {
25681 __failure = 510;
25682 if (!PyErr_Occurred()) {
25683 PyErr_SetString(PyExc_RuntimeError,
25684 "Unexpected error in an Op's C code. "
25685 "No Python exception was set.");
25686 }
25687 goto __label_510;}
25688 }
25689 // This is a TypeError to be consistent with DEBUG_MODE
25690 // Note: DEBUG_MODE also tells the name of the container
25691 if (PyArray_TYPE((PyArrayObject*) py_V509) != NPY_FLOAT64) {
25692 PyErr_Format(PyExc_TypeError,
25693 "expected type_num %d (NPY_FLOAT64) got %d",
25694 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V509));
25695 {
25696 __failure = 510;
25697 if (!PyErr_Occurred()) {
25698 PyErr_SetString(PyExc_RuntimeError,
25699 "Unexpected error in an Op's C code. "
25700 "No Python exception was set.");
25701 }
25702 goto __label_510;}
25703 }
25704
25705 V509 = (PyArrayObject*)(py_V509);
25706 Py_XINCREF(V509);
25707
25708 {
25709
25710 py_V511 = PyList_GET_ITEM(storage_V511, 0);
25711 {Py_XINCREF(py_V511);}
25712
25713 V511 = NULL;
25714 if (py_V511 == Py_None) {
25715 // We can either fail here or set V511 to NULL and rely on Ops
25716 // using tensors to handle the NULL case, but if they fail to do so
25717 // they'll end up with nasty segfaults, so this is public service.
25718 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
25719 {
25720 __failure = 512;
25721 if (!PyErr_Occurred()) {
25722 PyErr_SetString(PyExc_RuntimeError,
25723 "Unexpected error in an Op's C code. "
25724 "No Python exception was set.");
25725 }
25726 goto __label_512;}
25727 }
25728 if (!PyArray_Check(py_V511)) {
25729 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
25730 {
25731 __failure = 512;
25732 if (!PyErr_Occurred()) {
25733 PyErr_SetString(PyExc_RuntimeError,
25734 "Unexpected error in an Op's C code. "
25735 "No Python exception was set.");
25736 }
25737 goto __label_512;}
25738 }
25739 // We expect NPY_FLOAT64
25740 if (!PyArray_ISALIGNED((PyArrayObject*) py_V511)) {
25741 PyArrayObject * tmp = (PyArrayObject*) py_V511;
25742 PyErr_Format(PyExc_NotImplementedError,
25743 "expected an aligned array of type %ld "
25744 "(NPY_FLOAT64), got non-aligned array of type %ld"
25745 " with %ld dimensions, with 3 last dims "
25746 "%ld, %ld, %ld"
25747 " and 3 last strides %ld %ld, %ld.",
25748 (long int) NPY_FLOAT64,
25749 (long int) PyArray_TYPE((PyArrayObject*) py_V511),
25750 (long int) PyArray_NDIM(tmp),
25751 (long int) (PyArray_NDIM(tmp) >= 3 ?
25752 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
25753 (long int) (PyArray_NDIM(tmp) >= 2 ?
25754 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
25755 (long int) (PyArray_NDIM(tmp) >= 1 ?
25756 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
25757 (long int) (PyArray_NDIM(tmp) >= 3 ?
25758 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
25759 (long int) (PyArray_NDIM(tmp) >= 2 ?
25760 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
25761 (long int) (PyArray_NDIM(tmp) >= 1 ?
25762 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
25763 );
25764 {
25765 __failure = 512;
25766 if (!PyErr_Occurred()) {
25767 PyErr_SetString(PyExc_RuntimeError,
25768 "Unexpected error in an Op's C code. "
25769 "No Python exception was set.");
25770 }
25771 goto __label_512;}
25772 }
25773 // This is a TypeError to be consistent with DEBUG_MODE
25774 // Note: DEBUG_MODE also tells the name of the container
25775 if (PyArray_TYPE((PyArrayObject*) py_V511) != NPY_FLOAT64) {
25776 PyErr_Format(PyExc_TypeError,
25777 "expected type_num %d (NPY_FLOAT64) got %d",
25778 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V511));
25779 {
25780 __failure = 512;
25781 if (!PyErr_Occurred()) {
25782 PyErr_SetString(PyExc_RuntimeError,
25783 "Unexpected error in an Op's C code. "
25784 "No Python exception was set.");
25785 }
25786 goto __label_512;}
25787 }
25788
25789 V511 = (PyArrayObject*)(py_V511);
25790 Py_XINCREF(V511);
25791
25792 {
25793
25794 py_V513 = PyList_GET_ITEM(storage_V513, 0);
25795 {Py_XINCREF(py_V513);}
25796
25797 V513 = NULL;
25798 if (py_V513 == Py_None) {
25799 // We can either fail here or set V513 to NULL and rely on Ops
25800 // using tensors to handle the NULL case, but if they fail to do so
25801 // they'll end up with nasty segfaults, so this is public service.
25802 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
25803 {
25804 __failure = 514;
25805 if (!PyErr_Occurred()) {
25806 PyErr_SetString(PyExc_RuntimeError,
25807 "Unexpected error in an Op's C code. "
25808 "No Python exception was set.");
25809 }
25810 goto __label_514;}
25811 }
25812 if (!PyArray_Check(py_V513)) {
25813 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
25814 {
25815 __failure = 514;
25816 if (!PyErr_Occurred()) {
25817 PyErr_SetString(PyExc_RuntimeError,
25818 "Unexpected error in an Op's C code. "
25819 "No Python exception was set.");
25820 }
25821 goto __label_514;}
25822 }
25823 // We expect NPY_FLOAT64
25824 if (!PyArray_ISALIGNED((PyArrayObject*) py_V513)) {
25825 PyArrayObject * tmp = (PyArrayObject*) py_V513;
25826 PyErr_Format(PyExc_NotImplementedError,
25827 "expected an aligned array of type %ld "
25828 "(NPY_FLOAT64), got non-aligned array of type %ld"
25829 " with %ld dimensions, with 3 last dims "
25830 "%ld, %ld, %ld"
25831 " and 3 last strides %ld %ld, %ld.",
25832 (long int) NPY_FLOAT64,
25833 (long int) PyArray_TYPE((PyArrayObject*) py_V513),
25834 (long int) PyArray_NDIM(tmp),
25835 (long int) (PyArray_NDIM(tmp) >= 3 ?
25836 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
25837 (long int) (PyArray_NDIM(tmp) >= 2 ?
25838 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
25839 (long int) (PyArray_NDIM(tmp) >= 1 ?
25840 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
25841 (long int) (PyArray_NDIM(tmp) >= 3 ?
25842 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
25843 (long int) (PyArray_NDIM(tmp) >= 2 ?
25844 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
25845 (long int) (PyArray_NDIM(tmp) >= 1 ?
25846 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
25847 );
25848 {
25849 __failure = 514;
25850 if (!PyErr_Occurred()) {
25851 PyErr_SetString(PyExc_RuntimeError,
25852 "Unexpected error in an Op's C code. "
25853 "No Python exception was set.");
25854 }
25855 goto __label_514;}
25856 }
25857 // This is a TypeError to be consistent with DEBUG_MODE
25858 // Note: DEBUG_MODE also tells the name of the container
25859 if (PyArray_TYPE((PyArrayObject*) py_V513) != NPY_FLOAT64) {
25860 PyErr_Format(PyExc_TypeError,
25861 "expected type_num %d (NPY_FLOAT64) got %d",
25862 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V513));
25863 {
25864 __failure = 514;
25865 if (!PyErr_Occurred()) {
25866 PyErr_SetString(PyExc_RuntimeError,
25867 "Unexpected error in an Op's C code. "
25868 "No Python exception was set.");
25869 }
25870 goto __label_514;}
25871 }
25872
25873 V513 = (PyArrayObject*)(py_V513);
25874 Py_XINCREF(V513);
25875
25876 {
25877
25878 py_V515 = PyList_GET_ITEM(storage_V515, 0);
25879 {Py_XINCREF(py_V515);}
25880
25881 V515 = NULL;
25882 if (py_V515 == Py_None) {
25883 // We can either fail here or set V515 to NULL and rely on Ops
25884 // using tensors to handle the NULL case, but if they fail to do so
25885 // they'll end up with nasty segfaults, so this is public service.
25886 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
25887 {
25888 __failure = 516;
25889 if (!PyErr_Occurred()) {
25890 PyErr_SetString(PyExc_RuntimeError,
25891 "Unexpected error in an Op's C code. "
25892 "No Python exception was set.");
25893 }
25894 goto __label_516;}
25895 }
25896 if (!PyArray_Check(py_V515)) {
25897 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
25898 {
25899 __failure = 516;
25900 if (!PyErr_Occurred()) {
25901 PyErr_SetString(PyExc_RuntimeError,
25902 "Unexpected error in an Op's C code. "
25903 "No Python exception was set.");
25904 }
25905 goto __label_516;}
25906 }
25907 // We expect NPY_FLOAT64
25908 if (!PyArray_ISALIGNED((PyArrayObject*) py_V515)) {
25909 PyArrayObject * tmp = (PyArrayObject*) py_V515;
25910 PyErr_Format(PyExc_NotImplementedError,
25911 "expected an aligned array of type %ld "
25912 "(NPY_FLOAT64), got non-aligned array of type %ld"
25913 " with %ld dimensions, with 3 last dims "
25914 "%ld, %ld, %ld"
25915 " and 3 last strides %ld %ld, %ld.",
25916 (long int) NPY_FLOAT64,
25917 (long int) PyArray_TYPE((PyArrayObject*) py_V515),
25918 (long int) PyArray_NDIM(tmp),
25919 (long int) (PyArray_NDIM(tmp) >= 3 ?
25920 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
25921 (long int) (PyArray_NDIM(tmp) >= 2 ?
25922 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
25923 (long int) (PyArray_NDIM(tmp) >= 1 ?
25924 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
25925 (long int) (PyArray_NDIM(tmp) >= 3 ?
25926 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
25927 (long int) (PyArray_NDIM(tmp) >= 2 ?
25928 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
25929 (long int) (PyArray_NDIM(tmp) >= 1 ?
25930 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
25931 );
25932 {
25933 __failure = 516;
25934 if (!PyErr_Occurred()) {
25935 PyErr_SetString(PyExc_RuntimeError,
25936 "Unexpected error in an Op's C code. "
25937 "No Python exception was set.");
25938 }
25939 goto __label_516;}
25940 }
25941 // This is a TypeError to be consistent with DEBUG_MODE
25942 // Note: DEBUG_MODE also tells the name of the container
25943 if (PyArray_TYPE((PyArrayObject*) py_V515) != NPY_FLOAT64) {
25944 PyErr_Format(PyExc_TypeError,
25945 "expected type_num %d (NPY_FLOAT64) got %d",
25946 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V515));
25947 {
25948 __failure = 516;
25949 if (!PyErr_Occurred()) {
25950 PyErr_SetString(PyExc_RuntimeError,
25951 "Unexpected error in an Op's C code. "
25952 "No Python exception was set.");
25953 }
25954 goto __label_516;}
25955 }
25956
25957 V515 = (PyArrayObject*)(py_V515);
25958 Py_XINCREF(V515);
25959
25960 {
25961
25962 py_V517 = PyList_GET_ITEM(storage_V517, 0);
25963 {Py_XINCREF(py_V517);}
25964
25965 V517 = NULL;
25966 if (py_V517 == Py_None) {
25967 // We can either fail here or set V517 to NULL and rely on Ops
25968 // using tensors to handle the NULL case, but if they fail to do so
25969 // they'll end up with nasty segfaults, so this is public service.
25970 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
25971 {
25972 __failure = 518;
25973 if (!PyErr_Occurred()) {
25974 PyErr_SetString(PyExc_RuntimeError,
25975 "Unexpected error in an Op's C code. "
25976 "No Python exception was set.");
25977 }
25978 goto __label_518;}
25979 }
25980 if (!PyArray_Check(py_V517)) {
25981 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
25982 {
25983 __failure = 518;
25984 if (!PyErr_Occurred()) {
25985 PyErr_SetString(PyExc_RuntimeError,
25986 "Unexpected error in an Op's C code. "
25987 "No Python exception was set.");
25988 }
25989 goto __label_518;}
25990 }
25991 // We expect NPY_FLOAT64
25992 if (!PyArray_ISALIGNED((PyArrayObject*) py_V517)) {
25993 PyArrayObject * tmp = (PyArrayObject*) py_V517;
25994 PyErr_Format(PyExc_NotImplementedError,
25995 "expected an aligned array of type %ld "
25996 "(NPY_FLOAT64), got non-aligned array of type %ld"
25997 " with %ld dimensions, with 3 last dims "
25998 "%ld, %ld, %ld"
25999 " and 3 last strides %ld %ld, %ld.",
26000 (long int) NPY_FLOAT64,
26001 (long int) PyArray_TYPE((PyArrayObject*) py_V517),
26002 (long int) PyArray_NDIM(tmp),
26003 (long int) (PyArray_NDIM(tmp) >= 3 ?
26004 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
26005 (long int) (PyArray_NDIM(tmp) >= 2 ?
26006 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
26007 (long int) (PyArray_NDIM(tmp) >= 1 ?
26008 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
26009 (long int) (PyArray_NDIM(tmp) >= 3 ?
26010 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
26011 (long int) (PyArray_NDIM(tmp) >= 2 ?
26012 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
26013 (long int) (PyArray_NDIM(tmp) >= 1 ?
26014 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
26015 );
26016 {
26017 __failure = 518;
26018 if (!PyErr_Occurred()) {
26019 PyErr_SetString(PyExc_RuntimeError,
26020 "Unexpected error in an Op's C code. "
26021 "No Python exception was set.");
26022 }
26023 goto __label_518;}
26024 }
26025 // This is a TypeError to be consistent with DEBUG_MODE
26026 // Note: DEBUG_MODE also tells the name of the container
26027 if (PyArray_TYPE((PyArrayObject*) py_V517) != NPY_FLOAT64) {
26028 PyErr_Format(PyExc_TypeError,
26029 "expected type_num %d (NPY_FLOAT64) got %d",
26030 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V517));
26031 {
26032 __failure = 518;
26033 if (!PyErr_Occurred()) {
26034 PyErr_SetString(PyExc_RuntimeError,
26035 "Unexpected error in an Op's C code. "
26036 "No Python exception was set.");
26037 }
26038 goto __label_518;}
26039 }
26040
26041 V517 = (PyArrayObject*)(py_V517);
26042 Py_XINCREF(V517);
26043
26044 {
26045
26046 py_V519 = PyList_GET_ITEM(storage_V519, 0);
26047 {Py_XINCREF(py_V519);}
26048
26049 V519 = NULL;
26050 if (py_V519 == Py_None) {
26051 // We can either fail here or set V519 to NULL and rely on Ops
26052 // using tensors to handle the NULL case, but if they fail to do so
26053 // they'll end up with nasty segfaults, so this is public service.
26054 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
26055 {
26056 __failure = 520;
26057 if (!PyErr_Occurred()) {
26058 PyErr_SetString(PyExc_RuntimeError,
26059 "Unexpected error in an Op's C code. "
26060 "No Python exception was set.");
26061 }
26062 goto __label_520;}
26063 }
26064 if (!PyArray_Check(py_V519)) {
26065 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
26066 {
26067 __failure = 520;
26068 if (!PyErr_Occurred()) {
26069 PyErr_SetString(PyExc_RuntimeError,
26070 "Unexpected error in an Op's C code. "
26071 "No Python exception was set.");
26072 }
26073 goto __label_520;}
26074 }
26075 // We expect NPY_FLOAT64
26076 if (!PyArray_ISALIGNED((PyArrayObject*) py_V519)) {
26077 PyArrayObject * tmp = (PyArrayObject*) py_V519;
26078 PyErr_Format(PyExc_NotImplementedError,
26079 "expected an aligned array of type %ld "
26080 "(NPY_FLOAT64), got non-aligned array of type %ld"
26081 " with %ld dimensions, with 3 last dims "
26082 "%ld, %ld, %ld"
26083 " and 3 last strides %ld %ld, %ld.",
26084 (long int) NPY_FLOAT64,
26085 (long int) PyArray_TYPE((PyArrayObject*) py_V519),
26086 (long int) PyArray_NDIM(tmp),
26087 (long int) (PyArray_NDIM(tmp) >= 3 ?
26088 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
26089 (long int) (PyArray_NDIM(tmp) >= 2 ?
26090 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
26091 (long int) (PyArray_NDIM(tmp) >= 1 ?
26092 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
26093 (long int) (PyArray_NDIM(tmp) >= 3 ?
26094 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
26095 (long int) (PyArray_NDIM(tmp) >= 2 ?
26096 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
26097 (long int) (PyArray_NDIM(tmp) >= 1 ?
26098 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
26099 );
26100 {
26101 __failure = 520;
26102 if (!PyErr_Occurred()) {
26103 PyErr_SetString(PyExc_RuntimeError,
26104 "Unexpected error in an Op's C code. "
26105 "No Python exception was set.");
26106 }
26107 goto __label_520;}
26108 }
26109 // This is a TypeError to be consistent with DEBUG_MODE
26110 // Note: DEBUG_MODE also tells the name of the container
26111 if (PyArray_TYPE((PyArrayObject*) py_V519) != NPY_FLOAT64) {
26112 PyErr_Format(PyExc_TypeError,
26113 "expected type_num %d (NPY_FLOAT64) got %d",
26114 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V519));
26115 {
26116 __failure = 520;
26117 if (!PyErr_Occurred()) {
26118 PyErr_SetString(PyExc_RuntimeError,
26119 "Unexpected error in an Op's C code. "
26120 "No Python exception was set.");
26121 }
26122 goto __label_520;}
26123 }
26124
26125 V519 = (PyArrayObject*)(py_V519);
26126 Py_XINCREF(V519);
26127
26128 {
26129
26130 py_V521 = PyList_GET_ITEM(storage_V521, 0);
26131 {Py_XINCREF(py_V521);}
26132
26133 V521 = NULL;
26134 if (py_V521 == Py_None) {
26135 // We can either fail here or set V521 to NULL and rely on Ops
26136 // using tensors to handle the NULL case, but if they fail to do so
26137 // they'll end up with nasty segfaults, so this is public service.
26138 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
26139 {
26140 __failure = 522;
26141 if (!PyErr_Occurred()) {
26142 PyErr_SetString(PyExc_RuntimeError,
26143 "Unexpected error in an Op's C code. "
26144 "No Python exception was set.");
26145 }
26146 goto __label_522;}
26147 }
26148 if (!PyArray_Check(py_V521)) {
26149 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
26150 {
26151 __failure = 522;
26152 if (!PyErr_Occurred()) {
26153 PyErr_SetString(PyExc_RuntimeError,
26154 "Unexpected error in an Op's C code. "
26155 "No Python exception was set.");
26156 }
26157 goto __label_522;}
26158 }
26159 // We expect NPY_FLOAT64
26160 if (!PyArray_ISALIGNED((PyArrayObject*) py_V521)) {
26161 PyArrayObject * tmp = (PyArrayObject*) py_V521;
26162 PyErr_Format(PyExc_NotImplementedError,
26163 "expected an aligned array of type %ld "
26164 "(NPY_FLOAT64), got non-aligned array of type %ld"
26165 " with %ld dimensions, with 3 last dims "
26166 "%ld, %ld, %ld"
26167 " and 3 last strides %ld %ld, %ld.",
26168 (long int) NPY_FLOAT64,
26169 (long int) PyArray_TYPE((PyArrayObject*) py_V521),
26170 (long int) PyArray_NDIM(tmp),
26171 (long int) (PyArray_NDIM(tmp) >= 3 ?
26172 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
26173 (long int) (PyArray_NDIM(tmp) >= 2 ?
26174 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
26175 (long int) (PyArray_NDIM(tmp) >= 1 ?
26176 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
26177 (long int) (PyArray_NDIM(tmp) >= 3 ?
26178 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
26179 (long int) (PyArray_NDIM(tmp) >= 2 ?
26180 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
26181 (long int) (PyArray_NDIM(tmp) >= 1 ?
26182 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
26183 );
26184 {
26185 __failure = 522;
26186 if (!PyErr_Occurred()) {
26187 PyErr_SetString(PyExc_RuntimeError,
26188 "Unexpected error in an Op's C code. "
26189 "No Python exception was set.");
26190 }
26191 goto __label_522;}
26192 }
26193 // This is a TypeError to be consistent with DEBUG_MODE
26194 // Note: DEBUG_MODE also tells the name of the container
26195 if (PyArray_TYPE((PyArrayObject*) py_V521) != NPY_FLOAT64) {
26196 PyErr_Format(PyExc_TypeError,
26197 "expected type_num %d (NPY_FLOAT64) got %d",
26198 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V521));
26199 {
26200 __failure = 522;
26201 if (!PyErr_Occurred()) {
26202 PyErr_SetString(PyExc_RuntimeError,
26203 "Unexpected error in an Op's C code. "
26204 "No Python exception was set.");
26205 }
26206 goto __label_522;}
26207 }
26208
26209 V521 = (PyArrayObject*)(py_V521);
26210 Py_XINCREF(V521);
26211
26212 {
26213
26214 py_V523 = PyList_GET_ITEM(storage_V523, 0);
26215 {Py_XINCREF(py_V523);}
26216
26217 V523 = NULL;
26218 if (py_V523 == Py_None) {
26219 // We can either fail here or set V523 to NULL and rely on Ops
26220 // using tensors to handle the NULL case, but if they fail to do so
26221 // they'll end up with nasty segfaults, so this is public service.
26222 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
26223 {
26224 __failure = 524;
26225 if (!PyErr_Occurred()) {
26226 PyErr_SetString(PyExc_RuntimeError,
26227 "Unexpected error in an Op's C code. "
26228 "No Python exception was set.");
26229 }
26230 goto __label_524;}
26231 }
26232 if (!PyArray_Check(py_V523)) {
26233 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
26234 {
26235 __failure = 524;
26236 if (!PyErr_Occurred()) {
26237 PyErr_SetString(PyExc_RuntimeError,
26238 "Unexpected error in an Op's C code. "
26239 "No Python exception was set.");
26240 }
26241 goto __label_524;}
26242 }
26243 // We expect NPY_FLOAT64
26244 if (!PyArray_ISALIGNED((PyArrayObject*) py_V523)) {
26245 PyArrayObject * tmp = (PyArrayObject*) py_V523;
26246 PyErr_Format(PyExc_NotImplementedError,
26247 "expected an aligned array of type %ld "
26248 "(NPY_FLOAT64), got non-aligned array of type %ld"
26249 " with %ld dimensions, with 3 last dims "
26250 "%ld, %ld, %ld"
26251 " and 3 last strides %ld %ld, %ld.",
26252 (long int) NPY_FLOAT64,
26253 (long int) PyArray_TYPE((PyArrayObject*) py_V523),
26254 (long int) PyArray_NDIM(tmp),
26255 (long int) (PyArray_NDIM(tmp) >= 3 ?
26256 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
26257 (long int) (PyArray_NDIM(tmp) >= 2 ?
26258 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
26259 (long int) (PyArray_NDIM(tmp) >= 1 ?
26260 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
26261 (long int) (PyArray_NDIM(tmp) >= 3 ?
26262 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
26263 (long int) (PyArray_NDIM(tmp) >= 2 ?
26264 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
26265 (long int) (PyArray_NDIM(tmp) >= 1 ?
26266 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
26267 );
26268 {
26269 __failure = 524;
26270 if (!PyErr_Occurred()) {
26271 PyErr_SetString(PyExc_RuntimeError,
26272 "Unexpected error in an Op's C code. "
26273 "No Python exception was set.");
26274 }
26275 goto __label_524;}
26276 }
26277 // This is a TypeError to be consistent with DEBUG_MODE
26278 // Note: DEBUG_MODE also tells the name of the container
26279 if (PyArray_TYPE((PyArrayObject*) py_V523) != NPY_FLOAT64) {
26280 PyErr_Format(PyExc_TypeError,
26281 "expected type_num %d (NPY_FLOAT64) got %d",
26282 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V523));
26283 {
26284 __failure = 524;
26285 if (!PyErr_Occurred()) {
26286 PyErr_SetString(PyExc_RuntimeError,
26287 "Unexpected error in an Op's C code. "
26288 "No Python exception was set.");
26289 }
26290 goto __label_524;}
26291 }
26292
26293 V523 = (PyArrayObject*)(py_V523);
26294 Py_XINCREF(V523);
26295
26296 {
26297
26298 py_V525 = PyList_GET_ITEM(storage_V525, 0);
26299 {Py_XINCREF(py_V525);}
26300
26301 V525 = NULL;
26302 if (py_V525 == Py_None) {
26303 // We can either fail here or set V525 to NULL and rely on Ops
26304 // using tensors to handle the NULL case, but if they fail to do so
26305 // they'll end up with nasty segfaults, so this is public service.
26306 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
26307 {
26308 __failure = 526;
26309 if (!PyErr_Occurred()) {
26310 PyErr_SetString(PyExc_RuntimeError,
26311 "Unexpected error in an Op's C code. "
26312 "No Python exception was set.");
26313 }
26314 goto __label_526;}
26315 }
26316 if (!PyArray_Check(py_V525)) {
26317 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
26318 {
26319 __failure = 526;
26320 if (!PyErr_Occurred()) {
26321 PyErr_SetString(PyExc_RuntimeError,
26322 "Unexpected error in an Op's C code. "
26323 "No Python exception was set.");
26324 }
26325 goto __label_526;}
26326 }
26327 // We expect NPY_FLOAT64
26328 if (!PyArray_ISALIGNED((PyArrayObject*) py_V525)) {
26329 PyArrayObject * tmp = (PyArrayObject*) py_V525;
26330 PyErr_Format(PyExc_NotImplementedError,
26331 "expected an aligned array of type %ld "
26332 "(NPY_FLOAT64), got non-aligned array of type %ld"
26333 " with %ld dimensions, with 3 last dims "
26334 "%ld, %ld, %ld"
26335 " and 3 last strides %ld %ld, %ld.",
26336 (long int) NPY_FLOAT64,
26337 (long int) PyArray_TYPE((PyArrayObject*) py_V525),
26338 (long int) PyArray_NDIM(tmp),
26339 (long int) (PyArray_NDIM(tmp) >= 3 ?
26340 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
26341 (long int) (PyArray_NDIM(tmp) >= 2 ?
26342 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
26343 (long int) (PyArray_NDIM(tmp) >= 1 ?
26344 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
26345 (long int) (PyArray_NDIM(tmp) >= 3 ?
26346 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
26347 (long int) (PyArray_NDIM(tmp) >= 2 ?
26348 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
26349 (long int) (PyArray_NDIM(tmp) >= 1 ?
26350 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
26351 );
26352 {
26353 __failure = 526;
26354 if (!PyErr_Occurred()) {
26355 PyErr_SetString(PyExc_RuntimeError,
26356 "Unexpected error in an Op's C code. "
26357 "No Python exception was set.");
26358 }
26359 goto __label_526;}
26360 }
26361 // This is a TypeError to be consistent with DEBUG_MODE
26362 // Note: DEBUG_MODE also tells the name of the container
26363 if (PyArray_TYPE((PyArrayObject*) py_V525) != NPY_FLOAT64) {
26364 PyErr_Format(PyExc_TypeError,
26365 "expected type_num %d (NPY_FLOAT64) got %d",
26366 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V525));
26367 {
26368 __failure = 526;
26369 if (!PyErr_Occurred()) {
26370 PyErr_SetString(PyExc_RuntimeError,
26371 "Unexpected error in an Op's C code. "
26372 "No Python exception was set.");
26373 }
26374 goto __label_526;}
26375 }
26376
26377 V525 = (PyArrayObject*)(py_V525);
26378 Py_XINCREF(V525);
26379
26380 {
26381
26382 py_V527 = PyList_GET_ITEM(storage_V527, 0);
26383 {Py_XINCREF(py_V527);}
26384
26385 V527 = NULL;
26386 if (py_V527 == Py_None) {
26387 // We can either fail here or set V527 to NULL and rely on Ops
26388 // using tensors to handle the NULL case, but if they fail to do so
26389 // they'll end up with nasty segfaults, so this is public service.
26390 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
26391 {
26392 __failure = 528;
26393 if (!PyErr_Occurred()) {
26394 PyErr_SetString(PyExc_RuntimeError,
26395 "Unexpected error in an Op's C code. "
26396 "No Python exception was set.");
26397 }
26398 goto __label_528;}
26399 }
26400 if (!PyArray_Check(py_V527)) {
26401 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
26402 {
26403 __failure = 528;
26404 if (!PyErr_Occurred()) {
26405 PyErr_SetString(PyExc_RuntimeError,
26406 "Unexpected error in an Op's C code. "
26407 "No Python exception was set.");
26408 }
26409 goto __label_528;}
26410 }
26411 // We expect NPY_FLOAT64
26412 if (!PyArray_ISALIGNED((PyArrayObject*) py_V527)) {
26413 PyArrayObject * tmp = (PyArrayObject*) py_V527;
26414 PyErr_Format(PyExc_NotImplementedError,
26415 "expected an aligned array of type %ld "
26416 "(NPY_FLOAT64), got non-aligned array of type %ld"
26417 " with %ld dimensions, with 3 last dims "
26418 "%ld, %ld, %ld"
26419 " and 3 last strides %ld %ld, %ld.",
26420 (long int) NPY_FLOAT64,
26421 (long int) PyArray_TYPE((PyArrayObject*) py_V527),
26422 (long int) PyArray_NDIM(tmp),
26423 (long int) (PyArray_NDIM(tmp) >= 3 ?
26424 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
26425 (long int) (PyArray_NDIM(tmp) >= 2 ?
26426 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
26427 (long int) (PyArray_NDIM(tmp) >= 1 ?
26428 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
26429 (long int) (PyArray_NDIM(tmp) >= 3 ?
26430 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
26431 (long int) (PyArray_NDIM(tmp) >= 2 ?
26432 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
26433 (long int) (PyArray_NDIM(tmp) >= 1 ?
26434 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
26435 );
26436 {
26437 __failure = 528;
26438 if (!PyErr_Occurred()) {
26439 PyErr_SetString(PyExc_RuntimeError,
26440 "Unexpected error in an Op's C code. "
26441 "No Python exception was set.");
26442 }
26443 goto __label_528;}
26444 }
26445 // This is a TypeError to be consistent with DEBUG_MODE
26446 // Note: DEBUG_MODE also tells the name of the container
26447 if (PyArray_TYPE((PyArrayObject*) py_V527) != NPY_FLOAT64) {
26448 PyErr_Format(PyExc_TypeError,
26449 "expected type_num %d (NPY_FLOAT64) got %d",
26450 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V527));
26451 {
26452 __failure = 528;
26453 if (!PyErr_Occurred()) {
26454 PyErr_SetString(PyExc_RuntimeError,
26455 "Unexpected error in an Op's C code. "
26456 "No Python exception was set.");
26457 }
26458 goto __label_528;}
26459 }
26460
26461 V527 = (PyArrayObject*)(py_V527);
26462 Py_XINCREF(V527);
26463
26464 {
26465
26466 py_V529 = PyList_GET_ITEM(storage_V529, 0);
26467 {Py_XINCREF(py_V529);}
26468
26469 V529 = NULL;
26470 if (py_V529 == Py_None) {
26471 // We can either fail here or set V529 to NULL and rely on Ops
26472 // using tensors to handle the NULL case, but if they fail to do so
26473 // they'll end up with nasty segfaults, so this is public service.
26474 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
26475 {
26476 __failure = 530;
26477 if (!PyErr_Occurred()) {
26478 PyErr_SetString(PyExc_RuntimeError,
26479 "Unexpected error in an Op's C code. "
26480 "No Python exception was set.");
26481 }
26482 goto __label_530;}
26483 }
26484 if (!PyArray_Check(py_V529)) {
26485 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
26486 {
26487 __failure = 530;
26488 if (!PyErr_Occurred()) {
26489 PyErr_SetString(PyExc_RuntimeError,
26490 "Unexpected error in an Op's C code. "
26491 "No Python exception was set.");
26492 }
26493 goto __label_530;}
26494 }
26495 // We expect NPY_FLOAT64
26496 if (!PyArray_ISALIGNED((PyArrayObject*) py_V529)) {
26497 PyArrayObject * tmp = (PyArrayObject*) py_V529;
26498 PyErr_Format(PyExc_NotImplementedError,
26499 "expected an aligned array of type %ld "
26500 "(NPY_FLOAT64), got non-aligned array of type %ld"
26501 " with %ld dimensions, with 3 last dims "
26502 "%ld, %ld, %ld"
26503 " and 3 last strides %ld %ld, %ld.",
26504 (long int) NPY_FLOAT64,
26505 (long int) PyArray_TYPE((PyArrayObject*) py_V529),
26506 (long int) PyArray_NDIM(tmp),
26507 (long int) (PyArray_NDIM(tmp) >= 3 ?
26508 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
26509 (long int) (PyArray_NDIM(tmp) >= 2 ?
26510 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
26511 (long int) (PyArray_NDIM(tmp) >= 1 ?
26512 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
26513 (long int) (PyArray_NDIM(tmp) >= 3 ?
26514 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
26515 (long int) (PyArray_NDIM(tmp) >= 2 ?
26516 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
26517 (long int) (PyArray_NDIM(tmp) >= 1 ?
26518 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
26519 );
26520 {
26521 __failure = 530;
26522 if (!PyErr_Occurred()) {
26523 PyErr_SetString(PyExc_RuntimeError,
26524 "Unexpected error in an Op's C code. "
26525 "No Python exception was set.");
26526 }
26527 goto __label_530;}
26528 }
26529 // This is a TypeError to be consistent with DEBUG_MODE
26530 // Note: DEBUG_MODE also tells the name of the container
26531 if (PyArray_TYPE((PyArrayObject*) py_V529) != NPY_FLOAT64) {
26532 PyErr_Format(PyExc_TypeError,
26533 "expected type_num %d (NPY_FLOAT64) got %d",
26534 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V529));
26535 {
26536 __failure = 530;
26537 if (!PyErr_Occurred()) {
26538 PyErr_SetString(PyExc_RuntimeError,
26539 "Unexpected error in an Op's C code. "
26540 "No Python exception was set.");
26541 }
26542 goto __label_530;}
26543 }
26544
26545 V529 = (PyArrayObject*)(py_V529);
26546 Py_XINCREF(V529);
26547
26548 {
26549
26550 py_V531 = PyList_GET_ITEM(storage_V531, 0);
26551 {Py_XINCREF(py_V531);}
26552
26553 V531 = NULL;
26554 if (py_V531 == Py_None) {
26555 // We can either fail here or set V531 to NULL and rely on Ops
26556 // using tensors to handle the NULL case, but if they fail to do so
26557 // they'll end up with nasty segfaults, so this is public service.
26558 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
26559 {
26560 __failure = 532;
26561 if (!PyErr_Occurred()) {
26562 PyErr_SetString(PyExc_RuntimeError,
26563 "Unexpected error in an Op's C code. "
26564 "No Python exception was set.");
26565 }
26566 goto __label_532;}
26567 }
26568 if (!PyArray_Check(py_V531)) {
26569 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
26570 {
26571 __failure = 532;
26572 if (!PyErr_Occurred()) {
26573 PyErr_SetString(PyExc_RuntimeError,
26574 "Unexpected error in an Op's C code. "
26575 "No Python exception was set.");
26576 }
26577 goto __label_532;}
26578 }
26579 // We expect NPY_FLOAT64
26580 if (!PyArray_ISALIGNED((PyArrayObject*) py_V531)) {
26581 PyArrayObject * tmp = (PyArrayObject*) py_V531;
26582 PyErr_Format(PyExc_NotImplementedError,
26583 "expected an aligned array of type %ld "
26584 "(NPY_FLOAT64), got non-aligned array of type %ld"
26585 " with %ld dimensions, with 3 last dims "
26586 "%ld, %ld, %ld"
26587 " and 3 last strides %ld %ld, %ld.",
26588 (long int) NPY_FLOAT64,
26589 (long int) PyArray_TYPE((PyArrayObject*) py_V531),
26590 (long int) PyArray_NDIM(tmp),
26591 (long int) (PyArray_NDIM(tmp) >= 3 ?
26592 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
26593 (long int) (PyArray_NDIM(tmp) >= 2 ?
26594 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
26595 (long int) (PyArray_NDIM(tmp) >= 1 ?
26596 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
26597 (long int) (PyArray_NDIM(tmp) >= 3 ?
26598 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
26599 (long int) (PyArray_NDIM(tmp) >= 2 ?
26600 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
26601 (long int) (PyArray_NDIM(tmp) >= 1 ?
26602 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
26603 );
26604 {
26605 __failure = 532;
26606 if (!PyErr_Occurred()) {
26607 PyErr_SetString(PyExc_RuntimeError,
26608 "Unexpected error in an Op's C code. "
26609 "No Python exception was set.");
26610 }
26611 goto __label_532;}
26612 }
26613 // This is a TypeError to be consistent with DEBUG_MODE
26614 // Note: DEBUG_MODE also tells the name of the container
26615 if (PyArray_TYPE((PyArrayObject*) py_V531) != NPY_FLOAT64) {
26616 PyErr_Format(PyExc_TypeError,
26617 "expected type_num %d (NPY_FLOAT64) got %d",
26618 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V531));
26619 {
26620 __failure = 532;
26621 if (!PyErr_Occurred()) {
26622 PyErr_SetString(PyExc_RuntimeError,
26623 "Unexpected error in an Op's C code. "
26624 "No Python exception was set.");
26625 }
26626 goto __label_532;}
26627 }
26628
26629 V531 = (PyArrayObject*)(py_V531);
26630 Py_XINCREF(V531);
26631
26632 {
26633
26634 py_V533 = PyList_GET_ITEM(storage_V533, 0);
26635 {Py_XINCREF(py_V533);}
26636
26637 V533 = NULL;
26638 if (py_V533 == Py_None) {
26639 // We can either fail here or set V533 to NULL and rely on Ops
26640 // using tensors to handle the NULL case, but if they fail to do so
26641 // they'll end up with nasty segfaults, so this is public service.
26642 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
26643 {
26644 __failure = 534;
26645 if (!PyErr_Occurred()) {
26646 PyErr_SetString(PyExc_RuntimeError,
26647 "Unexpected error in an Op's C code. "
26648 "No Python exception was set.");
26649 }
26650 goto __label_534;}
26651 }
26652 if (!PyArray_Check(py_V533)) {
26653 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
26654 {
26655 __failure = 534;
26656 if (!PyErr_Occurred()) {
26657 PyErr_SetString(PyExc_RuntimeError,
26658 "Unexpected error in an Op's C code. "
26659 "No Python exception was set.");
26660 }
26661 goto __label_534;}
26662 }
26663 // We expect NPY_FLOAT64
26664 if (!PyArray_ISALIGNED((PyArrayObject*) py_V533)) {
26665 PyArrayObject * tmp = (PyArrayObject*) py_V533;
26666 PyErr_Format(PyExc_NotImplementedError,
26667 "expected an aligned array of type %ld "
26668 "(NPY_FLOAT64), got non-aligned array of type %ld"
26669 " with %ld dimensions, with 3 last dims "
26670 "%ld, %ld, %ld"
26671 " and 3 last strides %ld %ld, %ld.",
26672 (long int) NPY_FLOAT64,
26673 (long int) PyArray_TYPE((PyArrayObject*) py_V533),
26674 (long int) PyArray_NDIM(tmp),
26675 (long int) (PyArray_NDIM(tmp) >= 3 ?
26676 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
26677 (long int) (PyArray_NDIM(tmp) >= 2 ?
26678 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
26679 (long int) (PyArray_NDIM(tmp) >= 1 ?
26680 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
26681 (long int) (PyArray_NDIM(tmp) >= 3 ?
26682 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
26683 (long int) (PyArray_NDIM(tmp) >= 2 ?
26684 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
26685 (long int) (PyArray_NDIM(tmp) >= 1 ?
26686 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
26687 );
26688 {
26689 __failure = 534;
26690 if (!PyErr_Occurred()) {
26691 PyErr_SetString(PyExc_RuntimeError,
26692 "Unexpected error in an Op's C code. "
26693 "No Python exception was set.");
26694 }
26695 goto __label_534;}
26696 }
26697 // This is a TypeError to be consistent with DEBUG_MODE
26698 // Note: DEBUG_MODE also tells the name of the container
26699 if (PyArray_TYPE((PyArrayObject*) py_V533) != NPY_FLOAT64) {
26700 PyErr_Format(PyExc_TypeError,
26701 "expected type_num %d (NPY_FLOAT64) got %d",
26702 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V533));
26703 {
26704 __failure = 534;
26705 if (!PyErr_Occurred()) {
26706 PyErr_SetString(PyExc_RuntimeError,
26707 "Unexpected error in an Op's C code. "
26708 "No Python exception was set.");
26709 }
26710 goto __label_534;}
26711 }
26712
26713 V533 = (PyArrayObject*)(py_V533);
26714 Py_XINCREF(V533);
26715
26716 {
26717
26718 py_V535 = PyList_GET_ITEM(storage_V535, 0);
26719 {Py_XINCREF(py_V535);}
26720
26721 V535 = NULL;
26722 if (py_V535 == Py_None) {
26723 // We can either fail here or set V535 to NULL and rely on Ops
26724 // using tensors to handle the NULL case, but if they fail to do so
26725 // they'll end up with nasty segfaults, so this is public service.
26726 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
26727 {
26728 __failure = 536;
26729 if (!PyErr_Occurred()) {
26730 PyErr_SetString(PyExc_RuntimeError,
26731 "Unexpected error in an Op's C code. "
26732 "No Python exception was set.");
26733 }
26734 goto __label_536;}
26735 }
26736 if (!PyArray_Check(py_V535)) {
26737 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
26738 {
26739 __failure = 536;
26740 if (!PyErr_Occurred()) {
26741 PyErr_SetString(PyExc_RuntimeError,
26742 "Unexpected error in an Op's C code. "
26743 "No Python exception was set.");
26744 }
26745 goto __label_536;}
26746 }
26747 // We expect NPY_FLOAT64
26748 if (!PyArray_ISALIGNED((PyArrayObject*) py_V535)) {
26749 PyArrayObject * tmp = (PyArrayObject*) py_V535;
26750 PyErr_Format(PyExc_NotImplementedError,
26751 "expected an aligned array of type %ld "
26752 "(NPY_FLOAT64), got non-aligned array of type %ld"
26753 " with %ld dimensions, with 3 last dims "
26754 "%ld, %ld, %ld"
26755 " and 3 last strides %ld %ld, %ld.",
26756 (long int) NPY_FLOAT64,
26757 (long int) PyArray_TYPE((PyArrayObject*) py_V535),
26758 (long int) PyArray_NDIM(tmp),
26759 (long int) (PyArray_NDIM(tmp) >= 3 ?
26760 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
26761 (long int) (PyArray_NDIM(tmp) >= 2 ?
26762 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
26763 (long int) (PyArray_NDIM(tmp) >= 1 ?
26764 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
26765 (long int) (PyArray_NDIM(tmp) >= 3 ?
26766 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
26767 (long int) (PyArray_NDIM(tmp) >= 2 ?
26768 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
26769 (long int) (PyArray_NDIM(tmp) >= 1 ?
26770 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
26771 );
26772 {
26773 __failure = 536;
26774 if (!PyErr_Occurred()) {
26775 PyErr_SetString(PyExc_RuntimeError,
26776 "Unexpected error in an Op's C code. "
26777 "No Python exception was set.");
26778 }
26779 goto __label_536;}
26780 }
26781 // This is a TypeError to be consistent with DEBUG_MODE
26782 // Note: DEBUG_MODE also tells the name of the container
26783 if (PyArray_TYPE((PyArrayObject*) py_V535) != NPY_FLOAT64) {
26784 PyErr_Format(PyExc_TypeError,
26785 "expected type_num %d (NPY_FLOAT64) got %d",
26786 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V535));
26787 {
26788 __failure = 536;
26789 if (!PyErr_Occurred()) {
26790 PyErr_SetString(PyExc_RuntimeError,
26791 "Unexpected error in an Op's C code. "
26792 "No Python exception was set.");
26793 }
26794 goto __label_536;}
26795 }
26796
26797 V535 = (PyArrayObject*)(py_V535);
26798 Py_XINCREF(V535);
26799
26800 {
26801
26802 py_V537 = PyList_GET_ITEM(storage_V537, 0);
26803 {Py_XINCREF(py_V537);}
26804
26805 V537 = NULL;
26806 if (py_V537 == Py_None) {
26807 // We can either fail here or set V537 to NULL and rely on Ops
26808 // using tensors to handle the NULL case, but if they fail to do so
26809 // they'll end up with nasty segfaults, so this is public service.
26810 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
26811 {
26812 __failure = 538;
26813 if (!PyErr_Occurred()) {
26814 PyErr_SetString(PyExc_RuntimeError,
26815 "Unexpected error in an Op's C code. "
26816 "No Python exception was set.");
26817 }
26818 goto __label_538;}
26819 }
26820 if (!PyArray_Check(py_V537)) {
26821 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
26822 {
26823 __failure = 538;
26824 if (!PyErr_Occurred()) {
26825 PyErr_SetString(PyExc_RuntimeError,
26826 "Unexpected error in an Op's C code. "
26827 "No Python exception was set.");
26828 }
26829 goto __label_538;}
26830 }
26831 // We expect NPY_FLOAT64
26832 if (!PyArray_ISALIGNED((PyArrayObject*) py_V537)) {
26833 PyArrayObject * tmp = (PyArrayObject*) py_V537;
26834 PyErr_Format(PyExc_NotImplementedError,
26835 "expected an aligned array of type %ld "
26836 "(NPY_FLOAT64), got non-aligned array of type %ld"
26837 " with %ld dimensions, with 3 last dims "
26838 "%ld, %ld, %ld"
26839 " and 3 last strides %ld %ld, %ld.",
26840 (long int) NPY_FLOAT64,
26841 (long int) PyArray_TYPE((PyArrayObject*) py_V537),
26842 (long int) PyArray_NDIM(tmp),
26843 (long int) (PyArray_NDIM(tmp) >= 3 ?
26844 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
26845 (long int) (PyArray_NDIM(tmp) >= 2 ?
26846 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
26847 (long int) (PyArray_NDIM(tmp) >= 1 ?
26848 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
26849 (long int) (PyArray_NDIM(tmp) >= 3 ?
26850 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
26851 (long int) (PyArray_NDIM(tmp) >= 2 ?
26852 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
26853 (long int) (PyArray_NDIM(tmp) >= 1 ?
26854 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
26855 );
26856 {
26857 __failure = 538;
26858 if (!PyErr_Occurred()) {
26859 PyErr_SetString(PyExc_RuntimeError,
26860 "Unexpected error in an Op's C code. "
26861 "No Python exception was set.");
26862 }
26863 goto __label_538;}
26864 }
26865 // This is a TypeError to be consistent with DEBUG_MODE
26866 // Note: DEBUG_MODE also tells the name of the container
26867 if (PyArray_TYPE((PyArrayObject*) py_V537) != NPY_FLOAT64) {
26868 PyErr_Format(PyExc_TypeError,
26869 "expected type_num %d (NPY_FLOAT64) got %d",
26870 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V537));
26871 {
26872 __failure = 538;
26873 if (!PyErr_Occurred()) {
26874 PyErr_SetString(PyExc_RuntimeError,
26875 "Unexpected error in an Op's C code. "
26876 "No Python exception was set.");
26877 }
26878 goto __label_538;}
26879 }
26880
26881 V537 = (PyArrayObject*)(py_V537);
26882 Py_XINCREF(V537);
26883
26884 {
26885
26886 py_V539 = PyList_GET_ITEM(storage_V539, 0);
26887 {Py_XINCREF(py_V539);}
26888
26889 V539 = NULL;
26890 if (py_V539 == Py_None) {
26891 // We can either fail here or set V539 to NULL and rely on Ops
26892 // using tensors to handle the NULL case, but if they fail to do so
26893 // they'll end up with nasty segfaults, so this is public service.
26894 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
26895 {
26896 __failure = 540;
26897 if (!PyErr_Occurred()) {
26898 PyErr_SetString(PyExc_RuntimeError,
26899 "Unexpected error in an Op's C code. "
26900 "No Python exception was set.");
26901 }
26902 goto __label_540;}
26903 }
26904 if (!PyArray_Check(py_V539)) {
26905 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
26906 {
26907 __failure = 540;
26908 if (!PyErr_Occurred()) {
26909 PyErr_SetString(PyExc_RuntimeError,
26910 "Unexpected error in an Op's C code. "
26911 "No Python exception was set.");
26912 }
26913 goto __label_540;}
26914 }
26915 // We expect NPY_FLOAT64
26916 if (!PyArray_ISALIGNED((PyArrayObject*) py_V539)) {
26917 PyArrayObject * tmp = (PyArrayObject*) py_V539;
26918 PyErr_Format(PyExc_NotImplementedError,
26919 "expected an aligned array of type %ld "
26920 "(NPY_FLOAT64), got non-aligned array of type %ld"
26921 " with %ld dimensions, with 3 last dims "
26922 "%ld, %ld, %ld"
26923 " and 3 last strides %ld %ld, %ld.",
26924 (long int) NPY_FLOAT64,
26925 (long int) PyArray_TYPE((PyArrayObject*) py_V539),
26926 (long int) PyArray_NDIM(tmp),
26927 (long int) (PyArray_NDIM(tmp) >= 3 ?
26928 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
26929 (long int) (PyArray_NDIM(tmp) >= 2 ?
26930 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
26931 (long int) (PyArray_NDIM(tmp) >= 1 ?
26932 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
26933 (long int) (PyArray_NDIM(tmp) >= 3 ?
26934 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
26935 (long int) (PyArray_NDIM(tmp) >= 2 ?
26936 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
26937 (long int) (PyArray_NDIM(tmp) >= 1 ?
26938 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
26939 );
26940 {
26941 __failure = 540;
26942 if (!PyErr_Occurred()) {
26943 PyErr_SetString(PyExc_RuntimeError,
26944 "Unexpected error in an Op's C code. "
26945 "No Python exception was set.");
26946 }
26947 goto __label_540;}
26948 }
26949 // This is a TypeError to be consistent with DEBUG_MODE
26950 // Note: DEBUG_MODE also tells the name of the container
26951 if (PyArray_TYPE((PyArrayObject*) py_V539) != NPY_FLOAT64) {
26952 PyErr_Format(PyExc_TypeError,
26953 "expected type_num %d (NPY_FLOAT64) got %d",
26954 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V539));
26955 {
26956 __failure = 540;
26957 if (!PyErr_Occurred()) {
26958 PyErr_SetString(PyExc_RuntimeError,
26959 "Unexpected error in an Op's C code. "
26960 "No Python exception was set.");
26961 }
26962 goto __label_540;}
26963 }
26964
26965 V539 = (PyArrayObject*)(py_V539);
26966 Py_XINCREF(V539);
26967
26968 {
26969
26970 py_V541 = PyList_GET_ITEM(storage_V541, 0);
26971 {Py_XINCREF(py_V541);}
26972
26973 V541 = NULL;
26974 if (py_V541 == Py_None) {
26975 // We can either fail here or set V541 to NULL and rely on Ops
26976 // using tensors to handle the NULL case, but if they fail to do so
26977 // they'll end up with nasty segfaults, so this is public service.
26978 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
26979 {
26980 __failure = 542;
26981 if (!PyErr_Occurred()) {
26982 PyErr_SetString(PyExc_RuntimeError,
26983 "Unexpected error in an Op's C code. "
26984 "No Python exception was set.");
26985 }
26986 goto __label_542;}
26987 }
26988 if (!PyArray_Check(py_V541)) {
26989 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
26990 {
26991 __failure = 542;
26992 if (!PyErr_Occurred()) {
26993 PyErr_SetString(PyExc_RuntimeError,
26994 "Unexpected error in an Op's C code. "
26995 "No Python exception was set.");
26996 }
26997 goto __label_542;}
26998 }
26999 // We expect NPY_FLOAT64
27000 if (!PyArray_ISALIGNED((PyArrayObject*) py_V541)) {
27001 PyArrayObject * tmp = (PyArrayObject*) py_V541;
27002 PyErr_Format(PyExc_NotImplementedError,
27003 "expected an aligned array of type %ld "
27004 "(NPY_FLOAT64), got non-aligned array of type %ld"
27005 " with %ld dimensions, with 3 last dims "
27006 "%ld, %ld, %ld"
27007 " and 3 last strides %ld %ld, %ld.",
27008 (long int) NPY_FLOAT64,
27009 (long int) PyArray_TYPE((PyArrayObject*) py_V541),
27010 (long int) PyArray_NDIM(tmp),
27011 (long int) (PyArray_NDIM(tmp) >= 3 ?
27012 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
27013 (long int) (PyArray_NDIM(tmp) >= 2 ?
27014 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
27015 (long int) (PyArray_NDIM(tmp) >= 1 ?
27016 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
27017 (long int) (PyArray_NDIM(tmp) >= 3 ?
27018 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
27019 (long int) (PyArray_NDIM(tmp) >= 2 ?
27020 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
27021 (long int) (PyArray_NDIM(tmp) >= 1 ?
27022 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
27023 );
27024 {
27025 __failure = 542;
27026 if (!PyErr_Occurred()) {
27027 PyErr_SetString(PyExc_RuntimeError,
27028 "Unexpected error in an Op's C code. "
27029 "No Python exception was set.");
27030 }
27031 goto __label_542;}
27032 }
27033 // This is a TypeError to be consistent with DEBUG_MODE
27034 // Note: DEBUG_MODE also tells the name of the container
27035 if (PyArray_TYPE((PyArrayObject*) py_V541) != NPY_FLOAT64) {
27036 PyErr_Format(PyExc_TypeError,
27037 "expected type_num %d (NPY_FLOAT64) got %d",
27038 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V541));
27039 {
27040 __failure = 542;
27041 if (!PyErr_Occurred()) {
27042 PyErr_SetString(PyExc_RuntimeError,
27043 "Unexpected error in an Op's C code. "
27044 "No Python exception was set.");
27045 }
27046 goto __label_542;}
27047 }
27048
27049 V541 = (PyArrayObject*)(py_V541);
27050 Py_XINCREF(V541);
27051
27052 {
27053
27054 py_V543 = PyList_GET_ITEM(storage_V543, 0);
27055 {Py_XINCREF(py_V543);}
27056
27057 V543 = NULL;
27058 if (py_V543 == Py_None) {
27059 // We can either fail here or set V543 to NULL and rely on Ops
27060 // using tensors to handle the NULL case, but if they fail to do so
27061 // they'll end up with nasty segfaults, so this is public service.
27062 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
27063 {
27064 __failure = 544;
27065 if (!PyErr_Occurred()) {
27066 PyErr_SetString(PyExc_RuntimeError,
27067 "Unexpected error in an Op's C code. "
27068 "No Python exception was set.");
27069 }
27070 goto __label_544;}
27071 }
27072 if (!PyArray_Check(py_V543)) {
27073 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
27074 {
27075 __failure = 544;
27076 if (!PyErr_Occurred()) {
27077 PyErr_SetString(PyExc_RuntimeError,
27078 "Unexpected error in an Op's C code. "
27079 "No Python exception was set.");
27080 }
27081 goto __label_544;}
27082 }
27083 // We expect NPY_FLOAT64
27084 if (!PyArray_ISALIGNED((PyArrayObject*) py_V543)) {
27085 PyArrayObject * tmp = (PyArrayObject*) py_V543;
27086 PyErr_Format(PyExc_NotImplementedError,
27087 "expected an aligned array of type %ld "
27088 "(NPY_FLOAT64), got non-aligned array of type %ld"
27089 " with %ld dimensions, with 3 last dims "
27090 "%ld, %ld, %ld"
27091 " and 3 last strides %ld %ld, %ld.",
27092 (long int) NPY_FLOAT64,
27093 (long int) PyArray_TYPE((PyArrayObject*) py_V543),
27094 (long int) PyArray_NDIM(tmp),
27095 (long int) (PyArray_NDIM(tmp) >= 3 ?
27096 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
27097 (long int) (PyArray_NDIM(tmp) >= 2 ?
27098 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
27099 (long int) (PyArray_NDIM(tmp) >= 1 ?
27100 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
27101 (long int) (PyArray_NDIM(tmp) >= 3 ?
27102 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
27103 (long int) (PyArray_NDIM(tmp) >= 2 ?
27104 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
27105 (long int) (PyArray_NDIM(tmp) >= 1 ?
27106 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
27107 );
27108 {
27109 __failure = 544;
27110 if (!PyErr_Occurred()) {
27111 PyErr_SetString(PyExc_RuntimeError,
27112 "Unexpected error in an Op's C code. "
27113 "No Python exception was set.");
27114 }
27115 goto __label_544;}
27116 }
27117 // This is a TypeError to be consistent with DEBUG_MODE
27118 // Note: DEBUG_MODE also tells the name of the container
27119 if (PyArray_TYPE((PyArrayObject*) py_V543) != NPY_FLOAT64) {
27120 PyErr_Format(PyExc_TypeError,
27121 "expected type_num %d (NPY_FLOAT64) got %d",
27122 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V543));
27123 {
27124 __failure = 544;
27125 if (!PyErr_Occurred()) {
27126 PyErr_SetString(PyExc_RuntimeError,
27127 "Unexpected error in an Op's C code. "
27128 "No Python exception was set.");
27129 }
27130 goto __label_544;}
27131 }
27132
27133 V543 = (PyArrayObject*)(py_V543);
27134 Py_XINCREF(V543);
27135
27136 {
27137
27138 py_V545 = PyList_GET_ITEM(storage_V545, 0);
27139 {Py_XINCREF(py_V545);}
27140
27141 V545 = NULL;
27142 if (py_V545 == Py_None) {
27143 // We can either fail here or set V545 to NULL and rely on Ops
27144 // using tensors to handle the NULL case, but if they fail to do so
27145 // they'll end up with nasty segfaults, so this is public service.
27146 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
27147 {
27148 __failure = 546;
27149 if (!PyErr_Occurred()) {
27150 PyErr_SetString(PyExc_RuntimeError,
27151 "Unexpected error in an Op's C code. "
27152 "No Python exception was set.");
27153 }
27154 goto __label_546;}
27155 }
27156 if (!PyArray_Check(py_V545)) {
27157 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
27158 {
27159 __failure = 546;
27160 if (!PyErr_Occurred()) {
27161 PyErr_SetString(PyExc_RuntimeError,
27162 "Unexpected error in an Op's C code. "
27163 "No Python exception was set.");
27164 }
27165 goto __label_546;}
27166 }
27167 // We expect NPY_FLOAT64
27168 if (!PyArray_ISALIGNED((PyArrayObject*) py_V545)) {
27169 PyArrayObject * tmp = (PyArrayObject*) py_V545;
27170 PyErr_Format(PyExc_NotImplementedError,
27171 "expected an aligned array of type %ld "
27172 "(NPY_FLOAT64), got non-aligned array of type %ld"
27173 " with %ld dimensions, with 3 last dims "
27174 "%ld, %ld, %ld"
27175 " and 3 last strides %ld %ld, %ld.",
27176 (long int) NPY_FLOAT64,
27177 (long int) PyArray_TYPE((PyArrayObject*) py_V545),
27178 (long int) PyArray_NDIM(tmp),
27179 (long int) (PyArray_NDIM(tmp) >= 3 ?
27180 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
27181 (long int) (PyArray_NDIM(tmp) >= 2 ?
27182 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
27183 (long int) (PyArray_NDIM(tmp) >= 1 ?
27184 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
27185 (long int) (PyArray_NDIM(tmp) >= 3 ?
27186 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
27187 (long int) (PyArray_NDIM(tmp) >= 2 ?
27188 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
27189 (long int) (PyArray_NDIM(tmp) >= 1 ?
27190 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
27191 );
27192 {
27193 __failure = 546;
27194 if (!PyErr_Occurred()) {
27195 PyErr_SetString(PyExc_RuntimeError,
27196 "Unexpected error in an Op's C code. "
27197 "No Python exception was set.");
27198 }
27199 goto __label_546;}
27200 }
27201 // This is a TypeError to be consistent with DEBUG_MODE
27202 // Note: DEBUG_MODE also tells the name of the container
27203 if (PyArray_TYPE((PyArrayObject*) py_V545) != NPY_FLOAT64) {
27204 PyErr_Format(PyExc_TypeError,
27205 "expected type_num %d (NPY_FLOAT64) got %d",
27206 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V545));
27207 {
27208 __failure = 546;
27209 if (!PyErr_Occurred()) {
27210 PyErr_SetString(PyExc_RuntimeError,
27211 "Unexpected error in an Op's C code. "
27212 "No Python exception was set.");
27213 }
27214 goto __label_546;}
27215 }
27216
27217 V545 = (PyArrayObject*)(py_V545);
27218 Py_XINCREF(V545);
27219
27220 {
27221
27222 py_V547 = PyList_GET_ITEM(storage_V547, 0);
27223 {Py_XINCREF(py_V547);}
27224
27225 V547 = NULL;
27226 if (py_V547 == Py_None) {
27227 // We can either fail here or set V547 to NULL and rely on Ops
27228 // using tensors to handle the NULL case, but if they fail to do so
27229 // they'll end up with nasty segfaults, so this is public service.
27230 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
27231 {
27232 __failure = 548;
27233 if (!PyErr_Occurred()) {
27234 PyErr_SetString(PyExc_RuntimeError,
27235 "Unexpected error in an Op's C code. "
27236 "No Python exception was set.");
27237 }
27238 goto __label_548;}
27239 }
27240 if (!PyArray_Check(py_V547)) {
27241 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
27242 {
27243 __failure = 548;
27244 if (!PyErr_Occurred()) {
27245 PyErr_SetString(PyExc_RuntimeError,
27246 "Unexpected error in an Op's C code. "
27247 "No Python exception was set.");
27248 }
27249 goto __label_548;}
27250 }
27251 // We expect NPY_FLOAT64
27252 if (!PyArray_ISALIGNED((PyArrayObject*) py_V547)) {
27253 PyArrayObject * tmp = (PyArrayObject*) py_V547;
27254 PyErr_Format(PyExc_NotImplementedError,
27255 "expected an aligned array of type %ld "
27256 "(NPY_FLOAT64), got non-aligned array of type %ld"
27257 " with %ld dimensions, with 3 last dims "
27258 "%ld, %ld, %ld"
27259 " and 3 last strides %ld %ld, %ld.",
27260 (long int) NPY_FLOAT64,
27261 (long int) PyArray_TYPE((PyArrayObject*) py_V547),
27262 (long int) PyArray_NDIM(tmp),
27263 (long int) (PyArray_NDIM(tmp) >= 3 ?
27264 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
27265 (long int) (PyArray_NDIM(tmp) >= 2 ?
27266 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
27267 (long int) (PyArray_NDIM(tmp) >= 1 ?
27268 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
27269 (long int) (PyArray_NDIM(tmp) >= 3 ?
27270 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
27271 (long int) (PyArray_NDIM(tmp) >= 2 ?
27272 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
27273 (long int) (PyArray_NDIM(tmp) >= 1 ?
27274 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
27275 );
27276 {
27277 __failure = 548;
27278 if (!PyErr_Occurred()) {
27279 PyErr_SetString(PyExc_RuntimeError,
27280 "Unexpected error in an Op's C code. "
27281 "No Python exception was set.");
27282 }
27283 goto __label_548;}
27284 }
27285 // This is a TypeError to be consistent with DEBUG_MODE
27286 // Note: DEBUG_MODE also tells the name of the container
27287 if (PyArray_TYPE((PyArrayObject*) py_V547) != NPY_FLOAT64) {
27288 PyErr_Format(PyExc_TypeError,
27289 "expected type_num %d (NPY_FLOAT64) got %d",
27290 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V547));
27291 {
27292 __failure = 548;
27293 if (!PyErr_Occurred()) {
27294 PyErr_SetString(PyExc_RuntimeError,
27295 "Unexpected error in an Op's C code. "
27296 "No Python exception was set.");
27297 }
27298 goto __label_548;}
27299 }
27300
27301 V547 = (PyArrayObject*)(py_V547);
27302 Py_XINCREF(V547);
27303
27304 {
27305
27306 py_V549 = PyList_GET_ITEM(storage_V549, 0);
27307 {Py_XINCREF(py_V549);}
27308
27309 V549 = NULL;
27310 if (py_V549 == Py_None) {
27311 // We can either fail here or set V549 to NULL and rely on Ops
27312 // using tensors to handle the NULL case, but if they fail to do so
27313 // they'll end up with nasty segfaults, so this is public service.
27314 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
27315 {
27316 __failure = 550;
27317 if (!PyErr_Occurred()) {
27318 PyErr_SetString(PyExc_RuntimeError,
27319 "Unexpected error in an Op's C code. "
27320 "No Python exception was set.");
27321 }
27322 goto __label_550;}
27323 }
27324 if (!PyArray_Check(py_V549)) {
27325 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
27326 {
27327 __failure = 550;
27328 if (!PyErr_Occurred()) {
27329 PyErr_SetString(PyExc_RuntimeError,
27330 "Unexpected error in an Op's C code. "
27331 "No Python exception was set.");
27332 }
27333 goto __label_550;}
27334 }
27335 // We expect NPY_FLOAT64
27336 if (!PyArray_ISALIGNED((PyArrayObject*) py_V549)) {
27337 PyArrayObject * tmp = (PyArrayObject*) py_V549;
27338 PyErr_Format(PyExc_NotImplementedError,
27339 "expected an aligned array of type %ld "
27340 "(NPY_FLOAT64), got non-aligned array of type %ld"
27341 " with %ld dimensions, with 3 last dims "
27342 "%ld, %ld, %ld"
27343 " and 3 last strides %ld %ld, %ld.",
27344 (long int) NPY_FLOAT64,
27345 (long int) PyArray_TYPE((PyArrayObject*) py_V549),
27346 (long int) PyArray_NDIM(tmp),
27347 (long int) (PyArray_NDIM(tmp) >= 3 ?
27348 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
27349 (long int) (PyArray_NDIM(tmp) >= 2 ?
27350 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
27351 (long int) (PyArray_NDIM(tmp) >= 1 ?
27352 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
27353 (long int) (PyArray_NDIM(tmp) >= 3 ?
27354 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
27355 (long int) (PyArray_NDIM(tmp) >= 2 ?
27356 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
27357 (long int) (PyArray_NDIM(tmp) >= 1 ?
27358 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
27359 );
27360 {
27361 __failure = 550;
27362 if (!PyErr_Occurred()) {
27363 PyErr_SetString(PyExc_RuntimeError,
27364 "Unexpected error in an Op's C code. "
27365 "No Python exception was set.");
27366 }
27367 goto __label_550;}
27368 }
27369 // This is a TypeError to be consistent with DEBUG_MODE
27370 // Note: DEBUG_MODE also tells the name of the container
27371 if (PyArray_TYPE((PyArrayObject*) py_V549) != NPY_FLOAT64) {
27372 PyErr_Format(PyExc_TypeError,
27373 "expected type_num %d (NPY_FLOAT64) got %d",
27374 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V549));
27375 {
27376 __failure = 550;
27377 if (!PyErr_Occurred()) {
27378 PyErr_SetString(PyExc_RuntimeError,
27379 "Unexpected error in an Op's C code. "
27380 "No Python exception was set.");
27381 }
27382 goto __label_550;}
27383 }
27384
27385 V549 = (PyArrayObject*)(py_V549);
27386 Py_XINCREF(V549);
27387
27388 {
27389
27390 py_V551 = PyList_GET_ITEM(storage_V551, 0);
27391 {Py_XINCREF(py_V551);}
27392
27393 V551 = NULL;
27394 if (py_V551 == Py_None) {
27395 // We can either fail here or set V551 to NULL and rely on Ops
27396 // using tensors to handle the NULL case, but if they fail to do so
27397 // they'll end up with nasty segfaults, so this is public service.
27398 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
27399 {
27400 __failure = 552;
27401 if (!PyErr_Occurred()) {
27402 PyErr_SetString(PyExc_RuntimeError,
27403 "Unexpected error in an Op's C code. "
27404 "No Python exception was set.");
27405 }
27406 goto __label_552;}
27407 }
27408 if (!PyArray_Check(py_V551)) {
27409 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
27410 {
27411 __failure = 552;
27412 if (!PyErr_Occurred()) {
27413 PyErr_SetString(PyExc_RuntimeError,
27414 "Unexpected error in an Op's C code. "
27415 "No Python exception was set.");
27416 }
27417 goto __label_552;}
27418 }
27419 // We expect NPY_FLOAT64
27420 if (!PyArray_ISALIGNED((PyArrayObject*) py_V551)) {
27421 PyArrayObject * tmp = (PyArrayObject*) py_V551;
27422 PyErr_Format(PyExc_NotImplementedError,
27423 "expected an aligned array of type %ld "
27424 "(NPY_FLOAT64), got non-aligned array of type %ld"
27425 " with %ld dimensions, with 3 last dims "
27426 "%ld, %ld, %ld"
27427 " and 3 last strides %ld %ld, %ld.",
27428 (long int) NPY_FLOAT64,
27429 (long int) PyArray_TYPE((PyArrayObject*) py_V551),
27430 (long int) PyArray_NDIM(tmp),
27431 (long int) (PyArray_NDIM(tmp) >= 3 ?
27432 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
27433 (long int) (PyArray_NDIM(tmp) >= 2 ?
27434 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
27435 (long int) (PyArray_NDIM(tmp) >= 1 ?
27436 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
27437 (long int) (PyArray_NDIM(tmp) >= 3 ?
27438 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
27439 (long int) (PyArray_NDIM(tmp) >= 2 ?
27440 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
27441 (long int) (PyArray_NDIM(tmp) >= 1 ?
27442 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
27443 );
27444 {
27445 __failure = 552;
27446 if (!PyErr_Occurred()) {
27447 PyErr_SetString(PyExc_RuntimeError,
27448 "Unexpected error in an Op's C code. "
27449 "No Python exception was set.");
27450 }
27451 goto __label_552;}
27452 }
27453 // This is a TypeError to be consistent with DEBUG_MODE
27454 // Note: DEBUG_MODE also tells the name of the container
27455 if (PyArray_TYPE((PyArrayObject*) py_V551) != NPY_FLOAT64) {
27456 PyErr_Format(PyExc_TypeError,
27457 "expected type_num %d (NPY_FLOAT64) got %d",
27458 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V551));
27459 {
27460 __failure = 552;
27461 if (!PyErr_Occurred()) {
27462 PyErr_SetString(PyExc_RuntimeError,
27463 "Unexpected error in an Op's C code. "
27464 "No Python exception was set.");
27465 }
27466 goto __label_552;}
27467 }
27468
27469 V551 = (PyArrayObject*)(py_V551);
27470 Py_XINCREF(V551);
27471
27472 {
27473
27474 py_V553 = PyList_GET_ITEM(storage_V553, 0);
27475 {Py_XINCREF(py_V553);}
27476
27477 V553 = NULL;
27478 if (py_V553 == Py_None) {
27479 // We can either fail here or set V553 to NULL and rely on Ops
27480 // using tensors to handle the NULL case, but if they fail to do so
27481 // they'll end up with nasty segfaults, so this is public service.
27482 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
27483 {
27484 __failure = 554;
27485 if (!PyErr_Occurred()) {
27486 PyErr_SetString(PyExc_RuntimeError,
27487 "Unexpected error in an Op's C code. "
27488 "No Python exception was set.");
27489 }
27490 goto __label_554;}
27491 }
27492 if (!PyArray_Check(py_V553)) {
27493 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
27494 {
27495 __failure = 554;
27496 if (!PyErr_Occurred()) {
27497 PyErr_SetString(PyExc_RuntimeError,
27498 "Unexpected error in an Op's C code. "
27499 "No Python exception was set.");
27500 }
27501 goto __label_554;}
27502 }
27503 // We expect NPY_FLOAT64
27504 if (!PyArray_ISALIGNED((PyArrayObject*) py_V553)) {
27505 PyArrayObject * tmp = (PyArrayObject*) py_V553;
27506 PyErr_Format(PyExc_NotImplementedError,
27507 "expected an aligned array of type %ld "
27508 "(NPY_FLOAT64), got non-aligned array of type %ld"
27509 " with %ld dimensions, with 3 last dims "
27510 "%ld, %ld, %ld"
27511 " and 3 last strides %ld %ld, %ld.",
27512 (long int) NPY_FLOAT64,
27513 (long int) PyArray_TYPE((PyArrayObject*) py_V553),
27514 (long int) PyArray_NDIM(tmp),
27515 (long int) (PyArray_NDIM(tmp) >= 3 ?
27516 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
27517 (long int) (PyArray_NDIM(tmp) >= 2 ?
27518 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
27519 (long int) (PyArray_NDIM(tmp) >= 1 ?
27520 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
27521 (long int) (PyArray_NDIM(tmp) >= 3 ?
27522 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
27523 (long int) (PyArray_NDIM(tmp) >= 2 ?
27524 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
27525 (long int) (PyArray_NDIM(tmp) >= 1 ?
27526 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
27527 );
27528 {
27529 __failure = 554;
27530 if (!PyErr_Occurred()) {
27531 PyErr_SetString(PyExc_RuntimeError,
27532 "Unexpected error in an Op's C code. "
27533 "No Python exception was set.");
27534 }
27535 goto __label_554;}
27536 }
27537 // This is a TypeError to be consistent with DEBUG_MODE
27538 // Note: DEBUG_MODE also tells the name of the container
27539 if (PyArray_TYPE((PyArrayObject*) py_V553) != NPY_FLOAT64) {
27540 PyErr_Format(PyExc_TypeError,
27541 "expected type_num %d (NPY_FLOAT64) got %d",
27542 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V553));
27543 {
27544 __failure = 554;
27545 if (!PyErr_Occurred()) {
27546 PyErr_SetString(PyExc_RuntimeError,
27547 "Unexpected error in an Op's C code. "
27548 "No Python exception was set.");
27549 }
27550 goto __label_554;}
27551 }
27552
27553 V553 = (PyArrayObject*)(py_V553);
27554 Py_XINCREF(V553);
27555
27556 {
27557
27558 py_V555 = PyList_GET_ITEM(storage_V555, 0);
27559 {Py_XINCREF(py_V555);}
27560
27561 V555 = NULL;
27562 if (py_V555 == Py_None) {
27563 // We can either fail here or set V555 to NULL and rely on Ops
27564 // using tensors to handle the NULL case, but if they fail to do so
27565 // they'll end up with nasty segfaults, so this is public service.
27566 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
27567 {
27568 __failure = 556;
27569 if (!PyErr_Occurred()) {
27570 PyErr_SetString(PyExc_RuntimeError,
27571 "Unexpected error in an Op's C code. "
27572 "No Python exception was set.");
27573 }
27574 goto __label_556;}
27575 }
27576 if (!PyArray_Check(py_V555)) {
27577 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
27578 {
27579 __failure = 556;
27580 if (!PyErr_Occurred()) {
27581 PyErr_SetString(PyExc_RuntimeError,
27582 "Unexpected error in an Op's C code. "
27583 "No Python exception was set.");
27584 }
27585 goto __label_556;}
27586 }
27587 // We expect NPY_FLOAT64
27588 if (!PyArray_ISALIGNED((PyArrayObject*) py_V555)) {
27589 PyArrayObject * tmp = (PyArrayObject*) py_V555;
27590 PyErr_Format(PyExc_NotImplementedError,
27591 "expected an aligned array of type %ld "
27592 "(NPY_FLOAT64), got non-aligned array of type %ld"
27593 " with %ld dimensions, with 3 last dims "
27594 "%ld, %ld, %ld"
27595 " and 3 last strides %ld %ld, %ld.",
27596 (long int) NPY_FLOAT64,
27597 (long int) PyArray_TYPE((PyArrayObject*) py_V555),
27598 (long int) PyArray_NDIM(tmp),
27599 (long int) (PyArray_NDIM(tmp) >= 3 ?
27600 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
27601 (long int) (PyArray_NDIM(tmp) >= 2 ?
27602 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
27603 (long int) (PyArray_NDIM(tmp) >= 1 ?
27604 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
27605 (long int) (PyArray_NDIM(tmp) >= 3 ?
27606 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
27607 (long int) (PyArray_NDIM(tmp) >= 2 ?
27608 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
27609 (long int) (PyArray_NDIM(tmp) >= 1 ?
27610 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
27611 );
27612 {
27613 __failure = 556;
27614 if (!PyErr_Occurred()) {
27615 PyErr_SetString(PyExc_RuntimeError,
27616 "Unexpected error in an Op's C code. "
27617 "No Python exception was set.");
27618 }
27619 goto __label_556;}
27620 }
27621 // This is a TypeError to be consistent with DEBUG_MODE
27622 // Note: DEBUG_MODE also tells the name of the container
27623 if (PyArray_TYPE((PyArrayObject*) py_V555) != NPY_FLOAT64) {
27624 PyErr_Format(PyExc_TypeError,
27625 "expected type_num %d (NPY_FLOAT64) got %d",
27626 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V555));
27627 {
27628 __failure = 556;
27629 if (!PyErr_Occurred()) {
27630 PyErr_SetString(PyExc_RuntimeError,
27631 "Unexpected error in an Op's C code. "
27632 "No Python exception was set.");
27633 }
27634 goto __label_556;}
27635 }
27636
27637 V555 = (PyArrayObject*)(py_V555);
27638 Py_XINCREF(V555);
27639
27640 {
27641
27642 py_V557 = PyList_GET_ITEM(storage_V557, 0);
27643 {Py_XINCREF(py_V557);}
27644
27645 V557 = NULL;
27646 if (py_V557 == Py_None) {
27647 // We can either fail here or set V557 to NULL and rely on Ops
27648 // using tensors to handle the NULL case, but if they fail to do so
27649 // they'll end up with nasty segfaults, so this is public service.
27650 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
27651 {
27652 __failure = 558;
27653 if (!PyErr_Occurred()) {
27654 PyErr_SetString(PyExc_RuntimeError,
27655 "Unexpected error in an Op's C code. "
27656 "No Python exception was set.");
27657 }
27658 goto __label_558;}
27659 }
27660 if (!PyArray_Check(py_V557)) {
27661 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
27662 {
27663 __failure = 558;
27664 if (!PyErr_Occurred()) {
27665 PyErr_SetString(PyExc_RuntimeError,
27666 "Unexpected error in an Op's C code. "
27667 "No Python exception was set.");
27668 }
27669 goto __label_558;}
27670 }
27671 // We expect NPY_FLOAT64
27672 if (!PyArray_ISALIGNED((PyArrayObject*) py_V557)) {
27673 PyArrayObject * tmp = (PyArrayObject*) py_V557;
27674 PyErr_Format(PyExc_NotImplementedError,
27675 "expected an aligned array of type %ld "
27676 "(NPY_FLOAT64), got non-aligned array of type %ld"
27677 " with %ld dimensions, with 3 last dims "
27678 "%ld, %ld, %ld"
27679 " and 3 last strides %ld %ld, %ld.",
27680 (long int) NPY_FLOAT64,
27681 (long int) PyArray_TYPE((PyArrayObject*) py_V557),
27682 (long int) PyArray_NDIM(tmp),
27683 (long int) (PyArray_NDIM(tmp) >= 3 ?
27684 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
27685 (long int) (PyArray_NDIM(tmp) >= 2 ?
27686 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
27687 (long int) (PyArray_NDIM(tmp) >= 1 ?
27688 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
27689 (long int) (PyArray_NDIM(tmp) >= 3 ?
27690 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
27691 (long int) (PyArray_NDIM(tmp) >= 2 ?
27692 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
27693 (long int) (PyArray_NDIM(tmp) >= 1 ?
27694 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
27695 );
27696 {
27697 __failure = 558;
27698 if (!PyErr_Occurred()) {
27699 PyErr_SetString(PyExc_RuntimeError,
27700 "Unexpected error in an Op's C code. "
27701 "No Python exception was set.");
27702 }
27703 goto __label_558;}
27704 }
27705 // This is a TypeError to be consistent with DEBUG_MODE
27706 // Note: DEBUG_MODE also tells the name of the container
27707 if (PyArray_TYPE((PyArrayObject*) py_V557) != NPY_FLOAT64) {
27708 PyErr_Format(PyExc_TypeError,
27709 "expected type_num %d (NPY_FLOAT64) got %d",
27710 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V557));
27711 {
27712 __failure = 558;
27713 if (!PyErr_Occurred()) {
27714 PyErr_SetString(PyExc_RuntimeError,
27715 "Unexpected error in an Op's C code. "
27716 "No Python exception was set.");
27717 }
27718 goto __label_558;}
27719 }
27720
27721 V557 = (PyArrayObject*)(py_V557);
27722 Py_XINCREF(V557);
27723
27724 {
27725
27726 py_V559 = PyList_GET_ITEM(storage_V559, 0);
27727 {Py_XINCREF(py_V559);}
27728
27729 V559 = NULL;
27730 if (py_V559 == Py_None) {
27731 // We can either fail here or set V559 to NULL and rely on Ops
27732 // using tensors to handle the NULL case, but if they fail to do so
27733 // they'll end up with nasty segfaults, so this is public service.
27734 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
27735 {
27736 __failure = 560;
27737 if (!PyErr_Occurred()) {
27738 PyErr_SetString(PyExc_RuntimeError,
27739 "Unexpected error in an Op's C code. "
27740 "No Python exception was set.");
27741 }
27742 goto __label_560;}
27743 }
27744 if (!PyArray_Check(py_V559)) {
27745 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
27746 {
27747 __failure = 560;
27748 if (!PyErr_Occurred()) {
27749 PyErr_SetString(PyExc_RuntimeError,
27750 "Unexpected error in an Op's C code. "
27751 "No Python exception was set.");
27752 }
27753 goto __label_560;}
27754 }
27755 // We expect NPY_FLOAT64
27756 if (!PyArray_ISALIGNED((PyArrayObject*) py_V559)) {
27757 PyArrayObject * tmp = (PyArrayObject*) py_V559;
27758 PyErr_Format(PyExc_NotImplementedError,
27759 "expected an aligned array of type %ld "
27760 "(NPY_FLOAT64), got non-aligned array of type %ld"
27761 " with %ld dimensions, with 3 last dims "
27762 "%ld, %ld, %ld"
27763 " and 3 last strides %ld %ld, %ld.",
27764 (long int) NPY_FLOAT64,
27765 (long int) PyArray_TYPE((PyArrayObject*) py_V559),
27766 (long int) PyArray_NDIM(tmp),
27767 (long int) (PyArray_NDIM(tmp) >= 3 ?
27768 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
27769 (long int) (PyArray_NDIM(tmp) >= 2 ?
27770 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
27771 (long int) (PyArray_NDIM(tmp) >= 1 ?
27772 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
27773 (long int) (PyArray_NDIM(tmp) >= 3 ?
27774 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
27775 (long int) (PyArray_NDIM(tmp) >= 2 ?
27776 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
27777 (long int) (PyArray_NDIM(tmp) >= 1 ?
27778 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
27779 );
27780 {
27781 __failure = 560;
27782 if (!PyErr_Occurred()) {
27783 PyErr_SetString(PyExc_RuntimeError,
27784 "Unexpected error in an Op's C code. "
27785 "No Python exception was set.");
27786 }
27787 goto __label_560;}
27788 }
27789 // This is a TypeError to be consistent with DEBUG_MODE
27790 // Note: DEBUG_MODE also tells the name of the container
27791 if (PyArray_TYPE((PyArrayObject*) py_V559) != NPY_FLOAT64) {
27792 PyErr_Format(PyExc_TypeError,
27793 "expected type_num %d (NPY_FLOAT64) got %d",
27794 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V559));
27795 {
27796 __failure = 560;
27797 if (!PyErr_Occurred()) {
27798 PyErr_SetString(PyExc_RuntimeError,
27799 "Unexpected error in an Op's C code. "
27800 "No Python exception was set.");
27801 }
27802 goto __label_560;}
27803 }
27804
27805 V559 = (PyArrayObject*)(py_V559);
27806 Py_XINCREF(V559);
27807
27808 {
27809
27810 py_V561 = PyList_GET_ITEM(storage_V561, 0);
27811 {Py_XINCREF(py_V561);}
27812
27813 V561 = NULL;
27814 if (py_V561 == Py_None) {
27815 // We can either fail here or set V561 to NULL and rely on Ops
27816 // using tensors to handle the NULL case, but if they fail to do so
27817 // they'll end up with nasty segfaults, so this is public service.
27818 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
27819 {
27820 __failure = 562;
27821 if (!PyErr_Occurred()) {
27822 PyErr_SetString(PyExc_RuntimeError,
27823 "Unexpected error in an Op's C code. "
27824 "No Python exception was set.");
27825 }
27826 goto __label_562;}
27827 }
27828 if (!PyArray_Check(py_V561)) {
27829 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
27830 {
27831 __failure = 562;
27832 if (!PyErr_Occurred()) {
27833 PyErr_SetString(PyExc_RuntimeError,
27834 "Unexpected error in an Op's C code. "
27835 "No Python exception was set.");
27836 }
27837 goto __label_562;}
27838 }
27839 // We expect NPY_FLOAT64
27840 if (!PyArray_ISALIGNED((PyArrayObject*) py_V561)) {
27841 PyArrayObject * tmp = (PyArrayObject*) py_V561;
27842 PyErr_Format(PyExc_NotImplementedError,
27843 "expected an aligned array of type %ld "
27844 "(NPY_FLOAT64), got non-aligned array of type %ld"
27845 " with %ld dimensions, with 3 last dims "
27846 "%ld, %ld, %ld"
27847 " and 3 last strides %ld %ld, %ld.",
27848 (long int) NPY_FLOAT64,
27849 (long int) PyArray_TYPE((PyArrayObject*) py_V561),
27850 (long int) PyArray_NDIM(tmp),
27851 (long int) (PyArray_NDIM(tmp) >= 3 ?
27852 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
27853 (long int) (PyArray_NDIM(tmp) >= 2 ?
27854 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
27855 (long int) (PyArray_NDIM(tmp) >= 1 ?
27856 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
27857 (long int) (PyArray_NDIM(tmp) >= 3 ?
27858 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
27859 (long int) (PyArray_NDIM(tmp) >= 2 ?
27860 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
27861 (long int) (PyArray_NDIM(tmp) >= 1 ?
27862 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
27863 );
27864 {
27865 __failure = 562;
27866 if (!PyErr_Occurred()) {
27867 PyErr_SetString(PyExc_RuntimeError,
27868 "Unexpected error in an Op's C code. "
27869 "No Python exception was set.");
27870 }
27871 goto __label_562;}
27872 }
27873 // This is a TypeError to be consistent with DEBUG_MODE
27874 // Note: DEBUG_MODE also tells the name of the container
27875 if (PyArray_TYPE((PyArrayObject*) py_V561) != NPY_FLOAT64) {
27876 PyErr_Format(PyExc_TypeError,
27877 "expected type_num %d (NPY_FLOAT64) got %d",
27878 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V561));
27879 {
27880 __failure = 562;
27881 if (!PyErr_Occurred()) {
27882 PyErr_SetString(PyExc_RuntimeError,
27883 "Unexpected error in an Op's C code. "
27884 "No Python exception was set.");
27885 }
27886 goto __label_562;}
27887 }
27888
27889 V561 = (PyArrayObject*)(py_V561);
27890 Py_XINCREF(V561);
27891
27892 {
27893
27894 py_V563 = PyList_GET_ITEM(storage_V563, 0);
27895 {Py_XINCREF(py_V563);}
27896
27897 V563 = NULL;
27898 if (py_V563 == Py_None) {
27899 // We can either fail here or set V563 to NULL and rely on Ops
27900 // using tensors to handle the NULL case, but if they fail to do so
27901 // they'll end up with nasty segfaults, so this is public service.
27902 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
27903 {
27904 __failure = 564;
27905 if (!PyErr_Occurred()) {
27906 PyErr_SetString(PyExc_RuntimeError,
27907 "Unexpected error in an Op's C code. "
27908 "No Python exception was set.");
27909 }
27910 goto __label_564;}
27911 }
27912 if (!PyArray_Check(py_V563)) {
27913 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
27914 {
27915 __failure = 564;
27916 if (!PyErr_Occurred()) {
27917 PyErr_SetString(PyExc_RuntimeError,
27918 "Unexpected error in an Op's C code. "
27919 "No Python exception was set.");
27920 }
27921 goto __label_564;}
27922 }
27923 // We expect NPY_FLOAT64
27924 if (!PyArray_ISALIGNED((PyArrayObject*) py_V563)) {
27925 PyArrayObject * tmp = (PyArrayObject*) py_V563;
27926 PyErr_Format(PyExc_NotImplementedError,
27927 "expected an aligned array of type %ld "
27928 "(NPY_FLOAT64), got non-aligned array of type %ld"
27929 " with %ld dimensions, with 3 last dims "
27930 "%ld, %ld, %ld"
27931 " and 3 last strides %ld %ld, %ld.",
27932 (long int) NPY_FLOAT64,
27933 (long int) PyArray_TYPE((PyArrayObject*) py_V563),
27934 (long int) PyArray_NDIM(tmp),
27935 (long int) (PyArray_NDIM(tmp) >= 3 ?
27936 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
27937 (long int) (PyArray_NDIM(tmp) >= 2 ?
27938 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
27939 (long int) (PyArray_NDIM(tmp) >= 1 ?
27940 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
27941 (long int) (PyArray_NDIM(tmp) >= 3 ?
27942 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
27943 (long int) (PyArray_NDIM(tmp) >= 2 ?
27944 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
27945 (long int) (PyArray_NDIM(tmp) >= 1 ?
27946 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
27947 );
27948 {
27949 __failure = 564;
27950 if (!PyErr_Occurred()) {
27951 PyErr_SetString(PyExc_RuntimeError,
27952 "Unexpected error in an Op's C code. "
27953 "No Python exception was set.");
27954 }
27955 goto __label_564;}
27956 }
27957 // This is a TypeError to be consistent with DEBUG_MODE
27958 // Note: DEBUG_MODE also tells the name of the container
27959 if (PyArray_TYPE((PyArrayObject*) py_V563) != NPY_FLOAT64) {
27960 PyErr_Format(PyExc_TypeError,
27961 "expected type_num %d (NPY_FLOAT64) got %d",
27962 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V563));
27963 {
27964 __failure = 564;
27965 if (!PyErr_Occurred()) {
27966 PyErr_SetString(PyExc_RuntimeError,
27967 "Unexpected error in an Op's C code. "
27968 "No Python exception was set.");
27969 }
27970 goto __label_564;}
27971 }
27972
27973 V563 = (PyArrayObject*)(py_V563);
27974 Py_XINCREF(V563);
27975
27976 {
27977
27978 py_V565 = PyList_GET_ITEM(storage_V565, 0);
27979 {Py_XINCREF(py_V565);}
27980
27981 V565 = NULL;
27982 if (py_V565 == Py_None) {
27983 // We can either fail here or set V565 to NULL and rely on Ops
27984 // using tensors to handle the NULL case, but if they fail to do so
27985 // they'll end up with nasty segfaults, so this is public service.
27986 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
27987 {
27988 __failure = 566;
27989 if (!PyErr_Occurred()) {
27990 PyErr_SetString(PyExc_RuntimeError,
27991 "Unexpected error in an Op's C code. "
27992 "No Python exception was set.");
27993 }
27994 goto __label_566;}
27995 }
27996 if (!PyArray_Check(py_V565)) {
27997 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
27998 {
27999 __failure = 566;
28000 if (!PyErr_Occurred()) {
28001 PyErr_SetString(PyExc_RuntimeError,
28002 "Unexpected error in an Op's C code. "
28003 "No Python exception was set.");
28004 }
28005 goto __label_566;}
28006 }
28007 // We expect NPY_FLOAT64
28008 if (!PyArray_ISALIGNED((PyArrayObject*) py_V565)) {
28009 PyArrayObject * tmp = (PyArrayObject*) py_V565;
28010 PyErr_Format(PyExc_NotImplementedError,
28011 "expected an aligned array of type %ld "
28012 "(NPY_FLOAT64), got non-aligned array of type %ld"
28013 " with %ld dimensions, with 3 last dims "
28014 "%ld, %ld, %ld"
28015 " and 3 last strides %ld %ld, %ld.",
28016 (long int) NPY_FLOAT64,
28017 (long int) PyArray_TYPE((PyArrayObject*) py_V565),
28018 (long int) PyArray_NDIM(tmp),
28019 (long int) (PyArray_NDIM(tmp) >= 3 ?
28020 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
28021 (long int) (PyArray_NDIM(tmp) >= 2 ?
28022 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
28023 (long int) (PyArray_NDIM(tmp) >= 1 ?
28024 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
28025 (long int) (PyArray_NDIM(tmp) >= 3 ?
28026 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
28027 (long int) (PyArray_NDIM(tmp) >= 2 ?
28028 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
28029 (long int) (PyArray_NDIM(tmp) >= 1 ?
28030 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
28031 );
28032 {
28033 __failure = 566;
28034 if (!PyErr_Occurred()) {
28035 PyErr_SetString(PyExc_RuntimeError,
28036 "Unexpected error in an Op's C code. "
28037 "No Python exception was set.");
28038 }
28039 goto __label_566;}
28040 }
28041 // This is a TypeError to be consistent with DEBUG_MODE
28042 // Note: DEBUG_MODE also tells the name of the container
28043 if (PyArray_TYPE((PyArrayObject*) py_V565) != NPY_FLOAT64) {
28044 PyErr_Format(PyExc_TypeError,
28045 "expected type_num %d (NPY_FLOAT64) got %d",
28046 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V565));
28047 {
28048 __failure = 566;
28049 if (!PyErr_Occurred()) {
28050 PyErr_SetString(PyExc_RuntimeError,
28051 "Unexpected error in an Op's C code. "
28052 "No Python exception was set.");
28053 }
28054 goto __label_566;}
28055 }
28056
28057 V565 = (PyArrayObject*)(py_V565);
28058 Py_XINCREF(V565);
28059
28060 {
28061
28062 py_V567 = PyList_GET_ITEM(storage_V567, 0);
28063 {Py_XINCREF(py_V567);}
28064
28065 V567 = NULL;
28066 if (py_V567 == Py_None) {
28067 // We can either fail here or set V567 to NULL and rely on Ops
28068 // using tensors to handle the NULL case, but if they fail to do so
28069 // they'll end up with nasty segfaults, so this is public service.
28070 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
28071 {
28072 __failure = 568;
28073 if (!PyErr_Occurred()) {
28074 PyErr_SetString(PyExc_RuntimeError,
28075 "Unexpected error in an Op's C code. "
28076 "No Python exception was set.");
28077 }
28078 goto __label_568;}
28079 }
28080 if (!PyArray_Check(py_V567)) {
28081 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
28082 {
28083 __failure = 568;
28084 if (!PyErr_Occurred()) {
28085 PyErr_SetString(PyExc_RuntimeError,
28086 "Unexpected error in an Op's C code. "
28087 "No Python exception was set.");
28088 }
28089 goto __label_568;}
28090 }
28091 // We expect NPY_FLOAT64
28092 if (!PyArray_ISALIGNED((PyArrayObject*) py_V567)) {
28093 PyArrayObject * tmp = (PyArrayObject*) py_V567;
28094 PyErr_Format(PyExc_NotImplementedError,
28095 "expected an aligned array of type %ld "
28096 "(NPY_FLOAT64), got non-aligned array of type %ld"
28097 " with %ld dimensions, with 3 last dims "
28098 "%ld, %ld, %ld"
28099 " and 3 last strides %ld %ld, %ld.",
28100 (long int) NPY_FLOAT64,
28101 (long int) PyArray_TYPE((PyArrayObject*) py_V567),
28102 (long int) PyArray_NDIM(tmp),
28103 (long int) (PyArray_NDIM(tmp) >= 3 ?
28104 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
28105 (long int) (PyArray_NDIM(tmp) >= 2 ?
28106 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
28107 (long int) (PyArray_NDIM(tmp) >= 1 ?
28108 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
28109 (long int) (PyArray_NDIM(tmp) >= 3 ?
28110 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
28111 (long int) (PyArray_NDIM(tmp) >= 2 ?
28112 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
28113 (long int) (PyArray_NDIM(tmp) >= 1 ?
28114 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
28115 );
28116 {
28117 __failure = 568;
28118 if (!PyErr_Occurred()) {
28119 PyErr_SetString(PyExc_RuntimeError,
28120 "Unexpected error in an Op's C code. "
28121 "No Python exception was set.");
28122 }
28123 goto __label_568;}
28124 }
28125 // This is a TypeError to be consistent with DEBUG_MODE
28126 // Note: DEBUG_MODE also tells the name of the container
28127 if (PyArray_TYPE((PyArrayObject*) py_V567) != NPY_FLOAT64) {
28128 PyErr_Format(PyExc_TypeError,
28129 "expected type_num %d (NPY_FLOAT64) got %d",
28130 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V567));
28131 {
28132 __failure = 568;
28133 if (!PyErr_Occurred()) {
28134 PyErr_SetString(PyExc_RuntimeError,
28135 "Unexpected error in an Op's C code. "
28136 "No Python exception was set.");
28137 }
28138 goto __label_568;}
28139 }
28140
28141 V567 = (PyArrayObject*)(py_V567);
28142 Py_XINCREF(V567);
28143
28144 {
28145
28146 py_V569 = PyList_GET_ITEM(storage_V569, 0);
28147 {Py_XINCREF(py_V569);}
28148
28149 V569 = NULL;
28150 if (py_V569 == Py_None) {
28151 // We can either fail here or set V569 to NULL and rely on Ops
28152 // using tensors to handle the NULL case, but if they fail to do so
28153 // they'll end up with nasty segfaults, so this is public service.
28154 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
28155 {
28156 __failure = 570;
28157 if (!PyErr_Occurred()) {
28158 PyErr_SetString(PyExc_RuntimeError,
28159 "Unexpected error in an Op's C code. "
28160 "No Python exception was set.");
28161 }
28162 goto __label_570;}
28163 }
28164 if (!PyArray_Check(py_V569)) {
28165 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
28166 {
28167 __failure = 570;
28168 if (!PyErr_Occurred()) {
28169 PyErr_SetString(PyExc_RuntimeError,
28170 "Unexpected error in an Op's C code. "
28171 "No Python exception was set.");
28172 }
28173 goto __label_570;}
28174 }
28175 // We expect NPY_FLOAT64
28176 if (!PyArray_ISALIGNED((PyArrayObject*) py_V569)) {
28177 PyArrayObject * tmp = (PyArrayObject*) py_V569;
28178 PyErr_Format(PyExc_NotImplementedError,
28179 "expected an aligned array of type %ld "
28180 "(NPY_FLOAT64), got non-aligned array of type %ld"
28181 " with %ld dimensions, with 3 last dims "
28182 "%ld, %ld, %ld"
28183 " and 3 last strides %ld %ld, %ld.",
28184 (long int) NPY_FLOAT64,
28185 (long int) PyArray_TYPE((PyArrayObject*) py_V569),
28186 (long int) PyArray_NDIM(tmp),
28187 (long int) (PyArray_NDIM(tmp) >= 3 ?
28188 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
28189 (long int) (PyArray_NDIM(tmp) >= 2 ?
28190 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
28191 (long int) (PyArray_NDIM(tmp) >= 1 ?
28192 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
28193 (long int) (PyArray_NDIM(tmp) >= 3 ?
28194 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
28195 (long int) (PyArray_NDIM(tmp) >= 2 ?
28196 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
28197 (long int) (PyArray_NDIM(tmp) >= 1 ?
28198 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
28199 );
28200 {
28201 __failure = 570;
28202 if (!PyErr_Occurred()) {
28203 PyErr_SetString(PyExc_RuntimeError,
28204 "Unexpected error in an Op's C code. "
28205 "No Python exception was set.");
28206 }
28207 goto __label_570;}
28208 }
28209 // This is a TypeError to be consistent with DEBUG_MODE
28210 // Note: DEBUG_MODE also tells the name of the container
28211 if (PyArray_TYPE((PyArrayObject*) py_V569) != NPY_FLOAT64) {
28212 PyErr_Format(PyExc_TypeError,
28213 "expected type_num %d (NPY_FLOAT64) got %d",
28214 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V569));
28215 {
28216 __failure = 570;
28217 if (!PyErr_Occurred()) {
28218 PyErr_SetString(PyExc_RuntimeError,
28219 "Unexpected error in an Op's C code. "
28220 "No Python exception was set.");
28221 }
28222 goto __label_570;}
28223 }
28224
28225 V569 = (PyArrayObject*)(py_V569);
28226 Py_XINCREF(V569);
28227
28228 {
28229
28230 py_V571 = PyList_GET_ITEM(storage_V571, 0);
28231 {Py_XINCREF(py_V571);}
28232
28233 V571 = NULL;
28234 if (py_V571 == Py_None) {
28235 // We can either fail here or set V571 to NULL and rely on Ops
28236 // using tensors to handle the NULL case, but if they fail to do so
28237 // they'll end up with nasty segfaults, so this is public service.
28238 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
28239 {
28240 __failure = 572;
28241 if (!PyErr_Occurred()) {
28242 PyErr_SetString(PyExc_RuntimeError,
28243 "Unexpected error in an Op's C code. "
28244 "No Python exception was set.");
28245 }
28246 goto __label_572;}
28247 }
28248 if (!PyArray_Check(py_V571)) {
28249 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
28250 {
28251 __failure = 572;
28252 if (!PyErr_Occurred()) {
28253 PyErr_SetString(PyExc_RuntimeError,
28254 "Unexpected error in an Op's C code. "
28255 "No Python exception was set.");
28256 }
28257 goto __label_572;}
28258 }
28259 // We expect NPY_FLOAT64
28260 if (!PyArray_ISALIGNED((PyArrayObject*) py_V571)) {
28261 PyArrayObject * tmp = (PyArrayObject*) py_V571;
28262 PyErr_Format(PyExc_NotImplementedError,
28263 "expected an aligned array of type %ld "
28264 "(NPY_FLOAT64), got non-aligned array of type %ld"
28265 " with %ld dimensions, with 3 last dims "
28266 "%ld, %ld, %ld"
28267 " and 3 last strides %ld %ld, %ld.",
28268 (long int) NPY_FLOAT64,
28269 (long int) PyArray_TYPE((PyArrayObject*) py_V571),
28270 (long int) PyArray_NDIM(tmp),
28271 (long int) (PyArray_NDIM(tmp) >= 3 ?
28272 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
28273 (long int) (PyArray_NDIM(tmp) >= 2 ?
28274 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
28275 (long int) (PyArray_NDIM(tmp) >= 1 ?
28276 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
28277 (long int) (PyArray_NDIM(tmp) >= 3 ?
28278 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
28279 (long int) (PyArray_NDIM(tmp) >= 2 ?
28280 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
28281 (long int) (PyArray_NDIM(tmp) >= 1 ?
28282 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
28283 );
28284 {
28285 __failure = 572;
28286 if (!PyErr_Occurred()) {
28287 PyErr_SetString(PyExc_RuntimeError,
28288 "Unexpected error in an Op's C code. "
28289 "No Python exception was set.");
28290 }
28291 goto __label_572;}
28292 }
28293 // This is a TypeError to be consistent with DEBUG_MODE
28294 // Note: DEBUG_MODE also tells the name of the container
28295 if (PyArray_TYPE((PyArrayObject*) py_V571) != NPY_FLOAT64) {
28296 PyErr_Format(PyExc_TypeError,
28297 "expected type_num %d (NPY_FLOAT64) got %d",
28298 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V571));
28299 {
28300 __failure = 572;
28301 if (!PyErr_Occurred()) {
28302 PyErr_SetString(PyExc_RuntimeError,
28303 "Unexpected error in an Op's C code. "
28304 "No Python exception was set.");
28305 }
28306 goto __label_572;}
28307 }
28308
28309 V571 = (PyArrayObject*)(py_V571);
28310 Py_XINCREF(V571);
28311
28312 {
28313
28314 py_V573 = PyList_GET_ITEM(storage_V573, 0);
28315 {Py_XINCREF(py_V573);}
28316
28317 V573 = NULL;
28318 if (py_V573 == Py_None) {
28319 // We can either fail here or set V573 to NULL and rely on Ops
28320 // using tensors to handle the NULL case, but if they fail to do so
28321 // they'll end up with nasty segfaults, so this is public service.
28322 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
28323 {
28324 __failure = 574;
28325 if (!PyErr_Occurred()) {
28326 PyErr_SetString(PyExc_RuntimeError,
28327 "Unexpected error in an Op's C code. "
28328 "No Python exception was set.");
28329 }
28330 goto __label_574;}
28331 }
28332 if (!PyArray_Check(py_V573)) {
28333 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
28334 {
28335 __failure = 574;
28336 if (!PyErr_Occurred()) {
28337 PyErr_SetString(PyExc_RuntimeError,
28338 "Unexpected error in an Op's C code. "
28339 "No Python exception was set.");
28340 }
28341 goto __label_574;}
28342 }
28343 // We expect NPY_FLOAT64
28344 if (!PyArray_ISALIGNED((PyArrayObject*) py_V573)) {
28345 PyArrayObject * tmp = (PyArrayObject*) py_V573;
28346 PyErr_Format(PyExc_NotImplementedError,
28347 "expected an aligned array of type %ld "
28348 "(NPY_FLOAT64), got non-aligned array of type %ld"
28349 " with %ld dimensions, with 3 last dims "
28350 "%ld, %ld, %ld"
28351 " and 3 last strides %ld %ld, %ld.",
28352 (long int) NPY_FLOAT64,
28353 (long int) PyArray_TYPE((PyArrayObject*) py_V573),
28354 (long int) PyArray_NDIM(tmp),
28355 (long int) (PyArray_NDIM(tmp) >= 3 ?
28356 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
28357 (long int) (PyArray_NDIM(tmp) >= 2 ?
28358 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
28359 (long int) (PyArray_NDIM(tmp) >= 1 ?
28360 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
28361 (long int) (PyArray_NDIM(tmp) >= 3 ?
28362 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
28363 (long int) (PyArray_NDIM(tmp) >= 2 ?
28364 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
28365 (long int) (PyArray_NDIM(tmp) >= 1 ?
28366 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
28367 );
28368 {
28369 __failure = 574;
28370 if (!PyErr_Occurred()) {
28371 PyErr_SetString(PyExc_RuntimeError,
28372 "Unexpected error in an Op's C code. "
28373 "No Python exception was set.");
28374 }
28375 goto __label_574;}
28376 }
28377 // This is a TypeError to be consistent with DEBUG_MODE
28378 // Note: DEBUG_MODE also tells the name of the container
28379 if (PyArray_TYPE((PyArrayObject*) py_V573) != NPY_FLOAT64) {
28380 PyErr_Format(PyExc_TypeError,
28381 "expected type_num %d (NPY_FLOAT64) got %d",
28382 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V573));
28383 {
28384 __failure = 574;
28385 if (!PyErr_Occurred()) {
28386 PyErr_SetString(PyExc_RuntimeError,
28387 "Unexpected error in an Op's C code. "
28388 "No Python exception was set.");
28389 }
28390 goto __label_574;}
28391 }
28392
28393 V573 = (PyArrayObject*)(py_V573);
28394 Py_XINCREF(V573);
28395
28396 {
28397
28398 py_V575 = PyList_GET_ITEM(storage_V575, 0);
28399 {Py_XINCREF(py_V575);}
28400
28401 V575 = NULL;
28402 if (py_V575 == Py_None) {
28403 // We can either fail here or set V575 to NULL and rely on Ops
28404 // using tensors to handle the NULL case, but if they fail to do so
28405 // they'll end up with nasty segfaults, so this is public service.
28406 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
28407 {
28408 __failure = 576;
28409 if (!PyErr_Occurred()) {
28410 PyErr_SetString(PyExc_RuntimeError,
28411 "Unexpected error in an Op's C code. "
28412 "No Python exception was set.");
28413 }
28414 goto __label_576;}
28415 }
28416 if (!PyArray_Check(py_V575)) {
28417 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
28418 {
28419 __failure = 576;
28420 if (!PyErr_Occurred()) {
28421 PyErr_SetString(PyExc_RuntimeError,
28422 "Unexpected error in an Op's C code. "
28423 "No Python exception was set.");
28424 }
28425 goto __label_576;}
28426 }
28427 // We expect NPY_FLOAT64
28428 if (!PyArray_ISALIGNED((PyArrayObject*) py_V575)) {
28429 PyArrayObject * tmp = (PyArrayObject*) py_V575;
28430 PyErr_Format(PyExc_NotImplementedError,
28431 "expected an aligned array of type %ld "
28432 "(NPY_FLOAT64), got non-aligned array of type %ld"
28433 " with %ld dimensions, with 3 last dims "
28434 "%ld, %ld, %ld"
28435 " and 3 last strides %ld %ld, %ld.",
28436 (long int) NPY_FLOAT64,
28437 (long int) PyArray_TYPE((PyArrayObject*) py_V575),
28438 (long int) PyArray_NDIM(tmp),
28439 (long int) (PyArray_NDIM(tmp) >= 3 ?
28440 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
28441 (long int) (PyArray_NDIM(tmp) >= 2 ?
28442 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
28443 (long int) (PyArray_NDIM(tmp) >= 1 ?
28444 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
28445 (long int) (PyArray_NDIM(tmp) >= 3 ?
28446 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
28447 (long int) (PyArray_NDIM(tmp) >= 2 ?
28448 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
28449 (long int) (PyArray_NDIM(tmp) >= 1 ?
28450 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
28451 );
28452 {
28453 __failure = 576;
28454 if (!PyErr_Occurred()) {
28455 PyErr_SetString(PyExc_RuntimeError,
28456 "Unexpected error in an Op's C code. "
28457 "No Python exception was set.");
28458 }
28459 goto __label_576;}
28460 }
28461 // This is a TypeError to be consistent with DEBUG_MODE
28462 // Note: DEBUG_MODE also tells the name of the container
28463 if (PyArray_TYPE((PyArrayObject*) py_V575) != NPY_FLOAT64) {
28464 PyErr_Format(PyExc_TypeError,
28465 "expected type_num %d (NPY_FLOAT64) got %d",
28466 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V575));
28467 {
28468 __failure = 576;
28469 if (!PyErr_Occurred()) {
28470 PyErr_SetString(PyExc_RuntimeError,
28471 "Unexpected error in an Op's C code. "
28472 "No Python exception was set.");
28473 }
28474 goto __label_576;}
28475 }
28476
28477 V575 = (PyArrayObject*)(py_V575);
28478 Py_XINCREF(V575);
28479
28480 {
28481
28482 py_V577 = PyList_GET_ITEM(storage_V577, 0);
28483 {Py_XINCREF(py_V577);}
28484
28485 V577 = NULL;
28486 if (py_V577 == Py_None) {
28487 // We can either fail here or set V577 to NULL and rely on Ops
28488 // using tensors to handle the NULL case, but if they fail to do so
28489 // they'll end up with nasty segfaults, so this is public service.
28490 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
28491 {
28492 __failure = 578;
28493 if (!PyErr_Occurred()) {
28494 PyErr_SetString(PyExc_RuntimeError,
28495 "Unexpected error in an Op's C code. "
28496 "No Python exception was set.");
28497 }
28498 goto __label_578;}
28499 }
28500 if (!PyArray_Check(py_V577)) {
28501 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
28502 {
28503 __failure = 578;
28504 if (!PyErr_Occurred()) {
28505 PyErr_SetString(PyExc_RuntimeError,
28506 "Unexpected error in an Op's C code. "
28507 "No Python exception was set.");
28508 }
28509 goto __label_578;}
28510 }
28511 // We expect NPY_FLOAT64
28512 if (!PyArray_ISALIGNED((PyArrayObject*) py_V577)) {
28513 PyArrayObject * tmp = (PyArrayObject*) py_V577;
28514 PyErr_Format(PyExc_NotImplementedError,
28515 "expected an aligned array of type %ld "
28516 "(NPY_FLOAT64), got non-aligned array of type %ld"
28517 " with %ld dimensions, with 3 last dims "
28518 "%ld, %ld, %ld"
28519 " and 3 last strides %ld %ld, %ld.",
28520 (long int) NPY_FLOAT64,
28521 (long int) PyArray_TYPE((PyArrayObject*) py_V577),
28522 (long int) PyArray_NDIM(tmp),
28523 (long int) (PyArray_NDIM(tmp) >= 3 ?
28524 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
28525 (long int) (PyArray_NDIM(tmp) >= 2 ?
28526 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
28527 (long int) (PyArray_NDIM(tmp) >= 1 ?
28528 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
28529 (long int) (PyArray_NDIM(tmp) >= 3 ?
28530 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
28531 (long int) (PyArray_NDIM(tmp) >= 2 ?
28532 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
28533 (long int) (PyArray_NDIM(tmp) >= 1 ?
28534 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
28535 );
28536 {
28537 __failure = 578;
28538 if (!PyErr_Occurred()) {
28539 PyErr_SetString(PyExc_RuntimeError,
28540 "Unexpected error in an Op's C code. "
28541 "No Python exception was set.");
28542 }
28543 goto __label_578;}
28544 }
28545 // This is a TypeError to be consistent with DEBUG_MODE
28546 // Note: DEBUG_MODE also tells the name of the container
28547 if (PyArray_TYPE((PyArrayObject*) py_V577) != NPY_FLOAT64) {
28548 PyErr_Format(PyExc_TypeError,
28549 "expected type_num %d (NPY_FLOAT64) got %d",
28550 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V577));
28551 {
28552 __failure = 578;
28553 if (!PyErr_Occurred()) {
28554 PyErr_SetString(PyExc_RuntimeError,
28555 "Unexpected error in an Op's C code. "
28556 "No Python exception was set.");
28557 }
28558 goto __label_578;}
28559 }
28560
28561 V577 = (PyArrayObject*)(py_V577);
28562 Py_XINCREF(V577);
28563
28564 {
28565
28566 py_V579 = PyList_GET_ITEM(storage_V579, 0);
28567 {Py_XINCREF(py_V579);}
28568
28569 V579 = NULL;
28570 if (py_V579 == Py_None) {
28571 // We can either fail here or set V579 to NULL and rely on Ops
28572 // using tensors to handle the NULL case, but if they fail to do so
28573 // they'll end up with nasty segfaults, so this is public service.
28574 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
28575 {
28576 __failure = 580;
28577 if (!PyErr_Occurred()) {
28578 PyErr_SetString(PyExc_RuntimeError,
28579 "Unexpected error in an Op's C code. "
28580 "No Python exception was set.");
28581 }
28582 goto __label_580;}
28583 }
28584 if (!PyArray_Check(py_V579)) {
28585 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
28586 {
28587 __failure = 580;
28588 if (!PyErr_Occurred()) {
28589 PyErr_SetString(PyExc_RuntimeError,
28590 "Unexpected error in an Op's C code. "
28591 "No Python exception was set.");
28592 }
28593 goto __label_580;}
28594 }
28595 // We expect NPY_FLOAT64
28596 if (!PyArray_ISALIGNED((PyArrayObject*) py_V579)) {
28597 PyArrayObject * tmp = (PyArrayObject*) py_V579;
28598 PyErr_Format(PyExc_NotImplementedError,
28599 "expected an aligned array of type %ld "
28600 "(NPY_FLOAT64), got non-aligned array of type %ld"
28601 " with %ld dimensions, with 3 last dims "
28602 "%ld, %ld, %ld"
28603 " and 3 last strides %ld %ld, %ld.",
28604 (long int) NPY_FLOAT64,
28605 (long int) PyArray_TYPE((PyArrayObject*) py_V579),
28606 (long int) PyArray_NDIM(tmp),
28607 (long int) (PyArray_NDIM(tmp) >= 3 ?
28608 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
28609 (long int) (PyArray_NDIM(tmp) >= 2 ?
28610 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
28611 (long int) (PyArray_NDIM(tmp) >= 1 ?
28612 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
28613 (long int) (PyArray_NDIM(tmp) >= 3 ?
28614 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
28615 (long int) (PyArray_NDIM(tmp) >= 2 ?
28616 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
28617 (long int) (PyArray_NDIM(tmp) >= 1 ?
28618 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
28619 );
28620 {
28621 __failure = 580;
28622 if (!PyErr_Occurred()) {
28623 PyErr_SetString(PyExc_RuntimeError,
28624 "Unexpected error in an Op's C code. "
28625 "No Python exception was set.");
28626 }
28627 goto __label_580;}
28628 }
28629 // This is a TypeError to be consistent with DEBUG_MODE
28630 // Note: DEBUG_MODE also tells the name of the container
28631 if (PyArray_TYPE((PyArrayObject*) py_V579) != NPY_FLOAT64) {
28632 PyErr_Format(PyExc_TypeError,
28633 "expected type_num %d (NPY_FLOAT64) got %d",
28634 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V579));
28635 {
28636 __failure = 580;
28637 if (!PyErr_Occurred()) {
28638 PyErr_SetString(PyExc_RuntimeError,
28639 "Unexpected error in an Op's C code. "
28640 "No Python exception was set.");
28641 }
28642 goto __label_580;}
28643 }
28644
28645 V579 = (PyArrayObject*)(py_V579);
28646 Py_XINCREF(V579);
28647
28648 {
28649
28650 py_V581 = PyList_GET_ITEM(storage_V581, 0);
28651 {Py_XINCREF(py_V581);}
28652
28653 V581 = NULL;
28654 if (py_V581 == Py_None) {
28655 // We can either fail here or set V581 to NULL and rely on Ops
28656 // using tensors to handle the NULL case, but if they fail to do so
28657 // they'll end up with nasty segfaults, so this is public service.
28658 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
28659 {
28660 __failure = 582;
28661 if (!PyErr_Occurred()) {
28662 PyErr_SetString(PyExc_RuntimeError,
28663 "Unexpected error in an Op's C code. "
28664 "No Python exception was set.");
28665 }
28666 goto __label_582;}
28667 }
28668 if (!PyArray_Check(py_V581)) {
28669 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
28670 {
28671 __failure = 582;
28672 if (!PyErr_Occurred()) {
28673 PyErr_SetString(PyExc_RuntimeError,
28674 "Unexpected error in an Op's C code. "
28675 "No Python exception was set.");
28676 }
28677 goto __label_582;}
28678 }
28679 // We expect NPY_FLOAT64
28680 if (!PyArray_ISALIGNED((PyArrayObject*) py_V581)) {
28681 PyArrayObject * tmp = (PyArrayObject*) py_V581;
28682 PyErr_Format(PyExc_NotImplementedError,
28683 "expected an aligned array of type %ld "
28684 "(NPY_FLOAT64), got non-aligned array of type %ld"
28685 " with %ld dimensions, with 3 last dims "
28686 "%ld, %ld, %ld"
28687 " and 3 last strides %ld %ld, %ld.",
28688 (long int) NPY_FLOAT64,
28689 (long int) PyArray_TYPE((PyArrayObject*) py_V581),
28690 (long int) PyArray_NDIM(tmp),
28691 (long int) (PyArray_NDIM(tmp) >= 3 ?
28692 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
28693 (long int) (PyArray_NDIM(tmp) >= 2 ?
28694 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
28695 (long int) (PyArray_NDIM(tmp) >= 1 ?
28696 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
28697 (long int) (PyArray_NDIM(tmp) >= 3 ?
28698 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
28699 (long int) (PyArray_NDIM(tmp) >= 2 ?
28700 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
28701 (long int) (PyArray_NDIM(tmp) >= 1 ?
28702 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
28703 );
28704 {
28705 __failure = 582;
28706 if (!PyErr_Occurred()) {
28707 PyErr_SetString(PyExc_RuntimeError,
28708 "Unexpected error in an Op's C code. "
28709 "No Python exception was set.");
28710 }
28711 goto __label_582;}
28712 }
28713 // This is a TypeError to be consistent with DEBUG_MODE
28714 // Note: DEBUG_MODE also tells the name of the container
28715 if (PyArray_TYPE((PyArrayObject*) py_V581) != NPY_FLOAT64) {
28716 PyErr_Format(PyExc_TypeError,
28717 "expected type_num %d (NPY_FLOAT64) got %d",
28718 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V581));
28719 {
28720 __failure = 582;
28721 if (!PyErr_Occurred()) {
28722 PyErr_SetString(PyExc_RuntimeError,
28723 "Unexpected error in an Op's C code. "
28724 "No Python exception was set.");
28725 }
28726 goto __label_582;}
28727 }
28728
28729 V581 = (PyArrayObject*)(py_V581);
28730 Py_XINCREF(V581);
28731
28732 {
28733
28734 py_V583 = PyList_GET_ITEM(storage_V583, 0);
28735 {Py_XINCREF(py_V583);}
28736
28737 V583 = NULL;
28738 if (py_V583 == Py_None) {
28739 // We can either fail here or set V583 to NULL and rely on Ops
28740 // using tensors to handle the NULL case, but if they fail to do so
28741 // they'll end up with nasty segfaults, so this is public service.
28742 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
28743 {
28744 __failure = 584;
28745 if (!PyErr_Occurred()) {
28746 PyErr_SetString(PyExc_RuntimeError,
28747 "Unexpected error in an Op's C code. "
28748 "No Python exception was set.");
28749 }
28750 goto __label_584;}
28751 }
28752 if (!PyArray_Check(py_V583)) {
28753 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
28754 {
28755 __failure = 584;
28756 if (!PyErr_Occurred()) {
28757 PyErr_SetString(PyExc_RuntimeError,
28758 "Unexpected error in an Op's C code. "
28759 "No Python exception was set.");
28760 }
28761 goto __label_584;}
28762 }
28763 // We expect NPY_FLOAT64
28764 if (!PyArray_ISALIGNED((PyArrayObject*) py_V583)) {
28765 PyArrayObject * tmp = (PyArrayObject*) py_V583;
28766 PyErr_Format(PyExc_NotImplementedError,
28767 "expected an aligned array of type %ld "
28768 "(NPY_FLOAT64), got non-aligned array of type %ld"
28769 " with %ld dimensions, with 3 last dims "
28770 "%ld, %ld, %ld"
28771 " and 3 last strides %ld %ld, %ld.",
28772 (long int) NPY_FLOAT64,
28773 (long int) PyArray_TYPE((PyArrayObject*) py_V583),
28774 (long int) PyArray_NDIM(tmp),
28775 (long int) (PyArray_NDIM(tmp) >= 3 ?
28776 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
28777 (long int) (PyArray_NDIM(tmp) >= 2 ?
28778 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
28779 (long int) (PyArray_NDIM(tmp) >= 1 ?
28780 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
28781 (long int) (PyArray_NDIM(tmp) >= 3 ?
28782 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
28783 (long int) (PyArray_NDIM(tmp) >= 2 ?
28784 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
28785 (long int) (PyArray_NDIM(tmp) >= 1 ?
28786 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
28787 );
28788 {
28789 __failure = 584;
28790 if (!PyErr_Occurred()) {
28791 PyErr_SetString(PyExc_RuntimeError,
28792 "Unexpected error in an Op's C code. "
28793 "No Python exception was set.");
28794 }
28795 goto __label_584;}
28796 }
28797 // This is a TypeError to be consistent with DEBUG_MODE
28798 // Note: DEBUG_MODE also tells the name of the container
28799 if (PyArray_TYPE((PyArrayObject*) py_V583) != NPY_FLOAT64) {
28800 PyErr_Format(PyExc_TypeError,
28801 "expected type_num %d (NPY_FLOAT64) got %d",
28802 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V583));
28803 {
28804 __failure = 584;
28805 if (!PyErr_Occurred()) {
28806 PyErr_SetString(PyExc_RuntimeError,
28807 "Unexpected error in an Op's C code. "
28808 "No Python exception was set.");
28809 }
28810 goto __label_584;}
28811 }
28812
28813 V583 = (PyArrayObject*)(py_V583);
28814 Py_XINCREF(V583);
28815
28816 {
28817
28818 py_V585 = PyList_GET_ITEM(storage_V585, 0);
28819 {Py_XINCREF(py_V585);}
28820
28821 V585 = NULL;
28822 if (py_V585 == Py_None) {
28823 // We can either fail here or set V585 to NULL and rely on Ops
28824 // using tensors to handle the NULL case, but if they fail to do so
28825 // they'll end up with nasty segfaults, so this is public service.
28826 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
28827 {
28828 __failure = 586;
28829 if (!PyErr_Occurred()) {
28830 PyErr_SetString(PyExc_RuntimeError,
28831 "Unexpected error in an Op's C code. "
28832 "No Python exception was set.");
28833 }
28834 goto __label_586;}
28835 }
28836 if (!PyArray_Check(py_V585)) {
28837 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
28838 {
28839 __failure = 586;
28840 if (!PyErr_Occurred()) {
28841 PyErr_SetString(PyExc_RuntimeError,
28842 "Unexpected error in an Op's C code. "
28843 "No Python exception was set.");
28844 }
28845 goto __label_586;}
28846 }
28847 // We expect NPY_FLOAT64
28848 if (!PyArray_ISALIGNED((PyArrayObject*) py_V585)) {
28849 PyArrayObject * tmp = (PyArrayObject*) py_V585;
28850 PyErr_Format(PyExc_NotImplementedError,
28851 "expected an aligned array of type %ld "
28852 "(NPY_FLOAT64), got non-aligned array of type %ld"
28853 " with %ld dimensions, with 3 last dims "
28854 "%ld, %ld, %ld"
28855 " and 3 last strides %ld %ld, %ld.",
28856 (long int) NPY_FLOAT64,
28857 (long int) PyArray_TYPE((PyArrayObject*) py_V585),
28858 (long int) PyArray_NDIM(tmp),
28859 (long int) (PyArray_NDIM(tmp) >= 3 ?
28860 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
28861 (long int) (PyArray_NDIM(tmp) >= 2 ?
28862 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
28863 (long int) (PyArray_NDIM(tmp) >= 1 ?
28864 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
28865 (long int) (PyArray_NDIM(tmp) >= 3 ?
28866 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
28867 (long int) (PyArray_NDIM(tmp) >= 2 ?
28868 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
28869 (long int) (PyArray_NDIM(tmp) >= 1 ?
28870 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
28871 );
28872 {
28873 __failure = 586;
28874 if (!PyErr_Occurred()) {
28875 PyErr_SetString(PyExc_RuntimeError,
28876 "Unexpected error in an Op's C code. "
28877 "No Python exception was set.");
28878 }
28879 goto __label_586;}
28880 }
28881 // This is a TypeError to be consistent with DEBUG_MODE
28882 // Note: DEBUG_MODE also tells the name of the container
28883 if (PyArray_TYPE((PyArrayObject*) py_V585) != NPY_FLOAT64) {
28884 PyErr_Format(PyExc_TypeError,
28885 "expected type_num %d (NPY_FLOAT64) got %d",
28886 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V585));
28887 {
28888 __failure = 586;
28889 if (!PyErr_Occurred()) {
28890 PyErr_SetString(PyExc_RuntimeError,
28891 "Unexpected error in an Op's C code. "
28892 "No Python exception was set.");
28893 }
28894 goto __label_586;}
28895 }
28896
28897 V585 = (PyArrayObject*)(py_V585);
28898 Py_XINCREF(V585);
28899
28900 {
28901
28902 py_V587 = PyList_GET_ITEM(storage_V587, 0);
28903 {Py_XINCREF(py_V587);}
28904
28905 V587 = NULL;
28906 if (py_V587 == Py_None) {
28907 // We can either fail here or set V587 to NULL and rely on Ops
28908 // using tensors to handle the NULL case, but if they fail to do so
28909 // they'll end up with nasty segfaults, so this is public service.
28910 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
28911 {
28912 __failure = 588;
28913 if (!PyErr_Occurred()) {
28914 PyErr_SetString(PyExc_RuntimeError,
28915 "Unexpected error in an Op's C code. "
28916 "No Python exception was set.");
28917 }
28918 goto __label_588;}
28919 }
28920 if (!PyArray_Check(py_V587)) {
28921 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
28922 {
28923 __failure = 588;
28924 if (!PyErr_Occurred()) {
28925 PyErr_SetString(PyExc_RuntimeError,
28926 "Unexpected error in an Op's C code. "
28927 "No Python exception was set.");
28928 }
28929 goto __label_588;}
28930 }
28931 // We expect NPY_FLOAT64
28932 if (!PyArray_ISALIGNED((PyArrayObject*) py_V587)) {
28933 PyArrayObject * tmp = (PyArrayObject*) py_V587;
28934 PyErr_Format(PyExc_NotImplementedError,
28935 "expected an aligned array of type %ld "
28936 "(NPY_FLOAT64), got non-aligned array of type %ld"
28937 " with %ld dimensions, with 3 last dims "
28938 "%ld, %ld, %ld"
28939 " and 3 last strides %ld %ld, %ld.",
28940 (long int) NPY_FLOAT64,
28941 (long int) PyArray_TYPE((PyArrayObject*) py_V587),
28942 (long int) PyArray_NDIM(tmp),
28943 (long int) (PyArray_NDIM(tmp) >= 3 ?
28944 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
28945 (long int) (PyArray_NDIM(tmp) >= 2 ?
28946 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
28947 (long int) (PyArray_NDIM(tmp) >= 1 ?
28948 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
28949 (long int) (PyArray_NDIM(tmp) >= 3 ?
28950 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
28951 (long int) (PyArray_NDIM(tmp) >= 2 ?
28952 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
28953 (long int) (PyArray_NDIM(tmp) >= 1 ?
28954 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
28955 );
28956 {
28957 __failure = 588;
28958 if (!PyErr_Occurred()) {
28959 PyErr_SetString(PyExc_RuntimeError,
28960 "Unexpected error in an Op's C code. "
28961 "No Python exception was set.");
28962 }
28963 goto __label_588;}
28964 }
28965 // This is a TypeError to be consistent with DEBUG_MODE
28966 // Note: DEBUG_MODE also tells the name of the container
28967 if (PyArray_TYPE((PyArrayObject*) py_V587) != NPY_FLOAT64) {
28968 PyErr_Format(PyExc_TypeError,
28969 "expected type_num %d (NPY_FLOAT64) got %d",
28970 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V587));
28971 {
28972 __failure = 588;
28973 if (!PyErr_Occurred()) {
28974 PyErr_SetString(PyExc_RuntimeError,
28975 "Unexpected error in an Op's C code. "
28976 "No Python exception was set.");
28977 }
28978 goto __label_588;}
28979 }
28980
28981 V587 = (PyArrayObject*)(py_V587);
28982 Py_XINCREF(V587);
28983
28984 {
28985
28986 py_V589 = PyList_GET_ITEM(storage_V589, 0);
28987 {Py_XINCREF(py_V589);}
28988
28989 V589 = NULL;
28990 if (py_V589 == Py_None) {
28991 // We can either fail here or set V589 to NULL and rely on Ops
28992 // using tensors to handle the NULL case, but if they fail to do so
28993 // they'll end up with nasty segfaults, so this is public service.
28994 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
28995 {
28996 __failure = 590;
28997 if (!PyErr_Occurred()) {
28998 PyErr_SetString(PyExc_RuntimeError,
28999 "Unexpected error in an Op's C code. "
29000 "No Python exception was set.");
29001 }
29002 goto __label_590;}
29003 }
29004 if (!PyArray_Check(py_V589)) {
29005 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
29006 {
29007 __failure = 590;
29008 if (!PyErr_Occurred()) {
29009 PyErr_SetString(PyExc_RuntimeError,
29010 "Unexpected error in an Op's C code. "
29011 "No Python exception was set.");
29012 }
29013 goto __label_590;}
29014 }
29015 // We expect NPY_FLOAT64
29016 if (!PyArray_ISALIGNED((PyArrayObject*) py_V589)) {
29017 PyArrayObject * tmp = (PyArrayObject*) py_V589;
29018 PyErr_Format(PyExc_NotImplementedError,
29019 "expected an aligned array of type %ld "
29020 "(NPY_FLOAT64), got non-aligned array of type %ld"
29021 " with %ld dimensions, with 3 last dims "
29022 "%ld, %ld, %ld"
29023 " and 3 last strides %ld %ld, %ld.",
29024 (long int) NPY_FLOAT64,
29025 (long int) PyArray_TYPE((PyArrayObject*) py_V589),
29026 (long int) PyArray_NDIM(tmp),
29027 (long int) (PyArray_NDIM(tmp) >= 3 ?
29028 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
29029 (long int) (PyArray_NDIM(tmp) >= 2 ?
29030 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
29031 (long int) (PyArray_NDIM(tmp) >= 1 ?
29032 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
29033 (long int) (PyArray_NDIM(tmp) >= 3 ?
29034 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
29035 (long int) (PyArray_NDIM(tmp) >= 2 ?
29036 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
29037 (long int) (PyArray_NDIM(tmp) >= 1 ?
29038 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
29039 );
29040 {
29041 __failure = 590;
29042 if (!PyErr_Occurred()) {
29043 PyErr_SetString(PyExc_RuntimeError,
29044 "Unexpected error in an Op's C code. "
29045 "No Python exception was set.");
29046 }
29047 goto __label_590;}
29048 }
29049 // This is a TypeError to be consistent with DEBUG_MODE
29050 // Note: DEBUG_MODE also tells the name of the container
29051 if (PyArray_TYPE((PyArrayObject*) py_V589) != NPY_FLOAT64) {
29052 PyErr_Format(PyExc_TypeError,
29053 "expected type_num %d (NPY_FLOAT64) got %d",
29054 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V589));
29055 {
29056 __failure = 590;
29057 if (!PyErr_Occurred()) {
29058 PyErr_SetString(PyExc_RuntimeError,
29059 "Unexpected error in an Op's C code. "
29060 "No Python exception was set.");
29061 }
29062 goto __label_590;}
29063 }
29064
29065 V589 = (PyArrayObject*)(py_V589);
29066 Py_XINCREF(V589);
29067
29068 {
29069
29070 py_V591 = PyList_GET_ITEM(storage_V591, 0);
29071 {Py_XINCREF(py_V591);}
29072
29073 V591 = NULL;
29074 if (py_V591 == Py_None) {
29075 // We can either fail here or set V591 to NULL and rely on Ops
29076 // using tensors to handle the NULL case, but if they fail to do so
29077 // they'll end up with nasty segfaults, so this is public service.
29078 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
29079 {
29080 __failure = 592;
29081 if (!PyErr_Occurred()) {
29082 PyErr_SetString(PyExc_RuntimeError,
29083 "Unexpected error in an Op's C code. "
29084 "No Python exception was set.");
29085 }
29086 goto __label_592;}
29087 }
29088 if (!PyArray_Check(py_V591)) {
29089 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
29090 {
29091 __failure = 592;
29092 if (!PyErr_Occurred()) {
29093 PyErr_SetString(PyExc_RuntimeError,
29094 "Unexpected error in an Op's C code. "
29095 "No Python exception was set.");
29096 }
29097 goto __label_592;}
29098 }
29099 // We expect NPY_FLOAT64
29100 if (!PyArray_ISALIGNED((PyArrayObject*) py_V591)) {
29101 PyArrayObject * tmp = (PyArrayObject*) py_V591;
29102 PyErr_Format(PyExc_NotImplementedError,
29103 "expected an aligned array of type %ld "
29104 "(NPY_FLOAT64), got non-aligned array of type %ld"
29105 " with %ld dimensions, with 3 last dims "
29106 "%ld, %ld, %ld"
29107 " and 3 last strides %ld %ld, %ld.",
29108 (long int) NPY_FLOAT64,
29109 (long int) PyArray_TYPE((PyArrayObject*) py_V591),
29110 (long int) PyArray_NDIM(tmp),
29111 (long int) (PyArray_NDIM(tmp) >= 3 ?
29112 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
29113 (long int) (PyArray_NDIM(tmp) >= 2 ?
29114 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
29115 (long int) (PyArray_NDIM(tmp) >= 1 ?
29116 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
29117 (long int) (PyArray_NDIM(tmp) >= 3 ?
29118 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
29119 (long int) (PyArray_NDIM(tmp) >= 2 ?
29120 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
29121 (long int) (PyArray_NDIM(tmp) >= 1 ?
29122 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
29123 );
29124 {
29125 __failure = 592;
29126 if (!PyErr_Occurred()) {
29127 PyErr_SetString(PyExc_RuntimeError,
29128 "Unexpected error in an Op's C code. "
29129 "No Python exception was set.");
29130 }
29131 goto __label_592;}
29132 }
29133 // This is a TypeError to be consistent with DEBUG_MODE
29134 // Note: DEBUG_MODE also tells the name of the container
29135 if (PyArray_TYPE((PyArrayObject*) py_V591) != NPY_FLOAT64) {
29136 PyErr_Format(PyExc_TypeError,
29137 "expected type_num %d (NPY_FLOAT64) got %d",
29138 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V591));
29139 {
29140 __failure = 592;
29141 if (!PyErr_Occurred()) {
29142 PyErr_SetString(PyExc_RuntimeError,
29143 "Unexpected error in an Op's C code. "
29144 "No Python exception was set.");
29145 }
29146 goto __label_592;}
29147 }
29148
29149 V591 = (PyArrayObject*)(py_V591);
29150 Py_XINCREF(V591);
29151
29152 {
29153
29154 py_V593 = PyList_GET_ITEM(storage_V593, 0);
29155 {Py_XINCREF(py_V593);}
29156
29157 V593 = NULL;
29158 if (py_V593 == Py_None) {
29159 // We can either fail here or set V593 to NULL and rely on Ops
29160 // using tensors to handle the NULL case, but if they fail to do so
29161 // they'll end up with nasty segfaults, so this is public service.
29162 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
29163 {
29164 __failure = 594;
29165 if (!PyErr_Occurred()) {
29166 PyErr_SetString(PyExc_RuntimeError,
29167 "Unexpected error in an Op's C code. "
29168 "No Python exception was set.");
29169 }
29170 goto __label_594;}
29171 }
29172 if (!PyArray_Check(py_V593)) {
29173 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
29174 {
29175 __failure = 594;
29176 if (!PyErr_Occurred()) {
29177 PyErr_SetString(PyExc_RuntimeError,
29178 "Unexpected error in an Op's C code. "
29179 "No Python exception was set.");
29180 }
29181 goto __label_594;}
29182 }
29183 // We expect NPY_FLOAT64
29184 if (!PyArray_ISALIGNED((PyArrayObject*) py_V593)) {
29185 PyArrayObject * tmp = (PyArrayObject*) py_V593;
29186 PyErr_Format(PyExc_NotImplementedError,
29187 "expected an aligned array of type %ld "
29188 "(NPY_FLOAT64), got non-aligned array of type %ld"
29189 " with %ld dimensions, with 3 last dims "
29190 "%ld, %ld, %ld"
29191 " and 3 last strides %ld %ld, %ld.",
29192 (long int) NPY_FLOAT64,
29193 (long int) PyArray_TYPE((PyArrayObject*) py_V593),
29194 (long int) PyArray_NDIM(tmp),
29195 (long int) (PyArray_NDIM(tmp) >= 3 ?
29196 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
29197 (long int) (PyArray_NDIM(tmp) >= 2 ?
29198 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
29199 (long int) (PyArray_NDIM(tmp) >= 1 ?
29200 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
29201 (long int) (PyArray_NDIM(tmp) >= 3 ?
29202 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
29203 (long int) (PyArray_NDIM(tmp) >= 2 ?
29204 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
29205 (long int) (PyArray_NDIM(tmp) >= 1 ?
29206 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
29207 );
29208 {
29209 __failure = 594;
29210 if (!PyErr_Occurred()) {
29211 PyErr_SetString(PyExc_RuntimeError,
29212 "Unexpected error in an Op's C code. "
29213 "No Python exception was set.");
29214 }
29215 goto __label_594;}
29216 }
29217 // This is a TypeError to be consistent with DEBUG_MODE
29218 // Note: DEBUG_MODE also tells the name of the container
29219 if (PyArray_TYPE((PyArrayObject*) py_V593) != NPY_FLOAT64) {
29220 PyErr_Format(PyExc_TypeError,
29221 "expected type_num %d (NPY_FLOAT64) got %d",
29222 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V593));
29223 {
29224 __failure = 594;
29225 if (!PyErr_Occurred()) {
29226 PyErr_SetString(PyExc_RuntimeError,
29227 "Unexpected error in an Op's C code. "
29228 "No Python exception was set.");
29229 }
29230 goto __label_594;}
29231 }
29232
29233 V593 = (PyArrayObject*)(py_V593);
29234 Py_XINCREF(V593);
29235
29236 {
29237
29238 py_V595 = PyList_GET_ITEM(storage_V595, 0);
29239 {Py_XINCREF(py_V595);}
29240
29241 V595 = NULL;
29242 if (py_V595 == Py_None) {
29243 // We can either fail here or set V595 to NULL and rely on Ops
29244 // using tensors to handle the NULL case, but if they fail to do so
29245 // they'll end up with nasty segfaults, so this is public service.
29246 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
29247 {
29248 __failure = 596;
29249 if (!PyErr_Occurred()) {
29250 PyErr_SetString(PyExc_RuntimeError,
29251 "Unexpected error in an Op's C code. "
29252 "No Python exception was set.");
29253 }
29254 goto __label_596;}
29255 }
29256 if (!PyArray_Check(py_V595)) {
29257 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
29258 {
29259 __failure = 596;
29260 if (!PyErr_Occurred()) {
29261 PyErr_SetString(PyExc_RuntimeError,
29262 "Unexpected error in an Op's C code. "
29263 "No Python exception was set.");
29264 }
29265 goto __label_596;}
29266 }
29267 // We expect NPY_FLOAT64
29268 if (!PyArray_ISALIGNED((PyArrayObject*) py_V595)) {
29269 PyArrayObject * tmp = (PyArrayObject*) py_V595;
29270 PyErr_Format(PyExc_NotImplementedError,
29271 "expected an aligned array of type %ld "
29272 "(NPY_FLOAT64), got non-aligned array of type %ld"
29273 " with %ld dimensions, with 3 last dims "
29274 "%ld, %ld, %ld"
29275 " and 3 last strides %ld %ld, %ld.",
29276 (long int) NPY_FLOAT64,
29277 (long int) PyArray_TYPE((PyArrayObject*) py_V595),
29278 (long int) PyArray_NDIM(tmp),
29279 (long int) (PyArray_NDIM(tmp) >= 3 ?
29280 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
29281 (long int) (PyArray_NDIM(tmp) >= 2 ?
29282 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
29283 (long int) (PyArray_NDIM(tmp) >= 1 ?
29284 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
29285 (long int) (PyArray_NDIM(tmp) >= 3 ?
29286 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
29287 (long int) (PyArray_NDIM(tmp) >= 2 ?
29288 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
29289 (long int) (PyArray_NDIM(tmp) >= 1 ?
29290 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
29291 );
29292 {
29293 __failure = 596;
29294 if (!PyErr_Occurred()) {
29295 PyErr_SetString(PyExc_RuntimeError,
29296 "Unexpected error in an Op's C code. "
29297 "No Python exception was set.");
29298 }
29299 goto __label_596;}
29300 }
29301 // This is a TypeError to be consistent with DEBUG_MODE
29302 // Note: DEBUG_MODE also tells the name of the container
29303 if (PyArray_TYPE((PyArrayObject*) py_V595) != NPY_FLOAT64) {
29304 PyErr_Format(PyExc_TypeError,
29305 "expected type_num %d (NPY_FLOAT64) got %d",
29306 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V595));
29307 {
29308 __failure = 596;
29309 if (!PyErr_Occurred()) {
29310 PyErr_SetString(PyExc_RuntimeError,
29311 "Unexpected error in an Op's C code. "
29312 "No Python exception was set.");
29313 }
29314 goto __label_596;}
29315 }
29316
29317 V595 = (PyArrayObject*)(py_V595);
29318 Py_XINCREF(V595);
29319
29320 {
29321
29322 py_V597 = PyList_GET_ITEM(storage_V597, 0);
29323 {Py_XINCREF(py_V597);}
29324
29325 V597 = NULL;
29326 if (py_V597 == Py_None) {
29327 // We can either fail here or set V597 to NULL and rely on Ops
29328 // using tensors to handle the NULL case, but if they fail to do so
29329 // they'll end up with nasty segfaults, so this is public service.
29330 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
29331 {
29332 __failure = 598;
29333 if (!PyErr_Occurred()) {
29334 PyErr_SetString(PyExc_RuntimeError,
29335 "Unexpected error in an Op's C code. "
29336 "No Python exception was set.");
29337 }
29338 goto __label_598;}
29339 }
29340 if (!PyArray_Check(py_V597)) {
29341 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
29342 {
29343 __failure = 598;
29344 if (!PyErr_Occurred()) {
29345 PyErr_SetString(PyExc_RuntimeError,
29346 "Unexpected error in an Op's C code. "
29347 "No Python exception was set.");
29348 }
29349 goto __label_598;}
29350 }
29351 // We expect NPY_FLOAT64
29352 if (!PyArray_ISALIGNED((PyArrayObject*) py_V597)) {
29353 PyArrayObject * tmp = (PyArrayObject*) py_V597;
29354 PyErr_Format(PyExc_NotImplementedError,
29355 "expected an aligned array of type %ld "
29356 "(NPY_FLOAT64), got non-aligned array of type %ld"
29357 " with %ld dimensions, with 3 last dims "
29358 "%ld, %ld, %ld"
29359 " and 3 last strides %ld %ld, %ld.",
29360 (long int) NPY_FLOAT64,
29361 (long int) PyArray_TYPE((PyArrayObject*) py_V597),
29362 (long int) PyArray_NDIM(tmp),
29363 (long int) (PyArray_NDIM(tmp) >= 3 ?
29364 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
29365 (long int) (PyArray_NDIM(tmp) >= 2 ?
29366 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
29367 (long int) (PyArray_NDIM(tmp) >= 1 ?
29368 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
29369 (long int) (PyArray_NDIM(tmp) >= 3 ?
29370 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
29371 (long int) (PyArray_NDIM(tmp) >= 2 ?
29372 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
29373 (long int) (PyArray_NDIM(tmp) >= 1 ?
29374 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
29375 );
29376 {
29377 __failure = 598;
29378 if (!PyErr_Occurred()) {
29379 PyErr_SetString(PyExc_RuntimeError,
29380 "Unexpected error in an Op's C code. "
29381 "No Python exception was set.");
29382 }
29383 goto __label_598;}
29384 }
29385 // This is a TypeError to be consistent with DEBUG_MODE
29386 // Note: DEBUG_MODE also tells the name of the container
29387 if (PyArray_TYPE((PyArrayObject*) py_V597) != NPY_FLOAT64) {
29388 PyErr_Format(PyExc_TypeError,
29389 "expected type_num %d (NPY_FLOAT64) got %d",
29390 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V597));
29391 {
29392 __failure = 598;
29393 if (!PyErr_Occurred()) {
29394 PyErr_SetString(PyExc_RuntimeError,
29395 "Unexpected error in an Op's C code. "
29396 "No Python exception was set.");
29397 }
29398 goto __label_598;}
29399 }
29400
29401 V597 = (PyArrayObject*)(py_V597);
29402 Py_XINCREF(V597);
29403
29404 {
29405
29406 py_V599 = PyList_GET_ITEM(storage_V599, 0);
29407 {Py_XINCREF(py_V599);}
29408
29409 V599 = NULL;
29410 if (py_V599 == Py_None) {
29411 // We can either fail here or set V599 to NULL and rely on Ops
29412 // using tensors to handle the NULL case, but if they fail to do so
29413 // they'll end up with nasty segfaults, so this is public service.
29414 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
29415 {
29416 __failure = 600;
29417 if (!PyErr_Occurred()) {
29418 PyErr_SetString(PyExc_RuntimeError,
29419 "Unexpected error in an Op's C code. "
29420 "No Python exception was set.");
29421 }
29422 goto __label_600;}
29423 }
29424 if (!PyArray_Check(py_V599)) {
29425 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
29426 {
29427 __failure = 600;
29428 if (!PyErr_Occurred()) {
29429 PyErr_SetString(PyExc_RuntimeError,
29430 "Unexpected error in an Op's C code. "
29431 "No Python exception was set.");
29432 }
29433 goto __label_600;}
29434 }
29435 // We expect NPY_FLOAT64
29436 if (!PyArray_ISALIGNED((PyArrayObject*) py_V599)) {
29437 PyArrayObject * tmp = (PyArrayObject*) py_V599;
29438 PyErr_Format(PyExc_NotImplementedError,
29439 "expected an aligned array of type %ld "
29440 "(NPY_FLOAT64), got non-aligned array of type %ld"
29441 " with %ld dimensions, with 3 last dims "
29442 "%ld, %ld, %ld"
29443 " and 3 last strides %ld %ld, %ld.",
29444 (long int) NPY_FLOAT64,
29445 (long int) PyArray_TYPE((PyArrayObject*) py_V599),
29446 (long int) PyArray_NDIM(tmp),
29447 (long int) (PyArray_NDIM(tmp) >= 3 ?
29448 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
29449 (long int) (PyArray_NDIM(tmp) >= 2 ?
29450 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
29451 (long int) (PyArray_NDIM(tmp) >= 1 ?
29452 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
29453 (long int) (PyArray_NDIM(tmp) >= 3 ?
29454 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
29455 (long int) (PyArray_NDIM(tmp) >= 2 ?
29456 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
29457 (long int) (PyArray_NDIM(tmp) >= 1 ?
29458 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
29459 );
29460 {
29461 __failure = 600;
29462 if (!PyErr_Occurred()) {
29463 PyErr_SetString(PyExc_RuntimeError,
29464 "Unexpected error in an Op's C code. "
29465 "No Python exception was set.");
29466 }
29467 goto __label_600;}
29468 }
29469 // This is a TypeError to be consistent with DEBUG_MODE
29470 // Note: DEBUG_MODE also tells the name of the container
29471 if (PyArray_TYPE((PyArrayObject*) py_V599) != NPY_FLOAT64) {
29472 PyErr_Format(PyExc_TypeError,
29473 "expected type_num %d (NPY_FLOAT64) got %d",
29474 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V599));
29475 {
29476 __failure = 600;
29477 if (!PyErr_Occurred()) {
29478 PyErr_SetString(PyExc_RuntimeError,
29479 "Unexpected error in an Op's C code. "
29480 "No Python exception was set.");
29481 }
29482 goto __label_600;}
29483 }
29484
29485 V599 = (PyArrayObject*)(py_V599);
29486 Py_XINCREF(V599);
29487
29488 {
29489
29490 py_V601 = PyList_GET_ITEM(storage_V601, 0);
29491 {Py_XINCREF(py_V601);}
29492
29493 V601 = NULL;
29494 if (py_V601 == Py_None) {
29495 // We can either fail here or set V601 to NULL and rely on Ops
29496 // using tensors to handle the NULL case, but if they fail to do so
29497 // they'll end up with nasty segfaults, so this is public service.
29498 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
29499 {
29500 __failure = 602;
29501 if (!PyErr_Occurred()) {
29502 PyErr_SetString(PyExc_RuntimeError,
29503 "Unexpected error in an Op's C code. "
29504 "No Python exception was set.");
29505 }
29506 goto __label_602;}
29507 }
29508 if (!PyArray_Check(py_V601)) {
29509 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
29510 {
29511 __failure = 602;
29512 if (!PyErr_Occurred()) {
29513 PyErr_SetString(PyExc_RuntimeError,
29514 "Unexpected error in an Op's C code. "
29515 "No Python exception was set.");
29516 }
29517 goto __label_602;}
29518 }
29519 // We expect NPY_FLOAT64
29520 if (!PyArray_ISALIGNED((PyArrayObject*) py_V601)) {
29521 PyArrayObject * tmp = (PyArrayObject*) py_V601;
29522 PyErr_Format(PyExc_NotImplementedError,
29523 "expected an aligned array of type %ld "
29524 "(NPY_FLOAT64), got non-aligned array of type %ld"
29525 " with %ld dimensions, with 3 last dims "
29526 "%ld, %ld, %ld"
29527 " and 3 last strides %ld %ld, %ld.",
29528 (long int) NPY_FLOAT64,
29529 (long int) PyArray_TYPE((PyArrayObject*) py_V601),
29530 (long int) PyArray_NDIM(tmp),
29531 (long int) (PyArray_NDIM(tmp) >= 3 ?
29532 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
29533 (long int) (PyArray_NDIM(tmp) >= 2 ?
29534 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
29535 (long int) (PyArray_NDIM(tmp) >= 1 ?
29536 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
29537 (long int) (PyArray_NDIM(tmp) >= 3 ?
29538 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
29539 (long int) (PyArray_NDIM(tmp) >= 2 ?
29540 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
29541 (long int) (PyArray_NDIM(tmp) >= 1 ?
29542 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
29543 );
29544 {
29545 __failure = 602;
29546 if (!PyErr_Occurred()) {
29547 PyErr_SetString(PyExc_RuntimeError,
29548 "Unexpected error in an Op's C code. "
29549 "No Python exception was set.");
29550 }
29551 goto __label_602;}
29552 }
29553 // This is a TypeError to be consistent with DEBUG_MODE
29554 // Note: DEBUG_MODE also tells the name of the container
29555 if (PyArray_TYPE((PyArrayObject*) py_V601) != NPY_FLOAT64) {
29556 PyErr_Format(PyExc_TypeError,
29557 "expected type_num %d (NPY_FLOAT64) got %d",
29558 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V601));
29559 {
29560 __failure = 602;
29561 if (!PyErr_Occurred()) {
29562 PyErr_SetString(PyExc_RuntimeError,
29563 "Unexpected error in an Op's C code. "
29564 "No Python exception was set.");
29565 }
29566 goto __label_602;}
29567 }
29568
29569 V601 = (PyArrayObject*)(py_V601);
29570 Py_XINCREF(V601);
29571
29572 {
29573
29574 py_V603 = PyList_GET_ITEM(storage_V603, 0);
29575 {Py_XINCREF(py_V603);}
29576
29577 V603 = NULL;
29578 if (py_V603 == Py_None) {
29579 // We can either fail here or set V603 to NULL and rely on Ops
29580 // using tensors to handle the NULL case, but if they fail to do so
29581 // they'll end up with nasty segfaults, so this is public service.
29582 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
29583 {
29584 __failure = 604;
29585 if (!PyErr_Occurred()) {
29586 PyErr_SetString(PyExc_RuntimeError,
29587 "Unexpected error in an Op's C code. "
29588 "No Python exception was set.");
29589 }
29590 goto __label_604;}
29591 }
29592 if (!PyArray_Check(py_V603)) {
29593 PyErr_SetString(PyExc_ValueError, "expected an ndarray");
29594 {
29595 __failure = 604;
29596 if (!PyErr_Occurred()) {
29597 PyErr_SetString(PyExc_RuntimeError,
29598 "Unexpected error in an Op's C code. "
29599 "No Python exception was set.");
29600 }
29601 goto __label_604;}
29602 }
29603 // We expect NPY_FLOAT64
29604 if (!PyArray_ISALIGNED((PyArrayObject*) py_V603)) {
29605 PyArrayObject * tmp = (PyArrayObject*) py_V603;
29606 PyErr_Format(PyExc_NotImplementedError,
29607 "expected an aligned array of type %ld "
29608 "(NPY_FLOAT64), got non-aligned array of type %ld"
29609 " with %ld dimensions, with 3 last dims "
29610 "%ld, %ld, %ld"
29611 " and 3 last strides %ld %ld, %ld.",
29612 (long int) NPY_FLOAT64,
29613 (long int) PyArray_TYPE((PyArrayObject*) py_V603),
29614 (long int) PyArray_NDIM(tmp),
29615 (long int) (PyArray_NDIM(tmp) >= 3 ?
29616 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
29617 (long int) (PyArray_NDIM(tmp) >= 2 ?
29618 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
29619 (long int) (PyArray_NDIM(tmp) >= 1 ?
29620 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
29621 (long int) (PyArray_NDIM(tmp) >= 3 ?
29622 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
29623 (long int) (PyArray_NDIM(tmp) >= 2 ?
29624 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
29625 (long int) (PyArray_NDIM(tmp) >= 1 ?
29626 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
29627 );
29628 {
29629 __failure = 604;
29630 if (!PyErr_Occurred()) {
29631 PyErr_SetString(PyExc_RuntimeError,
29632 "Unexpected error in an Op's C code. "
29633 "No Python exception was set.");
29634 }
29635 goto __label_604;}
29636 }
29637 // This is a TypeError to be consistent with DEBUG_MODE
29638 // Note: DEBUG_MODE also tells the name of the container
29639 if (PyArray_TYPE((PyArrayObject*) py_V603) != NPY_FLOAT64) {
29640 PyErr_Format(PyExc_TypeError,
29641 "expected type_num %d (NPY_FLOAT64) got %d",
29642 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V603));
29643 {
29644 __failure = 604;
29645 if (!PyErr_Occurred()) {
29646 PyErr_SetString(PyExc_RuntimeError,
29647 "Unexpected error in an Op's C code. "
29648 "No Python exception was set.");
29649 }
29650 goto __label_604;}
29651 }
29652
29653 V603 = (PyArrayObject*)(py_V603);
29654 Py_XINCREF(V603);
29655
29656 {
29657 // Op class MakeVector
29658
29659 npy_intp dims[1];
29660 dims[0] = 301;
29661 if(!V1 || PyArray_DIMS(V1)[0] != 301){
29662 Py_XDECREF(V1);
29663 V1 = (PyArrayObject*)PyArray_EMPTY(1, dims, PyArray_TYPE(V3), 0);
29664 }
29665
29666 *((npy_float64 *)PyArray_GETPTR1(V1, 0)) = *((npy_float64 *) PyArray_DATA(V3));
29667
29668 *((npy_float64 *)PyArray_GETPTR1(V1, 1)) = *((npy_float64 *) PyArray_DATA(V5));
29669
29670 *((npy_float64 *)PyArray_GETPTR1(V1, 2)) = *((npy_float64 *) PyArray_DATA(V7));
29671
29672 *((npy_float64 *)PyArray_GETPTR1(V1, 3)) = *((npy_float64 *) PyArray_DATA(V9));
29673
29674 *((npy_float64 *)PyArray_GETPTR1(V1, 4)) = *((npy_float64 *) PyArray_DATA(V11));
29675
29676 *((npy_float64 *)PyArray_GETPTR1(V1, 5)) = *((npy_float64 *) PyArray_DATA(V13));
29677
29678 *((npy_float64 *)PyArray_GETPTR1(V1, 6)) = *((npy_float64 *) PyArray_DATA(V15));
29679
29680 *((npy_float64 *)PyArray_GETPTR1(V1, 7)) = *((npy_float64 *) PyArray_DATA(V17));
29681
29682 *((npy_float64 *)PyArray_GETPTR1(V1, 8)) = *((npy_float64 *) PyArray_DATA(V19));
29683
29684 *((npy_float64 *)PyArray_GETPTR1(V1, 9)) = *((npy_float64 *) PyArray_DATA(V21));
29685
29686 *((npy_float64 *)PyArray_GETPTR1(V1, 10)) = *((npy_float64 *) PyArray_DATA(V23));
29687
29688 *((npy_float64 *)PyArray_GETPTR1(V1, 11)) = *((npy_float64 *) PyArray_DATA(V25));
29689
29690 *((npy_float64 *)PyArray_GETPTR1(V1, 12)) = *((npy_float64 *) PyArray_DATA(V27));
29691
29692 *((npy_float64 *)PyArray_GETPTR1(V1, 13)) = *((npy_float64 *) PyArray_DATA(V29));
29693
29694 *((npy_float64 *)PyArray_GETPTR1(V1, 14)) = *((npy_float64 *) PyArray_DATA(V31));
29695
29696 *((npy_float64 *)PyArray_GETPTR1(V1, 15)) = *((npy_float64 *) PyArray_DATA(V33));
29697
29698 *((npy_float64 *)PyArray_GETPTR1(V1, 16)) = *((npy_float64 *) PyArray_DATA(V35));
29699
29700 *((npy_float64 *)PyArray_GETPTR1(V1, 17)) = *((npy_float64 *) PyArray_DATA(V37));
29701
29702 *((npy_float64 *)PyArray_GETPTR1(V1, 18)) = *((npy_float64 *) PyArray_DATA(V39));
29703
29704 *((npy_float64 *)PyArray_GETPTR1(V1, 19)) = *((npy_float64 *) PyArray_DATA(V41));
29705
29706 *((npy_float64 *)PyArray_GETPTR1(V1, 20)) = *((npy_float64 *) PyArray_DATA(V43));
29707
29708 *((npy_float64 *)PyArray_GETPTR1(V1, 21)) = *((npy_float64 *) PyArray_DATA(V45));
29709
29710 *((npy_float64 *)PyArray_GETPTR1(V1, 22)) = *((npy_float64 *) PyArray_DATA(V47));
29711
29712 *((npy_float64 *)PyArray_GETPTR1(V1, 23)) = *((npy_float64 *) PyArray_DATA(V49));
29713
29714 *((npy_float64 *)PyArray_GETPTR1(V1, 24)) = *((npy_float64 *) PyArray_DATA(V51));
29715
29716 *((npy_float64 *)PyArray_GETPTR1(V1, 25)) = *((npy_float64 *) PyArray_DATA(V53));
29717
29718 *((npy_float64 *)PyArray_GETPTR1(V1, 26)) = *((npy_float64 *) PyArray_DATA(V55));
29719
29720 *((npy_float64 *)PyArray_GETPTR1(V1, 27)) = *((npy_float64 *) PyArray_DATA(V57));
29721
29722 *((npy_float64 *)PyArray_GETPTR1(V1, 28)) = *((npy_float64 *) PyArray_DATA(V59));
29723
29724 *((npy_float64 *)PyArray_GETPTR1(V1, 29)) = *((npy_float64 *) PyArray_DATA(V61));
29725
29726 *((npy_float64 *)PyArray_GETPTR1(V1, 30)) = *((npy_float64 *) PyArray_DATA(V63));
29727
29728 *((npy_float64 *)PyArray_GETPTR1(V1, 31)) = *((npy_float64 *) PyArray_DATA(V65));
29729
29730 *((npy_float64 *)PyArray_GETPTR1(V1, 32)) = *((npy_float64 *) PyArray_DATA(V67));
29731
29732 *((npy_float64 *)PyArray_GETPTR1(V1, 33)) = *((npy_float64 *) PyArray_DATA(V69));
29733
29734 *((npy_float64 *)PyArray_GETPTR1(V1, 34)) = *((npy_float64 *) PyArray_DATA(V71));
29735
29736 *((npy_float64 *)PyArray_GETPTR1(V1, 35)) = *((npy_float64 *) PyArray_DATA(V73));
29737
29738 *((npy_float64 *)PyArray_GETPTR1(V1, 36)) = *((npy_float64 *) PyArray_DATA(V75));
29739
29740 *((npy_float64 *)PyArray_GETPTR1(V1, 37)) = *((npy_float64 *) PyArray_DATA(V77));
29741
29742 *((npy_float64 *)PyArray_GETPTR1(V1, 38)) = *((npy_float64 *) PyArray_DATA(V79));
29743
29744 *((npy_float64 *)PyArray_GETPTR1(V1, 39)) = *((npy_float64 *) PyArray_DATA(V81));
29745
29746 *((npy_float64 *)PyArray_GETPTR1(V1, 40)) = *((npy_float64 *) PyArray_DATA(V83));
29747
29748 *((npy_float64 *)PyArray_GETPTR1(V1, 41)) = *((npy_float64 *) PyArray_DATA(V85));
29749
29750 *((npy_float64 *)PyArray_GETPTR1(V1, 42)) = *((npy_float64 *) PyArray_DATA(V87));
29751
29752 *((npy_float64 *)PyArray_GETPTR1(V1, 43)) = *((npy_float64 *) PyArray_DATA(V89));
29753
29754 *((npy_float64 *)PyArray_GETPTR1(V1, 44)) = *((npy_float64 *) PyArray_DATA(V91));
29755
29756 *((npy_float64 *)PyArray_GETPTR1(V1, 45)) = *((npy_float64 *) PyArray_DATA(V93));
29757
29758 *((npy_float64 *)PyArray_GETPTR1(V1, 46)) = *((npy_float64 *) PyArray_DATA(V95));
29759
29760 *((npy_float64 *)PyArray_GETPTR1(V1, 47)) = *((npy_float64 *) PyArray_DATA(V97));
29761
29762 *((npy_float64 *)PyArray_GETPTR1(V1, 48)) = *((npy_float64 *) PyArray_DATA(V99));
29763
29764 *((npy_float64 *)PyArray_GETPTR1(V1, 49)) = *((npy_float64 *) PyArray_DATA(V101));
29765
29766 *((npy_float64 *)PyArray_GETPTR1(V1, 50)) = *((npy_float64 *) PyArray_DATA(V103));
29767
29768 *((npy_float64 *)PyArray_GETPTR1(V1, 51)) = *((npy_float64 *) PyArray_DATA(V105));
29769
29770 *((npy_float64 *)PyArray_GETPTR1(V1, 52)) = *((npy_float64 *) PyArray_DATA(V107));
29771
29772 *((npy_float64 *)PyArray_GETPTR1(V1, 53)) = *((npy_float64 *) PyArray_DATA(V109));
29773
29774 *((npy_float64 *)PyArray_GETPTR1(V1, 54)) = *((npy_float64 *) PyArray_DATA(V111));
29775
29776 *((npy_float64 *)PyArray_GETPTR1(V1, 55)) = *((npy_float64 *) PyArray_DATA(V113));
29777
29778 *((npy_float64 *)PyArray_GETPTR1(V1, 56)) = *((npy_float64 *) PyArray_DATA(V115));
29779
29780 *((npy_float64 *)PyArray_GETPTR1(V1, 57)) = *((npy_float64 *) PyArray_DATA(V117));
29781
29782 *((npy_float64 *)PyArray_GETPTR1(V1, 58)) = *((npy_float64 *) PyArray_DATA(V119));
29783
29784 *((npy_float64 *)PyArray_GETPTR1(V1, 59)) = *((npy_float64 *) PyArray_DATA(V121));
29785
29786 *((npy_float64 *)PyArray_GETPTR1(V1, 60)) = *((npy_float64 *) PyArray_DATA(V123));
29787
29788 *((npy_float64 *)PyArray_GETPTR1(V1, 61)) = *((npy_float64 *) PyArray_DATA(V125));
29789
29790 *((npy_float64 *)PyArray_GETPTR1(V1, 62)) = *((npy_float64 *) PyArray_DATA(V127));
29791
29792 *((npy_float64 *)PyArray_GETPTR1(V1, 63)) = *((npy_float64 *) PyArray_DATA(V129));
29793
29794 *((npy_float64 *)PyArray_GETPTR1(V1, 64)) = *((npy_float64 *) PyArray_DATA(V131));
29795
29796 *((npy_float64 *)PyArray_GETPTR1(V1, 65)) = *((npy_float64 *) PyArray_DATA(V133));
29797
29798 *((npy_float64 *)PyArray_GETPTR1(V1, 66)) = *((npy_float64 *) PyArray_DATA(V135));
29799
29800 *((npy_float64 *)PyArray_GETPTR1(V1, 67)) = *((npy_float64 *) PyArray_DATA(V137));
29801
29802 *((npy_float64 *)PyArray_GETPTR1(V1, 68)) = *((npy_float64 *) PyArray_DATA(V139));
29803
29804 *((npy_float64 *)PyArray_GETPTR1(V1, 69)) = *((npy_float64 *) PyArray_DATA(V141));
29805
29806 *((npy_float64 *)PyArray_GETPTR1(V1, 70)) = *((npy_float64 *) PyArray_DATA(V143));
29807
29808 *((npy_float64 *)PyArray_GETPTR1(V1, 71)) = *((npy_float64 *) PyArray_DATA(V145));
29809
29810 *((npy_float64 *)PyArray_GETPTR1(V1, 72)) = *((npy_float64 *) PyArray_DATA(V147));
29811
29812 *((npy_float64 *)PyArray_GETPTR1(V1, 73)) = *((npy_float64 *) PyArray_DATA(V149));
29813
29814 *((npy_float64 *)PyArray_GETPTR1(V1, 74)) = *((npy_float64 *) PyArray_DATA(V151));
29815
29816 *((npy_float64 *)PyArray_GETPTR1(V1, 75)) = *((npy_float64 *) PyArray_DATA(V153));
29817
29818 *((npy_float64 *)PyArray_GETPTR1(V1, 76)) = *((npy_float64 *) PyArray_DATA(V155));
29819
29820 *((npy_float64 *)PyArray_GETPTR1(V1, 77)) = *((npy_float64 *) PyArray_DATA(V157));
29821
29822 *((npy_float64 *)PyArray_GETPTR1(V1, 78)) = *((npy_float64 *) PyArray_DATA(V159));
29823
29824 *((npy_float64 *)PyArray_GETPTR1(V1, 79)) = *((npy_float64 *) PyArray_DATA(V161));
29825
29826 *((npy_float64 *)PyArray_GETPTR1(V1, 80)) = *((npy_float64 *) PyArray_DATA(V163));
29827
29828 *((npy_float64 *)PyArray_GETPTR1(V1, 81)) = *((npy_float64 *) PyArray_DATA(V165));
29829
29830 *((npy_float64 *)PyArray_GETPTR1(V1, 82)) = *((npy_float64 *) PyArray_DATA(V167));
29831
29832 *((npy_float64 *)PyArray_GETPTR1(V1, 83)) = *((npy_float64 *) PyArray_DATA(V169));
29833
29834 *((npy_float64 *)PyArray_GETPTR1(V1, 84)) = *((npy_float64 *) PyArray_DATA(V171));
29835
29836 *((npy_float64 *)PyArray_GETPTR1(V1, 85)) = *((npy_float64 *) PyArray_DATA(V173));
29837
29838 *((npy_float64 *)PyArray_GETPTR1(V1, 86)) = *((npy_float64 *) PyArray_DATA(V175));
29839
29840 *((npy_float64 *)PyArray_GETPTR1(V1, 87)) = *((npy_float64 *) PyArray_DATA(V177));
29841
29842 *((npy_float64 *)PyArray_GETPTR1(V1, 88)) = *((npy_float64 *) PyArray_DATA(V179));
29843
29844 *((npy_float64 *)PyArray_GETPTR1(V1, 89)) = *((npy_float64 *) PyArray_DATA(V181));
29845
29846 *((npy_float64 *)PyArray_GETPTR1(V1, 90)) = *((npy_float64 *) PyArray_DATA(V183));
29847
29848 *((npy_float64 *)PyArray_GETPTR1(V1, 91)) = *((npy_float64 *) PyArray_DATA(V185));
29849
29850 *((npy_float64 *)PyArray_GETPTR1(V1, 92)) = *((npy_float64 *) PyArray_DATA(V187));
29851
29852 *((npy_float64 *)PyArray_GETPTR1(V1, 93)) = *((npy_float64 *) PyArray_DATA(V189));
29853
29854 *((npy_float64 *)PyArray_GETPTR1(V1, 94)) = *((npy_float64 *) PyArray_DATA(V191));
29855
29856 *((npy_float64 *)PyArray_GETPTR1(V1, 95)) = *((npy_float64 *) PyArray_DATA(V193));
29857
29858 *((npy_float64 *)PyArray_GETPTR1(V1, 96)) = *((npy_float64 *) PyArray_DATA(V195));
29859
29860 *((npy_float64 *)PyArray_GETPTR1(V1, 97)) = *((npy_float64 *) PyArray_DATA(V197));
29861
29862 *((npy_float64 *)PyArray_GETPTR1(V1, 98)) = *((npy_float64 *) PyArray_DATA(V199));
29863
29864 *((npy_float64 *)PyArray_GETPTR1(V1, 99)) = *((npy_float64 *) PyArray_DATA(V201));
29865
29866 *((npy_float64 *)PyArray_GETPTR1(V1, 100)) = *((npy_float64 *) PyArray_DATA(V203));
29867
29868 *((npy_float64 *)PyArray_GETPTR1(V1, 101)) = *((npy_float64 *) PyArray_DATA(V205));
29869
29870 *((npy_float64 *)PyArray_GETPTR1(V1, 102)) = *((npy_float64 *) PyArray_DATA(V207));
29871
29872 *((npy_float64 *)PyArray_GETPTR1(V1, 103)) = *((npy_float64 *) PyArray_DATA(V209));
29873
29874 *((npy_float64 *)PyArray_GETPTR1(V1, 104)) = *((npy_float64 *) PyArray_DATA(V211));
29875
29876 *((npy_float64 *)PyArray_GETPTR1(V1, 105)) = *((npy_float64 *) PyArray_DATA(V213));
29877
29878 *((npy_float64 *)PyArray_GETPTR1(V1, 106)) = *((npy_float64 *) PyArray_DATA(V215));
29879
29880 *((npy_float64 *)PyArray_GETPTR1(V1, 107)) = *((npy_float64 *) PyArray_DATA(V217));
29881
29882 *((npy_float64 *)PyArray_GETPTR1(V1, 108)) = *((npy_float64 *) PyArray_DATA(V219));
29883
29884 *((npy_float64 *)PyArray_GETPTR1(V1, 109)) = *((npy_float64 *) PyArray_DATA(V221));
29885
29886 *((npy_float64 *)PyArray_GETPTR1(V1, 110)) = *((npy_float64 *) PyArray_DATA(V223));
29887
29888 *((npy_float64 *)PyArray_GETPTR1(V1, 111)) = *((npy_float64 *) PyArray_DATA(V225));
29889
29890 *((npy_float64 *)PyArray_GETPTR1(V1, 112)) = *((npy_float64 *) PyArray_DATA(V227));
29891
29892 *((npy_float64 *)PyArray_GETPTR1(V1, 113)) = *((npy_float64 *) PyArray_DATA(V229));
29893
29894 *((npy_float64 *)PyArray_GETPTR1(V1, 114)) = *((npy_float64 *) PyArray_DATA(V231));
29895
29896 *((npy_float64 *)PyArray_GETPTR1(V1, 115)) = *((npy_float64 *) PyArray_DATA(V233));
29897
29898 *((npy_float64 *)PyArray_GETPTR1(V1, 116)) = *((npy_float64 *) PyArray_DATA(V235));
29899
29900 *((npy_float64 *)PyArray_GETPTR1(V1, 117)) = *((npy_float64 *) PyArray_DATA(V237));
29901
29902 *((npy_float64 *)PyArray_GETPTR1(V1, 118)) = *((npy_float64 *) PyArray_DATA(V239));
29903
29904 *((npy_float64 *)PyArray_GETPTR1(V1, 119)) = *((npy_float64 *) PyArray_DATA(V241));
29905
29906 *((npy_float64 *)PyArray_GETPTR1(V1, 120)) = *((npy_float64 *) PyArray_DATA(V243));
29907
29908 *((npy_float64 *)PyArray_GETPTR1(V1, 121)) = *((npy_float64 *) PyArray_DATA(V245));
29909
29910 *((npy_float64 *)PyArray_GETPTR1(V1, 122)) = *((npy_float64 *) PyArray_DATA(V247));
29911
29912 *((npy_float64 *)PyArray_GETPTR1(V1, 123)) = *((npy_float64 *) PyArray_DATA(V249));
29913
29914 *((npy_float64 *)PyArray_GETPTR1(V1, 124)) = *((npy_float64 *) PyArray_DATA(V251));
29915
29916 *((npy_float64 *)PyArray_GETPTR1(V1, 125)) = *((npy_float64 *) PyArray_DATA(V253));
29917
29918 *((npy_float64 *)PyArray_GETPTR1(V1, 126)) = *((npy_float64 *) PyArray_DATA(V255));
29919
29920 *((npy_float64 *)PyArray_GETPTR1(V1, 127)) = *((npy_float64 *) PyArray_DATA(V257));
29921
29922 *((npy_float64 *)PyArray_GETPTR1(V1, 128)) = *((npy_float64 *) PyArray_DATA(V259));
29923
29924 *((npy_float64 *)PyArray_GETPTR1(V1, 129)) = *((npy_float64 *) PyArray_DATA(V261));
29925
29926 *((npy_float64 *)PyArray_GETPTR1(V1, 130)) = *((npy_float64 *) PyArray_DATA(V263));
29927
29928 *((npy_float64 *)PyArray_GETPTR1(V1, 131)) = *((npy_float64 *) PyArray_DATA(V265));
29929
29930 *((npy_float64 *)PyArray_GETPTR1(V1, 132)) = *((npy_float64 *) PyArray_DATA(V267));
29931
29932 *((npy_float64 *)PyArray_GETPTR1(V1, 133)) = *((npy_float64 *) PyArray_DATA(V269));
29933
29934 *((npy_float64 *)PyArray_GETPTR1(V1, 134)) = *((npy_float64 *) PyArray_DATA(V271));
29935
29936 *((npy_float64 *)PyArray_GETPTR1(V1, 135)) = *((npy_float64 *) PyArray_DATA(V273));
29937
29938 *((npy_float64 *)PyArray_GETPTR1(V1, 136)) = *((npy_float64 *) PyArray_DATA(V275));
29939
29940 *((npy_float64 *)PyArray_GETPTR1(V1, 137)) = *((npy_float64 *) PyArray_DATA(V277));
29941
29942 *((npy_float64 *)PyArray_GETPTR1(V1, 138)) = *((npy_float64 *) PyArray_DATA(V279));
29943
29944 *((npy_float64 *)PyArray_GETPTR1(V1, 139)) = *((npy_float64 *) PyArray_DATA(V281));
29945
29946 *((npy_float64 *)PyArray_GETPTR1(V1, 140)) = *((npy_float64 *) PyArray_DATA(V283));
29947
29948 *((npy_float64 *)PyArray_GETPTR1(V1, 141)) = *((npy_float64 *) PyArray_DATA(V285));
29949
29950 *((npy_float64 *)PyArray_GETPTR1(V1, 142)) = *((npy_float64 *) PyArray_DATA(V287));
29951
29952 *((npy_float64 *)PyArray_GETPTR1(V1, 143)) = *((npy_float64 *) PyArray_DATA(V289));
29953
29954 *((npy_float64 *)PyArray_GETPTR1(V1, 144)) = *((npy_float64 *) PyArray_DATA(V291));
29955
29956 *((npy_float64 *)PyArray_GETPTR1(V1, 145)) = *((npy_float64 *) PyArray_DATA(V293));
29957
29958 *((npy_float64 *)PyArray_GETPTR1(V1, 146)) = *((npy_float64 *) PyArray_DATA(V295));
29959
29960 *((npy_float64 *)PyArray_GETPTR1(V1, 147)) = *((npy_float64 *) PyArray_DATA(V297));
29961
29962 *((npy_float64 *)PyArray_GETPTR1(V1, 148)) = *((npy_float64 *) PyArray_DATA(V299));
29963
29964 *((npy_float64 *)PyArray_GETPTR1(V1, 149)) = *((npy_float64 *) PyArray_DATA(V301));
29965
29966 *((npy_float64 *)PyArray_GETPTR1(V1, 150)) = *((npy_float64 *) PyArray_DATA(V303));
29967
29968 *((npy_float64 *)PyArray_GETPTR1(V1, 151)) = *((npy_float64 *) PyArray_DATA(V305));
29969
29970 *((npy_float64 *)PyArray_GETPTR1(V1, 152)) = *((npy_float64 *) PyArray_DATA(V307));
29971
29972 *((npy_float64 *)PyArray_GETPTR1(V1, 153)) = *((npy_float64 *) PyArray_DATA(V309));
29973
29974 *((npy_float64 *)PyArray_GETPTR1(V1, 154)) = *((npy_float64 *) PyArray_DATA(V311));
29975
29976 *((npy_float64 *)PyArray_GETPTR1(V1, 155)) = *((npy_float64 *) PyArray_DATA(V313));
29977
29978 *((npy_float64 *)PyArray_GETPTR1(V1, 156)) = *((npy_float64 *) PyArray_DATA(V315));
29979
29980 *((npy_float64 *)PyArray_GETPTR1(V1, 157)) = *((npy_float64 *) PyArray_DATA(V317));
29981
29982 *((npy_float64 *)PyArray_GETPTR1(V1, 158)) = *((npy_float64 *) PyArray_DATA(V319));
29983
29984 *((npy_float64 *)PyArray_GETPTR1(V1, 159)) = *((npy_float64 *) PyArray_DATA(V321));
29985
29986 *((npy_float64 *)PyArray_GETPTR1(V1, 160)) = *((npy_float64 *) PyArray_DATA(V323));
29987
29988 *((npy_float64 *)PyArray_GETPTR1(V1, 161)) = *((npy_float64 *) PyArray_DATA(V325));
29989
29990 *((npy_float64 *)PyArray_GETPTR1(V1, 162)) = *((npy_float64 *) PyArray_DATA(V327));
29991
29992 *((npy_float64 *)PyArray_GETPTR1(V1, 163)) = *((npy_float64 *) PyArray_DATA(V329));
29993
29994 *((npy_float64 *)PyArray_GETPTR1(V1, 164)) = *((npy_float64 *) PyArray_DATA(V331));
29995
29996 *((npy_float64 *)PyArray_GETPTR1(V1, 165)) = *((npy_float64 *) PyArray_DATA(V333));
29997
29998 *((npy_float64 *)PyArray_GETPTR1(V1, 166)) = *((npy_float64 *) PyArray_DATA(V335));
29999
30000 *((npy_float64 *)PyArray_GETPTR1(V1, 167)) = *((npy_float64 *) PyArray_DATA(V337));
30001
30002 *((npy_float64 *)PyArray_GETPTR1(V1, 168)) = *((npy_float64 *) PyArray_DATA(V339));
30003
30004 *((npy_float64 *)PyArray_GETPTR1(V1, 169)) = *((npy_float64 *) PyArray_DATA(V341));
30005
30006 *((npy_float64 *)PyArray_GETPTR1(V1, 170)) = *((npy_float64 *) PyArray_DATA(V343));
30007
30008 *((npy_float64 *)PyArray_GETPTR1(V1, 171)) = *((npy_float64 *) PyArray_DATA(V345));
30009
30010 *((npy_float64 *)PyArray_GETPTR1(V1, 172)) = *((npy_float64 *) PyArray_DATA(V347));
30011
30012 *((npy_float64 *)PyArray_GETPTR1(V1, 173)) = *((npy_float64 *) PyArray_DATA(V349));
30013
30014 *((npy_float64 *)PyArray_GETPTR1(V1, 174)) = *((npy_float64 *) PyArray_DATA(V351));
30015
30016 *((npy_float64 *)PyArray_GETPTR1(V1, 175)) = *((npy_float64 *) PyArray_DATA(V353));
30017
30018 *((npy_float64 *)PyArray_GETPTR1(V1, 176)) = *((npy_float64 *) PyArray_DATA(V355));
30019
30020 *((npy_float64 *)PyArray_GETPTR1(V1, 177)) = *((npy_float64 *) PyArray_DATA(V357));
30021
30022 *((npy_float64 *)PyArray_GETPTR1(V1, 178)) = *((npy_float64 *) PyArray_DATA(V359));
30023
30024 *((npy_float64 *)PyArray_GETPTR1(V1, 179)) = *((npy_float64 *) PyArray_DATA(V361));
30025
30026 *((npy_float64 *)PyArray_GETPTR1(V1, 180)) = *((npy_float64 *) PyArray_DATA(V363));
30027
30028 *((npy_float64 *)PyArray_GETPTR1(V1, 181)) = *((npy_float64 *) PyArray_DATA(V365));
30029
30030 *((npy_float64 *)PyArray_GETPTR1(V1, 182)) = *((npy_float64 *) PyArray_DATA(V367));
30031
30032 *((npy_float64 *)PyArray_GETPTR1(V1, 183)) = *((npy_float64 *) PyArray_DATA(V369));
30033
30034 *((npy_float64 *)PyArray_GETPTR1(V1, 184)) = *((npy_float64 *) PyArray_DATA(V371));
30035
30036 *((npy_float64 *)PyArray_GETPTR1(V1, 185)) = *((npy_float64 *) PyArray_DATA(V373));
30037
30038 *((npy_float64 *)PyArray_GETPTR1(V1, 186)) = *((npy_float64 *) PyArray_DATA(V375));
30039
30040 *((npy_float64 *)PyArray_GETPTR1(V1, 187)) = *((npy_float64 *) PyArray_DATA(V377));
30041
30042 *((npy_float64 *)PyArray_GETPTR1(V1, 188)) = *((npy_float64 *) PyArray_DATA(V379));
30043
30044 *((npy_float64 *)PyArray_GETPTR1(V1, 189)) = *((npy_float64 *) PyArray_DATA(V381));
30045
30046 *((npy_float64 *)PyArray_GETPTR1(V1, 190)) = *((npy_float64 *) PyArray_DATA(V383));
30047
30048 *((npy_float64 *)PyArray_GETPTR1(V1, 191)) = *((npy_float64 *) PyArray_DATA(V385));
30049
30050 *((npy_float64 *)PyArray_GETPTR1(V1, 192)) = *((npy_float64 *) PyArray_DATA(V387));
30051
30052 *((npy_float64 *)PyArray_GETPTR1(V1, 193)) = *((npy_float64 *) PyArray_DATA(V389));
30053
30054 *((npy_float64 *)PyArray_GETPTR1(V1, 194)) = *((npy_float64 *) PyArray_DATA(V391));
30055
30056 *((npy_float64 *)PyArray_GETPTR1(V1, 195)) = *((npy_float64 *) PyArray_DATA(V393));
30057
30058 *((npy_float64 *)PyArray_GETPTR1(V1, 196)) = *((npy_float64 *) PyArray_DATA(V395));
30059
30060 *((npy_float64 *)PyArray_GETPTR1(V1, 197)) = *((npy_float64 *) PyArray_DATA(V397));
30061
30062 *((npy_float64 *)PyArray_GETPTR1(V1, 198)) = *((npy_float64 *) PyArray_DATA(V399));
30063
30064 *((npy_float64 *)PyArray_GETPTR1(V1, 199)) = *((npy_float64 *) PyArray_DATA(V401));
30065
30066 *((npy_float64 *)PyArray_GETPTR1(V1, 200)) = *((npy_float64 *) PyArray_DATA(V403));
30067
30068 *((npy_float64 *)PyArray_GETPTR1(V1, 201)) = *((npy_float64 *) PyArray_DATA(V405));
30069
30070 *((npy_float64 *)PyArray_GETPTR1(V1, 202)) = *((npy_float64 *) PyArray_DATA(V407));
30071
30072 *((npy_float64 *)PyArray_GETPTR1(V1, 203)) = *((npy_float64 *) PyArray_DATA(V409));
30073
30074 *((npy_float64 *)PyArray_GETPTR1(V1, 204)) = *((npy_float64 *) PyArray_DATA(V411));
30075
30076 *((npy_float64 *)PyArray_GETPTR1(V1, 205)) = *((npy_float64 *) PyArray_DATA(V413));
30077
30078 *((npy_float64 *)PyArray_GETPTR1(V1, 206)) = *((npy_float64 *) PyArray_DATA(V415));
30079
30080 *((npy_float64 *)PyArray_GETPTR1(V1, 207)) = *((npy_float64 *) PyArray_DATA(V417));
30081
30082 *((npy_float64 *)PyArray_GETPTR1(V1, 208)) = *((npy_float64 *) PyArray_DATA(V419));
30083
30084 *((npy_float64 *)PyArray_GETPTR1(V1, 209)) = *((npy_float64 *) PyArray_DATA(V421));
30085
30086 *((npy_float64 *)PyArray_GETPTR1(V1, 210)) = *((npy_float64 *) PyArray_DATA(V423));
30087
30088 *((npy_float64 *)PyArray_GETPTR1(V1, 211)) = *((npy_float64 *) PyArray_DATA(V425));
30089
30090 *((npy_float64 *)PyArray_GETPTR1(V1, 212)) = *((npy_float64 *) PyArray_DATA(V427));
30091
30092 *((npy_float64 *)PyArray_GETPTR1(V1, 213)) = *((npy_float64 *) PyArray_DATA(V429));
30093
30094 *((npy_float64 *)PyArray_GETPTR1(V1, 214)) = *((npy_float64 *) PyArray_DATA(V431));
30095
30096 *((npy_float64 *)PyArray_GETPTR1(V1, 215)) = *((npy_float64 *) PyArray_DATA(V433));
30097
30098 *((npy_float64 *)PyArray_GETPTR1(V1, 216)) = *((npy_float64 *) PyArray_DATA(V435));
30099
30100 *((npy_float64 *)PyArray_GETPTR1(V1, 217)) = *((npy_float64 *) PyArray_DATA(V437));
30101
30102 *((npy_float64 *)PyArray_GETPTR1(V1, 218)) = *((npy_float64 *) PyArray_DATA(V439));
30103
30104 *((npy_float64 *)PyArray_GETPTR1(V1, 219)) = *((npy_float64 *) PyArray_DATA(V441));
30105
30106 *((npy_float64 *)PyArray_GETPTR1(V1, 220)) = *((npy_float64 *) PyArray_DATA(V443));
30107
30108 *((npy_float64 *)PyArray_GETPTR1(V1, 221)) = *((npy_float64 *) PyArray_DATA(V445));
30109
30110 *((npy_float64 *)PyArray_GETPTR1(V1, 222)) = *((npy_float64 *) PyArray_DATA(V447));
30111
30112 *((npy_float64 *)PyArray_GETPTR1(V1, 223)) = *((npy_float64 *) PyArray_DATA(V449));
30113
30114 *((npy_float64 *)PyArray_GETPTR1(V1, 224)) = *((npy_float64 *) PyArray_DATA(V451));
30115
30116 *((npy_float64 *)PyArray_GETPTR1(V1, 225)) = *((npy_float64 *) PyArray_DATA(V453));
30117
30118 *((npy_float64 *)PyArray_GETPTR1(V1, 226)) = *((npy_float64 *) PyArray_DATA(V455));
30119
30120 *((npy_float64 *)PyArray_GETPTR1(V1, 227)) = *((npy_float64 *) PyArray_DATA(V457));
30121
30122 *((npy_float64 *)PyArray_GETPTR1(V1, 228)) = *((npy_float64 *) PyArray_DATA(V459));
30123
30124 *((npy_float64 *)PyArray_GETPTR1(V1, 229)) = *((npy_float64 *) PyArray_DATA(V461));
30125
30126 *((npy_float64 *)PyArray_GETPTR1(V1, 230)) = *((npy_float64 *) PyArray_DATA(V463));
30127
30128 *((npy_float64 *)PyArray_GETPTR1(V1, 231)) = *((npy_float64 *) PyArray_DATA(V465));
30129
30130 *((npy_float64 *)PyArray_GETPTR1(V1, 232)) = *((npy_float64 *) PyArray_DATA(V467));
30131
30132 *((npy_float64 *)PyArray_GETPTR1(V1, 233)) = *((npy_float64 *) PyArray_DATA(V469));
30133
30134 *((npy_float64 *)PyArray_GETPTR1(V1, 234)) = *((npy_float64 *) PyArray_DATA(V471));
30135
30136 *((npy_float64 *)PyArray_GETPTR1(V1, 235)) = *((npy_float64 *) PyArray_DATA(V473));
30137
30138 *((npy_float64 *)PyArray_GETPTR1(V1, 236)) = *((npy_float64 *) PyArray_DATA(V475));
30139
30140 *((npy_float64 *)PyArray_GETPTR1(V1, 237)) = *((npy_float64 *) PyArray_DATA(V477));
30141
30142 *((npy_float64 *)PyArray_GETPTR1(V1, 238)) = *((npy_float64 *) PyArray_DATA(V479));
30143
30144 *((npy_float64 *)PyArray_GETPTR1(V1, 239)) = *((npy_float64 *) PyArray_DATA(V481));
30145
30146 *((npy_float64 *)PyArray_GETPTR1(V1, 240)) = *((npy_float64 *) PyArray_DATA(V483));
30147
30148 *((npy_float64 *)PyArray_GETPTR1(V1, 241)) = *((npy_float64 *) PyArray_DATA(V485));
30149
30150 *((npy_float64 *)PyArray_GETPTR1(V1, 242)) = *((npy_float64 *) PyArray_DATA(V487));
30151
30152 *((npy_float64 *)PyArray_GETPTR1(V1, 243)) = *((npy_float64 *) PyArray_DATA(V489));
30153
30154 *((npy_float64 *)PyArray_GETPTR1(V1, 244)) = *((npy_float64 *) PyArray_DATA(V491));
30155
30156 *((npy_float64 *)PyArray_GETPTR1(V1, 245)) = *((npy_float64 *) PyArray_DATA(V493));
30157
30158 *((npy_float64 *)PyArray_GETPTR1(V1, 246)) = *((npy_float64 *) PyArray_DATA(V495));
30159
30160 *((npy_float64 *)PyArray_GETPTR1(V1, 247)) = *((npy_float64 *) PyArray_DATA(V497));
30161
30162 *((npy_float64 *)PyArray_GETPTR1(V1, 248)) = *((npy_float64 *) PyArray_DATA(V499));
30163
30164 *((npy_float64 *)PyArray_GETPTR1(V1, 249)) = *((npy_float64 *) PyArray_DATA(V501));
30165
30166 *((npy_float64 *)PyArray_GETPTR1(V1, 250)) = *((npy_float64 *) PyArray_DATA(V503));
30167
30168 *((npy_float64 *)PyArray_GETPTR1(V1, 251)) = *((npy_float64 *) PyArray_DATA(V505));
30169
30170 *((npy_float64 *)PyArray_GETPTR1(V1, 252)) = *((npy_float64 *) PyArray_DATA(V507));
30171
30172 *((npy_float64 *)PyArray_GETPTR1(V1, 253)) = *((npy_float64 *) PyArray_DATA(V509));
30173
30174 *((npy_float64 *)PyArray_GETPTR1(V1, 254)) = *((npy_float64 *) PyArray_DATA(V511));
30175
30176 *((npy_float64 *)PyArray_GETPTR1(V1, 255)) = *((npy_float64 *) PyArray_DATA(V513));
30177
30178 *((npy_float64 *)PyArray_GETPTR1(V1, 256)) = *((npy_float64 *) PyArray_DATA(V515));
30179
30180 *((npy_float64 *)PyArray_GETPTR1(V1, 257)) = *((npy_float64 *) PyArray_DATA(V517));
30181
30182 *((npy_float64 *)PyArray_GETPTR1(V1, 258)) = *((npy_float64 *) PyArray_DATA(V519));
30183
30184 *((npy_float64 *)PyArray_GETPTR1(V1, 259)) = *((npy_float64 *) PyArray_DATA(V521));
30185
30186 *((npy_float64 *)PyArray_GETPTR1(V1, 260)) = *((npy_float64 *) PyArray_DATA(V523));
30187
30188 *((npy_float64 *)PyArray_GETPTR1(V1, 261)) = *((npy_float64 *) PyArray_DATA(V525));
30189
30190 *((npy_float64 *)PyArray_GETPTR1(V1, 262)) = *((npy_float64 *) PyArray_DATA(V527));
30191
30192 *((npy_float64 *)PyArray_GETPTR1(V1, 263)) = *((npy_float64 *) PyArray_DATA(V529));
30193
30194 *((npy_float64 *)PyArray_GETPTR1(V1, 264)) = *((npy_float64 *) PyArray_DATA(V531));
30195
30196 *((npy_float64 *)PyArray_GETPTR1(V1, 265)) = *((npy_float64 *) PyArray_DATA(V533));
30197
30198 *((npy_float64 *)PyArray_GETPTR1(V1, 266)) = *((npy_float64 *) PyArray_DATA(V535));
30199
30200 *((npy_float64 *)PyArray_GETPTR1(V1, 267)) = *((npy_float64 *) PyArray_DATA(V537));
30201
30202 *((npy_float64 *)PyArray_GETPTR1(V1, 268)) = *((npy_float64 *) PyArray_DATA(V539));
30203
30204 *((npy_float64 *)PyArray_GETPTR1(V1, 269)) = *((npy_float64 *) PyArray_DATA(V541));
30205
30206 *((npy_float64 *)PyArray_GETPTR1(V1, 270)) = *((npy_float64 *) PyArray_DATA(V543));
30207
30208 *((npy_float64 *)PyArray_GETPTR1(V1, 271)) = *((npy_float64 *) PyArray_DATA(V545));
30209
30210 *((npy_float64 *)PyArray_GETPTR1(V1, 272)) = *((npy_float64 *) PyArray_DATA(V547));
30211
30212 *((npy_float64 *)PyArray_GETPTR1(V1, 273)) = *((npy_float64 *) PyArray_DATA(V549));
30213
30214 *((npy_float64 *)PyArray_GETPTR1(V1, 274)) = *((npy_float64 *) PyArray_DATA(V551));
30215
30216 *((npy_float64 *)PyArray_GETPTR1(V1, 275)) = *((npy_float64 *) PyArray_DATA(V553));
30217
30218 *((npy_float64 *)PyArray_GETPTR1(V1, 276)) = *((npy_float64 *) PyArray_DATA(V555));
30219
30220 *((npy_float64 *)PyArray_GETPTR1(V1, 277)) = *((npy_float64 *) PyArray_DATA(V557));
30221
30222 *((npy_float64 *)PyArray_GETPTR1(V1, 278)) = *((npy_float64 *) PyArray_DATA(V559));
30223
30224 *((npy_float64 *)PyArray_GETPTR1(V1, 279)) = *((npy_float64 *) PyArray_DATA(V561));
30225
30226 *((npy_float64 *)PyArray_GETPTR1(V1, 280)) = *((npy_float64 *) PyArray_DATA(V563));
30227
30228 *((npy_float64 *)PyArray_GETPTR1(V1, 281)) = *((npy_float64 *) PyArray_DATA(V565));
30229
30230 *((npy_float64 *)PyArray_GETPTR1(V1, 282)) = *((npy_float64 *) PyArray_DATA(V567));
30231
30232 *((npy_float64 *)PyArray_GETPTR1(V1, 283)) = *((npy_float64 *) PyArray_DATA(V569));
30233
30234 *((npy_float64 *)PyArray_GETPTR1(V1, 284)) = *((npy_float64 *) PyArray_DATA(V571));
30235
30236 *((npy_float64 *)PyArray_GETPTR1(V1, 285)) = *((npy_float64 *) PyArray_DATA(V573));
30237
30238 *((npy_float64 *)PyArray_GETPTR1(V1, 286)) = *((npy_float64 *) PyArray_DATA(V575));
30239
30240 *((npy_float64 *)PyArray_GETPTR1(V1, 287)) = *((npy_float64 *) PyArray_DATA(V577));
30241
30242 *((npy_float64 *)PyArray_GETPTR1(V1, 288)) = *((npy_float64 *) PyArray_DATA(V579));
30243
30244 *((npy_float64 *)PyArray_GETPTR1(V1, 289)) = *((npy_float64 *) PyArray_DATA(V581));
30245
30246 *((npy_float64 *)PyArray_GETPTR1(V1, 290)) = *((npy_float64 *) PyArray_DATA(V583));
30247
30248 *((npy_float64 *)PyArray_GETPTR1(V1, 291)) = *((npy_float64 *) PyArray_DATA(V585));
30249
30250 *((npy_float64 *)PyArray_GETPTR1(V1, 292)) = *((npy_float64 *) PyArray_DATA(V587));
30251
30252 *((npy_float64 *)PyArray_GETPTR1(V1, 293)) = *((npy_float64 *) PyArray_DATA(V589));
30253
30254 *((npy_float64 *)PyArray_GETPTR1(V1, 294)) = *((npy_float64 *) PyArray_DATA(V591));
30255
30256 *((npy_float64 *)PyArray_GETPTR1(V1, 295)) = *((npy_float64 *) PyArray_DATA(V593));
30257
30258 *((npy_float64 *)PyArray_GETPTR1(V1, 296)) = *((npy_float64 *) PyArray_DATA(V595));
30259
30260 *((npy_float64 *)PyArray_GETPTR1(V1, 297)) = *((npy_float64 *) PyArray_DATA(V597));
30261
30262 *((npy_float64 *)PyArray_GETPTR1(V1, 298)) = *((npy_float64 *) PyArray_DATA(V599));
30263
30264 *((npy_float64 *)PyArray_GETPTR1(V1, 299)) = *((npy_float64 *) PyArray_DATA(V601));
30265
30266 *((npy_float64 *)PyArray_GETPTR1(V1, 300)) = *((npy_float64 *) PyArray_DATA(V603));
30267 __label_605:
30268
30269 double __DUMMY_605;
30270
30271 }
30272 __label_604:
30273
30274 if (V603) {
30275 Py_XDECREF(V603);
30276 }
30277
30278 {Py_XDECREF(py_V603);}
30279
30280 double __DUMMY_604;
30281
30282 }
30283 __label_602:
30284
30285 if (V601) {
30286 Py_XDECREF(V601);
30287 }
30288
30289 {Py_XDECREF(py_V601);}
30290
30291 double __DUMMY_602;
30292
30293 }
30294 __label_600:
30295
30296 if (V599) {
30297 Py_XDECREF(V599);
30298 }
30299
30300 {Py_XDECREF(py_V599);}
30301
30302 double __DUMMY_600;
30303
30304 }
30305 __label_598:
30306
30307 if (V597) {
30308 Py_XDECREF(V597);
30309 }
30310
30311 {Py_XDECREF(py_V597);}
30312
30313 double __DUMMY_598;
30314
30315 }
30316 __label_596:
30317
30318 if (V595) {
30319 Py_XDECREF(V595);
30320 }
30321
30322 {Py_XDECREF(py_V595);}
30323
30324 double __DUMMY_596;
30325
30326 }
30327 __label_594:
30328
30329 if (V593) {
30330 Py_XDECREF(V593);
30331 }
30332
30333 {Py_XDECREF(py_V593);}
30334
30335 double __DUMMY_594;
30336
30337 }
30338 __label_592:
30339
30340 if (V591) {
30341 Py_XDECREF(V591);
30342 }
30343
30344 {Py_XDECREF(py_V591);}
30345
30346 double __DUMMY_592;
30347
30348 }
30349 __label_590:
30350
30351 if (V589) {
30352 Py_XDECREF(V589);
30353 }
30354
30355 {Py_XDECREF(py_V589);}
30356
30357 double __DUMMY_590;
30358
30359 }
30360 __label_588:
30361
30362 if (V587) {
30363 Py_XDECREF(V587);
30364 }
30365
30366 {Py_XDECREF(py_V587);}
30367
30368 double __DUMMY_588;
30369
30370 }
30371 __label_586:
30372
30373 if (V585) {
30374 Py_XDECREF(V585);
30375 }
30376
30377 {Py_XDECREF(py_V585);}
30378
30379 double __DUMMY_586;
30380
30381 }
30382 __label_584:
30383
30384 if (V583) {
30385 Py_XDECREF(V583);
30386 }
30387
30388 {Py_XDECREF(py_V583);}
30389
30390 double __DUMMY_584;
30391
30392 }
30393 __label_582:
30394
30395 if (V581) {
30396 Py_XDECREF(V581);
30397 }
30398
30399 {Py_XDECREF(py_V581);}
30400
30401 double __DUMMY_582;
30402
30403 }
30404 __label_580:
30405
30406 if (V579) {
30407 Py_XDECREF(V579);
30408 }
30409
30410 {Py_XDECREF(py_V579);}
30411
30412 double __DUMMY_580;
30413
30414 }
30415 __label_578:
30416
30417 if (V577) {
30418 Py_XDECREF(V577);
30419 }
30420
30421 {Py_XDECREF(py_V577);}
30422
30423 double __DUMMY_578;
30424
30425 }
30426 __label_576:
30427
30428 if (V575) {
30429 Py_XDECREF(V575);
30430 }
30431
30432 {Py_XDECREF(py_V575);}
30433
30434 double __DUMMY_576;
30435
30436 }
30437 __label_574:
30438
30439 if (V573) {
30440 Py_XDECREF(V573);
30441 }
30442
30443 {Py_XDECREF(py_V573);}
30444
30445 double __DUMMY_574;
30446
30447 }
30448 __label_572:
30449
30450 if (V571) {
30451 Py_XDECREF(V571);
30452 }
30453
30454 {Py_XDECREF(py_V571);}
30455
30456 double __DUMMY_572;
30457
30458 }
30459 __label_570:
30460
30461 if (V569) {
30462 Py_XDECREF(V569);
30463 }
30464
30465 {Py_XDECREF(py_V569);}
30466
30467 double __DUMMY_570;
30468
30469 }
30470 __label_568:
30471
30472 if (V567) {
30473 Py_XDECREF(V567);
30474 }
30475
30476 {Py_XDECREF(py_V567);}
30477
30478 double __DUMMY_568;
30479
30480 }
30481 __label_566:
30482
30483 if (V565) {
30484 Py_XDECREF(V565);
30485 }
30486
30487 {Py_XDECREF(py_V565);}
30488
30489 double __DUMMY_566;
30490
30491 }
30492 __label_564:
30493
30494 if (V563) {
30495 Py_XDECREF(V563);
30496 }
30497
30498 {Py_XDECREF(py_V563);}
30499
30500 double __DUMMY_564;
30501
30502 }
30503 __label_562:
30504
30505 if (V561) {
30506 Py_XDECREF(V561);
30507 }
30508
30509 {Py_XDECREF(py_V561);}
30510
30511 double __DUMMY_562;
30512
30513 }
30514 __label_560:
30515
30516 if (V559) {
30517 Py_XDECREF(V559);
30518 }
30519
30520 {Py_XDECREF(py_V559);}
30521
30522 double __DUMMY_560;
30523
30524 }
30525 __label_558:
30526
30527 if (V557) {
30528 Py_XDECREF(V557);
30529 }
30530
30531 {Py_XDECREF(py_V557);}
30532
30533 double __DUMMY_558;
30534
30535 }
30536 __label_556:
30537
30538 if (V555) {
30539 Py_XDECREF(V555);
30540 }
30541
30542 {Py_XDECREF(py_V555);}
30543
30544 double __DUMMY_556;
30545
30546 }
30547 __label_554:
30548
30549 if (V553) {
30550 Py_XDECREF(V553);
30551 }
30552
30553 {Py_XDECREF(py_V553);}
30554
30555 double __DUMMY_554;
30556
30557 }
30558 __label_552:
30559
30560 if (V551) {
30561 Py_XDECREF(V551);
30562 }
30563
30564 {Py_XDECREF(py_V551);}
30565
30566 double __DUMMY_552;
30567
30568 }
30569 __label_550:
30570
30571 if (V549) {
30572 Py_XDECREF(V549);
30573 }
30574
30575 {Py_XDECREF(py_V549);}
30576
30577 double __DUMMY_550;
30578
30579 }
30580 __label_548:
30581
30582 if (V547) {
30583 Py_XDECREF(V547);
30584 }
30585
30586 {Py_XDECREF(py_V547);}
30587
30588 double __DUMMY_548;
30589
30590 }
30591 __label_546:
30592
30593 if (V545) {
30594 Py_XDECREF(V545);
30595 }
30596
30597 {Py_XDECREF(py_V545);}
30598
30599 double __DUMMY_546;
30600
30601 }
30602 __label_544:
30603
30604 if (V543) {
30605 Py_XDECREF(V543);
30606 }
30607
30608 {Py_XDECREF(py_V543);}
30609
30610 double __DUMMY_544;
30611
30612 }
30613 __label_542:
30614
30615 if (V541) {
30616 Py_XDECREF(V541);
30617 }
30618
30619 {Py_XDECREF(py_V541);}
30620
30621 double __DUMMY_542;
30622
30623 }
30624 __label_540:
30625
30626 if (V539) {
30627 Py_XDECREF(V539);
30628 }
30629
30630 {Py_XDECREF(py_V539);}
30631
30632 double __DUMMY_540;
30633
30634 }
30635 __label_538:
30636
30637 if (V537) {
30638 Py_XDECREF(V537);
30639 }
30640
30641 {Py_XDECREF(py_V537);}
30642
30643 double __DUMMY_538;
30644
30645 }
30646 __label_536:
30647
30648 if (V535) {
30649 Py_XDECREF(V535);
30650 }
30651
30652 {Py_XDECREF(py_V535);}
30653
30654 double __DUMMY_536;
30655
30656 }
30657 __label_534:
30658
30659 if (V533) {
30660 Py_XDECREF(V533);
30661 }
30662
30663 {Py_XDECREF(py_V533);}
30664
30665 double __DUMMY_534;
30666
30667 }
30668 __label_532:
30669
30670 if (V531) {
30671 Py_XDECREF(V531);
30672 }
30673
30674 {Py_XDECREF(py_V531);}
30675
30676 double __DUMMY_532;
30677
30678 }
30679 __label_530:
30680
30681 if (V529) {
30682 Py_XDECREF(V529);
30683 }
30684
30685 {Py_XDECREF(py_V529);}
30686
30687 double __DUMMY_530;
30688
30689 }
30690 __label_528:
30691
30692 if (V527) {
30693 Py_XDECREF(V527);
30694 }
30695
30696 {Py_XDECREF(py_V527);}
30697
30698 double __DUMMY_528;
30699
30700 }
30701 __label_526:
30702
30703 if (V525) {
30704 Py_XDECREF(V525);
30705 }
30706
30707 {Py_XDECREF(py_V525);}
30708
30709 double __DUMMY_526;
30710
30711 }
30712 __label_524:
30713
30714 if (V523) {
30715 Py_XDECREF(V523);
30716 }
30717
30718 {Py_XDECREF(py_V523);}
30719
30720 double __DUMMY_524;
30721
30722 }
30723 __label_522:
30724
30725 if (V521) {
30726 Py_XDECREF(V521);
30727 }
30728
30729 {Py_XDECREF(py_V521);}
30730
30731 double __DUMMY_522;
30732
30733 }
30734 __label_520:
30735
30736 if (V519) {
30737 Py_XDECREF(V519);
30738 }
30739
30740 {Py_XDECREF(py_V519);}
30741
30742 double __DUMMY_520;
30743
30744 }
30745 __label_518:
30746
30747 if (V517) {
30748 Py_XDECREF(V517);
30749 }
30750
30751 {Py_XDECREF(py_V517);}
30752
30753 double __DUMMY_518;
30754
30755 }
30756 __label_516:
30757
30758 if (V515) {
30759 Py_XDECREF(V515);
30760 }
30761
30762 {Py_XDECREF(py_V515);}
30763
30764 double __DUMMY_516;
30765
30766 }
30767 __label_514:
30768
30769 if (V513) {
30770 Py_XDECREF(V513);
30771 }
30772
30773 {Py_XDECREF(py_V513);}
30774
30775 double __DUMMY_514;
30776
30777 }
30778 __label_512:
30779
30780 if (V511) {
30781 Py_XDECREF(V511);
30782 }
30783
30784 {Py_XDECREF(py_V511);}
30785
30786 double __DUMMY_512;
30787
30788 }
30789 __label_510:
30790
30791 if (V509) {
30792 Py_XDECREF(V509);
30793 }
30794
30795 {Py_XDECREF(py_V509);}
30796
30797 double __DUMMY_510;
30798
30799 }
30800 __label_508:
30801
30802 if (V507) {
30803 Py_XDECREF(V507);
30804 }
30805
30806 {Py_XDECREF(py_V507);}
30807
30808 double __DUMMY_508;
30809
30810 }
30811 __label_506:
30812
30813 if (V505) {
30814 Py_XDECREF(V505);
30815 }
30816
30817 {Py_XDECREF(py_V505);}
30818
30819 double __DUMMY_506;
30820
30821 }
30822 __label_504:
30823
30824 if (V503) {
30825 Py_XDECREF(V503);
30826 }
30827
30828 {Py_XDECREF(py_V503);}
30829
30830 double __DUMMY_504;
30831
30832 }
30833 __label_502:
30834
30835 if (V501) {
30836 Py_XDECREF(V501);
30837 }
30838
30839 {Py_XDECREF(py_V501);}
30840
30841 double __DUMMY_502;
30842
30843 }
30844 __label_500:
30845
30846 if (V499) {
30847 Py_XDECREF(V499);
30848 }
30849
30850 {Py_XDECREF(py_V499);}
30851
30852 double __DUMMY_500;
30853
30854 }
30855 __label_498:
30856
30857 if (V497) {
30858 Py_XDECREF(V497);
30859 }
30860
30861 {Py_XDECREF(py_V497);}
30862
30863 double __DUMMY_498;
30864
30865 }
30866 __label_496:
30867
30868 if (V495) {
30869 Py_XDECREF(V495);
30870 }
30871
30872 {Py_XDECREF(py_V495);}
30873
30874 double __DUMMY_496;
30875
30876 }
30877 __label_494:
30878
30879 if (V493) {
30880 Py_XDECREF(V493);
30881 }
30882
30883 {Py_XDECREF(py_V493);}
30884
30885 double __DUMMY_494;
30886
30887 }
30888 __label_492:
30889
30890 if (V491) {
30891 Py_XDECREF(V491);
30892 }
30893
30894 {Py_XDECREF(py_V491);}
30895
30896 double __DUMMY_492;
30897
30898 }
30899 __label_490:
30900
30901 if (V489) {
30902 Py_XDECREF(V489);
30903 }
30904
30905 {Py_XDECREF(py_V489);}
30906
30907 double __DUMMY_490;
30908
30909 }
30910 __label_488:
30911
30912 if (V487) {
30913 Py_XDECREF(V487);
30914 }
30915
30916 {Py_XDECREF(py_V487);}
30917
30918 double __DUMMY_488;
30919
30920 }
30921 __label_486:
30922
30923 if (V485) {
30924 Py_XDECREF(V485);
30925 }
30926
30927 {Py_XDECREF(py_V485);}
30928
30929 double __DUMMY_486;
30930
30931 }
30932 __label_484:
30933
30934 if (V483) {
30935 Py_XDECREF(V483);
30936 }
30937
30938 {Py_XDECREF(py_V483);}
30939
30940 double __DUMMY_484;
30941
30942 }
30943 __label_482:
30944
30945 if (V481) {
30946 Py_XDECREF(V481);
30947 }
30948
30949 {Py_XDECREF(py_V481);}
30950
30951 double __DUMMY_482;
30952
30953 }
30954 __label_480:
30955
30956 if (V479) {
30957 Py_XDECREF(V479);
30958 }
30959
30960 {Py_XDECREF(py_V479);}
30961
30962 double __DUMMY_480;
30963
30964 }
30965 __label_478:
30966
30967 if (V477) {
30968 Py_XDECREF(V477);
30969 }
30970
30971 {Py_XDECREF(py_V477);}
30972
30973 double __DUMMY_478;
30974
30975 }
30976 __label_476:
30977
30978 if (V475) {
30979 Py_XDECREF(V475);
30980 }
30981
30982 {Py_XDECREF(py_V475);}
30983
30984 double __DUMMY_476;
30985
30986 }
30987 __label_474:
30988
30989 if (V473) {
30990 Py_XDECREF(V473);
30991 }
30992
30993 {Py_XDECREF(py_V473);}
30994
30995 double __DUMMY_474;
30996
30997 }
30998 __label_472:
30999
31000 if (V471) {
31001 Py_XDECREF(V471);
31002 }
31003
31004 {Py_XDECREF(py_V471);}
31005
31006 double __DUMMY_472;
31007
31008 }
31009 __label_470:
31010
31011 if (V469) {
31012 Py_XDECREF(V469);
31013 }
31014
31015 {Py_XDECREF(py_V469);}
31016
31017 double __DUMMY_470;
31018
31019 }
31020 __label_468:
31021
31022 if (V467) {
31023 Py_XDECREF(V467);
31024 }
31025
31026 {Py_XDECREF(py_V467);}
31027
31028 double __DUMMY_468;
31029
31030 }
31031 __label_466:
31032
31033 if (V465) {
31034 Py_XDECREF(V465);
31035 }
31036
31037 {Py_XDECREF(py_V465);}
31038
31039 double __DUMMY_466;
31040
31041 }
31042 __label_464:
31043
31044 if (V463) {
31045 Py_XDECREF(V463);
31046 }
31047
31048 {Py_XDECREF(py_V463);}
31049
31050 double __DUMMY_464;
31051
31052 }
31053 __label_462:
31054
31055 if (V461) {
31056 Py_XDECREF(V461);
31057 }
31058
31059 {Py_XDECREF(py_V461);}
31060
31061 double __DUMMY_462;
31062
31063 }
31064 __label_460:
31065
31066 if (V459) {
31067 Py_XDECREF(V459);
31068 }
31069
31070 {Py_XDECREF(py_V459);}
31071
31072 double __DUMMY_460;
31073
31074 }
31075 __label_458:
31076
31077 if (V457) {
31078 Py_XDECREF(V457);
31079 }
31080
31081 {Py_XDECREF(py_V457);}
31082
31083 double __DUMMY_458;
31084
31085 }
31086 __label_456:
31087
31088 if (V455) {
31089 Py_XDECREF(V455);
31090 }
31091
31092 {Py_XDECREF(py_V455);}
31093
31094 double __DUMMY_456;
31095
31096 }
31097 __label_454:
31098
31099 if (V453) {
31100 Py_XDECREF(V453);
31101 }
31102
31103 {Py_XDECREF(py_V453);}
31104
31105 double __DUMMY_454;
31106
31107 }
31108 __label_452:
31109
31110 if (V451) {
31111 Py_XDECREF(V451);
31112 }
31113
31114 {Py_XDECREF(py_V451);}
31115
31116 double __DUMMY_452;
31117
31118 }
31119 __label_450:
31120
31121 if (V449) {
31122 Py_XDECREF(V449);
31123 }
31124
31125 {Py_XDECREF(py_V449);}
31126
31127 double __DUMMY_450;
31128
31129 }
31130 __label_448:
31131
31132 if (V447) {
31133 Py_XDECREF(V447);
31134 }
31135
31136 {Py_XDECREF(py_V447);}
31137
31138 double __DUMMY_448;
31139
31140 }
31141 __label_446:
31142
31143 if (V445) {
31144 Py_XDECREF(V445);
31145 }
31146
31147 {Py_XDECREF(py_V445);}
31148
31149 double __DUMMY_446;
31150
31151 }
31152 __label_444:
31153
31154 if (V443) {
31155 Py_XDECREF(V443);
31156 }
31157
31158 {Py_XDECREF(py_V443);}
31159
31160 double __DUMMY_444;
31161
31162 }
31163 __label_442:
31164
31165 if (V441) {
31166 Py_XDECREF(V441);
31167 }
31168
31169 {Py_XDECREF(py_V441);}
31170
31171 double __DUMMY_442;
31172
31173 }
31174 __label_440:
31175
31176 if (V439) {
31177 Py_XDECREF(V439);
31178 }
31179
31180 {Py_XDECREF(py_V439);}
31181
31182 double __DUMMY_440;
31183
31184 }
31185 __label_438:
31186
31187 if (V437) {
31188 Py_XDECREF(V437);
31189 }
31190
31191 {Py_XDECREF(py_V437);}
31192
31193 double __DUMMY_438;
31194
31195 }
31196 __label_436:
31197
31198 if (V435) {
31199 Py_XDECREF(V435);
31200 }
31201
31202 {Py_XDECREF(py_V435);}
31203
31204 double __DUMMY_436;
31205
31206 }
31207 __label_434:
31208
31209 if (V433) {
31210 Py_XDECREF(V433);
31211 }
31212
31213 {Py_XDECREF(py_V433);}
31214
31215 double __DUMMY_434;
31216
31217 }
31218 __label_432:
31219
31220 if (V431) {
31221 Py_XDECREF(V431);
31222 }
31223
31224 {Py_XDECREF(py_V431);}
31225
31226 double __DUMMY_432;
31227
31228 }
31229 __label_430:
31230
31231 if (V429) {
31232 Py_XDECREF(V429);
31233 }
31234
31235 {Py_XDECREF(py_V429);}
31236
31237 double __DUMMY_430;
31238
31239 }
31240 __label_428:
31241
31242 if (V427) {
31243 Py_XDECREF(V427);
31244 }
31245
31246 {Py_XDECREF(py_V427);}
31247
31248 double __DUMMY_428;
31249
31250 }
31251 __label_426:
31252
31253 if (V425) {
31254 Py_XDECREF(V425);
31255 }
31256
31257 {Py_XDECREF(py_V425);}
31258
31259 double __DUMMY_426;
31260
31261 }
31262 __label_424:
31263
31264 if (V423) {
31265 Py_XDECREF(V423);
31266 }
31267
31268 {Py_XDECREF(py_V423);}
31269
31270 double __DUMMY_424;
31271
31272 }
31273 __label_422:
31274
31275 if (V421) {
31276 Py_XDECREF(V421);
31277 }
31278
31279 {Py_XDECREF(py_V421);}
31280
31281 double __DUMMY_422;
31282
31283 }
31284 __label_420:
31285
31286 if (V419) {
31287 Py_XDECREF(V419);
31288 }
31289
31290 {Py_XDECREF(py_V419);}
31291
31292 double __DUMMY_420;
31293
31294 }
31295 __label_418:
31296
31297 if (V417) {
31298 Py_XDECREF(V417);
31299 }
31300
31301 {Py_XDECREF(py_V417);}
31302
31303 double __DUMMY_418;
31304
31305 }
31306 __label_416:
31307
31308 if (V415) {
31309 Py_XDECREF(V415);
31310 }
31311
31312 {Py_XDECREF(py_V415);}
31313
31314 double __DUMMY_416;
31315
31316 }
31317 __label_414:
31318
31319 if (V413) {
31320 Py_XDECREF(V413);
31321 }
31322
31323 {Py_XDECREF(py_V413);}
31324
31325 double __DUMMY_414;
31326
31327 }
31328 __label_412:
31329
31330 if (V411) {
31331 Py_XDECREF(V411);
31332 }
31333
31334 {Py_XDECREF(py_V411);}
31335
31336 double __DUMMY_412;
31337
31338 }
31339 __label_410:
31340
31341 if (V409) {
31342 Py_XDECREF(V409);
31343 }
31344
31345 {Py_XDECREF(py_V409);}
31346
31347 double __DUMMY_410;
31348
31349 }
31350 __label_408:
31351
31352 if (V407) {
31353 Py_XDECREF(V407);
31354 }
31355
31356 {Py_XDECREF(py_V407);}
31357
31358 double __DUMMY_408;
31359
31360 }
31361 __label_406:
31362
31363 if (V405) {
31364 Py_XDECREF(V405);
31365 }
31366
31367 {Py_XDECREF(py_V405);}
31368
31369 double __DUMMY_406;
31370
31371 }
31372 __label_404:
31373
31374 if (V403) {
31375 Py_XDECREF(V403);
31376 }
31377
31378 {Py_XDECREF(py_V403);}
31379
31380 double __DUMMY_404;
31381
31382 }
31383 __label_402:
31384
31385 if (V401) {
31386 Py_XDECREF(V401);
31387 }
31388
31389 {Py_XDECREF(py_V401);}
31390
31391 double __DUMMY_402;
31392
31393 }
31394 __label_400:
31395
31396 if (V399) {
31397 Py_XDECREF(V399);
31398 }
31399
31400 {Py_XDECREF(py_V399);}
31401
31402 double __DUMMY_400;
31403
31404 }
31405 __label_398:
31406
31407 if (V397) {
31408 Py_XDECREF(V397);
31409 }
31410
31411 {Py_XDECREF(py_V397);}
31412
31413 double __DUMMY_398;
31414
31415 }
31416 __label_396:
31417
31418 if (V395) {
31419 Py_XDECREF(V395);
31420 }
31421
31422 {Py_XDECREF(py_V395);}
31423
31424 double __DUMMY_396;
31425
31426 }
31427 __label_394:
31428
31429 if (V393) {
31430 Py_XDECREF(V393);
31431 }
31432
31433 {Py_XDECREF(py_V393);}
31434
31435 double __DUMMY_394;
31436
31437 }
31438 __label_392:
31439
31440 if (V391) {
31441 Py_XDECREF(V391);
31442 }
31443
31444 {Py_XDECREF(py_V391);}
31445
31446 double __DUMMY_392;
31447
31448 }
31449 __label_390:
31450
31451 if (V389) {
31452 Py_XDECREF(V389);
31453 }
31454
31455 {Py_XDECREF(py_V389);}
31456
31457 double __DUMMY_390;
31458
31459 }
31460 __label_388:
31461
31462 if (V387) {
31463 Py_XDECREF(V387);
31464 }
31465
31466 {Py_XDECREF(py_V387);}
31467
31468 double __DUMMY_388;
31469
31470 }
31471 __label_386:
31472
31473 if (V385) {
31474 Py_XDECREF(V385);
31475 }
31476
31477 {Py_XDECREF(py_V385);}
31478
31479 double __DUMMY_386;
31480
31481 }
31482 __label_384:
31483
31484 if (V383) {
31485 Py_XDECREF(V383);
31486 }
31487
31488 {Py_XDECREF(py_V383);}
31489
31490 double __DUMMY_384;
31491
31492 }
31493 __label_382:
31494
31495 if (V381) {
31496 Py_XDECREF(V381);
31497 }
31498
31499 {Py_XDECREF(py_V381);}
31500
31501 double __DUMMY_382;
31502
31503 }
31504 __label_380:
31505
31506 if (V379) {
31507 Py_XDECREF(V379);
31508 }
31509
31510 {Py_XDECREF(py_V379);}
31511
31512 double __DUMMY_380;
31513
31514 }
31515 __label_378:
31516
31517 if (V377) {
31518 Py_XDECREF(V377);
31519 }
31520
31521 {Py_XDECREF(py_V377);}
31522
31523 double __DUMMY_378;
31524
31525 }
31526 __label_376:
31527
31528 if (V375) {
31529 Py_XDECREF(V375);
31530 }
31531
31532 {Py_XDECREF(py_V375);}
31533
31534 double __DUMMY_376;
31535
31536 }
31537 __label_374:
31538
31539 if (V373) {
31540 Py_XDECREF(V373);
31541 }
31542
31543 {Py_XDECREF(py_V373);}
31544
31545 double __DUMMY_374;
31546
31547 }
31548 __label_372:
31549
31550 if (V371) {
31551 Py_XDECREF(V371);
31552 }
31553
31554 {Py_XDECREF(py_V371);}
31555
31556 double __DUMMY_372;
31557
31558 }
31559 __label_370:
31560
31561 if (V369) {
31562 Py_XDECREF(V369);
31563 }
31564
31565 {Py_XDECREF(py_V369);}
31566
31567 double __DUMMY_370;
31568
31569 }
31570 __label_368:
31571
31572 if (V367) {
31573 Py_XDECREF(V367);
31574 }
31575
31576 {Py_XDECREF(py_V367);}
31577
31578 double __DUMMY_368;
31579
31580 }
31581 __label_366:
31582
31583 if (V365) {
31584 Py_XDECREF(V365);
31585 }
31586
31587 {Py_XDECREF(py_V365);}
31588
31589 double __DUMMY_366;
31590
31591 }
31592 __label_364:
31593
31594 if (V363) {
31595 Py_XDECREF(V363);
31596 }
31597
31598 {Py_XDECREF(py_V363);}
31599
31600 double __DUMMY_364;
31601
31602 }
31603 __label_362:
31604
31605 if (V361) {
31606 Py_XDECREF(V361);
31607 }
31608
31609 {Py_XDECREF(py_V361);}
31610
31611 double __DUMMY_362;
31612
31613 }
31614 __label_360:
31615
31616 if (V359) {
31617 Py_XDECREF(V359);
31618 }
31619
31620 {Py_XDECREF(py_V359);}
31621
31622 double __DUMMY_360;
31623
31624 }
31625 __label_358:
31626
31627 if (V357) {
31628 Py_XDECREF(V357);
31629 }
31630
31631 {Py_XDECREF(py_V357);}
31632
31633 double __DUMMY_358;
31634
31635 }
31636 __label_356:
31637
31638 if (V355) {
31639 Py_XDECREF(V355);
31640 }
31641
31642 {Py_XDECREF(py_V355);}
31643
31644 double __DUMMY_356;
31645
31646 }
31647 __label_354:
31648
31649 if (V353) {
31650 Py_XDECREF(V353);
31651 }
31652
31653 {Py_XDECREF(py_V353);}
31654
31655 double __DUMMY_354;
31656
31657 }
31658 __label_352:
31659
31660 if (V351) {
31661 Py_XDECREF(V351);
31662 }
31663
31664 {Py_XDECREF(py_V351);}
31665
31666 double __DUMMY_352;
31667
31668 }
31669 __label_350:
31670
31671 if (V349) {
31672 Py_XDECREF(V349);
31673 }
31674
31675 {Py_XDECREF(py_V349);}
31676
31677 double __DUMMY_350;
31678
31679 }
31680 __label_348:
31681
31682 if (V347) {
31683 Py_XDECREF(V347);
31684 }
31685
31686 {Py_XDECREF(py_V347);}
31687
31688 double __DUMMY_348;
31689
31690 }
31691 __label_346:
31692
31693 if (V345) {
31694 Py_XDECREF(V345);
31695 }
31696
31697 {Py_XDECREF(py_V345);}
31698
31699 double __DUMMY_346;
31700
31701 }
31702 __label_344:
31703
31704 if (V343) {
31705 Py_XDECREF(V343);
31706 }
31707
31708 {Py_XDECREF(py_V343);}
31709
31710 double __DUMMY_344;
31711
31712 }
31713 __label_342:
31714
31715 if (V341) {
31716 Py_XDECREF(V341);
31717 }
31718
31719 {Py_XDECREF(py_V341);}
31720
31721 double __DUMMY_342;
31722
31723 }
31724 __label_340:
31725
31726 if (V339) {
31727 Py_XDECREF(V339);
31728 }
31729
31730 {Py_XDECREF(py_V339);}
31731
31732 double __DUMMY_340;
31733
31734 }
31735 __label_338:
31736
31737 if (V337) {
31738 Py_XDECREF(V337);
31739 }
31740
31741 {Py_XDECREF(py_V337);}
31742
31743 double __DUMMY_338;
31744
31745 }
31746 __label_336:
31747
31748 if (V335) {
31749 Py_XDECREF(V335);
31750 }
31751
31752 {Py_XDECREF(py_V335);}
31753
31754 double __DUMMY_336;
31755
31756 }
31757 __label_334:
31758
31759 if (V333) {
31760 Py_XDECREF(V333);
31761 }
31762
31763 {Py_XDECREF(py_V333);}
31764
31765 double __DUMMY_334;
31766
31767 }
31768 __label_332:
31769
31770 if (V331) {
31771 Py_XDECREF(V331);
31772 }
31773
31774 {Py_XDECREF(py_V331);}
31775
31776 double __DUMMY_332;
31777
31778 }
31779 __label_330:
31780
31781 if (V329) {
31782 Py_XDECREF(V329);
31783 }
31784
31785 {Py_XDECREF(py_V329);}
31786
31787 double __DUMMY_330;
31788
31789 }
31790 __label_328:
31791
31792 if (V327) {
31793 Py_XDECREF(V327);
31794 }
31795
31796 {Py_XDECREF(py_V327);}
31797
31798 double __DUMMY_328;
31799
31800 }
31801 __label_326:
31802
31803 if (V325) {
31804 Py_XDECREF(V325);
31805 }
31806
31807 {Py_XDECREF(py_V325);}
31808
31809 double __DUMMY_326;
31810
31811 }
31812 __label_324:
31813
31814 if (V323) {
31815 Py_XDECREF(V323);
31816 }
31817
31818 {Py_XDECREF(py_V323);}
31819
31820 double __DUMMY_324;
31821
31822 }
31823 __label_322:
31824
31825 if (V321) {
31826 Py_XDECREF(V321);
31827 }
31828
31829 {Py_XDECREF(py_V321);}
31830
31831 double __DUMMY_322;
31832
31833 }
31834 __label_320:
31835
31836 if (V319) {
31837 Py_XDECREF(V319);
31838 }
31839
31840 {Py_XDECREF(py_V319);}
31841
31842 double __DUMMY_320;
31843
31844 }
31845 __label_318:
31846
31847 if (V317) {
31848 Py_XDECREF(V317);
31849 }
31850
31851 {Py_XDECREF(py_V317);}
31852
31853 double __DUMMY_318;
31854
31855 }
31856 __label_316:
31857
31858 if (V315) {
31859 Py_XDECREF(V315);
31860 }
31861
31862 {Py_XDECREF(py_V315);}
31863
31864 double __DUMMY_316;
31865
31866 }
31867 __label_314:
31868
31869 if (V313) {
31870 Py_XDECREF(V313);
31871 }
31872
31873 {Py_XDECREF(py_V313);}
31874
31875 double __DUMMY_314;
31876
31877 }
31878 __label_312:
31879
31880 if (V311) {
31881 Py_XDECREF(V311);
31882 }
31883
31884 {Py_XDECREF(py_V311);}
31885
31886 double __DUMMY_312;
31887
31888 }
31889 __label_310:
31890
31891 if (V309) {
31892 Py_XDECREF(V309);
31893 }
31894
31895 {Py_XDECREF(py_V309);}
31896
31897 double __DUMMY_310;
31898
31899 }
31900 __label_308:
31901
31902 if (V307) {
31903 Py_XDECREF(V307);
31904 }
31905
31906 {Py_XDECREF(py_V307);}
31907
31908 double __DUMMY_308;
31909
31910 }
31911 __label_306:
31912
31913 if (V305) {
31914 Py_XDECREF(V305);
31915 }
31916
31917 {Py_XDECREF(py_V305);}
31918
31919 double __DUMMY_306;
31920
31921 }
31922 __label_304:
31923
31924 if (V303) {
31925 Py_XDECREF(V303);
31926 }
31927
31928 {Py_XDECREF(py_V303);}
31929
31930 double __DUMMY_304;
31931
31932 }
31933 __label_302:
31934
31935 if (V301) {
31936 Py_XDECREF(V301);
31937 }
31938
31939 {Py_XDECREF(py_V301);}
31940
31941 double __DUMMY_302;
31942
31943 }
31944 __label_300:
31945
31946 if (V299) {
31947 Py_XDECREF(V299);
31948 }
31949
31950 {Py_XDECREF(py_V299);}
31951
31952 double __DUMMY_300;
31953
31954 }
31955 __label_298:
31956
31957 if (V297) {
31958 Py_XDECREF(V297);
31959 }
31960
31961 {Py_XDECREF(py_V297);}
31962
31963 double __DUMMY_298;
31964
31965 }
31966 __label_296:
31967
31968 if (V295) {
31969 Py_XDECREF(V295);
31970 }
31971
31972 {Py_XDECREF(py_V295);}
31973
31974 double __DUMMY_296;
31975
31976 }
31977 __label_294:
31978
31979 if (V293) {
31980 Py_XDECREF(V293);
31981 }
31982
31983 {Py_XDECREF(py_V293);}
31984
31985 double __DUMMY_294;
31986
31987 }
31988 __label_292:
31989
31990 if (V291) {
31991 Py_XDECREF(V291);
31992 }
31993
31994 {Py_XDECREF(py_V291);}
31995
31996 double __DUMMY_292;
31997
31998 }
31999 __label_290:
32000
32001 if (V289) {
32002 Py_XDECREF(V289);
32003 }
32004
32005 {Py_XDECREF(py_V289);}
32006
32007 double __DUMMY_290;
32008
32009 }
32010 __label_288:
32011
32012 if (V287) {
32013 Py_XDECREF(V287);
32014 }
32015
32016 {Py_XDECREF(py_V287);}
32017
32018 double __DUMMY_288;
32019
32020 }
32021 __label_286:
32022
32023 if (V285) {
32024 Py_XDECREF(V285);
32025 }
32026
32027 {Py_XDECREF(py_V285);}
32028
32029 double __DUMMY_286;
32030
32031 }
32032 __label_284:
32033
32034 if (V283) {
32035 Py_XDECREF(V283);
32036 }
32037
32038 {Py_XDECREF(py_V283);}
32039
32040 double __DUMMY_284;
32041
32042 }
32043 __label_282:
32044
32045 if (V281) {
32046 Py_XDECREF(V281);
32047 }
32048
32049 {Py_XDECREF(py_V281);}
32050
32051 double __DUMMY_282;
32052
32053 }
32054 __label_280:
32055
32056 if (V279) {
32057 Py_XDECREF(V279);
32058 }
32059
32060 {Py_XDECREF(py_V279);}
32061
32062 double __DUMMY_280;
32063
32064 }
32065 __label_278:
32066
32067 if (V277) {
32068 Py_XDECREF(V277);
32069 }
32070
32071 {Py_XDECREF(py_V277);}
32072
32073 double __DUMMY_278;
32074
32075 }
32076 __label_276:
32077
32078 if (V275) {
32079 Py_XDECREF(V275);
32080 }
32081
32082 {Py_XDECREF(py_V275);}
32083
32084 double __DUMMY_276;
32085
32086 }
32087 __label_274:
32088
32089 if (V273) {
32090 Py_XDECREF(V273);
32091 }
32092
32093 {Py_XDECREF(py_V273);}
32094
32095 double __DUMMY_274;
32096
32097 }
32098 __label_272:
32099
32100 if (V271) {
32101 Py_XDECREF(V271);
32102 }
32103
32104 {Py_XDECREF(py_V271);}
32105
32106 double __DUMMY_272;
32107
32108 }
32109 __label_270:
32110
32111 if (V269) {
32112 Py_XDECREF(V269);
32113 }
32114
32115 {Py_XDECREF(py_V269);}
32116
32117 double __DUMMY_270;
32118
32119 }
32120 __label_268:
32121
32122 if (V267) {
32123 Py_XDECREF(V267);
32124 }
32125
32126 {Py_XDECREF(py_V267);}
32127
32128 double __DUMMY_268;
32129
32130 }
32131 __label_266:
32132
32133 if (V265) {
32134 Py_XDECREF(V265);
32135 }
32136
32137 {Py_XDECREF(py_V265);}
32138
32139 double __DUMMY_266;
32140
32141 }
32142 __label_264:
32143
32144 if (V263) {
32145 Py_XDECREF(V263);
32146 }
32147
32148 {Py_XDECREF(py_V263);}
32149
32150 double __DUMMY_264;
32151
32152 }
32153 __label_262:
32154
32155 if (V261) {
32156 Py_XDECREF(V261);
32157 }
32158
32159 {Py_XDECREF(py_V261);}
32160
32161 double __DUMMY_262;
32162
32163 }
32164 __label_260:
32165
32166 if (V259) {
32167 Py_XDECREF(V259);
32168 }
32169
32170 {Py_XDECREF(py_V259);}
32171
32172 double __DUMMY_260;
32173
32174 }
32175 __label_258:
32176
32177 if (V257) {
32178 Py_XDECREF(V257);
32179 }
32180
32181 {Py_XDECREF(py_V257);}
32182
32183 double __DUMMY_258;
32184
32185 }
32186 __label_256:
32187
32188 if (V255) {
32189 Py_XDECREF(V255);
32190 }
32191
32192 {Py_XDECREF(py_V255);}
32193
32194 double __DUMMY_256;
32195
32196 }
32197 __label_254:
32198
32199 if (V253) {
32200 Py_XDECREF(V253);
32201 }
32202
32203 {Py_XDECREF(py_V253);}
32204
32205 double __DUMMY_254;
32206
32207 }
32208 __label_252:
32209
32210 if (V251) {
32211 Py_XDECREF(V251);
32212 }
32213
32214 {Py_XDECREF(py_V251);}
32215
32216 double __DUMMY_252;
32217
32218 }
32219 __label_250:
32220
32221 if (V249) {
32222 Py_XDECREF(V249);
32223 }
32224
32225 {Py_XDECREF(py_V249);}
32226
32227 double __DUMMY_250;
32228
32229 }
32230 __label_248:
32231
32232 if (V247) {
32233 Py_XDECREF(V247);
32234 }
32235
32236 {Py_XDECREF(py_V247);}
32237
32238 double __DUMMY_248;
32239
32240 }
32241 __label_246:
32242
32243 if (V245) {
32244 Py_XDECREF(V245);
32245 }
32246
32247 {Py_XDECREF(py_V245);}
32248
32249 double __DUMMY_246;
32250
32251 }
32252 __label_244:
32253
32254 if (V243) {
32255 Py_XDECREF(V243);
32256 }
32257
32258 {Py_XDECREF(py_V243);}
32259
32260 double __DUMMY_244;
32261
32262 }
32263 __label_242:
32264
32265 if (V241) {
32266 Py_XDECREF(V241);
32267 }
32268
32269 {Py_XDECREF(py_V241);}
32270
32271 double __DUMMY_242;
32272
32273 }
32274 __label_240:
32275
32276 if (V239) {
32277 Py_XDECREF(V239);
32278 }
32279
32280 {Py_XDECREF(py_V239);}
32281
32282 double __DUMMY_240;
32283
32284 }
32285 __label_238:
32286
32287 if (V237) {
32288 Py_XDECREF(V237);
32289 }
32290
32291 {Py_XDECREF(py_V237);}
32292
32293 double __DUMMY_238;
32294
32295 }
32296 __label_236:
32297
32298 if (V235) {
32299 Py_XDECREF(V235);
32300 }
32301
32302 {Py_XDECREF(py_V235);}
32303
32304 double __DUMMY_236;
32305
32306 }
32307 __label_234:
32308
32309 if (V233) {
32310 Py_XDECREF(V233);
32311 }
32312
32313 {Py_XDECREF(py_V233);}
32314
32315 double __DUMMY_234;
32316
32317 }
32318 __label_232:
32319
32320 if (V231) {
32321 Py_XDECREF(V231);
32322 }
32323
32324 {Py_XDECREF(py_V231);}
32325
32326 double __DUMMY_232;
32327
32328 }
32329 __label_230:
32330
32331 if (V229) {
32332 Py_XDECREF(V229);
32333 }
32334
32335 {Py_XDECREF(py_V229);}
32336
32337 double __DUMMY_230;
32338
32339 }
32340 __label_228:
32341
32342 if (V227) {
32343 Py_XDECREF(V227);
32344 }
32345
32346 {Py_XDECREF(py_V227);}
32347
32348 double __DUMMY_228;
32349
32350 }
32351 __label_226:
32352
32353 if (V225) {
32354 Py_XDECREF(V225);
32355 }
32356
32357 {Py_XDECREF(py_V225);}
32358
32359 double __DUMMY_226;
32360
32361 }
32362 __label_224:
32363
32364 if (V223) {
32365 Py_XDECREF(V223);
32366 }
32367
32368 {Py_XDECREF(py_V223);}
32369
32370 double __DUMMY_224;
32371
32372 }
32373 __label_222:
32374
32375 if (V221) {
32376 Py_XDECREF(V221);
32377 }
32378
32379 {Py_XDECREF(py_V221);}
32380
32381 double __DUMMY_222;
32382
32383 }
32384 __label_220:
32385
32386 if (V219) {
32387 Py_XDECREF(V219);
32388 }
32389
32390 {Py_XDECREF(py_V219);}
32391
32392 double __DUMMY_220;
32393
32394 }
32395 __label_218:
32396
32397 if (V217) {
32398 Py_XDECREF(V217);
32399 }
32400
32401 {Py_XDECREF(py_V217);}
32402
32403 double __DUMMY_218;
32404
32405 }
32406 __label_216:
32407
32408 if (V215) {
32409 Py_XDECREF(V215);
32410 }
32411
32412 {Py_XDECREF(py_V215);}
32413
32414 double __DUMMY_216;
32415
32416 }
32417 __label_214:
32418
32419 if (V213) {
32420 Py_XDECREF(V213);
32421 }
32422
32423 {Py_XDECREF(py_V213);}
32424
32425 double __DUMMY_214;
32426
32427 }
32428 __label_212:
32429
32430 if (V211) {
32431 Py_XDECREF(V211);
32432 }
32433
32434 {Py_XDECREF(py_V211);}
32435
32436 double __DUMMY_212;
32437
32438 }
32439 __label_210:
32440
32441 if (V209) {
32442 Py_XDECREF(V209);
32443 }
32444
32445 {Py_XDECREF(py_V209);}
32446
32447 double __DUMMY_210;
32448
32449 }
32450 __label_208:
32451
32452 if (V207) {
32453 Py_XDECREF(V207);
32454 }
32455
32456 {Py_XDECREF(py_V207);}
32457
32458 double __DUMMY_208;
32459
32460 }
32461 __label_206:
32462
32463 if (V205) {
32464 Py_XDECREF(V205);
32465 }
32466
32467 {Py_XDECREF(py_V205);}
32468
32469 double __DUMMY_206;
32470
32471 }
32472 __label_204:
32473
32474 if (V203) {
32475 Py_XDECREF(V203);
32476 }
32477
32478 {Py_XDECREF(py_V203);}
32479
32480 double __DUMMY_204;
32481
32482 }
32483 __label_202:
32484
32485 if (V201) {
32486 Py_XDECREF(V201);
32487 }
32488
32489 {Py_XDECREF(py_V201);}
32490
32491 double __DUMMY_202;
32492
32493 }
32494 __label_200:
32495
32496 if (V199) {
32497 Py_XDECREF(V199);
32498 }
32499
32500 {Py_XDECREF(py_V199);}
32501
32502 double __DUMMY_200;
32503
32504 }
32505 __label_198:
32506
32507 if (V197) {
32508 Py_XDECREF(V197);
32509 }
32510
32511 {Py_XDECREF(py_V197);}
32512
32513 double __DUMMY_198;
32514
32515 }
32516 __label_196:
32517
32518 if (V195) {
32519 Py_XDECREF(V195);
32520 }
32521
32522 {Py_XDECREF(py_V195);}
32523
32524 double __DUMMY_196;
32525
32526 }
32527 __label_194:
32528
32529 if (V193) {
32530 Py_XDECREF(V193);
32531 }
32532
32533 {Py_XDECREF(py_V193);}
32534
32535 double __DUMMY_194;
32536
32537 }
32538 __label_192:
32539
32540 if (V191) {
32541 Py_XDECREF(V191);
32542 }
32543
32544 {Py_XDECREF(py_V191);}
32545
32546 double __DUMMY_192;
32547
32548 }
32549 __label_190:
32550
32551 if (V189) {
32552 Py_XDECREF(V189);
32553 }
32554
32555 {Py_XDECREF(py_V189);}
32556
32557 double __DUMMY_190;
32558
32559 }
32560 __label_188:
32561
32562 if (V187) {
32563 Py_XDECREF(V187);
32564 }
32565
32566 {Py_XDECREF(py_V187);}
32567
32568 double __DUMMY_188;
32569
32570 }
32571 __label_186:
32572
32573 if (V185) {
32574 Py_XDECREF(V185);
32575 }
32576
32577 {Py_XDECREF(py_V185);}
32578
32579 double __DUMMY_186;
32580
32581 }
32582 __label_184:
32583
32584 if (V183) {
32585 Py_XDECREF(V183);
32586 }
32587
32588 {Py_XDECREF(py_V183);}
32589
32590 double __DUMMY_184;
32591
32592 }
32593 __label_182:
32594
32595 if (V181) {
32596 Py_XDECREF(V181);
32597 }
32598
32599 {Py_XDECREF(py_V181);}
32600
32601 double __DUMMY_182;
32602
32603 }
32604 __label_180:
32605
32606 if (V179) {
32607 Py_XDECREF(V179);
32608 }
32609
32610 {Py_XDECREF(py_V179);}
32611
32612 double __DUMMY_180;
32613
32614 }
32615 __label_178:
32616
32617 if (V177) {
32618 Py_XDECREF(V177);
32619 }
32620
32621 {Py_XDECREF(py_V177);}
32622
32623 double __DUMMY_178;
32624
32625 }
32626 __label_176:
32627
32628 if (V175) {
32629 Py_XDECREF(V175);
32630 }
32631
32632 {Py_XDECREF(py_V175);}
32633
32634 double __DUMMY_176;
32635
32636 }
32637 __label_174:
32638
32639 if (V173) {
32640 Py_XDECREF(V173);
32641 }
32642
32643 {Py_XDECREF(py_V173);}
32644
32645 double __DUMMY_174;
32646
32647 }
32648 __label_172:
32649
32650 if (V171) {
32651 Py_XDECREF(V171);
32652 }
32653
32654 {Py_XDECREF(py_V171);}
32655
32656 double __DUMMY_172;
32657
32658 }
32659 __label_170:
32660
32661 if (V169) {
32662 Py_XDECREF(V169);
32663 }
32664
32665 {Py_XDECREF(py_V169);}
32666
32667 double __DUMMY_170;
32668
32669 }
32670 __label_168:
32671
32672 if (V167) {
32673 Py_XDECREF(V167);
32674 }
32675
32676 {Py_XDECREF(py_V167);}
32677
32678 double __DUMMY_168;
32679
32680 }
32681 __label_166:
32682
32683 if (V165) {
32684 Py_XDECREF(V165);
32685 }
32686
32687 {Py_XDECREF(py_V165);}
32688
32689 double __DUMMY_166;
32690
32691 }
32692 __label_164:
32693
32694 if (V163) {
32695 Py_XDECREF(V163);
32696 }
32697
32698 {Py_XDECREF(py_V163);}
32699
32700 double __DUMMY_164;
32701
32702 }
32703 __label_162:
32704
32705 if (V161) {
32706 Py_XDECREF(V161);
32707 }
32708
32709 {Py_XDECREF(py_V161);}
32710
32711 double __DUMMY_162;
32712
32713 }
32714 __label_160:
32715
32716 if (V159) {
32717 Py_XDECREF(V159);
32718 }
32719
32720 {Py_XDECREF(py_V159);}
32721
32722 double __DUMMY_160;
32723
32724 }
32725 __label_158:
32726
32727 if (V157) {
32728 Py_XDECREF(V157);
32729 }
32730
32731 {Py_XDECREF(py_V157);}
32732
32733 double __DUMMY_158;
32734
32735 }
32736 __label_156:
32737
32738 if (V155) {
32739 Py_XDECREF(V155);
32740 }
32741
32742 {Py_XDECREF(py_V155);}
32743
32744 double __DUMMY_156;
32745
32746 }
32747 __label_154:
32748
32749 if (V153) {
32750 Py_XDECREF(V153);
32751 }
32752
32753 {Py_XDECREF(py_V153);}
32754
32755 double __DUMMY_154;
32756
32757 }
32758 __label_152:
32759
32760 if (V151) {
32761 Py_XDECREF(V151);
32762 }
32763
32764 {Py_XDECREF(py_V151);}
32765
32766 double __DUMMY_152;
32767
32768 }
32769 __label_150:
32770
32771 if (V149) {
32772 Py_XDECREF(V149);
32773 }
32774
32775 {Py_XDECREF(py_V149);}
32776
32777 double __DUMMY_150;
32778
32779 }
32780 __label_148:
32781
32782 if (V147) {
32783 Py_XDECREF(V147);
32784 }
32785
32786 {Py_XDECREF(py_V147);}
32787
32788 double __DUMMY_148;
32789
32790 }
32791 __label_146:
32792
32793 if (V145) {
32794 Py_XDECREF(V145);
32795 }
32796
32797 {Py_XDECREF(py_V145);}
32798
32799 double __DUMMY_146;
32800
32801 }
32802 __label_144:
32803
32804 if (V143) {
32805 Py_XDECREF(V143);
32806 }
32807
32808 {Py_XDECREF(py_V143);}
32809
32810 double __DUMMY_144;
32811
32812 }
32813 __label_142:
32814
32815 if (V141) {
32816 Py_XDECREF(V141);
32817 }
32818
32819 {Py_XDECREF(py_V141);}
32820
32821 double __DUMMY_142;
32822
32823 }
32824 __label_140:
32825
32826 if (V139) {
32827 Py_XDECREF(V139);
32828 }
32829
32830 {Py_XDECREF(py_V139);}
32831
32832 double __DUMMY_140;
32833
32834 }
32835 __label_138:
32836
32837 if (V137) {
32838 Py_XDECREF(V137);
32839 }
32840
32841 {Py_XDECREF(py_V137);}
32842
32843 double __DUMMY_138;
32844
32845 }
32846 __label_136:
32847
32848 if (V135) {
32849 Py_XDECREF(V135);
32850 }
32851
32852 {Py_XDECREF(py_V135);}
32853
32854 double __DUMMY_136;
32855
32856 }
32857 __label_134:
32858
32859 if (V133) {
32860 Py_XDECREF(V133);
32861 }
32862
32863 {Py_XDECREF(py_V133);}
32864
32865 double __DUMMY_134;
32866
32867 }
32868 __label_132:
32869
32870 if (V131) {
32871 Py_XDECREF(V131);
32872 }
32873
32874 {Py_XDECREF(py_V131);}
32875
32876 double __DUMMY_132;
32877
32878 }
32879 __label_130:
32880
32881 if (V129) {
32882 Py_XDECREF(V129);
32883 }
32884
32885 {Py_XDECREF(py_V129);}
32886
32887 double __DUMMY_130;
32888
32889 }
32890 __label_128:
32891
32892 if (V127) {
32893 Py_XDECREF(V127);
32894 }
32895
32896 {Py_XDECREF(py_V127);}
32897
32898 double __DUMMY_128;
32899
32900 }
32901 __label_126:
32902
32903 if (V125) {
32904 Py_XDECREF(V125);
32905 }
32906
32907 {Py_XDECREF(py_V125);}
32908
32909 double __DUMMY_126;
32910
32911 }
32912 __label_124:
32913
32914 if (V123) {
32915 Py_XDECREF(V123);
32916 }
32917
32918 {Py_XDECREF(py_V123);}
32919
32920 double __DUMMY_124;
32921
32922 }
32923 __label_122:
32924
32925 if (V121) {
32926 Py_XDECREF(V121);
32927 }
32928
32929 {Py_XDECREF(py_V121);}
32930
32931 double __DUMMY_122;
32932
32933 }
32934 __label_120:
32935
32936 if (V119) {
32937 Py_XDECREF(V119);
32938 }
32939
32940 {Py_XDECREF(py_V119);}
32941
32942 double __DUMMY_120;
32943
32944 }
32945 __label_118:
32946
32947 if (V117) {
32948 Py_XDECREF(V117);
32949 }
32950
32951 {Py_XDECREF(py_V117);}
32952
32953 double __DUMMY_118;
32954
32955 }
32956 __label_116:
32957
32958 if (V115) {
32959 Py_XDECREF(V115);
32960 }
32961
32962 {Py_XDECREF(py_V115);}
32963
32964 double __DUMMY_116;
32965
32966 }
32967 __label_114:
32968
32969 if (V113) {
32970 Py_XDECREF(V113);
32971 }
32972
32973 {Py_XDECREF(py_V113);}
32974
32975 double __DUMMY_114;
32976
32977 }
32978 __label_112:
32979
32980 if (V111) {
32981 Py_XDECREF(V111);
32982 }
32983
32984 {Py_XDECREF(py_V111);}
32985
32986 double __DUMMY_112;
32987
32988 }
32989 __label_110:
32990
32991 if (V109) {
32992 Py_XDECREF(V109);
32993 }
32994
32995 {Py_XDECREF(py_V109);}
32996
32997 double __DUMMY_110;
32998
32999 }
33000 __label_108:
33001
33002 if (V107) {
33003 Py_XDECREF(V107);
33004 }
33005
33006 {Py_XDECREF(py_V107);}
33007
33008 double __DUMMY_108;
33009
33010 }
33011 __label_106:
33012
33013 if (V105) {
33014 Py_XDECREF(V105);
33015 }
33016
33017 {Py_XDECREF(py_V105);}
33018
33019 double __DUMMY_106;
33020
33021 }
33022 __label_104:
33023
33024 if (V103) {
33025 Py_XDECREF(V103);
33026 }
33027
33028 {Py_XDECREF(py_V103);}
33029
33030 double __DUMMY_104;
33031
33032 }
33033 __label_102:
33034
33035 if (V101) {
33036 Py_XDECREF(V101);
33037 }
33038
33039 {Py_XDECREF(py_V101);}
33040
33041 double __DUMMY_102;
33042
33043 }
33044 __label_100:
33045
33046 if (V99) {
33047 Py_XDECREF(V99);
33048 }
33049
33050 {Py_XDECREF(py_V99);}
33051
33052 double __DUMMY_100;
33053
33054 }
33055 __label_98:
33056
33057 if (V97) {
33058 Py_XDECREF(V97);
33059 }
33060
33061 {Py_XDECREF(py_V97);}
33062
33063 double __DUMMY_98;
33064
33065 }
33066 __label_96:
33067
33068 if (V95) {
33069 Py_XDECREF(V95);
33070 }
33071
33072 {Py_XDECREF(py_V95);}
33073
33074 double __DUMMY_96;
33075
33076 }
33077 __label_94:
33078
33079 if (V93) {
33080 Py_XDECREF(V93);
33081 }
33082
33083 {Py_XDECREF(py_V93);}
33084
33085 double __DUMMY_94;
33086
33087 }
33088 __label_92:
33089
33090 if (V91) {
33091 Py_XDECREF(V91);
33092 }
33093
33094 {Py_XDECREF(py_V91);}
33095
33096 double __DUMMY_92;
33097
33098 }
33099 __label_90:
33100
33101 if (V89) {
33102 Py_XDECREF(V89);
33103 }
33104
33105 {Py_XDECREF(py_V89);}
33106
33107 double __DUMMY_90;
33108
33109 }
33110 __label_88:
33111
33112 if (V87) {
33113 Py_XDECREF(V87);
33114 }
33115
33116 {Py_XDECREF(py_V87);}
33117
33118 double __DUMMY_88;
33119
33120 }
33121 __label_86:
33122
33123 if (V85) {
33124 Py_XDECREF(V85);
33125 }
33126
33127 {Py_XDECREF(py_V85);}
33128
33129 double __DUMMY_86;
33130
33131 }
33132 __label_84:
33133
33134 if (V83) {
33135 Py_XDECREF(V83);
33136 }
33137
33138 {Py_XDECREF(py_V83);}
33139
33140 double __DUMMY_84;
33141
33142 }
33143 __label_82:
33144
33145 if (V81) {
33146 Py_XDECREF(V81);
33147 }
33148
33149 {Py_XDECREF(py_V81);}
33150
33151 double __DUMMY_82;
33152
33153 }
33154 __label_80:
33155
33156 if (V79) {
33157 Py_XDECREF(V79);
33158 }
33159
33160 {Py_XDECREF(py_V79);}
33161
33162 double __DUMMY_80;
33163
33164 }
33165 __label_78:
33166
33167 if (V77) {
33168 Py_XDECREF(V77);
33169 }
33170
33171 {Py_XDECREF(py_V77);}
33172
33173 double __DUMMY_78;
33174
33175 }
33176 __label_76:
33177
33178 if (V75) {
33179 Py_XDECREF(V75);
33180 }
33181
33182 {Py_XDECREF(py_V75);}
33183
33184 double __DUMMY_76;
33185
33186 }
33187 __label_74:
33188
33189 if (V73) {
33190 Py_XDECREF(V73);
33191 }
33192
33193 {Py_XDECREF(py_V73);}
33194
33195 double __DUMMY_74;
33196
33197 }
33198 __label_72:
33199
33200 if (V71) {
33201 Py_XDECREF(V71);
33202 }
33203
33204 {Py_XDECREF(py_V71);}
33205
33206 double __DUMMY_72;
33207
33208 }
33209 __label_70:
33210
33211 if (V69) {
33212 Py_XDECREF(V69);
33213 }
33214
33215 {Py_XDECREF(py_V69);}
33216
33217 double __DUMMY_70;
33218
33219 }
33220 __label_68:
33221
33222 if (V67) {
33223 Py_XDECREF(V67);
33224 }
33225
33226 {Py_XDECREF(py_V67);}
33227
33228 double __DUMMY_68;
33229
33230 }
33231 __label_66:
33232
33233 if (V65) {
33234 Py_XDECREF(V65);
33235 }
33236
33237 {Py_XDECREF(py_V65);}
33238
33239 double __DUMMY_66;
33240
33241 }
33242 __label_64:
33243
33244 if (V63) {
33245 Py_XDECREF(V63);
33246 }
33247
33248 {Py_XDECREF(py_V63);}
33249
33250 double __DUMMY_64;
33251
33252 }
33253 __label_62:
33254
33255 if (V61) {
33256 Py_XDECREF(V61);
33257 }
33258
33259 {Py_XDECREF(py_V61);}
33260
33261 double __DUMMY_62;
33262
33263 }
33264 __label_60:
33265
33266 if (V59) {
33267 Py_XDECREF(V59);
33268 }
33269
33270 {Py_XDECREF(py_V59);}
33271
33272 double __DUMMY_60;
33273
33274 }
33275 __label_58:
33276
33277 if (V57) {
33278 Py_XDECREF(V57);
33279 }
33280
33281 {Py_XDECREF(py_V57);}
33282
33283 double __DUMMY_58;
33284
33285 }
33286 __label_56:
33287
33288 if (V55) {
33289 Py_XDECREF(V55);
33290 }
33291
33292 {Py_XDECREF(py_V55);}
33293
33294 double __DUMMY_56;
33295
33296 }
33297 __label_54:
33298
33299 if (V53) {
33300 Py_XDECREF(V53);
33301 }
33302
33303 {Py_XDECREF(py_V53);}
33304
33305 double __DUMMY_54;
33306
33307 }
33308 __label_52:
33309
33310 if (V51) {
33311 Py_XDECREF(V51);
33312 }
33313
33314 {Py_XDECREF(py_V51);}
33315
33316 double __DUMMY_52;
33317
33318 }
33319 __label_50:
33320
33321 if (V49) {
33322 Py_XDECREF(V49);
33323 }
33324
33325 {Py_XDECREF(py_V49);}
33326
33327 double __DUMMY_50;
33328
33329 }
33330 __label_48:
33331
33332 if (V47) {
33333 Py_XDECREF(V47);
33334 }
33335
33336 {Py_XDECREF(py_V47);}
33337
33338 double __DUMMY_48;
33339
33340 }
33341 __label_46:
33342
33343 if (V45) {
33344 Py_XDECREF(V45);
33345 }
33346
33347 {Py_XDECREF(py_V45);}
33348
33349 double __DUMMY_46;
33350
33351 }
33352 __label_44:
33353
33354 if (V43) {
33355 Py_XDECREF(V43);
33356 }
33357
33358 {Py_XDECREF(py_V43);}
33359
33360 double __DUMMY_44;
33361
33362 }
33363 __label_42:
33364
33365 if (V41) {
33366 Py_XDECREF(V41);
33367 }
33368
33369 {Py_XDECREF(py_V41);}
33370
33371 double __DUMMY_42;
33372
33373 }
33374 __label_40:
33375
33376 if (V39) {
33377 Py_XDECREF(V39);
33378 }
33379
33380 {Py_XDECREF(py_V39);}
33381
33382 double __DUMMY_40;
33383
33384 }
33385 __label_38:
33386
33387 if (V37) {
33388 Py_XDECREF(V37);
33389 }
33390
33391 {Py_XDECREF(py_V37);}
33392
33393 double __DUMMY_38;
33394
33395 }
33396 __label_36:
33397
33398 if (V35) {
33399 Py_XDECREF(V35);
33400 }
33401
33402 {Py_XDECREF(py_V35);}
33403
33404 double __DUMMY_36;
33405
33406 }
33407 __label_34:
33408
33409 if (V33) {
33410 Py_XDECREF(V33);
33411 }
33412
33413 {Py_XDECREF(py_V33);}
33414
33415 double __DUMMY_34;
33416
33417 }
33418 __label_32:
33419
33420 if (V31) {
33421 Py_XDECREF(V31);
33422 }
33423
33424 {Py_XDECREF(py_V31);}
33425
33426 double __DUMMY_32;
33427
33428 }
33429 __label_30:
33430
33431 if (V29) {
33432 Py_XDECREF(V29);
33433 }
33434
33435 {Py_XDECREF(py_V29);}
33436
33437 double __DUMMY_30;
33438
33439 }
33440 __label_28:
33441
33442 if (V27) {
33443 Py_XDECREF(V27);
33444 }
33445
33446 {Py_XDECREF(py_V27);}
33447
33448 double __DUMMY_28;
33449
33450 }
33451 __label_26:
33452
33453 if (V25) {
33454 Py_XDECREF(V25);
33455 }
33456
33457 {Py_XDECREF(py_V25);}
33458
33459 double __DUMMY_26;
33460
33461 }
33462 __label_24:
33463
33464 if (V23) {
33465 Py_XDECREF(V23);
33466 }
33467
33468 {Py_XDECREF(py_V23);}
33469
33470 double __DUMMY_24;
33471
33472 }
33473 __label_22:
33474
33475 if (V21) {
33476 Py_XDECREF(V21);
33477 }
33478
33479 {Py_XDECREF(py_V21);}
33480
33481 double __DUMMY_22;
33482
33483 }
33484 __label_20:
33485
33486 if (V19) {
33487 Py_XDECREF(V19);
33488 }
33489
33490 {Py_XDECREF(py_V19);}
33491
33492 double __DUMMY_20;
33493
33494 }
33495 __label_18:
33496
33497 if (V17) {
33498 Py_XDECREF(V17);
33499 }
33500
33501 {Py_XDECREF(py_V17);}
33502
33503 double __DUMMY_18;
33504
33505 }
33506 __label_16:
33507
33508 if (V15) {
33509 Py_XDECREF(V15);
33510 }
33511
33512 {Py_XDECREF(py_V15);}
33513
33514 double __DUMMY_16;
33515
33516 }
33517 __label_14:
33518
33519 if (V13) {
33520 Py_XDECREF(V13);
33521 }
33522
33523 {Py_XDECREF(py_V13);}
33524
33525 double __DUMMY_14;
33526
33527 }
33528 __label_12:
33529
33530 if (V11) {
33531 Py_XDECREF(V11);
33532 }
33533
33534 {Py_XDECREF(py_V11);}
33535
33536 double __DUMMY_12;
33537
33538 }
33539 __label_10:
33540
33541 if (V9) {
33542 Py_XDECREF(V9);
33543 }
33544
33545 {Py_XDECREF(py_V9);}
33546
33547 double __DUMMY_10;
33548
33549 }
33550 __label_8:
33551
33552 if (V7) {
33553 Py_XDECREF(V7);
33554 }
33555
33556 {Py_XDECREF(py_V7);}
33557
33558 double __DUMMY_8;
33559
33560 }
33561 __label_6:
33562
33563 if (V5) {
33564 Py_XDECREF(V5);
33565 }
33566
33567 {Py_XDECREF(py_V5);}
33568
33569 double __DUMMY_6;
33570
33571 }
33572 __label_4:
33573
33574 if (V3) {
33575 Py_XDECREF(V3);
33576 }
33577
33578 {Py_XDECREF(py_V3);}
33579
33580 double __DUMMY_4;
33581
33582 }
33583 __label_2:
33584
33585 if (!__failure) {
33586
33587 {Py_XDECREF(py_V1);}
33588 if (!V1) {
33589 Py_INCREF(Py_None);
33590 py_V1 = Py_None;
33591 }
33592 else if ((void*)py_V1 != (void*)V1) {
33593 py_V1 = (PyObject*)V1;
33594 }
33595
33596 {Py_XINCREF(py_V1);}
33597
33598 if (V1 && !PyArray_ISALIGNED((PyArrayObject*) py_V1)) {
33599 PyErr_Format(PyExc_NotImplementedError,
33600 "c_sync: expected an aligned array, got non-aligned array of type %ld"
33601 " with %ld dimensions, with 3 last dims "
33602 "%ld, %ld, %ld"
33603 " and 3 last strides %ld %ld, %ld.",
33604 (long int) PyArray_TYPE((PyArrayObject*) py_V1),
33605 (long int) PyArray_NDIM(V1),
33606 (long int) (PyArray_NDIM(V1) >= 3 ?
33607 PyArray_DIMS(V1)[PyArray_NDIM(V1)-3] : -1),
33608 (long int) (PyArray_NDIM(V1) >= 2 ?
33609 PyArray_DIMS(V1)[PyArray_NDIM(V1)-2] : -1),
33610 (long int) (PyArray_NDIM(V1) >= 1 ?
33611 PyArray_DIMS(V1)[PyArray_NDIM(V1)-1] : -1),
33612 (long int) (PyArray_NDIM(V1) >= 3 ?
33613 PyArray_STRIDES(V1)[PyArray_NDIM(V1)-3] : -1),
33614 (long int) (PyArray_NDIM(V1) >= 2 ?
33615 PyArray_STRIDES(V1)[PyArray_NDIM(V1)-2] : -1),
33616 (long int) (PyArray_NDIM(V1) >= 1 ?
33617 PyArray_STRIDES(V1)[PyArray_NDIM(V1)-1] : -1)
33618 );
33619 {
33620 __failure = 2;
33621 if (!PyErr_Occurred()) {
33622 PyErr_SetString(PyExc_RuntimeError,
33623 "Unexpected error in an Op's C code. "
33624 "No Python exception was set.");
33625 }
33626 goto __label_2;}
33627 }
33628
33629 PyObject* old = PyList_GET_ITEM(storage_V1, 0);
33630 {Py_XINCREF(py_V1);}
33631 PyList_SET_ITEM(storage_V1, 0, py_V1);
33632 {Py_XDECREF(old);}
33633 }
33634
33635 if (V1) {
33636 Py_XDECREF(V1);
33637 }
33638
33639 {Py_XDECREF(py_V1);}
33640
33641 double __DUMMY_2;
33642
33643 }
33644
33645
33646 if (__failure) {
33647 // When there is a failure, this code puts the exception
33648 // in __ERROR.
33649 PyObject* err_type = NULL;
33650 PyObject* err_msg = NULL;
33651 PyObject* err_traceback = NULL;
33652 PyErr_Fetch(&err_type, &err_msg, &err_traceback);
33653 if (!err_type) {err_type = Py_None;Py_INCREF(Py_None);}
33654 if (!err_msg) {err_msg = Py_None; Py_INCREF(Py_None);}
33655 if (!err_traceback) {err_traceback = Py_None; Py_INCREF(Py_None);}
33656 PyObject* old_err_type = PyList_GET_ITEM(__ERROR, 0);
33657 PyObject* old_err_msg = PyList_GET_ITEM(__ERROR, 1);
33658 PyObject* old_err_traceback = PyList_GET_ITEM(__ERROR, 2);
33659 PyList_SET_ITEM(__ERROR, 0, err_type);
33660 PyList_SET_ITEM(__ERROR, 1, err_msg);
33661 PyList_SET_ITEM(__ERROR, 2, err_traceback);
33662 {Py_XDECREF(old_err_type);}
33663 {Py_XDECREF(old_err_msg);}
33664 {Py_XDECREF(old_err_traceback);}
33665 }
33666 // The failure code is returned to index what code block failed.
33667 return __failure;
33668
33669 }
33670 };
33671 }
33672
33673
33674 static int __struct_compiled_op_m60e56977ddfb69ae27ec355d8781d656_executor(__struct_compiled_op_m60e56977ddfb69ae27ec355d8781d656 *self) {
33675 return self->run();
33676 }
33677
33678 static void __struct_compiled_op_m60e56977ddfb69ae27ec355d8781d656_destructor(PyObject *capsule) {
33679 __struct_compiled_op_m60e56977ddfb69ae27ec355d8781d656 *self = (__struct_compiled_op_m60e56977ddfb69ae27ec355d8781d656 *)PyCapsule_GetContext(capsule);
33680 delete self;
33681 }
33682
33683 //////////////////////
33684 //// Functions
33685 //////////////////////
33686 static PyObject * instantiate(PyObject * self, PyObject *argtuple) {
33687 assert(PyTuple_Check(argtuple));
33688 if (303 != PyTuple_Size(argtuple)){
33689 PyErr_Format(PyExc_TypeError, "Wrong number of arguments, expected 303, got %i", (int)PyTuple_Size(argtuple));
33690 return NULL;
33691 }
33692 __struct_compiled_op_m60e56977ddfb69ae27ec355d8781d656* struct_ptr = new __struct_compiled_op_m60e56977ddfb69ae27ec355d8781d656();
33693 if (struct_ptr->init( PyTuple_GET_ITEM(argtuple, 0),PyTuple_GET_ITEM(argtuple, 1),PyTuple_GET_ITEM(argtuple, 2),PyTuple_GET_ITEM(argtuple, 3),PyTuple_GET_ITEM(argtuple, 4),PyTuple_GET_ITEM(argtuple, 5),PyTuple_GET_ITEM(argtuple, 6),PyTuple_GET_ITEM(argtuple, 7),PyTuple_GET_ITEM(argtuple, 8),PyTuple_GET_ITEM(argtuple, 9),PyTuple_GET_ITEM(argtuple, 10),PyTuple_GET_ITEM(argtuple, 11),PyTuple_GET_ITEM(argtuple, 12),PyTuple_GET_ITEM(argtuple, 13),PyTuple_GET_ITEM(argtuple, 14),PyTuple_GET_ITEM(argtuple, 15),PyTuple_GET_ITEM(argtuple, 16),PyTuple_GET_ITEM(argtuple, 17),PyTuple_GET_ITEM(argtuple, 18),PyTuple_GET_ITEM(argtuple, 19),PyTuple_GET_ITEM(argtuple, 20),PyTuple_GET_ITEM(argtuple, 21),PyTuple_GET_ITEM(argtuple, 22),PyTuple_GET_ITEM(argtuple, 23),PyTuple_GET_ITEM(argtuple, 24),PyTuple_GET_ITEM(argtuple, 25),PyTuple_GET_ITEM(argtuple, 26),PyTuple_GET_ITEM(argtuple, 27),PyTuple_GET_ITEM(argtuple, 28),PyTuple_GET_ITEM(argtuple, 29),PyTuple_GET_ITEM(argtuple, 30),PyTuple_GET_ITEM(argtuple, 31),PyTuple_GET_ITEM(argtuple, 32),PyTuple_GET_ITEM(argtuple, 33),PyTuple_GET_ITEM(argtuple, 34),PyTuple_GET_ITEM(argtuple, 35),PyTuple_GET_ITEM(argtuple, 36),PyTuple_GET_ITEM(argtuple, 37),PyTuple_GET_ITEM(argtuple, 38),PyTuple_GET_ITEM(argtuple, 39),PyTuple_GET_ITEM(argtuple, 40),PyTuple_GET_ITEM(argtuple, 41),PyTuple_GET_ITEM(argtuple, 42),PyTuple_GET_ITEM(argtuple, 43),PyTuple_GET_ITEM(argtuple, 44),PyTuple_GET_ITEM(argtuple, 45),PyTuple_GET_ITEM(argtuple, 46),PyTuple_GET_ITEM(argtuple, 47),PyTuple_GET_ITEM(argtuple, 48),PyTuple_GET_ITEM(argtuple, 49),PyTuple_GET_ITEM(argtuple, 50),PyTuple_GET_ITEM(argtuple, 51),PyTuple_GET_ITEM(argtuple, 52),PyTuple_GET_ITEM(argtuple, 53),PyTuple_GET_ITEM(argtuple, 54),PyTuple_GET_ITEM(argtuple, 55),PyTuple_GET_ITEM(argtuple, 56),PyTuple_GET_ITEM(argtuple, 57),PyTuple_GET_ITEM(argtuple, 58),PyTuple_GET_ITEM(argtuple, 59),PyTuple_GET_ITEM(argtuple, 60),PyTuple_GET_ITEM(argtuple, 61),PyTuple_GET_ITEM(argtuple, 62),PyTuple_GET_ITEM(argtuple, 63),PyTuple_GET_ITEM(argtuple, 64),PyTuple_GET_ITEM(argtuple, 65),PyTuple_GET_ITEM(argtuple, 66),PyTuple_GET_ITEM(argtuple, 67),PyTuple_GET_ITEM(argtuple, 68),PyTuple_GET_ITEM(argtuple, 69),PyTuple_GET_ITEM(argtuple, 70),PyTuple_GET_ITEM(argtuple, 71),PyTuple_GET_ITEM(argtuple, 72),PyTuple_GET_ITEM(argtuple, 73),PyTuple_GET_ITEM(argtuple, 74),PyTuple_GET_ITEM(argtuple, 75),PyTuple_GET_ITEM(argtuple, 76),PyTuple_GET_ITEM(argtuple, 77),PyTuple_GET_ITEM(argtuple, 78),PyTuple_GET_ITEM(argtuple, 79),PyTuple_GET_ITEM(argtuple, 80),PyTuple_GET_ITEM(argtuple, 81),PyTuple_GET_ITEM(argtuple, 82),PyTuple_GET_ITEM(argtuple, 83),PyTuple_GET_ITEM(argtuple, 84),PyTuple_GET_ITEM(argtuple, 85),PyTuple_GET_ITEM(argtuple, 86),PyTuple_GET_ITEM(argtuple, 87),PyTuple_GET_ITEM(argtuple, 88),PyTuple_GET_ITEM(argtuple, 89),PyTuple_GET_ITEM(argtuple, 90),PyTuple_GET_ITEM(argtuple, 91),PyTuple_GET_ITEM(argtuple, 92),PyTuple_GET_ITEM(argtuple, 93),PyTuple_GET_ITEM(argtuple, 94),PyTuple_GET_ITEM(argtuple, 95),PyTuple_GET_ITEM(argtuple, 96),PyTuple_GET_ITEM(argtuple, 97),PyTuple_GET_ITEM(argtuple, 98),PyTuple_GET_ITEM(argtuple, 99),PyTuple_GET_ITEM(argtuple, 100),PyTuple_GET_ITEM(argtuple, 101),PyTuple_GET_ITEM(argtuple, 102),PyTuple_GET_ITEM(argtuple, 103),PyTuple_GET_ITEM(argtuple, 104),PyTuple_GET_ITEM(argtuple, 105),PyTuple_GET_ITEM(argtuple, 106),PyTuple_GET_ITEM(argtuple, 107),PyTuple_GET_ITEM(argtuple, 108),PyTuple_GET_ITEM(argtuple, 109),PyTuple_GET_ITEM(argtuple, 110),PyTuple_GET_ITEM(argtuple, 111),PyTuple_GET_ITEM(argtuple, 112),PyTuple_GET_ITEM(argtuple, 113),PyTuple_GET_ITEM(argtuple, 114),PyTuple_GET_ITEM(argtuple, 115),PyTuple_GET_ITEM(argtuple, 116),PyTuple_GET_ITEM(argtuple, 117),PyTuple_GET_ITEM(argtuple, 118),PyTuple_GET_ITEM(argtuple, 119),PyTuple_GET_ITEM(argtuple, 120),PyTuple_GET_ITEM(argtuple, 121),PyTuple_GET_ITEM(argtuple, 122),PyTuple_GET_ITEM(argtuple, 123),PyTuple_GET_ITEM(argtuple, 124),PyTuple_GET_ITEM(argtuple, 125),PyTuple_GET_ITEM(argtuple, 126),PyTuple_GET_ITEM(argtuple, 127),PyTuple_GET_ITEM(argtuple, 128),PyTuple_GET_ITEM(argtuple, 129),PyTuple_GET_ITEM(argtuple, 130),PyTuple_GET_ITEM(argtuple, 131),PyTuple_GET_ITEM(argtuple, 132),PyTuple_GET_ITEM(argtuple, 133),PyTuple_GET_ITEM(argtuple, 134),PyTuple_GET_ITEM(argtuple, 135),PyTuple_GET_ITEM(argtuple, 136),PyTuple_GET_ITEM(argtuple, 137),PyTuple_GET_ITEM(argtuple, 138),PyTuple_GET_ITEM(argtuple, 139),PyTuple_GET_ITEM(argtuple, 140),PyTuple_GET_ITEM(argtuple, 141),PyTuple_GET_ITEM(argtuple, 142),PyTuple_GET_ITEM(argtuple, 143),PyTuple_GET_ITEM(argtuple, 144),PyTuple_GET_ITEM(argtuple, 145),PyTuple_GET_ITEM(argtuple, 146),PyTuple_GET_ITEM(argtuple, 147),PyTuple_GET_ITEM(argtuple, 148),PyTuple_GET_ITEM(argtuple, 149),PyTuple_GET_ITEM(argtuple, 150),PyTuple_GET_ITEM(argtuple, 151),PyTuple_GET_ITEM(argtuple, 152),PyTuple_GET_ITEM(argtuple, 153),PyTuple_GET_ITEM(argtuple, 154),PyTuple_GET_ITEM(argtuple, 155),PyTuple_GET_ITEM(argtuple, 156),PyTuple_GET_ITEM(argtuple, 157),PyTuple_GET_ITEM(argtuple, 158),PyTuple_GET_ITEM(argtuple, 159),PyTuple_GET_ITEM(argtuple, 160),PyTuple_GET_ITEM(argtuple, 161),PyTuple_GET_ITEM(argtuple, 162),PyTuple_GET_ITEM(argtuple, 163),PyTuple_GET_ITEM(argtuple, 164),PyTuple_GET_ITEM(argtuple, 165),PyTuple_GET_ITEM(argtuple, 166),PyTuple_GET_ITEM(argtuple, 167),PyTuple_GET_ITEM(argtuple, 168),PyTuple_GET_ITEM(argtuple, 169),PyTuple_GET_ITEM(argtuple, 170),PyTuple_GET_ITEM(argtuple, 171),PyTuple_GET_ITEM(argtuple, 172),PyTuple_GET_ITEM(argtuple, 173),PyTuple_GET_ITEM(argtuple, 174),PyTuple_GET_ITEM(argtuple, 175),PyTuple_GET_ITEM(argtuple, 176),PyTuple_GET_ITEM(argtuple, 177),PyTuple_GET_ITEM(argtuple, 178),PyTuple_GET_ITEM(argtuple, 179),PyTuple_GET_ITEM(argtuple, 180),PyTuple_GET_ITEM(argtuple, 181),PyTuple_GET_ITEM(argtuple, 182),PyTuple_GET_ITEM(argtuple, 183),PyTuple_GET_ITEM(argtuple, 184),PyTuple_GET_ITEM(argtuple, 185),PyTuple_GET_ITEM(argtuple, 186),PyTuple_GET_ITEM(argtuple, 187),PyTuple_GET_ITEM(argtuple, 188),PyTuple_GET_ITEM(argtuple, 189),PyTuple_GET_ITEM(argtuple, 190),PyTuple_GET_ITEM(argtuple, 191),PyTuple_GET_ITEM(argtuple, 192),PyTuple_GET_ITEM(argtuple, 193),PyTuple_GET_ITEM(argtuple, 194),PyTuple_GET_ITEM(argtuple, 195),PyTuple_GET_ITEM(argtuple, 196),PyTuple_GET_ITEM(argtuple, 197),PyTuple_GET_ITEM(argtuple, 198),PyTuple_GET_ITEM(argtuple, 199),PyTuple_GET_ITEM(argtuple, 200),PyTuple_GET_ITEM(argtuple, 201),PyTuple_GET_ITEM(argtuple, 202),PyTuple_GET_ITEM(argtuple, 203),PyTuple_GET_ITEM(argtuple, 204),PyTuple_GET_ITEM(argtuple, 205),PyTuple_GET_ITEM(argtuple, 206),PyTuple_GET_ITEM(argtuple, 207),PyTuple_GET_ITEM(argtuple, 208),PyTuple_GET_ITEM(argtuple, 209),PyTuple_GET_ITEM(argtuple, 210),PyTuple_GET_ITEM(argtuple, 211),PyTuple_GET_ITEM(argtuple, 212),PyTuple_GET_ITEM(argtuple, 213),PyTuple_GET_ITEM(argtuple, 214),PyTuple_GET_ITEM(argtuple, 215),PyTuple_GET_ITEM(argtuple, 216),PyTuple_GET_ITEM(argtuple, 217),PyTuple_GET_ITEM(argtuple, 218),PyTuple_GET_ITEM(argtuple, 219),PyTuple_GET_ITEM(argtuple, 220),PyTuple_GET_ITEM(argtuple, 221),PyTuple_GET_ITEM(argtuple, 222),PyTuple_GET_ITEM(argtuple, 223),PyTuple_GET_ITEM(argtuple, 224),PyTuple_GET_ITEM(argtuple, 225),PyTuple_GET_ITEM(argtuple, 226),PyTuple_GET_ITEM(argtuple, 227),PyTuple_GET_ITEM(argtuple, 228),PyTuple_GET_ITEM(argtuple, 229),PyTuple_GET_ITEM(argtuple, 230),PyTuple_GET_ITEM(argtuple, 231),PyTuple_GET_ITEM(argtuple, 232),PyTuple_GET_ITEM(argtuple, 233),PyTuple_GET_ITEM(argtuple, 234),PyTuple_GET_ITEM(argtuple, 235),PyTuple_GET_ITEM(argtuple, 236),PyTuple_GET_ITEM(argtuple, 237),PyTuple_GET_ITEM(argtuple, 238),PyTuple_GET_ITEM(argtuple, 239),PyTuple_GET_ITEM(argtuple, 240),PyTuple_GET_ITEM(argtuple, 241),PyTuple_GET_ITEM(argtuple, 242),PyTuple_GET_ITEM(argtuple, 243),PyTuple_GET_ITEM(argtuple, 244),PyTuple_GET_ITEM(argtuple, 245),PyTuple_GET_ITEM(argtuple, 246),PyTuple_GET_ITEM(argtuple, 247),PyTuple_GET_ITEM(argtuple, 248),PyTuple_GET_ITEM(argtuple, 249),PyTuple_GET_ITEM(argtuple, 250),PyTuple_GET_ITEM(argtuple, 251),PyTuple_GET_ITEM(argtuple, 252),PyTuple_GET_ITEM(argtuple, 253),PyTuple_GET_ITEM(argtuple, 254),PyTuple_GET_ITEM(argtuple, 255),PyTuple_GET_ITEM(argtuple, 256),PyTuple_GET_ITEM(argtuple, 257),PyTuple_GET_ITEM(argtuple, 258),PyTuple_GET_ITEM(argtuple, 259),PyTuple_GET_ITEM(argtuple, 260),PyTuple_GET_ITEM(argtuple, 261),PyTuple_GET_ITEM(argtuple, 262),PyTuple_GET_ITEM(argtuple, 263),PyTuple_GET_ITEM(argtuple, 264),PyTuple_GET_ITEM(argtuple, 265),PyTuple_GET_ITEM(argtuple, 266),PyTuple_GET_ITEM(argtuple, 267),PyTuple_GET_ITEM(argtuple, 268),PyTuple_GET_ITEM(argtuple, 269),PyTuple_GET_ITEM(argtuple, 270),PyTuple_GET_ITEM(argtuple, 271),PyTuple_GET_ITEM(argtuple, 272),PyTuple_GET_ITEM(argtuple, 273),PyTuple_GET_ITEM(argtuple, 274),PyTuple_GET_ITEM(argtuple, 275),PyTuple_GET_ITEM(argtuple, 276),PyTuple_GET_ITEM(argtuple, 277),PyTuple_GET_ITEM(argtuple, 278),PyTuple_GET_ITEM(argtuple, 279),PyTuple_GET_ITEM(argtuple, 280),PyTuple_GET_ITEM(argtuple, 281),PyTuple_GET_ITEM(argtuple, 282),PyTuple_GET_ITEM(argtuple, 283),PyTuple_GET_ITEM(argtuple, 284),PyTuple_GET_ITEM(argtuple, 285),PyTuple_GET_ITEM(argtuple, 286),PyTuple_GET_ITEM(argtuple, 287),PyTuple_GET_ITEM(argtuple, 288),PyTuple_GET_ITEM(argtuple, 289),PyTuple_GET_ITEM(argtuple, 290),PyTuple_GET_ITEM(argtuple, 291),PyTuple_GET_ITEM(argtuple, 292),PyTuple_GET_ITEM(argtuple, 293),PyTuple_GET_ITEM(argtuple, 294),PyTuple_GET_ITEM(argtuple, 295),PyTuple_GET_ITEM(argtuple, 296),PyTuple_GET_ITEM(argtuple, 297),PyTuple_GET_ITEM(argtuple, 298),PyTuple_GET_ITEM(argtuple, 299),PyTuple_GET_ITEM(argtuple, 300),PyTuple_GET_ITEM(argtuple, 301),PyTuple_GET_ITEM(argtuple, 302) ) != 0) {
33694 delete struct_ptr;
33695 return NULL;
33696 }
33697 PyObject* thunk = PyCapsule_New((void*)(&__struct_compiled_op_m60e56977ddfb69ae27ec355d8781d656_executor), NULL, __struct_compiled_op_m60e56977ddfb69ae27ec355d8781d656_destructor);
33698 if (thunk != NULL && PyCapsule_SetContext(thunk, struct_ptr) != 0) {
33699 PyErr_Clear();
33700 Py_DECREF(thunk);
33701 thunk = NULL;
33702 }
33703
33704 return thunk; }
33705
33706 //////////////////////
33707 //// Module init
33708 //////////////////////
33709 static PyMethodDef MyMethods[] = {
33710 {"instantiate", instantiate, METH_VARARGS, "undocumented"} ,
33711 {NULL, NULL, 0, NULL}
33712 };
33713 static struct PyModuleDef moduledef = {
33714 PyModuleDef_HEAD_INIT,
33715 "m60e56977ddfb69ae27ec355d8781d656",
33716 NULL,
33717 -1,
33718 MyMethods,
33719 };
33720
33721 PyMODINIT_FUNC PyInit_m60e56977ddfb69ae27ec355d8781d656(void) {
33722 import_array();
33723 PyObject *m = PyModule_Create(&moduledef);
33724 return m;
33725 }
33726
Problem occurred during compilation with the command line below:
/usr/bin/clang++ -dynamiclib -g -O3 -fno-math-errno -Wno-unused-label -Wno-unused-variable -Wno-write-strings -march=haswell -DNPY_NO_DEPRECATED_API=NPY_1_7_API_VERSION -m64 -fPIC -undefined dynamic_lookup -I/Users/fonnescj/anaconda3/lib/python3.5/site-packages/numpy/core/include -I/Users/fonnescj/anaconda3/include/python3.5m -I/Users/fonnescj/Repositories/Theano/theano/gof -L/Users/fonnescj/anaconda3/lib -fvisibility=hidden -o /Users/fonnescj/.theano/compiledir_Darwin-16.1.0-x86_64-i386-64bit-i386-3.5.2-64/tmp7oxnww5h/m60e56977ddfb69ae27ec355d8781d656.so /Users/fonnescj/.theano/compiledir_Darwin-16.1.0-x86_64-i386-64bit-i386-3.5.2-64/tmp7oxnww5h/mod.cpp