Untitled1.ipynb

Big Regression.ipynb

{
  "cells": [
    {
      "metadata": {
        "trusted": true,
        "collapsed": true
      },
      "cell_type": "code",
      "source": "%matplotlib inline\nimport numpy as np\nimport pandas as pd\nimport pymc3 as pm\nimport seaborn as sns",
      "execution_count": 1,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true,
        "collapsed": false
      },
      "cell_type": "code",
      "source": "fake_data = np.random.random((100, 301))\nX = pd.DataFrame(fake_data, columns=['y']+['x%i' % i for i in range(300)])",
      "execution_count": 6,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true,
        "collapsed": false
      },
      "cell_type": "code",
      "source": "formula = 'y ~ ' + ' + '.join(X.columns.values[1:])\nformula",
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": "'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'"
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "metadata": {
        "trusted": true,
        "collapsed": false,
        "scrolled": false
      },
      "cell_type": "code",
      "source": "with pm.Model() as model:\n    pm.glm.glm(formula, X)",
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": "===============================\n===============================\n/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\n        if (!PyErr_Occurred()) {\n                               ^\n/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\n1 error generated.\n\n",
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": "00001\t#include <Python.h>\n00002\t#include <iostream>\n00003\t#include \"theano_mod_helper.h\"\n00004\t#include <math.h>\n00005\t#include <numpy/arrayobject.h>\n00006\t#include <numpy/arrayscalars.h>\n00007\t//////////////////////\n00008\t////  Support Code\n00009\t//////////////////////\n00010\t\n00011\t\n00012\t    namespace {\n00013\t    struct __struct_compiled_op_m60e56977ddfb69ae27ec355d8781d656 {\n00014\t        PyObject* __ERROR;\n00015\t\n00016\t        PyObject* storage_V3;\n00017\tPyObject* storage_V5;\n00018\tPyObject* storage_V7;\n00019\tPyObject* storage_V9;\n00020\tPyObject* storage_V11;\n00021\tPyObject* storage_V13;\n00022\tPyObject* storage_V15;\n00023\tPyObject* storage_V17;\n00024\tPyObject* storage_V19;\n00025\tPyObject* storage_V21;\n00026\tPyObject* storage_V23;\n00027\tPyObject* storage_V25;\n00028\tPyObject* storage_V27;\n00029\tPyObject* storage_V29;\n00030\tPyObject* storage_V31;\n00031\tPyObject* storage_V33;\n00032\tPyObject* storage_V35;\n00033\tPyObject* storage_V37;\n00034\tPyObject* storage_V39;\n00035\tPyObject* storage_V41;\n00036\tPyObject* storage_V43;\n00037\tPyObject* storage_V45;\n00038\tPyObject* storage_V47;\n00039\tPyObject* storage_V49;\n00040\tPyObject* storage_V51;\n00041\tPyObject* storage_V53;\n00042\tPyObject* storage_V55;\n00043\tPyObject* storage_V57;\n00044\tPyObject* storage_V59;\n00045\tPyObject* storage_V61;\n00046\tPyObject* storage_V63;\n00047\tPyObject* storage_V65;\n00048\tPyObject* storage_V67;\n00049\tPyObject* storage_V69;\n00050\tPyObject* storage_V71;\n00051\tPyObject* storage_V73;\n00052\tPyObject* storage_V75;\n00053\tPyObject* storage_V77;\n00054\tPyObject* storage_V79;\n00055\tPyObject* storage_V81;\n00056\tPyObject* storage_V83;\n00057\tPyObject* storage_V85;\n00058\tPyObject* storage_V87;\n00059\tPyObject* storage_V89;\n00060\tPyObject* storage_V91;\n00061\tPyObject* storage_V93;\n00062\tPyObject* storage_V95;\n00063\tPyObject* storage_V97;\n00064\tPyObject* storage_V99;\n00065\tPyObject* storage_V101;\n00066\tPyObject* storage_V103;\n00067\tPyObject* storage_V105;\n00068\tPyObject* storage_V107;\n00069\tPyObject* storage_V109;\n00070\tPyObject* storage_V111;\n00071\tPyObject* storage_V113;\n00072\tPyObject* storage_V115;\n00073\tPyObject* storage_V117;\n00074\tPyObject* storage_V119;\n00075\tPyObject* storage_V121;\n00076\tPyObject* storage_V123;\n00077\tPyObject* storage_V125;\n00078\tPyObject* storage_V127;\n00079\tPyObject* storage_V129;\n00080\tPyObject* storage_V131;\n00081\tPyObject* storage_V133;\n00082\tPyObject* storage_V135;\n00083\tPyObject* storage_V137;\n00084\tPyObject* storage_V139;\n00085\tPyObject* storage_V141;\n00086\tPyObject* storage_V143;\n00087\tPyObject* storage_V145;\n00088\tPyObject* storage_V147;\n00089\tPyObject* storage_V149;\n00090\tPyObject* storage_V151;\n00091\tPyObject* storage_V153;\n00092\tPyObject* storage_V155;\n00093\tPyObject* storage_V157;\n00094\tPyObject* storage_V159;\n00095\tPyObject* storage_V161;\n00096\tPyObject* storage_V163;\n00097\tPyObject* storage_V165;\n00098\tPyObject* storage_V167;\n00099\tPyObject* storage_V169;\n00100\tPyObject* storage_V171;\n00101\tPyObject* storage_V173;\n00102\tPyObject* storage_V175;\n00103\tPyObject* storage_V177;\n00104\tPyObject* storage_V179;\n00105\tPyObject* storage_V181;\n00106\tPyObject* storage_V183;\n00107\tPyObject* storage_V185;\n00108\tPyObject* storage_V187;\n00109\tPyObject* storage_V189;\n00110\tPyObject* storage_V191;\n00111\tPyObject* storage_V193;\n00112\tPyObject* storage_V195;\n00113\tPyObject* storage_V197;\n00114\tPyObject* storage_V199;\n00115\tPyObject* storage_V201;\n00116\tPyObject* storage_V203;\n00117\tPyObject* storage_V205;\n00118\tPyObject* storage_V207;\n00119\tPyObject* storage_V209;\n00120\tPyObject* storage_V211;\n00121\tPyObject* storage_V213;\n00122\tPyObject* storage_V215;\n00123\tPyObject* storage_V217;\n00124\tPyObject* storage_V219;\n00125\tPyObject* storage_V221;\n00126\tPyObject* storage_V223;\n00127\tPyObject* storage_V225;\n00128\tPyObject* storage_V227;\n00129\tPyObject* storage_V229;\n00130\tPyObject* storage_V231;\n00131\tPyObject* storage_V233;\n00132\tPyObject* storage_V235;\n00133\tPyObject* storage_V237;\n00134\tPyObject* storage_V239;\n00135\tPyObject* storage_V241;\n00136\tPyObject* storage_V243;\n00137\tPyObject* storage_V245;\n00138\tPyObject* storage_V247;\n00139\tPyObject* storage_V249;\n00140\tPyObject* storage_V251;\n00141\tPyObject* storage_V253;\n00142\tPyObject* storage_V255;\n00143\tPyObject* storage_V257;\n00144\tPyObject* storage_V259;\n00145\tPyObject* storage_V261;\n00146\tPyObject* storage_V263;\n00147\tPyObject* storage_V265;\n00148\tPyObject* storage_V267;\n00149\tPyObject* storage_V269;\n00150\tPyObject* storage_V271;\n00151\tPyObject* storage_V273;\n00152\tPyObject* storage_V275;\n00153\tPyObject* storage_V277;\n00154\tPyObject* storage_V279;\n00155\tPyObject* storage_V281;\n00156\tPyObject* storage_V283;\n00157\tPyObject* storage_V285;\n00158\tPyObject* storage_V287;\n00159\tPyObject* storage_V289;\n00160\tPyObject* storage_V291;\n00161\tPyObject* storage_V293;\n00162\tPyObject* storage_V295;\n00163\tPyObject* storage_V297;\n00164\tPyObject* storage_V299;\n00165\tPyObject* storage_V301;\n00166\tPyObject* storage_V303;\n00167\tPyObject* storage_V305;\n00168\tPyObject* storage_V307;\n00169\tPyObject* storage_V309;\n00170\tPyObject* storage_V311;\n00171\tPyObject* storage_V313;\n00172\tPyObject* storage_V315;\n00173\tPyObject* storage_V317;\n00174\tPyObject* storage_V319;\n00175\tPyObject* storage_V321;\n00176\tPyObject* storage_V323;\n00177\tPyObject* storage_V325;\n00178\tPyObject* storage_V327;\n00179\tPyObject* storage_V329;\n00180\tPyObject* storage_V331;\n00181\tPyObject* storage_V333;\n00182\tPyObject* storage_V335;\n00183\tPyObject* storage_V337;\n00184\tPyObject* storage_V339;\n00185\tPyObject* storage_V341;\n00186\tPyObject* storage_V343;\n00187\tPyObject* storage_V345;\n00188\tPyObject* storage_V347;\n00189\tPyObject* storage_V349;\n00190\tPyObject* storage_V351;\n00191\tPyObject* storage_V353;\n00192\tPyObject* storage_V355;\n00193\tPyObject* storage_V357;\n00194\tPyObject* storage_V359;\n00195\tPyObject* storage_V361;\n00196\tPyObject* storage_V363;\n00197\tPyObject* storage_V365;\n00198\tPyObject* storage_V367;\n00199\tPyObject* storage_V369;\n00200\tPyObject* storage_V371;\n00201\tPyObject* storage_V373;\n00202\tPyObject* storage_V375;\n00203\tPyObject* storage_V377;\n00204\tPyObject* storage_V379;\n00205\tPyObject* storage_V381;\n00206\tPyObject* storage_V383;\n00207\tPyObject* storage_V385;\n00208\tPyObject* storage_V387;\n00209\tPyObject* storage_V389;\n00210\tPyObject* storage_V391;\n00211\tPyObject* storage_V393;\n00212\tPyObject* storage_V395;\n00213\tPyObject* storage_V397;\n00214\tPyObject* storage_V399;\n00215\tPyObject* storage_V401;\n00216\tPyObject* storage_V403;\n00217\tPyObject* storage_V405;\n00218\tPyObject* storage_V407;\n00219\tPyObject* storage_V409;\n00220\tPyObject* storage_V411;\n00221\tPyObject* storage_V413;\n00222\tPyObject* storage_V415;\n00223\tPyObject* storage_V417;\n00224\tPyObject* storage_V419;\n00225\tPyObject* storage_V421;\n00226\tPyObject* storage_V423;\n00227\tPyObject* storage_V425;\n00228\tPyObject* storage_V427;\n00229\tPyObject* storage_V429;\n00230\tPyObject* storage_V431;\n00231\tPyObject* storage_V433;\n00232\tPyObject* storage_V435;\n00233\tPyObject* storage_V437;\n00234\tPyObject* storage_V439;\n00235\tPyObject* storage_V441;\n00236\tPyObject* storage_V443;\n00237\tPyObject* storage_V445;\n00238\tPyObject* storage_V447;\n00239\tPyObject* storage_V449;\n00240\tPyObject* storage_V451;\n00241\tPyObject* storage_V453;\n00242\tPyObject* storage_V455;\n00243\tPyObject* storage_V457;\n00244\tPyObject* storage_V459;\n00245\tPyObject* storage_V461;\n00246\tPyObject* storage_V463;\n00247\tPyObject* storage_V465;\n00248\tPyObject* storage_V467;\n00249\tPyObject* storage_V469;\n00250\tPyObject* storage_V471;\n00251\tPyObject* storage_V473;\n00252\tPyObject* storage_V475;\n00253\tPyObject* storage_V477;\n00254\tPyObject* storage_V479;\n00255\tPyObject* storage_V481;\n00256\tPyObject* storage_V483;\n00257\tPyObject* storage_V485;\n00258\tPyObject* storage_V487;\n00259\tPyObject* storage_V489;\n00260\tPyObject* storage_V491;\n00261\tPyObject* storage_V493;\n00262\tPyObject* storage_V495;\n00263\tPyObject* storage_V497;\n00264\tPyObject* storage_V499;\n00265\tPyObject* storage_V501;\n00266\tPyObject* storage_V503;\n00267\tPyObject* storage_V505;\n00268\tPyObject* storage_V507;\n00269\tPyObject* storage_V509;\n00270\tPyObject* storage_V511;\n00271\tPyObject* storage_V513;\n00272\tPyObject* storage_V515;\n00273\tPyObject* storage_V517;\n00274\tPyObject* storage_V519;\n00275\tPyObject* storage_V521;\n00276\tPyObject* storage_V523;\n00277\tPyObject* storage_V525;\n00278\tPyObject* storage_V527;\n00279\tPyObject* storage_V529;\n00280\tPyObject* storage_V531;\n00281\tPyObject* storage_V533;\n00282\tPyObject* storage_V535;\n00283\tPyObject* storage_V537;\n00284\tPyObject* storage_V539;\n00285\tPyObject* storage_V541;\n00286\tPyObject* storage_V543;\n00287\tPyObject* storage_V545;\n00288\tPyObject* storage_V547;\n00289\tPyObject* storage_V549;\n00290\tPyObject* storage_V551;\n00291\tPyObject* storage_V553;\n00292\tPyObject* storage_V555;\n00293\tPyObject* storage_V557;\n00294\tPyObject* storage_V559;\n00295\tPyObject* storage_V561;\n00296\tPyObject* storage_V563;\n00297\tPyObject* storage_V565;\n00298\tPyObject* storage_V567;\n00299\tPyObject* storage_V569;\n00300\tPyObject* storage_V571;\n00301\tPyObject* storage_V573;\n00302\tPyObject* storage_V575;\n00303\tPyObject* storage_V577;\n00304\tPyObject* storage_V579;\n00305\tPyObject* storage_V581;\n00306\tPyObject* storage_V583;\n00307\tPyObject* storage_V585;\n00308\tPyObject* storage_V587;\n00309\tPyObject* storage_V589;\n00310\tPyObject* storage_V591;\n00311\tPyObject* storage_V593;\n00312\tPyObject* storage_V595;\n00313\tPyObject* storage_V597;\n00314\tPyObject* storage_V599;\n00315\tPyObject* storage_V601;\n00316\tPyObject* storage_V603;\n00317\tPyObject* storage_V1;\n00318\t        \n00319\t\n00320\t        __struct_compiled_op_m60e56977ddfb69ae27ec355d8781d656() {\n00321\t            // This is only somewhat safe because we:\n00322\t            //  1) Are not a virtual class\n00323\t            //  2) Do not use any virtual classes in the members\n00324\t            //  3) Deal with mostly POD and pointers\n00325\t\n00326\t            // If this changes, we would have to revise this, but for\n00327\t            // now I am tired of chasing segfaults because\n00328\t            // initialization code had an error and some pointer has\n00329\t            // a junk value.\n00330\t            memset(this, 0, sizeof(*this));\n00331\t        }\n00332\t        ~__struct_compiled_op_m60e56977ddfb69ae27ec355d8781d656(void) {\n00333\t            cleanup();\n00334\t        }\n00335\t\n00336\t        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) {\n00337\t            Py_XINCREF(storage_V3);\n00338\tPy_XINCREF(storage_V5);\n00339\tPy_XINCREF(storage_V7);\n00340\tPy_XINCREF(storage_V9);\n00341\tPy_XINCREF(storage_V11);\n00342\tPy_XINCREF(storage_V13);\n00343\tPy_XINCREF(storage_V15);\n00344\tPy_XINCREF(storage_V17);\n00345\tPy_XINCREF(storage_V19);\n00346\tPy_XINCREF(storage_V21);\n00347\tPy_XINCREF(storage_V23);\n00348\tPy_XINCREF(storage_V25);\n00349\tPy_XINCREF(storage_V27);\n00350\tPy_XINCREF(storage_V29);\n00351\tPy_XINCREF(storage_V31);\n00352\tPy_XINCREF(storage_V33);\n00353\tPy_XINCREF(storage_V35);\n00354\tPy_XINCREF(storage_V37);\n00355\tPy_XINCREF(storage_V39);\n00356\tPy_XINCREF(storage_V41);\n00357\tPy_XINCREF(storage_V43);\n00358\tPy_XINCREF(storage_V45);\n00359\tPy_XINCREF(storage_V47);\n00360\tPy_XINCREF(storage_V49);\n00361\tPy_XINCREF(storage_V51);\n00362\tPy_XINCREF(storage_V53);\n00363\tPy_XINCREF(storage_V55);\n00364\tPy_XINCREF(storage_V57);\n00365\tPy_XINCREF(storage_V59);\n00366\tPy_XINCREF(storage_V61);\n00367\tPy_XINCREF(storage_V63);\n00368\tPy_XINCREF(storage_V65);\n00369\tPy_XINCREF(storage_V67);\n00370\tPy_XINCREF(storage_V69);\n00371\tPy_XINCREF(storage_V71);\n00372\tPy_XINCREF(storage_V73);\n00373\tPy_XINCREF(storage_V75);\n00374\tPy_XINCREF(storage_V77);\n00375\tPy_XINCREF(storage_V79);\n00376\tPy_XINCREF(storage_V81);\n00377\tPy_XINCREF(storage_V83);\n00378\tPy_XINCREF(storage_V85);\n00379\tPy_XINCREF(storage_V87);\n00380\tPy_XINCREF(storage_V89);\n00381\tPy_XINCREF(storage_V91);\n00382\tPy_XINCREF(storage_V93);\n00383\tPy_XINCREF(storage_V95);\n00384\tPy_XINCREF(storage_V97);\n00385\tPy_XINCREF(storage_V99);\n00386\tPy_XINCREF(storage_V101);\n00387\tPy_XINCREF(storage_V103);\n00388\tPy_XINCREF(storage_V105);\n00389\tPy_XINCREF(storage_V107);\n00390\tPy_XINCREF(storage_V109);\n00391\tPy_XINCREF(storage_V111);\n00392\tPy_XINCREF(storage_V113);\n00393\tPy_XINCREF(storage_V115);\n00394\tPy_XINCREF(storage_V117);\n00395\tPy_XINCREF(storage_V119);\n00396\tPy_XINCREF(storage_V121);\n00397\tPy_XINCREF(storage_V123);\n00398\tPy_XINCREF(storage_V125);\n00399\tPy_XINCREF(storage_V127);\n00400\tPy_XINCREF(storage_V129);\n00401\tPy_XINCREF(storage_V131);\n00402\tPy_XINCREF(storage_V133);\n00403\tPy_XINCREF(storage_V135);\n00404\tPy_XINCREF(storage_V137);\n00405\tPy_XINCREF(storage_V139);\n00406\tPy_XINCREF(storage_V141);\n00407\tPy_XINCREF(storage_V143);\n00408\tPy_XINCREF(storage_V145);\n00409\tPy_XINCREF(storage_V147);\n00410\tPy_XINCREF(storage_V149);\n00411\tPy_XINCREF(storage_V151);\n00412\tPy_XINCREF(storage_V153);\n00413\tPy_XINCREF(storage_V155);\n00414\tPy_XINCREF(storage_V157);\n00415\tPy_XINCREF(storage_V159);\n00416\tPy_XINCREF(storage_V161);\n00417\tPy_XINCREF(storage_V163);\n00418\tPy_XINCREF(storage_V165);\n00419\tPy_XINCREF(storage_V167);\n00420\tPy_XINCREF(storage_V169);\n00421\tPy_XINCREF(storage_V171);\n00422\tPy_XINCREF(storage_V173);\n00423\tPy_XINCREF(storage_V175);\n00424\tPy_XINCREF(storage_V177);\n00425\tPy_XINCREF(storage_V179);\n00426\tPy_XINCREF(storage_V181);\n00427\tPy_XINCREF(storage_V183);\n00428\tPy_XINCREF(storage_V185);\n00429\tPy_XINCREF(storage_V187);\n00430\tPy_XINCREF(storage_V189);\n00431\tPy_XINCREF(storage_V191);\n00432\tPy_XINCREF(storage_V193);\n00433\tPy_XINCREF(storage_V195);\n00434\tPy_XINCREF(storage_V197);\n00435\tPy_XINCREF(storage_V199);\n00436\tPy_XINCREF(storage_V201);\n00437\tPy_XINCREF(storage_V203);\n00438\tPy_XINCREF(storage_V205);\n00439\tPy_XINCREF(storage_V207);\n00440\tPy_XINCREF(storage_V209);\n00441\tPy_XINCREF(storage_V211);\n00442\tPy_XINCREF(storage_V213);\n00443\tPy_XINCREF(storage_V215);\n00444\tPy_XINCREF(storage_V217);\n00445\tPy_XINCREF(storage_V219);\n00446\tPy_XINCREF(storage_V221);\n00447\tPy_XINCREF(storage_V223);\n00448\tPy_XINCREF(storage_V225);\n00449\tPy_XINCREF(storage_V227);\n00450\tPy_XINCREF(storage_V229);\n00451\tPy_XINCREF(storage_V231);\n00452\tPy_XINCREF(storage_V233);\n00453\tPy_XINCREF(storage_V235);\n00454\tPy_XINCREF(storage_V237);\n00455\tPy_XINCREF(storage_V239);\n00456\tPy_XINCREF(storage_V241);\n00457\tPy_XINCREF(storage_V243);\n00458\tPy_XINCREF(storage_V245);\n00459\tPy_XINCREF(storage_V247);\n00460\tPy_XINCREF(storage_V249);\n00461\tPy_XINCREF(storage_V251);\n00462\tPy_XINCREF(storage_V253);\n00463\tPy_XINCREF(storage_V255);\n00464\tPy_XINCREF(storage_V257);\n00465\tPy_XINCREF(storage_V259);\n00466\tPy_XINCREF(storage_V261);\n00467\tPy_XINCREF(storage_V263);\n00468\tPy_XINCREF(storage_V265);\n00469\tPy_XINCREF(storage_V267);\n00470\tPy_XINCREF(storage_V269);\n00471\tPy_XINCREF(storage_V271);\n00472\tPy_XINCREF(storage_V273);\n00473\tPy_XINCREF(storage_V275);\n00474\tPy_XINCREF(storage_V277);\n00475\tPy_XINCREF(storage_V279);\n00476\tPy_XINCREF(storage_V281);\n00477\tPy_XINCREF(storage_V283);\n00478\tPy_XINCREF(storage_V285);\n00479\tPy_XINCREF(storage_V287);\n00480\tPy_XINCREF(storage_V289);\n00481\tPy_XINCREF(storage_V291);\n00482\tPy_XINCREF(storage_V293);\n00483\tPy_XINCREF(storage_V295);\n00484\tPy_XINCREF(storage_V297);\n00485\tPy_XINCREF(storage_V299);\n00486\tPy_XINCREF(storage_V301);\n00487\tPy_XINCREF(storage_V303);\n00488\tPy_XINCREF(storage_V305);\n00489\tPy_XINCREF(storage_V307);\n00490\tPy_XINCREF(storage_V309);\n00491\tPy_XINCREF(storage_V311);\n00492\tPy_XINCREF(storage_V313);\n00493\tPy_XINCREF(storage_V315);\n00494\tPy_XINCREF(storage_V317);\n00495\tPy_XINCREF(storage_V319);\n00496\tPy_XINCREF(storage_V321);\n00497\tPy_XINCREF(storage_V323);\n00498\tPy_XINCREF(storage_V325);\n00499\tPy_XINCREF(storage_V327);\n00500\tPy_XINCREF(storage_V329);\n00501\tPy_XINCREF(storage_V331);\n00502\tPy_XINCREF(storage_V333);\n00503\tPy_XINCREF(storage_V335);\n00504\tPy_XINCREF(storage_V337);\n00505\tPy_XINCREF(storage_V339);\n00506\tPy_XINCREF(storage_V341);\n00507\tPy_XINCREF(storage_V343);\n00508\tPy_XINCREF(storage_V345);\n00509\tPy_XINCREF(storage_V347);\n00510\tPy_XINCREF(storage_V349);\n00511\tPy_XINCREF(storage_V351);\n00512\tPy_XINCREF(storage_V353);\n00513\tPy_XINCREF(storage_V355);\n00514\tPy_XINCREF(storage_V357);\n00515\tPy_XINCREF(storage_V359);\n00516\tPy_XINCREF(storage_V361);\n00517\tPy_XINCREF(storage_V363);\n00518\tPy_XINCREF(storage_V365);\n00519\tPy_XINCREF(storage_V367);\n00520\tPy_XINCREF(storage_V369);\n00521\tPy_XINCREF(storage_V371);\n00522\tPy_XINCREF(storage_V373);\n00523\tPy_XINCREF(storage_V375);\n00524\tPy_XINCREF(storage_V377);\n00525\tPy_XINCREF(storage_V379);\n00526\tPy_XINCREF(storage_V381);\n00527\tPy_XINCREF(storage_V383);\n00528\tPy_XINCREF(storage_V385);\n00529\tPy_XINCREF(storage_V387);\n00530\tPy_XINCREF(storage_V389);\n00531\tPy_XINCREF(storage_V391);\n00532\tPy_XINCREF(storage_V393);\n00533\tPy_XINCREF(storage_V395);\n00534\tPy_XINCREF(storage_V397);\n00535\tPy_XINCREF(storage_V399);\n00536\tPy_XINCREF(storage_V401);\n00537\tPy_XINCREF(storage_V403);\n00538\tPy_XINCREF(storage_V405);\n00539\tPy_XINCREF(storage_V407);\n00540\tPy_XINCREF(storage_V409);\n00541\tPy_XINCREF(storage_V411);\n00542\tPy_XINCREF(storage_V413);\n00543\tPy_XINCREF(storage_V415);\n00544\tPy_XINCREF(storage_V417);\n00545\tPy_XINCREF(storage_V419);\n00546\tPy_XINCREF(storage_V421);\n00547\tPy_XINCREF(storage_V423);\n00548\tPy_XINCREF(storage_V425);\n00549\tPy_XINCREF(storage_V427);\n00550\tPy_XINCREF(storage_V429);\n00551\tPy_XINCREF(storage_V431);\n00552\tPy_XINCREF(storage_V433);\n00553\tPy_XINCREF(storage_V435);\n00554\tPy_XINCREF(storage_V437);\n00555\tPy_XINCREF(storage_V439);\n00556\tPy_XINCREF(storage_V441);\n00557\tPy_XINCREF(storage_V443);\n00558\tPy_XINCREF(storage_V445);\n00559\tPy_XINCREF(storage_V447);\n00560\tPy_XINCREF(storage_V449);\n00561\tPy_XINCREF(storage_V451);\n00562\tPy_XINCREF(storage_V453);\n00563\tPy_XINCREF(storage_V455);\n00564\tPy_XINCREF(storage_V457);\n00565\tPy_XINCREF(storage_V459);\n00566\tPy_XINCREF(storage_V461);\n00567\tPy_XINCREF(storage_V463);\n00568\tPy_XINCREF(storage_V465);\n00569\tPy_XINCREF(storage_V467);\n00570\tPy_XINCREF(storage_V469);\n00571\tPy_XINCREF(storage_V471);\n00572\tPy_XINCREF(storage_V473);\n00573\tPy_XINCREF(storage_V475);\n00574\tPy_XINCREF(storage_V477);\n00575\tPy_XINCREF(storage_V479);\n00576\tPy_XINCREF(storage_V481);\n00577\tPy_XINCREF(storage_V483);\n00578\tPy_XINCREF(storage_V485);\n00579\tPy_XINCREF(storage_V487);\n00580\tPy_XINCREF(storage_V489);\n00581\tPy_XINCREF(storage_V491);\n00582\tPy_XINCREF(storage_V493);\n00583\tPy_XINCREF(storage_V495);\n00584\tPy_XINCREF(storage_V497);\n00585\tPy_XINCREF(storage_V499);\n00586\tPy_XINCREF(storage_V501);\n00587\tPy_XINCREF(storage_V503);\n00588\tPy_XINCREF(storage_V505);\n00589\tPy_XINCREF(storage_V507);\n00590\tPy_XINCREF(storage_V509);\n00591\tPy_XINCREF(storage_V511);\n00592\tPy_XINCREF(storage_V513);\n00593\tPy_XINCREF(storage_V515);\n00594\tPy_XINCREF(storage_V517);\n00595\tPy_XINCREF(storage_V519);\n00596\tPy_XINCREF(storage_V521);\n00597\tPy_XINCREF(storage_V523);\n00598\tPy_XINCREF(storage_V525);\n00599\tPy_XINCREF(storage_V527);\n00600\tPy_XINCREF(storage_V529);\n00601\tPy_XINCREF(storage_V531);\n00602\tPy_XINCREF(storage_V533);\n00603\tPy_XINCREF(storage_V535);\n00604\tPy_XINCREF(storage_V537);\n00605\tPy_XINCREF(storage_V539);\n00606\tPy_XINCREF(storage_V541);\n00607\tPy_XINCREF(storage_V543);\n00608\tPy_XINCREF(storage_V545);\n00609\tPy_XINCREF(storage_V547);\n00610\tPy_XINCREF(storage_V549);\n00611\tPy_XINCREF(storage_V551);\n00612\tPy_XINCREF(storage_V553);\n00613\tPy_XINCREF(storage_V555);\n00614\tPy_XINCREF(storage_V557);\n00615\tPy_XINCREF(storage_V559);\n00616\tPy_XINCREF(storage_V561);\n00617\tPy_XINCREF(storage_V563);\n00618\tPy_XINCREF(storage_V565);\n00619\tPy_XINCREF(storage_V567);\n00620\tPy_XINCREF(storage_V569);\n00621\tPy_XINCREF(storage_V571);\n00622\tPy_XINCREF(storage_V573);\n00623\tPy_XINCREF(storage_V575);\n00624\tPy_XINCREF(storage_V577);\n00625\tPy_XINCREF(storage_V579);\n00626\tPy_XINCREF(storage_V581);\n00627\tPy_XINCREF(storage_V583);\n00628\tPy_XINCREF(storage_V585);\n00629\tPy_XINCREF(storage_V587);\n00630\tPy_XINCREF(storage_V589);\n00631\tPy_XINCREF(storage_V591);\n00632\tPy_XINCREF(storage_V593);\n00633\tPy_XINCREF(storage_V595);\n00634\tPy_XINCREF(storage_V597);\n00635\tPy_XINCREF(storage_V599);\n00636\tPy_XINCREF(storage_V601);\n00637\tPy_XINCREF(storage_V603);\n00638\tPy_XINCREF(storage_V1);\n00639\t            this->storage_V3 = storage_V3;\n00640\tthis->storage_V5 = storage_V5;\n00641\tthis->storage_V7 = storage_V7;\n00642\tthis->storage_V9 = storage_V9;\n00643\tthis->storage_V11 = storage_V11;\n00644\tthis->storage_V13 = storage_V13;\n00645\tthis->storage_V15 = storage_V15;\n00646\tthis->storage_V17 = storage_V17;\n00647\tthis->storage_V19 = storage_V19;\n00648\tthis->storage_V21 = storage_V21;\n00649\tthis->storage_V23 = storage_V23;\n00650\tthis->storage_V25 = storage_V25;\n00651\tthis->storage_V27 = storage_V27;\n00652\tthis->storage_V29 = storage_V29;\n00653\tthis->storage_V31 = storage_V31;\n00654\tthis->storage_V33 = storage_V33;\n00655\tthis->storage_V35 = storage_V35;\n00656\tthis->storage_V37 = storage_V37;\n00657\tthis->storage_V39 = storage_V39;\n00658\tthis->storage_V41 = storage_V41;\n00659\tthis->storage_V43 = storage_V43;\n00660\tthis->storage_V45 = storage_V45;\n00661\tthis->storage_V47 = storage_V47;\n00662\tthis->storage_V49 = storage_V49;\n00663\tthis->storage_V51 = storage_V51;\n00664\tthis->storage_V53 = storage_V53;\n00665\tthis->storage_V55 = storage_V55;\n00666\tthis->storage_V57 = storage_V57;\n00667\tthis->storage_V59 = storage_V59;\n00668\tthis->storage_V61 = storage_V61;\n00669\tthis->storage_V63 = storage_V63;\n00670\tthis->storage_V65 = storage_V65;\n00671\tthis->storage_V67 = storage_V67;\n00672\tthis->storage_V69 = storage_V69;\n00673\tthis->storage_V71 = storage_V71;\n00674\tthis->storage_V73 = storage_V73;\n00675\tthis->storage_V75 = storage_V75;\n00676\tthis->storage_V77 = storage_V77;\n00677\tthis->storage_V79 = storage_V79;\n00678\tthis->storage_V81 = storage_V81;\n00679\tthis->storage_V83 = storage_V83;\n00680\tthis->storage_V85 = storage_V85;\n00681\tthis->storage_V87 = storage_V87;\n00682\tthis->storage_V89 = storage_V89;\n00683\tthis->storage_V91 = storage_V91;\n00684\tthis->storage_V93 = storage_V93;\n00685\tthis->storage_V95 = storage_V95;\n00686\tthis->storage_V97 = storage_V97;\n00687\tthis->storage_V99 = storage_V99;\n00688\tthis->storage_V101 = storage_V101;\n00689\tthis->storage_V103 = storage_V103;\n00690\tthis->storage_V105 = storage_V105;\n00691\tthis->storage_V107 = storage_V107;\n00692\tthis->storage_V109 = storage_V109;\n00693\tthis->storage_V111 = storage_V111;\n00694\tthis->storage_V113 = storage_V113;\n00695\tthis->storage_V115 = storage_V115;\n00696\tthis->storage_V117 = storage_V117;\n00697\tthis->storage_V119 = storage_V119;\n00698\tthis->storage_V121 = storage_V121;\n00699\tthis->storage_V123 = storage_V123;\n00700\tthis->storage_V125 = storage_V125;\n00701\tthis->storage_V127 = storage_V127;\n00702\tthis->storage_V129 = storage_V129;\n00703\tthis->storage_V131 = storage_V131;\n00704\tthis->storage_V133 = storage_V133;\n00705\tthis->storage_V135 = storage_V135;\n00706\tthis->storage_V137 = storage_V137;\n00707\tthis->storage_V139 = storage_V139;\n00708\tthis->storage_V141 = storage_V141;\n00709\tthis->storage_V143 = storage_V143;\n00710\tthis->storage_V145 = storage_V145;\n00711\tthis->storage_V147 = storage_V147;\n00712\tthis->storage_V149 = storage_V149;\n00713\tthis->storage_V151 = storage_V151;\n00714\tthis->storage_V153 = storage_V153;\n00715\tthis->storage_V155 = storage_V155;\n00716\tthis->storage_V157 = storage_V157;\n00717\tthis->storage_V159 = storage_V159;\n00718\tthis->storage_V161 = storage_V161;\n00719\tthis->storage_V163 = storage_V163;\n00720\tthis->storage_V165 = storage_V165;\n00721\tthis->storage_V167 = storage_V167;\n00722\tthis->storage_V169 = storage_V169;\n00723\tthis->storage_V171 = storage_V171;\n00724\tthis->storage_V173 = storage_V173;\n00725\tthis->storage_V175 = storage_V175;\n00726\tthis->storage_V177 = storage_V177;\n00727\tthis->storage_V179 = storage_V179;\n00728\tthis->storage_V181 = storage_V181;\n00729\tthis->storage_V183 = storage_V183;\n00730\tthis->storage_V185 = storage_V185;\n00731\tthis->storage_V187 = storage_V187;\n00732\tthis->storage_V189 = storage_V189;\n00733\tthis->storage_V191 = storage_V191;\n00734\tthis->storage_V193 = storage_V193;\n00735\tthis->storage_V195 = storage_V195;\n00736\tthis->storage_V197 = storage_V197;\n00737\tthis->storage_V199 = storage_V199;\n00738\tthis->storage_V201 = storage_V201;\n00739\tthis->storage_V203 = storage_V203;\n00740\tthis->storage_V205 = storage_V205;\n00741\tthis->storage_V207 = storage_V207;\n00742\tthis->storage_V209 = storage_V209;\n00743\tthis->storage_V211 = storage_V211;\n00744\tthis->storage_V213 = storage_V213;\n00745\tthis->storage_V215 = storage_V215;\n00746\tthis->storage_V217 = storage_V217;\n00747\tthis->storage_V219 = storage_V219;\n00748\tthis->storage_V221 = storage_V221;\n00749\tthis->storage_V223 = storage_V223;\n00750\tthis->storage_V225 = storage_V225;\n00751\tthis->storage_V227 = storage_V227;\n00752\tthis->storage_V229 = storage_V229;\n00753\tthis->storage_V231 = storage_V231;\n00754\tthis->storage_V233 = storage_V233;\n00755\tthis->storage_V235 = storage_V235;\n00756\tthis->storage_V237 = storage_V237;\n00757\tthis->storage_V239 = storage_V239;\n00758\tthis->storage_V241 = storage_V241;\n00759\tthis->storage_V243 = storage_V243;\n00760\tthis->storage_V245 = storage_V245;\n00761\tthis->storage_V247 = storage_V247;\n00762\tthis->storage_V249 = storage_V249;\n00763\tthis->storage_V251 = storage_V251;\n00764\tthis->storage_V253 = storage_V253;\n00765\tthis->storage_V255 = storage_V255;\n00766\tthis->storage_V257 = storage_V257;\n00767\tthis->storage_V259 = storage_V259;\n00768\tthis->storage_V261 = storage_V261;\n00769\tthis->storage_V263 = storage_V263;\n00770\tthis->storage_V265 = storage_V265;\n00771\tthis->storage_V267 = storage_V267;\n00772\tthis->storage_V269 = storage_V269;\n00773\tthis->storage_V271 = storage_V271;\n00774\tthis->storage_V273 = storage_V273;\n00775\tthis->storage_V275 = storage_V275;\n00776\tthis->storage_V277 = storage_V277;\n00777\tthis->storage_V279 = storage_V279;\n00778\tthis->storage_V281 = storage_V281;\n00779\tthis->storage_V283 = storage_V283;\n00780\tthis->storage_V285 = storage_V285;\n00781\tthis->storage_V287 = storage_V287;\n00782\tthis->storage_V289 = storage_V289;\n00783\tthis->storage_V291 = storage_V291;\n00784\tthis->storage_V293 = storage_V293;\n00785\tthis->storage_V295 = storage_V295;\n00786\tthis->storage_V297 = storage_V297;\n00787\tthis->storage_V299 = storage_V299;\n00788\tthis->storage_V301 = storage_V301;\n00789\tthis->storage_V303 = storage_V303;\n00790\tthis->storage_V305 = storage_V305;\n00791\tthis->storage_V307 = storage_V307;\n00792\tthis->storage_V309 = storage_V309;\n00793\tthis->storage_V311 = storage_V311;\n00794\tthis->storage_V313 = storage_V313;\n00795\tthis->storage_V315 = storage_V315;\n00796\tthis->storage_V317 = storage_V317;\n00797\tthis->storage_V319 = storage_V319;\n00798\tthis->storage_V321 = storage_V321;\n00799\tthis->storage_V323 = storage_V323;\n00800\tthis->storage_V325 = storage_V325;\n00801\tthis->storage_V327 = storage_V327;\n00802\tthis->storage_V329 = storage_V329;\n00803\tthis->storage_V331 = storage_V331;\n00804\tthis->storage_V333 = storage_V333;\n00805\tthis->storage_V335 = storage_V335;\n00806\tthis->storage_V337 = storage_V337;\n00807\tthis->storage_V339 = storage_V339;\n00808\tthis->storage_V341 = storage_V341;\n00809\tthis->storage_V343 = storage_V343;\n00810\tthis->storage_V345 = storage_V345;\n00811\tthis->storage_V347 = storage_V347;\n00812\tthis->storage_V349 = storage_V349;\n00813\tthis->storage_V351 = storage_V351;\n00814\tthis->storage_V353 = storage_V353;\n00815\tthis->storage_V355 = storage_V355;\n00816\tthis->storage_V357 = storage_V357;\n00817\tthis->storage_V359 = storage_V359;\n00818\tthis->storage_V361 = storage_V361;\n00819\tthis->storage_V363 = storage_V363;\n00820\tthis->storage_V365 = storage_V365;\n00821\tthis->storage_V367 = storage_V367;\n00822\tthis->storage_V369 = storage_V369;\n00823\tthis->storage_V371 = storage_V371;\n00824\tthis->storage_V373 = storage_V373;\n00825\tthis->storage_V375 = storage_V375;\n00826\tthis->storage_V377 = storage_V377;\n00827\tthis->storage_V379 = storage_V379;\n00828\tthis->storage_V381 = storage_V381;\n00829\tthis->storage_V383 = storage_V383;\n00830\tthis->storage_V385 = storage_V385;\n00831\tthis->storage_V387 = storage_V387;\n00832\tthis->storage_V389 = storage_V389;\n00833\tthis->storage_V391 = storage_V391;\n00834\tthis->storage_V393 = storage_V393;\n00835\tthis->storage_V395 = storage_V395;\n00836\tthis->storage_V397 = storage_V397;\n00837\tthis->storage_V399 = storage_V399;\n00838\tthis->storage_V401 = storage_V401;\n00839\tthis->storage_V403 = storage_V403;\n00840\tthis->storage_V405 = storage_V405;\n00841\tthis->storage_V407 = storage_V407;\n00842\tthis->storage_V409 = storage_V409;\n00843\tthis->storage_V411 = storage_V411;\n00844\tthis->storage_V413 = storage_V413;\n00845\tthis->storage_V415 = storage_V415;\n00846\tthis->storage_V417 = storage_V417;\n00847\tthis->storage_V419 = storage_V419;\n00848\tthis->storage_V421 = storage_V421;\n00849\tthis->storage_V423 = storage_V423;\n00850\tthis->storage_V425 = storage_V425;\n00851\tthis->storage_V427 = storage_V427;\n00852\tthis->storage_V429 = storage_V429;\n00853\tthis->storage_V431 = storage_V431;\n00854\tthis->storage_V433 = storage_V433;\n00855\tthis->storage_V435 = storage_V435;\n00856\tthis->storage_V437 = storage_V437;\n00857\tthis->storage_V439 = storage_V439;\n00858\tthis->storage_V441 = storage_V441;\n00859\tthis->storage_V443 = storage_V443;\n00860\tthis->storage_V445 = storage_V445;\n00861\tthis->storage_V447 = storage_V447;\n00862\tthis->storage_V449 = storage_V449;\n00863\tthis->storage_V451 = storage_V451;\n00864\tthis->storage_V453 = storage_V453;\n00865\tthis->storage_V455 = storage_V455;\n00866\tthis->storage_V457 = storage_V457;\n00867\tthis->storage_V459 = storage_V459;\n00868\tthis->storage_V461 = storage_V461;\n00869\tthis->storage_V463 = storage_V463;\n00870\tthis->storage_V465 = storage_V465;\n00871\tthis->storage_V467 = storage_V467;\n00872\tthis->storage_V469 = storage_V469;\n00873\tthis->storage_V471 = storage_V471;\n00874\tthis->storage_V473 = storage_V473;\n00875\tthis->storage_V475 = storage_V475;\n00876\tthis->storage_V477 = storage_V477;\n00877\tthis->storage_V479 = storage_V479;\n00878\tthis->storage_V481 = storage_V481;\n00879\tthis->storage_V483 = storage_V483;\n00880\tthis->storage_V485 = storage_V485;\n00881\tthis->storage_V487 = storage_V487;\n00882\tthis->storage_V489 = storage_V489;\n00883\tthis->storage_V491 = storage_V491;\n00884\tthis->storage_V493 = storage_V493;\n00885\tthis->storage_V495 = storage_V495;\n00886\tthis->storage_V497 = storage_V497;\n00887\tthis->storage_V499 = storage_V499;\n00888\tthis->storage_V501 = storage_V501;\n00889\tthis->storage_V503 = storage_V503;\n00890\tthis->storage_V505 = storage_V505;\n00891\tthis->storage_V507 = storage_V507;\n00892\tthis->storage_V509 = storage_V509;\n00893\tthis->storage_V511 = storage_V511;\n00894\tthis->storage_V513 = storage_V513;\n00895\tthis->storage_V515 = storage_V515;\n00896\tthis->storage_V517 = storage_V517;\n00897\tthis->storage_V519 = storage_V519;\n00898\tthis->storage_V521 = storage_V521;\n00899\tthis->storage_V523 = storage_V523;\n00900\tthis->storage_V525 = storage_V525;\n00901\tthis->storage_V527 = storage_V527;\n00902\tthis->storage_V529 = storage_V529;\n00903\tthis->storage_V531 = storage_V531;\n00904\tthis->storage_V533 = storage_V533;\n00905\tthis->storage_V535 = storage_V535;\n00906\tthis->storage_V537 = storage_V537;\n00907\tthis->storage_V539 = storage_V539;\n00908\tthis->storage_V541 = storage_V541;\n00909\tthis->storage_V543 = storage_V543;\n00910\tthis->storage_V545 = storage_V545;\n00911\tthis->storage_V547 = storage_V547;\n00912\tthis->storage_V549 = storage_V549;\n00913\tthis->storage_V551 = storage_V551;\n00914\tthis->storage_V553 = storage_V553;\n00915\tthis->storage_V555 = storage_V555;\n00916\tthis->storage_V557 = storage_V557;\n00917\tthis->storage_V559 = storage_V559;\n00918\tthis->storage_V561 = storage_V561;\n00919\tthis->storage_V563 = storage_V563;\n00920\tthis->storage_V565 = storage_V565;\n00921\tthis->storage_V567 = storage_V567;\n00922\tthis->storage_V569 = storage_V569;\n00923\tthis->storage_V571 = storage_V571;\n00924\tthis->storage_V573 = storage_V573;\n00925\tthis->storage_V575 = storage_V575;\n00926\tthis->storage_V577 = storage_V577;\n00927\tthis->storage_V579 = storage_V579;\n00928\tthis->storage_V581 = storage_V581;\n00929\tthis->storage_V583 = storage_V583;\n00930\tthis->storage_V585 = storage_V585;\n00931\tthis->storage_V587 = storage_V587;\n00932\tthis->storage_V589 = storage_V589;\n00933\tthis->storage_V591 = storage_V591;\n00934\tthis->storage_V593 = storage_V593;\n00935\tthis->storage_V595 = storage_V595;\n00936\tthis->storage_V597 = storage_V597;\n00937\tthis->storage_V599 = storage_V599;\n00938\tthis->storage_V601 = storage_V601;\n00939\tthis->storage_V603 = storage_V603;\n00940\tthis->storage_V1 = storage_V1;\n00941\t            \n00942\t\n00943\t\n00944\t\n00945\t\n00946\t\n00947\t\n00948\t\n00949\t\n00950\t\n00951\t\n00952\t\n00953\t\n00954\t\n00955\t\n00956\t\n00957\t\n00958\t\n00959\t\n00960\t\n00961\t\n00962\t\n00963\t\n00964\t\n00965\t\n00966\t\n00967\t\n00968\t\n00969\t\n00970\t\n00971\t\n00972\t\n00973\t\n00974\t\n00975\t\n00976\t\n00977\t\n00978\t\n00979\t\n00980\t\n00981\t\n00982\t\n00983\t\n00984\t\n00985\t\n00986\t\n00987\t\n00988\t\n00989\t\n00990\t\n00991\t\n00992\t\n00993\t\n00994\t\n00995\t\n00996\t\n00997\t\n00998\t\n00999\t\n01000\t\n01001\t\n01002\t\n01003\t\n01004\t\n01005\t\n01006\t\n01007\t\n01008\t\n01009\t\n01010\t\n01011\t\n01012\t\n01013\t\n01014\t\n01015\t\n01016\t\n01017\t\n01018\t\n01019\t\n01020\t\n01021\t\n01022\t\n01023\t\n01024\t\n01025\t\n01026\t\n01027\t\n01028\t\n01029\t\n01030\t\n01031\t\n01032\t\n01033\t\n01034\t\n01035\t\n01036\t\n01037\t\n01038\t\n01039\t\n01040\t\n01041\t\n01042\t\n01043\t\n01044\t\n01045\t\n01046\t\n01047\t\n01048\t\n01049\t\n01050\t\n01051\t\n01052\t\n01053\t\n01054\t\n01055\t\n01056\t\n01057\t\n01058\t\n01059\t\n01060\t\n01061\t\n01062\t\n01063\t\n01064\t\n01065\t\n01066\t\n01067\t\n01068\t\n01069\t\n01070\t\n01071\t\n01072\t\n01073\t\n01074\t\n01075\t\n01076\t\n01077\t\n01078\t\n01079\t\n01080\t\n01081\t\n01082\t\n01083\t\n01084\t\n01085\t\n01086\t\n01087\t\n01088\t\n01089\t\n01090\t\n01091\t\n01092\t\n01093\t\n01094\t\n01095\t\n01096\t\n01097\t\n01098\t\n01099\t\n01100\t\n01101\t\n01102\t\n01103\t\n01104\t\n01105\t\n01106\t\n01107\t\n01108\t\n01109\t\n01110\t\n01111\t\n01112\t\n01113\t\n01114\t\n01115\t\n01116\t\n01117\t\n01118\t\n01119\t\n01120\t\n01121\t\n01122\t\n01123\t\n01124\t\n01125\t\n01126\t\n01127\t\n01128\t\n01129\t\n01130\t\n01131\t\n01132\t\n01133\t\n01134\t\n01135\t\n01136\t\n01137\t\n01138\t\n01139\t\n01140\t\n01141\t\n01142\t\n01143\t\n01144\t\n01145\t\n01146\t\n01147\t\n01148\t\n01149\t\n01150\t\n01151\t\n01152\t\n01153\t\n01154\t\n01155\t\n01156\t\n01157\t\n01158\t\n01159\t\n01160\t\n01161\t\n01162\t\n01163\t\n01164\t\n01165\t\n01166\t\n01167\t\n01168\t\n01169\t\n01170\t\n01171\t\n01172\t\n01173\t\n01174\t\n01175\t\n01176\t\n01177\t\n01178\t\n01179\t\n01180\t\n01181\t\n01182\t\n01183\t\n01184\t\n01185\t\n01186\t\n01187\t\n01188\t\n01189\t\n01190\t\n01191\t\n01192\t\n01193\t\n01194\t\n01195\t\n01196\t\n01197\t\n01198\t\n01199\t\n01200\t\n01201\t\n01202\t\n01203\t\n01204\t\n01205\t\n01206\t\n01207\t\n01208\t\n01209\t\n01210\t\n01211\t\n01212\t\n01213\t\n01214\t\n01215\t\n01216\t\n01217\t\n01218\t\n01219\t\n01220\t\n01221\t\n01222\t\n01223\t\n01224\t\n01225\t\n01226\t\n01227\t\n01228\t\n01229\t\n01230\t\n01231\t\n01232\t\n01233\t\n01234\t\n01235\t\n01236\t\n01237\t\n01238\t\n01239\t\n01240\t\n01241\t\n01242\t\n01243\t\n01244\t\n01245\t            this->__ERROR = __ERROR;\n01246\t            return 0;\n01247\t        }\n01248\t        void cleanup(void) {\n01249\t            __label_1:\n01250\t\n01251\tdouble __DUMMY_1;\n01252\t__label_3:\n01253\t\n01254\tdouble __DUMMY_3;\n01255\t__label_5:\n01256\t\n01257\tdouble __DUMMY_5;\n01258\t__label_7:\n01259\t\n01260\tdouble __DUMMY_7;\n01261\t__label_9:\n01262\t\n01263\tdouble __DUMMY_9;\n01264\t__label_11:\n01265\t\n01266\tdouble __DUMMY_11;\n01267\t__label_13:\n01268\t\n01269\tdouble __DUMMY_13;\n01270\t__label_15:\n01271\t\n01272\tdouble __DUMMY_15;\n01273\t__label_17:\n01274\t\n01275\tdouble __DUMMY_17;\n01276\t__label_19:\n01277\t\n01278\tdouble __DUMMY_19;\n01279\t__label_21:\n01280\t\n01281\tdouble __DUMMY_21;\n01282\t__label_23:\n01283\t\n01284\tdouble __DUMMY_23;\n01285\t__label_25:\n01286\t\n01287\tdouble __DUMMY_25;\n01288\t__label_27:\n01289\t\n01290\tdouble __DUMMY_27;\n01291\t__label_29:\n01292\t\n01293\tdouble __DUMMY_29;\n01294\t__label_31:\n01295\t\n01296\tdouble __DUMMY_31;\n01297\t__label_33:\n01298\t\n01299\tdouble __DUMMY_33;\n01300\t__label_35:\n01301\t\n01302\tdouble __DUMMY_35;\n01303\t__label_37:\n01304\t\n01305\tdouble __DUMMY_37;\n01306\t__label_39:\n01307\t\n01308\tdouble __DUMMY_39;\n01309\t__label_41:\n01310\t\n01311\tdouble __DUMMY_41;\n01312\t__label_43:\n01313\t\n01314\tdouble __DUMMY_43;\n01315\t__label_45:\n01316\t\n01317\tdouble __DUMMY_45;\n01318\t__label_47:\n01319\t\n01320\tdouble __DUMMY_47;\n01321\t__label_49:\n01322\t\n01323\tdouble __DUMMY_49;\n01324\t__label_51:\n01325\t\n01326\tdouble __DUMMY_51;\n01327\t__label_53:\n01328\t\n01329\tdouble __DUMMY_53;\n01330\t__label_55:\n01331\t\n01332\tdouble __DUMMY_55;\n01333\t__label_57:\n01334\t\n01335\tdouble __DUMMY_57;\n01336\t__label_59:\n01337\t\n01338\tdouble __DUMMY_59;\n01339\t__label_61:\n01340\t\n01341\tdouble __DUMMY_61;\n01342\t__label_63:\n01343\t\n01344\tdouble __DUMMY_63;\n01345\t__label_65:\n01346\t\n01347\tdouble __DUMMY_65;\n01348\t__label_67:\n01349\t\n01350\tdouble __DUMMY_67;\n01351\t__label_69:\n01352\t\n01353\tdouble __DUMMY_69;\n01354\t__label_71:\n01355\t\n01356\tdouble __DUMMY_71;\n01357\t__label_73:\n01358\t\n01359\tdouble __DUMMY_73;\n01360\t__label_75:\n01361\t\n01362\tdouble __DUMMY_75;\n01363\t__label_77:\n01364\t\n01365\tdouble __DUMMY_77;\n01366\t__label_79:\n01367\t\n01368\tdouble __DUMMY_79;\n01369\t__label_81:\n01370\t\n01371\tdouble __DUMMY_81;\n01372\t__label_83:\n01373\t\n01374\tdouble __DUMMY_83;\n01375\t__label_85:\n01376\t\n01377\tdouble __DUMMY_85;\n01378\t__label_87:\n01379\t\n01380\tdouble __DUMMY_87;\n01381\t__label_89:\n01382\t\n01383\tdouble __DUMMY_89;\n01384\t__label_91:\n01385\t\n01386\tdouble __DUMMY_91;\n01387\t__label_93:\n01388\t\n01389\tdouble __DUMMY_93;\n01390\t__label_95:\n01391\t\n01392\tdouble __DUMMY_95;\n01393\t__label_97:\n01394\t\n01395\tdouble __DUMMY_97;\n01396\t__label_99:\n01397\t\n01398\tdouble __DUMMY_99;\n01399\t__label_101:\n01400\t\n01401\tdouble __DUMMY_101;\n01402\t__label_103:\n01403\t\n01404\tdouble __DUMMY_103;\n01405\t__label_105:\n01406\t\n01407\tdouble __DUMMY_105;\n01408\t__label_107:\n01409\t\n01410\tdouble __DUMMY_107;\n01411\t__label_109:\n01412\t\n01413\tdouble __DUMMY_109;\n01414\t__label_111:\n01415\t\n01416\tdouble __DUMMY_111;\n01417\t__label_113:\n01418\t\n01419\tdouble __DUMMY_113;\n01420\t__label_115:\n01421\t\n01422\tdouble __DUMMY_115;\n01423\t__label_117:\n01424\t\n01425\tdouble __DUMMY_117;\n01426\t__label_119:\n01427\t\n01428\tdouble __DUMMY_119;\n01429\t__label_121:\n01430\t\n01431\tdouble __DUMMY_121;\n01432\t__label_123:\n01433\t\n01434\tdouble __DUMMY_123;\n01435\t__label_125:\n01436\t\n01437\tdouble __DUMMY_125;\n01438\t__label_127:\n01439\t\n01440\tdouble __DUMMY_127;\n01441\t__label_129:\n01442\t\n01443\tdouble __DUMMY_129;\n01444\t__label_131:\n01445\t\n01446\tdouble __DUMMY_131;\n01447\t__label_133:\n01448\t\n01449\tdouble __DUMMY_133;\n01450\t__label_135:\n01451\t\n01452\tdouble __DUMMY_135;\n01453\t__label_137:\n01454\t\n01455\tdouble __DUMMY_137;\n01456\t__label_139:\n01457\t\n01458\tdouble __DUMMY_139;\n01459\t__label_141:\n01460\t\n01461\tdouble __DUMMY_141;\n01462\t__label_143:\n01463\t\n01464\tdouble __DUMMY_143;\n01465\t__label_145:\n01466\t\n01467\tdouble __DUMMY_145;\n01468\t__label_147:\n01469\t\n01470\tdouble __DUMMY_147;\n01471\t__label_149:\n01472\t\n01473\tdouble __DUMMY_149;\n01474\t__label_151:\n01475\t\n01476\tdouble __DUMMY_151;\n01477\t__label_153:\n01478\t\n01479\tdouble __DUMMY_153;\n01480\t__label_155:\n01481\t\n01482\tdouble __DUMMY_155;\n01483\t__label_157:\n01484\t\n01485\tdouble __DUMMY_157;\n01486\t__label_159:\n01487\t\n01488\tdouble __DUMMY_159;\n01489\t__label_161:\n01490\t\n01491\tdouble __DUMMY_161;\n01492\t__label_163:\n01493\t\n01494\tdouble __DUMMY_163;\n01495\t__label_165:\n01496\t\n01497\tdouble __DUMMY_165;\n01498\t__label_167:\n01499\t\n01500\tdouble __DUMMY_167;\n01501\t__label_169:\n01502\t\n01503\tdouble __DUMMY_169;\n01504\t__label_171:\n01505\t\n01506\tdouble __DUMMY_171;\n01507\t__label_173:\n01508\t\n01509\tdouble __DUMMY_173;\n01510\t__label_175:\n01511\t\n01512\tdouble __DUMMY_175;\n01513\t__label_177:\n01514\t\n01515\tdouble __DUMMY_177;\n01516\t__label_179:\n01517\t\n01518\tdouble __DUMMY_179;\n01519\t__label_181:\n01520\t\n01521\tdouble __DUMMY_181;\n01522\t__label_183:\n01523\t\n01524\tdouble __DUMMY_183;\n01525\t__label_185:\n01526\t\n01527\tdouble __DUMMY_185;\n01528\t__label_187:\n01529\t\n01530\tdouble __DUMMY_187;\n01531\t__label_189:\n01532\t\n01533\tdouble __DUMMY_189;\n01534\t__label_191:\n01535\t\n01536\tdouble __DUMMY_191;\n01537\t__label_193:\n01538\t\n01539\tdouble __DUMMY_193;\n01540\t__label_195:\n01541\t\n01542\tdouble __DUMMY_195;\n01543\t__label_197:\n01544\t\n01545\tdouble __DUMMY_197;\n01546\t__label_199:\n01547\t\n01548\tdouble __DUMMY_199;\n01549\t__label_201:\n01550\t\n01551\tdouble __DUMMY_201;\n01552\t__label_203:\n01553\t\n01554\tdouble __DUMMY_203;\n01555\t__label_205:\n01556\t\n01557\tdouble __DUMMY_205;\n01558\t__label_207:\n01559\t\n01560\tdouble __DUMMY_207;\n01561\t__label_209:\n01562\t\n01563\tdouble __DUMMY_209;\n01564\t__label_211:\n01565\t\n01566\tdouble __DUMMY_211;\n01567\t__label_213:\n01568\t\n01569\tdouble __DUMMY_213;\n01570\t__label_215:\n01571\t\n01572\tdouble __DUMMY_215;\n01573\t__label_217:\n01574\t\n01575\tdouble __DUMMY_217;\n01576\t__label_219:\n01577\t\n01578\tdouble __DUMMY_219;\n01579\t__label_221:\n01580\t\n01581\tdouble __DUMMY_221;\n01582\t__label_223:\n01583\t\n01584\tdouble __DUMMY_223;\n01585\t__label_225:\n01586\t\n01587\tdouble __DUMMY_225;\n01588\t__label_227:\n01589\t\n01590\tdouble __DUMMY_227;\n01591\t__label_229:\n01592\t\n01593\tdouble __DUMMY_229;\n01594\t__label_231:\n01595\t\n01596\tdouble __DUMMY_231;\n01597\t__label_233:\n01598\t\n01599\tdouble __DUMMY_233;\n01600\t__label_235:\n01601\t\n01602\tdouble __DUMMY_235;\n01603\t__label_237:\n01604\t\n01605\tdouble __DUMMY_237;\n01606\t__label_239:\n01607\t\n01608\tdouble __DUMMY_239;\n01609\t__label_241:\n01610\t\n01611\tdouble __DUMMY_241;\n01612\t__label_243:\n01613\t\n01614\tdouble __DUMMY_243;\n01615\t__label_245:\n01616\t\n01617\tdouble __DUMMY_245;\n01618\t__label_247:\n01619\t\n01620\tdouble __DUMMY_247;\n01621\t__label_249:\n01622\t\n01623\tdouble __DUMMY_249;\n01624\t__label_251:\n01625\t\n01626\tdouble __DUMMY_251;\n01627\t__label_253:\n01628\t\n01629\tdouble __DUMMY_253;\n01630\t__label_255:\n01631\t\n01632\tdouble __DUMMY_255;\n01633\t__label_257:\n01634\t\n01635\tdouble __DUMMY_257;\n01636\t__label_259:\n01637\t\n01638\tdouble __DUMMY_259;\n01639\t__label_261:\n01640\t\n01641\tdouble __DUMMY_261;\n01642\t__label_263:\n01643\t\n01644\tdouble __DUMMY_263;\n01645\t__label_265:\n01646\t\n01647\tdouble __DUMMY_265;\n01648\t__label_267:\n01649\t\n01650\tdouble __DUMMY_267;\n01651\t__label_269:\n01652\t\n01653\tdouble __DUMMY_269;\n01654\t__label_271:\n01655\t\n01656\tdouble __DUMMY_271;\n01657\t__label_273:\n01658\t\n01659\tdouble __DUMMY_273;\n01660\t__label_275:\n01661\t\n01662\tdouble __DUMMY_275;\n01663\t__label_277:\n01664\t\n01665\tdouble __DUMMY_277;\n01666\t__label_279:\n01667\t\n01668\tdouble __DUMMY_279;\n01669\t__label_281:\n01670\t\n01671\tdouble __DUMMY_281;\n01672\t__label_283:\n01673\t\n01674\tdouble __DUMMY_283;\n01675\t__label_285:\n01676\t\n01677\tdouble __DUMMY_285;\n01678\t__label_287:\n01679\t\n01680\tdouble __DUMMY_287;\n01681\t__label_289:\n01682\t\n01683\tdouble __DUMMY_289;\n01684\t__label_291:\n01685\t\n01686\tdouble __DUMMY_291;\n01687\t__label_293:\n01688\t\n01689\tdouble __DUMMY_293;\n01690\t__label_295:\n01691\t\n01692\tdouble __DUMMY_295;\n01693\t__label_297:\n01694\t\n01695\tdouble __DUMMY_297;\n01696\t__label_299:\n01697\t\n01698\tdouble __DUMMY_299;\n01699\t__label_301:\n01700\t\n01701\tdouble __DUMMY_301;\n01702\t__label_303:\n01703\t\n01704\tdouble __DUMMY_303;\n01705\t__label_305:\n01706\t\n01707\tdouble __DUMMY_305;\n01708\t__label_307:\n01709\t\n01710\tdouble __DUMMY_307;\n01711\t__label_309:\n01712\t\n01713\tdouble __DUMMY_309;\n01714\t__label_311:\n01715\t\n01716\tdouble __DUMMY_311;\n01717\t__label_313:\n01718\t\n01719\tdouble __DUMMY_313;\n01720\t__label_315:\n01721\t\n01722\tdouble __DUMMY_315;\n01723\t__label_317:\n01724\t\n01725\tdouble __DUMMY_317;\n01726\t__label_319:\n01727\t\n01728\tdouble __DUMMY_319;\n01729\t__label_321:\n01730\t\n01731\tdouble __DUMMY_321;\n01732\t__label_323:\n01733\t\n01734\tdouble __DUMMY_323;\n01735\t__label_325:\n01736\t\n01737\tdouble __DUMMY_325;\n01738\t__label_327:\n01739\t\n01740\tdouble __DUMMY_327;\n01741\t__label_329:\n01742\t\n01743\tdouble __DUMMY_329;\n01744\t__label_331:\n01745\t\n01746\tdouble __DUMMY_331;\n01747\t__label_333:\n01748\t\n01749\tdouble __DUMMY_333;\n01750\t__label_335:\n01751\t\n01752\tdouble __DUMMY_335;\n01753\t__label_337:\n01754\t\n01755\tdouble __DUMMY_337;\n01756\t__label_339:\n01757\t\n01758\tdouble __DUMMY_339;\n01759\t__label_341:\n01760\t\n01761\tdouble __DUMMY_341;\n01762\t__label_343:\n01763\t\n01764\tdouble __DUMMY_343;\n01765\t__label_345:\n01766\t\n01767\tdouble __DUMMY_345;\n01768\t__label_347:\n01769\t\n01770\tdouble __DUMMY_347;\n01771\t__label_349:\n01772\t\n01773\tdouble __DUMMY_349;\n01774\t__label_351:\n01775\t\n01776\tdouble __DUMMY_351;\n01777\t__label_353:\n01778\t\n01779\tdouble __DUMMY_353;\n01780\t__label_355:\n01781\t\n01782\tdouble __DUMMY_355;\n01783\t__label_357:\n01784\t\n01785\tdouble __DUMMY_357;\n01786\t__label_359:\n01787\t\n01788\tdouble __DUMMY_359;\n01789\t__label_361:\n01790\t\n01791\tdouble __DUMMY_361;\n01792\t__label_363:\n01793\t\n01794\tdouble __DUMMY_363;\n01795\t__label_365:\n01796\t\n01797\tdouble __DUMMY_365;\n01798\t__label_367:\n01799\t\n01800\tdouble __DUMMY_367;\n01801\t__label_369:\n01802\t\n01803\tdouble __DUMMY_369;\n01804\t__label_371:\n01805\t\n01806\tdouble __DUMMY_371;\n01807\t__label_373:\n01808\t\n01809\tdouble __DUMMY_373;\n01810\t__label_375:\n01811\t\n01812\tdouble __DUMMY_375;\n01813\t__label_377:\n01814\t\n01815\tdouble __DUMMY_377;\n01816\t__label_379:\n01817\t\n01818\tdouble __DUMMY_379;\n01819\t__label_381:\n01820\t\n01821\tdouble __DUMMY_381;\n01822\t__label_383:\n01823\t\n01824\tdouble __DUMMY_383;\n01825\t__label_385:\n01826\t\n01827\tdouble __DUMMY_385;\n01828\t__label_387:\n01829\t\n01830\tdouble __DUMMY_387;\n01831\t__label_389:\n01832\t\n01833\tdouble __DUMMY_389;\n01834\t__label_391:\n01835\t\n01836\tdouble __DUMMY_391;\n01837\t__label_393:\n01838\t\n01839\tdouble __DUMMY_393;\n01840\t__label_395:\n01841\t\n01842\tdouble __DUMMY_395;\n01843\t__label_397:\n01844\t\n01845\tdouble __DUMMY_397;\n01846\t__label_399:\n01847\t\n01848\tdouble __DUMMY_399;\n01849\t__label_401:\n01850\t\n01851\tdouble __DUMMY_401;\n01852\t__label_403:\n01853\t\n01854\tdouble __DUMMY_403;\n01855\t__label_405:\n01856\t\n01857\tdouble __DUMMY_405;\n01858\t__label_407:\n01859\t\n01860\tdouble __DUMMY_407;\n01861\t__label_409:\n01862\t\n01863\tdouble __DUMMY_409;\n01864\t__label_411:\n01865\t\n01866\tdouble __DUMMY_411;\n01867\t__label_413:\n01868\t\n01869\tdouble __DUMMY_413;\n01870\t__label_415:\n01871\t\n01872\tdouble __DUMMY_415;\n01873\t__label_417:\n01874\t\n01875\tdouble __DUMMY_417;\n01876\t__label_419:\n01877\t\n01878\tdouble __DUMMY_419;\n01879\t__label_421:\n01880\t\n01881\tdouble __DUMMY_421;\n01882\t__label_423:\n01883\t\n01884\tdouble __DUMMY_423;\n01885\t__label_425:\n01886\t\n01887\tdouble __DUMMY_425;\n01888\t__label_427:\n01889\t\n01890\tdouble __DUMMY_427;\n01891\t__label_429:\n01892\t\n01893\tdouble __DUMMY_429;\n01894\t__label_431:\n01895\t\n01896\tdouble __DUMMY_431;\n01897\t__label_433:\n01898\t\n01899\tdouble __DUMMY_433;\n01900\t__label_435:\n01901\t\n01902\tdouble __DUMMY_435;\n01903\t__label_437:\n01904\t\n01905\tdouble __DUMMY_437;\n01906\t__label_439:\n01907\t\n01908\tdouble __DUMMY_439;\n01909\t__label_441:\n01910\t\n01911\tdouble __DUMMY_441;\n01912\t__label_443:\n01913\t\n01914\tdouble __DUMMY_443;\n01915\t__label_445:\n01916\t\n01917\tdouble __DUMMY_445;\n01918\t__label_447:\n01919\t\n01920\tdouble __DUMMY_447;\n01921\t__label_449:\n01922\t\n01923\tdouble __DUMMY_449;\n01924\t__label_451:\n01925\t\n01926\tdouble __DUMMY_451;\n01927\t__label_453:\n01928\t\n01929\tdouble __DUMMY_453;\n01930\t__label_455:\n01931\t\n01932\tdouble __DUMMY_455;\n01933\t__label_457:\n01934\t\n01935\tdouble __DUMMY_457;\n01936\t__label_459:\n01937\t\n01938\tdouble __DUMMY_459;\n01939\t__label_461:\n01940\t\n01941\tdouble __DUMMY_461;\n01942\t__label_463:\n01943\t\n01944\tdouble __DUMMY_463;\n01945\t__label_465:\n01946\t\n01947\tdouble __DUMMY_465;\n01948\t__label_467:\n01949\t\n01950\tdouble __DUMMY_467;\n01951\t__label_469:\n01952\t\n01953\tdouble __DUMMY_469;\n01954\t__label_471:\n01955\t\n01956\tdouble __DUMMY_471;\n01957\t__label_473:\n01958\t\n01959\tdouble __DUMMY_473;\n01960\t__label_475:\n01961\t\n01962\tdouble __DUMMY_475;\n01963\t__label_477:\n01964\t\n01965\tdouble __DUMMY_477;\n01966\t__label_479:\n01967\t\n01968\tdouble __DUMMY_479;\n01969\t__label_481:\n01970\t\n01971\tdouble __DUMMY_481;\n01972\t__label_483:\n01973\t\n01974\tdouble __DUMMY_483;\n01975\t__label_485:\n01976\t\n01977\tdouble __DUMMY_485;\n01978\t__label_487:\n01979\t\n01980\tdouble __DUMMY_487;\n01981\t__label_489:\n01982\t\n01983\tdouble __DUMMY_489;\n01984\t__label_491:\n01985\t\n01986\tdouble __DUMMY_491;\n01987\t__label_493:\n01988\t\n01989\tdouble __DUMMY_493;\n01990\t__label_495:\n01991\t\n01992\tdouble __DUMMY_495;\n01993\t__label_497:\n01994\t\n01995\tdouble __DUMMY_497;\n01996\t__label_499:\n01997\t\n01998\tdouble __DUMMY_499;\n01999\t__label_501:\n02000\t\n02001\tdouble __DUMMY_501;\n02002\t__label_503:\n02003\t\n02004\tdouble __DUMMY_503;\n02005\t__label_505:\n02006\t\n02007\tdouble __DUMMY_505;\n02008\t__label_507:\n02009\t\n02010\tdouble __DUMMY_507;\n02011\t__label_509:\n02012\t\n02013\tdouble __DUMMY_509;\n02014\t__label_511:\n02015\t\n02016\tdouble __DUMMY_511;\n02017\t__label_513:\n02018\t\n02019\tdouble __DUMMY_513;\n02020\t__label_515:\n02021\t\n02022\tdouble __DUMMY_515;\n02023\t__label_517:\n02024\t\n02025\tdouble __DUMMY_517;\n02026\t__label_519:\n02027\t\n02028\tdouble __DUMMY_519;\n02029\t__label_521:\n02030\t\n02031\tdouble __DUMMY_521;\n02032\t__label_523:\n02033\t\n02034\tdouble __DUMMY_523;\n02035\t__label_525:\n02036\t\n02037\tdouble __DUMMY_525;\n02038\t__label_527:\n02039\t\n02040\tdouble __DUMMY_527;\n02041\t__label_529:\n02042\t\n02043\tdouble __DUMMY_529;\n02044\t__label_531:\n02045\t\n02046\tdouble __DUMMY_531;\n02047\t__label_533:\n02048\t\n02049\tdouble __DUMMY_533;\n02050\t__label_535:\n02051\t\n02052\tdouble __DUMMY_535;\n02053\t__label_537:\n02054\t\n02055\tdouble __DUMMY_537;\n02056\t__label_539:\n02057\t\n02058\tdouble __DUMMY_539;\n02059\t__label_541:\n02060\t\n02061\tdouble __DUMMY_541;\n02062\t__label_543:\n02063\t\n02064\tdouble __DUMMY_543;\n02065\t__label_545:\n02066\t\n02067\tdouble __DUMMY_545;\n02068\t__label_547:\n02069\t\n02070\tdouble __DUMMY_547;\n02071\t__label_549:\n02072\t\n02073\tdouble __DUMMY_549;\n02074\t__label_551:\n02075\t\n02076\tdouble __DUMMY_551;\n02077\t__label_553:\n02078\t\n02079\tdouble __DUMMY_553;\n02080\t__label_555:\n02081\t\n02082\tdouble __DUMMY_555;\n02083\t__label_557:\n02084\t\n02085\tdouble __DUMMY_557;\n02086\t__label_559:\n02087\t\n02088\tdouble __DUMMY_559;\n02089\t__label_561:\n02090\t\n02091\tdouble __DUMMY_561;\n02092\t__label_563:\n02093\t\n02094\tdouble __DUMMY_563;\n02095\t__label_565:\n02096\t\n02097\tdouble __DUMMY_565;\n02098\t__label_567:\n02099\t\n02100\tdouble __DUMMY_567;\n02101\t__label_569:\n02102\t\n02103\tdouble __DUMMY_569;\n02104\t__label_571:\n02105\t\n02106\tdouble __DUMMY_571;\n02107\t__label_573:\n02108\t\n02109\tdouble __DUMMY_573;\n02110\t__label_575:\n02111\t\n02112\tdouble __DUMMY_575;\n02113\t__label_577:\n02114\t\n02115\tdouble __DUMMY_577;\n02116\t__label_579:\n02117\t\n02118\tdouble __DUMMY_579;\n02119\t__label_581:\n02120\t\n02121\tdouble __DUMMY_581;\n02122\t__label_583:\n02123\t\n02124\tdouble __DUMMY_583;\n02125\t__label_585:\n02126\t\n02127\tdouble __DUMMY_585;\n02128\t__label_587:\n02129\t\n02130\tdouble __DUMMY_587;\n02131\t__label_589:\n02132\t\n02133\tdouble __DUMMY_589;\n02134\t__label_591:\n02135\t\n02136\tdouble __DUMMY_591;\n02137\t__label_593:\n02138\t\n02139\tdouble __DUMMY_593;\n02140\t__label_595:\n02141\t\n02142\tdouble __DUMMY_595;\n02143\t__label_597:\n02144\t\n02145\tdouble __DUMMY_597;\n02146\t__label_599:\n02147\t\n02148\tdouble __DUMMY_599;\n02149\t__label_601:\n02150\t\n02151\tdouble __DUMMY_601;\n02152\t__label_603:\n02153\t\n02154\tdouble __DUMMY_603;\n02155\t__label_606:\n02156\t\n02157\tdouble __DUMMY_606;\n02158\t\n02159\t            Py_XDECREF(this->storage_V3);\n02160\tPy_XDECREF(this->storage_V5);\n02161\tPy_XDECREF(this->storage_V7);\n02162\tPy_XDECREF(this->storage_V9);\n02163\tPy_XDECREF(this->storage_V11);\n02164\tPy_XDECREF(this->storage_V13);\n02165\tPy_XDECREF(this->storage_V15);\n02166\tPy_XDECREF(this->storage_V17);\n02167\tPy_XDECREF(this->storage_V19);\n02168\tPy_XDECREF(this->storage_V21);\n02169\tPy_XDECREF(this->storage_V23);\n02170\tPy_XDECREF(this->storage_V25);\n02171\tPy_XDECREF(this->storage_V27);\n02172\tPy_XDECREF(this->storage_V29);\n02173\tPy_XDECREF(this->storage_V31);\n02174\tPy_XDECREF(this->storage_V33);\n02175\tPy_XDECREF(this->storage_V35);\n02176\tPy_XDECREF(this->storage_V37);\n02177\tPy_XDECREF(this->storage_V39);\n02178\tPy_XDECREF(this->storage_V41);\n02179\tPy_XDECREF(this->storage_V43);\n02180\tPy_XDECREF(this->storage_V45);\n02181\tPy_XDECREF(this->storage_V47);\n02182\tPy_XDECREF(this->storage_V49);\n02183\tPy_XDECREF(this->storage_V51);\n02184\tPy_XDECREF(this->storage_V53);\n02185\tPy_XDECREF(this->storage_V55);\n02186\tPy_XDECREF(this->storage_V57);\n02187\tPy_XDECREF(this->storage_V59);\n02188\tPy_XDECREF(this->storage_V61);\n02189\tPy_XDECREF(this->storage_V63);\n02190\tPy_XDECREF(this->storage_V65);\n02191\tPy_XDECREF(this->storage_V67);\n02192\tPy_XDECREF(this->storage_V69);\n02193\tPy_XDECREF(this->storage_V71);\n02194\tPy_XDECREF(this->storage_V73);\n02195\tPy_XDECREF(this->storage_V75);\n02196\tPy_XDECREF(this->storage_V77);\n02197\tPy_XDECREF(this->storage_V79);\n02198\tPy_XDECREF(this->storage_V81);\n02199\tPy_XDECREF(this->storage_V83);\n02200\tPy_XDECREF(this->storage_V85);\n02201\tPy_XDECREF(this->storage_V87);\n02202\tPy_XDECREF(this->storage_V89);\n02203\tPy_XDECREF(this->storage_V91);\n02204\tPy_XDECREF(this->storage_V93);\n02205\tPy_XDECREF(this->storage_V95);\n02206\tPy_XDECREF(this->storage_V97);\n02207\tPy_XDECREF(this->storage_V99);\n02208\tPy_XDECREF(this->storage_V101);\n02209\tPy_XDECREF(this->storage_V103);\n02210\tPy_XDECREF(this->storage_V105);\n02211\tPy_XDECREF(this->storage_V107);\n02212\tPy_XDECREF(this->storage_V109);\n02213\tPy_XDECREF(this->storage_V111);\n02214\tPy_XDECREF(this->storage_V113);\n02215\tPy_XDECREF(this->storage_V115);\n02216\tPy_XDECREF(this->storage_V117);\n02217\tPy_XDECREF(this->storage_V119);\n02218\tPy_XDECREF(this->storage_V121);\n02219\tPy_XDECREF(this->storage_V123);\n02220\tPy_XDECREF(this->storage_V125);\n02221\tPy_XDECREF(this->storage_V127);\n02222\tPy_XDECREF(this->storage_V129);\n02223\tPy_XDECREF(this->storage_V131);\n02224\tPy_XDECREF(this->storage_V133);\n02225\tPy_XDECREF(this->storage_V135);\n02226\tPy_XDECREF(this->storage_V137);\n02227\tPy_XDECREF(this->storage_V139);\n02228\tPy_XDECREF(this->storage_V141);\n02229\tPy_XDECREF(this->storage_V143);\n02230\tPy_XDECREF(this->storage_V145);\n02231\tPy_XDECREF(this->storage_V147);\n02232\tPy_XDECREF(this->storage_V149);\n02233\tPy_XDECREF(this->storage_V151);\n02234\tPy_XDECREF(this->storage_V153);\n02235\tPy_XDECREF(this->storage_V155);\n02236\tPy_XDECREF(this->storage_V157);\n02237\tPy_XDECREF(this->storage_V159);\n02238\tPy_XDECREF(this->storage_V161);\n02239\tPy_XDECREF(this->storage_V163);\n02240\tPy_XDECREF(this->storage_V165);\n02241\tPy_XDECREF(this->storage_V167);\n02242\tPy_XDECREF(this->storage_V169);\n02243\tPy_XDECREF(this->storage_V171);\n02244\tPy_XDECREF(this->storage_V173);\n02245\tPy_XDECREF(this->storage_V175);\n02246\tPy_XDECREF(this->storage_V177);\n02247\tPy_XDECREF(this->storage_V179);\n02248\tPy_XDECREF(this->storage_V181);\n02249\tPy_XDECREF(this->storage_V183);\n02250\tPy_XDECREF(this->storage_V185);\n02251\tPy_XDECREF(this->storage_V187);\n02252\tPy_XDECREF(this->storage_V189);\n02253\tPy_XDECREF(this->storage_V191);\n02254\tPy_XDECREF(this->storage_V193);\n02255\tPy_XDECREF(this->storage_V195);\n02256\tPy_XDECREF(this->storage_V197);\n02257\tPy_XDECREF(this->storage_V199);\n02258\tPy_XDECREF(this->storage_V201);\n02259\tPy_XDECREF(this->storage_V203);\n02260\tPy_XDECREF(this->storage_V205);\n02261\tPy_XDECREF(this->storage_V207);\n02262\tPy_XDECREF(this->storage_V209);\n02263\tPy_XDECREF(this->storage_V211);\n02264\tPy_XDECREF(this->storage_V213);\n02265\tPy_XDECREF(this->storage_V215);\n02266\tPy_XDECREF(this->storage_V217);\n02267\tPy_XDECREF(this->storage_V219);\n02268\tPy_XDECREF(this->storage_V221);\n02269\tPy_XDECREF(this->storage_V223);\n02270\tPy_XDECREF(this->storage_V225);\n02271\tPy_XDECREF(this->storage_V227);\n02272\tPy_XDECREF(this->storage_V229);\n02273\tPy_XDECREF(this->storage_V231);\n02274\tPy_XDECREF(this->storage_V233);\n02275\tPy_XDECREF(this->storage_V235);\n02276\tPy_XDECREF(this->storage_V237);\n02277\tPy_XDECREF(this->storage_V239);\n02278\tPy_XDECREF(this->storage_V241);\n02279\tPy_XDECREF(this->storage_V243);\n02280\tPy_XDECREF(this->storage_V245);\n02281\tPy_XDECREF(this->storage_V247);\n02282\tPy_XDECREF(this->storage_V249);\n02283\tPy_XDECREF(this->storage_V251);\n02284\tPy_XDECREF(this->storage_V253);\n02285\tPy_XDECREF(this->storage_V255);\n02286\tPy_XDECREF(this->storage_V257);\n02287\tPy_XDECREF(this->storage_V259);\n02288\tPy_XDECREF(this->storage_V261);\n02289\tPy_XDECREF(this->storage_V263);\n02290\tPy_XDECREF(this->storage_V265);\n02291\tPy_XDECREF(this->storage_V267);\n02292\tPy_XDECREF(this->storage_V269);\n02293\tPy_XDECREF(this->storage_V271);\n02294\tPy_XDECREF(this->storage_V273);\n02295\tPy_XDECREF(this->storage_V275);\n02296\tPy_XDECREF(this->storage_V277);\n02297\tPy_XDECREF(this->storage_V279);\n02298\tPy_XDECREF(this->storage_V281);\n02299\tPy_XDECREF(this->storage_V283);\n02300\tPy_XDECREF(this->storage_V285);\n02301\tPy_XDECREF(this->storage_V287);\n02302\tPy_XDECREF(this->storage_V289);\n02303\tPy_XDECREF(this->storage_V291);\n02304\tPy_XDECREF(this->storage_V293);\n02305\tPy_XDECREF(this->storage_V295);\n02306\tPy_XDECREF(this->storage_V297);\n02307\tPy_XDECREF(this->storage_V299);\n02308\tPy_XDECREF(this->storage_V301);\n02309\tPy_XDECREF(this->storage_V303);\n02310\tPy_XDECREF(this->storage_V305);\n02311\tPy_XDECREF(this->storage_V307);\n02312\tPy_XDECREF(this->storage_V309);\n02313\tPy_XDECREF(this->storage_V311);\n02314\tPy_XDECREF(this->storage_V313);\n02315\tPy_XDECREF(this->storage_V315);\n02316\tPy_XDECREF(this->storage_V317);\n02317\tPy_XDECREF(this->storage_V319);\n02318\tPy_XDECREF(this->storage_V321);\n02319\tPy_XDECREF(this->storage_V323);\n02320\tPy_XDECREF(this->storage_V325);\n02321\tPy_XDECREF(this->storage_V327);\n02322\tPy_XDECREF(this->storage_V329);\n02323\tPy_XDECREF(this->storage_V331);\n02324\tPy_XDECREF(this->storage_V333);\n02325\tPy_XDECREF(this->storage_V335);\n02326\tPy_XDECREF(this->storage_V337);\n02327\tPy_XDECREF(this->storage_V339);\n02328\tPy_XDECREF(this->storage_V341);\n02329\tPy_XDECREF(this->storage_V343);\n02330\tPy_XDECREF(this->storage_V345);\n02331\tPy_XDECREF(this->storage_V347);\n02332\tPy_XDECREF(this->storage_V349);\n02333\tPy_XDECREF(this->storage_V351);\n02334\tPy_XDECREF(this->storage_V353);\n02335\tPy_XDECREF(this->storage_V355);\n02336\tPy_XDECREF(this->storage_V357);\n02337\tPy_XDECREF(this->storage_V359);\n02338\tPy_XDECREF(this->storage_V361);\n02339\tPy_XDECREF(this->storage_V363);\n02340\tPy_XDECREF(this->storage_V365);\n02341\tPy_XDECREF(this->storage_V367);\n02342\tPy_XDECREF(this->storage_V369);\n02343\tPy_XDECREF(this->storage_V371);\n02344\tPy_XDECREF(this->storage_V373);\n02345\tPy_XDECREF(this->storage_V375);\n02346\tPy_XDECREF(this->storage_V377);\n02347\tPy_XDECREF(this->storage_V379);\n02348\tPy_XDECREF(this->storage_V381);\n02349\tPy_XDECREF(this->storage_V383);\n02350\tPy_XDECREF(this->storage_V385);\n02351\tPy_XDECREF(this->storage_V387);\n02352\tPy_XDECREF(this->storage_V389);\n02353\tPy_XDECREF(this->storage_V391);\n02354\tPy_XDECREF(this->storage_V393);\n02355\tPy_XDECREF(this->storage_V395);\n02356\tPy_XDECREF(this->storage_V397);\n02357\tPy_XDECREF(this->storage_V399);\n02358\tPy_XDECREF(this->storage_V401);\n02359\tPy_XDECREF(this->storage_V403);\n02360\tPy_XDECREF(this->storage_V405);\n02361\tPy_XDECREF(this->storage_V407);\n02362\tPy_XDECREF(this->storage_V409);\n02363\tPy_XDECREF(this->storage_V411);\n02364\tPy_XDECREF(this->storage_V413);\n02365\tPy_XDECREF(this->storage_V415);\n02366\tPy_XDECREF(this->storage_V417);\n02367\tPy_XDECREF(this->storage_V419);\n02368\tPy_XDECREF(this->storage_V421);\n02369\tPy_XDECREF(this->storage_V423);\n02370\tPy_XDECREF(this->storage_V425);\n02371\tPy_XDECREF(this->storage_V427);\n02372\tPy_XDECREF(this->storage_V429);\n02373\tPy_XDECREF(this->storage_V431);\n02374\tPy_XDECREF(this->storage_V433);\n02375\tPy_XDECREF(this->storage_V435);\n02376\tPy_XDECREF(this->storage_V437);\n02377\tPy_XDECREF(this->storage_V439);\n02378\tPy_XDECREF(this->storage_V441);\n02379\tPy_XDECREF(this->storage_V443);\n02380\tPy_XDECREF(this->storage_V445);\n02381\tPy_XDECREF(this->storage_V447);\n02382\tPy_XDECREF(this->storage_V449);\n02383\tPy_XDECREF(this->storage_V451);\n02384\tPy_XDECREF(this->storage_V453);\n02385\tPy_XDECREF(this->storage_V455);\n02386\tPy_XDECREF(this->storage_V457);\n02387\tPy_XDECREF(this->storage_V459);\n02388\tPy_XDECREF(this->storage_V461);\n02389\tPy_XDECREF(this->storage_V463);\n02390\tPy_XDECREF(this->storage_V465);\n02391\tPy_XDECREF(this->storage_V467);\n02392\tPy_XDECREF(this->storage_V469);\n02393\tPy_XDECREF(this->storage_V471);\n02394\tPy_XDECREF(this->storage_V473);\n02395\tPy_XDECREF(this->storage_V475);\n02396\tPy_XDECREF(this->storage_V477);\n02397\tPy_XDECREF(this->storage_V479);\n02398\tPy_XDECREF(this->storage_V481);\n02399\tPy_XDECREF(this->storage_V483);\n02400\tPy_XDECREF(this->storage_V485);\n02401\tPy_XDECREF(this->storage_V487);\n02402\tPy_XDECREF(this->storage_V489);\n02403\tPy_XDECREF(this->storage_V491);\n02404\tPy_XDECREF(this->storage_V493);\n02405\tPy_XDECREF(this->storage_V495);\n02406\tPy_XDECREF(this->storage_V497);\n02407\tPy_XDECREF(this->storage_V499);\n02408\tPy_XDECREF(this->storage_V501);\n02409\tPy_XDECREF(this->storage_V503);\n02410\tPy_XDECREF(this->storage_V505);\n02411\tPy_XDECREF(this->storage_V507);\n02412\tPy_XDECREF(this->storage_V509);\n02413\tPy_XDECREF(this->storage_V511);\n02414\tPy_XDECREF(this->storage_V513);\n02415\tPy_XDECREF(this->storage_V515);\n02416\tPy_XDECREF(this->storage_V517);\n02417\tPy_XDECREF(this->storage_V519);\n02418\tPy_XDECREF(this->storage_V521);\n02419\tPy_XDECREF(this->storage_V523);\n02420\tPy_XDECREF(this->storage_V525);\n02421\tPy_XDECREF(this->storage_V527);\n02422\tPy_XDECREF(this->storage_V529);\n02423\tPy_XDECREF(this->storage_V531);\n02424\tPy_XDECREF(this->storage_V533);\n02425\tPy_XDECREF(this->storage_V535);\n02426\tPy_XDECREF(this->storage_V537);\n02427\tPy_XDECREF(this->storage_V539);\n02428\tPy_XDECREF(this->storage_V541);\n02429\tPy_XDECREF(this->storage_V543);\n02430\tPy_XDECREF(this->storage_V545);\n02431\tPy_XDECREF(this->storage_V547);\n02432\tPy_XDECREF(this->storage_V549);\n02433\tPy_XDECREF(this->storage_V551);\n02434\tPy_XDECREF(this->storage_V553);\n02435\tPy_XDECREF(this->storage_V555);\n02436\tPy_XDECREF(this->storage_V557);\n02437\tPy_XDECREF(this->storage_V559);\n02438\tPy_XDECREF(this->storage_V561);\n02439\tPy_XDECREF(this->storage_V563);\n02440\tPy_XDECREF(this->storage_V565);\n02441\tPy_XDECREF(this->storage_V567);\n02442\tPy_XDECREF(this->storage_V569);\n02443\tPy_XDECREF(this->storage_V571);\n02444\tPy_XDECREF(this->storage_V573);\n02445\tPy_XDECREF(this->storage_V575);\n02446\tPy_XDECREF(this->storage_V577);\n02447\tPy_XDECREF(this->storage_V579);\n02448\tPy_XDECREF(this->storage_V581);\n02449\tPy_XDECREF(this->storage_V583);\n02450\tPy_XDECREF(this->storage_V585);\n02451\tPy_XDECREF(this->storage_V587);\n02452\tPy_XDECREF(this->storage_V589);\n02453\tPy_XDECREF(this->storage_V591);\n02454\tPy_XDECREF(this->storage_V593);\n02455\tPy_XDECREF(this->storage_V595);\n02456\tPy_XDECREF(this->storage_V597);\n02457\tPy_XDECREF(this->storage_V599);\n02458\tPy_XDECREF(this->storage_V601);\n02459\tPy_XDECREF(this->storage_V603);\n02460\tPy_XDECREF(this->storage_V1);\n02461\t        }\n02462\t        int run(void) {\n02463\t            int __failure = 0;\n02464\t            \n02465\t    PyObject* py_V1;\n02466\t    \n02467\t        PyArrayObject* V1;\n02468\t        \n02469\t            typedef npy_float64 dtype_V1;\n02470\t            \n02471\t    PyObject* py_V3;\n02472\t    \n02473\t        PyArrayObject* V3;\n02474\t        \n02475\t            typedef npy_float64 dtype_V3;\n02476\t            \n02477\t    PyObject* py_V5;\n02478\t    \n02479\t        PyArrayObject* V5;\n02480\t        \n02481\t            typedef npy_float64 dtype_V5;\n02482\t            \n02483\t    PyObject* py_V7;\n02484\t    \n02485\t        PyArrayObject* V7;\n02486\t        \n02487\t            typedef npy_float64 dtype_V7;\n02488\t            \n02489\t    PyObject* py_V9;\n02490\t    \n02491\t        PyArrayObject* V9;\n02492\t        \n02493\t            typedef npy_float64 dtype_V9;\n02494\t            \n02495\t    PyObject* py_V11;\n02496\t    \n02497\t        PyArrayObject* V11;\n02498\t        \n02499\t            typedef npy_float64 dtype_V11;\n02500\t            \n02501\t    PyObject* py_V13;\n02502\t    \n02503\t        PyArrayObject* V13;\n02504\t        \n02505\t            typedef npy_float64 dtype_V13;\n02506\t            \n02507\t    PyObject* py_V15;\n02508\t    \n02509\t        PyArrayObject* V15;\n02510\t        \n02511\t            typedef npy_float64 dtype_V15;\n02512\t            \n02513\t    PyObject* py_V17;\n02514\t    \n02515\t        PyArrayObject* V17;\n02516\t        \n02517\t            typedef npy_float64 dtype_V17;\n02518\t            \n02519\t    PyObject* py_V19;\n02520\t    \n02521\t        PyArrayObject* V19;\n02522\t        \n02523\t            typedef npy_float64 dtype_V19;\n02524\t            \n02525\t    PyObject* py_V21;\n02526\t    \n02527\t        PyArrayObject* V21;\n02528\t        \n02529\t            typedef npy_float64 dtype_V21;\n02530\t            \n02531\t    PyObject* py_V23;\n02532\t    \n02533\t        PyArrayObject* V23;\n02534\t        \n02535\t            typedef npy_float64 dtype_V23;\n02536\t            \n02537\t    PyObject* py_V25;\n02538\t    \n02539\t        PyArrayObject* V25;\n02540\t        \n02541\t            typedef npy_float64 dtype_V25;\n02542\t            \n02543\t    PyObject* py_V27;\n02544\t    \n02545\t        PyArrayObject* V27;\n02546\t        \n02547\t            typedef npy_float64 dtype_V27;\n02548\t            \n02549\t    PyObject* py_V29;\n02550\t    \n02551\t        PyArrayObject* V29;\n02552\t        \n02553\t            typedef npy_float64 dtype_V29;\n02554\t            \n02555\t    PyObject* py_V31;\n02556\t    \n02557\t        PyArrayObject* V31;\n02558\t        \n02559\t            typedef npy_float64 dtype_V31;\n02560\t            \n02561\t    PyObject* py_V33;\n02562\t    \n02563\t        PyArrayObject* V33;\n02564\t        \n02565\t            typedef npy_float64 dtype_V33;\n02566\t            \n02567\t    PyObject* py_V35;\n02568\t    \n02569\t        PyArrayObject* V35;\n02570\t        \n02571\t            typedef npy_float64 dtype_V35;\n02572\t            \n02573\t    PyObject* py_V37;\n02574\t    \n02575\t        PyArrayObject* V37;\n02576\t        \n02577\t            typedef npy_float64 dtype_V37;\n02578\t            \n02579\t    PyObject* py_V39;\n02580\t    \n02581\t        PyArrayObject* V39;\n02582\t        \n02583\t            typedef npy_float64 dtype_V39;\n02584\t            \n02585\t    PyObject* py_V41;\n02586\t    \n02587\t        PyArrayObject* V41;\n02588\t        \n02589\t            typedef npy_float64 dtype_V41;\n02590\t            \n02591\t    PyObject* py_V43;\n02592\t    \n02593\t        PyArrayObject* V43;\n02594\t        \n02595\t            typedef npy_float64 dtype_V43;\n02596\t            \n02597\t    PyObject* py_V45;\n02598\t    \n02599\t        PyArrayObject* V45;\n02600\t        \n02601\t            typedef npy_float64 dtype_V45;\n02602\t            \n02603\t    PyObject* py_V47;\n02604\t    \n02605\t        PyArrayObject* V47;\n02606\t        \n02607\t            typedef npy_float64 dtype_V47;\n02608\t            \n02609\t    PyObject* py_V49;\n02610\t    \n02611\t        PyArrayObject* V49;\n02612\t        \n02613\t            typedef npy_float64 dtype_V49;\n02614\t            \n02615\t    PyObject* py_V51;\n02616\t    \n02617\t        PyArrayObject* V51;\n02618\t        \n02619\t            typedef npy_float64 dtype_V51;\n02620\t            \n02621\t    PyObject* py_V53;\n02622\t    \n02623\t        PyArrayObject* V53;\n02624\t        \n02625\t            typedef npy_float64 dtype_V53;\n02626\t            \n02627\t    PyObject* py_V55;\n02628\t    \n02629\t        PyArrayObject* V55;\n02630\t        \n02631\t            typedef npy_float64 dtype_V55;\n02632\t            \n02633\t    PyObject* py_V57;\n02634\t    \n02635\t        PyArrayObject* V57;\n02636\t        \n02637\t            typedef npy_float64 dtype_V57;\n02638\t            \n02639\t    PyObject* py_V59;\n02640\t    \n02641\t        PyArrayObject* V59;\n02642\t        \n02643\t            typedef npy_float64 dtype_V59;\n02644\t            \n02645\t    PyObject* py_V61;\n02646\t    \n02647\t        PyArrayObject* V61;\n02648\t        \n02649\t            typedef npy_float64 dtype_V61;\n02650\t            \n02651\t    PyObject* py_V63;\n02652\t    \n02653\t        PyArrayObject* V63;\n02654\t        \n02655\t            typedef npy_float64 dtype_V63;\n02656\t            \n02657\t    PyObject* py_V65;\n02658\t    \n02659\t        PyArrayObject* V65;\n02660\t        \n02661\t            typedef npy_float64 dtype_V65;\n02662\t            \n02663\t    PyObject* py_V67;\n02664\t    \n02665\t        PyArrayObject* V67;\n02666\t        \n02667\t            typedef npy_float64 dtype_V67;\n02668\t            \n02669\t    PyObject* py_V69;\n02670\t    \n02671\t        PyArrayObject* V69;\n02672\t        \n02673\t            typedef npy_float64 dtype_V69;\n02674\t            \n02675\t    PyObject* py_V71;\n02676\t    \n02677\t        PyArrayObject* V71;\n02678\t        \n02679\t            typedef npy_float64 dtype_V71;\n02680\t            \n02681\t    PyObject* py_V73;\n02682\t    \n02683\t        PyArrayObject* V73;\n02684\t        \n02685\t            typedef npy_float64 dtype_V73;\n02686\t            \n02687\t    PyObject* py_V75;\n02688\t    \n02689\t        PyArrayObject* V75;\n02690\t        \n02691\t            typedef npy_float64 dtype_V75;\n02692\t            \n02693\t    PyObject* py_V77;\n02694\t    \n02695\t        PyArrayObject* V77;\n02696\t        \n02697\t            typedef npy_float64 dtype_V77;\n02698\t            \n02699\t    PyObject* py_V79;\n02700\t    \n02701\t        PyArrayObject* V79;\n02702\t        \n02703\t            typedef npy_float64 dtype_V79;\n02704\t            \n02705\t    PyObject* py_V81;\n02706\t    \n02707\t        PyArrayObject* V81;\n02708\t        \n02709\t            typedef npy_float64 dtype_V81;\n02710\t            \n02711\t    PyObject* py_V83;\n02712\t    \n02713\t        PyArrayObject* V83;\n02714\t        \n02715\t            typedef npy_float64 dtype_V83;\n02716\t            \n02717\t    PyObject* py_V85;\n02718\t    \n02719\t        PyArrayObject* V85;\n02720\t        \n02721\t            typedef npy_float64 dtype_V85;\n02722\t            \n02723\t    PyObject* py_V87;\n02724\t    \n02725\t        PyArrayObject* V87;\n02726\t        \n02727\t            typedef npy_float64 dtype_V87;\n02728\t            \n02729\t    PyObject* py_V89;\n02730\t    \n02731\t        PyArrayObject* V89;\n02732\t        \n02733\t            typedef npy_float64 dtype_V89;\n02734\t            \n02735\t    PyObject* py_V91;\n02736\t    \n02737\t        PyArrayObject* V91;\n02738\t        \n02739\t            typedef npy_float64 dtype_V91;\n02740\t            \n02741\t    PyObject* py_V93;\n02742\t    \n02743\t        PyArrayObject* V93;\n02744\t        \n02745\t            typedef npy_float64 dtype_V93;\n02746\t            \n02747\t    PyObject* py_V95;\n02748\t    \n02749\t        PyArrayObject* V95;\n02750\t        \n02751\t            typedef npy_float64 dtype_V95;\n02752\t            \n02753\t    PyObject* py_V97;\n02754\t    \n02755\t        PyArrayObject* V97;\n02756\t        \n02757\t            typedef npy_float64 dtype_V97;\n02758\t            \n02759\t    PyObject* py_V99;\n02760\t    \n02761\t        PyArrayObject* V99;\n02762\t        \n02763\t            typedef npy_float64 dtype_V99;\n02764\t            \n02765\t    PyObject* py_V101;\n02766\t    \n02767\t        PyArrayObject* V101;\n02768\t        \n02769\t            typedef npy_float64 dtype_V101;\n02770\t            \n02771\t    PyObject* py_V103;\n02772\t    \n02773\t        PyArrayObject* V103;\n02774\t        \n02775\t            typedef npy_float64 dtype_V103;\n02776\t            \n02777\t    PyObject* py_V105;\n02778\t    \n02779\t        PyArrayObject* V105;\n02780\t        \n02781\t            typedef npy_float64 dtype_V105;\n02782\t            \n02783\t    PyObject* py_V107;\n02784\t    \n02785\t        PyArrayObject* V107;\n02786\t        \n02787\t            typedef npy_float64 dtype_V107;\n02788\t            \n02789\t    PyObject* py_V109;\n02790\t    \n02791\t        PyArrayObject* V109;\n02792\t        \n02793\t            typedef npy_float64 dtype_V109;\n02794\t            \n02795\t    PyObject* py_V111;\n02796\t    \n02797\t        PyArrayObject* V111;\n02798\t        \n02799\t            typedef npy_float64 dtype_V111;\n02800\t            \n02801\t    PyObject* py_V113;\n02802\t    \n02803\t        PyArrayObject* V113;\n02804\t        \n02805\t            typedef npy_float64 dtype_V113;\n02806\t            \n02807\t    PyObject* py_V115;\n02808\t    \n02809\t        PyArrayObject* V115;\n02810\t        \n02811\t            typedef npy_float64 dtype_V115;\n02812\t            \n02813\t    PyObject* py_V117;\n02814\t    \n02815\t        PyArrayObject* V117;\n02816\t        \n02817\t            typedef npy_float64 dtype_V117;\n02818\t            \n02819\t    PyObject* py_V119;\n02820\t    \n02821\t        PyArrayObject* V119;\n02822\t        \n02823\t            typedef npy_float64 dtype_V119;\n02824\t            \n02825\t    PyObject* py_V121;\n02826\t    \n02827\t        PyArrayObject* V121;\n02828\t        \n02829\t            typedef npy_float64 dtype_V121;\n02830\t            \n02831\t    PyObject* py_V123;\n02832\t    \n02833\t        PyArrayObject* V123;\n02834\t        \n02835\t            typedef npy_float64 dtype_V123;\n02836\t            \n02837\t    PyObject* py_V125;\n02838\t    \n02839\t        PyArrayObject* V125;\n02840\t        \n02841\t            typedef npy_float64 dtype_V125;\n02842\t            \n02843\t    PyObject* py_V127;\n02844\t    \n02845\t        PyArrayObject* V127;\n02846\t        \n02847\t            typedef npy_float64 dtype_V127;\n02848\t            \n02849\t    PyObject* py_V129;\n02850\t    \n02851\t        PyArrayObject* V129;\n02852\t        \n02853\t            typedef npy_float64 dtype_V129;\n02854\t            \n02855\t    PyObject* py_V131;\n02856\t    \n02857\t        PyArrayObject* V131;\n02858\t        \n02859\t            typedef npy_float64 dtype_V131;\n02860\t            \n02861\t    PyObject* py_V133;\n02862\t    \n02863\t        PyArrayObject* V133;\n02864\t        \n02865\t            typedef npy_float64 dtype_V133;\n02866\t            \n02867\t    PyObject* py_V135;\n02868\t    \n02869\t        PyArrayObject* V135;\n02870\t        \n02871\t            typedef npy_float64 dtype_V135;\n02872\t            \n02873\t    PyObject* py_V137;\n02874\t    \n02875\t        PyArrayObject* V137;\n02876\t        \n02877\t            typedef npy_float64 dtype_V137;\n02878\t            \n02879\t    PyObject* py_V139;\n02880\t    \n02881\t        PyArrayObject* V139;\n02882\t        \n02883\t            typedef npy_float64 dtype_V139;\n02884\t            \n02885\t    PyObject* py_V141;\n02886\t    \n02887\t        PyArrayObject* V141;\n02888\t        \n02889\t            typedef npy_float64 dtype_V141;\n02890\t            \n02891\t    PyObject* py_V143;\n02892\t    \n02893\t        PyArrayObject* V143;\n02894\t        \n02895\t            typedef npy_float64 dtype_V143;\n02896\t            \n02897\t    PyObject* py_V145;\n02898\t    \n02899\t        PyArrayObject* V145;\n02900\t        \n02901\t            typedef npy_float64 dtype_V145;\n02902\t            \n02903\t    PyObject* py_V147;\n02904\t    \n02905\t        PyArrayObject* V147;\n02906\t        \n02907\t            typedef npy_float64 dtype_V147;\n02908\t            \n02909\t    PyObject* py_V149;\n02910\t    \n02911\t        PyArrayObject* V149;\n02912\t        \n02913\t            typedef npy_float64 dtype_V149;\n02914\t            \n02915\t    PyObject* py_V151;\n02916\t    \n02917\t        PyArrayObject* V151;\n02918\t        \n02919\t            typedef npy_float64 dtype_V151;\n02920\t            \n02921\t    PyObject* py_V153;\n02922\t    \n02923\t        PyArrayObject* V153;\n02924\t        \n02925\t            typedef npy_float64 dtype_V153;\n02926\t            \n02927\t    PyObject* py_V155;\n02928\t    \n02929\t        PyArrayObject* V155;\n02930\t        \n02931\t            typedef npy_float64 dtype_V155;\n02932\t            \n02933\t    PyObject* py_V157;\n02934\t    \n02935\t        PyArrayObject* V157;\n02936\t        \n02937\t            typedef npy_float64 dtype_V157;\n02938\t            \n02939\t    PyObject* py_V159;\n02940\t    \n02941\t        PyArrayObject* V159;\n02942\t        \n02943\t            typedef npy_float64 dtype_V159;\n02944\t            \n02945\t    PyObject* py_V161;\n02946\t    \n02947\t        PyArrayObject* V161;\n02948\t        \n02949\t            typedef npy_float64 dtype_V161;\n02950\t            \n02951\t    PyObject* py_V163;\n02952\t    \n02953\t        PyArrayObject* V163;\n02954\t        \n02955\t            typedef npy_float64 dtype_V163;\n02956\t            \n02957\t    PyObject* py_V165;\n02958\t    \n02959\t        PyArrayObject* V165;\n02960\t        \n02961\t            typedef npy_float64 dtype_V165;\n02962\t            \n02963\t    PyObject* py_V167;\n02964\t    \n02965\t        PyArrayObject* V167;\n02966\t        \n02967\t            typedef npy_float64 dtype_V167;\n02968\t            \n02969\t    PyObject* py_V169;\n02970\t    \n02971\t        PyArrayObject* V169;\n02972\t        \n02973\t            typedef npy_float64 dtype_V169;\n02974\t            \n02975\t    PyObject* py_V171;\n02976\t    \n02977\t        PyArrayObject* V171;\n02978\t        \n02979\t            typedef npy_float64 dtype_V171;\n02980\t            \n02981\t    PyObject* py_V173;\n02982\t    \n02983\t        PyArrayObject* V173;\n02984\t        \n02985\t            typedef npy_float64 dtype_V173;\n02986\t            \n02987\t    PyObject* py_V175;\n02988\t    \n02989\t        PyArrayObject* V175;\n02990\t        \n02991\t            typedef npy_float64 dtype_V175;\n02992\t            \n02993\t    PyObject* py_V177;\n02994\t    \n02995\t        PyArrayObject* V177;\n02996\t        \n02997\t            typedef npy_float64 dtype_V177;\n02998\t            \n02999\t    PyObject* py_V179;\n03000\t    \n03001\t        PyArrayObject* V179;\n03002\t        \n03003\t            typedef npy_float64 dtype_V179;\n03004\t            \n03005\t    PyObject* py_V181;\n03006\t    \n03007\t        PyArrayObject* V181;\n03008\t        \n03009\t            typedef npy_float64 dtype_V181;\n03010\t            \n03011\t    PyObject* py_V183;\n03012\t    \n03013\t        PyArrayObject* V183;\n03014\t        \n03015\t            typedef npy_float64 dtype_V183;\n03016\t            \n03017\t    PyObject* py_V185;\n03018\t    \n03019\t        PyArrayObject* V185;\n03020\t        \n03021\t            typedef npy_float64 dtype_V185;\n03022\t            \n03023\t    PyObject* py_V187;\n03024\t    \n03025\t        PyArrayObject* V187;\n03026\t        \n03027\t            typedef npy_float64 dtype_V187;\n03028\t            \n03029\t    PyObject* py_V189;\n03030\t    \n03031\t        PyArrayObject* V189;\n03032\t        \n03033\t            typedef npy_float64 dtype_V189;\n03034\t            \n03035\t    PyObject* py_V191;\n03036\t    \n03037\t        PyArrayObject* V191;\n03038\t        \n03039\t            typedef npy_float64 dtype_V191;\n03040\t            \n03041\t    PyObject* py_V193;\n03042\t    \n03043\t        PyArrayObject* V193;\n03044\t        \n03045\t            typedef npy_float64 dtype_V193;\n03046\t            \n03047\t    PyObject* py_V195;\n03048\t    \n03049\t        PyArrayObject* V195;\n03050\t        \n03051\t            typedef npy_float64 dtype_V195;\n03052\t            \n03053\t    PyObject* py_V197;\n03054\t    \n03055\t        PyArrayObject* V197;\n03056\t        \n03057\t            typedef npy_float64 dtype_V197;\n03058\t            \n03059\t    PyObject* py_V199;\n03060\t    \n03061\t        PyArrayObject* V199;\n03062\t        \n03063\t            typedef npy_float64 dtype_V199;\n03064\t            \n03065\t    PyObject* py_V201;\n03066\t    \n03067\t        PyArrayObject* V201;\n03068\t        \n03069\t            typedef npy_float64 dtype_V201;\n03070\t            \n03071\t    PyObject* py_V203;\n03072\t    \n03073\t        PyArrayObject* V203;\n03074\t        \n03075\t            typedef npy_float64 dtype_V203;\n03076\t            \n03077\t    PyObject* py_V205;\n03078\t    \n03079\t        PyArrayObject* V205;\n03080\t        \n03081\t            typedef npy_float64 dtype_V205;\n03082\t            \n03083\t    PyObject* py_V207;\n03084\t    \n03085\t        PyArrayObject* V207;\n03086\t        \n03087\t            typedef npy_float64 dtype_V207;\n03088\t            \n03089\t    PyObject* py_V209;\n03090\t    \n03091\t        PyArrayObject* V209;\n03092\t        \n03093\t            typedef npy_float64 dtype_V209;\n03094\t            \n03095\t    PyObject* py_V211;\n03096\t    \n03097\t        PyArrayObject* V211;\n03098\t        \n03099\t            typedef npy_float64 dtype_V211;\n03100\t            \n03101\t    PyObject* py_V213;\n03102\t    \n03103\t        PyArrayObject* V213;\n03104\t        \n03105\t            typedef npy_float64 dtype_V213;\n03106\t            \n03107\t    PyObject* py_V215;\n03108\t    \n03109\t        PyArrayObject* V215;\n03110\t        \n03111\t            typedef npy_float64 dtype_V215;\n03112\t            \n03113\t    PyObject* py_V217;\n03114\t    \n03115\t        PyArrayObject* V217;\n03116\t        \n03117\t            typedef npy_float64 dtype_V217;\n03118\t            \n03119\t    PyObject* py_V219;\n03120\t    \n03121\t        PyArrayObject* V219;\n03122\t        \n03123\t            typedef npy_float64 dtype_V219;\n03124\t            \n03125\t    PyObject* py_V221;\n03126\t    \n03127\t        PyArrayObject* V221;\n03128\t        \n03129\t            typedef npy_float64 dtype_V221;\n03130\t            \n03131\t    PyObject* py_V223;\n03132\t    \n03133\t        PyArrayObject* V223;\n03134\t        \n03135\t            typedef npy_float64 dtype_V223;\n03136\t            \n03137\t    PyObject* py_V225;\n03138\t    \n03139\t        PyArrayObject* V225;\n03140\t        \n03141\t            typedef npy_float64 dtype_V225;\n03142\t            \n03143\t    PyObject* py_V227;\n03144\t    \n03145\t        PyArrayObject* V227;\n03146\t        \n03147\t            typedef npy_float64 dtype_V227;\n03148\t            \n03149\t    PyObject* py_V229;\n03150\t    \n03151\t        PyArrayObject* V229;\n03152\t        \n03153\t            typedef npy_float64 dtype_V229;\n03154\t            \n03155\t    PyObject* py_V231;\n03156\t    \n03157\t        PyArrayObject* V231;\n03158\t        \n03159\t            typedef npy_float64 dtype_V231;\n03160\t            \n03161\t    PyObject* py_V233;\n03162\t    \n03163\t        PyArrayObject* V233;\n03164\t        \n03165\t            typedef npy_float64 dtype_V233;\n03166\t            \n03167\t    PyObject* py_V235;\n03168\t    \n03169\t        PyArrayObject* V235;\n03170\t        \n03171\t            typedef npy_float64 dtype_V235;\n03172\t            \n03173\t    PyObject* py_V237;\n03174\t    \n03175\t        PyArrayObject* V237;\n03176\t        \n03177\t            typedef npy_float64 dtype_V237;\n03178\t            \n03179\t    PyObject* py_V239;\n03180\t    \n03181\t        PyArrayObject* V239;\n03182\t        \n03183\t            typedef npy_float64 dtype_V239;\n03184\t            \n03185\t    PyObject* py_V241;\n03186\t    \n03187\t        PyArrayObject* V241;\n03188\t        \n03189\t            typedef npy_float64 dtype_V241;\n03190\t            \n03191\t    PyObject* py_V243;\n03192\t    \n03193\t        PyArrayObject* V243;\n03194\t        \n03195\t            typedef npy_float64 dtype_V243;\n03196\t            \n03197\t    PyObject* py_V245;\n03198\t    \n03199\t        PyArrayObject* V245;\n03200\t        \n03201\t            typedef npy_float64 dtype_V245;\n03202\t            \n03203\t    PyObject* py_V247;\n03204\t    \n03205\t        PyArrayObject* V247;\n03206\t        \n03207\t            typedef npy_float64 dtype_V247;\n03208\t            \n03209\t    PyObject* py_V249;\n03210\t    \n03211\t        PyArrayObject* V249;\n03212\t        \n03213\t            typedef npy_float64 dtype_V249;\n03214\t            \n03215\t    PyObject* py_V251;\n03216\t    \n03217\t        PyArrayObject* V251;\n03218\t        \n03219\t            typedef npy_float64 dtype_V251;\n03220\t            \n03221\t    PyObject* py_V253;\n03222\t    \n03223\t        PyArrayObject* V253;\n03224\t        \n03225\t            typedef npy_float64 dtype_V253;\n03226\t            \n03227\t    PyObject* py_V255;\n03228\t    \n03229\t        PyArrayObject* V255;\n03230\t        \n03231\t            typedef npy_float64 dtype_V255;\n03232\t            \n03233\t    PyObject* py_V257;\n03234\t    \n03235\t        PyArrayObject* V257;\n03236\t        \n03237\t            typedef npy_float64 dtype_V257;\n03238\t            \n03239\t    PyObject* py_V259;\n03240\t    \n03241\t        PyArrayObject* V259;\n03242\t        \n03243\t            typedef npy_float64 dtype_V259;\n03244\t            \n03245\t    PyObject* py_V261;\n03246\t    \n03247\t        PyArrayObject* V261;\n03248\t        \n03249\t            typedef npy_float64 dtype_V261;\n03250\t            \n03251\t    PyObject* py_V263;\n03252\t    \n03253\t        PyArrayObject* V263;\n03254\t        \n03255\t            typedef npy_float64 dtype_V263;\n03256\t            \n03257\t    PyObject* py_V265;\n03258\t    \n03259\t        PyArrayObject* V265;\n03260\t        \n03261\t            typedef npy_float64 dtype_V265;\n03262\t            \n03263\t    PyObject* py_V267;\n03264\t    \n03265\t        PyArrayObject* V267;\n03266\t        \n03267\t            typedef npy_float64 dtype_V267;\n03268\t            \n03269\t    PyObject* py_V269;\n03270\t    \n03271\t        PyArrayObject* V269;\n03272\t        \n03273\t            typedef npy_float64 dtype_V269;\n03274\t            \n03275\t    PyObject* py_V271;\n03276\t    \n03277\t        PyArrayObject* V271;\n03278\t        \n03279\t            typedef npy_float64 dtype_V271;\n03280\t            \n03281\t    PyObject* py_V273;\n03282\t    \n03283\t        PyArrayObject* V273;\n03284\t        \n03285\t            typedef npy_float64 dtype_V273;\n03286\t            \n03287\t    PyObject* py_V275;\n03288\t    \n03289\t        PyArrayObject* V275;\n03290\t        \n03291\t            typedef npy_float64 dtype_V275;\n03292\t            \n03293\t    PyObject* py_V277;\n03294\t    \n03295\t        PyArrayObject* V277;\n03296\t        \n03297\t            typedef npy_float64 dtype_V277;\n03298\t            \n03299\t    PyObject* py_V279;\n03300\t    \n03301\t        PyArrayObject* V279;\n03302\t        \n03303\t            typedef npy_float64 dtype_V279;\n03304\t            \n03305\t    PyObject* py_V281;\n03306\t    \n03307\t        PyArrayObject* V281;\n03308\t        \n03309\t            typedef npy_float64 dtype_V281;\n03310\t            \n03311\t    PyObject* py_V283;\n03312\t    \n03313\t        PyArrayObject* V283;\n03314\t        \n03315\t            typedef npy_float64 dtype_V283;\n03316\t            \n03317\t    PyObject* py_V285;\n03318\t    \n03319\t        PyArrayObject* V285;\n03320\t        \n03321\t            typedef npy_float64 dtype_V285;\n03322\t            \n03323\t    PyObject* py_V287;\n03324\t    \n03325\t        PyArrayObject* V287;\n03326\t        \n03327\t            typedef npy_float64 dtype_V287;\n03328\t            \n03329\t    PyObject* py_V289;\n03330\t    \n03331\t        PyArrayObject* V289;\n03332\t        \n03333\t            typedef npy_float64 dtype_V289;\n03334\t            \n03335\t    PyObject* py_V291;\n03336\t    \n03337\t        PyArrayObject* V291;\n03338\t        \n03339\t            typedef npy_float64 dtype_V291;\n03340\t            \n03341\t    PyObject* py_V293;\n03342\t    \n03343\t        PyArrayObject* V293;\n03344\t        \n03345\t            typedef npy_float64 dtype_V293;\n03346\t            \n03347\t    PyObject* py_V295;\n03348\t    \n03349\t        PyArrayObject* V295;\n03350\t        \n03351\t            typedef npy_float64 dtype_V295;\n03352\t            \n03353\t    PyObject* py_V297;\n03354\t    \n03355\t        PyArrayObject* V297;\n03356\t        \n03357\t            typedef npy_float64 dtype_V297;\n03358\t            \n03359\t    PyObject* py_V299;\n03360\t    \n03361\t        PyArrayObject* V299;\n03362\t        \n03363\t            typedef npy_float64 dtype_V299;\n03364\t            \n03365\t    PyObject* py_V301;\n03366\t    \n03367\t        PyArrayObject* V301;\n03368\t        \n03369\t            typedef npy_float64 dtype_V301;\n03370\t            \n03371\t    PyObject* py_V303;\n03372\t    \n03373\t        PyArrayObject* V303;\n03374\t        \n03375\t            typedef npy_float64 dtype_V303;\n03376\t            \n03377\t    PyObject* py_V305;\n03378\t    \n03379\t        PyArrayObject* V305;\n03380\t        \n03381\t            typedef npy_float64 dtype_V305;\n03382\t            \n03383\t    PyObject* py_V307;\n03384\t    \n03385\t        PyArrayObject* V307;\n03386\t        \n03387\t            typedef npy_float64 dtype_V307;\n03388\t            \n03389\t    PyObject* py_V309;\n03390\t    \n03391\t        PyArrayObject* V309;\n03392\t        \n03393\t            typedef npy_float64 dtype_V309;\n03394\t            \n03395\t    PyObject* py_V311;\n03396\t    \n03397\t        PyArrayObject* V311;\n03398\t        \n03399\t            typedef npy_float64 dtype_V311;\n03400\t            \n03401\t    PyObject* py_V313;\n03402\t    \n03403\t        PyArrayObject* V313;\n03404\t        \n03405\t            typedef npy_float64 dtype_V313;\n03406\t            \n03407\t    PyObject* py_V315;\n03408\t    \n03409\t        PyArrayObject* V315;\n03410\t        \n03411\t            typedef npy_float64 dtype_V315;\n03412\t            \n03413\t    PyObject* py_V317;\n03414\t    \n03415\t        PyArrayObject* V317;\n03416\t        \n03417\t            typedef npy_float64 dtype_V317;\n03418\t            \n03419\t    PyObject* py_V319;\n03420\t    \n03421\t        PyArrayObject* V319;\n03422\t        \n03423\t            typedef npy_float64 dtype_V319;\n03424\t            \n03425\t    PyObject* py_V321;\n03426\t    \n03427\t        PyArrayObject* V321;\n03428\t        \n03429\t            typedef npy_float64 dtype_V321;\n03430\t            \n03431\t    PyObject* py_V323;\n03432\t    \n03433\t        PyArrayObject* V323;\n03434\t        \n03435\t            typedef npy_float64 dtype_V323;\n03436\t            \n03437\t    PyObject* py_V325;\n03438\t    \n03439\t        PyArrayObject* V325;\n03440\t        \n03441\t            typedef npy_float64 dtype_V325;\n03442\t            \n03443\t    PyObject* py_V327;\n03444\t    \n03445\t        PyArrayObject* V327;\n03446\t        \n03447\t            typedef npy_float64 dtype_V327;\n03448\t            \n03449\t    PyObject* py_V329;\n03450\t    \n03451\t        PyArrayObject* V329;\n03452\t        \n03453\t            typedef npy_float64 dtype_V329;\n03454\t            \n03455\t    PyObject* py_V331;\n03456\t    \n03457\t        PyArrayObject* V331;\n03458\t        \n03459\t            typedef npy_float64 dtype_V331;\n03460\t            \n03461\t    PyObject* py_V333;\n03462\t    \n03463\t        PyArrayObject* V333;\n03464\t        \n03465\t            typedef npy_float64 dtype_V333;\n03466\t            \n03467\t    PyObject* py_V335;\n03468\t    \n03469\t        PyArrayObject* V335;\n03470\t        \n03471\t            typedef npy_float64 dtype_V335;\n03472\t            \n03473\t    PyObject* py_V337;\n03474\t    \n03475\t        PyArrayObject* V337;\n03476\t        \n03477\t            typedef npy_float64 dtype_V337;\n03478\t            \n03479\t    PyObject* py_V339;\n03480\t    \n03481\t        PyArrayObject* V339;\n03482\t        \n03483\t            typedef npy_float64 dtype_V339;\n03484\t            \n03485\t    PyObject* py_V341;\n03486\t    \n03487\t        PyArrayObject* V341;\n03488\t        \n03489\t            typedef npy_float64 dtype_V341;\n03490\t            \n03491\t    PyObject* py_V343;\n03492\t    \n03493\t        PyArrayObject* V343;\n03494\t        \n03495\t            typedef npy_float64 dtype_V343;\n03496\t            \n03497\t    PyObject* py_V345;\n03498\t    \n03499\t        PyArrayObject* V345;\n03500\t        \n03501\t            typedef npy_float64 dtype_V345;\n03502\t            \n03503\t    PyObject* py_V347;\n03504\t    \n03505\t        PyArrayObject* V347;\n03506\t        \n03507\t            typedef npy_float64 dtype_V347;\n03508\t            \n03509\t    PyObject* py_V349;\n03510\t    \n03511\t        PyArrayObject* V349;\n03512\t        \n03513\t            typedef npy_float64 dtype_V349;\n03514\t            \n03515\t    PyObject* py_V351;\n03516\t    \n03517\t        PyArrayObject* V351;\n03518\t        \n03519\t            typedef npy_float64 dtype_V351;\n03520\t            \n03521\t    PyObject* py_V353;\n03522\t    \n03523\t        PyArrayObject* V353;\n03524\t        \n03525\t            typedef npy_float64 dtype_V353;\n03526\t            \n03527\t    PyObject* py_V355;\n03528\t    \n03529\t        PyArrayObject* V355;\n03530\t        \n03531\t            typedef npy_float64 dtype_V355;\n03532\t            \n03533\t    PyObject* py_V357;\n03534\t    \n03535\t        PyArrayObject* V357;\n03536\t        \n03537\t            typedef npy_float64 dtype_V357;\n03538\t            \n03539\t    PyObject* py_V359;\n03540\t    \n03541\t        PyArrayObject* V359;\n03542\t        \n03543\t            typedef npy_float64 dtype_V359;\n03544\t            \n03545\t    PyObject* py_V361;\n03546\t    \n03547\t        PyArrayObject* V361;\n03548\t        \n03549\t            typedef npy_float64 dtype_V361;\n03550\t            \n03551\t    PyObject* py_V363;\n03552\t    \n03553\t        PyArrayObject* V363;\n03554\t        \n03555\t            typedef npy_float64 dtype_V363;\n03556\t            \n03557\t    PyObject* py_V365;\n03558\t    \n03559\t        PyArrayObject* V365;\n03560\t        \n03561\t            typedef npy_float64 dtype_V365;\n03562\t            \n03563\t    PyObject* py_V367;\n03564\t    \n03565\t        PyArrayObject* V367;\n03566\t        \n03567\t            typedef npy_float64 dtype_V367;\n03568\t            \n03569\t    PyObject* py_V369;\n03570\t    \n03571\t        PyArrayObject* V369;\n03572\t        \n03573\t            typedef npy_float64 dtype_V369;\n03574\t            \n03575\t    PyObject* py_V371;\n03576\t    \n03577\t        PyArrayObject* V371;\n03578\t        \n03579\t            typedef npy_float64 dtype_V371;\n03580\t            \n03581\t    PyObject* py_V373;\n03582\t    \n03583\t        PyArrayObject* V373;\n03584\t        \n03585\t            typedef npy_float64 dtype_V373;\n03586\t            \n03587\t    PyObject* py_V375;\n03588\t    \n03589\t        PyArrayObject* V375;\n03590\t        \n03591\t            typedef npy_float64 dtype_V375;\n03592\t            \n03593\t    PyObject* py_V377;\n03594\t    \n03595\t        PyArrayObject* V377;\n03596\t        \n03597\t            typedef npy_float64 dtype_V377;\n03598\t            \n03599\t    PyObject* py_V379;\n03600\t    \n03601\t        PyArrayObject* V379;\n03602\t        \n03603\t            typedef npy_float64 dtype_V379;\n03604\t            \n03605\t    PyObject* py_V381;\n03606\t    \n03607\t        PyArrayObject* V381;\n03608\t        \n03609\t            typedef npy_float64 dtype_V381;\n03610\t            \n03611\t    PyObject* py_V383;\n03612\t    \n03613\t        PyArrayObject* V383;\n03614\t        \n03615\t            typedef npy_float64 dtype_V383;\n03616\t            \n03617\t    PyObject* py_V385;\n03618\t    \n03619\t        PyArrayObject* V385;\n03620\t        \n03621\t            typedef npy_float64 dtype_V385;\n03622\t            \n03623\t    PyObject* py_V387;\n03624\t    \n03625\t        PyArrayObject* V387;\n03626\t        \n03627\t            typedef npy_float64 dtype_V387;\n03628\t            \n03629\t    PyObject* py_V389;\n03630\t    \n03631\t        PyArrayObject* V389;\n03632\t        \n03633\t            typedef npy_float64 dtype_V389;\n03634\t            \n03635\t    PyObject* py_V391;\n03636\t    \n03637\t        PyArrayObject* V391;\n03638\t        \n03639\t            typedef npy_float64 dtype_V391;\n03640\t            \n03641\t    PyObject* py_V393;\n03642\t    \n03643\t        PyArrayObject* V393;\n03644\t        \n03645\t            typedef npy_float64 dtype_V393;\n03646\t            \n03647\t    PyObject* py_V395;\n03648\t    \n03649\t        PyArrayObject* V395;\n03650\t        \n03651\t            typedef npy_float64 dtype_V395;\n03652\t            \n03653\t    PyObject* py_V397;\n03654\t    \n03655\t        PyArrayObject* V397;\n03656\t        \n03657\t            typedef npy_float64 dtype_V397;\n03658\t            \n03659\t    PyObject* py_V399;\n03660\t    \n03661\t        PyArrayObject* V399;\n03662\t        \n03663\t            typedef npy_float64 dtype_V399;\n03664\t            \n03665\t    PyObject* py_V401;\n03666\t    \n03667\t        PyArrayObject* V401;\n03668\t        \n03669\t            typedef npy_float64 dtype_V401;\n03670\t            \n03671\t    PyObject* py_V403;\n03672\t    \n03673\t        PyArrayObject* V403;\n03674\t        \n03675\t            typedef npy_float64 dtype_V403;\n03676\t            \n03677\t    PyObject* py_V405;\n03678\t    \n03679\t        PyArrayObject* V405;\n03680\t        \n03681\t            typedef npy_float64 dtype_V405;\n03682\t            \n03683\t    PyObject* py_V407;\n03684\t    \n03685\t        PyArrayObject* V407;\n03686\t        \n03687\t            typedef npy_float64 dtype_V407;\n03688\t            \n03689\t    PyObject* py_V409;\n03690\t    \n03691\t        PyArrayObject* V409;\n03692\t        \n03693\t            typedef npy_float64 dtype_V409;\n03694\t            \n03695\t    PyObject* py_V411;\n03696\t    \n03697\t        PyArrayObject* V411;\n03698\t        \n03699\t            typedef npy_float64 dtype_V411;\n03700\t            \n03701\t    PyObject* py_V413;\n03702\t    \n03703\t        PyArrayObject* V413;\n03704\t        \n03705\t            typedef npy_float64 dtype_V413;\n03706\t            \n03707\t    PyObject* py_V415;\n03708\t    \n03709\t        PyArrayObject* V415;\n03710\t        \n03711\t            typedef npy_float64 dtype_V415;\n03712\t            \n03713\t    PyObject* py_V417;\n03714\t    \n03715\t        PyArrayObject* V417;\n03716\t        \n03717\t            typedef npy_float64 dtype_V417;\n03718\t            \n03719\t    PyObject* py_V419;\n03720\t    \n03721\t        PyArrayObject* V419;\n03722\t        \n03723\t            typedef npy_float64 dtype_V419;\n03724\t            \n03725\t    PyObject* py_V421;\n03726\t    \n03727\t        PyArrayObject* V421;\n03728\t        \n03729\t            typedef npy_float64 dtype_V421;\n03730\t            \n03731\t    PyObject* py_V423;\n03732\t    \n03733\t        PyArrayObject* V423;\n03734\t        \n03735\t            typedef npy_float64 dtype_V423;\n03736\t            \n03737\t    PyObject* py_V425;\n03738\t    \n03739\t        PyArrayObject* V425;\n03740\t        \n03741\t            typedef npy_float64 dtype_V425;\n03742\t            \n03743\t    PyObject* py_V427;\n03744\t    \n03745\t        PyArrayObject* V427;\n03746\t        \n03747\t            typedef npy_float64 dtype_V427;\n03748\t            \n03749\t    PyObject* py_V429;\n03750\t    \n03751\t        PyArrayObject* V429;\n03752\t        \n03753\t            typedef npy_float64 dtype_V429;\n03754\t            \n03755\t    PyObject* py_V431;\n03756\t    \n03757\t        PyArrayObject* V431;\n03758\t        \n03759\t            typedef npy_float64 dtype_V431;\n03760\t            \n03761\t    PyObject* py_V433;\n03762\t    \n03763\t        PyArrayObject* V433;\n03764\t        \n03765\t            typedef npy_float64 dtype_V433;\n03766\t            \n03767\t    PyObject* py_V435;\n03768\t    \n03769\t        PyArrayObject* V435;\n03770\t        \n03771\t            typedef npy_float64 dtype_V435;\n03772\t            \n03773\t    PyObject* py_V437;\n03774\t    \n03775\t        PyArrayObject* V437;\n03776\t        \n03777\t            typedef npy_float64 dtype_V437;\n03778\t            \n03779\t    PyObject* py_V439;\n03780\t    \n03781\t        PyArrayObject* V439;\n03782\t        \n03783\t            typedef npy_float64 dtype_V439;\n03784\t            \n03785\t    PyObject* py_V441;\n03786\t    \n03787\t        PyArrayObject* V441;\n03788\t        \n03789\t            typedef npy_float64 dtype_V441;\n03790\t            \n03791\t    PyObject* py_V443;\n03792\t    \n03793\t        PyArrayObject* V443;\n03794\t        \n03795\t            typedef npy_float64 dtype_V443;\n03796\t            \n03797\t    PyObject* py_V445;\n03798\t    \n03799\t        PyArrayObject* V445;\n03800\t        \n03801\t            typedef npy_float64 dtype_V445;\n03802\t            \n03803\t    PyObject* py_V447;\n03804\t    \n03805\t        PyArrayObject* V447;\n03806\t        \n03807\t            typedef npy_float64 dtype_V447;\n03808\t            \n03809\t    PyObject* py_V449;\n03810\t    \n03811\t        PyArrayObject* V449;\n03812\t        \n03813\t            typedef npy_float64 dtype_V449;\n03814\t            \n03815\t    PyObject* py_V451;\n03816\t    \n03817\t        PyArrayObject* V451;\n03818\t        \n03819\t            typedef npy_float64 dtype_V451;\n03820\t            \n03821\t    PyObject* py_V453;\n03822\t    \n03823\t        PyArrayObject* V453;\n03824\t        \n03825\t            typedef npy_float64 dtype_V453;\n03826\t            \n03827\t    PyObject* py_V455;\n03828\t    \n03829\t        PyArrayObject* V455;\n03830\t        \n03831\t            typedef npy_float64 dtype_V455;\n03832\t            \n03833\t    PyObject* py_V457;\n03834\t    \n03835\t        PyArrayObject* V457;\n03836\t        \n03837\t            typedef npy_float64 dtype_V457;\n03838\t            \n03839\t    PyObject* py_V459;\n03840\t    \n03841\t        PyArrayObject* V459;\n03842\t        \n03843\t            typedef npy_float64 dtype_V459;\n03844\t            \n03845\t    PyObject* py_V461;\n03846\t    \n03847\t        PyArrayObject* V461;\n03848\t        \n03849\t            typedef npy_float64 dtype_V461;\n03850\t            \n03851\t    PyObject* py_V463;\n03852\t    \n03853\t        PyArrayObject* V463;\n03854\t        \n03855\t            typedef npy_float64 dtype_V463;\n03856\t            \n03857\t    PyObject* py_V465;\n03858\t    \n03859\t        PyArrayObject* V465;\n03860\t        \n03861\t            typedef npy_float64 dtype_V465;\n03862\t            \n03863\t    PyObject* py_V467;\n03864\t    \n03865\t        PyArrayObject* V467;\n03866\t        \n03867\t            typedef npy_float64 dtype_V467;\n03868\t            \n03869\t    PyObject* py_V469;\n03870\t    \n03871\t        PyArrayObject* V469;\n03872\t        \n03873\t            typedef npy_float64 dtype_V469;\n03874\t            \n03875\t    PyObject* py_V471;\n03876\t    \n03877\t        PyArrayObject* V471;\n03878\t        \n03879\t            typedef npy_float64 dtype_V471;\n03880\t            \n03881\t    PyObject* py_V473;\n03882\t    \n03883\t        PyArrayObject* V473;\n03884\t        \n03885\t            typedef npy_float64 dtype_V473;\n03886\t            \n03887\t    PyObject* py_V475;\n03888\t    \n03889\t        PyArrayObject* V475;\n03890\t        \n03891\t            typedef npy_float64 dtype_V475;\n03892\t            \n03893\t    PyObject* py_V477;\n03894\t    \n03895\t        PyArrayObject* V477;\n03896\t        \n03897\t            typedef npy_float64 dtype_V477;\n03898\t            \n03899\t    PyObject* py_V479;\n03900\t    \n03901\t        PyArrayObject* V479;\n03902\t        \n03903\t            typedef npy_float64 dtype_V479;\n03904\t            \n03905\t    PyObject* py_V481;\n03906\t    \n03907\t        PyArrayObject* V481;\n03908\t        \n03909\t            typedef npy_float64 dtype_V481;\n03910\t            \n03911\t    PyObject* py_V483;\n03912\t    \n03913\t        PyArrayObject* V483;\n03914\t        \n03915\t            typedef npy_float64 dtype_V483;\n03916\t            \n03917\t    PyObject* py_V485;\n03918\t    \n03919\t        PyArrayObject* V485;\n03920\t        \n03921\t            typedef npy_float64 dtype_V485;\n03922\t            \n03923\t    PyObject* py_V487;\n03924\t    \n03925\t        PyArrayObject* V487;\n03926\t        \n03927\t            typedef npy_float64 dtype_V487;\n03928\t            \n03929\t    PyObject* py_V489;\n03930\t    \n03931\t        PyArrayObject* V489;\n03932\t        \n03933\t            typedef npy_float64 dtype_V489;\n03934\t            \n03935\t    PyObject* py_V491;\n03936\t    \n03937\t        PyArrayObject* V491;\n03938\t        \n03939\t            typedef npy_float64 dtype_V491;\n03940\t            \n03941\t    PyObject* py_V493;\n03942\t    \n03943\t        PyArrayObject* V493;\n03944\t        \n03945\t            typedef npy_float64 dtype_V493;\n03946\t            \n03947\t    PyObject* py_V495;\n03948\t    \n03949\t        PyArrayObject* V495;\n03950\t        \n03951\t            typedef npy_float64 dtype_V495;\n03952\t            \n03953\t    PyObject* py_V497;\n03954\t    \n03955\t        PyArrayObject* V497;\n03956\t        \n03957\t            typedef npy_float64 dtype_V497;\n03958\t            \n03959\t    PyObject* py_V499;\n03960\t    \n03961\t        PyArrayObject* V499;\n03962\t        \n03963\t            typedef npy_float64 dtype_V499;\n03964\t            \n03965\t    PyObject* py_V501;\n03966\t    \n03967\t        PyArrayObject* V501;\n03968\t        \n03969\t            typedef npy_float64 dtype_V501;\n03970\t            \n03971\t    PyObject* py_V503;\n03972\t    \n03973\t        PyArrayObject* V503;\n03974\t        \n03975\t            typedef npy_float64 dtype_V503;\n03976\t            \n03977\t    PyObject* py_V505;\n03978\t    \n03979\t        PyArrayObject* V505;\n03980\t        \n03981\t            typedef npy_float64 dtype_V505;\n03982\t            \n03983\t    PyObject* py_V507;\n03984\t    \n03985\t        PyArrayObject* V507;\n03986\t        \n03987\t            typedef npy_float64 dtype_V507;\n03988\t            \n03989\t    PyObject* py_V509;\n03990\t    \n03991\t        PyArrayObject* V509;\n03992\t        \n03993\t            typedef npy_float64 dtype_V509;\n03994\t            \n03995\t    PyObject* py_V511;\n03996\t    \n03997\t        PyArrayObject* V511;\n03998\t        \n03999\t            typedef npy_float64 dtype_V511;\n04000\t            \n04001\t    PyObject* py_V513;\n04002\t    \n04003\t        PyArrayObject* V513;\n04004\t        \n04005\t            typedef npy_float64 dtype_V513;\n04006\t            \n04007\t    PyObject* py_V515;\n04008\t    \n04009\t        PyArrayObject* V515;\n04010\t        \n04011\t            typedef npy_float64 dtype_V515;\n04012\t            \n04013\t    PyObject* py_V517;\n04014\t    \n04015\t        PyArrayObject* V517;\n04016\t        \n04017\t            typedef npy_float64 dtype_V517;\n04018\t            \n04019\t    PyObject* py_V519;\n04020\t    \n04021\t        PyArrayObject* V519;\n04022\t        \n04023\t            typedef npy_float64 dtype_V519;\n04024\t            \n04025\t    PyObject* py_V521;\n04026\t    \n04027\t        PyArrayObject* V521;\n04028\t        \n04029\t            typedef npy_float64 dtype_V521;\n04030\t            \n04031\t    PyObject* py_V523;\n04032\t    \n04033\t        PyArrayObject* V523;\n04034\t        \n04035\t            typedef npy_float64 dtype_V523;\n04036\t            \n04037\t    PyObject* py_V525;\n04038\t    \n04039\t        PyArrayObject* V525;\n04040\t        \n04041\t            typedef npy_float64 dtype_V525;\n04042\t            \n04043\t    PyObject* py_V527;\n04044\t    \n04045\t        PyArrayObject* V527;\n04046\t        \n04047\t            typedef npy_float64 dtype_V527;\n04048\t            \n04049\t    PyObject* py_V529;\n04050\t    \n04051\t        PyArrayObject* V529;\n04052\t        \n04053\t            typedef npy_float64 dtype_V529;\n04054\t            \n04055\t    PyObject* py_V531;\n04056\t    \n04057\t        PyArrayObject* V531;\n04058\t        \n04059\t            typedef npy_float64 dtype_V531;\n04060\t            \n04061\t    PyObject* py_V533;\n04062\t    \n04063\t        PyArrayObject* V533;\n04064\t        \n04065\t            typedef npy_float64 dtype_V533;\n04066\t            \n04067\t    PyObject* py_V535;\n04068\t    \n04069\t        PyArrayObject* V535;\n04070\t        \n04071\t            typedef npy_float64 dtype_V535;\n04072\t            \n04073\t    PyObject* py_V537;\n04074\t    \n04075\t        PyArrayObject* V537;\n04076\t        \n04077\t            typedef npy_float64 dtype_V537;\n04078\t            \n04079\t    PyObject* py_V539;\n04080\t    \n04081\t        PyArrayObject* V539;\n04082\t        \n04083\t            typedef npy_float64 dtype_V539;\n04084\t            \n04085\t    PyObject* py_V541;\n04086\t    \n04087\t        PyArrayObject* V541;\n04088\t        \n04089\t            typedef npy_float64 dtype_V541;\n04090\t            \n04091\t    PyObject* py_V543;\n04092\t    \n04093\t        PyArrayObject* V543;\n04094\t        \n04095\t            typedef npy_float64 dtype_V543;\n04096\t            \n04097\t    PyObject* py_V545;\n04098\t    \n04099\t        PyArrayObject* V545;\n04100\t        \n04101\t            typedef npy_float64 dtype_V545;\n04102\t            \n04103\t    PyObject* py_V547;\n04104\t    \n04105\t        PyArrayObject* V547;\n04106\t        \n04107\t            typedef npy_float64 dtype_V547;\n04108\t            \n04109\t    PyObject* py_V549;\n04110\t    \n04111\t        PyArrayObject* V549;\n04112\t        \n04113\t            typedef npy_float64 dtype_V549;\n04114\t            \n04115\t    PyObject* py_V551;\n04116\t    \n04117\t        PyArrayObject* V551;\n04118\t        \n04119\t            typedef npy_float64 dtype_V551;\n04120\t            \n04121\t    PyObject* py_V553;\n04122\t    \n04123\t        PyArrayObject* V553;\n04124\t        \n04125\t            typedef npy_float64 dtype_V553;\n04126\t            \n04127\t    PyObject* py_V555;\n04128\t    \n04129\t        PyArrayObject* V555;\n04130\t        \n04131\t            typedef npy_float64 dtype_V555;\n04132\t            \n04133\t    PyObject* py_V557;\n04134\t    \n04135\t        PyArrayObject* V557;\n04136\t        \n04137\t            typedef npy_float64 dtype_V557;\n04138\t            \n04139\t    PyObject* py_V559;\n04140\t    \n04141\t        PyArrayObject* V559;\n04142\t        \n04143\t            typedef npy_float64 dtype_V559;\n04144\t            \n04145\t    PyObject* py_V561;\n04146\t    \n04147\t        PyArrayObject* V561;\n04148\t        \n04149\t            typedef npy_float64 dtype_V561;\n04150\t            \n04151\t    PyObject* py_V563;\n04152\t    \n04153\t        PyArrayObject* V563;\n04154\t        \n04155\t            typedef npy_float64 dtype_V563;\n04156\t            \n04157\t    PyObject* py_V565;\n04158\t    \n04159\t        PyArrayObject* V565;\n04160\t        \n04161\t            typedef npy_float64 dtype_V565;\n04162\t            \n04163\t    PyObject* py_V567;\n04164\t    \n04165\t        PyArrayObject* V567;\n04166\t        \n04167\t            typedef npy_float64 dtype_V567;\n04168\t            \n04169\t    PyObject* py_V569;\n04170\t    \n04171\t        PyArrayObject* V569;\n04172\t        \n04173\t            typedef npy_float64 dtype_V569;\n04174\t            \n04175\t    PyObject* py_V571;\n04176\t    \n04177\t        PyArrayObject* V571;\n04178\t        \n04179\t            typedef npy_float64 dtype_V571;\n04180\t            \n04181\t    PyObject* py_V573;\n04182\t    \n04183\t        PyArrayObject* V573;\n04184\t        \n04185\t            typedef npy_float64 dtype_V573;\n04186\t            \n04187\t    PyObject* py_V575;\n04188\t    \n04189\t        PyArrayObject* V575;\n04190\t        \n04191\t            typedef npy_float64 dtype_V575;\n04192\t            \n04193\t    PyObject* py_V577;\n04194\t    \n04195\t        PyArrayObject* V577;\n04196\t        \n04197\t            typedef npy_float64 dtype_V577;\n04198\t            \n04199\t    PyObject* py_V579;\n04200\t    \n04201\t        PyArrayObject* V579;\n04202\t        \n04203\t            typedef npy_float64 dtype_V579;\n04204\t            \n04205\t    PyObject* py_V581;\n04206\t    \n04207\t        PyArrayObject* V581;\n04208\t        \n04209\t            typedef npy_float64 dtype_V581;\n04210\t            \n04211\t    PyObject* py_V583;\n04212\t    \n04213\t        PyArrayObject* V583;\n04214\t        \n04215\t            typedef npy_float64 dtype_V583;\n04216\t            \n04217\t    PyObject* py_V585;\n04218\t    \n04219\t        PyArrayObject* V585;\n04220\t        \n04221\t            typedef npy_float64 dtype_V585;\n04222\t            \n04223\t    PyObject* py_V587;\n04224\t    \n04225\t        PyArrayObject* V587;\n04226\t        \n04227\t            typedef npy_float64 dtype_V587;\n04228\t            \n04229\t    PyObject* py_V589;\n04230\t    \n04231\t        PyArrayObject* V589;\n04232\t        \n04233\t            typedef npy_float64 dtype_V589;\n04234\t            \n04235\t    PyObject* py_V591;\n04236\t    \n04237\t        PyArrayObject* V591;\n04238\t        \n04239\t            typedef npy_float64 dtype_V591;\n04240\t            \n04241\t    PyObject* py_V593;\n04242\t    \n04243\t        PyArrayObject* V593;\n04244\t        \n04245\t            typedef npy_float64 dtype_V593;\n04246\t            \n04247\t    PyObject* py_V595;\n04248\t    \n04249\t        PyArrayObject* V595;\n04250\t        \n04251\t            typedef npy_float64 dtype_V595;\n04252\t            \n04253\t    PyObject* py_V597;\n04254\t    \n04255\t        PyArrayObject* V597;\n04256\t        \n04257\t            typedef npy_float64 dtype_V597;\n04258\t            \n04259\t    PyObject* py_V599;\n04260\t    \n04261\t        PyArrayObject* V599;\n04262\t        \n04263\t            typedef npy_float64 dtype_V599;\n04264\t            \n04265\t    PyObject* py_V601;\n04266\t    \n04267\t        PyArrayObject* V601;\n04268\t        \n04269\t            typedef npy_float64 dtype_V601;\n04270\t            \n04271\t    PyObject* py_V603;\n04272\t    \n04273\t        PyArrayObject* V603;\n04274\t        \n04275\t            typedef npy_float64 dtype_V603;\n04276\t            \n04277\t{\n04278\t\n04279\t    py_V1 = PyList_GET_ITEM(storage_V1, 0);\n04280\t    {Py_XINCREF(py_V1);}\n04281\t    \n04282\t        if (py_V1 == Py_None)\n04283\t        {\n04284\t            \n04285\t        V1 = NULL;\n04286\t        \n04287\t        }\n04288\t        else\n04289\t        {\n04290\t            \n04291\t            V1 = NULL;\n04292\t            if (py_V1 == Py_None) {\n04293\t                // We can either fail here or set V1 to NULL and rely on Ops\n04294\t                // using tensors to handle the NULL case, but if they fail to do so\n04295\t                // they'll end up with nasty segfaults, so this is public service.\n04296\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n04297\t                {\n04298\t        __failure = 2;\n04299\t        if (!PyErr_Occurred()) {\n04300\t            PyErr_SetString(PyExc_RuntimeError,\n04301\t                \"Unexpected error in an Op's C code. \"\n04302\t                \"No Python exception was set.\");\n04303\t            }\n04304\t        goto __label_2;}\n04305\t            }\n04306\t            if (!PyArray_Check(py_V1)) {\n04307\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n04308\t                {\n04309\t        __failure = 2;\n04310\t        if (!PyErr_Occurred()) {\n04311\t            PyErr_SetString(PyExc_RuntimeError,\n04312\t                \"Unexpected error in an Op's C code. \"\n04313\t                \"No Python exception was set.\");\n04314\t            }\n04315\t        goto __label_2;}\n04316\t            }\n04317\t            // We expect NPY_FLOAT64\n04318\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V1)) {\n04319\t                PyArrayObject * tmp = (PyArrayObject*) py_V1;\n04320\t                PyErr_Format(PyExc_NotImplementedError,\n04321\t                             \"expected an aligned array of type %ld \"\n04322\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n04323\t                             \" with %ld dimensions, with 3 last dims \"\n04324\t                             \"%ld, %ld, %ld\"\n04325\t                             \" and 3 last strides %ld %ld, %ld.\",\n04326\t                             (long int) NPY_FLOAT64,\n04327\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V1),\n04328\t                             (long int) PyArray_NDIM(tmp),\n04329\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n04330\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n04331\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n04332\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n04333\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n04334\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n04335\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n04336\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n04337\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n04338\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n04339\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n04340\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n04341\t            );\n04342\t                {\n04343\t        __failure = 2;\n04344\t        if (!PyErr_Occurred()) {\n04345\t            PyErr_SetString(PyExc_RuntimeError,\n04346\t                \"Unexpected error in an Op's C code. \"\n04347\t                \"No Python exception was set.\");\n04348\t            }\n04349\t        goto __label_2;}\n04350\t            }\n04351\t            // This is a TypeError to be consistent with DEBUG_MODE\n04352\t            // Note: DEBUG_MODE also tells the name of the container\n04353\t            if (PyArray_TYPE((PyArrayObject*) py_V1) != NPY_FLOAT64) {\n04354\t                PyErr_Format(PyExc_TypeError,\n04355\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n04356\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V1));\n04357\t                {\n04358\t        __failure = 2;\n04359\t        if (!PyErr_Occurred()) {\n04360\t            PyErr_SetString(PyExc_RuntimeError,\n04361\t                \"Unexpected error in an Op's C code. \"\n04362\t                \"No Python exception was set.\");\n04363\t            }\n04364\t        goto __label_2;}\n04365\t            }\n04366\t            \n04367\t        V1 = (PyArrayObject*)(py_V1);\n04368\t        Py_XINCREF(V1);\n04369\t        \n04370\t        }\n04371\t        \n04372\t{\n04373\t\n04374\t    py_V3 = PyList_GET_ITEM(storage_V3, 0);\n04375\t    {Py_XINCREF(py_V3);}\n04376\t    \n04377\t            V3 = NULL;\n04378\t            if (py_V3 == Py_None) {\n04379\t                // We can either fail here or set V3 to NULL and rely on Ops\n04380\t                // using tensors to handle the NULL case, but if they fail to do so\n04381\t                // they'll end up with nasty segfaults, so this is public service.\n04382\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n04383\t                {\n04384\t        __failure = 4;\n04385\t        if (!PyErr_Occurred()) {\n04386\t            PyErr_SetString(PyExc_RuntimeError,\n04387\t                \"Unexpected error in an Op's C code. \"\n04388\t                \"No Python exception was set.\");\n04389\t            }\n04390\t        goto __label_4;}\n04391\t            }\n04392\t            if (!PyArray_Check(py_V3)) {\n04393\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n04394\t                {\n04395\t        __failure = 4;\n04396\t        if (!PyErr_Occurred()) {\n04397\t            PyErr_SetString(PyExc_RuntimeError,\n04398\t                \"Unexpected error in an Op's C code. \"\n04399\t                \"No Python exception was set.\");\n04400\t            }\n04401\t        goto __label_4;}\n04402\t            }\n04403\t            // We expect NPY_FLOAT64\n04404\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V3)) {\n04405\t                PyArrayObject * tmp = (PyArrayObject*) py_V3;\n04406\t                PyErr_Format(PyExc_NotImplementedError,\n04407\t                             \"expected an aligned array of type %ld \"\n04408\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n04409\t                             \" with %ld dimensions, with 3 last dims \"\n04410\t                             \"%ld, %ld, %ld\"\n04411\t                             \" and 3 last strides %ld %ld, %ld.\",\n04412\t                             (long int) NPY_FLOAT64,\n04413\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V3),\n04414\t                             (long int) PyArray_NDIM(tmp),\n04415\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n04416\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n04417\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n04418\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n04419\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n04420\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n04421\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n04422\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n04423\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n04424\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n04425\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n04426\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n04427\t            );\n04428\t                {\n04429\t        __failure = 4;\n04430\t        if (!PyErr_Occurred()) {\n04431\t            PyErr_SetString(PyExc_RuntimeError,\n04432\t                \"Unexpected error in an Op's C code. \"\n04433\t                \"No Python exception was set.\");\n04434\t            }\n04435\t        goto __label_4;}\n04436\t            }\n04437\t            // This is a TypeError to be consistent with DEBUG_MODE\n04438\t            // Note: DEBUG_MODE also tells the name of the container\n04439\t            if (PyArray_TYPE((PyArrayObject*) py_V3) != NPY_FLOAT64) {\n04440\t                PyErr_Format(PyExc_TypeError,\n04441\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n04442\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V3));\n04443\t                {\n04444\t        __failure = 4;\n04445\t        if (!PyErr_Occurred()) {\n04446\t            PyErr_SetString(PyExc_RuntimeError,\n04447\t                \"Unexpected error in an Op's C code. \"\n04448\t                \"No Python exception was set.\");\n04449\t            }\n04450\t        goto __label_4;}\n04451\t            }\n04452\t            \n04453\t        V3 = (PyArrayObject*)(py_V3);\n04454\t        Py_XINCREF(V3);\n04455\t        \n04456\t{\n04457\t\n04458\t    py_V5 = PyList_GET_ITEM(storage_V5, 0);\n04459\t    {Py_XINCREF(py_V5);}\n04460\t    \n04461\t            V5 = NULL;\n04462\t            if (py_V5 == Py_None) {\n04463\t                // We can either fail here or set V5 to NULL and rely on Ops\n04464\t                // using tensors to handle the NULL case, but if they fail to do so\n04465\t                // they'll end up with nasty segfaults, so this is public service.\n04466\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n04467\t                {\n04468\t        __failure = 6;\n04469\t        if (!PyErr_Occurred()) {\n04470\t            PyErr_SetString(PyExc_RuntimeError,\n04471\t                \"Unexpected error in an Op's C code. \"\n04472\t                \"No Python exception was set.\");\n04473\t            }\n04474\t        goto __label_6;}\n04475\t            }\n04476\t            if (!PyArray_Check(py_V5)) {\n04477\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n04478\t                {\n04479\t        __failure = 6;\n04480\t        if (!PyErr_Occurred()) {\n04481\t            PyErr_SetString(PyExc_RuntimeError,\n04482\t                \"Unexpected error in an Op's C code. \"\n04483\t                \"No Python exception was set.\");\n04484\t            }\n04485\t        goto __label_6;}\n04486\t            }\n04487\t            // We expect NPY_FLOAT64\n04488\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V5)) {\n04489\t                PyArrayObject * tmp = (PyArrayObject*) py_V5;\n04490\t                PyErr_Format(PyExc_NotImplementedError,\n04491\t                             \"expected an aligned array of type %ld \"\n04492\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n04493\t                             \" with %ld dimensions, with 3 last dims \"\n04494\t                             \"%ld, %ld, %ld\"\n04495\t                             \" and 3 last strides %ld %ld, %ld.\",\n04496\t                             (long int) NPY_FLOAT64,\n04497\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V5),\n04498\t                             (long int) PyArray_NDIM(tmp),\n04499\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n04500\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n04501\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n04502\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n04503\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n04504\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n04505\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n04506\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n04507\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n04508\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n04509\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n04510\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n04511\t            );\n04512\t                {\n04513\t        __failure = 6;\n04514\t        if (!PyErr_Occurred()) {\n04515\t            PyErr_SetString(PyExc_RuntimeError,\n04516\t                \"Unexpected error in an Op's C code. \"\n04517\t                \"No Python exception was set.\");\n04518\t            }\n04519\t        goto __label_6;}\n04520\t            }\n04521\t            // This is a TypeError to be consistent with DEBUG_MODE\n04522\t            // Note: DEBUG_MODE also tells the name of the container\n04523\t            if (PyArray_TYPE((PyArrayObject*) py_V5) != NPY_FLOAT64) {\n04524\t                PyErr_Format(PyExc_TypeError,\n04525\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n04526\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V5));\n04527\t                {\n04528\t        __failure = 6;\n04529\t        if (!PyErr_Occurred()) {\n04530\t            PyErr_SetString(PyExc_RuntimeError,\n04531\t                \"Unexpected error in an Op's C code. \"\n04532\t                \"No Python exception was set.\");\n04533\t            }\n04534\t        goto __label_6;}\n04535\t            }\n04536\t            \n04537\t        V5 = (PyArrayObject*)(py_V5);\n04538\t        Py_XINCREF(V5);\n04539\t        \n04540\t{\n04541\t\n04542\t    py_V7 = PyList_GET_ITEM(storage_V7, 0);\n04543\t    {Py_XINCREF(py_V7);}\n04544\t    \n04545\t            V7 = NULL;\n04546\t            if (py_V7 == Py_None) {\n04547\t                // We can either fail here or set V7 to NULL and rely on Ops\n04548\t                // using tensors to handle the NULL case, but if they fail to do so\n04549\t                // they'll end up with nasty segfaults, so this is public service.\n04550\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n04551\t                {\n04552\t        __failure = 8;\n04553\t        if (!PyErr_Occurred()) {\n04554\t            PyErr_SetString(PyExc_RuntimeError,\n04555\t                \"Unexpected error in an Op's C code. \"\n04556\t                \"No Python exception was set.\");\n04557\t            }\n04558\t        goto __label_8;}\n04559\t            }\n04560\t            if (!PyArray_Check(py_V7)) {\n04561\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n04562\t                {\n04563\t        __failure = 8;\n04564\t        if (!PyErr_Occurred()) {\n04565\t            PyErr_SetString(PyExc_RuntimeError,\n04566\t                \"Unexpected error in an Op's C code. \"\n04567\t                \"No Python exception was set.\");\n04568\t            }\n04569\t        goto __label_8;}\n04570\t            }\n04571\t            // We expect NPY_FLOAT64\n04572\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V7)) {\n04573\t                PyArrayObject * tmp = (PyArrayObject*) py_V7;\n04574\t                PyErr_Format(PyExc_NotImplementedError,\n04575\t                             \"expected an aligned array of type %ld \"\n04576\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n04577\t                             \" with %ld dimensions, with 3 last dims \"\n04578\t                             \"%ld, %ld, %ld\"\n04579\t                             \" and 3 last strides %ld %ld, %ld.\",\n04580\t                             (long int) NPY_FLOAT64,\n04581\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V7),\n04582\t                             (long int) PyArray_NDIM(tmp),\n04583\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n04584\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n04585\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n04586\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n04587\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n04588\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n04589\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n04590\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n04591\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n04592\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n04593\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n04594\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n04595\t            );\n04596\t                {\n04597\t        __failure = 8;\n04598\t        if (!PyErr_Occurred()) {\n04599\t            PyErr_SetString(PyExc_RuntimeError,\n04600\t                \"Unexpected error in an Op's C code. \"\n04601\t                \"No Python exception was set.\");\n04602\t            }\n04603\t        goto __label_8;}\n04604\t            }\n04605\t            // This is a TypeError to be consistent with DEBUG_MODE\n04606\t            // Note: DEBUG_MODE also tells the name of the container\n04607\t            if (PyArray_TYPE((PyArrayObject*) py_V7) != NPY_FLOAT64) {\n04608\t                PyErr_Format(PyExc_TypeError,\n04609\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n04610\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V7));\n04611\t                {\n04612\t        __failure = 8;\n04613\t        if (!PyErr_Occurred()) {\n04614\t            PyErr_SetString(PyExc_RuntimeError,\n04615\t                \"Unexpected error in an Op's C code. \"\n04616\t                \"No Python exception was set.\");\n04617\t            }\n04618\t        goto __label_8;}\n04619\t            }\n04620\t            \n04621\t        V7 = (PyArrayObject*)(py_V7);\n04622\t        Py_XINCREF(V7);\n04623\t        \n04624\t{\n04625\t\n04626\t    py_V9 = PyList_GET_ITEM(storage_V9, 0);\n04627\t    {Py_XINCREF(py_V9);}\n04628\t    \n04629\t            V9 = NULL;\n04630\t            if (py_V9 == Py_None) {\n04631\t                // We can either fail here or set V9 to NULL and rely on Ops\n04632\t                // using tensors to handle the NULL case, but if they fail to do so\n04633\t                // they'll end up with nasty segfaults, so this is public service.\n04634\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n04635\t                {\n04636\t        __failure = 10;\n04637\t        if (!PyErr_Occurred()) {\n04638\t            PyErr_SetString(PyExc_RuntimeError,\n04639\t                \"Unexpected error in an Op's C code. \"\n04640\t                \"No Python exception was set.\");\n04641\t            }\n04642\t        goto __label_10;}\n04643\t            }\n04644\t            if (!PyArray_Check(py_V9)) {\n04645\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n04646\t                {\n04647\t        __failure = 10;\n04648\t        if (!PyErr_Occurred()) {\n04649\t            PyErr_SetString(PyExc_RuntimeError,\n04650\t                \"Unexpected error in an Op's C code. \"\n04651\t                \"No Python exception was set.\");\n04652\t            }\n04653\t        goto __label_10;}\n04654\t            }\n04655\t            // We expect NPY_FLOAT64\n04656\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V9)) {\n04657\t                PyArrayObject * tmp = (PyArrayObject*) py_V9;\n04658\t                PyErr_Format(PyExc_NotImplementedError,\n04659\t                             \"expected an aligned array of type %ld \"\n04660\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n04661\t                             \" with %ld dimensions, with 3 last dims \"\n04662\t                             \"%ld, %ld, %ld\"\n04663\t                             \" and 3 last strides %ld %ld, %ld.\",\n04664\t                             (long int) NPY_FLOAT64,\n04665\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V9),\n04666\t                             (long int) PyArray_NDIM(tmp),\n04667\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n04668\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n04669\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n04670\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n04671\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n04672\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n04673\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n04674\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n04675\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n04676\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n04677\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n04678\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n04679\t            );\n04680\t                {\n04681\t        __failure = 10;\n04682\t        if (!PyErr_Occurred()) {\n04683\t            PyErr_SetString(PyExc_RuntimeError,\n04684\t                \"Unexpected error in an Op's C code. \"\n04685\t                \"No Python exception was set.\");\n04686\t            }\n04687\t        goto __label_10;}\n04688\t            }\n04689\t            // This is a TypeError to be consistent with DEBUG_MODE\n04690\t            // Note: DEBUG_MODE also tells the name of the container\n04691\t            if (PyArray_TYPE((PyArrayObject*) py_V9) != NPY_FLOAT64) {\n04692\t                PyErr_Format(PyExc_TypeError,\n04693\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n04694\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V9));\n04695\t                {\n04696\t        __failure = 10;\n04697\t        if (!PyErr_Occurred()) {\n04698\t            PyErr_SetString(PyExc_RuntimeError,\n04699\t                \"Unexpected error in an Op's C code. \"\n04700\t                \"No Python exception was set.\");\n04701\t            }\n04702\t        goto __label_10;}\n04703\t            }\n04704\t            \n04705\t        V9 = (PyArrayObject*)(py_V9);\n04706\t        Py_XINCREF(V9);\n04707\t        \n04708\t{\n04709\t\n04710\t    py_V11 = PyList_GET_ITEM(storage_V11, 0);\n04711\t    {Py_XINCREF(py_V11);}\n04712\t    \n04713\t            V11 = NULL;\n04714\t            if (py_V11 == Py_None) {\n04715\t                // We can either fail here or set V11 to NULL and rely on Ops\n04716\t                // using tensors to handle the NULL case, but if they fail to do so\n04717\t                // they'll end up with nasty segfaults, so this is public service.\n04718\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n04719\t                {\n04720\t        __failure = 12;\n04721\t        if (!PyErr_Occurred()) {\n04722\t            PyErr_SetString(PyExc_RuntimeError,\n04723\t                \"Unexpected error in an Op's C code. \"\n04724\t                \"No Python exception was set.\");\n04725\t            }\n04726\t        goto __label_12;}\n04727\t            }\n04728\t            if (!PyArray_Check(py_V11)) {\n04729\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n04730\t                {\n04731\t        __failure = 12;\n04732\t        if (!PyErr_Occurred()) {\n04733\t            PyErr_SetString(PyExc_RuntimeError,\n04734\t                \"Unexpected error in an Op's C code. \"\n04735\t                \"No Python exception was set.\");\n04736\t            }\n04737\t        goto __label_12;}\n04738\t            }\n04739\t            // We expect NPY_FLOAT64\n04740\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V11)) {\n04741\t                PyArrayObject * tmp = (PyArrayObject*) py_V11;\n04742\t                PyErr_Format(PyExc_NotImplementedError,\n04743\t                             \"expected an aligned array of type %ld \"\n04744\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n04745\t                             \" with %ld dimensions, with 3 last dims \"\n04746\t                             \"%ld, %ld, %ld\"\n04747\t                             \" and 3 last strides %ld %ld, %ld.\",\n04748\t                             (long int) NPY_FLOAT64,\n04749\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V11),\n04750\t                             (long int) PyArray_NDIM(tmp),\n04751\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n04752\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n04753\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n04754\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n04755\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n04756\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n04757\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n04758\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n04759\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n04760\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n04761\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n04762\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n04763\t            );\n04764\t                {\n04765\t        __failure = 12;\n04766\t        if (!PyErr_Occurred()) {\n04767\t            PyErr_SetString(PyExc_RuntimeError,\n04768\t                \"Unexpected error in an Op's C code. \"\n04769\t                \"No Python exception was set.\");\n04770\t            }\n04771\t        goto __label_12;}\n04772\t            }\n04773\t            // This is a TypeError to be consistent with DEBUG_MODE\n04774\t            // Note: DEBUG_MODE also tells the name of the container\n04775\t            if (PyArray_TYPE((PyArrayObject*) py_V11) != NPY_FLOAT64) {\n04776\t                PyErr_Format(PyExc_TypeError,\n04777\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n04778\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V11));\n04779\t                {\n04780\t        __failure = 12;\n04781\t        if (!PyErr_Occurred()) {\n04782\t            PyErr_SetString(PyExc_RuntimeError,\n04783\t                \"Unexpected error in an Op's C code. \"\n04784\t                \"No Python exception was set.\");\n04785\t            }\n04786\t        goto __label_12;}\n04787\t            }\n04788\t            \n04789\t        V11 = (PyArrayObject*)(py_V11);\n04790\t        Py_XINCREF(V11);\n04791\t        \n04792\t{\n04793\t\n04794\t    py_V13 = PyList_GET_ITEM(storage_V13, 0);\n04795\t    {Py_XINCREF(py_V13);}\n04796\t    \n04797\t            V13 = NULL;\n04798\t            if (py_V13 == Py_None) {\n04799\t                // We can either fail here or set V13 to NULL and rely on Ops\n04800\t                // using tensors to handle the NULL case, but if they fail to do so\n04801\t                // they'll end up with nasty segfaults, so this is public service.\n04802\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n04803\t                {\n04804\t        __failure = 14;\n04805\t        if (!PyErr_Occurred()) {\n04806\t            PyErr_SetString(PyExc_RuntimeError,\n04807\t                \"Unexpected error in an Op's C code. \"\n04808\t                \"No Python exception was set.\");\n04809\t            }\n04810\t        goto __label_14;}\n04811\t            }\n04812\t            if (!PyArray_Check(py_V13)) {\n04813\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n04814\t                {\n04815\t        __failure = 14;\n04816\t        if (!PyErr_Occurred()) {\n04817\t            PyErr_SetString(PyExc_RuntimeError,\n04818\t                \"Unexpected error in an Op's C code. \"\n04819\t                \"No Python exception was set.\");\n04820\t            }\n04821\t        goto __label_14;}\n04822\t            }\n04823\t            // We expect NPY_FLOAT64\n04824\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V13)) {\n04825\t                PyArrayObject * tmp = (PyArrayObject*) py_V13;\n04826\t                PyErr_Format(PyExc_NotImplementedError,\n04827\t                             \"expected an aligned array of type %ld \"\n04828\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n04829\t                             \" with %ld dimensions, with 3 last dims \"\n04830\t                             \"%ld, %ld, %ld\"\n04831\t                             \" and 3 last strides %ld %ld, %ld.\",\n04832\t                             (long int) NPY_FLOAT64,\n04833\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V13),\n04834\t                             (long int) PyArray_NDIM(tmp),\n04835\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n04836\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n04837\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n04838\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n04839\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n04840\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n04841\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n04842\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n04843\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n04844\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n04845\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n04846\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n04847\t            );\n04848\t                {\n04849\t        __failure = 14;\n04850\t        if (!PyErr_Occurred()) {\n04851\t            PyErr_SetString(PyExc_RuntimeError,\n04852\t                \"Unexpected error in an Op's C code. \"\n04853\t                \"No Python exception was set.\");\n04854\t            }\n04855\t        goto __label_14;}\n04856\t            }\n04857\t            // This is a TypeError to be consistent with DEBUG_MODE\n04858\t            // Note: DEBUG_MODE also tells the name of the container\n04859\t            if (PyArray_TYPE((PyArrayObject*) py_V13) != NPY_FLOAT64) {\n04860\t                PyErr_Format(PyExc_TypeError,\n04861\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n04862\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V13));\n04863\t                {\n04864\t        __failure = 14;\n04865\t        if (!PyErr_Occurred()) {\n04866\t            PyErr_SetString(PyExc_RuntimeError,\n04867\t                \"Unexpected error in an Op's C code. \"\n04868\t                \"No Python exception was set.\");\n04869\t            }\n04870\t        goto __label_14;}\n04871\t            }\n04872\t            \n04873\t        V13 = (PyArrayObject*)(py_V13);\n04874\t        Py_XINCREF(V13);\n04875\t        \n04876\t{\n04877\t\n04878\t    py_V15 = PyList_GET_ITEM(storage_V15, 0);\n04879\t    {Py_XINCREF(py_V15);}\n04880\t    \n04881\t            V15 = NULL;\n04882\t            if (py_V15 == Py_None) {\n04883\t                // We can either fail here or set V15 to NULL and rely on Ops\n04884\t                // using tensors to handle the NULL case, but if they fail to do so\n04885\t                // they'll end up with nasty segfaults, so this is public service.\n04886\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n04887\t                {\n04888\t        __failure = 16;\n04889\t        if (!PyErr_Occurred()) {\n04890\t            PyErr_SetString(PyExc_RuntimeError,\n04891\t                \"Unexpected error in an Op's C code. \"\n04892\t                \"No Python exception was set.\");\n04893\t            }\n04894\t        goto __label_16;}\n04895\t            }\n04896\t            if (!PyArray_Check(py_V15)) {\n04897\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n04898\t                {\n04899\t        __failure = 16;\n04900\t        if (!PyErr_Occurred()) {\n04901\t            PyErr_SetString(PyExc_RuntimeError,\n04902\t                \"Unexpected error in an Op's C code. \"\n04903\t                \"No Python exception was set.\");\n04904\t            }\n04905\t        goto __label_16;}\n04906\t            }\n04907\t            // We expect NPY_FLOAT64\n04908\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V15)) {\n04909\t                PyArrayObject * tmp = (PyArrayObject*) py_V15;\n04910\t                PyErr_Format(PyExc_NotImplementedError,\n04911\t                             \"expected an aligned array of type %ld \"\n04912\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n04913\t                             \" with %ld dimensions, with 3 last dims \"\n04914\t                             \"%ld, %ld, %ld\"\n04915\t                             \" and 3 last strides %ld %ld, %ld.\",\n04916\t                             (long int) NPY_FLOAT64,\n04917\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V15),\n04918\t                             (long int) PyArray_NDIM(tmp),\n04919\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n04920\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n04921\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n04922\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n04923\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n04924\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n04925\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n04926\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n04927\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n04928\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n04929\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n04930\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n04931\t            );\n04932\t                {\n04933\t        __failure = 16;\n04934\t        if (!PyErr_Occurred()) {\n04935\t            PyErr_SetString(PyExc_RuntimeError,\n04936\t                \"Unexpected error in an Op's C code. \"\n04937\t                \"No Python exception was set.\");\n04938\t            }\n04939\t        goto __label_16;}\n04940\t            }\n04941\t            // This is a TypeError to be consistent with DEBUG_MODE\n04942\t            // Note: DEBUG_MODE also tells the name of the container\n04943\t            if (PyArray_TYPE((PyArrayObject*) py_V15) != NPY_FLOAT64) {\n04944\t                PyErr_Format(PyExc_TypeError,\n04945\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n04946\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V15));\n04947\t                {\n04948\t        __failure = 16;\n04949\t        if (!PyErr_Occurred()) {\n04950\t            PyErr_SetString(PyExc_RuntimeError,\n04951\t                \"Unexpected error in an Op's C code. \"\n04952\t                \"No Python exception was set.\");\n04953\t            }\n04954\t        goto __label_16;}\n04955\t            }\n04956\t            \n04957\t        V15 = (PyArrayObject*)(py_V15);\n04958\t        Py_XINCREF(V15);\n04959\t        \n04960\t{\n04961\t\n04962\t    py_V17 = PyList_GET_ITEM(storage_V17, 0);\n04963\t    {Py_XINCREF(py_V17);}\n04964\t    \n04965\t            V17 = NULL;\n04966\t            if (py_V17 == Py_None) {\n04967\t                // We can either fail here or set V17 to NULL and rely on Ops\n04968\t                // using tensors to handle the NULL case, but if they fail to do so\n04969\t                // they'll end up with nasty segfaults, so this is public service.\n04970\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n04971\t                {\n04972\t        __failure = 18;\n04973\t        if (!PyErr_Occurred()) {\n04974\t            PyErr_SetString(PyExc_RuntimeError,\n04975\t                \"Unexpected error in an Op's C code. \"\n04976\t                \"No Python exception was set.\");\n04977\t            }\n04978\t        goto __label_18;}\n04979\t            }\n04980\t            if (!PyArray_Check(py_V17)) {\n04981\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n04982\t                {\n04983\t        __failure = 18;\n04984\t        if (!PyErr_Occurred()) {\n04985\t            PyErr_SetString(PyExc_RuntimeError,\n04986\t                \"Unexpected error in an Op's C code. \"\n04987\t                \"No Python exception was set.\");\n04988\t            }\n04989\t        goto __label_18;}\n04990\t            }\n04991\t            // We expect NPY_FLOAT64\n04992\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V17)) {\n04993\t                PyArrayObject * tmp = (PyArrayObject*) py_V17;\n04994\t                PyErr_Format(PyExc_NotImplementedError,\n04995\t                             \"expected an aligned array of type %ld \"\n04996\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n04997\t                             \" with %ld dimensions, with 3 last dims \"\n04998\t                             \"%ld, %ld, %ld\"\n04999\t                             \" and 3 last strides %ld %ld, %ld.\",\n05000\t                             (long int) NPY_FLOAT64,\n05001\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V17),\n05002\t                             (long int) PyArray_NDIM(tmp),\n05003\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n05004\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n05005\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n05006\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n05007\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n05008\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n05009\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n05010\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n05011\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n05012\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n05013\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n05014\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n05015\t            );\n05016\t                {\n05017\t        __failure = 18;\n05018\t        if (!PyErr_Occurred()) {\n05019\t            PyErr_SetString(PyExc_RuntimeError,\n05020\t                \"Unexpected error in an Op's C code. \"\n05021\t                \"No Python exception was set.\");\n05022\t            }\n05023\t        goto __label_18;}\n05024\t            }\n05025\t            // This is a TypeError to be consistent with DEBUG_MODE\n05026\t            // Note: DEBUG_MODE also tells the name of the container\n05027\t            if (PyArray_TYPE((PyArrayObject*) py_V17) != NPY_FLOAT64) {\n05028\t                PyErr_Format(PyExc_TypeError,\n05029\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n05030\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V17));\n05031\t                {\n05032\t        __failure = 18;\n05033\t        if (!PyErr_Occurred()) {\n05034\t            PyErr_SetString(PyExc_RuntimeError,\n05035\t                \"Unexpected error in an Op's C code. \"\n05036\t                \"No Python exception was set.\");\n05037\t            }\n05038\t        goto __label_18;}\n05039\t            }\n05040\t            \n05041\t        V17 = (PyArrayObject*)(py_V17);\n05042\t        Py_XINCREF(V17);\n05043\t        \n05044\t{\n05045\t\n05046\t    py_V19 = PyList_GET_ITEM(storage_V19, 0);\n05047\t    {Py_XINCREF(py_V19);}\n05048\t    \n05049\t            V19 = NULL;\n05050\t            if (py_V19 == Py_None) {\n05051\t                // We can either fail here or set V19 to NULL and rely on Ops\n05052\t                // using tensors to handle the NULL case, but if they fail to do so\n05053\t                // they'll end up with nasty segfaults, so this is public service.\n05054\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n05055\t                {\n05056\t        __failure = 20;\n05057\t        if (!PyErr_Occurred()) {\n05058\t            PyErr_SetString(PyExc_RuntimeError,\n05059\t                \"Unexpected error in an Op's C code. \"\n05060\t                \"No Python exception was set.\");\n05061\t            }\n05062\t        goto __label_20;}\n05063\t            }\n05064\t            if (!PyArray_Check(py_V19)) {\n05065\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n05066\t                {\n05067\t        __failure = 20;\n05068\t        if (!PyErr_Occurred()) {\n05069\t            PyErr_SetString(PyExc_RuntimeError,\n05070\t                \"Unexpected error in an Op's C code. \"\n05071\t                \"No Python exception was set.\");\n05072\t            }\n05073\t        goto __label_20;}\n05074\t            }\n05075\t            // We expect NPY_FLOAT64\n05076\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V19)) {\n05077\t                PyArrayObject * tmp = (PyArrayObject*) py_V19;\n05078\t                PyErr_Format(PyExc_NotImplementedError,\n05079\t                             \"expected an aligned array of type %ld \"\n05080\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n05081\t                             \" with %ld dimensions, with 3 last dims \"\n05082\t                             \"%ld, %ld, %ld\"\n05083\t                             \" and 3 last strides %ld %ld, %ld.\",\n05084\t                             (long int) NPY_FLOAT64,\n05085\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V19),\n05086\t                             (long int) PyArray_NDIM(tmp),\n05087\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n05088\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n05089\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n05090\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n05091\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n05092\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n05093\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n05094\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n05095\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n05096\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n05097\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n05098\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n05099\t            );\n05100\t                {\n05101\t        __failure = 20;\n05102\t        if (!PyErr_Occurred()) {\n05103\t            PyErr_SetString(PyExc_RuntimeError,\n05104\t                \"Unexpected error in an Op's C code. \"\n05105\t                \"No Python exception was set.\");\n05106\t            }\n05107\t        goto __label_20;}\n05108\t            }\n05109\t            // This is a TypeError to be consistent with DEBUG_MODE\n05110\t            // Note: DEBUG_MODE also tells the name of the container\n05111\t            if (PyArray_TYPE((PyArrayObject*) py_V19) != NPY_FLOAT64) {\n05112\t                PyErr_Format(PyExc_TypeError,\n05113\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n05114\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V19));\n05115\t                {\n05116\t        __failure = 20;\n05117\t        if (!PyErr_Occurred()) {\n05118\t            PyErr_SetString(PyExc_RuntimeError,\n05119\t                \"Unexpected error in an Op's C code. \"\n05120\t                \"No Python exception was set.\");\n05121\t            }\n05122\t        goto __label_20;}\n05123\t            }\n05124\t            \n05125\t        V19 = (PyArrayObject*)(py_V19);\n05126\t        Py_XINCREF(V19);\n05127\t        \n05128\t{\n05129\t\n05130\t    py_V21 = PyList_GET_ITEM(storage_V21, 0);\n05131\t    {Py_XINCREF(py_V21);}\n05132\t    \n05133\t            V21 = NULL;\n05134\t            if (py_V21 == Py_None) {\n05135\t                // We can either fail here or set V21 to NULL and rely on Ops\n05136\t                // using tensors to handle the NULL case, but if they fail to do so\n05137\t                // they'll end up with nasty segfaults, so this is public service.\n05138\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n05139\t                {\n05140\t        __failure = 22;\n05141\t        if (!PyErr_Occurred()) {\n05142\t            PyErr_SetString(PyExc_RuntimeError,\n05143\t                \"Unexpected error in an Op's C code. \"\n05144\t                \"No Python exception was set.\");\n05145\t            }\n05146\t        goto __label_22;}\n05147\t            }\n05148\t            if (!PyArray_Check(py_V21)) {\n05149\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n05150\t                {\n05151\t        __failure = 22;\n05152\t        if (!PyErr_Occurred()) {\n05153\t            PyErr_SetString(PyExc_RuntimeError,\n05154\t                \"Unexpected error in an Op's C code. \"\n05155\t                \"No Python exception was set.\");\n05156\t            }\n05157\t        goto __label_22;}\n05158\t            }\n05159\t            // We expect NPY_FLOAT64\n05160\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V21)) {\n05161\t                PyArrayObject * tmp = (PyArrayObject*) py_V21;\n05162\t                PyErr_Format(PyExc_NotImplementedError,\n05163\t                             \"expected an aligned array of type %ld \"\n05164\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n05165\t                             \" with %ld dimensions, with 3 last dims \"\n05166\t                             \"%ld, %ld, %ld\"\n05167\t                             \" and 3 last strides %ld %ld, %ld.\",\n05168\t                             (long int) NPY_FLOAT64,\n05169\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V21),\n05170\t                             (long int) PyArray_NDIM(tmp),\n05171\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n05172\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n05173\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n05174\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n05175\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n05176\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n05177\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n05178\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n05179\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n05180\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n05181\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n05182\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n05183\t            );\n05184\t                {\n05185\t        __failure = 22;\n05186\t        if (!PyErr_Occurred()) {\n05187\t            PyErr_SetString(PyExc_RuntimeError,\n05188\t                \"Unexpected error in an Op's C code. \"\n05189\t                \"No Python exception was set.\");\n05190\t            }\n05191\t        goto __label_22;}\n05192\t            }\n05193\t            // This is a TypeError to be consistent with DEBUG_MODE\n05194\t            // Note: DEBUG_MODE also tells the name of the container\n05195\t            if (PyArray_TYPE((PyArrayObject*) py_V21) != NPY_FLOAT64) {\n05196\t                PyErr_Format(PyExc_TypeError,\n05197\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n05198\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V21));\n05199\t                {\n05200\t        __failure = 22;\n05201\t        if (!PyErr_Occurred()) {\n05202\t            PyErr_SetString(PyExc_RuntimeError,\n05203\t                \"Unexpected error in an Op's C code. \"\n05204\t                \"No Python exception was set.\");\n05205\t            }\n05206\t        goto __label_22;}\n05207\t            }\n05208\t            \n05209\t        V21 = (PyArrayObject*)(py_V21);\n05210\t        Py_XINCREF(V21);\n05211\t        \n05212\t{\n05213\t\n05214\t    py_V23 = PyList_GET_ITEM(storage_V23, 0);\n05215\t    {Py_XINCREF(py_V23);}\n05216\t    \n05217\t            V23 = NULL;\n05218\t            if (py_V23 == Py_None) {\n05219\t                // We can either fail here or set V23 to NULL and rely on Ops\n05220\t                // using tensors to handle the NULL case, but if they fail to do so\n05221\t                // they'll end up with nasty segfaults, so this is public service.\n05222\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n05223\t                {\n05224\t        __failure = 24;\n05225\t        if (!PyErr_Occurred()) {\n05226\t            PyErr_SetString(PyExc_RuntimeError,\n05227\t                \"Unexpected error in an Op's C code. \"\n05228\t                \"No Python exception was set.\");\n05229\t            }\n05230\t        goto __label_24;}\n05231\t            }\n05232\t            if (!PyArray_Check(py_V23)) {\n05233\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n05234\t                {\n05235\t        __failure = 24;\n05236\t        if (!PyErr_Occurred()) {\n05237\t            PyErr_SetString(PyExc_RuntimeError,\n05238\t                \"Unexpected error in an Op's C code. \"\n05239\t                \"No Python exception was set.\");\n05240\t            }\n05241\t        goto __label_24;}\n05242\t            }\n05243\t            // We expect NPY_FLOAT64\n05244\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V23)) {\n05245\t                PyArrayObject * tmp = (PyArrayObject*) py_V23;\n05246\t                PyErr_Format(PyExc_NotImplementedError,\n05247\t                             \"expected an aligned array of type %ld \"\n05248\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n05249\t                             \" with %ld dimensions, with 3 last dims \"\n05250\t                             \"%ld, %ld, %ld\"\n05251\t                             \" and 3 last strides %ld %ld, %ld.\",\n05252\t                             (long int) NPY_FLOAT64,\n05253\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V23),\n05254\t                             (long int) PyArray_NDIM(tmp),\n05255\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n05256\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n05257\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n05258\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n05259\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n05260\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n05261\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n05262\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n05263\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n05264\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n05265\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n05266\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n05267\t            );\n05268\t                {\n05269\t        __failure = 24;\n05270\t        if (!PyErr_Occurred()) {\n05271\t            PyErr_SetString(PyExc_RuntimeError,\n05272\t                \"Unexpected error in an Op's C code. \"\n05273\t                \"No Python exception was set.\");\n05274\t            }\n05275\t        goto __label_24;}\n05276\t            }\n05277\t            // This is a TypeError to be consistent with DEBUG_MODE\n05278\t            // Note: DEBUG_MODE also tells the name of the container\n05279\t            if (PyArray_TYPE((PyArrayObject*) py_V23) != NPY_FLOAT64) {\n05280\t                PyErr_Format(PyExc_TypeError,\n05281\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n05282\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V23));\n05283\t                {\n05284\t        __failure = 24;\n05285\t        if (!PyErr_Occurred()) {\n05286\t            PyErr_SetString(PyExc_RuntimeError,\n05287\t                \"Unexpected error in an Op's C code. \"\n05288\t                \"No Python exception was set.\");\n05289\t            }\n05290\t        goto __label_24;}\n05291\t            }\n05292\t            \n05293\t        V23 = (PyArrayObject*)(py_V23);\n05294\t        Py_XINCREF(V23);\n05295\t        \n05296\t{\n05297\t\n05298\t    py_V25 = PyList_GET_ITEM(storage_V25, 0);\n05299\t    {Py_XINCREF(py_V25);}\n05300\t    \n05301\t            V25 = NULL;\n05302\t            if (py_V25 == Py_None) {\n05303\t                // We can either fail here or set V25 to NULL and rely on Ops\n05304\t                // using tensors to handle the NULL case, but if they fail to do so\n05305\t                // they'll end up with nasty segfaults, so this is public service.\n05306\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n05307\t                {\n05308\t        __failure = 26;\n05309\t        if (!PyErr_Occurred()) {\n05310\t            PyErr_SetString(PyExc_RuntimeError,\n05311\t                \"Unexpected error in an Op's C code. \"\n05312\t                \"No Python exception was set.\");\n05313\t            }\n05314\t        goto __label_26;}\n05315\t            }\n05316\t            if (!PyArray_Check(py_V25)) {\n05317\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n05318\t                {\n05319\t        __failure = 26;\n05320\t        if (!PyErr_Occurred()) {\n05321\t            PyErr_SetString(PyExc_RuntimeError,\n05322\t                \"Unexpected error in an Op's C code. \"\n05323\t                \"No Python exception was set.\");\n05324\t            }\n05325\t        goto __label_26;}\n05326\t            }\n05327\t            // We expect NPY_FLOAT64\n05328\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V25)) {\n05329\t                PyArrayObject * tmp = (PyArrayObject*) py_V25;\n05330\t                PyErr_Format(PyExc_NotImplementedError,\n05331\t                             \"expected an aligned array of type %ld \"\n05332\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n05333\t                             \" with %ld dimensions, with 3 last dims \"\n05334\t                             \"%ld, %ld, %ld\"\n05335\t                             \" and 3 last strides %ld %ld, %ld.\",\n05336\t                             (long int) NPY_FLOAT64,\n05337\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V25),\n05338\t                             (long int) PyArray_NDIM(tmp),\n05339\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n05340\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n05341\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n05342\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n05343\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n05344\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n05345\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n05346\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n05347\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n05348\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n05349\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n05350\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n05351\t            );\n05352\t                {\n05353\t        __failure = 26;\n05354\t        if (!PyErr_Occurred()) {\n05355\t            PyErr_SetString(PyExc_RuntimeError,\n05356\t                \"Unexpected error in an Op's C code. \"\n05357\t                \"No Python exception was set.\");\n05358\t            }\n05359\t        goto __label_26;}\n05360\t            }\n05361\t            // This is a TypeError to be consistent with DEBUG_MODE\n05362\t            // Note: DEBUG_MODE also tells the name of the container\n05363\t            if (PyArray_TYPE((PyArrayObject*) py_V25) != NPY_FLOAT64) {\n05364\t                PyErr_Format(PyExc_TypeError,\n05365\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n05366\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V25));\n05367\t                {\n05368\t        __failure = 26;\n05369\t        if (!PyErr_Occurred()) {\n05370\t            PyErr_SetString(PyExc_RuntimeError,\n05371\t                \"Unexpected error in an Op's C code. \"\n05372\t                \"No Python exception was set.\");\n05373\t            }\n05374\t        goto __label_26;}\n05375\t            }\n05376\t            \n05377\t        V25 = (PyArrayObject*)(py_V25);\n05378\t        Py_XINCREF(V25);\n05379\t        \n05380\t{\n05381\t\n05382\t    py_V27 = PyList_GET_ITEM(storage_V27, 0);\n05383\t    {Py_XINCREF(py_V27);}\n05384\t    \n05385\t            V27 = NULL;\n05386\t            if (py_V27 == Py_None) {\n05387\t                // We can either fail here or set V27 to NULL and rely on Ops\n05388\t                // using tensors to handle the NULL case, but if they fail to do so\n05389\t                // they'll end up with nasty segfaults, so this is public service.\n05390\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n05391\t                {\n05392\t        __failure = 28;\n05393\t        if (!PyErr_Occurred()) {\n05394\t            PyErr_SetString(PyExc_RuntimeError,\n05395\t                \"Unexpected error in an Op's C code. \"\n05396\t                \"No Python exception was set.\");\n05397\t            }\n05398\t        goto __label_28;}\n05399\t            }\n05400\t            if (!PyArray_Check(py_V27)) {\n05401\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n05402\t                {\n05403\t        __failure = 28;\n05404\t        if (!PyErr_Occurred()) {\n05405\t            PyErr_SetString(PyExc_RuntimeError,\n05406\t                \"Unexpected error in an Op's C code. \"\n05407\t                \"No Python exception was set.\");\n05408\t            }\n05409\t        goto __label_28;}\n05410\t            }\n05411\t            // We expect NPY_FLOAT64\n05412\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V27)) {\n05413\t                PyArrayObject * tmp = (PyArrayObject*) py_V27;\n05414\t                PyErr_Format(PyExc_NotImplementedError,\n05415\t                             \"expected an aligned array of type %ld \"\n05416\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n05417\t                             \" with %ld dimensions, with 3 last dims \"\n05418\t                             \"%ld, %ld, %ld\"\n05419\t                             \" and 3 last strides %ld %ld, %ld.\",\n05420\t                             (long int) NPY_FLOAT64,\n05421\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V27),\n05422\t                             (long int) PyArray_NDIM(tmp),\n05423\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n05424\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n05425\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n05426\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n05427\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n05428\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n05429\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n05430\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n05431\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n05432\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n05433\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n05434\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n05435\t            );\n05436\t                {\n05437\t        __failure = 28;\n05438\t        if (!PyErr_Occurred()) {\n05439\t            PyErr_SetString(PyExc_RuntimeError,\n05440\t                \"Unexpected error in an Op's C code. \"\n05441\t                \"No Python exception was set.\");\n05442\t            }\n05443\t        goto __label_28;}\n05444\t            }\n05445\t            // This is a TypeError to be consistent with DEBUG_MODE\n05446\t            // Note: DEBUG_MODE also tells the name of the container\n05447\t            if (PyArray_TYPE((PyArrayObject*) py_V27) != NPY_FLOAT64) {\n05448\t                PyErr_Format(PyExc_TypeError,\n05449\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n05450\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V27));\n05451\t                {\n05452\t        __failure = 28;\n05453\t        if (!PyErr_Occurred()) {\n05454\t            PyErr_SetString(PyExc_RuntimeError,\n05455\t                \"Unexpected error in an Op's C code. \"\n05456\t                \"No Python exception was set.\");\n05457\t            }\n05458\t        goto __label_28;}\n05459\t            }\n05460\t            \n05461\t        V27 = (PyArrayObject*)(py_V27);\n05462\t        Py_XINCREF(V27);\n05463\t        \n05464\t{\n05465\t\n05466\t    py_V29 = PyList_GET_ITEM(storage_V29, 0);\n05467\t    {Py_XINCREF(py_V29);}\n05468\t    \n05469\t            V29 = NULL;\n05470\t            if (py_V29 == Py_None) {\n05471\t                // We can either fail here or set V29 to NULL and rely on Ops\n05472\t                // using tensors to handle the NULL case, but if they fail to do so\n05473\t                // they'll end up with nasty segfaults, so this is public service.\n05474\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n05475\t                {\n05476\t        __failure = 30;\n05477\t        if (!PyErr_Occurred()) {\n05478\t            PyErr_SetString(PyExc_RuntimeError,\n05479\t                \"Unexpected error in an Op's C code. \"\n05480\t                \"No Python exception was set.\");\n05481\t            }\n05482\t        goto __label_30;}\n05483\t            }\n05484\t            if (!PyArray_Check(py_V29)) {\n05485\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n05486\t                {\n05487\t        __failure = 30;\n05488\t        if (!PyErr_Occurred()) {\n05489\t            PyErr_SetString(PyExc_RuntimeError,\n05490\t                \"Unexpected error in an Op's C code. \"\n05491\t                \"No Python exception was set.\");\n05492\t            }\n05493\t        goto __label_30;}\n05494\t            }\n05495\t            // We expect NPY_FLOAT64\n05496\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V29)) {\n05497\t                PyArrayObject * tmp = (PyArrayObject*) py_V29;\n05498\t                PyErr_Format(PyExc_NotImplementedError,\n05499\t                             \"expected an aligned array of type %ld \"\n05500\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n05501\t                             \" with %ld dimensions, with 3 last dims \"\n05502\t                             \"%ld, %ld, %ld\"\n05503\t                             \" and 3 last strides %ld %ld, %ld.\",\n05504\t                             (long int) NPY_FLOAT64,\n05505\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V29),\n05506\t                             (long int) PyArray_NDIM(tmp),\n05507\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n05508\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n05509\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n05510\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n05511\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n05512\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n05513\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n05514\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n05515\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n05516\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n05517\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n05518\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n05519\t            );\n05520\t                {\n05521\t        __failure = 30;\n05522\t        if (!PyErr_Occurred()) {\n05523\t            PyErr_SetString(PyExc_RuntimeError,\n05524\t                \"Unexpected error in an Op's C code. \"\n05525\t                \"No Python exception was set.\");\n05526\t            }\n05527\t        goto __label_30;}\n05528\t            }\n05529\t            // This is a TypeError to be consistent with DEBUG_MODE\n05530\t            // Note: DEBUG_MODE also tells the name of the container\n05531\t            if (PyArray_TYPE((PyArrayObject*) py_V29) != NPY_FLOAT64) {\n05532\t                PyErr_Format(PyExc_TypeError,\n05533\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n05534\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V29));\n05535\t                {\n05536\t        __failure = 30;\n05537\t        if (!PyErr_Occurred()) {\n05538\t            PyErr_SetString(PyExc_RuntimeError,\n05539\t                \"Unexpected error in an Op's C code. \"\n05540\t                \"No Python exception was set.\");\n05541\t            }\n05542\t        goto __label_30;}\n05543\t            }\n05544\t            \n05545\t        V29 = (PyArrayObject*)(py_V29);\n05546\t        Py_XINCREF(V29);\n05547\t        \n05548\t{\n05549\t\n05550\t    py_V31 = PyList_GET_ITEM(storage_V31, 0);\n05551\t    {Py_XINCREF(py_V31);}\n05552\t    \n05553\t            V31 = NULL;\n05554\t            if (py_V31 == Py_None) {\n05555\t                // We can either fail here or set V31 to NULL and rely on Ops\n05556\t                // using tensors to handle the NULL case, but if they fail to do so\n05557\t                // they'll end up with nasty segfaults, so this is public service.\n05558\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n05559\t                {\n05560\t        __failure = 32;\n05561\t        if (!PyErr_Occurred()) {\n05562\t            PyErr_SetString(PyExc_RuntimeError,\n05563\t                \"Unexpected error in an Op's C code. \"\n05564\t                \"No Python exception was set.\");\n05565\t            }\n05566\t        goto __label_32;}\n05567\t            }\n05568\t            if (!PyArray_Check(py_V31)) {\n05569\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n05570\t                {\n05571\t        __failure = 32;\n05572\t        if (!PyErr_Occurred()) {\n05573\t            PyErr_SetString(PyExc_RuntimeError,\n05574\t                \"Unexpected error in an Op's C code. \"\n05575\t                \"No Python exception was set.\");\n05576\t            }\n05577\t        goto __label_32;}\n05578\t            }\n05579\t            // We expect NPY_FLOAT64\n05580\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V31)) {\n05581\t                PyArrayObject * tmp = (PyArrayObject*) py_V31;\n05582\t                PyErr_Format(PyExc_NotImplementedError,\n05583\t                             \"expected an aligned array of type %ld \"\n05584\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n05585\t                             \" with %ld dimensions, with 3 last dims \"\n05586\t                             \"%ld, %ld, %ld\"\n05587\t                             \" and 3 last strides %ld %ld, %ld.\",\n05588\t                             (long int) NPY_FLOAT64,\n05589\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V31),\n05590\t                             (long int) PyArray_NDIM(tmp),\n05591\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n05592\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n05593\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n05594\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n05595\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n05596\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n05597\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n05598\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n05599\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n05600\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n05601\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n05602\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n05603\t            );\n05604\t                {\n05605\t        __failure = 32;\n05606\t        if (!PyErr_Occurred()) {\n05607\t            PyErr_SetString(PyExc_RuntimeError,\n05608\t                \"Unexpected error in an Op's C code. \"\n05609\t                \"No Python exception was set.\");\n05610\t            }\n05611\t        goto __label_32;}\n05612\t            }\n05613\t            // This is a TypeError to be consistent with DEBUG_MODE\n05614\t            // Note: DEBUG_MODE also tells the name of the container\n05615\t            if (PyArray_TYPE((PyArrayObject*) py_V31) != NPY_FLOAT64) {\n05616\t                PyErr_Format(PyExc_TypeError,\n05617\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n05618\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V31));\n05619\t                {\n05620\t        __failure = 32;\n05621\t        if (!PyErr_Occurred()) {\n05622\t            PyErr_SetString(PyExc_RuntimeError,\n05623\t                \"Unexpected error in an Op's C code. \"\n05624\t                \"No Python exception was set.\");\n05625\t            }\n05626\t        goto __label_32;}\n05627\t            }\n05628\t            \n05629\t        V31 = (PyArrayObject*)(py_V31);\n05630\t        Py_XINCREF(V31);\n05631\t        \n05632\t{\n05633\t\n05634\t    py_V33 = PyList_GET_ITEM(storage_V33, 0);\n05635\t    {Py_XINCREF(py_V33);}\n05636\t    \n05637\t            V33 = NULL;\n05638\t            if (py_V33 == Py_None) {\n05639\t                // We can either fail here or set V33 to NULL and rely on Ops\n05640\t                // using tensors to handle the NULL case, but if they fail to do so\n05641\t                // they'll end up with nasty segfaults, so this is public service.\n05642\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n05643\t                {\n05644\t        __failure = 34;\n05645\t        if (!PyErr_Occurred()) {\n05646\t            PyErr_SetString(PyExc_RuntimeError,\n05647\t                \"Unexpected error in an Op's C code. \"\n05648\t                \"No Python exception was set.\");\n05649\t            }\n05650\t        goto __label_34;}\n05651\t            }\n05652\t            if (!PyArray_Check(py_V33)) {\n05653\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n05654\t                {\n05655\t        __failure = 34;\n05656\t        if (!PyErr_Occurred()) {\n05657\t            PyErr_SetString(PyExc_RuntimeError,\n05658\t                \"Unexpected error in an Op's C code. \"\n05659\t                \"No Python exception was set.\");\n05660\t            }\n05661\t        goto __label_34;}\n05662\t            }\n05663\t            // We expect NPY_FLOAT64\n05664\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V33)) {\n05665\t                PyArrayObject * tmp = (PyArrayObject*) py_V33;\n05666\t                PyErr_Format(PyExc_NotImplementedError,\n05667\t                             \"expected an aligned array of type %ld \"\n05668\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n05669\t                             \" with %ld dimensions, with 3 last dims \"\n05670\t                             \"%ld, %ld, %ld\"\n05671\t                             \" and 3 last strides %ld %ld, %ld.\",\n05672\t                             (long int) NPY_FLOAT64,\n05673\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V33),\n05674\t                             (long int) PyArray_NDIM(tmp),\n05675\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n05676\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n05677\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n05678\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n05679\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n05680\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n05681\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n05682\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n05683\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n05684\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n05685\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n05686\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n05687\t            );\n05688\t                {\n05689\t        __failure = 34;\n05690\t        if (!PyErr_Occurred()) {\n05691\t            PyErr_SetString(PyExc_RuntimeError,\n05692\t                \"Unexpected error in an Op's C code. \"\n05693\t                \"No Python exception was set.\");\n05694\t            }\n05695\t        goto __label_34;}\n05696\t            }\n05697\t            // This is a TypeError to be consistent with DEBUG_MODE\n05698\t            // Note: DEBUG_MODE also tells the name of the container\n05699\t            if (PyArray_TYPE((PyArrayObject*) py_V33) != NPY_FLOAT64) {\n05700\t                PyErr_Format(PyExc_TypeError,\n05701\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n05702\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V33));\n05703\t                {\n05704\t        __failure = 34;\n05705\t        if (!PyErr_Occurred()) {\n05706\t            PyErr_SetString(PyExc_RuntimeError,\n05707\t                \"Unexpected error in an Op's C code. \"\n05708\t                \"No Python exception was set.\");\n05709\t            }\n05710\t        goto __label_34;}\n05711\t            }\n05712\t            \n05713\t        V33 = (PyArrayObject*)(py_V33);\n05714\t        Py_XINCREF(V33);\n05715\t        \n05716\t{\n05717\t\n05718\t    py_V35 = PyList_GET_ITEM(storage_V35, 0);\n05719\t    {Py_XINCREF(py_V35);}\n05720\t    \n05721\t            V35 = NULL;\n05722\t            if (py_V35 == Py_None) {\n05723\t                // We can either fail here or set V35 to NULL and rely on Ops\n05724\t                // using tensors to handle the NULL case, but if they fail to do so\n05725\t                // they'll end up with nasty segfaults, so this is public service.\n05726\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n05727\t                {\n05728\t        __failure = 36;\n05729\t        if (!PyErr_Occurred()) {\n05730\t            PyErr_SetString(PyExc_RuntimeError,\n05731\t                \"Unexpected error in an Op's C code. \"\n05732\t                \"No Python exception was set.\");\n05733\t            }\n05734\t        goto __label_36;}\n05735\t            }\n05736\t            if (!PyArray_Check(py_V35)) {\n05737\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n05738\t                {\n05739\t        __failure = 36;\n05740\t        if (!PyErr_Occurred()) {\n05741\t            PyErr_SetString(PyExc_RuntimeError,\n05742\t                \"Unexpected error in an Op's C code. \"\n05743\t                \"No Python exception was set.\");\n05744\t            }\n05745\t        goto __label_36;}\n05746\t            }\n05747\t            // We expect NPY_FLOAT64\n05748\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V35)) {\n05749\t                PyArrayObject * tmp = (PyArrayObject*) py_V35;\n05750\t                PyErr_Format(PyExc_NotImplementedError,\n05751\t                             \"expected an aligned array of type %ld \"\n05752\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n05753\t                             \" with %ld dimensions, with 3 last dims \"\n05754\t                             \"%ld, %ld, %ld\"\n05755\t                             \" and 3 last strides %ld %ld, %ld.\",\n05756\t                             (long int) NPY_FLOAT64,\n05757\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V35),\n05758\t                             (long int) PyArray_NDIM(tmp),\n05759\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n05760\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n05761\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n05762\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n05763\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n05764\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n05765\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n05766\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n05767\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n05768\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n05769\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n05770\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n05771\t            );\n05772\t                {\n05773\t        __failure = 36;\n05774\t        if (!PyErr_Occurred()) {\n05775\t            PyErr_SetString(PyExc_RuntimeError,\n05776\t                \"Unexpected error in an Op's C code. \"\n05777\t                \"No Python exception was set.\");\n05778\t            }\n05779\t        goto __label_36;}\n05780\t            }\n05781\t            // This is a TypeError to be consistent with DEBUG_MODE\n05782\t            // Note: DEBUG_MODE also tells the name of the container\n05783\t            if (PyArray_TYPE((PyArrayObject*) py_V35) != NPY_FLOAT64) {\n05784\t                PyErr_Format(PyExc_TypeError,\n05785\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n05786\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V35));\n05787\t                {\n05788\t        __failure = 36;\n05789\t        if (!PyErr_Occurred()) {\n05790\t            PyErr_SetString(PyExc_RuntimeError,\n05791\t                \"Unexpected error in an Op's C code. \"\n05792\t                \"No Python exception was set.\");\n05793\t            }\n05794\t        goto __label_36;}\n05795\t            }\n05796\t            \n05797\t        V35 = (PyArrayObject*)(py_V35);\n05798\t        Py_XINCREF(V35);\n05799\t        \n05800\t{\n05801\t\n05802\t    py_V37 = PyList_GET_ITEM(storage_V37, 0);\n05803\t    {Py_XINCREF(py_V37);}\n05804\t    \n05805\t            V37 = NULL;\n05806\t            if (py_V37 == Py_None) {\n05807\t                // We can either fail here or set V37 to NULL and rely on Ops\n05808\t                // using tensors to handle the NULL case, but if they fail to do so\n05809\t                // they'll end up with nasty segfaults, so this is public service.\n05810\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n05811\t                {\n05812\t        __failure = 38;\n05813\t        if (!PyErr_Occurred()) {\n05814\t            PyErr_SetString(PyExc_RuntimeError,\n05815\t                \"Unexpected error in an Op's C code. \"\n05816\t                \"No Python exception was set.\");\n05817\t            }\n05818\t        goto __label_38;}\n05819\t            }\n05820\t            if (!PyArray_Check(py_V37)) {\n05821\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n05822\t                {\n05823\t        __failure = 38;\n05824\t        if (!PyErr_Occurred()) {\n05825\t            PyErr_SetString(PyExc_RuntimeError,\n05826\t                \"Unexpected error in an Op's C code. \"\n05827\t                \"No Python exception was set.\");\n05828\t            }\n05829\t        goto __label_38;}\n05830\t            }\n05831\t            // We expect NPY_FLOAT64\n05832\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V37)) {\n05833\t                PyArrayObject * tmp = (PyArrayObject*) py_V37;\n05834\t                PyErr_Format(PyExc_NotImplementedError,\n05835\t                             \"expected an aligned array of type %ld \"\n05836\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n05837\t                             \" with %ld dimensions, with 3 last dims \"\n05838\t                             \"%ld, %ld, %ld\"\n05839\t                             \" and 3 last strides %ld %ld, %ld.\",\n05840\t                             (long int) NPY_FLOAT64,\n05841\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V37),\n05842\t                             (long int) PyArray_NDIM(tmp),\n05843\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n05844\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n05845\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n05846\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n05847\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n05848\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n05849\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n05850\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n05851\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n05852\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n05853\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n05854\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n05855\t            );\n05856\t                {\n05857\t        __failure = 38;\n05858\t        if (!PyErr_Occurred()) {\n05859\t            PyErr_SetString(PyExc_RuntimeError,\n05860\t                \"Unexpected error in an Op's C code. \"\n05861\t                \"No Python exception was set.\");\n05862\t            }\n05863\t        goto __label_38;}\n05864\t            }\n05865\t            // This is a TypeError to be consistent with DEBUG_MODE\n05866\t            // Note: DEBUG_MODE also tells the name of the container\n05867\t            if (PyArray_TYPE((PyArrayObject*) py_V37) != NPY_FLOAT64) {\n05868\t                PyErr_Format(PyExc_TypeError,\n05869\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n05870\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V37));\n05871\t                {\n05872\t        __failure = 38;\n05873\t        if (!PyErr_Occurred()) {\n05874\t            PyErr_SetString(PyExc_RuntimeError,\n05875\t                \"Unexpected error in an Op's C code. \"\n05876\t                \"No Python exception was set.\");\n05877\t            }\n05878\t        goto __label_38;}\n05879\t            }\n05880\t            \n05881\t        V37 = (PyArrayObject*)(py_V37);\n05882\t        Py_XINCREF(V37);\n05883\t        \n05884\t{\n05885\t\n05886\t    py_V39 = PyList_GET_ITEM(storage_V39, 0);\n05887\t    {Py_XINCREF(py_V39);}\n05888\t    \n05889\t            V39 = NULL;\n05890\t            if (py_V39 == Py_None) {\n05891\t                // We can either fail here or set V39 to NULL and rely on Ops\n05892\t                // using tensors to handle the NULL case, but if they fail to do so\n05893\t                // they'll end up with nasty segfaults, so this is public service.\n05894\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n05895\t                {\n05896\t        __failure = 40;\n05897\t        if (!PyErr_Occurred()) {\n05898\t            PyErr_SetString(PyExc_RuntimeError,\n05899\t                \"Unexpected error in an Op's C code. \"\n05900\t                \"No Python exception was set.\");\n05901\t            }\n05902\t        goto __label_40;}\n05903\t            }\n05904\t            if (!PyArray_Check(py_V39)) {\n05905\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n05906\t                {\n05907\t        __failure = 40;\n05908\t        if (!PyErr_Occurred()) {\n05909\t            PyErr_SetString(PyExc_RuntimeError,\n05910\t                \"Unexpected error in an Op's C code. \"\n05911\t                \"No Python exception was set.\");\n05912\t            }\n05913\t        goto __label_40;}\n05914\t            }\n05915\t            // We expect NPY_FLOAT64\n05916\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V39)) {\n05917\t                PyArrayObject * tmp = (PyArrayObject*) py_V39;\n05918\t                PyErr_Format(PyExc_NotImplementedError,\n05919\t                             \"expected an aligned array of type %ld \"\n05920\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n05921\t                             \" with %ld dimensions, with 3 last dims \"\n05922\t                             \"%ld, %ld, %ld\"\n05923\t                             \" and 3 last strides %ld %ld, %ld.\",\n05924\t                             (long int) NPY_FLOAT64,\n05925\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V39),\n05926\t                             (long int) PyArray_NDIM(tmp),\n05927\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n05928\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n05929\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n05930\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n05931\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n05932\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n05933\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n05934\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n05935\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n05936\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n05937\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n05938\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n05939\t            );\n05940\t                {\n05941\t        __failure = 40;\n05942\t        if (!PyErr_Occurred()) {\n05943\t            PyErr_SetString(PyExc_RuntimeError,\n05944\t                \"Unexpected error in an Op's C code. \"\n05945\t                \"No Python exception was set.\");\n05946\t            }\n05947\t        goto __label_40;}\n05948\t            }\n05949\t            // This is a TypeError to be consistent with DEBUG_MODE\n05950\t            // Note: DEBUG_MODE also tells the name of the container\n05951\t            if (PyArray_TYPE((PyArrayObject*) py_V39) != NPY_FLOAT64) {\n05952\t                PyErr_Format(PyExc_TypeError,\n05953\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n05954\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V39));\n05955\t                {\n05956\t        __failure = 40;\n05957\t        if (!PyErr_Occurred()) {\n05958\t            PyErr_SetString(PyExc_RuntimeError,\n05959\t                \"Unexpected error in an Op's C code. \"\n05960\t                \"No Python exception was set.\");\n05961\t            }\n05962\t        goto __label_40;}\n05963\t            }\n05964\t            \n05965\t        V39 = (PyArrayObject*)(py_V39);\n05966\t        Py_XINCREF(V39);\n05967\t        \n05968\t{\n05969\t\n05970\t    py_V41 = PyList_GET_ITEM(storage_V41, 0);\n05971\t    {Py_XINCREF(py_V41);}\n05972\t    \n05973\t            V41 = NULL;\n05974\t            if (py_V41 == Py_None) {\n05975\t                // We can either fail here or set V41 to NULL and rely on Ops\n05976\t                // using tensors to handle the NULL case, but if they fail to do so\n05977\t                // they'll end up with nasty segfaults, so this is public service.\n05978\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n05979\t                {\n05980\t        __failure = 42;\n05981\t        if (!PyErr_Occurred()) {\n05982\t            PyErr_SetString(PyExc_RuntimeError,\n05983\t                \"Unexpected error in an Op's C code. \"\n05984\t                \"No Python exception was set.\");\n05985\t            }\n05986\t        goto __label_42;}\n05987\t            }\n05988\t            if (!PyArray_Check(py_V41)) {\n05989\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n05990\t                {\n05991\t        __failure = 42;\n05992\t        if (!PyErr_Occurred()) {\n05993\t            PyErr_SetString(PyExc_RuntimeError,\n05994\t                \"Unexpected error in an Op's C code. \"\n05995\t                \"No Python exception was set.\");\n05996\t            }\n05997\t        goto __label_42;}\n05998\t            }\n05999\t            // We expect NPY_FLOAT64\n06000\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V41)) {\n06001\t                PyArrayObject * tmp = (PyArrayObject*) py_V41;\n06002\t                PyErr_Format(PyExc_NotImplementedError,\n06003\t                             \"expected an aligned array of type %ld \"\n06004\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n06005\t                             \" with %ld dimensions, with 3 last dims \"\n06006\t                             \"%ld, %ld, %ld\"\n06007\t                             \" and 3 last strides %ld %ld, %ld.\",\n06008\t                             (long int) NPY_FLOAT64,\n06009\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V41),\n06010\t                             (long int) PyArray_NDIM(tmp),\n06011\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n06012\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n06013\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n06014\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n06015\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n06016\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n06017\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n06018\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n06019\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n06020\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n06021\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n06022\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n06023\t            );\n06024\t                {\n06025\t        __failure = 42;\n06026\t        if (!PyErr_Occurred()) {\n06027\t            PyErr_SetString(PyExc_RuntimeError,\n06028\t                \"Unexpected error in an Op's C code. \"\n06029\t                \"No Python exception was set.\");\n06030\t            }\n06031\t        goto __label_42;}\n06032\t            }\n06033\t            // This is a TypeError to be consistent with DEBUG_MODE\n06034\t            // Note: DEBUG_MODE also tells the name of the container\n06035\t            if (PyArray_TYPE((PyArrayObject*) py_V41) != NPY_FLOAT64) {\n06036\t                PyErr_Format(PyExc_TypeError,\n06037\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n06038\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V41));\n06039\t                {\n06040\t        __failure = 42;\n06041\t        if (!PyErr_Occurred()) {\n06042\t            PyErr_SetString(PyExc_RuntimeError,\n06043\t                \"Unexpected error in an Op's C code. \"\n06044\t                \"No Python exception was set.\");\n06045\t            }\n06046\t        goto __label_42;}\n06047\t            }\n06048\t            \n06049\t        V41 = (PyArrayObject*)(py_V41);\n06050\t        Py_XINCREF(V41);\n06051\t        \n06052\t{\n06053\t\n06054\t    py_V43 = PyList_GET_ITEM(storage_V43, 0);\n06055\t    {Py_XINCREF(py_V43);}\n06056\t    \n06057\t            V43 = NULL;\n06058\t            if (py_V43 == Py_None) {\n06059\t                // We can either fail here or set V43 to NULL and rely on Ops\n06060\t                // using tensors to handle the NULL case, but if they fail to do so\n06061\t                // they'll end up with nasty segfaults, so this is public service.\n06062\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n06063\t                {\n06064\t        __failure = 44;\n06065\t        if (!PyErr_Occurred()) {\n06066\t            PyErr_SetString(PyExc_RuntimeError,\n06067\t                \"Unexpected error in an Op's C code. \"\n06068\t                \"No Python exception was set.\");\n06069\t            }\n06070\t        goto __label_44;}\n06071\t            }\n06072\t            if (!PyArray_Check(py_V43)) {\n06073\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n06074\t                {\n06075\t        __failure = 44;\n06076\t        if (!PyErr_Occurred()) {\n06077\t            PyErr_SetString(PyExc_RuntimeError,\n06078\t                \"Unexpected error in an Op's C code. \"\n06079\t                \"No Python exception was set.\");\n06080\t            }\n06081\t        goto __label_44;}\n06082\t            }\n06083\t            // We expect NPY_FLOAT64\n06084\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V43)) {\n06085\t                PyArrayObject * tmp = (PyArrayObject*) py_V43;\n06086\t                PyErr_Format(PyExc_NotImplementedError,\n06087\t                             \"expected an aligned array of type %ld \"\n06088\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n06089\t                             \" with %ld dimensions, with 3 last dims \"\n06090\t                             \"%ld, %ld, %ld\"\n06091\t                             \" and 3 last strides %ld %ld, %ld.\",\n06092\t                             (long int) NPY_FLOAT64,\n06093\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V43),\n06094\t                             (long int) PyArray_NDIM(tmp),\n06095\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n06096\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n06097\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n06098\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n06099\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n06100\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n06101\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n06102\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n06103\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n06104\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n06105\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n06106\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n06107\t            );\n06108\t                {\n06109\t        __failure = 44;\n06110\t        if (!PyErr_Occurred()) {\n06111\t            PyErr_SetString(PyExc_RuntimeError,\n06112\t                \"Unexpected error in an Op's C code. \"\n06113\t                \"No Python exception was set.\");\n06114\t            }\n06115\t        goto __label_44;}\n06116\t            }\n06117\t            // This is a TypeError to be consistent with DEBUG_MODE\n06118\t            // Note: DEBUG_MODE also tells the name of the container\n06119\t            if (PyArray_TYPE((PyArrayObject*) py_V43) != NPY_FLOAT64) {\n06120\t                PyErr_Format(PyExc_TypeError,\n06121\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n06122\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V43));\n06123\t                {\n06124\t        __failure = 44;\n06125\t        if (!PyErr_Occurred()) {\n06126\t            PyErr_SetString(PyExc_RuntimeError,\n06127\t                \"Unexpected error in an Op's C code. \"\n06128\t                \"No Python exception was set.\");\n06129\t            }\n06130\t        goto __label_44;}\n06131\t            }\n06132\t            \n06133\t        V43 = (PyArrayObject*)(py_V43);\n06134\t        Py_XINCREF(V43);\n06135\t        \n06136\t{\n06137\t\n06138\t    py_V45 = PyList_GET_ITEM(storage_V45, 0);\n06139\t    {Py_XINCREF(py_V45);}\n06140\t    \n06141\t            V45 = NULL;\n06142\t            if (py_V45 == Py_None) {\n06143\t                // We can either fail here or set V45 to NULL and rely on Ops\n06144\t                // using tensors to handle the NULL case, but if they fail to do so\n06145\t                // they'll end up with nasty segfaults, so this is public service.\n06146\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n06147\t                {\n06148\t        __failure = 46;\n06149\t        if (!PyErr_Occurred()) {\n06150\t            PyErr_SetString(PyExc_RuntimeError,\n06151\t                \"Unexpected error in an Op's C code. \"\n06152\t                \"No Python exception was set.\");\n06153\t            }\n06154\t        goto __label_46;}\n06155\t            }\n06156\t            if (!PyArray_Check(py_V45)) {\n06157\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n06158\t                {\n06159\t        __failure = 46;\n06160\t        if (!PyErr_Occurred()) {\n06161\t            PyErr_SetString(PyExc_RuntimeError,\n06162\t                \"Unexpected error in an Op's C code. \"\n06163\t                \"No Python exception was set.\");\n06164\t            }\n06165\t        goto __label_46;}\n06166\t            }\n06167\t            // We expect NPY_FLOAT64\n06168\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V45)) {\n06169\t                PyArrayObject * tmp = (PyArrayObject*) py_V45;\n06170\t                PyErr_Format(PyExc_NotImplementedError,\n06171\t                             \"expected an aligned array of type %ld \"\n06172\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n06173\t                             \" with %ld dimensions, with 3 last dims \"\n06174\t                             \"%ld, %ld, %ld\"\n06175\t                             \" and 3 last strides %ld %ld, %ld.\",\n06176\t                             (long int) NPY_FLOAT64,\n06177\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V45),\n06178\t                             (long int) PyArray_NDIM(tmp),\n06179\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n06180\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n06181\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n06182\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n06183\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n06184\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n06185\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n06186\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n06187\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n06188\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n06189\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n06190\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n06191\t            );\n06192\t                {\n06193\t        __failure = 46;\n06194\t        if (!PyErr_Occurred()) {\n06195\t            PyErr_SetString(PyExc_RuntimeError,\n06196\t                \"Unexpected error in an Op's C code. \"\n06197\t                \"No Python exception was set.\");\n06198\t            }\n06199\t        goto __label_46;}\n06200\t            }\n06201\t            // This is a TypeError to be consistent with DEBUG_MODE\n06202\t            // Note: DEBUG_MODE also tells the name of the container\n06203\t            if (PyArray_TYPE((PyArrayObject*) py_V45) != NPY_FLOAT64) {\n06204\t                PyErr_Format(PyExc_TypeError,\n06205\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n06206\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V45));\n06207\t                {\n06208\t        __failure = 46;\n06209\t        if (!PyErr_Occurred()) {\n06210\t            PyErr_SetString(PyExc_RuntimeError,\n06211\t                \"Unexpected error in an Op's C code. \"\n06212\t                \"No Python exception was set.\");\n06213\t            }\n06214\t        goto __label_46;}\n06215\t            }\n06216\t            \n06217\t        V45 = (PyArrayObject*)(py_V45);\n06218\t        Py_XINCREF(V45);\n06219\t        \n06220\t{\n06221\t\n06222\t    py_V47 = PyList_GET_ITEM(storage_V47, 0);\n06223\t    {Py_XINCREF(py_V47);}\n06224\t    \n06225\t            V47 = NULL;\n06226\t            if (py_V47 == Py_None) {\n06227\t                // We can either fail here or set V47 to NULL and rely on Ops\n06228\t                // using tensors to handle the NULL case, but if they fail to do so\n06229\t                // they'll end up with nasty segfaults, so this is public service.\n06230\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n06231\t                {\n06232\t        __failure = 48;\n06233\t        if (!PyErr_Occurred()) {\n06234\t            PyErr_SetString(PyExc_RuntimeError,\n06235\t                \"Unexpected error in an Op's C code. \"\n06236\t                \"No Python exception was set.\");\n06237\t            }\n06238\t        goto __label_48;}\n06239\t            }\n06240\t            if (!PyArray_Check(py_V47)) {\n06241\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n06242\t                {\n06243\t        __failure = 48;\n06244\t        if (!PyErr_Occurred()) {\n06245\t            PyErr_SetString(PyExc_RuntimeError,\n06246\t                \"Unexpected error in an Op's C code. \"\n06247\t                \"No Python exception was set.\");\n06248\t            }\n06249\t        goto __label_48;}\n06250\t            }\n06251\t            // We expect NPY_FLOAT64\n06252\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V47)) {\n06253\t                PyArrayObject * tmp = (PyArrayObject*) py_V47;\n06254\t                PyErr_Format(PyExc_NotImplementedError,\n06255\t                             \"expected an aligned array of type %ld \"\n06256\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n06257\t                             \" with %ld dimensions, with 3 last dims \"\n06258\t                             \"%ld, %ld, %ld\"\n06259\t                             \" and 3 last strides %ld %ld, %ld.\",\n06260\t                             (long int) NPY_FLOAT64,\n06261\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V47),\n06262\t                             (long int) PyArray_NDIM(tmp),\n06263\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n06264\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n06265\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n06266\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n06267\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n06268\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n06269\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n06270\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n06271\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n06272\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n06273\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n06274\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n06275\t            );\n06276\t                {\n06277\t        __failure = 48;\n06278\t        if (!PyErr_Occurred()) {\n06279\t            PyErr_SetString(PyExc_RuntimeError,\n06280\t                \"Unexpected error in an Op's C code. \"\n06281\t                \"No Python exception was set.\");\n06282\t            }\n06283\t        goto __label_48;}\n06284\t            }\n06285\t            // This is a TypeError to be consistent with DEBUG_MODE\n06286\t            // Note: DEBUG_MODE also tells the name of the container\n06287\t            if (PyArray_TYPE((PyArrayObject*) py_V47) != NPY_FLOAT64) {\n06288\t                PyErr_Format(PyExc_TypeError,\n06289\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n06290\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V47));\n06291\t                {\n06292\t        __failure = 48;\n06293\t        if (!PyErr_Occurred()) {\n06294\t            PyErr_SetString(PyExc_RuntimeError,\n06295\t                \"Unexpected error in an Op's C code. \"\n06296\t                \"No Python exception was set.\");\n06297\t            }\n06298\t        goto __label_48;}\n06299\t            }\n06300\t            \n06301\t        V47 = (PyArrayObject*)(py_V47);\n06302\t        Py_XINCREF(V47);\n06303\t        \n06304\t{\n06305\t\n06306\t    py_V49 = PyList_GET_ITEM(storage_V49, 0);\n06307\t    {Py_XINCREF(py_V49);}\n06308\t    \n06309\t            V49 = NULL;\n06310\t            if (py_V49 == Py_None) {\n06311\t                // We can either fail here or set V49 to NULL and rely on Ops\n06312\t                // using tensors to handle the NULL case, but if they fail to do so\n06313\t                // they'll end up with nasty segfaults, so this is public service.\n06314\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n06315\t                {\n06316\t        __failure = 50;\n06317\t        if (!PyErr_Occurred()) {\n06318\t            PyErr_SetString(PyExc_RuntimeError,\n06319\t                \"Unexpected error in an Op's C code. \"\n06320\t                \"No Python exception was set.\");\n06321\t            }\n06322\t        goto __label_50;}\n06323\t            }\n06324\t            if (!PyArray_Check(py_V49)) {\n06325\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n06326\t                {\n06327\t        __failure = 50;\n06328\t        if (!PyErr_Occurred()) {\n06329\t            PyErr_SetString(PyExc_RuntimeError,\n06330\t                \"Unexpected error in an Op's C code. \"\n06331\t                \"No Python exception was set.\");\n06332\t            }\n06333\t        goto __label_50;}\n06334\t            }\n06335\t            // We expect NPY_FLOAT64\n06336\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V49)) {\n06337\t                PyArrayObject * tmp = (PyArrayObject*) py_V49;\n06338\t                PyErr_Format(PyExc_NotImplementedError,\n06339\t                             \"expected an aligned array of type %ld \"\n06340\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n06341\t                             \" with %ld dimensions, with 3 last dims \"\n06342\t                             \"%ld, %ld, %ld\"\n06343\t                             \" and 3 last strides %ld %ld, %ld.\",\n06344\t                             (long int) NPY_FLOAT64,\n06345\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V49),\n06346\t                             (long int) PyArray_NDIM(tmp),\n06347\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n06348\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n06349\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n06350\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n06351\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n06352\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n06353\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n06354\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n06355\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n06356\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n06357\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n06358\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n06359\t            );\n06360\t                {\n06361\t        __failure = 50;\n06362\t        if (!PyErr_Occurred()) {\n06363\t            PyErr_SetString(PyExc_RuntimeError,\n06364\t                \"Unexpected error in an Op's C code. \"\n06365\t                \"No Python exception was set.\");\n06366\t            }\n06367\t        goto __label_50;}\n06368\t            }\n06369\t            // This is a TypeError to be consistent with DEBUG_MODE\n06370\t            // Note: DEBUG_MODE also tells the name of the container\n06371\t            if (PyArray_TYPE((PyArrayObject*) py_V49) != NPY_FLOAT64) {\n06372\t                PyErr_Format(PyExc_TypeError,\n06373\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n06374\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V49));\n06375\t                {\n06376\t        __failure = 50;\n06377\t        if (!PyErr_Occurred()) {\n06378\t            PyErr_SetString(PyExc_RuntimeError,\n06379\t                \"Unexpected error in an Op's C code. \"\n06380\t                \"No Python exception was set.\");\n06381\t            }\n06382\t        goto __label_50;}\n06383\t            }\n06384\t            \n06385\t        V49 = (PyArrayObject*)(py_V49);\n06386\t        Py_XINCREF(V49);\n06387\t        \n06388\t{\n06389\t\n06390\t    py_V51 = PyList_GET_ITEM(storage_V51, 0);\n06391\t    {Py_XINCREF(py_V51);}\n06392\t    \n06393\t            V51 = NULL;\n06394\t            if (py_V51 == Py_None) {\n06395\t                // We can either fail here or set V51 to NULL and rely on Ops\n06396\t                // using tensors to handle the NULL case, but if they fail to do so\n06397\t                // they'll end up with nasty segfaults, so this is public service.\n06398\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n06399\t                {\n06400\t        __failure = 52;\n06401\t        if (!PyErr_Occurred()) {\n06402\t            PyErr_SetString(PyExc_RuntimeError,\n06403\t                \"Unexpected error in an Op's C code. \"\n06404\t                \"No Python exception was set.\");\n06405\t            }\n06406\t        goto __label_52;}\n06407\t            }\n06408\t            if (!PyArray_Check(py_V51)) {\n06409\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n06410\t                {\n06411\t        __failure = 52;\n06412\t        if (!PyErr_Occurred()) {\n06413\t            PyErr_SetString(PyExc_RuntimeError,\n06414\t                \"Unexpected error in an Op's C code. \"\n06415\t                \"No Python exception was set.\");\n06416\t            }\n06417\t        goto __label_52;}\n06418\t            }\n06419\t            // We expect NPY_FLOAT64\n06420\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V51)) {\n06421\t                PyArrayObject * tmp = (PyArrayObject*) py_V51;\n06422\t                PyErr_Format(PyExc_NotImplementedError,\n06423\t                             \"expected an aligned array of type %ld \"\n06424\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n06425\t                             \" with %ld dimensions, with 3 last dims \"\n06426\t                             \"%ld, %ld, %ld\"\n06427\t                             \" and 3 last strides %ld %ld, %ld.\",\n06428\t                             (long int) NPY_FLOAT64,\n06429\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V51),\n06430\t                             (long int) PyArray_NDIM(tmp),\n06431\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n06432\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n06433\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n06434\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n06435\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n06436\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n06437\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n06438\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n06439\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n06440\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n06441\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n06442\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n06443\t            );\n06444\t                {\n06445\t        __failure = 52;\n06446\t        if (!PyErr_Occurred()) {\n06447\t            PyErr_SetString(PyExc_RuntimeError,\n06448\t                \"Unexpected error in an Op's C code. \"\n06449\t                \"No Python exception was set.\");\n06450\t            }\n06451\t        goto __label_52;}\n06452\t            }\n06453\t            // This is a TypeError to be consistent with DEBUG_MODE\n06454\t            // Note: DEBUG_MODE also tells the name of the container\n06455\t            if (PyArray_TYPE((PyArrayObject*) py_V51) != NPY_FLOAT64) {\n06456\t                PyErr_Format(PyExc_TypeError,\n06457\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n06458\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V51));\n06459\t                {\n06460\t        __failure = 52;\n06461\t        if (!PyErr_Occurred()) {\n06462\t            PyErr_SetString(PyExc_RuntimeError,\n06463\t                \"Unexpected error in an Op's C code. \"\n06464\t                \"No Python exception was set.\");\n06465\t            }\n06466\t        goto __label_52;}\n06467\t            }\n06468\t            \n06469\t        V51 = (PyArrayObject*)(py_V51);\n06470\t        Py_XINCREF(V51);\n06471\t        \n06472\t{\n06473\t\n06474\t    py_V53 = PyList_GET_ITEM(storage_V53, 0);\n06475\t    {Py_XINCREF(py_V53);}\n06476\t    \n06477\t            V53 = NULL;\n06478\t            if (py_V53 == Py_None) {\n06479\t                // We can either fail here or set V53 to NULL and rely on Ops\n06480\t                // using tensors to handle the NULL case, but if they fail to do so\n06481\t                // they'll end up with nasty segfaults, so this is public service.\n06482\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n06483\t                {\n06484\t        __failure = 54;\n06485\t        if (!PyErr_Occurred()) {\n06486\t            PyErr_SetString(PyExc_RuntimeError,\n06487\t                \"Unexpected error in an Op's C code. \"\n06488\t                \"No Python exception was set.\");\n06489\t            }\n06490\t        goto __label_54;}\n06491\t            }\n06492\t            if (!PyArray_Check(py_V53)) {\n06493\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n06494\t                {\n06495\t        __failure = 54;\n06496\t        if (!PyErr_Occurred()) {\n06497\t            PyErr_SetString(PyExc_RuntimeError,\n06498\t                \"Unexpected error in an Op's C code. \"\n06499\t                \"No Python exception was set.\");\n06500\t            }\n06501\t        goto __label_54;}\n06502\t            }\n06503\t            // We expect NPY_FLOAT64\n06504\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V53)) {\n06505\t                PyArrayObject * tmp = (PyArrayObject*) py_V53;\n06506\t                PyErr_Format(PyExc_NotImplementedError,\n06507\t                             \"expected an aligned array of type %ld \"\n06508\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n06509\t                             \" with %ld dimensions, with 3 last dims \"\n06510\t                             \"%ld, %ld, %ld\"\n06511\t                             \" and 3 last strides %ld %ld, %ld.\",\n06512\t                             (long int) NPY_FLOAT64,\n06513\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V53),\n06514\t                             (long int) PyArray_NDIM(tmp),\n06515\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n06516\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n06517\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n06518\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n06519\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n06520\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n06521\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n06522\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n06523\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n06524\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n06525\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n06526\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n06527\t            );\n06528\t                {\n06529\t        __failure = 54;\n06530\t        if (!PyErr_Occurred()) {\n06531\t            PyErr_SetString(PyExc_RuntimeError,\n06532\t                \"Unexpected error in an Op's C code. \"\n06533\t                \"No Python exception was set.\");\n06534\t            }\n06535\t        goto __label_54;}\n06536\t            }\n06537\t            // This is a TypeError to be consistent with DEBUG_MODE\n06538\t            // Note: DEBUG_MODE also tells the name of the container\n06539\t            if (PyArray_TYPE((PyArrayObject*) py_V53) != NPY_FLOAT64) {\n06540\t                PyErr_Format(PyExc_TypeError,\n06541\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n06542\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V53));\n06543\t                {\n06544\t        __failure = 54;\n06545\t        if (!PyErr_Occurred()) {\n06546\t            PyErr_SetString(PyExc_RuntimeError,\n06547\t                \"Unexpected error in an Op's C code. \"\n06548\t                \"No Python exception was set.\");\n06549\t            }\n06550\t        goto __label_54;}\n06551\t            }\n06552\t            \n06553\t        V53 = (PyArrayObject*)(py_V53);\n06554\t        Py_XINCREF(V53);\n06555\t        \n06556\t{\n06557\t\n06558\t    py_V55 = PyList_GET_ITEM(storage_V55, 0);\n06559\t    {Py_XINCREF(py_V55);}\n06560\t    \n06561\t            V55 = NULL;\n06562\t            if (py_V55 == Py_None) {\n06563\t                // We can either fail here or set V55 to NULL and rely on Ops\n06564\t                // using tensors to handle the NULL case, but if they fail to do so\n06565\t                // they'll end up with nasty segfaults, so this is public service.\n06566\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n06567\t                {\n06568\t        __failure = 56;\n06569\t        if (!PyErr_Occurred()) {\n06570\t            PyErr_SetString(PyExc_RuntimeError,\n06571\t                \"Unexpected error in an Op's C code. \"\n06572\t                \"No Python exception was set.\");\n06573\t            }\n06574\t        goto __label_56;}\n06575\t            }\n06576\t            if (!PyArray_Check(py_V55)) {\n06577\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n06578\t                {\n06579\t        __failure = 56;\n06580\t        if (!PyErr_Occurred()) {\n06581\t            PyErr_SetString(PyExc_RuntimeError,\n06582\t                \"Unexpected error in an Op's C code. \"\n06583\t                \"No Python exception was set.\");\n06584\t            }\n06585\t        goto __label_56;}\n06586\t            }\n06587\t            // We expect NPY_FLOAT64\n06588\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V55)) {\n06589\t                PyArrayObject * tmp = (PyArrayObject*) py_V55;\n06590\t                PyErr_Format(PyExc_NotImplementedError,\n06591\t                             \"expected an aligned array of type %ld \"\n06592\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n06593\t                             \" with %ld dimensions, with 3 last dims \"\n06594\t                             \"%ld, %ld, %ld\"\n06595\t                             \" and 3 last strides %ld %ld, %ld.\",\n06596\t                             (long int) NPY_FLOAT64,\n06597\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V55),\n06598\t                             (long int) PyArray_NDIM(tmp),\n06599\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n06600\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n06601\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n06602\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n06603\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n06604\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n06605\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n06606\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n06607\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n06608\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n06609\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n06610\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n06611\t            );\n06612\t                {\n06613\t        __failure = 56;\n06614\t        if (!PyErr_Occurred()) {\n06615\t            PyErr_SetString(PyExc_RuntimeError,\n06616\t                \"Unexpected error in an Op's C code. \"\n06617\t                \"No Python exception was set.\");\n06618\t            }\n06619\t        goto __label_56;}\n06620\t            }\n06621\t            // This is a TypeError to be consistent with DEBUG_MODE\n06622\t            // Note: DEBUG_MODE also tells the name of the container\n06623\t            if (PyArray_TYPE((PyArrayObject*) py_V55) != NPY_FLOAT64) {\n06624\t                PyErr_Format(PyExc_TypeError,\n06625\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n06626\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V55));\n06627\t                {\n06628\t        __failure = 56;\n06629\t        if (!PyErr_Occurred()) {\n06630\t            PyErr_SetString(PyExc_RuntimeError,\n06631\t                \"Unexpected error in an Op's C code. \"\n06632\t                \"No Python exception was set.\");\n06633\t            }\n06634\t        goto __label_56;}\n06635\t            }\n06636\t            \n06637\t        V55 = (PyArrayObject*)(py_V55);\n06638\t        Py_XINCREF(V55);\n06639\t        \n06640\t{\n06641\t\n06642\t    py_V57 = PyList_GET_ITEM(storage_V57, 0);\n06643\t    {Py_XINCREF(py_V57);}\n06644\t    \n06645\t            V57 = NULL;\n06646\t            if (py_V57 == Py_None) {\n06647\t                // We can either fail here or set V57 to NULL and rely on Ops\n06648\t                // using tensors to handle the NULL case, but if they fail to do so\n06649\t                // they'll end up with nasty segfaults, so this is public service.\n06650\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n06651\t                {\n06652\t        __failure = 58;\n06653\t        if (!PyErr_Occurred()) {\n06654\t            PyErr_SetString(PyExc_RuntimeError,\n06655\t                \"Unexpected error in an Op's C code. \"\n06656\t                \"No Python exception was set.\");\n06657\t            }\n06658\t        goto __label_58;}\n06659\t            }\n06660\t            if (!PyArray_Check(py_V57)) {\n06661\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n06662\t                {\n06663\t        __failure = 58;\n06664\t        if (!PyErr_Occurred()) {\n06665\t            PyErr_SetString(PyExc_RuntimeError,\n06666\t                \"Unexpected error in an Op's C code. \"\n06667\t                \"No Python exception was set.\");\n06668\t            }\n06669\t        goto __label_58;}\n06670\t            }\n06671\t            // We expect NPY_FLOAT64\n06672\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V57)) {\n06673\t                PyArrayObject * tmp = (PyArrayObject*) py_V57;\n06674\t                PyErr_Format(PyExc_NotImplementedError,\n06675\t                             \"expected an aligned array of type %ld \"\n06676\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n06677\t                             \" with %ld dimensions, with 3 last dims \"\n06678\t                             \"%ld, %ld, %ld\"\n06679\t                             \" and 3 last strides %ld %ld, %ld.\",\n06680\t                             (long int) NPY_FLOAT64,\n06681\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V57),\n06682\t                             (long int) PyArray_NDIM(tmp),\n06683\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n06684\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n06685\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n06686\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n06687\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n06688\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n06689\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n06690\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n06691\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n06692\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n06693\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n06694\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n06695\t            );\n06696\t                {\n06697\t        __failure = 58;\n06698\t        if (!PyErr_Occurred()) {\n06699\t            PyErr_SetString(PyExc_RuntimeError,\n06700\t                \"Unexpected error in an Op's C code. \"\n06701\t                \"No Python exception was set.\");\n06702\t            }\n06703\t        goto __label_58;}\n06704\t            }\n06705\t            // This is a TypeError to be consistent with DEBUG_MODE\n06706\t            // Note: DEBUG_MODE also tells the name of the container\n06707\t            if (PyArray_TYPE((PyArrayObject*) py_V57) != NPY_FLOAT64) {\n06708\t                PyErr_Format(PyExc_TypeError,\n06709\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n06710\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V57));\n06711\t                {\n06712\t        __failure = 58;\n06713\t        if (!PyErr_Occurred()) {\n06714\t            PyErr_SetString(PyExc_RuntimeError,\n06715\t                \"Unexpected error in an Op's C code. \"\n06716\t                \"No Python exception was set.\");\n06717\t            }\n06718\t        goto __label_58;}\n06719\t            }\n06720\t            \n06721\t        V57 = (PyArrayObject*)(py_V57);\n06722\t        Py_XINCREF(V57);\n06723\t        \n06724\t{\n06725\t\n06726\t    py_V59 = PyList_GET_ITEM(storage_V59, 0);\n06727\t    {Py_XINCREF(py_V59);}\n06728\t    \n06729\t            V59 = NULL;\n06730\t            if (py_V59 == Py_None) {\n06731\t                // We can either fail here or set V59 to NULL and rely on Ops\n06732\t                // using tensors to handle the NULL case, but if they fail to do so\n06733\t                // they'll end up with nasty segfaults, so this is public service.\n06734\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n06735\t                {\n06736\t        __failure = 60;\n06737\t        if (!PyErr_Occurred()) {\n06738\t            PyErr_SetString(PyExc_RuntimeError,\n06739\t                \"Unexpected error in an Op's C code. \"\n06740\t                \"No Python exception was set.\");\n06741\t            }\n06742\t        goto __label_60;}\n06743\t            }\n06744\t            if (!PyArray_Check(py_V59)) {\n06745\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n06746\t                {\n06747\t        __failure = 60;\n06748\t        if (!PyErr_Occurred()) {\n06749\t            PyErr_SetString(PyExc_RuntimeError,\n06750\t                \"Unexpected error in an Op's C code. \"\n06751\t                \"No Python exception was set.\");\n06752\t            }\n06753\t        goto __label_60;}\n06754\t            }\n06755\t            // We expect NPY_FLOAT64\n06756\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V59)) {\n06757\t                PyArrayObject * tmp = (PyArrayObject*) py_V59;\n06758\t                PyErr_Format(PyExc_NotImplementedError,\n06759\t                             \"expected an aligned array of type %ld \"\n06760\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n06761\t                             \" with %ld dimensions, with 3 last dims \"\n06762\t                             \"%ld, %ld, %ld\"\n06763\t                             \" and 3 last strides %ld %ld, %ld.\",\n06764\t                             (long int) NPY_FLOAT64,\n06765\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V59),\n06766\t                             (long int) PyArray_NDIM(tmp),\n06767\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n06768\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n06769\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n06770\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n06771\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n06772\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n06773\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n06774\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n06775\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n06776\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n06777\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n06778\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n06779\t            );\n06780\t                {\n06781\t        __failure = 60;\n06782\t        if (!PyErr_Occurred()) {\n06783\t            PyErr_SetString(PyExc_RuntimeError,\n06784\t                \"Unexpected error in an Op's C code. \"\n06785\t                \"No Python exception was set.\");\n06786\t            }\n06787\t        goto __label_60;}\n06788\t            }\n06789\t            // This is a TypeError to be consistent with DEBUG_MODE\n06790\t            // Note: DEBUG_MODE also tells the name of the container\n06791\t            if (PyArray_TYPE((PyArrayObject*) py_V59) != NPY_FLOAT64) {\n06792\t                PyErr_Format(PyExc_TypeError,\n06793\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n06794\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V59));\n06795\t                {\n06796\t        __failure = 60;\n06797\t        if (!PyErr_Occurred()) {\n06798\t            PyErr_SetString(PyExc_RuntimeError,\n06799\t                \"Unexpected error in an Op's C code. \"\n06800\t                \"No Python exception was set.\");\n06801\t            }\n06802\t        goto __label_60;}\n06803\t            }\n06804\t            \n06805\t        V59 = (PyArrayObject*)(py_V59);\n06806\t        Py_XINCREF(V59);\n06807\t        \n06808\t{\n06809\t\n06810\t    py_V61 = PyList_GET_ITEM(storage_V61, 0);\n06811\t    {Py_XINCREF(py_V61);}\n06812\t    \n06813\t            V61 = NULL;\n06814\t            if (py_V61 == Py_None) {\n06815\t                // We can either fail here or set V61 to NULL and rely on Ops\n06816\t                // using tensors to handle the NULL case, but if they fail to do so\n06817\t                // they'll end up with nasty segfaults, so this is public service.\n06818\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n06819\t                {\n06820\t        __failure = 62;\n06821\t        if (!PyErr_Occurred()) {\n06822\t            PyErr_SetString(PyExc_RuntimeError,\n06823\t                \"Unexpected error in an Op's C code. \"\n06824\t                \"No Python exception was set.\");\n06825\t            }\n06826\t        goto __label_62;}\n06827\t            }\n06828\t            if (!PyArray_Check(py_V61)) {\n06829\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n06830\t                {\n06831\t        __failure = 62;\n06832\t        if (!PyErr_Occurred()) {\n06833\t            PyErr_SetString(PyExc_RuntimeError,\n06834\t                \"Unexpected error in an Op's C code. \"\n06835\t                \"No Python exception was set.\");\n06836\t            }\n06837\t        goto __label_62;}\n06838\t            }\n06839\t            // We expect NPY_FLOAT64\n06840\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V61)) {\n06841\t                PyArrayObject * tmp = (PyArrayObject*) py_V61;\n06842\t                PyErr_Format(PyExc_NotImplementedError,\n06843\t                             \"expected an aligned array of type %ld \"\n06844\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n06845\t                             \" with %ld dimensions, with 3 last dims \"\n06846\t                             \"%ld, %ld, %ld\"\n06847\t                             \" and 3 last strides %ld %ld, %ld.\",\n06848\t                             (long int) NPY_FLOAT64,\n06849\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V61),\n06850\t                             (long int) PyArray_NDIM(tmp),\n06851\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n06852\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n06853\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n06854\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n06855\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n06856\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n06857\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n06858\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n06859\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n06860\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n06861\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n06862\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n06863\t            );\n06864\t                {\n06865\t        __failure = 62;\n06866\t        if (!PyErr_Occurred()) {\n06867\t            PyErr_SetString(PyExc_RuntimeError,\n06868\t                \"Unexpected error in an Op's C code. \"\n06869\t                \"No Python exception was set.\");\n06870\t            }\n06871\t        goto __label_62;}\n06872\t            }\n06873\t            // This is a TypeError to be consistent with DEBUG_MODE\n06874\t            // Note: DEBUG_MODE also tells the name of the container\n06875\t            if (PyArray_TYPE((PyArrayObject*) py_V61) != NPY_FLOAT64) {\n06876\t                PyErr_Format(PyExc_TypeError,\n06877\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n06878\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V61));\n06879\t                {\n06880\t        __failure = 62;\n06881\t        if (!PyErr_Occurred()) {\n06882\t            PyErr_SetString(PyExc_RuntimeError,\n06883\t                \"Unexpected error in an Op's C code. \"\n06884\t                \"No Python exception was set.\");\n06885\t            }\n06886\t        goto __label_62;}\n06887\t            }\n06888\t            \n06889\t        V61 = (PyArrayObject*)(py_V61);\n06890\t        Py_XINCREF(V61);\n06891\t        \n06892\t{\n06893\t\n06894\t    py_V63 = PyList_GET_ITEM(storage_V63, 0);\n06895\t    {Py_XINCREF(py_V63);}\n06896\t    \n06897\t            V63 = NULL;\n06898\t            if (py_V63 == Py_None) {\n06899\t                // We can either fail here or set V63 to NULL and rely on Ops\n06900\t                // using tensors to handle the NULL case, but if they fail to do so\n06901\t                // they'll end up with nasty segfaults, so this is public service.\n06902\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n06903\t                {\n06904\t        __failure = 64;\n06905\t        if (!PyErr_Occurred()) {\n06906\t            PyErr_SetString(PyExc_RuntimeError,\n06907\t                \"Unexpected error in an Op's C code. \"\n06908\t                \"No Python exception was set.\");\n06909\t            }\n06910\t        goto __label_64;}\n06911\t            }\n06912\t            if (!PyArray_Check(py_V63)) {\n06913\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n06914\t                {\n06915\t        __failure = 64;\n06916\t        if (!PyErr_Occurred()) {\n06917\t            PyErr_SetString(PyExc_RuntimeError,\n06918\t                \"Unexpected error in an Op's C code. \"\n06919\t                \"No Python exception was set.\");\n06920\t            }\n06921\t        goto __label_64;}\n06922\t            }\n06923\t            // We expect NPY_FLOAT64\n06924\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V63)) {\n06925\t                PyArrayObject * tmp = (PyArrayObject*) py_V63;\n06926\t                PyErr_Format(PyExc_NotImplementedError,\n06927\t                             \"expected an aligned array of type %ld \"\n06928\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n06929\t                             \" with %ld dimensions, with 3 last dims \"\n06930\t                             \"%ld, %ld, %ld\"\n06931\t                             \" and 3 last strides %ld %ld, %ld.\",\n06932\t                             (long int) NPY_FLOAT64,\n06933\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V63),\n06934\t                             (long int) PyArray_NDIM(tmp),\n06935\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n06936\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n06937\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n06938\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n06939\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n06940\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n06941\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n06942\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n06943\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n06944\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n06945\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n06946\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n06947\t            );\n06948\t                {\n06949\t        __failure = 64;\n06950\t        if (!PyErr_Occurred()) {\n06951\t            PyErr_SetString(PyExc_RuntimeError,\n06952\t                \"Unexpected error in an Op's C code. \"\n06953\t                \"No Python exception was set.\");\n06954\t            }\n06955\t        goto __label_64;}\n06956\t            }\n06957\t            // This is a TypeError to be consistent with DEBUG_MODE\n06958\t            // Note: DEBUG_MODE also tells the name of the container\n06959\t            if (PyArray_TYPE((PyArrayObject*) py_V63) != NPY_FLOAT64) {\n06960\t                PyErr_Format(PyExc_TypeError,\n06961\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n06962\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V63));\n06963\t                {\n06964\t        __failure = 64;\n06965\t        if (!PyErr_Occurred()) {\n06966\t            PyErr_SetString(PyExc_RuntimeError,\n06967\t                \"Unexpected error in an Op's C code. \"\n06968\t                \"No Python exception was set.\");\n06969\t            }\n06970\t        goto __label_64;}\n06971\t            }\n06972\t            \n06973\t        V63 = (PyArrayObject*)(py_V63);\n06974\t        Py_XINCREF(V63);\n06975\t        \n06976\t{\n06977\t\n06978\t    py_V65 = PyList_GET_ITEM(storage_V65, 0);\n06979\t    {Py_XINCREF(py_V65);}\n06980\t    \n06981\t            V65 = NULL;\n06982\t            if (py_V65 == Py_None) {\n06983\t                // We can either fail here or set V65 to NULL and rely on Ops\n06984\t                // using tensors to handle the NULL case, but if they fail to do so\n06985\t                // they'll end up with nasty segfaults, so this is public service.\n06986\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n06987\t                {\n06988\t        __failure = 66;\n06989\t        if (!PyErr_Occurred()) {\n06990\t            PyErr_SetString(PyExc_RuntimeError,\n06991\t                \"Unexpected error in an Op's C code. \"\n06992\t                \"No Python exception was set.\");\n06993\t            }\n06994\t        goto __label_66;}\n06995\t            }\n06996\t            if (!PyArray_Check(py_V65)) {\n06997\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n06998\t                {\n06999\t        __failure = 66;\n07000\t        if (!PyErr_Occurred()) {\n07001\t            PyErr_SetString(PyExc_RuntimeError,\n07002\t                \"Unexpected error in an Op's C code. \"\n07003\t                \"No Python exception was set.\");\n07004\t            }\n07005\t        goto __label_66;}\n07006\t            }\n07007\t            // We expect NPY_FLOAT64\n07008\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V65)) {\n07009\t                PyArrayObject * tmp = (PyArrayObject*) py_V65;\n07010\t                PyErr_Format(PyExc_NotImplementedError,\n07011\t                             \"expected an aligned array of type %ld \"\n07012\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n07013\t                             \" with %ld dimensions, with 3 last dims \"\n07014\t                             \"%ld, %ld, %ld\"\n07015\t                             \" and 3 last strides %ld %ld, %ld.\",\n07016\t                             (long int) NPY_FLOAT64,\n07017\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V65),\n07018\t                             (long int) PyArray_NDIM(tmp),\n07019\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n07020\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n07021\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n07022\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n07023\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n07024\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n07025\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n07026\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n07027\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n07028\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n07029\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n07030\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n07031\t            );\n07032\t                {\n07033\t        __failure = 66;\n07034\t        if (!PyErr_Occurred()) {\n07035\t            PyErr_SetString(PyExc_RuntimeError,\n07036\t                \"Unexpected error in an Op's C code. \"\n07037\t                \"No Python exception was set.\");\n07038\t            }\n07039\t        goto __label_66;}\n07040\t            }\n07041\t            // This is a TypeError to be consistent with DEBUG_MODE\n07042\t            // Note: DEBUG_MODE also tells the name of the container\n07043\t            if (PyArray_TYPE((PyArrayObject*) py_V65) != NPY_FLOAT64) {\n07044\t                PyErr_Format(PyExc_TypeError,\n07045\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n07046\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V65));\n07047\t                {\n07048\t        __failure = 66;\n07049\t        if (!PyErr_Occurred()) {\n07050\t            PyErr_SetString(PyExc_RuntimeError,\n07051\t                \"Unexpected error in an Op's C code. \"\n07052\t                \"No Python exception was set.\");\n07053\t            }\n07054\t        goto __label_66;}\n07055\t            }\n07056\t            \n07057\t        V65 = (PyArrayObject*)(py_V65);\n07058\t        Py_XINCREF(V65);\n07059\t        \n07060\t{\n07061\t\n07062\t    py_V67 = PyList_GET_ITEM(storage_V67, 0);\n07063\t    {Py_XINCREF(py_V67);}\n07064\t    \n07065\t            V67 = NULL;\n07066\t            if (py_V67 == Py_None) {\n07067\t                // We can either fail here or set V67 to NULL and rely on Ops\n07068\t                // using tensors to handle the NULL case, but if they fail to do so\n07069\t                // they'll end up with nasty segfaults, so this is public service.\n07070\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n07071\t                {\n07072\t        __failure = 68;\n07073\t        if (!PyErr_Occurred()) {\n07074\t            PyErr_SetString(PyExc_RuntimeError,\n07075\t                \"Unexpected error in an Op's C code. \"\n07076\t                \"No Python exception was set.\");\n07077\t            }\n07078\t        goto __label_68;}\n07079\t            }\n07080\t            if (!PyArray_Check(py_V67)) {\n07081\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n07082\t                {\n07083\t        __failure = 68;\n07084\t        if (!PyErr_Occurred()) {\n07085\t            PyErr_SetString(PyExc_RuntimeError,\n07086\t                \"Unexpected error in an Op's C code. \"\n07087\t                \"No Python exception was set.\");\n07088\t            }\n07089\t        goto __label_68;}\n07090\t            }\n07091\t            // We expect NPY_FLOAT64\n07092\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V67)) {\n07093\t                PyArrayObject * tmp = (PyArrayObject*) py_V67;\n07094\t                PyErr_Format(PyExc_NotImplementedError,\n07095\t                             \"expected an aligned array of type %ld \"\n07096\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n07097\t                             \" with %ld dimensions, with 3 last dims \"\n07098\t                             \"%ld, %ld, %ld\"\n07099\t                             \" and 3 last strides %ld %ld, %ld.\",\n07100\t                             (long int) NPY_FLOAT64,\n07101\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V67),\n07102\t                             (long int) PyArray_NDIM(tmp),\n07103\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n07104\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n07105\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n07106\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n07107\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n07108\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n07109\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n07110\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n07111\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n07112\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n07113\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n07114\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n07115\t            );\n07116\t                {\n07117\t        __failure = 68;\n07118\t        if (!PyErr_Occurred()) {\n07119\t            PyErr_SetString(PyExc_RuntimeError,\n07120\t                \"Unexpected error in an Op's C code. \"\n07121\t                \"No Python exception was set.\");\n07122\t            }\n07123\t        goto __label_68;}\n07124\t            }\n07125\t            // This is a TypeError to be consistent with DEBUG_MODE\n07126\t            // Note: DEBUG_MODE also tells the name of the container\n07127\t            if (PyArray_TYPE((PyArrayObject*) py_V67) != NPY_FLOAT64) {\n07128\t                PyErr_Format(PyExc_TypeError,\n07129\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n07130\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V67));\n07131\t                {\n07132\t        __failure = 68;\n07133\t        if (!PyErr_Occurred()) {\n07134\t            PyErr_SetString(PyExc_RuntimeError,\n07135\t                \"Unexpected error in an Op's C code. \"\n07136\t                \"No Python exception was set.\");\n07137\t            }\n07138\t        goto __label_68;}\n07139\t            }\n07140\t            \n07141\t        V67 = (PyArrayObject*)(py_V67);\n07142\t        Py_XINCREF(V67);\n07143\t        \n07144\t{\n07145\t\n07146\t    py_V69 = PyList_GET_ITEM(storage_V69, 0);\n07147\t    {Py_XINCREF(py_V69);}\n07148\t    \n07149\t            V69 = NULL;\n07150\t            if (py_V69 == Py_None) {\n07151\t                // We can either fail here or set V69 to NULL and rely on Ops\n07152\t                // using tensors to handle the NULL case, but if they fail to do so\n07153\t                // they'll end up with nasty segfaults, so this is public service.\n07154\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n07155\t                {\n07156\t        __failure = 70;\n07157\t        if (!PyErr_Occurred()) {\n07158\t            PyErr_SetString(PyExc_RuntimeError,\n07159\t                \"Unexpected error in an Op's C code. \"\n07160\t                \"No Python exception was set.\");\n07161\t            }\n07162\t        goto __label_70;}\n07163\t            }\n07164\t            if (!PyArray_Check(py_V69)) {\n07165\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n07166\t                {\n07167\t        __failure = 70;\n07168\t        if (!PyErr_Occurred()) {\n07169\t            PyErr_SetString(PyExc_RuntimeError,\n07170\t                \"Unexpected error in an Op's C code. \"\n07171\t                \"No Python exception was set.\");\n07172\t            }\n07173\t        goto __label_70;}\n07174\t            }\n07175\t            // We expect NPY_FLOAT64\n07176\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V69)) {\n07177\t                PyArrayObject * tmp = (PyArrayObject*) py_V69;\n07178\t                PyErr_Format(PyExc_NotImplementedError,\n07179\t                             \"expected an aligned array of type %ld \"\n07180\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n07181\t                             \" with %ld dimensions, with 3 last dims \"\n07182\t                             \"%ld, %ld, %ld\"\n07183\t                             \" and 3 last strides %ld %ld, %ld.\",\n07184\t                             (long int) NPY_FLOAT64,\n07185\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V69),\n07186\t                             (long int) PyArray_NDIM(tmp),\n07187\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n07188\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n07189\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n07190\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n07191\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n07192\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n07193\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n07194\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n07195\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n07196\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n07197\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n07198\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n07199\t            );\n07200\t                {\n07201\t        __failure = 70;\n07202\t        if (!PyErr_Occurred()) {\n07203\t            PyErr_SetString(PyExc_RuntimeError,\n07204\t                \"Unexpected error in an Op's C code. \"\n07205\t                \"No Python exception was set.\");\n07206\t            }\n07207\t        goto __label_70;}\n07208\t            }\n07209\t            // This is a TypeError to be consistent with DEBUG_MODE\n07210\t            // Note: DEBUG_MODE also tells the name of the container\n07211\t            if (PyArray_TYPE((PyArrayObject*) py_V69) != NPY_FLOAT64) {\n07212\t                PyErr_Format(PyExc_TypeError,\n07213\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n07214\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V69));\n07215\t                {\n07216\t        __failure = 70;\n07217\t        if (!PyErr_Occurred()) {\n07218\t            PyErr_SetString(PyExc_RuntimeError,\n07219\t                \"Unexpected error in an Op's C code. \"\n07220\t                \"No Python exception was set.\");\n07221\t            }\n07222\t        goto __label_70;}\n07223\t            }\n07224\t            \n07225\t        V69 = (PyArrayObject*)(py_V69);\n07226\t        Py_XINCREF(V69);\n07227\t        \n07228\t{\n07229\t\n07230\t    py_V71 = PyList_GET_ITEM(storage_V71, 0);\n07231\t    {Py_XINCREF(py_V71);}\n07232\t    \n07233\t            V71 = NULL;\n07234\t            if (py_V71 == Py_None) {\n07235\t                // We can either fail here or set V71 to NULL and rely on Ops\n07236\t                // using tensors to handle the NULL case, but if they fail to do so\n07237\t                // they'll end up with nasty segfaults, so this is public service.\n07238\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n07239\t                {\n07240\t        __failure = 72;\n07241\t        if (!PyErr_Occurred()) {\n07242\t            PyErr_SetString(PyExc_RuntimeError,\n07243\t                \"Unexpected error in an Op's C code. \"\n07244\t                \"No Python exception was set.\");\n07245\t            }\n07246\t        goto __label_72;}\n07247\t            }\n07248\t            if (!PyArray_Check(py_V71)) {\n07249\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n07250\t                {\n07251\t        __failure = 72;\n07252\t        if (!PyErr_Occurred()) {\n07253\t            PyErr_SetString(PyExc_RuntimeError,\n07254\t                \"Unexpected error in an Op's C code. \"\n07255\t                \"No Python exception was set.\");\n07256\t            }\n07257\t        goto __label_72;}\n07258\t            }\n07259\t            // We expect NPY_FLOAT64\n07260\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V71)) {\n07261\t                PyArrayObject * tmp = (PyArrayObject*) py_V71;\n07262\t                PyErr_Format(PyExc_NotImplementedError,\n07263\t                             \"expected an aligned array of type %ld \"\n07264\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n07265\t                             \" with %ld dimensions, with 3 last dims \"\n07266\t                             \"%ld, %ld, %ld\"\n07267\t                             \" and 3 last strides %ld %ld, %ld.\",\n07268\t                             (long int) NPY_FLOAT64,\n07269\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V71),\n07270\t                             (long int) PyArray_NDIM(tmp),\n07271\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n07272\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n07273\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n07274\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n07275\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n07276\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n07277\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n07278\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n07279\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n07280\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n07281\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n07282\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n07283\t            );\n07284\t                {\n07285\t        __failure = 72;\n07286\t        if (!PyErr_Occurred()) {\n07287\t            PyErr_SetString(PyExc_RuntimeError,\n07288\t                \"Unexpected error in an Op's C code. \"\n07289\t                \"No Python exception was set.\");\n07290\t            }\n07291\t        goto __label_72;}\n07292\t            }\n07293\t            // This is a TypeError to be consistent with DEBUG_MODE\n07294\t            // Note: DEBUG_MODE also tells the name of the container\n07295\t            if (PyArray_TYPE((PyArrayObject*) py_V71) != NPY_FLOAT64) {\n07296\t                PyErr_Format(PyExc_TypeError,\n07297\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n07298\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V71));\n07299\t                {\n07300\t        __failure = 72;\n07301\t        if (!PyErr_Occurred()) {\n07302\t            PyErr_SetString(PyExc_RuntimeError,\n07303\t                \"Unexpected error in an Op's C code. \"\n07304\t                \"No Python exception was set.\");\n07305\t            }\n07306\t        goto __label_72;}\n07307\t            }\n07308\t            \n07309\t        V71 = (PyArrayObject*)(py_V71);\n07310\t        Py_XINCREF(V71);\n07311\t        \n07312\t{\n07313\t\n07314\t    py_V73 = PyList_GET_ITEM(storage_V73, 0);\n07315\t    {Py_XINCREF(py_V73);}\n07316\t    \n07317\t            V73 = NULL;\n07318\t            if (py_V73 == Py_None) {\n07319\t                // We can either fail here or set V73 to NULL and rely on Ops\n07320\t                // using tensors to handle the NULL case, but if they fail to do so\n07321\t                // they'll end up with nasty segfaults, so this is public service.\n07322\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n07323\t                {\n07324\t        __failure = 74;\n07325\t        if (!PyErr_Occurred()) {\n07326\t            PyErr_SetString(PyExc_RuntimeError,\n07327\t                \"Unexpected error in an Op's C code. \"\n07328\t                \"No Python exception was set.\");\n07329\t            }\n07330\t        goto __label_74;}\n07331\t            }\n07332\t            if (!PyArray_Check(py_V73)) {\n07333\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n07334\t                {\n07335\t        __failure = 74;\n07336\t        if (!PyErr_Occurred()) {\n07337\t            PyErr_SetString(PyExc_RuntimeError,\n07338\t                \"Unexpected error in an Op's C code. \"\n07339\t                \"No Python exception was set.\");\n07340\t            }\n07341\t        goto __label_74;}\n07342\t            }\n07343\t            // We expect NPY_FLOAT64\n07344\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V73)) {\n07345\t                PyArrayObject * tmp = (PyArrayObject*) py_V73;\n07346\t                PyErr_Format(PyExc_NotImplementedError,\n07347\t                             \"expected an aligned array of type %ld \"\n07348\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n07349\t                             \" with %ld dimensions, with 3 last dims \"\n07350\t                             \"%ld, %ld, %ld\"\n07351\t                             \" and 3 last strides %ld %ld, %ld.\",\n07352\t                             (long int) NPY_FLOAT64,\n07353\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V73),\n07354\t                             (long int) PyArray_NDIM(tmp),\n07355\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n07356\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n07357\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n07358\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n07359\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n07360\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n07361\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n07362\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n07363\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n07364\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n07365\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n07366\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n07367\t            );\n07368\t                {\n07369\t        __failure = 74;\n07370\t        if (!PyErr_Occurred()) {\n07371\t            PyErr_SetString(PyExc_RuntimeError,\n07372\t                \"Unexpected error in an Op's C code. \"\n07373\t                \"No Python exception was set.\");\n07374\t            }\n07375\t        goto __label_74;}\n07376\t            }\n07377\t            // This is a TypeError to be consistent with DEBUG_MODE\n07378\t            // Note: DEBUG_MODE also tells the name of the container\n07379\t            if (PyArray_TYPE((PyArrayObject*) py_V73) != NPY_FLOAT64) {\n07380\t                PyErr_Format(PyExc_TypeError,\n07381\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n07382\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V73));\n07383\t                {\n07384\t        __failure = 74;\n07385\t        if (!PyErr_Occurred()) {\n07386\t            PyErr_SetString(PyExc_RuntimeError,\n07387\t                \"Unexpected error in an Op's C code. \"\n07388\t                \"No Python exception was set.\");\n07389\t            }\n07390\t        goto __label_74;}\n07391\t            }\n07392\t            \n07393\t        V73 = (PyArrayObject*)(py_V73);\n07394\t        Py_XINCREF(V73);\n07395\t        \n07396\t{\n07397\t\n07398\t    py_V75 = PyList_GET_ITEM(storage_V75, 0);\n07399\t    {Py_XINCREF(py_V75);}\n07400\t    \n07401\t            V75 = NULL;\n07402\t            if (py_V75 == Py_None) {\n07403\t                // We can either fail here or set V75 to NULL and rely on Ops\n07404\t                // using tensors to handle the NULL case, but if they fail to do so\n07405\t                // they'll end up with nasty segfaults, so this is public service.\n07406\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n07407\t                {\n07408\t        __failure = 76;\n07409\t        if (!PyErr_Occurred()) {\n07410\t            PyErr_SetString(PyExc_RuntimeError,\n07411\t                \"Unexpected error in an Op's C code. \"\n07412\t                \"No Python exception was set.\");\n07413\t            }\n07414\t        goto __label_76;}\n07415\t            }\n07416\t            if (!PyArray_Check(py_V75)) {\n07417\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n07418\t                {\n07419\t        __failure = 76;\n07420\t        if (!PyErr_Occurred()) {\n07421\t            PyErr_SetString(PyExc_RuntimeError,\n07422\t                \"Unexpected error in an Op's C code. \"\n07423\t                \"No Python exception was set.\");\n07424\t            }\n07425\t        goto __label_76;}\n07426\t            }\n07427\t            // We expect NPY_FLOAT64\n07428\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V75)) {\n07429\t                PyArrayObject * tmp = (PyArrayObject*) py_V75;\n07430\t                PyErr_Format(PyExc_NotImplementedError,\n07431\t                             \"expected an aligned array of type %ld \"\n07432\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n07433\t                             \" with %ld dimensions, with 3 last dims \"\n07434\t                             \"%ld, %ld, %ld\"\n07435\t                             \" and 3 last strides %ld %ld, %ld.\",\n07436\t                             (long int) NPY_FLOAT64,\n07437\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V75),\n07438\t                             (long int) PyArray_NDIM(tmp),\n07439\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n07440\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n07441\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n07442\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n07443\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n07444\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n07445\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n07446\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n07447\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n07448\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n07449\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n07450\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n07451\t            );\n07452\t                {\n07453\t        __failure = 76;\n07454\t        if (!PyErr_Occurred()) {\n07455\t            PyErr_SetString(PyExc_RuntimeError,\n07456\t                \"Unexpected error in an Op's C code. \"\n07457\t                \"No Python exception was set.\");\n07458\t            }\n07459\t        goto __label_76;}\n07460\t            }\n07461\t            // This is a TypeError to be consistent with DEBUG_MODE\n07462\t            // Note: DEBUG_MODE also tells the name of the container\n07463\t            if (PyArray_TYPE((PyArrayObject*) py_V75) != NPY_FLOAT64) {\n07464\t                PyErr_Format(PyExc_TypeError,\n07465\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n07466\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V75));\n07467\t                {\n07468\t        __failure = 76;\n07469\t        if (!PyErr_Occurred()) {\n07470\t            PyErr_SetString(PyExc_RuntimeError,\n07471\t                \"Unexpected error in an Op's C code. \"\n07472\t                \"No Python exception was set.\");\n07473\t            }\n07474\t        goto __label_76;}\n07475\t            }\n07476\t            \n07477\t        V75 = (PyArrayObject*)(py_V75);\n07478\t        Py_XINCREF(V75);\n07479\t        \n07480\t{\n07481\t\n07482\t    py_V77 = PyList_GET_ITEM(storage_V77, 0);\n07483\t    {Py_XINCREF(py_V77);}\n07484\t    \n07485\t            V77 = NULL;\n07486\t            if (py_V77 == Py_None) {\n07487\t                // We can either fail here or set V77 to NULL and rely on Ops\n07488\t                // using tensors to handle the NULL case, but if they fail to do so\n07489\t                // they'll end up with nasty segfaults, so this is public service.\n07490\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n07491\t                {\n07492\t        __failure = 78;\n07493\t        if (!PyErr_Occurred()) {\n07494\t            PyErr_SetString(PyExc_RuntimeError,\n07495\t                \"Unexpected error in an Op's C code. \"\n07496\t                \"No Python exception was set.\");\n07497\t            }\n07498\t        goto __label_78;}\n07499\t            }\n07500\t            if (!PyArray_Check(py_V77)) {\n07501\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n07502\t                {\n07503\t        __failure = 78;\n07504\t        if (!PyErr_Occurred()) {\n07505\t            PyErr_SetString(PyExc_RuntimeError,\n07506\t                \"Unexpected error in an Op's C code. \"\n07507\t                \"No Python exception was set.\");\n07508\t            }\n07509\t        goto __label_78;}\n07510\t            }\n07511\t            // We expect NPY_FLOAT64\n07512\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V77)) {\n07513\t                PyArrayObject * tmp = (PyArrayObject*) py_V77;\n07514\t                PyErr_Format(PyExc_NotImplementedError,\n07515\t                             \"expected an aligned array of type %ld \"\n07516\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n07517\t                             \" with %ld dimensions, with 3 last dims \"\n07518\t                             \"%ld, %ld, %ld\"\n07519\t                             \" and 3 last strides %ld %ld, %ld.\",\n07520\t                             (long int) NPY_FLOAT64,\n07521\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V77),\n07522\t                             (long int) PyArray_NDIM(tmp),\n07523\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n07524\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n07525\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n07526\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n07527\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n07528\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n07529\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n07530\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n07531\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n07532\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n07533\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n07534\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n07535\t            );\n07536\t                {\n07537\t        __failure = 78;\n07538\t        if (!PyErr_Occurred()) {\n07539\t            PyErr_SetString(PyExc_RuntimeError,\n07540\t                \"Unexpected error in an Op's C code. \"\n07541\t                \"No Python exception was set.\");\n07542\t            }\n07543\t        goto __label_78;}\n07544\t            }\n07545\t            // This is a TypeError to be consistent with DEBUG_MODE\n07546\t            // Note: DEBUG_MODE also tells the name of the container\n07547\t            if (PyArray_TYPE((PyArrayObject*) py_V77) != NPY_FLOAT64) {\n07548\t                PyErr_Format(PyExc_TypeError,\n07549\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n07550\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V77));\n07551\t                {\n07552\t        __failure = 78;\n07553\t        if (!PyErr_Occurred()) {\n07554\t            PyErr_SetString(PyExc_RuntimeError,\n07555\t                \"Unexpected error in an Op's C code. \"\n07556\t                \"No Python exception was set.\");\n07557\t            }\n07558\t        goto __label_78;}\n07559\t            }\n07560\t            \n07561\t        V77 = (PyArrayObject*)(py_V77);\n07562\t        Py_XINCREF(V77);\n07563\t        \n07564\t{\n07565\t\n07566\t    py_V79 = PyList_GET_ITEM(storage_V79, 0);\n07567\t    {Py_XINCREF(py_V79);}\n07568\t    \n07569\t            V79 = NULL;\n07570\t            if (py_V79 == Py_None) {\n07571\t                // We can either fail here or set V79 to NULL and rely on Ops\n07572\t                // using tensors to handle the NULL case, but if they fail to do so\n07573\t                // they'll end up with nasty segfaults, so this is public service.\n07574\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n07575\t                {\n07576\t        __failure = 80;\n07577\t        if (!PyErr_Occurred()) {\n07578\t            PyErr_SetString(PyExc_RuntimeError,\n07579\t                \"Unexpected error in an Op's C code. \"\n07580\t                \"No Python exception was set.\");\n07581\t            }\n07582\t        goto __label_80;}\n07583\t            }\n07584\t            if (!PyArray_Check(py_V79)) {\n07585\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n07586\t                {\n07587\t        __failure = 80;\n07588\t        if (!PyErr_Occurred()) {\n07589\t            PyErr_SetString(PyExc_RuntimeError,\n07590\t                \"Unexpected error in an Op's C code. \"\n07591\t                \"No Python exception was set.\");\n07592\t            }\n07593\t        goto __label_80;}\n07594\t            }\n07595\t            // We expect NPY_FLOAT64\n07596\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V79)) {\n07597\t                PyArrayObject * tmp = (PyArrayObject*) py_V79;\n07598\t                PyErr_Format(PyExc_NotImplementedError,\n07599\t                             \"expected an aligned array of type %ld \"\n07600\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n07601\t                             \" with %ld dimensions, with 3 last dims \"\n07602\t                             \"%ld, %ld, %ld\"\n07603\t                             \" and 3 last strides %ld %ld, %ld.\",\n07604\t                             (long int) NPY_FLOAT64,\n07605\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V79),\n07606\t                             (long int) PyArray_NDIM(tmp),\n07607\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n07608\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n07609\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n07610\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n07611\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n07612\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n07613\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n07614\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n07615\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n07616\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n07617\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n07618\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n07619\t            );\n07620\t                {\n07621\t        __failure = 80;\n07622\t        if (!PyErr_Occurred()) {\n07623\t            PyErr_SetString(PyExc_RuntimeError,\n07624\t                \"Unexpected error in an Op's C code. \"\n07625\t                \"No Python exception was set.\");\n07626\t            }\n07627\t        goto __label_80;}\n07628\t            }\n07629\t            // This is a TypeError to be consistent with DEBUG_MODE\n07630\t            // Note: DEBUG_MODE also tells the name of the container\n07631\t            if (PyArray_TYPE((PyArrayObject*) py_V79) != NPY_FLOAT64) {\n07632\t                PyErr_Format(PyExc_TypeError,\n07633\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n07634\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V79));\n07635\t                {\n07636\t        __failure = 80;\n07637\t        if (!PyErr_Occurred()) {\n07638\t            PyErr_SetString(PyExc_RuntimeError,\n07639\t                \"Unexpected error in an Op's C code. \"\n07640\t                \"No Python exception was set.\");\n07641\t            }\n07642\t        goto __label_80;}\n07643\t            }\n07644\t            \n07645\t        V79 = (PyArrayObject*)(py_V79);\n07646\t        Py_XINCREF(V79);\n07647\t        \n07648\t{\n07649\t\n07650\t    py_V81 = PyList_GET_ITEM(storage_V81, 0);\n07651\t    {Py_XINCREF(py_V81);}\n07652\t    \n07653\t            V81 = NULL;\n07654\t            if (py_V81 == Py_None) {\n07655\t                // We can either fail here or set V81 to NULL and rely on Ops\n07656\t                // using tensors to handle the NULL case, but if they fail to do so\n07657\t                // they'll end up with nasty segfaults, so this is public service.\n07658\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n07659\t                {\n07660\t        __failure = 82;\n07661\t        if (!PyErr_Occurred()) {\n07662\t            PyErr_SetString(PyExc_RuntimeError,\n07663\t                \"Unexpected error in an Op's C code. \"\n07664\t                \"No Python exception was set.\");\n07665\t            }\n07666\t        goto __label_82;}\n07667\t            }\n07668\t            if (!PyArray_Check(py_V81)) {\n07669\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n07670\t                {\n07671\t        __failure = 82;\n07672\t        if (!PyErr_Occurred()) {\n07673\t            PyErr_SetString(PyExc_RuntimeError,\n07674\t                \"Unexpected error in an Op's C code. \"\n07675\t                \"No Python exception was set.\");\n07676\t            }\n07677\t        goto __label_82;}\n07678\t            }\n07679\t            // We expect NPY_FLOAT64\n07680\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V81)) {\n07681\t                PyArrayObject * tmp = (PyArrayObject*) py_V81;\n07682\t                PyErr_Format(PyExc_NotImplementedError,\n07683\t                             \"expected an aligned array of type %ld \"\n07684\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n07685\t                             \" with %ld dimensions, with 3 last dims \"\n07686\t                             \"%ld, %ld, %ld\"\n07687\t                             \" and 3 last strides %ld %ld, %ld.\",\n07688\t                             (long int) NPY_FLOAT64,\n07689\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V81),\n07690\t                             (long int) PyArray_NDIM(tmp),\n07691\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n07692\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n07693\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n07694\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n07695\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n07696\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n07697\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n07698\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n07699\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n07700\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n07701\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n07702\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n07703\t            );\n07704\t                {\n07705\t        __failure = 82;\n07706\t        if (!PyErr_Occurred()) {\n07707\t            PyErr_SetString(PyExc_RuntimeError,\n07708\t                \"Unexpected error in an Op's C code. \"\n07709\t                \"No Python exception was set.\");\n07710\t            }\n07711\t        goto __label_82;}\n07712\t            }\n07713\t            // This is a TypeError to be consistent with DEBUG_MODE\n07714\t            // Note: DEBUG_MODE also tells the name of the container\n07715\t            if (PyArray_TYPE((PyArrayObject*) py_V81) != NPY_FLOAT64) {\n07716\t                PyErr_Format(PyExc_TypeError,\n07717\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n07718\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V81));\n07719\t                {\n07720\t        __failure = 82;\n07721\t        if (!PyErr_Occurred()) {\n07722\t            PyErr_SetString(PyExc_RuntimeError,\n07723\t                \"Unexpected error in an Op's C code. \"\n07724\t                \"No Python exception was set.\");\n07725\t            }\n07726\t        goto __label_82;}\n07727\t            }\n07728\t            \n07729\t        V81 = (PyArrayObject*)(py_V81);\n07730\t        Py_XINCREF(V81);\n07731\t        \n07732\t{\n07733\t\n07734\t    py_V83 = PyList_GET_ITEM(storage_V83, 0);\n07735\t    {Py_XINCREF(py_V83);}\n07736\t    \n07737\t            V83 = NULL;\n07738\t            if (py_V83 == Py_None) {\n07739\t                // We can either fail here or set V83 to NULL and rely on Ops\n07740\t                // using tensors to handle the NULL case, but if they fail to do so\n07741\t                // they'll end up with nasty segfaults, so this is public service.\n07742\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n07743\t                {\n07744\t        __failure = 84;\n07745\t        if (!PyErr_Occurred()) {\n07746\t            PyErr_SetString(PyExc_RuntimeError,\n07747\t                \"Unexpected error in an Op's C code. \"\n07748\t                \"No Python exception was set.\");\n07749\t            }\n07750\t        goto __label_84;}\n07751\t            }\n07752\t            if (!PyArray_Check(py_V83)) {\n07753\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n07754\t                {\n07755\t        __failure = 84;\n07756\t        if (!PyErr_Occurred()) {\n07757\t            PyErr_SetString(PyExc_RuntimeError,\n07758\t                \"Unexpected error in an Op's C code. \"\n07759\t                \"No Python exception was set.\");\n07760\t            }\n07761\t        goto __label_84;}\n07762\t            }\n07763\t            // We expect NPY_FLOAT64\n07764\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V83)) {\n07765\t                PyArrayObject * tmp = (PyArrayObject*) py_V83;\n07766\t                PyErr_Format(PyExc_NotImplementedError,\n07767\t                             \"expected an aligned array of type %ld \"\n07768\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n07769\t                             \" with %ld dimensions, with 3 last dims \"\n07770\t                             \"%ld, %ld, %ld\"\n07771\t                             \" and 3 last strides %ld %ld, %ld.\",\n07772\t                             (long int) NPY_FLOAT64,\n07773\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V83),\n07774\t                             (long int) PyArray_NDIM(tmp),\n07775\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n07776\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n07777\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n07778\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n07779\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n07780\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n07781\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n07782\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n07783\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n07784\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n07785\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n07786\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n07787\t            );\n07788\t                {\n07789\t        __failure = 84;\n07790\t        if (!PyErr_Occurred()) {\n07791\t            PyErr_SetString(PyExc_RuntimeError,\n07792\t                \"Unexpected error in an Op's C code. \"\n07793\t                \"No Python exception was set.\");\n07794\t            }\n07795\t        goto __label_84;}\n07796\t            }\n07797\t            // This is a TypeError to be consistent with DEBUG_MODE\n07798\t            // Note: DEBUG_MODE also tells the name of the container\n07799\t            if (PyArray_TYPE((PyArrayObject*) py_V83) != NPY_FLOAT64) {\n07800\t                PyErr_Format(PyExc_TypeError,\n07801\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n07802\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V83));\n07803\t                {\n07804\t        __failure = 84;\n07805\t        if (!PyErr_Occurred()) {\n07806\t            PyErr_SetString(PyExc_RuntimeError,\n07807\t                \"Unexpected error in an Op's C code. \"\n07808\t                \"No Python exception was set.\");\n07809\t            }\n07810\t        goto __label_84;}\n07811\t            }\n07812\t            \n07813\t        V83 = (PyArrayObject*)(py_V83);\n07814\t        Py_XINCREF(V83);\n07815\t        \n07816\t{\n07817\t\n07818\t    py_V85 = PyList_GET_ITEM(storage_V85, 0);\n07819\t    {Py_XINCREF(py_V85);}\n07820\t    \n07821\t            V85 = NULL;\n07822\t            if (py_V85 == Py_None) {\n07823\t                // We can either fail here or set V85 to NULL and rely on Ops\n07824\t                // using tensors to handle the NULL case, but if they fail to do so\n07825\t                // they'll end up with nasty segfaults, so this is public service.\n07826\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n07827\t                {\n07828\t        __failure = 86;\n07829\t        if (!PyErr_Occurred()) {\n07830\t            PyErr_SetString(PyExc_RuntimeError,\n07831\t                \"Unexpected error in an Op's C code. \"\n07832\t                \"No Python exception was set.\");\n07833\t            }\n07834\t        goto __label_86;}\n07835\t            }\n07836\t            if (!PyArray_Check(py_V85)) {\n07837\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n07838\t                {\n07839\t        __failure = 86;\n07840\t        if (!PyErr_Occurred()) {\n07841\t            PyErr_SetString(PyExc_RuntimeError,\n07842\t                \"Unexpected error in an Op's C code. \"\n07843\t                \"No Python exception was set.\");\n07844\t            }\n07845\t        goto __label_86;}\n07846\t            }\n07847\t            // We expect NPY_FLOAT64\n07848\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V85)) {\n07849\t                PyArrayObject * tmp = (PyArrayObject*) py_V85;\n07850\t                PyErr_Format(PyExc_NotImplementedError,\n07851\t                             \"expected an aligned array of type %ld \"\n07852\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n07853\t                             \" with %ld dimensions, with 3 last dims \"\n07854\t                             \"%ld, %ld, %ld\"\n07855\t                             \" and 3 last strides %ld %ld, %ld.\",\n07856\t                             (long int) NPY_FLOAT64,\n07857\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V85),\n07858\t                             (long int) PyArray_NDIM(tmp),\n07859\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n07860\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n07861\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n07862\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n07863\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n07864\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n07865\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n07866\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n07867\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n07868\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n07869\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n07870\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n07871\t            );\n07872\t                {\n07873\t        __failure = 86;\n07874\t        if (!PyErr_Occurred()) {\n07875\t            PyErr_SetString(PyExc_RuntimeError,\n07876\t                \"Unexpected error in an Op's C code. \"\n07877\t                \"No Python exception was set.\");\n07878\t            }\n07879\t        goto __label_86;}\n07880\t            }\n07881\t            // This is a TypeError to be consistent with DEBUG_MODE\n07882\t            // Note: DEBUG_MODE also tells the name of the container\n07883\t            if (PyArray_TYPE((PyArrayObject*) py_V85) != NPY_FLOAT64) {\n07884\t                PyErr_Format(PyExc_TypeError,\n07885\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n07886\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V85));\n07887\t                {\n07888\t        __failure = 86;\n07889\t        if (!PyErr_Occurred()) {\n07890\t            PyErr_SetString(PyExc_RuntimeError,\n07891\t                \"Unexpected error in an Op's C code. \"\n07892\t                \"No Python exception was set.\");\n07893\t            }\n07894\t        goto __label_86;}\n07895\t            }\n07896\t            \n07897\t        V85 = (PyArrayObject*)(py_V85);\n07898\t        Py_XINCREF(V85);\n07899\t        \n07900\t{\n07901\t\n07902\t    py_V87 = PyList_GET_ITEM(storage_V87, 0);\n07903\t    {Py_XINCREF(py_V87);}\n07904\t    \n07905\t            V87 = NULL;\n07906\t            if (py_V87 == Py_None) {\n07907\t                // We can either fail here or set V87 to NULL and rely on Ops\n07908\t                // using tensors to handle the NULL case, but if they fail to do so\n07909\t                // they'll end up with nasty segfaults, so this is public service.\n07910\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n07911\t                {\n07912\t        __failure = 88;\n07913\t        if (!PyErr_Occurred()) {\n07914\t            PyErr_SetString(PyExc_RuntimeError,\n07915\t                \"Unexpected error in an Op's C code. \"\n07916\t                \"No Python exception was set.\");\n07917\t            }\n07918\t        goto __label_88;}\n07919\t            }\n07920\t            if (!PyArray_Check(py_V87)) {\n07921\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n07922\t                {\n07923\t        __failure = 88;\n07924\t        if (!PyErr_Occurred()) {\n07925\t            PyErr_SetString(PyExc_RuntimeError,\n07926\t                \"Unexpected error in an Op's C code. \"\n07927\t                \"No Python exception was set.\");\n07928\t            }\n07929\t        goto __label_88;}\n07930\t            }\n07931\t            // We expect NPY_FLOAT64\n07932\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V87)) {\n07933\t                PyArrayObject * tmp = (PyArrayObject*) py_V87;\n07934\t                PyErr_Format(PyExc_NotImplementedError,\n07935\t                             \"expected an aligned array of type %ld \"\n07936\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n07937\t                             \" with %ld dimensions, with 3 last dims \"\n07938\t                             \"%ld, %ld, %ld\"\n07939\t                             \" and 3 last strides %ld %ld, %ld.\",\n07940\t                             (long int) NPY_FLOAT64,\n07941\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V87),\n07942\t                             (long int) PyArray_NDIM(tmp),\n07943\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n07944\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n07945\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n07946\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n07947\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n07948\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n07949\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n07950\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n07951\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n07952\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n07953\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n07954\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n07955\t            );\n07956\t                {\n07957\t        __failure = 88;\n07958\t        if (!PyErr_Occurred()) {\n07959\t            PyErr_SetString(PyExc_RuntimeError,\n07960\t                \"Unexpected error in an Op's C code. \"\n07961\t                \"No Python exception was set.\");\n07962\t            }\n07963\t        goto __label_88;}\n07964\t            }\n07965\t            // This is a TypeError to be consistent with DEBUG_MODE\n07966\t            // Note: DEBUG_MODE also tells the name of the container\n07967\t            if (PyArray_TYPE((PyArrayObject*) py_V87) != NPY_FLOAT64) {\n07968\t                PyErr_Format(PyExc_TypeError,\n07969\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n07970\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V87));\n07971\t                {\n07972\t        __failure = 88;\n07973\t        if (!PyErr_Occurred()) {\n07974\t            PyErr_SetString(PyExc_RuntimeError,\n07975\t                \"Unexpected error in an Op's C code. \"\n07976\t                \"No Python exception was set.\");\n07977\t            }\n07978\t        goto __label_88;}\n07979\t            }\n07980\t            \n07981\t        V87 = (PyArrayObject*)(py_V87);\n07982\t        Py_XINCREF(V87);\n07983\t        \n07984\t{\n07985\t\n07986\t    py_V89 = PyList_GET_ITEM(storage_V89, 0);\n07987\t    {Py_XINCREF(py_V89);}\n07988\t    \n07989\t            V89 = NULL;\n07990\t            if (py_V89 == Py_None) {\n07991\t                // We can either fail here or set V89 to NULL and rely on Ops\n07992\t                // using tensors to handle the NULL case, but if they fail to do so\n07993\t                // they'll end up with nasty segfaults, so this is public service.\n07994\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n07995\t                {\n07996\t        __failure = 90;\n07997\t        if (!PyErr_Occurred()) {\n07998\t            PyErr_SetString(PyExc_RuntimeError,\n07999\t                \"Unexpected error in an Op's C code. \"\n08000\t                \"No Python exception was set.\");\n08001\t            }\n08002\t        goto __label_90;}\n08003\t            }\n08004\t            if (!PyArray_Check(py_V89)) {\n08005\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n08006\t                {\n08007\t        __failure = 90;\n08008\t        if (!PyErr_Occurred()) {\n08009\t            PyErr_SetString(PyExc_RuntimeError,\n08010\t                \"Unexpected error in an Op's C code. \"\n08011\t                \"No Python exception was set.\");\n08012\t            }\n08013\t        goto __label_90;}\n08014\t            }\n08015\t            // We expect NPY_FLOAT64\n08016\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V89)) {\n08017\t                PyArrayObject * tmp = (PyArrayObject*) py_V89;\n08018\t                PyErr_Format(PyExc_NotImplementedError,\n08019\t                             \"expected an aligned array of type %ld \"\n08020\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n08021\t                             \" with %ld dimensions, with 3 last dims \"\n08022\t                             \"%ld, %ld, %ld\"\n08023\t                             \" and 3 last strides %ld %ld, %ld.\",\n08024\t                             (long int) NPY_FLOAT64,\n08025\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V89),\n08026\t                             (long int) PyArray_NDIM(tmp),\n08027\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n08028\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n08029\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n08030\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n08031\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n08032\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n08033\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n08034\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n08035\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n08036\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n08037\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n08038\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n08039\t            );\n08040\t                {\n08041\t        __failure = 90;\n08042\t        if (!PyErr_Occurred()) {\n08043\t            PyErr_SetString(PyExc_RuntimeError,\n08044\t                \"Unexpected error in an Op's C code. \"\n08045\t                \"No Python exception was set.\");\n08046\t            }\n08047\t        goto __label_90;}\n08048\t            }\n08049\t            // This is a TypeError to be consistent with DEBUG_MODE\n08050\t            // Note: DEBUG_MODE also tells the name of the container\n08051\t            if (PyArray_TYPE((PyArrayObject*) py_V89) != NPY_FLOAT64) {\n08052\t                PyErr_Format(PyExc_TypeError,\n08053\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n08054\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V89));\n08055\t                {\n08056\t        __failure = 90;\n08057\t        if (!PyErr_Occurred()) {\n08058\t            PyErr_SetString(PyExc_RuntimeError,\n08059\t                \"Unexpected error in an Op's C code. \"\n08060\t                \"No Python exception was set.\");\n08061\t            }\n08062\t        goto __label_90;}\n08063\t            }\n08064\t            \n08065\t        V89 = (PyArrayObject*)(py_V89);\n08066\t        Py_XINCREF(V89);\n08067\t        \n08068\t{\n08069\t\n08070\t    py_V91 = PyList_GET_ITEM(storage_V91, 0);\n08071\t    {Py_XINCREF(py_V91);}\n08072\t    \n08073\t            V91 = NULL;\n08074\t            if (py_V91 == Py_None) {\n08075\t                // We can either fail here or set V91 to NULL and rely on Ops\n08076\t                // using tensors to handle the NULL case, but if they fail to do so\n08077\t                // they'll end up with nasty segfaults, so this is public service.\n08078\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n08079\t                {\n08080\t        __failure = 92;\n08081\t        if (!PyErr_Occurred()) {\n08082\t            PyErr_SetString(PyExc_RuntimeError,\n08083\t                \"Unexpected error in an Op's C code. \"\n08084\t                \"No Python exception was set.\");\n08085\t            }\n08086\t        goto __label_92;}\n08087\t            }\n08088\t            if (!PyArray_Check(py_V91)) {\n08089\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n08090\t                {\n08091\t        __failure = 92;\n08092\t        if (!PyErr_Occurred()) {\n08093\t            PyErr_SetString(PyExc_RuntimeError,\n08094\t                \"Unexpected error in an Op's C code. \"\n08095\t                \"No Python exception was set.\");\n08096\t            }\n08097\t        goto __label_92;}\n08098\t            }\n08099\t            // We expect NPY_FLOAT64\n08100\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V91)) {\n08101\t                PyArrayObject * tmp = (PyArrayObject*) py_V91;\n08102\t                PyErr_Format(PyExc_NotImplementedError,\n08103\t                             \"expected an aligned array of type %ld \"\n08104\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n08105\t                             \" with %ld dimensions, with 3 last dims \"\n08106\t                             \"%ld, %ld, %ld\"\n08107\t                             \" and 3 last strides %ld %ld, %ld.\",\n08108\t                             (long int) NPY_FLOAT64,\n08109\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V91),\n08110\t                             (long int) PyArray_NDIM(tmp),\n08111\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n08112\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n08113\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n08114\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n08115\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n08116\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n08117\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n08118\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n08119\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n08120\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n08121\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n08122\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n08123\t            );\n08124\t                {\n08125\t        __failure = 92;\n08126\t        if (!PyErr_Occurred()) {\n08127\t            PyErr_SetString(PyExc_RuntimeError,\n08128\t                \"Unexpected error in an Op's C code. \"\n08129\t                \"No Python exception was set.\");\n08130\t            }\n08131\t        goto __label_92;}\n08132\t            }\n08133\t            // This is a TypeError to be consistent with DEBUG_MODE\n08134\t            // Note: DEBUG_MODE also tells the name of the container\n08135\t            if (PyArray_TYPE((PyArrayObject*) py_V91) != NPY_FLOAT64) {\n08136\t                PyErr_Format(PyExc_TypeError,\n08137\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n08138\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V91));\n08139\t                {\n08140\t        __failure = 92;\n08141\t        if (!PyErr_Occurred()) {\n08142\t            PyErr_SetString(PyExc_RuntimeError,\n08143\t                \"Unexpected error in an Op's C code. \"\n08144\t                \"No Python exception was set.\");\n08145\t            }\n08146\t        goto __label_92;}\n08147\t            }\n08148\t            \n08149\t        V91 = (PyArrayObject*)(py_V91);\n08150\t        Py_XINCREF(V91);\n08151\t        \n08152\t{\n08153\t\n08154\t    py_V93 = PyList_GET_ITEM(storage_V93, 0);\n08155\t    {Py_XINCREF(py_V93);}\n08156\t    \n08157\t            V93 = NULL;\n08158\t            if (py_V93 == Py_None) {\n08159\t                // We can either fail here or set V93 to NULL and rely on Ops\n08160\t                // using tensors to handle the NULL case, but if they fail to do so\n08161\t                // they'll end up with nasty segfaults, so this is public service.\n08162\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n08163\t                {\n08164\t        __failure = 94;\n08165\t        if (!PyErr_Occurred()) {\n08166\t            PyErr_SetString(PyExc_RuntimeError,\n08167\t                \"Unexpected error in an Op's C code. \"\n08168\t                \"No Python exception was set.\");\n08169\t            }\n08170\t        goto __label_94;}\n08171\t            }\n08172\t            if (!PyArray_Check(py_V93)) {\n08173\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n08174\t                {\n08175\t        __failure = 94;\n08176\t        if (!PyErr_Occurred()) {\n08177\t            PyErr_SetString(PyExc_RuntimeError,\n08178\t                \"Unexpected error in an Op's C code. \"\n08179\t                \"No Python exception was set.\");\n08180\t            }\n08181\t        goto __label_94;}\n08182\t            }\n08183\t            // We expect NPY_FLOAT64\n08184\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V93)) {\n08185\t                PyArrayObject * tmp = (PyArrayObject*) py_V93;\n08186\t                PyErr_Format(PyExc_NotImplementedError,\n08187\t                             \"expected an aligned array of type %ld \"\n08188\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n08189\t                             \" with %ld dimensions, with 3 last dims \"\n08190\t                             \"%ld, %ld, %ld\"\n08191\t                             \" and 3 last strides %ld %ld, %ld.\",\n08192\t                             (long int) NPY_FLOAT64,\n08193\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V93),\n08194\t                             (long int) PyArray_NDIM(tmp),\n08195\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n08196\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n08197\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n08198\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n08199\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n08200\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n08201\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n08202\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n08203\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n08204\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n08205\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n08206\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n08207\t            );\n08208\t                {\n08209\t        __failure = 94;\n08210\t        if (!PyErr_Occurred()) {\n08211\t            PyErr_SetString(PyExc_RuntimeError,\n08212\t                \"Unexpected error in an Op's C code. \"\n08213\t                \"No Python exception was set.\");\n08214\t            }\n08215\t        goto __label_94;}\n08216\t            }\n08217\t            // This is a TypeError to be consistent with DEBUG_MODE\n08218\t            // Note: DEBUG_MODE also tells the name of the container\n08219\t            if (PyArray_TYPE((PyArrayObject*) py_V93) != NPY_FLOAT64) {\n08220\t                PyErr_Format(PyExc_TypeError,\n08221\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n08222\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V93));\n08223\t                {\n08224\t        __failure = 94;\n08225\t        if (!PyErr_Occurred()) {\n08226\t            PyErr_SetString(PyExc_RuntimeError,\n08227\t                \"Unexpected error in an Op's C code. \"\n08228\t                \"No Python exception was set.\");\n08229\t            }\n08230\t        goto __label_94;}\n08231\t            }\n08232\t            \n08233\t        V93 = (PyArrayObject*)(py_V93);\n08234\t        Py_XINCREF(V93);\n08235\t        \n08236\t{\n08237\t\n08238\t    py_V95 = PyList_GET_ITEM(storage_V95, 0);\n08239\t    {Py_XINCREF(py_V95);}\n08240\t    \n08241\t            V95 = NULL;\n08242\t            if (py_V95 == Py_None) {\n08243\t                // We can either fail here or set V95 to NULL and rely on Ops\n08244\t                // using tensors to handle the NULL case, but if they fail to do so\n08245\t                // they'll end up with nasty segfaults, so this is public service.\n08246\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n08247\t                {\n08248\t        __failure = 96;\n08249\t        if (!PyErr_Occurred()) {\n08250\t            PyErr_SetString(PyExc_RuntimeError,\n08251\t                \"Unexpected error in an Op's C code. \"\n08252\t                \"No Python exception was set.\");\n08253\t            }\n08254\t        goto __label_96;}\n08255\t            }\n08256\t            if (!PyArray_Check(py_V95)) {\n08257\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n08258\t                {\n08259\t        __failure = 96;\n08260\t        if (!PyErr_Occurred()) {\n08261\t            PyErr_SetString(PyExc_RuntimeError,\n08262\t                \"Unexpected error in an Op's C code. \"\n08263\t                \"No Python exception was set.\");\n08264\t            }\n08265\t        goto __label_96;}\n08266\t            }\n08267\t            // We expect NPY_FLOAT64\n08268\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V95)) {\n08269\t                PyArrayObject * tmp = (PyArrayObject*) py_V95;\n08270\t                PyErr_Format(PyExc_NotImplementedError,\n08271\t                             \"expected an aligned array of type %ld \"\n08272\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n08273\t                             \" with %ld dimensions, with 3 last dims \"\n08274\t                             \"%ld, %ld, %ld\"\n08275\t                             \" and 3 last strides %ld %ld, %ld.\",\n08276\t                             (long int) NPY_FLOAT64,\n08277\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V95),\n08278\t                             (long int) PyArray_NDIM(tmp),\n08279\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n08280\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n08281\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n08282\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n08283\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n08284\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n08285\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n08286\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n08287\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n08288\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n08289\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n08290\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n08291\t            );\n08292\t                {\n08293\t        __failure = 96;\n08294\t        if (!PyErr_Occurred()) {\n08295\t            PyErr_SetString(PyExc_RuntimeError,\n08296\t                \"Unexpected error in an Op's C code. \"\n08297\t                \"No Python exception was set.\");\n08298\t            }\n08299\t        goto __label_96;}\n08300\t            }\n08301\t            // This is a TypeError to be consistent with DEBUG_MODE\n08302\t            // Note: DEBUG_MODE also tells the name of the container\n08303\t            if (PyArray_TYPE((PyArrayObject*) py_V95) != NPY_FLOAT64) {\n08304\t                PyErr_Format(PyExc_TypeError,\n08305\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n08306\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V95));\n08307\t                {\n08308\t        __failure = 96;\n08309\t        if (!PyErr_Occurred()) {\n08310\t            PyErr_SetString(PyExc_RuntimeError,\n08311\t                \"Unexpected error in an Op's C code. \"\n08312\t                \"No Python exception was set.\");\n08313\t            }\n08314\t        goto __label_96;}\n08315\t            }\n08316\t            \n08317\t        V95 = (PyArrayObject*)(py_V95);\n08318\t        Py_XINCREF(V95);\n08319\t        \n08320\t{\n08321\t\n08322\t    py_V97 = PyList_GET_ITEM(storage_V97, 0);\n08323\t    {Py_XINCREF(py_V97);}\n08324\t    \n08325\t            V97 = NULL;\n08326\t            if (py_V97 == Py_None) {\n08327\t                // We can either fail here or set V97 to NULL and rely on Ops\n08328\t                // using tensors to handle the NULL case, but if they fail to do so\n08329\t                // they'll end up with nasty segfaults, so this is public service.\n08330\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n08331\t                {\n08332\t        __failure = 98;\n08333\t        if (!PyErr_Occurred()) {\n08334\t            PyErr_SetString(PyExc_RuntimeError,\n08335\t                \"Unexpected error in an Op's C code. \"\n08336\t                \"No Python exception was set.\");\n08337\t            }\n08338\t        goto __label_98;}\n08339\t            }\n08340\t            if (!PyArray_Check(py_V97)) {\n08341\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n08342\t                {\n08343\t        __failure = 98;\n08344\t        if (!PyErr_Occurred()) {\n08345\t            PyErr_SetString(PyExc_RuntimeError,\n08346\t                \"Unexpected error in an Op's C code. \"\n08347\t                \"No Python exception was set.\");\n08348\t            }\n08349\t        goto __label_98;}\n08350\t            }\n08351\t            // We expect NPY_FLOAT64\n08352\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V97)) {\n08353\t                PyArrayObject * tmp = (PyArrayObject*) py_V97;\n08354\t                PyErr_Format(PyExc_NotImplementedError,\n08355\t                             \"expected an aligned array of type %ld \"\n08356\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n08357\t                             \" with %ld dimensions, with 3 last dims \"\n08358\t                             \"%ld, %ld, %ld\"\n08359\t                             \" and 3 last strides %ld %ld, %ld.\",\n08360\t                             (long int) NPY_FLOAT64,\n08361\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V97),\n08362\t                             (long int) PyArray_NDIM(tmp),\n08363\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n08364\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n08365\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n08366\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n08367\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n08368\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n08369\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n08370\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n08371\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n08372\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n08373\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n08374\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n08375\t            );\n08376\t                {\n08377\t        __failure = 98;\n08378\t        if (!PyErr_Occurred()) {\n08379\t            PyErr_SetString(PyExc_RuntimeError,\n08380\t                \"Unexpected error in an Op's C code. \"\n08381\t                \"No Python exception was set.\");\n08382\t            }\n08383\t        goto __label_98;}\n08384\t            }\n08385\t            // This is a TypeError to be consistent with DEBUG_MODE\n08386\t            // Note: DEBUG_MODE also tells the name of the container\n08387\t            if (PyArray_TYPE((PyArrayObject*) py_V97) != NPY_FLOAT64) {\n08388\t                PyErr_Format(PyExc_TypeError,\n08389\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n08390\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V97));\n08391\t                {\n08392\t        __failure = 98;\n08393\t        if (!PyErr_Occurred()) {\n08394\t            PyErr_SetString(PyExc_RuntimeError,\n08395\t                \"Unexpected error in an Op's C code. \"\n08396\t                \"No Python exception was set.\");\n08397\t            }\n08398\t        goto __label_98;}\n08399\t            }\n08400\t            \n08401\t        V97 = (PyArrayObject*)(py_V97);\n08402\t        Py_XINCREF(V97);\n08403\t        \n08404\t{\n08405\t\n08406\t    py_V99 = PyList_GET_ITEM(storage_V99, 0);\n08407\t    {Py_XINCREF(py_V99);}\n08408\t    \n08409\t            V99 = NULL;\n08410\t            if (py_V99 == Py_None) {\n08411\t                // We can either fail here or set V99 to NULL and rely on Ops\n08412\t                // using tensors to handle the NULL case, but if they fail to do so\n08413\t                // they'll end up with nasty segfaults, so this is public service.\n08414\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n08415\t                {\n08416\t        __failure = 100;\n08417\t        if (!PyErr_Occurred()) {\n08418\t            PyErr_SetString(PyExc_RuntimeError,\n08419\t                \"Unexpected error in an Op's C code. \"\n08420\t                \"No Python exception was set.\");\n08421\t            }\n08422\t        goto __label_100;}\n08423\t            }\n08424\t            if (!PyArray_Check(py_V99)) {\n08425\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n08426\t                {\n08427\t        __failure = 100;\n08428\t        if (!PyErr_Occurred()) {\n08429\t            PyErr_SetString(PyExc_RuntimeError,\n08430\t                \"Unexpected error in an Op's C code. \"\n08431\t                \"No Python exception was set.\");\n08432\t            }\n08433\t        goto __label_100;}\n08434\t            }\n08435\t            // We expect NPY_FLOAT64\n08436\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V99)) {\n08437\t                PyArrayObject * tmp = (PyArrayObject*) py_V99;\n08438\t                PyErr_Format(PyExc_NotImplementedError,\n08439\t                             \"expected an aligned array of type %ld \"\n08440\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n08441\t                             \" with %ld dimensions, with 3 last dims \"\n08442\t                             \"%ld, %ld, %ld\"\n08443\t                             \" and 3 last strides %ld %ld, %ld.\",\n08444\t                             (long int) NPY_FLOAT64,\n08445\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V99),\n08446\t                             (long int) PyArray_NDIM(tmp),\n08447\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n08448\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n08449\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n08450\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n08451\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n08452\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n08453\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n08454\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n08455\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n08456\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n08457\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n08458\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n08459\t            );\n08460\t                {\n08461\t        __failure = 100;\n08462\t        if (!PyErr_Occurred()) {\n08463\t            PyErr_SetString(PyExc_RuntimeError,\n08464\t                \"Unexpected error in an Op's C code. \"\n08465\t                \"No Python exception was set.\");\n08466\t            }\n08467\t        goto __label_100;}\n08468\t            }\n08469\t            // This is a TypeError to be consistent with DEBUG_MODE\n08470\t            // Note: DEBUG_MODE also tells the name of the container\n08471\t            if (PyArray_TYPE((PyArrayObject*) py_V99) != NPY_FLOAT64) {\n08472\t                PyErr_Format(PyExc_TypeError,\n08473\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n08474\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V99));\n08475\t                {\n08476\t        __failure = 100;\n08477\t        if (!PyErr_Occurred()) {\n08478\t            PyErr_SetString(PyExc_RuntimeError,\n08479\t                \"Unexpected error in an Op's C code. \"\n08480\t                \"No Python exception was set.\");\n08481\t            }\n08482\t        goto __label_100;}\n08483\t            }\n08484\t            \n08485\t        V99 = (PyArrayObject*)(py_V99);\n08486\t        Py_XINCREF(V99);\n08487\t        \n08488\t{\n08489\t\n08490\t    py_V101 = PyList_GET_ITEM(storage_V101, 0);\n08491\t    {Py_XINCREF(py_V101);}\n08492\t    \n08493\t            V101 = NULL;\n08494\t            if (py_V101 == Py_None) {\n08495\t                // We can either fail here or set V101 to NULL and rely on Ops\n08496\t                // using tensors to handle the NULL case, but if they fail to do so\n08497\t                // they'll end up with nasty segfaults, so this is public service.\n08498\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n08499\t                {\n08500\t        __failure = 102;\n08501\t        if (!PyErr_Occurred()) {\n08502\t            PyErr_SetString(PyExc_RuntimeError,\n08503\t                \"Unexpected error in an Op's C code. \"\n08504\t                \"No Python exception was set.\");\n08505\t            }\n08506\t        goto __label_102;}\n08507\t            }\n08508\t            if (!PyArray_Check(py_V101)) {\n08509\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n08510\t                {\n08511\t        __failure = 102;\n08512\t        if (!PyErr_Occurred()) {\n08513\t            PyErr_SetString(PyExc_RuntimeError,\n08514\t                \"Unexpected error in an Op's C code. \"\n08515\t                \"No Python exception was set.\");\n08516\t            }\n08517\t        goto __label_102;}\n08518\t            }\n08519\t            // We expect NPY_FLOAT64\n08520\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V101)) {\n08521\t                PyArrayObject * tmp = (PyArrayObject*) py_V101;\n08522\t                PyErr_Format(PyExc_NotImplementedError,\n08523\t                             \"expected an aligned array of type %ld \"\n08524\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n08525\t                             \" with %ld dimensions, with 3 last dims \"\n08526\t                             \"%ld, %ld, %ld\"\n08527\t                             \" and 3 last strides %ld %ld, %ld.\",\n08528\t                             (long int) NPY_FLOAT64,\n08529\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V101),\n08530\t                             (long int) PyArray_NDIM(tmp),\n08531\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n08532\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n08533\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n08534\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n08535\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n08536\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n08537\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n08538\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n08539\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n08540\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n08541\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n08542\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n08543\t            );\n08544\t                {\n08545\t        __failure = 102;\n08546\t        if (!PyErr_Occurred()) {\n08547\t            PyErr_SetString(PyExc_RuntimeError,\n08548\t                \"Unexpected error in an Op's C code. \"\n08549\t                \"No Python exception was set.\");\n08550\t            }\n08551\t        goto __label_102;}\n08552\t            }\n08553\t            // This is a TypeError to be consistent with DEBUG_MODE\n08554\t            // Note: DEBUG_MODE also tells the name of the container\n08555\t            if (PyArray_TYPE((PyArrayObject*) py_V101) != NPY_FLOAT64) {\n08556\t                PyErr_Format(PyExc_TypeError,\n08557\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n08558\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V101));\n08559\t                {\n08560\t        __failure = 102;\n08561\t        if (!PyErr_Occurred()) {\n08562\t            PyErr_SetString(PyExc_RuntimeError,\n08563\t                \"Unexpected error in an Op's C code. \"\n08564\t                \"No Python exception was set.\");\n08565\t            }\n08566\t        goto __label_102;}\n08567\t            }\n08568\t            \n08569\t        V101 = (PyArrayObject*)(py_V101);\n08570\t        Py_XINCREF(V101);\n08571\t        \n08572\t{\n08573\t\n08574\t    py_V103 = PyList_GET_ITEM(storage_V103, 0);\n08575\t    {Py_XINCREF(py_V103);}\n08576\t    \n08577\t            V103 = NULL;\n08578\t            if (py_V103 == Py_None) {\n08579\t                // We can either fail here or set V103 to NULL and rely on Ops\n08580\t                // using tensors to handle the NULL case, but if they fail to do so\n08581\t                // they'll end up with nasty segfaults, so this is public service.\n08582\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n08583\t                {\n08584\t        __failure = 104;\n08585\t        if (!PyErr_Occurred()) {\n08586\t            PyErr_SetString(PyExc_RuntimeError,\n08587\t                \"Unexpected error in an Op's C code. \"\n08588\t                \"No Python exception was set.\");\n08589\t            }\n08590\t        goto __label_104;}\n08591\t            }\n08592\t            if (!PyArray_Check(py_V103)) {\n08593\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n08594\t                {\n08595\t        __failure = 104;\n08596\t        if (!PyErr_Occurred()) {\n08597\t            PyErr_SetString(PyExc_RuntimeError,\n08598\t                \"Unexpected error in an Op's C code. \"\n08599\t                \"No Python exception was set.\");\n08600\t            }\n08601\t        goto __label_104;}\n08602\t            }\n08603\t            // We expect NPY_FLOAT64\n08604\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V103)) {\n08605\t                PyArrayObject * tmp = (PyArrayObject*) py_V103;\n08606\t                PyErr_Format(PyExc_NotImplementedError,\n08607\t                             \"expected an aligned array of type %ld \"\n08608\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n08609\t                             \" with %ld dimensions, with 3 last dims \"\n08610\t                             \"%ld, %ld, %ld\"\n08611\t                             \" and 3 last strides %ld %ld, %ld.\",\n08612\t                             (long int) NPY_FLOAT64,\n08613\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V103),\n08614\t                             (long int) PyArray_NDIM(tmp),\n08615\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n08616\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n08617\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n08618\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n08619\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n08620\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n08621\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n08622\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n08623\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n08624\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n08625\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n08626\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n08627\t            );\n08628\t                {\n08629\t        __failure = 104;\n08630\t        if (!PyErr_Occurred()) {\n08631\t            PyErr_SetString(PyExc_RuntimeError,\n08632\t                \"Unexpected error in an Op's C code. \"\n08633\t                \"No Python exception was set.\");\n08634\t            }\n08635\t        goto __label_104;}\n08636\t            }\n08637\t            // This is a TypeError to be consistent with DEBUG_MODE\n08638\t            // Note: DEBUG_MODE also tells the name of the container\n08639\t            if (PyArray_TYPE((PyArrayObject*) py_V103) != NPY_FLOAT64) {\n08640\t                PyErr_Format(PyExc_TypeError,\n08641\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n08642\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V103));\n08643\t                {\n08644\t        __failure = 104;\n08645\t        if (!PyErr_Occurred()) {\n08646\t            PyErr_SetString(PyExc_RuntimeError,\n08647\t                \"Unexpected error in an Op's C code. \"\n08648\t                \"No Python exception was set.\");\n08649\t            }\n08650\t        goto __label_104;}\n08651\t            }\n08652\t            \n08653\t        V103 = (PyArrayObject*)(py_V103);\n08654\t        Py_XINCREF(V103);\n08655\t        \n08656\t{\n08657\t\n08658\t    py_V105 = PyList_GET_ITEM(storage_V105, 0);\n08659\t    {Py_XINCREF(py_V105);}\n08660\t    \n08661\t            V105 = NULL;\n08662\t            if (py_V105 == Py_None) {\n08663\t                // We can either fail here or set V105 to NULL and rely on Ops\n08664\t                // using tensors to handle the NULL case, but if they fail to do so\n08665\t                // they'll end up with nasty segfaults, so this is public service.\n08666\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n08667\t                {\n08668\t        __failure = 106;\n08669\t        if (!PyErr_Occurred()) {\n08670\t            PyErr_SetString(PyExc_RuntimeError,\n08671\t                \"Unexpected error in an Op's C code. \"\n08672\t                \"No Python exception was set.\");\n08673\t            }\n08674\t        goto __label_106;}\n08675\t            }\n08676\t            if (!PyArray_Check(py_V105)) {\n08677\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n08678\t                {\n08679\t        __failure = 106;\n08680\t        if (!PyErr_Occurred()) {\n08681\t            PyErr_SetString(PyExc_RuntimeError,\n08682\t                \"Unexpected error in an Op's C code. \"\n08683\t                \"No Python exception was set.\");\n08684\t            }\n08685\t        goto __label_106;}\n08686\t            }\n08687\t            // We expect NPY_FLOAT64\n08688\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V105)) {\n08689\t                PyArrayObject * tmp = (PyArrayObject*) py_V105;\n08690\t                PyErr_Format(PyExc_NotImplementedError,\n08691\t                             \"expected an aligned array of type %ld \"\n08692\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n08693\t                             \" with %ld dimensions, with 3 last dims \"\n08694\t                             \"%ld, %ld, %ld\"\n08695\t                             \" and 3 last strides %ld %ld, %ld.\",\n08696\t                             (long int) NPY_FLOAT64,\n08697\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V105),\n08698\t                             (long int) PyArray_NDIM(tmp),\n08699\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n08700\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n08701\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n08702\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n08703\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n08704\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n08705\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n08706\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n08707\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n08708\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n08709\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n08710\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n08711\t            );\n08712\t                {\n08713\t        __failure = 106;\n08714\t        if (!PyErr_Occurred()) {\n08715\t            PyErr_SetString(PyExc_RuntimeError,\n08716\t                \"Unexpected error in an Op's C code. \"\n08717\t                \"No Python exception was set.\");\n08718\t            }\n08719\t        goto __label_106;}\n08720\t            }\n08721\t            // This is a TypeError to be consistent with DEBUG_MODE\n08722\t            // Note: DEBUG_MODE also tells the name of the container\n08723\t            if (PyArray_TYPE((PyArrayObject*) py_V105) != NPY_FLOAT64) {\n08724\t                PyErr_Format(PyExc_TypeError,\n08725\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n08726\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V105));\n08727\t                {\n08728\t        __failure = 106;\n08729\t        if (!PyErr_Occurred()) {\n08730\t            PyErr_SetString(PyExc_RuntimeError,\n08731\t                \"Unexpected error in an Op's C code. \"\n08732\t                \"No Python exception was set.\");\n08733\t            }\n08734\t        goto __label_106;}\n08735\t            }\n08736\t            \n08737\t        V105 = (PyArrayObject*)(py_V105);\n08738\t        Py_XINCREF(V105);\n08739\t        \n08740\t{\n08741\t\n08742\t    py_V107 = PyList_GET_ITEM(storage_V107, 0);\n08743\t    {Py_XINCREF(py_V107);}\n08744\t    \n08745\t            V107 = NULL;\n08746\t            if (py_V107 == Py_None) {\n08747\t                // We can either fail here or set V107 to NULL and rely on Ops\n08748\t                // using tensors to handle the NULL case, but if they fail to do so\n08749\t                // they'll end up with nasty segfaults, so this is public service.\n08750\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n08751\t                {\n08752\t        __failure = 108;\n08753\t        if (!PyErr_Occurred()) {\n08754\t            PyErr_SetString(PyExc_RuntimeError,\n08755\t                \"Unexpected error in an Op's C code. \"\n08756\t                \"No Python exception was set.\");\n08757\t            }\n08758\t        goto __label_108;}\n08759\t            }\n08760\t            if (!PyArray_Check(py_V107)) {\n08761\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n08762\t                {\n08763\t        __failure = 108;\n08764\t        if (!PyErr_Occurred()) {\n08765\t            PyErr_SetString(PyExc_RuntimeError,\n08766\t                \"Unexpected error in an Op's C code. \"\n08767\t                \"No Python exception was set.\");\n08768\t            }\n08769\t        goto __label_108;}\n08770\t            }\n08771\t            // We expect NPY_FLOAT64\n08772\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V107)) {\n08773\t                PyArrayObject * tmp = (PyArrayObject*) py_V107;\n08774\t                PyErr_Format(PyExc_NotImplementedError,\n08775\t                             \"expected an aligned array of type %ld \"\n08776\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n08777\t                             \" with %ld dimensions, with 3 last dims \"\n08778\t                             \"%ld, %ld, %ld\"\n08779\t                             \" and 3 last strides %ld %ld, %ld.\",\n08780\t                             (long int) NPY_FLOAT64,\n08781\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V107),\n08782\t                             (long int) PyArray_NDIM(tmp),\n08783\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n08784\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n08785\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n08786\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n08787\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n08788\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n08789\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n08790\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n08791\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n08792\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n08793\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n08794\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n08795\t            );\n08796\t                {\n08797\t        __failure = 108;\n08798\t        if (!PyErr_Occurred()) {\n08799\t            PyErr_SetString(PyExc_RuntimeError,\n08800\t                \"Unexpected error in an Op's C code. \"\n08801\t                \"No Python exception was set.\");\n08802\t            }\n08803\t        goto __label_108;}\n08804\t            }\n08805\t            // This is a TypeError to be consistent with DEBUG_MODE\n08806\t            // Note: DEBUG_MODE also tells the name of the container\n08807\t            if (PyArray_TYPE((PyArrayObject*) py_V107) != NPY_FLOAT64) {\n08808\t                PyErr_Format(PyExc_TypeError,\n08809\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n08810\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V107));\n08811\t                {\n08812\t        __failure = 108;\n08813\t        if (!PyErr_Occurred()) {\n08814\t            PyErr_SetString(PyExc_RuntimeError,\n08815\t                \"Unexpected error in an Op's C code. \"\n08816\t                \"No Python exception was set.\");\n08817\t            }\n08818\t        goto __label_108;}\n08819\t            }\n08820\t            \n08821\t        V107 = (PyArrayObject*)(py_V107);\n08822\t        Py_XINCREF(V107);\n08823\t        \n08824\t{\n08825\t\n08826\t    py_V109 = PyList_GET_ITEM(storage_V109, 0);\n08827\t    {Py_XINCREF(py_V109);}\n08828\t    \n08829\t            V109 = NULL;\n08830\t            if (py_V109 == Py_None) {\n08831\t                // We can either fail here or set V109 to NULL and rely on Ops\n08832\t                // using tensors to handle the NULL case, but if they fail to do so\n08833\t                // they'll end up with nasty segfaults, so this is public service.\n08834\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n08835\t                {\n08836\t        __failure = 110;\n08837\t        if (!PyErr_Occurred()) {\n08838\t            PyErr_SetString(PyExc_RuntimeError,\n08839\t                \"Unexpected error in an Op's C code. \"\n08840\t                \"No Python exception was set.\");\n08841\t            }\n08842\t        goto __label_110;}\n08843\t            }\n08844\t            if (!PyArray_Check(py_V109)) {\n08845\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n08846\t                {\n08847\t        __failure = 110;\n08848\t        if (!PyErr_Occurred()) {\n08849\t            PyErr_SetString(PyExc_RuntimeError,\n08850\t                \"Unexpected error in an Op's C code. \"\n08851\t                \"No Python exception was set.\");\n08852\t            }\n08853\t        goto __label_110;}\n08854\t            }\n08855\t            // We expect NPY_FLOAT64\n08856\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V109)) {\n08857\t                PyArrayObject * tmp = (PyArrayObject*) py_V109;\n08858\t                PyErr_Format(PyExc_NotImplementedError,\n08859\t                             \"expected an aligned array of type %ld \"\n08860\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n08861\t                             \" with %ld dimensions, with 3 last dims \"\n08862\t                             \"%ld, %ld, %ld\"\n08863\t                             \" and 3 last strides %ld %ld, %ld.\",\n08864\t                             (long int) NPY_FLOAT64,\n08865\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V109),\n08866\t                             (long int) PyArray_NDIM(tmp),\n08867\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n08868\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n08869\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n08870\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n08871\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n08872\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n08873\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n08874\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n08875\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n08876\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n08877\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n08878\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n08879\t            );\n08880\t                {\n08881\t        __failure = 110;\n08882\t        if (!PyErr_Occurred()) {\n08883\t            PyErr_SetString(PyExc_RuntimeError,\n08884\t                \"Unexpected error in an Op's C code. \"\n08885\t                \"No Python exception was set.\");\n08886\t            }\n08887\t        goto __label_110;}\n08888\t            }\n08889\t            // This is a TypeError to be consistent with DEBUG_MODE\n08890\t            // Note: DEBUG_MODE also tells the name of the container\n08891\t            if (PyArray_TYPE((PyArrayObject*) py_V109) != NPY_FLOAT64) {\n08892\t                PyErr_Format(PyExc_TypeError,\n08893\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n08894\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V109));\n08895\t                {\n08896\t        __failure = 110;\n08897\t        if (!PyErr_Occurred()) {\n08898\t            PyErr_SetString(PyExc_RuntimeError,\n08899\t                \"Unexpected error in an Op's C code. \"\n08900\t                \"No Python exception was set.\");\n08901\t            }\n08902\t        goto __label_110;}\n08903\t            }\n08904\t            \n08905\t        V109 = (PyArrayObject*)(py_V109);\n08906\t        Py_XINCREF(V109);\n08907\t        \n08908\t{\n08909\t\n08910\t    py_V111 = PyList_GET_ITEM(storage_V111, 0);\n08911\t    {Py_XINCREF(py_V111);}\n08912\t    \n08913\t            V111 = NULL;\n08914\t            if (py_V111 == Py_None) {\n08915\t                // We can either fail here or set V111 to NULL and rely on Ops\n08916\t                // using tensors to handle the NULL case, but if they fail to do so\n08917\t                // they'll end up with nasty segfaults, so this is public service.\n08918\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n08919\t                {\n08920\t        __failure = 112;\n08921\t        if (!PyErr_Occurred()) {\n08922\t            PyErr_SetString(PyExc_RuntimeError,\n08923\t                \"Unexpected error in an Op's C code. \"\n08924\t                \"No Python exception was set.\");\n08925\t            }\n08926\t        goto __label_112;}\n08927\t            }\n08928\t            if (!PyArray_Check(py_V111)) {\n08929\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n08930\t                {\n08931\t        __failure = 112;\n08932\t        if (!PyErr_Occurred()) {\n08933\t            PyErr_SetString(PyExc_RuntimeError,\n08934\t                \"Unexpected error in an Op's C code. \"\n08935\t                \"No Python exception was set.\");\n08936\t            }\n08937\t        goto __label_112;}\n08938\t            }\n08939\t            // We expect NPY_FLOAT64\n08940\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V111)) {\n08941\t                PyArrayObject * tmp = (PyArrayObject*) py_V111;\n08942\t                PyErr_Format(PyExc_NotImplementedError,\n08943\t                             \"expected an aligned array of type %ld \"\n08944\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n08945\t                             \" with %ld dimensions, with 3 last dims \"\n08946\t                             \"%ld, %ld, %ld\"\n08947\t                             \" and 3 last strides %ld %ld, %ld.\",\n08948\t                             (long int) NPY_FLOAT64,\n08949\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V111),\n08950\t                             (long int) PyArray_NDIM(tmp),\n08951\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n08952\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n08953\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n08954\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n08955\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n08956\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n08957\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n08958\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n08959\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n08960\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n08961\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n08962\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n08963\t            );\n08964\t                {\n08965\t        __failure = 112;\n08966\t        if (!PyErr_Occurred()) {\n08967\t            PyErr_SetString(PyExc_RuntimeError,\n08968\t                \"Unexpected error in an Op's C code. \"\n08969\t                \"No Python exception was set.\");\n08970\t            }\n08971\t        goto __label_112;}\n08972\t            }\n08973\t            // This is a TypeError to be consistent with DEBUG_MODE\n08974\t            // Note: DEBUG_MODE also tells the name of the container\n08975\t            if (PyArray_TYPE((PyArrayObject*) py_V111) != NPY_FLOAT64) {\n08976\t                PyErr_Format(PyExc_TypeError,\n08977\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n08978\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V111));\n08979\t                {\n08980\t        __failure = 112;\n08981\t        if (!PyErr_Occurred()) {\n08982\t            PyErr_SetString(PyExc_RuntimeError,\n08983\t                \"Unexpected error in an Op's C code. \"\n08984\t                \"No Python exception was set.\");\n08985\t            }\n08986\t        goto __label_112;}\n08987\t            }\n08988\t            \n08989\t        V111 = (PyArrayObject*)(py_V111);\n08990\t        Py_XINCREF(V111);\n08991\t        \n08992\t{\n08993\t\n08994\t    py_V113 = PyList_GET_ITEM(storage_V113, 0);\n08995\t    {Py_XINCREF(py_V113);}\n08996\t    \n08997\t            V113 = NULL;\n08998\t            if (py_V113 == Py_None) {\n08999\t                // We can either fail here or set V113 to NULL and rely on Ops\n09000\t                // using tensors to handle the NULL case, but if they fail to do so\n09001\t                // they'll end up with nasty segfaults, so this is public service.\n09002\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n09003\t                {\n09004\t        __failure = 114;\n09005\t        if (!PyErr_Occurred()) {\n09006\t            PyErr_SetString(PyExc_RuntimeError,\n09007\t                \"Unexpected error in an Op's C code. \"\n09008\t                \"No Python exception was set.\");\n09009\t            }\n09010\t        goto __label_114;}\n09011\t            }\n09012\t            if (!PyArray_Check(py_V113)) {\n09013\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n09014\t                {\n09015\t        __failure = 114;\n09016\t        if (!PyErr_Occurred()) {\n09017\t            PyErr_SetString(PyExc_RuntimeError,\n09018\t                \"Unexpected error in an Op's C code. \"\n09019\t                \"No Python exception was set.\");\n09020\t            }\n09021\t        goto __label_114;}\n09022\t            }\n09023\t            // We expect NPY_FLOAT64\n09024\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V113)) {\n09025\t                PyArrayObject * tmp = (PyArrayObject*) py_V113;\n09026\t                PyErr_Format(PyExc_NotImplementedError,\n09027\t                             \"expected an aligned array of type %ld \"\n09028\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n09029\t                             \" with %ld dimensions, with 3 last dims \"\n09030\t                             \"%ld, %ld, %ld\"\n09031\t                             \" and 3 last strides %ld %ld, %ld.\",\n09032\t                             (long int) NPY_FLOAT64,\n09033\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V113),\n09034\t                             (long int) PyArray_NDIM(tmp),\n09035\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n09036\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n09037\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n09038\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n09039\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n09040\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n09041\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n09042\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n09043\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n09044\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n09045\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n09046\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n09047\t            );\n09048\t                {\n09049\t        __failure = 114;\n09050\t        if (!PyErr_Occurred()) {\n09051\t            PyErr_SetString(PyExc_RuntimeError,\n09052\t                \"Unexpected error in an Op's C code. \"\n09053\t                \"No Python exception was set.\");\n09054\t            }\n09055\t        goto __label_114;}\n09056\t            }\n09057\t            // This is a TypeError to be consistent with DEBUG_MODE\n09058\t            // Note: DEBUG_MODE also tells the name of the container\n09059\t            if (PyArray_TYPE((PyArrayObject*) py_V113) != NPY_FLOAT64) {\n09060\t                PyErr_Format(PyExc_TypeError,\n09061\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n09062\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V113));\n09063\t                {\n09064\t        __failure = 114;\n09065\t        if (!PyErr_Occurred()) {\n09066\t            PyErr_SetString(PyExc_RuntimeError,\n09067\t                \"Unexpected error in an Op's C code. \"\n09068\t                \"No Python exception was set.\");\n09069\t            }\n09070\t        goto __label_114;}\n09071\t            }\n09072\t            \n09073\t        V113 = (PyArrayObject*)(py_V113);\n09074\t        Py_XINCREF(V113);\n09075\t        \n09076\t{\n09077\t\n09078\t    py_V115 = PyList_GET_ITEM(storage_V115, 0);\n09079\t    {Py_XINCREF(py_V115);}\n09080\t    \n09081\t            V115 = NULL;\n09082\t            if (py_V115 == Py_None) {\n09083\t                // We can either fail here or set V115 to NULL and rely on Ops\n09084\t                // using tensors to handle the NULL case, but if they fail to do so\n09085\t                // they'll end up with nasty segfaults, so this is public service.\n09086\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n09087\t                {\n09088\t        __failure = 116;\n09089\t        if (!PyErr_Occurred()) {\n09090\t            PyErr_SetString(PyExc_RuntimeError,\n09091\t                \"Unexpected error in an Op's C code. \"\n09092\t                \"No Python exception was set.\");\n09093\t            }\n09094\t        goto __label_116;}\n09095\t            }\n09096\t            if (!PyArray_Check(py_V115)) {\n09097\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n09098\t                {\n09099\t        __failure = 116;\n09100\t        if (!PyErr_Occurred()) {\n09101\t            PyErr_SetString(PyExc_RuntimeError,\n09102\t                \"Unexpected error in an Op's C code. \"\n09103\t                \"No Python exception was set.\");\n09104\t            }\n09105\t        goto __label_116;}\n09106\t            }\n09107\t            // We expect NPY_FLOAT64\n09108\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V115)) {\n09109\t                PyArrayObject * tmp = (PyArrayObject*) py_V115;\n09110\t                PyErr_Format(PyExc_NotImplementedError,\n09111\t                             \"expected an aligned array of type %ld \"\n09112\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n09113\t                             \" with %ld dimensions, with 3 last dims \"\n09114\t                             \"%ld, %ld, %ld\"\n09115\t                             \" and 3 last strides %ld %ld, %ld.\",\n09116\t                             (long int) NPY_FLOAT64,\n09117\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V115),\n09118\t                             (long int) PyArray_NDIM(tmp),\n09119\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n09120\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n09121\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n09122\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n09123\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n09124\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n09125\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n09126\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n09127\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n09128\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n09129\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n09130\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n09131\t            );\n09132\t                {\n09133\t        __failure = 116;\n09134\t        if (!PyErr_Occurred()) {\n09135\t            PyErr_SetString(PyExc_RuntimeError,\n09136\t                \"Unexpected error in an Op's C code. \"\n09137\t                \"No Python exception was set.\");\n09138\t            }\n09139\t        goto __label_116;}\n09140\t            }\n09141\t            // This is a TypeError to be consistent with DEBUG_MODE\n09142\t            // Note: DEBUG_MODE also tells the name of the container\n09143\t            if (PyArray_TYPE((PyArrayObject*) py_V115) != NPY_FLOAT64) {\n09144\t                PyErr_Format(PyExc_TypeError,\n09145\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n09146\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V115));\n09147\t                {\n09148\t        __failure = 116;\n09149\t        if (!PyErr_Occurred()) {\n09150\t            PyErr_SetString(PyExc_RuntimeError,\n09151\t                \"Unexpected error in an Op's C code. \"\n09152\t                \"No Python exception was set.\");\n09153\t            }\n09154\t        goto __label_116;}\n09155\t            }\n09156\t            \n09157\t        V115 = (PyArrayObject*)(py_V115);\n09158\t        Py_XINCREF(V115);\n09159\t        \n09160\t{\n09161\t\n09162\t    py_V117 = PyList_GET_ITEM(storage_V117, 0);\n09163\t    {Py_XINCREF(py_V117);}\n09164\t    \n09165\t            V117 = NULL;\n09166\t            if (py_V117 == Py_None) {\n09167\t                // We can either fail here or set V117 to NULL and rely on Ops\n09168\t                // using tensors to handle the NULL case, but if they fail to do so\n09169\t                // they'll end up with nasty segfaults, so this is public service.\n09170\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n09171\t                {\n09172\t        __failure = 118;\n09173\t        if (!PyErr_Occurred()) {\n09174\t            PyErr_SetString(PyExc_RuntimeError,\n09175\t                \"Unexpected error in an Op's C code. \"\n09176\t                \"No Python exception was set.\");\n09177\t            }\n09178\t        goto __label_118;}\n09179\t            }\n09180\t            if (!PyArray_Check(py_V117)) {\n09181\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n09182\t                {\n09183\t        __failure = 118;\n09184\t        if (!PyErr_Occurred()) {\n09185\t            PyErr_SetString(PyExc_RuntimeError,\n09186\t                \"Unexpected error in an Op's C code. \"\n09187\t                \"No Python exception was set.\");\n09188\t            }\n09189\t        goto __label_118;}\n09190\t            }\n09191\t            // We expect NPY_FLOAT64\n09192\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V117)) {\n09193\t                PyArrayObject * tmp = (PyArrayObject*) py_V117;\n09194\t                PyErr_Format(PyExc_NotImplementedError,\n09195\t                             \"expected an aligned array of type %ld \"\n09196\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n09197\t                             \" with %ld dimensions, with 3 last dims \"\n09198\t                             \"%ld, %ld, %ld\"\n09199\t                             \" and 3 last strides %ld %ld, %ld.\",\n09200\t                             (long int) NPY_FLOAT64,\n09201\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V117),\n09202\t                             (long int) PyArray_NDIM(tmp),\n09203\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n09204\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n09205\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n09206\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n09207\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n09208\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n09209\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n09210\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n09211\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n09212\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n09213\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n09214\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n09215\t            );\n09216\t                {\n09217\t        __failure = 118;\n09218\t        if (!PyErr_Occurred()) {\n09219\t            PyErr_SetString(PyExc_RuntimeError,\n09220\t                \"Unexpected error in an Op's C code. \"\n09221\t                \"No Python exception was set.\");\n09222\t            }\n09223\t        goto __label_118;}\n09224\t            }\n09225\t            // This is a TypeError to be consistent with DEBUG_MODE\n09226\t            // Note: DEBUG_MODE also tells the name of the container\n09227\t            if (PyArray_TYPE((PyArrayObject*) py_V117) != NPY_FLOAT64) {\n09228\t                PyErr_Format(PyExc_TypeError,\n09229\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n09230\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V117));\n09231\t                {\n09232\t        __failure = 118;\n09233\t        if (!PyErr_Occurred()) {\n09234\t            PyErr_SetString(PyExc_RuntimeError,\n09235\t                \"Unexpected error in an Op's C code. \"\n09236\t                \"No Python exception was set.\");\n09237\t            }\n09238\t        goto __label_118;}\n09239\t            }\n09240\t            \n09241\t        V117 = (PyArrayObject*)(py_V117);\n09242\t        Py_XINCREF(V117);\n09243\t        \n09244\t{\n09245\t\n09246\t    py_V119 = PyList_GET_ITEM(storage_V119, 0);\n09247\t    {Py_XINCREF(py_V119);}\n09248\t    \n09249\t            V119 = NULL;\n09250\t            if (py_V119 == Py_None) {\n09251\t                // We can either fail here or set V119 to NULL and rely on Ops\n09252\t                // using tensors to handle the NULL case, but if they fail to do so\n09253\t                // they'll end up with nasty segfaults, so this is public service.\n09254\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n09255\t                {\n09256\t        __failure = 120;\n09257\t        if (!PyErr_Occurred()) {\n09258\t            PyErr_SetString(PyExc_RuntimeError,\n09259\t                \"Unexpected error in an Op's C code. \"\n09260\t                \"No Python exception was set.\");\n09261\t            }\n09262\t        goto __label_120;}\n09263\t            }\n09264\t            if (!PyArray_Check(py_V119)) {\n09265\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n09266\t                {\n09267\t        __failure = 120;\n09268\t        if (!PyErr_Occurred()) {\n09269\t            PyErr_SetString(PyExc_RuntimeError,\n09270\t                \"Unexpected error in an Op's C code. \"\n09271\t                \"No Python exception was set.\");\n09272\t            }\n09273\t        goto __label_120;}\n09274\t            }\n09275\t            // We expect NPY_FLOAT64\n09276\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V119)) {\n09277\t                PyArrayObject * tmp = (PyArrayObject*) py_V119;\n09278\t                PyErr_Format(PyExc_NotImplementedError,\n09279\t                             \"expected an aligned array of type %ld \"\n09280\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n09281\t                             \" with %ld dimensions, with 3 last dims \"\n09282\t                             \"%ld, %ld, %ld\"\n09283\t                             \" and 3 last strides %ld %ld, %ld.\",\n09284\t                             (long int) NPY_FLOAT64,\n09285\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V119),\n09286\t                             (long int) PyArray_NDIM(tmp),\n09287\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n09288\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n09289\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n09290\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n09291\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n09292\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n09293\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n09294\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n09295\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n09296\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n09297\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n09298\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n09299\t            );\n09300\t                {\n09301\t        __failure = 120;\n09302\t        if (!PyErr_Occurred()) {\n09303\t            PyErr_SetString(PyExc_RuntimeError,\n09304\t                \"Unexpected error in an Op's C code. \"\n09305\t                \"No Python exception was set.\");\n09306\t            }\n09307\t        goto __label_120;}\n09308\t            }\n09309\t            // This is a TypeError to be consistent with DEBUG_MODE\n09310\t            // Note: DEBUG_MODE also tells the name of the container\n09311\t            if (PyArray_TYPE((PyArrayObject*) py_V119) != NPY_FLOAT64) {\n09312\t                PyErr_Format(PyExc_TypeError,\n09313\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n09314\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V119));\n09315\t                {\n09316\t        __failure = 120;\n09317\t        if (!PyErr_Occurred()) {\n09318\t            PyErr_SetString(PyExc_RuntimeError,\n09319\t                \"Unexpected error in an Op's C code. \"\n09320\t                \"No Python exception was set.\");\n09321\t            }\n09322\t        goto __label_120;}\n09323\t            }\n09324\t            \n09325\t        V119 = (PyArrayObject*)(py_V119);\n09326\t        Py_XINCREF(V119);\n09327\t        \n09328\t{\n09329\t\n09330\t    py_V121 = PyList_GET_ITEM(storage_V121, 0);\n09331\t    {Py_XINCREF(py_V121);}\n09332\t    \n09333\t            V121 = NULL;\n09334\t            if (py_V121 == Py_None) {\n09335\t                // We can either fail here or set V121 to NULL and rely on Ops\n09336\t                // using tensors to handle the NULL case, but if they fail to do so\n09337\t                // they'll end up with nasty segfaults, so this is public service.\n09338\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n09339\t                {\n09340\t        __failure = 122;\n09341\t        if (!PyErr_Occurred()) {\n09342\t            PyErr_SetString(PyExc_RuntimeError,\n09343\t                \"Unexpected error in an Op's C code. \"\n09344\t                \"No Python exception was set.\");\n09345\t            }\n09346\t        goto __label_122;}\n09347\t            }\n09348\t            if (!PyArray_Check(py_V121)) {\n09349\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n09350\t                {\n09351\t        __failure = 122;\n09352\t        if (!PyErr_Occurred()) {\n09353\t            PyErr_SetString(PyExc_RuntimeError,\n09354\t                \"Unexpected error in an Op's C code. \"\n09355\t                \"No Python exception was set.\");\n09356\t            }\n09357\t        goto __label_122;}\n09358\t            }\n09359\t            // We expect NPY_FLOAT64\n09360\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V121)) {\n09361\t                PyArrayObject * tmp = (PyArrayObject*) py_V121;\n09362\t                PyErr_Format(PyExc_NotImplementedError,\n09363\t                             \"expected an aligned array of type %ld \"\n09364\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n09365\t                             \" with %ld dimensions, with 3 last dims \"\n09366\t                             \"%ld, %ld, %ld\"\n09367\t                             \" and 3 last strides %ld %ld, %ld.\",\n09368\t                             (long int) NPY_FLOAT64,\n09369\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V121),\n09370\t                             (long int) PyArray_NDIM(tmp),\n09371\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n09372\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n09373\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n09374\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n09375\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n09376\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n09377\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n09378\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n09379\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n09380\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n09381\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n09382\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n09383\t            );\n09384\t                {\n09385\t        __failure = 122;\n09386\t        if (!PyErr_Occurred()) {\n09387\t            PyErr_SetString(PyExc_RuntimeError,\n09388\t                \"Unexpected error in an Op's C code. \"\n09389\t                \"No Python exception was set.\");\n09390\t            }\n09391\t        goto __label_122;}\n09392\t            }\n09393\t            // This is a TypeError to be consistent with DEBUG_MODE\n09394\t            // Note: DEBUG_MODE also tells the name of the container\n09395\t            if (PyArray_TYPE((PyArrayObject*) py_V121) != NPY_FLOAT64) {\n09396\t                PyErr_Format(PyExc_TypeError,\n09397\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n09398\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V121));\n09399\t                {\n09400\t        __failure = 122;\n09401\t        if (!PyErr_Occurred()) {\n09402\t            PyErr_SetString(PyExc_RuntimeError,\n09403\t                \"Unexpected error in an Op's C code. \"\n09404\t                \"No Python exception was set.\");\n09405\t            }\n09406\t        goto __label_122;}\n09407\t            }\n09408\t            \n09409\t        V121 = (PyArrayObject*)(py_V121);\n09410\t        Py_XINCREF(V121);\n09411\t        \n09412\t{\n09413\t\n09414\t    py_V123 = PyList_GET_ITEM(storage_V123, 0);\n09415\t    {Py_XINCREF(py_V123);}\n09416\t    \n09417\t            V123 = NULL;\n09418\t            if (py_V123 == Py_None) {\n09419\t                // We can either fail here or set V123 to NULL and rely on Ops\n09420\t                // using tensors to handle the NULL case, but if they fail to do so\n09421\t                // they'll end up with nasty segfaults, so this is public service.\n09422\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n09423\t                {\n09424\t        __failure = 124;\n09425\t        if (!PyErr_Occurred()) {\n09426\t            PyErr_SetString(PyExc_RuntimeError,\n09427\t                \"Unexpected error in an Op's C code. \"\n09428\t                \"No Python exception was set.\");\n09429\t            }\n09430\t        goto __label_124;}\n09431\t            }\n09432\t            if (!PyArray_Check(py_V123)) {\n09433\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n09434\t                {\n09435\t        __failure = 124;\n09436\t        if (!PyErr_Occurred()) {\n09437\t            PyErr_SetString(PyExc_RuntimeError,\n09438\t                \"Unexpected error in an Op's C code. \"\n09439\t                \"No Python exception was set.\");\n09440\t            }\n09441\t        goto __label_124;}\n09442\t            }\n09443\t            // We expect NPY_FLOAT64\n09444\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V123)) {\n09445\t                PyArrayObject * tmp = (PyArrayObject*) py_V123;\n09446\t                PyErr_Format(PyExc_NotImplementedError,\n09447\t                             \"expected an aligned array of type %ld \"\n09448\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n09449\t                             \" with %ld dimensions, with 3 last dims \"\n09450\t                             \"%ld, %ld, %ld\"\n09451\t                             \" and 3 last strides %ld %ld, %ld.\",\n09452\t                             (long int) NPY_FLOAT64,\n09453\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V123),\n09454\t                             (long int) PyArray_NDIM(tmp),\n09455\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n09456\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n09457\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n09458\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n09459\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n09460\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n09461\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n09462\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n09463\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n09464\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n09465\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n09466\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n09467\t            );\n09468\t                {\n09469\t        __failure = 124;\n09470\t        if (!PyErr_Occurred()) {\n09471\t            PyErr_SetString(PyExc_RuntimeError,\n09472\t                \"Unexpected error in an Op's C code. \"\n09473\t                \"No Python exception was set.\");\n09474\t            }\n09475\t        goto __label_124;}\n09476\t            }\n09477\t            // This is a TypeError to be consistent with DEBUG_MODE\n09478\t            // Note: DEBUG_MODE also tells the name of the container\n09479\t            if (PyArray_TYPE((PyArrayObject*) py_V123) != NPY_FLOAT64) {\n09480\t                PyErr_Format(PyExc_TypeError,\n09481\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n09482\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V123));\n09483\t                {\n09484\t        __failure = 124;\n09485\t        if (!PyErr_Occurred()) {\n09486\t            PyErr_SetString(PyExc_RuntimeError,\n09487\t                \"Unexpected error in an Op's C code. \"\n09488\t                \"No Python exception was set.\");\n09489\t            }\n09490\t        goto __label_124;}\n09491\t            }\n09492\t            \n09493\t        V123 = (PyArrayObject*)(py_V123);\n09494\t        Py_XINCREF(V123);\n09495\t        \n09496\t{\n09497\t\n09498\t    py_V125 = PyList_GET_ITEM(storage_V125, 0);\n09499\t    {Py_XINCREF(py_V125);}\n09500\t    \n09501\t            V125 = NULL;\n09502\t            if (py_V125 == Py_None) {\n09503\t                // We can either fail here or set V125 to NULL and rely on Ops\n09504\t                // using tensors to handle the NULL case, but if they fail to do so\n09505\t                // they'll end up with nasty segfaults, so this is public service.\n09506\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n09507\t                {\n09508\t        __failure = 126;\n09509\t        if (!PyErr_Occurred()) {\n09510\t            PyErr_SetString(PyExc_RuntimeError,\n09511\t                \"Unexpected error in an Op's C code. \"\n09512\t                \"No Python exception was set.\");\n09513\t            }\n09514\t        goto __label_126;}\n09515\t            }\n09516\t            if (!PyArray_Check(py_V125)) {\n09517\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n09518\t                {\n09519\t        __failure = 126;\n09520\t        if (!PyErr_Occurred()) {\n09521\t            PyErr_SetString(PyExc_RuntimeError,\n09522\t                \"Unexpected error in an Op's C code. \"\n09523\t                \"No Python exception was set.\");\n09524\t            }\n09525\t        goto __label_126;}\n09526\t            }\n09527\t            // We expect NPY_FLOAT64\n09528\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V125)) {\n09529\t                PyArrayObject * tmp = (PyArrayObject*) py_V125;\n09530\t                PyErr_Format(PyExc_NotImplementedError,\n09531\t                             \"expected an aligned array of type %ld \"\n09532\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n09533\t                             \" with %ld dimensions, with 3 last dims \"\n09534\t                             \"%ld, %ld, %ld\"\n09535\t                             \" and 3 last strides %ld %ld, %ld.\",\n09536\t                             (long int) NPY_FLOAT64,\n09537\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V125),\n09538\t                             (long int) PyArray_NDIM(tmp),\n09539\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n09540\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n09541\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n09542\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n09543\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n09544\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n09545\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n09546\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n09547\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n09548\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n09549\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n09550\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n09551\t            );\n09552\t                {\n09553\t        __failure = 126;\n09554\t        if (!PyErr_Occurred()) {\n09555\t            PyErr_SetString(PyExc_RuntimeError,\n09556\t                \"Unexpected error in an Op's C code. \"\n09557\t                \"No Python exception was set.\");\n09558\t            }\n09559\t        goto __label_126;}\n09560\t            }\n09561\t            // This is a TypeError to be consistent with DEBUG_MODE\n09562\t            // Note: DEBUG_MODE also tells the name of the container\n09563\t            if (PyArray_TYPE((PyArrayObject*) py_V125) != NPY_FLOAT64) {\n09564\t                PyErr_Format(PyExc_TypeError,\n09565\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n09566\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V125));\n09567\t                {\n09568\t        __failure = 126;\n09569\t        if (!PyErr_Occurred()) {\n09570\t            PyErr_SetString(PyExc_RuntimeError,\n09571\t                \"Unexpected error in an Op's C code. \"\n09572\t                \"No Python exception was set.\");\n09573\t            }\n09574\t        goto __label_126;}\n09575\t            }\n09576\t            \n09577\t        V125 = (PyArrayObject*)(py_V125);\n09578\t        Py_XINCREF(V125);\n09579\t        \n09580\t{\n09581\t\n09582\t    py_V127 = PyList_GET_ITEM(storage_V127, 0);\n09583\t    {Py_XINCREF(py_V127);}\n09584\t    \n09585\t            V127 = NULL;\n09586\t            if (py_V127 == Py_None) {\n09587\t                // We can either fail here or set V127 to NULL and rely on Ops\n09588\t                // using tensors to handle the NULL case, but if they fail to do so\n09589\t                // they'll end up with nasty segfaults, so this is public service.\n09590\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n09591\t                {\n09592\t        __failure = 128;\n09593\t        if (!PyErr_Occurred()) {\n09594\t            PyErr_SetString(PyExc_RuntimeError,\n09595\t                \"Unexpected error in an Op's C code. \"\n09596\t                \"No Python exception was set.\");\n09597\t            }\n09598\t        goto __label_128;}\n09599\t            }\n09600\t            if (!PyArray_Check(py_V127)) {\n09601\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n09602\t                {\n09603\t        __failure = 128;\n09604\t        if (!PyErr_Occurred()) {\n09605\t            PyErr_SetString(PyExc_RuntimeError,\n09606\t                \"Unexpected error in an Op's C code. \"\n09607\t                \"No Python exception was set.\");\n09608\t            }\n09609\t        goto __label_128;}\n09610\t            }\n09611\t            // We expect NPY_FLOAT64\n09612\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V127)) {\n09613\t                PyArrayObject * tmp = (PyArrayObject*) py_V127;\n09614\t                PyErr_Format(PyExc_NotImplementedError,\n09615\t                             \"expected an aligned array of type %ld \"\n09616\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n09617\t                             \" with %ld dimensions, with 3 last dims \"\n09618\t                             \"%ld, %ld, %ld\"\n09619\t                             \" and 3 last strides %ld %ld, %ld.\",\n09620\t                             (long int) NPY_FLOAT64,\n09621\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V127),\n09622\t                             (long int) PyArray_NDIM(tmp),\n09623\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n09624\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n09625\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n09626\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n09627\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n09628\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n09629\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n09630\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n09631\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n09632\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n09633\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n09634\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n09635\t            );\n09636\t                {\n09637\t        __failure = 128;\n09638\t        if (!PyErr_Occurred()) {\n09639\t            PyErr_SetString(PyExc_RuntimeError,\n09640\t                \"Unexpected error in an Op's C code. \"\n09641\t                \"No Python exception was set.\");\n09642\t            }\n09643\t        goto __label_128;}\n09644\t            }\n09645\t            // This is a TypeError to be consistent with DEBUG_MODE\n09646\t            // Note: DEBUG_MODE also tells the name of the container\n09647\t            if (PyArray_TYPE((PyArrayObject*) py_V127) != NPY_FLOAT64) {\n09648\t                PyErr_Format(PyExc_TypeError,\n09649\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n09650\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V127));\n09651\t                {\n09652\t        __failure = 128;\n09653\t        if (!PyErr_Occurred()) {\n09654\t            PyErr_SetString(PyExc_RuntimeError,\n09655\t                \"Unexpected error in an Op's C code. \"\n09656\t                \"No Python exception was set.\");\n09657\t            }\n09658\t        goto __label_128;}\n09659\t            }\n09660\t            \n09661\t        V127 = (PyArrayObject*)(py_V127);\n09662\t        Py_XINCREF(V127);\n09663\t        \n09664\t{\n09665\t\n09666\t    py_V129 = PyList_GET_ITEM(storage_V129, 0);\n09667\t    {Py_XINCREF(py_V129);}\n09668\t    \n09669\t            V129 = NULL;\n09670\t            if (py_V129 == Py_None) {\n09671\t                // We can either fail here or set V129 to NULL and rely on Ops\n09672\t                // using tensors to handle the NULL case, but if they fail to do so\n09673\t                // they'll end up with nasty segfaults, so this is public service.\n09674\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n09675\t                {\n09676\t        __failure = 130;\n09677\t        if (!PyErr_Occurred()) {\n09678\t            PyErr_SetString(PyExc_RuntimeError,\n09679\t                \"Unexpected error in an Op's C code. \"\n09680\t                \"No Python exception was set.\");\n09681\t            }\n09682\t        goto __label_130;}\n09683\t            }\n09684\t            if (!PyArray_Check(py_V129)) {\n09685\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n09686\t                {\n09687\t        __failure = 130;\n09688\t        if (!PyErr_Occurred()) {\n09689\t            PyErr_SetString(PyExc_RuntimeError,\n09690\t                \"Unexpected error in an Op's C code. \"\n09691\t                \"No Python exception was set.\");\n09692\t            }\n09693\t        goto __label_130;}\n09694\t            }\n09695\t            // We expect NPY_FLOAT64\n09696\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V129)) {\n09697\t                PyArrayObject * tmp = (PyArrayObject*) py_V129;\n09698\t                PyErr_Format(PyExc_NotImplementedError,\n09699\t                             \"expected an aligned array of type %ld \"\n09700\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n09701\t                             \" with %ld dimensions, with 3 last dims \"\n09702\t                             \"%ld, %ld, %ld\"\n09703\t                             \" and 3 last strides %ld %ld, %ld.\",\n09704\t                             (long int) NPY_FLOAT64,\n09705\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V129),\n09706\t                             (long int) PyArray_NDIM(tmp),\n09707\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n09708\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n09709\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n09710\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n09711\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n09712\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n09713\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n09714\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n09715\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n09716\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n09717\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n09718\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n09719\t            );\n09720\t                {\n09721\t        __failure = 130;\n09722\t        if (!PyErr_Occurred()) {\n09723\t            PyErr_SetString(PyExc_RuntimeError,\n09724\t                \"Unexpected error in an Op's C code. \"\n09725\t                \"No Python exception was set.\");\n09726\t            }\n09727\t        goto __label_130;}\n09728\t            }\n09729\t            // This is a TypeError to be consistent with DEBUG_MODE\n09730\t            // Note: DEBUG_MODE also tells the name of the container\n09731\t            if (PyArray_TYPE((PyArrayObject*) py_V129) != NPY_FLOAT64) {\n09732\t                PyErr_Format(PyExc_TypeError,\n09733\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n09734\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V129));\n09735\t                {\n09736\t        __failure = 130;\n09737\t        if (!PyErr_Occurred()) {\n09738\t            PyErr_SetString(PyExc_RuntimeError,\n09739\t                \"Unexpected error in an Op's C code. \"\n09740\t                \"No Python exception was set.\");\n09741\t            }\n09742\t        goto __label_130;}\n09743\t            }\n09744\t            \n09745\t        V129 = (PyArrayObject*)(py_V129);\n09746\t        Py_XINCREF(V129);\n09747\t        \n09748\t{\n09749\t\n09750\t    py_V131 = PyList_GET_ITEM(storage_V131, 0);\n09751\t    {Py_XINCREF(py_V131);}\n09752\t    \n09753\t            V131 = NULL;\n09754\t            if (py_V131 == Py_None) {\n09755\t                // We can either fail here or set V131 to NULL and rely on Ops\n09756\t                // using tensors to handle the NULL case, but if they fail to do so\n09757\t                // they'll end up with nasty segfaults, so this is public service.\n09758\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n09759\t                {\n09760\t        __failure = 132;\n09761\t        if (!PyErr_Occurred()) {\n09762\t            PyErr_SetString(PyExc_RuntimeError,\n09763\t                \"Unexpected error in an Op's C code. \"\n09764\t                \"No Python exception was set.\");\n09765\t            }\n09766\t        goto __label_132;}\n09767\t            }\n09768\t            if (!PyArray_Check(py_V131)) {\n09769\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n09770\t                {\n09771\t        __failure = 132;\n09772\t        if (!PyErr_Occurred()) {\n09773\t            PyErr_SetString(PyExc_RuntimeError,\n09774\t                \"Unexpected error in an Op's C code. \"\n09775\t                \"No Python exception was set.\");\n09776\t            }\n09777\t        goto __label_132;}\n09778\t            }\n09779\t            // We expect NPY_FLOAT64\n09780\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V131)) {\n09781\t                PyArrayObject * tmp = (PyArrayObject*) py_V131;\n09782\t                PyErr_Format(PyExc_NotImplementedError,\n09783\t                             \"expected an aligned array of type %ld \"\n09784\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n09785\t                             \" with %ld dimensions, with 3 last dims \"\n09786\t                             \"%ld, %ld, %ld\"\n09787\t                             \" and 3 last strides %ld %ld, %ld.\",\n09788\t                             (long int) NPY_FLOAT64,\n09789\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V131),\n09790\t                             (long int) PyArray_NDIM(tmp),\n09791\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n09792\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n09793\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n09794\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n09795\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n09796\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n09797\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n09798\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n09799\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n09800\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n09801\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n09802\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n09803\t            );\n09804\t                {\n09805\t        __failure = 132;\n09806\t        if (!PyErr_Occurred()) {\n09807\t            PyErr_SetString(PyExc_RuntimeError,\n09808\t                \"Unexpected error in an Op's C code. \"\n09809\t                \"No Python exception was set.\");\n09810\t            }\n09811\t        goto __label_132;}\n09812\t            }\n09813\t            // This is a TypeError to be consistent with DEBUG_MODE\n09814\t            // Note: DEBUG_MODE also tells the name of the container\n09815\t            if (PyArray_TYPE((PyArrayObject*) py_V131) != NPY_FLOAT64) {\n09816\t                PyErr_Format(PyExc_TypeError,\n09817\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n09818\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V131));\n09819\t                {\n09820\t        __failure = 132;\n09821\t        if (!PyErr_Occurred()) {\n09822\t            PyErr_SetString(PyExc_RuntimeError,\n09823\t                \"Unexpected error in an Op's C code. \"\n09824\t                \"No Python exception was set.\");\n09825\t            }\n09826\t        goto __label_132;}\n09827\t            }\n09828\t            \n09829\t        V131 = (PyArrayObject*)(py_V131);\n09830\t        Py_XINCREF(V131);\n09831\t        \n09832\t{\n09833\t\n09834\t    py_V133 = PyList_GET_ITEM(storage_V133, 0);\n09835\t    {Py_XINCREF(py_V133);}\n09836\t    \n09837\t            V133 = NULL;\n09838\t            if (py_V133 == Py_None) {\n09839\t                // We can either fail here or set V133 to NULL and rely on Ops\n09840\t                // using tensors to handle the NULL case, but if they fail to do so\n09841\t                // they'll end up with nasty segfaults, so this is public service.\n09842\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n09843\t                {\n09844\t        __failure = 134;\n09845\t        if (!PyErr_Occurred()) {\n09846\t            PyErr_SetString(PyExc_RuntimeError,\n09847\t                \"Unexpected error in an Op's C code. \"\n09848\t                \"No Python exception was set.\");\n09849\t            }\n09850\t        goto __label_134;}\n09851\t            }\n09852\t            if (!PyArray_Check(py_V133)) {\n09853\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n09854\t                {\n09855\t        __failure = 134;\n09856\t        if (!PyErr_Occurred()) {\n09857\t            PyErr_SetString(PyExc_RuntimeError,\n09858\t                \"Unexpected error in an Op's C code. \"\n09859\t                \"No Python exception was set.\");\n09860\t            }\n09861\t        goto __label_134;}\n09862\t            }\n09863\t            // We expect NPY_FLOAT64\n09864\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V133)) {\n09865\t                PyArrayObject * tmp = (PyArrayObject*) py_V133;\n09866\t                PyErr_Format(PyExc_NotImplementedError,\n09867\t                             \"expected an aligned array of type %ld \"\n09868\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n09869\t                             \" with %ld dimensions, with 3 last dims \"\n09870\t                             \"%ld, %ld, %ld\"\n09871\t                             \" and 3 last strides %ld %ld, %ld.\",\n09872\t                             (long int) NPY_FLOAT64,\n09873\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V133),\n09874\t                             (long int) PyArray_NDIM(tmp),\n09875\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n09876\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n09877\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n09878\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n09879\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n09880\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n09881\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n09882\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n09883\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n09884\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n09885\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n09886\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n09887\t            );\n09888\t                {\n09889\t        __failure = 134;\n09890\t        if (!PyErr_Occurred()) {\n09891\t            PyErr_SetString(PyExc_RuntimeError,\n09892\t                \"Unexpected error in an Op's C code. \"\n09893\t                \"No Python exception was set.\");\n09894\t            }\n09895\t        goto __label_134;}\n09896\t            }\n09897\t            // This is a TypeError to be consistent with DEBUG_MODE\n09898\t            // Note: DEBUG_MODE also tells the name of the container\n09899\t            if (PyArray_TYPE((PyArrayObject*) py_V133) != NPY_FLOAT64) {\n09900\t                PyErr_Format(PyExc_TypeError,\n09901\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n09902\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V133));\n09903\t                {\n09904\t        __failure = 134;\n09905\t        if (!PyErr_Occurred()) {\n09906\t            PyErr_SetString(PyExc_RuntimeError,\n09907\t                \"Unexpected error in an Op's C code. \"\n09908\t                \"No Python exception was set.\");\n09909\t            }\n09910\t        goto __label_134;}\n09911\t            }\n09912\t            \n09913\t        V133 = (PyArrayObject*)(py_V133);\n09914\t        Py_XINCREF(V133);\n09915\t        \n09916\t{\n09917\t\n09918\t    py_V135 = PyList_GET_ITEM(storage_V135, 0);\n09919\t    {Py_XINCREF(py_V135);}\n09920\t    \n09921\t            V135 = NULL;\n09922\t            if (py_V135 == Py_None) {\n09923\t                // We can either fail here or set V135 to NULL and rely on Ops\n09924\t                // using tensors to handle the NULL case, but if they fail to do so\n09925\t                // they'll end up with nasty segfaults, so this is public service.\n09926\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n09927\t                {\n09928\t        __failure = 136;\n09929\t        if (!PyErr_Occurred()) {\n09930\t            PyErr_SetString(PyExc_RuntimeError,\n09931\t                \"Unexpected error in an Op's C code. \"\n09932\t                \"No Python exception was set.\");\n09933\t            }\n09934\t        goto __label_136;}\n09935\t            }\n09936\t            if (!PyArray_Check(py_V135)) {\n09937\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n09938\t                {\n09939\t        __failure = 136;\n09940\t        if (!PyErr_Occurred()) {\n09941\t            PyErr_SetString(PyExc_RuntimeError,\n09942\t                \"Unexpected error in an Op's C code. \"\n09943\t                \"No Python exception was set.\");\n09944\t            }\n09945\t        goto __label_136;}\n09946\t            }\n09947\t            // We expect NPY_FLOAT64\n09948\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V135)) {\n09949\t                PyArrayObject * tmp = (PyArrayObject*) py_V135;\n09950\t                PyErr_Format(PyExc_NotImplementedError,\n09951\t                             \"expected an aligned array of type %ld \"\n09952\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n09953\t                             \" with %ld dimensions, with 3 last dims \"\n09954\t                             \"%ld, %ld, %ld\"\n09955\t                             \" and 3 last strides %ld %ld, %ld.\",\n09956\t                             (long int) NPY_FLOAT64,\n09957\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V135),\n09958\t                             (long int) PyArray_NDIM(tmp),\n09959\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n09960\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n09961\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n09962\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n09963\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n09964\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n09965\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n09966\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n09967\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n09968\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n09969\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n09970\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n09971\t            );\n09972\t                {\n09973\t        __failure = 136;\n09974\t        if (!PyErr_Occurred()) {\n09975\t            PyErr_SetString(PyExc_RuntimeError,\n09976\t                \"Unexpected error in an Op's C code. \"\n09977\t                \"No Python exception was set.\");\n09978\t            }\n09979\t        goto __label_136;}\n09980\t            }\n09981\t            // This is a TypeError to be consistent with DEBUG_MODE\n09982\t            // Note: DEBUG_MODE also tells the name of the container\n09983\t            if (PyArray_TYPE((PyArrayObject*) py_V135) != NPY_FLOAT64) {\n09984\t                PyErr_Format(PyExc_TypeError,\n09985\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n09986\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V135));\n09987\t                {\n09988\t        __failure = 136;\n09989\t        if (!PyErr_Occurred()) {\n09990\t            PyErr_SetString(PyExc_RuntimeError,\n09991\t                \"Unexpected error in an Op's C code. \"\n09992\t                \"No Python exception was set.\");\n09993\t            }\n09994\t        goto __label_136;}\n09995\t            }\n09996\t            \n09997\t        V135 = (PyArrayObject*)(py_V135);\n09998\t        Py_XINCREF(V135);\n09999\t        \n10000\t{\n10001\t\n10002\t    py_V137 = PyList_GET_ITEM(storage_V137, 0);\n10003\t    {Py_XINCREF(py_V137);}\n10004\t    \n10005\t            V137 = NULL;\n10006\t            if (py_V137 == Py_None) {\n10007\t                // We can either fail here or set V137 to NULL and rely on Ops\n10008\t                // using tensors to handle the NULL case, but if they fail to do so\n10009\t                // they'll end up with nasty segfaults, so this is public service.\n10010\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n10011\t                {\n10012\t        __failure = 138;\n10013\t        if (!PyErr_Occurred()) {\n10014\t            PyErr_SetString(PyExc_RuntimeError,\n10015\t                \"Unexpected error in an Op's C code. \"\n10016\t                \"No Python exception was set.\");\n10017\t            }\n10018\t        goto __label_138;}\n10019\t            }\n10020\t            if (!PyArray_Check(py_V137)) {\n10021\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n10022\t                {\n10023\t        __failure = 138;\n10024\t        if (!PyErr_Occurred()) {\n10025\t            PyErr_SetString(PyExc_RuntimeError,\n10026\t                \"Unexpected error in an Op's C code. \"\n10027\t                \"No Python exception was set.\");\n10028\t            }\n10029\t        goto __label_138;}\n10030\t            }\n10031\t            // We expect NPY_FLOAT64\n10032\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V137)) {\n10033\t                PyArrayObject * tmp = (PyArrayObject*) py_V137;\n10034\t                PyErr_Format(PyExc_NotImplementedError,\n10035\t                             \"expected an aligned array of type %ld \"\n10036\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n10037\t                             \" with %ld dimensions, with 3 last dims \"\n10038\t                             \"%ld, %ld, %ld\"\n10039\t                             \" and 3 last strides %ld %ld, %ld.\",\n10040\t                             (long int) NPY_FLOAT64,\n10041\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V137),\n10042\t                             (long int) PyArray_NDIM(tmp),\n10043\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n10044\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n10045\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n10046\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n10047\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n10048\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n10049\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n10050\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n10051\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n10052\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n10053\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n10054\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n10055\t            );\n10056\t                {\n10057\t        __failure = 138;\n10058\t        if (!PyErr_Occurred()) {\n10059\t            PyErr_SetString(PyExc_RuntimeError,\n10060\t                \"Unexpected error in an Op's C code. \"\n10061\t                \"No Python exception was set.\");\n10062\t            }\n10063\t        goto __label_138;}\n10064\t            }\n10065\t            // This is a TypeError to be consistent with DEBUG_MODE\n10066\t            // Note: DEBUG_MODE also tells the name of the container\n10067\t            if (PyArray_TYPE((PyArrayObject*) py_V137) != NPY_FLOAT64) {\n10068\t                PyErr_Format(PyExc_TypeError,\n10069\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n10070\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V137));\n10071\t                {\n10072\t        __failure = 138;\n10073\t        if (!PyErr_Occurred()) {\n10074\t            PyErr_SetString(PyExc_RuntimeError,\n10075\t                \"Unexpected error in an Op's C code. \"\n10076\t                \"No Python exception was set.\");\n10077\t            }\n10078\t        goto __label_138;}\n10079\t            }\n10080\t            \n10081\t        V137 = (PyArrayObject*)(py_V137);\n10082\t        Py_XINCREF(V137);\n10083\t        \n10084\t{\n10085\t\n10086\t    py_V139 = PyList_GET_ITEM(storage_V139, 0);\n10087\t    {Py_XINCREF(py_V139);}\n10088\t    \n10089\t            V139 = NULL;\n10090\t            if (py_V139 == Py_None) {\n10091\t                // We can either fail here or set V139 to NULL and rely on Ops\n10092\t                // using tensors to handle the NULL case, but if they fail to do so\n10093\t                // they'll end up with nasty segfaults, so this is public service.\n10094\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n10095\t                {\n10096\t        __failure = 140;\n10097\t        if (!PyErr_Occurred()) {\n10098\t            PyErr_SetString(PyExc_RuntimeError,\n10099\t                \"Unexpected error in an Op's C code. \"\n10100\t                \"No Python exception was set.\");\n10101\t            }\n10102\t        goto __label_140;}\n10103\t            }\n10104\t            if (!PyArray_Check(py_V139)) {\n10105\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n10106\t                {\n10107\t        __failure = 140;\n10108\t        if (!PyErr_Occurred()) {\n10109\t            PyErr_SetString(PyExc_RuntimeError,\n10110\t                \"Unexpected error in an Op's C code. \"\n10111\t                \"No Python exception was set.\");\n10112\t            }\n10113\t        goto __label_140;}\n10114\t            }\n10115\t            // We expect NPY_FLOAT64\n10116\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V139)) {\n10117\t                PyArrayObject * tmp = (PyArrayObject*) py_V139;\n10118\t                PyErr_Format(PyExc_NotImplementedError,\n10119\t                             \"expected an aligned array of type %ld \"\n10120\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n10121\t                             \" with %ld dimensions, with 3 last dims \"\n10122\t                             \"%ld, %ld, %ld\"\n10123\t                             \" and 3 last strides %ld %ld, %ld.\",\n10124\t                             (long int) NPY_FLOAT64,\n10125\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V139),\n10126\t                             (long int) PyArray_NDIM(tmp),\n10127\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n10128\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n10129\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n10130\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n10131\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n10132\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n10133\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n10134\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n10135\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n10136\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n10137\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n10138\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n10139\t            );\n10140\t                {\n10141\t        __failure = 140;\n10142\t        if (!PyErr_Occurred()) {\n10143\t            PyErr_SetString(PyExc_RuntimeError,\n10144\t                \"Unexpected error in an Op's C code. \"\n10145\t                \"No Python exception was set.\");\n10146\t            }\n10147\t        goto __label_140;}\n10148\t            }\n10149\t            // This is a TypeError to be consistent with DEBUG_MODE\n10150\t            // Note: DEBUG_MODE also tells the name of the container\n10151\t            if (PyArray_TYPE((PyArrayObject*) py_V139) != NPY_FLOAT64) {\n10152\t                PyErr_Format(PyExc_TypeError,\n10153\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n10154\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V139));\n10155\t                {\n10156\t        __failure = 140;\n10157\t        if (!PyErr_Occurred()) {\n10158\t            PyErr_SetString(PyExc_RuntimeError,\n10159\t                \"Unexpected error in an Op's C code. \"\n10160\t                \"No Python exception was set.\");\n10161\t            }\n10162\t        goto __label_140;}\n10163\t            }\n10164\t            \n10165\t        V139 = (PyArrayObject*)(py_V139);\n10166\t        Py_XINCREF(V139);\n10167\t        \n10168\t{\n10169\t\n10170\t    py_V141 = PyList_GET_ITEM(storage_V141, 0);\n10171\t    {Py_XINCREF(py_V141);}\n10172\t    \n10173\t            V141 = NULL;\n10174\t            if (py_V141 == Py_None) {\n10175\t                // We can either fail here or set V141 to NULL and rely on Ops\n10176\t                // using tensors to handle the NULL case, but if they fail to do so\n10177\t                // they'll end up with nasty segfaults, so this is public service.\n10178\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n10179\t                {\n10180\t        __failure = 142;\n10181\t        if (!PyErr_Occurred()) {\n10182\t            PyErr_SetString(PyExc_RuntimeError,\n10183\t                \"Unexpected error in an Op's C code. \"\n10184\t                \"No Python exception was set.\");\n10185\t            }\n10186\t        goto __label_142;}\n10187\t            }\n10188\t            if (!PyArray_Check(py_V141)) {\n10189\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n10190\t                {\n10191\t        __failure = 142;\n10192\t        if (!PyErr_Occurred()) {\n10193\t            PyErr_SetString(PyExc_RuntimeError,\n10194\t                \"Unexpected error in an Op's C code. \"\n10195\t                \"No Python exception was set.\");\n10196\t            }\n10197\t        goto __label_142;}\n10198\t            }\n10199\t            // We expect NPY_FLOAT64\n10200\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V141)) {\n10201\t                PyArrayObject * tmp = (PyArrayObject*) py_V141;\n10202\t                PyErr_Format(PyExc_NotImplementedError,\n10203\t                             \"expected an aligned array of type %ld \"\n10204\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n10205\t                             \" with %ld dimensions, with 3 last dims \"\n10206\t                             \"%ld, %ld, %ld\"\n10207\t                             \" and 3 last strides %ld %ld, %ld.\",\n10208\t                             (long int) NPY_FLOAT64,\n10209\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V141),\n10210\t                             (long int) PyArray_NDIM(tmp),\n10211\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n10212\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n10213\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n10214\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n10215\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n10216\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n10217\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n10218\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n10219\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n10220\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n10221\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n10222\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n10223\t            );\n10224\t                {\n10225\t        __failure = 142;\n10226\t        if (!PyErr_Occurred()) {\n10227\t            PyErr_SetString(PyExc_RuntimeError,\n10228\t                \"Unexpected error in an Op's C code. \"\n10229\t                \"No Python exception was set.\");\n10230\t            }\n10231\t        goto __label_142;}\n10232\t            }\n10233\t            // This is a TypeError to be consistent with DEBUG_MODE\n10234\t            // Note: DEBUG_MODE also tells the name of the container\n10235\t            if (PyArray_TYPE((PyArrayObject*) py_V141) != NPY_FLOAT64) {\n10236\t                PyErr_Format(PyExc_TypeError,\n10237\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n10238\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V141));\n10239\t                {\n10240\t        __failure = 142;\n10241\t        if (!PyErr_Occurred()) {\n10242\t            PyErr_SetString(PyExc_RuntimeError,\n10243\t                \"Unexpected error in an Op's C code. \"\n10244\t                \"No Python exception was set.\");\n10245\t            }\n10246\t        goto __label_142;}\n10247\t            }\n10248\t            \n10249\t        V141 = (PyArrayObject*)(py_V141);\n10250\t        Py_XINCREF(V141);\n10251\t        \n10252\t{\n10253\t\n10254\t    py_V143 = PyList_GET_ITEM(storage_V143, 0);\n10255\t    {Py_XINCREF(py_V143);}\n10256\t    \n10257\t            V143 = NULL;\n10258\t            if (py_V143 == Py_None) {\n10259\t                // We can either fail here or set V143 to NULL and rely on Ops\n10260\t                // using tensors to handle the NULL case, but if they fail to do so\n10261\t                // they'll end up with nasty segfaults, so this is public service.\n10262\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n10263\t                {\n10264\t        __failure = 144;\n10265\t        if (!PyErr_Occurred()) {\n10266\t            PyErr_SetString(PyExc_RuntimeError,\n10267\t                \"Unexpected error in an Op's C code. \"\n10268\t                \"No Python exception was set.\");\n10269\t            }\n10270\t        goto __label_144;}\n10271\t            }\n10272\t            if (!PyArray_Check(py_V143)) {\n10273\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n10274\t                {\n10275\t        __failure = 144;\n10276\t        if (!PyErr_Occurred()) {\n10277\t            PyErr_SetString(PyExc_RuntimeError,\n10278\t                \"Unexpected error in an Op's C code. \"\n10279\t                \"No Python exception was set.\");\n10280\t            }\n10281\t        goto __label_144;}\n10282\t            }\n10283\t            // We expect NPY_FLOAT64\n10284\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V143)) {\n10285\t                PyArrayObject * tmp = (PyArrayObject*) py_V143;\n10286\t                PyErr_Format(PyExc_NotImplementedError,\n10287\t                             \"expected an aligned array of type %ld \"\n10288\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n10289\t                             \" with %ld dimensions, with 3 last dims \"\n10290\t                             \"%ld, %ld, %ld\"\n10291\t                             \" and 3 last strides %ld %ld, %ld.\",\n10292\t                             (long int) NPY_FLOAT64,\n10293\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V143),\n10294\t                             (long int) PyArray_NDIM(tmp),\n10295\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n10296\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n10297\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n10298\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n10299\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n10300\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n10301\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n10302\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n10303\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n10304\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n10305\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n10306\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n10307\t            );\n10308\t                {\n10309\t        __failure = 144;\n10310\t        if (!PyErr_Occurred()) {\n10311\t            PyErr_SetString(PyExc_RuntimeError,\n10312\t                \"Unexpected error in an Op's C code. \"\n10313\t                \"No Python exception was set.\");\n10314\t            }\n10315\t        goto __label_144;}\n10316\t            }\n10317\t            // This is a TypeError to be consistent with DEBUG_MODE\n10318\t            // Note: DEBUG_MODE also tells the name of the container\n10319\t            if (PyArray_TYPE((PyArrayObject*) py_V143) != NPY_FLOAT64) {\n10320\t                PyErr_Format(PyExc_TypeError,\n10321\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n10322\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V143));\n10323\t                {\n10324\t        __failure = 144;\n10325\t        if (!PyErr_Occurred()) {\n10326\t            PyErr_SetString(PyExc_RuntimeError,\n10327\t                \"Unexpected error in an Op's C code. \"\n10328\t                \"No Python exception was set.\");\n10329\t            }\n10330\t        goto __label_144;}\n10331\t            }\n10332\t            \n10333\t        V143 = (PyArrayObject*)(py_V143);\n10334\t        Py_XINCREF(V143);\n10335\t        \n10336\t{\n10337\t\n10338\t    py_V145 = PyList_GET_ITEM(storage_V145, 0);\n10339\t    {Py_XINCREF(py_V145);}\n10340\t    \n10341\t            V145 = NULL;\n10342\t            if (py_V145 == Py_None) {\n10343\t                // We can either fail here or set V145 to NULL and rely on Ops\n10344\t                // using tensors to handle the NULL case, but if they fail to do so\n10345\t                // they'll end up with nasty segfaults, so this is public service.\n10346\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n10347\t                {\n10348\t        __failure = 146;\n10349\t        if (!PyErr_Occurred()) {\n10350\t            PyErr_SetString(PyExc_RuntimeError,\n10351\t                \"Unexpected error in an Op's C code. \"\n10352\t                \"No Python exception was set.\");\n10353\t            }\n10354\t        goto __label_146;}\n10355\t            }\n10356\t            if (!PyArray_Check(py_V145)) {\n10357\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n10358\t                {\n10359\t        __failure = 146;\n10360\t        if (!PyErr_Occurred()) {\n10361\t            PyErr_SetString(PyExc_RuntimeError,\n10362\t                \"Unexpected error in an Op's C code. \"\n10363\t                \"No Python exception was set.\");\n10364\t            }\n10365\t        goto __label_146;}\n10366\t            }\n10367\t            // We expect NPY_FLOAT64\n10368\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V145)) {\n10369\t                PyArrayObject * tmp = (PyArrayObject*) py_V145;\n10370\t                PyErr_Format(PyExc_NotImplementedError,\n10371\t                             \"expected an aligned array of type %ld \"\n10372\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n10373\t                             \" with %ld dimensions, with 3 last dims \"\n10374\t                             \"%ld, %ld, %ld\"\n10375\t                             \" and 3 last strides %ld %ld, %ld.\",\n10376\t                             (long int) NPY_FLOAT64,\n10377\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V145),\n10378\t                             (long int) PyArray_NDIM(tmp),\n10379\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n10380\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n10381\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n10382\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n10383\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n10384\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n10385\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n10386\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n10387\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n10388\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n10389\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n10390\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n10391\t            );\n10392\t                {\n10393\t        __failure = 146;\n10394\t        if (!PyErr_Occurred()) {\n10395\t            PyErr_SetString(PyExc_RuntimeError,\n10396\t                \"Unexpected error in an Op's C code. \"\n10397\t                \"No Python exception was set.\");\n10398\t            }\n10399\t        goto __label_146;}\n10400\t            }\n10401\t            // This is a TypeError to be consistent with DEBUG_MODE\n10402\t            // Note: DEBUG_MODE also tells the name of the container\n10403\t            if (PyArray_TYPE((PyArrayObject*) py_V145) != NPY_FLOAT64) {\n10404\t                PyErr_Format(PyExc_TypeError,\n10405\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n10406\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V145));\n10407\t                {\n10408\t        __failure = 146;\n10409\t        if (!PyErr_Occurred()) {\n10410\t            PyErr_SetString(PyExc_RuntimeError,\n10411\t                \"Unexpected error in an Op's C code. \"\n10412\t                \"No Python exception was set.\");\n10413\t            }\n10414\t        goto __label_146;}\n10415\t            }\n10416\t            \n10417\t        V145 = (PyArrayObject*)(py_V145);\n10418\t        Py_XINCREF(V145);\n10419\t        \n10420\t{\n10421\t\n10422\t    py_V147 = PyList_GET_ITEM(storage_V147, 0);\n10423\t    {Py_XINCREF(py_V147);}\n10424\t    \n10425\t            V147 = NULL;\n10426\t            if (py_V147 == Py_None) {\n10427\t                // We can either fail here or set V147 to NULL and rely on Ops\n10428\t                // using tensors to handle the NULL case, but if they fail to do so\n10429\t                // they'll end up with nasty segfaults, so this is public service.\n10430\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n10431\t                {\n10432\t        __failure = 148;\n10433\t        if (!PyErr_Occurred()) {\n10434\t            PyErr_SetString(PyExc_RuntimeError,\n10435\t                \"Unexpected error in an Op's C code. \"\n10436\t                \"No Python exception was set.\");\n10437\t            }\n10438\t        goto __label_148;}\n10439\t            }\n10440\t            if (!PyArray_Check(py_V147)) {\n10441\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n10442\t                {\n10443\t        __failure = 148;\n10444\t        if (!PyErr_Occurred()) {\n10445\t            PyErr_SetString(PyExc_RuntimeError,\n10446\t                \"Unexpected error in an Op's C code. \"\n10447\t                \"No Python exception was set.\");\n10448\t            }\n10449\t        goto __label_148;}\n10450\t            }\n10451\t            // We expect NPY_FLOAT64\n10452\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V147)) {\n10453\t                PyArrayObject * tmp = (PyArrayObject*) py_V147;\n10454\t                PyErr_Format(PyExc_NotImplementedError,\n10455\t                             \"expected an aligned array of type %ld \"\n10456\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n10457\t                             \" with %ld dimensions, with 3 last dims \"\n10458\t                             \"%ld, %ld, %ld\"\n10459\t                             \" and 3 last strides %ld %ld, %ld.\",\n10460\t                             (long int) NPY_FLOAT64,\n10461\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V147),\n10462\t                             (long int) PyArray_NDIM(tmp),\n10463\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n10464\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n10465\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n10466\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n10467\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n10468\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n10469\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n10470\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n10471\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n10472\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n10473\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n10474\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n10475\t            );\n10476\t                {\n10477\t        __failure = 148;\n10478\t        if (!PyErr_Occurred()) {\n10479\t            PyErr_SetString(PyExc_RuntimeError,\n10480\t                \"Unexpected error in an Op's C code. \"\n10481\t                \"No Python exception was set.\");\n10482\t            }\n10483\t        goto __label_148;}\n10484\t            }\n10485\t            // This is a TypeError to be consistent with DEBUG_MODE\n10486\t            // Note: DEBUG_MODE also tells the name of the container\n10487\t            if (PyArray_TYPE((PyArrayObject*) py_V147) != NPY_FLOAT64) {\n10488\t                PyErr_Format(PyExc_TypeError,\n10489\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n10490\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V147));\n10491\t                {\n10492\t        __failure = 148;\n10493\t        if (!PyErr_Occurred()) {\n10494\t            PyErr_SetString(PyExc_RuntimeError,\n10495\t                \"Unexpected error in an Op's C code. \"\n10496\t                \"No Python exception was set.\");\n10497\t            }\n10498\t        goto __label_148;}\n10499\t            }\n10500\t            \n10501\t        V147 = (PyArrayObject*)(py_V147);\n10502\t        Py_XINCREF(V147);\n10503\t        \n10504\t{\n10505\t\n10506\t    py_V149 = PyList_GET_ITEM(storage_V149, 0);\n10507\t    {Py_XINCREF(py_V149);}\n10508\t    \n10509\t            V149 = NULL;\n10510\t            if (py_V149 == Py_None) {\n10511\t                // We can either fail here or set V149 to NULL and rely on Ops\n10512\t                // using tensors to handle the NULL case, but if they fail to do so\n10513\t                // they'll end up with nasty segfaults, so this is public service.\n10514\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n10515\t                {\n10516\t        __failure = 150;\n10517\t        if (!PyErr_Occurred()) {\n10518\t            PyErr_SetString(PyExc_RuntimeError,\n10519\t                \"Unexpected error in an Op's C code. \"\n10520\t                \"No Python exception was set.\");\n10521\t            }\n10522\t        goto __label_150;}\n10523\t            }\n10524\t            if (!PyArray_Check(py_V149)) {\n10525\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n10526\t                {\n10527\t        __failure = 150;\n10528\t        if (!PyErr_Occurred()) {\n10529\t            PyErr_SetString(PyExc_RuntimeError,\n10530\t                \"Unexpected error in an Op's C code. \"\n10531\t                \"No Python exception was set.\");\n10532\t            }\n10533\t        goto __label_150;}\n10534\t            }\n10535\t            // We expect NPY_FLOAT64\n10536\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V149)) {\n10537\t                PyArrayObject * tmp = (PyArrayObject*) py_V149;\n10538\t                PyErr_Format(PyExc_NotImplementedError,\n10539\t                             \"expected an aligned array of type %ld \"\n10540\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n10541\t                             \" with %ld dimensions, with 3 last dims \"\n10542\t                             \"%ld, %ld, %ld\"\n10543\t                             \" and 3 last strides %ld %ld, %ld.\",\n10544\t                             (long int) NPY_FLOAT64,\n10545\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V149),\n10546\t                             (long int) PyArray_NDIM(tmp),\n10547\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n10548\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n10549\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n10550\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n10551\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n10552\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n10553\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n10554\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n10555\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n10556\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n10557\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n10558\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n10559\t            );\n10560\t                {\n10561\t        __failure = 150;\n10562\t        if (!PyErr_Occurred()) {\n10563\t            PyErr_SetString(PyExc_RuntimeError,\n10564\t                \"Unexpected error in an Op's C code. \"\n10565\t                \"No Python exception was set.\");\n10566\t            }\n10567\t        goto __label_150;}\n10568\t            }\n10569\t            // This is a TypeError to be consistent with DEBUG_MODE\n10570\t            // Note: DEBUG_MODE also tells the name of the container\n10571\t            if (PyArray_TYPE((PyArrayObject*) py_V149) != NPY_FLOAT64) {\n10572\t                PyErr_Format(PyExc_TypeError,\n10573\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n10574\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V149));\n10575\t                {\n10576\t        __failure = 150;\n10577\t        if (!PyErr_Occurred()) {\n10578\t            PyErr_SetString(PyExc_RuntimeError,\n10579\t                \"Unexpected error in an Op's C code. \"\n10580\t                \"No Python exception was set.\");\n10581\t            }\n10582\t        goto __label_150;}\n10583\t            }\n10584\t            \n10585\t        V149 = (PyArrayObject*)(py_V149);\n10586\t        Py_XINCREF(V149);\n10587\t        \n10588\t{\n10589\t\n10590\t    py_V151 = PyList_GET_ITEM(storage_V151, 0);\n10591\t    {Py_XINCREF(py_V151);}\n10592\t    \n10593\t            V151 = NULL;\n10594\t            if (py_V151 == Py_None) {\n10595\t                // We can either fail here or set V151 to NULL and rely on Ops\n10596\t                // using tensors to handle the NULL case, but if they fail to do so\n10597\t                // they'll end up with nasty segfaults, so this is public service.\n10598\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n10599\t                {\n10600\t        __failure = 152;\n10601\t        if (!PyErr_Occurred()) {\n10602\t            PyErr_SetString(PyExc_RuntimeError,\n10603\t                \"Unexpected error in an Op's C code. \"\n10604\t                \"No Python exception was set.\");\n10605\t            }\n10606\t        goto __label_152;}\n10607\t            }\n10608\t            if (!PyArray_Check(py_V151)) {\n10609\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n10610\t                {\n10611\t        __failure = 152;\n10612\t        if (!PyErr_Occurred()) {\n10613\t            PyErr_SetString(PyExc_RuntimeError,\n10614\t                \"Unexpected error in an Op's C code. \"\n10615\t                \"No Python exception was set.\");\n10616\t            }\n10617\t        goto __label_152;}\n10618\t            }\n10619\t            // We expect NPY_FLOAT64\n10620\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V151)) {\n10621\t                PyArrayObject * tmp = (PyArrayObject*) py_V151;\n10622\t                PyErr_Format(PyExc_NotImplementedError,\n10623\t                             \"expected an aligned array of type %ld \"\n10624\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n10625\t                             \" with %ld dimensions, with 3 last dims \"\n10626\t                             \"%ld, %ld, %ld\"\n10627\t                             \" and 3 last strides %ld %ld, %ld.\",\n10628\t                             (long int) NPY_FLOAT64,\n10629\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V151),\n10630\t                             (long int) PyArray_NDIM(tmp),\n10631\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n10632\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n10633\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n10634\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n10635\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n10636\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n10637\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n10638\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n10639\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n10640\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n10641\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n10642\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n10643\t            );\n10644\t                {\n10645\t        __failure = 152;\n10646\t        if (!PyErr_Occurred()) {\n10647\t            PyErr_SetString(PyExc_RuntimeError,\n10648\t                \"Unexpected error in an Op's C code. \"\n10649\t                \"No Python exception was set.\");\n10650\t            }\n10651\t        goto __label_152;}\n10652\t            }\n10653\t            // This is a TypeError to be consistent with DEBUG_MODE\n10654\t            // Note: DEBUG_MODE also tells the name of the container\n10655\t            if (PyArray_TYPE((PyArrayObject*) py_V151) != NPY_FLOAT64) {\n10656\t                PyErr_Format(PyExc_TypeError,\n10657\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n10658\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V151));\n10659\t                {\n10660\t        __failure = 152;\n10661\t        if (!PyErr_Occurred()) {\n10662\t            PyErr_SetString(PyExc_RuntimeError,\n10663\t                \"Unexpected error in an Op's C code. \"\n10664\t                \"No Python exception was set.\");\n10665\t            }\n10666\t        goto __label_152;}\n10667\t            }\n10668\t            \n10669\t        V151 = (PyArrayObject*)(py_V151);\n10670\t        Py_XINCREF(V151);\n10671\t        \n10672\t{\n10673\t\n10674\t    py_V153 = PyList_GET_ITEM(storage_V153, 0);\n10675\t    {Py_XINCREF(py_V153);}\n10676\t    \n10677\t            V153 = NULL;\n10678\t            if (py_V153 == Py_None) {\n10679\t                // We can either fail here or set V153 to NULL and rely on Ops\n10680\t                // using tensors to handle the NULL case, but if they fail to do so\n10681\t                // they'll end up with nasty segfaults, so this is public service.\n10682\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n10683\t                {\n10684\t        __failure = 154;\n10685\t        if (!PyErr_Occurred()) {\n10686\t            PyErr_SetString(PyExc_RuntimeError,\n10687\t                \"Unexpected error in an Op's C code. \"\n10688\t                \"No Python exception was set.\");\n10689\t            }\n10690\t        goto __label_154;}\n10691\t            }\n10692\t            if (!PyArray_Check(py_V153)) {\n10693\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n10694\t                {\n10695\t        __failure = 154;\n10696\t        if (!PyErr_Occurred()) {\n10697\t            PyErr_SetString(PyExc_RuntimeError,\n10698\t                \"Unexpected error in an Op's C code. \"\n10699\t                \"No Python exception was set.\");\n10700\t            }\n10701\t        goto __label_154;}\n10702\t            }\n10703\t            // We expect NPY_FLOAT64\n10704\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V153)) {\n10705\t                PyArrayObject * tmp = (PyArrayObject*) py_V153;\n10706\t                PyErr_Format(PyExc_NotImplementedError,\n10707\t                             \"expected an aligned array of type %ld \"\n10708\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n10709\t                             \" with %ld dimensions, with 3 last dims \"\n10710\t                             \"%ld, %ld, %ld\"\n10711\t                             \" and 3 last strides %ld %ld, %ld.\",\n10712\t                             (long int) NPY_FLOAT64,\n10713\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V153),\n10714\t                             (long int) PyArray_NDIM(tmp),\n10715\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n10716\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n10717\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n10718\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n10719\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n10720\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n10721\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n10722\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n10723\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n10724\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n10725\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n10726\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n10727\t            );\n10728\t                {\n10729\t        __failure = 154;\n10730\t        if (!PyErr_Occurred()) {\n10731\t            PyErr_SetString(PyExc_RuntimeError,\n10732\t                \"Unexpected error in an Op's C code. \"\n10733\t                \"No Python exception was set.\");\n10734\t            }\n10735\t        goto __label_154;}\n10736\t            }\n10737\t            // This is a TypeError to be consistent with DEBUG_MODE\n10738\t            // Note: DEBUG_MODE also tells the name of the container\n10739\t            if (PyArray_TYPE((PyArrayObject*) py_V153) != NPY_FLOAT64) {\n10740\t                PyErr_Format(PyExc_TypeError,\n10741\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n10742\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V153));\n10743\t                {\n10744\t        __failure = 154;\n10745\t        if (!PyErr_Occurred()) {\n10746\t            PyErr_SetString(PyExc_RuntimeError,\n10747\t                \"Unexpected error in an Op's C code. \"\n10748\t                \"No Python exception was set.\");\n10749\t            }\n10750\t        goto __label_154;}\n10751\t            }\n10752\t            \n10753\t        V153 = (PyArrayObject*)(py_V153);\n10754\t        Py_XINCREF(V153);\n10755\t        \n10756\t{\n10757\t\n10758\t    py_V155 = PyList_GET_ITEM(storage_V155, 0);\n10759\t    {Py_XINCREF(py_V155);}\n10760\t    \n10761\t            V155 = NULL;\n10762\t            if (py_V155 == Py_None) {\n10763\t                // We can either fail here or set V155 to NULL and rely on Ops\n10764\t                // using tensors to handle the NULL case, but if they fail to do so\n10765\t                // they'll end up with nasty segfaults, so this is public service.\n10766\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n10767\t                {\n10768\t        __failure = 156;\n10769\t        if (!PyErr_Occurred()) {\n10770\t            PyErr_SetString(PyExc_RuntimeError,\n10771\t                \"Unexpected error in an Op's C code. \"\n10772\t                \"No Python exception was set.\");\n10773\t            }\n10774\t        goto __label_156;}\n10775\t            }\n10776\t            if (!PyArray_Check(py_V155)) {\n10777\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n10778\t                {\n10779\t        __failure = 156;\n10780\t        if (!PyErr_Occurred()) {\n10781\t            PyErr_SetString(PyExc_RuntimeError,\n10782\t                \"Unexpected error in an Op's C code. \"\n10783\t                \"No Python exception was set.\");\n10784\t            }\n10785\t        goto __label_156;}\n10786\t            }\n10787\t            // We expect NPY_FLOAT64\n10788\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V155)) {\n10789\t                PyArrayObject * tmp = (PyArrayObject*) py_V155;\n10790\t                PyErr_Format(PyExc_NotImplementedError,\n10791\t                             \"expected an aligned array of type %ld \"\n10792\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n10793\t                             \" with %ld dimensions, with 3 last dims \"\n10794\t                             \"%ld, %ld, %ld\"\n10795\t                             \" and 3 last strides %ld %ld, %ld.\",\n10796\t                             (long int) NPY_FLOAT64,\n10797\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V155),\n10798\t                             (long int) PyArray_NDIM(tmp),\n10799\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n10800\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n10801\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n10802\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n10803\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n10804\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n10805\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n10806\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n10807\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n10808\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n10809\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n10810\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n10811\t            );\n10812\t                {\n10813\t        __failure = 156;\n10814\t        if (!PyErr_Occurred()) {\n10815\t            PyErr_SetString(PyExc_RuntimeError,\n10816\t                \"Unexpected error in an Op's C code. \"\n10817\t                \"No Python exception was set.\");\n10818\t            }\n10819\t        goto __label_156;}\n10820\t            }\n10821\t            // This is a TypeError to be consistent with DEBUG_MODE\n10822\t            // Note: DEBUG_MODE also tells the name of the container\n10823\t            if (PyArray_TYPE((PyArrayObject*) py_V155) != NPY_FLOAT64) {\n10824\t                PyErr_Format(PyExc_TypeError,\n10825\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n10826\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V155));\n10827\t                {\n10828\t        __failure = 156;\n10829\t        if (!PyErr_Occurred()) {\n10830\t            PyErr_SetString(PyExc_RuntimeError,\n10831\t                \"Unexpected error in an Op's C code. \"\n10832\t                \"No Python exception was set.\");\n10833\t            }\n10834\t        goto __label_156;}\n10835\t            }\n10836\t            \n10837\t        V155 = (PyArrayObject*)(py_V155);\n10838\t        Py_XINCREF(V155);\n10839\t        \n10840\t{\n10841\t\n10842\t    py_V157 = PyList_GET_ITEM(storage_V157, 0);\n10843\t    {Py_XINCREF(py_V157);}\n10844\t    \n10845\t            V157 = NULL;\n10846\t            if (py_V157 == Py_None) {\n10847\t                // We can either fail here or set V157 to NULL and rely on Ops\n10848\t                // using tensors to handle the NULL case, but if they fail to do so\n10849\t                // they'll end up with nasty segfaults, so this is public service.\n10850\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n10851\t                {\n10852\t        __failure = 158;\n10853\t        if (!PyErr_Occurred()) {\n10854\t            PyErr_SetString(PyExc_RuntimeError,\n10855\t                \"Unexpected error in an Op's C code. \"\n10856\t                \"No Python exception was set.\");\n10857\t            }\n10858\t        goto __label_158;}\n10859\t            }\n10860\t            if (!PyArray_Check(py_V157)) {\n10861\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n10862\t                {\n10863\t        __failure = 158;\n10864\t        if (!PyErr_Occurred()) {\n10865\t            PyErr_SetString(PyExc_RuntimeError,\n10866\t                \"Unexpected error in an Op's C code. \"\n10867\t                \"No Python exception was set.\");\n10868\t            }\n10869\t        goto __label_158;}\n10870\t            }\n10871\t            // We expect NPY_FLOAT64\n10872\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V157)) {\n10873\t                PyArrayObject * tmp = (PyArrayObject*) py_V157;\n10874\t                PyErr_Format(PyExc_NotImplementedError,\n10875\t                             \"expected an aligned array of type %ld \"\n10876\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n10877\t                             \" with %ld dimensions, with 3 last dims \"\n10878\t                             \"%ld, %ld, %ld\"\n10879\t                             \" and 3 last strides %ld %ld, %ld.\",\n10880\t                             (long int) NPY_FLOAT64,\n10881\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V157),\n10882\t                             (long int) PyArray_NDIM(tmp),\n10883\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n10884\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n10885\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n10886\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n10887\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n10888\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n10889\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n10890\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n10891\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n10892\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n10893\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n10894\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n10895\t            );\n10896\t                {\n10897\t        __failure = 158;\n10898\t        if (!PyErr_Occurred()) {\n10899\t            PyErr_SetString(PyExc_RuntimeError,\n10900\t                \"Unexpected error in an Op's C code. \"\n10901\t                \"No Python exception was set.\");\n10902\t            }\n10903\t        goto __label_158;}\n10904\t            }\n10905\t            // This is a TypeError to be consistent with DEBUG_MODE\n10906\t            // Note: DEBUG_MODE also tells the name of the container\n10907\t            if (PyArray_TYPE((PyArrayObject*) py_V157) != NPY_FLOAT64) {\n10908\t                PyErr_Format(PyExc_TypeError,\n10909\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n10910\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V157));\n10911\t                {\n10912\t        __failure = 158;\n10913\t        if (!PyErr_Occurred()) {\n10914\t            PyErr_SetString(PyExc_RuntimeError,\n10915\t                \"Unexpected error in an Op's C code. \"\n10916\t                \"No Python exception was set.\");\n10917\t            }\n10918\t        goto __label_158;}\n10919\t            }\n10920\t            \n10921\t        V157 = (PyArrayObject*)(py_V157);\n10922\t        Py_XINCREF(V157);\n10923\t        \n10924\t{\n10925\t\n10926\t    py_V159 = PyList_GET_ITEM(storage_V159, 0);\n10927\t    {Py_XINCREF(py_V159);}\n10928\t    \n10929\t            V159 = NULL;\n10930\t            if (py_V159 == Py_None) {\n10931\t                // We can either fail here or set V159 to NULL and rely on Ops\n10932\t                // using tensors to handle the NULL case, but if they fail to do so\n10933\t                // they'll end up with nasty segfaults, so this is public service.\n10934\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n10935\t                {\n10936\t        __failure = 160;\n10937\t        if (!PyErr_Occurred()) {\n10938\t            PyErr_SetString(PyExc_RuntimeError,\n10939\t                \"Unexpected error in an Op's C code. \"\n10940\t                \"No Python exception was set.\");\n10941\t            }\n10942\t        goto __label_160;}\n10943\t            }\n10944\t            if (!PyArray_Check(py_V159)) {\n10945\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n10946\t                {\n10947\t        __failure = 160;\n10948\t        if (!PyErr_Occurred()) {\n10949\t            PyErr_SetString(PyExc_RuntimeError,\n10950\t                \"Unexpected error in an Op's C code. \"\n10951\t                \"No Python exception was set.\");\n10952\t            }\n10953\t        goto __label_160;}\n10954\t            }\n10955\t            // We expect NPY_FLOAT64\n10956\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V159)) {\n10957\t                PyArrayObject * tmp = (PyArrayObject*) py_V159;\n10958\t                PyErr_Format(PyExc_NotImplementedError,\n10959\t                             \"expected an aligned array of type %ld \"\n10960\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n10961\t                             \" with %ld dimensions, with 3 last dims \"\n10962\t                             \"%ld, %ld, %ld\"\n10963\t                             \" and 3 last strides %ld %ld, %ld.\",\n10964\t                             (long int) NPY_FLOAT64,\n10965\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V159),\n10966\t                             (long int) PyArray_NDIM(tmp),\n10967\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n10968\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n10969\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n10970\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n10971\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n10972\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n10973\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n10974\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n10975\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n10976\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n10977\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n10978\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n10979\t            );\n10980\t                {\n10981\t        __failure = 160;\n10982\t        if (!PyErr_Occurred()) {\n10983\t            PyErr_SetString(PyExc_RuntimeError,\n10984\t                \"Unexpected error in an Op's C code. \"\n10985\t                \"No Python exception was set.\");\n10986\t            }\n10987\t        goto __label_160;}\n10988\t            }\n10989\t            // This is a TypeError to be consistent with DEBUG_MODE\n10990\t            // Note: DEBUG_MODE also tells the name of the container\n10991\t            if (PyArray_TYPE((PyArrayObject*) py_V159) != NPY_FLOAT64) {\n10992\t                PyErr_Format(PyExc_TypeError,\n10993\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n10994\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V159));\n10995\t                {\n10996\t        __failure = 160;\n10997\t        if (!PyErr_Occurred()) {\n10998\t            PyErr_SetString(PyExc_RuntimeError,\n10999\t                \"Unexpected error in an Op's C code. \"\n11000\t                \"No Python exception was set.\");\n11001\t            }\n11002\t        goto __label_160;}\n11003\t            }\n11004\t            \n11005\t        V159 = (PyArrayObject*)(py_V159);\n11006\t        Py_XINCREF(V159);\n11007\t        \n11008\t{\n11009\t\n11010\t    py_V161 = PyList_GET_ITEM(storage_V161, 0);\n11011\t    {Py_XINCREF(py_V161);}\n11012\t    \n11013\t            V161 = NULL;\n11014\t            if (py_V161 == Py_None) {\n11015\t                // We can either fail here or set V161 to NULL and rely on Ops\n11016\t                // using tensors to handle the NULL case, but if they fail to do so\n11017\t                // they'll end up with nasty segfaults, so this is public service.\n11018\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n11019\t                {\n11020\t        __failure = 162;\n11021\t        if (!PyErr_Occurred()) {\n11022\t            PyErr_SetString(PyExc_RuntimeError,\n11023\t                \"Unexpected error in an Op's C code. \"\n11024\t                \"No Python exception was set.\");\n11025\t            }\n11026\t        goto __label_162;}\n11027\t            }\n11028\t            if (!PyArray_Check(py_V161)) {\n11029\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n11030\t                {\n11031\t        __failure = 162;\n11032\t        if (!PyErr_Occurred()) {\n11033\t            PyErr_SetString(PyExc_RuntimeError,\n11034\t                \"Unexpected error in an Op's C code. \"\n11035\t                \"No Python exception was set.\");\n11036\t            }\n11037\t        goto __label_162;}\n11038\t            }\n11039\t            // We expect NPY_FLOAT64\n11040\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V161)) {\n11041\t                PyArrayObject * tmp = (PyArrayObject*) py_V161;\n11042\t                PyErr_Format(PyExc_NotImplementedError,\n11043\t                             \"expected an aligned array of type %ld \"\n11044\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n11045\t                             \" with %ld dimensions, with 3 last dims \"\n11046\t                             \"%ld, %ld, %ld\"\n11047\t                             \" and 3 last strides %ld %ld, %ld.\",\n11048\t                             (long int) NPY_FLOAT64,\n11049\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V161),\n11050\t                             (long int) PyArray_NDIM(tmp),\n11051\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n11052\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n11053\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n11054\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n11055\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n11056\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n11057\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n11058\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n11059\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n11060\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n11061\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n11062\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n11063\t            );\n11064\t                {\n11065\t        __failure = 162;\n11066\t        if (!PyErr_Occurred()) {\n11067\t            PyErr_SetString(PyExc_RuntimeError,\n11068\t                \"Unexpected error in an Op's C code. \"\n11069\t                \"No Python exception was set.\");\n11070\t            }\n11071\t        goto __label_162;}\n11072\t            }\n11073\t            // This is a TypeError to be consistent with DEBUG_MODE\n11074\t            // Note: DEBUG_MODE also tells the name of the container\n11075\t            if (PyArray_TYPE((PyArrayObject*) py_V161) != NPY_FLOAT64) {\n11076\t                PyErr_Format(PyExc_TypeError,\n11077\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n11078\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V161));\n11079\t                {\n11080\t        __failure = 162;\n11081\t        if (!PyErr_Occurred()) {\n11082\t            PyErr_SetString(PyExc_RuntimeError,\n11083\t                \"Unexpected error in an Op's C code. \"\n11084\t                \"No Python exception was set.\");\n11085\t            }\n11086\t        goto __label_162;}\n11087\t            }\n11088\t            \n11089\t        V161 = (PyArrayObject*)(py_V161);\n11090\t        Py_XINCREF(V161);\n11091\t        \n11092\t{\n11093\t\n11094\t    py_V163 = PyList_GET_ITEM(storage_V163, 0);\n11095\t    {Py_XINCREF(py_V163);}\n11096\t    \n11097\t            V163 = NULL;\n11098\t            if (py_V163 == Py_None) {\n11099\t                // We can either fail here or set V163 to NULL and rely on Ops\n11100\t                // using tensors to handle the NULL case, but if they fail to do so\n11101\t                // they'll end up with nasty segfaults, so this is public service.\n11102\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n11103\t                {\n11104\t        __failure = 164;\n11105\t        if (!PyErr_Occurred()) {\n11106\t            PyErr_SetString(PyExc_RuntimeError,\n11107\t                \"Unexpected error in an Op's C code. \"\n11108\t                \"No Python exception was set.\");\n11109\t            }\n11110\t        goto __label_164;}\n11111\t            }\n11112\t            if (!PyArray_Check(py_V163)) {\n11113\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n11114\t                {\n11115\t        __failure = 164;\n11116\t        if (!PyErr_Occurred()) {\n11117\t            PyErr_SetString(PyExc_RuntimeError,\n11118\t                \"Unexpected error in an Op's C code. \"\n11119\t                \"No Python exception was set.\");\n11120\t            }\n11121\t        goto __label_164;}\n11122\t            }\n11123\t            // We expect NPY_FLOAT64\n11124\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V163)) {\n11125\t                PyArrayObject * tmp = (PyArrayObject*) py_V163;\n11126\t                PyErr_Format(PyExc_NotImplementedError,\n11127\t                             \"expected an aligned array of type %ld \"\n11128\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n11129\t                             \" with %ld dimensions, with 3 last dims \"\n11130\t                             \"%ld, %ld, %ld\"\n11131\t                             \" and 3 last strides %ld %ld, %ld.\",\n11132\t                             (long int) NPY_FLOAT64,\n11133\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V163),\n11134\t                             (long int) PyArray_NDIM(tmp),\n11135\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n11136\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n11137\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n11138\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n11139\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n11140\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n11141\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n11142\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n11143\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n11144\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n11145\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n11146\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n11147\t            );\n11148\t                {\n11149\t        __failure = 164;\n11150\t        if (!PyErr_Occurred()) {\n11151\t            PyErr_SetString(PyExc_RuntimeError,\n11152\t                \"Unexpected error in an Op's C code. \"\n11153\t                \"No Python exception was set.\");\n11154\t            }\n11155\t        goto __label_164;}\n11156\t            }\n11157\t            // This is a TypeError to be consistent with DEBUG_MODE\n11158\t            // Note: DEBUG_MODE also tells the name of the container\n11159\t            if (PyArray_TYPE((PyArrayObject*) py_V163) != NPY_FLOAT64) {\n11160\t                PyErr_Format(PyExc_TypeError,\n11161\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n11162\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V163));\n11163\t                {\n11164\t        __failure = 164;\n11165\t        if (!PyErr_Occurred()) {\n11166\t            PyErr_SetString(PyExc_RuntimeError,\n11167\t                \"Unexpected error in an Op's C code. \"\n11168\t                \"No Python exception was set.\");\n11169\t            }\n11170\t        goto __label_164;}\n11171\t            }\n11172\t            \n11173\t        V163 = (PyArrayObject*)(py_V163);\n11174\t        Py_XINCREF(V163);\n11175\t        \n11176\t{\n11177\t\n11178\t    py_V165 = PyList_GET_ITEM(storage_V165, 0);\n11179\t    {Py_XINCREF(py_V165);}\n11180\t    \n11181\t            V165 = NULL;\n11182\t            if (py_V165 == Py_None) {\n11183\t                // We can either fail here or set V165 to NULL and rely on Ops\n11184\t                // using tensors to handle the NULL case, but if they fail to do so\n11185\t                // they'll end up with nasty segfaults, so this is public service.\n11186\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n11187\t                {\n11188\t        __failure = 166;\n11189\t        if (!PyErr_Occurred()) {\n11190\t            PyErr_SetString(PyExc_RuntimeError,\n11191\t                \"Unexpected error in an Op's C code. \"\n11192\t                \"No Python exception was set.\");\n11193\t            }\n11194\t        goto __label_166;}\n11195\t            }\n11196\t            if (!PyArray_Check(py_V165)) {\n11197\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n11198\t                {\n11199\t        __failure = 166;\n11200\t        if (!PyErr_Occurred()) {\n11201\t            PyErr_SetString(PyExc_RuntimeError,\n11202\t                \"Unexpected error in an Op's C code. \"\n11203\t                \"No Python exception was set.\");\n11204\t            }\n11205\t        goto __label_166;}\n11206\t            }\n11207\t            // We expect NPY_FLOAT64\n11208\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V165)) {\n11209\t                PyArrayObject * tmp = (PyArrayObject*) py_V165;\n11210\t                PyErr_Format(PyExc_NotImplementedError,\n11211\t                             \"expected an aligned array of type %ld \"\n11212\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n11213\t                             \" with %ld dimensions, with 3 last dims \"\n11214\t                             \"%ld, %ld, %ld\"\n11215\t                             \" and 3 last strides %ld %ld, %ld.\",\n11216\t                             (long int) NPY_FLOAT64,\n11217\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V165),\n11218\t                             (long int) PyArray_NDIM(tmp),\n11219\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n11220\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n11221\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n11222\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n11223\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n11224\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n11225\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n11226\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n11227\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n11228\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n11229\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n11230\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n11231\t            );\n11232\t                {\n11233\t        __failure = 166;\n11234\t        if (!PyErr_Occurred()) {\n11235\t            PyErr_SetString(PyExc_RuntimeError,\n11236\t                \"Unexpected error in an Op's C code. \"\n11237\t                \"No Python exception was set.\");\n11238\t            }\n11239\t        goto __label_166;}\n11240\t            }\n11241\t            // This is a TypeError to be consistent with DEBUG_MODE\n11242\t            // Note: DEBUG_MODE also tells the name of the container\n11243\t            if (PyArray_TYPE((PyArrayObject*) py_V165) != NPY_FLOAT64) {\n11244\t                PyErr_Format(PyExc_TypeError,\n11245\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n11246\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V165));\n11247\t                {\n11248\t        __failure = 166;\n11249\t        if (!PyErr_Occurred()) {\n11250\t            PyErr_SetString(PyExc_RuntimeError,\n11251\t                \"Unexpected error in an Op's C code. \"\n11252\t                \"No Python exception was set.\");\n11253\t            }\n11254\t        goto __label_166;}\n11255\t            }\n11256\t            \n11257\t        V165 = (PyArrayObject*)(py_V165);\n11258\t        Py_XINCREF(V165);\n11259\t        \n11260\t{\n11261\t\n11262\t    py_V167 = PyList_GET_ITEM(storage_V167, 0);\n11263\t    {Py_XINCREF(py_V167);}\n11264\t    \n11265\t            V167 = NULL;\n11266\t            if (py_V167 == Py_None) {\n11267\t                // We can either fail here or set V167 to NULL and rely on Ops\n11268\t                // using tensors to handle the NULL case, but if they fail to do so\n11269\t                // they'll end up with nasty segfaults, so this is public service.\n11270\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n11271\t                {\n11272\t        __failure = 168;\n11273\t        if (!PyErr_Occurred()) {\n11274\t            PyErr_SetString(PyExc_RuntimeError,\n11275\t                \"Unexpected error in an Op's C code. \"\n11276\t                \"No Python exception was set.\");\n11277\t            }\n11278\t        goto __label_168;}\n11279\t            }\n11280\t            if (!PyArray_Check(py_V167)) {\n11281\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n11282\t                {\n11283\t        __failure = 168;\n11284\t        if (!PyErr_Occurred()) {\n11285\t            PyErr_SetString(PyExc_RuntimeError,\n11286\t                \"Unexpected error in an Op's C code. \"\n11287\t                \"No Python exception was set.\");\n11288\t            }\n11289\t        goto __label_168;}\n11290\t            }\n11291\t            // We expect NPY_FLOAT64\n11292\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V167)) {\n11293\t                PyArrayObject * tmp = (PyArrayObject*) py_V167;\n11294\t                PyErr_Format(PyExc_NotImplementedError,\n11295\t                             \"expected an aligned array of type %ld \"\n11296\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n11297\t                             \" with %ld dimensions, with 3 last dims \"\n11298\t                             \"%ld, %ld, %ld\"\n11299\t                             \" and 3 last strides %ld %ld, %ld.\",\n11300\t                             (long int) NPY_FLOAT64,\n11301\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V167),\n11302\t                             (long int) PyArray_NDIM(tmp),\n11303\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n11304\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n11305\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n11306\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n11307\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n11308\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n11309\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n11310\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n11311\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n11312\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n11313\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n11314\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n11315\t            );\n11316\t                {\n11317\t        __failure = 168;\n11318\t        if (!PyErr_Occurred()) {\n11319\t            PyErr_SetString(PyExc_RuntimeError,\n11320\t                \"Unexpected error in an Op's C code. \"\n11321\t                \"No Python exception was set.\");\n11322\t            }\n11323\t        goto __label_168;}\n11324\t            }\n11325\t            // This is a TypeError to be consistent with DEBUG_MODE\n11326\t            // Note: DEBUG_MODE also tells the name of the container\n11327\t            if (PyArray_TYPE((PyArrayObject*) py_V167) != NPY_FLOAT64) {\n11328\t                PyErr_Format(PyExc_TypeError,\n11329\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n11330\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V167));\n11331\t                {\n11332\t        __failure = 168;\n11333\t        if (!PyErr_Occurred()) {\n11334\t            PyErr_SetString(PyExc_RuntimeError,\n11335\t                \"Unexpected error in an Op's C code. \"\n11336\t                \"No Python exception was set.\");\n11337\t            }\n11338\t        goto __label_168;}\n11339\t            }\n11340\t            \n11341\t        V167 = (PyArrayObject*)(py_V167);\n11342\t        Py_XINCREF(V167);\n11343\t        \n11344\t{\n11345\t\n11346\t    py_V169 = PyList_GET_ITEM(storage_V169, 0);\n11347\t    {Py_XINCREF(py_V169);}\n11348\t    \n11349\t            V169 = NULL;\n11350\t            if (py_V169 == Py_None) {\n11351\t                // We can either fail here or set V169 to NULL and rely on Ops\n11352\t                // using tensors to handle the NULL case, but if they fail to do so\n11353\t                // they'll end up with nasty segfaults, so this is public service.\n11354\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n11355\t                {\n11356\t        __failure = 170;\n11357\t        if (!PyErr_Occurred()) {\n11358\t            PyErr_SetString(PyExc_RuntimeError,\n11359\t                \"Unexpected error in an Op's C code. \"\n11360\t                \"No Python exception was set.\");\n11361\t            }\n11362\t        goto __label_170;}\n11363\t            }\n11364\t            if (!PyArray_Check(py_V169)) {\n11365\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n11366\t                {\n11367\t        __failure = 170;\n11368\t        if (!PyErr_Occurred()) {\n11369\t            PyErr_SetString(PyExc_RuntimeError,\n11370\t                \"Unexpected error in an Op's C code. \"\n11371\t                \"No Python exception was set.\");\n11372\t            }\n11373\t        goto __label_170;}\n11374\t            }\n11375\t            // We expect NPY_FLOAT64\n11376\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V169)) {\n11377\t                PyArrayObject * tmp = (PyArrayObject*) py_V169;\n11378\t                PyErr_Format(PyExc_NotImplementedError,\n11379\t                             \"expected an aligned array of type %ld \"\n11380\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n11381\t                             \" with %ld dimensions, with 3 last dims \"\n11382\t                             \"%ld, %ld, %ld\"\n11383\t                             \" and 3 last strides %ld %ld, %ld.\",\n11384\t                             (long int) NPY_FLOAT64,\n11385\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V169),\n11386\t                             (long int) PyArray_NDIM(tmp),\n11387\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n11388\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n11389\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n11390\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n11391\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n11392\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n11393\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n11394\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n11395\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n11396\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n11397\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n11398\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n11399\t            );\n11400\t                {\n11401\t        __failure = 170;\n11402\t        if (!PyErr_Occurred()) {\n11403\t            PyErr_SetString(PyExc_RuntimeError,\n11404\t                \"Unexpected error in an Op's C code. \"\n11405\t                \"No Python exception was set.\");\n11406\t            }\n11407\t        goto __label_170;}\n11408\t            }\n11409\t            // This is a TypeError to be consistent with DEBUG_MODE\n11410\t            // Note: DEBUG_MODE also tells the name of the container\n11411\t            if (PyArray_TYPE((PyArrayObject*) py_V169) != NPY_FLOAT64) {\n11412\t                PyErr_Format(PyExc_TypeError,\n11413\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n11414\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V169));\n11415\t                {\n11416\t        __failure = 170;\n11417\t        if (!PyErr_Occurred()) {\n11418\t            PyErr_SetString(PyExc_RuntimeError,\n11419\t                \"Unexpected error in an Op's C code. \"\n11420\t                \"No Python exception was set.\");\n11421\t            }\n11422\t        goto __label_170;}\n11423\t            }\n11424\t            \n11425\t        V169 = (PyArrayObject*)(py_V169);\n11426\t        Py_XINCREF(V169);\n11427\t        \n11428\t{\n11429\t\n11430\t    py_V171 = PyList_GET_ITEM(storage_V171, 0);\n11431\t    {Py_XINCREF(py_V171);}\n11432\t    \n11433\t            V171 = NULL;\n11434\t            if (py_V171 == Py_None) {\n11435\t                // We can either fail here or set V171 to NULL and rely on Ops\n11436\t                // using tensors to handle the NULL case, but if they fail to do so\n11437\t                // they'll end up with nasty segfaults, so this is public service.\n11438\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n11439\t                {\n11440\t        __failure = 172;\n11441\t        if (!PyErr_Occurred()) {\n11442\t            PyErr_SetString(PyExc_RuntimeError,\n11443\t                \"Unexpected error in an Op's C code. \"\n11444\t                \"No Python exception was set.\");\n11445\t            }\n11446\t        goto __label_172;}\n11447\t            }\n11448\t            if (!PyArray_Check(py_V171)) {\n11449\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n11450\t                {\n11451\t        __failure = 172;\n11452\t        if (!PyErr_Occurred()) {\n11453\t            PyErr_SetString(PyExc_RuntimeError,\n11454\t                \"Unexpected error in an Op's C code. \"\n11455\t                \"No Python exception was set.\");\n11456\t            }\n11457\t        goto __label_172;}\n11458\t            }\n11459\t            // We expect NPY_FLOAT64\n11460\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V171)) {\n11461\t                PyArrayObject * tmp = (PyArrayObject*) py_V171;\n11462\t                PyErr_Format(PyExc_NotImplementedError,\n11463\t                             \"expected an aligned array of type %ld \"\n11464\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n11465\t                             \" with %ld dimensions, with 3 last dims \"\n11466\t                             \"%ld, %ld, %ld\"\n11467\t                             \" and 3 last strides %ld %ld, %ld.\",\n11468\t                             (long int) NPY_FLOAT64,\n11469\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V171),\n11470\t                             (long int) PyArray_NDIM(tmp),\n11471\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n11472\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n11473\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n11474\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n11475\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n11476\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n11477\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n11478\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n11479\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n11480\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n11481\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n11482\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n11483\t            );\n11484\t                {\n11485\t        __failure = 172;\n11486\t        if (!PyErr_Occurred()) {\n11487\t            PyErr_SetString(PyExc_RuntimeError,\n11488\t                \"Unexpected error in an Op's C code. \"\n11489\t                \"No Python exception was set.\");\n11490\t            }\n11491\t        goto __label_172;}\n11492\t            }\n11493\t            // This is a TypeError to be consistent with DEBUG_MODE\n11494\t            // Note: DEBUG_MODE also tells the name of the container\n11495\t            if (PyArray_TYPE((PyArrayObject*) py_V171) != NPY_FLOAT64) {\n11496\t                PyErr_Format(PyExc_TypeError,\n11497\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n11498\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V171));\n11499\t                {\n11500\t        __failure = 172;\n11501\t        if (!PyErr_Occurred()) {\n11502\t            PyErr_SetString(PyExc_RuntimeError,\n11503\t                \"Unexpected error in an Op's C code. \"\n11504\t                \"No Python exception was set.\");\n11505\t            }\n11506\t        goto __label_172;}\n11507\t            }\n11508\t            \n11509\t        V171 = (PyArrayObject*)(py_V171);\n11510\t        Py_XINCREF(V171);\n11511\t        \n11512\t{\n11513\t\n11514\t    py_V173 = PyList_GET_ITEM(storage_V173, 0);\n11515\t    {Py_XINCREF(py_V173);}\n11516\t    \n11517\t            V173 = NULL;\n11518\t            if (py_V173 == Py_None) {\n11519\t                // We can either fail here or set V173 to NULL and rely on Ops\n11520\t                // using tensors to handle the NULL case, but if they fail to do so\n11521\t                // they'll end up with nasty segfaults, so this is public service.\n11522\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n11523\t                {\n11524\t        __failure = 174;\n11525\t        if (!PyErr_Occurred()) {\n11526\t            PyErr_SetString(PyExc_RuntimeError,\n11527\t                \"Unexpected error in an Op's C code. \"\n11528\t                \"No Python exception was set.\");\n11529\t            }\n11530\t        goto __label_174;}\n11531\t            }\n11532\t            if (!PyArray_Check(py_V173)) {\n11533\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n11534\t                {\n11535\t        __failure = 174;\n11536\t        if (!PyErr_Occurred()) {\n11537\t            PyErr_SetString(PyExc_RuntimeError,\n11538\t                \"Unexpected error in an Op's C code. \"\n11539\t                \"No Python exception was set.\");\n11540\t            }\n11541\t        goto __label_174;}\n11542\t            }\n11543\t            // We expect NPY_FLOAT64\n11544\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V173)) {\n11545\t                PyArrayObject * tmp = (PyArrayObject*) py_V173;\n11546\t                PyErr_Format(PyExc_NotImplementedError,\n11547\t                             \"expected an aligned array of type %ld \"\n11548\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n11549\t                             \" with %ld dimensions, with 3 last dims \"\n11550\t                             \"%ld, %ld, %ld\"\n11551\t                             \" and 3 last strides %ld %ld, %ld.\",\n11552\t                             (long int) NPY_FLOAT64,\n11553\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V173),\n11554\t                             (long int) PyArray_NDIM(tmp),\n11555\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n11556\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n11557\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n11558\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n11559\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n11560\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n11561\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n11562\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n11563\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n11564\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n11565\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n11566\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n11567\t            );\n11568\t                {\n11569\t        __failure = 174;\n11570\t        if (!PyErr_Occurred()) {\n11571\t            PyErr_SetString(PyExc_RuntimeError,\n11572\t                \"Unexpected error in an Op's C code. \"\n11573\t                \"No Python exception was set.\");\n11574\t            }\n11575\t        goto __label_174;}\n11576\t            }\n11577\t            // This is a TypeError to be consistent with DEBUG_MODE\n11578\t            // Note: DEBUG_MODE also tells the name of the container\n11579\t            if (PyArray_TYPE((PyArrayObject*) py_V173) != NPY_FLOAT64) {\n11580\t                PyErr_Format(PyExc_TypeError,\n11581\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n11582\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V173));\n11583\t                {\n11584\t        __failure = 174;\n11585\t        if (!PyErr_Occurred()) {\n11586\t            PyErr_SetString(PyExc_RuntimeError,\n11587\t                \"Unexpected error in an Op's C code. \"\n11588\t                \"No Python exception was set.\");\n11589\t            }\n11590\t        goto __label_174;}\n11591\t            }\n11592\t            \n11593\t        V173 = (PyArrayObject*)(py_V173);\n11594\t        Py_XINCREF(V173);\n11595\t        \n11596\t{\n11597\t\n11598\t    py_V175 = PyList_GET_ITEM(storage_V175, 0);\n11599\t    {Py_XINCREF(py_V175);}\n11600\t    \n11601\t            V175 = NULL;\n11602\t            if (py_V175 == Py_None) {\n11603\t                // We can either fail here or set V175 to NULL and rely on Ops\n11604\t                // using tensors to handle the NULL case, but if they fail to do so\n11605\t                // they'll end up with nasty segfaults, so this is public service.\n11606\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n11607\t                {\n11608\t        __failure = 176;\n11609\t        if (!PyErr_Occurred()) {\n11610\t            PyErr_SetString(PyExc_RuntimeError,\n11611\t                \"Unexpected error in an Op's C code. \"\n11612\t                \"No Python exception was set.\");\n11613\t            }\n11614\t        goto __label_176;}\n11615\t            }\n11616\t            if (!PyArray_Check(py_V175)) {\n11617\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n11618\t                {\n11619\t        __failure = 176;\n11620\t        if (!PyErr_Occurred()) {\n11621\t            PyErr_SetString(PyExc_RuntimeError,\n11622\t                \"Unexpected error in an Op's C code. \"\n11623\t                \"No Python exception was set.\");\n11624\t            }\n11625\t        goto __label_176;}\n11626\t            }\n11627\t            // We expect NPY_FLOAT64\n11628\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V175)) {\n11629\t                PyArrayObject * tmp = (PyArrayObject*) py_V175;\n11630\t                PyErr_Format(PyExc_NotImplementedError,\n11631\t                             \"expected an aligned array of type %ld \"\n11632\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n11633\t                             \" with %ld dimensions, with 3 last dims \"\n11634\t                             \"%ld, %ld, %ld\"\n11635\t                             \" and 3 last strides %ld %ld, %ld.\",\n11636\t                             (long int) NPY_FLOAT64,\n11637\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V175),\n11638\t                             (long int) PyArray_NDIM(tmp),\n11639\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n11640\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n11641\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n11642\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n11643\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n11644\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n11645\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n11646\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n11647\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n11648\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n11649\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n11650\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n11651\t            );\n11652\t                {\n11653\t        __failure = 176;\n11654\t        if (!PyErr_Occurred()) {\n11655\t            PyErr_SetString(PyExc_RuntimeError,\n11656\t                \"Unexpected error in an Op's C code. \"\n11657\t                \"No Python exception was set.\");\n11658\t            }\n11659\t        goto __label_176;}\n11660\t            }\n11661\t            // This is a TypeError to be consistent with DEBUG_MODE\n11662\t            // Note: DEBUG_MODE also tells the name of the container\n11663\t            if (PyArray_TYPE((PyArrayObject*) py_V175) != NPY_FLOAT64) {\n11664\t                PyErr_Format(PyExc_TypeError,\n11665\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n11666\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V175));\n11667\t                {\n11668\t        __failure = 176;\n11669\t        if (!PyErr_Occurred()) {\n11670\t            PyErr_SetString(PyExc_RuntimeError,\n11671\t                \"Unexpected error in an Op's C code. \"\n11672\t                \"No Python exception was set.\");\n11673\t            }\n11674\t        goto __label_176;}\n11675\t            }\n11676\t            \n11677\t        V175 = (PyArrayObject*)(py_V175);\n11678\t        Py_XINCREF(V175);\n11679\t        \n11680\t{\n11681\t\n11682\t    py_V177 = PyList_GET_ITEM(storage_V177, 0);\n11683\t    {Py_XINCREF(py_V177);}\n11684\t    \n11685\t            V177 = NULL;\n11686\t            if (py_V177 == Py_None) {\n11687\t                // We can either fail here or set V177 to NULL and rely on Ops\n11688\t                // using tensors to handle the NULL case, but if they fail to do so\n11689\t                // they'll end up with nasty segfaults, so this is public service.\n11690\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n11691\t                {\n11692\t        __failure = 178;\n11693\t        if (!PyErr_Occurred()) {\n11694\t            PyErr_SetString(PyExc_RuntimeError,\n11695\t                \"Unexpected error in an Op's C code. \"\n11696\t                \"No Python exception was set.\");\n11697\t            }\n11698\t        goto __label_178;}\n11699\t            }\n11700\t            if (!PyArray_Check(py_V177)) {\n11701\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n11702\t                {\n11703\t        __failure = 178;\n11704\t        if (!PyErr_Occurred()) {\n11705\t            PyErr_SetString(PyExc_RuntimeError,\n11706\t                \"Unexpected error in an Op's C code. \"\n11707\t                \"No Python exception was set.\");\n11708\t            }\n11709\t        goto __label_178;}\n11710\t            }\n11711\t            // We expect NPY_FLOAT64\n11712\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V177)) {\n11713\t                PyArrayObject * tmp = (PyArrayObject*) py_V177;\n11714\t                PyErr_Format(PyExc_NotImplementedError,\n11715\t                             \"expected an aligned array of type %ld \"\n11716\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n11717\t                             \" with %ld dimensions, with 3 last dims \"\n11718\t                             \"%ld, %ld, %ld\"\n11719\t                             \" and 3 last strides %ld %ld, %ld.\",\n11720\t                             (long int) NPY_FLOAT64,\n11721\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V177),\n11722\t                             (long int) PyArray_NDIM(tmp),\n11723\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n11724\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n11725\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n11726\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n11727\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n11728\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n11729\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n11730\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n11731\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n11732\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n11733\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n11734\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n11735\t            );\n11736\t                {\n11737\t        __failure = 178;\n11738\t        if (!PyErr_Occurred()) {\n11739\t            PyErr_SetString(PyExc_RuntimeError,\n11740\t                \"Unexpected error in an Op's C code. \"\n11741\t                \"No Python exception was set.\");\n11742\t            }\n11743\t        goto __label_178;}\n11744\t            }\n11745\t            // This is a TypeError to be consistent with DEBUG_MODE\n11746\t            // Note: DEBUG_MODE also tells the name of the container\n11747\t            if (PyArray_TYPE((PyArrayObject*) py_V177) != NPY_FLOAT64) {\n11748\t                PyErr_Format(PyExc_TypeError,\n11749\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n11750\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V177));\n11751\t                {\n11752\t        __failure = 178;\n11753\t        if (!PyErr_Occurred()) {\n11754\t            PyErr_SetString(PyExc_RuntimeError,\n11755\t                \"Unexpected error in an Op's C code. \"\n11756\t                \"No Python exception was set.\");\n11757\t            }\n11758\t        goto __label_178;}\n11759\t            }\n11760\t            \n11761\t        V177 = (PyArrayObject*)(py_V177);\n11762\t        Py_XINCREF(V177);\n11763\t        \n11764\t{\n11765\t\n11766\t    py_V179 = PyList_GET_ITEM(storage_V179, 0);\n11767\t    {Py_XINCREF(py_V179);}\n11768\t    \n11769\t            V179 = NULL;\n11770\t            if (py_V179 == Py_None) {\n11771\t                // We can either fail here or set V179 to NULL and rely on Ops\n11772\t                // using tensors to handle the NULL case, but if they fail to do so\n11773\t                // they'll end up with nasty segfaults, so this is public service.\n11774\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n11775\t                {\n11776\t        __failure = 180;\n11777\t        if (!PyErr_Occurred()) {\n11778\t            PyErr_SetString(PyExc_RuntimeError,\n11779\t                \"Unexpected error in an Op's C code. \"\n11780\t                \"No Python exception was set.\");\n11781\t            }\n11782\t        goto __label_180;}\n11783\t            }\n11784\t            if (!PyArray_Check(py_V179)) {\n11785\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n11786\t                {\n11787\t        __failure = 180;\n11788\t        if (!PyErr_Occurred()) {\n11789\t            PyErr_SetString(PyExc_RuntimeError,\n11790\t                \"Unexpected error in an Op's C code. \"\n11791\t                \"No Python exception was set.\");\n11792\t            }\n11793\t        goto __label_180;}\n11794\t            }\n11795\t            // We expect NPY_FLOAT64\n11796\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V179)) {\n11797\t                PyArrayObject * tmp = (PyArrayObject*) py_V179;\n11798\t                PyErr_Format(PyExc_NotImplementedError,\n11799\t                             \"expected an aligned array of type %ld \"\n11800\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n11801\t                             \" with %ld dimensions, with 3 last dims \"\n11802\t                             \"%ld, %ld, %ld\"\n11803\t                             \" and 3 last strides %ld %ld, %ld.\",\n11804\t                             (long int) NPY_FLOAT64,\n11805\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V179),\n11806\t                             (long int) PyArray_NDIM(tmp),\n11807\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n11808\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n11809\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n11810\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n11811\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n11812\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n11813\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n11814\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n11815\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n11816\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n11817\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n11818\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n11819\t            );\n11820\t                {\n11821\t        __failure = 180;\n11822\t        if (!PyErr_Occurred()) {\n11823\t            PyErr_SetString(PyExc_RuntimeError,\n11824\t                \"Unexpected error in an Op's C code. \"\n11825\t                \"No Python exception was set.\");\n11826\t            }\n11827\t        goto __label_180;}\n11828\t            }\n11829\t            // This is a TypeError to be consistent with DEBUG_MODE\n11830\t            // Note: DEBUG_MODE also tells the name of the container\n11831\t            if (PyArray_TYPE((PyArrayObject*) py_V179) != NPY_FLOAT64) {\n11832\t                PyErr_Format(PyExc_TypeError,\n11833\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n11834\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V179));\n11835\t                {\n11836\t        __failure = 180;\n11837\t        if (!PyErr_Occurred()) {\n11838\t            PyErr_SetString(PyExc_RuntimeError,\n11839\t                \"Unexpected error in an Op's C code. \"\n11840\t                \"No Python exception was set.\");\n11841\t            }\n11842\t        goto __label_180;}\n11843\t            }\n11844\t            \n11845\t        V179 = (PyArrayObject*)(py_V179);\n11846\t        Py_XINCREF(V179);\n11847\t        \n11848\t{\n11849\t\n11850\t    py_V181 = PyList_GET_ITEM(storage_V181, 0);\n11851\t    {Py_XINCREF(py_V181);}\n11852\t    \n11853\t            V181 = NULL;\n11854\t            if (py_V181 == Py_None) {\n11855\t                // We can either fail here or set V181 to NULL and rely on Ops\n11856\t                // using tensors to handle the NULL case, but if they fail to do so\n11857\t                // they'll end up with nasty segfaults, so this is public service.\n11858\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n11859\t                {\n11860\t        __failure = 182;\n11861\t        if (!PyErr_Occurred()) {\n11862\t            PyErr_SetString(PyExc_RuntimeError,\n11863\t                \"Unexpected error in an Op's C code. \"\n11864\t                \"No Python exception was set.\");\n11865\t            }\n11866\t        goto __label_182;}\n11867\t            }\n11868\t            if (!PyArray_Check(py_V181)) {\n11869\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n11870\t                {\n11871\t        __failure = 182;\n11872\t        if (!PyErr_Occurred()) {\n11873\t            PyErr_SetString(PyExc_RuntimeError,\n11874\t                \"Unexpected error in an Op's C code. \"\n11875\t                \"No Python exception was set.\");\n11876\t            }\n11877\t        goto __label_182;}\n11878\t            }\n11879\t            // We expect NPY_FLOAT64\n11880\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V181)) {\n11881\t                PyArrayObject * tmp = (PyArrayObject*) py_V181;\n11882\t                PyErr_Format(PyExc_NotImplementedError,\n11883\t                             \"expected an aligned array of type %ld \"\n11884\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n11885\t                             \" with %ld dimensions, with 3 last dims \"\n11886\t                             \"%ld, %ld, %ld\"\n11887\t                             \" and 3 last strides %ld %ld, %ld.\",\n11888\t                             (long int) NPY_FLOAT64,\n11889\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V181),\n11890\t                             (long int) PyArray_NDIM(tmp),\n11891\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n11892\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n11893\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n11894\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n11895\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n11896\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n11897\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n11898\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n11899\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n11900\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n11901\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n11902\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n11903\t            );\n11904\t                {\n11905\t        __failure = 182;\n11906\t        if (!PyErr_Occurred()) {\n11907\t            PyErr_SetString(PyExc_RuntimeError,\n11908\t                \"Unexpected error in an Op's C code. \"\n11909\t                \"No Python exception was set.\");\n11910\t            }\n11911\t        goto __label_182;}\n11912\t            }\n11913\t            // This is a TypeError to be consistent with DEBUG_MODE\n11914\t            // Note: DEBUG_MODE also tells the name of the container\n11915\t            if (PyArray_TYPE((PyArrayObject*) py_V181) != NPY_FLOAT64) {\n11916\t                PyErr_Format(PyExc_TypeError,\n11917\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n11918\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V181));\n11919\t                {\n11920\t        __failure = 182;\n11921\t        if (!PyErr_Occurred()) {\n11922\t            PyErr_SetString(PyExc_RuntimeError,\n11923\t                \"Unexpected error in an Op's C code. \"\n11924\t                \"No Python exception was set.\");\n11925\t            }\n11926\t        goto __label_182;}\n11927\t            }\n11928\t            \n11929\t        V181 = (PyArrayObject*)(py_V181);\n11930\t        Py_XINCREF(V181);\n11931\t        \n11932\t{\n11933\t\n11934\t    py_V183 = PyList_GET_ITEM(storage_V183, 0);\n11935\t    {Py_XINCREF(py_V183);}\n11936\t    \n11937\t            V183 = NULL;\n11938\t            if (py_V183 == Py_None) {\n11939\t                // We can either fail here or set V183 to NULL and rely on Ops\n11940\t                // using tensors to handle the NULL case, but if they fail to do so\n11941\t                // they'll end up with nasty segfaults, so this is public service.\n11942\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n11943\t                {\n11944\t        __failure = 184;\n11945\t        if (!PyErr_Occurred()) {\n11946\t            PyErr_SetString(PyExc_RuntimeError,\n11947\t                \"Unexpected error in an Op's C code. \"\n11948\t                \"No Python exception was set.\");\n11949\t            }\n11950\t        goto __label_184;}\n11951\t            }\n11952\t            if (!PyArray_Check(py_V183)) {\n11953\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n11954\t                {\n11955\t        __failure = 184;\n11956\t        if (!PyErr_Occurred()) {\n11957\t            PyErr_SetString(PyExc_RuntimeError,\n11958\t                \"Unexpected error in an Op's C code. \"\n11959\t                \"No Python exception was set.\");\n11960\t            }\n11961\t        goto __label_184;}\n11962\t            }\n11963\t            // We expect NPY_FLOAT64\n11964\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V183)) {\n11965\t                PyArrayObject * tmp = (PyArrayObject*) py_V183;\n11966\t                PyErr_Format(PyExc_NotImplementedError,\n11967\t                             \"expected an aligned array of type %ld \"\n11968\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n11969\t                             \" with %ld dimensions, with 3 last dims \"\n11970\t                             \"%ld, %ld, %ld\"\n11971\t                             \" and 3 last strides %ld %ld, %ld.\",\n11972\t                             (long int) NPY_FLOAT64,\n11973\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V183),\n11974\t                             (long int) PyArray_NDIM(tmp),\n11975\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n11976\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n11977\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n11978\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n11979\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n11980\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n11981\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n11982\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n11983\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n11984\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n11985\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n11986\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n11987\t            );\n11988\t                {\n11989\t        __failure = 184;\n11990\t        if (!PyErr_Occurred()) {\n11991\t            PyErr_SetString(PyExc_RuntimeError,\n11992\t                \"Unexpected error in an Op's C code. \"\n11993\t                \"No Python exception was set.\");\n11994\t            }\n11995\t        goto __label_184;}\n11996\t            }\n11997\t            // This is a TypeError to be consistent with DEBUG_MODE\n11998\t            // Note: DEBUG_MODE also tells the name of the container\n11999\t            if (PyArray_TYPE((PyArrayObject*) py_V183) != NPY_FLOAT64) {\n12000\t                PyErr_Format(PyExc_TypeError,\n12001\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n12002\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V183));\n12003\t                {\n12004\t        __failure = 184;\n12005\t        if (!PyErr_Occurred()) {\n12006\t            PyErr_SetString(PyExc_RuntimeError,\n12007\t                \"Unexpected error in an Op's C code. \"\n12008\t                \"No Python exception was set.\");\n12009\t            }\n12010\t        goto __label_184;}\n12011\t            }\n12012\t            \n12013\t        V183 = (PyArrayObject*)(py_V183);\n12014\t        Py_XINCREF(V183);\n12015\t        \n12016\t{\n12017\t\n12018\t    py_V185 = PyList_GET_ITEM(storage_V185, 0);\n12019\t    {Py_XINCREF(py_V185);}\n12020\t    \n12021\t            V185 = NULL;\n12022\t            if (py_V185 == Py_None) {\n12023\t                // We can either fail here or set V185 to NULL and rely on Ops\n12024\t                // using tensors to handle the NULL case, but if they fail to do so\n12025\t                // they'll end up with nasty segfaults, so this is public service.\n12026\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n12027\t                {\n12028\t        __failure = 186;\n12029\t        if (!PyErr_Occurred()) {\n12030\t            PyErr_SetString(PyExc_RuntimeError,\n12031\t                \"Unexpected error in an Op's C code. \"\n12032\t                \"No Python exception was set.\");\n12033\t            }\n12034\t        goto __label_186;}\n12035\t            }\n12036\t            if (!PyArray_Check(py_V185)) {\n12037\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n12038\t                {\n12039\t        __failure = 186;\n12040\t        if (!PyErr_Occurred()) {\n12041\t            PyErr_SetString(PyExc_RuntimeError,\n12042\t                \"Unexpected error in an Op's C code. \"\n12043\t                \"No Python exception was set.\");\n12044\t            }\n12045\t        goto __label_186;}\n12046\t            }\n12047\t            // We expect NPY_FLOAT64\n12048\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V185)) {\n12049\t                PyArrayObject * tmp = (PyArrayObject*) py_V185;\n12050\t                PyErr_Format(PyExc_NotImplementedError,\n12051\t                             \"expected an aligned array of type %ld \"\n12052\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n12053\t                             \" with %ld dimensions, with 3 last dims \"\n12054\t                             \"%ld, %ld, %ld\"\n12055\t                             \" and 3 last strides %ld %ld, %ld.\",\n12056\t                             (long int) NPY_FLOAT64,\n12057\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V185),\n12058\t                             (long int) PyArray_NDIM(tmp),\n12059\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n12060\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n12061\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n12062\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n12063\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n12064\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n12065\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n12066\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n12067\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n12068\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n12069\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n12070\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n12071\t            );\n12072\t                {\n12073\t        __failure = 186;\n12074\t        if (!PyErr_Occurred()) {\n12075\t            PyErr_SetString(PyExc_RuntimeError,\n12076\t                \"Unexpected error in an Op's C code. \"\n12077\t                \"No Python exception was set.\");\n12078\t            }\n12079\t        goto __label_186;}\n12080\t            }\n12081\t            // This is a TypeError to be consistent with DEBUG_MODE\n12082\t            // Note: DEBUG_MODE also tells the name of the container\n12083\t            if (PyArray_TYPE((PyArrayObject*) py_V185) != NPY_FLOAT64) {\n12084\t                PyErr_Format(PyExc_TypeError,\n12085\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n12086\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V185));\n12087\t                {\n12088\t        __failure = 186;\n12089\t        if (!PyErr_Occurred()) {\n12090\t            PyErr_SetString(PyExc_RuntimeError,\n12091\t                \"Unexpected error in an Op's C code. \"\n12092\t                \"No Python exception was set.\");\n12093\t            }\n12094\t        goto __label_186;}\n12095\t            }\n12096\t            \n12097\t        V185 = (PyArrayObject*)(py_V185);\n12098\t        Py_XINCREF(V185);\n12099\t        \n12100\t{\n12101\t\n12102\t    py_V187 = PyList_GET_ITEM(storage_V187, 0);\n12103\t    {Py_XINCREF(py_V187);}\n12104\t    \n12105\t            V187 = NULL;\n12106\t            if (py_V187 == Py_None) {\n12107\t                // We can either fail here or set V187 to NULL and rely on Ops\n12108\t                // using tensors to handle the NULL case, but if they fail to do so\n12109\t                // they'll end up with nasty segfaults, so this is public service.\n12110\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n12111\t                {\n12112\t        __failure = 188;\n12113\t        if (!PyErr_Occurred()) {\n12114\t            PyErr_SetString(PyExc_RuntimeError,\n12115\t                \"Unexpected error in an Op's C code. \"\n12116\t                \"No Python exception was set.\");\n12117\t            }\n12118\t        goto __label_188;}\n12119\t            }\n12120\t            if (!PyArray_Check(py_V187)) {\n12121\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n12122\t                {\n12123\t        __failure = 188;\n12124\t        if (!PyErr_Occurred()) {\n12125\t            PyErr_SetString(PyExc_RuntimeError,\n12126\t                \"Unexpected error in an Op's C code. \"\n12127\t                \"No Python exception was set.\");\n12128\t            }\n12129\t        goto __label_188;}\n12130\t            }\n12131\t            // We expect NPY_FLOAT64\n12132\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V187)) {\n12133\t                PyArrayObject * tmp = (PyArrayObject*) py_V187;\n12134\t                PyErr_Format(PyExc_NotImplementedError,\n12135\t                             \"expected an aligned array of type %ld \"\n12136\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n12137\t                             \" with %ld dimensions, with 3 last dims \"\n12138\t                             \"%ld, %ld, %ld\"\n12139\t                             \" and 3 last strides %ld %ld, %ld.\",\n12140\t                             (long int) NPY_FLOAT64,\n12141\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V187),\n12142\t                             (long int) PyArray_NDIM(tmp),\n12143\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n12144\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n12145\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n12146\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n12147\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n12148\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n12149\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n12150\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n12151\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n12152\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n12153\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n12154\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n12155\t            );\n12156\t                {\n12157\t        __failure = 188;\n12158\t        if (!PyErr_Occurred()) {\n12159\t            PyErr_SetString(PyExc_RuntimeError,\n12160\t                \"Unexpected error in an Op's C code. \"\n12161\t                \"No Python exception was set.\");\n12162\t            }\n12163\t        goto __label_188;}\n12164\t            }\n12165\t            // This is a TypeError to be consistent with DEBUG_MODE\n12166\t            // Note: DEBUG_MODE also tells the name of the container\n12167\t            if (PyArray_TYPE((PyArrayObject*) py_V187) != NPY_FLOAT64) {\n12168\t                PyErr_Format(PyExc_TypeError,\n12169\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n12170\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V187));\n12171\t                {\n12172\t        __failure = 188;\n12173\t        if (!PyErr_Occurred()) {\n12174\t            PyErr_SetString(PyExc_RuntimeError,\n12175\t                \"Unexpected error in an Op's C code. \"\n12176\t                \"No Python exception was set.\");\n12177\t            }\n12178\t        goto __label_188;}\n12179\t            }\n12180\t            \n12181\t        V187 = (PyArrayObject*)(py_V187);\n12182\t        Py_XINCREF(V187);\n12183\t        \n12184\t{\n12185\t\n12186\t    py_V189 = PyList_GET_ITEM(storage_V189, 0);\n12187\t    {Py_XINCREF(py_V189);}\n12188\t    \n12189\t            V189 = NULL;\n12190\t            if (py_V189 == Py_None) {\n12191\t                // We can either fail here or set V189 to NULL and rely on Ops\n12192\t                // using tensors to handle the NULL case, but if they fail to do so\n12193\t                // they'll end up with nasty segfaults, so this is public service.\n12194\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n12195\t                {\n12196\t        __failure = 190;\n12197\t        if (!PyErr_Occurred()) {\n12198\t            PyErr_SetString(PyExc_RuntimeError,\n12199\t                \"Unexpected error in an Op's C code. \"\n12200\t                \"No Python exception was set.\");\n12201\t            }\n12202\t        goto __label_190;}\n12203\t            }\n12204\t            if (!PyArray_Check(py_V189)) {\n12205\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n12206\t                {\n12207\t        __failure = 190;\n12208\t        if (!PyErr_Occurred()) {\n12209\t            PyErr_SetString(PyExc_RuntimeError,\n12210\t                \"Unexpected error in an Op's C code. \"\n12211\t                \"No Python exception was set.\");\n12212\t            }\n12213\t        goto __label_190;}\n12214\t            }\n12215\t            // We expect NPY_FLOAT64\n12216\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V189)) {\n12217\t                PyArrayObject * tmp = (PyArrayObject*) py_V189;\n12218\t                PyErr_Format(PyExc_NotImplementedError,\n12219\t                             \"expected an aligned array of type %ld \"\n12220\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n12221\t                             \" with %ld dimensions, with 3 last dims \"\n12222\t                             \"%ld, %ld, %ld\"\n12223\t                             \" and 3 last strides %ld %ld, %ld.\",\n12224\t                             (long int) NPY_FLOAT64,\n12225\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V189),\n12226\t                             (long int) PyArray_NDIM(tmp),\n12227\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n12228\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n12229\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n12230\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n12231\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n12232\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n12233\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n12234\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n12235\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n12236\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n12237\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n12238\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n12239\t            );\n12240\t                {\n12241\t        __failure = 190;\n12242\t        if (!PyErr_Occurred()) {\n12243\t            PyErr_SetString(PyExc_RuntimeError,\n12244\t                \"Unexpected error in an Op's C code. \"\n12245\t                \"No Python exception was set.\");\n12246\t            }\n12247\t        goto __label_190;}\n12248\t            }\n12249\t            // This is a TypeError to be consistent with DEBUG_MODE\n12250\t            // Note: DEBUG_MODE also tells the name of the container\n12251\t            if (PyArray_TYPE((PyArrayObject*) py_V189) != NPY_FLOAT64) {\n12252\t                PyErr_Format(PyExc_TypeError,\n12253\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n12254\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V189));\n12255\t                {\n12256\t        __failure = 190;\n12257\t        if (!PyErr_Occurred()) {\n12258\t            PyErr_SetString(PyExc_RuntimeError,\n12259\t                \"Unexpected error in an Op's C code. \"\n12260\t                \"No Python exception was set.\");\n12261\t            }\n12262\t        goto __label_190;}\n12263\t            }\n12264\t            \n12265\t        V189 = (PyArrayObject*)(py_V189);\n12266\t        Py_XINCREF(V189);\n12267\t        \n12268\t{\n12269\t\n12270\t    py_V191 = PyList_GET_ITEM(storage_V191, 0);\n12271\t    {Py_XINCREF(py_V191);}\n12272\t    \n12273\t            V191 = NULL;\n12274\t            if (py_V191 == Py_None) {\n12275\t                // We can either fail here or set V191 to NULL and rely on Ops\n12276\t                // using tensors to handle the NULL case, but if they fail to do so\n12277\t                // they'll end up with nasty segfaults, so this is public service.\n12278\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n12279\t                {\n12280\t        __failure = 192;\n12281\t        if (!PyErr_Occurred()) {\n12282\t            PyErr_SetString(PyExc_RuntimeError,\n12283\t                \"Unexpected error in an Op's C code. \"\n12284\t                \"No Python exception was set.\");\n12285\t            }\n12286\t        goto __label_192;}\n12287\t            }\n12288\t            if (!PyArray_Check(py_V191)) {\n12289\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n12290\t                {\n12291\t        __failure = 192;\n12292\t        if (!PyErr_Occurred()) {\n12293\t            PyErr_SetString(PyExc_RuntimeError,\n12294\t                \"Unexpected error in an Op's C code. \"\n12295\t                \"No Python exception was set.\");\n12296\t            }\n12297\t        goto __label_192;}\n12298\t            }\n12299\t            // We expect NPY_FLOAT64\n12300\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V191)) {\n12301\t                PyArrayObject * tmp = (PyArrayObject*) py_V191;\n12302\t                PyErr_Format(PyExc_NotImplementedError,\n12303\t                             \"expected an aligned array of type %ld \"\n12304\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n12305\t                             \" with %ld dimensions, with 3 last dims \"\n12306\t                             \"%ld, %ld, %ld\"\n12307\t                             \" and 3 last strides %ld %ld, %ld.\",\n12308\t                             (long int) NPY_FLOAT64,\n12309\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V191),\n12310\t                             (long int) PyArray_NDIM(tmp),\n12311\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n12312\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n12313\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n12314\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n12315\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n12316\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n12317\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n12318\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n12319\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n12320\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n12321\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n12322\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n12323\t            );\n12324\t                {\n12325\t        __failure = 192;\n12326\t        if (!PyErr_Occurred()) {\n12327\t            PyErr_SetString(PyExc_RuntimeError,\n12328\t                \"Unexpected error in an Op's C code. \"\n12329\t                \"No Python exception was set.\");\n12330\t            }\n12331\t        goto __label_192;}\n12332\t            }\n12333\t            // This is a TypeError to be consistent with DEBUG_MODE\n12334\t            // Note: DEBUG_MODE also tells the name of the container\n12335\t            if (PyArray_TYPE((PyArrayObject*) py_V191) != NPY_FLOAT64) {\n12336\t                PyErr_Format(PyExc_TypeError,\n12337\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n12338\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V191));\n12339\t                {\n12340\t        __failure = 192;\n12341\t        if (!PyErr_Occurred()) {\n12342\t            PyErr_SetString(PyExc_RuntimeError,\n12343\t                \"Unexpected error in an Op's C code. \"\n12344\t                \"No Python exception was set.\");\n12345\t            }\n12346\t        goto __label_192;}\n12347\t            }\n12348\t            \n12349\t        V191 = (PyArrayObject*)(py_V191);\n12350\t        Py_XINCREF(V191);\n12351\t        \n12352\t{\n12353\t\n12354\t    py_V193 = PyList_GET_ITEM(storage_V193, 0);\n12355\t    {Py_XINCREF(py_V193);}\n12356\t    \n12357\t            V193 = NULL;\n12358\t            if (py_V193 == Py_None) {\n12359\t                // We can either fail here or set V193 to NULL and rely on Ops\n12360\t                // using tensors to handle the NULL case, but if they fail to do so\n12361\t                // they'll end up with nasty segfaults, so this is public service.\n12362\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n12363\t                {\n12364\t        __failure = 194;\n12365\t        if (!PyErr_Occurred()) {\n12366\t            PyErr_SetString(PyExc_RuntimeError,\n12367\t                \"Unexpected error in an Op's C code. \"\n12368\t                \"No Python exception was set.\");\n12369\t            }\n12370\t        goto __label_194;}\n12371\t            }\n12372\t            if (!PyArray_Check(py_V193)) {\n12373\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n12374\t                {\n12375\t        __failure = 194;\n12376\t        if (!PyErr_Occurred()) {\n12377\t            PyErr_SetString(PyExc_RuntimeError,\n12378\t                \"Unexpected error in an Op's C code. \"\n12379\t                \"No Python exception was set.\");\n12380\t            }\n12381\t        goto __label_194;}\n12382\t            }\n12383\t            // We expect NPY_FLOAT64\n12384\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V193)) {\n12385\t                PyArrayObject * tmp = (PyArrayObject*) py_V193;\n12386\t                PyErr_Format(PyExc_NotImplementedError,\n12387\t                             \"expected an aligned array of type %ld \"\n12388\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n12389\t                             \" with %ld dimensions, with 3 last dims \"\n12390\t                             \"%ld, %ld, %ld\"\n12391\t                             \" and 3 last strides %ld %ld, %ld.\",\n12392\t                             (long int) NPY_FLOAT64,\n12393\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V193),\n12394\t                             (long int) PyArray_NDIM(tmp),\n12395\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n12396\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n12397\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n12398\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n12399\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n12400\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n12401\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n12402\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n12403\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n12404\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n12405\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n12406\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n12407\t            );\n12408\t                {\n12409\t        __failure = 194;\n12410\t        if (!PyErr_Occurred()) {\n12411\t            PyErr_SetString(PyExc_RuntimeError,\n12412\t                \"Unexpected error in an Op's C code. \"\n12413\t                \"No Python exception was set.\");\n12414\t            }\n12415\t        goto __label_194;}\n12416\t            }\n12417\t            // This is a TypeError to be consistent with DEBUG_MODE\n12418\t            // Note: DEBUG_MODE also tells the name of the container\n12419\t            if (PyArray_TYPE((PyArrayObject*) py_V193) != NPY_FLOAT64) {\n12420\t                PyErr_Format(PyExc_TypeError,\n12421\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n12422\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V193));\n12423\t                {\n12424\t        __failure = 194;\n12425\t        if (!PyErr_Occurred()) {\n12426\t            PyErr_SetString(PyExc_RuntimeError,\n12427\t                \"Unexpected error in an Op's C code. \"\n12428\t                \"No Python exception was set.\");\n12429\t            }\n12430\t        goto __label_194;}\n12431\t            }\n12432\t            \n12433\t        V193 = (PyArrayObject*)(py_V193);\n12434\t        Py_XINCREF(V193);\n12435\t        \n12436\t{\n12437\t\n12438\t    py_V195 = PyList_GET_ITEM(storage_V195, 0);\n12439\t    {Py_XINCREF(py_V195);}\n12440\t    \n12441\t            V195 = NULL;\n12442\t            if (py_V195 == Py_None) {\n12443\t                // We can either fail here or set V195 to NULL and rely on Ops\n12444\t                // using tensors to handle the NULL case, but if they fail to do so\n12445\t                // they'll end up with nasty segfaults, so this is public service.\n12446\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n12447\t                {\n12448\t        __failure = 196;\n12449\t        if (!PyErr_Occurred()) {\n12450\t            PyErr_SetString(PyExc_RuntimeError,\n12451\t                \"Unexpected error in an Op's C code. \"\n12452\t                \"No Python exception was set.\");\n12453\t            }\n12454\t        goto __label_196;}\n12455\t            }\n12456\t            if (!PyArray_Check(py_V195)) {\n12457\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n12458\t                {\n12459\t        __failure = 196;\n12460\t        if (!PyErr_Occurred()) {\n12461\t            PyErr_SetString(PyExc_RuntimeError,\n12462\t                \"Unexpected error in an Op's C code. \"\n12463\t                \"No Python exception was set.\");\n12464\t            }\n12465\t        goto __label_196;}\n12466\t            }\n12467\t            // We expect NPY_FLOAT64\n12468\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V195)) {\n12469\t                PyArrayObject * tmp = (PyArrayObject*) py_V195;\n12470\t                PyErr_Format(PyExc_NotImplementedError,\n12471\t                             \"expected an aligned array of type %ld \"\n12472\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n12473\t                             \" with %ld dimensions, with 3 last dims \"\n12474\t                             \"%ld, %ld, %ld\"\n12475\t                             \" and 3 last strides %ld %ld, %ld.\",\n12476\t                             (long int) NPY_FLOAT64,\n12477\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V195),\n12478\t                             (long int) PyArray_NDIM(tmp),\n12479\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n12480\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n12481\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n12482\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n12483\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n12484\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n12485\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n12486\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n12487\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n12488\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n12489\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n12490\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n12491\t            );\n12492\t                {\n12493\t        __failure = 196;\n12494\t        if (!PyErr_Occurred()) {\n12495\t            PyErr_SetString(PyExc_RuntimeError,\n12496\t                \"Unexpected error in an Op's C code. \"\n12497\t                \"No Python exception was set.\");\n12498\t            }\n12499\t        goto __label_196;}\n12500\t            }\n12501\t            // This is a TypeError to be consistent with DEBUG_MODE\n12502\t            // Note: DEBUG_MODE also tells the name of the container\n12503\t            if (PyArray_TYPE((PyArrayObject*) py_V195) != NPY_FLOAT64) {\n12504\t                PyErr_Format(PyExc_TypeError,\n12505\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n12506\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V195));\n12507\t                {\n12508\t        __failure = 196;\n12509\t        if (!PyErr_Occurred()) {\n12510\t            PyErr_SetString(PyExc_RuntimeError,\n12511\t                \"Unexpected error in an Op's C code. \"\n12512\t                \"No Python exception was set.\");\n12513\t            }\n12514\t        goto __label_196;}\n12515\t            }\n12516\t            \n12517\t        V195 = (PyArrayObject*)(py_V195);\n12518\t        Py_XINCREF(V195);\n12519\t        \n12520\t{\n12521\t\n12522\t    py_V197 = PyList_GET_ITEM(storage_V197, 0);\n12523\t    {Py_XINCREF(py_V197);}\n12524\t    \n12525\t            V197 = NULL;\n12526\t            if (py_V197 == Py_None) {\n12527\t                // We can either fail here or set V197 to NULL and rely on Ops\n12528\t                // using tensors to handle the NULL case, but if they fail to do so\n12529\t                // they'll end up with nasty segfaults, so this is public service.\n12530\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n12531\t                {\n12532\t        __failure = 198;\n12533\t        if (!PyErr_Occurred()) {\n12534\t            PyErr_SetString(PyExc_RuntimeError,\n12535\t                \"Unexpected error in an Op's C code. \"\n12536\t                \"No Python exception was set.\");\n12537\t            }\n12538\t        goto __label_198;}\n12539\t            }\n12540\t            if (!PyArray_Check(py_V197)) {\n12541\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n12542\t                {\n12543\t        __failure = 198;\n12544\t        if (!PyErr_Occurred()) {\n12545\t            PyErr_SetString(PyExc_RuntimeError,\n12546\t                \"Unexpected error in an Op's C code. \"\n12547\t                \"No Python exception was set.\");\n12548\t            }\n12549\t        goto __label_198;}\n12550\t            }\n12551\t            // We expect NPY_FLOAT64\n12552\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V197)) {\n12553\t                PyArrayObject * tmp = (PyArrayObject*) py_V197;\n12554\t                PyErr_Format(PyExc_NotImplementedError,\n12555\t                             \"expected an aligned array of type %ld \"\n12556\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n12557\t                             \" with %ld dimensions, with 3 last dims \"\n12558\t                             \"%ld, %ld, %ld\"\n12559\t                             \" and 3 last strides %ld %ld, %ld.\",\n12560\t                             (long int) NPY_FLOAT64,\n12561\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V197),\n12562\t                             (long int) PyArray_NDIM(tmp),\n12563\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n12564\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n12565\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n12566\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n12567\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n12568\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n12569\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n12570\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n12571\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n12572\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n12573\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n12574\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n12575\t            );\n12576\t                {\n12577\t        __failure = 198;\n12578\t        if (!PyErr_Occurred()) {\n12579\t            PyErr_SetString(PyExc_RuntimeError,\n12580\t                \"Unexpected error in an Op's C code. \"\n12581\t                \"No Python exception was set.\");\n12582\t            }\n12583\t        goto __label_198;}\n12584\t            }\n12585\t            // This is a TypeError to be consistent with DEBUG_MODE\n12586\t            // Note: DEBUG_MODE also tells the name of the container\n12587\t            if (PyArray_TYPE((PyArrayObject*) py_V197) != NPY_FLOAT64) {\n12588\t                PyErr_Format(PyExc_TypeError,\n12589\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n12590\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V197));\n12591\t                {\n12592\t        __failure = 198;\n12593\t        if (!PyErr_Occurred()) {\n12594\t            PyErr_SetString(PyExc_RuntimeError,\n12595\t                \"Unexpected error in an Op's C code. \"\n12596\t                \"No Python exception was set.\");\n12597\t            }\n12598\t        goto __label_198;}\n12599\t            }\n12600\t            \n12601\t        V197 = (PyArrayObject*)(py_V197);\n12602\t        Py_XINCREF(V197);\n12603\t        \n12604\t{\n12605\t\n12606\t    py_V199 = PyList_GET_ITEM(storage_V199, 0);\n12607\t    {Py_XINCREF(py_V199);}\n12608\t    \n12609\t            V199 = NULL;\n12610\t            if (py_V199 == Py_None) {\n12611\t                // We can either fail here or set V199 to NULL and rely on Ops\n12612\t                // using tensors to handle the NULL case, but if they fail to do so\n12613\t                // they'll end up with nasty segfaults, so this is public service.\n12614\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n12615\t                {\n12616\t        __failure = 200;\n12617\t        if (!PyErr_Occurred()) {\n12618\t            PyErr_SetString(PyExc_RuntimeError,\n12619\t                \"Unexpected error in an Op's C code. \"\n12620\t                \"No Python exception was set.\");\n12621\t            }\n12622\t        goto __label_200;}\n12623\t            }\n12624\t            if (!PyArray_Check(py_V199)) {\n12625\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n12626\t                {\n12627\t        __failure = 200;\n12628\t        if (!PyErr_Occurred()) {\n12629\t            PyErr_SetString(PyExc_RuntimeError,\n12630\t                \"Unexpected error in an Op's C code. \"\n12631\t                \"No Python exception was set.\");\n12632\t            }\n12633\t        goto __label_200;}\n12634\t            }\n12635\t            // We expect NPY_FLOAT64\n12636\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V199)) {\n12637\t                PyArrayObject * tmp = (PyArrayObject*) py_V199;\n12638\t                PyErr_Format(PyExc_NotImplementedError,\n12639\t                             \"expected an aligned array of type %ld \"\n12640\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n12641\t                             \" with %ld dimensions, with 3 last dims \"\n12642\t                             \"%ld, %ld, %ld\"\n12643\t                             \" and 3 last strides %ld %ld, %ld.\",\n12644\t                             (long int) NPY_FLOAT64,\n12645\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V199),\n12646\t                             (long int) PyArray_NDIM(tmp),\n12647\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n12648\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n12649\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n12650\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n12651\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n12652\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n12653\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n12654\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n12655\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n12656\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n12657\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n12658\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n12659\t            );\n12660\t                {\n12661\t        __failure = 200;\n12662\t        if (!PyErr_Occurred()) {\n12663\t            PyErr_SetString(PyExc_RuntimeError,\n12664\t                \"Unexpected error in an Op's C code. \"\n12665\t                \"No Python exception was set.\");\n12666\t            }\n12667\t        goto __label_200;}\n12668\t            }\n12669\t            // This is a TypeError to be consistent with DEBUG_MODE\n12670\t            // Note: DEBUG_MODE also tells the name of the container\n12671\t            if (PyArray_TYPE((PyArrayObject*) py_V199) != NPY_FLOAT64) {\n12672\t                PyErr_Format(PyExc_TypeError,\n12673\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n12674\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V199));\n12675\t                {\n12676\t        __failure = 200;\n12677\t        if (!PyErr_Occurred()) {\n12678\t            PyErr_SetString(PyExc_RuntimeError,\n12679\t                \"Unexpected error in an Op's C code. \"\n12680\t                \"No Python exception was set.\");\n12681\t            }\n12682\t        goto __label_200;}\n12683\t            }\n12684\t            \n12685\t        V199 = (PyArrayObject*)(py_V199);\n12686\t        Py_XINCREF(V199);\n12687\t        \n12688\t{\n12689\t\n12690\t    py_V201 = PyList_GET_ITEM(storage_V201, 0);\n12691\t    {Py_XINCREF(py_V201);}\n12692\t    \n12693\t            V201 = NULL;\n12694\t            if (py_V201 == Py_None) {\n12695\t                // We can either fail here or set V201 to NULL and rely on Ops\n12696\t                // using tensors to handle the NULL case, but if they fail to do so\n12697\t                // they'll end up with nasty segfaults, so this is public service.\n12698\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n12699\t                {\n12700\t        __failure = 202;\n12701\t        if (!PyErr_Occurred()) {\n12702\t            PyErr_SetString(PyExc_RuntimeError,\n12703\t                \"Unexpected error in an Op's C code. \"\n12704\t                \"No Python exception was set.\");\n12705\t            }\n12706\t        goto __label_202;}\n12707\t            }\n12708\t            if (!PyArray_Check(py_V201)) {\n12709\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n12710\t                {\n12711\t        __failure = 202;\n12712\t        if (!PyErr_Occurred()) {\n12713\t            PyErr_SetString(PyExc_RuntimeError,\n12714\t                \"Unexpected error in an Op's C code. \"\n12715\t                \"No Python exception was set.\");\n12716\t            }\n12717\t        goto __label_202;}\n12718\t            }\n12719\t            // We expect NPY_FLOAT64\n12720\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V201)) {\n12721\t                PyArrayObject * tmp = (PyArrayObject*) py_V201;\n12722\t                PyErr_Format(PyExc_NotImplementedError,\n12723\t                             \"expected an aligned array of type %ld \"\n12724\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n12725\t                             \" with %ld dimensions, with 3 last dims \"\n12726\t                             \"%ld, %ld, %ld\"\n12727\t                             \" and 3 last strides %ld %ld, %ld.\",\n12728\t                             (long int) NPY_FLOAT64,\n12729\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V201),\n12730\t                             (long int) PyArray_NDIM(tmp),\n12731\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n12732\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n12733\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n12734\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n12735\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n12736\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n12737\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n12738\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n12739\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n12740\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n12741\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n12742\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n12743\t            );\n12744\t                {\n12745\t        __failure = 202;\n12746\t        if (!PyErr_Occurred()) {\n12747\t            PyErr_SetString(PyExc_RuntimeError,\n12748\t                \"Unexpected error in an Op's C code. \"\n12749\t                \"No Python exception was set.\");\n12750\t            }\n12751\t        goto __label_202;}\n12752\t            }\n12753\t            // This is a TypeError to be consistent with DEBUG_MODE\n12754\t            // Note: DEBUG_MODE also tells the name of the container\n12755\t            if (PyArray_TYPE((PyArrayObject*) py_V201) != NPY_FLOAT64) {\n12756\t                PyErr_Format(PyExc_TypeError,\n12757\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n12758\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V201));\n12759\t                {\n12760\t        __failure = 202;\n12761\t        if (!PyErr_Occurred()) {\n12762\t            PyErr_SetString(PyExc_RuntimeError,\n12763\t                \"Unexpected error in an Op's C code. \"\n12764\t                \"No Python exception was set.\");\n12765\t            }\n12766\t        goto __label_202;}\n12767\t            }\n12768\t            \n12769\t        V201 = (PyArrayObject*)(py_V201);\n12770\t        Py_XINCREF(V201);\n12771\t        \n12772\t{\n12773\t\n12774\t    py_V203 = PyList_GET_ITEM(storage_V203, 0);\n12775\t    {Py_XINCREF(py_V203);}\n12776\t    \n12777\t            V203 = NULL;\n12778\t            if (py_V203 == Py_None) {\n12779\t                // We can either fail here or set V203 to NULL and rely on Ops\n12780\t                // using tensors to handle the NULL case, but if they fail to do so\n12781\t                // they'll end up with nasty segfaults, so this is public service.\n12782\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n12783\t                {\n12784\t        __failure = 204;\n12785\t        if (!PyErr_Occurred()) {\n12786\t            PyErr_SetString(PyExc_RuntimeError,\n12787\t                \"Unexpected error in an Op's C code. \"\n12788\t                \"No Python exception was set.\");\n12789\t            }\n12790\t        goto __label_204;}\n12791\t            }\n12792\t            if (!PyArray_Check(py_V203)) {\n12793\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n12794\t                {\n12795\t        __failure = 204;\n12796\t        if (!PyErr_Occurred()) {\n12797\t            PyErr_SetString(PyExc_RuntimeError,\n12798\t                \"Unexpected error in an Op's C code. \"\n12799\t                \"No Python exception was set.\");\n12800\t            }\n12801\t        goto __label_204;}\n12802\t            }\n12803\t            // We expect NPY_FLOAT64\n12804\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V203)) {\n12805\t                PyArrayObject * tmp = (PyArrayObject*) py_V203;\n12806\t                PyErr_Format(PyExc_NotImplementedError,\n12807\t                             \"expected an aligned array of type %ld \"\n12808\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n12809\t                             \" with %ld dimensions, with 3 last dims \"\n12810\t                             \"%ld, %ld, %ld\"\n12811\t                             \" and 3 last strides %ld %ld, %ld.\",\n12812\t                             (long int) NPY_FLOAT64,\n12813\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V203),\n12814\t                             (long int) PyArray_NDIM(tmp),\n12815\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n12816\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n12817\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n12818\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n12819\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n12820\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n12821\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n12822\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n12823\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n12824\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n12825\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n12826\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n12827\t            );\n12828\t                {\n12829\t        __failure = 204;\n12830\t        if (!PyErr_Occurred()) {\n12831\t            PyErr_SetString(PyExc_RuntimeError,\n12832\t                \"Unexpected error in an Op's C code. \"\n12833\t                \"No Python exception was set.\");\n12834\t            }\n12835\t        goto __label_204;}\n12836\t            }\n12837\t            // This is a TypeError to be consistent with DEBUG_MODE\n12838\t            // Note: DEBUG_MODE also tells the name of the container\n12839\t            if (PyArray_TYPE((PyArrayObject*) py_V203) != NPY_FLOAT64) {\n12840\t                PyErr_Format(PyExc_TypeError,\n12841\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n12842\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V203));\n12843\t                {\n12844\t        __failure = 204;\n12845\t        if (!PyErr_Occurred()) {\n12846\t            PyErr_SetString(PyExc_RuntimeError,\n12847\t                \"Unexpected error in an Op's C code. \"\n12848\t                \"No Python exception was set.\");\n12849\t            }\n12850\t        goto __label_204;}\n12851\t            }\n12852\t            \n12853\t        V203 = (PyArrayObject*)(py_V203);\n12854\t        Py_XINCREF(V203);\n12855\t        \n12856\t{\n12857\t\n12858\t    py_V205 = PyList_GET_ITEM(storage_V205, 0);\n12859\t    {Py_XINCREF(py_V205);}\n12860\t    \n12861\t            V205 = NULL;\n12862\t            if (py_V205 == Py_None) {\n12863\t                // We can either fail here or set V205 to NULL and rely on Ops\n12864\t                // using tensors to handle the NULL case, but if they fail to do so\n12865\t                // they'll end up with nasty segfaults, so this is public service.\n12866\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n12867\t                {\n12868\t        __failure = 206;\n12869\t        if (!PyErr_Occurred()) {\n12870\t            PyErr_SetString(PyExc_RuntimeError,\n12871\t                \"Unexpected error in an Op's C code. \"\n12872\t                \"No Python exception was set.\");\n12873\t            }\n12874\t        goto __label_206;}\n12875\t            }\n12876\t            if (!PyArray_Check(py_V205)) {\n12877\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n12878\t                {\n12879\t        __failure = 206;\n12880\t        if (!PyErr_Occurred()) {\n12881\t            PyErr_SetString(PyExc_RuntimeError,\n12882\t                \"Unexpected error in an Op's C code. \"\n12883\t                \"No Python exception was set.\");\n12884\t            }\n12885\t        goto __label_206;}\n12886\t            }\n12887\t            // We expect NPY_FLOAT64\n12888\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V205)) {\n12889\t                PyArrayObject * tmp = (PyArrayObject*) py_V205;\n12890\t                PyErr_Format(PyExc_NotImplementedError,\n12891\t                             \"expected an aligned array of type %ld \"\n12892\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n12893\t                             \" with %ld dimensions, with 3 last dims \"\n12894\t                             \"%ld, %ld, %ld\"\n12895\t                             \" and 3 last strides %ld %ld, %ld.\",\n12896\t                             (long int) NPY_FLOAT64,\n12897\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V205),\n12898\t                             (long int) PyArray_NDIM(tmp),\n12899\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n12900\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n12901\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n12902\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n12903\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n12904\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n12905\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n12906\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n12907\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n12908\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n12909\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n12910\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n12911\t            );\n12912\t                {\n12913\t        __failure = 206;\n12914\t        if (!PyErr_Occurred()) {\n12915\t            PyErr_SetString(PyExc_RuntimeError,\n12916\t                \"Unexpected error in an Op's C code. \"\n12917\t                \"No Python exception was set.\");\n12918\t            }\n12919\t        goto __label_206;}\n12920\t            }\n12921\t            // This is a TypeError to be consistent with DEBUG_MODE\n12922\t            // Note: DEBUG_MODE also tells the name of the container\n12923\t            if (PyArray_TYPE((PyArrayObject*) py_V205) != NPY_FLOAT64) {\n12924\t                PyErr_Format(PyExc_TypeError,\n12925\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n12926\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V205));\n12927\t                {\n12928\t        __failure = 206;\n12929\t        if (!PyErr_Occurred()) {\n12930\t            PyErr_SetString(PyExc_RuntimeError,\n12931\t                \"Unexpected error in an Op's C code. \"\n12932\t                \"No Python exception was set.\");\n12933\t            }\n12934\t        goto __label_206;}\n12935\t            }\n12936\t            \n12937\t        V205 = (PyArrayObject*)(py_V205);\n12938\t        Py_XINCREF(V205);\n12939\t        \n12940\t{\n12941\t\n12942\t    py_V207 = PyList_GET_ITEM(storage_V207, 0);\n12943\t    {Py_XINCREF(py_V207);}\n12944\t    \n12945\t            V207 = NULL;\n12946\t            if (py_V207 == Py_None) {\n12947\t                // We can either fail here or set V207 to NULL and rely on Ops\n12948\t                // using tensors to handle the NULL case, but if they fail to do so\n12949\t                // they'll end up with nasty segfaults, so this is public service.\n12950\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n12951\t                {\n12952\t        __failure = 208;\n12953\t        if (!PyErr_Occurred()) {\n12954\t            PyErr_SetString(PyExc_RuntimeError,\n12955\t                \"Unexpected error in an Op's C code. \"\n12956\t                \"No Python exception was set.\");\n12957\t            }\n12958\t        goto __label_208;}\n12959\t            }\n12960\t            if (!PyArray_Check(py_V207)) {\n12961\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n12962\t                {\n12963\t        __failure = 208;\n12964\t        if (!PyErr_Occurred()) {\n12965\t            PyErr_SetString(PyExc_RuntimeError,\n12966\t                \"Unexpected error in an Op's C code. \"\n12967\t                \"No Python exception was set.\");\n12968\t            }\n12969\t        goto __label_208;}\n12970\t            }\n12971\t            // We expect NPY_FLOAT64\n12972\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V207)) {\n12973\t                PyArrayObject * tmp = (PyArrayObject*) py_V207;\n12974\t                PyErr_Format(PyExc_NotImplementedError,\n12975\t                             \"expected an aligned array of type %ld \"\n12976\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n12977\t                             \" with %ld dimensions, with 3 last dims \"\n12978\t                             \"%ld, %ld, %ld\"\n12979\t                             \" and 3 last strides %ld %ld, %ld.\",\n12980\t                             (long int) NPY_FLOAT64,\n12981\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V207),\n12982\t                             (long int) PyArray_NDIM(tmp),\n12983\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n12984\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n12985\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n12986\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n12987\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n12988\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n12989\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n12990\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n12991\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n12992\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n12993\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n12994\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n12995\t            );\n12996\t                {\n12997\t        __failure = 208;\n12998\t        if (!PyErr_Occurred()) {\n12999\t            PyErr_SetString(PyExc_RuntimeError,\n13000\t                \"Unexpected error in an Op's C code. \"\n13001\t                \"No Python exception was set.\");\n13002\t            }\n13003\t        goto __label_208;}\n13004\t            }\n13005\t            // This is a TypeError to be consistent with DEBUG_MODE\n13006\t            // Note: DEBUG_MODE also tells the name of the container\n13007\t            if (PyArray_TYPE((PyArrayObject*) py_V207) != NPY_FLOAT64) {\n13008\t                PyErr_Format(PyExc_TypeError,\n13009\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n13010\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V207));\n13011\t                {\n13012\t        __failure = 208;\n13013\t        if (!PyErr_Occurred()) {\n13014\t            PyErr_SetString(PyExc_RuntimeError,\n13015\t                \"Unexpected error in an Op's C code. \"\n13016\t                \"No Python exception was set.\");\n13017\t            }\n13018\t        goto __label_208;}\n13019\t            }\n13020\t            \n13021\t        V207 = (PyArrayObject*)(py_V207);\n13022\t        Py_XINCREF(V207);\n13023\t        \n13024\t{\n13025\t\n13026\t    py_V209 = PyList_GET_ITEM(storage_V209, 0);\n13027\t    {Py_XINCREF(py_V209);}\n13028\t    \n13029\t            V209 = NULL;\n13030\t            if (py_V209 == Py_None) {\n13031\t                // We can either fail here or set V209 to NULL and rely on Ops\n13032\t                // using tensors to handle the NULL case, but if they fail to do so\n13033\t                // they'll end up with nasty segfaults, so this is public service.\n13034\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n13035\t                {\n13036\t        __failure = 210;\n13037\t        if (!PyErr_Occurred()) {\n13038\t            PyErr_SetString(PyExc_RuntimeError,\n13039\t                \"Unexpected error in an Op's C code. \"\n13040\t                \"No Python exception was set.\");\n13041\t            }\n13042\t        goto __label_210;}\n13043\t            }\n13044\t            if (!PyArray_Check(py_V209)) {\n13045\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n13046\t                {\n13047\t        __failure = 210;\n13048\t        if (!PyErr_Occurred()) {\n13049\t            PyErr_SetString(PyExc_RuntimeError,\n13050\t                \"Unexpected error in an Op's C code. \"\n13051\t                \"No Python exception was set.\");\n13052\t            }\n13053\t        goto __label_210;}\n13054\t            }\n13055\t            // We expect NPY_FLOAT64\n13056\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V209)) {\n13057\t                PyArrayObject * tmp = (PyArrayObject*) py_V209;\n13058\t                PyErr_Format(PyExc_NotImplementedError,\n13059\t                             \"expected an aligned array of type %ld \"\n13060\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n13061\t                             \" with %ld dimensions, with 3 last dims \"\n13062\t                             \"%ld, %ld, %ld\"\n13063\t                             \" and 3 last strides %ld %ld, %ld.\",\n13064\t                             (long int) NPY_FLOAT64,\n13065\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V209),\n13066\t                             (long int) PyArray_NDIM(tmp),\n13067\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n13068\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n13069\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n13070\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n13071\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n13072\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n13073\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n13074\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n13075\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n13076\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n13077\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n13078\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n13079\t            );\n13080\t                {\n13081\t        __failure = 210;\n13082\t        if (!PyErr_Occurred()) {\n13083\t            PyErr_SetString(PyExc_RuntimeError,\n13084\t                \"Unexpected error in an Op's C code. \"\n13085\t                \"No Python exception was set.\");\n13086\t            }\n13087\t        goto __label_210;}\n13088\t            }\n13089\t            // This is a TypeError to be consistent with DEBUG_MODE\n13090\t            // Note: DEBUG_MODE also tells the name of the container\n13091\t            if (PyArray_TYPE((PyArrayObject*) py_V209) != NPY_FLOAT64) {\n13092\t                PyErr_Format(PyExc_TypeError,\n13093\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n13094\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V209));\n13095\t                {\n13096\t        __failure = 210;\n13097\t        if (!PyErr_Occurred()) {\n13098\t            PyErr_SetString(PyExc_RuntimeError,\n13099\t                \"Unexpected error in an Op's C code. \"\n13100\t                \"No Python exception was set.\");\n13101\t            }\n13102\t        goto __label_210;}\n13103\t            }\n13104\t            \n13105\t        V209 = (PyArrayObject*)(py_V209);\n13106\t        Py_XINCREF(V209);\n13107\t        \n13108\t{\n13109\t\n13110\t    py_V211 = PyList_GET_ITEM(storage_V211, 0);\n13111\t    {Py_XINCREF(py_V211);}\n13112\t    \n13113\t            V211 = NULL;\n13114\t            if (py_V211 == Py_None) {\n13115\t                // We can either fail here or set V211 to NULL and rely on Ops\n13116\t                // using tensors to handle the NULL case, but if they fail to do so\n13117\t                // they'll end up with nasty segfaults, so this is public service.\n13118\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n13119\t                {\n13120\t        __failure = 212;\n13121\t        if (!PyErr_Occurred()) {\n13122\t            PyErr_SetString(PyExc_RuntimeError,\n13123\t                \"Unexpected error in an Op's C code. \"\n13124\t                \"No Python exception was set.\");\n13125\t            }\n13126\t        goto __label_212;}\n13127\t            }\n13128\t            if (!PyArray_Check(py_V211)) {\n13129\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n13130\t                {\n13131\t        __failure = 212;\n13132\t        if (!PyErr_Occurred()) {\n13133\t            PyErr_SetString(PyExc_RuntimeError,\n13134\t                \"Unexpected error in an Op's C code. \"\n13135\t                \"No Python exception was set.\");\n13136\t            }\n13137\t        goto __label_212;}\n13138\t            }\n13139\t            // We expect NPY_FLOAT64\n13140\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V211)) {\n13141\t                PyArrayObject * tmp = (PyArrayObject*) py_V211;\n13142\t                PyErr_Format(PyExc_NotImplementedError,\n13143\t                             \"expected an aligned array of type %ld \"\n13144\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n13145\t                             \" with %ld dimensions, with 3 last dims \"\n13146\t                             \"%ld, %ld, %ld\"\n13147\t                             \" and 3 last strides %ld %ld, %ld.\",\n13148\t                             (long int) NPY_FLOAT64,\n13149\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V211),\n13150\t                             (long int) PyArray_NDIM(tmp),\n13151\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n13152\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n13153\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n13154\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n13155\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n13156\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n13157\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n13158\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n13159\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n13160\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n13161\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n13162\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n13163\t            );\n13164\t                {\n13165\t        __failure = 212;\n13166\t        if (!PyErr_Occurred()) {\n13167\t            PyErr_SetString(PyExc_RuntimeError,\n13168\t                \"Unexpected error in an Op's C code. \"\n13169\t                \"No Python exception was set.\");\n13170\t            }\n13171\t        goto __label_212;}\n13172\t            }\n13173\t            // This is a TypeError to be consistent with DEBUG_MODE\n13174\t            // Note: DEBUG_MODE also tells the name of the container\n13175\t            if (PyArray_TYPE((PyArrayObject*) py_V211) != NPY_FLOAT64) {\n13176\t                PyErr_Format(PyExc_TypeError,\n13177\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n13178\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V211));\n13179\t                {\n13180\t        __failure = 212;\n13181\t        if (!PyErr_Occurred()) {\n13182\t            PyErr_SetString(PyExc_RuntimeError,\n13183\t                \"Unexpected error in an Op's C code. \"\n13184\t                \"No Python exception was set.\");\n13185\t            }\n13186\t        goto __label_212;}\n13187\t            }\n13188\t            \n13189\t        V211 = (PyArrayObject*)(py_V211);\n13190\t        Py_XINCREF(V211);\n13191\t        \n13192\t{\n13193\t\n13194\t    py_V213 = PyList_GET_ITEM(storage_V213, 0);\n13195\t    {Py_XINCREF(py_V213);}\n13196\t    \n13197\t            V213 = NULL;\n13198\t            if (py_V213 == Py_None) {\n13199\t                // We can either fail here or set V213 to NULL and rely on Ops\n13200\t                // using tensors to handle the NULL case, but if they fail to do so\n13201\t                // they'll end up with nasty segfaults, so this is public service.\n13202\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n13203\t                {\n13204\t        __failure = 214;\n13205\t        if (!PyErr_Occurred()) {\n13206\t            PyErr_SetString(PyExc_RuntimeError,\n13207\t                \"Unexpected error in an Op's C code. \"\n13208\t                \"No Python exception was set.\");\n13209\t            }\n13210\t        goto __label_214;}\n13211\t            }\n13212\t            if (!PyArray_Check(py_V213)) {\n13213\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n13214\t                {\n13215\t        __failure = 214;\n13216\t        if (!PyErr_Occurred()) {\n13217\t            PyErr_SetString(PyExc_RuntimeError,\n13218\t                \"Unexpected error in an Op's C code. \"\n13219\t                \"No Python exception was set.\");\n13220\t            }\n13221\t        goto __label_214;}\n13222\t            }\n13223\t            // We expect NPY_FLOAT64\n13224\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V213)) {\n13225\t                PyArrayObject * tmp = (PyArrayObject*) py_V213;\n13226\t                PyErr_Format(PyExc_NotImplementedError,\n13227\t                             \"expected an aligned array of type %ld \"\n13228\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n13229\t                             \" with %ld dimensions, with 3 last dims \"\n13230\t                             \"%ld, %ld, %ld\"\n13231\t                             \" and 3 last strides %ld %ld, %ld.\",\n13232\t                             (long int) NPY_FLOAT64,\n13233\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V213),\n13234\t                             (long int) PyArray_NDIM(tmp),\n13235\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n13236\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n13237\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n13238\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n13239\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n13240\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n13241\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n13242\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n13243\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n13244\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n13245\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n13246\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n13247\t            );\n13248\t                {\n13249\t        __failure = 214;\n13250\t        if (!PyErr_Occurred()) {\n13251\t            PyErr_SetString(PyExc_RuntimeError,\n13252\t                \"Unexpected error in an Op's C code. \"\n13253\t                \"No Python exception was set.\");\n13254\t            }\n13255\t        goto __label_214;}\n13256\t            }\n13257\t            // This is a TypeError to be consistent with DEBUG_MODE\n13258\t            // Note: DEBUG_MODE also tells the name of the container\n13259\t            if (PyArray_TYPE((PyArrayObject*) py_V213) != NPY_FLOAT64) {\n13260\t                PyErr_Format(PyExc_TypeError,\n13261\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n13262\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V213));\n13263\t                {\n13264\t        __failure = 214;\n13265\t        if (!PyErr_Occurred()) {\n13266\t            PyErr_SetString(PyExc_RuntimeError,\n13267\t                \"Unexpected error in an Op's C code. \"\n13268\t                \"No Python exception was set.\");\n13269\t            }\n13270\t        goto __label_214;}\n13271\t            }\n13272\t            \n13273\t        V213 = (PyArrayObject*)(py_V213);\n13274\t        Py_XINCREF(V213);\n13275\t        \n13276\t{\n13277\t\n13278\t    py_V215 = PyList_GET_ITEM(storage_V215, 0);\n13279\t    {Py_XINCREF(py_V215);}\n13280\t    \n13281\t            V215 = NULL;\n13282\t            if (py_V215 == Py_None) {\n13283\t                // We can either fail here or set V215 to NULL and rely on Ops\n13284\t                // using tensors to handle the NULL case, but if they fail to do so\n13285\t                // they'll end up with nasty segfaults, so this is public service.\n13286\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n13287\t                {\n13288\t        __failure = 216;\n13289\t        if (!PyErr_Occurred()) {\n13290\t            PyErr_SetString(PyExc_RuntimeError,\n13291\t                \"Unexpected error in an Op's C code. \"\n13292\t                \"No Python exception was set.\");\n13293\t            }\n13294\t        goto __label_216;}\n13295\t            }\n13296\t            if (!PyArray_Check(py_V215)) {\n13297\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n13298\t                {\n13299\t        __failure = 216;\n13300\t        if (!PyErr_Occurred()) {\n13301\t            PyErr_SetString(PyExc_RuntimeError,\n13302\t                \"Unexpected error in an Op's C code. \"\n13303\t                \"No Python exception was set.\");\n13304\t            }\n13305\t        goto __label_216;}\n13306\t            }\n13307\t            // We expect NPY_FLOAT64\n13308\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V215)) {\n13309\t                PyArrayObject * tmp = (PyArrayObject*) py_V215;\n13310\t                PyErr_Format(PyExc_NotImplementedError,\n13311\t                             \"expected an aligned array of type %ld \"\n13312\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n13313\t                             \" with %ld dimensions, with 3 last dims \"\n13314\t                             \"%ld, %ld, %ld\"\n13315\t                             \" and 3 last strides %ld %ld, %ld.\",\n13316\t                             (long int) NPY_FLOAT64,\n13317\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V215),\n13318\t                             (long int) PyArray_NDIM(tmp),\n13319\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n13320\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n13321\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n13322\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n13323\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n13324\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n13325\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n13326\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n13327\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n13328\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n13329\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n13330\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n13331\t            );\n13332\t                {\n13333\t        __failure = 216;\n13334\t        if (!PyErr_Occurred()) {\n13335\t            PyErr_SetString(PyExc_RuntimeError,\n13336\t                \"Unexpected error in an Op's C code. \"\n13337\t                \"No Python exception was set.\");\n13338\t            }\n13339\t        goto __label_216;}\n13340\t            }\n13341\t            // This is a TypeError to be consistent with DEBUG_MODE\n13342\t            // Note: DEBUG_MODE also tells the name of the container\n13343\t            if (PyArray_TYPE((PyArrayObject*) py_V215) != NPY_FLOAT64) {\n13344\t                PyErr_Format(PyExc_TypeError,\n13345\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n13346\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V215));\n13347\t                {\n13348\t        __failure = 216;\n13349\t        if (!PyErr_Occurred()) {\n13350\t            PyErr_SetString(PyExc_RuntimeError,\n13351\t                \"Unexpected error in an Op's C code. \"\n13352\t                \"No Python exception was set.\");\n13353\t            }\n13354\t        goto __label_216;}\n13355\t            }\n13356\t            \n13357\t        V215 = (PyArrayObject*)(py_V215);\n13358\t        Py_XINCREF(V215);\n13359\t        \n13360\t{\n13361\t\n13362\t    py_V217 = PyList_GET_ITEM(storage_V217, 0);\n13363\t    {Py_XINCREF(py_V217);}\n13364\t    \n13365\t            V217 = NULL;\n13366\t            if (py_V217 == Py_None) {\n13367\t                // We can either fail here or set V217 to NULL and rely on Ops\n13368\t                // using tensors to handle the NULL case, but if they fail to do so\n13369\t                // they'll end up with nasty segfaults, so this is public service.\n13370\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n13371\t                {\n13372\t        __failure = 218;\n13373\t        if (!PyErr_Occurred()) {\n13374\t            PyErr_SetString(PyExc_RuntimeError,\n13375\t                \"Unexpected error in an Op's C code. \"\n13376\t                \"No Python exception was set.\");\n13377\t            }\n13378\t        goto __label_218;}\n13379\t            }\n13380\t            if (!PyArray_Check(py_V217)) {\n13381\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n13382\t                {\n13383\t        __failure = 218;\n13384\t        if (!PyErr_Occurred()) {\n13385\t            PyErr_SetString(PyExc_RuntimeError,\n13386\t                \"Unexpected error in an Op's C code. \"\n13387\t                \"No Python exception was set.\");\n13388\t            }\n13389\t        goto __label_218;}\n13390\t            }\n13391\t            // We expect NPY_FLOAT64\n13392\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V217)) {\n13393\t                PyArrayObject * tmp = (PyArrayObject*) py_V217;\n13394\t                PyErr_Format(PyExc_NotImplementedError,\n13395\t                             \"expected an aligned array of type %ld \"\n13396\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n13397\t                             \" with %ld dimensions, with 3 last dims \"\n13398\t                             \"%ld, %ld, %ld\"\n13399\t                             \" and 3 last strides %ld %ld, %ld.\",\n13400\t                             (long int) NPY_FLOAT64,\n13401\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V217),\n13402\t                             (long int) PyArray_NDIM(tmp),\n13403\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n13404\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n13405\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n13406\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n13407\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n13408\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n13409\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n13410\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n13411\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n13412\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n13413\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n13414\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n13415\t            );\n13416\t                {\n13417\t        __failure = 218;\n13418\t        if (!PyErr_Occurred()) {\n13419\t            PyErr_SetString(PyExc_RuntimeError,\n13420\t                \"Unexpected error in an Op's C code. \"\n13421\t                \"No Python exception was set.\");\n13422\t            }\n13423\t        goto __label_218;}\n13424\t            }\n13425\t            // This is a TypeError to be consistent with DEBUG_MODE\n13426\t            // Note: DEBUG_MODE also tells the name of the container\n13427\t            if (PyArray_TYPE((PyArrayObject*) py_V217) != NPY_FLOAT64) {\n13428\t                PyErr_Format(PyExc_TypeError,\n13429\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n13430\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V217));\n13431\t                {\n13432\t        __failure = 218;\n13433\t        if (!PyErr_Occurred()) {\n13434\t            PyErr_SetString(PyExc_RuntimeError,\n13435\t                \"Unexpected error in an Op's C code. \"\n13436\t                \"No Python exception was set.\");\n13437\t            }\n13438\t        goto __label_218;}\n13439\t            }\n13440\t            \n13441\t        V217 = (PyArrayObject*)(py_V217);\n13442\t        Py_XINCREF(V217);\n13443\t        \n13444\t{\n13445\t\n13446\t    py_V219 = PyList_GET_ITEM(storage_V219, 0);\n13447\t    {Py_XINCREF(py_V219);}\n13448\t    \n13449\t            V219 = NULL;\n13450\t            if (py_V219 == Py_None) {\n13451\t                // We can either fail here or set V219 to NULL and rely on Ops\n13452\t                // using tensors to handle the NULL case, but if they fail to do so\n13453\t                // they'll end up with nasty segfaults, so this is public service.\n13454\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n13455\t                {\n13456\t        __failure = 220;\n13457\t        if (!PyErr_Occurred()) {\n13458\t            PyErr_SetString(PyExc_RuntimeError,\n13459\t                \"Unexpected error in an Op's C code. \"\n13460\t                \"No Python exception was set.\");\n13461\t            }\n13462\t        goto __label_220;}\n13463\t            }\n13464\t            if (!PyArray_Check(py_V219)) {\n13465\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n13466\t                {\n13467\t        __failure = 220;\n13468\t        if (!PyErr_Occurred()) {\n13469\t            PyErr_SetString(PyExc_RuntimeError,\n13470\t                \"Unexpected error in an Op's C code. \"\n13471\t                \"No Python exception was set.\");\n13472\t            }\n13473\t        goto __label_220;}\n13474\t            }\n13475\t            // We expect NPY_FLOAT64\n13476\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V219)) {\n13477\t                PyArrayObject * tmp = (PyArrayObject*) py_V219;\n13478\t                PyErr_Format(PyExc_NotImplementedError,\n13479\t                             \"expected an aligned array of type %ld \"\n13480\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n13481\t                             \" with %ld dimensions, with 3 last dims \"\n13482\t                             \"%ld, %ld, %ld\"\n13483\t                             \" and 3 last strides %ld %ld, %ld.\",\n13484\t                             (long int) NPY_FLOAT64,\n13485\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V219),\n13486\t                             (long int) PyArray_NDIM(tmp),\n13487\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n13488\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n13489\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n13490\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n13491\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n13492\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n13493\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n13494\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n13495\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n13496\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n13497\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n13498\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n13499\t            );\n13500\t                {\n13501\t        __failure = 220;\n13502\t        if (!PyErr_Occurred()) {\n13503\t            PyErr_SetString(PyExc_RuntimeError,\n13504\t                \"Unexpected error in an Op's C code. \"\n13505\t                \"No Python exception was set.\");\n13506\t            }\n13507\t        goto __label_220;}\n13508\t            }\n13509\t            // This is a TypeError to be consistent with DEBUG_MODE\n13510\t            // Note: DEBUG_MODE also tells the name of the container\n13511\t            if (PyArray_TYPE((PyArrayObject*) py_V219) != NPY_FLOAT64) {\n13512\t                PyErr_Format(PyExc_TypeError,\n13513\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n13514\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V219));\n13515\t                {\n13516\t        __failure = 220;\n13517\t        if (!PyErr_Occurred()) {\n13518\t            PyErr_SetString(PyExc_RuntimeError,\n13519\t                \"Unexpected error in an Op's C code. \"\n13520\t                \"No Python exception was set.\");\n13521\t            }\n13522\t        goto __label_220;}\n13523\t            }\n13524\t            \n13525\t        V219 = (PyArrayObject*)(py_V219);\n13526\t        Py_XINCREF(V219);\n13527\t        \n13528\t{\n13529\t\n13530\t    py_V221 = PyList_GET_ITEM(storage_V221, 0);\n13531\t    {Py_XINCREF(py_V221);}\n13532\t    \n13533\t            V221 = NULL;\n13534\t            if (py_V221 == Py_None) {\n13535\t                // We can either fail here or set V221 to NULL and rely on Ops\n13536\t                // using tensors to handle the NULL case, but if they fail to do so\n13537\t                // they'll end up with nasty segfaults, so this is public service.\n13538\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n13539\t                {\n13540\t        __failure = 222;\n13541\t        if (!PyErr_Occurred()) {\n13542\t            PyErr_SetString(PyExc_RuntimeError,\n13543\t                \"Unexpected error in an Op's C code. \"\n13544\t                \"No Python exception was set.\");\n13545\t            }\n13546\t        goto __label_222;}\n13547\t            }\n13548\t            if (!PyArray_Check(py_V221)) {\n13549\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n13550\t                {\n13551\t        __failure = 222;\n13552\t        if (!PyErr_Occurred()) {\n13553\t            PyErr_SetString(PyExc_RuntimeError,\n13554\t                \"Unexpected error in an Op's C code. \"\n13555\t                \"No Python exception was set.\");\n13556\t            }\n13557\t        goto __label_222;}\n13558\t            }\n13559\t            // We expect NPY_FLOAT64\n13560\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V221)) {\n13561\t                PyArrayObject * tmp = (PyArrayObject*) py_V221;\n13562\t                PyErr_Format(PyExc_NotImplementedError,\n13563\t                             \"expected an aligned array of type %ld \"\n13564\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n13565\t                             \" with %ld dimensions, with 3 last dims \"\n13566\t                             \"%ld, %ld, %ld\"\n13567\t                             \" and 3 last strides %ld %ld, %ld.\",\n13568\t                             (long int) NPY_FLOAT64,\n13569\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V221),\n13570\t                             (long int) PyArray_NDIM(tmp),\n13571\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n13572\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n13573\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n13574\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n13575\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n13576\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n13577\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n13578\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n13579\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n13580\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n13581\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n13582\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n13583\t            );\n13584\t                {\n13585\t        __failure = 222;\n13586\t        if (!PyErr_Occurred()) {\n13587\t            PyErr_SetString(PyExc_RuntimeError,\n13588\t                \"Unexpected error in an Op's C code. \"\n13589\t                \"No Python exception was set.\");\n13590\t            }\n13591\t        goto __label_222;}\n13592\t            }\n13593\t            // This is a TypeError to be consistent with DEBUG_MODE\n13594\t            // Note: DEBUG_MODE also tells the name of the container\n13595\t            if (PyArray_TYPE((PyArrayObject*) py_V221) != NPY_FLOAT64) {\n13596\t                PyErr_Format(PyExc_TypeError,\n13597\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n13598\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V221));\n13599\t                {\n13600\t        __failure = 222;\n13601\t        if (!PyErr_Occurred()) {\n13602\t            PyErr_SetString(PyExc_RuntimeError,\n13603\t                \"Unexpected error in an Op's C code. \"\n13604\t                \"No Python exception was set.\");\n13605\t            }\n13606\t        goto __label_222;}\n13607\t            }\n13608\t            \n13609\t        V221 = (PyArrayObject*)(py_V221);\n13610\t        Py_XINCREF(V221);\n13611\t        \n13612\t{\n13613\t\n13614\t    py_V223 = PyList_GET_ITEM(storage_V223, 0);\n13615\t    {Py_XINCREF(py_V223);}\n13616\t    \n13617\t            V223 = NULL;\n13618\t            if (py_V223 == Py_None) {\n13619\t                // We can either fail here or set V223 to NULL and rely on Ops\n13620\t                // using tensors to handle the NULL case, but if they fail to do so\n13621\t                // they'll end up with nasty segfaults, so this is public service.\n13622\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n13623\t                {\n13624\t        __failure = 224;\n13625\t        if (!PyErr_Occurred()) {\n13626\t            PyErr_SetString(PyExc_RuntimeError,\n13627\t                \"Unexpected error in an Op's C code. \"\n13628\t                \"No Python exception was set.\");\n13629\t            }\n13630\t        goto __label_224;}\n13631\t            }\n13632\t            if (!PyArray_Check(py_V223)) {\n13633\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n13634\t                {\n13635\t        __failure = 224;\n13636\t        if (!PyErr_Occurred()) {\n13637\t            PyErr_SetString(PyExc_RuntimeError,\n13638\t                \"Unexpected error in an Op's C code. \"\n13639\t                \"No Python exception was set.\");\n13640\t            }\n13641\t        goto __label_224;}\n13642\t            }\n13643\t            // We expect NPY_FLOAT64\n13644\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V223)) {\n13645\t                PyArrayObject * tmp = (PyArrayObject*) py_V223;\n13646\t                PyErr_Format(PyExc_NotImplementedError,\n13647\t                             \"expected an aligned array of type %ld \"\n13648\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n13649\t                             \" with %ld dimensions, with 3 last dims \"\n13650\t                             \"%ld, %ld, %ld\"\n13651\t                             \" and 3 last strides %ld %ld, %ld.\",\n13652\t                             (long int) NPY_FLOAT64,\n13653\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V223),\n13654\t                             (long int) PyArray_NDIM(tmp),\n13655\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n13656\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n13657\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n13658\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n13659\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n13660\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n13661\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n13662\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n13663\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n13664\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n13665\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n13666\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n13667\t            );\n13668\t                {\n13669\t        __failure = 224;\n13670\t        if (!PyErr_Occurred()) {\n13671\t            PyErr_SetString(PyExc_RuntimeError,\n13672\t                \"Unexpected error in an Op's C code. \"\n13673\t                \"No Python exception was set.\");\n13674\t            }\n13675\t        goto __label_224;}\n13676\t            }\n13677\t            // This is a TypeError to be consistent with DEBUG_MODE\n13678\t            // Note: DEBUG_MODE also tells the name of the container\n13679\t            if (PyArray_TYPE((PyArrayObject*) py_V223) != NPY_FLOAT64) {\n13680\t                PyErr_Format(PyExc_TypeError,\n13681\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n13682\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V223));\n13683\t                {\n13684\t        __failure = 224;\n13685\t        if (!PyErr_Occurred()) {\n13686\t            PyErr_SetString(PyExc_RuntimeError,\n13687\t                \"Unexpected error in an Op's C code. \"\n13688\t                \"No Python exception was set.\");\n13689\t            }\n13690\t        goto __label_224;}\n13691\t            }\n13692\t            \n13693\t        V223 = (PyArrayObject*)(py_V223);\n13694\t        Py_XINCREF(V223);\n13695\t        \n13696\t{\n13697\t\n13698\t    py_V225 = PyList_GET_ITEM(storage_V225, 0);\n13699\t    {Py_XINCREF(py_V225);}\n13700\t    \n13701\t            V225 = NULL;\n13702\t            if (py_V225 == Py_None) {\n13703\t                // We can either fail here or set V225 to NULL and rely on Ops\n13704\t                // using tensors to handle the NULL case, but if they fail to do so\n13705\t                // they'll end up with nasty segfaults, so this is public service.\n13706\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n13707\t                {\n13708\t        __failure = 226;\n13709\t        if (!PyErr_Occurred()) {\n13710\t            PyErr_SetString(PyExc_RuntimeError,\n13711\t                \"Unexpected error in an Op's C code. \"\n13712\t                \"No Python exception was set.\");\n13713\t            }\n13714\t        goto __label_226;}\n13715\t            }\n13716\t            if (!PyArray_Check(py_V225)) {\n13717\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n13718\t                {\n13719\t        __failure = 226;\n13720\t        if (!PyErr_Occurred()) {\n13721\t            PyErr_SetString(PyExc_RuntimeError,\n13722\t                \"Unexpected error in an Op's C code. \"\n13723\t                \"No Python exception was set.\");\n13724\t            }\n13725\t        goto __label_226;}\n13726\t            }\n13727\t            // We expect NPY_FLOAT64\n13728\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V225)) {\n13729\t                PyArrayObject * tmp = (PyArrayObject*) py_V225;\n13730\t                PyErr_Format(PyExc_NotImplementedError,\n13731\t                             \"expected an aligned array of type %ld \"\n13732\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n13733\t                             \" with %ld dimensions, with 3 last dims \"\n13734\t                             \"%ld, %ld, %ld\"\n13735\t                             \" and 3 last strides %ld %ld, %ld.\",\n13736\t                             (long int) NPY_FLOAT64,\n13737\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V225),\n13738\t                             (long int) PyArray_NDIM(tmp),\n13739\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n13740\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n13741\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n13742\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n13743\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n13744\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n13745\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n13746\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n13747\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n13748\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n13749\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n13750\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n13751\t            );\n13752\t                {\n13753\t        __failure = 226;\n13754\t        if (!PyErr_Occurred()) {\n13755\t            PyErr_SetString(PyExc_RuntimeError,\n13756\t                \"Unexpected error in an Op's C code. \"\n13757\t                \"No Python exception was set.\");\n13758\t            }\n13759\t        goto __label_226;}\n13760\t            }\n13761\t            // This is a TypeError to be consistent with DEBUG_MODE\n13762\t            // Note: DEBUG_MODE also tells the name of the container\n13763\t            if (PyArray_TYPE((PyArrayObject*) py_V225) != NPY_FLOAT64) {\n13764\t                PyErr_Format(PyExc_TypeError,\n13765\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n13766\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V225));\n13767\t                {\n13768\t        __failure = 226;\n13769\t        if (!PyErr_Occurred()) {\n13770\t            PyErr_SetString(PyExc_RuntimeError,\n13771\t                \"Unexpected error in an Op's C code. \"\n13772\t                \"No Python exception was set.\");\n13773\t            }\n13774\t        goto __label_226;}\n13775\t            }\n13776\t            \n13777\t        V225 = (PyArrayObject*)(py_V225);\n13778\t        Py_XINCREF(V225);\n13779\t        \n13780\t{\n13781\t\n13782\t    py_V227 = PyList_GET_ITEM(storage_V227, 0);\n13783\t    {Py_XINCREF(py_V227);}\n13784\t    \n13785\t            V227 = NULL;\n13786\t            if (py_V227 == Py_None) {\n13787\t                // We can either fail here or set V227 to NULL and rely on Ops\n13788\t                // using tensors to handle the NULL case, but if they fail to do so\n13789\t                // they'll end up with nasty segfaults, so this is public service.\n13790\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n13791\t                {\n13792\t        __failure = 228;\n13793\t        if (!PyErr_Occurred()) {\n13794\t            PyErr_SetString(PyExc_RuntimeError,\n13795\t                \"Unexpected error in an Op's C code. \"\n13796\t                \"No Python exception was set.\");\n13797\t            }\n13798\t        goto __label_228;}\n13799\t            }\n13800\t            if (!PyArray_Check(py_V227)) {\n13801\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n13802\t                {\n13803\t        __failure = 228;\n13804\t        if (!PyErr_Occurred()) {\n13805\t            PyErr_SetString(PyExc_RuntimeError,\n13806\t                \"Unexpected error in an Op's C code. \"\n13807\t                \"No Python exception was set.\");\n13808\t            }\n13809\t        goto __label_228;}\n13810\t            }\n13811\t            // We expect NPY_FLOAT64\n13812\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V227)) {\n13813\t                PyArrayObject * tmp = (PyArrayObject*) py_V227;\n13814\t                PyErr_Format(PyExc_NotImplementedError,\n13815\t                             \"expected an aligned array of type %ld \"\n13816\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n13817\t                             \" with %ld dimensions, with 3 last dims \"\n13818\t                             \"%ld, %ld, %ld\"\n13819\t                             \" and 3 last strides %ld %ld, %ld.\",\n13820\t                             (long int) NPY_FLOAT64,\n13821\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V227),\n13822\t                             (long int) PyArray_NDIM(tmp),\n13823\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n13824\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n13825\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n13826\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n13827\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n13828\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n13829\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n13830\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n13831\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n13832\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n13833\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n13834\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n13835\t            );\n13836\t                {\n13837\t        __failure = 228;\n13838\t        if (!PyErr_Occurred()) {\n13839\t            PyErr_SetString(PyExc_RuntimeError,\n13840\t                \"Unexpected error in an Op's C code. \"\n13841\t                \"No Python exception was set.\");\n13842\t            }\n13843\t        goto __label_228;}\n13844\t            }\n13845\t            // This is a TypeError to be consistent with DEBUG_MODE\n13846\t            // Note: DEBUG_MODE also tells the name of the container\n13847\t            if (PyArray_TYPE((PyArrayObject*) py_V227) != NPY_FLOAT64) {\n13848\t                PyErr_Format(PyExc_TypeError,\n13849\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n13850\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V227));\n13851\t                {\n13852\t        __failure = 228;\n13853\t        if (!PyErr_Occurred()) {\n13854\t            PyErr_SetString(PyExc_RuntimeError,\n13855\t                \"Unexpected error in an Op's C code. \"\n13856\t                \"No Python exception was set.\");\n13857\t            }\n13858\t        goto __label_228;}\n13859\t            }\n13860\t            \n13861\t        V227 = (PyArrayObject*)(py_V227);\n13862\t        Py_XINCREF(V227);\n13863\t        \n13864\t{\n13865\t\n13866\t    py_V229 = PyList_GET_ITEM(storage_V229, 0);\n13867\t    {Py_XINCREF(py_V229);}\n13868\t    \n13869\t            V229 = NULL;\n13870\t            if (py_V229 == Py_None) {\n13871\t                // We can either fail here or set V229 to NULL and rely on Ops\n13872\t                // using tensors to handle the NULL case, but if they fail to do so\n13873\t                // they'll end up with nasty segfaults, so this is public service.\n13874\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n13875\t                {\n13876\t        __failure = 230;\n13877\t        if (!PyErr_Occurred()) {\n13878\t            PyErr_SetString(PyExc_RuntimeError,\n13879\t                \"Unexpected error in an Op's C code. \"\n13880\t                \"No Python exception was set.\");\n13881\t            }\n13882\t        goto __label_230;}\n13883\t            }\n13884\t            if (!PyArray_Check(py_V229)) {\n13885\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n13886\t                {\n13887\t        __failure = 230;\n13888\t        if (!PyErr_Occurred()) {\n13889\t            PyErr_SetString(PyExc_RuntimeError,\n13890\t                \"Unexpected error in an Op's C code. \"\n13891\t                \"No Python exception was set.\");\n13892\t            }\n13893\t        goto __label_230;}\n13894\t            }\n13895\t            // We expect NPY_FLOAT64\n13896\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V229)) {\n13897\t                PyArrayObject * tmp = (PyArrayObject*) py_V229;\n13898\t                PyErr_Format(PyExc_NotImplementedError,\n13899\t                             \"expected an aligned array of type %ld \"\n13900\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n13901\t                             \" with %ld dimensions, with 3 last dims \"\n13902\t                             \"%ld, %ld, %ld\"\n13903\t                             \" and 3 last strides %ld %ld, %ld.\",\n13904\t                             (long int) NPY_FLOAT64,\n13905\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V229),\n13906\t                             (long int) PyArray_NDIM(tmp),\n13907\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n13908\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n13909\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n13910\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n13911\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n13912\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n13913\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n13914\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n13915\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n13916\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n13917\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n13918\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n13919\t            );\n13920\t                {\n13921\t        __failure = 230;\n13922\t        if (!PyErr_Occurred()) {\n13923\t            PyErr_SetString(PyExc_RuntimeError,\n13924\t                \"Unexpected error in an Op's C code. \"\n13925\t                \"No Python exception was set.\");\n13926\t            }\n13927\t        goto __label_230;}\n13928\t            }\n13929\t            // This is a TypeError to be consistent with DEBUG_MODE\n13930\t            // Note: DEBUG_MODE also tells the name of the container\n13931\t            if (PyArray_TYPE((PyArrayObject*) py_V229) != NPY_FLOAT64) {\n13932\t                PyErr_Format(PyExc_TypeError,\n13933\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n13934\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V229));\n13935\t                {\n13936\t        __failure = 230;\n13937\t        if (!PyErr_Occurred()) {\n13938\t            PyErr_SetString(PyExc_RuntimeError,\n13939\t                \"Unexpected error in an Op's C code. \"\n13940\t                \"No Python exception was set.\");\n13941\t            }\n13942\t        goto __label_230;}\n13943\t            }\n13944\t            \n13945\t        V229 = (PyArrayObject*)(py_V229);\n13946\t        Py_XINCREF(V229);\n13947\t        \n13948\t{\n13949\t\n13950\t    py_V231 = PyList_GET_ITEM(storage_V231, 0);\n13951\t    {Py_XINCREF(py_V231);}\n13952\t    \n13953\t            V231 = NULL;\n13954\t            if (py_V231 == Py_None) {\n13955\t                // We can either fail here or set V231 to NULL and rely on Ops\n13956\t                // using tensors to handle the NULL case, but if they fail to do so\n13957\t                // they'll end up with nasty segfaults, so this is public service.\n13958\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n13959\t                {\n13960\t        __failure = 232;\n13961\t        if (!PyErr_Occurred()) {\n13962\t            PyErr_SetString(PyExc_RuntimeError,\n13963\t                \"Unexpected error in an Op's C code. \"\n13964\t                \"No Python exception was set.\");\n13965\t            }\n13966\t        goto __label_232;}\n13967\t            }\n13968\t            if (!PyArray_Check(py_V231)) {\n13969\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n13970\t                {\n13971\t        __failure = 232;\n13972\t        if (!PyErr_Occurred()) {\n13973\t            PyErr_SetString(PyExc_RuntimeError,\n13974\t                \"Unexpected error in an Op's C code. \"\n13975\t                \"No Python exception was set.\");\n13976\t            }\n13977\t        goto __label_232;}\n13978\t            }\n13979\t            // We expect NPY_FLOAT64\n13980\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V231)) {\n13981\t                PyArrayObject * tmp = (PyArrayObject*) py_V231;\n13982\t                PyErr_Format(PyExc_NotImplementedError,\n13983\t                             \"expected an aligned array of type %ld \"\n13984\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n13985\t                             \" with %ld dimensions, with 3 last dims \"\n13986\t                             \"%ld, %ld, %ld\"\n13987\t                             \" and 3 last strides %ld %ld, %ld.\",\n13988\t                             (long int) NPY_FLOAT64,\n13989\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V231),\n13990\t                             (long int) PyArray_NDIM(tmp),\n13991\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n13992\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n13993\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n13994\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n13995\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n13996\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n13997\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n13998\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n13999\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n14000\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n14001\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n14002\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n14003\t            );\n14004\t                {\n14005\t        __failure = 232;\n14006\t        if (!PyErr_Occurred()) {\n14007\t            PyErr_SetString(PyExc_RuntimeError,\n14008\t                \"Unexpected error in an Op's C code. \"\n14009\t                \"No Python exception was set.\");\n14010\t            }\n14011\t        goto __label_232;}\n14012\t            }\n14013\t            // This is a TypeError to be consistent with DEBUG_MODE\n14014\t            // Note: DEBUG_MODE also tells the name of the container\n14015\t            if (PyArray_TYPE((PyArrayObject*) py_V231) != NPY_FLOAT64) {\n14016\t                PyErr_Format(PyExc_TypeError,\n14017\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n14018\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V231));\n14019\t                {\n14020\t        __failure = 232;\n14021\t        if (!PyErr_Occurred()) {\n14022\t            PyErr_SetString(PyExc_RuntimeError,\n14023\t                \"Unexpected error in an Op's C code. \"\n14024\t                \"No Python exception was set.\");\n14025\t            }\n14026\t        goto __label_232;}\n14027\t            }\n14028\t            \n14029\t        V231 = (PyArrayObject*)(py_V231);\n14030\t        Py_XINCREF(V231);\n14031\t        \n14032\t{\n14033\t\n14034\t    py_V233 = PyList_GET_ITEM(storage_V233, 0);\n14035\t    {Py_XINCREF(py_V233);}\n14036\t    \n14037\t            V233 = NULL;\n14038\t            if (py_V233 == Py_None) {\n14039\t                // We can either fail here or set V233 to NULL and rely on Ops\n14040\t                // using tensors to handle the NULL case, but if they fail to do so\n14041\t                // they'll end up with nasty segfaults, so this is public service.\n14042\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n14043\t                {\n14044\t        __failure = 234;\n14045\t        if (!PyErr_Occurred()) {\n14046\t            PyErr_SetString(PyExc_RuntimeError,\n14047\t                \"Unexpected error in an Op's C code. \"\n14048\t                \"No Python exception was set.\");\n14049\t            }\n14050\t        goto __label_234;}\n14051\t            }\n14052\t            if (!PyArray_Check(py_V233)) {\n14053\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n14054\t                {\n14055\t        __failure = 234;\n14056\t        if (!PyErr_Occurred()) {\n14057\t            PyErr_SetString(PyExc_RuntimeError,\n14058\t                \"Unexpected error in an Op's C code. \"\n14059\t                \"No Python exception was set.\");\n14060\t            }\n14061\t        goto __label_234;}\n14062\t            }\n14063\t            // We expect NPY_FLOAT64\n14064\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V233)) {\n14065\t                PyArrayObject * tmp = (PyArrayObject*) py_V233;\n14066\t                PyErr_Format(PyExc_NotImplementedError,\n14067\t                             \"expected an aligned array of type %ld \"\n14068\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n14069\t                             \" with %ld dimensions, with 3 last dims \"\n14070\t                             \"%ld, %ld, %ld\"\n14071\t                             \" and 3 last strides %ld %ld, %ld.\",\n14072\t                             (long int) NPY_FLOAT64,\n14073\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V233),\n14074\t                             (long int) PyArray_NDIM(tmp),\n14075\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n14076\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n14077\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n14078\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n14079\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n14080\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n14081\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n14082\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n14083\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n14084\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n14085\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n14086\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n14087\t            );\n14088\t                {\n14089\t        __failure = 234;\n14090\t        if (!PyErr_Occurred()) {\n14091\t            PyErr_SetString(PyExc_RuntimeError,\n14092\t                \"Unexpected error in an Op's C code. \"\n14093\t                \"No Python exception was set.\");\n14094\t            }\n14095\t        goto __label_234;}\n14096\t            }\n14097\t            // This is a TypeError to be consistent with DEBUG_MODE\n14098\t            // Note: DEBUG_MODE also tells the name of the container\n14099\t            if (PyArray_TYPE((PyArrayObject*) py_V233) != NPY_FLOAT64) {\n14100\t                PyErr_Format(PyExc_TypeError,\n14101\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n14102\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V233));\n14103\t                {\n14104\t        __failure = 234;\n14105\t        if (!PyErr_Occurred()) {\n14106\t            PyErr_SetString(PyExc_RuntimeError,\n14107\t                \"Unexpected error in an Op's C code. \"\n14108\t                \"No Python exception was set.\");\n14109\t            }\n14110\t        goto __label_234;}\n14111\t            }\n14112\t            \n14113\t        V233 = (PyArrayObject*)(py_V233);\n14114\t        Py_XINCREF(V233);\n14115\t        \n14116\t{\n14117\t\n14118\t    py_V235 = PyList_GET_ITEM(storage_V235, 0);\n14119\t    {Py_XINCREF(py_V235);}\n14120\t    \n14121\t            V235 = NULL;\n14122\t            if (py_V235 == Py_None) {\n14123\t                // We can either fail here or set V235 to NULL and rely on Ops\n14124\t                // using tensors to handle the NULL case, but if they fail to do so\n14125\t                // they'll end up with nasty segfaults, so this is public service.\n14126\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n14127\t                {\n14128\t        __failure = 236;\n14129\t        if (!PyErr_Occurred()) {\n14130\t            PyErr_SetString(PyExc_RuntimeError,\n14131\t                \"Unexpected error in an Op's C code. \"\n14132\t                \"No Python exception was set.\");\n14133\t            }\n14134\t        goto __label_236;}\n14135\t            }\n14136\t            if (!PyArray_Check(py_V235)) {\n14137\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n14138\t                {\n14139\t        __failure = 236;\n14140\t        if (!PyErr_Occurred()) {\n14141\t            PyErr_SetString(PyExc_RuntimeError,\n14142\t                \"Unexpected error in an Op's C code. \"\n14143\t                \"No Python exception was set.\");\n14144\t            }\n14145\t        goto __label_236;}\n14146\t            }\n14147\t            // We expect NPY_FLOAT64\n14148\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V235)) {\n14149\t                PyArrayObject * tmp = (PyArrayObject*) py_V235;\n14150\t                PyErr_Format(PyExc_NotImplementedError,\n14151\t                             \"expected an aligned array of type %ld \"\n14152\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n14153\t                             \" with %ld dimensions, with 3 last dims \"\n14154\t                             \"%ld, %ld, %ld\"\n14155\t                             \" and 3 last strides %ld %ld, %ld.\",\n14156\t                             (long int) NPY_FLOAT64,\n14157\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V235),\n14158\t                             (long int) PyArray_NDIM(tmp),\n14159\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n14160\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n14161\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n14162\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n14163\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n14164\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n14165\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n14166\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n14167\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n14168\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n14169\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n14170\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n14171\t            );\n14172\t                {\n14173\t        __failure = 236;\n14174\t        if (!PyErr_Occurred()) {\n14175\t            PyErr_SetString(PyExc_RuntimeError,\n14176\t                \"Unexpected error in an Op's C code. \"\n14177\t                \"No Python exception was set.\");\n14178\t            }\n14179\t        goto __label_236;}\n14180\t            }\n14181\t            // This is a TypeError to be consistent with DEBUG_MODE\n14182\t            // Note: DEBUG_MODE also tells the name of the container\n14183\t            if (PyArray_TYPE((PyArrayObject*) py_V235) != NPY_FLOAT64) {\n14184\t                PyErr_Format(PyExc_TypeError,\n14185\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n14186\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V235));\n14187\t                {\n14188\t        __failure = 236;\n14189\t        if (!PyErr_Occurred()) {\n14190\t            PyErr_SetString(PyExc_RuntimeError,\n14191\t                \"Unexpected error in an Op's C code. \"\n14192\t                \"No Python exception was set.\");\n14193\t            }\n14194\t        goto __label_236;}\n14195\t            }\n14196\t            \n14197\t        V235 = (PyArrayObject*)(py_V235);\n14198\t        Py_XINCREF(V235);\n14199\t        \n14200\t{\n14201\t\n14202\t    py_V237 = PyList_GET_ITEM(storage_V237, 0);\n14203\t    {Py_XINCREF(py_V237);}\n14204\t    \n14205\t            V237 = NULL;\n14206\t            if (py_V237 == Py_None) {\n14207\t                // We can either fail here or set V237 to NULL and rely on Ops\n14208\t                // using tensors to handle the NULL case, but if they fail to do so\n14209\t                // they'll end up with nasty segfaults, so this is public service.\n14210\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n14211\t                {\n14212\t        __failure = 238;\n14213\t        if (!PyErr_Occurred()) {\n14214\t            PyErr_SetString(PyExc_RuntimeError,\n14215\t                \"Unexpected error in an Op's C code. \"\n14216\t                \"No Python exception was set.\");\n14217\t            }\n14218\t        goto __label_238;}\n14219\t            }\n14220\t            if (!PyArray_Check(py_V237)) {\n14221\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n14222\t                {\n14223\t        __failure = 238;\n14224\t        if (!PyErr_Occurred()) {\n14225\t            PyErr_SetString(PyExc_RuntimeError,\n14226\t                \"Unexpected error in an Op's C code. \"\n14227\t                \"No Python exception was set.\");\n14228\t            }\n14229\t        goto __label_238;}\n14230\t            }\n14231\t            // We expect NPY_FLOAT64\n14232\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V237)) {\n14233\t                PyArrayObject * tmp = (PyArrayObject*) py_V237;\n14234\t                PyErr_Format(PyExc_NotImplementedError,\n14235\t                             \"expected an aligned array of type %ld \"\n14236\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n14237\t                             \" with %ld dimensions, with 3 last dims \"\n14238\t                             \"%ld, %ld, %ld\"\n14239\t                             \" and 3 last strides %ld %ld, %ld.\",\n14240\t                             (long int) NPY_FLOAT64,\n14241\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V237),\n14242\t                             (long int) PyArray_NDIM(tmp),\n14243\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n14244\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n14245\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n14246\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n14247\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n14248\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n14249\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n14250\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n14251\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n14252\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n14253\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n14254\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n14255\t            );\n14256\t                {\n14257\t        __failure = 238;\n14258\t        if (!PyErr_Occurred()) {\n14259\t            PyErr_SetString(PyExc_RuntimeError,\n14260\t                \"Unexpected error in an Op's C code. \"\n14261\t                \"No Python exception was set.\");\n14262\t            }\n14263\t        goto __label_238;}\n14264\t            }\n14265\t            // This is a TypeError to be consistent with DEBUG_MODE\n14266\t            // Note: DEBUG_MODE also tells the name of the container\n14267\t            if (PyArray_TYPE((PyArrayObject*) py_V237) != NPY_FLOAT64) {\n14268\t                PyErr_Format(PyExc_TypeError,\n14269\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n14270\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V237));\n14271\t                {\n14272\t        __failure = 238;\n14273\t        if (!PyErr_Occurred()) {\n14274\t            PyErr_SetString(PyExc_RuntimeError,\n14275\t                \"Unexpected error in an Op's C code. \"\n14276\t                \"No Python exception was set.\");\n14277\t            }\n14278\t        goto __label_238;}\n14279\t            }\n14280\t            \n14281\t        V237 = (PyArrayObject*)(py_V237);\n14282\t        Py_XINCREF(V237);\n14283\t        \n14284\t{\n14285\t\n14286\t    py_V239 = PyList_GET_ITEM(storage_V239, 0);\n14287\t    {Py_XINCREF(py_V239);}\n14288\t    \n14289\t            V239 = NULL;\n14290\t            if (py_V239 == Py_None) {\n14291\t                // We can either fail here or set V239 to NULL and rely on Ops\n14292\t                // using tensors to handle the NULL case, but if they fail to do so\n14293\t                // they'll end up with nasty segfaults, so this is public service.\n14294\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n14295\t                {\n14296\t        __failure = 240;\n14297\t        if (!PyErr_Occurred()) {\n14298\t            PyErr_SetString(PyExc_RuntimeError,\n14299\t                \"Unexpected error in an Op's C code. \"\n14300\t                \"No Python exception was set.\");\n14301\t            }\n14302\t        goto __label_240;}\n14303\t            }\n14304\t            if (!PyArray_Check(py_V239)) {\n14305\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n14306\t                {\n14307\t        __failure = 240;\n14308\t        if (!PyErr_Occurred()) {\n14309\t            PyErr_SetString(PyExc_RuntimeError,\n14310\t                \"Unexpected error in an Op's C code. \"\n14311\t                \"No Python exception was set.\");\n14312\t            }\n14313\t        goto __label_240;}\n14314\t            }\n14315\t            // We expect NPY_FLOAT64\n14316\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V239)) {\n14317\t                PyArrayObject * tmp = (PyArrayObject*) py_V239;\n14318\t                PyErr_Format(PyExc_NotImplementedError,\n14319\t                             \"expected an aligned array of type %ld \"\n14320\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n14321\t                             \" with %ld dimensions, with 3 last dims \"\n14322\t                             \"%ld, %ld, %ld\"\n14323\t                             \" and 3 last strides %ld %ld, %ld.\",\n14324\t                             (long int) NPY_FLOAT64,\n14325\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V239),\n14326\t                             (long int) PyArray_NDIM(tmp),\n14327\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n14328\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n14329\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n14330\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n14331\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n14332\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n14333\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n14334\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n14335\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n14336\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n14337\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n14338\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n14339\t            );\n14340\t                {\n14341\t        __failure = 240;\n14342\t        if (!PyErr_Occurred()) {\n14343\t            PyErr_SetString(PyExc_RuntimeError,\n14344\t                \"Unexpected error in an Op's C code. \"\n14345\t                \"No Python exception was set.\");\n14346\t            }\n14347\t        goto __label_240;}\n14348\t            }\n14349\t            // This is a TypeError to be consistent with DEBUG_MODE\n14350\t            // Note: DEBUG_MODE also tells the name of the container\n14351\t            if (PyArray_TYPE((PyArrayObject*) py_V239) != NPY_FLOAT64) {\n14352\t                PyErr_Format(PyExc_TypeError,\n14353\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n14354\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V239));\n14355\t                {\n14356\t        __failure = 240;\n14357\t        if (!PyErr_Occurred()) {\n14358\t            PyErr_SetString(PyExc_RuntimeError,\n14359\t                \"Unexpected error in an Op's C code. \"\n14360\t                \"No Python exception was set.\");\n14361\t            }\n14362\t        goto __label_240;}\n14363\t            }\n14364\t            \n14365\t        V239 = (PyArrayObject*)(py_V239);\n14366\t        Py_XINCREF(V239);\n14367\t        \n14368\t{\n14369\t\n14370\t    py_V241 = PyList_GET_ITEM(storage_V241, 0);\n14371\t    {Py_XINCREF(py_V241);}\n14372\t    \n14373\t            V241 = NULL;\n14374\t            if (py_V241 == Py_None) {\n14375\t                // We can either fail here or set V241 to NULL and rely on Ops\n14376\t                // using tensors to handle the NULL case, but if they fail to do so\n14377\t                // they'll end up with nasty segfaults, so this is public service.\n14378\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n14379\t                {\n14380\t        __failure = 242;\n14381\t        if (!PyErr_Occurred()) {\n14382\t            PyErr_SetString(PyExc_RuntimeError,\n14383\t                \"Unexpected error in an Op's C code. \"\n14384\t                \"No Python exception was set.\");\n14385\t            }\n14386\t        goto __label_242;}\n14387\t            }\n14388\t            if (!PyArray_Check(py_V241)) {\n14389\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n14390\t                {\n14391\t        __failure = 242;\n14392\t        if (!PyErr_Occurred()) {\n14393\t            PyErr_SetString(PyExc_RuntimeError,\n14394\t                \"Unexpected error in an Op's C code. \"\n14395\t                \"No Python exception was set.\");\n14396\t            }\n14397\t        goto __label_242;}\n14398\t            }\n14399\t            // We expect NPY_FLOAT64\n14400\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V241)) {\n14401\t                PyArrayObject * tmp = (PyArrayObject*) py_V241;\n14402\t                PyErr_Format(PyExc_NotImplementedError,\n14403\t                             \"expected an aligned array of type %ld \"\n14404\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n14405\t                             \" with %ld dimensions, with 3 last dims \"\n14406\t                             \"%ld, %ld, %ld\"\n14407\t                             \" and 3 last strides %ld %ld, %ld.\",\n14408\t                             (long int) NPY_FLOAT64,\n14409\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V241),\n14410\t                             (long int) PyArray_NDIM(tmp),\n14411\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n14412\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n14413\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n14414\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n14415\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n14416\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n14417\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n14418\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n14419\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n14420\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n14421\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n14422\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n14423\t            );\n14424\t                {\n14425\t        __failure = 242;\n14426\t        if (!PyErr_Occurred()) {\n14427\t            PyErr_SetString(PyExc_RuntimeError,\n14428\t                \"Unexpected error in an Op's C code. \"\n14429\t                \"No Python exception was set.\");\n14430\t            }\n14431\t        goto __label_242;}\n14432\t            }\n14433\t            // This is a TypeError to be consistent with DEBUG_MODE\n14434\t            // Note: DEBUG_MODE also tells the name of the container\n14435\t            if (PyArray_TYPE((PyArrayObject*) py_V241) != NPY_FLOAT64) {\n14436\t                PyErr_Format(PyExc_TypeError,\n14437\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n14438\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V241));\n14439\t                {\n14440\t        __failure = 242;\n14441\t        if (!PyErr_Occurred()) {\n14442\t            PyErr_SetString(PyExc_RuntimeError,\n14443\t                \"Unexpected error in an Op's C code. \"\n14444\t                \"No Python exception was set.\");\n14445\t            }\n14446\t        goto __label_242;}\n14447\t            }\n14448\t            \n14449\t        V241 = (PyArrayObject*)(py_V241);\n14450\t        Py_XINCREF(V241);\n14451\t        \n14452\t{\n14453\t\n14454\t    py_V243 = PyList_GET_ITEM(storage_V243, 0);\n14455\t    {Py_XINCREF(py_V243);}\n14456\t    \n14457\t            V243 = NULL;\n14458\t            if (py_V243 == Py_None) {\n14459\t                // We can either fail here or set V243 to NULL and rely on Ops\n14460\t                // using tensors to handle the NULL case, but if they fail to do so\n14461\t                // they'll end up with nasty segfaults, so this is public service.\n14462\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n14463\t                {\n14464\t        __failure = 244;\n14465\t        if (!PyErr_Occurred()) {\n14466\t            PyErr_SetString(PyExc_RuntimeError,\n14467\t                \"Unexpected error in an Op's C code. \"\n14468\t                \"No Python exception was set.\");\n14469\t            }\n14470\t        goto __label_244;}\n14471\t            }\n14472\t            if (!PyArray_Check(py_V243)) {\n14473\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n14474\t                {\n14475\t        __failure = 244;\n14476\t        if (!PyErr_Occurred()) {\n14477\t            PyErr_SetString(PyExc_RuntimeError,\n14478\t                \"Unexpected error in an Op's C code. \"\n14479\t                \"No Python exception was set.\");\n14480\t            }\n14481\t        goto __label_244;}\n14482\t            }\n14483\t            // We expect NPY_FLOAT64\n14484\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V243)) {\n14485\t                PyArrayObject * tmp = (PyArrayObject*) py_V243;\n14486\t                PyErr_Format(PyExc_NotImplementedError,\n14487\t                             \"expected an aligned array of type %ld \"\n14488\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n14489\t                             \" with %ld dimensions, with 3 last dims \"\n14490\t                             \"%ld, %ld, %ld\"\n14491\t                             \" and 3 last strides %ld %ld, %ld.\",\n14492\t                             (long int) NPY_FLOAT64,\n14493\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V243),\n14494\t                             (long int) PyArray_NDIM(tmp),\n14495\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n14496\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n14497\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n14498\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n14499\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n14500\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n14501\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n14502\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n14503\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n14504\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n14505\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n14506\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n14507\t            );\n14508\t                {\n14509\t        __failure = 244;\n14510\t        if (!PyErr_Occurred()) {\n14511\t            PyErr_SetString(PyExc_RuntimeError,\n14512\t                \"Unexpected error in an Op's C code. \"\n14513\t                \"No Python exception was set.\");\n14514\t            }\n14515\t        goto __label_244;}\n14516\t            }\n14517\t            // This is a TypeError to be consistent with DEBUG_MODE\n14518\t            // Note: DEBUG_MODE also tells the name of the container\n14519\t            if (PyArray_TYPE((PyArrayObject*) py_V243) != NPY_FLOAT64) {\n14520\t                PyErr_Format(PyExc_TypeError,\n14521\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n14522\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V243));\n14523\t                {\n14524\t        __failure = 244;\n14525\t        if (!PyErr_Occurred()) {\n14526\t            PyErr_SetString(PyExc_RuntimeError,\n14527\t                \"Unexpected error in an Op's C code. \"\n14528\t                \"No Python exception was set.\");\n14529\t            }\n14530\t        goto __label_244;}\n14531\t            }\n14532\t            \n14533\t        V243 = (PyArrayObject*)(py_V243);\n14534\t        Py_XINCREF(V243);\n14535\t        \n14536\t{\n14537\t\n14538\t    py_V245 = PyList_GET_ITEM(storage_V245, 0);\n14539\t    {Py_XINCREF(py_V245);}\n14540\t    \n14541\t            V245 = NULL;\n14542\t            if (py_V245 == Py_None) {\n14543\t                // We can either fail here or set V245 to NULL and rely on Ops\n14544\t                // using tensors to handle the NULL case, but if they fail to do so\n14545\t                // they'll end up with nasty segfaults, so this is public service.\n14546\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n14547\t                {\n14548\t        __failure = 246;\n14549\t        if (!PyErr_Occurred()) {\n14550\t            PyErr_SetString(PyExc_RuntimeError,\n14551\t                \"Unexpected error in an Op's C code. \"\n14552\t                \"No Python exception was set.\");\n14553\t            }\n14554\t        goto __label_246;}\n14555\t            }\n14556\t            if (!PyArray_Check(py_V245)) {\n14557\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n14558\t                {\n14559\t        __failure = 246;\n14560\t        if (!PyErr_Occurred()) {\n14561\t            PyErr_SetString(PyExc_RuntimeError,\n14562\t                \"Unexpected error in an Op's C code. \"\n14563\t                \"No Python exception was set.\");\n14564\t            }\n14565\t        goto __label_246;}\n14566\t            }\n14567\t            // We expect NPY_FLOAT64\n14568\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V245)) {\n14569\t                PyArrayObject * tmp = (PyArrayObject*) py_V245;\n14570\t                PyErr_Format(PyExc_NotImplementedError,\n14571\t                             \"expected an aligned array of type %ld \"\n14572\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n14573\t                             \" with %ld dimensions, with 3 last dims \"\n14574\t                             \"%ld, %ld, %ld\"\n14575\t                             \" and 3 last strides %ld %ld, %ld.\",\n14576\t                             (long int) NPY_FLOAT64,\n14577\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V245),\n14578\t                             (long int) PyArray_NDIM(tmp),\n14579\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n14580\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n14581\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n14582\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n14583\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n14584\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n14585\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n14586\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n14587\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n14588\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n14589\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n14590\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n14591\t            );\n14592\t                {\n14593\t        __failure = 246;\n14594\t        if (!PyErr_Occurred()) {\n14595\t            PyErr_SetString(PyExc_RuntimeError,\n14596\t                \"Unexpected error in an Op's C code. \"\n14597\t                \"No Python exception was set.\");\n14598\t            }\n14599\t        goto __label_246;}\n14600\t            }\n14601\t            // This is a TypeError to be consistent with DEBUG_MODE\n14602\t            // Note: DEBUG_MODE also tells the name of the container\n14603\t            if (PyArray_TYPE((PyArrayObject*) py_V245) != NPY_FLOAT64) {\n14604\t                PyErr_Format(PyExc_TypeError,\n14605\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n14606\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V245));\n14607\t                {\n14608\t        __failure = 246;\n14609\t        if (!PyErr_Occurred()) {\n14610\t            PyErr_SetString(PyExc_RuntimeError,\n14611\t                \"Unexpected error in an Op's C code. \"\n14612\t                \"No Python exception was set.\");\n14613\t            }\n14614\t        goto __label_246;}\n14615\t            }\n14616\t            \n14617\t        V245 = (PyArrayObject*)(py_V245);\n14618\t        Py_XINCREF(V245);\n14619\t        \n14620\t{\n14621\t\n14622\t    py_V247 = PyList_GET_ITEM(storage_V247, 0);\n14623\t    {Py_XINCREF(py_V247);}\n14624\t    \n14625\t            V247 = NULL;\n14626\t            if (py_V247 == Py_None) {\n14627\t                // We can either fail here or set V247 to NULL and rely on Ops\n14628\t                // using tensors to handle the NULL case, but if they fail to do so\n14629\t                // they'll end up with nasty segfaults, so this is public service.\n14630\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n14631\t                {\n14632\t        __failure = 248;\n14633\t        if (!PyErr_Occurred()) {\n14634\t            PyErr_SetString(PyExc_RuntimeError,\n14635\t                \"Unexpected error in an Op's C code. \"\n14636\t                \"No Python exception was set.\");\n14637\t            }\n14638\t        goto __label_248;}\n14639\t            }\n14640\t            if (!PyArray_Check(py_V247)) {\n14641\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n14642\t                {\n14643\t        __failure = 248;\n14644\t        if (!PyErr_Occurred()) {\n14645\t            PyErr_SetString(PyExc_RuntimeError,\n14646\t                \"Unexpected error in an Op's C code. \"\n14647\t                \"No Python exception was set.\");\n14648\t            }\n14649\t        goto __label_248;}\n14650\t            }\n14651\t            // We expect NPY_FLOAT64\n14652\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V247)) {\n14653\t                PyArrayObject * tmp = (PyArrayObject*) py_V247;\n14654\t                PyErr_Format(PyExc_NotImplementedError,\n14655\t                             \"expected an aligned array of type %ld \"\n14656\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n14657\t                             \" with %ld dimensions, with 3 last dims \"\n14658\t                             \"%ld, %ld, %ld\"\n14659\t                             \" and 3 last strides %ld %ld, %ld.\",\n14660\t                             (long int) NPY_FLOAT64,\n14661\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V247),\n14662\t                             (long int) PyArray_NDIM(tmp),\n14663\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n14664\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n14665\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n14666\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n14667\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n14668\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n14669\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n14670\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n14671\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n14672\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n14673\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n14674\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n14675\t            );\n14676\t                {\n14677\t        __failure = 248;\n14678\t        if (!PyErr_Occurred()) {\n14679\t            PyErr_SetString(PyExc_RuntimeError,\n14680\t                \"Unexpected error in an Op's C code. \"\n14681\t                \"No Python exception was set.\");\n14682\t            }\n14683\t        goto __label_248;}\n14684\t            }\n14685\t            // This is a TypeError to be consistent with DEBUG_MODE\n14686\t            // Note: DEBUG_MODE also tells the name of the container\n14687\t            if (PyArray_TYPE((PyArrayObject*) py_V247) != NPY_FLOAT64) {\n14688\t                PyErr_Format(PyExc_TypeError,\n14689\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n14690\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V247));\n14691\t                {\n14692\t        __failure = 248;\n14693\t        if (!PyErr_Occurred()) {\n14694\t            PyErr_SetString(PyExc_RuntimeError,\n14695\t                \"Unexpected error in an Op's C code. \"\n14696\t                \"No Python exception was set.\");\n14697\t            }\n14698\t        goto __label_248;}\n14699\t            }\n14700\t            \n14701\t        V247 = (PyArrayObject*)(py_V247);\n14702\t        Py_XINCREF(V247);\n14703\t        \n14704\t{\n14705\t\n14706\t    py_V249 = PyList_GET_ITEM(storage_V249, 0);\n14707\t    {Py_XINCREF(py_V249);}\n14708\t    \n14709\t            V249 = NULL;\n14710\t            if (py_V249 == Py_None) {\n14711\t                // We can either fail here or set V249 to NULL and rely on Ops\n14712\t                // using tensors to handle the NULL case, but if they fail to do so\n14713\t                // they'll end up with nasty segfaults, so this is public service.\n14714\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n14715\t                {\n14716\t        __failure = 250;\n14717\t        if (!PyErr_Occurred()) {\n14718\t            PyErr_SetString(PyExc_RuntimeError,\n14719\t                \"Unexpected error in an Op's C code. \"\n14720\t                \"No Python exception was set.\");\n14721\t            }\n14722\t        goto __label_250;}\n14723\t            }\n14724\t            if (!PyArray_Check(py_V249)) {\n14725\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n14726\t                {\n14727\t        __failure = 250;\n14728\t        if (!PyErr_Occurred()) {\n14729\t            PyErr_SetString(PyExc_RuntimeError,\n14730\t                \"Unexpected error in an Op's C code. \"\n14731\t                \"No Python exception was set.\");\n14732\t            }\n14733\t        goto __label_250;}\n14734\t            }\n14735\t            // We expect NPY_FLOAT64\n14736\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V249)) {\n14737\t                PyArrayObject * tmp = (PyArrayObject*) py_V249;\n14738\t                PyErr_Format(PyExc_NotImplementedError,\n14739\t                             \"expected an aligned array of type %ld \"\n14740\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n14741\t                             \" with %ld dimensions, with 3 last dims \"\n14742\t                             \"%ld, %ld, %ld\"\n14743\t                             \" and 3 last strides %ld %ld, %ld.\",\n14744\t                             (long int) NPY_FLOAT64,\n14745\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V249),\n14746\t                             (long int) PyArray_NDIM(tmp),\n14747\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n14748\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n14749\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n14750\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n14751\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n14752\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n14753\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n14754\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n14755\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n14756\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n14757\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n14758\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n14759\t            );\n14760\t                {\n14761\t        __failure = 250;\n14762\t        if (!PyErr_Occurred()) {\n14763\t            PyErr_SetString(PyExc_RuntimeError,\n14764\t                \"Unexpected error in an Op's C code. \"\n14765\t                \"No Python exception was set.\");\n14766\t            }\n14767\t        goto __label_250;}\n14768\t            }\n14769\t            // This is a TypeError to be consistent with DEBUG_MODE\n14770\t            // Note: DEBUG_MODE also tells the name of the container\n14771\t            if (PyArray_TYPE((PyArrayObject*) py_V249) != NPY_FLOAT64) {\n14772\t                PyErr_Format(PyExc_TypeError,\n14773\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n14774\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V249));\n14775\t                {\n14776\t        __failure = 250;\n14777\t        if (!PyErr_Occurred()) {\n14778\t            PyErr_SetString(PyExc_RuntimeError,\n14779\t                \"Unexpected error in an Op's C code. \"\n14780\t                \"No Python exception was set.\");\n14781\t            }\n14782\t        goto __label_250;}\n14783\t            }\n14784\t            \n14785\t        V249 = (PyArrayObject*)(py_V249);\n14786\t        Py_XINCREF(V249);\n14787\t        \n14788\t{\n14789\t\n14790\t    py_V251 = PyList_GET_ITEM(storage_V251, 0);\n14791\t    {Py_XINCREF(py_V251);}\n14792\t    \n14793\t            V251 = NULL;\n14794\t            if (py_V251 == Py_None) {\n14795\t                // We can either fail here or set V251 to NULL and rely on Ops\n14796\t                // using tensors to handle the NULL case, but if they fail to do so\n14797\t                // they'll end up with nasty segfaults, so this is public service.\n14798\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n14799\t                {\n14800\t        __failure = 252;\n14801\t        if (!PyErr_Occurred()) {\n14802\t            PyErr_SetString(PyExc_RuntimeError,\n14803\t                \"Unexpected error in an Op's C code. \"\n14804\t                \"No Python exception was set.\");\n14805\t            }\n14806\t        goto __label_252;}\n14807\t            }\n14808\t            if (!PyArray_Check(py_V251)) {\n14809\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n14810\t                {\n14811\t        __failure = 252;\n14812\t        if (!PyErr_Occurred()) {\n14813\t            PyErr_SetString(PyExc_RuntimeError,\n14814\t                \"Unexpected error in an Op's C code. \"\n14815\t                \"No Python exception was set.\");\n14816\t            }\n14817\t        goto __label_252;}\n14818\t            }\n14819\t            // We expect NPY_FLOAT64\n14820\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V251)) {\n14821\t                PyArrayObject * tmp = (PyArrayObject*) py_V251;\n14822\t                PyErr_Format(PyExc_NotImplementedError,\n14823\t                             \"expected an aligned array of type %ld \"\n14824\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n14825\t                             \" with %ld dimensions, with 3 last dims \"\n14826\t                             \"%ld, %ld, %ld\"\n14827\t                             \" and 3 last strides %ld %ld, %ld.\",\n14828\t                             (long int) NPY_FLOAT64,\n14829\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V251),\n14830\t                             (long int) PyArray_NDIM(tmp),\n14831\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n14832\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n14833\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n14834\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n14835\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n14836\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n14837\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n14838\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n14839\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n14840\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n14841\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n14842\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n14843\t            );\n14844\t                {\n14845\t        __failure = 252;\n14846\t        if (!PyErr_Occurred()) {\n14847\t            PyErr_SetString(PyExc_RuntimeError,\n14848\t                \"Unexpected error in an Op's C code. \"\n14849\t                \"No Python exception was set.\");\n14850\t            }\n14851\t        goto __label_252;}\n14852\t            }\n14853\t            // This is a TypeError to be consistent with DEBUG_MODE\n14854\t            // Note: DEBUG_MODE also tells the name of the container\n14855\t            if (PyArray_TYPE((PyArrayObject*) py_V251) != NPY_FLOAT64) {\n14856\t                PyErr_Format(PyExc_TypeError,\n14857\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n14858\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V251));\n14859\t                {\n14860\t        __failure = 252;\n14861\t        if (!PyErr_Occurred()) {\n14862\t            PyErr_SetString(PyExc_RuntimeError,\n14863\t                \"Unexpected error in an Op's C code. \"\n14864\t                \"No Python exception was set.\");\n14865\t            }\n14866\t        goto __label_252;}\n14867\t            }\n14868\t            \n14869\t        V251 = (PyArrayObject*)(py_V251);\n14870\t        Py_XINCREF(V251);\n14871\t        \n14872\t{\n14873\t\n14874\t    py_V253 = PyList_GET_ITEM(storage_V253, 0);\n14875\t    {Py_XINCREF(py_V253);}\n14876\t    \n14877\t            V253 = NULL;\n14878\t            if (py_V253 == Py_None) {\n14879\t                // We can either fail here or set V253 to NULL and rely on Ops\n14880\t                // using tensors to handle the NULL case, but if they fail to do so\n14881\t                // they'll end up with nasty segfaults, so this is public service.\n14882\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n14883\t                {\n14884\t        __failure = 254;\n14885\t        if (!PyErr_Occurred()) {\n14886\t            PyErr_SetString(PyExc_RuntimeError,\n14887\t                \"Unexpected error in an Op's C code. \"\n14888\t                \"No Python exception was set.\");\n14889\t            }\n14890\t        goto __label_254;}\n14891\t            }\n14892\t            if (!PyArray_Check(py_V253)) {\n14893\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n14894\t                {\n14895\t        __failure = 254;\n14896\t        if (!PyErr_Occurred()) {\n14897\t            PyErr_SetString(PyExc_RuntimeError,\n14898\t                \"Unexpected error in an Op's C code. \"\n14899\t                \"No Python exception was set.\");\n14900\t            }\n14901\t        goto __label_254;}\n14902\t            }\n14903\t            // We expect NPY_FLOAT64\n14904\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V253)) {\n14905\t                PyArrayObject * tmp = (PyArrayObject*) py_V253;\n14906\t                PyErr_Format(PyExc_NotImplementedError,\n14907\t                             \"expected an aligned array of type %ld \"\n14908\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n14909\t                             \" with %ld dimensions, with 3 last dims \"\n14910\t                             \"%ld, %ld, %ld\"\n14911\t                             \" and 3 last strides %ld %ld, %ld.\",\n14912\t                             (long int) NPY_FLOAT64,\n14913\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V253),\n14914\t                             (long int) PyArray_NDIM(tmp),\n14915\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n14916\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n14917\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n14918\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n14919\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n14920\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n14921\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n14922\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n14923\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n14924\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n14925\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n14926\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n14927\t            );\n14928\t                {\n14929\t        __failure = 254;\n14930\t        if (!PyErr_Occurred()) {\n14931\t            PyErr_SetString(PyExc_RuntimeError,\n14932\t                \"Unexpected error in an Op's C code. \"\n14933\t                \"No Python exception was set.\");\n14934\t            }\n14935\t        goto __label_254;}\n14936\t            }\n14937\t            // This is a TypeError to be consistent with DEBUG_MODE\n14938\t            // Note: DEBUG_MODE also tells the name of the container\n14939\t            if (PyArray_TYPE((PyArrayObject*) py_V253) != NPY_FLOAT64) {\n14940\t                PyErr_Format(PyExc_TypeError,\n14941\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n14942\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V253));\n14943\t                {\n14944\t        __failure = 254;\n14945\t        if (!PyErr_Occurred()) {\n14946\t            PyErr_SetString(PyExc_RuntimeError,\n14947\t                \"Unexpected error in an Op's C code. \"\n14948\t                \"No Python exception was set.\");\n14949\t            }\n14950\t        goto __label_254;}\n14951\t            }\n14952\t            \n14953\t        V253 = (PyArrayObject*)(py_V253);\n14954\t        Py_XINCREF(V253);\n14955\t        \n14956\t{\n14957\t\n14958\t    py_V255 = PyList_GET_ITEM(storage_V255, 0);\n14959\t    {Py_XINCREF(py_V255);}\n14960\t    \n14961\t            V255 = NULL;\n14962\t            if (py_V255 == Py_None) {\n14963\t                // We can either fail here or set V255 to NULL and rely on Ops\n14964\t                // using tensors to handle the NULL case, but if they fail to do so\n14965\t                // they'll end up with nasty segfaults, so this is public service.\n14966\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n14967\t                {\n14968\t        __failure = 256;\n14969\t        if (!PyErr_Occurred()) {\n14970\t            PyErr_SetString(PyExc_RuntimeError,\n14971\t                \"Unexpected error in an Op's C code. \"\n14972\t                \"No Python exception was set.\");\n14973\t            }\n14974\t        goto __label_256;}\n14975\t            }\n14976\t            if (!PyArray_Check(py_V255)) {\n14977\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n14978\t                {\n14979\t        __failure = 256;\n14980\t        if (!PyErr_Occurred()) {\n14981\t            PyErr_SetString(PyExc_RuntimeError,\n14982\t                \"Unexpected error in an Op's C code. \"\n14983\t                \"No Python exception was set.\");\n14984\t            }\n14985\t        goto __label_256;}\n14986\t            }\n14987\t            // We expect NPY_FLOAT64\n14988\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V255)) {\n14989\t                PyArrayObject * tmp = (PyArrayObject*) py_V255;\n14990\t                PyErr_Format(PyExc_NotImplementedError,\n14991\t                             \"expected an aligned array of type %ld \"\n14992\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n14993\t                             \" with %ld dimensions, with 3 last dims \"\n14994\t                             \"%ld, %ld, %ld\"\n14995\t                             \" and 3 last strides %ld %ld, %ld.\",\n14996\t                             (long int) NPY_FLOAT64,\n14997\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V255),\n14998\t                             (long int) PyArray_NDIM(tmp),\n14999\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n15000\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n15001\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n15002\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n15003\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n15004\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n15005\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n15006\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n15007\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n15008\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n15009\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n15010\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n15011\t            );\n15012\t                {\n15013\t        __failure = 256;\n15014\t        if (!PyErr_Occurred()) {\n15015\t            PyErr_SetString(PyExc_RuntimeError,\n15016\t                \"Unexpected error in an Op's C code. \"\n15017\t                \"No Python exception was set.\");\n15018\t            }\n15019\t        goto __label_256;}\n15020\t            }\n15021\t            // This is a TypeError to be consistent with DEBUG_MODE\n15022\t            // Note: DEBUG_MODE also tells the name of the container\n15023\t            if (PyArray_TYPE((PyArrayObject*) py_V255) != NPY_FLOAT64) {\n15024\t                PyErr_Format(PyExc_TypeError,\n15025\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n15026\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V255));\n15027\t                {\n15028\t        __failure = 256;\n15029\t        if (!PyErr_Occurred()) {\n15030\t            PyErr_SetString(PyExc_RuntimeError,\n15031\t                \"Unexpected error in an Op's C code. \"\n15032\t                \"No Python exception was set.\");\n15033\t            }\n15034\t        goto __label_256;}\n15035\t            }\n15036\t            \n15037\t        V255 = (PyArrayObject*)(py_V255);\n15038\t        Py_XINCREF(V255);\n15039\t        \n15040\t{\n15041\t\n15042\t    py_V257 = PyList_GET_ITEM(storage_V257, 0);\n15043\t    {Py_XINCREF(py_V257);}\n15044\t    \n15045\t            V257 = NULL;\n15046\t            if (py_V257 == Py_None) {\n15047\t                // We can either fail here or set V257 to NULL and rely on Ops\n15048\t                // using tensors to handle the NULL case, but if they fail to do so\n15049\t                // they'll end up with nasty segfaults, so this is public service.\n15050\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n15051\t                {\n15052\t        __failure = 258;\n15053\t        if (!PyErr_Occurred()) {\n15054\t            PyErr_SetString(PyExc_RuntimeError,\n15055\t                \"Unexpected error in an Op's C code. \"\n15056\t                \"No Python exception was set.\");\n15057\t            }\n15058\t        goto __label_258;}\n15059\t            }\n15060\t            if (!PyArray_Check(py_V257)) {\n15061\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n15062\t                {\n15063\t        __failure = 258;\n15064\t        if (!PyErr_Occurred()) {\n15065\t            PyErr_SetString(PyExc_RuntimeError,\n15066\t                \"Unexpected error in an Op's C code. \"\n15067\t                \"No Python exception was set.\");\n15068\t            }\n15069\t        goto __label_258;}\n15070\t            }\n15071\t            // We expect NPY_FLOAT64\n15072\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V257)) {\n15073\t                PyArrayObject * tmp = (PyArrayObject*) py_V257;\n15074\t                PyErr_Format(PyExc_NotImplementedError,\n15075\t                             \"expected an aligned array of type %ld \"\n15076\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n15077\t                             \" with %ld dimensions, with 3 last dims \"\n15078\t                             \"%ld, %ld, %ld\"\n15079\t                             \" and 3 last strides %ld %ld, %ld.\",\n15080\t                             (long int) NPY_FLOAT64,\n15081\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V257),\n15082\t                             (long int) PyArray_NDIM(tmp),\n15083\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n15084\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n15085\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n15086\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n15087\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n15088\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n15089\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n15090\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n15091\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n15092\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n15093\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n15094\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n15095\t            );\n15096\t                {\n15097\t        __failure = 258;\n15098\t        if (!PyErr_Occurred()) {\n15099\t            PyErr_SetString(PyExc_RuntimeError,\n15100\t                \"Unexpected error in an Op's C code. \"\n15101\t                \"No Python exception was set.\");\n15102\t            }\n15103\t        goto __label_258;}\n15104\t            }\n15105\t            // This is a TypeError to be consistent with DEBUG_MODE\n15106\t            // Note: DEBUG_MODE also tells the name of the container\n15107\t            if (PyArray_TYPE((PyArrayObject*) py_V257) != NPY_FLOAT64) {\n15108\t                PyErr_Format(PyExc_TypeError,\n15109\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n15110\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V257));\n15111\t                {\n15112\t        __failure = 258;\n15113\t        if (!PyErr_Occurred()) {\n15114\t            PyErr_SetString(PyExc_RuntimeError,\n15115\t                \"Unexpected error in an Op's C code. \"\n15116\t                \"No Python exception was set.\");\n15117\t            }\n15118\t        goto __label_258;}\n15119\t            }\n15120\t            \n15121\t        V257 = (PyArrayObject*)(py_V257);\n15122\t        Py_XINCREF(V257);\n15123\t        \n15124\t{\n15125\t\n15126\t    py_V259 = PyList_GET_ITEM(storage_V259, 0);\n15127\t    {Py_XINCREF(py_V259);}\n15128\t    \n15129\t            V259 = NULL;\n15130\t            if (py_V259 == Py_None) {\n15131\t                // We can either fail here or set V259 to NULL and rely on Ops\n15132\t                // using tensors to handle the NULL case, but if they fail to do so\n15133\t                // they'll end up with nasty segfaults, so this is public service.\n15134\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n15135\t                {\n15136\t        __failure = 260;\n15137\t        if (!PyErr_Occurred()) {\n15138\t            PyErr_SetString(PyExc_RuntimeError,\n15139\t                \"Unexpected error in an Op's C code. \"\n15140\t                \"No Python exception was set.\");\n15141\t            }\n15142\t        goto __label_260;}\n15143\t            }\n15144\t            if (!PyArray_Check(py_V259)) {\n15145\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n15146\t                {\n15147\t        __failure = 260;\n15148\t        if (!PyErr_Occurred()) {\n15149\t            PyErr_SetString(PyExc_RuntimeError,\n15150\t                \"Unexpected error in an Op's C code. \"\n15151\t                \"No Python exception was set.\");\n15152\t            }\n15153\t        goto __label_260;}\n15154\t            }\n15155\t            // We expect NPY_FLOAT64\n15156\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V259)) {\n15157\t                PyArrayObject * tmp = (PyArrayObject*) py_V259;\n15158\t                PyErr_Format(PyExc_NotImplementedError,\n15159\t                             \"expected an aligned array of type %ld \"\n15160\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n15161\t                             \" with %ld dimensions, with 3 last dims \"\n15162\t                             \"%ld, %ld, %ld\"\n15163\t                             \" and 3 last strides %ld %ld, %ld.\",\n15164\t                             (long int) NPY_FLOAT64,\n15165\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V259),\n15166\t                             (long int) PyArray_NDIM(tmp),\n15167\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n15168\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n15169\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n15170\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n15171\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n15172\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n15173\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n15174\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n15175\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n15176\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n15177\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n15178\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n15179\t            );\n15180\t                {\n15181\t        __failure = 260;\n15182\t        if (!PyErr_Occurred()) {\n15183\t            PyErr_SetString(PyExc_RuntimeError,\n15184\t                \"Unexpected error in an Op's C code. \"\n15185\t                \"No Python exception was set.\");\n15186\t            }\n15187\t        goto __label_260;}\n15188\t            }\n15189\t            // This is a TypeError to be consistent with DEBUG_MODE\n15190\t            // Note: DEBUG_MODE also tells the name of the container\n15191\t            if (PyArray_TYPE((PyArrayObject*) py_V259) != NPY_FLOAT64) {\n15192\t                PyErr_Format(PyExc_TypeError,\n15193\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n15194\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V259));\n15195\t                {\n15196\t        __failure = 260;\n15197\t        if (!PyErr_Occurred()) {\n15198\t            PyErr_SetString(PyExc_RuntimeError,\n15199\t                \"Unexpected error in an Op's C code. \"\n15200\t                \"No Python exception was set.\");\n15201\t            }\n15202\t        goto __label_260;}\n15203\t            }\n15204\t            \n15205\t        V259 = (PyArrayObject*)(py_V259);\n15206\t        Py_XINCREF(V259);\n15207\t        \n15208\t{\n15209\t\n15210\t    py_V261 = PyList_GET_ITEM(storage_V261, 0);\n15211\t    {Py_XINCREF(py_V261);}\n15212\t    \n15213\t            V261 = NULL;\n15214\t            if (py_V261 == Py_None) {\n15215\t                // We can either fail here or set V261 to NULL and rely on Ops\n15216\t                // using tensors to handle the NULL case, but if they fail to do so\n15217\t                // they'll end up with nasty segfaults, so this is public service.\n15218\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n15219\t                {\n15220\t        __failure = 262;\n15221\t        if (!PyErr_Occurred()) {\n15222\t            PyErr_SetString(PyExc_RuntimeError,\n15223\t                \"Unexpected error in an Op's C code. \"\n15224\t                \"No Python exception was set.\");\n15225\t            }\n15226\t        goto __label_262;}\n15227\t            }\n15228\t            if (!PyArray_Check(py_V261)) {\n15229\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n15230\t                {\n15231\t        __failure = 262;\n15232\t        if (!PyErr_Occurred()) {\n15233\t            PyErr_SetString(PyExc_RuntimeError,\n15234\t                \"Unexpected error in an Op's C code. \"\n15235\t                \"No Python exception was set.\");\n15236\t            }\n15237\t        goto __label_262;}\n15238\t            }\n15239\t            // We expect NPY_FLOAT64\n15240\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V261)) {\n15241\t                PyArrayObject * tmp = (PyArrayObject*) py_V261;\n15242\t                PyErr_Format(PyExc_NotImplementedError,\n15243\t                             \"expected an aligned array of type %ld \"\n15244\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n15245\t                             \" with %ld dimensions, with 3 last dims \"\n15246\t                             \"%ld, %ld, %ld\"\n15247\t                             \" and 3 last strides %ld %ld, %ld.\",\n15248\t                             (long int) NPY_FLOAT64,\n15249\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V261),\n15250\t                             (long int) PyArray_NDIM(tmp),\n15251\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n15252\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n15253\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n15254\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n15255\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n15256\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n15257\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n15258\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n15259\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n15260\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n15261\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n15262\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n15263\t            );\n15264\t                {\n15265\t        __failure = 262;\n15266\t        if (!PyErr_Occurred()) {\n15267\t            PyErr_SetString(PyExc_RuntimeError,\n15268\t                \"Unexpected error in an Op's C code. \"\n15269\t                \"No Python exception was set.\");\n15270\t            }\n15271\t        goto __label_262;}\n15272\t            }\n15273\t            // This is a TypeError to be consistent with DEBUG_MODE\n15274\t            // Note: DEBUG_MODE also tells the name of the container\n15275\t            if (PyArray_TYPE((PyArrayObject*) py_V261) != NPY_FLOAT64) {\n15276\t                PyErr_Format(PyExc_TypeError,\n15277\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n15278\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V261));\n15279\t                {\n15280\t        __failure = 262;\n15281\t        if (!PyErr_Occurred()) {\n15282\t            PyErr_SetString(PyExc_RuntimeError,\n15283\t                \"Unexpected error in an Op's C code. \"\n15284\t                \"No Python exception was set.\");\n15285\t            }\n15286\t        goto __label_262;}\n15287\t            }\n15288\t            \n15289\t        V261 = (PyArrayObject*)(py_V261);\n15290\t        Py_XINCREF(V261);\n15291\t        \n15292\t{\n15293\t\n15294\t    py_V263 = PyList_GET_ITEM(storage_V263, 0);\n15295\t    {Py_XINCREF(py_V263);}\n15296\t    \n15297\t            V263 = NULL;\n15298\t            if (py_V263 == Py_None) {\n15299\t                // We can either fail here or set V263 to NULL and rely on Ops\n15300\t                // using tensors to handle the NULL case, but if they fail to do so\n15301\t                // they'll end up with nasty segfaults, so this is public service.\n15302\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n15303\t                {\n15304\t        __failure = 264;\n15305\t        if (!PyErr_Occurred()) {\n15306\t            PyErr_SetString(PyExc_RuntimeError,\n15307\t                \"Unexpected error in an Op's C code. \"\n15308\t                \"No Python exception was set.\");\n15309\t            }\n15310\t        goto __label_264;}\n15311\t            }\n15312\t            if (!PyArray_Check(py_V263)) {\n15313\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n15314\t                {\n15315\t        __failure = 264;\n15316\t        if (!PyErr_Occurred()) {\n15317\t            PyErr_SetString(PyExc_RuntimeError,\n15318\t                \"Unexpected error in an Op's C code. \"\n15319\t                \"No Python exception was set.\");\n15320\t            }\n15321\t        goto __label_264;}\n15322\t            }\n15323\t            // We expect NPY_FLOAT64\n15324\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V263)) {\n15325\t                PyArrayObject * tmp = (PyArrayObject*) py_V263;\n15326\t                PyErr_Format(PyExc_NotImplementedError,\n15327\t                             \"expected an aligned array of type %ld \"\n15328\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n15329\t                             \" with %ld dimensions, with 3 last dims \"\n15330\t                             \"%ld, %ld, %ld\"\n15331\t                             \" and 3 last strides %ld %ld, %ld.\",\n15332\t                             (long int) NPY_FLOAT64,\n15333\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V263),\n15334\t                             (long int) PyArray_NDIM(tmp),\n15335\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n15336\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n15337\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n15338\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n15339\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n15340\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n15341\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n15342\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n15343\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n15344\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n15345\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n15346\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n15347\t            );\n15348\t                {\n15349\t        __failure = 264;\n15350\t        if (!PyErr_Occurred()) {\n15351\t            PyErr_SetString(PyExc_RuntimeError,\n15352\t                \"Unexpected error in an Op's C code. \"\n15353\t                \"No Python exception was set.\");\n15354\t            }\n15355\t        goto __label_264;}\n15356\t            }\n15357\t            // This is a TypeError to be consistent with DEBUG_MODE\n15358\t            // Note: DEBUG_MODE also tells the name of the container\n15359\t            if (PyArray_TYPE((PyArrayObject*) py_V263) != NPY_FLOAT64) {\n15360\t                PyErr_Format(PyExc_TypeError,\n15361\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n15362\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V263));\n15363\t                {\n15364\t        __failure = 264;\n15365\t        if (!PyErr_Occurred()) {\n15366\t            PyErr_SetString(PyExc_RuntimeError,\n15367\t                \"Unexpected error in an Op's C code. \"\n15368\t                \"No Python exception was set.\");\n15369\t            }\n15370\t        goto __label_264;}\n15371\t            }\n15372\t            \n15373\t        V263 = (PyArrayObject*)(py_V263);\n15374\t        Py_XINCREF(V263);\n15375\t        \n15376\t{\n15377\t\n15378\t    py_V265 = PyList_GET_ITEM(storage_V265, 0);\n15379\t    {Py_XINCREF(py_V265);}\n15380\t    \n15381\t            V265 = NULL;\n15382\t            if (py_V265 == Py_None) {\n15383\t                // We can either fail here or set V265 to NULL and rely on Ops\n15384\t                // using tensors to handle the NULL case, but if they fail to do so\n15385\t                // they'll end up with nasty segfaults, so this is public service.\n15386\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n15387\t                {\n15388\t        __failure = 266;\n15389\t        if (!PyErr_Occurred()) {\n15390\t            PyErr_SetString(PyExc_RuntimeError,\n15391\t                \"Unexpected error in an Op's C code. \"\n15392\t                \"No Python exception was set.\");\n15393\t            }\n15394\t        goto __label_266;}\n15395\t            }\n15396\t            if (!PyArray_Check(py_V265)) {\n15397\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n15398\t                {\n15399\t        __failure = 266;\n15400\t        if (!PyErr_Occurred()) {\n15401\t            PyErr_SetString(PyExc_RuntimeError,\n15402\t                \"Unexpected error in an Op's C code. \"\n15403\t                \"No Python exception was set.\");\n15404\t            }\n15405\t        goto __label_266;}\n15406\t            }\n15407\t            // We expect NPY_FLOAT64\n15408\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V265)) {\n15409\t                PyArrayObject * tmp = (PyArrayObject*) py_V265;\n15410\t                PyErr_Format(PyExc_NotImplementedError,\n15411\t                             \"expected an aligned array of type %ld \"\n15412\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n15413\t                             \" with %ld dimensions, with 3 last dims \"\n15414\t                             \"%ld, %ld, %ld\"\n15415\t                             \" and 3 last strides %ld %ld, %ld.\",\n15416\t                             (long int) NPY_FLOAT64,\n15417\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V265),\n15418\t                             (long int) PyArray_NDIM(tmp),\n15419\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n15420\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n15421\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n15422\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n15423\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n15424\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n15425\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n15426\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n15427\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n15428\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n15429\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n15430\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n15431\t            );\n15432\t                {\n15433\t        __failure = 266;\n15434\t        if (!PyErr_Occurred()) {\n15435\t            PyErr_SetString(PyExc_RuntimeError,\n15436\t                \"Unexpected error in an Op's C code. \"\n15437\t                \"No Python exception was set.\");\n15438\t            }\n15439\t        goto __label_266;}\n15440\t            }\n15441\t            // This is a TypeError to be consistent with DEBUG_MODE\n15442\t            // Note: DEBUG_MODE also tells the name of the container\n15443\t            if (PyArray_TYPE((PyArrayObject*) py_V265) != NPY_FLOAT64) {\n15444\t                PyErr_Format(PyExc_TypeError,\n15445\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n15446\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V265));\n15447\t                {\n15448\t        __failure = 266;\n15449\t        if (!PyErr_Occurred()) {\n15450\t            PyErr_SetString(PyExc_RuntimeError,\n15451\t                \"Unexpected error in an Op's C code. \"\n15452\t                \"No Python exception was set.\");\n15453\t            }\n15454\t        goto __label_266;}\n15455\t            }\n15456\t            \n15457\t        V265 = (PyArrayObject*)(py_V265);\n15458\t        Py_XINCREF(V265);\n15459\t        \n15460\t{\n15461\t\n15462\t    py_V267 = PyList_GET_ITEM(storage_V267, 0);\n15463\t    {Py_XINCREF(py_V267);}\n15464\t    \n15465\t            V267 = NULL;\n15466\t            if (py_V267 == Py_None) {\n15467\t                // We can either fail here or set V267 to NULL and rely on Ops\n15468\t                // using tensors to handle the NULL case, but if they fail to do so\n15469\t                // they'll end up with nasty segfaults, so this is public service.\n15470\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n15471\t                {\n15472\t        __failure = 268;\n15473\t        if (!PyErr_Occurred()) {\n15474\t            PyErr_SetString(PyExc_RuntimeError,\n15475\t                \"Unexpected error in an Op's C code. \"\n15476\t                \"No Python exception was set.\");\n15477\t            }\n15478\t        goto __label_268;}\n15479\t            }\n15480\t            if (!PyArray_Check(py_V267)) {\n15481\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n15482\t                {\n15483\t        __failure = 268;\n15484\t        if (!PyErr_Occurred()) {\n15485\t            PyErr_SetString(PyExc_RuntimeError,\n15486\t                \"Unexpected error in an Op's C code. \"\n15487\t                \"No Python exception was set.\");\n15488\t            }\n15489\t        goto __label_268;}\n15490\t            }\n15491\t            // We expect NPY_FLOAT64\n15492\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V267)) {\n15493\t                PyArrayObject * tmp = (PyArrayObject*) py_V267;\n15494\t                PyErr_Format(PyExc_NotImplementedError,\n15495\t                             \"expected an aligned array of type %ld \"\n15496\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n15497\t                             \" with %ld dimensions, with 3 last dims \"\n15498\t                             \"%ld, %ld, %ld\"\n15499\t                             \" and 3 last strides %ld %ld, %ld.\",\n15500\t                             (long int) NPY_FLOAT64,\n15501\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V267),\n15502\t                             (long int) PyArray_NDIM(tmp),\n15503\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n15504\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n15505\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n15506\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n15507\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n15508\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n15509\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n15510\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n15511\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n15512\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n15513\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n15514\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n15515\t            );\n15516\t                {\n15517\t        __failure = 268;\n15518\t        if (!PyErr_Occurred()) {\n15519\t            PyErr_SetString(PyExc_RuntimeError,\n15520\t                \"Unexpected error in an Op's C code. \"\n15521\t                \"No Python exception was set.\");\n15522\t            }\n15523\t        goto __label_268;}\n15524\t            }\n15525\t            // This is a TypeError to be consistent with DEBUG_MODE\n15526\t            // Note: DEBUG_MODE also tells the name of the container\n15527\t            if (PyArray_TYPE((PyArrayObject*) py_V267) != NPY_FLOAT64) {\n15528\t                PyErr_Format(PyExc_TypeError,\n15529\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n15530\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V267));\n15531\t                {\n15532\t        __failure = 268;\n15533\t        if (!PyErr_Occurred()) {\n15534\t            PyErr_SetString(PyExc_RuntimeError,\n15535\t                \"Unexpected error in an Op's C code. \"\n15536\t                \"No Python exception was set.\");\n15537\t            }\n15538\t        goto __label_268;}\n15539\t            }\n15540\t            \n15541\t        V267 = (PyArrayObject*)(py_V267);\n15542\t        Py_XINCREF(V267);\n15543\t        \n15544\t{\n15545\t\n15546\t    py_V269 = PyList_GET_ITEM(storage_V269, 0);\n15547\t    {Py_XINCREF(py_V269);}\n15548\t    \n15549\t            V269 = NULL;\n15550\t            if (py_V269 == Py_None) {\n15551\t                // We can either fail here or set V269 to NULL and rely on Ops\n15552\t                // using tensors to handle the NULL case, but if they fail to do so\n15553\t                // they'll end up with nasty segfaults, so this is public service.\n15554\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n15555\t                {\n15556\t        __failure = 270;\n15557\t        if (!PyErr_Occurred()) {\n15558\t            PyErr_SetString(PyExc_RuntimeError,\n15559\t                \"Unexpected error in an Op's C code. \"\n15560\t                \"No Python exception was set.\");\n15561\t            }\n15562\t        goto __label_270;}\n15563\t            }\n15564\t            if (!PyArray_Check(py_V269)) {\n15565\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n15566\t                {\n15567\t        __failure = 270;\n15568\t        if (!PyErr_Occurred()) {\n15569\t            PyErr_SetString(PyExc_RuntimeError,\n15570\t                \"Unexpected error in an Op's C code. \"\n15571\t                \"No Python exception was set.\");\n15572\t            }\n15573\t        goto __label_270;}\n15574\t            }\n15575\t            // We expect NPY_FLOAT64\n15576\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V269)) {\n15577\t                PyArrayObject * tmp = (PyArrayObject*) py_V269;\n15578\t                PyErr_Format(PyExc_NotImplementedError,\n15579\t                             \"expected an aligned array of type %ld \"\n15580\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n15581\t                             \" with %ld dimensions, with 3 last dims \"\n15582\t                             \"%ld, %ld, %ld\"\n15583\t                             \" and 3 last strides %ld %ld, %ld.\",\n15584\t                             (long int) NPY_FLOAT64,\n15585\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V269),\n15586\t                             (long int) PyArray_NDIM(tmp),\n15587\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n15588\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n15589\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n15590\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n15591\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n15592\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n15593\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n15594\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n15595\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n15596\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n15597\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n15598\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n15599\t            );\n15600\t                {\n15601\t        __failure = 270;\n15602\t        if (!PyErr_Occurred()) {\n15603\t            PyErr_SetString(PyExc_RuntimeError,\n15604\t                \"Unexpected error in an Op's C code. \"\n15605\t                \"No Python exception was set.\");\n15606\t            }\n15607\t        goto __label_270;}\n15608\t            }\n15609\t            // This is a TypeError to be consistent with DEBUG_MODE\n15610\t            // Note: DEBUG_MODE also tells the name of the container\n15611\t            if (PyArray_TYPE((PyArrayObject*) py_V269) != NPY_FLOAT64) {\n15612\t                PyErr_Format(PyExc_TypeError,\n15613\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n15614\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V269));\n15615\t                {\n15616\t        __failure = 270;\n15617\t        if (!PyErr_Occurred()) {\n15618\t            PyErr_SetString(PyExc_RuntimeError,\n15619\t                \"Unexpected error in an Op's C code. \"\n15620\t                \"No Python exception was set.\");\n15621\t            }\n15622\t        goto __label_270;}\n15623\t            }\n15624\t            \n15625\t        V269 = (PyArrayObject*)(py_V269);\n15626\t        Py_XINCREF(V269);\n15627\t        \n15628\t{\n15629\t\n15630\t    py_V271 = PyList_GET_ITEM(storage_V271, 0);\n15631\t    {Py_XINCREF(py_V271);}\n15632\t    \n15633\t            V271 = NULL;\n15634\t            if (py_V271 == Py_None) {\n15635\t                // We can either fail here or set V271 to NULL and rely on Ops\n15636\t                // using tensors to handle the NULL case, but if they fail to do so\n15637\t                // they'll end up with nasty segfaults, so this is public service.\n15638\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n15639\t                {\n15640\t        __failure = 272;\n15641\t        if (!PyErr_Occurred()) {\n15642\t            PyErr_SetString(PyExc_RuntimeError,\n15643\t                \"Unexpected error in an Op's C code. \"\n15644\t                \"No Python exception was set.\");\n15645\t            }\n15646\t        goto __label_272;}\n15647\t            }\n15648\t            if (!PyArray_Check(py_V271)) {\n15649\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n15650\t                {\n15651\t        __failure = 272;\n15652\t        if (!PyErr_Occurred()) {\n15653\t            PyErr_SetString(PyExc_RuntimeError,\n15654\t                \"Unexpected error in an Op's C code. \"\n15655\t                \"No Python exception was set.\");\n15656\t            }\n15657\t        goto __label_272;}\n15658\t            }\n15659\t            // We expect NPY_FLOAT64\n15660\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V271)) {\n15661\t                PyArrayObject * tmp = (PyArrayObject*) py_V271;\n15662\t                PyErr_Format(PyExc_NotImplementedError,\n15663\t                             \"expected an aligned array of type %ld \"\n15664\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n15665\t                             \" with %ld dimensions, with 3 last dims \"\n15666\t                             \"%ld, %ld, %ld\"\n15667\t                             \" and 3 last strides %ld %ld, %ld.\",\n15668\t                             (long int) NPY_FLOAT64,\n15669\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V271),\n15670\t                             (long int) PyArray_NDIM(tmp),\n15671\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n15672\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n15673\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n15674\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n15675\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n15676\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n15677\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n15678\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n15679\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n15680\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n15681\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n15682\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n15683\t            );\n15684\t                {\n15685\t        __failure = 272;\n15686\t        if (!PyErr_Occurred()) {\n15687\t            PyErr_SetString(PyExc_RuntimeError,\n15688\t                \"Unexpected error in an Op's C code. \"\n15689\t                \"No Python exception was set.\");\n15690\t            }\n15691\t        goto __label_272;}\n15692\t            }\n15693\t            // This is a TypeError to be consistent with DEBUG_MODE\n15694\t            // Note: DEBUG_MODE also tells the name of the container\n15695\t            if (PyArray_TYPE((PyArrayObject*) py_V271) != NPY_FLOAT64) {\n15696\t                PyErr_Format(PyExc_TypeError,\n15697\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n15698\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V271));\n15699\t                {\n15700\t        __failure = 272;\n15701\t        if (!PyErr_Occurred()) {\n15702\t            PyErr_SetString(PyExc_RuntimeError,\n15703\t                \"Unexpected error in an Op's C code. \"\n15704\t                \"No Python exception was set.\");\n15705\t            }\n15706\t        goto __label_272;}\n15707\t            }\n15708\t            \n15709\t        V271 = (PyArrayObject*)(py_V271);\n15710\t        Py_XINCREF(V271);\n15711\t        \n15712\t{\n15713\t\n15714\t    py_V273 = PyList_GET_ITEM(storage_V273, 0);\n15715\t    {Py_XINCREF(py_V273);}\n15716\t    \n15717\t            V273 = NULL;\n15718\t            if (py_V273 == Py_None) {\n15719\t                // We can either fail here or set V273 to NULL and rely on Ops\n15720\t                // using tensors to handle the NULL case, but if they fail to do so\n15721\t                // they'll end up with nasty segfaults, so this is public service.\n15722\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n15723\t                {\n15724\t        __failure = 274;\n15725\t        if (!PyErr_Occurred()) {\n15726\t            PyErr_SetString(PyExc_RuntimeError,\n15727\t                \"Unexpected error in an Op's C code. \"\n15728\t                \"No Python exception was set.\");\n15729\t            }\n15730\t        goto __label_274;}\n15731\t            }\n15732\t            if (!PyArray_Check(py_V273)) {\n15733\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n15734\t                {\n15735\t        __failure = 274;\n15736\t        if (!PyErr_Occurred()) {\n15737\t            PyErr_SetString(PyExc_RuntimeError,\n15738\t                \"Unexpected error in an Op's C code. \"\n15739\t                \"No Python exception was set.\");\n15740\t            }\n15741\t        goto __label_274;}\n15742\t            }\n15743\t            // We expect NPY_FLOAT64\n15744\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V273)) {\n15745\t                PyArrayObject * tmp = (PyArrayObject*) py_V273;\n15746\t                PyErr_Format(PyExc_NotImplementedError,\n15747\t                             \"expected an aligned array of type %ld \"\n15748\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n15749\t                             \" with %ld dimensions, with 3 last dims \"\n15750\t                             \"%ld, %ld, %ld\"\n15751\t                             \" and 3 last strides %ld %ld, %ld.\",\n15752\t                             (long int) NPY_FLOAT64,\n15753\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V273),\n15754\t                             (long int) PyArray_NDIM(tmp),\n15755\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n15756\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n15757\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n15758\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n15759\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n15760\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n15761\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n15762\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n15763\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n15764\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n15765\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n15766\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n15767\t            );\n15768\t                {\n15769\t        __failure = 274;\n15770\t        if (!PyErr_Occurred()) {\n15771\t            PyErr_SetString(PyExc_RuntimeError,\n15772\t                \"Unexpected error in an Op's C code. \"\n15773\t                \"No Python exception was set.\");\n15774\t            }\n15775\t        goto __label_274;}\n15776\t            }\n15777\t            // This is a TypeError to be consistent with DEBUG_MODE\n15778\t            // Note: DEBUG_MODE also tells the name of the container\n15779\t            if (PyArray_TYPE((PyArrayObject*) py_V273) != NPY_FLOAT64) {\n15780\t                PyErr_Format(PyExc_TypeError,\n15781\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n15782\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V273));\n15783\t                {\n15784\t        __failure = 274;\n15785\t        if (!PyErr_Occurred()) {\n15786\t            PyErr_SetString(PyExc_RuntimeError,\n15787\t                \"Unexpected error in an Op's C code. \"\n15788\t                \"No Python exception was set.\");\n15789\t            }\n15790\t        goto __label_274;}\n15791\t            }\n15792\t            \n15793\t        V273 = (PyArrayObject*)(py_V273);\n15794\t        Py_XINCREF(V273);\n15795\t        \n15796\t{\n15797\t\n15798\t    py_V275 = PyList_GET_ITEM(storage_V275, 0);\n15799\t    {Py_XINCREF(py_V275);}\n15800\t    \n15801\t            V275 = NULL;\n15802\t            if (py_V275 == Py_None) {\n15803\t                // We can either fail here or set V275 to NULL and rely on Ops\n15804\t                // using tensors to handle the NULL case, but if they fail to do so\n15805\t                // they'll end up with nasty segfaults, so this is public service.\n15806\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n15807\t                {\n15808\t        __failure = 276;\n15809\t        if (!PyErr_Occurred()) {\n15810\t            PyErr_SetString(PyExc_RuntimeError,\n15811\t                \"Unexpected error in an Op's C code. \"\n15812\t                \"No Python exception was set.\");\n15813\t            }\n15814\t        goto __label_276;}\n15815\t            }\n15816\t            if (!PyArray_Check(py_V275)) {\n15817\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n15818\t                {\n15819\t        __failure = 276;\n15820\t        if (!PyErr_Occurred()) {\n15821\t            PyErr_SetString(PyExc_RuntimeError,\n15822\t                \"Unexpected error in an Op's C code. \"\n15823\t                \"No Python exception was set.\");\n15824\t            }\n15825\t        goto __label_276;}\n15826\t            }\n15827\t            // We expect NPY_FLOAT64\n15828\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V275)) {\n15829\t                PyArrayObject * tmp = (PyArrayObject*) py_V275;\n15830\t                PyErr_Format(PyExc_NotImplementedError,\n15831\t                             \"expected an aligned array of type %ld \"\n15832\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n15833\t                             \" with %ld dimensions, with 3 last dims \"\n15834\t                             \"%ld, %ld, %ld\"\n15835\t                             \" and 3 last strides %ld %ld, %ld.\",\n15836\t                             (long int) NPY_FLOAT64,\n15837\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V275),\n15838\t                             (long int) PyArray_NDIM(tmp),\n15839\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n15840\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n15841\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n15842\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n15843\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n15844\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n15845\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n15846\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n15847\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n15848\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n15849\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n15850\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n15851\t            );\n15852\t                {\n15853\t        __failure = 276;\n15854\t        if (!PyErr_Occurred()) {\n15855\t            PyErr_SetString(PyExc_RuntimeError,\n15856\t                \"Unexpected error in an Op's C code. \"\n15857\t                \"No Python exception was set.\");\n15858\t            }\n15859\t        goto __label_276;}\n15860\t            }\n15861\t            // This is a TypeError to be consistent with DEBUG_MODE\n15862\t            // Note: DEBUG_MODE also tells the name of the container\n15863\t            if (PyArray_TYPE((PyArrayObject*) py_V275) != NPY_FLOAT64) {\n15864\t                PyErr_Format(PyExc_TypeError,\n15865\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n15866\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V275));\n15867\t                {\n15868\t        __failure = 276;\n15869\t        if (!PyErr_Occurred()) {\n15870\t            PyErr_SetString(PyExc_RuntimeError,\n15871\t                \"Unexpected error in an Op's C code. \"\n15872\t                \"No Python exception was set.\");\n15873\t            }\n15874\t        goto __label_276;}\n15875\t            }\n15876\t            \n15877\t        V275 = (PyArrayObject*)(py_V275);\n15878\t        Py_XINCREF(V275);\n15879\t        \n15880\t{\n15881\t\n15882\t    py_V277 = PyList_GET_ITEM(storage_V277, 0);\n15883\t    {Py_XINCREF(py_V277);}\n15884\t    \n15885\t            V277 = NULL;\n15886\t            if (py_V277 == Py_None) {\n15887\t                // We can either fail here or set V277 to NULL and rely on Ops\n15888\t                // using tensors to handle the NULL case, but if they fail to do so\n15889\t                // they'll end up with nasty segfaults, so this is public service.\n15890\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n15891\t                {\n15892\t        __failure = 278;\n15893\t        if (!PyErr_Occurred()) {\n15894\t            PyErr_SetString(PyExc_RuntimeError,\n15895\t                \"Unexpected error in an Op's C code. \"\n15896\t                \"No Python exception was set.\");\n15897\t            }\n15898\t        goto __label_278;}\n15899\t            }\n15900\t            if (!PyArray_Check(py_V277)) {\n15901\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n15902\t                {\n15903\t        __failure = 278;\n15904\t        if (!PyErr_Occurred()) {\n15905\t            PyErr_SetString(PyExc_RuntimeError,\n15906\t                \"Unexpected error in an Op's C code. \"\n15907\t                \"No Python exception was set.\");\n15908\t            }\n15909\t        goto __label_278;}\n15910\t            }\n15911\t            // We expect NPY_FLOAT64\n15912\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V277)) {\n15913\t                PyArrayObject * tmp = (PyArrayObject*) py_V277;\n15914\t                PyErr_Format(PyExc_NotImplementedError,\n15915\t                             \"expected an aligned array of type %ld \"\n15916\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n15917\t                             \" with %ld dimensions, with 3 last dims \"\n15918\t                             \"%ld, %ld, %ld\"\n15919\t                             \" and 3 last strides %ld %ld, %ld.\",\n15920\t                             (long int) NPY_FLOAT64,\n15921\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V277),\n15922\t                             (long int) PyArray_NDIM(tmp),\n15923\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n15924\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n15925\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n15926\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n15927\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n15928\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n15929\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n15930\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n15931\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n15932\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n15933\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n15934\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n15935\t            );\n15936\t                {\n15937\t        __failure = 278;\n15938\t        if (!PyErr_Occurred()) {\n15939\t            PyErr_SetString(PyExc_RuntimeError,\n15940\t                \"Unexpected error in an Op's C code. \"\n15941\t                \"No Python exception was set.\");\n15942\t            }\n15943\t        goto __label_278;}\n15944\t            }\n15945\t            // This is a TypeError to be consistent with DEBUG_MODE\n15946\t            // Note: DEBUG_MODE also tells the name of the container\n15947\t            if (PyArray_TYPE((PyArrayObject*) py_V277) != NPY_FLOAT64) {\n15948\t                PyErr_Format(PyExc_TypeError,\n15949\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n15950\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V277));\n15951\t                {\n15952\t        __failure = 278;\n15953\t        if (!PyErr_Occurred()) {\n15954\t            PyErr_SetString(PyExc_RuntimeError,\n15955\t                \"Unexpected error in an Op's C code. \"\n15956\t                \"No Python exception was set.\");\n15957\t            }\n15958\t        goto __label_278;}\n15959\t            }\n15960\t            \n15961\t        V277 = (PyArrayObject*)(py_V277);\n15962\t        Py_XINCREF(V277);\n15963\t        \n15964\t{\n15965\t\n15966\t    py_V279 = PyList_GET_ITEM(storage_V279, 0);\n15967\t    {Py_XINCREF(py_V279);}\n15968\t    \n15969\t            V279 = NULL;\n15970\t            if (py_V279 == Py_None) {\n15971\t                // We can either fail here or set V279 to NULL and rely on Ops\n15972\t                // using tensors to handle the NULL case, but if they fail to do so\n15973\t                // they'll end up with nasty segfaults, so this is public service.\n15974\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n15975\t                {\n15976\t        __failure = 280;\n15977\t        if (!PyErr_Occurred()) {\n15978\t            PyErr_SetString(PyExc_RuntimeError,\n15979\t                \"Unexpected error in an Op's C code. \"\n15980\t                \"No Python exception was set.\");\n15981\t            }\n15982\t        goto __label_280;}\n15983\t            }\n15984\t            if (!PyArray_Check(py_V279)) {\n15985\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n15986\t                {\n15987\t        __failure = 280;\n15988\t        if (!PyErr_Occurred()) {\n15989\t            PyErr_SetString(PyExc_RuntimeError,\n15990\t                \"Unexpected error in an Op's C code. \"\n15991\t                \"No Python exception was set.\");\n15992\t            }\n15993\t        goto __label_280;}\n15994\t            }\n15995\t            // We expect NPY_FLOAT64\n15996\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V279)) {\n15997\t                PyArrayObject * tmp = (PyArrayObject*) py_V279;\n15998\t                PyErr_Format(PyExc_NotImplementedError,\n15999\t                             \"expected an aligned array of type %ld \"\n16000\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n16001\t                             \" with %ld dimensions, with 3 last dims \"\n16002\t                             \"%ld, %ld, %ld\"\n16003\t                             \" and 3 last strides %ld %ld, %ld.\",\n16004\t                             (long int) NPY_FLOAT64,\n16005\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V279),\n16006\t                             (long int) PyArray_NDIM(tmp),\n16007\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n16008\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n16009\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n16010\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n16011\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n16012\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n16013\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n16014\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n16015\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n16016\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n16017\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n16018\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n16019\t            );\n16020\t                {\n16021\t        __failure = 280;\n16022\t        if (!PyErr_Occurred()) {\n16023\t            PyErr_SetString(PyExc_RuntimeError,\n16024\t                \"Unexpected error in an Op's C code. \"\n16025\t                \"No Python exception was set.\");\n16026\t            }\n16027\t        goto __label_280;}\n16028\t            }\n16029\t            // This is a TypeError to be consistent with DEBUG_MODE\n16030\t            // Note: DEBUG_MODE also tells the name of the container\n16031\t            if (PyArray_TYPE((PyArrayObject*) py_V279) != NPY_FLOAT64) {\n16032\t                PyErr_Format(PyExc_TypeError,\n16033\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n16034\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V279));\n16035\t                {\n16036\t        __failure = 280;\n16037\t        if (!PyErr_Occurred()) {\n16038\t            PyErr_SetString(PyExc_RuntimeError,\n16039\t                \"Unexpected error in an Op's C code. \"\n16040\t                \"No Python exception was set.\");\n16041\t            }\n16042\t        goto __label_280;}\n16043\t            }\n16044\t            \n16045\t        V279 = (PyArrayObject*)(py_V279);\n16046\t        Py_XINCREF(V279);\n16047\t        \n16048\t{\n16049\t\n16050\t    py_V281 = PyList_GET_ITEM(storage_V281, 0);\n16051\t    {Py_XINCREF(py_V281);}\n16052\t    \n16053\t            V281 = NULL;\n16054\t            if (py_V281 == Py_None) {\n16055\t                // We can either fail here or set V281 to NULL and rely on Ops\n16056\t                // using tensors to handle the NULL case, but if they fail to do so\n16057\t                // they'll end up with nasty segfaults, so this is public service.\n16058\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n16059\t                {\n16060\t        __failure = 282;\n16061\t        if (!PyErr_Occurred()) {\n16062\t            PyErr_SetString(PyExc_RuntimeError,\n16063\t                \"Unexpected error in an Op's C code. \"\n16064\t                \"No Python exception was set.\");\n16065\t            }\n16066\t        goto __label_282;}\n16067\t            }\n16068\t            if (!PyArray_Check(py_V281)) {\n16069\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n16070\t                {\n16071\t        __failure = 282;\n16072\t        if (!PyErr_Occurred()) {\n16073\t            PyErr_SetString(PyExc_RuntimeError,\n16074\t                \"Unexpected error in an Op's C code. \"\n16075\t                \"No Python exception was set.\");\n16076\t            }\n16077\t        goto __label_282;}\n16078\t            }\n16079\t            // We expect NPY_FLOAT64\n16080\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V281)) {\n16081\t                PyArrayObject * tmp = (PyArrayObject*) py_V281;\n16082\t                PyErr_Format(PyExc_NotImplementedError,\n16083\t                             \"expected an aligned array of type %ld \"\n16084\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n16085\t                             \" with %ld dimensions, with 3 last dims \"\n16086\t                             \"%ld, %ld, %ld\"\n16087\t                             \" and 3 last strides %ld %ld, %ld.\",\n16088\t                             (long int) NPY_FLOAT64,\n16089\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V281),\n16090\t                             (long int) PyArray_NDIM(tmp),\n16091\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n16092\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n16093\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n16094\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n16095\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n16096\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n16097\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n16098\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n16099\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n16100\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n16101\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n16102\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n16103\t            );\n16104\t                {\n16105\t        __failure = 282;\n16106\t        if (!PyErr_Occurred()) {\n16107\t            PyErr_SetString(PyExc_RuntimeError,\n16108\t                \"Unexpected error in an Op's C code. \"\n16109\t                \"No Python exception was set.\");\n16110\t            }\n16111\t        goto __label_282;}\n16112\t            }\n16113\t            // This is a TypeError to be consistent with DEBUG_MODE\n16114\t            // Note: DEBUG_MODE also tells the name of the container\n16115\t            if (PyArray_TYPE((PyArrayObject*) py_V281) != NPY_FLOAT64) {\n16116\t                PyErr_Format(PyExc_TypeError,\n16117\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n16118\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V281));\n16119\t                {\n16120\t        __failure = 282;\n16121\t        if (!PyErr_Occurred()) {\n16122\t            PyErr_SetString(PyExc_RuntimeError,\n16123\t                \"Unexpected error in an Op's C code. \"\n16124\t                \"No Python exception was set.\");\n16125\t            }\n16126\t        goto __label_282;}\n16127\t            }\n16128\t            \n16129\t        V281 = (PyArrayObject*)(py_V281);\n16130\t        Py_XINCREF(V281);\n16131\t        \n16132\t{\n16133\t\n16134\t    py_V283 = PyList_GET_ITEM(storage_V283, 0);\n16135\t    {Py_XINCREF(py_V283);}\n16136\t    \n16137\t            V283 = NULL;\n16138\t            if (py_V283 == Py_None) {\n16139\t                // We can either fail here or set V283 to NULL and rely on Ops\n16140\t                // using tensors to handle the NULL case, but if they fail to do so\n16141\t                // they'll end up with nasty segfaults, so this is public service.\n16142\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n16143\t                {\n16144\t        __failure = 284;\n16145\t        if (!PyErr_Occurred()) {\n16146\t            PyErr_SetString(PyExc_RuntimeError,\n16147\t                \"Unexpected error in an Op's C code. \"\n16148\t                \"No Python exception was set.\");\n16149\t            }\n16150\t        goto __label_284;}\n16151\t            }\n16152\t            if (!PyArray_Check(py_V283)) {\n16153\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n16154\t                {\n16155\t        __failure = 284;\n16156\t        if (!PyErr_Occurred()) {\n16157\t            PyErr_SetString(PyExc_RuntimeError,\n16158\t                \"Unexpected error in an Op's C code. \"\n16159\t                \"No Python exception was set.\");\n16160\t            }\n16161\t        goto __label_284;}\n16162\t            }\n16163\t            // We expect NPY_FLOAT64\n16164\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V283)) {\n16165\t                PyArrayObject * tmp = (PyArrayObject*) py_V283;\n16166\t                PyErr_Format(PyExc_NotImplementedError,\n16167\t                             \"expected an aligned array of type %ld \"\n16168\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n16169\t                             \" with %ld dimensions, with 3 last dims \"\n16170\t                             \"%ld, %ld, %ld\"\n16171\t                             \" and 3 last strides %ld %ld, %ld.\",\n16172\t                             (long int) NPY_FLOAT64,\n16173\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V283),\n16174\t                             (long int) PyArray_NDIM(tmp),\n16175\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n16176\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n16177\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n16178\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n16179\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n16180\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n16181\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n16182\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n16183\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n16184\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n16185\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n16186\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n16187\t            );\n16188\t                {\n16189\t        __failure = 284;\n16190\t        if (!PyErr_Occurred()) {\n16191\t            PyErr_SetString(PyExc_RuntimeError,\n16192\t                \"Unexpected error in an Op's C code. \"\n16193\t                \"No Python exception was set.\");\n16194\t            }\n16195\t        goto __label_284;}\n16196\t            }\n16197\t            // This is a TypeError to be consistent with DEBUG_MODE\n16198\t            // Note: DEBUG_MODE also tells the name of the container\n16199\t            if (PyArray_TYPE((PyArrayObject*) py_V283) != NPY_FLOAT64) {\n16200\t                PyErr_Format(PyExc_TypeError,\n16201\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n16202\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V283));\n16203\t                {\n16204\t        __failure = 284;\n16205\t        if (!PyErr_Occurred()) {\n16206\t            PyErr_SetString(PyExc_RuntimeError,\n16207\t                \"Unexpected error in an Op's C code. \"\n16208\t                \"No Python exception was set.\");\n16209\t            }\n16210\t        goto __label_284;}\n16211\t            }\n16212\t            \n16213\t        V283 = (PyArrayObject*)(py_V283);\n16214\t        Py_XINCREF(V283);\n16215\t        \n16216\t{\n16217\t\n16218\t    py_V285 = PyList_GET_ITEM(storage_V285, 0);\n16219\t    {Py_XINCREF(py_V285);}\n16220\t    \n16221\t            V285 = NULL;\n16222\t            if (py_V285 == Py_None) {\n16223\t                // We can either fail here or set V285 to NULL and rely on Ops\n16224\t                // using tensors to handle the NULL case, but if they fail to do so\n16225\t                // they'll end up with nasty segfaults, so this is public service.\n16226\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n16227\t                {\n16228\t        __failure = 286;\n16229\t        if (!PyErr_Occurred()) {\n16230\t            PyErr_SetString(PyExc_RuntimeError,\n16231\t                \"Unexpected error in an Op's C code. \"\n16232\t                \"No Python exception was set.\");\n16233\t            }\n16234\t        goto __label_286;}\n16235\t            }\n16236\t            if (!PyArray_Check(py_V285)) {\n16237\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n16238\t                {\n16239\t        __failure = 286;\n16240\t        if (!PyErr_Occurred()) {\n16241\t            PyErr_SetString(PyExc_RuntimeError,\n16242\t                \"Unexpected error in an Op's C code. \"\n16243\t                \"No Python exception was set.\");\n16244\t            }\n16245\t        goto __label_286;}\n16246\t            }\n16247\t            // We expect NPY_FLOAT64\n16248\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V285)) {\n16249\t                PyArrayObject * tmp = (PyArrayObject*) py_V285;\n16250\t                PyErr_Format(PyExc_NotImplementedError,\n16251\t                             \"expected an aligned array of type %ld \"\n16252\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n16253\t                             \" with %ld dimensions, with 3 last dims \"\n16254\t                             \"%ld, %ld, %ld\"\n16255\t                             \" and 3 last strides %ld %ld, %ld.\",\n16256\t                             (long int) NPY_FLOAT64,\n16257\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V285),\n16258\t                             (long int) PyArray_NDIM(tmp),\n16259\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n16260\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n16261\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n16262\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n16263\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n16264\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n16265\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n16266\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n16267\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n16268\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n16269\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n16270\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n16271\t            );\n16272\t                {\n16273\t        __failure = 286;\n16274\t        if (!PyErr_Occurred()) {\n16275\t            PyErr_SetString(PyExc_RuntimeError,\n16276\t                \"Unexpected error in an Op's C code. \"\n16277\t                \"No Python exception was set.\");\n16278\t            }\n16279\t        goto __label_286;}\n16280\t            }\n16281\t            // This is a TypeError to be consistent with DEBUG_MODE\n16282\t            // Note: DEBUG_MODE also tells the name of the container\n16283\t            if (PyArray_TYPE((PyArrayObject*) py_V285) != NPY_FLOAT64) {\n16284\t                PyErr_Format(PyExc_TypeError,\n16285\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n16286\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V285));\n16287\t                {\n16288\t        __failure = 286;\n16289\t        if (!PyErr_Occurred()) {\n16290\t            PyErr_SetString(PyExc_RuntimeError,\n16291\t                \"Unexpected error in an Op's C code. \"\n16292\t                \"No Python exception was set.\");\n16293\t            }\n16294\t        goto __label_286;}\n16295\t            }\n16296\t            \n16297\t        V285 = (PyArrayObject*)(py_V285);\n16298\t        Py_XINCREF(V285);\n16299\t        \n16300\t{\n16301\t\n16302\t    py_V287 = PyList_GET_ITEM(storage_V287, 0);\n16303\t    {Py_XINCREF(py_V287);}\n16304\t    \n16305\t            V287 = NULL;\n16306\t            if (py_V287 == Py_None) {\n16307\t                // We can either fail here or set V287 to NULL and rely on Ops\n16308\t                // using tensors to handle the NULL case, but if they fail to do so\n16309\t                // they'll end up with nasty segfaults, so this is public service.\n16310\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n16311\t                {\n16312\t        __failure = 288;\n16313\t        if (!PyErr_Occurred()) {\n16314\t            PyErr_SetString(PyExc_RuntimeError,\n16315\t                \"Unexpected error in an Op's C code. \"\n16316\t                \"No Python exception was set.\");\n16317\t            }\n16318\t        goto __label_288;}\n16319\t            }\n16320\t            if (!PyArray_Check(py_V287)) {\n16321\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n16322\t                {\n16323\t        __failure = 288;\n16324\t        if (!PyErr_Occurred()) {\n16325\t            PyErr_SetString(PyExc_RuntimeError,\n16326\t                \"Unexpected error in an Op's C code. \"\n16327\t                \"No Python exception was set.\");\n16328\t            }\n16329\t        goto __label_288;}\n16330\t            }\n16331\t            // We expect NPY_FLOAT64\n16332\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V287)) {\n16333\t                PyArrayObject * tmp = (PyArrayObject*) py_V287;\n16334\t                PyErr_Format(PyExc_NotImplementedError,\n16335\t                             \"expected an aligned array of type %ld \"\n16336\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n16337\t                             \" with %ld dimensions, with 3 last dims \"\n16338\t                             \"%ld, %ld, %ld\"\n16339\t                             \" and 3 last strides %ld %ld, %ld.\",\n16340\t                             (long int) NPY_FLOAT64,\n16341\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V287),\n16342\t                             (long int) PyArray_NDIM(tmp),\n16343\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n16344\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n16345\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n16346\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n16347\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n16348\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n16349\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n16350\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n16351\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n16352\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n16353\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n16354\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n16355\t            );\n16356\t                {\n16357\t        __failure = 288;\n16358\t        if (!PyErr_Occurred()) {\n16359\t            PyErr_SetString(PyExc_RuntimeError,\n16360\t                \"Unexpected error in an Op's C code. \"\n16361\t                \"No Python exception was set.\");\n16362\t            }\n16363\t        goto __label_288;}\n16364\t            }\n16365\t            // This is a TypeError to be consistent with DEBUG_MODE\n16366\t            // Note: DEBUG_MODE also tells the name of the container\n16367\t            if (PyArray_TYPE((PyArrayObject*) py_V287) != NPY_FLOAT64) {\n16368\t                PyErr_Format(PyExc_TypeError,\n16369\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n16370\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V287));\n16371\t                {\n16372\t        __failure = 288;\n16373\t        if (!PyErr_Occurred()) {\n16374\t            PyErr_SetString(PyExc_RuntimeError,\n16375\t                \"Unexpected error in an Op's C code. \"\n16376\t                \"No Python exception was set.\");\n16377\t            }\n16378\t        goto __label_288;}\n16379\t            }\n16380\t            \n16381\t        V287 = (PyArrayObject*)(py_V287);\n16382\t        Py_XINCREF(V287);\n16383\t        \n16384\t{\n16385\t\n16386\t    py_V289 = PyList_GET_ITEM(storage_V289, 0);\n16387\t    {Py_XINCREF(py_V289);}\n16388\t    \n16389\t            V289 = NULL;\n16390\t            if (py_V289 == Py_None) {\n16391\t                // We can either fail here or set V289 to NULL and rely on Ops\n16392\t                // using tensors to handle the NULL case, but if they fail to do so\n16393\t                // they'll end up with nasty segfaults, so this is public service.\n16394\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n16395\t                {\n16396\t        __failure = 290;\n16397\t        if (!PyErr_Occurred()) {\n16398\t            PyErr_SetString(PyExc_RuntimeError,\n16399\t                \"Unexpected error in an Op's C code. \"\n16400\t                \"No Python exception was set.\");\n16401\t            }\n16402\t        goto __label_290;}\n16403\t            }\n16404\t            if (!PyArray_Check(py_V289)) {\n16405\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n16406\t                {\n16407\t        __failure = 290;\n16408\t        if (!PyErr_Occurred()) {\n16409\t            PyErr_SetString(PyExc_RuntimeError,\n16410\t                \"Unexpected error in an Op's C code. \"\n16411\t                \"No Python exception was set.\");\n16412\t            }\n16413\t        goto __label_290;}\n16414\t            }\n16415\t            // We expect NPY_FLOAT64\n16416\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V289)) {\n16417\t                PyArrayObject * tmp = (PyArrayObject*) py_V289;\n16418\t                PyErr_Format(PyExc_NotImplementedError,\n16419\t                             \"expected an aligned array of type %ld \"\n16420\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n16421\t                             \" with %ld dimensions, with 3 last dims \"\n16422\t                             \"%ld, %ld, %ld\"\n16423\t                             \" and 3 last strides %ld %ld, %ld.\",\n16424\t                             (long int) NPY_FLOAT64,\n16425\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V289),\n16426\t                             (long int) PyArray_NDIM(tmp),\n16427\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n16428\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n16429\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n16430\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n16431\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n16432\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n16433\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n16434\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n16435\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n16436\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n16437\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n16438\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n16439\t            );\n16440\t                {\n16441\t        __failure = 290;\n16442\t        if (!PyErr_Occurred()) {\n16443\t            PyErr_SetString(PyExc_RuntimeError,\n16444\t                \"Unexpected error in an Op's C code. \"\n16445\t                \"No Python exception was set.\");\n16446\t            }\n16447\t        goto __label_290;}\n16448\t            }\n16449\t            // This is a TypeError to be consistent with DEBUG_MODE\n16450\t            // Note: DEBUG_MODE also tells the name of the container\n16451\t            if (PyArray_TYPE((PyArrayObject*) py_V289) != NPY_FLOAT64) {\n16452\t                PyErr_Format(PyExc_TypeError,\n16453\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n16454\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V289));\n16455\t                {\n16456\t        __failure = 290;\n16457\t        if (!PyErr_Occurred()) {\n16458\t            PyErr_SetString(PyExc_RuntimeError,\n16459\t                \"Unexpected error in an Op's C code. \"\n16460\t                \"No Python exception was set.\");\n16461\t            }\n16462\t        goto __label_290;}\n16463\t            }\n16464\t            \n16465\t        V289 = (PyArrayObject*)(py_V289);\n16466\t        Py_XINCREF(V289);\n16467\t        \n16468\t{\n16469\t\n16470\t    py_V291 = PyList_GET_ITEM(storage_V291, 0);\n16471\t    {Py_XINCREF(py_V291);}\n16472\t    \n16473\t            V291 = NULL;\n16474\t            if (py_V291 == Py_None) {\n16475\t                // We can either fail here or set V291 to NULL and rely on Ops\n16476\t                // using tensors to handle the NULL case, but if they fail to do so\n16477\t                // they'll end up with nasty segfaults, so this is public service.\n16478\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n16479\t                {\n16480\t        __failure = 292;\n16481\t        if (!PyErr_Occurred()) {\n16482\t            PyErr_SetString(PyExc_RuntimeError,\n16483\t                \"Unexpected error in an Op's C code. \"\n16484\t                \"No Python exception was set.\");\n16485\t            }\n16486\t        goto __label_292;}\n16487\t            }\n16488\t            if (!PyArray_Check(py_V291)) {\n16489\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n16490\t                {\n16491\t        __failure = 292;\n16492\t        if (!PyErr_Occurred()) {\n16493\t            PyErr_SetString(PyExc_RuntimeError,\n16494\t                \"Unexpected error in an Op's C code. \"\n16495\t                \"No Python exception was set.\");\n16496\t            }\n16497\t        goto __label_292;}\n16498\t            }\n16499\t            // We expect NPY_FLOAT64\n16500\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V291)) {\n16501\t                PyArrayObject * tmp = (PyArrayObject*) py_V291;\n16502\t                PyErr_Format(PyExc_NotImplementedError,\n16503\t                             \"expected an aligned array of type %ld \"\n16504\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n16505\t                             \" with %ld dimensions, with 3 last dims \"\n16506\t                             \"%ld, %ld, %ld\"\n16507\t                             \" and 3 last strides %ld %ld, %ld.\",\n16508\t                             (long int) NPY_FLOAT64,\n16509\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V291),\n16510\t                             (long int) PyArray_NDIM(tmp),\n16511\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n16512\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n16513\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n16514\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n16515\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n16516\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n16517\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n16518\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n16519\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n16520\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n16521\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n16522\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n16523\t            );\n16524\t                {\n16525\t        __failure = 292;\n16526\t        if (!PyErr_Occurred()) {\n16527\t            PyErr_SetString(PyExc_RuntimeError,\n16528\t                \"Unexpected error in an Op's C code. \"\n16529\t                \"No Python exception was set.\");\n16530\t            }\n16531\t        goto __label_292;}\n16532\t            }\n16533\t            // This is a TypeError to be consistent with DEBUG_MODE\n16534\t            // Note: DEBUG_MODE also tells the name of the container\n16535\t            if (PyArray_TYPE((PyArrayObject*) py_V291) != NPY_FLOAT64) {\n16536\t                PyErr_Format(PyExc_TypeError,\n16537\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n16538\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V291));\n16539\t                {\n16540\t        __failure = 292;\n16541\t        if (!PyErr_Occurred()) {\n16542\t            PyErr_SetString(PyExc_RuntimeError,\n16543\t                \"Unexpected error in an Op's C code. \"\n16544\t                \"No Python exception was set.\");\n16545\t            }\n16546\t        goto __label_292;}\n16547\t            }\n16548\t            \n16549\t        V291 = (PyArrayObject*)(py_V291);\n16550\t        Py_XINCREF(V291);\n16551\t        \n16552\t{\n16553\t\n16554\t    py_V293 = PyList_GET_ITEM(storage_V293, 0);\n16555\t    {Py_XINCREF(py_V293);}\n16556\t    \n16557\t            V293 = NULL;\n16558\t            if (py_V293 == Py_None) {\n16559\t                // We can either fail here or set V293 to NULL and rely on Ops\n16560\t                // using tensors to handle the NULL case, but if they fail to do so\n16561\t                // they'll end up with nasty segfaults, so this is public service.\n16562\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n16563\t                {\n16564\t        __failure = 294;\n16565\t        if (!PyErr_Occurred()) {\n16566\t            PyErr_SetString(PyExc_RuntimeError,\n16567\t                \"Unexpected error in an Op's C code. \"\n16568\t                \"No Python exception was set.\");\n16569\t            }\n16570\t        goto __label_294;}\n16571\t            }\n16572\t            if (!PyArray_Check(py_V293)) {\n16573\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n16574\t                {\n16575\t        __failure = 294;\n16576\t        if (!PyErr_Occurred()) {\n16577\t            PyErr_SetString(PyExc_RuntimeError,\n16578\t                \"Unexpected error in an Op's C code. \"\n16579\t                \"No Python exception was set.\");\n16580\t            }\n16581\t        goto __label_294;}\n16582\t            }\n16583\t            // We expect NPY_FLOAT64\n16584\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V293)) {\n16585\t                PyArrayObject * tmp = (PyArrayObject*) py_V293;\n16586\t                PyErr_Format(PyExc_NotImplementedError,\n16587\t                             \"expected an aligned array of type %ld \"\n16588\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n16589\t                             \" with %ld dimensions, with 3 last dims \"\n16590\t                             \"%ld, %ld, %ld\"\n16591\t                             \" and 3 last strides %ld %ld, %ld.\",\n16592\t                             (long int) NPY_FLOAT64,\n16593\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V293),\n16594\t                             (long int) PyArray_NDIM(tmp),\n16595\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n16596\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n16597\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n16598\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n16599\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n16600\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n16601\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n16602\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n16603\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n16604\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n16605\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n16606\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n16607\t            );\n16608\t                {\n16609\t        __failure = 294;\n16610\t        if (!PyErr_Occurred()) {\n16611\t            PyErr_SetString(PyExc_RuntimeError,\n16612\t                \"Unexpected error in an Op's C code. \"\n16613\t                \"No Python exception was set.\");\n16614\t            }\n16615\t        goto __label_294;}\n16616\t            }\n16617\t            // This is a TypeError to be consistent with DEBUG_MODE\n16618\t            // Note: DEBUG_MODE also tells the name of the container\n16619\t            if (PyArray_TYPE((PyArrayObject*) py_V293) != NPY_FLOAT64) {\n16620\t                PyErr_Format(PyExc_TypeError,\n16621\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n16622\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V293));\n16623\t                {\n16624\t        __failure = 294;\n16625\t        if (!PyErr_Occurred()) {\n16626\t            PyErr_SetString(PyExc_RuntimeError,\n16627\t                \"Unexpected error in an Op's C code. \"\n16628\t                \"No Python exception was set.\");\n16629\t            }\n16630\t        goto __label_294;}\n16631\t            }\n16632\t            \n16633\t        V293 = (PyArrayObject*)(py_V293);\n16634\t        Py_XINCREF(V293);\n16635\t        \n16636\t{\n16637\t\n16638\t    py_V295 = PyList_GET_ITEM(storage_V295, 0);\n16639\t    {Py_XINCREF(py_V295);}\n16640\t    \n16641\t            V295 = NULL;\n16642\t            if (py_V295 == Py_None) {\n16643\t                // We can either fail here or set V295 to NULL and rely on Ops\n16644\t                // using tensors to handle the NULL case, but if they fail to do so\n16645\t                // they'll end up with nasty segfaults, so this is public service.\n16646\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n16647\t                {\n16648\t        __failure = 296;\n16649\t        if (!PyErr_Occurred()) {\n16650\t            PyErr_SetString(PyExc_RuntimeError,\n16651\t                \"Unexpected error in an Op's C code. \"\n16652\t                \"No Python exception was set.\");\n16653\t            }\n16654\t        goto __label_296;}\n16655\t            }\n16656\t            if (!PyArray_Check(py_V295)) {\n16657\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n16658\t                {\n16659\t        __failure = 296;\n16660\t        if (!PyErr_Occurred()) {\n16661\t            PyErr_SetString(PyExc_RuntimeError,\n16662\t                \"Unexpected error in an Op's C code. \"\n16663\t                \"No Python exception was set.\");\n16664\t            }\n16665\t        goto __label_296;}\n16666\t            }\n16667\t            // We expect NPY_FLOAT64\n16668\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V295)) {\n16669\t                PyArrayObject * tmp = (PyArrayObject*) py_V295;\n16670\t                PyErr_Format(PyExc_NotImplementedError,\n16671\t                             \"expected an aligned array of type %ld \"\n16672\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n16673\t                             \" with %ld dimensions, with 3 last dims \"\n16674\t                             \"%ld, %ld, %ld\"\n16675\t                             \" and 3 last strides %ld %ld, %ld.\",\n16676\t                             (long int) NPY_FLOAT64,\n16677\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V295),\n16678\t                             (long int) PyArray_NDIM(tmp),\n16679\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n16680\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n16681\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n16682\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n16683\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n16684\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n16685\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n16686\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n16687\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n16688\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n16689\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n16690\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n16691\t            );\n16692\t                {\n16693\t        __failure = 296;\n16694\t        if (!PyErr_Occurred()) {\n16695\t            PyErr_SetString(PyExc_RuntimeError,\n16696\t                \"Unexpected error in an Op's C code. \"\n16697\t                \"No Python exception was set.\");\n16698\t            }\n16699\t        goto __label_296;}\n16700\t            }\n16701\t            // This is a TypeError to be consistent with DEBUG_MODE\n16702\t            // Note: DEBUG_MODE also tells the name of the container\n16703\t            if (PyArray_TYPE((PyArrayObject*) py_V295) != NPY_FLOAT64) {\n16704\t                PyErr_Format(PyExc_TypeError,\n16705\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n16706\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V295));\n16707\t                {\n16708\t        __failure = 296;\n16709\t        if (!PyErr_Occurred()) {\n16710\t            PyErr_SetString(PyExc_RuntimeError,\n16711\t                \"Unexpected error in an Op's C code. \"\n16712\t                \"No Python exception was set.\");\n16713\t            }\n16714\t        goto __label_296;}\n16715\t            }\n16716\t            \n16717\t        V295 = (PyArrayObject*)(py_V295);\n16718\t        Py_XINCREF(V295);\n16719\t        \n16720\t{\n16721\t\n16722\t    py_V297 = PyList_GET_ITEM(storage_V297, 0);\n16723\t    {Py_XINCREF(py_V297);}\n16724\t    \n16725\t            V297 = NULL;\n16726\t            if (py_V297 == Py_None) {\n16727\t                // We can either fail here or set V297 to NULL and rely on Ops\n16728\t                // using tensors to handle the NULL case, but if they fail to do so\n16729\t                // they'll end up with nasty segfaults, so this is public service.\n16730\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n16731\t                {\n16732\t        __failure = 298;\n16733\t        if (!PyErr_Occurred()) {\n16734\t            PyErr_SetString(PyExc_RuntimeError,\n16735\t                \"Unexpected error in an Op's C code. \"\n16736\t                \"No Python exception was set.\");\n16737\t            }\n16738\t        goto __label_298;}\n16739\t            }\n16740\t            if (!PyArray_Check(py_V297)) {\n16741\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n16742\t                {\n16743\t        __failure = 298;\n16744\t        if (!PyErr_Occurred()) {\n16745\t            PyErr_SetString(PyExc_RuntimeError,\n16746\t                \"Unexpected error in an Op's C code. \"\n16747\t                \"No Python exception was set.\");\n16748\t            }\n16749\t        goto __label_298;}\n16750\t            }\n16751\t            // We expect NPY_FLOAT64\n16752\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V297)) {\n16753\t                PyArrayObject * tmp = (PyArrayObject*) py_V297;\n16754\t                PyErr_Format(PyExc_NotImplementedError,\n16755\t                             \"expected an aligned array of type %ld \"\n16756\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n16757\t                             \" with %ld dimensions, with 3 last dims \"\n16758\t                             \"%ld, %ld, %ld\"\n16759\t                             \" and 3 last strides %ld %ld, %ld.\",\n16760\t                             (long int) NPY_FLOAT64,\n16761\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V297),\n16762\t                             (long int) PyArray_NDIM(tmp),\n16763\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n16764\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n16765\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n16766\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n16767\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n16768\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n16769\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n16770\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n16771\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n16772\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n16773\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n16774\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n16775\t            );\n16776\t                {\n16777\t        __failure = 298;\n16778\t        if (!PyErr_Occurred()) {\n16779\t            PyErr_SetString(PyExc_RuntimeError,\n16780\t                \"Unexpected error in an Op's C code. \"\n16781\t                \"No Python exception was set.\");\n16782\t            }\n16783\t        goto __label_298;}\n16784\t            }\n16785\t            // This is a TypeError to be consistent with DEBUG_MODE\n16786\t            // Note: DEBUG_MODE also tells the name of the container\n16787\t            if (PyArray_TYPE((PyArrayObject*) py_V297) != NPY_FLOAT64) {\n16788\t                PyErr_Format(PyExc_TypeError,\n16789\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n16790\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V297));\n16791\t                {\n16792\t        __failure = 298;\n16793\t        if (!PyErr_Occurred()) {\n16794\t            PyErr_SetString(PyExc_RuntimeError,\n16795\t                \"Unexpected error in an Op's C code. \"\n16796\t                \"No Python exception was set.\");\n16797\t            }\n16798\t        goto __label_298;}\n16799\t            }\n16800\t            \n16801\t        V297 = (PyArrayObject*)(py_V297);\n16802\t        Py_XINCREF(V297);\n16803\t        \n16804\t{\n16805\t\n16806\t    py_V299 = PyList_GET_ITEM(storage_V299, 0);\n16807\t    {Py_XINCREF(py_V299);}\n16808\t    \n16809\t            V299 = NULL;\n16810\t            if (py_V299 == Py_None) {\n16811\t                // We can either fail here or set V299 to NULL and rely on Ops\n16812\t                // using tensors to handle the NULL case, but if they fail to do so\n16813\t                // they'll end up with nasty segfaults, so this is public service.\n16814\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n16815\t                {\n16816\t        __failure = 300;\n16817\t        if (!PyErr_Occurred()) {\n16818\t            PyErr_SetString(PyExc_RuntimeError,\n16819\t                \"Unexpected error in an Op's C code. \"\n16820\t                \"No Python exception was set.\");\n16821\t            }\n16822\t        goto __label_300;}\n16823\t            }\n16824\t            if (!PyArray_Check(py_V299)) {\n16825\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n16826\t                {\n16827\t        __failure = 300;\n16828\t        if (!PyErr_Occurred()) {\n16829\t            PyErr_SetString(PyExc_RuntimeError,\n16830\t                \"Unexpected error in an Op's C code. \"\n16831\t                \"No Python exception was set.\");\n16832\t            }\n16833\t        goto __label_300;}\n16834\t            }\n16835\t            // We expect NPY_FLOAT64\n16836\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V299)) {\n16837\t                PyArrayObject * tmp = (PyArrayObject*) py_V299;\n16838\t                PyErr_Format(PyExc_NotImplementedError,\n16839\t                             \"expected an aligned array of type %ld \"\n16840\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n16841\t                             \" with %ld dimensions, with 3 last dims \"\n16842\t                             \"%ld, %ld, %ld\"\n16843\t                             \" and 3 last strides %ld %ld, %ld.\",\n16844\t                             (long int) NPY_FLOAT64,\n16845\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V299),\n16846\t                             (long int) PyArray_NDIM(tmp),\n16847\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n16848\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n16849\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n16850\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n16851\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n16852\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n16853\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n16854\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n16855\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n16856\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n16857\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n16858\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n16859\t            );\n16860\t                {\n16861\t        __failure = 300;\n16862\t        if (!PyErr_Occurred()) {\n16863\t            PyErr_SetString(PyExc_RuntimeError,\n16864\t                \"Unexpected error in an Op's C code. \"\n16865\t                \"No Python exception was set.\");\n16866\t            }\n16867\t        goto __label_300;}\n16868\t            }\n16869\t            // This is a TypeError to be consistent with DEBUG_MODE\n16870\t            // Note: DEBUG_MODE also tells the name of the container\n16871\t            if (PyArray_TYPE((PyArrayObject*) py_V299) != NPY_FLOAT64) {\n16872\t                PyErr_Format(PyExc_TypeError,\n16873\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n16874\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V299));\n16875\t                {\n16876\t        __failure = 300;\n16877\t        if (!PyErr_Occurred()) {\n16878\t            PyErr_SetString(PyExc_RuntimeError,\n16879\t                \"Unexpected error in an Op's C code. \"\n16880\t                \"No Python exception was set.\");\n16881\t            }\n16882\t        goto __label_300;}\n16883\t            }\n16884\t            \n16885\t        V299 = (PyArrayObject*)(py_V299);\n16886\t        Py_XINCREF(V299);\n16887\t        \n16888\t{\n16889\t\n16890\t    py_V301 = PyList_GET_ITEM(storage_V301, 0);\n16891\t    {Py_XINCREF(py_V301);}\n16892\t    \n16893\t            V301 = NULL;\n16894\t            if (py_V301 == Py_None) {\n16895\t                // We can either fail here or set V301 to NULL and rely on Ops\n16896\t                // using tensors to handle the NULL case, but if they fail to do so\n16897\t                // they'll end up with nasty segfaults, so this is public service.\n16898\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n16899\t                {\n16900\t        __failure = 302;\n16901\t        if (!PyErr_Occurred()) {\n16902\t            PyErr_SetString(PyExc_RuntimeError,\n16903\t                \"Unexpected error in an Op's C code. \"\n16904\t                \"No Python exception was set.\");\n16905\t            }\n16906\t        goto __label_302;}\n16907\t            }\n16908\t            if (!PyArray_Check(py_V301)) {\n16909\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n16910\t                {\n16911\t        __failure = 302;\n16912\t        if (!PyErr_Occurred()) {\n16913\t            PyErr_SetString(PyExc_RuntimeError,\n16914\t                \"Unexpected error in an Op's C code. \"\n16915\t                \"No Python exception was set.\");\n16916\t            }\n16917\t        goto __label_302;}\n16918\t            }\n16919\t            // We expect NPY_FLOAT64\n16920\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V301)) {\n16921\t                PyArrayObject * tmp = (PyArrayObject*) py_V301;\n16922\t                PyErr_Format(PyExc_NotImplementedError,\n16923\t                             \"expected an aligned array of type %ld \"\n16924\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n16925\t                             \" with %ld dimensions, with 3 last dims \"\n16926\t                             \"%ld, %ld, %ld\"\n16927\t                             \" and 3 last strides %ld %ld, %ld.\",\n16928\t                             (long int) NPY_FLOAT64,\n16929\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V301),\n16930\t                             (long int) PyArray_NDIM(tmp),\n16931\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n16932\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n16933\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n16934\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n16935\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n16936\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n16937\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n16938\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n16939\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n16940\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n16941\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n16942\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n16943\t            );\n16944\t                {\n16945\t        __failure = 302;\n16946\t        if (!PyErr_Occurred()) {\n16947\t            PyErr_SetString(PyExc_RuntimeError,\n16948\t                \"Unexpected error in an Op's C code. \"\n16949\t                \"No Python exception was set.\");\n16950\t            }\n16951\t        goto __label_302;}\n16952\t            }\n16953\t            // This is a TypeError to be consistent with DEBUG_MODE\n16954\t            // Note: DEBUG_MODE also tells the name of the container\n16955\t            if (PyArray_TYPE((PyArrayObject*) py_V301) != NPY_FLOAT64) {\n16956\t                PyErr_Format(PyExc_TypeError,\n16957\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n16958\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V301));\n16959\t                {\n16960\t        __failure = 302;\n16961\t        if (!PyErr_Occurred()) {\n16962\t            PyErr_SetString(PyExc_RuntimeError,\n16963\t                \"Unexpected error in an Op's C code. \"\n16964\t                \"No Python exception was set.\");\n16965\t            }\n16966\t        goto __label_302;}\n16967\t            }\n16968\t            \n16969\t        V301 = (PyArrayObject*)(py_V301);\n16970\t        Py_XINCREF(V301);\n16971\t        \n16972\t{\n16973\t\n16974\t    py_V303 = PyList_GET_ITEM(storage_V303, 0);\n16975\t    {Py_XINCREF(py_V303);}\n16976\t    \n16977\t            V303 = NULL;\n16978\t            if (py_V303 == Py_None) {\n16979\t                // We can either fail here or set V303 to NULL and rely on Ops\n16980\t                // using tensors to handle the NULL case, but if they fail to do so\n16981\t                // they'll end up with nasty segfaults, so this is public service.\n16982\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n16983\t                {\n16984\t        __failure = 304;\n16985\t        if (!PyErr_Occurred()) {\n16986\t            PyErr_SetString(PyExc_RuntimeError,\n16987\t                \"Unexpected error in an Op's C code. \"\n16988\t                \"No Python exception was set.\");\n16989\t            }\n16990\t        goto __label_304;}\n16991\t            }\n16992\t            if (!PyArray_Check(py_V303)) {\n16993\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n16994\t                {\n16995\t        __failure = 304;\n16996\t        if (!PyErr_Occurred()) {\n16997\t            PyErr_SetString(PyExc_RuntimeError,\n16998\t                \"Unexpected error in an Op's C code. \"\n16999\t                \"No Python exception was set.\");\n17000\t            }\n17001\t        goto __label_304;}\n17002\t            }\n17003\t            // We expect NPY_FLOAT64\n17004\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V303)) {\n17005\t                PyArrayObject * tmp = (PyArrayObject*) py_V303;\n17006\t                PyErr_Format(PyExc_NotImplementedError,\n17007\t                             \"expected an aligned array of type %ld \"\n17008\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n17009\t                             \" with %ld dimensions, with 3 last dims \"\n17010\t                             \"%ld, %ld, %ld\"\n17011\t                             \" and 3 last strides %ld %ld, %ld.\",\n17012\t                             (long int) NPY_FLOAT64,\n17013\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V303),\n17014\t                             (long int) PyArray_NDIM(tmp),\n17015\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n17016\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n17017\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n17018\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n17019\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n17020\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n17021\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n17022\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n17023\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n17024\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n17025\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n17026\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n17027\t            );\n17028\t                {\n17029\t        __failure = 304;\n17030\t        if (!PyErr_Occurred()) {\n17031\t            PyErr_SetString(PyExc_RuntimeError,\n17032\t                \"Unexpected error in an Op's C code. \"\n17033\t                \"No Python exception was set.\");\n17034\t            }\n17035\t        goto __label_304;}\n17036\t            }\n17037\t            // This is a TypeError to be consistent with DEBUG_MODE\n17038\t            // Note: DEBUG_MODE also tells the name of the container\n17039\t            if (PyArray_TYPE((PyArrayObject*) py_V303) != NPY_FLOAT64) {\n17040\t                PyErr_Format(PyExc_TypeError,\n17041\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n17042\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V303));\n17043\t                {\n17044\t        __failure = 304;\n17045\t        if (!PyErr_Occurred()) {\n17046\t            PyErr_SetString(PyExc_RuntimeError,\n17047\t                \"Unexpected error in an Op's C code. \"\n17048\t                \"No Python exception was set.\");\n17049\t            }\n17050\t        goto __label_304;}\n17051\t            }\n17052\t            \n17053\t        V303 = (PyArrayObject*)(py_V303);\n17054\t        Py_XINCREF(V303);\n17055\t        \n17056\t{\n17057\t\n17058\t    py_V305 = PyList_GET_ITEM(storage_V305, 0);\n17059\t    {Py_XINCREF(py_V305);}\n17060\t    \n17061\t            V305 = NULL;\n17062\t            if (py_V305 == Py_None) {\n17063\t                // We can either fail here or set V305 to NULL and rely on Ops\n17064\t                // using tensors to handle the NULL case, but if they fail to do so\n17065\t                // they'll end up with nasty segfaults, so this is public service.\n17066\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n17067\t                {\n17068\t        __failure = 306;\n17069\t        if (!PyErr_Occurred()) {\n17070\t            PyErr_SetString(PyExc_RuntimeError,\n17071\t                \"Unexpected error in an Op's C code. \"\n17072\t                \"No Python exception was set.\");\n17073\t            }\n17074\t        goto __label_306;}\n17075\t            }\n17076\t            if (!PyArray_Check(py_V305)) {\n17077\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n17078\t                {\n17079\t        __failure = 306;\n17080\t        if (!PyErr_Occurred()) {\n17081\t            PyErr_SetString(PyExc_RuntimeError,\n17082\t                \"Unexpected error in an Op's C code. \"\n17083\t                \"No Python exception was set.\");\n17084\t            }\n17085\t        goto __label_306;}\n17086\t            }\n17087\t            // We expect NPY_FLOAT64\n17088\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V305)) {\n17089\t                PyArrayObject * tmp = (PyArrayObject*) py_V305;\n17090\t                PyErr_Format(PyExc_NotImplementedError,\n17091\t                             \"expected an aligned array of type %ld \"\n17092\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n17093\t                             \" with %ld dimensions, with 3 last dims \"\n17094\t                             \"%ld, %ld, %ld\"\n17095\t                             \" and 3 last strides %ld %ld, %ld.\",\n17096\t                             (long int) NPY_FLOAT64,\n17097\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V305),\n17098\t                             (long int) PyArray_NDIM(tmp),\n17099\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n17100\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n17101\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n17102\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n17103\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n17104\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n17105\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n17106\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n17107\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n17108\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n17109\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n17110\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n17111\t            );\n17112\t                {\n17113\t        __failure = 306;\n17114\t        if (!PyErr_Occurred()) {\n17115\t            PyErr_SetString(PyExc_RuntimeError,\n17116\t                \"Unexpected error in an Op's C code. \"\n17117\t                \"No Python exception was set.\");\n17118\t            }\n17119\t        goto __label_306;}\n17120\t            }\n17121\t            // This is a TypeError to be consistent with DEBUG_MODE\n17122\t            // Note: DEBUG_MODE also tells the name of the container\n17123\t            if (PyArray_TYPE((PyArrayObject*) py_V305) != NPY_FLOAT64) {\n17124\t                PyErr_Format(PyExc_TypeError,\n17125\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n17126\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V305));\n17127\t                {\n17128\t        __failure = 306;\n17129\t        if (!PyErr_Occurred()) {\n17130\t            PyErr_SetString(PyExc_RuntimeError,\n17131\t                \"Unexpected error in an Op's C code. \"\n17132\t                \"No Python exception was set.\");\n17133\t            }\n17134\t        goto __label_306;}\n17135\t            }\n17136\t            \n17137\t        V305 = (PyArrayObject*)(py_V305);\n17138\t        Py_XINCREF(V305);\n17139\t        \n17140\t{\n17141\t\n17142\t    py_V307 = PyList_GET_ITEM(storage_V307, 0);\n17143\t    {Py_XINCREF(py_V307);}\n17144\t    \n17145\t            V307 = NULL;\n17146\t            if (py_V307 == Py_None) {\n17147\t                // We can either fail here or set V307 to NULL and rely on Ops\n17148\t                // using tensors to handle the NULL case, but if they fail to do so\n17149\t                // they'll end up with nasty segfaults, so this is public service.\n17150\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n17151\t                {\n17152\t        __failure = 308;\n17153\t        if (!PyErr_Occurred()) {\n17154\t            PyErr_SetString(PyExc_RuntimeError,\n17155\t                \"Unexpected error in an Op's C code. \"\n17156\t                \"No Python exception was set.\");\n17157\t            }\n17158\t        goto __label_308;}\n17159\t            }\n17160\t            if (!PyArray_Check(py_V307)) {\n17161\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n17162\t                {\n17163\t        __failure = 308;\n17164\t        if (!PyErr_Occurred()) {\n17165\t            PyErr_SetString(PyExc_RuntimeError,\n17166\t                \"Unexpected error in an Op's C code. \"\n17167\t                \"No Python exception was set.\");\n17168\t            }\n17169\t        goto __label_308;}\n17170\t            }\n17171\t            // We expect NPY_FLOAT64\n17172\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V307)) {\n17173\t                PyArrayObject * tmp = (PyArrayObject*) py_V307;\n17174\t                PyErr_Format(PyExc_NotImplementedError,\n17175\t                             \"expected an aligned array of type %ld \"\n17176\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n17177\t                             \" with %ld dimensions, with 3 last dims \"\n17178\t                             \"%ld, %ld, %ld\"\n17179\t                             \" and 3 last strides %ld %ld, %ld.\",\n17180\t                             (long int) NPY_FLOAT64,\n17181\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V307),\n17182\t                             (long int) PyArray_NDIM(tmp),\n17183\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n17184\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n17185\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n17186\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n17187\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n17188\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n17189\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n17190\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n17191\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n17192\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n17193\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n17194\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n17195\t            );\n17196\t                {\n17197\t        __failure = 308;\n17198\t        if (!PyErr_Occurred()) {\n17199\t            PyErr_SetString(PyExc_RuntimeError,\n17200\t                \"Unexpected error in an Op's C code. \"\n17201\t                \"No Python exception was set.\");\n17202\t            }\n17203\t        goto __label_308;}\n17204\t            }\n17205\t            // This is a TypeError to be consistent with DEBUG_MODE\n17206\t            // Note: DEBUG_MODE also tells the name of the container\n17207\t            if (PyArray_TYPE((PyArrayObject*) py_V307) != NPY_FLOAT64) {\n17208\t                PyErr_Format(PyExc_TypeError,\n17209\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n17210\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V307));\n17211\t                {\n17212\t        __failure = 308;\n17213\t        if (!PyErr_Occurred()) {\n17214\t            PyErr_SetString(PyExc_RuntimeError,\n17215\t                \"Unexpected error in an Op's C code. \"\n17216\t                \"No Python exception was set.\");\n17217\t            }\n17218\t        goto __label_308;}\n17219\t            }\n17220\t            \n17221\t        V307 = (PyArrayObject*)(py_V307);\n17222\t        Py_XINCREF(V307);\n17223\t        \n17224\t{\n17225\t\n17226\t    py_V309 = PyList_GET_ITEM(storage_V309, 0);\n17227\t    {Py_XINCREF(py_V309);}\n17228\t    \n17229\t            V309 = NULL;\n17230\t            if (py_V309 == Py_None) {\n17231\t                // We can either fail here or set V309 to NULL and rely on Ops\n17232\t                // using tensors to handle the NULL case, but if they fail to do so\n17233\t                // they'll end up with nasty segfaults, so this is public service.\n17234\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n17235\t                {\n17236\t        __failure = 310;\n17237\t        if (!PyErr_Occurred()) {\n17238\t            PyErr_SetString(PyExc_RuntimeError,\n17239\t                \"Unexpected error in an Op's C code. \"\n17240\t                \"No Python exception was set.\");\n17241\t            }\n17242\t        goto __label_310;}\n17243\t            }\n17244\t            if (!PyArray_Check(py_V309)) {\n17245\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n17246\t                {\n17247\t        __failure = 310;\n17248\t        if (!PyErr_Occurred()) {\n17249\t            PyErr_SetString(PyExc_RuntimeError,\n17250\t                \"Unexpected error in an Op's C code. \"\n17251\t                \"No Python exception was set.\");\n17252\t            }\n17253\t        goto __label_310;}\n17254\t            }\n17255\t            // We expect NPY_FLOAT64\n17256\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V309)) {\n17257\t                PyArrayObject * tmp = (PyArrayObject*) py_V309;\n17258\t                PyErr_Format(PyExc_NotImplementedError,\n17259\t                             \"expected an aligned array of type %ld \"\n17260\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n17261\t                             \" with %ld dimensions, with 3 last dims \"\n17262\t                             \"%ld, %ld, %ld\"\n17263\t                             \" and 3 last strides %ld %ld, %ld.\",\n17264\t                             (long int) NPY_FLOAT64,\n17265\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V309),\n17266\t                             (long int) PyArray_NDIM(tmp),\n17267\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n17268\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n17269\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n17270\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n17271\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n17272\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n17273\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n17274\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n17275\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n17276\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n17277\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n17278\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n17279\t            );\n17280\t                {\n17281\t        __failure = 310;\n17282\t        if (!PyErr_Occurred()) {\n17283\t            PyErr_SetString(PyExc_RuntimeError,\n17284\t                \"Unexpected error in an Op's C code. \"\n17285\t                \"No Python exception was set.\");\n17286\t            }\n17287\t        goto __label_310;}\n17288\t            }\n17289\t            // This is a TypeError to be consistent with DEBUG_MODE\n17290\t            // Note: DEBUG_MODE also tells the name of the container\n17291\t            if (PyArray_TYPE((PyArrayObject*) py_V309) != NPY_FLOAT64) {\n17292\t                PyErr_Format(PyExc_TypeError,\n17293\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n17294\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V309));\n17295\t                {\n17296\t        __failure = 310;\n17297\t        if (!PyErr_Occurred()) {\n17298\t            PyErr_SetString(PyExc_RuntimeError,\n17299\t                \"Unexpected error in an Op's C code. \"\n17300\t                \"No Python exception was set.\");\n17301\t            }\n17302\t        goto __label_310;}\n17303\t            }\n17304\t            \n17305\t        V309 = (PyArrayObject*)(py_V309);\n17306\t        Py_XINCREF(V309);\n17307\t        \n17308\t{\n17309\t\n17310\t    py_V311 = PyList_GET_ITEM(storage_V311, 0);\n17311\t    {Py_XINCREF(py_V311);}\n17312\t    \n17313\t            V311 = NULL;\n17314\t            if (py_V311 == Py_None) {\n17315\t                // We can either fail here or set V311 to NULL and rely on Ops\n17316\t                // using tensors to handle the NULL case, but if they fail to do so\n17317\t                // they'll end up with nasty segfaults, so this is public service.\n17318\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n17319\t                {\n17320\t        __failure = 312;\n17321\t        if (!PyErr_Occurred()) {\n17322\t            PyErr_SetString(PyExc_RuntimeError,\n17323\t                \"Unexpected error in an Op's C code. \"\n17324\t                \"No Python exception was set.\");\n17325\t            }\n17326\t        goto __label_312;}\n17327\t            }\n17328\t            if (!PyArray_Check(py_V311)) {\n17329\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n17330\t                {\n17331\t        __failure = 312;\n17332\t        if (!PyErr_Occurred()) {\n17333\t            PyErr_SetString(PyExc_RuntimeError,\n17334\t                \"Unexpected error in an Op's C code. \"\n17335\t                \"No Python exception was set.\");\n17336\t            }\n17337\t        goto __label_312;}\n17338\t            }\n17339\t            // We expect NPY_FLOAT64\n17340\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V311)) {\n17341\t                PyArrayObject * tmp = (PyArrayObject*) py_V311;\n17342\t                PyErr_Format(PyExc_NotImplementedError,\n17343\t                             \"expected an aligned array of type %ld \"\n17344\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n17345\t                             \" with %ld dimensions, with 3 last dims \"\n17346\t                             \"%ld, %ld, %ld\"\n17347\t                             \" and 3 last strides %ld %ld, %ld.\",\n17348\t                             (long int) NPY_FLOAT64,\n17349\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V311),\n17350\t                             (long int) PyArray_NDIM(tmp),\n17351\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n17352\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n17353\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n17354\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n17355\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n17356\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n17357\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n17358\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n17359\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n17360\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n17361\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n17362\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n17363\t            );\n17364\t                {\n17365\t        __failure = 312;\n17366\t        if (!PyErr_Occurred()) {\n17367\t            PyErr_SetString(PyExc_RuntimeError,\n17368\t                \"Unexpected error in an Op's C code. \"\n17369\t                \"No Python exception was set.\");\n17370\t            }\n17371\t        goto __label_312;}\n17372\t            }\n17373\t            // This is a TypeError to be consistent with DEBUG_MODE\n17374\t            // Note: DEBUG_MODE also tells the name of the container\n17375\t            if (PyArray_TYPE((PyArrayObject*) py_V311) != NPY_FLOAT64) {\n17376\t                PyErr_Format(PyExc_TypeError,\n17377\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n17378\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V311));\n17379\t                {\n17380\t        __failure = 312;\n17381\t        if (!PyErr_Occurred()) {\n17382\t            PyErr_SetString(PyExc_RuntimeError,\n17383\t                \"Unexpected error in an Op's C code. \"\n17384\t                \"No Python exception was set.\");\n17385\t            }\n17386\t        goto __label_312;}\n17387\t            }\n17388\t            \n17389\t        V311 = (PyArrayObject*)(py_V311);\n17390\t        Py_XINCREF(V311);\n17391\t        \n17392\t{\n17393\t\n17394\t    py_V313 = PyList_GET_ITEM(storage_V313, 0);\n17395\t    {Py_XINCREF(py_V313);}\n17396\t    \n17397\t            V313 = NULL;\n17398\t            if (py_V313 == Py_None) {\n17399\t                // We can either fail here or set V313 to NULL and rely on Ops\n17400\t                // using tensors to handle the NULL case, but if they fail to do so\n17401\t                // they'll end up with nasty segfaults, so this is public service.\n17402\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n17403\t                {\n17404\t        __failure = 314;\n17405\t        if (!PyErr_Occurred()) {\n17406\t            PyErr_SetString(PyExc_RuntimeError,\n17407\t                \"Unexpected error in an Op's C code. \"\n17408\t                \"No Python exception was set.\");\n17409\t            }\n17410\t        goto __label_314;}\n17411\t            }\n17412\t            if (!PyArray_Check(py_V313)) {\n17413\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n17414\t                {\n17415\t        __failure = 314;\n17416\t        if (!PyErr_Occurred()) {\n17417\t            PyErr_SetString(PyExc_RuntimeError,\n17418\t                \"Unexpected error in an Op's C code. \"\n17419\t                \"No Python exception was set.\");\n17420\t            }\n17421\t        goto __label_314;}\n17422\t            }\n17423\t            // We expect NPY_FLOAT64\n17424\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V313)) {\n17425\t                PyArrayObject * tmp = (PyArrayObject*) py_V313;\n17426\t                PyErr_Format(PyExc_NotImplementedError,\n17427\t                             \"expected an aligned array of type %ld \"\n17428\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n17429\t                             \" with %ld dimensions, with 3 last dims \"\n17430\t                             \"%ld, %ld, %ld\"\n17431\t                             \" and 3 last strides %ld %ld, %ld.\",\n17432\t                             (long int) NPY_FLOAT64,\n17433\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V313),\n17434\t                             (long int) PyArray_NDIM(tmp),\n17435\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n17436\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n17437\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n17438\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n17439\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n17440\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n17441\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n17442\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n17443\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n17444\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n17445\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n17446\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n17447\t            );\n17448\t                {\n17449\t        __failure = 314;\n17450\t        if (!PyErr_Occurred()) {\n17451\t            PyErr_SetString(PyExc_RuntimeError,\n17452\t                \"Unexpected error in an Op's C code. \"\n17453\t                \"No Python exception was set.\");\n17454\t            }\n17455\t        goto __label_314;}\n17456\t            }\n17457\t            // This is a TypeError to be consistent with DEBUG_MODE\n17458\t            // Note: DEBUG_MODE also tells the name of the container\n17459\t            if (PyArray_TYPE((PyArrayObject*) py_V313) != NPY_FLOAT64) {\n17460\t                PyErr_Format(PyExc_TypeError,\n17461\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n17462\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V313));\n17463\t                {\n17464\t        __failure = 314;\n17465\t        if (!PyErr_Occurred()) {\n17466\t            PyErr_SetString(PyExc_RuntimeError,\n17467\t                \"Unexpected error in an Op's C code. \"\n17468\t                \"No Python exception was set.\");\n17469\t            }\n17470\t        goto __label_314;}\n17471\t            }\n17472\t            \n17473\t        V313 = (PyArrayObject*)(py_V313);\n17474\t        Py_XINCREF(V313);\n17475\t        \n17476\t{\n17477\t\n17478\t    py_V315 = PyList_GET_ITEM(storage_V315, 0);\n17479\t    {Py_XINCREF(py_V315);}\n17480\t    \n17481\t            V315 = NULL;\n17482\t            if (py_V315 == Py_None) {\n17483\t                // We can either fail here or set V315 to NULL and rely on Ops\n17484\t                // using tensors to handle the NULL case, but if they fail to do so\n17485\t                // they'll end up with nasty segfaults, so this is public service.\n17486\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n17487\t                {\n17488\t        __failure = 316;\n17489\t        if (!PyErr_Occurred()) {\n17490\t            PyErr_SetString(PyExc_RuntimeError,\n17491\t                \"Unexpected error in an Op's C code. \"\n17492\t                \"No Python exception was set.\");\n17493\t            }\n17494\t        goto __label_316;}\n17495\t            }\n17496\t            if (!PyArray_Check(py_V315)) {\n17497\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n17498\t                {\n17499\t        __failure = 316;\n17500\t        if (!PyErr_Occurred()) {\n17501\t            PyErr_SetString(PyExc_RuntimeError,\n17502\t                \"Unexpected error in an Op's C code. \"\n17503\t                \"No Python exception was set.\");\n17504\t            }\n17505\t        goto __label_316;}\n17506\t            }\n17507\t            // We expect NPY_FLOAT64\n17508\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V315)) {\n17509\t                PyArrayObject * tmp = (PyArrayObject*) py_V315;\n17510\t                PyErr_Format(PyExc_NotImplementedError,\n17511\t                             \"expected an aligned array of type %ld \"\n17512\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n17513\t                             \" with %ld dimensions, with 3 last dims \"\n17514\t                             \"%ld, %ld, %ld\"\n17515\t                             \" and 3 last strides %ld %ld, %ld.\",\n17516\t                             (long int) NPY_FLOAT64,\n17517\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V315),\n17518\t                             (long int) PyArray_NDIM(tmp),\n17519\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n17520\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n17521\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n17522\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n17523\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n17524\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n17525\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n17526\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n17527\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n17528\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n17529\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n17530\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n17531\t            );\n17532\t                {\n17533\t        __failure = 316;\n17534\t        if (!PyErr_Occurred()) {\n17535\t            PyErr_SetString(PyExc_RuntimeError,\n17536\t                \"Unexpected error in an Op's C code. \"\n17537\t                \"No Python exception was set.\");\n17538\t            }\n17539\t        goto __label_316;}\n17540\t            }\n17541\t            // This is a TypeError to be consistent with DEBUG_MODE\n17542\t            // Note: DEBUG_MODE also tells the name of the container\n17543\t            if (PyArray_TYPE((PyArrayObject*) py_V315) != NPY_FLOAT64) {\n17544\t                PyErr_Format(PyExc_TypeError,\n17545\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n17546\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V315));\n17547\t                {\n17548\t        __failure = 316;\n17549\t        if (!PyErr_Occurred()) {\n17550\t            PyErr_SetString(PyExc_RuntimeError,\n17551\t                \"Unexpected error in an Op's C code. \"\n17552\t                \"No Python exception was set.\");\n17553\t            }\n17554\t        goto __label_316;}\n17555\t            }\n17556\t            \n17557\t        V315 = (PyArrayObject*)(py_V315);\n17558\t        Py_XINCREF(V315);\n17559\t        \n17560\t{\n17561\t\n17562\t    py_V317 = PyList_GET_ITEM(storage_V317, 0);\n17563\t    {Py_XINCREF(py_V317);}\n17564\t    \n17565\t            V317 = NULL;\n17566\t            if (py_V317 == Py_None) {\n17567\t                // We can either fail here or set V317 to NULL and rely on Ops\n17568\t                // using tensors to handle the NULL case, but if they fail to do so\n17569\t                // they'll end up with nasty segfaults, so this is public service.\n17570\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n17571\t                {\n17572\t        __failure = 318;\n17573\t        if (!PyErr_Occurred()) {\n17574\t            PyErr_SetString(PyExc_RuntimeError,\n17575\t                \"Unexpected error in an Op's C code. \"\n17576\t                \"No Python exception was set.\");\n17577\t            }\n17578\t        goto __label_318;}\n17579\t            }\n17580\t            if (!PyArray_Check(py_V317)) {\n17581\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n17582\t                {\n17583\t        __failure = 318;\n17584\t        if (!PyErr_Occurred()) {\n17585\t            PyErr_SetString(PyExc_RuntimeError,\n17586\t                \"Unexpected error in an Op's C code. \"\n17587\t                \"No Python exception was set.\");\n17588\t            }\n17589\t        goto __label_318;}\n17590\t            }\n17591\t            // We expect NPY_FLOAT64\n17592\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V317)) {\n17593\t                PyArrayObject * tmp = (PyArrayObject*) py_V317;\n17594\t                PyErr_Format(PyExc_NotImplementedError,\n17595\t                             \"expected an aligned array of type %ld \"\n17596\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n17597\t                             \" with %ld dimensions, with 3 last dims \"\n17598\t                             \"%ld, %ld, %ld\"\n17599\t                             \" and 3 last strides %ld %ld, %ld.\",\n17600\t                             (long int) NPY_FLOAT64,\n17601\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V317),\n17602\t                             (long int) PyArray_NDIM(tmp),\n17603\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n17604\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n17605\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n17606\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n17607\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n17608\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n17609\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n17610\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n17611\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n17612\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n17613\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n17614\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n17615\t            );\n17616\t                {\n17617\t        __failure = 318;\n17618\t        if (!PyErr_Occurred()) {\n17619\t            PyErr_SetString(PyExc_RuntimeError,\n17620\t                \"Unexpected error in an Op's C code. \"\n17621\t                \"No Python exception was set.\");\n17622\t            }\n17623\t        goto __label_318;}\n17624\t            }\n17625\t            // This is a TypeError to be consistent with DEBUG_MODE\n17626\t            // Note: DEBUG_MODE also tells the name of the container\n17627\t            if (PyArray_TYPE((PyArrayObject*) py_V317) != NPY_FLOAT64) {\n17628\t                PyErr_Format(PyExc_TypeError,\n17629\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n17630\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V317));\n17631\t                {\n17632\t        __failure = 318;\n17633\t        if (!PyErr_Occurred()) {\n17634\t            PyErr_SetString(PyExc_RuntimeError,\n17635\t                \"Unexpected error in an Op's C code. \"\n17636\t                \"No Python exception was set.\");\n17637\t            }\n17638\t        goto __label_318;}\n17639\t            }\n17640\t            \n17641\t        V317 = (PyArrayObject*)(py_V317);\n17642\t        Py_XINCREF(V317);\n17643\t        \n17644\t{\n17645\t\n17646\t    py_V319 = PyList_GET_ITEM(storage_V319, 0);\n17647\t    {Py_XINCREF(py_V319);}\n17648\t    \n17649\t            V319 = NULL;\n17650\t            if (py_V319 == Py_None) {\n17651\t                // We can either fail here or set V319 to NULL and rely on Ops\n17652\t                // using tensors to handle the NULL case, but if they fail to do so\n17653\t                // they'll end up with nasty segfaults, so this is public service.\n17654\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n17655\t                {\n17656\t        __failure = 320;\n17657\t        if (!PyErr_Occurred()) {\n17658\t            PyErr_SetString(PyExc_RuntimeError,\n17659\t                \"Unexpected error in an Op's C code. \"\n17660\t                \"No Python exception was set.\");\n17661\t            }\n17662\t        goto __label_320;}\n17663\t            }\n17664\t            if (!PyArray_Check(py_V319)) {\n17665\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n17666\t                {\n17667\t        __failure = 320;\n17668\t        if (!PyErr_Occurred()) {\n17669\t            PyErr_SetString(PyExc_RuntimeError,\n17670\t                \"Unexpected error in an Op's C code. \"\n17671\t                \"No Python exception was set.\");\n17672\t            }\n17673\t        goto __label_320;}\n17674\t            }\n17675\t            // We expect NPY_FLOAT64\n17676\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V319)) {\n17677\t                PyArrayObject * tmp = (PyArrayObject*) py_V319;\n17678\t                PyErr_Format(PyExc_NotImplementedError,\n17679\t                             \"expected an aligned array of type %ld \"\n17680\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n17681\t                             \" with %ld dimensions, with 3 last dims \"\n17682\t                             \"%ld, %ld, %ld\"\n17683\t                             \" and 3 last strides %ld %ld, %ld.\",\n17684\t                             (long int) NPY_FLOAT64,\n17685\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V319),\n17686\t                             (long int) PyArray_NDIM(tmp),\n17687\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n17688\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n17689\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n17690\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n17691\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n17692\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n17693\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n17694\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n17695\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n17696\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n17697\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n17698\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n17699\t            );\n17700\t                {\n17701\t        __failure = 320;\n17702\t        if (!PyErr_Occurred()) {\n17703\t            PyErr_SetString(PyExc_RuntimeError,\n17704\t                \"Unexpected error in an Op's C code. \"\n17705\t                \"No Python exception was set.\");\n17706\t            }\n17707\t        goto __label_320;}\n17708\t            }\n17709\t            // This is a TypeError to be consistent with DEBUG_MODE\n17710\t            // Note: DEBUG_MODE also tells the name of the container\n17711\t            if (PyArray_TYPE((PyArrayObject*) py_V319) != NPY_FLOAT64) {\n17712\t                PyErr_Format(PyExc_TypeError,\n17713\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n17714\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V319));\n17715\t                {\n17716\t        __failure = 320;\n17717\t        if (!PyErr_Occurred()) {\n17718\t            PyErr_SetString(PyExc_RuntimeError,\n17719\t                \"Unexpected error in an Op's C code. \"\n17720\t                \"No Python exception was set.\");\n17721\t            }\n17722\t        goto __label_320;}\n17723\t            }\n17724\t            \n17725\t        V319 = (PyArrayObject*)(py_V319);\n17726\t        Py_XINCREF(V319);\n17727\t        \n17728\t{\n17729\t\n17730\t    py_V321 = PyList_GET_ITEM(storage_V321, 0);\n17731\t    {Py_XINCREF(py_V321);}\n17732\t    \n17733\t            V321 = NULL;\n17734\t            if (py_V321 == Py_None) {\n17735\t                // We can either fail here or set V321 to NULL and rely on Ops\n17736\t                // using tensors to handle the NULL case, but if they fail to do so\n17737\t                // they'll end up with nasty segfaults, so this is public service.\n17738\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n17739\t                {\n17740\t        __failure = 322;\n17741\t        if (!PyErr_Occurred()) {\n17742\t            PyErr_SetString(PyExc_RuntimeError,\n17743\t                \"Unexpected error in an Op's C code. \"\n17744\t                \"No Python exception was set.\");\n17745\t            }\n17746\t        goto __label_322;}\n17747\t            }\n17748\t            if (!PyArray_Check(py_V321)) {\n17749\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n17750\t                {\n17751\t        __failure = 322;\n17752\t        if (!PyErr_Occurred()) {\n17753\t            PyErr_SetString(PyExc_RuntimeError,\n17754\t                \"Unexpected error in an Op's C code. \"\n17755\t                \"No Python exception was set.\");\n17756\t            }\n17757\t        goto __label_322;}\n17758\t            }\n17759\t            // We expect NPY_FLOAT64\n17760\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V321)) {\n17761\t                PyArrayObject * tmp = (PyArrayObject*) py_V321;\n17762\t                PyErr_Format(PyExc_NotImplementedError,\n17763\t                             \"expected an aligned array of type %ld \"\n17764\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n17765\t                             \" with %ld dimensions, with 3 last dims \"\n17766\t                             \"%ld, %ld, %ld\"\n17767\t                             \" and 3 last strides %ld %ld, %ld.\",\n17768\t                             (long int) NPY_FLOAT64,\n17769\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V321),\n17770\t                             (long int) PyArray_NDIM(tmp),\n17771\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n17772\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n17773\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n17774\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n17775\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n17776\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n17777\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n17778\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n17779\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n17780\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n17781\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n17782\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n17783\t            );\n17784\t                {\n17785\t        __failure = 322;\n17786\t        if (!PyErr_Occurred()) {\n17787\t            PyErr_SetString(PyExc_RuntimeError,\n17788\t                \"Unexpected error in an Op's C code. \"\n17789\t                \"No Python exception was set.\");\n17790\t            }\n17791\t        goto __label_322;}\n17792\t            }\n17793\t            // This is a TypeError to be consistent with DEBUG_MODE\n17794\t            // Note: DEBUG_MODE also tells the name of the container\n17795\t            if (PyArray_TYPE((PyArrayObject*) py_V321) != NPY_FLOAT64) {\n17796\t                PyErr_Format(PyExc_TypeError,\n17797\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n17798\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V321));\n17799\t                {\n17800\t        __failure = 322;\n17801\t        if (!PyErr_Occurred()) {\n17802\t            PyErr_SetString(PyExc_RuntimeError,\n17803\t                \"Unexpected error in an Op's C code. \"\n17804\t                \"No Python exception was set.\");\n17805\t            }\n17806\t        goto __label_322;}\n17807\t            }\n17808\t            \n17809\t        V321 = (PyArrayObject*)(py_V321);\n17810\t        Py_XINCREF(V321);\n17811\t        \n17812\t{\n17813\t\n17814\t    py_V323 = PyList_GET_ITEM(storage_V323, 0);\n17815\t    {Py_XINCREF(py_V323);}\n17816\t    \n17817\t            V323 = NULL;\n17818\t            if (py_V323 == Py_None) {\n17819\t                // We can either fail here or set V323 to NULL and rely on Ops\n17820\t                // using tensors to handle the NULL case, but if they fail to do so\n17821\t                // they'll end up with nasty segfaults, so this is public service.\n17822\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n17823\t                {\n17824\t        __failure = 324;\n17825\t        if (!PyErr_Occurred()) {\n17826\t            PyErr_SetString(PyExc_RuntimeError,\n17827\t                \"Unexpected error in an Op's C code. \"\n17828\t                \"No Python exception was set.\");\n17829\t            }\n17830\t        goto __label_324;}\n17831\t            }\n17832\t            if (!PyArray_Check(py_V323)) {\n17833\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n17834\t                {\n17835\t        __failure = 324;\n17836\t        if (!PyErr_Occurred()) {\n17837\t            PyErr_SetString(PyExc_RuntimeError,\n17838\t                \"Unexpected error in an Op's C code. \"\n17839\t                \"No Python exception was set.\");\n17840\t            }\n17841\t        goto __label_324;}\n17842\t            }\n17843\t            // We expect NPY_FLOAT64\n17844\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V323)) {\n17845\t                PyArrayObject * tmp = (PyArrayObject*) py_V323;\n17846\t                PyErr_Format(PyExc_NotImplementedError,\n17847\t                             \"expected an aligned array of type %ld \"\n17848\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n17849\t                             \" with %ld dimensions, with 3 last dims \"\n17850\t                             \"%ld, %ld, %ld\"\n17851\t                             \" and 3 last strides %ld %ld, %ld.\",\n17852\t                             (long int) NPY_FLOAT64,\n17853\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V323),\n17854\t                             (long int) PyArray_NDIM(tmp),\n17855\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n17856\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n17857\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n17858\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n17859\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n17860\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n17861\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n17862\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n17863\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n17864\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n17865\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n17866\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n17867\t            );\n17868\t                {\n17869\t        __failure = 324;\n17870\t        if (!PyErr_Occurred()) {\n17871\t            PyErr_SetString(PyExc_RuntimeError,\n17872\t                \"Unexpected error in an Op's C code. \"\n17873\t                \"No Python exception was set.\");\n17874\t            }\n17875\t        goto __label_324;}\n17876\t            }\n17877\t            // This is a TypeError to be consistent with DEBUG_MODE\n17878\t            // Note: DEBUG_MODE also tells the name of the container\n17879\t            if (PyArray_TYPE((PyArrayObject*) py_V323) != NPY_FLOAT64) {\n17880\t                PyErr_Format(PyExc_TypeError,\n17881\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n17882\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V323));\n17883\t                {\n17884\t        __failure = 324;\n17885\t        if (!PyErr_Occurred()) {\n17886\t            PyErr_SetString(PyExc_RuntimeError,\n17887\t                \"Unexpected error in an Op's C code. \"\n17888\t                \"No Python exception was set.\");\n17889\t            }\n17890\t        goto __label_324;}\n17891\t            }\n17892\t            \n17893\t        V323 = (PyArrayObject*)(py_V323);\n17894\t        Py_XINCREF(V323);\n17895\t        \n17896\t{\n17897\t\n17898\t    py_V325 = PyList_GET_ITEM(storage_V325, 0);\n17899\t    {Py_XINCREF(py_V325);}\n17900\t    \n17901\t            V325 = NULL;\n17902\t            if (py_V325 == Py_None) {\n17903\t                // We can either fail here or set V325 to NULL and rely on Ops\n17904\t                // using tensors to handle the NULL case, but if they fail to do so\n17905\t                // they'll end up with nasty segfaults, so this is public service.\n17906\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n17907\t                {\n17908\t        __failure = 326;\n17909\t        if (!PyErr_Occurred()) {\n17910\t            PyErr_SetString(PyExc_RuntimeError,\n17911\t                \"Unexpected error in an Op's C code. \"\n17912\t                \"No Python exception was set.\");\n17913\t            }\n17914\t        goto __label_326;}\n17915\t            }\n17916\t            if (!PyArray_Check(py_V325)) {\n17917\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n17918\t                {\n17919\t        __failure = 326;\n17920\t        if (!PyErr_Occurred()) {\n17921\t            PyErr_SetString(PyExc_RuntimeError,\n17922\t                \"Unexpected error in an Op's C code. \"\n17923\t                \"No Python exception was set.\");\n17924\t            }\n17925\t        goto __label_326;}\n17926\t            }\n17927\t            // We expect NPY_FLOAT64\n17928\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V325)) {\n17929\t                PyArrayObject * tmp = (PyArrayObject*) py_V325;\n17930\t                PyErr_Format(PyExc_NotImplementedError,\n17931\t                             \"expected an aligned array of type %ld \"\n17932\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n17933\t                             \" with %ld dimensions, with 3 last dims \"\n17934\t                             \"%ld, %ld, %ld\"\n17935\t                             \" and 3 last strides %ld %ld, %ld.\",\n17936\t                             (long int) NPY_FLOAT64,\n17937\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V325),\n17938\t                             (long int) PyArray_NDIM(tmp),\n17939\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n17940\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n17941\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n17942\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n17943\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n17944\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n17945\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n17946\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n17947\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n17948\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n17949\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n17950\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n17951\t            );\n17952\t                {\n17953\t        __failure = 326;\n17954\t        if (!PyErr_Occurred()) {\n17955\t            PyErr_SetString(PyExc_RuntimeError,\n17956\t                \"Unexpected error in an Op's C code. \"\n17957\t                \"No Python exception was set.\");\n17958\t            }\n17959\t        goto __label_326;}\n17960\t            }\n17961\t            // This is a TypeError to be consistent with DEBUG_MODE\n17962\t            // Note: DEBUG_MODE also tells the name of the container\n17963\t            if (PyArray_TYPE((PyArrayObject*) py_V325) != NPY_FLOAT64) {\n17964\t                PyErr_Format(PyExc_TypeError,\n17965\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n17966\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V325));\n17967\t                {\n17968\t        __failure = 326;\n17969\t        if (!PyErr_Occurred()) {\n17970\t            PyErr_SetString(PyExc_RuntimeError,\n17971\t                \"Unexpected error in an Op's C code. \"\n17972\t                \"No Python exception was set.\");\n17973\t            }\n17974\t        goto __label_326;}\n17975\t            }\n17976\t            \n17977\t        V325 = (PyArrayObject*)(py_V325);\n17978\t        Py_XINCREF(V325);\n17979\t        \n17980\t{\n17981\t\n17982\t    py_V327 = PyList_GET_ITEM(storage_V327, 0);\n17983\t    {Py_XINCREF(py_V327);}\n17984\t    \n17985\t            V327 = NULL;\n17986\t            if (py_V327 == Py_None) {\n17987\t                // We can either fail here or set V327 to NULL and rely on Ops\n17988\t                // using tensors to handle the NULL case, but if they fail to do so\n17989\t                // they'll end up with nasty segfaults, so this is public service.\n17990\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n17991\t                {\n17992\t        __failure = 328;\n17993\t        if (!PyErr_Occurred()) {\n17994\t            PyErr_SetString(PyExc_RuntimeError,\n17995\t                \"Unexpected error in an Op's C code. \"\n17996\t                \"No Python exception was set.\");\n17997\t            }\n17998\t        goto __label_328;}\n17999\t            }\n18000\t            if (!PyArray_Check(py_V327)) {\n18001\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n18002\t                {\n18003\t        __failure = 328;\n18004\t        if (!PyErr_Occurred()) {\n18005\t            PyErr_SetString(PyExc_RuntimeError,\n18006\t                \"Unexpected error in an Op's C code. \"\n18007\t                \"No Python exception was set.\");\n18008\t            }\n18009\t        goto __label_328;}\n18010\t            }\n18011\t            // We expect NPY_FLOAT64\n18012\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V327)) {\n18013\t                PyArrayObject * tmp = (PyArrayObject*) py_V327;\n18014\t                PyErr_Format(PyExc_NotImplementedError,\n18015\t                             \"expected an aligned array of type %ld \"\n18016\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n18017\t                             \" with %ld dimensions, with 3 last dims \"\n18018\t                             \"%ld, %ld, %ld\"\n18019\t                             \" and 3 last strides %ld %ld, %ld.\",\n18020\t                             (long int) NPY_FLOAT64,\n18021\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V327),\n18022\t                             (long int) PyArray_NDIM(tmp),\n18023\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n18024\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n18025\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n18026\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n18027\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n18028\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n18029\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n18030\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n18031\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n18032\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n18033\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n18034\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n18035\t            );\n18036\t                {\n18037\t        __failure = 328;\n18038\t        if (!PyErr_Occurred()) {\n18039\t            PyErr_SetString(PyExc_RuntimeError,\n18040\t                \"Unexpected error in an Op's C code. \"\n18041\t                \"No Python exception was set.\");\n18042\t            }\n18043\t        goto __label_328;}\n18044\t            }\n18045\t            // This is a TypeError to be consistent with DEBUG_MODE\n18046\t            // Note: DEBUG_MODE also tells the name of the container\n18047\t            if (PyArray_TYPE((PyArrayObject*) py_V327) != NPY_FLOAT64) {\n18048\t                PyErr_Format(PyExc_TypeError,\n18049\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n18050\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V327));\n18051\t                {\n18052\t        __failure = 328;\n18053\t        if (!PyErr_Occurred()) {\n18054\t            PyErr_SetString(PyExc_RuntimeError,\n18055\t                \"Unexpected error in an Op's C code. \"\n18056\t                \"No Python exception was set.\");\n18057\t            }\n18058\t        goto __label_328;}\n18059\t            }\n18060\t            \n18061\t        V327 = (PyArrayObject*)(py_V327);\n18062\t        Py_XINCREF(V327);\n18063\t        \n18064\t{\n18065\t\n18066\t    py_V329 = PyList_GET_ITEM(storage_V329, 0);\n18067\t    {Py_XINCREF(py_V329);}\n18068\t    \n18069\t            V329 = NULL;\n18070\t            if (py_V329 == Py_None) {\n18071\t                // We can either fail here or set V329 to NULL and rely on Ops\n18072\t                // using tensors to handle the NULL case, but if they fail to do so\n18073\t                // they'll end up with nasty segfaults, so this is public service.\n18074\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n18075\t                {\n18076\t        __failure = 330;\n18077\t        if (!PyErr_Occurred()) {\n18078\t            PyErr_SetString(PyExc_RuntimeError,\n18079\t                \"Unexpected error in an Op's C code. \"\n18080\t                \"No Python exception was set.\");\n18081\t            }\n18082\t        goto __label_330;}\n18083\t            }\n18084\t            if (!PyArray_Check(py_V329)) {\n18085\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n18086\t                {\n18087\t        __failure = 330;\n18088\t        if (!PyErr_Occurred()) {\n18089\t            PyErr_SetString(PyExc_RuntimeError,\n18090\t                \"Unexpected error in an Op's C code. \"\n18091\t                \"No Python exception was set.\");\n18092\t            }\n18093\t        goto __label_330;}\n18094\t            }\n18095\t            // We expect NPY_FLOAT64\n18096\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V329)) {\n18097\t                PyArrayObject * tmp = (PyArrayObject*) py_V329;\n18098\t                PyErr_Format(PyExc_NotImplementedError,\n18099\t                             \"expected an aligned array of type %ld \"\n18100\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n18101\t                             \" with %ld dimensions, with 3 last dims \"\n18102\t                             \"%ld, %ld, %ld\"\n18103\t                             \" and 3 last strides %ld %ld, %ld.\",\n18104\t                             (long int) NPY_FLOAT64,\n18105\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V329),\n18106\t                             (long int) PyArray_NDIM(tmp),\n18107\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n18108\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n18109\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n18110\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n18111\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n18112\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n18113\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n18114\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n18115\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n18116\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n18117\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n18118\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n18119\t            );\n18120\t                {\n18121\t        __failure = 330;\n18122\t        if (!PyErr_Occurred()) {\n18123\t            PyErr_SetString(PyExc_RuntimeError,\n18124\t                \"Unexpected error in an Op's C code. \"\n18125\t                \"No Python exception was set.\");\n18126\t            }\n18127\t        goto __label_330;}\n18128\t            }\n18129\t            // This is a TypeError to be consistent with DEBUG_MODE\n18130\t            // Note: DEBUG_MODE also tells the name of the container\n18131\t            if (PyArray_TYPE((PyArrayObject*) py_V329) != NPY_FLOAT64) {\n18132\t                PyErr_Format(PyExc_TypeError,\n18133\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n18134\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V329));\n18135\t                {\n18136\t        __failure = 330;\n18137\t        if (!PyErr_Occurred()) {\n18138\t            PyErr_SetString(PyExc_RuntimeError,\n18139\t                \"Unexpected error in an Op's C code. \"\n18140\t                \"No Python exception was set.\");\n18141\t            }\n18142\t        goto __label_330;}\n18143\t            }\n18144\t            \n18145\t        V329 = (PyArrayObject*)(py_V329);\n18146\t        Py_XINCREF(V329);\n18147\t        \n18148\t{\n18149\t\n18150\t    py_V331 = PyList_GET_ITEM(storage_V331, 0);\n18151\t    {Py_XINCREF(py_V331);}\n18152\t    \n18153\t            V331 = NULL;\n18154\t            if (py_V331 == Py_None) {\n18155\t                // We can either fail here or set V331 to NULL and rely on Ops\n18156\t                // using tensors to handle the NULL case, but if they fail to do so\n18157\t                // they'll end up with nasty segfaults, so this is public service.\n18158\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n18159\t                {\n18160\t        __failure = 332;\n18161\t        if (!PyErr_Occurred()) {\n18162\t            PyErr_SetString(PyExc_RuntimeError,\n18163\t                \"Unexpected error in an Op's C code. \"\n18164\t                \"No Python exception was set.\");\n18165\t            }\n18166\t        goto __label_332;}\n18167\t            }\n18168\t            if (!PyArray_Check(py_V331)) {\n18169\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n18170\t                {\n18171\t        __failure = 332;\n18172\t        if (!PyErr_Occurred()) {\n18173\t            PyErr_SetString(PyExc_RuntimeError,\n18174\t                \"Unexpected error in an Op's C code. \"\n18175\t                \"No Python exception was set.\");\n18176\t            }\n18177\t        goto __label_332;}\n18178\t            }\n18179\t            // We expect NPY_FLOAT64\n18180\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V331)) {\n18181\t                PyArrayObject * tmp = (PyArrayObject*) py_V331;\n18182\t                PyErr_Format(PyExc_NotImplementedError,\n18183\t                             \"expected an aligned array of type %ld \"\n18184\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n18185\t                             \" with %ld dimensions, with 3 last dims \"\n18186\t                             \"%ld, %ld, %ld\"\n18187\t                             \" and 3 last strides %ld %ld, %ld.\",\n18188\t                             (long int) NPY_FLOAT64,\n18189\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V331),\n18190\t                             (long int) PyArray_NDIM(tmp),\n18191\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n18192\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n18193\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n18194\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n18195\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n18196\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n18197\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n18198\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n18199\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n18200\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n18201\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n18202\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n18203\t            );\n18204\t                {\n18205\t        __failure = 332;\n18206\t        if (!PyErr_Occurred()) {\n18207\t            PyErr_SetString(PyExc_RuntimeError,\n18208\t                \"Unexpected error in an Op's C code. \"\n18209\t                \"No Python exception was set.\");\n18210\t            }\n18211\t        goto __label_332;}\n18212\t            }\n18213\t            // This is a TypeError to be consistent with DEBUG_MODE\n18214\t            // Note: DEBUG_MODE also tells the name of the container\n18215\t            if (PyArray_TYPE((PyArrayObject*) py_V331) != NPY_FLOAT64) {\n18216\t                PyErr_Format(PyExc_TypeError,\n18217\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n18218\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V331));\n18219\t                {\n18220\t        __failure = 332;\n18221\t        if (!PyErr_Occurred()) {\n18222\t            PyErr_SetString(PyExc_RuntimeError,\n18223\t                \"Unexpected error in an Op's C code. \"\n18224\t                \"No Python exception was set.\");\n18225\t            }\n18226\t        goto __label_332;}\n18227\t            }\n18228\t            \n18229\t        V331 = (PyArrayObject*)(py_V331);\n18230\t        Py_XINCREF(V331);\n18231\t        \n18232\t{\n18233\t\n18234\t    py_V333 = PyList_GET_ITEM(storage_V333, 0);\n18235\t    {Py_XINCREF(py_V333);}\n18236\t    \n18237\t            V333 = NULL;\n18238\t            if (py_V333 == Py_None) {\n18239\t                // We can either fail here or set V333 to NULL and rely on Ops\n18240\t                // using tensors to handle the NULL case, but if they fail to do so\n18241\t                // they'll end up with nasty segfaults, so this is public service.\n18242\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n18243\t                {\n18244\t        __failure = 334;\n18245\t        if (!PyErr_Occurred()) {\n18246\t            PyErr_SetString(PyExc_RuntimeError,\n18247\t                \"Unexpected error in an Op's C code. \"\n18248\t                \"No Python exception was set.\");\n18249\t            }\n18250\t        goto __label_334;}\n18251\t            }\n18252\t            if (!PyArray_Check(py_V333)) {\n18253\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n18254\t                {\n18255\t        __failure = 334;\n18256\t        if (!PyErr_Occurred()) {\n18257\t            PyErr_SetString(PyExc_RuntimeError,\n18258\t                \"Unexpected error in an Op's C code. \"\n18259\t                \"No Python exception was set.\");\n18260\t            }\n18261\t        goto __label_334;}\n18262\t            }\n18263\t            // We expect NPY_FLOAT64\n18264\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V333)) {\n18265\t                PyArrayObject * tmp = (PyArrayObject*) py_V333;\n18266\t                PyErr_Format(PyExc_NotImplementedError,\n18267\t                             \"expected an aligned array of type %ld \"\n18268\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n18269\t                             \" with %ld dimensions, with 3 last dims \"\n18270\t                             \"%ld, %ld, %ld\"\n18271\t                             \" and 3 last strides %ld %ld, %ld.\",\n18272\t                             (long int) NPY_FLOAT64,\n18273\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V333),\n18274\t                             (long int) PyArray_NDIM(tmp),\n18275\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n18276\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n18277\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n18278\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n18279\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n18280\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n18281\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n18282\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n18283\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n18284\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n18285\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n18286\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n18287\t            );\n18288\t                {\n18289\t        __failure = 334;\n18290\t        if (!PyErr_Occurred()) {\n18291\t            PyErr_SetString(PyExc_RuntimeError,\n18292\t                \"Unexpected error in an Op's C code. \"\n18293\t                \"No Python exception was set.\");\n18294\t            }\n18295\t        goto __label_334;}\n18296\t            }\n18297\t            // This is a TypeError to be consistent with DEBUG_MODE\n18298\t            // Note: DEBUG_MODE also tells the name of the container\n18299\t            if (PyArray_TYPE((PyArrayObject*) py_V333) != NPY_FLOAT64) {\n18300\t                PyErr_Format(PyExc_TypeError,\n18301\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n18302\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V333));\n18303\t                {\n18304\t        __failure = 334;\n18305\t        if (!PyErr_Occurred()) {\n18306\t            PyErr_SetString(PyExc_RuntimeError,\n18307\t                \"Unexpected error in an Op's C code. \"\n18308\t                \"No Python exception was set.\");\n18309\t            }\n18310\t        goto __label_334;}\n18311\t            }\n18312\t            \n18313\t        V333 = (PyArrayObject*)(py_V333);\n18314\t        Py_XINCREF(V333);\n18315\t        \n18316\t{\n18317\t\n18318\t    py_V335 = PyList_GET_ITEM(storage_V335, 0);\n18319\t    {Py_XINCREF(py_V335);}\n18320\t    \n18321\t            V335 = NULL;\n18322\t            if (py_V335 == Py_None) {\n18323\t                // We can either fail here or set V335 to NULL and rely on Ops\n18324\t                // using tensors to handle the NULL case, but if they fail to do so\n18325\t                // they'll end up with nasty segfaults, so this is public service.\n18326\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n18327\t                {\n18328\t        __failure = 336;\n18329\t        if (!PyErr_Occurred()) {\n18330\t            PyErr_SetString(PyExc_RuntimeError,\n18331\t                \"Unexpected error in an Op's C code. \"\n18332\t                \"No Python exception was set.\");\n18333\t            }\n18334\t        goto __label_336;}\n18335\t            }\n18336\t            if (!PyArray_Check(py_V335)) {\n18337\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n18338\t                {\n18339\t        __failure = 336;\n18340\t        if (!PyErr_Occurred()) {\n18341\t            PyErr_SetString(PyExc_RuntimeError,\n18342\t                \"Unexpected error in an Op's C code. \"\n18343\t                \"No Python exception was set.\");\n18344\t            }\n18345\t        goto __label_336;}\n18346\t            }\n18347\t            // We expect NPY_FLOAT64\n18348\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V335)) {\n18349\t                PyArrayObject * tmp = (PyArrayObject*) py_V335;\n18350\t                PyErr_Format(PyExc_NotImplementedError,\n18351\t                             \"expected an aligned array of type %ld \"\n18352\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n18353\t                             \" with %ld dimensions, with 3 last dims \"\n18354\t                             \"%ld, %ld, %ld\"\n18355\t                             \" and 3 last strides %ld %ld, %ld.\",\n18356\t                             (long int) NPY_FLOAT64,\n18357\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V335),\n18358\t                             (long int) PyArray_NDIM(tmp),\n18359\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n18360\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n18361\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n18362\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n18363\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n18364\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n18365\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n18366\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n18367\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n18368\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n18369\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n18370\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n18371\t            );\n18372\t                {\n18373\t        __failure = 336;\n18374\t        if (!PyErr_Occurred()) {\n18375\t            PyErr_SetString(PyExc_RuntimeError,\n18376\t                \"Unexpected error in an Op's C code. \"\n18377\t                \"No Python exception was set.\");\n18378\t            }\n18379\t        goto __label_336;}\n18380\t            }\n18381\t            // This is a TypeError to be consistent with DEBUG_MODE\n18382\t            // Note: DEBUG_MODE also tells the name of the container\n18383\t            if (PyArray_TYPE((PyArrayObject*) py_V335) != NPY_FLOAT64) {\n18384\t                PyErr_Format(PyExc_TypeError,\n18385\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n18386\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V335));\n18387\t                {\n18388\t        __failure = 336;\n18389\t        if (!PyErr_Occurred()) {\n18390\t            PyErr_SetString(PyExc_RuntimeError,\n18391\t                \"Unexpected error in an Op's C code. \"\n18392\t                \"No Python exception was set.\");\n18393\t            }\n18394\t        goto __label_336;}\n18395\t            }\n18396\t            \n18397\t        V335 = (PyArrayObject*)(py_V335);\n18398\t        Py_XINCREF(V335);\n18399\t        \n18400\t{\n18401\t\n18402\t    py_V337 = PyList_GET_ITEM(storage_V337, 0);\n18403\t    {Py_XINCREF(py_V337);}\n18404\t    \n18405\t            V337 = NULL;\n18406\t            if (py_V337 == Py_None) {\n18407\t                // We can either fail here or set V337 to NULL and rely on Ops\n18408\t                // using tensors to handle the NULL case, but if they fail to do so\n18409\t                // they'll end up with nasty segfaults, so this is public service.\n18410\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n18411\t                {\n18412\t        __failure = 338;\n18413\t        if (!PyErr_Occurred()) {\n18414\t            PyErr_SetString(PyExc_RuntimeError,\n18415\t                \"Unexpected error in an Op's C code. \"\n18416\t                \"No Python exception was set.\");\n18417\t            }\n18418\t        goto __label_338;}\n18419\t            }\n18420\t            if (!PyArray_Check(py_V337)) {\n18421\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n18422\t                {\n18423\t        __failure = 338;\n18424\t        if (!PyErr_Occurred()) {\n18425\t            PyErr_SetString(PyExc_RuntimeError,\n18426\t                \"Unexpected error in an Op's C code. \"\n18427\t                \"No Python exception was set.\");\n18428\t            }\n18429\t        goto __label_338;}\n18430\t            }\n18431\t            // We expect NPY_FLOAT64\n18432\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V337)) {\n18433\t                PyArrayObject * tmp = (PyArrayObject*) py_V337;\n18434\t                PyErr_Format(PyExc_NotImplementedError,\n18435\t                             \"expected an aligned array of type %ld \"\n18436\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n18437\t                             \" with %ld dimensions, with 3 last dims \"\n18438\t                             \"%ld, %ld, %ld\"\n18439\t                             \" and 3 last strides %ld %ld, %ld.\",\n18440\t                             (long int) NPY_FLOAT64,\n18441\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V337),\n18442\t                             (long int) PyArray_NDIM(tmp),\n18443\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n18444\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n18445\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n18446\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n18447\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n18448\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n18449\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n18450\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n18451\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n18452\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n18453\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n18454\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n18455\t            );\n18456\t                {\n18457\t        __failure = 338;\n18458\t        if (!PyErr_Occurred()) {\n18459\t            PyErr_SetString(PyExc_RuntimeError,\n18460\t                \"Unexpected error in an Op's C code. \"\n18461\t                \"No Python exception was set.\");\n18462\t            }\n18463\t        goto __label_338;}\n18464\t            }\n18465\t            // This is a TypeError to be consistent with DEBUG_MODE\n18466\t            // Note: DEBUG_MODE also tells the name of the container\n18467\t            if (PyArray_TYPE((PyArrayObject*) py_V337) != NPY_FLOAT64) {\n18468\t                PyErr_Format(PyExc_TypeError,\n18469\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n18470\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V337));\n18471\t                {\n18472\t        __failure = 338;\n18473\t        if (!PyErr_Occurred()) {\n18474\t            PyErr_SetString(PyExc_RuntimeError,\n18475\t                \"Unexpected error in an Op's C code. \"\n18476\t                \"No Python exception was set.\");\n18477\t            }\n18478\t        goto __label_338;}\n18479\t            }\n18480\t            \n18481\t        V337 = (PyArrayObject*)(py_V337);\n18482\t        Py_XINCREF(V337);\n18483\t        \n18484\t{\n18485\t\n18486\t    py_V339 = PyList_GET_ITEM(storage_V339, 0);\n18487\t    {Py_XINCREF(py_V339);}\n18488\t    \n18489\t            V339 = NULL;\n18490\t            if (py_V339 == Py_None) {\n18491\t                // We can either fail here or set V339 to NULL and rely on Ops\n18492\t                // using tensors to handle the NULL case, but if they fail to do so\n18493\t                // they'll end up with nasty segfaults, so this is public service.\n18494\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n18495\t                {\n18496\t        __failure = 340;\n18497\t        if (!PyErr_Occurred()) {\n18498\t            PyErr_SetString(PyExc_RuntimeError,\n18499\t                \"Unexpected error in an Op's C code. \"\n18500\t                \"No Python exception was set.\");\n18501\t            }\n18502\t        goto __label_340;}\n18503\t            }\n18504\t            if (!PyArray_Check(py_V339)) {\n18505\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n18506\t                {\n18507\t        __failure = 340;\n18508\t        if (!PyErr_Occurred()) {\n18509\t            PyErr_SetString(PyExc_RuntimeError,\n18510\t                \"Unexpected error in an Op's C code. \"\n18511\t                \"No Python exception was set.\");\n18512\t            }\n18513\t        goto __label_340;}\n18514\t            }\n18515\t            // We expect NPY_FLOAT64\n18516\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V339)) {\n18517\t                PyArrayObject * tmp = (PyArrayObject*) py_V339;\n18518\t                PyErr_Format(PyExc_NotImplementedError,\n18519\t                             \"expected an aligned array of type %ld \"\n18520\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n18521\t                             \" with %ld dimensions, with 3 last dims \"\n18522\t                             \"%ld, %ld, %ld\"\n18523\t                             \" and 3 last strides %ld %ld, %ld.\",\n18524\t                             (long int) NPY_FLOAT64,\n18525\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V339),\n18526\t                             (long int) PyArray_NDIM(tmp),\n18527\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n18528\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n18529\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n18530\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n18531\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n18532\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n18533\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n18534\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n18535\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n18536\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n18537\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n18538\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n18539\t            );\n18540\t                {\n18541\t        __failure = 340;\n18542\t        if (!PyErr_Occurred()) {\n18543\t            PyErr_SetString(PyExc_RuntimeError,\n18544\t                \"Unexpected error in an Op's C code. \"\n18545\t                \"No Python exception was set.\");\n18546\t            }\n18547\t        goto __label_340;}\n18548\t            }\n18549\t            // This is a TypeError to be consistent with DEBUG_MODE\n18550\t            // Note: DEBUG_MODE also tells the name of the container\n18551\t            if (PyArray_TYPE((PyArrayObject*) py_V339) != NPY_FLOAT64) {\n18552\t                PyErr_Format(PyExc_TypeError,\n18553\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n18554\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V339));\n18555\t                {\n18556\t        __failure = 340;\n18557\t        if (!PyErr_Occurred()) {\n18558\t            PyErr_SetString(PyExc_RuntimeError,\n18559\t                \"Unexpected error in an Op's C code. \"\n18560\t                \"No Python exception was set.\");\n18561\t            }\n18562\t        goto __label_340;}\n18563\t            }\n18564\t            \n18565\t        V339 = (PyArrayObject*)(py_V339);\n18566\t        Py_XINCREF(V339);\n18567\t        \n18568\t{\n18569\t\n18570\t    py_V341 = PyList_GET_ITEM(storage_V341, 0);\n18571\t    {Py_XINCREF(py_V341);}\n18572\t    \n18573\t            V341 = NULL;\n18574\t            if (py_V341 == Py_None) {\n18575\t                // We can either fail here or set V341 to NULL and rely on Ops\n18576\t                // using tensors to handle the NULL case, but if they fail to do so\n18577\t                // they'll end up with nasty segfaults, so this is public service.\n18578\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n18579\t                {\n18580\t        __failure = 342;\n18581\t        if (!PyErr_Occurred()) {\n18582\t            PyErr_SetString(PyExc_RuntimeError,\n18583\t                \"Unexpected error in an Op's C code. \"\n18584\t                \"No Python exception was set.\");\n18585\t            }\n18586\t        goto __label_342;}\n18587\t            }\n18588\t            if (!PyArray_Check(py_V341)) {\n18589\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n18590\t                {\n18591\t        __failure = 342;\n18592\t        if (!PyErr_Occurred()) {\n18593\t            PyErr_SetString(PyExc_RuntimeError,\n18594\t                \"Unexpected error in an Op's C code. \"\n18595\t                \"No Python exception was set.\");\n18596\t            }\n18597\t        goto __label_342;}\n18598\t            }\n18599\t            // We expect NPY_FLOAT64\n18600\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V341)) {\n18601\t                PyArrayObject * tmp = (PyArrayObject*) py_V341;\n18602\t                PyErr_Format(PyExc_NotImplementedError,\n18603\t                             \"expected an aligned array of type %ld \"\n18604\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n18605\t                             \" with %ld dimensions, with 3 last dims \"\n18606\t                             \"%ld, %ld, %ld\"\n18607\t                             \" and 3 last strides %ld %ld, %ld.\",\n18608\t                             (long int) NPY_FLOAT64,\n18609\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V341),\n18610\t                             (long int) PyArray_NDIM(tmp),\n18611\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n18612\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n18613\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n18614\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n18615\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n18616\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n18617\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n18618\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n18619\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n18620\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n18621\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n18622\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n18623\t            );\n18624\t                {\n18625\t        __failure = 342;\n18626\t        if (!PyErr_Occurred()) {\n18627\t            PyErr_SetString(PyExc_RuntimeError,\n18628\t                \"Unexpected error in an Op's C code. \"\n18629\t                \"No Python exception was set.\");\n18630\t            }\n18631\t        goto __label_342;}\n18632\t            }\n18633\t            // This is a TypeError to be consistent with DEBUG_MODE\n18634\t            // Note: DEBUG_MODE also tells the name of the container\n18635\t            if (PyArray_TYPE((PyArrayObject*) py_V341) != NPY_FLOAT64) {\n18636\t                PyErr_Format(PyExc_TypeError,\n18637\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n18638\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V341));\n18639\t                {\n18640\t        __failure = 342;\n18641\t        if (!PyErr_Occurred()) {\n18642\t            PyErr_SetString(PyExc_RuntimeError,\n18643\t                \"Unexpected error in an Op's C code. \"\n18644\t                \"No Python exception was set.\");\n18645\t            }\n18646\t        goto __label_342;}\n18647\t            }\n18648\t            \n18649\t        V341 = (PyArrayObject*)(py_V341);\n18650\t        Py_XINCREF(V341);\n18651\t        \n18652\t{\n18653\t\n18654\t    py_V343 = PyList_GET_ITEM(storage_V343, 0);\n18655\t    {Py_XINCREF(py_V343);}\n18656\t    \n18657\t            V343 = NULL;\n18658\t            if (py_V343 == Py_None) {\n18659\t                // We can either fail here or set V343 to NULL and rely on Ops\n18660\t                // using tensors to handle the NULL case, but if they fail to do so\n18661\t                // they'll end up with nasty segfaults, so this is public service.\n18662\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n18663\t                {\n18664\t        __failure = 344;\n18665\t        if (!PyErr_Occurred()) {\n18666\t            PyErr_SetString(PyExc_RuntimeError,\n18667\t                \"Unexpected error in an Op's C code. \"\n18668\t                \"No Python exception was set.\");\n18669\t            }\n18670\t        goto __label_344;}\n18671\t            }\n18672\t            if (!PyArray_Check(py_V343)) {\n18673\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n18674\t                {\n18675\t        __failure = 344;\n18676\t        if (!PyErr_Occurred()) {\n18677\t            PyErr_SetString(PyExc_RuntimeError,\n18678\t                \"Unexpected error in an Op's C code. \"\n18679\t                \"No Python exception was set.\");\n18680\t            }\n18681\t        goto __label_344;}\n18682\t            }\n18683\t            // We expect NPY_FLOAT64\n18684\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V343)) {\n18685\t                PyArrayObject * tmp = (PyArrayObject*) py_V343;\n18686\t                PyErr_Format(PyExc_NotImplementedError,\n18687\t                             \"expected an aligned array of type %ld \"\n18688\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n18689\t                             \" with %ld dimensions, with 3 last dims \"\n18690\t                             \"%ld, %ld, %ld\"\n18691\t                             \" and 3 last strides %ld %ld, %ld.\",\n18692\t                             (long int) NPY_FLOAT64,\n18693\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V343),\n18694\t                             (long int) PyArray_NDIM(tmp),\n18695\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n18696\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n18697\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n18698\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n18699\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n18700\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n18701\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n18702\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n18703\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n18704\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n18705\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n18706\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n18707\t            );\n18708\t                {\n18709\t        __failure = 344;\n18710\t        if (!PyErr_Occurred()) {\n18711\t            PyErr_SetString(PyExc_RuntimeError,\n18712\t                \"Unexpected error in an Op's C code. \"\n18713\t                \"No Python exception was set.\");\n18714\t            }\n18715\t        goto __label_344;}\n18716\t            }\n18717\t            // This is a TypeError to be consistent with DEBUG_MODE\n18718\t            // Note: DEBUG_MODE also tells the name of the container\n18719\t            if (PyArray_TYPE((PyArrayObject*) py_V343) != NPY_FLOAT64) {\n18720\t                PyErr_Format(PyExc_TypeError,\n18721\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n18722\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V343));\n18723\t                {\n18724\t        __failure = 344;\n18725\t        if (!PyErr_Occurred()) {\n18726\t            PyErr_SetString(PyExc_RuntimeError,\n18727\t                \"Unexpected error in an Op's C code. \"\n18728\t                \"No Python exception was set.\");\n18729\t            }\n18730\t        goto __label_344;}\n18731\t            }\n18732\t            \n18733\t        V343 = (PyArrayObject*)(py_V343);\n18734\t        Py_XINCREF(V343);\n18735\t        \n18736\t{\n18737\t\n18738\t    py_V345 = PyList_GET_ITEM(storage_V345, 0);\n18739\t    {Py_XINCREF(py_V345);}\n18740\t    \n18741\t            V345 = NULL;\n18742\t            if (py_V345 == Py_None) {\n18743\t                // We can either fail here or set V345 to NULL and rely on Ops\n18744\t                // using tensors to handle the NULL case, but if they fail to do so\n18745\t                // they'll end up with nasty segfaults, so this is public service.\n18746\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n18747\t                {\n18748\t        __failure = 346;\n18749\t        if (!PyErr_Occurred()) {\n18750\t            PyErr_SetString(PyExc_RuntimeError,\n18751\t                \"Unexpected error in an Op's C code. \"\n18752\t                \"No Python exception was set.\");\n18753\t            }\n18754\t        goto __label_346;}\n18755\t            }\n18756\t            if (!PyArray_Check(py_V345)) {\n18757\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n18758\t                {\n18759\t        __failure = 346;\n18760\t        if (!PyErr_Occurred()) {\n18761\t            PyErr_SetString(PyExc_RuntimeError,\n18762\t                \"Unexpected error in an Op's C code. \"\n18763\t                \"No Python exception was set.\");\n18764\t            }\n18765\t        goto __label_346;}\n18766\t            }\n18767\t            // We expect NPY_FLOAT64\n18768\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V345)) {\n18769\t                PyArrayObject * tmp = (PyArrayObject*) py_V345;\n18770\t                PyErr_Format(PyExc_NotImplementedError,\n18771\t                             \"expected an aligned array of type %ld \"\n18772\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n18773\t                             \" with %ld dimensions, with 3 last dims \"\n18774\t                             \"%ld, %ld, %ld\"\n18775\t                             \" and 3 last strides %ld %ld, %ld.\",\n18776\t                             (long int) NPY_FLOAT64,\n18777\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V345),\n18778\t                             (long int) PyArray_NDIM(tmp),\n18779\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n18780\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n18781\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n18782\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n18783\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n18784\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n18785\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n18786\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n18787\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n18788\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n18789\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n18790\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n18791\t            );\n18792\t                {\n18793\t        __failure = 346;\n18794\t        if (!PyErr_Occurred()) {\n18795\t            PyErr_SetString(PyExc_RuntimeError,\n18796\t                \"Unexpected error in an Op's C code. \"\n18797\t                \"No Python exception was set.\");\n18798\t            }\n18799\t        goto __label_346;}\n18800\t            }\n18801\t            // This is a TypeError to be consistent with DEBUG_MODE\n18802\t            // Note: DEBUG_MODE also tells the name of the container\n18803\t            if (PyArray_TYPE((PyArrayObject*) py_V345) != NPY_FLOAT64) {\n18804\t                PyErr_Format(PyExc_TypeError,\n18805\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n18806\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V345));\n18807\t                {\n18808\t        __failure = 346;\n18809\t        if (!PyErr_Occurred()) {\n18810\t            PyErr_SetString(PyExc_RuntimeError,\n18811\t                \"Unexpected error in an Op's C code. \"\n18812\t                \"No Python exception was set.\");\n18813\t            }\n18814\t        goto __label_346;}\n18815\t            }\n18816\t            \n18817\t        V345 = (PyArrayObject*)(py_V345);\n18818\t        Py_XINCREF(V345);\n18819\t        \n18820\t{\n18821\t\n18822\t    py_V347 = PyList_GET_ITEM(storage_V347, 0);\n18823\t    {Py_XINCREF(py_V347);}\n18824\t    \n18825\t            V347 = NULL;\n18826\t            if (py_V347 == Py_None) {\n18827\t                // We can either fail here or set V347 to NULL and rely on Ops\n18828\t                // using tensors to handle the NULL case, but if they fail to do so\n18829\t                // they'll end up with nasty segfaults, so this is public service.\n18830\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n18831\t                {\n18832\t        __failure = 348;\n18833\t        if (!PyErr_Occurred()) {\n18834\t            PyErr_SetString(PyExc_RuntimeError,\n18835\t                \"Unexpected error in an Op's C code. \"\n18836\t                \"No Python exception was set.\");\n18837\t            }\n18838\t        goto __label_348;}\n18839\t            }\n18840\t            if (!PyArray_Check(py_V347)) {\n18841\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n18842\t                {\n18843\t        __failure = 348;\n18844\t        if (!PyErr_Occurred()) {\n18845\t            PyErr_SetString(PyExc_RuntimeError,\n18846\t                \"Unexpected error in an Op's C code. \"\n18847\t                \"No Python exception was set.\");\n18848\t            }\n18849\t        goto __label_348;}\n18850\t            }\n18851\t            // We expect NPY_FLOAT64\n18852\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V347)) {\n18853\t                PyArrayObject * tmp = (PyArrayObject*) py_V347;\n18854\t                PyErr_Format(PyExc_NotImplementedError,\n18855\t                             \"expected an aligned array of type %ld \"\n18856\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n18857\t                             \" with %ld dimensions, with 3 last dims \"\n18858\t                             \"%ld, %ld, %ld\"\n18859\t                             \" and 3 last strides %ld %ld, %ld.\",\n18860\t                             (long int) NPY_FLOAT64,\n18861\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V347),\n18862\t                             (long int) PyArray_NDIM(tmp),\n18863\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n18864\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n18865\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n18866\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n18867\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n18868\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n18869\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n18870\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n18871\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n18872\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n18873\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n18874\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n18875\t            );\n18876\t                {\n18877\t        __failure = 348;\n18878\t        if (!PyErr_Occurred()) {\n18879\t            PyErr_SetString(PyExc_RuntimeError,\n18880\t                \"Unexpected error in an Op's C code. \"\n18881\t                \"No Python exception was set.\");\n18882\t            }\n18883\t        goto __label_348;}\n18884\t            }\n18885\t            // This is a TypeError to be consistent with DEBUG_MODE\n18886\t            // Note: DEBUG_MODE also tells the name of the container\n18887\t            if (PyArray_TYPE((PyArrayObject*) py_V347) != NPY_FLOAT64) {\n18888\t                PyErr_Format(PyExc_TypeError,\n18889\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n18890\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V347));\n18891\t                {\n18892\t        __failure = 348;\n18893\t        if (!PyErr_Occurred()) {\n18894\t            PyErr_SetString(PyExc_RuntimeError,\n18895\t                \"Unexpected error in an Op's C code. \"\n18896\t                \"No Python exception was set.\");\n18897\t            }\n18898\t        goto __label_348;}\n18899\t            }\n18900\t            \n18901\t        V347 = (PyArrayObject*)(py_V347);\n18902\t        Py_XINCREF(V347);\n18903\t        \n18904\t{\n18905\t\n18906\t    py_V349 = PyList_GET_ITEM(storage_V349, 0);\n18907\t    {Py_XINCREF(py_V349);}\n18908\t    \n18909\t            V349 = NULL;\n18910\t            if (py_V349 == Py_None) {\n18911\t                // We can either fail here or set V349 to NULL and rely on Ops\n18912\t                // using tensors to handle the NULL case, but if they fail to do so\n18913\t                // they'll end up with nasty segfaults, so this is public service.\n18914\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n18915\t                {\n18916\t        __failure = 350;\n18917\t        if (!PyErr_Occurred()) {\n18918\t            PyErr_SetString(PyExc_RuntimeError,\n18919\t                \"Unexpected error in an Op's C code. \"\n18920\t                \"No Python exception was set.\");\n18921\t            }\n18922\t        goto __label_350;}\n18923\t            }\n18924\t            if (!PyArray_Check(py_V349)) {\n18925\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n18926\t                {\n18927\t        __failure = 350;\n18928\t        if (!PyErr_Occurred()) {\n18929\t            PyErr_SetString(PyExc_RuntimeError,\n18930\t                \"Unexpected error in an Op's C code. \"\n18931\t                \"No Python exception was set.\");\n18932\t            }\n18933\t        goto __label_350;}\n18934\t            }\n18935\t            // We expect NPY_FLOAT64\n18936\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V349)) {\n18937\t                PyArrayObject * tmp = (PyArrayObject*) py_V349;\n18938\t                PyErr_Format(PyExc_NotImplementedError,\n18939\t                             \"expected an aligned array of type %ld \"\n18940\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n18941\t                             \" with %ld dimensions, with 3 last dims \"\n18942\t                             \"%ld, %ld, %ld\"\n18943\t                             \" and 3 last strides %ld %ld, %ld.\",\n18944\t                             (long int) NPY_FLOAT64,\n18945\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V349),\n18946\t                             (long int) PyArray_NDIM(tmp),\n18947\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n18948\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n18949\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n18950\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n18951\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n18952\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n18953\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n18954\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n18955\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n18956\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n18957\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n18958\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n18959\t            );\n18960\t                {\n18961\t        __failure = 350;\n18962\t        if (!PyErr_Occurred()) {\n18963\t            PyErr_SetString(PyExc_RuntimeError,\n18964\t                \"Unexpected error in an Op's C code. \"\n18965\t                \"No Python exception was set.\");\n18966\t            }\n18967\t        goto __label_350;}\n18968\t            }\n18969\t            // This is a TypeError to be consistent with DEBUG_MODE\n18970\t            // Note: DEBUG_MODE also tells the name of the container\n18971\t            if (PyArray_TYPE((PyArrayObject*) py_V349) != NPY_FLOAT64) {\n18972\t                PyErr_Format(PyExc_TypeError,\n18973\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n18974\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V349));\n18975\t                {\n18976\t        __failure = 350;\n18977\t        if (!PyErr_Occurred()) {\n18978\t            PyErr_SetString(PyExc_RuntimeError,\n18979\t                \"Unexpected error in an Op's C code. \"\n18980\t                \"No Python exception was set.\");\n18981\t            }\n18982\t        goto __label_350;}\n18983\t            }\n18984\t            \n18985\t        V349 = (PyArrayObject*)(py_V349);\n18986\t        Py_XINCREF(V349);\n18987\t        \n18988\t{\n18989\t\n18990\t    py_V351 = PyList_GET_ITEM(storage_V351, 0);\n18991\t    {Py_XINCREF(py_V351);}\n18992\t    \n18993\t            V351 = NULL;\n18994\t            if (py_V351 == Py_None) {\n18995\t                // We can either fail here or set V351 to NULL and rely on Ops\n18996\t                // using tensors to handle the NULL case, but if they fail to do so\n18997\t                // they'll end up with nasty segfaults, so this is public service.\n18998\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n18999\t                {\n19000\t        __failure = 352;\n19001\t        if (!PyErr_Occurred()) {\n19002\t            PyErr_SetString(PyExc_RuntimeError,\n19003\t                \"Unexpected error in an Op's C code. \"\n19004\t                \"No Python exception was set.\");\n19005\t            }\n19006\t        goto __label_352;}\n19007\t            }\n19008\t            if (!PyArray_Check(py_V351)) {\n19009\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n19010\t                {\n19011\t        __failure = 352;\n19012\t        if (!PyErr_Occurred()) {\n19013\t            PyErr_SetString(PyExc_RuntimeError,\n19014\t                \"Unexpected error in an Op's C code. \"\n19015\t                \"No Python exception was set.\");\n19016\t            }\n19017\t        goto __label_352;}\n19018\t            }\n19019\t            // We expect NPY_FLOAT64\n19020\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V351)) {\n19021\t                PyArrayObject * tmp = (PyArrayObject*) py_V351;\n19022\t                PyErr_Format(PyExc_NotImplementedError,\n19023\t                             \"expected an aligned array of type %ld \"\n19024\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n19025\t                             \" with %ld dimensions, with 3 last dims \"\n19026\t                             \"%ld, %ld, %ld\"\n19027\t                             \" and 3 last strides %ld %ld, %ld.\",\n19028\t                             (long int) NPY_FLOAT64,\n19029\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V351),\n19030\t                             (long int) PyArray_NDIM(tmp),\n19031\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n19032\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n19033\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n19034\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n19035\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n19036\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n19037\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n19038\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n19039\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n19040\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n19041\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n19042\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n19043\t            );\n19044\t                {\n19045\t        __failure = 352;\n19046\t        if (!PyErr_Occurred()) {\n19047\t            PyErr_SetString(PyExc_RuntimeError,\n19048\t                \"Unexpected error in an Op's C code. \"\n19049\t                \"No Python exception was set.\");\n19050\t            }\n19051\t        goto __label_352;}\n19052\t            }\n19053\t            // This is a TypeError to be consistent with DEBUG_MODE\n19054\t            // Note: DEBUG_MODE also tells the name of the container\n19055\t            if (PyArray_TYPE((PyArrayObject*) py_V351) != NPY_FLOAT64) {\n19056\t                PyErr_Format(PyExc_TypeError,\n19057\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n19058\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V351));\n19059\t                {\n19060\t        __failure = 352;\n19061\t        if (!PyErr_Occurred()) {\n19062\t            PyErr_SetString(PyExc_RuntimeError,\n19063\t                \"Unexpected error in an Op's C code. \"\n19064\t                \"No Python exception was set.\");\n19065\t            }\n19066\t        goto __label_352;}\n19067\t            }\n19068\t            \n19069\t        V351 = (PyArrayObject*)(py_V351);\n19070\t        Py_XINCREF(V351);\n19071\t        \n19072\t{\n19073\t\n19074\t    py_V353 = PyList_GET_ITEM(storage_V353, 0);\n19075\t    {Py_XINCREF(py_V353);}\n19076\t    \n19077\t            V353 = NULL;\n19078\t            if (py_V353 == Py_None) {\n19079\t                // We can either fail here or set V353 to NULL and rely on Ops\n19080\t                // using tensors to handle the NULL case, but if they fail to do so\n19081\t                // they'll end up with nasty segfaults, so this is public service.\n19082\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n19083\t                {\n19084\t        __failure = 354;\n19085\t        if (!PyErr_Occurred()) {\n19086\t            PyErr_SetString(PyExc_RuntimeError,\n19087\t                \"Unexpected error in an Op's C code. \"\n19088\t                \"No Python exception was set.\");\n19089\t            }\n19090\t        goto __label_354;}\n19091\t            }\n19092\t            if (!PyArray_Check(py_V353)) {\n19093\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n19094\t                {\n19095\t        __failure = 354;\n19096\t        if (!PyErr_Occurred()) {\n19097\t            PyErr_SetString(PyExc_RuntimeError,\n19098\t                \"Unexpected error in an Op's C code. \"\n19099\t                \"No Python exception was set.\");\n19100\t            }\n19101\t        goto __label_354;}\n19102\t            }\n19103\t            // We expect NPY_FLOAT64\n19104\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V353)) {\n19105\t                PyArrayObject * tmp = (PyArrayObject*) py_V353;\n19106\t                PyErr_Format(PyExc_NotImplementedError,\n19107\t                             \"expected an aligned array of type %ld \"\n19108\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n19109\t                             \" with %ld dimensions, with 3 last dims \"\n19110\t                             \"%ld, %ld, %ld\"\n19111\t                             \" and 3 last strides %ld %ld, %ld.\",\n19112\t                             (long int) NPY_FLOAT64,\n19113\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V353),\n19114\t                             (long int) PyArray_NDIM(tmp),\n19115\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n19116\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n19117\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n19118\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n19119\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n19120\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n19121\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n19122\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n19123\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n19124\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n19125\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n19126\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n19127\t            );\n19128\t                {\n19129\t        __failure = 354;\n19130\t        if (!PyErr_Occurred()) {\n19131\t            PyErr_SetString(PyExc_RuntimeError,\n19132\t                \"Unexpected error in an Op's C code. \"\n19133\t                \"No Python exception was set.\");\n19134\t            }\n19135\t        goto __label_354;}\n19136\t            }\n19137\t            // This is a TypeError to be consistent with DEBUG_MODE\n19138\t            // Note: DEBUG_MODE also tells the name of the container\n19139\t            if (PyArray_TYPE((PyArrayObject*) py_V353) != NPY_FLOAT64) {\n19140\t                PyErr_Format(PyExc_TypeError,\n19141\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n19142\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V353));\n19143\t                {\n19144\t        __failure = 354;\n19145\t        if (!PyErr_Occurred()) {\n19146\t            PyErr_SetString(PyExc_RuntimeError,\n19147\t                \"Unexpected error in an Op's C code. \"\n19148\t                \"No Python exception was set.\");\n19149\t            }\n19150\t        goto __label_354;}\n19151\t            }\n19152\t            \n19153\t        V353 = (PyArrayObject*)(py_V353);\n19154\t        Py_XINCREF(V353);\n19155\t        \n19156\t{\n19157\t\n19158\t    py_V355 = PyList_GET_ITEM(storage_V355, 0);\n19159\t    {Py_XINCREF(py_V355);}\n19160\t    \n19161\t            V355 = NULL;\n19162\t            if (py_V355 == Py_None) {\n19163\t                // We can either fail here or set V355 to NULL and rely on Ops\n19164\t                // using tensors to handle the NULL case, but if they fail to do so\n19165\t                // they'll end up with nasty segfaults, so this is public service.\n19166\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n19167\t                {\n19168\t        __failure = 356;\n19169\t        if (!PyErr_Occurred()) {\n19170\t            PyErr_SetString(PyExc_RuntimeError,\n19171\t                \"Unexpected error in an Op's C code. \"\n19172\t                \"No Python exception was set.\");\n19173\t            }\n19174\t        goto __label_356;}\n19175\t            }\n19176\t            if (!PyArray_Check(py_V355)) {\n19177\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n19178\t                {\n19179\t        __failure = 356;\n19180\t        if (!PyErr_Occurred()) {\n19181\t            PyErr_SetString(PyExc_RuntimeError,\n19182\t                \"Unexpected error in an Op's C code. \"\n19183\t                \"No Python exception was set.\");\n19184\t            }\n19185\t        goto __label_356;}\n19186\t            }\n19187\t            // We expect NPY_FLOAT64\n19188\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V355)) {\n19189\t                PyArrayObject * tmp = (PyArrayObject*) py_V355;\n19190\t                PyErr_Format(PyExc_NotImplementedError,\n19191\t                             \"expected an aligned array of type %ld \"\n19192\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n19193\t                             \" with %ld dimensions, with 3 last dims \"\n19194\t                             \"%ld, %ld, %ld\"\n19195\t                             \" and 3 last strides %ld %ld, %ld.\",\n19196\t                             (long int) NPY_FLOAT64,\n19197\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V355),\n19198\t                             (long int) PyArray_NDIM(tmp),\n19199\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n19200\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),\n19201\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n19202\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),\n19203\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n19204\t            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),\n19205\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n19206\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),\n19207\t                             (long int) (PyArray_NDIM(tmp) >= 2 ?\n19208\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),\n19209\t                             (long int) (PyArray_NDIM(tmp) >= 1 ?\n19210\t            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)\n19211\t            );\n19212\t                {\n19213\t        __failure = 356;\n19214\t        if (!PyErr_Occurred()) {\n19215\t            PyErr_SetString(PyExc_RuntimeError,\n19216\t                \"Unexpected error in an Op's C code. \"\n19217\t                \"No Python exception was set.\");\n19218\t            }\n19219\t        goto __label_356;}\n19220\t            }\n19221\t            // This is a TypeError to be consistent with DEBUG_MODE\n19222\t            // Note: DEBUG_MODE also tells the name of the container\n19223\t            if (PyArray_TYPE((PyArrayObject*) py_V355) != NPY_FLOAT64) {\n19224\t                PyErr_Format(PyExc_TypeError,\n19225\t                             \"expected type_num %d (NPY_FLOAT64) got %d\",\n19226\t                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V355));\n19227\t                {\n19228\t        __failure = 356;\n19229\t        if (!PyErr_Occurred()) {\n19230\t            PyErr_SetString(PyExc_RuntimeError,\n19231\t                \"Unexpected error in an Op's C code. \"\n19232\t                \"No Python exception was set.\");\n19233\t            }\n19234\t        goto __label_356;}\n19235\t            }\n19236\t            \n19237\t        V355 = (PyArrayObject*)(py_V355);\n19238\t        Py_XINCREF(V355);\n19239\t        \n19240\t{\n19241\t\n19242\t    py_V357 = PyList_GET_ITEM(storage_V357, 0);\n19243\t    {Py_XINCREF(py_V357);}\n19244\t    \n19245\t            V357 = NULL;\n19246\t            if (py_V357 == Py_None) {\n19247\t                // We can either fail here or set V357 to NULL and rely on Ops\n19248\t                // using tensors to handle the NULL case, but if they fail to do so\n19249\t                // they'll end up with nasty segfaults, so this is public service.\n19250\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray, not None\");\n19251\t                {\n19252\t        __failure = 358;\n19253\t        if (!PyErr_Occurred()) {\n19254\t            PyErr_SetString(PyExc_RuntimeError,\n19255\t                \"Unexpected error in an Op's C code. \"\n19256\t                \"No Python exception was set.\");\n19257\t            }\n19258\t        goto __label_358;}\n19259\t            }\n19260\t            if (!PyArray_Check(py_V357)) {\n19261\t                PyErr_SetString(PyExc_ValueError, \"expected an ndarray\");\n19262\t                {\n19263\t        __failure = 358;\n19264\t        if (!PyErr_Occurred()) {\n19265\t            PyErr_SetString(PyExc_RuntimeError,\n19266\t                \"Unexpected error in an Op's C code. \"\n19267\t                \"No Python exception was set.\");\n19268\t            }\n19269\t        goto __label_358;}\n19270\t            }\n19271\t            // We expect NPY_FLOAT64\n19272\t            if (!PyArray_ISALIGNED((PyArrayObject*) py_V357)) {\n19273\t                PyArrayObject * tmp = (PyArrayObject*) py_V357;\n19274\t                PyErr_Format(PyExc_NotImplementedError,\n19275\t                             \"expected an aligned array of type %ld \"\n19276\t                             \"(NPY_FLOAT64), got non-aligned array of type %ld\"\n19277\t                             \" with %ld dimensions, with 3 last dims \"\n19278\t                             \"%ld, %ld, %ld\"\n19279\t                             \" and 3 last strides %ld %ld, %ld.\",\n19280\t                             (long int) NPY_FLOAT64,\n19281\t                             (long int) PyArray_TYPE((PyArrayObject*) py_V357),\n19282\t                             (long int) PyArray_NDIM(tmp),\n19283\t                             (long int) (PyArray_NDIM(tmp) >= 3 ?\n19284\t            PyArray_DIMS(tm