## 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

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]:
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
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]:
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]:

## 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

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]:

## 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

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