Unsupvervised Learning

Clustering is a class of unsupervised learning methods that associates observations according to some specified measure of similarity (e.g. Euclidean distance).

K-means Algorithm

The K-means clustering algorithm associates each point $x_i$ in a set of input points $\{x_1, x_2, \ldots, x_m\}$ to $K$ clusters. Each cluster is specified by a centroid that is the average location of all the points in the cluster. The algorithm proceeds iteratively from arbitrary centroid locations, updating the membership of each point according to minimum distance, then updating the centroid location based on the new cluster membership.

In this sense, it is similar to the expectation maximization (EM) algorithm. Recall that in EM we iteratively assigned labels to observations, according to which mixture component they were most likely to have been derived from. K-means is simpler, in that we just use the minimum distance to assign membership.

The algorithm will have converged when the assignment of points to centroids does not change with each iteration.

Algorithm

  1. Initialize cluster centroids:

$$\mu^{(0)}_1, \ldots, \mu^{(0)}_k \in \mathbb{R}^n$$

  1. Iterate until converged:

    a. Set $c_i = \text{argmin}_j || x_i - \mu_j^{(s)} ||$

    b. Update centroids:

    $$\mu_j^{(s+1)} = \frac{\sum_{i=1}^m I[c_i = j] x_i}{\sum_{i=1}^m I[c_i = j]}$$

The K-means algorithm is simply a Gaussian mixture model with two restrictions:

  1. the covariance matrix is spherical:

    $$\Sigma_k = \sigma I_D$$

  2. the mixture weights are fixed:

    $$\pi_k = \frac{1}{K}$$

Hence, we are only interested in locating the appropriate centroid of the clusters. This serves to speed computation.

We can define the distortion function:

$$J(c,\mu) = \sum_{i]1}^m ||x_i - \mu_{c_i}||$$

which gets smaller at every iteration. So, k-means is coordinate ascent on $J(c,\mu)$

Choosing $k$

To check whether a chosen $k$ is reasonable, one approach is to compare the distances between the centroids to the mean distance bewween each data point and their assigned centroid. A good fit involves relatively large inter-centroid distances.

The appropriate value for k (the number of clusters) may depend on the goals of the analysis, or it may be chosen algorithmically, using an optimization procedure.

Example: clustering random points

In [1]:
%matplotlib inline
import seaborn as sns; sns.set_context('notebook')
import numpy as np
import matplotlib.pyplot as plt

x, y = np.random.uniform(0, 10, 50).reshape(2, 25)
plt.scatter(x, y)
Out[1]:
<matplotlib.collections.PathCollection at 0x10f917080>

Let's start with $k=4$, arbitrarily assigned:

In [2]:
centroids = (3, 3), (3, 7), (7, 3), (7, 7)
In [3]:
np.transpose(centroids)
Out[3]:
array([[3, 3, 7, 7],
       [3, 7, 3, 7]])
In [4]:
plt.scatter(x, y)
plt.scatter(*np.transpose(centroids), c='r', marker='+', s=100)
Out[4]:
<matplotlib.collections.PathCollection at 0x10fb9a898>

We can use the function cdist from SciPy to calculate the distances from each point to each centroid.

In [5]:
from scipy.spatial.distance import cdist

distances = cdist(centroids, list(zip(x,y)))
distances.shape
Out[5]:
(4, 25)

We can make the initial assignment to centroids by picking the minimum distance.

In [6]:
labels = distances.argmin(axis=0)
labels
Out[6]:
array([2, 0, 2, 3, 1, 3, 2, 1, 3, 3, 0, 1, 2, 3, 0, 1, 1, 2, 2, 1, 3, 0, 1,
       0, 1])
In [7]:
plt.scatter(x, y, c=np.array(list('rgbc'))[labels])
plt.scatter(*np.transpose(centroids), c='r', marker='+', s=100)
Out[7]:
<matplotlib.collections.PathCollection at 0x104a01be0>

Now we can re-assign the centroid locations based on the means of the current members' locations.

In [8]:
new_centroids = [(x[labels==i].mean(), y[labels==i].mean())
                 for i in range(len(centroids))]
In [9]:
plt.scatter(x, y, c=np.array(list('rgbc'))[labels])
plt.scatter(*np.transpose(new_centroids), c='r', marker='+', s=100)
Out[9]:
<matplotlib.collections.PathCollection at 0x10ff44f28>

So, we simply iterate these steps until convergence.

In [10]:
centroids = new_centroids
iterations = 20

for _ in range(iterations):
    distances = cdist(centroids, list(zip(x,y)))
    labels = distances.argmin(axis=0)
    centroids = [(x[labels==i].mean(), y[labels==i].mean())
                 for i in range(len(centroids))]
In [11]:
plt.scatter(x, y, c=np.array(list('rgbc'))[labels])
plt.scatter(*np.transpose(centroids), c='r', marker='+', s=100)
Out[11]:
<matplotlib.collections.PathCollection at 0x10ffb6438>

k-means using scikit-learn

The scikit-learn package includes a KMeans class for flexibly fitting K-means models. It includes additional features, such as initialization options and the ability to set the convergence tolerance.

In [12]:
from sklearn.cluster import KMeans
from numpy.random import RandomState
rng = RandomState(1)

# Instantiate model
kmeans = KMeans(n_clusters=4, random_state=rng)
# Fit model
kmeans.fit(np.transpose((x,y)))
Out[12]:
KMeans(algorithm='auto', copy_x=True, init='k-means++', max_iter=300,
    n_clusters=4, n_init=10, n_jobs=1, precompute_distances='auto',
    random_state=<mtrand.RandomState object at 0x1115d93a8>, tol=0.0001,
    verbose=0)

After fitting, we can retrieve the labels and cluster centers.

In [13]:
kmeans.labels_
Out[13]:
array([2, 1, 2, 0, 1, 0, 2, 3, 3, 0, 1, 3, 2, 0, 1, 3, 3, 2, 2, 3, 0, 1, 3,
       1, 3], dtype=int32)
In [14]:
kmeans.cluster_centers_
Out[14]:
array([[ 7.35743718,  6.95641383],
       [ 1.71691979,  2.70212954],
       [ 8.2642307 ,  2.31513011],
       [ 3.75278302,  7.78000755]])

The resulting plot should look very similar to the one we fit by hand.

In [15]:
plt.scatter(x, y, c=np.array(list('rgbc'))[kmeans.labels_])
plt.scatter(*kmeans.cluster_centers_.T, c='r', marker='+', s=100)
Out[15]:
<matplotlib.collections.PathCollection at 0x1115cb438>

Example: Microbiome data

The microbiome.csv dataset contains counts of various microbe taxa extraced from either tissue or stool samples of NICU infants. We might be interested in seeing if samples cluster into groups approximately corresponding to location (tissue or stool) based on the counts of each bacterial taxon.

In [16]:
import pandas as pd

microbiome = pd.read_csv("../data/microbiome.csv")

First, we need to transpose the data so that it can be used with scikit-learn's interface. Fortunately, Pandas makes this relatively painless. The data are stored in long format:

In [17]:
microbiome.head()
Out[17]:
Taxon Patient Group Tissue Stool
0 Firmicutes 1 0 136 4182
1 Firmicutes 2 1 1174 703
2 Firmicutes 3 0 408 3946
3 Firmicutes 4 1 831 8605
4 Firmicutes 5 0 693 50

For this analysis, we need the features (i.e. taxa) in columns, with a row for each sample. First we drop the Group column, then pivot the Taxon column into a column index.

In [18]:
microbiome_pivoted.pivot?
Object `microbiome_pivoted.pivot` not found.
In [19]:
microbiome_pivoted = microbiome.drop('Group', axis=1).pivot(index='Patient', 
                        columns='Taxon').stack(level=0).reset_index()
microbiome_pivoted.columns.name = None
microbiome_pivoted.head()
Out[19]:
Patient level_1 Actinobacteria Bacteroidetes Firmicutes Other Proteobacteria
0 1 Tissue 1590 67 136 195 2469
1 1 Stool 4 0 4182 18 1821
2 2 Tissue 25 0 1174 42 839
3 2 Stool 2 0 703 2 661
4 3 Tissue 259 85 408 316 4414

Then we drop the unused column and change the location variable from str type to int.

In [20]:
microbiome_data = microbiome_pivoted.drop('Patient', 
                        axis=1).rename(columns={'level_1':'Location'}
                                       ).replace({'Tissue': 0 , 'Stool':1})

y = microbiome_data.values[:, 0]
X = microbiome_data.values[:, 1:]
In [21]:
microbiome_data.head()
Out[21]:
Location Actinobacteria Bacteroidetes Firmicutes Other Proteobacteria
0 0 1590 67 136 195 2469
1 1 4 0 4182 18 1821
2 0 25 0 1174 42 839
3 1 2 0 703 2 661
4 0 259 85 408 316 4414

To simplify the analysis, and aid visualization, we will again perform a PCA to isolate the majority of the variation into two principal components.

In [22]:
from sklearn.decomposition import PCA
from itertools import cycle

pca = PCA(n_components=2, whiten=True).fit(X)
X_pca = pca.transform(X)

def plot_2D(data, target, target_names, pca):
    colors = cycle('rgbcmykw')
    target_ids = range(len(target_names))
    plt.figure()
    for i, c, label in zip(target_ids, colors, target_names):
        plt.scatter(data[target == i, 0], data[target == i, 1],
                   c=c, label=label)
    var_explained = pca.explained_variance_ratio_ * 100
    plt.xlabel('First Component: {0:.1f}%'.format(var_explained[0]))
    plt.ylabel('Second Component: {0:.1f}%'.format(var_explained[1]))
    plt.legend()
In [23]:
plot_2D(X_pca, y, ['Tissue', 'Stool'], pca)

We can now create a KMeans object with k=2, and fit the data with it.

In [24]:
km_microbiome = KMeans(n_clusters=2, random_state=rng)
km_microbiome.fit(X_pca)
Out[24]:
KMeans(algorithm='auto', copy_x=True, init='k-means++', max_iter=300,
    n_clusters=2, n_init=10, n_jobs=1, precompute_distances='auto',
    random_state=<mtrand.RandomState object at 0x1115d93a8>, tol=0.0001,
    verbose=0)

From this, we can extract the cluster centroids (in the cluster_center_ attribute) and the group labels (in labels_) in order to generate a plot of the classification result.

In [25]:
np.round(km_microbiome.cluster_centers_, decimals=2)
Out[25]:
array([[ 0.34, -0.38],
       [-1.01,  1.14]])
In [26]:
km_microbiome.labels_
Out[26]:
array([0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0,
       0, 0, 0, 0, 1], dtype=int32)
In [27]:
plot_2D(X_pca, km_microbiome.labels_, ["c1", "c2"], pca)

scikit-learn includes a suite of well-known clustering algorithms. Like most unsupervised learning models in the scikit, they expect the data to be clustered to have the shape (n_samples, n_features):

  • sklearn.cluster.KMeans : The simplest, yet effective clustering algorithm. Needs to be provided with the number of clusters in advance, and assumes that the data is normalized as input (but use a PCA model as preprocessor).
  • sklearn.cluster.MeanShift : Can find better looking clusters than KMeans but is not scalable to high number of samples.
  • sklearn.cluster.DBSCAN : Can detect irregularly shaped clusters based on density, i.e. sparse regions in the input space are likely to become inter-cluster boundaries. Can also detect outliers (samples that are not part of a cluster).

Exercise: NEC

If all the odd-numbered patients are healthy controls and the even-numbered patients have necrotizing enterocolitis (NEC), see if either the tissue or stool samples cluster according to group status.

In [28]:
## Write answer here

Exercise: clustering baseball statistics

We can use clustering to try to find interesting groupings among sets of baseball statistics. Load the baseball dataset and run a clustering algorithm on the set of three statistics:

  • hit rate: hits / at bats
  • strikeout rate: strikeouts / at bats
  • walk rate: bases on balls /at bats

You should probably set a minimum number of at bats to qualify for the analysis, since there are pitchers that get only a handful of at bats each year.

Since we are clustering in 3 dimensions, you can visualize the output as a series of pairwise plots.

In [29]:
import pandas as pd

baseball = pd.read_csv("../data/baseball.csv", index_col=0)
baseball.head()
Out[29]:
player year stint team lg g ab r h X2b ... rbi sb cs bb so ibb hbp sh sf gidp
id
88641 womacto01 2006 2 CHN NL 19 50 6 14 1 ... 2.0 1.0 1.0 4 4.0 0.0 0.0 3.0 0.0 0.0
88643 schilcu01 2006 1 BOS AL 31 2 0 1 0 ... 0.0 0.0 0.0 0 1.0 0.0 0.0 0.0 0.0 0.0
88645 myersmi01 2006 1 NYA AL 62 0 0 0 0 ... 0.0 0.0 0.0 0 0.0 0.0 0.0 0.0 0.0 0.0
88649 helliri01 2006 1 MIL NL 20 3 0 0 0 ... 0.0 0.0 0.0 0 2.0 0.0 0.0 0.0 0.0 0.0
88650 johnsra05 2006 1 NYA AL 33 6 0 1 0 ... 0.0 0.0 0.0 0 4.0 0.0 0.0 0.0 0.0 0.0

5 rows × 22 columns

In [30]:
## Write answer here

DP-Means

The major weakness of the k-means approach to clustering is that the number of clusters needs to be specified at the outset. However, there is usually uncertainty with respect to the appropriate number of clusters for a given dataset. A flexible alternative to k-means that allows for an unknown number of clusters involves using a Bayesian non-parametric mixture model instead (Kulis and Jordan 2011). In particular, a Dirichlet process (DP) mixture model, which we have seen in a previous lecture, probabilistically assigns observations to clusters, using a stick-breaking algorithm.

Recall the definition of a finite mixture model:

$$f(y) = \sum_{h=1}^{k} \pi_h \mathcal{K}(y|\theta_h)$$

where $k$ is the number of mixture components, $\pi_h$ is the mixing coefficient for component $h$, and $K$ specifies the mixing components (e.g. a Gaussian distribution), which has parameters $\theta_h$ for each component.

A DP mixture extends this by placing a Dirichlet prior of dimension $k$ on the mixing coefficients. The distribution over the group indicators can then be specified as a categorical distribution:

$$\begin{aligned} \mathbf{\pi} &\sim \text{Dirichlet}(k, \pi_0) \\ z_1,\ldots,z_n &\sim \text{Categorical}(\mathbf{\pi}) \\ \end{aligned}$$

We might then specify the observations as being a mixture of Gaussians, whose means are drawn from an appropriate prior distribution $P$:

$$\begin{aligned} \theta_1,\ldots,\theta_k &\sim P \\ y_1,\ldots,y_n &\sim N(\theta_{z[i]}, \sigma I) \end{aligned}$$

In [31]:
from sklearn.decomposition import PCA
from sklearn import datasets

iris = datasets.load_iris()

pca = PCA(n_components=2, whiten=True).fit(iris.data)
X_pca = pca.transform(iris.data)
In [32]:
X_pca.shape
Out[32]:
(150, 2)
In [33]:
import pymc3 as pm
import theano.tensor as tt

K = 10
N = X_pca.shape[0]

with pm.Model() as dp_mixture:
    
    α = pm.Gamma('α', 1., 1.)
    β = pm.Beta('β', 1., α, shape=K)
    w = pm.Deterministic('w', β * tt.concatenate([[1], tt.extra_ops.cumprod(1 - β)[:-1]]))
    component = pm.Categorical('component', w, shape=N)

    μ = tt.stack([pm.Normal('μ_%i' % i, mu=tt.zeros(2), sd=1000, shape=2) for i in range(K)])
    σ = pm.Uniform('σ', 0, 5, shape=(K, 2))
    
    sigs = σ[component]
    mus = μ[component]
    
    obs = tt.stack([pm.MvNormal('obs_%i' % i, mus[i], cov=tt.eye(2)*(sigs[i]**2), observed=X_pca[i]) for i in range(N)])
Applied log-transform to α and added transformed α_log_ to model.
Applied logodds-transform to β and added transformed β_logodds_ to model.
Applied interval-transform to σ and added transformed σ_interval_ to model.
In [34]:
with dp_mixture:
    step1 = pm.Metropolis(vars=[α, β, σ, μ])
    step2 = pm.CategoricalGibbsMetropolis(vars=[component])
    trace = pm.sample(10000, step=[step1, step2])
===============================
00001	#include <Python.h>
00002	#include <iostream>
00003	#include "theano_mod_helper.h"
00004	#include <math.h>
00005	#include <numpy/arrayobject.h>
00006	#include <numpy/arrayscalars.h>
00007	#include <vector>
00008	#include <algorithm>
00009	//////////////////////
00010	////  Support Code
00011	//////////////////////
00012	
00013	
00014	    namespace {
00015	    struct __struct_compiled_op_m17e0841797488fe86115b4f81aba8732 {
00016	        PyObject* __ERROR;
00017	
00018	        PyObject* storage_V3;
00019	PyObject* storage_V5;
00020	PyObject* storage_V7;
00021	PyObject* storage_V9;
00022	PyObject* storage_V11;
00023	PyObject* storage_V13;
00024	PyObject* storage_V15;
00025	PyObject* storage_V17;
00026	PyObject* storage_V19;
00027	PyObject* storage_V21;
00028	PyObject* storage_V23;
00029	PyObject* storage_V25;
00030	PyObject* storage_V27;
00031	PyObject* storage_V29;
00032	PyObject* storage_V31;
00033	PyObject* storage_V33;
00034	PyObject* storage_V35;
00035	PyObject* storage_V37;
00036	PyObject* storage_V39;
00037	PyObject* storage_V41;
00038	PyObject* storage_V43;
00039	PyObject* storage_V45;
00040	PyObject* storage_V47;
00041	PyObject* storage_V49;
00042	PyObject* storage_V51;
00043	PyObject* storage_V53;
00044	PyObject* storage_V55;
00045	PyObject* storage_V57;
00046	PyObject* storage_V59;
00047	PyObject* storage_V61;
00048	PyObject* storage_V63;
00049	PyObject* storage_V65;
00050	PyObject* storage_V67;
00051	PyObject* storage_V69;
00052	PyObject* storage_V71;
00053	PyObject* storage_V73;
00054	PyObject* storage_V75;
00055	PyObject* storage_V77;
00056	PyObject* storage_V79;
00057	PyObject* storage_V81;
00058	PyObject* storage_V83;
00059	PyObject* storage_V85;
00060	PyObject* storage_V87;
00061	PyObject* storage_V89;
00062	PyObject* storage_V91;
00063	PyObject* storage_V93;
00064	PyObject* storage_V95;
00065	PyObject* storage_V97;
00066	PyObject* storage_V99;
00067	PyObject* storage_V101;
00068	PyObject* storage_V103;
00069	PyObject* storage_V105;
00070	PyObject* storage_V107;
00071	PyObject* storage_V109;
00072	PyObject* storage_V111;
00073	PyObject* storage_V113;
00074	PyObject* storage_V115;
00075	PyObject* storage_V117;
00076	PyObject* storage_V119;
00077	PyObject* storage_V121;
00078	PyObject* storage_V123;
00079	PyObject* storage_V125;
00080	PyObject* storage_V127;
00081	PyObject* storage_V129;
00082	PyObject* storage_V131;
00083	PyObject* storage_V133;
00084	PyObject* storage_V135;
00085	PyObject* storage_V137;
00086	PyObject* storage_V139;
00087	PyObject* storage_V141;
00088	PyObject* storage_V143;
00089	PyObject* storage_V145;
00090	PyObject* storage_V147;
00091	PyObject* storage_V149;
00092	PyObject* storage_V151;
00093	PyObject* storage_V153;
00094	PyObject* storage_V155;
00095	PyObject* storage_V157;
00096	PyObject* storage_V159;
00097	PyObject* storage_V161;
00098	PyObject* storage_V163;
00099	PyObject* storage_V165;
00100	PyObject* storage_V167;
00101	PyObject* storage_V169;
00102	PyObject* storage_V171;
00103	PyObject* storage_V173;
00104	PyObject* storage_V175;
00105	PyObject* storage_V177;
00106	PyObject* storage_V179;
00107	PyObject* storage_V181;
00108	PyObject* storage_V183;
00109	PyObject* storage_V185;
00110	PyObject* storage_V187;
00111	PyObject* storage_V189;
00112	PyObject* storage_V191;
00113	PyObject* storage_V193;
00114	PyObject* storage_V195;
00115	PyObject* storage_V197;
00116	PyObject* storage_V199;
00117	PyObject* storage_V201;
00118	PyObject* storage_V203;
00119	PyObject* storage_V205;
00120	PyObject* storage_V207;
00121	PyObject* storage_V209;
00122	PyObject* storage_V211;
00123	PyObject* storage_V213;
00124	PyObject* storage_V215;
00125	PyObject* storage_V217;
00126	PyObject* storage_V219;
00127	PyObject* storage_V221;
00128	PyObject* storage_V223;
00129	PyObject* storage_V225;
00130	PyObject* storage_V227;
00131	PyObject* storage_V229;
00132	PyObject* storage_V231;
00133	PyObject* storage_V233;
00134	PyObject* storage_V235;
00135	PyObject* storage_V237;
00136	PyObject* storage_V239;
00137	PyObject* storage_V241;
00138	PyObject* storage_V243;
00139	PyObject* storage_V245;
00140	PyObject* storage_V247;
00141	PyObject* storage_V249;
00142	PyObject* storage_V251;
00143	PyObject* storage_V253;
00144	PyObject* storage_V255;
00145	PyObject* storage_V257;
00146	PyObject* storage_V259;
00147	PyObject* storage_V261;
00148	PyObject* storage_V263;
00149	PyObject* storage_V265;
00150	PyObject* storage_V267;
00151	PyObject* storage_V269;
00152	PyObject* storage_V271;
00153	PyObject* storage_V273;
00154	PyObject* storage_V275;
00155	PyObject* storage_V277;
00156	PyObject* storage_V279;
00157	PyObject* storage_V281;
00158	PyObject* storage_V283;
00159	PyObject* storage_V285;
00160	PyObject* storage_V287;
00161	PyObject* storage_V289;
00162	PyObject* storage_V291;
00163	PyObject* storage_V293;
00164	PyObject* storage_V295;
00165	PyObject* storage_V297;
00166	PyObject* storage_V299;
00167	PyObject* storage_V301;
00168	PyObject* storage_V303;
00169	PyObject* storage_V305;
00170	PyObject* storage_V307;
00171	PyObject* storage_V309;
00172	PyObject* storage_V311;
00173	PyObject* storage_V313;
00174	PyObject* storage_V315;
00175	PyObject* storage_V317;
00176	PyObject* storage_V319;
00177	PyObject* storage_V321;
00178	PyObject* storage_V323;
00179	PyObject* storage_V325;
00180	PyObject* storage_V327;
00181	PyObject* storage_V329;
00182	PyObject* storage_V331;
00183	PyObject* storage_V333;
00184	PyObject* storage_V335;
00185	PyObject* storage_V337;
00186	PyObject* storage_V339;
00187	PyObject* storage_V341;
00188	PyObject* storage_V343;
00189	PyObject* storage_V345;
00190	PyObject* storage_V347;
00191	PyObject* storage_V349;
00192	PyObject* storage_V351;
00193	PyObject* storage_V353;
00194	PyObject* storage_V355;
00195	PyObject* storage_V357;
00196	PyObject* storage_V359;
00197	PyObject* storage_V361;
00198	PyObject* storage_V363;
00199	PyObject* storage_V365;
00200	PyObject* storage_V367;
00201	PyObject* storage_V369;
00202	PyObject* storage_V371;
00203	PyObject* storage_V373;
00204	PyObject* storage_V375;
00205	PyObject* storage_V377;
00206	PyObject* storage_V379;
00207	PyObject* storage_V381;
00208	PyObject* storage_V383;
00209	PyObject* storage_V385;
00210	PyObject* storage_V387;
00211	PyObject* storage_V389;
00212	PyObject* storage_V391;
00213	PyObject* storage_V393;
00214	PyObject* storage_V395;
00215	PyObject* storage_V397;
00216	PyObject* storage_V399;
00217	PyObject* storage_V401;
00218	PyObject* storage_V403;
00219	PyObject* storage_V405;
00220	PyObject* storage_V407;
00221	PyObject* storage_V409;
00222	PyObject* storage_V411;
00223	PyObject* storage_V413;
00224	PyObject* storage_V415;
00225	PyObject* storage_V417;
00226	PyObject* storage_V419;
00227	PyObject* storage_V421;
00228	PyObject* storage_V423;
00229	PyObject* storage_V425;
00230	PyObject* storage_V427;
00231	PyObject* storage_V429;
00232	PyObject* storage_V431;
00233	PyObject* storage_V433;
00234	PyObject* storage_V435;
00235	PyObject* storage_V437;
00236	PyObject* storage_V439;
00237	PyObject* storage_V441;
00238	PyObject* storage_V443;
00239	PyObject* storage_V445;
00240	PyObject* storage_V447;
00241	PyObject* storage_V449;
00242	PyObject* storage_V451;
00243	PyObject* storage_V453;
00244	PyObject* storage_V455;
00245	PyObject* storage_V457;
00246	PyObject* storage_V459;
00247	PyObject* storage_V461;
00248	PyObject* storage_V463;
00249	PyObject* storage_V465;
00250	PyObject* storage_V467;
00251	PyObject* storage_V469;
00252	PyObject* storage_V471;
00253	PyObject* storage_V473;
00254	PyObject* storage_V475;
00255	PyObject* storage_V477;
00256	PyObject* storage_V479;
00257	PyObject* storage_V481;
00258	PyObject* storage_V483;
00259	PyObject* storage_V485;
00260	PyObject* storage_V487;
00261	PyObject* storage_V489;
00262	PyObject* storage_V491;
00263	PyObject* storage_V493;
00264	PyObject* storage_V495;
00265	PyObject* storage_V497;
00266	PyObject* storage_V499;
00267	PyObject* storage_V501;
00268	PyObject* storage_V503;
00269	PyObject* storage_V505;
00270	PyObject* storage_V507;
00271	PyObject* storage_V509;
00272	PyObject* storage_V511;
00273	PyObject* storage_V513;
00274	PyObject* storage_V515;
00275	PyObject* storage_V517;
00276	PyObject* storage_V519;
00277	PyObject* storage_V521;
00278	PyObject* storage_V523;
00279	PyObject* storage_V525;
00280	PyObject* storage_V527;
00281	PyObject* storage_V529;
00282	PyObject* storage_V531;
00283	PyObject* storage_V533;
00284	PyObject* storage_V535;
00285	PyObject* storage_V537;
00286	PyObject* storage_V539;
00287	PyObject* storage_V541;
00288	PyObject* storage_V543;
00289	PyObject* storage_V545;
00290	PyObject* storage_V547;
00291	PyObject* storage_V549;
00292	PyObject* storage_V551;
00293	PyObject* storage_V553;
00294	PyObject* storage_V555;
00295	PyObject* storage_V557;
00296	PyObject* storage_V559;
00297	PyObject* storage_V561;
00298	PyObject* storage_V563;
00299	PyObject* storage_V565;
00300	PyObject* storage_V567;
00301	PyObject* storage_V569;
00302	PyObject* storage_V571;
00303	PyObject* storage_V573;
00304	PyObject* storage_V575;
00305	PyObject* storage_V577;
00306	PyObject* storage_V579;
00307	PyObject* storage_V581;
00308	PyObject* storage_V583;
00309	PyObject* storage_V585;
00310	PyObject* storage_V587;
00311	PyObject* storage_V589;
00312	PyObject* storage_V591;
00313	PyObject* storage_V593;
00314	PyObject* storage_V595;
00315	PyObject* storage_V597;
00316	PyObject* storage_V599;
00317	PyObject* storage_V601;
00318	PyObject* storage_V603;
00319	PyObject* storage_V605;
00320	PyObject* storage_V607;
00321	PyObject* storage_V609;
00322	PyObject* storage_V611;
00323	PyObject* storage_V613;
00324	PyObject* storage_V615;
00325	PyObject* storage_V617;
00326	PyObject* storage_V619;
00327	PyObject* storage_V621;
00328	PyObject* storage_V623;
00329	PyObject* storage_V625;
00330	PyObject* storage_V627;
00331	PyObject* storage_V629;
00332	PyObject* storage_V631;
00333	PyObject* storage_V633;
00334	PyObject* storage_V635;
00335	PyObject* storage_V637;
00336	PyObject* storage_V639;
00337	PyObject* storage_V641;
00338	PyObject* storage_V643;
00339	PyObject* storage_V645;
00340	PyObject* storage_V647;
00341	PyObject* storage_V649;
00342	PyObject* storage_V651;
00343	PyObject* storage_V653;
00344	PyObject* storage_V655;
00345	PyObject* storage_V657;
00346	PyObject* storage_V659;
00347	PyObject* storage_V661;
00348	PyObject* storage_V663;
00349	PyObject* storage_V665;
00350	PyObject* storage_V667;
00351	PyObject* storage_V669;
00352	PyObject* storage_V671;
00353	PyObject* storage_V673;
00354	PyObject* storage_V675;
00355	PyObject* storage_V677;
00356	PyObject* storage_V679;
00357	PyObject* storage_V681;
00358	PyObject* storage_V683;
00359	PyObject* storage_V685;
00360	PyObject* storage_V687;
00361	PyObject* storage_V689;
00362	PyObject* storage_V691;
00363	PyObject* storage_V693;
00364	PyObject* storage_V695;
00365	PyObject* storage_V697;
00366	PyObject* storage_V699;
00367	PyObject* storage_V701;
00368	PyObject* storage_V703;
00369	PyObject* storage_V705;
00370	PyObject* storage_V707;
00371	PyObject* storage_V709;
00372	PyObject* storage_V711;
00373	PyObject* storage_V713;
00374	PyObject* storage_V715;
00375	PyObject* storage_V717;
00376	PyObject* storage_V719;
00377	PyObject* storage_V721;
00378	PyObject* storage_V723;
00379	PyObject* storage_V725;
00380	PyObject* storage_V727;
00381	PyObject* storage_V729;
00382	PyObject* storage_V731;
00383	PyObject* storage_V733;
00384	PyObject* storage_V735;
00385	PyObject* storage_V737;
00386	PyObject* storage_V739;
00387	PyObject* storage_V741;
00388	PyObject* storage_V743;
00389	PyObject* storage_V745;
00390	PyObject* storage_V747;
00391	PyObject* storage_V749;
00392	PyObject* storage_V751;
00393	PyObject* storage_V753;
00394	PyObject* storage_V755;
00395	PyObject* storage_V757;
00396	PyObject* storage_V759;
00397	PyObject* storage_V761;
00398	PyObject* storage_V763;
00399	PyObject* storage_V765;
00400	PyObject* storage_V767;
00401	PyObject* storage_V769;
00402	PyObject* storage_V771;
00403	PyObject* storage_V773;
00404	PyObject* storage_V775;
00405	PyObject* storage_V777;
00406	PyObject* storage_V779;
00407	PyObject* storage_V781;
00408	PyObject* storage_V783;
00409	PyObject* storage_V785;
00410	PyObject* storage_V787;
00411	PyObject* storage_V789;
00412	PyObject* storage_V791;
00413	PyObject* storage_V793;
00414	PyObject* storage_V795;
00415	PyObject* storage_V797;
00416	PyObject* storage_V799;
00417	PyObject* storage_V801;
00418	PyObject* storage_V803;
00419	PyObject* storage_V805;
00420	PyObject* storage_V807;
00421	PyObject* storage_V809;
00422	PyObject* storage_V811;
00423	PyObject* storage_V813;
00424	PyObject* storage_V815;
00425	PyObject* storage_V817;
00426	PyObject* storage_V819;
00427	PyObject* storage_V821;
00428	PyObject* storage_V823;
00429	PyObject* storage_V825;
00430	PyObject* storage_V827;
00431	PyObject* storage_V829;
00432	PyObject* storage_V831;
00433	PyObject* storage_V833;
00434	PyObject* storage_V835;
00435	PyObject* storage_V837;
00436	PyObject* storage_V839;
00437	PyObject* storage_V841;
00438	PyObject* storage_V843;
00439	PyObject* storage_V845;
00440	PyObject* storage_V847;
00441	PyObject* storage_V849;
00442	PyObject* storage_V851;
00443	PyObject* storage_V853;
00444	PyObject* storage_V855;
00445	PyObject* storage_V857;
00446	PyObject* storage_V859;
00447	PyObject* storage_V861;
00448	PyObject* storage_V863;
00449	PyObject* storage_V865;
00450	PyObject* storage_V867;
00451	PyObject* storage_V869;
00452	PyObject* storage_V871;
00453	PyObject* storage_V873;
00454	PyObject* storage_V875;
00455	PyObject* storage_V877;
00456	PyObject* storage_V879;
00457	PyObject* storage_V881;
00458	PyObject* storage_V883;
00459	PyObject* storage_V885;
00460	PyObject* storage_V887;
00461	PyObject* storage_V889;
00462	PyObject* storage_V891;
00463	PyObject* storage_V893;
00464	PyObject* storage_V895;
00465	PyObject* storage_V897;
00466	PyObject* storage_V899;
00467	PyObject* storage_V901;
00468	PyObject* storage_V903;
00469	PyObject* storage_V905;
00470	PyObject* storage_V907;
00471	PyObject* storage_V909;
00472	PyObject* storage_V1;
00473	        
00474	
00475	        __struct_compiled_op_m17e0841797488fe86115b4f81aba8732() {
00476	            // This is only somewhat safe because we:
00477	            //  1) Are not a virtual class
00478	            //  2) Do not use any virtual classes in the members
00479	            //  3) Deal with mostly POD and pointers
00480	
00481	            // If this changes, we would have to revise this, but for
00482	            // now I am tired of chasing segfaults because
00483	            // initialization code had an error and some pointer has
00484	            // a junk value.
00485	            memset(this, 0, sizeof(*this));
00486	        }
00487	        ~__struct_compiled_op_m17e0841797488fe86115b4f81aba8732(void) {
00488	            cleanup();
00489	        }
00490	
00491	        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_V605, PyObject* storage_V607, PyObject* storage_V609, PyObject* storage_V611, PyObject* storage_V613, PyObject* storage_V615, PyObject* storage_V617, PyObject* storage_V619, PyObject* storage_V621, PyObject* storage_V623, PyObject* storage_V625, PyObject* storage_V627, PyObject* storage_V629, PyObject* storage_V631, PyObject* storage_V633, PyObject* storage_V635, PyObject* storage_V637, PyObject* storage_V639, PyObject* storage_V641, PyObject* storage_V643, PyObject* storage_V645, PyObject* storage_V647, PyObject* storage_V649, PyObject* storage_V651, PyObject* storage_V653, PyObject* storage_V655, PyObject* storage_V657, PyObject* storage_V659, PyObject* storage_V661, PyObject* storage_V663, PyObject* storage_V665, PyObject* storage_V667, PyObject* storage_V669, PyObject* storage_V671, PyObject* storage_V673, PyObject* storage_V675, PyObject* storage_V677, PyObject* storage_V679, PyObject* storage_V681, PyObject* storage_V683, PyObject* storage_V685, PyObject* storage_V687, PyObject* storage_V689, PyObject* storage_V691, PyObject* storage_V693, PyObject* storage_V695, PyObject* storage_V697, PyObject* storage_V699, PyObject* storage_V701, PyObject* storage_V703, PyObject* storage_V705, PyObject* storage_V707, PyObject* storage_V709, PyObject* storage_V711, PyObject* storage_V713, PyObject* storage_V715, PyObject* storage_V717, PyObject* storage_V719, PyObject* storage_V721, PyObject* storage_V723, PyObject* storage_V725, PyObject* storage_V727, PyObject* storage_V729, PyObject* storage_V731, PyObject* storage_V733, PyObject* storage_V735, PyObject* storage_V737, PyObject* storage_V739, PyObject* storage_V741, PyObject* storage_V743, PyObject* storage_V745, PyObject* storage_V747, PyObject* storage_V749, PyObject* storage_V751, PyObject* storage_V753, PyObject* storage_V755, PyObject* storage_V757, PyObject* storage_V759, PyObject* storage_V761, PyObject* storage_V763, PyObject* storage_V765, PyObject* storage_V767, PyObject* storage_V769, PyObject* storage_V771, PyObject* storage_V773, PyObject* storage_V775, PyObject* storage_V777, PyObject* storage_V779, PyObject* storage_V781, PyObject* storage_V783, PyObject* storage_V785, PyObject* storage_V787, PyObject* storage_V789, PyObject* storage_V791, PyObject* storage_V793, PyObject* storage_V795, PyObject* storage_V797, PyObject* storage_V799, PyObject* storage_V801, PyObject* storage_V803, PyObject* storage_V805, PyObject* storage_V807, PyObject* storage_V809, PyObject* storage_V811, PyObject* storage_V813, PyObject* storage_V815, PyObject* storage_V817, PyObject* storage_V819, PyObject* storage_V821, PyObject* storage_V823, PyObject* storage_V825, PyObject* storage_V827, PyObject* storage_V829, PyObject* storage_V831, PyObject* storage_V833, PyObject* storage_V835, PyObject* storage_V837, PyObject* storage_V839, PyObject* storage_V841, PyObject* storage_V843, PyObject* storage_V845, PyObject* storage_V847, PyObject* storage_V849, PyObject* storage_V851, PyObject* storage_V853, PyObject* storage_V855, PyObject* storage_V857, PyObject* storage_V859, PyObject* storage_V861, PyObject* storage_V863, PyObject* storage_V865, PyObject* storage_V867, PyObject* storage_V869, PyObject* storage_V871, PyObject* storage_V873, PyObject* storage_V875, PyObject* storage_V877, PyObject* storage_V879, PyObject* storage_V881, PyObject* storage_V883, PyObject* storage_V885, PyObject* storage_V887, PyObject* storage_V889, PyObject* storage_V891, PyObject* storage_V893, PyObject* storage_V895, PyObject* storage_V897, PyObject* storage_V899, PyObject* storage_V901, PyObject* storage_V903, PyObject* storage_V905, PyObject* storage_V907, PyObject* storage_V909, PyObject* storage_V1) {
00492	            Py_XINCREF(storage_V3);
00493	Py_XINCREF(storage_V5);
00494	Py_XINCREF(storage_V7);
00495	Py_XINCREF(storage_V9);
00496	Py_XINCREF(storage_V11);
00497	Py_XINCREF(storage_V13);
00498	Py_XINCREF(storage_V15);
00499	Py_XINCREF(storage_V17);
00500	Py_XINCREF(storage_V19);
00501	Py_XINCREF(storage_V21);
00502	Py_XINCREF(storage_V23);
00503	Py_XINCREF(storage_V25);
00504	Py_XINCREF(storage_V27);
00505	Py_XINCREF(storage_V29);
00506	Py_XINCREF(storage_V31);
00507	Py_XINCREF(storage_V33);
00508	Py_XINCREF(storage_V35);
00509	Py_XINCREF(storage_V37);
00510	Py_XINCREF(storage_V39);
00511	Py_XINCREF(storage_V41);
00512	Py_XINCREF(storage_V43);
00513	Py_XINCREF(storage_V45);
00514	Py_XINCREF(storage_V47);
00515	Py_XINCREF(storage_V49);
00516	Py_XINCREF(storage_V51);
00517	Py_XINCREF(storage_V53);
00518	Py_XINCREF(storage_V55);
00519	Py_XINCREF(storage_V57);
00520	Py_XINCREF(storage_V59);
00521	Py_XINCREF(storage_V61);
00522	Py_XINCREF(storage_V63);
00523	Py_XINCREF(storage_V65);
00524	Py_XINCREF(storage_V67);
00525	Py_XINCREF(storage_V69);
00526	Py_XINCREF(storage_V71);
00527	Py_XINCREF(storage_V73);
00528	Py_XINCREF(storage_V75);
00529	Py_XINCREF(storage_V77);
00530	Py_XINCREF(storage_V79);
00531	Py_XINCREF(storage_V81);
00532	Py_XINCREF(storage_V83);
00533	Py_XINCREF(storage_V85);
00534	Py_XINCREF(storage_V87);
00535	Py_XINCREF(storage_V89);
00536	Py_XINCREF(storage_V91);
00537	Py_XINCREF(storage_V93);
00538	Py_XINCREF(storage_V95);
00539	Py_XINCREF(storage_V97);
00540	Py_XINCREF(storage_V99);
00541	Py_XINCREF(storage_V101);
00542	Py_XINCREF(storage_V103);
00543	Py_XINCREF(storage_V105);
00544	Py_XINCREF(storage_V107);
00545	Py_XINCREF(storage_V109);
00546	Py_XINCREF(storage_V111);
00547	Py_XINCREF(storage_V113);
00548	Py_XINCREF(storage_V115);
00549	Py_XINCREF(storage_V117);
00550	Py_XINCREF(storage_V119);
00551	Py_XINCREF(storage_V121);
00552	Py_XINCREF(storage_V123);
00553	Py_XINCREF(storage_V125);
00554	Py_XINCREF(storage_V127);
00555	Py_XINCREF(storage_V129);
00556	Py_XINCREF(storage_V131);
00557	Py_XINCREF(storage_V133);
00558	Py_XINCREF(storage_V135);
00559	Py_XINCREF(storage_V137);
00560	Py_XINCREF(storage_V139);
00561	Py_XINCREF(storage_V141);
00562	Py_XINCREF(storage_V143);
00563	Py_XINCREF(storage_V145);
00564	Py_XINCREF(storage_V147);
00565	Py_XINCREF(storage_V149);
00566	Py_XINCREF(storage_V151);
00567	Py_XINCREF(storage_V153);
00568	Py_XINCREF(storage_V155);
00569	Py_XINCREF(storage_V157);
00570	Py_XINCREF(storage_V159);
00571	Py_XINCREF(storage_V161);
00572	Py_XINCREF(storage_V163);
00573	Py_XINCREF(storage_V165);
00574	Py_XINCREF(storage_V167);
00575	Py_XINCREF(storage_V169);
00576	Py_XINCREF(storage_V171);
00577	Py_XINCREF(storage_V173);
00578	Py_XINCREF(storage_V175);
00579	Py_XINCREF(storage_V177);
00580	Py_XINCREF(storage_V179);
00581	Py_XINCREF(storage_V181);
00582	Py_XINCREF(storage_V183);
00583	Py_XINCREF(storage_V185);
00584	Py_XINCREF(storage_V187);
00585	Py_XINCREF(storage_V189);
00586	Py_XINCREF(storage_V191);
00587	Py_XINCREF(storage_V193);
00588	Py_XINCREF(storage_V195);
00589	Py_XINCREF(storage_V197);
00590	Py_XINCREF(storage_V199);
00591	Py_XINCREF(storage_V201);
00592	Py_XINCREF(storage_V203);
00593	Py_XINCREF(storage_V205);
00594	Py_XINCREF(storage_V207);
00595	Py_XINCREF(storage_V209);
00596	Py_XINCREF(storage_V211);
00597	Py_XINCREF(storage_V213);
00598	Py_XINCREF(storage_V215);
00599	Py_XINCREF(storage_V217);
00600	Py_XINCREF(storage_V219);
00601	Py_XINCREF(storage_V221);
00602	Py_XINCREF(storage_V223);
00603	Py_XINCREF(storage_V225);
00604	Py_XINCREF(storage_V227);
00605	Py_XINCREF(storage_V229);
00606	Py_XINCREF(storage_V231);
00607	Py_XINCREF(storage_V233);
00608	Py_XINCREF(storage_V235);
00609	Py_XINCREF(storage_V237);
00610	Py_XINCREF(storage_V239);
00611	Py_XINCREF(storage_V241);
00612	Py_XINCREF(storage_V243);
00613	Py_XINCREF(storage_V245);
00614	Py_XINCREF(storage_V247);
00615	Py_XINCREF(storage_V249);
00616	Py_XINCREF(storage_V251);
00617	Py_XINCREF(storage_V253);
00618	Py_XINCREF(storage_V255);
00619	Py_XINCREF(storage_V257);
00620	Py_XINCREF(storage_V259);
00621	Py_XINCREF(storage_V261);
00622	Py_XINCREF(storage_V263);
00623	Py_XINCREF(storage_V265);
00624	Py_XINCREF(storage_V267);
00625	Py_XINCREF(storage_V269);
00626	Py_XINCREF(storage_V271);
00627	Py_XINCREF(storage_V273);
00628	Py_XINCREF(storage_V275);
00629	Py_XINCREF(storage_V277);
00630	Py_XINCREF(storage_V279);
00631	Py_XINCREF(storage_V281);
00632	Py_XINCREF(storage_V283);
00633	Py_XINCREF(storage_V285);
00634	Py_XINCREF(storage_V287);
00635	Py_XINCREF(storage_V289);
00636	Py_XINCREF(storage_V291);
00637	Py_XINCREF(storage_V293);
00638	Py_XINCREF(storage_V295);
00639	Py_XINCREF(storage_V297);
00640	Py_XINCREF(storage_V299);
00641	Py_XINCREF(storage_V301);
00642	Py_XINCREF(storage_V303);
00643	Py_XINCREF(storage_V305);
00644	Py_XINCREF(storage_V307);
00645	Py_XINCREF(storage_V309);
00646	Py_XINCREF(storage_V311);
00647	Py_XINCREF(storage_V313);
00648	Py_XINCREF(storage_V315);
00649	Py_XINCREF(storage_V317);
00650	Py_XINCREF(storage_V319);
00651	Py_XINCREF(storage_V321);
00652	Py_XINCREF(storage_V323);
00653	Py_XINCREF(storage_V325);
00654	Py_XINCREF(storage_V327);
00655	Py_XINCREF(storage_V329);
00656	Py_XINCREF(storage_V331);
00657	Py_XINCREF(storage_V333);
00658	Py_XINCREF(storage_V335);
00659	Py_XINCREF(storage_V337);
00660	Py_XINCREF(storage_V339);
00661	Py_XINCREF(storage_V341);
00662	Py_XINCREF(storage_V343);
00663	Py_XINCREF(storage_V345);
00664	Py_XINCREF(storage_V347);
00665	Py_XINCREF(storage_V349);
00666	Py_XINCREF(storage_V351);
00667	Py_XINCREF(storage_V353);
00668	Py_XINCREF(storage_V355);
00669	Py_XINCREF(storage_V357);
00670	Py_XINCREF(storage_V359);
00671	Py_XINCREF(storage_V361);
00672	Py_XINCREF(storage_V363);
00673	Py_XINCREF(storage_V365);
00674	Py_XINCREF(storage_V367);
00675	Py_XINCREF(storage_V369);
00676	Py_XINCREF(storage_V371);
00677	Py_XINCREF(storage_V373);
00678	Py_XINCREF(storage_V375);
00679	Py_XINCREF(storage_V377);
00680	Py_XINCREF(storage_V379);
00681	Py_XINCREF(storage_V381);
00682	Py_XINCREF(storage_V383);
00683	Py_XINCREF(storage_V385);
00684	Py_XINCREF(storage_V387);
00685	Py_XINCREF(storage_V389);
00686	Py_XINCREF(storage_V391);
00687	Py_XINCREF(storage_V393);
00688	Py_XINCREF(storage_V395);
00689	Py_XINCREF(storage_V397);
00690	Py_XINCREF(storage_V399);
00691	Py_XINCREF(storage_V401);
00692	Py_XINCREF(storage_V403);
00693	Py_XINCREF(storage_V405);
00694	Py_XINCREF(storage_V407);
00695	Py_XINCREF(storage_V409);
00696	Py_XINCREF(storage_V411);
00697	Py_XINCREF(storage_V413);
00698	Py_XINCREF(storage_V415);
00699	Py_XINCREF(storage_V417);
00700	Py_XINCREF(storage_V419);
00701	Py_XINCREF(storage_V421);
00702	Py_XINCREF(storage_V423);
00703	Py_XINCREF(storage_V425);
00704	Py_XINCREF(storage_V427);
00705	Py_XINCREF(storage_V429);
00706	Py_XINCREF(storage_V431);
00707	Py_XINCREF(storage_V433);
00708	Py_XINCREF(storage_V435);
00709	Py_XINCREF(storage_V437);
00710	Py_XINCREF(storage_V439);
00711	Py_XINCREF(storage_V441);
00712	Py_XINCREF(storage_V443);
00713	Py_XINCREF(storage_V445);
00714	Py_XINCREF(storage_V447);
00715	Py_XINCREF(storage_V449);
00716	Py_XINCREF(storage_V451);
00717	Py_XINCREF(storage_V453);
00718	Py_XINCREF(storage_V455);
00719	Py_XINCREF(storage_V457);
00720	Py_XINCREF(storage_V459);
00721	Py_XINCREF(storage_V461);
00722	Py_XINCREF(storage_V463);
00723	Py_XINCREF(storage_V465);
00724	Py_XINCREF(storage_V467);
00725	Py_XINCREF(storage_V469);
00726	Py_XINCREF(storage_V471);
00727	Py_XINCREF(storage_V473);
00728	Py_XINCREF(storage_V475);
00729	Py_XINCREF(storage_V477);
00730	Py_XINCREF(storage_V479);
00731	Py_XINCREF(storage_V481);
00732	Py_XINCREF(storage_V483);
00733	Py_XINCREF(storage_V485);
00734	Py_XINCREF(storage_V487);
00735	Py_XINCREF(storage_V489);
00736	Py_XINCREF(storage_V491);
00737	Py_XINCREF(storage_V493);
00738	Py_XINCREF(storage_V495);
00739	Py_XINCREF(storage_V497);
00740	Py_XINCREF(storage_V499);
00741	Py_XINCREF(storage_V501);
00742	Py_XINCREF(storage_V503);
00743	Py_XINCREF(storage_V505);
00744	Py_XINCREF(storage_V507);
00745	Py_XINCREF(storage_V509);
00746	Py_XINCREF(storage_V511);
00747	Py_XINCREF(storage_V513);
00748	Py_XINCREF(storage_V515);
00749	Py_XINCREF(storage_V517);
00750	Py_XINCREF(storage_V519);
00751	Py_XINCREF(storage_V521);
00752	Py_XINCREF(storage_V523);
00753	Py_XINCREF(storage_V525);
00754	Py_XINCREF(storage_V527);
00755	Py_XINCREF(storage_V529);
00756	Py_XINCREF(storage_V531);
00757	Py_XINCREF(storage_V533);
00758	Py_XINCREF(storage_V535);
00759	Py_XINCREF(storage_V537);
00760	Py_XINCREF(storage_V539);
00761	Py_XINCREF(storage_V541);
00762	Py_XINCREF(storage_V543);
00763	Py_XINCREF(storage_V545);
00764	Py_XINCREF(storage_V547);
00765	Py_XINCREF(storage_V549);
00766	Py_XINCREF(storage_V551);
00767	Py_XINCREF(storage_V553);
00768	Py_XINCREF(storage_V555);
00769	Py_XINCREF(storage_V557);
00770	Py_XINCREF(storage_V559);
00771	Py_XINCREF(storage_V561);
00772	Py_XINCREF(storage_V563);
00773	Py_XINCREF(storage_V565);
00774	Py_XINCREF(storage_V567);
00775	Py_XINCREF(storage_V569);
00776	Py_XINCREF(storage_V571);
00777	Py_XINCREF(storage_V573);
00778	Py_XINCREF(storage_V575);
00779	Py_XINCREF(storage_V577);
00780	Py_XINCREF(storage_V579);
00781	Py_XINCREF(storage_V581);
00782	Py_XINCREF(storage_V583);
00783	Py_XINCREF(storage_V585);
00784	Py_XINCREF(storage_V587);
00785	Py_XINCREF(storage_V589);
00786	Py_XINCREF(storage_V591);
00787	Py_XINCREF(storage_V593);
00788	Py_XINCREF(storage_V595);
00789	Py_XINCREF(storage_V597);
00790	Py_XINCREF(storage_V599);
00791	Py_XINCREF(storage_V601);
00792	Py_XINCREF(storage_V603);
00793	Py_XINCREF(storage_V605);
00794	Py_XINCREF(storage_V607);
00795	Py_XINCREF(storage_V609);
00796	Py_XINCREF(storage_V611);
00797	Py_XINCREF(storage_V613);
00798	Py_XINCREF(storage_V615);
00799	Py_XINCREF(storage_V617);
00800	Py_XINCREF(storage_V619);
00801	Py_XINCREF(storage_V621);
00802	Py_XINCREF(storage_V623);
00803	Py_XINCREF(storage_V625);
00804	Py_XINCREF(storage_V627);
00805	Py_XINCREF(storage_V629);
00806	Py_XINCREF(storage_V631);
00807	Py_XINCREF(storage_V633);
00808	Py_XINCREF(storage_V635);
00809	Py_XINCREF(storage_V637);
00810	Py_XINCREF(storage_V639);
00811	Py_XINCREF(storage_V641);
00812	Py_XINCREF(storage_V643);
00813	Py_XINCREF(storage_V645);
00814	Py_XINCREF(storage_V647);
00815	Py_XINCREF(storage_V649);
00816	Py_XINCREF(storage_V651);
00817	Py_XINCREF(storage_V653);
00818	Py_XINCREF(storage_V655);
00819	Py_XINCREF(storage_V657);
00820	Py_XINCREF(storage_V659);
00821	Py_XINCREF(storage_V661);
00822	Py_XINCREF(storage_V663);
00823	Py_XINCREF(storage_V665);
00824	Py_XINCREF(storage_V667);
00825	Py_XINCREF(storage_V669);
00826	Py_XINCREF(storage_V671);
00827	Py_XINCREF(storage_V673);
00828	Py_XINCREF(storage_V675);
00829	Py_XINCREF(storage_V677);
00830	Py_XINCREF(storage_V679);
00831	Py_XINCREF(storage_V681);
00832	Py_XINCREF(storage_V683);
00833	Py_XINCREF(storage_V685);
00834	Py_XINCREF(storage_V687);
00835	Py_XINCREF(storage_V689);
00836	Py_XINCREF(storage_V691);
00837	Py_XINCREF(storage_V693);
00838	Py_XINCREF(storage_V695);
00839	Py_XINCREF(storage_V697);
00840	Py_XINCREF(storage_V699);
00841	Py_XINCREF(storage_V701);
00842	Py_XINCREF(storage_V703);
00843	Py_XINCREF(storage_V705);
00844	Py_XINCREF(storage_V707);
00845	Py_XINCREF(storage_V709);
00846	Py_XINCREF(storage_V711);
00847	Py_XINCREF(storage_V713);
00848	Py_XINCREF(storage_V715);
00849	Py_XINCREF(storage_V717);
00850	Py_XINCREF(storage_V719);
00851	Py_XINCREF(storage_V721);
00852	Py_XINCREF(storage_V723);
00853	Py_XINCREF(storage_V725);
00854	Py_XINCREF(storage_V727);
00855	Py_XINCREF(storage_V729);
00856	Py_XINCREF(storage_V731);
00857	Py_XINCREF(storage_V733);
00858	Py_XINCREF(storage_V735);
00859	Py_XINCREF(storage_V737);
00860	Py_XINCREF(storage_V739);
00861	Py_XINCREF(storage_V741);
00862	Py_XINCREF(storage_V743);
00863	Py_XINCREF(storage_V745);
00864	Py_XINCREF(storage_V747);
00865	Py_XINCREF(storage_V749);
00866	Py_XINCREF(storage_V751);
00867	Py_XINCREF(storage_V753);
00868	Py_XINCREF(storage_V755);
00869	Py_XINCREF(storage_V757);
00870	Py_XINCREF(storage_V759);
00871	Py_XINCREF(storage_V761);
00872	Py_XINCREF(storage_V763);
00873	Py_XINCREF(storage_V765);
00874	Py_XINCREF(storage_V767);
00875	Py_XINCREF(storage_V769);
00876	Py_XINCREF(storage_V771);
00877	Py_XINCREF(storage_V773);
00878	Py_XINCREF(storage_V775);
00879	Py_XINCREF(storage_V777);
00880	Py_XINCREF(storage_V779);
00881	Py_XINCREF(storage_V781);
00882	Py_XINCREF(storage_V783);
00883	Py_XINCREF(storage_V785);
00884	Py_XINCREF(storage_V787);
00885	Py_XINCREF(storage_V789);
00886	Py_XINCREF(storage_V791);
00887	Py_XINCREF(storage_V793);
00888	Py_XINCREF(storage_V795);
00889	Py_XINCREF(storage_V797);
00890	Py_XINCREF(storage_V799);
00891	Py_XINCREF(storage_V801);
00892	Py_XINCREF(storage_V803);
00893	Py_XINCREF(storage_V805);
00894	Py_XINCREF(storage_V807);
00895	Py_XINCREF(storage_V809);
00896	Py_XINCREF(storage_V811);
00897	Py_XINCREF(storage_V813);
00898	Py_XINCREF(storage_V815);
00899	Py_XINCREF(storage_V817);
00900	Py_XINCREF(storage_V819);
00901	Py_XINCREF(storage_V821);
00902	Py_XINCREF(storage_V823);
00903	Py_XINCREF(storage_V825);
00904	Py_XINCREF(storage_V827);
00905	Py_XINCREF(storage_V829);
00906	Py_XINCREF(storage_V831);
00907	Py_XINCREF(storage_V833);
00908	Py_XINCREF(storage_V835);
00909	Py_XINCREF(storage_V837);
00910	Py_XINCREF(storage_V839);
00911	Py_XINCREF(storage_V841);
00912	Py_XINCREF(storage_V843);
00913	Py_XINCREF(storage_V845);
00914	Py_XINCREF(storage_V847);
00915	Py_XINCREF(storage_V849);
00916	Py_XINCREF(storage_V851);
00917	Py_XINCREF(storage_V853);
00918	Py_XINCREF(storage_V855);
00919	Py_XINCREF(storage_V857);
00920	Py_XINCREF(storage_V859);
00921	Py_XINCREF(storage_V861);
00922	Py_XINCREF(storage_V863);
00923	Py_XINCREF(storage_V865);
00924	Py_XINCREF(storage_V867);
00925	Py_XINCREF(storage_V869);
00926	Py_XINCREF(storage_V871);
00927	Py_XINCREF(storage_V873);
00928	Py_XINCREF(storage_V875);
00929	Py_XINCREF(storage_V877);
00930	Py_XINCREF(storage_V879);
00931	Py_XINCREF(storage_V881);
00932	Py_XINCREF(storage_V883);
00933	Py_XINCREF(storage_V885);
00934	Py_XINCREF(storage_V887);
00935	Py_XINCREF(storage_V889);
00936	Py_XINCREF(storage_V891);
00937	Py_XINCREF(storage_V893);
00938	Py_XINCREF(storage_V895);
00939	Py_XINCREF(storage_V897);
00940	Py_XINCREF(storage_V899);
00941	Py_XINCREF(storage_V901);
00942	Py_XINCREF(storage_V903);
00943	Py_XINCREF(storage_V905);
00944	Py_XINCREF(storage_V907);
00945	Py_XINCREF(storage_V909);
00946	Py_XINCREF(storage_V1);
00947	            this->storage_V3 = storage_V3;
00948	this->storage_V5 = storage_V5;
00949	this->storage_V7 = storage_V7;
00950	this->storage_V9 = storage_V9;
00951	this->storage_V11 = storage_V11;
00952	this->storage_V13 = storage_V13;
00953	this->storage_V15 = storage_V15;
00954	this->storage_V17 = storage_V17;
00955	this->storage_V19 = storage_V19;
00956	this->storage_V21 = storage_V21;
00957	this->storage_V23 = storage_V23;
00958	this->storage_V25 = storage_V25;
00959	this->storage_V27 = storage_V27;
00960	this->storage_V29 = storage_V29;
00961	this->storage_V31 = storage_V31;
00962	this->storage_V33 = storage_V33;
00963	this->storage_V35 = storage_V35;
00964	this->storage_V37 = storage_V37;
00965	this->storage_V39 = storage_V39;
00966	this->storage_V41 = storage_V41;
00967	this->storage_V43 = storage_V43;
00968	this->storage_V45 = storage_V45;
00969	this->storage_V47 = storage_V47;
00970	this->storage_V49 = storage_V49;
00971	this->storage_V51 = storage_V51;
00972	this->storage_V53 = storage_V53;
00973	this->storage_V55 = storage_V55;
00974	this->storage_V57 = storage_V57;
00975	this->storage_V59 = storage_V59;
00976	this->storage_V61 = storage_V61;
00977	this->storage_V63 = storage_V63;
00978	this->storage_V65 = storage_V65;
00979	this->storage_V67 = storage_V67;
00980	this->storage_V69 = storage_V69;
00981	this->storage_V71 = storage_V71;
00982	this->storage_V73 = storage_V73;
00983	this->storage_V75 = storage_V75;
00984	this->storage_V77 = storage_V77;
00985	this->storage_V79 = storage_V79;
00986	this->storage_V81 = storage_V81;
00987	this->storage_V83 = storage_V83;
00988	this->storage_V85 = storage_V85;
00989	this->storage_V87 = storage_V87;
00990	this->storage_V89 = storage_V89;
00991	this->storage_V91 = storage_V91;
00992	this->storage_V93 = storage_V93;
00993	this->storage_V95 = storage_V95;
00994	this->storage_V97 = storage_V97;
00995	this->storage_V99 = storage_V99;
00996	this->storage_V101 = storage_V101;
00997	this->storage_V103 = storage_V103;
00998	this->storage_V105 = storage_V105;
00999	this->storage_V107 = storage_V107;
01000	this->storage_V109 = storage_V109;
01001	this->storage_V111 = storage_V111;
01002	this->storage_V113 = storage_V113;
01003	this->storage_V115 = storage_V115;
01004	this->storage_V117 = storage_V117;
01005	this->storage_V119 = storage_V119;
01006	this->storage_V121 = storage_V121;
01007	this->storage_V123 = storage_V123;
01008	this->storage_V125 = storage_V125;
01009	this->storage_V127 = storage_V127;
01010	this->storage_V129 = storage_V129;
01011	this->storage_V131 = storage_V131;
01012	this->storage_V133 = storage_V133;
01013	this->storage_V135 = storage_V135;
01014	this->storage_V137 = storage_V137;
01015	this->storage_V139 = storage_V139;
01016	this->storage_V141 = storage_V141;
01017	this->storage_V143 = storage_V143;
01018	this->storage_V145 = storage_V145;
01019	this->storage_V147 = storage_V147;
01020	this->storage_V149 = storage_V149;
01021	this->storage_V151 = storage_V151;
01022	this->storage_V153 = storage_V153;
01023	this->storage_V155 = storage_V155;
01024	this->storage_V157 = storage_V157;
01025	this->storage_V159 = storage_V159;
01026	this->storage_V161 = storage_V161;
01027	this->storage_V163 = storage_V163;
01028	this->storage_V165 = storage_V165;
01029	this->storage_V167 = storage_V167;
01030	this->storage_V169 = storage_V169;
01031	this->storage_V171 = storage_V171;
01032	this->storage_V173 = storage_V173;
01033	this->storage_V175 = storage_V175;
01034	this->storage_V177 = storage_V177;
01035	this->storage_V179 = storage_V179;
01036	this->storage_V181 = storage_V181;
01037	this->storage_V183 = storage_V183;
01038	this->storage_V185 = storage_V185;
01039	this->storage_V187 = storage_V187;
01040	this->storage_V189 = storage_V189;
01041	this->storage_V191 = storage_V191;
01042	this->storage_V193 = storage_V193;
01043	this->storage_V195 = storage_V195;
01044	this->storage_V197 = storage_V197;
01045	this->storage_V199 = storage_V199;
01046	this->storage_V201 = storage_V201;
01047	this->storage_V203 = storage_V203;
01048	this->storage_V205 = storage_V205;
01049	this->storage_V207 = storage_V207;
01050	this->storage_V209 = storage_V209;
01051	this->storage_V211 = storage_V211;
01052	this->storage_V213 = storage_V213;
01053	this->storage_V215 = storage_V215;
01054	this->storage_V217 = storage_V217;
01055	this->storage_V219 = storage_V219;
01056	this->storage_V221 = storage_V221;
01057	this->storage_V223 = storage_V223;
01058	this->storage_V225 = storage_V225;
01059	this->storage_V227 = storage_V227;
01060	this->storage_V229 = storage_V229;
01061	this->storage_V231 = storage_V231;
01062	this->storage_V233 = storage_V233;
01063	this->storage_V235 = storage_V235;
01064	this->storage_V237 = storage_V237;
01065	this->storage_V239 = storage_V239;
01066	this->storage_V241 = storage_V241;
01067	this->storage_V243 = storage_V243;
01068	this->storage_V245 = storage_V245;
01069	this->storage_V247 = storage_V247;
01070	this->storage_V249 = storage_V249;
01071	this->storage_V251 = storage_V251;
01072	this->storage_V253 = storage_V253;
01073	this->storage_V255 = storage_V255;
01074	this->storage_V257 = storage_V257;
01075	this->storage_V259 = storage_V259;
01076	this->storage_V261 = storage_V261;
01077	this->storage_V263 = storage_V263;
01078	this->storage_V265 = storage_V265;
01079	this->storage_V267 = storage_V267;
01080	this->storage_V269 = storage_V269;
01081	this->storage_V271 = storage_V271;
01082	this->storage_V273 = storage_V273;
01083	this->storage_V275 = storage_V275;
01084	this->storage_V277 = storage_V277;
01085	this->storage_V279 = storage_V279;
01086	this->storage_V281 = storage_V281;
01087	this->storage_V283 = storage_V283;
01088	this->storage_V285 = storage_V285;
01089	this->storage_V287 = storage_V287;
01090	this->storage_V289 = storage_V289;
01091	this->storage_V291 = storage_V291;
01092	this->storage_V293 = storage_V293;
01093	this->storage_V295 = storage_V295;
01094	this->storage_V297 = storage_V297;
01095	this->storage_V299 = storage_V299;
01096	this->storage_V301 = storage_V301;
01097	this->storage_V303 = storage_V303;
01098	this->storage_V305 = storage_V305;
01099	this->storage_V307 = storage_V307;
01100	this->storage_V309 = storage_V309;
01101	this->storage_V311 = storage_V311;
01102	this->storage_V313 = storage_V313;
01103	this->storage_V315 = storage_V315;
01104	this->storage_V317 = storage_V317;
01105	this->storage_V319 = storage_V319;
01106	this->storage_V321 = storage_V321;
01107	this->storage_V323 = storage_V323;
01108	this->storage_V325 = storage_V325;
01109	this->storage_V327 = storage_V327;
01110	this->storage_V329 = storage_V329;
01111	this->storage_V331 = storage_V331;
01112	this->storage_V333 = storage_V333;
01113	this->storage_V335 = storage_V335;
01114	this->storage_V337 = storage_V337;
01115	this->storage_V339 = storage_V339;
01116	this->storage_V341 = storage_V341;
01117	this->storage_V343 = storage_V343;
01118	this->storage_V345 = storage_V345;
01119	this->storage_V347 = storage_V347;
01120	this->storage_V349 = storage_V349;
01121	this->storage_V351 = storage_V351;
01122	this->storage_V353 = storage_V353;
01123	this->storage_V355 = storage_V355;
01124	this->storage_V357 = storage_V357;
01125	this->storage_V359 = storage_V359;
01126	this->storage_V361 = storage_V361;
01127	this->storage_V363 = storage_V363;
01128	this->storage_V365 = storage_V365;
01129	this->storage_V367 = storage_V367;
01130	this->storage_V369 = storage_V369;
01131	this->storage_V371 = storage_V371;
01132	this->storage_V373 = storage_V373;
01133	this->storage_V375 = storage_V375;
01134	this->storage_V377 = storage_V377;
01135	this->storage_V379 = storage_V379;
01136	this->storage_V381 = storage_V381;
01137	this->storage_V383 = storage_V383;
01138	this->storage_V385 = storage_V385;
01139	this->storage_V387 = storage_V387;
01140	this->storage_V389 = storage_V389;
01141	this->storage_V391 = storage_V391;
01142	this->storage_V393 = storage_V393;
01143	this->storage_V395 = storage_V395;
01144	this->storage_V397 = storage_V397;
01145	this->storage_V399 = storage_V399;
01146	this->storage_V401 = storage_V401;
01147	this->storage_V403 = storage_V403;
01148	this->storage_V405 = storage_V405;
01149	this->storage_V407 = storage_V407;
01150	this->storage_V409 = storage_V409;
01151	this->storage_V411 = storage_V411;
01152	this->storage_V413 = storage_V413;
01153	this->storage_V415 = storage_V415;
01154	this->storage_V417 = storage_V417;
01155	this->storage_V419 = storage_V419;
01156	this->storage_V421 = storage_V421;
01157	this->storage_V423 = storage_V423;
01158	this->storage_V425 = storage_V425;
01159	this->storage_V427 = storage_V427;
01160	this->storage_V429 = storage_V429;
01161	this->storage_V431 = storage_V431;
01162	this->storage_V433 = storage_V433;
01163	this->storage_V435 = storage_V435;
01164	this->storage_V437 = storage_V437;
01165	this->storage_V439 = storage_V439;
01166	this->storage_V441 = storage_V441;
01167	this->storage_V443 = storage_V443;
01168	this->storage_V445 = storage_V445;
01169	this->storage_V447 = storage_V447;
01170	this->storage_V449 = storage_V449;
01171	this->storage_V451 = storage_V451;
01172	this->storage_V453 = storage_V453;
01173	this->storage_V455 = storage_V455;
01174	this->storage_V457 = storage_V457;
01175	this->storage_V459 = storage_V459;
01176	this->storage_V461 = storage_V461;
01177	this->storage_V463 = storage_V463;
01178	this->storage_V465 = storage_V465;
01179	this->storage_V467 = storage_V467;
01180	this->storage_V469 = storage_V469;
01181	this->storage_V471 = storage_V471;
01182	this->storage_V473 = storage_V473;
01183	this->storage_V475 = storage_V475;
01184	this->storage_V477 = storage_V477;
01185	this->storage_V479 = storage_V479;
01186	this->storage_V481 = storage_V481;
01187	this->storage_V483 = storage_V483;
01188	this->storage_V485 = storage_V485;
01189	this->storage_V487 = storage_V487;
01190	this->storage_V489 = storage_V489;
01191	this->storage_V491 = storage_V491;
01192	this->storage_V493 = storage_V493;
01193	this->storage_V495 = storage_V495;
01194	this->storage_V497 = storage_V497;
01195	this->storage_V499 = storage_V499;
01196	this->storage_V501 = storage_V501;
01197	this->storage_V503 = storage_V503;
01198	this->storage_V505 = storage_V505;
01199	this->storage_V507 = storage_V507;
01200	this->storage_V509 = storage_V509;
01201	this->storage_V511 = storage_V511;
01202	this->storage_V513 = storage_V513;
01203	this->storage_V515 = storage_V515;
01204	this->storage_V517 = storage_V517;
01205	this->storage_V519 = storage_V519;
01206	this->storage_V521 = storage_V521;
01207	this->storage_V523 = storage_V523;
01208	this->storage_V525 = storage_V525;
01209	this->storage_V527 = storage_V527;
01210	this->storage_V529 = storage_V529;
01211	this->storage_V531 = storage_V531;
01212	this->storage_V533 = storage_V533;
01213	this->storage_V535 = storage_V535;
01214	this->storage_V537 = storage_V537;
01215	this->storage_V539 = storage_V539;
01216	this->storage_V541 = storage_V541;
01217	this->storage_V543 = storage_V543;
01218	this->storage_V545 = storage_V545;
01219	this->storage_V547 = storage_V547;
01220	this->storage_V549 = storage_V549;
01221	this->storage_V551 = storage_V551;
01222	this->storage_V553 = storage_V553;
01223	this->storage_V555 = storage_V555;
01224	this->storage_V557 = storage_V557;
01225	this->storage_V559 = storage_V559;
01226	this->storage_V561 = storage_V561;
01227	this->storage_V563 = storage_V563;
01228	this->storage_V565 = storage_V565;
01229	this->storage_V567 = storage_V567;
01230	this->storage_V569 = storage_V569;
01231	this->storage_V571 = storage_V571;
01232	this->storage_V573 = storage_V573;
01233	this->storage_V575 = storage_V575;
01234	this->storage_V577 = storage_V577;
01235	this->storage_V579 = storage_V579;
01236	this->storage_V581 = storage_V581;
01237	this->storage_V583 = storage_V583;
01238	this->storage_V585 = storage_V585;
01239	this->storage_V587 = storage_V587;
01240	this->storage_V589 = storage_V589;
01241	this->storage_V591 = storage_V591;
01242	this->storage_V593 = storage_V593;
01243	this->storage_V595 = storage_V595;
01244	this->storage_V597 = storage_V597;
01245	this->storage_V599 = storage_V599;
01246	this->storage_V601 = storage_V601;
01247	this->storage_V603 = storage_V603;
01248	this->storage_V605 = storage_V605;
01249	this->storage_V607 = storage_V607;
01250	this->storage_V609 = storage_V609;
01251	this->storage_V611 = storage_V611;
01252	this->storage_V613 = storage_V613;
01253	this->storage_V615 = storage_V615;
01254	this->storage_V617 = storage_V617;
01255	this->storage_V619 = storage_V619;
01256	this->storage_V621 = storage_V621;
01257	this->storage_V623 = storage_V623;
01258	this->storage_V625 = storage_V625;
01259	this->storage_V627 = storage_V627;
01260	this->storage_V629 = storage_V629;
01261	this->storage_V631 = storage_V631;
01262	this->storage_V633 = storage_V633;
01263	this->storage_V635 = storage_V635;
01264	this->storage_V637 = storage_V637;
01265	this->storage_V639 = storage_V639;
01266	this->storage_V641 = storage_V641;
01267	this->storage_V643 = storage_V643;
01268	this->storage_V645 = storage_V645;
01269	this->storage_V647 = storage_V647;
01270	this->storage_V649 = storage_V649;
01271	this->storage_V651 = storage_V651;
01272	this->storage_V653 = storage_V653;
01273	this->storage_V655 = storage_V655;
01274	this->storage_V657 = storage_V657;
01275	this->storage_V659 = storage_V659;
01276	this->storage_V661 = storage_V661;
01277	this->storage_V663 = storage_V663;
01278	this->storage_V665 = storage_V665;
01279	this->storage_V667 = storage_V667;
01280	this->storage_V669 = storage_V669;
01281	this->storage_V671 = storage_V671;
01282	this->storage_V673 = storage_V673;
01283	this->storage_V675 = storage_V675;
01284	this->storage_V677 = storage_V677;
01285	this->storage_V679 = storage_V679;
01286	this->storage_V681 = storage_V681;
01287	this->storage_V683 = storage_V683;
01288	this->storage_V685 = storage_V685;
01289	this->storage_V687 = storage_V687;
01290	this->storage_V689 = storage_V689;
01291	this->storage_V691 = storage_V691;
01292	this->storage_V693 = storage_V693;
01293	this->storage_V695 = storage_V695;
01294	this->storage_V697 = storage_V697;
01295	this->storage_V699 = storage_V699;
01296	this->storage_V701 = storage_V701;
01297	this->storage_V703 = storage_V703;
01298	this->storage_V705 = storage_V705;
01299	this->storage_V707 = storage_V707;
01300	this->storage_V709 = storage_V709;
01301	this->storage_V711 = storage_V711;
01302	this->storage_V713 = storage_V713;
01303	this->storage_V715 = storage_V715;
01304	this->storage_V717 = storage_V717;
01305	this->storage_V719 = storage_V719;
01306	this->storage_V721 = storage_V721;
01307	this->storage_V723 = storage_V723;
01308	this->storage_V725 = storage_V725;
01309	this->storage_V727 = storage_V727;
01310	this->storage_V729 = storage_V729;
01311	this->storage_V731 = storage_V731;
01312	this->storage_V733 = storage_V733;
01313	this->storage_V735 = storage_V735;
01314	this->storage_V737 = storage_V737;
01315	this->storage_V739 = storage_V739;
01316	this->storage_V741 = storage_V741;
01317	this->storage_V743 = storage_V743;
01318	this->storage_V745 = storage_V745;
01319	this->storage_V747 = storage_V747;
01320	this->storage_V749 = storage_V749;
01321	this->storage_V751 = storage_V751;
01322	this->storage_V753 = storage_V753;
01323	this->storage_V755 = storage_V755;
01324	this->storage_V757 = storage_V757;
01325	this->storage_V759 = storage_V759;
01326	this->storage_V761 = storage_V761;
01327	this->storage_V763 = storage_V763;
01328	this->storage_V765 = storage_V765;
01329	this->storage_V767 = storage_V767;
01330	this->storage_V769 = storage_V769;
01331	this->storage_V771 = storage_V771;
01332	this->storage_V773 = storage_V773;
01333	this->storage_V775 = storage_V775;
01334	this->storage_V777 = storage_V777;
01335	this->storage_V779 = storage_V779;
01336	this->storage_V781 = storage_V781;
01337	this->storage_V783 = storage_V783;
01338	this->storage_V785 = storage_V785;
01339	this->storage_V787 = storage_V787;
01340	this->storage_V789 = storage_V789;
01341	this->storage_V791 = storage_V791;
01342	this->storage_V793 = storage_V793;
01343	this->storage_V795 = storage_V795;
01344	this->storage_V797 = storage_V797;
01345	this->storage_V799 = storage_V799;
01346	this->storage_V801 = storage_V801;
01347	this->storage_V803 = storage_V803;
01348	this->storage_V805 = storage_V805;
01349	this->storage_V807 = storage_V807;
01350	this->storage_V809 = storage_V809;
01351	this->storage_V811 = storage_V811;
01352	this->storage_V813 = storage_V813;
01353	this->storage_V815 = storage_V815;
01354	this->storage_V817 = storage_V817;
01355	this->storage_V819 = storage_V819;
01356	this->storage_V821 = storage_V821;
01357	this->storage_V823 = storage_V823;
01358	this->storage_V825 = storage_V825;
01359	this->storage_V827 = storage_V827;
01360	this->storage_V829 = storage_V829;
01361	this->storage_V831 = storage_V831;
01362	this->storage_V833 = storage_V833;
01363	this->storage_V835 = storage_V835;
01364	this->storage_V837 = storage_V837;
01365	this->storage_V839 = storage_V839;
01366	this->storage_V841 = storage_V841;
01367	this->storage_V843 = storage_V843;
01368	this->storage_V845 = storage_V845;
01369	this->storage_V847 = storage_V847;
01370	this->storage_V849 = storage_V849;
01371	this->storage_V851 = storage_V851;
01372	this->storage_V853 = storage_V853;
01373	this->storage_V855 = storage_V855;
01374	this->storage_V857 = storage_V857;
01375	this->storage_V859 = storage_V859;
01376	this->storage_V861 = storage_V861;
01377	this->storage_V863 = storage_V863;
01378	this->storage_V865 = storage_V865;
01379	this->storage_V867 = storage_V867;
01380	this->storage_V869 = storage_V869;
01381	this->storage_V871 = storage_V871;
01382	this->storage_V873 = storage_V873;
01383	this->storage_V875 = storage_V875;
01384	this->storage_V877 = storage_V877;
01385	this->storage_V879 = storage_V879;
01386	this->storage_V881 = storage_V881;
01387	this->storage_V883 = storage_V883;
01388	this->storage_V885 = storage_V885;
01389	this->storage_V887 = storage_V887;
01390	this->storage_V889 = storage_V889;
01391	this->storage_V891 = storage_V891;
01392	this->storage_V893 = storage_V893;
01393	this->storage_V895 = storage_V895;
01394	this->storage_V897 = storage_V897;
01395	this->storage_V899 = storage_V899;
01396	this->storage_V901 = storage_V901;
01397	this->storage_V903 = storage_V903;
01398	this->storage_V905 = storage_V905;
01399	this->storage_V907 = storage_V907;
01400	this->storage_V909 = storage_V909;
01401	this->storage_V1 = storage_V1;
01402	            
01403	
01404	
01405	
01406	
01407	
01408	
01409	
01410	
01411	
01412	
01413	
01414	
01415	
01416	
01417	
01418	
01419	
01420	
01421	
01422	
01423	
01424	
01425	
01426	
01427	
01428	
01429	
01430	
01431	
01432	
01433	
01434	
01435	
01436	
01437	
01438	
01439	
01440	
01441	
01442	
01443	
01444	
01445	
01446	
01447	
01448	
01449	
01450	
01451	
01452	
01453	
01454	
01455	
01456	
01457	
01458	
01459	
01460	
01461	
01462	
01463	
01464	
01465	
01466	
01467	
01468	
01469	
01470	
01471	
01472	
01473	
01474	
01475	
01476	
01477	
01478	
01479	
01480	
01481	
01482	
01483	
01484	
01485	
01486	
01487	
01488	
01489	
01490	
01491	
01492	
01493	
01494	
01495	
01496	
01497	
01498	
01499	
01500	
01501	
01502	
01503	
01504	
01505	
01506	
01507	
01508	
01509	
01510	
01511	
01512	
01513	
01514	
01515	
01516	
01517	
01518	
01519	
01520	
01521	
01522	
01523	
01524	
01525	
01526	
01527	
01528	
01529	
01530	
01531	
01532	
01533	
01534	
01535	
01536	
01537	
01538	
01539	
01540	
01541	
01542	
01543	
01544	
01545	
01546	
01547	
01548	
01549	
01550	
01551	
01552	
01553	
01554	
01555	
01556	
01557	
01558	
01559	
01560	
01561	
01562	
01563	
01564	
01565	
01566	
01567	
01568	
01569	
01570	
01571	
01572	
01573	
01574	
01575	
01576	
01577	
01578	
01579	
01580	
01581	
01582	
01583	
01584	
01585	
01586	
01587	
01588	
01589	
01590	
01591	
01592	
01593	
01594	
01595	
01596	
01597	
01598	
01599	
01600	
01601	
01602	
01603	
01604	
01605	
01606	
01607	
01608	
01609	
01610	
01611	
01612	
01613	
01614	
01615	
01616	
01617	
01618	
01619	
01620	
01621	
01622	
01623	
01624	
01625	
01626	
01627	
01628	
01629	
01630	
01631	
01632	
01633	
01634	
01635	
01636	
01637	
01638	
01639	
01640	
01641	
01642	
01643	
01644	
01645	
01646	
01647	
01648	
01649	
01650	
01651	
01652	
01653	
01654	
01655	
01656	
01657	
01658	
01659	
01660	
01661	
01662	
01663	
01664	
01665	
01666	
01667	
01668	
01669	
01670	
01671	
01672	
01673	
01674	
01675	
01676	
01677	
01678	
01679	
01680	
01681	
01682	
01683	
01684	
01685	
01686	
01687	
01688	
01689	
01690	
01691	
01692	
01693	
01694	
01695	
01696	
01697	
01698	
01699	
01700	
01701	
01702	
01703	
01704	
01705	
01706	
01707	
01708	
01709	
01710	
01711	
01712	
01713	
01714	
01715	
01716	
01717	
01718	
01719	
01720	
01721	
01722	
01723	
01724	
01725	
01726	
01727	
01728	
01729	
01730	
01731	
01732	
01733	
01734	
01735	
01736	
01737	
01738	
01739	
01740	
01741	
01742	
01743	
01744	
01745	
01746	
01747	
01748	
01749	
01750	
01751	
01752	
01753	
01754	
01755	
01756	
01757	
01758	
01759	
01760	
01761	
01762	
01763	
01764	
01765	
01766	
01767	
01768	
01769	
01770	
01771	
01772	
01773	
01774	
01775	
01776	
01777	
01778	
01779	
01780	
01781	
01782	
01783	
01784	
01785	
01786	
01787	
01788	
01789	
01790	
01791	
01792	
01793	
01794	
01795	
01796	
01797	
01798	
01799	
01800	
01801	
01802	
01803	
01804	
01805	
01806	
01807	
01808	
01809	
01810	
01811	
01812	
01813	
01814	
01815	
01816	
01817	
01818	
01819	
01820	
01821	
01822	
01823	
01824	
01825	
01826	
01827	
01828	
01829	
01830	
01831	
01832	
01833	
01834	
01835	
01836	
01837	
01838	
01839	
01840	
01841	
01842	
01843	
01844	
01845	
01846	
01847	
01848	
01849	
01850	
01851	
01852	
01853	
01854	
01855	
01856	
01857	
01858	
01859	            this->__ERROR = __ERROR;
01860	            return 0;
01861	        }
01862	        void cleanup(void) {
01863	            __label_1:
01864	
01865	double __DUMMY_1;
01866	__label_3:
01867	
01868	double __DUMMY_3;
01869	__label_5:
01870	
01871	double __DUMMY_5;
01872	__label_7:
01873	
01874	double __DUMMY_7;
01875	__label_9:
01876	
01877	double __DUMMY_9;
01878	__label_11:
01879	
01880	double __DUMMY_11;
01881	__label_13:
01882	
01883	double __DUMMY_13;
01884	__label_15:
01885	
01886	double __DUMMY_15;
01887	__label_17:
01888	
01889	double __DUMMY_17;
01890	__label_19:
01891	
01892	double __DUMMY_19;
01893	__label_21:
01894	
01895	double __DUMMY_21;
01896	__label_23:
01897	
01898	double __DUMMY_23;
01899	__label_25:
01900	
01901	double __DUMMY_25;
01902	__label_27:
01903	
01904	double __DUMMY_27;
01905	__label_29:
01906	
01907	double __DUMMY_29;
01908	__label_31:
01909	
01910	double __DUMMY_31;
01911	__label_33:
01912	
01913	double __DUMMY_33;
01914	__label_35:
01915	
01916	double __DUMMY_35;
01917	__label_37:
01918	
01919	double __DUMMY_37;
01920	__label_39:
01921	
01922	double __DUMMY_39;
01923	__label_41:
01924	
01925	double __DUMMY_41;
01926	__label_43:
01927	
01928	double __DUMMY_43;
01929	__label_45:
01930	
01931	double __DUMMY_45;
01932	__label_47:
01933	
01934	double __DUMMY_47;
01935	__label_49:
01936	
01937	double __DUMMY_49;
01938	__label_51:
01939	
01940	double __DUMMY_51;
01941	__label_53:
01942	
01943	double __DUMMY_53;
01944	__label_55:
01945	
01946	double __DUMMY_55;
01947	__label_57:
01948	
01949	double __DUMMY_57;
01950	__label_59:
01951	
01952	double __DUMMY_59;
01953	__label_61:
01954	
01955	double __DUMMY_61;
01956	__label_63:
01957	
01958	double __DUMMY_63;
01959	__label_65:
01960	
01961	double __DUMMY_65;
01962	__label_67:
01963	
01964	double __DUMMY_67;
01965	__label_69:
01966	
01967	double __DUMMY_69;
01968	__label_71:
01969	
01970	double __DUMMY_71;
01971	__label_73:
01972	
01973	double __DUMMY_73;
01974	__label_75:
01975	
01976	double __DUMMY_75;
01977	__label_77:
01978	
01979	double __DUMMY_77;
01980	__label_79:
01981	
01982	double __DUMMY_79;
01983	__label_81:
01984	
01985	double __DUMMY_81;
01986	__label_83:
01987	
01988	double __DUMMY_83;
01989	__label_85:
01990	
01991	double __DUMMY_85;
01992	__label_87:
01993	
01994	double __DUMMY_87;
01995	__label_89:
01996	
01997	double __DUMMY_89;
01998	__label_91:
01999	
02000	double __DUMMY_91;
02001	__label_93:
02002	
02003	double __DUMMY_93;
02004	__label_95:
02005	
02006	double __DUMMY_95;
02007	__label_97:
02008	
02009	double __DUMMY_97;
02010	__label_99:
02011	
02012	double __DUMMY_99;
02013	__label_101:
02014	
02015	double __DUMMY_101;
02016	__label_103:
02017	
02018	double __DUMMY_103;
02019	__label_105:
02020	
02021	double __DUMMY_105;
02022	__label_107:
02023	
02024	double __DUMMY_107;
02025	__label_109:
02026	
02027	double __DUMMY_109;
02028	__label_111:
02029	
02030	double __DUMMY_111;
02031	__label_113:
02032	
02033	double __DUMMY_113;
02034	__label_115:
02035	
02036	double __DUMMY_115;
02037	__label_117:
02038	
02039	double __DUMMY_117;
02040	__label_119:
02041	
02042	double __DUMMY_119;
02043	__label_121:
02044	
02045	double __DUMMY_121;
02046	__label_123:
02047	
02048	double __DUMMY_123;
02049	__label_125:
02050	
02051	double __DUMMY_125;
02052	__label_127:
02053	
02054	double __DUMMY_127;
02055	__label_129:
02056	
02057	double __DUMMY_129;
02058	__label_131:
02059	
02060	double __DUMMY_131;
02061	__label_133:
02062	
02063	double __DUMMY_133;
02064	__label_135:
02065	
02066	double __DUMMY_135;
02067	__label_137:
02068	
02069	double __DUMMY_137;
02070	__label_139:
02071	
02072	double __DUMMY_139;
02073	__label_141:
02074	
02075	double __DUMMY_141;
02076	__label_143:
02077	
02078	double __DUMMY_143;
02079	__label_145:
02080	
02081	double __DUMMY_145;
02082	__label_147:
02083	
02084	double __DUMMY_147;
02085	__label_149:
02086	
02087	double __DUMMY_149;
02088	__label_151:
02089	
02090	double __DUMMY_151;
02091	__label_153:
02092	
02093	double __DUMMY_153;
02094	__label_155:
02095	
02096	double __DUMMY_155;
02097	__label_157:
02098	
02099	double __DUMMY_157;
02100	__label_159:
02101	
02102	double __DUMMY_159;
02103	__label_161:
02104	
02105	double __DUMMY_161;
02106	__label_163:
02107	
02108	double __DUMMY_163;
02109	__label_165:
02110	
02111	double __DUMMY_165;
02112	__label_167:
02113	
02114	double __DUMMY_167;
02115	__label_169:
02116	
02117	double __DUMMY_169;
02118	__label_171:
02119	
02120	double __DUMMY_171;
02121	__label_173:
02122	
02123	double __DUMMY_173;
02124	__label_175:
02125	
02126	double __DUMMY_175;
02127	__label_177:
02128	
02129	double __DUMMY_177;
02130	__label_179:
02131	
02132	double __DUMMY_179;
02133	__label_181:
02134	
02135	double __DUMMY_181;
02136	__label_183:
02137	
02138	double __DUMMY_183;
02139	__label_185:
02140	
02141	double __DUMMY_185;
02142	__label_187:
02143	
02144	double __DUMMY_187;
02145	__label_189:
02146	
02147	double __DUMMY_189;
02148	__label_191:
02149	
02150	double __DUMMY_191;
02151	__label_193:
02152	
02153	double __DUMMY_193;
02154	__label_195:
02155	
02156	double __DUMMY_195;
02157	__label_197:
02158	
02159	double __DUMMY_197;
02160	__label_199:
02161	
02162	double __DUMMY_199;
02163	__label_201:
02164	
02165	double __DUMMY_201;
02166	__label_203:
02167	
02168	double __DUMMY_203;
02169	__label_205:
02170	
02171	double __DUMMY_205;
02172	__label_207:
02173	
02174	double __DUMMY_207;
02175	__label_209:
02176	
02177	double __DUMMY_209;
02178	__label_211:
02179	
02180	double __DUMMY_211;
02181	__label_213:
02182	
02183	double __DUMMY_213;
02184	__label_215:
02185	
02186	double __DUMMY_215;
02187	__label_217:
02188	
02189	double __DUMMY_217;
02190	__label_219:
02191	
02192	double __DUMMY_219;
02193	__label_221:
02194	
02195	double __DUMMY_221;
02196	__label_223:
02197	
02198	double __DUMMY_223;
02199	__label_225:
02200	
02201	double __DUMMY_225;
02202	__label_227:
02203	
02204	double __DUMMY_227;
02205	__label_229:
02206	
02207	double __DUMMY_229;
02208	__label_231:
02209	
02210	double __DUMMY_231;
02211	__label_233:
02212	
02213	double __DUMMY_233;
02214	__label_235:
02215	
02216	double __DUMMY_235;
02217	__label_237:
02218	
02219	double __DUMMY_237;
02220	__label_239:
02221	
02222	double __DUMMY_239;
02223	__label_241:
02224	
02225	double __DUMMY_241;
02226	__label_243:
02227	
02228	double __DUMMY_243;
02229	__label_245:
02230	
02231	double __DUMMY_245;
02232	__label_247:
02233	
02234	double __DUMMY_247;
02235	__label_249:
02236	
02237	double __DUMMY_249;
02238	__label_251:
02239	
02240	double __DUMMY_251;
02241	__label_253:
02242	
02243	double __DUMMY_253;
02244	__label_255:
02245	
02246	double __DUMMY_255;
02247	__label_257:
02248	
02249	double __DUMMY_257;
02250	__label_259:
02251	
02252	double __DUMMY_259;
02253	__label_261:
02254	
02255	double __DUMMY_261;
02256	__label_263:
02257	
02258	double __DUMMY_263;
02259	__label_265:
02260	
02261	double __DUMMY_265;
02262	__label_267:
02263	
02264	double __DUMMY_267;
02265	__label_269:
02266	
02267	double __DUMMY_269;
02268	__label_271:
02269	
02270	double __DUMMY_271;
02271	__label_273:
02272	
02273	double __DUMMY_273;
02274	__label_275:
02275	
02276	double __DUMMY_275;
02277	__label_277:
02278	
02279	double __DUMMY_277;
02280	__label_279:
02281	
02282	double __DUMMY_279;
02283	__label_281:
02284	
02285	double __DUMMY_281;
02286	__label_283:
02287	
02288	double __DUMMY_283;
02289	__label_285:
02290	
02291	double __DUMMY_285;
02292	__label_287:
02293	
02294	double __DUMMY_287;
02295	__label_289:
02296	
02297	double __DUMMY_289;
02298	__label_291:
02299	
02300	double __DUMMY_291;
02301	__label_293:
02302	
02303	double __DUMMY_293;
02304	__label_295:
02305	
02306	double __DUMMY_295;
02307	__label_297:
02308	
02309	double __DUMMY_297;
02310	__label_299:
02311	
02312	double __DUMMY_299;
02313	__label_301:
02314	
02315	double __DUMMY_301;
02316	__label_303:
02317	
02318	double __DUMMY_303;
02319	__label_305:
02320	
02321	double __DUMMY_305;
02322	__label_307:
02323	
02324	double __DUMMY_307;
02325	__label_309:
02326	
02327	double __DUMMY_309;
02328	__label_311:
02329	
02330	double __DUMMY_311;
02331	__label_313:
02332	
02333	double __DUMMY_313;
02334	__label_315:
02335	
02336	double __DUMMY_315;
02337	__label_317:
02338	
02339	double __DUMMY_317;
02340	__label_319:
02341	
02342	double __DUMMY_319;
02343	__label_321:
02344	
02345	double __DUMMY_321;
02346	__label_323:
02347	
02348	double __DUMMY_323;
02349	__label_325:
02350	
02351	double __DUMMY_325;
02352	__label_327:
02353	
02354	double __DUMMY_327;
02355	__label_329:
02356	
02357	double __DUMMY_329;
02358	__label_331:
02359	
02360	double __DUMMY_331;
02361	__label_333:
02362	
02363	double __DUMMY_333;
02364	__label_335:
02365	
02366	double __DUMMY_335;
02367	__label_337:
02368	
02369	double __DUMMY_337;
02370	__label_339:
02371	
02372	double __DUMMY_339;
02373	__label_341:
02374	
02375	double __DUMMY_341;
02376	__label_343:
02377	
02378	double __DUMMY_343;
02379	__label_345:
02380	
02381	double __DUMMY_345;
02382	__label_347:
02383	
02384	double __DUMMY_347;
02385	__label_349:
02386	
02387	double __DUMMY_349;
02388	__label_351:
02389	
02390	double __DUMMY_351;
02391	__label_353:
02392	
02393	double __DUMMY_353;
02394	__label_355:
02395	
02396	double __DUMMY_355;
02397	__label_357:
02398	
02399	double __DUMMY_357;
02400	__label_359:
02401	
02402	double __DUMMY_359;
02403	__label_361:
02404	
02405	double __DUMMY_361;
02406	__label_363:
02407	
02408	double __DUMMY_363;
02409	__label_365:
02410	
02411	double __DUMMY_365;
02412	__label_367:
02413	
02414	double __DUMMY_367;
02415	__label_369:
02416	
02417	double __DUMMY_369;
02418	__label_371:
02419	
02420	double __DUMMY_371;
02421	__label_373:
02422	
02423	double __DUMMY_373;
02424	__label_375:
02425	
02426	double __DUMMY_375;
02427	__label_377:
02428	
02429	double __DUMMY_377;
02430	__label_379:
02431	
02432	double __DUMMY_379;
02433	__label_381:
02434	
02435	double __DUMMY_381;
02436	__label_383:
02437	
02438	double __DUMMY_383;
02439	__label_385:
02440	
02441	double __DUMMY_385;
02442	__label_387:
02443	
02444	double __DUMMY_387;
02445	__label_389:
02446	
02447	double __DUMMY_389;
02448	__label_391:
02449	
02450	double __DUMMY_391;
02451	__label_393:
02452	
02453	double __DUMMY_393;
02454	__label_395:
02455	
02456	double __DUMMY_395;
02457	__label_397:
02458	
02459	double __DUMMY_397;
02460	__label_399:
02461	
02462	double __DUMMY_399;
02463	__label_401:
02464	
02465	double __DUMMY_401;
02466	__label_403:
02467	
02468	double __DUMMY_403;
02469	__label_405:
02470	
02471	double __DUMMY_405;
02472	__label_407:
02473	
02474	double __DUMMY_407;
02475	__label_409:
02476	
02477	double __DUMMY_409;
02478	__label_411:
02479	
02480	double __DUMMY_411;
02481	__label_413:
02482	
02483	double __DUMMY_413;
02484	__label_415:
02485	
02486	double __DUMMY_415;
02487	__label_417:
02488	
02489	double __DUMMY_417;
02490	__label_419:
02491	
02492	double __DUMMY_419;
02493	__label_421:
02494	
02495	double __DUMMY_421;
02496	__label_423:
02497	
02498	double __DUMMY_423;
02499	__label_425:
02500	
02501	double __DUMMY_425;
02502	__label_427:
02503	
02504	double __DUMMY_427;
02505	__label_429:
02506	
02507	double __DUMMY_429;
02508	__label_431:
02509	
02510	double __DUMMY_431;
02511	__label_433:
02512	
02513	double __DUMMY_433;
02514	__label_435:
02515	
02516	double __DUMMY_435;
02517	__label_437:
02518	
02519	double __DUMMY_437;
02520	__label_439:
02521	
02522	double __DUMMY_439;
02523	__label_441:
02524	
02525	double __DUMMY_441;
02526	__label_443:
02527	
02528	double __DUMMY_443;
02529	__label_445:
02530	
02531	double __DUMMY_445;
02532	__label_447:
02533	
02534	double __DUMMY_447;
02535	__label_449:
02536	
02537	double __DUMMY_449;
02538	__label_451:
02539	
02540	double __DUMMY_451;
02541	__label_453:
02542	
02543	double __DUMMY_453;
02544	__label_455:
02545	
02546	double __DUMMY_455;
02547	__label_457:
02548	
02549	double __DUMMY_457;
02550	__label_459:
02551	
02552	double __DUMMY_459;
02553	__label_461:
02554	
02555	double __DUMMY_461;
02556	__label_463:
02557	
02558	double __DUMMY_463;
02559	__label_465:
02560	
02561	double __DUMMY_465;
02562	__label_467:
02563	
02564	double __DUMMY_467;
02565	__label_469:
02566	
02567	double __DUMMY_469;
02568	__label_471:
02569	
02570	double __DUMMY_471;
02571	__label_473:
02572	
02573	double __DUMMY_473;
02574	__label_475:
02575	
02576	double __DUMMY_475;
02577	__label_477:
02578	
02579	double __DUMMY_477;
02580	__label_479:
02581	
02582	double __DUMMY_479;
02583	__label_481:
02584	
02585	double __DUMMY_481;
02586	__label_483:
02587	
02588	double __DUMMY_483;
02589	__label_485:
02590	
02591	double __DUMMY_485;
02592	__label_487:
02593	
02594	double __DUMMY_487;
02595	__label_489:
02596	
02597	double __DUMMY_489;
02598	__label_491:
02599	
02600	double __DUMMY_491;
02601	__label_493:
02602	
02603	double __DUMMY_493;
02604	__label_495:
02605	
02606	double __DUMMY_495;
02607	__label_497:
02608	
02609	double __DUMMY_497;
02610	__label_499:
02611	
02612	double __DUMMY_499;
02613	__label_501:
02614	
02615	double __DUMMY_501;
02616	__label_503:
02617	
02618	double __DUMMY_503;
02619	__label_505:
02620	
02621	double __DUMMY_505;
02622	__label_507:
02623	
02624	double __DUMMY_507;
02625	__label_509:
02626	
02627	double __DUMMY_509;
02628	__label_511:
02629	
02630	double __DUMMY_511;
02631	__label_513:
02632	
02633	double __DUMMY_513;
02634	__label_515:
02635	
02636	double __DUMMY_515;
02637	__label_517:
02638	
02639	double __DUMMY_517;
02640	__label_519:
02641	
02642	double __DUMMY_519;
02643	__label_521:
02644	
02645	double __DUMMY_521;
02646	__label_523:
02647	
02648	double __DUMMY_523;
02649	__label_525:
02650	
02651	double __DUMMY_525;
02652	__label_527:
02653	
02654	double __DUMMY_527;
02655	__label_529:
02656	
02657	double __DUMMY_529;
02658	__label_531:
02659	
02660	double __DUMMY_531;
02661	__label_533:
02662	
02663	double __DUMMY_533;
02664	__label_535:
02665	
02666	double __DUMMY_535;
02667	__label_537:
02668	
02669	double __DUMMY_537;
02670	__label_539:
02671	
02672	double __DUMMY_539;
02673	__label_541:
02674	
02675	double __DUMMY_541;
02676	__label_543:
02677	
02678	double __DUMMY_543;
02679	__label_545:
02680	
02681	double __DUMMY_545;
02682	__label_547:
02683	
02684	double __DUMMY_547;
02685	__label_549:
02686	
02687	double __DUMMY_549;
02688	__label_551:
02689	
02690	double __DUMMY_551;
02691	__label_553:
02692	
02693	double __DUMMY_553;
02694	__label_555:
02695	
02696	double __DUMMY_555;
02697	__label_557:
02698	
02699	double __DUMMY_557;
02700	__label_559:
02701	
02702	double __DUMMY_559;
02703	__label_561:
02704	
02705	double __DUMMY_561;
02706	__label_563:
02707	
02708	double __DUMMY_563;
02709	__label_565:
02710	
02711	double __DUMMY_565;
02712	__label_567:
02713	
02714	double __DUMMY_567;
02715	__label_569:
02716	
02717	double __DUMMY_569;
02718	__label_571:
02719	
02720	double __DUMMY_571;
02721	__label_573:
02722	
02723	double __DUMMY_573;
02724	__label_575:
02725	
02726	double __DUMMY_575;
02727	__label_577:
02728	
02729	double __DUMMY_577;
02730	__label_579:
02731	
02732	double __DUMMY_579;
02733	__label_581:
02734	
02735	double __DUMMY_581;
02736	__label_583:
02737	
02738	double __DUMMY_583;
02739	__label_585:
02740	
02741	double __DUMMY_585;
02742	__label_587:
02743	
02744	double __DUMMY_587;
02745	__label_589:
02746	
02747	double __DUMMY_589;
02748	__label_591:
02749	
02750	double __DUMMY_591;
02751	__label_593:
02752	
02753	double __DUMMY_593;
02754	__label_595:
02755	
02756	double __DUMMY_595;
02757	__label_597:
02758	
02759	double __DUMMY_597;
02760	__label_599:
02761	
02762	double __DUMMY_599;
02763	__label_601:
02764	
02765	double __DUMMY_601;
02766	__label_603:
02767	
02768	double __DUMMY_603;
02769	__label_605:
02770	
02771	double __DUMMY_605;
02772	__label_607:
02773	
02774	double __DUMMY_607;
02775	__label_609:
02776	
02777	double __DUMMY_609;
02778	__label_611:
02779	
02780	double __DUMMY_611;
02781	__label_613:
02782	
02783	double __DUMMY_613;
02784	__label_615:
02785	
02786	double __DUMMY_615;
02787	__label_617:
02788	
02789	double __DUMMY_617;
02790	__label_619:
02791	
02792	double __DUMMY_619;
02793	__label_621:
02794	
02795	double __DUMMY_621;
02796	__label_623:
02797	
02798	double __DUMMY_623;
02799	__label_625:
02800	
02801	double __DUMMY_625;
02802	__label_627:
02803	
02804	double __DUMMY_627;
02805	__label_629:
02806	
02807	double __DUMMY_629;
02808	__label_631:
02809	
02810	double __DUMMY_631;
02811	__label_633:
02812	
02813	double __DUMMY_633;
02814	__label_635:
02815	
02816	double __DUMMY_635;
02817	__label_637:
02818	
02819	double __DUMMY_637;
02820	__label_639:
02821	
02822	double __DUMMY_639;
02823	__label_641:
02824	
02825	double __DUMMY_641;
02826	__label_643:
02827	
02828	double __DUMMY_643;
02829	__label_645:
02830	
02831	double __DUMMY_645;
02832	__label_647:
02833	
02834	double __DUMMY_647;
02835	__label_649:
02836	
02837	double __DUMMY_649;
02838	__label_651:
02839	
02840	double __DUMMY_651;
02841	__label_653:
02842	
02843	double __DUMMY_653;
02844	__label_655:
02845	
02846	double __DUMMY_655;
02847	__label_657:
02848	
02849	double __DUMMY_657;
02850	__label_659:
02851	
02852	double __DUMMY_659;
02853	__label_661:
02854	
02855	double __DUMMY_661;
02856	__label_663:
02857	
02858	double __DUMMY_663;
02859	__label_665:
02860	
02861	double __DUMMY_665;
02862	__label_667:
02863	
02864	double __DUMMY_667;
02865	__label_669:
02866	
02867	double __DUMMY_669;
02868	__label_671:
02869	
02870	double __DUMMY_671;
02871	__label_673:
02872	
02873	double __DUMMY_673;
02874	__label_675:
02875	
02876	double __DUMMY_675;
02877	__label_677:
02878	
02879	double __DUMMY_677;
02880	__label_679:
02881	
02882	double __DUMMY_679;
02883	__label_681:
02884	
02885	double __DUMMY_681;
02886	__label_683:
02887	
02888	double __DUMMY_683;
02889	__label_685:
02890	
02891	double __DUMMY_685;
02892	__label_687:
02893	
02894	double __DUMMY_687;
02895	__label_689:
02896	
02897	double __DUMMY_689;
02898	__label_691:
02899	
02900	double __DUMMY_691;
02901	__label_693:
02902	
02903	double __DUMMY_693;
02904	__label_695:
02905	
02906	double __DUMMY_695;
02907	__label_697:
02908	
02909	double __DUMMY_697;
02910	__label_699:
02911	
02912	double __DUMMY_699;
02913	__label_701:
02914	
02915	double __DUMMY_701;
02916	__label_703:
02917	
02918	double __DUMMY_703;
02919	__label_705:
02920	
02921	double __DUMMY_705;
02922	__label_707:
02923	
02924	double __DUMMY_707;
02925	__label_709:
02926	
02927	double __DUMMY_709;
02928	__label_711:
02929	
02930	double __DUMMY_711;
02931	__label_713:
02932	
02933	double __DUMMY_713;
02934	__label_715:
02935	
02936	double __DUMMY_715;
02937	__label_717:
02938	
02939	double __DUMMY_717;
02940	__label_719:
02941	
02942	double __DUMMY_719;
02943	__label_721:
02944	
02945	double __DUMMY_721;
02946	__label_723:
02947	
02948	double __DUMMY_723;
02949	__label_725:
02950	
02951	double __DUMMY_725;
02952	__label_727:
02953	
02954	double __DUMMY_727;
02955	__label_729:
02956	
02957	double __DUMMY_729;
02958	__label_731:
02959	
02960	double __DUMMY_731;
02961	__label_733:
02962	
02963	double __DUMMY_733;
02964	__label_735:
02965	
02966	double __DUMMY_735;
02967	__label_737:
02968	
02969	double __DUMMY_737;
02970	__label_739:
02971	
02972	double __DUMMY_739;
02973	__label_741:
02974	
02975	double __DUMMY_741;
02976	__label_743:
02977	
02978	double __DUMMY_743;
02979	__label_745:
02980	
02981	double __DUMMY_745;
02982	__label_747:
02983	
02984	double __DUMMY_747;
02985	__label_749:
02986	
02987	double __DUMMY_749;
02988	__label_751:
02989	
02990	double __DUMMY_751;
02991	__label_753:
02992	
02993	double __DUMMY_753;
02994	__label_755:
02995	
02996	double __DUMMY_755;
02997	__label_757:
02998	
02999	double __DUMMY_757;
03000	__label_759:
03001	
03002	double __DUMMY_759;
03003	__label_761:
03004	
03005	double __DUMMY_761;
03006	__label_763:
03007	
03008	double __DUMMY_763;
03009	__label_765:
03010	
03011	double __DUMMY_765;
03012	__label_767:
03013	
03014	double __DUMMY_767;
03015	__label_769:
03016	
03017	double __DUMMY_769;
03018	__label_771:
03019	
03020	double __DUMMY_771;
03021	__label_773:
03022	
03023	double __DUMMY_773;
03024	__label_775:
03025	
03026	double __DUMMY_775;
03027	__label_777:
03028	
03029	double __DUMMY_777;
03030	__label_779:
03031	
03032	double __DUMMY_779;
03033	__label_781:
03034	
03035	double __DUMMY_781;
03036	__label_783:
03037	
03038	double __DUMMY_783;
03039	__label_785:
03040	
03041	double __DUMMY_785;
03042	__label_787:
03043	
03044	double __DUMMY_787;
03045	__label_789:
03046	
03047	double __DUMMY_789;
03048	__label_791:
03049	
03050	double __DUMMY_791;
03051	__label_793:
03052	
03053	double __DUMMY_793;
03054	__label_795:
03055	
03056	double __DUMMY_795;
03057	__label_797:
03058	
03059	double __DUMMY_797;
03060	__label_799:
03061	
03062	double __DUMMY_799;
03063	__label_801:
03064	
03065	double __DUMMY_801;
03066	__label_803:
03067	
03068	double __DUMMY_803;
03069	__label_805:
03070	
03071	double __DUMMY_805;
03072	__label_807:
03073	
03074	double __DUMMY_807;
03075	__label_809:
03076	
03077	double __DUMMY_809;
03078	__label_811:
03079	
03080	double __DUMMY_811;
03081	__label_813:
03082	
03083	double __DUMMY_813;
03084	__label_815:
03085	
03086	double __DUMMY_815;
03087	__label_817:
03088	
03089	double __DUMMY_817;
03090	__label_819:
03091	
03092	double __DUMMY_819;
03093	__label_821:
03094	
03095	double __DUMMY_821;
03096	__label_823:
03097	
03098	double __DUMMY_823;
03099	__label_825:
03100	
03101	double __DUMMY_825;
03102	__label_827:
03103	
03104	double __DUMMY_827;
03105	__label_829:
03106	
03107	double __DUMMY_829;
03108	__label_831:
03109	
03110	double __DUMMY_831;
03111	__label_833:
03112	
03113	double __DUMMY_833;
03114	__label_835:
03115	
03116	double __DUMMY_835;
03117	__label_837:
03118	
03119	double __DUMMY_837;
03120	__label_839:
03121	
03122	double __DUMMY_839;
03123	__label_841:
03124	
03125	double __DUMMY_841;
03126	__label_843:
03127	
03128	double __DUMMY_843;
03129	__label_845:
03130	
03131	double __DUMMY_845;
03132	__label_847:
03133	
03134	double __DUMMY_847;
03135	__label_849:
03136	
03137	double __DUMMY_849;
03138	__label_851:
03139	
03140	double __DUMMY_851;
03141	__label_853:
03142	
03143	double __DUMMY_853;
03144	__label_855:
03145	
03146	double __DUMMY_855;
03147	__label_857:
03148	
03149	double __DUMMY_857;
03150	__label_859:
03151	
03152	double __DUMMY_859;
03153	__label_861:
03154	
03155	double __DUMMY_861;
03156	__label_863:
03157	
03158	double __DUMMY_863;
03159	__label_865:
03160	
03161	double __DUMMY_865;
03162	__label_867:
03163	
03164	double __DUMMY_867;
03165	__label_869:
03166	
03167	double __DUMMY_869;
03168	__label_871:
03169	
03170	double __DUMMY_871;
03171	__label_873:
03172	
03173	double __DUMMY_873;
03174	__label_875:
03175	
03176	double __DUMMY_875;
03177	__label_877:
03178	
03179	double __DUMMY_877;
03180	__label_879:
03181	
03182	double __DUMMY_879;
03183	__label_881:
03184	
03185	double __DUMMY_881;
03186	__label_883:
03187	
03188	double __DUMMY_883;
03189	__label_885:
03190	
03191	double __DUMMY_885;
03192	__label_887:
03193	
03194	double __DUMMY_887;
03195	__label_889:
03196	
03197	double __DUMMY_889;
03198	__label_891:
03199	
03200	double __DUMMY_891;
03201	__label_893:
03202	
03203	double __DUMMY_893;
03204	__label_895:
03205	
03206	double __DUMMY_895;
03207	__label_897:
03208	
03209	double __DUMMY_897;
03210	__label_899:
03211	
03212	double __DUMMY_899;
03213	__label_901:
03214	
03215	double __DUMMY_901;
03216	__label_903:
03217	
03218	double __DUMMY_903;
03219	__label_905:
03220	
03221	double __DUMMY_905;
03222	__label_907:
03223	
03224	double __DUMMY_907;
03225	__label_909:
03226	
03227	double __DUMMY_909;
03228	__label_912:
03229	
03230	double __DUMMY_912;
03231	
03232	            Py_XDECREF(this->storage_V3);
03233	Py_XDECREF(this->storage_V5);
03234	Py_XDECREF(this->storage_V7);
03235	Py_XDECREF(this->storage_V9);
03236	Py_XDECREF(this->storage_V11);
03237	Py_XDECREF(this->storage_V13);
03238	Py_XDECREF(this->storage_V15);
03239	Py_XDECREF(this->storage_V17);
03240	Py_XDECREF(this->storage_V19);
03241	Py_XDECREF(this->storage_V21);
03242	Py_XDECREF(this->storage_V23);
03243	Py_XDECREF(this->storage_V25);
03244	Py_XDECREF(this->storage_V27);
03245	Py_XDECREF(this->storage_V29);
03246	Py_XDECREF(this->storage_V31);
03247	Py_XDECREF(this->storage_V33);
03248	Py_XDECREF(this->storage_V35);
03249	Py_XDECREF(this->storage_V37);
03250	Py_XDECREF(this->storage_V39);
03251	Py_XDECREF(this->storage_V41);
03252	Py_XDECREF(this->storage_V43);
03253	Py_XDECREF(this->storage_V45);
03254	Py_XDECREF(this->storage_V47);
03255	Py_XDECREF(this->storage_V49);
03256	Py_XDECREF(this->storage_V51);
03257	Py_XDECREF(this->storage_V53);
03258	Py_XDECREF(this->storage_V55);
03259	Py_XDECREF(this->storage_V57);
03260	Py_XDECREF(this->storage_V59);
03261	Py_XDECREF(this->storage_V61);
03262	Py_XDECREF(this->storage_V63);
03263	Py_XDECREF(this->storage_V65);
03264	Py_XDECREF(this->storage_V67);
03265	Py_XDECREF(this->storage_V69);
03266	Py_XDECREF(this->storage_V71);
03267	Py_XDECREF(this->storage_V73);
03268	Py_XDECREF(this->storage_V75);
03269	Py_XDECREF(this->storage_V77);
03270	Py_XDECREF(this->storage_V79);
03271	Py_XDECREF(this->storage_V81);
03272	Py_XDECREF(this->storage_V83);
03273	Py_XDECREF(this->storage_V85);
03274	Py_XDECREF(this->storage_V87);
03275	Py_XDECREF(this->storage_V89);
03276	Py_XDECREF(this->storage_V91);
03277	Py_XDECREF(this->storage_V93);
03278	Py_XDECREF(this->storage_V95);
03279	Py_XDECREF(this->storage_V97);
03280	Py_XDECREF(this->storage_V99);
03281	Py_XDECREF(this->storage_V101);
03282	Py_XDECREF(this->storage_V103);
03283	Py_XDECREF(this->storage_V105);
03284	Py_XDECREF(this->storage_V107);
03285	Py_XDECREF(this->storage_V109);
03286	Py_XDECREF(this->storage_V111);
03287	Py_XDECREF(this->storage_V113);
03288	Py_XDECREF(this->storage_V115);
03289	Py_XDECREF(this->storage_V117);
03290	Py_XDECREF(this->storage_V119);
03291	Py_XDECREF(this->storage_V121);
03292	Py_XDECREF(this->storage_V123);
03293	Py_XDECREF(this->storage_V125);
03294	Py_XDECREF(this->storage_V127);
03295	Py_XDECREF(this->storage_V129);
03296	Py_XDECREF(this->storage_V131);
03297	Py_XDECREF(this->storage_V133);
03298	Py_XDECREF(this->storage_V135);
03299	Py_XDECREF(this->storage_V137);
03300	Py_XDECREF(this->storage_V139);
03301	Py_XDECREF(this->storage_V141);
03302	Py_XDECREF(this->storage_V143);
03303	Py_XDECREF(this->storage_V145);
03304	Py_XDECREF(this->storage_V147);
03305	Py_XDECREF(this->storage_V149);
03306	Py_XDECREF(this->storage_V151);
03307	Py_XDECREF(this->storage_V153);
03308	Py_XDECREF(this->storage_V155);
03309	Py_XDECREF(this->storage_V157);
03310	Py_XDECREF(this->storage_V159);
03311	Py_XDECREF(this->storage_V161);
03312	Py_XDECREF(this->storage_V163);
03313	Py_XDECREF(this->storage_V165);
03314	Py_XDECREF(this->storage_V167);
03315	Py_XDECREF(this->storage_V169);
03316	Py_XDECREF(this->storage_V171);
03317	Py_XDECREF(this->storage_V173);
03318	Py_XDECREF(this->storage_V175);
03319	Py_XDECREF(this->storage_V177);
03320	Py_XDECREF(this->storage_V179);
03321	Py_XDECREF(this->storage_V181);
03322	Py_XDECREF(this->storage_V183);
03323	Py_XDECREF(this->storage_V185);
03324	Py_XDECREF(this->storage_V187);
03325	Py_XDECREF(this->storage_V189);
03326	Py_XDECREF(this->storage_V191);
03327	Py_XDECREF(this->storage_V193);
03328	Py_XDECREF(this->storage_V195);
03329	Py_XDECREF(this->storage_V197);
03330	Py_XDECREF(this->storage_V199);
03331	Py_XDECREF(this->storage_V201);
03332	Py_XDECREF(this->storage_V203);
03333	Py_XDECREF(this->storage_V205);
03334	Py_XDECREF(this->storage_V207);
03335	Py_XDECREF(this->storage_V209);
03336	Py_XDECREF(this->storage_V211);
03337	Py_XDECREF(this->storage_V213);
03338	Py_XDECREF(this->storage_V215);
03339	Py_XDECREF(this->storage_V217);
03340	Py_XDECREF(this->storage_V219);
03341	Py_XDECREF(this->storage_V221);
03342	Py_XDECREF(this->storage_V223);
03343	Py_XDECREF(this->storage_V225);
03344	Py_XDECREF(this->storage_V227);
03345	Py_XDECREF(this->storage_V229);
03346	Py_XDECREF(this->storage_V231);
03347	Py_XDECREF(this->storage_V233);
03348	Py_XDECREF(this->storage_V235);
03349	Py_XDECREF(this->storage_V237);
03350	Py_XDECREF(this->storage_V239);
03351	Py_XDECREF(this->storage_V241);
03352	Py_XDECREF(this->storage_V243);
03353	Py_XDECREF(this->storage_V245);
03354	Py_XDECREF(this->storage_V247);
03355	Py_XDECREF(this->storage_V249);
03356	Py_XDECREF(this->storage_V251);
03357	Py_XDECREF(this->storage_V253);
03358	Py_XDECREF(this->storage_V255);
03359	Py_XDECREF(this->storage_V257);
03360	Py_XDECREF(this->storage_V259);
03361	Py_XDECREF(this->storage_V261);
03362	Py_XDECREF(this->storage_V263);
03363	Py_XDECREF(this->storage_V265);
03364	Py_XDECREF(this->storage_V267);
03365	Py_XDECREF(this->storage_V269);
03366	Py_XDECREF(this->storage_V271);
03367	Py_XDECREF(this->storage_V273);
03368	Py_XDECREF(this->storage_V275);
03369	Py_XDECREF(this->storage_V277);
03370	Py_XDECREF(this->storage_V279);
03371	Py_XDECREF(this->storage_V281);
03372	Py_XDECREF(this->storage_V283);
03373	Py_XDECREF(this->storage_V285);
03374	Py_XDECREF(this->storage_V287);
03375	Py_XDECREF(this->storage_V289);
03376	Py_XDECREF(this->storage_V291);
03377	Py_XDECREF(this->storage_V293);
03378	Py_XDECREF(this->storage_V295);
03379	Py_XDECREF(this->storage_V297);
03380	Py_XDECREF(this->storage_V299);
03381	Py_XDECREF(this->storage_V301);
03382	Py_XDECREF(this->storage_V303);
03383	Py_XDECREF(this->storage_V305);
03384	Py_XDECREF(this->storage_V307);
03385	Py_XDECREF(this->storage_V309);
03386	Py_XDECREF(this->storage_V311);
03387	Py_XDECREF(this->storage_V313);
03388	Py_XDECREF(this->storage_V315);
03389	Py_XDECREF(this->storage_V317);
03390	Py_XDECREF(this->storage_V319);
03391	Py_XDECREF(this->storage_V321);
03392	Py_XDECREF(this->storage_V323);
03393	Py_XDECREF(this->storage_V325);
03394	Py_XDECREF(this->storage_V327);
03395	Py_XDECREF(this->storage_V329);
03396	Py_XDECREF(this->storage_V331);
03397	Py_XDECREF(this->storage_V333);
03398	Py_XDECREF(this->storage_V335);
03399	Py_XDECREF(this->storage_V337);
03400	Py_XDECREF(this->storage_V339);
03401	Py_XDECREF(this->storage_V341);
03402	Py_XDECREF(this->storage_V343);
03403	Py_XDECREF(this->storage_V345);
03404	Py_XDECREF(this->storage_V347);
03405	Py_XDECREF(this->storage_V349);
03406	Py_XDECREF(this->storage_V351);
03407	Py_XDECREF(this->storage_V353);
03408	Py_XDECREF(this->storage_V355);
03409	Py_XDECREF(this->storage_V357);
03410	Py_XDECREF(this->storage_V359);
03411	Py_XDECREF(this->storage_V361);
03412	Py_XDECREF(this->storage_V363);
03413	Py_XDECREF(this->storage_V365);
03414	Py_XDECREF(this->storage_V367);
03415	Py_XDECREF(this->storage_V369);
03416	Py_XDECREF(this->storage_V371);
03417	Py_XDECREF(this->storage_V373);
03418	Py_XDECREF(this->storage_V375);
03419	Py_XDECREF(this->storage_V377);
03420	Py_XDECREF(this->storage_V379);
03421	Py_XDECREF(this->storage_V381);
03422	Py_XDECREF(this->storage_V383);
03423	Py_XDECREF(this->storage_V385);
03424	Py_XDECREF(this->storage_V387);
03425	Py_XDECREF(this->storage_V389);
03426	Py_XDECREF(this->storage_V391);
03427	Py_XDECREF(this->storage_V393);
03428	Py_XDECREF(this->storage_V395);
03429	Py_XDECREF(this->storage_V397);
03430	Py_XDECREF(this->storage_V399);
03431	Py_XDECREF(this->storage_V401);
03432	Py_XDECREF(this->storage_V403);
03433	Py_XDECREF(this->storage_V405);
03434	Py_XDECREF(this->storage_V407);
03435	Py_XDECREF(this->storage_V409);
03436	Py_XDECREF(this->storage_V411);
03437	Py_XDECREF(this->storage_V413);
03438	Py_XDECREF(this->storage_V415);
03439	Py_XDECREF(this->storage_V417);
03440	Py_XDECREF(this->storage_V419);
03441	Py_XDECREF(this->storage_V421);
03442	Py_XDECREF(this->storage_V423);
03443	Py_XDECREF(this->storage_V425);
03444	Py_XDECREF(this->storage_V427);
03445	Py_XDECREF(this->storage_V429);
03446	Py_XDECREF(this->storage_V431);
03447	Py_XDECREF(this->storage_V433);
03448	Py_XDECREF(this->storage_V435);
03449	Py_XDECREF(this->storage_V437);
03450	Py_XDECREF(this->storage_V439);
03451	Py_XDECREF(this->storage_V441);
03452	Py_XDECREF(this->storage_V443);
03453	Py_XDECREF(this->storage_V445);
03454	Py_XDECREF(this->storage_V447);
03455	Py_XDECREF(this->storage_V449);
03456	Py_XDECREF(this->storage_V451);
03457	Py_XDECREF(this->storage_V453);
03458	Py_XDECREF(this->storage_V455);
03459	Py_XDECREF(this->storage_V457);
03460	Py_XDECREF(this->storage_V459);
03461	Py_XDECREF(this->storage_V461);
03462	Py_XDECREF(this->storage_V463);
03463	Py_XDECREF(this->storage_V465);
03464	Py_XDECREF(this->storage_V467);
03465	Py_XDECREF(this->storage_V469);
03466	Py_XDECREF(this->storage_V471);
03467	Py_XDECREF(this->storage_V473);
03468	Py_XDECREF(this->storage_V475);
03469	Py_XDECREF(this->storage_V477);
03470	Py_XDECREF(this->storage_V479);
03471	Py_XDECREF(this->storage_V481);
03472	Py_XDECREF(this->storage_V483);
03473	Py_XDECREF(this->storage_V485);
03474	Py_XDECREF(this->storage_V487);
03475	Py_XDECREF(this->storage_V489);
03476	Py_XDECREF(this->storage_V491);
03477	Py_XDECREF(this->storage_V493);
03478	Py_XDECREF(this->storage_V495);
03479	Py_XDECREF(this->storage_V497);
03480	Py_XDECREF(this->storage_V499);
03481	Py_XDECREF(this->storage_V501);
03482	Py_XDECREF(this->storage_V503);
03483	Py_XDECREF(this->storage_V505);
03484	Py_XDECREF(this->storage_V507);
03485	Py_XDECREF(this->storage_V509);
03486	Py_XDECREF(this->storage_V511);
03487	Py_XDECREF(this->storage_V513);
03488	Py_XDECREF(this->storage_V515);
03489	Py_XDECREF(this->storage_V517);
03490	Py_XDECREF(this->storage_V519);
03491	Py_XDECREF(this->storage_V521);
03492	Py_XDECREF(this->storage_V523);
03493	Py_XDECREF(this->storage_V525);
03494	Py_XDECREF(this->storage_V527);
03495	Py_XDECREF(this->storage_V529);
03496	Py_XDECREF(this->storage_V531);
03497	Py_XDECREF(this->storage_V533);
03498	Py_XDECREF(this->storage_V535);
03499	Py_XDECREF(this->storage_V537);
03500	Py_XDECREF(this->storage_V539);
03501	Py_XDECREF(this->storage_V541);
03502	Py_XDECREF(this->storage_V543);
03503	Py_XDECREF(this->storage_V545);
03504	Py_XDECREF(this->storage_V547);
03505	Py_XDECREF(this->storage_V549);
03506	Py_XDECREF(this->storage_V551);
03507	Py_XDECREF(this->storage_V553);
03508	Py_XDECREF(this->storage_V555);
03509	Py_XDECREF(this->storage_V557);
03510	Py_XDECREF(this->storage_V559);
03511	Py_XDECREF(this->storage_V561);
03512	Py_XDECREF(this->storage_V563);
03513	Py_XDECREF(this->storage_V565);
03514	Py_XDECREF(this->storage_V567);
03515	Py_XDECREF(this->storage_V569);
03516	Py_XDECREF(this->storage_V571);
03517	Py_XDECREF(this->storage_V573);
03518	Py_XDECREF(this->storage_V575);
03519	Py_XDECREF(this->storage_V577);
03520	Py_XDECREF(this->storage_V579);
03521	Py_XDECREF(this->storage_V581);
03522	Py_XDECREF(this->storage_V583);
03523	Py_XDECREF(this->storage_V585);
03524	Py_XDECREF(this->storage_V587);
03525	Py_XDECREF(this->storage_V589);
03526	Py_XDECREF(this->storage_V591);
03527	Py_XDECREF(this->storage_V593);
03528	Py_XDECREF(this->storage_V595);
03529	Py_XDECREF(this->storage_V597);
03530	Py_XDECREF(this->storage_V599);
03531	Py_XDECREF(this->storage_V601);
03532	Py_XDECREF(this->storage_V603);
03533	Py_XDECREF(this->storage_V605);
03534	Py_XDECREF(this->storage_V607);
03535	Py_XDECREF(this->storage_V609);
03536	Py_XDECREF(this->storage_V611);
03537	Py_XDECREF(this->storage_V613);
03538	Py_XDECREF(this->storage_V615);
03539	Py_XDECREF(this->storage_V617);
03540	Py_XDECREF(this->storage_V619);
03541	Py_XDECREF(this->storage_V621);
03542	Py_XDECREF(this->storage_V623);
03543	Py_XDECREF(this->storage_V625);
03544	Py_XDECREF(this->storage_V627);
03545	Py_XDECREF(this->storage_V629);
03546	Py_XDECREF(this->storage_V631);
03547	Py_XDECREF(this->storage_V633);
03548	Py_XDECREF(this->storage_V635);
03549	Py_XDECREF(this->storage_V637);
03550	Py_XDECREF(this->storage_V639);
03551	Py_XDECREF(this->storage_V641);
03552	Py_XDECREF(this->storage_V643);
03553	Py_XDECREF(this->storage_V645);
03554	Py_XDECREF(this->storage_V647);
03555	Py_XDECREF(this->storage_V649);
03556	Py_XDECREF(this->storage_V651);
03557	Py_XDECREF(this->storage_V653);
03558	Py_XDECREF(this->storage_V655);
03559	Py_XDECREF(this->storage_V657);
03560	Py_XDECREF(this->storage_V659);
03561	Py_XDECREF(this->storage_V661);
03562	Py_XDECREF(this->storage_V663);
03563	Py_XDECREF(this->storage_V665);
03564	Py_XDECREF(this->storage_V667);
03565	Py_XDECREF(this->storage_V669);
03566	Py_XDECREF(this->storage_V671);
03567	Py_XDECREF(this->storage_V673);
03568	Py_XDECREF(this->storage_V675);
03569	Py_XDECREF(this->storage_V677);
03570	Py_XDECREF(this->storage_V679);
03571	Py_XDECREF(this->storage_V681);
03572	Py_XDECREF(this->storage_V683);
03573	Py_XDECREF(this->storage_V685);
03574	Py_XDECREF(this->storage_V687);
03575	Py_XDECREF(this->storage_V689);
03576	Py_XDECREF(this->storage_V691);
03577	Py_XDECREF(this->storage_V693);
03578	Py_XDECREF(this->storage_V695);
03579	Py_XDECREF(this->storage_V697);
03580	Py_XDECREF(this->storage_V699);
03581	Py_XDECREF(this->storage_V701);
03582	Py_XDECREF(this->storage_V703);
03583	Py_XDECREF(this->storage_V705);
03584	Py_XDECREF(this->storage_V707);
03585	Py_XDECREF(this->storage_V709);
03586	Py_XDECREF(this->storage_V711);
03587	Py_XDECREF(this->storage_V713);
03588	Py_XDECREF(this->storage_V715);
03589	Py_XDECREF(this->storage_V717);
03590	Py_XDECREF(this->storage_V719);
03591	Py_XDECREF(this->storage_V721);
03592	Py_XDECREF(this->storage_V723);
03593	Py_XDECREF(this->storage_V725);
03594	Py_XDECREF(this->storage_V727);
03595	Py_XDECREF(this->storage_V729);
03596	Py_XDECREF(this->storage_V731);
03597	Py_XDECREF(this->storage_V733);
03598	Py_XDECREF(this->storage_V735);
03599	Py_XDECREF(this->storage_V737);
03600	Py_XDECREF(this->storage_V739);
03601	Py_XDECREF(this->storage_V741);
03602	Py_XDECREF(this->storage_V743);
03603	Py_XDECREF(this->storage_V745);
03604	Py_XDECREF(this->storage_V747);
03605	Py_XDECREF(this->storage_V749);
03606	Py_XDECREF(this->storage_V751);
03607	Py_XDECREF(this->storage_V753);
03608	Py_XDECREF(this->storage_V755);
03609	Py_XDECREF(this->storage_V757);
03610	Py_XDECREF(this->storage_V759);
03611	Py_XDECREF(this->storage_V761);
03612	Py_XDECREF(this->storage_V763);
03613	Py_XDECREF(this->storage_V765);
03614	Py_XDECREF(this->storage_V767);
03615	Py_XDECREF(this->storage_V769);
03616	Py_XDECREF(this->storage_V771);
03617	Py_XDECREF(this->storage_V773);
03618	Py_XDECREF(this->storage_V775);
03619	Py_XDECREF(this->storage_V777);
03620	Py_XDECREF(this->storage_V779);
03621	Py_XDECREF(this->storage_V781);
03622	Py_XDECREF(this->storage_V783);
03623	Py_XDECREF(this->storage_V785);
03624	Py_XDECREF(this->storage_V787);
03625	Py_XDECREF(this->storage_V789);
03626	Py_XDECREF(this->storage_V791);
03627	Py_XDECREF(this->storage_V793);
03628	Py_XDECREF(this->storage_V795);
03629	Py_XDECREF(this->storage_V797);
03630	Py_XDECREF(this->storage_V799);
03631	Py_XDECREF(this->storage_V801);
03632	Py_XDECREF(this->storage_V803);
03633	Py_XDECREF(this->storage_V805);
03634	Py_XDECREF(this->storage_V807);
03635	Py_XDECREF(this->storage_V809);
03636	Py_XDECREF(this->storage_V811);
03637	Py_XDECREF(this->storage_V813);
03638	Py_XDECREF(this->storage_V815);
03639	Py_XDECREF(this->storage_V817);
03640	Py_XDECREF(this->storage_V819);
03641	Py_XDECREF(this->storage_V821);
03642	Py_XDECREF(this->storage_V823);
03643	Py_XDECREF(this->storage_V825);
03644	Py_XDECREF(this->storage_V827);
03645	Py_XDECREF(this->storage_V829);
03646	Py_XDECREF(this->storage_V831);
03647	Py_XDECREF(this->storage_V833);
03648	Py_XDECREF(this->storage_V835);
03649	Py_XDECREF(this->storage_V837);
03650	Py_XDECREF(this->storage_V839);
03651	Py_XDECREF(this->storage_V841);
03652	Py_XDECREF(this->storage_V843);
03653	Py_XDECREF(this->storage_V845);
03654	Py_XDECREF(this->storage_V847);
03655	Py_XDECREF(this->storage_V849);
03656	Py_XDECREF(this->storage_V851);
03657	Py_XDECREF(this->storage_V853);
03658	Py_XDECREF(this->storage_V855);
03659	Py_XDECREF(this->storage_V857);
03660	Py_XDECREF(this->storage_V859);
03661	Py_XDECREF(this->storage_V861);
03662	Py_XDECREF(this->storage_V863);
03663	Py_XDECREF(this->storage_V865);
03664	Py_XDECREF(this->storage_V867);
03665	Py_XDECREF(this->storage_V869);
03666	Py_XDECREF(this->storage_V871);
03667	Py_XDECREF(this->storage_V873);
03668	Py_XDECREF(this->storage_V875);
03669	Py_XDECREF(this->storage_V877);
03670	Py_XDECREF(this->storage_V879);
03671	Py_XDECREF(this->storage_V881);
03672	Py_XDECREF(this->storage_V883);
03673	Py_XDECREF(this->storage_V885);
03674	Py_XDECREF(this->storage_V887);
03675	Py_XDECREF(this->storage_V889);
03676	Py_XDECREF(this->storage_V891);
03677	Py_XDECREF(this->storage_V893);
03678	Py_XDECREF(this->storage_V895);
03679	Py_XDECREF(this->storage_V897);
03680	Py_XDECREF(this->storage_V899);
03681	Py_XDECREF(this->storage_V901);
03682	Py_XDECREF(this->storage_V903);
03683	Py_XDECREF(this->storage_V905);
03684	Py_XDECREF(this->storage_V907);
03685	Py_XDECREF(this->storage_V909);
03686	Py_XDECREF(this->storage_V1);
03687	        }
03688	        int run(void) {
03689	            int __failure = 0;
03690	            
03691	    PyObject* py_V1;
03692	    
03693	        PyArrayObject* V1;
03694	        
03695	            typedef npy_float64 dtype_V1;
03696	            
03697	    PyObject* py_V3;
03698	    
03699	        PyArrayObject* V3;
03700	        
03701	            typedef npy_float64 dtype_V3;
03702	            
03703	    PyObject* py_V5;
03704	    
03705	        PyArrayObject* V5;
03706	        
03707	            typedef npy_float64 dtype_V5;
03708	            
03709	    PyObject* py_V7;
03710	    
03711	        PyArrayObject* V7;
03712	        
03713	            typedef npy_float64 dtype_V7;
03714	            
03715	    PyObject* py_V9;
03716	    
03717	        PyArrayObject* V9;
03718	        
03719	            typedef npy_float64 dtype_V9;
03720	            
03721	    PyObject* py_V11;
03722	    
03723	        PyArrayObject* V11;
03724	        
03725	            typedef npy_float64 dtype_V11;
03726	            
03727	    PyObject* py_V13;
03728	    
03729	        PyArrayObject* V13;
03730	        
03731	            typedef npy_float64 dtype_V13;
03732	            
03733	    PyObject* py_V15;
03734	    
03735	        PyArrayObject* V15;
03736	        
03737	            typedef npy_float64 dtype_V15;
03738	            
03739	    PyObject* py_V17;
03740	    
03741	        PyArrayObject* V17;
03742	        
03743	            typedef npy_float64 dtype_V17;
03744	            
03745	    PyObject* py_V19;
03746	    
03747	        PyArrayObject* V19;
03748	        
03749	            typedef npy_float64 dtype_V19;
03750	            
03751	    PyObject* py_V21;
03752	    
03753	        PyArrayObject* V21;
03754	        
03755	            typedef npy_float64 dtype_V21;
03756	            
03757	    PyObject* py_V23;
03758	    
03759	        PyArrayObject* V23;
03760	        
03761	            typedef npy_float64 dtype_V23;
03762	            
03763	    PyObject* py_V25;
03764	    
03765	        PyArrayObject* V25;
03766	        
03767	            typedef npy_float64 dtype_V25;
03768	            
03769	    PyObject* py_V27;
03770	    
03771	        PyArrayObject* V27;
03772	        
03773	            typedef npy_float64 dtype_V27;
03774	            
03775	    PyObject* py_V29;
03776	    
03777	        PyArrayObject* V29;
03778	        
03779	            typedef npy_float64 dtype_V29;
03780	            
03781	    PyObject* py_V31;
03782	    
03783	        PyArrayObject* V31;
03784	        
03785	            typedef npy_float64 dtype_V31;
03786	            
03787	    PyObject* py_V33;
03788	    
03789	        PyArrayObject* V33;
03790	        
03791	            typedef npy_float64 dtype_V33;
03792	            
03793	    PyObject* py_V35;
03794	    
03795	        PyArrayObject* V35;
03796	        
03797	            typedef npy_float64 dtype_V35;
03798	            
03799	    PyObject* py_V37;
03800	    
03801	        PyArrayObject* V37;
03802	        
03803	            typedef npy_float64 dtype_V37;
03804	            
03805	    PyObject* py_V39;
03806	    
03807	        PyArrayObject* V39;
03808	        
03809	            typedef npy_float64 dtype_V39;
03810	            
03811	    PyObject* py_V41;
03812	    
03813	        PyArrayObject* V41;
03814	        
03815	            typedef npy_float64 dtype_V41;
03816	            
03817	    PyObject* py_V43;
03818	    
03819	        PyArrayObject* V43;
03820	        
03821	            typedef npy_float64 dtype_V43;
03822	            
03823	    PyObject* py_V45;
03824	    
03825	        PyArrayObject* V45;
03826	        
03827	            typedef npy_float64 dtype_V45;
03828	            
03829	    PyObject* py_V47;
03830	    
03831	        PyArrayObject* V47;
03832	        
03833	            typedef npy_float64 dtype_V47;
03834	            
03835	    PyObject* py_V49;
03836	    
03837	        PyArrayObject* V49;
03838	        
03839	            typedef npy_float64 dtype_V49;
03840	            
03841	    PyObject* py_V51;
03842	    
03843	        PyArrayObject* V51;
03844	        
03845	            typedef npy_float64 dtype_V51;
03846	            
03847	    PyObject* py_V53;
03848	    
03849	        PyArrayObject* V53;
03850	        
03851	            typedef npy_float64 dtype_V53;
03852	            
03853	    PyObject* py_V55;
03854	    
03855	        PyArrayObject* V55;
03856	        
03857	            typedef npy_float64 dtype_V55;
03858	            
03859	    PyObject* py_V57;
03860	    
03861	        PyArrayObject* V57;
03862	        
03863	            typedef npy_float64 dtype_V57;
03864	            
03865	    PyObject* py_V59;
03866	    
03867	        PyArrayObject* V59;
03868	        
03869	            typedef npy_float64 dtype_V59;
03870	            
03871	    PyObject* py_V61;
03872	    
03873	        PyArrayObject* V61;
03874	        
03875	            typedef npy_float64 dtype_V61;
03876	            
03877	    PyObject* py_V63;
03878	    
03879	        PyArrayObject* V63;
03880	        
03881	            typedef npy_float64 dtype_V63;
03882	            
03883	    PyObject* py_V65;
03884	    
03885	        PyArrayObject* V65;
03886	        
03887	            typedef npy_float64 dtype_V65;
03888	            
03889	    PyObject* py_V67;
03890	    
03891	        PyArrayObject* V67;
03892	        
03893	            typedef npy_float64 dtype_V67;
03894	            
03895	    PyObject* py_V69;
03896	    
03897	        PyArrayObject* V69;
03898	        
03899	            typedef npy_float64 dtype_V69;
03900	            
03901	    PyObject* py_V71;
03902	    
03903	        PyArrayObject* V71;
03904	        
03905	            typedef npy_float64 dtype_V71;
03906	            
03907	    PyObject* py_V73;
03908	    
03909	        PyArrayObject* V73;
03910	        
03911	            typedef npy_float64 dtype_V73;
03912	            
03913	    PyObject* py_V75;
03914	    
03915	        PyArrayObject* V75;
03916	        
03917	            typedef npy_float64 dtype_V75;
03918	            
03919	    PyObject* py_V77;
03920	    
03921	        PyArrayObject* V77;
03922	        
03923	            typedef npy_float64 dtype_V77;
03924	            
03925	    PyObject* py_V79;
03926	    
03927	        PyArrayObject* V79;
03928	        
03929	            typedef npy_float64 dtype_V79;
03930	            
03931	    PyObject* py_V81;
03932	    
03933	        PyArrayObject* V81;
03934	        
03935	            typedef npy_float64 dtype_V81;
03936	            
03937	    PyObject* py_V83;
03938	    
03939	        PyArrayObject* V83;
03940	        
03941	            typedef npy_float64 dtype_V83;
03942	            
03943	    PyObject* py_V85;
03944	    
03945	        PyArrayObject* V85;
03946	        
03947	            typedef npy_float64 dtype_V85;
03948	            
03949	    PyObject* py_V87;
03950	    
03951	        PyArrayObject* V87;
03952	        
03953	            typedef npy_float64 dtype_V87;
03954	            
03955	    PyObject* py_V89;
03956	    
03957	        PyArrayObject* V89;
03958	        
03959	            typedef npy_float64 dtype_V89;
03960	            
03961	    PyObject* py_V91;
03962	    
03963	        PyArrayObject* V91;
03964	        
03965	            typedef npy_float64 dtype_V91;
03966	            
03967	    PyObject* py_V93;
03968	    
03969	        PyArrayObject* V93;
03970	        
03971	            typedef npy_float64 dtype_V93;
03972	            
03973	    PyObject* py_V95;
03974	    
03975	        PyArrayObject* V95;
03976	        
03977	            typedef npy_float64 dtype_V95;
03978	            
03979	    PyObject* py_V97;
03980	    
03981	        PyArrayObject* V97;
03982	        
03983	            typedef npy_float64 dtype_V97;
03984	            
03985	    PyObject* py_V99;
03986	    
03987	        PyArrayObject* V99;
03988	        
03989	            typedef npy_float64 dtype_V99;
03990	            
03991	    PyObject* py_V101;
03992	    
03993	        PyArrayObject* V101;
03994	        
03995	            typedef npy_float64 dtype_V101;
03996	            
03997	    PyObject* py_V103;
03998	    
03999	        PyArrayObject* V103;
04000	        
04001	            typedef npy_float64 dtype_V103;
04002	            
04003	    PyObject* py_V105;
04004	    
04005	        PyArrayObject* V105;
04006	        
04007	            typedef npy_float64 dtype_V105;
04008	            
04009	    PyObject* py_V107;
04010	    
04011	        PyArrayObject* V107;
04012	        
04013	            typedef npy_float64 dtype_V107;
04014	            
04015	    PyObject* py_V109;
04016	    
04017	        PyArrayObject* V109;
04018	        
04019	            typedef npy_float64 dtype_V109;
04020	            
04021	    PyObject* py_V111;
04022	    
04023	        PyArrayObject* V111;
04024	        
04025	            typedef npy_float64 dtype_V111;
04026	            
04027	    PyObject* py_V113;
04028	    
04029	        PyArrayObject* V113;
04030	        
04031	            typedef npy_float64 dtype_V113;
04032	            
04033	    PyObject* py_V115;
04034	    
04035	        PyArrayObject* V115;
04036	        
04037	            typedef npy_float64 dtype_V115;
04038	            
04039	    PyObject* py_V117;
04040	    
04041	        PyArrayObject* V117;
04042	        
04043	            typedef npy_float64 dtype_V117;
04044	            
04045	    PyObject* py_V119;
04046	    
04047	        PyArrayObject* V119;
04048	        
04049	            typedef npy_float64 dtype_V119;
04050	            
04051	    PyObject* py_V121;
04052	    
04053	        PyArrayObject* V121;
04054	        
04055	            typedef npy_float64 dtype_V121;
04056	            
04057	    PyObject* py_V123;
04058	    
04059	        PyArrayObject* V123;
04060	        
04061	            typedef npy_float64 dtype_V123;
04062	            
04063	    PyObject* py_V125;
04064	    
04065	        PyArrayObject* V125;
04066	        
04067	            typedef npy_float64 dtype_V125;
04068	            
04069	    PyObject* py_V127;
04070	    
04071	        PyArrayObject* V127;
04072	        
04073	            typedef npy_float64 dtype_V127;
04074	            
04075	    PyObject* py_V129;
04076	    
04077	        PyArrayObject* V129;
04078	        
04079	            typedef npy_float64 dtype_V129;
04080	            
04081	    PyObject* py_V131;
04082	    
04083	        PyArrayObject* V131;
04084	        
04085	            typedef npy_float64 dtype_V131;
04086	            
04087	    PyObject* py_V133;
04088	    
04089	        PyArrayObject* V133;
04090	        
04091	            typedef npy_float64 dtype_V133;
04092	            
04093	    PyObject* py_V135;
04094	    
04095	        PyArrayObject* V135;
04096	        
04097	            typedef npy_float64 dtype_V135;
04098	            
04099	    PyObject* py_V137;
04100	    
04101	        PyArrayObject* V137;
04102	        
04103	            typedef npy_float64 dtype_V137;
04104	            
04105	    PyObject* py_V139;
04106	    
04107	        PyArrayObject* V139;
04108	        
04109	            typedef npy_float64 dtype_V139;
04110	            
04111	    PyObject* py_V141;
04112	    
04113	        PyArrayObject* V141;
04114	        
04115	            typedef npy_float64 dtype_V141;
04116	            
04117	    PyObject* py_V143;
04118	    
04119	        PyArrayObject* V143;
04120	        
04121	            typedef npy_float64 dtype_V143;
04122	            
04123	    PyObject* py_V145;
04124	    
04125	        PyArrayObject* V145;
04126	        
04127	            typedef npy_float64 dtype_V145;
04128	            
04129	    PyObject* py_V147;
04130	    
04131	        PyArrayObject* V147;
04132	        
04133	            typedef npy_float64 dtype_V147;
04134	            
04135	    PyObject* py_V149;
04136	    
04137	        PyArrayObject* V149;
04138	        
04139	            typedef npy_float64 dtype_V149;
04140	            
04141	    PyObject* py_V151;
04142	    
04143	        PyArrayObject* V151;
04144	        
04145	            typedef npy_float64 dtype_V151;
04146	            
04147	    PyObject* py_V153;
04148	    
04149	        PyArrayObject* V153;
04150	        
04151	            typedef npy_float64 dtype_V153;
04152	            
04153	    PyObject* py_V155;
04154	    
04155	        PyArrayObject* V155;
04156	        
04157	            typedef npy_float64 dtype_V155;
04158	            
04159	    PyObject* py_V157;
04160	    
04161	        PyArrayObject* V157;
04162	        
04163	            typedef npy_float64 dtype_V157;
04164	            
04165	    PyObject* py_V159;
04166	    
04167	        PyArrayObject* V159;
04168	        
04169	            typedef npy_float64 dtype_V159;
04170	            
04171	    PyObject* py_V161;
04172	    
04173	        PyArrayObject* V161;
04174	        
04175	            typedef npy_float64 dtype_V161;
04176	            
04177	    PyObject* py_V163;
04178	    
04179	        PyArrayObject* V163;
04180	        
04181	            typedef npy_float64 dtype_V163;
04182	            
04183	    PyObject* py_V165;
04184	    
04185	        PyArrayObject* V165;
04186	        
04187	            typedef npy_float64 dtype_V165;
04188	            
04189	    PyObject* py_V167;
04190	    
04191	        PyArrayObject* V167;
04192	        
04193	            typedef npy_float64 dtype_V167;
04194	            
04195	    PyObject* py_V169;
04196	    
04197	        PyArrayObject* V169;
04198	        
04199	            typedef npy_float64 dtype_V169;
04200	            
04201	    PyObject* py_V171;
04202	    
04203	        PyArrayObject* V171;
04204	        
04205	            typedef npy_float64 dtype_V171;
04206	            
04207	    PyObject* py_V173;
04208	    
04209	        PyArrayObject* V173;
04210	        
04211	            typedef npy_float64 dtype_V173;
04212	            
04213	    PyObject* py_V175;
04214	    
04215	        PyArrayObject* V175;
04216	        
04217	            typedef npy_float64 dtype_V175;
04218	            
04219	    PyObject* py_V177;
04220	    
04221	        PyArrayObject* V177;
04222	        
04223	            typedef npy_float64 dtype_V177;
04224	            
04225	    PyObject* py_V179;
04226	    
04227	        PyArrayObject* V179;
04228	        
04229	            typedef npy_float64 dtype_V179;
04230	            
04231	    PyObject* py_V181;
04232	    
04233	        PyArrayObject* V181;
04234	        
04235	            typedef npy_float64 dtype_V181;
04236	            
04237	    PyObject* py_V183;
04238	    
04239	        PyArrayObject* V183;
04240	        
04241	            typedef npy_float64 dtype_V183;
04242	            
04243	    PyObject* py_V185;
04244	    
04245	        PyArrayObject* V185;
04246	        
04247	            typedef npy_float64 dtype_V185;
04248	            
04249	    PyObject* py_V187;
04250	    
04251	        PyArrayObject* V187;
04252	        
04253	            typedef npy_float64 dtype_V187;
04254	            
04255	    PyObject* py_V189;
04256	    
04257	        PyArrayObject* V189;
04258	        
04259	            typedef npy_float64 dtype_V189;
04260	            
04261	    PyObject* py_V191;
04262	    
04263	        PyArrayObject* V191;
04264	        
04265	            typedef npy_float64 dtype_V191;
04266	            
04267	    PyObject* py_V193;
04268	    
04269	        PyArrayObject* V193;
04270	        
04271	            typedef npy_float64 dtype_V193;
04272	            
04273	    PyObject* py_V195;
04274	    
04275	        PyArrayObject* V195;
04276	        
04277	            typedef npy_float64 dtype_V195;
04278	            
04279	    PyObject* py_V197;
04280	    
04281	        PyArrayObject* V197;
04282	        
04283	            typedef npy_float64 dtype_V197;
04284	            
04285	    PyObject* py_V199;
04286	    
04287	        PyArrayObject* V199;
04288	        
04289	            typedef npy_float64 dtype_V199;
04290	            
04291	    PyObject* py_V201;
04292	    
04293	        PyArrayObject* V201;
04294	        
04295	            typedef npy_float64 dtype_V201;
04296	            
04297	    PyObject* py_V203;
04298	    
04299	        PyArrayObject* V203;
04300	        
04301	            typedef npy_float64 dtype_V203;
04302	            
04303	    PyObject* py_V205;
04304	    
04305	        PyArrayObject* V205;
04306	        
04307	            typedef npy_float64 dtype_V205;
04308	            
04309	    PyObject* py_V207;
04310	    
04311	        PyArrayObject* V207;
04312	        
04313	            typedef npy_float64 dtype_V207;
04314	            
04315	    PyObject* py_V209;
04316	    
04317	        PyArrayObject* V209;
04318	        
04319	            typedef npy_float64 dtype_V209;
04320	            
04321	    PyObject* py_V211;
04322	    
04323	        PyArrayObject* V211;
04324	        
04325	            typedef npy_float64 dtype_V211;
04326	            
04327	    PyObject* py_V213;
04328	    
04329	        PyArrayObject* V213;
04330	        
04331	            typedef npy_float64 dtype_V213;
04332	            
04333	    PyObject* py_V215;
04334	    
04335	        PyArrayObject* V215;
04336	        
04337	            typedef npy_float64 dtype_V215;
04338	            
04339	    PyObject* py_V217;
04340	    
04341	        PyArrayObject* V217;
04342	        
04343	            typedef npy_float64 dtype_V217;
04344	            
04345	    PyObject* py_V219;
04346	    
04347	        PyArrayObject* V219;
04348	        
04349	            typedef npy_float64 dtype_V219;
04350	            
04351	    PyObject* py_V221;
04352	    
04353	        PyArrayObject* V221;
04354	        
04355	            typedef npy_float64 dtype_V221;
04356	            
04357	    PyObject* py_V223;
04358	    
04359	        PyArrayObject* V223;
04360	        
04361	            typedef npy_float64 dtype_V223;
04362	            
04363	    PyObject* py_V225;
04364	    
04365	        PyArrayObject* V225;
04366	        
04367	            typedef npy_float64 dtype_V225;
04368	            
04369	    PyObject* py_V227;
04370	    
04371	        PyArrayObject* V227;
04372	        
04373	            typedef npy_float64 dtype_V227;
04374	            
04375	    PyObject* py_V229;
04376	    
04377	        PyArrayObject* V229;
04378	        
04379	            typedef npy_float64 dtype_V229;
04380	            
04381	    PyObject* py_V231;
04382	    
04383	        PyArrayObject* V231;
04384	        
04385	            typedef npy_float64 dtype_V231;
04386	            
04387	    PyObject* py_V233;
04388	    
04389	        PyArrayObject* V233;
04390	        
04391	            typedef npy_float64 dtype_V233;
04392	            
04393	    PyObject* py_V235;
04394	    
04395	        PyArrayObject* V235;
04396	        
04397	            typedef npy_float64 dtype_V235;
04398	            
04399	    PyObject* py_V237;
04400	    
04401	        PyArrayObject* V237;
04402	        
04403	            typedef npy_float64 dtype_V237;
04404	            
04405	    PyObject* py_V239;
04406	    
04407	        PyArrayObject* V239;
04408	        
04409	            typedef npy_float64 dtype_V239;
04410	            
04411	    PyObject* py_V241;
04412	    
04413	        PyArrayObject* V241;
04414	        
04415	            typedef npy_float64 dtype_V241;
04416	            
04417	    PyObject* py_V243;
04418	    
04419	        PyArrayObject* V243;
04420	        
04421	            typedef npy_float64 dtype_V243;
04422	            
04423	    PyObject* py_V245;
04424	    
04425	        PyArrayObject* V245;
04426	        
04427	            typedef npy_float64 dtype_V245;
04428	            
04429	    PyObject* py_V247;
04430	    
04431	        PyArrayObject* V247;
04432	        
04433	            typedef npy_float64 dtype_V247;
04434	            
04435	    PyObject* py_V249;
04436	    
04437	        PyArrayObject* V249;
04438	        
04439	            typedef npy_float64 dtype_V249;
04440	            
04441	    PyObject* py_V251;
04442	    
04443	        PyArrayObject* V251;
04444	        
04445	            typedef npy_float64 dtype_V251;
04446	            
04447	    PyObject* py_V253;
04448	    
04449	        PyArrayObject* V253;
04450	        
04451	            typedef npy_float64 dtype_V253;
04452	            
04453	    PyObject* py_V255;
04454	    
04455	        PyArrayObject* V255;
04456	        
04457	            typedef npy_float64 dtype_V255;
04458	            
04459	    PyObject* py_V257;
04460	    
04461	        PyArrayObject* V257;
04462	        
04463	            typedef npy_float64 dtype_V257;
04464	            
04465	    PyObject* py_V259;
04466	    
04467	        PyArrayObject* V259;
04468	        
04469	            typedef npy_float64 dtype_V259;
04470	            
04471	    PyObject* py_V261;
04472	    
04473	        PyArrayObject* V261;
04474	        
04475	            typedef npy_float64 dtype_V261;
04476	            
04477	    PyObject* py_V263;
04478	    
04479	        PyArrayObject* V263;
04480	        
04481	            typedef npy_float64 dtype_V263;
04482	            
04483	    PyObject* py_V265;
04484	    
04485	        PyArrayObject* V265;
04486	        
04487	            typedef npy_float64 dtype_V265;
04488	            
04489	    PyObject* py_V267;
04490	    
04491	        PyArrayObject* V267;
04492	        
04493	            typedef npy_float64 dtype_V267;
04494	            
04495	    PyObject* py_V269;
04496	    
04497	        PyArrayObject* V269;
04498	        
04499	            typedef npy_float64 dtype_V269;
04500	            
04501	    PyObject* py_V271;
04502	    
04503	        PyArrayObject* V271;
04504	        
04505	            typedef npy_float64 dtype_V271;
04506	            
04507	    PyObject* py_V273;
04508	    
04509	        PyArrayObject* V273;
04510	        
04511	            typedef npy_float64 dtype_V273;
04512	            
04513	    PyObject* py_V275;
04514	    
04515	        PyArrayObject* V275;
04516	        
04517	            typedef npy_float64 dtype_V275;
04518	            
04519	    PyObject* py_V277;
04520	    
04521	        PyArrayObject* V277;
04522	        
04523	            typedef npy_float64 dtype_V277;
04524	            
04525	    PyObject* py_V279;
04526	    
04527	        PyArrayObject* V279;
04528	        
04529	            typedef npy_float64 dtype_V279;
04530	            
04531	    PyObject* py_V281;
04532	    
04533	        PyArrayObject* V281;
04534	        
04535	            typedef npy_float64 dtype_V281;
04536	            
04537	    PyObject* py_V283;
04538	    
04539	        PyArrayObject* V283;
04540	        
04541	            typedef npy_float64 dtype_V283;
04542	            
04543	    PyObject* py_V285;
04544	    
04545	        PyArrayObject* V285;
04546	        
04547	            typedef npy_float64 dtype_V285;
04548	            
04549	    PyObject* py_V287;
04550	    
04551	        PyArrayObject* V287;
04552	        
04553	            typedef npy_float64 dtype_V287;
04554	            
04555	    PyObject* py_V289;
04556	    
04557	        PyArrayObject* V289;
04558	        
04559	            typedef npy_float64 dtype_V289;
04560	            
04561	    PyObject* py_V291;
04562	    
04563	        PyArrayObject* V291;
04564	        
04565	            typedef npy_float64 dtype_V291;
04566	            
04567	    PyObject* py_V293;
04568	    
04569	        PyArrayObject* V293;
04570	        
04571	            typedef npy_float64 dtype_V293;
04572	            
04573	    PyObject* py_V295;
04574	    
04575	        PyArrayObject* V295;
04576	        
04577	            typedef npy_float64 dtype_V295;
04578	            
04579	    PyObject* py_V297;
04580	    
04581	        PyArrayObject* V297;
04582	        
04583	            typedef npy_float64 dtype_V297;
04584	            
04585	    PyObject* py_V299;
04586	    
04587	        PyArrayObject* V299;
04588	        
04589	            typedef npy_float64 dtype_V299;
04590	            
04591	    PyObject* py_V301;
04592	    
04593	        PyArrayObject* V301;
04594	        
04595	            typedef npy_float64 dtype_V301;
04596	            
04597	    PyObject* py_V303;
04598	    
04599	        PyArrayObject* V303;
04600	        
04601	            typedef npy_float64 dtype_V303;
04602	            
04603	    PyObject* py_V305;
04604	    
04605	        PyArrayObject* V305;
04606	        
04607	            typedef npy_float64 dtype_V305;
04608	            
04609	    PyObject* py_V307;
04610	    
04611	        PyArrayObject* V307;
04612	        
04613	            typedef npy_float64 dtype_V307;
04614	            
04615	    PyObject* py_V309;
04616	    
04617	        PyArrayObject* V309;
04618	        
04619	            typedef npy_float64 dtype_V309;
04620	            
04621	    PyObject* py_V311;
04622	    
04623	        PyArrayObject* V311;
04624	        
04625	            typedef npy_float64 dtype_V311;
04626	            
04627	    PyObject* py_V313;
04628	    
04629	        PyArrayObject* V313;
04630	        
04631	            typedef npy_float64 dtype_V313;
04632	            
04633	    PyObject* py_V315;
04634	    
04635	        PyArrayObject* V315;
04636	        
04637	            typedef npy_float64 dtype_V315;
04638	            
04639	    PyObject* py_V317;
04640	    
04641	        PyArrayObject* V317;
04642	        
04643	            typedef npy_float64 dtype_V317;
04644	            
04645	    PyObject* py_V319;
04646	    
04647	        PyArrayObject* V319;
04648	        
04649	            typedef npy_float64 dtype_V319;
04650	            
04651	    PyObject* py_V321;
04652	    
04653	        PyArrayObject* V321;
04654	        
04655	            typedef npy_float64 dtype_V321;
04656	            
04657	    PyObject* py_V323;
04658	    
04659	        PyArrayObject* V323;
04660	        
04661	            typedef npy_float64 dtype_V323;
04662	            
04663	    PyObject* py_V325;
04664	    
04665	        PyArrayObject* V325;
04666	        
04667	            typedef npy_float64 dtype_V325;
04668	            
04669	    PyObject* py_V327;
04670	    
04671	        PyArrayObject* V327;
04672	        
04673	            typedef npy_float64 dtype_V327;
04674	            
04675	    PyObject* py_V329;
04676	    
04677	        PyArrayObject* V329;
04678	        
04679	            typedef npy_float64 dtype_V329;
04680	            
04681	    PyObject* py_V331;
04682	    
04683	        PyArrayObject* V331;
04684	        
04685	            typedef npy_float64 dtype_V331;
04686	            
04687	    PyObject* py_V333;
04688	    
04689	        PyArrayObject* V333;
04690	        
04691	            typedef npy_float64 dtype_V333;
04692	            
04693	    PyObject* py_V335;
04694	    
04695	        PyArrayObject* V335;
04696	        
04697	            typedef npy_float64 dtype_V335;
04698	            
04699	    PyObject* py_V337;
04700	    
04701	        PyArrayObject* V337;
04702	        
04703	            typedef npy_float64 dtype_V337;
04704	            
04705	    PyObject* py_V339;
04706	    
04707	        PyArrayObject* V339;
04708	        
04709	            typedef npy_float64 dtype_V339;
04710	            
04711	    PyObject* py_V341;
04712	    
04713	        PyArrayObject* V341;
04714	        
04715	            typedef npy_float64 dtype_V341;
04716	            
04717	    PyObject* py_V343;
04718	    
04719	        PyArrayObject* V343;
04720	        
04721	            typedef npy_float64 dtype_V343;
04722	            
04723	    PyObject* py_V345;
04724	    
04725	        PyArrayObject* V345;
04726	        
04727	            typedef npy_float64 dtype_V345;
04728	            
04729	    PyObject* py_V347;
04730	    
04731	        PyArrayObject* V347;
04732	        
04733	            typedef npy_float64 dtype_V347;
04734	            
04735	    PyObject* py_V349;
04736	    
04737	        PyArrayObject* V349;
04738	        
04739	            typedef npy_float64 dtype_V349;
04740	            
04741	    PyObject* py_V351;
04742	    
04743	        PyArrayObject* V351;
04744	        
04745	            typedef npy_float64 dtype_V351;
04746	            
04747	    PyObject* py_V353;
04748	    
04749	        PyArrayObject* V353;
04750	        
04751	            typedef npy_float64 dtype_V353;
04752	            
04753	    PyObject* py_V355;
04754	    
04755	        PyArrayObject* V355;
04756	        
04757	            typedef npy_float64 dtype_V355;
04758	            
04759	    PyObject* py_V357;
04760	    
04761	        PyArrayObject* V357;
04762	        
04763	            typedef npy_float64 dtype_V357;
04764	            
04765	    PyObject* py_V359;
04766	    
04767	        PyArrayObject* V359;
04768	        
04769	            typedef npy_float64 dtype_V359;
04770	            
04771	    PyObject* py_V361;
04772	    
04773	        PyArrayObject* V361;
04774	        
04775	            typedef npy_float64 dtype_V361;
04776	            
04777	    PyObject* py_V363;
04778	    
04779	        PyArrayObject* V363;
04780	        
04781	            typedef npy_float64 dtype_V363;
04782	            
04783	    PyObject* py_V365;
04784	    
04785	        PyArrayObject* V365;
04786	        
04787	            typedef npy_float64 dtype_V365;
04788	            
04789	    PyObject* py_V367;
04790	    
04791	        PyArrayObject* V367;
04792	        
04793	            typedef npy_float64 dtype_V367;
04794	            
04795	    PyObject* py_V369;
04796	    
04797	        PyArrayObject* V369;
04798	        
04799	            typedef npy_float64 dtype_V369;
04800	            
04801	    PyObject* py_V371;
04802	    
04803	        PyArrayObject* V371;
04804	        
04805	            typedef npy_float64 dtype_V371;
04806	            
04807	    PyObject* py_V373;
04808	    
04809	        PyArrayObject* V373;
04810	        
04811	            typedef npy_float64 dtype_V373;
04812	            
04813	    PyObject* py_V375;
04814	    
04815	        PyArrayObject* V375;
04816	        
04817	            typedef npy_float64 dtype_V375;
04818	            
04819	    PyObject* py_V377;
04820	    
04821	        PyArrayObject* V377;
04822	        
04823	            typedef npy_float64 dtype_V377;
04824	            
04825	    PyObject* py_V379;
04826	    
04827	        PyArrayObject* V379;
04828	        
04829	            typedef npy_float64 dtype_V379;
04830	            
04831	    PyObject* py_V381;
04832	    
04833	        PyArrayObject* V381;
04834	        
04835	            typedef npy_float64 dtype_V381;
04836	            
04837	    PyObject* py_V383;
04838	    
04839	        PyArrayObject* V383;
04840	        
04841	            typedef npy_float64 dtype_V383;
04842	            
04843	    PyObject* py_V385;
04844	    
04845	        PyArrayObject* V385;
04846	        
04847	            typedef npy_float64 dtype_V385;
04848	            
04849	    PyObject* py_V387;
04850	    
04851	        PyArrayObject* V387;
04852	        
04853	            typedef npy_float64 dtype_V387;
04854	            
04855	    PyObject* py_V389;
04856	    
04857	        PyArrayObject* V389;
04858	        
04859	            typedef npy_float64 dtype_V389;
04860	            
04861	    PyObject* py_V391;
04862	    
04863	        PyArrayObject* V391;
04864	        
04865	            typedef npy_float64 dtype_V391;
04866	            
04867	    PyObject* py_V393;
04868	    
04869	        PyArrayObject* V393;
04870	        
04871	            typedef npy_float64 dtype_V393;
04872	            
04873	    PyObject* py_V395;
04874	    
04875	        PyArrayObject* V395;
04876	        
04877	            typedef npy_float64 dtype_V395;
04878	            
04879	    PyObject* py_V397;
04880	    
04881	        PyArrayObject* V397;
04882	        
04883	            typedef npy_float64 dtype_V397;
04884	            
04885	    PyObject* py_V399;
04886	    
04887	        PyArrayObject* V399;
04888	        
04889	            typedef npy_float64 dtype_V399;
04890	            
04891	    PyObject* py_V401;
04892	    
04893	        PyArrayObject* V401;
04894	        
04895	            typedef npy_float64 dtype_V401;
04896	            
04897	    PyObject* py_V403;
04898	    
04899	        PyArrayObject* V403;
04900	        
04901	            typedef npy_float64 dtype_V403;
04902	            
04903	    PyObject* py_V405;
04904	    
04905	        PyArrayObject* V405;
04906	        
04907	            typedef npy_float64 dtype_V405;
04908	            
04909	    PyObject* py_V407;
04910	    
04911	        PyArrayObject* V407;
04912	        
04913	            typedef npy_float64 dtype_V407;
04914	            
04915	    PyObject* py_V409;
04916	    
04917	        PyArrayObject* V409;
04918	        
04919	            typedef npy_float64 dtype_V409;
04920	            
04921	    PyObject* py_V411;
04922	    
04923	        PyArrayObject* V411;
04924	        
04925	            typedef npy_float64 dtype_V411;
04926	            
04927	    PyObject* py_V413;
04928	    
04929	        PyArrayObject* V413;
04930	        
04931	            typedef npy_float64 dtype_V413;
04932	            
04933	    PyObject* py_V415;
04934	    
04935	        PyArrayObject* V415;
04936	        
04937	            typedef npy_float64 dtype_V415;
04938	            
04939	    PyObject* py_V417;
04940	    
04941	        PyArrayObject* V417;
04942	        
04943	            typedef npy_float64 dtype_V417;
04944	            
04945	    PyObject* py_V419;
04946	    
04947	        PyArrayObject* V419;
04948	        
04949	            typedef npy_float64 dtype_V419;
04950	            
04951	    PyObject* py_V421;
04952	    
04953	        PyArrayObject* V421;
04954	        
04955	            typedef npy_float64 dtype_V421;
04956	            
04957	    PyObject* py_V423;
04958	    
04959	        PyArrayObject* V423;
04960	        
04961	            typedef npy_float64 dtype_V423;
04962	            
04963	    PyObject* py_V425;
04964	    
04965	        PyArrayObject* V425;
04966	        
04967	            typedef npy_float64 dtype_V425;
04968	            
04969	    PyObject* py_V427;
04970	    
04971	        PyArrayObject* V427;
04972	        
04973	            typedef npy_float64 dtype_V427;
04974	            
04975	    PyObject* py_V429;
04976	    
04977	        PyArrayObject* V429;
04978	        
04979	            typedef npy_float64 dtype_V429;
04980	            
04981	    PyObject* py_V431;
04982	    
04983	        PyArrayObject* V431;
04984	        
04985	            typedef npy_float64 dtype_V431;
04986	            
04987	    PyObject* py_V433;
04988	    
04989	        PyArrayObject* V433;
04990	        
04991	            typedef npy_float64 dtype_V433;
04992	            
04993	    PyObject* py_V435;
04994	    
04995	        PyArrayObject* V435;
04996	        
04997	            typedef npy_float64 dtype_V435;
04998	            
04999	    PyObject* py_V437;
05000	    
05001	        PyArrayObject* V437;
05002	        
05003	            typedef npy_float64 dtype_V437;
05004	            
05005	    PyObject* py_V439;
05006	    
05007	        PyArrayObject* V439;
05008	        
05009	            typedef npy_float64 dtype_V439;
05010	            
05011	    PyObject* py_V441;
05012	    
05013	        PyArrayObject* V441;
05014	        
05015	            typedef npy_float64 dtype_V441;
05016	            
05017	    PyObject* py_V443;
05018	    
05019	        PyArrayObject* V443;
05020	        
05021	            typedef npy_float64 dtype_V443;
05022	            
05023	    PyObject* py_V445;
05024	    
05025	        PyArrayObject* V445;
05026	        
05027	            typedef npy_float64 dtype_V445;
05028	            
05029	    PyObject* py_V447;
05030	    
05031	        PyArrayObject* V447;
05032	        
05033	            typedef npy_float64 dtype_V447;
05034	            
05035	    PyObject* py_V449;
05036	    
05037	        PyArrayObject* V449;
05038	        
05039	            typedef npy_float64 dtype_V449;
05040	            
05041	    PyObject* py_V451;
05042	    
05043	        PyArrayObject* V451;
05044	        
05045	            typedef npy_float64 dtype_V451;
05046	            
05047	    PyObject* py_V453;
05048	    
05049	        PyArrayObject* V453;
05050	        
05051	            typedef npy_float64 dtype_V453;
05052	            
05053	    PyObject* py_V455;
05054	    
05055	        PyArrayObject* V455;
05056	        
05057	            typedef npy_float64 dtype_V455;
05058	            
05059	    PyObject* py_V457;
05060	    
05061	        PyArrayObject* V457;
05062	        
05063	            typedef npy_float64 dtype_V457;
05064	            
05065	    PyObject* py_V459;
05066	    
05067	        PyArrayObject* V459;
05068	        
05069	            typedef npy_float64 dtype_V459;
05070	            
05071	    PyObject* py_V461;
05072	    
05073	        PyArrayObject* V461;
05074	        
05075	            typedef npy_float64 dtype_V461;
05076	            
05077	    PyObject* py_V463;
05078	    
05079	        PyArrayObject* V463;
05080	        
05081	            typedef npy_float64 dtype_V463;
05082	            
05083	    PyObject* py_V465;
05084	    
05085	        PyArrayObject* V465;
05086	        
05087	            typedef npy_float64 dtype_V465;
05088	            
05089	    PyObject* py_V467;
05090	    
05091	        PyArrayObject* V467;
05092	        
05093	            typedef npy_float64 dtype_V467;
05094	            
05095	    PyObject* py_V469;
05096	    
05097	        PyArrayObject* V469;
05098	        
05099	            typedef npy_float64 dtype_V469;
05100	            
05101	    PyObject* py_V471;
05102	    
05103	        PyArrayObject* V471;
05104	        
05105	            typedef npy_float64 dtype_V471;
05106	            
05107	    PyObject* py_V473;
05108	    
05109	        PyArrayObject* V473;
05110	        
05111	            typedef npy_float64 dtype_V473;
05112	            
05113	    PyObject* py_V475;
05114	    
05115	        PyArrayObject* V475;
05116	        
05117	            typedef npy_float64 dtype_V475;
05118	            
05119	    PyObject* py_V477;
05120	    
05121	        PyArrayObject* V477;
05122	        
05123	            typedef npy_float64 dtype_V477;
05124	            
05125	    PyObject* py_V479;
05126	    
05127	        PyArrayObject* V479;
05128	        
05129	            typedef npy_float64 dtype_V479;
05130	            
05131	    PyObject* py_V481;
05132	    
05133	        PyArrayObject* V481;
05134	        
05135	            typedef npy_float64 dtype_V481;
05136	            
05137	    PyObject* py_V483;
05138	    
05139	        PyArrayObject* V483;
05140	        
05141	            typedef npy_float64 dtype_V483;
05142	            
05143	    PyObject* py_V485;
05144	    
05145	        PyArrayObject* V485;
05146	        
05147	            typedef npy_float64 dtype_V485;
05148	            
05149	    PyObject* py_V487;
05150	    
05151	        PyArrayObject* V487;
05152	        
05153	            typedef npy_float64 dtype_V487;
05154	            
05155	    PyObject* py_V489;
05156	    
05157	        PyArrayObject* V489;
05158	        
05159	            typedef npy_float64 dtype_V489;
05160	            
05161	    PyObject* py_V491;
05162	    
05163	        PyArrayObject* V491;
05164	        
05165	            typedef npy_float64 dtype_V491;
05166	            
05167	    PyObject* py_V493;
05168	    
05169	        PyArrayObject* V493;
05170	        
05171	            typedef npy_float64 dtype_V493;
05172	            
05173	    PyObject* py_V495;
05174	    
05175	        PyArrayObject* V495;
05176	        
05177	            typedef npy_float64 dtype_V495;
05178	            
05179	    PyObject* py_V497;
05180	    
05181	        PyArrayObject* V497;
05182	        
05183	            typedef npy_float64 dtype_V497;
05184	            
05185	    PyObject* py_V499;
05186	    
05187	        PyArrayObject* V499;
05188	        
05189	            typedef npy_float64 dtype_V499;
05190	            
05191	    PyObject* py_V501;
05192	    
05193	        PyArrayObject* V501;
05194	        
05195	            typedef npy_float64 dtype_V501;
05196	            
05197	    PyObject* py_V503;
05198	    
05199	        PyArrayObject* V503;
05200	        
05201	            typedef npy_float64 dtype_V503;
05202	            
05203	    PyObject* py_V505;
05204	    
05205	        PyArrayObject* V505;
05206	        
05207	            typedef npy_float64 dtype_V505;
05208	            
05209	    PyObject* py_V507;
05210	    
05211	        PyArrayObject* V507;
05212	        
05213	            typedef npy_float64 dtype_V507;
05214	            
05215	    PyObject* py_V509;
05216	    
05217	        PyArrayObject* V509;
05218	        
05219	            typedef npy_float64 dtype_V509;
05220	            
05221	    PyObject* py_V511;
05222	    
05223	        PyArrayObject* V511;
05224	        
05225	            typedef npy_float64 dtype_V511;
05226	            
05227	    PyObject* py_V513;
05228	    
05229	        PyArrayObject* V513;
05230	        
05231	            typedef npy_float64 dtype_V513;
05232	            
05233	    PyObject* py_V515;
05234	    
05235	        PyArrayObject* V515;
05236	        
05237	            typedef npy_float64 dtype_V515;
05238	            
05239	    PyObject* py_V517;
05240	    
05241	        PyArrayObject* V517;
05242	        
05243	            typedef npy_float64 dtype_V517;
05244	            
05245	    PyObject* py_V519;
05246	    
05247	        PyArrayObject* V519;
05248	        
05249	            typedef npy_float64 dtype_V519;
05250	            
05251	    PyObject* py_V521;
05252	    
05253	        PyArrayObject* V521;
05254	        
05255	            typedef npy_float64 dtype_V521;
05256	            
05257	    PyObject* py_V523;
05258	    
05259	        PyArrayObject* V523;
05260	        
05261	            typedef npy_float64 dtype_V523;
05262	            
05263	    PyObject* py_V525;
05264	    
05265	        PyArrayObject* V525;
05266	        
05267	            typedef npy_float64 dtype_V525;
05268	            
05269	    PyObject* py_V527;
05270	    
05271	        PyArrayObject* V527;
05272	        
05273	            typedef npy_float64 dtype_V527;
05274	            
05275	    PyObject* py_V529;
05276	    
05277	        PyArrayObject* V529;
05278	        
05279	            typedef npy_float64 dtype_V529;
05280	            
05281	    PyObject* py_V531;
05282	    
05283	        PyArrayObject* V531;
05284	        
05285	            typedef npy_float64 dtype_V531;
05286	            
05287	    PyObject* py_V533;
05288	    
05289	        PyArrayObject* V533;
05290	        
05291	            typedef npy_float64 dtype_V533;
05292	            
05293	    PyObject* py_V535;
05294	    
05295	        PyArrayObject* V535;
05296	        
05297	            typedef npy_float64 dtype_V535;
05298	            
05299	    PyObject* py_V537;
05300	    
05301	        PyArrayObject* V537;
05302	        
05303	            typedef npy_float64 dtype_V537;
05304	            
05305	    PyObject* py_V539;
05306	    
05307	        PyArrayObject* V539;
05308	        
05309	            typedef npy_float64 dtype_V539;
05310	            
05311	    PyObject* py_V541;
05312	    
05313	        PyArrayObject* V541;
05314	        
05315	            typedef npy_float64 dtype_V541;
05316	            
05317	    PyObject* py_V543;
05318	    
05319	        PyArrayObject* V543;
05320	        
05321	            typedef npy_float64 dtype_V543;
05322	            
05323	    PyObject* py_V545;
05324	    
05325	        PyArrayObject* V545;
05326	        
05327	            typedef npy_float64 dtype_V545;
05328	            
05329	    PyObject* py_V547;
05330	    
05331	        PyArrayObject* V547;
05332	        
05333	            typedef npy_float64 dtype_V547;
05334	            
05335	    PyObject* py_V549;
05336	    
05337	        PyArrayObject* V549;
05338	        
05339	            typedef npy_float64 dtype_V549;
05340	            
05341	    PyObject* py_V551;
05342	    
05343	        PyArrayObject* V551;
05344	        
05345	            typedef npy_float64 dtype_V551;
05346	            
05347	    PyObject* py_V553;
05348	    
05349	        PyArrayObject* V553;
05350	        
05351	            typedef npy_float64 dtype_V553;
05352	            
05353	    PyObject* py_V555;
05354	    
05355	        PyArrayObject* V555;
05356	        
05357	            typedef npy_float64 dtype_V555;
05358	            
05359	    PyObject* py_V557;
05360	    
05361	        PyArrayObject* V557;
05362	        
05363	            typedef npy_float64 dtype_V557;
05364	            
05365	    PyObject* py_V559;
05366	    
05367	        PyArrayObject* V559;
05368	        
05369	            typedef npy_float64 dtype_V559;
05370	            
05371	    PyObject* py_V561;
05372	    
05373	        PyArrayObject* V561;
05374	        
05375	            typedef npy_float64 dtype_V561;
05376	            
05377	    PyObject* py_V563;
05378	    
05379	        PyArrayObject* V563;
05380	        
05381	            typedef npy_float64 dtype_V563;
05382	            
05383	    PyObject* py_V565;
05384	    
05385	        PyArrayObject* V565;
05386	        
05387	            typedef npy_float64 dtype_V565;
05388	            
05389	    PyObject* py_V567;
05390	    
05391	        PyArrayObject* V567;
05392	        
05393	            typedef npy_float64 dtype_V567;
05394	            
05395	    PyObject* py_V569;
05396	    
05397	        PyArrayObject* V569;
05398	        
05399	            typedef npy_float64 dtype_V569;
05400	            
05401	    PyObject* py_V571;
05402	    
05403	        PyArrayObject* V571;
05404	        
05405	            typedef npy_float64 dtype_V571;
05406	            
05407	    PyObject* py_V573;
05408	    
05409	        PyArrayObject* V573;
05410	        
05411	            typedef npy_float64 dtype_V573;
05412	            
05413	    PyObject* py_V575;
05414	    
05415	        PyArrayObject* V575;
05416	        
05417	            typedef npy_float64 dtype_V575;
05418	            
05419	    PyObject* py_V577;
05420	    
05421	        PyArrayObject* V577;
05422	        
05423	            typedef npy_float64 dtype_V577;
05424	            
05425	    PyObject* py_V579;
05426	    
05427	        PyArrayObject* V579;
05428	        
05429	            typedef npy_float64 dtype_V579;
05430	            
05431	    PyObject* py_V581;
05432	    
05433	        PyArrayObject* V581;
05434	        
05435	            typedef npy_float64 dtype_V581;
05436	            
05437	    PyObject* py_V583;
05438	    
05439	        PyArrayObject* V583;
05440	        
05441	            typedef npy_float64 dtype_V583;
05442	            
05443	    PyObject* py_V585;
05444	    
05445	        PyArrayObject* V585;
05446	        
05447	            typedef npy_float64 dtype_V585;
05448	            
05449	    PyObject* py_V587;
05450	    
05451	        PyArrayObject* V587;
05452	        
05453	            typedef npy_float64 dtype_V587;
05454	            
05455	    PyObject* py_V589;
05456	    
05457	        PyArrayObject* V589;
05458	        
05459	            typedef npy_float64 dtype_V589;
05460	            
05461	    PyObject* py_V591;
05462	    
05463	        PyArrayObject* V591;
05464	        
05465	            typedef npy_float64 dtype_V591;
05466	            
05467	    PyObject* py_V593;
05468	    
05469	        PyArrayObject* V593;
05470	        
05471	            typedef npy_float64 dtype_V593;
05472	            
05473	    PyObject* py_V595;
05474	    
05475	        PyArrayObject* V595;
05476	        
05477	            typedef npy_float64 dtype_V595;
05478	            
05479	    PyObject* py_V597;
05480	    
05481	        PyArrayObject* V597;
05482	        
05483	            typedef npy_float64 dtype_V597;
05484	            
05485	    PyObject* py_V599;
05486	    
05487	        PyArrayObject* V599;
05488	        
05489	            typedef npy_float64 dtype_V599;
05490	            
05491	    PyObject* py_V601;
05492	    
05493	        PyArrayObject* V601;
05494	        
05495	            typedef npy_float64 dtype_V601;
05496	            
05497	    PyObject* py_V603;
05498	    
05499	        PyArrayObject* V603;
05500	        
05501	            typedef npy_float64 dtype_V603;
05502	            
05503	    PyObject* py_V605;
05504	    
05505	        PyArrayObject* V605;
05506	        
05507	            typedef npy_float64 dtype_V605;
05508	            
05509	    PyObject* py_V607;
05510	    
05511	        PyArrayObject* V607;
05512	        
05513	            typedef npy_float64 dtype_V607;
05514	            
05515	    PyObject* py_V609;
05516	    
05517	        PyArrayObject* V609;
05518	        
05519	            typedef npy_float64 dtype_V609;
05520	            
05521	    PyObject* py_V611;
05522	    
05523	        PyArrayObject* V611;
05524	        
05525	            typedef npy_float64 dtype_V611;
05526	            
05527	    PyObject* py_V613;
05528	    
05529	        PyArrayObject* V613;
05530	        
05531	            typedef npy_float64 dtype_V613;
05532	            
05533	    PyObject* py_V615;
05534	    
05535	        PyArrayObject* V615;
05536	        
05537	            typedef npy_float64 dtype_V615;
05538	            
05539	    PyObject* py_V617;
05540	    
05541	        PyArrayObject* V617;
05542	        
05543	            typedef npy_float64 dtype_V617;
05544	            
05545	    PyObject* py_V619;
05546	    
05547	        PyArrayObject* V619;
05548	        
05549	            typedef npy_float64 dtype_V619;
05550	            
05551	    PyObject* py_V621;
05552	    
05553	        PyArrayObject* V621;
05554	        
05555	            typedef npy_float64 dtype_V621;
05556	            
05557	    PyObject* py_V623;
05558	    
05559	        PyArrayObject* V623;
05560	        
05561	            typedef npy_float64 dtype_V623;
05562	            
05563	    PyObject* py_V625;
05564	    
05565	        PyArrayObject* V625;
05566	        
05567	            typedef npy_float64 dtype_V625;
05568	            
05569	    PyObject* py_V627;
05570	    
05571	        PyArrayObject* V627;
05572	        
05573	            typedef npy_float64 dtype_V627;
05574	            
05575	    PyObject* py_V629;
05576	    
05577	        PyArrayObject* V629;
05578	        
05579	            typedef npy_float64 dtype_V629;
05580	            
05581	    PyObject* py_V631;
05582	    
05583	        PyArrayObject* V631;
05584	        
05585	            typedef npy_float64 dtype_V631;
05586	            
05587	    PyObject* py_V633;
05588	    
05589	        PyArrayObject* V633;
05590	        
05591	            typedef npy_float64 dtype_V633;
05592	            
05593	    PyObject* py_V635;
05594	    
05595	        PyArrayObject* V635;
05596	        
05597	            typedef npy_float64 dtype_V635;
05598	            
05599	    PyObject* py_V637;
05600	    
05601	        PyArrayObject* V637;
05602	        
05603	            typedef npy_float64 dtype_V637;
05604	            
05605	    PyObject* py_V639;
05606	    
05607	        PyArrayObject* V639;
05608	        
05609	            typedef npy_float64 dtype_V639;
05610	            
05611	    PyObject* py_V641;
05612	    
05613	        PyArrayObject* V641;
05614	        
05615	            typedef npy_float64 dtype_V641;
05616	            
05617	    PyObject* py_V643;
05618	    
05619	        PyArrayObject* V643;
05620	        
05621	            typedef npy_float64 dtype_V643;
05622	            
05623	    PyObject* py_V645;
05624	    
05625	        PyArrayObject* V645;
05626	        
05627	            typedef npy_float64 dtype_V645;
05628	            
05629	    PyObject* py_V647;
05630	    
05631	        PyArrayObject* V647;
05632	        
05633	            typedef npy_float64 dtype_V647;
05634	            
05635	    PyObject* py_V649;
05636	    
05637	        PyArrayObject* V649;
05638	        
05639	            typedef npy_float64 dtype_V649;
05640	            
05641	    PyObject* py_V651;
05642	    
05643	        PyArrayObject* V651;
05644	        
05645	            typedef npy_float64 dtype_V651;
05646	            
05647	    PyObject* py_V653;
05648	    
05649	        PyArrayObject* V653;
05650	        
05651	            typedef npy_float64 dtype_V653;
05652	            
05653	    PyObject* py_V655;
05654	    
05655	        PyArrayObject* V655;
05656	        
05657	            typedef npy_float64 dtype_V655;
05658	            
05659	    PyObject* py_V657;
05660	    
05661	        PyArrayObject* V657;
05662	        
05663	            typedef npy_float64 dtype_V657;
05664	            
05665	    PyObject* py_V659;
05666	    
05667	        PyArrayObject* V659;
05668	        
05669	            typedef npy_float64 dtype_V659;
05670	            
05671	    PyObject* py_V661;
05672	    
05673	        PyArrayObject* V661;
05674	        
05675	            typedef npy_float64 dtype_V661;
05676	            
05677	    PyObject* py_V663;
05678	    
05679	        PyArrayObject* V663;
05680	        
05681	            typedef npy_float64 dtype_V663;
05682	            
05683	    PyObject* py_V665;
05684	    
05685	        PyArrayObject* V665;
05686	        
05687	            typedef npy_float64 dtype_V665;
05688	            
05689	    PyObject* py_V667;
05690	    
05691	        PyArrayObject* V667;
05692	        
05693	            typedef npy_float64 dtype_V667;
05694	            
05695	    PyObject* py_V669;
05696	    
05697	        PyArrayObject* V669;
05698	        
05699	            typedef npy_float64 dtype_V669;
05700	            
05701	    PyObject* py_V671;
05702	    
05703	        PyArrayObject* V671;
05704	        
05705	            typedef npy_float64 dtype_V671;
05706	            
05707	    PyObject* py_V673;
05708	    
05709	        PyArrayObject* V673;
05710	        
05711	            typedef npy_float64 dtype_V673;
05712	            
05713	    PyObject* py_V675;
05714	    
05715	        PyArrayObject* V675;
05716	        
05717	            typedef npy_float64 dtype_V675;
05718	            
05719	    PyObject* py_V677;
05720	    
05721	        PyArrayObject* V677;
05722	        
05723	            typedef npy_float64 dtype_V677;
05724	            
05725	    PyObject* py_V679;
05726	    
05727	        PyArrayObject* V679;
05728	        
05729	            typedef npy_float64 dtype_V679;
05730	            
05731	    PyObject* py_V681;
05732	    
05733	        PyArrayObject* V681;
05734	        
05735	            typedef npy_float64 dtype_V681;
05736	            
05737	    PyObject* py_V683;
05738	    
05739	        PyArrayObject* V683;
05740	        
05741	            typedef npy_float64 dtype_V683;
05742	            
05743	    PyObject* py_V685;
05744	    
05745	        PyArrayObject* V685;
05746	        
05747	            typedef npy_float64 dtype_V685;
05748	            
05749	    PyObject* py_V687;
05750	    
05751	        PyArrayObject* V687;
05752	        
05753	            typedef npy_float64 dtype_V687;
05754	            
05755	    PyObject* py_V689;
05756	    
05757	        PyArrayObject* V689;
05758	        
05759	            typedef npy_float64 dtype_V689;
05760	            
05761	    PyObject* py_V691;
05762	    
05763	        PyArrayObject* V691;
05764	        
05765	            typedef npy_float64 dtype_V691;
05766	            
05767	    PyObject* py_V693;
05768	    
05769	        PyArrayObject* V693;
05770	        
05771	            typedef npy_float64 dtype_V693;
05772	            
05773	    PyObject* py_V695;
05774	    
05775	        PyArrayObject* V695;
05776	        
05777	            typedef npy_float64 dtype_V695;
05778	            
05779	    PyObject* py_V697;
05780	    
05781	        PyArrayObject* V697;
05782	        
05783	            typedef npy_float64 dtype_V697;
05784	            
05785	    PyObject* py_V699;
05786	    
05787	        PyArrayObject* V699;
05788	        
05789	            typedef npy_float64 dtype_V699;
05790	            
05791	    PyObject* py_V701;
05792	    
05793	        PyArrayObject* V701;
05794	        
05795	            typedef npy_float64 dtype_V701;
05796	            
05797	    PyObject* py_V703;
05798	    
05799	        PyArrayObject* V703;
05800	        
05801	            typedef npy_float64 dtype_V703;
05802	            
05803	    PyObject* py_V705;
05804	    
05805	        PyArrayObject* V705;
05806	        
05807	            typedef npy_float64 dtype_V705;
05808	            
05809	    PyObject* py_V707;
05810	    
05811	        PyArrayObject* V707;
05812	        
05813	            typedef npy_float64 dtype_V707;
05814	            
05815	    PyObject* py_V709;
05816	    
05817	        PyArrayObject* V709;
05818	        
05819	            typedef npy_float64 dtype_V709;
05820	            
05821	    PyObject* py_V711;
05822	    
05823	        PyArrayObject* V711;
05824	        
05825	            typedef npy_float64 dtype_V711;
05826	            
05827	    PyObject* py_V713;
05828	    
05829	        PyArrayObject* V713;
05830	        
05831	            typedef npy_float64 dtype_V713;
05832	            
05833	    PyObject* py_V715;
05834	    
05835	        PyArrayObject* V715;
05836	        
05837	            typedef npy_float64 dtype_V715;
05838	            
05839	    PyObject* py_V717;
05840	    
05841	        PyArrayObject* V717;
05842	        
05843	            typedef npy_float64 dtype_V717;
05844	            
05845	    PyObject* py_V719;
05846	    
05847	        PyArrayObject* V719;
05848	        
05849	            typedef npy_float64 dtype_V719;
05850	            
05851	    PyObject* py_V721;
05852	    
05853	        PyArrayObject* V721;
05854	        
05855	            typedef npy_float64 dtype_V721;
05856	            
05857	    PyObject* py_V723;
05858	    
05859	        PyArrayObject* V723;
05860	        
05861	            typedef npy_float64 dtype_V723;
05862	            
05863	    PyObject* py_V725;
05864	    
05865	        PyArrayObject* V725;
05866	        
05867	            typedef npy_float64 dtype_V725;
05868	            
05869	    PyObject* py_V727;
05870	    
05871	        PyArrayObject* V727;
05872	        
05873	            typedef npy_float64 dtype_V727;
05874	            
05875	    PyObject* py_V729;
05876	    
05877	        PyArrayObject* V729;
05878	        
05879	            typedef npy_float64 dtype_V729;
05880	            
05881	    PyObject* py_V731;
05882	    
05883	        PyArrayObject* V731;
05884	        
05885	            typedef npy_float64 dtype_V731;
05886	            
05887	    PyObject* py_V733;
05888	    
05889	        PyArrayObject* V733;
05890	        
05891	            typedef npy_float64 dtype_V733;
05892	            
05893	    PyObject* py_V735;
05894	    
05895	        PyArrayObject* V735;
05896	        
05897	            typedef npy_float64 dtype_V735;
05898	            
05899	    PyObject* py_V737;
05900	    
05901	        PyArrayObject* V737;
05902	        
05903	            typedef npy_float64 dtype_V737;
05904	            
05905	    PyObject* py_V739;
05906	    
05907	        PyArrayObject* V739;
05908	        
05909	            typedef npy_float64 dtype_V739;
05910	            
05911	    PyObject* py_V741;
05912	    
05913	        PyArrayObject* V741;
05914	        
05915	            typedef npy_float64 dtype_V741;
05916	            
05917	    PyObject* py_V743;
05918	    
05919	        PyArrayObject* V743;
05920	        
05921	            typedef npy_float64 dtype_V743;
05922	            
05923	    PyObject* py_V745;
05924	    
05925	        PyArrayObject* V745;
05926	        
05927	            typedef npy_float64 dtype_V745;
05928	            
05929	    PyObject* py_V747;
05930	    
05931	        PyArrayObject* V747;
05932	        
05933	            typedef npy_float64 dtype_V747;
05934	            
05935	    PyObject* py_V749;
05936	    
05937	        PyArrayObject* V749;
05938	        
05939	            typedef npy_float64 dtype_V749;
05940	            
05941	    PyObject* py_V751;
05942	    
05943	        PyArrayObject* V751;
05944	        
05945	            typedef npy_float64 dtype_V751;
05946	            
05947	    PyObject* py_V753;
05948	    
05949	        PyArrayObject* V753;
05950	        
05951	            typedef npy_float64 dtype_V753;
05952	            
05953	    PyObject* py_V755;
05954	    
05955	        PyArrayObject* V755;
05956	        
05957	            typedef npy_float64 dtype_V755;
05958	            
05959	    PyObject* py_V757;
05960	    
05961	        PyArrayObject* V757;
05962	        
05963	            typedef npy_float64 dtype_V757;
05964	            
05965	    PyObject* py_V759;
05966	    
05967	        PyArrayObject* V759;
05968	        
05969	            typedef npy_float64 dtype_V759;
05970	            
05971	    PyObject* py_V761;
05972	    
05973	        PyArrayObject* V761;
05974	        
05975	            typedef npy_float64 dtype_V761;
05976	            
05977	    PyObject* py_V763;
05978	    
05979	        PyArrayObject* V763;
05980	        
05981	            typedef npy_float64 dtype_V763;
05982	            
05983	    PyObject* py_V765;
05984	    
05985	        PyArrayObject* V765;
05986	        
05987	            typedef npy_float64 dtype_V765;
05988	            
05989	    PyObject* py_V767;
05990	    
05991	        PyArrayObject* V767;
05992	        
05993	            typedef npy_float64 dtype_V767;
05994	            
05995	    PyObject* py_V769;
05996	    
05997	        PyArrayObject* V769;
05998	        
05999	            typedef npy_float64 dtype_V769;
06000	            
06001	    PyObject* py_V771;
06002	    
06003	        PyArrayObject* V771;
06004	        
06005	            typedef npy_float64 dtype_V771;
06006	            
06007	    PyObject* py_V773;
06008	    
06009	        PyArrayObject* V773;
06010	        
06011	            typedef npy_float64 dtype_V773;
06012	            
06013	    PyObject* py_V775;
06014	    
06015	        PyArrayObject* V775;
06016	        
06017	            typedef npy_float64 dtype_V775;
06018	            
06019	    PyObject* py_V777;
06020	    
06021	        PyArrayObject* V777;
06022	        
06023	            typedef npy_float64 dtype_V777;
06024	            
06025	    PyObject* py_V779;
06026	    
06027	        PyArrayObject* V779;
06028	        
06029	            typedef npy_float64 dtype_V779;
06030	            
06031	    PyObject* py_V781;
06032	    
06033	        PyArrayObject* V781;
06034	        
06035	            typedef npy_float64 dtype_V781;
06036	            
06037	    PyObject* py_V783;
06038	    
06039	        PyArrayObject* V783;
06040	        
06041	            typedef npy_float64 dtype_V783;
06042	            
06043	    PyObject* py_V785;
06044	    
06045	        PyArrayObject* V785;
06046	        
06047	            typedef npy_float64 dtype_V785;
06048	            
06049	    PyObject* py_V787;
06050	    
06051	        PyArrayObject* V787;
06052	        
06053	            typedef npy_float64 dtype_V787;
06054	            
06055	    PyObject* py_V789;
06056	    
06057	        PyArrayObject* V789;
06058	        
06059	            typedef npy_float64 dtype_V789;
06060	            
06061	    PyObject* py_V791;
06062	    
06063	        PyArrayObject* V791;
06064	        
06065	            typedef npy_float64 dtype_V791;
06066	            
06067	    PyObject* py_V793;
06068	    
06069	        PyArrayObject* V793;
06070	        
06071	            typedef npy_float64 dtype_V793;
06072	            
06073	    PyObject* py_V795;
06074	    
06075	        PyArrayObject* V795;
06076	        
06077	            typedef npy_float64 dtype_V795;
06078	            
06079	    PyObject* py_V797;
06080	    
06081	        PyArrayObject* V797;
06082	        
06083	            typedef npy_float64 dtype_V797;
06084	            
06085	    PyObject* py_V799;
06086	    
06087	        PyArrayObject* V799;
06088	        
06089	            typedef npy_float64 dtype_V799;
06090	            
06091	    PyObject* py_V801;
06092	    
06093	        PyArrayObject* V801;
06094	        
06095	            typedef npy_float64 dtype_V801;
06096	            
06097	    PyObject* py_V803;
06098	    
06099	        PyArrayObject* V803;
06100	        
06101	            typedef npy_float64 dtype_V803;
06102	            
06103	    PyObject* py_V805;
06104	    
06105	        PyArrayObject* V805;
06106	        
06107	            typedef npy_float64 dtype_V805;
06108	            
06109	    PyObject* py_V807;
06110	    
06111	        PyArrayObject* V807;
06112	        
06113	            typedef npy_float64 dtype_V807;
06114	            
06115	    PyObject* py_V809;
06116	    
06117	        PyArrayObject* V809;
06118	        
06119	            typedef npy_float64 dtype_V809;
06120	            
06121	    PyObject* py_V811;
06122	    
06123	        PyArrayObject* V811;
06124	        
06125	            typedef npy_float64 dtype_V811;
06126	            
06127	    PyObject* py_V813;
06128	    
06129	        PyArrayObject* V813;
06130	        
06131	            typedef npy_float64 dtype_V813;
06132	            
06133	    PyObject* py_V815;
06134	    
06135	        PyArrayObject* V815;
06136	        
06137	            typedef npy_float64 dtype_V815;
06138	            
06139	    PyObject* py_V817;
06140	    
06141	        PyArrayObject* V817;
06142	        
06143	            typedef npy_float64 dtype_V817;
06144	            
06145	    PyObject* py_V819;
06146	    
06147	        PyArrayObject* V819;
06148	        
06149	            typedef npy_float64 dtype_V819;
06150	            
06151	    PyObject* py_V821;
06152	    
06153	        PyArrayObject* V821;
06154	        
06155	            typedef npy_float64 dtype_V821;
06156	            
06157	    PyObject* py_V823;
06158	    
06159	        PyArrayObject* V823;
06160	        
06161	            typedef npy_float64 dtype_V823;
06162	            
06163	    PyObject* py_V825;
06164	    
06165	        PyArrayObject* V825;
06166	        
06167	            typedef npy_float64 dtype_V825;
06168	            
06169	    PyObject* py_V827;
06170	    
06171	        PyArrayObject* V827;
06172	        
06173	            typedef npy_float64 dtype_V827;
06174	            
06175	    PyObject* py_V829;
06176	    
06177	        PyArrayObject* V829;
06178	        
06179	            typedef npy_float64 dtype_V829;
06180	            
06181	    PyObject* py_V831;
06182	    
06183	        PyArrayObject* V831;
06184	        
06185	            typedef npy_float64 dtype_V831;
06186	            
06187	    PyObject* py_V833;
06188	    
06189	        PyArrayObject* V833;
06190	        
06191	            typedef npy_float64 dtype_V833;
06192	            
06193	    PyObject* py_V835;
06194	    
06195	        PyArrayObject* V835;
06196	        
06197	            typedef npy_float64 dtype_V835;
06198	            
06199	    PyObject* py_V837;
06200	    
06201	        PyArrayObject* V837;
06202	        
06203	            typedef npy_float64 dtype_V837;
06204	            
06205	    PyObject* py_V839;
06206	    
06207	        PyArrayObject* V839;
06208	        
06209	            typedef npy_float64 dtype_V839;
06210	            
06211	    PyObject* py_V841;
06212	    
06213	        PyArrayObject* V841;
06214	        
06215	            typedef npy_float64 dtype_V841;
06216	            
06217	    PyObject* py_V843;
06218	    
06219	        PyArrayObject* V843;
06220	        
06221	            typedef npy_float64 dtype_V843;
06222	            
06223	    PyObject* py_V845;
06224	    
06225	        PyArrayObject* V845;
06226	        
06227	            typedef npy_float64 dtype_V845;
06228	            
06229	    PyObject* py_V847;
06230	    
06231	        PyArrayObject* V847;
06232	        
06233	            typedef npy_float64 dtype_V847;
06234	            
06235	    PyObject* py_V849;
06236	    
06237	        PyArrayObject* V849;
06238	        
06239	            typedef npy_float64 dtype_V849;
06240	            
06241	    PyObject* py_V851;
06242	    
06243	        PyArrayObject* V851;
06244	        
06245	            typedef npy_float64 dtype_V851;
06246	            
06247	    PyObject* py_V853;
06248	    
06249	        PyArrayObject* V853;
06250	        
06251	            typedef npy_float64 dtype_V853;
06252	            
06253	    PyObject* py_V855;
06254	    
06255	        PyArrayObject* V855;
06256	        
06257	            typedef npy_float64 dtype_V855;
06258	            
06259	    PyObject* py_V857;
06260	    
06261	        PyArrayObject* V857;
06262	        
06263	            typedef npy_float64 dtype_V857;
06264	            
06265	    PyObject* py_V859;
06266	    
06267	        PyArrayObject* V859;
06268	        
06269	            typedef npy_float64 dtype_V859;
06270	            
06271	    PyObject* py_V861;
06272	    
06273	        PyArrayObject* V861;
06274	        
06275	            typedef npy_float64 dtype_V861;
06276	            
06277	    PyObject* py_V863;
06278	    
06279	        PyArrayObject* V863;
06280	        
06281	            typedef npy_float64 dtype_V863;
06282	            
06283	    PyObject* py_V865;
06284	    
06285	        PyArrayObject* V865;
06286	        
06287	            typedef npy_float64 dtype_V865;
06288	            
06289	    PyObject* py_V867;
06290	    
06291	        PyArrayObject* V867;
06292	        
06293	            typedef npy_float64 dtype_V867;
06294	            
06295	    PyObject* py_V869;
06296	    
06297	        PyArrayObject* V869;
06298	        
06299	            typedef npy_float64 dtype_V869;
06300	            
06301	    PyObject* py_V871;
06302	    
06303	        PyArrayObject* V871;
06304	        
06305	            typedef npy_float64 dtype_V871;
06306	            
06307	    PyObject* py_V873;
06308	    
06309	        PyArrayObject* V873;
06310	        
06311	            typedef npy_float64 dtype_V873;
06312	            
06313	    PyObject* py_V875;
06314	    
06315	        PyArrayObject* V875;
06316	        
06317	            typedef npy_float64 dtype_V875;
06318	            
06319	    PyObject* py_V877;
06320	    
06321	        PyArrayObject* V877;
06322	        
06323	            typedef npy_float64 dtype_V877;
06324	            
06325	    PyObject* py_V879;
06326	    
06327	        PyArrayObject* V879;
06328	        
06329	            typedef npy_float64 dtype_V879;
06330	            
06331	    PyObject* py_V881;
06332	    
06333	        PyArrayObject* V881;
06334	        
06335	            typedef npy_float64 dtype_V881;
06336	            
06337	    PyObject* py_V883;
06338	    
06339	        PyArrayObject* V883;
06340	        
06341	            typedef npy_float64 dtype_V883;
06342	            
06343	    PyObject* py_V885;
06344	    
06345	        PyArrayObject* V885;
06346	        
06347	            typedef npy_float64 dtype_V885;
06348	            
06349	    PyObject* py_V887;
06350	    
06351	        PyArrayObject* V887;
06352	        
06353	            typedef npy_float64 dtype_V887;
06354	            
06355	    PyObject* py_V889;
06356	    
06357	        PyArrayObject* V889;
06358	        
06359	            typedef npy_float64 dtype_V889;
06360	            
06361	    PyObject* py_V891;
06362	    
06363	        PyArrayObject* V891;
06364	        
06365	            typedef npy_float64 dtype_V891;
06366	            
06367	    PyObject* py_V893;
06368	    
06369	        PyArrayObject* V893;
06370	        
06371	            typedef npy_float64 dtype_V893;
06372	            
06373	    PyObject* py_V895;
06374	    
06375	        PyArrayObject* V895;
06376	        
06377	            typedef npy_float64 dtype_V895;
06378	            
06379	    PyObject* py_V897;
06380	    
06381	        PyArrayObject* V897;
06382	        
06383	            typedef npy_float64 dtype_V897;
06384	            
06385	    PyObject* py_V899;
06386	    
06387	        PyArrayObject* V899;
06388	        
06389	            typedef npy_float64 dtype_V899;
06390	            
06391	    PyObject* py_V901;
06392	    
06393	        PyArrayObject* V901;
06394	        
06395	            typedef npy_float64 dtype_V901;
06396	            
06397	    PyObject* py_V903;
06398	    
06399	        PyArrayObject* V903;
06400	        
06401	            typedef npy_float64 dtype_V903;
06402	            
06403	    PyObject* py_V905;
06404	    
06405	        PyArrayObject* V905;
06406	        
06407	            typedef npy_float64 dtype_V905;
06408	            
06409	    PyObject* py_V907;
06410	    
06411	        PyArrayObject* V907;
06412	        
06413	            typedef npy_float64 dtype_V907;
06414	            
06415	    PyObject* py_V909;
06416	    
06417	        PyArrayObject* V909;
06418	        
06419	            typedef npy_float64 dtype_V909;
06420	            
06421	{
06422	
06423	    py_V1 = Py_None;
06424	    {Py_XINCREF(py_V1);}
06425	    
06426	        V1 = NULL;
06427	        
06428	{
06429	
06430	    py_V3 = PyList_GET_ITEM(storage_V3, 0);
06431	    {Py_XINCREF(py_V3);}
06432	    
06433	            V3 = NULL;
06434	            if (py_V3 == Py_None) {
06435	                // We can either fail here or set V3 to NULL and rely on Ops
06436	                // using tensors to handle the NULL case, but if they fail to do so
06437	                // they'll end up with nasty segfaults, so this is public service.
06438	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
06439	                {
06440	        __failure = 4;
06441	        if (!PyErr_Occurred()) {
06442	            PyErr_SetString(PyExc_RuntimeError,
06443	                "Unexpected error in an Op's C code. "
06444	                "No Python exception was set.");
06445	            }
06446	        goto __label_4;}
06447	            }
06448	            if (!PyArray_Check(py_V3)) {
06449	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
06450	                {
06451	        __failure = 4;
06452	        if (!PyErr_Occurred()) {
06453	            PyErr_SetString(PyExc_RuntimeError,
06454	                "Unexpected error in an Op's C code. "
06455	                "No Python exception was set.");
06456	            }
06457	        goto __label_4;}
06458	            }
06459	            // We expect NPY_FLOAT64
06460	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V3)) {
06461	                PyArrayObject * tmp = (PyArrayObject*) py_V3;
06462	                PyErr_Format(PyExc_NotImplementedError,
06463	                             "expected an aligned array of type %ld "
06464	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
06465	                             " with %ld dimensions, with 3 last dims "
06466	                             "%ld, %ld, %ld"
06467	                             " and 3 last strides %ld %ld, %ld.",
06468	                             (long int) NPY_FLOAT64,
06469	                             (long int) PyArray_TYPE((PyArrayObject*) py_V3),
06470	                             (long int) PyArray_NDIM(tmp),
06471	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
06472	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
06473	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
06474	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
06475	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
06476	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
06477	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
06478	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
06479	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
06480	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
06481	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
06482	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
06483	            );
06484	                {
06485	        __failure = 4;
06486	        if (!PyErr_Occurred()) {
06487	            PyErr_SetString(PyExc_RuntimeError,
06488	                "Unexpected error in an Op's C code. "
06489	                "No Python exception was set.");
06490	            }
06491	        goto __label_4;}
06492	            }
06493	            // This is a TypeError to be consistent with DEBUG_MODE
06494	            // Note: DEBUG_MODE also tells the name of the container
06495	            if (PyArray_TYPE((PyArrayObject*) py_V3) != NPY_FLOAT64) {
06496	                PyErr_Format(PyExc_TypeError,
06497	                             "expected type_num %d (NPY_FLOAT64) got %d",
06498	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V3));
06499	                {
06500	        __failure = 4;
06501	        if (!PyErr_Occurred()) {
06502	            PyErr_SetString(PyExc_RuntimeError,
06503	                "Unexpected error in an Op's C code. "
06504	                "No Python exception was set.");
06505	            }
06506	        goto __label_4;}
06507	            }
06508	            
06509	        V3 = (PyArrayObject*)(py_V3);
06510	        Py_XINCREF(V3);
06511	        
06512	{
06513	
06514	    py_V5 = PyList_GET_ITEM(storage_V5, 0);
06515	    {Py_XINCREF(py_V5);}
06516	    
06517	            V5 = NULL;
06518	            if (py_V5 == Py_None) {
06519	                // We can either fail here or set V5 to NULL and rely on Ops
06520	                // using tensors to handle the NULL case, but if they fail to do so
06521	                // they'll end up with nasty segfaults, so this is public service.
06522	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
06523	                {
06524	        __failure = 6;
06525	        if (!PyErr_Occurred()) {
06526	            PyErr_SetString(PyExc_RuntimeError,
06527	                "Unexpected error in an Op's C code. "
06528	                "No Python exception was set.");
06529	            }
06530	        goto __label_6;}
06531	            }
06532	            if (!PyArray_Check(py_V5)) {
06533	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
06534	                {
06535	        __failure = 6;
06536	        if (!PyErr_Occurred()) {
06537	            PyErr_SetString(PyExc_RuntimeError,
06538	                "Unexpected error in an Op's C code. "
06539	                "No Python exception was set.");
06540	            }
06541	        goto __label_6;}
06542	            }
06543	            // We expect NPY_FLOAT64
06544	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V5)) {
06545	                PyArrayObject * tmp = (PyArrayObject*) py_V5;
06546	                PyErr_Format(PyExc_NotImplementedError,
06547	                             "expected an aligned array of type %ld "
06548	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
06549	                             " with %ld dimensions, with 3 last dims "
06550	                             "%ld, %ld, %ld"
06551	                             " and 3 last strides %ld %ld, %ld.",
06552	                             (long int) NPY_FLOAT64,
06553	                             (long int) PyArray_TYPE((PyArrayObject*) py_V5),
06554	                             (long int) PyArray_NDIM(tmp),
06555	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
06556	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
06557	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
06558	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
06559	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
06560	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
06561	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
06562	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
06563	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
06564	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
06565	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
06566	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
06567	            );
06568	                {
06569	        __failure = 6;
06570	        if (!PyErr_Occurred()) {
06571	            PyErr_SetString(PyExc_RuntimeError,
06572	                "Unexpected error in an Op's C code. "
06573	                "No Python exception was set.");
06574	            }
06575	        goto __label_6;}
06576	            }
06577	            // This is a TypeError to be consistent with DEBUG_MODE
06578	            // Note: DEBUG_MODE also tells the name of the container
06579	            if (PyArray_TYPE((PyArrayObject*) py_V5) != NPY_FLOAT64) {
06580	                PyErr_Format(PyExc_TypeError,
06581	                             "expected type_num %d (NPY_FLOAT64) got %d",
06582	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V5));
06583	                {
06584	        __failure = 6;
06585	        if (!PyErr_Occurred()) {
06586	            PyErr_SetString(PyExc_RuntimeError,
06587	                "Unexpected error in an Op's C code. "
06588	                "No Python exception was set.");
06589	            }
06590	        goto __label_6;}
06591	            }
06592	            
06593	        V5 = (PyArrayObject*)(py_V5);
06594	        Py_XINCREF(V5);
06595	        
06596	{
06597	
06598	    py_V7 = PyList_GET_ITEM(storage_V7, 0);
06599	    {Py_XINCREF(py_V7);}
06600	    
06601	            V7 = NULL;
06602	            if (py_V7 == Py_None) {
06603	                // We can either fail here or set V7 to NULL and rely on Ops
06604	                // using tensors to handle the NULL case, but if they fail to do so
06605	                // they'll end up with nasty segfaults, so this is public service.
06606	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
06607	                {
06608	        __failure = 8;
06609	        if (!PyErr_Occurred()) {
06610	            PyErr_SetString(PyExc_RuntimeError,
06611	                "Unexpected error in an Op's C code. "
06612	                "No Python exception was set.");
06613	            }
06614	        goto __label_8;}
06615	            }
06616	            if (!PyArray_Check(py_V7)) {
06617	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
06618	                {
06619	        __failure = 8;
06620	        if (!PyErr_Occurred()) {
06621	            PyErr_SetString(PyExc_RuntimeError,
06622	                "Unexpected error in an Op's C code. "
06623	                "No Python exception was set.");
06624	            }
06625	        goto __label_8;}
06626	            }
06627	            // We expect NPY_FLOAT64
06628	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V7)) {
06629	                PyArrayObject * tmp = (PyArrayObject*) py_V7;
06630	                PyErr_Format(PyExc_NotImplementedError,
06631	                             "expected an aligned array of type %ld "
06632	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
06633	                             " with %ld dimensions, with 3 last dims "
06634	                             "%ld, %ld, %ld"
06635	                             " and 3 last strides %ld %ld, %ld.",
06636	                             (long int) NPY_FLOAT64,
06637	                             (long int) PyArray_TYPE((PyArrayObject*) py_V7),
06638	                             (long int) PyArray_NDIM(tmp),
06639	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
06640	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
06641	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
06642	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
06643	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
06644	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
06645	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
06646	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
06647	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
06648	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
06649	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
06650	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
06651	            );
06652	                {
06653	        __failure = 8;
06654	        if (!PyErr_Occurred()) {
06655	            PyErr_SetString(PyExc_RuntimeError,
06656	                "Unexpected error in an Op's C code. "
06657	                "No Python exception was set.");
06658	            }
06659	        goto __label_8;}
06660	            }
06661	            // This is a TypeError to be consistent with DEBUG_MODE
06662	            // Note: DEBUG_MODE also tells the name of the container
06663	            if (PyArray_TYPE((PyArrayObject*) py_V7) != NPY_FLOAT64) {
06664	                PyErr_Format(PyExc_TypeError,
06665	                             "expected type_num %d (NPY_FLOAT64) got %d",
06666	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V7));
06667	                {
06668	        __failure = 8;
06669	        if (!PyErr_Occurred()) {
06670	            PyErr_SetString(PyExc_RuntimeError,
06671	                "Unexpected error in an Op's C code. "
06672	                "No Python exception was set.");
06673	            }
06674	        goto __label_8;}
06675	            }
06676	            
06677	        V7 = (PyArrayObject*)(py_V7);
06678	        Py_XINCREF(V7);
06679	        
06680	{
06681	
06682	    py_V9 = PyList_GET_ITEM(storage_V9, 0);
06683	    {Py_XINCREF(py_V9);}
06684	    
06685	            V9 = NULL;
06686	            if (py_V9 == Py_None) {
06687	                // We can either fail here or set V9 to NULL and rely on Ops
06688	                // using tensors to handle the NULL case, but if they fail to do so
06689	                // they'll end up with nasty segfaults, so this is public service.
06690	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
06691	                {
06692	        __failure = 10;
06693	        if (!PyErr_Occurred()) {
06694	            PyErr_SetString(PyExc_RuntimeError,
06695	                "Unexpected error in an Op's C code. "
06696	                "No Python exception was set.");
06697	            }
06698	        goto __label_10;}
06699	            }
06700	            if (!PyArray_Check(py_V9)) {
06701	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
06702	                {
06703	        __failure = 10;
06704	        if (!PyErr_Occurred()) {
06705	            PyErr_SetString(PyExc_RuntimeError,
06706	                "Unexpected error in an Op's C code. "
06707	                "No Python exception was set.");
06708	            }
06709	        goto __label_10;}
06710	            }
06711	            // We expect NPY_FLOAT64
06712	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V9)) {
06713	                PyArrayObject * tmp = (PyArrayObject*) py_V9;
06714	                PyErr_Format(PyExc_NotImplementedError,
06715	                             "expected an aligned array of type %ld "
06716	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
06717	                             " with %ld dimensions, with 3 last dims "
06718	                             "%ld, %ld, %ld"
06719	                             " and 3 last strides %ld %ld, %ld.",
06720	                             (long int) NPY_FLOAT64,
06721	                             (long int) PyArray_TYPE((PyArrayObject*) py_V9),
06722	                             (long int) PyArray_NDIM(tmp),
06723	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
06724	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
06725	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
06726	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
06727	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
06728	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
06729	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
06730	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
06731	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
06732	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
06733	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
06734	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
06735	            );
06736	                {
06737	        __failure = 10;
06738	        if (!PyErr_Occurred()) {
06739	            PyErr_SetString(PyExc_RuntimeError,
06740	                "Unexpected error in an Op's C code. "
06741	                "No Python exception was set.");
06742	            }
06743	        goto __label_10;}
06744	            }
06745	            // This is a TypeError to be consistent with DEBUG_MODE
06746	            // Note: DEBUG_MODE also tells the name of the container
06747	            if (PyArray_TYPE((PyArrayObject*) py_V9) != NPY_FLOAT64) {
06748	                PyErr_Format(PyExc_TypeError,
06749	                             "expected type_num %d (NPY_FLOAT64) got %d",
06750	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V9));
06751	                {
06752	        __failure = 10;
06753	        if (!PyErr_Occurred()) {
06754	            PyErr_SetString(PyExc_RuntimeError,
06755	                "Unexpected error in an Op's C code. "
06756	                "No Python exception was set.");
06757	            }
06758	        goto __label_10;}
06759	            }
06760	            
06761	        V9 = (PyArrayObject*)(py_V9);
06762	        Py_XINCREF(V9);
06763	        
06764	{
06765	
06766	    py_V11 = PyList_GET_ITEM(storage_V11, 0);
06767	    {Py_XINCREF(py_V11);}
06768	    
06769	            V11 = NULL;
06770	            if (py_V11 == Py_None) {
06771	                // We can either fail here or set V11 to NULL and rely on Ops
06772	                // using tensors to handle the NULL case, but if they fail to do so
06773	                // they'll end up with nasty segfaults, so this is public service.
06774	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
06775	                {
06776	        __failure = 12;
06777	        if (!PyErr_Occurred()) {
06778	            PyErr_SetString(PyExc_RuntimeError,
06779	                "Unexpected error in an Op's C code. "
06780	                "No Python exception was set.");
06781	            }
06782	        goto __label_12;}
06783	            }
06784	            if (!PyArray_Check(py_V11)) {
06785	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
06786	                {
06787	        __failure = 12;
06788	        if (!PyErr_Occurred()) {
06789	            PyErr_SetString(PyExc_RuntimeError,
06790	                "Unexpected error in an Op's C code. "
06791	                "No Python exception was set.");
06792	            }
06793	        goto __label_12;}
06794	            }
06795	            // We expect NPY_FLOAT64
06796	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V11)) {
06797	                PyArrayObject * tmp = (PyArrayObject*) py_V11;
06798	                PyErr_Format(PyExc_NotImplementedError,
06799	                             "expected an aligned array of type %ld "
06800	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
06801	                             " with %ld dimensions, with 3 last dims "
06802	                             "%ld, %ld, %ld"
06803	                             " and 3 last strides %ld %ld, %ld.",
06804	                             (long int) NPY_FLOAT64,
06805	                             (long int) PyArray_TYPE((PyArrayObject*) py_V11),
06806	                             (long int) PyArray_NDIM(tmp),
06807	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
06808	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
06809	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
06810	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
06811	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
06812	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
06813	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
06814	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
06815	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
06816	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
06817	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
06818	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
06819	            );
06820	                {
06821	        __failure = 12;
06822	        if (!PyErr_Occurred()) {
06823	            PyErr_SetString(PyExc_RuntimeError,
06824	                "Unexpected error in an Op's C code. "
06825	                "No Python exception was set.");
06826	            }
06827	        goto __label_12;}
06828	            }
06829	            // This is a TypeError to be consistent with DEBUG_MODE
06830	            // Note: DEBUG_MODE also tells the name of the container
06831	            if (PyArray_TYPE((PyArrayObject*) py_V11) != NPY_FLOAT64) {
06832	                PyErr_Format(PyExc_TypeError,
06833	                             "expected type_num %d (NPY_FLOAT64) got %d",
06834	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V11));
06835	                {
06836	        __failure = 12;
06837	        if (!PyErr_Occurred()) {
06838	            PyErr_SetString(PyExc_RuntimeError,
06839	                "Unexpected error in an Op's C code. "
06840	                "No Python exception was set.");
06841	            }
06842	        goto __label_12;}
06843	            }
06844	            
06845	        V11 = (PyArrayObject*)(py_V11);
06846	        Py_XINCREF(V11);
06847	        
06848	{
06849	
06850	    py_V13 = PyList_GET_ITEM(storage_V13, 0);
06851	    {Py_XINCREF(py_V13);}
06852	    
06853	            V13 = NULL;
06854	            if (py_V13 == Py_None) {
06855	                // We can either fail here or set V13 to NULL and rely on Ops
06856	                // using tensors to handle the NULL case, but if they fail to do so
06857	                // they'll end up with nasty segfaults, so this is public service.
06858	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
06859	                {
06860	        __failure = 14;
06861	        if (!PyErr_Occurred()) {
06862	            PyErr_SetString(PyExc_RuntimeError,
06863	                "Unexpected error in an Op's C code. "
06864	                "No Python exception was set.");
06865	            }
06866	        goto __label_14;}
06867	            }
06868	            if (!PyArray_Check(py_V13)) {
06869	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
06870	                {
06871	        __failure = 14;
06872	        if (!PyErr_Occurred()) {
06873	            PyErr_SetString(PyExc_RuntimeError,
06874	                "Unexpected error in an Op's C code. "
06875	                "No Python exception was set.");
06876	            }
06877	        goto __label_14;}
06878	            }
06879	            // We expect NPY_FLOAT64
06880	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V13)) {
06881	                PyArrayObject * tmp = (PyArrayObject*) py_V13;
06882	                PyErr_Format(PyExc_NotImplementedError,
06883	                             "expected an aligned array of type %ld "
06884	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
06885	                             " with %ld dimensions, with 3 last dims "
06886	                             "%ld, %ld, %ld"
06887	                             " and 3 last strides %ld %ld, %ld.",
06888	                             (long int) NPY_FLOAT64,
06889	                             (long int) PyArray_TYPE((PyArrayObject*) py_V13),
06890	                             (long int) PyArray_NDIM(tmp),
06891	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
06892	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
06893	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
06894	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
06895	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
06896	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
06897	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
06898	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
06899	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
06900	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
06901	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
06902	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
06903	            );
06904	                {
06905	        __failure = 14;
06906	        if (!PyErr_Occurred()) {
06907	            PyErr_SetString(PyExc_RuntimeError,
06908	                "Unexpected error in an Op's C code. "
06909	                "No Python exception was set.");
06910	            }
06911	        goto __label_14;}
06912	            }
06913	            // This is a TypeError to be consistent with DEBUG_MODE
06914	            // Note: DEBUG_MODE also tells the name of the container
06915	            if (PyArray_TYPE((PyArrayObject*) py_V13) != NPY_FLOAT64) {
06916	                PyErr_Format(PyExc_TypeError,
06917	                             "expected type_num %d (NPY_FLOAT64) got %d",
06918	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V13));
06919	                {
06920	        __failure = 14;
06921	        if (!PyErr_Occurred()) {
06922	            PyErr_SetString(PyExc_RuntimeError,
06923	                "Unexpected error in an Op's C code. "
06924	                "No Python exception was set.");
06925	            }
06926	        goto __label_14;}
06927	            }
06928	            
06929	        V13 = (PyArrayObject*)(py_V13);
06930	        Py_XINCREF(V13);
06931	        
06932	{
06933	
06934	    py_V15 = PyList_GET_ITEM(storage_V15, 0);
06935	    {Py_XINCREF(py_V15);}
06936	    
06937	            V15 = NULL;
06938	            if (py_V15 == Py_None) {
06939	                // We can either fail here or set V15 to NULL and rely on Ops
06940	                // using tensors to handle the NULL case, but if they fail to do so
06941	                // they'll end up with nasty segfaults, so this is public service.
06942	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
06943	                {
06944	        __failure = 16;
06945	        if (!PyErr_Occurred()) {
06946	            PyErr_SetString(PyExc_RuntimeError,
06947	                "Unexpected error in an Op's C code. "
06948	                "No Python exception was set.");
06949	            }
06950	        goto __label_16;}
06951	            }
06952	            if (!PyArray_Check(py_V15)) {
06953	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
06954	                {
06955	        __failure = 16;
06956	        if (!PyErr_Occurred()) {
06957	            PyErr_SetString(PyExc_RuntimeError,
06958	                "Unexpected error in an Op's C code. "
06959	                "No Python exception was set.");
06960	            }
06961	        goto __label_16;}
06962	            }
06963	            // We expect NPY_FLOAT64
06964	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V15)) {
06965	                PyArrayObject * tmp = (PyArrayObject*) py_V15;
06966	                PyErr_Format(PyExc_NotImplementedError,
06967	                             "expected an aligned array of type %ld "
06968	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
06969	                             " with %ld dimensions, with 3 last dims "
06970	                             "%ld, %ld, %ld"
06971	                             " and 3 last strides %ld %ld, %ld.",
06972	                             (long int) NPY_FLOAT64,
06973	                             (long int) PyArray_TYPE((PyArrayObject*) py_V15),
06974	                             (long int) PyArray_NDIM(tmp),
06975	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
06976	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
06977	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
06978	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
06979	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
06980	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
06981	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
06982	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
06983	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
06984	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
06985	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
06986	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
06987	            );
06988	                {
06989	        __failure = 16;
06990	        if (!PyErr_Occurred()) {
06991	            PyErr_SetString(PyExc_RuntimeError,
06992	                "Unexpected error in an Op's C code. "
06993	                "No Python exception was set.");
06994	            }
06995	        goto __label_16;}
06996	            }
06997	            // This is a TypeError to be consistent with DEBUG_MODE
06998	            // Note: DEBUG_MODE also tells the name of the container
06999	            if (PyArray_TYPE((PyArrayObject*) py_V15) != NPY_FLOAT64) {
07000	                PyErr_Format(PyExc_TypeError,
07001	                             "expected type_num %d (NPY_FLOAT64) got %d",
07002	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V15));
07003	                {
07004	        __failure = 16;
07005	        if (!PyErr_Occurred()) {
07006	            PyErr_SetString(PyExc_RuntimeError,
07007	                "Unexpected error in an Op's C code. "
07008	                "No Python exception was set.");
07009	            }
07010	        goto __label_16;}
07011	            }
07012	            
07013	        V15 = (PyArrayObject*)(py_V15);
07014	        Py_XINCREF(V15);
07015	        
07016	{
07017	
07018	    py_V17 = PyList_GET_ITEM(storage_V17, 0);
07019	    {Py_XINCREF(py_V17);}
07020	    
07021	            V17 = NULL;
07022	            if (py_V17 == Py_None) {
07023	                // We can either fail here or set V17 to NULL and rely on Ops
07024	                // using tensors to handle the NULL case, but if they fail to do so
07025	                // they'll end up with nasty segfaults, so this is public service.
07026	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
07027	                {
07028	        __failure = 18;
07029	        if (!PyErr_Occurred()) {
07030	            PyErr_SetString(PyExc_RuntimeError,
07031	                "Unexpected error in an Op's C code. "
07032	                "No Python exception was set.");
07033	            }
07034	        goto __label_18;}
07035	            }
07036	            if (!PyArray_Check(py_V17)) {
07037	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
07038	                {
07039	        __failure = 18;
07040	        if (!PyErr_Occurred()) {
07041	            PyErr_SetString(PyExc_RuntimeError,
07042	                "Unexpected error in an Op's C code. "
07043	                "No Python exception was set.");
07044	            }
07045	        goto __label_18;}
07046	            }
07047	            // We expect NPY_FLOAT64
07048	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V17)) {
07049	                PyArrayObject * tmp = (PyArrayObject*) py_V17;
07050	                PyErr_Format(PyExc_NotImplementedError,
07051	                             "expected an aligned array of type %ld "
07052	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
07053	                             " with %ld dimensions, with 3 last dims "
07054	                             "%ld, %ld, %ld"
07055	                             " and 3 last strides %ld %ld, %ld.",
07056	                             (long int) NPY_FLOAT64,
07057	                             (long int) PyArray_TYPE((PyArrayObject*) py_V17),
07058	                             (long int) PyArray_NDIM(tmp),
07059	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
07060	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
07061	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
07062	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
07063	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
07064	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
07065	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
07066	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
07067	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
07068	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
07069	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
07070	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
07071	            );
07072	                {
07073	        __failure = 18;
07074	        if (!PyErr_Occurred()) {
07075	            PyErr_SetString(PyExc_RuntimeError,
07076	                "Unexpected error in an Op's C code. "
07077	                "No Python exception was set.");
07078	            }
07079	        goto __label_18;}
07080	            }
07081	            // This is a TypeError to be consistent with DEBUG_MODE
07082	            // Note: DEBUG_MODE also tells the name of the container
07083	            if (PyArray_TYPE((PyArrayObject*) py_V17) != NPY_FLOAT64) {
07084	                PyErr_Format(PyExc_TypeError,
07085	                             "expected type_num %d (NPY_FLOAT64) got %d",
07086	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V17));
07087	                {
07088	        __failure = 18;
07089	        if (!PyErr_Occurred()) {
07090	            PyErr_SetString(PyExc_RuntimeError,
07091	                "Unexpected error in an Op's C code. "
07092	                "No Python exception was set.");
07093	            }
07094	        goto __label_18;}
07095	            }
07096	            
07097	        V17 = (PyArrayObject*)(py_V17);
07098	        Py_XINCREF(V17);
07099	        
07100	{
07101	
07102	    py_V19 = PyList_GET_ITEM(storage_V19, 0);
07103	    {Py_XINCREF(py_V19);}
07104	    
07105	            V19 = NULL;
07106	            if (py_V19 == Py_None) {
07107	                // We can either fail here or set V19 to NULL and rely on Ops
07108	                // using tensors to handle the NULL case, but if they fail to do so
07109	                // they'll end up with nasty segfaults, so this is public service.
07110	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
07111	                {
07112	        __failure = 20;
07113	        if (!PyErr_Occurred()) {
07114	            PyErr_SetString(PyExc_RuntimeError,
07115	                "Unexpected error in an Op's C code. "
07116	                "No Python exception was set.");
07117	            }
07118	        goto __label_20;}
07119	            }
07120	            if (!PyArray_Check(py_V19)) {
07121	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
07122	                {
07123	        __failure = 20;
07124	        if (!PyErr_Occurred()) {
07125	            PyErr_SetString(PyExc_RuntimeError,
07126	                "Unexpected error in an Op's C code. "
07127	                "No Python exception was set.");
07128	            }
07129	        goto __label_20;}
07130	            }
07131	            // We expect NPY_FLOAT64
07132	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V19)) {
07133	                PyArrayObject * tmp = (PyArrayObject*) py_V19;
07134	                PyErr_Format(PyExc_NotImplementedError,
07135	                             "expected an aligned array of type %ld "
07136	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
07137	                             " with %ld dimensions, with 3 last dims "
07138	                             "%ld, %ld, %ld"
07139	                             " and 3 last strides %ld %ld, %ld.",
07140	                             (long int) NPY_FLOAT64,
07141	                             (long int) PyArray_TYPE((PyArrayObject*) py_V19),
07142	                             (long int) PyArray_NDIM(tmp),
07143	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
07144	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
07145	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
07146	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
07147	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
07148	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
07149	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
07150	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
07151	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
07152	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
07153	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
07154	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
07155	            );
07156	                {
07157	        __failure = 20;
07158	        if (!PyErr_Occurred()) {
07159	            PyErr_SetString(PyExc_RuntimeError,
07160	                "Unexpected error in an Op's C code. "
07161	                "No Python exception was set.");
07162	            }
07163	        goto __label_20;}
07164	            }
07165	            // This is a TypeError to be consistent with DEBUG_MODE
07166	            // Note: DEBUG_MODE also tells the name of the container
07167	            if (PyArray_TYPE((PyArrayObject*) py_V19) != NPY_FLOAT64) {
07168	                PyErr_Format(PyExc_TypeError,
07169	                             "expected type_num %d (NPY_FLOAT64) got %d",
07170	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V19));
07171	                {
07172	        __failure = 20;
07173	        if (!PyErr_Occurred()) {
07174	            PyErr_SetString(PyExc_RuntimeError,
07175	                "Unexpected error in an Op's C code. "
07176	                "No Python exception was set.");
07177	            }
07178	        goto __label_20;}
07179	            }
07180	            
07181	        V19 = (PyArrayObject*)(py_V19);
07182	        Py_XINCREF(V19);
07183	        
07184	{
07185	
07186	    py_V21 = PyList_GET_ITEM(storage_V21, 0);
07187	    {Py_XINCREF(py_V21);}
07188	    
07189	            V21 = NULL;
07190	            if (py_V21 == Py_None) {
07191	                // We can either fail here or set V21 to NULL and rely on Ops
07192	                // using tensors to handle the NULL case, but if they fail to do so
07193	                // they'll end up with nasty segfaults, so this is public service.
07194	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
07195	                {
07196	        __failure = 22;
07197	        if (!PyErr_Occurred()) {
07198	            PyErr_SetString(PyExc_RuntimeError,
07199	                "Unexpected error in an Op's C code. "
07200	                "No Python exception was set.");
07201	            }
07202	        goto __label_22;}
07203	            }
07204	            if (!PyArray_Check(py_V21)) {
07205	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
07206	                {
07207	        __failure = 22;
07208	        if (!PyErr_Occurred()) {
07209	            PyErr_SetString(PyExc_RuntimeError,
07210	                "Unexpected error in an Op's C code. "
07211	                "No Python exception was set.");
07212	            }
07213	        goto __label_22;}
07214	            }
07215	            // We expect NPY_FLOAT64
07216	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V21)) {
07217	                PyArrayObject * tmp = (PyArrayObject*) py_V21;
07218	                PyErr_Format(PyExc_NotImplementedError,
07219	                             "expected an aligned array of type %ld "
07220	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
07221	                             " with %ld dimensions, with 3 last dims "
07222	                             "%ld, %ld, %ld"
07223	                             " and 3 last strides %ld %ld, %ld.",
07224	                             (long int) NPY_FLOAT64,
07225	                             (long int) PyArray_TYPE((PyArrayObject*) py_V21),
07226	                             (long int) PyArray_NDIM(tmp),
07227	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
07228	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
07229	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
07230	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
07231	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
07232	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
07233	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
07234	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
07235	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
07236	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
07237	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
07238	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
07239	            );
07240	                {
07241	        __failure = 22;
07242	        if (!PyErr_Occurred()) {
07243	            PyErr_SetString(PyExc_RuntimeError,
07244	                "Unexpected error in an Op's C code. "
07245	                "No Python exception was set.");
07246	            }
07247	        goto __label_22;}
07248	            }
07249	            // This is a TypeError to be consistent with DEBUG_MODE
07250	            // Note: DEBUG_MODE also tells the name of the container
07251	            if (PyArray_TYPE((PyArrayObject*) py_V21) != NPY_FLOAT64) {
07252	                PyErr_Format(PyExc_TypeError,
07253	                             "expected type_num %d (NPY_FLOAT64) got %d",
07254	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V21));
07255	                {
07256	        __failure = 22;
07257	        if (!PyErr_Occurred()) {
07258	            PyErr_SetString(PyExc_RuntimeError,
07259	                "Unexpected error in an Op's C code. "
07260	                "No Python exception was set.");
07261	            }
07262	        goto __label_22;}
07263	            }
07264	            
07265	        V21 = (PyArrayObject*)(py_V21);
07266	        Py_XINCREF(V21);
07267	        
07268	{
07269	
07270	    py_V23 = PyList_GET_ITEM(storage_V23, 0);
07271	    {Py_XINCREF(py_V23);}
07272	    
07273	            V23 = NULL;
07274	            if (py_V23 == Py_None) {
07275	                // We can either fail here or set V23 to NULL and rely on Ops
07276	                // using tensors to handle the NULL case, but if they fail to do so
07277	                // they'll end up with nasty segfaults, so this is public service.
07278	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
07279	                {
07280	        __failure = 24;
07281	        if (!PyErr_Occurred()) {
07282	            PyErr_SetString(PyExc_RuntimeError,
07283	                "Unexpected error in an Op's C code. "
07284	                "No Python exception was set.");
07285	            }
07286	        goto __label_24;}
07287	            }
07288	            if (!PyArray_Check(py_V23)) {
07289	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
07290	                {
07291	        __failure = 24;
07292	        if (!PyErr_Occurred()) {
07293	            PyErr_SetString(PyExc_RuntimeError,
07294	                "Unexpected error in an Op's C code. "
07295	                "No Python exception was set.");
07296	            }
07297	        goto __label_24;}
07298	            }
07299	            // We expect NPY_FLOAT64
07300	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V23)) {
07301	                PyArrayObject * tmp = (PyArrayObject*) py_V23;
07302	                PyErr_Format(PyExc_NotImplementedError,
07303	                             "expected an aligned array of type %ld "
07304	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
07305	                             " with %ld dimensions, with 3 last dims "
07306	                             "%ld, %ld, %ld"
07307	                             " and 3 last strides %ld %ld, %ld.",
07308	                             (long int) NPY_FLOAT64,
07309	                             (long int) PyArray_TYPE((PyArrayObject*) py_V23),
07310	                             (long int) PyArray_NDIM(tmp),
07311	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
07312	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
07313	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
07314	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
07315	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
07316	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
07317	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
07318	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
07319	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
07320	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
07321	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
07322	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
07323	            );
07324	                {
07325	        __failure = 24;
07326	        if (!PyErr_Occurred()) {
07327	            PyErr_SetString(PyExc_RuntimeError,
07328	                "Unexpected error in an Op's C code. "
07329	                "No Python exception was set.");
07330	            }
07331	        goto __label_24;}
07332	            }
07333	            // This is a TypeError to be consistent with DEBUG_MODE
07334	            // Note: DEBUG_MODE also tells the name of the container
07335	            if (PyArray_TYPE((PyArrayObject*) py_V23) != NPY_FLOAT64) {
07336	                PyErr_Format(PyExc_TypeError,
07337	                             "expected type_num %d (NPY_FLOAT64) got %d",
07338	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V23));
07339	                {
07340	        __failure = 24;
07341	        if (!PyErr_Occurred()) {
07342	            PyErr_SetString(PyExc_RuntimeError,
07343	                "Unexpected error in an Op's C code. "
07344	                "No Python exception was set.");
07345	            }
07346	        goto __label_24;}
07347	            }
07348	            
07349	        V23 = (PyArrayObject*)(py_V23);
07350	        Py_XINCREF(V23);
07351	        
07352	{
07353	
07354	    py_V25 = PyList_GET_ITEM(storage_V25, 0);
07355	    {Py_XINCREF(py_V25);}
07356	    
07357	            V25 = NULL;
07358	            if (py_V25 == Py_None) {
07359	                // We can either fail here or set V25 to NULL and rely on Ops
07360	                // using tensors to handle the NULL case, but if they fail to do so
07361	                // they'll end up with nasty segfaults, so this is public service.
07362	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
07363	                {
07364	        __failure = 26;
07365	        if (!PyErr_Occurred()) {
07366	            PyErr_SetString(PyExc_RuntimeError,
07367	                "Unexpected error in an Op's C code. "
07368	                "No Python exception was set.");
07369	            }
07370	        goto __label_26;}
07371	            }
07372	            if (!PyArray_Check(py_V25)) {
07373	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
07374	                {
07375	        __failure = 26;
07376	        if (!PyErr_Occurred()) {
07377	            PyErr_SetString(PyExc_RuntimeError,
07378	                "Unexpected error in an Op's C code. "
07379	                "No Python exception was set.");
07380	            }
07381	        goto __label_26;}
07382	            }
07383	            // We expect NPY_FLOAT64
07384	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V25)) {
07385	                PyArrayObject * tmp = (PyArrayObject*) py_V25;
07386	                PyErr_Format(PyExc_NotImplementedError,
07387	                             "expected an aligned array of type %ld "
07388	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
07389	                             " with %ld dimensions, with 3 last dims "
07390	                             "%ld, %ld, %ld"
07391	                             " and 3 last strides %ld %ld, %ld.",
07392	                             (long int) NPY_FLOAT64,
07393	                             (long int) PyArray_TYPE((PyArrayObject*) py_V25),
07394	                             (long int) PyArray_NDIM(tmp),
07395	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
07396	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
07397	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
07398	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
07399	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
07400	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
07401	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
07402	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
07403	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
07404	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
07405	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
07406	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
07407	            );
07408	                {
07409	        __failure = 26;
07410	        if (!PyErr_Occurred()) {
07411	            PyErr_SetString(PyExc_RuntimeError,
07412	                "Unexpected error in an Op's C code. "
07413	                "No Python exception was set.");
07414	            }
07415	        goto __label_26;}
07416	            }
07417	            // This is a TypeError to be consistent with DEBUG_MODE
07418	            // Note: DEBUG_MODE also tells the name of the container
07419	            if (PyArray_TYPE((PyArrayObject*) py_V25) != NPY_FLOAT64) {
07420	                PyErr_Format(PyExc_TypeError,
07421	                             "expected type_num %d (NPY_FLOAT64) got %d",
07422	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V25));
07423	                {
07424	        __failure = 26;
07425	        if (!PyErr_Occurred()) {
07426	            PyErr_SetString(PyExc_RuntimeError,
07427	                "Unexpected error in an Op's C code. "
07428	                "No Python exception was set.");
07429	            }
07430	        goto __label_26;}
07431	            }
07432	            
07433	        V25 = (PyArrayObject*)(py_V25);
07434	        Py_XINCREF(V25);
07435	        
07436	{
07437	
07438	    py_V27 = PyList_GET_ITEM(storage_V27, 0);
07439	    {Py_XINCREF(py_V27);}
07440	    
07441	            V27 = NULL;
07442	            if (py_V27 == Py_None) {
07443	                // We can either fail here or set V27 to NULL and rely on Ops
07444	                // using tensors to handle the NULL case, but if they fail to do so
07445	                // they'll end up with nasty segfaults, so this is public service.
07446	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
07447	                {
07448	        __failure = 28;
07449	        if (!PyErr_Occurred()) {
07450	            PyErr_SetString(PyExc_RuntimeError,
07451	                "Unexpected error in an Op's C code. "
07452	                "No Python exception was set.");
07453	            }
07454	        goto __label_28;}
07455	            }
07456	            if (!PyArray_Check(py_V27)) {
07457	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
07458	                {
07459	        __failure = 28;
07460	        if (!PyErr_Occurred()) {
07461	            PyErr_SetString(PyExc_RuntimeError,
07462	                "Unexpected error in an Op's C code. "
07463	                "No Python exception was set.");
07464	            }
07465	        goto __label_28;}
07466	            }
07467	            // We expect NPY_FLOAT64
07468	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V27)) {
07469	                PyArrayObject * tmp = (PyArrayObject*) py_V27;
07470	                PyErr_Format(PyExc_NotImplementedError,
07471	                             "expected an aligned array of type %ld "
07472	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
07473	                             " with %ld dimensions, with 3 last dims "
07474	                             "%ld, %ld, %ld"
07475	                             " and 3 last strides %ld %ld, %ld.",
07476	                             (long int) NPY_FLOAT64,
07477	                             (long int) PyArray_TYPE((PyArrayObject*) py_V27),
07478	                             (long int) PyArray_NDIM(tmp),
07479	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
07480	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
07481	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
07482	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
07483	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
07484	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
07485	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
07486	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
07487	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
07488	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
07489	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
07490	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
07491	            );
07492	                {
07493	        __failure = 28;
07494	        if (!PyErr_Occurred()) {
07495	            PyErr_SetString(PyExc_RuntimeError,
07496	                "Unexpected error in an Op's C code. "
07497	                "No Python exception was set.");
07498	            }
07499	        goto __label_28;}
07500	            }
07501	            // This is a TypeError to be consistent with DEBUG_MODE
07502	            // Note: DEBUG_MODE also tells the name of the container
07503	            if (PyArray_TYPE((PyArrayObject*) py_V27) != NPY_FLOAT64) {
07504	                PyErr_Format(PyExc_TypeError,
07505	                             "expected type_num %d (NPY_FLOAT64) got %d",
07506	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V27));
07507	                {
07508	        __failure = 28;
07509	        if (!PyErr_Occurred()) {
07510	            PyErr_SetString(PyExc_RuntimeError,
07511	                "Unexpected error in an Op's C code. "
07512	                "No Python exception was set.");
07513	            }
07514	        goto __label_28;}
07515	            }
07516	            
07517	        V27 = (PyArrayObject*)(py_V27);
07518	        Py_XINCREF(V27);
07519	        
07520	{
07521	
07522	    py_V29 = PyList_GET_ITEM(storage_V29, 0);
07523	    {Py_XINCREF(py_V29);}
07524	    
07525	            V29 = NULL;
07526	            if (py_V29 == Py_None) {
07527	                // We can either fail here or set V29 to NULL and rely on Ops
07528	                // using tensors to handle the NULL case, but if they fail to do so
07529	                // they'll end up with nasty segfaults, so this is public service.
07530	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
07531	                {
07532	        __failure = 30;
07533	        if (!PyErr_Occurred()) {
07534	            PyErr_SetString(PyExc_RuntimeError,
07535	                "Unexpected error in an Op's C code. "
07536	                "No Python exception was set.");
07537	            }
07538	        goto __label_30;}
07539	            }
07540	            if (!PyArray_Check(py_V29)) {
07541	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
07542	                {
07543	        __failure = 30;
07544	        if (!PyErr_Occurred()) {
07545	            PyErr_SetString(PyExc_RuntimeError,
07546	                "Unexpected error in an Op's C code. "
07547	                "No Python exception was set.");
07548	            }
07549	        goto __label_30;}
07550	            }
07551	            // We expect NPY_FLOAT64
07552	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V29)) {
07553	                PyArrayObject * tmp = (PyArrayObject*) py_V29;
07554	                PyErr_Format(PyExc_NotImplementedError,
07555	                             "expected an aligned array of type %ld "
07556	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
07557	                             " with %ld dimensions, with 3 last dims "
07558	                             "%ld, %ld, %ld"
07559	                             " and 3 last strides %ld %ld, %ld.",
07560	                             (long int) NPY_FLOAT64,
07561	                             (long int) PyArray_TYPE((PyArrayObject*) py_V29),
07562	                             (long int) PyArray_NDIM(tmp),
07563	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
07564	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
07565	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
07566	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
07567	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
07568	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
07569	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
07570	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
07571	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
07572	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
07573	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
07574	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
07575	            );
07576	                {
07577	        __failure = 30;
07578	        if (!PyErr_Occurred()) {
07579	            PyErr_SetString(PyExc_RuntimeError,
07580	                "Unexpected error in an Op's C code. "
07581	                "No Python exception was set.");
07582	            }
07583	        goto __label_30;}
07584	            }
07585	            // This is a TypeError to be consistent with DEBUG_MODE
07586	            // Note: DEBUG_MODE also tells the name of the container
07587	            if (PyArray_TYPE((PyArrayObject*) py_V29) != NPY_FLOAT64) {
07588	                PyErr_Format(PyExc_TypeError,
07589	                             "expected type_num %d (NPY_FLOAT64) got %d",
07590	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V29));
07591	                {
07592	        __failure = 30;
07593	        if (!PyErr_Occurred()) {
07594	            PyErr_SetString(PyExc_RuntimeError,
07595	                "Unexpected error in an Op's C code. "
07596	                "No Python exception was set.");
07597	            }
07598	        goto __label_30;}
07599	            }
07600	            
07601	        V29 = (PyArrayObject*)(py_V29);
07602	        Py_XINCREF(V29);
07603	        
07604	{
07605	
07606	    py_V31 = PyList_GET_ITEM(storage_V31, 0);
07607	    {Py_XINCREF(py_V31);}
07608	    
07609	            V31 = NULL;
07610	            if (py_V31 == Py_None) {
07611	                // We can either fail here or set V31 to NULL and rely on Ops
07612	                // using tensors to handle the NULL case, but if they fail to do so
07613	                // they'll end up with nasty segfaults, so this is public service.
07614	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
07615	                {
07616	        __failure = 32;
07617	        if (!PyErr_Occurred()) {
07618	            PyErr_SetString(PyExc_RuntimeError,
07619	                "Unexpected error in an Op's C code. "
07620	                "No Python exception was set.");
07621	            }
07622	        goto __label_32;}
07623	            }
07624	            if (!PyArray_Check(py_V31)) {
07625	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
07626	                {
07627	        __failure = 32;
07628	        if (!PyErr_Occurred()) {
07629	            PyErr_SetString(PyExc_RuntimeError,
07630	                "Unexpected error in an Op's C code. "
07631	                "No Python exception was set.");
07632	            }
07633	        goto __label_32;}
07634	            }
07635	            // We expect NPY_FLOAT64
07636	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V31)) {
07637	                PyArrayObject * tmp = (PyArrayObject*) py_V31;
07638	                PyErr_Format(PyExc_NotImplementedError,
07639	                             "expected an aligned array of type %ld "
07640	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
07641	                             " with %ld dimensions, with 3 last dims "
07642	                             "%ld, %ld, %ld"
07643	                             " and 3 last strides %ld %ld, %ld.",
07644	                             (long int) NPY_FLOAT64,
07645	                             (long int) PyArray_TYPE((PyArrayObject*) py_V31),
07646	                             (long int) PyArray_NDIM(tmp),
07647	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
07648	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
07649	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
07650	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
07651	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
07652	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
07653	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
07654	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
07655	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
07656	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
07657	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
07658	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
07659	            );
07660	                {
07661	        __failure = 32;
07662	        if (!PyErr_Occurred()) {
07663	            PyErr_SetString(PyExc_RuntimeError,
07664	                "Unexpected error in an Op's C code. "
07665	                "No Python exception was set.");
07666	            }
07667	        goto __label_32;}
07668	            }
07669	            // This is a TypeError to be consistent with DEBUG_MODE
07670	            // Note: DEBUG_MODE also tells the name of the container
07671	            if (PyArray_TYPE((PyArrayObject*) py_V31) != NPY_FLOAT64) {
07672	                PyErr_Format(PyExc_TypeError,
07673	                             "expected type_num %d (NPY_FLOAT64) got %d",
07674	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V31));
07675	                {
07676	        __failure = 32;
07677	        if (!PyErr_Occurred()) {
07678	            PyErr_SetString(PyExc_RuntimeError,
07679	                "Unexpected error in an Op's C code. "
07680	                "No Python exception was set.");
07681	            }
07682	        goto __label_32;}
07683	            }
07684	            
07685	        V31 = (PyArrayObject*)(py_V31);
07686	        Py_XINCREF(V31);
07687	        
07688	{
07689	
07690	    py_V33 = PyList_GET_ITEM(storage_V33, 0);
07691	    {Py_XINCREF(py_V33);}
07692	    
07693	            V33 = NULL;
07694	            if (py_V33 == Py_None) {
07695	                // We can either fail here or set V33 to NULL and rely on Ops
07696	                // using tensors to handle the NULL case, but if they fail to do so
07697	                // they'll end up with nasty segfaults, so this is public service.
07698	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
07699	                {
07700	        __failure = 34;
07701	        if (!PyErr_Occurred()) {
07702	            PyErr_SetString(PyExc_RuntimeError,
07703	                "Unexpected error in an Op's C code. "
07704	                "No Python exception was set.");
07705	            }
07706	        goto __label_34;}
07707	            }
07708	            if (!PyArray_Check(py_V33)) {
07709	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
07710	                {
07711	        __failure = 34;
07712	        if (!PyErr_Occurred()) {
07713	            PyErr_SetString(PyExc_RuntimeError,
07714	                "Unexpected error in an Op's C code. "
07715	                "No Python exception was set.");
07716	            }
07717	        goto __label_34;}
07718	            }
07719	            // We expect NPY_FLOAT64
07720	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V33)) {
07721	                PyArrayObject * tmp = (PyArrayObject*) py_V33;
07722	                PyErr_Format(PyExc_NotImplementedError,
07723	                             "expected an aligned array of type %ld "
07724	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
07725	                             " with %ld dimensions, with 3 last dims "
07726	                             "%ld, %ld, %ld"
07727	                             " and 3 last strides %ld %ld, %ld.",
07728	                             (long int) NPY_FLOAT64,
07729	                             (long int) PyArray_TYPE((PyArrayObject*) py_V33),
07730	                             (long int) PyArray_NDIM(tmp),
07731	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
07732	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
07733	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
07734	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
07735	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
07736	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
07737	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
07738	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
07739	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
07740	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
07741	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
07742	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
07743	            );
07744	                {
07745	        __failure = 34;
07746	        if (!PyErr_Occurred()) {
07747	            PyErr_SetString(PyExc_RuntimeError,
07748	                "Unexpected error in an Op's C code. "
07749	                "No Python exception was set.");
07750	            }
07751	        goto __label_34;}
07752	            }
07753	            // This is a TypeError to be consistent with DEBUG_MODE
07754	            // Note: DEBUG_MODE also tells the name of the container
07755	            if (PyArray_TYPE((PyArrayObject*) py_V33) != NPY_FLOAT64) {
07756	                PyErr_Format(PyExc_TypeError,
07757	                             "expected type_num %d (NPY_FLOAT64) got %d",
07758	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V33));
07759	                {
07760	        __failure = 34;
07761	        if (!PyErr_Occurred()) {
07762	            PyErr_SetString(PyExc_RuntimeError,
07763	                "Unexpected error in an Op's C code. "
07764	                "No Python exception was set.");
07765	            }
07766	        goto __label_34;}
07767	            }
07768	            
07769	        V33 = (PyArrayObject*)(py_V33);
07770	        Py_XINCREF(V33);
07771	        
07772	{
07773	
07774	    py_V35 = PyList_GET_ITEM(storage_V35, 0);
07775	    {Py_XINCREF(py_V35);}
07776	    
07777	            V35 = NULL;
07778	            if (py_V35 == Py_None) {
07779	                // We can either fail here or set V35 to NULL and rely on Ops
07780	                // using tensors to handle the NULL case, but if they fail to do so
07781	                // they'll end up with nasty segfaults, so this is public service.
07782	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
07783	                {
07784	        __failure = 36;
07785	        if (!PyErr_Occurred()) {
07786	            PyErr_SetString(PyExc_RuntimeError,
07787	                "Unexpected error in an Op's C code. "
07788	                "No Python exception was set.");
07789	            }
07790	        goto __label_36;}
07791	            }
07792	            if (!PyArray_Check(py_V35)) {
07793	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
07794	                {
07795	        __failure = 36;
07796	        if (!PyErr_Occurred()) {
07797	            PyErr_SetString(PyExc_RuntimeError,
07798	                "Unexpected error in an Op's C code. "
07799	                "No Python exception was set.");
07800	            }
07801	        goto __label_36;}
07802	            }
07803	            // We expect NPY_FLOAT64
07804	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V35)) {
07805	                PyArrayObject * tmp = (PyArrayObject*) py_V35;
07806	                PyErr_Format(PyExc_NotImplementedError,
07807	                             "expected an aligned array of type %ld "
07808	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
07809	                             " with %ld dimensions, with 3 last dims "
07810	                             "%ld, %ld, %ld"
07811	                             " and 3 last strides %ld %ld, %ld.",
07812	                             (long int) NPY_FLOAT64,
07813	                             (long int) PyArray_TYPE((PyArrayObject*) py_V35),
07814	                             (long int) PyArray_NDIM(tmp),
07815	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
07816	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
07817	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
07818	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
07819	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
07820	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
07821	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
07822	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
07823	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
07824	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
07825	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
07826	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
07827	            );
07828	                {
07829	        __failure = 36;
07830	        if (!PyErr_Occurred()) {
07831	            PyErr_SetString(PyExc_RuntimeError,
07832	                "Unexpected error in an Op's C code. "
07833	                "No Python exception was set.");
07834	            }
07835	        goto __label_36;}
07836	            }
07837	            // This is a TypeError to be consistent with DEBUG_MODE
07838	            // Note: DEBUG_MODE also tells the name of the container
07839	            if (PyArray_TYPE((PyArrayObject*) py_V35) != NPY_FLOAT64) {
07840	                PyErr_Format(PyExc_TypeError,
07841	                             "expected type_num %d (NPY_FLOAT64) got %d",
07842	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V35));
07843	                {
07844	        __failure = 36;
07845	        if (!PyErr_Occurred()) {
07846	            PyErr_SetString(PyExc_RuntimeError,
07847	                "Unexpected error in an Op's C code. "
07848	                "No Python exception was set.");
07849	            }
07850	        goto __label_36;}
07851	            }
07852	            
07853	        V35 = (PyArrayObject*)(py_V35);
07854	        Py_XINCREF(V35);
07855	        
07856	{
07857	
07858	    py_V37 = PyList_GET_ITEM(storage_V37, 0);
07859	    {Py_XINCREF(py_V37);}
07860	    
07861	            V37 = NULL;
07862	            if (py_V37 == Py_None) {
07863	                // We can either fail here or set V37 to NULL and rely on Ops
07864	                // using tensors to handle the NULL case, but if they fail to do so
07865	                // they'll end up with nasty segfaults, so this is public service.
07866	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
07867	                {
07868	        __failure = 38;
07869	        if (!PyErr_Occurred()) {
07870	            PyErr_SetString(PyExc_RuntimeError,
07871	                "Unexpected error in an Op's C code. "
07872	                "No Python exception was set.");
07873	            }
07874	        goto __label_38;}
07875	            }
07876	            if (!PyArray_Check(py_V37)) {
07877	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
07878	                {
07879	        __failure = 38;
07880	        if (!PyErr_Occurred()) {
07881	            PyErr_SetString(PyExc_RuntimeError,
07882	                "Unexpected error in an Op's C code. "
07883	                "No Python exception was set.");
07884	            }
07885	        goto __label_38;}
07886	            }
07887	            // We expect NPY_FLOAT64
07888	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V37)) {
07889	                PyArrayObject * tmp = (PyArrayObject*) py_V37;
07890	                PyErr_Format(PyExc_NotImplementedError,
07891	                             "expected an aligned array of type %ld "
07892	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
07893	                             " with %ld dimensions, with 3 last dims "
07894	                             "%ld, %ld, %ld"
07895	                             " and 3 last strides %ld %ld, %ld.",
07896	                             (long int) NPY_FLOAT64,
07897	                             (long int) PyArray_TYPE((PyArrayObject*) py_V37),
07898	                             (long int) PyArray_NDIM(tmp),
07899	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
07900	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
07901	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
07902	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
07903	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
07904	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
07905	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
07906	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
07907	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
07908	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
07909	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
07910	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
07911	            );
07912	                {
07913	        __failure = 38;
07914	        if (!PyErr_Occurred()) {
07915	            PyErr_SetString(PyExc_RuntimeError,
07916	                "Unexpected error in an Op's C code. "
07917	                "No Python exception was set.");
07918	            }
07919	        goto __label_38;}
07920	            }
07921	            // This is a TypeError to be consistent with DEBUG_MODE
07922	            // Note: DEBUG_MODE also tells the name of the container
07923	            if (PyArray_TYPE((PyArrayObject*) py_V37) != NPY_FLOAT64) {
07924	                PyErr_Format(PyExc_TypeError,
07925	                             "expected type_num %d (NPY_FLOAT64) got %d",
07926	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V37));
07927	                {
07928	        __failure = 38;
07929	        if (!PyErr_Occurred()) {
07930	            PyErr_SetString(PyExc_RuntimeError,
07931	                "Unexpected error in an Op's C code. "
07932	                "No Python exception was set.");
07933	            }
07934	        goto __label_38;}
07935	            }
07936	            
07937	        V37 = (PyArrayObject*)(py_V37);
07938	        Py_XINCREF(V37);
07939	        
07940	{
07941	
07942	    py_V39 = PyList_GET_ITEM(storage_V39, 0);
07943	    {Py_XINCREF(py_V39);}
07944	    
07945	            V39 = NULL;
07946	            if (py_V39 == Py_None) {
07947	                // We can either fail here or set V39 to NULL and rely on Ops
07948	                // using tensors to handle the NULL case, but if they fail to do so
07949	                // they'll end up with nasty segfaults, so this is public service.
07950	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
07951	                {
07952	        __failure = 40;
07953	        if (!PyErr_Occurred()) {
07954	            PyErr_SetString(PyExc_RuntimeError,
07955	                "Unexpected error in an Op's C code. "
07956	                "No Python exception was set.");
07957	            }
07958	        goto __label_40;}
07959	            }
07960	            if (!PyArray_Check(py_V39)) {
07961	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
07962	                {
07963	        __failure = 40;
07964	        if (!PyErr_Occurred()) {
07965	            PyErr_SetString(PyExc_RuntimeError,
07966	                "Unexpected error in an Op's C code. "
07967	                "No Python exception was set.");
07968	            }
07969	        goto __label_40;}
07970	            }
07971	            // We expect NPY_FLOAT64
07972	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V39)) {
07973	                PyArrayObject * tmp = (PyArrayObject*) py_V39;
07974	                PyErr_Format(PyExc_NotImplementedError,
07975	                             "expected an aligned array of type %ld "
07976	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
07977	                             " with %ld dimensions, with 3 last dims "
07978	                             "%ld, %ld, %ld"
07979	                             " and 3 last strides %ld %ld, %ld.",
07980	                             (long int) NPY_FLOAT64,
07981	                             (long int) PyArray_TYPE((PyArrayObject*) py_V39),
07982	                             (long int) PyArray_NDIM(tmp),
07983	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
07984	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
07985	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
07986	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
07987	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
07988	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
07989	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
07990	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
07991	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
07992	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
07993	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
07994	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
07995	            );
07996	                {
07997	        __failure = 40;
07998	        if (!PyErr_Occurred()) {
07999	            PyErr_SetString(PyExc_RuntimeError,
08000	                "Unexpected error in an Op's C code. "
08001	                "No Python exception was set.");
08002	            }
08003	        goto __label_40;}
08004	            }
08005	            // This is a TypeError to be consistent with DEBUG_MODE
08006	            // Note: DEBUG_MODE also tells the name of the container
08007	            if (PyArray_TYPE((PyArrayObject*) py_V39) != NPY_FLOAT64) {
08008	                PyErr_Format(PyExc_TypeError,
08009	                             "expected type_num %d (NPY_FLOAT64) got %d",
08010	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V39));
08011	                {
08012	        __failure = 40;
08013	        if (!PyErr_Occurred()) {
08014	            PyErr_SetString(PyExc_RuntimeError,
08015	                "Unexpected error in an Op's C code. "
08016	                "No Python exception was set.");
08017	            }
08018	        goto __label_40;}
08019	            }
08020	            
08021	        V39 = (PyArrayObject*)(py_V39);
08022	        Py_XINCREF(V39);
08023	        
08024	{
08025	
08026	    py_V41 = PyList_GET_ITEM(storage_V41, 0);
08027	    {Py_XINCREF(py_V41);}
08028	    
08029	            V41 = NULL;
08030	            if (py_V41 == Py_None) {
08031	                // We can either fail here or set V41 to NULL and rely on Ops
08032	                // using tensors to handle the NULL case, but if they fail to do so
08033	                // they'll end up with nasty segfaults, so this is public service.
08034	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
08035	                {
08036	        __failure = 42;
08037	        if (!PyErr_Occurred()) {
08038	            PyErr_SetString(PyExc_RuntimeError,
08039	                "Unexpected error in an Op's C code. "
08040	                "No Python exception was set.");
08041	            }
08042	        goto __label_42;}
08043	            }
08044	            if (!PyArray_Check(py_V41)) {
08045	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
08046	                {
08047	        __failure = 42;
08048	        if (!PyErr_Occurred()) {
08049	            PyErr_SetString(PyExc_RuntimeError,
08050	                "Unexpected error in an Op's C code. "
08051	                "No Python exception was set.");
08052	            }
08053	        goto __label_42;}
08054	            }
08055	            // We expect NPY_FLOAT64
08056	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V41)) {
08057	                PyArrayObject * tmp = (PyArrayObject*) py_V41;
08058	                PyErr_Format(PyExc_NotImplementedError,
08059	                             "expected an aligned array of type %ld "
08060	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
08061	                             " with %ld dimensions, with 3 last dims "
08062	                             "%ld, %ld, %ld"
08063	                             " and 3 last strides %ld %ld, %ld.",
08064	                             (long int) NPY_FLOAT64,
08065	                             (long int) PyArray_TYPE((PyArrayObject*) py_V41),
08066	                             (long int) PyArray_NDIM(tmp),
08067	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
08068	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
08069	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
08070	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
08071	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
08072	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
08073	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
08074	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
08075	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
08076	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
08077	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
08078	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
08079	            );
08080	                {
08081	        __failure = 42;
08082	        if (!PyErr_Occurred()) {
08083	            PyErr_SetString(PyExc_RuntimeError,
08084	                "Unexpected error in an Op's C code. "
08085	                "No Python exception was set.");
08086	            }
08087	        goto __label_42;}
08088	            }
08089	            // This is a TypeError to be consistent with DEBUG_MODE
08090	            // Note: DEBUG_MODE also tells the name of the container
08091	            if (PyArray_TYPE((PyArrayObject*) py_V41) != NPY_FLOAT64) {
08092	                PyErr_Format(PyExc_TypeError,
08093	                             "expected type_num %d (NPY_FLOAT64) got %d",
08094	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V41));
08095	                {
08096	        __failure = 42;
08097	        if (!PyErr_Occurred()) {
08098	            PyErr_SetString(PyExc_RuntimeError,
08099	                "Unexpected error in an Op's C code. "
08100	                "No Python exception was set.");
08101	            }
08102	        goto __label_42;}
08103	            }
08104	            
08105	        V41 = (PyArrayObject*)(py_V41);
08106	        Py_XINCREF(V41);
08107	        
08108	{
08109	
08110	    py_V43 = PyList_GET_ITEM(storage_V43, 0);
08111	    {Py_XINCREF(py_V43);}
08112	    
08113	            V43 = NULL;
08114	            if (py_V43 == Py_None) {
08115	                // We can either fail here or set V43 to NULL and rely on Ops
08116	                // using tensors to handle the NULL case, but if they fail to do so
08117	                // they'll end up with nasty segfaults, so this is public service.
08118	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
08119	                {
08120	        __failure = 44;
08121	        if (!PyErr_Occurred()) {
08122	            PyErr_SetString(PyExc_RuntimeError,
08123	                "Unexpected error in an Op's C code. "
08124	                "No Python exception was set.");
08125	            }
08126	        goto __label_44;}
08127	            }
08128	            if (!PyArray_Check(py_V43)) {
08129	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
08130	                {
08131	        __failure = 44;
08132	        if (!PyErr_Occurred()) {
08133	            PyErr_SetString(PyExc_RuntimeError,
08134	                "Unexpected error in an Op's C code. "
08135	                "No Python exception was set.");
08136	            }
08137	        goto __label_44;}
08138	            }
08139	            // We expect NPY_FLOAT64
08140	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V43)) {
08141	                PyArrayObject * tmp = (PyArrayObject*) py_V43;
08142	                PyErr_Format(PyExc_NotImplementedError,
08143	                             "expected an aligned array of type %ld "
08144	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
08145	                             " with %ld dimensions, with 3 last dims "
08146	                             "%ld, %ld, %ld"
08147	                             " and 3 last strides %ld %ld, %ld.",
08148	                             (long int) NPY_FLOAT64,
08149	                             (long int) PyArray_TYPE((PyArrayObject*) py_V43),
08150	                             (long int) PyArray_NDIM(tmp),
08151	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
08152	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
08153	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
08154	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
08155	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
08156	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
08157	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
08158	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
08159	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
08160	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
08161	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
08162	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
08163	            );
08164	                {
08165	        __failure = 44;
08166	        if (!PyErr_Occurred()) {
08167	            PyErr_SetString(PyExc_RuntimeError,
08168	                "Unexpected error in an Op's C code. "
08169	                "No Python exception was set.");
08170	            }
08171	        goto __label_44;}
08172	            }
08173	            // This is a TypeError to be consistent with DEBUG_MODE
08174	            // Note: DEBUG_MODE also tells the name of the container
08175	            if (PyArray_TYPE((PyArrayObject*) py_V43) != NPY_FLOAT64) {
08176	                PyErr_Format(PyExc_TypeError,
08177	                             "expected type_num %d (NPY_FLOAT64) got %d",
08178	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V43));
08179	                {
08180	        __failure = 44;
08181	        if (!PyErr_Occurred()) {
08182	            PyErr_SetString(PyExc_RuntimeError,
08183	                "Unexpected error in an Op's C code. "
08184	                "No Python exception was set.");
08185	            }
08186	        goto __label_44;}
08187	            }
08188	            
08189	        V43 = (PyArrayObject*)(py_V43);
08190	        Py_XINCREF(V43);
08191	        
08192	{
08193	
08194	    py_V45 = PyList_GET_ITEM(storage_V45, 0);
08195	    {Py_XINCREF(py_V45);}
08196	    
08197	            V45 = NULL;
08198	            if (py_V45 == Py_None) {
08199	                // We can either fail here or set V45 to NULL and rely on Ops
08200	                // using tensors to handle the NULL case, but if they fail to do so
08201	                // they'll end up with nasty segfaults, so this is public service.
08202	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
08203	                {
08204	        __failure = 46;
08205	        if (!PyErr_Occurred()) {
08206	            PyErr_SetString(PyExc_RuntimeError,
08207	                "Unexpected error in an Op's C code. "
08208	                "No Python exception was set.");
08209	            }
08210	        goto __label_46;}
08211	            }
08212	            if (!PyArray_Check(py_V45)) {
08213	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
08214	                {
08215	        __failure = 46;
08216	        if (!PyErr_Occurred()) {
08217	            PyErr_SetString(PyExc_RuntimeError,
08218	                "Unexpected error in an Op's C code. "
08219	                "No Python exception was set.");
08220	            }
08221	        goto __label_46;}
08222	            }
08223	            // We expect NPY_FLOAT64
08224	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V45)) {
08225	                PyArrayObject * tmp = (PyArrayObject*) py_V45;
08226	                PyErr_Format(PyExc_NotImplementedError,
08227	                             "expected an aligned array of type %ld "
08228	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
08229	                             " with %ld dimensions, with 3 last dims "
08230	                             "%ld, %ld, %ld"
08231	                             " and 3 last strides %ld %ld, %ld.",
08232	                             (long int) NPY_FLOAT64,
08233	                             (long int) PyArray_TYPE((PyArrayObject*) py_V45),
08234	                             (long int) PyArray_NDIM(tmp),
08235	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
08236	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
08237	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
08238	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
08239	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
08240	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
08241	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
08242	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
08243	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
08244	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
08245	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
08246	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
08247	            );
08248	                {
08249	        __failure = 46;
08250	        if (!PyErr_Occurred()) {
08251	            PyErr_SetString(PyExc_RuntimeError,
08252	                "Unexpected error in an Op's C code. "
08253	                "No Python exception was set.");
08254	            }
08255	        goto __label_46;}
08256	            }
08257	            // This is a TypeError to be consistent with DEBUG_MODE
08258	            // Note: DEBUG_MODE also tells the name of the container
08259	            if (PyArray_TYPE((PyArrayObject*) py_V45) != NPY_FLOAT64) {
08260	                PyErr_Format(PyExc_TypeError,
08261	                             "expected type_num %d (NPY_FLOAT64) got %d",
08262	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V45));
08263	                {
08264	        __failure = 46;
08265	        if (!PyErr_Occurred()) {
08266	            PyErr_SetString(PyExc_RuntimeError,
08267	                "Unexpected error in an Op's C code. "
08268	                "No Python exception was set.");
08269	            }
08270	        goto __label_46;}
08271	            }
08272	            
08273	        V45 = (PyArrayObject*)(py_V45);
08274	        Py_XINCREF(V45);
08275	        
08276	{
08277	
08278	    py_V47 = PyList_GET_ITEM(storage_V47, 0);
08279	    {Py_XINCREF(py_V47);}
08280	    
08281	            V47 = NULL;
08282	            if (py_V47 == Py_None) {
08283	                // We can either fail here or set V47 to NULL and rely on Ops
08284	                // using tensors to handle the NULL case, but if they fail to do so
08285	                // they'll end up with nasty segfaults, so this is public service.
08286	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
08287	                {
08288	        __failure = 48;
08289	        if (!PyErr_Occurred()) {
08290	            PyErr_SetString(PyExc_RuntimeError,
08291	                "Unexpected error in an Op's C code. "
08292	                "No Python exception was set.");
08293	            }
08294	        goto __label_48;}
08295	            }
08296	            if (!PyArray_Check(py_V47)) {
08297	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
08298	                {
08299	        __failure = 48;
08300	        if (!PyErr_Occurred()) {
08301	            PyErr_SetString(PyExc_RuntimeError,
08302	                "Unexpected error in an Op's C code. "
08303	                "No Python exception was set.");
08304	            }
08305	        goto __label_48;}
08306	            }
08307	            // We expect NPY_FLOAT64
08308	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V47)) {
08309	                PyArrayObject * tmp = (PyArrayObject*) py_V47;
08310	                PyErr_Format(PyExc_NotImplementedError,
08311	                             "expected an aligned array of type %ld "
08312	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
08313	                             " with %ld dimensions, with 3 last dims "
08314	                             "%ld, %ld, %ld"
08315	                             " and 3 last strides %ld %ld, %ld.",
08316	                             (long int) NPY_FLOAT64,
08317	                             (long int) PyArray_TYPE((PyArrayObject*) py_V47),
08318	                             (long int) PyArray_NDIM(tmp),
08319	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
08320	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
08321	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
08322	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
08323	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
08324	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
08325	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
08326	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
08327	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
08328	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
08329	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
08330	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
08331	            );
08332	                {
08333	        __failure = 48;
08334	        if (!PyErr_Occurred()) {
08335	            PyErr_SetString(PyExc_RuntimeError,
08336	                "Unexpected error in an Op's C code. "
08337	                "No Python exception was set.");
08338	            }
08339	        goto __label_48;}
08340	            }
08341	            // This is a TypeError to be consistent with DEBUG_MODE
08342	            // Note: DEBUG_MODE also tells the name of the container
08343	            if (PyArray_TYPE((PyArrayObject*) py_V47) != NPY_FLOAT64) {
08344	                PyErr_Format(PyExc_TypeError,
08345	                             "expected type_num %d (NPY_FLOAT64) got %d",
08346	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V47));
08347	                {
08348	        __failure = 48;
08349	        if (!PyErr_Occurred()) {
08350	            PyErr_SetString(PyExc_RuntimeError,
08351	                "Unexpected error in an Op's C code. "
08352	                "No Python exception was set.");
08353	            }
08354	        goto __label_48;}
08355	            }
08356	            
08357	        V47 = (PyArrayObject*)(py_V47);
08358	        Py_XINCREF(V47);
08359	        
08360	{
08361	
08362	    py_V49 = PyList_GET_ITEM(storage_V49, 0);
08363	    {Py_XINCREF(py_V49);}
08364	    
08365	            V49 = NULL;
08366	            if (py_V49 == Py_None) {
08367	                // We can either fail here or set V49 to NULL and rely on Ops
08368	                // using tensors to handle the NULL case, but if they fail to do so
08369	                // they'll end up with nasty segfaults, so this is public service.
08370	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
08371	                {
08372	        __failure = 50;
08373	        if (!PyErr_Occurred()) {
08374	            PyErr_SetString(PyExc_RuntimeError,
08375	                "Unexpected error in an Op's C code. "
08376	                "No Python exception was set.");
08377	            }
08378	        goto __label_50;}
08379	            }
08380	            if (!PyArray_Check(py_V49)) {
08381	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
08382	                {
08383	        __failure = 50;
08384	        if (!PyErr_Occurred()) {
08385	            PyErr_SetString(PyExc_RuntimeError,
08386	                "Unexpected error in an Op's C code. "
08387	                "No Python exception was set.");
08388	            }
08389	        goto __label_50;}
08390	            }
08391	            // We expect NPY_FLOAT64
08392	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V49)) {
08393	                PyArrayObject * tmp = (PyArrayObject*) py_V49;
08394	                PyErr_Format(PyExc_NotImplementedError,
08395	                             "expected an aligned array of type %ld "
08396	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
08397	                             " with %ld dimensions, with 3 last dims "
08398	                             "%ld, %ld, %ld"
08399	                             " and 3 last strides %ld %ld, %ld.",
08400	                             (long int) NPY_FLOAT64,
08401	                             (long int) PyArray_TYPE((PyArrayObject*) py_V49),
08402	                             (long int) PyArray_NDIM(tmp),
08403	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
08404	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
08405	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
08406	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
08407	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
08408	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
08409	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
08410	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
08411	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
08412	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
08413	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
08414	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
08415	            );
08416	                {
08417	        __failure = 50;
08418	        if (!PyErr_Occurred()) {
08419	            PyErr_SetString(PyExc_RuntimeError,
08420	                "Unexpected error in an Op's C code. "
08421	                "No Python exception was set.");
08422	            }
08423	        goto __label_50;}
08424	            }
08425	            // This is a TypeError to be consistent with DEBUG_MODE
08426	            // Note: DEBUG_MODE also tells the name of the container
08427	            if (PyArray_TYPE((PyArrayObject*) py_V49) != NPY_FLOAT64) {
08428	                PyErr_Format(PyExc_TypeError,
08429	                             "expected type_num %d (NPY_FLOAT64) got %d",
08430	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V49));
08431	                {
08432	        __failure = 50;
08433	        if (!PyErr_Occurred()) {
08434	            PyErr_SetString(PyExc_RuntimeError,
08435	                "Unexpected error in an Op's C code. "
08436	                "No Python exception was set.");
08437	            }
08438	        goto __label_50;}
08439	            }
08440	            
08441	        V49 = (PyArrayObject*)(py_V49);
08442	        Py_XINCREF(V49);
08443	        
08444	{
08445	
08446	    py_V51 = PyList_GET_ITEM(storage_V51, 0);
08447	    {Py_XINCREF(py_V51);}
08448	    
08449	            V51 = NULL;
08450	            if (py_V51 == Py_None) {
08451	                // We can either fail here or set V51 to NULL and rely on Ops
08452	                // using tensors to handle the NULL case, but if they fail to do so
08453	                // they'll end up with nasty segfaults, so this is public service.
08454	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
08455	                {
08456	        __failure = 52;
08457	        if (!PyErr_Occurred()) {
08458	            PyErr_SetString(PyExc_RuntimeError,
08459	                "Unexpected error in an Op's C code. "
08460	                "No Python exception was set.");
08461	            }
08462	        goto __label_52;}
08463	            }
08464	            if (!PyArray_Check(py_V51)) {
08465	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
08466	                {
08467	        __failure = 52;
08468	        if (!PyErr_Occurred()) {
08469	            PyErr_SetString(PyExc_RuntimeError,
08470	                "Unexpected error in an Op's C code. "
08471	                "No Python exception was set.");
08472	            }
08473	        goto __label_52;}
08474	            }
08475	            // We expect NPY_FLOAT64
08476	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V51)) {
08477	                PyArrayObject * tmp = (PyArrayObject*) py_V51;
08478	                PyErr_Format(PyExc_NotImplementedError,
08479	                             "expected an aligned array of type %ld "
08480	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
08481	                             " with %ld dimensions, with 3 last dims "
08482	                             "%ld, %ld, %ld"
08483	                             " and 3 last strides %ld %ld, %ld.",
08484	                             (long int) NPY_FLOAT64,
08485	                             (long int) PyArray_TYPE((PyArrayObject*) py_V51),
08486	                             (long int) PyArray_NDIM(tmp),
08487	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
08488	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
08489	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
08490	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
08491	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
08492	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
08493	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
08494	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
08495	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
08496	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
08497	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
08498	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
08499	            );
08500	                {
08501	        __failure = 52;
08502	        if (!PyErr_Occurred()) {
08503	            PyErr_SetString(PyExc_RuntimeError,
08504	                "Unexpected error in an Op's C code. "
08505	                "No Python exception was set.");
08506	            }
08507	        goto __label_52;}
08508	            }
08509	            // This is a TypeError to be consistent with DEBUG_MODE
08510	            // Note: DEBUG_MODE also tells the name of the container
08511	            if (PyArray_TYPE((PyArrayObject*) py_V51) != NPY_FLOAT64) {
08512	                PyErr_Format(PyExc_TypeError,
08513	                             "expected type_num %d (NPY_FLOAT64) got %d",
08514	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V51));
08515	                {
08516	        __failure = 52;
08517	        if (!PyErr_Occurred()) {
08518	            PyErr_SetString(PyExc_RuntimeError,
08519	                "Unexpected error in an Op's C code. "
08520	                "No Python exception was set.");
08521	            }
08522	        goto __label_52;}
08523	            }
08524	            
08525	        V51 = (PyArrayObject*)(py_V51);
08526	        Py_XINCREF(V51);
08527	        
08528	{
08529	
08530	    py_V53 = PyList_GET_ITEM(storage_V53, 0);
08531	    {Py_XINCREF(py_V53);}
08532	    
08533	            V53 = NULL;
08534	            if (py_V53 == Py_None) {
08535	                // We can either fail here or set V53 to NULL and rely on Ops
08536	                // using tensors to handle the NULL case, but if they fail to do so
08537	                // they'll end up with nasty segfaults, so this is public service.
08538	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
08539	                {
08540	        __failure = 54;
08541	        if (!PyErr_Occurred()) {
08542	            PyErr_SetString(PyExc_RuntimeError,
08543	                "Unexpected error in an Op's C code. "
08544	                "No Python exception was set.");
08545	            }
08546	        goto __label_54;}
08547	            }
08548	            if (!PyArray_Check(py_V53)) {
08549	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
08550	                {
08551	        __failure = 54;
08552	        if (!PyErr_Occurred()) {
08553	            PyErr_SetString(PyExc_RuntimeError,
08554	                "Unexpected error in an Op's C code. "
08555	                "No Python exception was set.");
08556	            }
08557	        goto __label_54;}
08558	            }
08559	            // We expect NPY_FLOAT64
08560	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V53)) {
08561	                PyArrayObject * tmp = (PyArrayObject*) py_V53;
08562	                PyErr_Format(PyExc_NotImplementedError,
08563	                             "expected an aligned array of type %ld "
08564	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
08565	                             " with %ld dimensions, with 3 last dims "
08566	                             "%ld, %ld, %ld"
08567	                             " and 3 last strides %ld %ld, %ld.",
08568	                             (long int) NPY_FLOAT64,
08569	                             (long int) PyArray_TYPE((PyArrayObject*) py_V53),
08570	                             (long int) PyArray_NDIM(tmp),
08571	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
08572	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
08573	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
08574	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
08575	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
08576	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
08577	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
08578	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
08579	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
08580	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
08581	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
08582	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
08583	            );
08584	                {
08585	        __failure = 54;
08586	        if (!PyErr_Occurred()) {
08587	            PyErr_SetString(PyExc_RuntimeError,
08588	                "Unexpected error in an Op's C code. "
08589	                "No Python exception was set.");
08590	            }
08591	        goto __label_54;}
08592	            }
08593	            // This is a TypeError to be consistent with DEBUG_MODE
08594	            // Note: DEBUG_MODE also tells the name of the container
08595	            if (PyArray_TYPE((PyArrayObject*) py_V53) != NPY_FLOAT64) {
08596	                PyErr_Format(PyExc_TypeError,
08597	                             "expected type_num %d (NPY_FLOAT64) got %d",
08598	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V53));
08599	                {
08600	        __failure = 54;
08601	        if (!PyErr_Occurred()) {
08602	            PyErr_SetString(PyExc_RuntimeError,
08603	                "Unexpected error in an Op's C code. "
08604	                "No Python exception was set.");
08605	            }
08606	        goto __label_54;}
08607	            }
08608	            
08609	        V53 = (PyArrayObject*)(py_V53);
08610	        Py_XINCREF(V53);
08611	        
08612	{
08613	
08614	    py_V55 = PyList_GET_ITEM(storage_V55, 0);
08615	    {Py_XINCREF(py_V55);}
08616	    
08617	            V55 = NULL;
08618	            if (py_V55 == Py_None) {
08619	                // We can either fail here or set V55 to NULL and rely on Ops
08620	                // using tensors to handle the NULL case, but if they fail to do so
08621	                // they'll end up with nasty segfaults, so this is public service.
08622	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
08623	                {
08624	        __failure = 56;
08625	        if (!PyErr_Occurred()) {
08626	            PyErr_SetString(PyExc_RuntimeError,
08627	                "Unexpected error in an Op's C code. "
08628	                "No Python exception was set.");
08629	            }
08630	        goto __label_56;}
08631	            }
08632	            if (!PyArray_Check(py_V55)) {
08633	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
08634	                {
08635	        __failure = 56;
08636	        if (!PyErr_Occurred()) {
08637	            PyErr_SetString(PyExc_RuntimeError,
08638	                "Unexpected error in an Op's C code. "
08639	                "No Python exception was set.");
08640	            }
08641	        goto __label_56;}
08642	            }
08643	            // We expect NPY_FLOAT64
08644	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V55)) {
08645	                PyArrayObject * tmp = (PyArrayObject*) py_V55;
08646	                PyErr_Format(PyExc_NotImplementedError,
08647	                             "expected an aligned array of type %ld "
08648	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
08649	                             " with %ld dimensions, with 3 last dims "
08650	                             "%ld, %ld, %ld"
08651	                             " and 3 last strides %ld %ld, %ld.",
08652	                             (long int) NPY_FLOAT64,
08653	                             (long int) PyArray_TYPE((PyArrayObject*) py_V55),
08654	                             (long int) PyArray_NDIM(tmp),
08655	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
08656	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
08657	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
08658	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
08659	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
08660	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
08661	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
08662	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
08663	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
08664	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
08665	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
08666	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
08667	            );
08668	                {
08669	        __failure = 56;
08670	        if (!PyErr_Occurred()) {
08671	            PyErr_SetString(PyExc_RuntimeError,
08672	                "Unexpected error in an Op's C code. "
08673	                "No Python exception was set.");
08674	            }
08675	        goto __label_56;}
08676	            }
08677	            // This is a TypeError to be consistent with DEBUG_MODE
08678	            // Note: DEBUG_MODE also tells the name of the container
08679	            if (PyArray_TYPE((PyArrayObject*) py_V55) != NPY_FLOAT64) {
08680	                PyErr_Format(PyExc_TypeError,
08681	                             "expected type_num %d (NPY_FLOAT64) got %d",
08682	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V55));
08683	                {
08684	        __failure = 56;
08685	        if (!PyErr_Occurred()) {
08686	            PyErr_SetString(PyExc_RuntimeError,
08687	                "Unexpected error in an Op's C code. "
08688	                "No Python exception was set.");
08689	            }
08690	        goto __label_56;}
08691	            }
08692	            
08693	        V55 = (PyArrayObject*)(py_V55);
08694	        Py_XINCREF(V55);
08695	        
08696	{
08697	
08698	    py_V57 = PyList_GET_ITEM(storage_V57, 0);
08699	    {Py_XINCREF(py_V57);}
08700	    
08701	            V57 = NULL;
08702	            if (py_V57 == Py_None) {
08703	                // We can either fail here or set V57 to NULL and rely on Ops
08704	                // using tensors to handle the NULL case, but if they fail to do so
08705	                // they'll end up with nasty segfaults, so this is public service.
08706	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
08707	                {
08708	        __failure = 58;
08709	        if (!PyErr_Occurred()) {
08710	            PyErr_SetString(PyExc_RuntimeError,
08711	                "Unexpected error in an Op's C code. "
08712	                "No Python exception was set.");
08713	            }
08714	        goto __label_58;}
08715	            }
08716	            if (!PyArray_Check(py_V57)) {
08717	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
08718	                {
08719	        __failure = 58;
08720	        if (!PyErr_Occurred()) {
08721	            PyErr_SetString(PyExc_RuntimeError,
08722	                "Unexpected error in an Op's C code. "
08723	                "No Python exception was set.");
08724	            }
08725	        goto __label_58;}
08726	            }
08727	            // We expect NPY_FLOAT64
08728	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V57)) {
08729	                PyArrayObject * tmp = (PyArrayObject*) py_V57;
08730	                PyErr_Format(PyExc_NotImplementedError,
08731	                             "expected an aligned array of type %ld "
08732	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
08733	                             " with %ld dimensions, with 3 last dims "
08734	                             "%ld, %ld, %ld"
08735	                             " and 3 last strides %ld %ld, %ld.",
08736	                             (long int) NPY_FLOAT64,
08737	                             (long int) PyArray_TYPE((PyArrayObject*) py_V57),
08738	                             (long int) PyArray_NDIM(tmp),
08739	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
08740	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
08741	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
08742	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
08743	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
08744	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
08745	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
08746	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
08747	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
08748	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
08749	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
08750	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
08751	            );
08752	                {
08753	        __failure = 58;
08754	        if (!PyErr_Occurred()) {
08755	            PyErr_SetString(PyExc_RuntimeError,
08756	                "Unexpected error in an Op's C code. "
08757	                "No Python exception was set.");
08758	            }
08759	        goto __label_58;}
08760	            }
08761	            // This is a TypeError to be consistent with DEBUG_MODE
08762	            // Note: DEBUG_MODE also tells the name of the container
08763	            if (PyArray_TYPE((PyArrayObject*) py_V57) != NPY_FLOAT64) {
08764	                PyErr_Format(PyExc_TypeError,
08765	                             "expected type_num %d (NPY_FLOAT64) got %d",
08766	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V57));
08767	                {
08768	        __failure = 58;
08769	        if (!PyErr_Occurred()) {
08770	            PyErr_SetString(PyExc_RuntimeError,
08771	                "Unexpected error in an Op's C code. "
08772	                "No Python exception was set.");
08773	            }
08774	        goto __label_58;}
08775	            }
08776	            
08777	        V57 = (PyArrayObject*)(py_V57);
08778	        Py_XINCREF(V57);
08779	        
08780	{
08781	
08782	    py_V59 = PyList_GET_ITEM(storage_V59, 0);
08783	    {Py_XINCREF(py_V59);}
08784	    
08785	            V59 = NULL;
08786	            if (py_V59 == Py_None) {
08787	                // We can either fail here or set V59 to NULL and rely on Ops
08788	                // using tensors to handle the NULL case, but if they fail to do so
08789	                // they'll end up with nasty segfaults, so this is public service.
08790	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
08791	                {
08792	        __failure = 60;
08793	        if (!PyErr_Occurred()) {
08794	            PyErr_SetString(PyExc_RuntimeError,
08795	                "Unexpected error in an Op's C code. "
08796	                "No Python exception was set.");
08797	            }
08798	        goto __label_60;}
08799	            }
08800	            if (!PyArray_Check(py_V59)) {
08801	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
08802	                {
08803	        __failure = 60;
08804	        if (!PyErr_Occurred()) {
08805	            PyErr_SetString(PyExc_RuntimeError,
08806	                "Unexpected error in an Op's C code. "
08807	                "No Python exception was set.");
08808	            }
08809	        goto __label_60;}
08810	            }
08811	            // We expect NPY_FLOAT64
08812	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V59)) {
08813	                PyArrayObject * tmp = (PyArrayObject*) py_V59;
08814	                PyErr_Format(PyExc_NotImplementedError,
08815	                             "expected an aligned array of type %ld "
08816	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
08817	                             " with %ld dimensions, with 3 last dims "
08818	                             "%ld, %ld, %ld"
08819	                             " and 3 last strides %ld %ld, %ld.",
08820	                             (long int) NPY_FLOAT64,
08821	                             (long int) PyArray_TYPE((PyArrayObject*) py_V59),
08822	                             (long int) PyArray_NDIM(tmp),
08823	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
08824	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
08825	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
08826	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
08827	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
08828	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
08829	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
08830	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
08831	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
08832	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
08833	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
08834	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
08835	            );
08836	                {
08837	        __failure = 60;
08838	        if (!PyErr_Occurred()) {
08839	            PyErr_SetString(PyExc_RuntimeError,
08840	                "Unexpected error in an Op's C code. "
08841	                "No Python exception was set.");
08842	            }
08843	        goto __label_60;}
08844	            }
08845	            // This is a TypeError to be consistent with DEBUG_MODE
08846	            // Note: DEBUG_MODE also tells the name of the container
08847	            if (PyArray_TYPE((PyArrayObject*) py_V59) != NPY_FLOAT64) {
08848	                PyErr_Format(PyExc_TypeError,
08849	                             "expected type_num %d (NPY_FLOAT64) got %d",
08850	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V59));
08851	                {
08852	        __failure = 60;
08853	        if (!PyErr_Occurred()) {
08854	            PyErr_SetString(PyExc_RuntimeError,
08855	                "Unexpected error in an Op's C code. "
08856	                "No Python exception was set.");
08857	            }
08858	        goto __label_60;}
08859	            }
08860	            
08861	        V59 = (PyArrayObject*)(py_V59);
08862	        Py_XINCREF(V59);
08863	        
08864	{
08865	
08866	    py_V61 = PyList_GET_ITEM(storage_V61, 0);
08867	    {Py_XINCREF(py_V61);}
08868	    
08869	            V61 = NULL;
08870	            if (py_V61 == Py_None) {
08871	                // We can either fail here or set V61 to NULL and rely on Ops
08872	                // using tensors to handle the NULL case, but if they fail to do so
08873	                // they'll end up with nasty segfaults, so this is public service.
08874	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
08875	                {
08876	        __failure = 62;
08877	        if (!PyErr_Occurred()) {
08878	            PyErr_SetString(PyExc_RuntimeError,
08879	                "Unexpected error in an Op's C code. "
08880	                "No Python exception was set.");
08881	            }
08882	        goto __label_62;}
08883	            }
08884	            if (!PyArray_Check(py_V61)) {
08885	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
08886	                {
08887	        __failure = 62;
08888	        if (!PyErr_Occurred()) {
08889	            PyErr_SetString(PyExc_RuntimeError,
08890	                "Unexpected error in an Op's C code. "
08891	                "No Python exception was set.");
08892	            }
08893	        goto __label_62;}
08894	            }
08895	            // We expect NPY_FLOAT64
08896	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V61)) {
08897	                PyArrayObject * tmp = (PyArrayObject*) py_V61;
08898	                PyErr_Format(PyExc_NotImplementedError,
08899	                             "expected an aligned array of type %ld "
08900	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
08901	                             " with %ld dimensions, with 3 last dims "
08902	                             "%ld, %ld, %ld"
08903	                             " and 3 last strides %ld %ld, %ld.",
08904	                             (long int) NPY_FLOAT64,
08905	                             (long int) PyArray_TYPE((PyArrayObject*) py_V61),
08906	                             (long int) PyArray_NDIM(tmp),
08907	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
08908	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
08909	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
08910	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
08911	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
08912	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
08913	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
08914	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
08915	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
08916	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
08917	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
08918	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
08919	            );
08920	                {
08921	        __failure = 62;
08922	        if (!PyErr_Occurred()) {
08923	            PyErr_SetString(PyExc_RuntimeError,
08924	                "Unexpected error in an Op's C code. "
08925	                "No Python exception was set.");
08926	            }
08927	        goto __label_62;}
08928	            }
08929	            // This is a TypeError to be consistent with DEBUG_MODE
08930	            // Note: DEBUG_MODE also tells the name of the container
08931	            if (PyArray_TYPE((PyArrayObject*) py_V61) != NPY_FLOAT64) {
08932	                PyErr_Format(PyExc_TypeError,
08933	                             "expected type_num %d (NPY_FLOAT64) got %d",
08934	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V61));
08935	                {
08936	        __failure = 62;
08937	        if (!PyErr_Occurred()) {
08938	            PyErr_SetString(PyExc_RuntimeError,
08939	                "Unexpected error in an Op's C code. "
08940	                "No Python exception was set.");
08941	            }
08942	        goto __label_62;}
08943	            }
08944	            
08945	        V61 = (PyArrayObject*)(py_V61);
08946	        Py_XINCREF(V61);
08947	        
08948	{
08949	
08950	    py_V63 = PyList_GET_ITEM(storage_V63, 0);
08951	    {Py_XINCREF(py_V63);}
08952	    
08953	            V63 = NULL;
08954	            if (py_V63 == Py_None) {
08955	                // We can either fail here or set V63 to NULL and rely on Ops
08956	                // using tensors to handle the NULL case, but if they fail to do so
08957	                // they'll end up with nasty segfaults, so this is public service.
08958	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
08959	                {
08960	        __failure = 64;
08961	        if (!PyErr_Occurred()) {
08962	            PyErr_SetString(PyExc_RuntimeError,
08963	                "Unexpected error in an Op's C code. "
08964	                "No Python exception was set.");
08965	            }
08966	        goto __label_64;}
08967	            }
08968	            if (!PyArray_Check(py_V63)) {
08969	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
08970	                {
08971	        __failure = 64;
08972	        if (!PyErr_Occurred()) {
08973	            PyErr_SetString(PyExc_RuntimeError,
08974	                "Unexpected error in an Op's C code. "
08975	                "No Python exception was set.");
08976	            }
08977	        goto __label_64;}
08978	            }
08979	            // We expect NPY_FLOAT64
08980	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V63)) {
08981	                PyArrayObject * tmp = (PyArrayObject*) py_V63;
08982	                PyErr_Format(PyExc_NotImplementedError,
08983	                             "expected an aligned array of type %ld "
08984	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
08985	                             " with %ld dimensions, with 3 last dims "
08986	                             "%ld, %ld, %ld"
08987	                             " and 3 last strides %ld %ld, %ld.",
08988	                             (long int) NPY_FLOAT64,
08989	                             (long int) PyArray_TYPE((PyArrayObject*) py_V63),
08990	                             (long int) PyArray_NDIM(tmp),
08991	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
08992	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
08993	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
08994	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
08995	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
08996	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
08997	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
08998	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
08999	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
09000	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
09001	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
09002	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
09003	            );
09004	                {
09005	        __failure = 64;
09006	        if (!PyErr_Occurred()) {
09007	            PyErr_SetString(PyExc_RuntimeError,
09008	                "Unexpected error in an Op's C code. "
09009	                "No Python exception was set.");
09010	            }
09011	        goto __label_64;}
09012	            }
09013	            // This is a TypeError to be consistent with DEBUG_MODE
09014	            // Note: DEBUG_MODE also tells the name of the container
09015	            if (PyArray_TYPE((PyArrayObject*) py_V63) != NPY_FLOAT64) {
09016	                PyErr_Format(PyExc_TypeError,
09017	                             "expected type_num %d (NPY_FLOAT64) got %d",
09018	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V63));
09019	                {
09020	        __failure = 64;
09021	        if (!PyErr_Occurred()) {
09022	            PyErr_SetString(PyExc_RuntimeError,
09023	                "Unexpected error in an Op's C code. "
09024	                "No Python exception was set.");
09025	            }
09026	        goto __label_64;}
09027	            }
09028	            
09029	        V63 = (PyArrayObject*)(py_V63);
09030	        Py_XINCREF(V63);
09031	        
09032	{
09033	
09034	    py_V65 = PyList_GET_ITEM(storage_V65, 0);
09035	    {Py_XINCREF(py_V65);}
09036	    
09037	            V65 = NULL;
09038	            if (py_V65 == Py_None) {
09039	                // We can either fail here or set V65 to NULL and rely on Ops
09040	                // using tensors to handle the NULL case, but if they fail to do so
09041	                // they'll end up with nasty segfaults, so this is public service.
09042	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
09043	                {
09044	        __failure = 66;
09045	        if (!PyErr_Occurred()) {
09046	            PyErr_SetString(PyExc_RuntimeError,
09047	                "Unexpected error in an Op's C code. "
09048	                "No Python exception was set.");
09049	            }
09050	        goto __label_66;}
09051	            }
09052	            if (!PyArray_Check(py_V65)) {
09053	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
09054	                {
09055	        __failure = 66;
09056	        if (!PyErr_Occurred()) {
09057	            PyErr_SetString(PyExc_RuntimeError,
09058	                "Unexpected error in an Op's C code. "
09059	                "No Python exception was set.");
09060	            }
09061	        goto __label_66;}
09062	            }
09063	            // We expect NPY_FLOAT64
09064	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V65)) {
09065	                PyArrayObject * tmp = (PyArrayObject*) py_V65;
09066	                PyErr_Format(PyExc_NotImplementedError,
09067	                             "expected an aligned array of type %ld "
09068	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
09069	                             " with %ld dimensions, with 3 last dims "
09070	                             "%ld, %ld, %ld"
09071	                             " and 3 last strides %ld %ld, %ld.",
09072	                             (long int) NPY_FLOAT64,
09073	                             (long int) PyArray_TYPE((PyArrayObject*) py_V65),
09074	                             (long int) PyArray_NDIM(tmp),
09075	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
09076	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
09077	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
09078	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
09079	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
09080	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
09081	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
09082	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
09083	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
09084	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
09085	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
09086	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
09087	            );
09088	                {
09089	        __failure = 66;
09090	        if (!PyErr_Occurred()) {
09091	            PyErr_SetString(PyExc_RuntimeError,
09092	                "Unexpected error in an Op's C code. "
09093	                "No Python exception was set.");
09094	            }
09095	        goto __label_66;}
09096	            }
09097	            // This is a TypeError to be consistent with DEBUG_MODE
09098	            // Note: DEBUG_MODE also tells the name of the container
09099	            if (PyArray_TYPE((PyArrayObject*) py_V65) != NPY_FLOAT64) {
09100	                PyErr_Format(PyExc_TypeError,
09101	                             "expected type_num %d (NPY_FLOAT64) got %d",
09102	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V65));
09103	                {
09104	        __failure = 66;
09105	        if (!PyErr_Occurred()) {
09106	            PyErr_SetString(PyExc_RuntimeError,
09107	                "Unexpected error in an Op's C code. "
09108	                "No Python exception was set.");
09109	            }
09110	        goto __label_66;}
09111	            }
09112	            
09113	        V65 = (PyArrayObject*)(py_V65);
09114	        Py_XINCREF(V65);
09115	        
09116	{
09117	
09118	    py_V67 = PyList_GET_ITEM(storage_V67, 0);
09119	    {Py_XINCREF(py_V67);}
09120	    
09121	            V67 = NULL;
09122	            if (py_V67 == Py_None) {
09123	                // We can either fail here or set V67 to NULL and rely on Ops
09124	                // using tensors to handle the NULL case, but if they fail to do so
09125	                // they'll end up with nasty segfaults, so this is public service.
09126	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
09127	                {
09128	        __failure = 68;
09129	        if (!PyErr_Occurred()) {
09130	            PyErr_SetString(PyExc_RuntimeError,
09131	                "Unexpected error in an Op's C code. "
09132	                "No Python exception was set.");
09133	            }
09134	        goto __label_68;}
09135	            }
09136	            if (!PyArray_Check(py_V67)) {
09137	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
09138	                {
09139	        __failure = 68;
09140	        if (!PyErr_Occurred()) {
09141	            PyErr_SetString(PyExc_RuntimeError,
09142	                "Unexpected error in an Op's C code. "
09143	                "No Python exception was set.");
09144	            }
09145	        goto __label_68;}
09146	            }
09147	            // We expect NPY_FLOAT64
09148	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V67)) {
09149	                PyArrayObject * tmp = (PyArrayObject*) py_V67;
09150	                PyErr_Format(PyExc_NotImplementedError,
09151	                             "expected an aligned array of type %ld "
09152	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
09153	                             " with %ld dimensions, with 3 last dims "
09154	                             "%ld, %ld, %ld"
09155	                             " and 3 last strides %ld %ld, %ld.",
09156	                             (long int) NPY_FLOAT64,
09157	                             (long int) PyArray_TYPE((PyArrayObject*) py_V67),
09158	                             (long int) PyArray_NDIM(tmp),
09159	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
09160	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
09161	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
09162	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
09163	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
09164	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
09165	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
09166	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
09167	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
09168	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
09169	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
09170	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
09171	            );
09172	                {
09173	        __failure = 68;
09174	        if (!PyErr_Occurred()) {
09175	            PyErr_SetString(PyExc_RuntimeError,
09176	                "Unexpected error in an Op's C code. "
09177	                "No Python exception was set.");
09178	            }
09179	        goto __label_68;}
09180	            }
09181	            // This is a TypeError to be consistent with DEBUG_MODE
09182	            // Note: DEBUG_MODE also tells the name of the container
09183	            if (PyArray_TYPE((PyArrayObject*) py_V67) != NPY_FLOAT64) {
09184	                PyErr_Format(PyExc_TypeError,
09185	                             "expected type_num %d (NPY_FLOAT64) got %d",
09186	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V67));
09187	                {
09188	        __failure = 68;
09189	        if (!PyErr_Occurred()) {
09190	            PyErr_SetString(PyExc_RuntimeError,
09191	                "Unexpected error in an Op's C code. "
09192	                "No Python exception was set.");
09193	            }
09194	        goto __label_68;}
09195	            }
09196	            
09197	        V67 = (PyArrayObject*)(py_V67);
09198	        Py_XINCREF(V67);
09199	        
09200	{
09201	
09202	    py_V69 = PyList_GET_ITEM(storage_V69, 0);
09203	    {Py_XINCREF(py_V69);}
09204	    
09205	            V69 = NULL;
09206	            if (py_V69 == Py_None) {
09207	                // We can either fail here or set V69 to NULL and rely on Ops
09208	                // using tensors to handle the NULL case, but if they fail to do so
09209	                // they'll end up with nasty segfaults, so this is public service.
09210	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
09211	                {
09212	        __failure = 70;
09213	        if (!PyErr_Occurred()) {
09214	            PyErr_SetString(PyExc_RuntimeError,
09215	                "Unexpected error in an Op's C code. "
09216	                "No Python exception was set.");
09217	            }
09218	        goto __label_70;}
09219	            }
09220	            if (!PyArray_Check(py_V69)) {
09221	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
09222	                {
09223	        __failure = 70;
09224	        if (!PyErr_Occurred()) {
09225	            PyErr_SetString(PyExc_RuntimeError,
09226	                "Unexpected error in an Op's C code. "
09227	                "No Python exception was set.");
09228	            }
09229	        goto __label_70;}
09230	            }
09231	            // We expect NPY_FLOAT64
09232	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V69)) {
09233	                PyArrayObject * tmp = (PyArrayObject*) py_V69;
09234	                PyErr_Format(PyExc_NotImplementedError,
09235	                             "expected an aligned array of type %ld "
09236	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
09237	                             " with %ld dimensions, with 3 last dims "
09238	                             "%ld, %ld, %ld"
09239	                             " and 3 last strides %ld %ld, %ld.",
09240	                             (long int) NPY_FLOAT64,
09241	                             (long int) PyArray_TYPE((PyArrayObject*) py_V69),
09242	                             (long int) PyArray_NDIM(tmp),
09243	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
09244	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
09245	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
09246	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
09247	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
09248	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
09249	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
09250	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
09251	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
09252	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
09253	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
09254	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
09255	            );
09256	                {
09257	        __failure = 70;
09258	        if (!PyErr_Occurred()) {
09259	            PyErr_SetString(PyExc_RuntimeError,
09260	                "Unexpected error in an Op's C code. "
09261	                "No Python exception was set.");
09262	            }
09263	        goto __label_70;}
09264	            }
09265	            // This is a TypeError to be consistent with DEBUG_MODE
09266	            // Note: DEBUG_MODE also tells the name of the container
09267	            if (PyArray_TYPE((PyArrayObject*) py_V69) != NPY_FLOAT64) {
09268	                PyErr_Format(PyExc_TypeError,
09269	                             "expected type_num %d (NPY_FLOAT64) got %d",
09270	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V69));
09271	                {
09272	        __failure = 70;
09273	        if (!PyErr_Occurred()) {
09274	            PyErr_SetString(PyExc_RuntimeError,
09275	                "Unexpected error in an Op's C code. "
09276	                "No Python exception was set.");
09277	            }
09278	        goto __label_70;}
09279	            }
09280	            
09281	        V69 = (PyArrayObject*)(py_V69);
09282	        Py_XINCREF(V69);
09283	        
09284	{
09285	
09286	    py_V71 = PyList_GET_ITEM(storage_V71, 0);
09287	    {Py_XINCREF(py_V71);}
09288	    
09289	            V71 = NULL;
09290	            if (py_V71 == Py_None) {
09291	                // We can either fail here or set V71 to NULL and rely on Ops
09292	                // using tensors to handle the NULL case, but if they fail to do so
09293	                // they'll end up with nasty segfaults, so this is public service.
09294	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
09295	                {
09296	        __failure = 72;
09297	        if (!PyErr_Occurred()) {
09298	            PyErr_SetString(PyExc_RuntimeError,
09299	                "Unexpected error in an Op's C code. "
09300	                "No Python exception was set.");
09301	            }
09302	        goto __label_72;}
09303	            }
09304	            if (!PyArray_Check(py_V71)) {
09305	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
09306	                {
09307	        __failure = 72;
09308	        if (!PyErr_Occurred()) {
09309	            PyErr_SetString(PyExc_RuntimeError,
09310	                "Unexpected error in an Op's C code. "
09311	                "No Python exception was set.");
09312	            }
09313	        goto __label_72;}
09314	            }
09315	            // We expect NPY_FLOAT64
09316	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V71)) {
09317	                PyArrayObject * tmp = (PyArrayObject*) py_V71;
09318	                PyErr_Format(PyExc_NotImplementedError,
09319	                             "expected an aligned array of type %ld "
09320	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
09321	                             " with %ld dimensions, with 3 last dims "
09322	                             "%ld, %ld, %ld"
09323	                             " and 3 last strides %ld %ld, %ld.",
09324	                             (long int) NPY_FLOAT64,
09325	                             (long int) PyArray_TYPE((PyArrayObject*) py_V71),
09326	                             (long int) PyArray_NDIM(tmp),
09327	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
09328	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
09329	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
09330	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
09331	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
09332	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
09333	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
09334	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
09335	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
09336	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
09337	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
09338	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
09339	            );
09340	                {
09341	        __failure = 72;
09342	        if (!PyErr_Occurred()) {
09343	            PyErr_SetString(PyExc_RuntimeError,
09344	                "Unexpected error in an Op's C code. "
09345	                "No Python exception was set.");
09346	            }
09347	        goto __label_72;}
09348	            }
09349	            // This is a TypeError to be consistent with DEBUG_MODE
09350	            // Note: DEBUG_MODE also tells the name of the container
09351	            if (PyArray_TYPE((PyArrayObject*) py_V71) != NPY_FLOAT64) {
09352	                PyErr_Format(PyExc_TypeError,
09353	                             "expected type_num %d (NPY_FLOAT64) got %d",
09354	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V71));
09355	                {
09356	        __failure = 72;
09357	        if (!PyErr_Occurred()) {
09358	            PyErr_SetString(PyExc_RuntimeError,
09359	                "Unexpected error in an Op's C code. "
09360	                "No Python exception was set.");
09361	            }
09362	        goto __label_72;}
09363	            }
09364	            
09365	        V71 = (PyArrayObject*)(py_V71);
09366	        Py_XINCREF(V71);
09367	        
09368	{
09369	
09370	    py_V73 = PyList_GET_ITEM(storage_V73, 0);
09371	    {Py_XINCREF(py_V73);}
09372	    
09373	            V73 = NULL;
09374	            if (py_V73 == Py_None) {
09375	                // We can either fail here or set V73 to NULL and rely on Ops
09376	                // using tensors to handle the NULL case, but if they fail to do so
09377	                // they'll end up with nasty segfaults, so this is public service.
09378	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
09379	                {
09380	        __failure = 74;
09381	        if (!PyErr_Occurred()) {
09382	            PyErr_SetString(PyExc_RuntimeError,
09383	                "Unexpected error in an Op's C code. "
09384	                "No Python exception was set.");
09385	            }
09386	        goto __label_74;}
09387	            }
09388	            if (!PyArray_Check(py_V73)) {
09389	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
09390	                {
09391	        __failure = 74;
09392	        if (!PyErr_Occurred()) {
09393	            PyErr_SetString(PyExc_RuntimeError,
09394	                "Unexpected error in an Op's C code. "
09395	                "No Python exception was set.");
09396	            }
09397	        goto __label_74;}
09398	            }
09399	            // We expect NPY_FLOAT64
09400	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V73)) {
09401	                PyArrayObject * tmp = (PyArrayObject*) py_V73;
09402	                PyErr_Format(PyExc_NotImplementedError,
09403	                             "expected an aligned array of type %ld "
09404	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
09405	                             " with %ld dimensions, with 3 last dims "
09406	                             "%ld, %ld, %ld"
09407	                             " and 3 last strides %ld %ld, %ld.",
09408	                             (long int) NPY_FLOAT64,
09409	                             (long int) PyArray_TYPE((PyArrayObject*) py_V73),
09410	                             (long int) PyArray_NDIM(tmp),
09411	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
09412	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
09413	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
09414	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
09415	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
09416	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
09417	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
09418	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
09419	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
09420	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
09421	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
09422	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
09423	            );
09424	                {
09425	        __failure = 74;
09426	        if (!PyErr_Occurred()) {
09427	            PyErr_SetString(PyExc_RuntimeError,
09428	                "Unexpected error in an Op's C code. "
09429	                "No Python exception was set.");
09430	            }
09431	        goto __label_74;}
09432	            }
09433	            // This is a TypeError to be consistent with DEBUG_MODE
09434	            // Note: DEBUG_MODE also tells the name of the container
09435	            if (PyArray_TYPE((PyArrayObject*) py_V73) != NPY_FLOAT64) {
09436	                PyErr_Format(PyExc_TypeError,
09437	                             "expected type_num %d (NPY_FLOAT64) got %d",
09438	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V73));
09439	                {
09440	        __failure = 74;
09441	        if (!PyErr_Occurred()) {
09442	            PyErr_SetString(PyExc_RuntimeError,
09443	                "Unexpected error in an Op's C code. "
09444	                "No Python exception was set.");
09445	            }
09446	        goto __label_74;}
09447	            }
09448	            
09449	        V73 = (PyArrayObject*)(py_V73);
09450	        Py_XINCREF(V73);
09451	        
09452	{
09453	
09454	    py_V75 = PyList_GET_ITEM(storage_V75, 0);
09455	    {Py_XINCREF(py_V75);}
09456	    
09457	            V75 = NULL;
09458	            if (py_V75 == Py_None) {
09459	                // We can either fail here or set V75 to NULL and rely on Ops
09460	                // using tensors to handle the NULL case, but if they fail to do so
09461	                // they'll end up with nasty segfaults, so this is public service.
09462	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
09463	                {
09464	        __failure = 76;
09465	        if (!PyErr_Occurred()) {
09466	            PyErr_SetString(PyExc_RuntimeError,
09467	                "Unexpected error in an Op's C code. "
09468	                "No Python exception was set.");
09469	            }
09470	        goto __label_76;}
09471	            }
09472	            if (!PyArray_Check(py_V75)) {
09473	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
09474	                {
09475	        __failure = 76;
09476	        if (!PyErr_Occurred()) {
09477	            PyErr_SetString(PyExc_RuntimeError,
09478	                "Unexpected error in an Op's C code. "
09479	                "No Python exception was set.");
09480	            }
09481	        goto __label_76;}
09482	            }
09483	            // We expect NPY_FLOAT64
09484	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V75)) {
09485	                PyArrayObject * tmp = (PyArrayObject*) py_V75;
09486	                PyErr_Format(PyExc_NotImplementedError,
09487	                             "expected an aligned array of type %ld "
09488	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
09489	                             " with %ld dimensions, with 3 last dims "
09490	                             "%ld, %ld, %ld"
09491	                             " and 3 last strides %ld %ld, %ld.",
09492	                             (long int) NPY_FLOAT64,
09493	                             (long int) PyArray_TYPE((PyArrayObject*) py_V75),
09494	                             (long int) PyArray_NDIM(tmp),
09495	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
09496	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
09497	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
09498	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
09499	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
09500	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
09501	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
09502	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
09503	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
09504	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
09505	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
09506	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
09507	            );
09508	                {
09509	        __failure = 76;
09510	        if (!PyErr_Occurred()) {
09511	            PyErr_SetString(PyExc_RuntimeError,
09512	                "Unexpected error in an Op's C code. "
09513	                "No Python exception was set.");
09514	            }
09515	        goto __label_76;}
09516	            }
09517	            // This is a TypeError to be consistent with DEBUG_MODE
09518	            // Note: DEBUG_MODE also tells the name of the container
09519	            if (PyArray_TYPE((PyArrayObject*) py_V75) != NPY_FLOAT64) {
09520	                PyErr_Format(PyExc_TypeError,
09521	                             "expected type_num %d (NPY_FLOAT64) got %d",
09522	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V75));
09523	                {
09524	        __failure = 76;
09525	        if (!PyErr_Occurred()) {
09526	            PyErr_SetString(PyExc_RuntimeError,
09527	                "Unexpected error in an Op's C code. "
09528	                "No Python exception was set.");
09529	            }
09530	        goto __label_76;}
09531	            }
09532	            
09533	        V75 = (PyArrayObject*)(py_V75);
09534	        Py_XINCREF(V75);
09535	        
09536	{
09537	
09538	    py_V77 = PyList_GET_ITEM(storage_V77, 0);
09539	    {Py_XINCREF(py_V77);}
09540	    
09541	            V77 = NULL;
09542	            if (py_V77 == Py_None) {
09543	                // We can either fail here or set V77 to NULL and rely on Ops
09544	                // using tensors to handle the NULL case, but if they fail to do so
09545	                // they'll end up with nasty segfaults, so this is public service.
09546	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
09547	                {
09548	        __failure = 78;
09549	        if (!PyErr_Occurred()) {
09550	            PyErr_SetString(PyExc_RuntimeError,
09551	                "Unexpected error in an Op's C code. "
09552	                "No Python exception was set.");
09553	            }
09554	        goto __label_78;}
09555	            }
09556	            if (!PyArray_Check(py_V77)) {
09557	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
09558	                {
09559	        __failure = 78;
09560	        if (!PyErr_Occurred()) {
09561	            PyErr_SetString(PyExc_RuntimeError,
09562	                "Unexpected error in an Op's C code. "
09563	                "No Python exception was set.");
09564	            }
09565	        goto __label_78;}
09566	            }
09567	            // We expect NPY_FLOAT64
09568	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V77)) {
09569	                PyArrayObject * tmp = (PyArrayObject*) py_V77;
09570	                PyErr_Format(PyExc_NotImplementedError,
09571	                             "expected an aligned array of type %ld "
09572	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
09573	                             " with %ld dimensions, with 3 last dims "
09574	                             "%ld, %ld, %ld"
09575	                             " and 3 last strides %ld %ld, %ld.",
09576	                             (long int) NPY_FLOAT64,
09577	                             (long int) PyArray_TYPE((PyArrayObject*) py_V77),
09578	                             (long int) PyArray_NDIM(tmp),
09579	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
09580	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
09581	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
09582	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
09583	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
09584	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
09585	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
09586	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
09587	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
09588	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
09589	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
09590	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
09591	            );
09592	                {
09593	        __failure = 78;
09594	        if (!PyErr_Occurred()) {
09595	            PyErr_SetString(PyExc_RuntimeError,
09596	                "Unexpected error in an Op's C code. "
09597	                "No Python exception was set.");
09598	            }
09599	        goto __label_78;}
09600	            }
09601	            // This is a TypeError to be consistent with DEBUG_MODE
09602	            // Note: DEBUG_MODE also tells the name of the container
09603	            if (PyArray_TYPE((PyArrayObject*) py_V77) != NPY_FLOAT64) {
09604	                PyErr_Format(PyExc_TypeError,
09605	                             "expected type_num %d (NPY_FLOAT64) got %d",
09606	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V77));
09607	                {
09608	        __failure = 78;
09609	        if (!PyErr_Occurred()) {
09610	            PyErr_SetString(PyExc_RuntimeError,
09611	                "Unexpected error in an Op's C code. "
09612	                "No Python exception was set.");
09613	            }
09614	        goto __label_78;}
09615	            }
09616	            
09617	        V77 = (PyArrayObject*)(py_V77);
09618	        Py_XINCREF(V77);
09619	        
09620	{
09621	
09622	    py_V79 = PyList_GET_ITEM(storage_V79, 0);
09623	    {Py_XINCREF(py_V79);}
09624	    
09625	            V79 = NULL;
09626	            if (py_V79 == Py_None) {
09627	                // We can either fail here or set V79 to NULL and rely on Ops
09628	                // using tensors to handle the NULL case, but if they fail to do so
09629	                // they'll end up with nasty segfaults, so this is public service.
09630	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
09631	                {
09632	        __failure = 80;
09633	        if (!PyErr_Occurred()) {
09634	            PyErr_SetString(PyExc_RuntimeError,
09635	                "Unexpected error in an Op's C code. "
09636	                "No Python exception was set.");
09637	            }
09638	        goto __label_80;}
09639	            }
09640	            if (!PyArray_Check(py_V79)) {
09641	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
09642	                {
09643	        __failure = 80;
09644	        if (!PyErr_Occurred()) {
09645	            PyErr_SetString(PyExc_RuntimeError,
09646	                "Unexpected error in an Op's C code. "
09647	                "No Python exception was set.");
09648	            }
09649	        goto __label_80;}
09650	            }
09651	            // We expect NPY_FLOAT64
09652	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V79)) {
09653	                PyArrayObject * tmp = (PyArrayObject*) py_V79;
09654	                PyErr_Format(PyExc_NotImplementedError,
09655	                             "expected an aligned array of type %ld "
09656	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
09657	                             " with %ld dimensions, with 3 last dims "
09658	                             "%ld, %ld, %ld"
09659	                             " and 3 last strides %ld %ld, %ld.",
09660	                             (long int) NPY_FLOAT64,
09661	                             (long int) PyArray_TYPE((PyArrayObject*) py_V79),
09662	                             (long int) PyArray_NDIM(tmp),
09663	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
09664	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
09665	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
09666	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
09667	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
09668	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
09669	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
09670	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
09671	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
09672	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
09673	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
09674	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
09675	            );
09676	                {
09677	        __failure = 80;
09678	        if (!PyErr_Occurred()) {
09679	            PyErr_SetString(PyExc_RuntimeError,
09680	                "Unexpected error in an Op's C code. "
09681	                "No Python exception was set.");
09682	            }
09683	        goto __label_80;}
09684	            }
09685	            // This is a TypeError to be consistent with DEBUG_MODE
09686	            // Note: DEBUG_MODE also tells the name of the container
09687	            if (PyArray_TYPE((PyArrayObject*) py_V79) != NPY_FLOAT64) {
09688	                PyErr_Format(PyExc_TypeError,
09689	                             "expected type_num %d (NPY_FLOAT64) got %d",
09690	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V79));
09691	                {
09692	        __failure = 80;
09693	        if (!PyErr_Occurred()) {
09694	            PyErr_SetString(PyExc_RuntimeError,
09695	                "Unexpected error in an Op's C code. "
09696	                "No Python exception was set.");
09697	            }
09698	        goto __label_80;}
09699	            }
09700	            
09701	        V79 = (PyArrayObject*)(py_V79);
09702	        Py_XINCREF(V79);
09703	        
09704	{
09705	
09706	    py_V81 = PyList_GET_ITEM(storage_V81, 0);
09707	    {Py_XINCREF(py_V81);}
09708	    
09709	            V81 = NULL;
09710	            if (py_V81 == Py_None) {
09711	                // We can either fail here or set V81 to NULL and rely on Ops
09712	                // using tensors to handle the NULL case, but if they fail to do so
09713	                // they'll end up with nasty segfaults, so this is public service.
09714	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
09715	                {
09716	        __failure = 82;
09717	        if (!PyErr_Occurred()) {
09718	            PyErr_SetString(PyExc_RuntimeError,
09719	                "Unexpected error in an Op's C code. "
09720	                "No Python exception was set.");
09721	            }
09722	        goto __label_82;}
09723	            }
09724	            if (!PyArray_Check(py_V81)) {
09725	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
09726	                {
09727	        __failure = 82;
09728	        if (!PyErr_Occurred()) {
09729	            PyErr_SetString(PyExc_RuntimeError,
09730	                "Unexpected error in an Op's C code. "
09731	                "No Python exception was set.");
09732	            }
09733	        goto __label_82;}
09734	            }
09735	            // We expect NPY_FLOAT64
09736	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V81)) {
09737	                PyArrayObject * tmp = (PyArrayObject*) py_V81;
09738	                PyErr_Format(PyExc_NotImplementedError,
09739	                             "expected an aligned array of type %ld "
09740	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
09741	                             " with %ld dimensions, with 3 last dims "
09742	                             "%ld, %ld, %ld"
09743	                             " and 3 last strides %ld %ld, %ld.",
09744	                             (long int) NPY_FLOAT64,
09745	                             (long int) PyArray_TYPE((PyArrayObject*) py_V81),
09746	                             (long int) PyArray_NDIM(tmp),
09747	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
09748	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
09749	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
09750	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
09751	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
09752	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
09753	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
09754	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
09755	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
09756	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
09757	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
09758	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
09759	            );
09760	                {
09761	        __failure = 82;
09762	        if (!PyErr_Occurred()) {
09763	            PyErr_SetString(PyExc_RuntimeError,
09764	                "Unexpected error in an Op's C code. "
09765	                "No Python exception was set.");
09766	            }
09767	        goto __label_82;}
09768	            }
09769	            // This is a TypeError to be consistent with DEBUG_MODE
09770	            // Note: DEBUG_MODE also tells the name of the container
09771	            if (PyArray_TYPE((PyArrayObject*) py_V81) != NPY_FLOAT64) {
09772	                PyErr_Format(PyExc_TypeError,
09773	                             "expected type_num %d (NPY_FLOAT64) got %d",
09774	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V81));
09775	                {
09776	        __failure = 82;
09777	        if (!PyErr_Occurred()) {
09778	            PyErr_SetString(PyExc_RuntimeError,
09779	                "Unexpected error in an Op's C code. "
09780	                "No Python exception was set.");
09781	            }
09782	        goto __label_82;}
09783	            }
09784	            
09785	        V81 = (PyArrayObject*)(py_V81);
09786	        Py_XINCREF(V81);
09787	        
09788	{
09789	
09790	    py_V83 = PyList_GET_ITEM(storage_V83, 0);
09791	    {Py_XINCREF(py_V83);}
09792	    
09793	            V83 = NULL;
09794	            if (py_V83 == Py_None) {
09795	                // We can either fail here or set V83 to NULL and rely on Ops
09796	                // using tensors to handle the NULL case, but if they fail to do so
09797	                // they'll end up with nasty segfaults, so this is public service.
09798	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
09799	                {
09800	        __failure = 84;
09801	        if (!PyErr_Occurred()) {
09802	            PyErr_SetString(PyExc_RuntimeError,
09803	                "Unexpected error in an Op's C code. "
09804	                "No Python exception was set.");
09805	            }
09806	        goto __label_84;}
09807	            }
09808	            if (!PyArray_Check(py_V83)) {
09809	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
09810	                {
09811	        __failure = 84;
09812	        if (!PyErr_Occurred()) {
09813	            PyErr_SetString(PyExc_RuntimeError,
09814	                "Unexpected error in an Op's C code. "
09815	                "No Python exception was set.");
09816	            }
09817	        goto __label_84;}
09818	            }
09819	            // We expect NPY_FLOAT64
09820	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V83)) {
09821	                PyArrayObject * tmp = (PyArrayObject*) py_V83;
09822	                PyErr_Format(PyExc_NotImplementedError,
09823	                             "expected an aligned array of type %ld "
09824	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
09825	                             " with %ld dimensions, with 3 last dims "
09826	                             "%ld, %ld, %ld"
09827	                             " and 3 last strides %ld %ld, %ld.",
09828	                             (long int) NPY_FLOAT64,
09829	                             (long int) PyArray_TYPE((PyArrayObject*) py_V83),
09830	                             (long int) PyArray_NDIM(tmp),
09831	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
09832	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
09833	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
09834	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
09835	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
09836	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
09837	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
09838	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
09839	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
09840	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
09841	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
09842	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
09843	            );
09844	                {
09845	        __failure = 84;
09846	        if (!PyErr_Occurred()) {
09847	            PyErr_SetString(PyExc_RuntimeError,
09848	                "Unexpected error in an Op's C code. "
09849	                "No Python exception was set.");
09850	            }
09851	        goto __label_84;}
09852	            }
09853	            // This is a TypeError to be consistent with DEBUG_MODE
09854	            // Note: DEBUG_MODE also tells the name of the container
09855	            if (PyArray_TYPE((PyArrayObject*) py_V83) != NPY_FLOAT64) {
09856	                PyErr_Format(PyExc_TypeError,
09857	                             "expected type_num %d (NPY_FLOAT64) got %d",
09858	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V83));
09859	                {
09860	        __failure = 84;
09861	        if (!PyErr_Occurred()) {
09862	            PyErr_SetString(PyExc_RuntimeError,
09863	                "Unexpected error in an Op's C code. "
09864	                "No Python exception was set.");
09865	            }
09866	        goto __label_84;}
09867	            }
09868	            
09869	        V83 = (PyArrayObject*)(py_V83);
09870	        Py_XINCREF(V83);
09871	        
09872	{
09873	
09874	    py_V85 = PyList_GET_ITEM(storage_V85, 0);
09875	    {Py_XINCREF(py_V85);}
09876	    
09877	            V85 = NULL;
09878	            if (py_V85 == Py_None) {
09879	                // We can either fail here or set V85 to NULL and rely on Ops
09880	                // using tensors to handle the NULL case, but if they fail to do so
09881	                // they'll end up with nasty segfaults, so this is public service.
09882	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
09883	                {
09884	        __failure = 86;
09885	        if (!PyErr_Occurred()) {
09886	            PyErr_SetString(PyExc_RuntimeError,
09887	                "Unexpected error in an Op's C code. "
09888	                "No Python exception was set.");
09889	            }
09890	        goto __label_86;}
09891	            }
09892	            if (!PyArray_Check(py_V85)) {
09893	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
09894	                {
09895	        __failure = 86;
09896	        if (!PyErr_Occurred()) {
09897	            PyErr_SetString(PyExc_RuntimeError,
09898	                "Unexpected error in an Op's C code. "
09899	                "No Python exception was set.");
09900	            }
09901	        goto __label_86;}
09902	            }
09903	            // We expect NPY_FLOAT64
09904	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V85)) {
09905	                PyArrayObject * tmp = (PyArrayObject*) py_V85;
09906	                PyErr_Format(PyExc_NotImplementedError,
09907	                             "expected an aligned array of type %ld "
09908	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
09909	                             " with %ld dimensions, with 3 last dims "
09910	                             "%ld, %ld, %ld"
09911	                             " and 3 last strides %ld %ld, %ld.",
09912	                             (long int) NPY_FLOAT64,
09913	                             (long int) PyArray_TYPE((PyArrayObject*) py_V85),
09914	                             (long int) PyArray_NDIM(tmp),
09915	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
09916	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
09917	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
09918	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
09919	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
09920	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
09921	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
09922	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
09923	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
09924	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
09925	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
09926	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
09927	            );
09928	                {
09929	        __failure = 86;
09930	        if (!PyErr_Occurred()) {
09931	            PyErr_SetString(PyExc_RuntimeError,
09932	                "Unexpected error in an Op's C code. "
09933	                "No Python exception was set.");
09934	            }
09935	        goto __label_86;}
09936	            }
09937	            // This is a TypeError to be consistent with DEBUG_MODE
09938	            // Note: DEBUG_MODE also tells the name of the container
09939	            if (PyArray_TYPE((PyArrayObject*) py_V85) != NPY_FLOAT64) {
09940	                PyErr_Format(PyExc_TypeError,
09941	                             "expected type_num %d (NPY_FLOAT64) got %d",
09942	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V85));
09943	                {
09944	        __failure = 86;
09945	        if (!PyErr_Occurred()) {
09946	            PyErr_SetString(PyExc_RuntimeError,
09947	                "Unexpected error in an Op's C code. "
09948	                "No Python exception was set.");
09949	            }
09950	        goto __label_86;}
09951	            }
09952	            
09953	        V85 = (PyArrayObject*)(py_V85);
09954	        Py_XINCREF(V85);
09955	        
09956	{
09957	
09958	    py_V87 = PyList_GET_ITEM(storage_V87, 0);
09959	    {Py_XINCREF(py_V87);}
09960	    
09961	            V87 = NULL;
09962	            if (py_V87 == Py_None) {
09963	                // We can either fail here or set V87 to NULL and rely on Ops
09964	                // using tensors to handle the NULL case, but if they fail to do so
09965	                // they'll end up with nasty segfaults, so this is public service.
09966	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
09967	                {
09968	        __failure = 88;
09969	        if (!PyErr_Occurred()) {
09970	            PyErr_SetString(PyExc_RuntimeError,
09971	                "Unexpected error in an Op's C code. "
09972	                "No Python exception was set.");
09973	            }
09974	        goto __label_88;}
09975	            }
09976	            if (!PyArray_Check(py_V87)) {
09977	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
09978	                {
09979	        __failure = 88;
09980	        if (!PyErr_Occurred()) {
09981	            PyErr_SetString(PyExc_RuntimeError,
09982	                "Unexpected error in an Op's C code. "
09983	                "No Python exception was set.");
09984	            }
09985	        goto __label_88;}
09986	            }
09987	            // We expect NPY_FLOAT64
09988	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V87)) {
09989	                PyArrayObject * tmp = (PyArrayObject*) py_V87;
09990	                PyErr_Format(PyExc_NotImplementedError,
09991	                             "expected an aligned array of type %ld "
09992	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
09993	                             " with %ld dimensions, with 3 last dims "
09994	                             "%ld, %ld, %ld"
09995	                             " and 3 last strides %ld %ld, %ld.",
09996	                             (long int) NPY_FLOAT64,
09997	                             (long int) PyArray_TYPE((PyArrayObject*) py_V87),
09998	                             (long int) PyArray_NDIM(tmp),
09999	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
10000	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
10001	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
10002	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
10003	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
10004	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
10005	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
10006	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
10007	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
10008	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
10009	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
10010	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
10011	            );
10012	                {
10013	        __failure = 88;
10014	        if (!PyErr_Occurred()) {
10015	            PyErr_SetString(PyExc_RuntimeError,
10016	                "Unexpected error in an Op's C code. "
10017	                "No Python exception was set.");
10018	            }
10019	        goto __label_88;}
10020	            }
10021	            // This is a TypeError to be consistent with DEBUG_MODE
10022	            // Note: DEBUG_MODE also tells the name of the container
10023	            if (PyArray_TYPE((PyArrayObject*) py_V87) != NPY_FLOAT64) {
10024	                PyErr_Format(PyExc_TypeError,
10025	                             "expected type_num %d (NPY_FLOAT64) got %d",
10026	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V87));
10027	                {
10028	        __failure = 88;
10029	        if (!PyErr_Occurred()) {
10030	            PyErr_SetString(PyExc_RuntimeError,
10031	                "Unexpected error in an Op's C code. "
10032	                "No Python exception was set.");
10033	            }
10034	        goto __label_88;}
10035	            }
10036	            
10037	        V87 = (PyArrayObject*)(py_V87);
10038	        Py_XINCREF(V87);
10039	        
10040	{
10041	
10042	    py_V89 = PyList_GET_ITEM(storage_V89, 0);
10043	    {Py_XINCREF(py_V89);}
10044	    
10045	            V89 = NULL;
10046	            if (py_V89 == Py_None) {
10047	                // We can either fail here or set V89 to NULL and rely on Ops
10048	                // using tensors to handle the NULL case, but if they fail to do so
10049	                // they'll end up with nasty segfaults, so this is public service.
10050	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
10051	                {
10052	        __failure = 90;
10053	        if (!PyErr_Occurred()) {
10054	            PyErr_SetString(PyExc_RuntimeError,
10055	                "Unexpected error in an Op's C code. "
10056	                "No Python exception was set.");
10057	            }
10058	        goto __label_90;}
10059	            }
10060	            if (!PyArray_Check(py_V89)) {
10061	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
10062	                {
10063	        __failure = 90;
10064	        if (!PyErr_Occurred()) {
10065	            PyErr_SetString(PyExc_RuntimeError,
10066	                "Unexpected error in an Op's C code. "
10067	                "No Python exception was set.");
10068	            }
10069	        goto __label_90;}
10070	            }
10071	            // We expect NPY_FLOAT64
10072	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V89)) {
10073	                PyArrayObject * tmp = (PyArrayObject*) py_V89;
10074	                PyErr_Format(PyExc_NotImplementedError,
10075	                             "expected an aligned array of type %ld "
10076	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
10077	                             " with %ld dimensions, with 3 last dims "
10078	                             "%ld, %ld, %ld"
10079	                             " and 3 last strides %ld %ld, %ld.",
10080	                             (long int) NPY_FLOAT64,
10081	                             (long int) PyArray_TYPE((PyArrayObject*) py_V89),
10082	                             (long int) PyArray_NDIM(tmp),
10083	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
10084	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
10085	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
10086	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
10087	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
10088	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
10089	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
10090	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
10091	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
10092	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
10093	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
10094	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
10095	            );
10096	                {
10097	        __failure = 90;
10098	        if (!PyErr_Occurred()) {
10099	            PyErr_SetString(PyExc_RuntimeError,
10100	                "Unexpected error in an Op's C code. "
10101	                "No Python exception was set.");
10102	            }
10103	        goto __label_90;}
10104	            }
10105	            // This is a TypeError to be consistent with DEBUG_MODE
10106	            // Note: DEBUG_MODE also tells the name of the container
10107	            if (PyArray_TYPE((PyArrayObject*) py_V89) != NPY_FLOAT64) {
10108	                PyErr_Format(PyExc_TypeError,
10109	                             "expected type_num %d (NPY_FLOAT64) got %d",
10110	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V89));
10111	                {
10112	        __failure = 90;
10113	        if (!PyErr_Occurred()) {
10114	            PyErr_SetString(PyExc_RuntimeError,
10115	                "Unexpected error in an Op's C code. "
10116	                "No Python exception was set.");
10117	            }
10118	        goto __label_90;}
10119	            }
10120	            
10121	        V89 = (PyArrayObject*)(py_V89);
10122	        Py_XINCREF(V89);
10123	        
10124	{
10125	
10126	    py_V91 = PyList_GET_ITEM(storage_V91, 0);
10127	    {Py_XINCREF(py_V91);}
10128	    
10129	            V91 = NULL;
10130	            if (py_V91 == Py_None) {
10131	                // We can either fail here or set V91 to NULL and rely on Ops
10132	                // using tensors to handle the NULL case, but if they fail to do so
10133	                // they'll end up with nasty segfaults, so this is public service.
10134	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
10135	                {
10136	        __failure = 92;
10137	        if (!PyErr_Occurred()) {
10138	            PyErr_SetString(PyExc_RuntimeError,
10139	                "Unexpected error in an Op's C code. "
10140	                "No Python exception was set.");
10141	            }
10142	        goto __label_92;}
10143	            }
10144	            if (!PyArray_Check(py_V91)) {
10145	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
10146	                {
10147	        __failure = 92;
10148	        if (!PyErr_Occurred()) {
10149	            PyErr_SetString(PyExc_RuntimeError,
10150	                "Unexpected error in an Op's C code. "
10151	                "No Python exception was set.");
10152	            }
10153	        goto __label_92;}
10154	            }
10155	            // We expect NPY_FLOAT64
10156	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V91)) {
10157	                PyArrayObject * tmp = (PyArrayObject*) py_V91;
10158	                PyErr_Format(PyExc_NotImplementedError,
10159	                             "expected an aligned array of type %ld "
10160	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
10161	                             " with %ld dimensions, with 3 last dims "
10162	                             "%ld, %ld, %ld"
10163	                             " and 3 last strides %ld %ld, %ld.",
10164	                             (long int) NPY_FLOAT64,
10165	                             (long int) PyArray_TYPE((PyArrayObject*) py_V91),
10166	                             (long int) PyArray_NDIM(tmp),
10167	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
10168	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
10169	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
10170	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
10171	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
10172	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
10173	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
10174	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
10175	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
10176	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
10177	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
10178	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
10179	            );
10180	                {
10181	        __failure = 92;
10182	        if (!PyErr_Occurred()) {
10183	            PyErr_SetString(PyExc_RuntimeError,
10184	                "Unexpected error in an Op's C code. "
10185	                "No Python exception was set.");
10186	            }
10187	        goto __label_92;}
10188	            }
10189	            // This is a TypeError to be consistent with DEBUG_MODE
10190	            // Note: DEBUG_MODE also tells the name of the container
10191	            if (PyArray_TYPE((PyArrayObject*) py_V91) != NPY_FLOAT64) {
10192	                PyErr_Format(PyExc_TypeError,
10193	                             "expected type_num %d (NPY_FLOAT64) got %d",
10194	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V91));
10195	                {
10196	        __failure = 92;
10197	        if (!PyErr_Occurred()) {
10198	            PyErr_SetString(PyExc_RuntimeError,
10199	                "Unexpected error in an Op's C code. "
10200	                "No Python exception was set.");
10201	            }
10202	        goto __label_92;}
10203	            }
10204	            
10205	        V91 = (PyArrayObject*)(py_V91);
10206	        Py_XINCREF(V91);
10207	        
10208	{
10209	
10210	    py_V93 = PyList_GET_ITEM(storage_V93, 0);
10211	    {Py_XINCREF(py_V93);}
10212	    
10213	            V93 = NULL;
10214	            if (py_V93 == Py_None) {
10215	                // We can either fail here or set V93 to NULL and rely on Ops
10216	                // using tensors to handle the NULL case, but if they fail to do so
10217	                // they'll end up with nasty segfaults, so this is public service.
10218	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
10219	                {
10220	        __failure = 94;
10221	        if (!PyErr_Occurred()) {
10222	            PyErr_SetString(PyExc_RuntimeError,
10223	                "Unexpected error in an Op's C code. "
10224	                "No Python exception was set.");
10225	            }
10226	        goto __label_94;}
10227	            }
10228	            if (!PyArray_Check(py_V93)) {
10229	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
10230	                {
10231	        __failure = 94;
10232	        if (!PyErr_Occurred()) {
10233	            PyErr_SetString(PyExc_RuntimeError,
10234	                "Unexpected error in an Op's C code. "
10235	                "No Python exception was set.");
10236	            }
10237	        goto __label_94;}
10238	            }
10239	            // We expect NPY_FLOAT64
10240	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V93)) {
10241	                PyArrayObject * tmp = (PyArrayObject*) py_V93;
10242	                PyErr_Format(PyExc_NotImplementedError,
10243	                             "expected an aligned array of type %ld "
10244	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
10245	                             " with %ld dimensions, with 3 last dims "
10246	                             "%ld, %ld, %ld"
10247	                             " and 3 last strides %ld %ld, %ld.",
10248	                             (long int) NPY_FLOAT64,
10249	                             (long int) PyArray_TYPE((PyArrayObject*) py_V93),
10250	                             (long int) PyArray_NDIM(tmp),
10251	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
10252	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
10253	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
10254	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
10255	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
10256	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
10257	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
10258	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
10259	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
10260	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
10261	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
10262	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
10263	            );
10264	                {
10265	        __failure = 94;
10266	        if (!PyErr_Occurred()) {
10267	            PyErr_SetString(PyExc_RuntimeError,
10268	                "Unexpected error in an Op's C code. "
10269	                "No Python exception was set.");
10270	            }
10271	        goto __label_94;}
10272	            }
10273	            // This is a TypeError to be consistent with DEBUG_MODE
10274	            // Note: DEBUG_MODE also tells the name of the container
10275	            if (PyArray_TYPE((PyArrayObject*) py_V93) != NPY_FLOAT64) {
10276	                PyErr_Format(PyExc_TypeError,
10277	                             "expected type_num %d (NPY_FLOAT64) got %d",
10278	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V93));
10279	                {
10280	        __failure = 94;
10281	        if (!PyErr_Occurred()) {
10282	            PyErr_SetString(PyExc_RuntimeError,
10283	                "Unexpected error in an Op's C code. "
10284	                "No Python exception was set.");
10285	            }
10286	        goto __label_94;}
10287	            }
10288	            
10289	        V93 = (PyArrayObject*)(py_V93);
10290	        Py_XINCREF(V93);
10291	        
10292	{
10293	
10294	    py_V95 = PyList_GET_ITEM(storage_V95, 0);
10295	    {Py_XINCREF(py_V95);}
10296	    
10297	            V95 = NULL;
10298	            if (py_V95 == Py_None) {
10299	                // We can either fail here or set V95 to NULL and rely on Ops
10300	                // using tensors to handle the NULL case, but if they fail to do so
10301	                // they'll end up with nasty segfaults, so this is public service.
10302	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
10303	                {
10304	        __failure = 96;
10305	        if (!PyErr_Occurred()) {
10306	            PyErr_SetString(PyExc_RuntimeError,
10307	                "Unexpected error in an Op's C code. "
10308	                "No Python exception was set.");
10309	            }
10310	        goto __label_96;}
10311	            }
10312	            if (!PyArray_Check(py_V95)) {
10313	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
10314	                {
10315	        __failure = 96;
10316	        if (!PyErr_Occurred()) {
10317	            PyErr_SetString(PyExc_RuntimeError,
10318	                "Unexpected error in an Op's C code. "
10319	                "No Python exception was set.");
10320	            }
10321	        goto __label_96;}
10322	            }
10323	            // We expect NPY_FLOAT64
10324	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V95)) {
10325	                PyArrayObject * tmp = (PyArrayObject*) py_V95;
10326	                PyErr_Format(PyExc_NotImplementedError,
10327	                             "expected an aligned array of type %ld "
10328	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
10329	                             " with %ld dimensions, with 3 last dims "
10330	                             "%ld, %ld, %ld"
10331	                             " and 3 last strides %ld %ld, %ld.",
10332	                             (long int) NPY_FLOAT64,
10333	                             (long int) PyArray_TYPE((PyArrayObject*) py_V95),
10334	                             (long int) PyArray_NDIM(tmp),
10335	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
10336	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
10337	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
10338	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
10339	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
10340	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
10341	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
10342	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
10343	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
10344	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
10345	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
10346	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
10347	            );
10348	                {
10349	        __failure = 96;
10350	        if (!PyErr_Occurred()) {
10351	            PyErr_SetString(PyExc_RuntimeError,
10352	                "Unexpected error in an Op's C code. "
10353	                "No Python exception was set.");
10354	            }
10355	        goto __label_96;}
10356	            }
10357	            // This is a TypeError to be consistent with DEBUG_MODE
10358	            // Note: DEBUG_MODE also tells the name of the container
10359	            if (PyArray_TYPE((PyArrayObject*) py_V95) != NPY_FLOAT64) {
10360	                PyErr_Format(PyExc_TypeError,
10361	                             "expected type_num %d (NPY_FLOAT64) got %d",
10362	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V95));
10363	                {
10364	        __failure = 96;
10365	        if (!PyErr_Occurred()) {
10366	            PyErr_SetString(PyExc_RuntimeError,
10367	                "Unexpected error in an Op's C code. "
10368	                "No Python exception was set.");
10369	            }
10370	        goto __label_96;}
10371	            }
10372	            
10373	        V95 = (PyArrayObject*)(py_V95);
10374	        Py_XINCREF(V95);
10375	        
10376	{
10377	
10378	    py_V97 = PyList_GET_ITEM(storage_V97, 0);
10379	    {Py_XINCREF(py_V97);}
10380	    
10381	            V97 = NULL;
10382	            if (py_V97 == Py_None) {
10383	                // We can either fail here or set V97 to NULL and rely on Ops
10384	                // using tensors to handle the NULL case, but if they fail to do so
10385	                // they'll end up with nasty segfaults, so this is public service.
10386	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
10387	                {
10388	        __failure = 98;
10389	        if (!PyErr_Occurred()) {
10390	            PyErr_SetString(PyExc_RuntimeError,
10391	                "Unexpected error in an Op's C code. "
10392	                "No Python exception was set.");
10393	            }
10394	        goto __label_98;}
10395	            }
10396	            if (!PyArray_Check(py_V97)) {
10397	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
10398	                {
10399	        __failure = 98;
10400	        if (!PyErr_Occurred()) {
10401	            PyErr_SetString(PyExc_RuntimeError,
10402	                "Unexpected error in an Op's C code. "
10403	                "No Python exception was set.");
10404	            }
10405	        goto __label_98;}
10406	            }
10407	            // We expect NPY_FLOAT64
10408	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V97)) {
10409	                PyArrayObject * tmp = (PyArrayObject*) py_V97;
10410	                PyErr_Format(PyExc_NotImplementedError,
10411	                             "expected an aligned array of type %ld "
10412	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
10413	                             " with %ld dimensions, with 3 last dims "
10414	                             "%ld, %ld, %ld"
10415	                             " and 3 last strides %ld %ld, %ld.",
10416	                             (long int) NPY_FLOAT64,
10417	                             (long int) PyArray_TYPE((PyArrayObject*) py_V97),
10418	                             (long int) PyArray_NDIM(tmp),
10419	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
10420	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
10421	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
10422	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
10423	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
10424	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
10425	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
10426	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
10427	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
10428	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
10429	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
10430	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
10431	            );
10432	                {
10433	        __failure = 98;
10434	        if (!PyErr_Occurred()) {
10435	            PyErr_SetString(PyExc_RuntimeError,
10436	                "Unexpected error in an Op's C code. "
10437	                "No Python exception was set.");
10438	            }
10439	        goto __label_98;}
10440	            }
10441	            // This is a TypeError to be consistent with DEBUG_MODE
10442	            // Note: DEBUG_MODE also tells the name of the container
10443	            if (PyArray_TYPE((PyArrayObject*) py_V97) != NPY_FLOAT64) {
10444	                PyErr_Format(PyExc_TypeError,
10445	                             "expected type_num %d (NPY_FLOAT64) got %d",
10446	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V97));
10447	                {
10448	        __failure = 98;
10449	        if (!PyErr_Occurred()) {
10450	            PyErr_SetString(PyExc_RuntimeError,
10451	                "Unexpected error in an Op's C code. "
10452	                "No Python exception was set.");
10453	            }
10454	        goto __label_98;}
10455	            }
10456	            
10457	        V97 = (PyArrayObject*)(py_V97);
10458	        Py_XINCREF(V97);
10459	        
10460	{
10461	
10462	    py_V99 = PyList_GET_ITEM(storage_V99, 0);
10463	    {Py_XINCREF(py_V99);}
10464	    
10465	            V99 = NULL;
10466	            if (py_V99 == Py_None) {
10467	                // We can either fail here or set V99 to NULL and rely on Ops
10468	                // using tensors to handle the NULL case, but if they fail to do so
10469	                // they'll end up with nasty segfaults, so this is public service.
10470	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
10471	                {
10472	        __failure = 100;
10473	        if (!PyErr_Occurred()) {
10474	            PyErr_SetString(PyExc_RuntimeError,
10475	                "Unexpected error in an Op's C code. "
10476	                "No Python exception was set.");
10477	            }
10478	        goto __label_100;}
10479	            }
10480	            if (!PyArray_Check(py_V99)) {
10481	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
10482	                {
10483	        __failure = 100;
10484	        if (!PyErr_Occurred()) {
10485	            PyErr_SetString(PyExc_RuntimeError,
10486	                "Unexpected error in an Op's C code. "
10487	                "No Python exception was set.");
10488	            }
10489	        goto __label_100;}
10490	            }
10491	            // We expect NPY_FLOAT64
10492	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V99)) {
10493	                PyArrayObject * tmp = (PyArrayObject*) py_V99;
10494	                PyErr_Format(PyExc_NotImplementedError,
10495	                             "expected an aligned array of type %ld "
10496	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
10497	                             " with %ld dimensions, with 3 last dims "
10498	                             "%ld, %ld, %ld"
10499	                             " and 3 last strides %ld %ld, %ld.",
10500	                             (long int) NPY_FLOAT64,
10501	                             (long int) PyArray_TYPE((PyArrayObject*) py_V99),
10502	                             (long int) PyArray_NDIM(tmp),
10503	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
10504	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
10505	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
10506	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
10507	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
10508	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
10509	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
10510	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
10511	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
10512	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
10513	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
10514	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
10515	            );
10516	                {
10517	        __failure = 100;
10518	        if (!PyErr_Occurred()) {
10519	            PyErr_SetString(PyExc_RuntimeError,
10520	                "Unexpected error in an Op's C code. "
10521	                "No Python exception was set.");
10522	            }
10523	        goto __label_100;}
10524	            }
10525	            // This is a TypeError to be consistent with DEBUG_MODE
10526	            // Note: DEBUG_MODE also tells the name of the container
10527	            if (PyArray_TYPE((PyArrayObject*) py_V99) != NPY_FLOAT64) {
10528	                PyErr_Format(PyExc_TypeError,
10529	                             "expected type_num %d (NPY_FLOAT64) got %d",
10530	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V99));
10531	                {
10532	        __failure = 100;
10533	        if (!PyErr_Occurred()) {
10534	            PyErr_SetString(PyExc_RuntimeError,
10535	                "Unexpected error in an Op's C code. "
10536	                "No Python exception was set.");
10537	            }
10538	        goto __label_100;}
10539	            }
10540	            
10541	        V99 = (PyArrayObject*)(py_V99);
10542	        Py_XINCREF(V99);
10543	        
10544	{
10545	
10546	    py_V101 = PyList_GET_ITEM(storage_V101, 0);
10547	    {Py_XINCREF(py_V101);}
10548	    
10549	            V101 = NULL;
10550	            if (py_V101 == Py_None) {
10551	                // We can either fail here or set V101 to NULL and rely on Ops
10552	                // using tensors to handle the NULL case, but if they fail to do so
10553	                // they'll end up with nasty segfaults, so this is public service.
10554	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
10555	                {
10556	        __failure = 102;
10557	        if (!PyErr_Occurred()) {
10558	            PyErr_SetString(PyExc_RuntimeError,
10559	                "Unexpected error in an Op's C code. "
10560	                "No Python exception was set.");
10561	            }
10562	        goto __label_102;}
10563	            }
10564	            if (!PyArray_Check(py_V101)) {
10565	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
10566	                {
10567	        __failure = 102;
10568	        if (!PyErr_Occurred()) {
10569	            PyErr_SetString(PyExc_RuntimeError,
10570	                "Unexpected error in an Op's C code. "
10571	                "No Python exception was set.");
10572	            }
10573	        goto __label_102;}
10574	            }
10575	            // We expect NPY_FLOAT64
10576	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V101)) {
10577	                PyArrayObject * tmp = (PyArrayObject*) py_V101;
10578	                PyErr_Format(PyExc_NotImplementedError,
10579	                             "expected an aligned array of type %ld "
10580	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
10581	                             " with %ld dimensions, with 3 last dims "
10582	                             "%ld, %ld, %ld"
10583	                             " and 3 last strides %ld %ld, %ld.",
10584	                             (long int) NPY_FLOAT64,
10585	                             (long int) PyArray_TYPE((PyArrayObject*) py_V101),
10586	                             (long int) PyArray_NDIM(tmp),
10587	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
10588	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
10589	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
10590	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
10591	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
10592	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
10593	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
10594	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
10595	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
10596	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
10597	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
10598	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
10599	            );
10600	                {
10601	        __failure = 102;
10602	        if (!PyErr_Occurred()) {
10603	            PyErr_SetString(PyExc_RuntimeError,
10604	                "Unexpected error in an Op's C code. "
10605	                "No Python exception was set.");
10606	            }
10607	        goto __label_102;}
10608	            }
10609	            // This is a TypeError to be consistent with DEBUG_MODE
10610	            // Note: DEBUG_MODE also tells the name of the container
10611	            if (PyArray_TYPE((PyArrayObject*) py_V101) != NPY_FLOAT64) {
10612	                PyErr_Format(PyExc_TypeError,
10613	                             "expected type_num %d (NPY_FLOAT64) got %d",
10614	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V101));
10615	                {
10616	        __failure = 102;
10617	        if (!PyErr_Occurred()) {
10618	            PyErr_SetString(PyExc_RuntimeError,
10619	                "Unexpected error in an Op's C code. "
10620	                "No Python exception was set.");
10621	            }
10622	        goto __label_102;}
10623	            }
10624	            
10625	        V101 = (PyArrayObject*)(py_V101);
10626	        Py_XINCREF(V101);
10627	        
10628	{
10629	
10630	    py_V103 = PyList_GET_ITEM(storage_V103, 0);
10631	    {Py_XINCREF(py_V103);}
10632	    
10633	            V103 = NULL;
10634	            if (py_V103 == Py_None) {
10635	                // We can either fail here or set V103 to NULL and rely on Ops
10636	                // using tensors to handle the NULL case, but if they fail to do so
10637	                // they'll end up with nasty segfaults, so this is public service.
10638	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
10639	                {
10640	        __failure = 104;
10641	        if (!PyErr_Occurred()) {
10642	            PyErr_SetString(PyExc_RuntimeError,
10643	                "Unexpected error in an Op's C code. "
10644	                "No Python exception was set.");
10645	            }
10646	        goto __label_104;}
10647	            }
10648	            if (!PyArray_Check(py_V103)) {
10649	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
10650	                {
10651	        __failure = 104;
10652	        if (!PyErr_Occurred()) {
10653	            PyErr_SetString(PyExc_RuntimeError,
10654	                "Unexpected error in an Op's C code. "
10655	                "No Python exception was set.");
10656	            }
10657	        goto __label_104;}
10658	            }
10659	            // We expect NPY_FLOAT64
10660	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V103)) {
10661	                PyArrayObject * tmp = (PyArrayObject*) py_V103;
10662	                PyErr_Format(PyExc_NotImplementedError,
10663	                             "expected an aligned array of type %ld "
10664	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
10665	                             " with %ld dimensions, with 3 last dims "
10666	                             "%ld, %ld, %ld"
10667	                             " and 3 last strides %ld %ld, %ld.",
10668	                             (long int) NPY_FLOAT64,
10669	                             (long int) PyArray_TYPE((PyArrayObject*) py_V103),
10670	                             (long int) PyArray_NDIM(tmp),
10671	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
10672	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
10673	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
10674	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
10675	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
10676	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
10677	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
10678	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
10679	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
10680	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
10681	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
10682	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
10683	            );
10684	                {
10685	        __failure = 104;
10686	        if (!PyErr_Occurred()) {
10687	            PyErr_SetString(PyExc_RuntimeError,
10688	                "Unexpected error in an Op's C code. "
10689	                "No Python exception was set.");
10690	            }
10691	        goto __label_104;}
10692	            }
10693	            // This is a TypeError to be consistent with DEBUG_MODE
10694	            // Note: DEBUG_MODE also tells the name of the container
10695	            if (PyArray_TYPE((PyArrayObject*) py_V103) != NPY_FLOAT64) {
10696	                PyErr_Format(PyExc_TypeError,
10697	                             "expected type_num %d (NPY_FLOAT64) got %d",
10698	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V103));
10699	                {
10700	        __failure = 104;
10701	        if (!PyErr_Occurred()) {
10702	            PyErr_SetString(PyExc_RuntimeError,
10703	                "Unexpected error in an Op's C code. "
10704	                "No Python exception was set.");
10705	            }
10706	        goto __label_104;}
10707	            }
10708	            
10709	        V103 = (PyArrayObject*)(py_V103);
10710	        Py_XINCREF(V103);
10711	        
10712	{
10713	
10714	    py_V105 = PyList_GET_ITEM(storage_V105, 0);
10715	    {Py_XINCREF(py_V105);}
10716	    
10717	            V105 = NULL;
10718	            if (py_V105 == Py_None) {
10719	                // We can either fail here or set V105 to NULL and rely on Ops
10720	                // using tensors to handle the NULL case, but if they fail to do so
10721	                // they'll end up with nasty segfaults, so this is public service.
10722	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
10723	                {
10724	        __failure = 106;
10725	        if (!PyErr_Occurred()) {
10726	            PyErr_SetString(PyExc_RuntimeError,
10727	                "Unexpected error in an Op's C code. "
10728	                "No Python exception was set.");
10729	            }
10730	        goto __label_106;}
10731	            }
10732	            if (!PyArray_Check(py_V105)) {
10733	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
10734	                {
10735	        __failure = 106;
10736	        if (!PyErr_Occurred()) {
10737	            PyErr_SetString(PyExc_RuntimeError,
10738	                "Unexpected error in an Op's C code. "
10739	                "No Python exception was set.");
10740	            }
10741	        goto __label_106;}
10742	            }
10743	            // We expect NPY_FLOAT64
10744	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V105)) {
10745	                PyArrayObject * tmp = (PyArrayObject*) py_V105;
10746	                PyErr_Format(PyExc_NotImplementedError,
10747	                             "expected an aligned array of type %ld "
10748	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
10749	                             " with %ld dimensions, with 3 last dims "
10750	                             "%ld, %ld, %ld"
10751	                             " and 3 last strides %ld %ld, %ld.",
10752	                             (long int) NPY_FLOAT64,
10753	                             (long int) PyArray_TYPE((PyArrayObject*) py_V105),
10754	                             (long int) PyArray_NDIM(tmp),
10755	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
10756	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
10757	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
10758	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
10759	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
10760	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
10761	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
10762	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
10763	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
10764	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
10765	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
10766	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
10767	            );
10768	                {
10769	        __failure = 106;
10770	        if (!PyErr_Occurred()) {
10771	            PyErr_SetString(PyExc_RuntimeError,
10772	                "Unexpected error in an Op's C code. "
10773	                "No Python exception was set.");
10774	            }
10775	        goto __label_106;}
10776	            }
10777	            // This is a TypeError to be consistent with DEBUG_MODE
10778	            // Note: DEBUG_MODE also tells the name of the container
10779	            if (PyArray_TYPE((PyArrayObject*) py_V105) != NPY_FLOAT64) {
10780	                PyErr_Format(PyExc_TypeError,
10781	                             "expected type_num %d (NPY_FLOAT64) got %d",
10782	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V105));
10783	                {
10784	        __failure = 106;
10785	        if (!PyErr_Occurred()) {
10786	            PyErr_SetString(PyExc_RuntimeError,
10787	                "Unexpected error in an Op's C code. "
10788	                "No Python exception was set.");
10789	            }
10790	        goto __label_106;}
10791	            }
10792	            
10793	        V105 = (PyArrayObject*)(py_V105);
10794	        Py_XINCREF(V105);
10795	        
10796	{
10797	
10798	    py_V107 = PyList_GET_ITEM(storage_V107, 0);
10799	    {Py_XINCREF(py_V107);}
10800	    
10801	            V107 = NULL;
10802	            if (py_V107 == Py_None) {
10803	                // We can either fail here or set V107 to NULL and rely on Ops
10804	                // using tensors to handle the NULL case, but if they fail to do so
10805	                // they'll end up with nasty segfaults, so this is public service.
10806	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
10807	                {
10808	        __failure = 108;
10809	        if (!PyErr_Occurred()) {
10810	            PyErr_SetString(PyExc_RuntimeError,
10811	                "Unexpected error in an Op's C code. "
10812	                "No Python exception was set.");
10813	            }
10814	        goto __label_108;}
10815	            }
10816	            if (!PyArray_Check(py_V107)) {
10817	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
10818	                {
10819	        __failure = 108;
10820	        if (!PyErr_Occurred()) {
10821	            PyErr_SetString(PyExc_RuntimeError,
10822	                "Unexpected error in an Op's C code. "
10823	                "No Python exception was set.");
10824	            }
10825	        goto __label_108;}
10826	            }
10827	            // We expect NPY_FLOAT64
10828	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V107)) {
10829	                PyArrayObject * tmp = (PyArrayObject*) py_V107;
10830	                PyErr_Format(PyExc_NotImplementedError,
10831	                             "expected an aligned array of type %ld "
10832	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
10833	                             " with %ld dimensions, with 3 last dims "
10834	                             "%ld, %ld, %ld"
10835	                             " and 3 last strides %ld %ld, %ld.",
10836	                             (long int) NPY_FLOAT64,
10837	                             (long int) PyArray_TYPE((PyArrayObject*) py_V107),
10838	                             (long int) PyArray_NDIM(tmp),
10839	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
10840	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
10841	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
10842	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
10843	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
10844	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
10845	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
10846	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
10847	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
10848	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
10849	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
10850	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
10851	            );
10852	                {
10853	        __failure = 108;
10854	        if (!PyErr_Occurred()) {
10855	            PyErr_SetString(PyExc_RuntimeError,
10856	                "Unexpected error in an Op's C code. "
10857	                "No Python exception was set.");
10858	            }
10859	        goto __label_108;}
10860	            }
10861	            // This is a TypeError to be consistent with DEBUG_MODE
10862	            // Note: DEBUG_MODE also tells the name of the container
10863	            if (PyArray_TYPE((PyArrayObject*) py_V107) != NPY_FLOAT64) {
10864	                PyErr_Format(PyExc_TypeError,
10865	                             "expected type_num %d (NPY_FLOAT64) got %d",
10866	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V107));
10867	                {
10868	        __failure = 108;
10869	        if (!PyErr_Occurred()) {
10870	            PyErr_SetString(PyExc_RuntimeError,
10871	                "Unexpected error in an Op's C code. "
10872	                "No Python exception was set.");
10873	            }
10874	        goto __label_108;}
10875	            }
10876	            
10877	        V107 = (PyArrayObject*)(py_V107);
10878	        Py_XINCREF(V107);
10879	        
10880	{
10881	
10882	    py_V109 = PyList_GET_ITEM(storage_V109, 0);
10883	    {Py_XINCREF(py_V109);}
10884	    
10885	            V109 = NULL;
10886	            if (py_V109 == Py_None) {
10887	                // We can either fail here or set V109 to NULL and rely on Ops
10888	                // using tensors to handle the NULL case, but if they fail to do so
10889	                // they'll end up with nasty segfaults, so this is public service.
10890	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
10891	                {
10892	        __failure = 110;
10893	        if (!PyErr_Occurred()) {
10894	            PyErr_SetString(PyExc_RuntimeError,
10895	                "Unexpected error in an Op's C code. "
10896	                "No Python exception was set.");
10897	            }
10898	        goto __label_110;}
10899	            }
10900	            if (!PyArray_Check(py_V109)) {
10901	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
10902	                {
10903	        __failure = 110;
10904	        if (!PyErr_Occurred()) {
10905	            PyErr_SetString(PyExc_RuntimeError,
10906	                "Unexpected error in an Op's C code. "
10907	                "No Python exception was set.");
10908	            }
10909	        goto __label_110;}
10910	            }
10911	            // We expect NPY_FLOAT64
10912	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V109)) {
10913	                PyArrayObject * tmp = (PyArrayObject*) py_V109;
10914	                PyErr_Format(PyExc_NotImplementedError,
10915	                             "expected an aligned array of type %ld "
10916	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
10917	                             " with %ld dimensions, with 3 last dims "
10918	                             "%ld, %ld, %ld"
10919	                             " and 3 last strides %ld %ld, %ld.",
10920	                             (long int) NPY_FLOAT64,
10921	                             (long int) PyArray_TYPE((PyArrayObject*) py_V109),
10922	                             (long int) PyArray_NDIM(tmp),
10923	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
10924	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
10925	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
10926	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
10927	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
10928	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
10929	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
10930	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
10931	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
10932	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
10933	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
10934	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
10935	            );
10936	                {
10937	        __failure = 110;
10938	        if (!PyErr_Occurred()) {
10939	            PyErr_SetString(PyExc_RuntimeError,
10940	                "Unexpected error in an Op's C code. "
10941	                "No Python exception was set.");
10942	            }
10943	        goto __label_110;}
10944	            }
10945	            // This is a TypeError to be consistent with DEBUG_MODE
10946	            // Note: DEBUG_MODE also tells the name of the container
10947	            if (PyArray_TYPE((PyArrayObject*) py_V109) != NPY_FLOAT64) {
10948	                PyErr_Format(PyExc_TypeError,
10949	                             "expected type_num %d (NPY_FLOAT64) got %d",
10950	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V109));
10951	                {
10952	        __failure = 110;
10953	        if (!PyErr_Occurred()) {
10954	            PyErr_SetString(PyExc_RuntimeError,
10955	                "Unexpected error in an Op's C code. "
10956	                "No Python exception was set.");
10957	            }
10958	        goto __label_110;}
10959	            }
10960	            
10961	        V109 = (PyArrayObject*)(py_V109);
10962	        Py_XINCREF(V109);
10963	        
10964	{
10965	
10966	    py_V111 = PyList_GET_ITEM(storage_V111, 0);
10967	    {Py_XINCREF(py_V111);}
10968	    
10969	            V111 = NULL;
10970	            if (py_V111 == Py_None) {
10971	                // We can either fail here or set V111 to NULL and rely on Ops
10972	                // using tensors to handle the NULL case, but if they fail to do so
10973	                // they'll end up with nasty segfaults, so this is public service.
10974	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
10975	                {
10976	        __failure = 112;
10977	        if (!PyErr_Occurred()) {
10978	            PyErr_SetString(PyExc_RuntimeError,
10979	                "Unexpected error in an Op's C code. "
10980	                "No Python exception was set.");
10981	            }
10982	        goto __label_112;}
10983	            }
10984	            if (!PyArray_Check(py_V111)) {
10985	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
10986	                {
10987	        __failure = 112;
10988	        if (!PyErr_Occurred()) {
10989	            PyErr_SetString(PyExc_RuntimeError,
10990	                "Unexpected error in an Op's C code. "
10991	                "No Python exception was set.");
10992	            }
10993	        goto __label_112;}
10994	            }
10995	            // We expect NPY_FLOAT64
10996	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V111)) {
10997	                PyArrayObject * tmp = (PyArrayObject*) py_V111;
10998	                PyErr_Format(PyExc_NotImplementedError,
10999	                             "expected an aligned array of type %ld "
11000	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
11001	                             " with %ld dimensions, with 3 last dims "
11002	                             "%ld, %ld, %ld"
11003	                             " and 3 last strides %ld %ld, %ld.",
11004	                             (long int) NPY_FLOAT64,
11005	                             (long int) PyArray_TYPE((PyArrayObject*) py_V111),
11006	                             (long int) PyArray_NDIM(tmp),
11007	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
11008	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
11009	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
11010	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
11011	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
11012	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
11013	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
11014	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
11015	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
11016	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
11017	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
11018	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
11019	            );
11020	                {
11021	        __failure = 112;
11022	        if (!PyErr_Occurred()) {
11023	            PyErr_SetString(PyExc_RuntimeError,
11024	                "Unexpected error in an Op's C code. "
11025	                "No Python exception was set.");
11026	            }
11027	        goto __label_112;}
11028	            }
11029	            // This is a TypeError to be consistent with DEBUG_MODE
11030	            // Note: DEBUG_MODE also tells the name of the container
11031	            if (PyArray_TYPE((PyArrayObject*) py_V111) != NPY_FLOAT64) {
11032	                PyErr_Format(PyExc_TypeError,
11033	                             "expected type_num %d (NPY_FLOAT64) got %d",
11034	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V111));
11035	                {
11036	        __failure = 112;
11037	        if (!PyErr_Occurred()) {
11038	            PyErr_SetString(PyExc_RuntimeError,
11039	                "Unexpected error in an Op's C code. "
11040	                "No Python exception was set.");
11041	            }
11042	        goto __label_112;}
11043	            }
11044	            
11045	        V111 = (PyArrayObject*)(py_V111);
11046	        Py_XINCREF(V111);
11047	        
11048	{
11049	
11050	    py_V113 = PyList_GET_ITEM(storage_V113, 0);
11051	    {Py_XINCREF(py_V113);}
11052	    
11053	            V113 = NULL;
11054	            if (py_V113 == Py_None) {
11055	                // We can either fail here or set V113 to NULL and rely on Ops
11056	                // using tensors to handle the NULL case, but if they fail to do so
11057	                // they'll end up with nasty segfaults, so this is public service.
11058	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
11059	                {
11060	        __failure = 114;
11061	        if (!PyErr_Occurred()) {
11062	            PyErr_SetString(PyExc_RuntimeError,
11063	                "Unexpected error in an Op's C code. "
11064	                "No Python exception was set.");
11065	            }
11066	        goto __label_114;}
11067	            }
11068	            if (!PyArray_Check(py_V113)) {
11069	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
11070	                {
11071	        __failure = 114;
11072	        if (!PyErr_Occurred()) {
11073	            PyErr_SetString(PyExc_RuntimeError,
11074	                "Unexpected error in an Op's C code. "
11075	                "No Python exception was set.");
11076	            }
11077	        goto __label_114;}
11078	            }
11079	            // We expect NPY_FLOAT64
11080	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V113)) {
11081	                PyArrayObject * tmp = (PyArrayObject*) py_V113;
11082	                PyErr_Format(PyExc_NotImplementedError,
11083	                             "expected an aligned array of type %ld "
11084	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
11085	                             " with %ld dimensions, with 3 last dims "
11086	                             "%ld, %ld, %ld"
11087	                             " and 3 last strides %ld %ld, %ld.",
11088	                             (long int) NPY_FLOAT64,
11089	                             (long int) PyArray_TYPE((PyArrayObject*) py_V113),
11090	                             (long int) PyArray_NDIM(tmp),
11091	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
11092	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
11093	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
11094	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
11095	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
11096	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
11097	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
11098	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
11099	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
11100	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
11101	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
11102	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
11103	            );
11104	                {
11105	        __failure = 114;
11106	        if (!PyErr_Occurred()) {
11107	            PyErr_SetString(PyExc_RuntimeError,
11108	                "Unexpected error in an Op's C code. "
11109	                "No Python exception was set.");
11110	            }
11111	        goto __label_114;}
11112	            }
11113	            // This is a TypeError to be consistent with DEBUG_MODE
11114	            // Note: DEBUG_MODE also tells the name of the container
11115	            if (PyArray_TYPE((PyArrayObject*) py_V113) != NPY_FLOAT64) {
11116	                PyErr_Format(PyExc_TypeError,
11117	                             "expected type_num %d (NPY_FLOAT64) got %d",
11118	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V113));
11119	                {
11120	        __failure = 114;
11121	        if (!PyErr_Occurred()) {
11122	            PyErr_SetString(PyExc_RuntimeError,
11123	                "Unexpected error in an Op's C code. "
11124	                "No Python exception was set.");
11125	            }
11126	        goto __label_114;}
11127	            }
11128	            
11129	        V113 = (PyArrayObject*)(py_V113);
11130	        Py_XINCREF(V113);
11131	        
11132	{
11133	
11134	    py_V115 = PyList_GET_ITEM(storage_V115, 0);
11135	    {Py_XINCREF(py_V115);}
11136	    
11137	            V115 = NULL;
11138	            if (py_V115 == Py_None) {
11139	                // We can either fail here or set V115 to NULL and rely on Ops
11140	                // using tensors to handle the NULL case, but if they fail to do so
11141	                // they'll end up with nasty segfaults, so this is public service.
11142	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
11143	                {
11144	        __failure = 116;
11145	        if (!PyErr_Occurred()) {
11146	            PyErr_SetString(PyExc_RuntimeError,
11147	                "Unexpected error in an Op's C code. "
11148	                "No Python exception was set.");
11149	            }
11150	        goto __label_116;}
11151	            }
11152	            if (!PyArray_Check(py_V115)) {
11153	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
11154	                {
11155	        __failure = 116;
11156	        if (!PyErr_Occurred()) {
11157	            PyErr_SetString(PyExc_RuntimeError,
11158	                "Unexpected error in an Op's C code. "
11159	                "No Python exception was set.");
11160	            }
11161	        goto __label_116;}
11162	            }
11163	            // We expect NPY_FLOAT64
11164	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V115)) {
11165	                PyArrayObject * tmp = (PyArrayObject*) py_V115;
11166	                PyErr_Format(PyExc_NotImplementedError,
11167	                             "expected an aligned array of type %ld "
11168	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
11169	                             " with %ld dimensions, with 3 last dims "
11170	                             "%ld, %ld, %ld"
11171	                             " and 3 last strides %ld %ld, %ld.",
11172	                             (long int) NPY_FLOAT64,
11173	                             (long int) PyArray_TYPE((PyArrayObject*) py_V115),
11174	                             (long int) PyArray_NDIM(tmp),
11175	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
11176	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
11177	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
11178	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
11179	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
11180	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
11181	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
11182	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
11183	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
11184	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
11185	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
11186	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
11187	            );
11188	                {
11189	        __failure = 116;
11190	        if (!PyErr_Occurred()) {
11191	            PyErr_SetString(PyExc_RuntimeError,
11192	                "Unexpected error in an Op's C code. "
11193	                "No Python exception was set.");
11194	            }
11195	        goto __label_116;}
11196	            }
11197	            // This is a TypeError to be consistent with DEBUG_MODE
11198	            // Note: DEBUG_MODE also tells the name of the container
11199	            if (PyArray_TYPE((PyArrayObject*) py_V115) != NPY_FLOAT64) {
11200	                PyErr_Format(PyExc_TypeError,
11201	                             "expected type_num %d (NPY_FLOAT64) got %d",
11202	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V115));
11203	                {
11204	        __failure = 116;
11205	        if (!PyErr_Occurred()) {
11206	            PyErr_SetString(PyExc_RuntimeError,
11207	                "Unexpected error in an Op's C code. "
11208	                "No Python exception was set.");
11209	            }
11210	        goto __label_116;}
11211	            }
11212	            
11213	        V115 = (PyArrayObject*)(py_V115);
11214	        Py_XINCREF(V115);
11215	        
11216	{
11217	
11218	    py_V117 = PyList_GET_ITEM(storage_V117, 0);
11219	    {Py_XINCREF(py_V117);}
11220	    
11221	            V117 = NULL;
11222	            if (py_V117 == Py_None) {
11223	                // We can either fail here or set V117 to NULL and rely on Ops
11224	                // using tensors to handle the NULL case, but if they fail to do so
11225	                // they'll end up with nasty segfaults, so this is public service.
11226	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
11227	                {
11228	        __failure = 118;
11229	        if (!PyErr_Occurred()) {
11230	            PyErr_SetString(PyExc_RuntimeError,
11231	                "Unexpected error in an Op's C code. "
11232	                "No Python exception was set.");
11233	            }
11234	        goto __label_118;}
11235	            }
11236	            if (!PyArray_Check(py_V117)) {
11237	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
11238	                {
11239	        __failure = 118;
11240	        if (!PyErr_Occurred()) {
11241	            PyErr_SetString(PyExc_RuntimeError,
11242	                "Unexpected error in an Op's C code. "
11243	                "No Python exception was set.");
11244	            }
11245	        goto __label_118;}
11246	            }
11247	            // We expect NPY_FLOAT64
11248	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V117)) {
11249	                PyArrayObject * tmp = (PyArrayObject*) py_V117;
11250	                PyErr_Format(PyExc_NotImplementedError,
11251	                             "expected an aligned array of type %ld "
11252	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
11253	                             " with %ld dimensions, with 3 last dims "
11254	                             "%ld, %ld, %ld"
11255	                             " and 3 last strides %ld %ld, %ld.",
11256	                             (long int) NPY_FLOAT64,
11257	                             (long int) PyArray_TYPE((PyArrayObject*) py_V117),
11258	                             (long int) PyArray_NDIM(tmp),
11259	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
11260	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
11261	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
11262	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
11263	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
11264	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
11265	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
11266	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
11267	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
11268	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
11269	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
11270	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
11271	            );
11272	                {
11273	        __failure = 118;
11274	        if (!PyErr_Occurred()) {
11275	            PyErr_SetString(PyExc_RuntimeError,
11276	                "Unexpected error in an Op's C code. "
11277	                "No Python exception was set.");
11278	            }
11279	        goto __label_118;}
11280	            }
11281	            // This is a TypeError to be consistent with DEBUG_MODE
11282	            // Note: DEBUG_MODE also tells the name of the container
11283	            if (PyArray_TYPE((PyArrayObject*) py_V117) != NPY_FLOAT64) {
11284	                PyErr_Format(PyExc_TypeError,
11285	                             "expected type_num %d (NPY_FLOAT64) got %d",
11286	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V117));
11287	                {
11288	        __failure = 118;
11289	        if (!PyErr_Occurred()) {
11290	            PyErr_SetString(PyExc_RuntimeError,
11291	                "Unexpected error in an Op's C code. "
11292	                "No Python exception was set.");
11293	            }
11294	        goto __label_118;}
11295	            }
11296	            
11297	        V117 = (PyArrayObject*)(py_V117);
11298	        Py_XINCREF(V117);
11299	        
11300	{
11301	
11302	    py_V119 = PyList_GET_ITEM(storage_V119, 0);
11303	    {Py_XINCREF(py_V119);}
11304	    
11305	            V119 = NULL;
11306	            if (py_V119 == Py_None) {
11307	                // We can either fail here or set V119 to NULL and rely on Ops
11308	                // using tensors to handle the NULL case, but if they fail to do so
11309	                // they'll end up with nasty segfaults, so this is public service.
11310	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
11311	                {
11312	        __failure = 120;
11313	        if (!PyErr_Occurred()) {
11314	            PyErr_SetString(PyExc_RuntimeError,
11315	                "Unexpected error in an Op's C code. "
11316	                "No Python exception was set.");
11317	            }
11318	        goto __label_120;}
11319	            }
11320	            if (!PyArray_Check(py_V119)) {
11321	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
11322	                {
11323	        __failure = 120;
11324	        if (!PyErr_Occurred()) {
11325	            PyErr_SetString(PyExc_RuntimeError,
11326	                "Unexpected error in an Op's C code. "
11327	                "No Python exception was set.");
11328	            }
11329	        goto __label_120;}
11330	            }
11331	            // We expect NPY_FLOAT64
11332	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V119)) {
11333	                PyArrayObject * tmp = (PyArrayObject*) py_V119;
11334	                PyErr_Format(PyExc_NotImplementedError,
11335	                             "expected an aligned array of type %ld "
11336	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
11337	                             " with %ld dimensions, with 3 last dims "
11338	                             "%ld, %ld, %ld"
11339	                             " and 3 last strides %ld %ld, %ld.",
11340	                             (long int) NPY_FLOAT64,
11341	                             (long int) PyArray_TYPE((PyArrayObject*) py_V119),
11342	                             (long int) PyArray_NDIM(tmp),
11343	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
11344	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
11345	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
11346	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
11347	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
11348	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
11349	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
11350	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
11351	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
11352	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
11353	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
11354	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
11355	            );
11356	                {
11357	        __failure = 120;
11358	        if (!PyErr_Occurred()) {
11359	            PyErr_SetString(PyExc_RuntimeError,
11360	                "Unexpected error in an Op's C code. "
11361	                "No Python exception was set.");
11362	            }
11363	        goto __label_120;}
11364	            }
11365	            // This is a TypeError to be consistent with DEBUG_MODE
11366	            // Note: DEBUG_MODE also tells the name of the container
11367	            if (PyArray_TYPE((PyArrayObject*) py_V119) != NPY_FLOAT64) {
11368	                PyErr_Format(PyExc_TypeError,
11369	                             "expected type_num %d (NPY_FLOAT64) got %d",
11370	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V119));
11371	                {
11372	        __failure = 120;
11373	        if (!PyErr_Occurred()) {
11374	            PyErr_SetString(PyExc_RuntimeError,
11375	                "Unexpected error in an Op's C code. "
11376	                "No Python exception was set.");
11377	            }
11378	        goto __label_120;}
11379	            }
11380	            
11381	        V119 = (PyArrayObject*)(py_V119);
11382	        Py_XINCREF(V119);
11383	        
11384	{
11385	
11386	    py_V121 = PyList_GET_ITEM(storage_V121, 0);
11387	    {Py_XINCREF(py_V121);}
11388	    
11389	            V121 = NULL;
11390	            if (py_V121 == Py_None) {
11391	                // We can either fail here or set V121 to NULL and rely on Ops
11392	                // using tensors to handle the NULL case, but if they fail to do so
11393	                // they'll end up with nasty segfaults, so this is public service.
11394	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
11395	                {
11396	        __failure = 122;
11397	        if (!PyErr_Occurred()) {
11398	            PyErr_SetString(PyExc_RuntimeError,
11399	                "Unexpected error in an Op's C code. "
11400	                "No Python exception was set.");
11401	            }
11402	        goto __label_122;}
11403	            }
11404	            if (!PyArray_Check(py_V121)) {
11405	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
11406	                {
11407	        __failure = 122;
11408	        if (!PyErr_Occurred()) {
11409	            PyErr_SetString(PyExc_RuntimeError,
11410	                "Unexpected error in an Op's C code. "
11411	                "No Python exception was set.");
11412	            }
11413	        goto __label_122;}
11414	            }
11415	            // We expect NPY_FLOAT64
11416	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V121)) {
11417	                PyArrayObject * tmp = (PyArrayObject*) py_V121;
11418	                PyErr_Format(PyExc_NotImplementedError,
11419	                             "expected an aligned array of type %ld "
11420	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
11421	                             " with %ld dimensions, with 3 last dims "
11422	                             "%ld, %ld, %ld"
11423	                             " and 3 last strides %ld %ld, %ld.",
11424	                             (long int) NPY_FLOAT64,
11425	                             (long int) PyArray_TYPE((PyArrayObject*) py_V121),
11426	                             (long int) PyArray_NDIM(tmp),
11427	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
11428	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
11429	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
11430	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
11431	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
11432	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
11433	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
11434	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
11435	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
11436	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
11437	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
11438	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
11439	            );
11440	                {
11441	        __failure = 122;
11442	        if (!PyErr_Occurred()) {
11443	            PyErr_SetString(PyExc_RuntimeError,
11444	                "Unexpected error in an Op's C code. "
11445	                "No Python exception was set.");
11446	            }
11447	        goto __label_122;}
11448	            }
11449	            // This is a TypeError to be consistent with DEBUG_MODE
11450	            // Note: DEBUG_MODE also tells the name of the container
11451	            if (PyArray_TYPE((PyArrayObject*) py_V121) != NPY_FLOAT64) {
11452	                PyErr_Format(PyExc_TypeError,
11453	                             "expected type_num %d (NPY_FLOAT64) got %d",
11454	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V121));
11455	                {
11456	        __failure = 122;
11457	        if (!PyErr_Occurred()) {
11458	            PyErr_SetString(PyExc_RuntimeError,
11459	                "Unexpected error in an Op's C code. "
11460	                "No Python exception was set.");
11461	            }
11462	        goto __label_122;}
11463	            }
11464	            
11465	        V121 = (PyArrayObject*)(py_V121);
11466	        Py_XINCREF(V121);
11467	        
11468	{
11469	
11470	    py_V123 = PyList_GET_ITEM(storage_V123, 0);
11471	    {Py_XINCREF(py_V123);}
11472	    
11473	            V123 = NULL;
11474	            if (py_V123 == Py_None) {
11475	                // We can either fail here or set V123 to NULL and rely on Ops
11476	                // using tensors to handle the NULL case, but if they fail to do so
11477	                // they'll end up with nasty segfaults, so this is public service.
11478	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
11479	                {
11480	        __failure = 124;
11481	        if (!PyErr_Occurred()) {
11482	            PyErr_SetString(PyExc_RuntimeError,
11483	                "Unexpected error in an Op's C code. "
11484	                "No Python exception was set.");
11485	            }
11486	        goto __label_124;}
11487	            }
11488	            if (!PyArray_Check(py_V123)) {
11489	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
11490	                {
11491	        __failure = 124;
11492	        if (!PyErr_Occurred()) {
11493	            PyErr_SetString(PyExc_RuntimeError,
11494	                "Unexpected error in an Op's C code. "
11495	                "No Python exception was set.");
11496	            }
11497	        goto __label_124;}
11498	            }
11499	            // We expect NPY_FLOAT64
11500	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V123)) {
11501	                PyArrayObject * tmp = (PyArrayObject*) py_V123;
11502	                PyErr_Format(PyExc_NotImplementedError,
11503	                             "expected an aligned array of type %ld "
11504	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
11505	                             " with %ld dimensions, with 3 last dims "
11506	                             "%ld, %ld, %ld"
11507	                             " and 3 last strides %ld %ld, %ld.",
11508	                             (long int) NPY_FLOAT64,
11509	                             (long int) PyArray_TYPE((PyArrayObject*) py_V123),
11510	                             (long int) PyArray_NDIM(tmp),
11511	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
11512	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
11513	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
11514	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
11515	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
11516	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
11517	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
11518	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
11519	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
11520	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
11521	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
11522	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
11523	            );
11524	                {
11525	        __failure = 124;
11526	        if (!PyErr_Occurred()) {
11527	            PyErr_SetString(PyExc_RuntimeError,
11528	                "Unexpected error in an Op's C code. "
11529	                "No Python exception was set.");
11530	            }
11531	        goto __label_124;}
11532	            }
11533	            // This is a TypeError to be consistent with DEBUG_MODE
11534	            // Note: DEBUG_MODE also tells the name of the container
11535	            if (PyArray_TYPE((PyArrayObject*) py_V123) != NPY_FLOAT64) {
11536	                PyErr_Format(PyExc_TypeError,
11537	                             "expected type_num %d (NPY_FLOAT64) got %d",
11538	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V123));
11539	                {
11540	        __failure = 124;
11541	        if (!PyErr_Occurred()) {
11542	            PyErr_SetString(PyExc_RuntimeError,
11543	                "Unexpected error in an Op's C code. "
11544	                "No Python exception was set.");
11545	            }
11546	        goto __label_124;}
11547	            }
11548	            
11549	        V123 = (PyArrayObject*)(py_V123);
11550	        Py_XINCREF(V123);
11551	        
11552	{
11553	
11554	    py_V125 = PyList_GET_ITEM(storage_V125, 0);
11555	    {Py_XINCREF(py_V125);}
11556	    
11557	            V125 = NULL;
11558	            if (py_V125 == Py_None) {
11559	                // We can either fail here or set V125 to NULL and rely on Ops
11560	                // using tensors to handle the NULL case, but if they fail to do so
11561	                // they'll end up with nasty segfaults, so this is public service.
11562	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
11563	                {
11564	        __failure = 126;
11565	        if (!PyErr_Occurred()) {
11566	            PyErr_SetString(PyExc_RuntimeError,
11567	                "Unexpected error in an Op's C code. "
11568	                "No Python exception was set.");
11569	            }
11570	        goto __label_126;}
11571	            }
11572	            if (!PyArray_Check(py_V125)) {
11573	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
11574	                {
11575	        __failure = 126;
11576	        if (!PyErr_Occurred()) {
11577	            PyErr_SetString(PyExc_RuntimeError,
11578	                "Unexpected error in an Op's C code. "
11579	                "No Python exception was set.");
11580	            }
11581	        goto __label_126;}
11582	            }
11583	            // We expect NPY_FLOAT64
11584	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V125)) {
11585	                PyArrayObject * tmp = (PyArrayObject*) py_V125;
11586	                PyErr_Format(PyExc_NotImplementedError,
11587	                             "expected an aligned array of type %ld "
11588	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
11589	                             " with %ld dimensions, with 3 last dims "
11590	                             "%ld, %ld, %ld"
11591	                             " and 3 last strides %ld %ld, %ld.",
11592	                             (long int) NPY_FLOAT64,
11593	                             (long int) PyArray_TYPE((PyArrayObject*) py_V125),
11594	                             (long int) PyArray_NDIM(tmp),
11595	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
11596	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
11597	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
11598	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
11599	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
11600	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
11601	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
11602	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
11603	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
11604	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
11605	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
11606	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
11607	            );
11608	                {
11609	        __failure = 126;
11610	        if (!PyErr_Occurred()) {
11611	            PyErr_SetString(PyExc_RuntimeError,
11612	                "Unexpected error in an Op's C code. "
11613	                "No Python exception was set.");
11614	            }
11615	        goto __label_126;}
11616	            }
11617	            // This is a TypeError to be consistent with DEBUG_MODE
11618	            // Note: DEBUG_MODE also tells the name of the container
11619	            if (PyArray_TYPE((PyArrayObject*) py_V125) != NPY_FLOAT64) {
11620	                PyErr_Format(PyExc_TypeError,
11621	                             "expected type_num %d (NPY_FLOAT64) got %d",
11622	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V125));
11623	                {
11624	        __failure = 126;
11625	        if (!PyErr_Occurred()) {
11626	            PyErr_SetString(PyExc_RuntimeError,
11627	                "Unexpected error in an Op's C code. "
11628	                "No Python exception was set.");
11629	            }
11630	        goto __label_126;}
11631	            }
11632	            
11633	        V125 = (PyArrayObject*)(py_V125);
11634	        Py_XINCREF(V125);
11635	        
11636	{
11637	
11638	    py_V127 = PyList_GET_ITEM(storage_V127, 0);
11639	    {Py_XINCREF(py_V127);}
11640	    
11641	            V127 = NULL;
11642	            if (py_V127 == Py_None) {
11643	                // We can either fail here or set V127 to NULL and rely on Ops
11644	                // using tensors to handle the NULL case, but if they fail to do so
11645	                // they'll end up with nasty segfaults, so this is public service.
11646	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
11647	                {
11648	        __failure = 128;
11649	        if (!PyErr_Occurred()) {
11650	            PyErr_SetString(PyExc_RuntimeError,
11651	                "Unexpected error in an Op's C code. "
11652	                "No Python exception was set.");
11653	            }
11654	        goto __label_128;}
11655	            }
11656	            if (!PyArray_Check(py_V127)) {
11657	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
11658	                {
11659	        __failure = 128;
11660	        if (!PyErr_Occurred()) {
11661	            PyErr_SetString(PyExc_RuntimeError,
11662	                "Unexpected error in an Op's C code. "
11663	                "No Python exception was set.");
11664	            }
11665	        goto __label_128;}
11666	            }
11667	            // We expect NPY_FLOAT64
11668	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V127)) {
11669	                PyArrayObject * tmp = (PyArrayObject*) py_V127;
11670	                PyErr_Format(PyExc_NotImplementedError,
11671	                             "expected an aligned array of type %ld "
11672	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
11673	                             " with %ld dimensions, with 3 last dims "
11674	                             "%ld, %ld, %ld"
11675	                             " and 3 last strides %ld %ld, %ld.",
11676	                             (long int) NPY_FLOAT64,
11677	                             (long int) PyArray_TYPE((PyArrayObject*) py_V127),
11678	                             (long int) PyArray_NDIM(tmp),
11679	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
11680	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
11681	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
11682	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
11683	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
11684	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
11685	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
11686	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
11687	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
11688	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
11689	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
11690	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
11691	            );
11692	                {
11693	        __failure = 128;
11694	        if (!PyErr_Occurred()) {
11695	            PyErr_SetString(PyExc_RuntimeError,
11696	                "Unexpected error in an Op's C code. "
11697	                "No Python exception was set.");
11698	            }
11699	        goto __label_128;}
11700	            }
11701	            // This is a TypeError to be consistent with DEBUG_MODE
11702	            // Note: DEBUG_MODE also tells the name of the container
11703	            if (PyArray_TYPE((PyArrayObject*) py_V127) != NPY_FLOAT64) {
11704	                PyErr_Format(PyExc_TypeError,
11705	                             "expected type_num %d (NPY_FLOAT64) got %d",
11706	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V127));
11707	                {
11708	        __failure = 128;
11709	        if (!PyErr_Occurred()) {
11710	            PyErr_SetString(PyExc_RuntimeError,
11711	                "Unexpected error in an Op's C code. "
11712	                "No Python exception was set.");
11713	            }
11714	        goto __label_128;}
11715	            }
11716	            
11717	        V127 = (PyArrayObject*)(py_V127);
11718	        Py_XINCREF(V127);
11719	        
11720	{
11721	
11722	    py_V129 = PyList_GET_ITEM(storage_V129, 0);
11723	    {Py_XINCREF(py_V129);}
11724	    
11725	            V129 = NULL;
11726	            if (py_V129 == Py_None) {
11727	                // We can either fail here or set V129 to NULL and rely on Ops
11728	                // using tensors to handle the NULL case, but if they fail to do so
11729	                // they'll end up with nasty segfaults, so this is public service.
11730	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
11731	                {
11732	        __failure = 130;
11733	        if (!PyErr_Occurred()) {
11734	            PyErr_SetString(PyExc_RuntimeError,
11735	                "Unexpected error in an Op's C code. "
11736	                "No Python exception was set.");
11737	            }
11738	        goto __label_130;}
11739	            }
11740	            if (!PyArray_Check(py_V129)) {
11741	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
11742	                {
11743	        __failure = 130;
11744	        if (!PyErr_Occurred()) {
11745	            PyErr_SetString(PyExc_RuntimeError,
11746	                "Unexpected error in an Op's C code. "
11747	                "No Python exception was set.");
11748	            }
11749	        goto __label_130;}
11750	            }
11751	            // We expect NPY_FLOAT64
11752	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V129)) {
11753	                PyArrayObject * tmp = (PyArrayObject*) py_V129;
11754	                PyErr_Format(PyExc_NotImplementedError,
11755	                             "expected an aligned array of type %ld "
11756	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
11757	                             " with %ld dimensions, with 3 last dims "
11758	                             "%ld, %ld, %ld"
11759	                             " and 3 last strides %ld %ld, %ld.",
11760	                             (long int) NPY_FLOAT64,
11761	                             (long int) PyArray_TYPE((PyArrayObject*) py_V129),
11762	                             (long int) PyArray_NDIM(tmp),
11763	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
11764	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
11765	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
11766	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
11767	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
11768	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
11769	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
11770	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
11771	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
11772	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
11773	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
11774	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
11775	            );
11776	                {
11777	        __failure = 130;
11778	        if (!PyErr_Occurred()) {
11779	            PyErr_SetString(PyExc_RuntimeError,
11780	                "Unexpected error in an Op's C code. "
11781	                "No Python exception was set.");
11782	            }
11783	        goto __label_130;}
11784	            }
11785	            // This is a TypeError to be consistent with DEBUG_MODE
11786	            // Note: DEBUG_MODE also tells the name of the container
11787	            if (PyArray_TYPE((PyArrayObject*) py_V129) != NPY_FLOAT64) {
11788	                PyErr_Format(PyExc_TypeError,
11789	                             "expected type_num %d (NPY_FLOAT64) got %d",
11790	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V129));
11791	                {
11792	        __failure = 130;
11793	        if (!PyErr_Occurred()) {
11794	            PyErr_SetString(PyExc_RuntimeError,
11795	                "Unexpected error in an Op's C code. "
11796	                "No Python exception was set.");
11797	            }
11798	        goto __label_130;}
11799	            }
11800	            
11801	        V129 = (PyArrayObject*)(py_V129);
11802	        Py_XINCREF(V129);
11803	        
11804	{
11805	
11806	    py_V131 = PyList_GET_ITEM(storage_V131, 0);
11807	    {Py_XINCREF(py_V131);}
11808	    
11809	            V131 = NULL;
11810	            if (py_V131 == Py_None) {
11811	                // We can either fail here or set V131 to NULL and rely on Ops
11812	                // using tensors to handle the NULL case, but if they fail to do so
11813	                // they'll end up with nasty segfaults, so this is public service.
11814	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
11815	                {
11816	        __failure = 132;
11817	        if (!PyErr_Occurred()) {
11818	            PyErr_SetString(PyExc_RuntimeError,
11819	                "Unexpected error in an Op's C code. "
11820	                "No Python exception was set.");
11821	            }
11822	        goto __label_132;}
11823	            }
11824	            if (!PyArray_Check(py_V131)) {
11825	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
11826	                {
11827	        __failure = 132;
11828	        if (!PyErr_Occurred()) {
11829	            PyErr_SetString(PyExc_RuntimeError,
11830	                "Unexpected error in an Op's C code. "
11831	                "No Python exception was set.");
11832	            }
11833	        goto __label_132;}
11834	            }
11835	            // We expect NPY_FLOAT64
11836	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V131)) {
11837	                PyArrayObject * tmp = (PyArrayObject*) py_V131;
11838	                PyErr_Format(PyExc_NotImplementedError,
11839	                             "expected an aligned array of type %ld "
11840	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
11841	                             " with %ld dimensions, with 3 last dims "
11842	                             "%ld, %ld, %ld"
11843	                             " and 3 last strides %ld %ld, %ld.",
11844	                             (long int) NPY_FLOAT64,
11845	                             (long int) PyArray_TYPE((PyArrayObject*) py_V131),
11846	                             (long int) PyArray_NDIM(tmp),
11847	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
11848	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
11849	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
11850	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
11851	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
11852	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
11853	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
11854	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
11855	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
11856	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
11857	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
11858	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
11859	            );
11860	                {
11861	        __failure = 132;
11862	        if (!PyErr_Occurred()) {
11863	            PyErr_SetString(PyExc_RuntimeError,
11864	                "Unexpected error in an Op's C code. "
11865	                "No Python exception was set.");
11866	            }
11867	        goto __label_132;}
11868	            }
11869	            // This is a TypeError to be consistent with DEBUG_MODE
11870	            // Note: DEBUG_MODE also tells the name of the container
11871	            if (PyArray_TYPE((PyArrayObject*) py_V131) != NPY_FLOAT64) {
11872	                PyErr_Format(PyExc_TypeError,
11873	                             "expected type_num %d (NPY_FLOAT64) got %d",
11874	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V131));
11875	                {
11876	        __failure = 132;
11877	        if (!PyErr_Occurred()) {
11878	            PyErr_SetString(PyExc_RuntimeError,
11879	                "Unexpected error in an Op's C code. "
11880	                "No Python exception was set.");
11881	            }
11882	        goto __label_132;}
11883	            }
11884	            
11885	        V131 = (PyArrayObject*)(py_V131);
11886	        Py_XINCREF(V131);
11887	        
11888	{
11889	
11890	    py_V133 = PyList_GET_ITEM(storage_V133, 0);
11891	    {Py_XINCREF(py_V133);}
11892	    
11893	            V133 = NULL;
11894	            if (py_V133 == Py_None) {
11895	                // We can either fail here or set V133 to NULL and rely on Ops
11896	                // using tensors to handle the NULL case, but if they fail to do so
11897	                // they'll end up with nasty segfaults, so this is public service.
11898	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
11899	                {
11900	        __failure = 134;
11901	        if (!PyErr_Occurred()) {
11902	            PyErr_SetString(PyExc_RuntimeError,
11903	                "Unexpected error in an Op's C code. "
11904	                "No Python exception was set.");
11905	            }
11906	        goto __label_134;}
11907	            }
11908	            if (!PyArray_Check(py_V133)) {
11909	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
11910	                {
11911	        __failure = 134;
11912	        if (!PyErr_Occurred()) {
11913	            PyErr_SetString(PyExc_RuntimeError,
11914	                "Unexpected error in an Op's C code. "
11915	                "No Python exception was set.");
11916	            }
11917	        goto __label_134;}
11918	            }
11919	            // We expect NPY_FLOAT64
11920	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V133)) {
11921	                PyArrayObject * tmp = (PyArrayObject*) py_V133;
11922	                PyErr_Format(PyExc_NotImplementedError,
11923	                             "expected an aligned array of type %ld "
11924	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
11925	                             " with %ld dimensions, with 3 last dims "
11926	                             "%ld, %ld, %ld"
11927	                             " and 3 last strides %ld %ld, %ld.",
11928	                             (long int) NPY_FLOAT64,
11929	                             (long int) PyArray_TYPE((PyArrayObject*) py_V133),
11930	                             (long int) PyArray_NDIM(tmp),
11931	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
11932	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
11933	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
11934	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
11935	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
11936	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
11937	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
11938	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
11939	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
11940	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
11941	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
11942	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
11943	            );
11944	                {
11945	        __failure = 134;
11946	        if (!PyErr_Occurred()) {
11947	            PyErr_SetString(PyExc_RuntimeError,
11948	                "Unexpected error in an Op's C code. "
11949	                "No Python exception was set.");
11950	            }
11951	        goto __label_134;}
11952	            }
11953	            // This is a TypeError to be consistent with DEBUG_MODE
11954	            // Note: DEBUG_MODE also tells the name of the container
11955	            if (PyArray_TYPE((PyArrayObject*) py_V133) != NPY_FLOAT64) {
11956	                PyErr_Format(PyExc_TypeError,
11957	                             "expected type_num %d (NPY_FLOAT64) got %d",
11958	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V133));
11959	                {
11960	        __failure = 134;
11961	        if (!PyErr_Occurred()) {
11962	            PyErr_SetString(PyExc_RuntimeError,
11963	                "Unexpected error in an Op's C code. "
11964	                "No Python exception was set.");
11965	            }
11966	        goto __label_134;}
11967	            }
11968	            
11969	        V133 = (PyArrayObject*)(py_V133);
11970	        Py_XINCREF(V133);
11971	        
11972	{
11973	
11974	    py_V135 = PyList_GET_ITEM(storage_V135, 0);
11975	    {Py_XINCREF(py_V135);}
11976	    
11977	            V135 = NULL;
11978	            if (py_V135 == Py_None) {
11979	                // We can either fail here or set V135 to NULL and rely on Ops
11980	                // using tensors to handle the NULL case, but if they fail to do so
11981	                // they'll end up with nasty segfaults, so this is public service.
11982	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
11983	                {
11984	        __failure = 136;
11985	        if (!PyErr_Occurred()) {
11986	            PyErr_SetString(PyExc_RuntimeError,
11987	                "Unexpected error in an Op's C code. "
11988	                "No Python exception was set.");
11989	            }
11990	        goto __label_136;}
11991	            }
11992	            if (!PyArray_Check(py_V135)) {
11993	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
11994	                {
11995	        __failure = 136;
11996	        if (!PyErr_Occurred()) {
11997	            PyErr_SetString(PyExc_RuntimeError,
11998	                "Unexpected error in an Op's C code. "
11999	                "No Python exception was set.");
12000	            }
12001	        goto __label_136;}
12002	            }
12003	            // We expect NPY_FLOAT64
12004	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V135)) {
12005	                PyArrayObject * tmp = (PyArrayObject*) py_V135;
12006	                PyErr_Format(PyExc_NotImplementedError,
12007	                             "expected an aligned array of type %ld "
12008	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
12009	                             " with %ld dimensions, with 3 last dims "
12010	                             "%ld, %ld, %ld"
12011	                             " and 3 last strides %ld %ld, %ld.",
12012	                             (long int) NPY_FLOAT64,
12013	                             (long int) PyArray_TYPE((PyArrayObject*) py_V135),
12014	                             (long int) PyArray_NDIM(tmp),
12015	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
12016	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
12017	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
12018	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
12019	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
12020	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
12021	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
12022	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
12023	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
12024	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
12025	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
12026	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
12027	            );
12028	                {
12029	        __failure = 136;
12030	        if (!PyErr_Occurred()) {
12031	            PyErr_SetString(PyExc_RuntimeError,
12032	                "Unexpected error in an Op's C code. "
12033	                "No Python exception was set.");
12034	            }
12035	        goto __label_136;}
12036	            }
12037	            // This is a TypeError to be consistent with DEBUG_MODE
12038	            // Note: DEBUG_MODE also tells the name of the container
12039	            if (PyArray_TYPE((PyArrayObject*) py_V135) != NPY_FLOAT64) {
12040	                PyErr_Format(PyExc_TypeError,
12041	                             "expected type_num %d (NPY_FLOAT64) got %d",
12042	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V135));
12043	                {
12044	        __failure = 136;
12045	        if (!PyErr_Occurred()) {
12046	            PyErr_SetString(PyExc_RuntimeError,
12047	                "Unexpected error in an Op's C code. "
12048	                "No Python exception was set.");
12049	            }
12050	        goto __label_136;}
12051	            }
12052	            
12053	        V135 = (PyArrayObject*)(py_V135);
12054	        Py_XINCREF(V135);
12055	        
12056	{
12057	
12058	    py_V137 = PyList_GET_ITEM(storage_V137, 0);
12059	    {Py_XINCREF(py_V137);}
12060	    
12061	            V137 = NULL;
12062	            if (py_V137 == Py_None) {
12063	                // We can either fail here or set V137 to NULL and rely on Ops
12064	                // using tensors to handle the NULL case, but if they fail to do so
12065	                // they'll end up with nasty segfaults, so this is public service.
12066	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
12067	                {
12068	        __failure = 138;
12069	        if (!PyErr_Occurred()) {
12070	            PyErr_SetString(PyExc_RuntimeError,
12071	                "Unexpected error in an Op's C code. "
12072	                "No Python exception was set.");
12073	            }
12074	        goto __label_138;}
12075	            }
12076	            if (!PyArray_Check(py_V137)) {
12077	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
12078	                {
12079	        __failure = 138;
12080	        if (!PyErr_Occurred()) {
12081	            PyErr_SetString(PyExc_RuntimeError,
12082	                "Unexpected error in an Op's C code. "
12083	                "No Python exception was set.");
12084	            }
12085	        goto __label_138;}
12086	            }
12087	            // We expect NPY_FLOAT64
12088	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V137)) {
12089	                PyArrayObject * tmp = (PyArrayObject*) py_V137;
12090	                PyErr_Format(PyExc_NotImplementedError,
12091	                             "expected an aligned array of type %ld "
12092	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
12093	                             " with %ld dimensions, with 3 last dims "
12094	                             "%ld, %ld, %ld"
12095	                             " and 3 last strides %ld %ld, %ld.",
12096	                             (long int) NPY_FLOAT64,
12097	                             (long int) PyArray_TYPE((PyArrayObject*) py_V137),
12098	                             (long int) PyArray_NDIM(tmp),
12099	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
12100	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
12101	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
12102	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
12103	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
12104	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
12105	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
12106	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
12107	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
12108	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
12109	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
12110	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
12111	            );
12112	                {
12113	        __failure = 138;
12114	        if (!PyErr_Occurred()) {
12115	            PyErr_SetString(PyExc_RuntimeError,
12116	                "Unexpected error in an Op's C code. "
12117	                "No Python exception was set.");
12118	            }
12119	        goto __label_138;}
12120	            }
12121	            // This is a TypeError to be consistent with DEBUG_MODE
12122	            // Note: DEBUG_MODE also tells the name of the container
12123	            if (PyArray_TYPE((PyArrayObject*) py_V137) != NPY_FLOAT64) {
12124	                PyErr_Format(PyExc_TypeError,
12125	                             "expected type_num %d (NPY_FLOAT64) got %d",
12126	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V137));
12127	                {
12128	        __failure = 138;
12129	        if (!PyErr_Occurred()) {
12130	            PyErr_SetString(PyExc_RuntimeError,
12131	                "Unexpected error in an Op's C code. "
12132	                "No Python exception was set.");
12133	            }
12134	        goto __label_138;}
12135	            }
12136	            
12137	        V137 = (PyArrayObject*)(py_V137);
12138	        Py_XINCREF(V137);
12139	        
12140	{
12141	
12142	    py_V139 = PyList_GET_ITEM(storage_V139, 0);
12143	    {Py_XINCREF(py_V139);}
12144	    
12145	            V139 = NULL;
12146	            if (py_V139 == Py_None) {
12147	                // We can either fail here or set V139 to NULL and rely on Ops
12148	                // using tensors to handle the NULL case, but if they fail to do so
12149	                // they'll end up with nasty segfaults, so this is public service.
12150	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
12151	                {
12152	        __failure = 140;
12153	        if (!PyErr_Occurred()) {
12154	            PyErr_SetString(PyExc_RuntimeError,
12155	                "Unexpected error in an Op's C code. "
12156	                "No Python exception was set.");
12157	            }
12158	        goto __label_140;}
12159	            }
12160	            if (!PyArray_Check(py_V139)) {
12161	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
12162	                {
12163	        __failure = 140;
12164	        if (!PyErr_Occurred()) {
12165	            PyErr_SetString(PyExc_RuntimeError,
12166	                "Unexpected error in an Op's C code. "
12167	                "No Python exception was set.");
12168	            }
12169	        goto __label_140;}
12170	            }
12171	            // We expect NPY_FLOAT64
12172	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V139)) {
12173	                PyArrayObject * tmp = (PyArrayObject*) py_V139;
12174	                PyErr_Format(PyExc_NotImplementedError,
12175	                             "expected an aligned array of type %ld "
12176	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
12177	                             " with %ld dimensions, with 3 last dims "
12178	                             "%ld, %ld, %ld"
12179	                             " and 3 last strides %ld %ld, %ld.",
12180	                             (long int) NPY_FLOAT64,
12181	                             (long int) PyArray_TYPE((PyArrayObject*) py_V139),
12182	                             (long int) PyArray_NDIM(tmp),
12183	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
12184	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
12185	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
12186	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
12187	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
12188	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
12189	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
12190	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
12191	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
12192	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
12193	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
12194	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
12195	            );
12196	                {
12197	        __failure = 140;
12198	        if (!PyErr_Occurred()) {
12199	            PyErr_SetString(PyExc_RuntimeError,
12200	                "Unexpected error in an Op's C code. "
12201	                "No Python exception was set.");
12202	            }
12203	        goto __label_140;}
12204	            }
12205	            // This is a TypeError to be consistent with DEBUG_MODE
12206	            // Note: DEBUG_MODE also tells the name of the container
12207	            if (PyArray_TYPE((PyArrayObject*) py_V139) != NPY_FLOAT64) {
12208	                PyErr_Format(PyExc_TypeError,
12209	                             "expected type_num %d (NPY_FLOAT64) got %d",
12210	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V139));
12211	                {
12212	        __failure = 140;
12213	        if (!PyErr_Occurred()) {
12214	            PyErr_SetString(PyExc_RuntimeError,
12215	                "Unexpected error in an Op's C code. "
12216	                "No Python exception was set.");
12217	            }
12218	        goto __label_140;}
12219	            }
12220	            
12221	        V139 = (PyArrayObject*)(py_V139);
12222	        Py_XINCREF(V139);
12223	        
12224	{
12225	
12226	    py_V141 = PyList_GET_ITEM(storage_V141, 0);
12227	    {Py_XINCREF(py_V141);}
12228	    
12229	            V141 = NULL;
12230	            if (py_V141 == Py_None) {
12231	                // We can either fail here or set V141 to NULL and rely on Ops
12232	                // using tensors to handle the NULL case, but if they fail to do so
12233	                // they'll end up with nasty segfaults, so this is public service.
12234	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
12235	                {
12236	        __failure = 142;
12237	        if (!PyErr_Occurred()) {
12238	            PyErr_SetString(PyExc_RuntimeError,
12239	                "Unexpected error in an Op's C code. "
12240	                "No Python exception was set.");
12241	            }
12242	        goto __label_142;}
12243	            }
12244	            if (!PyArray_Check(py_V141)) {
12245	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
12246	                {
12247	        __failure = 142;
12248	        if (!PyErr_Occurred()) {
12249	            PyErr_SetString(PyExc_RuntimeError,
12250	                "Unexpected error in an Op's C code. "
12251	                "No Python exception was set.");
12252	            }
12253	        goto __label_142;}
12254	            }
12255	            // We expect NPY_FLOAT64
12256	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V141)) {
12257	                PyArrayObject * tmp = (PyArrayObject*) py_V141;
12258	                PyErr_Format(PyExc_NotImplementedError,
12259	                             "expected an aligned array of type %ld "
12260	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
12261	                             " with %ld dimensions, with 3 last dims "
12262	                             "%ld, %ld, %ld"
12263	                             " and 3 last strides %ld %ld, %ld.",
12264	                             (long int) NPY_FLOAT64,
12265	                             (long int) PyArray_TYPE((PyArrayObject*) py_V141),
12266	                             (long int) PyArray_NDIM(tmp),
12267	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
12268	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
12269	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
12270	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
12271	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
12272	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
12273	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
12274	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
12275	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
12276	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
12277	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
12278	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
12279	            );
12280	                {
12281	        __failure = 142;
12282	        if (!PyErr_Occurred()) {
12283	            PyErr_SetString(PyExc_RuntimeError,
12284	                "Unexpected error in an Op's C code. "
12285	                "No Python exception was set.");
12286	            }
12287	        goto __label_142;}
12288	            }
12289	            // This is a TypeError to be consistent with DEBUG_MODE
12290	            // Note: DEBUG_MODE also tells the name of the container
12291	            if (PyArray_TYPE((PyArrayObject*) py_V141) != NPY_FLOAT64) {
12292	                PyErr_Format(PyExc_TypeError,
12293	                             "expected type_num %d (NPY_FLOAT64) got %d",
12294	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V141));
12295	                {
12296	        __failure = 142;
12297	        if (!PyErr_Occurred()) {
12298	            PyErr_SetString(PyExc_RuntimeError,
12299	                "Unexpected error in an Op's C code. "
12300	                "No Python exception was set.");
12301	            }
12302	        goto __label_142;}
12303	            }
12304	            
12305	        V141 = (PyArrayObject*)(py_V141);
12306	        Py_XINCREF(V141);
12307	        
12308	{
12309	
12310	    py_V143 = PyList_GET_ITEM(storage_V143, 0);
12311	    {Py_XINCREF(py_V143);}
12312	    
12313	            V143 = NULL;
12314	            if (py_V143 == Py_None) {
12315	                // We can either fail here or set V143 to NULL and rely on Ops
12316	                // using tensors to handle the NULL case, but if they fail to do so
12317	                // they'll end up with nasty segfaults, so this is public service.
12318	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
12319	                {
12320	        __failure = 144;
12321	        if (!PyErr_Occurred()) {
12322	            PyErr_SetString(PyExc_RuntimeError,
12323	                "Unexpected error in an Op's C code. "
12324	                "No Python exception was set.");
12325	            }
12326	        goto __label_144;}
12327	            }
12328	            if (!PyArray_Check(py_V143)) {
12329	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
12330	                {
12331	        __failure = 144;
12332	        if (!PyErr_Occurred()) {
12333	            PyErr_SetString(PyExc_RuntimeError,
12334	                "Unexpected error in an Op's C code. "
12335	                "No Python exception was set.");
12336	            }
12337	        goto __label_144;}
12338	            }
12339	            // We expect NPY_FLOAT64
12340	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V143)) {
12341	                PyArrayObject * tmp = (PyArrayObject*) py_V143;
12342	                PyErr_Format(PyExc_NotImplementedError,
12343	                             "expected an aligned array of type %ld "
12344	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
12345	                             " with %ld dimensions, with 3 last dims "
12346	                             "%ld, %ld, %ld"
12347	                             " and 3 last strides %ld %ld, %ld.",
12348	                             (long int) NPY_FLOAT64,
12349	                             (long int) PyArray_TYPE((PyArrayObject*) py_V143),
12350	                             (long int) PyArray_NDIM(tmp),
12351	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
12352	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
12353	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
12354	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
12355	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
12356	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
12357	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
12358	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
12359	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
12360	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
12361	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
12362	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
12363	            );
12364	                {
12365	        __failure = 144;
12366	        if (!PyErr_Occurred()) {
12367	            PyErr_SetString(PyExc_RuntimeError,
12368	                "Unexpected error in an Op's C code. "
12369	                "No Python exception was set.");
12370	            }
12371	        goto __label_144;}
12372	            }
12373	            // This is a TypeError to be consistent with DEBUG_MODE
12374	            // Note: DEBUG_MODE also tells the name of the container
12375	            if (PyArray_TYPE((PyArrayObject*) py_V143) != NPY_FLOAT64) {
12376	                PyErr_Format(PyExc_TypeError,
12377	                             "expected type_num %d (NPY_FLOAT64) got %d",
12378	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V143));
12379	                {
12380	        __failure = 144;
12381	        if (!PyErr_Occurred()) {
12382	            PyErr_SetString(PyExc_RuntimeError,
12383	                "Unexpected error in an Op's C code. "
12384	                "No Python exception was set.");
12385	            }
12386	        goto __label_144;}
12387	            }
12388	            
12389	        V143 = (PyArrayObject*)(py_V143);
12390	        Py_XINCREF(V143);
12391	        
12392	{
12393	
12394	    py_V145 = PyList_GET_ITEM(storage_V145, 0);
12395	    {Py_XINCREF(py_V145);}
12396	    
12397	            V145 = NULL;
12398	            if (py_V145 == Py_None) {
12399	                // We can either fail here or set V145 to NULL and rely on Ops
12400	                // using tensors to handle the NULL case, but if they fail to do so
12401	                // they'll end up with nasty segfaults, so this is public service.
12402	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
12403	                {
12404	        __failure = 146;
12405	        if (!PyErr_Occurred()) {
12406	            PyErr_SetString(PyExc_RuntimeError,
12407	                "Unexpected error in an Op's C code. "
12408	                "No Python exception was set.");
12409	            }
12410	        goto __label_146;}
12411	            }
12412	            if (!PyArray_Check(py_V145)) {
12413	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
12414	                {
12415	        __failure = 146;
12416	        if (!PyErr_Occurred()) {
12417	            PyErr_SetString(PyExc_RuntimeError,
12418	                "Unexpected error in an Op's C code. "
12419	                "No Python exception was set.");
12420	            }
12421	        goto __label_146;}
12422	            }
12423	            // We expect NPY_FLOAT64
12424	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V145)) {
12425	                PyArrayObject * tmp = (PyArrayObject*) py_V145;
12426	                PyErr_Format(PyExc_NotImplementedError,
12427	                             "expected an aligned array of type %ld "
12428	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
12429	                             " with %ld dimensions, with 3 last dims "
12430	                             "%ld, %ld, %ld"
12431	                             " and 3 last strides %ld %ld, %ld.",
12432	                             (long int) NPY_FLOAT64,
12433	                             (long int) PyArray_TYPE((PyArrayObject*) py_V145),
12434	                             (long int) PyArray_NDIM(tmp),
12435	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
12436	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
12437	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
12438	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
12439	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
12440	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
12441	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
12442	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
12443	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
12444	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
12445	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
12446	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
12447	            );
12448	                {
12449	        __failure = 146;
12450	        if (!PyErr_Occurred()) {
12451	            PyErr_SetString(PyExc_RuntimeError,
12452	                "Unexpected error in an Op's C code. "
12453	                "No Python exception was set.");
12454	            }
12455	        goto __label_146;}
12456	            }
12457	            // This is a TypeError to be consistent with DEBUG_MODE
12458	            // Note: DEBUG_MODE also tells the name of the container
12459	            if (PyArray_TYPE((PyArrayObject*) py_V145) != NPY_FLOAT64) {
12460	                PyErr_Format(PyExc_TypeError,
12461	                             "expected type_num %d (NPY_FLOAT64) got %d",
12462	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V145));
12463	                {
12464	        __failure = 146;
12465	        if (!PyErr_Occurred()) {
12466	            PyErr_SetString(PyExc_RuntimeError,
12467	                "Unexpected error in an Op's C code. "
12468	                "No Python exception was set.");
12469	            }
12470	        goto __label_146;}
12471	            }
12472	            
12473	        V145 = (PyArrayObject*)(py_V145);
12474	        Py_XINCREF(V145);
12475	        
12476	{
12477	
12478	    py_V147 = PyList_GET_ITEM(storage_V147, 0);
12479	    {Py_XINCREF(py_V147);}
12480	    
12481	            V147 = NULL;
12482	            if (py_V147 == Py_None) {
12483	                // We can either fail here or set V147 to NULL and rely on Ops
12484	                // using tensors to handle the NULL case, but if they fail to do so
12485	                // they'll end up with nasty segfaults, so this is public service.
12486	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
12487	                {
12488	        __failure = 148;
12489	        if (!PyErr_Occurred()) {
12490	            PyErr_SetString(PyExc_RuntimeError,
12491	                "Unexpected error in an Op's C code. "
12492	                "No Python exception was set.");
12493	            }
12494	        goto __label_148;}
12495	            }
12496	            if (!PyArray_Check(py_V147)) {
12497	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
12498	                {
12499	        __failure = 148;
12500	        if (!PyErr_Occurred()) {
12501	            PyErr_SetString(PyExc_RuntimeError,
12502	                "Unexpected error in an Op's C code. "
12503	                "No Python exception was set.");
12504	            }
12505	        goto __label_148;}
12506	            }
12507	            // We expect NPY_FLOAT64
12508	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V147)) {
12509	                PyArrayObject * tmp = (PyArrayObject*) py_V147;
12510	                PyErr_Format(PyExc_NotImplementedError,
12511	                             "expected an aligned array of type %ld "
12512	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
12513	                             " with %ld dimensions, with 3 last dims "
12514	                             "%ld, %ld, %ld"
12515	                             " and 3 last strides %ld %ld, %ld.",
12516	                             (long int) NPY_FLOAT64,
12517	                             (long int) PyArray_TYPE((PyArrayObject*) py_V147),
12518	                             (long int) PyArray_NDIM(tmp),
12519	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
12520	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
12521	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
12522	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
12523	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
12524	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
12525	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
12526	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
12527	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
12528	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
12529	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
12530	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
12531	            );
12532	                {
12533	        __failure = 148;
12534	        if (!PyErr_Occurred()) {
12535	            PyErr_SetString(PyExc_RuntimeError,
12536	                "Unexpected error in an Op's C code. "
12537	                "No Python exception was set.");
12538	            }
12539	        goto __label_148;}
12540	            }
12541	            // This is a TypeError to be consistent with DEBUG_MODE
12542	            // Note: DEBUG_MODE also tells the name of the container
12543	            if (PyArray_TYPE((PyArrayObject*) py_V147) != NPY_FLOAT64) {
12544	                PyErr_Format(PyExc_TypeError,
12545	                             "expected type_num %d (NPY_FLOAT64) got %d",
12546	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V147));
12547	                {
12548	        __failure = 148;
12549	        if (!PyErr_Occurred()) {
12550	            PyErr_SetString(PyExc_RuntimeError,
12551	                "Unexpected error in an Op's C code. "
12552	                "No Python exception was set.");
12553	            }
12554	        goto __label_148;}
12555	            }
12556	            
12557	        V147 = (PyArrayObject*)(py_V147);
12558	        Py_XINCREF(V147);
12559	        
12560	{
12561	
12562	    py_V149 = PyList_GET_ITEM(storage_V149, 0);
12563	    {Py_XINCREF(py_V149);}
12564	    
12565	            V149 = NULL;
12566	            if (py_V149 == Py_None) {
12567	                // We can either fail here or set V149 to NULL and rely on Ops
12568	                // using tensors to handle the NULL case, but if they fail to do so
12569	                // they'll end up with nasty segfaults, so this is public service.
12570	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
12571	                {
12572	        __failure = 150;
12573	        if (!PyErr_Occurred()) {
12574	            PyErr_SetString(PyExc_RuntimeError,
12575	                "Unexpected error in an Op's C code. "
12576	                "No Python exception was set.");
12577	            }
12578	        goto __label_150;}
12579	            }
12580	            if (!PyArray_Check(py_V149)) {
12581	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
12582	                {
12583	        __failure = 150;
12584	        if (!PyErr_Occurred()) {
12585	            PyErr_SetString(PyExc_RuntimeError,
12586	                "Unexpected error in an Op's C code. "
12587	                "No Python exception was set.");
12588	            }
12589	        goto __label_150;}
12590	            }
12591	            // We expect NPY_FLOAT64
12592	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V149)) {
12593	                PyArrayObject * tmp = (PyArrayObject*) py_V149;
12594	                PyErr_Format(PyExc_NotImplementedError,
12595	                             "expected an aligned array of type %ld "
12596	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
12597	                             " with %ld dimensions, with 3 last dims "
12598	                             "%ld, %ld, %ld"
12599	                             " and 3 last strides %ld %ld, %ld.",
12600	                             (long int) NPY_FLOAT64,
12601	                             (long int) PyArray_TYPE((PyArrayObject*) py_V149),
12602	                             (long int) PyArray_NDIM(tmp),
12603	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
12604	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
12605	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
12606	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
12607	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
12608	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
12609	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
12610	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
12611	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
12612	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
12613	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
12614	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
12615	            );
12616	                {
12617	        __failure = 150;
12618	        if (!PyErr_Occurred()) {
12619	            PyErr_SetString(PyExc_RuntimeError,
12620	                "Unexpected error in an Op's C code. "
12621	                "No Python exception was set.");
12622	            }
12623	        goto __label_150;}
12624	            }
12625	            // This is a TypeError to be consistent with DEBUG_MODE
12626	            // Note: DEBUG_MODE also tells the name of the container
12627	            if (PyArray_TYPE((PyArrayObject*) py_V149) != NPY_FLOAT64) {
12628	                PyErr_Format(PyExc_TypeError,
12629	                             "expected type_num %d (NPY_FLOAT64) got %d",
12630	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V149));
12631	                {
12632	        __failure = 150;
12633	        if (!PyErr_Occurred()) {
12634	            PyErr_SetString(PyExc_RuntimeError,
12635	                "Unexpected error in an Op's C code. "
12636	                "No Python exception was set.");
12637	            }
12638	        goto __label_150;}
12639	            }
12640	            
12641	        V149 = (PyArrayObject*)(py_V149);
12642	        Py_XINCREF(V149);
12643	        
12644	{
12645	
12646	    py_V151 = PyList_GET_ITEM(storage_V151, 0);
12647	    {Py_XINCREF(py_V151);}
12648	    
12649	            V151 = NULL;
12650	            if (py_V151 == Py_None) {
12651	                // We can either fail here or set V151 to NULL and rely on Ops
12652	                // using tensors to handle the NULL case, but if they fail to do so
12653	                // they'll end up with nasty segfaults, so this is public service.
12654	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
12655	                {
12656	        __failure = 152;
12657	        if (!PyErr_Occurred()) {
12658	            PyErr_SetString(PyExc_RuntimeError,
12659	                "Unexpected error in an Op's C code. "
12660	                "No Python exception was set.");
12661	            }
12662	        goto __label_152;}
12663	            }
12664	            if (!PyArray_Check(py_V151)) {
12665	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
12666	                {
12667	        __failure = 152;
12668	        if (!PyErr_Occurred()) {
12669	            PyErr_SetString(PyExc_RuntimeError,
12670	                "Unexpected error in an Op's C code. "
12671	                "No Python exception was set.");
12672	            }
12673	        goto __label_152;}
12674	            }
12675	            // We expect NPY_FLOAT64
12676	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V151)) {
12677	                PyArrayObject * tmp = (PyArrayObject*) py_V151;
12678	                PyErr_Format(PyExc_NotImplementedError,
12679	                             "expected an aligned array of type %ld "
12680	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
12681	                             " with %ld dimensions, with 3 last dims "
12682	                             "%ld, %ld, %ld"
12683	                             " and 3 last strides %ld %ld, %ld.",
12684	                             (long int) NPY_FLOAT64,
12685	                             (long int) PyArray_TYPE((PyArrayObject*) py_V151),
12686	                             (long int) PyArray_NDIM(tmp),
12687	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
12688	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
12689	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
12690	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
12691	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
12692	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
12693	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
12694	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
12695	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
12696	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
12697	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
12698	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
12699	            );
12700	                {
12701	        __failure = 152;
12702	        if (!PyErr_Occurred()) {
12703	            PyErr_SetString(PyExc_RuntimeError,
12704	                "Unexpected error in an Op's C code. "
12705	                "No Python exception was set.");
12706	            }
12707	        goto __label_152;}
12708	            }
12709	            // This is a TypeError to be consistent with DEBUG_MODE
12710	            // Note: DEBUG_MODE also tells the name of the container
12711	            if (PyArray_TYPE((PyArrayObject*) py_V151) != NPY_FLOAT64) {
12712	                PyErr_Format(PyExc_TypeError,
12713	                             "expected type_num %d (NPY_FLOAT64) got %d",
12714	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V151));
12715	                {
12716	        __failure = 152;
12717	        if (!PyErr_Occurred()) {
12718	            PyErr_SetString(PyExc_RuntimeError,
12719	                "Unexpected error in an Op's C code. "
12720	                "No Python exception was set.");
12721	            }
12722	        goto __label_152;}
12723	            }
12724	            
12725	        V151 = (PyArrayObject*)(py_V151);
12726	        Py_XINCREF(V151);
12727	        
12728	{
12729	
12730	    py_V153 = PyList_GET_ITEM(storage_V153, 0);
12731	    {Py_XINCREF(py_V153);}
12732	    
12733	            V153 = NULL;
12734	            if (py_V153 == Py_None) {
12735	                // We can either fail here or set V153 to NULL and rely on Ops
12736	                // using tensors to handle the NULL case, but if they fail to do so
12737	                // they'll end up with nasty segfaults, so this is public service.
12738	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
12739	                {
12740	        __failure = 154;
12741	        if (!PyErr_Occurred()) {
12742	            PyErr_SetString(PyExc_RuntimeError,
12743	                "Unexpected error in an Op's C code. "
12744	                "No Python exception was set.");
12745	            }
12746	        goto __label_154;}
12747	            }
12748	            if (!PyArray_Check(py_V153)) {
12749	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
12750	                {
12751	        __failure = 154;
12752	        if (!PyErr_Occurred()) {
12753	            PyErr_SetString(PyExc_RuntimeError,
12754	                "Unexpected error in an Op's C code. "
12755	                "No Python exception was set.");
12756	            }
12757	        goto __label_154;}
12758	            }
12759	            // We expect NPY_FLOAT64
12760	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V153)) {
12761	                PyArrayObject * tmp = (PyArrayObject*) py_V153;
12762	                PyErr_Format(PyExc_NotImplementedError,
12763	                             "expected an aligned array of type %ld "
12764	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
12765	                             " with %ld dimensions, with 3 last dims "
12766	                             "%ld, %ld, %ld"
12767	                             " and 3 last strides %ld %ld, %ld.",
12768	                             (long int) NPY_FLOAT64,
12769	                             (long int) PyArray_TYPE((PyArrayObject*) py_V153),
12770	                             (long int) PyArray_NDIM(tmp),
12771	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
12772	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
12773	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
12774	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
12775	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
12776	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
12777	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
12778	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
12779	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
12780	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
12781	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
12782	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
12783	            );
12784	                {
12785	        __failure = 154;
12786	        if (!PyErr_Occurred()) {
12787	            PyErr_SetString(PyExc_RuntimeError,
12788	                "Unexpected error in an Op's C code. "
12789	                "No Python exception was set.");
12790	            }
12791	        goto __label_154;}
12792	            }
12793	            // This is a TypeError to be consistent with DEBUG_MODE
12794	            // Note: DEBUG_MODE also tells the name of the container
12795	            if (PyArray_TYPE((PyArrayObject*) py_V153) != NPY_FLOAT64) {
12796	                PyErr_Format(PyExc_TypeError,
12797	                             "expected type_num %d (NPY_FLOAT64) got %d",
12798	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V153));
12799	                {
12800	        __failure = 154;
12801	        if (!PyErr_Occurred()) {
12802	            PyErr_SetString(PyExc_RuntimeError,
12803	                "Unexpected error in an Op's C code. "
12804	                "No Python exception was set.");
12805	            }
12806	        goto __label_154;}
12807	            }
12808	            
12809	        V153 = (PyArrayObject*)(py_V153);
12810	        Py_XINCREF(V153);
12811	        
12812	{
12813	
12814	    py_V155 = PyList_GET_ITEM(storage_V155, 0);
12815	    {Py_XINCREF(py_V155);}
12816	    
12817	            V155 = NULL;
12818	            if (py_V155 == Py_None) {
12819	                // We can either fail here or set V155 to NULL and rely on Ops
12820	                // using tensors to handle the NULL case, but if they fail to do so
12821	                // they'll end up with nasty segfaults, so this is public service.
12822	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
12823	                {
12824	        __failure = 156;
12825	        if (!PyErr_Occurred()) {
12826	            PyErr_SetString(PyExc_RuntimeError,
12827	                "Unexpected error in an Op's C code. "
12828	                "No Python exception was set.");
12829	            }
12830	        goto __label_156;}
12831	            }
12832	            if (!PyArray_Check(py_V155)) {
12833	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
12834	                {
12835	        __failure = 156;
12836	        if (!PyErr_Occurred()) {
12837	            PyErr_SetString(PyExc_RuntimeError,
12838	                "Unexpected error in an Op's C code. "
12839	                "No Python exception was set.");
12840	            }
12841	        goto __label_156;}
12842	            }
12843	            // We expect NPY_FLOAT64
12844	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V155)) {
12845	                PyArrayObject * tmp = (PyArrayObject*) py_V155;
12846	                PyErr_Format(PyExc_NotImplementedError,
12847	                             "expected an aligned array of type %ld "
12848	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
12849	                             " with %ld dimensions, with 3 last dims "
12850	                             "%ld, %ld, %ld"
12851	                             " and 3 last strides %ld %ld, %ld.",
12852	                             (long int) NPY_FLOAT64,
12853	                             (long int) PyArray_TYPE((PyArrayObject*) py_V155),
12854	                             (long int) PyArray_NDIM(tmp),
12855	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
12856	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
12857	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
12858	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
12859	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
12860	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
12861	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
12862	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
12863	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
12864	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
12865	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
12866	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
12867	            );
12868	                {
12869	        __failure = 156;
12870	        if (!PyErr_Occurred()) {
12871	            PyErr_SetString(PyExc_RuntimeError,
12872	                "Unexpected error in an Op's C code. "
12873	                "No Python exception was set.");
12874	            }
12875	        goto __label_156;}
12876	            }
12877	            // This is a TypeError to be consistent with DEBUG_MODE
12878	            // Note: DEBUG_MODE also tells the name of the container
12879	            if (PyArray_TYPE((PyArrayObject*) py_V155) != NPY_FLOAT64) {
12880	                PyErr_Format(PyExc_TypeError,
12881	                             "expected type_num %d (NPY_FLOAT64) got %d",
12882	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V155));
12883	                {
12884	        __failure = 156;
12885	        if (!PyErr_Occurred()) {
12886	            PyErr_SetString(PyExc_RuntimeError,
12887	                "Unexpected error in an Op's C code. "
12888	                "No Python exception was set.");
12889	            }
12890	        goto __label_156;}
12891	            }
12892	            
12893	        V155 = (PyArrayObject*)(py_V155);
12894	        Py_XINCREF(V155);
12895	        
12896	{
12897	
12898	    py_V157 = PyList_GET_ITEM(storage_V157, 0);
12899	    {Py_XINCREF(py_V157);}
12900	    
12901	            V157 = NULL;
12902	            if (py_V157 == Py_None) {
12903	                // We can either fail here or set V157 to NULL and rely on Ops
12904	                // using tensors to handle the NULL case, but if they fail to do so
12905	                // they'll end up with nasty segfaults, so this is public service.
12906	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
12907	                {
12908	        __failure = 158;
12909	        if (!PyErr_Occurred()) {
12910	            PyErr_SetString(PyExc_RuntimeError,
12911	                "Unexpected error in an Op's C code. "
12912	                "No Python exception was set.");
12913	            }
12914	        goto __label_158;}
12915	            }
12916	            if (!PyArray_Check(py_V157)) {
12917	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
12918	                {
12919	        __failure = 158;
12920	        if (!PyErr_Occurred()) {
12921	            PyErr_SetString(PyExc_RuntimeError,
12922	                "Unexpected error in an Op's C code. "
12923	                "No Python exception was set.");
12924	            }
12925	        goto __label_158;}
12926	            }
12927	            // We expect NPY_FLOAT64
12928	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V157)) {
12929	                PyArrayObject * tmp = (PyArrayObject*) py_V157;
12930	                PyErr_Format(PyExc_NotImplementedError,
12931	                             "expected an aligned array of type %ld "
12932	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
12933	                             " with %ld dimensions, with 3 last dims "
12934	                             "%ld, %ld, %ld"
12935	                             " and 3 last strides %ld %ld, %ld.",
12936	                             (long int) NPY_FLOAT64,
12937	                             (long int) PyArray_TYPE((PyArrayObject*) py_V157),
12938	                             (long int) PyArray_NDIM(tmp),
12939	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
12940	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
12941	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
12942	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
12943	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
12944	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
12945	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
12946	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
12947	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
12948	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
12949	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
12950	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
12951	            );
12952	                {
12953	        __failure = 158;
12954	        if (!PyErr_Occurred()) {
12955	            PyErr_SetString(PyExc_RuntimeError,
12956	                "Unexpected error in an Op's C code. "
12957	                "No Python exception was set.");
12958	            }
12959	        goto __label_158;}
12960	            }
12961	            // This is a TypeError to be consistent with DEBUG_MODE
12962	            // Note: DEBUG_MODE also tells the name of the container
12963	            if (PyArray_TYPE((PyArrayObject*) py_V157) != NPY_FLOAT64) {
12964	                PyErr_Format(PyExc_TypeError,
12965	                             "expected type_num %d (NPY_FLOAT64) got %d",
12966	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V157));
12967	                {
12968	        __failure = 158;
12969	        if (!PyErr_Occurred()) {
12970	            PyErr_SetString(PyExc_RuntimeError,
12971	                "Unexpected error in an Op's C code. "
12972	                "No Python exception was set.");
12973	            }
12974	        goto __label_158;}
12975	            }
12976	            
12977	        V157 = (PyArrayObject*)(py_V157);
12978	        Py_XINCREF(V157);
12979	        
12980	{
12981	
12982	    py_V159 = PyList_GET_ITEM(storage_V159, 0);
12983	    {Py_XINCREF(py_V159);}
12984	    
12985	            V159 = NULL;
12986	            if (py_V159 == Py_None) {
12987	                // We can either fail here or set V159 to NULL and rely on Ops
12988	                // using tensors to handle the NULL case, but if they fail to do so
12989	                // they'll end up with nasty segfaults, so this is public service.
12990	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
12991	                {
12992	        __failure = 160;
12993	        if (!PyErr_Occurred()) {
12994	            PyErr_SetString(PyExc_RuntimeError,
12995	                "Unexpected error in an Op's C code. "
12996	                "No Python exception was set.");
12997	            }
12998	        goto __label_160;}
12999	            }
13000	            if (!PyArray_Check(py_V159)) {
13001	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
13002	                {
13003	        __failure = 160;
13004	        if (!PyErr_Occurred()) {
13005	            PyErr_SetString(PyExc_RuntimeError,
13006	                "Unexpected error in an Op's C code. "
13007	                "No Python exception was set.");
13008	            }
13009	        goto __label_160;}
13010	            }
13011	            // We expect NPY_FLOAT64
13012	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V159)) {
13013	                PyArrayObject * tmp = (PyArrayObject*) py_V159;
13014	                PyErr_Format(PyExc_NotImplementedError,
13015	                             "expected an aligned array of type %ld "
13016	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
13017	                             " with %ld dimensions, with 3 last dims "
13018	                             "%ld, %ld, %ld"
13019	                             " and 3 last strides %ld %ld, %ld.",
13020	                             (long int) NPY_FLOAT64,
13021	                             (long int) PyArray_TYPE((PyArrayObject*) py_V159),
13022	                             (long int) PyArray_NDIM(tmp),
13023	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
13024	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
13025	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
13026	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
13027	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
13028	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
13029	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
13030	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
13031	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
13032	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
13033	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
13034	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
13035	            );
13036	                {
13037	        __failure = 160;
13038	        if (!PyErr_Occurred()) {
13039	            PyErr_SetString(PyExc_RuntimeError,
13040	                "Unexpected error in an Op's C code. "
13041	                "No Python exception was set.");
13042	            }
13043	        goto __label_160;}
13044	            }
13045	            // This is a TypeError to be consistent with DEBUG_MODE
13046	            // Note: DEBUG_MODE also tells the name of the container
13047	            if (PyArray_TYPE((PyArrayObject*) py_V159) != NPY_FLOAT64) {
13048	                PyErr_Format(PyExc_TypeError,
13049	                             "expected type_num %d (NPY_FLOAT64) got %d",
13050	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V159));
13051	                {
13052	        __failure = 160;
13053	        if (!PyErr_Occurred()) {
13054	            PyErr_SetString(PyExc_RuntimeError,
13055	                "Unexpected error in an Op's C code. "
13056	                "No Python exception was set.");
13057	            }
13058	        goto __label_160;}
13059	            }
13060	            
13061	        V159 = (PyArrayObject*)(py_V159);
13062	        Py_XINCREF(V159);
13063	        
13064	{
13065	
13066	    py_V161 = PyList_GET_ITEM(storage_V161, 0);
13067	    {Py_XINCREF(py_V161);}
13068	    
13069	            V161 = NULL;
13070	            if (py_V161 == Py_None) {
13071	                // We can either fail here or set V161 to NULL and rely on Ops
13072	                // using tensors to handle the NULL case, but if they fail to do so
13073	                // they'll end up with nasty segfaults, so this is public service.
13074	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
13075	                {
13076	        __failure = 162;
13077	        if (!PyErr_Occurred()) {
13078	            PyErr_SetString(PyExc_RuntimeError,
13079	                "Unexpected error in an Op's C code. "
13080	                "No Python exception was set.");
13081	            }
13082	        goto __label_162;}
13083	            }
13084	            if (!PyArray_Check(py_V161)) {
13085	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
13086	                {
13087	        __failure = 162;
13088	        if (!PyErr_Occurred()) {
13089	            PyErr_SetString(PyExc_RuntimeError,
13090	                "Unexpected error in an Op's C code. "
13091	                "No Python exception was set.");
13092	            }
13093	        goto __label_162;}
13094	            }
13095	            // We expect NPY_FLOAT64
13096	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V161)) {
13097	                PyArrayObject * tmp = (PyArrayObject*) py_V161;
13098	                PyErr_Format(PyExc_NotImplementedError,
13099	                             "expected an aligned array of type %ld "
13100	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
13101	                             " with %ld dimensions, with 3 last dims "
13102	                             "%ld, %ld, %ld"
13103	                             " and 3 last strides %ld %ld, %ld.",
13104	                             (long int) NPY_FLOAT64,
13105	                             (long int) PyArray_TYPE((PyArrayObject*) py_V161),
13106	                             (long int) PyArray_NDIM(tmp),
13107	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
13108	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
13109	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
13110	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
13111	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
13112	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
13113	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
13114	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
13115	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
13116	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
13117	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
13118	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
13119	            );
13120	                {
13121	        __failure = 162;
13122	        if (!PyErr_Occurred()) {
13123	            PyErr_SetString(PyExc_RuntimeError,
13124	                "Unexpected error in an Op's C code. "
13125	                "No Python exception was set.");
13126	            }
13127	        goto __label_162;}
13128	            }
13129	            // This is a TypeError to be consistent with DEBUG_MODE
13130	            // Note: DEBUG_MODE also tells the name of the container
13131	            if (PyArray_TYPE((PyArrayObject*) py_V161) != NPY_FLOAT64) {
13132	                PyErr_Format(PyExc_TypeError,
13133	                             "expected type_num %d (NPY_FLOAT64) got %d",
13134	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V161));
13135	                {
13136	        __failure = 162;
13137	        if (!PyErr_Occurred()) {
13138	            PyErr_SetString(PyExc_RuntimeError,
13139	                "Unexpected error in an Op's C code. "
13140	                "No Python exception was set.");
13141	            }
13142	        goto __label_162;}
13143	            }
13144	            
13145	        V161 = (PyArrayObject*)(py_V161);
13146	        Py_XINCREF(V161);
13147	        
13148	{
13149	
13150	    py_V163 = PyList_GET_ITEM(storage_V163, 0);
13151	    {Py_XINCREF(py_V163);}
13152	    
13153	            V163 = NULL;
13154	            if (py_V163 == Py_None) {
13155	                // We can either fail here or set V163 to NULL and rely on Ops
13156	                // using tensors to handle the NULL case, but if they fail to do so
13157	                // they'll end up with nasty segfaults, so this is public service.
13158	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
13159	                {
13160	        __failure = 164;
13161	        if (!PyErr_Occurred()) {
13162	            PyErr_SetString(PyExc_RuntimeError,
13163	                "Unexpected error in an Op's C code. "
13164	                "No Python exception was set.");
13165	            }
13166	        goto __label_164;}
13167	            }
13168	            if (!PyArray_Check(py_V163)) {
13169	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
13170	                {
13171	        __failure = 164;
13172	        if (!PyErr_Occurred()) {
13173	            PyErr_SetString(PyExc_RuntimeError,
13174	                "Unexpected error in an Op's C code. "
13175	                "No Python exception was set.");
13176	            }
13177	        goto __label_164;}
13178	            }
13179	            // We expect NPY_FLOAT64
13180	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V163)) {
13181	                PyArrayObject * tmp = (PyArrayObject*) py_V163;
13182	                PyErr_Format(PyExc_NotImplementedError,
13183	                             "expected an aligned array of type %ld "
13184	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
13185	                             " with %ld dimensions, with 3 last dims "
13186	                             "%ld, %ld, %ld"
13187	                             " and 3 last strides %ld %ld, %ld.",
13188	                             (long int) NPY_FLOAT64,
13189	                             (long int) PyArray_TYPE((PyArrayObject*) py_V163),
13190	                             (long int) PyArray_NDIM(tmp),
13191	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
13192	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
13193	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
13194	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
13195	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
13196	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
13197	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
13198	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
13199	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
13200	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
13201	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
13202	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
13203	            );
13204	                {
13205	        __failure = 164;
13206	        if (!PyErr_Occurred()) {
13207	            PyErr_SetString(PyExc_RuntimeError,
13208	                "Unexpected error in an Op's C code. "
13209	                "No Python exception was set.");
13210	            }
13211	        goto __label_164;}
13212	            }
13213	            // This is a TypeError to be consistent with DEBUG_MODE
13214	            // Note: DEBUG_MODE also tells the name of the container
13215	            if (PyArray_TYPE((PyArrayObject*) py_V163) != NPY_FLOAT64) {
13216	                PyErr_Format(PyExc_TypeError,
13217	                             "expected type_num %d (NPY_FLOAT64) got %d",
13218	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V163));
13219	                {
13220	        __failure = 164;
13221	        if (!PyErr_Occurred()) {
13222	            PyErr_SetString(PyExc_RuntimeError,
13223	                "Unexpected error in an Op's C code. "
13224	                "No Python exception was set.");
13225	            }
13226	        goto __label_164;}
13227	            }
13228	            
13229	        V163 = (PyArrayObject*)(py_V163);
13230	        Py_XINCREF(V163);
13231	        
13232	{
13233	
13234	    py_V165 = PyList_GET_ITEM(storage_V165, 0);
13235	    {Py_XINCREF(py_V165);}
13236	    
13237	            V165 = NULL;
13238	            if (py_V165 == Py_None) {
13239	                // We can either fail here or set V165 to NULL and rely on Ops
13240	                // using tensors to handle the NULL case, but if they fail to do so
13241	                // they'll end up with nasty segfaults, so this is public service.
13242	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
13243	                {
13244	        __failure = 166;
13245	        if (!PyErr_Occurred()) {
13246	            PyErr_SetString(PyExc_RuntimeError,
13247	                "Unexpected error in an Op's C code. "
13248	                "No Python exception was set.");
13249	            }
13250	        goto __label_166;}
13251	            }
13252	            if (!PyArray_Check(py_V165)) {
13253	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
13254	                {
13255	        __failure = 166;
13256	        if (!PyErr_Occurred()) {
13257	            PyErr_SetString(PyExc_RuntimeError,
13258	                "Unexpected error in an Op's C code. "
13259	                "No Python exception was set.");
13260	            }
13261	        goto __label_166;}
13262	            }
13263	            // We expect NPY_FLOAT64
13264	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V165)) {
13265	                PyArrayObject * tmp = (PyArrayObject*) py_V165;
13266	                PyErr_Format(PyExc_NotImplementedError,
13267	                             "expected an aligned array of type %ld "
13268	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
13269	                             " with %ld dimensions, with 3 last dims "
13270	                             "%ld, %ld, %ld"
13271	                             " and 3 last strides %ld %ld, %ld.",
13272	                             (long int) NPY_FLOAT64,
13273	                             (long int) PyArray_TYPE((PyArrayObject*) py_V165),
13274	                             (long int) PyArray_NDIM(tmp),
13275	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
13276	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
13277	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
13278	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
13279	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
13280	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
13281	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
13282	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
13283	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
13284	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
13285	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
13286	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
13287	            );
13288	                {
13289	        __failure = 166;
13290	        if (!PyErr_Occurred()) {
13291	            PyErr_SetString(PyExc_RuntimeError,
13292	                "Unexpected error in an Op's C code. "
13293	                "No Python exception was set.");
13294	            }
13295	        goto __label_166;}
13296	            }
13297	            // This is a TypeError to be consistent with DEBUG_MODE
13298	            // Note: DEBUG_MODE also tells the name of the container
13299	            if (PyArray_TYPE((PyArrayObject*) py_V165) != NPY_FLOAT64) {
13300	                PyErr_Format(PyExc_TypeError,
13301	                             "expected type_num %d (NPY_FLOAT64) got %d",
13302	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V165));
13303	                {
13304	        __failure = 166;
13305	        if (!PyErr_Occurred()) {
13306	            PyErr_SetString(PyExc_RuntimeError,
13307	                "Unexpected error in an Op's C code. "
13308	                "No Python exception was set.");
13309	            }
13310	        goto __label_166;}
13311	            }
13312	            
13313	        V165 = (PyArrayObject*)(py_V165);
13314	        Py_XINCREF(V165);
13315	        
13316	{
13317	
13318	    py_V167 = PyList_GET_ITEM(storage_V167, 0);
13319	    {Py_XINCREF(py_V167);}
13320	    
13321	            V167 = NULL;
13322	            if (py_V167 == Py_None) {
13323	                // We can either fail here or set V167 to NULL and rely on Ops
13324	                // using tensors to handle the NULL case, but if they fail to do so
13325	                // they'll end up with nasty segfaults, so this is public service.
13326	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
13327	                {
13328	        __failure = 168;
13329	        if (!PyErr_Occurred()) {
13330	            PyErr_SetString(PyExc_RuntimeError,
13331	                "Unexpected error in an Op's C code. "
13332	                "No Python exception was set.");
13333	            }
13334	        goto __label_168;}
13335	            }
13336	            if (!PyArray_Check(py_V167)) {
13337	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
13338	                {
13339	        __failure = 168;
13340	        if (!PyErr_Occurred()) {
13341	            PyErr_SetString(PyExc_RuntimeError,
13342	                "Unexpected error in an Op's C code. "
13343	                "No Python exception was set.");
13344	            }
13345	        goto __label_168;}
13346	            }
13347	            // We expect NPY_FLOAT64
13348	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V167)) {
13349	                PyArrayObject * tmp = (PyArrayObject*) py_V167;
13350	                PyErr_Format(PyExc_NotImplementedError,
13351	                             "expected an aligned array of type %ld "
13352	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
13353	                             " with %ld dimensions, with 3 last dims "
13354	                             "%ld, %ld, %ld"
13355	                             " and 3 last strides %ld %ld, %ld.",
13356	                             (long int) NPY_FLOAT64,
13357	                             (long int) PyArray_TYPE((PyArrayObject*) py_V167),
13358	                             (long int) PyArray_NDIM(tmp),
13359	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
13360	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
13361	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
13362	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
13363	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
13364	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
13365	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
13366	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
13367	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
13368	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
13369	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
13370	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
13371	            );
13372	                {
13373	        __failure = 168;
13374	        if (!PyErr_Occurred()) {
13375	            PyErr_SetString(PyExc_RuntimeError,
13376	                "Unexpected error in an Op's C code. "
13377	                "No Python exception was set.");
13378	            }
13379	        goto __label_168;}
13380	            }
13381	            // This is a TypeError to be consistent with DEBUG_MODE
13382	            // Note: DEBUG_MODE also tells the name of the container
13383	            if (PyArray_TYPE((PyArrayObject*) py_V167) != NPY_FLOAT64) {
13384	                PyErr_Format(PyExc_TypeError,
13385	                             "expected type_num %d (NPY_FLOAT64) got %d",
13386	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V167));
13387	                {
13388	        __failure = 168;
13389	        if (!PyErr_Occurred()) {
13390	            PyErr_SetString(PyExc_RuntimeError,
13391	                "Unexpected error in an Op's C code. "
13392	                "No Python exception was set.");
13393	            }
13394	        goto __label_168;}
13395	            }
13396	            
13397	        V167 = (PyArrayObject*)(py_V167);
13398	        Py_XINCREF(V167);
13399	        
13400	{
13401	
13402	    py_V169 = PyList_GET_ITEM(storage_V169, 0);
13403	    {Py_XINCREF(py_V169);}
13404	    
13405	            V169 = NULL;
13406	            if (py_V169 == Py_None) {
13407	                // We can either fail here or set V169 to NULL and rely on Ops
13408	                // using tensors to handle the NULL case, but if they fail to do so
13409	                // they'll end up with nasty segfaults, so this is public service.
13410	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
13411	                {
13412	        __failure = 170;
13413	        if (!PyErr_Occurred()) {
13414	            PyErr_SetString(PyExc_RuntimeError,
13415	                "Unexpected error in an Op's C code. "
13416	                "No Python exception was set.");
13417	            }
13418	        goto __label_170;}
13419	            }
13420	            if (!PyArray_Check(py_V169)) {
13421	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
13422	                {
13423	        __failure = 170;
13424	        if (!PyErr_Occurred()) {
13425	            PyErr_SetString(PyExc_RuntimeError,
13426	                "Unexpected error in an Op's C code. "
13427	                "No Python exception was set.");
13428	            }
13429	        goto __label_170;}
13430	            }
13431	            // We expect NPY_FLOAT64
13432	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V169)) {
13433	                PyArrayObject * tmp = (PyArrayObject*) py_V169;
13434	                PyErr_Format(PyExc_NotImplementedError,
13435	                             "expected an aligned array of type %ld "
13436	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
13437	                             " with %ld dimensions, with 3 last dims "
13438	                             "%ld, %ld, %ld"
13439	                             " and 3 last strides %ld %ld, %ld.",
13440	                             (long int) NPY_FLOAT64,
13441	                             (long int) PyArray_TYPE((PyArrayObject*) py_V169),
13442	                             (long int) PyArray_NDIM(tmp),
13443	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
13444	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
13445	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
13446	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
13447	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
13448	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
13449	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
13450	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
13451	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
13452	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
13453	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
13454	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
13455	            );
13456	                {
13457	        __failure = 170;
13458	        if (!PyErr_Occurred()) {
13459	            PyErr_SetString(PyExc_RuntimeError,
13460	                "Unexpected error in an Op's C code. "
13461	                "No Python exception was set.");
13462	            }
13463	        goto __label_170;}
13464	            }
13465	            // This is a TypeError to be consistent with DEBUG_MODE
13466	            // Note: DEBUG_MODE also tells the name of the container
13467	            if (PyArray_TYPE((PyArrayObject*) py_V169) != NPY_FLOAT64) {
13468	                PyErr_Format(PyExc_TypeError,
13469	                             "expected type_num %d (NPY_FLOAT64) got %d",
13470	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V169));
13471	                {
13472	        __failure = 170;
13473	        if (!PyErr_Occurred()) {
13474	            PyErr_SetString(PyExc_RuntimeError,
13475	                "Unexpected error in an Op's C code. "
13476	                "No Python exception was set.");
13477	            }
13478	        goto __label_170;}
13479	            }
13480	            
13481	        V169 = (PyArrayObject*)(py_V169);
13482	        Py_XINCREF(V169);
13483	        
13484	{
13485	
13486	    py_V171 = PyList_GET_ITEM(storage_V171, 0);
13487	    {Py_XINCREF(py_V171);}
13488	    
13489	            V171 = NULL;
13490	            if (py_V171 == Py_None) {
13491	                // We can either fail here or set V171 to NULL and rely on Ops
13492	                // using tensors to handle the NULL case, but if they fail to do so
13493	                // they'll end up with nasty segfaults, so this is public service.
13494	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
13495	                {
13496	        __failure = 172;
13497	        if (!PyErr_Occurred()) {
13498	            PyErr_SetString(PyExc_RuntimeError,
13499	                "Unexpected error in an Op's C code. "
13500	                "No Python exception was set.");
13501	            }
13502	        goto __label_172;}
13503	            }
13504	            if (!PyArray_Check(py_V171)) {
13505	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
13506	                {
13507	        __failure = 172;
13508	        if (!PyErr_Occurred()) {
13509	            PyErr_SetString(PyExc_RuntimeError,
13510	                "Unexpected error in an Op's C code. "
13511	                "No Python exception was set.");
13512	            }
13513	        goto __label_172;}
13514	            }
13515	            // We expect NPY_FLOAT64
13516	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V171)) {
13517	                PyArrayObject * tmp = (PyArrayObject*) py_V171;
13518	                PyErr_Format(PyExc_NotImplementedError,
13519	                             "expected an aligned array of type %ld "
13520	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
13521	                             " with %ld dimensions, with 3 last dims "
13522	                             "%ld, %ld, %ld"
13523	                             " and 3 last strides %ld %ld, %ld.",
13524	                             (long int) NPY_FLOAT64,
13525	                             (long int) PyArray_TYPE((PyArrayObject*) py_V171),
13526	                             (long int) PyArray_NDIM(tmp),
13527	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
13528	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
13529	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
13530	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
13531	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
13532	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
13533	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
13534	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
13535	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
13536	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
13537	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
13538	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
13539	            );
13540	                {
13541	        __failure = 172;
13542	        if (!PyErr_Occurred()) {
13543	            PyErr_SetString(PyExc_RuntimeError,
13544	                "Unexpected error in an Op's C code. "
13545	                "No Python exception was set.");
13546	            }
13547	        goto __label_172;}
13548	            }
13549	            // This is a TypeError to be consistent with DEBUG_MODE
13550	            // Note: DEBUG_MODE also tells the name of the container
13551	            if (PyArray_TYPE((PyArrayObject*) py_V171) != NPY_FLOAT64) {
13552	                PyErr_Format(PyExc_TypeError,
13553	                             "expected type_num %d (NPY_FLOAT64) got %d",
13554	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V171));
13555	                {
13556	        __failure = 172;
13557	        if (!PyErr_Occurred()) {
13558	            PyErr_SetString(PyExc_RuntimeError,
13559	                "Unexpected error in an Op's C code. "
13560	                "No Python exception was set.");
13561	            }
13562	        goto __label_172;}
13563	            }
13564	            
13565	        V171 = (PyArrayObject*)(py_V171);
13566	        Py_XINCREF(V171);
13567	        
13568	{
13569	
13570	    py_V173 = PyList_GET_ITEM(storage_V173, 0);
13571	    {Py_XINCREF(py_V173);}
13572	    
13573	            V173 = NULL;
13574	            if (py_V173 == Py_None) {
13575	                // We can either fail here or set V173 to NULL and rely on Ops
13576	                // using tensors to handle the NULL case, but if they fail to do so
13577	                // they'll end up with nasty segfaults, so this is public service.
13578	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
13579	                {
13580	        __failure = 174;
13581	        if (!PyErr_Occurred()) {
13582	            PyErr_SetString(PyExc_RuntimeError,
13583	                "Unexpected error in an Op's C code. "
13584	                "No Python exception was set.");
13585	            }
13586	        goto __label_174;}
13587	            }
13588	            if (!PyArray_Check(py_V173)) {
13589	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
13590	                {
13591	        __failure = 174;
13592	        if (!PyErr_Occurred()) {
13593	            PyErr_SetString(PyExc_RuntimeError,
13594	                "Unexpected error in an Op's C code. "
13595	                "No Python exception was set.");
13596	            }
13597	        goto __label_174;}
13598	            }
13599	            // We expect NPY_FLOAT64
13600	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V173)) {
13601	                PyArrayObject * tmp = (PyArrayObject*) py_V173;
13602	                PyErr_Format(PyExc_NotImplementedError,
13603	                             "expected an aligned array of type %ld "
13604	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
13605	                             " with %ld dimensions, with 3 last dims "
13606	                             "%ld, %ld, %ld"
13607	                             " and 3 last strides %ld %ld, %ld.",
13608	                             (long int) NPY_FLOAT64,
13609	                             (long int) PyArray_TYPE((PyArrayObject*) py_V173),
13610	                             (long int) PyArray_NDIM(tmp),
13611	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
13612	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
13613	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
13614	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
13615	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
13616	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
13617	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
13618	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
13619	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
13620	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
13621	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
13622	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
13623	            );
13624	                {
13625	        __failure = 174;
13626	        if (!PyErr_Occurred()) {
13627	            PyErr_SetString(PyExc_RuntimeError,
13628	                "Unexpected error in an Op's C code. "
13629	                "No Python exception was set.");
13630	            }
13631	        goto __label_174;}
13632	            }
13633	            // This is a TypeError to be consistent with DEBUG_MODE
13634	            // Note: DEBUG_MODE also tells the name of the container
13635	            if (PyArray_TYPE((PyArrayObject*) py_V173) != NPY_FLOAT64) {
13636	                PyErr_Format(PyExc_TypeError,
13637	                             "expected type_num %d (NPY_FLOAT64) got %d",
13638	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V173));
13639	                {
13640	        __failure = 174;
13641	        if (!PyErr_Occurred()) {
13642	            PyErr_SetString(PyExc_RuntimeError,
13643	                "Unexpected error in an Op's C code. "
13644	                "No Python exception was set.");
13645	            }
13646	        goto __label_174;}
13647	            }
13648	            
13649	        V173 = (PyArrayObject*)(py_V173);
13650	        Py_XINCREF(V173);
13651	        
13652	{
13653	
13654	    py_V175 = PyList_GET_ITEM(storage_V175, 0);
13655	    {Py_XINCREF(py_V175);}
13656	    
13657	            V175 = NULL;
13658	            if (py_V175 == Py_None) {
13659	                // We can either fail here or set V175 to NULL and rely on Ops
13660	                // using tensors to handle the NULL case, but if they fail to do so
13661	                // they'll end up with nasty segfaults, so this is public service.
13662	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
13663	                {
13664	        __failure = 176;
13665	        if (!PyErr_Occurred()) {
13666	            PyErr_SetString(PyExc_RuntimeError,
13667	                "Unexpected error in an Op's C code. "
13668	                "No Python exception was set.");
13669	            }
13670	        goto __label_176;}
13671	            }
13672	            if (!PyArray_Check(py_V175)) {
13673	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
13674	                {
13675	        __failure = 176;
13676	        if (!PyErr_Occurred()) {
13677	            PyErr_SetString(PyExc_RuntimeError,
13678	                "Unexpected error in an Op's C code. "
13679	                "No Python exception was set.");
13680	            }
13681	        goto __label_176;}
13682	            }
13683	            // We expect NPY_FLOAT64
13684	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V175)) {
13685	                PyArrayObject * tmp = (PyArrayObject*) py_V175;
13686	                PyErr_Format(PyExc_NotImplementedError,
13687	                             "expected an aligned array of type %ld "
13688	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
13689	                             " with %ld dimensions, with 3 last dims "
13690	                             "%ld, %ld, %ld"
13691	                             " and 3 last strides %ld %ld, %ld.",
13692	                             (long int) NPY_FLOAT64,
13693	                             (long int) PyArray_TYPE((PyArrayObject*) py_V175),
13694	                             (long int) PyArray_NDIM(tmp),
13695	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
13696	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
13697	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
13698	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
13699	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
13700	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
13701	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
13702	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
13703	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
13704	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
13705	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
13706	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
13707	            );
13708	                {
13709	        __failure = 176;
13710	        if (!PyErr_Occurred()) {
13711	            PyErr_SetString(PyExc_RuntimeError,
13712	                "Unexpected error in an Op's C code. "
13713	                "No Python exception was set.");
13714	            }
13715	        goto __label_176;}
13716	            }
13717	            // This is a TypeError to be consistent with DEBUG_MODE
13718	            // Note: DEBUG_MODE also tells the name of the container
13719	            if (PyArray_TYPE((PyArrayObject*) py_V175) != NPY_FLOAT64) {
13720	                PyErr_Format(PyExc_TypeError,
13721	                             "expected type_num %d (NPY_FLOAT64) got %d",
13722	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V175));
13723	                {
13724	        __failure = 176;
13725	        if (!PyErr_Occurred()) {
13726	            PyErr_SetString(PyExc_RuntimeError,
13727	                "Unexpected error in an Op's C code. "
13728	                "No Python exception was set.");
13729	            }
13730	        goto __label_176;}
13731	            }
13732	            
13733	        V175 = (PyArrayObject*)(py_V175);
13734	        Py_XINCREF(V175);
13735	        
13736	{
13737	
13738	    py_V177 = PyList_GET_ITEM(storage_V177, 0);
13739	    {Py_XINCREF(py_V177);}
13740	    
13741	            V177 = NULL;
13742	            if (py_V177 == Py_None) {
13743	                // We can either fail here or set V177 to NULL and rely on Ops
13744	                // using tensors to handle the NULL case, but if they fail to do so
13745	                // they'll end up with nasty segfaults, so this is public service.
13746	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
13747	                {
13748	        __failure = 178;
13749	        if (!PyErr_Occurred()) {
13750	            PyErr_SetString(PyExc_RuntimeError,
13751	                "Unexpected error in an Op's C code. "
13752	                "No Python exception was set.");
13753	            }
13754	        goto __label_178;}
13755	            }
13756	            if (!PyArray_Check(py_V177)) {
13757	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
13758	                {
13759	        __failure = 178;
13760	        if (!PyErr_Occurred()) {
13761	            PyErr_SetString(PyExc_RuntimeError,
13762	                "Unexpected error in an Op's C code. "
13763	                "No Python exception was set.");
13764	            }
13765	        goto __label_178;}
13766	            }
13767	            // We expect NPY_FLOAT64
13768	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V177)) {
13769	                PyArrayObject * tmp = (PyArrayObject*) py_V177;
13770	                PyErr_Format(PyExc_NotImplementedError,
13771	                             "expected an aligned array of type %ld "
13772	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
13773	                             " with %ld dimensions, with 3 last dims "
13774	                             "%ld, %ld, %ld"
13775	                             " and 3 last strides %ld %ld, %ld.",
13776	                             (long int) NPY_FLOAT64,
13777	                             (long int) PyArray_TYPE((PyArrayObject*) py_V177),
13778	                             (long int) PyArray_NDIM(tmp),
13779	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
13780	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
13781	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
13782	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
13783	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
13784	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
13785	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
13786	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
13787	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
13788	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
13789	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
13790	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
13791	            );
13792	                {
13793	        __failure = 178;
13794	        if (!PyErr_Occurred()) {
13795	            PyErr_SetString(PyExc_RuntimeError,
13796	                "Unexpected error in an Op's C code. "
13797	                "No Python exception was set.");
13798	            }
13799	        goto __label_178;}
13800	            }
13801	            // This is a TypeError to be consistent with DEBUG_MODE
13802	            // Note: DEBUG_MODE also tells the name of the container
13803	            if (PyArray_TYPE((PyArrayObject*) py_V177) != NPY_FLOAT64) {
13804	                PyErr_Format(PyExc_TypeError,
13805	                             "expected type_num %d (NPY_FLOAT64) got %d",
13806	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V177));
13807	                {
13808	        __failure = 178;
13809	        if (!PyErr_Occurred()) {
13810	            PyErr_SetString(PyExc_RuntimeError,
13811	                "Unexpected error in an Op's C code. "
13812	                "No Python exception was set.");
13813	            }
13814	        goto __label_178;}
13815	            }
13816	            
13817	        V177 = (PyArrayObject*)(py_V177);
13818	        Py_XINCREF(V177);
13819	        
13820	{
13821	
13822	    py_V179 = PyList_GET_ITEM(storage_V179, 0);
13823	    {Py_XINCREF(py_V179);}
13824	    
13825	            V179 = NULL;
13826	            if (py_V179 == Py_None) {
13827	                // We can either fail here or set V179 to NULL and rely on Ops
13828	                // using tensors to handle the NULL case, but if they fail to do so
13829	                // they'll end up with nasty segfaults, so this is public service.
13830	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
13831	                {
13832	        __failure = 180;
13833	        if (!PyErr_Occurred()) {
13834	            PyErr_SetString(PyExc_RuntimeError,
13835	                "Unexpected error in an Op's C code. "
13836	                "No Python exception was set.");
13837	            }
13838	        goto __label_180;}
13839	            }
13840	            if (!PyArray_Check(py_V179)) {
13841	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
13842	                {
13843	        __failure = 180;
13844	        if (!PyErr_Occurred()) {
13845	            PyErr_SetString(PyExc_RuntimeError,
13846	                "Unexpected error in an Op's C code. "
13847	                "No Python exception was set.");
13848	            }
13849	        goto __label_180;}
13850	            }
13851	            // We expect NPY_FLOAT64
13852	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V179)) {
13853	                PyArrayObject * tmp = (PyArrayObject*) py_V179;
13854	                PyErr_Format(PyExc_NotImplementedError,
13855	                             "expected an aligned array of type %ld "
13856	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
13857	                             " with %ld dimensions, with 3 last dims "
13858	                             "%ld, %ld, %ld"
13859	                             " and 3 last strides %ld %ld, %ld.",
13860	                             (long int) NPY_FLOAT64,
13861	                             (long int) PyArray_TYPE((PyArrayObject*) py_V179),
13862	                             (long int) PyArray_NDIM(tmp),
13863	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
13864	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
13865	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
13866	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
13867	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
13868	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
13869	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
13870	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
13871	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
13872	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
13873	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
13874	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
13875	            );
13876	                {
13877	        __failure = 180;
13878	        if (!PyErr_Occurred()) {
13879	            PyErr_SetString(PyExc_RuntimeError,
13880	                "Unexpected error in an Op's C code. "
13881	                "No Python exception was set.");
13882	            }
13883	        goto __label_180;}
13884	            }
13885	            // This is a TypeError to be consistent with DEBUG_MODE
13886	            // Note: DEBUG_MODE also tells the name of the container
13887	            if (PyArray_TYPE((PyArrayObject*) py_V179) != NPY_FLOAT64) {
13888	                PyErr_Format(PyExc_TypeError,
13889	                             "expected type_num %d (NPY_FLOAT64) got %d",
13890	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V179));
13891	                {
13892	        __failure = 180;
13893	        if (!PyErr_Occurred()) {
13894	            PyErr_SetString(PyExc_RuntimeError,
13895	                "Unexpected error in an Op's C code. "
13896	                "No Python exception was set.");
13897	            }
13898	        goto __label_180;}
13899	            }
13900	            
13901	        V179 = (PyArrayObject*)(py_V179);
13902	        Py_XINCREF(V179);
13903	        
13904	{
13905	
13906	    py_V181 = PyList_GET_ITEM(storage_V181, 0);
13907	    {Py_XINCREF(py_V181);}
13908	    
13909	            V181 = NULL;
13910	            if (py_V181 == Py_None) {
13911	                // We can either fail here or set V181 to NULL and rely on Ops
13912	                // using tensors to handle the NULL case, but if they fail to do so
13913	                // they'll end up with nasty segfaults, so this is public service.
13914	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
13915	                {
13916	        __failure = 182;
13917	        if (!PyErr_Occurred()) {
13918	            PyErr_SetString(PyExc_RuntimeError,
13919	                "Unexpected error in an Op's C code. "
13920	                "No Python exception was set.");
13921	            }
13922	        goto __label_182;}
13923	            }
13924	            if (!PyArray_Check(py_V181)) {
13925	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
13926	                {
13927	        __failure = 182;
13928	        if (!PyErr_Occurred()) {
13929	            PyErr_SetString(PyExc_RuntimeError,
13930	                "Unexpected error in an Op's C code. "
13931	                "No Python exception was set.");
13932	            }
13933	        goto __label_182;}
13934	            }
13935	            // We expect NPY_FLOAT64
13936	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V181)) {
13937	                PyArrayObject * tmp = (PyArrayObject*) py_V181;
13938	                PyErr_Format(PyExc_NotImplementedError,
13939	                             "expected an aligned array of type %ld "
13940	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
13941	                             " with %ld dimensions, with 3 last dims "
13942	                             "%ld, %ld, %ld"
13943	                             " and 3 last strides %ld %ld, %ld.",
13944	                             (long int) NPY_FLOAT64,
13945	                             (long int) PyArray_TYPE((PyArrayObject*) py_V181),
13946	                             (long int) PyArray_NDIM(tmp),
13947	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
13948	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
13949	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
13950	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
13951	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
13952	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
13953	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
13954	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
13955	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
13956	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
13957	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
13958	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
13959	            );
13960	                {
13961	        __failure = 182;
13962	        if (!PyErr_Occurred()) {
13963	            PyErr_SetString(PyExc_RuntimeError,
13964	                "Unexpected error in an Op's C code. "
13965	                "No Python exception was set.");
13966	            }
13967	        goto __label_182;}
13968	            }
13969	            // This is a TypeError to be consistent with DEBUG_MODE
13970	            // Note: DEBUG_MODE also tells the name of the container
13971	            if (PyArray_TYPE((PyArrayObject*) py_V181) != NPY_FLOAT64) {
13972	                PyErr_Format(PyExc_TypeError,
13973	                             "expected type_num %d (NPY_FLOAT64) got %d",
13974	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V181));
13975	                {
13976	        __failure = 182;
13977	        if (!PyErr_Occurred()) {
13978	            PyErr_SetString(PyExc_RuntimeError,
13979	                "Unexpected error in an Op's C code. "
13980	                "No Python exception was set.");
13981	            }
13982	        goto __label_182;}
13983	            }
13984	            
13985	        V181 = (PyArrayObject*)(py_V181);
13986	        Py_XINCREF(V181);
13987	        
13988	{
13989	
13990	    py_V183 = PyList_GET_ITEM(storage_V183, 0);
13991	    {Py_XINCREF(py_V183);}
13992	    
13993	            V183 = NULL;
13994	            if (py_V183 == Py_None) {
13995	                // We can either fail here or set V183 to NULL and rely on Ops
13996	                // using tensors to handle the NULL case, but if they fail to do so
13997	                // they'll end up with nasty segfaults, so this is public service.
13998	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
13999	                {
14000	        __failure = 184;
14001	        if (!PyErr_Occurred()) {
14002	            PyErr_SetString(PyExc_RuntimeError,
14003	                "Unexpected error in an Op's C code. "
14004	                "No Python exception was set.");
14005	            }
14006	        goto __label_184;}
14007	            }
14008	            if (!PyArray_Check(py_V183)) {
14009	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
14010	                {
14011	        __failure = 184;
14012	        if (!PyErr_Occurred()) {
14013	            PyErr_SetString(PyExc_RuntimeError,
14014	                "Unexpected error in an Op's C code. "
14015	                "No Python exception was set.");
14016	            }
14017	        goto __label_184;}
14018	            }
14019	            // We expect NPY_FLOAT64
14020	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V183)) {
14021	                PyArrayObject * tmp = (PyArrayObject*) py_V183;
14022	                PyErr_Format(PyExc_NotImplementedError,
14023	                             "expected an aligned array of type %ld "
14024	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
14025	                             " with %ld dimensions, with 3 last dims "
14026	                             "%ld, %ld, %ld"
14027	                             " and 3 last strides %ld %ld, %ld.",
14028	                             (long int) NPY_FLOAT64,
14029	                             (long int) PyArray_TYPE((PyArrayObject*) py_V183),
14030	                             (long int) PyArray_NDIM(tmp),
14031	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
14032	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
14033	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
14034	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
14035	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
14036	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
14037	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
14038	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
14039	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
14040	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
14041	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
14042	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
14043	            );
14044	                {
14045	        __failure = 184;
14046	        if (!PyErr_Occurred()) {
14047	            PyErr_SetString(PyExc_RuntimeError,
14048	                "Unexpected error in an Op's C code. "
14049	                "No Python exception was set.");
14050	            }
14051	        goto __label_184;}
14052	            }
14053	            // This is a TypeError to be consistent with DEBUG_MODE
14054	            // Note: DEBUG_MODE also tells the name of the container
14055	            if (PyArray_TYPE((PyArrayObject*) py_V183) != NPY_FLOAT64) {
14056	                PyErr_Format(PyExc_TypeError,
14057	                             "expected type_num %d (NPY_FLOAT64) got %d",
14058	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V183));
14059	                {
14060	        __failure = 184;
14061	        if (!PyErr_Occurred()) {
14062	            PyErr_SetString(PyExc_RuntimeError,
14063	                "Unexpected error in an Op's C code. "
14064	                "No Python exception was set.");
14065	            }
14066	        goto __label_184;}
14067	            }
14068	            
14069	        V183 = (PyArrayObject*)(py_V183);
14070	        Py_XINCREF(V183);
14071	        
14072	{
14073	
14074	    py_V185 = PyList_GET_ITEM(storage_V185, 0);
14075	    {Py_XINCREF(py_V185);}
14076	    
14077	            V185 = NULL;
14078	            if (py_V185 == Py_None) {
14079	                // We can either fail here or set V185 to NULL and rely on Ops
14080	                // using tensors to handle the NULL case, but if they fail to do so
14081	                // they'll end up with nasty segfaults, so this is public service.
14082	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
14083	                {
14084	        __failure = 186;
14085	        if (!PyErr_Occurred()) {
14086	            PyErr_SetString(PyExc_RuntimeError,
14087	                "Unexpected error in an Op's C code. "
14088	                "No Python exception was set.");
14089	            }
14090	        goto __label_186;}
14091	            }
14092	            if (!PyArray_Check(py_V185)) {
14093	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
14094	                {
14095	        __failure = 186;
14096	        if (!PyErr_Occurred()) {
14097	            PyErr_SetString(PyExc_RuntimeError,
14098	                "Unexpected error in an Op's C code. "
14099	                "No Python exception was set.");
14100	            }
14101	        goto __label_186;}
14102	            }
14103	            // We expect NPY_FLOAT64
14104	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V185)) {
14105	                PyArrayObject * tmp = (PyArrayObject*) py_V185;
14106	                PyErr_Format(PyExc_NotImplementedError,
14107	                             "expected an aligned array of type %ld "
14108	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
14109	                             " with %ld dimensions, with 3 last dims "
14110	                             "%ld, %ld, %ld"
14111	                             " and 3 last strides %ld %ld, %ld.",
14112	                             (long int) NPY_FLOAT64,
14113	                             (long int) PyArray_TYPE((PyArrayObject*) py_V185),
14114	                             (long int) PyArray_NDIM(tmp),
14115	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
14116	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
14117	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
14118	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
14119	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
14120	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
14121	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
14122	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
14123	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
14124	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
14125	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
14126	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
14127	            );
14128	                {
14129	        __failure = 186;
14130	        if (!PyErr_Occurred()) {
14131	            PyErr_SetString(PyExc_RuntimeError,
14132	                "Unexpected error in an Op's C code. "
14133	                "No Python exception was set.");
14134	            }
14135	        goto __label_186;}
14136	            }
14137	            // This is a TypeError to be consistent with DEBUG_MODE
14138	            // Note: DEBUG_MODE also tells the name of the container
14139	            if (PyArray_TYPE((PyArrayObject*) py_V185) != NPY_FLOAT64) {
14140	                PyErr_Format(PyExc_TypeError,
14141	                             "expected type_num %d (NPY_FLOAT64) got %d",
14142	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V185));
14143	                {
14144	        __failure = 186;
14145	        if (!PyErr_Occurred()) {
14146	            PyErr_SetString(PyExc_RuntimeError,
14147	                "Unexpected error in an Op's C code. "
14148	                "No Python exception was set.");
14149	            }
14150	        goto __label_186;}
14151	            }
14152	            
14153	        V185 = (PyArrayObject*)(py_V185);
14154	        Py_XINCREF(V185);
14155	        
14156	{
14157	
14158	    py_V187 = PyList_GET_ITEM(storage_V187, 0);
14159	    {Py_XINCREF(py_V187);}
14160	    
14161	            V187 = NULL;
14162	            if (py_V187 == Py_None) {
14163	                // We can either fail here or set V187 to NULL and rely on Ops
14164	                // using tensors to handle the NULL case, but if they fail to do so
14165	                // they'll end up with nasty segfaults, so this is public service.
14166	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
14167	                {
14168	        __failure = 188;
14169	        if (!PyErr_Occurred()) {
14170	            PyErr_SetString(PyExc_RuntimeError,
14171	                "Unexpected error in an Op's C code. "
14172	                "No Python exception was set.");
14173	            }
14174	        goto __label_188;}
14175	            }
14176	            if (!PyArray_Check(py_V187)) {
14177	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
14178	                {
14179	        __failure = 188;
14180	        if (!PyErr_Occurred()) {
14181	            PyErr_SetString(PyExc_RuntimeError,
14182	                "Unexpected error in an Op's C code. "
14183	                "No Python exception was set.");
14184	            }
14185	        goto __label_188;}
14186	            }
14187	            // We expect NPY_FLOAT64
14188	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V187)) {
14189	                PyArrayObject * tmp = (PyArrayObject*) py_V187;
14190	                PyErr_Format(PyExc_NotImplementedError,
14191	                             "expected an aligned array of type %ld "
14192	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
14193	                             " with %ld dimensions, with 3 last dims "
14194	                             "%ld, %ld, %ld"
14195	                             " and 3 last strides %ld %ld, %ld.",
14196	                             (long int) NPY_FLOAT64,
14197	                             (long int) PyArray_TYPE((PyArrayObject*) py_V187),
14198	                             (long int) PyArray_NDIM(tmp),
14199	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
14200	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
14201	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
14202	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
14203	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
14204	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
14205	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
14206	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
14207	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
14208	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
14209	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
14210	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
14211	            );
14212	                {
14213	        __failure = 188;
14214	        if (!PyErr_Occurred()) {
14215	            PyErr_SetString(PyExc_RuntimeError,
14216	                "Unexpected error in an Op's C code. "
14217	                "No Python exception was set.");
14218	            }
14219	        goto __label_188;}
14220	            }
14221	            // This is a TypeError to be consistent with DEBUG_MODE
14222	            // Note: DEBUG_MODE also tells the name of the container
14223	            if (PyArray_TYPE((PyArrayObject*) py_V187) != NPY_FLOAT64) {
14224	                PyErr_Format(PyExc_TypeError,
14225	                             "expected type_num %d (NPY_FLOAT64) got %d",
14226	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V187));
14227	                {
14228	        __failure = 188;
14229	        if (!PyErr_Occurred()) {
14230	            PyErr_SetString(PyExc_RuntimeError,
14231	                "Unexpected error in an Op's C code. "
14232	                "No Python exception was set.");
14233	            }
14234	        goto __label_188;}
14235	            }
14236	            
14237	        V187 = (PyArrayObject*)(py_V187);
14238	        Py_XINCREF(V187);
14239	        
14240	{
14241	
14242	    py_V189 = PyList_GET_ITEM(storage_V189, 0);
14243	    {Py_XINCREF(py_V189);}
14244	    
14245	            V189 = NULL;
14246	            if (py_V189 == Py_None) {
14247	                // We can either fail here or set V189 to NULL and rely on Ops
14248	                // using tensors to handle the NULL case, but if they fail to do so
14249	                // they'll end up with nasty segfaults, so this is public service.
14250	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
14251	                {
14252	        __failure = 190;
14253	        if (!PyErr_Occurred()) {
14254	            PyErr_SetString(PyExc_RuntimeError,
14255	                "Unexpected error in an Op's C code. "
14256	                "No Python exception was set.");
14257	            }
14258	        goto __label_190;}
14259	            }
14260	            if (!PyArray_Check(py_V189)) {
14261	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
14262	                {
14263	        __failure = 190;
14264	        if (!PyErr_Occurred()) {
14265	            PyErr_SetString(PyExc_RuntimeError,
14266	                "Unexpected error in an Op's C code. "
14267	                "No Python exception was set.");
14268	            }
14269	        goto __label_190;}
14270	            }
14271	            // We expect NPY_FLOAT64
14272	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V189)) {
14273	                PyArrayObject * tmp = (PyArrayObject*) py_V189;
14274	                PyErr_Format(PyExc_NotImplementedError,
14275	                             "expected an aligned array of type %ld "
14276	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
14277	                             " with %ld dimensions, with 3 last dims "
14278	                             "%ld, %ld, %ld"
14279	                             " and 3 last strides %ld %ld, %ld.",
14280	                             (long int) NPY_FLOAT64,
14281	                             (long int) PyArray_TYPE((PyArrayObject*) py_V189),
14282	                             (long int) PyArray_NDIM(tmp),
14283	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
14284	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
14285	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
14286	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
14287	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
14288	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
14289	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
14290	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
14291	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
14292	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
14293	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
14294	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
14295	            );
14296	                {
14297	        __failure = 190;
14298	        if (!PyErr_Occurred()) {
14299	            PyErr_SetString(PyExc_RuntimeError,
14300	                "Unexpected error in an Op's C code. "
14301	                "No Python exception was set.");
14302	            }
14303	        goto __label_190;}
14304	            }
14305	            // This is a TypeError to be consistent with DEBUG_MODE
14306	            // Note: DEBUG_MODE also tells the name of the container
14307	            if (PyArray_TYPE((PyArrayObject*) py_V189) != NPY_FLOAT64) {
14308	                PyErr_Format(PyExc_TypeError,
14309	                             "expected type_num %d (NPY_FLOAT64) got %d",
14310	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V189));
14311	                {
14312	        __failure = 190;
14313	        if (!PyErr_Occurred()) {
14314	            PyErr_SetString(PyExc_RuntimeError,
14315	                "Unexpected error in an Op's C code. "
14316	                "No Python exception was set.");
14317	            }
14318	        goto __label_190;}
14319	            }
14320	            
14321	        V189 = (PyArrayObject*)(py_V189);
14322	        Py_XINCREF(V189);
14323	        
14324	{
14325	
14326	    py_V191 = PyList_GET_ITEM(storage_V191, 0);
14327	    {Py_XINCREF(py_V191);}
14328	    
14329	            V191 = NULL;
14330	            if (py_V191 == Py_None) {
14331	                // We can either fail here or set V191 to NULL and rely on Ops
14332	                // using tensors to handle the NULL case, but if they fail to do so
14333	                // they'll end up with nasty segfaults, so this is public service.
14334	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
14335	                {
14336	        __failure = 192;
14337	        if (!PyErr_Occurred()) {
14338	            PyErr_SetString(PyExc_RuntimeError,
14339	                "Unexpected error in an Op's C code. "
14340	                "No Python exception was set.");
14341	            }
14342	        goto __label_192;}
14343	            }
14344	            if (!PyArray_Check(py_V191)) {
14345	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
14346	                {
14347	        __failure = 192;
14348	        if (!PyErr_Occurred()) {
14349	            PyErr_SetString(PyExc_RuntimeError,
14350	                "Unexpected error in an Op's C code. "
14351	                "No Python exception was set.");
14352	            }
14353	        goto __label_192;}
14354	            }
14355	            // We expect NPY_FLOAT64
14356	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V191)) {
14357	                PyArrayObject * tmp = (PyArrayObject*) py_V191;
14358	                PyErr_Format(PyExc_NotImplementedError,
14359	                             "expected an aligned array of type %ld "
14360	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
14361	                             " with %ld dimensions, with 3 last dims "
14362	                             "%ld, %ld, %ld"
14363	                             " and 3 last strides %ld %ld, %ld.",
14364	                             (long int) NPY_FLOAT64,
14365	                             (long int) PyArray_TYPE((PyArrayObject*) py_V191),
14366	                             (long int) PyArray_NDIM(tmp),
14367	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
14368	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
14369	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
14370	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
14371	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
14372	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
14373	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
14374	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
14375	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
14376	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
14377	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
14378	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
14379	            );
14380	                {
14381	        __failure = 192;
14382	        if (!PyErr_Occurred()) {
14383	            PyErr_SetString(PyExc_RuntimeError,
14384	                "Unexpected error in an Op's C code. "
14385	                "No Python exception was set.");
14386	            }
14387	        goto __label_192;}
14388	            }
14389	            // This is a TypeError to be consistent with DEBUG_MODE
14390	            // Note: DEBUG_MODE also tells the name of the container
14391	            if (PyArray_TYPE((PyArrayObject*) py_V191) != NPY_FLOAT64) {
14392	                PyErr_Format(PyExc_TypeError,
14393	                             "expected type_num %d (NPY_FLOAT64) got %d",
14394	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V191));
14395	                {
14396	        __failure = 192;
14397	        if (!PyErr_Occurred()) {
14398	            PyErr_SetString(PyExc_RuntimeError,
14399	                "Unexpected error in an Op's C code. "
14400	                "No Python exception was set.");
14401	            }
14402	        goto __label_192;}
14403	            }
14404	            
14405	        V191 = (PyArrayObject*)(py_V191);
14406	        Py_XINCREF(V191);
14407	        
14408	{
14409	
14410	    py_V193 = PyList_GET_ITEM(storage_V193, 0);
14411	    {Py_XINCREF(py_V193);}
14412	    
14413	            V193 = NULL;
14414	            if (py_V193 == Py_None) {
14415	                // We can either fail here or set V193 to NULL and rely on Ops
14416	                // using tensors to handle the NULL case, but if they fail to do so
14417	                // they'll end up with nasty segfaults, so this is public service.
14418	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
14419	                {
14420	        __failure = 194;
14421	        if (!PyErr_Occurred()) {
14422	            PyErr_SetString(PyExc_RuntimeError,
14423	                "Unexpected error in an Op's C code. "
14424	                "No Python exception was set.");
14425	            }
14426	        goto __label_194;}
14427	            }
14428	            if (!PyArray_Check(py_V193)) {
14429	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
14430	                {
14431	        __failure = 194;
14432	        if (!PyErr_Occurred()) {
14433	            PyErr_SetString(PyExc_RuntimeError,
14434	                "Unexpected error in an Op's C code. "
14435	                "No Python exception was set.");
14436	            }
14437	        goto __label_194;}
14438	            }
14439	            // We expect NPY_FLOAT64
14440	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V193)) {
14441	                PyArrayObject * tmp = (PyArrayObject*) py_V193;
14442	                PyErr_Format(PyExc_NotImplementedError,
14443	                             "expected an aligned array of type %ld "
14444	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
14445	                             " with %ld dimensions, with 3 last dims "
14446	                             "%ld, %ld, %ld"
14447	                             " and 3 last strides %ld %ld, %ld.",
14448	                             (long int) NPY_FLOAT64,
14449	                             (long int) PyArray_TYPE((PyArrayObject*) py_V193),
14450	                             (long int) PyArray_NDIM(tmp),
14451	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
14452	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
14453	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
14454	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
14455	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
14456	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
14457	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
14458	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
14459	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
14460	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
14461	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
14462	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
14463	            );
14464	                {
14465	        __failure = 194;
14466	        if (!PyErr_Occurred()) {
14467	            PyErr_SetString(PyExc_RuntimeError,
14468	                "Unexpected error in an Op's C code. "
14469	                "No Python exception was set.");
14470	            }
14471	        goto __label_194;}
14472	            }
14473	            // This is a TypeError to be consistent with DEBUG_MODE
14474	            // Note: DEBUG_MODE also tells the name of the container
14475	            if (PyArray_TYPE((PyArrayObject*) py_V193) != NPY_FLOAT64) {
14476	                PyErr_Format(PyExc_TypeError,
14477	                             "expected type_num %d (NPY_FLOAT64) got %d",
14478	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V193));
14479	                {
14480	        __failure = 194;
14481	        if (!PyErr_Occurred()) {
14482	            PyErr_SetString(PyExc_RuntimeError,
14483	                "Unexpected error in an Op's C code. "
14484	                "No Python exception was set.");
14485	            }
14486	        goto __label_194;}
14487	            }
14488	            
14489	        V193 = (PyArrayObject*)(py_V193);
14490	        Py_XINCREF(V193);
14491	        
14492	{
14493	
14494	    py_V195 = PyList_GET_ITEM(storage_V195, 0);
14495	    {Py_XINCREF(py_V195);}
14496	    
14497	            V195 = NULL;
14498	            if (py_V195 == Py_None) {
14499	                // We can either fail here or set V195 to NULL and rely on Ops
14500	                // using tensors to handle the NULL case, but if they fail to do so
14501	                // they'll end up with nasty segfaults, so this is public service.
14502	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
14503	                {
14504	        __failure = 196;
14505	        if (!PyErr_Occurred()) {
14506	            PyErr_SetString(PyExc_RuntimeError,
14507	                "Unexpected error in an Op's C code. "
14508	                "No Python exception was set.");
14509	            }
14510	        goto __label_196;}
14511	            }
14512	            if (!PyArray_Check(py_V195)) {
14513	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
14514	                {
14515	        __failure = 196;
14516	        if (!PyErr_Occurred()) {
14517	            PyErr_SetString(PyExc_RuntimeError,
14518	                "Unexpected error in an Op's C code. "
14519	                "No Python exception was set.");
14520	            }
14521	        goto __label_196;}
14522	            }
14523	            // We expect NPY_FLOAT64
14524	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V195)) {
14525	                PyArrayObject * tmp = (PyArrayObject*) py_V195;
14526	                PyErr_Format(PyExc_NotImplementedError,
14527	                             "expected an aligned array of type %ld "
14528	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
14529	                             " with %ld dimensions, with 3 last dims "
14530	                             "%ld, %ld, %ld"
14531	                             " and 3 last strides %ld %ld, %ld.",
14532	                             (long int) NPY_FLOAT64,
14533	                             (long int) PyArray_TYPE((PyArrayObject*) py_V195),
14534	                             (long int) PyArray_NDIM(tmp),
14535	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
14536	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
14537	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
14538	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
14539	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
14540	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
14541	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
14542	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
14543	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
14544	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
14545	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
14546	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
14547	            );
14548	                {
14549	        __failure = 196;
14550	        if (!PyErr_Occurred()) {
14551	            PyErr_SetString(PyExc_RuntimeError,
14552	                "Unexpected error in an Op's C code. "
14553	                "No Python exception was set.");
14554	            }
14555	        goto __label_196;}
14556	            }
14557	            // This is a TypeError to be consistent with DEBUG_MODE
14558	            // Note: DEBUG_MODE also tells the name of the container
14559	            if (PyArray_TYPE((PyArrayObject*) py_V195) != NPY_FLOAT64) {
14560	                PyErr_Format(PyExc_TypeError,
14561	                             "expected type_num %d (NPY_FLOAT64) got %d",
14562	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V195));
14563	                {
14564	        __failure = 196;
14565	        if (!PyErr_Occurred()) {
14566	            PyErr_SetString(PyExc_RuntimeError,
14567	                "Unexpected error in an Op's C code. "
14568	                "No Python exception was set.");
14569	            }
14570	        goto __label_196;}
14571	            }
14572	            
14573	        V195 = (PyArrayObject*)(py_V195);
14574	        Py_XINCREF(V195);
14575	        
14576	{
14577	
14578	    py_V197 = PyList_GET_ITEM(storage_V197, 0);
14579	    {Py_XINCREF(py_V197);}
14580	    
14581	            V197 = NULL;
14582	            if (py_V197 == Py_None) {
14583	                // We can either fail here or set V197 to NULL and rely on Ops
14584	                // using tensors to handle the NULL case, but if they fail to do so
14585	                // they'll end up with nasty segfaults, so this is public service.
14586	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
14587	                {
14588	        __failure = 198;
14589	        if (!PyErr_Occurred()) {
14590	            PyErr_SetString(PyExc_RuntimeError,
14591	                "Unexpected error in an Op's C code. "
14592	                "No Python exception was set.");
14593	            }
14594	        goto __label_198;}
14595	            }
14596	            if (!PyArray_Check(py_V197)) {
14597	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
14598	                {
14599	        __failure = 198;
14600	        if (!PyErr_Occurred()) {
14601	            PyErr_SetString(PyExc_RuntimeError,
14602	                "Unexpected error in an Op's C code. "
14603	                "No Python exception was set.");
14604	            }
14605	        goto __label_198;}
14606	            }
14607	            // We expect NPY_FLOAT64
14608	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V197)) {
14609	                PyArrayObject * tmp = (PyArrayObject*) py_V197;
14610	                PyErr_Format(PyExc_NotImplementedError,
14611	                             "expected an aligned array of type %ld "
14612	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
14613	                             " with %ld dimensions, with 3 last dims "
14614	                             "%ld, %ld, %ld"
14615	                             " and 3 last strides %ld %ld, %ld.",
14616	                             (long int) NPY_FLOAT64,
14617	                             (long int) PyArray_TYPE((PyArrayObject*) py_V197),
14618	                             (long int) PyArray_NDIM(tmp),
14619	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
14620	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
14621	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
14622	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
14623	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
14624	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
14625	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
14626	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
14627	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
14628	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
14629	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
14630	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
14631	            );
14632	                {
14633	        __failure = 198;
14634	        if (!PyErr_Occurred()) {
14635	            PyErr_SetString(PyExc_RuntimeError,
14636	                "Unexpected error in an Op's C code. "
14637	                "No Python exception was set.");
14638	            }
14639	        goto __label_198;}
14640	            }
14641	            // This is a TypeError to be consistent with DEBUG_MODE
14642	            // Note: DEBUG_MODE also tells the name of the container
14643	            if (PyArray_TYPE((PyArrayObject*) py_V197) != NPY_FLOAT64) {
14644	                PyErr_Format(PyExc_TypeError,
14645	                             "expected type_num %d (NPY_FLOAT64) got %d",
14646	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V197));
14647	                {
14648	        __failure = 198;
14649	        if (!PyErr_Occurred()) {
14650	            PyErr_SetString(PyExc_RuntimeError,
14651	                "Unexpected error in an Op's C code. "
14652	                "No Python exception was set.");
14653	            }
14654	        goto __label_198;}
14655	            }
14656	            
14657	        V197 = (PyArrayObject*)(py_V197);
14658	        Py_XINCREF(V197);
14659	        
14660	{
14661	
14662	    py_V199 = PyList_GET_ITEM(storage_V199, 0);
14663	    {Py_XINCREF(py_V199);}
14664	    
14665	            V199 = NULL;
14666	            if (py_V199 == Py_None) {
14667	                // We can either fail here or set V199 to NULL and rely on Ops
14668	                // using tensors to handle the NULL case, but if they fail to do so
14669	                // they'll end up with nasty segfaults, so this is public service.
14670	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
14671	                {
14672	        __failure = 200;
14673	        if (!PyErr_Occurred()) {
14674	            PyErr_SetString(PyExc_RuntimeError,
14675	                "Unexpected error in an Op's C code. "
14676	                "No Python exception was set.");
14677	            }
14678	        goto __label_200;}
14679	            }
14680	            if (!PyArray_Check(py_V199)) {
14681	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
14682	                {
14683	        __failure = 200;
14684	        if (!PyErr_Occurred()) {
14685	            PyErr_SetString(PyExc_RuntimeError,
14686	                "Unexpected error in an Op's C code. "
14687	                "No Python exception was set.");
14688	            }
14689	        goto __label_200;}
14690	            }
14691	            // We expect NPY_FLOAT64
14692	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V199)) {
14693	                PyArrayObject * tmp = (PyArrayObject*) py_V199;
14694	                PyErr_Format(PyExc_NotImplementedError,
14695	                             "expected an aligned array of type %ld "
14696	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
14697	                             " with %ld dimensions, with 3 last dims "
14698	                             "%ld, %ld, %ld"
14699	                             " and 3 last strides %ld %ld, %ld.",
14700	                             (long int) NPY_FLOAT64,
14701	                             (long int) PyArray_TYPE((PyArrayObject*) py_V199),
14702	                             (long int) PyArray_NDIM(tmp),
14703	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
14704	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
14705	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
14706	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
14707	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
14708	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
14709	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
14710	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
14711	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
14712	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
14713	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
14714	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
14715	            );
14716	                {
14717	        __failure = 200;
14718	        if (!PyErr_Occurred()) {
14719	            PyErr_SetString(PyExc_RuntimeError,
14720	                "Unexpected error in an Op's C code. "
14721	                "No Python exception was set.");
14722	            }
14723	        goto __label_200;}
14724	            }
14725	            // This is a TypeError to be consistent with DEBUG_MODE
14726	            // Note: DEBUG_MODE also tells the name of the container
14727	            if (PyArray_TYPE((PyArrayObject*) py_V199) != NPY_FLOAT64) {
14728	                PyErr_Format(PyExc_TypeError,
14729	                             "expected type_num %d (NPY_FLOAT64) got %d",
14730	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V199));
14731	                {
14732	        __failure = 200;
14733	        if (!PyErr_Occurred()) {
14734	            PyErr_SetString(PyExc_RuntimeError,
14735	                "Unexpected error in an Op's C code. "
14736	                "No Python exception was set.");
14737	            }
14738	        goto __label_200;}
14739	            }
14740	            
14741	        V199 = (PyArrayObject*)(py_V199);
14742	        Py_XINCREF(V199);
14743	        
14744	{
14745	
14746	    py_V201 = PyList_GET_ITEM(storage_V201, 0);
14747	    {Py_XINCREF(py_V201);}
14748	    
14749	            V201 = NULL;
14750	            if (py_V201 == Py_None) {
14751	                // We can either fail here or set V201 to NULL and rely on Ops
14752	                // using tensors to handle the NULL case, but if they fail to do so
14753	                // they'll end up with nasty segfaults, so this is public service.
14754	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
14755	                {
14756	        __failure = 202;
14757	        if (!PyErr_Occurred()) {
14758	            PyErr_SetString(PyExc_RuntimeError,
14759	                "Unexpected error in an Op's C code. "
14760	                "No Python exception was set.");
14761	            }
14762	        goto __label_202;}
14763	            }
14764	            if (!PyArray_Check(py_V201)) {
14765	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
14766	                {
14767	        __failure = 202;
14768	        if (!PyErr_Occurred()) {
14769	            PyErr_SetString(PyExc_RuntimeError,
14770	                "Unexpected error in an Op's C code. "
14771	                "No Python exception was set.");
14772	            }
14773	        goto __label_202;}
14774	            }
14775	            // We expect NPY_FLOAT64
14776	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V201)) {
14777	                PyArrayObject * tmp = (PyArrayObject*) py_V201;
14778	                PyErr_Format(PyExc_NotImplementedError,
14779	                             "expected an aligned array of type %ld "
14780	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
14781	                             " with %ld dimensions, with 3 last dims "
14782	                             "%ld, %ld, %ld"
14783	                             " and 3 last strides %ld %ld, %ld.",
14784	                             (long int) NPY_FLOAT64,
14785	                             (long int) PyArray_TYPE((PyArrayObject*) py_V201),
14786	                             (long int) PyArray_NDIM(tmp),
14787	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
14788	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
14789	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
14790	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
14791	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
14792	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
14793	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
14794	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
14795	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
14796	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
14797	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
14798	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
14799	            );
14800	                {
14801	        __failure = 202;
14802	        if (!PyErr_Occurred()) {
14803	            PyErr_SetString(PyExc_RuntimeError,
14804	                "Unexpected error in an Op's C code. "
14805	                "No Python exception was set.");
14806	            }
14807	        goto __label_202;}
14808	            }
14809	            // This is a TypeError to be consistent with DEBUG_MODE
14810	            // Note: DEBUG_MODE also tells the name of the container
14811	            if (PyArray_TYPE((PyArrayObject*) py_V201) != NPY_FLOAT64) {
14812	                PyErr_Format(PyExc_TypeError,
14813	                             "expected type_num %d (NPY_FLOAT64) got %d",
14814	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V201));
14815	                {
14816	        __failure = 202;
14817	        if (!PyErr_Occurred()) {
14818	            PyErr_SetString(PyExc_RuntimeError,
14819	                "Unexpected error in an Op's C code. "
14820	                "No Python exception was set.");
14821	            }
14822	        goto __label_202;}
14823	            }
14824	            
14825	        V201 = (PyArrayObject*)(py_V201);
14826	        Py_XINCREF(V201);
14827	        
14828	{
14829	
14830	    py_V203 = PyList_GET_ITEM(storage_V203, 0);
14831	    {Py_XINCREF(py_V203);}
14832	    
14833	            V203 = NULL;
14834	            if (py_V203 == Py_None) {
14835	                // We can either fail here or set V203 to NULL and rely on Ops
14836	                // using tensors to handle the NULL case, but if they fail to do so
14837	                // they'll end up with nasty segfaults, so this is public service.
14838	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
14839	                {
14840	        __failure = 204;
14841	        if (!PyErr_Occurred()) {
14842	            PyErr_SetString(PyExc_RuntimeError,
14843	                "Unexpected error in an Op's C code. "
14844	                "No Python exception was set.");
14845	            }
14846	        goto __label_204;}
14847	            }
14848	            if (!PyArray_Check(py_V203)) {
14849	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
14850	                {
14851	        __failure = 204;
14852	        if (!PyErr_Occurred()) {
14853	            PyErr_SetString(PyExc_RuntimeError,
14854	                "Unexpected error in an Op's C code. "
14855	                "No Python exception was set.");
14856	            }
14857	        goto __label_204;}
14858	            }
14859	            // We expect NPY_FLOAT64
14860	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V203)) {
14861	                PyArrayObject * tmp = (PyArrayObject*) py_V203;
14862	                PyErr_Format(PyExc_NotImplementedError,
14863	                             "expected an aligned array of type %ld "
14864	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
14865	                             " with %ld dimensions, with 3 last dims "
14866	                             "%ld, %ld, %ld"
14867	                             " and 3 last strides %ld %ld, %ld.",
14868	                             (long int) NPY_FLOAT64,
14869	                             (long int) PyArray_TYPE((PyArrayObject*) py_V203),
14870	                             (long int) PyArray_NDIM(tmp),
14871	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
14872	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
14873	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
14874	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
14875	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
14876	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
14877	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
14878	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
14879	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
14880	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
14881	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
14882	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
14883	            );
14884	                {
14885	        __failure = 204;
14886	        if (!PyErr_Occurred()) {
14887	            PyErr_SetString(PyExc_RuntimeError,
14888	                "Unexpected error in an Op's C code. "
14889	                "No Python exception was set.");
14890	            }
14891	        goto __label_204;}
14892	            }
14893	            // This is a TypeError to be consistent with DEBUG_MODE
14894	            // Note: DEBUG_MODE also tells the name of the container
14895	            if (PyArray_TYPE((PyArrayObject*) py_V203) != NPY_FLOAT64) {
14896	                PyErr_Format(PyExc_TypeError,
14897	                             "expected type_num %d (NPY_FLOAT64) got %d",
14898	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V203));
14899	                {
14900	        __failure = 204;
14901	        if (!PyErr_Occurred()) {
14902	            PyErr_SetString(PyExc_RuntimeError,
14903	                "Unexpected error in an Op's C code. "
14904	                "No Python exception was set.");
14905	            }
14906	        goto __label_204;}
14907	            }
14908	            
14909	        V203 = (PyArrayObject*)(py_V203);
14910	        Py_XINCREF(V203);
14911	        
14912	{
14913	
14914	    py_V205 = PyList_GET_ITEM(storage_V205, 0);
14915	    {Py_XINCREF(py_V205);}
14916	    
14917	            V205 = NULL;
14918	            if (py_V205 == Py_None) {
14919	                // We can either fail here or set V205 to NULL and rely on Ops
14920	                // using tensors to handle the NULL case, but if they fail to do so
14921	                // they'll end up with nasty segfaults, so this is public service.
14922	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
14923	                {
14924	        __failure = 206;
14925	        if (!PyErr_Occurred()) {
14926	            PyErr_SetString(PyExc_RuntimeError,
14927	                "Unexpected error in an Op's C code. "
14928	                "No Python exception was set.");
14929	            }
14930	        goto __label_206;}
14931	            }
14932	            if (!PyArray_Check(py_V205)) {
14933	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
14934	                {
14935	        __failure = 206;
14936	        if (!PyErr_Occurred()) {
14937	            PyErr_SetString(PyExc_RuntimeError,
14938	                "Unexpected error in an Op's C code. "
14939	                "No Python exception was set.");
14940	            }
14941	        goto __label_206;}
14942	            }
14943	            // We expect NPY_FLOAT64
14944	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V205)) {
14945	                PyArrayObject * tmp = (PyArrayObject*) py_V205;
14946	                PyErr_Format(PyExc_NotImplementedError,
14947	                             "expected an aligned array of type %ld "
14948	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
14949	                             " with %ld dimensions, with 3 last dims "
14950	                             "%ld, %ld, %ld"
14951	                             " and 3 last strides %ld %ld, %ld.",
14952	                             (long int) NPY_FLOAT64,
14953	                             (long int) PyArray_TYPE((PyArrayObject*) py_V205),
14954	                             (long int) PyArray_NDIM(tmp),
14955	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
14956	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
14957	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
14958	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
14959	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
14960	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
14961	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
14962	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
14963	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
14964	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
14965	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
14966	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
14967	            );
14968	                {
14969	        __failure = 206;
14970	        if (!PyErr_Occurred()) {
14971	            PyErr_SetString(PyExc_RuntimeError,
14972	                "Unexpected error in an Op's C code. "
14973	                "No Python exception was set.");
14974	            }
14975	        goto __label_206;}
14976	            }
14977	            // This is a TypeError to be consistent with DEBUG_MODE
14978	            // Note: DEBUG_MODE also tells the name of the container
14979	            if (PyArray_TYPE((PyArrayObject*) py_V205) != NPY_FLOAT64) {
14980	                PyErr_Format(PyExc_TypeError,
14981	                             "expected type_num %d (NPY_FLOAT64) got %d",
14982	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V205));
14983	                {
14984	        __failure = 206;
14985	        if (!PyErr_Occurred()) {
14986	            PyErr_SetString(PyExc_RuntimeError,
14987	                "Unexpected error in an Op's C code. "
14988	                "No Python exception was set.");
14989	            }
14990	        goto __label_206;}
14991	            }
14992	            
14993	        V205 = (PyArrayObject*)(py_V205);
14994	        Py_XINCREF(V205);
14995	        
14996	{
14997	
14998	    py_V207 = PyList_GET_ITEM(storage_V207, 0);
14999	    {Py_XINCREF(py_V207);}
15000	    
15001	            V207 = NULL;
15002	            if (py_V207 == Py_None) {
15003	                // We can either fail here or set V207 to NULL and rely on Ops
15004	                // using tensors to handle the NULL case, but if they fail to do so
15005	                // they'll end up with nasty segfaults, so this is public service.
15006	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
15007	                {
15008	        __failure = 208;
15009	        if (!PyErr_Occurred()) {
15010	            PyErr_SetString(PyExc_RuntimeError,
15011	                "Unexpected error in an Op's C code. "
15012	                "No Python exception was set.");
15013	            }
15014	        goto __label_208;}
15015	            }
15016	            if (!PyArray_Check(py_V207)) {
15017	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
15018	                {
15019	        __failure = 208;
15020	        if (!PyErr_Occurred()) {
15021	            PyErr_SetString(PyExc_RuntimeError,
15022	                "Unexpected error in an Op's C code. "
15023	                "No Python exception was set.");
15024	            }
15025	        goto __label_208;}
15026	            }
15027	            // We expect NPY_FLOAT64
15028	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V207)) {
15029	                PyArrayObject * tmp = (PyArrayObject*) py_V207;
15030	                PyErr_Format(PyExc_NotImplementedError,
15031	                             "expected an aligned array of type %ld "
15032	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
15033	                             " with %ld dimensions, with 3 last dims "
15034	                             "%ld, %ld, %ld"
15035	                             " and 3 last strides %ld %ld, %ld.",
15036	                             (long int) NPY_FLOAT64,
15037	                             (long int) PyArray_TYPE((PyArrayObject*) py_V207),
15038	                             (long int) PyArray_NDIM(tmp),
15039	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
15040	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
15041	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
15042	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
15043	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
15044	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
15045	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
15046	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
15047	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
15048	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
15049	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
15050	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
15051	            );
15052	                {
15053	        __failure = 208;
15054	        if (!PyErr_Occurred()) {
15055	            PyErr_SetString(PyExc_RuntimeError,
15056	                "Unexpected error in an Op's C code. "
15057	                "No Python exception was set.");
15058	            }
15059	        goto __label_208;}
15060	            }
15061	            // This is a TypeError to be consistent with DEBUG_MODE
15062	            // Note: DEBUG_MODE also tells the name of the container
15063	            if (PyArray_TYPE((PyArrayObject*) py_V207) != NPY_FLOAT64) {
15064	                PyErr_Format(PyExc_TypeError,
15065	                             "expected type_num %d (NPY_FLOAT64) got %d",
15066	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V207));
15067	                {
15068	        __failure = 208;
15069	        if (!PyErr_Occurred()) {
15070	            PyErr_SetString(PyExc_RuntimeError,
15071	                "Unexpected error in an Op's C code. "
15072	                "No Python exception was set.");
15073	            }
15074	        goto __label_208;}
15075	            }
15076	            
15077	        V207 = (PyArrayObject*)(py_V207);
15078	        Py_XINCREF(V207);
15079	        
15080	{
15081	
15082	    py_V209 = PyList_GET_ITEM(storage_V209, 0);
15083	    {Py_XINCREF(py_V209);}
15084	    
15085	            V209 = NULL;
15086	            if (py_V209 == Py_None) {
15087	                // We can either fail here or set V209 to NULL and rely on Ops
15088	                // using tensors to handle the NULL case, but if they fail to do so
15089	                // they'll end up with nasty segfaults, so this is public service.
15090	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
15091	                {
15092	        __failure = 210;
15093	        if (!PyErr_Occurred()) {
15094	            PyErr_SetString(PyExc_RuntimeError,
15095	                "Unexpected error in an Op's C code. "
15096	                "No Python exception was set.");
15097	            }
15098	        goto __label_210;}
15099	            }
15100	            if (!PyArray_Check(py_V209)) {
15101	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
15102	                {
15103	        __failure = 210;
15104	        if (!PyErr_Occurred()) {
15105	            PyErr_SetString(PyExc_RuntimeError,
15106	                "Unexpected error in an Op's C code. "
15107	                "No Python exception was set.");
15108	            }
15109	        goto __label_210;}
15110	            }
15111	            // We expect NPY_FLOAT64
15112	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V209)) {
15113	                PyArrayObject * tmp = (PyArrayObject*) py_V209;
15114	                PyErr_Format(PyExc_NotImplementedError,
15115	                             "expected an aligned array of type %ld "
15116	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
15117	                             " with %ld dimensions, with 3 last dims "
15118	                             "%ld, %ld, %ld"
15119	                             " and 3 last strides %ld %ld, %ld.",
15120	                             (long int) NPY_FLOAT64,
15121	                             (long int) PyArray_TYPE((PyArrayObject*) py_V209),
15122	                             (long int) PyArray_NDIM(tmp),
15123	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
15124	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
15125	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
15126	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
15127	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
15128	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
15129	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
15130	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
15131	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
15132	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
15133	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
15134	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
15135	            );
15136	                {
15137	        __failure = 210;
15138	        if (!PyErr_Occurred()) {
15139	            PyErr_SetString(PyExc_RuntimeError,
15140	                "Unexpected error in an Op's C code. "
15141	                "No Python exception was set.");
15142	            }
15143	        goto __label_210;}
15144	            }
15145	            // This is a TypeError to be consistent with DEBUG_MODE
15146	            // Note: DEBUG_MODE also tells the name of the container
15147	            if (PyArray_TYPE((PyArrayObject*) py_V209) != NPY_FLOAT64) {
15148	                PyErr_Format(PyExc_TypeError,
15149	                             "expected type_num %d (NPY_FLOAT64) got %d",
15150	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V209));
15151	                {
15152	        __failure = 210;
15153	        if (!PyErr_Occurred()) {
15154	            PyErr_SetString(PyExc_RuntimeError,
15155	                "Unexpected error in an Op's C code. "
15156	                "No Python exception was set.");
15157	            }
15158	        goto __label_210;}
15159	            }
15160	            
15161	        V209 = (PyArrayObject*)(py_V209);
15162	        Py_XINCREF(V209);
15163	        
15164	{
15165	
15166	    py_V211 = PyList_GET_ITEM(storage_V211, 0);
15167	    {Py_XINCREF(py_V211);}
15168	    
15169	            V211 = NULL;
15170	            if (py_V211 == Py_None) {
15171	                // We can either fail here or set V211 to NULL and rely on Ops
15172	                // using tensors to handle the NULL case, but if they fail to do so
15173	                // they'll end up with nasty segfaults, so this is public service.
15174	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
15175	                {
15176	        __failure = 212;
15177	        if (!PyErr_Occurred()) {
15178	            PyErr_SetString(PyExc_RuntimeError,
15179	                "Unexpected error in an Op's C code. "
15180	                "No Python exception was set.");
15181	            }
15182	        goto __label_212;}
15183	            }
15184	            if (!PyArray_Check(py_V211)) {
15185	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
15186	                {
15187	        __failure = 212;
15188	        if (!PyErr_Occurred()) {
15189	            PyErr_SetString(PyExc_RuntimeError,
15190	                "Unexpected error in an Op's C code. "
15191	                "No Python exception was set.");
15192	            }
15193	        goto __label_212;}
15194	            }
15195	            // We expect NPY_FLOAT64
15196	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V211)) {
15197	                PyArrayObject * tmp = (PyArrayObject*) py_V211;
15198	                PyErr_Format(PyExc_NotImplementedError,
15199	                             "expected an aligned array of type %ld "
15200	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
15201	                             " with %ld dimensions, with 3 last dims "
15202	                             "%ld, %ld, %ld"
15203	                             " and 3 last strides %ld %ld, %ld.",
15204	                             (long int) NPY_FLOAT64,
15205	                             (long int) PyArray_TYPE((PyArrayObject*) py_V211),
15206	                             (long int) PyArray_NDIM(tmp),
15207	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
15208	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
15209	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
15210	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
15211	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
15212	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
15213	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
15214	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
15215	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
15216	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
15217	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
15218	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
15219	            );
15220	                {
15221	        __failure = 212;
15222	        if (!PyErr_Occurred()) {
15223	            PyErr_SetString(PyExc_RuntimeError,
15224	                "Unexpected error in an Op's C code. "
15225	                "No Python exception was set.");
15226	            }
15227	        goto __label_212;}
15228	            }
15229	            // This is a TypeError to be consistent with DEBUG_MODE
15230	            // Note: DEBUG_MODE also tells the name of the container
15231	            if (PyArray_TYPE((PyArrayObject*) py_V211) != NPY_FLOAT64) {
15232	                PyErr_Format(PyExc_TypeError,
15233	                             "expected type_num %d (NPY_FLOAT64) got %d",
15234	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V211));
15235	                {
15236	        __failure = 212;
15237	        if (!PyErr_Occurred()) {
15238	            PyErr_SetString(PyExc_RuntimeError,
15239	                "Unexpected error in an Op's C code. "
15240	                "No Python exception was set.");
15241	            }
15242	        goto __label_212;}
15243	            }
15244	            
15245	        V211 = (PyArrayObject*)(py_V211);
15246	        Py_XINCREF(V211);
15247	        
15248	{
15249	
15250	    py_V213 = PyList_GET_ITEM(storage_V213, 0);
15251	    {Py_XINCREF(py_V213);}
15252	    
15253	            V213 = NULL;
15254	            if (py_V213 == Py_None) {
15255	                // We can either fail here or set V213 to NULL and rely on Ops
15256	                // using tensors to handle the NULL case, but if they fail to do so
15257	                // they'll end up with nasty segfaults, so this is public service.
15258	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
15259	                {
15260	        __failure = 214;
15261	        if (!PyErr_Occurred()) {
15262	            PyErr_SetString(PyExc_RuntimeError,
15263	                "Unexpected error in an Op's C code. "
15264	                "No Python exception was set.");
15265	            }
15266	        goto __label_214;}
15267	            }
15268	            if (!PyArray_Check(py_V213)) {
15269	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
15270	                {
15271	        __failure = 214;
15272	        if (!PyErr_Occurred()) {
15273	            PyErr_SetString(PyExc_RuntimeError,
15274	                "Unexpected error in an Op's C code. "
15275	                "No Python exception was set.");
15276	            }
15277	        goto __label_214;}
15278	            }
15279	            // We expect NPY_FLOAT64
15280	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V213)) {
15281	                PyArrayObject * tmp = (PyArrayObject*) py_V213;
15282	                PyErr_Format(PyExc_NotImplementedError,
15283	                             "expected an aligned array of type %ld "
15284	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
15285	                             " with %ld dimensions, with 3 last dims "
15286	                             "%ld, %ld, %ld"
15287	                             " and 3 last strides %ld %ld, %ld.",
15288	                             (long int) NPY_FLOAT64,
15289	                             (long int) PyArray_TYPE((PyArrayObject*) py_V213),
15290	                             (long int) PyArray_NDIM(tmp),
15291	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
15292	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
15293	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
15294	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
15295	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
15296	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
15297	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
15298	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
15299	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
15300	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
15301	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
15302	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
15303	            );
15304	                {
15305	        __failure = 214;
15306	        if (!PyErr_Occurred()) {
15307	            PyErr_SetString(PyExc_RuntimeError,
15308	                "Unexpected error in an Op's C code. "
15309	                "No Python exception was set.");
15310	            }
15311	        goto __label_214;}
15312	            }
15313	            // This is a TypeError to be consistent with DEBUG_MODE
15314	            // Note: DEBUG_MODE also tells the name of the container
15315	            if (PyArray_TYPE((PyArrayObject*) py_V213) != NPY_FLOAT64) {
15316	                PyErr_Format(PyExc_TypeError,
15317	                             "expected type_num %d (NPY_FLOAT64) got %d",
15318	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V213));
15319	                {
15320	        __failure = 214;
15321	        if (!PyErr_Occurred()) {
15322	            PyErr_SetString(PyExc_RuntimeError,
15323	                "Unexpected error in an Op's C code. "
15324	                "No Python exception was set.");
15325	            }
15326	        goto __label_214;}
15327	            }
15328	            
15329	        V213 = (PyArrayObject*)(py_V213);
15330	        Py_XINCREF(V213);
15331	        
15332	{
15333	
15334	    py_V215 = PyList_GET_ITEM(storage_V215, 0);
15335	    {Py_XINCREF(py_V215);}
15336	    
15337	            V215 = NULL;
15338	            if (py_V215 == Py_None) {
15339	                // We can either fail here or set V215 to NULL and rely on Ops
15340	                // using tensors to handle the NULL case, but if they fail to do so
15341	                // they'll end up with nasty segfaults, so this is public service.
15342	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
15343	                {
15344	        __failure = 216;
15345	        if (!PyErr_Occurred()) {
15346	            PyErr_SetString(PyExc_RuntimeError,
15347	                "Unexpected error in an Op's C code. "
15348	                "No Python exception was set.");
15349	            }
15350	        goto __label_216;}
15351	            }
15352	            if (!PyArray_Check(py_V215)) {
15353	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
15354	                {
15355	        __failure = 216;
15356	        if (!PyErr_Occurred()) {
15357	            PyErr_SetString(PyExc_RuntimeError,
15358	                "Unexpected error in an Op's C code. "
15359	                "No Python exception was set.");
15360	            }
15361	        goto __label_216;}
15362	            }
15363	            // We expect NPY_FLOAT64
15364	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V215)) {
15365	                PyArrayObject * tmp = (PyArrayObject*) py_V215;
15366	                PyErr_Format(PyExc_NotImplementedError,
15367	                             "expected an aligned array of type %ld "
15368	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
15369	                             " with %ld dimensions, with 3 last dims "
15370	                             "%ld, %ld, %ld"
15371	                             " and 3 last strides %ld %ld, %ld.",
15372	                             (long int) NPY_FLOAT64,
15373	                             (long int) PyArray_TYPE((PyArrayObject*) py_V215),
15374	                             (long int) PyArray_NDIM(tmp),
15375	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
15376	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
15377	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
15378	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
15379	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
15380	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
15381	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
15382	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
15383	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
15384	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
15385	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
15386	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
15387	            );
15388	                {
15389	        __failure = 216;
15390	        if (!PyErr_Occurred()) {
15391	            PyErr_SetString(PyExc_RuntimeError,
15392	                "Unexpected error in an Op's C code. "
15393	                "No Python exception was set.");
15394	            }
15395	        goto __label_216;}
15396	            }
15397	            // This is a TypeError to be consistent with DEBUG_MODE
15398	            // Note: DEBUG_MODE also tells the name of the container
15399	            if (PyArray_TYPE((PyArrayObject*) py_V215) != NPY_FLOAT64) {
15400	                PyErr_Format(PyExc_TypeError,
15401	                             "expected type_num %d (NPY_FLOAT64) got %d",
15402	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V215));
15403	                {
15404	        __failure = 216;
15405	        if (!PyErr_Occurred()) {
15406	            PyErr_SetString(PyExc_RuntimeError,
15407	                "Unexpected error in an Op's C code. "
15408	                "No Python exception was set.");
15409	            }
15410	        goto __label_216;}
15411	            }
15412	            
15413	        V215 = (PyArrayObject*)(py_V215);
15414	        Py_XINCREF(V215);
15415	        
15416	{
15417	
15418	    py_V217 = PyList_GET_ITEM(storage_V217, 0);
15419	    {Py_XINCREF(py_V217);}
15420	    
15421	            V217 = NULL;
15422	            if (py_V217 == Py_None) {
15423	                // We can either fail here or set V217 to NULL and rely on Ops
15424	                // using tensors to handle the NULL case, but if they fail to do so
15425	                // they'll end up with nasty segfaults, so this is public service.
15426	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
15427	                {
15428	        __failure = 218;
15429	        if (!PyErr_Occurred()) {
15430	            PyErr_SetString(PyExc_RuntimeError,
15431	                "Unexpected error in an Op's C code. "
15432	                "No Python exception was set.");
15433	            }
15434	        goto __label_218;}
15435	            }
15436	            if (!PyArray_Check(py_V217)) {
15437	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
15438	                {
15439	        __failure = 218;
15440	        if (!PyErr_Occurred()) {
15441	            PyErr_SetString(PyExc_RuntimeError,
15442	                "Unexpected error in an Op's C code. "
15443	                "No Python exception was set.");
15444	            }
15445	        goto __label_218;}
15446	            }
15447	            // We expect NPY_FLOAT64
15448	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V217)) {
15449	                PyArrayObject * tmp = (PyArrayObject*) py_V217;
15450	                PyErr_Format(PyExc_NotImplementedError,
15451	                             "expected an aligned array of type %ld "
15452	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
15453	                             " with %ld dimensions, with 3 last dims "
15454	                             "%ld, %ld, %ld"
15455	                             " and 3 last strides %ld %ld, %ld.",
15456	                             (long int) NPY_FLOAT64,
15457	                             (long int) PyArray_TYPE((PyArrayObject*) py_V217),
15458	                             (long int) PyArray_NDIM(tmp),
15459	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
15460	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
15461	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
15462	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
15463	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
15464	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
15465	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
15466	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
15467	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
15468	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
15469	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
15470	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
15471	            );
15472	                {
15473	        __failure = 218;
15474	        if (!PyErr_Occurred()) {
15475	            PyErr_SetString(PyExc_RuntimeError,
15476	                "Unexpected error in an Op's C code. "
15477	                "No Python exception was set.");
15478	            }
15479	        goto __label_218;}
15480	            }
15481	            // This is a TypeError to be consistent with DEBUG_MODE
15482	            // Note: DEBUG_MODE also tells the name of the container
15483	            if (PyArray_TYPE((PyArrayObject*) py_V217) != NPY_FLOAT64) {
15484	                PyErr_Format(PyExc_TypeError,
15485	                             "expected type_num %d (NPY_FLOAT64) got %d",
15486	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V217));
15487	                {
15488	        __failure = 218;
15489	        if (!PyErr_Occurred()) {
15490	            PyErr_SetString(PyExc_RuntimeError,
15491	                "Unexpected error in an Op's C code. "
15492	                "No Python exception was set.");
15493	            }
15494	        goto __label_218;}
15495	            }
15496	            
15497	        V217 = (PyArrayObject*)(py_V217);
15498	        Py_XINCREF(V217);
15499	        
15500	{
15501	
15502	    py_V219 = PyList_GET_ITEM(storage_V219, 0);
15503	    {Py_XINCREF(py_V219);}
15504	    
15505	            V219 = NULL;
15506	            if (py_V219 == Py_None) {
15507	                // We can either fail here or set V219 to NULL and rely on Ops
15508	                // using tensors to handle the NULL case, but if they fail to do so
15509	                // they'll end up with nasty segfaults, so this is public service.
15510	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
15511	                {
15512	        __failure = 220;
15513	        if (!PyErr_Occurred()) {
15514	            PyErr_SetString(PyExc_RuntimeError,
15515	                "Unexpected error in an Op's C code. "
15516	                "No Python exception was set.");
15517	            }
15518	        goto __label_220;}
15519	            }
15520	            if (!PyArray_Check(py_V219)) {
15521	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
15522	                {
15523	        __failure = 220;
15524	        if (!PyErr_Occurred()) {
15525	            PyErr_SetString(PyExc_RuntimeError,
15526	                "Unexpected error in an Op's C code. "
15527	                "No Python exception was set.");
15528	            }
15529	        goto __label_220;}
15530	            }
15531	            // We expect NPY_FLOAT64
15532	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V219)) {
15533	                PyArrayObject * tmp = (PyArrayObject*) py_V219;
15534	                PyErr_Format(PyExc_NotImplementedError,
15535	                             "expected an aligned array of type %ld "
15536	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
15537	                             " with %ld dimensions, with 3 last dims "
15538	                             "%ld, %ld, %ld"
15539	                             " and 3 last strides %ld %ld, %ld.",
15540	                             (long int) NPY_FLOAT64,
15541	                             (long int) PyArray_TYPE((PyArrayObject*) py_V219),
15542	                             (long int) PyArray_NDIM(tmp),
15543	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
15544	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
15545	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
15546	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
15547	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
15548	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
15549	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
15550	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
15551	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
15552	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
15553	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
15554	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
15555	            );
15556	                {
15557	        __failure = 220;
15558	        if (!PyErr_Occurred()) {
15559	            PyErr_SetString(PyExc_RuntimeError,
15560	                "Unexpected error in an Op's C code. "
15561	                "No Python exception was set.");
15562	            }
15563	        goto __label_220;}
15564	            }
15565	            // This is a TypeError to be consistent with DEBUG_MODE
15566	            // Note: DEBUG_MODE also tells the name of the container
15567	            if (PyArray_TYPE((PyArrayObject*) py_V219) != NPY_FLOAT64) {
15568	                PyErr_Format(PyExc_TypeError,
15569	                             "expected type_num %d (NPY_FLOAT64) got %d",
15570	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V219));
15571	                {
15572	        __failure = 220;
15573	        if (!PyErr_Occurred()) {
15574	            PyErr_SetString(PyExc_RuntimeError,
15575	                "Unexpected error in an Op's C code. "
15576	                "No Python exception was set.");
15577	            }
15578	        goto __label_220;}
15579	            }
15580	            
15581	        V219 = (PyArrayObject*)(py_V219);
15582	        Py_XINCREF(V219);
15583	        
15584	{
15585	
15586	    py_V221 = PyList_GET_ITEM(storage_V221, 0);
15587	    {Py_XINCREF(py_V221);}
15588	    
15589	            V221 = NULL;
15590	            if (py_V221 == Py_None) {
15591	                // We can either fail here or set V221 to NULL and rely on Ops
15592	                // using tensors to handle the NULL case, but if they fail to do so
15593	                // they'll end up with nasty segfaults, so this is public service.
15594	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
15595	                {
15596	        __failure = 222;
15597	        if (!PyErr_Occurred()) {
15598	            PyErr_SetString(PyExc_RuntimeError,
15599	                "Unexpected error in an Op's C code. "
15600	                "No Python exception was set.");
15601	            }
15602	        goto __label_222;}
15603	            }
15604	            if (!PyArray_Check(py_V221)) {
15605	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
15606	                {
15607	        __failure = 222;
15608	        if (!PyErr_Occurred()) {
15609	            PyErr_SetString(PyExc_RuntimeError,
15610	                "Unexpected error in an Op's C code. "
15611	                "No Python exception was set.");
15612	            }
15613	        goto __label_222;}
15614	            }
15615	            // We expect NPY_FLOAT64
15616	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V221)) {
15617	                PyArrayObject * tmp = (PyArrayObject*) py_V221;
15618	                PyErr_Format(PyExc_NotImplementedError,
15619	                             "expected an aligned array of type %ld "
15620	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
15621	                             " with %ld dimensions, with 3 last dims "
15622	                             "%ld, %ld, %ld"
15623	                             " and 3 last strides %ld %ld, %ld.",
15624	                             (long int) NPY_FLOAT64,
15625	                             (long int) PyArray_TYPE((PyArrayObject*) py_V221),
15626	                             (long int) PyArray_NDIM(tmp),
15627	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
15628	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
15629	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
15630	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
15631	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
15632	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
15633	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
15634	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
15635	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
15636	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
15637	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
15638	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
15639	            );
15640	                {
15641	        __failure = 222;
15642	        if (!PyErr_Occurred()) {
15643	            PyErr_SetString(PyExc_RuntimeError,
15644	                "Unexpected error in an Op's C code. "
15645	                "No Python exception was set.");
15646	            }
15647	        goto __label_222;}
15648	            }
15649	            // This is a TypeError to be consistent with DEBUG_MODE
15650	            // Note: DEBUG_MODE also tells the name of the container
15651	            if (PyArray_TYPE((PyArrayObject*) py_V221) != NPY_FLOAT64) {
15652	                PyErr_Format(PyExc_TypeError,
15653	                             "expected type_num %d (NPY_FLOAT64) got %d",
15654	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V221));
15655	                {
15656	        __failure = 222;
15657	        if (!PyErr_Occurred()) {
15658	            PyErr_SetString(PyExc_RuntimeError,
15659	                "Unexpected error in an Op's C code. "
15660	                "No Python exception was set.");
15661	            }
15662	        goto __label_222;}
15663	            }
15664	            
15665	        V221 = (PyArrayObject*)(py_V221);
15666	        Py_XINCREF(V221);
15667	        
15668	{
15669	
15670	    py_V223 = PyList_GET_ITEM(storage_V223, 0);
15671	    {Py_XINCREF(py_V223);}
15672	    
15673	            V223 = NULL;
15674	            if (py_V223 == Py_None) {
15675	                // We can either fail here or set V223 to NULL and rely on Ops
15676	                // using tensors to handle the NULL case, but if they fail to do so
15677	                // they'll end up with nasty segfaults, so this is public service.
15678	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
15679	                {
15680	        __failure = 224;
15681	        if (!PyErr_Occurred()) {
15682	            PyErr_SetString(PyExc_RuntimeError,
15683	                "Unexpected error in an Op's C code. "
15684	                "No Python exception was set.");
15685	            }
15686	        goto __label_224;}
15687	            }
15688	            if (!PyArray_Check(py_V223)) {
15689	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
15690	                {
15691	        __failure = 224;
15692	        if (!PyErr_Occurred()) {
15693	            PyErr_SetString(PyExc_RuntimeError,
15694	                "Unexpected error in an Op's C code. "
15695	                "No Python exception was set.");
15696	            }
15697	        goto __label_224;}
15698	            }
15699	            // We expect NPY_FLOAT64
15700	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V223)) {
15701	                PyArrayObject * tmp = (PyArrayObject*) py_V223;
15702	                PyErr_Format(PyExc_NotImplementedError,
15703	                             "expected an aligned array of type %ld "
15704	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
15705	                             " with %ld dimensions, with 3 last dims "
15706	                             "%ld, %ld, %ld"
15707	                             " and 3 last strides %ld %ld, %ld.",
15708	                             (long int) NPY_FLOAT64,
15709	                             (long int) PyArray_TYPE((PyArrayObject*) py_V223),
15710	                             (long int) PyArray_NDIM(tmp),
15711	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
15712	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
15713	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
15714	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
15715	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
15716	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
15717	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
15718	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
15719	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
15720	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
15721	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
15722	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
15723	            );
15724	                {
15725	        __failure = 224;
15726	        if (!PyErr_Occurred()) {
15727	            PyErr_SetString(PyExc_RuntimeError,
15728	                "Unexpected error in an Op's C code. "
15729	                "No Python exception was set.");
15730	            }
15731	        goto __label_224;}
15732	            }
15733	            // This is a TypeError to be consistent with DEBUG_MODE
15734	            // Note: DEBUG_MODE also tells the name of the container
15735	            if (PyArray_TYPE((PyArrayObject*) py_V223) != NPY_FLOAT64) {
15736	                PyErr_Format(PyExc_TypeError,
15737	                             "expected type_num %d (NPY_FLOAT64) got %d",
15738	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V223));
15739	                {
15740	        __failure = 224;
15741	        if (!PyErr_Occurred()) {
15742	            PyErr_SetString(PyExc_RuntimeError,
15743	                "Unexpected error in an Op's C code. "
15744	                "No Python exception was set.");
15745	            }
15746	        goto __label_224;}
15747	            }
15748	            
15749	        V223 = (PyArrayObject*)(py_V223);
15750	        Py_XINCREF(V223);
15751	        
15752	{
15753	
15754	    py_V225 = PyList_GET_ITEM(storage_V225, 0);
15755	    {Py_XINCREF(py_V225);}
15756	    
15757	            V225 = NULL;
15758	            if (py_V225 == Py_None) {
15759	                // We can either fail here or set V225 to NULL and rely on Ops
15760	                // using tensors to handle the NULL case, but if they fail to do so
15761	                // they'll end up with nasty segfaults, so this is public service.
15762	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
15763	                {
15764	        __failure = 226;
15765	        if (!PyErr_Occurred()) {
15766	            PyErr_SetString(PyExc_RuntimeError,
15767	                "Unexpected error in an Op's C code. "
15768	                "No Python exception was set.");
15769	            }
15770	        goto __label_226;}
15771	            }
15772	            if (!PyArray_Check(py_V225)) {
15773	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
15774	                {
15775	        __failure = 226;
15776	        if (!PyErr_Occurred()) {
15777	            PyErr_SetString(PyExc_RuntimeError,
15778	                "Unexpected error in an Op's C code. "
15779	                "No Python exception was set.");
15780	            }
15781	        goto __label_226;}
15782	            }
15783	            // We expect NPY_FLOAT64
15784	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V225)) {
15785	                PyArrayObject * tmp = (PyArrayObject*) py_V225;
15786	                PyErr_Format(PyExc_NotImplementedError,
15787	                             "expected an aligned array of type %ld "
15788	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
15789	                             " with %ld dimensions, with 3 last dims "
15790	                             "%ld, %ld, %ld"
15791	                             " and 3 last strides %ld %ld, %ld.",
15792	                             (long int) NPY_FLOAT64,
15793	                             (long int) PyArray_TYPE((PyArrayObject*) py_V225),
15794	                             (long int) PyArray_NDIM(tmp),
15795	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
15796	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
15797	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
15798	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
15799	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
15800	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
15801	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
15802	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
15803	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
15804	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
15805	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
15806	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
15807	            );
15808	                {
15809	        __failure = 226;
15810	        if (!PyErr_Occurred()) {
15811	            PyErr_SetString(PyExc_RuntimeError,
15812	                "Unexpected error in an Op's C code. "
15813	                "No Python exception was set.");
15814	            }
15815	        goto __label_226;}
15816	            }
15817	            // This is a TypeError to be consistent with DEBUG_MODE
15818	            // Note: DEBUG_MODE also tells the name of the container
15819	            if (PyArray_TYPE((PyArrayObject*) py_V225) != NPY_FLOAT64) {
15820	                PyErr_Format(PyExc_TypeError,
15821	                             "expected type_num %d (NPY_FLOAT64) got %d",
15822	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V225));
15823	                {
15824	        __failure = 226;
15825	        if (!PyErr_Occurred()) {
15826	            PyErr_SetString(PyExc_RuntimeError,
15827	                "Unexpected error in an Op's C code. "
15828	                "No Python exception was set.");
15829	            }
15830	        goto __label_226;}
15831	            }
15832	            
15833	        V225 = (PyArrayObject*)(py_V225);
15834	        Py_XINCREF(V225);
15835	        
15836	{
15837	
15838	    py_V227 = PyList_GET_ITEM(storage_V227, 0);
15839	    {Py_XINCREF(py_V227);}
15840	    
15841	            V227 = NULL;
15842	            if (py_V227 == Py_None) {
15843	                // We can either fail here or set V227 to NULL and rely on Ops
15844	                // using tensors to handle the NULL case, but if they fail to do so
15845	                // they'll end up with nasty segfaults, so this is public service.
15846	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
15847	                {
15848	        __failure = 228;
15849	        if (!PyErr_Occurred()) {
15850	            PyErr_SetString(PyExc_RuntimeError,
15851	                "Unexpected error in an Op's C code. "
15852	                "No Python exception was set.");
15853	            }
15854	        goto __label_228;}
15855	            }
15856	            if (!PyArray_Check(py_V227)) {
15857	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
15858	                {
15859	        __failure = 228;
15860	        if (!PyErr_Occurred()) {
15861	            PyErr_SetString(PyExc_RuntimeError,
15862	                "Unexpected error in an Op's C code. "
15863	                "No Python exception was set.");
15864	            }
15865	        goto __label_228;}
15866	            }
15867	            // We expect NPY_FLOAT64
15868	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V227)) {
15869	                PyArrayObject * tmp = (PyArrayObject*) py_V227;
15870	                PyErr_Format(PyExc_NotImplementedError,
15871	                             "expected an aligned array of type %ld "
15872	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
15873	                             " with %ld dimensions, with 3 last dims "
15874	                             "%ld, %ld, %ld"
15875	                             " and 3 last strides %ld %ld, %ld.",
15876	                             (long int) NPY_FLOAT64,
15877	                             (long int) PyArray_TYPE((PyArrayObject*) py_V227),
15878	                             (long int) PyArray_NDIM(tmp),
15879	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
15880	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
15881	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
15882	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
15883	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
15884	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
15885	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
15886	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
15887	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
15888	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
15889	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
15890	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
15891	            );
15892	                {
15893	        __failure = 228;
15894	        if (!PyErr_Occurred()) {
15895	            PyErr_SetString(PyExc_RuntimeError,
15896	                "Unexpected error in an Op's C code. "
15897	                "No Python exception was set.");
15898	            }
15899	        goto __label_228;}
15900	            }
15901	            // This is a TypeError to be consistent with DEBUG_MODE
15902	            // Note: DEBUG_MODE also tells the name of the container
15903	            if (PyArray_TYPE((PyArrayObject*) py_V227) != NPY_FLOAT64) {
15904	                PyErr_Format(PyExc_TypeError,
15905	                             "expected type_num %d (NPY_FLOAT64) got %d",
15906	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V227));
15907	                {
15908	        __failure = 228;
15909	        if (!PyErr_Occurred()) {
15910	            PyErr_SetString(PyExc_RuntimeError,
15911	                "Unexpected error in an Op's C code. "
15912	                "No Python exception was set.");
15913	            }
15914	        goto __label_228;}
15915	            }
15916	            
15917	        V227 = (PyArrayObject*)(py_V227);
15918	        Py_XINCREF(V227);
15919	        
15920	{
15921	
15922	    py_V229 = PyList_GET_ITEM(storage_V229, 0);
15923	    {Py_XINCREF(py_V229);}
15924	    
15925	            V229 = NULL;
15926	            if (py_V229 == Py_None) {
15927	                // We can either fail here or set V229 to NULL and rely on Ops
15928	                // using tensors to handle the NULL case, but if they fail to do so
15929	                // they'll end up with nasty segfaults, so this is public service.
15930	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
15931	                {
15932	        __failure = 230;
15933	        if (!PyErr_Occurred()) {
15934	            PyErr_SetString(PyExc_RuntimeError,
15935	                "Unexpected error in an Op's C code. "
15936	                "No Python exception was set.");
15937	            }
15938	        goto __label_230;}
15939	            }
15940	            if (!PyArray_Check(py_V229)) {
15941	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
15942	                {
15943	        __failure = 230;
15944	        if (!PyErr_Occurred()) {
15945	            PyErr_SetString(PyExc_RuntimeError,
15946	                "Unexpected error in an Op's C code. "
15947	                "No Python exception was set.");
15948	            }
15949	        goto __label_230;}
15950	            }
15951	            // We expect NPY_FLOAT64
15952	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V229)) {
15953	                PyArrayObject * tmp = (PyArrayObject*) py_V229;
15954	                PyErr_Format(PyExc_NotImplementedError,
15955	                             "expected an aligned array of type %ld "
15956	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
15957	                             " with %ld dimensions, with 3 last dims "
15958	                             "%ld, %ld, %ld"
15959	                             " and 3 last strides %ld %ld, %ld.",
15960	                             (long int) NPY_FLOAT64,
15961	                             (long int) PyArray_TYPE((PyArrayObject*) py_V229),
15962	                             (long int) PyArray_NDIM(tmp),
15963	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
15964	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
15965	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
15966	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
15967	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
15968	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
15969	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
15970	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
15971	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
15972	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
15973	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
15974	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
15975	            );
15976	                {
15977	        __failure = 230;
15978	        if (!PyErr_Occurred()) {
15979	            PyErr_SetString(PyExc_RuntimeError,
15980	                "Unexpected error in an Op's C code. "
15981	                "No Python exception was set.");
15982	            }
15983	        goto __label_230;}
15984	            }
15985	            // This is a TypeError to be consistent with DEBUG_MODE
15986	            // Note: DEBUG_MODE also tells the name of the container
15987	            if (PyArray_TYPE((PyArrayObject*) py_V229) != NPY_FLOAT64) {
15988	                PyErr_Format(PyExc_TypeError,
15989	                             "expected type_num %d (NPY_FLOAT64) got %d",
15990	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V229));
15991	                {
15992	        __failure = 230;
15993	        if (!PyErr_Occurred()) {
15994	            PyErr_SetString(PyExc_RuntimeError,
15995	                "Unexpected error in an Op's C code. "
15996	                "No Python exception was set.");
15997	            }
15998	        goto __label_230;}
15999	            }
16000	            
16001	        V229 = (PyArrayObject*)(py_V229);
16002	        Py_XINCREF(V229);
16003	        
16004	{
16005	
16006	    py_V231 = PyList_GET_ITEM(storage_V231, 0);
16007	    {Py_XINCREF(py_V231);}
16008	    
16009	            V231 = NULL;
16010	            if (py_V231 == Py_None) {
16011	                // We can either fail here or set V231 to NULL and rely on Ops
16012	                // using tensors to handle the NULL case, but if they fail to do so
16013	                // they'll end up with nasty segfaults, so this is public service.
16014	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
16015	                {
16016	        __failure = 232;
16017	        if (!PyErr_Occurred()) {
16018	            PyErr_SetString(PyExc_RuntimeError,
16019	                "Unexpected error in an Op's C code. "
16020	                "No Python exception was set.");
16021	            }
16022	        goto __label_232;}
16023	            }
16024	            if (!PyArray_Check(py_V231)) {
16025	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
16026	                {
16027	        __failure = 232;
16028	        if (!PyErr_Occurred()) {
16029	            PyErr_SetString(PyExc_RuntimeError,
16030	                "Unexpected error in an Op's C code. "
16031	                "No Python exception was set.");
16032	            }
16033	        goto __label_232;}
16034	            }
16035	            // We expect NPY_FLOAT64
16036	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V231)) {
16037	                PyArrayObject * tmp = (PyArrayObject*) py_V231;
16038	                PyErr_Format(PyExc_NotImplementedError,
16039	                             "expected an aligned array of type %ld "
16040	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
16041	                             " with %ld dimensions, with 3 last dims "
16042	                             "%ld, %ld, %ld"
16043	                             " and 3 last strides %ld %ld, %ld.",
16044	                             (long int) NPY_FLOAT64,
16045	                             (long int) PyArray_TYPE((PyArrayObject*) py_V231),
16046	                             (long int) PyArray_NDIM(tmp),
16047	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
16048	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
16049	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
16050	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
16051	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
16052	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
16053	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
16054	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
16055	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
16056	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
16057	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
16058	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
16059	            );
16060	                {
16061	        __failure = 232;
16062	        if (!PyErr_Occurred()) {
16063	            PyErr_SetString(PyExc_RuntimeError,
16064	                "Unexpected error in an Op's C code. "
16065	                "No Python exception was set.");
16066	            }
16067	        goto __label_232;}
16068	            }
16069	            // This is a TypeError to be consistent with DEBUG_MODE
16070	            // Note: DEBUG_MODE also tells the name of the container
16071	            if (PyArray_TYPE((PyArrayObject*) py_V231) != NPY_FLOAT64) {
16072	                PyErr_Format(PyExc_TypeError,
16073	                             "expected type_num %d (NPY_FLOAT64) got %d",
16074	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V231));
16075	                {
16076	        __failure = 232;
16077	        if (!PyErr_Occurred()) {
16078	            PyErr_SetString(PyExc_RuntimeError,
16079	                "Unexpected error in an Op's C code. "
16080	                "No Python exception was set.");
16081	            }
16082	        goto __label_232;}
16083	            }
16084	            
16085	        V231 = (PyArrayObject*)(py_V231);
16086	        Py_XINCREF(V231);
16087	        
16088	{
16089	
16090	    py_V233 = PyList_GET_ITEM(storage_V233, 0);
16091	    {Py_XINCREF(py_V233);}
16092	    
16093	            V233 = NULL;
16094	            if (py_V233 == Py_None) {
16095	                // We can either fail here or set V233 to NULL and rely on Ops
16096	                // using tensors to handle the NULL case, but if they fail to do so
16097	                // they'll end up with nasty segfaults, so this is public service.
16098	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
16099	                {
16100	        __failure = 234;
16101	        if (!PyErr_Occurred()) {
16102	            PyErr_SetString(PyExc_RuntimeError,
16103	                "Unexpected error in an Op's C code. "
16104	                "No Python exception was set.");
16105	            }
16106	        goto __label_234;}
16107	            }
16108	            if (!PyArray_Check(py_V233)) {
16109	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
16110	                {
16111	        __failure = 234;
16112	        if (!PyErr_Occurred()) {
16113	            PyErr_SetString(PyExc_RuntimeError,
16114	                "Unexpected error in an Op's C code. "
16115	                "No Python exception was set.");
16116	            }
16117	        goto __label_234;}
16118	            }
16119	            // We expect NPY_FLOAT64
16120	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V233)) {
16121	                PyArrayObject * tmp = (PyArrayObject*) py_V233;
16122	                PyErr_Format(PyExc_NotImplementedError,
16123	                             "expected an aligned array of type %ld "
16124	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
16125	                             " with %ld dimensions, with 3 last dims "
16126	                             "%ld, %ld, %ld"
16127	                             " and 3 last strides %ld %ld, %ld.",
16128	                             (long int) NPY_FLOAT64,
16129	                             (long int) PyArray_TYPE((PyArrayObject*) py_V233),
16130	                             (long int) PyArray_NDIM(tmp),
16131	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
16132	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
16133	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
16134	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
16135	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
16136	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
16137	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
16138	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
16139	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
16140	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
16141	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
16142	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
16143	            );
16144	                {
16145	        __failure = 234;
16146	        if (!PyErr_Occurred()) {
16147	            PyErr_SetString(PyExc_RuntimeError,
16148	                "Unexpected error in an Op's C code. "
16149	                "No Python exception was set.");
16150	            }
16151	        goto __label_234;}
16152	            }
16153	            // This is a TypeError to be consistent with DEBUG_MODE
16154	            // Note: DEBUG_MODE also tells the name of the container
16155	            if (PyArray_TYPE((PyArrayObject*) py_V233) != NPY_FLOAT64) {
16156	                PyErr_Format(PyExc_TypeError,
16157	                             "expected type_num %d (NPY_FLOAT64) got %d",
16158	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V233));
16159	                {
16160	        __failure = 234;
16161	        if (!PyErr_Occurred()) {
16162	            PyErr_SetString(PyExc_RuntimeError,
16163	                "Unexpected error in an Op's C code. "
16164	                "No Python exception was set.");
16165	            }
16166	        goto __label_234;}
16167	            }
16168	            
16169	        V233 = (PyArrayObject*)(py_V233);
16170	        Py_XINCREF(V233);
16171	        
16172	{
16173	
16174	    py_V235 = PyList_GET_ITEM(storage_V235, 0);
16175	    {Py_XINCREF(py_V235);}
16176	    
16177	            V235 = NULL;
16178	            if (py_V235 == Py_None) {
16179	                // We can either fail here or set V235 to NULL and rely on Ops
16180	                // using tensors to handle the NULL case, but if they fail to do so
16181	                // they'll end up with nasty segfaults, so this is public service.
16182	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
16183	                {
16184	        __failure = 236;
16185	        if (!PyErr_Occurred()) {
16186	            PyErr_SetString(PyExc_RuntimeError,
16187	                "Unexpected error in an Op's C code. "
16188	                "No Python exception was set.");
16189	            }
16190	        goto __label_236;}
16191	            }
16192	            if (!PyArray_Check(py_V235)) {
16193	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
16194	                {
16195	        __failure = 236;
16196	        if (!PyErr_Occurred()) {
16197	            PyErr_SetString(PyExc_RuntimeError,
16198	                "Unexpected error in an Op's C code. "
16199	                "No Python exception was set.");
16200	            }
16201	        goto __label_236;}
16202	            }
16203	            // We expect NPY_FLOAT64
16204	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V235)) {
16205	                PyArrayObject * tmp = (PyArrayObject*) py_V235;
16206	                PyErr_Format(PyExc_NotImplementedError,
16207	                             "expected an aligned array of type %ld "
16208	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
16209	                             " with %ld dimensions, with 3 last dims "
16210	                             "%ld, %ld, %ld"
16211	                             " and 3 last strides %ld %ld, %ld.",
16212	                             (long int) NPY_FLOAT64,
16213	                             (long int) PyArray_TYPE((PyArrayObject*) py_V235),
16214	                             (long int) PyArray_NDIM(tmp),
16215	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
16216	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
16217	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
16218	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
16219	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
16220	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
16221	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
16222	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
16223	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
16224	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
16225	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
16226	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
16227	            );
16228	                {
16229	        __failure = 236;
16230	        if (!PyErr_Occurred()) {
16231	            PyErr_SetString(PyExc_RuntimeError,
16232	                "Unexpected error in an Op's C code. "
16233	                "No Python exception was set.");
16234	            }
16235	        goto __label_236;}
16236	            }
16237	            // This is a TypeError to be consistent with DEBUG_MODE
16238	            // Note: DEBUG_MODE also tells the name of the container
16239	            if (PyArray_TYPE((PyArrayObject*) py_V235) != NPY_FLOAT64) {
16240	                PyErr_Format(PyExc_TypeError,
16241	                             "expected type_num %d (NPY_FLOAT64) got %d",
16242	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V235));
16243	                {
16244	        __failure = 236;
16245	        if (!PyErr_Occurred()) {
16246	            PyErr_SetString(PyExc_RuntimeError,
16247	                "Unexpected error in an Op's C code. "
16248	                "No Python exception was set.");
16249	            }
16250	        goto __label_236;}
16251	            }
16252	            
16253	        V235 = (PyArrayObject*)(py_V235);
16254	        Py_XINCREF(V235);
16255	        
16256	{
16257	
16258	    py_V237 = PyList_GET_ITEM(storage_V237, 0);
16259	    {Py_XINCREF(py_V237);}
16260	    
16261	            V237 = NULL;
16262	            if (py_V237 == Py_None) {
16263	                // We can either fail here or set V237 to NULL and rely on Ops
16264	                // using tensors to handle the NULL case, but if they fail to do so
16265	                // they'll end up with nasty segfaults, so this is public service.
16266	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
16267	                {
16268	        __failure = 238;
16269	        if (!PyErr_Occurred()) {
16270	            PyErr_SetString(PyExc_RuntimeError,
16271	                "Unexpected error in an Op's C code. "
16272	                "No Python exception was set.");
16273	            }
16274	        goto __label_238;}
16275	            }
16276	            if (!PyArray_Check(py_V237)) {
16277	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
16278	                {
16279	        __failure = 238;
16280	        if (!PyErr_Occurred()) {
16281	            PyErr_SetString(PyExc_RuntimeError,
16282	                "Unexpected error in an Op's C code. "
16283	                "No Python exception was set.");
16284	            }
16285	        goto __label_238;}
16286	            }
16287	            // We expect NPY_FLOAT64
16288	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V237)) {
16289	                PyArrayObject * tmp = (PyArrayObject*) py_V237;
16290	                PyErr_Format(PyExc_NotImplementedError,
16291	                             "expected an aligned array of type %ld "
16292	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
16293	                             " with %ld dimensions, with 3 last dims "
16294	                             "%ld, %ld, %ld"
16295	                             " and 3 last strides %ld %ld, %ld.",
16296	                             (long int) NPY_FLOAT64,
16297	                             (long int) PyArray_TYPE((PyArrayObject*) py_V237),
16298	                             (long int) PyArray_NDIM(tmp),
16299	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
16300	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
16301	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
16302	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
16303	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
16304	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
16305	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
16306	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
16307	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
16308	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
16309	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
16310	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
16311	            );
16312	                {
16313	        __failure = 238;
16314	        if (!PyErr_Occurred()) {
16315	            PyErr_SetString(PyExc_RuntimeError,
16316	                "Unexpected error in an Op's C code. "
16317	                "No Python exception was set.");
16318	            }
16319	        goto __label_238;}
16320	            }
16321	            // This is a TypeError to be consistent with DEBUG_MODE
16322	            // Note: DEBUG_MODE also tells the name of the container
16323	            if (PyArray_TYPE((PyArrayObject*) py_V237) != NPY_FLOAT64) {
16324	                PyErr_Format(PyExc_TypeError,
16325	                             "expected type_num %d (NPY_FLOAT64) got %d",
16326	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V237));
16327	                {
16328	        __failure = 238;
16329	        if (!PyErr_Occurred()) {
16330	            PyErr_SetString(PyExc_RuntimeError,
16331	                "Unexpected error in an Op's C code. "
16332	                "No Python exception was set.");
16333	            }
16334	        goto __label_238;}
16335	            }
16336	            
16337	        V237 = (PyArrayObject*)(py_V237);
16338	        Py_XINCREF(V237);
16339	        
16340	{
16341	
16342	    py_V239 = PyList_GET_ITEM(storage_V239, 0);
16343	    {Py_XINCREF(py_V239);}
16344	    
16345	            V239 = NULL;
16346	            if (py_V239 == Py_None) {
16347	                // We can either fail here or set V239 to NULL and rely on Ops
16348	                // using tensors to handle the NULL case, but if they fail to do so
16349	                // they'll end up with nasty segfaults, so this is public service.
16350	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
16351	                {
16352	        __failure = 240;
16353	        if (!PyErr_Occurred()) {
16354	            PyErr_SetString(PyExc_RuntimeError,
16355	                "Unexpected error in an Op's C code. "
16356	                "No Python exception was set.");
16357	            }
16358	        goto __label_240;}
16359	            }
16360	            if (!PyArray_Check(py_V239)) {
16361	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
16362	                {
16363	        __failure = 240;
16364	        if (!PyErr_Occurred()) {
16365	            PyErr_SetString(PyExc_RuntimeError,
16366	                "Unexpected error in an Op's C code. "
16367	                "No Python exception was set.");
16368	            }
16369	        goto __label_240;}
16370	            }
16371	            // We expect NPY_FLOAT64
16372	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V239)) {
16373	                PyArrayObject * tmp = (PyArrayObject*) py_V239;
16374	                PyErr_Format(PyExc_NotImplementedError,
16375	                             "expected an aligned array of type %ld "
16376	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
16377	                             " with %ld dimensions, with 3 last dims "
16378	                             "%ld, %ld, %ld"
16379	                             " and 3 last strides %ld %ld, %ld.",
16380	                             (long int) NPY_FLOAT64,
16381	                             (long int) PyArray_TYPE((PyArrayObject*) py_V239),
16382	                             (long int) PyArray_NDIM(tmp),
16383	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
16384	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
16385	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
16386	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
16387	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
16388	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
16389	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
16390	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
16391	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
16392	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
16393	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
16394	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
16395	            );
16396	                {
16397	        __failure = 240;
16398	        if (!PyErr_Occurred()) {
16399	            PyErr_SetString(PyExc_RuntimeError,
16400	                "Unexpected error in an Op's C code. "
16401	                "No Python exception was set.");
16402	            }
16403	        goto __label_240;}
16404	            }
16405	            // This is a TypeError to be consistent with DEBUG_MODE
16406	            // Note: DEBUG_MODE also tells the name of the container
16407	            if (PyArray_TYPE((PyArrayObject*) py_V239) != NPY_FLOAT64) {
16408	                PyErr_Format(PyExc_TypeError,
16409	                             "expected type_num %d (NPY_FLOAT64) got %d",
16410	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V239));
16411	                {
16412	        __failure = 240;
16413	        if (!PyErr_Occurred()) {
16414	            PyErr_SetString(PyExc_RuntimeError,
16415	                "Unexpected error in an Op's C code. "
16416	                "No Python exception was set.");
16417	            }
16418	        goto __label_240;}
16419	            }
16420	            
16421	        V239 = (PyArrayObject*)(py_V239);
16422	        Py_XINCREF(V239);
16423	        
16424	{
16425	
16426	    py_V241 = PyList_GET_ITEM(storage_V241, 0);
16427	    {Py_XINCREF(py_V241);}
16428	    
16429	            V241 = NULL;
16430	            if (py_V241 == Py_None) {
16431	                // We can either fail here or set V241 to NULL and rely on Ops
16432	                // using tensors to handle the NULL case, but if they fail to do so
16433	                // they'll end up with nasty segfaults, so this is public service.
16434	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
16435	                {
16436	        __failure = 242;
16437	        if (!PyErr_Occurred()) {
16438	            PyErr_SetString(PyExc_RuntimeError,
16439	                "Unexpected error in an Op's C code. "
16440	                "No Python exception was set.");
16441	            }
16442	        goto __label_242;}
16443	            }
16444	            if (!PyArray_Check(py_V241)) {
16445	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
16446	                {
16447	        __failure = 242;
16448	        if (!PyErr_Occurred()) {
16449	            PyErr_SetString(PyExc_RuntimeError,
16450	                "Unexpected error in an Op's C code. "
16451	                "No Python exception was set.");
16452	            }
16453	        goto __label_242;}
16454	            }
16455	            // We expect NPY_FLOAT64
16456	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V241)) {
16457	                PyArrayObject * tmp = (PyArrayObject*) py_V241;
16458	                PyErr_Format(PyExc_NotImplementedError,
16459	                             "expected an aligned array of type %ld "
16460	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
16461	                             " with %ld dimensions, with 3 last dims "
16462	                             "%ld, %ld, %ld"
16463	                             " and 3 last strides %ld %ld, %ld.",
16464	                             (long int) NPY_FLOAT64,
16465	                             (long int) PyArray_TYPE((PyArrayObject*) py_V241),
16466	                             (long int) PyArray_NDIM(tmp),
16467	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
16468	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
16469	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
16470	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
16471	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
16472	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
16473	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
16474	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
16475	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
16476	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
16477	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
16478	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
16479	            );
16480	                {
16481	        __failure = 242;
16482	        if (!PyErr_Occurred()) {
16483	            PyErr_SetString(PyExc_RuntimeError,
16484	                "Unexpected error in an Op's C code. "
16485	                "No Python exception was set.");
16486	            }
16487	        goto __label_242;}
16488	            }
16489	            // This is a TypeError to be consistent with DEBUG_MODE
16490	            // Note: DEBUG_MODE also tells the name of the container
16491	            if (PyArray_TYPE((PyArrayObject*) py_V241) != NPY_FLOAT64) {
16492	                PyErr_Format(PyExc_TypeError,
16493	                             "expected type_num %d (NPY_FLOAT64) got %d",
16494	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V241));
16495	                {
16496	        __failure = 242;
16497	        if (!PyErr_Occurred()) {
16498	            PyErr_SetString(PyExc_RuntimeError,
16499	                "Unexpected error in an Op's C code. "
16500	                "No Python exception was set.");
16501	            }
16502	        goto __label_242;}
16503	            }
16504	            
16505	        V241 = (PyArrayObject*)(py_V241);
16506	        Py_XINCREF(V241);
16507	        
16508	{
16509	
16510	    py_V243 = PyList_GET_ITEM(storage_V243, 0);
16511	    {Py_XINCREF(py_V243);}
16512	    
16513	            V243 = NULL;
16514	            if (py_V243 == Py_None) {
16515	                // We can either fail here or set V243 to NULL and rely on Ops
16516	                // using tensors to handle the NULL case, but if they fail to do so
16517	                // they'll end up with nasty segfaults, so this is public service.
16518	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
16519	                {
16520	        __failure = 244;
16521	        if (!PyErr_Occurred()) {
16522	            PyErr_SetString(PyExc_RuntimeError,
16523	                "Unexpected error in an Op's C code. "
16524	                "No Python exception was set.");
16525	            }
16526	        goto __label_244;}
16527	            }
16528	            if (!PyArray_Check(py_V243)) {
16529	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
16530	                {
16531	        __failure = 244;
16532	        if (!PyErr_Occurred()) {
16533	            PyErr_SetString(PyExc_RuntimeError,
16534	                "Unexpected error in an Op's C code. "
16535	                "No Python exception was set.");
16536	            }
16537	        goto __label_244;}
16538	            }
16539	            // We expect NPY_FLOAT64
16540	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V243)) {
16541	                PyArrayObject * tmp = (PyArrayObject*) py_V243;
16542	                PyErr_Format(PyExc_NotImplementedError,
16543	                             "expected an aligned array of type %ld "
16544	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
16545	                             " with %ld dimensions, with 3 last dims "
16546	                             "%ld, %ld, %ld"
16547	                             " and 3 last strides %ld %ld, %ld.",
16548	                             (long int) NPY_FLOAT64,
16549	                             (long int) PyArray_TYPE((PyArrayObject*) py_V243),
16550	                             (long int) PyArray_NDIM(tmp),
16551	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
16552	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
16553	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
16554	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
16555	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
16556	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
16557	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
16558	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
16559	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
16560	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
16561	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
16562	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
16563	            );
16564	                {
16565	        __failure = 244;
16566	        if (!PyErr_Occurred()) {
16567	            PyErr_SetString(PyExc_RuntimeError,
16568	                "Unexpected error in an Op's C code. "
16569	                "No Python exception was set.");
16570	            }
16571	        goto __label_244;}
16572	            }
16573	            // This is a TypeError to be consistent with DEBUG_MODE
16574	            // Note: DEBUG_MODE also tells the name of the container
16575	            if (PyArray_TYPE((PyArrayObject*) py_V243) != NPY_FLOAT64) {
16576	                PyErr_Format(PyExc_TypeError,
16577	                             "expected type_num %d (NPY_FLOAT64) got %d",
16578	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V243));
16579	                {
16580	        __failure = 244;
16581	        if (!PyErr_Occurred()) {
16582	            PyErr_SetString(PyExc_RuntimeError,
16583	                "Unexpected error in an Op's C code. "
16584	                "No Python exception was set.");
16585	            }
16586	        goto __label_244;}
16587	            }
16588	            
16589	        V243 = (PyArrayObject*)(py_V243);
16590	        Py_XINCREF(V243);
16591	        
16592	{
16593	
16594	    py_V245 = PyList_GET_ITEM(storage_V245, 0);
16595	    {Py_XINCREF(py_V245);}
16596	    
16597	            V245 = NULL;
16598	            if (py_V245 == Py_None) {
16599	                // We can either fail here or set V245 to NULL and rely on Ops
16600	                // using tensors to handle the NULL case, but if they fail to do so
16601	                // they'll end up with nasty segfaults, so this is public service.
16602	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
16603	                {
16604	        __failure = 246;
16605	        if (!PyErr_Occurred()) {
16606	            PyErr_SetString(PyExc_RuntimeError,
16607	                "Unexpected error in an Op's C code. "
16608	                "No Python exception was set.");
16609	            }
16610	        goto __label_246;}
16611	            }
16612	            if (!PyArray_Check(py_V245)) {
16613	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
16614	                {
16615	        __failure = 246;
16616	        if (!PyErr_Occurred()) {
16617	            PyErr_SetString(PyExc_RuntimeError,
16618	                "Unexpected error in an Op's C code. "
16619	                "No Python exception was set.");
16620	            }
16621	        goto __label_246;}
16622	            }
16623	            // We expect NPY_FLOAT64
16624	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V245)) {
16625	                PyArrayObject * tmp = (PyArrayObject*) py_V245;
16626	                PyErr_Format(PyExc_NotImplementedError,
16627	                             "expected an aligned array of type %ld "
16628	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
16629	                             " with %ld dimensions, with 3 last dims "
16630	                             "%ld, %ld, %ld"
16631	                             " and 3 last strides %ld %ld, %ld.",
16632	                             (long int) NPY_FLOAT64,
16633	                             (long int) PyArray_TYPE((PyArrayObject*) py_V245),
16634	                             (long int) PyArray_NDIM(tmp),
16635	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
16636	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
16637	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
16638	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
16639	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
16640	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
16641	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
16642	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
16643	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
16644	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
16645	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
16646	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
16647	            );
16648	                {
16649	        __failure = 246;
16650	        if (!PyErr_Occurred()) {
16651	            PyErr_SetString(PyExc_RuntimeError,
16652	                "Unexpected error in an Op's C code. "
16653	                "No Python exception was set.");
16654	            }
16655	        goto __label_246;}
16656	            }
16657	            // This is a TypeError to be consistent with DEBUG_MODE
16658	            // Note: DEBUG_MODE also tells the name of the container
16659	            if (PyArray_TYPE((PyArrayObject*) py_V245) != NPY_FLOAT64) {
16660	                PyErr_Format(PyExc_TypeError,
16661	                             "expected type_num %d (NPY_FLOAT64) got %d",
16662	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V245));
16663	                {
16664	        __failure = 246;
16665	        if (!PyErr_Occurred()) {
16666	            PyErr_SetString(PyExc_RuntimeError,
16667	                "Unexpected error in an Op's C code. "
16668	                "No Python exception was set.");
16669	            }
16670	        goto __label_246;}
16671	            }
16672	            
16673	        V245 = (PyArrayObject*)(py_V245);
16674	        Py_XINCREF(V245);
16675	        
16676	{
16677	
16678	    py_V247 = PyList_GET_ITEM(storage_V247, 0);
16679	    {Py_XINCREF(py_V247);}
16680	    
16681	            V247 = NULL;
16682	            if (py_V247 == Py_None) {
16683	                // We can either fail here or set V247 to NULL and rely on Ops
16684	                // using tensors to handle the NULL case, but if they fail to do so
16685	                // they'll end up with nasty segfaults, so this is public service.
16686	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
16687	                {
16688	        __failure = 248;
16689	        if (!PyErr_Occurred()) {
16690	            PyErr_SetString(PyExc_RuntimeError,
16691	                "Unexpected error in an Op's C code. "
16692	                "No Python exception was set.");
16693	            }
16694	        goto __label_248;}
16695	            }
16696	            if (!PyArray_Check(py_V247)) {
16697	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
16698	                {
16699	        __failure = 248;
16700	        if (!PyErr_Occurred()) {
16701	            PyErr_SetString(PyExc_RuntimeError,
16702	                "Unexpected error in an Op's C code. "
16703	                "No Python exception was set.");
16704	            }
16705	        goto __label_248;}
16706	            }
16707	            // We expect NPY_FLOAT64
16708	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V247)) {
16709	                PyArrayObject * tmp = (PyArrayObject*) py_V247;
16710	                PyErr_Format(PyExc_NotImplementedError,
16711	                             "expected an aligned array of type %ld "
16712	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
16713	                             " with %ld dimensions, with 3 last dims "
16714	                             "%ld, %ld, %ld"
16715	                             " and 3 last strides %ld %ld, %ld.",
16716	                             (long int) NPY_FLOAT64,
16717	                             (long int) PyArray_TYPE((PyArrayObject*) py_V247),
16718	                             (long int) PyArray_NDIM(tmp),
16719	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
16720	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
16721	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
16722	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
16723	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
16724	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
16725	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
16726	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
16727	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
16728	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
16729	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
16730	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
16731	            );
16732	                {
16733	        __failure = 248;
16734	        if (!PyErr_Occurred()) {
16735	            PyErr_SetString(PyExc_RuntimeError,
16736	                "Unexpected error in an Op's C code. "
16737	                "No Python exception was set.");
16738	            }
16739	        goto __label_248;}
16740	            }
16741	            // This is a TypeError to be consistent with DEBUG_MODE
16742	            // Note: DEBUG_MODE also tells the name of the container
16743	            if (PyArray_TYPE((PyArrayObject*) py_V247) != NPY_FLOAT64) {
16744	                PyErr_Format(PyExc_TypeError,
16745	                             "expected type_num %d (NPY_FLOAT64) got %d",
16746	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V247));
16747	                {
16748	        __failure = 248;
16749	        if (!PyErr_Occurred()) {
16750	            PyErr_SetString(PyExc_RuntimeError,
16751	                "Unexpected error in an Op's C code. "
16752	                "No Python exception was set.");
16753	            }
16754	        goto __label_248;}
16755	            }
16756	            
16757	        V247 = (PyArrayObject*)(py_V247);
16758	        Py_XINCREF(V247);
16759	        
16760	{
16761	
16762	    py_V249 = PyList_GET_ITEM(storage_V249, 0);
16763	    {Py_XINCREF(py_V249);}
16764	    
16765	            V249 = NULL;
16766	            if (py_V249 == Py_None) {
16767	                // We can either fail here or set V249 to NULL and rely on Ops
16768	                // using tensors to handle the NULL case, but if they fail to do so
16769	                // they'll end up with nasty segfaults, so this is public service.
16770	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
16771	                {
16772	        __failure = 250;
16773	        if (!PyErr_Occurred()) {
16774	            PyErr_SetString(PyExc_RuntimeError,
16775	                "Unexpected error in an Op's C code. "
16776	                "No Python exception was set.");
16777	            }
16778	        goto __label_250;}
16779	            }
16780	            if (!PyArray_Check(py_V249)) {
16781	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
16782	                {
16783	        __failure = 250;
16784	        if (!PyErr_Occurred()) {
16785	            PyErr_SetString(PyExc_RuntimeError,
16786	                "Unexpected error in an Op's C code. "
16787	                "No Python exception was set.");
16788	            }
16789	        goto __label_250;}
16790	            }
16791	            // We expect NPY_FLOAT64
16792	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V249)) {
16793	                PyArrayObject * tmp = (PyArrayObject*) py_V249;
16794	                PyErr_Format(PyExc_NotImplementedError,
16795	                             "expected an aligned array of type %ld "
16796	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
16797	                             " with %ld dimensions, with 3 last dims "
16798	                             "%ld, %ld, %ld"
16799	                             " and 3 last strides %ld %ld, %ld.",
16800	                             (long int) NPY_FLOAT64,
16801	                             (long int) PyArray_TYPE((PyArrayObject*) py_V249),
16802	                             (long int) PyArray_NDIM(tmp),
16803	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
16804	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
16805	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
16806	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
16807	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
16808	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
16809	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
16810	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
16811	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
16812	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
16813	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
16814	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
16815	            );
16816	                {
16817	        __failure = 250;
16818	        if (!PyErr_Occurred()) {
16819	            PyErr_SetString(PyExc_RuntimeError,
16820	                "Unexpected error in an Op's C code. "
16821	                "No Python exception was set.");
16822	            }
16823	        goto __label_250;}
16824	            }
16825	            // This is a TypeError to be consistent with DEBUG_MODE
16826	            // Note: DEBUG_MODE also tells the name of the container
16827	            if (PyArray_TYPE((PyArrayObject*) py_V249) != NPY_FLOAT64) {
16828	                PyErr_Format(PyExc_TypeError,
16829	                             "expected type_num %d (NPY_FLOAT64) got %d",
16830	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V249));
16831	                {
16832	        __failure = 250;
16833	        if (!PyErr_Occurred()) {
16834	            PyErr_SetString(PyExc_RuntimeError,
16835	                "Unexpected error in an Op's C code. "
16836	                "No Python exception was set.");
16837	            }
16838	        goto __label_250;}
16839	            }
16840	            
16841	        V249 = (PyArrayObject*)(py_V249);
16842	        Py_XINCREF(V249);
16843	        
16844	{
16845	
16846	    py_V251 = PyList_GET_ITEM(storage_V251, 0);
16847	    {Py_XINCREF(py_V251);}
16848	    
16849	            V251 = NULL;
16850	            if (py_V251 == Py_None) {
16851	                // We can either fail here or set V251 to NULL and rely on Ops
16852	                // using tensors to handle the NULL case, but if they fail to do so
16853	                // they'll end up with nasty segfaults, so this is public service.
16854	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
16855	                {
16856	        __failure = 252;
16857	        if (!PyErr_Occurred()) {
16858	            PyErr_SetString(PyExc_RuntimeError,
16859	                "Unexpected error in an Op's C code. "
16860	                "No Python exception was set.");
16861	            }
16862	        goto __label_252;}
16863	            }
16864	            if (!PyArray_Check(py_V251)) {
16865	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
16866	                {
16867	        __failure = 252;
16868	        if (!PyErr_Occurred()) {
16869	            PyErr_SetString(PyExc_RuntimeError,
16870	                "Unexpected error in an Op's C code. "
16871	                "No Python exception was set.");
16872	            }
16873	        goto __label_252;}
16874	            }
16875	            // We expect NPY_FLOAT64
16876	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V251)) {
16877	                PyArrayObject * tmp = (PyArrayObject*) py_V251;
16878	                PyErr_Format(PyExc_NotImplementedError,
16879	                             "expected an aligned array of type %ld "
16880	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
16881	                             " with %ld dimensions, with 3 last dims "
16882	                             "%ld, %ld, %ld"
16883	                             " and 3 last strides %ld %ld, %ld.",
16884	                             (long int) NPY_FLOAT64,
16885	                             (long int) PyArray_TYPE((PyArrayObject*) py_V251),
16886	                             (long int) PyArray_NDIM(tmp),
16887	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
16888	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
16889	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
16890	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
16891	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
16892	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
16893	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
16894	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
16895	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
16896	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
16897	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
16898	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
16899	            );
16900	                {
16901	        __failure = 252;
16902	        if (!PyErr_Occurred()) {
16903	            PyErr_SetString(PyExc_RuntimeError,
16904	                "Unexpected error in an Op's C code. "
16905	                "No Python exception was set.");
16906	            }
16907	        goto __label_252;}
16908	            }
16909	            // This is a TypeError to be consistent with DEBUG_MODE
16910	            // Note: DEBUG_MODE also tells the name of the container
16911	            if (PyArray_TYPE((PyArrayObject*) py_V251) != NPY_FLOAT64) {
16912	                PyErr_Format(PyExc_TypeError,
16913	                             "expected type_num %d (NPY_FLOAT64) got %d",
16914	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V251));
16915	                {
16916	        __failure = 252;
16917	        if (!PyErr_Occurred()) {
16918	            PyErr_SetString(PyExc_RuntimeError,
16919	                "Unexpected error in an Op's C code. "
16920	                "No Python exception was set.");
16921	            }
16922	        goto __label_252;}
16923	            }
16924	            
16925	        V251 = (PyArrayObject*)(py_V251);
16926	        Py_XINCREF(V251);
16927	        
16928	{
16929	
16930	    py_V253 = PyList_GET_ITEM(storage_V253, 0);
16931	    {Py_XINCREF(py_V253);}
16932	    
16933	            V253 = NULL;
16934	            if (py_V253 == Py_None) {
16935	                // We can either fail here or set V253 to NULL and rely on Ops
16936	                // using tensors to handle the NULL case, but if they fail to do so
16937	                // they'll end up with nasty segfaults, so this is public service.
16938	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
16939	                {
16940	        __failure = 254;
16941	        if (!PyErr_Occurred()) {
16942	            PyErr_SetString(PyExc_RuntimeError,
16943	                "Unexpected error in an Op's C code. "
16944	                "No Python exception was set.");
16945	            }
16946	        goto __label_254;}
16947	            }
16948	            if (!PyArray_Check(py_V253)) {
16949	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
16950	                {
16951	        __failure = 254;
16952	        if (!PyErr_Occurred()) {
16953	            PyErr_SetString(PyExc_RuntimeError,
16954	                "Unexpected error in an Op's C code. "
16955	                "No Python exception was set.");
16956	            }
16957	        goto __label_254;}
16958	            }
16959	            // We expect NPY_FLOAT64
16960	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V253)) {
16961	                PyArrayObject * tmp = (PyArrayObject*) py_V253;
16962	                PyErr_Format(PyExc_NotImplementedError,
16963	                             "expected an aligned array of type %ld "
16964	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
16965	                             " with %ld dimensions, with 3 last dims "
16966	                             "%ld, %ld, %ld"
16967	                             " and 3 last strides %ld %ld, %ld.",
16968	                             (long int) NPY_FLOAT64,
16969	                             (long int) PyArray_TYPE((PyArrayObject*) py_V253),
16970	                             (long int) PyArray_NDIM(tmp),
16971	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
16972	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
16973	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
16974	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
16975	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
16976	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
16977	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
16978	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
16979	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
16980	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
16981	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
16982	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
16983	            );
16984	                {
16985	        __failure = 254;
16986	        if (!PyErr_Occurred()) {
16987	            PyErr_SetString(PyExc_RuntimeError,
16988	                "Unexpected error in an Op's C code. "
16989	                "No Python exception was set.");
16990	            }
16991	        goto __label_254;}
16992	            }
16993	            // This is a TypeError to be consistent with DEBUG_MODE
16994	            // Note: DEBUG_MODE also tells the name of the container
16995	            if (PyArray_TYPE((PyArrayObject*) py_V253) != NPY_FLOAT64) {
16996	                PyErr_Format(PyExc_TypeError,
16997	                             "expected type_num %d (NPY_FLOAT64) got %d",
16998	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V253));
16999	                {
17000	        __failure = 254;
17001	        if (!PyErr_Occurred()) {
17002	            PyErr_SetString(PyExc_RuntimeError,
17003	                "Unexpected error in an Op's C code. "
17004	                "No Python exception was set.");
17005	            }
17006	        goto __label_254;}
17007	            }
17008	            
17009	        V253 = (PyArrayObject*)(py_V253);
17010	        Py_XINCREF(V253);
17011	        
17012	{
17013	
17014	    py_V255 = PyList_GET_ITEM(storage_V255, 0);
17015	    {Py_XINCREF(py_V255);}
17016	    
17017	            V255 = NULL;
17018	            if (py_V255 == Py_None) {
17019	                // We can either fail here or set V255 to NULL and rely on Ops
17020	                // using tensors to handle the NULL case, but if they fail to do so
17021	                // they'll end up with nasty segfaults, so this is public service.
17022	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
17023	                {
17024	        __failure = 256;
17025	        if (!PyErr_Occurred()) {
17026	            PyErr_SetString(PyExc_RuntimeError,
17027	                "Unexpected error in an Op's C code. "
17028	                "No Python exception was set.");
17029	            }
17030	        goto __label_256;}
17031	            }
17032	            if (!PyArray_Check(py_V255)) {
17033	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
17034	                {
17035	        __failure = 256;
17036	        if (!PyErr_Occurred()) {
17037	            PyErr_SetString(PyExc_RuntimeError,
17038	                "Unexpected error in an Op's C code. "
17039	                "No Python exception was set.");
17040	            }
17041	        goto __label_256;}
17042	            }
17043	            // We expect NPY_FLOAT64
17044	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V255)) {
17045	                PyArrayObject * tmp = (PyArrayObject*) py_V255;
17046	                PyErr_Format(PyExc_NotImplementedError,
17047	                             "expected an aligned array of type %ld "
17048	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
17049	                             " with %ld dimensions, with 3 last dims "
17050	                             "%ld, %ld, %ld"
17051	                             " and 3 last strides %ld %ld, %ld.",
17052	                             (long int) NPY_FLOAT64,
17053	                             (long int) PyArray_TYPE((PyArrayObject*) py_V255),
17054	                             (long int) PyArray_NDIM(tmp),
17055	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
17056	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
17057	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
17058	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
17059	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
17060	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
17061	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
17062	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
17063	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
17064	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
17065	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
17066	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
17067	            );
17068	                {
17069	        __failure = 256;
17070	        if (!PyErr_Occurred()) {
17071	            PyErr_SetString(PyExc_RuntimeError,
17072	                "Unexpected error in an Op's C code. "
17073	                "No Python exception was set.");
17074	            }
17075	        goto __label_256;}
17076	            }
17077	            // This is a TypeError to be consistent with DEBUG_MODE
17078	            // Note: DEBUG_MODE also tells the name of the container
17079	            if (PyArray_TYPE((PyArrayObject*) py_V255) != NPY_FLOAT64) {
17080	                PyErr_Format(PyExc_TypeError,
17081	                             "expected type_num %d (NPY_FLOAT64) got %d",
17082	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V255));
17083	                {
17084	        __failure = 256;
17085	        if (!PyErr_Occurred()) {
17086	            PyErr_SetString(PyExc_RuntimeError,
17087	                "Unexpected error in an Op's C code. "
17088	                "No Python exception was set.");
17089	            }
17090	        goto __label_256;}
17091	            }
17092	            
17093	        V255 = (PyArrayObject*)(py_V255);
17094	        Py_XINCREF(V255);
17095	        
17096	{
17097	
17098	    py_V257 = PyList_GET_ITEM(storage_V257, 0);
17099	    {Py_XINCREF(py_V257);}
17100	    
17101	            V257 = NULL;
17102	            if (py_V257 == Py_None) {
17103	                // We can either fail here or set V257 to NULL and rely on Ops
17104	                // using tensors to handle the NULL case, but if they fail to do so
17105	                // they'll end up with nasty segfaults, so this is public service.
17106	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
17107	                {
17108	        __failure = 258;
17109	        if (!PyErr_Occurred()) {
17110	            PyErr_SetString(PyExc_RuntimeError,
17111	                "Unexpected error in an Op's C code. "
17112	                "No Python exception was set.");
17113	            }
17114	        goto __label_258;}
17115	            }
17116	            if (!PyArray_Check(py_V257)) {
17117	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
17118	                {
17119	        __failure = 258;
17120	        if (!PyErr_Occurred()) {
17121	            PyErr_SetString(PyExc_RuntimeError,
17122	                "Unexpected error in an Op's C code. "
17123	                "No Python exception was set.");
17124	            }
17125	        goto __label_258;}
17126	            }
17127	            // We expect NPY_FLOAT64
17128	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V257)) {
17129	                PyArrayObject * tmp = (PyArrayObject*) py_V257;
17130	                PyErr_Format(PyExc_NotImplementedError,
17131	                             "expected an aligned array of type %ld "
17132	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
17133	                             " with %ld dimensions, with 3 last dims "
17134	                             "%ld, %ld, %ld"
17135	                             " and 3 last strides %ld %ld, %ld.",
17136	                             (long int) NPY_FLOAT64,
17137	                             (long int) PyArray_TYPE((PyArrayObject*) py_V257),
17138	                             (long int) PyArray_NDIM(tmp),
17139	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
17140	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
17141	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
17142	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
17143	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
17144	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
17145	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
17146	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
17147	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
17148	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
17149	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
17150	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
17151	            );
17152	                {
17153	        __failure = 258;
17154	        if (!PyErr_Occurred()) {
17155	            PyErr_SetString(PyExc_RuntimeError,
17156	                "Unexpected error in an Op's C code. "
17157	                "No Python exception was set.");
17158	            }
17159	        goto __label_258;}
17160	            }
17161	            // This is a TypeError to be consistent with DEBUG_MODE
17162	            // Note: DEBUG_MODE also tells the name of the container
17163	            if (PyArray_TYPE((PyArrayObject*) py_V257) != NPY_FLOAT64) {
17164	                PyErr_Format(PyExc_TypeError,
17165	                             "expected type_num %d (NPY_FLOAT64) got %d",
17166	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V257));
17167	                {
17168	        __failure = 258;
17169	        if (!PyErr_Occurred()) {
17170	            PyErr_SetString(PyExc_RuntimeError,
17171	                "Unexpected error in an Op's C code. "
17172	                "No Python exception was set.");
17173	            }
17174	        goto __label_258;}
17175	            }
17176	            
17177	        V257 = (PyArrayObject*)(py_V257);
17178	        Py_XINCREF(V257);
17179	        
17180	{
17181	
17182	    py_V259 = PyList_GET_ITEM(storage_V259, 0);
17183	    {Py_XINCREF(py_V259);}
17184	    
17185	            V259 = NULL;
17186	            if (py_V259 == Py_None) {
17187	                // We can either fail here or set V259 to NULL and rely on Ops
17188	                // using tensors to handle the NULL case, but if they fail to do so
17189	                // they'll end up with nasty segfaults, so this is public service.
17190	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
17191	                {
17192	        __failure = 260;
17193	        if (!PyErr_Occurred()) {
17194	            PyErr_SetString(PyExc_RuntimeError,
17195	                "Unexpected error in an Op's C code. "
17196	                "No Python exception was set.");
17197	            }
17198	        goto __label_260;}
17199	            }
17200	            if (!PyArray_Check(py_V259)) {
17201	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
17202	                {
17203	        __failure = 260;
17204	        if (!PyErr_Occurred()) {
17205	            PyErr_SetString(PyExc_RuntimeError,
17206	                "Unexpected error in an Op's C code. "
17207	                "No Python exception was set.");
17208	            }
17209	        goto __label_260;}
17210	            }
17211	            // We expect NPY_FLOAT64
17212	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V259)) {
17213	                PyArrayObject * tmp = (PyArrayObject*) py_V259;
17214	                PyErr_Format(PyExc_NotImplementedError,
17215	                             "expected an aligned array of type %ld "
17216	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
17217	                             " with %ld dimensions, with 3 last dims "
17218	                             "%ld, %ld, %ld"
17219	                             " and 3 last strides %ld %ld, %ld.",
17220	                             (long int) NPY_FLOAT64,
17221	                             (long int) PyArray_TYPE((PyArrayObject*) py_V259),
17222	                             (long int) PyArray_NDIM(tmp),
17223	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
17224	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
17225	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
17226	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
17227	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
17228	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
17229	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
17230	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
17231	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
17232	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
17233	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
17234	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
17235	            );
17236	                {
17237	        __failure = 260;
17238	        if (!PyErr_Occurred()) {
17239	            PyErr_SetString(PyExc_RuntimeError,
17240	                "Unexpected error in an Op's C code. "
17241	                "No Python exception was set.");
17242	            }
17243	        goto __label_260;}
17244	            }
17245	            // This is a TypeError to be consistent with DEBUG_MODE
17246	            // Note: DEBUG_MODE also tells the name of the container
17247	            if (PyArray_TYPE((PyArrayObject*) py_V259) != NPY_FLOAT64) {
17248	                PyErr_Format(PyExc_TypeError,
17249	                             "expected type_num %d (NPY_FLOAT64) got %d",
17250	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V259));
17251	                {
17252	        __failure = 260;
17253	        if (!PyErr_Occurred()) {
17254	            PyErr_SetString(PyExc_RuntimeError,
17255	                "Unexpected error in an Op's C code. "
17256	                "No Python exception was set.");
17257	            }
17258	        goto __label_260;}
17259	            }
17260	            
17261	        V259 = (PyArrayObject*)(py_V259);
17262	        Py_XINCREF(V259);
17263	        
17264	{
17265	
17266	    py_V261 = PyList_GET_ITEM(storage_V261, 0);
17267	    {Py_XINCREF(py_V261);}
17268	    
17269	            V261 = NULL;
17270	            if (py_V261 == Py_None) {
17271	                // We can either fail here or set V261 to NULL and rely on Ops
17272	                // using tensors to handle the NULL case, but if they fail to do so
17273	                // they'll end up with nasty segfaults, so this is public service.
17274	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
17275	                {
17276	        __failure = 262;
17277	        if (!PyErr_Occurred()) {
17278	            PyErr_SetString(PyExc_RuntimeError,
17279	                "Unexpected error in an Op's C code. "
17280	                "No Python exception was set.");
17281	            }
17282	        goto __label_262;}
17283	            }
17284	            if (!PyArray_Check(py_V261)) {
17285	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
17286	                {
17287	        __failure = 262;
17288	        if (!PyErr_Occurred()) {
17289	            PyErr_SetString(PyExc_RuntimeError,
17290	                "Unexpected error in an Op's C code. "
17291	                "No Python exception was set.");
17292	            }
17293	        goto __label_262;}
17294	            }
17295	            // We expect NPY_FLOAT64
17296	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V261)) {
17297	                PyArrayObject * tmp = (PyArrayObject*) py_V261;
17298	                PyErr_Format(PyExc_NotImplementedError,
17299	                             "expected an aligned array of type %ld "
17300	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
17301	                             " with %ld dimensions, with 3 last dims "
17302	                             "%ld, %ld, %ld"
17303	                             " and 3 last strides %ld %ld, %ld.",
17304	                             (long int) NPY_FLOAT64,
17305	                             (long int) PyArray_TYPE((PyArrayObject*) py_V261),
17306	                             (long int) PyArray_NDIM(tmp),
17307	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
17308	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
17309	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
17310	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
17311	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
17312	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
17313	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
17314	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
17315	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
17316	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
17317	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
17318	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
17319	            );
17320	                {
17321	        __failure = 262;
17322	        if (!PyErr_Occurred()) {
17323	            PyErr_SetString(PyExc_RuntimeError,
17324	                "Unexpected error in an Op's C code. "
17325	                "No Python exception was set.");
17326	            }
17327	        goto __label_262;}
17328	            }
17329	            // This is a TypeError to be consistent with DEBUG_MODE
17330	            // Note: DEBUG_MODE also tells the name of the container
17331	            if (PyArray_TYPE((PyArrayObject*) py_V261) != NPY_FLOAT64) {
17332	                PyErr_Format(PyExc_TypeError,
17333	                             "expected type_num %d (NPY_FLOAT64) got %d",
17334	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V261));
17335	                {
17336	        __failure = 262;
17337	        if (!PyErr_Occurred()) {
17338	            PyErr_SetString(PyExc_RuntimeError,
17339	                "Unexpected error in an Op's C code. "
17340	                "No Python exception was set.");
17341	            }
17342	        goto __label_262;}
17343	            }
17344	            
17345	        V261 = (PyArrayObject*)(py_V261);
17346	        Py_XINCREF(V261);
17347	        
17348	{
17349	
17350	    py_V263 = PyList_GET_ITEM(storage_V263, 0);
17351	    {Py_XINCREF(py_V263);}
17352	    
17353	            V263 = NULL;
17354	            if (py_V263 == Py_None) {
17355	                // We can either fail here or set V263 to NULL and rely on Ops
17356	                // using tensors to handle the NULL case, but if they fail to do so
17357	                // they'll end up with nasty segfaults, so this is public service.
17358	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
17359	                {
17360	        __failure = 264;
17361	        if (!PyErr_Occurred()) {
17362	            PyErr_SetString(PyExc_RuntimeError,
17363	                "Unexpected error in an Op's C code. "
17364	                "No Python exception was set.");
17365	            }
17366	        goto __label_264;}
17367	            }
17368	            if (!PyArray_Check(py_V263)) {
17369	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
17370	                {
17371	        __failure = 264;
17372	        if (!PyErr_Occurred()) {
17373	            PyErr_SetString(PyExc_RuntimeError,
17374	                "Unexpected error in an Op's C code. "
17375	                "No Python exception was set.");
17376	            }
17377	        goto __label_264;}
17378	            }
17379	            // We expect NPY_FLOAT64
17380	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V263)) {
17381	                PyArrayObject * tmp = (PyArrayObject*) py_V263;
17382	                PyErr_Format(PyExc_NotImplementedError,
17383	                             "expected an aligned array of type %ld "
17384	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
17385	                             " with %ld dimensions, with 3 last dims "
17386	                             "%ld, %ld, %ld"
17387	                             " and 3 last strides %ld %ld, %ld.",
17388	                             (long int) NPY_FLOAT64,
17389	                             (long int) PyArray_TYPE((PyArrayObject*) py_V263),
17390	                             (long int) PyArray_NDIM(tmp),
17391	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
17392	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
17393	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
17394	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
17395	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
17396	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
17397	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
17398	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
17399	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
17400	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
17401	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
17402	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
17403	            );
17404	                {
17405	        __failure = 264;
17406	        if (!PyErr_Occurred()) {
17407	            PyErr_SetString(PyExc_RuntimeError,
17408	                "Unexpected error in an Op's C code. "
17409	                "No Python exception was set.");
17410	            }
17411	        goto __label_264;}
17412	            }
17413	            // This is a TypeError to be consistent with DEBUG_MODE
17414	            // Note: DEBUG_MODE also tells the name of the container
17415	            if (PyArray_TYPE((PyArrayObject*) py_V263) != NPY_FLOAT64) {
17416	                PyErr_Format(PyExc_TypeError,
17417	                             "expected type_num %d (NPY_FLOAT64) got %d",
17418	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V263));
17419	                {
17420	        __failure = 264;
17421	        if (!PyErr_Occurred()) {
17422	            PyErr_SetString(PyExc_RuntimeError,
17423	                "Unexpected error in an Op's C code. "
17424	                "No Python exception was set.");
17425	            }
17426	        goto __label_264;}
17427	            }
17428	            
17429	        V263 = (PyArrayObject*)(py_V263);
17430	        Py_XINCREF(V263);
17431	        
17432	{
17433	
17434	    py_V265 = PyList_GET_ITEM(storage_V265, 0);
17435	    {Py_XINCREF(py_V265);}
17436	    
17437	            V265 = NULL;
17438	            if (py_V265 == Py_None) {
17439	                // We can either fail here or set V265 to NULL and rely on Ops
17440	                // using tensors to handle the NULL case, but if they fail to do so
17441	                // they'll end up with nasty segfaults, so this is public service.
17442	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
17443	                {
17444	        __failure = 266;
17445	        if (!PyErr_Occurred()) {
17446	            PyErr_SetString(PyExc_RuntimeError,
17447	                "Unexpected error in an Op's C code. "
17448	                "No Python exception was set.");
17449	            }
17450	        goto __label_266;}
17451	            }
17452	            if (!PyArray_Check(py_V265)) {
17453	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
17454	                {
17455	        __failure = 266;
17456	        if (!PyErr_Occurred()) {
17457	            PyErr_SetString(PyExc_RuntimeError,
17458	                "Unexpected error in an Op's C code. "
17459	                "No Python exception was set.");
17460	            }
17461	        goto __label_266;}
17462	            }
17463	            // We expect NPY_FLOAT64
17464	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V265)) {
17465	                PyArrayObject * tmp = (PyArrayObject*) py_V265;
17466	                PyErr_Format(PyExc_NotImplementedError,
17467	                             "expected an aligned array of type %ld "
17468	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
17469	                             " with %ld dimensions, with 3 last dims "
17470	                             "%ld, %ld, %ld"
17471	                             " and 3 last strides %ld %ld, %ld.",
17472	                             (long int) NPY_FLOAT64,
17473	                             (long int) PyArray_TYPE((PyArrayObject*) py_V265),
17474	                             (long int) PyArray_NDIM(tmp),
17475	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
17476	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
17477	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
17478	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
17479	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
17480	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
17481	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
17482	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
17483	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
17484	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
17485	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
17486	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
17487	            );
17488	                {
17489	        __failure = 266;
17490	        if (!PyErr_Occurred()) {
17491	            PyErr_SetString(PyExc_RuntimeError,
17492	                "Unexpected error in an Op's C code. "
17493	                "No Python exception was set.");
17494	            }
17495	        goto __label_266;}
17496	            }
17497	            // This is a TypeError to be consistent with DEBUG_MODE
17498	            // Note: DEBUG_MODE also tells the name of the container
17499	            if (PyArray_TYPE((PyArrayObject*) py_V265) != NPY_FLOAT64) {
17500	                PyErr_Format(PyExc_TypeError,
17501	                             "expected type_num %d (NPY_FLOAT64) got %d",
17502	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V265));
17503	                {
17504	        __failure = 266;
17505	        if (!PyErr_Occurred()) {
17506	            PyErr_SetString(PyExc_RuntimeError,
17507	                "Unexpected error in an Op's C code. "
17508	                "No Python exception was set.");
17509	            }
17510	        goto __label_266;}
17511	            }
17512	            
17513	        V265 = (PyArrayObject*)(py_V265);
17514	        Py_XINCREF(V265);
17515	        
17516	{
17517	
17518	    py_V267 = PyList_GET_ITEM(storage_V267, 0);
17519	    {Py_XINCREF(py_V267);}
17520	    
17521	            V267 = NULL;
17522	            if (py_V267 == Py_None) {
17523	                // We can either fail here or set V267 to NULL and rely on Ops
17524	                // using tensors to handle the NULL case, but if they fail to do so
17525	                // they'll end up with nasty segfaults, so this is public service.
17526	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
17527	                {
17528	        __failure = 268;
17529	        if (!PyErr_Occurred()) {
17530	            PyErr_SetString(PyExc_RuntimeError,
17531	                "Unexpected error in an Op's C code. "
17532	                "No Python exception was set.");
17533	            }
17534	        goto __label_268;}
17535	            }
17536	            if (!PyArray_Check(py_V267)) {
17537	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
17538	                {
17539	        __failure = 268;
17540	        if (!PyErr_Occurred()) {
17541	            PyErr_SetString(PyExc_RuntimeError,
17542	                "Unexpected error in an Op's C code. "
17543	                "No Python exception was set.");
17544	            }
17545	        goto __label_268;}
17546	            }
17547	            // We expect NPY_FLOAT64
17548	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V267)) {
17549	                PyArrayObject * tmp = (PyArrayObject*) py_V267;
17550	                PyErr_Format(PyExc_NotImplementedError,
17551	                             "expected an aligned array of type %ld "
17552	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
17553	                             " with %ld dimensions, with 3 last dims "
17554	                             "%ld, %ld, %ld"
17555	                             " and 3 last strides %ld %ld, %ld.",
17556	                             (long int) NPY_FLOAT64,
17557	                             (long int) PyArray_TYPE((PyArrayObject*) py_V267),
17558	                             (long int) PyArray_NDIM(tmp),
17559	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
17560	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
17561	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
17562	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
17563	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
17564	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
17565	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
17566	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
17567	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
17568	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
17569	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
17570	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
17571	            );
17572	                {
17573	        __failure = 268;
17574	        if (!PyErr_Occurred()) {
17575	            PyErr_SetString(PyExc_RuntimeError,
17576	                "Unexpected error in an Op's C code. "
17577	                "No Python exception was set.");
17578	            }
17579	        goto __label_268;}
17580	            }
17581	            // This is a TypeError to be consistent with DEBUG_MODE
17582	            // Note: DEBUG_MODE also tells the name of the container
17583	            if (PyArray_TYPE((PyArrayObject*) py_V267) != NPY_FLOAT64) {
17584	                PyErr_Format(PyExc_TypeError,
17585	                             "expected type_num %d (NPY_FLOAT64) got %d",
17586	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V267));
17587	                {
17588	        __failure = 268;
17589	        if (!PyErr_Occurred()) {
17590	            PyErr_SetString(PyExc_RuntimeError,
17591	                "Unexpected error in an Op's C code. "
17592	                "No Python exception was set.");
17593	            }
17594	        goto __label_268;}
17595	            }
17596	            
17597	        V267 = (PyArrayObject*)(py_V267);
17598	        Py_XINCREF(V267);
17599	        
17600	{
17601	
17602	    py_V269 = PyList_GET_ITEM(storage_V269, 0);
17603	    {Py_XINCREF(py_V269);}
17604	    
17605	            V269 = NULL;
17606	            if (py_V269 == Py_None) {
17607	                // We can either fail here or set V269 to NULL and rely on Ops
17608	                // using tensors to handle the NULL case, but if they fail to do so
17609	                // they'll end up with nasty segfaults, so this is public service.
17610	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
17611	                {
17612	        __failure = 270;
17613	        if (!PyErr_Occurred()) {
17614	            PyErr_SetString(PyExc_RuntimeError,
17615	                "Unexpected error in an Op's C code. "
17616	                "No Python exception was set.");
17617	            }
17618	        goto __label_270;}
17619	            }
17620	            if (!PyArray_Check(py_V269)) {
17621	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
17622	                {
17623	        __failure = 270;
17624	        if (!PyErr_Occurred()) {
17625	            PyErr_SetString(PyExc_RuntimeError,
17626	                "Unexpected error in an Op's C code. "
17627	                "No Python exception was set.");
17628	            }
17629	        goto __label_270;}
17630	            }
17631	            // We expect NPY_FLOAT64
17632	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V269)) {
17633	                PyArrayObject * tmp = (PyArrayObject*) py_V269;
17634	                PyErr_Format(PyExc_NotImplementedError,
17635	                             "expected an aligned array of type %ld "
17636	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
17637	                             " with %ld dimensions, with 3 last dims "
17638	                             "%ld, %ld, %ld"
17639	                             " and 3 last strides %ld %ld, %ld.",
17640	                             (long int) NPY_FLOAT64,
17641	                             (long int) PyArray_TYPE((PyArrayObject*) py_V269),
17642	                             (long int) PyArray_NDIM(tmp),
17643	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
17644	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
17645	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
17646	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
17647	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
17648	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
17649	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
17650	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
17651	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
17652	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
17653	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
17654	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
17655	            );
17656	                {
17657	        __failure = 270;
17658	        if (!PyErr_Occurred()) {
17659	            PyErr_SetString(PyExc_RuntimeError,
17660	                "Unexpected error in an Op's C code. "
17661	                "No Python exception was set.");
17662	            }
17663	        goto __label_270;}
17664	            }
17665	            // This is a TypeError to be consistent with DEBUG_MODE
17666	            // Note: DEBUG_MODE also tells the name of the container
17667	            if (PyArray_TYPE((PyArrayObject*) py_V269) != NPY_FLOAT64) {
17668	                PyErr_Format(PyExc_TypeError,
17669	                             "expected type_num %d (NPY_FLOAT64) got %d",
17670	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V269));
17671	                {
17672	        __failure = 270;
17673	        if (!PyErr_Occurred()) {
17674	            PyErr_SetString(PyExc_RuntimeError,
17675	                "Unexpected error in an Op's C code. "
17676	                "No Python exception was set.");
17677	            }
17678	        goto __label_270;}
17679	            }
17680	            
17681	        V269 = (PyArrayObject*)(py_V269);
17682	        Py_XINCREF(V269);
17683	        
17684	{
17685	
17686	    py_V271 = PyList_GET_ITEM(storage_V271, 0);
17687	    {Py_XINCREF(py_V271);}
17688	    
17689	            V271 = NULL;
17690	            if (py_V271 == Py_None) {
17691	                // We can either fail here or set V271 to NULL and rely on Ops
17692	                // using tensors to handle the NULL case, but if they fail to do so
17693	                // they'll end up with nasty segfaults, so this is public service.
17694	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
17695	                {
17696	        __failure = 272;
17697	        if (!PyErr_Occurred()) {
17698	            PyErr_SetString(PyExc_RuntimeError,
17699	                "Unexpected error in an Op's C code. "
17700	                "No Python exception was set.");
17701	            }
17702	        goto __label_272;}
17703	            }
17704	            if (!PyArray_Check(py_V271)) {
17705	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
17706	                {
17707	        __failure = 272;
17708	        if (!PyErr_Occurred()) {
17709	            PyErr_SetString(PyExc_RuntimeError,
17710	                "Unexpected error in an Op's C code. "
17711	                "No Python exception was set.");
17712	            }
17713	        goto __label_272;}
17714	            }
17715	            // We expect NPY_FLOAT64
17716	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V271)) {
17717	                PyArrayObject * tmp = (PyArrayObject*) py_V271;
17718	                PyErr_Format(PyExc_NotImplementedError,
17719	                             "expected an aligned array of type %ld "
17720	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
17721	                             " with %ld dimensions, with 3 last dims "
17722	                             "%ld, %ld, %ld"
17723	                             " and 3 last strides %ld %ld, %ld.",
17724	                             (long int) NPY_FLOAT64,
17725	                             (long int) PyArray_TYPE((PyArrayObject*) py_V271),
17726	                             (long int) PyArray_NDIM(tmp),
17727	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
17728	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
17729	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
17730	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
17731	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
17732	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
17733	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
17734	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
17735	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
17736	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
17737	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
17738	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
17739	            );
17740	                {
17741	        __failure = 272;
17742	        if (!PyErr_Occurred()) {
17743	            PyErr_SetString(PyExc_RuntimeError,
17744	                "Unexpected error in an Op's C code. "
17745	                "No Python exception was set.");
17746	            }
17747	        goto __label_272;}
17748	            }
17749	            // This is a TypeError to be consistent with DEBUG_MODE
17750	            // Note: DEBUG_MODE also tells the name of the container
17751	            if (PyArray_TYPE((PyArrayObject*) py_V271) != NPY_FLOAT64) {
17752	                PyErr_Format(PyExc_TypeError,
17753	                             "expected type_num %d (NPY_FLOAT64) got %d",
17754	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V271));
17755	                {
17756	        __failure = 272;
17757	        if (!PyErr_Occurred()) {
17758	            PyErr_SetString(PyExc_RuntimeError,
17759	                "Unexpected error in an Op's C code. "
17760	                "No Python exception was set.");
17761	            }
17762	        goto __label_272;}
17763	            }
17764	            
17765	        V271 = (PyArrayObject*)(py_V271);
17766	        Py_XINCREF(V271);
17767	        
17768	{
17769	
17770	    py_V273 = PyList_GET_ITEM(storage_V273, 0);
17771	    {Py_XINCREF(py_V273);}
17772	    
17773	            V273 = NULL;
17774	            if (py_V273 == Py_None) {
17775	                // We can either fail here or set V273 to NULL and rely on Ops
17776	                // using tensors to handle the NULL case, but if they fail to do so
17777	                // they'll end up with nasty segfaults, so this is public service.
17778	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
17779	                {
17780	        __failure = 274;
17781	        if (!PyErr_Occurred()) {
17782	            PyErr_SetString(PyExc_RuntimeError,
17783	                "Unexpected error in an Op's C code. "
17784	                "No Python exception was set.");
17785	            }
17786	        goto __label_274;}
17787	            }
17788	            if (!PyArray_Check(py_V273)) {
17789	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
17790	                {
17791	        __failure = 274;
17792	        if (!PyErr_Occurred()) {
17793	            PyErr_SetString(PyExc_RuntimeError,
17794	                "Unexpected error in an Op's C code. "
17795	                "No Python exception was set.");
17796	            }
17797	        goto __label_274;}
17798	            }
17799	            // We expect NPY_FLOAT64
17800	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V273)) {
17801	                PyArrayObject * tmp = (PyArrayObject*) py_V273;
17802	                PyErr_Format(PyExc_NotImplementedError,
17803	                             "expected an aligned array of type %ld "
17804	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
17805	                             " with %ld dimensions, with 3 last dims "
17806	                             "%ld, %ld, %ld"
17807	                             " and 3 last strides %ld %ld, %ld.",
17808	                             (long int) NPY_FLOAT64,
17809	                             (long int) PyArray_TYPE((PyArrayObject*) py_V273),
17810	                             (long int) PyArray_NDIM(tmp),
17811	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
17812	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
17813	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
17814	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
17815	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
17816	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
17817	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
17818	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
17819	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
17820	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
17821	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
17822	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
17823	            );
17824	                {
17825	        __failure = 274;
17826	        if (!PyErr_Occurred()) {
17827	            PyErr_SetString(PyExc_RuntimeError,
17828	                "Unexpected error in an Op's C code. "
17829	                "No Python exception was set.");
17830	            }
17831	        goto __label_274;}
17832	            }
17833	            // This is a TypeError to be consistent with DEBUG_MODE
17834	            // Note: DEBUG_MODE also tells the name of the container
17835	            if (PyArray_TYPE((PyArrayObject*) py_V273) != NPY_FLOAT64) {
17836	                PyErr_Format(PyExc_TypeError,
17837	                             "expected type_num %d (NPY_FLOAT64) got %d",
17838	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V273));
17839	                {
17840	        __failure = 274;
17841	        if (!PyErr_Occurred()) {
17842	            PyErr_SetString(PyExc_RuntimeError,
17843	                "Unexpected error in an Op's C code. "
17844	                "No Python exception was set.");
17845	            }
17846	        goto __label_274;}
17847	            }
17848	            
17849	        V273 = (PyArrayObject*)(py_V273);
17850	        Py_XINCREF(V273);
17851	        
17852	{
17853	
17854	    py_V275 = PyList_GET_ITEM(storage_V275, 0);
17855	    {Py_XINCREF(py_V275);}
17856	    
17857	            V275 = NULL;
17858	            if (py_V275 == Py_None) {
17859	                // We can either fail here or set V275 to NULL and rely on Ops
17860	                // using tensors to handle the NULL case, but if they fail to do so
17861	                // they'll end up with nasty segfaults, so this is public service.
17862	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
17863	                {
17864	        __failure = 276;
17865	        if (!PyErr_Occurred()) {
17866	            PyErr_SetString(PyExc_RuntimeError,
17867	                "Unexpected error in an Op's C code. "
17868	                "No Python exception was set.");
17869	            }
17870	        goto __label_276;}
17871	            }
17872	            if (!PyArray_Check(py_V275)) {
17873	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
17874	                {
17875	        __failure = 276;
17876	        if (!PyErr_Occurred()) {
17877	            PyErr_SetString(PyExc_RuntimeError,
17878	                "Unexpected error in an Op's C code. "
17879	                "No Python exception was set.");
17880	            }
17881	        goto __label_276;}
17882	            }
17883	            // We expect NPY_FLOAT64
17884	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V275)) {
17885	                PyArrayObject * tmp = (PyArrayObject*) py_V275;
17886	                PyErr_Format(PyExc_NotImplementedError,
17887	                             "expected an aligned array of type %ld "
17888	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
17889	                             " with %ld dimensions, with 3 last dims "
17890	                             "%ld, %ld, %ld"
17891	                             " and 3 last strides %ld %ld, %ld.",
17892	                             (long int) NPY_FLOAT64,
17893	                             (long int) PyArray_TYPE((PyArrayObject*) py_V275),
17894	                             (long int) PyArray_NDIM(tmp),
17895	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
17896	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
17897	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
17898	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
17899	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
17900	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
17901	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
17902	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
17903	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
17904	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
17905	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
17906	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
17907	            );
17908	                {
17909	        __failure = 276;
17910	        if (!PyErr_Occurred()) {
17911	            PyErr_SetString(PyExc_RuntimeError,
17912	                "Unexpected error in an Op's C code. "
17913	                "No Python exception was set.");
17914	            }
17915	        goto __label_276;}
17916	            }
17917	            // This is a TypeError to be consistent with DEBUG_MODE
17918	            // Note: DEBUG_MODE also tells the name of the container
17919	            if (PyArray_TYPE((PyArrayObject*) py_V275) != NPY_FLOAT64) {
17920	                PyErr_Format(PyExc_TypeError,
17921	                             "expected type_num %d (NPY_FLOAT64) got %d",
17922	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V275));
17923	                {
17924	        __failure = 276;
17925	        if (!PyErr_Occurred()) {
17926	            PyErr_SetString(PyExc_RuntimeError,
17927	                "Unexpected error in an Op's C code. "
17928	                "No Python exception was set.");
17929	            }
17930	        goto __label_276;}
17931	            }
17932	            
17933	        V275 = (PyArrayObject*)(py_V275);
17934	        Py_XINCREF(V275);
17935	        
17936	{
17937	
17938	    py_V277 = PyList_GET_ITEM(storage_V277, 0);
17939	    {Py_XINCREF(py_V277);}
17940	    
17941	            V277 = NULL;
17942	            if (py_V277 == Py_None) {
17943	                // We can either fail here or set V277 to NULL and rely on Ops
17944	                // using tensors to handle the NULL case, but if they fail to do so
17945	                // they'll end up with nasty segfaults, so this is public service.
17946	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
17947	                {
17948	        __failure = 278;
17949	        if (!PyErr_Occurred()) {
17950	            PyErr_SetString(PyExc_RuntimeError,
17951	                "Unexpected error in an Op's C code. "
17952	                "No Python exception was set.");
17953	            }
17954	        goto __label_278;}
17955	            }
17956	            if (!PyArray_Check(py_V277)) {
17957	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
17958	                {
17959	        __failure = 278;
17960	        if (!PyErr_Occurred()) {
17961	            PyErr_SetString(PyExc_RuntimeError,
17962	                "Unexpected error in an Op's C code. "
17963	                "No Python exception was set.");
17964	            }
17965	        goto __label_278;}
17966	            }
17967	            // We expect NPY_FLOAT64
17968	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V277)) {
17969	                PyArrayObject * tmp = (PyArrayObject*) py_V277;
17970	                PyErr_Format(PyExc_NotImplementedError,
17971	                             "expected an aligned array of type %ld "
17972	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
17973	                             " with %ld dimensions, with 3 last dims "
17974	                             "%ld, %ld, %ld"
17975	                             " and 3 last strides %ld %ld, %ld.",
17976	                             (long int) NPY_FLOAT64,
17977	                             (long int) PyArray_TYPE((PyArrayObject*) py_V277),
17978	                             (long int) PyArray_NDIM(tmp),
17979	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
17980	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
17981	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
17982	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
17983	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
17984	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
17985	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
17986	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
17987	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
17988	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
17989	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
17990	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
17991	            );
17992	                {
17993	        __failure = 278;
17994	        if (!PyErr_Occurred()) {
17995	            PyErr_SetString(PyExc_RuntimeError,
17996	                "Unexpected error in an Op's C code. "
17997	                "No Python exception was set.");
17998	            }
17999	        goto __label_278;}
18000	            }
18001	            // This is a TypeError to be consistent with DEBUG_MODE
18002	            // Note: DEBUG_MODE also tells the name of the container
18003	            if (PyArray_TYPE((PyArrayObject*) py_V277) != NPY_FLOAT64) {
18004	                PyErr_Format(PyExc_TypeError,
18005	                             "expected type_num %d (NPY_FLOAT64) got %d",
18006	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V277));
18007	                {
18008	        __failure = 278;
18009	        if (!PyErr_Occurred()) {
18010	            PyErr_SetString(PyExc_RuntimeError,
18011	                "Unexpected error in an Op's C code. "
18012	                "No Python exception was set.");
18013	            }
18014	        goto __label_278;}
18015	            }
18016	            
18017	        V277 = (PyArrayObject*)(py_V277);
18018	        Py_XINCREF(V277);
18019	        
18020	{
18021	
18022	    py_V279 = PyList_GET_ITEM(storage_V279, 0);
18023	    {Py_XINCREF(py_V279);}
18024	    
18025	            V279 = NULL;
18026	            if (py_V279 == Py_None) {
18027	                // We can either fail here or set V279 to NULL and rely on Ops
18028	                // using tensors to handle the NULL case, but if they fail to do so
18029	                // they'll end up with nasty segfaults, so this is public service.
18030	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
18031	                {
18032	        __failure = 280;
18033	        if (!PyErr_Occurred()) {
18034	            PyErr_SetString(PyExc_RuntimeError,
18035	                "Unexpected error in an Op's C code. "
18036	                "No Python exception was set.");
18037	            }
18038	        goto __label_280;}
18039	            }
18040	            if (!PyArray_Check(py_V279)) {
18041	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
18042	                {
18043	        __failure = 280;
18044	        if (!PyErr_Occurred()) {
18045	            PyErr_SetString(PyExc_RuntimeError,
18046	                "Unexpected error in an Op's C code. "
18047	                "No Python exception was set.");
18048	            }
18049	        goto __label_280;}
18050	            }
18051	            // We expect NPY_FLOAT64
18052	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V279)) {
18053	                PyArrayObject * tmp = (PyArrayObject*) py_V279;
18054	                PyErr_Format(PyExc_NotImplementedError,
18055	                             "expected an aligned array of type %ld "
18056	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
18057	                             " with %ld dimensions, with 3 last dims "
18058	                             "%ld, %ld, %ld"
18059	                             " and 3 last strides %ld %ld, %ld.",
18060	                             (long int) NPY_FLOAT64,
18061	                             (long int) PyArray_TYPE((PyArrayObject*) py_V279),
18062	                             (long int) PyArray_NDIM(tmp),
18063	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
18064	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
18065	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
18066	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
18067	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
18068	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
18069	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
18070	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
18071	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
18072	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
18073	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
18074	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
18075	            );
18076	                {
18077	        __failure = 280;
18078	        if (!PyErr_Occurred()) {
18079	            PyErr_SetString(PyExc_RuntimeError,
18080	                "Unexpected error in an Op's C code. "
18081	                "No Python exception was set.");
18082	            }
18083	        goto __label_280;}
18084	            }
18085	            // This is a TypeError to be consistent with DEBUG_MODE
18086	            // Note: DEBUG_MODE also tells the name of the container
18087	            if (PyArray_TYPE((PyArrayObject*) py_V279) != NPY_FLOAT64) {
18088	                PyErr_Format(PyExc_TypeError,
18089	                             "expected type_num %d (NPY_FLOAT64) got %d",
18090	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V279));
18091	                {
18092	        __failure = 280;
18093	        if (!PyErr_Occurred()) {
18094	            PyErr_SetString(PyExc_RuntimeError,
18095	                "Unexpected error in an Op's C code. "
18096	                "No Python exception was set.");
18097	            }
18098	        goto __label_280;}
18099	            }
18100	            
18101	        V279 = (PyArrayObject*)(py_V279);
18102	        Py_XINCREF(V279);
18103	        
18104	{
18105	
18106	    py_V281 = PyList_GET_ITEM(storage_V281, 0);
18107	    {Py_XINCREF(py_V281);}
18108	    
18109	            V281 = NULL;
18110	            if (py_V281 == Py_None) {
18111	                // We can either fail here or set V281 to NULL and rely on Ops
18112	                // using tensors to handle the NULL case, but if they fail to do so
18113	                // they'll end up with nasty segfaults, so this is public service.
18114	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
18115	                {
18116	        __failure = 282;
18117	        if (!PyErr_Occurred()) {
18118	            PyErr_SetString(PyExc_RuntimeError,
18119	                "Unexpected error in an Op's C code. "
18120	                "No Python exception was set.");
18121	            }
18122	        goto __label_282;}
18123	            }
18124	            if (!PyArray_Check(py_V281)) {
18125	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
18126	                {
18127	        __failure = 282;
18128	        if (!PyErr_Occurred()) {
18129	            PyErr_SetString(PyExc_RuntimeError,
18130	                "Unexpected error in an Op's C code. "
18131	                "No Python exception was set.");
18132	            }
18133	        goto __label_282;}
18134	            }
18135	            // We expect NPY_FLOAT64
18136	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V281)) {
18137	                PyArrayObject * tmp = (PyArrayObject*) py_V281;
18138	                PyErr_Format(PyExc_NotImplementedError,
18139	                             "expected an aligned array of type %ld "
18140	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
18141	                             " with %ld dimensions, with 3 last dims "
18142	                             "%ld, %ld, %ld"
18143	                             " and 3 last strides %ld %ld, %ld.",
18144	                             (long int) NPY_FLOAT64,
18145	                             (long int) PyArray_TYPE((PyArrayObject*) py_V281),
18146	                             (long int) PyArray_NDIM(tmp),
18147	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
18148	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
18149	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
18150	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
18151	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
18152	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
18153	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
18154	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
18155	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
18156	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
18157	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
18158	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
18159	            );
18160	                {
18161	        __failure = 282;
18162	        if (!PyErr_Occurred()) {
18163	            PyErr_SetString(PyExc_RuntimeError,
18164	                "Unexpected error in an Op's C code. "
18165	                "No Python exception was set.");
18166	            }
18167	        goto __label_282;}
18168	            }
18169	            // This is a TypeError to be consistent with DEBUG_MODE
18170	            // Note: DEBUG_MODE also tells the name of the container
18171	            if (PyArray_TYPE((PyArrayObject*) py_V281) != NPY_FLOAT64) {
18172	                PyErr_Format(PyExc_TypeError,
18173	                             "expected type_num %d (NPY_FLOAT64) got %d",
18174	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V281));
18175	                {
18176	        __failure = 282;
18177	        if (!PyErr_Occurred()) {
18178	            PyErr_SetString(PyExc_RuntimeError,
18179	                "Unexpected error in an Op's C code. "
18180	                "No Python exception was set.");
18181	            }
18182	        goto __label_282;}
18183	            }
18184	            
18185	        V281 = (PyArrayObject*)(py_V281);
18186	        Py_XINCREF(V281);
18187	        
18188	{
18189	
18190	    py_V283 = PyList_GET_ITEM(storage_V283, 0);
18191	    {Py_XINCREF(py_V283);}
18192	    
18193	            V283 = NULL;
18194	            if (py_V283 == Py_None) {
18195	                // We can either fail here or set V283 to NULL and rely on Ops
18196	                // using tensors to handle the NULL case, but if they fail to do so
18197	                // they'll end up with nasty segfaults, so this is public service.
18198	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
18199	                {
18200	        __failure = 284;
18201	        if (!PyErr_Occurred()) {
18202	            PyErr_SetString(PyExc_RuntimeError,
18203	                "Unexpected error in an Op's C code. "
18204	                "No Python exception was set.");
18205	            }
18206	        goto __label_284;}
18207	            }
18208	            if (!PyArray_Check(py_V283)) {
18209	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
18210	                {
18211	        __failure = 284;
18212	        if (!PyErr_Occurred()) {
18213	            PyErr_SetString(PyExc_RuntimeError,
18214	                "Unexpected error in an Op's C code. "
18215	                "No Python exception was set.");
18216	            }
18217	        goto __label_284;}
18218	            }
18219	            // We expect NPY_FLOAT64
18220	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V283)) {
18221	                PyArrayObject * tmp = (PyArrayObject*) py_V283;
18222	                PyErr_Format(PyExc_NotImplementedError,
18223	                             "expected an aligned array of type %ld "
18224	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
18225	                             " with %ld dimensions, with 3 last dims "
18226	                             "%ld, %ld, %ld"
18227	                             " and 3 last strides %ld %ld, %ld.",
18228	                             (long int) NPY_FLOAT64,
18229	                             (long int) PyArray_TYPE((PyArrayObject*) py_V283),
18230	                             (long int) PyArray_NDIM(tmp),
18231	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
18232	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
18233	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
18234	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
18235	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
18236	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
18237	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
18238	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
18239	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
18240	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
18241	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
18242	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
18243	            );
18244	                {
18245	        __failure = 284;
18246	        if (!PyErr_Occurred()) {
18247	            PyErr_SetString(PyExc_RuntimeError,
18248	                "Unexpected error in an Op's C code. "
18249	                "No Python exception was set.");
18250	            }
18251	        goto __label_284;}
18252	            }
18253	            // This is a TypeError to be consistent with DEBUG_MODE
18254	            // Note: DEBUG_MODE also tells the name of the container
18255	            if (PyArray_TYPE((PyArrayObject*) py_V283) != NPY_FLOAT64) {
18256	                PyErr_Format(PyExc_TypeError,
18257	                             "expected type_num %d (NPY_FLOAT64) got %d",
18258	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V283));
18259	                {
18260	        __failure = 284;
18261	        if (!PyErr_Occurred()) {
18262	            PyErr_SetString(PyExc_RuntimeError,
18263	                "Unexpected error in an Op's C code. "
18264	                "No Python exception was set.");
18265	            }
18266	        goto __label_284;}
18267	            }
18268	            
18269	        V283 = (PyArrayObject*)(py_V283);
18270	        Py_XINCREF(V283);
18271	        
18272	{
18273	
18274	    py_V285 = PyList_GET_ITEM(storage_V285, 0);
18275	    {Py_XINCREF(py_V285);}
18276	    
18277	            V285 = NULL;
18278	            if (py_V285 == Py_None) {
18279	                // We can either fail here or set V285 to NULL and rely on Ops
18280	                // using tensors to handle the NULL case, but if they fail to do so
18281	                // they'll end up with nasty segfaults, so this is public service.
18282	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
18283	                {
18284	        __failure = 286;
18285	        if (!PyErr_Occurred()) {
18286	            PyErr_SetString(PyExc_RuntimeError,
18287	                "Unexpected error in an Op's C code. "
18288	                "No Python exception was set.");
18289	            }
18290	        goto __label_286;}
18291	            }
18292	            if (!PyArray_Check(py_V285)) {
18293	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
18294	                {
18295	        __failure = 286;
18296	        if (!PyErr_Occurred()) {
18297	            PyErr_SetString(PyExc_RuntimeError,
18298	                "Unexpected error in an Op's C code. "
18299	                "No Python exception was set.");
18300	            }
18301	        goto __label_286;}
18302	            }
18303	            // We expect NPY_FLOAT64
18304	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V285)) {
18305	                PyArrayObject * tmp = (PyArrayObject*) py_V285;
18306	                PyErr_Format(PyExc_NotImplementedError,
18307	                             "expected an aligned array of type %ld "
18308	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
18309	                             " with %ld dimensions, with 3 last dims "
18310	                             "%ld, %ld, %ld"
18311	                             " and 3 last strides %ld %ld, %ld.",
18312	                             (long int) NPY_FLOAT64,
18313	                             (long int) PyArray_TYPE((PyArrayObject*) py_V285),
18314	                             (long int) PyArray_NDIM(tmp),
18315	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
18316	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
18317	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
18318	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
18319	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
18320	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
18321	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
18322	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
18323	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
18324	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
18325	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
18326	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
18327	            );
18328	                {
18329	        __failure = 286;
18330	        if (!PyErr_Occurred()) {
18331	            PyErr_SetString(PyExc_RuntimeError,
18332	                "Unexpected error in an Op's C code. "
18333	                "No Python exception was set.");
18334	            }
18335	        goto __label_286;}
18336	            }
18337	            // This is a TypeError to be consistent with DEBUG_MODE
18338	            // Note: DEBUG_MODE also tells the name of the container
18339	            if (PyArray_TYPE((PyArrayObject*) py_V285) != NPY_FLOAT64) {
18340	                PyErr_Format(PyExc_TypeError,
18341	                             "expected type_num %d (NPY_FLOAT64) got %d",
18342	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V285));
18343	                {
18344	        __failure = 286;
18345	        if (!PyErr_Occurred()) {
18346	            PyErr_SetString(PyExc_RuntimeError,
18347	                "Unexpected error in an Op's C code. "
18348	                "No Python exception was set.");
18349	            }
18350	        goto __label_286;}
18351	            }
18352	            
18353	        V285 = (PyArrayObject*)(py_V285);
18354	        Py_XINCREF(V285);
18355	        
18356	{
18357	
18358	    py_V287 = PyList_GET_ITEM(storage_V287, 0);
18359	    {Py_XINCREF(py_V287);}
18360	    
18361	            V287 = NULL;
18362	            if (py_V287 == Py_None) {
18363	                // We can either fail here or set V287 to NULL and rely on Ops
18364	                // using tensors to handle the NULL case, but if they fail to do so
18365	                // they'll end up with nasty segfaults, so this is public service.
18366	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
18367	                {
18368	        __failure = 288;
18369	        if (!PyErr_Occurred()) {
18370	            PyErr_SetString(PyExc_RuntimeError,
18371	                "Unexpected error in an Op's C code. "
18372	                "No Python exception was set.");
18373	            }
18374	        goto __label_288;}
18375	            }
18376	            if (!PyArray_Check(py_V287)) {
18377	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
18378	                {
18379	        __failure = 288;
18380	        if (!PyErr_Occurred()) {
18381	            PyErr_SetString(PyExc_RuntimeError,
18382	                "Unexpected error in an Op's C code. "
18383	                "No Python exception was set.");
18384	            }
18385	        goto __label_288;}
18386	            }
18387	            // We expect NPY_FLOAT64
18388	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V287)) {
18389	                PyArrayObject * tmp = (PyArrayObject*) py_V287;
18390	                PyErr_Format(PyExc_NotImplementedError,
18391	                             "expected an aligned array of type %ld "
18392	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
18393	                             " with %ld dimensions, with 3 last dims "
18394	                             "%ld, %ld, %ld"
18395	                             " and 3 last strides %ld %ld, %ld.",
18396	                             (long int) NPY_FLOAT64,
18397	                             (long int) PyArray_TYPE((PyArrayObject*) py_V287),
18398	                             (long int) PyArray_NDIM(tmp),
18399	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
18400	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
18401	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
18402	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
18403	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
18404	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
18405	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
18406	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
18407	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
18408	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
18409	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
18410	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
18411	            );
18412	                {
18413	        __failure = 288;
18414	        if (!PyErr_Occurred()) {
18415	            PyErr_SetString(PyExc_RuntimeError,
18416	                "Unexpected error in an Op's C code. "
18417	                "No Python exception was set.");
18418	            }
18419	        goto __label_288;}
18420	            }
18421	            // This is a TypeError to be consistent with DEBUG_MODE
18422	            // Note: DEBUG_MODE also tells the name of the container
18423	            if (PyArray_TYPE((PyArrayObject*) py_V287) != NPY_FLOAT64) {
18424	                PyErr_Format(PyExc_TypeError,
18425	                             "expected type_num %d (NPY_FLOAT64) got %d",
18426	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V287));
18427	                {
18428	        __failure = 288;
18429	        if (!PyErr_Occurred()) {
18430	            PyErr_SetString(PyExc_RuntimeError,
18431	                "Unexpected error in an Op's C code. "
18432	                "No Python exception was set.");
18433	            }
18434	        goto __label_288;}
18435	            }
18436	            
18437	        V287 = (PyArrayObject*)(py_V287);
18438	        Py_XINCREF(V287);
18439	        
18440	{
18441	
18442	    py_V289 = PyList_GET_ITEM(storage_V289, 0);
18443	    {Py_XINCREF(py_V289);}
18444	    
18445	            V289 = NULL;
18446	            if (py_V289 == Py_None) {
18447	                // We can either fail here or set V289 to NULL and rely on Ops
18448	                // using tensors to handle the NULL case, but if they fail to do so
18449	                // they'll end up with nasty segfaults, so this is public service.
18450	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
18451	                {
18452	        __failure = 290;
18453	        if (!PyErr_Occurred()) {
18454	            PyErr_SetString(PyExc_RuntimeError,
18455	                "Unexpected error in an Op's C code. "
18456	                "No Python exception was set.");
18457	            }
18458	        goto __label_290;}
18459	            }
18460	            if (!PyArray_Check(py_V289)) {
18461	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
18462	                {
18463	        __failure = 290;
18464	        if (!PyErr_Occurred()) {
18465	            PyErr_SetString(PyExc_RuntimeError,
18466	                "Unexpected error in an Op's C code. "
18467	                "No Python exception was set.");
18468	            }
18469	        goto __label_290;}
18470	            }
18471	            // We expect NPY_FLOAT64
18472	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V289)) {
18473	                PyArrayObject * tmp = (PyArrayObject*) py_V289;
18474	                PyErr_Format(PyExc_NotImplementedError,
18475	                             "expected an aligned array of type %ld "
18476	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
18477	                             " with %ld dimensions, with 3 last dims "
18478	                             "%ld, %ld, %ld"
18479	                             " and 3 last strides %ld %ld, %ld.",
18480	                             (long int) NPY_FLOAT64,
18481	                             (long int) PyArray_TYPE((PyArrayObject*) py_V289),
18482	                             (long int) PyArray_NDIM(tmp),
18483	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
18484	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
18485	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
18486	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
18487	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
18488	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
18489	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
18490	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
18491	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
18492	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
18493	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
18494	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
18495	            );
18496	                {
18497	        __failure = 290;
18498	        if (!PyErr_Occurred()) {
18499	            PyErr_SetString(PyExc_RuntimeError,
18500	                "Unexpected error in an Op's C code. "
18501	                "No Python exception was set.");
18502	            }
18503	        goto __label_290;}
18504	            }
18505	            // This is a TypeError to be consistent with DEBUG_MODE
18506	            // Note: DEBUG_MODE also tells the name of the container
18507	            if (PyArray_TYPE((PyArrayObject*) py_V289) != NPY_FLOAT64) {
18508	                PyErr_Format(PyExc_TypeError,
18509	                             "expected type_num %d (NPY_FLOAT64) got %d",
18510	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V289));
18511	                {
18512	        __failure = 290;
18513	        if (!PyErr_Occurred()) {
18514	            PyErr_SetString(PyExc_RuntimeError,
18515	                "Unexpected error in an Op's C code. "
18516	                "No Python exception was set.");
18517	            }
18518	        goto __label_290;}
18519	            }
18520	            
18521	        V289 = (PyArrayObject*)(py_V289);
18522	        Py_XINCREF(V289);
18523	        
18524	{
18525	
18526	    py_V291 = PyList_GET_ITEM(storage_V291, 0);
18527	    {Py_XINCREF(py_V291);}
18528	    
18529	            V291 = NULL;
18530	            if (py_V291 == Py_None) {
18531	                // We can either fail here or set V291 to NULL and rely on Ops
18532	                // using tensors to handle the NULL case, but if they fail to do so
18533	                // they'll end up with nasty segfaults, so this is public service.
18534	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
18535	                {
18536	        __failure = 292;
18537	        if (!PyErr_Occurred()) {
18538	            PyErr_SetString(PyExc_RuntimeError,
18539	                "Unexpected error in an Op's C code. "
18540	                "No Python exception was set.");
18541	            }
18542	        goto __label_292;}
18543	            }
18544	            if (!PyArray_Check(py_V291)) {
18545	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
18546	                {
18547	        __failure = 292;
18548	        if (!PyErr_Occurred()) {
18549	            PyErr_SetString(PyExc_RuntimeError,
18550	                "Unexpected error in an Op's C code. "
18551	                "No Python exception was set.");
18552	            }
18553	        goto __label_292;}
18554	            }
18555	            // We expect NPY_FLOAT64
18556	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V291)) {
18557	                PyArrayObject * tmp = (PyArrayObject*) py_V291;
18558	                PyErr_Format(PyExc_NotImplementedError,
18559	                             "expected an aligned array of type %ld "
18560	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
18561	                             " with %ld dimensions, with 3 last dims "
18562	                             "%ld, %ld, %ld"
18563	                             " and 3 last strides %ld %ld, %ld.",
18564	                             (long int) NPY_FLOAT64,
18565	                             (long int) PyArray_TYPE((PyArrayObject*) py_V291),
18566	                             (long int) PyArray_NDIM(tmp),
18567	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
18568	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
18569	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
18570	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
18571	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
18572	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
18573	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
18574	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
18575	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
18576	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
18577	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
18578	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
18579	            );
18580	                {
18581	        __failure = 292;
18582	        if (!PyErr_Occurred()) {
18583	            PyErr_SetString(PyExc_RuntimeError,
18584	                "Unexpected error in an Op's C code. "
18585	                "No Python exception was set.");
18586	            }
18587	        goto __label_292;}
18588	            }
18589	            // This is a TypeError to be consistent with DEBUG_MODE
18590	            // Note: DEBUG_MODE also tells the name of the container
18591	            if (PyArray_TYPE((PyArrayObject*) py_V291) != NPY_FLOAT64) {
18592	                PyErr_Format(PyExc_TypeError,
18593	                             "expected type_num %d (NPY_FLOAT64) got %d",
18594	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V291));
18595	                {
18596	        __failure = 292;
18597	        if (!PyErr_Occurred()) {
18598	            PyErr_SetString(PyExc_RuntimeError,
18599	                "Unexpected error in an Op's C code. "
18600	                "No Python exception was set.");
18601	            }
18602	        goto __label_292;}
18603	            }
18604	            
18605	        V291 = (PyArrayObject*)(py_V291);
18606	        Py_XINCREF(V291);
18607	        
18608	{
18609	
18610	    py_V293 = PyList_GET_ITEM(storage_V293, 0);
18611	    {Py_XINCREF(py_V293);}
18612	    
18613	            V293 = NULL;
18614	            if (py_V293 == Py_None) {
18615	                // We can either fail here or set V293 to NULL and rely on Ops
18616	                // using tensors to handle the NULL case, but if they fail to do so
18617	                // they'll end up with nasty segfaults, so this is public service.
18618	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
18619	                {
18620	        __failure = 294;
18621	        if (!PyErr_Occurred()) {
18622	            PyErr_SetString(PyExc_RuntimeError,
18623	                "Unexpected error in an Op's C code. "
18624	                "No Python exception was set.");
18625	            }
18626	        goto __label_294;}
18627	            }
18628	            if (!PyArray_Check(py_V293)) {
18629	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
18630	                {
18631	        __failure = 294;
18632	        if (!PyErr_Occurred()) {
18633	            PyErr_SetString(PyExc_RuntimeError,
18634	                "Unexpected error in an Op's C code. "
18635	                "No Python exception was set.");
18636	            }
18637	        goto __label_294;}
18638	            }
18639	            // We expect NPY_FLOAT64
18640	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V293)) {
18641	                PyArrayObject * tmp = (PyArrayObject*) py_V293;
18642	                PyErr_Format(PyExc_NotImplementedError,
18643	                             "expected an aligned array of type %ld "
18644	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
18645	                             " with %ld dimensions, with 3 last dims "
18646	                             "%ld, %ld, %ld"
18647	                             " and 3 last strides %ld %ld, %ld.",
18648	                             (long int) NPY_FLOAT64,
18649	                             (long int) PyArray_TYPE((PyArrayObject*) py_V293),
18650	                             (long int) PyArray_NDIM(tmp),
18651	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
18652	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1),
18653	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
18654	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1),
18655	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
18656	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1),
18657	                             (long int) (PyArray_NDIM(tmp) >= 3 ?
18658	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1),
18659	                             (long int) (PyArray_NDIM(tmp) >= 2 ?
18660	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1),
18661	                             (long int) (PyArray_NDIM(tmp) >= 1 ?
18662	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1)
18663	            );
18664	                {
18665	        __failure = 294;
18666	        if (!PyErr_Occurred()) {
18667	            PyErr_SetString(PyExc_RuntimeError,
18668	                "Unexpected error in an Op's C code. "
18669	                "No Python exception was set.");
18670	            }
18671	        goto __label_294;}
18672	            }
18673	            // This is a TypeError to be consistent with DEBUG_MODE
18674	            // Note: DEBUG_MODE also tells the name of the container
18675	            if (PyArray_TYPE((PyArrayObject*) py_V293) != NPY_FLOAT64) {
18676	                PyErr_Format(PyExc_TypeError,
18677