In [1]:
%matplotlib inline
import numpy as np
import pandas as pd
import pymc3 as pm
import seaborn as sns
In [6]:
fake_data = np.random.random((100, 301))
X = pd.DataFrame(fake_data, columns=['y']+['x%i' % i for i in range(300)])
In [8]:
formula = 'y ~ ' + ' + '.join(X.columns.values[1:])
formula
Out[8]:
'y ~ x0 + x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 + x11 + x12 + x13 + x14 + x15 + x16 + x17 + x18 + x19 + x20 + x21 + x22 + x23 + x24 + x25 + x26 + x27 + x28 + x29 + x30 + x31 + x32 + x33 + x34 + x35 + x36 + x37 + x38 + x39 + x40 + x41 + x42 + x43 + x44 + x45 + x46 + x47 + x48 + x49 + x50 + x51 + x52 + x53 + x54 + x55 + x56 + x57 + x58 + x59 + x60 + x61 + x62 + x63 + x64 + x65 + x66 + x67 + x68 + x69 + x70 + x71 + x72 + x73 + x74 + x75 + x76 + x77 + x78 + x79 + x80 + x81 + x82 + x83 + x84 + x85 + x86 + x87 + x88 + x89 + x90 + x91 + x92 + x93 + x94 + x95 + x96 + x97 + x98 + x99 + x100 + x101 + x102 + x103 + x104 + x105 + x106 + x107 + x108 + x109 + x110 + x111 + x112 + x113 + x114 + x115 + x116 + x117 + x118 + x119 + x120 + x121 + x122 + x123 + x124 + x125 + x126 + x127 + x128 + x129 + x130 + x131 + x132 + x133 + x134 + x135 + x136 + x137 + x138 + x139 + x140 + x141 + x142 + x143 + x144 + x145 + x146 + x147 + x148 + x149 + x150 + x151 + x152 + x153 + x154 + x155 + x156 + x157 + x158 + x159 + x160 + x161 + x162 + x163 + x164 + x165 + x166 + x167 + x168 + x169 + x170 + x171 + x172 + x173 + x174 + x175 + x176 + x177 + x178 + x179 + x180 + x181 + x182 + x183 + x184 + x185 + x186 + x187 + x188 + x189 + x190 + x191 + x192 + x193 + x194 + x195 + x196 + x197 + x198 + x199 + x200 + x201 + x202 + x203 + x204 + x205 + x206 + x207 + x208 + x209 + x210 + x211 + x212 + x213 + x214 + x215 + x216 + x217 + x218 + x219 + x220 + x221 + x222 + x223 + x224 + x225 + x226 + x227 + x228 + x229 + x230 + x231 + x232 + x233 + x234 + x235 + x236 + x237 + x238 + x239 + x240 + x241 + x242 + x243 + x244 + x245 + x246 + x247 + x248 + x249 + x250 + x251 + x252 + x253 + x254 + x255 + x256 + x257 + x258 + x259 + x260 + x261 + x262 + x263 + x264 + x265 + x266 + x267 + x268 + x269 + x270 + x271 + x272 + x273 + x274 + x275 + x276 + x277 + x278 + x279 + x280 + x281 + x282 + x283 + x284 + x285 + x286 + x287 + x288 + x289 + x290 + x291 + x292 + x293 + x294 + x295 + x296 + x297 + x298 + x299'
In [9]:
with pm.Model() as model:
    pm.glm.glm(formula, X)
===============================
===============================
/Users/fonnescj/.theano/compiledir_Darwin-16.1.0-x86_64-i386-64bit-i386-3.5.2-64/tmp7oxnww5h/mod.cpp:25385:32: fatal error: bracket nesting level exceeded maximum of 256
        if (!PyErr_Occurred()) {
                               ^
/Users/fonnescj/.theano/compiledir_Darwin-16.1.0-x86_64-i386-64bit-i386-3.5.2-64/tmp7oxnww5h/mod.cpp:25385:32: note: use -fbracket-depth=N to increase maximum nesting level
1 error generated.

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