Clustering is a class of unsupervised learning methods that associates observations according to some specified measure of similarity (e.g. Euclidean distance).
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.
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:
the covariance matrix is spherical:
$$\Sigma_k = \sigma I_D$$
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)$
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.
%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)
<matplotlib.collections.PathCollection at 0x10f917080>
Let's start with $k=4$, arbitrarily assigned:
centroids = (3, 3), (3, 7), (7, 3), (7, 7)
np.transpose(centroids)
array([[3, 3, 7, 7], [3, 7, 3, 7]])
plt.scatter(x, y)
plt.scatter(*np.transpose(centroids), c='r', marker='+', s=100)
<matplotlib.collections.PathCollection at 0x10fb9a898>
We can use the function cdist
from SciPy to calculate the distances from each point to each centroid.
from scipy.spatial.distance import cdist
distances = cdist(centroids, list(zip(x,y)))
distances.shape
(4, 25)
We can make the initial assignment to centroids by picking the minimum distance.
labels = distances.argmin(axis=0)
labels
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])
plt.scatter(x, y, c=np.array(list('rgbc'))[labels])
plt.scatter(*np.transpose(centroids), c='r', marker='+', s=100)
<matplotlib.collections.PathCollection at 0x104a01be0>
Now we can re-assign the centroid locations based on the means of the current members' locations.
new_centroids = [(x[labels==i].mean(), y[labels==i].mean())
for i in range(len(centroids))]
plt.scatter(x, y, c=np.array(list('rgbc'))[labels])
plt.scatter(*np.transpose(new_centroids), c='r', marker='+', s=100)
<matplotlib.collections.PathCollection at 0x10ff44f28>
So, we simply iterate these steps until convergence.
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))]
plt.scatter(x, y, c=np.array(list('rgbc'))[labels])
plt.scatter(*np.transpose(centroids), c='r', marker='+', s=100)
<matplotlib.collections.PathCollection at 0x10ffb6438>
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.
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)))
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.
kmeans.labels_
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)
kmeans.cluster_centers_
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.
plt.scatter(x, y, c=np.array(list('rgbc'))[kmeans.labels_])
plt.scatter(*kmeans.cluster_centers_.T, c='r', marker='+', s=100)
<matplotlib.collections.PathCollection at 0x1115cb438>
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.
import pandas as pd
microbiome = pd.read_csv("../data/microbiome.csv")
First, we need to transpose the data so that it can be used with scikit-learn
's interface. Fortunately, Pandas makes this relatively painless. The data are stored in long format:
microbiome.head()
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.
microbiome_pivoted.pivot?
Object `microbiome_pivoted.pivot` not found.
microbiome_pivoted = microbiome.drop('Group', axis=1).pivot(index='Patient',
columns='Taxon').stack(level=0).reset_index()
microbiome_pivoted.columns.name = None
microbiome_pivoted.head()
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
.
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:]
microbiome_data.head()
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.
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()
plot_2D(X_pca, y, ['Tissue', 'Stool'], pca)
We can now create a KMeans
object with k=2
, and fit the data with it.
km_microbiome = KMeans(n_clusters=2, random_state=rng)
km_microbiome.fit(X_pca)
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.
np.round(km_microbiome.cluster_centers_, decimals=2)
array([[ 0.34, -0.38], [-1.01, 1.14]])
km_microbiome.labels_
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)
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).
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.
## Write answer here
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:
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.
import pandas as pd
baseball = pd.read_csv("../data/baseball.csv", index_col=0)
baseball.head()
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
## Write answer here
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}$$from sklearn.decomposition import PCA
from sklearn import datasets
iris = datasets.load_iris()
pca = PCA(n_components=2, whiten=True).fit(iris.data)
X_pca = pca.transform(iris.data)
X_pca.shape
(150, 2)
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.
with dp_mixture:
step1 = pm.Metropolis(vars=[α, β, σ, μ])
step2 = pm.CategoricalGibbsMetropolis(vars=[component])
trace = pm.sample(10000, step=[step1, step2])
===============================
00001 #include <Python.h> 00002 #include <iostream> 00003 #include "theano_mod_helper.h" 00004 #include <math.h> 00005 #include <numpy/arrayobject.h> 00006 #include <numpy/arrayscalars.h> 00007 #include <vector> 00008 #include <algorithm> 00009 ////////////////////// 00010 //// Support Code 00011 ////////////////////// 00012 00013 00014 namespace { 00015 struct __struct_compiled_op_m17e0841797488fe86115b4f81aba8732 { 00016 PyObject* __ERROR; 00017 00018 PyObject* storage_V3; 00019 PyObject* storage_V5; 00020 PyObject* storage_V7; 00021 PyObject* storage_V9; 00022 PyObject* storage_V11; 00023 PyObject* storage_V13; 00024 PyObject* storage_V15; 00025 PyObject* storage_V17; 00026 PyObject* storage_V19; 00027 PyObject* storage_V21; 00028 PyObject* storage_V23; 00029 PyObject* storage_V25; 00030 PyObject* storage_V27; 00031 PyObject* storage_V29; 00032 PyObject* storage_V31; 00033 PyObject* storage_V33; 00034 PyObject* storage_V35; 00035 PyObject* storage_V37; 00036 PyObject* storage_V39; 00037 PyObject* storage_V41; 00038 PyObject* storage_V43; 00039 PyObject* storage_V45; 00040 PyObject* storage_V47; 00041 PyObject* storage_V49; 00042 PyObject* storage_V51; 00043 PyObject* storage_V53; 00044 PyObject* storage_V55; 00045 PyObject* storage_V57; 00046 PyObject* storage_V59; 00047 PyObject* storage_V61; 00048 PyObject* storage_V63; 00049 PyObject* storage_V65; 00050 PyObject* storage_V67; 00051 PyObject* storage_V69; 00052 PyObject* storage_V71; 00053 PyObject* storage_V73; 00054 PyObject* storage_V75; 00055 PyObject* storage_V77; 00056 PyObject* storage_V79; 00057 PyObject* storage_V81; 00058 PyObject* storage_V83; 00059 PyObject* storage_V85; 00060 PyObject* storage_V87; 00061 PyObject* storage_V89; 00062 PyObject* storage_V91; 00063 PyObject* storage_V93; 00064 PyObject* storage_V95; 00065 PyObject* storage_V97; 00066 PyObject* storage_V99; 00067 PyObject* storage_V101; 00068 PyObject* storage_V103; 00069 PyObject* storage_V105; 00070 PyObject* storage_V107; 00071 PyObject* storage_V109; 00072 PyObject* storage_V111; 00073 PyObject* storage_V113; 00074 PyObject* storage_V115; 00075 PyObject* storage_V117; 00076 PyObject* storage_V119; 00077 PyObject* storage_V121; 00078 PyObject* storage_V123; 00079 PyObject* storage_V125; 00080 PyObject* storage_V127; 00081 PyObject* storage_V129; 00082 PyObject* storage_V131; 00083 PyObject* storage_V133; 00084 PyObject* storage_V135; 00085 PyObject* storage_V137; 00086 PyObject* storage_V139; 00087 PyObject* storage_V141; 00088 PyObject* storage_V143; 00089 PyObject* storage_V145; 00090 PyObject* storage_V147; 00091 PyObject* storage_V149; 00092 PyObject* storage_V151; 00093 PyObject* storage_V153; 00094 PyObject* storage_V155; 00095 PyObject* storage_V157; 00096 PyObject* storage_V159; 00097 PyObject* storage_V161; 00098 PyObject* storage_V163; 00099 PyObject* storage_V165; 00100 PyObject* storage_V167; 00101 PyObject* storage_V169; 00102 PyObject* storage_V171; 00103 PyObject* storage_V173; 00104 PyObject* storage_V175; 00105 PyObject* storage_V177; 00106 PyObject* storage_V179; 00107 PyObject* storage_V181; 00108 PyObject* storage_V183; 00109 PyObject* storage_V185; 00110 PyObject* storage_V187; 00111 PyObject* storage_V189; 00112 PyObject* storage_V191; 00113 PyObject* storage_V193; 00114 PyObject* storage_V195; 00115 PyObject* storage_V197; 00116 PyObject* storage_V199; 00117 PyObject* storage_V201; 00118 PyObject* storage_V203; 00119 PyObject* storage_V205; 00120 PyObject* storage_V207; 00121 PyObject* storage_V209; 00122 PyObject* storage_V211; 00123 PyObject* storage_V213; 00124 PyObject* storage_V215; 00125 PyObject* storage_V217; 00126 PyObject* storage_V219; 00127 PyObject* storage_V221; 00128 PyObject* storage_V223; 00129 PyObject* storage_V225; 00130 PyObject* storage_V227; 00131 PyObject* storage_V229; 00132 PyObject* storage_V231; 00133 PyObject* storage_V233; 00134 PyObject* storage_V235; 00135 PyObject* storage_V237; 00136 PyObject* storage_V239; 00137 PyObject* storage_V241; 00138 PyObject* storage_V243; 00139 PyObject* storage_V245; 00140 PyObject* storage_V247; 00141 PyObject* storage_V249; 00142 PyObject* storage_V251; 00143 PyObject* storage_V253; 00144 PyObject* storage_V255; 00145 PyObject* storage_V257; 00146 PyObject* storage_V259; 00147 PyObject* storage_V261; 00148 PyObject* storage_V263; 00149 PyObject* storage_V265; 00150 PyObject* storage_V267; 00151 PyObject* storage_V269; 00152 PyObject* storage_V271; 00153 PyObject* storage_V273; 00154 PyObject* storage_V275; 00155 PyObject* storage_V277; 00156 PyObject* storage_V279; 00157 PyObject* storage_V281; 00158 PyObject* storage_V283; 00159 PyObject* storage_V285; 00160 PyObject* storage_V287; 00161 PyObject* storage_V289; 00162 PyObject* storage_V291; 00163 PyObject* storage_V293; 00164 PyObject* storage_V295; 00165 PyObject* storage_V297; 00166 PyObject* storage_V299; 00167 PyObject* storage_V301; 00168 PyObject* storage_V303; 00169 PyObject* storage_V305; 00170 PyObject* storage_V307; 00171 PyObject* storage_V309; 00172 PyObject* storage_V311; 00173 PyObject* storage_V313; 00174 PyObject* storage_V315; 00175 PyObject* storage_V317; 00176 PyObject* storage_V319; 00177 PyObject* storage_V321; 00178 PyObject* storage_V323; 00179 PyObject* storage_V325; 00180 PyObject* storage_V327; 00181 PyObject* storage_V329; 00182 PyObject* storage_V331; 00183 PyObject* storage_V333; 00184 PyObject* storage_V335; 00185 PyObject* storage_V337; 00186 PyObject* storage_V339; 00187 PyObject* storage_V341; 00188 PyObject* storage_V343; 00189 PyObject* storage_V345; 00190 PyObject* storage_V347; 00191 PyObject* storage_V349; 00192 PyObject* storage_V351; 00193 PyObject* storage_V353; 00194 PyObject* storage_V355; 00195 PyObject* storage_V357; 00196 PyObject* storage_V359; 00197 PyObject* storage_V361; 00198 PyObject* storage_V363; 00199 PyObject* storage_V365; 00200 PyObject* storage_V367; 00201 PyObject* storage_V369; 00202 PyObject* storage_V371; 00203 PyObject* storage_V373; 00204 PyObject* storage_V375; 00205 PyObject* storage_V377; 00206 PyObject* storage_V379; 00207 PyObject* storage_V381; 00208 PyObject* storage_V383; 00209 PyObject* storage_V385; 00210 PyObject* storage_V387; 00211 PyObject* storage_V389; 00212 PyObject* storage_V391; 00213 PyObject* storage_V393; 00214 PyObject* storage_V395; 00215 PyObject* storage_V397; 00216 PyObject* storage_V399; 00217 PyObject* storage_V401; 00218 PyObject* storage_V403; 00219 PyObject* storage_V405; 00220 PyObject* storage_V407; 00221 PyObject* storage_V409; 00222 PyObject* storage_V411; 00223 PyObject* storage_V413; 00224 PyObject* storage_V415; 00225 PyObject* storage_V417; 00226 PyObject* storage_V419; 00227 PyObject* storage_V421; 00228 PyObject* storage_V423; 00229 PyObject* storage_V425; 00230 PyObject* storage_V427; 00231 PyObject* storage_V429; 00232 PyObject* storage_V431; 00233 PyObject* storage_V433; 00234 PyObject* storage_V435; 00235 PyObject* storage_V437; 00236 PyObject* storage_V439; 00237 PyObject* storage_V441; 00238 PyObject* storage_V443; 00239 PyObject* storage_V445; 00240 PyObject* storage_V447; 00241 PyObject* storage_V449; 00242 PyObject* storage_V451; 00243 PyObject* storage_V453; 00244 PyObject* storage_V455; 00245 PyObject* storage_V457; 00246 PyObject* storage_V459; 00247 PyObject* storage_V461; 00248 PyObject* storage_V463; 00249 PyObject* storage_V465; 00250 PyObject* storage_V467; 00251 PyObject* storage_V469; 00252 PyObject* storage_V471; 00253 PyObject* storage_V473; 00254 PyObject* storage_V475; 00255 PyObject* storage_V477; 00256 PyObject* storage_V479; 00257 PyObject* storage_V481; 00258 PyObject* storage_V483; 00259 PyObject* storage_V485; 00260 PyObject* storage_V487; 00261 PyObject* storage_V489; 00262 PyObject* storage_V491; 00263 PyObject* storage_V493; 00264 PyObject* storage_V495; 00265 PyObject* storage_V497; 00266 PyObject* storage_V499; 00267 PyObject* storage_V501; 00268 PyObject* storage_V503; 00269 PyObject* storage_V505; 00270 PyObject* storage_V507; 00271 PyObject* storage_V509; 00272 PyObject* storage_V511; 00273 PyObject* storage_V513; 00274 PyObject* storage_V515; 00275 PyObject* storage_V517; 00276 PyObject* storage_V519; 00277 PyObject* storage_V521; 00278 PyObject* storage_V523; 00279 PyObject* storage_V525; 00280 PyObject* storage_V527; 00281 PyObject* storage_V529; 00282 PyObject* storage_V531; 00283 PyObject* storage_V533; 00284 PyObject* storage_V535; 00285 PyObject* storage_V537; 00286 PyObject* storage_V539; 00287 PyObject* storage_V541; 00288 PyObject* storage_V543; 00289 PyObject* storage_V545; 00290 PyObject* storage_V547; 00291 PyObject* storage_V549; 00292 PyObject* storage_V551; 00293 PyObject* storage_V553; 00294 PyObject* storage_V555; 00295 PyObject* storage_V557; 00296 PyObject* storage_V559; 00297 PyObject* storage_V561; 00298 PyObject* storage_V563; 00299 PyObject* storage_V565; 00300 PyObject* storage_V567; 00301 PyObject* storage_V569; 00302 PyObject* storage_V571; 00303 PyObject* storage_V573; 00304 PyObject* storage_V575; 00305 PyObject* storage_V577; 00306 PyObject* storage_V579; 00307 PyObject* storage_V581; 00308 PyObject* storage_V583; 00309 PyObject* storage_V585; 00310 PyObject* storage_V587; 00311 PyObject* storage_V589; 00312 PyObject* storage_V591; 00313 PyObject* storage_V593; 00314 PyObject* storage_V595; 00315 PyObject* storage_V597; 00316 PyObject* storage_V599; 00317 PyObject* storage_V601; 00318 PyObject* storage_V603; 00319 PyObject* storage_V605; 00320 PyObject* storage_V607; 00321 PyObject* storage_V609; 00322 PyObject* storage_V611; 00323 PyObject* storage_V613; 00324 PyObject* storage_V615; 00325 PyObject* storage_V617; 00326 PyObject* storage_V619; 00327 PyObject* storage_V621; 00328 PyObject* storage_V623; 00329 PyObject* storage_V625; 00330 PyObject* storage_V627; 00331 PyObject* storage_V629; 00332 PyObject* storage_V631; 00333 PyObject* storage_V633; 00334 PyObject* storage_V635; 00335 PyObject* storage_V637; 00336 PyObject* storage_V639; 00337 PyObject* storage_V641; 00338 PyObject* storage_V643; 00339 PyObject* storage_V645; 00340 PyObject* storage_V647; 00341 PyObject* storage_V649; 00342 PyObject* storage_V651; 00343 PyObject* storage_V653; 00344 PyObject* storage_V655; 00345 PyObject* storage_V657; 00346 PyObject* storage_V659; 00347 PyObject* storage_V661; 00348 PyObject* storage_V663; 00349 PyObject* storage_V665; 00350 PyObject* storage_V667; 00351 PyObject* storage_V669; 00352 PyObject* storage_V671; 00353 PyObject* storage_V673; 00354 PyObject* storage_V675; 00355 PyObject* storage_V677; 00356 PyObject* storage_V679; 00357 PyObject* storage_V681; 00358 PyObject* storage_V683; 00359 PyObject* storage_V685; 00360 PyObject* storage_V687; 00361 PyObject* storage_V689; 00362 PyObject* storage_V691; 00363 PyObject* storage_V693; 00364 PyObject* storage_V695; 00365 PyObject* storage_V697; 00366 PyObject* storage_V699; 00367 PyObject* storage_V701; 00368 PyObject* storage_V703; 00369 PyObject* storage_V705; 00370 PyObject* storage_V707; 00371 PyObject* storage_V709; 00372 PyObject* storage_V711; 00373 PyObject* storage_V713; 00374 PyObject* storage_V715; 00375 PyObject* storage_V717; 00376 PyObject* storage_V719; 00377 PyObject* storage_V721; 00378 PyObject* storage_V723; 00379 PyObject* storage_V725; 00380 PyObject* storage_V727; 00381 PyObject* storage_V729; 00382 PyObject* storage_V731; 00383 PyObject* storage_V733; 00384 PyObject* storage_V735; 00385 PyObject* storage_V737; 00386 PyObject* storage_V739; 00387 PyObject* storage_V741; 00388 PyObject* storage_V743; 00389 PyObject* storage_V745; 00390 PyObject* storage_V747; 00391 PyObject* storage_V749; 00392 PyObject* storage_V751; 00393 PyObject* storage_V753; 00394 PyObject* storage_V755; 00395 PyObject* storage_V757; 00396 PyObject* storage_V759; 00397 PyObject* storage_V761; 00398 PyObject* storage_V763; 00399 PyObject* storage_V765; 00400 PyObject* storage_V767; 00401 PyObject* storage_V769; 00402 PyObject* storage_V771; 00403 PyObject* storage_V773; 00404 PyObject* storage_V775; 00405 PyObject* storage_V777; 00406 PyObject* storage_V779; 00407 PyObject* storage_V781; 00408 PyObject* storage_V783; 00409 PyObject* storage_V785; 00410 PyObject* storage_V787; 00411 PyObject* storage_V789; 00412 PyObject* storage_V791; 00413 PyObject* storage_V793; 00414 PyObject* storage_V795; 00415 PyObject* storage_V797; 00416 PyObject* storage_V799; 00417 PyObject* storage_V801; 00418 PyObject* storage_V803; 00419 PyObject* storage_V805; 00420 PyObject* storage_V807; 00421 PyObject* storage_V809; 00422 PyObject* storage_V811; 00423 PyObject* storage_V813; 00424 PyObject* storage_V815; 00425 PyObject* storage_V817; 00426 PyObject* storage_V819; 00427 PyObject* storage_V821; 00428 PyObject* storage_V823; 00429 PyObject* storage_V825; 00430 PyObject* storage_V827; 00431 PyObject* storage_V829; 00432 PyObject* storage_V831; 00433 PyObject* storage_V833; 00434 PyObject* storage_V835; 00435 PyObject* storage_V837; 00436 PyObject* storage_V839; 00437 PyObject* storage_V841; 00438 PyObject* storage_V843; 00439 PyObject* storage_V845; 00440 PyObject* storage_V847; 00441 PyObject* storage_V849; 00442 PyObject* storage_V851; 00443 PyObject* storage_V853; 00444 PyObject* storage_V855; 00445 PyObject* storage_V857; 00446 PyObject* storage_V859; 00447 PyObject* storage_V861; 00448 PyObject* storage_V863; 00449 PyObject* storage_V865; 00450 PyObject* storage_V867; 00451 PyObject* storage_V869; 00452 PyObject* storage_V871; 00453 PyObject* storage_V873; 00454 PyObject* storage_V875; 00455 PyObject* storage_V877; 00456 PyObject* storage_V879; 00457 PyObject* storage_V881; 00458 PyObject* storage_V883; 00459 PyObject* storage_V885; 00460 PyObject* storage_V887; 00461 PyObject* storage_V889; 00462 PyObject* storage_V891; 00463 PyObject* storage_V893; 00464 PyObject* storage_V895; 00465 PyObject* storage_V897; 00466 PyObject* storage_V899; 00467 PyObject* storage_V901; 00468 PyObject* storage_V903; 00469 PyObject* storage_V905; 00470 PyObject* storage_V907; 00471 PyObject* storage_V909; 00472 PyObject* storage_V1; 00473 00474 00475 __struct_compiled_op_m17e0841797488fe86115b4f81aba8732() { 00476 // This is only somewhat safe because we: 00477 // 1) Are not a virtual class 00478 // 2) Do not use any virtual classes in the members 00479 // 3) Deal with mostly POD and pointers 00480 00481 // If this changes, we would have to revise this, but for 00482 // now I am tired of chasing segfaults because 00483 // initialization code had an error and some pointer has 00484 // a junk value. 00485 memset(this, 0, sizeof(*this)); 00486 } 00487 ~__struct_compiled_op_m17e0841797488fe86115b4f81aba8732(void) { 00488 cleanup(); 00489 } 00490 00491 int init(PyObject* __ERROR, PyObject* storage_V3, PyObject* storage_V5, PyObject* storage_V7, PyObject* storage_V9, PyObject* storage_V11, PyObject* storage_V13, PyObject* storage_V15, PyObject* storage_V17, PyObject* storage_V19, PyObject* storage_V21, PyObject* storage_V23, PyObject* storage_V25, PyObject* storage_V27, PyObject* storage_V29, PyObject* storage_V31, PyObject* storage_V33, PyObject* storage_V35, PyObject* storage_V37, PyObject* storage_V39, PyObject* storage_V41, PyObject* storage_V43, PyObject* storage_V45, PyObject* storage_V47, PyObject* storage_V49, PyObject* storage_V51, PyObject* storage_V53, PyObject* storage_V55, PyObject* storage_V57, PyObject* storage_V59, PyObject* storage_V61, PyObject* storage_V63, PyObject* storage_V65, PyObject* storage_V67, PyObject* storage_V69, PyObject* storage_V71, PyObject* storage_V73, PyObject* storage_V75, PyObject* storage_V77, PyObject* storage_V79, PyObject* storage_V81, PyObject* storage_V83, PyObject* storage_V85, PyObject* storage_V87, PyObject* storage_V89, PyObject* storage_V91, PyObject* storage_V93, PyObject* storage_V95, PyObject* storage_V97, PyObject* storage_V99, PyObject* storage_V101, PyObject* storage_V103, PyObject* storage_V105, PyObject* storage_V107, PyObject* storage_V109, PyObject* storage_V111, PyObject* storage_V113, PyObject* storage_V115, PyObject* storage_V117, PyObject* storage_V119, PyObject* storage_V121, PyObject* storage_V123, PyObject* storage_V125, PyObject* storage_V127, PyObject* storage_V129, PyObject* storage_V131, PyObject* storage_V133, PyObject* storage_V135, PyObject* storage_V137, PyObject* storage_V139, PyObject* storage_V141, PyObject* storage_V143, PyObject* storage_V145, PyObject* storage_V147, PyObject* storage_V149, PyObject* storage_V151, PyObject* storage_V153, PyObject* storage_V155, PyObject* storage_V157, PyObject* storage_V159, PyObject* storage_V161, PyObject* storage_V163, PyObject* storage_V165, PyObject* storage_V167, PyObject* storage_V169, PyObject* storage_V171, PyObject* storage_V173, PyObject* storage_V175, PyObject* storage_V177, PyObject* storage_V179, PyObject* storage_V181, PyObject* storage_V183, PyObject* storage_V185, PyObject* storage_V187, PyObject* storage_V189, PyObject* storage_V191, PyObject* storage_V193, PyObject* storage_V195, PyObject* storage_V197, PyObject* storage_V199, PyObject* storage_V201, PyObject* storage_V203, PyObject* storage_V205, PyObject* storage_V207, PyObject* storage_V209, PyObject* storage_V211, PyObject* storage_V213, PyObject* storage_V215, PyObject* storage_V217, PyObject* storage_V219, PyObject* storage_V221, PyObject* storage_V223, PyObject* storage_V225, PyObject* storage_V227, PyObject* storage_V229, PyObject* storage_V231, PyObject* storage_V233, PyObject* storage_V235, PyObject* storage_V237, PyObject* storage_V239, PyObject* storage_V241, PyObject* storage_V243, PyObject* storage_V245, PyObject* storage_V247, PyObject* storage_V249, PyObject* storage_V251, PyObject* storage_V253, PyObject* storage_V255, PyObject* storage_V257, PyObject* storage_V259, PyObject* storage_V261, PyObject* storage_V263, PyObject* storage_V265, PyObject* storage_V267, PyObject* storage_V269, PyObject* storage_V271, PyObject* storage_V273, PyObject* storage_V275, PyObject* storage_V277, PyObject* storage_V279, PyObject* storage_V281, PyObject* storage_V283, PyObject* storage_V285, PyObject* storage_V287, PyObject* storage_V289, PyObject* storage_V291, PyObject* storage_V293, PyObject* storage_V295, PyObject* storage_V297, PyObject* storage_V299, PyObject* storage_V301, PyObject* storage_V303, PyObject* storage_V305, PyObject* storage_V307, PyObject* storage_V309, PyObject* storage_V311, PyObject* storage_V313, PyObject* storage_V315, PyObject* storage_V317, PyObject* storage_V319, PyObject* storage_V321, PyObject* storage_V323, PyObject* storage_V325, PyObject* storage_V327, PyObject* storage_V329, PyObject* storage_V331, PyObject* storage_V333, PyObject* storage_V335, PyObject* storage_V337, PyObject* storage_V339, PyObject* storage_V341, PyObject* storage_V343, PyObject* storage_V345, PyObject* storage_V347, PyObject* storage_V349, PyObject* storage_V351, PyObject* storage_V353, PyObject* storage_V355, PyObject* storage_V357, PyObject* storage_V359, PyObject* storage_V361, PyObject* storage_V363, PyObject* storage_V365, PyObject* storage_V367, PyObject* storage_V369, PyObject* storage_V371, PyObject* storage_V373, PyObject* storage_V375, PyObject* storage_V377, PyObject* storage_V379, PyObject* storage_V381, PyObject* storage_V383, PyObject* storage_V385, PyObject* storage_V387, PyObject* storage_V389, PyObject* storage_V391, PyObject* storage_V393, PyObject* storage_V395, PyObject* storage_V397, PyObject* storage_V399, PyObject* storage_V401, PyObject* storage_V403, PyObject* storage_V405, PyObject* storage_V407, PyObject* storage_V409, PyObject* storage_V411, PyObject* storage_V413, PyObject* storage_V415, PyObject* storage_V417, PyObject* storage_V419, PyObject* storage_V421, PyObject* storage_V423, PyObject* storage_V425, PyObject* storage_V427, PyObject* storage_V429, PyObject* storage_V431, PyObject* storage_V433, PyObject* storage_V435, PyObject* storage_V437, PyObject* storage_V439, PyObject* storage_V441, PyObject* storage_V443, PyObject* storage_V445, PyObject* storage_V447, PyObject* storage_V449, PyObject* storage_V451, PyObject* storage_V453, PyObject* storage_V455, PyObject* storage_V457, PyObject* storage_V459, PyObject* storage_V461, PyObject* storage_V463, PyObject* storage_V465, PyObject* storage_V467, PyObject* storage_V469, PyObject* storage_V471, PyObject* storage_V473, PyObject* storage_V475, PyObject* storage_V477, PyObject* storage_V479, PyObject* storage_V481, PyObject* storage_V483, PyObject* storage_V485, PyObject* storage_V487, PyObject* storage_V489, PyObject* storage_V491, PyObject* storage_V493, PyObject* storage_V495, PyObject* storage_V497, PyObject* storage_V499, PyObject* storage_V501, PyObject* storage_V503, PyObject* storage_V505, PyObject* storage_V507, PyObject* storage_V509, PyObject* storage_V511, PyObject* storage_V513, PyObject* storage_V515, PyObject* storage_V517, PyObject* storage_V519, PyObject* storage_V521, PyObject* storage_V523, PyObject* storage_V525, PyObject* storage_V527, PyObject* storage_V529, PyObject* storage_V531, PyObject* storage_V533, PyObject* storage_V535, PyObject* storage_V537, PyObject* storage_V539, PyObject* storage_V541, PyObject* storage_V543, PyObject* storage_V545, PyObject* storage_V547, PyObject* storage_V549, PyObject* storage_V551, PyObject* storage_V553, PyObject* storage_V555, PyObject* storage_V557, PyObject* storage_V559, PyObject* storage_V561, PyObject* storage_V563, PyObject* storage_V565, PyObject* storage_V567, PyObject* storage_V569, PyObject* storage_V571, PyObject* storage_V573, PyObject* storage_V575, PyObject* storage_V577, PyObject* storage_V579, PyObject* storage_V581, PyObject* storage_V583, PyObject* storage_V585, PyObject* storage_V587, PyObject* storage_V589, PyObject* storage_V591, PyObject* storage_V593, PyObject* storage_V595, PyObject* storage_V597, PyObject* storage_V599, PyObject* storage_V601, PyObject* storage_V603, PyObject* storage_V605, PyObject* storage_V607, PyObject* storage_V609, PyObject* storage_V611, PyObject* storage_V613, PyObject* storage_V615, PyObject* storage_V617, PyObject* storage_V619, PyObject* storage_V621, PyObject* storage_V623, PyObject* storage_V625, PyObject* storage_V627, PyObject* storage_V629, PyObject* storage_V631, PyObject* storage_V633, PyObject* storage_V635, PyObject* storage_V637, PyObject* storage_V639, PyObject* storage_V641, PyObject* storage_V643, PyObject* storage_V645, PyObject* storage_V647, PyObject* storage_V649, PyObject* storage_V651, PyObject* storage_V653, PyObject* storage_V655, PyObject* storage_V657, PyObject* storage_V659, PyObject* storage_V661, PyObject* storage_V663, PyObject* storage_V665, PyObject* storage_V667, PyObject* storage_V669, PyObject* storage_V671, PyObject* storage_V673, PyObject* storage_V675, PyObject* storage_V677, PyObject* storage_V679, PyObject* storage_V681, PyObject* storage_V683, PyObject* storage_V685, PyObject* storage_V687, PyObject* storage_V689, PyObject* storage_V691, PyObject* storage_V693, PyObject* storage_V695, PyObject* storage_V697, PyObject* storage_V699, PyObject* storage_V701, PyObject* storage_V703, PyObject* storage_V705, PyObject* storage_V707, PyObject* storage_V709, PyObject* storage_V711, PyObject* storage_V713, PyObject* storage_V715, PyObject* storage_V717, PyObject* storage_V719, PyObject* storage_V721, PyObject* storage_V723, PyObject* storage_V725, PyObject* storage_V727, PyObject* storage_V729, PyObject* storage_V731, PyObject* storage_V733, PyObject* storage_V735, PyObject* storage_V737, PyObject* storage_V739, PyObject* storage_V741, PyObject* storage_V743, PyObject* storage_V745, PyObject* storage_V747, PyObject* storage_V749, PyObject* storage_V751, PyObject* storage_V753, PyObject* storage_V755, PyObject* storage_V757, PyObject* storage_V759, PyObject* storage_V761, PyObject* storage_V763, PyObject* storage_V765, PyObject* storage_V767, PyObject* storage_V769, PyObject* storage_V771, PyObject* storage_V773, PyObject* storage_V775, PyObject* storage_V777, PyObject* storage_V779, PyObject* storage_V781, PyObject* storage_V783, PyObject* storage_V785, PyObject* storage_V787, PyObject* storage_V789, PyObject* storage_V791, PyObject* storage_V793, PyObject* storage_V795, PyObject* storage_V797, PyObject* storage_V799, PyObject* storage_V801, PyObject* storage_V803, PyObject* storage_V805, PyObject* storage_V807, PyObject* storage_V809, PyObject* storage_V811, PyObject* storage_V813, PyObject* storage_V815, PyObject* storage_V817, PyObject* storage_V819, PyObject* storage_V821, PyObject* storage_V823, PyObject* storage_V825, PyObject* storage_V827, PyObject* storage_V829, PyObject* storage_V831, PyObject* storage_V833, PyObject* storage_V835, PyObject* storage_V837, PyObject* storage_V839, PyObject* storage_V841, PyObject* storage_V843, PyObject* storage_V845, PyObject* storage_V847, PyObject* storage_V849, PyObject* storage_V851, PyObject* storage_V853, PyObject* storage_V855, PyObject* storage_V857, PyObject* storage_V859, PyObject* storage_V861, PyObject* storage_V863, PyObject* storage_V865, PyObject* storage_V867, PyObject* storage_V869, PyObject* storage_V871, PyObject* storage_V873, PyObject* storage_V875, PyObject* storage_V877, PyObject* storage_V879, PyObject* storage_V881, PyObject* storage_V883, PyObject* storage_V885, PyObject* storage_V887, PyObject* storage_V889, PyObject* storage_V891, PyObject* storage_V893, PyObject* storage_V895, PyObject* storage_V897, PyObject* storage_V899, PyObject* storage_V901, PyObject* storage_V903, PyObject* storage_V905, PyObject* storage_V907, PyObject* storage_V909, PyObject* storage_V1) { 00492 Py_XINCREF(storage_V3); 00493 Py_XINCREF(storage_V5); 00494 Py_XINCREF(storage_V7); 00495 Py_XINCREF(storage_V9); 00496 Py_XINCREF(storage_V11); 00497 Py_XINCREF(storage_V13); 00498 Py_XINCREF(storage_V15); 00499 Py_XINCREF(storage_V17); 00500 Py_XINCREF(storage_V19); 00501 Py_XINCREF(storage_V21); 00502 Py_XINCREF(storage_V23); 00503 Py_XINCREF(storage_V25); 00504 Py_XINCREF(storage_V27); 00505 Py_XINCREF(storage_V29); 00506 Py_XINCREF(storage_V31); 00507 Py_XINCREF(storage_V33); 00508 Py_XINCREF(storage_V35); 00509 Py_XINCREF(storage_V37); 00510 Py_XINCREF(storage_V39); 00511 Py_XINCREF(storage_V41); 00512 Py_XINCREF(storage_V43); 00513 Py_XINCREF(storage_V45); 00514 Py_XINCREF(storage_V47); 00515 Py_XINCREF(storage_V49); 00516 Py_XINCREF(storage_V51); 00517 Py_XINCREF(storage_V53); 00518 Py_XINCREF(storage_V55); 00519 Py_XINCREF(storage_V57); 00520 Py_XINCREF(storage_V59); 00521 Py_XINCREF(storage_V61); 00522 Py_XINCREF(storage_V63); 00523 Py_XINCREF(storage_V65); 00524 Py_XINCREF(storage_V67); 00525 Py_XINCREF(storage_V69); 00526 Py_XINCREF(storage_V71); 00527 Py_XINCREF(storage_V73); 00528 Py_XINCREF(storage_V75); 00529 Py_XINCREF(storage_V77); 00530 Py_XINCREF(storage_V79); 00531 Py_XINCREF(storage_V81); 00532 Py_XINCREF(storage_V83); 00533 Py_XINCREF(storage_V85); 00534 Py_XINCREF(storage_V87); 00535 Py_XINCREF(storage_V89); 00536 Py_XINCREF(storage_V91); 00537 Py_XINCREF(storage_V93); 00538 Py_XINCREF(storage_V95); 00539 Py_XINCREF(storage_V97); 00540 Py_XINCREF(storage_V99); 00541 Py_XINCREF(storage_V101); 00542 Py_XINCREF(storage_V103); 00543 Py_XINCREF(storage_V105); 00544 Py_XINCREF(storage_V107); 00545 Py_XINCREF(storage_V109); 00546 Py_XINCREF(storage_V111); 00547 Py_XINCREF(storage_V113); 00548 Py_XINCREF(storage_V115); 00549 Py_XINCREF(storage_V117); 00550 Py_XINCREF(storage_V119); 00551 Py_XINCREF(storage_V121); 00552 Py_XINCREF(storage_V123); 00553 Py_XINCREF(storage_V125); 00554 Py_XINCREF(storage_V127); 00555 Py_XINCREF(storage_V129); 00556 Py_XINCREF(storage_V131); 00557 Py_XINCREF(storage_V133); 00558 Py_XINCREF(storage_V135); 00559 Py_XINCREF(storage_V137); 00560 Py_XINCREF(storage_V139); 00561 Py_XINCREF(storage_V141); 00562 Py_XINCREF(storage_V143); 00563 Py_XINCREF(storage_V145); 00564 Py_XINCREF(storage_V147); 00565 Py_XINCREF(storage_V149); 00566 Py_XINCREF(storage_V151); 00567 Py_XINCREF(storage_V153); 00568 Py_XINCREF(storage_V155); 00569 Py_XINCREF(storage_V157); 00570 Py_XINCREF(storage_V159); 00571 Py_XINCREF(storage_V161); 00572 Py_XINCREF(storage_V163); 00573 Py_XINCREF(storage_V165); 00574 Py_XINCREF(storage_V167); 00575 Py_XINCREF(storage_V169); 00576 Py_XINCREF(storage_V171); 00577 Py_XINCREF(storage_V173); 00578 Py_XINCREF(storage_V175); 00579 Py_XINCREF(storage_V177); 00580 Py_XINCREF(storage_V179); 00581 Py_XINCREF(storage_V181); 00582 Py_XINCREF(storage_V183); 00583 Py_XINCREF(storage_V185); 00584 Py_XINCREF(storage_V187); 00585 Py_XINCREF(storage_V189); 00586 Py_XINCREF(storage_V191); 00587 Py_XINCREF(storage_V193); 00588 Py_XINCREF(storage_V195); 00589 Py_XINCREF(storage_V197); 00590 Py_XINCREF(storage_V199); 00591 Py_XINCREF(storage_V201); 00592 Py_XINCREF(storage_V203); 00593 Py_XINCREF(storage_V205); 00594 Py_XINCREF(storage_V207); 00595 Py_XINCREF(storage_V209); 00596 Py_XINCREF(storage_V211); 00597 Py_XINCREF(storage_V213); 00598 Py_XINCREF(storage_V215); 00599 Py_XINCREF(storage_V217); 00600 Py_XINCREF(storage_V219); 00601 Py_XINCREF(storage_V221); 00602 Py_XINCREF(storage_V223); 00603 Py_XINCREF(storage_V225); 00604 Py_XINCREF(storage_V227); 00605 Py_XINCREF(storage_V229); 00606 Py_XINCREF(storage_V231); 00607 Py_XINCREF(storage_V233); 00608 Py_XINCREF(storage_V235); 00609 Py_XINCREF(storage_V237); 00610 Py_XINCREF(storage_V239); 00611 Py_XINCREF(storage_V241); 00612 Py_XINCREF(storage_V243); 00613 Py_XINCREF(storage_V245); 00614 Py_XINCREF(storage_V247); 00615 Py_XINCREF(storage_V249); 00616 Py_XINCREF(storage_V251); 00617 Py_XINCREF(storage_V253); 00618 Py_XINCREF(storage_V255); 00619 Py_XINCREF(storage_V257); 00620 Py_XINCREF(storage_V259); 00621 Py_XINCREF(storage_V261); 00622 Py_XINCREF(storage_V263); 00623 Py_XINCREF(storage_V265); 00624 Py_XINCREF(storage_V267); 00625 Py_XINCREF(storage_V269); 00626 Py_XINCREF(storage_V271); 00627 Py_XINCREF(storage_V273); 00628 Py_XINCREF(storage_V275); 00629 Py_XINCREF(storage_V277); 00630 Py_XINCREF(storage_V279); 00631 Py_XINCREF(storage_V281); 00632 Py_XINCREF(storage_V283); 00633 Py_XINCREF(storage_V285); 00634 Py_XINCREF(storage_V287); 00635 Py_XINCREF(storage_V289); 00636 Py_XINCREF(storage_V291); 00637 Py_XINCREF(storage_V293); 00638 Py_XINCREF(storage_V295); 00639 Py_XINCREF(storage_V297); 00640 Py_XINCREF(storage_V299); 00641 Py_XINCREF(storage_V301); 00642 Py_XINCREF(storage_V303); 00643 Py_XINCREF(storage_V305); 00644 Py_XINCREF(storage_V307); 00645 Py_XINCREF(storage_V309); 00646 Py_XINCREF(storage_V311); 00647 Py_XINCREF(storage_V313); 00648 Py_XINCREF(storage_V315); 00649 Py_XINCREF(storage_V317); 00650 Py_XINCREF(storage_V319); 00651 Py_XINCREF(storage_V321); 00652 Py_XINCREF(storage_V323); 00653 Py_XINCREF(storage_V325); 00654 Py_XINCREF(storage_V327); 00655 Py_XINCREF(storage_V329); 00656 Py_XINCREF(storage_V331); 00657 Py_XINCREF(storage_V333); 00658 Py_XINCREF(storage_V335); 00659 Py_XINCREF(storage_V337); 00660 Py_XINCREF(storage_V339); 00661 Py_XINCREF(storage_V341); 00662 Py_XINCREF(storage_V343); 00663 Py_XINCREF(storage_V345); 00664 Py_XINCREF(storage_V347); 00665 Py_XINCREF(storage_V349); 00666 Py_XINCREF(storage_V351); 00667 Py_XINCREF(storage_V353); 00668 Py_XINCREF(storage_V355); 00669 Py_XINCREF(storage_V357); 00670 Py_XINCREF(storage_V359); 00671 Py_XINCREF(storage_V361); 00672 Py_XINCREF(storage_V363); 00673 Py_XINCREF(storage_V365); 00674 Py_XINCREF(storage_V367); 00675 Py_XINCREF(storage_V369); 00676 Py_XINCREF(storage_V371); 00677 Py_XINCREF(storage_V373); 00678 Py_XINCREF(storage_V375); 00679 Py_XINCREF(storage_V377); 00680 Py_XINCREF(storage_V379); 00681 Py_XINCREF(storage_V381); 00682 Py_XINCREF(storage_V383); 00683 Py_XINCREF(storage_V385); 00684 Py_XINCREF(storage_V387); 00685 Py_XINCREF(storage_V389); 00686 Py_XINCREF(storage_V391); 00687 Py_XINCREF(storage_V393); 00688 Py_XINCREF(storage_V395); 00689 Py_XINCREF(storage_V397); 00690 Py_XINCREF(storage_V399); 00691 Py_XINCREF(storage_V401); 00692 Py_XINCREF(storage_V403); 00693 Py_XINCREF(storage_V405); 00694 Py_XINCREF(storage_V407); 00695 Py_XINCREF(storage_V409); 00696 Py_XINCREF(storage_V411); 00697 Py_XINCREF(storage_V413); 00698 Py_XINCREF(storage_V415); 00699 Py_XINCREF(storage_V417); 00700 Py_XINCREF(storage_V419); 00701 Py_XINCREF(storage_V421); 00702 Py_XINCREF(storage_V423); 00703 Py_XINCREF(storage_V425); 00704 Py_XINCREF(storage_V427); 00705 Py_XINCREF(storage_V429); 00706 Py_XINCREF(storage_V431); 00707 Py_XINCREF(storage_V433); 00708 Py_XINCREF(storage_V435); 00709 Py_XINCREF(storage_V437); 00710 Py_XINCREF(storage_V439); 00711 Py_XINCREF(storage_V441); 00712 Py_XINCREF(storage_V443); 00713 Py_XINCREF(storage_V445); 00714 Py_XINCREF(storage_V447); 00715 Py_XINCREF(storage_V449); 00716 Py_XINCREF(storage_V451); 00717 Py_XINCREF(storage_V453); 00718 Py_XINCREF(storage_V455); 00719 Py_XINCREF(storage_V457); 00720 Py_XINCREF(storage_V459); 00721 Py_XINCREF(storage_V461); 00722 Py_XINCREF(storage_V463); 00723 Py_XINCREF(storage_V465); 00724 Py_XINCREF(storage_V467); 00725 Py_XINCREF(storage_V469); 00726 Py_XINCREF(storage_V471); 00727 Py_XINCREF(storage_V473); 00728 Py_XINCREF(storage_V475); 00729 Py_XINCREF(storage_V477); 00730 Py_XINCREF(storage_V479); 00731 Py_XINCREF(storage_V481); 00732 Py_XINCREF(storage_V483); 00733 Py_XINCREF(storage_V485); 00734 Py_XINCREF(storage_V487); 00735 Py_XINCREF(storage_V489); 00736 Py_XINCREF(storage_V491); 00737 Py_XINCREF(storage_V493); 00738 Py_XINCREF(storage_V495); 00739 Py_XINCREF(storage_V497); 00740 Py_XINCREF(storage_V499); 00741 Py_XINCREF(storage_V501); 00742 Py_XINCREF(storage_V503); 00743 Py_XINCREF(storage_V505); 00744 Py_XINCREF(storage_V507); 00745 Py_XINCREF(storage_V509); 00746 Py_XINCREF(storage_V511); 00747 Py_XINCREF(storage_V513); 00748 Py_XINCREF(storage_V515); 00749 Py_XINCREF(storage_V517); 00750 Py_XINCREF(storage_V519); 00751 Py_XINCREF(storage_V521); 00752 Py_XINCREF(storage_V523); 00753 Py_XINCREF(storage_V525); 00754 Py_XINCREF(storage_V527); 00755 Py_XINCREF(storage_V529); 00756 Py_XINCREF(storage_V531); 00757 Py_XINCREF(storage_V533); 00758 Py_XINCREF(storage_V535); 00759 Py_XINCREF(storage_V537); 00760 Py_XINCREF(storage_V539); 00761 Py_XINCREF(storage_V541); 00762 Py_XINCREF(storage_V543); 00763 Py_XINCREF(storage_V545); 00764 Py_XINCREF(storage_V547); 00765 Py_XINCREF(storage_V549); 00766 Py_XINCREF(storage_V551); 00767 Py_XINCREF(storage_V553); 00768 Py_XINCREF(storage_V555); 00769 Py_XINCREF(storage_V557); 00770 Py_XINCREF(storage_V559); 00771 Py_XINCREF(storage_V561); 00772 Py_XINCREF(storage_V563); 00773 Py_XINCREF(storage_V565); 00774 Py_XINCREF(storage_V567); 00775 Py_XINCREF(storage_V569); 00776 Py_XINCREF(storage_V571); 00777 Py_XINCREF(storage_V573); 00778 Py_XINCREF(storage_V575); 00779 Py_XINCREF(storage_V577); 00780 Py_XINCREF(storage_V579); 00781 Py_XINCREF(storage_V581); 00782 Py_XINCREF(storage_V583); 00783 Py_XINCREF(storage_V585); 00784 Py_XINCREF(storage_V587); 00785 Py_XINCREF(storage_V589); 00786 Py_XINCREF(storage_V591); 00787 Py_XINCREF(storage_V593); 00788 Py_XINCREF(storage_V595); 00789 Py_XINCREF(storage_V597); 00790 Py_XINCREF(storage_V599); 00791 Py_XINCREF(storage_V601); 00792 Py_XINCREF(storage_V603); 00793 Py_XINCREF(storage_V605); 00794 Py_XINCREF(storage_V607); 00795 Py_XINCREF(storage_V609); 00796 Py_XINCREF(storage_V611); 00797 Py_XINCREF(storage_V613); 00798 Py_XINCREF(storage_V615); 00799 Py_XINCREF(storage_V617); 00800 Py_XINCREF(storage_V619); 00801 Py_XINCREF(storage_V621); 00802 Py_XINCREF(storage_V623); 00803 Py_XINCREF(storage_V625); 00804 Py_XINCREF(storage_V627); 00805 Py_XINCREF(storage_V629); 00806 Py_XINCREF(storage_V631); 00807 Py_XINCREF(storage_V633); 00808 Py_XINCREF(storage_V635); 00809 Py_XINCREF(storage_V637); 00810 Py_XINCREF(storage_V639); 00811 Py_XINCREF(storage_V641); 00812 Py_XINCREF(storage_V643); 00813 Py_XINCREF(storage_V645); 00814 Py_XINCREF(storage_V647); 00815 Py_XINCREF(storage_V649); 00816 Py_XINCREF(storage_V651); 00817 Py_XINCREF(storage_V653); 00818 Py_XINCREF(storage_V655); 00819 Py_XINCREF(storage_V657); 00820 Py_XINCREF(storage_V659); 00821 Py_XINCREF(storage_V661); 00822 Py_XINCREF(storage_V663); 00823 Py_XINCREF(storage_V665); 00824 Py_XINCREF(storage_V667); 00825 Py_XINCREF(storage_V669); 00826 Py_XINCREF(storage_V671); 00827 Py_XINCREF(storage_V673); 00828 Py_XINCREF(storage_V675); 00829 Py_XINCREF(storage_V677); 00830 Py_XINCREF(storage_V679); 00831 Py_XINCREF(storage_V681); 00832 Py_XINCREF(storage_V683); 00833 Py_XINCREF(storage_V685); 00834 Py_XINCREF(storage_V687); 00835 Py_XINCREF(storage_V689); 00836 Py_XINCREF(storage_V691); 00837 Py_XINCREF(storage_V693); 00838 Py_XINCREF(storage_V695); 00839 Py_XINCREF(storage_V697); 00840 Py_XINCREF(storage_V699); 00841 Py_XINCREF(storage_V701); 00842 Py_XINCREF(storage_V703); 00843 Py_XINCREF(storage_V705); 00844 Py_XINCREF(storage_V707); 00845 Py_XINCREF(storage_V709); 00846 Py_XINCREF(storage_V711); 00847 Py_XINCREF(storage_V713); 00848 Py_XINCREF(storage_V715); 00849 Py_XINCREF(storage_V717); 00850 Py_XINCREF(storage_V719); 00851 Py_XINCREF(storage_V721); 00852 Py_XINCREF(storage_V723); 00853 Py_XINCREF(storage_V725); 00854 Py_XINCREF(storage_V727); 00855 Py_XINCREF(storage_V729); 00856 Py_XINCREF(storage_V731); 00857 Py_XINCREF(storage_V733); 00858 Py_XINCREF(storage_V735); 00859 Py_XINCREF(storage_V737); 00860 Py_XINCREF(storage_V739); 00861 Py_XINCREF(storage_V741); 00862 Py_XINCREF(storage_V743); 00863 Py_XINCREF(storage_V745); 00864 Py_XINCREF(storage_V747); 00865 Py_XINCREF(storage_V749); 00866 Py_XINCREF(storage_V751); 00867 Py_XINCREF(storage_V753); 00868 Py_XINCREF(storage_V755); 00869 Py_XINCREF(storage_V757); 00870 Py_XINCREF(storage_V759); 00871 Py_XINCREF(storage_V761); 00872 Py_XINCREF(storage_V763); 00873 Py_XINCREF(storage_V765); 00874 Py_XINCREF(storage_V767); 00875 Py_XINCREF(storage_V769); 00876 Py_XINCREF(storage_V771); 00877 Py_XINCREF(storage_V773); 00878 Py_XINCREF(storage_V775); 00879 Py_XINCREF(storage_V777); 00880 Py_XINCREF(storage_V779); 00881 Py_XINCREF(storage_V781); 00882 Py_XINCREF(storage_V783); 00883 Py_XINCREF(storage_V785); 00884 Py_XINCREF(storage_V787); 00885 Py_XINCREF(storage_V789); 00886 Py_XINCREF(storage_V791); 00887 Py_XINCREF(storage_V793); 00888 Py_XINCREF(storage_V795); 00889 Py_XINCREF(storage_V797); 00890 Py_XINCREF(storage_V799); 00891 Py_XINCREF(storage_V801); 00892 Py_XINCREF(storage_V803); 00893 Py_XINCREF(storage_V805); 00894 Py_XINCREF(storage_V807); 00895 Py_XINCREF(storage_V809); 00896 Py_XINCREF(storage_V811); 00897 Py_XINCREF(storage_V813); 00898 Py_XINCREF(storage_V815); 00899 Py_XINCREF(storage_V817); 00900 Py_XINCREF(storage_V819); 00901 Py_XINCREF(storage_V821); 00902 Py_XINCREF(storage_V823); 00903 Py_XINCREF(storage_V825); 00904 Py_XINCREF(storage_V827); 00905 Py_XINCREF(storage_V829); 00906 Py_XINCREF(storage_V831); 00907 Py_XINCREF(storage_V833); 00908 Py_XINCREF(storage_V835); 00909 Py_XINCREF(storage_V837); 00910 Py_XINCREF(storage_V839); 00911 Py_XINCREF(storage_V841); 00912 Py_XINCREF(storage_V843); 00913 Py_XINCREF(storage_V845); 00914 Py_XINCREF(storage_V847); 00915 Py_XINCREF(storage_V849); 00916 Py_XINCREF(storage_V851); 00917 Py_XINCREF(storage_V853); 00918 Py_XINCREF(storage_V855); 00919 Py_XINCREF(storage_V857); 00920 Py_XINCREF(storage_V859); 00921 Py_XINCREF(storage_V861); 00922 Py_XINCREF(storage_V863); 00923 Py_XINCREF(storage_V865); 00924 Py_XINCREF(storage_V867); 00925 Py_XINCREF(storage_V869); 00926 Py_XINCREF(storage_V871); 00927 Py_XINCREF(storage_V873); 00928 Py_XINCREF(storage_V875); 00929 Py_XINCREF(storage_V877); 00930 Py_XINCREF(storage_V879); 00931 Py_XINCREF(storage_V881); 00932 Py_XINCREF(storage_V883); 00933 Py_XINCREF(storage_V885); 00934 Py_XINCREF(storage_V887); 00935 Py_XINCREF(storage_V889); 00936 Py_XINCREF(storage_V891); 00937 Py_XINCREF(storage_V893); 00938 Py_XINCREF(storage_V895); 00939 Py_XINCREF(storage_V897); 00940 Py_XINCREF(storage_V899); 00941 Py_XINCREF(storage_V901); 00942 Py_XINCREF(storage_V903); 00943 Py_XINCREF(storage_V905); 00944 Py_XINCREF(storage_V907); 00945 Py_XINCREF(storage_V909); 00946 Py_XINCREF(storage_V1); 00947 this->storage_V3 = storage_V3; 00948 this->storage_V5 = storage_V5; 00949 this->storage_V7 = storage_V7; 00950 this->storage_V9 = storage_V9; 00951 this->storage_V11 = storage_V11; 00952 this->storage_V13 = storage_V13; 00953 this->storage_V15 = storage_V15; 00954 this->storage_V17 = storage_V17; 00955 this->storage_V19 = storage_V19; 00956 this->storage_V21 = storage_V21; 00957 this->storage_V23 = storage_V23; 00958 this->storage_V25 = storage_V25; 00959 this->storage_V27 = storage_V27; 00960 this->storage_V29 = storage_V29; 00961 this->storage_V31 = storage_V31; 00962 this->storage_V33 = storage_V33; 00963 this->storage_V35 = storage_V35; 00964 this->storage_V37 = storage_V37; 00965 this->storage_V39 = storage_V39; 00966 this->storage_V41 = storage_V41; 00967 this->storage_V43 = storage_V43; 00968 this->storage_V45 = storage_V45; 00969 this->storage_V47 = storage_V47; 00970 this->storage_V49 = storage_V49; 00971 this->storage_V51 = storage_V51; 00972 this->storage_V53 = storage_V53; 00973 this->storage_V55 = storage_V55; 00974 this->storage_V57 = storage_V57; 00975 this->storage_V59 = storage_V59; 00976 this->storage_V61 = storage_V61; 00977 this->storage_V63 = storage_V63; 00978 this->storage_V65 = storage_V65; 00979 this->storage_V67 = storage_V67; 00980 this->storage_V69 = storage_V69; 00981 this->storage_V71 = storage_V71; 00982 this->storage_V73 = storage_V73; 00983 this->storage_V75 = storage_V75; 00984 this->storage_V77 = storage_V77; 00985 this->storage_V79 = storage_V79; 00986 this->storage_V81 = storage_V81; 00987 this->storage_V83 = storage_V83; 00988 this->storage_V85 = storage_V85; 00989 this->storage_V87 = storage_V87; 00990 this->storage_V89 = storage_V89; 00991 this->storage_V91 = storage_V91; 00992 this->storage_V93 = storage_V93; 00993 this->storage_V95 = storage_V95; 00994 this->storage_V97 = storage_V97; 00995 this->storage_V99 = storage_V99; 00996 this->storage_V101 = storage_V101; 00997 this->storage_V103 = storage_V103; 00998 this->storage_V105 = storage_V105; 00999 this->storage_V107 = storage_V107; 01000 this->storage_V109 = storage_V109; 01001 this->storage_V111 = storage_V111; 01002 this->storage_V113 = storage_V113; 01003 this->storage_V115 = storage_V115; 01004 this->storage_V117 = storage_V117; 01005 this->storage_V119 = storage_V119; 01006 this->storage_V121 = storage_V121; 01007 this->storage_V123 = storage_V123; 01008 this->storage_V125 = storage_V125; 01009 this->storage_V127 = storage_V127; 01010 this->storage_V129 = storage_V129; 01011 this->storage_V131 = storage_V131; 01012 this->storage_V133 = storage_V133; 01013 this->storage_V135 = storage_V135; 01014 this->storage_V137 = storage_V137; 01015 this->storage_V139 = storage_V139; 01016 this->storage_V141 = storage_V141; 01017 this->storage_V143 = storage_V143; 01018 this->storage_V145 = storage_V145; 01019 this->storage_V147 = storage_V147; 01020 this->storage_V149 = storage_V149; 01021 this->storage_V151 = storage_V151; 01022 this->storage_V153 = storage_V153; 01023 this->storage_V155 = storage_V155; 01024 this->storage_V157 = storage_V157; 01025 this->storage_V159 = storage_V159; 01026 this->storage_V161 = storage_V161; 01027 this->storage_V163 = storage_V163; 01028 this->storage_V165 = storage_V165; 01029 this->storage_V167 = storage_V167; 01030 this->storage_V169 = storage_V169; 01031 this->storage_V171 = storage_V171; 01032 this->storage_V173 = storage_V173; 01033 this->storage_V175 = storage_V175; 01034 this->storage_V177 = storage_V177; 01035 this->storage_V179 = storage_V179; 01036 this->storage_V181 = storage_V181; 01037 this->storage_V183 = storage_V183; 01038 this->storage_V185 = storage_V185; 01039 this->storage_V187 = storage_V187; 01040 this->storage_V189 = storage_V189; 01041 this->storage_V191 = storage_V191; 01042 this->storage_V193 = storage_V193; 01043 this->storage_V195 = storage_V195; 01044 this->storage_V197 = storage_V197; 01045 this->storage_V199 = storage_V199; 01046 this->storage_V201 = storage_V201; 01047 this->storage_V203 = storage_V203; 01048 this->storage_V205 = storage_V205; 01049 this->storage_V207 = storage_V207; 01050 this->storage_V209 = storage_V209; 01051 this->storage_V211 = storage_V211; 01052 this->storage_V213 = storage_V213; 01053 this->storage_V215 = storage_V215; 01054 this->storage_V217 = storage_V217; 01055 this->storage_V219 = storage_V219; 01056 this->storage_V221 = storage_V221; 01057 this->storage_V223 = storage_V223; 01058 this->storage_V225 = storage_V225; 01059 this->storage_V227 = storage_V227; 01060 this->storage_V229 = storage_V229; 01061 this->storage_V231 = storage_V231; 01062 this->storage_V233 = storage_V233; 01063 this->storage_V235 = storage_V235; 01064 this->storage_V237 = storage_V237; 01065 this->storage_V239 = storage_V239; 01066 this->storage_V241 = storage_V241; 01067 this->storage_V243 = storage_V243; 01068 this->storage_V245 = storage_V245; 01069 this->storage_V247 = storage_V247; 01070 this->storage_V249 = storage_V249; 01071 this->storage_V251 = storage_V251; 01072 this->storage_V253 = storage_V253; 01073 this->storage_V255 = storage_V255; 01074 this->storage_V257 = storage_V257; 01075 this->storage_V259 = storage_V259; 01076 this->storage_V261 = storage_V261; 01077 this->storage_V263 = storage_V263; 01078 this->storage_V265 = storage_V265; 01079 this->storage_V267 = storage_V267; 01080 this->storage_V269 = storage_V269; 01081 this->storage_V271 = storage_V271; 01082 this->storage_V273 = storage_V273; 01083 this->storage_V275 = storage_V275; 01084 this->storage_V277 = storage_V277; 01085 this->storage_V279 = storage_V279; 01086 this->storage_V281 = storage_V281; 01087 this->storage_V283 = storage_V283; 01088 this->storage_V285 = storage_V285; 01089 this->storage_V287 = storage_V287; 01090 this->storage_V289 = storage_V289; 01091 this->storage_V291 = storage_V291; 01092 this->storage_V293 = storage_V293; 01093 this->storage_V295 = storage_V295; 01094 this->storage_V297 = storage_V297; 01095 this->storage_V299 = storage_V299; 01096 this->storage_V301 = storage_V301; 01097 this->storage_V303 = storage_V303; 01098 this->storage_V305 = storage_V305; 01099 this->storage_V307 = storage_V307; 01100 this->storage_V309 = storage_V309; 01101 this->storage_V311 = storage_V311; 01102 this->storage_V313 = storage_V313; 01103 this->storage_V315 = storage_V315; 01104 this->storage_V317 = storage_V317; 01105 this->storage_V319 = storage_V319; 01106 this->storage_V321 = storage_V321; 01107 this->storage_V323 = storage_V323; 01108 this->storage_V325 = storage_V325; 01109 this->storage_V327 = storage_V327; 01110 this->storage_V329 = storage_V329; 01111 this->storage_V331 = storage_V331; 01112 this->storage_V333 = storage_V333; 01113 this->storage_V335 = storage_V335; 01114 this->storage_V337 = storage_V337; 01115 this->storage_V339 = storage_V339; 01116 this->storage_V341 = storage_V341; 01117 this->storage_V343 = storage_V343; 01118 this->storage_V345 = storage_V345; 01119 this->storage_V347 = storage_V347; 01120 this->storage_V349 = storage_V349; 01121 this->storage_V351 = storage_V351; 01122 this->storage_V353 = storage_V353; 01123 this->storage_V355 = storage_V355; 01124 this->storage_V357 = storage_V357; 01125 this->storage_V359 = storage_V359; 01126 this->storage_V361 = storage_V361; 01127 this->storage_V363 = storage_V363; 01128 this->storage_V365 = storage_V365; 01129 this->storage_V367 = storage_V367; 01130 this->storage_V369 = storage_V369; 01131 this->storage_V371 = storage_V371; 01132 this->storage_V373 = storage_V373; 01133 this->storage_V375 = storage_V375; 01134 this->storage_V377 = storage_V377; 01135 this->storage_V379 = storage_V379; 01136 this->storage_V381 = storage_V381; 01137 this->storage_V383 = storage_V383; 01138 this->storage_V385 = storage_V385; 01139 this->storage_V387 = storage_V387; 01140 this->storage_V389 = storage_V389; 01141 this->storage_V391 = storage_V391; 01142 this->storage_V393 = storage_V393; 01143 this->storage_V395 = storage_V395; 01144 this->storage_V397 = storage_V397; 01145 this->storage_V399 = storage_V399; 01146 this->storage_V401 = storage_V401; 01147 this->storage_V403 = storage_V403; 01148 this->storage_V405 = storage_V405; 01149 this->storage_V407 = storage_V407; 01150 this->storage_V409 = storage_V409; 01151 this->storage_V411 = storage_V411; 01152 this->storage_V413 = storage_V413; 01153 this->storage_V415 = storage_V415; 01154 this->storage_V417 = storage_V417; 01155 this->storage_V419 = storage_V419; 01156 this->storage_V421 = storage_V421; 01157 this->storage_V423 = storage_V423; 01158 this->storage_V425 = storage_V425; 01159 this->storage_V427 = storage_V427; 01160 this->storage_V429 = storage_V429; 01161 this->storage_V431 = storage_V431; 01162 this->storage_V433 = storage_V433; 01163 this->storage_V435 = storage_V435; 01164 this->storage_V437 = storage_V437; 01165 this->storage_V439 = storage_V439; 01166 this->storage_V441 = storage_V441; 01167 this->storage_V443 = storage_V443; 01168 this->storage_V445 = storage_V445; 01169 this->storage_V447 = storage_V447; 01170 this->storage_V449 = storage_V449; 01171 this->storage_V451 = storage_V451; 01172 this->storage_V453 = storage_V453; 01173 this->storage_V455 = storage_V455; 01174 this->storage_V457 = storage_V457; 01175 this->storage_V459 = storage_V459; 01176 this->storage_V461 = storage_V461; 01177 this->storage_V463 = storage_V463; 01178 this->storage_V465 = storage_V465; 01179 this->storage_V467 = storage_V467; 01180 this->storage_V469 = storage_V469; 01181 this->storage_V471 = storage_V471; 01182 this->storage_V473 = storage_V473; 01183 this->storage_V475 = storage_V475; 01184 this->storage_V477 = storage_V477; 01185 this->storage_V479 = storage_V479; 01186 this->storage_V481 = storage_V481; 01187 this->storage_V483 = storage_V483; 01188 this->storage_V485 = storage_V485; 01189 this->storage_V487 = storage_V487; 01190 this->storage_V489 = storage_V489; 01191 this->storage_V491 = storage_V491; 01192 this->storage_V493 = storage_V493; 01193 this->storage_V495 = storage_V495; 01194 this->storage_V497 = storage_V497; 01195 this->storage_V499 = storage_V499; 01196 this->storage_V501 = storage_V501; 01197 this->storage_V503 = storage_V503; 01198 this->storage_V505 = storage_V505; 01199 this->storage_V507 = storage_V507; 01200 this->storage_V509 = storage_V509; 01201 this->storage_V511 = storage_V511; 01202 this->storage_V513 = storage_V513; 01203 this->storage_V515 = storage_V515; 01204 this->storage_V517 = storage_V517; 01205 this->storage_V519 = storage_V519; 01206 this->storage_V521 = storage_V521; 01207 this->storage_V523 = storage_V523; 01208 this->storage_V525 = storage_V525; 01209 this->storage_V527 = storage_V527; 01210 this->storage_V529 = storage_V529; 01211 this->storage_V531 = storage_V531; 01212 this->storage_V533 = storage_V533; 01213 this->storage_V535 = storage_V535; 01214 this->storage_V537 = storage_V537; 01215 this->storage_V539 = storage_V539; 01216 this->storage_V541 = storage_V541; 01217 this->storage_V543 = storage_V543; 01218 this->storage_V545 = storage_V545; 01219 this->storage_V547 = storage_V547; 01220 this->storage_V549 = storage_V549; 01221 this->storage_V551 = storage_V551; 01222 this->storage_V553 = storage_V553; 01223 this->storage_V555 = storage_V555; 01224 this->storage_V557 = storage_V557; 01225 this->storage_V559 = storage_V559; 01226 this->storage_V561 = storage_V561; 01227 this->storage_V563 = storage_V563; 01228 this->storage_V565 = storage_V565; 01229 this->storage_V567 = storage_V567; 01230 this->storage_V569 = storage_V569; 01231 this->storage_V571 = storage_V571; 01232 this->storage_V573 = storage_V573; 01233 this->storage_V575 = storage_V575; 01234 this->storage_V577 = storage_V577; 01235 this->storage_V579 = storage_V579; 01236 this->storage_V581 = storage_V581; 01237 this->storage_V583 = storage_V583; 01238 this->storage_V585 = storage_V585; 01239 this->storage_V587 = storage_V587; 01240 this->storage_V589 = storage_V589; 01241 this->storage_V591 = storage_V591; 01242 this->storage_V593 = storage_V593; 01243 this->storage_V595 = storage_V595; 01244 this->storage_V597 = storage_V597; 01245 this->storage_V599 = storage_V599; 01246 this->storage_V601 = storage_V601; 01247 this->storage_V603 = storage_V603; 01248 this->storage_V605 = storage_V605; 01249 this->storage_V607 = storage_V607; 01250 this->storage_V609 = storage_V609; 01251 this->storage_V611 = storage_V611; 01252 this->storage_V613 = storage_V613; 01253 this->storage_V615 = storage_V615; 01254 this->storage_V617 = storage_V617; 01255 this->storage_V619 = storage_V619; 01256 this->storage_V621 = storage_V621; 01257 this->storage_V623 = storage_V623; 01258 this->storage_V625 = storage_V625; 01259 this->storage_V627 = storage_V627; 01260 this->storage_V629 = storage_V629; 01261 this->storage_V631 = storage_V631; 01262 this->storage_V633 = storage_V633; 01263 this->storage_V635 = storage_V635; 01264 this->storage_V637 = storage_V637; 01265 this->storage_V639 = storage_V639; 01266 this->storage_V641 = storage_V641; 01267 this->storage_V643 = storage_V643; 01268 this->storage_V645 = storage_V645; 01269 this->storage_V647 = storage_V647; 01270 this->storage_V649 = storage_V649; 01271 this->storage_V651 = storage_V651; 01272 this->storage_V653 = storage_V653; 01273 this->storage_V655 = storage_V655; 01274 this->storage_V657 = storage_V657; 01275 this->storage_V659 = storage_V659; 01276 this->storage_V661 = storage_V661; 01277 this->storage_V663 = storage_V663; 01278 this->storage_V665 = storage_V665; 01279 this->storage_V667 = storage_V667; 01280 this->storage_V669 = storage_V669; 01281 this->storage_V671 = storage_V671; 01282 this->storage_V673 = storage_V673; 01283 this->storage_V675 = storage_V675; 01284 this->storage_V677 = storage_V677; 01285 this->storage_V679 = storage_V679; 01286 this->storage_V681 = storage_V681; 01287 this->storage_V683 = storage_V683; 01288 this->storage_V685 = storage_V685; 01289 this->storage_V687 = storage_V687; 01290 this->storage_V689 = storage_V689; 01291 this->storage_V691 = storage_V691; 01292 this->storage_V693 = storage_V693; 01293 this->storage_V695 = storage_V695; 01294 this->storage_V697 = storage_V697; 01295 this->storage_V699 = storage_V699; 01296 this->storage_V701 = storage_V701; 01297 this->storage_V703 = storage_V703; 01298 this->storage_V705 = storage_V705; 01299 this->storage_V707 = storage_V707; 01300 this->storage_V709 = storage_V709; 01301 this->storage_V711 = storage_V711; 01302 this->storage_V713 = storage_V713; 01303 this->storage_V715 = storage_V715; 01304 this->storage_V717 = storage_V717; 01305 this->storage_V719 = storage_V719; 01306 this->storage_V721 = storage_V721; 01307 this->storage_V723 = storage_V723; 01308 this->storage_V725 = storage_V725; 01309 this->storage_V727 = storage_V727; 01310 this->storage_V729 = storage_V729; 01311 this->storage_V731 = storage_V731; 01312 this->storage_V733 = storage_V733; 01313 this->storage_V735 = storage_V735; 01314 this->storage_V737 = storage_V737; 01315 this->storage_V739 = storage_V739; 01316 this->storage_V741 = storage_V741; 01317 this->storage_V743 = storage_V743; 01318 this->storage_V745 = storage_V745; 01319 this->storage_V747 = storage_V747; 01320 this->storage_V749 = storage_V749; 01321 this->storage_V751 = storage_V751; 01322 this->storage_V753 = storage_V753; 01323 this->storage_V755 = storage_V755; 01324 this->storage_V757 = storage_V757; 01325 this->storage_V759 = storage_V759; 01326 this->storage_V761 = storage_V761; 01327 this->storage_V763 = storage_V763; 01328 this->storage_V765 = storage_V765; 01329 this->storage_V767 = storage_V767; 01330 this->storage_V769 = storage_V769; 01331 this->storage_V771 = storage_V771; 01332 this->storage_V773 = storage_V773; 01333 this->storage_V775 = storage_V775; 01334 this->storage_V777 = storage_V777; 01335 this->storage_V779 = storage_V779; 01336 this->storage_V781 = storage_V781; 01337 this->storage_V783 = storage_V783; 01338 this->storage_V785 = storage_V785; 01339 this->storage_V787 = storage_V787; 01340 this->storage_V789 = storage_V789; 01341 this->storage_V791 = storage_V791; 01342 this->storage_V793 = storage_V793; 01343 this->storage_V795 = storage_V795; 01344 this->storage_V797 = storage_V797; 01345 this->storage_V799 = storage_V799; 01346 this->storage_V801 = storage_V801; 01347 this->storage_V803 = storage_V803; 01348 this->storage_V805 = storage_V805; 01349 this->storage_V807 = storage_V807; 01350 this->storage_V809 = storage_V809; 01351 this->storage_V811 = storage_V811; 01352 this->storage_V813 = storage_V813; 01353 this->storage_V815 = storage_V815; 01354 this->storage_V817 = storage_V817; 01355 this->storage_V819 = storage_V819; 01356 this->storage_V821 = storage_V821; 01357 this->storage_V823 = storage_V823; 01358 this->storage_V825 = storage_V825; 01359 this->storage_V827 = storage_V827; 01360 this->storage_V829 = storage_V829; 01361 this->storage_V831 = storage_V831; 01362 this->storage_V833 = storage_V833; 01363 this->storage_V835 = storage_V835; 01364 this->storage_V837 = storage_V837; 01365 this->storage_V839 = storage_V839; 01366 this->storage_V841 = storage_V841; 01367 this->storage_V843 = storage_V843; 01368 this->storage_V845 = storage_V845; 01369 this->storage_V847 = storage_V847; 01370 this->storage_V849 = storage_V849; 01371 this->storage_V851 = storage_V851; 01372 this->storage_V853 = storage_V853; 01373 this->storage_V855 = storage_V855; 01374 this->storage_V857 = storage_V857; 01375 this->storage_V859 = storage_V859; 01376 this->storage_V861 = storage_V861; 01377 this->storage_V863 = storage_V863; 01378 this->storage_V865 = storage_V865; 01379 this->storage_V867 = storage_V867; 01380 this->storage_V869 = storage_V869; 01381 this->storage_V871 = storage_V871; 01382 this->storage_V873 = storage_V873; 01383 this->storage_V875 = storage_V875; 01384 this->storage_V877 = storage_V877; 01385 this->storage_V879 = storage_V879; 01386 this->storage_V881 = storage_V881; 01387 this->storage_V883 = storage_V883; 01388 this->storage_V885 = storage_V885; 01389 this->storage_V887 = storage_V887; 01390 this->storage_V889 = storage_V889; 01391 this->storage_V891 = storage_V891; 01392 this->storage_V893 = storage_V893; 01393 this->storage_V895 = storage_V895; 01394 this->storage_V897 = storage_V897; 01395 this->storage_V899 = storage_V899; 01396 this->storage_V901 = storage_V901; 01397 this->storage_V903 = storage_V903; 01398 this->storage_V905 = storage_V905; 01399 this->storage_V907 = storage_V907; 01400 this->storage_V909 = storage_V909; 01401 this->storage_V1 = storage_V1; 01402 01403 01404 01405 01406 01407 01408 01409 01410 01411 01412 01413 01414 01415 01416 01417 01418 01419 01420 01421 01422 01423 01424 01425 01426 01427 01428 01429 01430 01431 01432 01433 01434 01435 01436 01437 01438 01439 01440 01441 01442 01443 01444 01445 01446 01447 01448 01449 01450 01451 01452 01453 01454 01455 01456 01457 01458 01459 01460 01461 01462 01463 01464 01465 01466 01467 01468 01469 01470 01471 01472 01473 01474 01475 01476 01477 01478 01479 01480 01481 01482 01483 01484 01485 01486 01487 01488 01489 01490 01491 01492 01493 01494 01495 01496 01497 01498 01499 01500 01501 01502 01503 01504 01505 01506 01507 01508 01509 01510 01511 01512 01513 01514 01515 01516 01517 01518 01519 01520 01521 01522 01523 01524 01525 01526 01527 01528 01529 01530 01531 01532 01533 01534 01535 01536 01537 01538 01539 01540 01541 01542 01543 01544 01545 01546 01547 01548 01549 01550 01551 01552 01553 01554 01555 01556 01557 01558 01559 01560 01561 01562 01563 01564 01565 01566 01567 01568 01569 01570 01571 01572 01573 01574 01575 01576 01577 01578 01579 01580 01581 01582 01583 01584 01585 01586 01587 01588 01589 01590 01591 01592 01593 01594 01595 01596 01597 01598 01599 01600 01601 01602 01603 01604 01605 01606 01607 01608 01609 01610 01611 01612 01613 01614 01615 01616 01617 01618 01619 01620 01621 01622 01623 01624 01625 01626 01627 01628 01629 01630 01631 01632 01633 01634 01635 01636 01637 01638 01639 01640 01641 01642 01643 01644 01645 01646 01647 01648 01649 01650 01651 01652 01653 01654 01655 01656 01657 01658 01659 01660 01661 01662 01663 01664 01665 01666 01667 01668 01669 01670 01671 01672 01673 01674 01675 01676 01677 01678 01679 01680 01681 01682 01683 01684 01685 01686 01687 01688 01689 01690 01691 01692 01693 01694 01695 01696 01697 01698 01699 01700 01701 01702 01703 01704 01705 01706 01707 01708 01709 01710 01711 01712 01713 01714 01715 01716 01717 01718 01719 01720 01721 01722 01723 01724 01725 01726 01727 01728 01729 01730 01731 01732 01733 01734 01735 01736 01737 01738 01739 01740 01741 01742 01743 01744 01745 01746 01747 01748 01749 01750 01751 01752 01753 01754 01755 01756 01757 01758 01759 01760 01761 01762 01763 01764 01765 01766 01767 01768 01769 01770 01771 01772 01773 01774 01775 01776 01777 01778 01779 01780 01781 01782 01783 01784 01785 01786 01787 01788 01789 01790 01791 01792 01793 01794 01795 01796 01797 01798 01799 01800 01801 01802 01803 01804 01805 01806 01807 01808 01809 01810 01811 01812 01813 01814 01815 01816 01817 01818 01819 01820 01821 01822 01823 01824 01825 01826 01827 01828 01829 01830 01831 01832 01833 01834 01835 01836 01837 01838 01839 01840 01841 01842 01843 01844 01845 01846 01847 01848 01849 01850 01851 01852 01853 01854 01855 01856 01857 01858 01859 this->__ERROR = __ERROR; 01860 return 0; 01861 } 01862 void cleanup(void) { 01863 __label_1: 01864 01865 double __DUMMY_1; 01866 __label_3: 01867 01868 double __DUMMY_3; 01869 __label_5: 01870 01871 double __DUMMY_5; 01872 __label_7: 01873 01874 double __DUMMY_7; 01875 __label_9: 01876 01877 double __DUMMY_9; 01878 __label_11: 01879 01880 double __DUMMY_11; 01881 __label_13: 01882 01883 double __DUMMY_13; 01884 __label_15: 01885 01886 double __DUMMY_15; 01887 __label_17: 01888 01889 double __DUMMY_17; 01890 __label_19: 01891 01892 double __DUMMY_19; 01893 __label_21: 01894 01895 double __DUMMY_21; 01896 __label_23: 01897 01898 double __DUMMY_23; 01899 __label_25: 01900 01901 double __DUMMY_25; 01902 __label_27: 01903 01904 double __DUMMY_27; 01905 __label_29: 01906 01907 double __DUMMY_29; 01908 __label_31: 01909 01910 double __DUMMY_31; 01911 __label_33: 01912 01913 double __DUMMY_33; 01914 __label_35: 01915 01916 double __DUMMY_35; 01917 __label_37: 01918 01919 double __DUMMY_37; 01920 __label_39: 01921 01922 double __DUMMY_39; 01923 __label_41: 01924 01925 double __DUMMY_41; 01926 __label_43: 01927 01928 double __DUMMY_43; 01929 __label_45: 01930 01931 double __DUMMY_45; 01932 __label_47: 01933 01934 double __DUMMY_47; 01935 __label_49: 01936 01937 double __DUMMY_49; 01938 __label_51: 01939 01940 double __DUMMY_51; 01941 __label_53: 01942 01943 double __DUMMY_53; 01944 __label_55: 01945 01946 double __DUMMY_55; 01947 __label_57: 01948 01949 double __DUMMY_57; 01950 __label_59: 01951 01952 double __DUMMY_59; 01953 __label_61: 01954 01955 double __DUMMY_61; 01956 __label_63: 01957 01958 double __DUMMY_63; 01959 __label_65: 01960 01961 double __DUMMY_65; 01962 __label_67: 01963 01964 double __DUMMY_67; 01965 __label_69: 01966 01967 double __DUMMY_69; 01968 __label_71: 01969 01970 double __DUMMY_71; 01971 __label_73: 01972 01973 double __DUMMY_73; 01974 __label_75: 01975 01976 double __DUMMY_75; 01977 __label_77: 01978 01979 double __DUMMY_77; 01980 __label_79: 01981 01982 double __DUMMY_79; 01983 __label_81: 01984 01985 double __DUMMY_81; 01986 __label_83: 01987 01988 double __DUMMY_83; 01989 __label_85: 01990 01991 double __DUMMY_85; 01992 __label_87: 01993 01994 double __DUMMY_87; 01995 __label_89: 01996 01997 double __DUMMY_89; 01998 __label_91: 01999 02000 double __DUMMY_91; 02001 __label_93: 02002 02003 double __DUMMY_93; 02004 __label_95: 02005 02006 double __DUMMY_95; 02007 __label_97: 02008 02009 double __DUMMY_97; 02010 __label_99: 02011 02012 double __DUMMY_99; 02013 __label_101: 02014 02015 double __DUMMY_101; 02016 __label_103: 02017 02018 double __DUMMY_103; 02019 __label_105: 02020 02021 double __DUMMY_105; 02022 __label_107: 02023 02024 double __DUMMY_107; 02025 __label_109: 02026 02027 double __DUMMY_109; 02028 __label_111: 02029 02030 double __DUMMY_111; 02031 __label_113: 02032 02033 double __DUMMY_113; 02034 __label_115: 02035 02036 double __DUMMY_115; 02037 __label_117: 02038 02039 double __DUMMY_117; 02040 __label_119: 02041 02042 double __DUMMY_119; 02043 __label_121: 02044 02045 double __DUMMY_121; 02046 __label_123: 02047 02048 double __DUMMY_123; 02049 __label_125: 02050 02051 double __DUMMY_125; 02052 __label_127: 02053 02054 double __DUMMY_127; 02055 __label_129: 02056 02057 double __DUMMY_129; 02058 __label_131: 02059 02060 double __DUMMY_131; 02061 __label_133: 02062 02063 double __DUMMY_133; 02064 __label_135: 02065 02066 double __DUMMY_135; 02067 __label_137: 02068 02069 double __DUMMY_137; 02070 __label_139: 02071 02072 double __DUMMY_139; 02073 __label_141: 02074 02075 double __DUMMY_141; 02076 __label_143: 02077 02078 double __DUMMY_143; 02079 __label_145: 02080 02081 double __DUMMY_145; 02082 __label_147: 02083 02084 double __DUMMY_147; 02085 __label_149: 02086 02087 double __DUMMY_149; 02088 __label_151: 02089 02090 double __DUMMY_151; 02091 __label_153: 02092 02093 double __DUMMY_153; 02094 __label_155: 02095 02096 double __DUMMY_155; 02097 __label_157: 02098 02099 double __DUMMY_157; 02100 __label_159: 02101 02102 double __DUMMY_159; 02103 __label_161: 02104 02105 double __DUMMY_161; 02106 __label_163: 02107 02108 double __DUMMY_163; 02109 __label_165: 02110 02111 double __DUMMY_165; 02112 __label_167: 02113 02114 double __DUMMY_167; 02115 __label_169: 02116 02117 double __DUMMY_169; 02118 __label_171: 02119 02120 double __DUMMY_171; 02121 __label_173: 02122 02123 double __DUMMY_173; 02124 __label_175: 02125 02126 double __DUMMY_175; 02127 __label_177: 02128 02129 double __DUMMY_177; 02130 __label_179: 02131 02132 double __DUMMY_179; 02133 __label_181: 02134 02135 double __DUMMY_181; 02136 __label_183: 02137 02138 double __DUMMY_183; 02139 __label_185: 02140 02141 double __DUMMY_185; 02142 __label_187: 02143 02144 double __DUMMY_187; 02145 __label_189: 02146 02147 double __DUMMY_189; 02148 __label_191: 02149 02150 double __DUMMY_191; 02151 __label_193: 02152 02153 double __DUMMY_193; 02154 __label_195: 02155 02156 double __DUMMY_195; 02157 __label_197: 02158 02159 double __DUMMY_197; 02160 __label_199: 02161 02162 double __DUMMY_199; 02163 __label_201: 02164 02165 double __DUMMY_201; 02166 __label_203: 02167 02168 double __DUMMY_203; 02169 __label_205: 02170 02171 double __DUMMY_205; 02172 __label_207: 02173 02174 double __DUMMY_207; 02175 __label_209: 02176 02177 double __DUMMY_209; 02178 __label_211: 02179 02180 double __DUMMY_211; 02181 __label_213: 02182 02183 double __DUMMY_213; 02184 __label_215: 02185 02186 double __DUMMY_215; 02187 __label_217: 02188 02189 double __DUMMY_217; 02190 __label_219: 02191 02192 double __DUMMY_219; 02193 __label_221: 02194 02195 double __DUMMY_221; 02196 __label_223: 02197 02198 double __DUMMY_223; 02199 __label_225: 02200 02201 double __DUMMY_225; 02202 __label_227: 02203 02204 double __DUMMY_227; 02205 __label_229: 02206 02207 double __DUMMY_229; 02208 __label_231: 02209 02210 double __DUMMY_231; 02211 __label_233: 02212 02213 double __DUMMY_233; 02214 __label_235: 02215 02216 double __DUMMY_235; 02217 __label_237: 02218 02219 double __DUMMY_237; 02220 __label_239: 02221 02222 double __DUMMY_239; 02223 __label_241: 02224 02225 double __DUMMY_241; 02226 __label_243: 02227 02228 double __DUMMY_243; 02229 __label_245: 02230 02231 double __DUMMY_245; 02232 __label_247: 02233 02234 double __DUMMY_247; 02235 __label_249: 02236 02237 double __DUMMY_249; 02238 __label_251: 02239 02240 double __DUMMY_251; 02241 __label_253: 02242 02243 double __DUMMY_253; 02244 __label_255: 02245 02246 double __DUMMY_255; 02247 __label_257: 02248 02249 double __DUMMY_257; 02250 __label_259: 02251 02252 double __DUMMY_259; 02253 __label_261: 02254 02255 double __DUMMY_261; 02256 __label_263: 02257 02258 double __DUMMY_263; 02259 __label_265: 02260 02261 double __DUMMY_265; 02262 __label_267: 02263 02264 double __DUMMY_267; 02265 __label_269: 02266 02267 double __DUMMY_269; 02268 __label_271: 02269 02270 double __DUMMY_271; 02271 __label_273: 02272 02273 double __DUMMY_273; 02274 __label_275: 02275 02276 double __DUMMY_275; 02277 __label_277: 02278 02279 double __DUMMY_277; 02280 __label_279: 02281 02282 double __DUMMY_279; 02283 __label_281: 02284 02285 double __DUMMY_281; 02286 __label_283: 02287 02288 double __DUMMY_283; 02289 __label_285: 02290 02291 double __DUMMY_285; 02292 __label_287: 02293 02294 double __DUMMY_287; 02295 __label_289: 02296 02297 double __DUMMY_289; 02298 __label_291: 02299 02300 double __DUMMY_291; 02301 __label_293: 02302 02303 double __DUMMY_293; 02304 __label_295: 02305 02306 double __DUMMY_295; 02307 __label_297: 02308 02309 double __DUMMY_297; 02310 __label_299: 02311 02312 double __DUMMY_299; 02313 __label_301: 02314 02315 double __DUMMY_301; 02316 __label_303: 02317 02318 double __DUMMY_303; 02319 __label_305: 02320 02321 double __DUMMY_305; 02322 __label_307: 02323 02324 double __DUMMY_307; 02325 __label_309: 02326 02327 double __DUMMY_309; 02328 __label_311: 02329 02330 double __DUMMY_311; 02331 __label_313: 02332 02333 double __DUMMY_313; 02334 __label_315: 02335 02336 double __DUMMY_315; 02337 __label_317: 02338 02339 double __DUMMY_317; 02340 __label_319: 02341 02342 double __DUMMY_319; 02343 __label_321: 02344 02345 double __DUMMY_321; 02346 __label_323: 02347 02348 double __DUMMY_323; 02349 __label_325: 02350 02351 double __DUMMY_325; 02352 __label_327: 02353 02354 double __DUMMY_327; 02355 __label_329: 02356 02357 double __DUMMY_329; 02358 __label_331: 02359 02360 double __DUMMY_331; 02361 __label_333: 02362 02363 double __DUMMY_333; 02364 __label_335: 02365 02366 double __DUMMY_335; 02367 __label_337: 02368 02369 double __DUMMY_337; 02370 __label_339: 02371 02372 double __DUMMY_339; 02373 __label_341: 02374 02375 double __DUMMY_341; 02376 __label_343: 02377 02378 double __DUMMY_343; 02379 __label_345: 02380 02381 double __DUMMY_345; 02382 __label_347: 02383 02384 double __DUMMY_347; 02385 __label_349: 02386 02387 double __DUMMY_349; 02388 __label_351: 02389 02390 double __DUMMY_351; 02391 __label_353: 02392 02393 double __DUMMY_353; 02394 __label_355: 02395 02396 double __DUMMY_355; 02397 __label_357: 02398 02399 double __DUMMY_357; 02400 __label_359: 02401 02402 double __DUMMY_359; 02403 __label_361: 02404 02405 double __DUMMY_361; 02406 __label_363: 02407 02408 double __DUMMY_363; 02409 __label_365: 02410 02411 double __DUMMY_365; 02412 __label_367: 02413 02414 double __DUMMY_367; 02415 __label_369: 02416 02417 double __DUMMY_369; 02418 __label_371: 02419 02420 double __DUMMY_371; 02421 __label_373: 02422 02423 double __DUMMY_373; 02424 __label_375: 02425 02426 double __DUMMY_375; 02427 __label_377: 02428 02429 double __DUMMY_377; 02430 __label_379: 02431 02432 double __DUMMY_379; 02433 __label_381: 02434 02435 double __DUMMY_381; 02436 __label_383: 02437 02438 double __DUMMY_383; 02439 __label_385: 02440 02441 double __DUMMY_385; 02442 __label_387: 02443 02444 double __DUMMY_387; 02445 __label_389: 02446 02447 double __DUMMY_389; 02448 __label_391: 02449 02450 double __DUMMY_391; 02451 __label_393: 02452 02453 double __DUMMY_393; 02454 __label_395: 02455 02456 double __DUMMY_395; 02457 __label_397: 02458 02459 double __DUMMY_397; 02460 __label_399: 02461 02462 double __DUMMY_399; 02463 __label_401: 02464 02465 double __DUMMY_401; 02466 __label_403: 02467 02468 double __DUMMY_403; 02469 __label_405: 02470 02471 double __DUMMY_405; 02472 __label_407: 02473 02474 double __DUMMY_407; 02475 __label_409: 02476 02477 double __DUMMY_409; 02478 __label_411: 02479 02480 double __DUMMY_411; 02481 __label_413: 02482 02483 double __DUMMY_413; 02484 __label_415: 02485 02486 double __DUMMY_415; 02487 __label_417: 02488 02489 double __DUMMY_417; 02490 __label_419: 02491 02492 double __DUMMY_419; 02493 __label_421: 02494 02495 double __DUMMY_421; 02496 __label_423: 02497 02498 double __DUMMY_423; 02499 __label_425: 02500 02501 double __DUMMY_425; 02502 __label_427: 02503 02504 double __DUMMY_427; 02505 __label_429: 02506 02507 double __DUMMY_429; 02508 __label_431: 02509 02510 double __DUMMY_431; 02511 __label_433: 02512 02513 double __DUMMY_433; 02514 __label_435: 02515 02516 double __DUMMY_435; 02517 __label_437: 02518 02519 double __DUMMY_437; 02520 __label_439: 02521 02522 double __DUMMY_439; 02523 __label_441: 02524 02525 double __DUMMY_441; 02526 __label_443: 02527 02528 double __DUMMY_443; 02529 __label_445: 02530 02531 double __DUMMY_445; 02532 __label_447: 02533 02534 double __DUMMY_447; 02535 __label_449: 02536 02537 double __DUMMY_449; 02538 __label_451: 02539 02540 double __DUMMY_451; 02541 __label_453: 02542 02543 double __DUMMY_453; 02544 __label_455: 02545 02546 double __DUMMY_455; 02547 __label_457: 02548 02549 double __DUMMY_457; 02550 __label_459: 02551 02552 double __DUMMY_459; 02553 __label_461: 02554 02555 double __DUMMY_461; 02556 __label_463: 02557 02558 double __DUMMY_463; 02559 __label_465: 02560 02561 double __DUMMY_465; 02562 __label_467: 02563 02564 double __DUMMY_467; 02565 __label_469: 02566 02567 double __DUMMY_469; 02568 __label_471: 02569 02570 double __DUMMY_471; 02571 __label_473: 02572 02573 double __DUMMY_473; 02574 __label_475: 02575 02576 double __DUMMY_475; 02577 __label_477: 02578 02579 double __DUMMY_477; 02580 __label_479: 02581 02582 double __DUMMY_479; 02583 __label_481: 02584 02585 double __DUMMY_481; 02586 __label_483: 02587 02588 double __DUMMY_483; 02589 __label_485: 02590 02591 double __DUMMY_485; 02592 __label_487: 02593 02594 double __DUMMY_487; 02595 __label_489: 02596 02597 double __DUMMY_489; 02598 __label_491: 02599 02600 double __DUMMY_491; 02601 __label_493: 02602 02603 double __DUMMY_493; 02604 __label_495: 02605 02606 double __DUMMY_495; 02607 __label_497: 02608 02609 double __DUMMY_497; 02610 __label_499: 02611 02612 double __DUMMY_499; 02613 __label_501: 02614 02615 double __DUMMY_501; 02616 __label_503: 02617 02618 double __DUMMY_503; 02619 __label_505: 02620 02621 double __DUMMY_505; 02622 __label_507: 02623 02624 double __DUMMY_507; 02625 __label_509: 02626 02627 double __DUMMY_509; 02628 __label_511: 02629 02630 double __DUMMY_511; 02631 __label_513: 02632 02633 double __DUMMY_513; 02634 __label_515: 02635 02636 double __DUMMY_515; 02637 __label_517: 02638 02639 double __DUMMY_517; 02640 __label_519: 02641 02642 double __DUMMY_519; 02643 __label_521: 02644 02645 double __DUMMY_521; 02646 __label_523: 02647 02648 double __DUMMY_523; 02649 __label_525: 02650 02651 double __DUMMY_525; 02652 __label_527: 02653 02654 double __DUMMY_527; 02655 __label_529: 02656 02657 double __DUMMY_529; 02658 __label_531: 02659 02660 double __DUMMY_531; 02661 __label_533: 02662 02663 double __DUMMY_533; 02664 __label_535: 02665 02666 double __DUMMY_535; 02667 __label_537: 02668 02669 double __DUMMY_537; 02670 __label_539: 02671 02672 double __DUMMY_539; 02673 __label_541: 02674 02675 double __DUMMY_541; 02676 __label_543: 02677 02678 double __DUMMY_543; 02679 __label_545: 02680 02681 double __DUMMY_545; 02682 __label_547: 02683 02684 double __DUMMY_547; 02685 __label_549: 02686 02687 double __DUMMY_549; 02688 __label_551: 02689 02690 double __DUMMY_551; 02691 __label_553: 02692 02693 double __DUMMY_553; 02694 __label_555: 02695 02696 double __DUMMY_555; 02697 __label_557: 02698 02699 double __DUMMY_557; 02700 __label_559: 02701 02702 double __DUMMY_559; 02703 __label_561: 02704 02705 double __DUMMY_561; 02706 __label_563: 02707 02708 double __DUMMY_563; 02709 __label_565: 02710 02711 double __DUMMY_565; 02712 __label_567: 02713 02714 double __DUMMY_567; 02715 __label_569: 02716 02717 double __DUMMY_569; 02718 __label_571: 02719 02720 double __DUMMY_571; 02721 __label_573: 02722 02723 double __DUMMY_573; 02724 __label_575: 02725 02726 double __DUMMY_575; 02727 __label_577: 02728 02729 double __DUMMY_577; 02730 __label_579: 02731 02732 double __DUMMY_579; 02733 __label_581: 02734 02735 double __DUMMY_581; 02736 __label_583: 02737 02738 double __DUMMY_583; 02739 __label_585: 02740 02741 double __DUMMY_585; 02742 __label_587: 02743 02744 double __DUMMY_587; 02745 __label_589: 02746 02747 double __DUMMY_589; 02748 __label_591: 02749 02750 double __DUMMY_591; 02751 __label_593: 02752 02753 double __DUMMY_593; 02754 __label_595: 02755 02756 double __DUMMY_595; 02757 __label_597: 02758 02759 double __DUMMY_597; 02760 __label_599: 02761 02762 double __DUMMY_599; 02763 __label_601: 02764 02765 double __DUMMY_601; 02766 __label_603: 02767 02768 double __DUMMY_603; 02769 __label_605: 02770 02771 double __DUMMY_605; 02772 __label_607: 02773 02774 double __DUMMY_607; 02775 __label_609: 02776 02777 double __DUMMY_609; 02778 __label_611: 02779 02780 double __DUMMY_611; 02781 __label_613: 02782 02783 double __DUMMY_613; 02784 __label_615: 02785 02786 double __DUMMY_615; 02787 __label_617: 02788 02789 double __DUMMY_617; 02790 __label_619: 02791 02792 double __DUMMY_619; 02793 __label_621: 02794 02795 double __DUMMY_621; 02796 __label_623: 02797 02798 double __DUMMY_623; 02799 __label_625: 02800 02801 double __DUMMY_625; 02802 __label_627: 02803 02804 double __DUMMY_627; 02805 __label_629: 02806 02807 double __DUMMY_629; 02808 __label_631: 02809 02810 double __DUMMY_631; 02811 __label_633: 02812 02813 double __DUMMY_633; 02814 __label_635: 02815 02816 double __DUMMY_635; 02817 __label_637: 02818 02819 double __DUMMY_637; 02820 __label_639: 02821 02822 double __DUMMY_639; 02823 __label_641: 02824 02825 double __DUMMY_641; 02826 __label_643: 02827 02828 double __DUMMY_643; 02829 __label_645: 02830 02831 double __DUMMY_645; 02832 __label_647: 02833 02834 double __DUMMY_647; 02835 __label_649: 02836 02837 double __DUMMY_649; 02838 __label_651: 02839 02840 double __DUMMY_651; 02841 __label_653: 02842 02843 double __DUMMY_653; 02844 __label_655: 02845 02846 double __DUMMY_655; 02847 __label_657: 02848 02849 double __DUMMY_657; 02850 __label_659: 02851 02852 double __DUMMY_659; 02853 __label_661: 02854 02855 double __DUMMY_661; 02856 __label_663: 02857 02858 double __DUMMY_663; 02859 __label_665: 02860 02861 double __DUMMY_665; 02862 __label_667: 02863 02864 double __DUMMY_667; 02865 __label_669: 02866 02867 double __DUMMY_669; 02868 __label_671: 02869 02870 double __DUMMY_671; 02871 __label_673: 02872 02873 double __DUMMY_673; 02874 __label_675: 02875 02876 double __DUMMY_675; 02877 __label_677: 02878 02879 double __DUMMY_677; 02880 __label_679: 02881 02882 double __DUMMY_679; 02883 __label_681: 02884 02885 double __DUMMY_681; 02886 __label_683: 02887 02888 double __DUMMY_683; 02889 __label_685: 02890 02891 double __DUMMY_685; 02892 __label_687: 02893 02894 double __DUMMY_687; 02895 __label_689: 02896 02897 double __DUMMY_689; 02898 __label_691: 02899 02900 double __DUMMY_691; 02901 __label_693: 02902 02903 double __DUMMY_693; 02904 __label_695: 02905 02906 double __DUMMY_695; 02907 __label_697: 02908 02909 double __DUMMY_697; 02910 __label_699: 02911 02912 double __DUMMY_699; 02913 __label_701: 02914 02915 double __DUMMY_701; 02916 __label_703: 02917 02918 double __DUMMY_703; 02919 __label_705: 02920 02921 double __DUMMY_705; 02922 __label_707: 02923 02924 double __DUMMY_707; 02925 __label_709: 02926 02927 double __DUMMY_709; 02928 __label_711: 02929 02930 double __DUMMY_711; 02931 __label_713: 02932 02933 double __DUMMY_713; 02934 __label_715: 02935 02936 double __DUMMY_715; 02937 __label_717: 02938 02939 double __DUMMY_717; 02940 __label_719: 02941 02942 double __DUMMY_719; 02943 __label_721: 02944 02945 double __DUMMY_721; 02946 __label_723: 02947 02948 double __DUMMY_723; 02949 __label_725: 02950 02951 double __DUMMY_725; 02952 __label_727: 02953 02954 double __DUMMY_727; 02955 __label_729: 02956 02957 double __DUMMY_729; 02958 __label_731: 02959 02960 double __DUMMY_731; 02961 __label_733: 02962 02963 double __DUMMY_733; 02964 __label_735: 02965 02966 double __DUMMY_735; 02967 __label_737: 02968 02969 double __DUMMY_737; 02970 __label_739: 02971 02972 double __DUMMY_739; 02973 __label_741: 02974 02975 double __DUMMY_741; 02976 __label_743: 02977 02978 double __DUMMY_743; 02979 __label_745: 02980 02981 double __DUMMY_745; 02982 __label_747: 02983 02984 double __DUMMY_747; 02985 __label_749: 02986 02987 double __DUMMY_749; 02988 __label_751: 02989 02990 double __DUMMY_751; 02991 __label_753: 02992 02993 double __DUMMY_753; 02994 __label_755: 02995 02996 double __DUMMY_755; 02997 __label_757: 02998 02999 double __DUMMY_757; 03000 __label_759: 03001 03002 double __DUMMY_759; 03003 __label_761: 03004 03005 double __DUMMY_761; 03006 __label_763: 03007 03008 double __DUMMY_763; 03009 __label_765: 03010 03011 double __DUMMY_765; 03012 __label_767: 03013 03014 double __DUMMY_767; 03015 __label_769: 03016 03017 double __DUMMY_769; 03018 __label_771: 03019 03020 double __DUMMY_771; 03021 __label_773: 03022 03023 double __DUMMY_773; 03024 __label_775: 03025 03026 double __DUMMY_775; 03027 __label_777: 03028 03029 double __DUMMY_777; 03030 __label_779: 03031 03032 double __DUMMY_779; 03033 __label_781: 03034 03035 double __DUMMY_781; 03036 __label_783: 03037 03038 double __DUMMY_783; 03039 __label_785: 03040 03041 double __DUMMY_785; 03042 __label_787: 03043 03044 double __DUMMY_787; 03045 __label_789: 03046 03047 double __DUMMY_789; 03048 __label_791: 03049 03050 double __DUMMY_791; 03051 __label_793: 03052 03053 double __DUMMY_793; 03054 __label_795: 03055 03056 double __DUMMY_795; 03057 __label_797: 03058 03059 double __DUMMY_797; 03060 __label_799: 03061 03062 double __DUMMY_799; 03063 __label_801: 03064 03065 double __DUMMY_801; 03066 __label_803: 03067 03068 double __DUMMY_803; 03069 __label_805: 03070 03071 double __DUMMY_805; 03072 __label_807: 03073 03074 double __DUMMY_807; 03075 __label_809: 03076 03077 double __DUMMY_809; 03078 __label_811: 03079 03080 double __DUMMY_811; 03081 __label_813: 03082 03083 double __DUMMY_813; 03084 __label_815: 03085 03086 double __DUMMY_815; 03087 __label_817: 03088 03089 double __DUMMY_817; 03090 __label_819: 03091 03092 double __DUMMY_819; 03093 __label_821: 03094 03095 double __DUMMY_821; 03096 __label_823: 03097 03098 double __DUMMY_823; 03099 __label_825: 03100 03101 double __DUMMY_825; 03102 __label_827: 03103 03104 double __DUMMY_827; 03105 __label_829: 03106 03107 double __DUMMY_829; 03108 __label_831: 03109 03110 double __DUMMY_831; 03111 __label_833: 03112 03113 double __DUMMY_833; 03114 __label_835: 03115 03116 double __DUMMY_835; 03117 __label_837: 03118 03119 double __DUMMY_837; 03120 __label_839: 03121 03122 double __DUMMY_839; 03123 __label_841: 03124 03125 double __DUMMY_841; 03126 __label_843: 03127 03128 double __DUMMY_843; 03129 __label_845: 03130 03131 double __DUMMY_845; 03132 __label_847: 03133 03134 double __DUMMY_847; 03135 __label_849: 03136 03137 double __DUMMY_849; 03138 __label_851: 03139 03140 double __DUMMY_851; 03141 __label_853: 03142 03143 double __DUMMY_853; 03144 __label_855: 03145 03146 double __DUMMY_855; 03147 __label_857: 03148 03149 double __DUMMY_857; 03150 __label_859: 03151 03152 double __DUMMY_859; 03153 __label_861: 03154 03155 double __DUMMY_861; 03156 __label_863: 03157 03158 double __DUMMY_863; 03159 __label_865: 03160 03161 double __DUMMY_865; 03162 __label_867: 03163 03164 double __DUMMY_867; 03165 __label_869: 03166 03167 double __DUMMY_869; 03168 __label_871: 03169 03170 double __DUMMY_871; 03171 __label_873: 03172 03173 double __DUMMY_873; 03174 __label_875: 03175 03176 double __DUMMY_875; 03177 __label_877: 03178 03179 double __DUMMY_877; 03180 __label_879: 03181 03182 double __DUMMY_879; 03183 __label_881: 03184 03185 double __DUMMY_881; 03186 __label_883: 03187 03188 double __DUMMY_883; 03189 __label_885: 03190 03191 double __DUMMY_885; 03192 __label_887: 03193 03194 double __DUMMY_887; 03195 __label_889: 03196 03197 double __DUMMY_889; 03198 __label_891: 03199 03200 double __DUMMY_891; 03201 __label_893: 03202 03203 double __DUMMY_893; 03204 __label_895: 03205 03206 double __DUMMY_895; 03207 __label_897: 03208 03209 double __DUMMY_897; 03210 __label_899: 03211 03212 double __DUMMY_899; 03213 __label_901: 03214 03215 double __DUMMY_901; 03216 __label_903: 03217 03218 double __DUMMY_903; 03219 __label_905: 03220 03221 double __DUMMY_905; 03222 __label_907: 03223 03224 double __DUMMY_907; 03225 __label_909: 03226 03227 double __DUMMY_909; 03228 __label_912: 03229 03230 double __DUMMY_912; 03231 03232 Py_XDECREF(this->storage_V3); 03233 Py_XDECREF(this->storage_V5); 03234 Py_XDECREF(this->storage_V7); 03235 Py_XDECREF(this->storage_V9); 03236 Py_XDECREF(this->storage_V11); 03237 Py_XDECREF(this->storage_V13); 03238 Py_XDECREF(this->storage_V15); 03239 Py_XDECREF(this->storage_V17); 03240 Py_XDECREF(this->storage_V19); 03241 Py_XDECREF(this->storage_V21); 03242 Py_XDECREF(this->storage_V23); 03243 Py_XDECREF(this->storage_V25); 03244 Py_XDECREF(this->storage_V27); 03245 Py_XDECREF(this->storage_V29); 03246 Py_XDECREF(this->storage_V31); 03247 Py_XDECREF(this->storage_V33); 03248 Py_XDECREF(this->storage_V35); 03249 Py_XDECREF(this->storage_V37); 03250 Py_XDECREF(this->storage_V39); 03251 Py_XDECREF(this->storage_V41); 03252 Py_XDECREF(this->storage_V43); 03253 Py_XDECREF(this->storage_V45); 03254 Py_XDECREF(this->storage_V47); 03255 Py_XDECREF(this->storage_V49); 03256 Py_XDECREF(this->storage_V51); 03257 Py_XDECREF(this->storage_V53); 03258 Py_XDECREF(this->storage_V55); 03259 Py_XDECREF(this->storage_V57); 03260 Py_XDECREF(this->storage_V59); 03261 Py_XDECREF(this->storage_V61); 03262 Py_XDECREF(this->storage_V63); 03263 Py_XDECREF(this->storage_V65); 03264 Py_XDECREF(this->storage_V67); 03265 Py_XDECREF(this->storage_V69); 03266 Py_XDECREF(this->storage_V71); 03267 Py_XDECREF(this->storage_V73); 03268 Py_XDECREF(this->storage_V75); 03269 Py_XDECREF(this->storage_V77); 03270 Py_XDECREF(this->storage_V79); 03271 Py_XDECREF(this->storage_V81); 03272 Py_XDECREF(this->storage_V83); 03273 Py_XDECREF(this->storage_V85); 03274 Py_XDECREF(this->storage_V87); 03275 Py_XDECREF(this->storage_V89); 03276 Py_XDECREF(this->storage_V91); 03277 Py_XDECREF(this->storage_V93); 03278 Py_XDECREF(this->storage_V95); 03279 Py_XDECREF(this->storage_V97); 03280 Py_XDECREF(this->storage_V99); 03281 Py_XDECREF(this->storage_V101); 03282 Py_XDECREF(this->storage_V103); 03283 Py_XDECREF(this->storage_V105); 03284 Py_XDECREF(this->storage_V107); 03285 Py_XDECREF(this->storage_V109); 03286 Py_XDECREF(this->storage_V111); 03287 Py_XDECREF(this->storage_V113); 03288 Py_XDECREF(this->storage_V115); 03289 Py_XDECREF(this->storage_V117); 03290 Py_XDECREF(this->storage_V119); 03291 Py_XDECREF(this->storage_V121); 03292 Py_XDECREF(this->storage_V123); 03293 Py_XDECREF(this->storage_V125); 03294 Py_XDECREF(this->storage_V127); 03295 Py_XDECREF(this->storage_V129); 03296 Py_XDECREF(this->storage_V131); 03297 Py_XDECREF(this->storage_V133); 03298 Py_XDECREF(this->storage_V135); 03299 Py_XDECREF(this->storage_V137); 03300 Py_XDECREF(this->storage_V139); 03301 Py_XDECREF(this->storage_V141); 03302 Py_XDECREF(this->storage_V143); 03303 Py_XDECREF(this->storage_V145); 03304 Py_XDECREF(this->storage_V147); 03305 Py_XDECREF(this->storage_V149); 03306 Py_XDECREF(this->storage_V151); 03307 Py_XDECREF(this->storage_V153); 03308 Py_XDECREF(this->storage_V155); 03309 Py_XDECREF(this->storage_V157); 03310 Py_XDECREF(this->storage_V159); 03311 Py_XDECREF(this->storage_V161); 03312 Py_XDECREF(this->storage_V163); 03313 Py_XDECREF(this->storage_V165); 03314 Py_XDECREF(this->storage_V167); 03315 Py_XDECREF(this->storage_V169); 03316 Py_XDECREF(this->storage_V171); 03317 Py_XDECREF(this->storage_V173); 03318 Py_XDECREF(this->storage_V175); 03319 Py_XDECREF(this->storage_V177); 03320 Py_XDECREF(this->storage_V179); 03321 Py_XDECREF(this->storage_V181); 03322 Py_XDECREF(this->storage_V183); 03323 Py_XDECREF(this->storage_V185); 03324 Py_XDECREF(this->storage_V187); 03325 Py_XDECREF(this->storage_V189); 03326 Py_XDECREF(this->storage_V191); 03327 Py_XDECREF(this->storage_V193); 03328 Py_XDECREF(this->storage_V195); 03329 Py_XDECREF(this->storage_V197); 03330 Py_XDECREF(this->storage_V199); 03331 Py_XDECREF(this->storage_V201); 03332 Py_XDECREF(this->storage_V203); 03333 Py_XDECREF(this->storage_V205); 03334 Py_XDECREF(this->storage_V207); 03335 Py_XDECREF(this->storage_V209); 03336 Py_XDECREF(this->storage_V211); 03337 Py_XDECREF(this->storage_V213); 03338 Py_XDECREF(this->storage_V215); 03339 Py_XDECREF(this->storage_V217); 03340 Py_XDECREF(this->storage_V219); 03341 Py_XDECREF(this->storage_V221); 03342 Py_XDECREF(this->storage_V223); 03343 Py_XDECREF(this->storage_V225); 03344 Py_XDECREF(this->storage_V227); 03345 Py_XDECREF(this->storage_V229); 03346 Py_XDECREF(this->storage_V231); 03347 Py_XDECREF(this->storage_V233); 03348 Py_XDECREF(this->storage_V235); 03349 Py_XDECREF(this->storage_V237); 03350 Py_XDECREF(this->storage_V239); 03351 Py_XDECREF(this->storage_V241); 03352 Py_XDECREF(this->storage_V243); 03353 Py_XDECREF(this->storage_V245); 03354 Py_XDECREF(this->storage_V247); 03355 Py_XDECREF(this->storage_V249); 03356 Py_XDECREF(this->storage_V251); 03357 Py_XDECREF(this->storage_V253); 03358 Py_XDECREF(this->storage_V255); 03359 Py_XDECREF(this->storage_V257); 03360 Py_XDECREF(this->storage_V259); 03361 Py_XDECREF(this->storage_V261); 03362 Py_XDECREF(this->storage_V263); 03363 Py_XDECREF(this->storage_V265); 03364 Py_XDECREF(this->storage_V267); 03365 Py_XDECREF(this->storage_V269); 03366 Py_XDECREF(this->storage_V271); 03367 Py_XDECREF(this->storage_V273); 03368 Py_XDECREF(this->storage_V275); 03369 Py_XDECREF(this->storage_V277); 03370 Py_XDECREF(this->storage_V279); 03371 Py_XDECREF(this->storage_V281); 03372 Py_XDECREF(this->storage_V283); 03373 Py_XDECREF(this->storage_V285); 03374 Py_XDECREF(this->storage_V287); 03375 Py_XDECREF(this->storage_V289); 03376 Py_XDECREF(this->storage_V291); 03377 Py_XDECREF(this->storage_V293); 03378 Py_XDECREF(this->storage_V295); 03379 Py_XDECREF(this->storage_V297); 03380 Py_XDECREF(this->storage_V299); 03381 Py_XDECREF(this->storage_V301); 03382 Py_XDECREF(this->storage_V303); 03383 Py_XDECREF(this->storage_V305); 03384 Py_XDECREF(this->storage_V307); 03385 Py_XDECREF(this->storage_V309); 03386 Py_XDECREF(this->storage_V311); 03387 Py_XDECREF(this->storage_V313); 03388 Py_XDECREF(this->storage_V315); 03389 Py_XDECREF(this->storage_V317); 03390 Py_XDECREF(this->storage_V319); 03391 Py_XDECREF(this->storage_V321); 03392 Py_XDECREF(this->storage_V323); 03393 Py_XDECREF(this->storage_V325); 03394 Py_XDECREF(this->storage_V327); 03395 Py_XDECREF(this->storage_V329); 03396 Py_XDECREF(this->storage_V331); 03397 Py_XDECREF(this->storage_V333); 03398 Py_XDECREF(this->storage_V335); 03399 Py_XDECREF(this->storage_V337); 03400 Py_XDECREF(this->storage_V339); 03401 Py_XDECREF(this->storage_V341); 03402 Py_XDECREF(this->storage_V343); 03403 Py_XDECREF(this->storage_V345); 03404 Py_XDECREF(this->storage_V347); 03405 Py_XDECREF(this->storage_V349); 03406 Py_XDECREF(this->storage_V351); 03407 Py_XDECREF(this->storage_V353); 03408 Py_XDECREF(this->storage_V355); 03409 Py_XDECREF(this->storage_V357); 03410 Py_XDECREF(this->storage_V359); 03411 Py_XDECREF(this->storage_V361); 03412 Py_XDECREF(this->storage_V363); 03413 Py_XDECREF(this->storage_V365); 03414 Py_XDECREF(this->storage_V367); 03415 Py_XDECREF(this->storage_V369); 03416 Py_XDECREF(this->storage_V371); 03417 Py_XDECREF(this->storage_V373); 03418 Py_XDECREF(this->storage_V375); 03419 Py_XDECREF(this->storage_V377); 03420 Py_XDECREF(this->storage_V379); 03421 Py_XDECREF(this->storage_V381); 03422 Py_XDECREF(this->storage_V383); 03423 Py_XDECREF(this->storage_V385); 03424 Py_XDECREF(this->storage_V387); 03425 Py_XDECREF(this->storage_V389); 03426 Py_XDECREF(this->storage_V391); 03427 Py_XDECREF(this->storage_V393); 03428 Py_XDECREF(this->storage_V395); 03429 Py_XDECREF(this->storage_V397); 03430 Py_XDECREF(this->storage_V399); 03431 Py_XDECREF(this->storage_V401); 03432 Py_XDECREF(this->storage_V403); 03433 Py_XDECREF(this->storage_V405); 03434 Py_XDECREF(this->storage_V407); 03435 Py_XDECREF(this->storage_V409); 03436 Py_XDECREF(this->storage_V411); 03437 Py_XDECREF(this->storage_V413); 03438 Py_XDECREF(this->storage_V415); 03439 Py_XDECREF(this->storage_V417); 03440 Py_XDECREF(this->storage_V419); 03441 Py_XDECREF(this->storage_V421); 03442 Py_XDECREF(this->storage_V423); 03443 Py_XDECREF(this->storage_V425); 03444 Py_XDECREF(this->storage_V427); 03445 Py_XDECREF(this->storage_V429); 03446 Py_XDECREF(this->storage_V431); 03447 Py_XDECREF(this->storage_V433); 03448 Py_XDECREF(this->storage_V435); 03449 Py_XDECREF(this->storage_V437); 03450 Py_XDECREF(this->storage_V439); 03451 Py_XDECREF(this->storage_V441); 03452 Py_XDECREF(this->storage_V443); 03453 Py_XDECREF(this->storage_V445); 03454 Py_XDECREF(this->storage_V447); 03455 Py_XDECREF(this->storage_V449); 03456 Py_XDECREF(this->storage_V451); 03457 Py_XDECREF(this->storage_V453); 03458 Py_XDECREF(this->storage_V455); 03459 Py_XDECREF(this->storage_V457); 03460 Py_XDECREF(this->storage_V459); 03461 Py_XDECREF(this->storage_V461); 03462 Py_XDECREF(this->storage_V463); 03463 Py_XDECREF(this->storage_V465); 03464 Py_XDECREF(this->storage_V467); 03465 Py_XDECREF(this->storage_V469); 03466 Py_XDECREF(this->storage_V471); 03467 Py_XDECREF(this->storage_V473); 03468 Py_XDECREF(this->storage_V475); 03469 Py_XDECREF(this->storage_V477); 03470 Py_XDECREF(this->storage_V479); 03471 Py_XDECREF(this->storage_V481); 03472 Py_XDECREF(this->storage_V483); 03473 Py_XDECREF(this->storage_V485); 03474 Py_XDECREF(this->storage_V487); 03475 Py_XDECREF(this->storage_V489); 03476 Py_XDECREF(this->storage_V491); 03477 Py_XDECREF(this->storage_V493); 03478 Py_XDECREF(this->storage_V495); 03479 Py_XDECREF(this->storage_V497); 03480 Py_XDECREF(this->storage_V499); 03481 Py_XDECREF(this->storage_V501); 03482 Py_XDECREF(this->storage_V503); 03483 Py_XDECREF(this->storage_V505); 03484 Py_XDECREF(this->storage_V507); 03485 Py_XDECREF(this->storage_V509); 03486 Py_XDECREF(this->storage_V511); 03487 Py_XDECREF(this->storage_V513); 03488 Py_XDECREF(this->storage_V515); 03489 Py_XDECREF(this->storage_V517); 03490 Py_XDECREF(this->storage_V519); 03491 Py_XDECREF(this->storage_V521); 03492 Py_XDECREF(this->storage_V523); 03493 Py_XDECREF(this->storage_V525); 03494 Py_XDECREF(this->storage_V527); 03495 Py_XDECREF(this->storage_V529); 03496 Py_XDECREF(this->storage_V531); 03497 Py_XDECREF(this->storage_V533); 03498 Py_XDECREF(this->storage_V535); 03499 Py_XDECREF(this->storage_V537); 03500 Py_XDECREF(this->storage_V539); 03501 Py_XDECREF(this->storage_V541); 03502 Py_XDECREF(this->storage_V543); 03503 Py_XDECREF(this->storage_V545); 03504 Py_XDECREF(this->storage_V547); 03505 Py_XDECREF(this->storage_V549); 03506 Py_XDECREF(this->storage_V551); 03507 Py_XDECREF(this->storage_V553); 03508 Py_XDECREF(this->storage_V555); 03509 Py_XDECREF(this->storage_V557); 03510 Py_XDECREF(this->storage_V559); 03511 Py_XDECREF(this->storage_V561); 03512 Py_XDECREF(this->storage_V563); 03513 Py_XDECREF(this->storage_V565); 03514 Py_XDECREF(this->storage_V567); 03515 Py_XDECREF(this->storage_V569); 03516 Py_XDECREF(this->storage_V571); 03517 Py_XDECREF(this->storage_V573); 03518 Py_XDECREF(this->storage_V575); 03519 Py_XDECREF(this->storage_V577); 03520 Py_XDECREF(this->storage_V579); 03521 Py_XDECREF(this->storage_V581); 03522 Py_XDECREF(this->storage_V583); 03523 Py_XDECREF(this->storage_V585); 03524 Py_XDECREF(this->storage_V587); 03525 Py_XDECREF(this->storage_V589); 03526 Py_XDECREF(this->storage_V591); 03527 Py_XDECREF(this->storage_V593); 03528 Py_XDECREF(this->storage_V595); 03529 Py_XDECREF(this->storage_V597); 03530 Py_XDECREF(this->storage_V599); 03531 Py_XDECREF(this->storage_V601); 03532 Py_XDECREF(this->storage_V603); 03533 Py_XDECREF(this->storage_V605); 03534 Py_XDECREF(this->storage_V607); 03535 Py_XDECREF(this->storage_V609); 03536 Py_XDECREF(this->storage_V611); 03537 Py_XDECREF(this->storage_V613); 03538 Py_XDECREF(this->storage_V615); 03539 Py_XDECREF(this->storage_V617); 03540 Py_XDECREF(this->storage_V619); 03541 Py_XDECREF(this->storage_V621); 03542 Py_XDECREF(this->storage_V623); 03543 Py_XDECREF(this->storage_V625); 03544 Py_XDECREF(this->storage_V627); 03545 Py_XDECREF(this->storage_V629); 03546 Py_XDECREF(this->storage_V631); 03547 Py_XDECREF(this->storage_V633); 03548 Py_XDECREF(this->storage_V635); 03549 Py_XDECREF(this->storage_V637); 03550 Py_XDECREF(this->storage_V639); 03551 Py_XDECREF(this->storage_V641); 03552 Py_XDECREF(this->storage_V643); 03553 Py_XDECREF(this->storage_V645); 03554 Py_XDECREF(this->storage_V647); 03555 Py_XDECREF(this->storage_V649); 03556 Py_XDECREF(this->storage_V651); 03557 Py_XDECREF(this->storage_V653); 03558 Py_XDECREF(this->storage_V655); 03559 Py_XDECREF(this->storage_V657); 03560 Py_XDECREF(this->storage_V659); 03561 Py_XDECREF(this->storage_V661); 03562 Py_XDECREF(this->storage_V663); 03563 Py_XDECREF(this->storage_V665); 03564 Py_XDECREF(this->storage_V667); 03565 Py_XDECREF(this->storage_V669); 03566 Py_XDECREF(this->storage_V671); 03567 Py_XDECREF(this->storage_V673); 03568 Py_XDECREF(this->storage_V675); 03569 Py_XDECREF(this->storage_V677); 03570 Py_XDECREF(this->storage_V679); 03571 Py_XDECREF(this->storage_V681); 03572 Py_XDECREF(this->storage_V683); 03573 Py_XDECREF(this->storage_V685); 03574 Py_XDECREF(this->storage_V687); 03575 Py_XDECREF(this->storage_V689); 03576 Py_XDECREF(this->storage_V691); 03577 Py_XDECREF(this->storage_V693); 03578 Py_XDECREF(this->storage_V695); 03579 Py_XDECREF(this->storage_V697); 03580 Py_XDECREF(this->storage_V699); 03581 Py_XDECREF(this->storage_V701); 03582 Py_XDECREF(this->storage_V703); 03583 Py_XDECREF(this->storage_V705); 03584 Py_XDECREF(this->storage_V707); 03585 Py_XDECREF(this->storage_V709); 03586 Py_XDECREF(this->storage_V711); 03587 Py_XDECREF(this->storage_V713); 03588 Py_XDECREF(this->storage_V715); 03589 Py_XDECREF(this->storage_V717); 03590 Py_XDECREF(this->storage_V719); 03591 Py_XDECREF(this->storage_V721); 03592 Py_XDECREF(this->storage_V723); 03593 Py_XDECREF(this->storage_V725); 03594 Py_XDECREF(this->storage_V727); 03595 Py_XDECREF(this->storage_V729); 03596 Py_XDECREF(this->storage_V731); 03597 Py_XDECREF(this->storage_V733); 03598 Py_XDECREF(this->storage_V735); 03599 Py_XDECREF(this->storage_V737); 03600 Py_XDECREF(this->storage_V739); 03601 Py_XDECREF(this->storage_V741); 03602 Py_XDECREF(this->storage_V743); 03603 Py_XDECREF(this->storage_V745); 03604 Py_XDECREF(this->storage_V747); 03605 Py_XDECREF(this->storage_V749); 03606 Py_XDECREF(this->storage_V751); 03607 Py_XDECREF(this->storage_V753); 03608 Py_XDECREF(this->storage_V755); 03609 Py_XDECREF(this->storage_V757); 03610 Py_XDECREF(this->storage_V759); 03611 Py_XDECREF(this->storage_V761); 03612 Py_XDECREF(this->storage_V763); 03613 Py_XDECREF(this->storage_V765); 03614 Py_XDECREF(this->storage_V767); 03615 Py_XDECREF(this->storage_V769); 03616 Py_XDECREF(this->storage_V771); 03617 Py_XDECREF(this->storage_V773); 03618 Py_XDECREF(this->storage_V775); 03619 Py_XDECREF(this->storage_V777); 03620 Py_XDECREF(this->storage_V779); 03621 Py_XDECREF(this->storage_V781); 03622 Py_XDECREF(this->storage_V783); 03623 Py_XDECREF(this->storage_V785); 03624 Py_XDECREF(this->storage_V787); 03625 Py_XDECREF(this->storage_V789); 03626 Py_XDECREF(this->storage_V791); 03627 Py_XDECREF(this->storage_V793); 03628 Py_XDECREF(this->storage_V795); 03629 Py_XDECREF(this->storage_V797); 03630 Py_XDECREF(this->storage_V799); 03631 Py_XDECREF(this->storage_V801); 03632 Py_XDECREF(this->storage_V803); 03633 Py_XDECREF(this->storage_V805); 03634 Py_XDECREF(this->storage_V807); 03635 Py_XDECREF(this->storage_V809); 03636 Py_XDECREF(this->storage_V811); 03637 Py_XDECREF(this->storage_V813); 03638 Py_XDECREF(this->storage_V815); 03639 Py_XDECREF(this->storage_V817); 03640 Py_XDECREF(this->storage_V819); 03641 Py_XDECREF(this->storage_V821); 03642 Py_XDECREF(this->storage_V823); 03643 Py_XDECREF(this->storage_V825); 03644 Py_XDECREF(this->storage_V827); 03645 Py_XDECREF(this->storage_V829); 03646 Py_XDECREF(this->storage_V831); 03647 Py_XDECREF(this->storage_V833); 03648 Py_XDECREF(this->storage_V835); 03649 Py_XDECREF(this->storage_V837); 03650 Py_XDECREF(this->storage_V839); 03651 Py_XDECREF(this->storage_V841); 03652 Py_XDECREF(this->storage_V843); 03653 Py_XDECREF(this->storage_V845); 03654 Py_XDECREF(this->storage_V847); 03655 Py_XDECREF(this->storage_V849); 03656 Py_XDECREF(this->storage_V851); 03657 Py_XDECREF(this->storage_V853); 03658 Py_XDECREF(this->storage_V855); 03659 Py_XDECREF(this->storage_V857); 03660 Py_XDECREF(this->storage_V859); 03661 Py_XDECREF(this->storage_V861); 03662 Py_XDECREF(this->storage_V863); 03663 Py_XDECREF(this->storage_V865); 03664 Py_XDECREF(this->storage_V867); 03665 Py_XDECREF(this->storage_V869); 03666 Py_XDECREF(this->storage_V871); 03667 Py_XDECREF(this->storage_V873); 03668 Py_XDECREF(this->storage_V875); 03669 Py_XDECREF(this->storage_V877); 03670 Py_XDECREF(this->storage_V879); 03671 Py_XDECREF(this->storage_V881); 03672 Py_XDECREF(this->storage_V883); 03673 Py_XDECREF(this->storage_V885); 03674 Py_XDECREF(this->storage_V887); 03675 Py_XDECREF(this->storage_V889); 03676 Py_XDECREF(this->storage_V891); 03677 Py_XDECREF(this->storage_V893); 03678 Py_XDECREF(this->storage_V895); 03679 Py_XDECREF(this->storage_V897); 03680 Py_XDECREF(this->storage_V899); 03681 Py_XDECREF(this->storage_V901); 03682 Py_XDECREF(this->storage_V903); 03683 Py_XDECREF(this->storage_V905); 03684 Py_XDECREF(this->storage_V907); 03685 Py_XDECREF(this->storage_V909); 03686 Py_XDECREF(this->storage_V1); 03687 } 03688 int run(void) { 03689 int __failure = 0; 03690 03691 PyObject* py_V1; 03692 03693 PyArrayObject* V1; 03694 03695 typedef npy_float64 dtype_V1; 03696 03697 PyObject* py_V3; 03698 03699 PyArrayObject* V3; 03700 03701 typedef npy_float64 dtype_V3; 03702 03703 PyObject* py_V5; 03704 03705 PyArrayObject* V5; 03706 03707 typedef npy_float64 dtype_V5; 03708 03709 PyObject* py_V7; 03710 03711 PyArrayObject* V7; 03712 03713 typedef npy_float64 dtype_V7; 03714 03715 PyObject* py_V9; 03716 03717 PyArrayObject* V9; 03718 03719 typedef npy_float64 dtype_V9; 03720 03721 PyObject* py_V11; 03722 03723 PyArrayObject* V11; 03724 03725 typedef npy_float64 dtype_V11; 03726 03727 PyObject* py_V13; 03728 03729 PyArrayObject* V13; 03730 03731 typedef npy_float64 dtype_V13; 03732 03733 PyObject* py_V15; 03734 03735 PyArrayObject* V15; 03736 03737 typedef npy_float64 dtype_V15; 03738 03739 PyObject* py_V17; 03740 03741 PyArrayObject* V17; 03742 03743 typedef npy_float64 dtype_V17; 03744 03745 PyObject* py_V19; 03746 03747 PyArrayObject* V19; 03748 03749 typedef npy_float64 dtype_V19; 03750 03751 PyObject* py_V21; 03752 03753 PyArrayObject* V21; 03754 03755 typedef npy_float64 dtype_V21; 03756 03757 PyObject* py_V23; 03758 03759 PyArrayObject* V23; 03760 03761 typedef npy_float64 dtype_V23; 03762 03763 PyObject* py_V25; 03764 03765 PyArrayObject* V25; 03766 03767 typedef npy_float64 dtype_V25; 03768 03769 PyObject* py_V27; 03770 03771 PyArrayObject* V27; 03772 03773 typedef npy_float64 dtype_V27; 03774 03775 PyObject* py_V29; 03776 03777 PyArrayObject* V29; 03778 03779 typedef npy_float64 dtype_V29; 03780 03781 PyObject* py_V31; 03782 03783 PyArrayObject* V31; 03784 03785 typedef npy_float64 dtype_V31; 03786 03787 PyObject* py_V33; 03788 03789 PyArrayObject* V33; 03790 03791 typedef npy_float64 dtype_V33; 03792 03793 PyObject* py_V35; 03794 03795 PyArrayObject* V35; 03796 03797 typedef npy_float64 dtype_V35; 03798 03799 PyObject* py_V37; 03800 03801 PyArrayObject* V37; 03802 03803 typedef npy_float64 dtype_V37; 03804 03805 PyObject* py_V39; 03806 03807 PyArrayObject* V39; 03808 03809 typedef npy_float64 dtype_V39; 03810 03811 PyObject* py_V41; 03812 03813 PyArrayObject* V41; 03814 03815 typedef npy_float64 dtype_V41; 03816 03817 PyObject* py_V43; 03818 03819 PyArrayObject* V43; 03820 03821 typedef npy_float64 dtype_V43; 03822 03823 PyObject* py_V45; 03824 03825 PyArrayObject* V45; 03826 03827 typedef npy_float64 dtype_V45; 03828 03829 PyObject* py_V47; 03830 03831 PyArrayObject* V47; 03832 03833 typedef npy_float64 dtype_V47; 03834 03835 PyObject* py_V49; 03836 03837 PyArrayObject* V49; 03838 03839 typedef npy_float64 dtype_V49; 03840 03841 PyObject* py_V51; 03842 03843 PyArrayObject* V51; 03844 03845 typedef npy_float64 dtype_V51; 03846 03847 PyObject* py_V53; 03848 03849 PyArrayObject* V53; 03850 03851 typedef npy_float64 dtype_V53; 03852 03853 PyObject* py_V55; 03854 03855 PyArrayObject* V55; 03856 03857 typedef npy_float64 dtype_V55; 03858 03859 PyObject* py_V57; 03860 03861 PyArrayObject* V57; 03862 03863 typedef npy_float64 dtype_V57; 03864 03865 PyObject* py_V59; 03866 03867 PyArrayObject* V59; 03868 03869 typedef npy_float64 dtype_V59; 03870 03871 PyObject* py_V61; 03872 03873 PyArrayObject* V61; 03874 03875 typedef npy_float64 dtype_V61; 03876 03877 PyObject* py_V63; 03878 03879 PyArrayObject* V63; 03880 03881 typedef npy_float64 dtype_V63; 03882 03883 PyObject* py_V65; 03884 03885 PyArrayObject* V65; 03886 03887 typedef npy_float64 dtype_V65; 03888 03889 PyObject* py_V67; 03890 03891 PyArrayObject* V67; 03892 03893 typedef npy_float64 dtype_V67; 03894 03895 PyObject* py_V69; 03896 03897 PyArrayObject* V69; 03898 03899 typedef npy_float64 dtype_V69; 03900 03901 PyObject* py_V71; 03902 03903 PyArrayObject* V71; 03904 03905 typedef npy_float64 dtype_V71; 03906 03907 PyObject* py_V73; 03908 03909 PyArrayObject* V73; 03910 03911 typedef npy_float64 dtype_V73; 03912 03913 PyObject* py_V75; 03914 03915 PyArrayObject* V75; 03916 03917 typedef npy_float64 dtype_V75; 03918 03919 PyObject* py_V77; 03920 03921 PyArrayObject* V77; 03922 03923 typedef npy_float64 dtype_V77; 03924 03925 PyObject* py_V79; 03926 03927 PyArrayObject* V79; 03928 03929 typedef npy_float64 dtype_V79; 03930 03931 PyObject* py_V81; 03932 03933 PyArrayObject* V81; 03934 03935 typedef npy_float64 dtype_V81; 03936 03937 PyObject* py_V83; 03938 03939 PyArrayObject* V83; 03940 03941 typedef npy_float64 dtype_V83; 03942 03943 PyObject* py_V85; 03944 03945 PyArrayObject* V85; 03946 03947 typedef npy_float64 dtype_V85; 03948 03949 PyObject* py_V87; 03950 03951 PyArrayObject* V87; 03952 03953 typedef npy_float64 dtype_V87; 03954 03955 PyObject* py_V89; 03956 03957 PyArrayObject* V89; 03958 03959 typedef npy_float64 dtype_V89; 03960 03961 PyObject* py_V91; 03962 03963 PyArrayObject* V91; 03964 03965 typedef npy_float64 dtype_V91; 03966 03967 PyObject* py_V93; 03968 03969 PyArrayObject* V93; 03970 03971 typedef npy_float64 dtype_V93; 03972 03973 PyObject* py_V95; 03974 03975 PyArrayObject* V95; 03976 03977 typedef npy_float64 dtype_V95; 03978 03979 PyObject* py_V97; 03980 03981 PyArrayObject* V97; 03982 03983 typedef npy_float64 dtype_V97; 03984 03985 PyObject* py_V99; 03986 03987 PyArrayObject* V99; 03988 03989 typedef npy_float64 dtype_V99; 03990 03991 PyObject* py_V101; 03992 03993 PyArrayObject* V101; 03994 03995 typedef npy_float64 dtype_V101; 03996 03997 PyObject* py_V103; 03998 03999 PyArrayObject* V103; 04000 04001 typedef npy_float64 dtype_V103; 04002 04003 PyObject* py_V105; 04004 04005 PyArrayObject* V105; 04006 04007 typedef npy_float64 dtype_V105; 04008 04009 PyObject* py_V107; 04010 04011 PyArrayObject* V107; 04012 04013 typedef npy_float64 dtype_V107; 04014 04015 PyObject* py_V109; 04016 04017 PyArrayObject* V109; 04018 04019 typedef npy_float64 dtype_V109; 04020 04021 PyObject* py_V111; 04022 04023 PyArrayObject* V111; 04024 04025 typedef npy_float64 dtype_V111; 04026 04027 PyObject* py_V113; 04028 04029 PyArrayObject* V113; 04030 04031 typedef npy_float64 dtype_V113; 04032 04033 PyObject* py_V115; 04034 04035 PyArrayObject* V115; 04036 04037 typedef npy_float64 dtype_V115; 04038 04039 PyObject* py_V117; 04040 04041 PyArrayObject* V117; 04042 04043 typedef npy_float64 dtype_V117; 04044 04045 PyObject* py_V119; 04046 04047 PyArrayObject* V119; 04048 04049 typedef npy_float64 dtype_V119; 04050 04051 PyObject* py_V121; 04052 04053 PyArrayObject* V121; 04054 04055 typedef npy_float64 dtype_V121; 04056 04057 PyObject* py_V123; 04058 04059 PyArrayObject* V123; 04060 04061 typedef npy_float64 dtype_V123; 04062 04063 PyObject* py_V125; 04064 04065 PyArrayObject* V125; 04066 04067 typedef npy_float64 dtype_V125; 04068 04069 PyObject* py_V127; 04070 04071 PyArrayObject* V127; 04072 04073 typedef npy_float64 dtype_V127; 04074 04075 PyObject* py_V129; 04076 04077 PyArrayObject* V129; 04078 04079 typedef npy_float64 dtype_V129; 04080 04081 PyObject* py_V131; 04082 04083 PyArrayObject* V131; 04084 04085 typedef npy_float64 dtype_V131; 04086 04087 PyObject* py_V133; 04088 04089 PyArrayObject* V133; 04090 04091 typedef npy_float64 dtype_V133; 04092 04093 PyObject* py_V135; 04094 04095 PyArrayObject* V135; 04096 04097 typedef npy_float64 dtype_V135; 04098 04099 PyObject* py_V137; 04100 04101 PyArrayObject* V137; 04102 04103 typedef npy_float64 dtype_V137; 04104 04105 PyObject* py_V139; 04106 04107 PyArrayObject* V139; 04108 04109 typedef npy_float64 dtype_V139; 04110 04111 PyObject* py_V141; 04112 04113 PyArrayObject* V141; 04114 04115 typedef npy_float64 dtype_V141; 04116 04117 PyObject* py_V143; 04118 04119 PyArrayObject* V143; 04120 04121 typedef npy_float64 dtype_V143; 04122 04123 PyObject* py_V145; 04124 04125 PyArrayObject* V145; 04126 04127 typedef npy_float64 dtype_V145; 04128 04129 PyObject* py_V147; 04130 04131 PyArrayObject* V147; 04132 04133 typedef npy_float64 dtype_V147; 04134 04135 PyObject* py_V149; 04136 04137 PyArrayObject* V149; 04138 04139 typedef npy_float64 dtype_V149; 04140 04141 PyObject* py_V151; 04142 04143 PyArrayObject* V151; 04144 04145 typedef npy_float64 dtype_V151; 04146 04147 PyObject* py_V153; 04148 04149 PyArrayObject* V153; 04150 04151 typedef npy_float64 dtype_V153; 04152 04153 PyObject* py_V155; 04154 04155 PyArrayObject* V155; 04156 04157 typedef npy_float64 dtype_V155; 04158 04159 PyObject* py_V157; 04160 04161 PyArrayObject* V157; 04162 04163 typedef npy_float64 dtype_V157; 04164 04165 PyObject* py_V159; 04166 04167 PyArrayObject* V159; 04168 04169 typedef npy_float64 dtype_V159; 04170 04171 PyObject* py_V161; 04172 04173 PyArrayObject* V161; 04174 04175 typedef npy_float64 dtype_V161; 04176 04177 PyObject* py_V163; 04178 04179 PyArrayObject* V163; 04180 04181 typedef npy_float64 dtype_V163; 04182 04183 PyObject* py_V165; 04184 04185 PyArrayObject* V165; 04186 04187 typedef npy_float64 dtype_V165; 04188 04189 PyObject* py_V167; 04190 04191 PyArrayObject* V167; 04192 04193 typedef npy_float64 dtype_V167; 04194 04195 PyObject* py_V169; 04196 04197 PyArrayObject* V169; 04198 04199 typedef npy_float64 dtype_V169; 04200 04201 PyObject* py_V171; 04202 04203 PyArrayObject* V171; 04204 04205 typedef npy_float64 dtype_V171; 04206 04207 PyObject* py_V173; 04208 04209 PyArrayObject* V173; 04210 04211 typedef npy_float64 dtype_V173; 04212 04213 PyObject* py_V175; 04214 04215 PyArrayObject* V175; 04216 04217 typedef npy_float64 dtype_V175; 04218 04219 PyObject* py_V177; 04220 04221 PyArrayObject* V177; 04222 04223 typedef npy_float64 dtype_V177; 04224 04225 PyObject* py_V179; 04226 04227 PyArrayObject* V179; 04228 04229 typedef npy_float64 dtype_V179; 04230 04231 PyObject* py_V181; 04232 04233 PyArrayObject* V181; 04234 04235 typedef npy_float64 dtype_V181; 04236 04237 PyObject* py_V183; 04238 04239 PyArrayObject* V183; 04240 04241 typedef npy_float64 dtype_V183; 04242 04243 PyObject* py_V185; 04244 04245 PyArrayObject* V185; 04246 04247 typedef npy_float64 dtype_V185; 04248 04249 PyObject* py_V187; 04250 04251 PyArrayObject* V187; 04252 04253 typedef npy_float64 dtype_V187; 04254 04255 PyObject* py_V189; 04256 04257 PyArrayObject* V189; 04258 04259 typedef npy_float64 dtype_V189; 04260 04261 PyObject* py_V191; 04262 04263 PyArrayObject* V191; 04264 04265 typedef npy_float64 dtype_V191; 04266 04267 PyObject* py_V193; 04268 04269 PyArrayObject* V193; 04270 04271 typedef npy_float64 dtype_V193; 04272 04273 PyObject* py_V195; 04274 04275 PyArrayObject* V195; 04276 04277 typedef npy_float64 dtype_V195; 04278 04279 PyObject* py_V197; 04280 04281 PyArrayObject* V197; 04282 04283 typedef npy_float64 dtype_V197; 04284 04285 PyObject* py_V199; 04286 04287 PyArrayObject* V199; 04288 04289 typedef npy_float64 dtype_V199; 04290 04291 PyObject* py_V201; 04292 04293 PyArrayObject* V201; 04294 04295 typedef npy_float64 dtype_V201; 04296 04297 PyObject* py_V203; 04298 04299 PyArrayObject* V203; 04300 04301 typedef npy_float64 dtype_V203; 04302 04303 PyObject* py_V205; 04304 04305 PyArrayObject* V205; 04306 04307 typedef npy_float64 dtype_V205; 04308 04309 PyObject* py_V207; 04310 04311 PyArrayObject* V207; 04312 04313 typedef npy_float64 dtype_V207; 04314 04315 PyObject* py_V209; 04316 04317 PyArrayObject* V209; 04318 04319 typedef npy_float64 dtype_V209; 04320 04321 PyObject* py_V211; 04322 04323 PyArrayObject* V211; 04324 04325 typedef npy_float64 dtype_V211; 04326 04327 PyObject* py_V213; 04328 04329 PyArrayObject* V213; 04330 04331 typedef npy_float64 dtype_V213; 04332 04333 PyObject* py_V215; 04334 04335 PyArrayObject* V215; 04336 04337 typedef npy_float64 dtype_V215; 04338 04339 PyObject* py_V217; 04340 04341 PyArrayObject* V217; 04342 04343 typedef npy_float64 dtype_V217; 04344 04345 PyObject* py_V219; 04346 04347 PyArrayObject* V219; 04348 04349 typedef npy_float64 dtype_V219; 04350 04351 PyObject* py_V221; 04352 04353 PyArrayObject* V221; 04354 04355 typedef npy_float64 dtype_V221; 04356 04357 PyObject* py_V223; 04358 04359 PyArrayObject* V223; 04360 04361 typedef npy_float64 dtype_V223; 04362 04363 PyObject* py_V225; 04364 04365 PyArrayObject* V225; 04366 04367 typedef npy_float64 dtype_V225; 04368 04369 PyObject* py_V227; 04370 04371 PyArrayObject* V227; 04372 04373 typedef npy_float64 dtype_V227; 04374 04375 PyObject* py_V229; 04376 04377 PyArrayObject* V229; 04378 04379 typedef npy_float64 dtype_V229; 04380 04381 PyObject* py_V231; 04382 04383 PyArrayObject* V231; 04384 04385 typedef npy_float64 dtype_V231; 04386 04387 PyObject* py_V233; 04388 04389 PyArrayObject* V233; 04390 04391 typedef npy_float64 dtype_V233; 04392 04393 PyObject* py_V235; 04394 04395 PyArrayObject* V235; 04396 04397 typedef npy_float64 dtype_V235; 04398 04399 PyObject* py_V237; 04400 04401 PyArrayObject* V237; 04402 04403 typedef npy_float64 dtype_V237; 04404 04405 PyObject* py_V239; 04406 04407 PyArrayObject* V239; 04408 04409 typedef npy_float64 dtype_V239; 04410 04411 PyObject* py_V241; 04412 04413 PyArrayObject* V241; 04414 04415 typedef npy_float64 dtype_V241; 04416 04417 PyObject* py_V243; 04418 04419 PyArrayObject* V243; 04420 04421 typedef npy_float64 dtype_V243; 04422 04423 PyObject* py_V245; 04424 04425 PyArrayObject* V245; 04426 04427 typedef npy_float64 dtype_V245; 04428 04429 PyObject* py_V247; 04430 04431 PyArrayObject* V247; 04432 04433 typedef npy_float64 dtype_V247; 04434 04435 PyObject* py_V249; 04436 04437 PyArrayObject* V249; 04438 04439 typedef npy_float64 dtype_V249; 04440 04441 PyObject* py_V251; 04442 04443 PyArrayObject* V251; 04444 04445 typedef npy_float64 dtype_V251; 04446 04447 PyObject* py_V253; 04448 04449 PyArrayObject* V253; 04450 04451 typedef npy_float64 dtype_V253; 04452 04453 PyObject* py_V255; 04454 04455 PyArrayObject* V255; 04456 04457 typedef npy_float64 dtype_V255; 04458 04459 PyObject* py_V257; 04460 04461 PyArrayObject* V257; 04462 04463 typedef npy_float64 dtype_V257; 04464 04465 PyObject* py_V259; 04466 04467 PyArrayObject* V259; 04468 04469 typedef npy_float64 dtype_V259; 04470 04471 PyObject* py_V261; 04472 04473 PyArrayObject* V261; 04474 04475 typedef npy_float64 dtype_V261; 04476 04477 PyObject* py_V263; 04478 04479 PyArrayObject* V263; 04480 04481 typedef npy_float64 dtype_V263; 04482 04483 PyObject* py_V265; 04484 04485 PyArrayObject* V265; 04486 04487 typedef npy_float64 dtype_V265; 04488 04489 PyObject* py_V267; 04490 04491 PyArrayObject* V267; 04492 04493 typedef npy_float64 dtype_V267; 04494 04495 PyObject* py_V269; 04496 04497 PyArrayObject* V269; 04498 04499 typedef npy_float64 dtype_V269; 04500 04501 PyObject* py_V271; 04502 04503 PyArrayObject* V271; 04504 04505 typedef npy_float64 dtype_V271; 04506 04507 PyObject* py_V273; 04508 04509 PyArrayObject* V273; 04510 04511 typedef npy_float64 dtype_V273; 04512 04513 PyObject* py_V275; 04514 04515 PyArrayObject* V275; 04516 04517 typedef npy_float64 dtype_V275; 04518 04519 PyObject* py_V277; 04520 04521 PyArrayObject* V277; 04522 04523 typedef npy_float64 dtype_V277; 04524 04525 PyObject* py_V279; 04526 04527 PyArrayObject* V279; 04528 04529 typedef npy_float64 dtype_V279; 04530 04531 PyObject* py_V281; 04532 04533 PyArrayObject* V281; 04534 04535 typedef npy_float64 dtype_V281; 04536 04537 PyObject* py_V283; 04538 04539 PyArrayObject* V283; 04540 04541 typedef npy_float64 dtype_V283; 04542 04543 PyObject* py_V285; 04544 04545 PyArrayObject* V285; 04546 04547 typedef npy_float64 dtype_V285; 04548 04549 PyObject* py_V287; 04550 04551 PyArrayObject* V287; 04552 04553 typedef npy_float64 dtype_V287; 04554 04555 PyObject* py_V289; 04556 04557 PyArrayObject* V289; 04558 04559 typedef npy_float64 dtype_V289; 04560 04561 PyObject* py_V291; 04562 04563 PyArrayObject* V291; 04564 04565 typedef npy_float64 dtype_V291; 04566 04567 PyObject* py_V293; 04568 04569 PyArrayObject* V293; 04570 04571 typedef npy_float64 dtype_V293; 04572 04573 PyObject* py_V295; 04574 04575 PyArrayObject* V295; 04576 04577 typedef npy_float64 dtype_V295; 04578 04579 PyObject* py_V297; 04580 04581 PyArrayObject* V297; 04582 04583 typedef npy_float64 dtype_V297; 04584 04585 PyObject* py_V299; 04586 04587 PyArrayObject* V299; 04588 04589 typedef npy_float64 dtype_V299; 04590 04591 PyObject* py_V301; 04592 04593 PyArrayObject* V301; 04594 04595 typedef npy_float64 dtype_V301; 04596 04597 PyObject* py_V303; 04598 04599 PyArrayObject* V303; 04600 04601 typedef npy_float64 dtype_V303; 04602 04603 PyObject* py_V305; 04604 04605 PyArrayObject* V305; 04606 04607 typedef npy_float64 dtype_V305; 04608 04609 PyObject* py_V307; 04610 04611 PyArrayObject* V307; 04612 04613 typedef npy_float64 dtype_V307; 04614 04615 PyObject* py_V309; 04616 04617 PyArrayObject* V309; 04618 04619 typedef npy_float64 dtype_V309; 04620 04621 PyObject* py_V311; 04622 04623 PyArrayObject* V311; 04624 04625 typedef npy_float64 dtype_V311; 04626 04627 PyObject* py_V313; 04628 04629 PyArrayObject* V313; 04630 04631 typedef npy_float64 dtype_V313; 04632 04633 PyObject* py_V315; 04634 04635 PyArrayObject* V315; 04636 04637 typedef npy_float64 dtype_V315; 04638 04639 PyObject* py_V317; 04640 04641 PyArrayObject* V317; 04642 04643 typedef npy_float64 dtype_V317; 04644 04645 PyObject* py_V319; 04646 04647 PyArrayObject* V319; 04648 04649 typedef npy_float64 dtype_V319; 04650 04651 PyObject* py_V321; 04652 04653 PyArrayObject* V321; 04654 04655 typedef npy_float64 dtype_V321; 04656 04657 PyObject* py_V323; 04658 04659 PyArrayObject* V323; 04660 04661 typedef npy_float64 dtype_V323; 04662 04663 PyObject* py_V325; 04664 04665 PyArrayObject* V325; 04666 04667 typedef npy_float64 dtype_V325; 04668 04669 PyObject* py_V327; 04670 04671 PyArrayObject* V327; 04672 04673 typedef npy_float64 dtype_V327; 04674 04675 PyObject* py_V329; 04676 04677 PyArrayObject* V329; 04678 04679 typedef npy_float64 dtype_V329; 04680 04681 PyObject* py_V331; 04682 04683 PyArrayObject* V331; 04684 04685 typedef npy_float64 dtype_V331; 04686 04687 PyObject* py_V333; 04688 04689 PyArrayObject* V333; 04690 04691 typedef npy_float64 dtype_V333; 04692 04693 PyObject* py_V335; 04694 04695 PyArrayObject* V335; 04696 04697 typedef npy_float64 dtype_V335; 04698 04699 PyObject* py_V337; 04700 04701 PyArrayObject* V337; 04702 04703 typedef npy_float64 dtype_V337; 04704 04705 PyObject* py_V339; 04706 04707 PyArrayObject* V339; 04708 04709 typedef npy_float64 dtype_V339; 04710 04711 PyObject* py_V341; 04712 04713 PyArrayObject* V341; 04714 04715 typedef npy_float64 dtype_V341; 04716 04717 PyObject* py_V343; 04718 04719 PyArrayObject* V343; 04720 04721 typedef npy_float64 dtype_V343; 04722 04723 PyObject* py_V345; 04724 04725 PyArrayObject* V345; 04726 04727 typedef npy_float64 dtype_V345; 04728 04729 PyObject* py_V347; 04730 04731 PyArrayObject* V347; 04732 04733 typedef npy_float64 dtype_V347; 04734 04735 PyObject* py_V349; 04736 04737 PyArrayObject* V349; 04738 04739 typedef npy_float64 dtype_V349; 04740 04741 PyObject* py_V351; 04742 04743 PyArrayObject* V351; 04744 04745 typedef npy_float64 dtype_V351; 04746 04747 PyObject* py_V353; 04748 04749 PyArrayObject* V353; 04750 04751 typedef npy_float64 dtype_V353; 04752 04753 PyObject* py_V355; 04754 04755 PyArrayObject* V355; 04756 04757 typedef npy_float64 dtype_V355; 04758 04759 PyObject* py_V357; 04760 04761 PyArrayObject* V357; 04762 04763 typedef npy_float64 dtype_V357; 04764 04765 PyObject* py_V359; 04766 04767 PyArrayObject* V359; 04768 04769 typedef npy_float64 dtype_V359; 04770 04771 PyObject* py_V361; 04772 04773 PyArrayObject* V361; 04774 04775 typedef npy_float64 dtype_V361; 04776 04777 PyObject* py_V363; 04778 04779 PyArrayObject* V363; 04780 04781 typedef npy_float64 dtype_V363; 04782 04783 PyObject* py_V365; 04784 04785 PyArrayObject* V365; 04786 04787 typedef npy_float64 dtype_V365; 04788 04789 PyObject* py_V367; 04790 04791 PyArrayObject* V367; 04792 04793 typedef npy_float64 dtype_V367; 04794 04795 PyObject* py_V369; 04796 04797 PyArrayObject* V369; 04798 04799 typedef npy_float64 dtype_V369; 04800 04801 PyObject* py_V371; 04802 04803 PyArrayObject* V371; 04804 04805 typedef npy_float64 dtype_V371; 04806 04807 PyObject* py_V373; 04808 04809 PyArrayObject* V373; 04810 04811 typedef npy_float64 dtype_V373; 04812 04813 PyObject* py_V375; 04814 04815 PyArrayObject* V375; 04816 04817 typedef npy_float64 dtype_V375; 04818 04819 PyObject* py_V377; 04820 04821 PyArrayObject* V377; 04822 04823 typedef npy_float64 dtype_V377; 04824 04825 PyObject* py_V379; 04826 04827 PyArrayObject* V379; 04828 04829 typedef npy_float64 dtype_V379; 04830 04831 PyObject* py_V381; 04832 04833 PyArrayObject* V381; 04834 04835 typedef npy_float64 dtype_V381; 04836 04837 PyObject* py_V383; 04838 04839 PyArrayObject* V383; 04840 04841 typedef npy_float64 dtype_V383; 04842 04843 PyObject* py_V385; 04844 04845 PyArrayObject* V385; 04846 04847 typedef npy_float64 dtype_V385; 04848 04849 PyObject* py_V387; 04850 04851 PyArrayObject* V387; 04852 04853 typedef npy_float64 dtype_V387; 04854 04855 PyObject* py_V389; 04856 04857 PyArrayObject* V389; 04858 04859 typedef npy_float64 dtype_V389; 04860 04861 PyObject* py_V391; 04862 04863 PyArrayObject* V391; 04864 04865 typedef npy_float64 dtype_V391; 04866 04867 PyObject* py_V393; 04868 04869 PyArrayObject* V393; 04870 04871 typedef npy_float64 dtype_V393; 04872 04873 PyObject* py_V395; 04874 04875 PyArrayObject* V395; 04876 04877 typedef npy_float64 dtype_V395; 04878 04879 PyObject* py_V397; 04880 04881 PyArrayObject* V397; 04882 04883 typedef npy_float64 dtype_V397; 04884 04885 PyObject* py_V399; 04886 04887 PyArrayObject* V399; 04888 04889 typedef npy_float64 dtype_V399; 04890 04891 PyObject* py_V401; 04892 04893 PyArrayObject* V401; 04894 04895 typedef npy_float64 dtype_V401; 04896 04897 PyObject* py_V403; 04898 04899 PyArrayObject* V403; 04900 04901 typedef npy_float64 dtype_V403; 04902 04903 PyObject* py_V405; 04904 04905 PyArrayObject* V405; 04906 04907 typedef npy_float64 dtype_V405; 04908 04909 PyObject* py_V407; 04910 04911 PyArrayObject* V407; 04912 04913 typedef npy_float64 dtype_V407; 04914 04915 PyObject* py_V409; 04916 04917 PyArrayObject* V409; 04918 04919 typedef npy_float64 dtype_V409; 04920 04921 PyObject* py_V411; 04922 04923 PyArrayObject* V411; 04924 04925 typedef npy_float64 dtype_V411; 04926 04927 PyObject* py_V413; 04928 04929 PyArrayObject* V413; 04930 04931 typedef npy_float64 dtype_V413; 04932 04933 PyObject* py_V415; 04934 04935 PyArrayObject* V415; 04936 04937 typedef npy_float64 dtype_V415; 04938 04939 PyObject* py_V417; 04940 04941 PyArrayObject* V417; 04942 04943 typedef npy_float64 dtype_V417; 04944 04945 PyObject* py_V419; 04946 04947 PyArrayObject* V419; 04948 04949 typedef npy_float64 dtype_V419; 04950 04951 PyObject* py_V421; 04952 04953 PyArrayObject* V421; 04954 04955 typedef npy_float64 dtype_V421; 04956 04957 PyObject* py_V423; 04958 04959 PyArrayObject* V423; 04960 04961 typedef npy_float64 dtype_V423; 04962 04963 PyObject* py_V425; 04964 04965 PyArrayObject* V425; 04966 04967 typedef npy_float64 dtype_V425; 04968 04969 PyObject* py_V427; 04970 04971 PyArrayObject* V427; 04972 04973 typedef npy_float64 dtype_V427; 04974 04975 PyObject* py_V429; 04976 04977 PyArrayObject* V429; 04978 04979 typedef npy_float64 dtype_V429; 04980 04981 PyObject* py_V431; 04982 04983 PyArrayObject* V431; 04984 04985 typedef npy_float64 dtype_V431; 04986 04987 PyObject* py_V433; 04988 04989 PyArrayObject* V433; 04990 04991 typedef npy_float64 dtype_V433; 04992 04993 PyObject* py_V435; 04994 04995 PyArrayObject* V435; 04996 04997 typedef npy_float64 dtype_V435; 04998 04999 PyObject* py_V437; 05000 05001 PyArrayObject* V437; 05002 05003 typedef npy_float64 dtype_V437; 05004 05005 PyObject* py_V439; 05006 05007 PyArrayObject* V439; 05008 05009 typedef npy_float64 dtype_V439; 05010 05011 PyObject* py_V441; 05012 05013 PyArrayObject* V441; 05014 05015 typedef npy_float64 dtype_V441; 05016 05017 PyObject* py_V443; 05018 05019 PyArrayObject* V443; 05020 05021 typedef npy_float64 dtype_V443; 05022 05023 PyObject* py_V445; 05024 05025 PyArrayObject* V445; 05026 05027 typedef npy_float64 dtype_V445; 05028 05029 PyObject* py_V447; 05030 05031 PyArrayObject* V447; 05032 05033 typedef npy_float64 dtype_V447; 05034 05035 PyObject* py_V449; 05036 05037 PyArrayObject* V449; 05038 05039 typedef npy_float64 dtype_V449; 05040 05041 PyObject* py_V451; 05042 05043 PyArrayObject* V451; 05044 05045 typedef npy_float64 dtype_V451; 05046 05047 PyObject* py_V453; 05048 05049 PyArrayObject* V453; 05050 05051 typedef npy_float64 dtype_V453; 05052 05053 PyObject* py_V455; 05054 05055 PyArrayObject* V455; 05056 05057 typedef npy_float64 dtype_V455; 05058 05059 PyObject* py_V457; 05060 05061 PyArrayObject* V457; 05062 05063 typedef npy_float64 dtype_V457; 05064 05065 PyObject* py_V459; 05066 05067 PyArrayObject* V459; 05068 05069 typedef npy_float64 dtype_V459; 05070 05071 PyObject* py_V461; 05072 05073 PyArrayObject* V461; 05074 05075 typedef npy_float64 dtype_V461; 05076 05077 PyObject* py_V463; 05078 05079 PyArrayObject* V463; 05080 05081 typedef npy_float64 dtype_V463; 05082 05083 PyObject* py_V465; 05084 05085 PyArrayObject* V465; 05086 05087 typedef npy_float64 dtype_V465; 05088 05089 PyObject* py_V467; 05090 05091 PyArrayObject* V467; 05092 05093 typedef npy_float64 dtype_V467; 05094 05095 PyObject* py_V469; 05096 05097 PyArrayObject* V469; 05098 05099 typedef npy_float64 dtype_V469; 05100 05101 PyObject* py_V471; 05102 05103 PyArrayObject* V471; 05104 05105 typedef npy_float64 dtype_V471; 05106 05107 PyObject* py_V473; 05108 05109 PyArrayObject* V473; 05110 05111 typedef npy_float64 dtype_V473; 05112 05113 PyObject* py_V475; 05114 05115 PyArrayObject* V475; 05116 05117 typedef npy_float64 dtype_V475; 05118 05119 PyObject* py_V477; 05120 05121 PyArrayObject* V477; 05122 05123 typedef npy_float64 dtype_V477; 05124 05125 PyObject* py_V479; 05126 05127 PyArrayObject* V479; 05128 05129 typedef npy_float64 dtype_V479; 05130 05131 PyObject* py_V481; 05132 05133 PyArrayObject* V481; 05134 05135 typedef npy_float64 dtype_V481; 05136 05137 PyObject* py_V483; 05138 05139 PyArrayObject* V483; 05140 05141 typedef npy_float64 dtype_V483; 05142 05143 PyObject* py_V485; 05144 05145 PyArrayObject* V485; 05146 05147 typedef npy_float64 dtype_V485; 05148 05149 PyObject* py_V487; 05150 05151 PyArrayObject* V487; 05152 05153 typedef npy_float64 dtype_V487; 05154 05155 PyObject* py_V489; 05156 05157 PyArrayObject* V489; 05158 05159 typedef npy_float64 dtype_V489; 05160 05161 PyObject* py_V491; 05162 05163 PyArrayObject* V491; 05164 05165 typedef npy_float64 dtype_V491; 05166 05167 PyObject* py_V493; 05168 05169 PyArrayObject* V493; 05170 05171 typedef npy_float64 dtype_V493; 05172 05173 PyObject* py_V495; 05174 05175 PyArrayObject* V495; 05176 05177 typedef npy_float64 dtype_V495; 05178 05179 PyObject* py_V497; 05180 05181 PyArrayObject* V497; 05182 05183 typedef npy_float64 dtype_V497; 05184 05185 PyObject* py_V499; 05186 05187 PyArrayObject* V499; 05188 05189 typedef npy_float64 dtype_V499; 05190 05191 PyObject* py_V501; 05192 05193 PyArrayObject* V501; 05194 05195 typedef npy_float64 dtype_V501; 05196 05197 PyObject* py_V503; 05198 05199 PyArrayObject* V503; 05200 05201 typedef npy_float64 dtype_V503; 05202 05203 PyObject* py_V505; 05204 05205 PyArrayObject* V505; 05206 05207 typedef npy_float64 dtype_V505; 05208 05209 PyObject* py_V507; 05210 05211 PyArrayObject* V507; 05212 05213 typedef npy_float64 dtype_V507; 05214 05215 PyObject* py_V509; 05216 05217 PyArrayObject* V509; 05218 05219 typedef npy_float64 dtype_V509; 05220 05221 PyObject* py_V511; 05222 05223 PyArrayObject* V511; 05224 05225 typedef npy_float64 dtype_V511; 05226 05227 PyObject* py_V513; 05228 05229 PyArrayObject* V513; 05230 05231 typedef npy_float64 dtype_V513; 05232 05233 PyObject* py_V515; 05234 05235 PyArrayObject* V515; 05236 05237 typedef npy_float64 dtype_V515; 05238 05239 PyObject* py_V517; 05240 05241 PyArrayObject* V517; 05242 05243 typedef npy_float64 dtype_V517; 05244 05245 PyObject* py_V519; 05246 05247 PyArrayObject* V519; 05248 05249 typedef npy_float64 dtype_V519; 05250 05251 PyObject* py_V521; 05252 05253 PyArrayObject* V521; 05254 05255 typedef npy_float64 dtype_V521; 05256 05257 PyObject* py_V523; 05258 05259 PyArrayObject* V523; 05260 05261 typedef npy_float64 dtype_V523; 05262 05263 PyObject* py_V525; 05264 05265 PyArrayObject* V525; 05266 05267 typedef npy_float64 dtype_V525; 05268 05269 PyObject* py_V527; 05270 05271 PyArrayObject* V527; 05272 05273 typedef npy_float64 dtype_V527; 05274 05275 PyObject* py_V529; 05276 05277 PyArrayObject* V529; 05278 05279 typedef npy_float64 dtype_V529; 05280 05281 PyObject* py_V531; 05282 05283 PyArrayObject* V531; 05284 05285 typedef npy_float64 dtype_V531; 05286 05287 PyObject* py_V533; 05288 05289 PyArrayObject* V533; 05290 05291 typedef npy_float64 dtype_V533; 05292 05293 PyObject* py_V535; 05294 05295 PyArrayObject* V535; 05296 05297 typedef npy_float64 dtype_V535; 05298 05299 PyObject* py_V537; 05300 05301 PyArrayObject* V537; 05302 05303 typedef npy_float64 dtype_V537; 05304 05305 PyObject* py_V539; 05306 05307 PyArrayObject* V539; 05308 05309 typedef npy_float64 dtype_V539; 05310 05311 PyObject* py_V541; 05312 05313 PyArrayObject* V541; 05314 05315 typedef npy_float64 dtype_V541; 05316 05317 PyObject* py_V543; 05318 05319 PyArrayObject* V543; 05320 05321 typedef npy_float64 dtype_V543; 05322 05323 PyObject* py_V545; 05324 05325 PyArrayObject* V545; 05326 05327 typedef npy_float64 dtype_V545; 05328 05329 PyObject* py_V547; 05330 05331 PyArrayObject* V547; 05332 05333 typedef npy_float64 dtype_V547; 05334 05335 PyObject* py_V549; 05336 05337 PyArrayObject* V549; 05338 05339 typedef npy_float64 dtype_V549; 05340 05341 PyObject* py_V551; 05342 05343 PyArrayObject* V551; 05344 05345 typedef npy_float64 dtype_V551; 05346 05347 PyObject* py_V553; 05348 05349 PyArrayObject* V553; 05350 05351 typedef npy_float64 dtype_V553; 05352 05353 PyObject* py_V555; 05354 05355 PyArrayObject* V555; 05356 05357 typedef npy_float64 dtype_V555; 05358 05359 PyObject* py_V557; 05360 05361 PyArrayObject* V557; 05362 05363 typedef npy_float64 dtype_V557; 05364 05365 PyObject* py_V559; 05366 05367 PyArrayObject* V559; 05368 05369 typedef npy_float64 dtype_V559; 05370 05371 PyObject* py_V561; 05372 05373 PyArrayObject* V561; 05374 05375 typedef npy_float64 dtype_V561; 05376 05377 PyObject* py_V563; 05378 05379 PyArrayObject* V563; 05380 05381 typedef npy_float64 dtype_V563; 05382 05383 PyObject* py_V565; 05384 05385 PyArrayObject* V565; 05386 05387 typedef npy_float64 dtype_V565; 05388 05389 PyObject* py_V567; 05390 05391 PyArrayObject* V567; 05392 05393 typedef npy_float64 dtype_V567; 05394 05395 PyObject* py_V569; 05396 05397 PyArrayObject* V569; 05398 05399 typedef npy_float64 dtype_V569; 05400 05401 PyObject* py_V571; 05402 05403 PyArrayObject* V571; 05404 05405 typedef npy_float64 dtype_V571; 05406 05407 PyObject* py_V573; 05408 05409 PyArrayObject* V573; 05410 05411 typedef npy_float64 dtype_V573; 05412 05413 PyObject* py_V575; 05414 05415 PyArrayObject* V575; 05416 05417 typedef npy_float64 dtype_V575; 05418 05419 PyObject* py_V577; 05420 05421 PyArrayObject* V577; 05422 05423 typedef npy_float64 dtype_V577; 05424 05425 PyObject* py_V579; 05426 05427 PyArrayObject* V579; 05428 05429 typedef npy_float64 dtype_V579; 05430 05431 PyObject* py_V581; 05432 05433 PyArrayObject* V581; 05434 05435 typedef npy_float64 dtype_V581; 05436 05437 PyObject* py_V583; 05438 05439 PyArrayObject* V583; 05440 05441 typedef npy_float64 dtype_V583; 05442 05443 PyObject* py_V585; 05444 05445 PyArrayObject* V585; 05446 05447 typedef npy_float64 dtype_V585; 05448 05449 PyObject* py_V587; 05450 05451 PyArrayObject* V587; 05452 05453 typedef npy_float64 dtype_V587; 05454 05455 PyObject* py_V589; 05456 05457 PyArrayObject* V589; 05458 05459 typedef npy_float64 dtype_V589; 05460 05461 PyObject* py_V591; 05462 05463 PyArrayObject* V591; 05464 05465 typedef npy_float64 dtype_V591; 05466 05467 PyObject* py_V593; 05468 05469 PyArrayObject* V593; 05470 05471 typedef npy_float64 dtype_V593; 05472 05473 PyObject* py_V595; 05474 05475 PyArrayObject* V595; 05476 05477 typedef npy_float64 dtype_V595; 05478 05479 PyObject* py_V597; 05480 05481 PyArrayObject* V597; 05482 05483 typedef npy_float64 dtype_V597; 05484 05485 PyObject* py_V599; 05486 05487 PyArrayObject* V599; 05488 05489 typedef npy_float64 dtype_V599; 05490 05491 PyObject* py_V601; 05492 05493 PyArrayObject* V601; 05494 05495 typedef npy_float64 dtype_V601; 05496 05497 PyObject* py_V603; 05498 05499 PyArrayObject* V603; 05500 05501 typedef npy_float64 dtype_V603; 05502 05503 PyObject* py_V605; 05504 05505 PyArrayObject* V605; 05506 05507 typedef npy_float64 dtype_V605; 05508 05509 PyObject* py_V607; 05510 05511 PyArrayObject* V607; 05512 05513 typedef npy_float64 dtype_V607; 05514 05515 PyObject* py_V609; 05516 05517 PyArrayObject* V609; 05518 05519 typedef npy_float64 dtype_V609; 05520 05521 PyObject* py_V611; 05522 05523 PyArrayObject* V611; 05524 05525 typedef npy_float64 dtype_V611; 05526 05527 PyObject* py_V613; 05528 05529 PyArrayObject* V613; 05530 05531 typedef npy_float64 dtype_V613; 05532 05533 PyObject* py_V615; 05534 05535 PyArrayObject* V615; 05536 05537 typedef npy_float64 dtype_V615; 05538 05539 PyObject* py_V617; 05540 05541 PyArrayObject* V617; 05542 05543 typedef npy_float64 dtype_V617; 05544 05545 PyObject* py_V619; 05546 05547 PyArrayObject* V619; 05548 05549 typedef npy_float64 dtype_V619; 05550 05551 PyObject* py_V621; 05552 05553 PyArrayObject* V621; 05554 05555 typedef npy_float64 dtype_V621; 05556 05557 PyObject* py_V623; 05558 05559 PyArrayObject* V623; 05560 05561 typedef npy_float64 dtype_V623; 05562 05563 PyObject* py_V625; 05564 05565 PyArrayObject* V625; 05566 05567 typedef npy_float64 dtype_V625; 05568 05569 PyObject* py_V627; 05570 05571 PyArrayObject* V627; 05572 05573 typedef npy_float64 dtype_V627; 05574 05575 PyObject* py_V629; 05576 05577 PyArrayObject* V629; 05578 05579 typedef npy_float64 dtype_V629; 05580 05581 PyObject* py_V631; 05582 05583 PyArrayObject* V631; 05584 05585 typedef npy_float64 dtype_V631; 05586 05587 PyObject* py_V633; 05588 05589 PyArrayObject* V633; 05590 05591 typedef npy_float64 dtype_V633; 05592 05593 PyObject* py_V635; 05594 05595 PyArrayObject* V635; 05596 05597 typedef npy_float64 dtype_V635; 05598 05599 PyObject* py_V637; 05600 05601 PyArrayObject* V637; 05602 05603 typedef npy_float64 dtype_V637; 05604 05605 PyObject* py_V639; 05606 05607 PyArrayObject* V639; 05608 05609 typedef npy_float64 dtype_V639; 05610 05611 PyObject* py_V641; 05612 05613 PyArrayObject* V641; 05614 05615 typedef npy_float64 dtype_V641; 05616 05617 PyObject* py_V643; 05618 05619 PyArrayObject* V643; 05620 05621 typedef npy_float64 dtype_V643; 05622 05623 PyObject* py_V645; 05624 05625 PyArrayObject* V645; 05626 05627 typedef npy_float64 dtype_V645; 05628 05629 PyObject* py_V647; 05630 05631 PyArrayObject* V647; 05632 05633 typedef npy_float64 dtype_V647; 05634 05635 PyObject* py_V649; 05636 05637 PyArrayObject* V649; 05638 05639 typedef npy_float64 dtype_V649; 05640 05641 PyObject* py_V651; 05642 05643 PyArrayObject* V651; 05644 05645 typedef npy_float64 dtype_V651; 05646 05647 PyObject* py_V653; 05648 05649 PyArrayObject* V653; 05650 05651 typedef npy_float64 dtype_V653; 05652 05653 PyObject* py_V655; 05654 05655 PyArrayObject* V655; 05656 05657 typedef npy_float64 dtype_V655; 05658 05659 PyObject* py_V657; 05660 05661 PyArrayObject* V657; 05662 05663 typedef npy_float64 dtype_V657; 05664 05665 PyObject* py_V659; 05666 05667 PyArrayObject* V659; 05668 05669 typedef npy_float64 dtype_V659; 05670 05671 PyObject* py_V661; 05672 05673 PyArrayObject* V661; 05674 05675 typedef npy_float64 dtype_V661; 05676 05677 PyObject* py_V663; 05678 05679 PyArrayObject* V663; 05680 05681 typedef npy_float64 dtype_V663; 05682 05683 PyObject* py_V665; 05684 05685 PyArrayObject* V665; 05686 05687 typedef npy_float64 dtype_V665; 05688 05689 PyObject* py_V667; 05690 05691 PyArrayObject* V667; 05692 05693 typedef npy_float64 dtype_V667; 05694 05695 PyObject* py_V669; 05696 05697 PyArrayObject* V669; 05698 05699 typedef npy_float64 dtype_V669; 05700 05701 PyObject* py_V671; 05702 05703 PyArrayObject* V671; 05704 05705 typedef npy_float64 dtype_V671; 05706 05707 PyObject* py_V673; 05708 05709 PyArrayObject* V673; 05710 05711 typedef npy_float64 dtype_V673; 05712 05713 PyObject* py_V675; 05714 05715 PyArrayObject* V675; 05716 05717 typedef npy_float64 dtype_V675; 05718 05719 PyObject* py_V677; 05720 05721 PyArrayObject* V677; 05722 05723 typedef npy_float64 dtype_V677; 05724 05725 PyObject* py_V679; 05726 05727 PyArrayObject* V679; 05728 05729 typedef npy_float64 dtype_V679; 05730 05731 PyObject* py_V681; 05732 05733 PyArrayObject* V681; 05734 05735 typedef npy_float64 dtype_V681; 05736 05737 PyObject* py_V683; 05738 05739 PyArrayObject* V683; 05740 05741 typedef npy_float64 dtype_V683; 05742 05743 PyObject* py_V685; 05744 05745 PyArrayObject* V685; 05746 05747 typedef npy_float64 dtype_V685; 05748 05749 PyObject* py_V687; 05750 05751 PyArrayObject* V687; 05752 05753 typedef npy_float64 dtype_V687; 05754 05755 PyObject* py_V689; 05756 05757 PyArrayObject* V689; 05758 05759 typedef npy_float64 dtype_V689; 05760 05761 PyObject* py_V691; 05762 05763 PyArrayObject* V691; 05764 05765 typedef npy_float64 dtype_V691; 05766 05767 PyObject* py_V693; 05768 05769 PyArrayObject* V693; 05770 05771 typedef npy_float64 dtype_V693; 05772 05773 PyObject* py_V695; 05774 05775 PyArrayObject* V695; 05776 05777 typedef npy_float64 dtype_V695; 05778 05779 PyObject* py_V697; 05780 05781 PyArrayObject* V697; 05782 05783 typedef npy_float64 dtype_V697; 05784 05785 PyObject* py_V699; 05786 05787 PyArrayObject* V699; 05788 05789 typedef npy_float64 dtype_V699; 05790 05791 PyObject* py_V701; 05792 05793 PyArrayObject* V701; 05794 05795 typedef npy_float64 dtype_V701; 05796 05797 PyObject* py_V703; 05798 05799 PyArrayObject* V703; 05800 05801 typedef npy_float64 dtype_V703; 05802 05803 PyObject* py_V705; 05804 05805 PyArrayObject* V705; 05806 05807 typedef npy_float64 dtype_V705; 05808 05809 PyObject* py_V707; 05810 05811 PyArrayObject* V707; 05812 05813 typedef npy_float64 dtype_V707; 05814 05815 PyObject* py_V709; 05816 05817 PyArrayObject* V709; 05818 05819 typedef npy_float64 dtype_V709; 05820 05821 PyObject* py_V711; 05822 05823 PyArrayObject* V711; 05824 05825 typedef npy_float64 dtype_V711; 05826 05827 PyObject* py_V713; 05828 05829 PyArrayObject* V713; 05830 05831 typedef npy_float64 dtype_V713; 05832 05833 PyObject* py_V715; 05834 05835 PyArrayObject* V715; 05836 05837 typedef npy_float64 dtype_V715; 05838 05839 PyObject* py_V717; 05840 05841 PyArrayObject* V717; 05842 05843 typedef npy_float64 dtype_V717; 05844 05845 PyObject* py_V719; 05846 05847 PyArrayObject* V719; 05848 05849 typedef npy_float64 dtype_V719; 05850 05851 PyObject* py_V721; 05852 05853 PyArrayObject* V721; 05854 05855 typedef npy_float64 dtype_V721; 05856 05857 PyObject* py_V723; 05858 05859 PyArrayObject* V723; 05860 05861 typedef npy_float64 dtype_V723; 05862 05863 PyObject* py_V725; 05864 05865 PyArrayObject* V725; 05866 05867 typedef npy_float64 dtype_V725; 05868 05869 PyObject* py_V727; 05870 05871 PyArrayObject* V727; 05872 05873 typedef npy_float64 dtype_V727; 05874 05875 PyObject* py_V729; 05876 05877 PyArrayObject* V729; 05878 05879 typedef npy_float64 dtype_V729; 05880 05881 PyObject* py_V731; 05882 05883 PyArrayObject* V731; 05884 05885 typedef npy_float64 dtype_V731; 05886 05887 PyObject* py_V733; 05888 05889 PyArrayObject* V733; 05890 05891 typedef npy_float64 dtype_V733; 05892 05893 PyObject* py_V735; 05894 05895 PyArrayObject* V735; 05896 05897 typedef npy_float64 dtype_V735; 05898 05899 PyObject* py_V737; 05900 05901 PyArrayObject* V737; 05902 05903 typedef npy_float64 dtype_V737; 05904 05905 PyObject* py_V739; 05906 05907 PyArrayObject* V739; 05908 05909 typedef npy_float64 dtype_V739; 05910 05911 PyObject* py_V741; 05912 05913 PyArrayObject* V741; 05914 05915 typedef npy_float64 dtype_V741; 05916 05917 PyObject* py_V743; 05918 05919 PyArrayObject* V743; 05920 05921 typedef npy_float64 dtype_V743; 05922 05923 PyObject* py_V745; 05924 05925 PyArrayObject* V745; 05926 05927 typedef npy_float64 dtype_V745; 05928 05929 PyObject* py_V747; 05930 05931 PyArrayObject* V747; 05932 05933 typedef npy_float64 dtype_V747; 05934 05935 PyObject* py_V749; 05936 05937 PyArrayObject* V749; 05938 05939 typedef npy_float64 dtype_V749; 05940 05941 PyObject* py_V751; 05942 05943 PyArrayObject* V751; 05944 05945 typedef npy_float64 dtype_V751; 05946 05947 PyObject* py_V753; 05948 05949 PyArrayObject* V753; 05950 05951 typedef npy_float64 dtype_V753; 05952 05953 PyObject* py_V755; 05954 05955 PyArrayObject* V755; 05956 05957 typedef npy_float64 dtype_V755; 05958 05959 PyObject* py_V757; 05960 05961 PyArrayObject* V757; 05962 05963 typedef npy_float64 dtype_V757; 05964 05965 PyObject* py_V759; 05966 05967 PyArrayObject* V759; 05968 05969 typedef npy_float64 dtype_V759; 05970 05971 PyObject* py_V761; 05972 05973 PyArrayObject* V761; 05974 05975 typedef npy_float64 dtype_V761; 05976 05977 PyObject* py_V763; 05978 05979 PyArrayObject* V763; 05980 05981 typedef npy_float64 dtype_V763; 05982 05983 PyObject* py_V765; 05984 05985 PyArrayObject* V765; 05986 05987 typedef npy_float64 dtype_V765; 05988 05989 PyObject* py_V767; 05990 05991 PyArrayObject* V767; 05992 05993 typedef npy_float64 dtype_V767; 05994 05995 PyObject* py_V769; 05996 05997 PyArrayObject* V769; 05998 05999 typedef npy_float64 dtype_V769; 06000 06001 PyObject* py_V771; 06002 06003 PyArrayObject* V771; 06004 06005 typedef npy_float64 dtype_V771; 06006 06007 PyObject* py_V773; 06008 06009 PyArrayObject* V773; 06010 06011 typedef npy_float64 dtype_V773; 06012 06013 PyObject* py_V775; 06014 06015 PyArrayObject* V775; 06016 06017 typedef npy_float64 dtype_V775; 06018 06019 PyObject* py_V777; 06020 06021 PyArrayObject* V777; 06022 06023 typedef npy_float64 dtype_V777; 06024 06025 PyObject* py_V779; 06026 06027 PyArrayObject* V779; 06028 06029 typedef npy_float64 dtype_V779; 06030 06031 PyObject* py_V781; 06032 06033 PyArrayObject* V781; 06034 06035 typedef npy_float64 dtype_V781; 06036 06037 PyObject* py_V783; 06038 06039 PyArrayObject* V783; 06040 06041 typedef npy_float64 dtype_V783; 06042 06043 PyObject* py_V785; 06044 06045 PyArrayObject* V785; 06046 06047 typedef npy_float64 dtype_V785; 06048 06049 PyObject* py_V787; 06050 06051 PyArrayObject* V787; 06052 06053 typedef npy_float64 dtype_V787; 06054 06055 PyObject* py_V789; 06056 06057 PyArrayObject* V789; 06058 06059 typedef npy_float64 dtype_V789; 06060 06061 PyObject* py_V791; 06062 06063 PyArrayObject* V791; 06064 06065 typedef npy_float64 dtype_V791; 06066 06067 PyObject* py_V793; 06068 06069 PyArrayObject* V793; 06070 06071 typedef npy_float64 dtype_V793; 06072 06073 PyObject* py_V795; 06074 06075 PyArrayObject* V795; 06076 06077 typedef npy_float64 dtype_V795; 06078 06079 PyObject* py_V797; 06080 06081 PyArrayObject* V797; 06082 06083 typedef npy_float64 dtype_V797; 06084 06085 PyObject* py_V799; 06086 06087 PyArrayObject* V799; 06088 06089 typedef npy_float64 dtype_V799; 06090 06091 PyObject* py_V801; 06092 06093 PyArrayObject* V801; 06094 06095 typedef npy_float64 dtype_V801; 06096 06097 PyObject* py_V803; 06098 06099 PyArrayObject* V803; 06100 06101 typedef npy_float64 dtype_V803; 06102 06103 PyObject* py_V805; 06104 06105 PyArrayObject* V805; 06106 06107 typedef npy_float64 dtype_V805; 06108 06109 PyObject* py_V807; 06110 06111 PyArrayObject* V807; 06112 06113 typedef npy_float64 dtype_V807; 06114 06115 PyObject* py_V809; 06116 06117 PyArrayObject* V809; 06118 06119 typedef npy_float64 dtype_V809; 06120 06121 PyObject* py_V811; 06122 06123 PyArrayObject* V811; 06124 06125 typedef npy_float64 dtype_V811; 06126 06127 PyObject* py_V813; 06128 06129 PyArrayObject* V813; 06130 06131 typedef npy_float64 dtype_V813; 06132 06133 PyObject* py_V815; 06134 06135 PyArrayObject* V815; 06136 06137 typedef npy_float64 dtype_V815; 06138 06139 PyObject* py_V817; 06140 06141 PyArrayObject* V817; 06142 06143 typedef npy_float64 dtype_V817; 06144 06145 PyObject* py_V819; 06146 06147 PyArrayObject* V819; 06148 06149 typedef npy_float64 dtype_V819; 06150 06151 PyObject* py_V821; 06152 06153 PyArrayObject* V821; 06154 06155 typedef npy_float64 dtype_V821; 06156 06157 PyObject* py_V823; 06158 06159 PyArrayObject* V823; 06160 06161 typedef npy_float64 dtype_V823; 06162 06163 PyObject* py_V825; 06164 06165 PyArrayObject* V825; 06166 06167 typedef npy_float64 dtype_V825; 06168 06169 PyObject* py_V827; 06170 06171 PyArrayObject* V827; 06172 06173 typedef npy_float64 dtype_V827; 06174 06175 PyObject* py_V829; 06176 06177 PyArrayObject* V829; 06178 06179 typedef npy_float64 dtype_V829; 06180 06181 PyObject* py_V831; 06182 06183 PyArrayObject* V831; 06184 06185 typedef npy_float64 dtype_V831; 06186 06187 PyObject* py_V833; 06188 06189 PyArrayObject* V833; 06190 06191 typedef npy_float64 dtype_V833; 06192 06193 PyObject* py_V835; 06194 06195 PyArrayObject* V835; 06196 06197 typedef npy_float64 dtype_V835; 06198 06199 PyObject* py_V837; 06200 06201 PyArrayObject* V837; 06202 06203 typedef npy_float64 dtype_V837; 06204 06205 PyObject* py_V839; 06206 06207 PyArrayObject* V839; 06208 06209 typedef npy_float64 dtype_V839; 06210 06211 PyObject* py_V841; 06212 06213 PyArrayObject* V841; 06214 06215 typedef npy_float64 dtype_V841; 06216 06217 PyObject* py_V843; 06218 06219 PyArrayObject* V843; 06220 06221 typedef npy_float64 dtype_V843; 06222 06223 PyObject* py_V845; 06224 06225 PyArrayObject* V845; 06226 06227 typedef npy_float64 dtype_V845; 06228 06229 PyObject* py_V847; 06230 06231 PyArrayObject* V847; 06232 06233 typedef npy_float64 dtype_V847; 06234 06235 PyObject* py_V849; 06236 06237 PyArrayObject* V849; 06238 06239 typedef npy_float64 dtype_V849; 06240 06241 PyObject* py_V851; 06242 06243 PyArrayObject* V851; 06244 06245 typedef npy_float64 dtype_V851; 06246 06247 PyObject* py_V853; 06248 06249 PyArrayObject* V853; 06250 06251 typedef npy_float64 dtype_V853; 06252 06253 PyObject* py_V855; 06254 06255 PyArrayObject* V855; 06256 06257 typedef npy_float64 dtype_V855; 06258 06259 PyObject* py_V857; 06260 06261 PyArrayObject* V857; 06262 06263 typedef npy_float64 dtype_V857; 06264 06265 PyObject* py_V859; 06266 06267 PyArrayObject* V859; 06268 06269 typedef npy_float64 dtype_V859; 06270 06271 PyObject* py_V861; 06272 06273 PyArrayObject* V861; 06274 06275 typedef npy_float64 dtype_V861; 06276 06277 PyObject* py_V863; 06278 06279 PyArrayObject* V863; 06280 06281 typedef npy_float64 dtype_V863; 06282 06283 PyObject* py_V865; 06284 06285 PyArrayObject* V865; 06286 06287 typedef npy_float64 dtype_V865; 06288 06289 PyObject* py_V867; 06290 06291 PyArrayObject* V867; 06292 06293 typedef npy_float64 dtype_V867; 06294 06295 PyObject* py_V869; 06296 06297 PyArrayObject* V869; 06298 06299 typedef npy_float64 dtype_V869; 06300 06301 PyObject* py_V871; 06302 06303 PyArrayObject* V871; 06304 06305 typedef npy_float64 dtype_V871; 06306 06307 PyObject* py_V873; 06308 06309 PyArrayObject* V873; 06310 06311 typedef npy_float64 dtype_V873; 06312 06313 PyObject* py_V875; 06314 06315 PyArrayObject* V875; 06316 06317 typedef npy_float64 dtype_V875; 06318 06319 PyObject* py_V877; 06320 06321 PyArrayObject* V877; 06322 06323 typedef npy_float64 dtype_V877; 06324 06325 PyObject* py_V879; 06326 06327 PyArrayObject* V879; 06328 06329 typedef npy_float64 dtype_V879; 06330 06331 PyObject* py_V881; 06332 06333 PyArrayObject* V881; 06334 06335 typedef npy_float64 dtype_V881; 06336 06337 PyObject* py_V883; 06338 06339 PyArrayObject* V883; 06340 06341 typedef npy_float64 dtype_V883; 06342 06343 PyObject* py_V885; 06344 06345 PyArrayObject* V885; 06346 06347 typedef npy_float64 dtype_V885; 06348 06349 PyObject* py_V887; 06350 06351 PyArrayObject* V887; 06352 06353 typedef npy_float64 dtype_V887; 06354 06355 PyObject* py_V889; 06356 06357 PyArrayObject* V889; 06358 06359 typedef npy_float64 dtype_V889; 06360 06361 PyObject* py_V891; 06362 06363 PyArrayObject* V891; 06364 06365 typedef npy_float64 dtype_V891; 06366 06367 PyObject* py_V893; 06368 06369 PyArrayObject* V893; 06370 06371 typedef npy_float64 dtype_V893; 06372 06373 PyObject* py_V895; 06374 06375 PyArrayObject* V895; 06376 06377 typedef npy_float64 dtype_V895; 06378 06379 PyObject* py_V897; 06380 06381 PyArrayObject* V897; 06382 06383 typedef npy_float64 dtype_V897; 06384 06385 PyObject* py_V899; 06386 06387 PyArrayObject* V899; 06388 06389 typedef npy_float64 dtype_V899; 06390 06391 PyObject* py_V901; 06392 06393 PyArrayObject* V901; 06394 06395 typedef npy_float64 dtype_V901; 06396 06397 PyObject* py_V903; 06398 06399 PyArrayObject* V903; 06400 06401 typedef npy_float64 dtype_V903; 06402 06403 PyObject* py_V905; 06404 06405 PyArrayObject* V905; 06406 06407 typedef npy_float64 dtype_V905; 06408 06409 PyObject* py_V907; 06410 06411 PyArrayObject* V907; 06412 06413 typedef npy_float64 dtype_V907; 06414 06415 PyObject* py_V909; 06416 06417 PyArrayObject* V909; 06418 06419 typedef npy_float64 dtype_V909; 06420 06421 { 06422 06423 py_V1 = Py_None; 06424 {Py_XINCREF(py_V1);} 06425 06426 V1 = NULL; 06427 06428 { 06429 06430 py_V3 = PyList_GET_ITEM(storage_V3, 0); 06431 {Py_XINCREF(py_V3);} 06432 06433 V3 = NULL; 06434 if (py_V3 == Py_None) { 06435 // We can either fail here or set V3 to NULL and rely on Ops 06436 // using tensors to handle the NULL case, but if they fail to do so 06437 // they'll end up with nasty segfaults, so this is public service. 06438 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 06439 { 06440 __failure = 4; 06441 if (!PyErr_Occurred()) { 06442 PyErr_SetString(PyExc_RuntimeError, 06443 "Unexpected error in an Op's C code. " 06444 "No Python exception was set."); 06445 } 06446 goto __label_4;} 06447 } 06448 if (!PyArray_Check(py_V3)) { 06449 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 06450 { 06451 __failure = 4; 06452 if (!PyErr_Occurred()) { 06453 PyErr_SetString(PyExc_RuntimeError, 06454 "Unexpected error in an Op's C code. " 06455 "No Python exception was set."); 06456 } 06457 goto __label_4;} 06458 } 06459 // We expect NPY_FLOAT64 06460 if (!PyArray_ISALIGNED((PyArrayObject*) py_V3)) { 06461 PyArrayObject * tmp = (PyArrayObject*) py_V3; 06462 PyErr_Format(PyExc_NotImplementedError, 06463 "expected an aligned array of type %ld " 06464 "(NPY_FLOAT64), got non-aligned array of type %ld" 06465 " with %ld dimensions, with 3 last dims " 06466 "%ld, %ld, %ld" 06467 " and 3 last strides %ld %ld, %ld.", 06468 (long int) NPY_FLOAT64, 06469 (long int) PyArray_TYPE((PyArrayObject*) py_V3), 06470 (long int) PyArray_NDIM(tmp), 06471 (long int) (PyArray_NDIM(tmp) >= 3 ? 06472 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 06473 (long int) (PyArray_NDIM(tmp) >= 2 ? 06474 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 06475 (long int) (PyArray_NDIM(tmp) >= 1 ? 06476 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 06477 (long int) (PyArray_NDIM(tmp) >= 3 ? 06478 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 06479 (long int) (PyArray_NDIM(tmp) >= 2 ? 06480 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 06481 (long int) (PyArray_NDIM(tmp) >= 1 ? 06482 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 06483 ); 06484 { 06485 __failure = 4; 06486 if (!PyErr_Occurred()) { 06487 PyErr_SetString(PyExc_RuntimeError, 06488 "Unexpected error in an Op's C code. " 06489 "No Python exception was set."); 06490 } 06491 goto __label_4;} 06492 } 06493 // This is a TypeError to be consistent with DEBUG_MODE 06494 // Note: DEBUG_MODE also tells the name of the container 06495 if (PyArray_TYPE((PyArrayObject*) py_V3) != NPY_FLOAT64) { 06496 PyErr_Format(PyExc_TypeError, 06497 "expected type_num %d (NPY_FLOAT64) got %d", 06498 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V3)); 06499 { 06500 __failure = 4; 06501 if (!PyErr_Occurred()) { 06502 PyErr_SetString(PyExc_RuntimeError, 06503 "Unexpected error in an Op's C code. " 06504 "No Python exception was set."); 06505 } 06506 goto __label_4;} 06507 } 06508 06509 V3 = (PyArrayObject*)(py_V3); 06510 Py_XINCREF(V3); 06511 06512 { 06513 06514 py_V5 = PyList_GET_ITEM(storage_V5, 0); 06515 {Py_XINCREF(py_V5);} 06516 06517 V5 = NULL; 06518 if (py_V5 == Py_None) { 06519 // We can either fail here or set V5 to NULL and rely on Ops 06520 // using tensors to handle the NULL case, but if they fail to do so 06521 // they'll end up with nasty segfaults, so this is public service. 06522 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 06523 { 06524 __failure = 6; 06525 if (!PyErr_Occurred()) { 06526 PyErr_SetString(PyExc_RuntimeError, 06527 "Unexpected error in an Op's C code. " 06528 "No Python exception was set."); 06529 } 06530 goto __label_6;} 06531 } 06532 if (!PyArray_Check(py_V5)) { 06533 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 06534 { 06535 __failure = 6; 06536 if (!PyErr_Occurred()) { 06537 PyErr_SetString(PyExc_RuntimeError, 06538 "Unexpected error in an Op's C code. " 06539 "No Python exception was set."); 06540 } 06541 goto __label_6;} 06542 } 06543 // We expect NPY_FLOAT64 06544 if (!PyArray_ISALIGNED((PyArrayObject*) py_V5)) { 06545 PyArrayObject * tmp = (PyArrayObject*) py_V5; 06546 PyErr_Format(PyExc_NotImplementedError, 06547 "expected an aligned array of type %ld " 06548 "(NPY_FLOAT64), got non-aligned array of type %ld" 06549 " with %ld dimensions, with 3 last dims " 06550 "%ld, %ld, %ld" 06551 " and 3 last strides %ld %ld, %ld.", 06552 (long int) NPY_FLOAT64, 06553 (long int) PyArray_TYPE((PyArrayObject*) py_V5), 06554 (long int) PyArray_NDIM(tmp), 06555 (long int) (PyArray_NDIM(tmp) >= 3 ? 06556 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 06557 (long int) (PyArray_NDIM(tmp) >= 2 ? 06558 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 06559 (long int) (PyArray_NDIM(tmp) >= 1 ? 06560 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 06561 (long int) (PyArray_NDIM(tmp) >= 3 ? 06562 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 06563 (long int) (PyArray_NDIM(tmp) >= 2 ? 06564 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 06565 (long int) (PyArray_NDIM(tmp) >= 1 ? 06566 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 06567 ); 06568 { 06569 __failure = 6; 06570 if (!PyErr_Occurred()) { 06571 PyErr_SetString(PyExc_RuntimeError, 06572 "Unexpected error in an Op's C code. " 06573 "No Python exception was set."); 06574 } 06575 goto __label_6;} 06576 } 06577 // This is a TypeError to be consistent with DEBUG_MODE 06578 // Note: DEBUG_MODE also tells the name of the container 06579 if (PyArray_TYPE((PyArrayObject*) py_V5) != NPY_FLOAT64) { 06580 PyErr_Format(PyExc_TypeError, 06581 "expected type_num %d (NPY_FLOAT64) got %d", 06582 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V5)); 06583 { 06584 __failure = 6; 06585 if (!PyErr_Occurred()) { 06586 PyErr_SetString(PyExc_RuntimeError, 06587 "Unexpected error in an Op's C code. " 06588 "No Python exception was set."); 06589 } 06590 goto __label_6;} 06591 } 06592 06593 V5 = (PyArrayObject*)(py_V5); 06594 Py_XINCREF(V5); 06595 06596 { 06597 06598 py_V7 = PyList_GET_ITEM(storage_V7, 0); 06599 {Py_XINCREF(py_V7);} 06600 06601 V7 = NULL; 06602 if (py_V7 == Py_None) { 06603 // We can either fail here or set V7 to NULL and rely on Ops 06604 // using tensors to handle the NULL case, but if they fail to do so 06605 // they'll end up with nasty segfaults, so this is public service. 06606 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 06607 { 06608 __failure = 8; 06609 if (!PyErr_Occurred()) { 06610 PyErr_SetString(PyExc_RuntimeError, 06611 "Unexpected error in an Op's C code. " 06612 "No Python exception was set."); 06613 } 06614 goto __label_8;} 06615 } 06616 if (!PyArray_Check(py_V7)) { 06617 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 06618 { 06619 __failure = 8; 06620 if (!PyErr_Occurred()) { 06621 PyErr_SetString(PyExc_RuntimeError, 06622 "Unexpected error in an Op's C code. " 06623 "No Python exception was set."); 06624 } 06625 goto __label_8;} 06626 } 06627 // We expect NPY_FLOAT64 06628 if (!PyArray_ISALIGNED((PyArrayObject*) py_V7)) { 06629 PyArrayObject * tmp = (PyArrayObject*) py_V7; 06630 PyErr_Format(PyExc_NotImplementedError, 06631 "expected an aligned array of type %ld " 06632 "(NPY_FLOAT64), got non-aligned array of type %ld" 06633 " with %ld dimensions, with 3 last dims " 06634 "%ld, %ld, %ld" 06635 " and 3 last strides %ld %ld, %ld.", 06636 (long int) NPY_FLOAT64, 06637 (long int) PyArray_TYPE((PyArrayObject*) py_V7), 06638 (long int) PyArray_NDIM(tmp), 06639 (long int) (PyArray_NDIM(tmp) >= 3 ? 06640 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 06641 (long int) (PyArray_NDIM(tmp) >= 2 ? 06642 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 06643 (long int) (PyArray_NDIM(tmp) >= 1 ? 06644 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 06645 (long int) (PyArray_NDIM(tmp) >= 3 ? 06646 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 06647 (long int) (PyArray_NDIM(tmp) >= 2 ? 06648 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 06649 (long int) (PyArray_NDIM(tmp) >= 1 ? 06650 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 06651 ); 06652 { 06653 __failure = 8; 06654 if (!PyErr_Occurred()) { 06655 PyErr_SetString(PyExc_RuntimeError, 06656 "Unexpected error in an Op's C code. " 06657 "No Python exception was set."); 06658 } 06659 goto __label_8;} 06660 } 06661 // This is a TypeError to be consistent with DEBUG_MODE 06662 // Note: DEBUG_MODE also tells the name of the container 06663 if (PyArray_TYPE((PyArrayObject*) py_V7) != NPY_FLOAT64) { 06664 PyErr_Format(PyExc_TypeError, 06665 "expected type_num %d (NPY_FLOAT64) got %d", 06666 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V7)); 06667 { 06668 __failure = 8; 06669 if (!PyErr_Occurred()) { 06670 PyErr_SetString(PyExc_RuntimeError, 06671 "Unexpected error in an Op's C code. " 06672 "No Python exception was set."); 06673 } 06674 goto __label_8;} 06675 } 06676 06677 V7 = (PyArrayObject*)(py_V7); 06678 Py_XINCREF(V7); 06679 06680 { 06681 06682 py_V9 = PyList_GET_ITEM(storage_V9, 0); 06683 {Py_XINCREF(py_V9);} 06684 06685 V9 = NULL; 06686 if (py_V9 == Py_None) { 06687 // We can either fail here or set V9 to NULL and rely on Ops 06688 // using tensors to handle the NULL case, but if they fail to do so 06689 // they'll end up with nasty segfaults, so this is public service. 06690 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 06691 { 06692 __failure = 10; 06693 if (!PyErr_Occurred()) { 06694 PyErr_SetString(PyExc_RuntimeError, 06695 "Unexpected error in an Op's C code. " 06696 "No Python exception was set."); 06697 } 06698 goto __label_10;} 06699 } 06700 if (!PyArray_Check(py_V9)) { 06701 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 06702 { 06703 __failure = 10; 06704 if (!PyErr_Occurred()) { 06705 PyErr_SetString(PyExc_RuntimeError, 06706 "Unexpected error in an Op's C code. " 06707 "No Python exception was set."); 06708 } 06709 goto __label_10;} 06710 } 06711 // We expect NPY_FLOAT64 06712 if (!PyArray_ISALIGNED((PyArrayObject*) py_V9)) { 06713 PyArrayObject * tmp = (PyArrayObject*) py_V9; 06714 PyErr_Format(PyExc_NotImplementedError, 06715 "expected an aligned array of type %ld " 06716 "(NPY_FLOAT64), got non-aligned array of type %ld" 06717 " with %ld dimensions, with 3 last dims " 06718 "%ld, %ld, %ld" 06719 " and 3 last strides %ld %ld, %ld.", 06720 (long int) NPY_FLOAT64, 06721 (long int) PyArray_TYPE((PyArrayObject*) py_V9), 06722 (long int) PyArray_NDIM(tmp), 06723 (long int) (PyArray_NDIM(tmp) >= 3 ? 06724 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 06725 (long int) (PyArray_NDIM(tmp) >= 2 ? 06726 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 06727 (long int) (PyArray_NDIM(tmp) >= 1 ? 06728 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 06729 (long int) (PyArray_NDIM(tmp) >= 3 ? 06730 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 06731 (long int) (PyArray_NDIM(tmp) >= 2 ? 06732 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 06733 (long int) (PyArray_NDIM(tmp) >= 1 ? 06734 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 06735 ); 06736 { 06737 __failure = 10; 06738 if (!PyErr_Occurred()) { 06739 PyErr_SetString(PyExc_RuntimeError, 06740 "Unexpected error in an Op's C code. " 06741 "No Python exception was set."); 06742 } 06743 goto __label_10;} 06744 } 06745 // This is a TypeError to be consistent with DEBUG_MODE 06746 // Note: DEBUG_MODE also tells the name of the container 06747 if (PyArray_TYPE((PyArrayObject*) py_V9) != NPY_FLOAT64) { 06748 PyErr_Format(PyExc_TypeError, 06749 "expected type_num %d (NPY_FLOAT64) got %d", 06750 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V9)); 06751 { 06752 __failure = 10; 06753 if (!PyErr_Occurred()) { 06754 PyErr_SetString(PyExc_RuntimeError, 06755 "Unexpected error in an Op's C code. " 06756 "No Python exception was set."); 06757 } 06758 goto __label_10;} 06759 } 06760 06761 V9 = (PyArrayObject*)(py_V9); 06762 Py_XINCREF(V9); 06763 06764 { 06765 06766 py_V11 = PyList_GET_ITEM(storage_V11, 0); 06767 {Py_XINCREF(py_V11);} 06768 06769 V11 = NULL; 06770 if (py_V11 == Py_None) { 06771 // We can either fail here or set V11 to NULL and rely on Ops 06772 // using tensors to handle the NULL case, but if they fail to do so 06773 // they'll end up with nasty segfaults, so this is public service. 06774 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 06775 { 06776 __failure = 12; 06777 if (!PyErr_Occurred()) { 06778 PyErr_SetString(PyExc_RuntimeError, 06779 "Unexpected error in an Op's C code. " 06780 "No Python exception was set."); 06781 } 06782 goto __label_12;} 06783 } 06784 if (!PyArray_Check(py_V11)) { 06785 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 06786 { 06787 __failure = 12; 06788 if (!PyErr_Occurred()) { 06789 PyErr_SetString(PyExc_RuntimeError, 06790 "Unexpected error in an Op's C code. " 06791 "No Python exception was set."); 06792 } 06793 goto __label_12;} 06794 } 06795 // We expect NPY_FLOAT64 06796 if (!PyArray_ISALIGNED((PyArrayObject*) py_V11)) { 06797 PyArrayObject * tmp = (PyArrayObject*) py_V11; 06798 PyErr_Format(PyExc_NotImplementedError, 06799 "expected an aligned array of type %ld " 06800 "(NPY_FLOAT64), got non-aligned array of type %ld" 06801 " with %ld dimensions, with 3 last dims " 06802 "%ld, %ld, %ld" 06803 " and 3 last strides %ld %ld, %ld.", 06804 (long int) NPY_FLOAT64, 06805 (long int) PyArray_TYPE((PyArrayObject*) py_V11), 06806 (long int) PyArray_NDIM(tmp), 06807 (long int) (PyArray_NDIM(tmp) >= 3 ? 06808 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 06809 (long int) (PyArray_NDIM(tmp) >= 2 ? 06810 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 06811 (long int) (PyArray_NDIM(tmp) >= 1 ? 06812 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 06813 (long int) (PyArray_NDIM(tmp) >= 3 ? 06814 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 06815 (long int) (PyArray_NDIM(tmp) >= 2 ? 06816 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 06817 (long int) (PyArray_NDIM(tmp) >= 1 ? 06818 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 06819 ); 06820 { 06821 __failure = 12; 06822 if (!PyErr_Occurred()) { 06823 PyErr_SetString(PyExc_RuntimeError, 06824 "Unexpected error in an Op's C code. " 06825 "No Python exception was set."); 06826 } 06827 goto __label_12;} 06828 } 06829 // This is a TypeError to be consistent with DEBUG_MODE 06830 // Note: DEBUG_MODE also tells the name of the container 06831 if (PyArray_TYPE((PyArrayObject*) py_V11) != NPY_FLOAT64) { 06832 PyErr_Format(PyExc_TypeError, 06833 "expected type_num %d (NPY_FLOAT64) got %d", 06834 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V11)); 06835 { 06836 __failure = 12; 06837 if (!PyErr_Occurred()) { 06838 PyErr_SetString(PyExc_RuntimeError, 06839 "Unexpected error in an Op's C code. " 06840 "No Python exception was set."); 06841 } 06842 goto __label_12;} 06843 } 06844 06845 V11 = (PyArrayObject*)(py_V11); 06846 Py_XINCREF(V11); 06847 06848 { 06849 06850 py_V13 = PyList_GET_ITEM(storage_V13, 0); 06851 {Py_XINCREF(py_V13);} 06852 06853 V13 = NULL; 06854 if (py_V13 == Py_None) { 06855 // We can either fail here or set V13 to NULL and rely on Ops 06856 // using tensors to handle the NULL case, but if they fail to do so 06857 // they'll end up with nasty segfaults, so this is public service. 06858 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 06859 { 06860 __failure = 14; 06861 if (!PyErr_Occurred()) { 06862 PyErr_SetString(PyExc_RuntimeError, 06863 "Unexpected error in an Op's C code. " 06864 "No Python exception was set."); 06865 } 06866 goto __label_14;} 06867 } 06868 if (!PyArray_Check(py_V13)) { 06869 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 06870 { 06871 __failure = 14; 06872 if (!PyErr_Occurred()) { 06873 PyErr_SetString(PyExc_RuntimeError, 06874 "Unexpected error in an Op's C code. " 06875 "No Python exception was set."); 06876 } 06877 goto __label_14;} 06878 } 06879 // We expect NPY_FLOAT64 06880 if (!PyArray_ISALIGNED((PyArrayObject*) py_V13)) { 06881 PyArrayObject * tmp = (PyArrayObject*) py_V13; 06882 PyErr_Format(PyExc_NotImplementedError, 06883 "expected an aligned array of type %ld " 06884 "(NPY_FLOAT64), got non-aligned array of type %ld" 06885 " with %ld dimensions, with 3 last dims " 06886 "%ld, %ld, %ld" 06887 " and 3 last strides %ld %ld, %ld.", 06888 (long int) NPY_FLOAT64, 06889 (long int) PyArray_TYPE((PyArrayObject*) py_V13), 06890 (long int) PyArray_NDIM(tmp), 06891 (long int) (PyArray_NDIM(tmp) >= 3 ? 06892 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 06893 (long int) (PyArray_NDIM(tmp) >= 2 ? 06894 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 06895 (long int) (PyArray_NDIM(tmp) >= 1 ? 06896 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 06897 (long int) (PyArray_NDIM(tmp) >= 3 ? 06898 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 06899 (long int) (PyArray_NDIM(tmp) >= 2 ? 06900 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 06901 (long int) (PyArray_NDIM(tmp) >= 1 ? 06902 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 06903 ); 06904 { 06905 __failure = 14; 06906 if (!PyErr_Occurred()) { 06907 PyErr_SetString(PyExc_RuntimeError, 06908 "Unexpected error in an Op's C code. " 06909 "No Python exception was set."); 06910 } 06911 goto __label_14;} 06912 } 06913 // This is a TypeError to be consistent with DEBUG_MODE 06914 // Note: DEBUG_MODE also tells the name of the container 06915 if (PyArray_TYPE((PyArrayObject*) py_V13) != NPY_FLOAT64) { 06916 PyErr_Format(PyExc_TypeError, 06917 "expected type_num %d (NPY_FLOAT64) got %d", 06918 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V13)); 06919 { 06920 __failure = 14; 06921 if (!PyErr_Occurred()) { 06922 PyErr_SetString(PyExc_RuntimeError, 06923 "Unexpected error in an Op's C code. " 06924 "No Python exception was set."); 06925 } 06926 goto __label_14;} 06927 } 06928 06929 V13 = (PyArrayObject*)(py_V13); 06930 Py_XINCREF(V13); 06931 06932 { 06933 06934 py_V15 = PyList_GET_ITEM(storage_V15, 0); 06935 {Py_XINCREF(py_V15);} 06936 06937 V15 = NULL; 06938 if (py_V15 == Py_None) { 06939 // We can either fail here or set V15 to NULL and rely on Ops 06940 // using tensors to handle the NULL case, but if they fail to do so 06941 // they'll end up with nasty segfaults, so this is public service. 06942 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 06943 { 06944 __failure = 16; 06945 if (!PyErr_Occurred()) { 06946 PyErr_SetString(PyExc_RuntimeError, 06947 "Unexpected error in an Op's C code. " 06948 "No Python exception was set."); 06949 } 06950 goto __label_16;} 06951 } 06952 if (!PyArray_Check(py_V15)) { 06953 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 06954 { 06955 __failure = 16; 06956 if (!PyErr_Occurred()) { 06957 PyErr_SetString(PyExc_RuntimeError, 06958 "Unexpected error in an Op's C code. " 06959 "No Python exception was set."); 06960 } 06961 goto __label_16;} 06962 } 06963 // We expect NPY_FLOAT64 06964 if (!PyArray_ISALIGNED((PyArrayObject*) py_V15)) { 06965 PyArrayObject * tmp = (PyArrayObject*) py_V15; 06966 PyErr_Format(PyExc_NotImplementedError, 06967 "expected an aligned array of type %ld " 06968 "(NPY_FLOAT64), got non-aligned array of type %ld" 06969 " with %ld dimensions, with 3 last dims " 06970 "%ld, %ld, %ld" 06971 " and 3 last strides %ld %ld, %ld.", 06972 (long int) NPY_FLOAT64, 06973 (long int) PyArray_TYPE((PyArrayObject*) py_V15), 06974 (long int) PyArray_NDIM(tmp), 06975 (long int) (PyArray_NDIM(tmp) >= 3 ? 06976 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 06977 (long int) (PyArray_NDIM(tmp) >= 2 ? 06978 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 06979 (long int) (PyArray_NDIM(tmp) >= 1 ? 06980 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 06981 (long int) (PyArray_NDIM(tmp) >= 3 ? 06982 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 06983 (long int) (PyArray_NDIM(tmp) >= 2 ? 06984 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 06985 (long int) (PyArray_NDIM(tmp) >= 1 ? 06986 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 06987 ); 06988 { 06989 __failure = 16; 06990 if (!PyErr_Occurred()) { 06991 PyErr_SetString(PyExc_RuntimeError, 06992 "Unexpected error in an Op's C code. " 06993 "No Python exception was set."); 06994 } 06995 goto __label_16;} 06996 } 06997 // This is a TypeError to be consistent with DEBUG_MODE 06998 // Note: DEBUG_MODE also tells the name of the container 06999 if (PyArray_TYPE((PyArrayObject*) py_V15) != NPY_FLOAT64) { 07000 PyErr_Format(PyExc_TypeError, 07001 "expected type_num %d (NPY_FLOAT64) got %d", 07002 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V15)); 07003 { 07004 __failure = 16; 07005 if (!PyErr_Occurred()) { 07006 PyErr_SetString(PyExc_RuntimeError, 07007 "Unexpected error in an Op's C code. " 07008 "No Python exception was set."); 07009 } 07010 goto __label_16;} 07011 } 07012 07013 V15 = (PyArrayObject*)(py_V15); 07014 Py_XINCREF(V15); 07015 07016 { 07017 07018 py_V17 = PyList_GET_ITEM(storage_V17, 0); 07019 {Py_XINCREF(py_V17);} 07020 07021 V17 = NULL; 07022 if (py_V17 == Py_None) { 07023 // We can either fail here or set V17 to NULL and rely on Ops 07024 // using tensors to handle the NULL case, but if they fail to do so 07025 // they'll end up with nasty segfaults, so this is public service. 07026 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 07027 { 07028 __failure = 18; 07029 if (!PyErr_Occurred()) { 07030 PyErr_SetString(PyExc_RuntimeError, 07031 "Unexpected error in an Op's C code. " 07032 "No Python exception was set."); 07033 } 07034 goto __label_18;} 07035 } 07036 if (!PyArray_Check(py_V17)) { 07037 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 07038 { 07039 __failure = 18; 07040 if (!PyErr_Occurred()) { 07041 PyErr_SetString(PyExc_RuntimeError, 07042 "Unexpected error in an Op's C code. " 07043 "No Python exception was set."); 07044 } 07045 goto __label_18;} 07046 } 07047 // We expect NPY_FLOAT64 07048 if (!PyArray_ISALIGNED((PyArrayObject*) py_V17)) { 07049 PyArrayObject * tmp = (PyArrayObject*) py_V17; 07050 PyErr_Format(PyExc_NotImplementedError, 07051 "expected an aligned array of type %ld " 07052 "(NPY_FLOAT64), got non-aligned array of type %ld" 07053 " with %ld dimensions, with 3 last dims " 07054 "%ld, %ld, %ld" 07055 " and 3 last strides %ld %ld, %ld.", 07056 (long int) NPY_FLOAT64, 07057 (long int) PyArray_TYPE((PyArrayObject*) py_V17), 07058 (long int) PyArray_NDIM(tmp), 07059 (long int) (PyArray_NDIM(tmp) >= 3 ? 07060 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 07061 (long int) (PyArray_NDIM(tmp) >= 2 ? 07062 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 07063 (long int) (PyArray_NDIM(tmp) >= 1 ? 07064 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 07065 (long int) (PyArray_NDIM(tmp) >= 3 ? 07066 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 07067 (long int) (PyArray_NDIM(tmp) >= 2 ? 07068 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 07069 (long int) (PyArray_NDIM(tmp) >= 1 ? 07070 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 07071 ); 07072 { 07073 __failure = 18; 07074 if (!PyErr_Occurred()) { 07075 PyErr_SetString(PyExc_RuntimeError, 07076 "Unexpected error in an Op's C code. " 07077 "No Python exception was set."); 07078 } 07079 goto __label_18;} 07080 } 07081 // This is a TypeError to be consistent with DEBUG_MODE 07082 // Note: DEBUG_MODE also tells the name of the container 07083 if (PyArray_TYPE((PyArrayObject*) py_V17) != NPY_FLOAT64) { 07084 PyErr_Format(PyExc_TypeError, 07085 "expected type_num %d (NPY_FLOAT64) got %d", 07086 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V17)); 07087 { 07088 __failure = 18; 07089 if (!PyErr_Occurred()) { 07090 PyErr_SetString(PyExc_RuntimeError, 07091 "Unexpected error in an Op's C code. " 07092 "No Python exception was set."); 07093 } 07094 goto __label_18;} 07095 } 07096 07097 V17 = (PyArrayObject*)(py_V17); 07098 Py_XINCREF(V17); 07099 07100 { 07101 07102 py_V19 = PyList_GET_ITEM(storage_V19, 0); 07103 {Py_XINCREF(py_V19);} 07104 07105 V19 = NULL; 07106 if (py_V19 == Py_None) { 07107 // We can either fail here or set V19 to NULL and rely on Ops 07108 // using tensors to handle the NULL case, but if they fail to do so 07109 // they'll end up with nasty segfaults, so this is public service. 07110 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 07111 { 07112 __failure = 20; 07113 if (!PyErr_Occurred()) { 07114 PyErr_SetString(PyExc_RuntimeError, 07115 "Unexpected error in an Op's C code. " 07116 "No Python exception was set."); 07117 } 07118 goto __label_20;} 07119 } 07120 if (!PyArray_Check(py_V19)) { 07121 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 07122 { 07123 __failure = 20; 07124 if (!PyErr_Occurred()) { 07125 PyErr_SetString(PyExc_RuntimeError, 07126 "Unexpected error in an Op's C code. " 07127 "No Python exception was set."); 07128 } 07129 goto __label_20;} 07130 } 07131 // We expect NPY_FLOAT64 07132 if (!PyArray_ISALIGNED((PyArrayObject*) py_V19)) { 07133 PyArrayObject * tmp = (PyArrayObject*) py_V19; 07134 PyErr_Format(PyExc_NotImplementedError, 07135 "expected an aligned array of type %ld " 07136 "(NPY_FLOAT64), got non-aligned array of type %ld" 07137 " with %ld dimensions, with 3 last dims " 07138 "%ld, %ld, %ld" 07139 " and 3 last strides %ld %ld, %ld.", 07140 (long int) NPY_FLOAT64, 07141 (long int) PyArray_TYPE((PyArrayObject*) py_V19), 07142 (long int) PyArray_NDIM(tmp), 07143 (long int) (PyArray_NDIM(tmp) >= 3 ? 07144 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 07145 (long int) (PyArray_NDIM(tmp) >= 2 ? 07146 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 07147 (long int) (PyArray_NDIM(tmp) >= 1 ? 07148 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 07149 (long int) (PyArray_NDIM(tmp) >= 3 ? 07150 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 07151 (long int) (PyArray_NDIM(tmp) >= 2 ? 07152 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 07153 (long int) (PyArray_NDIM(tmp) >= 1 ? 07154 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 07155 ); 07156 { 07157 __failure = 20; 07158 if (!PyErr_Occurred()) { 07159 PyErr_SetString(PyExc_RuntimeError, 07160 "Unexpected error in an Op's C code. " 07161 "No Python exception was set."); 07162 } 07163 goto __label_20;} 07164 } 07165 // This is a TypeError to be consistent with DEBUG_MODE 07166 // Note: DEBUG_MODE also tells the name of the container 07167 if (PyArray_TYPE((PyArrayObject*) py_V19) != NPY_FLOAT64) { 07168 PyErr_Format(PyExc_TypeError, 07169 "expected type_num %d (NPY_FLOAT64) got %d", 07170 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V19)); 07171 { 07172 __failure = 20; 07173 if (!PyErr_Occurred()) { 07174 PyErr_SetString(PyExc_RuntimeError, 07175 "Unexpected error in an Op's C code. " 07176 "No Python exception was set."); 07177 } 07178 goto __label_20;} 07179 } 07180 07181 V19 = (PyArrayObject*)(py_V19); 07182 Py_XINCREF(V19); 07183 07184 { 07185 07186 py_V21 = PyList_GET_ITEM(storage_V21, 0); 07187 {Py_XINCREF(py_V21);} 07188 07189 V21 = NULL; 07190 if (py_V21 == Py_None) { 07191 // We can either fail here or set V21 to NULL and rely on Ops 07192 // using tensors to handle the NULL case, but if they fail to do so 07193 // they'll end up with nasty segfaults, so this is public service. 07194 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 07195 { 07196 __failure = 22; 07197 if (!PyErr_Occurred()) { 07198 PyErr_SetString(PyExc_RuntimeError, 07199 "Unexpected error in an Op's C code. " 07200 "No Python exception was set."); 07201 } 07202 goto __label_22;} 07203 } 07204 if (!PyArray_Check(py_V21)) { 07205 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 07206 { 07207 __failure = 22; 07208 if (!PyErr_Occurred()) { 07209 PyErr_SetString(PyExc_RuntimeError, 07210 "Unexpected error in an Op's C code. " 07211 "No Python exception was set."); 07212 } 07213 goto __label_22;} 07214 } 07215 // We expect NPY_FLOAT64 07216 if (!PyArray_ISALIGNED((PyArrayObject*) py_V21)) { 07217 PyArrayObject * tmp = (PyArrayObject*) py_V21; 07218 PyErr_Format(PyExc_NotImplementedError, 07219 "expected an aligned array of type %ld " 07220 "(NPY_FLOAT64), got non-aligned array of type %ld" 07221 " with %ld dimensions, with 3 last dims " 07222 "%ld, %ld, %ld" 07223 " and 3 last strides %ld %ld, %ld.", 07224 (long int) NPY_FLOAT64, 07225 (long int) PyArray_TYPE((PyArrayObject*) py_V21), 07226 (long int) PyArray_NDIM(tmp), 07227 (long int) (PyArray_NDIM(tmp) >= 3 ? 07228 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 07229 (long int) (PyArray_NDIM(tmp) >= 2 ? 07230 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 07231 (long int) (PyArray_NDIM(tmp) >= 1 ? 07232 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 07233 (long int) (PyArray_NDIM(tmp) >= 3 ? 07234 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 07235 (long int) (PyArray_NDIM(tmp) >= 2 ? 07236 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 07237 (long int) (PyArray_NDIM(tmp) >= 1 ? 07238 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 07239 ); 07240 { 07241 __failure = 22; 07242 if (!PyErr_Occurred()) { 07243 PyErr_SetString(PyExc_RuntimeError, 07244 "Unexpected error in an Op's C code. " 07245 "No Python exception was set."); 07246 } 07247 goto __label_22;} 07248 } 07249 // This is a TypeError to be consistent with DEBUG_MODE 07250 // Note: DEBUG_MODE also tells the name of the container 07251 if (PyArray_TYPE((PyArrayObject*) py_V21) != NPY_FLOAT64) { 07252 PyErr_Format(PyExc_TypeError, 07253 "expected type_num %d (NPY_FLOAT64) got %d", 07254 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V21)); 07255 { 07256 __failure = 22; 07257 if (!PyErr_Occurred()) { 07258 PyErr_SetString(PyExc_RuntimeError, 07259 "Unexpected error in an Op's C code. " 07260 "No Python exception was set."); 07261 } 07262 goto __label_22;} 07263 } 07264 07265 V21 = (PyArrayObject*)(py_V21); 07266 Py_XINCREF(V21); 07267 07268 { 07269 07270 py_V23 = PyList_GET_ITEM(storage_V23, 0); 07271 {Py_XINCREF(py_V23);} 07272 07273 V23 = NULL; 07274 if (py_V23 == Py_None) { 07275 // We can either fail here or set V23 to NULL and rely on Ops 07276 // using tensors to handle the NULL case, but if they fail to do so 07277 // they'll end up with nasty segfaults, so this is public service. 07278 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 07279 { 07280 __failure = 24; 07281 if (!PyErr_Occurred()) { 07282 PyErr_SetString(PyExc_RuntimeError, 07283 "Unexpected error in an Op's C code. " 07284 "No Python exception was set."); 07285 } 07286 goto __label_24;} 07287 } 07288 if (!PyArray_Check(py_V23)) { 07289 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 07290 { 07291 __failure = 24; 07292 if (!PyErr_Occurred()) { 07293 PyErr_SetString(PyExc_RuntimeError, 07294 "Unexpected error in an Op's C code. " 07295 "No Python exception was set."); 07296 } 07297 goto __label_24;} 07298 } 07299 // We expect NPY_FLOAT64 07300 if (!PyArray_ISALIGNED((PyArrayObject*) py_V23)) { 07301 PyArrayObject * tmp = (PyArrayObject*) py_V23; 07302 PyErr_Format(PyExc_NotImplementedError, 07303 "expected an aligned array of type %ld " 07304 "(NPY_FLOAT64), got non-aligned array of type %ld" 07305 " with %ld dimensions, with 3 last dims " 07306 "%ld, %ld, %ld" 07307 " and 3 last strides %ld %ld, %ld.", 07308 (long int) NPY_FLOAT64, 07309 (long int) PyArray_TYPE((PyArrayObject*) py_V23), 07310 (long int) PyArray_NDIM(tmp), 07311 (long int) (PyArray_NDIM(tmp) >= 3 ? 07312 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 07313 (long int) (PyArray_NDIM(tmp) >= 2 ? 07314 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 07315 (long int) (PyArray_NDIM(tmp) >= 1 ? 07316 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 07317 (long int) (PyArray_NDIM(tmp) >= 3 ? 07318 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 07319 (long int) (PyArray_NDIM(tmp) >= 2 ? 07320 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 07321 (long int) (PyArray_NDIM(tmp) >= 1 ? 07322 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 07323 ); 07324 { 07325 __failure = 24; 07326 if (!PyErr_Occurred()) { 07327 PyErr_SetString(PyExc_RuntimeError, 07328 "Unexpected error in an Op's C code. " 07329 "No Python exception was set."); 07330 } 07331 goto __label_24;} 07332 } 07333 // This is a TypeError to be consistent with DEBUG_MODE 07334 // Note: DEBUG_MODE also tells the name of the container 07335 if (PyArray_TYPE((PyArrayObject*) py_V23) != NPY_FLOAT64) { 07336 PyErr_Format(PyExc_TypeError, 07337 "expected type_num %d (NPY_FLOAT64) got %d", 07338 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V23)); 07339 { 07340 __failure = 24; 07341 if (!PyErr_Occurred()) { 07342 PyErr_SetString(PyExc_RuntimeError, 07343 "Unexpected error in an Op's C code. " 07344 "No Python exception was set."); 07345 } 07346 goto __label_24;} 07347 } 07348 07349 V23 = (PyArrayObject*)(py_V23); 07350 Py_XINCREF(V23); 07351 07352 { 07353 07354 py_V25 = PyList_GET_ITEM(storage_V25, 0); 07355 {Py_XINCREF(py_V25);} 07356 07357 V25 = NULL; 07358 if (py_V25 == Py_None) { 07359 // We can either fail here or set V25 to NULL and rely on Ops 07360 // using tensors to handle the NULL case, but if they fail to do so 07361 // they'll end up with nasty segfaults, so this is public service. 07362 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 07363 { 07364 __failure = 26; 07365 if (!PyErr_Occurred()) { 07366 PyErr_SetString(PyExc_RuntimeError, 07367 "Unexpected error in an Op's C code. " 07368 "No Python exception was set."); 07369 } 07370 goto __label_26;} 07371 } 07372 if (!PyArray_Check(py_V25)) { 07373 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 07374 { 07375 __failure = 26; 07376 if (!PyErr_Occurred()) { 07377 PyErr_SetString(PyExc_RuntimeError, 07378 "Unexpected error in an Op's C code. " 07379 "No Python exception was set."); 07380 } 07381 goto __label_26;} 07382 } 07383 // We expect NPY_FLOAT64 07384 if (!PyArray_ISALIGNED((PyArrayObject*) py_V25)) { 07385 PyArrayObject * tmp = (PyArrayObject*) py_V25; 07386 PyErr_Format(PyExc_NotImplementedError, 07387 "expected an aligned array of type %ld " 07388 "(NPY_FLOAT64), got non-aligned array of type %ld" 07389 " with %ld dimensions, with 3 last dims " 07390 "%ld, %ld, %ld" 07391 " and 3 last strides %ld %ld, %ld.", 07392 (long int) NPY_FLOAT64, 07393 (long int) PyArray_TYPE((PyArrayObject*) py_V25), 07394 (long int) PyArray_NDIM(tmp), 07395 (long int) (PyArray_NDIM(tmp) >= 3 ? 07396 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 07397 (long int) (PyArray_NDIM(tmp) >= 2 ? 07398 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 07399 (long int) (PyArray_NDIM(tmp) >= 1 ? 07400 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 07401 (long int) (PyArray_NDIM(tmp) >= 3 ? 07402 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 07403 (long int) (PyArray_NDIM(tmp) >= 2 ? 07404 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 07405 (long int) (PyArray_NDIM(tmp) >= 1 ? 07406 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 07407 ); 07408 { 07409 __failure = 26; 07410 if (!PyErr_Occurred()) { 07411 PyErr_SetString(PyExc_RuntimeError, 07412 "Unexpected error in an Op's C code. " 07413 "No Python exception was set."); 07414 } 07415 goto __label_26;} 07416 } 07417 // This is a TypeError to be consistent with DEBUG_MODE 07418 // Note: DEBUG_MODE also tells the name of the container 07419 if (PyArray_TYPE((PyArrayObject*) py_V25) != NPY_FLOAT64) { 07420 PyErr_Format(PyExc_TypeError, 07421 "expected type_num %d (NPY_FLOAT64) got %d", 07422 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V25)); 07423 { 07424 __failure = 26; 07425 if (!PyErr_Occurred()) { 07426 PyErr_SetString(PyExc_RuntimeError, 07427 "Unexpected error in an Op's C code. " 07428 "No Python exception was set."); 07429 } 07430 goto __label_26;} 07431 } 07432 07433 V25 = (PyArrayObject*)(py_V25); 07434 Py_XINCREF(V25); 07435 07436 { 07437 07438 py_V27 = PyList_GET_ITEM(storage_V27, 0); 07439 {Py_XINCREF(py_V27);} 07440 07441 V27 = NULL; 07442 if (py_V27 == Py_None) { 07443 // We can either fail here or set V27 to NULL and rely on Ops 07444 // using tensors to handle the NULL case, but if they fail to do so 07445 // they'll end up with nasty segfaults, so this is public service. 07446 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 07447 { 07448 __failure = 28; 07449 if (!PyErr_Occurred()) { 07450 PyErr_SetString(PyExc_RuntimeError, 07451 "Unexpected error in an Op's C code. " 07452 "No Python exception was set."); 07453 } 07454 goto __label_28;} 07455 } 07456 if (!PyArray_Check(py_V27)) { 07457 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 07458 { 07459 __failure = 28; 07460 if (!PyErr_Occurred()) { 07461 PyErr_SetString(PyExc_RuntimeError, 07462 "Unexpected error in an Op's C code. " 07463 "No Python exception was set."); 07464 } 07465 goto __label_28;} 07466 } 07467 // We expect NPY_FLOAT64 07468 if (!PyArray_ISALIGNED((PyArrayObject*) py_V27)) { 07469 PyArrayObject * tmp = (PyArrayObject*) py_V27; 07470 PyErr_Format(PyExc_NotImplementedError, 07471 "expected an aligned array of type %ld " 07472 "(NPY_FLOAT64), got non-aligned array of type %ld" 07473 " with %ld dimensions, with 3 last dims " 07474 "%ld, %ld, %ld" 07475 " and 3 last strides %ld %ld, %ld.", 07476 (long int) NPY_FLOAT64, 07477 (long int) PyArray_TYPE((PyArrayObject*) py_V27), 07478 (long int) PyArray_NDIM(tmp), 07479 (long int) (PyArray_NDIM(tmp) >= 3 ? 07480 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 07481 (long int) (PyArray_NDIM(tmp) >= 2 ? 07482 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 07483 (long int) (PyArray_NDIM(tmp) >= 1 ? 07484 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 07485 (long int) (PyArray_NDIM(tmp) >= 3 ? 07486 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 07487 (long int) (PyArray_NDIM(tmp) >= 2 ? 07488 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 07489 (long int) (PyArray_NDIM(tmp) >= 1 ? 07490 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 07491 ); 07492 { 07493 __failure = 28; 07494 if (!PyErr_Occurred()) { 07495 PyErr_SetString(PyExc_RuntimeError, 07496 "Unexpected error in an Op's C code. " 07497 "No Python exception was set."); 07498 } 07499 goto __label_28;} 07500 } 07501 // This is a TypeError to be consistent with DEBUG_MODE 07502 // Note: DEBUG_MODE also tells the name of the container 07503 if (PyArray_TYPE((PyArrayObject*) py_V27) != NPY_FLOAT64) { 07504 PyErr_Format(PyExc_TypeError, 07505 "expected type_num %d (NPY_FLOAT64) got %d", 07506 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V27)); 07507 { 07508 __failure = 28; 07509 if (!PyErr_Occurred()) { 07510 PyErr_SetString(PyExc_RuntimeError, 07511 "Unexpected error in an Op's C code. " 07512 "No Python exception was set."); 07513 } 07514 goto __label_28;} 07515 } 07516 07517 V27 = (PyArrayObject*)(py_V27); 07518 Py_XINCREF(V27); 07519 07520 { 07521 07522 py_V29 = PyList_GET_ITEM(storage_V29, 0); 07523 {Py_XINCREF(py_V29);} 07524 07525 V29 = NULL; 07526 if (py_V29 == Py_None) { 07527 // We can either fail here or set V29 to NULL and rely on Ops 07528 // using tensors to handle the NULL case, but if they fail to do so 07529 // they'll end up with nasty segfaults, so this is public service. 07530 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 07531 { 07532 __failure = 30; 07533 if (!PyErr_Occurred()) { 07534 PyErr_SetString(PyExc_RuntimeError, 07535 "Unexpected error in an Op's C code. " 07536 "No Python exception was set."); 07537 } 07538 goto __label_30;} 07539 } 07540 if (!PyArray_Check(py_V29)) { 07541 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 07542 { 07543 __failure = 30; 07544 if (!PyErr_Occurred()) { 07545 PyErr_SetString(PyExc_RuntimeError, 07546 "Unexpected error in an Op's C code. " 07547 "No Python exception was set."); 07548 } 07549 goto __label_30;} 07550 } 07551 // We expect NPY_FLOAT64 07552 if (!PyArray_ISALIGNED((PyArrayObject*) py_V29)) { 07553 PyArrayObject * tmp = (PyArrayObject*) py_V29; 07554 PyErr_Format(PyExc_NotImplementedError, 07555 "expected an aligned array of type %ld " 07556 "(NPY_FLOAT64), got non-aligned array of type %ld" 07557 " with %ld dimensions, with 3 last dims " 07558 "%ld, %ld, %ld" 07559 " and 3 last strides %ld %ld, %ld.", 07560 (long int) NPY_FLOAT64, 07561 (long int) PyArray_TYPE((PyArrayObject*) py_V29), 07562 (long int) PyArray_NDIM(tmp), 07563 (long int) (PyArray_NDIM(tmp) >= 3 ? 07564 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 07565 (long int) (PyArray_NDIM(tmp) >= 2 ? 07566 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 07567 (long int) (PyArray_NDIM(tmp) >= 1 ? 07568 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 07569 (long int) (PyArray_NDIM(tmp) >= 3 ? 07570 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 07571 (long int) (PyArray_NDIM(tmp) >= 2 ? 07572 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 07573 (long int) (PyArray_NDIM(tmp) >= 1 ? 07574 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 07575 ); 07576 { 07577 __failure = 30; 07578 if (!PyErr_Occurred()) { 07579 PyErr_SetString(PyExc_RuntimeError, 07580 "Unexpected error in an Op's C code. " 07581 "No Python exception was set."); 07582 } 07583 goto __label_30;} 07584 } 07585 // This is a TypeError to be consistent with DEBUG_MODE 07586 // Note: DEBUG_MODE also tells the name of the container 07587 if (PyArray_TYPE((PyArrayObject*) py_V29) != NPY_FLOAT64) { 07588 PyErr_Format(PyExc_TypeError, 07589 "expected type_num %d (NPY_FLOAT64) got %d", 07590 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V29)); 07591 { 07592 __failure = 30; 07593 if (!PyErr_Occurred()) { 07594 PyErr_SetString(PyExc_RuntimeError, 07595 "Unexpected error in an Op's C code. " 07596 "No Python exception was set."); 07597 } 07598 goto __label_30;} 07599 } 07600 07601 V29 = (PyArrayObject*)(py_V29); 07602 Py_XINCREF(V29); 07603 07604 { 07605 07606 py_V31 = PyList_GET_ITEM(storage_V31, 0); 07607 {Py_XINCREF(py_V31);} 07608 07609 V31 = NULL; 07610 if (py_V31 == Py_None) { 07611 // We can either fail here or set V31 to NULL and rely on Ops 07612 // using tensors to handle the NULL case, but if they fail to do so 07613 // they'll end up with nasty segfaults, so this is public service. 07614 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 07615 { 07616 __failure = 32; 07617 if (!PyErr_Occurred()) { 07618 PyErr_SetString(PyExc_RuntimeError, 07619 "Unexpected error in an Op's C code. " 07620 "No Python exception was set."); 07621 } 07622 goto __label_32;} 07623 } 07624 if (!PyArray_Check(py_V31)) { 07625 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 07626 { 07627 __failure = 32; 07628 if (!PyErr_Occurred()) { 07629 PyErr_SetString(PyExc_RuntimeError, 07630 "Unexpected error in an Op's C code. " 07631 "No Python exception was set."); 07632 } 07633 goto __label_32;} 07634 } 07635 // We expect NPY_FLOAT64 07636 if (!PyArray_ISALIGNED((PyArrayObject*) py_V31)) { 07637 PyArrayObject * tmp = (PyArrayObject*) py_V31; 07638 PyErr_Format(PyExc_NotImplementedError, 07639 "expected an aligned array of type %ld " 07640 "(NPY_FLOAT64), got non-aligned array of type %ld" 07641 " with %ld dimensions, with 3 last dims " 07642 "%ld, %ld, %ld" 07643 " and 3 last strides %ld %ld, %ld.", 07644 (long int) NPY_FLOAT64, 07645 (long int) PyArray_TYPE((PyArrayObject*) py_V31), 07646 (long int) PyArray_NDIM(tmp), 07647 (long int) (PyArray_NDIM(tmp) >= 3 ? 07648 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 07649 (long int) (PyArray_NDIM(tmp) >= 2 ? 07650 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 07651 (long int) (PyArray_NDIM(tmp) >= 1 ? 07652 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 07653 (long int) (PyArray_NDIM(tmp) >= 3 ? 07654 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 07655 (long int) (PyArray_NDIM(tmp) >= 2 ? 07656 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 07657 (long int) (PyArray_NDIM(tmp) >= 1 ? 07658 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 07659 ); 07660 { 07661 __failure = 32; 07662 if (!PyErr_Occurred()) { 07663 PyErr_SetString(PyExc_RuntimeError, 07664 "Unexpected error in an Op's C code. " 07665 "No Python exception was set."); 07666 } 07667 goto __label_32;} 07668 } 07669 // This is a TypeError to be consistent with DEBUG_MODE 07670 // Note: DEBUG_MODE also tells the name of the container 07671 if (PyArray_TYPE((PyArrayObject*) py_V31) != NPY_FLOAT64) { 07672 PyErr_Format(PyExc_TypeError, 07673 "expected type_num %d (NPY_FLOAT64) got %d", 07674 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V31)); 07675 { 07676 __failure = 32; 07677 if (!PyErr_Occurred()) { 07678 PyErr_SetString(PyExc_RuntimeError, 07679 "Unexpected error in an Op's C code. " 07680 "No Python exception was set."); 07681 } 07682 goto __label_32;} 07683 } 07684 07685 V31 = (PyArrayObject*)(py_V31); 07686 Py_XINCREF(V31); 07687 07688 { 07689 07690 py_V33 = PyList_GET_ITEM(storage_V33, 0); 07691 {Py_XINCREF(py_V33);} 07692 07693 V33 = NULL; 07694 if (py_V33 == Py_None) { 07695 // We can either fail here or set V33 to NULL and rely on Ops 07696 // using tensors to handle the NULL case, but if they fail to do so 07697 // they'll end up with nasty segfaults, so this is public service. 07698 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 07699 { 07700 __failure = 34; 07701 if (!PyErr_Occurred()) { 07702 PyErr_SetString(PyExc_RuntimeError, 07703 "Unexpected error in an Op's C code. " 07704 "No Python exception was set."); 07705 } 07706 goto __label_34;} 07707 } 07708 if (!PyArray_Check(py_V33)) { 07709 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 07710 { 07711 __failure = 34; 07712 if (!PyErr_Occurred()) { 07713 PyErr_SetString(PyExc_RuntimeError, 07714 "Unexpected error in an Op's C code. " 07715 "No Python exception was set."); 07716 } 07717 goto __label_34;} 07718 } 07719 // We expect NPY_FLOAT64 07720 if (!PyArray_ISALIGNED((PyArrayObject*) py_V33)) { 07721 PyArrayObject * tmp = (PyArrayObject*) py_V33; 07722 PyErr_Format(PyExc_NotImplementedError, 07723 "expected an aligned array of type %ld " 07724 "(NPY_FLOAT64), got non-aligned array of type %ld" 07725 " with %ld dimensions, with 3 last dims " 07726 "%ld, %ld, %ld" 07727 " and 3 last strides %ld %ld, %ld.", 07728 (long int) NPY_FLOAT64, 07729 (long int) PyArray_TYPE((PyArrayObject*) py_V33), 07730 (long int) PyArray_NDIM(tmp), 07731 (long int) (PyArray_NDIM(tmp) >= 3 ? 07732 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 07733 (long int) (PyArray_NDIM(tmp) >= 2 ? 07734 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 07735 (long int) (PyArray_NDIM(tmp) >= 1 ? 07736 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 07737 (long int) (PyArray_NDIM(tmp) >= 3 ? 07738 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 07739 (long int) (PyArray_NDIM(tmp) >= 2 ? 07740 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 07741 (long int) (PyArray_NDIM(tmp) >= 1 ? 07742 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 07743 ); 07744 { 07745 __failure = 34; 07746 if (!PyErr_Occurred()) { 07747 PyErr_SetString(PyExc_RuntimeError, 07748 "Unexpected error in an Op's C code. " 07749 "No Python exception was set."); 07750 } 07751 goto __label_34;} 07752 } 07753 // This is a TypeError to be consistent with DEBUG_MODE 07754 // Note: DEBUG_MODE also tells the name of the container 07755 if (PyArray_TYPE((PyArrayObject*) py_V33) != NPY_FLOAT64) { 07756 PyErr_Format(PyExc_TypeError, 07757 "expected type_num %d (NPY_FLOAT64) got %d", 07758 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V33)); 07759 { 07760 __failure = 34; 07761 if (!PyErr_Occurred()) { 07762 PyErr_SetString(PyExc_RuntimeError, 07763 "Unexpected error in an Op's C code. " 07764 "No Python exception was set."); 07765 } 07766 goto __label_34;} 07767 } 07768 07769 V33 = (PyArrayObject*)(py_V33); 07770 Py_XINCREF(V33); 07771 07772 { 07773 07774 py_V35 = PyList_GET_ITEM(storage_V35, 0); 07775 {Py_XINCREF(py_V35);} 07776 07777 V35 = NULL; 07778 if (py_V35 == Py_None) { 07779 // We can either fail here or set V35 to NULL and rely on Ops 07780 // using tensors to handle the NULL case, but if they fail to do so 07781 // they'll end up with nasty segfaults, so this is public service. 07782 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 07783 { 07784 __failure = 36; 07785 if (!PyErr_Occurred()) { 07786 PyErr_SetString(PyExc_RuntimeError, 07787 "Unexpected error in an Op's C code. " 07788 "No Python exception was set."); 07789 } 07790 goto __label_36;} 07791 } 07792 if (!PyArray_Check(py_V35)) { 07793 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 07794 { 07795 __failure = 36; 07796 if (!PyErr_Occurred()) { 07797 PyErr_SetString(PyExc_RuntimeError, 07798 "Unexpected error in an Op's C code. " 07799 "No Python exception was set."); 07800 } 07801 goto __label_36;} 07802 } 07803 // We expect NPY_FLOAT64 07804 if (!PyArray_ISALIGNED((PyArrayObject*) py_V35)) { 07805 PyArrayObject * tmp = (PyArrayObject*) py_V35; 07806 PyErr_Format(PyExc_NotImplementedError, 07807 "expected an aligned array of type %ld " 07808 "(NPY_FLOAT64), got non-aligned array of type %ld" 07809 " with %ld dimensions, with 3 last dims " 07810 "%ld, %ld, %ld" 07811 " and 3 last strides %ld %ld, %ld.", 07812 (long int) NPY_FLOAT64, 07813 (long int) PyArray_TYPE((PyArrayObject*) py_V35), 07814 (long int) PyArray_NDIM(tmp), 07815 (long int) (PyArray_NDIM(tmp) >= 3 ? 07816 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 07817 (long int) (PyArray_NDIM(tmp) >= 2 ? 07818 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 07819 (long int) (PyArray_NDIM(tmp) >= 1 ? 07820 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 07821 (long int) (PyArray_NDIM(tmp) >= 3 ? 07822 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 07823 (long int) (PyArray_NDIM(tmp) >= 2 ? 07824 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 07825 (long int) (PyArray_NDIM(tmp) >= 1 ? 07826 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 07827 ); 07828 { 07829 __failure = 36; 07830 if (!PyErr_Occurred()) { 07831 PyErr_SetString(PyExc_RuntimeError, 07832 "Unexpected error in an Op's C code. " 07833 "No Python exception was set."); 07834 } 07835 goto __label_36;} 07836 } 07837 // This is a TypeError to be consistent with DEBUG_MODE 07838 // Note: DEBUG_MODE also tells the name of the container 07839 if (PyArray_TYPE((PyArrayObject*) py_V35) != NPY_FLOAT64) { 07840 PyErr_Format(PyExc_TypeError, 07841 "expected type_num %d (NPY_FLOAT64) got %d", 07842 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V35)); 07843 { 07844 __failure = 36; 07845 if (!PyErr_Occurred()) { 07846 PyErr_SetString(PyExc_RuntimeError, 07847 "Unexpected error in an Op's C code. " 07848 "No Python exception was set."); 07849 } 07850 goto __label_36;} 07851 } 07852 07853 V35 = (PyArrayObject*)(py_V35); 07854 Py_XINCREF(V35); 07855 07856 { 07857 07858 py_V37 = PyList_GET_ITEM(storage_V37, 0); 07859 {Py_XINCREF(py_V37);} 07860 07861 V37 = NULL; 07862 if (py_V37 == Py_None) { 07863 // We can either fail here or set V37 to NULL and rely on Ops 07864 // using tensors to handle the NULL case, but if they fail to do so 07865 // they'll end up with nasty segfaults, so this is public service. 07866 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 07867 { 07868 __failure = 38; 07869 if (!PyErr_Occurred()) { 07870 PyErr_SetString(PyExc_RuntimeError, 07871 "Unexpected error in an Op's C code. " 07872 "No Python exception was set."); 07873 } 07874 goto __label_38;} 07875 } 07876 if (!PyArray_Check(py_V37)) { 07877 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 07878 { 07879 __failure = 38; 07880 if (!PyErr_Occurred()) { 07881 PyErr_SetString(PyExc_RuntimeError, 07882 "Unexpected error in an Op's C code. " 07883 "No Python exception was set."); 07884 } 07885 goto __label_38;} 07886 } 07887 // We expect NPY_FLOAT64 07888 if (!PyArray_ISALIGNED((PyArrayObject*) py_V37)) { 07889 PyArrayObject * tmp = (PyArrayObject*) py_V37; 07890 PyErr_Format(PyExc_NotImplementedError, 07891 "expected an aligned array of type %ld " 07892 "(NPY_FLOAT64), got non-aligned array of type %ld" 07893 " with %ld dimensions, with 3 last dims " 07894 "%ld, %ld, %ld" 07895 " and 3 last strides %ld %ld, %ld.", 07896 (long int) NPY_FLOAT64, 07897 (long int) PyArray_TYPE((PyArrayObject*) py_V37), 07898 (long int) PyArray_NDIM(tmp), 07899 (long int) (PyArray_NDIM(tmp) >= 3 ? 07900 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 07901 (long int) (PyArray_NDIM(tmp) >= 2 ? 07902 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 07903 (long int) (PyArray_NDIM(tmp) >= 1 ? 07904 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 07905 (long int) (PyArray_NDIM(tmp) >= 3 ? 07906 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 07907 (long int) (PyArray_NDIM(tmp) >= 2 ? 07908 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 07909 (long int) (PyArray_NDIM(tmp) >= 1 ? 07910 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 07911 ); 07912 { 07913 __failure = 38; 07914 if (!PyErr_Occurred()) { 07915 PyErr_SetString(PyExc_RuntimeError, 07916 "Unexpected error in an Op's C code. " 07917 "No Python exception was set."); 07918 } 07919 goto __label_38;} 07920 } 07921 // This is a TypeError to be consistent with DEBUG_MODE 07922 // Note: DEBUG_MODE also tells the name of the container 07923 if (PyArray_TYPE((PyArrayObject*) py_V37) != NPY_FLOAT64) { 07924 PyErr_Format(PyExc_TypeError, 07925 "expected type_num %d (NPY_FLOAT64) got %d", 07926 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V37)); 07927 { 07928 __failure = 38; 07929 if (!PyErr_Occurred()) { 07930 PyErr_SetString(PyExc_RuntimeError, 07931 "Unexpected error in an Op's C code. " 07932 "No Python exception was set."); 07933 } 07934 goto __label_38;} 07935 } 07936 07937 V37 = (PyArrayObject*)(py_V37); 07938 Py_XINCREF(V37); 07939 07940 { 07941 07942 py_V39 = PyList_GET_ITEM(storage_V39, 0); 07943 {Py_XINCREF(py_V39);} 07944 07945 V39 = NULL; 07946 if (py_V39 == Py_None) { 07947 // We can either fail here or set V39 to NULL and rely on Ops 07948 // using tensors to handle the NULL case, but if they fail to do so 07949 // they'll end up with nasty segfaults, so this is public service. 07950 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 07951 { 07952 __failure = 40; 07953 if (!PyErr_Occurred()) { 07954 PyErr_SetString(PyExc_RuntimeError, 07955 "Unexpected error in an Op's C code. " 07956 "No Python exception was set."); 07957 } 07958 goto __label_40;} 07959 } 07960 if (!PyArray_Check(py_V39)) { 07961 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 07962 { 07963 __failure = 40; 07964 if (!PyErr_Occurred()) { 07965 PyErr_SetString(PyExc_RuntimeError, 07966 "Unexpected error in an Op's C code. " 07967 "No Python exception was set."); 07968 } 07969 goto __label_40;} 07970 } 07971 // We expect NPY_FLOAT64 07972 if (!PyArray_ISALIGNED((PyArrayObject*) py_V39)) { 07973 PyArrayObject * tmp = (PyArrayObject*) py_V39; 07974 PyErr_Format(PyExc_NotImplementedError, 07975 "expected an aligned array of type %ld " 07976 "(NPY_FLOAT64), got non-aligned array of type %ld" 07977 " with %ld dimensions, with 3 last dims " 07978 "%ld, %ld, %ld" 07979 " and 3 last strides %ld %ld, %ld.", 07980 (long int) NPY_FLOAT64, 07981 (long int) PyArray_TYPE((PyArrayObject*) py_V39), 07982 (long int) PyArray_NDIM(tmp), 07983 (long int) (PyArray_NDIM(tmp) >= 3 ? 07984 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 07985 (long int) (PyArray_NDIM(tmp) >= 2 ? 07986 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 07987 (long int) (PyArray_NDIM(tmp) >= 1 ? 07988 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 07989 (long int) (PyArray_NDIM(tmp) >= 3 ? 07990 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 07991 (long int) (PyArray_NDIM(tmp) >= 2 ? 07992 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 07993 (long int) (PyArray_NDIM(tmp) >= 1 ? 07994 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 07995 ); 07996 { 07997 __failure = 40; 07998 if (!PyErr_Occurred()) { 07999 PyErr_SetString(PyExc_RuntimeError, 08000 "Unexpected error in an Op's C code. " 08001 "No Python exception was set."); 08002 } 08003 goto __label_40;} 08004 } 08005 // This is a TypeError to be consistent with DEBUG_MODE 08006 // Note: DEBUG_MODE also tells the name of the container 08007 if (PyArray_TYPE((PyArrayObject*) py_V39) != NPY_FLOAT64) { 08008 PyErr_Format(PyExc_TypeError, 08009 "expected type_num %d (NPY_FLOAT64) got %d", 08010 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V39)); 08011 { 08012 __failure = 40; 08013 if (!PyErr_Occurred()) { 08014 PyErr_SetString(PyExc_RuntimeError, 08015 "Unexpected error in an Op's C code. " 08016 "No Python exception was set."); 08017 } 08018 goto __label_40;} 08019 } 08020 08021 V39 = (PyArrayObject*)(py_V39); 08022 Py_XINCREF(V39); 08023 08024 { 08025 08026 py_V41 = PyList_GET_ITEM(storage_V41, 0); 08027 {Py_XINCREF(py_V41);} 08028 08029 V41 = NULL; 08030 if (py_V41 == Py_None) { 08031 // We can either fail here or set V41 to NULL and rely on Ops 08032 // using tensors to handle the NULL case, but if they fail to do so 08033 // they'll end up with nasty segfaults, so this is public service. 08034 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 08035 { 08036 __failure = 42; 08037 if (!PyErr_Occurred()) { 08038 PyErr_SetString(PyExc_RuntimeError, 08039 "Unexpected error in an Op's C code. " 08040 "No Python exception was set."); 08041 } 08042 goto __label_42;} 08043 } 08044 if (!PyArray_Check(py_V41)) { 08045 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 08046 { 08047 __failure = 42; 08048 if (!PyErr_Occurred()) { 08049 PyErr_SetString(PyExc_RuntimeError, 08050 "Unexpected error in an Op's C code. " 08051 "No Python exception was set."); 08052 } 08053 goto __label_42;} 08054 } 08055 // We expect NPY_FLOAT64 08056 if (!PyArray_ISALIGNED((PyArrayObject*) py_V41)) { 08057 PyArrayObject * tmp = (PyArrayObject*) py_V41; 08058 PyErr_Format(PyExc_NotImplementedError, 08059 "expected an aligned array of type %ld " 08060 "(NPY_FLOAT64), got non-aligned array of type %ld" 08061 " with %ld dimensions, with 3 last dims " 08062 "%ld, %ld, %ld" 08063 " and 3 last strides %ld %ld, %ld.", 08064 (long int) NPY_FLOAT64, 08065 (long int) PyArray_TYPE((PyArrayObject*) py_V41), 08066 (long int) PyArray_NDIM(tmp), 08067 (long int) (PyArray_NDIM(tmp) >= 3 ? 08068 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 08069 (long int) (PyArray_NDIM(tmp) >= 2 ? 08070 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 08071 (long int) (PyArray_NDIM(tmp) >= 1 ? 08072 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 08073 (long int) (PyArray_NDIM(tmp) >= 3 ? 08074 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 08075 (long int) (PyArray_NDIM(tmp) >= 2 ? 08076 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 08077 (long int) (PyArray_NDIM(tmp) >= 1 ? 08078 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 08079 ); 08080 { 08081 __failure = 42; 08082 if (!PyErr_Occurred()) { 08083 PyErr_SetString(PyExc_RuntimeError, 08084 "Unexpected error in an Op's C code. " 08085 "No Python exception was set."); 08086 } 08087 goto __label_42;} 08088 } 08089 // This is a TypeError to be consistent with DEBUG_MODE 08090 // Note: DEBUG_MODE also tells the name of the container 08091 if (PyArray_TYPE((PyArrayObject*) py_V41) != NPY_FLOAT64) { 08092 PyErr_Format(PyExc_TypeError, 08093 "expected type_num %d (NPY_FLOAT64) got %d", 08094 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V41)); 08095 { 08096 __failure = 42; 08097 if (!PyErr_Occurred()) { 08098 PyErr_SetString(PyExc_RuntimeError, 08099 "Unexpected error in an Op's C code. " 08100 "No Python exception was set."); 08101 } 08102 goto __label_42;} 08103 } 08104 08105 V41 = (PyArrayObject*)(py_V41); 08106 Py_XINCREF(V41); 08107 08108 { 08109 08110 py_V43 = PyList_GET_ITEM(storage_V43, 0); 08111 {Py_XINCREF(py_V43);} 08112 08113 V43 = NULL; 08114 if (py_V43 == Py_None) { 08115 // We can either fail here or set V43 to NULL and rely on Ops 08116 // using tensors to handle the NULL case, but if they fail to do so 08117 // they'll end up with nasty segfaults, so this is public service. 08118 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 08119 { 08120 __failure = 44; 08121 if (!PyErr_Occurred()) { 08122 PyErr_SetString(PyExc_RuntimeError, 08123 "Unexpected error in an Op's C code. " 08124 "No Python exception was set."); 08125 } 08126 goto __label_44;} 08127 } 08128 if (!PyArray_Check(py_V43)) { 08129 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 08130 { 08131 __failure = 44; 08132 if (!PyErr_Occurred()) { 08133 PyErr_SetString(PyExc_RuntimeError, 08134 "Unexpected error in an Op's C code. " 08135 "No Python exception was set."); 08136 } 08137 goto __label_44;} 08138 } 08139 // We expect NPY_FLOAT64 08140 if (!PyArray_ISALIGNED((PyArrayObject*) py_V43)) { 08141 PyArrayObject * tmp = (PyArrayObject*) py_V43; 08142 PyErr_Format(PyExc_NotImplementedError, 08143 "expected an aligned array of type %ld " 08144 "(NPY_FLOAT64), got non-aligned array of type %ld" 08145 " with %ld dimensions, with 3 last dims " 08146 "%ld, %ld, %ld" 08147 " and 3 last strides %ld %ld, %ld.", 08148 (long int) NPY_FLOAT64, 08149 (long int) PyArray_TYPE((PyArrayObject*) py_V43), 08150 (long int) PyArray_NDIM(tmp), 08151 (long int) (PyArray_NDIM(tmp) >= 3 ? 08152 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 08153 (long int) (PyArray_NDIM(tmp) >= 2 ? 08154 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 08155 (long int) (PyArray_NDIM(tmp) >= 1 ? 08156 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 08157 (long int) (PyArray_NDIM(tmp) >= 3 ? 08158 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 08159 (long int) (PyArray_NDIM(tmp) >= 2 ? 08160 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 08161 (long int) (PyArray_NDIM(tmp) >= 1 ? 08162 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 08163 ); 08164 { 08165 __failure = 44; 08166 if (!PyErr_Occurred()) { 08167 PyErr_SetString(PyExc_RuntimeError, 08168 "Unexpected error in an Op's C code. " 08169 "No Python exception was set."); 08170 } 08171 goto __label_44;} 08172 } 08173 // This is a TypeError to be consistent with DEBUG_MODE 08174 // Note: DEBUG_MODE also tells the name of the container 08175 if (PyArray_TYPE((PyArrayObject*) py_V43) != NPY_FLOAT64) { 08176 PyErr_Format(PyExc_TypeError, 08177 "expected type_num %d (NPY_FLOAT64) got %d", 08178 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V43)); 08179 { 08180 __failure = 44; 08181 if (!PyErr_Occurred()) { 08182 PyErr_SetString(PyExc_RuntimeError, 08183 "Unexpected error in an Op's C code. " 08184 "No Python exception was set."); 08185 } 08186 goto __label_44;} 08187 } 08188 08189 V43 = (PyArrayObject*)(py_V43); 08190 Py_XINCREF(V43); 08191 08192 { 08193 08194 py_V45 = PyList_GET_ITEM(storage_V45, 0); 08195 {Py_XINCREF(py_V45);} 08196 08197 V45 = NULL; 08198 if (py_V45 == Py_None) { 08199 // We can either fail here or set V45 to NULL and rely on Ops 08200 // using tensors to handle the NULL case, but if they fail to do so 08201 // they'll end up with nasty segfaults, so this is public service. 08202 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 08203 { 08204 __failure = 46; 08205 if (!PyErr_Occurred()) { 08206 PyErr_SetString(PyExc_RuntimeError, 08207 "Unexpected error in an Op's C code. " 08208 "No Python exception was set."); 08209 } 08210 goto __label_46;} 08211 } 08212 if (!PyArray_Check(py_V45)) { 08213 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 08214 { 08215 __failure = 46; 08216 if (!PyErr_Occurred()) { 08217 PyErr_SetString(PyExc_RuntimeError, 08218 "Unexpected error in an Op's C code. " 08219 "No Python exception was set."); 08220 } 08221 goto __label_46;} 08222 } 08223 // We expect NPY_FLOAT64 08224 if (!PyArray_ISALIGNED((PyArrayObject*) py_V45)) { 08225 PyArrayObject * tmp = (PyArrayObject*) py_V45; 08226 PyErr_Format(PyExc_NotImplementedError, 08227 "expected an aligned array of type %ld " 08228 "(NPY_FLOAT64), got non-aligned array of type %ld" 08229 " with %ld dimensions, with 3 last dims " 08230 "%ld, %ld, %ld" 08231 " and 3 last strides %ld %ld, %ld.", 08232 (long int) NPY_FLOAT64, 08233 (long int) PyArray_TYPE((PyArrayObject*) py_V45), 08234 (long int) PyArray_NDIM(tmp), 08235 (long int) (PyArray_NDIM(tmp) >= 3 ? 08236 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 08237 (long int) (PyArray_NDIM(tmp) >= 2 ? 08238 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 08239 (long int) (PyArray_NDIM(tmp) >= 1 ? 08240 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 08241 (long int) (PyArray_NDIM(tmp) >= 3 ? 08242 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 08243 (long int) (PyArray_NDIM(tmp) >= 2 ? 08244 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 08245 (long int) (PyArray_NDIM(tmp) >= 1 ? 08246 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 08247 ); 08248 { 08249 __failure = 46; 08250 if (!PyErr_Occurred()) { 08251 PyErr_SetString(PyExc_RuntimeError, 08252 "Unexpected error in an Op's C code. " 08253 "No Python exception was set."); 08254 } 08255 goto __label_46;} 08256 } 08257 // This is a TypeError to be consistent with DEBUG_MODE 08258 // Note: DEBUG_MODE also tells the name of the container 08259 if (PyArray_TYPE((PyArrayObject*) py_V45) != NPY_FLOAT64) { 08260 PyErr_Format(PyExc_TypeError, 08261 "expected type_num %d (NPY_FLOAT64) got %d", 08262 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V45)); 08263 { 08264 __failure = 46; 08265 if (!PyErr_Occurred()) { 08266 PyErr_SetString(PyExc_RuntimeError, 08267 "Unexpected error in an Op's C code. " 08268 "No Python exception was set."); 08269 } 08270 goto __label_46;} 08271 } 08272 08273 V45 = (PyArrayObject*)(py_V45); 08274 Py_XINCREF(V45); 08275 08276 { 08277 08278 py_V47 = PyList_GET_ITEM(storage_V47, 0); 08279 {Py_XINCREF(py_V47);} 08280 08281 V47 = NULL; 08282 if (py_V47 == Py_None) { 08283 // We can either fail here or set V47 to NULL and rely on Ops 08284 // using tensors to handle the NULL case, but if they fail to do so 08285 // they'll end up with nasty segfaults, so this is public service. 08286 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 08287 { 08288 __failure = 48; 08289 if (!PyErr_Occurred()) { 08290 PyErr_SetString(PyExc_RuntimeError, 08291 "Unexpected error in an Op's C code. " 08292 "No Python exception was set."); 08293 } 08294 goto __label_48;} 08295 } 08296 if (!PyArray_Check(py_V47)) { 08297 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 08298 { 08299 __failure = 48; 08300 if (!PyErr_Occurred()) { 08301 PyErr_SetString(PyExc_RuntimeError, 08302 "Unexpected error in an Op's C code. " 08303 "No Python exception was set."); 08304 } 08305 goto __label_48;} 08306 } 08307 // We expect NPY_FLOAT64 08308 if (!PyArray_ISALIGNED((PyArrayObject*) py_V47)) { 08309 PyArrayObject * tmp = (PyArrayObject*) py_V47; 08310 PyErr_Format(PyExc_NotImplementedError, 08311 "expected an aligned array of type %ld " 08312 "(NPY_FLOAT64), got non-aligned array of type %ld" 08313 " with %ld dimensions, with 3 last dims " 08314 "%ld, %ld, %ld" 08315 " and 3 last strides %ld %ld, %ld.", 08316 (long int) NPY_FLOAT64, 08317 (long int) PyArray_TYPE((PyArrayObject*) py_V47), 08318 (long int) PyArray_NDIM(tmp), 08319 (long int) (PyArray_NDIM(tmp) >= 3 ? 08320 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 08321 (long int) (PyArray_NDIM(tmp) >= 2 ? 08322 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 08323 (long int) (PyArray_NDIM(tmp) >= 1 ? 08324 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 08325 (long int) (PyArray_NDIM(tmp) >= 3 ? 08326 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 08327 (long int) (PyArray_NDIM(tmp) >= 2 ? 08328 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 08329 (long int) (PyArray_NDIM(tmp) >= 1 ? 08330 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 08331 ); 08332 { 08333 __failure = 48; 08334 if (!PyErr_Occurred()) { 08335 PyErr_SetString(PyExc_RuntimeError, 08336 "Unexpected error in an Op's C code. " 08337 "No Python exception was set."); 08338 } 08339 goto __label_48;} 08340 } 08341 // This is a TypeError to be consistent with DEBUG_MODE 08342 // Note: DEBUG_MODE also tells the name of the container 08343 if (PyArray_TYPE((PyArrayObject*) py_V47) != NPY_FLOAT64) { 08344 PyErr_Format(PyExc_TypeError, 08345 "expected type_num %d (NPY_FLOAT64) got %d", 08346 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V47)); 08347 { 08348 __failure = 48; 08349 if (!PyErr_Occurred()) { 08350 PyErr_SetString(PyExc_RuntimeError, 08351 "Unexpected error in an Op's C code. " 08352 "No Python exception was set."); 08353 } 08354 goto __label_48;} 08355 } 08356 08357 V47 = (PyArrayObject*)(py_V47); 08358 Py_XINCREF(V47); 08359 08360 { 08361 08362 py_V49 = PyList_GET_ITEM(storage_V49, 0); 08363 {Py_XINCREF(py_V49);} 08364 08365 V49 = NULL; 08366 if (py_V49 == Py_None) { 08367 // We can either fail here or set V49 to NULL and rely on Ops 08368 // using tensors to handle the NULL case, but if they fail to do so 08369 // they'll end up with nasty segfaults, so this is public service. 08370 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 08371 { 08372 __failure = 50; 08373 if (!PyErr_Occurred()) { 08374 PyErr_SetString(PyExc_RuntimeError, 08375 "Unexpected error in an Op's C code. " 08376 "No Python exception was set."); 08377 } 08378 goto __label_50;} 08379 } 08380 if (!PyArray_Check(py_V49)) { 08381 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 08382 { 08383 __failure = 50; 08384 if (!PyErr_Occurred()) { 08385 PyErr_SetString(PyExc_RuntimeError, 08386 "Unexpected error in an Op's C code. " 08387 "No Python exception was set."); 08388 } 08389 goto __label_50;} 08390 } 08391 // We expect NPY_FLOAT64 08392 if (!PyArray_ISALIGNED((PyArrayObject*) py_V49)) { 08393 PyArrayObject * tmp = (PyArrayObject*) py_V49; 08394 PyErr_Format(PyExc_NotImplementedError, 08395 "expected an aligned array of type %ld " 08396 "(NPY_FLOAT64), got non-aligned array of type %ld" 08397 " with %ld dimensions, with 3 last dims " 08398 "%ld, %ld, %ld" 08399 " and 3 last strides %ld %ld, %ld.", 08400 (long int) NPY_FLOAT64, 08401 (long int) PyArray_TYPE((PyArrayObject*) py_V49), 08402 (long int) PyArray_NDIM(tmp), 08403 (long int) (PyArray_NDIM(tmp) >= 3 ? 08404 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 08405 (long int) (PyArray_NDIM(tmp) >= 2 ? 08406 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 08407 (long int) (PyArray_NDIM(tmp) >= 1 ? 08408 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 08409 (long int) (PyArray_NDIM(tmp) >= 3 ? 08410 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 08411 (long int) (PyArray_NDIM(tmp) >= 2 ? 08412 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 08413 (long int) (PyArray_NDIM(tmp) >= 1 ? 08414 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 08415 ); 08416 { 08417 __failure = 50; 08418 if (!PyErr_Occurred()) { 08419 PyErr_SetString(PyExc_RuntimeError, 08420 "Unexpected error in an Op's C code. " 08421 "No Python exception was set."); 08422 } 08423 goto __label_50;} 08424 } 08425 // This is a TypeError to be consistent with DEBUG_MODE 08426 // Note: DEBUG_MODE also tells the name of the container 08427 if (PyArray_TYPE((PyArrayObject*) py_V49) != NPY_FLOAT64) { 08428 PyErr_Format(PyExc_TypeError, 08429 "expected type_num %d (NPY_FLOAT64) got %d", 08430 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V49)); 08431 { 08432 __failure = 50; 08433 if (!PyErr_Occurred()) { 08434 PyErr_SetString(PyExc_RuntimeError, 08435 "Unexpected error in an Op's C code. " 08436 "No Python exception was set."); 08437 } 08438 goto __label_50;} 08439 } 08440 08441 V49 = (PyArrayObject*)(py_V49); 08442 Py_XINCREF(V49); 08443 08444 { 08445 08446 py_V51 = PyList_GET_ITEM(storage_V51, 0); 08447 {Py_XINCREF(py_V51);} 08448 08449 V51 = NULL; 08450 if (py_V51 == Py_None) { 08451 // We can either fail here or set V51 to NULL and rely on Ops 08452 // using tensors to handle the NULL case, but if they fail to do so 08453 // they'll end up with nasty segfaults, so this is public service. 08454 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 08455 { 08456 __failure = 52; 08457 if (!PyErr_Occurred()) { 08458 PyErr_SetString(PyExc_RuntimeError, 08459 "Unexpected error in an Op's C code. " 08460 "No Python exception was set."); 08461 } 08462 goto __label_52;} 08463 } 08464 if (!PyArray_Check(py_V51)) { 08465 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 08466 { 08467 __failure = 52; 08468 if (!PyErr_Occurred()) { 08469 PyErr_SetString(PyExc_RuntimeError, 08470 "Unexpected error in an Op's C code. " 08471 "No Python exception was set."); 08472 } 08473 goto __label_52;} 08474 } 08475 // We expect NPY_FLOAT64 08476 if (!PyArray_ISALIGNED((PyArrayObject*) py_V51)) { 08477 PyArrayObject * tmp = (PyArrayObject*) py_V51; 08478 PyErr_Format(PyExc_NotImplementedError, 08479 "expected an aligned array of type %ld " 08480 "(NPY_FLOAT64), got non-aligned array of type %ld" 08481 " with %ld dimensions, with 3 last dims " 08482 "%ld, %ld, %ld" 08483 " and 3 last strides %ld %ld, %ld.", 08484 (long int) NPY_FLOAT64, 08485 (long int) PyArray_TYPE((PyArrayObject*) py_V51), 08486 (long int) PyArray_NDIM(tmp), 08487 (long int) (PyArray_NDIM(tmp) >= 3 ? 08488 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 08489 (long int) (PyArray_NDIM(tmp) >= 2 ? 08490 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 08491 (long int) (PyArray_NDIM(tmp) >= 1 ? 08492 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 08493 (long int) (PyArray_NDIM(tmp) >= 3 ? 08494 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 08495 (long int) (PyArray_NDIM(tmp) >= 2 ? 08496 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 08497 (long int) (PyArray_NDIM(tmp) >= 1 ? 08498 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 08499 ); 08500 { 08501 __failure = 52; 08502 if (!PyErr_Occurred()) { 08503 PyErr_SetString(PyExc_RuntimeError, 08504 "Unexpected error in an Op's C code. " 08505 "No Python exception was set."); 08506 } 08507 goto __label_52;} 08508 } 08509 // This is a TypeError to be consistent with DEBUG_MODE 08510 // Note: DEBUG_MODE also tells the name of the container 08511 if (PyArray_TYPE((PyArrayObject*) py_V51) != NPY_FLOAT64) { 08512 PyErr_Format(PyExc_TypeError, 08513 "expected type_num %d (NPY_FLOAT64) got %d", 08514 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V51)); 08515 { 08516 __failure = 52; 08517 if (!PyErr_Occurred()) { 08518 PyErr_SetString(PyExc_RuntimeError, 08519 "Unexpected error in an Op's C code. " 08520 "No Python exception was set."); 08521 } 08522 goto __label_52;} 08523 } 08524 08525 V51 = (PyArrayObject*)(py_V51); 08526 Py_XINCREF(V51); 08527 08528 { 08529 08530 py_V53 = PyList_GET_ITEM(storage_V53, 0); 08531 {Py_XINCREF(py_V53);} 08532 08533 V53 = NULL; 08534 if (py_V53 == Py_None) { 08535 // We can either fail here or set V53 to NULL and rely on Ops 08536 // using tensors to handle the NULL case, but if they fail to do so 08537 // they'll end up with nasty segfaults, so this is public service. 08538 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 08539 { 08540 __failure = 54; 08541 if (!PyErr_Occurred()) { 08542 PyErr_SetString(PyExc_RuntimeError, 08543 "Unexpected error in an Op's C code. " 08544 "No Python exception was set."); 08545 } 08546 goto __label_54;} 08547 } 08548 if (!PyArray_Check(py_V53)) { 08549 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 08550 { 08551 __failure = 54; 08552 if (!PyErr_Occurred()) { 08553 PyErr_SetString(PyExc_RuntimeError, 08554 "Unexpected error in an Op's C code. " 08555 "No Python exception was set."); 08556 } 08557 goto __label_54;} 08558 } 08559 // We expect NPY_FLOAT64 08560 if (!PyArray_ISALIGNED((PyArrayObject*) py_V53)) { 08561 PyArrayObject * tmp = (PyArrayObject*) py_V53; 08562 PyErr_Format(PyExc_NotImplementedError, 08563 "expected an aligned array of type %ld " 08564 "(NPY_FLOAT64), got non-aligned array of type %ld" 08565 " with %ld dimensions, with 3 last dims " 08566 "%ld, %ld, %ld" 08567 " and 3 last strides %ld %ld, %ld.", 08568 (long int) NPY_FLOAT64, 08569 (long int) PyArray_TYPE((PyArrayObject*) py_V53), 08570 (long int) PyArray_NDIM(tmp), 08571 (long int) (PyArray_NDIM(tmp) >= 3 ? 08572 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 08573 (long int) (PyArray_NDIM(tmp) >= 2 ? 08574 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 08575 (long int) (PyArray_NDIM(tmp) >= 1 ? 08576 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 08577 (long int) (PyArray_NDIM(tmp) >= 3 ? 08578 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 08579 (long int) (PyArray_NDIM(tmp) >= 2 ? 08580 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 08581 (long int) (PyArray_NDIM(tmp) >= 1 ? 08582 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 08583 ); 08584 { 08585 __failure = 54; 08586 if (!PyErr_Occurred()) { 08587 PyErr_SetString(PyExc_RuntimeError, 08588 "Unexpected error in an Op's C code. " 08589 "No Python exception was set."); 08590 } 08591 goto __label_54;} 08592 } 08593 // This is a TypeError to be consistent with DEBUG_MODE 08594 // Note: DEBUG_MODE also tells the name of the container 08595 if (PyArray_TYPE((PyArrayObject*) py_V53) != NPY_FLOAT64) { 08596 PyErr_Format(PyExc_TypeError, 08597 "expected type_num %d (NPY_FLOAT64) got %d", 08598 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V53)); 08599 { 08600 __failure = 54; 08601 if (!PyErr_Occurred()) { 08602 PyErr_SetString(PyExc_RuntimeError, 08603 "Unexpected error in an Op's C code. " 08604 "No Python exception was set."); 08605 } 08606 goto __label_54;} 08607 } 08608 08609 V53 = (PyArrayObject*)(py_V53); 08610 Py_XINCREF(V53); 08611 08612 { 08613 08614 py_V55 = PyList_GET_ITEM(storage_V55, 0); 08615 {Py_XINCREF(py_V55);} 08616 08617 V55 = NULL; 08618 if (py_V55 == Py_None) { 08619 // We can either fail here or set V55 to NULL and rely on Ops 08620 // using tensors to handle the NULL case, but if they fail to do so 08621 // they'll end up with nasty segfaults, so this is public service. 08622 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 08623 { 08624 __failure = 56; 08625 if (!PyErr_Occurred()) { 08626 PyErr_SetString(PyExc_RuntimeError, 08627 "Unexpected error in an Op's C code. " 08628 "No Python exception was set."); 08629 } 08630 goto __label_56;} 08631 } 08632 if (!PyArray_Check(py_V55)) { 08633 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 08634 { 08635 __failure = 56; 08636 if (!PyErr_Occurred()) { 08637 PyErr_SetString(PyExc_RuntimeError, 08638 "Unexpected error in an Op's C code. " 08639 "No Python exception was set."); 08640 } 08641 goto __label_56;} 08642 } 08643 // We expect NPY_FLOAT64 08644 if (!PyArray_ISALIGNED((PyArrayObject*) py_V55)) { 08645 PyArrayObject * tmp = (PyArrayObject*) py_V55; 08646 PyErr_Format(PyExc_NotImplementedError, 08647 "expected an aligned array of type %ld " 08648 "(NPY_FLOAT64), got non-aligned array of type %ld" 08649 " with %ld dimensions, with 3 last dims " 08650 "%ld, %ld, %ld" 08651 " and 3 last strides %ld %ld, %ld.", 08652 (long int) NPY_FLOAT64, 08653 (long int) PyArray_TYPE((PyArrayObject*) py_V55), 08654 (long int) PyArray_NDIM(tmp), 08655 (long int) (PyArray_NDIM(tmp) >= 3 ? 08656 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 08657 (long int) (PyArray_NDIM(tmp) >= 2 ? 08658 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 08659 (long int) (PyArray_NDIM(tmp) >= 1 ? 08660 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 08661 (long int) (PyArray_NDIM(tmp) >= 3 ? 08662 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 08663 (long int) (PyArray_NDIM(tmp) >= 2 ? 08664 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 08665 (long int) (PyArray_NDIM(tmp) >= 1 ? 08666 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 08667 ); 08668 { 08669 __failure = 56; 08670 if (!PyErr_Occurred()) { 08671 PyErr_SetString(PyExc_RuntimeError, 08672 "Unexpected error in an Op's C code. " 08673 "No Python exception was set."); 08674 } 08675 goto __label_56;} 08676 } 08677 // This is a TypeError to be consistent with DEBUG_MODE 08678 // Note: DEBUG_MODE also tells the name of the container 08679 if (PyArray_TYPE((PyArrayObject*) py_V55) != NPY_FLOAT64) { 08680 PyErr_Format(PyExc_TypeError, 08681 "expected type_num %d (NPY_FLOAT64) got %d", 08682 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V55)); 08683 { 08684 __failure = 56; 08685 if (!PyErr_Occurred()) { 08686 PyErr_SetString(PyExc_RuntimeError, 08687 "Unexpected error in an Op's C code. " 08688 "No Python exception was set."); 08689 } 08690 goto __label_56;} 08691 } 08692 08693 V55 = (PyArrayObject*)(py_V55); 08694 Py_XINCREF(V55); 08695 08696 { 08697 08698 py_V57 = PyList_GET_ITEM(storage_V57, 0); 08699 {Py_XINCREF(py_V57);} 08700 08701 V57 = NULL; 08702 if (py_V57 == Py_None) { 08703 // We can either fail here or set V57 to NULL and rely on Ops 08704 // using tensors to handle the NULL case, but if they fail to do so 08705 // they'll end up with nasty segfaults, so this is public service. 08706 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 08707 { 08708 __failure = 58; 08709 if (!PyErr_Occurred()) { 08710 PyErr_SetString(PyExc_RuntimeError, 08711 "Unexpected error in an Op's C code. " 08712 "No Python exception was set."); 08713 } 08714 goto __label_58;} 08715 } 08716 if (!PyArray_Check(py_V57)) { 08717 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 08718 { 08719 __failure = 58; 08720 if (!PyErr_Occurred()) { 08721 PyErr_SetString(PyExc_RuntimeError, 08722 "Unexpected error in an Op's C code. " 08723 "No Python exception was set."); 08724 } 08725 goto __label_58;} 08726 } 08727 // We expect NPY_FLOAT64 08728 if (!PyArray_ISALIGNED((PyArrayObject*) py_V57)) { 08729 PyArrayObject * tmp = (PyArrayObject*) py_V57; 08730 PyErr_Format(PyExc_NotImplementedError, 08731 "expected an aligned array of type %ld " 08732 "(NPY_FLOAT64), got non-aligned array of type %ld" 08733 " with %ld dimensions, with 3 last dims " 08734 "%ld, %ld, %ld" 08735 " and 3 last strides %ld %ld, %ld.", 08736 (long int) NPY_FLOAT64, 08737 (long int) PyArray_TYPE((PyArrayObject*) py_V57), 08738 (long int) PyArray_NDIM(tmp), 08739 (long int) (PyArray_NDIM(tmp) >= 3 ? 08740 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 08741 (long int) (PyArray_NDIM(tmp) >= 2 ? 08742 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 08743 (long int) (PyArray_NDIM(tmp) >= 1 ? 08744 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 08745 (long int) (PyArray_NDIM(tmp) >= 3 ? 08746 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 08747 (long int) (PyArray_NDIM(tmp) >= 2 ? 08748 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 08749 (long int) (PyArray_NDIM(tmp) >= 1 ? 08750 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 08751 ); 08752 { 08753 __failure = 58; 08754 if (!PyErr_Occurred()) { 08755 PyErr_SetString(PyExc_RuntimeError, 08756 "Unexpected error in an Op's C code. " 08757 "No Python exception was set."); 08758 } 08759 goto __label_58;} 08760 } 08761 // This is a TypeError to be consistent with DEBUG_MODE 08762 // Note: DEBUG_MODE also tells the name of the container 08763 if (PyArray_TYPE((PyArrayObject*) py_V57) != NPY_FLOAT64) { 08764 PyErr_Format(PyExc_TypeError, 08765 "expected type_num %d (NPY_FLOAT64) got %d", 08766 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V57)); 08767 { 08768 __failure = 58; 08769 if (!PyErr_Occurred()) { 08770 PyErr_SetString(PyExc_RuntimeError, 08771 "Unexpected error in an Op's C code. " 08772 "No Python exception was set."); 08773 } 08774 goto __label_58;} 08775 } 08776 08777 V57 = (PyArrayObject*)(py_V57); 08778 Py_XINCREF(V57); 08779 08780 { 08781 08782 py_V59 = PyList_GET_ITEM(storage_V59, 0); 08783 {Py_XINCREF(py_V59);} 08784 08785 V59 = NULL; 08786 if (py_V59 == Py_None) { 08787 // We can either fail here or set V59 to NULL and rely on Ops 08788 // using tensors to handle the NULL case, but if they fail to do so 08789 // they'll end up with nasty segfaults, so this is public service. 08790 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 08791 { 08792 __failure = 60; 08793 if (!PyErr_Occurred()) { 08794 PyErr_SetString(PyExc_RuntimeError, 08795 "Unexpected error in an Op's C code. " 08796 "No Python exception was set."); 08797 } 08798 goto __label_60;} 08799 } 08800 if (!PyArray_Check(py_V59)) { 08801 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 08802 { 08803 __failure = 60; 08804 if (!PyErr_Occurred()) { 08805 PyErr_SetString(PyExc_RuntimeError, 08806 "Unexpected error in an Op's C code. " 08807 "No Python exception was set."); 08808 } 08809 goto __label_60;} 08810 } 08811 // We expect NPY_FLOAT64 08812 if (!PyArray_ISALIGNED((PyArrayObject*) py_V59)) { 08813 PyArrayObject * tmp = (PyArrayObject*) py_V59; 08814 PyErr_Format(PyExc_NotImplementedError, 08815 "expected an aligned array of type %ld " 08816 "(NPY_FLOAT64), got non-aligned array of type %ld" 08817 " with %ld dimensions, with 3 last dims " 08818 "%ld, %ld, %ld" 08819 " and 3 last strides %ld %ld, %ld.", 08820 (long int) NPY_FLOAT64, 08821 (long int) PyArray_TYPE((PyArrayObject*) py_V59), 08822 (long int) PyArray_NDIM(tmp), 08823 (long int) (PyArray_NDIM(tmp) >= 3 ? 08824 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 08825 (long int) (PyArray_NDIM(tmp) >= 2 ? 08826 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 08827 (long int) (PyArray_NDIM(tmp) >= 1 ? 08828 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 08829 (long int) (PyArray_NDIM(tmp) >= 3 ? 08830 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 08831 (long int) (PyArray_NDIM(tmp) >= 2 ? 08832 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 08833 (long int) (PyArray_NDIM(tmp) >= 1 ? 08834 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 08835 ); 08836 { 08837 __failure = 60; 08838 if (!PyErr_Occurred()) { 08839 PyErr_SetString(PyExc_RuntimeError, 08840 "Unexpected error in an Op's C code. " 08841 "No Python exception was set."); 08842 } 08843 goto __label_60;} 08844 } 08845 // This is a TypeError to be consistent with DEBUG_MODE 08846 // Note: DEBUG_MODE also tells the name of the container 08847 if (PyArray_TYPE((PyArrayObject*) py_V59) != NPY_FLOAT64) { 08848 PyErr_Format(PyExc_TypeError, 08849 "expected type_num %d (NPY_FLOAT64) got %d", 08850 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V59)); 08851 { 08852 __failure = 60; 08853 if (!PyErr_Occurred()) { 08854 PyErr_SetString(PyExc_RuntimeError, 08855 "Unexpected error in an Op's C code. " 08856 "No Python exception was set."); 08857 } 08858 goto __label_60;} 08859 } 08860 08861 V59 = (PyArrayObject*)(py_V59); 08862 Py_XINCREF(V59); 08863 08864 { 08865 08866 py_V61 = PyList_GET_ITEM(storage_V61, 0); 08867 {Py_XINCREF(py_V61);} 08868 08869 V61 = NULL; 08870 if (py_V61 == Py_None) { 08871 // We can either fail here or set V61 to NULL and rely on Ops 08872 // using tensors to handle the NULL case, but if they fail to do so 08873 // they'll end up with nasty segfaults, so this is public service. 08874 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 08875 { 08876 __failure = 62; 08877 if (!PyErr_Occurred()) { 08878 PyErr_SetString(PyExc_RuntimeError, 08879 "Unexpected error in an Op's C code. " 08880 "No Python exception was set."); 08881 } 08882 goto __label_62;} 08883 } 08884 if (!PyArray_Check(py_V61)) { 08885 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 08886 { 08887 __failure = 62; 08888 if (!PyErr_Occurred()) { 08889 PyErr_SetString(PyExc_RuntimeError, 08890 "Unexpected error in an Op's C code. " 08891 "No Python exception was set."); 08892 } 08893 goto __label_62;} 08894 } 08895 // We expect NPY_FLOAT64 08896 if (!PyArray_ISALIGNED((PyArrayObject*) py_V61)) { 08897 PyArrayObject * tmp = (PyArrayObject*) py_V61; 08898 PyErr_Format(PyExc_NotImplementedError, 08899 "expected an aligned array of type %ld " 08900 "(NPY_FLOAT64), got non-aligned array of type %ld" 08901 " with %ld dimensions, with 3 last dims " 08902 "%ld, %ld, %ld" 08903 " and 3 last strides %ld %ld, %ld.", 08904 (long int) NPY_FLOAT64, 08905 (long int) PyArray_TYPE((PyArrayObject*) py_V61), 08906 (long int) PyArray_NDIM(tmp), 08907 (long int) (PyArray_NDIM(tmp) >= 3 ? 08908 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 08909 (long int) (PyArray_NDIM(tmp) >= 2 ? 08910 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 08911 (long int) (PyArray_NDIM(tmp) >= 1 ? 08912 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 08913 (long int) (PyArray_NDIM(tmp) >= 3 ? 08914 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 08915 (long int) (PyArray_NDIM(tmp) >= 2 ? 08916 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 08917 (long int) (PyArray_NDIM(tmp) >= 1 ? 08918 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 08919 ); 08920 { 08921 __failure = 62; 08922 if (!PyErr_Occurred()) { 08923 PyErr_SetString(PyExc_RuntimeError, 08924 "Unexpected error in an Op's C code. " 08925 "No Python exception was set."); 08926 } 08927 goto __label_62;} 08928 } 08929 // This is a TypeError to be consistent with DEBUG_MODE 08930 // Note: DEBUG_MODE also tells the name of the container 08931 if (PyArray_TYPE((PyArrayObject*) py_V61) != NPY_FLOAT64) { 08932 PyErr_Format(PyExc_TypeError, 08933 "expected type_num %d (NPY_FLOAT64) got %d", 08934 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V61)); 08935 { 08936 __failure = 62; 08937 if (!PyErr_Occurred()) { 08938 PyErr_SetString(PyExc_RuntimeError, 08939 "Unexpected error in an Op's C code. " 08940 "No Python exception was set."); 08941 } 08942 goto __label_62;} 08943 } 08944 08945 V61 = (PyArrayObject*)(py_V61); 08946 Py_XINCREF(V61); 08947 08948 { 08949 08950 py_V63 = PyList_GET_ITEM(storage_V63, 0); 08951 {Py_XINCREF(py_V63);} 08952 08953 V63 = NULL; 08954 if (py_V63 == Py_None) { 08955 // We can either fail here or set V63 to NULL and rely on Ops 08956 // using tensors to handle the NULL case, but if they fail to do so 08957 // they'll end up with nasty segfaults, so this is public service. 08958 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 08959 { 08960 __failure = 64; 08961 if (!PyErr_Occurred()) { 08962 PyErr_SetString(PyExc_RuntimeError, 08963 "Unexpected error in an Op's C code. " 08964 "No Python exception was set."); 08965 } 08966 goto __label_64;} 08967 } 08968 if (!PyArray_Check(py_V63)) { 08969 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 08970 { 08971 __failure = 64; 08972 if (!PyErr_Occurred()) { 08973 PyErr_SetString(PyExc_RuntimeError, 08974 "Unexpected error in an Op's C code. " 08975 "No Python exception was set."); 08976 } 08977 goto __label_64;} 08978 } 08979 // We expect NPY_FLOAT64 08980 if (!PyArray_ISALIGNED((PyArrayObject*) py_V63)) { 08981 PyArrayObject * tmp = (PyArrayObject*) py_V63; 08982 PyErr_Format(PyExc_NotImplementedError, 08983 "expected an aligned array of type %ld " 08984 "(NPY_FLOAT64), got non-aligned array of type %ld" 08985 " with %ld dimensions, with 3 last dims " 08986 "%ld, %ld, %ld" 08987 " and 3 last strides %ld %ld, %ld.", 08988 (long int) NPY_FLOAT64, 08989 (long int) PyArray_TYPE((PyArrayObject*) py_V63), 08990 (long int) PyArray_NDIM(tmp), 08991 (long int) (PyArray_NDIM(tmp) >= 3 ? 08992 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 08993 (long int) (PyArray_NDIM(tmp) >= 2 ? 08994 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 08995 (long int) (PyArray_NDIM(tmp) >= 1 ? 08996 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 08997 (long int) (PyArray_NDIM(tmp) >= 3 ? 08998 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 08999 (long int) (PyArray_NDIM(tmp) >= 2 ? 09000 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 09001 (long int) (PyArray_NDIM(tmp) >= 1 ? 09002 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 09003 ); 09004 { 09005 __failure = 64; 09006 if (!PyErr_Occurred()) { 09007 PyErr_SetString(PyExc_RuntimeError, 09008 "Unexpected error in an Op's C code. " 09009 "No Python exception was set."); 09010 } 09011 goto __label_64;} 09012 } 09013 // This is a TypeError to be consistent with DEBUG_MODE 09014 // Note: DEBUG_MODE also tells the name of the container 09015 if (PyArray_TYPE((PyArrayObject*) py_V63) != NPY_FLOAT64) { 09016 PyErr_Format(PyExc_TypeError, 09017 "expected type_num %d (NPY_FLOAT64) got %d", 09018 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V63)); 09019 { 09020 __failure = 64; 09021 if (!PyErr_Occurred()) { 09022 PyErr_SetString(PyExc_RuntimeError, 09023 "Unexpected error in an Op's C code. " 09024 "No Python exception was set."); 09025 } 09026 goto __label_64;} 09027 } 09028 09029 V63 = (PyArrayObject*)(py_V63); 09030 Py_XINCREF(V63); 09031 09032 { 09033 09034 py_V65 = PyList_GET_ITEM(storage_V65, 0); 09035 {Py_XINCREF(py_V65);} 09036 09037 V65 = NULL; 09038 if (py_V65 == Py_None) { 09039 // We can either fail here or set V65 to NULL and rely on Ops 09040 // using tensors to handle the NULL case, but if they fail to do so 09041 // they'll end up with nasty segfaults, so this is public service. 09042 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 09043 { 09044 __failure = 66; 09045 if (!PyErr_Occurred()) { 09046 PyErr_SetString(PyExc_RuntimeError, 09047 "Unexpected error in an Op's C code. " 09048 "No Python exception was set."); 09049 } 09050 goto __label_66;} 09051 } 09052 if (!PyArray_Check(py_V65)) { 09053 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 09054 { 09055 __failure = 66; 09056 if (!PyErr_Occurred()) { 09057 PyErr_SetString(PyExc_RuntimeError, 09058 "Unexpected error in an Op's C code. " 09059 "No Python exception was set."); 09060 } 09061 goto __label_66;} 09062 } 09063 // We expect NPY_FLOAT64 09064 if (!PyArray_ISALIGNED((PyArrayObject*) py_V65)) { 09065 PyArrayObject * tmp = (PyArrayObject*) py_V65; 09066 PyErr_Format(PyExc_NotImplementedError, 09067 "expected an aligned array of type %ld " 09068 "(NPY_FLOAT64), got non-aligned array of type %ld" 09069 " with %ld dimensions, with 3 last dims " 09070 "%ld, %ld, %ld" 09071 " and 3 last strides %ld %ld, %ld.", 09072 (long int) NPY_FLOAT64, 09073 (long int) PyArray_TYPE((PyArrayObject*) py_V65), 09074 (long int) PyArray_NDIM(tmp), 09075 (long int) (PyArray_NDIM(tmp) >= 3 ? 09076 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 09077 (long int) (PyArray_NDIM(tmp) >= 2 ? 09078 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 09079 (long int) (PyArray_NDIM(tmp) >= 1 ? 09080 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 09081 (long int) (PyArray_NDIM(tmp) >= 3 ? 09082 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 09083 (long int) (PyArray_NDIM(tmp) >= 2 ? 09084 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 09085 (long int) (PyArray_NDIM(tmp) >= 1 ? 09086 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 09087 ); 09088 { 09089 __failure = 66; 09090 if (!PyErr_Occurred()) { 09091 PyErr_SetString(PyExc_RuntimeError, 09092 "Unexpected error in an Op's C code. " 09093 "No Python exception was set."); 09094 } 09095 goto __label_66;} 09096 } 09097 // This is a TypeError to be consistent with DEBUG_MODE 09098 // Note: DEBUG_MODE also tells the name of the container 09099 if (PyArray_TYPE((PyArrayObject*) py_V65) != NPY_FLOAT64) { 09100 PyErr_Format(PyExc_TypeError, 09101 "expected type_num %d (NPY_FLOAT64) got %d", 09102 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V65)); 09103 { 09104 __failure = 66; 09105 if (!PyErr_Occurred()) { 09106 PyErr_SetString(PyExc_RuntimeError, 09107 "Unexpected error in an Op's C code. " 09108 "No Python exception was set."); 09109 } 09110 goto __label_66;} 09111 } 09112 09113 V65 = (PyArrayObject*)(py_V65); 09114 Py_XINCREF(V65); 09115 09116 { 09117 09118 py_V67 = PyList_GET_ITEM(storage_V67, 0); 09119 {Py_XINCREF(py_V67);} 09120 09121 V67 = NULL; 09122 if (py_V67 == Py_None) { 09123 // We can either fail here or set V67 to NULL and rely on Ops 09124 // using tensors to handle the NULL case, but if they fail to do so 09125 // they'll end up with nasty segfaults, so this is public service. 09126 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 09127 { 09128 __failure = 68; 09129 if (!PyErr_Occurred()) { 09130 PyErr_SetString(PyExc_RuntimeError, 09131 "Unexpected error in an Op's C code. " 09132 "No Python exception was set."); 09133 } 09134 goto __label_68;} 09135 } 09136 if (!PyArray_Check(py_V67)) { 09137 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 09138 { 09139 __failure = 68; 09140 if (!PyErr_Occurred()) { 09141 PyErr_SetString(PyExc_RuntimeError, 09142 "Unexpected error in an Op's C code. " 09143 "No Python exception was set."); 09144 } 09145 goto __label_68;} 09146 } 09147 // We expect NPY_FLOAT64 09148 if (!PyArray_ISALIGNED((PyArrayObject*) py_V67)) { 09149 PyArrayObject * tmp = (PyArrayObject*) py_V67; 09150 PyErr_Format(PyExc_NotImplementedError, 09151 "expected an aligned array of type %ld " 09152 "(NPY_FLOAT64), got non-aligned array of type %ld" 09153 " with %ld dimensions, with 3 last dims " 09154 "%ld, %ld, %ld" 09155 " and 3 last strides %ld %ld, %ld.", 09156 (long int) NPY_FLOAT64, 09157 (long int) PyArray_TYPE((PyArrayObject*) py_V67), 09158 (long int) PyArray_NDIM(tmp), 09159 (long int) (PyArray_NDIM(tmp) >= 3 ? 09160 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 09161 (long int) (PyArray_NDIM(tmp) >= 2 ? 09162 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 09163 (long int) (PyArray_NDIM(tmp) >= 1 ? 09164 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 09165 (long int) (PyArray_NDIM(tmp) >= 3 ? 09166 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 09167 (long int) (PyArray_NDIM(tmp) >= 2 ? 09168 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 09169 (long int) (PyArray_NDIM(tmp) >= 1 ? 09170 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 09171 ); 09172 { 09173 __failure = 68; 09174 if (!PyErr_Occurred()) { 09175 PyErr_SetString(PyExc_RuntimeError, 09176 "Unexpected error in an Op's C code. " 09177 "No Python exception was set."); 09178 } 09179 goto __label_68;} 09180 } 09181 // This is a TypeError to be consistent with DEBUG_MODE 09182 // Note: DEBUG_MODE also tells the name of the container 09183 if (PyArray_TYPE((PyArrayObject*) py_V67) != NPY_FLOAT64) { 09184 PyErr_Format(PyExc_TypeError, 09185 "expected type_num %d (NPY_FLOAT64) got %d", 09186 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V67)); 09187 { 09188 __failure = 68; 09189 if (!PyErr_Occurred()) { 09190 PyErr_SetString(PyExc_RuntimeError, 09191 "Unexpected error in an Op's C code. " 09192 "No Python exception was set."); 09193 } 09194 goto __label_68;} 09195 } 09196 09197 V67 = (PyArrayObject*)(py_V67); 09198 Py_XINCREF(V67); 09199 09200 { 09201 09202 py_V69 = PyList_GET_ITEM(storage_V69, 0); 09203 {Py_XINCREF(py_V69);} 09204 09205 V69 = NULL; 09206 if (py_V69 == Py_None) { 09207 // We can either fail here or set V69 to NULL and rely on Ops 09208 // using tensors to handle the NULL case, but if they fail to do so 09209 // they'll end up with nasty segfaults, so this is public service. 09210 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 09211 { 09212 __failure = 70; 09213 if (!PyErr_Occurred()) { 09214 PyErr_SetString(PyExc_RuntimeError, 09215 "Unexpected error in an Op's C code. " 09216 "No Python exception was set."); 09217 } 09218 goto __label_70;} 09219 } 09220 if (!PyArray_Check(py_V69)) { 09221 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 09222 { 09223 __failure = 70; 09224 if (!PyErr_Occurred()) { 09225 PyErr_SetString(PyExc_RuntimeError, 09226 "Unexpected error in an Op's C code. " 09227 "No Python exception was set."); 09228 } 09229 goto __label_70;} 09230 } 09231 // We expect NPY_FLOAT64 09232 if (!PyArray_ISALIGNED((PyArrayObject*) py_V69)) { 09233 PyArrayObject * tmp = (PyArrayObject*) py_V69; 09234 PyErr_Format(PyExc_NotImplementedError, 09235 "expected an aligned array of type %ld " 09236 "(NPY_FLOAT64), got non-aligned array of type %ld" 09237 " with %ld dimensions, with 3 last dims " 09238 "%ld, %ld, %ld" 09239 " and 3 last strides %ld %ld, %ld.", 09240 (long int) NPY_FLOAT64, 09241 (long int) PyArray_TYPE((PyArrayObject*) py_V69), 09242 (long int) PyArray_NDIM(tmp), 09243 (long int) (PyArray_NDIM(tmp) >= 3 ? 09244 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 09245 (long int) (PyArray_NDIM(tmp) >= 2 ? 09246 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 09247 (long int) (PyArray_NDIM(tmp) >= 1 ? 09248 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 09249 (long int) (PyArray_NDIM(tmp) >= 3 ? 09250 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 09251 (long int) (PyArray_NDIM(tmp) >= 2 ? 09252 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 09253 (long int) (PyArray_NDIM(tmp) >= 1 ? 09254 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 09255 ); 09256 { 09257 __failure = 70; 09258 if (!PyErr_Occurred()) { 09259 PyErr_SetString(PyExc_RuntimeError, 09260 "Unexpected error in an Op's C code. " 09261 "No Python exception was set."); 09262 } 09263 goto __label_70;} 09264 } 09265 // This is a TypeError to be consistent with DEBUG_MODE 09266 // Note: DEBUG_MODE also tells the name of the container 09267 if (PyArray_TYPE((PyArrayObject*) py_V69) != NPY_FLOAT64) { 09268 PyErr_Format(PyExc_TypeError, 09269 "expected type_num %d (NPY_FLOAT64) got %d", 09270 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V69)); 09271 { 09272 __failure = 70; 09273 if (!PyErr_Occurred()) { 09274 PyErr_SetString(PyExc_RuntimeError, 09275 "Unexpected error in an Op's C code. " 09276 "No Python exception was set."); 09277 } 09278 goto __label_70;} 09279 } 09280 09281 V69 = (PyArrayObject*)(py_V69); 09282 Py_XINCREF(V69); 09283 09284 { 09285 09286 py_V71 = PyList_GET_ITEM(storage_V71, 0); 09287 {Py_XINCREF(py_V71);} 09288 09289 V71 = NULL; 09290 if (py_V71 == Py_None) { 09291 // We can either fail here or set V71 to NULL and rely on Ops 09292 // using tensors to handle the NULL case, but if they fail to do so 09293 // they'll end up with nasty segfaults, so this is public service. 09294 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 09295 { 09296 __failure = 72; 09297 if (!PyErr_Occurred()) { 09298 PyErr_SetString(PyExc_RuntimeError, 09299 "Unexpected error in an Op's C code. " 09300 "No Python exception was set."); 09301 } 09302 goto __label_72;} 09303 } 09304 if (!PyArray_Check(py_V71)) { 09305 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 09306 { 09307 __failure = 72; 09308 if (!PyErr_Occurred()) { 09309 PyErr_SetString(PyExc_RuntimeError, 09310 "Unexpected error in an Op's C code. " 09311 "No Python exception was set."); 09312 } 09313 goto __label_72;} 09314 } 09315 // We expect NPY_FLOAT64 09316 if (!PyArray_ISALIGNED((PyArrayObject*) py_V71)) { 09317 PyArrayObject * tmp = (PyArrayObject*) py_V71; 09318 PyErr_Format(PyExc_NotImplementedError, 09319 "expected an aligned array of type %ld " 09320 "(NPY_FLOAT64), got non-aligned array of type %ld" 09321 " with %ld dimensions, with 3 last dims " 09322 "%ld, %ld, %ld" 09323 " and 3 last strides %ld %ld, %ld.", 09324 (long int) NPY_FLOAT64, 09325 (long int) PyArray_TYPE((PyArrayObject*) py_V71), 09326 (long int) PyArray_NDIM(tmp), 09327 (long int) (PyArray_NDIM(tmp) >= 3 ? 09328 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 09329 (long int) (PyArray_NDIM(tmp) >= 2 ? 09330 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 09331 (long int) (PyArray_NDIM(tmp) >= 1 ? 09332 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 09333 (long int) (PyArray_NDIM(tmp) >= 3 ? 09334 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 09335 (long int) (PyArray_NDIM(tmp) >= 2 ? 09336 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 09337 (long int) (PyArray_NDIM(tmp) >= 1 ? 09338 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 09339 ); 09340 { 09341 __failure = 72; 09342 if (!PyErr_Occurred()) { 09343 PyErr_SetString(PyExc_RuntimeError, 09344 "Unexpected error in an Op's C code. " 09345 "No Python exception was set."); 09346 } 09347 goto __label_72;} 09348 } 09349 // This is a TypeError to be consistent with DEBUG_MODE 09350 // Note: DEBUG_MODE also tells the name of the container 09351 if (PyArray_TYPE((PyArrayObject*) py_V71) != NPY_FLOAT64) { 09352 PyErr_Format(PyExc_TypeError, 09353 "expected type_num %d (NPY_FLOAT64) got %d", 09354 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V71)); 09355 { 09356 __failure = 72; 09357 if (!PyErr_Occurred()) { 09358 PyErr_SetString(PyExc_RuntimeError, 09359 "Unexpected error in an Op's C code. " 09360 "No Python exception was set."); 09361 } 09362 goto __label_72;} 09363 } 09364 09365 V71 = (PyArrayObject*)(py_V71); 09366 Py_XINCREF(V71); 09367 09368 { 09369 09370 py_V73 = PyList_GET_ITEM(storage_V73, 0); 09371 {Py_XINCREF(py_V73);} 09372 09373 V73 = NULL; 09374 if (py_V73 == Py_None) { 09375 // We can either fail here or set V73 to NULL and rely on Ops 09376 // using tensors to handle the NULL case, but if they fail to do so 09377 // they'll end up with nasty segfaults, so this is public service. 09378 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 09379 { 09380 __failure = 74; 09381 if (!PyErr_Occurred()) { 09382 PyErr_SetString(PyExc_RuntimeError, 09383 "Unexpected error in an Op's C code. " 09384 "No Python exception was set."); 09385 } 09386 goto __label_74;} 09387 } 09388 if (!PyArray_Check(py_V73)) { 09389 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 09390 { 09391 __failure = 74; 09392 if (!PyErr_Occurred()) { 09393 PyErr_SetString(PyExc_RuntimeError, 09394 "Unexpected error in an Op's C code. " 09395 "No Python exception was set."); 09396 } 09397 goto __label_74;} 09398 } 09399 // We expect NPY_FLOAT64 09400 if (!PyArray_ISALIGNED((PyArrayObject*) py_V73)) { 09401 PyArrayObject * tmp = (PyArrayObject*) py_V73; 09402 PyErr_Format(PyExc_NotImplementedError, 09403 "expected an aligned array of type %ld " 09404 "(NPY_FLOAT64), got non-aligned array of type %ld" 09405 " with %ld dimensions, with 3 last dims " 09406 "%ld, %ld, %ld" 09407 " and 3 last strides %ld %ld, %ld.", 09408 (long int) NPY_FLOAT64, 09409 (long int) PyArray_TYPE((PyArrayObject*) py_V73), 09410 (long int) PyArray_NDIM(tmp), 09411 (long int) (PyArray_NDIM(tmp) >= 3 ? 09412 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 09413 (long int) (PyArray_NDIM(tmp) >= 2 ? 09414 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 09415 (long int) (PyArray_NDIM(tmp) >= 1 ? 09416 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 09417 (long int) (PyArray_NDIM(tmp) >= 3 ? 09418 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 09419 (long int) (PyArray_NDIM(tmp) >= 2 ? 09420 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 09421 (long int) (PyArray_NDIM(tmp) >= 1 ? 09422 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 09423 ); 09424 { 09425 __failure = 74; 09426 if (!PyErr_Occurred()) { 09427 PyErr_SetString(PyExc_RuntimeError, 09428 "Unexpected error in an Op's C code. " 09429 "No Python exception was set."); 09430 } 09431 goto __label_74;} 09432 } 09433 // This is a TypeError to be consistent with DEBUG_MODE 09434 // Note: DEBUG_MODE also tells the name of the container 09435 if (PyArray_TYPE((PyArrayObject*) py_V73) != NPY_FLOAT64) { 09436 PyErr_Format(PyExc_TypeError, 09437 "expected type_num %d (NPY_FLOAT64) got %d", 09438 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V73)); 09439 { 09440 __failure = 74; 09441 if (!PyErr_Occurred()) { 09442 PyErr_SetString(PyExc_RuntimeError, 09443 "Unexpected error in an Op's C code. " 09444 "No Python exception was set."); 09445 } 09446 goto __label_74;} 09447 } 09448 09449 V73 = (PyArrayObject*)(py_V73); 09450 Py_XINCREF(V73); 09451 09452 { 09453 09454 py_V75 = PyList_GET_ITEM(storage_V75, 0); 09455 {Py_XINCREF(py_V75);} 09456 09457 V75 = NULL; 09458 if (py_V75 == Py_None) { 09459 // We can either fail here or set V75 to NULL and rely on Ops 09460 // using tensors to handle the NULL case, but if they fail to do so 09461 // they'll end up with nasty segfaults, so this is public service. 09462 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 09463 { 09464 __failure = 76; 09465 if (!PyErr_Occurred()) { 09466 PyErr_SetString(PyExc_RuntimeError, 09467 "Unexpected error in an Op's C code. " 09468 "No Python exception was set."); 09469 } 09470 goto __label_76;} 09471 } 09472 if (!PyArray_Check(py_V75)) { 09473 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 09474 { 09475 __failure = 76; 09476 if (!PyErr_Occurred()) { 09477 PyErr_SetString(PyExc_RuntimeError, 09478 "Unexpected error in an Op's C code. " 09479 "No Python exception was set."); 09480 } 09481 goto __label_76;} 09482 } 09483 // We expect NPY_FLOAT64 09484 if (!PyArray_ISALIGNED((PyArrayObject*) py_V75)) { 09485 PyArrayObject * tmp = (PyArrayObject*) py_V75; 09486 PyErr_Format(PyExc_NotImplementedError, 09487 "expected an aligned array of type %ld " 09488 "(NPY_FLOAT64), got non-aligned array of type %ld" 09489 " with %ld dimensions, with 3 last dims " 09490 "%ld, %ld, %ld" 09491 " and 3 last strides %ld %ld, %ld.", 09492 (long int) NPY_FLOAT64, 09493 (long int) PyArray_TYPE((PyArrayObject*) py_V75), 09494 (long int) PyArray_NDIM(tmp), 09495 (long int) (PyArray_NDIM(tmp) >= 3 ? 09496 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 09497 (long int) (PyArray_NDIM(tmp) >= 2 ? 09498 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 09499 (long int) (PyArray_NDIM(tmp) >= 1 ? 09500 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 09501 (long int) (PyArray_NDIM(tmp) >= 3 ? 09502 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 09503 (long int) (PyArray_NDIM(tmp) >= 2 ? 09504 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 09505 (long int) (PyArray_NDIM(tmp) >= 1 ? 09506 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 09507 ); 09508 { 09509 __failure = 76; 09510 if (!PyErr_Occurred()) { 09511 PyErr_SetString(PyExc_RuntimeError, 09512 "Unexpected error in an Op's C code. " 09513 "No Python exception was set."); 09514 } 09515 goto __label_76;} 09516 } 09517 // This is a TypeError to be consistent with DEBUG_MODE 09518 // Note: DEBUG_MODE also tells the name of the container 09519 if (PyArray_TYPE((PyArrayObject*) py_V75) != NPY_FLOAT64) { 09520 PyErr_Format(PyExc_TypeError, 09521 "expected type_num %d (NPY_FLOAT64) got %d", 09522 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V75)); 09523 { 09524 __failure = 76; 09525 if (!PyErr_Occurred()) { 09526 PyErr_SetString(PyExc_RuntimeError, 09527 "Unexpected error in an Op's C code. " 09528 "No Python exception was set."); 09529 } 09530 goto __label_76;} 09531 } 09532 09533 V75 = (PyArrayObject*)(py_V75); 09534 Py_XINCREF(V75); 09535 09536 { 09537 09538 py_V77 = PyList_GET_ITEM(storage_V77, 0); 09539 {Py_XINCREF(py_V77);} 09540 09541 V77 = NULL; 09542 if (py_V77 == Py_None) { 09543 // We can either fail here or set V77 to NULL and rely on Ops 09544 // using tensors to handle the NULL case, but if they fail to do so 09545 // they'll end up with nasty segfaults, so this is public service. 09546 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 09547 { 09548 __failure = 78; 09549 if (!PyErr_Occurred()) { 09550 PyErr_SetString(PyExc_RuntimeError, 09551 "Unexpected error in an Op's C code. " 09552 "No Python exception was set."); 09553 } 09554 goto __label_78;} 09555 } 09556 if (!PyArray_Check(py_V77)) { 09557 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 09558 { 09559 __failure = 78; 09560 if (!PyErr_Occurred()) { 09561 PyErr_SetString(PyExc_RuntimeError, 09562 "Unexpected error in an Op's C code. " 09563 "No Python exception was set."); 09564 } 09565 goto __label_78;} 09566 } 09567 // We expect NPY_FLOAT64 09568 if (!PyArray_ISALIGNED((PyArrayObject*) py_V77)) { 09569 PyArrayObject * tmp = (PyArrayObject*) py_V77; 09570 PyErr_Format(PyExc_NotImplementedError, 09571 "expected an aligned array of type %ld " 09572 "(NPY_FLOAT64), got non-aligned array of type %ld" 09573 " with %ld dimensions, with 3 last dims " 09574 "%ld, %ld, %ld" 09575 " and 3 last strides %ld %ld, %ld.", 09576 (long int) NPY_FLOAT64, 09577 (long int) PyArray_TYPE((PyArrayObject*) py_V77), 09578 (long int) PyArray_NDIM(tmp), 09579 (long int) (PyArray_NDIM(tmp) >= 3 ? 09580 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 09581 (long int) (PyArray_NDIM(tmp) >= 2 ? 09582 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 09583 (long int) (PyArray_NDIM(tmp) >= 1 ? 09584 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 09585 (long int) (PyArray_NDIM(tmp) >= 3 ? 09586 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 09587 (long int) (PyArray_NDIM(tmp) >= 2 ? 09588 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 09589 (long int) (PyArray_NDIM(tmp) >= 1 ? 09590 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 09591 ); 09592 { 09593 __failure = 78; 09594 if (!PyErr_Occurred()) { 09595 PyErr_SetString(PyExc_RuntimeError, 09596 "Unexpected error in an Op's C code. " 09597 "No Python exception was set."); 09598 } 09599 goto __label_78;} 09600 } 09601 // This is a TypeError to be consistent with DEBUG_MODE 09602 // Note: DEBUG_MODE also tells the name of the container 09603 if (PyArray_TYPE((PyArrayObject*) py_V77) != NPY_FLOAT64) { 09604 PyErr_Format(PyExc_TypeError, 09605 "expected type_num %d (NPY_FLOAT64) got %d", 09606 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V77)); 09607 { 09608 __failure = 78; 09609 if (!PyErr_Occurred()) { 09610 PyErr_SetString(PyExc_RuntimeError, 09611 "Unexpected error in an Op's C code. " 09612 "No Python exception was set."); 09613 } 09614 goto __label_78;} 09615 } 09616 09617 V77 = (PyArrayObject*)(py_V77); 09618 Py_XINCREF(V77); 09619 09620 { 09621 09622 py_V79 = PyList_GET_ITEM(storage_V79, 0); 09623 {Py_XINCREF(py_V79);} 09624 09625 V79 = NULL; 09626 if (py_V79 == Py_None) { 09627 // We can either fail here or set V79 to NULL and rely on Ops 09628 // using tensors to handle the NULL case, but if they fail to do so 09629 // they'll end up with nasty segfaults, so this is public service. 09630 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 09631 { 09632 __failure = 80; 09633 if (!PyErr_Occurred()) { 09634 PyErr_SetString(PyExc_RuntimeError, 09635 "Unexpected error in an Op's C code. " 09636 "No Python exception was set."); 09637 } 09638 goto __label_80;} 09639 } 09640 if (!PyArray_Check(py_V79)) { 09641 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 09642 { 09643 __failure = 80; 09644 if (!PyErr_Occurred()) { 09645 PyErr_SetString(PyExc_RuntimeError, 09646 "Unexpected error in an Op's C code. " 09647 "No Python exception was set."); 09648 } 09649 goto __label_80;} 09650 } 09651 // We expect NPY_FLOAT64 09652 if (!PyArray_ISALIGNED((PyArrayObject*) py_V79)) { 09653 PyArrayObject * tmp = (PyArrayObject*) py_V79; 09654 PyErr_Format(PyExc_NotImplementedError, 09655 "expected an aligned array of type %ld " 09656 "(NPY_FLOAT64), got non-aligned array of type %ld" 09657 " with %ld dimensions, with 3 last dims " 09658 "%ld, %ld, %ld" 09659 " and 3 last strides %ld %ld, %ld.", 09660 (long int) NPY_FLOAT64, 09661 (long int) PyArray_TYPE((PyArrayObject*) py_V79), 09662 (long int) PyArray_NDIM(tmp), 09663 (long int) (PyArray_NDIM(tmp) >= 3 ? 09664 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 09665 (long int) (PyArray_NDIM(tmp) >= 2 ? 09666 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 09667 (long int) (PyArray_NDIM(tmp) >= 1 ? 09668 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 09669 (long int) (PyArray_NDIM(tmp) >= 3 ? 09670 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 09671 (long int) (PyArray_NDIM(tmp) >= 2 ? 09672 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 09673 (long int) (PyArray_NDIM(tmp) >= 1 ? 09674 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 09675 ); 09676 { 09677 __failure = 80; 09678 if (!PyErr_Occurred()) { 09679 PyErr_SetString(PyExc_RuntimeError, 09680 "Unexpected error in an Op's C code. " 09681 "No Python exception was set."); 09682 } 09683 goto __label_80;} 09684 } 09685 // This is a TypeError to be consistent with DEBUG_MODE 09686 // Note: DEBUG_MODE also tells the name of the container 09687 if (PyArray_TYPE((PyArrayObject*) py_V79) != NPY_FLOAT64) { 09688 PyErr_Format(PyExc_TypeError, 09689 "expected type_num %d (NPY_FLOAT64) got %d", 09690 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V79)); 09691 { 09692 __failure = 80; 09693 if (!PyErr_Occurred()) { 09694 PyErr_SetString(PyExc_RuntimeError, 09695 "Unexpected error in an Op's C code. " 09696 "No Python exception was set."); 09697 } 09698 goto __label_80;} 09699 } 09700 09701 V79 = (PyArrayObject*)(py_V79); 09702 Py_XINCREF(V79); 09703 09704 { 09705 09706 py_V81 = PyList_GET_ITEM(storage_V81, 0); 09707 {Py_XINCREF(py_V81);} 09708 09709 V81 = NULL; 09710 if (py_V81 == Py_None) { 09711 // We can either fail here or set V81 to NULL and rely on Ops 09712 // using tensors to handle the NULL case, but if they fail to do so 09713 // they'll end up with nasty segfaults, so this is public service. 09714 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 09715 { 09716 __failure = 82; 09717 if (!PyErr_Occurred()) { 09718 PyErr_SetString(PyExc_RuntimeError, 09719 "Unexpected error in an Op's C code. " 09720 "No Python exception was set."); 09721 } 09722 goto __label_82;} 09723 } 09724 if (!PyArray_Check(py_V81)) { 09725 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 09726 { 09727 __failure = 82; 09728 if (!PyErr_Occurred()) { 09729 PyErr_SetString(PyExc_RuntimeError, 09730 "Unexpected error in an Op's C code. " 09731 "No Python exception was set."); 09732 } 09733 goto __label_82;} 09734 } 09735 // We expect NPY_FLOAT64 09736 if (!PyArray_ISALIGNED((PyArrayObject*) py_V81)) { 09737 PyArrayObject * tmp = (PyArrayObject*) py_V81; 09738 PyErr_Format(PyExc_NotImplementedError, 09739 "expected an aligned array of type %ld " 09740 "(NPY_FLOAT64), got non-aligned array of type %ld" 09741 " with %ld dimensions, with 3 last dims " 09742 "%ld, %ld, %ld" 09743 " and 3 last strides %ld %ld, %ld.", 09744 (long int) NPY_FLOAT64, 09745 (long int) PyArray_TYPE((PyArrayObject*) py_V81), 09746 (long int) PyArray_NDIM(tmp), 09747 (long int) (PyArray_NDIM(tmp) >= 3 ? 09748 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 09749 (long int) (PyArray_NDIM(tmp) >= 2 ? 09750 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 09751 (long int) (PyArray_NDIM(tmp) >= 1 ? 09752 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 09753 (long int) (PyArray_NDIM(tmp) >= 3 ? 09754 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 09755 (long int) (PyArray_NDIM(tmp) >= 2 ? 09756 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 09757 (long int) (PyArray_NDIM(tmp) >= 1 ? 09758 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 09759 ); 09760 { 09761 __failure = 82; 09762 if (!PyErr_Occurred()) { 09763 PyErr_SetString(PyExc_RuntimeError, 09764 "Unexpected error in an Op's C code. " 09765 "No Python exception was set."); 09766 } 09767 goto __label_82;} 09768 } 09769 // This is a TypeError to be consistent with DEBUG_MODE 09770 // Note: DEBUG_MODE also tells the name of the container 09771 if (PyArray_TYPE((PyArrayObject*) py_V81) != NPY_FLOAT64) { 09772 PyErr_Format(PyExc_TypeError, 09773 "expected type_num %d (NPY_FLOAT64) got %d", 09774 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V81)); 09775 { 09776 __failure = 82; 09777 if (!PyErr_Occurred()) { 09778 PyErr_SetString(PyExc_RuntimeError, 09779 "Unexpected error in an Op's C code. " 09780 "No Python exception was set."); 09781 } 09782 goto __label_82;} 09783 } 09784 09785 V81 = (PyArrayObject*)(py_V81); 09786 Py_XINCREF(V81); 09787 09788 { 09789 09790 py_V83 = PyList_GET_ITEM(storage_V83, 0); 09791 {Py_XINCREF(py_V83);} 09792 09793 V83 = NULL; 09794 if (py_V83 == Py_None) { 09795 // We can either fail here or set V83 to NULL and rely on Ops 09796 // using tensors to handle the NULL case, but if they fail to do so 09797 // they'll end up with nasty segfaults, so this is public service. 09798 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 09799 { 09800 __failure = 84; 09801 if (!PyErr_Occurred()) { 09802 PyErr_SetString(PyExc_RuntimeError, 09803 "Unexpected error in an Op's C code. " 09804 "No Python exception was set."); 09805 } 09806 goto __label_84;} 09807 } 09808 if (!PyArray_Check(py_V83)) { 09809 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 09810 { 09811 __failure = 84; 09812 if (!PyErr_Occurred()) { 09813 PyErr_SetString(PyExc_RuntimeError, 09814 "Unexpected error in an Op's C code. " 09815 "No Python exception was set."); 09816 } 09817 goto __label_84;} 09818 } 09819 // We expect NPY_FLOAT64 09820 if (!PyArray_ISALIGNED((PyArrayObject*) py_V83)) { 09821 PyArrayObject * tmp = (PyArrayObject*) py_V83; 09822 PyErr_Format(PyExc_NotImplementedError, 09823 "expected an aligned array of type %ld " 09824 "(NPY_FLOAT64), got non-aligned array of type %ld" 09825 " with %ld dimensions, with 3 last dims " 09826 "%ld, %ld, %ld" 09827 " and 3 last strides %ld %ld, %ld.", 09828 (long int) NPY_FLOAT64, 09829 (long int) PyArray_TYPE((PyArrayObject*) py_V83), 09830 (long int) PyArray_NDIM(tmp), 09831 (long int) (PyArray_NDIM(tmp) >= 3 ? 09832 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 09833 (long int) (PyArray_NDIM(tmp) >= 2 ? 09834 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 09835 (long int) (PyArray_NDIM(tmp) >= 1 ? 09836 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 09837 (long int) (PyArray_NDIM(tmp) >= 3 ? 09838 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 09839 (long int) (PyArray_NDIM(tmp) >= 2 ? 09840 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 09841 (long int) (PyArray_NDIM(tmp) >= 1 ? 09842 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 09843 ); 09844 { 09845 __failure = 84; 09846 if (!PyErr_Occurred()) { 09847 PyErr_SetString(PyExc_RuntimeError, 09848 "Unexpected error in an Op's C code. " 09849 "No Python exception was set."); 09850 } 09851 goto __label_84;} 09852 } 09853 // This is a TypeError to be consistent with DEBUG_MODE 09854 // Note: DEBUG_MODE also tells the name of the container 09855 if (PyArray_TYPE((PyArrayObject*) py_V83) != NPY_FLOAT64) { 09856 PyErr_Format(PyExc_TypeError, 09857 "expected type_num %d (NPY_FLOAT64) got %d", 09858 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V83)); 09859 { 09860 __failure = 84; 09861 if (!PyErr_Occurred()) { 09862 PyErr_SetString(PyExc_RuntimeError, 09863 "Unexpected error in an Op's C code. " 09864 "No Python exception was set."); 09865 } 09866 goto __label_84;} 09867 } 09868 09869 V83 = (PyArrayObject*)(py_V83); 09870 Py_XINCREF(V83); 09871 09872 { 09873 09874 py_V85 = PyList_GET_ITEM(storage_V85, 0); 09875 {Py_XINCREF(py_V85);} 09876 09877 V85 = NULL; 09878 if (py_V85 == Py_None) { 09879 // We can either fail here or set V85 to NULL and rely on Ops 09880 // using tensors to handle the NULL case, but if they fail to do so 09881 // they'll end up with nasty segfaults, so this is public service. 09882 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 09883 { 09884 __failure = 86; 09885 if (!PyErr_Occurred()) { 09886 PyErr_SetString(PyExc_RuntimeError, 09887 "Unexpected error in an Op's C code. " 09888 "No Python exception was set."); 09889 } 09890 goto __label_86;} 09891 } 09892 if (!PyArray_Check(py_V85)) { 09893 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 09894 { 09895 __failure = 86; 09896 if (!PyErr_Occurred()) { 09897 PyErr_SetString(PyExc_RuntimeError, 09898 "Unexpected error in an Op's C code. " 09899 "No Python exception was set."); 09900 } 09901 goto __label_86;} 09902 } 09903 // We expect NPY_FLOAT64 09904 if (!PyArray_ISALIGNED((PyArrayObject*) py_V85)) { 09905 PyArrayObject * tmp = (PyArrayObject*) py_V85; 09906 PyErr_Format(PyExc_NotImplementedError, 09907 "expected an aligned array of type %ld " 09908 "(NPY_FLOAT64), got non-aligned array of type %ld" 09909 " with %ld dimensions, with 3 last dims " 09910 "%ld, %ld, %ld" 09911 " and 3 last strides %ld %ld, %ld.", 09912 (long int) NPY_FLOAT64, 09913 (long int) PyArray_TYPE((PyArrayObject*) py_V85), 09914 (long int) PyArray_NDIM(tmp), 09915 (long int) (PyArray_NDIM(tmp) >= 3 ? 09916 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 09917 (long int) (PyArray_NDIM(tmp) >= 2 ? 09918 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 09919 (long int) (PyArray_NDIM(tmp) >= 1 ? 09920 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 09921 (long int) (PyArray_NDIM(tmp) >= 3 ? 09922 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 09923 (long int) (PyArray_NDIM(tmp) >= 2 ? 09924 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 09925 (long int) (PyArray_NDIM(tmp) >= 1 ? 09926 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 09927 ); 09928 { 09929 __failure = 86; 09930 if (!PyErr_Occurred()) { 09931 PyErr_SetString(PyExc_RuntimeError, 09932 "Unexpected error in an Op's C code. " 09933 "No Python exception was set."); 09934 } 09935 goto __label_86;} 09936 } 09937 // This is a TypeError to be consistent with DEBUG_MODE 09938 // Note: DEBUG_MODE also tells the name of the container 09939 if (PyArray_TYPE((PyArrayObject*) py_V85) != NPY_FLOAT64) { 09940 PyErr_Format(PyExc_TypeError, 09941 "expected type_num %d (NPY_FLOAT64) got %d", 09942 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V85)); 09943 { 09944 __failure = 86; 09945 if (!PyErr_Occurred()) { 09946 PyErr_SetString(PyExc_RuntimeError, 09947 "Unexpected error in an Op's C code. " 09948 "No Python exception was set."); 09949 } 09950 goto __label_86;} 09951 } 09952 09953 V85 = (PyArrayObject*)(py_V85); 09954 Py_XINCREF(V85); 09955 09956 { 09957 09958 py_V87 = PyList_GET_ITEM(storage_V87, 0); 09959 {Py_XINCREF(py_V87);} 09960 09961 V87 = NULL; 09962 if (py_V87 == Py_None) { 09963 // We can either fail here or set V87 to NULL and rely on Ops 09964 // using tensors to handle the NULL case, but if they fail to do so 09965 // they'll end up with nasty segfaults, so this is public service. 09966 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 09967 { 09968 __failure = 88; 09969 if (!PyErr_Occurred()) { 09970 PyErr_SetString(PyExc_RuntimeError, 09971 "Unexpected error in an Op's C code. " 09972 "No Python exception was set."); 09973 } 09974 goto __label_88;} 09975 } 09976 if (!PyArray_Check(py_V87)) { 09977 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 09978 { 09979 __failure = 88; 09980 if (!PyErr_Occurred()) { 09981 PyErr_SetString(PyExc_RuntimeError, 09982 "Unexpected error in an Op's C code. " 09983 "No Python exception was set."); 09984 } 09985 goto __label_88;} 09986 } 09987 // We expect NPY_FLOAT64 09988 if (!PyArray_ISALIGNED((PyArrayObject*) py_V87)) { 09989 PyArrayObject * tmp = (PyArrayObject*) py_V87; 09990 PyErr_Format(PyExc_NotImplementedError, 09991 "expected an aligned array of type %ld " 09992 "(NPY_FLOAT64), got non-aligned array of type %ld" 09993 " with %ld dimensions, with 3 last dims " 09994 "%ld, %ld, %ld" 09995 " and 3 last strides %ld %ld, %ld.", 09996 (long int) NPY_FLOAT64, 09997 (long int) PyArray_TYPE((PyArrayObject*) py_V87), 09998 (long int) PyArray_NDIM(tmp), 09999 (long int) (PyArray_NDIM(tmp) >= 3 ? 10000 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 10001 (long int) (PyArray_NDIM(tmp) >= 2 ? 10002 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 10003 (long int) (PyArray_NDIM(tmp) >= 1 ? 10004 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 10005 (long int) (PyArray_NDIM(tmp) >= 3 ? 10006 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 10007 (long int) (PyArray_NDIM(tmp) >= 2 ? 10008 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 10009 (long int) (PyArray_NDIM(tmp) >= 1 ? 10010 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 10011 ); 10012 { 10013 __failure = 88; 10014 if (!PyErr_Occurred()) { 10015 PyErr_SetString(PyExc_RuntimeError, 10016 "Unexpected error in an Op's C code. " 10017 "No Python exception was set."); 10018 } 10019 goto __label_88;} 10020 } 10021 // This is a TypeError to be consistent with DEBUG_MODE 10022 // Note: DEBUG_MODE also tells the name of the container 10023 if (PyArray_TYPE((PyArrayObject*) py_V87) != NPY_FLOAT64) { 10024 PyErr_Format(PyExc_TypeError, 10025 "expected type_num %d (NPY_FLOAT64) got %d", 10026 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V87)); 10027 { 10028 __failure = 88; 10029 if (!PyErr_Occurred()) { 10030 PyErr_SetString(PyExc_RuntimeError, 10031 "Unexpected error in an Op's C code. " 10032 "No Python exception was set."); 10033 } 10034 goto __label_88;} 10035 } 10036 10037 V87 = (PyArrayObject*)(py_V87); 10038 Py_XINCREF(V87); 10039 10040 { 10041 10042 py_V89 = PyList_GET_ITEM(storage_V89, 0); 10043 {Py_XINCREF(py_V89);} 10044 10045 V89 = NULL; 10046 if (py_V89 == Py_None) { 10047 // We can either fail here or set V89 to NULL and rely on Ops 10048 // using tensors to handle the NULL case, but if they fail to do so 10049 // they'll end up with nasty segfaults, so this is public service. 10050 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 10051 { 10052 __failure = 90; 10053 if (!PyErr_Occurred()) { 10054 PyErr_SetString(PyExc_RuntimeError, 10055 "Unexpected error in an Op's C code. " 10056 "No Python exception was set."); 10057 } 10058 goto __label_90;} 10059 } 10060 if (!PyArray_Check(py_V89)) { 10061 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 10062 { 10063 __failure = 90; 10064 if (!PyErr_Occurred()) { 10065 PyErr_SetString(PyExc_RuntimeError, 10066 "Unexpected error in an Op's C code. " 10067 "No Python exception was set."); 10068 } 10069 goto __label_90;} 10070 } 10071 // We expect NPY_FLOAT64 10072 if (!PyArray_ISALIGNED((PyArrayObject*) py_V89)) { 10073 PyArrayObject * tmp = (PyArrayObject*) py_V89; 10074 PyErr_Format(PyExc_NotImplementedError, 10075 "expected an aligned array of type %ld " 10076 "(NPY_FLOAT64), got non-aligned array of type %ld" 10077 " with %ld dimensions, with 3 last dims " 10078 "%ld, %ld, %ld" 10079 " and 3 last strides %ld %ld, %ld.", 10080 (long int) NPY_FLOAT64, 10081 (long int) PyArray_TYPE((PyArrayObject*) py_V89), 10082 (long int) PyArray_NDIM(tmp), 10083 (long int) (PyArray_NDIM(tmp) >= 3 ? 10084 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 10085 (long int) (PyArray_NDIM(tmp) >= 2 ? 10086 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 10087 (long int) (PyArray_NDIM(tmp) >= 1 ? 10088 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 10089 (long int) (PyArray_NDIM(tmp) >= 3 ? 10090 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 10091 (long int) (PyArray_NDIM(tmp) >= 2 ? 10092 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 10093 (long int) (PyArray_NDIM(tmp) >= 1 ? 10094 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 10095 ); 10096 { 10097 __failure = 90; 10098 if (!PyErr_Occurred()) { 10099 PyErr_SetString(PyExc_RuntimeError, 10100 "Unexpected error in an Op's C code. " 10101 "No Python exception was set."); 10102 } 10103 goto __label_90;} 10104 } 10105 // This is a TypeError to be consistent with DEBUG_MODE 10106 // Note: DEBUG_MODE also tells the name of the container 10107 if (PyArray_TYPE((PyArrayObject*) py_V89) != NPY_FLOAT64) { 10108 PyErr_Format(PyExc_TypeError, 10109 "expected type_num %d (NPY_FLOAT64) got %d", 10110 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V89)); 10111 { 10112 __failure = 90; 10113 if (!PyErr_Occurred()) { 10114 PyErr_SetString(PyExc_RuntimeError, 10115 "Unexpected error in an Op's C code. " 10116 "No Python exception was set."); 10117 } 10118 goto __label_90;} 10119 } 10120 10121 V89 = (PyArrayObject*)(py_V89); 10122 Py_XINCREF(V89); 10123 10124 { 10125 10126 py_V91 = PyList_GET_ITEM(storage_V91, 0); 10127 {Py_XINCREF(py_V91);} 10128 10129 V91 = NULL; 10130 if (py_V91 == Py_None) { 10131 // We can either fail here or set V91 to NULL and rely on Ops 10132 // using tensors to handle the NULL case, but if they fail to do so 10133 // they'll end up with nasty segfaults, so this is public service. 10134 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 10135 { 10136 __failure = 92; 10137 if (!PyErr_Occurred()) { 10138 PyErr_SetString(PyExc_RuntimeError, 10139 "Unexpected error in an Op's C code. " 10140 "No Python exception was set."); 10141 } 10142 goto __label_92;} 10143 } 10144 if (!PyArray_Check(py_V91)) { 10145 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 10146 { 10147 __failure = 92; 10148 if (!PyErr_Occurred()) { 10149 PyErr_SetString(PyExc_RuntimeError, 10150 "Unexpected error in an Op's C code. " 10151 "No Python exception was set."); 10152 } 10153 goto __label_92;} 10154 } 10155 // We expect NPY_FLOAT64 10156 if (!PyArray_ISALIGNED((PyArrayObject*) py_V91)) { 10157 PyArrayObject * tmp = (PyArrayObject*) py_V91; 10158 PyErr_Format(PyExc_NotImplementedError, 10159 "expected an aligned array of type %ld " 10160 "(NPY_FLOAT64), got non-aligned array of type %ld" 10161 " with %ld dimensions, with 3 last dims " 10162 "%ld, %ld, %ld" 10163 " and 3 last strides %ld %ld, %ld.", 10164 (long int) NPY_FLOAT64, 10165 (long int) PyArray_TYPE((PyArrayObject*) py_V91), 10166 (long int) PyArray_NDIM(tmp), 10167 (long int) (PyArray_NDIM(tmp) >= 3 ? 10168 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 10169 (long int) (PyArray_NDIM(tmp) >= 2 ? 10170 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 10171 (long int) (PyArray_NDIM(tmp) >= 1 ? 10172 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 10173 (long int) (PyArray_NDIM(tmp) >= 3 ? 10174 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 10175 (long int) (PyArray_NDIM(tmp) >= 2 ? 10176 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 10177 (long int) (PyArray_NDIM(tmp) >= 1 ? 10178 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 10179 ); 10180 { 10181 __failure = 92; 10182 if (!PyErr_Occurred()) { 10183 PyErr_SetString(PyExc_RuntimeError, 10184 "Unexpected error in an Op's C code. " 10185 "No Python exception was set."); 10186 } 10187 goto __label_92;} 10188 } 10189 // This is a TypeError to be consistent with DEBUG_MODE 10190 // Note: DEBUG_MODE also tells the name of the container 10191 if (PyArray_TYPE((PyArrayObject*) py_V91) != NPY_FLOAT64) { 10192 PyErr_Format(PyExc_TypeError, 10193 "expected type_num %d (NPY_FLOAT64) got %d", 10194 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V91)); 10195 { 10196 __failure = 92; 10197 if (!PyErr_Occurred()) { 10198 PyErr_SetString(PyExc_RuntimeError, 10199 "Unexpected error in an Op's C code. " 10200 "No Python exception was set."); 10201 } 10202 goto __label_92;} 10203 } 10204 10205 V91 = (PyArrayObject*)(py_V91); 10206 Py_XINCREF(V91); 10207 10208 { 10209 10210 py_V93 = PyList_GET_ITEM(storage_V93, 0); 10211 {Py_XINCREF(py_V93);} 10212 10213 V93 = NULL; 10214 if (py_V93 == Py_None) { 10215 // We can either fail here or set V93 to NULL and rely on Ops 10216 // using tensors to handle the NULL case, but if they fail to do so 10217 // they'll end up with nasty segfaults, so this is public service. 10218 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 10219 { 10220 __failure = 94; 10221 if (!PyErr_Occurred()) { 10222 PyErr_SetString(PyExc_RuntimeError, 10223 "Unexpected error in an Op's C code. " 10224 "No Python exception was set."); 10225 } 10226 goto __label_94;} 10227 } 10228 if (!PyArray_Check(py_V93)) { 10229 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 10230 { 10231 __failure = 94; 10232 if (!PyErr_Occurred()) { 10233 PyErr_SetString(PyExc_RuntimeError, 10234 "Unexpected error in an Op's C code. " 10235 "No Python exception was set."); 10236 } 10237 goto __label_94;} 10238 } 10239 // We expect NPY_FLOAT64 10240 if (!PyArray_ISALIGNED((PyArrayObject*) py_V93)) { 10241 PyArrayObject * tmp = (PyArrayObject*) py_V93; 10242 PyErr_Format(PyExc_NotImplementedError, 10243 "expected an aligned array of type %ld " 10244 "(NPY_FLOAT64), got non-aligned array of type %ld" 10245 " with %ld dimensions, with 3 last dims " 10246 "%ld, %ld, %ld" 10247 " and 3 last strides %ld %ld, %ld.", 10248 (long int) NPY_FLOAT64, 10249 (long int) PyArray_TYPE((PyArrayObject*) py_V93), 10250 (long int) PyArray_NDIM(tmp), 10251 (long int) (PyArray_NDIM(tmp) >= 3 ? 10252 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 10253 (long int) (PyArray_NDIM(tmp) >= 2 ? 10254 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 10255 (long int) (PyArray_NDIM(tmp) >= 1 ? 10256 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 10257 (long int) (PyArray_NDIM(tmp) >= 3 ? 10258 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 10259 (long int) (PyArray_NDIM(tmp) >= 2 ? 10260 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 10261 (long int) (PyArray_NDIM(tmp) >= 1 ? 10262 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 10263 ); 10264 { 10265 __failure = 94; 10266 if (!PyErr_Occurred()) { 10267 PyErr_SetString(PyExc_RuntimeError, 10268 "Unexpected error in an Op's C code. " 10269 "No Python exception was set."); 10270 } 10271 goto __label_94;} 10272 } 10273 // This is a TypeError to be consistent with DEBUG_MODE 10274 // Note: DEBUG_MODE also tells the name of the container 10275 if (PyArray_TYPE((PyArrayObject*) py_V93) != NPY_FLOAT64) { 10276 PyErr_Format(PyExc_TypeError, 10277 "expected type_num %d (NPY_FLOAT64) got %d", 10278 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V93)); 10279 { 10280 __failure = 94; 10281 if (!PyErr_Occurred()) { 10282 PyErr_SetString(PyExc_RuntimeError, 10283 "Unexpected error in an Op's C code. " 10284 "No Python exception was set."); 10285 } 10286 goto __label_94;} 10287 } 10288 10289 V93 = (PyArrayObject*)(py_V93); 10290 Py_XINCREF(V93); 10291 10292 { 10293 10294 py_V95 = PyList_GET_ITEM(storage_V95, 0); 10295 {Py_XINCREF(py_V95);} 10296 10297 V95 = NULL; 10298 if (py_V95 == Py_None) { 10299 // We can either fail here or set V95 to NULL and rely on Ops 10300 // using tensors to handle the NULL case, but if they fail to do so 10301 // they'll end up with nasty segfaults, so this is public service. 10302 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 10303 { 10304 __failure = 96; 10305 if (!PyErr_Occurred()) { 10306 PyErr_SetString(PyExc_RuntimeError, 10307 "Unexpected error in an Op's C code. " 10308 "No Python exception was set."); 10309 } 10310 goto __label_96;} 10311 } 10312 if (!PyArray_Check(py_V95)) { 10313 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 10314 { 10315 __failure = 96; 10316 if (!PyErr_Occurred()) { 10317 PyErr_SetString(PyExc_RuntimeError, 10318 "Unexpected error in an Op's C code. " 10319 "No Python exception was set."); 10320 } 10321 goto __label_96;} 10322 } 10323 // We expect NPY_FLOAT64 10324 if (!PyArray_ISALIGNED((PyArrayObject*) py_V95)) { 10325 PyArrayObject * tmp = (PyArrayObject*) py_V95; 10326 PyErr_Format(PyExc_NotImplementedError, 10327 "expected an aligned array of type %ld " 10328 "(NPY_FLOAT64), got non-aligned array of type %ld" 10329 " with %ld dimensions, with 3 last dims " 10330 "%ld, %ld, %ld" 10331 " and 3 last strides %ld %ld, %ld.", 10332 (long int) NPY_FLOAT64, 10333 (long int) PyArray_TYPE((PyArrayObject*) py_V95), 10334 (long int) PyArray_NDIM(tmp), 10335 (long int) (PyArray_NDIM(tmp) >= 3 ? 10336 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 10337 (long int) (PyArray_NDIM(tmp) >= 2 ? 10338 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 10339 (long int) (PyArray_NDIM(tmp) >= 1 ? 10340 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 10341 (long int) (PyArray_NDIM(tmp) >= 3 ? 10342 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 10343 (long int) (PyArray_NDIM(tmp) >= 2 ? 10344 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 10345 (long int) (PyArray_NDIM(tmp) >= 1 ? 10346 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 10347 ); 10348 { 10349 __failure = 96; 10350 if (!PyErr_Occurred()) { 10351 PyErr_SetString(PyExc_RuntimeError, 10352 "Unexpected error in an Op's C code. " 10353 "No Python exception was set."); 10354 } 10355 goto __label_96;} 10356 } 10357 // This is a TypeError to be consistent with DEBUG_MODE 10358 // Note: DEBUG_MODE also tells the name of the container 10359 if (PyArray_TYPE((PyArrayObject*) py_V95) != NPY_FLOAT64) { 10360 PyErr_Format(PyExc_TypeError, 10361 "expected type_num %d (NPY_FLOAT64) got %d", 10362 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V95)); 10363 { 10364 __failure = 96; 10365 if (!PyErr_Occurred()) { 10366 PyErr_SetString(PyExc_RuntimeError, 10367 "Unexpected error in an Op's C code. " 10368 "No Python exception was set."); 10369 } 10370 goto __label_96;} 10371 } 10372 10373 V95 = (PyArrayObject*)(py_V95); 10374 Py_XINCREF(V95); 10375 10376 { 10377 10378 py_V97 = PyList_GET_ITEM(storage_V97, 0); 10379 {Py_XINCREF(py_V97);} 10380 10381 V97 = NULL; 10382 if (py_V97 == Py_None) { 10383 // We can either fail here or set V97 to NULL and rely on Ops 10384 // using tensors to handle the NULL case, but if they fail to do so 10385 // they'll end up with nasty segfaults, so this is public service. 10386 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 10387 { 10388 __failure = 98; 10389 if (!PyErr_Occurred()) { 10390 PyErr_SetString(PyExc_RuntimeError, 10391 "Unexpected error in an Op's C code. " 10392 "No Python exception was set."); 10393 } 10394 goto __label_98;} 10395 } 10396 if (!PyArray_Check(py_V97)) { 10397 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 10398 { 10399 __failure = 98; 10400 if (!PyErr_Occurred()) { 10401 PyErr_SetString(PyExc_RuntimeError, 10402 "Unexpected error in an Op's C code. " 10403 "No Python exception was set."); 10404 } 10405 goto __label_98;} 10406 } 10407 // We expect NPY_FLOAT64 10408 if (!PyArray_ISALIGNED((PyArrayObject*) py_V97)) { 10409 PyArrayObject * tmp = (PyArrayObject*) py_V97; 10410 PyErr_Format(PyExc_NotImplementedError, 10411 "expected an aligned array of type %ld " 10412 "(NPY_FLOAT64), got non-aligned array of type %ld" 10413 " with %ld dimensions, with 3 last dims " 10414 "%ld, %ld, %ld" 10415 " and 3 last strides %ld %ld, %ld.", 10416 (long int) NPY_FLOAT64, 10417 (long int) PyArray_TYPE((PyArrayObject*) py_V97), 10418 (long int) PyArray_NDIM(tmp), 10419 (long int) (PyArray_NDIM(tmp) >= 3 ? 10420 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 10421 (long int) (PyArray_NDIM(tmp) >= 2 ? 10422 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 10423 (long int) (PyArray_NDIM(tmp) >= 1 ? 10424 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 10425 (long int) (PyArray_NDIM(tmp) >= 3 ? 10426 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 10427 (long int) (PyArray_NDIM(tmp) >= 2 ? 10428 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 10429 (long int) (PyArray_NDIM(tmp) >= 1 ? 10430 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 10431 ); 10432 { 10433 __failure = 98; 10434 if (!PyErr_Occurred()) { 10435 PyErr_SetString(PyExc_RuntimeError, 10436 "Unexpected error in an Op's C code. " 10437 "No Python exception was set."); 10438 } 10439 goto __label_98;} 10440 } 10441 // This is a TypeError to be consistent with DEBUG_MODE 10442 // Note: DEBUG_MODE also tells the name of the container 10443 if (PyArray_TYPE((PyArrayObject*) py_V97) != NPY_FLOAT64) { 10444 PyErr_Format(PyExc_TypeError, 10445 "expected type_num %d (NPY_FLOAT64) got %d", 10446 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V97)); 10447 { 10448 __failure = 98; 10449 if (!PyErr_Occurred()) { 10450 PyErr_SetString(PyExc_RuntimeError, 10451 "Unexpected error in an Op's C code. " 10452 "No Python exception was set."); 10453 } 10454 goto __label_98;} 10455 } 10456 10457 V97 = (PyArrayObject*)(py_V97); 10458 Py_XINCREF(V97); 10459 10460 { 10461 10462 py_V99 = PyList_GET_ITEM(storage_V99, 0); 10463 {Py_XINCREF(py_V99);} 10464 10465 V99 = NULL; 10466 if (py_V99 == Py_None) { 10467 // We can either fail here or set V99 to NULL and rely on Ops 10468 // using tensors to handle the NULL case, but if they fail to do so 10469 // they'll end up with nasty segfaults, so this is public service. 10470 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 10471 { 10472 __failure = 100; 10473 if (!PyErr_Occurred()) { 10474 PyErr_SetString(PyExc_RuntimeError, 10475 "Unexpected error in an Op's C code. " 10476 "No Python exception was set."); 10477 } 10478 goto __label_100;} 10479 } 10480 if (!PyArray_Check(py_V99)) { 10481 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 10482 { 10483 __failure = 100; 10484 if (!PyErr_Occurred()) { 10485 PyErr_SetString(PyExc_RuntimeError, 10486 "Unexpected error in an Op's C code. " 10487 "No Python exception was set."); 10488 } 10489 goto __label_100;} 10490 } 10491 // We expect NPY_FLOAT64 10492 if (!PyArray_ISALIGNED((PyArrayObject*) py_V99)) { 10493 PyArrayObject * tmp = (PyArrayObject*) py_V99; 10494 PyErr_Format(PyExc_NotImplementedError, 10495 "expected an aligned array of type %ld " 10496 "(NPY_FLOAT64), got non-aligned array of type %ld" 10497 " with %ld dimensions, with 3 last dims " 10498 "%ld, %ld, %ld" 10499 " and 3 last strides %ld %ld, %ld.", 10500 (long int) NPY_FLOAT64, 10501 (long int) PyArray_TYPE((PyArrayObject*) py_V99), 10502 (long int) PyArray_NDIM(tmp), 10503 (long int) (PyArray_NDIM(tmp) >= 3 ? 10504 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 10505 (long int) (PyArray_NDIM(tmp) >= 2 ? 10506 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 10507 (long int) (PyArray_NDIM(tmp) >= 1 ? 10508 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 10509 (long int) (PyArray_NDIM(tmp) >= 3 ? 10510 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 10511 (long int) (PyArray_NDIM(tmp) >= 2 ? 10512 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 10513 (long int) (PyArray_NDIM(tmp) >= 1 ? 10514 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 10515 ); 10516 { 10517 __failure = 100; 10518 if (!PyErr_Occurred()) { 10519 PyErr_SetString(PyExc_RuntimeError, 10520 "Unexpected error in an Op's C code. " 10521 "No Python exception was set."); 10522 } 10523 goto __label_100;} 10524 } 10525 // This is a TypeError to be consistent with DEBUG_MODE 10526 // Note: DEBUG_MODE also tells the name of the container 10527 if (PyArray_TYPE((PyArrayObject*) py_V99) != NPY_FLOAT64) { 10528 PyErr_Format(PyExc_TypeError, 10529 "expected type_num %d (NPY_FLOAT64) got %d", 10530 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V99)); 10531 { 10532 __failure = 100; 10533 if (!PyErr_Occurred()) { 10534 PyErr_SetString(PyExc_RuntimeError, 10535 "Unexpected error in an Op's C code. " 10536 "No Python exception was set."); 10537 } 10538 goto __label_100;} 10539 } 10540 10541 V99 = (PyArrayObject*)(py_V99); 10542 Py_XINCREF(V99); 10543 10544 { 10545 10546 py_V101 = PyList_GET_ITEM(storage_V101, 0); 10547 {Py_XINCREF(py_V101);} 10548 10549 V101 = NULL; 10550 if (py_V101 == Py_None) { 10551 // We can either fail here or set V101 to NULL and rely on Ops 10552 // using tensors to handle the NULL case, but if they fail to do so 10553 // they'll end up with nasty segfaults, so this is public service. 10554 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 10555 { 10556 __failure = 102; 10557 if (!PyErr_Occurred()) { 10558 PyErr_SetString(PyExc_RuntimeError, 10559 "Unexpected error in an Op's C code. " 10560 "No Python exception was set."); 10561 } 10562 goto __label_102;} 10563 } 10564 if (!PyArray_Check(py_V101)) { 10565 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 10566 { 10567 __failure = 102; 10568 if (!PyErr_Occurred()) { 10569 PyErr_SetString(PyExc_RuntimeError, 10570 "Unexpected error in an Op's C code. " 10571 "No Python exception was set."); 10572 } 10573 goto __label_102;} 10574 } 10575 // We expect NPY_FLOAT64 10576 if (!PyArray_ISALIGNED((PyArrayObject*) py_V101)) { 10577 PyArrayObject * tmp = (PyArrayObject*) py_V101; 10578 PyErr_Format(PyExc_NotImplementedError, 10579 "expected an aligned array of type %ld " 10580 "(NPY_FLOAT64), got non-aligned array of type %ld" 10581 " with %ld dimensions, with 3 last dims " 10582 "%ld, %ld, %ld" 10583 " and 3 last strides %ld %ld, %ld.", 10584 (long int) NPY_FLOAT64, 10585 (long int) PyArray_TYPE((PyArrayObject*) py_V101), 10586 (long int) PyArray_NDIM(tmp), 10587 (long int) (PyArray_NDIM(tmp) >= 3 ? 10588 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 10589 (long int) (PyArray_NDIM(tmp) >= 2 ? 10590 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 10591 (long int) (PyArray_NDIM(tmp) >= 1 ? 10592 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 10593 (long int) (PyArray_NDIM(tmp) >= 3 ? 10594 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 10595 (long int) (PyArray_NDIM(tmp) >= 2 ? 10596 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 10597 (long int) (PyArray_NDIM(tmp) >= 1 ? 10598 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 10599 ); 10600 { 10601 __failure = 102; 10602 if (!PyErr_Occurred()) { 10603 PyErr_SetString(PyExc_RuntimeError, 10604 "Unexpected error in an Op's C code. " 10605 "No Python exception was set."); 10606 } 10607 goto __label_102;} 10608 } 10609 // This is a TypeError to be consistent with DEBUG_MODE 10610 // Note: DEBUG_MODE also tells the name of the container 10611 if (PyArray_TYPE((PyArrayObject*) py_V101) != NPY_FLOAT64) { 10612 PyErr_Format(PyExc_TypeError, 10613 "expected type_num %d (NPY_FLOAT64) got %d", 10614 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V101)); 10615 { 10616 __failure = 102; 10617 if (!PyErr_Occurred()) { 10618 PyErr_SetString(PyExc_RuntimeError, 10619 "Unexpected error in an Op's C code. " 10620 "No Python exception was set."); 10621 } 10622 goto __label_102;} 10623 } 10624 10625 V101 = (PyArrayObject*)(py_V101); 10626 Py_XINCREF(V101); 10627 10628 { 10629 10630 py_V103 = PyList_GET_ITEM(storage_V103, 0); 10631 {Py_XINCREF(py_V103);} 10632 10633 V103 = NULL; 10634 if (py_V103 == Py_None) { 10635 // We can either fail here or set V103 to NULL and rely on Ops 10636 // using tensors to handle the NULL case, but if they fail to do so 10637 // they'll end up with nasty segfaults, so this is public service. 10638 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 10639 { 10640 __failure = 104; 10641 if (!PyErr_Occurred()) { 10642 PyErr_SetString(PyExc_RuntimeError, 10643 "Unexpected error in an Op's C code. " 10644 "No Python exception was set."); 10645 } 10646 goto __label_104;} 10647 } 10648 if (!PyArray_Check(py_V103)) { 10649 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 10650 { 10651 __failure = 104; 10652 if (!PyErr_Occurred()) { 10653 PyErr_SetString(PyExc_RuntimeError, 10654 "Unexpected error in an Op's C code. " 10655 "No Python exception was set."); 10656 } 10657 goto __label_104;} 10658 } 10659 // We expect NPY_FLOAT64 10660 if (!PyArray_ISALIGNED((PyArrayObject*) py_V103)) { 10661 PyArrayObject * tmp = (PyArrayObject*) py_V103; 10662 PyErr_Format(PyExc_NotImplementedError, 10663 "expected an aligned array of type %ld " 10664 "(NPY_FLOAT64), got non-aligned array of type %ld" 10665 " with %ld dimensions, with 3 last dims " 10666 "%ld, %ld, %ld" 10667 " and 3 last strides %ld %ld, %ld.", 10668 (long int) NPY_FLOAT64, 10669 (long int) PyArray_TYPE((PyArrayObject*) py_V103), 10670 (long int) PyArray_NDIM(tmp), 10671 (long int) (PyArray_NDIM(tmp) >= 3 ? 10672 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 10673 (long int) (PyArray_NDIM(tmp) >= 2 ? 10674 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 10675 (long int) (PyArray_NDIM(tmp) >= 1 ? 10676 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 10677 (long int) (PyArray_NDIM(tmp) >= 3 ? 10678 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 10679 (long int) (PyArray_NDIM(tmp) >= 2 ? 10680 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 10681 (long int) (PyArray_NDIM(tmp) >= 1 ? 10682 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 10683 ); 10684 { 10685 __failure = 104; 10686 if (!PyErr_Occurred()) { 10687 PyErr_SetString(PyExc_RuntimeError, 10688 "Unexpected error in an Op's C code. " 10689 "No Python exception was set."); 10690 } 10691 goto __label_104;} 10692 } 10693 // This is a TypeError to be consistent with DEBUG_MODE 10694 // Note: DEBUG_MODE also tells the name of the container 10695 if (PyArray_TYPE((PyArrayObject*) py_V103) != NPY_FLOAT64) { 10696 PyErr_Format(PyExc_TypeError, 10697 "expected type_num %d (NPY_FLOAT64) got %d", 10698 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V103)); 10699 { 10700 __failure = 104; 10701 if (!PyErr_Occurred()) { 10702 PyErr_SetString(PyExc_RuntimeError, 10703 "Unexpected error in an Op's C code. " 10704 "No Python exception was set."); 10705 } 10706 goto __label_104;} 10707 } 10708 10709 V103 = (PyArrayObject*)(py_V103); 10710 Py_XINCREF(V103); 10711 10712 { 10713 10714 py_V105 = PyList_GET_ITEM(storage_V105, 0); 10715 {Py_XINCREF(py_V105);} 10716 10717 V105 = NULL; 10718 if (py_V105 == Py_None) { 10719 // We can either fail here or set V105 to NULL and rely on Ops 10720 // using tensors to handle the NULL case, but if they fail to do so 10721 // they'll end up with nasty segfaults, so this is public service. 10722 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 10723 { 10724 __failure = 106; 10725 if (!PyErr_Occurred()) { 10726 PyErr_SetString(PyExc_RuntimeError, 10727 "Unexpected error in an Op's C code. " 10728 "No Python exception was set."); 10729 } 10730 goto __label_106;} 10731 } 10732 if (!PyArray_Check(py_V105)) { 10733 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 10734 { 10735 __failure = 106; 10736 if (!PyErr_Occurred()) { 10737 PyErr_SetString(PyExc_RuntimeError, 10738 "Unexpected error in an Op's C code. " 10739 "No Python exception was set."); 10740 } 10741 goto __label_106;} 10742 } 10743 // We expect NPY_FLOAT64 10744 if (!PyArray_ISALIGNED((PyArrayObject*) py_V105)) { 10745 PyArrayObject * tmp = (PyArrayObject*) py_V105; 10746 PyErr_Format(PyExc_NotImplementedError, 10747 "expected an aligned array of type %ld " 10748 "(NPY_FLOAT64), got non-aligned array of type %ld" 10749 " with %ld dimensions, with 3 last dims " 10750 "%ld, %ld, %ld" 10751 " and 3 last strides %ld %ld, %ld.", 10752 (long int) NPY_FLOAT64, 10753 (long int) PyArray_TYPE((PyArrayObject*) py_V105), 10754 (long int) PyArray_NDIM(tmp), 10755 (long int) (PyArray_NDIM(tmp) >= 3 ? 10756 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 10757 (long int) (PyArray_NDIM(tmp) >= 2 ? 10758 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 10759 (long int) (PyArray_NDIM(tmp) >= 1 ? 10760 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 10761 (long int) (PyArray_NDIM(tmp) >= 3 ? 10762 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 10763 (long int) (PyArray_NDIM(tmp) >= 2 ? 10764 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 10765 (long int) (PyArray_NDIM(tmp) >= 1 ? 10766 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 10767 ); 10768 { 10769 __failure = 106; 10770 if (!PyErr_Occurred()) { 10771 PyErr_SetString(PyExc_RuntimeError, 10772 "Unexpected error in an Op's C code. " 10773 "No Python exception was set."); 10774 } 10775 goto __label_106;} 10776 } 10777 // This is a TypeError to be consistent with DEBUG_MODE 10778 // Note: DEBUG_MODE also tells the name of the container 10779 if (PyArray_TYPE((PyArrayObject*) py_V105) != NPY_FLOAT64) { 10780 PyErr_Format(PyExc_TypeError, 10781 "expected type_num %d (NPY_FLOAT64) got %d", 10782 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V105)); 10783 { 10784 __failure = 106; 10785 if (!PyErr_Occurred()) { 10786 PyErr_SetString(PyExc_RuntimeError, 10787 "Unexpected error in an Op's C code. " 10788 "No Python exception was set."); 10789 } 10790 goto __label_106;} 10791 } 10792 10793 V105 = (PyArrayObject*)(py_V105); 10794 Py_XINCREF(V105); 10795 10796 { 10797 10798 py_V107 = PyList_GET_ITEM(storage_V107, 0); 10799 {Py_XINCREF(py_V107);} 10800 10801 V107 = NULL; 10802 if (py_V107 == Py_None) { 10803 // We can either fail here or set V107 to NULL and rely on Ops 10804 // using tensors to handle the NULL case, but if they fail to do so 10805 // they'll end up with nasty segfaults, so this is public service. 10806 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 10807 { 10808 __failure = 108; 10809 if (!PyErr_Occurred()) { 10810 PyErr_SetString(PyExc_RuntimeError, 10811 "Unexpected error in an Op's C code. " 10812 "No Python exception was set."); 10813 } 10814 goto __label_108;} 10815 } 10816 if (!PyArray_Check(py_V107)) { 10817 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 10818 { 10819 __failure = 108; 10820 if (!PyErr_Occurred()) { 10821 PyErr_SetString(PyExc_RuntimeError, 10822 "Unexpected error in an Op's C code. " 10823 "No Python exception was set."); 10824 } 10825 goto __label_108;} 10826 } 10827 // We expect NPY_FLOAT64 10828 if (!PyArray_ISALIGNED((PyArrayObject*) py_V107)) { 10829 PyArrayObject * tmp = (PyArrayObject*) py_V107; 10830 PyErr_Format(PyExc_NotImplementedError, 10831 "expected an aligned array of type %ld " 10832 "(NPY_FLOAT64), got non-aligned array of type %ld" 10833 " with %ld dimensions, with 3 last dims " 10834 "%ld, %ld, %ld" 10835 " and 3 last strides %ld %ld, %ld.", 10836 (long int) NPY_FLOAT64, 10837 (long int) PyArray_TYPE((PyArrayObject*) py_V107), 10838 (long int) PyArray_NDIM(tmp), 10839 (long int) (PyArray_NDIM(tmp) >= 3 ? 10840 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 10841 (long int) (PyArray_NDIM(tmp) >= 2 ? 10842 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 10843 (long int) (PyArray_NDIM(tmp) >= 1 ? 10844 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 10845 (long int) (PyArray_NDIM(tmp) >= 3 ? 10846 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 10847 (long int) (PyArray_NDIM(tmp) >= 2 ? 10848 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 10849 (long int) (PyArray_NDIM(tmp) >= 1 ? 10850 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 10851 ); 10852 { 10853 __failure = 108; 10854 if (!PyErr_Occurred()) { 10855 PyErr_SetString(PyExc_RuntimeError, 10856 "Unexpected error in an Op's C code. " 10857 "No Python exception was set."); 10858 } 10859 goto __label_108;} 10860 } 10861 // This is a TypeError to be consistent with DEBUG_MODE 10862 // Note: DEBUG_MODE also tells the name of the container 10863 if (PyArray_TYPE((PyArrayObject*) py_V107) != NPY_FLOAT64) { 10864 PyErr_Format(PyExc_TypeError, 10865 "expected type_num %d (NPY_FLOAT64) got %d", 10866 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V107)); 10867 { 10868 __failure = 108; 10869 if (!PyErr_Occurred()) { 10870 PyErr_SetString(PyExc_RuntimeError, 10871 "Unexpected error in an Op's C code. " 10872 "No Python exception was set."); 10873 } 10874 goto __label_108;} 10875 } 10876 10877 V107 = (PyArrayObject*)(py_V107); 10878 Py_XINCREF(V107); 10879 10880 { 10881 10882 py_V109 = PyList_GET_ITEM(storage_V109, 0); 10883 {Py_XINCREF(py_V109);} 10884 10885 V109 = NULL; 10886 if (py_V109 == Py_None) { 10887 // We can either fail here or set V109 to NULL and rely on Ops 10888 // using tensors to handle the NULL case, but if they fail to do so 10889 // they'll end up with nasty segfaults, so this is public service. 10890 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 10891 { 10892 __failure = 110; 10893 if (!PyErr_Occurred()) { 10894 PyErr_SetString(PyExc_RuntimeError, 10895 "Unexpected error in an Op's C code. " 10896 "No Python exception was set."); 10897 } 10898 goto __label_110;} 10899 } 10900 if (!PyArray_Check(py_V109)) { 10901 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 10902 { 10903 __failure = 110; 10904 if (!PyErr_Occurred()) { 10905 PyErr_SetString(PyExc_RuntimeError, 10906 "Unexpected error in an Op's C code. " 10907 "No Python exception was set."); 10908 } 10909 goto __label_110;} 10910 } 10911 // We expect NPY_FLOAT64 10912 if (!PyArray_ISALIGNED((PyArrayObject*) py_V109)) { 10913 PyArrayObject * tmp = (PyArrayObject*) py_V109; 10914 PyErr_Format(PyExc_NotImplementedError, 10915 "expected an aligned array of type %ld " 10916 "(NPY_FLOAT64), got non-aligned array of type %ld" 10917 " with %ld dimensions, with 3 last dims " 10918 "%ld, %ld, %ld" 10919 " and 3 last strides %ld %ld, %ld.", 10920 (long int) NPY_FLOAT64, 10921 (long int) PyArray_TYPE((PyArrayObject*) py_V109), 10922 (long int) PyArray_NDIM(tmp), 10923 (long int) (PyArray_NDIM(tmp) >= 3 ? 10924 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 10925 (long int) (PyArray_NDIM(tmp) >= 2 ? 10926 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 10927 (long int) (PyArray_NDIM(tmp) >= 1 ? 10928 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 10929 (long int) (PyArray_NDIM(tmp) >= 3 ? 10930 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 10931 (long int) (PyArray_NDIM(tmp) >= 2 ? 10932 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 10933 (long int) (PyArray_NDIM(tmp) >= 1 ? 10934 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 10935 ); 10936 { 10937 __failure = 110; 10938 if (!PyErr_Occurred()) { 10939 PyErr_SetString(PyExc_RuntimeError, 10940 "Unexpected error in an Op's C code. " 10941 "No Python exception was set."); 10942 } 10943 goto __label_110;} 10944 } 10945 // This is a TypeError to be consistent with DEBUG_MODE 10946 // Note: DEBUG_MODE also tells the name of the container 10947 if (PyArray_TYPE((PyArrayObject*) py_V109) != NPY_FLOAT64) { 10948 PyErr_Format(PyExc_TypeError, 10949 "expected type_num %d (NPY_FLOAT64) got %d", 10950 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V109)); 10951 { 10952 __failure = 110; 10953 if (!PyErr_Occurred()) { 10954 PyErr_SetString(PyExc_RuntimeError, 10955 "Unexpected error in an Op's C code. " 10956 "No Python exception was set."); 10957 } 10958 goto __label_110;} 10959 } 10960 10961 V109 = (PyArrayObject*)(py_V109); 10962 Py_XINCREF(V109); 10963 10964 { 10965 10966 py_V111 = PyList_GET_ITEM(storage_V111, 0); 10967 {Py_XINCREF(py_V111);} 10968 10969 V111 = NULL; 10970 if (py_V111 == Py_None) { 10971 // We can either fail here or set V111 to NULL and rely on Ops 10972 // using tensors to handle the NULL case, but if they fail to do so 10973 // they'll end up with nasty segfaults, so this is public service. 10974 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 10975 { 10976 __failure = 112; 10977 if (!PyErr_Occurred()) { 10978 PyErr_SetString(PyExc_RuntimeError, 10979 "Unexpected error in an Op's C code. " 10980 "No Python exception was set."); 10981 } 10982 goto __label_112;} 10983 } 10984 if (!PyArray_Check(py_V111)) { 10985 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 10986 { 10987 __failure = 112; 10988 if (!PyErr_Occurred()) { 10989 PyErr_SetString(PyExc_RuntimeError, 10990 "Unexpected error in an Op's C code. " 10991 "No Python exception was set."); 10992 } 10993 goto __label_112;} 10994 } 10995 // We expect NPY_FLOAT64 10996 if (!PyArray_ISALIGNED((PyArrayObject*) py_V111)) { 10997 PyArrayObject * tmp = (PyArrayObject*) py_V111; 10998 PyErr_Format(PyExc_NotImplementedError, 10999 "expected an aligned array of type %ld " 11000 "(NPY_FLOAT64), got non-aligned array of type %ld" 11001 " with %ld dimensions, with 3 last dims " 11002 "%ld, %ld, %ld" 11003 " and 3 last strides %ld %ld, %ld.", 11004 (long int) NPY_FLOAT64, 11005 (long int) PyArray_TYPE((PyArrayObject*) py_V111), 11006 (long int) PyArray_NDIM(tmp), 11007 (long int) (PyArray_NDIM(tmp) >= 3 ? 11008 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 11009 (long int) (PyArray_NDIM(tmp) >= 2 ? 11010 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 11011 (long int) (PyArray_NDIM(tmp) >= 1 ? 11012 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 11013 (long int) (PyArray_NDIM(tmp) >= 3 ? 11014 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 11015 (long int) (PyArray_NDIM(tmp) >= 2 ? 11016 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 11017 (long int) (PyArray_NDIM(tmp) >= 1 ? 11018 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 11019 ); 11020 { 11021 __failure = 112; 11022 if (!PyErr_Occurred()) { 11023 PyErr_SetString(PyExc_RuntimeError, 11024 "Unexpected error in an Op's C code. " 11025 "No Python exception was set."); 11026 } 11027 goto __label_112;} 11028 } 11029 // This is a TypeError to be consistent with DEBUG_MODE 11030 // Note: DEBUG_MODE also tells the name of the container 11031 if (PyArray_TYPE((PyArrayObject*) py_V111) != NPY_FLOAT64) { 11032 PyErr_Format(PyExc_TypeError, 11033 "expected type_num %d (NPY_FLOAT64) got %d", 11034 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V111)); 11035 { 11036 __failure = 112; 11037 if (!PyErr_Occurred()) { 11038 PyErr_SetString(PyExc_RuntimeError, 11039 "Unexpected error in an Op's C code. " 11040 "No Python exception was set."); 11041 } 11042 goto __label_112;} 11043 } 11044 11045 V111 = (PyArrayObject*)(py_V111); 11046 Py_XINCREF(V111); 11047 11048 { 11049 11050 py_V113 = PyList_GET_ITEM(storage_V113, 0); 11051 {Py_XINCREF(py_V113);} 11052 11053 V113 = NULL; 11054 if (py_V113 == Py_None) { 11055 // We can either fail here or set V113 to NULL and rely on Ops 11056 // using tensors to handle the NULL case, but if they fail to do so 11057 // they'll end up with nasty segfaults, so this is public service. 11058 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 11059 { 11060 __failure = 114; 11061 if (!PyErr_Occurred()) { 11062 PyErr_SetString(PyExc_RuntimeError, 11063 "Unexpected error in an Op's C code. " 11064 "No Python exception was set."); 11065 } 11066 goto __label_114;} 11067 } 11068 if (!PyArray_Check(py_V113)) { 11069 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 11070 { 11071 __failure = 114; 11072 if (!PyErr_Occurred()) { 11073 PyErr_SetString(PyExc_RuntimeError, 11074 "Unexpected error in an Op's C code. " 11075 "No Python exception was set."); 11076 } 11077 goto __label_114;} 11078 } 11079 // We expect NPY_FLOAT64 11080 if (!PyArray_ISALIGNED((PyArrayObject*) py_V113)) { 11081 PyArrayObject * tmp = (PyArrayObject*) py_V113; 11082 PyErr_Format(PyExc_NotImplementedError, 11083 "expected an aligned array of type %ld " 11084 "(NPY_FLOAT64), got non-aligned array of type %ld" 11085 " with %ld dimensions, with 3 last dims " 11086 "%ld, %ld, %ld" 11087 " and 3 last strides %ld %ld, %ld.", 11088 (long int) NPY_FLOAT64, 11089 (long int) PyArray_TYPE((PyArrayObject*) py_V113), 11090 (long int) PyArray_NDIM(tmp), 11091 (long int) (PyArray_NDIM(tmp) >= 3 ? 11092 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 11093 (long int) (PyArray_NDIM(tmp) >= 2 ? 11094 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 11095 (long int) (PyArray_NDIM(tmp) >= 1 ? 11096 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 11097 (long int) (PyArray_NDIM(tmp) >= 3 ? 11098 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 11099 (long int) (PyArray_NDIM(tmp) >= 2 ? 11100 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 11101 (long int) (PyArray_NDIM(tmp) >= 1 ? 11102 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 11103 ); 11104 { 11105 __failure = 114; 11106 if (!PyErr_Occurred()) { 11107 PyErr_SetString(PyExc_RuntimeError, 11108 "Unexpected error in an Op's C code. " 11109 "No Python exception was set."); 11110 } 11111 goto __label_114;} 11112 } 11113 // This is a TypeError to be consistent with DEBUG_MODE 11114 // Note: DEBUG_MODE also tells the name of the container 11115 if (PyArray_TYPE((PyArrayObject*) py_V113) != NPY_FLOAT64) { 11116 PyErr_Format(PyExc_TypeError, 11117 "expected type_num %d (NPY_FLOAT64) got %d", 11118 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V113)); 11119 { 11120 __failure = 114; 11121 if (!PyErr_Occurred()) { 11122 PyErr_SetString(PyExc_RuntimeError, 11123 "Unexpected error in an Op's C code. " 11124 "No Python exception was set."); 11125 } 11126 goto __label_114;} 11127 } 11128 11129 V113 = (PyArrayObject*)(py_V113); 11130 Py_XINCREF(V113); 11131 11132 { 11133 11134 py_V115 = PyList_GET_ITEM(storage_V115, 0); 11135 {Py_XINCREF(py_V115);} 11136 11137 V115 = NULL; 11138 if (py_V115 == Py_None) { 11139 // We can either fail here or set V115 to NULL and rely on Ops 11140 // using tensors to handle the NULL case, but if they fail to do so 11141 // they'll end up with nasty segfaults, so this is public service. 11142 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 11143 { 11144 __failure = 116; 11145 if (!PyErr_Occurred()) { 11146 PyErr_SetString(PyExc_RuntimeError, 11147 "Unexpected error in an Op's C code. " 11148 "No Python exception was set."); 11149 } 11150 goto __label_116;} 11151 } 11152 if (!PyArray_Check(py_V115)) { 11153 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 11154 { 11155 __failure = 116; 11156 if (!PyErr_Occurred()) { 11157 PyErr_SetString(PyExc_RuntimeError, 11158 "Unexpected error in an Op's C code. " 11159 "No Python exception was set."); 11160 } 11161 goto __label_116;} 11162 } 11163 // We expect NPY_FLOAT64 11164 if (!PyArray_ISALIGNED((PyArrayObject*) py_V115)) { 11165 PyArrayObject * tmp = (PyArrayObject*) py_V115; 11166 PyErr_Format(PyExc_NotImplementedError, 11167 "expected an aligned array of type %ld " 11168 "(NPY_FLOAT64), got non-aligned array of type %ld" 11169 " with %ld dimensions, with 3 last dims " 11170 "%ld, %ld, %ld" 11171 " and 3 last strides %ld %ld, %ld.", 11172 (long int) NPY_FLOAT64, 11173 (long int) PyArray_TYPE((PyArrayObject*) py_V115), 11174 (long int) PyArray_NDIM(tmp), 11175 (long int) (PyArray_NDIM(tmp) >= 3 ? 11176 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 11177 (long int) (PyArray_NDIM(tmp) >= 2 ? 11178 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 11179 (long int) (PyArray_NDIM(tmp) >= 1 ? 11180 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 11181 (long int) (PyArray_NDIM(tmp) >= 3 ? 11182 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 11183 (long int) (PyArray_NDIM(tmp) >= 2 ? 11184 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 11185 (long int) (PyArray_NDIM(tmp) >= 1 ? 11186 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 11187 ); 11188 { 11189 __failure = 116; 11190 if (!PyErr_Occurred()) { 11191 PyErr_SetString(PyExc_RuntimeError, 11192 "Unexpected error in an Op's C code. " 11193 "No Python exception was set."); 11194 } 11195 goto __label_116;} 11196 } 11197 // This is a TypeError to be consistent with DEBUG_MODE 11198 // Note: DEBUG_MODE also tells the name of the container 11199 if (PyArray_TYPE((PyArrayObject*) py_V115) != NPY_FLOAT64) { 11200 PyErr_Format(PyExc_TypeError, 11201 "expected type_num %d (NPY_FLOAT64) got %d", 11202 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V115)); 11203 { 11204 __failure = 116; 11205 if (!PyErr_Occurred()) { 11206 PyErr_SetString(PyExc_RuntimeError, 11207 "Unexpected error in an Op's C code. " 11208 "No Python exception was set."); 11209 } 11210 goto __label_116;} 11211 } 11212 11213 V115 = (PyArrayObject*)(py_V115); 11214 Py_XINCREF(V115); 11215 11216 { 11217 11218 py_V117 = PyList_GET_ITEM(storage_V117, 0); 11219 {Py_XINCREF(py_V117);} 11220 11221 V117 = NULL; 11222 if (py_V117 == Py_None) { 11223 // We can either fail here or set V117 to NULL and rely on Ops 11224 // using tensors to handle the NULL case, but if they fail to do so 11225 // they'll end up with nasty segfaults, so this is public service. 11226 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 11227 { 11228 __failure = 118; 11229 if (!PyErr_Occurred()) { 11230 PyErr_SetString(PyExc_RuntimeError, 11231 "Unexpected error in an Op's C code. " 11232 "No Python exception was set."); 11233 } 11234 goto __label_118;} 11235 } 11236 if (!PyArray_Check(py_V117)) { 11237 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 11238 { 11239 __failure = 118; 11240 if (!PyErr_Occurred()) { 11241 PyErr_SetString(PyExc_RuntimeError, 11242 "Unexpected error in an Op's C code. " 11243 "No Python exception was set."); 11244 } 11245 goto __label_118;} 11246 } 11247 // We expect NPY_FLOAT64 11248 if (!PyArray_ISALIGNED((PyArrayObject*) py_V117)) { 11249 PyArrayObject * tmp = (PyArrayObject*) py_V117; 11250 PyErr_Format(PyExc_NotImplementedError, 11251 "expected an aligned array of type %ld " 11252 "(NPY_FLOAT64), got non-aligned array of type %ld" 11253 " with %ld dimensions, with 3 last dims " 11254 "%ld, %ld, %ld" 11255 " and 3 last strides %ld %ld, %ld.", 11256 (long int) NPY_FLOAT64, 11257 (long int) PyArray_TYPE((PyArrayObject*) py_V117), 11258 (long int) PyArray_NDIM(tmp), 11259 (long int) (PyArray_NDIM(tmp) >= 3 ? 11260 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 11261 (long int) (PyArray_NDIM(tmp) >= 2 ? 11262 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 11263 (long int) (PyArray_NDIM(tmp) >= 1 ? 11264 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 11265 (long int) (PyArray_NDIM(tmp) >= 3 ? 11266 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 11267 (long int) (PyArray_NDIM(tmp) >= 2 ? 11268 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 11269 (long int) (PyArray_NDIM(tmp) >= 1 ? 11270 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 11271 ); 11272 { 11273 __failure = 118; 11274 if (!PyErr_Occurred()) { 11275 PyErr_SetString(PyExc_RuntimeError, 11276 "Unexpected error in an Op's C code. " 11277 "No Python exception was set."); 11278 } 11279 goto __label_118;} 11280 } 11281 // This is a TypeError to be consistent with DEBUG_MODE 11282 // Note: DEBUG_MODE also tells the name of the container 11283 if (PyArray_TYPE((PyArrayObject*) py_V117) != NPY_FLOAT64) { 11284 PyErr_Format(PyExc_TypeError, 11285 "expected type_num %d (NPY_FLOAT64) got %d", 11286 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V117)); 11287 { 11288 __failure = 118; 11289 if (!PyErr_Occurred()) { 11290 PyErr_SetString(PyExc_RuntimeError, 11291 "Unexpected error in an Op's C code. " 11292 "No Python exception was set."); 11293 } 11294 goto __label_118;} 11295 } 11296 11297 V117 = (PyArrayObject*)(py_V117); 11298 Py_XINCREF(V117); 11299 11300 { 11301 11302 py_V119 = PyList_GET_ITEM(storage_V119, 0); 11303 {Py_XINCREF(py_V119);} 11304 11305 V119 = NULL; 11306 if (py_V119 == Py_None) { 11307 // We can either fail here or set V119 to NULL and rely on Ops 11308 // using tensors to handle the NULL case, but if they fail to do so 11309 // they'll end up with nasty segfaults, so this is public service. 11310 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 11311 { 11312 __failure = 120; 11313 if (!PyErr_Occurred()) { 11314 PyErr_SetString(PyExc_RuntimeError, 11315 "Unexpected error in an Op's C code. " 11316 "No Python exception was set."); 11317 } 11318 goto __label_120;} 11319 } 11320 if (!PyArray_Check(py_V119)) { 11321 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 11322 { 11323 __failure = 120; 11324 if (!PyErr_Occurred()) { 11325 PyErr_SetString(PyExc_RuntimeError, 11326 "Unexpected error in an Op's C code. " 11327 "No Python exception was set."); 11328 } 11329 goto __label_120;} 11330 } 11331 // We expect NPY_FLOAT64 11332 if (!PyArray_ISALIGNED((PyArrayObject*) py_V119)) { 11333 PyArrayObject * tmp = (PyArrayObject*) py_V119; 11334 PyErr_Format(PyExc_NotImplementedError, 11335 "expected an aligned array of type %ld " 11336 "(NPY_FLOAT64), got non-aligned array of type %ld" 11337 " with %ld dimensions, with 3 last dims " 11338 "%ld, %ld, %ld" 11339 " and 3 last strides %ld %ld, %ld.", 11340 (long int) NPY_FLOAT64, 11341 (long int) PyArray_TYPE((PyArrayObject*) py_V119), 11342 (long int) PyArray_NDIM(tmp), 11343 (long int) (PyArray_NDIM(tmp) >= 3 ? 11344 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 11345 (long int) (PyArray_NDIM(tmp) >= 2 ? 11346 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 11347 (long int) (PyArray_NDIM(tmp) >= 1 ? 11348 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 11349 (long int) (PyArray_NDIM(tmp) >= 3 ? 11350 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 11351 (long int) (PyArray_NDIM(tmp) >= 2 ? 11352 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 11353 (long int) (PyArray_NDIM(tmp) >= 1 ? 11354 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 11355 ); 11356 { 11357 __failure = 120; 11358 if (!PyErr_Occurred()) { 11359 PyErr_SetString(PyExc_RuntimeError, 11360 "Unexpected error in an Op's C code. " 11361 "No Python exception was set."); 11362 } 11363 goto __label_120;} 11364 } 11365 // This is a TypeError to be consistent with DEBUG_MODE 11366 // Note: DEBUG_MODE also tells the name of the container 11367 if (PyArray_TYPE((PyArrayObject*) py_V119) != NPY_FLOAT64) { 11368 PyErr_Format(PyExc_TypeError, 11369 "expected type_num %d (NPY_FLOAT64) got %d", 11370 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V119)); 11371 { 11372 __failure = 120; 11373 if (!PyErr_Occurred()) { 11374 PyErr_SetString(PyExc_RuntimeError, 11375 "Unexpected error in an Op's C code. " 11376 "No Python exception was set."); 11377 } 11378 goto __label_120;} 11379 } 11380 11381 V119 = (PyArrayObject*)(py_V119); 11382 Py_XINCREF(V119); 11383 11384 { 11385 11386 py_V121 = PyList_GET_ITEM(storage_V121, 0); 11387 {Py_XINCREF(py_V121);} 11388 11389 V121 = NULL; 11390 if (py_V121 == Py_None) { 11391 // We can either fail here or set V121 to NULL and rely on Ops 11392 // using tensors to handle the NULL case, but if they fail to do so 11393 // they'll end up with nasty segfaults, so this is public service. 11394 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 11395 { 11396 __failure = 122; 11397 if (!PyErr_Occurred()) { 11398 PyErr_SetString(PyExc_RuntimeError, 11399 "Unexpected error in an Op's C code. " 11400 "No Python exception was set."); 11401 } 11402 goto __label_122;} 11403 } 11404 if (!PyArray_Check(py_V121)) { 11405 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 11406 { 11407 __failure = 122; 11408 if (!PyErr_Occurred()) { 11409 PyErr_SetString(PyExc_RuntimeError, 11410 "Unexpected error in an Op's C code. " 11411 "No Python exception was set."); 11412 } 11413 goto __label_122;} 11414 } 11415 // We expect NPY_FLOAT64 11416 if (!PyArray_ISALIGNED((PyArrayObject*) py_V121)) { 11417 PyArrayObject * tmp = (PyArrayObject*) py_V121; 11418 PyErr_Format(PyExc_NotImplementedError, 11419 "expected an aligned array of type %ld " 11420 "(NPY_FLOAT64), got non-aligned array of type %ld" 11421 " with %ld dimensions, with 3 last dims " 11422 "%ld, %ld, %ld" 11423 " and 3 last strides %ld %ld, %ld.", 11424 (long int) NPY_FLOAT64, 11425 (long int) PyArray_TYPE((PyArrayObject*) py_V121), 11426 (long int) PyArray_NDIM(tmp), 11427 (long int) (PyArray_NDIM(tmp) >= 3 ? 11428 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 11429 (long int) (PyArray_NDIM(tmp) >= 2 ? 11430 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 11431 (long int) (PyArray_NDIM(tmp) >= 1 ? 11432 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 11433 (long int) (PyArray_NDIM(tmp) >= 3 ? 11434 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 11435 (long int) (PyArray_NDIM(tmp) >= 2 ? 11436 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 11437 (long int) (PyArray_NDIM(tmp) >= 1 ? 11438 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 11439 ); 11440 { 11441 __failure = 122; 11442 if (!PyErr_Occurred()) { 11443 PyErr_SetString(PyExc_RuntimeError, 11444 "Unexpected error in an Op's C code. " 11445 "No Python exception was set."); 11446 } 11447 goto __label_122;} 11448 } 11449 // This is a TypeError to be consistent with DEBUG_MODE 11450 // Note: DEBUG_MODE also tells the name of the container 11451 if (PyArray_TYPE((PyArrayObject*) py_V121) != NPY_FLOAT64) { 11452 PyErr_Format(PyExc_TypeError, 11453 "expected type_num %d (NPY_FLOAT64) got %d", 11454 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V121)); 11455 { 11456 __failure = 122; 11457 if (!PyErr_Occurred()) { 11458 PyErr_SetString(PyExc_RuntimeError, 11459 "Unexpected error in an Op's C code. " 11460 "No Python exception was set."); 11461 } 11462 goto __label_122;} 11463 } 11464 11465 V121 = (PyArrayObject*)(py_V121); 11466 Py_XINCREF(V121); 11467 11468 { 11469 11470 py_V123 = PyList_GET_ITEM(storage_V123, 0); 11471 {Py_XINCREF(py_V123);} 11472 11473 V123 = NULL; 11474 if (py_V123 == Py_None) { 11475 // We can either fail here or set V123 to NULL and rely on Ops 11476 // using tensors to handle the NULL case, but if they fail to do so 11477 // they'll end up with nasty segfaults, so this is public service. 11478 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 11479 { 11480 __failure = 124; 11481 if (!PyErr_Occurred()) { 11482 PyErr_SetString(PyExc_RuntimeError, 11483 "Unexpected error in an Op's C code. " 11484 "No Python exception was set."); 11485 } 11486 goto __label_124;} 11487 } 11488 if (!PyArray_Check(py_V123)) { 11489 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 11490 { 11491 __failure = 124; 11492 if (!PyErr_Occurred()) { 11493 PyErr_SetString(PyExc_RuntimeError, 11494 "Unexpected error in an Op's C code. " 11495 "No Python exception was set."); 11496 } 11497 goto __label_124;} 11498 } 11499 // We expect NPY_FLOAT64 11500 if (!PyArray_ISALIGNED((PyArrayObject*) py_V123)) { 11501 PyArrayObject * tmp = (PyArrayObject*) py_V123; 11502 PyErr_Format(PyExc_NotImplementedError, 11503 "expected an aligned array of type %ld " 11504 "(NPY_FLOAT64), got non-aligned array of type %ld" 11505 " with %ld dimensions, with 3 last dims " 11506 "%ld, %ld, %ld" 11507 " and 3 last strides %ld %ld, %ld.", 11508 (long int) NPY_FLOAT64, 11509 (long int) PyArray_TYPE((PyArrayObject*) py_V123), 11510 (long int) PyArray_NDIM(tmp), 11511 (long int) (PyArray_NDIM(tmp) >= 3 ? 11512 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 11513 (long int) (PyArray_NDIM(tmp) >= 2 ? 11514 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 11515 (long int) (PyArray_NDIM(tmp) >= 1 ? 11516 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 11517 (long int) (PyArray_NDIM(tmp) >= 3 ? 11518 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 11519 (long int) (PyArray_NDIM(tmp) >= 2 ? 11520 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 11521 (long int) (PyArray_NDIM(tmp) >= 1 ? 11522 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 11523 ); 11524 { 11525 __failure = 124; 11526 if (!PyErr_Occurred()) { 11527 PyErr_SetString(PyExc_RuntimeError, 11528 "Unexpected error in an Op's C code. " 11529 "No Python exception was set."); 11530 } 11531 goto __label_124;} 11532 } 11533 // This is a TypeError to be consistent with DEBUG_MODE 11534 // Note: DEBUG_MODE also tells the name of the container 11535 if (PyArray_TYPE((PyArrayObject*) py_V123) != NPY_FLOAT64) { 11536 PyErr_Format(PyExc_TypeError, 11537 "expected type_num %d (NPY_FLOAT64) got %d", 11538 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V123)); 11539 { 11540 __failure = 124; 11541 if (!PyErr_Occurred()) { 11542 PyErr_SetString(PyExc_RuntimeError, 11543 "Unexpected error in an Op's C code. " 11544 "No Python exception was set."); 11545 } 11546 goto __label_124;} 11547 } 11548 11549 V123 = (PyArrayObject*)(py_V123); 11550 Py_XINCREF(V123); 11551 11552 { 11553 11554 py_V125 = PyList_GET_ITEM(storage_V125, 0); 11555 {Py_XINCREF(py_V125);} 11556 11557 V125 = NULL; 11558 if (py_V125 == Py_None) { 11559 // We can either fail here or set V125 to NULL and rely on Ops 11560 // using tensors to handle the NULL case, but if they fail to do so 11561 // they'll end up with nasty segfaults, so this is public service. 11562 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 11563 { 11564 __failure = 126; 11565 if (!PyErr_Occurred()) { 11566 PyErr_SetString(PyExc_RuntimeError, 11567 "Unexpected error in an Op's C code. " 11568 "No Python exception was set."); 11569 } 11570 goto __label_126;} 11571 } 11572 if (!PyArray_Check(py_V125)) { 11573 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 11574 { 11575 __failure = 126; 11576 if (!PyErr_Occurred()) { 11577 PyErr_SetString(PyExc_RuntimeError, 11578 "Unexpected error in an Op's C code. " 11579 "No Python exception was set."); 11580 } 11581 goto __label_126;} 11582 } 11583 // We expect NPY_FLOAT64 11584 if (!PyArray_ISALIGNED((PyArrayObject*) py_V125)) { 11585 PyArrayObject * tmp = (PyArrayObject*) py_V125; 11586 PyErr_Format(PyExc_NotImplementedError, 11587 "expected an aligned array of type %ld " 11588 "(NPY_FLOAT64), got non-aligned array of type %ld" 11589 " with %ld dimensions, with 3 last dims " 11590 "%ld, %ld, %ld" 11591 " and 3 last strides %ld %ld, %ld.", 11592 (long int) NPY_FLOAT64, 11593 (long int) PyArray_TYPE((PyArrayObject*) py_V125), 11594 (long int) PyArray_NDIM(tmp), 11595 (long int) (PyArray_NDIM(tmp) >= 3 ? 11596 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 11597 (long int) (PyArray_NDIM(tmp) >= 2 ? 11598 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 11599 (long int) (PyArray_NDIM(tmp) >= 1 ? 11600 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 11601 (long int) (PyArray_NDIM(tmp) >= 3 ? 11602 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 11603 (long int) (PyArray_NDIM(tmp) >= 2 ? 11604 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 11605 (long int) (PyArray_NDIM(tmp) >= 1 ? 11606 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 11607 ); 11608 { 11609 __failure = 126; 11610 if (!PyErr_Occurred()) { 11611 PyErr_SetString(PyExc_RuntimeError, 11612 "Unexpected error in an Op's C code. " 11613 "No Python exception was set."); 11614 } 11615 goto __label_126;} 11616 } 11617 // This is a TypeError to be consistent with DEBUG_MODE 11618 // Note: DEBUG_MODE also tells the name of the container 11619 if (PyArray_TYPE((PyArrayObject*) py_V125) != NPY_FLOAT64) { 11620 PyErr_Format(PyExc_TypeError, 11621 "expected type_num %d (NPY_FLOAT64) got %d", 11622 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V125)); 11623 { 11624 __failure = 126; 11625 if (!PyErr_Occurred()) { 11626 PyErr_SetString(PyExc_RuntimeError, 11627 "Unexpected error in an Op's C code. " 11628 "No Python exception was set."); 11629 } 11630 goto __label_126;} 11631 } 11632 11633 V125 = (PyArrayObject*)(py_V125); 11634 Py_XINCREF(V125); 11635 11636 { 11637 11638 py_V127 = PyList_GET_ITEM(storage_V127, 0); 11639 {Py_XINCREF(py_V127);} 11640 11641 V127 = NULL; 11642 if (py_V127 == Py_None) { 11643 // We can either fail here or set V127 to NULL and rely on Ops 11644 // using tensors to handle the NULL case, but if they fail to do so 11645 // they'll end up with nasty segfaults, so this is public service. 11646 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 11647 { 11648 __failure = 128; 11649 if (!PyErr_Occurred()) { 11650 PyErr_SetString(PyExc_RuntimeError, 11651 "Unexpected error in an Op's C code. " 11652 "No Python exception was set."); 11653 } 11654 goto __label_128;} 11655 } 11656 if (!PyArray_Check(py_V127)) { 11657 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 11658 { 11659 __failure = 128; 11660 if (!PyErr_Occurred()) { 11661 PyErr_SetString(PyExc_RuntimeError, 11662 "Unexpected error in an Op's C code. " 11663 "No Python exception was set."); 11664 } 11665 goto __label_128;} 11666 } 11667 // We expect NPY_FLOAT64 11668 if (!PyArray_ISALIGNED((PyArrayObject*) py_V127)) { 11669 PyArrayObject * tmp = (PyArrayObject*) py_V127; 11670 PyErr_Format(PyExc_NotImplementedError, 11671 "expected an aligned array of type %ld " 11672 "(NPY_FLOAT64), got non-aligned array of type %ld" 11673 " with %ld dimensions, with 3 last dims " 11674 "%ld, %ld, %ld" 11675 " and 3 last strides %ld %ld, %ld.", 11676 (long int) NPY_FLOAT64, 11677 (long int) PyArray_TYPE((PyArrayObject*) py_V127), 11678 (long int) PyArray_NDIM(tmp), 11679 (long int) (PyArray_NDIM(tmp) >= 3 ? 11680 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 11681 (long int) (PyArray_NDIM(tmp) >= 2 ? 11682 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 11683 (long int) (PyArray_NDIM(tmp) >= 1 ? 11684 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 11685 (long int) (PyArray_NDIM(tmp) >= 3 ? 11686 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 11687 (long int) (PyArray_NDIM(tmp) >= 2 ? 11688 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 11689 (long int) (PyArray_NDIM(tmp) >= 1 ? 11690 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 11691 ); 11692 { 11693 __failure = 128; 11694 if (!PyErr_Occurred()) { 11695 PyErr_SetString(PyExc_RuntimeError, 11696 "Unexpected error in an Op's C code. " 11697 "No Python exception was set."); 11698 } 11699 goto __label_128;} 11700 } 11701 // This is a TypeError to be consistent with DEBUG_MODE 11702 // Note: DEBUG_MODE also tells the name of the container 11703 if (PyArray_TYPE((PyArrayObject*) py_V127) != NPY_FLOAT64) { 11704 PyErr_Format(PyExc_TypeError, 11705 "expected type_num %d (NPY_FLOAT64) got %d", 11706 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V127)); 11707 { 11708 __failure = 128; 11709 if (!PyErr_Occurred()) { 11710 PyErr_SetString(PyExc_RuntimeError, 11711 "Unexpected error in an Op's C code. " 11712 "No Python exception was set."); 11713 } 11714 goto __label_128;} 11715 } 11716 11717 V127 = (PyArrayObject*)(py_V127); 11718 Py_XINCREF(V127); 11719 11720 { 11721 11722 py_V129 = PyList_GET_ITEM(storage_V129, 0); 11723 {Py_XINCREF(py_V129);} 11724 11725 V129 = NULL; 11726 if (py_V129 == Py_None) { 11727 // We can either fail here or set V129 to NULL and rely on Ops 11728 // using tensors to handle the NULL case, but if they fail to do so 11729 // they'll end up with nasty segfaults, so this is public service. 11730 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 11731 { 11732 __failure = 130; 11733 if (!PyErr_Occurred()) { 11734 PyErr_SetString(PyExc_RuntimeError, 11735 "Unexpected error in an Op's C code. " 11736 "No Python exception was set."); 11737 } 11738 goto __label_130;} 11739 } 11740 if (!PyArray_Check(py_V129)) { 11741 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 11742 { 11743 __failure = 130; 11744 if (!PyErr_Occurred()) { 11745 PyErr_SetString(PyExc_RuntimeError, 11746 "Unexpected error in an Op's C code. " 11747 "No Python exception was set."); 11748 } 11749 goto __label_130;} 11750 } 11751 // We expect NPY_FLOAT64 11752 if (!PyArray_ISALIGNED((PyArrayObject*) py_V129)) { 11753 PyArrayObject * tmp = (PyArrayObject*) py_V129; 11754 PyErr_Format(PyExc_NotImplementedError, 11755 "expected an aligned array of type %ld " 11756 "(NPY_FLOAT64), got non-aligned array of type %ld" 11757 " with %ld dimensions, with 3 last dims " 11758 "%ld, %ld, %ld" 11759 " and 3 last strides %ld %ld, %ld.", 11760 (long int) NPY_FLOAT64, 11761 (long int) PyArray_TYPE((PyArrayObject*) py_V129), 11762 (long int) PyArray_NDIM(tmp), 11763 (long int) (PyArray_NDIM(tmp) >= 3 ? 11764 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 11765 (long int) (PyArray_NDIM(tmp) >= 2 ? 11766 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 11767 (long int) (PyArray_NDIM(tmp) >= 1 ? 11768 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 11769 (long int) (PyArray_NDIM(tmp) >= 3 ? 11770 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 11771 (long int) (PyArray_NDIM(tmp) >= 2 ? 11772 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 11773 (long int) (PyArray_NDIM(tmp) >= 1 ? 11774 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 11775 ); 11776 { 11777 __failure = 130; 11778 if (!PyErr_Occurred()) { 11779 PyErr_SetString(PyExc_RuntimeError, 11780 "Unexpected error in an Op's C code. " 11781 "No Python exception was set."); 11782 } 11783 goto __label_130;} 11784 } 11785 // This is a TypeError to be consistent with DEBUG_MODE 11786 // Note: DEBUG_MODE also tells the name of the container 11787 if (PyArray_TYPE((PyArrayObject*) py_V129) != NPY_FLOAT64) { 11788 PyErr_Format(PyExc_TypeError, 11789 "expected type_num %d (NPY_FLOAT64) got %d", 11790 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V129)); 11791 { 11792 __failure = 130; 11793 if (!PyErr_Occurred()) { 11794 PyErr_SetString(PyExc_RuntimeError, 11795 "Unexpected error in an Op's C code. " 11796 "No Python exception was set."); 11797 } 11798 goto __label_130;} 11799 } 11800 11801 V129 = (PyArrayObject*)(py_V129); 11802 Py_XINCREF(V129); 11803 11804 { 11805 11806 py_V131 = PyList_GET_ITEM(storage_V131, 0); 11807 {Py_XINCREF(py_V131);} 11808 11809 V131 = NULL; 11810 if (py_V131 == Py_None) { 11811 // We can either fail here or set V131 to NULL and rely on Ops 11812 // using tensors to handle the NULL case, but if they fail to do so 11813 // they'll end up with nasty segfaults, so this is public service. 11814 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 11815 { 11816 __failure = 132; 11817 if (!PyErr_Occurred()) { 11818 PyErr_SetString(PyExc_RuntimeError, 11819 "Unexpected error in an Op's C code. " 11820 "No Python exception was set."); 11821 } 11822 goto __label_132;} 11823 } 11824 if (!PyArray_Check(py_V131)) { 11825 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 11826 { 11827 __failure = 132; 11828 if (!PyErr_Occurred()) { 11829 PyErr_SetString(PyExc_RuntimeError, 11830 "Unexpected error in an Op's C code. " 11831 "No Python exception was set."); 11832 } 11833 goto __label_132;} 11834 } 11835 // We expect NPY_FLOAT64 11836 if (!PyArray_ISALIGNED((PyArrayObject*) py_V131)) { 11837 PyArrayObject * tmp = (PyArrayObject*) py_V131; 11838 PyErr_Format(PyExc_NotImplementedError, 11839 "expected an aligned array of type %ld " 11840 "(NPY_FLOAT64), got non-aligned array of type %ld" 11841 " with %ld dimensions, with 3 last dims " 11842 "%ld, %ld, %ld" 11843 " and 3 last strides %ld %ld, %ld.", 11844 (long int) NPY_FLOAT64, 11845 (long int) PyArray_TYPE((PyArrayObject*) py_V131), 11846 (long int) PyArray_NDIM(tmp), 11847 (long int) (PyArray_NDIM(tmp) >= 3 ? 11848 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 11849 (long int) (PyArray_NDIM(tmp) >= 2 ? 11850 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 11851 (long int) (PyArray_NDIM(tmp) >= 1 ? 11852 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 11853 (long int) (PyArray_NDIM(tmp) >= 3 ? 11854 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 11855 (long int) (PyArray_NDIM(tmp) >= 2 ? 11856 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 11857 (long int) (PyArray_NDIM(tmp) >= 1 ? 11858 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 11859 ); 11860 { 11861 __failure = 132; 11862 if (!PyErr_Occurred()) { 11863 PyErr_SetString(PyExc_RuntimeError, 11864 "Unexpected error in an Op's C code. " 11865 "No Python exception was set."); 11866 } 11867 goto __label_132;} 11868 } 11869 // This is a TypeError to be consistent with DEBUG_MODE 11870 // Note: DEBUG_MODE also tells the name of the container 11871 if (PyArray_TYPE((PyArrayObject*) py_V131) != NPY_FLOAT64) { 11872 PyErr_Format(PyExc_TypeError, 11873 "expected type_num %d (NPY_FLOAT64) got %d", 11874 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V131)); 11875 { 11876 __failure = 132; 11877 if (!PyErr_Occurred()) { 11878 PyErr_SetString(PyExc_RuntimeError, 11879 "Unexpected error in an Op's C code. " 11880 "No Python exception was set."); 11881 } 11882 goto __label_132;} 11883 } 11884 11885 V131 = (PyArrayObject*)(py_V131); 11886 Py_XINCREF(V131); 11887 11888 { 11889 11890 py_V133 = PyList_GET_ITEM(storage_V133, 0); 11891 {Py_XINCREF(py_V133);} 11892 11893 V133 = NULL; 11894 if (py_V133 == Py_None) { 11895 // We can either fail here or set V133 to NULL and rely on Ops 11896 // using tensors to handle the NULL case, but if they fail to do so 11897 // they'll end up with nasty segfaults, so this is public service. 11898 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 11899 { 11900 __failure = 134; 11901 if (!PyErr_Occurred()) { 11902 PyErr_SetString(PyExc_RuntimeError, 11903 "Unexpected error in an Op's C code. " 11904 "No Python exception was set."); 11905 } 11906 goto __label_134;} 11907 } 11908 if (!PyArray_Check(py_V133)) { 11909 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 11910 { 11911 __failure = 134; 11912 if (!PyErr_Occurred()) { 11913 PyErr_SetString(PyExc_RuntimeError, 11914 "Unexpected error in an Op's C code. " 11915 "No Python exception was set."); 11916 } 11917 goto __label_134;} 11918 } 11919 // We expect NPY_FLOAT64 11920 if (!PyArray_ISALIGNED((PyArrayObject*) py_V133)) { 11921 PyArrayObject * tmp = (PyArrayObject*) py_V133; 11922 PyErr_Format(PyExc_NotImplementedError, 11923 "expected an aligned array of type %ld " 11924 "(NPY_FLOAT64), got non-aligned array of type %ld" 11925 " with %ld dimensions, with 3 last dims " 11926 "%ld, %ld, %ld" 11927 " and 3 last strides %ld %ld, %ld.", 11928 (long int) NPY_FLOAT64, 11929 (long int) PyArray_TYPE((PyArrayObject*) py_V133), 11930 (long int) PyArray_NDIM(tmp), 11931 (long int) (PyArray_NDIM(tmp) >= 3 ? 11932 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 11933 (long int) (PyArray_NDIM(tmp) >= 2 ? 11934 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 11935 (long int) (PyArray_NDIM(tmp) >= 1 ? 11936 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 11937 (long int) (PyArray_NDIM(tmp) >= 3 ? 11938 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 11939 (long int) (PyArray_NDIM(tmp) >= 2 ? 11940 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 11941 (long int) (PyArray_NDIM(tmp) >= 1 ? 11942 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 11943 ); 11944 { 11945 __failure = 134; 11946 if (!PyErr_Occurred()) { 11947 PyErr_SetString(PyExc_RuntimeError, 11948 "Unexpected error in an Op's C code. " 11949 "No Python exception was set."); 11950 } 11951 goto __label_134;} 11952 } 11953 // This is a TypeError to be consistent with DEBUG_MODE 11954 // Note: DEBUG_MODE also tells the name of the container 11955 if (PyArray_TYPE((PyArrayObject*) py_V133) != NPY_FLOAT64) { 11956 PyErr_Format(PyExc_TypeError, 11957 "expected type_num %d (NPY_FLOAT64) got %d", 11958 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V133)); 11959 { 11960 __failure = 134; 11961 if (!PyErr_Occurred()) { 11962 PyErr_SetString(PyExc_RuntimeError, 11963 "Unexpected error in an Op's C code. " 11964 "No Python exception was set."); 11965 } 11966 goto __label_134;} 11967 } 11968 11969 V133 = (PyArrayObject*)(py_V133); 11970 Py_XINCREF(V133); 11971 11972 { 11973 11974 py_V135 = PyList_GET_ITEM(storage_V135, 0); 11975 {Py_XINCREF(py_V135);} 11976 11977 V135 = NULL; 11978 if (py_V135 == Py_None) { 11979 // We can either fail here or set V135 to NULL and rely on Ops 11980 // using tensors to handle the NULL case, but if they fail to do so 11981 // they'll end up with nasty segfaults, so this is public service. 11982 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 11983 { 11984 __failure = 136; 11985 if (!PyErr_Occurred()) { 11986 PyErr_SetString(PyExc_RuntimeError, 11987 "Unexpected error in an Op's C code. " 11988 "No Python exception was set."); 11989 } 11990 goto __label_136;} 11991 } 11992 if (!PyArray_Check(py_V135)) { 11993 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 11994 { 11995 __failure = 136; 11996 if (!PyErr_Occurred()) { 11997 PyErr_SetString(PyExc_RuntimeError, 11998 "Unexpected error in an Op's C code. " 11999 "No Python exception was set."); 12000 } 12001 goto __label_136;} 12002 } 12003 // We expect NPY_FLOAT64 12004 if (!PyArray_ISALIGNED((PyArrayObject*) py_V135)) { 12005 PyArrayObject * tmp = (PyArrayObject*) py_V135; 12006 PyErr_Format(PyExc_NotImplementedError, 12007 "expected an aligned array of type %ld " 12008 "(NPY_FLOAT64), got non-aligned array of type %ld" 12009 " with %ld dimensions, with 3 last dims " 12010 "%ld, %ld, %ld" 12011 " and 3 last strides %ld %ld, %ld.", 12012 (long int) NPY_FLOAT64, 12013 (long int) PyArray_TYPE((PyArrayObject*) py_V135), 12014 (long int) PyArray_NDIM(tmp), 12015 (long int) (PyArray_NDIM(tmp) >= 3 ? 12016 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 12017 (long int) (PyArray_NDIM(tmp) >= 2 ? 12018 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 12019 (long int) (PyArray_NDIM(tmp) >= 1 ? 12020 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 12021 (long int) (PyArray_NDIM(tmp) >= 3 ? 12022 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 12023 (long int) (PyArray_NDIM(tmp) >= 2 ? 12024 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 12025 (long int) (PyArray_NDIM(tmp) >= 1 ? 12026 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 12027 ); 12028 { 12029 __failure = 136; 12030 if (!PyErr_Occurred()) { 12031 PyErr_SetString(PyExc_RuntimeError, 12032 "Unexpected error in an Op's C code. " 12033 "No Python exception was set."); 12034 } 12035 goto __label_136;} 12036 } 12037 // This is a TypeError to be consistent with DEBUG_MODE 12038 // Note: DEBUG_MODE also tells the name of the container 12039 if (PyArray_TYPE((PyArrayObject*) py_V135) != NPY_FLOAT64) { 12040 PyErr_Format(PyExc_TypeError, 12041 "expected type_num %d (NPY_FLOAT64) got %d", 12042 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V135)); 12043 { 12044 __failure = 136; 12045 if (!PyErr_Occurred()) { 12046 PyErr_SetString(PyExc_RuntimeError, 12047 "Unexpected error in an Op's C code. " 12048 "No Python exception was set."); 12049 } 12050 goto __label_136;} 12051 } 12052 12053 V135 = (PyArrayObject*)(py_V135); 12054 Py_XINCREF(V135); 12055 12056 { 12057 12058 py_V137 = PyList_GET_ITEM(storage_V137, 0); 12059 {Py_XINCREF(py_V137);} 12060 12061 V137 = NULL; 12062 if (py_V137 == Py_None) { 12063 // We can either fail here or set V137 to NULL and rely on Ops 12064 // using tensors to handle the NULL case, but if they fail to do so 12065 // they'll end up with nasty segfaults, so this is public service. 12066 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 12067 { 12068 __failure = 138; 12069 if (!PyErr_Occurred()) { 12070 PyErr_SetString(PyExc_RuntimeError, 12071 "Unexpected error in an Op's C code. " 12072 "No Python exception was set."); 12073 } 12074 goto __label_138;} 12075 } 12076 if (!PyArray_Check(py_V137)) { 12077 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 12078 { 12079 __failure = 138; 12080 if (!PyErr_Occurred()) { 12081 PyErr_SetString(PyExc_RuntimeError, 12082 "Unexpected error in an Op's C code. " 12083 "No Python exception was set."); 12084 } 12085 goto __label_138;} 12086 } 12087 // We expect NPY_FLOAT64 12088 if (!PyArray_ISALIGNED((PyArrayObject*) py_V137)) { 12089 PyArrayObject * tmp = (PyArrayObject*) py_V137; 12090 PyErr_Format(PyExc_NotImplementedError, 12091 "expected an aligned array of type %ld " 12092 "(NPY_FLOAT64), got non-aligned array of type %ld" 12093 " with %ld dimensions, with 3 last dims " 12094 "%ld, %ld, %ld" 12095 " and 3 last strides %ld %ld, %ld.", 12096 (long int) NPY_FLOAT64, 12097 (long int) PyArray_TYPE((PyArrayObject*) py_V137), 12098 (long int) PyArray_NDIM(tmp), 12099 (long int) (PyArray_NDIM(tmp) >= 3 ? 12100 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 12101 (long int) (PyArray_NDIM(tmp) >= 2 ? 12102 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 12103 (long int) (PyArray_NDIM(tmp) >= 1 ? 12104 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 12105 (long int) (PyArray_NDIM(tmp) >= 3 ? 12106 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 12107 (long int) (PyArray_NDIM(tmp) >= 2 ? 12108 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 12109 (long int) (PyArray_NDIM(tmp) >= 1 ? 12110 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 12111 ); 12112 { 12113 __failure = 138; 12114 if (!PyErr_Occurred()) { 12115 PyErr_SetString(PyExc_RuntimeError, 12116 "Unexpected error in an Op's C code. " 12117 "No Python exception was set."); 12118 } 12119 goto __label_138;} 12120 } 12121 // This is a TypeError to be consistent with DEBUG_MODE 12122 // Note: DEBUG_MODE also tells the name of the container 12123 if (PyArray_TYPE((PyArrayObject*) py_V137) != NPY_FLOAT64) { 12124 PyErr_Format(PyExc_TypeError, 12125 "expected type_num %d (NPY_FLOAT64) got %d", 12126 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V137)); 12127 { 12128 __failure = 138; 12129 if (!PyErr_Occurred()) { 12130 PyErr_SetString(PyExc_RuntimeError, 12131 "Unexpected error in an Op's C code. " 12132 "No Python exception was set."); 12133 } 12134 goto __label_138;} 12135 } 12136 12137 V137 = (PyArrayObject*)(py_V137); 12138 Py_XINCREF(V137); 12139 12140 { 12141 12142 py_V139 = PyList_GET_ITEM(storage_V139, 0); 12143 {Py_XINCREF(py_V139);} 12144 12145 V139 = NULL; 12146 if (py_V139 == Py_None) { 12147 // We can either fail here or set V139 to NULL and rely on Ops 12148 // using tensors to handle the NULL case, but if they fail to do so 12149 // they'll end up with nasty segfaults, so this is public service. 12150 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 12151 { 12152 __failure = 140; 12153 if (!PyErr_Occurred()) { 12154 PyErr_SetString(PyExc_RuntimeError, 12155 "Unexpected error in an Op's C code. " 12156 "No Python exception was set."); 12157 } 12158 goto __label_140;} 12159 } 12160 if (!PyArray_Check(py_V139)) { 12161 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 12162 { 12163 __failure = 140; 12164 if (!PyErr_Occurred()) { 12165 PyErr_SetString(PyExc_RuntimeError, 12166 "Unexpected error in an Op's C code. " 12167 "No Python exception was set."); 12168 } 12169 goto __label_140;} 12170 } 12171 // We expect NPY_FLOAT64 12172 if (!PyArray_ISALIGNED((PyArrayObject*) py_V139)) { 12173 PyArrayObject * tmp = (PyArrayObject*) py_V139; 12174 PyErr_Format(PyExc_NotImplementedError, 12175 "expected an aligned array of type %ld " 12176 "(NPY_FLOAT64), got non-aligned array of type %ld" 12177 " with %ld dimensions, with 3 last dims " 12178 "%ld, %ld, %ld" 12179 " and 3 last strides %ld %ld, %ld.", 12180 (long int) NPY_FLOAT64, 12181 (long int) PyArray_TYPE((PyArrayObject*) py_V139), 12182 (long int) PyArray_NDIM(tmp), 12183 (long int) (PyArray_NDIM(tmp) >= 3 ? 12184 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 12185 (long int) (PyArray_NDIM(tmp) >= 2 ? 12186 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 12187 (long int) (PyArray_NDIM(tmp) >= 1 ? 12188 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 12189 (long int) (PyArray_NDIM(tmp) >= 3 ? 12190 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 12191 (long int) (PyArray_NDIM(tmp) >= 2 ? 12192 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 12193 (long int) (PyArray_NDIM(tmp) >= 1 ? 12194 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 12195 ); 12196 { 12197 __failure = 140; 12198 if (!PyErr_Occurred()) { 12199 PyErr_SetString(PyExc_RuntimeError, 12200 "Unexpected error in an Op's C code. " 12201 "No Python exception was set."); 12202 } 12203 goto __label_140;} 12204 } 12205 // This is a TypeError to be consistent with DEBUG_MODE 12206 // Note: DEBUG_MODE also tells the name of the container 12207 if (PyArray_TYPE((PyArrayObject*) py_V139) != NPY_FLOAT64) { 12208 PyErr_Format(PyExc_TypeError, 12209 "expected type_num %d (NPY_FLOAT64) got %d", 12210 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V139)); 12211 { 12212 __failure = 140; 12213 if (!PyErr_Occurred()) { 12214 PyErr_SetString(PyExc_RuntimeError, 12215 "Unexpected error in an Op's C code. " 12216 "No Python exception was set."); 12217 } 12218 goto __label_140;} 12219 } 12220 12221 V139 = (PyArrayObject*)(py_V139); 12222 Py_XINCREF(V139); 12223 12224 { 12225 12226 py_V141 = PyList_GET_ITEM(storage_V141, 0); 12227 {Py_XINCREF(py_V141);} 12228 12229 V141 = NULL; 12230 if (py_V141 == Py_None) { 12231 // We can either fail here or set V141 to NULL and rely on Ops 12232 // using tensors to handle the NULL case, but if they fail to do so 12233 // they'll end up with nasty segfaults, so this is public service. 12234 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 12235 { 12236 __failure = 142; 12237 if (!PyErr_Occurred()) { 12238 PyErr_SetString(PyExc_RuntimeError, 12239 "Unexpected error in an Op's C code. " 12240 "No Python exception was set."); 12241 } 12242 goto __label_142;} 12243 } 12244 if (!PyArray_Check(py_V141)) { 12245 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 12246 { 12247 __failure = 142; 12248 if (!PyErr_Occurred()) { 12249 PyErr_SetString(PyExc_RuntimeError, 12250 "Unexpected error in an Op's C code. " 12251 "No Python exception was set."); 12252 } 12253 goto __label_142;} 12254 } 12255 // We expect NPY_FLOAT64 12256 if (!PyArray_ISALIGNED((PyArrayObject*) py_V141)) { 12257 PyArrayObject * tmp = (PyArrayObject*) py_V141; 12258 PyErr_Format(PyExc_NotImplementedError, 12259 "expected an aligned array of type %ld " 12260 "(NPY_FLOAT64), got non-aligned array of type %ld" 12261 " with %ld dimensions, with 3 last dims " 12262 "%ld, %ld, %ld" 12263 " and 3 last strides %ld %ld, %ld.", 12264 (long int) NPY_FLOAT64, 12265 (long int) PyArray_TYPE((PyArrayObject*) py_V141), 12266 (long int) PyArray_NDIM(tmp), 12267 (long int) (PyArray_NDIM(tmp) >= 3 ? 12268 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 12269 (long int) (PyArray_NDIM(tmp) >= 2 ? 12270 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 12271 (long int) (PyArray_NDIM(tmp) >= 1 ? 12272 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 12273 (long int) (PyArray_NDIM(tmp) >= 3 ? 12274 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 12275 (long int) (PyArray_NDIM(tmp) >= 2 ? 12276 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 12277 (long int) (PyArray_NDIM(tmp) >= 1 ? 12278 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 12279 ); 12280 { 12281 __failure = 142; 12282 if (!PyErr_Occurred()) { 12283 PyErr_SetString(PyExc_RuntimeError, 12284 "Unexpected error in an Op's C code. " 12285 "No Python exception was set."); 12286 } 12287 goto __label_142;} 12288 } 12289 // This is a TypeError to be consistent with DEBUG_MODE 12290 // Note: DEBUG_MODE also tells the name of the container 12291 if (PyArray_TYPE((PyArrayObject*) py_V141) != NPY_FLOAT64) { 12292 PyErr_Format(PyExc_TypeError, 12293 "expected type_num %d (NPY_FLOAT64) got %d", 12294 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V141)); 12295 { 12296 __failure = 142; 12297 if (!PyErr_Occurred()) { 12298 PyErr_SetString(PyExc_RuntimeError, 12299 "Unexpected error in an Op's C code. " 12300 "No Python exception was set."); 12301 } 12302 goto __label_142;} 12303 } 12304 12305 V141 = (PyArrayObject*)(py_V141); 12306 Py_XINCREF(V141); 12307 12308 { 12309 12310 py_V143 = PyList_GET_ITEM(storage_V143, 0); 12311 {Py_XINCREF(py_V143);} 12312 12313 V143 = NULL; 12314 if (py_V143 == Py_None) { 12315 // We can either fail here or set V143 to NULL and rely on Ops 12316 // using tensors to handle the NULL case, but if they fail to do so 12317 // they'll end up with nasty segfaults, so this is public service. 12318 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 12319 { 12320 __failure = 144; 12321 if (!PyErr_Occurred()) { 12322 PyErr_SetString(PyExc_RuntimeError, 12323 "Unexpected error in an Op's C code. " 12324 "No Python exception was set."); 12325 } 12326 goto __label_144;} 12327 } 12328 if (!PyArray_Check(py_V143)) { 12329 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 12330 { 12331 __failure = 144; 12332 if (!PyErr_Occurred()) { 12333 PyErr_SetString(PyExc_RuntimeError, 12334 "Unexpected error in an Op's C code. " 12335 "No Python exception was set."); 12336 } 12337 goto __label_144;} 12338 } 12339 // We expect NPY_FLOAT64 12340 if (!PyArray_ISALIGNED((PyArrayObject*) py_V143)) { 12341 PyArrayObject * tmp = (PyArrayObject*) py_V143; 12342 PyErr_Format(PyExc_NotImplementedError, 12343 "expected an aligned array of type %ld " 12344 "(NPY_FLOAT64), got non-aligned array of type %ld" 12345 " with %ld dimensions, with 3 last dims " 12346 "%ld, %ld, %ld" 12347 " and 3 last strides %ld %ld, %ld.", 12348 (long int) NPY_FLOAT64, 12349 (long int) PyArray_TYPE((PyArrayObject*) py_V143), 12350 (long int) PyArray_NDIM(tmp), 12351 (long int) (PyArray_NDIM(tmp) >= 3 ? 12352 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 12353 (long int) (PyArray_NDIM(tmp) >= 2 ? 12354 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 12355 (long int) (PyArray_NDIM(tmp) >= 1 ? 12356 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 12357 (long int) (PyArray_NDIM(tmp) >= 3 ? 12358 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 12359 (long int) (PyArray_NDIM(tmp) >= 2 ? 12360 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 12361 (long int) (PyArray_NDIM(tmp) >= 1 ? 12362 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 12363 ); 12364 { 12365 __failure = 144; 12366 if (!PyErr_Occurred()) { 12367 PyErr_SetString(PyExc_RuntimeError, 12368 "Unexpected error in an Op's C code. " 12369 "No Python exception was set."); 12370 } 12371 goto __label_144;} 12372 } 12373 // This is a TypeError to be consistent with DEBUG_MODE 12374 // Note: DEBUG_MODE also tells the name of the container 12375 if (PyArray_TYPE((PyArrayObject*) py_V143) != NPY_FLOAT64) { 12376 PyErr_Format(PyExc_TypeError, 12377 "expected type_num %d (NPY_FLOAT64) got %d", 12378 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V143)); 12379 { 12380 __failure = 144; 12381 if (!PyErr_Occurred()) { 12382 PyErr_SetString(PyExc_RuntimeError, 12383 "Unexpected error in an Op's C code. " 12384 "No Python exception was set."); 12385 } 12386 goto __label_144;} 12387 } 12388 12389 V143 = (PyArrayObject*)(py_V143); 12390 Py_XINCREF(V143); 12391 12392 { 12393 12394 py_V145 = PyList_GET_ITEM(storage_V145, 0); 12395 {Py_XINCREF(py_V145);} 12396 12397 V145 = NULL; 12398 if (py_V145 == Py_None) { 12399 // We can either fail here or set V145 to NULL and rely on Ops 12400 // using tensors to handle the NULL case, but if they fail to do so 12401 // they'll end up with nasty segfaults, so this is public service. 12402 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 12403 { 12404 __failure = 146; 12405 if (!PyErr_Occurred()) { 12406 PyErr_SetString(PyExc_RuntimeError, 12407 "Unexpected error in an Op's C code. " 12408 "No Python exception was set."); 12409 } 12410 goto __label_146;} 12411 } 12412 if (!PyArray_Check(py_V145)) { 12413 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 12414 { 12415 __failure = 146; 12416 if (!PyErr_Occurred()) { 12417 PyErr_SetString(PyExc_RuntimeError, 12418 "Unexpected error in an Op's C code. " 12419 "No Python exception was set."); 12420 } 12421 goto __label_146;} 12422 } 12423 // We expect NPY_FLOAT64 12424 if (!PyArray_ISALIGNED((PyArrayObject*) py_V145)) { 12425 PyArrayObject * tmp = (PyArrayObject*) py_V145; 12426 PyErr_Format(PyExc_NotImplementedError, 12427 "expected an aligned array of type %ld " 12428 "(NPY_FLOAT64), got non-aligned array of type %ld" 12429 " with %ld dimensions, with 3 last dims " 12430 "%ld, %ld, %ld" 12431 " and 3 last strides %ld %ld, %ld.", 12432 (long int) NPY_FLOAT64, 12433 (long int) PyArray_TYPE((PyArrayObject*) py_V145), 12434 (long int) PyArray_NDIM(tmp), 12435 (long int) (PyArray_NDIM(tmp) >= 3 ? 12436 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 12437 (long int) (PyArray_NDIM(tmp) >= 2 ? 12438 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 12439 (long int) (PyArray_NDIM(tmp) >= 1 ? 12440 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 12441 (long int) (PyArray_NDIM(tmp) >= 3 ? 12442 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 12443 (long int) (PyArray_NDIM(tmp) >= 2 ? 12444 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 12445 (long int) (PyArray_NDIM(tmp) >= 1 ? 12446 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 12447 ); 12448 { 12449 __failure = 146; 12450 if (!PyErr_Occurred()) { 12451 PyErr_SetString(PyExc_RuntimeError, 12452 "Unexpected error in an Op's C code. " 12453 "No Python exception was set."); 12454 } 12455 goto __label_146;} 12456 } 12457 // This is a TypeError to be consistent with DEBUG_MODE 12458 // Note: DEBUG_MODE also tells the name of the container 12459 if (PyArray_TYPE((PyArrayObject*) py_V145) != NPY_FLOAT64) { 12460 PyErr_Format(PyExc_TypeError, 12461 "expected type_num %d (NPY_FLOAT64) got %d", 12462 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V145)); 12463 { 12464 __failure = 146; 12465 if (!PyErr_Occurred()) { 12466 PyErr_SetString(PyExc_RuntimeError, 12467 "Unexpected error in an Op's C code. " 12468 "No Python exception was set."); 12469 } 12470 goto __label_146;} 12471 } 12472 12473 V145 = (PyArrayObject*)(py_V145); 12474 Py_XINCREF(V145); 12475 12476 { 12477 12478 py_V147 = PyList_GET_ITEM(storage_V147, 0); 12479 {Py_XINCREF(py_V147);} 12480 12481 V147 = NULL; 12482 if (py_V147 == Py_None) { 12483 // We can either fail here or set V147 to NULL and rely on Ops 12484 // using tensors to handle the NULL case, but if they fail to do so 12485 // they'll end up with nasty segfaults, so this is public service. 12486 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 12487 { 12488 __failure = 148; 12489 if (!PyErr_Occurred()) { 12490 PyErr_SetString(PyExc_RuntimeError, 12491 "Unexpected error in an Op's C code. " 12492 "No Python exception was set."); 12493 } 12494 goto __label_148;} 12495 } 12496 if (!PyArray_Check(py_V147)) { 12497 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 12498 { 12499 __failure = 148; 12500 if (!PyErr_Occurred()) { 12501 PyErr_SetString(PyExc_RuntimeError, 12502 "Unexpected error in an Op's C code. " 12503 "No Python exception was set."); 12504 } 12505 goto __label_148;} 12506 } 12507 // We expect NPY_FLOAT64 12508 if (!PyArray_ISALIGNED((PyArrayObject*) py_V147)) { 12509 PyArrayObject * tmp = (PyArrayObject*) py_V147; 12510 PyErr_Format(PyExc_NotImplementedError, 12511 "expected an aligned array of type %ld " 12512 "(NPY_FLOAT64), got non-aligned array of type %ld" 12513 " with %ld dimensions, with 3 last dims " 12514 "%ld, %ld, %ld" 12515 " and 3 last strides %ld %ld, %ld.", 12516 (long int) NPY_FLOAT64, 12517 (long int) PyArray_TYPE((PyArrayObject*) py_V147), 12518 (long int) PyArray_NDIM(tmp), 12519 (long int) (PyArray_NDIM(tmp) >= 3 ? 12520 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 12521 (long int) (PyArray_NDIM(tmp) >= 2 ? 12522 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 12523 (long int) (PyArray_NDIM(tmp) >= 1 ? 12524 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 12525 (long int) (PyArray_NDIM(tmp) >= 3 ? 12526 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 12527 (long int) (PyArray_NDIM(tmp) >= 2 ? 12528 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 12529 (long int) (PyArray_NDIM(tmp) >= 1 ? 12530 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 12531 ); 12532 { 12533 __failure = 148; 12534 if (!PyErr_Occurred()) { 12535 PyErr_SetString(PyExc_RuntimeError, 12536 "Unexpected error in an Op's C code. " 12537 "No Python exception was set."); 12538 } 12539 goto __label_148;} 12540 } 12541 // This is a TypeError to be consistent with DEBUG_MODE 12542 // Note: DEBUG_MODE also tells the name of the container 12543 if (PyArray_TYPE((PyArrayObject*) py_V147) != NPY_FLOAT64) { 12544 PyErr_Format(PyExc_TypeError, 12545 "expected type_num %d (NPY_FLOAT64) got %d", 12546 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V147)); 12547 { 12548 __failure = 148; 12549 if (!PyErr_Occurred()) { 12550 PyErr_SetString(PyExc_RuntimeError, 12551 "Unexpected error in an Op's C code. " 12552 "No Python exception was set."); 12553 } 12554 goto __label_148;} 12555 } 12556 12557 V147 = (PyArrayObject*)(py_V147); 12558 Py_XINCREF(V147); 12559 12560 { 12561 12562 py_V149 = PyList_GET_ITEM(storage_V149, 0); 12563 {Py_XINCREF(py_V149);} 12564 12565 V149 = NULL; 12566 if (py_V149 == Py_None) { 12567 // We can either fail here or set V149 to NULL and rely on Ops 12568 // using tensors to handle the NULL case, but if they fail to do so 12569 // they'll end up with nasty segfaults, so this is public service. 12570 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 12571 { 12572 __failure = 150; 12573 if (!PyErr_Occurred()) { 12574 PyErr_SetString(PyExc_RuntimeError, 12575 "Unexpected error in an Op's C code. " 12576 "No Python exception was set."); 12577 } 12578 goto __label_150;} 12579 } 12580 if (!PyArray_Check(py_V149)) { 12581 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 12582 { 12583 __failure = 150; 12584 if (!PyErr_Occurred()) { 12585 PyErr_SetString(PyExc_RuntimeError, 12586 "Unexpected error in an Op's C code. " 12587 "No Python exception was set."); 12588 } 12589 goto __label_150;} 12590 } 12591 // We expect NPY_FLOAT64 12592 if (!PyArray_ISALIGNED((PyArrayObject*) py_V149)) { 12593 PyArrayObject * tmp = (PyArrayObject*) py_V149; 12594 PyErr_Format(PyExc_NotImplementedError, 12595 "expected an aligned array of type %ld " 12596 "(NPY_FLOAT64), got non-aligned array of type %ld" 12597 " with %ld dimensions, with 3 last dims " 12598 "%ld, %ld, %ld" 12599 " and 3 last strides %ld %ld, %ld.", 12600 (long int) NPY_FLOAT64, 12601 (long int) PyArray_TYPE((PyArrayObject*) py_V149), 12602 (long int) PyArray_NDIM(tmp), 12603 (long int) (PyArray_NDIM(tmp) >= 3 ? 12604 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 12605 (long int) (PyArray_NDIM(tmp) >= 2 ? 12606 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 12607 (long int) (PyArray_NDIM(tmp) >= 1 ? 12608 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 12609 (long int) (PyArray_NDIM(tmp) >= 3 ? 12610 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 12611 (long int) (PyArray_NDIM(tmp) >= 2 ? 12612 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 12613 (long int) (PyArray_NDIM(tmp) >= 1 ? 12614 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 12615 ); 12616 { 12617 __failure = 150; 12618 if (!PyErr_Occurred()) { 12619 PyErr_SetString(PyExc_RuntimeError, 12620 "Unexpected error in an Op's C code. " 12621 "No Python exception was set."); 12622 } 12623 goto __label_150;} 12624 } 12625 // This is a TypeError to be consistent with DEBUG_MODE 12626 // Note: DEBUG_MODE also tells the name of the container 12627 if (PyArray_TYPE((PyArrayObject*) py_V149) != NPY_FLOAT64) { 12628 PyErr_Format(PyExc_TypeError, 12629 "expected type_num %d (NPY_FLOAT64) got %d", 12630 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V149)); 12631 { 12632 __failure = 150; 12633 if (!PyErr_Occurred()) { 12634 PyErr_SetString(PyExc_RuntimeError, 12635 "Unexpected error in an Op's C code. " 12636 "No Python exception was set."); 12637 } 12638 goto __label_150;} 12639 } 12640 12641 V149 = (PyArrayObject*)(py_V149); 12642 Py_XINCREF(V149); 12643 12644 { 12645 12646 py_V151 = PyList_GET_ITEM(storage_V151, 0); 12647 {Py_XINCREF(py_V151);} 12648 12649 V151 = NULL; 12650 if (py_V151 == Py_None) { 12651 // We can either fail here or set V151 to NULL and rely on Ops 12652 // using tensors to handle the NULL case, but if they fail to do so 12653 // they'll end up with nasty segfaults, so this is public service. 12654 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 12655 { 12656 __failure = 152; 12657 if (!PyErr_Occurred()) { 12658 PyErr_SetString(PyExc_RuntimeError, 12659 "Unexpected error in an Op's C code. " 12660 "No Python exception was set."); 12661 } 12662 goto __label_152;} 12663 } 12664 if (!PyArray_Check(py_V151)) { 12665 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 12666 { 12667 __failure = 152; 12668 if (!PyErr_Occurred()) { 12669 PyErr_SetString(PyExc_RuntimeError, 12670 "Unexpected error in an Op's C code. " 12671 "No Python exception was set."); 12672 } 12673 goto __label_152;} 12674 } 12675 // We expect NPY_FLOAT64 12676 if (!PyArray_ISALIGNED((PyArrayObject*) py_V151)) { 12677 PyArrayObject * tmp = (PyArrayObject*) py_V151; 12678 PyErr_Format(PyExc_NotImplementedError, 12679 "expected an aligned array of type %ld " 12680 "(NPY_FLOAT64), got non-aligned array of type %ld" 12681 " with %ld dimensions, with 3 last dims " 12682 "%ld, %ld, %ld" 12683 " and 3 last strides %ld %ld, %ld.", 12684 (long int) NPY_FLOAT64, 12685 (long int) PyArray_TYPE((PyArrayObject*) py_V151), 12686 (long int) PyArray_NDIM(tmp), 12687 (long int) (PyArray_NDIM(tmp) >= 3 ? 12688 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 12689 (long int) (PyArray_NDIM(tmp) >= 2 ? 12690 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 12691 (long int) (PyArray_NDIM(tmp) >= 1 ? 12692 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 12693 (long int) (PyArray_NDIM(tmp) >= 3 ? 12694 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 12695 (long int) (PyArray_NDIM(tmp) >= 2 ? 12696 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 12697 (long int) (PyArray_NDIM(tmp) >= 1 ? 12698 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 12699 ); 12700 { 12701 __failure = 152; 12702 if (!PyErr_Occurred()) { 12703 PyErr_SetString(PyExc_RuntimeError, 12704 "Unexpected error in an Op's C code. " 12705 "No Python exception was set."); 12706 } 12707 goto __label_152;} 12708 } 12709 // This is a TypeError to be consistent with DEBUG_MODE 12710 // Note: DEBUG_MODE also tells the name of the container 12711 if (PyArray_TYPE((PyArrayObject*) py_V151) != NPY_FLOAT64) { 12712 PyErr_Format(PyExc_TypeError, 12713 "expected type_num %d (NPY_FLOAT64) got %d", 12714 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V151)); 12715 { 12716 __failure = 152; 12717 if (!PyErr_Occurred()) { 12718 PyErr_SetString(PyExc_RuntimeError, 12719 "Unexpected error in an Op's C code. " 12720 "No Python exception was set."); 12721 } 12722 goto __label_152;} 12723 } 12724 12725 V151 = (PyArrayObject*)(py_V151); 12726 Py_XINCREF(V151); 12727 12728 { 12729 12730 py_V153 = PyList_GET_ITEM(storage_V153, 0); 12731 {Py_XINCREF(py_V153);} 12732 12733 V153 = NULL; 12734 if (py_V153 == Py_None) { 12735 // We can either fail here or set V153 to NULL and rely on Ops 12736 // using tensors to handle the NULL case, but if they fail to do so 12737 // they'll end up with nasty segfaults, so this is public service. 12738 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 12739 { 12740 __failure = 154; 12741 if (!PyErr_Occurred()) { 12742 PyErr_SetString(PyExc_RuntimeError, 12743 "Unexpected error in an Op's C code. " 12744 "No Python exception was set."); 12745 } 12746 goto __label_154;} 12747 } 12748 if (!PyArray_Check(py_V153)) { 12749 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 12750 { 12751 __failure = 154; 12752 if (!PyErr_Occurred()) { 12753 PyErr_SetString(PyExc_RuntimeError, 12754 "Unexpected error in an Op's C code. " 12755 "No Python exception was set."); 12756 } 12757 goto __label_154;} 12758 } 12759 // We expect NPY_FLOAT64 12760 if (!PyArray_ISALIGNED((PyArrayObject*) py_V153)) { 12761 PyArrayObject * tmp = (PyArrayObject*) py_V153; 12762 PyErr_Format(PyExc_NotImplementedError, 12763 "expected an aligned array of type %ld " 12764 "(NPY_FLOAT64), got non-aligned array of type %ld" 12765 " with %ld dimensions, with 3 last dims " 12766 "%ld, %ld, %ld" 12767 " and 3 last strides %ld %ld, %ld.", 12768 (long int) NPY_FLOAT64, 12769 (long int) PyArray_TYPE((PyArrayObject*) py_V153), 12770 (long int) PyArray_NDIM(tmp), 12771 (long int) (PyArray_NDIM(tmp) >= 3 ? 12772 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 12773 (long int) (PyArray_NDIM(tmp) >= 2 ? 12774 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 12775 (long int) (PyArray_NDIM(tmp) >= 1 ? 12776 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 12777 (long int) (PyArray_NDIM(tmp) >= 3 ? 12778 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 12779 (long int) (PyArray_NDIM(tmp) >= 2 ? 12780 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 12781 (long int) (PyArray_NDIM(tmp) >= 1 ? 12782 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 12783 ); 12784 { 12785 __failure = 154; 12786 if (!PyErr_Occurred()) { 12787 PyErr_SetString(PyExc_RuntimeError, 12788 "Unexpected error in an Op's C code. " 12789 "No Python exception was set."); 12790 } 12791 goto __label_154;} 12792 } 12793 // This is a TypeError to be consistent with DEBUG_MODE 12794 // Note: DEBUG_MODE also tells the name of the container 12795 if (PyArray_TYPE((PyArrayObject*) py_V153) != NPY_FLOAT64) { 12796 PyErr_Format(PyExc_TypeError, 12797 "expected type_num %d (NPY_FLOAT64) got %d", 12798 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V153)); 12799 { 12800 __failure = 154; 12801 if (!PyErr_Occurred()) { 12802 PyErr_SetString(PyExc_RuntimeError, 12803 "Unexpected error in an Op's C code. " 12804 "No Python exception was set."); 12805 } 12806 goto __label_154;} 12807 } 12808 12809 V153 = (PyArrayObject*)(py_V153); 12810 Py_XINCREF(V153); 12811 12812 { 12813 12814 py_V155 = PyList_GET_ITEM(storage_V155, 0); 12815 {Py_XINCREF(py_V155);} 12816 12817 V155 = NULL; 12818 if (py_V155 == Py_None) { 12819 // We can either fail here or set V155 to NULL and rely on Ops 12820 // using tensors to handle the NULL case, but if they fail to do so 12821 // they'll end up with nasty segfaults, so this is public service. 12822 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 12823 { 12824 __failure = 156; 12825 if (!PyErr_Occurred()) { 12826 PyErr_SetString(PyExc_RuntimeError, 12827 "Unexpected error in an Op's C code. " 12828 "No Python exception was set."); 12829 } 12830 goto __label_156;} 12831 } 12832 if (!PyArray_Check(py_V155)) { 12833 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 12834 { 12835 __failure = 156; 12836 if (!PyErr_Occurred()) { 12837 PyErr_SetString(PyExc_RuntimeError, 12838 "Unexpected error in an Op's C code. " 12839 "No Python exception was set."); 12840 } 12841 goto __label_156;} 12842 } 12843 // We expect NPY_FLOAT64 12844 if (!PyArray_ISALIGNED((PyArrayObject*) py_V155)) { 12845 PyArrayObject * tmp = (PyArrayObject*) py_V155; 12846 PyErr_Format(PyExc_NotImplementedError, 12847 "expected an aligned array of type %ld " 12848 "(NPY_FLOAT64), got non-aligned array of type %ld" 12849 " with %ld dimensions, with 3 last dims " 12850 "%ld, %ld, %ld" 12851 " and 3 last strides %ld %ld, %ld.", 12852 (long int) NPY_FLOAT64, 12853 (long int) PyArray_TYPE((PyArrayObject*) py_V155), 12854 (long int) PyArray_NDIM(tmp), 12855 (long int) (PyArray_NDIM(tmp) >= 3 ? 12856 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 12857 (long int) (PyArray_NDIM(tmp) >= 2 ? 12858 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 12859 (long int) (PyArray_NDIM(tmp) >= 1 ? 12860 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 12861 (long int) (PyArray_NDIM(tmp) >= 3 ? 12862 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 12863 (long int) (PyArray_NDIM(tmp) >= 2 ? 12864 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 12865 (long int) (PyArray_NDIM(tmp) >= 1 ? 12866 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 12867 ); 12868 { 12869 __failure = 156; 12870 if (!PyErr_Occurred()) { 12871 PyErr_SetString(PyExc_RuntimeError, 12872 "Unexpected error in an Op's C code. " 12873 "No Python exception was set."); 12874 } 12875 goto __label_156;} 12876 } 12877 // This is a TypeError to be consistent with DEBUG_MODE 12878 // Note: DEBUG_MODE also tells the name of the container 12879 if (PyArray_TYPE((PyArrayObject*) py_V155) != NPY_FLOAT64) { 12880 PyErr_Format(PyExc_TypeError, 12881 "expected type_num %d (NPY_FLOAT64) got %d", 12882 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V155)); 12883 { 12884 __failure = 156; 12885 if (!PyErr_Occurred()) { 12886 PyErr_SetString(PyExc_RuntimeError, 12887 "Unexpected error in an Op's C code. " 12888 "No Python exception was set."); 12889 } 12890 goto __label_156;} 12891 } 12892 12893 V155 = (PyArrayObject*)(py_V155); 12894 Py_XINCREF(V155); 12895 12896 { 12897 12898 py_V157 = PyList_GET_ITEM(storage_V157, 0); 12899 {Py_XINCREF(py_V157);} 12900 12901 V157 = NULL; 12902 if (py_V157 == Py_None) { 12903 // We can either fail here or set V157 to NULL and rely on Ops 12904 // using tensors to handle the NULL case, but if they fail to do so 12905 // they'll end up with nasty segfaults, so this is public service. 12906 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 12907 { 12908 __failure = 158; 12909 if (!PyErr_Occurred()) { 12910 PyErr_SetString(PyExc_RuntimeError, 12911 "Unexpected error in an Op's C code. " 12912 "No Python exception was set."); 12913 } 12914 goto __label_158;} 12915 } 12916 if (!PyArray_Check(py_V157)) { 12917 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 12918 { 12919 __failure = 158; 12920 if (!PyErr_Occurred()) { 12921 PyErr_SetString(PyExc_RuntimeError, 12922 "Unexpected error in an Op's C code. " 12923 "No Python exception was set."); 12924 } 12925 goto __label_158;} 12926 } 12927 // We expect NPY_FLOAT64 12928 if (!PyArray_ISALIGNED((PyArrayObject*) py_V157)) { 12929 PyArrayObject * tmp = (PyArrayObject*) py_V157; 12930 PyErr_Format(PyExc_NotImplementedError, 12931 "expected an aligned array of type %ld " 12932 "(NPY_FLOAT64), got non-aligned array of type %ld" 12933 " with %ld dimensions, with 3 last dims " 12934 "%ld, %ld, %ld" 12935 " and 3 last strides %ld %ld, %ld.", 12936 (long int) NPY_FLOAT64, 12937 (long int) PyArray_TYPE((PyArrayObject*) py_V157), 12938 (long int) PyArray_NDIM(tmp), 12939 (long int) (PyArray_NDIM(tmp) >= 3 ? 12940 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 12941 (long int) (PyArray_NDIM(tmp) >= 2 ? 12942 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 12943 (long int) (PyArray_NDIM(tmp) >= 1 ? 12944 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 12945 (long int) (PyArray_NDIM(tmp) >= 3 ? 12946 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 12947 (long int) (PyArray_NDIM(tmp) >= 2 ? 12948 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 12949 (long int) (PyArray_NDIM(tmp) >= 1 ? 12950 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 12951 ); 12952 { 12953 __failure = 158; 12954 if (!PyErr_Occurred()) { 12955 PyErr_SetString(PyExc_RuntimeError, 12956 "Unexpected error in an Op's C code. " 12957 "No Python exception was set."); 12958 } 12959 goto __label_158;} 12960 } 12961 // This is a TypeError to be consistent with DEBUG_MODE 12962 // Note: DEBUG_MODE also tells the name of the container 12963 if (PyArray_TYPE((PyArrayObject*) py_V157) != NPY_FLOAT64) { 12964 PyErr_Format(PyExc_TypeError, 12965 "expected type_num %d (NPY_FLOAT64) got %d", 12966 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V157)); 12967 { 12968 __failure = 158; 12969 if (!PyErr_Occurred()) { 12970 PyErr_SetString(PyExc_RuntimeError, 12971 "Unexpected error in an Op's C code. " 12972 "No Python exception was set."); 12973 } 12974 goto __label_158;} 12975 } 12976 12977 V157 = (PyArrayObject*)(py_V157); 12978 Py_XINCREF(V157); 12979 12980 { 12981 12982 py_V159 = PyList_GET_ITEM(storage_V159, 0); 12983 {Py_XINCREF(py_V159);} 12984 12985 V159 = NULL; 12986 if (py_V159 == Py_None) { 12987 // We can either fail here or set V159 to NULL and rely on Ops 12988 // using tensors to handle the NULL case, but if they fail to do so 12989 // they'll end up with nasty segfaults, so this is public service. 12990 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 12991 { 12992 __failure = 160; 12993 if (!PyErr_Occurred()) { 12994 PyErr_SetString(PyExc_RuntimeError, 12995 "Unexpected error in an Op's C code. " 12996 "No Python exception was set."); 12997 } 12998 goto __label_160;} 12999 } 13000 if (!PyArray_Check(py_V159)) { 13001 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 13002 { 13003 __failure = 160; 13004 if (!PyErr_Occurred()) { 13005 PyErr_SetString(PyExc_RuntimeError, 13006 "Unexpected error in an Op's C code. " 13007 "No Python exception was set."); 13008 } 13009 goto __label_160;} 13010 } 13011 // We expect NPY_FLOAT64 13012 if (!PyArray_ISALIGNED((PyArrayObject*) py_V159)) { 13013 PyArrayObject * tmp = (PyArrayObject*) py_V159; 13014 PyErr_Format(PyExc_NotImplementedError, 13015 "expected an aligned array of type %ld " 13016 "(NPY_FLOAT64), got non-aligned array of type %ld" 13017 " with %ld dimensions, with 3 last dims " 13018 "%ld, %ld, %ld" 13019 " and 3 last strides %ld %ld, %ld.", 13020 (long int) NPY_FLOAT64, 13021 (long int) PyArray_TYPE((PyArrayObject*) py_V159), 13022 (long int) PyArray_NDIM(tmp), 13023 (long int) (PyArray_NDIM(tmp) >= 3 ? 13024 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 13025 (long int) (PyArray_NDIM(tmp) >= 2 ? 13026 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 13027 (long int) (PyArray_NDIM(tmp) >= 1 ? 13028 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 13029 (long int) (PyArray_NDIM(tmp) >= 3 ? 13030 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 13031 (long int) (PyArray_NDIM(tmp) >= 2 ? 13032 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 13033 (long int) (PyArray_NDIM(tmp) >= 1 ? 13034 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 13035 ); 13036 { 13037 __failure = 160; 13038 if (!PyErr_Occurred()) { 13039 PyErr_SetString(PyExc_RuntimeError, 13040 "Unexpected error in an Op's C code. " 13041 "No Python exception was set."); 13042 } 13043 goto __label_160;} 13044 } 13045 // This is a TypeError to be consistent with DEBUG_MODE 13046 // Note: DEBUG_MODE also tells the name of the container 13047 if (PyArray_TYPE((PyArrayObject*) py_V159) != NPY_FLOAT64) { 13048 PyErr_Format(PyExc_TypeError, 13049 "expected type_num %d (NPY_FLOAT64) got %d", 13050 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V159)); 13051 { 13052 __failure = 160; 13053 if (!PyErr_Occurred()) { 13054 PyErr_SetString(PyExc_RuntimeError, 13055 "Unexpected error in an Op's C code. " 13056 "No Python exception was set."); 13057 } 13058 goto __label_160;} 13059 } 13060 13061 V159 = (PyArrayObject*)(py_V159); 13062 Py_XINCREF(V159); 13063 13064 { 13065 13066 py_V161 = PyList_GET_ITEM(storage_V161, 0); 13067 {Py_XINCREF(py_V161);} 13068 13069 V161 = NULL; 13070 if (py_V161 == Py_None) { 13071 // We can either fail here or set V161 to NULL and rely on Ops 13072 // using tensors to handle the NULL case, but if they fail to do so 13073 // they'll end up with nasty segfaults, so this is public service. 13074 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 13075 { 13076 __failure = 162; 13077 if (!PyErr_Occurred()) { 13078 PyErr_SetString(PyExc_RuntimeError, 13079 "Unexpected error in an Op's C code. " 13080 "No Python exception was set."); 13081 } 13082 goto __label_162;} 13083 } 13084 if (!PyArray_Check(py_V161)) { 13085 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 13086 { 13087 __failure = 162; 13088 if (!PyErr_Occurred()) { 13089 PyErr_SetString(PyExc_RuntimeError, 13090 "Unexpected error in an Op's C code. " 13091 "No Python exception was set."); 13092 } 13093 goto __label_162;} 13094 } 13095 // We expect NPY_FLOAT64 13096 if (!PyArray_ISALIGNED((PyArrayObject*) py_V161)) { 13097 PyArrayObject * tmp = (PyArrayObject*) py_V161; 13098 PyErr_Format(PyExc_NotImplementedError, 13099 "expected an aligned array of type %ld " 13100 "(NPY_FLOAT64), got non-aligned array of type %ld" 13101 " with %ld dimensions, with 3 last dims " 13102 "%ld, %ld, %ld" 13103 " and 3 last strides %ld %ld, %ld.", 13104 (long int) NPY_FLOAT64, 13105 (long int) PyArray_TYPE((PyArrayObject*) py_V161), 13106 (long int) PyArray_NDIM(tmp), 13107 (long int) (PyArray_NDIM(tmp) >= 3 ? 13108 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 13109 (long int) (PyArray_NDIM(tmp) >= 2 ? 13110 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 13111 (long int) (PyArray_NDIM(tmp) >= 1 ? 13112 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 13113 (long int) (PyArray_NDIM(tmp) >= 3 ? 13114 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 13115 (long int) (PyArray_NDIM(tmp) >= 2 ? 13116 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 13117 (long int) (PyArray_NDIM(tmp) >= 1 ? 13118 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 13119 ); 13120 { 13121 __failure = 162; 13122 if (!PyErr_Occurred()) { 13123 PyErr_SetString(PyExc_RuntimeError, 13124 "Unexpected error in an Op's C code. " 13125 "No Python exception was set."); 13126 } 13127 goto __label_162;} 13128 } 13129 // This is a TypeError to be consistent with DEBUG_MODE 13130 // Note: DEBUG_MODE also tells the name of the container 13131 if (PyArray_TYPE((PyArrayObject*) py_V161) != NPY_FLOAT64) { 13132 PyErr_Format(PyExc_TypeError, 13133 "expected type_num %d (NPY_FLOAT64) got %d", 13134 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V161)); 13135 { 13136 __failure = 162; 13137 if (!PyErr_Occurred()) { 13138 PyErr_SetString(PyExc_RuntimeError, 13139 "Unexpected error in an Op's C code. " 13140 "No Python exception was set."); 13141 } 13142 goto __label_162;} 13143 } 13144 13145 V161 = (PyArrayObject*)(py_V161); 13146 Py_XINCREF(V161); 13147 13148 { 13149 13150 py_V163 = PyList_GET_ITEM(storage_V163, 0); 13151 {Py_XINCREF(py_V163);} 13152 13153 V163 = NULL; 13154 if (py_V163 == Py_None) { 13155 // We can either fail here or set V163 to NULL and rely on Ops 13156 // using tensors to handle the NULL case, but if they fail to do so 13157 // they'll end up with nasty segfaults, so this is public service. 13158 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 13159 { 13160 __failure = 164; 13161 if (!PyErr_Occurred()) { 13162 PyErr_SetString(PyExc_RuntimeError, 13163 "Unexpected error in an Op's C code. " 13164 "No Python exception was set."); 13165 } 13166 goto __label_164;} 13167 } 13168 if (!PyArray_Check(py_V163)) { 13169 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 13170 { 13171 __failure = 164; 13172 if (!PyErr_Occurred()) { 13173 PyErr_SetString(PyExc_RuntimeError, 13174 "Unexpected error in an Op's C code. " 13175 "No Python exception was set."); 13176 } 13177 goto __label_164;} 13178 } 13179 // We expect NPY_FLOAT64 13180 if (!PyArray_ISALIGNED((PyArrayObject*) py_V163)) { 13181 PyArrayObject * tmp = (PyArrayObject*) py_V163; 13182 PyErr_Format(PyExc_NotImplementedError, 13183 "expected an aligned array of type %ld " 13184 "(NPY_FLOAT64), got non-aligned array of type %ld" 13185 " with %ld dimensions, with 3 last dims " 13186 "%ld, %ld, %ld" 13187 " and 3 last strides %ld %ld, %ld.", 13188 (long int) NPY_FLOAT64, 13189 (long int) PyArray_TYPE((PyArrayObject*) py_V163), 13190 (long int) PyArray_NDIM(tmp), 13191 (long int) (PyArray_NDIM(tmp) >= 3 ? 13192 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 13193 (long int) (PyArray_NDIM(tmp) >= 2 ? 13194 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 13195 (long int) (PyArray_NDIM(tmp) >= 1 ? 13196 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 13197 (long int) (PyArray_NDIM(tmp) >= 3 ? 13198 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 13199 (long int) (PyArray_NDIM(tmp) >= 2 ? 13200 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 13201 (long int) (PyArray_NDIM(tmp) >= 1 ? 13202 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 13203 ); 13204 { 13205 __failure = 164; 13206 if (!PyErr_Occurred()) { 13207 PyErr_SetString(PyExc_RuntimeError, 13208 "Unexpected error in an Op's C code. " 13209 "No Python exception was set."); 13210 } 13211 goto __label_164;} 13212 } 13213 // This is a TypeError to be consistent with DEBUG_MODE 13214 // Note: DEBUG_MODE also tells the name of the container 13215 if (PyArray_TYPE((PyArrayObject*) py_V163) != NPY_FLOAT64) { 13216 PyErr_Format(PyExc_TypeError, 13217 "expected type_num %d (NPY_FLOAT64) got %d", 13218 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V163)); 13219 { 13220 __failure = 164; 13221 if (!PyErr_Occurred()) { 13222 PyErr_SetString(PyExc_RuntimeError, 13223 "Unexpected error in an Op's C code. " 13224 "No Python exception was set."); 13225 } 13226 goto __label_164;} 13227 } 13228 13229 V163 = (PyArrayObject*)(py_V163); 13230 Py_XINCREF(V163); 13231 13232 { 13233 13234 py_V165 = PyList_GET_ITEM(storage_V165, 0); 13235 {Py_XINCREF(py_V165);} 13236 13237 V165 = NULL; 13238 if (py_V165 == Py_None) { 13239 // We can either fail here or set V165 to NULL and rely on Ops 13240 // using tensors to handle the NULL case, but if they fail to do so 13241 // they'll end up with nasty segfaults, so this is public service. 13242 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 13243 { 13244 __failure = 166; 13245 if (!PyErr_Occurred()) { 13246 PyErr_SetString(PyExc_RuntimeError, 13247 "Unexpected error in an Op's C code. " 13248 "No Python exception was set."); 13249 } 13250 goto __label_166;} 13251 } 13252 if (!PyArray_Check(py_V165)) { 13253 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 13254 { 13255 __failure = 166; 13256 if (!PyErr_Occurred()) { 13257 PyErr_SetString(PyExc_RuntimeError, 13258 "Unexpected error in an Op's C code. " 13259 "No Python exception was set."); 13260 } 13261 goto __label_166;} 13262 } 13263 // We expect NPY_FLOAT64 13264 if (!PyArray_ISALIGNED((PyArrayObject*) py_V165)) { 13265 PyArrayObject * tmp = (PyArrayObject*) py_V165; 13266 PyErr_Format(PyExc_NotImplementedError, 13267 "expected an aligned array of type %ld " 13268 "(NPY_FLOAT64), got non-aligned array of type %ld" 13269 " with %ld dimensions, with 3 last dims " 13270 "%ld, %ld, %ld" 13271 " and 3 last strides %ld %ld, %ld.", 13272 (long int) NPY_FLOAT64, 13273 (long int) PyArray_TYPE((PyArrayObject*) py_V165), 13274 (long int) PyArray_NDIM(tmp), 13275 (long int) (PyArray_NDIM(tmp) >= 3 ? 13276 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 13277 (long int) (PyArray_NDIM(tmp) >= 2 ? 13278 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 13279 (long int) (PyArray_NDIM(tmp) >= 1 ? 13280 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 13281 (long int) (PyArray_NDIM(tmp) >= 3 ? 13282 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 13283 (long int) (PyArray_NDIM(tmp) >= 2 ? 13284 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 13285 (long int) (PyArray_NDIM(tmp) >= 1 ? 13286 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 13287 ); 13288 { 13289 __failure = 166; 13290 if (!PyErr_Occurred()) { 13291 PyErr_SetString(PyExc_RuntimeError, 13292 "Unexpected error in an Op's C code. " 13293 "No Python exception was set."); 13294 } 13295 goto __label_166;} 13296 } 13297 // This is a TypeError to be consistent with DEBUG_MODE 13298 // Note: DEBUG_MODE also tells the name of the container 13299 if (PyArray_TYPE((PyArrayObject*) py_V165) != NPY_FLOAT64) { 13300 PyErr_Format(PyExc_TypeError, 13301 "expected type_num %d (NPY_FLOAT64) got %d", 13302 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V165)); 13303 { 13304 __failure = 166; 13305 if (!PyErr_Occurred()) { 13306 PyErr_SetString(PyExc_RuntimeError, 13307 "Unexpected error in an Op's C code. " 13308 "No Python exception was set."); 13309 } 13310 goto __label_166;} 13311 } 13312 13313 V165 = (PyArrayObject*)(py_V165); 13314 Py_XINCREF(V165); 13315 13316 { 13317 13318 py_V167 = PyList_GET_ITEM(storage_V167, 0); 13319 {Py_XINCREF(py_V167);} 13320 13321 V167 = NULL; 13322 if (py_V167 == Py_None) { 13323 // We can either fail here or set V167 to NULL and rely on Ops 13324 // using tensors to handle the NULL case, but if they fail to do so 13325 // they'll end up with nasty segfaults, so this is public service. 13326 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 13327 { 13328 __failure = 168; 13329 if (!PyErr_Occurred()) { 13330 PyErr_SetString(PyExc_RuntimeError, 13331 "Unexpected error in an Op's C code. " 13332 "No Python exception was set."); 13333 } 13334 goto __label_168;} 13335 } 13336 if (!PyArray_Check(py_V167)) { 13337 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 13338 { 13339 __failure = 168; 13340 if (!PyErr_Occurred()) { 13341 PyErr_SetString(PyExc_RuntimeError, 13342 "Unexpected error in an Op's C code. " 13343 "No Python exception was set."); 13344 } 13345 goto __label_168;} 13346 } 13347 // We expect NPY_FLOAT64 13348 if (!PyArray_ISALIGNED((PyArrayObject*) py_V167)) { 13349 PyArrayObject * tmp = (PyArrayObject*) py_V167; 13350 PyErr_Format(PyExc_NotImplementedError, 13351 "expected an aligned array of type %ld " 13352 "(NPY_FLOAT64), got non-aligned array of type %ld" 13353 " with %ld dimensions, with 3 last dims " 13354 "%ld, %ld, %ld" 13355 " and 3 last strides %ld %ld, %ld.", 13356 (long int) NPY_FLOAT64, 13357 (long int) PyArray_TYPE((PyArrayObject*) py_V167), 13358 (long int) PyArray_NDIM(tmp), 13359 (long int) (PyArray_NDIM(tmp) >= 3 ? 13360 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 13361 (long int) (PyArray_NDIM(tmp) >= 2 ? 13362 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 13363 (long int) (PyArray_NDIM(tmp) >= 1 ? 13364 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 13365 (long int) (PyArray_NDIM(tmp) >= 3 ? 13366 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 13367 (long int) (PyArray_NDIM(tmp) >= 2 ? 13368 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 13369 (long int) (PyArray_NDIM(tmp) >= 1 ? 13370 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 13371 ); 13372 { 13373 __failure = 168; 13374 if (!PyErr_Occurred()) { 13375 PyErr_SetString(PyExc_RuntimeError, 13376 "Unexpected error in an Op's C code. " 13377 "No Python exception was set."); 13378 } 13379 goto __label_168;} 13380 } 13381 // This is a TypeError to be consistent with DEBUG_MODE 13382 // Note: DEBUG_MODE also tells the name of the container 13383 if (PyArray_TYPE((PyArrayObject*) py_V167) != NPY_FLOAT64) { 13384 PyErr_Format(PyExc_TypeError, 13385 "expected type_num %d (NPY_FLOAT64) got %d", 13386 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V167)); 13387 { 13388 __failure = 168; 13389 if (!PyErr_Occurred()) { 13390 PyErr_SetString(PyExc_RuntimeError, 13391 "Unexpected error in an Op's C code. " 13392 "No Python exception was set."); 13393 } 13394 goto __label_168;} 13395 } 13396 13397 V167 = (PyArrayObject*)(py_V167); 13398 Py_XINCREF(V167); 13399 13400 { 13401 13402 py_V169 = PyList_GET_ITEM(storage_V169, 0); 13403 {Py_XINCREF(py_V169);} 13404 13405 V169 = NULL; 13406 if (py_V169 == Py_None) { 13407 // We can either fail here or set V169 to NULL and rely on Ops 13408 // using tensors to handle the NULL case, but if they fail to do so 13409 // they'll end up with nasty segfaults, so this is public service. 13410 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 13411 { 13412 __failure = 170; 13413 if (!PyErr_Occurred()) { 13414 PyErr_SetString(PyExc_RuntimeError, 13415 "Unexpected error in an Op's C code. " 13416 "No Python exception was set."); 13417 } 13418 goto __label_170;} 13419 } 13420 if (!PyArray_Check(py_V169)) { 13421 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 13422 { 13423 __failure = 170; 13424 if (!PyErr_Occurred()) { 13425 PyErr_SetString(PyExc_RuntimeError, 13426 "Unexpected error in an Op's C code. " 13427 "No Python exception was set."); 13428 } 13429 goto __label_170;} 13430 } 13431 // We expect NPY_FLOAT64 13432 if (!PyArray_ISALIGNED((PyArrayObject*) py_V169)) { 13433 PyArrayObject * tmp = (PyArrayObject*) py_V169; 13434 PyErr_Format(PyExc_NotImplementedError, 13435 "expected an aligned array of type %ld " 13436 "(NPY_FLOAT64), got non-aligned array of type %ld" 13437 " with %ld dimensions, with 3 last dims " 13438 "%ld, %ld, %ld" 13439 " and 3 last strides %ld %ld, %ld.", 13440 (long int) NPY_FLOAT64, 13441 (long int) PyArray_TYPE((PyArrayObject*) py_V169), 13442 (long int) PyArray_NDIM(tmp), 13443 (long int) (PyArray_NDIM(tmp) >= 3 ? 13444 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 13445 (long int) (PyArray_NDIM(tmp) >= 2 ? 13446 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 13447 (long int) (PyArray_NDIM(tmp) >= 1 ? 13448 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 13449 (long int) (PyArray_NDIM(tmp) >= 3 ? 13450 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 13451 (long int) (PyArray_NDIM(tmp) >= 2 ? 13452 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 13453 (long int) (PyArray_NDIM(tmp) >= 1 ? 13454 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 13455 ); 13456 { 13457 __failure = 170; 13458 if (!PyErr_Occurred()) { 13459 PyErr_SetString(PyExc_RuntimeError, 13460 "Unexpected error in an Op's C code. " 13461 "No Python exception was set."); 13462 } 13463 goto __label_170;} 13464 } 13465 // This is a TypeError to be consistent with DEBUG_MODE 13466 // Note: DEBUG_MODE also tells the name of the container 13467 if (PyArray_TYPE((PyArrayObject*) py_V169) != NPY_FLOAT64) { 13468 PyErr_Format(PyExc_TypeError, 13469 "expected type_num %d (NPY_FLOAT64) got %d", 13470 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V169)); 13471 { 13472 __failure = 170; 13473 if (!PyErr_Occurred()) { 13474 PyErr_SetString(PyExc_RuntimeError, 13475 "Unexpected error in an Op's C code. " 13476 "No Python exception was set."); 13477 } 13478 goto __label_170;} 13479 } 13480 13481 V169 = (PyArrayObject*)(py_V169); 13482 Py_XINCREF(V169); 13483 13484 { 13485 13486 py_V171 = PyList_GET_ITEM(storage_V171, 0); 13487 {Py_XINCREF(py_V171);} 13488 13489 V171 = NULL; 13490 if (py_V171 == Py_None) { 13491 // We can either fail here or set V171 to NULL and rely on Ops 13492 // using tensors to handle the NULL case, but if they fail to do so 13493 // they'll end up with nasty segfaults, so this is public service. 13494 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 13495 { 13496 __failure = 172; 13497 if (!PyErr_Occurred()) { 13498 PyErr_SetString(PyExc_RuntimeError, 13499 "Unexpected error in an Op's C code. " 13500 "No Python exception was set."); 13501 } 13502 goto __label_172;} 13503 } 13504 if (!PyArray_Check(py_V171)) { 13505 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 13506 { 13507 __failure = 172; 13508 if (!PyErr_Occurred()) { 13509 PyErr_SetString(PyExc_RuntimeError, 13510 "Unexpected error in an Op's C code. " 13511 "No Python exception was set."); 13512 } 13513 goto __label_172;} 13514 } 13515 // We expect NPY_FLOAT64 13516 if (!PyArray_ISALIGNED((PyArrayObject*) py_V171)) { 13517 PyArrayObject * tmp = (PyArrayObject*) py_V171; 13518 PyErr_Format(PyExc_NotImplementedError, 13519 "expected an aligned array of type %ld " 13520 "(NPY_FLOAT64), got non-aligned array of type %ld" 13521 " with %ld dimensions, with 3 last dims " 13522 "%ld, %ld, %ld" 13523 " and 3 last strides %ld %ld, %ld.", 13524 (long int) NPY_FLOAT64, 13525 (long int) PyArray_TYPE((PyArrayObject*) py_V171), 13526 (long int) PyArray_NDIM(tmp), 13527 (long int) (PyArray_NDIM(tmp) >= 3 ? 13528 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 13529 (long int) (PyArray_NDIM(tmp) >= 2 ? 13530 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 13531 (long int) (PyArray_NDIM(tmp) >= 1 ? 13532 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 13533 (long int) (PyArray_NDIM(tmp) >= 3 ? 13534 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 13535 (long int) (PyArray_NDIM(tmp) >= 2 ? 13536 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 13537 (long int) (PyArray_NDIM(tmp) >= 1 ? 13538 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 13539 ); 13540 { 13541 __failure = 172; 13542 if (!PyErr_Occurred()) { 13543 PyErr_SetString(PyExc_RuntimeError, 13544 "Unexpected error in an Op's C code. " 13545 "No Python exception was set."); 13546 } 13547 goto __label_172;} 13548 } 13549 // This is a TypeError to be consistent with DEBUG_MODE 13550 // Note: DEBUG_MODE also tells the name of the container 13551 if (PyArray_TYPE((PyArrayObject*) py_V171) != NPY_FLOAT64) { 13552 PyErr_Format(PyExc_TypeError, 13553 "expected type_num %d (NPY_FLOAT64) got %d", 13554 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V171)); 13555 { 13556 __failure = 172; 13557 if (!PyErr_Occurred()) { 13558 PyErr_SetString(PyExc_RuntimeError, 13559 "Unexpected error in an Op's C code. " 13560 "No Python exception was set."); 13561 } 13562 goto __label_172;} 13563 } 13564 13565 V171 = (PyArrayObject*)(py_V171); 13566 Py_XINCREF(V171); 13567 13568 { 13569 13570 py_V173 = PyList_GET_ITEM(storage_V173, 0); 13571 {Py_XINCREF(py_V173);} 13572 13573 V173 = NULL; 13574 if (py_V173 == Py_None) { 13575 // We can either fail here or set V173 to NULL and rely on Ops 13576 // using tensors to handle the NULL case, but if they fail to do so 13577 // they'll end up with nasty segfaults, so this is public service. 13578 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 13579 { 13580 __failure = 174; 13581 if (!PyErr_Occurred()) { 13582 PyErr_SetString(PyExc_RuntimeError, 13583 "Unexpected error in an Op's C code. " 13584 "No Python exception was set."); 13585 } 13586 goto __label_174;} 13587 } 13588 if (!PyArray_Check(py_V173)) { 13589 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 13590 { 13591 __failure = 174; 13592 if (!PyErr_Occurred()) { 13593 PyErr_SetString(PyExc_RuntimeError, 13594 "Unexpected error in an Op's C code. " 13595 "No Python exception was set."); 13596 } 13597 goto __label_174;} 13598 } 13599 // We expect NPY_FLOAT64 13600 if (!PyArray_ISALIGNED((PyArrayObject*) py_V173)) { 13601 PyArrayObject * tmp = (PyArrayObject*) py_V173; 13602 PyErr_Format(PyExc_NotImplementedError, 13603 "expected an aligned array of type %ld " 13604 "(NPY_FLOAT64), got non-aligned array of type %ld" 13605 " with %ld dimensions, with 3 last dims " 13606 "%ld, %ld, %ld" 13607 " and 3 last strides %ld %ld, %ld.", 13608 (long int) NPY_FLOAT64, 13609 (long int) PyArray_TYPE((PyArrayObject*) py_V173), 13610 (long int) PyArray_NDIM(tmp), 13611 (long int) (PyArray_NDIM(tmp) >= 3 ? 13612 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 13613 (long int) (PyArray_NDIM(tmp) >= 2 ? 13614 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 13615 (long int) (PyArray_NDIM(tmp) >= 1 ? 13616 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 13617 (long int) (PyArray_NDIM(tmp) >= 3 ? 13618 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 13619 (long int) (PyArray_NDIM(tmp) >= 2 ? 13620 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 13621 (long int) (PyArray_NDIM(tmp) >= 1 ? 13622 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 13623 ); 13624 { 13625 __failure = 174; 13626 if (!PyErr_Occurred()) { 13627 PyErr_SetString(PyExc_RuntimeError, 13628 "Unexpected error in an Op's C code. " 13629 "No Python exception was set."); 13630 } 13631 goto __label_174;} 13632 } 13633 // This is a TypeError to be consistent with DEBUG_MODE 13634 // Note: DEBUG_MODE also tells the name of the container 13635 if (PyArray_TYPE((PyArrayObject*) py_V173) != NPY_FLOAT64) { 13636 PyErr_Format(PyExc_TypeError, 13637 "expected type_num %d (NPY_FLOAT64) got %d", 13638 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V173)); 13639 { 13640 __failure = 174; 13641 if (!PyErr_Occurred()) { 13642 PyErr_SetString(PyExc_RuntimeError, 13643 "Unexpected error in an Op's C code. " 13644 "No Python exception was set."); 13645 } 13646 goto __label_174;} 13647 } 13648 13649 V173 = (PyArrayObject*)(py_V173); 13650 Py_XINCREF(V173); 13651 13652 { 13653 13654 py_V175 = PyList_GET_ITEM(storage_V175, 0); 13655 {Py_XINCREF(py_V175);} 13656 13657 V175 = NULL; 13658 if (py_V175 == Py_None) { 13659 // We can either fail here or set V175 to NULL and rely on Ops 13660 // using tensors to handle the NULL case, but if they fail to do so 13661 // they'll end up with nasty segfaults, so this is public service. 13662 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 13663 { 13664 __failure = 176; 13665 if (!PyErr_Occurred()) { 13666 PyErr_SetString(PyExc_RuntimeError, 13667 "Unexpected error in an Op's C code. " 13668 "No Python exception was set."); 13669 } 13670 goto __label_176;} 13671 } 13672 if (!PyArray_Check(py_V175)) { 13673 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 13674 { 13675 __failure = 176; 13676 if (!PyErr_Occurred()) { 13677 PyErr_SetString(PyExc_RuntimeError, 13678 "Unexpected error in an Op's C code. " 13679 "No Python exception was set."); 13680 } 13681 goto __label_176;} 13682 } 13683 // We expect NPY_FLOAT64 13684 if (!PyArray_ISALIGNED((PyArrayObject*) py_V175)) { 13685 PyArrayObject * tmp = (PyArrayObject*) py_V175; 13686 PyErr_Format(PyExc_NotImplementedError, 13687 "expected an aligned array of type %ld " 13688 "(NPY_FLOAT64), got non-aligned array of type %ld" 13689 " with %ld dimensions, with 3 last dims " 13690 "%ld, %ld, %ld" 13691 " and 3 last strides %ld %ld, %ld.", 13692 (long int) NPY_FLOAT64, 13693 (long int) PyArray_TYPE((PyArrayObject*) py_V175), 13694 (long int) PyArray_NDIM(tmp), 13695 (long int) (PyArray_NDIM(tmp) >= 3 ? 13696 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 13697 (long int) (PyArray_NDIM(tmp) >= 2 ? 13698 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 13699 (long int) (PyArray_NDIM(tmp) >= 1 ? 13700 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 13701 (long int) (PyArray_NDIM(tmp) >= 3 ? 13702 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 13703 (long int) (PyArray_NDIM(tmp) >= 2 ? 13704 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 13705 (long int) (PyArray_NDIM(tmp) >= 1 ? 13706 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 13707 ); 13708 { 13709 __failure = 176; 13710 if (!PyErr_Occurred()) { 13711 PyErr_SetString(PyExc_RuntimeError, 13712 "Unexpected error in an Op's C code. " 13713 "No Python exception was set."); 13714 } 13715 goto __label_176;} 13716 } 13717 // This is a TypeError to be consistent with DEBUG_MODE 13718 // Note: DEBUG_MODE also tells the name of the container 13719 if (PyArray_TYPE((PyArrayObject*) py_V175) != NPY_FLOAT64) { 13720 PyErr_Format(PyExc_TypeError, 13721 "expected type_num %d (NPY_FLOAT64) got %d", 13722 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V175)); 13723 { 13724 __failure = 176; 13725 if (!PyErr_Occurred()) { 13726 PyErr_SetString(PyExc_RuntimeError, 13727 "Unexpected error in an Op's C code. " 13728 "No Python exception was set."); 13729 } 13730 goto __label_176;} 13731 } 13732 13733 V175 = (PyArrayObject*)(py_V175); 13734 Py_XINCREF(V175); 13735 13736 { 13737 13738 py_V177 = PyList_GET_ITEM(storage_V177, 0); 13739 {Py_XINCREF(py_V177);} 13740 13741 V177 = NULL; 13742 if (py_V177 == Py_None) { 13743 // We can either fail here or set V177 to NULL and rely on Ops 13744 // using tensors to handle the NULL case, but if they fail to do so 13745 // they'll end up with nasty segfaults, so this is public service. 13746 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 13747 { 13748 __failure = 178; 13749 if (!PyErr_Occurred()) { 13750 PyErr_SetString(PyExc_RuntimeError, 13751 "Unexpected error in an Op's C code. " 13752 "No Python exception was set."); 13753 } 13754 goto __label_178;} 13755 } 13756 if (!PyArray_Check(py_V177)) { 13757 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 13758 { 13759 __failure = 178; 13760 if (!PyErr_Occurred()) { 13761 PyErr_SetString(PyExc_RuntimeError, 13762 "Unexpected error in an Op's C code. " 13763 "No Python exception was set."); 13764 } 13765 goto __label_178;} 13766 } 13767 // We expect NPY_FLOAT64 13768 if (!PyArray_ISALIGNED((PyArrayObject*) py_V177)) { 13769 PyArrayObject * tmp = (PyArrayObject*) py_V177; 13770 PyErr_Format(PyExc_NotImplementedError, 13771 "expected an aligned array of type %ld " 13772 "(NPY_FLOAT64), got non-aligned array of type %ld" 13773 " with %ld dimensions, with 3 last dims " 13774 "%ld, %ld, %ld" 13775 " and 3 last strides %ld %ld, %ld.", 13776 (long int) NPY_FLOAT64, 13777 (long int) PyArray_TYPE((PyArrayObject*) py_V177), 13778 (long int) PyArray_NDIM(tmp), 13779 (long int) (PyArray_NDIM(tmp) >= 3 ? 13780 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 13781 (long int) (PyArray_NDIM(tmp) >= 2 ? 13782 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 13783 (long int) (PyArray_NDIM(tmp) >= 1 ? 13784 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 13785 (long int) (PyArray_NDIM(tmp) >= 3 ? 13786 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 13787 (long int) (PyArray_NDIM(tmp) >= 2 ? 13788 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 13789 (long int) (PyArray_NDIM(tmp) >= 1 ? 13790 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 13791 ); 13792 { 13793 __failure = 178; 13794 if (!PyErr_Occurred()) { 13795 PyErr_SetString(PyExc_RuntimeError, 13796 "Unexpected error in an Op's C code. " 13797 "No Python exception was set."); 13798 } 13799 goto __label_178;} 13800 } 13801 // This is a TypeError to be consistent with DEBUG_MODE 13802 // Note: DEBUG_MODE also tells the name of the container 13803 if (PyArray_TYPE((PyArrayObject*) py_V177) != NPY_FLOAT64) { 13804 PyErr_Format(PyExc_TypeError, 13805 "expected type_num %d (NPY_FLOAT64) got %d", 13806 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V177)); 13807 { 13808 __failure = 178; 13809 if (!PyErr_Occurred()) { 13810 PyErr_SetString(PyExc_RuntimeError, 13811 "Unexpected error in an Op's C code. " 13812 "No Python exception was set."); 13813 } 13814 goto __label_178;} 13815 } 13816 13817 V177 = (PyArrayObject*)(py_V177); 13818 Py_XINCREF(V177); 13819 13820 { 13821 13822 py_V179 = PyList_GET_ITEM(storage_V179, 0); 13823 {Py_XINCREF(py_V179);} 13824 13825 V179 = NULL; 13826 if (py_V179 == Py_None) { 13827 // We can either fail here or set V179 to NULL and rely on Ops 13828 // using tensors to handle the NULL case, but if they fail to do so 13829 // they'll end up with nasty segfaults, so this is public service. 13830 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 13831 { 13832 __failure = 180; 13833 if (!PyErr_Occurred()) { 13834 PyErr_SetString(PyExc_RuntimeError, 13835 "Unexpected error in an Op's C code. " 13836 "No Python exception was set."); 13837 } 13838 goto __label_180;} 13839 } 13840 if (!PyArray_Check(py_V179)) { 13841 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 13842 { 13843 __failure = 180; 13844 if (!PyErr_Occurred()) { 13845 PyErr_SetString(PyExc_RuntimeError, 13846 "Unexpected error in an Op's C code. " 13847 "No Python exception was set."); 13848 } 13849 goto __label_180;} 13850 } 13851 // We expect NPY_FLOAT64 13852 if (!PyArray_ISALIGNED((PyArrayObject*) py_V179)) { 13853 PyArrayObject * tmp = (PyArrayObject*) py_V179; 13854 PyErr_Format(PyExc_NotImplementedError, 13855 "expected an aligned array of type %ld " 13856 "(NPY_FLOAT64), got non-aligned array of type %ld" 13857 " with %ld dimensions, with 3 last dims " 13858 "%ld, %ld, %ld" 13859 " and 3 last strides %ld %ld, %ld.", 13860 (long int) NPY_FLOAT64, 13861 (long int) PyArray_TYPE((PyArrayObject*) py_V179), 13862 (long int) PyArray_NDIM(tmp), 13863 (long int) (PyArray_NDIM(tmp) >= 3 ? 13864 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 13865 (long int) (PyArray_NDIM(tmp) >= 2 ? 13866 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 13867 (long int) (PyArray_NDIM(tmp) >= 1 ? 13868 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 13869 (long int) (PyArray_NDIM(tmp) >= 3 ? 13870 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 13871 (long int) (PyArray_NDIM(tmp) >= 2 ? 13872 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 13873 (long int) (PyArray_NDIM(tmp) >= 1 ? 13874 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 13875 ); 13876 { 13877 __failure = 180; 13878 if (!PyErr_Occurred()) { 13879 PyErr_SetString(PyExc_RuntimeError, 13880 "Unexpected error in an Op's C code. " 13881 "No Python exception was set."); 13882 } 13883 goto __label_180;} 13884 } 13885 // This is a TypeError to be consistent with DEBUG_MODE 13886 // Note: DEBUG_MODE also tells the name of the container 13887 if (PyArray_TYPE((PyArrayObject*) py_V179) != NPY_FLOAT64) { 13888 PyErr_Format(PyExc_TypeError, 13889 "expected type_num %d (NPY_FLOAT64) got %d", 13890 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V179)); 13891 { 13892 __failure = 180; 13893 if (!PyErr_Occurred()) { 13894 PyErr_SetString(PyExc_RuntimeError, 13895 "Unexpected error in an Op's C code. " 13896 "No Python exception was set."); 13897 } 13898 goto __label_180;} 13899 } 13900 13901 V179 = (PyArrayObject*)(py_V179); 13902 Py_XINCREF(V179); 13903 13904 { 13905 13906 py_V181 = PyList_GET_ITEM(storage_V181, 0); 13907 {Py_XINCREF(py_V181);} 13908 13909 V181 = NULL; 13910 if (py_V181 == Py_None) { 13911 // We can either fail here or set V181 to NULL and rely on Ops 13912 // using tensors to handle the NULL case, but if they fail to do so 13913 // they'll end up with nasty segfaults, so this is public service. 13914 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 13915 { 13916 __failure = 182; 13917 if (!PyErr_Occurred()) { 13918 PyErr_SetString(PyExc_RuntimeError, 13919 "Unexpected error in an Op's C code. " 13920 "No Python exception was set."); 13921 } 13922 goto __label_182;} 13923 } 13924 if (!PyArray_Check(py_V181)) { 13925 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 13926 { 13927 __failure = 182; 13928 if (!PyErr_Occurred()) { 13929 PyErr_SetString(PyExc_RuntimeError, 13930 "Unexpected error in an Op's C code. " 13931 "No Python exception was set."); 13932 } 13933 goto __label_182;} 13934 } 13935 // We expect NPY_FLOAT64 13936 if (!PyArray_ISALIGNED((PyArrayObject*) py_V181)) { 13937 PyArrayObject * tmp = (PyArrayObject*) py_V181; 13938 PyErr_Format(PyExc_NotImplementedError, 13939 "expected an aligned array of type %ld " 13940 "(NPY_FLOAT64), got non-aligned array of type %ld" 13941 " with %ld dimensions, with 3 last dims " 13942 "%ld, %ld, %ld" 13943 " and 3 last strides %ld %ld, %ld.", 13944 (long int) NPY_FLOAT64, 13945 (long int) PyArray_TYPE((PyArrayObject*) py_V181), 13946 (long int) PyArray_NDIM(tmp), 13947 (long int) (PyArray_NDIM(tmp) >= 3 ? 13948 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 13949 (long int) (PyArray_NDIM(tmp) >= 2 ? 13950 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 13951 (long int) (PyArray_NDIM(tmp) >= 1 ? 13952 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 13953 (long int) (PyArray_NDIM(tmp) >= 3 ? 13954 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 13955 (long int) (PyArray_NDIM(tmp) >= 2 ? 13956 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 13957 (long int) (PyArray_NDIM(tmp) >= 1 ? 13958 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 13959 ); 13960 { 13961 __failure = 182; 13962 if (!PyErr_Occurred()) { 13963 PyErr_SetString(PyExc_RuntimeError, 13964 "Unexpected error in an Op's C code. " 13965 "No Python exception was set."); 13966 } 13967 goto __label_182;} 13968 } 13969 // This is a TypeError to be consistent with DEBUG_MODE 13970 // Note: DEBUG_MODE also tells the name of the container 13971 if (PyArray_TYPE((PyArrayObject*) py_V181) != NPY_FLOAT64) { 13972 PyErr_Format(PyExc_TypeError, 13973 "expected type_num %d (NPY_FLOAT64) got %d", 13974 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V181)); 13975 { 13976 __failure = 182; 13977 if (!PyErr_Occurred()) { 13978 PyErr_SetString(PyExc_RuntimeError, 13979 "Unexpected error in an Op's C code. " 13980 "No Python exception was set."); 13981 } 13982 goto __label_182;} 13983 } 13984 13985 V181 = (PyArrayObject*)(py_V181); 13986 Py_XINCREF(V181); 13987 13988 { 13989 13990 py_V183 = PyList_GET_ITEM(storage_V183, 0); 13991 {Py_XINCREF(py_V183);} 13992 13993 V183 = NULL; 13994 if (py_V183 == Py_None) { 13995 // We can either fail here or set V183 to NULL and rely on Ops 13996 // using tensors to handle the NULL case, but if they fail to do so 13997 // they'll end up with nasty segfaults, so this is public service. 13998 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 13999 { 14000 __failure = 184; 14001 if (!PyErr_Occurred()) { 14002 PyErr_SetString(PyExc_RuntimeError, 14003 "Unexpected error in an Op's C code. " 14004 "No Python exception was set."); 14005 } 14006 goto __label_184;} 14007 } 14008 if (!PyArray_Check(py_V183)) { 14009 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 14010 { 14011 __failure = 184; 14012 if (!PyErr_Occurred()) { 14013 PyErr_SetString(PyExc_RuntimeError, 14014 "Unexpected error in an Op's C code. " 14015 "No Python exception was set."); 14016 } 14017 goto __label_184;} 14018 } 14019 // We expect NPY_FLOAT64 14020 if (!PyArray_ISALIGNED((PyArrayObject*) py_V183)) { 14021 PyArrayObject * tmp = (PyArrayObject*) py_V183; 14022 PyErr_Format(PyExc_NotImplementedError, 14023 "expected an aligned array of type %ld " 14024 "(NPY_FLOAT64), got non-aligned array of type %ld" 14025 " with %ld dimensions, with 3 last dims " 14026 "%ld, %ld, %ld" 14027 " and 3 last strides %ld %ld, %ld.", 14028 (long int) NPY_FLOAT64, 14029 (long int) PyArray_TYPE((PyArrayObject*) py_V183), 14030 (long int) PyArray_NDIM(tmp), 14031 (long int) (PyArray_NDIM(tmp) >= 3 ? 14032 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 14033 (long int) (PyArray_NDIM(tmp) >= 2 ? 14034 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 14035 (long int) (PyArray_NDIM(tmp) >= 1 ? 14036 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 14037 (long int) (PyArray_NDIM(tmp) >= 3 ? 14038 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 14039 (long int) (PyArray_NDIM(tmp) >= 2 ? 14040 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 14041 (long int) (PyArray_NDIM(tmp) >= 1 ? 14042 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 14043 ); 14044 { 14045 __failure = 184; 14046 if (!PyErr_Occurred()) { 14047 PyErr_SetString(PyExc_RuntimeError, 14048 "Unexpected error in an Op's C code. " 14049 "No Python exception was set."); 14050 } 14051 goto __label_184;} 14052 } 14053 // This is a TypeError to be consistent with DEBUG_MODE 14054 // Note: DEBUG_MODE also tells the name of the container 14055 if (PyArray_TYPE((PyArrayObject*) py_V183) != NPY_FLOAT64) { 14056 PyErr_Format(PyExc_TypeError, 14057 "expected type_num %d (NPY_FLOAT64) got %d", 14058 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V183)); 14059 { 14060 __failure = 184; 14061 if (!PyErr_Occurred()) { 14062 PyErr_SetString(PyExc_RuntimeError, 14063 "Unexpected error in an Op's C code. " 14064 "No Python exception was set."); 14065 } 14066 goto __label_184;} 14067 } 14068 14069 V183 = (PyArrayObject*)(py_V183); 14070 Py_XINCREF(V183); 14071 14072 { 14073 14074 py_V185 = PyList_GET_ITEM(storage_V185, 0); 14075 {Py_XINCREF(py_V185);} 14076 14077 V185 = NULL; 14078 if (py_V185 == Py_None) { 14079 // We can either fail here or set V185 to NULL and rely on Ops 14080 // using tensors to handle the NULL case, but if they fail to do so 14081 // they'll end up with nasty segfaults, so this is public service. 14082 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 14083 { 14084 __failure = 186; 14085 if (!PyErr_Occurred()) { 14086 PyErr_SetString(PyExc_RuntimeError, 14087 "Unexpected error in an Op's C code. " 14088 "No Python exception was set."); 14089 } 14090 goto __label_186;} 14091 } 14092 if (!PyArray_Check(py_V185)) { 14093 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 14094 { 14095 __failure = 186; 14096 if (!PyErr_Occurred()) { 14097 PyErr_SetString(PyExc_RuntimeError, 14098 "Unexpected error in an Op's C code. " 14099 "No Python exception was set."); 14100 } 14101 goto __label_186;} 14102 } 14103 // We expect NPY_FLOAT64 14104 if (!PyArray_ISALIGNED((PyArrayObject*) py_V185)) { 14105 PyArrayObject * tmp = (PyArrayObject*) py_V185; 14106 PyErr_Format(PyExc_NotImplementedError, 14107 "expected an aligned array of type %ld " 14108 "(NPY_FLOAT64), got non-aligned array of type %ld" 14109 " with %ld dimensions, with 3 last dims " 14110 "%ld, %ld, %ld" 14111 " and 3 last strides %ld %ld, %ld.", 14112 (long int) NPY_FLOAT64, 14113 (long int) PyArray_TYPE((PyArrayObject*) py_V185), 14114 (long int) PyArray_NDIM(tmp), 14115 (long int) (PyArray_NDIM(tmp) >= 3 ? 14116 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 14117 (long int) (PyArray_NDIM(tmp) >= 2 ? 14118 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 14119 (long int) (PyArray_NDIM(tmp) >= 1 ? 14120 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 14121 (long int) (PyArray_NDIM(tmp) >= 3 ? 14122 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 14123 (long int) (PyArray_NDIM(tmp) >= 2 ? 14124 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 14125 (long int) (PyArray_NDIM(tmp) >= 1 ? 14126 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 14127 ); 14128 { 14129 __failure = 186; 14130 if (!PyErr_Occurred()) { 14131 PyErr_SetString(PyExc_RuntimeError, 14132 "Unexpected error in an Op's C code. " 14133 "No Python exception was set."); 14134 } 14135 goto __label_186;} 14136 } 14137 // This is a TypeError to be consistent with DEBUG_MODE 14138 // Note: DEBUG_MODE also tells the name of the container 14139 if (PyArray_TYPE((PyArrayObject*) py_V185) != NPY_FLOAT64) { 14140 PyErr_Format(PyExc_TypeError, 14141 "expected type_num %d (NPY_FLOAT64) got %d", 14142 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V185)); 14143 { 14144 __failure = 186; 14145 if (!PyErr_Occurred()) { 14146 PyErr_SetString(PyExc_RuntimeError, 14147 "Unexpected error in an Op's C code. " 14148 "No Python exception was set."); 14149 } 14150 goto __label_186;} 14151 } 14152 14153 V185 = (PyArrayObject*)(py_V185); 14154 Py_XINCREF(V185); 14155 14156 { 14157 14158 py_V187 = PyList_GET_ITEM(storage_V187, 0); 14159 {Py_XINCREF(py_V187);} 14160 14161 V187 = NULL; 14162 if (py_V187 == Py_None) { 14163 // We can either fail here or set V187 to NULL and rely on Ops 14164 // using tensors to handle the NULL case, but if they fail to do so 14165 // they'll end up with nasty segfaults, so this is public service. 14166 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 14167 { 14168 __failure = 188; 14169 if (!PyErr_Occurred()) { 14170 PyErr_SetString(PyExc_RuntimeError, 14171 "Unexpected error in an Op's C code. " 14172 "No Python exception was set."); 14173 } 14174 goto __label_188;} 14175 } 14176 if (!PyArray_Check(py_V187)) { 14177 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 14178 { 14179 __failure = 188; 14180 if (!PyErr_Occurred()) { 14181 PyErr_SetString(PyExc_RuntimeError, 14182 "Unexpected error in an Op's C code. " 14183 "No Python exception was set."); 14184 } 14185 goto __label_188;} 14186 } 14187 // We expect NPY_FLOAT64 14188 if (!PyArray_ISALIGNED((PyArrayObject*) py_V187)) { 14189 PyArrayObject * tmp = (PyArrayObject*) py_V187; 14190 PyErr_Format(PyExc_NotImplementedError, 14191 "expected an aligned array of type %ld " 14192 "(NPY_FLOAT64), got non-aligned array of type %ld" 14193 " with %ld dimensions, with 3 last dims " 14194 "%ld, %ld, %ld" 14195 " and 3 last strides %ld %ld, %ld.", 14196 (long int) NPY_FLOAT64, 14197 (long int) PyArray_TYPE((PyArrayObject*) py_V187), 14198 (long int) PyArray_NDIM(tmp), 14199 (long int) (PyArray_NDIM(tmp) >= 3 ? 14200 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 14201 (long int) (PyArray_NDIM(tmp) >= 2 ? 14202 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 14203 (long int) (PyArray_NDIM(tmp) >= 1 ? 14204 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 14205 (long int) (PyArray_NDIM(tmp) >= 3 ? 14206 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 14207 (long int) (PyArray_NDIM(tmp) >= 2 ? 14208 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 14209 (long int) (PyArray_NDIM(tmp) >= 1 ? 14210 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 14211 ); 14212 { 14213 __failure = 188; 14214 if (!PyErr_Occurred()) { 14215 PyErr_SetString(PyExc_RuntimeError, 14216 "Unexpected error in an Op's C code. " 14217 "No Python exception was set."); 14218 } 14219 goto __label_188;} 14220 } 14221 // This is a TypeError to be consistent with DEBUG_MODE 14222 // Note: DEBUG_MODE also tells the name of the container 14223 if (PyArray_TYPE((PyArrayObject*) py_V187) != NPY_FLOAT64) { 14224 PyErr_Format(PyExc_TypeError, 14225 "expected type_num %d (NPY_FLOAT64) got %d", 14226 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V187)); 14227 { 14228 __failure = 188; 14229 if (!PyErr_Occurred()) { 14230 PyErr_SetString(PyExc_RuntimeError, 14231 "Unexpected error in an Op's C code. " 14232 "No Python exception was set."); 14233 } 14234 goto __label_188;} 14235 } 14236 14237 V187 = (PyArrayObject*)(py_V187); 14238 Py_XINCREF(V187); 14239 14240 { 14241 14242 py_V189 = PyList_GET_ITEM(storage_V189, 0); 14243 {Py_XINCREF(py_V189);} 14244 14245 V189 = NULL; 14246 if (py_V189 == Py_None) { 14247 // We can either fail here or set V189 to NULL and rely on Ops 14248 // using tensors to handle the NULL case, but if they fail to do so 14249 // they'll end up with nasty segfaults, so this is public service. 14250 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 14251 { 14252 __failure = 190; 14253 if (!PyErr_Occurred()) { 14254 PyErr_SetString(PyExc_RuntimeError, 14255 "Unexpected error in an Op's C code. " 14256 "No Python exception was set."); 14257 } 14258 goto __label_190;} 14259 } 14260 if (!PyArray_Check(py_V189)) { 14261 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 14262 { 14263 __failure = 190; 14264 if (!PyErr_Occurred()) { 14265 PyErr_SetString(PyExc_RuntimeError, 14266 "Unexpected error in an Op's C code. " 14267 "No Python exception was set."); 14268 } 14269 goto __label_190;} 14270 } 14271 // We expect NPY_FLOAT64 14272 if (!PyArray_ISALIGNED((PyArrayObject*) py_V189)) { 14273 PyArrayObject * tmp = (PyArrayObject*) py_V189; 14274 PyErr_Format(PyExc_NotImplementedError, 14275 "expected an aligned array of type %ld " 14276 "(NPY_FLOAT64), got non-aligned array of type %ld" 14277 " with %ld dimensions, with 3 last dims " 14278 "%ld, %ld, %ld" 14279 " and 3 last strides %ld %ld, %ld.", 14280 (long int) NPY_FLOAT64, 14281 (long int) PyArray_TYPE((PyArrayObject*) py_V189), 14282 (long int) PyArray_NDIM(tmp), 14283 (long int) (PyArray_NDIM(tmp) >= 3 ? 14284 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 14285 (long int) (PyArray_NDIM(tmp) >= 2 ? 14286 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 14287 (long int) (PyArray_NDIM(tmp) >= 1 ? 14288 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 14289 (long int) (PyArray_NDIM(tmp) >= 3 ? 14290 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 14291 (long int) (PyArray_NDIM(tmp) >= 2 ? 14292 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 14293 (long int) (PyArray_NDIM(tmp) >= 1 ? 14294 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 14295 ); 14296 { 14297 __failure = 190; 14298 if (!PyErr_Occurred()) { 14299 PyErr_SetString(PyExc_RuntimeError, 14300 "Unexpected error in an Op's C code. " 14301 "No Python exception was set."); 14302 } 14303 goto __label_190;} 14304 } 14305 // This is a TypeError to be consistent with DEBUG_MODE 14306 // Note: DEBUG_MODE also tells the name of the container 14307 if (PyArray_TYPE((PyArrayObject*) py_V189) != NPY_FLOAT64) { 14308 PyErr_Format(PyExc_TypeError, 14309 "expected type_num %d (NPY_FLOAT64) got %d", 14310 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V189)); 14311 { 14312 __failure = 190; 14313 if (!PyErr_Occurred()) { 14314 PyErr_SetString(PyExc_RuntimeError, 14315 "Unexpected error in an Op's C code. " 14316 "No Python exception was set."); 14317 } 14318 goto __label_190;} 14319 } 14320 14321 V189 = (PyArrayObject*)(py_V189); 14322 Py_XINCREF(V189); 14323 14324 { 14325 14326 py_V191 = PyList_GET_ITEM(storage_V191, 0); 14327 {Py_XINCREF(py_V191);} 14328 14329 V191 = NULL; 14330 if (py_V191 == Py_None) { 14331 // We can either fail here or set V191 to NULL and rely on Ops 14332 // using tensors to handle the NULL case, but if they fail to do so 14333 // they'll end up with nasty segfaults, so this is public service. 14334 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 14335 { 14336 __failure = 192; 14337 if (!PyErr_Occurred()) { 14338 PyErr_SetString(PyExc_RuntimeError, 14339 "Unexpected error in an Op's C code. " 14340 "No Python exception was set."); 14341 } 14342 goto __label_192;} 14343 } 14344 if (!PyArray_Check(py_V191)) { 14345 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 14346 { 14347 __failure = 192; 14348 if (!PyErr_Occurred()) { 14349 PyErr_SetString(PyExc_RuntimeError, 14350 "Unexpected error in an Op's C code. " 14351 "No Python exception was set."); 14352 } 14353 goto __label_192;} 14354 } 14355 // We expect NPY_FLOAT64 14356 if (!PyArray_ISALIGNED((PyArrayObject*) py_V191)) { 14357 PyArrayObject * tmp = (PyArrayObject*) py_V191; 14358 PyErr_Format(PyExc_NotImplementedError, 14359 "expected an aligned array of type %ld " 14360 "(NPY_FLOAT64), got non-aligned array of type %ld" 14361 " with %ld dimensions, with 3 last dims " 14362 "%ld, %ld, %ld" 14363 " and 3 last strides %ld %ld, %ld.", 14364 (long int) NPY_FLOAT64, 14365 (long int) PyArray_TYPE((PyArrayObject*) py_V191), 14366 (long int) PyArray_NDIM(tmp), 14367 (long int) (PyArray_NDIM(tmp) >= 3 ? 14368 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 14369 (long int) (PyArray_NDIM(tmp) >= 2 ? 14370 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 14371 (long int) (PyArray_NDIM(tmp) >= 1 ? 14372 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 14373 (long int) (PyArray_NDIM(tmp) >= 3 ? 14374 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 14375 (long int) (PyArray_NDIM(tmp) >= 2 ? 14376 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 14377 (long int) (PyArray_NDIM(tmp) >= 1 ? 14378 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 14379 ); 14380 { 14381 __failure = 192; 14382 if (!PyErr_Occurred()) { 14383 PyErr_SetString(PyExc_RuntimeError, 14384 "Unexpected error in an Op's C code. " 14385 "No Python exception was set."); 14386 } 14387 goto __label_192;} 14388 } 14389 // This is a TypeError to be consistent with DEBUG_MODE 14390 // Note: DEBUG_MODE also tells the name of the container 14391 if (PyArray_TYPE((PyArrayObject*) py_V191) != NPY_FLOAT64) { 14392 PyErr_Format(PyExc_TypeError, 14393 "expected type_num %d (NPY_FLOAT64) got %d", 14394 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V191)); 14395 { 14396 __failure = 192; 14397 if (!PyErr_Occurred()) { 14398 PyErr_SetString(PyExc_RuntimeError, 14399 "Unexpected error in an Op's C code. " 14400 "No Python exception was set."); 14401 } 14402 goto __label_192;} 14403 } 14404 14405 V191 = (PyArrayObject*)(py_V191); 14406 Py_XINCREF(V191); 14407 14408 { 14409 14410 py_V193 = PyList_GET_ITEM(storage_V193, 0); 14411 {Py_XINCREF(py_V193);} 14412 14413 V193 = NULL; 14414 if (py_V193 == Py_None) { 14415 // We can either fail here or set V193 to NULL and rely on Ops 14416 // using tensors to handle the NULL case, but if they fail to do so 14417 // they'll end up with nasty segfaults, so this is public service. 14418 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 14419 { 14420 __failure = 194; 14421 if (!PyErr_Occurred()) { 14422 PyErr_SetString(PyExc_RuntimeError, 14423 "Unexpected error in an Op's C code. " 14424 "No Python exception was set."); 14425 } 14426 goto __label_194;} 14427 } 14428 if (!PyArray_Check(py_V193)) { 14429 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 14430 { 14431 __failure = 194; 14432 if (!PyErr_Occurred()) { 14433 PyErr_SetString(PyExc_RuntimeError, 14434 "Unexpected error in an Op's C code. " 14435 "No Python exception was set."); 14436 } 14437 goto __label_194;} 14438 } 14439 // We expect NPY_FLOAT64 14440 if (!PyArray_ISALIGNED((PyArrayObject*) py_V193)) { 14441 PyArrayObject * tmp = (PyArrayObject*) py_V193; 14442 PyErr_Format(PyExc_NotImplementedError, 14443 "expected an aligned array of type %ld " 14444 "(NPY_FLOAT64), got non-aligned array of type %ld" 14445 " with %ld dimensions, with 3 last dims " 14446 "%ld, %ld, %ld" 14447 " and 3 last strides %ld %ld, %ld.", 14448 (long int) NPY_FLOAT64, 14449 (long int) PyArray_TYPE((PyArrayObject*) py_V193), 14450 (long int) PyArray_NDIM(tmp), 14451 (long int) (PyArray_NDIM(tmp) >= 3 ? 14452 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 14453 (long int) (PyArray_NDIM(tmp) >= 2 ? 14454 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 14455 (long int) (PyArray_NDIM(tmp) >= 1 ? 14456 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 14457 (long int) (PyArray_NDIM(tmp) >= 3 ? 14458 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 14459 (long int) (PyArray_NDIM(tmp) >= 2 ? 14460 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 14461 (long int) (PyArray_NDIM(tmp) >= 1 ? 14462 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 14463 ); 14464 { 14465 __failure = 194; 14466 if (!PyErr_Occurred()) { 14467 PyErr_SetString(PyExc_RuntimeError, 14468 "Unexpected error in an Op's C code. " 14469 "No Python exception was set."); 14470 } 14471 goto __label_194;} 14472 } 14473 // This is a TypeError to be consistent with DEBUG_MODE 14474 // Note: DEBUG_MODE also tells the name of the container 14475 if (PyArray_TYPE((PyArrayObject*) py_V193) != NPY_FLOAT64) { 14476 PyErr_Format(PyExc_TypeError, 14477 "expected type_num %d (NPY_FLOAT64) got %d", 14478 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V193)); 14479 { 14480 __failure = 194; 14481 if (!PyErr_Occurred()) { 14482 PyErr_SetString(PyExc_RuntimeError, 14483 "Unexpected error in an Op's C code. " 14484 "No Python exception was set."); 14485 } 14486 goto __label_194;} 14487 } 14488 14489 V193 = (PyArrayObject*)(py_V193); 14490 Py_XINCREF(V193); 14491 14492 { 14493 14494 py_V195 = PyList_GET_ITEM(storage_V195, 0); 14495 {Py_XINCREF(py_V195);} 14496 14497 V195 = NULL; 14498 if (py_V195 == Py_None) { 14499 // We can either fail here or set V195 to NULL and rely on Ops 14500 // using tensors to handle the NULL case, but if they fail to do so 14501 // they'll end up with nasty segfaults, so this is public service. 14502 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 14503 { 14504 __failure = 196; 14505 if (!PyErr_Occurred()) { 14506 PyErr_SetString(PyExc_RuntimeError, 14507 "Unexpected error in an Op's C code. " 14508 "No Python exception was set."); 14509 } 14510 goto __label_196;} 14511 } 14512 if (!PyArray_Check(py_V195)) { 14513 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 14514 { 14515 __failure = 196; 14516 if (!PyErr_Occurred()) { 14517 PyErr_SetString(PyExc_RuntimeError, 14518 "Unexpected error in an Op's C code. " 14519 "No Python exception was set."); 14520 } 14521 goto __label_196;} 14522 } 14523 // We expect NPY_FLOAT64 14524 if (!PyArray_ISALIGNED((PyArrayObject*) py_V195)) { 14525 PyArrayObject * tmp = (PyArrayObject*) py_V195; 14526 PyErr_Format(PyExc_NotImplementedError, 14527 "expected an aligned array of type %ld " 14528 "(NPY_FLOAT64), got non-aligned array of type %ld" 14529 " with %ld dimensions, with 3 last dims " 14530 "%ld, %ld, %ld" 14531 " and 3 last strides %ld %ld, %ld.", 14532 (long int) NPY_FLOAT64, 14533 (long int) PyArray_TYPE((PyArrayObject*) py_V195), 14534 (long int) PyArray_NDIM(tmp), 14535 (long int) (PyArray_NDIM(tmp) >= 3 ? 14536 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 14537 (long int) (PyArray_NDIM(tmp) >= 2 ? 14538 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 14539 (long int) (PyArray_NDIM(tmp) >= 1 ? 14540 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 14541 (long int) (PyArray_NDIM(tmp) >= 3 ? 14542 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 14543 (long int) (PyArray_NDIM(tmp) >= 2 ? 14544 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 14545 (long int) (PyArray_NDIM(tmp) >= 1 ? 14546 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 14547 ); 14548 { 14549 __failure = 196; 14550 if (!PyErr_Occurred()) { 14551 PyErr_SetString(PyExc_RuntimeError, 14552 "Unexpected error in an Op's C code. " 14553 "No Python exception was set."); 14554 } 14555 goto __label_196;} 14556 } 14557 // This is a TypeError to be consistent with DEBUG_MODE 14558 // Note: DEBUG_MODE also tells the name of the container 14559 if (PyArray_TYPE((PyArrayObject*) py_V195) != NPY_FLOAT64) { 14560 PyErr_Format(PyExc_TypeError, 14561 "expected type_num %d (NPY_FLOAT64) got %d", 14562 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V195)); 14563 { 14564 __failure = 196; 14565 if (!PyErr_Occurred()) { 14566 PyErr_SetString(PyExc_RuntimeError, 14567 "Unexpected error in an Op's C code. " 14568 "No Python exception was set."); 14569 } 14570 goto __label_196;} 14571 } 14572 14573 V195 = (PyArrayObject*)(py_V195); 14574 Py_XINCREF(V195); 14575 14576 { 14577 14578 py_V197 = PyList_GET_ITEM(storage_V197, 0); 14579 {Py_XINCREF(py_V197);} 14580 14581 V197 = NULL; 14582 if (py_V197 == Py_None) { 14583 // We can either fail here or set V197 to NULL and rely on Ops 14584 // using tensors to handle the NULL case, but if they fail to do so 14585 // they'll end up with nasty segfaults, so this is public service. 14586 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 14587 { 14588 __failure = 198; 14589 if (!PyErr_Occurred()) { 14590 PyErr_SetString(PyExc_RuntimeError, 14591 "Unexpected error in an Op's C code. " 14592 "No Python exception was set."); 14593 } 14594 goto __label_198;} 14595 } 14596 if (!PyArray_Check(py_V197)) { 14597 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 14598 { 14599 __failure = 198; 14600 if (!PyErr_Occurred()) { 14601 PyErr_SetString(PyExc_RuntimeError, 14602 "Unexpected error in an Op's C code. " 14603 "No Python exception was set."); 14604 } 14605 goto __label_198;} 14606 } 14607 // We expect NPY_FLOAT64 14608 if (!PyArray_ISALIGNED((PyArrayObject*) py_V197)) { 14609 PyArrayObject * tmp = (PyArrayObject*) py_V197; 14610 PyErr_Format(PyExc_NotImplementedError, 14611 "expected an aligned array of type %ld " 14612 "(NPY_FLOAT64), got non-aligned array of type %ld" 14613 " with %ld dimensions, with 3 last dims " 14614 "%ld, %ld, %ld" 14615 " and 3 last strides %ld %ld, %ld.", 14616 (long int) NPY_FLOAT64, 14617 (long int) PyArray_TYPE((PyArrayObject*) py_V197), 14618 (long int) PyArray_NDIM(tmp), 14619 (long int) (PyArray_NDIM(tmp) >= 3 ? 14620 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 14621 (long int) (PyArray_NDIM(tmp) >= 2 ? 14622 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 14623 (long int) (PyArray_NDIM(tmp) >= 1 ? 14624 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 14625 (long int) (PyArray_NDIM(tmp) >= 3 ? 14626 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 14627 (long int) (PyArray_NDIM(tmp) >= 2 ? 14628 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 14629 (long int) (PyArray_NDIM(tmp) >= 1 ? 14630 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 14631 ); 14632 { 14633 __failure = 198; 14634 if (!PyErr_Occurred()) { 14635 PyErr_SetString(PyExc_RuntimeError, 14636 "Unexpected error in an Op's C code. " 14637 "No Python exception was set."); 14638 } 14639 goto __label_198;} 14640 } 14641 // This is a TypeError to be consistent with DEBUG_MODE 14642 // Note: DEBUG_MODE also tells the name of the container 14643 if (PyArray_TYPE((PyArrayObject*) py_V197) != NPY_FLOAT64) { 14644 PyErr_Format(PyExc_TypeError, 14645 "expected type_num %d (NPY_FLOAT64) got %d", 14646 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V197)); 14647 { 14648 __failure = 198; 14649 if (!PyErr_Occurred()) { 14650 PyErr_SetString(PyExc_RuntimeError, 14651 "Unexpected error in an Op's C code. " 14652 "No Python exception was set."); 14653 } 14654 goto __label_198;} 14655 } 14656 14657 V197 = (PyArrayObject*)(py_V197); 14658 Py_XINCREF(V197); 14659 14660 { 14661 14662 py_V199 = PyList_GET_ITEM(storage_V199, 0); 14663 {Py_XINCREF(py_V199);} 14664 14665 V199 = NULL; 14666 if (py_V199 == Py_None) { 14667 // We can either fail here or set V199 to NULL and rely on Ops 14668 // using tensors to handle the NULL case, but if they fail to do so 14669 // they'll end up with nasty segfaults, so this is public service. 14670 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 14671 { 14672 __failure = 200; 14673 if (!PyErr_Occurred()) { 14674 PyErr_SetString(PyExc_RuntimeError, 14675 "Unexpected error in an Op's C code. " 14676 "No Python exception was set."); 14677 } 14678 goto __label_200;} 14679 } 14680 if (!PyArray_Check(py_V199)) { 14681 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 14682 { 14683 __failure = 200; 14684 if (!PyErr_Occurred()) { 14685 PyErr_SetString(PyExc_RuntimeError, 14686 "Unexpected error in an Op's C code. " 14687 "No Python exception was set."); 14688 } 14689 goto __label_200;} 14690 } 14691 // We expect NPY_FLOAT64 14692 if (!PyArray_ISALIGNED((PyArrayObject*) py_V199)) { 14693 PyArrayObject * tmp = (PyArrayObject*) py_V199; 14694 PyErr_Format(PyExc_NotImplementedError, 14695 "expected an aligned array of type %ld " 14696 "(NPY_FLOAT64), got non-aligned array of type %ld" 14697 " with %ld dimensions, with 3 last dims " 14698 "%ld, %ld, %ld" 14699 " and 3 last strides %ld %ld, %ld.", 14700 (long int) NPY_FLOAT64, 14701 (long int) PyArray_TYPE((PyArrayObject*) py_V199), 14702 (long int) PyArray_NDIM(tmp), 14703 (long int) (PyArray_NDIM(tmp) >= 3 ? 14704 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 14705 (long int) (PyArray_NDIM(tmp) >= 2 ? 14706 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 14707 (long int) (PyArray_NDIM(tmp) >= 1 ? 14708 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 14709 (long int) (PyArray_NDIM(tmp) >= 3 ? 14710 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 14711 (long int) (PyArray_NDIM(tmp) >= 2 ? 14712 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 14713 (long int) (PyArray_NDIM(tmp) >= 1 ? 14714 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 14715 ); 14716 { 14717 __failure = 200; 14718 if (!PyErr_Occurred()) { 14719 PyErr_SetString(PyExc_RuntimeError, 14720 "Unexpected error in an Op's C code. " 14721 "No Python exception was set."); 14722 } 14723 goto __label_200;} 14724 } 14725 // This is a TypeError to be consistent with DEBUG_MODE 14726 // Note: DEBUG_MODE also tells the name of the container 14727 if (PyArray_TYPE((PyArrayObject*) py_V199) != NPY_FLOAT64) { 14728 PyErr_Format(PyExc_TypeError, 14729 "expected type_num %d (NPY_FLOAT64) got %d", 14730 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V199)); 14731 { 14732 __failure = 200; 14733 if (!PyErr_Occurred()) { 14734 PyErr_SetString(PyExc_RuntimeError, 14735 "Unexpected error in an Op's C code. " 14736 "No Python exception was set."); 14737 } 14738 goto __label_200;} 14739 } 14740 14741 V199 = (PyArrayObject*)(py_V199); 14742 Py_XINCREF(V199); 14743 14744 { 14745 14746 py_V201 = PyList_GET_ITEM(storage_V201, 0); 14747 {Py_XINCREF(py_V201);} 14748 14749 V201 = NULL; 14750 if (py_V201 == Py_None) { 14751 // We can either fail here or set V201 to NULL and rely on Ops 14752 // using tensors to handle the NULL case, but if they fail to do so 14753 // they'll end up with nasty segfaults, so this is public service. 14754 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 14755 { 14756 __failure = 202; 14757 if (!PyErr_Occurred()) { 14758 PyErr_SetString(PyExc_RuntimeError, 14759 "Unexpected error in an Op's C code. " 14760 "No Python exception was set."); 14761 } 14762 goto __label_202;} 14763 } 14764 if (!PyArray_Check(py_V201)) { 14765 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 14766 { 14767 __failure = 202; 14768 if (!PyErr_Occurred()) { 14769 PyErr_SetString(PyExc_RuntimeError, 14770 "Unexpected error in an Op's C code. " 14771 "No Python exception was set."); 14772 } 14773 goto __label_202;} 14774 } 14775 // We expect NPY_FLOAT64 14776 if (!PyArray_ISALIGNED((PyArrayObject*) py_V201)) { 14777 PyArrayObject * tmp = (PyArrayObject*) py_V201; 14778 PyErr_Format(PyExc_NotImplementedError, 14779 "expected an aligned array of type %ld " 14780 "(NPY_FLOAT64), got non-aligned array of type %ld" 14781 " with %ld dimensions, with 3 last dims " 14782 "%ld, %ld, %ld" 14783 " and 3 last strides %ld %ld, %ld.", 14784 (long int) NPY_FLOAT64, 14785 (long int) PyArray_TYPE((PyArrayObject*) py_V201), 14786 (long int) PyArray_NDIM(tmp), 14787 (long int) (PyArray_NDIM(tmp) >= 3 ? 14788 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 14789 (long int) (PyArray_NDIM(tmp) >= 2 ? 14790 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 14791 (long int) (PyArray_NDIM(tmp) >= 1 ? 14792 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 14793 (long int) (PyArray_NDIM(tmp) >= 3 ? 14794 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 14795 (long int) (PyArray_NDIM(tmp) >= 2 ? 14796 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 14797 (long int) (PyArray_NDIM(tmp) >= 1 ? 14798 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 14799 ); 14800 { 14801 __failure = 202; 14802 if (!PyErr_Occurred()) { 14803 PyErr_SetString(PyExc_RuntimeError, 14804 "Unexpected error in an Op's C code. " 14805 "No Python exception was set."); 14806 } 14807 goto __label_202;} 14808 } 14809 // This is a TypeError to be consistent with DEBUG_MODE 14810 // Note: DEBUG_MODE also tells the name of the container 14811 if (PyArray_TYPE((PyArrayObject*) py_V201) != NPY_FLOAT64) { 14812 PyErr_Format(PyExc_TypeError, 14813 "expected type_num %d (NPY_FLOAT64) got %d", 14814 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V201)); 14815 { 14816 __failure = 202; 14817 if (!PyErr_Occurred()) { 14818 PyErr_SetString(PyExc_RuntimeError, 14819 "Unexpected error in an Op's C code. " 14820 "No Python exception was set."); 14821 } 14822 goto __label_202;} 14823 } 14824 14825 V201 = (PyArrayObject*)(py_V201); 14826 Py_XINCREF(V201); 14827 14828 { 14829 14830 py_V203 = PyList_GET_ITEM(storage_V203, 0); 14831 {Py_XINCREF(py_V203);} 14832 14833 V203 = NULL; 14834 if (py_V203 == Py_None) { 14835 // We can either fail here or set V203 to NULL and rely on Ops 14836 // using tensors to handle the NULL case, but if they fail to do so 14837 // they'll end up with nasty segfaults, so this is public service. 14838 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 14839 { 14840 __failure = 204; 14841 if (!PyErr_Occurred()) { 14842 PyErr_SetString(PyExc_RuntimeError, 14843 "Unexpected error in an Op's C code. " 14844 "No Python exception was set."); 14845 } 14846 goto __label_204;} 14847 } 14848 if (!PyArray_Check(py_V203)) { 14849 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 14850 { 14851 __failure = 204; 14852 if (!PyErr_Occurred()) { 14853 PyErr_SetString(PyExc_RuntimeError, 14854 "Unexpected error in an Op's C code. " 14855 "No Python exception was set."); 14856 } 14857 goto __label_204;} 14858 } 14859 // We expect NPY_FLOAT64 14860 if (!PyArray_ISALIGNED((PyArrayObject*) py_V203)) { 14861 PyArrayObject * tmp = (PyArrayObject*) py_V203; 14862 PyErr_Format(PyExc_NotImplementedError, 14863 "expected an aligned array of type %ld " 14864 "(NPY_FLOAT64), got non-aligned array of type %ld" 14865 " with %ld dimensions, with 3 last dims " 14866 "%ld, %ld, %ld" 14867 " and 3 last strides %ld %ld, %ld.", 14868 (long int) NPY_FLOAT64, 14869 (long int) PyArray_TYPE((PyArrayObject*) py_V203), 14870 (long int) PyArray_NDIM(tmp), 14871 (long int) (PyArray_NDIM(tmp) >= 3 ? 14872 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 14873 (long int) (PyArray_NDIM(tmp) >= 2 ? 14874 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 14875 (long int) (PyArray_NDIM(tmp) >= 1 ? 14876 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 14877 (long int) (PyArray_NDIM(tmp) >= 3 ? 14878 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 14879 (long int) (PyArray_NDIM(tmp) >= 2 ? 14880 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 14881 (long int) (PyArray_NDIM(tmp) >= 1 ? 14882 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 14883 ); 14884 { 14885 __failure = 204; 14886 if (!PyErr_Occurred()) { 14887 PyErr_SetString(PyExc_RuntimeError, 14888 "Unexpected error in an Op's C code. " 14889 "No Python exception was set."); 14890 } 14891 goto __label_204;} 14892 } 14893 // This is a TypeError to be consistent with DEBUG_MODE 14894 // Note: DEBUG_MODE also tells the name of the container 14895 if (PyArray_TYPE((PyArrayObject*) py_V203) != NPY_FLOAT64) { 14896 PyErr_Format(PyExc_TypeError, 14897 "expected type_num %d (NPY_FLOAT64) got %d", 14898 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V203)); 14899 { 14900 __failure = 204; 14901 if (!PyErr_Occurred()) { 14902 PyErr_SetString(PyExc_RuntimeError, 14903 "Unexpected error in an Op's C code. " 14904 "No Python exception was set."); 14905 } 14906 goto __label_204;} 14907 } 14908 14909 V203 = (PyArrayObject*)(py_V203); 14910 Py_XINCREF(V203); 14911 14912 { 14913 14914 py_V205 = PyList_GET_ITEM(storage_V205, 0); 14915 {Py_XINCREF(py_V205);} 14916 14917 V205 = NULL; 14918 if (py_V205 == Py_None) { 14919 // We can either fail here or set V205 to NULL and rely on Ops 14920 // using tensors to handle the NULL case, but if they fail to do so 14921 // they'll end up with nasty segfaults, so this is public service. 14922 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 14923 { 14924 __failure = 206; 14925 if (!PyErr_Occurred()) { 14926 PyErr_SetString(PyExc_RuntimeError, 14927 "Unexpected error in an Op's C code. " 14928 "No Python exception was set."); 14929 } 14930 goto __label_206;} 14931 } 14932 if (!PyArray_Check(py_V205)) { 14933 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 14934 { 14935 __failure = 206; 14936 if (!PyErr_Occurred()) { 14937 PyErr_SetString(PyExc_RuntimeError, 14938 "Unexpected error in an Op's C code. " 14939 "No Python exception was set."); 14940 } 14941 goto __label_206;} 14942 } 14943 // We expect NPY_FLOAT64 14944 if (!PyArray_ISALIGNED((PyArrayObject*) py_V205)) { 14945 PyArrayObject * tmp = (PyArrayObject*) py_V205; 14946 PyErr_Format(PyExc_NotImplementedError, 14947 "expected an aligned array of type %ld " 14948 "(NPY_FLOAT64), got non-aligned array of type %ld" 14949 " with %ld dimensions, with 3 last dims " 14950 "%ld, %ld, %ld" 14951 " and 3 last strides %ld %ld, %ld.", 14952 (long int) NPY_FLOAT64, 14953 (long int) PyArray_TYPE((PyArrayObject*) py_V205), 14954 (long int) PyArray_NDIM(tmp), 14955 (long int) (PyArray_NDIM(tmp) >= 3 ? 14956 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 14957 (long int) (PyArray_NDIM(tmp) >= 2 ? 14958 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 14959 (long int) (PyArray_NDIM(tmp) >= 1 ? 14960 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 14961 (long int) (PyArray_NDIM(tmp) >= 3 ? 14962 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 14963 (long int) (PyArray_NDIM(tmp) >= 2 ? 14964 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 14965 (long int) (PyArray_NDIM(tmp) >= 1 ? 14966 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 14967 ); 14968 { 14969 __failure = 206; 14970 if (!PyErr_Occurred()) { 14971 PyErr_SetString(PyExc_RuntimeError, 14972 "Unexpected error in an Op's C code. " 14973 "No Python exception was set."); 14974 } 14975 goto __label_206;} 14976 } 14977 // This is a TypeError to be consistent with DEBUG_MODE 14978 // Note: DEBUG_MODE also tells the name of the container 14979 if (PyArray_TYPE((PyArrayObject*) py_V205) != NPY_FLOAT64) { 14980 PyErr_Format(PyExc_TypeError, 14981 "expected type_num %d (NPY_FLOAT64) got %d", 14982 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V205)); 14983 { 14984 __failure = 206; 14985 if (!PyErr_Occurred()) { 14986 PyErr_SetString(PyExc_RuntimeError, 14987 "Unexpected error in an Op's C code. " 14988 "No Python exception was set."); 14989 } 14990 goto __label_206;} 14991 } 14992 14993 V205 = (PyArrayObject*)(py_V205); 14994 Py_XINCREF(V205); 14995 14996 { 14997 14998 py_V207 = PyList_GET_ITEM(storage_V207, 0); 14999 {Py_XINCREF(py_V207);} 15000 15001 V207 = NULL; 15002 if (py_V207 == Py_None) { 15003 // We can either fail here or set V207 to NULL and rely on Ops 15004 // using tensors to handle the NULL case, but if they fail to do so 15005 // they'll end up with nasty segfaults, so this is public service. 15006 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 15007 { 15008 __failure = 208; 15009 if (!PyErr_Occurred()) { 15010 PyErr_SetString(PyExc_RuntimeError, 15011 "Unexpected error in an Op's C code. " 15012 "No Python exception was set."); 15013 } 15014 goto __label_208;} 15015 } 15016 if (!PyArray_Check(py_V207)) { 15017 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 15018 { 15019 __failure = 208; 15020 if (!PyErr_Occurred()) { 15021 PyErr_SetString(PyExc_RuntimeError, 15022 "Unexpected error in an Op's C code. " 15023 "No Python exception was set."); 15024 } 15025 goto __label_208;} 15026 } 15027 // We expect NPY_FLOAT64 15028 if (!PyArray_ISALIGNED((PyArrayObject*) py_V207)) { 15029 PyArrayObject * tmp = (PyArrayObject*) py_V207; 15030 PyErr_Format(PyExc_NotImplementedError, 15031 "expected an aligned array of type %ld " 15032 "(NPY_FLOAT64), got non-aligned array of type %ld" 15033 " with %ld dimensions, with 3 last dims " 15034 "%ld, %ld, %ld" 15035 " and 3 last strides %ld %ld, %ld.", 15036 (long int) NPY_FLOAT64, 15037 (long int) PyArray_TYPE((PyArrayObject*) py_V207), 15038 (long int) PyArray_NDIM(tmp), 15039 (long int) (PyArray_NDIM(tmp) >= 3 ? 15040 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 15041 (long int) (PyArray_NDIM(tmp) >= 2 ? 15042 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 15043 (long int) (PyArray_NDIM(tmp) >= 1 ? 15044 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 15045 (long int) (PyArray_NDIM(tmp) >= 3 ? 15046 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 15047 (long int) (PyArray_NDIM(tmp) >= 2 ? 15048 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 15049 (long int) (PyArray_NDIM(tmp) >= 1 ? 15050 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 15051 ); 15052 { 15053 __failure = 208; 15054 if (!PyErr_Occurred()) { 15055 PyErr_SetString(PyExc_RuntimeError, 15056 "Unexpected error in an Op's C code. " 15057 "No Python exception was set."); 15058 } 15059 goto __label_208;} 15060 } 15061 // This is a TypeError to be consistent with DEBUG_MODE 15062 // Note: DEBUG_MODE also tells the name of the container 15063 if (PyArray_TYPE((PyArrayObject*) py_V207) != NPY_FLOAT64) { 15064 PyErr_Format(PyExc_TypeError, 15065 "expected type_num %d (NPY_FLOAT64) got %d", 15066 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V207)); 15067 { 15068 __failure = 208; 15069 if (!PyErr_Occurred()) { 15070 PyErr_SetString(PyExc_RuntimeError, 15071 "Unexpected error in an Op's C code. " 15072 "No Python exception was set."); 15073 } 15074 goto __label_208;} 15075 } 15076 15077 V207 = (PyArrayObject*)(py_V207); 15078 Py_XINCREF(V207); 15079 15080 { 15081 15082 py_V209 = PyList_GET_ITEM(storage_V209, 0); 15083 {Py_XINCREF(py_V209);} 15084 15085 V209 = NULL; 15086 if (py_V209 == Py_None) { 15087 // We can either fail here or set V209 to NULL and rely on Ops 15088 // using tensors to handle the NULL case, but if they fail to do so 15089 // they'll end up with nasty segfaults, so this is public service. 15090 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 15091 { 15092 __failure = 210; 15093 if (!PyErr_Occurred()) { 15094 PyErr_SetString(PyExc_RuntimeError, 15095 "Unexpected error in an Op's C code. " 15096 "No Python exception was set."); 15097 } 15098 goto __label_210;} 15099 } 15100 if (!PyArray_Check(py_V209)) { 15101 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 15102 { 15103 __failure = 210; 15104 if (!PyErr_Occurred()) { 15105 PyErr_SetString(PyExc_RuntimeError, 15106 "Unexpected error in an Op's C code. " 15107 "No Python exception was set."); 15108 } 15109 goto __label_210;} 15110 } 15111 // We expect NPY_FLOAT64 15112 if (!PyArray_ISALIGNED((PyArrayObject*) py_V209)) { 15113 PyArrayObject * tmp = (PyArrayObject*) py_V209; 15114 PyErr_Format(PyExc_NotImplementedError, 15115 "expected an aligned array of type %ld " 15116 "(NPY_FLOAT64), got non-aligned array of type %ld" 15117 " with %ld dimensions, with 3 last dims " 15118 "%ld, %ld, %ld" 15119 " and 3 last strides %ld %ld, %ld.", 15120 (long int) NPY_FLOAT64, 15121 (long int) PyArray_TYPE((PyArrayObject*) py_V209), 15122 (long int) PyArray_NDIM(tmp), 15123 (long int) (PyArray_NDIM(tmp) >= 3 ? 15124 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 15125 (long int) (PyArray_NDIM(tmp) >= 2 ? 15126 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 15127 (long int) (PyArray_NDIM(tmp) >= 1 ? 15128 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 15129 (long int) (PyArray_NDIM(tmp) >= 3 ? 15130 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 15131 (long int) (PyArray_NDIM(tmp) >= 2 ? 15132 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 15133 (long int) (PyArray_NDIM(tmp) >= 1 ? 15134 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 15135 ); 15136 { 15137 __failure = 210; 15138 if (!PyErr_Occurred()) { 15139 PyErr_SetString(PyExc_RuntimeError, 15140 "Unexpected error in an Op's C code. " 15141 "No Python exception was set."); 15142 } 15143 goto __label_210;} 15144 } 15145 // This is a TypeError to be consistent with DEBUG_MODE 15146 // Note: DEBUG_MODE also tells the name of the container 15147 if (PyArray_TYPE((PyArrayObject*) py_V209) != NPY_FLOAT64) { 15148 PyErr_Format(PyExc_TypeError, 15149 "expected type_num %d (NPY_FLOAT64) got %d", 15150 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V209)); 15151 { 15152 __failure = 210; 15153 if (!PyErr_Occurred()) { 15154 PyErr_SetString(PyExc_RuntimeError, 15155 "Unexpected error in an Op's C code. " 15156 "No Python exception was set."); 15157 } 15158 goto __label_210;} 15159 } 15160 15161 V209 = (PyArrayObject*)(py_V209); 15162 Py_XINCREF(V209); 15163 15164 { 15165 15166 py_V211 = PyList_GET_ITEM(storage_V211, 0); 15167 {Py_XINCREF(py_V211);} 15168 15169 V211 = NULL; 15170 if (py_V211 == Py_None) { 15171 // We can either fail here or set V211 to NULL and rely on Ops 15172 // using tensors to handle the NULL case, but if they fail to do so 15173 // they'll end up with nasty segfaults, so this is public service. 15174 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 15175 { 15176 __failure = 212; 15177 if (!PyErr_Occurred()) { 15178 PyErr_SetString(PyExc_RuntimeError, 15179 "Unexpected error in an Op's C code. " 15180 "No Python exception was set."); 15181 } 15182 goto __label_212;} 15183 } 15184 if (!PyArray_Check(py_V211)) { 15185 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 15186 { 15187 __failure = 212; 15188 if (!PyErr_Occurred()) { 15189 PyErr_SetString(PyExc_RuntimeError, 15190 "Unexpected error in an Op's C code. " 15191 "No Python exception was set."); 15192 } 15193 goto __label_212;} 15194 } 15195 // We expect NPY_FLOAT64 15196 if (!PyArray_ISALIGNED((PyArrayObject*) py_V211)) { 15197 PyArrayObject * tmp = (PyArrayObject*) py_V211; 15198 PyErr_Format(PyExc_NotImplementedError, 15199 "expected an aligned array of type %ld " 15200 "(NPY_FLOAT64), got non-aligned array of type %ld" 15201 " with %ld dimensions, with 3 last dims " 15202 "%ld, %ld, %ld" 15203 " and 3 last strides %ld %ld, %ld.", 15204 (long int) NPY_FLOAT64, 15205 (long int) PyArray_TYPE((PyArrayObject*) py_V211), 15206 (long int) PyArray_NDIM(tmp), 15207 (long int) (PyArray_NDIM(tmp) >= 3 ? 15208 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 15209 (long int) (PyArray_NDIM(tmp) >= 2 ? 15210 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 15211 (long int) (PyArray_NDIM(tmp) >= 1 ? 15212 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 15213 (long int) (PyArray_NDIM(tmp) >= 3 ? 15214 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 15215 (long int) (PyArray_NDIM(tmp) >= 2 ? 15216 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 15217 (long int) (PyArray_NDIM(tmp) >= 1 ? 15218 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 15219 ); 15220 { 15221 __failure = 212; 15222 if (!PyErr_Occurred()) { 15223 PyErr_SetString(PyExc_RuntimeError, 15224 "Unexpected error in an Op's C code. " 15225 "No Python exception was set."); 15226 } 15227 goto __label_212;} 15228 } 15229 // This is a TypeError to be consistent with DEBUG_MODE 15230 // Note: DEBUG_MODE also tells the name of the container 15231 if (PyArray_TYPE((PyArrayObject*) py_V211) != NPY_FLOAT64) { 15232 PyErr_Format(PyExc_TypeError, 15233 "expected type_num %d (NPY_FLOAT64) got %d", 15234 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V211)); 15235 { 15236 __failure = 212; 15237 if (!PyErr_Occurred()) { 15238 PyErr_SetString(PyExc_RuntimeError, 15239 "Unexpected error in an Op's C code. " 15240 "No Python exception was set."); 15241 } 15242 goto __label_212;} 15243 } 15244 15245 V211 = (PyArrayObject*)(py_V211); 15246 Py_XINCREF(V211); 15247 15248 { 15249 15250 py_V213 = PyList_GET_ITEM(storage_V213, 0); 15251 {Py_XINCREF(py_V213);} 15252 15253 V213 = NULL; 15254 if (py_V213 == Py_None) { 15255 // We can either fail here or set V213 to NULL and rely on Ops 15256 // using tensors to handle the NULL case, but if they fail to do so 15257 // they'll end up with nasty segfaults, so this is public service. 15258 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 15259 { 15260 __failure = 214; 15261 if (!PyErr_Occurred()) { 15262 PyErr_SetString(PyExc_RuntimeError, 15263 "Unexpected error in an Op's C code. " 15264 "No Python exception was set."); 15265 } 15266 goto __label_214;} 15267 } 15268 if (!PyArray_Check(py_V213)) { 15269 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 15270 { 15271 __failure = 214; 15272 if (!PyErr_Occurred()) { 15273 PyErr_SetString(PyExc_RuntimeError, 15274 "Unexpected error in an Op's C code. " 15275 "No Python exception was set."); 15276 } 15277 goto __label_214;} 15278 } 15279 // We expect NPY_FLOAT64 15280 if (!PyArray_ISALIGNED((PyArrayObject*) py_V213)) { 15281 PyArrayObject * tmp = (PyArrayObject*) py_V213; 15282 PyErr_Format(PyExc_NotImplementedError, 15283 "expected an aligned array of type %ld " 15284 "(NPY_FLOAT64), got non-aligned array of type %ld" 15285 " with %ld dimensions, with 3 last dims " 15286 "%ld, %ld, %ld" 15287 " and 3 last strides %ld %ld, %ld.", 15288 (long int) NPY_FLOAT64, 15289 (long int) PyArray_TYPE((PyArrayObject*) py_V213), 15290 (long int) PyArray_NDIM(tmp), 15291 (long int) (PyArray_NDIM(tmp) >= 3 ? 15292 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 15293 (long int) (PyArray_NDIM(tmp) >= 2 ? 15294 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 15295 (long int) (PyArray_NDIM(tmp) >= 1 ? 15296 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 15297 (long int) (PyArray_NDIM(tmp) >= 3 ? 15298 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 15299 (long int) (PyArray_NDIM(tmp) >= 2 ? 15300 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 15301 (long int) (PyArray_NDIM(tmp) >= 1 ? 15302 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 15303 ); 15304 { 15305 __failure = 214; 15306 if (!PyErr_Occurred()) { 15307 PyErr_SetString(PyExc_RuntimeError, 15308 "Unexpected error in an Op's C code. " 15309 "No Python exception was set."); 15310 } 15311 goto __label_214;} 15312 } 15313 // This is a TypeError to be consistent with DEBUG_MODE 15314 // Note: DEBUG_MODE also tells the name of the container 15315 if (PyArray_TYPE((PyArrayObject*) py_V213) != NPY_FLOAT64) { 15316 PyErr_Format(PyExc_TypeError, 15317 "expected type_num %d (NPY_FLOAT64) got %d", 15318 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V213)); 15319 { 15320 __failure = 214; 15321 if (!PyErr_Occurred()) { 15322 PyErr_SetString(PyExc_RuntimeError, 15323 "Unexpected error in an Op's C code. " 15324 "No Python exception was set."); 15325 } 15326 goto __label_214;} 15327 } 15328 15329 V213 = (PyArrayObject*)(py_V213); 15330 Py_XINCREF(V213); 15331 15332 { 15333 15334 py_V215 = PyList_GET_ITEM(storage_V215, 0); 15335 {Py_XINCREF(py_V215);} 15336 15337 V215 = NULL; 15338 if (py_V215 == Py_None) { 15339 // We can either fail here or set V215 to NULL and rely on Ops 15340 // using tensors to handle the NULL case, but if they fail to do so 15341 // they'll end up with nasty segfaults, so this is public service. 15342 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 15343 { 15344 __failure = 216; 15345 if (!PyErr_Occurred()) { 15346 PyErr_SetString(PyExc_RuntimeError, 15347 "Unexpected error in an Op's C code. " 15348 "No Python exception was set."); 15349 } 15350 goto __label_216;} 15351 } 15352 if (!PyArray_Check(py_V215)) { 15353 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 15354 { 15355 __failure = 216; 15356 if (!PyErr_Occurred()) { 15357 PyErr_SetString(PyExc_RuntimeError, 15358 "Unexpected error in an Op's C code. " 15359 "No Python exception was set."); 15360 } 15361 goto __label_216;} 15362 } 15363 // We expect NPY_FLOAT64 15364 if (!PyArray_ISALIGNED((PyArrayObject*) py_V215)) { 15365 PyArrayObject * tmp = (PyArrayObject*) py_V215; 15366 PyErr_Format(PyExc_NotImplementedError, 15367 "expected an aligned array of type %ld " 15368 "(NPY_FLOAT64), got non-aligned array of type %ld" 15369 " with %ld dimensions, with 3 last dims " 15370 "%ld, %ld, %ld" 15371 " and 3 last strides %ld %ld, %ld.", 15372 (long int) NPY_FLOAT64, 15373 (long int) PyArray_TYPE((PyArrayObject*) py_V215), 15374 (long int) PyArray_NDIM(tmp), 15375 (long int) (PyArray_NDIM(tmp) >= 3 ? 15376 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 15377 (long int) (PyArray_NDIM(tmp) >= 2 ? 15378 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 15379 (long int) (PyArray_NDIM(tmp) >= 1 ? 15380 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 15381 (long int) (PyArray_NDIM(tmp) >= 3 ? 15382 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 15383 (long int) (PyArray_NDIM(tmp) >= 2 ? 15384 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 15385 (long int) (PyArray_NDIM(tmp) >= 1 ? 15386 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 15387 ); 15388 { 15389 __failure = 216; 15390 if (!PyErr_Occurred()) { 15391 PyErr_SetString(PyExc_RuntimeError, 15392 "Unexpected error in an Op's C code. " 15393 "No Python exception was set."); 15394 } 15395 goto __label_216;} 15396 } 15397 // This is a TypeError to be consistent with DEBUG_MODE 15398 // Note: DEBUG_MODE also tells the name of the container 15399 if (PyArray_TYPE((PyArrayObject*) py_V215) != NPY_FLOAT64) { 15400 PyErr_Format(PyExc_TypeError, 15401 "expected type_num %d (NPY_FLOAT64) got %d", 15402 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V215)); 15403 { 15404 __failure = 216; 15405 if (!PyErr_Occurred()) { 15406 PyErr_SetString(PyExc_RuntimeError, 15407 "Unexpected error in an Op's C code. " 15408 "No Python exception was set."); 15409 } 15410 goto __label_216;} 15411 } 15412 15413 V215 = (PyArrayObject*)(py_V215); 15414 Py_XINCREF(V215); 15415 15416 { 15417 15418 py_V217 = PyList_GET_ITEM(storage_V217, 0); 15419 {Py_XINCREF(py_V217);} 15420 15421 V217 = NULL; 15422 if (py_V217 == Py_None) { 15423 // We can either fail here or set V217 to NULL and rely on Ops 15424 // using tensors to handle the NULL case, but if they fail to do so 15425 // they'll end up with nasty segfaults, so this is public service. 15426 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 15427 { 15428 __failure = 218; 15429 if (!PyErr_Occurred()) { 15430 PyErr_SetString(PyExc_RuntimeError, 15431 "Unexpected error in an Op's C code. " 15432 "No Python exception was set."); 15433 } 15434 goto __label_218;} 15435 } 15436 if (!PyArray_Check(py_V217)) { 15437 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 15438 { 15439 __failure = 218; 15440 if (!PyErr_Occurred()) { 15441 PyErr_SetString(PyExc_RuntimeError, 15442 "Unexpected error in an Op's C code. " 15443 "No Python exception was set."); 15444 } 15445 goto __label_218;} 15446 } 15447 // We expect NPY_FLOAT64 15448 if (!PyArray_ISALIGNED((PyArrayObject*) py_V217)) { 15449 PyArrayObject * tmp = (PyArrayObject*) py_V217; 15450 PyErr_Format(PyExc_NotImplementedError, 15451 "expected an aligned array of type %ld " 15452 "(NPY_FLOAT64), got non-aligned array of type %ld" 15453 " with %ld dimensions, with 3 last dims " 15454 "%ld, %ld, %ld" 15455 " and 3 last strides %ld %ld, %ld.", 15456 (long int) NPY_FLOAT64, 15457 (long int) PyArray_TYPE((PyArrayObject*) py_V217), 15458 (long int) PyArray_NDIM(tmp), 15459 (long int) (PyArray_NDIM(tmp) >= 3 ? 15460 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 15461 (long int) (PyArray_NDIM(tmp) >= 2 ? 15462 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 15463 (long int) (PyArray_NDIM(tmp) >= 1 ? 15464 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 15465 (long int) (PyArray_NDIM(tmp) >= 3 ? 15466 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 15467 (long int) (PyArray_NDIM(tmp) >= 2 ? 15468 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 15469 (long int) (PyArray_NDIM(tmp) >= 1 ? 15470 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 15471 ); 15472 { 15473 __failure = 218; 15474 if (!PyErr_Occurred()) { 15475 PyErr_SetString(PyExc_RuntimeError, 15476 "Unexpected error in an Op's C code. " 15477 "No Python exception was set."); 15478 } 15479 goto __label_218;} 15480 } 15481 // This is a TypeError to be consistent with DEBUG_MODE 15482 // Note: DEBUG_MODE also tells the name of the container 15483 if (PyArray_TYPE((PyArrayObject*) py_V217) != NPY_FLOAT64) { 15484 PyErr_Format(PyExc_TypeError, 15485 "expected type_num %d (NPY_FLOAT64) got %d", 15486 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V217)); 15487 { 15488 __failure = 218; 15489 if (!PyErr_Occurred()) { 15490 PyErr_SetString(PyExc_RuntimeError, 15491 "Unexpected error in an Op's C code. " 15492 "No Python exception was set."); 15493 } 15494 goto __label_218;} 15495 } 15496 15497 V217 = (PyArrayObject*)(py_V217); 15498 Py_XINCREF(V217); 15499 15500 { 15501 15502 py_V219 = PyList_GET_ITEM(storage_V219, 0); 15503 {Py_XINCREF(py_V219);} 15504 15505 V219 = NULL; 15506 if (py_V219 == Py_None) { 15507 // We can either fail here or set V219 to NULL and rely on Ops 15508 // using tensors to handle the NULL case, but if they fail to do so 15509 // they'll end up with nasty segfaults, so this is public service. 15510 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 15511 { 15512 __failure = 220; 15513 if (!PyErr_Occurred()) { 15514 PyErr_SetString(PyExc_RuntimeError, 15515 "Unexpected error in an Op's C code. " 15516 "No Python exception was set."); 15517 } 15518 goto __label_220;} 15519 } 15520 if (!PyArray_Check(py_V219)) { 15521 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 15522 { 15523 __failure = 220; 15524 if (!PyErr_Occurred()) { 15525 PyErr_SetString(PyExc_RuntimeError, 15526 "Unexpected error in an Op's C code. " 15527 "No Python exception was set."); 15528 } 15529 goto __label_220;} 15530 } 15531 // We expect NPY_FLOAT64 15532 if (!PyArray_ISALIGNED((PyArrayObject*) py_V219)) { 15533 PyArrayObject * tmp = (PyArrayObject*) py_V219; 15534 PyErr_Format(PyExc_NotImplementedError, 15535 "expected an aligned array of type %ld " 15536 "(NPY_FLOAT64), got non-aligned array of type %ld" 15537 " with %ld dimensions, with 3 last dims " 15538 "%ld, %ld, %ld" 15539 " and 3 last strides %ld %ld, %ld.", 15540 (long int) NPY_FLOAT64, 15541 (long int) PyArray_TYPE((PyArrayObject*) py_V219), 15542 (long int) PyArray_NDIM(tmp), 15543 (long int) (PyArray_NDIM(tmp) >= 3 ? 15544 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 15545 (long int) (PyArray_NDIM(tmp) >= 2 ? 15546 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 15547 (long int) (PyArray_NDIM(tmp) >= 1 ? 15548 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 15549 (long int) (PyArray_NDIM(tmp) >= 3 ? 15550 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 15551 (long int) (PyArray_NDIM(tmp) >= 2 ? 15552 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 15553 (long int) (PyArray_NDIM(tmp) >= 1 ? 15554 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 15555 ); 15556 { 15557 __failure = 220; 15558 if (!PyErr_Occurred()) { 15559 PyErr_SetString(PyExc_RuntimeError, 15560 "Unexpected error in an Op's C code. " 15561 "No Python exception was set."); 15562 } 15563 goto __label_220;} 15564 } 15565 // This is a TypeError to be consistent with DEBUG_MODE 15566 // Note: DEBUG_MODE also tells the name of the container 15567 if (PyArray_TYPE((PyArrayObject*) py_V219) != NPY_FLOAT64) { 15568 PyErr_Format(PyExc_TypeError, 15569 "expected type_num %d (NPY_FLOAT64) got %d", 15570 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V219)); 15571 { 15572 __failure = 220; 15573 if (!PyErr_Occurred()) { 15574 PyErr_SetString(PyExc_RuntimeError, 15575 "Unexpected error in an Op's C code. " 15576 "No Python exception was set."); 15577 } 15578 goto __label_220;} 15579 } 15580 15581 V219 = (PyArrayObject*)(py_V219); 15582 Py_XINCREF(V219); 15583 15584 { 15585 15586 py_V221 = PyList_GET_ITEM(storage_V221, 0); 15587 {Py_XINCREF(py_V221);} 15588 15589 V221 = NULL; 15590 if (py_V221 == Py_None) { 15591 // We can either fail here or set V221 to NULL and rely on Ops 15592 // using tensors to handle the NULL case, but if they fail to do so 15593 // they'll end up with nasty segfaults, so this is public service. 15594 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 15595 { 15596 __failure = 222; 15597 if (!PyErr_Occurred()) { 15598 PyErr_SetString(PyExc_RuntimeError, 15599 "Unexpected error in an Op's C code. " 15600 "No Python exception was set."); 15601 } 15602 goto __label_222;} 15603 } 15604 if (!PyArray_Check(py_V221)) { 15605 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 15606 { 15607 __failure = 222; 15608 if (!PyErr_Occurred()) { 15609 PyErr_SetString(PyExc_RuntimeError, 15610 "Unexpected error in an Op's C code. " 15611 "No Python exception was set."); 15612 } 15613 goto __label_222;} 15614 } 15615 // We expect NPY_FLOAT64 15616 if (!PyArray_ISALIGNED((PyArrayObject*) py_V221)) { 15617 PyArrayObject * tmp = (PyArrayObject*) py_V221; 15618 PyErr_Format(PyExc_NotImplementedError, 15619 "expected an aligned array of type %ld " 15620 "(NPY_FLOAT64), got non-aligned array of type %ld" 15621 " with %ld dimensions, with 3 last dims " 15622 "%ld, %ld, %ld" 15623 " and 3 last strides %ld %ld, %ld.", 15624 (long int) NPY_FLOAT64, 15625 (long int) PyArray_TYPE((PyArrayObject*) py_V221), 15626 (long int) PyArray_NDIM(tmp), 15627 (long int) (PyArray_NDIM(tmp) >= 3 ? 15628 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 15629 (long int) (PyArray_NDIM(tmp) >= 2 ? 15630 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 15631 (long int) (PyArray_NDIM(tmp) >= 1 ? 15632 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 15633 (long int) (PyArray_NDIM(tmp) >= 3 ? 15634 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 15635 (long int) (PyArray_NDIM(tmp) >= 2 ? 15636 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 15637 (long int) (PyArray_NDIM(tmp) >= 1 ? 15638 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 15639 ); 15640 { 15641 __failure = 222; 15642 if (!PyErr_Occurred()) { 15643 PyErr_SetString(PyExc_RuntimeError, 15644 "Unexpected error in an Op's C code. " 15645 "No Python exception was set."); 15646 } 15647 goto __label_222;} 15648 } 15649 // This is a TypeError to be consistent with DEBUG_MODE 15650 // Note: DEBUG_MODE also tells the name of the container 15651 if (PyArray_TYPE((PyArrayObject*) py_V221) != NPY_FLOAT64) { 15652 PyErr_Format(PyExc_TypeError, 15653 "expected type_num %d (NPY_FLOAT64) got %d", 15654 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V221)); 15655 { 15656 __failure = 222; 15657 if (!PyErr_Occurred()) { 15658 PyErr_SetString(PyExc_RuntimeError, 15659 "Unexpected error in an Op's C code. " 15660 "No Python exception was set."); 15661 } 15662 goto __label_222;} 15663 } 15664 15665 V221 = (PyArrayObject*)(py_V221); 15666 Py_XINCREF(V221); 15667 15668 { 15669 15670 py_V223 = PyList_GET_ITEM(storage_V223, 0); 15671 {Py_XINCREF(py_V223);} 15672 15673 V223 = NULL; 15674 if (py_V223 == Py_None) { 15675 // We can either fail here or set V223 to NULL and rely on Ops 15676 // using tensors to handle the NULL case, but if they fail to do so 15677 // they'll end up with nasty segfaults, so this is public service. 15678 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 15679 { 15680 __failure = 224; 15681 if (!PyErr_Occurred()) { 15682 PyErr_SetString(PyExc_RuntimeError, 15683 "Unexpected error in an Op's C code. " 15684 "No Python exception was set."); 15685 } 15686 goto __label_224;} 15687 } 15688 if (!PyArray_Check(py_V223)) { 15689 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 15690 { 15691 __failure = 224; 15692 if (!PyErr_Occurred()) { 15693 PyErr_SetString(PyExc_RuntimeError, 15694 "Unexpected error in an Op's C code. " 15695 "No Python exception was set."); 15696 } 15697 goto __label_224;} 15698 } 15699 // We expect NPY_FLOAT64 15700 if (!PyArray_ISALIGNED((PyArrayObject*) py_V223)) { 15701 PyArrayObject * tmp = (PyArrayObject*) py_V223; 15702 PyErr_Format(PyExc_NotImplementedError, 15703 "expected an aligned array of type %ld " 15704 "(NPY_FLOAT64), got non-aligned array of type %ld" 15705 " with %ld dimensions, with 3 last dims " 15706 "%ld, %ld, %ld" 15707 " and 3 last strides %ld %ld, %ld.", 15708 (long int) NPY_FLOAT64, 15709 (long int) PyArray_TYPE((PyArrayObject*) py_V223), 15710 (long int) PyArray_NDIM(tmp), 15711 (long int) (PyArray_NDIM(tmp) >= 3 ? 15712 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 15713 (long int) (PyArray_NDIM(tmp) >= 2 ? 15714 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 15715 (long int) (PyArray_NDIM(tmp) >= 1 ? 15716 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 15717 (long int) (PyArray_NDIM(tmp) >= 3 ? 15718 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 15719 (long int) (PyArray_NDIM(tmp) >= 2 ? 15720 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 15721 (long int) (PyArray_NDIM(tmp) >= 1 ? 15722 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 15723 ); 15724 { 15725 __failure = 224; 15726 if (!PyErr_Occurred()) { 15727 PyErr_SetString(PyExc_RuntimeError, 15728 "Unexpected error in an Op's C code. " 15729 "No Python exception was set."); 15730 } 15731 goto __label_224;} 15732 } 15733 // This is a TypeError to be consistent with DEBUG_MODE 15734 // Note: DEBUG_MODE also tells the name of the container 15735 if (PyArray_TYPE((PyArrayObject*) py_V223) != NPY_FLOAT64) { 15736 PyErr_Format(PyExc_TypeError, 15737 "expected type_num %d (NPY_FLOAT64) got %d", 15738 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V223)); 15739 { 15740 __failure = 224; 15741 if (!PyErr_Occurred()) { 15742 PyErr_SetString(PyExc_RuntimeError, 15743 "Unexpected error in an Op's C code. " 15744 "No Python exception was set."); 15745 } 15746 goto __label_224;} 15747 } 15748 15749 V223 = (PyArrayObject*)(py_V223); 15750 Py_XINCREF(V223); 15751 15752 { 15753 15754 py_V225 = PyList_GET_ITEM(storage_V225, 0); 15755 {Py_XINCREF(py_V225);} 15756 15757 V225 = NULL; 15758 if (py_V225 == Py_None) { 15759 // We can either fail here or set V225 to NULL and rely on Ops 15760 // using tensors to handle the NULL case, but if they fail to do so 15761 // they'll end up with nasty segfaults, so this is public service. 15762 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 15763 { 15764 __failure = 226; 15765 if (!PyErr_Occurred()) { 15766 PyErr_SetString(PyExc_RuntimeError, 15767 "Unexpected error in an Op's C code. " 15768 "No Python exception was set."); 15769 } 15770 goto __label_226;} 15771 } 15772 if (!PyArray_Check(py_V225)) { 15773 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 15774 { 15775 __failure = 226; 15776 if (!PyErr_Occurred()) { 15777 PyErr_SetString(PyExc_RuntimeError, 15778 "Unexpected error in an Op's C code. " 15779 "No Python exception was set."); 15780 } 15781 goto __label_226;} 15782 } 15783 // We expect NPY_FLOAT64 15784 if (!PyArray_ISALIGNED((PyArrayObject*) py_V225)) { 15785 PyArrayObject * tmp = (PyArrayObject*) py_V225; 15786 PyErr_Format(PyExc_NotImplementedError, 15787 "expected an aligned array of type %ld " 15788 "(NPY_FLOAT64), got non-aligned array of type %ld" 15789 " with %ld dimensions, with 3 last dims " 15790 "%ld, %ld, %ld" 15791 " and 3 last strides %ld %ld, %ld.", 15792 (long int) NPY_FLOAT64, 15793 (long int) PyArray_TYPE((PyArrayObject*) py_V225), 15794 (long int) PyArray_NDIM(tmp), 15795 (long int) (PyArray_NDIM(tmp) >= 3 ? 15796 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 15797 (long int) (PyArray_NDIM(tmp) >= 2 ? 15798 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 15799 (long int) (PyArray_NDIM(tmp) >= 1 ? 15800 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 15801 (long int) (PyArray_NDIM(tmp) >= 3 ? 15802 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 15803 (long int) (PyArray_NDIM(tmp) >= 2 ? 15804 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 15805 (long int) (PyArray_NDIM(tmp) >= 1 ? 15806 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 15807 ); 15808 { 15809 __failure = 226; 15810 if (!PyErr_Occurred()) { 15811 PyErr_SetString(PyExc_RuntimeError, 15812 "Unexpected error in an Op's C code. " 15813 "No Python exception was set."); 15814 } 15815 goto __label_226;} 15816 } 15817 // This is a TypeError to be consistent with DEBUG_MODE 15818 // Note: DEBUG_MODE also tells the name of the container 15819 if (PyArray_TYPE((PyArrayObject*) py_V225) != NPY_FLOAT64) { 15820 PyErr_Format(PyExc_TypeError, 15821 "expected type_num %d (NPY_FLOAT64) got %d", 15822 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V225)); 15823 { 15824 __failure = 226; 15825 if (!PyErr_Occurred()) { 15826 PyErr_SetString(PyExc_RuntimeError, 15827 "Unexpected error in an Op's C code. " 15828 "No Python exception was set."); 15829 } 15830 goto __label_226;} 15831 } 15832 15833 V225 = (PyArrayObject*)(py_V225); 15834 Py_XINCREF(V225); 15835 15836 { 15837 15838 py_V227 = PyList_GET_ITEM(storage_V227, 0); 15839 {Py_XINCREF(py_V227);} 15840 15841 V227 = NULL; 15842 if (py_V227 == Py_None) { 15843 // We can either fail here or set V227 to NULL and rely on Ops 15844 // using tensors to handle the NULL case, but if they fail to do so 15845 // they'll end up with nasty segfaults, so this is public service. 15846 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 15847 { 15848 __failure = 228; 15849 if (!PyErr_Occurred()) { 15850 PyErr_SetString(PyExc_RuntimeError, 15851 "Unexpected error in an Op's C code. " 15852 "No Python exception was set."); 15853 } 15854 goto __label_228;} 15855 } 15856 if (!PyArray_Check(py_V227)) { 15857 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 15858 { 15859 __failure = 228; 15860 if (!PyErr_Occurred()) { 15861 PyErr_SetString(PyExc_RuntimeError, 15862 "Unexpected error in an Op's C code. " 15863 "No Python exception was set."); 15864 } 15865 goto __label_228;} 15866 } 15867 // We expect NPY_FLOAT64 15868 if (!PyArray_ISALIGNED((PyArrayObject*) py_V227)) { 15869 PyArrayObject * tmp = (PyArrayObject*) py_V227; 15870 PyErr_Format(PyExc_NotImplementedError, 15871 "expected an aligned array of type %ld " 15872 "(NPY_FLOAT64), got non-aligned array of type %ld" 15873 " with %ld dimensions, with 3 last dims " 15874 "%ld, %ld, %ld" 15875 " and 3 last strides %ld %ld, %ld.", 15876 (long int) NPY_FLOAT64, 15877 (long int) PyArray_TYPE((PyArrayObject*) py_V227), 15878 (long int) PyArray_NDIM(tmp), 15879 (long int) (PyArray_NDIM(tmp) >= 3 ? 15880 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 15881 (long int) (PyArray_NDIM(tmp) >= 2 ? 15882 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 15883 (long int) (PyArray_NDIM(tmp) >= 1 ? 15884 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 15885 (long int) (PyArray_NDIM(tmp) >= 3 ? 15886 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 15887 (long int) (PyArray_NDIM(tmp) >= 2 ? 15888 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 15889 (long int) (PyArray_NDIM(tmp) >= 1 ? 15890 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 15891 ); 15892 { 15893 __failure = 228; 15894 if (!PyErr_Occurred()) { 15895 PyErr_SetString(PyExc_RuntimeError, 15896 "Unexpected error in an Op's C code. " 15897 "No Python exception was set."); 15898 } 15899 goto __label_228;} 15900 } 15901 // This is a TypeError to be consistent with DEBUG_MODE 15902 // Note: DEBUG_MODE also tells the name of the container 15903 if (PyArray_TYPE((PyArrayObject*) py_V227) != NPY_FLOAT64) { 15904 PyErr_Format(PyExc_TypeError, 15905 "expected type_num %d (NPY_FLOAT64) got %d", 15906 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V227)); 15907 { 15908 __failure = 228; 15909 if (!PyErr_Occurred()) { 15910 PyErr_SetString(PyExc_RuntimeError, 15911 "Unexpected error in an Op's C code. " 15912 "No Python exception was set."); 15913 } 15914 goto __label_228;} 15915 } 15916 15917 V227 = (PyArrayObject*)(py_V227); 15918 Py_XINCREF(V227); 15919 15920 { 15921 15922 py_V229 = PyList_GET_ITEM(storage_V229, 0); 15923 {Py_XINCREF(py_V229);} 15924 15925 V229 = NULL; 15926 if (py_V229 == Py_None) { 15927 // We can either fail here or set V229 to NULL and rely on Ops 15928 // using tensors to handle the NULL case, but if they fail to do so 15929 // they'll end up with nasty segfaults, so this is public service. 15930 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 15931 { 15932 __failure = 230; 15933 if (!PyErr_Occurred()) { 15934 PyErr_SetString(PyExc_RuntimeError, 15935 "Unexpected error in an Op's C code. " 15936 "No Python exception was set."); 15937 } 15938 goto __label_230;} 15939 } 15940 if (!PyArray_Check(py_V229)) { 15941 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 15942 { 15943 __failure = 230; 15944 if (!PyErr_Occurred()) { 15945 PyErr_SetString(PyExc_RuntimeError, 15946 "Unexpected error in an Op's C code. " 15947 "No Python exception was set."); 15948 } 15949 goto __label_230;} 15950 } 15951 // We expect NPY_FLOAT64 15952 if (!PyArray_ISALIGNED((PyArrayObject*) py_V229)) { 15953 PyArrayObject * tmp = (PyArrayObject*) py_V229; 15954 PyErr_Format(PyExc_NotImplementedError, 15955 "expected an aligned array of type %ld " 15956 "(NPY_FLOAT64), got non-aligned array of type %ld" 15957 " with %ld dimensions, with 3 last dims " 15958 "%ld, %ld, %ld" 15959 " and 3 last strides %ld %ld, %ld.", 15960 (long int) NPY_FLOAT64, 15961 (long int) PyArray_TYPE((PyArrayObject*) py_V229), 15962 (long int) PyArray_NDIM(tmp), 15963 (long int) (PyArray_NDIM(tmp) >= 3 ? 15964 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 15965 (long int) (PyArray_NDIM(tmp) >= 2 ? 15966 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 15967 (long int) (PyArray_NDIM(tmp) >= 1 ? 15968 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 15969 (long int) (PyArray_NDIM(tmp) >= 3 ? 15970 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 15971 (long int) (PyArray_NDIM(tmp) >= 2 ? 15972 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 15973 (long int) (PyArray_NDIM(tmp) >= 1 ? 15974 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 15975 ); 15976 { 15977 __failure = 230; 15978 if (!PyErr_Occurred()) { 15979 PyErr_SetString(PyExc_RuntimeError, 15980 "Unexpected error in an Op's C code. " 15981 "No Python exception was set."); 15982 } 15983 goto __label_230;} 15984 } 15985 // This is a TypeError to be consistent with DEBUG_MODE 15986 // Note: DEBUG_MODE also tells the name of the container 15987 if (PyArray_TYPE((PyArrayObject*) py_V229) != NPY_FLOAT64) { 15988 PyErr_Format(PyExc_TypeError, 15989 "expected type_num %d (NPY_FLOAT64) got %d", 15990 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V229)); 15991 { 15992 __failure = 230; 15993 if (!PyErr_Occurred()) { 15994 PyErr_SetString(PyExc_RuntimeError, 15995 "Unexpected error in an Op's C code. " 15996 "No Python exception was set."); 15997 } 15998 goto __label_230;} 15999 } 16000 16001 V229 = (PyArrayObject*)(py_V229); 16002 Py_XINCREF(V229); 16003 16004 { 16005 16006 py_V231 = PyList_GET_ITEM(storage_V231, 0); 16007 {Py_XINCREF(py_V231);} 16008 16009 V231 = NULL; 16010 if (py_V231 == Py_None) { 16011 // We can either fail here or set V231 to NULL and rely on Ops 16012 // using tensors to handle the NULL case, but if they fail to do so 16013 // they'll end up with nasty segfaults, so this is public service. 16014 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 16015 { 16016 __failure = 232; 16017 if (!PyErr_Occurred()) { 16018 PyErr_SetString(PyExc_RuntimeError, 16019 "Unexpected error in an Op's C code. " 16020 "No Python exception was set."); 16021 } 16022 goto __label_232;} 16023 } 16024 if (!PyArray_Check(py_V231)) { 16025 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 16026 { 16027 __failure = 232; 16028 if (!PyErr_Occurred()) { 16029 PyErr_SetString(PyExc_RuntimeError, 16030 "Unexpected error in an Op's C code. " 16031 "No Python exception was set."); 16032 } 16033 goto __label_232;} 16034 } 16035 // We expect NPY_FLOAT64 16036 if (!PyArray_ISALIGNED((PyArrayObject*) py_V231)) { 16037 PyArrayObject * tmp = (PyArrayObject*) py_V231; 16038 PyErr_Format(PyExc_NotImplementedError, 16039 "expected an aligned array of type %ld " 16040 "(NPY_FLOAT64), got non-aligned array of type %ld" 16041 " with %ld dimensions, with 3 last dims " 16042 "%ld, %ld, %ld" 16043 " and 3 last strides %ld %ld, %ld.", 16044 (long int) NPY_FLOAT64, 16045 (long int) PyArray_TYPE((PyArrayObject*) py_V231), 16046 (long int) PyArray_NDIM(tmp), 16047 (long int) (PyArray_NDIM(tmp) >= 3 ? 16048 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 16049 (long int) (PyArray_NDIM(tmp) >= 2 ? 16050 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 16051 (long int) (PyArray_NDIM(tmp) >= 1 ? 16052 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 16053 (long int) (PyArray_NDIM(tmp) >= 3 ? 16054 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 16055 (long int) (PyArray_NDIM(tmp) >= 2 ? 16056 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 16057 (long int) (PyArray_NDIM(tmp) >= 1 ? 16058 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 16059 ); 16060 { 16061 __failure = 232; 16062 if (!PyErr_Occurred()) { 16063 PyErr_SetString(PyExc_RuntimeError, 16064 "Unexpected error in an Op's C code. " 16065 "No Python exception was set."); 16066 } 16067 goto __label_232;} 16068 } 16069 // This is a TypeError to be consistent with DEBUG_MODE 16070 // Note: DEBUG_MODE also tells the name of the container 16071 if (PyArray_TYPE((PyArrayObject*) py_V231) != NPY_FLOAT64) { 16072 PyErr_Format(PyExc_TypeError, 16073 "expected type_num %d (NPY_FLOAT64) got %d", 16074 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V231)); 16075 { 16076 __failure = 232; 16077 if (!PyErr_Occurred()) { 16078 PyErr_SetString(PyExc_RuntimeError, 16079 "Unexpected error in an Op's C code. " 16080 "No Python exception was set."); 16081 } 16082 goto __label_232;} 16083 } 16084 16085 V231 = (PyArrayObject*)(py_V231); 16086 Py_XINCREF(V231); 16087 16088 { 16089 16090 py_V233 = PyList_GET_ITEM(storage_V233, 0); 16091 {Py_XINCREF(py_V233);} 16092 16093 V233 = NULL; 16094 if (py_V233 == Py_None) { 16095 // We can either fail here or set V233 to NULL and rely on Ops 16096 // using tensors to handle the NULL case, but if they fail to do so 16097 // they'll end up with nasty segfaults, so this is public service. 16098 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 16099 { 16100 __failure = 234; 16101 if (!PyErr_Occurred()) { 16102 PyErr_SetString(PyExc_RuntimeError, 16103 "Unexpected error in an Op's C code. " 16104 "No Python exception was set."); 16105 } 16106 goto __label_234;} 16107 } 16108 if (!PyArray_Check(py_V233)) { 16109 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 16110 { 16111 __failure = 234; 16112 if (!PyErr_Occurred()) { 16113 PyErr_SetString(PyExc_RuntimeError, 16114 "Unexpected error in an Op's C code. " 16115 "No Python exception was set."); 16116 } 16117 goto __label_234;} 16118 } 16119 // We expect NPY_FLOAT64 16120 if (!PyArray_ISALIGNED((PyArrayObject*) py_V233)) { 16121 PyArrayObject * tmp = (PyArrayObject*) py_V233; 16122 PyErr_Format(PyExc_NotImplementedError, 16123 "expected an aligned array of type %ld " 16124 "(NPY_FLOAT64), got non-aligned array of type %ld" 16125 " with %ld dimensions, with 3 last dims " 16126 "%ld, %ld, %ld" 16127 " and 3 last strides %ld %ld, %ld.", 16128 (long int) NPY_FLOAT64, 16129 (long int) PyArray_TYPE((PyArrayObject*) py_V233), 16130 (long int) PyArray_NDIM(tmp), 16131 (long int) (PyArray_NDIM(tmp) >= 3 ? 16132 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 16133 (long int) (PyArray_NDIM(tmp) >= 2 ? 16134 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 16135 (long int) (PyArray_NDIM(tmp) >= 1 ? 16136 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 16137 (long int) (PyArray_NDIM(tmp) >= 3 ? 16138 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 16139 (long int) (PyArray_NDIM(tmp) >= 2 ? 16140 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 16141 (long int) (PyArray_NDIM(tmp) >= 1 ? 16142 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 16143 ); 16144 { 16145 __failure = 234; 16146 if (!PyErr_Occurred()) { 16147 PyErr_SetString(PyExc_RuntimeError, 16148 "Unexpected error in an Op's C code. " 16149 "No Python exception was set."); 16150 } 16151 goto __label_234;} 16152 } 16153 // This is a TypeError to be consistent with DEBUG_MODE 16154 // Note: DEBUG_MODE also tells the name of the container 16155 if (PyArray_TYPE((PyArrayObject*) py_V233) != NPY_FLOAT64) { 16156 PyErr_Format(PyExc_TypeError, 16157 "expected type_num %d (NPY_FLOAT64) got %d", 16158 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V233)); 16159 { 16160 __failure = 234; 16161 if (!PyErr_Occurred()) { 16162 PyErr_SetString(PyExc_RuntimeError, 16163 "Unexpected error in an Op's C code. " 16164 "No Python exception was set."); 16165 } 16166 goto __label_234;} 16167 } 16168 16169 V233 = (PyArrayObject*)(py_V233); 16170 Py_XINCREF(V233); 16171 16172 { 16173 16174 py_V235 = PyList_GET_ITEM(storage_V235, 0); 16175 {Py_XINCREF(py_V235);} 16176 16177 V235 = NULL; 16178 if (py_V235 == Py_None) { 16179 // We can either fail here or set V235 to NULL and rely on Ops 16180 // using tensors to handle the NULL case, but if they fail to do so 16181 // they'll end up with nasty segfaults, so this is public service. 16182 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 16183 { 16184 __failure = 236; 16185 if (!PyErr_Occurred()) { 16186 PyErr_SetString(PyExc_RuntimeError, 16187 "Unexpected error in an Op's C code. " 16188 "No Python exception was set."); 16189 } 16190 goto __label_236;} 16191 } 16192 if (!PyArray_Check(py_V235)) { 16193 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 16194 { 16195 __failure = 236; 16196 if (!PyErr_Occurred()) { 16197 PyErr_SetString(PyExc_RuntimeError, 16198 "Unexpected error in an Op's C code. " 16199 "No Python exception was set."); 16200 } 16201 goto __label_236;} 16202 } 16203 // We expect NPY_FLOAT64 16204 if (!PyArray_ISALIGNED((PyArrayObject*) py_V235)) { 16205 PyArrayObject * tmp = (PyArrayObject*) py_V235; 16206 PyErr_Format(PyExc_NotImplementedError, 16207 "expected an aligned array of type %ld " 16208 "(NPY_FLOAT64), got non-aligned array of type %ld" 16209 " with %ld dimensions, with 3 last dims " 16210 "%ld, %ld, %ld" 16211 " and 3 last strides %ld %ld, %ld.", 16212 (long int) NPY_FLOAT64, 16213 (long int) PyArray_TYPE((PyArrayObject*) py_V235), 16214 (long int) PyArray_NDIM(tmp), 16215 (long int) (PyArray_NDIM(tmp) >= 3 ? 16216 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 16217 (long int) (PyArray_NDIM(tmp) >= 2 ? 16218 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 16219 (long int) (PyArray_NDIM(tmp) >= 1 ? 16220 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 16221 (long int) (PyArray_NDIM(tmp) >= 3 ? 16222 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 16223 (long int) (PyArray_NDIM(tmp) >= 2 ? 16224 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 16225 (long int) (PyArray_NDIM(tmp) >= 1 ? 16226 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 16227 ); 16228 { 16229 __failure = 236; 16230 if (!PyErr_Occurred()) { 16231 PyErr_SetString(PyExc_RuntimeError, 16232 "Unexpected error in an Op's C code. " 16233 "No Python exception was set."); 16234 } 16235 goto __label_236;} 16236 } 16237 // This is a TypeError to be consistent with DEBUG_MODE 16238 // Note: DEBUG_MODE also tells the name of the container 16239 if (PyArray_TYPE((PyArrayObject*) py_V235) != NPY_FLOAT64) { 16240 PyErr_Format(PyExc_TypeError, 16241 "expected type_num %d (NPY_FLOAT64) got %d", 16242 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V235)); 16243 { 16244 __failure = 236; 16245 if (!PyErr_Occurred()) { 16246 PyErr_SetString(PyExc_RuntimeError, 16247 "Unexpected error in an Op's C code. " 16248 "No Python exception was set."); 16249 } 16250 goto __label_236;} 16251 } 16252 16253 V235 = (PyArrayObject*)(py_V235); 16254 Py_XINCREF(V235); 16255 16256 { 16257 16258 py_V237 = PyList_GET_ITEM(storage_V237, 0); 16259 {Py_XINCREF(py_V237);} 16260 16261 V237 = NULL; 16262 if (py_V237 == Py_None) { 16263 // We can either fail here or set V237 to NULL and rely on Ops 16264 // using tensors to handle the NULL case, but if they fail to do so 16265 // they'll end up with nasty segfaults, so this is public service. 16266 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 16267 { 16268 __failure = 238; 16269 if (!PyErr_Occurred()) { 16270 PyErr_SetString(PyExc_RuntimeError, 16271 "Unexpected error in an Op's C code. " 16272 "No Python exception was set."); 16273 } 16274 goto __label_238;} 16275 } 16276 if (!PyArray_Check(py_V237)) { 16277 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 16278 { 16279 __failure = 238; 16280 if (!PyErr_Occurred()) { 16281 PyErr_SetString(PyExc_RuntimeError, 16282 "Unexpected error in an Op's C code. " 16283 "No Python exception was set."); 16284 } 16285 goto __label_238;} 16286 } 16287 // We expect NPY_FLOAT64 16288 if (!PyArray_ISALIGNED((PyArrayObject*) py_V237)) { 16289 PyArrayObject * tmp = (PyArrayObject*) py_V237; 16290 PyErr_Format(PyExc_NotImplementedError, 16291 "expected an aligned array of type %ld " 16292 "(NPY_FLOAT64), got non-aligned array of type %ld" 16293 " with %ld dimensions, with 3 last dims " 16294 "%ld, %ld, %ld" 16295 " and 3 last strides %ld %ld, %ld.", 16296 (long int) NPY_FLOAT64, 16297 (long int) PyArray_TYPE((PyArrayObject*) py_V237), 16298 (long int) PyArray_NDIM(tmp), 16299 (long int) (PyArray_NDIM(tmp) >= 3 ? 16300 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 16301 (long int) (PyArray_NDIM(tmp) >= 2 ? 16302 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 16303 (long int) (PyArray_NDIM(tmp) >= 1 ? 16304 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 16305 (long int) (PyArray_NDIM(tmp) >= 3 ? 16306 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 16307 (long int) (PyArray_NDIM(tmp) >= 2 ? 16308 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 16309 (long int) (PyArray_NDIM(tmp) >= 1 ? 16310 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 16311 ); 16312 { 16313 __failure = 238; 16314 if (!PyErr_Occurred()) { 16315 PyErr_SetString(PyExc_RuntimeError, 16316 "Unexpected error in an Op's C code. " 16317 "No Python exception was set."); 16318 } 16319 goto __label_238;} 16320 } 16321 // This is a TypeError to be consistent with DEBUG_MODE 16322 // Note: DEBUG_MODE also tells the name of the container 16323 if (PyArray_TYPE((PyArrayObject*) py_V237) != NPY_FLOAT64) { 16324 PyErr_Format(PyExc_TypeError, 16325 "expected type_num %d (NPY_FLOAT64) got %d", 16326 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V237)); 16327 { 16328 __failure = 238; 16329 if (!PyErr_Occurred()) { 16330 PyErr_SetString(PyExc_RuntimeError, 16331 "Unexpected error in an Op's C code. " 16332 "No Python exception was set."); 16333 } 16334 goto __label_238;} 16335 } 16336 16337 V237 = (PyArrayObject*)(py_V237); 16338 Py_XINCREF(V237); 16339 16340 { 16341 16342 py_V239 = PyList_GET_ITEM(storage_V239, 0); 16343 {Py_XINCREF(py_V239);} 16344 16345 V239 = NULL; 16346 if (py_V239 == Py_None) { 16347 // We can either fail here or set V239 to NULL and rely on Ops 16348 // using tensors to handle the NULL case, but if they fail to do so 16349 // they'll end up with nasty segfaults, so this is public service. 16350 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 16351 { 16352 __failure = 240; 16353 if (!PyErr_Occurred()) { 16354 PyErr_SetString(PyExc_RuntimeError, 16355 "Unexpected error in an Op's C code. " 16356 "No Python exception was set."); 16357 } 16358 goto __label_240;} 16359 } 16360 if (!PyArray_Check(py_V239)) { 16361 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 16362 { 16363 __failure = 240; 16364 if (!PyErr_Occurred()) { 16365 PyErr_SetString(PyExc_RuntimeError, 16366 "Unexpected error in an Op's C code. " 16367 "No Python exception was set."); 16368 } 16369 goto __label_240;} 16370 } 16371 // We expect NPY_FLOAT64 16372 if (!PyArray_ISALIGNED((PyArrayObject*) py_V239)) { 16373 PyArrayObject * tmp = (PyArrayObject*) py_V239; 16374 PyErr_Format(PyExc_NotImplementedError, 16375 "expected an aligned array of type %ld " 16376 "(NPY_FLOAT64), got non-aligned array of type %ld" 16377 " with %ld dimensions, with 3 last dims " 16378 "%ld, %ld, %ld" 16379 " and 3 last strides %ld %ld, %ld.", 16380 (long int) NPY_FLOAT64, 16381 (long int) PyArray_TYPE((PyArrayObject*) py_V239), 16382 (long int) PyArray_NDIM(tmp), 16383 (long int) (PyArray_NDIM(tmp) >= 3 ? 16384 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 16385 (long int) (PyArray_NDIM(tmp) >= 2 ? 16386 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 16387 (long int) (PyArray_NDIM(tmp) >= 1 ? 16388 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 16389 (long int) (PyArray_NDIM(tmp) >= 3 ? 16390 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 16391 (long int) (PyArray_NDIM(tmp) >= 2 ? 16392 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 16393 (long int) (PyArray_NDIM(tmp) >= 1 ? 16394 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 16395 ); 16396 { 16397 __failure = 240; 16398 if (!PyErr_Occurred()) { 16399 PyErr_SetString(PyExc_RuntimeError, 16400 "Unexpected error in an Op's C code. " 16401 "No Python exception was set."); 16402 } 16403 goto __label_240;} 16404 } 16405 // This is a TypeError to be consistent with DEBUG_MODE 16406 // Note: DEBUG_MODE also tells the name of the container 16407 if (PyArray_TYPE((PyArrayObject*) py_V239) != NPY_FLOAT64) { 16408 PyErr_Format(PyExc_TypeError, 16409 "expected type_num %d (NPY_FLOAT64) got %d", 16410 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V239)); 16411 { 16412 __failure = 240; 16413 if (!PyErr_Occurred()) { 16414 PyErr_SetString(PyExc_RuntimeError, 16415 "Unexpected error in an Op's C code. " 16416 "No Python exception was set."); 16417 } 16418 goto __label_240;} 16419 } 16420 16421 V239 = (PyArrayObject*)(py_V239); 16422 Py_XINCREF(V239); 16423 16424 { 16425 16426 py_V241 = PyList_GET_ITEM(storage_V241, 0); 16427 {Py_XINCREF(py_V241);} 16428 16429 V241 = NULL; 16430 if (py_V241 == Py_None) { 16431 // We can either fail here or set V241 to NULL and rely on Ops 16432 // using tensors to handle the NULL case, but if they fail to do so 16433 // they'll end up with nasty segfaults, so this is public service. 16434 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 16435 { 16436 __failure = 242; 16437 if (!PyErr_Occurred()) { 16438 PyErr_SetString(PyExc_RuntimeError, 16439 "Unexpected error in an Op's C code. " 16440 "No Python exception was set."); 16441 } 16442 goto __label_242;} 16443 } 16444 if (!PyArray_Check(py_V241)) { 16445 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 16446 { 16447 __failure = 242; 16448 if (!PyErr_Occurred()) { 16449 PyErr_SetString(PyExc_RuntimeError, 16450 "Unexpected error in an Op's C code. " 16451 "No Python exception was set."); 16452 } 16453 goto __label_242;} 16454 } 16455 // We expect NPY_FLOAT64 16456 if (!PyArray_ISALIGNED((PyArrayObject*) py_V241)) { 16457 PyArrayObject * tmp = (PyArrayObject*) py_V241; 16458 PyErr_Format(PyExc_NotImplementedError, 16459 "expected an aligned array of type %ld " 16460 "(NPY_FLOAT64), got non-aligned array of type %ld" 16461 " with %ld dimensions, with 3 last dims " 16462 "%ld, %ld, %ld" 16463 " and 3 last strides %ld %ld, %ld.", 16464 (long int) NPY_FLOAT64, 16465 (long int) PyArray_TYPE((PyArrayObject*) py_V241), 16466 (long int) PyArray_NDIM(tmp), 16467 (long int) (PyArray_NDIM(tmp) >= 3 ? 16468 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 16469 (long int) (PyArray_NDIM(tmp) >= 2 ? 16470 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 16471 (long int) (PyArray_NDIM(tmp) >= 1 ? 16472 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 16473 (long int) (PyArray_NDIM(tmp) >= 3 ? 16474 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 16475 (long int) (PyArray_NDIM(tmp) >= 2 ? 16476 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 16477 (long int) (PyArray_NDIM(tmp) >= 1 ? 16478 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 16479 ); 16480 { 16481 __failure = 242; 16482 if (!PyErr_Occurred()) { 16483 PyErr_SetString(PyExc_RuntimeError, 16484 "Unexpected error in an Op's C code. " 16485 "No Python exception was set."); 16486 } 16487 goto __label_242;} 16488 } 16489 // This is a TypeError to be consistent with DEBUG_MODE 16490 // Note: DEBUG_MODE also tells the name of the container 16491 if (PyArray_TYPE((PyArrayObject*) py_V241) != NPY_FLOAT64) { 16492 PyErr_Format(PyExc_TypeError, 16493 "expected type_num %d (NPY_FLOAT64) got %d", 16494 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V241)); 16495 { 16496 __failure = 242; 16497 if (!PyErr_Occurred()) { 16498 PyErr_SetString(PyExc_RuntimeError, 16499 "Unexpected error in an Op's C code. " 16500 "No Python exception was set."); 16501 } 16502 goto __label_242;} 16503 } 16504 16505 V241 = (PyArrayObject*)(py_V241); 16506 Py_XINCREF(V241); 16507 16508 { 16509 16510 py_V243 = PyList_GET_ITEM(storage_V243, 0); 16511 {Py_XINCREF(py_V243);} 16512 16513 V243 = NULL; 16514 if (py_V243 == Py_None) { 16515 // We can either fail here or set V243 to NULL and rely on Ops 16516 // using tensors to handle the NULL case, but if they fail to do so 16517 // they'll end up with nasty segfaults, so this is public service. 16518 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 16519 { 16520 __failure = 244; 16521 if (!PyErr_Occurred()) { 16522 PyErr_SetString(PyExc_RuntimeError, 16523 "Unexpected error in an Op's C code. " 16524 "No Python exception was set."); 16525 } 16526 goto __label_244;} 16527 } 16528 if (!PyArray_Check(py_V243)) { 16529 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 16530 { 16531 __failure = 244; 16532 if (!PyErr_Occurred()) { 16533 PyErr_SetString(PyExc_RuntimeError, 16534 "Unexpected error in an Op's C code. " 16535 "No Python exception was set."); 16536 } 16537 goto __label_244;} 16538 } 16539 // We expect NPY_FLOAT64 16540 if (!PyArray_ISALIGNED((PyArrayObject*) py_V243)) { 16541 PyArrayObject * tmp = (PyArrayObject*) py_V243; 16542 PyErr_Format(PyExc_NotImplementedError, 16543 "expected an aligned array of type %ld " 16544 "(NPY_FLOAT64), got non-aligned array of type %ld" 16545 " with %ld dimensions, with 3 last dims " 16546 "%ld, %ld, %ld" 16547 " and 3 last strides %ld %ld, %ld.", 16548 (long int) NPY_FLOAT64, 16549 (long int) PyArray_TYPE((PyArrayObject*) py_V243), 16550 (long int) PyArray_NDIM(tmp), 16551 (long int) (PyArray_NDIM(tmp) >= 3 ? 16552 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 16553 (long int) (PyArray_NDIM(tmp) >= 2 ? 16554 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 16555 (long int) (PyArray_NDIM(tmp) >= 1 ? 16556 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 16557 (long int) (PyArray_NDIM(tmp) >= 3 ? 16558 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 16559 (long int) (PyArray_NDIM(tmp) >= 2 ? 16560 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 16561 (long int) (PyArray_NDIM(tmp) >= 1 ? 16562 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 16563 ); 16564 { 16565 __failure = 244; 16566 if (!PyErr_Occurred()) { 16567 PyErr_SetString(PyExc_RuntimeError, 16568 "Unexpected error in an Op's C code. " 16569 "No Python exception was set."); 16570 } 16571 goto __label_244;} 16572 } 16573 // This is a TypeError to be consistent with DEBUG_MODE 16574 // Note: DEBUG_MODE also tells the name of the container 16575 if (PyArray_TYPE((PyArrayObject*) py_V243) != NPY_FLOAT64) { 16576 PyErr_Format(PyExc_TypeError, 16577 "expected type_num %d (NPY_FLOAT64) got %d", 16578 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V243)); 16579 { 16580 __failure = 244; 16581 if (!PyErr_Occurred()) { 16582 PyErr_SetString(PyExc_RuntimeError, 16583 "Unexpected error in an Op's C code. " 16584 "No Python exception was set."); 16585 } 16586 goto __label_244;} 16587 } 16588 16589 V243 = (PyArrayObject*)(py_V243); 16590 Py_XINCREF(V243); 16591 16592 { 16593 16594 py_V245 = PyList_GET_ITEM(storage_V245, 0); 16595 {Py_XINCREF(py_V245);} 16596 16597 V245 = NULL; 16598 if (py_V245 == Py_None) { 16599 // We can either fail here or set V245 to NULL and rely on Ops 16600 // using tensors to handle the NULL case, but if they fail to do so 16601 // they'll end up with nasty segfaults, so this is public service. 16602 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 16603 { 16604 __failure = 246; 16605 if (!PyErr_Occurred()) { 16606 PyErr_SetString(PyExc_RuntimeError, 16607 "Unexpected error in an Op's C code. " 16608 "No Python exception was set."); 16609 } 16610 goto __label_246;} 16611 } 16612 if (!PyArray_Check(py_V245)) { 16613 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 16614 { 16615 __failure = 246; 16616 if (!PyErr_Occurred()) { 16617 PyErr_SetString(PyExc_RuntimeError, 16618 "Unexpected error in an Op's C code. " 16619 "No Python exception was set."); 16620 } 16621 goto __label_246;} 16622 } 16623 // We expect NPY_FLOAT64 16624 if (!PyArray_ISALIGNED((PyArrayObject*) py_V245)) { 16625 PyArrayObject * tmp = (PyArrayObject*) py_V245; 16626 PyErr_Format(PyExc_NotImplementedError, 16627 "expected an aligned array of type %ld " 16628 "(NPY_FLOAT64), got non-aligned array of type %ld" 16629 " with %ld dimensions, with 3 last dims " 16630 "%ld, %ld, %ld" 16631 " and 3 last strides %ld %ld, %ld.", 16632 (long int) NPY_FLOAT64, 16633 (long int) PyArray_TYPE((PyArrayObject*) py_V245), 16634 (long int) PyArray_NDIM(tmp), 16635 (long int) (PyArray_NDIM(tmp) >= 3 ? 16636 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 16637 (long int) (PyArray_NDIM(tmp) >= 2 ? 16638 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 16639 (long int) (PyArray_NDIM(tmp) >= 1 ? 16640 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 16641 (long int) (PyArray_NDIM(tmp) >= 3 ? 16642 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 16643 (long int) (PyArray_NDIM(tmp) >= 2 ? 16644 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 16645 (long int) (PyArray_NDIM(tmp) >= 1 ? 16646 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 16647 ); 16648 { 16649 __failure = 246; 16650 if (!PyErr_Occurred()) { 16651 PyErr_SetString(PyExc_RuntimeError, 16652 "Unexpected error in an Op's C code. " 16653 "No Python exception was set."); 16654 } 16655 goto __label_246;} 16656 } 16657 // This is a TypeError to be consistent with DEBUG_MODE 16658 // Note: DEBUG_MODE also tells the name of the container 16659 if (PyArray_TYPE((PyArrayObject*) py_V245) != NPY_FLOAT64) { 16660 PyErr_Format(PyExc_TypeError, 16661 "expected type_num %d (NPY_FLOAT64) got %d", 16662 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V245)); 16663 { 16664 __failure = 246; 16665 if (!PyErr_Occurred()) { 16666 PyErr_SetString(PyExc_RuntimeError, 16667 "Unexpected error in an Op's C code. " 16668 "No Python exception was set."); 16669 } 16670 goto __label_246;} 16671 } 16672 16673 V245 = (PyArrayObject*)(py_V245); 16674 Py_XINCREF(V245); 16675 16676 { 16677 16678 py_V247 = PyList_GET_ITEM(storage_V247, 0); 16679 {Py_XINCREF(py_V247);} 16680 16681 V247 = NULL; 16682 if (py_V247 == Py_None) { 16683 // We can either fail here or set V247 to NULL and rely on Ops 16684 // using tensors to handle the NULL case, but if they fail to do so 16685 // they'll end up with nasty segfaults, so this is public service. 16686 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 16687 { 16688 __failure = 248; 16689 if (!PyErr_Occurred()) { 16690 PyErr_SetString(PyExc_RuntimeError, 16691 "Unexpected error in an Op's C code. " 16692 "No Python exception was set."); 16693 } 16694 goto __label_248;} 16695 } 16696 if (!PyArray_Check(py_V247)) { 16697 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 16698 { 16699 __failure = 248; 16700 if (!PyErr_Occurred()) { 16701 PyErr_SetString(PyExc_RuntimeError, 16702 "Unexpected error in an Op's C code. " 16703 "No Python exception was set."); 16704 } 16705 goto __label_248;} 16706 } 16707 // We expect NPY_FLOAT64 16708 if (!PyArray_ISALIGNED((PyArrayObject*) py_V247)) { 16709 PyArrayObject * tmp = (PyArrayObject*) py_V247; 16710 PyErr_Format(PyExc_NotImplementedError, 16711 "expected an aligned array of type %ld " 16712 "(NPY_FLOAT64), got non-aligned array of type %ld" 16713 " with %ld dimensions, with 3 last dims " 16714 "%ld, %ld, %ld" 16715 " and 3 last strides %ld %ld, %ld.", 16716 (long int) NPY_FLOAT64, 16717 (long int) PyArray_TYPE((PyArrayObject*) py_V247), 16718 (long int) PyArray_NDIM(tmp), 16719 (long int) (PyArray_NDIM(tmp) >= 3 ? 16720 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 16721 (long int) (PyArray_NDIM(tmp) >= 2 ? 16722 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 16723 (long int) (PyArray_NDIM(tmp) >= 1 ? 16724 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 16725 (long int) (PyArray_NDIM(tmp) >= 3 ? 16726 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 16727 (long int) (PyArray_NDIM(tmp) >= 2 ? 16728 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 16729 (long int) (PyArray_NDIM(tmp) >= 1 ? 16730 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 16731 ); 16732 { 16733 __failure = 248; 16734 if (!PyErr_Occurred()) { 16735 PyErr_SetString(PyExc_RuntimeError, 16736 "Unexpected error in an Op's C code. " 16737 "No Python exception was set."); 16738 } 16739 goto __label_248;} 16740 } 16741 // This is a TypeError to be consistent with DEBUG_MODE 16742 // Note: DEBUG_MODE also tells the name of the container 16743 if (PyArray_TYPE((PyArrayObject*) py_V247) != NPY_FLOAT64) { 16744 PyErr_Format(PyExc_TypeError, 16745 "expected type_num %d (NPY_FLOAT64) got %d", 16746 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V247)); 16747 { 16748 __failure = 248; 16749 if (!PyErr_Occurred()) { 16750 PyErr_SetString(PyExc_RuntimeError, 16751 "Unexpected error in an Op's C code. " 16752 "No Python exception was set."); 16753 } 16754 goto __label_248;} 16755 } 16756 16757 V247 = (PyArrayObject*)(py_V247); 16758 Py_XINCREF(V247); 16759 16760 { 16761 16762 py_V249 = PyList_GET_ITEM(storage_V249, 0); 16763 {Py_XINCREF(py_V249);} 16764 16765 V249 = NULL; 16766 if (py_V249 == Py_None) { 16767 // We can either fail here or set V249 to NULL and rely on Ops 16768 // using tensors to handle the NULL case, but if they fail to do so 16769 // they'll end up with nasty segfaults, so this is public service. 16770 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 16771 { 16772 __failure = 250; 16773 if (!PyErr_Occurred()) { 16774 PyErr_SetString(PyExc_RuntimeError, 16775 "Unexpected error in an Op's C code. " 16776 "No Python exception was set."); 16777 } 16778 goto __label_250;} 16779 } 16780 if (!PyArray_Check(py_V249)) { 16781 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 16782 { 16783 __failure = 250; 16784 if (!PyErr_Occurred()) { 16785 PyErr_SetString(PyExc_RuntimeError, 16786 "Unexpected error in an Op's C code. " 16787 "No Python exception was set."); 16788 } 16789 goto __label_250;} 16790 } 16791 // We expect NPY_FLOAT64 16792 if (!PyArray_ISALIGNED((PyArrayObject*) py_V249)) { 16793 PyArrayObject * tmp = (PyArrayObject*) py_V249; 16794 PyErr_Format(PyExc_NotImplementedError, 16795 "expected an aligned array of type %ld " 16796 "(NPY_FLOAT64), got non-aligned array of type %ld" 16797 " with %ld dimensions, with 3 last dims " 16798 "%ld, %ld, %ld" 16799 " and 3 last strides %ld %ld, %ld.", 16800 (long int) NPY_FLOAT64, 16801 (long int) PyArray_TYPE((PyArrayObject*) py_V249), 16802 (long int) PyArray_NDIM(tmp), 16803 (long int) (PyArray_NDIM(tmp) >= 3 ? 16804 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 16805 (long int) (PyArray_NDIM(tmp) >= 2 ? 16806 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 16807 (long int) (PyArray_NDIM(tmp) >= 1 ? 16808 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 16809 (long int) (PyArray_NDIM(tmp) >= 3 ? 16810 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 16811 (long int) (PyArray_NDIM(tmp) >= 2 ? 16812 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 16813 (long int) (PyArray_NDIM(tmp) >= 1 ? 16814 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 16815 ); 16816 { 16817 __failure = 250; 16818 if (!PyErr_Occurred()) { 16819 PyErr_SetString(PyExc_RuntimeError, 16820 "Unexpected error in an Op's C code. " 16821 "No Python exception was set."); 16822 } 16823 goto __label_250;} 16824 } 16825 // This is a TypeError to be consistent with DEBUG_MODE 16826 // Note: DEBUG_MODE also tells the name of the container 16827 if (PyArray_TYPE((PyArrayObject*) py_V249) != NPY_FLOAT64) { 16828 PyErr_Format(PyExc_TypeError, 16829 "expected type_num %d (NPY_FLOAT64) got %d", 16830 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V249)); 16831 { 16832 __failure = 250; 16833 if (!PyErr_Occurred()) { 16834 PyErr_SetString(PyExc_RuntimeError, 16835 "Unexpected error in an Op's C code. " 16836 "No Python exception was set."); 16837 } 16838 goto __label_250;} 16839 } 16840 16841 V249 = (PyArrayObject*)(py_V249); 16842 Py_XINCREF(V249); 16843 16844 { 16845 16846 py_V251 = PyList_GET_ITEM(storage_V251, 0); 16847 {Py_XINCREF(py_V251);} 16848 16849 V251 = NULL; 16850 if (py_V251 == Py_None) { 16851 // We can either fail here or set V251 to NULL and rely on Ops 16852 // using tensors to handle the NULL case, but if they fail to do so 16853 // they'll end up with nasty segfaults, so this is public service. 16854 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 16855 { 16856 __failure = 252; 16857 if (!PyErr_Occurred()) { 16858 PyErr_SetString(PyExc_RuntimeError, 16859 "Unexpected error in an Op's C code. " 16860 "No Python exception was set."); 16861 } 16862 goto __label_252;} 16863 } 16864 if (!PyArray_Check(py_V251)) { 16865 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 16866 { 16867 __failure = 252; 16868 if (!PyErr_Occurred()) { 16869 PyErr_SetString(PyExc_RuntimeError, 16870 "Unexpected error in an Op's C code. " 16871 "No Python exception was set."); 16872 } 16873 goto __label_252;} 16874 } 16875 // We expect NPY_FLOAT64 16876 if (!PyArray_ISALIGNED((PyArrayObject*) py_V251)) { 16877 PyArrayObject * tmp = (PyArrayObject*) py_V251; 16878 PyErr_Format(PyExc_NotImplementedError, 16879 "expected an aligned array of type %ld " 16880 "(NPY_FLOAT64), got non-aligned array of type %ld" 16881 " with %ld dimensions, with 3 last dims " 16882 "%ld, %ld, %ld" 16883 " and 3 last strides %ld %ld, %ld.", 16884 (long int) NPY_FLOAT64, 16885 (long int) PyArray_TYPE((PyArrayObject*) py_V251), 16886 (long int) PyArray_NDIM(tmp), 16887 (long int) (PyArray_NDIM(tmp) >= 3 ? 16888 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 16889 (long int) (PyArray_NDIM(tmp) >= 2 ? 16890 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 16891 (long int) (PyArray_NDIM(tmp) >= 1 ? 16892 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 16893 (long int) (PyArray_NDIM(tmp) >= 3 ? 16894 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 16895 (long int) (PyArray_NDIM(tmp) >= 2 ? 16896 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 16897 (long int) (PyArray_NDIM(tmp) >= 1 ? 16898 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 16899 ); 16900 { 16901 __failure = 252; 16902 if (!PyErr_Occurred()) { 16903 PyErr_SetString(PyExc_RuntimeError, 16904 "Unexpected error in an Op's C code. " 16905 "No Python exception was set."); 16906 } 16907 goto __label_252;} 16908 } 16909 // This is a TypeError to be consistent with DEBUG_MODE 16910 // Note: DEBUG_MODE also tells the name of the container 16911 if (PyArray_TYPE((PyArrayObject*) py_V251) != NPY_FLOAT64) { 16912 PyErr_Format(PyExc_TypeError, 16913 "expected type_num %d (NPY_FLOAT64) got %d", 16914 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V251)); 16915 { 16916 __failure = 252; 16917 if (!PyErr_Occurred()) { 16918 PyErr_SetString(PyExc_RuntimeError, 16919 "Unexpected error in an Op's C code. " 16920 "No Python exception was set."); 16921 } 16922 goto __label_252;} 16923 } 16924 16925 V251 = (PyArrayObject*)(py_V251); 16926 Py_XINCREF(V251); 16927 16928 { 16929 16930 py_V253 = PyList_GET_ITEM(storage_V253, 0); 16931 {Py_XINCREF(py_V253);} 16932 16933 V253 = NULL; 16934 if (py_V253 == Py_None) { 16935 // We can either fail here or set V253 to NULL and rely on Ops 16936 // using tensors to handle the NULL case, but if they fail to do so 16937 // they'll end up with nasty segfaults, so this is public service. 16938 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 16939 { 16940 __failure = 254; 16941 if (!PyErr_Occurred()) { 16942 PyErr_SetString(PyExc_RuntimeError, 16943 "Unexpected error in an Op's C code. " 16944 "No Python exception was set."); 16945 } 16946 goto __label_254;} 16947 } 16948 if (!PyArray_Check(py_V253)) { 16949 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 16950 { 16951 __failure = 254; 16952 if (!PyErr_Occurred()) { 16953 PyErr_SetString(PyExc_RuntimeError, 16954 "Unexpected error in an Op's C code. " 16955 "No Python exception was set."); 16956 } 16957 goto __label_254;} 16958 } 16959 // We expect NPY_FLOAT64 16960 if (!PyArray_ISALIGNED((PyArrayObject*) py_V253)) { 16961 PyArrayObject * tmp = (PyArrayObject*) py_V253; 16962 PyErr_Format(PyExc_NotImplementedError, 16963 "expected an aligned array of type %ld " 16964 "(NPY_FLOAT64), got non-aligned array of type %ld" 16965 " with %ld dimensions, with 3 last dims " 16966 "%ld, %ld, %ld" 16967 " and 3 last strides %ld %ld, %ld.", 16968 (long int) NPY_FLOAT64, 16969 (long int) PyArray_TYPE((PyArrayObject*) py_V253), 16970 (long int) PyArray_NDIM(tmp), 16971 (long int) (PyArray_NDIM(tmp) >= 3 ? 16972 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 16973 (long int) (PyArray_NDIM(tmp) >= 2 ? 16974 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 16975 (long int) (PyArray_NDIM(tmp) >= 1 ? 16976 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 16977 (long int) (PyArray_NDIM(tmp) >= 3 ? 16978 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 16979 (long int) (PyArray_NDIM(tmp) >= 2 ? 16980 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 16981 (long int) (PyArray_NDIM(tmp) >= 1 ? 16982 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 16983 ); 16984 { 16985 __failure = 254; 16986 if (!PyErr_Occurred()) { 16987 PyErr_SetString(PyExc_RuntimeError, 16988 "Unexpected error in an Op's C code. " 16989 "No Python exception was set."); 16990 } 16991 goto __label_254;} 16992 } 16993 // This is a TypeError to be consistent with DEBUG_MODE 16994 // Note: DEBUG_MODE also tells the name of the container 16995 if (PyArray_TYPE((PyArrayObject*) py_V253) != NPY_FLOAT64) { 16996 PyErr_Format(PyExc_TypeError, 16997 "expected type_num %d (NPY_FLOAT64) got %d", 16998 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V253)); 16999 { 17000 __failure = 254; 17001 if (!PyErr_Occurred()) { 17002 PyErr_SetString(PyExc_RuntimeError, 17003 "Unexpected error in an Op's C code. " 17004 "No Python exception was set."); 17005 } 17006 goto __label_254;} 17007 } 17008 17009 V253 = (PyArrayObject*)(py_V253); 17010 Py_XINCREF(V253); 17011 17012 { 17013 17014 py_V255 = PyList_GET_ITEM(storage_V255, 0); 17015 {Py_XINCREF(py_V255);} 17016 17017 V255 = NULL; 17018 if (py_V255 == Py_None) { 17019 // We can either fail here or set V255 to NULL and rely on Ops 17020 // using tensors to handle the NULL case, but if they fail to do so 17021 // they'll end up with nasty segfaults, so this is public service. 17022 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 17023 { 17024 __failure = 256; 17025 if (!PyErr_Occurred()) { 17026 PyErr_SetString(PyExc_RuntimeError, 17027 "Unexpected error in an Op's C code. " 17028 "No Python exception was set."); 17029 } 17030 goto __label_256;} 17031 } 17032 if (!PyArray_Check(py_V255)) { 17033 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 17034 { 17035 __failure = 256; 17036 if (!PyErr_Occurred()) { 17037 PyErr_SetString(PyExc_RuntimeError, 17038 "Unexpected error in an Op's C code. " 17039 "No Python exception was set."); 17040 } 17041 goto __label_256;} 17042 } 17043 // We expect NPY_FLOAT64 17044 if (!PyArray_ISALIGNED((PyArrayObject*) py_V255)) { 17045 PyArrayObject * tmp = (PyArrayObject*) py_V255; 17046 PyErr_Format(PyExc_NotImplementedError, 17047 "expected an aligned array of type %ld " 17048 "(NPY_FLOAT64), got non-aligned array of type %ld" 17049 " with %ld dimensions, with 3 last dims " 17050 "%ld, %ld, %ld" 17051 " and 3 last strides %ld %ld, %ld.", 17052 (long int) NPY_FLOAT64, 17053 (long int) PyArray_TYPE((PyArrayObject*) py_V255), 17054 (long int) PyArray_NDIM(tmp), 17055 (long int) (PyArray_NDIM(tmp) >= 3 ? 17056 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 17057 (long int) (PyArray_NDIM(tmp) >= 2 ? 17058 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 17059 (long int) (PyArray_NDIM(tmp) >= 1 ? 17060 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 17061 (long int) (PyArray_NDIM(tmp) >= 3 ? 17062 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 17063 (long int) (PyArray_NDIM(tmp) >= 2 ? 17064 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 17065 (long int) (PyArray_NDIM(tmp) >= 1 ? 17066 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 17067 ); 17068 { 17069 __failure = 256; 17070 if (!PyErr_Occurred()) { 17071 PyErr_SetString(PyExc_RuntimeError, 17072 "Unexpected error in an Op's C code. " 17073 "No Python exception was set."); 17074 } 17075 goto __label_256;} 17076 } 17077 // This is a TypeError to be consistent with DEBUG_MODE 17078 // Note: DEBUG_MODE also tells the name of the container 17079 if (PyArray_TYPE((PyArrayObject*) py_V255) != NPY_FLOAT64) { 17080 PyErr_Format(PyExc_TypeError, 17081 "expected type_num %d (NPY_FLOAT64) got %d", 17082 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V255)); 17083 { 17084 __failure = 256; 17085 if (!PyErr_Occurred()) { 17086 PyErr_SetString(PyExc_RuntimeError, 17087 "Unexpected error in an Op's C code. " 17088 "No Python exception was set."); 17089 } 17090 goto __label_256;} 17091 } 17092 17093 V255 = (PyArrayObject*)(py_V255); 17094 Py_XINCREF(V255); 17095 17096 { 17097 17098 py_V257 = PyList_GET_ITEM(storage_V257, 0); 17099 {Py_XINCREF(py_V257);} 17100 17101 V257 = NULL; 17102 if (py_V257 == Py_None) { 17103 // We can either fail here or set V257 to NULL and rely on Ops 17104 // using tensors to handle the NULL case, but if they fail to do so 17105 // they'll end up with nasty segfaults, so this is public service. 17106 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 17107 { 17108 __failure = 258; 17109 if (!PyErr_Occurred()) { 17110 PyErr_SetString(PyExc_RuntimeError, 17111 "Unexpected error in an Op's C code. " 17112 "No Python exception was set."); 17113 } 17114 goto __label_258;} 17115 } 17116 if (!PyArray_Check(py_V257)) { 17117 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 17118 { 17119 __failure = 258; 17120 if (!PyErr_Occurred()) { 17121 PyErr_SetString(PyExc_RuntimeError, 17122 "Unexpected error in an Op's C code. " 17123 "No Python exception was set."); 17124 } 17125 goto __label_258;} 17126 } 17127 // We expect NPY_FLOAT64 17128 if (!PyArray_ISALIGNED((PyArrayObject*) py_V257)) { 17129 PyArrayObject * tmp = (PyArrayObject*) py_V257; 17130 PyErr_Format(PyExc_NotImplementedError, 17131 "expected an aligned array of type %ld " 17132 "(NPY_FLOAT64), got non-aligned array of type %ld" 17133 " with %ld dimensions, with 3 last dims " 17134 "%ld, %ld, %ld" 17135 " and 3 last strides %ld %ld, %ld.", 17136 (long int) NPY_FLOAT64, 17137 (long int) PyArray_TYPE((PyArrayObject*) py_V257), 17138 (long int) PyArray_NDIM(tmp), 17139 (long int) (PyArray_NDIM(tmp) >= 3 ? 17140 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 17141 (long int) (PyArray_NDIM(tmp) >= 2 ? 17142 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 17143 (long int) (PyArray_NDIM(tmp) >= 1 ? 17144 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 17145 (long int) (PyArray_NDIM(tmp) >= 3 ? 17146 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 17147 (long int) (PyArray_NDIM(tmp) >= 2 ? 17148 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 17149 (long int) (PyArray_NDIM(tmp) >= 1 ? 17150 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 17151 ); 17152 { 17153 __failure = 258; 17154 if (!PyErr_Occurred()) { 17155 PyErr_SetString(PyExc_RuntimeError, 17156 "Unexpected error in an Op's C code. " 17157 "No Python exception was set."); 17158 } 17159 goto __label_258;} 17160 } 17161 // This is a TypeError to be consistent with DEBUG_MODE 17162 // Note: DEBUG_MODE also tells the name of the container 17163 if (PyArray_TYPE((PyArrayObject*) py_V257) != NPY_FLOAT64) { 17164 PyErr_Format(PyExc_TypeError, 17165 "expected type_num %d (NPY_FLOAT64) got %d", 17166 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V257)); 17167 { 17168 __failure = 258; 17169 if (!PyErr_Occurred()) { 17170 PyErr_SetString(PyExc_RuntimeError, 17171 "Unexpected error in an Op's C code. " 17172 "No Python exception was set."); 17173 } 17174 goto __label_258;} 17175 } 17176 17177 V257 = (PyArrayObject*)(py_V257); 17178 Py_XINCREF(V257); 17179 17180 { 17181 17182 py_V259 = PyList_GET_ITEM(storage_V259, 0); 17183 {Py_XINCREF(py_V259);} 17184 17185 V259 = NULL; 17186 if (py_V259 == Py_None) { 17187 // We can either fail here or set V259 to NULL and rely on Ops 17188 // using tensors to handle the NULL case, but if they fail to do so 17189 // they'll end up with nasty segfaults, so this is public service. 17190 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 17191 { 17192 __failure = 260; 17193 if (!PyErr_Occurred()) { 17194 PyErr_SetString(PyExc_RuntimeError, 17195 "Unexpected error in an Op's C code. " 17196 "No Python exception was set."); 17197 } 17198 goto __label_260;} 17199 } 17200 if (!PyArray_Check(py_V259)) { 17201 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 17202 { 17203 __failure = 260; 17204 if (!PyErr_Occurred()) { 17205 PyErr_SetString(PyExc_RuntimeError, 17206 "Unexpected error in an Op's C code. " 17207 "No Python exception was set."); 17208 } 17209 goto __label_260;} 17210 } 17211 // We expect NPY_FLOAT64 17212 if (!PyArray_ISALIGNED((PyArrayObject*) py_V259)) { 17213 PyArrayObject * tmp = (PyArrayObject*) py_V259; 17214 PyErr_Format(PyExc_NotImplementedError, 17215 "expected an aligned array of type %ld " 17216 "(NPY_FLOAT64), got non-aligned array of type %ld" 17217 " with %ld dimensions, with 3 last dims " 17218 "%ld, %ld, %ld" 17219 " and 3 last strides %ld %ld, %ld.", 17220 (long int) NPY_FLOAT64, 17221 (long int) PyArray_TYPE((PyArrayObject*) py_V259), 17222 (long int) PyArray_NDIM(tmp), 17223 (long int) (PyArray_NDIM(tmp) >= 3 ? 17224 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 17225 (long int) (PyArray_NDIM(tmp) >= 2 ? 17226 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 17227 (long int) (PyArray_NDIM(tmp) >= 1 ? 17228 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 17229 (long int) (PyArray_NDIM(tmp) >= 3 ? 17230 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 17231 (long int) (PyArray_NDIM(tmp) >= 2 ? 17232 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 17233 (long int) (PyArray_NDIM(tmp) >= 1 ? 17234 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 17235 ); 17236 { 17237 __failure = 260; 17238 if (!PyErr_Occurred()) { 17239 PyErr_SetString(PyExc_RuntimeError, 17240 "Unexpected error in an Op's C code. " 17241 "No Python exception was set."); 17242 } 17243 goto __label_260;} 17244 } 17245 // This is a TypeError to be consistent with DEBUG_MODE 17246 // Note: DEBUG_MODE also tells the name of the container 17247 if (PyArray_TYPE((PyArrayObject*) py_V259) != NPY_FLOAT64) { 17248 PyErr_Format(PyExc_TypeError, 17249 "expected type_num %d (NPY_FLOAT64) got %d", 17250 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V259)); 17251 { 17252 __failure = 260; 17253 if (!PyErr_Occurred()) { 17254 PyErr_SetString(PyExc_RuntimeError, 17255 "Unexpected error in an Op's C code. " 17256 "No Python exception was set."); 17257 } 17258 goto __label_260;} 17259 } 17260 17261 V259 = (PyArrayObject*)(py_V259); 17262 Py_XINCREF(V259); 17263 17264 { 17265 17266 py_V261 = PyList_GET_ITEM(storage_V261, 0); 17267 {Py_XINCREF(py_V261);} 17268 17269 V261 = NULL; 17270 if (py_V261 == Py_None) { 17271 // We can either fail here or set V261 to NULL and rely on Ops 17272 // using tensors to handle the NULL case, but if they fail to do so 17273 // they'll end up with nasty segfaults, so this is public service. 17274 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 17275 { 17276 __failure = 262; 17277 if (!PyErr_Occurred()) { 17278 PyErr_SetString(PyExc_RuntimeError, 17279 "Unexpected error in an Op's C code. " 17280 "No Python exception was set."); 17281 } 17282 goto __label_262;} 17283 } 17284 if (!PyArray_Check(py_V261)) { 17285 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 17286 { 17287 __failure = 262; 17288 if (!PyErr_Occurred()) { 17289 PyErr_SetString(PyExc_RuntimeError, 17290 "Unexpected error in an Op's C code. " 17291 "No Python exception was set."); 17292 } 17293 goto __label_262;} 17294 } 17295 // We expect NPY_FLOAT64 17296 if (!PyArray_ISALIGNED((PyArrayObject*) py_V261)) { 17297 PyArrayObject * tmp = (PyArrayObject*) py_V261; 17298 PyErr_Format(PyExc_NotImplementedError, 17299 "expected an aligned array of type %ld " 17300 "(NPY_FLOAT64), got non-aligned array of type %ld" 17301 " with %ld dimensions, with 3 last dims " 17302 "%ld, %ld, %ld" 17303 " and 3 last strides %ld %ld, %ld.", 17304 (long int) NPY_FLOAT64, 17305 (long int) PyArray_TYPE((PyArrayObject*) py_V261), 17306 (long int) PyArray_NDIM(tmp), 17307 (long int) (PyArray_NDIM(tmp) >= 3 ? 17308 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 17309 (long int) (PyArray_NDIM(tmp) >= 2 ? 17310 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 17311 (long int) (PyArray_NDIM(tmp) >= 1 ? 17312 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 17313 (long int) (PyArray_NDIM(tmp) >= 3 ? 17314 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 17315 (long int) (PyArray_NDIM(tmp) >= 2 ? 17316 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 17317 (long int) (PyArray_NDIM(tmp) >= 1 ? 17318 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 17319 ); 17320 { 17321 __failure = 262; 17322 if (!PyErr_Occurred()) { 17323 PyErr_SetString(PyExc_RuntimeError, 17324 "Unexpected error in an Op's C code. " 17325 "No Python exception was set."); 17326 } 17327 goto __label_262;} 17328 } 17329 // This is a TypeError to be consistent with DEBUG_MODE 17330 // Note: DEBUG_MODE also tells the name of the container 17331 if (PyArray_TYPE((PyArrayObject*) py_V261) != NPY_FLOAT64) { 17332 PyErr_Format(PyExc_TypeError, 17333 "expected type_num %d (NPY_FLOAT64) got %d", 17334 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V261)); 17335 { 17336 __failure = 262; 17337 if (!PyErr_Occurred()) { 17338 PyErr_SetString(PyExc_RuntimeError, 17339 "Unexpected error in an Op's C code. " 17340 "No Python exception was set."); 17341 } 17342 goto __label_262;} 17343 } 17344 17345 V261 = (PyArrayObject*)(py_V261); 17346 Py_XINCREF(V261); 17347 17348 { 17349 17350 py_V263 = PyList_GET_ITEM(storage_V263, 0); 17351 {Py_XINCREF(py_V263);} 17352 17353 V263 = NULL; 17354 if (py_V263 == Py_None) { 17355 // We can either fail here or set V263 to NULL and rely on Ops 17356 // using tensors to handle the NULL case, but if they fail to do so 17357 // they'll end up with nasty segfaults, so this is public service. 17358 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 17359 { 17360 __failure = 264; 17361 if (!PyErr_Occurred()) { 17362 PyErr_SetString(PyExc_RuntimeError, 17363 "Unexpected error in an Op's C code. " 17364 "No Python exception was set."); 17365 } 17366 goto __label_264;} 17367 } 17368 if (!PyArray_Check(py_V263)) { 17369 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 17370 { 17371 __failure = 264; 17372 if (!PyErr_Occurred()) { 17373 PyErr_SetString(PyExc_RuntimeError, 17374 "Unexpected error in an Op's C code. " 17375 "No Python exception was set."); 17376 } 17377 goto __label_264;} 17378 } 17379 // We expect NPY_FLOAT64 17380 if (!PyArray_ISALIGNED((PyArrayObject*) py_V263)) { 17381 PyArrayObject * tmp = (PyArrayObject*) py_V263; 17382 PyErr_Format(PyExc_NotImplementedError, 17383 "expected an aligned array of type %ld " 17384 "(NPY_FLOAT64), got non-aligned array of type %ld" 17385 " with %ld dimensions, with 3 last dims " 17386 "%ld, %ld, %ld" 17387 " and 3 last strides %ld %ld, %ld.", 17388 (long int) NPY_FLOAT64, 17389 (long int) PyArray_TYPE((PyArrayObject*) py_V263), 17390 (long int) PyArray_NDIM(tmp), 17391 (long int) (PyArray_NDIM(tmp) >= 3 ? 17392 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 17393 (long int) (PyArray_NDIM(tmp) >= 2 ? 17394 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 17395 (long int) (PyArray_NDIM(tmp) >= 1 ? 17396 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 17397 (long int) (PyArray_NDIM(tmp) >= 3 ? 17398 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 17399 (long int) (PyArray_NDIM(tmp) >= 2 ? 17400 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 17401 (long int) (PyArray_NDIM(tmp) >= 1 ? 17402 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 17403 ); 17404 { 17405 __failure = 264; 17406 if (!PyErr_Occurred()) { 17407 PyErr_SetString(PyExc_RuntimeError, 17408 "Unexpected error in an Op's C code. " 17409 "No Python exception was set."); 17410 } 17411 goto __label_264;} 17412 } 17413 // This is a TypeError to be consistent with DEBUG_MODE 17414 // Note: DEBUG_MODE also tells the name of the container 17415 if (PyArray_TYPE((PyArrayObject*) py_V263) != NPY_FLOAT64) { 17416 PyErr_Format(PyExc_TypeError, 17417 "expected type_num %d (NPY_FLOAT64) got %d", 17418 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V263)); 17419 { 17420 __failure = 264; 17421 if (!PyErr_Occurred()) { 17422 PyErr_SetString(PyExc_RuntimeError, 17423 "Unexpected error in an Op's C code. " 17424 "No Python exception was set."); 17425 } 17426 goto __label_264;} 17427 } 17428 17429 V263 = (PyArrayObject*)(py_V263); 17430 Py_XINCREF(V263); 17431 17432 { 17433 17434 py_V265 = PyList_GET_ITEM(storage_V265, 0); 17435 {Py_XINCREF(py_V265);} 17436 17437 V265 = NULL; 17438 if (py_V265 == Py_None) { 17439 // We can either fail here or set V265 to NULL and rely on Ops 17440 // using tensors to handle the NULL case, but if they fail to do so 17441 // they'll end up with nasty segfaults, so this is public service. 17442 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 17443 { 17444 __failure = 266; 17445 if (!PyErr_Occurred()) { 17446 PyErr_SetString(PyExc_RuntimeError, 17447 "Unexpected error in an Op's C code. " 17448 "No Python exception was set."); 17449 } 17450 goto __label_266;} 17451 } 17452 if (!PyArray_Check(py_V265)) { 17453 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 17454 { 17455 __failure = 266; 17456 if (!PyErr_Occurred()) { 17457 PyErr_SetString(PyExc_RuntimeError, 17458 "Unexpected error in an Op's C code. " 17459 "No Python exception was set."); 17460 } 17461 goto __label_266;} 17462 } 17463 // We expect NPY_FLOAT64 17464 if (!PyArray_ISALIGNED((PyArrayObject*) py_V265)) { 17465 PyArrayObject * tmp = (PyArrayObject*) py_V265; 17466 PyErr_Format(PyExc_NotImplementedError, 17467 "expected an aligned array of type %ld " 17468 "(NPY_FLOAT64), got non-aligned array of type %ld" 17469 " with %ld dimensions, with 3 last dims " 17470 "%ld, %ld, %ld" 17471 " and 3 last strides %ld %ld, %ld.", 17472 (long int) NPY_FLOAT64, 17473 (long int) PyArray_TYPE((PyArrayObject*) py_V265), 17474 (long int) PyArray_NDIM(tmp), 17475 (long int) (PyArray_NDIM(tmp) >= 3 ? 17476 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 17477 (long int) (PyArray_NDIM(tmp) >= 2 ? 17478 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 17479 (long int) (PyArray_NDIM(tmp) >= 1 ? 17480 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 17481 (long int) (PyArray_NDIM(tmp) >= 3 ? 17482 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 17483 (long int) (PyArray_NDIM(tmp) >= 2 ? 17484 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 17485 (long int) (PyArray_NDIM(tmp) >= 1 ? 17486 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 17487 ); 17488 { 17489 __failure = 266; 17490 if (!PyErr_Occurred()) { 17491 PyErr_SetString(PyExc_RuntimeError, 17492 "Unexpected error in an Op's C code. " 17493 "No Python exception was set."); 17494 } 17495 goto __label_266;} 17496 } 17497 // This is a TypeError to be consistent with DEBUG_MODE 17498 // Note: DEBUG_MODE also tells the name of the container 17499 if (PyArray_TYPE((PyArrayObject*) py_V265) != NPY_FLOAT64) { 17500 PyErr_Format(PyExc_TypeError, 17501 "expected type_num %d (NPY_FLOAT64) got %d", 17502 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V265)); 17503 { 17504 __failure = 266; 17505 if (!PyErr_Occurred()) { 17506 PyErr_SetString(PyExc_RuntimeError, 17507 "Unexpected error in an Op's C code. " 17508 "No Python exception was set."); 17509 } 17510 goto __label_266;} 17511 } 17512 17513 V265 = (PyArrayObject*)(py_V265); 17514 Py_XINCREF(V265); 17515 17516 { 17517 17518 py_V267 = PyList_GET_ITEM(storage_V267, 0); 17519 {Py_XINCREF(py_V267);} 17520 17521 V267 = NULL; 17522 if (py_V267 == Py_None) { 17523 // We can either fail here or set V267 to NULL and rely on Ops 17524 // using tensors to handle the NULL case, but if they fail to do so 17525 // they'll end up with nasty segfaults, so this is public service. 17526 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 17527 { 17528 __failure = 268; 17529 if (!PyErr_Occurred()) { 17530 PyErr_SetString(PyExc_RuntimeError, 17531 "Unexpected error in an Op's C code. " 17532 "No Python exception was set."); 17533 } 17534 goto __label_268;} 17535 } 17536 if (!PyArray_Check(py_V267)) { 17537 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 17538 { 17539 __failure = 268; 17540 if (!PyErr_Occurred()) { 17541 PyErr_SetString(PyExc_RuntimeError, 17542 "Unexpected error in an Op's C code. " 17543 "No Python exception was set."); 17544 } 17545 goto __label_268;} 17546 } 17547 // We expect NPY_FLOAT64 17548 if (!PyArray_ISALIGNED((PyArrayObject*) py_V267)) { 17549 PyArrayObject * tmp = (PyArrayObject*) py_V267; 17550 PyErr_Format(PyExc_NotImplementedError, 17551 "expected an aligned array of type %ld " 17552 "(NPY_FLOAT64), got non-aligned array of type %ld" 17553 " with %ld dimensions, with 3 last dims " 17554 "%ld, %ld, %ld" 17555 " and 3 last strides %ld %ld, %ld.", 17556 (long int) NPY_FLOAT64, 17557 (long int) PyArray_TYPE((PyArrayObject*) py_V267), 17558 (long int) PyArray_NDIM(tmp), 17559 (long int) (PyArray_NDIM(tmp) >= 3 ? 17560 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 17561 (long int) (PyArray_NDIM(tmp) >= 2 ? 17562 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 17563 (long int) (PyArray_NDIM(tmp) >= 1 ? 17564 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 17565 (long int) (PyArray_NDIM(tmp) >= 3 ? 17566 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 17567 (long int) (PyArray_NDIM(tmp) >= 2 ? 17568 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 17569 (long int) (PyArray_NDIM(tmp) >= 1 ? 17570 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 17571 ); 17572 { 17573 __failure = 268; 17574 if (!PyErr_Occurred()) { 17575 PyErr_SetString(PyExc_RuntimeError, 17576 "Unexpected error in an Op's C code. " 17577 "No Python exception was set."); 17578 } 17579 goto __label_268;} 17580 } 17581 // This is a TypeError to be consistent with DEBUG_MODE 17582 // Note: DEBUG_MODE also tells the name of the container 17583 if (PyArray_TYPE((PyArrayObject*) py_V267) != NPY_FLOAT64) { 17584 PyErr_Format(PyExc_TypeError, 17585 "expected type_num %d (NPY_FLOAT64) got %d", 17586 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V267)); 17587 { 17588 __failure = 268; 17589 if (!PyErr_Occurred()) { 17590 PyErr_SetString(PyExc_RuntimeError, 17591 "Unexpected error in an Op's C code. " 17592 "No Python exception was set."); 17593 } 17594 goto __label_268;} 17595 } 17596 17597 V267 = (PyArrayObject*)(py_V267); 17598 Py_XINCREF(V267); 17599 17600 { 17601 17602 py_V269 = PyList_GET_ITEM(storage_V269, 0); 17603 {Py_XINCREF(py_V269);} 17604 17605 V269 = NULL; 17606 if (py_V269 == Py_None) { 17607 // We can either fail here or set V269 to NULL and rely on Ops 17608 // using tensors to handle the NULL case, but if they fail to do so 17609 // they'll end up with nasty segfaults, so this is public service. 17610 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 17611 { 17612 __failure = 270; 17613 if (!PyErr_Occurred()) { 17614 PyErr_SetString(PyExc_RuntimeError, 17615 "Unexpected error in an Op's C code. " 17616 "No Python exception was set."); 17617 } 17618 goto __label_270;} 17619 } 17620 if (!PyArray_Check(py_V269)) { 17621 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 17622 { 17623 __failure = 270; 17624 if (!PyErr_Occurred()) { 17625 PyErr_SetString(PyExc_RuntimeError, 17626 "Unexpected error in an Op's C code. " 17627 "No Python exception was set."); 17628 } 17629 goto __label_270;} 17630 } 17631 // We expect NPY_FLOAT64 17632 if (!PyArray_ISALIGNED((PyArrayObject*) py_V269)) { 17633 PyArrayObject * tmp = (PyArrayObject*) py_V269; 17634 PyErr_Format(PyExc_NotImplementedError, 17635 "expected an aligned array of type %ld " 17636 "(NPY_FLOAT64), got non-aligned array of type %ld" 17637 " with %ld dimensions, with 3 last dims " 17638 "%ld, %ld, %ld" 17639 " and 3 last strides %ld %ld, %ld.", 17640 (long int) NPY_FLOAT64, 17641 (long int) PyArray_TYPE((PyArrayObject*) py_V269), 17642 (long int) PyArray_NDIM(tmp), 17643 (long int) (PyArray_NDIM(tmp) >= 3 ? 17644 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 17645 (long int) (PyArray_NDIM(tmp) >= 2 ? 17646 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 17647 (long int) (PyArray_NDIM(tmp) >= 1 ? 17648 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 17649 (long int) (PyArray_NDIM(tmp) >= 3 ? 17650 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 17651 (long int) (PyArray_NDIM(tmp) >= 2 ? 17652 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 17653 (long int) (PyArray_NDIM(tmp) >= 1 ? 17654 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 17655 ); 17656 { 17657 __failure = 270; 17658 if (!PyErr_Occurred()) { 17659 PyErr_SetString(PyExc_RuntimeError, 17660 "Unexpected error in an Op's C code. " 17661 "No Python exception was set."); 17662 } 17663 goto __label_270;} 17664 } 17665 // This is a TypeError to be consistent with DEBUG_MODE 17666 // Note: DEBUG_MODE also tells the name of the container 17667 if (PyArray_TYPE((PyArrayObject*) py_V269) != NPY_FLOAT64) { 17668 PyErr_Format(PyExc_TypeError, 17669 "expected type_num %d (NPY_FLOAT64) got %d", 17670 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V269)); 17671 { 17672 __failure = 270; 17673 if (!PyErr_Occurred()) { 17674 PyErr_SetString(PyExc_RuntimeError, 17675 "Unexpected error in an Op's C code. " 17676 "No Python exception was set."); 17677 } 17678 goto __label_270;} 17679 } 17680 17681 V269 = (PyArrayObject*)(py_V269); 17682 Py_XINCREF(V269); 17683 17684 { 17685 17686 py_V271 = PyList_GET_ITEM(storage_V271, 0); 17687 {Py_XINCREF(py_V271);} 17688 17689 V271 = NULL; 17690 if (py_V271 == Py_None) { 17691 // We can either fail here or set V271 to NULL and rely on Ops 17692 // using tensors to handle the NULL case, but if they fail to do so 17693 // they'll end up with nasty segfaults, so this is public service. 17694 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 17695 { 17696 __failure = 272; 17697 if (!PyErr_Occurred()) { 17698 PyErr_SetString(PyExc_RuntimeError, 17699 "Unexpected error in an Op's C code. " 17700 "No Python exception was set."); 17701 } 17702 goto __label_272;} 17703 } 17704 if (!PyArray_Check(py_V271)) { 17705 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 17706 { 17707 __failure = 272; 17708 if (!PyErr_Occurred()) { 17709 PyErr_SetString(PyExc_RuntimeError, 17710 "Unexpected error in an Op's C code. " 17711 "No Python exception was set."); 17712 } 17713 goto __label_272;} 17714 } 17715 // We expect NPY_FLOAT64 17716 if (!PyArray_ISALIGNED((PyArrayObject*) py_V271)) { 17717 PyArrayObject * tmp = (PyArrayObject*) py_V271; 17718 PyErr_Format(PyExc_NotImplementedError, 17719 "expected an aligned array of type %ld " 17720 "(NPY_FLOAT64), got non-aligned array of type %ld" 17721 " with %ld dimensions, with 3 last dims " 17722 "%ld, %ld, %ld" 17723 " and 3 last strides %ld %ld, %ld.", 17724 (long int) NPY_FLOAT64, 17725 (long int) PyArray_TYPE((PyArrayObject*) py_V271), 17726 (long int) PyArray_NDIM(tmp), 17727 (long int) (PyArray_NDIM(tmp) >= 3 ? 17728 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 17729 (long int) (PyArray_NDIM(tmp) >= 2 ? 17730 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 17731 (long int) (PyArray_NDIM(tmp) >= 1 ? 17732 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 17733 (long int) (PyArray_NDIM(tmp) >= 3 ? 17734 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 17735 (long int) (PyArray_NDIM(tmp) >= 2 ? 17736 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 17737 (long int) (PyArray_NDIM(tmp) >= 1 ? 17738 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 17739 ); 17740 { 17741 __failure = 272; 17742 if (!PyErr_Occurred()) { 17743 PyErr_SetString(PyExc_RuntimeError, 17744 "Unexpected error in an Op's C code. " 17745 "No Python exception was set."); 17746 } 17747 goto __label_272;} 17748 } 17749 // This is a TypeError to be consistent with DEBUG_MODE 17750 // Note: DEBUG_MODE also tells the name of the container 17751 if (PyArray_TYPE((PyArrayObject*) py_V271) != NPY_FLOAT64) { 17752 PyErr_Format(PyExc_TypeError, 17753 "expected type_num %d (NPY_FLOAT64) got %d", 17754 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V271)); 17755 { 17756 __failure = 272; 17757 if (!PyErr_Occurred()) { 17758 PyErr_SetString(PyExc_RuntimeError, 17759 "Unexpected error in an Op's C code. " 17760 "No Python exception was set."); 17761 } 17762 goto __label_272;} 17763 } 17764 17765 V271 = (PyArrayObject*)(py_V271); 17766 Py_XINCREF(V271); 17767 17768 { 17769 17770 py_V273 = PyList_GET_ITEM(storage_V273, 0); 17771 {Py_XINCREF(py_V273);} 17772 17773 V273 = NULL; 17774 if (py_V273 == Py_None) { 17775 // We can either fail here or set V273 to NULL and rely on Ops 17776 // using tensors to handle the NULL case, but if they fail to do so 17777 // they'll end up with nasty segfaults, so this is public service. 17778 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 17779 { 17780 __failure = 274; 17781 if (!PyErr_Occurred()) { 17782 PyErr_SetString(PyExc_RuntimeError, 17783 "Unexpected error in an Op's C code. " 17784 "No Python exception was set."); 17785 } 17786 goto __label_274;} 17787 } 17788 if (!PyArray_Check(py_V273)) { 17789 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 17790 { 17791 __failure = 274; 17792 if (!PyErr_Occurred()) { 17793 PyErr_SetString(PyExc_RuntimeError, 17794 "Unexpected error in an Op's C code. " 17795 "No Python exception was set."); 17796 } 17797 goto __label_274;} 17798 } 17799 // We expect NPY_FLOAT64 17800 if (!PyArray_ISALIGNED((PyArrayObject*) py_V273)) { 17801 PyArrayObject * tmp = (PyArrayObject*) py_V273; 17802 PyErr_Format(PyExc_NotImplementedError, 17803 "expected an aligned array of type %ld " 17804 "(NPY_FLOAT64), got non-aligned array of type %ld" 17805 " with %ld dimensions, with 3 last dims " 17806 "%ld, %ld, %ld" 17807 " and 3 last strides %ld %ld, %ld.", 17808 (long int) NPY_FLOAT64, 17809 (long int) PyArray_TYPE((PyArrayObject*) py_V273), 17810 (long int) PyArray_NDIM(tmp), 17811 (long int) (PyArray_NDIM(tmp) >= 3 ? 17812 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 17813 (long int) (PyArray_NDIM(tmp) >= 2 ? 17814 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 17815 (long int) (PyArray_NDIM(tmp) >= 1 ? 17816 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 17817 (long int) (PyArray_NDIM(tmp) >= 3 ? 17818 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 17819 (long int) (PyArray_NDIM(tmp) >= 2 ? 17820 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 17821 (long int) (PyArray_NDIM(tmp) >= 1 ? 17822 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 17823 ); 17824 { 17825 __failure = 274; 17826 if (!PyErr_Occurred()) { 17827 PyErr_SetString(PyExc_RuntimeError, 17828 "Unexpected error in an Op's C code. " 17829 "No Python exception was set."); 17830 } 17831 goto __label_274;} 17832 } 17833 // This is a TypeError to be consistent with DEBUG_MODE 17834 // Note: DEBUG_MODE also tells the name of the container 17835 if (PyArray_TYPE((PyArrayObject*) py_V273) != NPY_FLOAT64) { 17836 PyErr_Format(PyExc_TypeError, 17837 "expected type_num %d (NPY_FLOAT64) got %d", 17838 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V273)); 17839 { 17840 __failure = 274; 17841 if (!PyErr_Occurred()) { 17842 PyErr_SetString(PyExc_RuntimeError, 17843 "Unexpected error in an Op's C code. " 17844 "No Python exception was set."); 17845 } 17846 goto __label_274;} 17847 } 17848 17849 V273 = (PyArrayObject*)(py_V273); 17850 Py_XINCREF(V273); 17851 17852 { 17853 17854 py_V275 = PyList_GET_ITEM(storage_V275, 0); 17855 {Py_XINCREF(py_V275);} 17856 17857 V275 = NULL; 17858 if (py_V275 == Py_None) { 17859 // We can either fail here or set V275 to NULL and rely on Ops 17860 // using tensors to handle the NULL case, but if they fail to do so 17861 // they'll end up with nasty segfaults, so this is public service. 17862 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 17863 { 17864 __failure = 276; 17865 if (!PyErr_Occurred()) { 17866 PyErr_SetString(PyExc_RuntimeError, 17867 "Unexpected error in an Op's C code. " 17868 "No Python exception was set."); 17869 } 17870 goto __label_276;} 17871 } 17872 if (!PyArray_Check(py_V275)) { 17873 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 17874 { 17875 __failure = 276; 17876 if (!PyErr_Occurred()) { 17877 PyErr_SetString(PyExc_RuntimeError, 17878 "Unexpected error in an Op's C code. " 17879 "No Python exception was set."); 17880 } 17881 goto __label_276;} 17882 } 17883 // We expect NPY_FLOAT64 17884 if (!PyArray_ISALIGNED((PyArrayObject*) py_V275)) { 17885 PyArrayObject * tmp = (PyArrayObject*) py_V275; 17886 PyErr_Format(PyExc_NotImplementedError, 17887 "expected an aligned array of type %ld " 17888 "(NPY_FLOAT64), got non-aligned array of type %ld" 17889 " with %ld dimensions, with 3 last dims " 17890 "%ld, %ld, %ld" 17891 " and 3 last strides %ld %ld, %ld.", 17892 (long int) NPY_FLOAT64, 17893 (long int) PyArray_TYPE((PyArrayObject*) py_V275), 17894 (long int) PyArray_NDIM(tmp), 17895 (long int) (PyArray_NDIM(tmp) >= 3 ? 17896 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 17897 (long int) (PyArray_NDIM(tmp) >= 2 ? 17898 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 17899 (long int) (PyArray_NDIM(tmp) >= 1 ? 17900 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 17901 (long int) (PyArray_NDIM(tmp) >= 3 ? 17902 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 17903 (long int) (PyArray_NDIM(tmp) >= 2 ? 17904 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 17905 (long int) (PyArray_NDIM(tmp) >= 1 ? 17906 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 17907 ); 17908 { 17909 __failure = 276; 17910 if (!PyErr_Occurred()) { 17911 PyErr_SetString(PyExc_RuntimeError, 17912 "Unexpected error in an Op's C code. " 17913 "No Python exception was set."); 17914 } 17915 goto __label_276;} 17916 } 17917 // This is a TypeError to be consistent with DEBUG_MODE 17918 // Note: DEBUG_MODE also tells the name of the container 17919 if (PyArray_TYPE((PyArrayObject*) py_V275) != NPY_FLOAT64) { 17920 PyErr_Format(PyExc_TypeError, 17921 "expected type_num %d (NPY_FLOAT64) got %d", 17922 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V275)); 17923 { 17924 __failure = 276; 17925 if (!PyErr_Occurred()) { 17926 PyErr_SetString(PyExc_RuntimeError, 17927 "Unexpected error in an Op's C code. " 17928 "No Python exception was set."); 17929 } 17930 goto __label_276;} 17931 } 17932 17933 V275 = (PyArrayObject*)(py_V275); 17934 Py_XINCREF(V275); 17935 17936 { 17937 17938 py_V277 = PyList_GET_ITEM(storage_V277, 0); 17939 {Py_XINCREF(py_V277);} 17940 17941 V277 = NULL; 17942 if (py_V277 == Py_None) { 17943 // We can either fail here or set V277 to NULL and rely on Ops 17944 // using tensors to handle the NULL case, but if they fail to do so 17945 // they'll end up with nasty segfaults, so this is public service. 17946 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 17947 { 17948 __failure = 278; 17949 if (!PyErr_Occurred()) { 17950 PyErr_SetString(PyExc_RuntimeError, 17951 "Unexpected error in an Op's C code. " 17952 "No Python exception was set."); 17953 } 17954 goto __label_278;} 17955 } 17956 if (!PyArray_Check(py_V277)) { 17957 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 17958 { 17959 __failure = 278; 17960 if (!PyErr_Occurred()) { 17961 PyErr_SetString(PyExc_RuntimeError, 17962 "Unexpected error in an Op's C code. " 17963 "No Python exception was set."); 17964 } 17965 goto __label_278;} 17966 } 17967 // We expect NPY_FLOAT64 17968 if (!PyArray_ISALIGNED((PyArrayObject*) py_V277)) { 17969 PyArrayObject * tmp = (PyArrayObject*) py_V277; 17970 PyErr_Format(PyExc_NotImplementedError, 17971 "expected an aligned array of type %ld " 17972 "(NPY_FLOAT64), got non-aligned array of type %ld" 17973 " with %ld dimensions, with 3 last dims " 17974 "%ld, %ld, %ld" 17975 " and 3 last strides %ld %ld, %ld.", 17976 (long int) NPY_FLOAT64, 17977 (long int) PyArray_TYPE((PyArrayObject*) py_V277), 17978 (long int) PyArray_NDIM(tmp), 17979 (long int) (PyArray_NDIM(tmp) >= 3 ? 17980 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 17981 (long int) (PyArray_NDIM(tmp) >= 2 ? 17982 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 17983 (long int) (PyArray_NDIM(tmp) >= 1 ? 17984 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 17985 (long int) (PyArray_NDIM(tmp) >= 3 ? 17986 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 17987 (long int) (PyArray_NDIM(tmp) >= 2 ? 17988 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 17989 (long int) (PyArray_NDIM(tmp) >= 1 ? 17990 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 17991 ); 17992 { 17993 __failure = 278; 17994 if (!PyErr_Occurred()) { 17995 PyErr_SetString(PyExc_RuntimeError, 17996 "Unexpected error in an Op's C code. " 17997 "No Python exception was set."); 17998 } 17999 goto __label_278;} 18000 } 18001 // This is a TypeError to be consistent with DEBUG_MODE 18002 // Note: DEBUG_MODE also tells the name of the container 18003 if (PyArray_TYPE((PyArrayObject*) py_V277) != NPY_FLOAT64) { 18004 PyErr_Format(PyExc_TypeError, 18005 "expected type_num %d (NPY_FLOAT64) got %d", 18006 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V277)); 18007 { 18008 __failure = 278; 18009 if (!PyErr_Occurred()) { 18010 PyErr_SetString(PyExc_RuntimeError, 18011 "Unexpected error in an Op's C code. " 18012 "No Python exception was set."); 18013 } 18014 goto __label_278;} 18015 } 18016 18017 V277 = (PyArrayObject*)(py_V277); 18018 Py_XINCREF(V277); 18019 18020 { 18021 18022 py_V279 = PyList_GET_ITEM(storage_V279, 0); 18023 {Py_XINCREF(py_V279);} 18024 18025 V279 = NULL; 18026 if (py_V279 == Py_None) { 18027 // We can either fail here or set V279 to NULL and rely on Ops 18028 // using tensors to handle the NULL case, but if they fail to do so 18029 // they'll end up with nasty segfaults, so this is public service. 18030 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 18031 { 18032 __failure = 280; 18033 if (!PyErr_Occurred()) { 18034 PyErr_SetString(PyExc_RuntimeError, 18035 "Unexpected error in an Op's C code. " 18036 "No Python exception was set."); 18037 } 18038 goto __label_280;} 18039 } 18040 if (!PyArray_Check(py_V279)) { 18041 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 18042 { 18043 __failure = 280; 18044 if (!PyErr_Occurred()) { 18045 PyErr_SetString(PyExc_RuntimeError, 18046 "Unexpected error in an Op's C code. " 18047 "No Python exception was set."); 18048 } 18049 goto __label_280;} 18050 } 18051 // We expect NPY_FLOAT64 18052 if (!PyArray_ISALIGNED((PyArrayObject*) py_V279)) { 18053 PyArrayObject * tmp = (PyArrayObject*) py_V279; 18054 PyErr_Format(PyExc_NotImplementedError, 18055 "expected an aligned array of type %ld " 18056 "(NPY_FLOAT64), got non-aligned array of type %ld" 18057 " with %ld dimensions, with 3 last dims " 18058 "%ld, %ld, %ld" 18059 " and 3 last strides %ld %ld, %ld.", 18060 (long int) NPY_FLOAT64, 18061 (long int) PyArray_TYPE((PyArrayObject*) py_V279), 18062 (long int) PyArray_NDIM(tmp), 18063 (long int) (PyArray_NDIM(tmp) >= 3 ? 18064 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 18065 (long int) (PyArray_NDIM(tmp) >= 2 ? 18066 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 18067 (long int) (PyArray_NDIM(tmp) >= 1 ? 18068 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 18069 (long int) (PyArray_NDIM(tmp) >= 3 ? 18070 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 18071 (long int) (PyArray_NDIM(tmp) >= 2 ? 18072 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 18073 (long int) (PyArray_NDIM(tmp) >= 1 ? 18074 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 18075 ); 18076 { 18077 __failure = 280; 18078 if (!PyErr_Occurred()) { 18079 PyErr_SetString(PyExc_RuntimeError, 18080 "Unexpected error in an Op's C code. " 18081 "No Python exception was set."); 18082 } 18083 goto __label_280;} 18084 } 18085 // This is a TypeError to be consistent with DEBUG_MODE 18086 // Note: DEBUG_MODE also tells the name of the container 18087 if (PyArray_TYPE((PyArrayObject*) py_V279) != NPY_FLOAT64) { 18088 PyErr_Format(PyExc_TypeError, 18089 "expected type_num %d (NPY_FLOAT64) got %d", 18090 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V279)); 18091 { 18092 __failure = 280; 18093 if (!PyErr_Occurred()) { 18094 PyErr_SetString(PyExc_RuntimeError, 18095 "Unexpected error in an Op's C code. " 18096 "No Python exception was set."); 18097 } 18098 goto __label_280;} 18099 } 18100 18101 V279 = (PyArrayObject*)(py_V279); 18102 Py_XINCREF(V279); 18103 18104 { 18105 18106 py_V281 = PyList_GET_ITEM(storage_V281, 0); 18107 {Py_XINCREF(py_V281);} 18108 18109 V281 = NULL; 18110 if (py_V281 == Py_None) { 18111 // We can either fail here or set V281 to NULL and rely on Ops 18112 // using tensors to handle the NULL case, but if they fail to do so 18113 // they'll end up with nasty segfaults, so this is public service. 18114 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 18115 { 18116 __failure = 282; 18117 if (!PyErr_Occurred()) { 18118 PyErr_SetString(PyExc_RuntimeError, 18119 "Unexpected error in an Op's C code. " 18120 "No Python exception was set."); 18121 } 18122 goto __label_282;} 18123 } 18124 if (!PyArray_Check(py_V281)) { 18125 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 18126 { 18127 __failure = 282; 18128 if (!PyErr_Occurred()) { 18129 PyErr_SetString(PyExc_RuntimeError, 18130 "Unexpected error in an Op's C code. " 18131 "No Python exception was set."); 18132 } 18133 goto __label_282;} 18134 } 18135 // We expect NPY_FLOAT64 18136 if (!PyArray_ISALIGNED((PyArrayObject*) py_V281)) { 18137 PyArrayObject * tmp = (PyArrayObject*) py_V281; 18138 PyErr_Format(PyExc_NotImplementedError, 18139 "expected an aligned array of type %ld " 18140 "(NPY_FLOAT64), got non-aligned array of type %ld" 18141 " with %ld dimensions, with 3 last dims " 18142 "%ld, %ld, %ld" 18143 " and 3 last strides %ld %ld, %ld.", 18144 (long int) NPY_FLOAT64, 18145 (long int) PyArray_TYPE((PyArrayObject*) py_V281), 18146 (long int) PyArray_NDIM(tmp), 18147 (long int) (PyArray_NDIM(tmp) >= 3 ? 18148 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 18149 (long int) (PyArray_NDIM(tmp) >= 2 ? 18150 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 18151 (long int) (PyArray_NDIM(tmp) >= 1 ? 18152 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 18153 (long int) (PyArray_NDIM(tmp) >= 3 ? 18154 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 18155 (long int) (PyArray_NDIM(tmp) >= 2 ? 18156 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 18157 (long int) (PyArray_NDIM(tmp) >= 1 ? 18158 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 18159 ); 18160 { 18161 __failure = 282; 18162 if (!PyErr_Occurred()) { 18163 PyErr_SetString(PyExc_RuntimeError, 18164 "Unexpected error in an Op's C code. " 18165 "No Python exception was set."); 18166 } 18167 goto __label_282;} 18168 } 18169 // This is a TypeError to be consistent with DEBUG_MODE 18170 // Note: DEBUG_MODE also tells the name of the container 18171 if (PyArray_TYPE((PyArrayObject*) py_V281) != NPY_FLOAT64) { 18172 PyErr_Format(PyExc_TypeError, 18173 "expected type_num %d (NPY_FLOAT64) got %d", 18174 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V281)); 18175 { 18176 __failure = 282; 18177 if (!PyErr_Occurred()) { 18178 PyErr_SetString(PyExc_RuntimeError, 18179 "Unexpected error in an Op's C code. " 18180 "No Python exception was set."); 18181 } 18182 goto __label_282;} 18183 } 18184 18185 V281 = (PyArrayObject*)(py_V281); 18186 Py_XINCREF(V281); 18187 18188 { 18189 18190 py_V283 = PyList_GET_ITEM(storage_V283, 0); 18191 {Py_XINCREF(py_V283);} 18192 18193 V283 = NULL; 18194 if (py_V283 == Py_None) { 18195 // We can either fail here or set V283 to NULL and rely on Ops 18196 // using tensors to handle the NULL case, but if they fail to do so 18197 // they'll end up with nasty segfaults, so this is public service. 18198 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 18199 { 18200 __failure = 284; 18201 if (!PyErr_Occurred()) { 18202 PyErr_SetString(PyExc_RuntimeError, 18203 "Unexpected error in an Op's C code. " 18204 "No Python exception was set."); 18205 } 18206 goto __label_284;} 18207 } 18208 if (!PyArray_Check(py_V283)) { 18209 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 18210 { 18211 __failure = 284; 18212 if (!PyErr_Occurred()) { 18213 PyErr_SetString(PyExc_RuntimeError, 18214 "Unexpected error in an Op's C code. " 18215 "No Python exception was set."); 18216 } 18217 goto __label_284;} 18218 } 18219 // We expect NPY_FLOAT64 18220 if (!PyArray_ISALIGNED((PyArrayObject*) py_V283)) { 18221 PyArrayObject * tmp = (PyArrayObject*) py_V283; 18222 PyErr_Format(PyExc_NotImplementedError, 18223 "expected an aligned array of type %ld " 18224 "(NPY_FLOAT64), got non-aligned array of type %ld" 18225 " with %ld dimensions, with 3 last dims " 18226 "%ld, %ld, %ld" 18227 " and 3 last strides %ld %ld, %ld.", 18228 (long int) NPY_FLOAT64, 18229 (long int) PyArray_TYPE((PyArrayObject*) py_V283), 18230 (long int) PyArray_NDIM(tmp), 18231 (long int) (PyArray_NDIM(tmp) >= 3 ? 18232 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 18233 (long int) (PyArray_NDIM(tmp) >= 2 ? 18234 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 18235 (long int) (PyArray_NDIM(tmp) >= 1 ? 18236 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 18237 (long int) (PyArray_NDIM(tmp) >= 3 ? 18238 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 18239 (long int) (PyArray_NDIM(tmp) >= 2 ? 18240 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 18241 (long int) (PyArray_NDIM(tmp) >= 1 ? 18242 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 18243 ); 18244 { 18245 __failure = 284; 18246 if (!PyErr_Occurred()) { 18247 PyErr_SetString(PyExc_RuntimeError, 18248 "Unexpected error in an Op's C code. " 18249 "No Python exception was set."); 18250 } 18251 goto __label_284;} 18252 } 18253 // This is a TypeError to be consistent with DEBUG_MODE 18254 // Note: DEBUG_MODE also tells the name of the container 18255 if (PyArray_TYPE((PyArrayObject*) py_V283) != NPY_FLOAT64) { 18256 PyErr_Format(PyExc_TypeError, 18257 "expected type_num %d (NPY_FLOAT64) got %d", 18258 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V283)); 18259 { 18260 __failure = 284; 18261 if (!PyErr_Occurred()) { 18262 PyErr_SetString(PyExc_RuntimeError, 18263 "Unexpected error in an Op's C code. " 18264 "No Python exception was set."); 18265 } 18266 goto __label_284;} 18267 } 18268 18269 V283 = (PyArrayObject*)(py_V283); 18270 Py_XINCREF(V283); 18271 18272 { 18273 18274 py_V285 = PyList_GET_ITEM(storage_V285, 0); 18275 {Py_XINCREF(py_V285);} 18276 18277 V285 = NULL; 18278 if (py_V285 == Py_None) { 18279 // We can either fail here or set V285 to NULL and rely on Ops 18280 // using tensors to handle the NULL case, but if they fail to do so 18281 // they'll end up with nasty segfaults, so this is public service. 18282 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 18283 { 18284 __failure = 286; 18285 if (!PyErr_Occurred()) { 18286 PyErr_SetString(PyExc_RuntimeError, 18287 "Unexpected error in an Op's C code. " 18288 "No Python exception was set."); 18289 } 18290 goto __label_286;} 18291 } 18292 if (!PyArray_Check(py_V285)) { 18293 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 18294 { 18295 __failure = 286; 18296 if (!PyErr_Occurred()) { 18297 PyErr_SetString(PyExc_RuntimeError, 18298 "Unexpected error in an Op's C code. " 18299 "No Python exception was set."); 18300 } 18301 goto __label_286;} 18302 } 18303 // We expect NPY_FLOAT64 18304 if (!PyArray_ISALIGNED((PyArrayObject*) py_V285)) { 18305 PyArrayObject * tmp = (PyArrayObject*) py_V285; 18306 PyErr_Format(PyExc_NotImplementedError, 18307 "expected an aligned array of type %ld " 18308 "(NPY_FLOAT64), got non-aligned array of type %ld" 18309 " with %ld dimensions, with 3 last dims " 18310 "%ld, %ld, %ld" 18311 " and 3 last strides %ld %ld, %ld.", 18312 (long int) NPY_FLOAT64, 18313 (long int) PyArray_TYPE((PyArrayObject*) py_V285), 18314 (long int) PyArray_NDIM(tmp), 18315 (long int) (PyArray_NDIM(tmp) >= 3 ? 18316 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 18317 (long int) (PyArray_NDIM(tmp) >= 2 ? 18318 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 18319 (long int) (PyArray_NDIM(tmp) >= 1 ? 18320 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 18321 (long int) (PyArray_NDIM(tmp) >= 3 ? 18322 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 18323 (long int) (PyArray_NDIM(tmp) >= 2 ? 18324 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 18325 (long int) (PyArray_NDIM(tmp) >= 1 ? 18326 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 18327 ); 18328 { 18329 __failure = 286; 18330 if (!PyErr_Occurred()) { 18331 PyErr_SetString(PyExc_RuntimeError, 18332 "Unexpected error in an Op's C code. " 18333 "No Python exception was set."); 18334 } 18335 goto __label_286;} 18336 } 18337 // This is a TypeError to be consistent with DEBUG_MODE 18338 // Note: DEBUG_MODE also tells the name of the container 18339 if (PyArray_TYPE((PyArrayObject*) py_V285) != NPY_FLOAT64) { 18340 PyErr_Format(PyExc_TypeError, 18341 "expected type_num %d (NPY_FLOAT64) got %d", 18342 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V285)); 18343 { 18344 __failure = 286; 18345 if (!PyErr_Occurred()) { 18346 PyErr_SetString(PyExc_RuntimeError, 18347 "Unexpected error in an Op's C code. " 18348 "No Python exception was set."); 18349 } 18350 goto __label_286;} 18351 } 18352 18353 V285 = (PyArrayObject*)(py_V285); 18354 Py_XINCREF(V285); 18355 18356 { 18357 18358 py_V287 = PyList_GET_ITEM(storage_V287, 0); 18359 {Py_XINCREF(py_V287);} 18360 18361 V287 = NULL; 18362 if (py_V287 == Py_None) { 18363 // We can either fail here or set V287 to NULL and rely on Ops 18364 // using tensors to handle the NULL case, but if they fail to do so 18365 // they'll end up with nasty segfaults, so this is public service. 18366 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 18367 { 18368 __failure = 288; 18369 if (!PyErr_Occurred()) { 18370 PyErr_SetString(PyExc_RuntimeError, 18371 "Unexpected error in an Op's C code. " 18372 "No Python exception was set."); 18373 } 18374 goto __label_288;} 18375 } 18376 if (!PyArray_Check(py_V287)) { 18377 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 18378 { 18379 __failure = 288; 18380 if (!PyErr_Occurred()) { 18381 PyErr_SetString(PyExc_RuntimeError, 18382 "Unexpected error in an Op's C code. " 18383 "No Python exception was set."); 18384 } 18385 goto __label_288;} 18386 } 18387 // We expect NPY_FLOAT64 18388 if (!PyArray_ISALIGNED((PyArrayObject*) py_V287)) { 18389 PyArrayObject * tmp = (PyArrayObject*) py_V287; 18390 PyErr_Format(PyExc_NotImplementedError, 18391 "expected an aligned array of type %ld " 18392 "(NPY_FLOAT64), got non-aligned array of type %ld" 18393 " with %ld dimensions, with 3 last dims " 18394 "%ld, %ld, %ld" 18395 " and 3 last strides %ld %ld, %ld.", 18396 (long int) NPY_FLOAT64, 18397 (long int) PyArray_TYPE((PyArrayObject*) py_V287), 18398 (long int) PyArray_NDIM(tmp), 18399 (long int) (PyArray_NDIM(tmp) >= 3 ? 18400 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 18401 (long int) (PyArray_NDIM(tmp) >= 2 ? 18402 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 18403 (long int) (PyArray_NDIM(tmp) >= 1 ? 18404 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 18405 (long int) (PyArray_NDIM(tmp) >= 3 ? 18406 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 18407 (long int) (PyArray_NDIM(tmp) >= 2 ? 18408 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 18409 (long int) (PyArray_NDIM(tmp) >= 1 ? 18410 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 18411 ); 18412 { 18413 __failure = 288; 18414 if (!PyErr_Occurred()) { 18415 PyErr_SetString(PyExc_RuntimeError, 18416 "Unexpected error in an Op's C code. " 18417 "No Python exception was set."); 18418 } 18419 goto __label_288;} 18420 } 18421 // This is a TypeError to be consistent with DEBUG_MODE 18422 // Note: DEBUG_MODE also tells the name of the container 18423 if (PyArray_TYPE((PyArrayObject*) py_V287) != NPY_FLOAT64) { 18424 PyErr_Format(PyExc_TypeError, 18425 "expected type_num %d (NPY_FLOAT64) got %d", 18426 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V287)); 18427 { 18428 __failure = 288; 18429 if (!PyErr_Occurred()) { 18430 PyErr_SetString(PyExc_RuntimeError, 18431 "Unexpected error in an Op's C code. " 18432 "No Python exception was set."); 18433 } 18434 goto __label_288;} 18435 } 18436 18437 V287 = (PyArrayObject*)(py_V287); 18438 Py_XINCREF(V287); 18439 18440 { 18441 18442 py_V289 = PyList_GET_ITEM(storage_V289, 0); 18443 {Py_XINCREF(py_V289);} 18444 18445 V289 = NULL; 18446 if (py_V289 == Py_None) { 18447 // We can either fail here or set V289 to NULL and rely on Ops 18448 // using tensors to handle the NULL case, but if they fail to do so 18449 // they'll end up with nasty segfaults, so this is public service. 18450 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 18451 { 18452 __failure = 290; 18453 if (!PyErr_Occurred()) { 18454 PyErr_SetString(PyExc_RuntimeError, 18455 "Unexpected error in an Op's C code. " 18456 "No Python exception was set."); 18457 } 18458 goto __label_290;} 18459 } 18460 if (!PyArray_Check(py_V289)) { 18461 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 18462 { 18463 __failure = 290; 18464 if (!PyErr_Occurred()) { 18465 PyErr_SetString(PyExc_RuntimeError, 18466 "Unexpected error in an Op's C code. " 18467 "No Python exception was set."); 18468 } 18469 goto __label_290;} 18470 } 18471 // We expect NPY_FLOAT64 18472 if (!PyArray_ISALIGNED((PyArrayObject*) py_V289)) { 18473 PyArrayObject * tmp = (PyArrayObject*) py_V289; 18474 PyErr_Format(PyExc_NotImplementedError, 18475 "expected an aligned array of type %ld " 18476 "(NPY_FLOAT64), got non-aligned array of type %ld" 18477 " with %ld dimensions, with 3 last dims " 18478 "%ld, %ld, %ld" 18479 " and 3 last strides %ld %ld, %ld.", 18480 (long int) NPY_FLOAT64, 18481 (long int) PyArray_TYPE((PyArrayObject*) py_V289), 18482 (long int) PyArray_NDIM(tmp), 18483 (long int) (PyArray_NDIM(tmp) >= 3 ? 18484 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 18485 (long int) (PyArray_NDIM(tmp) >= 2 ? 18486 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 18487 (long int) (PyArray_NDIM(tmp) >= 1 ? 18488 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 18489 (long int) (PyArray_NDIM(tmp) >= 3 ? 18490 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 18491 (long int) (PyArray_NDIM(tmp) >= 2 ? 18492 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 18493 (long int) (PyArray_NDIM(tmp) >= 1 ? 18494 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 18495 ); 18496 { 18497 __failure = 290; 18498 if (!PyErr_Occurred()) { 18499 PyErr_SetString(PyExc_RuntimeError, 18500 "Unexpected error in an Op's C code. " 18501 "No Python exception was set."); 18502 } 18503 goto __label_290;} 18504 } 18505 // This is a TypeError to be consistent with DEBUG_MODE 18506 // Note: DEBUG_MODE also tells the name of the container 18507 if (PyArray_TYPE((PyArrayObject*) py_V289) != NPY_FLOAT64) { 18508 PyErr_Format(PyExc_TypeError, 18509 "expected type_num %d (NPY_FLOAT64) got %d", 18510 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V289)); 18511 { 18512 __failure = 290; 18513 if (!PyErr_Occurred()) { 18514 PyErr_SetString(PyExc_RuntimeError, 18515 "Unexpected error in an Op's C code. " 18516 "No Python exception was set."); 18517 } 18518 goto __label_290;} 18519 } 18520 18521 V289 = (PyArrayObject*)(py_V289); 18522 Py_XINCREF(V289); 18523 18524 { 18525 18526 py_V291 = PyList_GET_ITEM(storage_V291, 0); 18527 {Py_XINCREF(py_V291);} 18528 18529 V291 = NULL; 18530 if (py_V291 == Py_None) { 18531 // We can either fail here or set V291 to NULL and rely on Ops 18532 // using tensors to handle the NULL case, but if they fail to do so 18533 // they'll end up with nasty segfaults, so this is public service. 18534 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 18535 { 18536 __failure = 292; 18537 if (!PyErr_Occurred()) { 18538 PyErr_SetString(PyExc_RuntimeError, 18539 "Unexpected error in an Op's C code. " 18540 "No Python exception was set."); 18541 } 18542 goto __label_292;} 18543 } 18544 if (!PyArray_Check(py_V291)) { 18545 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 18546 { 18547 __failure = 292; 18548 if (!PyErr_Occurred()) { 18549 PyErr_SetString(PyExc_RuntimeError, 18550 "Unexpected error in an Op's C code. " 18551 "No Python exception was set."); 18552 } 18553 goto __label_292;} 18554 } 18555 // We expect NPY_FLOAT64 18556 if (!PyArray_ISALIGNED((PyArrayObject*) py_V291)) { 18557 PyArrayObject * tmp = (PyArrayObject*) py_V291; 18558 PyErr_Format(PyExc_NotImplementedError, 18559 "expected an aligned array of type %ld " 18560 "(NPY_FLOAT64), got non-aligned array of type %ld" 18561 " with %ld dimensions, with 3 last dims " 18562 "%ld, %ld, %ld" 18563 " and 3 last strides %ld %ld, %ld.", 18564 (long int) NPY_FLOAT64, 18565 (long int) PyArray_TYPE((PyArrayObject*) py_V291), 18566 (long int) PyArray_NDIM(tmp), 18567 (long int) (PyArray_NDIM(tmp) >= 3 ? 18568 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 18569 (long int) (PyArray_NDIM(tmp) >= 2 ? 18570 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 18571 (long int) (PyArray_NDIM(tmp) >= 1 ? 18572 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 18573 (long int) (PyArray_NDIM(tmp) >= 3 ? 18574 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 18575 (long int) (PyArray_NDIM(tmp) >= 2 ? 18576 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 18577 (long int) (PyArray_NDIM(tmp) >= 1 ? 18578 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 18579 ); 18580 { 18581 __failure = 292; 18582 if (!PyErr_Occurred()) { 18583 PyErr_SetString(PyExc_RuntimeError, 18584 "Unexpected error in an Op's C code. " 18585 "No Python exception was set."); 18586 } 18587 goto __label_292;} 18588 } 18589 // This is a TypeError to be consistent with DEBUG_MODE 18590 // Note: DEBUG_MODE also tells the name of the container 18591 if (PyArray_TYPE((PyArrayObject*) py_V291) != NPY_FLOAT64) { 18592 PyErr_Format(PyExc_TypeError, 18593 "expected type_num %d (NPY_FLOAT64) got %d", 18594 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V291)); 18595 { 18596 __failure = 292; 18597 if (!PyErr_Occurred()) { 18598 PyErr_SetString(PyExc_RuntimeError, 18599 "Unexpected error in an Op's C code. " 18600 "No Python exception was set."); 18601 } 18602 goto __label_292;} 18603 } 18604 18605 V291 = (PyArrayObject*)(py_V291); 18606 Py_XINCREF(V291); 18607 18608 { 18609 18610 py_V293 = PyList_GET_ITEM(storage_V293, 0); 18611 {Py_XINCREF(py_V293);} 18612 18613 V293 = NULL; 18614 if (py_V293 == Py_None) { 18615 // We can either fail here or set V293 to NULL and rely on Ops 18616 // using tensors to handle the NULL case, but if they fail to do so 18617 // they'll end up with nasty segfaults, so this is public service. 18618 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 18619 { 18620 __failure = 294; 18621 if (!PyErr_Occurred()) { 18622 PyErr_SetString(PyExc_RuntimeError, 18623 "Unexpected error in an Op's C code. " 18624 "No Python exception was set."); 18625 } 18626 goto __label_294;} 18627 } 18628 if (!PyArray_Check(py_V293)) { 18629 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 18630 { 18631 __failure = 294; 18632 if (!PyErr_Occurred()) { 18633 PyErr_SetString(PyExc_RuntimeError, 18634 "Unexpected error in an Op's C code. " 18635 "No Python exception was set."); 18636 } 18637 goto __label_294;} 18638 } 18639 // We expect NPY_FLOAT64 18640 if (!PyArray_ISALIGNED((PyArrayObject*) py_V293)) { 18641 PyArrayObject * tmp = (PyArrayObject*) py_V293; 18642 PyErr_Format(PyExc_NotImplementedError, 18643 "expected an aligned array of type %ld " 18644 "(NPY_FLOAT64), got non-aligned array of type %ld" 18645 " with %ld dimensions, with 3 last dims " 18646 "%ld, %ld, %ld" 18647 " and 3 last strides %ld %ld, %ld.", 18648 (long int) NPY_FLOAT64, 18649 (long int) PyArray_TYPE((PyArrayObject*) py_V293), 18650 (long int) PyArray_NDIM(tmp), 18651 (long int) (PyArray_NDIM(tmp) >= 3 ? 18652 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 18653 (long int) (PyArray_NDIM(tmp) >= 2 ? 18654 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 18655 (long int) (PyArray_NDIM(tmp) >= 1 ? 18656 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 18657 (long int) (PyArray_NDIM(tmp) >= 3 ? 18658 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 18659 (long int) (PyArray_NDIM(tmp) >= 2 ? 18660 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 18661 (long int) (PyArray_NDIM(tmp) >= 1 ? 18662 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 18663 ); 18664 { 18665 __failure = 294; 18666 if (!PyErr_Occurred()) { 18667 PyErr_SetString(PyExc_RuntimeError, 18668 "Unexpected error in an Op's C code. " 18669 "No Python exception was set."); 18670 } 18671 goto __label_294;} 18672 } 18673 // This is a TypeError to be consistent with DEBUG_MODE 18674 // Note: DEBUG_MODE also tells the name of the container 18675 if (PyArray_TYPE((PyArrayObject*) py_V293) != NPY_FLOAT64) { 18676 PyErr_Format(PyExc_TypeError, 18677 "expected type_num %d (NPY_FLOAT64) got %d", 18678 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V293)); 18679 { 18680 __failure = 294; 18681 if (!PyErr_Occurred()) { 18682 PyErr_SetString(PyExc_RuntimeError, 18683 "Unexpected error in an Op's C code. " 18684 "No Python exception was set."); 18685 } 18686 goto __label_294;} 18687 } 18688 18689 V293 = (PyArrayObject*)(py_V293); 18690 Py_XINCREF(V293); 18691 18692 { 18693 18694 py_V295 = PyList_GET_ITEM(storage_V295, 0); 18695 {Py_XINCREF(py_V295);} 18696 18697 V295 = NULL; 18698 if (py_V295 == Py_None) { 18699 // We can either fail here or set V295 to NULL and rely on Ops 18700 // using tensors to handle the NULL case, but if they fail to do so 18701 // they'll end up with nasty segfaults, so this is public service. 18702 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 18703 { 18704 __failure = 296; 18705 if (!PyErr_Occurred()) { 18706 PyErr_SetString(PyExc_RuntimeError, 18707 "Unexpected error in an Op's C code. " 18708 "No Python exception was set."); 18709 } 18710 goto __label_296;} 18711 } 18712 if (!PyArray_Check(py_V295)) { 18713 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 18714 { 18715 __failure = 296; 18716 if (!PyErr_Occurred()) { 18717 PyErr_SetString(PyExc_RuntimeError, 18718 "Unexpected error in an Op's C code. " 18719 "No Python exception was set."); 18720 } 18721 goto __label_296;} 18722 } 18723 // We expect NPY_FLOAT64 18724 if (!PyArray_ISALIGNED((PyArrayObject*) py_V295)) { 18725 PyArrayObject * tmp = (PyArrayObject*) py_V295; 18726 PyErr_Format(PyExc_NotImplementedError, 18727 "expected an aligned array of type %ld " 18728 "(NPY_FLOAT64), got non-aligned array of type %ld" 18729 " with %ld dimensions, with 3 last dims " 18730 "%ld, %ld, %ld" 18731 " and 3 last strides %ld %ld, %ld.", 18732 (long int) NPY_FLOAT64, 18733 (long int) PyArray_TYPE((PyArrayObject*) py_V295), 18734 (long int) PyArray_NDIM(tmp), 18735 (long int) (PyArray_NDIM(tmp) >= 3 ? 18736 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 18737 (long int) (PyArray_NDIM(tmp) >= 2 ? 18738 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 18739 (long int) (PyArray_NDIM(tmp) >= 1 ? 18740 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 18741 (long int) (PyArray_NDIM(tmp) >= 3 ? 18742 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 18743 (long int) (PyArray_NDIM(tmp) >= 2 ? 18744 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 18745 (long int) (PyArray_NDIM(tmp) >= 1 ? 18746 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 18747 ); 18748 { 18749 __failure = 296; 18750 if (!PyErr_Occurred()) { 18751 PyErr_SetString(PyExc_RuntimeError, 18752 "Unexpected error in an Op's C code. " 18753 "No Python exception was set."); 18754 } 18755 goto __label_296;} 18756 } 18757 // This is a TypeError to be consistent with DEBUG_MODE 18758 // Note: DEBUG_MODE also tells the name of the container 18759 if (PyArray_TYPE((PyArrayObject*) py_V295) != NPY_FLOAT64) { 18760 PyErr_Format(PyExc_TypeError, 18761 "expected type_num %d (NPY_FLOAT64) got %d", 18762 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V295)); 18763 { 18764 __failure = 296; 18765 if (!PyErr_Occurred()) { 18766 PyErr_SetString(PyExc_RuntimeError, 18767 "Unexpected error in an Op's C code. " 18768 "No Python exception was set."); 18769 } 18770 goto __label_296;} 18771 } 18772 18773 V295 = (PyArrayObject*)(py_V295); 18774 Py_XINCREF(V295); 18775 18776 { 18777 18778 py_V297 = PyList_GET_ITEM(storage_V297, 0); 18779 {Py_XINCREF(py_V297);} 18780 18781 V297 = NULL; 18782 if (py_V297 == Py_None) { 18783 // We can either fail here or set V297 to NULL and rely on Ops 18784 // using tensors to handle the NULL case, but if they fail to do so 18785 // they'll end up with nasty segfaults, so this is public service. 18786 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 18787 { 18788 __failure = 298; 18789 if (!PyErr_Occurred()) { 18790 PyErr_SetString(PyExc_RuntimeError, 18791 "Unexpected error in an Op's C code. " 18792 "No Python exception was set."); 18793 } 18794 goto __label_298;} 18795 } 18796 if (!PyArray_Check(py_V297)) { 18797 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 18798 { 18799 __failure = 298; 18800 if (!PyErr_Occurred()) { 18801 PyErr_SetString(PyExc_RuntimeError, 18802 "Unexpected error in an Op's C code. " 18803 "No Python exception was set."); 18804 } 18805 goto __label_298;} 18806 } 18807 // We expect NPY_FLOAT64 18808 if (!PyArray_ISALIGNED((PyArrayObject*) py_V297)) { 18809 PyArrayObject * tmp = (PyArrayObject*) py_V297; 18810 PyErr_Format(PyExc_NotImplementedError, 18811 "expected an aligned array of type %ld " 18812 "(NPY_FLOAT64), got non-aligned array of type %ld" 18813 " with %ld dimensions, with 3 last dims " 18814 "%ld, %ld, %ld" 18815 " and 3 last strides %ld %ld, %ld.", 18816 (long int) NPY_FLOAT64, 18817 (long int) PyArray_TYPE((PyArrayObject*) py_V297), 18818 (long int) PyArray_NDIM(tmp), 18819 (long int) (PyArray_NDIM(tmp) >= 3 ? 18820 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 18821 (long int) (PyArray_NDIM(tmp) >= 2 ? 18822 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 18823 (long int) (PyArray_NDIM(tmp) >= 1 ? 18824 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 18825 (long int) (PyArray_NDIM(tmp) >= 3 ? 18826 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 18827 (long int) (PyArray_NDIM(tmp) >= 2 ? 18828 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 18829 (long int) (PyArray_NDIM(tmp) >= 1 ? 18830 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 18831 ); 18832 { 18833 __failure = 298; 18834 if (!PyErr_Occurred()) { 18835 PyErr_SetString(PyExc_RuntimeError, 18836 "Unexpected error in an Op's C code. " 18837 "No Python exception was set."); 18838 } 18839 goto __label_298;} 18840 } 18841 // This is a TypeError to be consistent with DEBUG_MODE 18842 // Note: DEBUG_MODE also tells the name of the container 18843 if (PyArray_TYPE((PyArrayObject*) py_V297) != NPY_FLOAT64) { 18844 PyErr_Format(PyExc_TypeError, 18845 "expected type_num %d (NPY_FLOAT64) got %d", 18846 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V297)); 18847 { 18848 __failure = 298; 18849 if (!PyErr_Occurred()) { 18850 PyErr_SetString(PyExc_RuntimeError, 18851 "Unexpected error in an Op's C code. " 18852 "No Python exception was set."); 18853 } 18854 goto __label_298;} 18855 } 18856 18857 V297 = (PyArrayObject*)(py_V297); 18858 Py_XINCREF(V297); 18859 18860 { 18861 18862 py_V299 = PyList_GET_ITEM(storage_V299, 0); 18863 {Py_XINCREF(py_V299);} 18864 18865 V299 = NULL; 18866 if (py_V299 == Py_None) { 18867 // We can either fail here or set V299 to NULL and rely on Ops 18868 // using tensors to handle the NULL case, but if they fail to do so 18869 // they'll end up with nasty segfaults, so this is public service. 18870 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 18871 { 18872 __failure = 300; 18873 if (!PyErr_Occurred()) { 18874 PyErr_SetString(PyExc_RuntimeError, 18875 "Unexpected error in an Op's C code. " 18876 "No Python exception was set."); 18877 } 18878 goto __label_300;} 18879 } 18880 if (!PyArray_Check(py_V299)) { 18881 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 18882 { 18883 __failure = 300; 18884 if (!PyErr_Occurred()) { 18885 PyErr_SetString(PyExc_RuntimeError, 18886 "Unexpected error in an Op's C code. " 18887 "No Python exception was set."); 18888 } 18889 goto __label_300;} 18890 } 18891 // We expect NPY_FLOAT64 18892 if (!PyArray_ISALIGNED((PyArrayObject*) py_V299)) { 18893 PyArrayObject * tmp = (PyArrayObject*) py_V299; 18894 PyErr_Format(PyExc_NotImplementedError, 18895 "expected an aligned array of type %ld " 18896 "(NPY_FLOAT64), got non-aligned array of type %ld" 18897 " with %ld dimensions, with 3 last dims " 18898 "%ld, %ld, %ld" 18899 " and 3 last strides %ld %ld, %ld.", 18900 (long int) NPY_FLOAT64, 18901 (long int) PyArray_TYPE((PyArrayObject*) py_V299), 18902 (long int) PyArray_NDIM(tmp), 18903 (long int) (PyArray_NDIM(tmp) >= 3 ? 18904 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 18905 (long int) (PyArray_NDIM(tmp) >= 2 ? 18906 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 18907 (long int) (PyArray_NDIM(tmp) >= 1 ? 18908 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 18909 (long int) (PyArray_NDIM(tmp) >= 3 ? 18910 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 18911 (long int) (PyArray_NDIM(tmp) >= 2 ? 18912 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 18913 (long int) (PyArray_NDIM(tmp) >= 1 ? 18914 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 18915 ); 18916 { 18917 __failure = 300; 18918 if (!PyErr_Occurred()) { 18919 PyErr_SetString(PyExc_RuntimeError, 18920 "Unexpected error in an Op's C code. " 18921 "No Python exception was set."); 18922 } 18923 goto __label_300;} 18924 } 18925 // This is a TypeError to be consistent with DEBUG_MODE 18926 // Note: DEBUG_MODE also tells the name of the container 18927 if (PyArray_TYPE((PyArrayObject*) py_V299) != NPY_FLOAT64) { 18928 PyErr_Format(PyExc_TypeError, 18929 "expected type_num %d (NPY_FLOAT64) got %d", 18930 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V299)); 18931 { 18932 __failure = 300; 18933 if (!PyErr_Occurred()) { 18934 PyErr_SetString(PyExc_RuntimeError, 18935 "Unexpected error in an Op's C code. " 18936 "No Python exception was set."); 18937 } 18938 goto __label_300;} 18939 } 18940 18941 V299 = (PyArrayObject*)(py_V299); 18942 Py_XINCREF(V299); 18943 18944 { 18945 18946 py_V301 = PyList_GET_ITEM(storage_V301, 0); 18947 {Py_XINCREF(py_V301);} 18948 18949 V301 = NULL; 18950 if (py_V301 == Py_None) { 18951 // We can either fail here or set V301 to NULL and rely on Ops 18952 // using tensors to handle the NULL case, but if they fail to do so 18953 // they'll end up with nasty segfaults, so this is public service. 18954 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 18955 { 18956 __failure = 302; 18957 if (!PyErr_Occurred()) { 18958 PyErr_SetString(PyExc_RuntimeError, 18959 "Unexpected error in an Op's C code. " 18960 "No Python exception was set."); 18961 } 18962 goto __label_302;} 18963 } 18964 if (!PyArray_Check(py_V301)) { 18965 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 18966 { 18967 __failure = 302; 18968 if (!PyErr_Occurred()) { 18969 PyErr_SetString(PyExc_RuntimeError, 18970 "Unexpected error in an Op's C code. " 18971 "No Python exception was set."); 18972 } 18973 goto __label_302;} 18974 } 18975 // We expect NPY_FLOAT64 18976 if (!PyArray_ISALIGNED((PyArrayObject*) py_V301)) { 18977 PyArrayObject * tmp = (PyArrayObject*) py_V301; 18978 PyErr_Format(PyExc_NotImplementedError, 18979 "expected an aligned array of type %ld " 18980 "(NPY_FLOAT64), got non-aligned array of type %ld" 18981 " with %ld dimensions, with 3 last dims " 18982 "%ld, %ld, %ld" 18983 " and 3 last strides %ld %ld, %ld.", 18984 (long int) NPY_FLOAT64, 18985 (long int) PyArray_TYPE((PyArrayObject*) py_V301), 18986 (long int) PyArray_NDIM(tmp), 18987 (long int) (PyArray_NDIM(tmp) >= 3 ? 18988 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 18989 (long int) (PyArray_NDIM(tmp) >= 2 ? 18990 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 18991 (long int) (PyArray_NDIM(tmp) >= 1 ? 18992 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 18993 (long int) (PyArray_NDIM(tmp) >= 3 ? 18994 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 18995 (long int) (PyArray_NDIM(tmp) >= 2 ? 18996 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 18997 (long int) (PyArray_NDIM(tmp) >= 1 ? 18998 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 18999 ); 19000 { 19001 __failure = 302; 19002 if (!PyErr_Occurred()) { 19003 PyErr_SetString(PyExc_RuntimeError, 19004 "Unexpected error in an Op's C code. " 19005 "No Python exception was set."); 19006 } 19007 goto __label_302;} 19008 } 19009 // This is a TypeError to be consistent with DEBUG_MODE 19010 // Note: DEBUG_MODE also tells the name of the container 19011 if (PyArray_TYPE((PyArrayObject*) py_V301) != NPY_FLOAT64) { 19012 PyErr_Format(PyExc_TypeError, 19013 "expected type_num %d (NPY_FLOAT64) got %d", 19014 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V301)); 19015 { 19016 __failure = 302; 19017 if (!PyErr_Occurred()) { 19018 PyErr_SetString(PyExc_RuntimeError, 19019 "Unexpected error in an Op's C code. " 19020 "No Python exception was set."); 19021 } 19022 goto __label_302;} 19023 } 19024 19025 V301 = (PyArrayObject*)(py_V301); 19026 Py_XINCREF(V301); 19027 19028 { 19029 19030 py_V303 = PyList_GET_ITEM(storage_V303, 0); 19031 {Py_XINCREF(py_V303);} 19032 19033 V303 = NULL; 19034 if (py_V303 == Py_None) { 19035 // We can either fail here or set V303 to NULL and rely on Ops 19036 // using tensors to handle the NULL case, but if they fail to do so 19037 // they'll end up with nasty segfaults, so this is public service. 19038 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 19039 { 19040 __failure = 304; 19041 if (!PyErr_Occurred()) { 19042 PyErr_SetString(PyExc_RuntimeError, 19043 "Unexpected error in an Op's C code. " 19044 "No Python exception was set."); 19045 } 19046 goto __label_304;} 19047 } 19048 if (!PyArray_Check(py_V303)) { 19049 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 19050 { 19051 __failure = 304; 19052 if (!PyErr_Occurred()) { 19053 PyErr_SetString(PyExc_RuntimeError, 19054 "Unexpected error in an Op's C code. " 19055 "No Python exception was set."); 19056 } 19057 goto __label_304;} 19058 } 19059 // We expect NPY_FLOAT64 19060 if (!PyArray_ISALIGNED((PyArrayObject*) py_V303)) { 19061 PyArrayObject * tmp = (PyArrayObject*) py_V303; 19062 PyErr_Format(PyExc_NotImplementedError, 19063 "expected an aligned array of type %ld " 19064 "(NPY_FLOAT64), got non-aligned array of type %ld" 19065 " with %ld dimensions, with 3 last dims " 19066 "%ld, %ld, %ld" 19067 " and 3 last strides %ld %ld, %ld.", 19068 (long int) NPY_FLOAT64, 19069 (long int) PyArray_TYPE((PyArrayObject*) py_V303), 19070 (long int) PyArray_NDIM(tmp), 19071 (long int) (PyArray_NDIM(tmp) >= 3 ? 19072 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 19073 (long int) (PyArray_NDIM(tmp) >= 2 ? 19074 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 19075 (long int) (PyArray_NDIM(tmp) >= 1 ? 19076 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 19077 (long int) (PyArray_NDIM(tmp) >= 3 ? 19078 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 19079 (long int) (PyArray_NDIM(tmp) >= 2 ? 19080 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 19081 (long int) (PyArray_NDIM(tmp) >= 1 ? 19082 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 19083 ); 19084 { 19085 __failure = 304; 19086 if (!PyErr_Occurred()) { 19087 PyErr_SetString(PyExc_RuntimeError, 19088 "Unexpected error in an Op's C code. " 19089 "No Python exception was set."); 19090 } 19091 goto __label_304;} 19092 } 19093 // This is a TypeError to be consistent with DEBUG_MODE 19094 // Note: DEBUG_MODE also tells the name of the container 19095 if (PyArray_TYPE((PyArrayObject*) py_V303) != NPY_FLOAT64) { 19096 PyErr_Format(PyExc_TypeError, 19097 "expected type_num %d (NPY_FLOAT64) got %d", 19098 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V303)); 19099 { 19100 __failure = 304; 19101 if (!PyErr_Occurred()) { 19102 PyErr_SetString(PyExc_RuntimeError, 19103 "Unexpected error in an Op's C code. " 19104 "No Python exception was set."); 19105 } 19106 goto __label_304;} 19107 } 19108 19109 V303 = (PyArrayObject*)(py_V303); 19110 Py_XINCREF(V303); 19111 19112 { 19113 19114 py_V305 = PyList_GET_ITEM(storage_V305, 0); 19115 {Py_XINCREF(py_V305);} 19116 19117 V305 = NULL; 19118 if (py_V305 == Py_None) { 19119 // We can either fail here or set V305 to NULL and rely on Ops 19120 // using tensors to handle the NULL case, but if they fail to do so 19121 // they'll end up with nasty segfaults, so this is public service. 19122 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 19123 { 19124 __failure = 306; 19125 if (!PyErr_Occurred()) { 19126 PyErr_SetString(PyExc_RuntimeError, 19127 "Unexpected error in an Op's C code. " 19128 "No Python exception was set."); 19129 } 19130 goto __label_306;} 19131 } 19132 if (!PyArray_Check(py_V305)) { 19133 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 19134 { 19135 __failure = 306; 19136 if (!PyErr_Occurred()) { 19137 PyErr_SetString(PyExc_RuntimeError, 19138 "Unexpected error in an Op's C code. " 19139 "No Python exception was set."); 19140 } 19141 goto __label_306;} 19142 } 19143 // We expect NPY_FLOAT64 19144 if (!PyArray_ISALIGNED((PyArrayObject*) py_V305)) { 19145 PyArrayObject * tmp = (PyArrayObject*) py_V305; 19146 PyErr_Format(PyExc_NotImplementedError, 19147 "expected an aligned array of type %ld " 19148 "(NPY_FLOAT64), got non-aligned array of type %ld" 19149 " with %ld dimensions, with 3 last dims " 19150 "%ld, %ld, %ld" 19151 " and 3 last strides %ld %ld, %ld.", 19152 (long int) NPY_FLOAT64, 19153 (long int) PyArray_TYPE((PyArrayObject*) py_V305), 19154 (long int) PyArray_NDIM(tmp), 19155 (long int) (PyArray_NDIM(tmp) >= 3 ? 19156 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 19157 (long int) (PyArray_NDIM(tmp) >= 2 ? 19158 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 19159 (long int) (PyArray_NDIM(tmp) >= 1 ? 19160 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 19161 (long int) (PyArray_NDIM(tmp) >= 3 ? 19162 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 19163 (long int) (PyArray_NDIM(tmp) >= 2 ? 19164 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 19165 (long int) (PyArray_NDIM(tmp) >= 1 ? 19166 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 19167 ); 19168 { 19169 __failure = 306; 19170 if (!PyErr_Occurred()) { 19171 PyErr_SetString(PyExc_RuntimeError, 19172 "Unexpected error in an Op's C code. " 19173 "No Python exception was set."); 19174 } 19175 goto __label_306;} 19176 } 19177 // This is a TypeError to be consistent with DEBUG_MODE 19178 // Note: DEBUG_MODE also tells the name of the container 19179 if (PyArray_TYPE((PyArrayObject*) py_V305) != NPY_FLOAT64) { 19180 PyErr_Format(PyExc_TypeError, 19181 "expected type_num %d (NPY_FLOAT64) got %d", 19182 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V305)); 19183 { 19184 __failure = 306; 19185 if (!PyErr_Occurred()) { 19186 PyErr_SetString(PyExc_RuntimeError, 19187 "Unexpected error in an Op's C code. " 19188 "No Python exception was set."); 19189 } 19190 goto __label_306;} 19191 } 19192 19193 V305 = (PyArrayObject*)(py_V305); 19194 Py_XINCREF(V305); 19195 19196 { 19197 19198 py_V307 = PyList_GET_ITEM(storage_V307, 0); 19199 {Py_XINCREF(py_V307);} 19200 19201 V307 = NULL; 19202 if (py_V307 == Py_None) { 19203 // We can either fail here or set V307 to NULL and rely on Ops 19204 // using tensors to handle the NULL case, but if they fail to do so 19205 // they'll end up with nasty segfaults, so this is public service. 19206 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 19207 { 19208 __failure = 308; 19209 if (!PyErr_Occurred()) { 19210 PyErr_SetString(PyExc_RuntimeError, 19211 "Unexpected error in an Op's C code. " 19212 "No Python exception was set."); 19213 } 19214 goto __label_308;} 19215 } 19216 if (!PyArray_Check(py_V307)) { 19217 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 19218 { 19219 __failure = 308; 19220 if (!PyErr_Occurred()) { 19221 PyErr_SetString(PyExc_RuntimeError, 19222 "Unexpected error in an Op's C code. " 19223 "No Python exception was set."); 19224 } 19225 goto __label_308;} 19226 } 19227 // We expect NPY_FLOAT64 19228 if (!PyArray_ISALIGNED((PyArrayObject*) py_V307)) { 19229 PyArrayObject * tmp = (PyArrayObject*) py_V307; 19230 PyErr_Format(PyExc_NotImplementedError, 19231 "expected an aligned array of type %ld " 19232 "(NPY_FLOAT64), got non-aligned array of type %ld" 19233 " with %ld dimensions, with 3 last dims " 19234 "%ld, %ld, %ld" 19235 " and 3 last strides %ld %ld, %ld.", 19236 (long int) NPY_FLOAT64, 19237 (long int) PyArray_TYPE((PyArrayObject*) py_V307), 19238 (long int) PyArray_NDIM(tmp), 19239 (long int) (PyArray_NDIM(tmp) >= 3 ? 19240 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 19241 (long int) (PyArray_NDIM(tmp) >= 2 ? 19242 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 19243 (long int) (PyArray_NDIM(tmp) >= 1 ? 19244 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 19245 (long int) (PyArray_NDIM(tmp) >= 3 ? 19246 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 19247 (long int) (PyArray_NDIM(tmp) >= 2 ? 19248 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 19249 (long int) (PyArray_NDIM(tmp) >= 1 ? 19250 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 19251 ); 19252 { 19253 __failure = 308; 19254 if (!PyErr_Occurred()) { 19255 PyErr_SetString(PyExc_RuntimeError, 19256 "Unexpected error in an Op's C code. " 19257 "No Python exception was set."); 19258 } 19259 goto __label_308;} 19260 } 19261 // This is a TypeError to be consistent with DEBUG_MODE 19262 // Note: DEBUG_MODE also tells the name of the container 19263 if (PyArray_TYPE((PyArrayObject*) py_V307) != NPY_FLOAT64) { 19264 PyErr_Format(PyExc_TypeError, 19265 "expected type_num %d (NPY_FLOAT64) got %d", 19266 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V307)); 19267 { 19268 __failure = 308; 19269 if (!PyErr_Occurred()) { 19270 PyErr_SetString(PyExc_RuntimeError, 19271 "Unexpected error in an Op's C code. " 19272 "No Python exception was set."); 19273 } 19274 goto __label_308;} 19275 } 19276 19277 V307 = (PyArrayObject*)(py_V307); 19278 Py_XINCREF(V307); 19279 19280 { 19281 19282 py_V309 = PyList_GET_ITEM(storage_V309, 0); 19283 {Py_XINCREF(py_V309);} 19284 19285 V309 = NULL; 19286 if (py_V309 == Py_None) { 19287 // We can either fail here or set V309 to NULL and rely on Ops 19288 // using tensors to handle the NULL case, but if they fail to do so 19289 // they'll end up with nasty segfaults, so this is public service. 19290 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 19291 { 19292 __failure = 310; 19293 if (!PyErr_Occurred()) { 19294 PyErr_SetString(PyExc_RuntimeError, 19295 "Unexpected error in an Op's C code. " 19296 "No Python exception was set."); 19297 } 19298 goto __label_310;} 19299 } 19300 if (!PyArray_Check(py_V309)) { 19301 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 19302 { 19303 __failure = 310; 19304 if (!PyErr_Occurred()) { 19305 PyErr_SetString(PyExc_RuntimeError, 19306 "Unexpected error in an Op's C code. " 19307 "No Python exception was set."); 19308 } 19309 goto __label_310;} 19310 } 19311 // We expect NPY_FLOAT64 19312 if (!PyArray_ISALIGNED((PyArrayObject*) py_V309)) { 19313 PyArrayObject * tmp = (PyArrayObject*) py_V309; 19314 PyErr_Format(PyExc_NotImplementedError, 19315 "expected an aligned array of type %ld " 19316 "(NPY_FLOAT64), got non-aligned array of type %ld" 19317 " with %ld dimensions, with 3 last dims " 19318 "%ld, %ld, %ld" 19319 " and 3 last strides %ld %ld, %ld.", 19320 (long int) NPY_FLOAT64, 19321 (long int) PyArray_TYPE((PyArrayObject*) py_V309), 19322 (long int) PyArray_NDIM(tmp), 19323 (long int) (PyArray_NDIM(tmp) >= 3 ? 19324 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 19325 (long int) (PyArray_NDIM(tmp) >= 2 ? 19326 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 19327 (long int) (PyArray_NDIM(tmp) >= 1 ? 19328 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 19329 (long int) (PyArray_NDIM(tmp) >= 3 ? 19330 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 19331 (long int) (PyArray_NDIM(tmp) >= 2 ? 19332 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 19333 (long int) (PyArray_NDIM(tmp) >= 1 ? 19334 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 19335 ); 19336 { 19337 __failure = 310; 19338 if (!PyErr_Occurred()) { 19339 PyErr_SetString(PyExc_RuntimeError, 19340 "Unexpected error in an Op's C code. " 19341 "No Python exception was set."); 19342 } 19343 goto __label_310;} 19344 } 19345 // This is a TypeError to be consistent with DEBUG_MODE 19346 // Note: DEBUG_MODE also tells the name of the container 19347 if (PyArray_TYPE((PyArrayObject*) py_V309) != NPY_FLOAT64) { 19348 PyErr_Format(PyExc_TypeError, 19349 "expected type_num %d (NPY_FLOAT64) got %d", 19350 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V309)); 19351 { 19352 __failure = 310; 19353 if (!PyErr_Occurred()) { 19354 PyErr_SetString(PyExc_RuntimeError, 19355 "Unexpected error in an Op's C code. " 19356 "No Python exception was set."); 19357 } 19358 goto __label_310;} 19359 } 19360 19361 V309 = (PyArrayObject*)(py_V309); 19362 Py_XINCREF(V309); 19363 19364 { 19365 19366 py_V311 = PyList_GET_ITEM(storage_V311, 0); 19367 {Py_XINCREF(py_V311);} 19368 19369 V311 = NULL; 19370 if (py_V311 == Py_None) { 19371 // We can either fail here or set V311 to NULL and rely on Ops 19372 // using tensors to handle the NULL case, but if they fail to do so 19373 // they'll end up with nasty segfaults, so this is public service. 19374 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 19375 { 19376 __failure = 312; 19377 if (!PyErr_Occurred()) { 19378 PyErr_SetString(PyExc_RuntimeError, 19379 "Unexpected error in an Op's C code. " 19380 "No Python exception was set."); 19381 } 19382 goto __label_312;} 19383 } 19384 if (!PyArray_Check(py_V311)) { 19385 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 19386 { 19387 __failure = 312; 19388 if (!PyErr_Occurred()) { 19389 PyErr_SetString(PyExc_RuntimeError, 19390 "Unexpected error in an Op's C code. " 19391 "No Python exception was set."); 19392 } 19393 goto __label_312;} 19394 } 19395 // We expect NPY_FLOAT64 19396 if (!PyArray_ISALIGNED((PyArrayObject*) py_V311)) { 19397 PyArrayObject * tmp = (PyArrayObject*) py_V311; 19398 PyErr_Format(PyExc_NotImplementedError, 19399 "expected an aligned array of type %ld " 19400 "(NPY_FLOAT64), got non-aligned array of type %ld" 19401 " with %ld dimensions, with 3 last dims " 19402 "%ld, %ld, %ld" 19403 " and 3 last strides %ld %ld, %ld.", 19404 (long int) NPY_FLOAT64, 19405 (long int) PyArray_TYPE((PyArrayObject*) py_V311), 19406 (long int) PyArray_NDIM(tmp), 19407 (long int) (PyArray_NDIM(tmp) >= 3 ? 19408 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 19409 (long int) (PyArray_NDIM(tmp) >= 2 ? 19410 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 19411 (long int) (PyArray_NDIM(tmp) >= 1 ? 19412 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 19413 (long int) (PyArray_NDIM(tmp) >= 3 ? 19414 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 19415 (long int) (PyArray_NDIM(tmp) >= 2 ? 19416 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 19417 (long int) (PyArray_NDIM(tmp) >= 1 ? 19418 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 19419 ); 19420 { 19421 __failure = 312; 19422 if (!PyErr_Occurred()) { 19423 PyErr_SetString(PyExc_RuntimeError, 19424 "Unexpected error in an Op's C code. " 19425 "No Python exception was set."); 19426 } 19427 goto __label_312;} 19428 } 19429 // This is a TypeError to be consistent with DEBUG_MODE 19430 // Note: DEBUG_MODE also tells the name of the container 19431 if (PyArray_TYPE((PyArrayObject*) py_V311) != NPY_FLOAT64) { 19432 PyErr_Format(PyExc_TypeError, 19433 "expected type_num %d (NPY_FLOAT64) got %d", 19434 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V311)); 19435 { 19436 __failure = 312; 19437 if (!PyErr_Occurred()) { 19438 PyErr_SetString(PyExc_RuntimeError, 19439 "Unexpected error in an Op's C code. " 19440 "No Python exception was set."); 19441 } 19442 goto __label_312;} 19443 } 19444 19445 V311 = (PyArrayObject*)(py_V311); 19446 Py_XINCREF(V311); 19447 19448 { 19449 19450 py_V313 = PyList_GET_ITEM(storage_V313, 0); 19451 {Py_XINCREF(py_V313);} 19452 19453 V313 = NULL; 19454 if (py_V313 == Py_None) { 19455 // We can either fail here or set V313 to NULL and rely on Ops 19456 // using tensors to handle the NULL case, but if they fail to do so 19457 // they'll end up with nasty segfaults, so this is public service. 19458 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 19459 { 19460 __failure = 314; 19461 if (!PyErr_Occurred()) { 19462 PyErr_SetString(PyExc_RuntimeError, 19463 "Unexpected error in an Op's C code. " 19464 "No Python exception was set."); 19465 } 19466 goto __label_314;} 19467 } 19468 if (!PyArray_Check(py_V313)) { 19469 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 19470 { 19471 __failure = 314; 19472 if (!PyErr_Occurred()) { 19473 PyErr_SetString(PyExc_RuntimeError, 19474 "Unexpected error in an Op's C code. " 19475 "No Python exception was set."); 19476 } 19477 goto __label_314;} 19478 } 19479 // We expect NPY_FLOAT64 19480 if (!PyArray_ISALIGNED((PyArrayObject*) py_V313)) { 19481 PyArrayObject * tmp = (PyArrayObject*) py_V313; 19482 PyErr_Format(PyExc_NotImplementedError, 19483 "expected an aligned array of type %ld " 19484 "(NPY_FLOAT64), got non-aligned array of type %ld" 19485 " with %ld dimensions, with 3 last dims " 19486 "%ld, %ld, %ld" 19487 " and 3 last strides %ld %ld, %ld.", 19488 (long int) NPY_FLOAT64, 19489 (long int) PyArray_TYPE((PyArrayObject*) py_V313), 19490 (long int) PyArray_NDIM(tmp), 19491 (long int) (PyArray_NDIM(tmp) >= 3 ? 19492 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 19493 (long int) (PyArray_NDIM(tmp) >= 2 ? 19494 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 19495 (long int) (PyArray_NDIM(tmp) >= 1 ? 19496 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 19497 (long int) (PyArray_NDIM(tmp) >= 3 ? 19498 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 19499 (long int) (PyArray_NDIM(tmp) >= 2 ? 19500 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 19501 (long int) (PyArray_NDIM(tmp) >= 1 ? 19502 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 19503 ); 19504 { 19505 __failure = 314; 19506 if (!PyErr_Occurred()) { 19507 PyErr_SetString(PyExc_RuntimeError, 19508 "Unexpected error in an Op's C code. " 19509 "No Python exception was set."); 19510 } 19511 goto __label_314;} 19512 } 19513 // This is a TypeError to be consistent with DEBUG_MODE 19514 // Note: DEBUG_MODE also tells the name of the container 19515 if (PyArray_TYPE((PyArrayObject*) py_V313) != NPY_FLOAT64) { 19516 PyErr_Format(PyExc_TypeError, 19517 "expected type_num %d (NPY_FLOAT64) got %d", 19518 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V313)); 19519 { 19520 __failure = 314; 19521 if (!PyErr_Occurred()) { 19522 PyErr_SetString(PyExc_RuntimeError, 19523 "Unexpected error in an Op's C code. " 19524 "No Python exception was set."); 19525 } 19526 goto __label_314;} 19527 } 19528 19529 V313 = (PyArrayObject*)(py_V313); 19530 Py_XINCREF(V313); 19531 19532 { 19533 19534 py_V315 = PyList_GET_ITEM(storage_V315, 0); 19535 {Py_XINCREF(py_V315);} 19536 19537 V315 = NULL; 19538 if (py_V315 == Py_None) { 19539 // We can either fail here or set V315 to NULL and rely on Ops 19540 // using tensors to handle the NULL case, but if they fail to do so 19541 // they'll end up with nasty segfaults, so this is public service. 19542 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 19543 { 19544 __failure = 316; 19545 if (!PyErr_Occurred()) { 19546 PyErr_SetString(PyExc_RuntimeError, 19547 "Unexpected error in an Op's C code. " 19548 "No Python exception was set."); 19549 } 19550 goto __label_316;} 19551 } 19552 if (!PyArray_Check(py_V315)) { 19553 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 19554 { 19555 __failure = 316; 19556 if (!PyErr_Occurred()) { 19557 PyErr_SetString(PyExc_RuntimeError, 19558 "Unexpected error in an Op's C code. " 19559 "No Python exception was set."); 19560 } 19561 goto __label_316;} 19562 } 19563 // We expect NPY_FLOAT64 19564 if (!PyArray_ISALIGNED((PyArrayObject*) py_V315)) { 19565 PyArrayObject * tmp = (PyArrayObject*) py_V315; 19566 PyErr_Format(PyExc_NotImplementedError, 19567 "expected an aligned array of type %ld " 19568 "(NPY_FLOAT64), got non-aligned array of type %ld" 19569 " with %ld dimensions, with 3 last dims " 19570 "%ld, %ld, %ld" 19571 " and 3 last strides %ld %ld, %ld.", 19572 (long int) NPY_FLOAT64, 19573 (long int) PyArray_TYPE((PyArrayObject*) py_V315), 19574 (long int) PyArray_NDIM(tmp), 19575 (long int) (PyArray_NDIM(tmp) >= 3 ? 19576 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 19577 (long int) (PyArray_NDIM(tmp) >= 2 ? 19578 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 19579 (long int) (PyArray_NDIM(tmp) >= 1 ? 19580 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 19581 (long int) (PyArray_NDIM(tmp) >= 3 ? 19582 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 19583 (long int) (PyArray_NDIM(tmp) >= 2 ? 19584 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 19585 (long int) (PyArray_NDIM(tmp) >= 1 ? 19586 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 19587 ); 19588 { 19589 __failure = 316; 19590 if (!PyErr_Occurred()) { 19591 PyErr_SetString(PyExc_RuntimeError, 19592 "Unexpected error in an Op's C code. " 19593 "No Python exception was set."); 19594 } 19595 goto __label_316;} 19596 } 19597 // This is a TypeError to be consistent with DEBUG_MODE 19598 // Note: DEBUG_MODE also tells the name of the container 19599 if (PyArray_TYPE((PyArrayObject*) py_V315) != NPY_FLOAT64) { 19600 PyErr_Format(PyExc_TypeError, 19601 "expected type_num %d (NPY_FLOAT64) got %d", 19602 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V315)); 19603 { 19604 __failure = 316; 19605 if (!PyErr_Occurred()) { 19606 PyErr_SetString(PyExc_RuntimeError, 19607 "Unexpected error in an Op's C code. " 19608 "No Python exception was set."); 19609 } 19610 goto __label_316;} 19611 } 19612 19613 V315 = (PyArrayObject*)(py_V315); 19614 Py_XINCREF(V315); 19615 19616 { 19617 19618 py_V317 = PyList_GET_ITEM(storage_V317, 0); 19619 {Py_XINCREF(py_V317);} 19620 19621 V317 = NULL; 19622 if (py_V317 == Py_None) { 19623 // We can either fail here or set V317 to NULL and rely on Ops 19624 // using tensors to handle the NULL case, but if they fail to do so 19625 // they'll end up with nasty segfaults, so this is public service. 19626 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 19627 { 19628 __failure = 318; 19629 if (!PyErr_Occurred()) { 19630 PyErr_SetString(PyExc_RuntimeError, 19631 "Unexpected error in an Op's C code. " 19632 "No Python exception was set."); 19633 } 19634 goto __label_318;} 19635 } 19636 if (!PyArray_Check(py_V317)) { 19637 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 19638 { 19639 __failure = 318; 19640 if (!PyErr_Occurred()) { 19641 PyErr_SetString(PyExc_RuntimeError, 19642 "Unexpected error in an Op's C code. " 19643 "No Python exception was set."); 19644 } 19645 goto __label_318;} 19646 } 19647 // We expect NPY_FLOAT64 19648 if (!PyArray_ISALIGNED((PyArrayObject*) py_V317)) { 19649 PyArrayObject * tmp = (PyArrayObject*) py_V317; 19650 PyErr_Format(PyExc_NotImplementedError, 19651 "expected an aligned array of type %ld " 19652 "(NPY_FLOAT64), got non-aligned array of type %ld" 19653 " with %ld dimensions, with 3 last dims " 19654 "%ld, %ld, %ld" 19655 " and 3 last strides %ld %ld, %ld.", 19656 (long int) NPY_FLOAT64, 19657 (long int) PyArray_TYPE((PyArrayObject*) py_V317), 19658 (long int) PyArray_NDIM(tmp), 19659 (long int) (PyArray_NDIM(tmp) >= 3 ? 19660 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 19661 (long int) (PyArray_NDIM(tmp) >= 2 ? 19662 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 19663 (long int) (PyArray_NDIM(tmp) >= 1 ? 19664 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 19665 (long int) (PyArray_NDIM(tmp) >= 3 ? 19666 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 19667 (long int) (PyArray_NDIM(tmp) >= 2 ? 19668 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 19669 (long int) (PyArray_NDIM(tmp) >= 1 ? 19670 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 19671 ); 19672 { 19673 __failure = 318; 19674 if (!PyErr_Occurred()) { 19675 PyErr_SetString(PyExc_RuntimeError, 19676 "Unexpected error in an Op's C code. " 19677 "No Python exception was set."); 19678 } 19679 goto __label_318;} 19680 } 19681 // This is a TypeError to be consistent with DEBUG_MODE 19682 // Note: DEBUG_MODE also tells the name of the container 19683 if (PyArray_TYPE((PyArrayObject*) py_V317) != NPY_FLOAT64) { 19684 PyErr_Format(PyExc_TypeError, 19685 "expected type_num %d (NPY_FLOAT64) got %d", 19686 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V317)); 19687 { 19688 __failure = 318; 19689 if (!PyErr_Occurred()) { 19690 PyErr_SetString(PyExc_RuntimeError, 19691 "Unexpected error in an Op's C code. " 19692 "No Python exception was set."); 19693 } 19694 goto __label_318;} 19695 } 19696 19697 V317 = (PyArrayObject*)(py_V317); 19698 Py_XINCREF(V317); 19699 19700 { 19701 19702 py_V319 = PyList_GET_ITEM(storage_V319, 0); 19703 {Py_XINCREF(py_V319);} 19704 19705 V319 = NULL; 19706 if (py_V319 == Py_None) { 19707 // We can either fail here or set V319 to NULL and rely on Ops 19708 // using tensors to handle the NULL case, but if they fail to do so 19709 // they'll end up with nasty segfaults, so this is public service. 19710 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 19711 { 19712 __failure = 320; 19713 if (!PyErr_Occurred()) { 19714 PyErr_SetString(PyExc_RuntimeError, 19715 "Unexpected error in an Op's C code. " 19716 "No Python exception was set."); 19717 } 19718 goto __label_320;} 19719 } 19720 if (!PyArray_Check(py_V319)) { 19721 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 19722 { 19723 __failure = 320; 19724 if (!PyErr_Occurred()) { 19725 PyErr_SetString(PyExc_RuntimeError, 19726 "Unexpected error in an Op's C code. " 19727 "No Python exception was set."); 19728 } 19729 goto __label_320;} 19730 } 19731 // We expect NPY_FLOAT64 19732 if (!PyArray_ISALIGNED((PyArrayObject*) py_V319)) { 19733 PyArrayObject * tmp = (PyArrayObject*) py_V319; 19734 PyErr_Format(PyExc_NotImplementedError, 19735 "expected an aligned array of type %ld " 19736 "(NPY_FLOAT64), got non-aligned array of type %ld" 19737 " with %ld dimensions, with 3 last dims " 19738 "%ld, %ld, %ld" 19739 " and 3 last strides %ld %ld, %ld.", 19740 (long int) NPY_FLOAT64, 19741 (long int) PyArray_TYPE((PyArrayObject*) py_V319), 19742 (long int) PyArray_NDIM(tmp), 19743 (long int) (PyArray_NDIM(tmp) >= 3 ? 19744 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 19745 (long int) (PyArray_NDIM(tmp) >= 2 ? 19746 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 19747 (long int) (PyArray_NDIM(tmp) >= 1 ? 19748 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 19749 (long int) (PyArray_NDIM(tmp) >= 3 ? 19750 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 19751 (long int) (PyArray_NDIM(tmp) >= 2 ? 19752 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 19753 (long int) (PyArray_NDIM(tmp) >= 1 ? 19754 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 19755 ); 19756 { 19757 __failure = 320; 19758 if (!PyErr_Occurred()) { 19759 PyErr_SetString(PyExc_RuntimeError, 19760 "Unexpected error in an Op's C code. " 19761 "No Python exception was set."); 19762 } 19763 goto __label_320;} 19764 } 19765 // This is a TypeError to be consistent with DEBUG_MODE 19766 // Note: DEBUG_MODE also tells the name of the container 19767 if (PyArray_TYPE((PyArrayObject*) py_V319) != NPY_FLOAT64) { 19768 PyErr_Format(PyExc_TypeError, 19769 "expected type_num %d (NPY_FLOAT64) got %d", 19770 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V319)); 19771 { 19772 __failure = 320; 19773 if (!PyErr_Occurred()) { 19774 PyErr_SetString(PyExc_RuntimeError, 19775 "Unexpected error in an Op's C code. " 19776 "No Python exception was set."); 19777 } 19778 goto __label_320;} 19779 } 19780 19781 V319 = (PyArrayObject*)(py_V319); 19782 Py_XINCREF(V319); 19783 19784 { 19785 19786 py_V321 = PyList_GET_ITEM(storage_V321, 0); 19787 {Py_XINCREF(py_V321);} 19788 19789 V321 = NULL; 19790 if (py_V321 == Py_None) { 19791 // We can either fail here or set V321 to NULL and rely on Ops 19792 // using tensors to handle the NULL case, but if they fail to do so 19793 // they'll end up with nasty segfaults, so this is public service. 19794 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 19795 { 19796 __failure = 322; 19797 if (!PyErr_Occurred()) { 19798 PyErr_SetString(PyExc_RuntimeError, 19799 "Unexpected error in an Op's C code. " 19800 "No Python exception was set."); 19801 } 19802 goto __label_322;} 19803 } 19804 if (!PyArray_Check(py_V321)) { 19805 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 19806 { 19807 __failure = 322; 19808 if (!PyErr_Occurred()) { 19809 PyErr_SetString(PyExc_RuntimeError, 19810 "Unexpected error in an Op's C code. " 19811 "No Python exception was set."); 19812 } 19813 goto __label_322;} 19814 } 19815 // We expect NPY_FLOAT64 19816 if (!PyArray_ISALIGNED((PyArrayObject*) py_V321)) { 19817 PyArrayObject * tmp = (PyArrayObject*) py_V321; 19818 PyErr_Format(PyExc_NotImplementedError, 19819 "expected an aligned array of type %ld " 19820 "(NPY_FLOAT64), got non-aligned array of type %ld" 19821 " with %ld dimensions, with 3 last dims " 19822 "%ld, %ld, %ld" 19823 " and 3 last strides %ld %ld, %ld.", 19824 (long int) NPY_FLOAT64, 19825 (long int) PyArray_TYPE((PyArrayObject*) py_V321), 19826 (long int) PyArray_NDIM(tmp), 19827 (long int) (PyArray_NDIM(tmp) >= 3 ? 19828 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 19829 (long int) (PyArray_NDIM(tmp) >= 2 ? 19830 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 19831 (long int) (PyArray_NDIM(tmp) >= 1 ? 19832 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 19833 (long int) (PyArray_NDIM(tmp) >= 3 ? 19834 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 19835 (long int) (PyArray_NDIM(tmp) >= 2 ? 19836 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 19837 (long int) (PyArray_NDIM(tmp) >= 1 ? 19838 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 19839 ); 19840 { 19841 __failure = 322; 19842 if (!PyErr_Occurred()) { 19843 PyErr_SetString(PyExc_RuntimeError, 19844 "Unexpected error in an Op's C code. " 19845 "No Python exception was set."); 19846 } 19847 goto __label_322;} 19848 } 19849 // This is a TypeError to be consistent with DEBUG_MODE 19850 // Note: DEBUG_MODE also tells the name of the container 19851 if (PyArray_TYPE((PyArrayObject*) py_V321) != NPY_FLOAT64) { 19852 PyErr_Format(PyExc_TypeError, 19853 "expected type_num %d (NPY_FLOAT64) got %d", 19854 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V321)); 19855 { 19856 __failure = 322; 19857 if (!PyErr_Occurred()) { 19858 PyErr_SetString(PyExc_RuntimeError, 19859 "Unexpected error in an Op's C code. " 19860 "No Python exception was set."); 19861 } 19862 goto __label_322;} 19863 } 19864 19865 V321 = (PyArrayObject*)(py_V321); 19866 Py_XINCREF(V321); 19867 19868 { 19869 19870 py_V323 = PyList_GET_ITEM(storage_V323, 0); 19871 {Py_XINCREF(py_V323);} 19872 19873 V323 = NULL; 19874 if (py_V323 == Py_None) { 19875 // We can either fail here or set V323 to NULL and rely on Ops 19876 // using tensors to handle the NULL case, but if they fail to do so 19877 // they'll end up with nasty segfaults, so this is public service. 19878 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 19879 { 19880 __failure = 324; 19881 if (!PyErr_Occurred()) { 19882 PyErr_SetString(PyExc_RuntimeError, 19883 "Unexpected error in an Op's C code. " 19884 "No Python exception was set."); 19885 } 19886 goto __label_324;} 19887 } 19888 if (!PyArray_Check(py_V323)) { 19889 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 19890 { 19891 __failure = 324; 19892 if (!PyErr_Occurred()) { 19893 PyErr_SetString(PyExc_RuntimeError, 19894 "Unexpected error in an Op's C code. " 19895 "No Python exception was set."); 19896 } 19897 goto __label_324;} 19898 } 19899 // We expect NPY_FLOAT64 19900 if (!PyArray_ISALIGNED((PyArrayObject*) py_V323)) { 19901 PyArrayObject * tmp = (PyArrayObject*) py_V323; 19902 PyErr_Format(PyExc_NotImplementedError, 19903 "expected an aligned array of type %ld " 19904 "(NPY_FLOAT64), got non-aligned array of type %ld" 19905 " with %ld dimensions, with 3 last dims " 19906 "%ld, %ld, %ld" 19907 " and 3 last strides %ld %ld, %ld.", 19908 (long int) NPY_FLOAT64, 19909 (long int) PyArray_TYPE((PyArrayObject*) py_V323), 19910 (long int) PyArray_NDIM(tmp), 19911 (long int) (PyArray_NDIM(tmp) >= 3 ? 19912 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 19913 (long int) (PyArray_NDIM(tmp) >= 2 ? 19914 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 19915 (long int) (PyArray_NDIM(tmp) >= 1 ? 19916 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 19917 (long int) (PyArray_NDIM(tmp) >= 3 ? 19918 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 19919 (long int) (PyArray_NDIM(tmp) >= 2 ? 19920 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 19921 (long int) (PyArray_NDIM(tmp) >= 1 ? 19922 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 19923 ); 19924 { 19925 __failure = 324; 19926 if (!PyErr_Occurred()) { 19927 PyErr_SetString(PyExc_RuntimeError, 19928 "Unexpected error in an Op's C code. " 19929 "No Python exception was set."); 19930 } 19931 goto __label_324;} 19932 } 19933 // This is a TypeError to be consistent with DEBUG_MODE 19934 // Note: DEBUG_MODE also tells the name of the container 19935 if (PyArray_TYPE((PyArrayObject*) py_V323) != NPY_FLOAT64) { 19936 PyErr_Format(PyExc_TypeError, 19937 "expected type_num %d (NPY_FLOAT64) got %d", 19938 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V323)); 19939 { 19940 __failure = 324; 19941 if (!PyErr_Occurred()) { 19942 PyErr_SetString(PyExc_RuntimeError, 19943 "Unexpected error in an Op's C code. " 19944 "No Python exception was set."); 19945 } 19946 goto __label_324;} 19947 } 19948 19949 V323 = (PyArrayObject*)(py_V323); 19950 Py_XINCREF(V323); 19951 19952 { 19953 19954 py_V325 = PyList_GET_ITEM(storage_V325, 0); 19955 {Py_XINCREF(py_V325);} 19956 19957 V325 = NULL; 19958 if (py_V325 == Py_None) { 19959 // We can either fail here or set V325 to NULL and rely on Ops 19960 // using tensors to handle the NULL case, but if they fail to do so 19961 // they'll end up with nasty segfaults, so this is public service. 19962 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 19963 { 19964 __failure = 326; 19965 if (!PyErr_Occurred()) { 19966 PyErr_SetString(PyExc_RuntimeError, 19967 "Unexpected error in an Op's C code. " 19968 "No Python exception was set."); 19969 } 19970 goto __label_326;} 19971 } 19972 if (!PyArray_Check(py_V325)) { 19973 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 19974 { 19975 __failure = 326; 19976 if (!PyErr_Occurred()) { 19977 PyErr_SetString(PyExc_RuntimeError, 19978 "Unexpected error in an Op's C code. " 19979 "No Python exception was set."); 19980 } 19981 goto __label_326;} 19982 } 19983 // We expect NPY_FLOAT64 19984 if (!PyArray_ISALIGNED((PyArrayObject*) py_V325)) { 19985 PyArrayObject * tmp = (PyArrayObject*) py_V325; 19986 PyErr_Format(PyExc_NotImplementedError, 19987 "expected an aligned array of type %ld " 19988 "(NPY_FLOAT64), got non-aligned array of type %ld" 19989 " with %ld dimensions, with 3 last dims " 19990 "%ld, %ld, %ld" 19991 " and 3 last strides %ld %ld, %ld.", 19992 (long int) NPY_FLOAT64, 19993 (long int) PyArray_TYPE((PyArrayObject*) py_V325), 19994 (long int) PyArray_NDIM(tmp), 19995 (long int) (PyArray_NDIM(tmp) >= 3 ? 19996 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 19997 (long int) (PyArray_NDIM(tmp) >= 2 ? 19998 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 19999 (long int) (PyArray_NDIM(tmp) >= 1 ? 20000 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 20001 (long int) (PyArray_NDIM(tmp) >= 3 ? 20002 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 20003 (long int) (PyArray_NDIM(tmp) >= 2 ? 20004 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 20005 (long int) (PyArray_NDIM(tmp) >= 1 ? 20006 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 20007 ); 20008 { 20009 __failure = 326; 20010 if (!PyErr_Occurred()) { 20011 PyErr_SetString(PyExc_RuntimeError, 20012 "Unexpected error in an Op's C code. " 20013 "No Python exception was set."); 20014 } 20015 goto __label_326;} 20016 } 20017 // This is a TypeError to be consistent with DEBUG_MODE 20018 // Note: DEBUG_MODE also tells the name of the container 20019 if (PyArray_TYPE((PyArrayObject*) py_V325) != NPY_FLOAT64) { 20020 PyErr_Format(PyExc_TypeError, 20021 "expected type_num %d (NPY_FLOAT64) got %d", 20022 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V325)); 20023 { 20024 __failure = 326; 20025 if (!PyErr_Occurred()) { 20026 PyErr_SetString(PyExc_RuntimeError, 20027 "Unexpected error in an Op's C code. " 20028 "No Python exception was set."); 20029 } 20030 goto __label_326;} 20031 } 20032 20033 V325 = (PyArrayObject*)(py_V325); 20034 Py_XINCREF(V325); 20035 20036 { 20037 20038 py_V327 = PyList_GET_ITEM(storage_V327, 0); 20039 {Py_XINCREF(py_V327);} 20040 20041 V327 = NULL; 20042 if (py_V327 == Py_None) { 20043 // We can either fail here or set V327 to NULL and rely on Ops 20044 // using tensors to handle the NULL case, but if they fail to do so 20045 // they'll end up with nasty segfaults, so this is public service. 20046 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 20047 { 20048 __failure = 328; 20049 if (!PyErr_Occurred()) { 20050 PyErr_SetString(PyExc_RuntimeError, 20051 "Unexpected error in an Op's C code. " 20052 "No Python exception was set."); 20053 } 20054 goto __label_328;} 20055 } 20056 if (!PyArray_Check(py_V327)) { 20057 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 20058 { 20059 __failure = 328; 20060 if (!PyErr_Occurred()) { 20061 PyErr_SetString(PyExc_RuntimeError, 20062 "Unexpected error in an Op's C code. " 20063 "No Python exception was set."); 20064 } 20065 goto __label_328;} 20066 } 20067 // We expect NPY_FLOAT64 20068 if (!PyArray_ISALIGNED((PyArrayObject*) py_V327)) { 20069 PyArrayObject * tmp = (PyArrayObject*) py_V327; 20070 PyErr_Format(PyExc_NotImplementedError, 20071 "expected an aligned array of type %ld " 20072 "(NPY_FLOAT64), got non-aligned array of type %ld" 20073 " with %ld dimensions, with 3 last dims " 20074 "%ld, %ld, %ld" 20075 " and 3 last strides %ld %ld, %ld.", 20076 (long int) NPY_FLOAT64, 20077 (long int) PyArray_TYPE((PyArrayObject*) py_V327), 20078 (long int) PyArray_NDIM(tmp), 20079 (long int) (PyArray_NDIM(tmp) >= 3 ? 20080 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 20081 (long int) (PyArray_NDIM(tmp) >= 2 ? 20082 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 20083 (long int) (PyArray_NDIM(tmp) >= 1 ? 20084 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 20085 (long int) (PyArray_NDIM(tmp) >= 3 ? 20086 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 20087 (long int) (PyArray_NDIM(tmp) >= 2 ? 20088 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 20089 (long int) (PyArray_NDIM(tmp) >= 1 ? 20090 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 20091 ); 20092 { 20093 __failure = 328; 20094 if (!PyErr_Occurred()) { 20095 PyErr_SetString(PyExc_RuntimeError, 20096 "Unexpected error in an Op's C code. " 20097 "No Python exception was set."); 20098 } 20099 goto __label_328;} 20100 } 20101 // This is a TypeError to be consistent with DEBUG_MODE 20102 // Note: DEBUG_MODE also tells the name of the container 20103 if (PyArray_TYPE((PyArrayObject*) py_V327) != NPY_FLOAT64) { 20104 PyErr_Format(PyExc_TypeError, 20105 "expected type_num %d (NPY_FLOAT64) got %d", 20106 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V327)); 20107 { 20108 __failure = 328; 20109 if (!PyErr_Occurred()) { 20110 PyErr_SetString(PyExc_RuntimeError, 20111 "Unexpected error in an Op's C code. " 20112 "No Python exception was set."); 20113 } 20114 goto __label_328;} 20115 } 20116 20117 V327 = (PyArrayObject*)(py_V327); 20118 Py_XINCREF(V327); 20119 20120 { 20121 20122 py_V329 = PyList_GET_ITEM(storage_V329, 0); 20123 {Py_XINCREF(py_V329);} 20124 20125 V329 = NULL; 20126 if (py_V329 == Py_None) { 20127 // We can either fail here or set V329 to NULL and rely on Ops 20128 // using tensors to handle the NULL case, but if they fail to do so 20129 // they'll end up with nasty segfaults, so this is public service. 20130 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 20131 { 20132 __failure = 330; 20133 if (!PyErr_Occurred()) { 20134 PyErr_SetString(PyExc_RuntimeError, 20135 "Unexpected error in an Op's C code. " 20136 "No Python exception was set."); 20137 } 20138 goto __label_330;} 20139 } 20140 if (!PyArray_Check(py_V329)) { 20141 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 20142 { 20143 __failure = 330; 20144 if (!PyErr_Occurred()) { 20145 PyErr_SetString(PyExc_RuntimeError, 20146 "Unexpected error in an Op's C code. " 20147 "No Python exception was set."); 20148 } 20149 goto __label_330;} 20150 } 20151 // We expect NPY_FLOAT64 20152 if (!PyArray_ISALIGNED((PyArrayObject*) py_V329)) { 20153 PyArrayObject * tmp = (PyArrayObject*) py_V329; 20154 PyErr_Format(PyExc_NotImplementedError, 20155 "expected an aligned array of type %ld " 20156 "(NPY_FLOAT64), got non-aligned array of type %ld" 20157 " with %ld dimensions, with 3 last dims " 20158 "%ld, %ld, %ld" 20159 " and 3 last strides %ld %ld, %ld.", 20160 (long int) NPY_FLOAT64, 20161 (long int) PyArray_TYPE((PyArrayObject*) py_V329), 20162 (long int) PyArray_NDIM(tmp), 20163 (long int) (PyArray_NDIM(tmp) >= 3 ? 20164 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 20165 (long int) (PyArray_NDIM(tmp) >= 2 ? 20166 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 20167 (long int) (PyArray_NDIM(tmp) >= 1 ? 20168 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 20169 (long int) (PyArray_NDIM(tmp) >= 3 ? 20170 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 20171 (long int) (PyArray_NDIM(tmp) >= 2 ? 20172 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 20173 (long int) (PyArray_NDIM(tmp) >= 1 ? 20174 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 20175 ); 20176 { 20177 __failure = 330; 20178 if (!PyErr_Occurred()) { 20179 PyErr_SetString(PyExc_RuntimeError, 20180 "Unexpected error in an Op's C code. " 20181 "No Python exception was set."); 20182 } 20183 goto __label_330;} 20184 } 20185 // This is a TypeError to be consistent with DEBUG_MODE 20186 // Note: DEBUG_MODE also tells the name of the container 20187 if (PyArray_TYPE((PyArrayObject*) py_V329) != NPY_FLOAT64) { 20188 PyErr_Format(PyExc_TypeError, 20189 "expected type_num %d (NPY_FLOAT64) got %d", 20190 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V329)); 20191 { 20192 __failure = 330; 20193 if (!PyErr_Occurred()) { 20194 PyErr_SetString(PyExc_RuntimeError, 20195 "Unexpected error in an Op's C code. " 20196 "No Python exception was set."); 20197 } 20198 goto __label_330;} 20199 } 20200 20201 V329 = (PyArrayObject*)(py_V329); 20202 Py_XINCREF(V329); 20203 20204 { 20205 20206 py_V331 = PyList_GET_ITEM(storage_V331, 0); 20207 {Py_XINCREF(py_V331);} 20208 20209 V331 = NULL; 20210 if (py_V331 == Py_None) { 20211 // We can either fail here or set V331 to NULL and rely on Ops 20212 // using tensors to handle the NULL case, but if they fail to do so 20213 // they'll end up with nasty segfaults, so this is public service. 20214 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 20215 { 20216 __failure = 332; 20217 if (!PyErr_Occurred()) { 20218 PyErr_SetString(PyExc_RuntimeError, 20219 "Unexpected error in an Op's C code. " 20220 "No Python exception was set."); 20221 } 20222 goto __label_332;} 20223 } 20224 if (!PyArray_Check(py_V331)) { 20225 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 20226 { 20227 __failure = 332; 20228 if (!PyErr_Occurred()) { 20229 PyErr_SetString(PyExc_RuntimeError, 20230 "Unexpected error in an Op's C code. " 20231 "No Python exception was set."); 20232 } 20233 goto __label_332;} 20234 } 20235 // We expect NPY_FLOAT64 20236 if (!PyArray_ISALIGNED((PyArrayObject*) py_V331)) { 20237 PyArrayObject * tmp = (PyArrayObject*) py_V331; 20238 PyErr_Format(PyExc_NotImplementedError, 20239 "expected an aligned array of type %ld " 20240 "(NPY_FLOAT64), got non-aligned array of type %ld" 20241 " with %ld dimensions, with 3 last dims " 20242 "%ld, %ld, %ld" 20243 " and 3 last strides %ld %ld, %ld.", 20244 (long int) NPY_FLOAT64, 20245 (long int) PyArray_TYPE((PyArrayObject*) py_V331), 20246 (long int) PyArray_NDIM(tmp), 20247 (long int) (PyArray_NDIM(tmp) >= 3 ? 20248 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 20249 (long int) (PyArray_NDIM(tmp) >= 2 ? 20250 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 20251 (long int) (PyArray_NDIM(tmp) >= 1 ? 20252 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 20253 (long int) (PyArray_NDIM(tmp) >= 3 ? 20254 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 20255 (long int) (PyArray_NDIM(tmp) >= 2 ? 20256 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 20257 (long int) (PyArray_NDIM(tmp) >= 1 ? 20258 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 20259 ); 20260 { 20261 __failure = 332; 20262 if (!PyErr_Occurred()) { 20263 PyErr_SetString(PyExc_RuntimeError, 20264 "Unexpected error in an Op's C code. " 20265 "No Python exception was set."); 20266 } 20267 goto __label_332;} 20268 } 20269 // This is a TypeError to be consistent with DEBUG_MODE 20270 // Note: DEBUG_MODE also tells the name of the container 20271 if (PyArray_TYPE((PyArrayObject*) py_V331) != NPY_FLOAT64) { 20272 PyErr_Format(PyExc_TypeError, 20273 "expected type_num %d (NPY_FLOAT64) got %d", 20274 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V331)); 20275 { 20276 __failure = 332; 20277 if (!PyErr_Occurred()) { 20278 PyErr_SetString(PyExc_RuntimeError, 20279 "Unexpected error in an Op's C code. " 20280 "No Python exception was set."); 20281 } 20282 goto __label_332;} 20283 } 20284 20285 V331 = (PyArrayObject*)(py_V331); 20286 Py_XINCREF(V331); 20287 20288 { 20289 20290 py_V333 = PyList_GET_ITEM(storage_V333, 0); 20291 {Py_XINCREF(py_V333);} 20292 20293 V333 = NULL; 20294 if (py_V333 == Py_None) { 20295 // We can either fail here or set V333 to NULL and rely on Ops 20296 // using tensors to handle the NULL case, but if they fail to do so 20297 // they'll end up with nasty segfaults, so this is public service. 20298 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 20299 { 20300 __failure = 334; 20301 if (!PyErr_Occurred()) { 20302 PyErr_SetString(PyExc_RuntimeError, 20303 "Unexpected error in an Op's C code. " 20304 "No Python exception was set."); 20305 } 20306 goto __label_334;} 20307 } 20308 if (!PyArray_Check(py_V333)) { 20309 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 20310 { 20311 __failure = 334; 20312 if (!PyErr_Occurred()) { 20313 PyErr_SetString(PyExc_RuntimeError, 20314 "Unexpected error in an Op's C code. " 20315 "No Python exception was set."); 20316 } 20317 goto __label_334;} 20318 } 20319 // We expect NPY_FLOAT64 20320 if (!PyArray_ISALIGNED((PyArrayObject*) py_V333)) { 20321 PyArrayObject * tmp = (PyArrayObject*) py_V333; 20322 PyErr_Format(PyExc_NotImplementedError, 20323 "expected an aligned array of type %ld " 20324 "(NPY_FLOAT64), got non-aligned array of type %ld" 20325 " with %ld dimensions, with 3 last dims " 20326 "%ld, %ld, %ld" 20327 " and 3 last strides %ld %ld, %ld.", 20328 (long int) NPY_FLOAT64, 20329 (long int) PyArray_TYPE((PyArrayObject*) py_V333), 20330 (long int) PyArray_NDIM(tmp), 20331 (long int) (PyArray_NDIM(tmp) >= 3 ? 20332 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 20333 (long int) (PyArray_NDIM(tmp) >= 2 ? 20334 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 20335 (long int) (PyArray_NDIM(tmp) >= 1 ? 20336 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 20337 (long int) (PyArray_NDIM(tmp) >= 3 ? 20338 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 20339 (long int) (PyArray_NDIM(tmp) >= 2 ? 20340 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 20341 (long int) (PyArray_NDIM(tmp) >= 1 ? 20342 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 20343 ); 20344 { 20345 __failure = 334; 20346 if (!PyErr_Occurred()) { 20347 PyErr_SetString(PyExc_RuntimeError, 20348 "Unexpected error in an Op's C code. " 20349 "No Python exception was set."); 20350 } 20351 goto __label_334;} 20352 } 20353 // This is a TypeError to be consistent with DEBUG_MODE 20354 // Note: DEBUG_MODE also tells the name of the container 20355 if (PyArray_TYPE((PyArrayObject*) py_V333) != NPY_FLOAT64) { 20356 PyErr_Format(PyExc_TypeError, 20357 "expected type_num %d (NPY_FLOAT64) got %d", 20358 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V333)); 20359 { 20360 __failure = 334; 20361 if (!PyErr_Occurred()) { 20362 PyErr_SetString(PyExc_RuntimeError, 20363 "Unexpected error in an Op's C code. " 20364 "No Python exception was set."); 20365 } 20366 goto __label_334;} 20367 } 20368 20369 V333 = (PyArrayObject*)(py_V333); 20370 Py_XINCREF(V333); 20371 20372 { 20373 20374 py_V335 = PyList_GET_ITEM(storage_V335, 0); 20375 {Py_XINCREF(py_V335);} 20376 20377 V335 = NULL; 20378 if (py_V335 == Py_None) { 20379 // We can either fail here or set V335 to NULL and rely on Ops 20380 // using tensors to handle the NULL case, but if they fail to do so 20381 // they'll end up with nasty segfaults, so this is public service. 20382 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 20383 { 20384 __failure = 336; 20385 if (!PyErr_Occurred()) { 20386 PyErr_SetString(PyExc_RuntimeError, 20387 "Unexpected error in an Op's C code. " 20388 "No Python exception was set."); 20389 } 20390 goto __label_336;} 20391 } 20392 if (!PyArray_Check(py_V335)) { 20393 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 20394 { 20395 __failure = 336; 20396 if (!PyErr_Occurred()) { 20397 PyErr_SetString(PyExc_RuntimeError, 20398 "Unexpected error in an Op's C code. " 20399 "No Python exception was set."); 20400 } 20401 goto __label_336;} 20402 } 20403 // We expect NPY_FLOAT64 20404 if (!PyArray_ISALIGNED((PyArrayObject*) py_V335)) { 20405 PyArrayObject * tmp = (PyArrayObject*) py_V335; 20406 PyErr_Format(PyExc_NotImplementedError, 20407 "expected an aligned array of type %ld " 20408 "(NPY_FLOAT64), got non-aligned array of type %ld" 20409 " with %ld dimensions, with 3 last dims " 20410 "%ld, %ld, %ld" 20411 " and 3 last strides %ld %ld, %ld.", 20412 (long int) NPY_FLOAT64, 20413 (long int) PyArray_TYPE((PyArrayObject*) py_V335), 20414 (long int) PyArray_NDIM(tmp), 20415 (long int) (PyArray_NDIM(tmp) >= 3 ? 20416 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 20417 (long int) (PyArray_NDIM(tmp) >= 2 ? 20418 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 20419 (long int) (PyArray_NDIM(tmp) >= 1 ? 20420 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 20421 (long int) (PyArray_NDIM(tmp) >= 3 ? 20422 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 20423 (long int) (PyArray_NDIM(tmp) >= 2 ? 20424 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 20425 (long int) (PyArray_NDIM(tmp) >= 1 ? 20426 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 20427 ); 20428 { 20429 __failure = 336; 20430 if (!PyErr_Occurred()) { 20431 PyErr_SetString(PyExc_RuntimeError, 20432 "Unexpected error in an Op's C code. " 20433 "No Python exception was set."); 20434 } 20435 goto __label_336;} 20436 } 20437 // This is a TypeError to be consistent with DEBUG_MODE 20438 // Note: DEBUG_MODE also tells the name of the container 20439 if (PyArray_TYPE((PyArrayObject*) py_V335) != NPY_FLOAT64) { 20440 PyErr_Format(PyExc_TypeError, 20441 "expected type_num %d (NPY_FLOAT64) got %d", 20442 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V335)); 20443 { 20444 __failure = 336; 20445 if (!PyErr_Occurred()) { 20446 PyErr_SetString(PyExc_RuntimeError, 20447 "Unexpected error in an Op's C code. " 20448 "No Python exception was set."); 20449 } 20450 goto __label_336;} 20451 } 20452 20453 V335 = (PyArrayObject*)(py_V335); 20454 Py_XINCREF(V335); 20455 20456 { 20457 20458 py_V337 = PyList_GET_ITEM(storage_V337, 0); 20459 {Py_XINCREF(py_V337);} 20460 20461 V337 = NULL; 20462 if (py_V337 == Py_None) { 20463 // We can either fail here or set V337 to NULL and rely on Ops 20464 // using tensors to handle the NULL case, but if they fail to do so 20465 // they'll end up with nasty segfaults, so this is public service. 20466 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 20467 { 20468 __failure = 338; 20469 if (!PyErr_Occurred()) { 20470 PyErr_SetString(PyExc_RuntimeError, 20471 "Unexpected error in an Op's C code. " 20472 "No Python exception was set."); 20473 } 20474 goto __label_338;} 20475 } 20476 if (!PyArray_Check(py_V337)) { 20477 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 20478 { 20479 __failure = 338; 20480 if (!PyErr_Occurred()) { 20481 PyErr_SetString(PyExc_RuntimeError, 20482 "Unexpected error in an Op's C code. " 20483 "No Python exception was set."); 20484 } 20485 goto __label_338;} 20486 } 20487 // We expect NPY_FLOAT64 20488 if (!PyArray_ISALIGNED((PyArrayObject*) py_V337)) { 20489 PyArrayObject * tmp = (PyArrayObject*) py_V337; 20490 PyErr_Format(PyExc_NotImplementedError, 20491 "expected an aligned array of type %ld " 20492 "(NPY_FLOAT64), got non-aligned array of type %ld" 20493 " with %ld dimensions, with 3 last dims " 20494 "%ld, %ld, %ld" 20495 " and 3 last strides %ld %ld, %ld.", 20496 (long int) NPY_FLOAT64, 20497 (long int) PyArray_TYPE((PyArrayObject*) py_V337), 20498 (long int) PyArray_NDIM(tmp), 20499 (long int) (PyArray_NDIM(tmp) >= 3 ? 20500 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 20501 (long int) (PyArray_NDIM(tmp) >= 2 ? 20502 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 20503 (long int) (PyArray_NDIM(tmp) >= 1 ? 20504 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 20505 (long int) (PyArray_NDIM(tmp) >= 3 ? 20506 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 20507 (long int) (PyArray_NDIM(tmp) >= 2 ? 20508 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 20509 (long int) (PyArray_NDIM(tmp) >= 1 ? 20510 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 20511 ); 20512 { 20513 __failure = 338; 20514 if (!PyErr_Occurred()) { 20515 PyErr_SetString(PyExc_RuntimeError, 20516 "Unexpected error in an Op's C code. " 20517 "No Python exception was set."); 20518 } 20519 goto __label_338;} 20520 } 20521 // This is a TypeError to be consistent with DEBUG_MODE 20522 // Note: DEBUG_MODE also tells the name of the container 20523 if (PyArray_TYPE((PyArrayObject*) py_V337) != NPY_FLOAT64) { 20524 PyErr_Format(PyExc_TypeError, 20525 "expected type_num %d (NPY_FLOAT64) got %d", 20526 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V337)); 20527 { 20528 __failure = 338; 20529 if (!PyErr_Occurred()) { 20530 PyErr_SetString(PyExc_RuntimeError, 20531 "Unexpected error in an Op's C code. " 20532 "No Python exception was set."); 20533 } 20534 goto __label_338;} 20535 } 20536 20537 V337 = (PyArrayObject*)(py_V337); 20538 Py_XINCREF(V337); 20539 20540 { 20541 20542 py_V339 = PyList_GET_ITEM(storage_V339, 0); 20543 {Py_XINCREF(py_V339);} 20544 20545 V339 = NULL; 20546 if (py_V339 == Py_None) { 20547 // We can either fail here or set V339 to NULL and rely on Ops 20548 // using tensors to handle the NULL case, but if they fail to do so 20549 // they'll end up with nasty segfaults, so this is public service. 20550 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 20551 { 20552 __failure = 340; 20553 if (!PyErr_Occurred()) { 20554 PyErr_SetString(PyExc_RuntimeError, 20555 "Unexpected error in an Op's C code. " 20556 "No Python exception was set."); 20557 } 20558 goto __label_340;} 20559 } 20560 if (!PyArray_Check(py_V339)) { 20561 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 20562 { 20563 __failure = 340; 20564 if (!PyErr_Occurred()) { 20565 PyErr_SetString(PyExc_RuntimeError, 20566 "Unexpected error in an Op's C code. " 20567 "No Python exception was set."); 20568 } 20569 goto __label_340;} 20570 } 20571 // We expect NPY_FLOAT64 20572 if (!PyArray_ISALIGNED((PyArrayObject*) py_V339)) { 20573 PyArrayObject * tmp = (PyArrayObject*) py_V339; 20574 PyErr_Format(PyExc_NotImplementedError, 20575 "expected an aligned array of type %ld " 20576 "(NPY_FLOAT64), got non-aligned array of type %ld" 20577 " with %ld dimensions, with 3 last dims " 20578 "%ld, %ld, %ld" 20579 " and 3 last strides %ld %ld, %ld.", 20580 (long int) NPY_FLOAT64, 20581 (long int) PyArray_TYPE((PyArrayObject*) py_V339), 20582 (long int) PyArray_NDIM(tmp), 20583 (long int) (PyArray_NDIM(tmp) >= 3 ? 20584 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 20585 (long int) (PyArray_NDIM(tmp) >= 2 ? 20586 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 20587 (long int) (PyArray_NDIM(tmp) >= 1 ? 20588 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 20589 (long int) (PyArray_NDIM(tmp) >= 3 ? 20590 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 20591 (long int) (PyArray_NDIM(tmp) >= 2 ? 20592 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 20593 (long int) (PyArray_NDIM(tmp) >= 1 ? 20594 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 20595 ); 20596 { 20597 __failure = 340; 20598 if (!PyErr_Occurred()) { 20599 PyErr_SetString(PyExc_RuntimeError, 20600 "Unexpected error in an Op's C code. " 20601 "No Python exception was set."); 20602 } 20603 goto __label_340;} 20604 } 20605 // This is a TypeError to be consistent with DEBUG_MODE 20606 // Note: DEBUG_MODE also tells the name of the container 20607 if (PyArray_TYPE((PyArrayObject*) py_V339) != NPY_FLOAT64) { 20608 PyErr_Format(PyExc_TypeError, 20609 "expected type_num %d (NPY_FLOAT64) got %d", 20610 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V339)); 20611 { 20612 __failure = 340; 20613 if (!PyErr_Occurred()) { 20614 PyErr_SetString(PyExc_RuntimeError, 20615 "Unexpected error in an Op's C code. " 20616 "No Python exception was set."); 20617 } 20618 goto __label_340;} 20619 } 20620 20621 V339 = (PyArrayObject*)(py_V339); 20622 Py_XINCREF(V339); 20623 20624 { 20625 20626 py_V341 = PyList_GET_ITEM(storage_V341, 0); 20627 {Py_XINCREF(py_V341);} 20628 20629 V341 = NULL; 20630 if (py_V341 == Py_None) { 20631 // We can either fail here or set V341 to NULL and rely on Ops 20632 // using tensors to handle the NULL case, but if they fail to do so 20633 // they'll end up with nasty segfaults, so this is public service. 20634 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 20635 { 20636 __failure = 342; 20637 if (!PyErr_Occurred()) { 20638 PyErr_SetString(PyExc_RuntimeError, 20639 "Unexpected error in an Op's C code. " 20640 "No Python exception was set."); 20641 } 20642 goto __label_342;} 20643 } 20644 if (!PyArray_Check(py_V341)) { 20645 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 20646 { 20647 __failure = 342; 20648 if (!PyErr_Occurred()) { 20649 PyErr_SetString(PyExc_RuntimeError, 20650 "Unexpected error in an Op's C code. " 20651 "No Python exception was set."); 20652 } 20653 goto __label_342;} 20654 } 20655 // We expect NPY_FLOAT64 20656 if (!PyArray_ISALIGNED((PyArrayObject*) py_V341)) { 20657 PyArrayObject * tmp = (PyArrayObject*) py_V341; 20658 PyErr_Format(PyExc_NotImplementedError, 20659 "expected an aligned array of type %ld " 20660 "(NPY_FLOAT64), got non-aligned array of type %ld" 20661 " with %ld dimensions, with 3 last dims " 20662 "%ld, %ld, %ld" 20663 " and 3 last strides %ld %ld, %ld.", 20664 (long int) NPY_FLOAT64, 20665 (long int) PyArray_TYPE((PyArrayObject*) py_V341), 20666 (long int) PyArray_NDIM(tmp), 20667 (long int) (PyArray_NDIM(tmp) >= 3 ? 20668 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 20669 (long int) (PyArray_NDIM(tmp) >= 2 ? 20670 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 20671 (long int) (PyArray_NDIM(tmp) >= 1 ? 20672 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 20673 (long int) (PyArray_NDIM(tmp) >= 3 ? 20674 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 20675 (long int) (PyArray_NDIM(tmp) >= 2 ? 20676 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 20677 (long int) (PyArray_NDIM(tmp) >= 1 ? 20678 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 20679 ); 20680 { 20681 __failure = 342; 20682 if (!PyErr_Occurred()) { 20683 PyErr_SetString(PyExc_RuntimeError, 20684 "Unexpected error in an Op's C code. " 20685 "No Python exception was set."); 20686 } 20687 goto __label_342;} 20688 } 20689 // This is a TypeError to be consistent with DEBUG_MODE 20690 // Note: DEBUG_MODE also tells the name of the container 20691 if (PyArray_TYPE((PyArrayObject*) py_V341) != NPY_FLOAT64) { 20692 PyErr_Format(PyExc_TypeError, 20693 "expected type_num %d (NPY_FLOAT64) got %d", 20694 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V341)); 20695 { 20696 __failure = 342; 20697 if (!PyErr_Occurred()) { 20698 PyErr_SetString(PyExc_RuntimeError, 20699 "Unexpected error in an Op's C code. " 20700 "No Python exception was set."); 20701 } 20702 goto __label_342;} 20703 } 20704 20705 V341 = (PyArrayObject*)(py_V341); 20706 Py_XINCREF(V341); 20707 20708 { 20709 20710 py_V343 = PyList_GET_ITEM(storage_V343, 0); 20711 {Py_XINCREF(py_V343);} 20712 20713 V343 = NULL; 20714 if (py_V343 == Py_None) { 20715 // We can either fail here or set V343 to NULL and rely on Ops 20716 // using tensors to handle the NULL case, but if they fail to do so 20717 // they'll end up with nasty segfaults, so this is public service. 20718 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 20719 { 20720 __failure = 344; 20721 if (!PyErr_Occurred()) { 20722 PyErr_SetString(PyExc_RuntimeError, 20723 "Unexpected error in an Op's C code. " 20724 "No Python exception was set."); 20725 } 20726 goto __label_344;} 20727 } 20728 if (!PyArray_Check(py_V343)) { 20729 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 20730 { 20731 __failure = 344; 20732 if (!PyErr_Occurred()) { 20733 PyErr_SetString(PyExc_RuntimeError, 20734 "Unexpected error in an Op's C code. " 20735 "No Python exception was set."); 20736 } 20737 goto __label_344;} 20738 } 20739 // We expect NPY_FLOAT64 20740 if (!PyArray_ISALIGNED((PyArrayObject*) py_V343)) { 20741 PyArrayObject * tmp = (PyArrayObject*) py_V343; 20742 PyErr_Format(PyExc_NotImplementedError, 20743 "expected an aligned array of type %ld " 20744 "(NPY_FLOAT64), got non-aligned array of type %ld" 20745 " with %ld dimensions, with 3 last dims " 20746 "%ld, %ld, %ld" 20747 " and 3 last strides %ld %ld, %ld.", 20748 (long int) NPY_FLOAT64, 20749 (long int) PyArray_TYPE((PyArrayObject*) py_V343), 20750 (long int) PyArray_NDIM(tmp), 20751 (long int) (PyArray_NDIM(tmp) >= 3 ? 20752 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 20753 (long int) (PyArray_NDIM(tmp) >= 2 ? 20754 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 20755 (long int) (PyArray_NDIM(tmp) >= 1 ? 20756 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 20757 (long int) (PyArray_NDIM(tmp) >= 3 ? 20758 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 20759 (long int) (PyArray_NDIM(tmp) >= 2 ? 20760 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 20761 (long int) (PyArray_NDIM(tmp) >= 1 ? 20762 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 20763 ); 20764 { 20765 __failure = 344; 20766 if (!PyErr_Occurred()) { 20767 PyErr_SetString(PyExc_RuntimeError, 20768 "Unexpected error in an Op's C code. " 20769 "No Python exception was set."); 20770 } 20771 goto __label_344;} 20772 } 20773 // This is a TypeError to be consistent with DEBUG_MODE 20774 // Note: DEBUG_MODE also tells the name of the container 20775 if (PyArray_TYPE((PyArrayObject*) py_V343) != NPY_FLOAT64) { 20776 PyErr_Format(PyExc_TypeError, 20777 "expected type_num %d (NPY_FLOAT64) got %d", 20778 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V343)); 20779 { 20780 __failure = 344; 20781 if (!PyErr_Occurred()) { 20782 PyErr_SetString(PyExc_RuntimeError, 20783 "Unexpected error in an Op's C code. " 20784 "No Python exception was set."); 20785 } 20786 goto __label_344;} 20787 } 20788 20789 V343 = (PyArrayObject*)(py_V343); 20790 Py_XINCREF(V343); 20791 20792 { 20793 20794 py_V345 = PyList_GET_ITEM(storage_V345, 0); 20795 {Py_XINCREF(py_V345);} 20796 20797 V345 = NULL; 20798 if (py_V345 == Py_None) { 20799 // We can either fail here or set V345 to NULL and rely on Ops 20800 // using tensors to handle the NULL case, but if they fail to do so 20801 // they'll end up with nasty segfaults, so this is public service. 20802 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 20803 { 20804 __failure = 346; 20805 if (!PyErr_Occurred()) { 20806 PyErr_SetString(PyExc_RuntimeError, 20807 "Unexpected error in an Op's C code. " 20808 "No Python exception was set."); 20809 } 20810 goto __label_346;} 20811 } 20812 if (!PyArray_Check(py_V345)) { 20813 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 20814 { 20815 __failure = 346; 20816 if (!PyErr_Occurred()) { 20817 PyErr_SetString(PyExc_RuntimeError, 20818 "Unexpected error in an Op's C code. " 20819 "No Python exception was set."); 20820 } 20821 goto __label_346;} 20822 } 20823 // We expect NPY_FLOAT64 20824 if (!PyArray_ISALIGNED((PyArrayObject*) py_V345)) { 20825 PyArrayObject * tmp = (PyArrayObject*) py_V345; 20826 PyErr_Format(PyExc_NotImplementedError, 20827 "expected an aligned array of type %ld " 20828 "(NPY_FLOAT64), got non-aligned array of type %ld" 20829 " with %ld dimensions, with 3 last dims " 20830 "%ld, %ld, %ld" 20831 " and 3 last strides %ld %ld, %ld.", 20832 (long int) NPY_FLOAT64, 20833 (long int) PyArray_TYPE((PyArrayObject*) py_V345), 20834 (long int) PyArray_NDIM(tmp), 20835 (long int) (PyArray_NDIM(tmp) >= 3 ? 20836 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 20837 (long int) (PyArray_NDIM(tmp) >= 2 ? 20838 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 20839 (long int) (PyArray_NDIM(tmp) >= 1 ? 20840 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 20841 (long int) (PyArray_NDIM(tmp) >= 3 ? 20842 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 20843 (long int) (PyArray_NDIM(tmp) >= 2 ? 20844 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 20845 (long int) (PyArray_NDIM(tmp) >= 1 ? 20846 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 20847 ); 20848 { 20849 __failure = 346; 20850 if (!PyErr_Occurred()) { 20851 PyErr_SetString(PyExc_RuntimeError, 20852 "Unexpected error in an Op's C code. " 20853 "No Python exception was set."); 20854 } 20855 goto __label_346;} 20856 } 20857 // This is a TypeError to be consistent with DEBUG_MODE 20858 // Note: DEBUG_MODE also tells the name of the container 20859 if (PyArray_TYPE((PyArrayObject*) py_V345) != NPY_FLOAT64) { 20860 PyErr_Format(PyExc_TypeError, 20861 "expected type_num %d (NPY_FLOAT64) got %d", 20862 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V345)); 20863 { 20864 __failure = 346; 20865 if (!PyErr_Occurred()) { 20866 PyErr_SetString(PyExc_RuntimeError, 20867 "Unexpected error in an Op's C code. " 20868 "No Python exception was set."); 20869 } 20870 goto __label_346;} 20871 } 20872 20873 V345 = (PyArrayObject*)(py_V345); 20874 Py_XINCREF(V345); 20875 20876 { 20877 20878 py_V347 = PyList_GET_ITEM(storage_V347, 0); 20879 {Py_XINCREF(py_V347);} 20880 20881 V347 = NULL; 20882 if (py_V347 == Py_None) { 20883 // We can either fail here or set V347 to NULL and rely on Ops 20884 // using tensors to handle the NULL case, but if they fail to do so 20885 // they'll end up with nasty segfaults, so this is public service. 20886 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 20887 { 20888 __failure = 348; 20889 if (!PyErr_Occurred()) { 20890 PyErr_SetString(PyExc_RuntimeError, 20891 "Unexpected error in an Op's C code. " 20892 "No Python exception was set."); 20893 } 20894 goto __label_348;} 20895 } 20896 if (!PyArray_Check(py_V347)) { 20897 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 20898 { 20899 __failure = 348; 20900 if (!PyErr_Occurred()) { 20901 PyErr_SetString(PyExc_RuntimeError, 20902 "Unexpected error in an Op's C code. " 20903 "No Python exception was set."); 20904 } 20905 goto __label_348;} 20906 } 20907 // We expect NPY_FLOAT64 20908 if (!PyArray_ISALIGNED((PyArrayObject*) py_V347)) { 20909 PyArrayObject * tmp = (PyArrayObject*) py_V347; 20910 PyErr_Format(PyExc_NotImplementedError, 20911 "expected an aligned array of type %ld " 20912 "(NPY_FLOAT64), got non-aligned array of type %ld" 20913 " with %ld dimensions, with 3 last dims " 20914 "%ld, %ld, %ld" 20915 " and 3 last strides %ld %ld, %ld.", 20916 (long int) NPY_FLOAT64, 20917 (long int) PyArray_TYPE((PyArrayObject*) py_V347), 20918 (long int) PyArray_NDIM(tmp), 20919 (long int) (PyArray_NDIM(tmp) >= 3 ? 20920 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 20921 (long int) (PyArray_NDIM(tmp) >= 2 ? 20922 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 20923 (long int) (PyArray_NDIM(tmp) >= 1 ? 20924 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 20925 (long int) (PyArray_NDIM(tmp) >= 3 ? 20926 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 20927 (long int) (PyArray_NDIM(tmp) >= 2 ? 20928 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 20929 (long int) (PyArray_NDIM(tmp) >= 1 ? 20930 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 20931 ); 20932 { 20933 __failure = 348; 20934 if (!PyErr_Occurred()) { 20935 PyErr_SetString(PyExc_RuntimeError, 20936 "Unexpected error in an Op's C code. " 20937 "No Python exception was set."); 20938 } 20939 goto __label_348;} 20940 } 20941 // This is a TypeError to be consistent with DEBUG_MODE 20942 // Note: DEBUG_MODE also tells the name of the container 20943 if (PyArray_TYPE((PyArrayObject*) py_V347) != NPY_FLOAT64) { 20944 PyErr_Format(PyExc_TypeError, 20945 "expected type_num %d (NPY_FLOAT64) got %d", 20946 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V347)); 20947 { 20948 __failure = 348; 20949 if (!PyErr_Occurred()) { 20950 PyErr_SetString(PyExc_RuntimeError, 20951 "Unexpected error in an Op's C code. " 20952 "No Python exception was set."); 20953 } 20954 goto __label_348;} 20955 } 20956 20957 V347 = (PyArrayObject*)(py_V347); 20958 Py_XINCREF(V347); 20959 20960 { 20961 20962 py_V349 = PyList_GET_ITEM(storage_V349, 0); 20963 {Py_XINCREF(py_V349);} 20964 20965 V349 = NULL; 20966 if (py_V349 == Py_None) { 20967 // We can either fail here or set V349 to NULL and rely on Ops 20968 // using tensors to handle the NULL case, but if they fail to do so 20969 // they'll end up with nasty segfaults, so this is public service. 20970 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 20971 { 20972 __failure = 350; 20973 if (!PyErr_Occurred()) { 20974 PyErr_SetString(PyExc_RuntimeError, 20975 "Unexpected error in an Op's C code. " 20976 "No Python exception was set."); 20977 } 20978 goto __label_350;} 20979 } 20980 if (!PyArray_Check(py_V349)) { 20981 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 20982 { 20983 __failure = 350; 20984 if (!PyErr_Occurred()) { 20985 PyErr_SetString(PyExc_RuntimeError, 20986 "Unexpected error in an Op's C code. " 20987 "No Python exception was set."); 20988 } 20989 goto __label_350;} 20990 } 20991 // We expect NPY_FLOAT64 20992 if (!PyArray_ISALIGNED((PyArrayObject*) py_V349)) { 20993 PyArrayObject * tmp = (PyArrayObject*) py_V349; 20994 PyErr_Format(PyExc_NotImplementedError, 20995 "expected an aligned array of type %ld " 20996 "(NPY_FLOAT64), got non-aligned array of type %ld" 20997 " with %ld dimensions, with 3 last dims " 20998 "%ld, %ld, %ld" 20999 " and 3 last strides %ld %ld, %ld.", 21000 (long int) NPY_FLOAT64, 21001 (long int) PyArray_TYPE((PyArrayObject*) py_V349), 21002 (long int) PyArray_NDIM(tmp), 21003 (long int) (PyArray_NDIM(tmp) >= 3 ? 21004 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 21005 (long int) (PyArray_NDIM(tmp) >= 2 ? 21006 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 21007 (long int) (PyArray_NDIM(tmp) >= 1 ? 21008 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 21009 (long int) (PyArray_NDIM(tmp) >= 3 ? 21010 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 21011 (long int) (PyArray_NDIM(tmp) >= 2 ? 21012 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 21013 (long int) (PyArray_NDIM(tmp) >= 1 ? 21014 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 21015 ); 21016 { 21017 __failure = 350; 21018 if (!PyErr_Occurred()) { 21019 PyErr_SetString(PyExc_RuntimeError, 21020 "Unexpected error in an Op's C code. " 21021 "No Python exception was set."); 21022 } 21023 goto __label_350;} 21024 } 21025 // This is a TypeError to be consistent with DEBUG_MODE 21026 // Note: DEBUG_MODE also tells the name of the container 21027 if (PyArray_TYPE((PyArrayObject*) py_V349) != NPY_FLOAT64) { 21028 PyErr_Format(PyExc_TypeError, 21029 "expected type_num %d (NPY_FLOAT64) got %d", 21030 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V349)); 21031 { 21032 __failure = 350; 21033 if (!PyErr_Occurred()) { 21034 PyErr_SetString(PyExc_RuntimeError, 21035 "Unexpected error in an Op's C code. " 21036 "No Python exception was set."); 21037 } 21038 goto __label_350;} 21039 } 21040 21041 V349 = (PyArrayObject*)(py_V349); 21042 Py_XINCREF(V349); 21043 21044 { 21045 21046 py_V351 = PyList_GET_ITEM(storage_V351, 0); 21047 {Py_XINCREF(py_V351);} 21048 21049 V351 = NULL; 21050 if (py_V351 == Py_None) { 21051 // We can either fail here or set V351 to NULL and rely on Ops 21052 // using tensors to handle the NULL case, but if they fail to do so 21053 // they'll end up with nasty segfaults, so this is public service. 21054 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 21055 { 21056 __failure = 352; 21057 if (!PyErr_Occurred()) { 21058 PyErr_SetString(PyExc_RuntimeError, 21059 "Unexpected error in an Op's C code. " 21060 "No Python exception was set."); 21061 } 21062 goto __label_352;} 21063 } 21064 if (!PyArray_Check(py_V351)) { 21065 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 21066 { 21067 __failure = 352; 21068 if (!PyErr_Occurred()) { 21069 PyErr_SetString(PyExc_RuntimeError, 21070 "Unexpected error in an Op's C code. " 21071 "No Python exception was set."); 21072 } 21073 goto __label_352;} 21074 } 21075 // We expect NPY_FLOAT64 21076 if (!PyArray_ISALIGNED((PyArrayObject*) py_V351)) { 21077 PyArrayObject * tmp = (PyArrayObject*) py_V351; 21078 PyErr_Format(PyExc_NotImplementedError, 21079 "expected an aligned array of type %ld " 21080 "(NPY_FLOAT64), got non-aligned array of type %ld" 21081 " with %ld dimensions, with 3 last dims " 21082 "%ld, %ld, %ld" 21083 " and 3 last strides %ld %ld, %ld.", 21084 (long int) NPY_FLOAT64, 21085 (long int) PyArray_TYPE((PyArrayObject*) py_V351), 21086 (long int) PyArray_NDIM(tmp), 21087 (long int) (PyArray_NDIM(tmp) >= 3 ? 21088 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 21089 (long int) (PyArray_NDIM(tmp) >= 2 ? 21090 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 21091 (long int) (PyArray_NDIM(tmp) >= 1 ? 21092 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 21093 (long int) (PyArray_NDIM(tmp) >= 3 ? 21094 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 21095 (long int) (PyArray_NDIM(tmp) >= 2 ? 21096 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 21097 (long int) (PyArray_NDIM(tmp) >= 1 ? 21098 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 21099 ); 21100 { 21101 __failure = 352; 21102 if (!PyErr_Occurred()) { 21103 PyErr_SetString(PyExc_RuntimeError, 21104 "Unexpected error in an Op's C code. " 21105 "No Python exception was set."); 21106 } 21107 goto __label_352;} 21108 } 21109 // This is a TypeError to be consistent with DEBUG_MODE 21110 // Note: DEBUG_MODE also tells the name of the container 21111 if (PyArray_TYPE((PyArrayObject*) py_V351) != NPY_FLOAT64) { 21112 PyErr_Format(PyExc_TypeError, 21113 "expected type_num %d (NPY_FLOAT64) got %d", 21114 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V351)); 21115 { 21116 __failure = 352; 21117 if (!PyErr_Occurred()) { 21118 PyErr_SetString(PyExc_RuntimeError, 21119 "Unexpected error in an Op's C code. " 21120 "No Python exception was set."); 21121 } 21122 goto __label_352;} 21123 } 21124 21125 V351 = (PyArrayObject*)(py_V351); 21126 Py_XINCREF(V351); 21127 21128 { 21129 21130 py_V353 = PyList_GET_ITEM(storage_V353, 0); 21131 {Py_XINCREF(py_V353);} 21132 21133 V353 = NULL; 21134 if (py_V353 == Py_None) { 21135 // We can either fail here or set V353 to NULL and rely on Ops 21136 // using tensors to handle the NULL case, but if they fail to do so 21137 // they'll end up with nasty segfaults, so this is public service. 21138 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 21139 { 21140 __failure = 354; 21141 if (!PyErr_Occurred()) { 21142 PyErr_SetString(PyExc_RuntimeError, 21143 "Unexpected error in an Op's C code. " 21144 "No Python exception was set."); 21145 } 21146 goto __label_354;} 21147 } 21148 if (!PyArray_Check(py_V353)) { 21149 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 21150 { 21151 __failure = 354; 21152 if (!PyErr_Occurred()) { 21153 PyErr_SetString(PyExc_RuntimeError, 21154 "Unexpected error in an Op's C code. " 21155 "No Python exception was set."); 21156 } 21157 goto __label_354;} 21158 } 21159 // We expect NPY_FLOAT64 21160 if (!PyArray_ISALIGNED((PyArrayObject*) py_V353)) { 21161 PyArrayObject * tmp = (PyArrayObject*) py_V353; 21162 PyErr_Format(PyExc_NotImplementedError, 21163 "expected an aligned array of type %ld " 21164 "(NPY_FLOAT64), got non-aligned array of type %ld" 21165 " with %ld dimensions, with 3 last dims " 21166 "%ld, %ld, %ld" 21167 " and 3 last strides %ld %ld, %ld.", 21168 (long int) NPY_FLOAT64, 21169 (long int) PyArray_TYPE((PyArrayObject*) py_V353), 21170 (long int) PyArray_NDIM(tmp), 21171 (long int) (PyArray_NDIM(tmp) >= 3 ? 21172 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 21173 (long int) (PyArray_NDIM(tmp) >= 2 ? 21174 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 21175 (long int) (PyArray_NDIM(tmp) >= 1 ? 21176 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 21177 (long int) (PyArray_NDIM(tmp) >= 3 ? 21178 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 21179 (long int) (PyArray_NDIM(tmp) >= 2 ? 21180 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 21181 (long int) (PyArray_NDIM(tmp) >= 1 ? 21182 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 21183 ); 21184 { 21185 __failure = 354; 21186 if (!PyErr_Occurred()) { 21187 PyErr_SetString(PyExc_RuntimeError, 21188 "Unexpected error in an Op's C code. " 21189 "No Python exception was set."); 21190 } 21191 goto __label_354;} 21192 } 21193 // This is a TypeError to be consistent with DEBUG_MODE 21194 // Note: DEBUG_MODE also tells the name of the container 21195 if (PyArray_TYPE((PyArrayObject*) py_V353) != NPY_FLOAT64) { 21196 PyErr_Format(PyExc_TypeError, 21197 "expected type_num %d (NPY_FLOAT64) got %d", 21198 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V353)); 21199 { 21200 __failure = 354; 21201 if (!PyErr_Occurred()) { 21202 PyErr_SetString(PyExc_RuntimeError, 21203 "Unexpected error in an Op's C code. " 21204 "No Python exception was set."); 21205 } 21206 goto __label_354;} 21207 } 21208 21209 V353 = (PyArrayObject*)(py_V353); 21210 Py_XINCREF(V353); 21211 21212 { 21213 21214 py_V355 = PyList_GET_ITEM(storage_V355, 0); 21215 {Py_XINCREF(py_V355);} 21216 21217 V355 = NULL; 21218 if (py_V355 == Py_None) { 21219 // We can either fail here or set V355 to NULL and rely on Ops 21220 // using tensors to handle the NULL case, but if they fail to do so 21221 // they'll end up with nasty segfaults, so this is public service. 21222 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 21223 { 21224 __failure = 356; 21225 if (!PyErr_Occurred()) { 21226 PyErr_SetString(PyExc_RuntimeError, 21227 "Unexpected error in an Op's C code. " 21228 "No Python exception was set."); 21229 } 21230 goto __label_356;} 21231 } 21232 if (!PyArray_Check(py_V355)) { 21233 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 21234 { 21235 __failure = 356; 21236 if (!PyErr_Occurred()) { 21237 PyErr_SetString(PyExc_RuntimeError, 21238 "Unexpected error in an Op's C code. " 21239 "No Python exception was set."); 21240 } 21241 goto __label_356;} 21242 } 21243 // We expect NPY_FLOAT64 21244 if (!PyArray_ISALIGNED((PyArrayObject*) py_V355)) { 21245 PyArrayObject * tmp = (PyArrayObject*) py_V355; 21246 PyErr_Format(PyExc_NotImplementedError, 21247 "expected an aligned array of type %ld " 21248 "(NPY_FLOAT64), got non-aligned array of type %ld" 21249 " with %ld dimensions, with 3 last dims " 21250 "%ld, %ld, %ld" 21251 " and 3 last strides %ld %ld, %ld.", 21252 (long int) NPY_FLOAT64, 21253 (long int) PyArray_TYPE((PyArrayObject*) py_V355), 21254 (long int) PyArray_NDIM(tmp), 21255 (long int) (PyArray_NDIM(tmp) >= 3 ? 21256 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 21257 (long int) (PyArray_NDIM(tmp) >= 2 ? 21258 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 21259 (long int) (PyArray_NDIM(tmp) >= 1 ? 21260 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 21261 (long int) (PyArray_NDIM(tmp) >= 3 ? 21262 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 21263 (long int) (PyArray_NDIM(tmp) >= 2 ? 21264 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 21265 (long int) (PyArray_NDIM(tmp) >= 1 ? 21266 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 21267 ); 21268 { 21269 __failure = 356; 21270 if (!PyErr_Occurred()) { 21271 PyErr_SetString(PyExc_RuntimeError, 21272 "Unexpected error in an Op's C code. " 21273 "No Python exception was set."); 21274 } 21275 goto __label_356;} 21276 } 21277 // This is a TypeError to be consistent with DEBUG_MODE 21278 // Note: DEBUG_MODE also tells the name of the container 21279 if (PyArray_TYPE((PyArrayObject*) py_V355) != NPY_FLOAT64) { 21280 PyErr_Format(PyExc_TypeError, 21281 "expected type_num %d (NPY_FLOAT64) got %d", 21282 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V355)); 21283 { 21284 __failure = 356; 21285 if (!PyErr_Occurred()) { 21286 PyErr_SetString(PyExc_RuntimeError, 21287 "Unexpected error in an Op's C code. " 21288 "No Python exception was set."); 21289 } 21290 goto __label_356;} 21291 } 21292 21293 V355 = (PyArrayObject*)(py_V355); 21294 Py_XINCREF(V355); 21295 21296 { 21297 21298 py_V357 = PyList_GET_ITEM(storage_V357, 0); 21299 {Py_XINCREF(py_V357);} 21300 21301 V357 = NULL; 21302 if (py_V357 == Py_None) { 21303 // We can either fail here or set V357 to NULL and rely on Ops 21304 // using tensors to handle the NULL case, but if they fail to do so 21305 // they'll end up with nasty segfaults, so this is public service. 21306 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 21307 { 21308 __failure = 358; 21309 if (!PyErr_Occurred()) { 21310 PyErr_SetString(PyExc_RuntimeError, 21311 "Unexpected error in an Op's C code. " 21312 "No Python exception was set."); 21313 } 21314 goto __label_358;} 21315 } 21316 if (!PyArray_Check(py_V357)) { 21317 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 21318 { 21319 __failure = 358; 21320 if (!PyErr_Occurred()) { 21321 PyErr_SetString(PyExc_RuntimeError, 21322 "Unexpected error in an Op's C code. " 21323 "No Python exception was set."); 21324 } 21325 goto __label_358;} 21326 } 21327 // We expect NPY_FLOAT64 21328 if (!PyArray_ISALIGNED((PyArrayObject*) py_V357)) { 21329 PyArrayObject * tmp = (PyArrayObject*) py_V357; 21330 PyErr_Format(PyExc_NotImplementedError, 21331 "expected an aligned array of type %ld " 21332 "(NPY_FLOAT64), got non-aligned array of type %ld" 21333 " with %ld dimensions, with 3 last dims " 21334 "%ld, %ld, %ld" 21335 " and 3 last strides %ld %ld, %ld.", 21336 (long int) NPY_FLOAT64, 21337 (long int) PyArray_TYPE((PyArrayObject*) py_V357), 21338 (long int) PyArray_NDIM(tmp), 21339 (long int) (PyArray_NDIM(tmp) >= 3 ? 21340 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 21341 (long int) (PyArray_NDIM(tmp) >= 2 ? 21342 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 21343 (long int) (PyArray_NDIM(tmp) >= 1 ? 21344 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 21345 (long int) (PyArray_NDIM(tmp) >= 3 ? 21346 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 21347 (long int) (PyArray_NDIM(tmp) >= 2 ? 21348 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 21349 (long int) (PyArray_NDIM(tmp) >= 1 ? 21350 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 21351 ); 21352 { 21353 __failure = 358; 21354 if (!PyErr_Occurred()) { 21355 PyErr_SetString(PyExc_RuntimeError, 21356 "Unexpected error in an Op's C code. " 21357 "No Python exception was set."); 21358 } 21359 goto __label_358;} 21360 } 21361 // This is a TypeError to be consistent with DEBUG_MODE 21362 // Note: DEBUG_MODE also tells the name of the container 21363 if (PyArray_TYPE((PyArrayObject*) py_V357) != NPY_FLOAT64) { 21364 PyErr_Format(PyExc_TypeError, 21365 "expected type_num %d (NPY_FLOAT64) got %d", 21366 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V357)); 21367 { 21368 __failure = 358; 21369 if (!PyErr_Occurred()) { 21370 PyErr_SetString(PyExc_RuntimeError, 21371 "Unexpected error in an Op's C code. " 21372 "No Python exception was set."); 21373 } 21374 goto __label_358;} 21375 } 21376 21377 V357 = (PyArrayObject*)(py_V357); 21378 Py_XINCREF(V357); 21379 21380 { 21381 21382 py_V359 = PyList_GET_ITEM(storage_V359, 0); 21383 {Py_XINCREF(py_V359);} 21384 21385 V359 = NULL; 21386 if (py_V359 == Py_None) { 21387 // We can either fail here or set V359 to NULL and rely on Ops 21388 // using tensors to handle the NULL case, but if they fail to do so 21389 // they'll end up with nasty segfaults, so this is public service. 21390 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 21391 { 21392 __failure = 360; 21393 if (!PyErr_Occurred()) { 21394 PyErr_SetString(PyExc_RuntimeError, 21395 "Unexpected error in an Op's C code. " 21396 "No Python exception was set."); 21397 } 21398 goto __label_360;} 21399 } 21400 if (!PyArray_Check(py_V359)) { 21401 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 21402 { 21403 __failure = 360; 21404 if (!PyErr_Occurred()) { 21405 PyErr_SetString(PyExc_RuntimeError, 21406 "Unexpected error in an Op's C code. " 21407 "No Python exception was set."); 21408 } 21409 goto __label_360;} 21410 } 21411 // We expect NPY_FLOAT64 21412 if (!PyArray_ISALIGNED((PyArrayObject*) py_V359)) { 21413 PyArrayObject * tmp = (PyArrayObject*) py_V359; 21414 PyErr_Format(PyExc_NotImplementedError, 21415 "expected an aligned array of type %ld " 21416 "(NPY_FLOAT64), got non-aligned array of type %ld" 21417 " with %ld dimensions, with 3 last dims " 21418 "%ld, %ld, %ld" 21419 " and 3 last strides %ld %ld, %ld.", 21420 (long int) NPY_FLOAT64, 21421 (long int) PyArray_TYPE((PyArrayObject*) py_V359), 21422 (long int) PyArray_NDIM(tmp), 21423 (long int) (PyArray_NDIM(tmp) >= 3 ? 21424 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 21425 (long int) (PyArray_NDIM(tmp) >= 2 ? 21426 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 21427 (long int) (PyArray_NDIM(tmp) >= 1 ? 21428 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 21429 (long int) (PyArray_NDIM(tmp) >= 3 ? 21430 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 21431 (long int) (PyArray_NDIM(tmp) >= 2 ? 21432 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 21433 (long int) (PyArray_NDIM(tmp) >= 1 ? 21434 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 21435 ); 21436 { 21437 __failure = 360; 21438 if (!PyErr_Occurred()) { 21439 PyErr_SetString(PyExc_RuntimeError, 21440 "Unexpected error in an Op's C code. " 21441 "No Python exception was set."); 21442 } 21443 goto __label_360;} 21444 } 21445 // This is a TypeError to be consistent with DEBUG_MODE 21446 // Note: DEBUG_MODE also tells the name of the container 21447 if (PyArray_TYPE((PyArrayObject*) py_V359) != NPY_FLOAT64) { 21448 PyErr_Format(PyExc_TypeError, 21449 "expected type_num %d (NPY_FLOAT64) got %d", 21450 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V359)); 21451 { 21452 __failure = 360; 21453 if (!PyErr_Occurred()) { 21454 PyErr_SetString(PyExc_RuntimeError, 21455 "Unexpected error in an Op's C code. " 21456 "No Python exception was set."); 21457 } 21458 goto __label_360;} 21459 } 21460 21461 V359 = (PyArrayObject*)(py_V359); 21462 Py_XINCREF(V359); 21463 21464 { 21465 21466 py_V361 = PyList_GET_ITEM(storage_V361, 0); 21467 {Py_XINCREF(py_V361);} 21468 21469 V361 = NULL; 21470 if (py_V361 == Py_None) { 21471 // We can either fail here or set V361 to NULL and rely on Ops 21472 // using tensors to handle the NULL case, but if they fail to do so 21473 // they'll end up with nasty segfaults, so this is public service. 21474 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 21475 { 21476 __failure = 362; 21477 if (!PyErr_Occurred()) { 21478 PyErr_SetString(PyExc_RuntimeError, 21479 "Unexpected error in an Op's C code. " 21480 "No Python exception was set."); 21481 } 21482 goto __label_362;} 21483 } 21484 if (!PyArray_Check(py_V361)) { 21485 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 21486 { 21487 __failure = 362; 21488 if (!PyErr_Occurred()) { 21489 PyErr_SetString(PyExc_RuntimeError, 21490 "Unexpected error in an Op's C code. " 21491 "No Python exception was set."); 21492 } 21493 goto __label_362;} 21494 } 21495 // We expect NPY_FLOAT64 21496 if (!PyArray_ISALIGNED((PyArrayObject*) py_V361)) { 21497 PyArrayObject * tmp = (PyArrayObject*) py_V361; 21498 PyErr_Format(PyExc_NotImplementedError, 21499 "expected an aligned array of type %ld " 21500 "(NPY_FLOAT64), got non-aligned array of type %ld" 21501 " with %ld dimensions, with 3 last dims " 21502 "%ld, %ld, %ld" 21503 " and 3 last strides %ld %ld, %ld.", 21504 (long int) NPY_FLOAT64, 21505 (long int) PyArray_TYPE((PyArrayObject*) py_V361), 21506 (long int) PyArray_NDIM(tmp), 21507 (long int) (PyArray_NDIM(tmp) >= 3 ? 21508 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 21509 (long int) (PyArray_NDIM(tmp) >= 2 ? 21510 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 21511 (long int) (PyArray_NDIM(tmp) >= 1 ? 21512 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 21513 (long int) (PyArray_NDIM(tmp) >= 3 ? 21514 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 21515 (long int) (PyArray_NDIM(tmp) >= 2 ? 21516 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 21517 (long int) (PyArray_NDIM(tmp) >= 1 ? 21518 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 21519 ); 21520 { 21521 __failure = 362; 21522 if (!PyErr_Occurred()) { 21523 PyErr_SetString(PyExc_RuntimeError, 21524 "Unexpected error in an Op's C code. " 21525 "No Python exception was set."); 21526 } 21527 goto __label_362;} 21528 } 21529 // This is a TypeError to be consistent with DEBUG_MODE 21530 // Note: DEBUG_MODE also tells the name of the container 21531 if (PyArray_TYPE((PyArrayObject*) py_V361) != NPY_FLOAT64) { 21532 PyErr_Format(PyExc_TypeError, 21533 "expected type_num %d (NPY_FLOAT64) got %d", 21534 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V361)); 21535 { 21536 __failure = 362; 21537 if (!PyErr_Occurred()) { 21538 PyErr_SetString(PyExc_RuntimeError, 21539 "Unexpected error in an Op's C code. " 21540 "No Python exception was set."); 21541 } 21542 goto __label_362;} 21543 } 21544 21545 V361 = (PyArrayObject*)(py_V361); 21546 Py_XINCREF(V361); 21547 21548 { 21549 21550 py_V363 = PyList_GET_ITEM(storage_V363, 0); 21551 {Py_XINCREF(py_V363);} 21552 21553 V363 = NULL; 21554 if (py_V363 == Py_None) { 21555 // We can either fail here or set V363 to NULL and rely on Ops 21556 // using tensors to handle the NULL case, but if they fail to do so 21557 // they'll end up with nasty segfaults, so this is public service. 21558 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 21559 { 21560 __failure = 364; 21561 if (!PyErr_Occurred()) { 21562 PyErr_SetString(PyExc_RuntimeError, 21563 "Unexpected error in an Op's C code. " 21564 "No Python exception was set."); 21565 } 21566 goto __label_364;} 21567 } 21568 if (!PyArray_Check(py_V363)) { 21569 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 21570 { 21571 __failure = 364; 21572 if (!PyErr_Occurred()) { 21573 PyErr_SetString(PyExc_RuntimeError, 21574 "Unexpected error in an Op's C code. " 21575 "No Python exception was set."); 21576 } 21577 goto __label_364;} 21578 } 21579 // We expect NPY_FLOAT64 21580 if (!PyArray_ISALIGNED((PyArrayObject*) py_V363)) { 21581 PyArrayObject * tmp = (PyArrayObject*) py_V363; 21582 PyErr_Format(PyExc_NotImplementedError, 21583 "expected an aligned array of type %ld " 21584 "(NPY_FLOAT64), got non-aligned array of type %ld" 21585 " with %ld dimensions, with 3 last dims " 21586 "%ld, %ld, %ld" 21587 " and 3 last strides %ld %ld, %ld.", 21588 (long int) NPY_FLOAT64, 21589 (long int) PyArray_TYPE((PyArrayObject*) py_V363), 21590 (long int) PyArray_NDIM(tmp), 21591 (long int) (PyArray_NDIM(tmp) >= 3 ? 21592 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 21593 (long int) (PyArray_NDIM(tmp) >= 2 ? 21594 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 21595 (long int) (PyArray_NDIM(tmp) >= 1 ? 21596 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 21597 (long int) (PyArray_NDIM(tmp) >= 3 ? 21598 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 21599 (long int) (PyArray_NDIM(tmp) >= 2 ? 21600 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 21601 (long int) (PyArray_NDIM(tmp) >= 1 ? 21602 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 21603 ); 21604 { 21605 __failure = 364; 21606 if (!PyErr_Occurred()) { 21607 PyErr_SetString(PyExc_RuntimeError, 21608 "Unexpected error in an Op's C code. " 21609 "No Python exception was set."); 21610 } 21611 goto __label_364;} 21612 } 21613 // This is a TypeError to be consistent with DEBUG_MODE 21614 // Note: DEBUG_MODE also tells the name of the container 21615 if (PyArray_TYPE((PyArrayObject*) py_V363) != NPY_FLOAT64) { 21616 PyErr_Format(PyExc_TypeError, 21617 "expected type_num %d (NPY_FLOAT64) got %d", 21618 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V363)); 21619 { 21620 __failure = 364; 21621 if (!PyErr_Occurred()) { 21622 PyErr_SetString(PyExc_RuntimeError, 21623 "Unexpected error in an Op's C code. " 21624 "No Python exception was set."); 21625 } 21626 goto __label_364;} 21627 } 21628 21629 V363 = (PyArrayObject*)(py_V363); 21630 Py_XINCREF(V363); 21631 21632 { 21633 21634 py_V365 = PyList_GET_ITEM(storage_V365, 0); 21635 {Py_XINCREF(py_V365);} 21636 21637 V365 = NULL; 21638 if (py_V365 == Py_None) { 21639 // We can either fail here or set V365 to NULL and rely on Ops 21640 // using tensors to handle the NULL case, but if they fail to do so 21641 // they'll end up with nasty segfaults, so this is public service. 21642 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 21643 { 21644 __failure = 366; 21645 if (!PyErr_Occurred()) { 21646 PyErr_SetString(PyExc_RuntimeError, 21647 "Unexpected error in an Op's C code. " 21648 "No Python exception was set."); 21649 } 21650 goto __label_366;} 21651 } 21652 if (!PyArray_Check(py_V365)) { 21653 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 21654 { 21655 __failure = 366; 21656 if (!PyErr_Occurred()) { 21657 PyErr_SetString(PyExc_RuntimeError, 21658 "Unexpected error in an Op's C code. " 21659 "No Python exception was set."); 21660 } 21661 goto __label_366;} 21662 } 21663 // We expect NPY_FLOAT64 21664 if (!PyArray_ISALIGNED((PyArrayObject*) py_V365)) { 21665 PyArrayObject * tmp = (PyArrayObject*) py_V365; 21666 PyErr_Format(PyExc_NotImplementedError, 21667 "expected an aligned array of type %ld " 21668 "(NPY_FLOAT64), got non-aligned array of type %ld" 21669 " with %ld dimensions, with 3 last dims " 21670 "%ld, %ld, %ld" 21671 " and 3 last strides %ld %ld, %ld.", 21672 (long int) NPY_FLOAT64, 21673 (long int) PyArray_TYPE((PyArrayObject*) py_V365), 21674 (long int) PyArray_NDIM(tmp), 21675 (long int) (PyArray_NDIM(tmp) >= 3 ? 21676 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 21677 (long int) (PyArray_NDIM(tmp) >= 2 ? 21678 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 21679 (long int) (PyArray_NDIM(tmp) >= 1 ? 21680 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 21681 (long int) (PyArray_NDIM(tmp) >= 3 ? 21682 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 21683 (long int) (PyArray_NDIM(tmp) >= 2 ? 21684 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 21685 (long int) (PyArray_NDIM(tmp) >= 1 ? 21686 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 21687 ); 21688 { 21689 __failure = 366; 21690 if (!PyErr_Occurred()) { 21691 PyErr_SetString(PyExc_RuntimeError, 21692 "Unexpected error in an Op's C code. " 21693 "No Python exception was set."); 21694 } 21695 goto __label_366;} 21696 } 21697 // This is a TypeError to be consistent with DEBUG_MODE 21698 // Note: DEBUG_MODE also tells the name of the container 21699 if (PyArray_TYPE((PyArrayObject*) py_V365) != NPY_FLOAT64) { 21700 PyErr_Format(PyExc_TypeError, 21701 "expected type_num %d (NPY_FLOAT64) got %d", 21702 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V365)); 21703 { 21704 __failure = 366; 21705 if (!PyErr_Occurred()) { 21706 PyErr_SetString(PyExc_RuntimeError, 21707 "Unexpected error in an Op's C code. " 21708 "No Python exception was set."); 21709 } 21710 goto __label_366;} 21711 } 21712 21713 V365 = (PyArrayObject*)(py_V365); 21714 Py_XINCREF(V365); 21715 21716 { 21717 21718 py_V367 = PyList_GET_ITEM(storage_V367, 0); 21719 {Py_XINCREF(py_V367);} 21720 21721 V367 = NULL; 21722 if (py_V367 == Py_None) { 21723 // We can either fail here or set V367 to NULL and rely on Ops 21724 // using tensors to handle the NULL case, but if they fail to do so 21725 // they'll end up with nasty segfaults, so this is public service. 21726 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 21727 { 21728 __failure = 368; 21729 if (!PyErr_Occurred()) { 21730 PyErr_SetString(PyExc_RuntimeError, 21731 "Unexpected error in an Op's C code. " 21732 "No Python exception was set."); 21733 } 21734 goto __label_368;} 21735 } 21736 if (!PyArray_Check(py_V367)) { 21737 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 21738 { 21739 __failure = 368; 21740 if (!PyErr_Occurred()) { 21741 PyErr_SetString(PyExc_RuntimeError, 21742 "Unexpected error in an Op's C code. " 21743 "No Python exception was set."); 21744 } 21745 goto __label_368;} 21746 } 21747 // We expect NPY_FLOAT64 21748 if (!PyArray_ISALIGNED((PyArrayObject*) py_V367)) { 21749 PyArrayObject * tmp = (PyArrayObject*) py_V367; 21750 PyErr_Format(PyExc_NotImplementedError, 21751 "expected an aligned array of type %ld " 21752 "(NPY_FLOAT64), got non-aligned array of type %ld" 21753 " with %ld dimensions, with 3 last dims " 21754 "%ld, %ld, %ld" 21755 " and 3 last strides %ld %ld, %ld.", 21756 (long int) NPY_FLOAT64, 21757 (long int) PyArray_TYPE((PyArrayObject*) py_V367), 21758 (long int) PyArray_NDIM(tmp), 21759 (long int) (PyArray_NDIM(tmp) >= 3 ? 21760 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 21761 (long int) (PyArray_NDIM(tmp) >= 2 ? 21762 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 21763 (long int) (PyArray_NDIM(tmp) >= 1 ? 21764 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 21765 (long int) (PyArray_NDIM(tmp) >= 3 ? 21766 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 21767 (long int) (PyArray_NDIM(tmp) >= 2 ? 21768 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 21769 (long int) (PyArray_NDIM(tmp) >= 1 ? 21770 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 21771 ); 21772 { 21773 __failure = 368; 21774 if (!PyErr_Occurred()) { 21775 PyErr_SetString(PyExc_RuntimeError, 21776 "Unexpected error in an Op's C code. " 21777 "No Python exception was set."); 21778 } 21779 goto __label_368;} 21780 } 21781 // This is a TypeError to be consistent with DEBUG_MODE 21782 // Note: DEBUG_MODE also tells the name of the container 21783 if (PyArray_TYPE((PyArrayObject*) py_V367) != NPY_FLOAT64) { 21784 PyErr_Format(PyExc_TypeError, 21785 "expected type_num %d (NPY_FLOAT64) got %d", 21786 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V367)); 21787 { 21788 __failure = 368; 21789 if (!PyErr_Occurred()) { 21790 PyErr_SetString(PyExc_RuntimeError, 21791 "Unexpected error in an Op's C code. " 21792 "No Python exception was set."); 21793 } 21794 goto __label_368;} 21795 } 21796 21797 V367 = (PyArrayObject*)(py_V367); 21798 Py_XINCREF(V367); 21799 21800 { 21801 21802 py_V369 = PyList_GET_ITEM(storage_V369, 0); 21803 {Py_XINCREF(py_V369);} 21804 21805 V369 = NULL; 21806 if (py_V369 == Py_None) { 21807 // We can either fail here or set V369 to NULL and rely on Ops 21808 // using tensors to handle the NULL case, but if they fail to do so 21809 // they'll end up with nasty segfaults, so this is public service. 21810 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 21811 { 21812 __failure = 370; 21813 if (!PyErr_Occurred()) { 21814 PyErr_SetString(PyExc_RuntimeError, 21815 "Unexpected error in an Op's C code. " 21816 "No Python exception was set."); 21817 } 21818 goto __label_370;} 21819 } 21820 if (!PyArray_Check(py_V369)) { 21821 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 21822 { 21823 __failure = 370; 21824 if (!PyErr_Occurred()) { 21825 PyErr_SetString(PyExc_RuntimeError, 21826 "Unexpected error in an Op's C code. " 21827 "No Python exception was set."); 21828 } 21829 goto __label_370;} 21830 } 21831 // We expect NPY_FLOAT64 21832 if (!PyArray_ISALIGNED((PyArrayObject*) py_V369)) { 21833 PyArrayObject * tmp = (PyArrayObject*) py_V369; 21834 PyErr_Format(PyExc_NotImplementedError, 21835 "expected an aligned array of type %ld " 21836 "(NPY_FLOAT64), got non-aligned array of type %ld" 21837 " with %ld dimensions, with 3 last dims " 21838 "%ld, %ld, %ld" 21839 " and 3 last strides %ld %ld, %ld.", 21840 (long int) NPY_FLOAT64, 21841 (long int) PyArray_TYPE((PyArrayObject*) py_V369), 21842 (long int) PyArray_NDIM(tmp), 21843 (long int) (PyArray_NDIM(tmp) >= 3 ? 21844 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 21845 (long int) (PyArray_NDIM(tmp) >= 2 ? 21846 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 21847 (long int) (PyArray_NDIM(tmp) >= 1 ? 21848 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 21849 (long int) (PyArray_NDIM(tmp) >= 3 ? 21850 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 21851 (long int) (PyArray_NDIM(tmp) >= 2 ? 21852 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 21853 (long int) (PyArray_NDIM(tmp) >= 1 ? 21854 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 21855 ); 21856 { 21857 __failure = 370; 21858 if (!PyErr_Occurred()) { 21859 PyErr_SetString(PyExc_RuntimeError, 21860 "Unexpected error in an Op's C code. " 21861 "No Python exception was set."); 21862 } 21863 goto __label_370;} 21864 } 21865 // This is a TypeError to be consistent with DEBUG_MODE 21866 // Note: DEBUG_MODE also tells the name of the container 21867 if (PyArray_TYPE((PyArrayObject*) py_V369) != NPY_FLOAT64) { 21868 PyErr_Format(PyExc_TypeError, 21869 "expected type_num %d (NPY_FLOAT64) got %d", 21870 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V369)); 21871 { 21872 __failure = 370; 21873 if (!PyErr_Occurred()) { 21874 PyErr_SetString(PyExc_RuntimeError, 21875 "Unexpected error in an Op's C code. " 21876 "No Python exception was set."); 21877 } 21878 goto __label_370;} 21879 } 21880 21881 V369 = (PyArrayObject*)(py_V369); 21882 Py_XINCREF(V369); 21883 21884 { 21885 21886 py_V371 = PyList_GET_ITEM(storage_V371, 0); 21887 {Py_XINCREF(py_V371);} 21888 21889 V371 = NULL; 21890 if (py_V371 == Py_None) { 21891 // We can either fail here or set V371 to NULL and rely on Ops 21892 // using tensors to handle the NULL case, but if they fail to do so 21893 // they'll end up with nasty segfaults, so this is public service. 21894 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 21895 { 21896 __failure = 372; 21897 if (!PyErr_Occurred()) { 21898 PyErr_SetString(PyExc_RuntimeError, 21899 "Unexpected error in an Op's C code. " 21900 "No Python exception was set."); 21901 } 21902 goto __label_372;} 21903 } 21904 if (!PyArray_Check(py_V371)) { 21905 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 21906 { 21907 __failure = 372; 21908 if (!PyErr_Occurred()) { 21909 PyErr_SetString(PyExc_RuntimeError, 21910 "Unexpected error in an Op's C code. " 21911 "No Python exception was set."); 21912 } 21913 goto __label_372;} 21914 } 21915 // We expect NPY_FLOAT64 21916 if (!PyArray_ISALIGNED((PyArrayObject*) py_V371)) { 21917 PyArrayObject * tmp = (PyArrayObject*) py_V371; 21918 PyErr_Format(PyExc_NotImplementedError, 21919 "expected an aligned array of type %ld " 21920 "(NPY_FLOAT64), got non-aligned array of type %ld" 21921 " with %ld dimensions, with 3 last dims " 21922 "%ld, %ld, %ld" 21923 " and 3 last strides %ld %ld, %ld.", 21924 (long int) NPY_FLOAT64, 21925 (long int) PyArray_TYPE((PyArrayObject*) py_V371), 21926 (long int) PyArray_NDIM(tmp), 21927 (long int) (PyArray_NDIM(tmp) >= 3 ? 21928 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 21929 (long int) (PyArray_NDIM(tmp) >= 2 ? 21930 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 21931 (long int) (PyArray_NDIM(tmp) >= 1 ? 21932 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 21933 (long int) (PyArray_NDIM(tmp) >= 3 ? 21934 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 21935 (long int) (PyArray_NDIM(tmp) >= 2 ? 21936 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 21937 (long int) (PyArray_NDIM(tmp) >= 1 ? 21938 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 21939 ); 21940 { 21941 __failure = 372; 21942 if (!PyErr_Occurred()) { 21943 PyErr_SetString(PyExc_RuntimeError, 21944 "Unexpected error in an Op's C code. " 21945 "No Python exception was set."); 21946 } 21947 goto __label_372;} 21948 } 21949 // This is a TypeError to be consistent with DEBUG_MODE 21950 // Note: DEBUG_MODE also tells the name of the container 21951 if (PyArray_TYPE((PyArrayObject*) py_V371) != NPY_FLOAT64) { 21952 PyErr_Format(PyExc_TypeError, 21953 "expected type_num %d (NPY_FLOAT64) got %d", 21954 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V371)); 21955 { 21956 __failure = 372; 21957 if (!PyErr_Occurred()) { 21958 PyErr_SetString(PyExc_RuntimeError, 21959 "Unexpected error in an Op's C code. " 21960 "No Python exception was set."); 21961 } 21962 goto __label_372;} 21963 } 21964 21965 V371 = (PyArrayObject*)(py_V371); 21966 Py_XINCREF(V371); 21967 21968 { 21969 21970 py_V373 = PyList_GET_ITEM(storage_V373, 0); 21971 {Py_XINCREF(py_V373);} 21972 21973 V373 = NULL; 21974 if (py_V373 == Py_None) { 21975 // We can either fail here or set V373 to NULL and rely on Ops 21976 // using tensors to handle the NULL case, but if they fail to do so 21977 // they'll end up with nasty segfaults, so this is public service. 21978 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 21979 { 21980 __failure = 374; 21981 if (!PyErr_Occurred()) { 21982 PyErr_SetString(PyExc_RuntimeError, 21983 "Unexpected error in an Op's C code. " 21984 "No Python exception was set."); 21985 } 21986 goto __label_374;} 21987 } 21988 if (!PyArray_Check(py_V373)) { 21989 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 21990 { 21991 __failure = 374; 21992 if (!PyErr_Occurred()) { 21993 PyErr_SetString(PyExc_RuntimeError, 21994 "Unexpected error in an Op's C code. " 21995 "No Python exception was set."); 21996 } 21997 goto __label_374;} 21998 } 21999 // We expect NPY_FLOAT64 22000 if (!PyArray_ISALIGNED((PyArrayObject*) py_V373)) { 22001 PyArrayObject * tmp = (PyArrayObject*) py_V373; 22002 PyErr_Format(PyExc_NotImplementedError, 22003 "expected an aligned array of type %ld " 22004 "(NPY_FLOAT64), got non-aligned array of type %ld" 22005 " with %ld dimensions, with 3 last dims " 22006 "%ld, %ld, %ld" 22007 " and 3 last strides %ld %ld, %ld.", 22008 (long int) NPY_FLOAT64, 22009 (long int) PyArray_TYPE((PyArrayObject*) py_V373), 22010 (long int) PyArray_NDIM(tmp), 22011 (long int) (PyArray_NDIM(tmp) >= 3 ? 22012 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 22013 (long int) (PyArray_NDIM(tmp) >= 2 ? 22014 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 22015 (long int) (PyArray_NDIM(tmp) >= 1 ? 22016 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 22017 (long int) (PyArray_NDIM(tmp) >= 3 ? 22018 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 22019 (long int) (PyArray_NDIM(tmp) >= 2 ? 22020 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 22021 (long int) (PyArray_NDIM(tmp) >= 1 ? 22022 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 22023 ); 22024 { 22025 __failure = 374; 22026 if (!PyErr_Occurred()) { 22027 PyErr_SetString(PyExc_RuntimeError, 22028 "Unexpected error in an Op's C code. " 22029 "No Python exception was set."); 22030 } 22031 goto __label_374;} 22032 } 22033 // This is a TypeError to be consistent with DEBUG_MODE 22034 // Note: DEBUG_MODE also tells the name of the container 22035 if (PyArray_TYPE((PyArrayObject*) py_V373) != NPY_FLOAT64) { 22036 PyErr_Format(PyExc_TypeError, 22037 "expected type_num %d (NPY_FLOAT64) got %d", 22038 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V373)); 22039 { 22040 __failure = 374; 22041 if (!PyErr_Occurred()) { 22042 PyErr_SetString(PyExc_RuntimeError, 22043 "Unexpected error in an Op's C code. " 22044 "No Python exception was set."); 22045 } 22046 goto __label_374;} 22047 } 22048 22049 V373 = (PyArrayObject*)(py_V373); 22050 Py_XINCREF(V373); 22051 22052 { 22053 22054 py_V375 = PyList_GET_ITEM(storage_V375, 0); 22055 {Py_XINCREF(py_V375);} 22056 22057 V375 = NULL; 22058 if (py_V375 == Py_None) { 22059 // We can either fail here or set V375 to NULL and rely on Ops 22060 // using tensors to handle the NULL case, but if they fail to do so 22061 // they'll end up with nasty segfaults, so this is public service. 22062 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 22063 { 22064 __failure = 376; 22065 if (!PyErr_Occurred()) { 22066 PyErr_SetString(PyExc_RuntimeError, 22067 "Unexpected error in an Op's C code. " 22068 "No Python exception was set."); 22069 } 22070 goto __label_376;} 22071 } 22072 if (!PyArray_Check(py_V375)) { 22073 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 22074 { 22075 __failure = 376; 22076 if (!PyErr_Occurred()) { 22077 PyErr_SetString(PyExc_RuntimeError, 22078 "Unexpected error in an Op's C code. " 22079 "No Python exception was set."); 22080 } 22081 goto __label_376;} 22082 } 22083 // We expect NPY_FLOAT64 22084 if (!PyArray_ISALIGNED((PyArrayObject*) py_V375)) { 22085 PyArrayObject * tmp = (PyArrayObject*) py_V375; 22086 PyErr_Format(PyExc_NotImplementedError, 22087 "expected an aligned array of type %ld " 22088 "(NPY_FLOAT64), got non-aligned array of type %ld" 22089 " with %ld dimensions, with 3 last dims " 22090 "%ld, %ld, %ld" 22091 " and 3 last strides %ld %ld, %ld.", 22092 (long int) NPY_FLOAT64, 22093 (long int) PyArray_TYPE((PyArrayObject*) py_V375), 22094 (long int) PyArray_NDIM(tmp), 22095 (long int) (PyArray_NDIM(tmp) >= 3 ? 22096 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 22097 (long int) (PyArray_NDIM(tmp) >= 2 ? 22098 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 22099 (long int) (PyArray_NDIM(tmp) >= 1 ? 22100 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 22101 (long int) (PyArray_NDIM(tmp) >= 3 ? 22102 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 22103 (long int) (PyArray_NDIM(tmp) >= 2 ? 22104 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 22105 (long int) (PyArray_NDIM(tmp) >= 1 ? 22106 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 22107 ); 22108 { 22109 __failure = 376; 22110 if (!PyErr_Occurred()) { 22111 PyErr_SetString(PyExc_RuntimeError, 22112 "Unexpected error in an Op's C code. " 22113 "No Python exception was set."); 22114 } 22115 goto __label_376;} 22116 } 22117 // This is a TypeError to be consistent with DEBUG_MODE 22118 // Note: DEBUG_MODE also tells the name of the container 22119 if (PyArray_TYPE((PyArrayObject*) py_V375) != NPY_FLOAT64) { 22120 PyErr_Format(PyExc_TypeError, 22121 "expected type_num %d (NPY_FLOAT64) got %d", 22122 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V375)); 22123 { 22124 __failure = 376; 22125 if (!PyErr_Occurred()) { 22126 PyErr_SetString(PyExc_RuntimeError, 22127 "Unexpected error in an Op's C code. " 22128 "No Python exception was set."); 22129 } 22130 goto __label_376;} 22131 } 22132 22133 V375 = (PyArrayObject*)(py_V375); 22134 Py_XINCREF(V375); 22135 22136 { 22137 22138 py_V377 = PyList_GET_ITEM(storage_V377, 0); 22139 {Py_XINCREF(py_V377);} 22140 22141 V377 = NULL; 22142 if (py_V377 == Py_None) { 22143 // We can either fail here or set V377 to NULL and rely on Ops 22144 // using tensors to handle the NULL case, but if they fail to do so 22145 // they'll end up with nasty segfaults, so this is public service. 22146 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 22147 { 22148 __failure = 378; 22149 if (!PyErr_Occurred()) { 22150 PyErr_SetString(PyExc_RuntimeError, 22151 "Unexpected error in an Op's C code. " 22152 "No Python exception was set."); 22153 } 22154 goto __label_378;} 22155 } 22156 if (!PyArray_Check(py_V377)) { 22157 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 22158 { 22159 __failure = 378; 22160 if (!PyErr_Occurred()) { 22161 PyErr_SetString(PyExc_RuntimeError, 22162 "Unexpected error in an Op's C code. " 22163 "No Python exception was set."); 22164 } 22165 goto __label_378;} 22166 } 22167 // We expect NPY_FLOAT64 22168 if (!PyArray_ISALIGNED((PyArrayObject*) py_V377)) { 22169 PyArrayObject * tmp = (PyArrayObject*) py_V377; 22170 PyErr_Format(PyExc_NotImplementedError, 22171 "expected an aligned array of type %ld " 22172 "(NPY_FLOAT64), got non-aligned array of type %ld" 22173 " with %ld dimensions, with 3 last dims " 22174 "%ld, %ld, %ld" 22175 " and 3 last strides %ld %ld, %ld.", 22176 (long int) NPY_FLOAT64, 22177 (long int) PyArray_TYPE((PyArrayObject*) py_V377), 22178 (long int) PyArray_NDIM(tmp), 22179 (long int) (PyArray_NDIM(tmp) >= 3 ? 22180 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 22181 (long int) (PyArray_NDIM(tmp) >= 2 ? 22182 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 22183 (long int) (PyArray_NDIM(tmp) >= 1 ? 22184 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 22185 (long int) (PyArray_NDIM(tmp) >= 3 ? 22186 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 22187 (long int) (PyArray_NDIM(tmp) >= 2 ? 22188 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 22189 (long int) (PyArray_NDIM(tmp) >= 1 ? 22190 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 22191 ); 22192 { 22193 __failure = 378; 22194 if (!PyErr_Occurred()) { 22195 PyErr_SetString(PyExc_RuntimeError, 22196 "Unexpected error in an Op's C code. " 22197 "No Python exception was set."); 22198 } 22199 goto __label_378;} 22200 } 22201 // This is a TypeError to be consistent with DEBUG_MODE 22202 // Note: DEBUG_MODE also tells the name of the container 22203 if (PyArray_TYPE((PyArrayObject*) py_V377) != NPY_FLOAT64) { 22204 PyErr_Format(PyExc_TypeError, 22205 "expected type_num %d (NPY_FLOAT64) got %d", 22206 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V377)); 22207 { 22208 __failure = 378; 22209 if (!PyErr_Occurred()) { 22210 PyErr_SetString(PyExc_RuntimeError, 22211 "Unexpected error in an Op's C code. " 22212 "No Python exception was set."); 22213 } 22214 goto __label_378;} 22215 } 22216 22217 V377 = (PyArrayObject*)(py_V377); 22218 Py_XINCREF(V377); 22219 22220 { 22221 22222 py_V379 = PyList_GET_ITEM(storage_V379, 0); 22223 {Py_XINCREF(py_V379);} 22224 22225 V379 = NULL; 22226 if (py_V379 == Py_None) { 22227 // We can either fail here or set V379 to NULL and rely on Ops 22228 // using tensors to handle the NULL case, but if they fail to do so 22229 // they'll end up with nasty segfaults, so this is public service. 22230 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 22231 { 22232 __failure = 380; 22233 if (!PyErr_Occurred()) { 22234 PyErr_SetString(PyExc_RuntimeError, 22235 "Unexpected error in an Op's C code. " 22236 "No Python exception was set."); 22237 } 22238 goto __label_380;} 22239 } 22240 if (!PyArray_Check(py_V379)) { 22241 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 22242 { 22243 __failure = 380; 22244 if (!PyErr_Occurred()) { 22245 PyErr_SetString(PyExc_RuntimeError, 22246 "Unexpected error in an Op's C code. " 22247 "No Python exception was set."); 22248 } 22249 goto __label_380;} 22250 } 22251 // We expect NPY_FLOAT64 22252 if (!PyArray_ISALIGNED((PyArrayObject*) py_V379)) { 22253 PyArrayObject * tmp = (PyArrayObject*) py_V379; 22254 PyErr_Format(PyExc_NotImplementedError, 22255 "expected an aligned array of type %ld " 22256 "(NPY_FLOAT64), got non-aligned array of type %ld" 22257 " with %ld dimensions, with 3 last dims " 22258 "%ld, %ld, %ld" 22259 " and 3 last strides %ld %ld, %ld.", 22260 (long int) NPY_FLOAT64, 22261 (long int) PyArray_TYPE((PyArrayObject*) py_V379), 22262 (long int) PyArray_NDIM(tmp), 22263 (long int) (PyArray_NDIM(tmp) >= 3 ? 22264 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 22265 (long int) (PyArray_NDIM(tmp) >= 2 ? 22266 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 22267 (long int) (PyArray_NDIM(tmp) >= 1 ? 22268 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 22269 (long int) (PyArray_NDIM(tmp) >= 3 ? 22270 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 22271 (long int) (PyArray_NDIM(tmp) >= 2 ? 22272 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 22273 (long int) (PyArray_NDIM(tmp) >= 1 ? 22274 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 22275 ); 22276 { 22277 __failure = 380; 22278 if (!PyErr_Occurred()) { 22279 PyErr_SetString(PyExc_RuntimeError, 22280 "Unexpected error in an Op's C code. " 22281 "No Python exception was set."); 22282 } 22283 goto __label_380;} 22284 } 22285 // This is a TypeError to be consistent with DEBUG_MODE 22286 // Note: DEBUG_MODE also tells the name of the container 22287 if (PyArray_TYPE((PyArrayObject*) py_V379) != NPY_FLOAT64) { 22288 PyErr_Format(PyExc_TypeError, 22289 "expected type_num %d (NPY_FLOAT64) got %d", 22290 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V379)); 22291 { 22292 __failure = 380; 22293 if (!PyErr_Occurred()) { 22294 PyErr_SetString(PyExc_RuntimeError, 22295 "Unexpected error in an Op's C code. " 22296 "No Python exception was set."); 22297 } 22298 goto __label_380;} 22299 } 22300 22301 V379 = (PyArrayObject*)(py_V379); 22302 Py_XINCREF(V379); 22303 22304 { 22305 22306 py_V381 = PyList_GET_ITEM(storage_V381, 0); 22307 {Py_XINCREF(py_V381);} 22308 22309 V381 = NULL; 22310 if (py_V381 == Py_None) { 22311 // We can either fail here or set V381 to NULL and rely on Ops 22312 // using tensors to handle the NULL case, but if they fail to do so 22313 // they'll end up with nasty segfaults, so this is public service. 22314 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 22315 { 22316 __failure = 382; 22317 if (!PyErr_Occurred()) { 22318 PyErr_SetString(PyExc_RuntimeError, 22319 "Unexpected error in an Op's C code. " 22320 "No Python exception was set."); 22321 } 22322 goto __label_382;} 22323 } 22324 if (!PyArray_Check(py_V381)) { 22325 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 22326 { 22327 __failure = 382; 22328 if (!PyErr_Occurred()) { 22329 PyErr_SetString(PyExc_RuntimeError, 22330 "Unexpected error in an Op's C code. " 22331 "No Python exception was set."); 22332 } 22333 goto __label_382;} 22334 } 22335 // We expect NPY_FLOAT64 22336 if (!PyArray_ISALIGNED((PyArrayObject*) py_V381)) { 22337 PyArrayObject * tmp = (PyArrayObject*) py_V381; 22338 PyErr_Format(PyExc_NotImplementedError, 22339 "expected an aligned array of type %ld " 22340 "(NPY_FLOAT64), got non-aligned array of type %ld" 22341 " with %ld dimensions, with 3 last dims " 22342 "%ld, %ld, %ld" 22343 " and 3 last strides %ld %ld, %ld.", 22344 (long int) NPY_FLOAT64, 22345 (long int) PyArray_TYPE((PyArrayObject*) py_V381), 22346 (long int) PyArray_NDIM(tmp), 22347 (long int) (PyArray_NDIM(tmp) >= 3 ? 22348 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 22349 (long int) (PyArray_NDIM(tmp) >= 2 ? 22350 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 22351 (long int) (PyArray_NDIM(tmp) >= 1 ? 22352 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 22353 (long int) (PyArray_NDIM(tmp) >= 3 ? 22354 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 22355 (long int) (PyArray_NDIM(tmp) >= 2 ? 22356 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 22357 (long int) (PyArray_NDIM(tmp) >= 1 ? 22358 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 22359 ); 22360 { 22361 __failure = 382; 22362 if (!PyErr_Occurred()) { 22363 PyErr_SetString(PyExc_RuntimeError, 22364 "Unexpected error in an Op's C code. " 22365 "No Python exception was set."); 22366 } 22367 goto __label_382;} 22368 } 22369 // This is a TypeError to be consistent with DEBUG_MODE 22370 // Note: DEBUG_MODE also tells the name of the container 22371 if (PyArray_TYPE((PyArrayObject*) py_V381) != NPY_FLOAT64) { 22372 PyErr_Format(PyExc_TypeError, 22373 "expected type_num %d (NPY_FLOAT64) got %d", 22374 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V381)); 22375 { 22376 __failure = 382; 22377 if (!PyErr_Occurred()) { 22378 PyErr_SetString(PyExc_RuntimeError, 22379 "Unexpected error in an Op's C code. " 22380 "No Python exception was set."); 22381 } 22382 goto __label_382;} 22383 } 22384 22385 V381 = (PyArrayObject*)(py_V381); 22386 Py_XINCREF(V381); 22387 22388 { 22389 22390 py_V383 = PyList_GET_ITEM(storage_V383, 0); 22391 {Py_XINCREF(py_V383);} 22392 22393 V383 = NULL; 22394 if (py_V383 == Py_None) { 22395 // We can either fail here or set V383 to NULL and rely on Ops 22396 // using tensors to handle the NULL case, but if they fail to do so 22397 // they'll end up with nasty segfaults, so this is public service. 22398 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 22399 { 22400 __failure = 384; 22401 if (!PyErr_Occurred()) { 22402 PyErr_SetString(PyExc_RuntimeError, 22403 "Unexpected error in an Op's C code. " 22404 "No Python exception was set."); 22405 } 22406 goto __label_384;} 22407 } 22408 if (!PyArray_Check(py_V383)) { 22409 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 22410 { 22411 __failure = 384; 22412 if (!PyErr_Occurred()) { 22413 PyErr_SetString(PyExc_RuntimeError, 22414 "Unexpected error in an Op's C code. " 22415 "No Python exception was set."); 22416 } 22417 goto __label_384;} 22418 } 22419 // We expect NPY_FLOAT64 22420 if (!PyArray_ISALIGNED((PyArrayObject*) py_V383)) { 22421 PyArrayObject * tmp = (PyArrayObject*) py_V383; 22422 PyErr_Format(PyExc_NotImplementedError, 22423 "expected an aligned array of type %ld " 22424 "(NPY_FLOAT64), got non-aligned array of type %ld" 22425 " with %ld dimensions, with 3 last dims " 22426 "%ld, %ld, %ld" 22427 " and 3 last strides %ld %ld, %ld.", 22428 (long int) NPY_FLOAT64, 22429 (long int) PyArray_TYPE((PyArrayObject*) py_V383), 22430 (long int) PyArray_NDIM(tmp), 22431 (long int) (PyArray_NDIM(tmp) >= 3 ? 22432 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 22433 (long int) (PyArray_NDIM(tmp) >= 2 ? 22434 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 22435 (long int) (PyArray_NDIM(tmp) >= 1 ? 22436 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 22437 (long int) (PyArray_NDIM(tmp) >= 3 ? 22438 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 22439 (long int) (PyArray_NDIM(tmp) >= 2 ? 22440 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 22441 (long int) (PyArray_NDIM(tmp) >= 1 ? 22442 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 22443 ); 22444 { 22445 __failure = 384; 22446 if (!PyErr_Occurred()) { 22447 PyErr_SetString(PyExc_RuntimeError, 22448 "Unexpected error in an Op's C code. " 22449 "No Python exception was set."); 22450 } 22451 goto __label_384;} 22452 } 22453 // This is a TypeError to be consistent with DEBUG_MODE 22454 // Note: DEBUG_MODE also tells the name of the container 22455 if (PyArray_TYPE((PyArrayObject*) py_V383) != NPY_FLOAT64) { 22456 PyErr_Format(PyExc_TypeError, 22457 "expected type_num %d (NPY_FLOAT64) got %d", 22458 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V383)); 22459 { 22460 __failure = 384; 22461 if (!PyErr_Occurred()) { 22462 PyErr_SetString(PyExc_RuntimeError, 22463 "Unexpected error in an Op's C code. " 22464 "No Python exception was set."); 22465 } 22466 goto __label_384;} 22467 } 22468 22469 V383 = (PyArrayObject*)(py_V383); 22470 Py_XINCREF(V383); 22471 22472 { 22473 22474 py_V385 = PyList_GET_ITEM(storage_V385, 0); 22475 {Py_XINCREF(py_V385);} 22476 22477 V385 = NULL; 22478 if (py_V385 == Py_None) { 22479 // We can either fail here or set V385 to NULL and rely on Ops 22480 // using tensors to handle the NULL case, but if they fail to do so 22481 // they'll end up with nasty segfaults, so this is public service. 22482 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 22483 { 22484 __failure = 386; 22485 if (!PyErr_Occurred()) { 22486 PyErr_SetString(PyExc_RuntimeError, 22487 "Unexpected error in an Op's C code. " 22488 "No Python exception was set."); 22489 } 22490 goto __label_386;} 22491 } 22492 if (!PyArray_Check(py_V385)) { 22493 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 22494 { 22495 __failure = 386; 22496 if (!PyErr_Occurred()) { 22497 PyErr_SetString(PyExc_RuntimeError, 22498 "Unexpected error in an Op's C code. " 22499 "No Python exception was set."); 22500 } 22501 goto __label_386;} 22502 } 22503 // We expect NPY_FLOAT64 22504 if (!PyArray_ISALIGNED((PyArrayObject*) py_V385)) { 22505 PyArrayObject * tmp = (PyArrayObject*) py_V385; 22506 PyErr_Format(PyExc_NotImplementedError, 22507 "expected an aligned array of type %ld " 22508 "(NPY_FLOAT64), got non-aligned array of type %ld" 22509 " with %ld dimensions, with 3 last dims " 22510 "%ld, %ld, %ld" 22511 " and 3 last strides %ld %ld, %ld.", 22512 (long int) NPY_FLOAT64, 22513 (long int) PyArray_TYPE((PyArrayObject*) py_V385), 22514 (long int) PyArray_NDIM(tmp), 22515 (long int) (PyArray_NDIM(tmp) >= 3 ? 22516 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 22517 (long int) (PyArray_NDIM(tmp) >= 2 ? 22518 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 22519 (long int) (PyArray_NDIM(tmp) >= 1 ? 22520 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 22521 (long int) (PyArray_NDIM(tmp) >= 3 ? 22522 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 22523 (long int) (PyArray_NDIM(tmp) >= 2 ? 22524 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 22525 (long int) (PyArray_NDIM(tmp) >= 1 ? 22526 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 22527 ); 22528 { 22529 __failure = 386; 22530 if (!PyErr_Occurred()) { 22531 PyErr_SetString(PyExc_RuntimeError, 22532 "Unexpected error in an Op's C code. " 22533 "No Python exception was set."); 22534 } 22535 goto __label_386;} 22536 } 22537 // This is a TypeError to be consistent with DEBUG_MODE 22538 // Note: DEBUG_MODE also tells the name of the container 22539 if (PyArray_TYPE((PyArrayObject*) py_V385) != NPY_FLOAT64) { 22540 PyErr_Format(PyExc_TypeError, 22541 "expected type_num %d (NPY_FLOAT64) got %d", 22542 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V385)); 22543 { 22544 __failure = 386; 22545 if (!PyErr_Occurred()) { 22546 PyErr_SetString(PyExc_RuntimeError, 22547 "Unexpected error in an Op's C code. " 22548 "No Python exception was set."); 22549 } 22550 goto __label_386;} 22551 } 22552 22553 V385 = (PyArrayObject*)(py_V385); 22554 Py_XINCREF(V385); 22555 22556 { 22557 22558 py_V387 = PyList_GET_ITEM(storage_V387, 0); 22559 {Py_XINCREF(py_V387);} 22560 22561 V387 = NULL; 22562 if (py_V387 == Py_None) { 22563 // We can either fail here or set V387 to NULL and rely on Ops 22564 // using tensors to handle the NULL case, but if they fail to do so 22565 // they'll end up with nasty segfaults, so this is public service. 22566 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 22567 { 22568 __failure = 388; 22569 if (!PyErr_Occurred()) { 22570 PyErr_SetString(PyExc_RuntimeError, 22571 "Unexpected error in an Op's C code. " 22572 "No Python exception was set."); 22573 } 22574 goto __label_388;} 22575 } 22576 if (!PyArray_Check(py_V387)) { 22577 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 22578 { 22579 __failure = 388; 22580 if (!PyErr_Occurred()) { 22581 PyErr_SetString(PyExc_RuntimeError, 22582 "Unexpected error in an Op's C code. " 22583 "No Python exception was set."); 22584 } 22585 goto __label_388;} 22586 } 22587 // We expect NPY_FLOAT64 22588 if (!PyArray_ISALIGNED((PyArrayObject*) py_V387)) { 22589 PyArrayObject * tmp = (PyArrayObject*) py_V387; 22590 PyErr_Format(PyExc_NotImplementedError, 22591 "expected an aligned array of type %ld " 22592 "(NPY_FLOAT64), got non-aligned array of type %ld" 22593 " with %ld dimensions, with 3 last dims " 22594 "%ld, %ld, %ld" 22595 " and 3 last strides %ld %ld, %ld.", 22596 (long int) NPY_FLOAT64, 22597 (long int) PyArray_TYPE((PyArrayObject*) py_V387), 22598 (long int) PyArray_NDIM(tmp), 22599 (long int) (PyArray_NDIM(tmp) >= 3 ? 22600 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 22601 (long int) (PyArray_NDIM(tmp) >= 2 ? 22602 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 22603 (long int) (PyArray_NDIM(tmp) >= 1 ? 22604 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 22605 (long int) (PyArray_NDIM(tmp) >= 3 ? 22606 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 22607 (long int) (PyArray_NDIM(tmp) >= 2 ? 22608 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 22609 (long int) (PyArray_NDIM(tmp) >= 1 ? 22610 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 22611 ); 22612 { 22613 __failure = 388; 22614 if (!PyErr_Occurred()) { 22615 PyErr_SetString(PyExc_RuntimeError, 22616 "Unexpected error in an Op's C code. " 22617 "No Python exception was set."); 22618 } 22619 goto __label_388;} 22620 } 22621 // This is a TypeError to be consistent with DEBUG_MODE 22622 // Note: DEBUG_MODE also tells the name of the container 22623 if (PyArray_TYPE((PyArrayObject*) py_V387) != NPY_FLOAT64) { 22624 PyErr_Format(PyExc_TypeError, 22625 "expected type_num %d (NPY_FLOAT64) got %d", 22626 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V387)); 22627 { 22628 __failure = 388; 22629 if (!PyErr_Occurred()) { 22630 PyErr_SetString(PyExc_RuntimeError, 22631 "Unexpected error in an Op's C code. " 22632 "No Python exception was set."); 22633 } 22634 goto __label_388;} 22635 } 22636 22637 V387 = (PyArrayObject*)(py_V387); 22638 Py_XINCREF(V387); 22639 22640 { 22641 22642 py_V389 = PyList_GET_ITEM(storage_V389, 0); 22643 {Py_XINCREF(py_V389);} 22644 22645 V389 = NULL; 22646 if (py_V389 == Py_None) { 22647 // We can either fail here or set V389 to NULL and rely on Ops 22648 // using tensors to handle the NULL case, but if they fail to do so 22649 // they'll end up with nasty segfaults, so this is public service. 22650 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 22651 { 22652 __failure = 390; 22653 if (!PyErr_Occurred()) { 22654 PyErr_SetString(PyExc_RuntimeError, 22655 "Unexpected error in an Op's C code. " 22656 "No Python exception was set."); 22657 } 22658 goto __label_390;} 22659 } 22660 if (!PyArray_Check(py_V389)) { 22661 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 22662 { 22663 __failure = 390; 22664 if (!PyErr_Occurred()) { 22665 PyErr_SetString(PyExc_RuntimeError, 22666 "Unexpected error in an Op's C code. " 22667 "No Python exception was set."); 22668 } 22669 goto __label_390;} 22670 } 22671 // We expect NPY_FLOAT64 22672 if (!PyArray_ISALIGNED((PyArrayObject*) py_V389)) { 22673 PyArrayObject * tmp = (PyArrayObject*) py_V389; 22674 PyErr_Format(PyExc_NotImplementedError, 22675 "expected an aligned array of type %ld " 22676 "(NPY_FLOAT64), got non-aligned array of type %ld" 22677 " with %ld dimensions, with 3 last dims " 22678 "%ld, %ld, %ld" 22679 " and 3 last strides %ld %ld, %ld.", 22680 (long int) NPY_FLOAT64, 22681 (long int) PyArray_TYPE((PyArrayObject*) py_V389), 22682 (long int) PyArray_NDIM(tmp), 22683 (long int) (PyArray_NDIM(tmp) >= 3 ? 22684 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 22685 (long int) (PyArray_NDIM(tmp) >= 2 ? 22686 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 22687 (long int) (PyArray_NDIM(tmp) >= 1 ? 22688 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 22689 (long int) (PyArray_NDIM(tmp) >= 3 ? 22690 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 22691 (long int) (PyArray_NDIM(tmp) >= 2 ? 22692 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 22693 (long int) (PyArray_NDIM(tmp) >= 1 ? 22694 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 22695 ); 22696 { 22697 __failure = 390; 22698 if (!PyErr_Occurred()) { 22699 PyErr_SetString(PyExc_RuntimeError, 22700 "Unexpected error in an Op's C code. " 22701 "No Python exception was set."); 22702 } 22703 goto __label_390;} 22704 } 22705 // This is a TypeError to be consistent with DEBUG_MODE 22706 // Note: DEBUG_MODE also tells the name of the container 22707 if (PyArray_TYPE((PyArrayObject*) py_V389) != NPY_FLOAT64) { 22708 PyErr_Format(PyExc_TypeError, 22709 "expected type_num %d (NPY_FLOAT64) got %d", 22710 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V389)); 22711 { 22712 __failure = 390; 22713 if (!PyErr_Occurred()) { 22714 PyErr_SetString(PyExc_RuntimeError, 22715 "Unexpected error in an Op's C code. " 22716 "No Python exception was set."); 22717 } 22718 goto __label_390;} 22719 } 22720 22721 V389 = (PyArrayObject*)(py_V389); 22722 Py_XINCREF(V389); 22723 22724 { 22725 22726 py_V391 = PyList_GET_ITEM(storage_V391, 0); 22727 {Py_XINCREF(py_V391);} 22728 22729 V391 = NULL; 22730 if (py_V391 == Py_None) { 22731 // We can either fail here or set V391 to NULL and rely on Ops 22732 // using tensors to handle the NULL case, but if they fail to do so 22733 // they'll end up with nasty segfaults, so this is public service. 22734 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 22735 { 22736 __failure = 392; 22737 if (!PyErr_Occurred()) { 22738 PyErr_SetString(PyExc_RuntimeError, 22739 "Unexpected error in an Op's C code. " 22740 "No Python exception was set."); 22741 } 22742 goto __label_392;} 22743 } 22744 if (!PyArray_Check(py_V391)) { 22745 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 22746 { 22747 __failure = 392; 22748 if (!PyErr_Occurred()) { 22749 PyErr_SetString(PyExc_RuntimeError, 22750 "Unexpected error in an Op's C code. " 22751 "No Python exception was set."); 22752 } 22753 goto __label_392;} 22754 } 22755 // We expect NPY_FLOAT64 22756 if (!PyArray_ISALIGNED((PyArrayObject*) py_V391)) { 22757 PyArrayObject * tmp = (PyArrayObject*) py_V391; 22758 PyErr_Format(PyExc_NotImplementedError, 22759 "expected an aligned array of type %ld " 22760 "(NPY_FLOAT64), got non-aligned array of type %ld" 22761 " with %ld dimensions, with 3 last dims " 22762 "%ld, %ld, %ld" 22763 " and 3 last strides %ld %ld, %ld.", 22764 (long int) NPY_FLOAT64, 22765 (long int) PyArray_TYPE((PyArrayObject*) py_V391), 22766 (long int) PyArray_NDIM(tmp), 22767 (long int) (PyArray_NDIM(tmp) >= 3 ? 22768 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 22769 (long int) (PyArray_NDIM(tmp) >= 2 ? 22770 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 22771 (long int) (PyArray_NDIM(tmp) >= 1 ? 22772 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 22773 (long int) (PyArray_NDIM(tmp) >= 3 ? 22774 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 22775 (long int) (PyArray_NDIM(tmp) >= 2 ? 22776 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 22777 (long int) (PyArray_NDIM(tmp) >= 1 ? 22778 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 22779 ); 22780 { 22781 __failure = 392; 22782 if (!PyErr_Occurred()) { 22783 PyErr_SetString(PyExc_RuntimeError, 22784 "Unexpected error in an Op's C code. " 22785 "No Python exception was set."); 22786 } 22787 goto __label_392;} 22788 } 22789 // This is a TypeError to be consistent with DEBUG_MODE 22790 // Note: DEBUG_MODE also tells the name of the container 22791 if (PyArray_TYPE((PyArrayObject*) py_V391) != NPY_FLOAT64) { 22792 PyErr_Format(PyExc_TypeError, 22793 "expected type_num %d (NPY_FLOAT64) got %d", 22794 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V391)); 22795 { 22796 __failure = 392; 22797 if (!PyErr_Occurred()) { 22798 PyErr_SetString(PyExc_RuntimeError, 22799 "Unexpected error in an Op's C code. " 22800 "No Python exception was set."); 22801 } 22802 goto __label_392;} 22803 } 22804 22805 V391 = (PyArrayObject*)(py_V391); 22806 Py_XINCREF(V391); 22807 22808 { 22809 22810 py_V393 = PyList_GET_ITEM(storage_V393, 0); 22811 {Py_XINCREF(py_V393);} 22812 22813 V393 = NULL; 22814 if (py_V393 == Py_None) { 22815 // We can either fail here or set V393 to NULL and rely on Ops 22816 // using tensors to handle the NULL case, but if they fail to do so 22817 // they'll end up with nasty segfaults, so this is public service. 22818 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 22819 { 22820 __failure = 394; 22821 if (!PyErr_Occurred()) { 22822 PyErr_SetString(PyExc_RuntimeError, 22823 "Unexpected error in an Op's C code. " 22824 "No Python exception was set."); 22825 } 22826 goto __label_394;} 22827 } 22828 if (!PyArray_Check(py_V393)) { 22829 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 22830 { 22831 __failure = 394; 22832 if (!PyErr_Occurred()) { 22833 PyErr_SetString(PyExc_RuntimeError, 22834 "Unexpected error in an Op's C code. " 22835 "No Python exception was set."); 22836 } 22837 goto __label_394;} 22838 } 22839 // We expect NPY_FLOAT64 22840 if (!PyArray_ISALIGNED((PyArrayObject*) py_V393)) { 22841 PyArrayObject * tmp = (PyArrayObject*) py_V393; 22842 PyErr_Format(PyExc_NotImplementedError, 22843 "expected an aligned array of type %ld " 22844 "(NPY_FLOAT64), got non-aligned array of type %ld" 22845 " with %ld dimensions, with 3 last dims " 22846 "%ld, %ld, %ld" 22847 " and 3 last strides %ld %ld, %ld.", 22848 (long int) NPY_FLOAT64, 22849 (long int) PyArray_TYPE((PyArrayObject*) py_V393), 22850 (long int) PyArray_NDIM(tmp), 22851 (long int) (PyArray_NDIM(tmp) >= 3 ? 22852 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 22853 (long int) (PyArray_NDIM(tmp) >= 2 ? 22854 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 22855 (long int) (PyArray_NDIM(tmp) >= 1 ? 22856 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 22857 (long int) (PyArray_NDIM(tmp) >= 3 ? 22858 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 22859 (long int) (PyArray_NDIM(tmp) >= 2 ? 22860 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 22861 (long int) (PyArray_NDIM(tmp) >= 1 ? 22862 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 22863 ); 22864 { 22865 __failure = 394; 22866 if (!PyErr_Occurred()) { 22867 PyErr_SetString(PyExc_RuntimeError, 22868 "Unexpected error in an Op's C code. " 22869 "No Python exception was set."); 22870 } 22871 goto __label_394;} 22872 } 22873 // This is a TypeError to be consistent with DEBUG_MODE 22874 // Note: DEBUG_MODE also tells the name of the container 22875 if (PyArray_TYPE((PyArrayObject*) py_V393) != NPY_FLOAT64) { 22876 PyErr_Format(PyExc_TypeError, 22877 "expected type_num %d (NPY_FLOAT64) got %d", 22878 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V393)); 22879 { 22880 __failure = 394; 22881 if (!PyErr_Occurred()) { 22882 PyErr_SetString(PyExc_RuntimeError, 22883 "Unexpected error in an Op's C code. " 22884 "No Python exception was set."); 22885 } 22886 goto __label_394;} 22887 } 22888 22889 V393 = (PyArrayObject*)(py_V393); 22890 Py_XINCREF(V393); 22891 22892 { 22893 22894 py_V395 = PyList_GET_ITEM(storage_V395, 0); 22895 {Py_XINCREF(py_V395);} 22896 22897 V395 = NULL; 22898 if (py_V395 == Py_None) { 22899 // We can either fail here or set V395 to NULL and rely on Ops 22900 // using tensors to handle the NULL case, but if they fail to do so 22901 // they'll end up with nasty segfaults, so this is public service. 22902 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 22903 { 22904 __failure = 396; 22905 if (!PyErr_Occurred()) { 22906 PyErr_SetString(PyExc_RuntimeError, 22907 "Unexpected error in an Op's C code. " 22908 "No Python exception was set."); 22909 } 22910 goto __label_396;} 22911 } 22912 if (!PyArray_Check(py_V395)) { 22913 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 22914 { 22915 __failure = 396; 22916 if (!PyErr_Occurred()) { 22917 PyErr_SetString(PyExc_RuntimeError, 22918 "Unexpected error in an Op's C code. " 22919 "No Python exception was set."); 22920 } 22921 goto __label_396;} 22922 } 22923 // We expect NPY_FLOAT64 22924 if (!PyArray_ISALIGNED((PyArrayObject*) py_V395)) { 22925 PyArrayObject * tmp = (PyArrayObject*) py_V395; 22926 PyErr_Format(PyExc_NotImplementedError, 22927 "expected an aligned array of type %ld " 22928 "(NPY_FLOAT64), got non-aligned array of type %ld" 22929 " with %ld dimensions, with 3 last dims " 22930 "%ld, %ld, %ld" 22931 " and 3 last strides %ld %ld, %ld.", 22932 (long int) NPY_FLOAT64, 22933 (long int) PyArray_TYPE((PyArrayObject*) py_V395), 22934 (long int) PyArray_NDIM(tmp), 22935 (long int) (PyArray_NDIM(tmp) >= 3 ? 22936 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 22937 (long int) (PyArray_NDIM(tmp) >= 2 ? 22938 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 22939 (long int) (PyArray_NDIM(tmp) >= 1 ? 22940 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 22941 (long int) (PyArray_NDIM(tmp) >= 3 ? 22942 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 22943 (long int) (PyArray_NDIM(tmp) >= 2 ? 22944 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 22945 (long int) (PyArray_NDIM(tmp) >= 1 ? 22946 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 22947 ); 22948 { 22949 __failure = 396; 22950 if (!PyErr_Occurred()) { 22951 PyErr_SetString(PyExc_RuntimeError, 22952 "Unexpected error in an Op's C code. " 22953 "No Python exception was set."); 22954 } 22955 goto __label_396;} 22956 } 22957 // This is a TypeError to be consistent with DEBUG_MODE 22958 // Note: DEBUG_MODE also tells the name of the container 22959 if (PyArray_TYPE((PyArrayObject*) py_V395) != NPY_FLOAT64) { 22960 PyErr_Format(PyExc_TypeError, 22961 "expected type_num %d (NPY_FLOAT64) got %d", 22962 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V395)); 22963 { 22964 __failure = 396; 22965 if (!PyErr_Occurred()) { 22966 PyErr_SetString(PyExc_RuntimeError, 22967 "Unexpected error in an Op's C code. " 22968 "No Python exception was set."); 22969 } 22970 goto __label_396;} 22971 } 22972 22973 V395 = (PyArrayObject*)(py_V395); 22974 Py_XINCREF(V395); 22975 22976 { 22977 22978 py_V397 = PyList_GET_ITEM(storage_V397, 0); 22979 {Py_XINCREF(py_V397);} 22980 22981 V397 = NULL; 22982 if (py_V397 == Py_None) { 22983 // We can either fail here or set V397 to NULL and rely on Ops 22984 // using tensors to handle the NULL case, but if they fail to do so 22985 // they'll end up with nasty segfaults, so this is public service. 22986 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 22987 { 22988 __failure = 398; 22989 if (!PyErr_Occurred()) { 22990 PyErr_SetString(PyExc_RuntimeError, 22991 "Unexpected error in an Op's C code. " 22992 "No Python exception was set."); 22993 } 22994 goto __label_398;} 22995 } 22996 if (!PyArray_Check(py_V397)) { 22997 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 22998 { 22999 __failure = 398; 23000 if (!PyErr_Occurred()) { 23001 PyErr_SetString(PyExc_RuntimeError, 23002 "Unexpected error in an Op's C code. " 23003 "No Python exception was set."); 23004 } 23005 goto __label_398;} 23006 } 23007 // We expect NPY_FLOAT64 23008 if (!PyArray_ISALIGNED((PyArrayObject*) py_V397)) { 23009 PyArrayObject * tmp = (PyArrayObject*) py_V397; 23010 PyErr_Format(PyExc_NotImplementedError, 23011 "expected an aligned array of type %ld " 23012 "(NPY_FLOAT64), got non-aligned array of type %ld" 23013 " with %ld dimensions, with 3 last dims " 23014 "%ld, %ld, %ld" 23015 " and 3 last strides %ld %ld, %ld.", 23016 (long int) NPY_FLOAT64, 23017 (long int) PyArray_TYPE((PyArrayObject*) py_V397), 23018 (long int) PyArray_NDIM(tmp), 23019 (long int) (PyArray_NDIM(tmp) >= 3 ? 23020 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 23021 (long int) (PyArray_NDIM(tmp) >= 2 ? 23022 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 23023 (long int) (PyArray_NDIM(tmp) >= 1 ? 23024 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 23025 (long int) (PyArray_NDIM(tmp) >= 3 ? 23026 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 23027 (long int) (PyArray_NDIM(tmp) >= 2 ? 23028 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 23029 (long int) (PyArray_NDIM(tmp) >= 1 ? 23030 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 23031 ); 23032 { 23033 __failure = 398; 23034 if (!PyErr_Occurred()) { 23035 PyErr_SetString(PyExc_RuntimeError, 23036 "Unexpected error in an Op's C code. " 23037 "No Python exception was set."); 23038 } 23039 goto __label_398;} 23040 } 23041 // This is a TypeError to be consistent with DEBUG_MODE 23042 // Note: DEBUG_MODE also tells the name of the container 23043 if (PyArray_TYPE((PyArrayObject*) py_V397) != NPY_FLOAT64) { 23044 PyErr_Format(PyExc_TypeError, 23045 "expected type_num %d (NPY_FLOAT64) got %d", 23046 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V397)); 23047 { 23048 __failure = 398; 23049 if (!PyErr_Occurred()) { 23050 PyErr_SetString(PyExc_RuntimeError, 23051 "Unexpected error in an Op's C code. " 23052 "No Python exception was set."); 23053 } 23054 goto __label_398;} 23055 } 23056 23057 V397 = (PyArrayObject*)(py_V397); 23058 Py_XINCREF(V397); 23059 23060 { 23061 23062 py_V399 = PyList_GET_ITEM(storage_V399, 0); 23063 {Py_XINCREF(py_V399);} 23064 23065 V399 = NULL; 23066 if (py_V399 == Py_None) { 23067 // We can either fail here or set V399 to NULL and rely on Ops 23068 // using tensors to handle the NULL case, but if they fail to do so 23069 // they'll end up with nasty segfaults, so this is public service. 23070 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 23071 { 23072 __failure = 400; 23073 if (!PyErr_Occurred()) { 23074 PyErr_SetString(PyExc_RuntimeError, 23075 "Unexpected error in an Op's C code. " 23076 "No Python exception was set."); 23077 } 23078 goto __label_400;} 23079 } 23080 if (!PyArray_Check(py_V399)) { 23081 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 23082 { 23083 __failure = 400; 23084 if (!PyErr_Occurred()) { 23085 PyErr_SetString(PyExc_RuntimeError, 23086 "Unexpected error in an Op's C code. " 23087 "No Python exception was set."); 23088 } 23089 goto __label_400;} 23090 } 23091 // We expect NPY_FLOAT64 23092 if (!PyArray_ISALIGNED((PyArrayObject*) py_V399)) { 23093 PyArrayObject * tmp = (PyArrayObject*) py_V399; 23094 PyErr_Format(PyExc_NotImplementedError, 23095 "expected an aligned array of type %ld " 23096 "(NPY_FLOAT64), got non-aligned array of type %ld" 23097 " with %ld dimensions, with 3 last dims " 23098 "%ld, %ld, %ld" 23099 " and 3 last strides %ld %ld, %ld.", 23100 (long int) NPY_FLOAT64, 23101 (long int) PyArray_TYPE((PyArrayObject*) py_V399), 23102 (long int) PyArray_NDIM(tmp), 23103 (long int) (PyArray_NDIM(tmp) >= 3 ? 23104 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 23105 (long int) (PyArray_NDIM(tmp) >= 2 ? 23106 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 23107 (long int) (PyArray_NDIM(tmp) >= 1 ? 23108 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 23109 (long int) (PyArray_NDIM(tmp) >= 3 ? 23110 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 23111 (long int) (PyArray_NDIM(tmp) >= 2 ? 23112 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 23113 (long int) (PyArray_NDIM(tmp) >= 1 ? 23114 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 23115 ); 23116 { 23117 __failure = 400; 23118 if (!PyErr_Occurred()) { 23119 PyErr_SetString(PyExc_RuntimeError, 23120 "Unexpected error in an Op's C code. " 23121 "No Python exception was set."); 23122 } 23123 goto __label_400;} 23124 } 23125 // This is a TypeError to be consistent with DEBUG_MODE 23126 // Note: DEBUG_MODE also tells the name of the container 23127 if (PyArray_TYPE((PyArrayObject*) py_V399) != NPY_FLOAT64) { 23128 PyErr_Format(PyExc_TypeError, 23129 "expected type_num %d (NPY_FLOAT64) got %d", 23130 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V399)); 23131 { 23132 __failure = 400; 23133 if (!PyErr_Occurred()) { 23134 PyErr_SetString(PyExc_RuntimeError, 23135 "Unexpected error in an Op's C code. " 23136 "No Python exception was set."); 23137 } 23138 goto __label_400;} 23139 } 23140 23141 V399 = (PyArrayObject*)(py_V399); 23142 Py_XINCREF(V399); 23143 23144 { 23145 23146 py_V401 = PyList_GET_ITEM(storage_V401, 0); 23147 {Py_XINCREF(py_V401);} 23148 23149 V401 = NULL; 23150 if (py_V401 == Py_None) { 23151 // We can either fail here or set V401 to NULL and rely on Ops 23152 // using tensors to handle the NULL case, but if they fail to do so 23153 // they'll end up with nasty segfaults, so this is public service. 23154 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 23155 { 23156 __failure = 402; 23157 if (!PyErr_Occurred()) { 23158 PyErr_SetString(PyExc_RuntimeError, 23159 "Unexpected error in an Op's C code. " 23160 "No Python exception was set."); 23161 } 23162 goto __label_402;} 23163 } 23164 if (!PyArray_Check(py_V401)) { 23165 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 23166 { 23167 __failure = 402; 23168 if (!PyErr_Occurred()) { 23169 PyErr_SetString(PyExc_RuntimeError, 23170 "Unexpected error in an Op's C code. " 23171 "No Python exception was set."); 23172 } 23173 goto __label_402;} 23174 } 23175 // We expect NPY_FLOAT64 23176 if (!PyArray_ISALIGNED((PyArrayObject*) py_V401)) { 23177 PyArrayObject * tmp = (PyArrayObject*) py_V401; 23178 PyErr_Format(PyExc_NotImplementedError, 23179 "expected an aligned array of type %ld " 23180 "(NPY_FLOAT64), got non-aligned array of type %ld" 23181 " with %ld dimensions, with 3 last dims " 23182 "%ld, %ld, %ld" 23183 " and 3 last strides %ld %ld, %ld.", 23184 (long int) NPY_FLOAT64, 23185 (long int) PyArray_TYPE((PyArrayObject*) py_V401), 23186 (long int) PyArray_NDIM(tmp), 23187 (long int) (PyArray_NDIM(tmp) >= 3 ? 23188 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 23189 (long int) (PyArray_NDIM(tmp) >= 2 ? 23190 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 23191 (long int) (PyArray_NDIM(tmp) >= 1 ? 23192 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 23193 (long int) (PyArray_NDIM(tmp) >= 3 ? 23194 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 23195 (long int) (PyArray_NDIM(tmp) >= 2 ? 23196 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 23197 (long int) (PyArray_NDIM(tmp) >= 1 ? 23198 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 23199 ); 23200 { 23201 __failure = 402; 23202 if (!PyErr_Occurred()) { 23203 PyErr_SetString(PyExc_RuntimeError, 23204 "Unexpected error in an Op's C code. " 23205 "No Python exception was set."); 23206 } 23207 goto __label_402;} 23208 } 23209 // This is a TypeError to be consistent with DEBUG_MODE 23210 // Note: DEBUG_MODE also tells the name of the container 23211 if (PyArray_TYPE((PyArrayObject*) py_V401) != NPY_FLOAT64) { 23212 PyErr_Format(PyExc_TypeError, 23213 "expected type_num %d (NPY_FLOAT64) got %d", 23214 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V401)); 23215 { 23216 __failure = 402; 23217 if (!PyErr_Occurred()) { 23218 PyErr_SetString(PyExc_RuntimeError, 23219 "Unexpected error in an Op's C code. " 23220 "No Python exception was set."); 23221 } 23222 goto __label_402;} 23223 } 23224 23225 V401 = (PyArrayObject*)(py_V401); 23226 Py_XINCREF(V401); 23227 23228 { 23229 23230 py_V403 = PyList_GET_ITEM(storage_V403, 0); 23231 {Py_XINCREF(py_V403);} 23232 23233 V403 = NULL; 23234 if (py_V403 == Py_None) { 23235 // We can either fail here or set V403 to NULL and rely on Ops 23236 // using tensors to handle the NULL case, but if they fail to do so 23237 // they'll end up with nasty segfaults, so this is public service. 23238 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 23239 { 23240 __failure = 404; 23241 if (!PyErr_Occurred()) { 23242 PyErr_SetString(PyExc_RuntimeError, 23243 "Unexpected error in an Op's C code. " 23244 "No Python exception was set."); 23245 } 23246 goto __label_404;} 23247 } 23248 if (!PyArray_Check(py_V403)) { 23249 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 23250 { 23251 __failure = 404; 23252 if (!PyErr_Occurred()) { 23253 PyErr_SetString(PyExc_RuntimeError, 23254 "Unexpected error in an Op's C code. " 23255 "No Python exception was set."); 23256 } 23257 goto __label_404;} 23258 } 23259 // We expect NPY_FLOAT64 23260 if (!PyArray_ISALIGNED((PyArrayObject*) py_V403)) { 23261 PyArrayObject * tmp = (PyArrayObject*) py_V403; 23262 PyErr_Format(PyExc_NotImplementedError, 23263 "expected an aligned array of type %ld " 23264 "(NPY_FLOAT64), got non-aligned array of type %ld" 23265 " with %ld dimensions, with 3 last dims " 23266 "%ld, %ld, %ld" 23267 " and 3 last strides %ld %ld, %ld.", 23268 (long int) NPY_FLOAT64, 23269 (long int) PyArray_TYPE((PyArrayObject*) py_V403), 23270 (long int) PyArray_NDIM(tmp), 23271 (long int) (PyArray_NDIM(tmp) >= 3 ? 23272 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 23273 (long int) (PyArray_NDIM(tmp) >= 2 ? 23274 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 23275 (long int) (PyArray_NDIM(tmp) >= 1 ? 23276 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 23277 (long int) (PyArray_NDIM(tmp) >= 3 ? 23278 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 23279 (long int) (PyArray_NDIM(tmp) >= 2 ? 23280 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 23281 (long int) (PyArray_NDIM(tmp) >= 1 ? 23282 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 23283 ); 23284 { 23285 __failure = 404; 23286 if (!PyErr_Occurred()) { 23287 PyErr_SetString(PyExc_RuntimeError, 23288 "Unexpected error in an Op's C code. " 23289 "No Python exception was set."); 23290 } 23291 goto __label_404;} 23292 } 23293 // This is a TypeError to be consistent with DEBUG_MODE 23294 // Note: DEBUG_MODE also tells the name of the container 23295 if (PyArray_TYPE((PyArrayObject*) py_V403) != NPY_FLOAT64) { 23296 PyErr_Format(PyExc_TypeError, 23297 "expected type_num %d (NPY_FLOAT64) got %d", 23298 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V403)); 23299 { 23300 __failure = 404; 23301 if (!PyErr_Occurred()) { 23302 PyErr_SetString(PyExc_RuntimeError, 23303 "Unexpected error in an Op's C code. " 23304 "No Python exception was set."); 23305 } 23306 goto __label_404;} 23307 } 23308 23309 V403 = (PyArrayObject*)(py_V403); 23310 Py_XINCREF(V403); 23311 23312 { 23313 23314 py_V405 = PyList_GET_ITEM(storage_V405, 0); 23315 {Py_XINCREF(py_V405);} 23316 23317 V405 = NULL; 23318 if (py_V405 == Py_None) { 23319 // We can either fail here or set V405 to NULL and rely on Ops 23320 // using tensors to handle the NULL case, but if they fail to do so 23321 // they'll end up with nasty segfaults, so this is public service. 23322 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 23323 { 23324 __failure = 406; 23325 if (!PyErr_Occurred()) { 23326 PyErr_SetString(PyExc_RuntimeError, 23327 "Unexpected error in an Op's C code. " 23328 "No Python exception was set."); 23329 } 23330 goto __label_406;} 23331 } 23332 if (!PyArray_Check(py_V405)) { 23333 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 23334 { 23335 __failure = 406; 23336 if (!PyErr_Occurred()) { 23337 PyErr_SetString(PyExc_RuntimeError, 23338 "Unexpected error in an Op's C code. " 23339 "No Python exception was set."); 23340 } 23341 goto __label_406;} 23342 } 23343 // We expect NPY_FLOAT64 23344 if (!PyArray_ISALIGNED((PyArrayObject*) py_V405)) { 23345 PyArrayObject * tmp = (PyArrayObject*) py_V405; 23346 PyErr_Format(PyExc_NotImplementedError, 23347 "expected an aligned array of type %ld " 23348 "(NPY_FLOAT64), got non-aligned array of type %ld" 23349 " with %ld dimensions, with 3 last dims " 23350 "%ld, %ld, %ld" 23351 " and 3 last strides %ld %ld, %ld.", 23352 (long int) NPY_FLOAT64, 23353 (long int) PyArray_TYPE((PyArrayObject*) py_V405), 23354 (long int) PyArray_NDIM(tmp), 23355 (long int) (PyArray_NDIM(tmp) >= 3 ? 23356 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 23357 (long int) (PyArray_NDIM(tmp) >= 2 ? 23358 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 23359 (long int) (PyArray_NDIM(tmp) >= 1 ? 23360 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 23361 (long int) (PyArray_NDIM(tmp) >= 3 ? 23362 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 23363 (long int) (PyArray_NDIM(tmp) >= 2 ? 23364 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 23365 (long int) (PyArray_NDIM(tmp) >= 1 ? 23366 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 23367 ); 23368 { 23369 __failure = 406; 23370 if (!PyErr_Occurred()) { 23371 PyErr_SetString(PyExc_RuntimeError, 23372 "Unexpected error in an Op's C code. " 23373 "No Python exception was set."); 23374 } 23375 goto __label_406;} 23376 } 23377 // This is a TypeError to be consistent with DEBUG_MODE 23378 // Note: DEBUG_MODE also tells the name of the container 23379 if (PyArray_TYPE((PyArrayObject*) py_V405) != NPY_FLOAT64) { 23380 PyErr_Format(PyExc_TypeError, 23381 "expected type_num %d (NPY_FLOAT64) got %d", 23382 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V405)); 23383 { 23384 __failure = 406; 23385 if (!PyErr_Occurred()) { 23386 PyErr_SetString(PyExc_RuntimeError, 23387 "Unexpected error in an Op's C code. " 23388 "No Python exception was set."); 23389 } 23390 goto __label_406;} 23391 } 23392 23393 V405 = (PyArrayObject*)(py_V405); 23394 Py_XINCREF(V405); 23395 23396 { 23397 23398 py_V407 = PyList_GET_ITEM(storage_V407, 0); 23399 {Py_XINCREF(py_V407);} 23400 23401 V407 = NULL; 23402 if (py_V407 == Py_None) { 23403 // We can either fail here or set V407 to NULL and rely on Ops 23404 // using tensors to handle the NULL case, but if they fail to do so 23405 // they'll end up with nasty segfaults, so this is public service. 23406 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 23407 { 23408 __failure = 408; 23409 if (!PyErr_Occurred()) { 23410 PyErr_SetString(PyExc_RuntimeError, 23411 "Unexpected error in an Op's C code. " 23412 "No Python exception was set."); 23413 } 23414 goto __label_408;} 23415 } 23416 if (!PyArray_Check(py_V407)) { 23417 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 23418 { 23419 __failure = 408; 23420 if (!PyErr_Occurred()) { 23421 PyErr_SetString(PyExc_RuntimeError, 23422 "Unexpected error in an Op's C code. " 23423 "No Python exception was set."); 23424 } 23425 goto __label_408;} 23426 } 23427 // We expect NPY_FLOAT64 23428 if (!PyArray_ISALIGNED((PyArrayObject*) py_V407)) { 23429 PyArrayObject * tmp = (PyArrayObject*) py_V407; 23430 PyErr_Format(PyExc_NotImplementedError, 23431 "expected an aligned array of type %ld " 23432 "(NPY_FLOAT64), got non-aligned array of type %ld" 23433 " with %ld dimensions, with 3 last dims " 23434 "%ld, %ld, %ld" 23435 " and 3 last strides %ld %ld, %ld.", 23436 (long int) NPY_FLOAT64, 23437 (long int) PyArray_TYPE((PyArrayObject*) py_V407), 23438 (long int) PyArray_NDIM(tmp), 23439 (long int) (PyArray_NDIM(tmp) >= 3 ? 23440 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 23441 (long int) (PyArray_NDIM(tmp) >= 2 ? 23442 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 23443 (long int) (PyArray_NDIM(tmp) >= 1 ? 23444 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 23445 (long int) (PyArray_NDIM(tmp) >= 3 ? 23446 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 23447 (long int) (PyArray_NDIM(tmp) >= 2 ? 23448 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 23449 (long int) (PyArray_NDIM(tmp) >= 1 ? 23450 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 23451 ); 23452 { 23453 __failure = 408; 23454 if (!PyErr_Occurred()) { 23455 PyErr_SetString(PyExc_RuntimeError, 23456 "Unexpected error in an Op's C code. " 23457 "No Python exception was set."); 23458 } 23459 goto __label_408;} 23460 } 23461 // This is a TypeError to be consistent with DEBUG_MODE 23462 // Note: DEBUG_MODE also tells the name of the container 23463 if (PyArray_TYPE((PyArrayObject*) py_V407) != NPY_FLOAT64) { 23464 PyErr_Format(PyExc_TypeError, 23465 "expected type_num %d (NPY_FLOAT64) got %d", 23466 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V407)); 23467 { 23468 __failure = 408; 23469 if (!PyErr_Occurred()) { 23470 PyErr_SetString(PyExc_RuntimeError, 23471 "Unexpected error in an Op's C code. " 23472 "No Python exception was set."); 23473 } 23474 goto __label_408;} 23475 } 23476 23477 V407 = (PyArrayObject*)(py_V407); 23478 Py_XINCREF(V407); 23479 23480 { 23481 23482 py_V409 = PyList_GET_ITEM(storage_V409, 0); 23483 {Py_XINCREF(py_V409);} 23484 23485 V409 = NULL; 23486 if (py_V409 == Py_None) { 23487 // We can either fail here or set V409 to NULL and rely on Ops 23488 // using tensors to handle the NULL case, but if they fail to do so 23489 // they'll end up with nasty segfaults, so this is public service. 23490 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 23491 { 23492 __failure = 410; 23493 if (!PyErr_Occurred()) { 23494 PyErr_SetString(PyExc_RuntimeError, 23495 "Unexpected error in an Op's C code. " 23496 "No Python exception was set."); 23497 } 23498 goto __label_410;} 23499 } 23500 if (!PyArray_Check(py_V409)) { 23501 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 23502 { 23503 __failure = 410; 23504 if (!PyErr_Occurred()) { 23505 PyErr_SetString(PyExc_RuntimeError, 23506 "Unexpected error in an Op's C code. " 23507 "No Python exception was set."); 23508 } 23509 goto __label_410;} 23510 } 23511 // We expect NPY_FLOAT64 23512 if (!PyArray_ISALIGNED((PyArrayObject*) py_V409)) { 23513 PyArrayObject * tmp = (PyArrayObject*) py_V409; 23514 PyErr_Format(PyExc_NotImplementedError, 23515 "expected an aligned array of type %ld " 23516 "(NPY_FLOAT64), got non-aligned array of type %ld" 23517 " with %ld dimensions, with 3 last dims " 23518 "%ld, %ld, %ld" 23519 " and 3 last strides %ld %ld, %ld.", 23520 (long int) NPY_FLOAT64, 23521 (long int) PyArray_TYPE((PyArrayObject*) py_V409), 23522 (long int) PyArray_NDIM(tmp), 23523 (long int) (PyArray_NDIM(tmp) >= 3 ? 23524 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 23525 (long int) (PyArray_NDIM(tmp) >= 2 ? 23526 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 23527 (long int) (PyArray_NDIM(tmp) >= 1 ? 23528 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 23529 (long int) (PyArray_NDIM(tmp) >= 3 ? 23530 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 23531 (long int) (PyArray_NDIM(tmp) >= 2 ? 23532 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 23533 (long int) (PyArray_NDIM(tmp) >= 1 ? 23534 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 23535 ); 23536 { 23537 __failure = 410; 23538 if (!PyErr_Occurred()) { 23539 PyErr_SetString(PyExc_RuntimeError, 23540 "Unexpected error in an Op's C code. " 23541 "No Python exception was set."); 23542 } 23543 goto __label_410;} 23544 } 23545 // This is a TypeError to be consistent with DEBUG_MODE 23546 // Note: DEBUG_MODE also tells the name of the container 23547 if (PyArray_TYPE((PyArrayObject*) py_V409) != NPY_FLOAT64) { 23548 PyErr_Format(PyExc_TypeError, 23549 "expected type_num %d (NPY_FLOAT64) got %d", 23550 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V409)); 23551 { 23552 __failure = 410; 23553 if (!PyErr_Occurred()) { 23554 PyErr_SetString(PyExc_RuntimeError, 23555 "Unexpected error in an Op's C code. " 23556 "No Python exception was set."); 23557 } 23558 goto __label_410;} 23559 } 23560 23561 V409 = (PyArrayObject*)(py_V409); 23562 Py_XINCREF(V409); 23563 23564 { 23565 23566 py_V411 = PyList_GET_ITEM(storage_V411, 0); 23567 {Py_XINCREF(py_V411);} 23568 23569 V411 = NULL; 23570 if (py_V411 == Py_None) { 23571 // We can either fail here or set V411 to NULL and rely on Ops 23572 // using tensors to handle the NULL case, but if they fail to do so 23573 // they'll end up with nasty segfaults, so this is public service. 23574 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 23575 { 23576 __failure = 412; 23577 if (!PyErr_Occurred()) { 23578 PyErr_SetString(PyExc_RuntimeError, 23579 "Unexpected error in an Op's C code. " 23580 "No Python exception was set."); 23581 } 23582 goto __label_412;} 23583 } 23584 if (!PyArray_Check(py_V411)) { 23585 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 23586 { 23587 __failure = 412; 23588 if (!PyErr_Occurred()) { 23589 PyErr_SetString(PyExc_RuntimeError, 23590 "Unexpected error in an Op's C code. " 23591 "No Python exception was set."); 23592 } 23593 goto __label_412;} 23594 } 23595 // We expect NPY_FLOAT64 23596 if (!PyArray_ISALIGNED((PyArrayObject*) py_V411)) { 23597 PyArrayObject * tmp = (PyArrayObject*) py_V411; 23598 PyErr_Format(PyExc_NotImplementedError, 23599 "expected an aligned array of type %ld " 23600 "(NPY_FLOAT64), got non-aligned array of type %ld" 23601 " with %ld dimensions, with 3 last dims " 23602 "%ld, %ld, %ld" 23603 " and 3 last strides %ld %ld, %ld.", 23604 (long int) NPY_FLOAT64, 23605 (long int) PyArray_TYPE((PyArrayObject*) py_V411), 23606 (long int) PyArray_NDIM(tmp), 23607 (long int) (PyArray_NDIM(tmp) >= 3 ? 23608 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 23609 (long int) (PyArray_NDIM(tmp) >= 2 ? 23610 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 23611 (long int) (PyArray_NDIM(tmp) >= 1 ? 23612 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 23613 (long int) (PyArray_NDIM(tmp) >= 3 ? 23614 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 23615 (long int) (PyArray_NDIM(tmp) >= 2 ? 23616 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 23617 (long int) (PyArray_NDIM(tmp) >= 1 ? 23618 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 23619 ); 23620 { 23621 __failure = 412; 23622 if (!PyErr_Occurred()) { 23623 PyErr_SetString(PyExc_RuntimeError, 23624 "Unexpected error in an Op's C code. " 23625 "No Python exception was set."); 23626 } 23627 goto __label_412;} 23628 } 23629 // This is a TypeError to be consistent with DEBUG_MODE 23630 // Note: DEBUG_MODE also tells the name of the container 23631 if (PyArray_TYPE((PyArrayObject*) py_V411) != NPY_FLOAT64) { 23632 PyErr_Format(PyExc_TypeError, 23633 "expected type_num %d (NPY_FLOAT64) got %d", 23634 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V411)); 23635 { 23636 __failure = 412; 23637 if (!PyErr_Occurred()) { 23638 PyErr_SetString(PyExc_RuntimeError, 23639 "Unexpected error in an Op's C code. " 23640 "No Python exception was set."); 23641 } 23642 goto __label_412;} 23643 } 23644 23645 V411 = (PyArrayObject*)(py_V411); 23646 Py_XINCREF(V411); 23647 23648 { 23649 23650 py_V413 = PyList_GET_ITEM(storage_V413, 0); 23651 {Py_XINCREF(py_V413);} 23652 23653 V413 = NULL; 23654 if (py_V413 == Py_None) { 23655 // We can either fail here or set V413 to NULL and rely on Ops 23656 // using tensors to handle the NULL case, but if they fail to do so 23657 // they'll end up with nasty segfaults, so this is public service. 23658 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 23659 { 23660 __failure = 414; 23661 if (!PyErr_Occurred()) { 23662 PyErr_SetString(PyExc_RuntimeError, 23663 "Unexpected error in an Op's C code. " 23664 "No Python exception was set."); 23665 } 23666 goto __label_414;} 23667 } 23668 if (!PyArray_Check(py_V413)) { 23669 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 23670 { 23671 __failure = 414; 23672 if (!PyErr_Occurred()) { 23673 PyErr_SetString(PyExc_RuntimeError, 23674 "Unexpected error in an Op's C code. " 23675 "No Python exception was set."); 23676 } 23677 goto __label_414;} 23678 } 23679 // We expect NPY_FLOAT64 23680 if (!PyArray_ISALIGNED((PyArrayObject*) py_V413)) { 23681 PyArrayObject * tmp = (PyArrayObject*) py_V413; 23682 PyErr_Format(PyExc_NotImplementedError, 23683 "expected an aligned array of type %ld " 23684 "(NPY_FLOAT64), got non-aligned array of type %ld" 23685 " with %ld dimensions, with 3 last dims " 23686 "%ld, %ld, %ld" 23687 " and 3 last strides %ld %ld, %ld.", 23688 (long int) NPY_FLOAT64, 23689 (long int) PyArray_TYPE((PyArrayObject*) py_V413), 23690 (long int) PyArray_NDIM(tmp), 23691 (long int) (PyArray_NDIM(tmp) >= 3 ? 23692 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 23693 (long int) (PyArray_NDIM(tmp) >= 2 ? 23694 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 23695 (long int) (PyArray_NDIM(tmp) >= 1 ? 23696 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 23697 (long int) (PyArray_NDIM(tmp) >= 3 ? 23698 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 23699 (long int) (PyArray_NDIM(tmp) >= 2 ? 23700 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 23701 (long int) (PyArray_NDIM(tmp) >= 1 ? 23702 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 23703 ); 23704 { 23705 __failure = 414; 23706 if (!PyErr_Occurred()) { 23707 PyErr_SetString(PyExc_RuntimeError, 23708 "Unexpected error in an Op's C code. " 23709 "No Python exception was set."); 23710 } 23711 goto __label_414;} 23712 } 23713 // This is a TypeError to be consistent with DEBUG_MODE 23714 // Note: DEBUG_MODE also tells the name of the container 23715 if (PyArray_TYPE((PyArrayObject*) py_V413) != NPY_FLOAT64) { 23716 PyErr_Format(PyExc_TypeError, 23717 "expected type_num %d (NPY_FLOAT64) got %d", 23718 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V413)); 23719 { 23720 __failure = 414; 23721 if (!PyErr_Occurred()) { 23722 PyErr_SetString(PyExc_RuntimeError, 23723 "Unexpected error in an Op's C code. " 23724 "No Python exception was set."); 23725 } 23726 goto __label_414;} 23727 } 23728 23729 V413 = (PyArrayObject*)(py_V413); 23730 Py_XINCREF(V413); 23731 23732 { 23733 23734 py_V415 = PyList_GET_ITEM(storage_V415, 0); 23735 {Py_XINCREF(py_V415);} 23736 23737 V415 = NULL; 23738 if (py_V415 == Py_None) { 23739 // We can either fail here or set V415 to NULL and rely on Ops 23740 // using tensors to handle the NULL case, but if they fail to do so 23741 // they'll end up with nasty segfaults, so this is public service. 23742 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 23743 { 23744 __failure = 416; 23745 if (!PyErr_Occurred()) { 23746 PyErr_SetString(PyExc_RuntimeError, 23747 "Unexpected error in an Op's C code. " 23748 "No Python exception was set."); 23749 } 23750 goto __label_416;} 23751 } 23752 if (!PyArray_Check(py_V415)) { 23753 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 23754 { 23755 __failure = 416; 23756 if (!PyErr_Occurred()) { 23757 PyErr_SetString(PyExc_RuntimeError, 23758 "Unexpected error in an Op's C code. " 23759 "No Python exception was set."); 23760 } 23761 goto __label_416;} 23762 } 23763 // We expect NPY_FLOAT64 23764 if (!PyArray_ISALIGNED((PyArrayObject*) py_V415)) { 23765 PyArrayObject * tmp = (PyArrayObject*) py_V415; 23766 PyErr_Format(PyExc_NotImplementedError, 23767 "expected an aligned array of type %ld " 23768 "(NPY_FLOAT64), got non-aligned array of type %ld" 23769 " with %ld dimensions, with 3 last dims " 23770 "%ld, %ld, %ld" 23771 " and 3 last strides %ld %ld, %ld.", 23772 (long int) NPY_FLOAT64, 23773 (long int) PyArray_TYPE((PyArrayObject*) py_V415), 23774 (long int) PyArray_NDIM(tmp), 23775 (long int) (PyArray_NDIM(tmp) >= 3 ? 23776 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 23777 (long int) (PyArray_NDIM(tmp) >= 2 ? 23778 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 23779 (long int) (PyArray_NDIM(tmp) >= 1 ? 23780 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 23781 (long int) (PyArray_NDIM(tmp) >= 3 ? 23782 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 23783 (long int) (PyArray_NDIM(tmp) >= 2 ? 23784 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 23785 (long int) (PyArray_NDIM(tmp) >= 1 ? 23786 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 23787 ); 23788 { 23789 __failure = 416; 23790 if (!PyErr_Occurred()) { 23791 PyErr_SetString(PyExc_RuntimeError, 23792 "Unexpected error in an Op's C code. " 23793 "No Python exception was set."); 23794 } 23795 goto __label_416;} 23796 } 23797 // This is a TypeError to be consistent with DEBUG_MODE 23798 // Note: DEBUG_MODE also tells the name of the container 23799 if (PyArray_TYPE((PyArrayObject*) py_V415) != NPY_FLOAT64) { 23800 PyErr_Format(PyExc_TypeError, 23801 "expected type_num %d (NPY_FLOAT64) got %d", 23802 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V415)); 23803 { 23804 __failure = 416; 23805 if (!PyErr_Occurred()) { 23806 PyErr_SetString(PyExc_RuntimeError, 23807 "Unexpected error in an Op's C code. " 23808 "No Python exception was set."); 23809 } 23810 goto __label_416;} 23811 } 23812 23813 V415 = (PyArrayObject*)(py_V415); 23814 Py_XINCREF(V415); 23815 23816 { 23817 23818 py_V417 = PyList_GET_ITEM(storage_V417, 0); 23819 {Py_XINCREF(py_V417);} 23820 23821 V417 = NULL; 23822 if (py_V417 == Py_None) { 23823 // We can either fail here or set V417 to NULL and rely on Ops 23824 // using tensors to handle the NULL case, but if they fail to do so 23825 // they'll end up with nasty segfaults, so this is public service. 23826 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 23827 { 23828 __failure = 418; 23829 if (!PyErr_Occurred()) { 23830 PyErr_SetString(PyExc_RuntimeError, 23831 "Unexpected error in an Op's C code. " 23832 "No Python exception was set."); 23833 } 23834 goto __label_418;} 23835 } 23836 if (!PyArray_Check(py_V417)) { 23837 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 23838 { 23839 __failure = 418; 23840 if (!PyErr_Occurred()) { 23841 PyErr_SetString(PyExc_RuntimeError, 23842 "Unexpected error in an Op's C code. " 23843 "No Python exception was set."); 23844 } 23845 goto __label_418;} 23846 } 23847 // We expect NPY_FLOAT64 23848 if (!PyArray_ISALIGNED((PyArrayObject*) py_V417)) { 23849 PyArrayObject * tmp = (PyArrayObject*) py_V417; 23850 PyErr_Format(PyExc_NotImplementedError, 23851 "expected an aligned array of type %ld " 23852 "(NPY_FLOAT64), got non-aligned array of type %ld" 23853 " with %ld dimensions, with 3 last dims " 23854 "%ld, %ld, %ld" 23855 " and 3 last strides %ld %ld, %ld.", 23856 (long int) NPY_FLOAT64, 23857 (long int) PyArray_TYPE((PyArrayObject*) py_V417), 23858 (long int) PyArray_NDIM(tmp), 23859 (long int) (PyArray_NDIM(tmp) >= 3 ? 23860 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 23861 (long int) (PyArray_NDIM(tmp) >= 2 ? 23862 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 23863 (long int) (PyArray_NDIM(tmp) >= 1 ? 23864 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 23865 (long int) (PyArray_NDIM(tmp) >= 3 ? 23866 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 23867 (long int) (PyArray_NDIM(tmp) >= 2 ? 23868 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 23869 (long int) (PyArray_NDIM(tmp) >= 1 ? 23870 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 23871 ); 23872 { 23873 __failure = 418; 23874 if (!PyErr_Occurred()) { 23875 PyErr_SetString(PyExc_RuntimeError, 23876 "Unexpected error in an Op's C code. " 23877 "No Python exception was set."); 23878 } 23879 goto __label_418;} 23880 } 23881 // This is a TypeError to be consistent with DEBUG_MODE 23882 // Note: DEBUG_MODE also tells the name of the container 23883 if (PyArray_TYPE((PyArrayObject*) py_V417) != NPY_FLOAT64) { 23884 PyErr_Format(PyExc_TypeError, 23885 "expected type_num %d (NPY_FLOAT64) got %d", 23886 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V417)); 23887 { 23888 __failure = 418; 23889 if (!PyErr_Occurred()) { 23890 PyErr_SetString(PyExc_RuntimeError, 23891 "Unexpected error in an Op's C code. " 23892 "No Python exception was set."); 23893 } 23894 goto __label_418;} 23895 } 23896 23897 V417 = (PyArrayObject*)(py_V417); 23898 Py_XINCREF(V417); 23899 23900 { 23901 23902 py_V419 = PyList_GET_ITEM(storage_V419, 0); 23903 {Py_XINCREF(py_V419);} 23904 23905 V419 = NULL; 23906 if (py_V419 == Py_None) { 23907 // We can either fail here or set V419 to NULL and rely on Ops 23908 // using tensors to handle the NULL case, but if they fail to do so 23909 // they'll end up with nasty segfaults, so this is public service. 23910 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 23911 { 23912 __failure = 420; 23913 if (!PyErr_Occurred()) { 23914 PyErr_SetString(PyExc_RuntimeError, 23915 "Unexpected error in an Op's C code. " 23916 "No Python exception was set."); 23917 } 23918 goto __label_420;} 23919 } 23920 if (!PyArray_Check(py_V419)) { 23921 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 23922 { 23923 __failure = 420; 23924 if (!PyErr_Occurred()) { 23925 PyErr_SetString(PyExc_RuntimeError, 23926 "Unexpected error in an Op's C code. " 23927 "No Python exception was set."); 23928 } 23929 goto __label_420;} 23930 } 23931 // We expect NPY_FLOAT64 23932 if (!PyArray_ISALIGNED((PyArrayObject*) py_V419)) { 23933 PyArrayObject * tmp = (PyArrayObject*) py_V419; 23934 PyErr_Format(PyExc_NotImplementedError, 23935 "expected an aligned array of type %ld " 23936 "(NPY_FLOAT64), got non-aligned array of type %ld" 23937 " with %ld dimensions, with 3 last dims " 23938 "%ld, %ld, %ld" 23939 " and 3 last strides %ld %ld, %ld.", 23940 (long int) NPY_FLOAT64, 23941 (long int) PyArray_TYPE((PyArrayObject*) py_V419), 23942 (long int) PyArray_NDIM(tmp), 23943 (long int) (PyArray_NDIM(tmp) >= 3 ? 23944 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 23945 (long int) (PyArray_NDIM(tmp) >= 2 ? 23946 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 23947 (long int) (PyArray_NDIM(tmp) >= 1 ? 23948 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 23949 (long int) (PyArray_NDIM(tmp) >= 3 ? 23950 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 23951 (long int) (PyArray_NDIM(tmp) >= 2 ? 23952 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 23953 (long int) (PyArray_NDIM(tmp) >= 1 ? 23954 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 23955 ); 23956 { 23957 __failure = 420; 23958 if (!PyErr_Occurred()) { 23959 PyErr_SetString(PyExc_RuntimeError, 23960 "Unexpected error in an Op's C code. " 23961 "No Python exception was set."); 23962 } 23963 goto __label_420;} 23964 } 23965 // This is a TypeError to be consistent with DEBUG_MODE 23966 // Note: DEBUG_MODE also tells the name of the container 23967 if (PyArray_TYPE((PyArrayObject*) py_V419) != NPY_FLOAT64) { 23968 PyErr_Format(PyExc_TypeError, 23969 "expected type_num %d (NPY_FLOAT64) got %d", 23970 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V419)); 23971 { 23972 __failure = 420; 23973 if (!PyErr_Occurred()) { 23974 PyErr_SetString(PyExc_RuntimeError, 23975 "Unexpected error in an Op's C code. " 23976 "No Python exception was set."); 23977 } 23978 goto __label_420;} 23979 } 23980 23981 V419 = (PyArrayObject*)(py_V419); 23982 Py_XINCREF(V419); 23983 23984 { 23985 23986 py_V421 = PyList_GET_ITEM(storage_V421, 0); 23987 {Py_XINCREF(py_V421);} 23988 23989 V421 = NULL; 23990 if (py_V421 == Py_None) { 23991 // We can either fail here or set V421 to NULL and rely on Ops 23992 // using tensors to handle the NULL case, but if they fail to do so 23993 // they'll end up with nasty segfaults, so this is public service. 23994 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 23995 { 23996 __failure = 422; 23997 if (!PyErr_Occurred()) { 23998 PyErr_SetString(PyExc_RuntimeError, 23999 "Unexpected error in an Op's C code. " 24000 "No Python exception was set."); 24001 } 24002 goto __label_422;} 24003 } 24004 if (!PyArray_Check(py_V421)) { 24005 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 24006 { 24007 __failure = 422; 24008 if (!PyErr_Occurred()) { 24009 PyErr_SetString(PyExc_RuntimeError, 24010 "Unexpected error in an Op's C code. " 24011 "No Python exception was set."); 24012 } 24013 goto __label_422;} 24014 } 24015 // We expect NPY_FLOAT64 24016 if (!PyArray_ISALIGNED((PyArrayObject*) py_V421)) { 24017 PyArrayObject * tmp = (PyArrayObject*) py_V421; 24018 PyErr_Format(PyExc_NotImplementedError, 24019 "expected an aligned array of type %ld " 24020 "(NPY_FLOAT64), got non-aligned array of type %ld" 24021 " with %ld dimensions, with 3 last dims " 24022 "%ld, %ld, %ld" 24023 " and 3 last strides %ld %ld, %ld.", 24024 (long int) NPY_FLOAT64, 24025 (long int) PyArray_TYPE((PyArrayObject*) py_V421), 24026 (long int) PyArray_NDIM(tmp), 24027 (long int) (PyArray_NDIM(tmp) >= 3 ? 24028 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 24029 (long int) (PyArray_NDIM(tmp) >= 2 ? 24030 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 24031 (long int) (PyArray_NDIM(tmp) >= 1 ? 24032 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 24033 (long int) (PyArray_NDIM(tmp) >= 3 ? 24034 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 24035 (long int) (PyArray_NDIM(tmp) >= 2 ? 24036 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 24037 (long int) (PyArray_NDIM(tmp) >= 1 ? 24038 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 24039 ); 24040 { 24041 __failure = 422; 24042 if (!PyErr_Occurred()) { 24043 PyErr_SetString(PyExc_RuntimeError, 24044 "Unexpected error in an Op's C code. " 24045 "No Python exception was set."); 24046 } 24047 goto __label_422;} 24048 } 24049 // This is a TypeError to be consistent with DEBUG_MODE 24050 // Note: DEBUG_MODE also tells the name of the container 24051 if (PyArray_TYPE((PyArrayObject*) py_V421) != NPY_FLOAT64) { 24052 PyErr_Format(PyExc_TypeError, 24053 "expected type_num %d (NPY_FLOAT64) got %d", 24054 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V421)); 24055 { 24056 __failure = 422; 24057 if (!PyErr_Occurred()) { 24058 PyErr_SetString(PyExc_RuntimeError, 24059 "Unexpected error in an Op's C code. " 24060 "No Python exception was set."); 24061 } 24062 goto __label_422;} 24063 } 24064 24065 V421 = (PyArrayObject*)(py_V421); 24066 Py_XINCREF(V421); 24067 24068 { 24069 24070 py_V423 = PyList_GET_ITEM(storage_V423, 0); 24071 {Py_XINCREF(py_V423);} 24072 24073 V423 = NULL; 24074 if (py_V423 == Py_None) { 24075 // We can either fail here or set V423 to NULL and rely on Ops 24076 // using tensors to handle the NULL case, but if they fail to do so 24077 // they'll end up with nasty segfaults, so this is public service. 24078 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 24079 { 24080 __failure = 424; 24081 if (!PyErr_Occurred()) { 24082 PyErr_SetString(PyExc_RuntimeError, 24083 "Unexpected error in an Op's C code. " 24084 "No Python exception was set."); 24085 } 24086 goto __label_424;} 24087 } 24088 if (!PyArray_Check(py_V423)) { 24089 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 24090 { 24091 __failure = 424; 24092 if (!PyErr_Occurred()) { 24093 PyErr_SetString(PyExc_RuntimeError, 24094 "Unexpected error in an Op's C code. " 24095 "No Python exception was set."); 24096 } 24097 goto __label_424;} 24098 } 24099 // We expect NPY_FLOAT64 24100 if (!PyArray_ISALIGNED((PyArrayObject*) py_V423)) { 24101 PyArrayObject * tmp = (PyArrayObject*) py_V423; 24102 PyErr_Format(PyExc_NotImplementedError, 24103 "expected an aligned array of type %ld " 24104 "(NPY_FLOAT64), got non-aligned array of type %ld" 24105 " with %ld dimensions, with 3 last dims " 24106 "%ld, %ld, %ld" 24107 " and 3 last strides %ld %ld, %ld.", 24108 (long int) NPY_FLOAT64, 24109 (long int) PyArray_TYPE((PyArrayObject*) py_V423), 24110 (long int) PyArray_NDIM(tmp), 24111 (long int) (PyArray_NDIM(tmp) >= 3 ? 24112 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 24113 (long int) (PyArray_NDIM(tmp) >= 2 ? 24114 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 24115 (long int) (PyArray_NDIM(tmp) >= 1 ? 24116 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 24117 (long int) (PyArray_NDIM(tmp) >= 3 ? 24118 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 24119 (long int) (PyArray_NDIM(tmp) >= 2 ? 24120 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 24121 (long int) (PyArray_NDIM(tmp) >= 1 ? 24122 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 24123 ); 24124 { 24125 __failure = 424; 24126 if (!PyErr_Occurred()) { 24127 PyErr_SetString(PyExc_RuntimeError, 24128 "Unexpected error in an Op's C code. " 24129 "No Python exception was set."); 24130 } 24131 goto __label_424;} 24132 } 24133 // This is a TypeError to be consistent with DEBUG_MODE 24134 // Note: DEBUG_MODE also tells the name of the container 24135 if (PyArray_TYPE((PyArrayObject*) py_V423) != NPY_FLOAT64) { 24136 PyErr_Format(PyExc_TypeError, 24137 "expected type_num %d (NPY_FLOAT64) got %d", 24138 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V423)); 24139 { 24140 __failure = 424; 24141 if (!PyErr_Occurred()) { 24142 PyErr_SetString(PyExc_RuntimeError, 24143 "Unexpected error in an Op's C code. " 24144 "No Python exception was set."); 24145 } 24146 goto __label_424;} 24147 } 24148 24149 V423 = (PyArrayObject*)(py_V423); 24150 Py_XINCREF(V423); 24151 24152 { 24153 24154 py_V425 = PyList_GET_ITEM(storage_V425, 0); 24155 {Py_XINCREF(py_V425);} 24156 24157 V425 = NULL; 24158 if (py_V425 == Py_None) { 24159 // We can either fail here or set V425 to NULL and rely on Ops 24160 // using tensors to handle the NULL case, but if they fail to do so 24161 // they'll end up with nasty segfaults, so this is public service. 24162 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 24163 { 24164 __failure = 426; 24165 if (!PyErr_Occurred()) { 24166 PyErr_SetString(PyExc_RuntimeError, 24167 "Unexpected error in an Op's C code. " 24168 "No Python exception was set."); 24169 } 24170 goto __label_426;} 24171 } 24172 if (!PyArray_Check(py_V425)) { 24173 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 24174 { 24175 __failure = 426; 24176 if (!PyErr_Occurred()) { 24177 PyErr_SetString(PyExc_RuntimeError, 24178 "Unexpected error in an Op's C code. " 24179 "No Python exception was set."); 24180 } 24181 goto __label_426;} 24182 } 24183 // We expect NPY_FLOAT64 24184 if (!PyArray_ISALIGNED((PyArrayObject*) py_V425)) { 24185 PyArrayObject * tmp = (PyArrayObject*) py_V425; 24186 PyErr_Format(PyExc_NotImplementedError, 24187 "expected an aligned array of type %ld " 24188 "(NPY_FLOAT64), got non-aligned array of type %ld" 24189 " with %ld dimensions, with 3 last dims " 24190 "%ld, %ld, %ld" 24191 " and 3 last strides %ld %ld, %ld.", 24192 (long int) NPY_FLOAT64, 24193 (long int) PyArray_TYPE((PyArrayObject*) py_V425), 24194 (long int) PyArray_NDIM(tmp), 24195 (long int) (PyArray_NDIM(tmp) >= 3 ? 24196 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 24197 (long int) (PyArray_NDIM(tmp) >= 2 ? 24198 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 24199 (long int) (PyArray_NDIM(tmp) >= 1 ? 24200 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 24201 (long int) (PyArray_NDIM(tmp) >= 3 ? 24202 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 24203 (long int) (PyArray_NDIM(tmp) >= 2 ? 24204 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 24205 (long int) (PyArray_NDIM(tmp) >= 1 ? 24206 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 24207 ); 24208 { 24209 __failure = 426; 24210 if (!PyErr_Occurred()) { 24211 PyErr_SetString(PyExc_RuntimeError, 24212 "Unexpected error in an Op's C code. " 24213 "No Python exception was set."); 24214 } 24215 goto __label_426;} 24216 } 24217 // This is a TypeError to be consistent with DEBUG_MODE 24218 // Note: DEBUG_MODE also tells the name of the container 24219 if (PyArray_TYPE((PyArrayObject*) py_V425) != NPY_FLOAT64) { 24220 PyErr_Format(PyExc_TypeError, 24221 "expected type_num %d (NPY_FLOAT64) got %d", 24222 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V425)); 24223 { 24224 __failure = 426; 24225 if (!PyErr_Occurred()) { 24226 PyErr_SetString(PyExc_RuntimeError, 24227 "Unexpected error in an Op's C code. " 24228 "No Python exception was set."); 24229 } 24230 goto __label_426;} 24231 } 24232 24233 V425 = (PyArrayObject*)(py_V425); 24234 Py_XINCREF(V425); 24235 24236 { 24237 24238 py_V427 = PyList_GET_ITEM(storage_V427, 0); 24239 {Py_XINCREF(py_V427);} 24240 24241 V427 = NULL; 24242 if (py_V427 == Py_None) { 24243 // We can either fail here or set V427 to NULL and rely on Ops 24244 // using tensors to handle the NULL case, but if they fail to do so 24245 // they'll end up with nasty segfaults, so this is public service. 24246 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 24247 { 24248 __failure = 428; 24249 if (!PyErr_Occurred()) { 24250 PyErr_SetString(PyExc_RuntimeError, 24251 "Unexpected error in an Op's C code. " 24252 "No Python exception was set."); 24253 } 24254 goto __label_428;} 24255 } 24256 if (!PyArray_Check(py_V427)) { 24257 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 24258 { 24259 __failure = 428; 24260 if (!PyErr_Occurred()) { 24261 PyErr_SetString(PyExc_RuntimeError, 24262 "Unexpected error in an Op's C code. " 24263 "No Python exception was set."); 24264 } 24265 goto __label_428;} 24266 } 24267 // We expect NPY_FLOAT64 24268 if (!PyArray_ISALIGNED((PyArrayObject*) py_V427)) { 24269 PyArrayObject * tmp = (PyArrayObject*) py_V427; 24270 PyErr_Format(PyExc_NotImplementedError, 24271 "expected an aligned array of type %ld " 24272 "(NPY_FLOAT64), got non-aligned array of type %ld" 24273 " with %ld dimensions, with 3 last dims " 24274 "%ld, %ld, %ld" 24275 " and 3 last strides %ld %ld, %ld.", 24276 (long int) NPY_FLOAT64, 24277 (long int) PyArray_TYPE((PyArrayObject*) py_V427), 24278 (long int) PyArray_NDIM(tmp), 24279 (long int) (PyArray_NDIM(tmp) >= 3 ? 24280 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 24281 (long int) (PyArray_NDIM(tmp) >= 2 ? 24282 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 24283 (long int) (PyArray_NDIM(tmp) >= 1 ? 24284 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 24285 (long int) (PyArray_NDIM(tmp) >= 3 ? 24286 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 24287 (long int) (PyArray_NDIM(tmp) >= 2 ? 24288 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 24289 (long int) (PyArray_NDIM(tmp) >= 1 ? 24290 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 24291 ); 24292 { 24293 __failure = 428; 24294 if (!PyErr_Occurred()) { 24295 PyErr_SetString(PyExc_RuntimeError, 24296 "Unexpected error in an Op's C code. " 24297 "No Python exception was set."); 24298 } 24299 goto __label_428;} 24300 } 24301 // This is a TypeError to be consistent with DEBUG_MODE 24302 // Note: DEBUG_MODE also tells the name of the container 24303 if (PyArray_TYPE((PyArrayObject*) py_V427) != NPY_FLOAT64) { 24304 PyErr_Format(PyExc_TypeError, 24305 "expected type_num %d (NPY_FLOAT64) got %d", 24306 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V427)); 24307 { 24308 __failure = 428; 24309 if (!PyErr_Occurred()) { 24310 PyErr_SetString(PyExc_RuntimeError, 24311 "Unexpected error in an Op's C code. " 24312 "No Python exception was set."); 24313 } 24314 goto __label_428;} 24315 } 24316 24317 V427 = (PyArrayObject*)(py_V427); 24318 Py_XINCREF(V427); 24319 24320 { 24321 24322 py_V429 = PyList_GET_ITEM(storage_V429, 0); 24323 {Py_XINCREF(py_V429);} 24324 24325 V429 = NULL; 24326 if (py_V429 == Py_None) { 24327 // We can either fail here or set V429 to NULL and rely on Ops 24328 // using tensors to handle the NULL case, but if they fail to do so 24329 // they'll end up with nasty segfaults, so this is public service. 24330 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 24331 { 24332 __failure = 430; 24333 if (!PyErr_Occurred()) { 24334 PyErr_SetString(PyExc_RuntimeError, 24335 "Unexpected error in an Op's C code. " 24336 "No Python exception was set."); 24337 } 24338 goto __label_430;} 24339 } 24340 if (!PyArray_Check(py_V429)) { 24341 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 24342 { 24343 __failure = 430; 24344 if (!PyErr_Occurred()) { 24345 PyErr_SetString(PyExc_RuntimeError, 24346 "Unexpected error in an Op's C code. " 24347 "No Python exception was set."); 24348 } 24349 goto __label_430;} 24350 } 24351 // We expect NPY_FLOAT64 24352 if (!PyArray_ISALIGNED((PyArrayObject*) py_V429)) { 24353 PyArrayObject * tmp = (PyArrayObject*) py_V429; 24354 PyErr_Format(PyExc_NotImplementedError, 24355 "expected an aligned array of type %ld " 24356 "(NPY_FLOAT64), got non-aligned array of type %ld" 24357 " with %ld dimensions, with 3 last dims " 24358 "%ld, %ld, %ld" 24359 " and 3 last strides %ld %ld, %ld.", 24360 (long int) NPY_FLOAT64, 24361 (long int) PyArray_TYPE((PyArrayObject*) py_V429), 24362 (long int) PyArray_NDIM(tmp), 24363 (long int) (PyArray_NDIM(tmp) >= 3 ? 24364 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 24365 (long int) (PyArray_NDIM(tmp) >= 2 ? 24366 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 24367 (long int) (PyArray_NDIM(tmp) >= 1 ? 24368 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 24369 (long int) (PyArray_NDIM(tmp) >= 3 ? 24370 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 24371 (long int) (PyArray_NDIM(tmp) >= 2 ? 24372 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 24373 (long int) (PyArray_NDIM(tmp) >= 1 ? 24374 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 24375 ); 24376 { 24377 __failure = 430; 24378 if (!PyErr_Occurred()) { 24379 PyErr_SetString(PyExc_RuntimeError, 24380 "Unexpected error in an Op's C code. " 24381 "No Python exception was set."); 24382 } 24383 goto __label_430;} 24384 } 24385 // This is a TypeError to be consistent with DEBUG_MODE 24386 // Note: DEBUG_MODE also tells the name of the container 24387 if (PyArray_TYPE((PyArrayObject*) py_V429) != NPY_FLOAT64) { 24388 PyErr_Format(PyExc_TypeError, 24389 "expected type_num %d (NPY_FLOAT64) got %d", 24390 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V429)); 24391 { 24392 __failure = 430; 24393 if (!PyErr_Occurred()) { 24394 PyErr_SetString(PyExc_RuntimeError, 24395 "Unexpected error in an Op's C code. " 24396 "No Python exception was set."); 24397 } 24398 goto __label_430;} 24399 } 24400 24401 V429 = (PyArrayObject*)(py_V429); 24402 Py_XINCREF(V429); 24403 24404 { 24405 24406 py_V431 = PyList_GET_ITEM(storage_V431, 0); 24407 {Py_XINCREF(py_V431);} 24408 24409 V431 = NULL; 24410 if (py_V431 == Py_None) { 24411 // We can either fail here or set V431 to NULL and rely on Ops 24412 // using tensors to handle the NULL case, but if they fail to do so 24413 // they'll end up with nasty segfaults, so this is public service. 24414 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 24415 { 24416 __failure = 432; 24417 if (!PyErr_Occurred()) { 24418 PyErr_SetString(PyExc_RuntimeError, 24419 "Unexpected error in an Op's C code. " 24420 "No Python exception was set."); 24421 } 24422 goto __label_432;} 24423 } 24424 if (!PyArray_Check(py_V431)) { 24425 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 24426 { 24427 __failure = 432; 24428 if (!PyErr_Occurred()) { 24429 PyErr_SetString(PyExc_RuntimeError, 24430 "Unexpected error in an Op's C code. " 24431 "No Python exception was set."); 24432 } 24433 goto __label_432;} 24434 } 24435 // We expect NPY_FLOAT64 24436 if (!PyArray_ISALIGNED((PyArrayObject*) py_V431)) { 24437 PyArrayObject * tmp = (PyArrayObject*) py_V431; 24438 PyErr_Format(PyExc_NotImplementedError, 24439 "expected an aligned array of type %ld " 24440 "(NPY_FLOAT64), got non-aligned array of type %ld" 24441 " with %ld dimensions, with 3 last dims " 24442 "%ld, %ld, %ld" 24443 " and 3 last strides %ld %ld, %ld.", 24444 (long int) NPY_FLOAT64, 24445 (long int) PyArray_TYPE((PyArrayObject*) py_V431), 24446 (long int) PyArray_NDIM(tmp), 24447 (long int) (PyArray_NDIM(tmp) >= 3 ? 24448 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 24449 (long int) (PyArray_NDIM(tmp) >= 2 ? 24450 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 24451 (long int) (PyArray_NDIM(tmp) >= 1 ? 24452 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 24453 (long int) (PyArray_NDIM(tmp) >= 3 ? 24454 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 24455 (long int) (PyArray_NDIM(tmp) >= 2 ? 24456 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 24457 (long int) (PyArray_NDIM(tmp) >= 1 ? 24458 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 24459 ); 24460 { 24461 __failure = 432; 24462 if (!PyErr_Occurred()) { 24463 PyErr_SetString(PyExc_RuntimeError, 24464 "Unexpected error in an Op's C code. " 24465 "No Python exception was set."); 24466 } 24467 goto __label_432;} 24468 } 24469 // This is a TypeError to be consistent with DEBUG_MODE 24470 // Note: DEBUG_MODE also tells the name of the container 24471 if (PyArray_TYPE((PyArrayObject*) py_V431) != NPY_FLOAT64) { 24472 PyErr_Format(PyExc_TypeError, 24473 "expected type_num %d (NPY_FLOAT64) got %d", 24474 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V431)); 24475 { 24476 __failure = 432; 24477 if (!PyErr_Occurred()) { 24478 PyErr_SetString(PyExc_RuntimeError, 24479 "Unexpected error in an Op's C code. " 24480 "No Python exception was set."); 24481 } 24482 goto __label_432;} 24483 } 24484 24485 V431 = (PyArrayObject*)(py_V431); 24486 Py_XINCREF(V431); 24487 24488 { 24489 24490 py_V433 = PyList_GET_ITEM(storage_V433, 0); 24491 {Py_XINCREF(py_V433);} 24492 24493 V433 = NULL; 24494 if (py_V433 == Py_None) { 24495 // We can either fail here or set V433 to NULL and rely on Ops 24496 // using tensors to handle the NULL case, but if they fail to do so 24497 // they'll end up with nasty segfaults, so this is public service. 24498 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 24499 { 24500 __failure = 434; 24501 if (!PyErr_Occurred()) { 24502 PyErr_SetString(PyExc_RuntimeError, 24503 "Unexpected error in an Op's C code. " 24504 "No Python exception was set."); 24505 } 24506 goto __label_434;} 24507 } 24508 if (!PyArray_Check(py_V433)) { 24509 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 24510 { 24511 __failure = 434; 24512 if (!PyErr_Occurred()) { 24513 PyErr_SetString(PyExc_RuntimeError, 24514 "Unexpected error in an Op's C code. " 24515 "No Python exception was set."); 24516 } 24517 goto __label_434;} 24518 } 24519 // We expect NPY_FLOAT64 24520 if (!PyArray_ISALIGNED((PyArrayObject*) py_V433)) { 24521 PyArrayObject * tmp = (PyArrayObject*) py_V433; 24522 PyErr_Format(PyExc_NotImplementedError, 24523 "expected an aligned array of type %ld " 24524 "(NPY_FLOAT64), got non-aligned array of type %ld" 24525 " with %ld dimensions, with 3 last dims " 24526 "%ld, %ld, %ld" 24527 " and 3 last strides %ld %ld, %ld.", 24528 (long int) NPY_FLOAT64, 24529 (long int) PyArray_TYPE((PyArrayObject*) py_V433), 24530 (long int) PyArray_NDIM(tmp), 24531 (long int) (PyArray_NDIM(tmp) >= 3 ? 24532 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 24533 (long int) (PyArray_NDIM(tmp) >= 2 ? 24534 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 24535 (long int) (PyArray_NDIM(tmp) >= 1 ? 24536 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 24537 (long int) (PyArray_NDIM(tmp) >= 3 ? 24538 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 24539 (long int) (PyArray_NDIM(tmp) >= 2 ? 24540 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 24541 (long int) (PyArray_NDIM(tmp) >= 1 ? 24542 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 24543 ); 24544 { 24545 __failure = 434; 24546 if (!PyErr_Occurred()) { 24547 PyErr_SetString(PyExc_RuntimeError, 24548 "Unexpected error in an Op's C code. " 24549 "No Python exception was set."); 24550 } 24551 goto __label_434;} 24552 } 24553 // This is a TypeError to be consistent with DEBUG_MODE 24554 // Note: DEBUG_MODE also tells the name of the container 24555 if (PyArray_TYPE((PyArrayObject*) py_V433) != NPY_FLOAT64) { 24556 PyErr_Format(PyExc_TypeError, 24557 "expected type_num %d (NPY_FLOAT64) got %d", 24558 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V433)); 24559 { 24560 __failure = 434; 24561 if (!PyErr_Occurred()) { 24562 PyErr_SetString(PyExc_RuntimeError, 24563 "Unexpected error in an Op's C code. " 24564 "No Python exception was set."); 24565 } 24566 goto __label_434;} 24567 } 24568 24569 V433 = (PyArrayObject*)(py_V433); 24570 Py_XINCREF(V433); 24571 24572 { 24573 24574 py_V435 = PyList_GET_ITEM(storage_V435, 0); 24575 {Py_XINCREF(py_V435);} 24576 24577 V435 = NULL; 24578 if (py_V435 == Py_None) { 24579 // We can either fail here or set V435 to NULL and rely on Ops 24580 // using tensors to handle the NULL case, but if they fail to do so 24581 // they'll end up with nasty segfaults, so this is public service. 24582 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 24583 { 24584 __failure = 436; 24585 if (!PyErr_Occurred()) { 24586 PyErr_SetString(PyExc_RuntimeError, 24587 "Unexpected error in an Op's C code. " 24588 "No Python exception was set."); 24589 } 24590 goto __label_436;} 24591 } 24592 if (!PyArray_Check(py_V435)) { 24593 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 24594 { 24595 __failure = 436; 24596 if (!PyErr_Occurred()) { 24597 PyErr_SetString(PyExc_RuntimeError, 24598 "Unexpected error in an Op's C code. " 24599 "No Python exception was set."); 24600 } 24601 goto __label_436;} 24602 } 24603 // We expect NPY_FLOAT64 24604 if (!PyArray_ISALIGNED((PyArrayObject*) py_V435)) { 24605 PyArrayObject * tmp = (PyArrayObject*) py_V435; 24606 PyErr_Format(PyExc_NotImplementedError, 24607 "expected an aligned array of type %ld " 24608 "(NPY_FLOAT64), got non-aligned array of type %ld" 24609 " with %ld dimensions, with 3 last dims " 24610 "%ld, %ld, %ld" 24611 " and 3 last strides %ld %ld, %ld.", 24612 (long int) NPY_FLOAT64, 24613 (long int) PyArray_TYPE((PyArrayObject*) py_V435), 24614 (long int) PyArray_NDIM(tmp), 24615 (long int) (PyArray_NDIM(tmp) >= 3 ? 24616 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 24617 (long int) (PyArray_NDIM(tmp) >= 2 ? 24618 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 24619 (long int) (PyArray_NDIM(tmp) >= 1 ? 24620 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 24621 (long int) (PyArray_NDIM(tmp) >= 3 ? 24622 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 24623 (long int) (PyArray_NDIM(tmp) >= 2 ? 24624 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 24625 (long int) (PyArray_NDIM(tmp) >= 1 ? 24626 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 24627 ); 24628 { 24629 __failure = 436; 24630 if (!PyErr_Occurred()) { 24631 PyErr_SetString(PyExc_RuntimeError, 24632 "Unexpected error in an Op's C code. " 24633 "No Python exception was set."); 24634 } 24635 goto __label_436;} 24636 } 24637 // This is a TypeError to be consistent with DEBUG_MODE 24638 // Note: DEBUG_MODE also tells the name of the container 24639 if (PyArray_TYPE((PyArrayObject*) py_V435) != NPY_FLOAT64) { 24640 PyErr_Format(PyExc_TypeError, 24641 "expected type_num %d (NPY_FLOAT64) got %d", 24642 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V435)); 24643 { 24644 __failure = 436; 24645 if (!PyErr_Occurred()) { 24646 PyErr_SetString(PyExc_RuntimeError, 24647 "Unexpected error in an Op's C code. " 24648 "No Python exception was set."); 24649 } 24650 goto __label_436;} 24651 } 24652 24653 V435 = (PyArrayObject*)(py_V435); 24654 Py_XINCREF(V435); 24655 24656 { 24657 24658 py_V437 = PyList_GET_ITEM(storage_V437, 0); 24659 {Py_XINCREF(py_V437);} 24660 24661 V437 = NULL; 24662 if (py_V437 == Py_None) { 24663 // We can either fail here or set V437 to NULL and rely on Ops 24664 // using tensors to handle the NULL case, but if they fail to do so 24665 // they'll end up with nasty segfaults, so this is public service. 24666 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 24667 { 24668 __failure = 438; 24669 if (!PyErr_Occurred()) { 24670 PyErr_SetString(PyExc_RuntimeError, 24671 "Unexpected error in an Op's C code. " 24672 "No Python exception was set."); 24673 } 24674 goto __label_438;} 24675 } 24676 if (!PyArray_Check(py_V437)) { 24677 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 24678 { 24679 __failure = 438; 24680 if (!PyErr_Occurred()) { 24681 PyErr_SetString(PyExc_RuntimeError, 24682 "Unexpected error in an Op's C code. " 24683 "No Python exception was set."); 24684 } 24685 goto __label_438;} 24686 } 24687 // We expect NPY_FLOAT64 24688 if (!PyArray_ISALIGNED((PyArrayObject*) py_V437)) { 24689 PyArrayObject * tmp = (PyArrayObject*) py_V437; 24690 PyErr_Format(PyExc_NotImplementedError, 24691 "expected an aligned array of type %ld " 24692 "(NPY_FLOAT64), got non-aligned array of type %ld" 24693 " with %ld dimensions, with 3 last dims " 24694 "%ld, %ld, %ld" 24695 " and 3 last strides %ld %ld, %ld.", 24696 (long int) NPY_FLOAT64, 24697 (long int) PyArray_TYPE((PyArrayObject*) py_V437), 24698 (long int) PyArray_NDIM(tmp), 24699 (long int) (PyArray_NDIM(tmp) >= 3 ? 24700 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 24701 (long int) (PyArray_NDIM(tmp) >= 2 ? 24702 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 24703 (long int) (PyArray_NDIM(tmp) >= 1 ? 24704 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 24705 (long int) (PyArray_NDIM(tmp) >= 3 ? 24706 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 24707 (long int) (PyArray_NDIM(tmp) >= 2 ? 24708 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 24709 (long int) (PyArray_NDIM(tmp) >= 1 ? 24710 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 24711 ); 24712 { 24713 __failure = 438; 24714 if (!PyErr_Occurred()) { 24715 PyErr_SetString(PyExc_RuntimeError, 24716 "Unexpected error in an Op's C code. " 24717 "No Python exception was set."); 24718 } 24719 goto __label_438;} 24720 } 24721 // This is a TypeError to be consistent with DEBUG_MODE 24722 // Note: DEBUG_MODE also tells the name of the container 24723 if (PyArray_TYPE((PyArrayObject*) py_V437) != NPY_FLOAT64) { 24724 PyErr_Format(PyExc_TypeError, 24725 "expected type_num %d (NPY_FLOAT64) got %d", 24726 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V437)); 24727 { 24728 __failure = 438; 24729 if (!PyErr_Occurred()) { 24730 PyErr_SetString(PyExc_RuntimeError, 24731 "Unexpected error in an Op's C code. " 24732 "No Python exception was set."); 24733 } 24734 goto __label_438;} 24735 } 24736 24737 V437 = (PyArrayObject*)(py_V437); 24738 Py_XINCREF(V437); 24739 24740 { 24741 24742 py_V439 = PyList_GET_ITEM(storage_V439, 0); 24743 {Py_XINCREF(py_V439);} 24744 24745 V439 = NULL; 24746 if (py_V439 == Py_None) { 24747 // We can either fail here or set V439 to NULL and rely on Ops 24748 // using tensors to handle the NULL case, but if they fail to do so 24749 // they'll end up with nasty segfaults, so this is public service. 24750 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 24751 { 24752 __failure = 440; 24753 if (!PyErr_Occurred()) { 24754 PyErr_SetString(PyExc_RuntimeError, 24755 "Unexpected error in an Op's C code. " 24756 "No Python exception was set."); 24757 } 24758 goto __label_440;} 24759 } 24760 if (!PyArray_Check(py_V439)) { 24761 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 24762 { 24763 __failure = 440; 24764 if (!PyErr_Occurred()) { 24765 PyErr_SetString(PyExc_RuntimeError, 24766 "Unexpected error in an Op's C code. " 24767 "No Python exception was set."); 24768 } 24769 goto __label_440;} 24770 } 24771 // We expect NPY_FLOAT64 24772 if (!PyArray_ISALIGNED((PyArrayObject*) py_V439)) { 24773 PyArrayObject * tmp = (PyArrayObject*) py_V439; 24774 PyErr_Format(PyExc_NotImplementedError, 24775 "expected an aligned array of type %ld " 24776 "(NPY_FLOAT64), got non-aligned array of type %ld" 24777 " with %ld dimensions, with 3 last dims " 24778 "%ld, %ld, %ld" 24779 " and 3 last strides %ld %ld, %ld.", 24780 (long int) NPY_FLOAT64, 24781 (long int) PyArray_TYPE((PyArrayObject*) py_V439), 24782 (long int) PyArray_NDIM(tmp), 24783 (long int) (PyArray_NDIM(tmp) >= 3 ? 24784 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 24785 (long int) (PyArray_NDIM(tmp) >= 2 ? 24786 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 24787 (long int) (PyArray_NDIM(tmp) >= 1 ? 24788 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 24789 (long int) (PyArray_NDIM(tmp) >= 3 ? 24790 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 24791 (long int) (PyArray_NDIM(tmp) >= 2 ? 24792 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 24793 (long int) (PyArray_NDIM(tmp) >= 1 ? 24794 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 24795 ); 24796 { 24797 __failure = 440; 24798 if (!PyErr_Occurred()) { 24799 PyErr_SetString(PyExc_RuntimeError, 24800 "Unexpected error in an Op's C code. " 24801 "No Python exception was set."); 24802 } 24803 goto __label_440;} 24804 } 24805 // This is a TypeError to be consistent with DEBUG_MODE 24806 // Note: DEBUG_MODE also tells the name of the container 24807 if (PyArray_TYPE((PyArrayObject*) py_V439) != NPY_FLOAT64) { 24808 PyErr_Format(PyExc_TypeError, 24809 "expected type_num %d (NPY_FLOAT64) got %d", 24810 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V439)); 24811 { 24812 __failure = 440; 24813 if (!PyErr_Occurred()) { 24814 PyErr_SetString(PyExc_RuntimeError, 24815 "Unexpected error in an Op's C code. " 24816 "No Python exception was set."); 24817 } 24818 goto __label_440;} 24819 } 24820 24821 V439 = (PyArrayObject*)(py_V439); 24822 Py_XINCREF(V439); 24823 24824 { 24825 24826 py_V441 = PyList_GET_ITEM(storage_V441, 0); 24827 {Py_XINCREF(py_V441);} 24828 24829 V441 = NULL; 24830 if (py_V441 == Py_None) { 24831 // We can either fail here or set V441 to NULL and rely on Ops 24832 // using tensors to handle the NULL case, but if they fail to do so 24833 // they'll end up with nasty segfaults, so this is public service. 24834 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 24835 { 24836 __failure = 442; 24837 if (!PyErr_Occurred()) { 24838 PyErr_SetString(PyExc_RuntimeError, 24839 "Unexpected error in an Op's C code. " 24840 "No Python exception was set."); 24841 } 24842 goto __label_442;} 24843 } 24844 if (!PyArray_Check(py_V441)) { 24845 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 24846 { 24847 __failure = 442; 24848 if (!PyErr_Occurred()) { 24849 PyErr_SetString(PyExc_RuntimeError, 24850 "Unexpected error in an Op's C code. " 24851 "No Python exception was set."); 24852 } 24853 goto __label_442;} 24854 } 24855 // We expect NPY_FLOAT64 24856 if (!PyArray_ISALIGNED((PyArrayObject*) py_V441)) { 24857 PyArrayObject * tmp = (PyArrayObject*) py_V441; 24858 PyErr_Format(PyExc_NotImplementedError, 24859 "expected an aligned array of type %ld " 24860 "(NPY_FLOAT64), got non-aligned array of type %ld" 24861 " with %ld dimensions, with 3 last dims " 24862 "%ld, %ld, %ld" 24863 " and 3 last strides %ld %ld, %ld.", 24864 (long int) NPY_FLOAT64, 24865 (long int) PyArray_TYPE((PyArrayObject*) py_V441), 24866 (long int) PyArray_NDIM(tmp), 24867 (long int) (PyArray_NDIM(tmp) >= 3 ? 24868 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 24869 (long int) (PyArray_NDIM(tmp) >= 2 ? 24870 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 24871 (long int) (PyArray_NDIM(tmp) >= 1 ? 24872 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 24873 (long int) (PyArray_NDIM(tmp) >= 3 ? 24874 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 24875 (long int) (PyArray_NDIM(tmp) >= 2 ? 24876 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 24877 (long int) (PyArray_NDIM(tmp) >= 1 ? 24878 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 24879 ); 24880 { 24881 __failure = 442; 24882 if (!PyErr_Occurred()) { 24883 PyErr_SetString(PyExc_RuntimeError, 24884 "Unexpected error in an Op's C code. " 24885 "No Python exception was set."); 24886 } 24887 goto __label_442;} 24888 } 24889 // This is a TypeError to be consistent with DEBUG_MODE 24890 // Note: DEBUG_MODE also tells the name of the container 24891 if (PyArray_TYPE((PyArrayObject*) py_V441) != NPY_FLOAT64) { 24892 PyErr_Format(PyExc_TypeError, 24893 "expected type_num %d (NPY_FLOAT64) got %d", 24894 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V441)); 24895 { 24896 __failure = 442; 24897 if (!PyErr_Occurred()) { 24898 PyErr_SetString(PyExc_RuntimeError, 24899 "Unexpected error in an Op's C code. " 24900 "No Python exception was set."); 24901 } 24902 goto __label_442;} 24903 } 24904 24905 V441 = (PyArrayObject*)(py_V441); 24906 Py_XINCREF(V441); 24907 24908 { 24909 24910 py_V443 = PyList_GET_ITEM(storage_V443, 0); 24911 {Py_XINCREF(py_V443);} 24912 24913 V443 = NULL; 24914 if (py_V443 == Py_None) { 24915 // We can either fail here or set V443 to NULL and rely on Ops 24916 // using tensors to handle the NULL case, but if they fail to do so 24917 // they'll end up with nasty segfaults, so this is public service. 24918 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 24919 { 24920 __failure = 444; 24921 if (!PyErr_Occurred()) { 24922 PyErr_SetString(PyExc_RuntimeError, 24923 "Unexpected error in an Op's C code. " 24924 "No Python exception was set."); 24925 } 24926 goto __label_444;} 24927 } 24928 if (!PyArray_Check(py_V443)) { 24929 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 24930 { 24931 __failure = 444; 24932 if (!PyErr_Occurred()) { 24933 PyErr_SetString(PyExc_RuntimeError, 24934 "Unexpected error in an Op's C code. " 24935 "No Python exception was set."); 24936 } 24937 goto __label_444;} 24938 } 24939 // We expect NPY_FLOAT64 24940 if (!PyArray_ISALIGNED((PyArrayObject*) py_V443)) { 24941 PyArrayObject * tmp = (PyArrayObject*) py_V443; 24942 PyErr_Format(PyExc_NotImplementedError, 24943 "expected an aligned array of type %ld " 24944 "(NPY_FLOAT64), got non-aligned array of type %ld" 24945 " with %ld dimensions, with 3 last dims " 24946 "%ld, %ld, %ld" 24947 " and 3 last strides %ld %ld, %ld.", 24948 (long int) NPY_FLOAT64, 24949 (long int) PyArray_TYPE((PyArrayObject*) py_V443), 24950 (long int) PyArray_NDIM(tmp), 24951 (long int) (PyArray_NDIM(tmp) >= 3 ? 24952 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 24953 (long int) (PyArray_NDIM(tmp) >= 2 ? 24954 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 24955 (long int) (PyArray_NDIM(tmp) >= 1 ? 24956 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 24957 (long int) (PyArray_NDIM(tmp) >= 3 ? 24958 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 24959 (long int) (PyArray_NDIM(tmp) >= 2 ? 24960 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 24961 (long int) (PyArray_NDIM(tmp) >= 1 ? 24962 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 24963 ); 24964 { 24965 __failure = 444; 24966 if (!PyErr_Occurred()) { 24967 PyErr_SetString(PyExc_RuntimeError, 24968 "Unexpected error in an Op's C code. " 24969 "No Python exception was set."); 24970 } 24971 goto __label_444;} 24972 } 24973 // This is a TypeError to be consistent with DEBUG_MODE 24974 // Note: DEBUG_MODE also tells the name of the container 24975 if (PyArray_TYPE((PyArrayObject*) py_V443) != NPY_FLOAT64) { 24976 PyErr_Format(PyExc_TypeError, 24977 "expected type_num %d (NPY_FLOAT64) got %d", 24978 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V443)); 24979 { 24980 __failure = 444; 24981 if (!PyErr_Occurred()) { 24982 PyErr_SetString(PyExc_RuntimeError, 24983 "Unexpected error in an Op's C code. " 24984 "No Python exception was set."); 24985 } 24986 goto __label_444;} 24987 } 24988 24989 V443 = (PyArrayObject*)(py_V443); 24990 Py_XINCREF(V443); 24991 24992 { 24993 24994 py_V445 = PyList_GET_ITEM(storage_V445, 0); 24995 {Py_XINCREF(py_V445);} 24996 24997 V445 = NULL; 24998 if (py_V445 == Py_None) { 24999 // We can either fail here or set V445 to NULL and rely on Ops 25000 // using tensors to handle the NULL case, but if they fail to do so 25001 // they'll end up with nasty segfaults, so this is public service. 25002 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 25003 { 25004 __failure = 446; 25005 if (!PyErr_Occurred()) { 25006 PyErr_SetString(PyExc_RuntimeError, 25007 "Unexpected error in an Op's C code. " 25008 "No Python exception was set."); 25009 } 25010 goto __label_446;} 25011 } 25012 if (!PyArray_Check(py_V445)) { 25013 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 25014 { 25015 __failure = 446; 25016 if (!PyErr_Occurred()) { 25017 PyErr_SetString(PyExc_RuntimeError, 25018 "Unexpected error in an Op's C code. " 25019 "No Python exception was set."); 25020 } 25021 goto __label_446;} 25022 } 25023 // We expect NPY_FLOAT64 25024 if (!PyArray_ISALIGNED((PyArrayObject*) py_V445)) { 25025 PyArrayObject * tmp = (PyArrayObject*) py_V445; 25026 PyErr_Format(PyExc_NotImplementedError, 25027 "expected an aligned array of type %ld " 25028 "(NPY_FLOAT64), got non-aligned array of type %ld" 25029 " with %ld dimensions, with 3 last dims " 25030 "%ld, %ld, %ld" 25031 " and 3 last strides %ld %ld, %ld.", 25032 (long int) NPY_FLOAT64, 25033 (long int) PyArray_TYPE((PyArrayObject*) py_V445), 25034 (long int) PyArray_NDIM(tmp), 25035 (long int) (PyArray_NDIM(tmp) >= 3 ? 25036 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 25037 (long int) (PyArray_NDIM(tmp) >= 2 ? 25038 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 25039 (long int) (PyArray_NDIM(tmp) >= 1 ? 25040 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 25041 (long int) (PyArray_NDIM(tmp) >= 3 ? 25042 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 25043 (long int) (PyArray_NDIM(tmp) >= 2 ? 25044 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 25045 (long int) (PyArray_NDIM(tmp) >= 1 ? 25046 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 25047 ); 25048 { 25049 __failure = 446; 25050 if (!PyErr_Occurred()) { 25051 PyErr_SetString(PyExc_RuntimeError, 25052 "Unexpected error in an Op's C code. " 25053 "No Python exception was set."); 25054 } 25055 goto __label_446;} 25056 } 25057 // This is a TypeError to be consistent with DEBUG_MODE 25058 // Note: DEBUG_MODE also tells the name of the container 25059 if (PyArray_TYPE((PyArrayObject*) py_V445) != NPY_FLOAT64) { 25060 PyErr_Format(PyExc_TypeError, 25061 "expected type_num %d (NPY_FLOAT64) got %d", 25062 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V445)); 25063 { 25064 __failure = 446; 25065 if (!PyErr_Occurred()) { 25066 PyErr_SetString(PyExc_RuntimeError, 25067 "Unexpected error in an Op's C code. " 25068 "No Python exception was set."); 25069 } 25070 goto __label_446;} 25071 } 25072 25073 V445 = (PyArrayObject*)(py_V445); 25074 Py_XINCREF(V445); 25075 25076 { 25077 25078 py_V447 = PyList_GET_ITEM(storage_V447, 0); 25079 {Py_XINCREF(py_V447);} 25080 25081 V447 = NULL; 25082 if (py_V447 == Py_None) { 25083 // We can either fail here or set V447 to NULL and rely on Ops 25084 // using tensors to handle the NULL case, but if they fail to do so 25085 // they'll end up with nasty segfaults, so this is public service. 25086 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 25087 { 25088 __failure = 448; 25089 if (!PyErr_Occurred()) { 25090 PyErr_SetString(PyExc_RuntimeError, 25091 "Unexpected error in an Op's C code. " 25092 "No Python exception was set."); 25093 } 25094 goto __label_448;} 25095 } 25096 if (!PyArray_Check(py_V447)) { 25097 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 25098 { 25099 __failure = 448; 25100 if (!PyErr_Occurred()) { 25101 PyErr_SetString(PyExc_RuntimeError, 25102 "Unexpected error in an Op's C code. " 25103 "No Python exception was set."); 25104 } 25105 goto __label_448;} 25106 } 25107 // We expect NPY_FLOAT64 25108 if (!PyArray_ISALIGNED((PyArrayObject*) py_V447)) { 25109 PyArrayObject * tmp = (PyArrayObject*) py_V447; 25110 PyErr_Format(PyExc_NotImplementedError, 25111 "expected an aligned array of type %ld " 25112 "(NPY_FLOAT64), got non-aligned array of type %ld" 25113 " with %ld dimensions, with 3 last dims " 25114 "%ld, %ld, %ld" 25115 " and 3 last strides %ld %ld, %ld.", 25116 (long int) NPY_FLOAT64, 25117 (long int) PyArray_TYPE((PyArrayObject*) py_V447), 25118 (long int) PyArray_NDIM(tmp), 25119 (long int) (PyArray_NDIM(tmp) >= 3 ? 25120 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 25121 (long int) (PyArray_NDIM(tmp) >= 2 ? 25122 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 25123 (long int) (PyArray_NDIM(tmp) >= 1 ? 25124 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 25125 (long int) (PyArray_NDIM(tmp) >= 3 ? 25126 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 25127 (long int) (PyArray_NDIM(tmp) >= 2 ? 25128 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 25129 (long int) (PyArray_NDIM(tmp) >= 1 ? 25130 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 25131 ); 25132 { 25133 __failure = 448; 25134 if (!PyErr_Occurred()) { 25135 PyErr_SetString(PyExc_RuntimeError, 25136 "Unexpected error in an Op's C code. " 25137 "No Python exception was set."); 25138 } 25139 goto __label_448;} 25140 } 25141 // This is a TypeError to be consistent with DEBUG_MODE 25142 // Note: DEBUG_MODE also tells the name of the container 25143 if (PyArray_TYPE((PyArrayObject*) py_V447) != NPY_FLOAT64) { 25144 PyErr_Format(PyExc_TypeError, 25145 "expected type_num %d (NPY_FLOAT64) got %d", 25146 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V447)); 25147 { 25148 __failure = 448; 25149 if (!PyErr_Occurred()) { 25150 PyErr_SetString(PyExc_RuntimeError, 25151 "Unexpected error in an Op's C code. " 25152 "No Python exception was set."); 25153 } 25154 goto __label_448;} 25155 } 25156 25157 V447 = (PyArrayObject*)(py_V447); 25158 Py_XINCREF(V447); 25159 25160 { 25161 25162 py_V449 = PyList_GET_ITEM(storage_V449, 0); 25163 {Py_XINCREF(py_V449);} 25164 25165 V449 = NULL; 25166 if (py_V449 == Py_None) { 25167 // We can either fail here or set V449 to NULL and rely on Ops 25168 // using tensors to handle the NULL case, but if they fail to do so 25169 // they'll end up with nasty segfaults, so this is public service. 25170 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 25171 { 25172 __failure = 450; 25173 if (!PyErr_Occurred()) { 25174 PyErr_SetString(PyExc_RuntimeError, 25175 "Unexpected error in an Op's C code. " 25176 "No Python exception was set."); 25177 } 25178 goto __label_450;} 25179 } 25180 if (!PyArray_Check(py_V449)) { 25181 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 25182 { 25183 __failure = 450; 25184 if (!PyErr_Occurred()) { 25185 PyErr_SetString(PyExc_RuntimeError, 25186 "Unexpected error in an Op's C code. " 25187 "No Python exception was set."); 25188 } 25189 goto __label_450;} 25190 } 25191 // We expect NPY_FLOAT64 25192 if (!PyArray_ISALIGNED((PyArrayObject*) py_V449)) { 25193 PyArrayObject * tmp = (PyArrayObject*) py_V449; 25194 PyErr_Format(PyExc_NotImplementedError, 25195 "expected an aligned array of type %ld " 25196 "(NPY_FLOAT64), got non-aligned array of type %ld" 25197 " with %ld dimensions, with 3 last dims " 25198 "%ld, %ld, %ld" 25199 " and 3 last strides %ld %ld, %ld.", 25200 (long int) NPY_FLOAT64, 25201 (long int) PyArray_TYPE((PyArrayObject*) py_V449), 25202 (long int) PyArray_NDIM(tmp), 25203 (long int) (PyArray_NDIM(tmp) >= 3 ? 25204 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 25205 (long int) (PyArray_NDIM(tmp) >= 2 ? 25206 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 25207 (long int) (PyArray_NDIM(tmp) >= 1 ? 25208 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 25209 (long int) (PyArray_NDIM(tmp) >= 3 ? 25210 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 25211 (long int) (PyArray_NDIM(tmp) >= 2 ? 25212 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 25213 (long int) (PyArray_NDIM(tmp) >= 1 ? 25214 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 25215 ); 25216 { 25217 __failure = 450; 25218 if (!PyErr_Occurred()) { 25219 PyErr_SetString(PyExc_RuntimeError, 25220 "Unexpected error in an Op's C code. " 25221 "No Python exception was set."); 25222 } 25223 goto __label_450;} 25224 } 25225 // This is a TypeError to be consistent with DEBUG_MODE 25226 // Note: DEBUG_MODE also tells the name of the container 25227 if (PyArray_TYPE((PyArrayObject*) py_V449) != NPY_FLOAT64) { 25228 PyErr_Format(PyExc_TypeError, 25229 "expected type_num %d (NPY_FLOAT64) got %d", 25230 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V449)); 25231 { 25232 __failure = 450; 25233 if (!PyErr_Occurred()) { 25234 PyErr_SetString(PyExc_RuntimeError, 25235 "Unexpected error in an Op's C code. " 25236 "No Python exception was set."); 25237 } 25238 goto __label_450;} 25239 } 25240 25241 V449 = (PyArrayObject*)(py_V449); 25242 Py_XINCREF(V449); 25243 25244 { 25245 25246 py_V451 = PyList_GET_ITEM(storage_V451, 0); 25247 {Py_XINCREF(py_V451);} 25248 25249 V451 = NULL; 25250 if (py_V451 == Py_None) { 25251 // We can either fail here or set V451 to NULL and rely on Ops 25252 // using tensors to handle the NULL case, but if they fail to do so 25253 // they'll end up with nasty segfaults, so this is public service. 25254 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 25255 { 25256 __failure = 452; 25257 if (!PyErr_Occurred()) { 25258 PyErr_SetString(PyExc_RuntimeError, 25259 "Unexpected error in an Op's C code. " 25260 "No Python exception was set."); 25261 } 25262 goto __label_452;} 25263 } 25264 if (!PyArray_Check(py_V451)) { 25265 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 25266 { 25267 __failure = 452; 25268 if (!PyErr_Occurred()) { 25269 PyErr_SetString(PyExc_RuntimeError, 25270 "Unexpected error in an Op's C code. " 25271 "No Python exception was set."); 25272 } 25273 goto __label_452;} 25274 } 25275 // We expect NPY_FLOAT64 25276 if (!PyArray_ISALIGNED((PyArrayObject*) py_V451)) { 25277 PyArrayObject * tmp = (PyArrayObject*) py_V451; 25278 PyErr_Format(PyExc_NotImplementedError, 25279 "expected an aligned array of type %ld " 25280 "(NPY_FLOAT64), got non-aligned array of type %ld" 25281 " with %ld dimensions, with 3 last dims " 25282 "%ld, %ld, %ld" 25283 " and 3 last strides %ld %ld, %ld.", 25284 (long int) NPY_FLOAT64, 25285 (long int) PyArray_TYPE((PyArrayObject*) py_V451), 25286 (long int) PyArray_NDIM(tmp), 25287 (long int) (PyArray_NDIM(tmp) >= 3 ? 25288 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 25289 (long int) (PyArray_NDIM(tmp) >= 2 ? 25290 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 25291 (long int) (PyArray_NDIM(tmp) >= 1 ? 25292 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 25293 (long int) (PyArray_NDIM(tmp) >= 3 ? 25294 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 25295 (long int) (PyArray_NDIM(tmp) >= 2 ? 25296 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 25297 (long int) (PyArray_NDIM(tmp) >= 1 ? 25298 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 25299 ); 25300 { 25301 __failure = 452; 25302 if (!PyErr_Occurred()) { 25303 PyErr_SetString(PyExc_RuntimeError, 25304 "Unexpected error in an Op's C code. " 25305 "No Python exception was set."); 25306 } 25307 goto __label_452;} 25308 } 25309 // This is a TypeError to be consistent with DEBUG_MODE 25310 // Note: DEBUG_MODE also tells the name of the container 25311 if (PyArray_TYPE((PyArrayObject*) py_V451) != NPY_FLOAT64) { 25312 PyErr_Format(PyExc_TypeError, 25313 "expected type_num %d (NPY_FLOAT64) got %d", 25314 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V451)); 25315 { 25316 __failure = 452; 25317 if (!PyErr_Occurred()) { 25318 PyErr_SetString(PyExc_RuntimeError, 25319 "Unexpected error in an Op's C code. " 25320 "No Python exception was set."); 25321 } 25322 goto __label_452;} 25323 } 25324 25325 V451 = (PyArrayObject*)(py_V451); 25326 Py_XINCREF(V451); 25327 25328 { 25329 25330 py_V453 = PyList_GET_ITEM(storage_V453, 0); 25331 {Py_XINCREF(py_V453);} 25332 25333 V453 = NULL; 25334 if (py_V453 == Py_None) { 25335 // We can either fail here or set V453 to NULL and rely on Ops 25336 // using tensors to handle the NULL case, but if they fail to do so 25337 // they'll end up with nasty segfaults, so this is public service. 25338 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 25339 { 25340 __failure = 454; 25341 if (!PyErr_Occurred()) { 25342 PyErr_SetString(PyExc_RuntimeError, 25343 "Unexpected error in an Op's C code. " 25344 "No Python exception was set."); 25345 } 25346 goto __label_454;} 25347 } 25348 if (!PyArray_Check(py_V453)) { 25349 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 25350 { 25351 __failure = 454; 25352 if (!PyErr_Occurred()) { 25353 PyErr_SetString(PyExc_RuntimeError, 25354 "Unexpected error in an Op's C code. " 25355 "No Python exception was set."); 25356 } 25357 goto __label_454;} 25358 } 25359 // We expect NPY_FLOAT64 25360 if (!PyArray_ISALIGNED((PyArrayObject*) py_V453)) { 25361 PyArrayObject * tmp = (PyArrayObject*) py_V453; 25362 PyErr_Format(PyExc_NotImplementedError, 25363 "expected an aligned array of type %ld " 25364 "(NPY_FLOAT64), got non-aligned array of type %ld" 25365 " with %ld dimensions, with 3 last dims " 25366 "%ld, %ld, %ld" 25367 " and 3 last strides %ld %ld, %ld.", 25368 (long int) NPY_FLOAT64, 25369 (long int) PyArray_TYPE((PyArrayObject*) py_V453), 25370 (long int) PyArray_NDIM(tmp), 25371 (long int) (PyArray_NDIM(tmp) >= 3 ? 25372 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 25373 (long int) (PyArray_NDIM(tmp) >= 2 ? 25374 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 25375 (long int) (PyArray_NDIM(tmp) >= 1 ? 25376 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 25377 (long int) (PyArray_NDIM(tmp) >= 3 ? 25378 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 25379 (long int) (PyArray_NDIM(tmp) >= 2 ? 25380 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 25381 (long int) (PyArray_NDIM(tmp) >= 1 ? 25382 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 25383 ); 25384 { 25385 __failure = 454; 25386 if (!PyErr_Occurred()) { 25387 PyErr_SetString(PyExc_RuntimeError, 25388 "Unexpected error in an Op's C code. " 25389 "No Python exception was set."); 25390 } 25391 goto __label_454;} 25392 } 25393 // This is a TypeError to be consistent with DEBUG_MODE 25394 // Note: DEBUG_MODE also tells the name of the container 25395 if (PyArray_TYPE((PyArrayObject*) py_V453) != NPY_FLOAT64) { 25396 PyErr_Format(PyExc_TypeError, 25397 "expected type_num %d (NPY_FLOAT64) got %d", 25398 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V453)); 25399 { 25400 __failure = 454; 25401 if (!PyErr_Occurred()) { 25402 PyErr_SetString(PyExc_RuntimeError, 25403 "Unexpected error in an Op's C code. " 25404 "No Python exception was set."); 25405 } 25406 goto __label_454;} 25407 } 25408 25409 V453 = (PyArrayObject*)(py_V453); 25410 Py_XINCREF(V453); 25411 25412 { 25413 25414 py_V455 = PyList_GET_ITEM(storage_V455, 0); 25415 {Py_XINCREF(py_V455);} 25416 25417 V455 = NULL; 25418 if (py_V455 == Py_None) { 25419 // We can either fail here or set V455 to NULL and rely on Ops 25420 // using tensors to handle the NULL case, but if they fail to do so 25421 // they'll end up with nasty segfaults, so this is public service. 25422 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 25423 { 25424 __failure = 456; 25425 if (!PyErr_Occurred()) { 25426 PyErr_SetString(PyExc_RuntimeError, 25427 "Unexpected error in an Op's C code. " 25428 "No Python exception was set."); 25429 } 25430 goto __label_456;} 25431 } 25432 if (!PyArray_Check(py_V455)) { 25433 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 25434 { 25435 __failure = 456; 25436 if (!PyErr_Occurred()) { 25437 PyErr_SetString(PyExc_RuntimeError, 25438 "Unexpected error in an Op's C code. " 25439 "No Python exception was set."); 25440 } 25441 goto __label_456;} 25442 } 25443 // We expect NPY_FLOAT64 25444 if (!PyArray_ISALIGNED((PyArrayObject*) py_V455)) { 25445 PyArrayObject * tmp = (PyArrayObject*) py_V455; 25446 PyErr_Format(PyExc_NotImplementedError, 25447 "expected an aligned array of type %ld " 25448 "(NPY_FLOAT64), got non-aligned array of type %ld" 25449 " with %ld dimensions, with 3 last dims " 25450 "%ld, %ld, %ld" 25451 " and 3 last strides %ld %ld, %ld.", 25452 (long int) NPY_FLOAT64, 25453 (long int) PyArray_TYPE((PyArrayObject*) py_V455), 25454 (long int) PyArray_NDIM(tmp), 25455 (long int) (PyArray_NDIM(tmp) >= 3 ? 25456 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 25457 (long int) (PyArray_NDIM(tmp) >= 2 ? 25458 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 25459 (long int) (PyArray_NDIM(tmp) >= 1 ? 25460 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 25461 (long int) (PyArray_NDIM(tmp) >= 3 ? 25462 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 25463 (long int) (PyArray_NDIM(tmp) >= 2 ? 25464 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 25465 (long int) (PyArray_NDIM(tmp) >= 1 ? 25466 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 25467 ); 25468 { 25469 __failure = 456; 25470 if (!PyErr_Occurred()) { 25471 PyErr_SetString(PyExc_RuntimeError, 25472 "Unexpected error in an Op's C code. " 25473 "No Python exception was set."); 25474 } 25475 goto __label_456;} 25476 } 25477 // This is a TypeError to be consistent with DEBUG_MODE 25478 // Note: DEBUG_MODE also tells the name of the container 25479 if (PyArray_TYPE((PyArrayObject*) py_V455) != NPY_FLOAT64) { 25480 PyErr_Format(PyExc_TypeError, 25481 "expected type_num %d (NPY_FLOAT64) got %d", 25482 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V455)); 25483 { 25484 __failure = 456; 25485 if (!PyErr_Occurred()) { 25486 PyErr_SetString(PyExc_RuntimeError, 25487 "Unexpected error in an Op's C code. " 25488 "No Python exception was set."); 25489 } 25490 goto __label_456;} 25491 } 25492 25493 V455 = (PyArrayObject*)(py_V455); 25494 Py_XINCREF(V455); 25495 25496 { 25497 25498 py_V457 = PyList_GET_ITEM(storage_V457, 0); 25499 {Py_XINCREF(py_V457);} 25500 25501 V457 = NULL; 25502 if (py_V457 == Py_None) { 25503 // We can either fail here or set V457 to NULL and rely on Ops 25504 // using tensors to handle the NULL case, but if they fail to do so 25505 // they'll end up with nasty segfaults, so this is public service. 25506 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 25507 { 25508 __failure = 458; 25509 if (!PyErr_Occurred()) { 25510 PyErr_SetString(PyExc_RuntimeError, 25511 "Unexpected error in an Op's C code. " 25512 "No Python exception was set."); 25513 } 25514 goto __label_458;} 25515 } 25516 if (!PyArray_Check(py_V457)) { 25517 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 25518 { 25519 __failure = 458; 25520 if (!PyErr_Occurred()) { 25521 PyErr_SetString(PyExc_RuntimeError, 25522 "Unexpected error in an Op's C code. " 25523 "No Python exception was set."); 25524 } 25525 goto __label_458;} 25526 } 25527 // We expect NPY_FLOAT64 25528 if (!PyArray_ISALIGNED((PyArrayObject*) py_V457)) { 25529 PyArrayObject * tmp = (PyArrayObject*) py_V457; 25530 PyErr_Format(PyExc_NotImplementedError, 25531 "expected an aligned array of type %ld " 25532 "(NPY_FLOAT64), got non-aligned array of type %ld" 25533 " with %ld dimensions, with 3 last dims " 25534 "%ld, %ld, %ld" 25535 " and 3 last strides %ld %ld, %ld.", 25536 (long int) NPY_FLOAT64, 25537 (long int) PyArray_TYPE((PyArrayObject*) py_V457), 25538 (long int) PyArray_NDIM(tmp), 25539 (long int) (PyArray_NDIM(tmp) >= 3 ? 25540 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 25541 (long int) (PyArray_NDIM(tmp) >= 2 ? 25542 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 25543 (long int) (PyArray_NDIM(tmp) >= 1 ? 25544 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 25545 (long int) (PyArray_NDIM(tmp) >= 3 ? 25546 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 25547 (long int) (PyArray_NDIM(tmp) >= 2 ? 25548 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 25549 (long int) (PyArray_NDIM(tmp) >= 1 ? 25550 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 25551 ); 25552 { 25553 __failure = 458; 25554 if (!PyErr_Occurred()) { 25555 PyErr_SetString(PyExc_RuntimeError, 25556 "Unexpected error in an Op's C code. " 25557 "No Python exception was set."); 25558 } 25559 goto __label_458;} 25560 } 25561 // This is a TypeError to be consistent with DEBUG_MODE 25562 // Note: DEBUG_MODE also tells the name of the container 25563 if (PyArray_TYPE((PyArrayObject*) py_V457) != NPY_FLOAT64) { 25564 PyErr_Format(PyExc_TypeError, 25565 "expected type_num %d (NPY_FLOAT64) got %d", 25566 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V457)); 25567 { 25568 __failure = 458; 25569 if (!PyErr_Occurred()) { 25570 PyErr_SetString(PyExc_RuntimeError, 25571 "Unexpected error in an Op's C code. " 25572 "No Python exception was set."); 25573 } 25574 goto __label_458;} 25575 } 25576 25577 V457 = (PyArrayObject*)(py_V457); 25578 Py_XINCREF(V457); 25579 25580 { 25581 25582 py_V459 = PyList_GET_ITEM(storage_V459, 0); 25583 {Py_XINCREF(py_V459);} 25584 25585 V459 = NULL; 25586 if (py_V459 == Py_None) { 25587 // We can either fail here or set V459 to NULL and rely on Ops 25588 // using tensors to handle the NULL case, but if they fail to do so 25589 // they'll end up with nasty segfaults, so this is public service. 25590 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 25591 { 25592 __failure = 460; 25593 if (!PyErr_Occurred()) { 25594 PyErr_SetString(PyExc_RuntimeError, 25595 "Unexpected error in an Op's C code. " 25596 "No Python exception was set."); 25597 } 25598 goto __label_460;} 25599 } 25600 if (!PyArray_Check(py_V459)) { 25601 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 25602 { 25603 __failure = 460; 25604 if (!PyErr_Occurred()) { 25605 PyErr_SetString(PyExc_RuntimeError, 25606 "Unexpected error in an Op's C code. " 25607 "No Python exception was set."); 25608 } 25609 goto __label_460;} 25610 } 25611 // We expect NPY_FLOAT64 25612 if (!PyArray_ISALIGNED((PyArrayObject*) py_V459)) { 25613 PyArrayObject * tmp = (PyArrayObject*) py_V459; 25614 PyErr_Format(PyExc_NotImplementedError, 25615 "expected an aligned array of type %ld " 25616 "(NPY_FLOAT64), got non-aligned array of type %ld" 25617 " with %ld dimensions, with 3 last dims " 25618 "%ld, %ld, %ld" 25619 " and 3 last strides %ld %ld, %ld.", 25620 (long int) NPY_FLOAT64, 25621 (long int) PyArray_TYPE((PyArrayObject*) py_V459), 25622 (long int) PyArray_NDIM(tmp), 25623 (long int) (PyArray_NDIM(tmp) >= 3 ? 25624 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 25625 (long int) (PyArray_NDIM(tmp) >= 2 ? 25626 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 25627 (long int) (PyArray_NDIM(tmp) >= 1 ? 25628 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 25629 (long int) (PyArray_NDIM(tmp) >= 3 ? 25630 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 25631 (long int) (PyArray_NDIM(tmp) >= 2 ? 25632 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 25633 (long int) (PyArray_NDIM(tmp) >= 1 ? 25634 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 25635 ); 25636 { 25637 __failure = 460; 25638 if (!PyErr_Occurred()) { 25639 PyErr_SetString(PyExc_RuntimeError, 25640 "Unexpected error in an Op's C code. " 25641 "No Python exception was set."); 25642 } 25643 goto __label_460;} 25644 } 25645 // This is a TypeError to be consistent with DEBUG_MODE 25646 // Note: DEBUG_MODE also tells the name of the container 25647 if (PyArray_TYPE((PyArrayObject*) py_V459) != NPY_FLOAT64) { 25648 PyErr_Format(PyExc_TypeError, 25649 "expected type_num %d (NPY_FLOAT64) got %d", 25650 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V459)); 25651 { 25652 __failure = 460; 25653 if (!PyErr_Occurred()) { 25654 PyErr_SetString(PyExc_RuntimeError, 25655 "Unexpected error in an Op's C code. " 25656 "No Python exception was set."); 25657 } 25658 goto __label_460;} 25659 } 25660 25661 V459 = (PyArrayObject*)(py_V459); 25662 Py_XINCREF(V459); 25663 25664 { 25665 25666 py_V461 = PyList_GET_ITEM(storage_V461, 0); 25667 {Py_XINCREF(py_V461);} 25668 25669 V461 = NULL; 25670 if (py_V461 == Py_None) { 25671 // We can either fail here or set V461 to NULL and rely on Ops 25672 // using tensors to handle the NULL case, but if they fail to do so 25673 // they'll end up with nasty segfaults, so this is public service. 25674 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 25675 { 25676 __failure = 462; 25677 if (!PyErr_Occurred()) { 25678 PyErr_SetString(PyExc_RuntimeError, 25679 "Unexpected error in an Op's C code. " 25680 "No Python exception was set."); 25681 } 25682 goto __label_462;} 25683 } 25684 if (!PyArray_Check(py_V461)) { 25685 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 25686 { 25687 __failure = 462; 25688 if (!PyErr_Occurred()) { 25689 PyErr_SetString(PyExc_RuntimeError, 25690 "Unexpected error in an Op's C code. " 25691 "No Python exception was set."); 25692 } 25693 goto __label_462;} 25694 } 25695 // We expect NPY_FLOAT64 25696 if (!PyArray_ISALIGNED((PyArrayObject*) py_V461)) { 25697 PyArrayObject * tmp = (PyArrayObject*) py_V461; 25698 PyErr_Format(PyExc_NotImplementedError, 25699 "expected an aligned array of type %ld " 25700 "(NPY_FLOAT64), got non-aligned array of type %ld" 25701 " with %ld dimensions, with 3 last dims " 25702 "%ld, %ld, %ld" 25703 " and 3 last strides %ld %ld, %ld.", 25704 (long int) NPY_FLOAT64, 25705 (long int) PyArray_TYPE((PyArrayObject*) py_V461), 25706 (long int) PyArray_NDIM(tmp), 25707 (long int) (PyArray_NDIM(tmp) >= 3 ? 25708 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 25709 (long int) (PyArray_NDIM(tmp) >= 2 ? 25710 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 25711 (long int) (PyArray_NDIM(tmp) >= 1 ? 25712 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 25713 (long int) (PyArray_NDIM(tmp) >= 3 ? 25714 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 25715 (long int) (PyArray_NDIM(tmp) >= 2 ? 25716 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 25717 (long int) (PyArray_NDIM(tmp) >= 1 ? 25718 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 25719 ); 25720 { 25721 __failure = 462; 25722 if (!PyErr_Occurred()) { 25723 PyErr_SetString(PyExc_RuntimeError, 25724 "Unexpected error in an Op's C code. " 25725 "No Python exception was set."); 25726 } 25727 goto __label_462;} 25728 } 25729 // This is a TypeError to be consistent with DEBUG_MODE 25730 // Note: DEBUG_MODE also tells the name of the container 25731 if (PyArray_TYPE((PyArrayObject*) py_V461) != NPY_FLOAT64) { 25732 PyErr_Format(PyExc_TypeError, 25733 "expected type_num %d (NPY_FLOAT64) got %d", 25734 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V461)); 25735 { 25736 __failure = 462; 25737 if (!PyErr_Occurred()) { 25738 PyErr_SetString(PyExc_RuntimeError, 25739 "Unexpected error in an Op's C code. " 25740 "No Python exception was set."); 25741 } 25742 goto __label_462;} 25743 } 25744 25745 V461 = (PyArrayObject*)(py_V461); 25746 Py_XINCREF(V461); 25747 25748 { 25749 25750 py_V463 = PyList_GET_ITEM(storage_V463, 0); 25751 {Py_XINCREF(py_V463);} 25752 25753 V463 = NULL; 25754 if (py_V463 == Py_None) { 25755 // We can either fail here or set V463 to NULL and rely on Ops 25756 // using tensors to handle the NULL case, but if they fail to do so 25757 // they'll end up with nasty segfaults, so this is public service. 25758 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 25759 { 25760 __failure = 464; 25761 if (!PyErr_Occurred()) { 25762 PyErr_SetString(PyExc_RuntimeError, 25763 "Unexpected error in an Op's C code. " 25764 "No Python exception was set."); 25765 } 25766 goto __label_464;} 25767 } 25768 if (!PyArray_Check(py_V463)) { 25769 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 25770 { 25771 __failure = 464; 25772 if (!PyErr_Occurred()) { 25773 PyErr_SetString(PyExc_RuntimeError, 25774 "Unexpected error in an Op's C code. " 25775 "No Python exception was set."); 25776 } 25777 goto __label_464;} 25778 } 25779 // We expect NPY_FLOAT64 25780 if (!PyArray_ISALIGNED((PyArrayObject*) py_V463)) { 25781 PyArrayObject * tmp = (PyArrayObject*) py_V463; 25782 PyErr_Format(PyExc_NotImplementedError, 25783 "expected an aligned array of type %ld " 25784 "(NPY_FLOAT64), got non-aligned array of type %ld" 25785 " with %ld dimensions, with 3 last dims " 25786 "%ld, %ld, %ld" 25787 " and 3 last strides %ld %ld, %ld.", 25788 (long int) NPY_FLOAT64, 25789 (long int) PyArray_TYPE((PyArrayObject*) py_V463), 25790 (long int) PyArray_NDIM(tmp), 25791 (long int) (PyArray_NDIM(tmp) >= 3 ? 25792 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 25793 (long int) (PyArray_NDIM(tmp) >= 2 ? 25794 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 25795 (long int) (PyArray_NDIM(tmp) >= 1 ? 25796 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 25797 (long int) (PyArray_NDIM(tmp) >= 3 ? 25798 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 25799 (long int) (PyArray_NDIM(tmp) >= 2 ? 25800 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 25801 (long int) (PyArray_NDIM(tmp) >= 1 ? 25802 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 25803 ); 25804 { 25805 __failure = 464; 25806 if (!PyErr_Occurred()) { 25807 PyErr_SetString(PyExc_RuntimeError, 25808 "Unexpected error in an Op's C code. " 25809 "No Python exception was set."); 25810 } 25811 goto __label_464;} 25812 } 25813 // This is a TypeError to be consistent with DEBUG_MODE 25814 // Note: DEBUG_MODE also tells the name of the container 25815 if (PyArray_TYPE((PyArrayObject*) py_V463) != NPY_FLOAT64) { 25816 PyErr_Format(PyExc_TypeError, 25817 "expected type_num %d (NPY_FLOAT64) got %d", 25818 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V463)); 25819 { 25820 __failure = 464; 25821 if (!PyErr_Occurred()) { 25822 PyErr_SetString(PyExc_RuntimeError, 25823 "Unexpected error in an Op's C code. " 25824 "No Python exception was set."); 25825 } 25826 goto __label_464;} 25827 } 25828 25829 V463 = (PyArrayObject*)(py_V463); 25830 Py_XINCREF(V463); 25831 25832 { 25833 25834 py_V465 = PyList_GET_ITEM(storage_V465, 0); 25835 {Py_XINCREF(py_V465);} 25836 25837 V465 = NULL; 25838 if (py_V465 == Py_None) { 25839 // We can either fail here or set V465 to NULL and rely on Ops 25840 // using tensors to handle the NULL case, but if they fail to do so 25841 // they'll end up with nasty segfaults, so this is public service. 25842 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 25843 { 25844 __failure = 466; 25845 if (!PyErr_Occurred()) { 25846 PyErr_SetString(PyExc_RuntimeError, 25847 "Unexpected error in an Op's C code. " 25848 "No Python exception was set."); 25849 } 25850 goto __label_466;} 25851 } 25852 if (!PyArray_Check(py_V465)) { 25853 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 25854 { 25855 __failure = 466; 25856 if (!PyErr_Occurred()) { 25857 PyErr_SetString(PyExc_RuntimeError, 25858 "Unexpected error in an Op's C code. " 25859 "No Python exception was set."); 25860 } 25861 goto __label_466;} 25862 } 25863 // We expect NPY_FLOAT64 25864 if (!PyArray_ISALIGNED((PyArrayObject*) py_V465)) { 25865 PyArrayObject * tmp = (PyArrayObject*) py_V465; 25866 PyErr_Format(PyExc_NotImplementedError, 25867 "expected an aligned array of type %ld " 25868 "(NPY_FLOAT64), got non-aligned array of type %ld" 25869 " with %ld dimensions, with 3 last dims " 25870 "%ld, %ld, %ld" 25871 " and 3 last strides %ld %ld, %ld.", 25872 (long int) NPY_FLOAT64, 25873 (long int) PyArray_TYPE((PyArrayObject*) py_V465), 25874 (long int) PyArray_NDIM(tmp), 25875 (long int) (PyArray_NDIM(tmp) >= 3 ? 25876 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 25877 (long int) (PyArray_NDIM(tmp) >= 2 ? 25878 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 25879 (long int) (PyArray_NDIM(tmp) >= 1 ? 25880 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 25881 (long int) (PyArray_NDIM(tmp) >= 3 ? 25882 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 25883 (long int) (PyArray_NDIM(tmp) >= 2 ? 25884 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 25885 (long int) (PyArray_NDIM(tmp) >= 1 ? 25886 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 25887 ); 25888 { 25889 __failure = 466; 25890 if (!PyErr_Occurred()) { 25891 PyErr_SetString(PyExc_RuntimeError, 25892 "Unexpected error in an Op's C code. " 25893 "No Python exception was set."); 25894 } 25895 goto __label_466;} 25896 } 25897 // This is a TypeError to be consistent with DEBUG_MODE 25898 // Note: DEBUG_MODE also tells the name of the container 25899 if (PyArray_TYPE((PyArrayObject*) py_V465) != NPY_FLOAT64) { 25900 PyErr_Format(PyExc_TypeError, 25901 "expected type_num %d (NPY_FLOAT64) got %d", 25902 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V465)); 25903 { 25904 __failure = 466; 25905 if (!PyErr_Occurred()) { 25906 PyErr_SetString(PyExc_RuntimeError, 25907 "Unexpected error in an Op's C code. " 25908 "No Python exception was set."); 25909 } 25910 goto __label_466;} 25911 } 25912 25913 V465 = (PyArrayObject*)(py_V465); 25914 Py_XINCREF(V465); 25915 25916 { 25917 25918 py_V467 = PyList_GET_ITEM(storage_V467, 0); 25919 {Py_XINCREF(py_V467);} 25920 25921 V467 = NULL; 25922 if (py_V467 == Py_None) { 25923 // We can either fail here or set V467 to NULL and rely on Ops 25924 // using tensors to handle the NULL case, but if they fail to do so 25925 // they'll end up with nasty segfaults, so this is public service. 25926 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 25927 { 25928 __failure = 468; 25929 if (!PyErr_Occurred()) { 25930 PyErr_SetString(PyExc_RuntimeError, 25931 "Unexpected error in an Op's C code. " 25932 "No Python exception was set."); 25933 } 25934 goto __label_468;} 25935 } 25936 if (!PyArray_Check(py_V467)) { 25937 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 25938 { 25939 __failure = 468; 25940 if (!PyErr_Occurred()) { 25941 PyErr_SetString(PyExc_RuntimeError, 25942 "Unexpected error in an Op's C code. " 25943 "No Python exception was set."); 25944 } 25945 goto __label_468;} 25946 } 25947 // We expect NPY_FLOAT64 25948 if (!PyArray_ISALIGNED((PyArrayObject*) py_V467)) { 25949 PyArrayObject * tmp = (PyArrayObject*) py_V467; 25950 PyErr_Format(PyExc_NotImplementedError, 25951 "expected an aligned array of type %ld " 25952 "(NPY_FLOAT64), got non-aligned array of type %ld" 25953 " with %ld dimensions, with 3 last dims " 25954 "%ld, %ld, %ld" 25955 " and 3 last strides %ld %ld, %ld.", 25956 (long int) NPY_FLOAT64, 25957 (long int) PyArray_TYPE((PyArrayObject*) py_V467), 25958 (long int) PyArray_NDIM(tmp), 25959 (long int) (PyArray_NDIM(tmp) >= 3 ? 25960 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 25961 (long int) (PyArray_NDIM(tmp) >= 2 ? 25962 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 25963 (long int) (PyArray_NDIM(tmp) >= 1 ? 25964 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 25965 (long int) (PyArray_NDIM(tmp) >= 3 ? 25966 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 25967 (long int) (PyArray_NDIM(tmp) >= 2 ? 25968 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 25969 (long int) (PyArray_NDIM(tmp) >= 1 ? 25970 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 25971 ); 25972 { 25973 __failure = 468; 25974 if (!PyErr_Occurred()) { 25975 PyErr_SetString(PyExc_RuntimeError, 25976 "Unexpected error in an Op's C code. " 25977 "No Python exception was set."); 25978 } 25979 goto __label_468;} 25980 } 25981 // This is a TypeError to be consistent with DEBUG_MODE 25982 // Note: DEBUG_MODE also tells the name of the container 25983 if (PyArray_TYPE((PyArrayObject*) py_V467) != NPY_FLOAT64) { 25984 PyErr_Format(PyExc_TypeError, 25985 "expected type_num %d (NPY_FLOAT64) got %d", 25986 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V467)); 25987 { 25988 __failure = 468; 25989 if (!PyErr_Occurred()) { 25990 PyErr_SetString(PyExc_RuntimeError, 25991 "Unexpected error in an Op's C code. " 25992 "No Python exception was set."); 25993 } 25994 goto __label_468;} 25995 } 25996 25997 V467 = (PyArrayObject*)(py_V467); 25998 Py_XINCREF(V467); 25999 26000 { 26001 26002 py_V469 = PyList_GET_ITEM(storage_V469, 0); 26003 {Py_XINCREF(py_V469);} 26004 26005 V469 = NULL; 26006 if (py_V469 == Py_None) { 26007 // We can either fail here or set V469 to NULL and rely on Ops 26008 // using tensors to handle the NULL case, but if they fail to do so 26009 // they'll end up with nasty segfaults, so this is public service. 26010 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 26011 { 26012 __failure = 470; 26013 if (!PyErr_Occurred()) { 26014 PyErr_SetString(PyExc_RuntimeError, 26015 "Unexpected error in an Op's C code. " 26016 "No Python exception was set."); 26017 } 26018 goto __label_470;} 26019 } 26020 if (!PyArray_Check(py_V469)) { 26021 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 26022 { 26023 __failure = 470; 26024 if (!PyErr_Occurred()) { 26025 PyErr_SetString(PyExc_RuntimeError, 26026 "Unexpected error in an Op's C code. " 26027 "No Python exception was set."); 26028 } 26029 goto __label_470;} 26030 } 26031 // We expect NPY_FLOAT64 26032 if (!PyArray_ISALIGNED((PyArrayObject*) py_V469)) { 26033 PyArrayObject * tmp = (PyArrayObject*) py_V469; 26034 PyErr_Format(PyExc_NotImplementedError, 26035 "expected an aligned array of type %ld " 26036 "(NPY_FLOAT64), got non-aligned array of type %ld" 26037 " with %ld dimensions, with 3 last dims " 26038 "%ld, %ld, %ld" 26039 " and 3 last strides %ld %ld, %ld.", 26040 (long int) NPY_FLOAT64, 26041 (long int) PyArray_TYPE((PyArrayObject*) py_V469), 26042 (long int) PyArray_NDIM(tmp), 26043 (long int) (PyArray_NDIM(tmp) >= 3 ? 26044 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 26045 (long int) (PyArray_NDIM(tmp) >= 2 ? 26046 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 26047 (long int) (PyArray_NDIM(tmp) >= 1 ? 26048 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 26049 (long int) (PyArray_NDIM(tmp) >= 3 ? 26050 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 26051 (long int) (PyArray_NDIM(tmp) >= 2 ? 26052 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 26053 (long int) (PyArray_NDIM(tmp) >= 1 ? 26054 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 26055 ); 26056 { 26057 __failure = 470; 26058 if (!PyErr_Occurred()) { 26059 PyErr_SetString(PyExc_RuntimeError, 26060 "Unexpected error in an Op's C code. " 26061 "No Python exception was set."); 26062 } 26063 goto __label_470;} 26064 } 26065 // This is a TypeError to be consistent with DEBUG_MODE 26066 // Note: DEBUG_MODE also tells the name of the container 26067 if (PyArray_TYPE((PyArrayObject*) py_V469) != NPY_FLOAT64) { 26068 PyErr_Format(PyExc_TypeError, 26069 "expected type_num %d (NPY_FLOAT64) got %d", 26070 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V469)); 26071 { 26072 __failure = 470; 26073 if (!PyErr_Occurred()) { 26074 PyErr_SetString(PyExc_RuntimeError, 26075 "Unexpected error in an Op's C code. " 26076 "No Python exception was set."); 26077 } 26078 goto __label_470;} 26079 } 26080 26081 V469 = (PyArrayObject*)(py_V469); 26082 Py_XINCREF(V469); 26083 26084 { 26085 26086 py_V471 = PyList_GET_ITEM(storage_V471, 0); 26087 {Py_XINCREF(py_V471);} 26088 26089 V471 = NULL; 26090 if (py_V471 == Py_None) { 26091 // We can either fail here or set V471 to NULL and rely on Ops 26092 // using tensors to handle the NULL case, but if they fail to do so 26093 // they'll end up with nasty segfaults, so this is public service. 26094 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 26095 { 26096 __failure = 472; 26097 if (!PyErr_Occurred()) { 26098 PyErr_SetString(PyExc_RuntimeError, 26099 "Unexpected error in an Op's C code. " 26100 "No Python exception was set."); 26101 } 26102 goto __label_472;} 26103 } 26104 if (!PyArray_Check(py_V471)) { 26105 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 26106 { 26107 __failure = 472; 26108 if (!PyErr_Occurred()) { 26109 PyErr_SetString(PyExc_RuntimeError, 26110 "Unexpected error in an Op's C code. " 26111 "No Python exception was set."); 26112 } 26113 goto __label_472;} 26114 } 26115 // We expect NPY_FLOAT64 26116 if (!PyArray_ISALIGNED((PyArrayObject*) py_V471)) { 26117 PyArrayObject * tmp = (PyArrayObject*) py_V471; 26118 PyErr_Format(PyExc_NotImplementedError, 26119 "expected an aligned array of type %ld " 26120 "(NPY_FLOAT64), got non-aligned array of type %ld" 26121 " with %ld dimensions, with 3 last dims " 26122 "%ld, %ld, %ld" 26123 " and 3 last strides %ld %ld, %ld.", 26124 (long int) NPY_FLOAT64, 26125 (long int) PyArray_TYPE((PyArrayObject*) py_V471), 26126 (long int) PyArray_NDIM(tmp), 26127 (long int) (PyArray_NDIM(tmp) >= 3 ? 26128 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 26129 (long int) (PyArray_NDIM(tmp) >= 2 ? 26130 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 26131 (long int) (PyArray_NDIM(tmp) >= 1 ? 26132 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 26133 (long int) (PyArray_NDIM(tmp) >= 3 ? 26134 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 26135 (long int) (PyArray_NDIM(tmp) >= 2 ? 26136 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 26137 (long int) (PyArray_NDIM(tmp) >= 1 ? 26138 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 26139 ); 26140 { 26141 __failure = 472; 26142 if (!PyErr_Occurred()) { 26143 PyErr_SetString(PyExc_RuntimeError, 26144 "Unexpected error in an Op's C code. " 26145 "No Python exception was set."); 26146 } 26147 goto __label_472;} 26148 } 26149 // This is a TypeError to be consistent with DEBUG_MODE 26150 // Note: DEBUG_MODE also tells the name of the container 26151 if (PyArray_TYPE((PyArrayObject*) py_V471) != NPY_FLOAT64) { 26152 PyErr_Format(PyExc_TypeError, 26153 "expected type_num %d (NPY_FLOAT64) got %d", 26154 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V471)); 26155 { 26156 __failure = 472; 26157 if (!PyErr_Occurred()) { 26158 PyErr_SetString(PyExc_RuntimeError, 26159 "Unexpected error in an Op's C code. " 26160 "No Python exception was set."); 26161 } 26162 goto __label_472;} 26163 } 26164 26165 V471 = (PyArrayObject*)(py_V471); 26166 Py_XINCREF(V471); 26167 26168 { 26169 26170 py_V473 = PyList_GET_ITEM(storage_V473, 0); 26171 {Py_XINCREF(py_V473);} 26172 26173 V473 = NULL; 26174 if (py_V473 == Py_None) { 26175 // We can either fail here or set V473 to NULL and rely on Ops 26176 // using tensors to handle the NULL case, but if they fail to do so 26177 // they'll end up with nasty segfaults, so this is public service. 26178 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 26179 { 26180 __failure = 474; 26181 if (!PyErr_Occurred()) { 26182 PyErr_SetString(PyExc_RuntimeError, 26183 "Unexpected error in an Op's C code. " 26184 "No Python exception was set."); 26185 } 26186 goto __label_474;} 26187 } 26188 if (!PyArray_Check(py_V473)) { 26189 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 26190 { 26191 __failure = 474; 26192 if (!PyErr_Occurred()) { 26193 PyErr_SetString(PyExc_RuntimeError, 26194 "Unexpected error in an Op's C code. " 26195 "No Python exception was set."); 26196 } 26197 goto __label_474;} 26198 } 26199 // We expect NPY_FLOAT64 26200 if (!PyArray_ISALIGNED((PyArrayObject*) py_V473)) { 26201 PyArrayObject * tmp = (PyArrayObject*) py_V473; 26202 PyErr_Format(PyExc_NotImplementedError, 26203 "expected an aligned array of type %ld " 26204 "(NPY_FLOAT64), got non-aligned array of type %ld" 26205 " with %ld dimensions, with 3 last dims " 26206 "%ld, %ld, %ld" 26207 " and 3 last strides %ld %ld, %ld.", 26208 (long int) NPY_FLOAT64, 26209 (long int) PyArray_TYPE((PyArrayObject*) py_V473), 26210 (long int) PyArray_NDIM(tmp), 26211 (long int) (PyArray_NDIM(tmp) >= 3 ? 26212 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 26213 (long int) (PyArray_NDIM(tmp) >= 2 ? 26214 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 26215 (long int) (PyArray_NDIM(tmp) >= 1 ? 26216 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 26217 (long int) (PyArray_NDIM(tmp) >= 3 ? 26218 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 26219 (long int) (PyArray_NDIM(tmp) >= 2 ? 26220 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 26221 (long int) (PyArray_NDIM(tmp) >= 1 ? 26222 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 26223 ); 26224 { 26225 __failure = 474; 26226 if (!PyErr_Occurred()) { 26227 PyErr_SetString(PyExc_RuntimeError, 26228 "Unexpected error in an Op's C code. " 26229 "No Python exception was set."); 26230 } 26231 goto __label_474;} 26232 } 26233 // This is a TypeError to be consistent with DEBUG_MODE 26234 // Note: DEBUG_MODE also tells the name of the container 26235 if (PyArray_TYPE((PyArrayObject*) py_V473) != NPY_FLOAT64) { 26236 PyErr_Format(PyExc_TypeError, 26237 "expected type_num %d (NPY_FLOAT64) got %d", 26238 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V473)); 26239 { 26240 __failure = 474; 26241 if (!PyErr_Occurred()) { 26242 PyErr_SetString(PyExc_RuntimeError, 26243 "Unexpected error in an Op's C code. " 26244 "No Python exception was set."); 26245 } 26246 goto __label_474;} 26247 } 26248 26249 V473 = (PyArrayObject*)(py_V473); 26250 Py_XINCREF(V473); 26251 26252 { 26253 26254 py_V475 = PyList_GET_ITEM(storage_V475, 0); 26255 {Py_XINCREF(py_V475);} 26256 26257 V475 = NULL; 26258 if (py_V475 == Py_None) { 26259 // We can either fail here or set V475 to NULL and rely on Ops 26260 // using tensors to handle the NULL case, but if they fail to do so 26261 // they'll end up with nasty segfaults, so this is public service. 26262 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 26263 { 26264 __failure = 476; 26265 if (!PyErr_Occurred()) { 26266 PyErr_SetString(PyExc_RuntimeError, 26267 "Unexpected error in an Op's C code. " 26268 "No Python exception was set."); 26269 } 26270 goto __label_476;} 26271 } 26272 if (!PyArray_Check(py_V475)) { 26273 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 26274 { 26275 __failure = 476; 26276 if (!PyErr_Occurred()) { 26277 PyErr_SetString(PyExc_RuntimeError, 26278 "Unexpected error in an Op's C code. " 26279 "No Python exception was set."); 26280 } 26281 goto __label_476;} 26282 } 26283 // We expect NPY_FLOAT64 26284 if (!PyArray_ISALIGNED((PyArrayObject*) py_V475)) { 26285 PyArrayObject * tmp = (PyArrayObject*) py_V475; 26286 PyErr_Format(PyExc_NotImplementedError, 26287 "expected an aligned array of type %ld " 26288 "(NPY_FLOAT64), got non-aligned array of type %ld" 26289 " with %ld dimensions, with 3 last dims " 26290 "%ld, %ld, %ld" 26291 " and 3 last strides %ld %ld, %ld.", 26292 (long int) NPY_FLOAT64, 26293 (long int) PyArray_TYPE((PyArrayObject*) py_V475), 26294 (long int) PyArray_NDIM(tmp), 26295 (long int) (PyArray_NDIM(tmp) >= 3 ? 26296 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 26297 (long int) (PyArray_NDIM(tmp) >= 2 ? 26298 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 26299 (long int) (PyArray_NDIM(tmp) >= 1 ? 26300 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 26301 (long int) (PyArray_NDIM(tmp) >= 3 ? 26302 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 26303 (long int) (PyArray_NDIM(tmp) >= 2 ? 26304 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 26305 (long int) (PyArray_NDIM(tmp) >= 1 ? 26306 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 26307 ); 26308 { 26309 __failure = 476; 26310 if (!PyErr_Occurred()) { 26311 PyErr_SetString(PyExc_RuntimeError, 26312 "Unexpected error in an Op's C code. " 26313 "No Python exception was set."); 26314 } 26315 goto __label_476;} 26316 } 26317 // This is a TypeError to be consistent with DEBUG_MODE 26318 // Note: DEBUG_MODE also tells the name of the container 26319 if (PyArray_TYPE((PyArrayObject*) py_V475) != NPY_FLOAT64) { 26320 PyErr_Format(PyExc_TypeError, 26321 "expected type_num %d (NPY_FLOAT64) got %d", 26322 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V475)); 26323 { 26324 __failure = 476; 26325 if (!PyErr_Occurred()) { 26326 PyErr_SetString(PyExc_RuntimeError, 26327 "Unexpected error in an Op's C code. " 26328 "No Python exception was set."); 26329 } 26330 goto __label_476;} 26331 } 26332 26333 V475 = (PyArrayObject*)(py_V475); 26334 Py_XINCREF(V475); 26335 26336 { 26337 26338 py_V477 = PyList_GET_ITEM(storage_V477, 0); 26339 {Py_XINCREF(py_V477);} 26340 26341 V477 = NULL; 26342 if (py_V477 == Py_None) { 26343 // We can either fail here or set V477 to NULL and rely on Ops 26344 // using tensors to handle the NULL case, but if they fail to do so 26345 // they'll end up with nasty segfaults, so this is public service. 26346 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 26347 { 26348 __failure = 478; 26349 if (!PyErr_Occurred()) { 26350 PyErr_SetString(PyExc_RuntimeError, 26351 "Unexpected error in an Op's C code. " 26352 "No Python exception was set."); 26353 } 26354 goto __label_478;} 26355 } 26356 if (!PyArray_Check(py_V477)) { 26357 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 26358 { 26359 __failure = 478; 26360 if (!PyErr_Occurred()) { 26361 PyErr_SetString(PyExc_RuntimeError, 26362 "Unexpected error in an Op's C code. " 26363 "No Python exception was set."); 26364 } 26365 goto __label_478;} 26366 } 26367 // We expect NPY_FLOAT64 26368 if (!PyArray_ISALIGNED((PyArrayObject*) py_V477)) { 26369 PyArrayObject * tmp = (PyArrayObject*) py_V477; 26370 PyErr_Format(PyExc_NotImplementedError, 26371 "expected an aligned array of type %ld " 26372 "(NPY_FLOAT64), got non-aligned array of type %ld" 26373 " with %ld dimensions, with 3 last dims " 26374 "%ld, %ld, %ld" 26375 " and 3 last strides %ld %ld, %ld.", 26376 (long int) NPY_FLOAT64, 26377 (long int) PyArray_TYPE((PyArrayObject*) py_V477), 26378 (long int) PyArray_NDIM(tmp), 26379 (long int) (PyArray_NDIM(tmp) >= 3 ? 26380 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 26381 (long int) (PyArray_NDIM(tmp) >= 2 ? 26382 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 26383 (long int) (PyArray_NDIM(tmp) >= 1 ? 26384 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 26385 (long int) (PyArray_NDIM(tmp) >= 3 ? 26386 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 26387 (long int) (PyArray_NDIM(tmp) >= 2 ? 26388 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 26389 (long int) (PyArray_NDIM(tmp) >= 1 ? 26390 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 26391 ); 26392 { 26393 __failure = 478; 26394 if (!PyErr_Occurred()) { 26395 PyErr_SetString(PyExc_RuntimeError, 26396 "Unexpected error in an Op's C code. " 26397 "No Python exception was set."); 26398 } 26399 goto __label_478;} 26400 } 26401 // This is a TypeError to be consistent with DEBUG_MODE 26402 // Note: DEBUG_MODE also tells the name of the container 26403 if (PyArray_TYPE((PyArrayObject*) py_V477) != NPY_FLOAT64) { 26404 PyErr_Format(PyExc_TypeError, 26405 "expected type_num %d (NPY_FLOAT64) got %d", 26406 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V477)); 26407 { 26408 __failure = 478; 26409 if (!PyErr_Occurred()) { 26410 PyErr_SetString(PyExc_RuntimeError, 26411 "Unexpected error in an Op's C code. " 26412 "No Python exception was set."); 26413 } 26414 goto __label_478;} 26415 } 26416 26417 V477 = (PyArrayObject*)(py_V477); 26418 Py_XINCREF(V477); 26419 26420 { 26421 26422 py_V479 = PyList_GET_ITEM(storage_V479, 0); 26423 {Py_XINCREF(py_V479);} 26424 26425 V479 = NULL; 26426 if (py_V479 == Py_None) { 26427 // We can either fail here or set V479 to NULL and rely on Ops 26428 // using tensors to handle the NULL case, but if they fail to do so 26429 // they'll end up with nasty segfaults, so this is public service. 26430 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 26431 { 26432 __failure = 480; 26433 if (!PyErr_Occurred()) { 26434 PyErr_SetString(PyExc_RuntimeError, 26435 "Unexpected error in an Op's C code. " 26436 "No Python exception was set."); 26437 } 26438 goto __label_480;} 26439 } 26440 if (!PyArray_Check(py_V479)) { 26441 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 26442 { 26443 __failure = 480; 26444 if (!PyErr_Occurred()) { 26445 PyErr_SetString(PyExc_RuntimeError, 26446 "Unexpected error in an Op's C code. " 26447 "No Python exception was set."); 26448 } 26449 goto __label_480;} 26450 } 26451 // We expect NPY_FLOAT64 26452 if (!PyArray_ISALIGNED((PyArrayObject*) py_V479)) { 26453 PyArrayObject * tmp = (PyArrayObject*) py_V479; 26454 PyErr_Format(PyExc_NotImplementedError, 26455 "expected an aligned array of type %ld " 26456 "(NPY_FLOAT64), got non-aligned array of type %ld" 26457 " with %ld dimensions, with 3 last dims " 26458 "%ld, %ld, %ld" 26459 " and 3 last strides %ld %ld, %ld.", 26460 (long int) NPY_FLOAT64, 26461 (long int) PyArray_TYPE((PyArrayObject*) py_V479), 26462 (long int) PyArray_NDIM(tmp), 26463 (long int) (PyArray_NDIM(tmp) >= 3 ? 26464 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 26465 (long int) (PyArray_NDIM(tmp) >= 2 ? 26466 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 26467 (long int) (PyArray_NDIM(tmp) >= 1 ? 26468 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 26469 (long int) (PyArray_NDIM(tmp) >= 3 ? 26470 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 26471 (long int) (PyArray_NDIM(tmp) >= 2 ? 26472 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 26473 (long int) (PyArray_NDIM(tmp) >= 1 ? 26474 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 26475 ); 26476 { 26477 __failure = 480; 26478 if (!PyErr_Occurred()) { 26479 PyErr_SetString(PyExc_RuntimeError, 26480 "Unexpected error in an Op's C code. " 26481 "No Python exception was set."); 26482 } 26483 goto __label_480;} 26484 } 26485 // This is a TypeError to be consistent with DEBUG_MODE 26486 // Note: DEBUG_MODE also tells the name of the container 26487 if (PyArray_TYPE((PyArrayObject*) py_V479) != NPY_FLOAT64) { 26488 PyErr_Format(PyExc_TypeError, 26489 "expected type_num %d (NPY_FLOAT64) got %d", 26490 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V479)); 26491 { 26492 __failure = 480; 26493 if (!PyErr_Occurred()) { 26494 PyErr_SetString(PyExc_RuntimeError, 26495 "Unexpected error in an Op's C code. " 26496 "No Python exception was set."); 26497 } 26498 goto __label_480;} 26499 } 26500 26501 V479 = (PyArrayObject*)(py_V479); 26502 Py_XINCREF(V479); 26503 26504 { 26505 26506 py_V481 = PyList_GET_ITEM(storage_V481, 0); 26507 {Py_XINCREF(py_V481);} 26508 26509 V481 = NULL; 26510 if (py_V481 == Py_None) { 26511 // We can either fail here or set V481 to NULL and rely on Ops 26512 // using tensors to handle the NULL case, but if they fail to do so 26513 // they'll end up with nasty segfaults, so this is public service. 26514 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 26515 { 26516 __failure = 482; 26517 if (!PyErr_Occurred()) { 26518 PyErr_SetString(PyExc_RuntimeError, 26519 "Unexpected error in an Op's C code. " 26520 "No Python exception was set."); 26521 } 26522 goto __label_482;} 26523 } 26524 if (!PyArray_Check(py_V481)) { 26525 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 26526 { 26527 __failure = 482; 26528 if (!PyErr_Occurred()) { 26529 PyErr_SetString(PyExc_RuntimeError, 26530 "Unexpected error in an Op's C code. " 26531 "No Python exception was set."); 26532 } 26533 goto __label_482;} 26534 } 26535 // We expect NPY_FLOAT64 26536 if (!PyArray_ISALIGNED((PyArrayObject*) py_V481)) { 26537 PyArrayObject * tmp = (PyArrayObject*) py_V481; 26538 PyErr_Format(PyExc_NotImplementedError, 26539 "expected an aligned array of type %ld " 26540 "(NPY_FLOAT64), got non-aligned array of type %ld" 26541 " with %ld dimensions, with 3 last dims " 26542 "%ld, %ld, %ld" 26543 " and 3 last strides %ld %ld, %ld.", 26544 (long int) NPY_FLOAT64, 26545 (long int) PyArray_TYPE((PyArrayObject*) py_V481), 26546 (long int) PyArray_NDIM(tmp), 26547 (long int) (PyArray_NDIM(tmp) >= 3 ? 26548 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 26549 (long int) (PyArray_NDIM(tmp) >= 2 ? 26550 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 26551 (long int) (PyArray_NDIM(tmp) >= 1 ? 26552 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 26553 (long int) (PyArray_NDIM(tmp) >= 3 ? 26554 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 26555 (long int) (PyArray_NDIM(tmp) >= 2 ? 26556 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 26557 (long int) (PyArray_NDIM(tmp) >= 1 ? 26558 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 26559 ); 26560 { 26561 __failure = 482; 26562 if (!PyErr_Occurred()) { 26563 PyErr_SetString(PyExc_RuntimeError, 26564 "Unexpected error in an Op's C code. " 26565 "No Python exception was set."); 26566 } 26567 goto __label_482;} 26568 } 26569 // This is a TypeError to be consistent with DEBUG_MODE 26570 // Note: DEBUG_MODE also tells the name of the container 26571 if (PyArray_TYPE((PyArrayObject*) py_V481) != NPY_FLOAT64) { 26572 PyErr_Format(PyExc_TypeError, 26573 "expected type_num %d (NPY_FLOAT64) got %d", 26574 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V481)); 26575 { 26576 __failure = 482; 26577 if (!PyErr_Occurred()) { 26578 PyErr_SetString(PyExc_RuntimeError, 26579 "Unexpected error in an Op's C code. " 26580 "No Python exception was set."); 26581 } 26582 goto __label_482;} 26583 } 26584 26585 V481 = (PyArrayObject*)(py_V481); 26586 Py_XINCREF(V481); 26587 26588 { 26589 26590 py_V483 = PyList_GET_ITEM(storage_V483, 0); 26591 {Py_XINCREF(py_V483);} 26592 26593 V483 = NULL; 26594 if (py_V483 == Py_None) { 26595 // We can either fail here or set V483 to NULL and rely on Ops 26596 // using tensors to handle the NULL case, but if they fail to do so 26597 // they'll end up with nasty segfaults, so this is public service. 26598 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 26599 { 26600 __failure = 484; 26601 if (!PyErr_Occurred()) { 26602 PyErr_SetString(PyExc_RuntimeError, 26603 "Unexpected error in an Op's C code. " 26604 "No Python exception was set."); 26605 } 26606 goto __label_484;} 26607 } 26608 if (!PyArray_Check(py_V483)) { 26609 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 26610 { 26611 __failure = 484; 26612 if (!PyErr_Occurred()) { 26613 PyErr_SetString(PyExc_RuntimeError, 26614 "Unexpected error in an Op's C code. " 26615 "No Python exception was set."); 26616 } 26617 goto __label_484;} 26618 } 26619 // We expect NPY_FLOAT64 26620 if (!PyArray_ISALIGNED((PyArrayObject*) py_V483)) { 26621 PyArrayObject * tmp = (PyArrayObject*) py_V483; 26622 PyErr_Format(PyExc_NotImplementedError, 26623 "expected an aligned array of type %ld " 26624 "(NPY_FLOAT64), got non-aligned array of type %ld" 26625 " with %ld dimensions, with 3 last dims " 26626 "%ld, %ld, %ld" 26627 " and 3 last strides %ld %ld, %ld.", 26628 (long int) NPY_FLOAT64, 26629 (long int) PyArray_TYPE((PyArrayObject*) py_V483), 26630 (long int) PyArray_NDIM(tmp), 26631 (long int) (PyArray_NDIM(tmp) >= 3 ? 26632 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 26633 (long int) (PyArray_NDIM(tmp) >= 2 ? 26634 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 26635 (long int) (PyArray_NDIM(tmp) >= 1 ? 26636 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 26637 (long int) (PyArray_NDIM(tmp) >= 3 ? 26638 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 26639 (long int) (PyArray_NDIM(tmp) >= 2 ? 26640 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 26641 (long int) (PyArray_NDIM(tmp) >= 1 ? 26642 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 26643 ); 26644 { 26645 __failure = 484; 26646 if (!PyErr_Occurred()) { 26647 PyErr_SetString(PyExc_RuntimeError, 26648 "Unexpected error in an Op's C code. " 26649 "No Python exception was set."); 26650 } 26651 goto __label_484;} 26652 } 26653 // This is a TypeError to be consistent with DEBUG_MODE 26654 // Note: DEBUG_MODE also tells the name of the container 26655 if (PyArray_TYPE((PyArrayObject*) py_V483) != NPY_FLOAT64) { 26656 PyErr_Format(PyExc_TypeError, 26657 "expected type_num %d (NPY_FLOAT64) got %d", 26658 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V483)); 26659 { 26660 __failure = 484; 26661 if (!PyErr_Occurred()) { 26662 PyErr_SetString(PyExc_RuntimeError, 26663 "Unexpected error in an Op's C code. " 26664 "No Python exception was set."); 26665 } 26666 goto __label_484;} 26667 } 26668 26669 V483 = (PyArrayObject*)(py_V483); 26670 Py_XINCREF(V483); 26671 26672 { 26673 26674 py_V485 = PyList_GET_ITEM(storage_V485, 0); 26675 {Py_XINCREF(py_V485);} 26676 26677 V485 = NULL; 26678 if (py_V485 == Py_None) { 26679 // We can either fail here or set V485 to NULL and rely on Ops 26680 // using tensors to handle the NULL case, but if they fail to do so 26681 // they'll end up with nasty segfaults, so this is public service. 26682 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 26683 { 26684 __failure = 486; 26685 if (!PyErr_Occurred()) { 26686 PyErr_SetString(PyExc_RuntimeError, 26687 "Unexpected error in an Op's C code. " 26688 "No Python exception was set."); 26689 } 26690 goto __label_486;} 26691 } 26692 if (!PyArray_Check(py_V485)) { 26693 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 26694 { 26695 __failure = 486; 26696 if (!PyErr_Occurred()) { 26697 PyErr_SetString(PyExc_RuntimeError, 26698 "Unexpected error in an Op's C code. " 26699 "No Python exception was set."); 26700 } 26701 goto __label_486;} 26702 } 26703 // We expect NPY_FLOAT64 26704 if (!PyArray_ISALIGNED((PyArrayObject*) py_V485)) { 26705 PyArrayObject * tmp = (PyArrayObject*) py_V485; 26706 PyErr_Format(PyExc_NotImplementedError, 26707 "expected an aligned array of type %ld " 26708 "(NPY_FLOAT64), got non-aligned array of type %ld" 26709 " with %ld dimensions, with 3 last dims " 26710 "%ld, %ld, %ld" 26711 " and 3 last strides %ld %ld, %ld.", 26712 (long int) NPY_FLOAT64, 26713 (long int) PyArray_TYPE((PyArrayObject*) py_V485), 26714 (long int) PyArray_NDIM(tmp), 26715 (long int) (PyArray_NDIM(tmp) >= 3 ? 26716 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 26717 (long int) (PyArray_NDIM(tmp) >= 2 ? 26718 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 26719 (long int) (PyArray_NDIM(tmp) >= 1 ? 26720 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 26721 (long int) (PyArray_NDIM(tmp) >= 3 ? 26722 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 26723 (long int) (PyArray_NDIM(tmp) >= 2 ? 26724 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 26725 (long int) (PyArray_NDIM(tmp) >= 1 ? 26726 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 26727 ); 26728 { 26729 __failure = 486; 26730 if (!PyErr_Occurred()) { 26731 PyErr_SetString(PyExc_RuntimeError, 26732 "Unexpected error in an Op's C code. " 26733 "No Python exception was set."); 26734 } 26735 goto __label_486;} 26736 } 26737 // This is a TypeError to be consistent with DEBUG_MODE 26738 // Note: DEBUG_MODE also tells the name of the container 26739 if (PyArray_TYPE((PyArrayObject*) py_V485) != NPY_FLOAT64) { 26740 PyErr_Format(PyExc_TypeError, 26741 "expected type_num %d (NPY_FLOAT64) got %d", 26742 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V485)); 26743 { 26744 __failure = 486; 26745 if (!PyErr_Occurred()) { 26746 PyErr_SetString(PyExc_RuntimeError, 26747 "Unexpected error in an Op's C code. " 26748 "No Python exception was set."); 26749 } 26750 goto __label_486;} 26751 } 26752 26753 V485 = (PyArrayObject*)(py_V485); 26754 Py_XINCREF(V485); 26755 26756 { 26757 26758 py_V487 = PyList_GET_ITEM(storage_V487, 0); 26759 {Py_XINCREF(py_V487);} 26760 26761 V487 = NULL; 26762 if (py_V487 == Py_None) { 26763 // We can either fail here or set V487 to NULL and rely on Ops 26764 // using tensors to handle the NULL case, but if they fail to do so 26765 // they'll end up with nasty segfaults, so this is public service. 26766 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 26767 { 26768 __failure = 488; 26769 if (!PyErr_Occurred()) { 26770 PyErr_SetString(PyExc_RuntimeError, 26771 "Unexpected error in an Op's C code. " 26772 "No Python exception was set."); 26773 } 26774 goto __label_488;} 26775 } 26776 if (!PyArray_Check(py_V487)) { 26777 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 26778 { 26779 __failure = 488; 26780 if (!PyErr_Occurred()) { 26781 PyErr_SetString(PyExc_RuntimeError, 26782 "Unexpected error in an Op's C code. " 26783 "No Python exception was set."); 26784 } 26785 goto __label_488;} 26786 } 26787 // We expect NPY_FLOAT64 26788 if (!PyArray_ISALIGNED((PyArrayObject*) py_V487)) { 26789 PyArrayObject * tmp = (PyArrayObject*) py_V487; 26790 PyErr_Format(PyExc_NotImplementedError, 26791 "expected an aligned array of type %ld " 26792 "(NPY_FLOAT64), got non-aligned array of type %ld" 26793 " with %ld dimensions, with 3 last dims " 26794 "%ld, %ld, %ld" 26795 " and 3 last strides %ld %ld, %ld.", 26796 (long int) NPY_FLOAT64, 26797 (long int) PyArray_TYPE((PyArrayObject*) py_V487), 26798 (long int) PyArray_NDIM(tmp), 26799 (long int) (PyArray_NDIM(tmp) >= 3 ? 26800 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 26801 (long int) (PyArray_NDIM(tmp) >= 2 ? 26802 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 26803 (long int) (PyArray_NDIM(tmp) >= 1 ? 26804 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 26805 (long int) (PyArray_NDIM(tmp) >= 3 ? 26806 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 26807 (long int) (PyArray_NDIM(tmp) >= 2 ? 26808 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 26809 (long int) (PyArray_NDIM(tmp) >= 1 ? 26810 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 26811 ); 26812 { 26813 __failure = 488; 26814 if (!PyErr_Occurred()) { 26815 PyErr_SetString(PyExc_RuntimeError, 26816 "Unexpected error in an Op's C code. " 26817 "No Python exception was set."); 26818 } 26819 goto __label_488;} 26820 } 26821 // This is a TypeError to be consistent with DEBUG_MODE 26822 // Note: DEBUG_MODE also tells the name of the container 26823 if (PyArray_TYPE((PyArrayObject*) py_V487) != NPY_FLOAT64) { 26824 PyErr_Format(PyExc_TypeError, 26825 "expected type_num %d (NPY_FLOAT64) got %d", 26826 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V487)); 26827 { 26828 __failure = 488; 26829 if (!PyErr_Occurred()) { 26830 PyErr_SetString(PyExc_RuntimeError, 26831 "Unexpected error in an Op's C code. " 26832 "No Python exception was set."); 26833 } 26834 goto __label_488;} 26835 } 26836 26837 V487 = (PyArrayObject*)(py_V487); 26838 Py_XINCREF(V487); 26839 26840 { 26841 26842 py_V489 = PyList_GET_ITEM(storage_V489, 0); 26843 {Py_XINCREF(py_V489);} 26844 26845 V489 = NULL; 26846 if (py_V489 == Py_None) { 26847 // We can either fail here or set V489 to NULL and rely on Ops 26848 // using tensors to handle the NULL case, but if they fail to do so 26849 // they'll end up with nasty segfaults, so this is public service. 26850 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 26851 { 26852 __failure = 490; 26853 if (!PyErr_Occurred()) { 26854 PyErr_SetString(PyExc_RuntimeError, 26855 "Unexpected error in an Op's C code. " 26856 "No Python exception was set."); 26857 } 26858 goto __label_490;} 26859 } 26860 if (!PyArray_Check(py_V489)) { 26861 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 26862 { 26863 __failure = 490; 26864 if (!PyErr_Occurred()) { 26865 PyErr_SetString(PyExc_RuntimeError, 26866 "Unexpected error in an Op's C code. " 26867 "No Python exception was set."); 26868 } 26869 goto __label_490;} 26870 } 26871 // We expect NPY_FLOAT64 26872 if (!PyArray_ISALIGNED((PyArrayObject*) py_V489)) { 26873 PyArrayObject * tmp = (PyArrayObject*) py_V489; 26874 PyErr_Format(PyExc_NotImplementedError, 26875 "expected an aligned array of type %ld " 26876 "(NPY_FLOAT64), got non-aligned array of type %ld" 26877 " with %ld dimensions, with 3 last dims " 26878 "%ld, %ld, %ld" 26879 " and 3 last strides %ld %ld, %ld.", 26880 (long int) NPY_FLOAT64, 26881 (long int) PyArray_TYPE((PyArrayObject*) py_V489), 26882 (long int) PyArray_NDIM(tmp), 26883 (long int) (PyArray_NDIM(tmp) >= 3 ? 26884 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 26885 (long int) (PyArray_NDIM(tmp) >= 2 ? 26886 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 26887 (long int) (PyArray_NDIM(tmp) >= 1 ? 26888 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 26889 (long int) (PyArray_NDIM(tmp) >= 3 ? 26890 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 26891 (long int) (PyArray_NDIM(tmp) >= 2 ? 26892 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 26893 (long int) (PyArray_NDIM(tmp) >= 1 ? 26894 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 26895 ); 26896 { 26897 __failure = 490; 26898 if (!PyErr_Occurred()) { 26899 PyErr_SetString(PyExc_RuntimeError, 26900 "Unexpected error in an Op's C code. " 26901 "No Python exception was set."); 26902 } 26903 goto __label_490;} 26904 } 26905 // This is a TypeError to be consistent with DEBUG_MODE 26906 // Note: DEBUG_MODE also tells the name of the container 26907 if (PyArray_TYPE((PyArrayObject*) py_V489) != NPY_FLOAT64) { 26908 PyErr_Format(PyExc_TypeError, 26909 "expected type_num %d (NPY_FLOAT64) got %d", 26910 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V489)); 26911 { 26912 __failure = 490; 26913 if (!PyErr_Occurred()) { 26914 PyErr_SetString(PyExc_RuntimeError, 26915 "Unexpected error in an Op's C code. " 26916 "No Python exception was set."); 26917 } 26918 goto __label_490;} 26919 } 26920 26921 V489 = (PyArrayObject*)(py_V489); 26922 Py_XINCREF(V489); 26923 26924 { 26925 26926 py_V491 = PyList_GET_ITEM(storage_V491, 0); 26927 {Py_XINCREF(py_V491);} 26928 26929 V491 = NULL; 26930 if (py_V491 == Py_None) { 26931 // We can either fail here or set V491 to NULL and rely on Ops 26932 // using tensors to handle the NULL case, but if they fail to do so 26933 // they'll end up with nasty segfaults, so this is public service. 26934 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 26935 { 26936 __failure = 492; 26937 if (!PyErr_Occurred()) { 26938 PyErr_SetString(PyExc_RuntimeError, 26939 "Unexpected error in an Op's C code. " 26940 "No Python exception was set."); 26941 } 26942 goto __label_492;} 26943 } 26944 if (!PyArray_Check(py_V491)) { 26945 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 26946 { 26947 __failure = 492; 26948 if (!PyErr_Occurred()) { 26949 PyErr_SetString(PyExc_RuntimeError, 26950 "Unexpected error in an Op's C code. " 26951 "No Python exception was set."); 26952 } 26953 goto __label_492;} 26954 } 26955 // We expect NPY_FLOAT64 26956 if (!PyArray_ISALIGNED((PyArrayObject*) py_V491)) { 26957 PyArrayObject * tmp = (PyArrayObject*) py_V491; 26958 PyErr_Format(PyExc_NotImplementedError, 26959 "expected an aligned array of type %ld " 26960 "(NPY_FLOAT64), got non-aligned array of type %ld" 26961 " with %ld dimensions, with 3 last dims " 26962 "%ld, %ld, %ld" 26963 " and 3 last strides %ld %ld, %ld.", 26964 (long int) NPY_FLOAT64, 26965 (long int) PyArray_TYPE((PyArrayObject*) py_V491), 26966 (long int) PyArray_NDIM(tmp), 26967 (long int) (PyArray_NDIM(tmp) >= 3 ? 26968 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 26969 (long int) (PyArray_NDIM(tmp) >= 2 ? 26970 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 26971 (long int) (PyArray_NDIM(tmp) >= 1 ? 26972 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 26973 (long int) (PyArray_NDIM(tmp) >= 3 ? 26974 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 26975 (long int) (PyArray_NDIM(tmp) >= 2 ? 26976 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 26977 (long int) (PyArray_NDIM(tmp) >= 1 ? 26978 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 26979 ); 26980 { 26981 __failure = 492; 26982 if (!PyErr_Occurred()) { 26983 PyErr_SetString(PyExc_RuntimeError, 26984 "Unexpected error in an Op's C code. " 26985 "No Python exception was set."); 26986 } 26987 goto __label_492;} 26988 } 26989 // This is a TypeError to be consistent with DEBUG_MODE 26990 // Note: DEBUG_MODE also tells the name of the container 26991 if (PyArray_TYPE((PyArrayObject*) py_V491) != NPY_FLOAT64) { 26992 PyErr_Format(PyExc_TypeError, 26993 "expected type_num %d (NPY_FLOAT64) got %d", 26994 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V491)); 26995 { 26996 __failure = 492; 26997 if (!PyErr_Occurred()) { 26998 PyErr_SetString(PyExc_RuntimeError, 26999 "Unexpected error in an Op's C code. " 27000 "No Python exception was set."); 27001 } 27002 goto __label_492;} 27003 } 27004 27005 V491 = (PyArrayObject*)(py_V491); 27006 Py_XINCREF(V491); 27007 27008 { 27009 27010 py_V493 = PyList_GET_ITEM(storage_V493, 0); 27011 {Py_XINCREF(py_V493);} 27012 27013 V493 = NULL; 27014 if (py_V493 == Py_None) { 27015 // We can either fail here or set V493 to NULL and rely on Ops 27016 // using tensors to handle the NULL case, but if they fail to do so 27017 // they'll end up with nasty segfaults, so this is public service. 27018 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 27019 { 27020 __failure = 494; 27021 if (!PyErr_Occurred()) { 27022 PyErr_SetString(PyExc_RuntimeError, 27023 "Unexpected error in an Op's C code. " 27024 "No Python exception was set."); 27025 } 27026 goto __label_494;} 27027 } 27028 if (!PyArray_Check(py_V493)) { 27029 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 27030 { 27031 __failure = 494; 27032 if (!PyErr_Occurred()) { 27033 PyErr_SetString(PyExc_RuntimeError, 27034 "Unexpected error in an Op's C code. " 27035 "No Python exception was set."); 27036 } 27037 goto __label_494;} 27038 } 27039 // We expect NPY_FLOAT64 27040 if (!PyArray_ISALIGNED((PyArrayObject*) py_V493)) { 27041 PyArrayObject * tmp = (PyArrayObject*) py_V493; 27042 PyErr_Format(PyExc_NotImplementedError, 27043 "expected an aligned array of type %ld " 27044 "(NPY_FLOAT64), got non-aligned array of type %ld" 27045 " with %ld dimensions, with 3 last dims " 27046 "%ld, %ld, %ld" 27047 " and 3 last strides %ld %ld, %ld.", 27048 (long int) NPY_FLOAT64, 27049 (long int) PyArray_TYPE((PyArrayObject*) py_V493), 27050 (long int) PyArray_NDIM(tmp), 27051 (long int) (PyArray_NDIM(tmp) >= 3 ? 27052 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 27053 (long int) (PyArray_NDIM(tmp) >= 2 ? 27054 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 27055 (long int) (PyArray_NDIM(tmp) >= 1 ? 27056 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 27057 (long int) (PyArray_NDIM(tmp) >= 3 ? 27058 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 27059 (long int) (PyArray_NDIM(tmp) >= 2 ? 27060 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 27061 (long int) (PyArray_NDIM(tmp) >= 1 ? 27062 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 27063 ); 27064 { 27065 __failure = 494; 27066 if (!PyErr_Occurred()) { 27067 PyErr_SetString(PyExc_RuntimeError, 27068 "Unexpected error in an Op's C code. " 27069 "No Python exception was set."); 27070 } 27071 goto __label_494;} 27072 } 27073 // This is a TypeError to be consistent with DEBUG_MODE 27074 // Note: DEBUG_MODE also tells the name of the container 27075 if (PyArray_TYPE((PyArrayObject*) py_V493) != NPY_FLOAT64) { 27076 PyErr_Format(PyExc_TypeError, 27077 "expected type_num %d (NPY_FLOAT64) got %d", 27078 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V493)); 27079 { 27080 __failure = 494; 27081 if (!PyErr_Occurred()) { 27082 PyErr_SetString(PyExc_RuntimeError, 27083 "Unexpected error in an Op's C code. " 27084 "No Python exception was set."); 27085 } 27086 goto __label_494;} 27087 } 27088 27089 V493 = (PyArrayObject*)(py_V493); 27090 Py_XINCREF(V493); 27091 27092 { 27093 27094 py_V495 = PyList_GET_ITEM(storage_V495, 0); 27095 {Py_XINCREF(py_V495);} 27096 27097 V495 = NULL; 27098 if (py_V495 == Py_None) { 27099 // We can either fail here or set V495 to NULL and rely on Ops 27100 // using tensors to handle the NULL case, but if they fail to do so 27101 // they'll end up with nasty segfaults, so this is public service. 27102 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 27103 { 27104 __failure = 496; 27105 if (!PyErr_Occurred()) { 27106 PyErr_SetString(PyExc_RuntimeError, 27107 "Unexpected error in an Op's C code. " 27108 "No Python exception was set."); 27109 } 27110 goto __label_496;} 27111 } 27112 if (!PyArray_Check(py_V495)) { 27113 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 27114 { 27115 __failure = 496; 27116 if (!PyErr_Occurred()) { 27117 PyErr_SetString(PyExc_RuntimeError, 27118 "Unexpected error in an Op's C code. " 27119 "No Python exception was set."); 27120 } 27121 goto __label_496;} 27122 } 27123 // We expect NPY_FLOAT64 27124 if (!PyArray_ISALIGNED((PyArrayObject*) py_V495)) { 27125 PyArrayObject * tmp = (PyArrayObject*) py_V495; 27126 PyErr_Format(PyExc_NotImplementedError, 27127 "expected an aligned array of type %ld " 27128 "(NPY_FLOAT64), got non-aligned array of type %ld" 27129 " with %ld dimensions, with 3 last dims " 27130 "%ld, %ld, %ld" 27131 " and 3 last strides %ld %ld, %ld.", 27132 (long int) NPY_FLOAT64, 27133 (long int) PyArray_TYPE((PyArrayObject*) py_V495), 27134 (long int) PyArray_NDIM(tmp), 27135 (long int) (PyArray_NDIM(tmp) >= 3 ? 27136 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 27137 (long int) (PyArray_NDIM(tmp) >= 2 ? 27138 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 27139 (long int) (PyArray_NDIM(tmp) >= 1 ? 27140 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 27141 (long int) (PyArray_NDIM(tmp) >= 3 ? 27142 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 27143 (long int) (PyArray_NDIM(tmp) >= 2 ? 27144 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 27145 (long int) (PyArray_NDIM(tmp) >= 1 ? 27146 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 27147 ); 27148 { 27149 __failure = 496; 27150 if (!PyErr_Occurred()) { 27151 PyErr_SetString(PyExc_RuntimeError, 27152 "Unexpected error in an Op's C code. " 27153 "No Python exception was set."); 27154 } 27155 goto __label_496;} 27156 } 27157 // This is a TypeError to be consistent with DEBUG_MODE 27158 // Note: DEBUG_MODE also tells the name of the container 27159 if (PyArray_TYPE((PyArrayObject*) py_V495) != NPY_FLOAT64) { 27160 PyErr_Format(PyExc_TypeError, 27161 "expected type_num %d (NPY_FLOAT64) got %d", 27162 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V495)); 27163 { 27164 __failure = 496; 27165 if (!PyErr_Occurred()) { 27166 PyErr_SetString(PyExc_RuntimeError, 27167 "Unexpected error in an Op's C code. " 27168 "No Python exception was set."); 27169 } 27170 goto __label_496;} 27171 } 27172 27173 V495 = (PyArrayObject*)(py_V495); 27174 Py_XINCREF(V495); 27175 27176 { 27177 27178 py_V497 = PyList_GET_ITEM(storage_V497, 0); 27179 {Py_XINCREF(py_V497);} 27180 27181 V497 = NULL; 27182 if (py_V497 == Py_None) { 27183 // We can either fail here or set V497 to NULL and rely on Ops 27184 // using tensors to handle the NULL case, but if they fail to do so 27185 // they'll end up with nasty segfaults, so this is public service. 27186 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 27187 { 27188 __failure = 498; 27189 if (!PyErr_Occurred()) { 27190 PyErr_SetString(PyExc_RuntimeError, 27191 "Unexpected error in an Op's C code. " 27192 "No Python exception was set."); 27193 } 27194 goto __label_498;} 27195 } 27196 if (!PyArray_Check(py_V497)) { 27197 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 27198 { 27199 __failure = 498; 27200 if (!PyErr_Occurred()) { 27201 PyErr_SetString(PyExc_RuntimeError, 27202 "Unexpected error in an Op's C code. " 27203 "No Python exception was set."); 27204 } 27205 goto __label_498;} 27206 } 27207 // We expect NPY_FLOAT64 27208 if (!PyArray_ISALIGNED((PyArrayObject*) py_V497)) { 27209 PyArrayObject * tmp = (PyArrayObject*) py_V497; 27210 PyErr_Format(PyExc_NotImplementedError, 27211 "expected an aligned array of type %ld " 27212 "(NPY_FLOAT64), got non-aligned array of type %ld" 27213 " with %ld dimensions, with 3 last dims " 27214 "%ld, %ld, %ld" 27215 " and 3 last strides %ld %ld, %ld.", 27216 (long int) NPY_FLOAT64, 27217 (long int) PyArray_TYPE((PyArrayObject*) py_V497), 27218 (long int) PyArray_NDIM(tmp), 27219 (long int) (PyArray_NDIM(tmp) >= 3 ? 27220 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 27221 (long int) (PyArray_NDIM(tmp) >= 2 ? 27222 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 27223 (long int) (PyArray_NDIM(tmp) >= 1 ? 27224 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 27225 (long int) (PyArray_NDIM(tmp) >= 3 ? 27226 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 27227 (long int) (PyArray_NDIM(tmp) >= 2 ? 27228 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 27229 (long int) (PyArray_NDIM(tmp) >= 1 ? 27230 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 27231 ); 27232 { 27233 __failure = 498; 27234 if (!PyErr_Occurred()) { 27235 PyErr_SetString(PyExc_RuntimeError, 27236 "Unexpected error in an Op's C code. " 27237 "No Python exception was set."); 27238 } 27239 goto __label_498;} 27240 } 27241 // This is a TypeError to be consistent with DEBUG_MODE 27242 // Note: DEBUG_MODE also tells the name of the container 27243 if (PyArray_TYPE((PyArrayObject*) py_V497) != NPY_FLOAT64) { 27244 PyErr_Format(PyExc_TypeError, 27245 "expected type_num %d (NPY_FLOAT64) got %d", 27246 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V497)); 27247 { 27248 __failure = 498; 27249 if (!PyErr_Occurred()) { 27250 PyErr_SetString(PyExc_RuntimeError, 27251 "Unexpected error in an Op's C code. " 27252 "No Python exception was set."); 27253 } 27254 goto __label_498;} 27255 } 27256 27257 V497 = (PyArrayObject*)(py_V497); 27258 Py_XINCREF(V497); 27259 27260 { 27261 27262 py_V499 = PyList_GET_ITEM(storage_V499, 0); 27263 {Py_XINCREF(py_V499);} 27264 27265 V499 = NULL; 27266 if (py_V499 == Py_None) { 27267 // We can either fail here or set V499 to NULL and rely on Ops 27268 // using tensors to handle the NULL case, but if they fail to do so 27269 // they'll end up with nasty segfaults, so this is public service. 27270 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 27271 { 27272 __failure = 500; 27273 if (!PyErr_Occurred()) { 27274 PyErr_SetString(PyExc_RuntimeError, 27275 "Unexpected error in an Op's C code. " 27276 "No Python exception was set."); 27277 } 27278 goto __label_500;} 27279 } 27280 if (!PyArray_Check(py_V499)) { 27281 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 27282 { 27283 __failure = 500; 27284 if (!PyErr_Occurred()) { 27285 PyErr_SetString(PyExc_RuntimeError, 27286 "Unexpected error in an Op's C code. " 27287 "No Python exception was set."); 27288 } 27289 goto __label_500;} 27290 } 27291 // We expect NPY_FLOAT64 27292 if (!PyArray_ISALIGNED((PyArrayObject*) py_V499)) { 27293 PyArrayObject * tmp = (PyArrayObject*) py_V499; 27294 PyErr_Format(PyExc_NotImplementedError, 27295 "expected an aligned array of type %ld " 27296 "(NPY_FLOAT64), got non-aligned array of type %ld" 27297 " with %ld dimensions, with 3 last dims " 27298 "%ld, %ld, %ld" 27299 " and 3 last strides %ld %ld, %ld.", 27300 (long int) NPY_FLOAT64, 27301 (long int) PyArray_TYPE((PyArrayObject*) py_V499), 27302 (long int) PyArray_NDIM(tmp), 27303 (long int) (PyArray_NDIM(tmp) >= 3 ? 27304 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 27305 (long int) (PyArray_NDIM(tmp) >= 2 ? 27306 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 27307 (long int) (PyArray_NDIM(tmp) >= 1 ? 27308 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 27309 (long int) (PyArray_NDIM(tmp) >= 3 ? 27310 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 27311 (long int) (PyArray_NDIM(tmp) >= 2 ? 27312 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 27313 (long int) (PyArray_NDIM(tmp) >= 1 ? 27314 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 27315 ); 27316 { 27317 __failure = 500; 27318 if (!PyErr_Occurred()) { 27319 PyErr_SetString(PyExc_RuntimeError, 27320 "Unexpected error in an Op's C code. " 27321 "No Python exception was set."); 27322 } 27323 goto __label_500;} 27324 } 27325 // This is a TypeError to be consistent with DEBUG_MODE 27326 // Note: DEBUG_MODE also tells the name of the container 27327 if (PyArray_TYPE((PyArrayObject*) py_V499) != NPY_FLOAT64) { 27328 PyErr_Format(PyExc_TypeError, 27329 "expected type_num %d (NPY_FLOAT64) got %d", 27330 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V499)); 27331 { 27332 __failure = 500; 27333 if (!PyErr_Occurred()) { 27334 PyErr_SetString(PyExc_RuntimeError, 27335 "Unexpected error in an Op's C code. " 27336 "No Python exception was set."); 27337 } 27338 goto __label_500;} 27339 } 27340 27341 V499 = (PyArrayObject*)(py_V499); 27342 Py_XINCREF(V499); 27343 27344 { 27345 27346 py_V501 = PyList_GET_ITEM(storage_V501, 0); 27347 {Py_XINCREF(py_V501);} 27348 27349 V501 = NULL; 27350 if (py_V501 == Py_None) { 27351 // We can either fail here or set V501 to NULL and rely on Ops 27352 // using tensors to handle the NULL case, but if they fail to do so 27353 // they'll end up with nasty segfaults, so this is public service. 27354 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 27355 { 27356 __failure = 502; 27357 if (!PyErr_Occurred()) { 27358 PyErr_SetString(PyExc_RuntimeError, 27359 "Unexpected error in an Op's C code. " 27360 "No Python exception was set."); 27361 } 27362 goto __label_502;} 27363 } 27364 if (!PyArray_Check(py_V501)) { 27365 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 27366 { 27367 __failure = 502; 27368 if (!PyErr_Occurred()) { 27369 PyErr_SetString(PyExc_RuntimeError, 27370 "Unexpected error in an Op's C code. " 27371 "No Python exception was set."); 27372 } 27373 goto __label_502;} 27374 } 27375 // We expect NPY_FLOAT64 27376 if (!PyArray_ISALIGNED((PyArrayObject*) py_V501)) { 27377 PyArrayObject * tmp = (PyArrayObject*) py_V501; 27378 PyErr_Format(PyExc_NotImplementedError, 27379 "expected an aligned array of type %ld " 27380 "(NPY_FLOAT64), got non-aligned array of type %ld" 27381 " with %ld dimensions, with 3 last dims " 27382 "%ld, %ld, %ld" 27383 " and 3 last strides %ld %ld, %ld.", 27384 (long int) NPY_FLOAT64, 27385 (long int) PyArray_TYPE((PyArrayObject*) py_V501), 27386 (long int) PyArray_NDIM(tmp), 27387 (long int) (PyArray_NDIM(tmp) >= 3 ? 27388 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 27389 (long int) (PyArray_NDIM(tmp) >= 2 ? 27390 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 27391 (long int) (PyArray_NDIM(tmp) >= 1 ? 27392 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 27393 (long int) (PyArray_NDIM(tmp) >= 3 ? 27394 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 27395 (long int) (PyArray_NDIM(tmp) >= 2 ? 27396 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 27397 (long int) (PyArray_NDIM(tmp) >= 1 ? 27398 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 27399 ); 27400 { 27401 __failure = 502; 27402 if (!PyErr_Occurred()) { 27403 PyErr_SetString(PyExc_RuntimeError, 27404 "Unexpected error in an Op's C code. " 27405 "No Python exception was set."); 27406 } 27407 goto __label_502;} 27408 } 27409 // This is a TypeError to be consistent with DEBUG_MODE 27410 // Note: DEBUG_MODE also tells the name of the container 27411 if (PyArray_TYPE((PyArrayObject*) py_V501) != NPY_FLOAT64) { 27412 PyErr_Format(PyExc_TypeError, 27413 "expected type_num %d (NPY_FLOAT64) got %d", 27414 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V501)); 27415 { 27416 __failure = 502; 27417 if (!PyErr_Occurred()) { 27418 PyErr_SetString(PyExc_RuntimeError, 27419 "Unexpected error in an Op's C code. " 27420 "No Python exception was set."); 27421 } 27422 goto __label_502;} 27423 } 27424 27425 V501 = (PyArrayObject*)(py_V501); 27426 Py_XINCREF(V501); 27427 27428 { 27429 27430 py_V503 = PyList_GET_ITEM(storage_V503, 0); 27431 {Py_XINCREF(py_V503);} 27432 27433 V503 = NULL; 27434 if (py_V503 == Py_None) { 27435 // We can either fail here or set V503 to NULL and rely on Ops 27436 // using tensors to handle the NULL case, but if they fail to do so 27437 // they'll end up with nasty segfaults, so this is public service. 27438 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 27439 { 27440 __failure = 504; 27441 if (!PyErr_Occurred()) { 27442 PyErr_SetString(PyExc_RuntimeError, 27443 "Unexpected error in an Op's C code. " 27444 "No Python exception was set."); 27445 } 27446 goto __label_504;} 27447 } 27448 if (!PyArray_Check(py_V503)) { 27449 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 27450 { 27451 __failure = 504; 27452 if (!PyErr_Occurred()) { 27453 PyErr_SetString(PyExc_RuntimeError, 27454 "Unexpected error in an Op's C code. " 27455 "No Python exception was set."); 27456 } 27457 goto __label_504;} 27458 } 27459 // We expect NPY_FLOAT64 27460 if (!PyArray_ISALIGNED((PyArrayObject*) py_V503)) { 27461 PyArrayObject * tmp = (PyArrayObject*) py_V503; 27462 PyErr_Format(PyExc_NotImplementedError, 27463 "expected an aligned array of type %ld " 27464 "(NPY_FLOAT64), got non-aligned array of type %ld" 27465 " with %ld dimensions, with 3 last dims " 27466 "%ld, %ld, %ld" 27467 " and 3 last strides %ld %ld, %ld.", 27468 (long int) NPY_FLOAT64, 27469 (long int) PyArray_TYPE((PyArrayObject*) py_V503), 27470 (long int) PyArray_NDIM(tmp), 27471 (long int) (PyArray_NDIM(tmp) >= 3 ? 27472 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 27473 (long int) (PyArray_NDIM(tmp) >= 2 ? 27474 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 27475 (long int) (PyArray_NDIM(tmp) >= 1 ? 27476 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 27477 (long int) (PyArray_NDIM(tmp) >= 3 ? 27478 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 27479 (long int) (PyArray_NDIM(tmp) >= 2 ? 27480 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 27481 (long int) (PyArray_NDIM(tmp) >= 1 ? 27482 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 27483 ); 27484 { 27485 __failure = 504; 27486 if (!PyErr_Occurred()) { 27487 PyErr_SetString(PyExc_RuntimeError, 27488 "Unexpected error in an Op's C code. " 27489 "No Python exception was set."); 27490 } 27491 goto __label_504;} 27492 } 27493 // This is a TypeError to be consistent with DEBUG_MODE 27494 // Note: DEBUG_MODE also tells the name of the container 27495 if (PyArray_TYPE((PyArrayObject*) py_V503) != NPY_FLOAT64) { 27496 PyErr_Format(PyExc_TypeError, 27497 "expected type_num %d (NPY_FLOAT64) got %d", 27498 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V503)); 27499 { 27500 __failure = 504; 27501 if (!PyErr_Occurred()) { 27502 PyErr_SetString(PyExc_RuntimeError, 27503 "Unexpected error in an Op's C code. " 27504 "No Python exception was set."); 27505 } 27506 goto __label_504;} 27507 } 27508 27509 V503 = (PyArrayObject*)(py_V503); 27510 Py_XINCREF(V503); 27511 27512 { 27513 27514 py_V505 = PyList_GET_ITEM(storage_V505, 0); 27515 {Py_XINCREF(py_V505);} 27516 27517 V505 = NULL; 27518 if (py_V505 == Py_None) { 27519 // We can either fail here or set V505 to NULL and rely on Ops 27520 // using tensors to handle the NULL case, but if they fail to do so 27521 // they'll end up with nasty segfaults, so this is public service. 27522 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 27523 { 27524 __failure = 506; 27525 if (!PyErr_Occurred()) { 27526 PyErr_SetString(PyExc_RuntimeError, 27527 "Unexpected error in an Op's C code. " 27528 "No Python exception was set."); 27529 } 27530 goto __label_506;} 27531 } 27532 if (!PyArray_Check(py_V505)) { 27533 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 27534 { 27535 __failure = 506; 27536 if (!PyErr_Occurred()) { 27537 PyErr_SetString(PyExc_RuntimeError, 27538 "Unexpected error in an Op's C code. " 27539 "No Python exception was set."); 27540 } 27541 goto __label_506;} 27542 } 27543 // We expect NPY_FLOAT64 27544 if (!PyArray_ISALIGNED((PyArrayObject*) py_V505)) { 27545 PyArrayObject * tmp = (PyArrayObject*) py_V505; 27546 PyErr_Format(PyExc_NotImplementedError, 27547 "expected an aligned array of type %ld " 27548 "(NPY_FLOAT64), got non-aligned array of type %ld" 27549 " with %ld dimensions, with 3 last dims " 27550 "%ld, %ld, %ld" 27551 " and 3 last strides %ld %ld, %ld.", 27552 (long int) NPY_FLOAT64, 27553 (long int) PyArray_TYPE((PyArrayObject*) py_V505), 27554 (long int) PyArray_NDIM(tmp), 27555 (long int) (PyArray_NDIM(tmp) >= 3 ? 27556 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 27557 (long int) (PyArray_NDIM(tmp) >= 2 ? 27558 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 27559 (long int) (PyArray_NDIM(tmp) >= 1 ? 27560 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 27561 (long int) (PyArray_NDIM(tmp) >= 3 ? 27562 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 27563 (long int) (PyArray_NDIM(tmp) >= 2 ? 27564 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 27565 (long int) (PyArray_NDIM(tmp) >= 1 ? 27566 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 27567 ); 27568 { 27569 __failure = 506; 27570 if (!PyErr_Occurred()) { 27571 PyErr_SetString(PyExc_RuntimeError, 27572 "Unexpected error in an Op's C code. " 27573 "No Python exception was set."); 27574 } 27575 goto __label_506;} 27576 } 27577 // This is a TypeError to be consistent with DEBUG_MODE 27578 // Note: DEBUG_MODE also tells the name of the container 27579 if (PyArray_TYPE((PyArrayObject*) py_V505) != NPY_FLOAT64) { 27580 PyErr_Format(PyExc_TypeError, 27581 "expected type_num %d (NPY_FLOAT64) got %d", 27582 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V505)); 27583 { 27584 __failure = 506; 27585 if (!PyErr_Occurred()) { 27586 PyErr_SetString(PyExc_RuntimeError, 27587 "Unexpected error in an Op's C code. " 27588 "No Python exception was set."); 27589 } 27590 goto __label_506;} 27591 } 27592 27593 V505 = (PyArrayObject*)(py_V505); 27594 Py_XINCREF(V505); 27595 27596 { 27597 27598 py_V507 = PyList_GET_ITEM(storage_V507, 0); 27599 {Py_XINCREF(py_V507);} 27600 27601 V507 = NULL; 27602 if (py_V507 == Py_None) { 27603 // We can either fail here or set V507 to NULL and rely on Ops 27604 // using tensors to handle the NULL case, but if they fail to do so 27605 // they'll end up with nasty segfaults, so this is public service. 27606 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 27607 { 27608 __failure = 508; 27609 if (!PyErr_Occurred()) { 27610 PyErr_SetString(PyExc_RuntimeError, 27611 "Unexpected error in an Op's C code. " 27612 "No Python exception was set."); 27613 } 27614 goto __label_508;} 27615 } 27616 if (!PyArray_Check(py_V507)) { 27617 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 27618 { 27619 __failure = 508; 27620 if (!PyErr_Occurred()) { 27621 PyErr_SetString(PyExc_RuntimeError, 27622 "Unexpected error in an Op's C code. " 27623 "No Python exception was set."); 27624 } 27625 goto __label_508;} 27626 } 27627 // We expect NPY_FLOAT64 27628 if (!PyArray_ISALIGNED((PyArrayObject*) py_V507)) { 27629 PyArrayObject * tmp = (PyArrayObject*) py_V507; 27630 PyErr_Format(PyExc_NotImplementedError, 27631 "expected an aligned array of type %ld " 27632 "(NPY_FLOAT64), got non-aligned array of type %ld" 27633 " with %ld dimensions, with 3 last dims " 27634 "%ld, %ld, %ld" 27635 " and 3 last strides %ld %ld, %ld.", 27636 (long int) NPY_FLOAT64, 27637 (long int) PyArray_TYPE((PyArrayObject*) py_V507), 27638 (long int) PyArray_NDIM(tmp), 27639 (long int) (PyArray_NDIM(tmp) >= 3 ? 27640 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 27641 (long int) (PyArray_NDIM(tmp) >= 2 ? 27642 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 27643 (long int) (PyArray_NDIM(tmp) >= 1 ? 27644 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 27645 (long int) (PyArray_NDIM(tmp) >= 3 ? 27646 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 27647 (long int) (PyArray_NDIM(tmp) >= 2 ? 27648 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 27649 (long int) (PyArray_NDIM(tmp) >= 1 ? 27650 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 27651 ); 27652 { 27653 __failure = 508; 27654 if (!PyErr_Occurred()) { 27655 PyErr_SetString(PyExc_RuntimeError, 27656 "Unexpected error in an Op's C code. " 27657 "No Python exception was set."); 27658 } 27659 goto __label_508;} 27660 } 27661 // This is a TypeError to be consistent with DEBUG_MODE 27662 // Note: DEBUG_MODE also tells the name of the container 27663 if (PyArray_TYPE((PyArrayObject*) py_V507) != NPY_FLOAT64) { 27664 PyErr_Format(PyExc_TypeError, 27665 "expected type_num %d (NPY_FLOAT64) got %d", 27666 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V507)); 27667 { 27668 __failure = 508; 27669 if (!PyErr_Occurred()) { 27670 PyErr_SetString(PyExc_RuntimeError, 27671 "Unexpected error in an Op's C code. " 27672 "No Python exception was set."); 27673 } 27674 goto __label_508;} 27675 } 27676 27677 V507 = (PyArrayObject*)(py_V507); 27678 Py_XINCREF(V507); 27679 27680 { 27681 27682 py_V509 = PyList_GET_ITEM(storage_V509, 0); 27683 {Py_XINCREF(py_V509);} 27684 27685 V509 = NULL; 27686 if (py_V509 == Py_None) { 27687 // We can either fail here or set V509 to NULL and rely on Ops 27688 // using tensors to handle the NULL case, but if they fail to do so 27689 // they'll end up with nasty segfaults, so this is public service. 27690 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 27691 { 27692 __failure = 510; 27693 if (!PyErr_Occurred()) { 27694 PyErr_SetString(PyExc_RuntimeError, 27695 "Unexpected error in an Op's C code. " 27696 "No Python exception was set."); 27697 } 27698 goto __label_510;} 27699 } 27700 if (!PyArray_Check(py_V509)) { 27701 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 27702 { 27703 __failure = 510; 27704 if (!PyErr_Occurred()) { 27705 PyErr_SetString(PyExc_RuntimeError, 27706 "Unexpected error in an Op's C code. " 27707 "No Python exception was set."); 27708 } 27709 goto __label_510;} 27710 } 27711 // We expect NPY_FLOAT64 27712 if (!PyArray_ISALIGNED((PyArrayObject*) py_V509)) { 27713 PyArrayObject * tmp = (PyArrayObject*) py_V509; 27714 PyErr_Format(PyExc_NotImplementedError, 27715 "expected an aligned array of type %ld " 27716 "(NPY_FLOAT64), got non-aligned array of type %ld" 27717 " with %ld dimensions, with 3 last dims " 27718 "%ld, %ld, %ld" 27719 " and 3 last strides %ld %ld, %ld.", 27720 (long int) NPY_FLOAT64, 27721 (long int) PyArray_TYPE((PyArrayObject*) py_V509), 27722 (long int) PyArray_NDIM(tmp), 27723 (long int) (PyArray_NDIM(tmp) >= 3 ? 27724 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 27725 (long int) (PyArray_NDIM(tmp) >= 2 ? 27726 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 27727 (long int) (PyArray_NDIM(tmp) >= 1 ? 27728 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 27729 (long int) (PyArray_NDIM(tmp) >= 3 ? 27730 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 27731 (long int) (PyArray_NDIM(tmp) >= 2 ? 27732 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 27733 (long int) (PyArray_NDIM(tmp) >= 1 ? 27734 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 27735 ); 27736 { 27737 __failure = 510; 27738 if (!PyErr_Occurred()) { 27739 PyErr_SetString(PyExc_RuntimeError, 27740 "Unexpected error in an Op's C code. " 27741 "No Python exception was set."); 27742 } 27743 goto __label_510;} 27744 } 27745 // This is a TypeError to be consistent with DEBUG_MODE 27746 // Note: DEBUG_MODE also tells the name of the container 27747 if (PyArray_TYPE((PyArrayObject*) py_V509) != NPY_FLOAT64) { 27748 PyErr_Format(PyExc_TypeError, 27749 "expected type_num %d (NPY_FLOAT64) got %d", 27750 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V509)); 27751 { 27752 __failure = 510; 27753 if (!PyErr_Occurred()) { 27754 PyErr_SetString(PyExc_RuntimeError, 27755 "Unexpected error in an Op's C code. " 27756 "No Python exception was set."); 27757 } 27758 goto __label_510;} 27759 } 27760 27761 V509 = (PyArrayObject*)(py_V509); 27762 Py_XINCREF(V509); 27763 27764 { 27765 27766 py_V511 = PyList_GET_ITEM(storage_V511, 0); 27767 {Py_XINCREF(py_V511);} 27768 27769 V511 = NULL; 27770 if (py_V511 == Py_None) { 27771 // We can either fail here or set V511 to NULL and rely on Ops 27772 // using tensors to handle the NULL case, but if they fail to do so 27773 // they'll end up with nasty segfaults, so this is public service. 27774 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 27775 { 27776 __failure = 512; 27777 if (!PyErr_Occurred()) { 27778 PyErr_SetString(PyExc_RuntimeError, 27779 "Unexpected error in an Op's C code. " 27780 "No Python exception was set."); 27781 } 27782 goto __label_512;} 27783 } 27784 if (!PyArray_Check(py_V511)) { 27785 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 27786 { 27787 __failure = 512; 27788 if (!PyErr_Occurred()) { 27789 PyErr_SetString(PyExc_RuntimeError, 27790 "Unexpected error in an Op's C code. " 27791 "No Python exception was set."); 27792 } 27793 goto __label_512;} 27794 } 27795 // We expect NPY_FLOAT64 27796 if (!PyArray_ISALIGNED((PyArrayObject*) py_V511)) { 27797 PyArrayObject * tmp = (PyArrayObject*) py_V511; 27798 PyErr_Format(PyExc_NotImplementedError, 27799 "expected an aligned array of type %ld " 27800 "(NPY_FLOAT64), got non-aligned array of type %ld" 27801 " with %ld dimensions, with 3 last dims " 27802 "%ld, %ld, %ld" 27803 " and 3 last strides %ld %ld, %ld.", 27804 (long int) NPY_FLOAT64, 27805 (long int) PyArray_TYPE((PyArrayObject*) py_V511), 27806 (long int) PyArray_NDIM(tmp), 27807 (long int) (PyArray_NDIM(tmp) >= 3 ? 27808 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 27809 (long int) (PyArray_NDIM(tmp) >= 2 ? 27810 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 27811 (long int) (PyArray_NDIM(tmp) >= 1 ? 27812 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 27813 (long int) (PyArray_NDIM(tmp) >= 3 ? 27814 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 27815 (long int) (PyArray_NDIM(tmp) >= 2 ? 27816 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 27817 (long int) (PyArray_NDIM(tmp) >= 1 ? 27818 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 27819 ); 27820 { 27821 __failure = 512; 27822 if (!PyErr_Occurred()) { 27823 PyErr_SetString(PyExc_RuntimeError, 27824 "Unexpected error in an Op's C code. " 27825 "No Python exception was set."); 27826 } 27827 goto __label_512;} 27828 } 27829 // This is a TypeError to be consistent with DEBUG_MODE 27830 // Note: DEBUG_MODE also tells the name of the container 27831 if (PyArray_TYPE((PyArrayObject*) py_V511) != NPY_FLOAT64) { 27832 PyErr_Format(PyExc_TypeError, 27833 "expected type_num %d (NPY_FLOAT64) got %d", 27834 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V511)); 27835 { 27836 __failure = 512; 27837 if (!PyErr_Occurred()) { 27838 PyErr_SetString(PyExc_RuntimeError, 27839 "Unexpected error in an Op's C code. " 27840 "No Python exception was set."); 27841 } 27842 goto __label_512;} 27843 } 27844 27845 V511 = (PyArrayObject*)(py_V511); 27846 Py_XINCREF(V511); 27847 27848 { 27849 27850 py_V513 = PyList_GET_ITEM(storage_V513, 0); 27851 {Py_XINCREF(py_V513);} 27852 27853 V513 = NULL; 27854 if (py_V513 == Py_None) { 27855 // We can either fail here or set V513 to NULL and rely on Ops 27856 // using tensors to handle the NULL case, but if they fail to do so 27857 // they'll end up with nasty segfaults, so this is public service. 27858 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 27859 { 27860 __failure = 514; 27861 if (!PyErr_Occurred()) { 27862 PyErr_SetString(PyExc_RuntimeError, 27863 "Unexpected error in an Op's C code. " 27864 "No Python exception was set."); 27865 } 27866 goto __label_514;} 27867 } 27868 if (!PyArray_Check(py_V513)) { 27869 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 27870 { 27871 __failure = 514; 27872 if (!PyErr_Occurred()) { 27873 PyErr_SetString(PyExc_RuntimeError, 27874 "Unexpected error in an Op's C code. " 27875 "No Python exception was set."); 27876 } 27877 goto __label_514;} 27878 } 27879 // We expect NPY_FLOAT64 27880 if (!PyArray_ISALIGNED((PyArrayObject*) py_V513)) { 27881 PyArrayObject * tmp = (PyArrayObject*) py_V513; 27882 PyErr_Format(PyExc_NotImplementedError, 27883 "expected an aligned array of type %ld " 27884 "(NPY_FLOAT64), got non-aligned array of type %ld" 27885 " with %ld dimensions, with 3 last dims " 27886 "%ld, %ld, %ld" 27887 " and 3 last strides %ld %ld, %ld.", 27888 (long int) NPY_FLOAT64, 27889 (long int) PyArray_TYPE((PyArrayObject*) py_V513), 27890 (long int) PyArray_NDIM(tmp), 27891 (long int) (PyArray_NDIM(tmp) >= 3 ? 27892 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 27893 (long int) (PyArray_NDIM(tmp) >= 2 ? 27894 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 27895 (long int) (PyArray_NDIM(tmp) >= 1 ? 27896 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 27897 (long int) (PyArray_NDIM(tmp) >= 3 ? 27898 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 27899 (long int) (PyArray_NDIM(tmp) >= 2 ? 27900 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 27901 (long int) (PyArray_NDIM(tmp) >= 1 ? 27902 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 27903 ); 27904 { 27905 __failure = 514; 27906 if (!PyErr_Occurred()) { 27907 PyErr_SetString(PyExc_RuntimeError, 27908 "Unexpected error in an Op's C code. " 27909 "No Python exception was set."); 27910 } 27911 goto __label_514;} 27912 } 27913 // This is a TypeError to be consistent with DEBUG_MODE 27914 // Note: DEBUG_MODE also tells the name of the container 27915 if (PyArray_TYPE((PyArrayObject*) py_V513) != NPY_FLOAT64) { 27916 PyErr_Format(PyExc_TypeError, 27917 "expected type_num %d (NPY_FLOAT64) got %d", 27918 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V513)); 27919 { 27920 __failure = 514; 27921 if (!PyErr_Occurred()) { 27922 PyErr_SetString(PyExc_RuntimeError, 27923 "Unexpected error in an Op's C code. " 27924 "No Python exception was set."); 27925 } 27926 goto __label_514;} 27927 } 27928 27929 V513 = (PyArrayObject*)(py_V513); 27930 Py_XINCREF(V513); 27931 27932 { 27933 27934 py_V515 = PyList_GET_ITEM(storage_V515, 0); 27935 {Py_XINCREF(py_V515);} 27936 27937 V515 = NULL; 27938 if (py_V515 == Py_None) { 27939 // We can either fail here or set V515 to NULL and rely on Ops 27940 // using tensors to handle the NULL case, but if they fail to do so 27941 // they'll end up with nasty segfaults, so this is public service. 27942 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 27943 { 27944 __failure = 516; 27945 if (!PyErr_Occurred()) { 27946 PyErr_SetString(PyExc_RuntimeError, 27947 "Unexpected error in an Op's C code. " 27948 "No Python exception was set."); 27949 } 27950 goto __label_516;} 27951 } 27952 if (!PyArray_Check(py_V515)) { 27953 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 27954 { 27955 __failure = 516; 27956 if (!PyErr_Occurred()) { 27957 PyErr_SetString(PyExc_RuntimeError, 27958 "Unexpected error in an Op's C code. " 27959 "No Python exception was set."); 27960 } 27961 goto __label_516;} 27962 } 27963 // We expect NPY_FLOAT64 27964 if (!PyArray_ISALIGNED((PyArrayObject*) py_V515)) { 27965 PyArrayObject * tmp = (PyArrayObject*) py_V515; 27966 PyErr_Format(PyExc_NotImplementedError, 27967 "expected an aligned array of type %ld " 27968 "(NPY_FLOAT64), got non-aligned array of type %ld" 27969 " with %ld dimensions, with 3 last dims " 27970 "%ld, %ld, %ld" 27971 " and 3 last strides %ld %ld, %ld.", 27972 (long int) NPY_FLOAT64, 27973 (long int) PyArray_TYPE((PyArrayObject*) py_V515), 27974 (long int) PyArray_NDIM(tmp), 27975 (long int) (PyArray_NDIM(tmp) >= 3 ? 27976 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 27977 (long int) (PyArray_NDIM(tmp) >= 2 ? 27978 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 27979 (long int) (PyArray_NDIM(tmp) >= 1 ? 27980 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 27981 (long int) (PyArray_NDIM(tmp) >= 3 ? 27982 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 27983 (long int) (PyArray_NDIM(tmp) >= 2 ? 27984 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 27985 (long int) (PyArray_NDIM(tmp) >= 1 ? 27986 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 27987 ); 27988 { 27989 __failure = 516; 27990 if (!PyErr_Occurred()) { 27991 PyErr_SetString(PyExc_RuntimeError, 27992 "Unexpected error in an Op's C code. " 27993 "No Python exception was set."); 27994 } 27995 goto __label_516;} 27996 } 27997 // This is a TypeError to be consistent with DEBUG_MODE 27998 // Note: DEBUG_MODE also tells the name of the container 27999 if (PyArray_TYPE((PyArrayObject*) py_V515) != NPY_FLOAT64) { 28000 PyErr_Format(PyExc_TypeError, 28001 "expected type_num %d (NPY_FLOAT64) got %d", 28002 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V515)); 28003 { 28004 __failure = 516; 28005 if (!PyErr_Occurred()) { 28006 PyErr_SetString(PyExc_RuntimeError, 28007 "Unexpected error in an Op's C code. " 28008 "No Python exception was set."); 28009 } 28010 goto __label_516;} 28011 } 28012 28013 V515 = (PyArrayObject*)(py_V515); 28014 Py_XINCREF(V515); 28015 28016 { 28017 28018 py_V517 = PyList_GET_ITEM(storage_V517, 0); 28019 {Py_XINCREF(py_V517);} 28020 28021 V517 = NULL; 28022 if (py_V517 == Py_None) { 28023 // We can either fail here or set V517 to NULL and rely on Ops 28024 // using tensors to handle the NULL case, but if they fail to do so 28025 // they'll end up with nasty segfaults, so this is public service. 28026 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 28027 { 28028 __failure = 518; 28029 if (!PyErr_Occurred()) { 28030 PyErr_SetString(PyExc_RuntimeError, 28031 "Unexpected error in an Op's C code. " 28032 "No Python exception was set."); 28033 } 28034 goto __label_518;} 28035 } 28036 if (!PyArray_Check(py_V517)) { 28037 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 28038 { 28039 __failure = 518; 28040 if (!PyErr_Occurred()) { 28041 PyErr_SetString(PyExc_RuntimeError, 28042 "Unexpected error in an Op's C code. " 28043 "No Python exception was set."); 28044 } 28045 goto __label_518;} 28046 } 28047 // We expect NPY_FLOAT64 28048 if (!PyArray_ISALIGNED((PyArrayObject*) py_V517)) { 28049 PyArrayObject * tmp = (PyArrayObject*) py_V517; 28050 PyErr_Format(PyExc_NotImplementedError, 28051 "expected an aligned array of type %ld " 28052 "(NPY_FLOAT64), got non-aligned array of type %ld" 28053 " with %ld dimensions, with 3 last dims " 28054 "%ld, %ld, %ld" 28055 " and 3 last strides %ld %ld, %ld.", 28056 (long int) NPY_FLOAT64, 28057 (long int) PyArray_TYPE((PyArrayObject*) py_V517), 28058 (long int) PyArray_NDIM(tmp), 28059 (long int) (PyArray_NDIM(tmp) >= 3 ? 28060 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 28061 (long int) (PyArray_NDIM(tmp) >= 2 ? 28062 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 28063 (long int) (PyArray_NDIM(tmp) >= 1 ? 28064 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 28065 (long int) (PyArray_NDIM(tmp) >= 3 ? 28066 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 28067 (long int) (PyArray_NDIM(tmp) >= 2 ? 28068 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 28069 (long int) (PyArray_NDIM(tmp) >= 1 ? 28070 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 28071 ); 28072 { 28073 __failure = 518; 28074 if (!PyErr_Occurred()) { 28075 PyErr_SetString(PyExc_RuntimeError, 28076 "Unexpected error in an Op's C code. " 28077 "No Python exception was set."); 28078 } 28079 goto __label_518;} 28080 } 28081 // This is a TypeError to be consistent with DEBUG_MODE 28082 // Note: DEBUG_MODE also tells the name of the container 28083 if (PyArray_TYPE((PyArrayObject*) py_V517) != NPY_FLOAT64) { 28084 PyErr_Format(PyExc_TypeError, 28085 "expected type_num %d (NPY_FLOAT64) got %d", 28086 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V517)); 28087 { 28088 __failure = 518; 28089 if (!PyErr_Occurred()) { 28090 PyErr_SetString(PyExc_RuntimeError, 28091 "Unexpected error in an Op's C code. " 28092 "No Python exception was set."); 28093 } 28094 goto __label_518;} 28095 } 28096 28097 V517 = (PyArrayObject*)(py_V517); 28098 Py_XINCREF(V517); 28099 28100 { 28101 28102 py_V519 = PyList_GET_ITEM(storage_V519, 0); 28103 {Py_XINCREF(py_V519);} 28104 28105 V519 = NULL; 28106 if (py_V519 == Py_None) { 28107 // We can either fail here or set V519 to NULL and rely on Ops 28108 // using tensors to handle the NULL case, but if they fail to do so 28109 // they'll end up with nasty segfaults, so this is public service. 28110 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 28111 { 28112 __failure = 520; 28113 if (!PyErr_Occurred()) { 28114 PyErr_SetString(PyExc_RuntimeError, 28115 "Unexpected error in an Op's C code. " 28116 "No Python exception was set."); 28117 } 28118 goto __label_520;} 28119 } 28120 if (!PyArray_Check(py_V519)) { 28121 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 28122 { 28123 __failure = 520; 28124 if (!PyErr_Occurred()) { 28125 PyErr_SetString(PyExc_RuntimeError, 28126 "Unexpected error in an Op's C code. " 28127 "No Python exception was set."); 28128 } 28129 goto __label_520;} 28130 } 28131 // We expect NPY_FLOAT64 28132 if (!PyArray_ISALIGNED((PyArrayObject*) py_V519)) { 28133 PyArrayObject * tmp = (PyArrayObject*) py_V519; 28134 PyErr_Format(PyExc_NotImplementedError, 28135 "expected an aligned array of type %ld " 28136 "(NPY_FLOAT64), got non-aligned array of type %ld" 28137 " with %ld dimensions, with 3 last dims " 28138 "%ld, %ld, %ld" 28139 " and 3 last strides %ld %ld, %ld.", 28140 (long int) NPY_FLOAT64, 28141 (long int) PyArray_TYPE((PyArrayObject*) py_V519), 28142 (long int) PyArray_NDIM(tmp), 28143 (long int) (PyArray_NDIM(tmp) >= 3 ? 28144 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 28145 (long int) (PyArray_NDIM(tmp) >= 2 ? 28146 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 28147 (long int) (PyArray_NDIM(tmp) >= 1 ? 28148 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 28149 (long int) (PyArray_NDIM(tmp) >= 3 ? 28150 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 28151 (long int) (PyArray_NDIM(tmp) >= 2 ? 28152 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 28153 (long int) (PyArray_NDIM(tmp) >= 1 ? 28154 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 28155 ); 28156 { 28157 __failure = 520; 28158 if (!PyErr_Occurred()) { 28159 PyErr_SetString(PyExc_RuntimeError, 28160 "Unexpected error in an Op's C code. " 28161 "No Python exception was set."); 28162 } 28163 goto __label_520;} 28164 } 28165 // This is a TypeError to be consistent with DEBUG_MODE 28166 // Note: DEBUG_MODE also tells the name of the container 28167 if (PyArray_TYPE((PyArrayObject*) py_V519) != NPY_FLOAT64) { 28168 PyErr_Format(PyExc_TypeError, 28169 "expected type_num %d (NPY_FLOAT64) got %d", 28170 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V519)); 28171 { 28172 __failure = 520; 28173 if (!PyErr_Occurred()) { 28174 PyErr_SetString(PyExc_RuntimeError, 28175 "Unexpected error in an Op's C code. " 28176 "No Python exception was set."); 28177 } 28178 goto __label_520;} 28179 } 28180 28181 V519 = (PyArrayObject*)(py_V519); 28182 Py_XINCREF(V519); 28183 28184 { 28185 28186 py_V521 = PyList_GET_ITEM(storage_V521, 0); 28187 {Py_XINCREF(py_V521);} 28188 28189 V521 = NULL; 28190 if (py_V521 == Py_None) { 28191 // We can either fail here or set V521 to NULL and rely on Ops 28192 // using tensors to handle the NULL case, but if they fail to do so 28193 // they'll end up with nasty segfaults, so this is public service. 28194 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 28195 { 28196 __failure = 522; 28197 if (!PyErr_Occurred()) { 28198 PyErr_SetString(PyExc_RuntimeError, 28199 "Unexpected error in an Op's C code. " 28200 "No Python exception was set."); 28201 } 28202 goto __label_522;} 28203 } 28204 if (!PyArray_Check(py_V521)) { 28205 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 28206 { 28207 __failure = 522; 28208 if (!PyErr_Occurred()) { 28209 PyErr_SetString(PyExc_RuntimeError, 28210 "Unexpected error in an Op's C code. " 28211 "No Python exception was set."); 28212 } 28213 goto __label_522;} 28214 } 28215 // We expect NPY_FLOAT64 28216 if (!PyArray_ISALIGNED((PyArrayObject*) py_V521)) { 28217 PyArrayObject * tmp = (PyArrayObject*) py_V521; 28218 PyErr_Format(PyExc_NotImplementedError, 28219 "expected an aligned array of type %ld " 28220 "(NPY_FLOAT64), got non-aligned array of type %ld" 28221 " with %ld dimensions, with 3 last dims " 28222 "%ld, %ld, %ld" 28223 " and 3 last strides %ld %ld, %ld.", 28224 (long int) NPY_FLOAT64, 28225 (long int) PyArray_TYPE((PyArrayObject*) py_V521), 28226 (long int) PyArray_NDIM(tmp), 28227 (long int) (PyArray_NDIM(tmp) >= 3 ? 28228 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 28229 (long int) (PyArray_NDIM(tmp) >= 2 ? 28230 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 28231 (long int) (PyArray_NDIM(tmp) >= 1 ? 28232 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 28233 (long int) (PyArray_NDIM(tmp) >= 3 ? 28234 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 28235 (long int) (PyArray_NDIM(tmp) >= 2 ? 28236 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 28237 (long int) (PyArray_NDIM(tmp) >= 1 ? 28238 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 28239 ); 28240 { 28241 __failure = 522; 28242 if (!PyErr_Occurred()) { 28243 PyErr_SetString(PyExc_RuntimeError, 28244 "Unexpected error in an Op's C code. " 28245 "No Python exception was set."); 28246 } 28247 goto __label_522;} 28248 } 28249 // This is a TypeError to be consistent with DEBUG_MODE 28250 // Note: DEBUG_MODE also tells the name of the container 28251 if (PyArray_TYPE((PyArrayObject*) py_V521) != NPY_FLOAT64) { 28252 PyErr_Format(PyExc_TypeError, 28253 "expected type_num %d (NPY_FLOAT64) got %d", 28254 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V521)); 28255 { 28256 __failure = 522; 28257 if (!PyErr_Occurred()) { 28258 PyErr_SetString(PyExc_RuntimeError, 28259 "Unexpected error in an Op's C code. " 28260 "No Python exception was set."); 28261 } 28262 goto __label_522;} 28263 } 28264 28265 V521 = (PyArrayObject*)(py_V521); 28266 Py_XINCREF(V521); 28267 28268 { 28269 28270 py_V523 = PyList_GET_ITEM(storage_V523, 0); 28271 {Py_XINCREF(py_V523);} 28272 28273 V523 = NULL; 28274 if (py_V523 == Py_None) { 28275 // We can either fail here or set V523 to NULL and rely on Ops 28276 // using tensors to handle the NULL case, but if they fail to do so 28277 // they'll end up with nasty segfaults, so this is public service. 28278 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 28279 { 28280 __failure = 524; 28281 if (!PyErr_Occurred()) { 28282 PyErr_SetString(PyExc_RuntimeError, 28283 "Unexpected error in an Op's C code. " 28284 "No Python exception was set."); 28285 } 28286 goto __label_524;} 28287 } 28288 if (!PyArray_Check(py_V523)) { 28289 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 28290 { 28291 __failure = 524; 28292 if (!PyErr_Occurred()) { 28293 PyErr_SetString(PyExc_RuntimeError, 28294 "Unexpected error in an Op's C code. " 28295 "No Python exception was set."); 28296 } 28297 goto __label_524;} 28298 } 28299 // We expect NPY_FLOAT64 28300 if (!PyArray_ISALIGNED((PyArrayObject*) py_V523)) { 28301 PyArrayObject * tmp = (PyArrayObject*) py_V523; 28302 PyErr_Format(PyExc_NotImplementedError, 28303 "expected an aligned array of type %ld " 28304 "(NPY_FLOAT64), got non-aligned array of type %ld" 28305 " with %ld dimensions, with 3 last dims " 28306 "%ld, %ld, %ld" 28307 " and 3 last strides %ld %ld, %ld.", 28308 (long int) NPY_FLOAT64, 28309 (long int) PyArray_TYPE((PyArrayObject*) py_V523), 28310 (long int) PyArray_NDIM(tmp), 28311 (long int) (PyArray_NDIM(tmp) >= 3 ? 28312 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 28313 (long int) (PyArray_NDIM(tmp) >= 2 ? 28314 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 28315 (long int) (PyArray_NDIM(tmp) >= 1 ? 28316 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 28317 (long int) (PyArray_NDIM(tmp) >= 3 ? 28318 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 28319 (long int) (PyArray_NDIM(tmp) >= 2 ? 28320 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 28321 (long int) (PyArray_NDIM(tmp) >= 1 ? 28322 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 28323 ); 28324 { 28325 __failure = 524; 28326 if (!PyErr_Occurred()) { 28327 PyErr_SetString(PyExc_RuntimeError, 28328 "Unexpected error in an Op's C code. " 28329 "No Python exception was set."); 28330 } 28331 goto __label_524;} 28332 } 28333 // This is a TypeError to be consistent with DEBUG_MODE 28334 // Note: DEBUG_MODE also tells the name of the container 28335 if (PyArray_TYPE((PyArrayObject*) py_V523) != NPY_FLOAT64) { 28336 PyErr_Format(PyExc_TypeError, 28337 "expected type_num %d (NPY_FLOAT64) got %d", 28338 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V523)); 28339 { 28340 __failure = 524; 28341 if (!PyErr_Occurred()) { 28342 PyErr_SetString(PyExc_RuntimeError, 28343 "Unexpected error in an Op's C code. " 28344 "No Python exception was set."); 28345 } 28346 goto __label_524;} 28347 } 28348 28349 V523 = (PyArrayObject*)(py_V523); 28350 Py_XINCREF(V523); 28351 28352 { 28353 28354 py_V525 = PyList_GET_ITEM(storage_V525, 0); 28355 {Py_XINCREF(py_V525);} 28356 28357 V525 = NULL; 28358 if (py_V525 == Py_None) { 28359 // We can either fail here or set V525 to NULL and rely on Ops 28360 // using tensors to handle the NULL case, but if they fail to do so 28361 // they'll end up with nasty segfaults, so this is public service. 28362 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 28363 { 28364 __failure = 526; 28365 if (!PyErr_Occurred()) { 28366 PyErr_SetString(PyExc_RuntimeError, 28367 "Unexpected error in an Op's C code. " 28368 "No Python exception was set."); 28369 } 28370 goto __label_526;} 28371 } 28372 if (!PyArray_Check(py_V525)) { 28373 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 28374 { 28375 __failure = 526; 28376 if (!PyErr_Occurred()) { 28377 PyErr_SetString(PyExc_RuntimeError, 28378 "Unexpected error in an Op's C code. " 28379 "No Python exception was set."); 28380 } 28381 goto __label_526;} 28382 } 28383 // We expect NPY_FLOAT64 28384 if (!PyArray_ISALIGNED((PyArrayObject*) py_V525)) { 28385 PyArrayObject * tmp = (PyArrayObject*) py_V525; 28386 PyErr_Format(PyExc_NotImplementedError, 28387 "expected an aligned array of type %ld " 28388 "(NPY_FLOAT64), got non-aligned array of type %ld" 28389 " with %ld dimensions, with 3 last dims " 28390 "%ld, %ld, %ld" 28391 " and 3 last strides %ld %ld, %ld.", 28392 (long int) NPY_FLOAT64, 28393 (long int) PyArray_TYPE((PyArrayObject*) py_V525), 28394 (long int) PyArray_NDIM(tmp), 28395 (long int) (PyArray_NDIM(tmp) >= 3 ? 28396 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 28397 (long int) (PyArray_NDIM(tmp) >= 2 ? 28398 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 28399 (long int) (PyArray_NDIM(tmp) >= 1 ? 28400 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 28401 (long int) (PyArray_NDIM(tmp) >= 3 ? 28402 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 28403 (long int) (PyArray_NDIM(tmp) >= 2 ? 28404 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 28405 (long int) (PyArray_NDIM(tmp) >= 1 ? 28406 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 28407 ); 28408 { 28409 __failure = 526; 28410 if (!PyErr_Occurred()) { 28411 PyErr_SetString(PyExc_RuntimeError, 28412 "Unexpected error in an Op's C code. " 28413 "No Python exception was set."); 28414 } 28415 goto __label_526;} 28416 } 28417 // This is a TypeError to be consistent with DEBUG_MODE 28418 // Note: DEBUG_MODE also tells the name of the container 28419 if (PyArray_TYPE((PyArrayObject*) py_V525) != NPY_FLOAT64) { 28420 PyErr_Format(PyExc_TypeError, 28421 "expected type_num %d (NPY_FLOAT64) got %d", 28422 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V525)); 28423 { 28424 __failure = 526; 28425 if (!PyErr_Occurred()) { 28426 PyErr_SetString(PyExc_RuntimeError, 28427 "Unexpected error in an Op's C code. " 28428 "No Python exception was set."); 28429 } 28430 goto __label_526;} 28431 } 28432 28433 V525 = (PyArrayObject*)(py_V525); 28434 Py_XINCREF(V525); 28435 28436 { 28437 28438 py_V527 = PyList_GET_ITEM(storage_V527, 0); 28439 {Py_XINCREF(py_V527);} 28440 28441 V527 = NULL; 28442 if (py_V527 == Py_None) { 28443 // We can either fail here or set V527 to NULL and rely on Ops 28444 // using tensors to handle the NULL case, but if they fail to do so 28445 // they'll end up with nasty segfaults, so this is public service. 28446 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 28447 { 28448 __failure = 528; 28449 if (!PyErr_Occurred()) { 28450 PyErr_SetString(PyExc_RuntimeError, 28451 "Unexpected error in an Op's C code. " 28452 "No Python exception was set."); 28453 } 28454 goto __label_528;} 28455 } 28456 if (!PyArray_Check(py_V527)) { 28457 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 28458 { 28459 __failure = 528; 28460 if (!PyErr_Occurred()) { 28461 PyErr_SetString(PyExc_RuntimeError, 28462 "Unexpected error in an Op's C code. " 28463 "No Python exception was set."); 28464 } 28465 goto __label_528;} 28466 } 28467 // We expect NPY_FLOAT64 28468 if (!PyArray_ISALIGNED((PyArrayObject*) py_V527)) { 28469 PyArrayObject * tmp = (PyArrayObject*) py_V527; 28470 PyErr_Format(PyExc_NotImplementedError, 28471 "expected an aligned array of type %ld " 28472 "(NPY_FLOAT64), got non-aligned array of type %ld" 28473 " with %ld dimensions, with 3 last dims " 28474 "%ld, %ld, %ld" 28475 " and 3 last strides %ld %ld, %ld.", 28476 (long int) NPY_FLOAT64, 28477 (long int) PyArray_TYPE((PyArrayObject*) py_V527), 28478 (long int) PyArray_NDIM(tmp), 28479 (long int) (PyArray_NDIM(tmp) >= 3 ? 28480 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 28481 (long int) (PyArray_NDIM(tmp) >= 2 ? 28482 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 28483 (long int) (PyArray_NDIM(tmp) >= 1 ? 28484 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 28485 (long int) (PyArray_NDIM(tmp) >= 3 ? 28486 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 28487 (long int) (PyArray_NDIM(tmp) >= 2 ? 28488 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 28489 (long int) (PyArray_NDIM(tmp) >= 1 ? 28490 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 28491 ); 28492 { 28493 __failure = 528; 28494 if (!PyErr_Occurred()) { 28495 PyErr_SetString(PyExc_RuntimeError, 28496 "Unexpected error in an Op's C code. " 28497 "No Python exception was set."); 28498 } 28499 goto __label_528;} 28500 } 28501 // This is a TypeError to be consistent with DEBUG_MODE 28502 // Note: DEBUG_MODE also tells the name of the container 28503 if (PyArray_TYPE((PyArrayObject*) py_V527) != NPY_FLOAT64) { 28504 PyErr_Format(PyExc_TypeError, 28505 "expected type_num %d (NPY_FLOAT64) got %d", 28506 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V527)); 28507 { 28508 __failure = 528; 28509 if (!PyErr_Occurred()) { 28510 PyErr_SetString(PyExc_RuntimeError, 28511 "Unexpected error in an Op's C code. " 28512 "No Python exception was set."); 28513 } 28514 goto __label_528;} 28515 } 28516 28517 V527 = (PyArrayObject*)(py_V527); 28518 Py_XINCREF(V527); 28519 28520 { 28521 28522 py_V529 = PyList_GET_ITEM(storage_V529, 0); 28523 {Py_XINCREF(py_V529);} 28524 28525 V529 = NULL; 28526 if (py_V529 == Py_None) { 28527 // We can either fail here or set V529 to NULL and rely on Ops 28528 // using tensors to handle the NULL case, but if they fail to do so 28529 // they'll end up with nasty segfaults, so this is public service. 28530 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 28531 { 28532 __failure = 530; 28533 if (!PyErr_Occurred()) { 28534 PyErr_SetString(PyExc_RuntimeError, 28535 "Unexpected error in an Op's C code. " 28536 "No Python exception was set."); 28537 } 28538 goto __label_530;} 28539 } 28540 if (!PyArray_Check(py_V529)) { 28541 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 28542 { 28543 __failure = 530; 28544 if (!PyErr_Occurred()) { 28545 PyErr_SetString(PyExc_RuntimeError, 28546 "Unexpected error in an Op's C code. " 28547 "No Python exception was set."); 28548 } 28549 goto __label_530;} 28550 } 28551 // We expect NPY_FLOAT64 28552 if (!PyArray_ISALIGNED((PyArrayObject*) py_V529)) { 28553 PyArrayObject * tmp = (PyArrayObject*) py_V529; 28554 PyErr_Format(PyExc_NotImplementedError, 28555 "expected an aligned array of type %ld " 28556 "(NPY_FLOAT64), got non-aligned array of type %ld" 28557 " with %ld dimensions, with 3 last dims " 28558 "%ld, %ld, %ld" 28559 " and 3 last strides %ld %ld, %ld.", 28560 (long int) NPY_FLOAT64, 28561 (long int) PyArray_TYPE((PyArrayObject*) py_V529), 28562 (long int) PyArray_NDIM(tmp), 28563 (long int) (PyArray_NDIM(tmp) >= 3 ? 28564 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 28565 (long int) (PyArray_NDIM(tmp) >= 2 ? 28566 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 28567 (long int) (PyArray_NDIM(tmp) >= 1 ? 28568 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 28569 (long int) (PyArray_NDIM(tmp) >= 3 ? 28570 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 28571 (long int) (PyArray_NDIM(tmp) >= 2 ? 28572 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 28573 (long int) (PyArray_NDIM(tmp) >= 1 ? 28574 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 28575 ); 28576 { 28577 __failure = 530; 28578 if (!PyErr_Occurred()) { 28579 PyErr_SetString(PyExc_RuntimeError, 28580 "Unexpected error in an Op's C code. " 28581 "No Python exception was set."); 28582 } 28583 goto __label_530;} 28584 } 28585 // This is a TypeError to be consistent with DEBUG_MODE 28586 // Note: DEBUG_MODE also tells the name of the container 28587 if (PyArray_TYPE((PyArrayObject*) py_V529) != NPY_FLOAT64) { 28588 PyErr_Format(PyExc_TypeError, 28589 "expected type_num %d (NPY_FLOAT64) got %d", 28590 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V529)); 28591 { 28592 __failure = 530; 28593 if (!PyErr_Occurred()) { 28594 PyErr_SetString(PyExc_RuntimeError, 28595 "Unexpected error in an Op's C code. " 28596 "No Python exception was set."); 28597 } 28598 goto __label_530;} 28599 } 28600 28601 V529 = (PyArrayObject*)(py_V529); 28602 Py_XINCREF(V529); 28603 28604 { 28605 28606 py_V531 = PyList_GET_ITEM(storage_V531, 0); 28607 {Py_XINCREF(py_V531);} 28608 28609 V531 = NULL; 28610 if (py_V531 == Py_None) { 28611 // We can either fail here or set V531 to NULL and rely on Ops 28612 // using tensors to handle the NULL case, but if they fail to do so 28613 // they'll end up with nasty segfaults, so this is public service. 28614 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 28615 { 28616 __failure = 532; 28617 if (!PyErr_Occurred()) { 28618 PyErr_SetString(PyExc_RuntimeError, 28619 "Unexpected error in an Op's C code. " 28620 "No Python exception was set."); 28621 } 28622 goto __label_532;} 28623 } 28624 if (!PyArray_Check(py_V531)) { 28625 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 28626 { 28627 __failure = 532; 28628 if (!PyErr_Occurred()) { 28629 PyErr_SetString(PyExc_RuntimeError, 28630 "Unexpected error in an Op's C code. " 28631 "No Python exception was set."); 28632 } 28633 goto __label_532;} 28634 } 28635 // We expect NPY_FLOAT64 28636 if (!PyArray_ISALIGNED((PyArrayObject*) py_V531)) { 28637 PyArrayObject * tmp = (PyArrayObject*) py_V531; 28638 PyErr_Format(PyExc_NotImplementedError, 28639 "expected an aligned array of type %ld " 28640 "(NPY_FLOAT64), got non-aligned array of type %ld" 28641 " with %ld dimensions, with 3 last dims " 28642 "%ld, %ld, %ld" 28643 " and 3 last strides %ld %ld, %ld.", 28644 (long int) NPY_FLOAT64, 28645 (long int) PyArray_TYPE((PyArrayObject*) py_V531), 28646 (long int) PyArray_NDIM(tmp), 28647 (long int) (PyArray_NDIM(tmp) >= 3 ? 28648 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 28649 (long int) (PyArray_NDIM(tmp) >= 2 ? 28650 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 28651 (long int) (PyArray_NDIM(tmp) >= 1 ? 28652 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 28653 (long int) (PyArray_NDIM(tmp) >= 3 ? 28654 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 28655 (long int) (PyArray_NDIM(tmp) >= 2 ? 28656 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 28657 (long int) (PyArray_NDIM(tmp) >= 1 ? 28658 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 28659 ); 28660 { 28661 __failure = 532; 28662 if (!PyErr_Occurred()) { 28663 PyErr_SetString(PyExc_RuntimeError, 28664 "Unexpected error in an Op's C code. " 28665 "No Python exception was set."); 28666 } 28667 goto __label_532;} 28668 } 28669 // This is a TypeError to be consistent with DEBUG_MODE 28670 // Note: DEBUG_MODE also tells the name of the container 28671 if (PyArray_TYPE((PyArrayObject*) py_V531) != NPY_FLOAT64) { 28672 PyErr_Format(PyExc_TypeError, 28673 "expected type_num %d (NPY_FLOAT64) got %d", 28674 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V531)); 28675 { 28676 __failure = 532; 28677 if (!PyErr_Occurred()) { 28678 PyErr_SetString(PyExc_RuntimeError, 28679 "Unexpected error in an Op's C code. " 28680 "No Python exception was set."); 28681 } 28682 goto __label_532;} 28683 } 28684 28685 V531 = (PyArrayObject*)(py_V531); 28686 Py_XINCREF(V531); 28687 28688 { 28689 28690 py_V533 = PyList_GET_ITEM(storage_V533, 0); 28691 {Py_XINCREF(py_V533);} 28692 28693 V533 = NULL; 28694 if (py_V533 == Py_None) { 28695 // We can either fail here or set V533 to NULL and rely on Ops 28696 // using tensors to handle the NULL case, but if they fail to do so 28697 // they'll end up with nasty segfaults, so this is public service. 28698 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 28699 { 28700 __failure = 534; 28701 if (!PyErr_Occurred()) { 28702 PyErr_SetString(PyExc_RuntimeError, 28703 "Unexpected error in an Op's C code. " 28704 "No Python exception was set."); 28705 } 28706 goto __label_534;} 28707 } 28708 if (!PyArray_Check(py_V533)) { 28709 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 28710 { 28711 __failure = 534; 28712 if (!PyErr_Occurred()) { 28713 PyErr_SetString(PyExc_RuntimeError, 28714 "Unexpected error in an Op's C code. " 28715 "No Python exception was set."); 28716 } 28717 goto __label_534;} 28718 } 28719 // We expect NPY_FLOAT64 28720 if (!PyArray_ISALIGNED((PyArrayObject*) py_V533)) { 28721 PyArrayObject * tmp = (PyArrayObject*) py_V533; 28722 PyErr_Format(PyExc_NotImplementedError, 28723 "expected an aligned array of type %ld " 28724 "(NPY_FLOAT64), got non-aligned array of type %ld" 28725 " with %ld dimensions, with 3 last dims " 28726 "%ld, %ld, %ld" 28727 " and 3 last strides %ld %ld, %ld.", 28728 (long int) NPY_FLOAT64, 28729 (long int) PyArray_TYPE((PyArrayObject*) py_V533), 28730 (long int) PyArray_NDIM(tmp), 28731 (long int) (PyArray_NDIM(tmp) >= 3 ? 28732 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 28733 (long int) (PyArray_NDIM(tmp) >= 2 ? 28734 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 28735 (long int) (PyArray_NDIM(tmp) >= 1 ? 28736 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 28737 (long int) (PyArray_NDIM(tmp) >= 3 ? 28738 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 28739 (long int) (PyArray_NDIM(tmp) >= 2 ? 28740 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 28741 (long int) (PyArray_NDIM(tmp) >= 1 ? 28742 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 28743 ); 28744 { 28745 __failure = 534; 28746 if (!PyErr_Occurred()) { 28747 PyErr_SetString(PyExc_RuntimeError, 28748 "Unexpected error in an Op's C code. " 28749 "No Python exception was set."); 28750 } 28751 goto __label_534;} 28752 } 28753 // This is a TypeError to be consistent with DEBUG_MODE 28754 // Note: DEBUG_MODE also tells the name of the container 28755 if (PyArray_TYPE((PyArrayObject*) py_V533) != NPY_FLOAT64) { 28756 PyErr_Format(PyExc_TypeError, 28757 "expected type_num %d (NPY_FLOAT64) got %d", 28758 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V533)); 28759 { 28760 __failure = 534; 28761 if (!PyErr_Occurred()) { 28762 PyErr_SetString(PyExc_RuntimeError, 28763 "Unexpected error in an Op's C code. " 28764 "No Python exception was set."); 28765 } 28766 goto __label_534;} 28767 } 28768 28769 V533 = (PyArrayObject*)(py_V533); 28770 Py_XINCREF(V533); 28771 28772 { 28773 28774 py_V535 = PyList_GET_ITEM(storage_V535, 0); 28775 {Py_XINCREF(py_V535);} 28776 28777 V535 = NULL; 28778 if (py_V535 == Py_None) { 28779 // We can either fail here or set V535 to NULL and rely on Ops 28780 // using tensors to handle the NULL case, but if they fail to do so 28781 // they'll end up with nasty segfaults, so this is public service. 28782 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 28783 { 28784 __failure = 536; 28785 if (!PyErr_Occurred()) { 28786 PyErr_SetString(PyExc_RuntimeError, 28787 "Unexpected error in an Op's C code. " 28788 "No Python exception was set."); 28789 } 28790 goto __label_536;} 28791 } 28792 if (!PyArray_Check(py_V535)) { 28793 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 28794 { 28795 __failure = 536; 28796 if (!PyErr_Occurred()) { 28797 PyErr_SetString(PyExc_RuntimeError, 28798 "Unexpected error in an Op's C code. " 28799 "No Python exception was set."); 28800 } 28801 goto __label_536;} 28802 } 28803 // We expect NPY_FLOAT64 28804 if (!PyArray_ISALIGNED((PyArrayObject*) py_V535)) { 28805 PyArrayObject * tmp = (PyArrayObject*) py_V535; 28806 PyErr_Format(PyExc_NotImplementedError, 28807 "expected an aligned array of type %ld " 28808 "(NPY_FLOAT64), got non-aligned array of type %ld" 28809 " with %ld dimensions, with 3 last dims " 28810 "%ld, %ld, %ld" 28811 " and 3 last strides %ld %ld, %ld.", 28812 (long int) NPY_FLOAT64, 28813 (long int) PyArray_TYPE((PyArrayObject*) py_V535), 28814 (long int) PyArray_NDIM(tmp), 28815 (long int) (PyArray_NDIM(tmp) >= 3 ? 28816 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 28817 (long int) (PyArray_NDIM(tmp) >= 2 ? 28818 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 28819 (long int) (PyArray_NDIM(tmp) >= 1 ? 28820 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 28821 (long int) (PyArray_NDIM(tmp) >= 3 ? 28822 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 28823 (long int) (PyArray_NDIM(tmp) >= 2 ? 28824 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 28825 (long int) (PyArray_NDIM(tmp) >= 1 ? 28826 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 28827 ); 28828 { 28829 __failure = 536; 28830 if (!PyErr_Occurred()) { 28831 PyErr_SetString(PyExc_RuntimeError, 28832 "Unexpected error in an Op's C code. " 28833 "No Python exception was set."); 28834 } 28835 goto __label_536;} 28836 } 28837 // This is a TypeError to be consistent with DEBUG_MODE 28838 // Note: DEBUG_MODE also tells the name of the container 28839 if (PyArray_TYPE((PyArrayObject*) py_V535) != NPY_FLOAT64) { 28840 PyErr_Format(PyExc_TypeError, 28841 "expected type_num %d (NPY_FLOAT64) got %d", 28842 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V535)); 28843 { 28844 __failure = 536; 28845 if (!PyErr_Occurred()) { 28846 PyErr_SetString(PyExc_RuntimeError, 28847 "Unexpected error in an Op's C code. " 28848 "No Python exception was set."); 28849 } 28850 goto __label_536;} 28851 } 28852 28853 V535 = (PyArrayObject*)(py_V535); 28854 Py_XINCREF(V535); 28855 28856 { 28857 28858 py_V537 = PyList_GET_ITEM(storage_V537, 0); 28859 {Py_XINCREF(py_V537);} 28860 28861 V537 = NULL; 28862 if (py_V537 == Py_None) { 28863 // We can either fail here or set V537 to NULL and rely on Ops 28864 // using tensors to handle the NULL case, but if they fail to do so 28865 // they'll end up with nasty segfaults, so this is public service. 28866 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 28867 { 28868 __failure = 538; 28869 if (!PyErr_Occurred()) { 28870 PyErr_SetString(PyExc_RuntimeError, 28871 "Unexpected error in an Op's C code. " 28872 "No Python exception was set."); 28873 } 28874 goto __label_538;} 28875 } 28876 if (!PyArray_Check(py_V537)) { 28877 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 28878 { 28879 __failure = 538; 28880 if (!PyErr_Occurred()) { 28881 PyErr_SetString(PyExc_RuntimeError, 28882 "Unexpected error in an Op's C code. " 28883 "No Python exception was set."); 28884 } 28885 goto __label_538;} 28886 } 28887 // We expect NPY_FLOAT64 28888 if (!PyArray_ISALIGNED((PyArrayObject*) py_V537)) { 28889 PyArrayObject * tmp = (PyArrayObject*) py_V537; 28890 PyErr_Format(PyExc_NotImplementedError, 28891 "expected an aligned array of type %ld " 28892 "(NPY_FLOAT64), got non-aligned array of type %ld" 28893 " with %ld dimensions, with 3 last dims " 28894 "%ld, %ld, %ld" 28895 " and 3 last strides %ld %ld, %ld.", 28896 (long int) NPY_FLOAT64, 28897 (long int) PyArray_TYPE((PyArrayObject*) py_V537), 28898 (long int) PyArray_NDIM(tmp), 28899 (long int) (PyArray_NDIM(tmp) >= 3 ? 28900 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 28901 (long int) (PyArray_NDIM(tmp) >= 2 ? 28902 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 28903 (long int) (PyArray_NDIM(tmp) >= 1 ? 28904 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 28905 (long int) (PyArray_NDIM(tmp) >= 3 ? 28906 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 28907 (long int) (PyArray_NDIM(tmp) >= 2 ? 28908 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 28909 (long int) (PyArray_NDIM(tmp) >= 1 ? 28910 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 28911 ); 28912 { 28913 __failure = 538; 28914 if (!PyErr_Occurred()) { 28915 PyErr_SetString(PyExc_RuntimeError, 28916 "Unexpected error in an Op's C code. " 28917 "No Python exception was set."); 28918 } 28919 goto __label_538;} 28920 } 28921 // This is a TypeError to be consistent with DEBUG_MODE 28922 // Note: DEBUG_MODE also tells the name of the container 28923 if (PyArray_TYPE((PyArrayObject*) py_V537) != NPY_FLOAT64) { 28924 PyErr_Format(PyExc_TypeError, 28925 "expected type_num %d (NPY_FLOAT64) got %d", 28926 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V537)); 28927 { 28928 __failure = 538; 28929 if (!PyErr_Occurred()) { 28930 PyErr_SetString(PyExc_RuntimeError, 28931 "Unexpected error in an Op's C code. " 28932 "No Python exception was set."); 28933 } 28934 goto __label_538;} 28935 } 28936 28937 V537 = (PyArrayObject*)(py_V537); 28938 Py_XINCREF(V537); 28939 28940 { 28941 28942 py_V539 = PyList_GET_ITEM(storage_V539, 0); 28943 {Py_XINCREF(py_V539);} 28944 28945 V539 = NULL; 28946 if (py_V539 == Py_None) { 28947 // We can either fail here or set V539 to NULL and rely on Ops 28948 // using tensors to handle the NULL case, but if they fail to do so 28949 // they'll end up with nasty segfaults, so this is public service. 28950 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 28951 { 28952 __failure = 540; 28953 if (!PyErr_Occurred()) { 28954 PyErr_SetString(PyExc_RuntimeError, 28955 "Unexpected error in an Op's C code. " 28956 "No Python exception was set."); 28957 } 28958 goto __label_540;} 28959 } 28960 if (!PyArray_Check(py_V539)) { 28961 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 28962 { 28963 __failure = 540; 28964 if (!PyErr_Occurred()) { 28965 PyErr_SetString(PyExc_RuntimeError, 28966 "Unexpected error in an Op's C code. " 28967 "No Python exception was set."); 28968 } 28969 goto __label_540;} 28970 } 28971 // We expect NPY_FLOAT64 28972 if (!PyArray_ISALIGNED((PyArrayObject*) py_V539)) { 28973 PyArrayObject * tmp = (PyArrayObject*) py_V539; 28974 PyErr_Format(PyExc_NotImplementedError, 28975 "expected an aligned array of type %ld " 28976 "(NPY_FLOAT64), got non-aligned array of type %ld" 28977 " with %ld dimensions, with 3 last dims " 28978 "%ld, %ld, %ld" 28979 " and 3 last strides %ld %ld, %ld.", 28980 (long int) NPY_FLOAT64, 28981 (long int) PyArray_TYPE((PyArrayObject*) py_V539), 28982 (long int) PyArray_NDIM(tmp), 28983 (long int) (PyArray_NDIM(tmp) >= 3 ? 28984 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 28985 (long int) (PyArray_NDIM(tmp) >= 2 ? 28986 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 28987 (long int) (PyArray_NDIM(tmp) >= 1 ? 28988 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 28989 (long int) (PyArray_NDIM(tmp) >= 3 ? 28990 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 28991 (long int) (PyArray_NDIM(tmp) >= 2 ? 28992 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 28993 (long int) (PyArray_NDIM(tmp) >= 1 ? 28994 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 28995 ); 28996 { 28997 __failure = 540; 28998 if (!PyErr_Occurred()) { 28999 PyErr_SetString(PyExc_RuntimeError, 29000 "Unexpected error in an Op's C code. " 29001 "No Python exception was set."); 29002 } 29003 goto __label_540;} 29004 } 29005 // This is a TypeError to be consistent with DEBUG_MODE 29006 // Note: DEBUG_MODE also tells the name of the container 29007 if (PyArray_TYPE((PyArrayObject*) py_V539) != NPY_FLOAT64) { 29008 PyErr_Format(PyExc_TypeError, 29009 "expected type_num %d (NPY_FLOAT64) got %d", 29010 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V539)); 29011 { 29012 __failure = 540; 29013 if (!PyErr_Occurred()) { 29014 PyErr_SetString(PyExc_RuntimeError, 29015 "Unexpected error in an Op's C code. " 29016 "No Python exception was set."); 29017 } 29018 goto __label_540;} 29019 } 29020 29021 V539 = (PyArrayObject*)(py_V539); 29022 Py_XINCREF(V539); 29023 29024 { 29025 29026 py_V541 = PyList_GET_ITEM(storage_V541, 0); 29027 {Py_XINCREF(py_V541);} 29028 29029 V541 = NULL; 29030 if (py_V541 == Py_None) { 29031 // We can either fail here or set V541 to NULL and rely on Ops 29032 // using tensors to handle the NULL case, but if they fail to do so 29033 // they'll end up with nasty segfaults, so this is public service. 29034 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 29035 { 29036 __failure = 542; 29037 if (!PyErr_Occurred()) { 29038 PyErr_SetString(PyExc_RuntimeError, 29039 "Unexpected error in an Op's C code. " 29040 "No Python exception was set."); 29041 } 29042 goto __label_542;} 29043 } 29044 if (!PyArray_Check(py_V541)) { 29045 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 29046 { 29047 __failure = 542; 29048 if (!PyErr_Occurred()) { 29049 PyErr_SetString(PyExc_RuntimeError, 29050 "Unexpected error in an Op's C code. " 29051 "No Python exception was set."); 29052 } 29053 goto __label_542;} 29054 } 29055 // We expect NPY_FLOAT64 29056 if (!PyArray_ISALIGNED((PyArrayObject*) py_V541)) { 29057 PyArrayObject * tmp = (PyArrayObject*) py_V541; 29058 PyErr_Format(PyExc_NotImplementedError, 29059 "expected an aligned array of type %ld " 29060 "(NPY_FLOAT64), got non-aligned array of type %ld" 29061 " with %ld dimensions, with 3 last dims " 29062 "%ld, %ld, %ld" 29063 " and 3 last strides %ld %ld, %ld.", 29064 (long int) NPY_FLOAT64, 29065 (long int) PyArray_TYPE((PyArrayObject*) py_V541), 29066 (long int) PyArray_NDIM(tmp), 29067 (long int) (PyArray_NDIM(tmp) >= 3 ? 29068 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 29069 (long int) (PyArray_NDIM(tmp) >= 2 ? 29070 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 29071 (long int) (PyArray_NDIM(tmp) >= 1 ? 29072 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 29073 (long int) (PyArray_NDIM(tmp) >= 3 ? 29074 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 29075 (long int) (PyArray_NDIM(tmp) >= 2 ? 29076 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 29077 (long int) (PyArray_NDIM(tmp) >= 1 ? 29078 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 29079 ); 29080 { 29081 __failure = 542; 29082 if (!PyErr_Occurred()) { 29083 PyErr_SetString(PyExc_RuntimeError, 29084 "Unexpected error in an Op's C code. " 29085 "No Python exception was set."); 29086 } 29087 goto __label_542;} 29088 } 29089 // This is a TypeError to be consistent with DEBUG_MODE 29090 // Note: DEBUG_MODE also tells the name of the container 29091 if (PyArray_TYPE((PyArrayObject*) py_V541) != NPY_FLOAT64) { 29092 PyErr_Format(PyExc_TypeError, 29093 "expected type_num %d (NPY_FLOAT64) got %d", 29094 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V541)); 29095 { 29096 __failure = 542; 29097 if (!PyErr_Occurred()) { 29098 PyErr_SetString(PyExc_RuntimeError, 29099 "Unexpected error in an Op's C code. " 29100 "No Python exception was set."); 29101 } 29102 goto __label_542;} 29103 } 29104 29105 V541 = (PyArrayObject*)(py_V541); 29106 Py_XINCREF(V541); 29107 29108 { 29109 29110 py_V543 = PyList_GET_ITEM(storage_V543, 0); 29111 {Py_XINCREF(py_V543);} 29112 29113 V543 = NULL; 29114 if (py_V543 == Py_None) { 29115 // We can either fail here or set V543 to NULL and rely on Ops 29116 // using tensors to handle the NULL case, but if they fail to do so 29117 // they'll end up with nasty segfaults, so this is public service. 29118 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 29119 { 29120 __failure = 544; 29121 if (!PyErr_Occurred()) { 29122 PyErr_SetString(PyExc_RuntimeError, 29123 "Unexpected error in an Op's C code. " 29124 "No Python exception was set."); 29125 } 29126 goto __label_544;} 29127 } 29128 if (!PyArray_Check(py_V543)) { 29129 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 29130 { 29131 __failure = 544; 29132 if (!PyErr_Occurred()) { 29133 PyErr_SetString(PyExc_RuntimeError, 29134 "Unexpected error in an Op's C code. " 29135 "No Python exception was set."); 29136 } 29137 goto __label_544;} 29138 } 29139 // We expect NPY_FLOAT64 29140 if (!PyArray_ISALIGNED((PyArrayObject*) py_V543)) { 29141 PyArrayObject * tmp = (PyArrayObject*) py_V543; 29142 PyErr_Format(PyExc_NotImplementedError, 29143 "expected an aligned array of type %ld " 29144 "(NPY_FLOAT64), got non-aligned array of type %ld" 29145 " with %ld dimensions, with 3 last dims " 29146 "%ld, %ld, %ld" 29147 " and 3 last strides %ld %ld, %ld.", 29148 (long int) NPY_FLOAT64, 29149 (long int) PyArray_TYPE((PyArrayObject*) py_V543), 29150 (long int) PyArray_NDIM(tmp), 29151 (long int) (PyArray_NDIM(tmp) >= 3 ? 29152 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 29153 (long int) (PyArray_NDIM(tmp) >= 2 ? 29154 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 29155 (long int) (PyArray_NDIM(tmp) >= 1 ? 29156 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 29157 (long int) (PyArray_NDIM(tmp) >= 3 ? 29158 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 29159 (long int) (PyArray_NDIM(tmp) >= 2 ? 29160 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 29161 (long int) (PyArray_NDIM(tmp) >= 1 ? 29162 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 29163 ); 29164 { 29165 __failure = 544; 29166 if (!PyErr_Occurred()) { 29167 PyErr_SetString(PyExc_RuntimeError, 29168 "Unexpected error in an Op's C code. " 29169 "No Python exception was set."); 29170 } 29171 goto __label_544;} 29172 } 29173 // This is a TypeError to be consistent with DEBUG_MODE 29174 // Note: DEBUG_MODE also tells the name of the container 29175 if (PyArray_TYPE((PyArrayObject*) py_V543) != NPY_FLOAT64) { 29176 PyErr_Format(PyExc_TypeError, 29177 "expected type_num %d (NPY_FLOAT64) got %d", 29178 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V543)); 29179 { 29180 __failure = 544; 29181 if (!PyErr_Occurred()) { 29182 PyErr_SetString(PyExc_RuntimeError, 29183 "Unexpected error in an Op's C code. " 29184 "No Python exception was set."); 29185 } 29186 goto __label_544;} 29187 } 29188 29189 V543 = (PyArrayObject*)(py_V543); 29190 Py_XINCREF(V543); 29191 29192 { 29193 29194 py_V545 = PyList_GET_ITEM(storage_V545, 0); 29195 {Py_XINCREF(py_V545);} 29196 29197 V545 = NULL; 29198 if (py_V545 == Py_None) { 29199 // We can either fail here or set V545 to NULL and rely on Ops 29200 // using tensors to handle the NULL case, but if they fail to do so 29201 // they'll end up with nasty segfaults, so this is public service. 29202 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 29203 { 29204 __failure = 546; 29205 if (!PyErr_Occurred()) { 29206 PyErr_SetString(PyExc_RuntimeError, 29207 "Unexpected error in an Op's C code. " 29208 "No Python exception was set."); 29209 } 29210 goto __label_546;} 29211 } 29212 if (!PyArray_Check(py_V545)) { 29213 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 29214 { 29215 __failure = 546; 29216 if (!PyErr_Occurred()) { 29217 PyErr_SetString(PyExc_RuntimeError, 29218 "Unexpected error in an Op's C code. " 29219 "No Python exception was set."); 29220 } 29221 goto __label_546;} 29222 } 29223 // We expect NPY_FLOAT64 29224 if (!PyArray_ISALIGNED((PyArrayObject*) py_V545)) { 29225 PyArrayObject * tmp = (PyArrayObject*) py_V545; 29226 PyErr_Format(PyExc_NotImplementedError, 29227 "expected an aligned array of type %ld " 29228 "(NPY_FLOAT64), got non-aligned array of type %ld" 29229 " with %ld dimensions, with 3 last dims " 29230 "%ld, %ld, %ld" 29231 " and 3 last strides %ld %ld, %ld.", 29232 (long int) NPY_FLOAT64, 29233 (long int) PyArray_TYPE((PyArrayObject*) py_V545), 29234 (long int) PyArray_NDIM(tmp), 29235 (long int) (PyArray_NDIM(tmp) >= 3 ? 29236 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 29237 (long int) (PyArray_NDIM(tmp) >= 2 ? 29238 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 29239 (long int) (PyArray_NDIM(tmp) >= 1 ? 29240 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 29241 (long int) (PyArray_NDIM(tmp) >= 3 ? 29242 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 29243 (long int) (PyArray_NDIM(tmp) >= 2 ? 29244 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 29245 (long int) (PyArray_NDIM(tmp) >= 1 ? 29246 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 29247 ); 29248 { 29249 __failure = 546; 29250 if (!PyErr_Occurred()) { 29251 PyErr_SetString(PyExc_RuntimeError, 29252 "Unexpected error in an Op's C code. " 29253 "No Python exception was set."); 29254 } 29255 goto __label_546;} 29256 } 29257 // This is a TypeError to be consistent with DEBUG_MODE 29258 // Note: DEBUG_MODE also tells the name of the container 29259 if (PyArray_TYPE((PyArrayObject*) py_V545) != NPY_FLOAT64) { 29260 PyErr_Format(PyExc_TypeError, 29261 "expected type_num %d (NPY_FLOAT64) got %d", 29262 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V545)); 29263 { 29264 __failure = 546; 29265 if (!PyErr_Occurred()) { 29266 PyErr_SetString(PyExc_RuntimeError, 29267 "Unexpected error in an Op's C code. " 29268 "No Python exception was set."); 29269 } 29270 goto __label_546;} 29271 } 29272 29273 V545 = (PyArrayObject*)(py_V545); 29274 Py_XINCREF(V545); 29275 29276 { 29277 29278 py_V547 = PyList_GET_ITEM(storage_V547, 0); 29279 {Py_XINCREF(py_V547);} 29280 29281 V547 = NULL; 29282 if (py_V547 == Py_None) { 29283 // We can either fail here or set V547 to NULL and rely on Ops 29284 // using tensors to handle the NULL case, but if they fail to do so 29285 // they'll end up with nasty segfaults, so this is public service. 29286 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 29287 { 29288 __failure = 548; 29289 if (!PyErr_Occurred()) { 29290 PyErr_SetString(PyExc_RuntimeError, 29291 "Unexpected error in an Op's C code. " 29292 "No Python exception was set."); 29293 } 29294 goto __label_548;} 29295 } 29296 if (!PyArray_Check(py_V547)) { 29297 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 29298 { 29299 __failure = 548; 29300 if (!PyErr_Occurred()) { 29301 PyErr_SetString(PyExc_RuntimeError, 29302 "Unexpected error in an Op's C code. " 29303 "No Python exception was set."); 29304 } 29305 goto __label_548;} 29306 } 29307 // We expect NPY_FLOAT64 29308 if (!PyArray_ISALIGNED((PyArrayObject*) py_V547)) { 29309 PyArrayObject * tmp = (PyArrayObject*) py_V547; 29310 PyErr_Format(PyExc_NotImplementedError, 29311 "expected an aligned array of type %ld " 29312 "(NPY_FLOAT64), got non-aligned array of type %ld" 29313 " with %ld dimensions, with 3 last dims " 29314 "%ld, %ld, %ld" 29315 " and 3 last strides %ld %ld, %ld.", 29316 (long int) NPY_FLOAT64, 29317 (long int) PyArray_TYPE((PyArrayObject*) py_V547), 29318 (long int) PyArray_NDIM(tmp), 29319 (long int) (PyArray_NDIM(tmp) >= 3 ? 29320 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 29321 (long int) (PyArray_NDIM(tmp) >= 2 ? 29322 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 29323 (long int) (PyArray_NDIM(tmp) >= 1 ? 29324 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 29325 (long int) (PyArray_NDIM(tmp) >= 3 ? 29326 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 29327 (long int) (PyArray_NDIM(tmp) >= 2 ? 29328 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 29329 (long int) (PyArray_NDIM(tmp) >= 1 ? 29330 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 29331 ); 29332 { 29333 __failure = 548; 29334 if (!PyErr_Occurred()) { 29335 PyErr_SetString(PyExc_RuntimeError, 29336 "Unexpected error in an Op's C code. " 29337 "No Python exception was set."); 29338 } 29339 goto __label_548;} 29340 } 29341 // This is a TypeError to be consistent with DEBUG_MODE 29342 // Note: DEBUG_MODE also tells the name of the container 29343 if (PyArray_TYPE((PyArrayObject*) py_V547) != NPY_FLOAT64) { 29344 PyErr_Format(PyExc_TypeError, 29345 "expected type_num %d (NPY_FLOAT64) got %d", 29346 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V547)); 29347 { 29348 __failure = 548; 29349 if (!PyErr_Occurred()) { 29350 PyErr_SetString(PyExc_RuntimeError, 29351 "Unexpected error in an Op's C code. " 29352 "No Python exception was set."); 29353 } 29354 goto __label_548;} 29355 } 29356 29357 V547 = (PyArrayObject*)(py_V547); 29358 Py_XINCREF(V547); 29359 29360 { 29361 29362 py_V549 = PyList_GET_ITEM(storage_V549, 0); 29363 {Py_XINCREF(py_V549);} 29364 29365 V549 = NULL; 29366 if (py_V549 == Py_None) { 29367 // We can either fail here or set V549 to NULL and rely on Ops 29368 // using tensors to handle the NULL case, but if they fail to do so 29369 // they'll end up with nasty segfaults, so this is public service. 29370 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 29371 { 29372 __failure = 550; 29373 if (!PyErr_Occurred()) { 29374 PyErr_SetString(PyExc_RuntimeError, 29375 "Unexpected error in an Op's C code. " 29376 "No Python exception was set."); 29377 } 29378 goto __label_550;} 29379 } 29380 if (!PyArray_Check(py_V549)) { 29381 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 29382 { 29383 __failure = 550; 29384 if (!PyErr_Occurred()) { 29385 PyErr_SetString(PyExc_RuntimeError, 29386 "Unexpected error in an Op's C code. " 29387 "No Python exception was set."); 29388 } 29389 goto __label_550;} 29390 } 29391 // We expect NPY_FLOAT64 29392 if (!PyArray_ISALIGNED((PyArrayObject*) py_V549)) { 29393 PyArrayObject * tmp = (PyArrayObject*) py_V549; 29394 PyErr_Format(PyExc_NotImplementedError, 29395 "expected an aligned array of type %ld " 29396 "(NPY_FLOAT64), got non-aligned array of type %ld" 29397 " with %ld dimensions, with 3 last dims " 29398 "%ld, %ld, %ld" 29399 " and 3 last strides %ld %ld, %ld.", 29400 (long int) NPY_FLOAT64, 29401 (long int) PyArray_TYPE((PyArrayObject*) py_V549), 29402 (long int) PyArray_NDIM(tmp), 29403 (long int) (PyArray_NDIM(tmp) >= 3 ? 29404 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 29405 (long int) (PyArray_NDIM(tmp) >= 2 ? 29406 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 29407 (long int) (PyArray_NDIM(tmp) >= 1 ? 29408 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 29409 (long int) (PyArray_NDIM(tmp) >= 3 ? 29410 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 29411 (long int) (PyArray_NDIM(tmp) >= 2 ? 29412 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 29413 (long int) (PyArray_NDIM(tmp) >= 1 ? 29414 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 29415 ); 29416 { 29417 __failure = 550; 29418 if (!PyErr_Occurred()) { 29419 PyErr_SetString(PyExc_RuntimeError, 29420 "Unexpected error in an Op's C code. " 29421 "No Python exception was set."); 29422 } 29423 goto __label_550;} 29424 } 29425 // This is a TypeError to be consistent with DEBUG_MODE 29426 // Note: DEBUG_MODE also tells the name of the container 29427 if (PyArray_TYPE((PyArrayObject*) py_V549) != NPY_FLOAT64) { 29428 PyErr_Format(PyExc_TypeError, 29429 "expected type_num %d (NPY_FLOAT64) got %d", 29430 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V549)); 29431 { 29432 __failure = 550; 29433 if (!PyErr_Occurred()) { 29434 PyErr_SetString(PyExc_RuntimeError, 29435 "Unexpected error in an Op's C code. " 29436 "No Python exception was set."); 29437 } 29438 goto __label_550;} 29439 } 29440 29441 V549 = (PyArrayObject*)(py_V549); 29442 Py_XINCREF(V549); 29443 29444 { 29445 29446 py_V551 = PyList_GET_ITEM(storage_V551, 0); 29447 {Py_XINCREF(py_V551);} 29448 29449 V551 = NULL; 29450 if (py_V551 == Py_None) { 29451 // We can either fail here or set V551 to NULL and rely on Ops 29452 // using tensors to handle the NULL case, but if they fail to do so 29453 // they'll end up with nasty segfaults, so this is public service. 29454 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 29455 { 29456 __failure = 552; 29457 if (!PyErr_Occurred()) { 29458 PyErr_SetString(PyExc_RuntimeError, 29459 "Unexpected error in an Op's C code. " 29460 "No Python exception was set."); 29461 } 29462 goto __label_552;} 29463 } 29464 if (!PyArray_Check(py_V551)) { 29465 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 29466 { 29467 __failure = 552; 29468 if (!PyErr_Occurred()) { 29469 PyErr_SetString(PyExc_RuntimeError, 29470 "Unexpected error in an Op's C code. " 29471 "No Python exception was set."); 29472 } 29473 goto __label_552;} 29474 } 29475 // We expect NPY_FLOAT64 29476 if (!PyArray_ISALIGNED((PyArrayObject*) py_V551)) { 29477 PyArrayObject * tmp = (PyArrayObject*) py_V551; 29478 PyErr_Format(PyExc_NotImplementedError, 29479 "expected an aligned array of type %ld " 29480 "(NPY_FLOAT64), got non-aligned array of type %ld" 29481 " with %ld dimensions, with 3 last dims " 29482 "%ld, %ld, %ld" 29483 " and 3 last strides %ld %ld, %ld.", 29484 (long int) NPY_FLOAT64, 29485 (long int) PyArray_TYPE((PyArrayObject*) py_V551), 29486 (long int) PyArray_NDIM(tmp), 29487 (long int) (PyArray_NDIM(tmp) >= 3 ? 29488 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 29489 (long int) (PyArray_NDIM(tmp) >= 2 ? 29490 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 29491 (long int) (PyArray_NDIM(tmp) >= 1 ? 29492 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 29493 (long int) (PyArray_NDIM(tmp) >= 3 ? 29494 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 29495 (long int) (PyArray_NDIM(tmp) >= 2 ? 29496 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 29497 (long int) (PyArray_NDIM(tmp) >= 1 ? 29498 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 29499 ); 29500 { 29501 __failure = 552; 29502 if (!PyErr_Occurred()) { 29503 PyErr_SetString(PyExc_RuntimeError, 29504 "Unexpected error in an Op's C code. " 29505 "No Python exception was set."); 29506 } 29507 goto __label_552;} 29508 } 29509 // This is a TypeError to be consistent with DEBUG_MODE 29510 // Note: DEBUG_MODE also tells the name of the container 29511 if (PyArray_TYPE((PyArrayObject*) py_V551) != NPY_FLOAT64) { 29512 PyErr_Format(PyExc_TypeError, 29513 "expected type_num %d (NPY_FLOAT64) got %d", 29514 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V551)); 29515 { 29516 __failure = 552; 29517 if (!PyErr_Occurred()) { 29518 PyErr_SetString(PyExc_RuntimeError, 29519 "Unexpected error in an Op's C code. " 29520 "No Python exception was set."); 29521 } 29522 goto __label_552;} 29523 } 29524 29525 V551 = (PyArrayObject*)(py_V551); 29526 Py_XINCREF(V551); 29527 29528 { 29529 29530 py_V553 = PyList_GET_ITEM(storage_V553, 0); 29531 {Py_XINCREF(py_V553);} 29532 29533 V553 = NULL; 29534 if (py_V553 == Py_None) { 29535 // We can either fail here or set V553 to NULL and rely on Ops 29536 // using tensors to handle the NULL case, but if they fail to do so 29537 // they'll end up with nasty segfaults, so this is public service. 29538 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 29539 { 29540 __failure = 554; 29541 if (!PyErr_Occurred()) { 29542 PyErr_SetString(PyExc_RuntimeError, 29543 "Unexpected error in an Op's C code. " 29544 "No Python exception was set."); 29545 } 29546 goto __label_554;} 29547 } 29548 if (!PyArray_Check(py_V553)) { 29549 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 29550 { 29551 __failure = 554; 29552 if (!PyErr_Occurred()) { 29553 PyErr_SetString(PyExc_RuntimeError, 29554 "Unexpected error in an Op's C code. " 29555 "No Python exception was set."); 29556 } 29557 goto __label_554;} 29558 } 29559 // We expect NPY_FLOAT64 29560 if (!PyArray_ISALIGNED((PyArrayObject*) py_V553)) { 29561 PyArrayObject * tmp = (PyArrayObject*) py_V553; 29562 PyErr_Format(PyExc_NotImplementedError, 29563 "expected an aligned array of type %ld " 29564 "(NPY_FLOAT64), got non-aligned array of type %ld" 29565 " with %ld dimensions, with 3 last dims " 29566 "%ld, %ld, %ld" 29567 " and 3 last strides %ld %ld, %ld.", 29568 (long int) NPY_FLOAT64, 29569 (long int) PyArray_TYPE((PyArrayObject*) py_V553), 29570 (long int) PyArray_NDIM(tmp), 29571 (long int) (PyArray_NDIM(tmp) >= 3 ? 29572 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 29573 (long int) (PyArray_NDIM(tmp) >= 2 ? 29574 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 29575 (long int) (PyArray_NDIM(tmp) >= 1 ? 29576 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 29577 (long int) (PyArray_NDIM(tmp) >= 3 ? 29578 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 29579 (long int) (PyArray_NDIM(tmp) >= 2 ? 29580 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 29581 (long int) (PyArray_NDIM(tmp) >= 1 ? 29582 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 29583 ); 29584 { 29585 __failure = 554; 29586 if (!PyErr_Occurred()) { 29587 PyErr_SetString(PyExc_RuntimeError, 29588 "Unexpected error in an Op's C code. " 29589 "No Python exception was set."); 29590 } 29591 goto __label_554;} 29592 } 29593 // This is a TypeError to be consistent with DEBUG_MODE 29594 // Note: DEBUG_MODE also tells the name of the container 29595 if (PyArray_TYPE((PyArrayObject*) py_V553) != NPY_FLOAT64) { 29596 PyErr_Format(PyExc_TypeError, 29597 "expected type_num %d (NPY_FLOAT64) got %d", 29598 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V553)); 29599 { 29600 __failure = 554; 29601 if (!PyErr_Occurred()) { 29602 PyErr_SetString(PyExc_RuntimeError, 29603 "Unexpected error in an Op's C code. " 29604 "No Python exception was set."); 29605 } 29606 goto __label_554;} 29607 } 29608 29609 V553 = (PyArrayObject*)(py_V553); 29610 Py_XINCREF(V553); 29611 29612 { 29613 29614 py_V555 = PyList_GET_ITEM(storage_V555, 0); 29615 {Py_XINCREF(py_V555);} 29616 29617 V555 = NULL; 29618 if (py_V555 == Py_None) { 29619 // We can either fail here or set V555 to NULL and rely on Ops 29620 // using tensors to handle the NULL case, but if they fail to do so 29621 // they'll end up with nasty segfaults, so this is public service. 29622 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 29623 { 29624 __failure = 556; 29625 if (!PyErr_Occurred()) { 29626 PyErr_SetString(PyExc_RuntimeError, 29627 "Unexpected error in an Op's C code. " 29628 "No Python exception was set."); 29629 } 29630 goto __label_556;} 29631 } 29632 if (!PyArray_Check(py_V555)) { 29633 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 29634 { 29635 __failure = 556; 29636 if (!PyErr_Occurred()) { 29637 PyErr_SetString(PyExc_RuntimeError, 29638 "Unexpected error in an Op's C code. " 29639 "No Python exception was set."); 29640 } 29641 goto __label_556;} 29642 } 29643 // We expect NPY_FLOAT64 29644 if (!PyArray_ISALIGNED((PyArrayObject*) py_V555)) { 29645 PyArrayObject * tmp = (PyArrayObject*) py_V555; 29646 PyErr_Format(PyExc_NotImplementedError, 29647 "expected an aligned array of type %ld " 29648 "(NPY_FLOAT64), got non-aligned array of type %ld" 29649 " with %ld dimensions, with 3 last dims " 29650 "%ld, %ld, %ld" 29651 " and 3 last strides %ld %ld, %ld.", 29652 (long int) NPY_FLOAT64, 29653 (long int) PyArray_TYPE((PyArrayObject*) py_V555), 29654 (long int) PyArray_NDIM(tmp), 29655 (long int) (PyArray_NDIM(tmp) >= 3 ? 29656 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 29657 (long int) (PyArray_NDIM(tmp) >= 2 ? 29658 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 29659 (long int) (PyArray_NDIM(tmp) >= 1 ? 29660 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 29661 (long int) (PyArray_NDIM(tmp) >= 3 ? 29662 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 29663 (long int) (PyArray_NDIM(tmp) >= 2 ? 29664 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 29665 (long int) (PyArray_NDIM(tmp) >= 1 ? 29666 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 29667 ); 29668 { 29669 __failure = 556; 29670 if (!PyErr_Occurred()) { 29671 PyErr_SetString(PyExc_RuntimeError, 29672 "Unexpected error in an Op's C code. " 29673 "No Python exception was set."); 29674 } 29675 goto __label_556;} 29676 } 29677 // This is a TypeError to be consistent with DEBUG_MODE 29678 // Note: DEBUG_MODE also tells the name of the container 29679 if (PyArray_TYPE((PyArrayObject*) py_V555) != NPY_FLOAT64) { 29680 PyErr_Format(PyExc_TypeError, 29681 "expected type_num %d (NPY_FLOAT64) got %d", 29682 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V555)); 29683 { 29684 __failure = 556; 29685 if (!PyErr_Occurred()) { 29686 PyErr_SetString(PyExc_RuntimeError, 29687 "Unexpected error in an Op's C code. " 29688 "No Python exception was set."); 29689 } 29690 goto __label_556;} 29691 } 29692 29693 V555 = (PyArrayObject*)(py_V555); 29694 Py_XINCREF(V555); 29695 29696 { 29697 29698 py_V557 = PyList_GET_ITEM(storage_V557, 0); 29699 {Py_XINCREF(py_V557);} 29700 29701 V557 = NULL; 29702 if (py_V557 == Py_None) { 29703 // We can either fail here or set V557 to NULL and rely on Ops 29704 // using tensors to handle the NULL case, but if they fail to do so 29705 // they'll end up with nasty segfaults, so this is public service. 29706 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 29707 { 29708 __failure = 558; 29709 if (!PyErr_Occurred()) { 29710 PyErr_SetString(PyExc_RuntimeError, 29711 "Unexpected error in an Op's C code. " 29712 "No Python exception was set."); 29713 } 29714 goto __label_558;} 29715 } 29716 if (!PyArray_Check(py_V557)) { 29717 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 29718 { 29719 __failure = 558; 29720 if (!PyErr_Occurred()) { 29721 PyErr_SetString(PyExc_RuntimeError, 29722 "Unexpected error in an Op's C code. " 29723 "No Python exception was set."); 29724 } 29725 goto __label_558;} 29726 } 29727 // We expect NPY_FLOAT64 29728 if (!PyArray_ISALIGNED((PyArrayObject*) py_V557)) { 29729 PyArrayObject * tmp = (PyArrayObject*) py_V557; 29730 PyErr_Format(PyExc_NotImplementedError, 29731 "expected an aligned array of type %ld " 29732 "(NPY_FLOAT64), got non-aligned array of type %ld" 29733 " with %ld dimensions, with 3 last dims " 29734 "%ld, %ld, %ld" 29735 " and 3 last strides %ld %ld, %ld.", 29736 (long int) NPY_FLOAT64, 29737 (long int) PyArray_TYPE((PyArrayObject*) py_V557), 29738 (long int) PyArray_NDIM(tmp), 29739 (long int) (PyArray_NDIM(tmp) >= 3 ? 29740 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 29741 (long int) (PyArray_NDIM(tmp) >= 2 ? 29742 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 29743 (long int) (PyArray_NDIM(tmp) >= 1 ? 29744 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 29745 (long int) (PyArray_NDIM(tmp) >= 3 ? 29746 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 29747 (long int) (PyArray_NDIM(tmp) >= 2 ? 29748 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 29749 (long int) (PyArray_NDIM(tmp) >= 1 ? 29750 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 29751 ); 29752 { 29753 __failure = 558; 29754 if (!PyErr_Occurred()) { 29755 PyErr_SetString(PyExc_RuntimeError, 29756 "Unexpected error in an Op's C code. " 29757 "No Python exception was set."); 29758 } 29759 goto __label_558;} 29760 } 29761 // This is a TypeError to be consistent with DEBUG_MODE 29762 // Note: DEBUG_MODE also tells the name of the container 29763 if (PyArray_TYPE((PyArrayObject*) py_V557) != NPY_FLOAT64) { 29764 PyErr_Format(PyExc_TypeError, 29765 "expected type_num %d (NPY_FLOAT64) got %d", 29766 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V557)); 29767 { 29768 __failure = 558; 29769 if (!PyErr_Occurred()) { 29770 PyErr_SetString(PyExc_RuntimeError, 29771 "Unexpected error in an Op's C code. " 29772 "No Python exception was set."); 29773 } 29774 goto __label_558;} 29775 } 29776 29777 V557 = (PyArrayObject*)(py_V557); 29778 Py_XINCREF(V557); 29779 29780 { 29781 29782 py_V559 = PyList_GET_ITEM(storage_V559, 0); 29783 {Py_XINCREF(py_V559);} 29784 29785 V559 = NULL; 29786 if (py_V559 == Py_None) { 29787 // We can either fail here or set V559 to NULL and rely on Ops 29788 // using tensors to handle the NULL case, but if they fail to do so 29789 // they'll end up with nasty segfaults, so this is public service. 29790 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 29791 { 29792 __failure = 560; 29793 if (!PyErr_Occurred()) { 29794 PyErr_SetString(PyExc_RuntimeError, 29795 "Unexpected error in an Op's C code. " 29796 "No Python exception was set."); 29797 } 29798 goto __label_560;} 29799 } 29800 if (!PyArray_Check(py_V559)) { 29801 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 29802 { 29803 __failure = 560; 29804 if (!PyErr_Occurred()) { 29805 PyErr_SetString(PyExc_RuntimeError, 29806 "Unexpected error in an Op's C code. " 29807 "No Python exception was set."); 29808 } 29809 goto __label_560;} 29810 } 29811 // We expect NPY_FLOAT64 29812 if (!PyArray_ISALIGNED((PyArrayObject*) py_V559)) { 29813 PyArrayObject * tmp = (PyArrayObject*) py_V559; 29814 PyErr_Format(PyExc_NotImplementedError, 29815 "expected an aligned array of type %ld " 29816 "(NPY_FLOAT64), got non-aligned array of type %ld" 29817 " with %ld dimensions, with 3 last dims " 29818 "%ld, %ld, %ld" 29819 " and 3 last strides %ld %ld, %ld.", 29820 (long int) NPY_FLOAT64, 29821 (long int) PyArray_TYPE((PyArrayObject*) py_V559), 29822 (long int) PyArray_NDIM(tmp), 29823 (long int) (PyArray_NDIM(tmp) >= 3 ? 29824 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 29825 (long int) (PyArray_NDIM(tmp) >= 2 ? 29826 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 29827 (long int) (PyArray_NDIM(tmp) >= 1 ? 29828 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 29829 (long int) (PyArray_NDIM(tmp) >= 3 ? 29830 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 29831 (long int) (PyArray_NDIM(tmp) >= 2 ? 29832 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 29833 (long int) (PyArray_NDIM(tmp) >= 1 ? 29834 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 29835 ); 29836 { 29837 __failure = 560; 29838 if (!PyErr_Occurred()) { 29839 PyErr_SetString(PyExc_RuntimeError, 29840 "Unexpected error in an Op's C code. " 29841 "No Python exception was set."); 29842 } 29843 goto __label_560;} 29844 } 29845 // This is a TypeError to be consistent with DEBUG_MODE 29846 // Note: DEBUG_MODE also tells the name of the container 29847 if (PyArray_TYPE((PyArrayObject*) py_V559) != NPY_FLOAT64) { 29848 PyErr_Format(PyExc_TypeError, 29849 "expected type_num %d (NPY_FLOAT64) got %d", 29850 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V559)); 29851 { 29852 __failure = 560; 29853 if (!PyErr_Occurred()) { 29854 PyErr_SetString(PyExc_RuntimeError, 29855 "Unexpected error in an Op's C code. " 29856 "No Python exception was set."); 29857 } 29858 goto __label_560;} 29859 } 29860 29861 V559 = (PyArrayObject*)(py_V559); 29862 Py_XINCREF(V559); 29863 29864 { 29865 29866 py_V561 = PyList_GET_ITEM(storage_V561, 0); 29867 {Py_XINCREF(py_V561);} 29868 29869 V561 = NULL; 29870 if (py_V561 == Py_None) { 29871 // We can either fail here or set V561 to NULL and rely on Ops 29872 // using tensors to handle the NULL case, but if they fail to do so 29873 // they'll end up with nasty segfaults, so this is public service. 29874 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 29875 { 29876 __failure = 562; 29877 if (!PyErr_Occurred()) { 29878 PyErr_SetString(PyExc_RuntimeError, 29879 "Unexpected error in an Op's C code. " 29880 "No Python exception was set."); 29881 } 29882 goto __label_562;} 29883 } 29884 if (!PyArray_Check(py_V561)) { 29885 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 29886 { 29887 __failure = 562; 29888 if (!PyErr_Occurred()) { 29889 PyErr_SetString(PyExc_RuntimeError, 29890 "Unexpected error in an Op's C code. " 29891 "No Python exception was set."); 29892 } 29893 goto __label_562;} 29894 } 29895 // We expect NPY_FLOAT64 29896 if (!PyArray_ISALIGNED((PyArrayObject*) py_V561)) { 29897 PyArrayObject * tmp = (PyArrayObject*) py_V561; 29898 PyErr_Format(PyExc_NotImplementedError, 29899 "expected an aligned array of type %ld " 29900 "(NPY_FLOAT64), got non-aligned array of type %ld" 29901 " with %ld dimensions, with 3 last dims " 29902 "%ld, %ld, %ld" 29903 " and 3 last strides %ld %ld, %ld.", 29904 (long int) NPY_FLOAT64, 29905 (long int) PyArray_TYPE((PyArrayObject*) py_V561), 29906 (long int) PyArray_NDIM(tmp), 29907 (long int) (PyArray_NDIM(tmp) >= 3 ? 29908 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 29909 (long int) (PyArray_NDIM(tmp) >= 2 ? 29910 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 29911 (long int) (PyArray_NDIM(tmp) >= 1 ? 29912 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 29913 (long int) (PyArray_NDIM(tmp) >= 3 ? 29914 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 29915 (long int) (PyArray_NDIM(tmp) >= 2 ? 29916 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 29917 (long int) (PyArray_NDIM(tmp) >= 1 ? 29918 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 29919 ); 29920 { 29921 __failure = 562; 29922 if (!PyErr_Occurred()) { 29923 PyErr_SetString(PyExc_RuntimeError, 29924 "Unexpected error in an Op's C code. " 29925 "No Python exception was set."); 29926 } 29927 goto __label_562;} 29928 } 29929 // This is a TypeError to be consistent with DEBUG_MODE 29930 // Note: DEBUG_MODE also tells the name of the container 29931 if (PyArray_TYPE((PyArrayObject*) py_V561) != NPY_FLOAT64) { 29932 PyErr_Format(PyExc_TypeError, 29933 "expected type_num %d (NPY_FLOAT64) got %d", 29934 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V561)); 29935 { 29936 __failure = 562; 29937 if (!PyErr_Occurred()) { 29938 PyErr_SetString(PyExc_RuntimeError, 29939 "Unexpected error in an Op's C code. " 29940 "No Python exception was set."); 29941 } 29942 goto __label_562;} 29943 } 29944 29945 V561 = (PyArrayObject*)(py_V561); 29946 Py_XINCREF(V561); 29947 29948 { 29949 29950 py_V563 = PyList_GET_ITEM(storage_V563, 0); 29951 {Py_XINCREF(py_V563);} 29952 29953 V563 = NULL; 29954 if (py_V563 == Py_None) { 29955 // We can either fail here or set V563 to NULL and rely on Ops 29956 // using tensors to handle the NULL case, but if they fail to do so 29957 // they'll end up with nasty segfaults, so this is public service. 29958 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 29959 { 29960 __failure = 564; 29961 if (!PyErr_Occurred()) { 29962 PyErr_SetString(PyExc_RuntimeError, 29963 "Unexpected error in an Op's C code. " 29964 "No Python exception was set."); 29965 } 29966 goto __label_564;} 29967 } 29968 if (!PyArray_Check(py_V563)) { 29969 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 29970 { 29971 __failure = 564; 29972 if (!PyErr_Occurred()) { 29973 PyErr_SetString(PyExc_RuntimeError, 29974 "Unexpected error in an Op's C code. " 29975 "No Python exception was set."); 29976 } 29977 goto __label_564;} 29978 } 29979 // We expect NPY_FLOAT64 29980 if (!PyArray_ISALIGNED((PyArrayObject*) py_V563)) { 29981 PyArrayObject * tmp = (PyArrayObject*) py_V563; 29982 PyErr_Format(PyExc_NotImplementedError, 29983 "expected an aligned array of type %ld " 29984 "(NPY_FLOAT64), got non-aligned array of type %ld" 29985 " with %ld dimensions, with 3 last dims " 29986 "%ld, %ld, %ld" 29987 " and 3 last strides %ld %ld, %ld.", 29988 (long int) NPY_FLOAT64, 29989 (long int) PyArray_TYPE((PyArrayObject*) py_V563), 29990 (long int) PyArray_NDIM(tmp), 29991 (long int) (PyArray_NDIM(tmp) >= 3 ? 29992 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 29993 (long int) (PyArray_NDIM(tmp) >= 2 ? 29994 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 29995 (long int) (PyArray_NDIM(tmp) >= 1 ? 29996 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 29997 (long int) (PyArray_NDIM(tmp) >= 3 ? 29998 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 29999 (long int) (PyArray_NDIM(tmp) >= 2 ? 30000 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 30001 (long int) (PyArray_NDIM(tmp) >= 1 ? 30002 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 30003 ); 30004 { 30005 __failure = 564; 30006 if (!PyErr_Occurred()) { 30007 PyErr_SetString(PyExc_RuntimeError, 30008 "Unexpected error in an Op's C code. " 30009 "No Python exception was set."); 30010 } 30011 goto __label_564;} 30012 } 30013 // This is a TypeError to be consistent with DEBUG_MODE 30014 // Note: DEBUG_MODE also tells the name of the container 30015 if (PyArray_TYPE((PyArrayObject*) py_V563) != NPY_FLOAT64) { 30016 PyErr_Format(PyExc_TypeError, 30017 "expected type_num %d (NPY_FLOAT64) got %d", 30018 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V563)); 30019 { 30020 __failure = 564; 30021 if (!PyErr_Occurred()) { 30022 PyErr_SetString(PyExc_RuntimeError, 30023 "Unexpected error in an Op's C code. " 30024 "No Python exception was set."); 30025 } 30026 goto __label_564;} 30027 } 30028 30029 V563 = (PyArrayObject*)(py_V563); 30030 Py_XINCREF(V563); 30031 30032 { 30033 30034 py_V565 = PyList_GET_ITEM(storage_V565, 0); 30035 {Py_XINCREF(py_V565);} 30036 30037 V565 = NULL; 30038 if (py_V565 == Py_None) { 30039 // We can either fail here or set V565 to NULL and rely on Ops 30040 // using tensors to handle the NULL case, but if they fail to do so 30041 // they'll end up with nasty segfaults, so this is public service. 30042 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 30043 { 30044 __failure = 566; 30045 if (!PyErr_Occurred()) { 30046 PyErr_SetString(PyExc_RuntimeError, 30047 "Unexpected error in an Op's C code. " 30048 "No Python exception was set."); 30049 } 30050 goto __label_566;} 30051 } 30052 if (!PyArray_Check(py_V565)) { 30053 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 30054 { 30055 __failure = 566; 30056 if (!PyErr_Occurred()) { 30057 PyErr_SetString(PyExc_RuntimeError, 30058 "Unexpected error in an Op's C code. " 30059 "No Python exception was set."); 30060 } 30061 goto __label_566;} 30062 } 30063 // We expect NPY_FLOAT64 30064 if (!PyArray_ISALIGNED((PyArrayObject*) py_V565)) { 30065 PyArrayObject * tmp = (PyArrayObject*) py_V565; 30066 PyErr_Format(PyExc_NotImplementedError, 30067 "expected an aligned array of type %ld " 30068 "(NPY_FLOAT64), got non-aligned array of type %ld" 30069 " with %ld dimensions, with 3 last dims " 30070 "%ld, %ld, %ld" 30071 " and 3 last strides %ld %ld, %ld.", 30072 (long int) NPY_FLOAT64, 30073 (long int) PyArray_TYPE((PyArrayObject*) py_V565), 30074 (long int) PyArray_NDIM(tmp), 30075 (long int) (PyArray_NDIM(tmp) >= 3 ? 30076 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 30077 (long int) (PyArray_NDIM(tmp) >= 2 ? 30078 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 30079 (long int) (PyArray_NDIM(tmp) >= 1 ? 30080 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 30081 (long int) (PyArray_NDIM(tmp) >= 3 ? 30082 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 30083 (long int) (PyArray_NDIM(tmp) >= 2 ? 30084 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 30085 (long int) (PyArray_NDIM(tmp) >= 1 ? 30086 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 30087 ); 30088 { 30089 __failure = 566; 30090 if (!PyErr_Occurred()) { 30091 PyErr_SetString(PyExc_RuntimeError, 30092 "Unexpected error in an Op's C code. " 30093 "No Python exception was set."); 30094 } 30095 goto __label_566;} 30096 } 30097 // This is a TypeError to be consistent with DEBUG_MODE 30098 // Note: DEBUG_MODE also tells the name of the container 30099 if (PyArray_TYPE((PyArrayObject*) py_V565) != NPY_FLOAT64) { 30100 PyErr_Format(PyExc_TypeError, 30101 "expected type_num %d (NPY_FLOAT64) got %d", 30102 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V565)); 30103 { 30104 __failure = 566; 30105 if (!PyErr_Occurred()) { 30106 PyErr_SetString(PyExc_RuntimeError, 30107 "Unexpected error in an Op's C code. " 30108 "No Python exception was set."); 30109 } 30110 goto __label_566;} 30111 } 30112 30113 V565 = (PyArrayObject*)(py_V565); 30114 Py_XINCREF(V565); 30115 30116 { 30117 30118 py_V567 = PyList_GET_ITEM(storage_V567, 0); 30119 {Py_XINCREF(py_V567);} 30120 30121 V567 = NULL; 30122 if (py_V567 == Py_None) { 30123 // We can either fail here or set V567 to NULL and rely on Ops 30124 // using tensors to handle the NULL case, but if they fail to do so 30125 // they'll end up with nasty segfaults, so this is public service. 30126 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 30127 { 30128 __failure = 568; 30129 if (!PyErr_Occurred()) { 30130 PyErr_SetString(PyExc_RuntimeError, 30131 "Unexpected error in an Op's C code. " 30132 "No Python exception was set."); 30133 } 30134 goto __label_568;} 30135 } 30136 if (!PyArray_Check(py_V567)) { 30137 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 30138 { 30139 __failure = 568; 30140 if (!PyErr_Occurred()) { 30141 PyErr_SetString(PyExc_RuntimeError, 30142 "Unexpected error in an Op's C code. " 30143 "No Python exception was set."); 30144 } 30145 goto __label_568;} 30146 } 30147 // We expect NPY_FLOAT64 30148 if (!PyArray_ISALIGNED((PyArrayObject*) py_V567)) { 30149 PyArrayObject * tmp = (PyArrayObject*) py_V567; 30150 PyErr_Format(PyExc_NotImplementedError, 30151 "expected an aligned array of type %ld " 30152 "(NPY_FLOAT64), got non-aligned array of type %ld" 30153 " with %ld dimensions, with 3 last dims " 30154 "%ld, %ld, %ld" 30155 " and 3 last strides %ld %ld, %ld.", 30156 (long int) NPY_FLOAT64, 30157 (long int) PyArray_TYPE((PyArrayObject*) py_V567), 30158 (long int) PyArray_NDIM(tmp), 30159 (long int) (PyArray_NDIM(tmp) >= 3 ? 30160 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 30161 (long int) (PyArray_NDIM(tmp) >= 2 ? 30162 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 30163 (long int) (PyArray_NDIM(tmp) >= 1 ? 30164 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 30165 (long int) (PyArray_NDIM(tmp) >= 3 ? 30166 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 30167 (long int) (PyArray_NDIM(tmp) >= 2 ? 30168 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 30169 (long int) (PyArray_NDIM(tmp) >= 1 ? 30170 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 30171 ); 30172 { 30173 __failure = 568; 30174 if (!PyErr_Occurred()) { 30175 PyErr_SetString(PyExc_RuntimeError, 30176 "Unexpected error in an Op's C code. " 30177 "No Python exception was set."); 30178 } 30179 goto __label_568;} 30180 } 30181 // This is a TypeError to be consistent with DEBUG_MODE 30182 // Note: DEBUG_MODE also tells the name of the container 30183 if (PyArray_TYPE((PyArrayObject*) py_V567) != NPY_FLOAT64) { 30184 PyErr_Format(PyExc_TypeError, 30185 "expected type_num %d (NPY_FLOAT64) got %d", 30186 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V567)); 30187 { 30188 __failure = 568; 30189 if (!PyErr_Occurred()) { 30190 PyErr_SetString(PyExc_RuntimeError, 30191 "Unexpected error in an Op's C code. " 30192 "No Python exception was set."); 30193 } 30194 goto __label_568;} 30195 } 30196 30197 V567 = (PyArrayObject*)(py_V567); 30198 Py_XINCREF(V567); 30199 30200 { 30201 30202 py_V569 = PyList_GET_ITEM(storage_V569, 0); 30203 {Py_XINCREF(py_V569);} 30204 30205 V569 = NULL; 30206 if (py_V569 == Py_None) { 30207 // We can either fail here or set V569 to NULL and rely on Ops 30208 // using tensors to handle the NULL case, but if they fail to do so 30209 // they'll end up with nasty segfaults, so this is public service. 30210 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 30211 { 30212 __failure = 570; 30213 if (!PyErr_Occurred()) { 30214 PyErr_SetString(PyExc_RuntimeError, 30215 "Unexpected error in an Op's C code. " 30216 "No Python exception was set."); 30217 } 30218 goto __label_570;} 30219 } 30220 if (!PyArray_Check(py_V569)) { 30221 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 30222 { 30223 __failure = 570; 30224 if (!PyErr_Occurred()) { 30225 PyErr_SetString(PyExc_RuntimeError, 30226 "Unexpected error in an Op's C code. " 30227 "No Python exception was set."); 30228 } 30229 goto __label_570;} 30230 } 30231 // We expect NPY_FLOAT64 30232 if (!PyArray_ISALIGNED((PyArrayObject*) py_V569)) { 30233 PyArrayObject * tmp = (PyArrayObject*) py_V569; 30234 PyErr_Format(PyExc_NotImplementedError, 30235 "expected an aligned array of type %ld " 30236 "(NPY_FLOAT64), got non-aligned array of type %ld" 30237 " with %ld dimensions, with 3 last dims " 30238 "%ld, %ld, %ld" 30239 " and 3 last strides %ld %ld, %ld.", 30240 (long int) NPY_FLOAT64, 30241 (long int) PyArray_TYPE((PyArrayObject*) py_V569), 30242 (long int) PyArray_NDIM(tmp), 30243 (long int) (PyArray_NDIM(tmp) >= 3 ? 30244 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 30245 (long int) (PyArray_NDIM(tmp) >= 2 ? 30246 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 30247 (long int) (PyArray_NDIM(tmp) >= 1 ? 30248 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 30249 (long int) (PyArray_NDIM(tmp) >= 3 ? 30250 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 30251 (long int) (PyArray_NDIM(tmp) >= 2 ? 30252 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 30253 (long int) (PyArray_NDIM(tmp) >= 1 ? 30254 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 30255 ); 30256 { 30257 __failure = 570; 30258 if (!PyErr_Occurred()) { 30259 PyErr_SetString(PyExc_RuntimeError, 30260 "Unexpected error in an Op's C code. " 30261 "No Python exception was set."); 30262 } 30263 goto __label_570;} 30264 } 30265 // This is a TypeError to be consistent with DEBUG_MODE 30266 // Note: DEBUG_MODE also tells the name of the container 30267 if (PyArray_TYPE((PyArrayObject*) py_V569) != NPY_FLOAT64) { 30268 PyErr_Format(PyExc_TypeError, 30269 "expected type_num %d (NPY_FLOAT64) got %d", 30270 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V569)); 30271 { 30272 __failure = 570; 30273 if (!PyErr_Occurred()) { 30274 PyErr_SetString(PyExc_RuntimeError, 30275 "Unexpected error in an Op's C code. " 30276 "No Python exception was set."); 30277 } 30278 goto __label_570;} 30279 } 30280 30281 V569 = (PyArrayObject*)(py_V569); 30282 Py_XINCREF(V569); 30283 30284 { 30285 30286 py_V571 = PyList_GET_ITEM(storage_V571, 0); 30287 {Py_XINCREF(py_V571);} 30288 30289 V571 = NULL; 30290 if (py_V571 == Py_None) { 30291 // We can either fail here or set V571 to NULL and rely on Ops 30292 // using tensors to handle the NULL case, but if they fail to do so 30293 // they'll end up with nasty segfaults, so this is public service. 30294 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 30295 { 30296 __failure = 572; 30297 if (!PyErr_Occurred()) { 30298 PyErr_SetString(PyExc_RuntimeError, 30299 "Unexpected error in an Op's C code. " 30300 "No Python exception was set."); 30301 } 30302 goto __label_572;} 30303 } 30304 if (!PyArray_Check(py_V571)) { 30305 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 30306 { 30307 __failure = 572; 30308 if (!PyErr_Occurred()) { 30309 PyErr_SetString(PyExc_RuntimeError, 30310 "Unexpected error in an Op's C code. " 30311 "No Python exception was set."); 30312 } 30313 goto __label_572;} 30314 } 30315 // We expect NPY_FLOAT64 30316 if (!PyArray_ISALIGNED((PyArrayObject*) py_V571)) { 30317 PyArrayObject * tmp = (PyArrayObject*) py_V571; 30318 PyErr_Format(PyExc_NotImplementedError, 30319 "expected an aligned array of type %ld " 30320 "(NPY_FLOAT64), got non-aligned array of type %ld" 30321 " with %ld dimensions, with 3 last dims " 30322 "%ld, %ld, %ld" 30323 " and 3 last strides %ld %ld, %ld.", 30324 (long int) NPY_FLOAT64, 30325 (long int) PyArray_TYPE((PyArrayObject*) py_V571), 30326 (long int) PyArray_NDIM(tmp), 30327 (long int) (PyArray_NDIM(tmp) >= 3 ? 30328 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 30329 (long int) (PyArray_NDIM(tmp) >= 2 ? 30330 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 30331 (long int) (PyArray_NDIM(tmp) >= 1 ? 30332 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 30333 (long int) (PyArray_NDIM(tmp) >= 3 ? 30334 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 30335 (long int) (PyArray_NDIM(tmp) >= 2 ? 30336 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 30337 (long int) (PyArray_NDIM(tmp) >= 1 ? 30338 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 30339 ); 30340 { 30341 __failure = 572; 30342 if (!PyErr_Occurred()) { 30343 PyErr_SetString(PyExc_RuntimeError, 30344 "Unexpected error in an Op's C code. " 30345 "No Python exception was set."); 30346 } 30347 goto __label_572;} 30348 } 30349 // This is a TypeError to be consistent with DEBUG_MODE 30350 // Note: DEBUG_MODE also tells the name of the container 30351 if (PyArray_TYPE((PyArrayObject*) py_V571) != NPY_FLOAT64) { 30352 PyErr_Format(PyExc_TypeError, 30353 "expected type_num %d (NPY_FLOAT64) got %d", 30354 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V571)); 30355 { 30356 __failure = 572; 30357 if (!PyErr_Occurred()) { 30358 PyErr_SetString(PyExc_RuntimeError, 30359 "Unexpected error in an Op's C code. " 30360 "No Python exception was set."); 30361 } 30362 goto __label_572;} 30363 } 30364 30365 V571 = (PyArrayObject*)(py_V571); 30366 Py_XINCREF(V571); 30367 30368 { 30369 30370 py_V573 = PyList_GET_ITEM(storage_V573, 0); 30371 {Py_XINCREF(py_V573);} 30372 30373 V573 = NULL; 30374 if (py_V573 == Py_None) { 30375 // We can either fail here or set V573 to NULL and rely on Ops 30376 // using tensors to handle the NULL case, but if they fail to do so 30377 // they'll end up with nasty segfaults, so this is public service. 30378 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 30379 { 30380 __failure = 574; 30381 if (!PyErr_Occurred()) { 30382 PyErr_SetString(PyExc_RuntimeError, 30383 "Unexpected error in an Op's C code. " 30384 "No Python exception was set."); 30385 } 30386 goto __label_574;} 30387 } 30388 if (!PyArray_Check(py_V573)) { 30389 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 30390 { 30391 __failure = 574; 30392 if (!PyErr_Occurred()) { 30393 PyErr_SetString(PyExc_RuntimeError, 30394 "Unexpected error in an Op's C code. " 30395 "No Python exception was set."); 30396 } 30397 goto __label_574;} 30398 } 30399 // We expect NPY_FLOAT64 30400 if (!PyArray_ISALIGNED((PyArrayObject*) py_V573)) { 30401 PyArrayObject * tmp = (PyArrayObject*) py_V573; 30402 PyErr_Format(PyExc_NotImplementedError, 30403 "expected an aligned array of type %ld " 30404 "(NPY_FLOAT64), got non-aligned array of type %ld" 30405 " with %ld dimensions, with 3 last dims " 30406 "%ld, %ld, %ld" 30407 " and 3 last strides %ld %ld, %ld.", 30408 (long int) NPY_FLOAT64, 30409 (long int) PyArray_TYPE((PyArrayObject*) py_V573), 30410 (long int) PyArray_NDIM(tmp), 30411 (long int) (PyArray_NDIM(tmp) >= 3 ? 30412 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 30413 (long int) (PyArray_NDIM(tmp) >= 2 ? 30414 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 30415 (long int) (PyArray_NDIM(tmp) >= 1 ? 30416 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 30417 (long int) (PyArray_NDIM(tmp) >= 3 ? 30418 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 30419 (long int) (PyArray_NDIM(tmp) >= 2 ? 30420 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 30421 (long int) (PyArray_NDIM(tmp) >= 1 ? 30422 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 30423 ); 30424 { 30425 __failure = 574; 30426 if (!PyErr_Occurred()) { 30427 PyErr_SetString(PyExc_RuntimeError, 30428 "Unexpected error in an Op's C code. " 30429 "No Python exception was set."); 30430 } 30431 goto __label_574;} 30432 } 30433 // This is a TypeError to be consistent with DEBUG_MODE 30434 // Note: DEBUG_MODE also tells the name of the container 30435 if (PyArray_TYPE((PyArrayObject*) py_V573) != NPY_FLOAT64) { 30436 PyErr_Format(PyExc_TypeError, 30437 "expected type_num %d (NPY_FLOAT64) got %d", 30438 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V573)); 30439 { 30440 __failure = 574; 30441 if (!PyErr_Occurred()) { 30442 PyErr_SetString(PyExc_RuntimeError, 30443 "Unexpected error in an Op's C code. " 30444 "No Python exception was set."); 30445 } 30446 goto __label_574;} 30447 } 30448 30449 V573 = (PyArrayObject*)(py_V573); 30450 Py_XINCREF(V573); 30451 30452 { 30453 30454 py_V575 = PyList_GET_ITEM(storage_V575, 0); 30455 {Py_XINCREF(py_V575);} 30456 30457 V575 = NULL; 30458 if (py_V575 == Py_None) { 30459 // We can either fail here or set V575 to NULL and rely on Ops 30460 // using tensors to handle the NULL case, but if they fail to do so 30461 // they'll end up with nasty segfaults, so this is public service. 30462 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 30463 { 30464 __failure = 576; 30465 if (!PyErr_Occurred()) { 30466 PyErr_SetString(PyExc_RuntimeError, 30467 "Unexpected error in an Op's C code. " 30468 "No Python exception was set."); 30469 } 30470 goto __label_576;} 30471 } 30472 if (!PyArray_Check(py_V575)) { 30473 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 30474 { 30475 __failure = 576; 30476 if (!PyErr_Occurred()) { 30477 PyErr_SetString(PyExc_RuntimeError, 30478 "Unexpected error in an Op's C code. " 30479 "No Python exception was set."); 30480 } 30481 goto __label_576;} 30482 } 30483 // We expect NPY_FLOAT64 30484 if (!PyArray_ISALIGNED((PyArrayObject*) py_V575)) { 30485 PyArrayObject * tmp = (PyArrayObject*) py_V575; 30486 PyErr_Format(PyExc_NotImplementedError, 30487 "expected an aligned array of type %ld " 30488 "(NPY_FLOAT64), got non-aligned array of type %ld" 30489 " with %ld dimensions, with 3 last dims " 30490 "%ld, %ld, %ld" 30491 " and 3 last strides %ld %ld, %ld.", 30492 (long int) NPY_FLOAT64, 30493 (long int) PyArray_TYPE((PyArrayObject*) py_V575), 30494 (long int) PyArray_NDIM(tmp), 30495 (long int) (PyArray_NDIM(tmp) >= 3 ? 30496 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 30497 (long int) (PyArray_NDIM(tmp) >= 2 ? 30498 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 30499 (long int) (PyArray_NDIM(tmp) >= 1 ? 30500 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 30501 (long int) (PyArray_NDIM(tmp) >= 3 ? 30502 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 30503 (long int) (PyArray_NDIM(tmp) >= 2 ? 30504 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 30505 (long int) (PyArray_NDIM(tmp) >= 1 ? 30506 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 30507 ); 30508 { 30509 __failure = 576; 30510 if (!PyErr_Occurred()) { 30511 PyErr_SetString(PyExc_RuntimeError, 30512 "Unexpected error in an Op's C code. " 30513 "No Python exception was set."); 30514 } 30515 goto __label_576;} 30516 } 30517 // This is a TypeError to be consistent with DEBUG_MODE 30518 // Note: DEBUG_MODE also tells the name of the container 30519 if (PyArray_TYPE((PyArrayObject*) py_V575) != NPY_FLOAT64) { 30520 PyErr_Format(PyExc_TypeError, 30521 "expected type_num %d (NPY_FLOAT64) got %d", 30522 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V575)); 30523 { 30524 __failure = 576; 30525 if (!PyErr_Occurred()) { 30526 PyErr_SetString(PyExc_RuntimeError, 30527 "Unexpected error in an Op's C code. " 30528 "No Python exception was set."); 30529 } 30530 goto __label_576;} 30531 } 30532 30533 V575 = (PyArrayObject*)(py_V575); 30534 Py_XINCREF(V575); 30535 30536 { 30537 30538 py_V577 = PyList_GET_ITEM(storage_V577, 0); 30539 {Py_XINCREF(py_V577);} 30540 30541 V577 = NULL; 30542 if (py_V577 == Py_None) { 30543 // We can either fail here or set V577 to NULL and rely on Ops 30544 // using tensors to handle the NULL case, but if they fail to do so 30545 // they'll end up with nasty segfaults, so this is public service. 30546 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 30547 { 30548 __failure = 578; 30549 if (!PyErr_Occurred()) { 30550 PyErr_SetString(PyExc_RuntimeError, 30551 "Unexpected error in an Op's C code. " 30552 "No Python exception was set."); 30553 } 30554 goto __label_578;} 30555 } 30556 if (!PyArray_Check(py_V577)) { 30557 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 30558 { 30559 __failure = 578; 30560 if (!PyErr_Occurred()) { 30561 PyErr_SetString(PyExc_RuntimeError, 30562 "Unexpected error in an Op's C code. " 30563 "No Python exception was set."); 30564 } 30565 goto __label_578;} 30566 } 30567 // We expect NPY_FLOAT64 30568 if (!PyArray_ISALIGNED((PyArrayObject*) py_V577)) { 30569 PyArrayObject * tmp = (PyArrayObject*) py_V577; 30570 PyErr_Format(PyExc_NotImplementedError, 30571 "expected an aligned array of type %ld " 30572 "(NPY_FLOAT64), got non-aligned array of type %ld" 30573 " with %ld dimensions, with 3 last dims " 30574 "%ld, %ld, %ld" 30575 " and 3 last strides %ld %ld, %ld.", 30576 (long int) NPY_FLOAT64, 30577 (long int) PyArray_TYPE((PyArrayObject*) py_V577), 30578 (long int) PyArray_NDIM(tmp), 30579 (long int) (PyArray_NDIM(tmp) >= 3 ? 30580 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 30581 (long int) (PyArray_NDIM(tmp) >= 2 ? 30582 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 30583 (long int) (PyArray_NDIM(tmp) >= 1 ? 30584 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 30585 (long int) (PyArray_NDIM(tmp) >= 3 ? 30586 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 30587 (long int) (PyArray_NDIM(tmp) >= 2 ? 30588 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 30589 (long int) (PyArray_NDIM(tmp) >= 1 ? 30590 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 30591 ); 30592 { 30593 __failure = 578; 30594 if (!PyErr_Occurred()) { 30595 PyErr_SetString(PyExc_RuntimeError, 30596 "Unexpected error in an Op's C code. " 30597 "No Python exception was set."); 30598 } 30599 goto __label_578;} 30600 } 30601 // This is a TypeError to be consistent with DEBUG_MODE 30602 // Note: DEBUG_MODE also tells the name of the container 30603 if (PyArray_TYPE((PyArrayObject*) py_V577) != NPY_FLOAT64) { 30604 PyErr_Format(PyExc_TypeError, 30605 "expected type_num %d (NPY_FLOAT64) got %d", 30606 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V577)); 30607 { 30608 __failure = 578; 30609 if (!PyErr_Occurred()) { 30610 PyErr_SetString(PyExc_RuntimeError, 30611 "Unexpected error in an Op's C code. " 30612 "No Python exception was set."); 30613 } 30614 goto __label_578;} 30615 } 30616 30617 V577 = (PyArrayObject*)(py_V577); 30618 Py_XINCREF(V577); 30619 30620 { 30621 30622 py_V579 = PyList_GET_ITEM(storage_V579, 0); 30623 {Py_XINCREF(py_V579);} 30624 30625 V579 = NULL; 30626 if (py_V579 == Py_None) { 30627 // We can either fail here or set V579 to NULL and rely on Ops 30628 // using tensors to handle the NULL case, but if they fail to do so 30629 // they'll end up with nasty segfaults, so this is public service. 30630 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 30631 { 30632 __failure = 580; 30633 if (!PyErr_Occurred()) { 30634 PyErr_SetString(PyExc_RuntimeError, 30635 "Unexpected error in an Op's C code. " 30636 "No Python exception was set."); 30637 } 30638 goto __label_580;} 30639 } 30640 if (!PyArray_Check(py_V579)) { 30641 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 30642 { 30643 __failure = 580; 30644 if (!PyErr_Occurred()) { 30645 PyErr_SetString(PyExc_RuntimeError, 30646 "Unexpected error in an Op's C code. " 30647 "No Python exception was set."); 30648 } 30649 goto __label_580;} 30650 } 30651 // We expect NPY_FLOAT64 30652 if (!PyArray_ISALIGNED((PyArrayObject*) py_V579)) { 30653 PyArrayObject * tmp = (PyArrayObject*) py_V579; 30654 PyErr_Format(PyExc_NotImplementedError, 30655 "expected an aligned array of type %ld " 30656 "(NPY_FLOAT64), got non-aligned array of type %ld" 30657 " with %ld dimensions, with 3 last dims " 30658 "%ld, %ld, %ld" 30659 " and 3 last strides %ld %ld, %ld.", 30660 (long int) NPY_FLOAT64, 30661 (long int) PyArray_TYPE((PyArrayObject*) py_V579), 30662 (long int) PyArray_NDIM(tmp), 30663 (long int) (PyArray_NDIM(tmp) >= 3 ? 30664 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 30665 (long int) (PyArray_NDIM(tmp) >= 2 ? 30666 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 30667 (long int) (PyArray_NDIM(tmp) >= 1 ? 30668 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 30669 (long int) (PyArray_NDIM(tmp) >= 3 ? 30670 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 30671 (long int) (PyArray_NDIM(tmp) >= 2 ? 30672 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 30673 (long int) (PyArray_NDIM(tmp) >= 1 ? 30674 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 30675 ); 30676 { 30677 __failure = 580; 30678 if (!PyErr_Occurred()) { 30679 PyErr_SetString(PyExc_RuntimeError, 30680 "Unexpected error in an Op's C code. " 30681 "No Python exception was set."); 30682 } 30683 goto __label_580;} 30684 } 30685 // This is a TypeError to be consistent with DEBUG_MODE 30686 // Note: DEBUG_MODE also tells the name of the container 30687 if (PyArray_TYPE((PyArrayObject*) py_V579) != NPY_FLOAT64) { 30688 PyErr_Format(PyExc_TypeError, 30689 "expected type_num %d (NPY_FLOAT64) got %d", 30690 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V579)); 30691 { 30692 __failure = 580; 30693 if (!PyErr_Occurred()) { 30694 PyErr_SetString(PyExc_RuntimeError, 30695 "Unexpected error in an Op's C code. " 30696 "No Python exception was set."); 30697 } 30698 goto __label_580;} 30699 } 30700 30701 V579 = (PyArrayObject*)(py_V579); 30702 Py_XINCREF(V579); 30703 30704 { 30705 30706 py_V581 = PyList_GET_ITEM(storage_V581, 0); 30707 {Py_XINCREF(py_V581);} 30708 30709 V581 = NULL; 30710 if (py_V581 == Py_None) { 30711 // We can either fail here or set V581 to NULL and rely on Ops 30712 // using tensors to handle the NULL case, but if they fail to do so 30713 // they'll end up with nasty segfaults, so this is public service. 30714 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 30715 { 30716 __failure = 582; 30717 if (!PyErr_Occurred()) { 30718 PyErr_SetString(PyExc_RuntimeError, 30719 "Unexpected error in an Op's C code. " 30720 "No Python exception was set."); 30721 } 30722 goto __label_582;} 30723 } 30724 if (!PyArray_Check(py_V581)) { 30725 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 30726 { 30727 __failure = 582; 30728 if (!PyErr_Occurred()) { 30729 PyErr_SetString(PyExc_RuntimeError, 30730 "Unexpected error in an Op's C code. " 30731 "No Python exception was set."); 30732 } 30733 goto __label_582;} 30734 } 30735 // We expect NPY_FLOAT64 30736 if (!PyArray_ISALIGNED((PyArrayObject*) py_V581)) { 30737 PyArrayObject * tmp = (PyArrayObject*) py_V581; 30738 PyErr_Format(PyExc_NotImplementedError, 30739 "expected an aligned array of type %ld " 30740 "(NPY_FLOAT64), got non-aligned array of type %ld" 30741 " with %ld dimensions, with 3 last dims " 30742 "%ld, %ld, %ld" 30743 " and 3 last strides %ld %ld, %ld.", 30744 (long int) NPY_FLOAT64, 30745 (long int) PyArray_TYPE((PyArrayObject*) py_V581), 30746 (long int) PyArray_NDIM(tmp), 30747 (long int) (PyArray_NDIM(tmp) >= 3 ? 30748 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 30749 (long int) (PyArray_NDIM(tmp) >= 2 ? 30750 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 30751 (long int) (PyArray_NDIM(tmp) >= 1 ? 30752 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 30753 (long int) (PyArray_NDIM(tmp) >= 3 ? 30754 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 30755 (long int) (PyArray_NDIM(tmp) >= 2 ? 30756 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 30757 (long int) (PyArray_NDIM(tmp) >= 1 ? 30758 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 30759 ); 30760 { 30761 __failure = 582; 30762 if (!PyErr_Occurred()) { 30763 PyErr_SetString(PyExc_RuntimeError, 30764 "Unexpected error in an Op's C code. " 30765 "No Python exception was set."); 30766 } 30767 goto __label_582;} 30768 } 30769 // This is a TypeError to be consistent with DEBUG_MODE 30770 // Note: DEBUG_MODE also tells the name of the container 30771 if (PyArray_TYPE((PyArrayObject*) py_V581) != NPY_FLOAT64) { 30772 PyErr_Format(PyExc_TypeError, 30773 "expected type_num %d (NPY_FLOAT64) got %d", 30774 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V581)); 30775 { 30776 __failure = 582; 30777 if (!PyErr_Occurred()) { 30778 PyErr_SetString(PyExc_RuntimeError, 30779 "Unexpected error in an Op's C code. " 30780 "No Python exception was set."); 30781 } 30782 goto __label_582;} 30783 } 30784 30785 V581 = (PyArrayObject*)(py_V581); 30786 Py_XINCREF(V581); 30787 30788 { 30789 30790 py_V583 = PyList_GET_ITEM(storage_V583, 0); 30791 {Py_XINCREF(py_V583);} 30792 30793 V583 = NULL; 30794 if (py_V583 == Py_None) { 30795 // We can either fail here or set V583 to NULL and rely on Ops 30796 // using tensors to handle the NULL case, but if they fail to do so 30797 // they'll end up with nasty segfaults, so this is public service. 30798 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 30799 { 30800 __failure = 584; 30801 if (!PyErr_Occurred()) { 30802 PyErr_SetString(PyExc_RuntimeError, 30803 "Unexpected error in an Op's C code. " 30804 "No Python exception was set."); 30805 } 30806 goto __label_584;} 30807 } 30808 if (!PyArray_Check(py_V583)) { 30809 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 30810 { 30811 __failure = 584; 30812 if (!PyErr_Occurred()) { 30813 PyErr_SetString(PyExc_RuntimeError, 30814 "Unexpected error in an Op's C code. " 30815 "No Python exception was set."); 30816 } 30817 goto __label_584;} 30818 } 30819 // We expect NPY_FLOAT64 30820 if (!PyArray_ISALIGNED((PyArrayObject*) py_V583)) { 30821 PyArrayObject * tmp = (PyArrayObject*) py_V583; 30822 PyErr_Format(PyExc_NotImplementedError, 30823 "expected an aligned array of type %ld " 30824 "(NPY_FLOAT64), got non-aligned array of type %ld" 30825 " with %ld dimensions, with 3 last dims " 30826 "%ld, %ld, %ld" 30827 " and 3 last strides %ld %ld, %ld.", 30828 (long int) NPY_FLOAT64, 30829 (long int) PyArray_TYPE((PyArrayObject*) py_V583), 30830 (long int) PyArray_NDIM(tmp), 30831 (long int) (PyArray_NDIM(tmp) >= 3 ? 30832 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 30833 (long int) (PyArray_NDIM(tmp) >= 2 ? 30834 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 30835 (long int) (PyArray_NDIM(tmp) >= 1 ? 30836 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 30837 (long int) (PyArray_NDIM(tmp) >= 3 ? 30838 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 30839 (long int) (PyArray_NDIM(tmp) >= 2 ? 30840 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 30841 (long int) (PyArray_NDIM(tmp) >= 1 ? 30842 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 30843 ); 30844 { 30845 __failure = 584; 30846 if (!PyErr_Occurred()) { 30847 PyErr_SetString(PyExc_RuntimeError, 30848 "Unexpected error in an Op's C code. " 30849 "No Python exception was set."); 30850 } 30851 goto __label_584;} 30852 } 30853 // This is a TypeError to be consistent with DEBUG_MODE 30854 // Note: DEBUG_MODE also tells the name of the container 30855 if (PyArray_TYPE((PyArrayObject*) py_V583) != NPY_FLOAT64) { 30856 PyErr_Format(PyExc_TypeError, 30857 "expected type_num %d (NPY_FLOAT64) got %d", 30858 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V583)); 30859 { 30860 __failure = 584; 30861 if (!PyErr_Occurred()) { 30862 PyErr_SetString(PyExc_RuntimeError, 30863 "Unexpected error in an Op's C code. " 30864 "No Python exception was set."); 30865 } 30866 goto __label_584;} 30867 } 30868 30869 V583 = (PyArrayObject*)(py_V583); 30870 Py_XINCREF(V583); 30871 30872 { 30873 30874 py_V585 = PyList_GET_ITEM(storage_V585, 0); 30875 {Py_XINCREF(py_V585);} 30876 30877 V585 = NULL; 30878 if (py_V585 == Py_None) { 30879 // We can either fail here or set V585 to NULL and rely on Ops 30880 // using tensors to handle the NULL case, but if they fail to do so 30881 // they'll end up with nasty segfaults, so this is public service. 30882 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 30883 { 30884 __failure = 586; 30885 if (!PyErr_Occurred()) { 30886 PyErr_SetString(PyExc_RuntimeError, 30887 "Unexpected error in an Op's C code. " 30888 "No Python exception was set."); 30889 } 30890 goto __label_586;} 30891 } 30892 if (!PyArray_Check(py_V585)) { 30893 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 30894 { 30895 __failure = 586; 30896 if (!PyErr_Occurred()) { 30897 PyErr_SetString(PyExc_RuntimeError, 30898 "Unexpected error in an Op's C code. " 30899 "No Python exception was set."); 30900 } 30901 goto __label_586;} 30902 } 30903 // We expect NPY_FLOAT64 30904 if (!PyArray_ISALIGNED((PyArrayObject*) py_V585)) { 30905 PyArrayObject * tmp = (PyArrayObject*) py_V585; 30906 PyErr_Format(PyExc_NotImplementedError, 30907 "expected an aligned array of type %ld " 30908 "(NPY_FLOAT64), got non-aligned array of type %ld" 30909 " with %ld dimensions, with 3 last dims " 30910 "%ld, %ld, %ld" 30911 " and 3 last strides %ld %ld, %ld.", 30912 (long int) NPY_FLOAT64, 30913 (long int) PyArray_TYPE((PyArrayObject*) py_V585), 30914 (long int) PyArray_NDIM(tmp), 30915 (long int) (PyArray_NDIM(tmp) >= 3 ? 30916 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 30917 (long int) (PyArray_NDIM(tmp) >= 2 ? 30918 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 30919 (long int) (PyArray_NDIM(tmp) >= 1 ? 30920 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 30921 (long int) (PyArray_NDIM(tmp) >= 3 ? 30922 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 30923 (long int) (PyArray_NDIM(tmp) >= 2 ? 30924 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 30925 (long int) (PyArray_NDIM(tmp) >= 1 ? 30926 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 30927 ); 30928 { 30929 __failure = 586; 30930 if (!PyErr_Occurred()) { 30931 PyErr_SetString(PyExc_RuntimeError, 30932 "Unexpected error in an Op's C code. " 30933 "No Python exception was set."); 30934 } 30935 goto __label_586;} 30936 } 30937 // This is a TypeError to be consistent with DEBUG_MODE 30938 // Note: DEBUG_MODE also tells the name of the container 30939 if (PyArray_TYPE((PyArrayObject*) py_V585) != NPY_FLOAT64) { 30940 PyErr_Format(PyExc_TypeError, 30941 "expected type_num %d (NPY_FLOAT64) got %d", 30942 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V585)); 30943 { 30944 __failure = 586; 30945 if (!PyErr_Occurred()) { 30946 PyErr_SetString(PyExc_RuntimeError, 30947 "Unexpected error in an Op's C code. " 30948 "No Python exception was set."); 30949 } 30950 goto __label_586;} 30951 } 30952 30953 V585 = (PyArrayObject*)(py_V585); 30954 Py_XINCREF(V585); 30955 30956 { 30957 30958 py_V587 = PyList_GET_ITEM(storage_V587, 0); 30959 {Py_XINCREF(py_V587);} 30960 30961 V587 = NULL; 30962 if (py_V587 == Py_None) { 30963 // We can either fail here or set V587 to NULL and rely on Ops 30964 // using tensors to handle the NULL case, but if they fail to do so 30965 // they'll end up with nasty segfaults, so this is public service. 30966 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 30967 { 30968 __failure = 588; 30969 if (!PyErr_Occurred()) { 30970 PyErr_SetString(PyExc_RuntimeError, 30971 "Unexpected error in an Op's C code. " 30972 "No Python exception was set."); 30973 } 30974 goto __label_588;} 30975 } 30976 if (!PyArray_Check(py_V587)) { 30977 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 30978 { 30979 __failure = 588; 30980 if (!PyErr_Occurred()) { 30981 PyErr_SetString(PyExc_RuntimeError, 30982 "Unexpected error in an Op's C code. " 30983 "No Python exception was set."); 30984 } 30985 goto __label_588;} 30986 } 30987 // We expect NPY_FLOAT64 30988 if (!PyArray_ISALIGNED((PyArrayObject*) py_V587)) { 30989 PyArrayObject * tmp = (PyArrayObject*) py_V587; 30990 PyErr_Format(PyExc_NotImplementedError, 30991 "expected an aligned array of type %ld " 30992 "(NPY_FLOAT64), got non-aligned array of type %ld" 30993 " with %ld dimensions, with 3 last dims " 30994 "%ld, %ld, %ld" 30995 " and 3 last strides %ld %ld, %ld.", 30996 (long int) NPY_FLOAT64, 30997 (long int) PyArray_TYPE((PyArrayObject*) py_V587), 30998 (long int) PyArray_NDIM(tmp), 30999 (long int) (PyArray_NDIM(tmp) >= 3 ? 31000 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 31001 (long int) (PyArray_NDIM(tmp) >= 2 ? 31002 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 31003 (long int) (PyArray_NDIM(tmp) >= 1 ? 31004 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 31005 (long int) (PyArray_NDIM(tmp) >= 3 ? 31006 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 31007 (long int) (PyArray_NDIM(tmp) >= 2 ? 31008 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 31009 (long int) (PyArray_NDIM(tmp) >= 1 ? 31010 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 31011 ); 31012 { 31013 __failure = 588; 31014 if (!PyErr_Occurred()) { 31015 PyErr_SetString(PyExc_RuntimeError, 31016 "Unexpected error in an Op's C code. " 31017 "No Python exception was set."); 31018 } 31019 goto __label_588;} 31020 } 31021 // This is a TypeError to be consistent with DEBUG_MODE 31022 // Note: DEBUG_MODE also tells the name of the container 31023 if (PyArray_TYPE((PyArrayObject*) py_V587) != NPY_FLOAT64) { 31024 PyErr_Format(PyExc_TypeError, 31025 "expected type_num %d (NPY_FLOAT64) got %d", 31026 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V587)); 31027 { 31028 __failure = 588; 31029 if (!PyErr_Occurred()) { 31030 PyErr_SetString(PyExc_RuntimeError, 31031 "Unexpected error in an Op's C code. " 31032 "No Python exception was set."); 31033 } 31034 goto __label_588;} 31035 } 31036 31037 V587 = (PyArrayObject*)(py_V587); 31038 Py_XINCREF(V587); 31039 31040 { 31041 31042 py_V589 = PyList_GET_ITEM(storage_V589, 0); 31043 {Py_XINCREF(py_V589);} 31044 31045 V589 = NULL; 31046 if (py_V589 == Py_None) { 31047 // We can either fail here or set V589 to NULL and rely on Ops 31048 // using tensors to handle the NULL case, but if they fail to do so 31049 // they'll end up with nasty segfaults, so this is public service. 31050 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 31051 { 31052 __failure = 590; 31053 if (!PyErr_Occurred()) { 31054 PyErr_SetString(PyExc_RuntimeError, 31055 "Unexpected error in an Op's C code. " 31056 "No Python exception was set."); 31057 } 31058 goto __label_590;} 31059 } 31060 if (!PyArray_Check(py_V589)) { 31061 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 31062 { 31063 __failure = 590; 31064 if (!PyErr_Occurred()) { 31065 PyErr_SetString(PyExc_RuntimeError, 31066 "Unexpected error in an Op's C code. " 31067 "No Python exception was set."); 31068 } 31069 goto __label_590;} 31070 } 31071 // We expect NPY_FLOAT64 31072 if (!PyArray_ISALIGNED((PyArrayObject*) py_V589)) { 31073 PyArrayObject * tmp = (PyArrayObject*) py_V589; 31074 PyErr_Format(PyExc_NotImplementedError, 31075 "expected an aligned array of type %ld " 31076 "(NPY_FLOAT64), got non-aligned array of type %ld" 31077 " with %ld dimensions, with 3 last dims " 31078 "%ld, %ld, %ld" 31079 " and 3 last strides %ld %ld, %ld.", 31080 (long int) NPY_FLOAT64, 31081 (long int) PyArray_TYPE((PyArrayObject*) py_V589), 31082 (long int) PyArray_NDIM(tmp), 31083 (long int) (PyArray_NDIM(tmp) >= 3 ? 31084 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 31085 (long int) (PyArray_NDIM(tmp) >= 2 ? 31086 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 31087 (long int) (PyArray_NDIM(tmp) >= 1 ? 31088 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 31089 (long int) (PyArray_NDIM(tmp) >= 3 ? 31090 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 31091 (long int) (PyArray_NDIM(tmp) >= 2 ? 31092 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 31093 (long int) (PyArray_NDIM(tmp) >= 1 ? 31094 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 31095 ); 31096 { 31097 __failure = 590; 31098 if (!PyErr_Occurred()) { 31099 PyErr_SetString(PyExc_RuntimeError, 31100 "Unexpected error in an Op's C code. " 31101 "No Python exception was set."); 31102 } 31103 goto __label_590;} 31104 } 31105 // This is a TypeError to be consistent with DEBUG_MODE 31106 // Note: DEBUG_MODE also tells the name of the container 31107 if (PyArray_TYPE((PyArrayObject*) py_V589) != NPY_FLOAT64) { 31108 PyErr_Format(PyExc_TypeError, 31109 "expected type_num %d (NPY_FLOAT64) got %d", 31110 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V589)); 31111 { 31112 __failure = 590; 31113 if (!PyErr_Occurred()) { 31114 PyErr_SetString(PyExc_RuntimeError, 31115 "Unexpected error in an Op's C code. " 31116 "No Python exception was set."); 31117 } 31118 goto __label_590;} 31119 } 31120 31121 V589 = (PyArrayObject*)(py_V589); 31122 Py_XINCREF(V589); 31123 31124 { 31125 31126 py_V591 = PyList_GET_ITEM(storage_V591, 0); 31127 {Py_XINCREF(py_V591);} 31128 31129 V591 = NULL; 31130 if (py_V591 == Py_None) { 31131 // We can either fail here or set V591 to NULL and rely on Ops 31132 // using tensors to handle the NULL case, but if they fail to do so 31133 // they'll end up with nasty segfaults, so this is public service. 31134 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 31135 { 31136 __failure = 592; 31137 if (!PyErr_Occurred()) { 31138 PyErr_SetString(PyExc_RuntimeError, 31139 "Unexpected error in an Op's C code. " 31140 "No Python exception was set."); 31141 } 31142 goto __label_592;} 31143 } 31144 if (!PyArray_Check(py_V591)) { 31145 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 31146 { 31147 __failure = 592; 31148 if (!PyErr_Occurred()) { 31149 PyErr_SetString(PyExc_RuntimeError, 31150 "Unexpected error in an Op's C code. " 31151 "No Python exception was set."); 31152 } 31153 goto __label_592;} 31154 } 31155 // We expect NPY_FLOAT64 31156 if (!PyArray_ISALIGNED((PyArrayObject*) py_V591)) { 31157 PyArrayObject * tmp = (PyArrayObject*) py_V591; 31158 PyErr_Format(PyExc_NotImplementedError, 31159 "expected an aligned array of type %ld " 31160 "(NPY_FLOAT64), got non-aligned array of type %ld" 31161 " with %ld dimensions, with 3 last dims " 31162 "%ld, %ld, %ld" 31163 " and 3 last strides %ld %ld, %ld.", 31164 (long int) NPY_FLOAT64, 31165 (long int) PyArray_TYPE((PyArrayObject*) py_V591), 31166 (long int) PyArray_NDIM(tmp), 31167 (long int) (PyArray_NDIM(tmp) >= 3 ? 31168 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 31169 (long int) (PyArray_NDIM(tmp) >= 2 ? 31170 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 31171 (long int) (PyArray_NDIM(tmp) >= 1 ? 31172 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 31173 (long int) (PyArray_NDIM(tmp) >= 3 ? 31174 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 31175 (long int) (PyArray_NDIM(tmp) >= 2 ? 31176 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 31177 (long int) (PyArray_NDIM(tmp) >= 1 ? 31178 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 31179 ); 31180 { 31181 __failure = 592; 31182 if (!PyErr_Occurred()) { 31183 PyErr_SetString(PyExc_RuntimeError, 31184 "Unexpected error in an Op's C code. " 31185 "No Python exception was set."); 31186 } 31187 goto __label_592;} 31188 } 31189 // This is a TypeError to be consistent with DEBUG_MODE 31190 // Note: DEBUG_MODE also tells the name of the container 31191 if (PyArray_TYPE((PyArrayObject*) py_V591) != NPY_FLOAT64) { 31192 PyErr_Format(PyExc_TypeError, 31193 "expected type_num %d (NPY_FLOAT64) got %d", 31194 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V591)); 31195 { 31196 __failure = 592; 31197 if (!PyErr_Occurred()) { 31198 PyErr_SetString(PyExc_RuntimeError, 31199 "Unexpected error in an Op's C code. " 31200 "No Python exception was set."); 31201 } 31202 goto __label_592;} 31203 } 31204 31205 V591 = (PyArrayObject*)(py_V591); 31206 Py_XINCREF(V591); 31207 31208 { 31209 31210 py_V593 = PyList_GET_ITEM(storage_V593, 0); 31211 {Py_XINCREF(py_V593);} 31212 31213 V593 = NULL; 31214 if (py_V593 == Py_None) { 31215 // We can either fail here or set V593 to NULL and rely on Ops 31216 // using tensors to handle the NULL case, but if they fail to do so 31217 // they'll end up with nasty segfaults, so this is public service. 31218 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 31219 { 31220 __failure = 594; 31221 if (!PyErr_Occurred()) { 31222 PyErr_SetString(PyExc_RuntimeError, 31223 "Unexpected error in an Op's C code. " 31224 "No Python exception was set."); 31225 } 31226 goto __label_594;} 31227 } 31228 if (!PyArray_Check(py_V593)) { 31229 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 31230 { 31231 __failure = 594; 31232 if (!PyErr_Occurred()) { 31233 PyErr_SetString(PyExc_RuntimeError, 31234 "Unexpected error in an Op's C code. " 31235 "No Python exception was set."); 31236 } 31237 goto __label_594;} 31238 } 31239 // We expect NPY_FLOAT64 31240 if (!PyArray_ISALIGNED((PyArrayObject*) py_V593)) { 31241 PyArrayObject * tmp = (PyArrayObject*) py_V593; 31242 PyErr_Format(PyExc_NotImplementedError, 31243 "expected an aligned array of type %ld " 31244 "(NPY_FLOAT64), got non-aligned array of type %ld" 31245 " with %ld dimensions, with 3 last dims " 31246 "%ld, %ld, %ld" 31247 " and 3 last strides %ld %ld, %ld.", 31248 (long int) NPY_FLOAT64, 31249 (long int) PyArray_TYPE((PyArrayObject*) py_V593), 31250 (long int) PyArray_NDIM(tmp), 31251 (long int) (PyArray_NDIM(tmp) >= 3 ? 31252 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 31253 (long int) (PyArray_NDIM(tmp) >= 2 ? 31254 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 31255 (long int) (PyArray_NDIM(tmp) >= 1 ? 31256 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 31257 (long int) (PyArray_NDIM(tmp) >= 3 ? 31258 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 31259 (long int) (PyArray_NDIM(tmp) >= 2 ? 31260 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 31261 (long int) (PyArray_NDIM(tmp) >= 1 ? 31262 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 31263 ); 31264 { 31265 __failure = 594; 31266 if (!PyErr_Occurred()) { 31267 PyErr_SetString(PyExc_RuntimeError, 31268 "Unexpected error in an Op's C code. " 31269 "No Python exception was set."); 31270 } 31271 goto __label_594;} 31272 } 31273 // This is a TypeError to be consistent with DEBUG_MODE 31274 // Note: DEBUG_MODE also tells the name of the container 31275 if (PyArray_TYPE((PyArrayObject*) py_V593) != NPY_FLOAT64) { 31276 PyErr_Format(PyExc_TypeError, 31277 "expected type_num %d (NPY_FLOAT64) got %d", 31278 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V593)); 31279 { 31280 __failure = 594; 31281 if (!PyErr_Occurred()) { 31282 PyErr_SetString(PyExc_RuntimeError, 31283 "Unexpected error in an Op's C code. " 31284 "No Python exception was set."); 31285 } 31286 goto __label_594;} 31287 } 31288 31289 V593 = (PyArrayObject*)(py_V593); 31290 Py_XINCREF(V593); 31291 31292 { 31293 31294 py_V595 = PyList_GET_ITEM(storage_V595, 0); 31295 {Py_XINCREF(py_V595);} 31296 31297 V595 = NULL; 31298 if (py_V595 == Py_None) { 31299 // We can either fail here or set V595 to NULL and rely on Ops 31300 // using tensors to handle the NULL case, but if they fail to do so 31301 // they'll end up with nasty segfaults, so this is public service. 31302 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 31303 { 31304 __failure = 596; 31305 if (!PyErr_Occurred()) { 31306 PyErr_SetString(PyExc_RuntimeError, 31307 "Unexpected error in an Op's C code. " 31308 "No Python exception was set."); 31309 } 31310 goto __label_596;} 31311 } 31312 if (!PyArray_Check(py_V595)) { 31313 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 31314 { 31315 __failure = 596; 31316 if (!PyErr_Occurred()) { 31317 PyErr_SetString(PyExc_RuntimeError, 31318 "Unexpected error in an Op's C code. " 31319 "No Python exception was set."); 31320 } 31321 goto __label_596;} 31322 } 31323 // We expect NPY_FLOAT64 31324 if (!PyArray_ISALIGNED((PyArrayObject*) py_V595)) { 31325 PyArrayObject * tmp = (PyArrayObject*) py_V595; 31326 PyErr_Format(PyExc_NotImplementedError, 31327 "expected an aligned array of type %ld " 31328 "(NPY_FLOAT64), got non-aligned array of type %ld" 31329 " with %ld dimensions, with 3 last dims " 31330 "%ld, %ld, %ld" 31331 " and 3 last strides %ld %ld, %ld.", 31332 (long int) NPY_FLOAT64, 31333 (long int) PyArray_TYPE((PyArrayObject*) py_V595), 31334 (long int) PyArray_NDIM(tmp), 31335 (long int) (PyArray_NDIM(tmp) >= 3 ? 31336 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 31337 (long int) (PyArray_NDIM(tmp) >= 2 ? 31338 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 31339 (long int) (PyArray_NDIM(tmp) >= 1 ? 31340 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 31341 (long int) (PyArray_NDIM(tmp) >= 3 ? 31342 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 31343 (long int) (PyArray_NDIM(tmp) >= 2 ? 31344 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 31345 (long int) (PyArray_NDIM(tmp) >= 1 ? 31346 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 31347 ); 31348 { 31349 __failure = 596; 31350 if (!PyErr_Occurred()) { 31351 PyErr_SetString(PyExc_RuntimeError, 31352 "Unexpected error in an Op's C code. " 31353 "No Python exception was set."); 31354 } 31355 goto __label_596;} 31356 } 31357 // This is a TypeError to be consistent with DEBUG_MODE 31358 // Note: DEBUG_MODE also tells the name of the container 31359 if (PyArray_TYPE((PyArrayObject*) py_V595) != NPY_FLOAT64) { 31360 PyErr_Format(PyExc_TypeError, 31361 "expected type_num %d (NPY_FLOAT64) got %d", 31362 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V595)); 31363 { 31364 __failure = 596; 31365 if (!PyErr_Occurred()) { 31366 PyErr_SetString(PyExc_RuntimeError, 31367 "Unexpected error in an Op's C code. " 31368 "No Python exception was set."); 31369 } 31370 goto __label_596;} 31371 } 31372 31373 V595 = (PyArrayObject*)(py_V595); 31374 Py_XINCREF(V595); 31375 31376 { 31377 31378 py_V597 = PyList_GET_ITEM(storage_V597, 0); 31379 {Py_XINCREF(py_V597);} 31380 31381 V597 = NULL; 31382 if (py_V597 == Py_None) { 31383 // We can either fail here or set V597 to NULL and rely on Ops 31384 // using tensors to handle the NULL case, but if they fail to do so 31385 // they'll end up with nasty segfaults, so this is public service. 31386 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 31387 { 31388 __failure = 598; 31389 if (!PyErr_Occurred()) { 31390 PyErr_SetString(PyExc_RuntimeError, 31391 "Unexpected error in an Op's C code. " 31392 "No Python exception was set."); 31393 } 31394 goto __label_598;} 31395 } 31396 if (!PyArray_Check(py_V597)) { 31397 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 31398 { 31399 __failure = 598; 31400 if (!PyErr_Occurred()) { 31401 PyErr_SetString(PyExc_RuntimeError, 31402 "Unexpected error in an Op's C code. " 31403 "No Python exception was set."); 31404 } 31405 goto __label_598;} 31406 } 31407 // We expect NPY_FLOAT64 31408 if (!PyArray_ISALIGNED((PyArrayObject*) py_V597)) { 31409 PyArrayObject * tmp = (PyArrayObject*) py_V597; 31410 PyErr_Format(PyExc_NotImplementedError, 31411 "expected an aligned array of type %ld " 31412 "(NPY_FLOAT64), got non-aligned array of type %ld" 31413 " with %ld dimensions, with 3 last dims " 31414 "%ld, %ld, %ld" 31415 " and 3 last strides %ld %ld, %ld.", 31416 (long int) NPY_FLOAT64, 31417 (long int) PyArray_TYPE((PyArrayObject*) py_V597), 31418 (long int) PyArray_NDIM(tmp), 31419 (long int) (PyArray_NDIM(tmp) >= 3 ? 31420 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 31421 (long int) (PyArray_NDIM(tmp) >= 2 ? 31422 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 31423 (long int) (PyArray_NDIM(tmp) >= 1 ? 31424 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 31425 (long int) (PyArray_NDIM(tmp) >= 3 ? 31426 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 31427 (long int) (PyArray_NDIM(tmp) >= 2 ? 31428 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 31429 (long int) (PyArray_NDIM(tmp) >= 1 ? 31430 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 31431 ); 31432 { 31433 __failure = 598; 31434 if (!PyErr_Occurred()) { 31435 PyErr_SetString(PyExc_RuntimeError, 31436 "Unexpected error in an Op's C code. " 31437 "No Python exception was set."); 31438 } 31439 goto __label_598;} 31440 } 31441 // This is a TypeError to be consistent with DEBUG_MODE 31442 // Note: DEBUG_MODE also tells the name of the container 31443 if (PyArray_TYPE((PyArrayObject*) py_V597) != NPY_FLOAT64) { 31444 PyErr_Format(PyExc_TypeError, 31445 "expected type_num %d (NPY_FLOAT64) got %d", 31446 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V597)); 31447 { 31448 __failure = 598; 31449 if (!PyErr_Occurred()) { 31450 PyErr_SetString(PyExc_RuntimeError, 31451 "Unexpected error in an Op's C code. " 31452 "No Python exception was set."); 31453 } 31454 goto __label_598;} 31455 } 31456 31457 V597 = (PyArrayObject*)(py_V597); 31458 Py_XINCREF(V597); 31459 31460 { 31461 31462 py_V599 = PyList_GET_ITEM(storage_V599, 0); 31463 {Py_XINCREF(py_V599);} 31464 31465 V599 = NULL; 31466 if (py_V599 == Py_None) { 31467 // We can either fail here or set V599 to NULL and rely on Ops 31468 // using tensors to handle the NULL case, but if they fail to do so 31469 // they'll end up with nasty segfaults, so this is public service. 31470 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 31471 { 31472 __failure = 600; 31473 if (!PyErr_Occurred()) { 31474 PyErr_SetString(PyExc_RuntimeError, 31475 "Unexpected error in an Op's C code. " 31476 "No Python exception was set."); 31477 } 31478 goto __label_600;} 31479 } 31480 if (!PyArray_Check(py_V599)) { 31481 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 31482 { 31483 __failure = 600; 31484 if (!PyErr_Occurred()) { 31485 PyErr_SetString(PyExc_RuntimeError, 31486 "Unexpected error in an Op's C code. " 31487 "No Python exception was set."); 31488 } 31489 goto __label_600;} 31490 } 31491 // We expect NPY_FLOAT64 31492 if (!PyArray_ISALIGNED((PyArrayObject*) py_V599)) { 31493 PyArrayObject * tmp = (PyArrayObject*) py_V599; 31494 PyErr_Format(PyExc_NotImplementedError, 31495 "expected an aligned array of type %ld " 31496 "(NPY_FLOAT64), got non-aligned array of type %ld" 31497 " with %ld dimensions, with 3 last dims " 31498 "%ld, %ld, %ld" 31499 " and 3 last strides %ld %ld, %ld.", 31500 (long int) NPY_FLOAT64, 31501 (long int) PyArray_TYPE((PyArrayObject*) py_V599), 31502 (long int) PyArray_NDIM(tmp), 31503 (long int) (PyArray_NDIM(tmp) >= 3 ? 31504 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 31505 (long int) (PyArray_NDIM(tmp) >= 2 ? 31506 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 31507 (long int) (PyArray_NDIM(tmp) >= 1 ? 31508 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 31509 (long int) (PyArray_NDIM(tmp) >= 3 ? 31510 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 31511 (long int) (PyArray_NDIM(tmp) >= 2 ? 31512 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 31513 (long int) (PyArray_NDIM(tmp) >= 1 ? 31514 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 31515 ); 31516 { 31517 __failure = 600; 31518 if (!PyErr_Occurred()) { 31519 PyErr_SetString(PyExc_RuntimeError, 31520 "Unexpected error in an Op's C code. " 31521 "No Python exception was set."); 31522 } 31523 goto __label_600;} 31524 } 31525 // This is a TypeError to be consistent with DEBUG_MODE 31526 // Note: DEBUG_MODE also tells the name of the container 31527 if (PyArray_TYPE((PyArrayObject*) py_V599) != NPY_FLOAT64) { 31528 PyErr_Format(PyExc_TypeError, 31529 "expected type_num %d (NPY_FLOAT64) got %d", 31530 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V599)); 31531 { 31532 __failure = 600; 31533 if (!PyErr_Occurred()) { 31534 PyErr_SetString(PyExc_RuntimeError, 31535 "Unexpected error in an Op's C code. " 31536 "No Python exception was set."); 31537 } 31538 goto __label_600;} 31539 } 31540 31541 V599 = (PyArrayObject*)(py_V599); 31542 Py_XINCREF(V599); 31543 31544 { 31545 31546 py_V601 = PyList_GET_ITEM(storage_V601, 0); 31547 {Py_XINCREF(py_V601);} 31548 31549 V601 = NULL; 31550 if (py_V601 == Py_None) { 31551 // We can either fail here or set V601 to NULL and rely on Ops 31552 // using tensors to handle the NULL case, but if they fail to do so 31553 // they'll end up with nasty segfaults, so this is public service. 31554 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 31555 { 31556 __failure = 602; 31557 if (!PyErr_Occurred()) { 31558 PyErr_SetString(PyExc_RuntimeError, 31559 "Unexpected error in an Op's C code. " 31560 "No Python exception was set."); 31561 } 31562 goto __label_602;} 31563 } 31564 if (!PyArray_Check(py_V601)) { 31565 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 31566 { 31567 __failure = 602; 31568 if (!PyErr_Occurred()) { 31569 PyErr_SetString(PyExc_RuntimeError, 31570 "Unexpected error in an Op's C code. " 31571 "No Python exception was set."); 31572 } 31573 goto __label_602;} 31574 } 31575 // We expect NPY_FLOAT64 31576 if (!PyArray_ISALIGNED((PyArrayObject*) py_V601)) { 31577 PyArrayObject * tmp = (PyArrayObject*) py_V601; 31578 PyErr_Format(PyExc_NotImplementedError, 31579 "expected an aligned array of type %ld " 31580 "(NPY_FLOAT64), got non-aligned array of type %ld" 31581 " with %ld dimensions, with 3 last dims " 31582 "%ld, %ld, %ld" 31583 " and 3 last strides %ld %ld, %ld.", 31584 (long int) NPY_FLOAT64, 31585 (long int) PyArray_TYPE((PyArrayObject*) py_V601), 31586 (long int) PyArray_NDIM(tmp), 31587 (long int) (PyArray_NDIM(tmp) >= 3 ? 31588 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 31589 (long int) (PyArray_NDIM(tmp) >= 2 ? 31590 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 31591 (long int) (PyArray_NDIM(tmp) >= 1 ? 31592 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 31593 (long int) (PyArray_NDIM(tmp) >= 3 ? 31594 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 31595 (long int) (PyArray_NDIM(tmp) >= 2 ? 31596 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 31597 (long int) (PyArray_NDIM(tmp) >= 1 ? 31598 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 31599 ); 31600 { 31601 __failure = 602; 31602 if (!PyErr_Occurred()) { 31603 PyErr_SetString(PyExc_RuntimeError, 31604 "Unexpected error in an Op's C code. " 31605 "No Python exception was set."); 31606 } 31607 goto __label_602;} 31608 } 31609 // This is a TypeError to be consistent with DEBUG_MODE 31610 // Note: DEBUG_MODE also tells the name of the container 31611 if (PyArray_TYPE((PyArrayObject*) py_V601) != NPY_FLOAT64) { 31612 PyErr_Format(PyExc_TypeError, 31613 "expected type_num %d (NPY_FLOAT64) got %d", 31614 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V601)); 31615 { 31616 __failure = 602; 31617 if (!PyErr_Occurred()) { 31618 PyErr_SetString(PyExc_RuntimeError, 31619 "Unexpected error in an Op's C code. " 31620 "No Python exception was set."); 31621 } 31622 goto __label_602;} 31623 } 31624 31625 V601 = (PyArrayObject*)(py_V601); 31626 Py_XINCREF(V601); 31627 31628 { 31629 31630 py_V603 = PyList_GET_ITEM(storage_V603, 0); 31631 {Py_XINCREF(py_V603);} 31632 31633 V603 = NULL; 31634 if (py_V603 == Py_None) { 31635 // We can either fail here or set V603 to NULL and rely on Ops 31636 // using tensors to handle the NULL case, but if they fail to do so 31637 // they'll end up with nasty segfaults, so this is public service. 31638 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 31639 { 31640 __failure = 604; 31641 if (!PyErr_Occurred()) { 31642 PyErr_SetString(PyExc_RuntimeError, 31643 "Unexpected error in an Op's C code. " 31644 "No Python exception was set."); 31645 } 31646 goto __label_604;} 31647 } 31648 if (!PyArray_Check(py_V603)) { 31649 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 31650 { 31651 __failure = 604; 31652 if (!PyErr_Occurred()) { 31653 PyErr_SetString(PyExc_RuntimeError, 31654 "Unexpected error in an Op's C code. " 31655 "No Python exception was set."); 31656 } 31657 goto __label_604;} 31658 } 31659 // We expect NPY_FLOAT64 31660 if (!PyArray_ISALIGNED((PyArrayObject*) py_V603)) { 31661 PyArrayObject * tmp = (PyArrayObject*) py_V603; 31662 PyErr_Format(PyExc_NotImplementedError, 31663 "expected an aligned array of type %ld " 31664 "(NPY_FLOAT64), got non-aligned array of type %ld" 31665 " with %ld dimensions, with 3 last dims " 31666 "%ld, %ld, %ld" 31667 " and 3 last strides %ld %ld, %ld.", 31668 (long int) NPY_FLOAT64, 31669 (long int) PyArray_TYPE((PyArrayObject*) py_V603), 31670 (long int) PyArray_NDIM(tmp), 31671 (long int) (PyArray_NDIM(tmp) >= 3 ? 31672 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 31673 (long int) (PyArray_NDIM(tmp) >= 2 ? 31674 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 31675 (long int) (PyArray_NDIM(tmp) >= 1 ? 31676 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 31677 (long int) (PyArray_NDIM(tmp) >= 3 ? 31678 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 31679 (long int) (PyArray_NDIM(tmp) >= 2 ? 31680 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 31681 (long int) (PyArray_NDIM(tmp) >= 1 ? 31682 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 31683 ); 31684 { 31685 __failure = 604; 31686 if (!PyErr_Occurred()) { 31687 PyErr_SetString(PyExc_RuntimeError, 31688 "Unexpected error in an Op's C code. " 31689 "No Python exception was set."); 31690 } 31691 goto __label_604;} 31692 } 31693 // This is a TypeError to be consistent with DEBUG_MODE 31694 // Note: DEBUG_MODE also tells the name of the container 31695 if (PyArray_TYPE((PyArrayObject*) py_V603) != NPY_FLOAT64) { 31696 PyErr_Format(PyExc_TypeError, 31697 "expected type_num %d (NPY_FLOAT64) got %d", 31698 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V603)); 31699 { 31700 __failure = 604; 31701 if (!PyErr_Occurred()) { 31702 PyErr_SetString(PyExc_RuntimeError, 31703 "Unexpected error in an Op's C code. " 31704 "No Python exception was set."); 31705 } 31706 goto __label_604;} 31707 } 31708 31709 V603 = (PyArrayObject*)(py_V603); 31710 Py_XINCREF(V603); 31711 31712 { 31713 31714 py_V605 = PyList_GET_ITEM(storage_V605, 0); 31715 {Py_XINCREF(py_V605);} 31716 31717 V605 = NULL; 31718 if (py_V605 == Py_None) { 31719 // We can either fail here or set V605 to NULL and rely on Ops 31720 // using tensors to handle the NULL case, but if they fail to do so 31721 // they'll end up with nasty segfaults, so this is public service. 31722 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 31723 { 31724 __failure = 606; 31725 if (!PyErr_Occurred()) { 31726 PyErr_SetString(PyExc_RuntimeError, 31727 "Unexpected error in an Op's C code. " 31728 "No Python exception was set."); 31729 } 31730 goto __label_606;} 31731 } 31732 if (!PyArray_Check(py_V605)) { 31733 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 31734 { 31735 __failure = 606; 31736 if (!PyErr_Occurred()) { 31737 PyErr_SetString(PyExc_RuntimeError, 31738 "Unexpected error in an Op's C code. " 31739 "No Python exception was set."); 31740 } 31741 goto __label_606;} 31742 } 31743 // We expect NPY_FLOAT64 31744 if (!PyArray_ISALIGNED((PyArrayObject*) py_V605)) { 31745 PyArrayObject * tmp = (PyArrayObject*) py_V605; 31746 PyErr_Format(PyExc_NotImplementedError, 31747 "expected an aligned array of type %ld " 31748 "(NPY_FLOAT64), got non-aligned array of type %ld" 31749 " with %ld dimensions, with 3 last dims " 31750 "%ld, %ld, %ld" 31751 " and 3 last strides %ld %ld, %ld.", 31752 (long int) NPY_FLOAT64, 31753 (long int) PyArray_TYPE((PyArrayObject*) py_V605), 31754 (long int) PyArray_NDIM(tmp), 31755 (long int) (PyArray_NDIM(tmp) >= 3 ? 31756 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 31757 (long int) (PyArray_NDIM(tmp) >= 2 ? 31758 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 31759 (long int) (PyArray_NDIM(tmp) >= 1 ? 31760 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 31761 (long int) (PyArray_NDIM(tmp) >= 3 ? 31762 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 31763 (long int) (PyArray_NDIM(tmp) >= 2 ? 31764 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 31765 (long int) (PyArray_NDIM(tmp) >= 1 ? 31766 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 31767 ); 31768 { 31769 __failure = 606; 31770 if (!PyErr_Occurred()) { 31771 PyErr_SetString(PyExc_RuntimeError, 31772 "Unexpected error in an Op's C code. " 31773 "No Python exception was set."); 31774 } 31775 goto __label_606;} 31776 } 31777 // This is a TypeError to be consistent with DEBUG_MODE 31778 // Note: DEBUG_MODE also tells the name of the container 31779 if (PyArray_TYPE((PyArrayObject*) py_V605) != NPY_FLOAT64) { 31780 PyErr_Format(PyExc_TypeError, 31781 "expected type_num %d (NPY_FLOAT64) got %d", 31782 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V605)); 31783 { 31784 __failure = 606; 31785 if (!PyErr_Occurred()) { 31786 PyErr_SetString(PyExc_RuntimeError, 31787 "Unexpected error in an Op's C code. " 31788 "No Python exception was set."); 31789 } 31790 goto __label_606;} 31791 } 31792 31793 V605 = (PyArrayObject*)(py_V605); 31794 Py_XINCREF(V605); 31795 31796 { 31797 31798 py_V607 = PyList_GET_ITEM(storage_V607, 0); 31799 {Py_XINCREF(py_V607);} 31800 31801 V607 = NULL; 31802 if (py_V607 == Py_None) { 31803 // We can either fail here or set V607 to NULL and rely on Ops 31804 // using tensors to handle the NULL case, but if they fail to do so 31805 // they'll end up with nasty segfaults, so this is public service. 31806 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 31807 { 31808 __failure = 608; 31809 if (!PyErr_Occurred()) { 31810 PyErr_SetString(PyExc_RuntimeError, 31811 "Unexpected error in an Op's C code. " 31812 "No Python exception was set."); 31813 } 31814 goto __label_608;} 31815 } 31816 if (!PyArray_Check(py_V607)) { 31817 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 31818 { 31819 __failure = 608; 31820 if (!PyErr_Occurred()) { 31821 PyErr_SetString(PyExc_RuntimeError, 31822 "Unexpected error in an Op's C code. " 31823 "No Python exception was set."); 31824 } 31825 goto __label_608;} 31826 } 31827 // We expect NPY_FLOAT64 31828 if (!PyArray_ISALIGNED((PyArrayObject*) py_V607)) { 31829 PyArrayObject * tmp = (PyArrayObject*) py_V607; 31830 PyErr_Format(PyExc_NotImplementedError, 31831 "expected an aligned array of type %ld " 31832 "(NPY_FLOAT64), got non-aligned array of type %ld" 31833 " with %ld dimensions, with 3 last dims " 31834 "%ld, %ld, %ld" 31835 " and 3 last strides %ld %ld, %ld.", 31836 (long int) NPY_FLOAT64, 31837 (long int) PyArray_TYPE((PyArrayObject*) py_V607), 31838 (long int) PyArray_NDIM(tmp), 31839 (long int) (PyArray_NDIM(tmp) >= 3 ? 31840 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 31841 (long int) (PyArray_NDIM(tmp) >= 2 ? 31842 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 31843 (long int) (PyArray_NDIM(tmp) >= 1 ? 31844 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 31845 (long int) (PyArray_NDIM(tmp) >= 3 ? 31846 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 31847 (long int) (PyArray_NDIM(tmp) >= 2 ? 31848 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 31849 (long int) (PyArray_NDIM(tmp) >= 1 ? 31850 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 31851 ); 31852 { 31853 __failure = 608; 31854 if (!PyErr_Occurred()) { 31855 PyErr_SetString(PyExc_RuntimeError, 31856 "Unexpected error in an Op's C code. " 31857 "No Python exception was set."); 31858 } 31859 goto __label_608;} 31860 } 31861 // This is a TypeError to be consistent with DEBUG_MODE 31862 // Note: DEBUG_MODE also tells the name of the container 31863 if (PyArray_TYPE((PyArrayObject*) py_V607) != NPY_FLOAT64) { 31864 PyErr_Format(PyExc_TypeError, 31865 "expected type_num %d (NPY_FLOAT64) got %d", 31866 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V607)); 31867 { 31868 __failure = 608; 31869 if (!PyErr_Occurred()) { 31870 PyErr_SetString(PyExc_RuntimeError, 31871 "Unexpected error in an Op's C code. " 31872 "No Python exception was set."); 31873 } 31874 goto __label_608;} 31875 } 31876 31877 V607 = (PyArrayObject*)(py_V607); 31878 Py_XINCREF(V607); 31879 31880 { 31881 31882 py_V609 = PyList_GET_ITEM(storage_V609, 0); 31883 {Py_XINCREF(py_V609);} 31884 31885 V609 = NULL; 31886 if (py_V609 == Py_None) { 31887 // We can either fail here or set V609 to NULL and rely on Ops 31888 // using tensors to handle the NULL case, but if they fail to do so 31889 // they'll end up with nasty segfaults, so this is public service. 31890 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 31891 { 31892 __failure = 610; 31893 if (!PyErr_Occurred()) { 31894 PyErr_SetString(PyExc_RuntimeError, 31895 "Unexpected error in an Op's C code. " 31896 "No Python exception was set."); 31897 } 31898 goto __label_610;} 31899 } 31900 if (!PyArray_Check(py_V609)) { 31901 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 31902 { 31903 __failure = 610; 31904 if (!PyErr_Occurred()) { 31905 PyErr_SetString(PyExc_RuntimeError, 31906 "Unexpected error in an Op's C code. " 31907 "No Python exception was set."); 31908 } 31909 goto __label_610;} 31910 } 31911 // We expect NPY_FLOAT64 31912 if (!PyArray_ISALIGNED((PyArrayObject*) py_V609)) { 31913 PyArrayObject * tmp = (PyArrayObject*) py_V609; 31914 PyErr_Format(PyExc_NotImplementedError, 31915 "expected an aligned array of type %ld " 31916 "(NPY_FLOAT64), got non-aligned array of type %ld" 31917 " with %ld dimensions, with 3 last dims " 31918 "%ld, %ld, %ld" 31919 " and 3 last strides %ld %ld, %ld.", 31920 (long int) NPY_FLOAT64, 31921 (long int) PyArray_TYPE((PyArrayObject*) py_V609), 31922 (long int) PyArray_NDIM(tmp), 31923 (long int) (PyArray_NDIM(tmp) >= 3 ? 31924 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 31925 (long int) (PyArray_NDIM(tmp) >= 2 ? 31926 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 31927 (long int) (PyArray_NDIM(tmp) >= 1 ? 31928 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 31929 (long int) (PyArray_NDIM(tmp) >= 3 ? 31930 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 31931 (long int) (PyArray_NDIM(tmp) >= 2 ? 31932 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 31933 (long int) (PyArray_NDIM(tmp) >= 1 ? 31934 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 31935 ); 31936 { 31937 __failure = 610; 31938 if (!PyErr_Occurred()) { 31939 PyErr_SetString(PyExc_RuntimeError, 31940 "Unexpected error in an Op's C code. " 31941 "No Python exception was set."); 31942 } 31943 goto __label_610;} 31944 } 31945 // This is a TypeError to be consistent with DEBUG_MODE 31946 // Note: DEBUG_MODE also tells the name of the container 31947 if (PyArray_TYPE((PyArrayObject*) py_V609) != NPY_FLOAT64) { 31948 PyErr_Format(PyExc_TypeError, 31949 "expected type_num %d (NPY_FLOAT64) got %d", 31950 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V609)); 31951 { 31952 __failure = 610; 31953 if (!PyErr_Occurred()) { 31954 PyErr_SetString(PyExc_RuntimeError, 31955 "Unexpected error in an Op's C code. " 31956 "No Python exception was set."); 31957 } 31958 goto __label_610;} 31959 } 31960 31961 V609 = (PyArrayObject*)(py_V609); 31962 Py_XINCREF(V609); 31963 31964 { 31965 31966 py_V611 = PyList_GET_ITEM(storage_V611, 0); 31967 {Py_XINCREF(py_V611);} 31968 31969 V611 = NULL; 31970 if (py_V611 == Py_None) { 31971 // We can either fail here or set V611 to NULL and rely on Ops 31972 // using tensors to handle the NULL case, but if they fail to do so 31973 // they'll end up with nasty segfaults, so this is public service. 31974 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 31975 { 31976 __failure = 612; 31977 if (!PyErr_Occurred()) { 31978 PyErr_SetString(PyExc_RuntimeError, 31979 "Unexpected error in an Op's C code. " 31980 "No Python exception was set."); 31981 } 31982 goto __label_612;} 31983 } 31984 if (!PyArray_Check(py_V611)) { 31985 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 31986 { 31987 __failure = 612; 31988 if (!PyErr_Occurred()) { 31989 PyErr_SetString(PyExc_RuntimeError, 31990 "Unexpected error in an Op's C code. " 31991 "No Python exception was set."); 31992 } 31993 goto __label_612;} 31994 } 31995 // We expect NPY_FLOAT64 31996 if (!PyArray_ISALIGNED((PyArrayObject*) py_V611)) { 31997 PyArrayObject * tmp = (PyArrayObject*) py_V611; 31998 PyErr_Format(PyExc_NotImplementedError, 31999 "expected an aligned array of type %ld " 32000 "(NPY_FLOAT64), got non-aligned array of type %ld" 32001 " with %ld dimensions, with 3 last dims " 32002 "%ld, %ld, %ld" 32003 " and 3 last strides %ld %ld, %ld.", 32004 (long int) NPY_FLOAT64, 32005 (long int) PyArray_TYPE((PyArrayObject*) py_V611), 32006 (long int) PyArray_NDIM(tmp), 32007 (long int) (PyArray_NDIM(tmp) >= 3 ? 32008 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 32009 (long int) (PyArray_NDIM(tmp) >= 2 ? 32010 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 32011 (long int) (PyArray_NDIM(tmp) >= 1 ? 32012 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 32013 (long int) (PyArray_NDIM(tmp) >= 3 ? 32014 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 32015 (long int) (PyArray_NDIM(tmp) >= 2 ? 32016 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 32017 (long int) (PyArray_NDIM(tmp) >= 1 ? 32018 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 32019 ); 32020 { 32021 __failure = 612; 32022 if (!PyErr_Occurred()) { 32023 PyErr_SetString(PyExc_RuntimeError, 32024 "Unexpected error in an Op's C code. " 32025 "No Python exception was set."); 32026 } 32027 goto __label_612;} 32028 } 32029 // This is a TypeError to be consistent with DEBUG_MODE 32030 // Note: DEBUG_MODE also tells the name of the container 32031 if (PyArray_TYPE((PyArrayObject*) py_V611) != NPY_FLOAT64) { 32032 PyErr_Format(PyExc_TypeError, 32033 "expected type_num %d (NPY_FLOAT64) got %d", 32034 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V611)); 32035 { 32036 __failure = 612; 32037 if (!PyErr_Occurred()) { 32038 PyErr_SetString(PyExc_RuntimeError, 32039 "Unexpected error in an Op's C code. " 32040 "No Python exception was set."); 32041 } 32042 goto __label_612;} 32043 } 32044 32045 V611 = (PyArrayObject*)(py_V611); 32046 Py_XINCREF(V611); 32047 32048 { 32049 32050 py_V613 = PyList_GET_ITEM(storage_V613, 0); 32051 {Py_XINCREF(py_V613);} 32052 32053 V613 = NULL; 32054 if (py_V613 == Py_None) { 32055 // We can either fail here or set V613 to NULL and rely on Ops 32056 // using tensors to handle the NULL case, but if they fail to do so 32057 // they'll end up with nasty segfaults, so this is public service. 32058 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 32059 { 32060 __failure = 614; 32061 if (!PyErr_Occurred()) { 32062 PyErr_SetString(PyExc_RuntimeError, 32063 "Unexpected error in an Op's C code. " 32064 "No Python exception was set."); 32065 } 32066 goto __label_614;} 32067 } 32068 if (!PyArray_Check(py_V613)) { 32069 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 32070 { 32071 __failure = 614; 32072 if (!PyErr_Occurred()) { 32073 PyErr_SetString(PyExc_RuntimeError, 32074 "Unexpected error in an Op's C code. " 32075 "No Python exception was set."); 32076 } 32077 goto __label_614;} 32078 } 32079 // We expect NPY_FLOAT64 32080 if (!PyArray_ISALIGNED((PyArrayObject*) py_V613)) { 32081 PyArrayObject * tmp = (PyArrayObject*) py_V613; 32082 PyErr_Format(PyExc_NotImplementedError, 32083 "expected an aligned array of type %ld " 32084 "(NPY_FLOAT64), got non-aligned array of type %ld" 32085 " with %ld dimensions, with 3 last dims " 32086 "%ld, %ld, %ld" 32087 " and 3 last strides %ld %ld, %ld.", 32088 (long int) NPY_FLOAT64, 32089 (long int) PyArray_TYPE((PyArrayObject*) py_V613), 32090 (long int) PyArray_NDIM(tmp), 32091 (long int) (PyArray_NDIM(tmp) >= 3 ? 32092 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 32093 (long int) (PyArray_NDIM(tmp) >= 2 ? 32094 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 32095 (long int) (PyArray_NDIM(tmp) >= 1 ? 32096 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 32097 (long int) (PyArray_NDIM(tmp) >= 3 ? 32098 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 32099 (long int) (PyArray_NDIM(tmp) >= 2 ? 32100 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 32101 (long int) (PyArray_NDIM(tmp) >= 1 ? 32102 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 32103 ); 32104 { 32105 __failure = 614; 32106 if (!PyErr_Occurred()) { 32107 PyErr_SetString(PyExc_RuntimeError, 32108 "Unexpected error in an Op's C code. " 32109 "No Python exception was set."); 32110 } 32111 goto __label_614;} 32112 } 32113 // This is a TypeError to be consistent with DEBUG_MODE 32114 // Note: DEBUG_MODE also tells the name of the container 32115 if (PyArray_TYPE((PyArrayObject*) py_V613) != NPY_FLOAT64) { 32116 PyErr_Format(PyExc_TypeError, 32117 "expected type_num %d (NPY_FLOAT64) got %d", 32118 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V613)); 32119 { 32120 __failure = 614; 32121 if (!PyErr_Occurred()) { 32122 PyErr_SetString(PyExc_RuntimeError, 32123 "Unexpected error in an Op's C code. " 32124 "No Python exception was set."); 32125 } 32126 goto __label_614;} 32127 } 32128 32129 V613 = (PyArrayObject*)(py_V613); 32130 Py_XINCREF(V613); 32131 32132 { 32133 32134 py_V615 = PyList_GET_ITEM(storage_V615, 0); 32135 {Py_XINCREF(py_V615);} 32136 32137 V615 = NULL; 32138 if (py_V615 == Py_None) { 32139 // We can either fail here or set V615 to NULL and rely on Ops 32140 // using tensors to handle the NULL case, but if they fail to do so 32141 // they'll end up with nasty segfaults, so this is public service. 32142 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 32143 { 32144 __failure = 616; 32145 if (!PyErr_Occurred()) { 32146 PyErr_SetString(PyExc_RuntimeError, 32147 "Unexpected error in an Op's C code. " 32148 "No Python exception was set."); 32149 } 32150 goto __label_616;} 32151 } 32152 if (!PyArray_Check(py_V615)) { 32153 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 32154 { 32155 __failure = 616; 32156 if (!PyErr_Occurred()) { 32157 PyErr_SetString(PyExc_RuntimeError, 32158 "Unexpected error in an Op's C code. " 32159 "No Python exception was set."); 32160 } 32161 goto __label_616;} 32162 } 32163 // We expect NPY_FLOAT64 32164 if (!PyArray_ISALIGNED((PyArrayObject*) py_V615)) { 32165 PyArrayObject * tmp = (PyArrayObject*) py_V615; 32166 PyErr_Format(PyExc_NotImplementedError, 32167 "expected an aligned array of type %ld " 32168 "(NPY_FLOAT64), got non-aligned array of type %ld" 32169 " with %ld dimensions, with 3 last dims " 32170 "%ld, %ld, %ld" 32171 " and 3 last strides %ld %ld, %ld.", 32172 (long int) NPY_FLOAT64, 32173 (long int) PyArray_TYPE((PyArrayObject*) py_V615), 32174 (long int) PyArray_NDIM(tmp), 32175 (long int) (PyArray_NDIM(tmp) >= 3 ? 32176 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 32177 (long int) (PyArray_NDIM(tmp) >= 2 ? 32178 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 32179 (long int) (PyArray_NDIM(tmp) >= 1 ? 32180 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 32181 (long int) (PyArray_NDIM(tmp) >= 3 ? 32182 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 32183 (long int) (PyArray_NDIM(tmp) >= 2 ? 32184 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 32185 (long int) (PyArray_NDIM(tmp) >= 1 ? 32186 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 32187 ); 32188 { 32189 __failure = 616; 32190 if (!PyErr_Occurred()) { 32191 PyErr_SetString(PyExc_RuntimeError, 32192 "Unexpected error in an Op's C code. " 32193 "No Python exception was set."); 32194 } 32195 goto __label_616;} 32196 } 32197 // This is a TypeError to be consistent with DEBUG_MODE 32198 // Note: DEBUG_MODE also tells the name of the container 32199 if (PyArray_TYPE((PyArrayObject*) py_V615) != NPY_FLOAT64) { 32200 PyErr_Format(PyExc_TypeError, 32201 "expected type_num %d (NPY_FLOAT64) got %d", 32202 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V615)); 32203 { 32204 __failure = 616; 32205 if (!PyErr_Occurred()) { 32206 PyErr_SetString(PyExc_RuntimeError, 32207 "Unexpected error in an Op's C code. " 32208 "No Python exception was set."); 32209 } 32210 goto __label_616;} 32211 } 32212 32213 V615 = (PyArrayObject*)(py_V615); 32214 Py_XINCREF(V615); 32215 32216 { 32217 32218 py_V617 = PyList_GET_ITEM(storage_V617, 0); 32219 {Py_XINCREF(py_V617);} 32220 32221 V617 = NULL; 32222 if (py_V617 == Py_None) { 32223 // We can either fail here or set V617 to NULL and rely on Ops 32224 // using tensors to handle the NULL case, but if they fail to do so 32225 // they'll end up with nasty segfaults, so this is public service. 32226 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 32227 { 32228 __failure = 618; 32229 if (!PyErr_Occurred()) { 32230 PyErr_SetString(PyExc_RuntimeError, 32231 "Unexpected error in an Op's C code. " 32232 "No Python exception was set."); 32233 } 32234 goto __label_618;} 32235 } 32236 if (!PyArray_Check(py_V617)) { 32237 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 32238 { 32239 __failure = 618; 32240 if (!PyErr_Occurred()) { 32241 PyErr_SetString(PyExc_RuntimeError, 32242 "Unexpected error in an Op's C code. " 32243 "No Python exception was set."); 32244 } 32245 goto __label_618;} 32246 } 32247 // We expect NPY_FLOAT64 32248 if (!PyArray_ISALIGNED((PyArrayObject*) py_V617)) { 32249 PyArrayObject * tmp = (PyArrayObject*) py_V617; 32250 PyErr_Format(PyExc_NotImplementedError, 32251 "expected an aligned array of type %ld " 32252 "(NPY_FLOAT64), got non-aligned array of type %ld" 32253 " with %ld dimensions, with 3 last dims " 32254 "%ld, %ld, %ld" 32255 " and 3 last strides %ld %ld, %ld.", 32256 (long int) NPY_FLOAT64, 32257 (long int) PyArray_TYPE((PyArrayObject*) py_V617), 32258 (long int) PyArray_NDIM(tmp), 32259 (long int) (PyArray_NDIM(tmp) >= 3 ? 32260 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 32261 (long int) (PyArray_NDIM(tmp) >= 2 ? 32262 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 32263 (long int) (PyArray_NDIM(tmp) >= 1 ? 32264 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 32265 (long int) (PyArray_NDIM(tmp) >= 3 ? 32266 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 32267 (long int) (PyArray_NDIM(tmp) >= 2 ? 32268 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 32269 (long int) (PyArray_NDIM(tmp) >= 1 ? 32270 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 32271 ); 32272 { 32273 __failure = 618; 32274 if (!PyErr_Occurred()) { 32275 PyErr_SetString(PyExc_RuntimeError, 32276 "Unexpected error in an Op's C code. " 32277 "No Python exception was set."); 32278 } 32279 goto __label_618;} 32280 } 32281 // This is a TypeError to be consistent with DEBUG_MODE 32282 // Note: DEBUG_MODE also tells the name of the container 32283 if (PyArray_TYPE((PyArrayObject*) py_V617) != NPY_FLOAT64) { 32284 PyErr_Format(PyExc_TypeError, 32285 "expected type_num %d (NPY_FLOAT64) got %d", 32286 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V617)); 32287 { 32288 __failure = 618; 32289 if (!PyErr_Occurred()) { 32290 PyErr_SetString(PyExc_RuntimeError, 32291 "Unexpected error in an Op's C code. " 32292 "No Python exception was set."); 32293 } 32294 goto __label_618;} 32295 } 32296 32297 V617 = (PyArrayObject*)(py_V617); 32298 Py_XINCREF(V617); 32299 32300 { 32301 32302 py_V619 = PyList_GET_ITEM(storage_V619, 0); 32303 {Py_XINCREF(py_V619);} 32304 32305 V619 = NULL; 32306 if (py_V619 == Py_None) { 32307 // We can either fail here or set V619 to NULL and rely on Ops 32308 // using tensors to handle the NULL case, but if they fail to do so 32309 // they'll end up with nasty segfaults, so this is public service. 32310 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 32311 { 32312 __failure = 620; 32313 if (!PyErr_Occurred()) { 32314 PyErr_SetString(PyExc_RuntimeError, 32315 "Unexpected error in an Op's C code. " 32316 "No Python exception was set."); 32317 } 32318 goto __label_620;} 32319 } 32320 if (!PyArray_Check(py_V619)) { 32321 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 32322 { 32323 __failure = 620; 32324 if (!PyErr_Occurred()) { 32325 PyErr_SetString(PyExc_RuntimeError, 32326 "Unexpected error in an Op's C code. " 32327 "No Python exception was set."); 32328 } 32329 goto __label_620;} 32330 } 32331 // We expect NPY_FLOAT64 32332 if (!PyArray_ISALIGNED((PyArrayObject*) py_V619)) { 32333 PyArrayObject * tmp = (PyArrayObject*) py_V619; 32334 PyErr_Format(PyExc_NotImplementedError, 32335 "expected an aligned array of type %ld " 32336 "(NPY_FLOAT64), got non-aligned array of type %ld" 32337 " with %ld dimensions, with 3 last dims " 32338 "%ld, %ld, %ld" 32339 " and 3 last strides %ld %ld, %ld.", 32340 (long int) NPY_FLOAT64, 32341 (long int) PyArray_TYPE((PyArrayObject*) py_V619), 32342 (long int) PyArray_NDIM(tmp), 32343 (long int) (PyArray_NDIM(tmp) >= 3 ? 32344 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 32345 (long int) (PyArray_NDIM(tmp) >= 2 ? 32346 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 32347 (long int) (PyArray_NDIM(tmp) >= 1 ? 32348 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 32349 (long int) (PyArray_NDIM(tmp) >= 3 ? 32350 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 32351 (long int) (PyArray_NDIM(tmp) >= 2 ? 32352 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 32353 (long int) (PyArray_NDIM(tmp) >= 1 ? 32354 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 32355 ); 32356 { 32357 __failure = 620; 32358 if (!PyErr_Occurred()) { 32359 PyErr_SetString(PyExc_RuntimeError, 32360 "Unexpected error in an Op's C code. " 32361 "No Python exception was set."); 32362 } 32363 goto __label_620;} 32364 } 32365 // This is a TypeError to be consistent with DEBUG_MODE 32366 // Note: DEBUG_MODE also tells the name of the container 32367 if (PyArray_TYPE((PyArrayObject*) py_V619) != NPY_FLOAT64) { 32368 PyErr_Format(PyExc_TypeError, 32369 "expected type_num %d (NPY_FLOAT64) got %d", 32370 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V619)); 32371 { 32372 __failure = 620; 32373 if (!PyErr_Occurred()) { 32374 PyErr_SetString(PyExc_RuntimeError, 32375 "Unexpected error in an Op's C code. " 32376 "No Python exception was set."); 32377 } 32378 goto __label_620;} 32379 } 32380 32381 V619 = (PyArrayObject*)(py_V619); 32382 Py_XINCREF(V619); 32383 32384 { 32385 32386 py_V621 = PyList_GET_ITEM(storage_V621, 0); 32387 {Py_XINCREF(py_V621);} 32388 32389 V621 = NULL; 32390 if (py_V621 == Py_None) { 32391 // We can either fail here or set V621 to NULL and rely on Ops 32392 // using tensors to handle the NULL case, but if they fail to do so 32393 // they'll end up with nasty segfaults, so this is public service. 32394 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 32395 { 32396 __failure = 622; 32397 if (!PyErr_Occurred()) { 32398 PyErr_SetString(PyExc_RuntimeError, 32399 "Unexpected error in an Op's C code. " 32400 "No Python exception was set."); 32401 } 32402 goto __label_622;} 32403 } 32404 if (!PyArray_Check(py_V621)) { 32405 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 32406 { 32407 __failure = 622; 32408 if (!PyErr_Occurred()) { 32409 PyErr_SetString(PyExc_RuntimeError, 32410 "Unexpected error in an Op's C code. " 32411 "No Python exception was set."); 32412 } 32413 goto __label_622;} 32414 } 32415 // We expect NPY_FLOAT64 32416 if (!PyArray_ISALIGNED((PyArrayObject*) py_V621)) { 32417 PyArrayObject * tmp = (PyArrayObject*) py_V621; 32418 PyErr_Format(PyExc_NotImplementedError, 32419 "expected an aligned array of type %ld " 32420 "(NPY_FLOAT64), got non-aligned array of type %ld" 32421 " with %ld dimensions, with 3 last dims " 32422 "%ld, %ld, %ld" 32423 " and 3 last strides %ld %ld, %ld.", 32424 (long int) NPY_FLOAT64, 32425 (long int) PyArray_TYPE((PyArrayObject*) py_V621), 32426 (long int) PyArray_NDIM(tmp), 32427 (long int) (PyArray_NDIM(tmp) >= 3 ? 32428 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 32429 (long int) (PyArray_NDIM(tmp) >= 2 ? 32430 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 32431 (long int) (PyArray_NDIM(tmp) >= 1 ? 32432 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 32433 (long int) (PyArray_NDIM(tmp) >= 3 ? 32434 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 32435 (long int) (PyArray_NDIM(tmp) >= 2 ? 32436 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 32437 (long int) (PyArray_NDIM(tmp) >= 1 ? 32438 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 32439 ); 32440 { 32441 __failure = 622; 32442 if (!PyErr_Occurred()) { 32443 PyErr_SetString(PyExc_RuntimeError, 32444 "Unexpected error in an Op's C code. " 32445 "No Python exception was set."); 32446 } 32447 goto __label_622;} 32448 } 32449 // This is a TypeError to be consistent with DEBUG_MODE 32450 // Note: DEBUG_MODE also tells the name of the container 32451 if (PyArray_TYPE((PyArrayObject*) py_V621) != NPY_FLOAT64) { 32452 PyErr_Format(PyExc_TypeError, 32453 "expected type_num %d (NPY_FLOAT64) got %d", 32454 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V621)); 32455 { 32456 __failure = 622; 32457 if (!PyErr_Occurred()) { 32458 PyErr_SetString(PyExc_RuntimeError, 32459 "Unexpected error in an Op's C code. " 32460 "No Python exception was set."); 32461 } 32462 goto __label_622;} 32463 } 32464 32465 V621 = (PyArrayObject*)(py_V621); 32466 Py_XINCREF(V621); 32467 32468 { 32469 32470 py_V623 = PyList_GET_ITEM(storage_V623, 0); 32471 {Py_XINCREF(py_V623);} 32472 32473 V623 = NULL; 32474 if (py_V623 == Py_None) { 32475 // We can either fail here or set V623 to NULL and rely on Ops 32476 // using tensors to handle the NULL case, but if they fail to do so 32477 // they'll end up with nasty segfaults, so this is public service. 32478 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 32479 { 32480 __failure = 624; 32481 if (!PyErr_Occurred()) { 32482 PyErr_SetString(PyExc_RuntimeError, 32483 "Unexpected error in an Op's C code. " 32484 "No Python exception was set."); 32485 } 32486 goto __label_624;} 32487 } 32488 if (!PyArray_Check(py_V623)) { 32489 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 32490 { 32491 __failure = 624; 32492 if (!PyErr_Occurred()) { 32493 PyErr_SetString(PyExc_RuntimeError, 32494 "Unexpected error in an Op's C code. " 32495 "No Python exception was set."); 32496 } 32497 goto __label_624;} 32498 } 32499 // We expect NPY_FLOAT64 32500 if (!PyArray_ISALIGNED((PyArrayObject*) py_V623)) { 32501 PyArrayObject * tmp = (PyArrayObject*) py_V623; 32502 PyErr_Format(PyExc_NotImplementedError, 32503 "expected an aligned array of type %ld " 32504 "(NPY_FLOAT64), got non-aligned array of type %ld" 32505 " with %ld dimensions, with 3 last dims " 32506 "%ld, %ld, %ld" 32507 " and 3 last strides %ld %ld, %ld.", 32508 (long int) NPY_FLOAT64, 32509 (long int) PyArray_TYPE((PyArrayObject*) py_V623), 32510 (long int) PyArray_NDIM(tmp), 32511 (long int) (PyArray_NDIM(tmp) >= 3 ? 32512 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 32513 (long int) (PyArray_NDIM(tmp) >= 2 ? 32514 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 32515 (long int) (PyArray_NDIM(tmp) >= 1 ? 32516 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 32517 (long int) (PyArray_NDIM(tmp) >= 3 ? 32518 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 32519 (long int) (PyArray_NDIM(tmp) >= 2 ? 32520 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 32521 (long int) (PyArray_NDIM(tmp) >= 1 ? 32522 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 32523 ); 32524 { 32525 __failure = 624; 32526 if (!PyErr_Occurred()) { 32527 PyErr_SetString(PyExc_RuntimeError, 32528 "Unexpected error in an Op's C code. " 32529 "No Python exception was set."); 32530 } 32531 goto __label_624;} 32532 } 32533 // This is a TypeError to be consistent with DEBUG_MODE 32534 // Note: DEBUG_MODE also tells the name of the container 32535 if (PyArray_TYPE((PyArrayObject*) py_V623) != NPY_FLOAT64) { 32536 PyErr_Format(PyExc_TypeError, 32537 "expected type_num %d (NPY_FLOAT64) got %d", 32538 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V623)); 32539 { 32540 __failure = 624; 32541 if (!PyErr_Occurred()) { 32542 PyErr_SetString(PyExc_RuntimeError, 32543 "Unexpected error in an Op's C code. " 32544 "No Python exception was set."); 32545 } 32546 goto __label_624;} 32547 } 32548 32549 V623 = (PyArrayObject*)(py_V623); 32550 Py_XINCREF(V623); 32551 32552 { 32553 32554 py_V625 = PyList_GET_ITEM(storage_V625, 0); 32555 {Py_XINCREF(py_V625);} 32556 32557 V625 = NULL; 32558 if (py_V625 == Py_None) { 32559 // We can either fail here or set V625 to NULL and rely on Ops 32560 // using tensors to handle the NULL case, but if they fail to do so 32561 // they'll end up with nasty segfaults, so this is public service. 32562 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 32563 { 32564 __failure = 626; 32565 if (!PyErr_Occurred()) { 32566 PyErr_SetString(PyExc_RuntimeError, 32567 "Unexpected error in an Op's C code. " 32568 "No Python exception was set."); 32569 } 32570 goto __label_626;} 32571 } 32572 if (!PyArray_Check(py_V625)) { 32573 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 32574 { 32575 __failure = 626; 32576 if (!PyErr_Occurred()) { 32577 PyErr_SetString(PyExc_RuntimeError, 32578 "Unexpected error in an Op's C code. " 32579 "No Python exception was set."); 32580 } 32581 goto __label_626;} 32582 } 32583 // We expect NPY_FLOAT64 32584 if (!PyArray_ISALIGNED((PyArrayObject*) py_V625)) { 32585 PyArrayObject * tmp = (PyArrayObject*) py_V625; 32586 PyErr_Format(PyExc_NotImplementedError, 32587 "expected an aligned array of type %ld " 32588 "(NPY_FLOAT64), got non-aligned array of type %ld" 32589 " with %ld dimensions, with 3 last dims " 32590 "%ld, %ld, %ld" 32591 " and 3 last strides %ld %ld, %ld.", 32592 (long int) NPY_FLOAT64, 32593 (long int) PyArray_TYPE((PyArrayObject*) py_V625), 32594 (long int) PyArray_NDIM(tmp), 32595 (long int) (PyArray_NDIM(tmp) >= 3 ? 32596 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 32597 (long int) (PyArray_NDIM(tmp) >= 2 ? 32598 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 32599 (long int) (PyArray_NDIM(tmp) >= 1 ? 32600 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 32601 (long int) (PyArray_NDIM(tmp) >= 3 ? 32602 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 32603 (long int) (PyArray_NDIM(tmp) >= 2 ? 32604 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 32605 (long int) (PyArray_NDIM(tmp) >= 1 ? 32606 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 32607 ); 32608 { 32609 __failure = 626; 32610 if (!PyErr_Occurred()) { 32611 PyErr_SetString(PyExc_RuntimeError, 32612 "Unexpected error in an Op's C code. " 32613 "No Python exception was set."); 32614 } 32615 goto __label_626;} 32616 } 32617 // This is a TypeError to be consistent with DEBUG_MODE 32618 // Note: DEBUG_MODE also tells the name of the container 32619 if (PyArray_TYPE((PyArrayObject*) py_V625) != NPY_FLOAT64) { 32620 PyErr_Format(PyExc_TypeError, 32621 "expected type_num %d (NPY_FLOAT64) got %d", 32622 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V625)); 32623 { 32624 __failure = 626; 32625 if (!PyErr_Occurred()) { 32626 PyErr_SetString(PyExc_RuntimeError, 32627 "Unexpected error in an Op's C code. " 32628 "No Python exception was set."); 32629 } 32630 goto __label_626;} 32631 } 32632 32633 V625 = (PyArrayObject*)(py_V625); 32634 Py_XINCREF(V625); 32635 32636 { 32637 32638 py_V627 = PyList_GET_ITEM(storage_V627, 0); 32639 {Py_XINCREF(py_V627);} 32640 32641 V627 = NULL; 32642 if (py_V627 == Py_None) { 32643 // We can either fail here or set V627 to NULL and rely on Ops 32644 // using tensors to handle the NULL case, but if they fail to do so 32645 // they'll end up with nasty segfaults, so this is public service. 32646 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 32647 { 32648 __failure = 628; 32649 if (!PyErr_Occurred()) { 32650 PyErr_SetString(PyExc_RuntimeError, 32651 "Unexpected error in an Op's C code. " 32652 "No Python exception was set."); 32653 } 32654 goto __label_628;} 32655 } 32656 if (!PyArray_Check(py_V627)) { 32657 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 32658 { 32659 __failure = 628; 32660 if (!PyErr_Occurred()) { 32661 PyErr_SetString(PyExc_RuntimeError, 32662 "Unexpected error in an Op's C code. " 32663 "No Python exception was set."); 32664 } 32665 goto __label_628;} 32666 } 32667 // We expect NPY_FLOAT64 32668 if (!PyArray_ISALIGNED((PyArrayObject*) py_V627)) { 32669 PyArrayObject * tmp = (PyArrayObject*) py_V627; 32670 PyErr_Format(PyExc_NotImplementedError, 32671 "expected an aligned array of type %ld " 32672 "(NPY_FLOAT64), got non-aligned array of type %ld" 32673 " with %ld dimensions, with 3 last dims " 32674 "%ld, %ld, %ld" 32675 " and 3 last strides %ld %ld, %ld.", 32676 (long int) NPY_FLOAT64, 32677 (long int) PyArray_TYPE((PyArrayObject*) py_V627), 32678 (long int) PyArray_NDIM(tmp), 32679 (long int) (PyArray_NDIM(tmp) >= 3 ? 32680 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 32681 (long int) (PyArray_NDIM(tmp) >= 2 ? 32682 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 32683 (long int) (PyArray_NDIM(tmp) >= 1 ? 32684 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 32685 (long int) (PyArray_NDIM(tmp) >= 3 ? 32686 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 32687 (long int) (PyArray_NDIM(tmp) >= 2 ? 32688 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 32689 (long int) (PyArray_NDIM(tmp) >= 1 ? 32690 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 32691 ); 32692 { 32693 __failure = 628; 32694 if (!PyErr_Occurred()) { 32695 PyErr_SetString(PyExc_RuntimeError, 32696 "Unexpected error in an Op's C code. " 32697 "No Python exception was set."); 32698 } 32699 goto __label_628;} 32700 } 32701 // This is a TypeError to be consistent with DEBUG_MODE 32702 // Note: DEBUG_MODE also tells the name of the container 32703 if (PyArray_TYPE((PyArrayObject*) py_V627) != NPY_FLOAT64) { 32704 PyErr_Format(PyExc_TypeError, 32705 "expected type_num %d (NPY_FLOAT64) got %d", 32706 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V627)); 32707 { 32708 __failure = 628; 32709 if (!PyErr_Occurred()) { 32710 PyErr_SetString(PyExc_RuntimeError, 32711 "Unexpected error in an Op's C code. " 32712 "No Python exception was set."); 32713 } 32714 goto __label_628;} 32715 } 32716 32717 V627 = (PyArrayObject*)(py_V627); 32718 Py_XINCREF(V627); 32719 32720 { 32721 32722 py_V629 = PyList_GET_ITEM(storage_V629, 0); 32723 {Py_XINCREF(py_V629);} 32724 32725 V629 = NULL; 32726 if (py_V629 == Py_None) { 32727 // We can either fail here or set V629 to NULL and rely on Ops 32728 // using tensors to handle the NULL case, but if they fail to do so 32729 // they'll end up with nasty segfaults, so this is public service. 32730 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 32731 { 32732 __failure = 630; 32733 if (!PyErr_Occurred()) { 32734 PyErr_SetString(PyExc_RuntimeError, 32735 "Unexpected error in an Op's C code. " 32736 "No Python exception was set."); 32737 } 32738 goto __label_630;} 32739 } 32740 if (!PyArray_Check(py_V629)) { 32741 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 32742 { 32743 __failure = 630; 32744 if (!PyErr_Occurred()) { 32745 PyErr_SetString(PyExc_RuntimeError, 32746 "Unexpected error in an Op's C code. " 32747 "No Python exception was set."); 32748 } 32749 goto __label_630;} 32750 } 32751 // We expect NPY_FLOAT64 32752 if (!PyArray_ISALIGNED((PyArrayObject*) py_V629)) { 32753 PyArrayObject * tmp = (PyArrayObject*) py_V629; 32754 PyErr_Format(PyExc_NotImplementedError, 32755 "expected an aligned array of type %ld " 32756 "(NPY_FLOAT64), got non-aligned array of type %ld" 32757 " with %ld dimensions, with 3 last dims " 32758 "%ld, %ld, %ld" 32759 " and 3 last strides %ld %ld, %ld.", 32760 (long int) NPY_FLOAT64, 32761 (long int) PyArray_TYPE((PyArrayObject*) py_V629), 32762 (long int) PyArray_NDIM(tmp), 32763 (long int) (PyArray_NDIM(tmp) >= 3 ? 32764 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 32765 (long int) (PyArray_NDIM(tmp) >= 2 ? 32766 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 32767 (long int) (PyArray_NDIM(tmp) >= 1 ? 32768 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 32769 (long int) (PyArray_NDIM(tmp) >= 3 ? 32770 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 32771 (long int) (PyArray_NDIM(tmp) >= 2 ? 32772 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 32773 (long int) (PyArray_NDIM(tmp) >= 1 ? 32774 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 32775 ); 32776 { 32777 __failure = 630; 32778 if (!PyErr_Occurred()) { 32779 PyErr_SetString(PyExc_RuntimeError, 32780 "Unexpected error in an Op's C code. " 32781 "No Python exception was set."); 32782 } 32783 goto __label_630;} 32784 } 32785 // This is a TypeError to be consistent with DEBUG_MODE 32786 // Note: DEBUG_MODE also tells the name of the container 32787 if (PyArray_TYPE((PyArrayObject*) py_V629) != NPY_FLOAT64) { 32788 PyErr_Format(PyExc_TypeError, 32789 "expected type_num %d (NPY_FLOAT64) got %d", 32790 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V629)); 32791 { 32792 __failure = 630; 32793 if (!PyErr_Occurred()) { 32794 PyErr_SetString(PyExc_RuntimeError, 32795 "Unexpected error in an Op's C code. " 32796 "No Python exception was set."); 32797 } 32798 goto __label_630;} 32799 } 32800 32801 V629 = (PyArrayObject*)(py_V629); 32802 Py_XINCREF(V629); 32803 32804 { 32805 32806 py_V631 = PyList_GET_ITEM(storage_V631, 0); 32807 {Py_XINCREF(py_V631);} 32808 32809 V631 = NULL; 32810 if (py_V631 == Py_None) { 32811 // We can either fail here or set V631 to NULL and rely on Ops 32812 // using tensors to handle the NULL case, but if they fail to do so 32813 // they'll end up with nasty segfaults, so this is public service. 32814 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 32815 { 32816 __failure = 632; 32817 if (!PyErr_Occurred()) { 32818 PyErr_SetString(PyExc_RuntimeError, 32819 "Unexpected error in an Op's C code. " 32820 "No Python exception was set."); 32821 } 32822 goto __label_632;} 32823 } 32824 if (!PyArray_Check(py_V631)) { 32825 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 32826 { 32827 __failure = 632; 32828 if (!PyErr_Occurred()) { 32829 PyErr_SetString(PyExc_RuntimeError, 32830 "Unexpected error in an Op's C code. " 32831 "No Python exception was set."); 32832 } 32833 goto __label_632;} 32834 } 32835 // We expect NPY_FLOAT64 32836 if (!PyArray_ISALIGNED((PyArrayObject*) py_V631)) { 32837 PyArrayObject * tmp = (PyArrayObject*) py_V631; 32838 PyErr_Format(PyExc_NotImplementedError, 32839 "expected an aligned array of type %ld " 32840 "(NPY_FLOAT64), got non-aligned array of type %ld" 32841 " with %ld dimensions, with 3 last dims " 32842 "%ld, %ld, %ld" 32843 " and 3 last strides %ld %ld, %ld.", 32844 (long int) NPY_FLOAT64, 32845 (long int) PyArray_TYPE((PyArrayObject*) py_V631), 32846 (long int) PyArray_NDIM(tmp), 32847 (long int) (PyArray_NDIM(tmp) >= 3 ? 32848 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 32849 (long int) (PyArray_NDIM(tmp) >= 2 ? 32850 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 32851 (long int) (PyArray_NDIM(tmp) >= 1 ? 32852 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 32853 (long int) (PyArray_NDIM(tmp) >= 3 ? 32854 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 32855 (long int) (PyArray_NDIM(tmp) >= 2 ? 32856 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 32857 (long int) (PyArray_NDIM(tmp) >= 1 ? 32858 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 32859 ); 32860 { 32861 __failure = 632; 32862 if (!PyErr_Occurred()) { 32863 PyErr_SetString(PyExc_RuntimeError, 32864 "Unexpected error in an Op's C code. " 32865 "No Python exception was set."); 32866 } 32867 goto __label_632;} 32868 } 32869 // This is a TypeError to be consistent with DEBUG_MODE 32870 // Note: DEBUG_MODE also tells the name of the container 32871 if (PyArray_TYPE((PyArrayObject*) py_V631) != NPY_FLOAT64) { 32872 PyErr_Format(PyExc_TypeError, 32873 "expected type_num %d (NPY_FLOAT64) got %d", 32874 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V631)); 32875 { 32876 __failure = 632; 32877 if (!PyErr_Occurred()) { 32878 PyErr_SetString(PyExc_RuntimeError, 32879 "Unexpected error in an Op's C code. " 32880 "No Python exception was set."); 32881 } 32882 goto __label_632;} 32883 } 32884 32885 V631 = (PyArrayObject*)(py_V631); 32886 Py_XINCREF(V631); 32887 32888 { 32889 32890 py_V633 = PyList_GET_ITEM(storage_V633, 0); 32891 {Py_XINCREF(py_V633);} 32892 32893 V633 = NULL; 32894 if (py_V633 == Py_None) { 32895 // We can either fail here or set V633 to NULL and rely on Ops 32896 // using tensors to handle the NULL case, but if they fail to do so 32897 // they'll end up with nasty segfaults, so this is public service. 32898 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 32899 { 32900 __failure = 634; 32901 if (!PyErr_Occurred()) { 32902 PyErr_SetString(PyExc_RuntimeError, 32903 "Unexpected error in an Op's C code. " 32904 "No Python exception was set."); 32905 } 32906 goto __label_634;} 32907 } 32908 if (!PyArray_Check(py_V633)) { 32909 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 32910 { 32911 __failure = 634; 32912 if (!PyErr_Occurred()) { 32913 PyErr_SetString(PyExc_RuntimeError, 32914 "Unexpected error in an Op's C code. " 32915 "No Python exception was set."); 32916 } 32917 goto __label_634;} 32918 } 32919 // We expect NPY_FLOAT64 32920 if (!PyArray_ISALIGNED((PyArrayObject*) py_V633)) { 32921 PyArrayObject * tmp = (PyArrayObject*) py_V633; 32922 PyErr_Format(PyExc_NotImplementedError, 32923 "expected an aligned array of type %ld " 32924 "(NPY_FLOAT64), got non-aligned array of type %ld" 32925 " with %ld dimensions, with 3 last dims " 32926 "%ld, %ld, %ld" 32927 " and 3 last strides %ld %ld, %ld.", 32928 (long int) NPY_FLOAT64, 32929 (long int) PyArray_TYPE((PyArrayObject*) py_V633), 32930 (long int) PyArray_NDIM(tmp), 32931 (long int) (PyArray_NDIM(tmp) >= 3 ? 32932 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 32933 (long int) (PyArray_NDIM(tmp) >= 2 ? 32934 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 32935 (long int) (PyArray_NDIM(tmp) >= 1 ? 32936 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 32937 (long int) (PyArray_NDIM(tmp) >= 3 ? 32938 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 32939 (long int) (PyArray_NDIM(tmp) >= 2 ? 32940 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 32941 (long int) (PyArray_NDIM(tmp) >= 1 ? 32942 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 32943 ); 32944 { 32945 __failure = 634; 32946 if (!PyErr_Occurred()) { 32947 PyErr_SetString(PyExc_RuntimeError, 32948 "Unexpected error in an Op's C code. " 32949 "No Python exception was set."); 32950 } 32951 goto __label_634;} 32952 } 32953 // This is a TypeError to be consistent with DEBUG_MODE 32954 // Note: DEBUG_MODE also tells the name of the container 32955 if (PyArray_TYPE((PyArrayObject*) py_V633) != NPY_FLOAT64) { 32956 PyErr_Format(PyExc_TypeError, 32957 "expected type_num %d (NPY_FLOAT64) got %d", 32958 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V633)); 32959 { 32960 __failure = 634; 32961 if (!PyErr_Occurred()) { 32962 PyErr_SetString(PyExc_RuntimeError, 32963 "Unexpected error in an Op's C code. " 32964 "No Python exception was set."); 32965 } 32966 goto __label_634;} 32967 } 32968 32969 V633 = (PyArrayObject*)(py_V633); 32970 Py_XINCREF(V633); 32971 32972 { 32973 32974 py_V635 = PyList_GET_ITEM(storage_V635, 0); 32975 {Py_XINCREF(py_V635);} 32976 32977 V635 = NULL; 32978 if (py_V635 == Py_None) { 32979 // We can either fail here or set V635 to NULL and rely on Ops 32980 // using tensors to handle the NULL case, but if they fail to do so 32981 // they'll end up with nasty segfaults, so this is public service. 32982 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 32983 { 32984 __failure = 636; 32985 if (!PyErr_Occurred()) { 32986 PyErr_SetString(PyExc_RuntimeError, 32987 "Unexpected error in an Op's C code. " 32988 "No Python exception was set."); 32989 } 32990 goto __label_636;} 32991 } 32992 if (!PyArray_Check(py_V635)) { 32993 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 32994 { 32995 __failure = 636; 32996 if (!PyErr_Occurred()) { 32997 PyErr_SetString(PyExc_RuntimeError, 32998 "Unexpected error in an Op's C code. " 32999 "No Python exception was set."); 33000 } 33001 goto __label_636;} 33002 } 33003 // We expect NPY_FLOAT64 33004 if (!PyArray_ISALIGNED((PyArrayObject*) py_V635)) { 33005 PyArrayObject * tmp = (PyArrayObject*) py_V635; 33006 PyErr_Format(PyExc_NotImplementedError, 33007 "expected an aligned array of type %ld " 33008 "(NPY_FLOAT64), got non-aligned array of type %ld" 33009 " with %ld dimensions, with 3 last dims " 33010 "%ld, %ld, %ld" 33011 " and 3 last strides %ld %ld, %ld.", 33012 (long int) NPY_FLOAT64, 33013 (long int) PyArray_TYPE((PyArrayObject*) py_V635), 33014 (long int) PyArray_NDIM(tmp), 33015 (long int) (PyArray_NDIM(tmp) >= 3 ? 33016 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 33017 (long int) (PyArray_NDIM(tmp) >= 2 ? 33018 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 33019 (long int) (PyArray_NDIM(tmp) >= 1 ? 33020 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 33021 (long int) (PyArray_NDIM(tmp) >= 3 ? 33022 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 33023 (long int) (PyArray_NDIM(tmp) >= 2 ? 33024 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 33025 (long int) (PyArray_NDIM(tmp) >= 1 ? 33026 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 33027 ); 33028 { 33029 __failure = 636; 33030 if (!PyErr_Occurred()) { 33031 PyErr_SetString(PyExc_RuntimeError, 33032 "Unexpected error in an Op's C code. " 33033 "No Python exception was set."); 33034 } 33035 goto __label_636;} 33036 } 33037 // This is a TypeError to be consistent with DEBUG_MODE 33038 // Note: DEBUG_MODE also tells the name of the container 33039 if (PyArray_TYPE((PyArrayObject*) py_V635) != NPY_FLOAT64) { 33040 PyErr_Format(PyExc_TypeError, 33041 "expected type_num %d (NPY_FLOAT64) got %d", 33042 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V635)); 33043 { 33044 __failure = 636; 33045 if (!PyErr_Occurred()) { 33046 PyErr_SetString(PyExc_RuntimeError, 33047 "Unexpected error in an Op's C code. " 33048 "No Python exception was set."); 33049 } 33050 goto __label_636;} 33051 } 33052 33053 V635 = (PyArrayObject*)(py_V635); 33054 Py_XINCREF(V635); 33055 33056 { 33057 33058 py_V637 = PyList_GET_ITEM(storage_V637, 0); 33059 {Py_XINCREF(py_V637);} 33060 33061 V637 = NULL; 33062 if (py_V637 == Py_None) { 33063 // We can either fail here or set V637 to NULL and rely on Ops 33064 // using tensors to handle the NULL case, but if they fail to do so 33065 // they'll end up with nasty segfaults, so this is public service. 33066 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 33067 { 33068 __failure = 638; 33069 if (!PyErr_Occurred()) { 33070 PyErr_SetString(PyExc_RuntimeError, 33071 "Unexpected error in an Op's C code. " 33072 "No Python exception was set."); 33073 } 33074 goto __label_638;} 33075 } 33076 if (!PyArray_Check(py_V637)) { 33077 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 33078 { 33079 __failure = 638; 33080 if (!PyErr_Occurred()) { 33081 PyErr_SetString(PyExc_RuntimeError, 33082 "Unexpected error in an Op's C code. " 33083 "No Python exception was set."); 33084 } 33085 goto __label_638;} 33086 } 33087 // We expect NPY_FLOAT64 33088 if (!PyArray_ISALIGNED((PyArrayObject*) py_V637)) { 33089 PyArrayObject * tmp = (PyArrayObject*) py_V637; 33090 PyErr_Format(PyExc_NotImplementedError, 33091 "expected an aligned array of type %ld " 33092 "(NPY_FLOAT64), got non-aligned array of type %ld" 33093 " with %ld dimensions, with 3 last dims " 33094 "%ld, %ld, %ld" 33095 " and 3 last strides %ld %ld, %ld.", 33096 (long int) NPY_FLOAT64, 33097 (long int) PyArray_TYPE((PyArrayObject*) py_V637), 33098 (long int) PyArray_NDIM(tmp), 33099 (long int) (PyArray_NDIM(tmp) >= 3 ? 33100 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 33101 (long int) (PyArray_NDIM(tmp) >= 2 ? 33102 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 33103 (long int) (PyArray_NDIM(tmp) >= 1 ? 33104 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 33105 (long int) (PyArray_NDIM(tmp) >= 3 ? 33106 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 33107 (long int) (PyArray_NDIM(tmp) >= 2 ? 33108 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 33109 (long int) (PyArray_NDIM(tmp) >= 1 ? 33110 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 33111 ); 33112 { 33113 __failure = 638; 33114 if (!PyErr_Occurred()) { 33115 PyErr_SetString(PyExc_RuntimeError, 33116 "Unexpected error in an Op's C code. " 33117 "No Python exception was set."); 33118 } 33119 goto __label_638;} 33120 } 33121 // This is a TypeError to be consistent with DEBUG_MODE 33122 // Note: DEBUG_MODE also tells the name of the container 33123 if (PyArray_TYPE((PyArrayObject*) py_V637) != NPY_FLOAT64) { 33124 PyErr_Format(PyExc_TypeError, 33125 "expected type_num %d (NPY_FLOAT64) got %d", 33126 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V637)); 33127 { 33128 __failure = 638; 33129 if (!PyErr_Occurred()) { 33130 PyErr_SetString(PyExc_RuntimeError, 33131 "Unexpected error in an Op's C code. " 33132 "No Python exception was set."); 33133 } 33134 goto __label_638;} 33135 } 33136 33137 V637 = (PyArrayObject*)(py_V637); 33138 Py_XINCREF(V637); 33139 33140 { 33141 33142 py_V639 = PyList_GET_ITEM(storage_V639, 0); 33143 {Py_XINCREF(py_V639);} 33144 33145 V639 = NULL; 33146 if (py_V639 == Py_None) { 33147 // We can either fail here or set V639 to NULL and rely on Ops 33148 // using tensors to handle the NULL case, but if they fail to do so 33149 // they'll end up with nasty segfaults, so this is public service. 33150 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 33151 { 33152 __failure = 640; 33153 if (!PyErr_Occurred()) { 33154 PyErr_SetString(PyExc_RuntimeError, 33155 "Unexpected error in an Op's C code. " 33156 "No Python exception was set."); 33157 } 33158 goto __label_640;} 33159 } 33160 if (!PyArray_Check(py_V639)) { 33161 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 33162 { 33163 __failure = 640; 33164 if (!PyErr_Occurred()) { 33165 PyErr_SetString(PyExc_RuntimeError, 33166 "Unexpected error in an Op's C code. " 33167 "No Python exception was set."); 33168 } 33169 goto __label_640;} 33170 } 33171 // We expect NPY_FLOAT64 33172 if (!PyArray_ISALIGNED((PyArrayObject*) py_V639)) { 33173 PyArrayObject * tmp = (PyArrayObject*) py_V639; 33174 PyErr_Format(PyExc_NotImplementedError, 33175 "expected an aligned array of type %ld " 33176 "(NPY_FLOAT64), got non-aligned array of type %ld" 33177 " with %ld dimensions, with 3 last dims " 33178 "%ld, %ld, %ld" 33179 " and 3 last strides %ld %ld, %ld.", 33180 (long int) NPY_FLOAT64, 33181 (long int) PyArray_TYPE((PyArrayObject*) py_V639), 33182 (long int) PyArray_NDIM(tmp), 33183 (long int) (PyArray_NDIM(tmp) >= 3 ? 33184 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 33185 (long int) (PyArray_NDIM(tmp) >= 2 ? 33186 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 33187 (long int) (PyArray_NDIM(tmp) >= 1 ? 33188 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 33189 (long int) (PyArray_NDIM(tmp) >= 3 ? 33190 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 33191 (long int) (PyArray_NDIM(tmp) >= 2 ? 33192 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 33193 (long int) (PyArray_NDIM(tmp) >= 1 ? 33194 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 33195 ); 33196 { 33197 __failure = 640; 33198 if (!PyErr_Occurred()) { 33199 PyErr_SetString(PyExc_RuntimeError, 33200 "Unexpected error in an Op's C code. " 33201 "No Python exception was set."); 33202 } 33203 goto __label_640;} 33204 } 33205 // This is a TypeError to be consistent with DEBUG_MODE 33206 // Note: DEBUG_MODE also tells the name of the container 33207 if (PyArray_TYPE((PyArrayObject*) py_V639) != NPY_FLOAT64) { 33208 PyErr_Format(PyExc_TypeError, 33209 "expected type_num %d (NPY_FLOAT64) got %d", 33210 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V639)); 33211 { 33212 __failure = 640; 33213 if (!PyErr_Occurred()) { 33214 PyErr_SetString(PyExc_RuntimeError, 33215 "Unexpected error in an Op's C code. " 33216 "No Python exception was set."); 33217 } 33218 goto __label_640;} 33219 } 33220 33221 V639 = (PyArrayObject*)(py_V639); 33222 Py_XINCREF(V639); 33223 33224 { 33225 33226 py_V641 = PyList_GET_ITEM(storage_V641, 0); 33227 {Py_XINCREF(py_V641);} 33228 33229 V641 = NULL; 33230 if (py_V641 == Py_None) { 33231 // We can either fail here or set V641 to NULL and rely on Ops 33232 // using tensors to handle the NULL case, but if they fail to do so 33233 // they'll end up with nasty segfaults, so this is public service. 33234 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 33235 { 33236 __failure = 642; 33237 if (!PyErr_Occurred()) { 33238 PyErr_SetString(PyExc_RuntimeError, 33239 "Unexpected error in an Op's C code. " 33240 "No Python exception was set."); 33241 } 33242 goto __label_642;} 33243 } 33244 if (!PyArray_Check(py_V641)) { 33245 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 33246 { 33247 __failure = 642; 33248 if (!PyErr_Occurred()) { 33249 PyErr_SetString(PyExc_RuntimeError, 33250 "Unexpected error in an Op's C code. " 33251 "No Python exception was set."); 33252 } 33253 goto __label_642;} 33254 } 33255 // We expect NPY_FLOAT64 33256 if (!PyArray_ISALIGNED((PyArrayObject*) py_V641)) { 33257 PyArrayObject * tmp = (PyArrayObject*) py_V641; 33258 PyErr_Format(PyExc_NotImplementedError, 33259 "expected an aligned array of type %ld " 33260 "(NPY_FLOAT64), got non-aligned array of type %ld" 33261 " with %ld dimensions, with 3 last dims " 33262 "%ld, %ld, %ld" 33263 " and 3 last strides %ld %ld, %ld.", 33264 (long int) NPY_FLOAT64, 33265 (long int) PyArray_TYPE((PyArrayObject*) py_V641), 33266 (long int) PyArray_NDIM(tmp), 33267 (long int) (PyArray_NDIM(tmp) >= 3 ? 33268 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 33269 (long int) (PyArray_NDIM(tmp) >= 2 ? 33270 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 33271 (long int) (PyArray_NDIM(tmp) >= 1 ? 33272 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 33273 (long int) (PyArray_NDIM(tmp) >= 3 ? 33274 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 33275 (long int) (PyArray_NDIM(tmp) >= 2 ? 33276 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 33277 (long int) (PyArray_NDIM(tmp) >= 1 ? 33278 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 33279 ); 33280 { 33281 __failure = 642; 33282 if (!PyErr_Occurred()) { 33283 PyErr_SetString(PyExc_RuntimeError, 33284 "Unexpected error in an Op's C code. " 33285 "No Python exception was set."); 33286 } 33287 goto __label_642;} 33288 } 33289 // This is a TypeError to be consistent with DEBUG_MODE 33290 // Note: DEBUG_MODE also tells the name of the container 33291 if (PyArray_TYPE((PyArrayObject*) py_V641) != NPY_FLOAT64) { 33292 PyErr_Format(PyExc_TypeError, 33293 "expected type_num %d (NPY_FLOAT64) got %d", 33294 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V641)); 33295 { 33296 __failure = 642; 33297 if (!PyErr_Occurred()) { 33298 PyErr_SetString(PyExc_RuntimeError, 33299 "Unexpected error in an Op's C code. " 33300 "No Python exception was set."); 33301 } 33302 goto __label_642;} 33303 } 33304 33305 V641 = (PyArrayObject*)(py_V641); 33306 Py_XINCREF(V641); 33307 33308 { 33309 33310 py_V643 = PyList_GET_ITEM(storage_V643, 0); 33311 {Py_XINCREF(py_V643);} 33312 33313 V643 = NULL; 33314 if (py_V643 == Py_None) { 33315 // We can either fail here or set V643 to NULL and rely on Ops 33316 // using tensors to handle the NULL case, but if they fail to do so 33317 // they'll end up with nasty segfaults, so this is public service. 33318 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 33319 { 33320 __failure = 644; 33321 if (!PyErr_Occurred()) { 33322 PyErr_SetString(PyExc_RuntimeError, 33323 "Unexpected error in an Op's C code. " 33324 "No Python exception was set."); 33325 } 33326 goto __label_644;} 33327 } 33328 if (!PyArray_Check(py_V643)) { 33329 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 33330 { 33331 __failure = 644; 33332 if (!PyErr_Occurred()) { 33333 PyErr_SetString(PyExc_RuntimeError, 33334 "Unexpected error in an Op's C code. " 33335 "No Python exception was set."); 33336 } 33337 goto __label_644;} 33338 } 33339 // We expect NPY_FLOAT64 33340 if (!PyArray_ISALIGNED((PyArrayObject*) py_V643)) { 33341 PyArrayObject * tmp = (PyArrayObject*) py_V643; 33342 PyErr_Format(PyExc_NotImplementedError, 33343 "expected an aligned array of type %ld " 33344 "(NPY_FLOAT64), got non-aligned array of type %ld" 33345 " with %ld dimensions, with 3 last dims " 33346 "%ld, %ld, %ld" 33347 " and 3 last strides %ld %ld, %ld.", 33348 (long int) NPY_FLOAT64, 33349 (long int) PyArray_TYPE((PyArrayObject*) py_V643), 33350 (long int) PyArray_NDIM(tmp), 33351 (long int) (PyArray_NDIM(tmp) >= 3 ? 33352 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 33353 (long int) (PyArray_NDIM(tmp) >= 2 ? 33354 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 33355 (long int) (PyArray_NDIM(tmp) >= 1 ? 33356 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 33357 (long int) (PyArray_NDIM(tmp) >= 3 ? 33358 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 33359 (long int) (PyArray_NDIM(tmp) >= 2 ? 33360 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 33361 (long int) (PyArray_NDIM(tmp) >= 1 ? 33362 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 33363 ); 33364 { 33365 __failure = 644; 33366 if (!PyErr_Occurred()) { 33367 PyErr_SetString(PyExc_RuntimeError, 33368 "Unexpected error in an Op's C code. " 33369 "No Python exception was set."); 33370 } 33371 goto __label_644;} 33372 } 33373 // This is a TypeError to be consistent with DEBUG_MODE 33374 // Note: DEBUG_MODE also tells the name of the container 33375 if (PyArray_TYPE((PyArrayObject*) py_V643) != NPY_FLOAT64) { 33376 PyErr_Format(PyExc_TypeError, 33377 "expected type_num %d (NPY_FLOAT64) got %d", 33378 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V643)); 33379 { 33380 __failure = 644; 33381 if (!PyErr_Occurred()) { 33382 PyErr_SetString(PyExc_RuntimeError, 33383 "Unexpected error in an Op's C code. " 33384 "No Python exception was set."); 33385 } 33386 goto __label_644;} 33387 } 33388 33389 V643 = (PyArrayObject*)(py_V643); 33390 Py_XINCREF(V643); 33391 33392 { 33393 33394 py_V645 = PyList_GET_ITEM(storage_V645, 0); 33395 {Py_XINCREF(py_V645);} 33396 33397 V645 = NULL; 33398 if (py_V645 == Py_None) { 33399 // We can either fail here or set V645 to NULL and rely on Ops 33400 // using tensors to handle the NULL case, but if they fail to do so 33401 // they'll end up with nasty segfaults, so this is public service. 33402 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 33403 { 33404 __failure = 646; 33405 if (!PyErr_Occurred()) { 33406 PyErr_SetString(PyExc_RuntimeError, 33407 "Unexpected error in an Op's C code. " 33408 "No Python exception was set."); 33409 } 33410 goto __label_646;} 33411 } 33412 if (!PyArray_Check(py_V645)) { 33413 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 33414 { 33415 __failure = 646; 33416 if (!PyErr_Occurred()) { 33417 PyErr_SetString(PyExc_RuntimeError, 33418 "Unexpected error in an Op's C code. " 33419 "No Python exception was set."); 33420 } 33421 goto __label_646;} 33422 } 33423 // We expect NPY_FLOAT64 33424 if (!PyArray_ISALIGNED((PyArrayObject*) py_V645)) { 33425 PyArrayObject * tmp = (PyArrayObject*) py_V645; 33426 PyErr_Format(PyExc_NotImplementedError, 33427 "expected an aligned array of type %ld " 33428 "(NPY_FLOAT64), got non-aligned array of type %ld" 33429 " with %ld dimensions, with 3 last dims " 33430 "%ld, %ld, %ld" 33431 " and 3 last strides %ld %ld, %ld.", 33432 (long int) NPY_FLOAT64, 33433 (long int) PyArray_TYPE((PyArrayObject*) py_V645), 33434 (long int) PyArray_NDIM(tmp), 33435 (long int) (PyArray_NDIM(tmp) >= 3 ? 33436 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 33437 (long int) (PyArray_NDIM(tmp) >= 2 ? 33438 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 33439 (long int) (PyArray_NDIM(tmp) >= 1 ? 33440 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 33441 (long int) (PyArray_NDIM(tmp) >= 3 ? 33442 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 33443 (long int) (PyArray_NDIM(tmp) >= 2 ? 33444 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 33445 (long int) (PyArray_NDIM(tmp) >= 1 ? 33446 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 33447 ); 33448 { 33449 __failure = 646; 33450 if (!PyErr_Occurred()) { 33451 PyErr_SetString(PyExc_RuntimeError, 33452 "Unexpected error in an Op's C code. " 33453 "No Python exception was set."); 33454 } 33455 goto __label_646;} 33456 } 33457 // This is a TypeError to be consistent with DEBUG_MODE 33458 // Note: DEBUG_MODE also tells the name of the container 33459 if (PyArray_TYPE((PyArrayObject*) py_V645) != NPY_FLOAT64) { 33460 PyErr_Format(PyExc_TypeError, 33461 "expected type_num %d (NPY_FLOAT64) got %d", 33462 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V645)); 33463 { 33464 __failure = 646; 33465 if (!PyErr_Occurred()) { 33466 PyErr_SetString(PyExc_RuntimeError, 33467 "Unexpected error in an Op's C code. " 33468 "No Python exception was set."); 33469 } 33470 goto __label_646;} 33471 } 33472 33473 V645 = (PyArrayObject*)(py_V645); 33474 Py_XINCREF(V645); 33475 33476 { 33477 33478 py_V647 = PyList_GET_ITEM(storage_V647, 0); 33479 {Py_XINCREF(py_V647);} 33480 33481 V647 = NULL; 33482 if (py_V647 == Py_None) { 33483 // We can either fail here or set V647 to NULL and rely on Ops 33484 // using tensors to handle the NULL case, but if they fail to do so 33485 // they'll end up with nasty segfaults, so this is public service. 33486 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 33487 { 33488 __failure = 648; 33489 if (!PyErr_Occurred()) { 33490 PyErr_SetString(PyExc_RuntimeError, 33491 "Unexpected error in an Op's C code. " 33492 "No Python exception was set."); 33493 } 33494 goto __label_648;} 33495 } 33496 if (!PyArray_Check(py_V647)) { 33497 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 33498 { 33499 __failure = 648; 33500 if (!PyErr_Occurred()) { 33501 PyErr_SetString(PyExc_RuntimeError, 33502 "Unexpected error in an Op's C code. " 33503 "No Python exception was set."); 33504 } 33505 goto __label_648;} 33506 } 33507 // We expect NPY_FLOAT64 33508 if (!PyArray_ISALIGNED((PyArrayObject*) py_V647)) { 33509 PyArrayObject * tmp = (PyArrayObject*) py_V647; 33510 PyErr_Format(PyExc_NotImplementedError, 33511 "expected an aligned array of type %ld " 33512 "(NPY_FLOAT64), got non-aligned array of type %ld" 33513 " with %ld dimensions, with 3 last dims " 33514 "%ld, %ld, %ld" 33515 " and 3 last strides %ld %ld, %ld.", 33516 (long int) NPY_FLOAT64, 33517 (long int) PyArray_TYPE((PyArrayObject*) py_V647), 33518 (long int) PyArray_NDIM(tmp), 33519 (long int) (PyArray_NDIM(tmp) >= 3 ? 33520 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 33521 (long int) (PyArray_NDIM(tmp) >= 2 ? 33522 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 33523 (long int) (PyArray_NDIM(tmp) >= 1 ? 33524 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 33525 (long int) (PyArray_NDIM(tmp) >= 3 ? 33526 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 33527 (long int) (PyArray_NDIM(tmp) >= 2 ? 33528 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 33529 (long int) (PyArray_NDIM(tmp) >= 1 ? 33530 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 33531 ); 33532 { 33533 __failure = 648; 33534 if (!PyErr_Occurred()) { 33535 PyErr_SetString(PyExc_RuntimeError, 33536 "Unexpected error in an Op's C code. " 33537 "No Python exception was set."); 33538 } 33539 goto __label_648;} 33540 } 33541 // This is a TypeError to be consistent with DEBUG_MODE 33542 // Note: DEBUG_MODE also tells the name of the container 33543 if (PyArray_TYPE((PyArrayObject*) py_V647) != NPY_FLOAT64) { 33544 PyErr_Format(PyExc_TypeError, 33545 "expected type_num %d (NPY_FLOAT64) got %d", 33546 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V647)); 33547 { 33548 __failure = 648; 33549 if (!PyErr_Occurred()) { 33550 PyErr_SetString(PyExc_RuntimeError, 33551 "Unexpected error in an Op's C code. " 33552 "No Python exception was set."); 33553 } 33554 goto __label_648;} 33555 } 33556 33557 V647 = (PyArrayObject*)(py_V647); 33558 Py_XINCREF(V647); 33559 33560 { 33561 33562 py_V649 = PyList_GET_ITEM(storage_V649, 0); 33563 {Py_XINCREF(py_V649);} 33564 33565 V649 = NULL; 33566 if (py_V649 == Py_None) { 33567 // We can either fail here or set V649 to NULL and rely on Ops 33568 // using tensors to handle the NULL case, but if they fail to do so 33569 // they'll end up with nasty segfaults, so this is public service. 33570 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 33571 { 33572 __failure = 650; 33573 if (!PyErr_Occurred()) { 33574 PyErr_SetString(PyExc_RuntimeError, 33575 "Unexpected error in an Op's C code. " 33576 "No Python exception was set."); 33577 } 33578 goto __label_650;} 33579 } 33580 if (!PyArray_Check(py_V649)) { 33581 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 33582 { 33583 __failure = 650; 33584 if (!PyErr_Occurred()) { 33585 PyErr_SetString(PyExc_RuntimeError, 33586 "Unexpected error in an Op's C code. " 33587 "No Python exception was set."); 33588 } 33589 goto __label_650;} 33590 } 33591 // We expect NPY_FLOAT64 33592 if (!PyArray_ISALIGNED((PyArrayObject*) py_V649)) { 33593 PyArrayObject * tmp = (PyArrayObject*) py_V649; 33594 PyErr_Format(PyExc_NotImplementedError, 33595 "expected an aligned array of type %ld " 33596 "(NPY_FLOAT64), got non-aligned array of type %ld" 33597 " with %ld dimensions, with 3 last dims " 33598 "%ld, %ld, %ld" 33599 " and 3 last strides %ld %ld, %ld.", 33600 (long int) NPY_FLOAT64, 33601 (long int) PyArray_TYPE((PyArrayObject*) py_V649), 33602 (long int) PyArray_NDIM(tmp), 33603 (long int) (PyArray_NDIM(tmp) >= 3 ? 33604 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 33605 (long int) (PyArray_NDIM(tmp) >= 2 ? 33606 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 33607 (long int) (PyArray_NDIM(tmp) >= 1 ? 33608 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 33609 (long int) (PyArray_NDIM(tmp) >= 3 ? 33610 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 33611 (long int) (PyArray_NDIM(tmp) >= 2 ? 33612 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 33613 (long int) (PyArray_NDIM(tmp) >= 1 ? 33614 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 33615 ); 33616 { 33617 __failure = 650; 33618 if (!PyErr_Occurred()) { 33619 PyErr_SetString(PyExc_RuntimeError, 33620 "Unexpected error in an Op's C code. " 33621 "No Python exception was set."); 33622 } 33623 goto __label_650;} 33624 } 33625 // This is a TypeError to be consistent with DEBUG_MODE 33626 // Note: DEBUG_MODE also tells the name of the container 33627 if (PyArray_TYPE((PyArrayObject*) py_V649) != NPY_FLOAT64) { 33628 PyErr_Format(PyExc_TypeError, 33629 "expected type_num %d (NPY_FLOAT64) got %d", 33630 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V649)); 33631 { 33632 __failure = 650; 33633 if (!PyErr_Occurred()) { 33634 PyErr_SetString(PyExc_RuntimeError, 33635 "Unexpected error in an Op's C code. " 33636 "No Python exception was set."); 33637 } 33638 goto __label_650;} 33639 } 33640 33641 V649 = (PyArrayObject*)(py_V649); 33642 Py_XINCREF(V649); 33643 33644 { 33645 33646 py_V651 = PyList_GET_ITEM(storage_V651, 0); 33647 {Py_XINCREF(py_V651);} 33648 33649 V651 = NULL; 33650 if (py_V651 == Py_None) { 33651 // We can either fail here or set V651 to NULL and rely on Ops 33652 // using tensors to handle the NULL case, but if they fail to do so 33653 // they'll end up with nasty segfaults, so this is public service. 33654 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 33655 { 33656 __failure = 652; 33657 if (!PyErr_Occurred()) { 33658 PyErr_SetString(PyExc_RuntimeError, 33659 "Unexpected error in an Op's C code. " 33660 "No Python exception was set."); 33661 } 33662 goto __label_652;} 33663 } 33664 if (!PyArray_Check(py_V651)) { 33665 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 33666 { 33667 __failure = 652; 33668 if (!PyErr_Occurred()) { 33669 PyErr_SetString(PyExc_RuntimeError, 33670 "Unexpected error in an Op's C code. " 33671 "No Python exception was set."); 33672 } 33673 goto __label_652;} 33674 } 33675 // We expect NPY_FLOAT64 33676 if (!PyArray_ISALIGNED((PyArrayObject*) py_V651)) { 33677 PyArrayObject * tmp = (PyArrayObject*) py_V651; 33678 PyErr_Format(PyExc_NotImplementedError, 33679 "expected an aligned array of type %ld " 33680 "(NPY_FLOAT64), got non-aligned array of type %ld" 33681 " with %ld dimensions, with 3 last dims " 33682 "%ld, %ld, %ld" 33683 " and 3 last strides %ld %ld, %ld.", 33684 (long int) NPY_FLOAT64, 33685 (long int) PyArray_TYPE((PyArrayObject*) py_V651), 33686 (long int) PyArray_NDIM(tmp), 33687 (long int) (PyArray_NDIM(tmp) >= 3 ? 33688 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 33689 (long int) (PyArray_NDIM(tmp) >= 2 ? 33690 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 33691 (long int) (PyArray_NDIM(tmp) >= 1 ? 33692 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 33693 (long int) (PyArray_NDIM(tmp) >= 3 ? 33694 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 33695 (long int) (PyArray_NDIM(tmp) >= 2 ? 33696 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 33697 (long int) (PyArray_NDIM(tmp) >= 1 ? 33698 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 33699 ); 33700 { 33701 __failure = 652; 33702 if (!PyErr_Occurred()) { 33703 PyErr_SetString(PyExc_RuntimeError, 33704 "Unexpected error in an Op's C code. " 33705 "No Python exception was set."); 33706 } 33707 goto __label_652;} 33708 } 33709 // This is a TypeError to be consistent with DEBUG_MODE 33710 // Note: DEBUG_MODE also tells the name of the container 33711 if (PyArray_TYPE((PyArrayObject*) py_V651) != NPY_FLOAT64) { 33712 PyErr_Format(PyExc_TypeError, 33713 "expected type_num %d (NPY_FLOAT64) got %d", 33714 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V651)); 33715 { 33716 __failure = 652; 33717 if (!PyErr_Occurred()) { 33718 PyErr_SetString(PyExc_RuntimeError, 33719 "Unexpected error in an Op's C code. " 33720 "No Python exception was set."); 33721 } 33722 goto __label_652;} 33723 } 33724 33725 V651 = (PyArrayObject*)(py_V651); 33726 Py_XINCREF(V651); 33727 33728 { 33729 33730 py_V653 = PyList_GET_ITEM(storage_V653, 0); 33731 {Py_XINCREF(py_V653);} 33732 33733 V653 = NULL; 33734 if (py_V653 == Py_None) { 33735 // We can either fail here or set V653 to NULL and rely on Ops 33736 // using tensors to handle the NULL case, but if they fail to do so 33737 // they'll end up with nasty segfaults, so this is public service. 33738 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 33739 { 33740 __failure = 654; 33741 if (!PyErr_Occurred()) { 33742 PyErr_SetString(PyExc_RuntimeError, 33743 "Unexpected error in an Op's C code. " 33744 "No Python exception was set."); 33745 } 33746 goto __label_654;} 33747 } 33748 if (!PyArray_Check(py_V653)) { 33749 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 33750 { 33751 __failure = 654; 33752 if (!PyErr_Occurred()) { 33753 PyErr_SetString(PyExc_RuntimeError, 33754 "Unexpected error in an Op's C code. " 33755 "No Python exception was set."); 33756 } 33757 goto __label_654;} 33758 } 33759 // We expect NPY_FLOAT64 33760 if (!PyArray_ISALIGNED((PyArrayObject*) py_V653)) { 33761 PyArrayObject * tmp = (PyArrayObject*) py_V653; 33762 PyErr_Format(PyExc_NotImplementedError, 33763 "expected an aligned array of type %ld " 33764 "(NPY_FLOAT64), got non-aligned array of type %ld" 33765 " with %ld dimensions, with 3 last dims " 33766 "%ld, %ld, %ld" 33767 " and 3 last strides %ld %ld, %ld.", 33768 (long int) NPY_FLOAT64, 33769 (long int) PyArray_TYPE((PyArrayObject*) py_V653), 33770 (long int) PyArray_NDIM(tmp), 33771 (long int) (PyArray_NDIM(tmp) >= 3 ? 33772 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 33773 (long int) (PyArray_NDIM(tmp) >= 2 ? 33774 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 33775 (long int) (PyArray_NDIM(tmp) >= 1 ? 33776 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 33777 (long int) (PyArray_NDIM(tmp) >= 3 ? 33778 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 33779 (long int) (PyArray_NDIM(tmp) >= 2 ? 33780 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 33781 (long int) (PyArray_NDIM(tmp) >= 1 ? 33782 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 33783 ); 33784 { 33785 __failure = 654; 33786 if (!PyErr_Occurred()) { 33787 PyErr_SetString(PyExc_RuntimeError, 33788 "Unexpected error in an Op's C code. " 33789 "No Python exception was set."); 33790 } 33791 goto __label_654;} 33792 } 33793 // This is a TypeError to be consistent with DEBUG_MODE 33794 // Note: DEBUG_MODE also tells the name of the container 33795 if (PyArray_TYPE((PyArrayObject*) py_V653) != NPY_FLOAT64) { 33796 PyErr_Format(PyExc_TypeError, 33797 "expected type_num %d (NPY_FLOAT64) got %d", 33798 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V653)); 33799 { 33800 __failure = 654; 33801 if (!PyErr_Occurred()) { 33802 PyErr_SetString(PyExc_RuntimeError, 33803 "Unexpected error in an Op's C code. " 33804 "No Python exception was set."); 33805 } 33806 goto __label_654;} 33807 } 33808 33809 V653 = (PyArrayObject*)(py_V653); 33810 Py_XINCREF(V653); 33811 33812 { 33813 33814 py_V655 = PyList_GET_ITEM(storage_V655, 0); 33815 {Py_XINCREF(py_V655);} 33816 33817 V655 = NULL; 33818 if (py_V655 == Py_None) { 33819 // We can either fail here or set V655 to NULL and rely on Ops 33820 // using tensors to handle the NULL case, but if they fail to do so 33821 // they'll end up with nasty segfaults, so this is public service. 33822 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 33823 { 33824 __failure = 656; 33825 if (!PyErr_Occurred()) { 33826 PyErr_SetString(PyExc_RuntimeError, 33827 "Unexpected error in an Op's C code. " 33828 "No Python exception was set."); 33829 } 33830 goto __label_656;} 33831 } 33832 if (!PyArray_Check(py_V655)) { 33833 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 33834 { 33835 __failure = 656; 33836 if (!PyErr_Occurred()) { 33837 PyErr_SetString(PyExc_RuntimeError, 33838 "Unexpected error in an Op's C code. " 33839 "No Python exception was set."); 33840 } 33841 goto __label_656;} 33842 } 33843 // We expect NPY_FLOAT64 33844 if (!PyArray_ISALIGNED((PyArrayObject*) py_V655)) { 33845 PyArrayObject * tmp = (PyArrayObject*) py_V655; 33846 PyErr_Format(PyExc_NotImplementedError, 33847 "expected an aligned array of type %ld " 33848 "(NPY_FLOAT64), got non-aligned array of type %ld" 33849 " with %ld dimensions, with 3 last dims " 33850 "%ld, %ld, %ld" 33851 " and 3 last strides %ld %ld, %ld.", 33852 (long int) NPY_FLOAT64, 33853 (long int) PyArray_TYPE((PyArrayObject*) py_V655), 33854 (long int) PyArray_NDIM(tmp), 33855 (long int) (PyArray_NDIM(tmp) >= 3 ? 33856 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 33857 (long int) (PyArray_NDIM(tmp) >= 2 ? 33858 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 33859 (long int) (PyArray_NDIM(tmp) >= 1 ? 33860 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 33861 (long int) (PyArray_NDIM(tmp) >= 3 ? 33862 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 33863 (long int) (PyArray_NDIM(tmp) >= 2 ? 33864 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 33865 (long int) (PyArray_NDIM(tmp) >= 1 ? 33866 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 33867 ); 33868 { 33869 __failure = 656; 33870 if (!PyErr_Occurred()) { 33871 PyErr_SetString(PyExc_RuntimeError, 33872 "Unexpected error in an Op's C code. " 33873 "No Python exception was set."); 33874 } 33875 goto __label_656;} 33876 } 33877 // This is a TypeError to be consistent with DEBUG_MODE 33878 // Note: DEBUG_MODE also tells the name of the container 33879 if (PyArray_TYPE((PyArrayObject*) py_V655) != NPY_FLOAT64) { 33880 PyErr_Format(PyExc_TypeError, 33881 "expected type_num %d (NPY_FLOAT64) got %d", 33882 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V655)); 33883 { 33884 __failure = 656; 33885 if (!PyErr_Occurred()) { 33886 PyErr_SetString(PyExc_RuntimeError, 33887 "Unexpected error in an Op's C code. " 33888 "No Python exception was set."); 33889 } 33890 goto __label_656;} 33891 } 33892 33893 V655 = (PyArrayObject*)(py_V655); 33894 Py_XINCREF(V655); 33895 33896 { 33897 33898 py_V657 = PyList_GET_ITEM(storage_V657, 0); 33899 {Py_XINCREF(py_V657);} 33900 33901 V657 = NULL; 33902 if (py_V657 == Py_None) { 33903 // We can either fail here or set V657 to NULL and rely on Ops 33904 // using tensors to handle the NULL case, but if they fail to do so 33905 // they'll end up with nasty segfaults, so this is public service. 33906 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 33907 { 33908 __failure = 658; 33909 if (!PyErr_Occurred()) { 33910 PyErr_SetString(PyExc_RuntimeError, 33911 "Unexpected error in an Op's C code. " 33912 "No Python exception was set."); 33913 } 33914 goto __label_658;} 33915 } 33916 if (!PyArray_Check(py_V657)) { 33917 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 33918 { 33919 __failure = 658; 33920 if (!PyErr_Occurred()) { 33921 PyErr_SetString(PyExc_RuntimeError, 33922 "Unexpected error in an Op's C code. " 33923 "No Python exception was set."); 33924 } 33925 goto __label_658;} 33926 } 33927 // We expect NPY_FLOAT64 33928 if (!PyArray_ISALIGNED((PyArrayObject*) py_V657)) { 33929 PyArrayObject * tmp = (PyArrayObject*) py_V657; 33930 PyErr_Format(PyExc_NotImplementedError, 33931 "expected an aligned array of type %ld " 33932 "(NPY_FLOAT64), got non-aligned array of type %ld" 33933 " with %ld dimensions, with 3 last dims " 33934 "%ld, %ld, %ld" 33935 " and 3 last strides %ld %ld, %ld.", 33936 (long int) NPY_FLOAT64, 33937 (long int) PyArray_TYPE((PyArrayObject*) py_V657), 33938 (long int) PyArray_NDIM(tmp), 33939 (long int) (PyArray_NDIM(tmp) >= 3 ? 33940 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 33941 (long int) (PyArray_NDIM(tmp) >= 2 ? 33942 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 33943 (long int) (PyArray_NDIM(tmp) >= 1 ? 33944 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 33945 (long int) (PyArray_NDIM(tmp) >= 3 ? 33946 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 33947 (long int) (PyArray_NDIM(tmp) >= 2 ? 33948 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 33949 (long int) (PyArray_NDIM(tmp) >= 1 ? 33950 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 33951 ); 33952 { 33953 __failure = 658; 33954 if (!PyErr_Occurred()) { 33955 PyErr_SetString(PyExc_RuntimeError, 33956 "Unexpected error in an Op's C code. " 33957 "No Python exception was set."); 33958 } 33959 goto __label_658;} 33960 } 33961 // This is a TypeError to be consistent with DEBUG_MODE 33962 // Note: DEBUG_MODE also tells the name of the container 33963 if (PyArray_TYPE((PyArrayObject*) py_V657) != NPY_FLOAT64) { 33964 PyErr_Format(PyExc_TypeError, 33965 "expected type_num %d (NPY_FLOAT64) got %d", 33966 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V657)); 33967 { 33968 __failure = 658; 33969 if (!PyErr_Occurred()) { 33970 PyErr_SetString(PyExc_RuntimeError, 33971 "Unexpected error in an Op's C code. " 33972 "No Python exception was set."); 33973 } 33974 goto __label_658;} 33975 } 33976 33977 V657 = (PyArrayObject*)(py_V657); 33978 Py_XINCREF(V657); 33979 33980 { 33981 33982 py_V659 = PyList_GET_ITEM(storage_V659, 0); 33983 {Py_XINCREF(py_V659);} 33984 33985 V659 = NULL; 33986 if (py_V659 == Py_None) { 33987 // We can either fail here or set V659 to NULL and rely on Ops 33988 // using tensors to handle the NULL case, but if they fail to do so 33989 // they'll end up with nasty segfaults, so this is public service. 33990 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 33991 { 33992 __failure = 660; 33993 if (!PyErr_Occurred()) { 33994 PyErr_SetString(PyExc_RuntimeError, 33995 "Unexpected error in an Op's C code. " 33996 "No Python exception was set."); 33997 } 33998 goto __label_660;} 33999 } 34000 if (!PyArray_Check(py_V659)) { 34001 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 34002 { 34003 __failure = 660; 34004 if (!PyErr_Occurred()) { 34005 PyErr_SetString(PyExc_RuntimeError, 34006 "Unexpected error in an Op's C code. " 34007 "No Python exception was set."); 34008 } 34009 goto __label_660;} 34010 } 34011 // We expect NPY_FLOAT64 34012 if (!PyArray_ISALIGNED((PyArrayObject*) py_V659)) { 34013 PyArrayObject * tmp = (PyArrayObject*) py_V659; 34014 PyErr_Format(PyExc_NotImplementedError, 34015 "expected an aligned array of type %ld " 34016 "(NPY_FLOAT64), got non-aligned array of type %ld" 34017 " with %ld dimensions, with 3 last dims " 34018 "%ld, %ld, %ld" 34019 " and 3 last strides %ld %ld, %ld.", 34020 (long int) NPY_FLOAT64, 34021 (long int) PyArray_TYPE((PyArrayObject*) py_V659), 34022 (long int) PyArray_NDIM(tmp), 34023 (long int) (PyArray_NDIM(tmp) >= 3 ? 34024 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 34025 (long int) (PyArray_NDIM(tmp) >= 2 ? 34026 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 34027 (long int) (PyArray_NDIM(tmp) >= 1 ? 34028 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 34029 (long int) (PyArray_NDIM(tmp) >= 3 ? 34030 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 34031 (long int) (PyArray_NDIM(tmp) >= 2 ? 34032 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 34033 (long int) (PyArray_NDIM(tmp) >= 1 ? 34034 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 34035 ); 34036 { 34037 __failure = 660; 34038 if (!PyErr_Occurred()) { 34039 PyErr_SetString(PyExc_RuntimeError, 34040 "Unexpected error in an Op's C code. " 34041 "No Python exception was set."); 34042 } 34043 goto __label_660;} 34044 } 34045 // This is a TypeError to be consistent with DEBUG_MODE 34046 // Note: DEBUG_MODE also tells the name of the container 34047 if (PyArray_TYPE((PyArrayObject*) py_V659) != NPY_FLOAT64) { 34048 PyErr_Format(PyExc_TypeError, 34049 "expected type_num %d (NPY_FLOAT64) got %d", 34050 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V659)); 34051 { 34052 __failure = 660; 34053 if (!PyErr_Occurred()) { 34054 PyErr_SetString(PyExc_RuntimeError, 34055 "Unexpected error in an Op's C code. " 34056 "No Python exception was set."); 34057 } 34058 goto __label_660;} 34059 } 34060 34061 V659 = (PyArrayObject*)(py_V659); 34062 Py_XINCREF(V659); 34063 34064 { 34065 34066 py_V661 = PyList_GET_ITEM(storage_V661, 0); 34067 {Py_XINCREF(py_V661);} 34068 34069 V661 = NULL; 34070 if (py_V661 == Py_None) { 34071 // We can either fail here or set V661 to NULL and rely on Ops 34072 // using tensors to handle the NULL case, but if they fail to do so 34073 // they'll end up with nasty segfaults, so this is public service. 34074 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 34075 { 34076 __failure = 662; 34077 if (!PyErr_Occurred()) { 34078 PyErr_SetString(PyExc_RuntimeError, 34079 "Unexpected error in an Op's C code. " 34080 "No Python exception was set."); 34081 } 34082 goto __label_662;} 34083 } 34084 if (!PyArray_Check(py_V661)) { 34085 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 34086 { 34087 __failure = 662; 34088 if (!PyErr_Occurred()) { 34089 PyErr_SetString(PyExc_RuntimeError, 34090 "Unexpected error in an Op's C code. " 34091 "No Python exception was set."); 34092 } 34093 goto __label_662;} 34094 } 34095 // We expect NPY_FLOAT64 34096 if (!PyArray_ISALIGNED((PyArrayObject*) py_V661)) { 34097 PyArrayObject * tmp = (PyArrayObject*) py_V661; 34098 PyErr_Format(PyExc_NotImplementedError, 34099 "expected an aligned array of type %ld " 34100 "(NPY_FLOAT64), got non-aligned array of type %ld" 34101 " with %ld dimensions, with 3 last dims " 34102 "%ld, %ld, %ld" 34103 " and 3 last strides %ld %ld, %ld.", 34104 (long int) NPY_FLOAT64, 34105 (long int) PyArray_TYPE((PyArrayObject*) py_V661), 34106 (long int) PyArray_NDIM(tmp), 34107 (long int) (PyArray_NDIM(tmp) >= 3 ? 34108 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 34109 (long int) (PyArray_NDIM(tmp) >= 2 ? 34110 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 34111 (long int) (PyArray_NDIM(tmp) >= 1 ? 34112 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 34113 (long int) (PyArray_NDIM(tmp) >= 3 ? 34114 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 34115 (long int) (PyArray_NDIM(tmp) >= 2 ? 34116 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 34117 (long int) (PyArray_NDIM(tmp) >= 1 ? 34118 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 34119 ); 34120 { 34121 __failure = 662; 34122 if (!PyErr_Occurred()) { 34123 PyErr_SetString(PyExc_RuntimeError, 34124 "Unexpected error in an Op's C code. " 34125 "No Python exception was set."); 34126 } 34127 goto __label_662;} 34128 } 34129 // This is a TypeError to be consistent with DEBUG_MODE 34130 // Note: DEBUG_MODE also tells the name of the container 34131 if (PyArray_TYPE((PyArrayObject*) py_V661) != NPY_FLOAT64) { 34132 PyErr_Format(PyExc_TypeError, 34133 "expected type_num %d (NPY_FLOAT64) got %d", 34134 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V661)); 34135 { 34136 __failure = 662; 34137 if (!PyErr_Occurred()) { 34138 PyErr_SetString(PyExc_RuntimeError, 34139 "Unexpected error in an Op's C code. " 34140 "No Python exception was set."); 34141 } 34142 goto __label_662;} 34143 } 34144 34145 V661 = (PyArrayObject*)(py_V661); 34146 Py_XINCREF(V661); 34147 34148 { 34149 34150 py_V663 = PyList_GET_ITEM(storage_V663, 0); 34151 {Py_XINCREF(py_V663);} 34152 34153 V663 = NULL; 34154 if (py_V663 == Py_None) { 34155 // We can either fail here or set V663 to NULL and rely on Ops 34156 // using tensors to handle the NULL case, but if they fail to do so 34157 // they'll end up with nasty segfaults, so this is public service. 34158 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 34159 { 34160 __failure = 664; 34161 if (!PyErr_Occurred()) { 34162 PyErr_SetString(PyExc_RuntimeError, 34163 "Unexpected error in an Op's C code. " 34164 "No Python exception was set."); 34165 } 34166 goto __label_664;} 34167 } 34168 if (!PyArray_Check(py_V663)) { 34169 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 34170 { 34171 __failure = 664; 34172 if (!PyErr_Occurred()) { 34173 PyErr_SetString(PyExc_RuntimeError, 34174 "Unexpected error in an Op's C code. " 34175 "No Python exception was set."); 34176 } 34177 goto __label_664;} 34178 } 34179 // We expect NPY_FLOAT64 34180 if (!PyArray_ISALIGNED((PyArrayObject*) py_V663)) { 34181 PyArrayObject * tmp = (PyArrayObject*) py_V663; 34182 PyErr_Format(PyExc_NotImplementedError, 34183 "expected an aligned array of type %ld " 34184 "(NPY_FLOAT64), got non-aligned array of type %ld" 34185 " with %ld dimensions, with 3 last dims " 34186 "%ld, %ld, %ld" 34187 " and 3 last strides %ld %ld, %ld.", 34188 (long int) NPY_FLOAT64, 34189 (long int) PyArray_TYPE((PyArrayObject*) py_V663), 34190 (long int) PyArray_NDIM(tmp), 34191 (long int) (PyArray_NDIM(tmp) >= 3 ? 34192 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 34193 (long int) (PyArray_NDIM(tmp) >= 2 ? 34194 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 34195 (long int) (PyArray_NDIM(tmp) >= 1 ? 34196 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 34197 (long int) (PyArray_NDIM(tmp) >= 3 ? 34198 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 34199 (long int) (PyArray_NDIM(tmp) >= 2 ? 34200 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 34201 (long int) (PyArray_NDIM(tmp) >= 1 ? 34202 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 34203 ); 34204 { 34205 __failure = 664; 34206 if (!PyErr_Occurred()) { 34207 PyErr_SetString(PyExc_RuntimeError, 34208 "Unexpected error in an Op's C code. " 34209 "No Python exception was set."); 34210 } 34211 goto __label_664;} 34212 } 34213 // This is a TypeError to be consistent with DEBUG_MODE 34214 // Note: DEBUG_MODE also tells the name of the container 34215 if (PyArray_TYPE((PyArrayObject*) py_V663) != NPY_FLOAT64) { 34216 PyErr_Format(PyExc_TypeError, 34217 "expected type_num %d (NPY_FLOAT64) got %d", 34218 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V663)); 34219 { 34220 __failure = 664; 34221 if (!PyErr_Occurred()) { 34222 PyErr_SetString(PyExc_RuntimeError, 34223 "Unexpected error in an Op's C code. " 34224 "No Python exception was set."); 34225 } 34226 goto __label_664;} 34227 } 34228 34229 V663 = (PyArrayObject*)(py_V663); 34230 Py_XINCREF(V663); 34231 34232 { 34233 34234 py_V665 = PyList_GET_ITEM(storage_V665, 0); 34235 {Py_XINCREF(py_V665);} 34236 34237 V665 = NULL; 34238 if (py_V665 == Py_None) { 34239 // We can either fail here or set V665 to NULL and rely on Ops 34240 // using tensors to handle the NULL case, but if they fail to do so 34241 // they'll end up with nasty segfaults, so this is public service. 34242 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 34243 { 34244 __failure = 666; 34245 if (!PyErr_Occurred()) { 34246 PyErr_SetString(PyExc_RuntimeError, 34247 "Unexpected error in an Op's C code. " 34248 "No Python exception was set."); 34249 } 34250 goto __label_666;} 34251 } 34252 if (!PyArray_Check(py_V665)) { 34253 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 34254 { 34255 __failure = 666; 34256 if (!PyErr_Occurred()) { 34257 PyErr_SetString(PyExc_RuntimeError, 34258 "Unexpected error in an Op's C code. " 34259 "No Python exception was set."); 34260 } 34261 goto __label_666;} 34262 } 34263 // We expect NPY_FLOAT64 34264 if (!PyArray_ISALIGNED((PyArrayObject*) py_V665)) { 34265 PyArrayObject * tmp = (PyArrayObject*) py_V665; 34266 PyErr_Format(PyExc_NotImplementedError, 34267 "expected an aligned array of type %ld " 34268 "(NPY_FLOAT64), got non-aligned array of type %ld" 34269 " with %ld dimensions, with 3 last dims " 34270 "%ld, %ld, %ld" 34271 " and 3 last strides %ld %ld, %ld.", 34272 (long int) NPY_FLOAT64, 34273 (long int) PyArray_TYPE((PyArrayObject*) py_V665), 34274 (long int) PyArray_NDIM(tmp), 34275 (long int) (PyArray_NDIM(tmp) >= 3 ? 34276 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 34277 (long int) (PyArray_NDIM(tmp) >= 2 ? 34278 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 34279 (long int) (PyArray_NDIM(tmp) >= 1 ? 34280 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 34281 (long int) (PyArray_NDIM(tmp) >= 3 ? 34282 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 34283 (long int) (PyArray_NDIM(tmp) >= 2 ? 34284 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 34285 (long int) (PyArray_NDIM(tmp) >= 1 ? 34286 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 34287 ); 34288 { 34289 __failure = 666; 34290 if (!PyErr_Occurred()) { 34291 PyErr_SetString(PyExc_RuntimeError, 34292 "Unexpected error in an Op's C code. " 34293 "No Python exception was set."); 34294 } 34295 goto __label_666;} 34296 } 34297 // This is a TypeError to be consistent with DEBUG_MODE 34298 // Note: DEBUG_MODE also tells the name of the container 34299 if (PyArray_TYPE((PyArrayObject*) py_V665) != NPY_FLOAT64) { 34300 PyErr_Format(PyExc_TypeError, 34301 "expected type_num %d (NPY_FLOAT64) got %d", 34302 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V665)); 34303 { 34304 __failure = 666; 34305 if (!PyErr_Occurred()) { 34306 PyErr_SetString(PyExc_RuntimeError, 34307 "Unexpected error in an Op's C code. " 34308 "No Python exception was set."); 34309 } 34310 goto __label_666;} 34311 } 34312 34313 V665 = (PyArrayObject*)(py_V665); 34314 Py_XINCREF(V665); 34315 34316 { 34317 34318 py_V667 = PyList_GET_ITEM(storage_V667, 0); 34319 {Py_XINCREF(py_V667);} 34320 34321 V667 = NULL; 34322 if (py_V667 == Py_None) { 34323 // We can either fail here or set V667 to NULL and rely on Ops 34324 // using tensors to handle the NULL case, but if they fail to do so 34325 // they'll end up with nasty segfaults, so this is public service. 34326 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 34327 { 34328 __failure = 668; 34329 if (!PyErr_Occurred()) { 34330 PyErr_SetString(PyExc_RuntimeError, 34331 "Unexpected error in an Op's C code. " 34332 "No Python exception was set."); 34333 } 34334 goto __label_668;} 34335 } 34336 if (!PyArray_Check(py_V667)) { 34337 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 34338 { 34339 __failure = 668; 34340 if (!PyErr_Occurred()) { 34341 PyErr_SetString(PyExc_RuntimeError, 34342 "Unexpected error in an Op's C code. " 34343 "No Python exception was set."); 34344 } 34345 goto __label_668;} 34346 } 34347 // We expect NPY_FLOAT64 34348 if (!PyArray_ISALIGNED((PyArrayObject*) py_V667)) { 34349 PyArrayObject * tmp = (PyArrayObject*) py_V667; 34350 PyErr_Format(PyExc_NotImplementedError, 34351 "expected an aligned array of type %ld " 34352 "(NPY_FLOAT64), got non-aligned array of type %ld" 34353 " with %ld dimensions, with 3 last dims " 34354 "%ld, %ld, %ld" 34355 " and 3 last strides %ld %ld, %ld.", 34356 (long int) NPY_FLOAT64, 34357 (long int) PyArray_TYPE((PyArrayObject*) py_V667), 34358 (long int) PyArray_NDIM(tmp), 34359 (long int) (PyArray_NDIM(tmp) >= 3 ? 34360 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 34361 (long int) (PyArray_NDIM(tmp) >= 2 ? 34362 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 34363 (long int) (PyArray_NDIM(tmp) >= 1 ? 34364 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 34365 (long int) (PyArray_NDIM(tmp) >= 3 ? 34366 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 34367 (long int) (PyArray_NDIM(tmp) >= 2 ? 34368 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 34369 (long int) (PyArray_NDIM(tmp) >= 1 ? 34370 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 34371 ); 34372 { 34373 __failure = 668; 34374 if (!PyErr_Occurred()) { 34375 PyErr_SetString(PyExc_RuntimeError, 34376 "Unexpected error in an Op's C code. " 34377 "No Python exception was set."); 34378 } 34379 goto __label_668;} 34380 } 34381 // This is a TypeError to be consistent with DEBUG_MODE 34382 // Note: DEBUG_MODE also tells the name of the container 34383 if (PyArray_TYPE((PyArrayObject*) py_V667) != NPY_FLOAT64) { 34384 PyErr_Format(PyExc_TypeError, 34385 "expected type_num %d (NPY_FLOAT64) got %d", 34386 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V667)); 34387 { 34388 __failure = 668; 34389 if (!PyErr_Occurred()) { 34390 PyErr_SetString(PyExc_RuntimeError, 34391 "Unexpected error in an Op's C code. " 34392 "No Python exception was set."); 34393 } 34394 goto __label_668;} 34395 } 34396 34397 V667 = (PyArrayObject*)(py_V667); 34398 Py_XINCREF(V667); 34399 34400 { 34401 34402 py_V669 = PyList_GET_ITEM(storage_V669, 0); 34403 {Py_XINCREF(py_V669);} 34404 34405 V669 = NULL; 34406 if (py_V669 == Py_None) { 34407 // We can either fail here or set V669 to NULL and rely on Ops 34408 // using tensors to handle the NULL case, but if they fail to do so 34409 // they'll end up with nasty segfaults, so this is public service. 34410 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 34411 { 34412 __failure = 670; 34413 if (!PyErr_Occurred()) { 34414 PyErr_SetString(PyExc_RuntimeError, 34415 "Unexpected error in an Op's C code. " 34416 "No Python exception was set."); 34417 } 34418 goto __label_670;} 34419 } 34420 if (!PyArray_Check(py_V669)) { 34421 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 34422 { 34423 __failure = 670; 34424 if (!PyErr_Occurred()) { 34425 PyErr_SetString(PyExc_RuntimeError, 34426 "Unexpected error in an Op's C code. " 34427 "No Python exception was set."); 34428 } 34429 goto __label_670;} 34430 } 34431 // We expect NPY_FLOAT64 34432 if (!PyArray_ISALIGNED((PyArrayObject*) py_V669)) { 34433 PyArrayObject * tmp = (PyArrayObject*) py_V669; 34434 PyErr_Format(PyExc_NotImplementedError, 34435 "expected an aligned array of type %ld " 34436 "(NPY_FLOAT64), got non-aligned array of type %ld" 34437 " with %ld dimensions, with 3 last dims " 34438 "%ld, %ld, %ld" 34439 " and 3 last strides %ld %ld, %ld.", 34440 (long int) NPY_FLOAT64, 34441 (long int) PyArray_TYPE((PyArrayObject*) py_V669), 34442 (long int) PyArray_NDIM(tmp), 34443 (long int) (PyArray_NDIM(tmp) >= 3 ? 34444 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 34445 (long int) (PyArray_NDIM(tmp) >= 2 ? 34446 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 34447 (long int) (PyArray_NDIM(tmp) >= 1 ? 34448 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 34449 (long int) (PyArray_NDIM(tmp) >= 3 ? 34450 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 34451 (long int) (PyArray_NDIM(tmp) >= 2 ? 34452 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 34453 (long int) (PyArray_NDIM(tmp) >= 1 ? 34454 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 34455 ); 34456 { 34457 __failure = 670; 34458 if (!PyErr_Occurred()) { 34459 PyErr_SetString(PyExc_RuntimeError, 34460 "Unexpected error in an Op's C code. " 34461 "No Python exception was set."); 34462 } 34463 goto __label_670;} 34464 } 34465 // This is a TypeError to be consistent with DEBUG_MODE 34466 // Note: DEBUG_MODE also tells the name of the container 34467 if (PyArray_TYPE((PyArrayObject*) py_V669) != NPY_FLOAT64) { 34468 PyErr_Format(PyExc_TypeError, 34469 "expected type_num %d (NPY_FLOAT64) got %d", 34470 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V669)); 34471 { 34472 __failure = 670; 34473 if (!PyErr_Occurred()) { 34474 PyErr_SetString(PyExc_RuntimeError, 34475 "Unexpected error in an Op's C code. " 34476 "No Python exception was set."); 34477 } 34478 goto __label_670;} 34479 } 34480 34481 V669 = (PyArrayObject*)(py_V669); 34482 Py_XINCREF(V669); 34483 34484 { 34485 34486 py_V671 = PyList_GET_ITEM(storage_V671, 0); 34487 {Py_XINCREF(py_V671);} 34488 34489 V671 = NULL; 34490 if (py_V671 == Py_None) { 34491 // We can either fail here or set V671 to NULL and rely on Ops 34492 // using tensors to handle the NULL case, but if they fail to do so 34493 // they'll end up with nasty segfaults, so this is public service. 34494 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 34495 { 34496 __failure = 672; 34497 if (!PyErr_Occurred()) { 34498 PyErr_SetString(PyExc_RuntimeError, 34499 "Unexpected error in an Op's C code. " 34500 "No Python exception was set."); 34501 } 34502 goto __label_672;} 34503 } 34504 if (!PyArray_Check(py_V671)) { 34505 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 34506 { 34507 __failure = 672; 34508 if (!PyErr_Occurred()) { 34509 PyErr_SetString(PyExc_RuntimeError, 34510 "Unexpected error in an Op's C code. " 34511 "No Python exception was set."); 34512 } 34513 goto __label_672;} 34514 } 34515 // We expect NPY_FLOAT64 34516 if (!PyArray_ISALIGNED((PyArrayObject*) py_V671)) { 34517 PyArrayObject * tmp = (PyArrayObject*) py_V671; 34518 PyErr_Format(PyExc_NotImplementedError, 34519 "expected an aligned array of type %ld " 34520 "(NPY_FLOAT64), got non-aligned array of type %ld" 34521 " with %ld dimensions, with 3 last dims " 34522 "%ld, %ld, %ld" 34523 " and 3 last strides %ld %ld, %ld.", 34524 (long int) NPY_FLOAT64, 34525 (long int) PyArray_TYPE((PyArrayObject*) py_V671), 34526 (long int) PyArray_NDIM(tmp), 34527 (long int) (PyArray_NDIM(tmp) >= 3 ? 34528 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 34529 (long int) (PyArray_NDIM(tmp) >= 2 ? 34530 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 34531 (long int) (PyArray_NDIM(tmp) >= 1 ? 34532 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 34533 (long int) (PyArray_NDIM(tmp) >= 3 ? 34534 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 34535 (long int) (PyArray_NDIM(tmp) >= 2 ? 34536 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 34537 (long int) (PyArray_NDIM(tmp) >= 1 ? 34538 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 34539 ); 34540 { 34541 __failure = 672; 34542 if (!PyErr_Occurred()) { 34543 PyErr_SetString(PyExc_RuntimeError, 34544 "Unexpected error in an Op's C code. " 34545 "No Python exception was set."); 34546 } 34547 goto __label_672;} 34548 } 34549 // This is a TypeError to be consistent with DEBUG_MODE 34550 // Note: DEBUG_MODE also tells the name of the container 34551 if (PyArray_TYPE((PyArrayObject*) py_V671) != NPY_FLOAT64) { 34552 PyErr_Format(PyExc_TypeError, 34553 "expected type_num %d (NPY_FLOAT64) got %d", 34554 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V671)); 34555 { 34556 __failure = 672; 34557 if (!PyErr_Occurred()) { 34558 PyErr_SetString(PyExc_RuntimeError, 34559 "Unexpected error in an Op's C code. " 34560 "No Python exception was set."); 34561 } 34562 goto __label_672;} 34563 } 34564 34565 V671 = (PyArrayObject*)(py_V671); 34566 Py_XINCREF(V671); 34567 34568 { 34569 34570 py_V673 = PyList_GET_ITEM(storage_V673, 0); 34571 {Py_XINCREF(py_V673);} 34572 34573 V673 = NULL; 34574 if (py_V673 == Py_None) { 34575 // We can either fail here or set V673 to NULL and rely on Ops 34576 // using tensors to handle the NULL case, but if they fail to do so 34577 // they'll end up with nasty segfaults, so this is public service. 34578 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 34579 { 34580 __failure = 674; 34581 if (!PyErr_Occurred()) { 34582 PyErr_SetString(PyExc_RuntimeError, 34583 "Unexpected error in an Op's C code. " 34584 "No Python exception was set."); 34585 } 34586 goto __label_674;} 34587 } 34588 if (!PyArray_Check(py_V673)) { 34589 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 34590 { 34591 __failure = 674; 34592 if (!PyErr_Occurred()) { 34593 PyErr_SetString(PyExc_RuntimeError, 34594 "Unexpected error in an Op's C code. " 34595 "No Python exception was set."); 34596 } 34597 goto __label_674;} 34598 } 34599 // We expect NPY_FLOAT64 34600 if (!PyArray_ISALIGNED((PyArrayObject*) py_V673)) { 34601 PyArrayObject * tmp = (PyArrayObject*) py_V673; 34602 PyErr_Format(PyExc_NotImplementedError, 34603 "expected an aligned array of type %ld " 34604 "(NPY_FLOAT64), got non-aligned array of type %ld" 34605 " with %ld dimensions, with 3 last dims " 34606 "%ld, %ld, %ld" 34607 " and 3 last strides %ld %ld, %ld.", 34608 (long int) NPY_FLOAT64, 34609 (long int) PyArray_TYPE((PyArrayObject*) py_V673), 34610 (long int) PyArray_NDIM(tmp), 34611 (long int) (PyArray_NDIM(tmp) >= 3 ? 34612 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 34613 (long int) (PyArray_NDIM(tmp) >= 2 ? 34614 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 34615 (long int) (PyArray_NDIM(tmp) >= 1 ? 34616 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 34617 (long int) (PyArray_NDIM(tmp) >= 3 ? 34618 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 34619 (long int) (PyArray_NDIM(tmp) >= 2 ? 34620 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 34621 (long int) (PyArray_NDIM(tmp) >= 1 ? 34622 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 34623 ); 34624 { 34625 __failure = 674; 34626 if (!PyErr_Occurred()) { 34627 PyErr_SetString(PyExc_RuntimeError, 34628 "Unexpected error in an Op's C code. " 34629 "No Python exception was set."); 34630 } 34631 goto __label_674;} 34632 } 34633 // This is a TypeError to be consistent with DEBUG_MODE 34634 // Note: DEBUG_MODE also tells the name of the container 34635 if (PyArray_TYPE((PyArrayObject*) py_V673) != NPY_FLOAT64) { 34636 PyErr_Format(PyExc_TypeError, 34637 "expected type_num %d (NPY_FLOAT64) got %d", 34638 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V673)); 34639 { 34640 __failure = 674; 34641 if (!PyErr_Occurred()) { 34642 PyErr_SetString(PyExc_RuntimeError, 34643 "Unexpected error in an Op's C code. " 34644 "No Python exception was set."); 34645 } 34646 goto __label_674;} 34647 } 34648 34649 V673 = (PyArrayObject*)(py_V673); 34650 Py_XINCREF(V673); 34651 34652 { 34653 34654 py_V675 = PyList_GET_ITEM(storage_V675, 0); 34655 {Py_XINCREF(py_V675);} 34656 34657 V675 = NULL; 34658 if (py_V675 == Py_None) { 34659 // We can either fail here or set V675 to NULL and rely on Ops 34660 // using tensors to handle the NULL case, but if they fail to do so 34661 // they'll end up with nasty segfaults, so this is public service. 34662 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 34663 { 34664 __failure = 676; 34665 if (!PyErr_Occurred()) { 34666 PyErr_SetString(PyExc_RuntimeError, 34667 "Unexpected error in an Op's C code. " 34668 "No Python exception was set."); 34669 } 34670 goto __label_676;} 34671 } 34672 if (!PyArray_Check(py_V675)) { 34673 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 34674 { 34675 __failure = 676; 34676 if (!PyErr_Occurred()) { 34677 PyErr_SetString(PyExc_RuntimeError, 34678 "Unexpected error in an Op's C code. " 34679 "No Python exception was set."); 34680 } 34681 goto __label_676;} 34682 } 34683 // We expect NPY_FLOAT64 34684 if (!PyArray_ISALIGNED((PyArrayObject*) py_V675)) { 34685 PyArrayObject * tmp = (PyArrayObject*) py_V675; 34686 PyErr_Format(PyExc_NotImplementedError, 34687 "expected an aligned array of type %ld " 34688 "(NPY_FLOAT64), got non-aligned array of type %ld" 34689 " with %ld dimensions, with 3 last dims " 34690 "%ld, %ld, %ld" 34691 " and 3 last strides %ld %ld, %ld.", 34692 (long int) NPY_FLOAT64, 34693 (long int) PyArray_TYPE((PyArrayObject*) py_V675), 34694 (long int) PyArray_NDIM(tmp), 34695 (long int) (PyArray_NDIM(tmp) >= 3 ? 34696 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 34697 (long int) (PyArray_NDIM(tmp) >= 2 ? 34698 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 34699 (long int) (PyArray_NDIM(tmp) >= 1 ? 34700 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 34701 (long int) (PyArray_NDIM(tmp) >= 3 ? 34702 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 34703 (long int) (PyArray_NDIM(tmp) >= 2 ? 34704 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 34705 (long int) (PyArray_NDIM(tmp) >= 1 ? 34706 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 34707 ); 34708 { 34709 __failure = 676; 34710 if (!PyErr_Occurred()) { 34711 PyErr_SetString(PyExc_RuntimeError, 34712 "Unexpected error in an Op's C code. " 34713 "No Python exception was set."); 34714 } 34715 goto __label_676;} 34716 } 34717 // This is a TypeError to be consistent with DEBUG_MODE 34718 // Note: DEBUG_MODE also tells the name of the container 34719 if (PyArray_TYPE((PyArrayObject*) py_V675) != NPY_FLOAT64) { 34720 PyErr_Format(PyExc_TypeError, 34721 "expected type_num %d (NPY_FLOAT64) got %d", 34722 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V675)); 34723 { 34724 __failure = 676; 34725 if (!PyErr_Occurred()) { 34726 PyErr_SetString(PyExc_RuntimeError, 34727 "Unexpected error in an Op's C code. " 34728 "No Python exception was set."); 34729 } 34730 goto __label_676;} 34731 } 34732 34733 V675 = (PyArrayObject*)(py_V675); 34734 Py_XINCREF(V675); 34735 34736 { 34737 34738 py_V677 = PyList_GET_ITEM(storage_V677, 0); 34739 {Py_XINCREF(py_V677);} 34740 34741 V677 = NULL; 34742 if (py_V677 == Py_None) { 34743 // We can either fail here or set V677 to NULL and rely on Ops 34744 // using tensors to handle the NULL case, but if they fail to do so 34745 // they'll end up with nasty segfaults, so this is public service. 34746 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 34747 { 34748 __failure = 678; 34749 if (!PyErr_Occurred()) { 34750 PyErr_SetString(PyExc_RuntimeError, 34751 "Unexpected error in an Op's C code. " 34752 "No Python exception was set."); 34753 } 34754 goto __label_678;} 34755 } 34756 if (!PyArray_Check(py_V677)) { 34757 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 34758 { 34759 __failure = 678; 34760 if (!PyErr_Occurred()) { 34761 PyErr_SetString(PyExc_RuntimeError, 34762 "Unexpected error in an Op's C code. " 34763 "No Python exception was set."); 34764 } 34765 goto __label_678;} 34766 } 34767 // We expect NPY_FLOAT64 34768 if (!PyArray_ISALIGNED((PyArrayObject*) py_V677)) { 34769 PyArrayObject * tmp = (PyArrayObject*) py_V677; 34770 PyErr_Format(PyExc_NotImplementedError, 34771 "expected an aligned array of type %ld " 34772 "(NPY_FLOAT64), got non-aligned array of type %ld" 34773 " with %ld dimensions, with 3 last dims " 34774 "%ld, %ld, %ld" 34775 " and 3 last strides %ld %ld, %ld.", 34776 (long int) NPY_FLOAT64, 34777 (long int) PyArray_TYPE((PyArrayObject*) py_V677), 34778 (long int) PyArray_NDIM(tmp), 34779 (long int) (PyArray_NDIM(tmp) >= 3 ? 34780 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 34781 (long int) (PyArray_NDIM(tmp) >= 2 ? 34782 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 34783 (long int) (PyArray_NDIM(tmp) >= 1 ? 34784 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 34785 (long int) (PyArray_NDIM(tmp) >= 3 ? 34786 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 34787 (long int) (PyArray_NDIM(tmp) >= 2 ? 34788 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 34789 (long int) (PyArray_NDIM(tmp) >= 1 ? 34790 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 34791 ); 34792 { 34793 __failure = 678; 34794 if (!PyErr_Occurred()) { 34795 PyErr_SetString(PyExc_RuntimeError, 34796 "Unexpected error in an Op's C code. " 34797 "No Python exception was set."); 34798 } 34799 goto __label_678;} 34800 } 34801 // This is a TypeError to be consistent with DEBUG_MODE 34802 // Note: DEBUG_MODE also tells the name of the container 34803 if (PyArray_TYPE((PyArrayObject*) py_V677) != NPY_FLOAT64) { 34804 PyErr_Format(PyExc_TypeError, 34805 "expected type_num %d (NPY_FLOAT64) got %d", 34806 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V677)); 34807 { 34808 __failure = 678; 34809 if (!PyErr_Occurred()) { 34810 PyErr_SetString(PyExc_RuntimeError, 34811 "Unexpected error in an Op's C code. " 34812 "No Python exception was set."); 34813 } 34814 goto __label_678;} 34815 } 34816 34817 V677 = (PyArrayObject*)(py_V677); 34818 Py_XINCREF(V677); 34819 34820 { 34821 34822 py_V679 = PyList_GET_ITEM(storage_V679, 0); 34823 {Py_XINCREF(py_V679);} 34824 34825 V679 = NULL; 34826 if (py_V679 == Py_None) { 34827 // We can either fail here or set V679 to NULL and rely on Ops 34828 // using tensors to handle the NULL case, but if they fail to do so 34829 // they'll end up with nasty segfaults, so this is public service. 34830 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 34831 { 34832 __failure = 680; 34833 if (!PyErr_Occurred()) { 34834 PyErr_SetString(PyExc_RuntimeError, 34835 "Unexpected error in an Op's C code. " 34836 "No Python exception was set."); 34837 } 34838 goto __label_680;} 34839 } 34840 if (!PyArray_Check(py_V679)) { 34841 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 34842 { 34843 __failure = 680; 34844 if (!PyErr_Occurred()) { 34845 PyErr_SetString(PyExc_RuntimeError, 34846 "Unexpected error in an Op's C code. " 34847 "No Python exception was set."); 34848 } 34849 goto __label_680;} 34850 } 34851 // We expect NPY_FLOAT64 34852 if (!PyArray_ISALIGNED((PyArrayObject*) py_V679)) { 34853 PyArrayObject * tmp = (PyArrayObject*) py_V679; 34854 PyErr_Format(PyExc_NotImplementedError, 34855 "expected an aligned array of type %ld " 34856 "(NPY_FLOAT64), got non-aligned array of type %ld" 34857 " with %ld dimensions, with 3 last dims " 34858 "%ld, %ld, %ld" 34859 " and 3 last strides %ld %ld, %ld.", 34860 (long int) NPY_FLOAT64, 34861 (long int) PyArray_TYPE((PyArrayObject*) py_V679), 34862 (long int) PyArray_NDIM(tmp), 34863 (long int) (PyArray_NDIM(tmp) >= 3 ? 34864 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 34865 (long int) (PyArray_NDIM(tmp) >= 2 ? 34866 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 34867 (long int) (PyArray_NDIM(tmp) >= 1 ? 34868 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 34869 (long int) (PyArray_NDIM(tmp) >= 3 ? 34870 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 34871 (long int) (PyArray_NDIM(tmp) >= 2 ? 34872 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 34873 (long int) (PyArray_NDIM(tmp) >= 1 ? 34874 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 34875 ); 34876 { 34877 __failure = 680; 34878 if (!PyErr_Occurred()) { 34879 PyErr_SetString(PyExc_RuntimeError, 34880 "Unexpected error in an Op's C code. " 34881 "No Python exception was set."); 34882 } 34883 goto __label_680;} 34884 } 34885 // This is a TypeError to be consistent with DEBUG_MODE 34886 // Note: DEBUG_MODE also tells the name of the container 34887 if (PyArray_TYPE((PyArrayObject*) py_V679) != NPY_FLOAT64) { 34888 PyErr_Format(PyExc_TypeError, 34889 "expected type_num %d (NPY_FLOAT64) got %d", 34890 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V679)); 34891 { 34892 __failure = 680; 34893 if (!PyErr_Occurred()) { 34894 PyErr_SetString(PyExc_RuntimeError, 34895 "Unexpected error in an Op's C code. " 34896 "No Python exception was set."); 34897 } 34898 goto __label_680;} 34899 } 34900 34901 V679 = (PyArrayObject*)(py_V679); 34902 Py_XINCREF(V679); 34903 34904 { 34905 34906 py_V681 = PyList_GET_ITEM(storage_V681, 0); 34907 {Py_XINCREF(py_V681);} 34908 34909 V681 = NULL; 34910 if (py_V681 == Py_None) { 34911 // We can either fail here or set V681 to NULL and rely on Ops 34912 // using tensors to handle the NULL case, but if they fail to do so 34913 // they'll end up with nasty segfaults, so this is public service. 34914 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 34915 { 34916 __failure = 682; 34917 if (!PyErr_Occurred()) { 34918 PyErr_SetString(PyExc_RuntimeError, 34919 "Unexpected error in an Op's C code. " 34920 "No Python exception was set."); 34921 } 34922 goto __label_682;} 34923 } 34924 if (!PyArray_Check(py_V681)) { 34925 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 34926 { 34927 __failure = 682; 34928 if (!PyErr_Occurred()) { 34929 PyErr_SetString(PyExc_RuntimeError, 34930 "Unexpected error in an Op's C code. " 34931 "No Python exception was set."); 34932 } 34933 goto __label_682;} 34934 } 34935 // We expect NPY_FLOAT64 34936 if (!PyArray_ISALIGNED((PyArrayObject*) py_V681)) { 34937 PyArrayObject * tmp = (PyArrayObject*) py_V681; 34938 PyErr_Format(PyExc_NotImplementedError, 34939 "expected an aligned array of type %ld " 34940 "(NPY_FLOAT64), got non-aligned array of type %ld" 34941 " with %ld dimensions, with 3 last dims " 34942 "%ld, %ld, %ld" 34943 " and 3 last strides %ld %ld, %ld.", 34944 (long int) NPY_FLOAT64, 34945 (long int) PyArray_TYPE((PyArrayObject*) py_V681), 34946 (long int) PyArray_NDIM(tmp), 34947 (long int) (PyArray_NDIM(tmp) >= 3 ? 34948 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 34949 (long int) (PyArray_NDIM(tmp) >= 2 ? 34950 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 34951 (long int) (PyArray_NDIM(tmp) >= 1 ? 34952 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 34953 (long int) (PyArray_NDIM(tmp) >= 3 ? 34954 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 34955 (long int) (PyArray_NDIM(tmp) >= 2 ? 34956 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 34957 (long int) (PyArray_NDIM(tmp) >= 1 ? 34958 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 34959 ); 34960 { 34961 __failure = 682; 34962 if (!PyErr_Occurred()) { 34963 PyErr_SetString(PyExc_RuntimeError, 34964 "Unexpected error in an Op's C code. " 34965 "No Python exception was set."); 34966 } 34967 goto __label_682;} 34968 } 34969 // This is a TypeError to be consistent with DEBUG_MODE 34970 // Note: DEBUG_MODE also tells the name of the container 34971 if (PyArray_TYPE((PyArrayObject*) py_V681) != NPY_FLOAT64) { 34972 PyErr_Format(PyExc_TypeError, 34973 "expected type_num %d (NPY_FLOAT64) got %d", 34974 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V681)); 34975 { 34976 __failure = 682; 34977 if (!PyErr_Occurred()) { 34978 PyErr_SetString(PyExc_RuntimeError, 34979 "Unexpected error in an Op's C code. " 34980 "No Python exception was set."); 34981 } 34982 goto __label_682;} 34983 } 34984 34985 V681 = (PyArrayObject*)(py_V681); 34986 Py_XINCREF(V681); 34987 34988 { 34989 34990 py_V683 = PyList_GET_ITEM(storage_V683, 0); 34991 {Py_XINCREF(py_V683);} 34992 34993 V683 = NULL; 34994 if (py_V683 == Py_None) { 34995 // We can either fail here or set V683 to NULL and rely on Ops 34996 // using tensors to handle the NULL case, but if they fail to do so 34997 // they'll end up with nasty segfaults, so this is public service. 34998 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 34999 { 35000 __failure = 684; 35001 if (!PyErr_Occurred()) { 35002 PyErr_SetString(PyExc_RuntimeError, 35003 "Unexpected error in an Op's C code. " 35004 "No Python exception was set."); 35005 } 35006 goto __label_684;} 35007 } 35008 if (!PyArray_Check(py_V683)) { 35009 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 35010 { 35011 __failure = 684; 35012 if (!PyErr_Occurred()) { 35013 PyErr_SetString(PyExc_RuntimeError, 35014 "Unexpected error in an Op's C code. " 35015 "No Python exception was set."); 35016 } 35017 goto __label_684;} 35018 } 35019 // We expect NPY_FLOAT64 35020 if (!PyArray_ISALIGNED((PyArrayObject*) py_V683)) { 35021 PyArrayObject * tmp = (PyArrayObject*) py_V683; 35022 PyErr_Format(PyExc_NotImplementedError, 35023 "expected an aligned array of type %ld " 35024 "(NPY_FLOAT64), got non-aligned array of type %ld" 35025 " with %ld dimensions, with 3 last dims " 35026 "%ld, %ld, %ld" 35027 " and 3 last strides %ld %ld, %ld.", 35028 (long int) NPY_FLOAT64, 35029 (long int) PyArray_TYPE((PyArrayObject*) py_V683), 35030 (long int) PyArray_NDIM(tmp), 35031 (long int) (PyArray_NDIM(tmp) >= 3 ? 35032 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 35033 (long int) (PyArray_NDIM(tmp) >= 2 ? 35034 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 35035 (long int) (PyArray_NDIM(tmp) >= 1 ? 35036 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 35037 (long int) (PyArray_NDIM(tmp) >= 3 ? 35038 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 35039 (long int) (PyArray_NDIM(tmp) >= 2 ? 35040 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 35041 (long int) (PyArray_NDIM(tmp) >= 1 ? 35042 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 35043 ); 35044 { 35045 __failure = 684; 35046 if (!PyErr_Occurred()) { 35047 PyErr_SetString(PyExc_RuntimeError, 35048 "Unexpected error in an Op's C code. " 35049 "No Python exception was set."); 35050 } 35051 goto __label_684;} 35052 } 35053 // This is a TypeError to be consistent with DEBUG_MODE 35054 // Note: DEBUG_MODE also tells the name of the container 35055 if (PyArray_TYPE((PyArrayObject*) py_V683) != NPY_FLOAT64) { 35056 PyErr_Format(PyExc_TypeError, 35057 "expected type_num %d (NPY_FLOAT64) got %d", 35058 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V683)); 35059 { 35060 __failure = 684; 35061 if (!PyErr_Occurred()) { 35062 PyErr_SetString(PyExc_RuntimeError, 35063 "Unexpected error in an Op's C code. " 35064 "No Python exception was set."); 35065 } 35066 goto __label_684;} 35067 } 35068 35069 V683 = (PyArrayObject*)(py_V683); 35070 Py_XINCREF(V683); 35071 35072 { 35073 35074 py_V685 = PyList_GET_ITEM(storage_V685, 0); 35075 {Py_XINCREF(py_V685);} 35076 35077 V685 = NULL; 35078 if (py_V685 == Py_None) { 35079 // We can either fail here or set V685 to NULL and rely on Ops 35080 // using tensors to handle the NULL case, but if they fail to do so 35081 // they'll end up with nasty segfaults, so this is public service. 35082 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 35083 { 35084 __failure = 686; 35085 if (!PyErr_Occurred()) { 35086 PyErr_SetString(PyExc_RuntimeError, 35087 "Unexpected error in an Op's C code. " 35088 "No Python exception was set."); 35089 } 35090 goto __label_686;} 35091 } 35092 if (!PyArray_Check(py_V685)) { 35093 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 35094 { 35095 __failure = 686; 35096 if (!PyErr_Occurred()) { 35097 PyErr_SetString(PyExc_RuntimeError, 35098 "Unexpected error in an Op's C code. " 35099 "No Python exception was set."); 35100 } 35101 goto __label_686;} 35102 } 35103 // We expect NPY_FLOAT64 35104 if (!PyArray_ISALIGNED((PyArrayObject*) py_V685)) { 35105 PyArrayObject * tmp = (PyArrayObject*) py_V685; 35106 PyErr_Format(PyExc_NotImplementedError, 35107 "expected an aligned array of type %ld " 35108 "(NPY_FLOAT64), got non-aligned array of type %ld" 35109 " with %ld dimensions, with 3 last dims " 35110 "%ld, %ld, %ld" 35111 " and 3 last strides %ld %ld, %ld.", 35112 (long int) NPY_FLOAT64, 35113 (long int) PyArray_TYPE((PyArrayObject*) py_V685), 35114 (long int) PyArray_NDIM(tmp), 35115 (long int) (PyArray_NDIM(tmp) >= 3 ? 35116 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 35117 (long int) (PyArray_NDIM(tmp) >= 2 ? 35118 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 35119 (long int) (PyArray_NDIM(tmp) >= 1 ? 35120 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 35121 (long int) (PyArray_NDIM(tmp) >= 3 ? 35122 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 35123 (long int) (PyArray_NDIM(tmp) >= 2 ? 35124 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 35125 (long int) (PyArray_NDIM(tmp) >= 1 ? 35126 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 35127 ); 35128 { 35129 __failure = 686; 35130 if (!PyErr_Occurred()) { 35131 PyErr_SetString(PyExc_RuntimeError, 35132 "Unexpected error in an Op's C code. " 35133 "No Python exception was set."); 35134 } 35135 goto __label_686;} 35136 } 35137 // This is a TypeError to be consistent with DEBUG_MODE 35138 // Note: DEBUG_MODE also tells the name of the container 35139 if (PyArray_TYPE((PyArrayObject*) py_V685) != NPY_FLOAT64) { 35140 PyErr_Format(PyExc_TypeError, 35141 "expected type_num %d (NPY_FLOAT64) got %d", 35142 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V685)); 35143 { 35144 __failure = 686; 35145 if (!PyErr_Occurred()) { 35146 PyErr_SetString(PyExc_RuntimeError, 35147 "Unexpected error in an Op's C code. " 35148 "No Python exception was set."); 35149 } 35150 goto __label_686;} 35151 } 35152 35153 V685 = (PyArrayObject*)(py_V685); 35154 Py_XINCREF(V685); 35155 35156 { 35157 35158 py_V687 = PyList_GET_ITEM(storage_V687, 0); 35159 {Py_XINCREF(py_V687);} 35160 35161 V687 = NULL; 35162 if (py_V687 == Py_None) { 35163 // We can either fail here or set V687 to NULL and rely on Ops 35164 // using tensors to handle the NULL case, but if they fail to do so 35165 // they'll end up with nasty segfaults, so this is public service. 35166 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 35167 { 35168 __failure = 688; 35169 if (!PyErr_Occurred()) { 35170 PyErr_SetString(PyExc_RuntimeError, 35171 "Unexpected error in an Op's C code. " 35172 "No Python exception was set."); 35173 } 35174 goto __label_688;} 35175 } 35176 if (!PyArray_Check(py_V687)) { 35177 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 35178 { 35179 __failure = 688; 35180 if (!PyErr_Occurred()) { 35181 PyErr_SetString(PyExc_RuntimeError, 35182 "Unexpected error in an Op's C code. " 35183 "No Python exception was set."); 35184 } 35185 goto __label_688;} 35186 } 35187 // We expect NPY_FLOAT64 35188 if (!PyArray_ISALIGNED((PyArrayObject*) py_V687)) { 35189 PyArrayObject * tmp = (PyArrayObject*) py_V687; 35190 PyErr_Format(PyExc_NotImplementedError, 35191 "expected an aligned array of type %ld " 35192 "(NPY_FLOAT64), got non-aligned array of type %ld" 35193 " with %ld dimensions, with 3 last dims " 35194 "%ld, %ld, %ld" 35195 " and 3 last strides %ld %ld, %ld.", 35196 (long int) NPY_FLOAT64, 35197 (long int) PyArray_TYPE((PyArrayObject*) py_V687), 35198 (long int) PyArray_NDIM(tmp), 35199 (long int) (PyArray_NDIM(tmp) >= 3 ? 35200 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 35201 (long int) (PyArray_NDIM(tmp) >= 2 ? 35202 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 35203 (long int) (PyArray_NDIM(tmp) >= 1 ? 35204 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 35205 (long int) (PyArray_NDIM(tmp) >= 3 ? 35206 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 35207 (long int) (PyArray_NDIM(tmp) >= 2 ? 35208 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 35209 (long int) (PyArray_NDIM(tmp) >= 1 ? 35210 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 35211 ); 35212 { 35213 __failure = 688; 35214 if (!PyErr_Occurred()) { 35215 PyErr_SetString(PyExc_RuntimeError, 35216 "Unexpected error in an Op's C code. " 35217 "No Python exception was set."); 35218 } 35219 goto __label_688;} 35220 } 35221 // This is a TypeError to be consistent with DEBUG_MODE 35222 // Note: DEBUG_MODE also tells the name of the container 35223 if (PyArray_TYPE((PyArrayObject*) py_V687) != NPY_FLOAT64) { 35224 PyErr_Format(PyExc_TypeError, 35225 "expected type_num %d (NPY_FLOAT64) got %d", 35226 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V687)); 35227 { 35228 __failure = 688; 35229 if (!PyErr_Occurred()) { 35230 PyErr_SetString(PyExc_RuntimeError, 35231 "Unexpected error in an Op's C code. " 35232 "No Python exception was set."); 35233 } 35234 goto __label_688;} 35235 } 35236 35237 V687 = (PyArrayObject*)(py_V687); 35238 Py_XINCREF(V687); 35239 35240 { 35241 35242 py_V689 = PyList_GET_ITEM(storage_V689, 0); 35243 {Py_XINCREF(py_V689);} 35244 35245 V689 = NULL; 35246 if (py_V689 == Py_None) { 35247 // We can either fail here or set V689 to NULL and rely on Ops 35248 // using tensors to handle the NULL case, but if they fail to do so 35249 // they'll end up with nasty segfaults, so this is public service. 35250 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 35251 { 35252 __failure = 690; 35253 if (!PyErr_Occurred()) { 35254 PyErr_SetString(PyExc_RuntimeError, 35255 "Unexpected error in an Op's C code. " 35256 "No Python exception was set."); 35257 } 35258 goto __label_690;} 35259 } 35260 if (!PyArray_Check(py_V689)) { 35261 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 35262 { 35263 __failure = 690; 35264 if (!PyErr_Occurred()) { 35265 PyErr_SetString(PyExc_RuntimeError, 35266 "Unexpected error in an Op's C code. " 35267 "No Python exception was set."); 35268 } 35269 goto __label_690;} 35270 } 35271 // We expect NPY_FLOAT64 35272 if (!PyArray_ISALIGNED((PyArrayObject*) py_V689)) { 35273 PyArrayObject * tmp = (PyArrayObject*) py_V689; 35274 PyErr_Format(PyExc_NotImplementedError, 35275 "expected an aligned array of type %ld " 35276 "(NPY_FLOAT64), got non-aligned array of type %ld" 35277 " with %ld dimensions, with 3 last dims " 35278 "%ld, %ld, %ld" 35279 " and 3 last strides %ld %ld, %ld.", 35280 (long int) NPY_FLOAT64, 35281 (long int) PyArray_TYPE((PyArrayObject*) py_V689), 35282 (long int) PyArray_NDIM(tmp), 35283 (long int) (PyArray_NDIM(tmp) >= 3 ? 35284 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 35285 (long int) (PyArray_NDIM(tmp) >= 2 ? 35286 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 35287 (long int) (PyArray_NDIM(tmp) >= 1 ? 35288 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 35289 (long int) (PyArray_NDIM(tmp) >= 3 ? 35290 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 35291 (long int) (PyArray_NDIM(tmp) >= 2 ? 35292 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 35293 (long int) (PyArray_NDIM(tmp) >= 1 ? 35294 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 35295 ); 35296 { 35297 __failure = 690; 35298 if (!PyErr_Occurred()) { 35299 PyErr_SetString(PyExc_RuntimeError, 35300 "Unexpected error in an Op's C code. " 35301 "No Python exception was set."); 35302 } 35303 goto __label_690;} 35304 } 35305 // This is a TypeError to be consistent with DEBUG_MODE 35306 // Note: DEBUG_MODE also tells the name of the container 35307 if (PyArray_TYPE((PyArrayObject*) py_V689) != NPY_FLOAT64) { 35308 PyErr_Format(PyExc_TypeError, 35309 "expected type_num %d (NPY_FLOAT64) got %d", 35310 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V689)); 35311 { 35312 __failure = 690; 35313 if (!PyErr_Occurred()) { 35314 PyErr_SetString(PyExc_RuntimeError, 35315 "Unexpected error in an Op's C code. " 35316 "No Python exception was set."); 35317 } 35318 goto __label_690;} 35319 } 35320 35321 V689 = (PyArrayObject*)(py_V689); 35322 Py_XINCREF(V689); 35323 35324 { 35325 35326 py_V691 = PyList_GET_ITEM(storage_V691, 0); 35327 {Py_XINCREF(py_V691);} 35328 35329 V691 = NULL; 35330 if (py_V691 == Py_None) { 35331 // We can either fail here or set V691 to NULL and rely on Ops 35332 // using tensors to handle the NULL case, but if they fail to do so 35333 // they'll end up with nasty segfaults, so this is public service. 35334 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 35335 { 35336 __failure = 692; 35337 if (!PyErr_Occurred()) { 35338 PyErr_SetString(PyExc_RuntimeError, 35339 "Unexpected error in an Op's C code. " 35340 "No Python exception was set."); 35341 } 35342 goto __label_692;} 35343 } 35344 if (!PyArray_Check(py_V691)) { 35345 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 35346 { 35347 __failure = 692; 35348 if (!PyErr_Occurred()) { 35349 PyErr_SetString(PyExc_RuntimeError, 35350 "Unexpected error in an Op's C code. " 35351 "No Python exception was set."); 35352 } 35353 goto __label_692;} 35354 } 35355 // We expect NPY_FLOAT64 35356 if (!PyArray_ISALIGNED((PyArrayObject*) py_V691)) { 35357 PyArrayObject * tmp = (PyArrayObject*) py_V691; 35358 PyErr_Format(PyExc_NotImplementedError, 35359 "expected an aligned array of type %ld " 35360 "(NPY_FLOAT64), got non-aligned array of type %ld" 35361 " with %ld dimensions, with 3 last dims " 35362 "%ld, %ld, %ld" 35363 " and 3 last strides %ld %ld, %ld.", 35364 (long int) NPY_FLOAT64, 35365 (long int) PyArray_TYPE((PyArrayObject*) py_V691), 35366 (long int) PyArray_NDIM(tmp), 35367 (long int) (PyArray_NDIM(tmp) >= 3 ? 35368 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 35369 (long int) (PyArray_NDIM(tmp) >= 2 ? 35370 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 35371 (long int) (PyArray_NDIM(tmp) >= 1 ? 35372 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 35373 (long int) (PyArray_NDIM(tmp) >= 3 ? 35374 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 35375 (long int) (PyArray_NDIM(tmp) >= 2 ? 35376 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 35377 (long int) (PyArray_NDIM(tmp) >= 1 ? 35378 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 35379 ); 35380 { 35381 __failure = 692; 35382 if (!PyErr_Occurred()) { 35383 PyErr_SetString(PyExc_RuntimeError, 35384 "Unexpected error in an Op's C code. " 35385 "No Python exception was set."); 35386 } 35387 goto __label_692;} 35388 } 35389 // This is a TypeError to be consistent with DEBUG_MODE 35390 // Note: DEBUG_MODE also tells the name of the container 35391 if (PyArray_TYPE((PyArrayObject*) py_V691) != NPY_FLOAT64) { 35392 PyErr_Format(PyExc_TypeError, 35393 "expected type_num %d (NPY_FLOAT64) got %d", 35394 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V691)); 35395 { 35396 __failure = 692; 35397 if (!PyErr_Occurred()) { 35398 PyErr_SetString(PyExc_RuntimeError, 35399 "Unexpected error in an Op's C code. " 35400 "No Python exception was set."); 35401 } 35402 goto __label_692;} 35403 } 35404 35405 V691 = (PyArrayObject*)(py_V691); 35406 Py_XINCREF(V691); 35407 35408 { 35409 35410 py_V693 = PyList_GET_ITEM(storage_V693, 0); 35411 {Py_XINCREF(py_V693);} 35412 35413 V693 = NULL; 35414 if (py_V693 == Py_None) { 35415 // We can either fail here or set V693 to NULL and rely on Ops 35416 // using tensors to handle the NULL case, but if they fail to do so 35417 // they'll end up with nasty segfaults, so this is public service. 35418 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 35419 { 35420 __failure = 694; 35421 if (!PyErr_Occurred()) { 35422 PyErr_SetString(PyExc_RuntimeError, 35423 "Unexpected error in an Op's C code. " 35424 "No Python exception was set."); 35425 } 35426 goto __label_694;} 35427 } 35428 if (!PyArray_Check(py_V693)) { 35429 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 35430 { 35431 __failure = 694; 35432 if (!PyErr_Occurred()) { 35433 PyErr_SetString(PyExc_RuntimeError, 35434 "Unexpected error in an Op's C code. " 35435 "No Python exception was set."); 35436 } 35437 goto __label_694;} 35438 } 35439 // We expect NPY_FLOAT64 35440 if (!PyArray_ISALIGNED((PyArrayObject*) py_V693)) { 35441 PyArrayObject * tmp = (PyArrayObject*) py_V693; 35442 PyErr_Format(PyExc_NotImplementedError, 35443 "expected an aligned array of type %ld " 35444 "(NPY_FLOAT64), got non-aligned array of type %ld" 35445 " with %ld dimensions, with 3 last dims " 35446 "%ld, %ld, %ld" 35447 " and 3 last strides %ld %ld, %ld.", 35448 (long int) NPY_FLOAT64, 35449 (long int) PyArray_TYPE((PyArrayObject*) py_V693), 35450 (long int) PyArray_NDIM(tmp), 35451 (long int) (PyArray_NDIM(tmp) >= 3 ? 35452 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 35453 (long int) (PyArray_NDIM(tmp) >= 2 ? 35454 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 35455 (long int) (PyArray_NDIM(tmp) >= 1 ? 35456 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 35457 (long int) (PyArray_NDIM(tmp) >= 3 ? 35458 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 35459 (long int) (PyArray_NDIM(tmp) >= 2 ? 35460 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 35461 (long int) (PyArray_NDIM(tmp) >= 1 ? 35462 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 35463 ); 35464 { 35465 __failure = 694; 35466 if (!PyErr_Occurred()) { 35467 PyErr_SetString(PyExc_RuntimeError, 35468 "Unexpected error in an Op's C code. " 35469 "No Python exception was set."); 35470 } 35471 goto __label_694;} 35472 } 35473 // This is a TypeError to be consistent with DEBUG_MODE 35474 // Note: DEBUG_MODE also tells the name of the container 35475 if (PyArray_TYPE((PyArrayObject*) py_V693) != NPY_FLOAT64) { 35476 PyErr_Format(PyExc_TypeError, 35477 "expected type_num %d (NPY_FLOAT64) got %d", 35478 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V693)); 35479 { 35480 __failure = 694; 35481 if (!PyErr_Occurred()) { 35482 PyErr_SetString(PyExc_RuntimeError, 35483 "Unexpected error in an Op's C code. " 35484 "No Python exception was set."); 35485 } 35486 goto __label_694;} 35487 } 35488 35489 V693 = (PyArrayObject*)(py_V693); 35490 Py_XINCREF(V693); 35491 35492 { 35493 35494 py_V695 = PyList_GET_ITEM(storage_V695, 0); 35495 {Py_XINCREF(py_V695);} 35496 35497 V695 = NULL; 35498 if (py_V695 == Py_None) { 35499 // We can either fail here or set V695 to NULL and rely on Ops 35500 // using tensors to handle the NULL case, but if they fail to do so 35501 // they'll end up with nasty segfaults, so this is public service. 35502 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 35503 { 35504 __failure = 696; 35505 if (!PyErr_Occurred()) { 35506 PyErr_SetString(PyExc_RuntimeError, 35507 "Unexpected error in an Op's C code. " 35508 "No Python exception was set."); 35509 } 35510 goto __label_696;} 35511 } 35512 if (!PyArray_Check(py_V695)) { 35513 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 35514 { 35515 __failure = 696; 35516 if (!PyErr_Occurred()) { 35517 PyErr_SetString(PyExc_RuntimeError, 35518 "Unexpected error in an Op's C code. " 35519 "No Python exception was set."); 35520 } 35521 goto __label_696;} 35522 } 35523 // We expect NPY_FLOAT64 35524 if (!PyArray_ISALIGNED((PyArrayObject*) py_V695)) { 35525 PyArrayObject * tmp = (PyArrayObject*) py_V695; 35526 PyErr_Format(PyExc_NotImplementedError, 35527 "expected an aligned array of type %ld " 35528 "(NPY_FLOAT64), got non-aligned array of type %ld" 35529 " with %ld dimensions, with 3 last dims " 35530 "%ld, %ld, %ld" 35531 " and 3 last strides %ld %ld, %ld.", 35532 (long int) NPY_FLOAT64, 35533 (long int) PyArray_TYPE((PyArrayObject*) py_V695), 35534 (long int) PyArray_NDIM(tmp), 35535 (long int) (PyArray_NDIM(tmp) >= 3 ? 35536 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 35537 (long int) (PyArray_NDIM(tmp) >= 2 ? 35538 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 35539 (long int) (PyArray_NDIM(tmp) >= 1 ? 35540 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 35541 (long int) (PyArray_NDIM(tmp) >= 3 ? 35542 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 35543 (long int) (PyArray_NDIM(tmp) >= 2 ? 35544 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 35545 (long int) (PyArray_NDIM(tmp) >= 1 ? 35546 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 35547 ); 35548 { 35549 __failure = 696; 35550 if (!PyErr_Occurred()) { 35551 PyErr_SetString(PyExc_RuntimeError, 35552 "Unexpected error in an Op's C code. " 35553 "No Python exception was set."); 35554 } 35555 goto __label_696;} 35556 } 35557 // This is a TypeError to be consistent with DEBUG_MODE 35558 // Note: DEBUG_MODE also tells the name of the container 35559 if (PyArray_TYPE((PyArrayObject*) py_V695) != NPY_FLOAT64) { 35560 PyErr_Format(PyExc_TypeError, 35561 "expected type_num %d (NPY_FLOAT64) got %d", 35562 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V695)); 35563 { 35564 __failure = 696; 35565 if (!PyErr_Occurred()) { 35566 PyErr_SetString(PyExc_RuntimeError, 35567 "Unexpected error in an Op's C code. " 35568 "No Python exception was set."); 35569 } 35570 goto __label_696;} 35571 } 35572 35573 V695 = (PyArrayObject*)(py_V695); 35574 Py_XINCREF(V695); 35575 35576 { 35577 35578 py_V697 = PyList_GET_ITEM(storage_V697, 0); 35579 {Py_XINCREF(py_V697);} 35580 35581 V697 = NULL; 35582 if (py_V697 == Py_None) { 35583 // We can either fail here or set V697 to NULL and rely on Ops 35584 // using tensors to handle the NULL case, but if they fail to do so 35585 // they'll end up with nasty segfaults, so this is public service. 35586 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 35587 { 35588 __failure = 698; 35589 if (!PyErr_Occurred()) { 35590 PyErr_SetString(PyExc_RuntimeError, 35591 "Unexpected error in an Op's C code. " 35592 "No Python exception was set."); 35593 } 35594 goto __label_698;} 35595 } 35596 if (!PyArray_Check(py_V697)) { 35597 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 35598 { 35599 __failure = 698; 35600 if (!PyErr_Occurred()) { 35601 PyErr_SetString(PyExc_RuntimeError, 35602 "Unexpected error in an Op's C code. " 35603 "No Python exception was set."); 35604 } 35605 goto __label_698;} 35606 } 35607 // We expect NPY_FLOAT64 35608 if (!PyArray_ISALIGNED((PyArrayObject*) py_V697)) { 35609 PyArrayObject * tmp = (PyArrayObject*) py_V697; 35610 PyErr_Format(PyExc_NotImplementedError, 35611 "expected an aligned array of type %ld " 35612 "(NPY_FLOAT64), got non-aligned array of type %ld" 35613 " with %ld dimensions, with 3 last dims " 35614 "%ld, %ld, %ld" 35615 " and 3 last strides %ld %ld, %ld.", 35616 (long int) NPY_FLOAT64, 35617 (long int) PyArray_TYPE((PyArrayObject*) py_V697), 35618 (long int) PyArray_NDIM(tmp), 35619 (long int) (PyArray_NDIM(tmp) >= 3 ? 35620 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 35621 (long int) (PyArray_NDIM(tmp) >= 2 ? 35622 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 35623 (long int) (PyArray_NDIM(tmp) >= 1 ? 35624 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 35625 (long int) (PyArray_NDIM(tmp) >= 3 ? 35626 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 35627 (long int) (PyArray_NDIM(tmp) >= 2 ? 35628 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 35629 (long int) (PyArray_NDIM(tmp) >= 1 ? 35630 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 35631 ); 35632 { 35633 __failure = 698; 35634 if (!PyErr_Occurred()) { 35635 PyErr_SetString(PyExc_RuntimeError, 35636 "Unexpected error in an Op's C code. " 35637 "No Python exception was set."); 35638 } 35639 goto __label_698;} 35640 } 35641 // This is a TypeError to be consistent with DEBUG_MODE 35642 // Note: DEBUG_MODE also tells the name of the container 35643 if (PyArray_TYPE((PyArrayObject*) py_V697) != NPY_FLOAT64) { 35644 PyErr_Format(PyExc_TypeError, 35645 "expected type_num %d (NPY_FLOAT64) got %d", 35646 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V697)); 35647 { 35648 __failure = 698; 35649 if (!PyErr_Occurred()) { 35650 PyErr_SetString(PyExc_RuntimeError, 35651 "Unexpected error in an Op's C code. " 35652 "No Python exception was set."); 35653 } 35654 goto __label_698;} 35655 } 35656 35657 V697 = (PyArrayObject*)(py_V697); 35658 Py_XINCREF(V697); 35659 35660 { 35661 35662 py_V699 = PyList_GET_ITEM(storage_V699, 0); 35663 {Py_XINCREF(py_V699);} 35664 35665 V699 = NULL; 35666 if (py_V699 == Py_None) { 35667 // We can either fail here or set V699 to NULL and rely on Ops 35668 // using tensors to handle the NULL case, but if they fail to do so 35669 // they'll end up with nasty segfaults, so this is public service. 35670 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 35671 { 35672 __failure = 700; 35673 if (!PyErr_Occurred()) { 35674 PyErr_SetString(PyExc_RuntimeError, 35675 "Unexpected error in an Op's C code. " 35676 "No Python exception was set."); 35677 } 35678 goto __label_700;} 35679 } 35680 if (!PyArray_Check(py_V699)) { 35681 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 35682 { 35683 __failure = 700; 35684 if (!PyErr_Occurred()) { 35685 PyErr_SetString(PyExc_RuntimeError, 35686 "Unexpected error in an Op's C code. " 35687 "No Python exception was set."); 35688 } 35689 goto __label_700;} 35690 } 35691 // We expect NPY_FLOAT64 35692 if (!PyArray_ISALIGNED((PyArrayObject*) py_V699)) { 35693 PyArrayObject * tmp = (PyArrayObject*) py_V699; 35694 PyErr_Format(PyExc_NotImplementedError, 35695 "expected an aligned array of type %ld " 35696 "(NPY_FLOAT64), got non-aligned array of type %ld" 35697 " with %ld dimensions, with 3 last dims " 35698 "%ld, %ld, %ld" 35699 " and 3 last strides %ld %ld, %ld.", 35700 (long int) NPY_FLOAT64, 35701 (long int) PyArray_TYPE((PyArrayObject*) py_V699), 35702 (long int) PyArray_NDIM(tmp), 35703 (long int) (PyArray_NDIM(tmp) >= 3 ? 35704 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 35705 (long int) (PyArray_NDIM(tmp) >= 2 ? 35706 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 35707 (long int) (PyArray_NDIM(tmp) >= 1 ? 35708 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 35709 (long int) (PyArray_NDIM(tmp) >= 3 ? 35710 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 35711 (long int) (PyArray_NDIM(tmp) >= 2 ? 35712 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 35713 (long int) (PyArray_NDIM(tmp) >= 1 ? 35714 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 35715 ); 35716 { 35717 __failure = 700; 35718 if (!PyErr_Occurred()) { 35719 PyErr_SetString(PyExc_RuntimeError, 35720 "Unexpected error in an Op's C code. " 35721 "No Python exception was set."); 35722 } 35723 goto __label_700;} 35724 } 35725 // This is a TypeError to be consistent with DEBUG_MODE 35726 // Note: DEBUG_MODE also tells the name of the container 35727 if (PyArray_TYPE((PyArrayObject*) py_V699) != NPY_FLOAT64) { 35728 PyErr_Format(PyExc_TypeError, 35729 "expected type_num %d (NPY_FLOAT64) got %d", 35730 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V699)); 35731 { 35732 __failure = 700; 35733 if (!PyErr_Occurred()) { 35734 PyErr_SetString(PyExc_RuntimeError, 35735 "Unexpected error in an Op's C code. " 35736 "No Python exception was set."); 35737 } 35738 goto __label_700;} 35739 } 35740 35741 V699 = (PyArrayObject*)(py_V699); 35742 Py_XINCREF(V699); 35743 35744 { 35745 35746 py_V701 = PyList_GET_ITEM(storage_V701, 0); 35747 {Py_XINCREF(py_V701);} 35748 35749 V701 = NULL; 35750 if (py_V701 == Py_None) { 35751 // We can either fail here or set V701 to NULL and rely on Ops 35752 // using tensors to handle the NULL case, but if they fail to do so 35753 // they'll end up with nasty segfaults, so this is public service. 35754 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 35755 { 35756 __failure = 702; 35757 if (!PyErr_Occurred()) { 35758 PyErr_SetString(PyExc_RuntimeError, 35759 "Unexpected error in an Op's C code. " 35760 "No Python exception was set."); 35761 } 35762 goto __label_702;} 35763 } 35764 if (!PyArray_Check(py_V701)) { 35765 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 35766 { 35767 __failure = 702; 35768 if (!PyErr_Occurred()) { 35769 PyErr_SetString(PyExc_RuntimeError, 35770 "Unexpected error in an Op's C code. " 35771 "No Python exception was set."); 35772 } 35773 goto __label_702;} 35774 } 35775 // We expect NPY_FLOAT64 35776 if (!PyArray_ISALIGNED((PyArrayObject*) py_V701)) { 35777 PyArrayObject * tmp = (PyArrayObject*) py_V701; 35778 PyErr_Format(PyExc_NotImplementedError, 35779 "expected an aligned array of type %ld " 35780 "(NPY_FLOAT64), got non-aligned array of type %ld" 35781 " with %ld dimensions, with 3 last dims " 35782 "%ld, %ld, %ld" 35783 " and 3 last strides %ld %ld, %ld.", 35784 (long int) NPY_FLOAT64, 35785 (long int) PyArray_TYPE((PyArrayObject*) py_V701), 35786 (long int) PyArray_NDIM(tmp), 35787 (long int) (PyArray_NDIM(tmp) >= 3 ? 35788 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 35789 (long int) (PyArray_NDIM(tmp) >= 2 ? 35790 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 35791 (long int) (PyArray_NDIM(tmp) >= 1 ? 35792 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 35793 (long int) (PyArray_NDIM(tmp) >= 3 ? 35794 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 35795 (long int) (PyArray_NDIM(tmp) >= 2 ? 35796 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 35797 (long int) (PyArray_NDIM(tmp) >= 1 ? 35798 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 35799 ); 35800 { 35801 __failure = 702; 35802 if (!PyErr_Occurred()) { 35803 PyErr_SetString(PyExc_RuntimeError, 35804 "Unexpected error in an Op's C code. " 35805 "No Python exception was set."); 35806 } 35807 goto __label_702;} 35808 } 35809 // This is a TypeError to be consistent with DEBUG_MODE 35810 // Note: DEBUG_MODE also tells the name of the container 35811 if (PyArray_TYPE((PyArrayObject*) py_V701) != NPY_FLOAT64) { 35812 PyErr_Format(PyExc_TypeError, 35813 "expected type_num %d (NPY_FLOAT64) got %d", 35814 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V701)); 35815 { 35816 __failure = 702; 35817 if (!PyErr_Occurred()) { 35818 PyErr_SetString(PyExc_RuntimeError, 35819 "Unexpected error in an Op's C code. " 35820 "No Python exception was set."); 35821 } 35822 goto __label_702;} 35823 } 35824 35825 V701 = (PyArrayObject*)(py_V701); 35826 Py_XINCREF(V701); 35827 35828 { 35829 35830 py_V703 = PyList_GET_ITEM(storage_V703, 0); 35831 {Py_XINCREF(py_V703);} 35832 35833 V703 = NULL; 35834 if (py_V703 == Py_None) { 35835 // We can either fail here or set V703 to NULL and rely on Ops 35836 // using tensors to handle the NULL case, but if they fail to do so 35837 // they'll end up with nasty segfaults, so this is public service. 35838 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 35839 { 35840 __failure = 704; 35841 if (!PyErr_Occurred()) { 35842 PyErr_SetString(PyExc_RuntimeError, 35843 "Unexpected error in an Op's C code. " 35844 "No Python exception was set."); 35845 } 35846 goto __label_704;} 35847 } 35848 if (!PyArray_Check(py_V703)) { 35849 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 35850 { 35851 __failure = 704; 35852 if (!PyErr_Occurred()) { 35853 PyErr_SetString(PyExc_RuntimeError, 35854 "Unexpected error in an Op's C code. " 35855 "No Python exception was set."); 35856 } 35857 goto __label_704;} 35858 } 35859 // We expect NPY_FLOAT64 35860 if (!PyArray_ISALIGNED((PyArrayObject*) py_V703)) { 35861 PyArrayObject * tmp = (PyArrayObject*) py_V703; 35862 PyErr_Format(PyExc_NotImplementedError, 35863 "expected an aligned array of type %ld " 35864 "(NPY_FLOAT64), got non-aligned array of type %ld" 35865 " with %ld dimensions, with 3 last dims " 35866 "%ld, %ld, %ld" 35867 " and 3 last strides %ld %ld, %ld.", 35868 (long int) NPY_FLOAT64, 35869 (long int) PyArray_TYPE((PyArrayObject*) py_V703), 35870 (long int) PyArray_NDIM(tmp), 35871 (long int) (PyArray_NDIM(tmp) >= 3 ? 35872 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 35873 (long int) (PyArray_NDIM(tmp) >= 2 ? 35874 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 35875 (long int) (PyArray_NDIM(tmp) >= 1 ? 35876 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 35877 (long int) (PyArray_NDIM(tmp) >= 3 ? 35878 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 35879 (long int) (PyArray_NDIM(tmp) >= 2 ? 35880 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 35881 (long int) (PyArray_NDIM(tmp) >= 1 ? 35882 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 35883 ); 35884 { 35885 __failure = 704; 35886 if (!PyErr_Occurred()) { 35887 PyErr_SetString(PyExc_RuntimeError, 35888 "Unexpected error in an Op's C code. " 35889 "No Python exception was set."); 35890 } 35891 goto __label_704;} 35892 } 35893 // This is a TypeError to be consistent with DEBUG_MODE 35894 // Note: DEBUG_MODE also tells the name of the container 35895 if (PyArray_TYPE((PyArrayObject*) py_V703) != NPY_FLOAT64) { 35896 PyErr_Format(PyExc_TypeError, 35897 "expected type_num %d (NPY_FLOAT64) got %d", 35898 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V703)); 35899 { 35900 __failure = 704; 35901 if (!PyErr_Occurred()) { 35902 PyErr_SetString(PyExc_RuntimeError, 35903 "Unexpected error in an Op's C code. " 35904 "No Python exception was set."); 35905 } 35906 goto __label_704;} 35907 } 35908 35909 V703 = (PyArrayObject*)(py_V703); 35910 Py_XINCREF(V703); 35911 35912 { 35913 35914 py_V705 = PyList_GET_ITEM(storage_V705, 0); 35915 {Py_XINCREF(py_V705);} 35916 35917 V705 = NULL; 35918 if (py_V705 == Py_None) { 35919 // We can either fail here or set V705 to NULL and rely on Ops 35920 // using tensors to handle the NULL case, but if they fail to do so 35921 // they'll end up with nasty segfaults, so this is public service. 35922 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 35923 { 35924 __failure = 706; 35925 if (!PyErr_Occurred()) { 35926 PyErr_SetString(PyExc_RuntimeError, 35927 "Unexpected error in an Op's C code. " 35928 "No Python exception was set."); 35929 } 35930 goto __label_706;} 35931 } 35932 if (!PyArray_Check(py_V705)) { 35933 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 35934 { 35935 __failure = 706; 35936 if (!PyErr_Occurred()) { 35937 PyErr_SetString(PyExc_RuntimeError, 35938 "Unexpected error in an Op's C code. " 35939 "No Python exception was set."); 35940 } 35941 goto __label_706;} 35942 } 35943 // We expect NPY_FLOAT64 35944 if (!PyArray_ISALIGNED((PyArrayObject*) py_V705)) { 35945 PyArrayObject * tmp = (PyArrayObject*) py_V705; 35946 PyErr_Format(PyExc_NotImplementedError, 35947 "expected an aligned array of type %ld " 35948 "(NPY_FLOAT64), got non-aligned array of type %ld" 35949 " with %ld dimensions, with 3 last dims " 35950 "%ld, %ld, %ld" 35951 " and 3 last strides %ld %ld, %ld.", 35952 (long int) NPY_FLOAT64, 35953 (long int) PyArray_TYPE((PyArrayObject*) py_V705), 35954 (long int) PyArray_NDIM(tmp), 35955 (long int) (PyArray_NDIM(tmp) >= 3 ? 35956 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 35957 (long int) (PyArray_NDIM(tmp) >= 2 ? 35958 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 35959 (long int) (PyArray_NDIM(tmp) >= 1 ? 35960 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 35961 (long int) (PyArray_NDIM(tmp) >= 3 ? 35962 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 35963 (long int) (PyArray_NDIM(tmp) >= 2 ? 35964 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 35965 (long int) (PyArray_NDIM(tmp) >= 1 ? 35966 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 35967 ); 35968 { 35969 __failure = 706; 35970 if (!PyErr_Occurred()) { 35971 PyErr_SetString(PyExc_RuntimeError, 35972 "Unexpected error in an Op's C code. " 35973 "No Python exception was set."); 35974 } 35975 goto __label_706;} 35976 } 35977 // This is a TypeError to be consistent with DEBUG_MODE 35978 // Note: DEBUG_MODE also tells the name of the container 35979 if (PyArray_TYPE((PyArrayObject*) py_V705) != NPY_FLOAT64) { 35980 PyErr_Format(PyExc_TypeError, 35981 "expected type_num %d (NPY_FLOAT64) got %d", 35982 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V705)); 35983 { 35984 __failure = 706; 35985 if (!PyErr_Occurred()) { 35986 PyErr_SetString(PyExc_RuntimeError, 35987 "Unexpected error in an Op's C code. " 35988 "No Python exception was set."); 35989 } 35990 goto __label_706;} 35991 } 35992 35993 V705 = (PyArrayObject*)(py_V705); 35994 Py_XINCREF(V705); 35995 35996 { 35997 35998 py_V707 = PyList_GET_ITEM(storage_V707, 0); 35999 {Py_XINCREF(py_V707);} 36000 36001 V707 = NULL; 36002 if (py_V707 == Py_None) { 36003 // We can either fail here or set V707 to NULL and rely on Ops 36004 // using tensors to handle the NULL case, but if they fail to do so 36005 // they'll end up with nasty segfaults, so this is public service. 36006 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 36007 { 36008 __failure = 708; 36009 if (!PyErr_Occurred()) { 36010 PyErr_SetString(PyExc_RuntimeError, 36011 "Unexpected error in an Op's C code. " 36012 "No Python exception was set."); 36013 } 36014 goto __label_708;} 36015 } 36016 if (!PyArray_Check(py_V707)) { 36017 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 36018 { 36019 __failure = 708; 36020 if (!PyErr_Occurred()) { 36021 PyErr_SetString(PyExc_RuntimeError, 36022 "Unexpected error in an Op's C code. " 36023 "No Python exception was set."); 36024 } 36025 goto __label_708;} 36026 } 36027 // We expect NPY_FLOAT64 36028 if (!PyArray_ISALIGNED((PyArrayObject*) py_V707)) { 36029 PyArrayObject * tmp = (PyArrayObject*) py_V707; 36030 PyErr_Format(PyExc_NotImplementedError, 36031 "expected an aligned array of type %ld " 36032 "(NPY_FLOAT64), got non-aligned array of type %ld" 36033 " with %ld dimensions, with 3 last dims " 36034 "%ld, %ld, %ld" 36035 " and 3 last strides %ld %ld, %ld.", 36036 (long int) NPY_FLOAT64, 36037 (long int) PyArray_TYPE((PyArrayObject*) py_V707), 36038 (long int) PyArray_NDIM(tmp), 36039 (long int) (PyArray_NDIM(tmp) >= 3 ? 36040 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 36041 (long int) (PyArray_NDIM(tmp) >= 2 ? 36042 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 36043 (long int) (PyArray_NDIM(tmp) >= 1 ? 36044 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 36045 (long int) (PyArray_NDIM(tmp) >= 3 ? 36046 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 36047 (long int) (PyArray_NDIM(tmp) >= 2 ? 36048 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 36049 (long int) (PyArray_NDIM(tmp) >= 1 ? 36050 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 36051 ); 36052 { 36053 __failure = 708; 36054 if (!PyErr_Occurred()) { 36055 PyErr_SetString(PyExc_RuntimeError, 36056 "Unexpected error in an Op's C code. " 36057 "No Python exception was set."); 36058 } 36059 goto __label_708;} 36060 } 36061 // This is a TypeError to be consistent with DEBUG_MODE 36062 // Note: DEBUG_MODE also tells the name of the container 36063 if (PyArray_TYPE((PyArrayObject*) py_V707) != NPY_FLOAT64) { 36064 PyErr_Format(PyExc_TypeError, 36065 "expected type_num %d (NPY_FLOAT64) got %d", 36066 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V707)); 36067 { 36068 __failure = 708; 36069 if (!PyErr_Occurred()) { 36070 PyErr_SetString(PyExc_RuntimeError, 36071 "Unexpected error in an Op's C code. " 36072 "No Python exception was set."); 36073 } 36074 goto __label_708;} 36075 } 36076 36077 V707 = (PyArrayObject*)(py_V707); 36078 Py_XINCREF(V707); 36079 36080 { 36081 36082 py_V709 = PyList_GET_ITEM(storage_V709, 0); 36083 {Py_XINCREF(py_V709);} 36084 36085 V709 = NULL; 36086 if (py_V709 == Py_None) { 36087 // We can either fail here or set V709 to NULL and rely on Ops 36088 // using tensors to handle the NULL case, but if they fail to do so 36089 // they'll end up with nasty segfaults, so this is public service. 36090 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 36091 { 36092 __failure = 710; 36093 if (!PyErr_Occurred()) { 36094 PyErr_SetString(PyExc_RuntimeError, 36095 "Unexpected error in an Op's C code. " 36096 "No Python exception was set."); 36097 } 36098 goto __label_710;} 36099 } 36100 if (!PyArray_Check(py_V709)) { 36101 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 36102 { 36103 __failure = 710; 36104 if (!PyErr_Occurred()) { 36105 PyErr_SetString(PyExc_RuntimeError, 36106 "Unexpected error in an Op's C code. " 36107 "No Python exception was set."); 36108 } 36109 goto __label_710;} 36110 } 36111 // We expect NPY_FLOAT64 36112 if (!PyArray_ISALIGNED((PyArrayObject*) py_V709)) { 36113 PyArrayObject * tmp = (PyArrayObject*) py_V709; 36114 PyErr_Format(PyExc_NotImplementedError, 36115 "expected an aligned array of type %ld " 36116 "(NPY_FLOAT64), got non-aligned array of type %ld" 36117 " with %ld dimensions, with 3 last dims " 36118 "%ld, %ld, %ld" 36119 " and 3 last strides %ld %ld, %ld.", 36120 (long int) NPY_FLOAT64, 36121 (long int) PyArray_TYPE((PyArrayObject*) py_V709), 36122 (long int) PyArray_NDIM(tmp), 36123 (long int) (PyArray_NDIM(tmp) >= 3 ? 36124 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 36125 (long int) (PyArray_NDIM(tmp) >= 2 ? 36126 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 36127 (long int) (PyArray_NDIM(tmp) >= 1 ? 36128 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 36129 (long int) (PyArray_NDIM(tmp) >= 3 ? 36130 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 36131 (long int) (PyArray_NDIM(tmp) >= 2 ? 36132 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 36133 (long int) (PyArray_NDIM(tmp) >= 1 ? 36134 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 36135 ); 36136 { 36137 __failure = 710; 36138 if (!PyErr_Occurred()) { 36139 PyErr_SetString(PyExc_RuntimeError, 36140 "Unexpected error in an Op's C code. " 36141 "No Python exception was set."); 36142 } 36143 goto __label_710;} 36144 } 36145 // This is a TypeError to be consistent with DEBUG_MODE 36146 // Note: DEBUG_MODE also tells the name of the container 36147 if (PyArray_TYPE((PyArrayObject*) py_V709) != NPY_FLOAT64) { 36148 PyErr_Format(PyExc_TypeError, 36149 "expected type_num %d (NPY_FLOAT64) got %d", 36150 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V709)); 36151 { 36152 __failure = 710; 36153 if (!PyErr_Occurred()) { 36154 PyErr_SetString(PyExc_RuntimeError, 36155 "Unexpected error in an Op's C code. " 36156 "No Python exception was set."); 36157 } 36158 goto __label_710;} 36159 } 36160 36161 V709 = (PyArrayObject*)(py_V709); 36162 Py_XINCREF(V709); 36163 36164 { 36165 36166 py_V711 = PyList_GET_ITEM(storage_V711, 0); 36167 {Py_XINCREF(py_V711);} 36168 36169 V711 = NULL; 36170 if (py_V711 == Py_None) { 36171 // We can either fail here or set V711 to NULL and rely on Ops 36172 // using tensors to handle the NULL case, but if they fail to do so 36173 // they'll end up with nasty segfaults, so this is public service. 36174 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 36175 { 36176 __failure = 712; 36177 if (!PyErr_Occurred()) { 36178 PyErr_SetString(PyExc_RuntimeError, 36179 "Unexpected error in an Op's C code. " 36180 "No Python exception was set."); 36181 } 36182 goto __label_712;} 36183 } 36184 if (!PyArray_Check(py_V711)) { 36185 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 36186 { 36187 __failure = 712; 36188 if (!PyErr_Occurred()) { 36189 PyErr_SetString(PyExc_RuntimeError, 36190 "Unexpected error in an Op's C code. " 36191 "No Python exception was set."); 36192 } 36193 goto __label_712;} 36194 } 36195 // We expect NPY_FLOAT64 36196 if (!PyArray_ISALIGNED((PyArrayObject*) py_V711)) { 36197 PyArrayObject * tmp = (PyArrayObject*) py_V711; 36198 PyErr_Format(PyExc_NotImplementedError, 36199 "expected an aligned array of type %ld " 36200 "(NPY_FLOAT64), got non-aligned array of type %ld" 36201 " with %ld dimensions, with 3 last dims " 36202 "%ld, %ld, %ld" 36203 " and 3 last strides %ld %ld, %ld.", 36204 (long int) NPY_FLOAT64, 36205 (long int) PyArray_TYPE((PyArrayObject*) py_V711), 36206 (long int) PyArray_NDIM(tmp), 36207 (long int) (PyArray_NDIM(tmp) >= 3 ? 36208 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 36209 (long int) (PyArray_NDIM(tmp) >= 2 ? 36210 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 36211 (long int) (PyArray_NDIM(tmp) >= 1 ? 36212 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 36213 (long int) (PyArray_NDIM(tmp) >= 3 ? 36214 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 36215 (long int) (PyArray_NDIM(tmp) >= 2 ? 36216 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 36217 (long int) (PyArray_NDIM(tmp) >= 1 ? 36218 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 36219 ); 36220 { 36221 __failure = 712; 36222 if (!PyErr_Occurred()) { 36223 PyErr_SetString(PyExc_RuntimeError, 36224 "Unexpected error in an Op's C code. " 36225 "No Python exception was set."); 36226 } 36227 goto __label_712;} 36228 } 36229 // This is a TypeError to be consistent with DEBUG_MODE 36230 // Note: DEBUG_MODE also tells the name of the container 36231 if (PyArray_TYPE((PyArrayObject*) py_V711) != NPY_FLOAT64) { 36232 PyErr_Format(PyExc_TypeError, 36233 "expected type_num %d (NPY_FLOAT64) got %d", 36234 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V711)); 36235 { 36236 __failure = 712; 36237 if (!PyErr_Occurred()) { 36238 PyErr_SetString(PyExc_RuntimeError, 36239 "Unexpected error in an Op's C code. " 36240 "No Python exception was set."); 36241 } 36242 goto __label_712;} 36243 } 36244 36245 V711 = (PyArrayObject*)(py_V711); 36246 Py_XINCREF(V711); 36247 36248 { 36249 36250 py_V713 = PyList_GET_ITEM(storage_V713, 0); 36251 {Py_XINCREF(py_V713);} 36252 36253 V713 = NULL; 36254 if (py_V713 == Py_None) { 36255 // We can either fail here or set V713 to NULL and rely on Ops 36256 // using tensors to handle the NULL case, but if they fail to do so 36257 // they'll end up with nasty segfaults, so this is public service. 36258 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 36259 { 36260 __failure = 714; 36261 if (!PyErr_Occurred()) { 36262 PyErr_SetString(PyExc_RuntimeError, 36263 "Unexpected error in an Op's C code. " 36264 "No Python exception was set."); 36265 } 36266 goto __label_714;} 36267 } 36268 if (!PyArray_Check(py_V713)) { 36269 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 36270 { 36271 __failure = 714; 36272 if (!PyErr_Occurred()) { 36273 PyErr_SetString(PyExc_RuntimeError, 36274 "Unexpected error in an Op's C code. " 36275 "No Python exception was set."); 36276 } 36277 goto __label_714;} 36278 } 36279 // We expect NPY_FLOAT64 36280 if (!PyArray_ISALIGNED((PyArrayObject*) py_V713)) { 36281 PyArrayObject * tmp = (PyArrayObject*) py_V713; 36282 PyErr_Format(PyExc_NotImplementedError, 36283 "expected an aligned array of type %ld " 36284 "(NPY_FLOAT64), got non-aligned array of type %ld" 36285 " with %ld dimensions, with 3 last dims " 36286 "%ld, %ld, %ld" 36287 " and 3 last strides %ld %ld, %ld.", 36288 (long int) NPY_FLOAT64, 36289 (long int) PyArray_TYPE((PyArrayObject*) py_V713), 36290 (long int) PyArray_NDIM(tmp), 36291 (long int) (PyArray_NDIM(tmp) >= 3 ? 36292 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 36293 (long int) (PyArray_NDIM(tmp) >= 2 ? 36294 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 36295 (long int) (PyArray_NDIM(tmp) >= 1 ? 36296 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 36297 (long int) (PyArray_NDIM(tmp) >= 3 ? 36298 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 36299 (long int) (PyArray_NDIM(tmp) >= 2 ? 36300 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 36301 (long int) (PyArray_NDIM(tmp) >= 1 ? 36302 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 36303 ); 36304 { 36305 __failure = 714; 36306 if (!PyErr_Occurred()) { 36307 PyErr_SetString(PyExc_RuntimeError, 36308 "Unexpected error in an Op's C code. " 36309 "No Python exception was set."); 36310 } 36311 goto __label_714;} 36312 } 36313 // This is a TypeError to be consistent with DEBUG_MODE 36314 // Note: DEBUG_MODE also tells the name of the container 36315 if (PyArray_TYPE((PyArrayObject*) py_V713) != NPY_FLOAT64) { 36316 PyErr_Format(PyExc_TypeError, 36317 "expected type_num %d (NPY_FLOAT64) got %d", 36318 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V713)); 36319 { 36320 __failure = 714; 36321 if (!PyErr_Occurred()) { 36322 PyErr_SetString(PyExc_RuntimeError, 36323 "Unexpected error in an Op's C code. " 36324 "No Python exception was set."); 36325 } 36326 goto __label_714;} 36327 } 36328 36329 V713 = (PyArrayObject*)(py_V713); 36330 Py_XINCREF(V713); 36331 36332 { 36333 36334 py_V715 = PyList_GET_ITEM(storage_V715, 0); 36335 {Py_XINCREF(py_V715);} 36336 36337 V715 = NULL; 36338 if (py_V715 == Py_None) { 36339 // We can either fail here or set V715 to NULL and rely on Ops 36340 // using tensors to handle the NULL case, but if they fail to do so 36341 // they'll end up with nasty segfaults, so this is public service. 36342 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 36343 { 36344 __failure = 716; 36345 if (!PyErr_Occurred()) { 36346 PyErr_SetString(PyExc_RuntimeError, 36347 "Unexpected error in an Op's C code. " 36348 "No Python exception was set."); 36349 } 36350 goto __label_716;} 36351 } 36352 if (!PyArray_Check(py_V715)) { 36353 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 36354 { 36355 __failure = 716; 36356 if (!PyErr_Occurred()) { 36357 PyErr_SetString(PyExc_RuntimeError, 36358 "Unexpected error in an Op's C code. " 36359 "No Python exception was set."); 36360 } 36361 goto __label_716;} 36362 } 36363 // We expect NPY_FLOAT64 36364 if (!PyArray_ISALIGNED((PyArrayObject*) py_V715)) { 36365 PyArrayObject * tmp = (PyArrayObject*) py_V715; 36366 PyErr_Format(PyExc_NotImplementedError, 36367 "expected an aligned array of type %ld " 36368 "(NPY_FLOAT64), got non-aligned array of type %ld" 36369 " with %ld dimensions, with 3 last dims " 36370 "%ld, %ld, %ld" 36371 " and 3 last strides %ld %ld, %ld.", 36372 (long int) NPY_FLOAT64, 36373 (long int) PyArray_TYPE((PyArrayObject*) py_V715), 36374 (long int) PyArray_NDIM(tmp), 36375 (long int) (PyArray_NDIM(tmp) >= 3 ? 36376 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 36377 (long int) (PyArray_NDIM(tmp) >= 2 ? 36378 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 36379 (long int) (PyArray_NDIM(tmp) >= 1 ? 36380 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 36381 (long int) (PyArray_NDIM(tmp) >= 3 ? 36382 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 36383 (long int) (PyArray_NDIM(tmp) >= 2 ? 36384 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 36385 (long int) (PyArray_NDIM(tmp) >= 1 ? 36386 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 36387 ); 36388 { 36389 __failure = 716; 36390 if (!PyErr_Occurred()) { 36391 PyErr_SetString(PyExc_RuntimeError, 36392 "Unexpected error in an Op's C code. " 36393 "No Python exception was set."); 36394 } 36395 goto __label_716;} 36396 } 36397 // This is a TypeError to be consistent with DEBUG_MODE 36398 // Note: DEBUG_MODE also tells the name of the container 36399 if (PyArray_TYPE((PyArrayObject*) py_V715) != NPY_FLOAT64) { 36400 PyErr_Format(PyExc_TypeError, 36401 "expected type_num %d (NPY_FLOAT64) got %d", 36402 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V715)); 36403 { 36404 __failure = 716; 36405 if (!PyErr_Occurred()) { 36406 PyErr_SetString(PyExc_RuntimeError, 36407 "Unexpected error in an Op's C code. " 36408 "No Python exception was set."); 36409 } 36410 goto __label_716;} 36411 } 36412 36413 V715 = (PyArrayObject*)(py_V715); 36414 Py_XINCREF(V715); 36415 36416 { 36417 36418 py_V717 = PyList_GET_ITEM(storage_V717, 0); 36419 {Py_XINCREF(py_V717);} 36420 36421 V717 = NULL; 36422 if (py_V717 == Py_None) { 36423 // We can either fail here or set V717 to NULL and rely on Ops 36424 // using tensors to handle the NULL case, but if they fail to do so 36425 // they'll end up with nasty segfaults, so this is public service. 36426 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 36427 { 36428 __failure = 718; 36429 if (!PyErr_Occurred()) { 36430 PyErr_SetString(PyExc_RuntimeError, 36431 "Unexpected error in an Op's C code. " 36432 "No Python exception was set."); 36433 } 36434 goto __label_718;} 36435 } 36436 if (!PyArray_Check(py_V717)) { 36437 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 36438 { 36439 __failure = 718; 36440 if (!PyErr_Occurred()) { 36441 PyErr_SetString(PyExc_RuntimeError, 36442 "Unexpected error in an Op's C code. " 36443 "No Python exception was set."); 36444 } 36445 goto __label_718;} 36446 } 36447 // We expect NPY_FLOAT64 36448 if (!PyArray_ISALIGNED((PyArrayObject*) py_V717)) { 36449 PyArrayObject * tmp = (PyArrayObject*) py_V717; 36450 PyErr_Format(PyExc_NotImplementedError, 36451 "expected an aligned array of type %ld " 36452 "(NPY_FLOAT64), got non-aligned array of type %ld" 36453 " with %ld dimensions, with 3 last dims " 36454 "%ld, %ld, %ld" 36455 " and 3 last strides %ld %ld, %ld.", 36456 (long int) NPY_FLOAT64, 36457 (long int) PyArray_TYPE((PyArrayObject*) py_V717), 36458 (long int) PyArray_NDIM(tmp), 36459 (long int) (PyArray_NDIM(tmp) >= 3 ? 36460 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 36461 (long int) (PyArray_NDIM(tmp) >= 2 ? 36462 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 36463 (long int) (PyArray_NDIM(tmp) >= 1 ? 36464 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 36465 (long int) (PyArray_NDIM(tmp) >= 3 ? 36466 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 36467 (long int) (PyArray_NDIM(tmp) >= 2 ? 36468 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 36469 (long int) (PyArray_NDIM(tmp) >= 1 ? 36470 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 36471 ); 36472 { 36473 __failure = 718; 36474 if (!PyErr_Occurred()) { 36475 PyErr_SetString(PyExc_RuntimeError, 36476 "Unexpected error in an Op's C code. " 36477 "No Python exception was set."); 36478 } 36479 goto __label_718;} 36480 } 36481 // This is a TypeError to be consistent with DEBUG_MODE 36482 // Note: DEBUG_MODE also tells the name of the container 36483 if (PyArray_TYPE((PyArrayObject*) py_V717) != NPY_FLOAT64) { 36484 PyErr_Format(PyExc_TypeError, 36485 "expected type_num %d (NPY_FLOAT64) got %d", 36486 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V717)); 36487 { 36488 __failure = 718; 36489 if (!PyErr_Occurred()) { 36490 PyErr_SetString(PyExc_RuntimeError, 36491 "Unexpected error in an Op's C code. " 36492 "No Python exception was set."); 36493 } 36494 goto __label_718;} 36495 } 36496 36497 V717 = (PyArrayObject*)(py_V717); 36498 Py_XINCREF(V717); 36499 36500 { 36501 36502 py_V719 = PyList_GET_ITEM(storage_V719, 0); 36503 {Py_XINCREF(py_V719);} 36504 36505 V719 = NULL; 36506 if (py_V719 == Py_None) { 36507 // We can either fail here or set V719 to NULL and rely on Ops 36508 // using tensors to handle the NULL case, but if they fail to do so 36509 // they'll end up with nasty segfaults, so this is public service. 36510 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 36511 { 36512 __failure = 720; 36513 if (!PyErr_Occurred()) { 36514 PyErr_SetString(PyExc_RuntimeError, 36515 "Unexpected error in an Op's C code. " 36516 "No Python exception was set."); 36517 } 36518 goto __label_720;} 36519 } 36520 if (!PyArray_Check(py_V719)) { 36521 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 36522 { 36523 __failure = 720; 36524 if (!PyErr_Occurred()) { 36525 PyErr_SetString(PyExc_RuntimeError, 36526 "Unexpected error in an Op's C code. " 36527 "No Python exception was set."); 36528 } 36529 goto __label_720;} 36530 } 36531 // We expect NPY_FLOAT64 36532 if (!PyArray_ISALIGNED((PyArrayObject*) py_V719)) { 36533 PyArrayObject * tmp = (PyArrayObject*) py_V719; 36534 PyErr_Format(PyExc_NotImplementedError, 36535 "expected an aligned array of type %ld " 36536 "(NPY_FLOAT64), got non-aligned array of type %ld" 36537 " with %ld dimensions, with 3 last dims " 36538 "%ld, %ld, %ld" 36539 " and 3 last strides %ld %ld, %ld.", 36540 (long int) NPY_FLOAT64, 36541 (long int) PyArray_TYPE((PyArrayObject*) py_V719), 36542 (long int) PyArray_NDIM(tmp), 36543 (long int) (PyArray_NDIM(tmp) >= 3 ? 36544 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 36545 (long int) (PyArray_NDIM(tmp) >= 2 ? 36546 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 36547 (long int) (PyArray_NDIM(tmp) >= 1 ? 36548 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 36549 (long int) (PyArray_NDIM(tmp) >= 3 ? 36550 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 36551 (long int) (PyArray_NDIM(tmp) >= 2 ? 36552 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 36553 (long int) (PyArray_NDIM(tmp) >= 1 ? 36554 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 36555 ); 36556 { 36557 __failure = 720; 36558 if (!PyErr_Occurred()) { 36559 PyErr_SetString(PyExc_RuntimeError, 36560 "Unexpected error in an Op's C code. " 36561 "No Python exception was set."); 36562 } 36563 goto __label_720;} 36564 } 36565 // This is a TypeError to be consistent with DEBUG_MODE 36566 // Note: DEBUG_MODE also tells the name of the container 36567 if (PyArray_TYPE((PyArrayObject*) py_V719) != NPY_FLOAT64) { 36568 PyErr_Format(PyExc_TypeError, 36569 "expected type_num %d (NPY_FLOAT64) got %d", 36570 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V719)); 36571 { 36572 __failure = 720; 36573 if (!PyErr_Occurred()) { 36574 PyErr_SetString(PyExc_RuntimeError, 36575 "Unexpected error in an Op's C code. " 36576 "No Python exception was set."); 36577 } 36578 goto __label_720;} 36579 } 36580 36581 V719 = (PyArrayObject*)(py_V719); 36582 Py_XINCREF(V719); 36583 36584 { 36585 36586 py_V721 = PyList_GET_ITEM(storage_V721, 0); 36587 {Py_XINCREF(py_V721);} 36588 36589 V721 = NULL; 36590 if (py_V721 == Py_None) { 36591 // We can either fail here or set V721 to NULL and rely on Ops 36592 // using tensors to handle the NULL case, but if they fail to do so 36593 // they'll end up with nasty segfaults, so this is public service. 36594 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 36595 { 36596 __failure = 722; 36597 if (!PyErr_Occurred()) { 36598 PyErr_SetString(PyExc_RuntimeError, 36599 "Unexpected error in an Op's C code. " 36600 "No Python exception was set."); 36601 } 36602 goto __label_722;} 36603 } 36604 if (!PyArray_Check(py_V721)) { 36605 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 36606 { 36607 __failure = 722; 36608 if (!PyErr_Occurred()) { 36609 PyErr_SetString(PyExc_RuntimeError, 36610 "Unexpected error in an Op's C code. " 36611 "No Python exception was set."); 36612 } 36613 goto __label_722;} 36614 } 36615 // We expect NPY_FLOAT64 36616 if (!PyArray_ISALIGNED((PyArrayObject*) py_V721)) { 36617 PyArrayObject * tmp = (PyArrayObject*) py_V721; 36618 PyErr_Format(PyExc_NotImplementedError, 36619 "expected an aligned array of type %ld " 36620 "(NPY_FLOAT64), got non-aligned array of type %ld" 36621 " with %ld dimensions, with 3 last dims " 36622 "%ld, %ld, %ld" 36623 " and 3 last strides %ld %ld, %ld.", 36624 (long int) NPY_FLOAT64, 36625 (long int) PyArray_TYPE((PyArrayObject*) py_V721), 36626 (long int) PyArray_NDIM(tmp), 36627 (long int) (PyArray_NDIM(tmp) >= 3 ? 36628 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 36629 (long int) (PyArray_NDIM(tmp) >= 2 ? 36630 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 36631 (long int) (PyArray_NDIM(tmp) >= 1 ? 36632 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 36633 (long int) (PyArray_NDIM(tmp) >= 3 ? 36634 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 36635 (long int) (PyArray_NDIM(tmp) >= 2 ? 36636 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 36637 (long int) (PyArray_NDIM(tmp) >= 1 ? 36638 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 36639 ); 36640 { 36641 __failure = 722; 36642 if (!PyErr_Occurred()) { 36643 PyErr_SetString(PyExc_RuntimeError, 36644 "Unexpected error in an Op's C code. " 36645 "No Python exception was set."); 36646 } 36647 goto __label_722;} 36648 } 36649 // This is a TypeError to be consistent with DEBUG_MODE 36650 // Note: DEBUG_MODE also tells the name of the container 36651 if (PyArray_TYPE((PyArrayObject*) py_V721) != NPY_FLOAT64) { 36652 PyErr_Format(PyExc_TypeError, 36653 "expected type_num %d (NPY_FLOAT64) got %d", 36654 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V721)); 36655 { 36656 __failure = 722; 36657 if (!PyErr_Occurred()) { 36658 PyErr_SetString(PyExc_RuntimeError, 36659 "Unexpected error in an Op's C code. " 36660 "No Python exception was set."); 36661 } 36662 goto __label_722;} 36663 } 36664 36665 V721 = (PyArrayObject*)(py_V721); 36666 Py_XINCREF(V721); 36667 36668 { 36669 36670 py_V723 = PyList_GET_ITEM(storage_V723, 0); 36671 {Py_XINCREF(py_V723);} 36672 36673 V723 = NULL; 36674 if (py_V723 == Py_None) { 36675 // We can either fail here or set V723 to NULL and rely on Ops 36676 // using tensors to handle the NULL case, but if they fail to do so 36677 // they'll end up with nasty segfaults, so this is public service. 36678 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 36679 { 36680 __failure = 724; 36681 if (!PyErr_Occurred()) { 36682 PyErr_SetString(PyExc_RuntimeError, 36683 "Unexpected error in an Op's C code. " 36684 "No Python exception was set."); 36685 } 36686 goto __label_724;} 36687 } 36688 if (!PyArray_Check(py_V723)) { 36689 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 36690 { 36691 __failure = 724; 36692 if (!PyErr_Occurred()) { 36693 PyErr_SetString(PyExc_RuntimeError, 36694 "Unexpected error in an Op's C code. " 36695 "No Python exception was set."); 36696 } 36697 goto __label_724;} 36698 } 36699 // We expect NPY_FLOAT64 36700 if (!PyArray_ISALIGNED((PyArrayObject*) py_V723)) { 36701 PyArrayObject * tmp = (PyArrayObject*) py_V723; 36702 PyErr_Format(PyExc_NotImplementedError, 36703 "expected an aligned array of type %ld " 36704 "(NPY_FLOAT64), got non-aligned array of type %ld" 36705 " with %ld dimensions, with 3 last dims " 36706 "%ld, %ld, %ld" 36707 " and 3 last strides %ld %ld, %ld.", 36708 (long int) NPY_FLOAT64, 36709 (long int) PyArray_TYPE((PyArrayObject*) py_V723),
=============================== /Users/fonnescj/.theano/compiledir_Darwin-16.1.0-x86_64-i386-64bit-i386-3.5.2-64/tmpw1bwxf2l/mod.cpp:27441:32: fatal error: bracket nesting level exceeded maximum of 256 if (!PyErr_Occurred()) { ^ /Users/fonnescj/.theano/compiledir_Darwin-16.1.0-x86_64-i386-64bit-i386-3.5.2-64/tmpw1bwxf2l/mod.cpp:27441:32: note: use -fbracket-depth=N to increase maximum nesting level 1 error generated.
36710 (long int) PyArray_NDIM(tmp), 36711 (long int) (PyArray_NDIM(tmp) >= 3 ? 36712 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 36713 (long int) (PyArray_NDIM(tmp) >= 2 ? 36714 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 36715 (long int) (PyArray_NDIM(tmp) >= 1 ? 36716 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 36717 (long int) (PyArray_NDIM(tmp) >= 3 ? 36718 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 36719 (long int) (PyArray_NDIM(tmp) >= 2 ? 36720 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 36721 (long int) (PyArray_NDIM(tmp) >= 1 ? 36722 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 36723 ); 36724 { 36725 __failure = 724; 36726 if (!PyErr_Occurred()) { 36727 PyErr_SetString(PyExc_RuntimeError, 36728 "Unexpected error in an Op's C code. " 36729 "No Python exception was set."); 36730 } 36731 goto __label_724;} 36732 } 36733 // This is a TypeError to be consistent with DEBUG_MODE 36734 // Note: DEBUG_MODE also tells the name of the container 36735 if (PyArray_TYPE((PyArrayObject*) py_V723) != NPY_FLOAT64) { 36736 PyErr_Format(PyExc_TypeError, 36737 "expected type_num %d (NPY_FLOAT64) got %d", 36738 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V723)); 36739 { 36740 __failure = 724; 36741 if (!PyErr_Occurred()) { 36742 PyErr_SetString(PyExc_RuntimeError, 36743 "Unexpected error in an Op's C code. " 36744 "No Python exception was set."); 36745 } 36746 goto __label_724;} 36747 } 36748 36749 V723 = (PyArrayObject*)(py_V723); 36750 Py_XINCREF(V723); 36751 36752 { 36753 36754 py_V725 = PyList_GET_ITEM(storage_V725, 0); 36755 {Py_XINCREF(py_V725);} 36756 36757 V725 = NULL; 36758 if (py_V725 == Py_None) { 36759 // We can either fail here or set V725 to NULL and rely on Ops 36760 // using tensors to handle the NULL case, but if they fail to do so 36761 // they'll end up with nasty segfaults, so this is public service. 36762 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 36763 { 36764 __failure = 726; 36765 if (!PyErr_Occurred()) { 36766 PyErr_SetString(PyExc_RuntimeError, 36767 "Unexpected error in an Op's C code. " 36768 "No Python exception was set."); 36769 } 36770 goto __label_726;} 36771 } 36772 if (!PyArray_Check(py_V725)) { 36773 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 36774 { 36775 __failure = 726; 36776 if (!PyErr_Occurred()) { 36777 PyErr_SetString(PyExc_RuntimeError, 36778 "Unexpected error in an Op's C code. " 36779 "No Python exception was set."); 36780 } 36781 goto __label_726;} 36782 } 36783 // We expect NPY_FLOAT64 36784 if (!PyArray_ISALIGNED((PyArrayObject*) py_V725)) { 36785 PyArrayObject * tmp = (PyArrayObject*) py_V725; 36786 PyErr_Format(PyExc_NotImplementedError, 36787 "expected an aligned array of type %ld " 36788 "(NPY_FLOAT64), got non-aligned array of type %ld" 36789 " with %ld dimensions, with 3 last dims " 36790 "%ld, %ld, %ld" 36791 " and 3 last strides %ld %ld, %ld.", 36792 (long int) NPY_FLOAT64, 36793 (long int) PyArray_TYPE((PyArrayObject*) py_V725), 36794 (long int) PyArray_NDIM(tmp), 36795 (long int) (PyArray_NDIM(tmp) >= 3 ? 36796 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 36797 (long int) (PyArray_NDIM(tmp) >= 2 ? 36798 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 36799 (long int) (PyArray_NDIM(tmp) >= 1 ? 36800 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 36801 (long int) (PyArray_NDIM(tmp) >= 3 ? 36802 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 36803 (long int) (PyArray_NDIM(tmp) >= 2 ? 36804 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 36805 (long int) (PyArray_NDIM(tmp) >= 1 ? 36806 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 36807 ); 36808 { 36809 __failure = 726; 36810 if (!PyErr_Occurred()) { 36811 PyErr_SetString(PyExc_RuntimeError, 36812 "Unexpected error in an Op's C code. " 36813 "No Python exception was set."); 36814 } 36815 goto __label_726;} 36816 } 36817 // This is a TypeError to be consistent with DEBUG_MODE 36818 // Note: DEBUG_MODE also tells the name of the container 36819 if (PyArray_TYPE((PyArrayObject*) py_V725) != NPY_FLOAT64) { 36820 PyErr_Format(PyExc_TypeError, 36821 "expected type_num %d (NPY_FLOAT64) got %d", 36822 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V725)); 36823 { 36824 __failure = 726; 36825 if (!PyErr_Occurred()) { 36826 PyErr_SetString(PyExc_RuntimeError, 36827 "Unexpected error in an Op's C code. " 36828 "No Python exception was set."); 36829 } 36830 goto __label_726;} 36831 } 36832 36833 V725 = (PyArrayObject*)(py_V725); 36834 Py_XINCREF(V725); 36835 36836 { 36837 36838 py_V727 = PyList_GET_ITEM(storage_V727, 0); 36839 {Py_XINCREF(py_V727);} 36840 36841 V727 = NULL; 36842 if (py_V727 == Py_None) { 36843 // We can either fail here or set V727 to NULL and rely on Ops 36844 // using tensors to handle the NULL case, but if they fail to do so 36845 // they'll end up with nasty segfaults, so this is public service. 36846 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 36847 { 36848 __failure = 728; 36849 if (!PyErr_Occurred()) { 36850 PyErr_SetString(PyExc_RuntimeError, 36851 "Unexpected error in an Op's C code. " 36852 "No Python exception was set."); 36853 } 36854 goto __label_728;} 36855 } 36856 if (!PyArray_Check(py_V727)) { 36857 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 36858 { 36859 __failure = 728; 36860 if (!PyErr_Occurred()) { 36861 PyErr_SetString(PyExc_RuntimeError, 36862 "Unexpected error in an Op's C code. " 36863 "No Python exception was set."); 36864 } 36865 goto __label_728;} 36866 } 36867 // We expect NPY_FLOAT64 36868 if (!PyArray_ISALIGNED((PyArrayObject*) py_V727)) { 36869 PyArrayObject * tmp = (PyArrayObject*) py_V727; 36870 PyErr_Format(PyExc_NotImplementedError, 36871 "expected an aligned array of type %ld " 36872 "(NPY_FLOAT64), got non-aligned array of type %ld" 36873 " with %ld dimensions, with 3 last dims " 36874 "%ld, %ld, %ld" 36875 " and 3 last strides %ld %ld, %ld.", 36876 (long int) NPY_FLOAT64, 36877 (long int) PyArray_TYPE((PyArrayObject*) py_V727), 36878 (long int) PyArray_NDIM(tmp), 36879 (long int) (PyArray_NDIM(tmp) >= 3 ? 36880 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 36881 (long int) (PyArray_NDIM(tmp) >= 2 ? 36882 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 36883 (long int) (PyArray_NDIM(tmp) >= 1 ? 36884 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 36885 (long int) (PyArray_NDIM(tmp) >= 3 ? 36886 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 36887 (long int) (PyArray_NDIM(tmp) >= 2 ? 36888 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 36889 (long int) (PyArray_NDIM(tmp) >= 1 ? 36890 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 36891 ); 36892 { 36893 __failure = 728; 36894 if (!PyErr_Occurred()) { 36895 PyErr_SetString(PyExc_RuntimeError, 36896 "Unexpected error in an Op's C code. " 36897 "No Python exception was set."); 36898 } 36899 goto __label_728;} 36900 } 36901 // This is a TypeError to be consistent with DEBUG_MODE 36902 // Note: DEBUG_MODE also tells the name of the container 36903 if (PyArray_TYPE((PyArrayObject*) py_V727) != NPY_FLOAT64) { 36904 PyErr_Format(PyExc_TypeError, 36905 "expected type_num %d (NPY_FLOAT64) got %d", 36906 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V727)); 36907 { 36908 __failure = 728; 36909 if (!PyErr_Occurred()) { 36910 PyErr_SetString(PyExc_RuntimeError, 36911 "Unexpected error in an Op's C code. " 36912 "No Python exception was set."); 36913 } 36914 goto __label_728;} 36915 } 36916 36917 V727 = (PyArrayObject*)(py_V727); 36918 Py_XINCREF(V727); 36919 36920 { 36921 36922 py_V729 = PyList_GET_ITEM(storage_V729, 0); 36923 {Py_XINCREF(py_V729);} 36924 36925 V729 = NULL; 36926 if (py_V729 == Py_None) { 36927 // We can either fail here or set V729 to NULL and rely on Ops 36928 // using tensors to handle the NULL case, but if they fail to do so 36929 // they'll end up with nasty segfaults, so this is public service. 36930 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 36931 { 36932 __failure = 730; 36933 if (!PyErr_Occurred()) { 36934 PyErr_SetString(PyExc_RuntimeError, 36935 "Unexpected error in an Op's C code. " 36936 "No Python exception was set."); 36937 } 36938 goto __label_730;} 36939 } 36940 if (!PyArray_Check(py_V729)) { 36941 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 36942 { 36943 __failure = 730; 36944 if (!PyErr_Occurred()) { 36945 PyErr_SetString(PyExc_RuntimeError, 36946 "Unexpected error in an Op's C code. " 36947 "No Python exception was set."); 36948 } 36949 goto __label_730;} 36950 } 36951 // We expect NPY_FLOAT64 36952 if (!PyArray_ISALIGNED((PyArrayObject*) py_V729)) { 36953 PyArrayObject * tmp = (PyArrayObject*) py_V729; 36954 PyErr_Format(PyExc_NotImplementedError, 36955 "expected an aligned array of type %ld " 36956 "(NPY_FLOAT64), got non-aligned array of type %ld" 36957 " with %ld dimensions, with 3 last dims " 36958 "%ld, %ld, %ld" 36959 " and 3 last strides %ld %ld, %ld.", 36960 (long int) NPY_FLOAT64, 36961 (long int) PyArray_TYPE((PyArrayObject*) py_V729), 36962 (long int) PyArray_NDIM(tmp), 36963 (long int) (PyArray_NDIM(tmp) >= 3 ? 36964 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 36965 (long int) (PyArray_NDIM(tmp) >= 2 ? 36966 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 36967 (long int) (PyArray_NDIM(tmp) >= 1 ? 36968 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 36969 (long int) (PyArray_NDIM(tmp) >= 3 ? 36970 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 36971 (long int) (PyArray_NDIM(tmp) >= 2 ? 36972 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 36973 (long int) (PyArray_NDIM(tmp) >= 1 ? 36974 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 36975 ); 36976 { 36977 __failure = 730; 36978 if (!PyErr_Occurred()) { 36979 PyErr_SetString(PyExc_RuntimeError, 36980 "Unexpected error in an Op's C code. " 36981 "No Python exception was set."); 36982 } 36983 goto __label_730;} 36984 } 36985 // This is a TypeError to be consistent with DEBUG_MODE 36986 // Note: DEBUG_MODE also tells the name of the container 36987 if (PyArray_TYPE((PyArrayObject*) py_V729) != NPY_FLOAT64) { 36988 PyErr_Format(PyExc_TypeError, 36989 "expected type_num %d (NPY_FLOAT64) got %d", 36990 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V729)); 36991 { 36992 __failure = 730; 36993 if (!PyErr_Occurred()) { 36994 PyErr_SetString(PyExc_RuntimeError, 36995 "Unexpected error in an Op's C code. " 36996 "No Python exception was set."); 36997 } 36998 goto __label_730;} 36999 } 37000 37001 V729 = (PyArrayObject*)(py_V729); 37002 Py_XINCREF(V729); 37003 37004 { 37005 37006 py_V731 = PyList_GET_ITEM(storage_V731, 0); 37007 {Py_XINCREF(py_V731);} 37008 37009 V731 = NULL; 37010 if (py_V731 == Py_None) { 37011 // We can either fail here or set V731 to NULL and rely on Ops 37012 // using tensors to handle the NULL case, but if they fail to do so 37013 // they'll end up with nasty segfaults, so this is public service. 37014 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 37015 { 37016 __failure = 732; 37017 if (!PyErr_Occurred()) { 37018 PyErr_SetString(PyExc_RuntimeError, 37019 "Unexpected error in an Op's C code. " 37020 "No Python exception was set."); 37021 } 37022 goto __label_732;} 37023 } 37024 if (!PyArray_Check(py_V731)) { 37025 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 37026 { 37027 __failure = 732; 37028 if (!PyErr_Occurred()) { 37029 PyErr_SetString(PyExc_RuntimeError, 37030 "Unexpected error in an Op's C code. " 37031 "No Python exception was set."); 37032 } 37033 goto __label_732;} 37034 } 37035 // We expect NPY_FLOAT64 37036 if (!PyArray_ISALIGNED((PyArrayObject*) py_V731)) { 37037 PyArrayObject * tmp = (PyArrayObject*) py_V731; 37038 PyErr_Format(PyExc_NotImplementedError, 37039 "expected an aligned array of type %ld " 37040 "(NPY_FLOAT64), got non-aligned array of type %ld" 37041 " with %ld dimensions, with 3 last dims " 37042 "%ld, %ld, %ld" 37043 " and 3 last strides %ld %ld, %ld.", 37044 (long int) NPY_FLOAT64, 37045 (long int) PyArray_TYPE((PyArrayObject*) py_V731), 37046 (long int) PyArray_NDIM(tmp), 37047 (long int) (PyArray_NDIM(tmp) >= 3 ? 37048 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 37049 (long int) (PyArray_NDIM(tmp) >= 2 ? 37050 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 37051 (long int) (PyArray_NDIM(tmp) >= 1 ? 37052 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 37053 (long int) (PyArray_NDIM(tmp) >= 3 ? 37054 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 37055 (long int) (PyArray_NDIM(tmp) >= 2 ? 37056 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 37057 (long int) (PyArray_NDIM(tmp) >= 1 ? 37058 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 37059 ); 37060 { 37061 __failure = 732; 37062 if (!PyErr_Occurred()) { 37063 PyErr_SetString(PyExc_RuntimeError, 37064 "Unexpected error in an Op's C code. " 37065 "No Python exception was set."); 37066 } 37067 goto __label_732;} 37068 } 37069 // This is a TypeError to be consistent with DEBUG_MODE 37070 // Note: DEBUG_MODE also tells the name of the container 37071 if (PyArray_TYPE((PyArrayObject*) py_V731) != NPY_FLOAT64) { 37072 PyErr_Format(PyExc_TypeError, 37073 "expected type_num %d (NPY_FLOAT64) got %d", 37074 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V731)); 37075 { 37076 __failure = 732; 37077 if (!PyErr_Occurred()) { 37078 PyErr_SetString(PyExc_RuntimeError, 37079 "Unexpected error in an Op's C code. " 37080 "No Python exception was set."); 37081 } 37082 goto __label_732;} 37083 } 37084 37085 V731 = (PyArrayObject*)(py_V731); 37086 Py_XINCREF(V731); 37087 37088 { 37089 37090 py_V733 = PyList_GET_ITEM(storage_V733, 0); 37091 {Py_XINCREF(py_V733);} 37092 37093 V733 = NULL; 37094 if (py_V733 == Py_None) { 37095 // We can either fail here or set V733 to NULL and rely on Ops 37096 // using tensors to handle the NULL case, but if they fail to do so 37097 // they'll end up with nasty segfaults, so this is public service. 37098 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 37099 { 37100 __failure = 734; 37101 if (!PyErr_Occurred()) { 37102 PyErr_SetString(PyExc_RuntimeError, 37103 "Unexpected error in an Op's C code. " 37104 "No Python exception was set."); 37105 } 37106 goto __label_734;} 37107 } 37108 if (!PyArray_Check(py_V733)) { 37109 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 37110 { 37111 __failure = 734; 37112 if (!PyErr_Occurred()) { 37113 PyErr_SetString(PyExc_RuntimeError, 37114 "Unexpected error in an Op's C code. " 37115 "No Python exception was set."); 37116 } 37117 goto __label_734;} 37118 } 37119 // We expect NPY_FLOAT64 37120 if (!PyArray_ISALIGNED((PyArrayObject*) py_V733)) { 37121 PyArrayObject * tmp = (PyArrayObject*) py_V733; 37122 PyErr_Format(PyExc_NotImplementedError, 37123 "expected an aligned array of type %ld " 37124 "(NPY_FLOAT64), got non-aligned array of type %ld" 37125 " with %ld dimensions, with 3 last dims " 37126 "%ld, %ld, %ld" 37127 " and 3 last strides %ld %ld, %ld.", 37128 (long int) NPY_FLOAT64, 37129 (long int) PyArray_TYPE((PyArrayObject*) py_V733), 37130 (long int) PyArray_NDIM(tmp), 37131 (long int) (PyArray_NDIM(tmp) >= 3 ? 37132 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 37133 (long int) (PyArray_NDIM(tmp) >= 2 ? 37134 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 37135 (long int) (PyArray_NDIM(tmp) >= 1 ? 37136 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 37137 (long int) (PyArray_NDIM(tmp) >= 3 ? 37138 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 37139 (long int) (PyArray_NDIM(tmp) >= 2 ? 37140 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 37141 (long int) (PyArray_NDIM(tmp) >= 1 ? 37142 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 37143 ); 37144 { 37145 __failure = 734; 37146 if (!PyErr_Occurred()) { 37147 PyErr_SetString(PyExc_RuntimeError, 37148 "Unexpected error in an Op's C code. " 37149 "No Python exception was set."); 37150 } 37151 goto __label_734;} 37152 } 37153 // This is a TypeError to be consistent with DEBUG_MODE 37154 // Note: DEBUG_MODE also tells the name of the container 37155 if (PyArray_TYPE((PyArrayObject*) py_V733) != NPY_FLOAT64) { 37156 PyErr_Format(PyExc_TypeError, 37157 "expected type_num %d (NPY_FLOAT64) got %d", 37158 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V733)); 37159 { 37160 __failure = 734; 37161 if (!PyErr_Occurred()) { 37162 PyErr_SetString(PyExc_RuntimeError, 37163 "Unexpected error in an Op's C code. " 37164 "No Python exception was set."); 37165 } 37166 goto __label_734;} 37167 } 37168 37169 V733 = (PyArrayObject*)(py_V733); 37170 Py_XINCREF(V733); 37171 37172 { 37173 37174 py_V735 = PyList_GET_ITEM(storage_V735, 0); 37175 {Py_XINCREF(py_V735);} 37176 37177 V735 = NULL; 37178 if (py_V735 == Py_None) { 37179 // We can either fail here or set V735 to NULL and rely on Ops 37180 // using tensors to handle the NULL case, but if they fail to do so 37181 // they'll end up with nasty segfaults, so this is public service. 37182 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 37183 { 37184 __failure = 736; 37185 if (!PyErr_Occurred()) { 37186 PyErr_SetString(PyExc_RuntimeError, 37187 "Unexpected error in an Op's C code. " 37188 "No Python exception was set."); 37189 } 37190 goto __label_736;} 37191 } 37192 if (!PyArray_Check(py_V735)) { 37193 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 37194 { 37195 __failure = 736; 37196 if (!PyErr_Occurred()) { 37197 PyErr_SetString(PyExc_RuntimeError, 37198 "Unexpected error in an Op's C code. " 37199 "No Python exception was set."); 37200 } 37201 goto __label_736;} 37202 } 37203 // We expect NPY_FLOAT64 37204 if (!PyArray_ISALIGNED((PyArrayObject*) py_V735)) { 37205 PyArrayObject * tmp = (PyArrayObject*) py_V735; 37206 PyErr_Format(PyExc_NotImplementedError, 37207 "expected an aligned array of type %ld " 37208 "(NPY_FLOAT64), got non-aligned array of type %ld" 37209 " with %ld dimensions, with 3 last dims " 37210 "%ld, %ld, %ld" 37211 " and 3 last strides %ld %ld, %ld.", 37212 (long int) NPY_FLOAT64, 37213 (long int) PyArray_TYPE((PyArrayObject*) py_V735), 37214 (long int) PyArray_NDIM(tmp), 37215 (long int) (PyArray_NDIM(tmp) >= 3 ? 37216 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 37217 (long int) (PyArray_NDIM(tmp) >= 2 ? 37218 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 37219 (long int) (PyArray_NDIM(tmp) >= 1 ? 37220 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 37221 (long int) (PyArray_NDIM(tmp) >= 3 ? 37222 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 37223 (long int) (PyArray_NDIM(tmp) >= 2 ? 37224 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 37225 (long int) (PyArray_NDIM(tmp) >= 1 ? 37226 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 37227 ); 37228 { 37229 __failure = 736; 37230 if (!PyErr_Occurred()) { 37231 PyErr_SetString(PyExc_RuntimeError, 37232 "Unexpected error in an Op's C code. " 37233 "No Python exception was set."); 37234 } 37235 goto __label_736;} 37236 } 37237 // This is a TypeError to be consistent with DEBUG_MODE 37238 // Note: DEBUG_MODE also tells the name of the container 37239 if (PyArray_TYPE((PyArrayObject*) py_V735) != NPY_FLOAT64) { 37240 PyErr_Format(PyExc_TypeError, 37241 "expected type_num %d (NPY_FLOAT64) got %d", 37242 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V735)); 37243 { 37244 __failure = 736; 37245 if (!PyErr_Occurred()) { 37246 PyErr_SetString(PyExc_RuntimeError, 37247 "Unexpected error in an Op's C code. " 37248 "No Python exception was set."); 37249 } 37250 goto __label_736;} 37251 } 37252 37253 V735 = (PyArrayObject*)(py_V735); 37254 Py_XINCREF(V735); 37255 37256 { 37257 37258 py_V737 = PyList_GET_ITEM(storage_V737, 0); 37259 {Py_XINCREF(py_V737);} 37260 37261 V737 = NULL; 37262 if (py_V737 == Py_None) { 37263 // We can either fail here or set V737 to NULL and rely on Ops 37264 // using tensors to handle the NULL case, but if they fail to do so 37265 // they'll end up with nasty segfaults, so this is public service. 37266 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 37267 { 37268 __failure = 738; 37269 if (!PyErr_Occurred()) { 37270 PyErr_SetString(PyExc_RuntimeError, 37271 "Unexpected error in an Op's C code. " 37272 "No Python exception was set."); 37273 } 37274 goto __label_738;} 37275 } 37276 if (!PyArray_Check(py_V737)) { 37277 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 37278 { 37279 __failure = 738; 37280 if (!PyErr_Occurred()) { 37281 PyErr_SetString(PyExc_RuntimeError, 37282 "Unexpected error in an Op's C code. " 37283 "No Python exception was set."); 37284 } 37285 goto __label_738;} 37286 } 37287 // We expect NPY_FLOAT64 37288 if (!PyArray_ISALIGNED((PyArrayObject*) py_V737)) { 37289 PyArrayObject * tmp = (PyArrayObject*) py_V737; 37290 PyErr_Format(PyExc_NotImplementedError, 37291 "expected an aligned array of type %ld " 37292 "(NPY_FLOAT64), got non-aligned array of type %ld" 37293 " with %ld dimensions, with 3 last dims " 37294 "%ld, %ld, %ld" 37295 " and 3 last strides %ld %ld, %ld.", 37296 (long int) NPY_FLOAT64, 37297 (long int) PyArray_TYPE((PyArrayObject*) py_V737), 37298 (long int) PyArray_NDIM(tmp), 37299 (long int) (PyArray_NDIM(tmp) >= 3 ? 37300 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 37301 (long int) (PyArray_NDIM(tmp) >= 2 ? 37302 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 37303 (long int) (PyArray_NDIM(tmp) >= 1 ? 37304 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 37305 (long int) (PyArray_NDIM(tmp) >= 3 ? 37306 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 37307 (long int) (PyArray_NDIM(tmp) >= 2 ? 37308 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 37309 (long int) (PyArray_NDIM(tmp) >= 1 ? 37310 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 37311 ); 37312 { 37313 __failure = 738; 37314 if (!PyErr_Occurred()) { 37315 PyErr_SetString(PyExc_RuntimeError, 37316 "Unexpected error in an Op's C code. " 37317 "No Python exception was set."); 37318 } 37319 goto __label_738;} 37320 } 37321 // This is a TypeError to be consistent with DEBUG_MODE 37322 // Note: DEBUG_MODE also tells the name of the container 37323 if (PyArray_TYPE((PyArrayObject*) py_V737) != NPY_FLOAT64) { 37324 PyErr_Format(PyExc_TypeError, 37325 "expected type_num %d (NPY_FLOAT64) got %d", 37326 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V737)); 37327 { 37328 __failure = 738; 37329 if (!PyErr_Occurred()) { 37330 PyErr_SetString(PyExc_RuntimeError, 37331 "Unexpected error in an Op's C code. " 37332 "No Python exception was set."); 37333 } 37334 goto __label_738;} 37335 } 37336 37337 V737 = (PyArrayObject*)(py_V737); 37338 Py_XINCREF(V737); 37339 37340 { 37341 37342 py_V739 = PyList_GET_ITEM(storage_V739, 0); 37343 {Py_XINCREF(py_V739);} 37344 37345 V739 = NULL; 37346 if (py_V739 == Py_None) { 37347 // We can either fail here or set V739 to NULL and rely on Ops 37348 // using tensors to handle the NULL case, but if they fail to do so 37349 // they'll end up with nasty segfaults, so this is public service. 37350 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 37351 { 37352 __failure = 740; 37353 if (!PyErr_Occurred()) { 37354 PyErr_SetString(PyExc_RuntimeError, 37355 "Unexpected error in an Op's C code. " 37356 "No Python exception was set."); 37357 } 37358 goto __label_740;} 37359 } 37360 if (!PyArray_Check(py_V739)) { 37361 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 37362 { 37363 __failure = 740; 37364 if (!PyErr_Occurred()) { 37365 PyErr_SetString(PyExc_RuntimeError, 37366 "Unexpected error in an Op's C code. " 37367 "No Python exception was set."); 37368 } 37369 goto __label_740;} 37370 } 37371 // We expect NPY_FLOAT64 37372 if (!PyArray_ISALIGNED((PyArrayObject*) py_V739)) { 37373 PyArrayObject * tmp = (PyArrayObject*) py_V739; 37374 PyErr_Format(PyExc_NotImplementedError, 37375 "expected an aligned array of type %ld " 37376 "(NPY_FLOAT64), got non-aligned array of type %ld" 37377 " with %ld dimensions, with 3 last dims " 37378 "%ld, %ld, %ld" 37379 " and 3 last strides %ld %ld, %ld.", 37380 (long int) NPY_FLOAT64, 37381 (long int) PyArray_TYPE((PyArrayObject*) py_V739), 37382 (long int) PyArray_NDIM(tmp), 37383 (long int) (PyArray_NDIM(tmp) >= 3 ? 37384 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 37385 (long int) (PyArray_NDIM(tmp) >= 2 ? 37386 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 37387 (long int) (PyArray_NDIM(tmp) >= 1 ? 37388 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 37389 (long int) (PyArray_NDIM(tmp) >= 3 ? 37390 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 37391 (long int) (PyArray_NDIM(tmp) >= 2 ? 37392 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 37393 (long int) (PyArray_NDIM(tmp) >= 1 ? 37394 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 37395 ); 37396 { 37397 __failure = 740; 37398 if (!PyErr_Occurred()) { 37399 PyErr_SetString(PyExc_RuntimeError, 37400 "Unexpected error in an Op's C code. " 37401 "No Python exception was set."); 37402 } 37403 goto __label_740;} 37404 } 37405 // This is a TypeError to be consistent with DEBUG_MODE 37406 // Note: DEBUG_MODE also tells the name of the container 37407 if (PyArray_TYPE((PyArrayObject*) py_V739) != NPY_FLOAT64) { 37408 PyErr_Format(PyExc_TypeError, 37409 "expected type_num %d (NPY_FLOAT64) got %d", 37410 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V739)); 37411 { 37412 __failure = 740; 37413 if (!PyErr_Occurred()) { 37414 PyErr_SetString(PyExc_RuntimeError, 37415 "Unexpected error in an Op's C code. " 37416 "No Python exception was set."); 37417 } 37418 goto __label_740;} 37419 } 37420 37421 V739 = (PyArrayObject*)(py_V739); 37422 Py_XINCREF(V739); 37423 37424 { 37425 37426 py_V741 = PyList_GET_ITEM(storage_V741, 0); 37427 {Py_XINCREF(py_V741);} 37428 37429 V741 = NULL; 37430 if (py_V741 == Py_None) { 37431 // We can either fail here or set V741 to NULL and rely on Ops 37432 // using tensors to handle the NULL case, but if they fail to do so 37433 // they'll end up with nasty segfaults, so this is public service. 37434 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 37435 { 37436 __failure = 742; 37437 if (!PyErr_Occurred()) { 37438 PyErr_SetString(PyExc_RuntimeError, 37439 "Unexpected error in an Op's C code. " 37440 "No Python exception was set."); 37441 } 37442 goto __label_742;} 37443 } 37444 if (!PyArray_Check(py_V741)) { 37445 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 37446 { 37447 __failure = 742; 37448 if (!PyErr_Occurred()) { 37449 PyErr_SetString(PyExc_RuntimeError, 37450 "Unexpected error in an Op's C code. " 37451 "No Python exception was set."); 37452 } 37453 goto __label_742;} 37454 } 37455 // We expect NPY_FLOAT64 37456 if (!PyArray_ISALIGNED((PyArrayObject*) py_V741)) { 37457 PyArrayObject * tmp = (PyArrayObject*) py_V741; 37458 PyErr_Format(PyExc_NotImplementedError, 37459 "expected an aligned array of type %ld " 37460 "(NPY_FLOAT64), got non-aligned array of type %ld" 37461 " with %ld dimensions, with 3 last dims " 37462 "%ld, %ld, %ld" 37463 " and 3 last strides %ld %ld, %ld.", 37464 (long int) NPY_FLOAT64, 37465 (long int) PyArray_TYPE((PyArrayObject*) py_V741), 37466 (long int) PyArray_NDIM(tmp), 37467 (long int) (PyArray_NDIM(tmp) >= 3 ? 37468 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 37469 (long int) (PyArray_NDIM(tmp) >= 2 ? 37470 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 37471 (long int) (PyArray_NDIM(tmp) >= 1 ? 37472 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 37473 (long int) (PyArray_NDIM(tmp) >= 3 ? 37474 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 37475 (long int) (PyArray_NDIM(tmp) >= 2 ? 37476 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 37477 (long int) (PyArray_NDIM(tmp) >= 1 ? 37478 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 37479 ); 37480 { 37481 __failure = 742; 37482 if (!PyErr_Occurred()) { 37483 PyErr_SetString(PyExc_RuntimeError, 37484 "Unexpected error in an Op's C code. " 37485 "No Python exception was set."); 37486 } 37487 goto __label_742;} 37488 } 37489 // This is a TypeError to be consistent with DEBUG_MODE 37490 // Note: DEBUG_MODE also tells the name of the container 37491 if (PyArray_TYPE((PyArrayObject*) py_V741) != NPY_FLOAT64) { 37492 PyErr_Format(PyExc_TypeError, 37493 "expected type_num %d (NPY_FLOAT64) got %d", 37494 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V741)); 37495 { 37496 __failure = 742; 37497 if (!PyErr_Occurred()) { 37498 PyErr_SetString(PyExc_RuntimeError, 37499 "Unexpected error in an Op's C code. " 37500 "No Python exception was set."); 37501 } 37502 goto __label_742;} 37503 } 37504 37505 V741 = (PyArrayObject*)(py_V741); 37506 Py_XINCREF(V741); 37507 37508 { 37509 37510 py_V743 = PyList_GET_ITEM(storage_V743, 0); 37511 {Py_XINCREF(py_V743);} 37512 37513 V743 = NULL; 37514 if (py_V743 == Py_None) { 37515 // We can either fail here or set V743 to NULL and rely on Ops 37516 // using tensors to handle the NULL case, but if they fail to do so 37517 // they'll end up with nasty segfaults, so this is public service. 37518 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 37519 { 37520 __failure = 744; 37521 if (!PyErr_Occurred()) { 37522 PyErr_SetString(PyExc_RuntimeError, 37523 "Unexpected error in an Op's C code. " 37524 "No Python exception was set."); 37525 } 37526 goto __label_744;} 37527 } 37528 if (!PyArray_Check(py_V743)) { 37529 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 37530 { 37531 __failure = 744; 37532 if (!PyErr_Occurred()) { 37533 PyErr_SetString(PyExc_RuntimeError, 37534 "Unexpected error in an Op's C code. " 37535 "No Python exception was set."); 37536 } 37537 goto __label_744;} 37538 } 37539 // We expect NPY_FLOAT64 37540 if (!PyArray_ISALIGNED((PyArrayObject*) py_V743)) { 37541 PyArrayObject * tmp = (PyArrayObject*) py_V743; 37542 PyErr_Format(PyExc_NotImplementedError, 37543 "expected an aligned array of type %ld " 37544 "(NPY_FLOAT64), got non-aligned array of type %ld" 37545 " with %ld dimensions, with 3 last dims " 37546 "%ld, %ld, %ld" 37547 " and 3 last strides %ld %ld, %ld.", 37548 (long int) NPY_FLOAT64, 37549 (long int) PyArray_TYPE((PyArrayObject*) py_V743), 37550 (long int) PyArray_NDIM(tmp), 37551 (long int) (PyArray_NDIM(tmp) >= 3 ? 37552 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 37553 (long int) (PyArray_NDIM(tmp) >= 2 ? 37554 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 37555 (long int) (PyArray_NDIM(tmp) >= 1 ? 37556 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 37557 (long int) (PyArray_NDIM(tmp) >= 3 ? 37558 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 37559 (long int) (PyArray_NDIM(tmp) >= 2 ? 37560 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 37561 (long int) (PyArray_NDIM(tmp) >= 1 ? 37562 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 37563 ); 37564 { 37565 __failure = 744; 37566 if (!PyErr_Occurred()) { 37567 PyErr_SetString(PyExc_RuntimeError, 37568 "Unexpected error in an Op's C code. " 37569 "No Python exception was set."); 37570 } 37571 goto __label_744;} 37572 } 37573 // This is a TypeError to be consistent with DEBUG_MODE 37574 // Note: DEBUG_MODE also tells the name of the container 37575 if (PyArray_TYPE((PyArrayObject*) py_V743) != NPY_FLOAT64) { 37576 PyErr_Format(PyExc_TypeError, 37577 "expected type_num %d (NPY_FLOAT64) got %d", 37578 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V743)); 37579 { 37580 __failure = 744; 37581 if (!PyErr_Occurred()) { 37582 PyErr_SetString(PyExc_RuntimeError, 37583 "Unexpected error in an Op's C code. " 37584 "No Python exception was set."); 37585 } 37586 goto __label_744;} 37587 } 37588 37589 V743 = (PyArrayObject*)(py_V743); 37590 Py_XINCREF(V743); 37591 37592 { 37593 37594 py_V745 = PyList_GET_ITEM(storage_V745, 0); 37595 {Py_XINCREF(py_V745);} 37596 37597 V745 = NULL; 37598 if (py_V745 == Py_None) { 37599 // We can either fail here or set V745 to NULL and rely on Ops 37600 // using tensors to handle the NULL case, but if they fail to do so 37601 // they'll end up with nasty segfaults, so this is public service. 37602 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 37603 { 37604 __failure = 746; 37605 if (!PyErr_Occurred()) { 37606 PyErr_SetString(PyExc_RuntimeError, 37607 "Unexpected error in an Op's C code. " 37608 "No Python exception was set."); 37609 } 37610 goto __label_746;} 37611 } 37612 if (!PyArray_Check(py_V745)) { 37613 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 37614 { 37615 __failure = 746; 37616 if (!PyErr_Occurred()) { 37617 PyErr_SetString(PyExc_RuntimeError, 37618 "Unexpected error in an Op's C code. " 37619 "No Python exception was set."); 37620 } 37621 goto __label_746;} 37622 } 37623 // We expect NPY_FLOAT64 37624 if (!PyArray_ISALIGNED((PyArrayObject*) py_V745)) { 37625 PyArrayObject * tmp = (PyArrayObject*) py_V745; 37626 PyErr_Format(PyExc_NotImplementedError, 37627 "expected an aligned array of type %ld " 37628 "(NPY_FLOAT64), got non-aligned array of type %ld" 37629 " with %ld dimensions, with 3 last dims " 37630 "%ld, %ld, %ld" 37631 " and 3 last strides %ld %ld, %ld.", 37632 (long int) NPY_FLOAT64, 37633 (long int) PyArray_TYPE((PyArrayObject*) py_V745), 37634 (long int) PyArray_NDIM(tmp), 37635 (long int) (PyArray_NDIM(tmp) >= 3 ? 37636 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 37637 (long int) (PyArray_NDIM(tmp) >= 2 ? 37638 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 37639 (long int) (PyArray_NDIM(tmp) >= 1 ? 37640 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 37641 (long int) (PyArray_NDIM(tmp) >= 3 ? 37642 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 37643 (long int) (PyArray_NDIM(tmp) >= 2 ? 37644 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 37645 (long int) (PyArray_NDIM(tmp) >= 1 ? 37646 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 37647 ); 37648 { 37649 __failure = 746; 37650 if (!PyErr_Occurred()) { 37651 PyErr_SetString(PyExc_RuntimeError, 37652 "Unexpected error in an Op's C code. " 37653 "No Python exception was set."); 37654 } 37655 goto __label_746;} 37656 } 37657 // This is a TypeError to be consistent with DEBUG_MODE 37658 // Note: DEBUG_MODE also tells the name of the container 37659 if (PyArray_TYPE((PyArrayObject*) py_V745) != NPY_FLOAT64) { 37660 PyErr_Format(PyExc_TypeError, 37661 "expected type_num %d (NPY_FLOAT64) got %d", 37662 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V745)); 37663 { 37664 __failure = 746; 37665 if (!PyErr_Occurred()) { 37666 PyErr_SetString(PyExc_RuntimeError, 37667 "Unexpected error in an Op's C code. " 37668 "No Python exception was set."); 37669 } 37670 goto __label_746;} 37671 } 37672 37673 V745 = (PyArrayObject*)(py_V745); 37674 Py_XINCREF(V745); 37675 37676 { 37677 37678 py_V747 = PyList_GET_ITEM(storage_V747, 0); 37679 {Py_XINCREF(py_V747);} 37680 37681 V747 = NULL; 37682 if (py_V747 == Py_None) { 37683 // We can either fail here or set V747 to NULL and rely on Ops 37684 // using tensors to handle the NULL case, but if they fail to do so 37685 // they'll end up with nasty segfaults, so this is public service. 37686 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 37687 { 37688 __failure = 748; 37689 if (!PyErr_Occurred()) { 37690 PyErr_SetString(PyExc_RuntimeError, 37691 "Unexpected error in an Op's C code. " 37692 "No Python exception was set."); 37693 } 37694 goto __label_748;} 37695 } 37696 if (!PyArray_Check(py_V747)) { 37697 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 37698 { 37699 __failure = 748; 37700 if (!PyErr_Occurred()) { 37701 PyErr_SetString(PyExc_RuntimeError, 37702 "Unexpected error in an Op's C code. " 37703 "No Python exception was set."); 37704 } 37705 goto __label_748;} 37706 } 37707 // We expect NPY_FLOAT64 37708 if (!PyArray_ISALIGNED((PyArrayObject*) py_V747)) { 37709 PyArrayObject * tmp = (PyArrayObject*) py_V747; 37710 PyErr_Format(PyExc_NotImplementedError, 37711 "expected an aligned array of type %ld " 37712 "(NPY_FLOAT64), got non-aligned array of type %ld" 37713 " with %ld dimensions, with 3 last dims " 37714 "%ld, %ld, %ld" 37715 " and 3 last strides %ld %ld, %ld.", 37716 (long int) NPY_FLOAT64, 37717 (long int) PyArray_TYPE((PyArrayObject*) py_V747), 37718 (long int) PyArray_NDIM(tmp), 37719 (long int) (PyArray_NDIM(tmp) >= 3 ? 37720 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 37721 (long int) (PyArray_NDIM(tmp) >= 2 ? 37722 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 37723 (long int) (PyArray_NDIM(tmp) >= 1 ? 37724 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 37725 (long int) (PyArray_NDIM(tmp) >= 3 ? 37726 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 37727 (long int) (PyArray_NDIM(tmp) >= 2 ? 37728 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 37729 (long int) (PyArray_NDIM(tmp) >= 1 ? 37730 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 37731 ); 37732 { 37733 __failure = 748; 37734 if (!PyErr_Occurred()) { 37735 PyErr_SetString(PyExc_RuntimeError, 37736 "Unexpected error in an Op's C code. " 37737 "No Python exception was set."); 37738 } 37739 goto __label_748;} 37740 } 37741 // This is a TypeError to be consistent with DEBUG_MODE 37742 // Note: DEBUG_MODE also tells the name of the container 37743 if (PyArray_TYPE((PyArrayObject*) py_V747) != NPY_FLOAT64) { 37744 PyErr_Format(PyExc_TypeError, 37745 "expected type_num %d (NPY_FLOAT64) got %d", 37746 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V747)); 37747 { 37748 __failure = 748; 37749 if (!PyErr_Occurred()) { 37750 PyErr_SetString(PyExc_RuntimeError, 37751 "Unexpected error in an Op's C code. " 37752 "No Python exception was set."); 37753 } 37754 goto __label_748;} 37755 } 37756 37757 V747 = (PyArrayObject*)(py_V747); 37758 Py_XINCREF(V747); 37759 37760 { 37761 37762 py_V749 = PyList_GET_ITEM(storage_V749, 0); 37763 {Py_XINCREF(py_V749);} 37764 37765 V749 = NULL; 37766 if (py_V749 == Py_None) { 37767 // We can either fail here or set V749 to NULL and rely on Ops 37768 // using tensors to handle the NULL case, but if they fail to do so 37769 // they'll end up with nasty segfaults, so this is public service. 37770 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 37771 { 37772 __failure = 750; 37773 if (!PyErr_Occurred()) { 37774 PyErr_SetString(PyExc_RuntimeError, 37775 "Unexpected error in an Op's C code. " 37776 "No Python exception was set."); 37777 } 37778 goto __label_750;} 37779 } 37780 if (!PyArray_Check(py_V749)) { 37781 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 37782 { 37783 __failure = 750; 37784 if (!PyErr_Occurred()) { 37785 PyErr_SetString(PyExc_RuntimeError, 37786 "Unexpected error in an Op's C code. " 37787 "No Python exception was set."); 37788 } 37789 goto __label_750;} 37790 } 37791 // We expect NPY_FLOAT64 37792 if (!PyArray_ISALIGNED((PyArrayObject*) py_V749)) { 37793 PyArrayObject * tmp = (PyArrayObject*) py_V749; 37794 PyErr_Format(PyExc_NotImplementedError, 37795 "expected an aligned array of type %ld " 37796 "(NPY_FLOAT64), got non-aligned array of type %ld" 37797 " with %ld dimensions, with 3 last dims " 37798 "%ld, %ld, %ld" 37799 " and 3 last strides %ld %ld, %ld.", 37800 (long int) NPY_FLOAT64, 37801 (long int) PyArray_TYPE((PyArrayObject*) py_V749), 37802 (long int) PyArray_NDIM(tmp), 37803 (long int) (PyArray_NDIM(tmp) >= 3 ? 37804 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 37805 (long int) (PyArray_NDIM(tmp) >= 2 ? 37806 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 37807 (long int) (PyArray_NDIM(tmp) >= 1 ? 37808 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 37809 (long int) (PyArray_NDIM(tmp) >= 3 ? 37810 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 37811 (long int) (PyArray_NDIM(tmp) >= 2 ? 37812 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 37813 (long int) (PyArray_NDIM(tmp) >= 1 ? 37814 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 37815 ); 37816 { 37817 __failure = 750; 37818 if (!PyErr_Occurred()) { 37819 PyErr_SetString(PyExc_RuntimeError, 37820 "Unexpected error in an Op's C code. " 37821 "No Python exception was set."); 37822 } 37823 goto __label_750;} 37824 } 37825 // This is a TypeError to be consistent with DEBUG_MODE 37826 // Note: DEBUG_MODE also tells the name of the container 37827 if (PyArray_TYPE((PyArrayObject*) py_V749) != NPY_FLOAT64) { 37828 PyErr_Format(PyExc_TypeError, 37829 "expected type_num %d (NPY_FLOAT64) got %d", 37830 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V749)); 37831 { 37832 __failure = 750; 37833 if (!PyErr_Occurred()) { 37834 PyErr_SetString(PyExc_RuntimeError, 37835 "Unexpected error in an Op's C code. " 37836 "No Python exception was set."); 37837 } 37838 goto __label_750;} 37839 } 37840 37841 V749 = (PyArrayObject*)(py_V749); 37842 Py_XINCREF(V749); 37843 37844 { 37845 37846 py_V751 = PyList_GET_ITEM(storage_V751, 0); 37847 {Py_XINCREF(py_V751);} 37848 37849 V751 = NULL; 37850 if (py_V751 == Py_None) { 37851 // We can either fail here or set V751 to NULL and rely on Ops 37852 // using tensors to handle the NULL case, but if they fail to do so 37853 // they'll end up with nasty segfaults, so this is public service. 37854 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 37855 { 37856 __failure = 752; 37857 if (!PyErr_Occurred()) { 37858 PyErr_SetString(PyExc_RuntimeError, 37859 "Unexpected error in an Op's C code. " 37860 "No Python exception was set."); 37861 } 37862 goto __label_752;} 37863 } 37864 if (!PyArray_Check(py_V751)) { 37865 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 37866 { 37867 __failure = 752; 37868 if (!PyErr_Occurred()) { 37869 PyErr_SetString(PyExc_RuntimeError, 37870 "Unexpected error in an Op's C code. " 37871 "No Python exception was set."); 37872 } 37873 goto __label_752;} 37874 } 37875 // We expect NPY_FLOAT64 37876 if (!PyArray_ISALIGNED((PyArrayObject*) py_V751)) { 37877 PyArrayObject * tmp = (PyArrayObject*) py_V751; 37878 PyErr_Format(PyExc_NotImplementedError, 37879 "expected an aligned array of type %ld " 37880 "(NPY_FLOAT64), got non-aligned array of type %ld" 37881 " with %ld dimensions, with 3 last dims " 37882 "%ld, %ld, %ld" 37883 " and 3 last strides %ld %ld, %ld.", 37884 (long int) NPY_FLOAT64, 37885 (long int) PyArray_TYPE((PyArrayObject*) py_V751), 37886 (long int) PyArray_NDIM(tmp), 37887 (long int) (PyArray_NDIM(tmp) >= 3 ? 37888 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 37889 (long int) (PyArray_NDIM(tmp) >= 2 ? 37890 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 37891 (long int) (PyArray_NDIM(tmp) >= 1 ? 37892 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 37893 (long int) (PyArray_NDIM(tmp) >= 3 ? 37894 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 37895 (long int) (PyArray_NDIM(tmp) >= 2 ? 37896 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 37897 (long int) (PyArray_NDIM(tmp) >= 1 ? 37898 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 37899 ); 37900 { 37901 __failure = 752; 37902 if (!PyErr_Occurred()) { 37903 PyErr_SetString(PyExc_RuntimeError, 37904 "Unexpected error in an Op's C code. " 37905 "No Python exception was set."); 37906 } 37907 goto __label_752;} 37908 } 37909 // This is a TypeError to be consistent with DEBUG_MODE 37910 // Note: DEBUG_MODE also tells the name of the container 37911 if (PyArray_TYPE((PyArrayObject*) py_V751) != NPY_FLOAT64) { 37912 PyErr_Format(PyExc_TypeError, 37913 "expected type_num %d (NPY_FLOAT64) got %d", 37914 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V751)); 37915 { 37916 __failure = 752; 37917 if (!PyErr_Occurred()) { 37918 PyErr_SetString(PyExc_RuntimeError, 37919 "Unexpected error in an Op's C code. " 37920 "No Python exception was set."); 37921 } 37922 goto __label_752;} 37923 } 37924 37925 V751 = (PyArrayObject*)(py_V751); 37926 Py_XINCREF(V751); 37927 37928 { 37929 37930 py_V753 = PyList_GET_ITEM(storage_V753, 0); 37931 {Py_XINCREF(py_V753);} 37932 37933 V753 = NULL; 37934 if (py_V753 == Py_None) { 37935 // We can either fail here or set V753 to NULL and rely on Ops 37936 // using tensors to handle the NULL case, but if they fail to do so 37937 // they'll end up with nasty segfaults, so this is public service. 37938 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 37939 { 37940 __failure = 754; 37941 if (!PyErr_Occurred()) { 37942 PyErr_SetString(PyExc_RuntimeError, 37943 "Unexpected error in an Op's C code. " 37944 "No Python exception was set."); 37945 } 37946 goto __label_754;} 37947 } 37948 if (!PyArray_Check(py_V753)) { 37949 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 37950 { 37951 __failure = 754; 37952 if (!PyErr_Occurred()) { 37953 PyErr_SetString(PyExc_RuntimeError, 37954 "Unexpected error in an Op's C code. " 37955 "No Python exception was set."); 37956 } 37957 goto __label_754;} 37958 } 37959 // We expect NPY_FLOAT64 37960 if (!PyArray_ISALIGNED((PyArrayObject*) py_V753)) { 37961 PyArrayObject * tmp = (PyArrayObject*) py_V753; 37962 PyErr_Format(PyExc_NotImplementedError, 37963 "expected an aligned array of type %ld " 37964 "(NPY_FLOAT64), got non-aligned array of type %ld" 37965 " with %ld dimensions, with 3 last dims " 37966 "%ld, %ld, %ld" 37967 " and 3 last strides %ld %ld, %ld.", 37968 (long int) NPY_FLOAT64, 37969 (long int) PyArray_TYPE((PyArrayObject*) py_V753), 37970 (long int) PyArray_NDIM(tmp), 37971 (long int) (PyArray_NDIM(tmp) >= 3 ? 37972 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 37973 (long int) (PyArray_NDIM(tmp) >= 2 ? 37974 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 37975 (long int) (PyArray_NDIM(tmp) >= 1 ? 37976 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 37977 (long int) (PyArray_NDIM(tmp) >= 3 ? 37978 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 37979 (long int) (PyArray_NDIM(tmp) >= 2 ? 37980 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 37981 (long int) (PyArray_NDIM(tmp) >= 1 ? 37982 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 37983 ); 37984 { 37985 __failure = 754; 37986 if (!PyErr_Occurred()) { 37987 PyErr_SetString(PyExc_RuntimeError, 37988 "Unexpected error in an Op's C code. " 37989 "No Python exception was set."); 37990 } 37991 goto __label_754;} 37992 } 37993 // This is a TypeError to be consistent with DEBUG_MODE 37994 // Note: DEBUG_MODE also tells the name of the container 37995 if (PyArray_TYPE((PyArrayObject*) py_V753) != NPY_FLOAT64) { 37996 PyErr_Format(PyExc_TypeError, 37997 "expected type_num %d (NPY_FLOAT64) got %d", 37998 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V753)); 37999 { 38000 __failure = 754; 38001 if (!PyErr_Occurred()) { 38002 PyErr_SetString(PyExc_RuntimeError, 38003 "Unexpected error in an Op's C code. " 38004 "No Python exception was set."); 38005 } 38006 goto __label_754;} 38007 } 38008 38009 V753 = (PyArrayObject*)(py_V753); 38010 Py_XINCREF(V753); 38011 38012 { 38013 38014 py_V755 = PyList_GET_ITEM(storage_V755, 0); 38015 {Py_XINCREF(py_V755);} 38016 38017 V755 = NULL; 38018 if (py_V755 == Py_None) { 38019 // We can either fail here or set V755 to NULL and rely on Ops 38020 // using tensors to handle the NULL case, but if they fail to do so 38021 // they'll end up with nasty segfaults, so this is public service. 38022 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 38023 { 38024 __failure = 756; 38025 if (!PyErr_Occurred()) { 38026 PyErr_SetString(PyExc_RuntimeError, 38027 "Unexpected error in an Op's C code. " 38028 "No Python exception was set."); 38029 } 38030 goto __label_756;} 38031 } 38032 if (!PyArray_Check(py_V755)) { 38033 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 38034 { 38035 __failure = 756; 38036 if (!PyErr_Occurred()) { 38037 PyErr_SetString(PyExc_RuntimeError, 38038 "Unexpected error in an Op's C code. " 38039 "No Python exception was set."); 38040 } 38041 goto __label_756;} 38042 } 38043 // We expect NPY_FLOAT64 38044 if (!PyArray_ISALIGNED((PyArrayObject*) py_V755)) { 38045 PyArrayObject * tmp = (PyArrayObject*) py_V755; 38046 PyErr_Format(PyExc_NotImplementedError, 38047 "expected an aligned array of type %ld " 38048 "(NPY_FLOAT64), got non-aligned array of type %ld" 38049 " with %ld dimensions, with 3 last dims " 38050 "%ld, %ld, %ld" 38051 " and 3 last strides %ld %ld, %ld.", 38052 (long int) NPY_FLOAT64, 38053 (long int) PyArray_TYPE((PyArrayObject*) py_V755), 38054 (long int) PyArray_NDIM(tmp), 38055 (long int) (PyArray_NDIM(tmp) >= 3 ? 38056 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 38057 (long int) (PyArray_NDIM(tmp) >= 2 ? 38058 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 38059 (long int) (PyArray_NDIM(tmp) >= 1 ? 38060 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 38061 (long int) (PyArray_NDIM(tmp) >= 3 ? 38062 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 38063 (long int) (PyArray_NDIM(tmp) >= 2 ? 38064 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 38065 (long int) (PyArray_NDIM(tmp) >= 1 ? 38066 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 38067 ); 38068 { 38069 __failure = 756; 38070 if (!PyErr_Occurred()) { 38071 PyErr_SetString(PyExc_RuntimeError, 38072 "Unexpected error in an Op's C code. " 38073 "No Python exception was set."); 38074 } 38075 goto __label_756;} 38076 } 38077 // This is a TypeError to be consistent with DEBUG_MODE 38078 // Note: DEBUG_MODE also tells the name of the container 38079 if (PyArray_TYPE((PyArrayObject*) py_V755) != NPY_FLOAT64) { 38080 PyErr_Format(PyExc_TypeError, 38081 "expected type_num %d (NPY_FLOAT64) got %d", 38082 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V755)); 38083 { 38084 __failure = 756; 38085 if (!PyErr_Occurred()) { 38086 PyErr_SetString(PyExc_RuntimeError, 38087 "Unexpected error in an Op's C code. " 38088 "No Python exception was set."); 38089 } 38090 goto __label_756;} 38091 } 38092 38093 V755 = (PyArrayObject*)(py_V755); 38094 Py_XINCREF(V755); 38095 38096 { 38097 38098 py_V757 = PyList_GET_ITEM(storage_V757, 0); 38099 {Py_XINCREF(py_V757);} 38100 38101 V757 = NULL; 38102 if (py_V757 == Py_None) { 38103 // We can either fail here or set V757 to NULL and rely on Ops 38104 // using tensors to handle the NULL case, but if they fail to do so 38105 // they'll end up with nasty segfaults, so this is public service. 38106 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 38107 { 38108 __failure = 758; 38109 if (!PyErr_Occurred()) { 38110 PyErr_SetString(PyExc_RuntimeError, 38111 "Unexpected error in an Op's C code. " 38112 "No Python exception was set."); 38113 } 38114 goto __label_758;} 38115 } 38116 if (!PyArray_Check(py_V757)) { 38117 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 38118 { 38119 __failure = 758; 38120 if (!PyErr_Occurred()) { 38121 PyErr_SetString(PyExc_RuntimeError, 38122 "Unexpected error in an Op's C code. " 38123 "No Python exception was set."); 38124 } 38125 goto __label_758;} 38126 } 38127 // We expect NPY_FLOAT64 38128 if (!PyArray_ISALIGNED((PyArrayObject*) py_V757)) { 38129 PyArrayObject * tmp = (PyArrayObject*) py_V757; 38130 PyErr_Format(PyExc_NotImplementedError, 38131 "expected an aligned array of type %ld " 38132 "(NPY_FLOAT64), got non-aligned array of type %ld" 38133 " with %ld dimensions, with 3 last dims " 38134 "%ld, %ld, %ld" 38135 " and 3 last strides %ld %ld, %ld.", 38136 (long int) NPY_FLOAT64, 38137 (long int) PyArray_TYPE((PyArrayObject*) py_V757), 38138 (long int) PyArray_NDIM(tmp), 38139 (long int) (PyArray_NDIM(tmp) >= 3 ? 38140 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 38141 (long int) (PyArray_NDIM(tmp) >= 2 ? 38142 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 38143 (long int) (PyArray_NDIM(tmp) >= 1 ? 38144 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 38145 (long int) (PyArray_NDIM(tmp) >= 3 ? 38146 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 38147 (long int) (PyArray_NDIM(tmp) >= 2 ? 38148 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 38149 (long int) (PyArray_NDIM(tmp) >= 1 ? 38150 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 38151 ); 38152 { 38153 __failure = 758; 38154 if (!PyErr_Occurred()) { 38155 PyErr_SetString(PyExc_RuntimeError, 38156 "Unexpected error in an Op's C code. " 38157 "No Python exception was set."); 38158 } 38159 goto __label_758;} 38160 } 38161 // This is a TypeError to be consistent with DEBUG_MODE 38162 // Note: DEBUG_MODE also tells the name of the container 38163 if (PyArray_TYPE((PyArrayObject*) py_V757) != NPY_FLOAT64) { 38164 PyErr_Format(PyExc_TypeError, 38165 "expected type_num %d (NPY_FLOAT64) got %d", 38166 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V757)); 38167 { 38168 __failure = 758; 38169 if (!PyErr_Occurred()) { 38170 PyErr_SetString(PyExc_RuntimeError, 38171 "Unexpected error in an Op's C code. " 38172 "No Python exception was set."); 38173 } 38174 goto __label_758;} 38175 } 38176 38177 V757 = (PyArrayObject*)(py_V757); 38178 Py_XINCREF(V757); 38179 38180 { 38181 38182 py_V759 = PyList_GET_ITEM(storage_V759, 0); 38183 {Py_XINCREF(py_V759);} 38184 38185 V759 = NULL; 38186 if (py_V759 == Py_None) { 38187 // We can either fail here or set V759 to NULL and rely on Ops 38188 // using tensors to handle the NULL case, but if they fail to do so 38189 // they'll end up with nasty segfaults, so this is public service. 38190 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 38191 { 38192 __failure = 760; 38193 if (!PyErr_Occurred()) { 38194 PyErr_SetString(PyExc_RuntimeError, 38195 "Unexpected error in an Op's C code. " 38196 "No Python exception was set."); 38197 } 38198 goto __label_760;} 38199 } 38200 if (!PyArray_Check(py_V759)) { 38201 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 38202 { 38203 __failure = 760; 38204 if (!PyErr_Occurred()) { 38205 PyErr_SetString(PyExc_RuntimeError, 38206 "Unexpected error in an Op's C code. " 38207 "No Python exception was set."); 38208 } 38209 goto __label_760;} 38210 } 38211 // We expect NPY_FLOAT64 38212 if (!PyArray_ISALIGNED((PyArrayObject*) py_V759)) { 38213 PyArrayObject * tmp = (PyArrayObject*) py_V759; 38214 PyErr_Format(PyExc_NotImplementedError, 38215 "expected an aligned array of type %ld " 38216 "(NPY_FLOAT64), got non-aligned array of type %ld" 38217 " with %ld dimensions, with 3 last dims " 38218 "%ld, %ld, %ld" 38219 " and 3 last strides %ld %ld, %ld.", 38220 (long int) NPY_FLOAT64, 38221 (long int) PyArray_TYPE((PyArrayObject*) py_V759), 38222 (long int) PyArray_NDIM(tmp), 38223 (long int) (PyArray_NDIM(tmp) >= 3 ? 38224 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 38225 (long int) (PyArray_NDIM(tmp) >= 2 ? 38226 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 38227 (long int) (PyArray_NDIM(tmp) >= 1 ? 38228 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 38229 (long int) (PyArray_NDIM(tmp) >= 3 ? 38230 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 38231 (long int) (PyArray_NDIM(tmp) >= 2 ? 38232 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 38233 (long int) (PyArray_NDIM(tmp) >= 1 ? 38234 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 38235 ); 38236 { 38237 __failure = 760; 38238 if (!PyErr_Occurred()) { 38239 PyErr_SetString(PyExc_RuntimeError, 38240 "Unexpected error in an Op's C code. " 38241 "No Python exception was set."); 38242 } 38243 goto __label_760;} 38244 } 38245 // This is a TypeError to be consistent with DEBUG_MODE 38246 // Note: DEBUG_MODE also tells the name of the container 38247 if (PyArray_TYPE((PyArrayObject*) py_V759) != NPY_FLOAT64) { 38248 PyErr_Format(PyExc_TypeError, 38249 "expected type_num %d (NPY_FLOAT64) got %d", 38250 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V759)); 38251 { 38252 __failure = 760; 38253 if (!PyErr_Occurred()) { 38254 PyErr_SetString(PyExc_RuntimeError, 38255 "Unexpected error in an Op's C code. " 38256 "No Python exception was set."); 38257 } 38258 goto __label_760;} 38259 } 38260 38261 V759 = (PyArrayObject*)(py_V759); 38262 Py_XINCREF(V759); 38263 38264 { 38265 38266 py_V761 = PyList_GET_ITEM(storage_V761, 0); 38267 {Py_XINCREF(py_V761);} 38268 38269 V761 = NULL; 38270 if (py_V761 == Py_None) { 38271 // We can either fail here or set V761 to NULL and rely on Ops 38272 // using tensors to handle the NULL case, but if they fail to do so 38273 // they'll end up with nasty segfaults, so this is public service. 38274 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 38275 { 38276 __failure = 762; 38277 if (!PyErr_Occurred()) { 38278 PyErr_SetString(PyExc_RuntimeError, 38279 "Unexpected error in an Op's C code. " 38280 "No Python exception was set."); 38281 } 38282 goto __label_762;} 38283 } 38284 if (!PyArray_Check(py_V761)) { 38285 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 38286 { 38287 __failure = 762; 38288 if (!PyErr_Occurred()) { 38289 PyErr_SetString(PyExc_RuntimeError, 38290 "Unexpected error in an Op's C code. " 38291 "No Python exception was set."); 38292 } 38293 goto __label_762;} 38294 } 38295 // We expect NPY_FLOAT64 38296 if (!PyArray_ISALIGNED((PyArrayObject*) py_V761)) { 38297 PyArrayObject * tmp = (PyArrayObject*) py_V761; 38298 PyErr_Format(PyExc_NotImplementedError, 38299 "expected an aligned array of type %ld " 38300 "(NPY_FLOAT64), got non-aligned array of type %ld" 38301 " with %ld dimensions, with 3 last dims " 38302 "%ld, %ld, %ld" 38303 " and 3 last strides %ld %ld, %ld.", 38304 (long int) NPY_FLOAT64, 38305 (long int) PyArray_TYPE((PyArrayObject*) py_V761), 38306 (long int) PyArray_NDIM(tmp), 38307 (long int) (PyArray_NDIM(tmp) >= 3 ? 38308 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 38309 (long int) (PyArray_NDIM(tmp) >= 2 ? 38310 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 38311 (long int) (PyArray_NDIM(tmp) >= 1 ? 38312 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 38313 (long int) (PyArray_NDIM(tmp) >= 3 ? 38314 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 38315 (long int) (PyArray_NDIM(tmp) >= 2 ? 38316 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 38317 (long int) (PyArray_NDIM(tmp) >= 1 ? 38318 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 38319 ); 38320 { 38321 __failure = 762; 38322 if (!PyErr_Occurred()) { 38323 PyErr_SetString(PyExc_RuntimeError, 38324 "Unexpected error in an Op's C code. " 38325 "No Python exception was set."); 38326 } 38327 goto __label_762;} 38328 } 38329 // This is a TypeError to be consistent with DEBUG_MODE 38330 // Note: DEBUG_MODE also tells the name of the container 38331 if (PyArray_TYPE((PyArrayObject*) py_V761) != NPY_FLOAT64) { 38332 PyErr_Format(PyExc_TypeError, 38333 "expected type_num %d (NPY_FLOAT64) got %d", 38334 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V761)); 38335 { 38336 __failure = 762; 38337 if (!PyErr_Occurred()) { 38338 PyErr_SetString(PyExc_RuntimeError, 38339 "Unexpected error in an Op's C code. " 38340 "No Python exception was set."); 38341 } 38342 goto __label_762;} 38343 } 38344 38345 V761 = (PyArrayObject*)(py_V761); 38346 Py_XINCREF(V761); 38347 38348 { 38349 38350 py_V763 = PyList_GET_ITEM(storage_V763, 0); 38351 {Py_XINCREF(py_V763);} 38352 38353 V763 = NULL; 38354 if (py_V763 == Py_None) { 38355 // We can either fail here or set V763 to NULL and rely on Ops 38356 // using tensors to handle the NULL case, but if they fail to do so 38357 // they'll end up with nasty segfaults, so this is public service. 38358 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 38359 { 38360 __failure = 764; 38361 if (!PyErr_Occurred()) { 38362 PyErr_SetString(PyExc_RuntimeError, 38363 "Unexpected error in an Op's C code. " 38364 "No Python exception was set."); 38365 } 38366 goto __label_764;} 38367 } 38368 if (!PyArray_Check(py_V763)) { 38369 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 38370 { 38371 __failure = 764; 38372 if (!PyErr_Occurred()) { 38373 PyErr_SetString(PyExc_RuntimeError, 38374 "Unexpected error in an Op's C code. " 38375 "No Python exception was set."); 38376 } 38377 goto __label_764;} 38378 } 38379 // We expect NPY_FLOAT64 38380 if (!PyArray_ISALIGNED((PyArrayObject*) py_V763)) { 38381 PyArrayObject * tmp = (PyArrayObject*) py_V763; 38382 PyErr_Format(PyExc_NotImplementedError, 38383 "expected an aligned array of type %ld " 38384 "(NPY_FLOAT64), got non-aligned array of type %ld" 38385 " with %ld dimensions, with 3 last dims " 38386 "%ld, %ld, %ld" 38387 " and 3 last strides %ld %ld, %ld.", 38388 (long int) NPY_FLOAT64, 38389 (long int) PyArray_TYPE((PyArrayObject*) py_V763), 38390 (long int) PyArray_NDIM(tmp), 38391 (long int) (PyArray_NDIM(tmp) >= 3 ? 38392 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 38393 (long int) (PyArray_NDIM(tmp) >= 2 ? 38394 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 38395 (long int) (PyArray_NDIM(tmp) >= 1 ? 38396 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 38397 (long int) (PyArray_NDIM(tmp) >= 3 ? 38398 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 38399 (long int) (PyArray_NDIM(tmp) >= 2 ? 38400 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 38401 (long int) (PyArray_NDIM(tmp) >= 1 ? 38402 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 38403 ); 38404 { 38405 __failure = 764; 38406 if (!PyErr_Occurred()) { 38407 PyErr_SetString(PyExc_RuntimeError, 38408 "Unexpected error in an Op's C code. " 38409 "No Python exception was set."); 38410 } 38411 goto __label_764;} 38412 } 38413 // This is a TypeError to be consistent with DEBUG_MODE 38414 // Note: DEBUG_MODE also tells the name of the container 38415 if (PyArray_TYPE((PyArrayObject*) py_V763) != NPY_FLOAT64) { 38416 PyErr_Format(PyExc_TypeError, 38417 "expected type_num %d (NPY_FLOAT64) got %d", 38418 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V763)); 38419 { 38420 __failure = 764; 38421 if (!PyErr_Occurred()) { 38422 PyErr_SetString(PyExc_RuntimeError, 38423 "Unexpected error in an Op's C code. " 38424 "No Python exception was set."); 38425 } 38426 goto __label_764;} 38427 } 38428 38429 V763 = (PyArrayObject*)(py_V763); 38430 Py_XINCREF(V763); 38431 38432 { 38433 38434 py_V765 = PyList_GET_ITEM(storage_V765, 0); 38435 {Py_XINCREF(py_V765);} 38436 38437 V765 = NULL; 38438 if (py_V765 == Py_None) { 38439 // We can either fail here or set V765 to NULL and rely on Ops 38440 // using tensors to handle the NULL case, but if they fail to do so 38441 // they'll end up with nasty segfaults, so this is public service. 38442 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 38443 { 38444 __failure = 766; 38445 if (!PyErr_Occurred()) { 38446 PyErr_SetString(PyExc_RuntimeError, 38447 "Unexpected error in an Op's C code. " 38448 "No Python exception was set."); 38449 } 38450 goto __label_766;} 38451 } 38452 if (!PyArray_Check(py_V765)) { 38453 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 38454 { 38455 __failure = 766; 38456 if (!PyErr_Occurred()) { 38457 PyErr_SetString(PyExc_RuntimeError, 38458 "Unexpected error in an Op's C code. " 38459 "No Python exception was set."); 38460 } 38461 goto __label_766;} 38462 } 38463 // We expect NPY_FLOAT64 38464 if (!PyArray_ISALIGNED((PyArrayObject*) py_V765)) { 38465 PyArrayObject * tmp = (PyArrayObject*) py_V765; 38466 PyErr_Format(PyExc_NotImplementedError, 38467 "expected an aligned array of type %ld " 38468 "(NPY_FLOAT64), got non-aligned array of type %ld" 38469 " with %ld dimensions, with 3 last dims " 38470 "%ld, %ld, %ld" 38471 " and 3 last strides %ld %ld, %ld.", 38472 (long int) NPY_FLOAT64, 38473 (long int) PyArray_TYPE((PyArrayObject*) py_V765), 38474 (long int) PyArray_NDIM(tmp), 38475 (long int) (PyArray_NDIM(tmp) >= 3 ? 38476 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 38477 (long int) (PyArray_NDIM(tmp) >= 2 ? 38478 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 38479 (long int) (PyArray_NDIM(tmp) >= 1 ? 38480 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 38481 (long int) (PyArray_NDIM(tmp) >= 3 ? 38482 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 38483 (long int) (PyArray_NDIM(tmp) >= 2 ? 38484 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 38485 (long int) (PyArray_NDIM(tmp) >= 1 ? 38486 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 38487 ); 38488 { 38489 __failure = 766; 38490 if (!PyErr_Occurred()) { 38491 PyErr_SetString(PyExc_RuntimeError, 38492 "Unexpected error in an Op's C code. " 38493 "No Python exception was set."); 38494 } 38495 goto __label_766;} 38496 } 38497 // This is a TypeError to be consistent with DEBUG_MODE 38498 // Note: DEBUG_MODE also tells the name of the container 38499 if (PyArray_TYPE((PyArrayObject*) py_V765) != NPY_FLOAT64) { 38500 PyErr_Format(PyExc_TypeError, 38501 "expected type_num %d (NPY_FLOAT64) got %d", 38502 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V765)); 38503 { 38504 __failure = 766; 38505 if (!PyErr_Occurred()) { 38506 PyErr_SetString(PyExc_RuntimeError, 38507 "Unexpected error in an Op's C code. " 38508 "No Python exception was set."); 38509 } 38510 goto __label_766;} 38511 } 38512 38513 V765 = (PyArrayObject*)(py_V765); 38514 Py_XINCREF(V765); 38515 38516 { 38517 38518 py_V767 = PyList_GET_ITEM(storage_V767, 0); 38519 {Py_XINCREF(py_V767);} 38520 38521 V767 = NULL; 38522 if (py_V767 == Py_None) { 38523 // We can either fail here or set V767 to NULL and rely on Ops 38524 // using tensors to handle the NULL case, but if they fail to do so 38525 // they'll end up with nasty segfaults, so this is public service. 38526 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 38527 { 38528 __failure = 768; 38529 if (!PyErr_Occurred()) { 38530 PyErr_SetString(PyExc_RuntimeError, 38531 "Unexpected error in an Op's C code. " 38532 "No Python exception was set."); 38533 } 38534 goto __label_768;} 38535 } 38536 if (!PyArray_Check(py_V767)) { 38537 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 38538 { 38539 __failure = 768; 38540 if (!PyErr_Occurred()) { 38541 PyErr_SetString(PyExc_RuntimeError, 38542 "Unexpected error in an Op's C code. " 38543 "No Python exception was set."); 38544 } 38545 goto __label_768;} 38546 } 38547 // We expect NPY_FLOAT64 38548 if (!PyArray_ISALIGNED((PyArrayObject*) py_V767)) { 38549 PyArrayObject * tmp = (PyArrayObject*) py_V767; 38550 PyErr_Format(PyExc_NotImplementedError, 38551 "expected an aligned array of type %ld " 38552 "(NPY_FLOAT64), got non-aligned array of type %ld" 38553 " with %ld dimensions, with 3 last dims " 38554 "%ld, %ld, %ld" 38555 " and 3 last strides %ld %ld, %ld.", 38556 (long int) NPY_FLOAT64, 38557 (long int) PyArray_TYPE((PyArrayObject*) py_V767), 38558 (long int) PyArray_NDIM(tmp), 38559 (long int) (PyArray_NDIM(tmp) >= 3 ? 38560 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 38561 (long int) (PyArray_NDIM(tmp) >= 2 ? 38562 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 38563 (long int) (PyArray_NDIM(tmp) >= 1 ? 38564 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 38565 (long int) (PyArray_NDIM(tmp) >= 3 ? 38566 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 38567 (long int) (PyArray_NDIM(tmp) >= 2 ? 38568 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 38569 (long int) (PyArray_NDIM(tmp) >= 1 ? 38570 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 38571 ); 38572 { 38573 __failure = 768; 38574 if (!PyErr_Occurred()) { 38575 PyErr_SetString(PyExc_RuntimeError, 38576 "Unexpected error in an Op's C code. " 38577 "No Python exception was set."); 38578 } 38579 goto __label_768;} 38580 } 38581 // This is a TypeError to be consistent with DEBUG_MODE 38582 // Note: DEBUG_MODE also tells the name of the container 38583 if (PyArray_TYPE((PyArrayObject*) py_V767) != NPY_FLOAT64) { 38584 PyErr_Format(PyExc_TypeError, 38585 "expected type_num %d (NPY_FLOAT64) got %d", 38586 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V767)); 38587 { 38588 __failure = 768; 38589 if (!PyErr_Occurred()) { 38590 PyErr_SetString(PyExc_RuntimeError, 38591 "Unexpected error in an Op's C code. " 38592 "No Python exception was set."); 38593 } 38594 goto __label_768;} 38595 } 38596 38597 V767 = (PyArrayObject*)(py_V767); 38598 Py_XINCREF(V767); 38599 38600 { 38601 38602 py_V769 = PyList_GET_ITEM(storage_V769, 0); 38603 {Py_XINCREF(py_V769);} 38604 38605 V769 = NULL; 38606 if (py_V769 == Py_None) { 38607 // We can either fail here or set V769 to NULL and rely on Ops 38608 // using tensors to handle the NULL case, but if they fail to do so 38609 // they'll end up with nasty segfaults, so this is public service. 38610 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 38611 { 38612 __failure = 770; 38613 if (!PyErr_Occurred()) { 38614 PyErr_SetString(PyExc_RuntimeError, 38615 "Unexpected error in an Op's C code. " 38616 "No Python exception was set."); 38617 } 38618 goto __label_770;} 38619 } 38620 if (!PyArray_Check(py_V769)) { 38621 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 38622 { 38623 __failure = 770; 38624 if (!PyErr_Occurred()) { 38625 PyErr_SetString(PyExc_RuntimeError, 38626 "Unexpected error in an Op's C code. " 38627 "No Python exception was set."); 38628 } 38629 goto __label_770;} 38630 } 38631 // We expect NPY_FLOAT64 38632 if (!PyArray_ISALIGNED((PyArrayObject*) py_V769)) { 38633 PyArrayObject * tmp = (PyArrayObject*) py_V769; 38634 PyErr_Format(PyExc_NotImplementedError, 38635 "expected an aligned array of type %ld " 38636 "(NPY_FLOAT64), got non-aligned array of type %ld" 38637 " with %ld dimensions, with 3 last dims " 38638 "%ld, %ld, %ld" 38639 " and 3 last strides %ld %ld, %ld.", 38640 (long int) NPY_FLOAT64, 38641 (long int) PyArray_TYPE((PyArrayObject*) py_V769), 38642 (long int) PyArray_NDIM(tmp), 38643 (long int) (PyArray_NDIM(tmp) >= 3 ? 38644 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 38645 (long int) (PyArray_NDIM(tmp) >= 2 ? 38646 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 38647 (long int) (PyArray_NDIM(tmp) >= 1 ? 38648 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 38649 (long int) (PyArray_NDIM(tmp) >= 3 ? 38650 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 38651 (long int) (PyArray_NDIM(tmp) >= 2 ? 38652 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 38653 (long int) (PyArray_NDIM(tmp) >= 1 ? 38654 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 38655 ); 38656 { 38657 __failure = 770; 38658 if (!PyErr_Occurred()) { 38659 PyErr_SetString(PyExc_RuntimeError, 38660 "Unexpected error in an Op's C code. " 38661 "No Python exception was set."); 38662 } 38663 goto __label_770;} 38664 } 38665 // This is a TypeError to be consistent with DEBUG_MODE 38666 // Note: DEBUG_MODE also tells the name of the container 38667 if (PyArray_TYPE((PyArrayObject*) py_V769) != NPY_FLOAT64) { 38668 PyErr_Format(PyExc_TypeError, 38669 "expected type_num %d (NPY_FLOAT64) got %d", 38670 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V769)); 38671 { 38672 __failure = 770; 38673 if (!PyErr_Occurred()) { 38674 PyErr_SetString(PyExc_RuntimeError, 38675 "Unexpected error in an Op's C code. " 38676 "No Python exception was set."); 38677 } 38678 goto __label_770;} 38679 } 38680 38681 V769 = (PyArrayObject*)(py_V769); 38682 Py_XINCREF(V769); 38683 38684 { 38685 38686 py_V771 = PyList_GET_ITEM(storage_V771, 0); 38687 {Py_XINCREF(py_V771);} 38688 38689 V771 = NULL; 38690 if (py_V771 == Py_None) { 38691 // We can either fail here or set V771 to NULL and rely on Ops 38692 // using tensors to handle the NULL case, but if they fail to do so 38693 // they'll end up with nasty segfaults, so this is public service. 38694 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 38695 { 38696 __failure = 772; 38697 if (!PyErr_Occurred()) { 38698 PyErr_SetString(PyExc_RuntimeError, 38699 "Unexpected error in an Op's C code. " 38700 "No Python exception was set."); 38701 } 38702 goto __label_772;} 38703 } 38704 if (!PyArray_Check(py_V771)) { 38705 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 38706 { 38707 __failure = 772; 38708 if (!PyErr_Occurred()) { 38709 PyErr_SetString(PyExc_RuntimeError, 38710 "Unexpected error in an Op's C code. " 38711 "No Python exception was set."); 38712 } 38713 goto __label_772;} 38714 } 38715 // We expect NPY_FLOAT64 38716 if (!PyArray_ISALIGNED((PyArrayObject*) py_V771)) { 38717 PyArrayObject * tmp = (PyArrayObject*) py_V771; 38718 PyErr_Format(PyExc_NotImplementedError, 38719 "expected an aligned array of type %ld " 38720 "(NPY_FLOAT64), got non-aligned array of type %ld" 38721 " with %ld dimensions, with 3 last dims " 38722 "%ld, %ld, %ld" 38723 " and 3 last strides %ld %ld, %ld.", 38724 (long int) NPY_FLOAT64, 38725 (long int) PyArray_TYPE((PyArrayObject*) py_V771), 38726 (long int) PyArray_NDIM(tmp), 38727 (long int) (PyArray_NDIM(tmp) >= 3 ? 38728 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 38729 (long int) (PyArray_NDIM(tmp) >= 2 ? 38730 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 38731 (long int) (PyArray_NDIM(tmp) >= 1 ? 38732 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 38733 (long int) (PyArray_NDIM(tmp) >= 3 ? 38734 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 38735 (long int) (PyArray_NDIM(tmp) >= 2 ? 38736 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 38737 (long int) (PyArray_NDIM(tmp) >= 1 ? 38738 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 38739 ); 38740 { 38741 __failure = 772; 38742 if (!PyErr_Occurred()) { 38743 PyErr_SetString(PyExc_RuntimeError, 38744 "Unexpected error in an Op's C code. " 38745 "No Python exception was set."); 38746 } 38747 goto __label_772;} 38748 } 38749 // This is a TypeError to be consistent with DEBUG_MODE 38750 // Note: DEBUG_MODE also tells the name of the container 38751 if (PyArray_TYPE((PyArrayObject*) py_V771) != NPY_FLOAT64) { 38752 PyErr_Format(PyExc_TypeError, 38753 "expected type_num %d (NPY_FLOAT64) got %d", 38754 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V771)); 38755 { 38756 __failure = 772; 38757 if (!PyErr_Occurred()) { 38758 PyErr_SetString(PyExc_RuntimeError, 38759 "Unexpected error in an Op's C code. " 38760 "No Python exception was set."); 38761 } 38762 goto __label_772;} 38763 } 38764 38765 V771 = (PyArrayObject*)(py_V771); 38766 Py_XINCREF(V771); 38767 38768 { 38769 38770 py_V773 = PyList_GET_ITEM(storage_V773, 0); 38771 {Py_XINCREF(py_V773);} 38772 38773 V773 = NULL; 38774 if (py_V773 == Py_None) { 38775 // We can either fail here or set V773 to NULL and rely on Ops 38776 // using tensors to handle the NULL case, but if they fail to do so 38777 // they'll end up with nasty segfaults, so this is public service. 38778 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 38779 { 38780 __failure = 774; 38781 if (!PyErr_Occurred()) { 38782 PyErr_SetString(PyExc_RuntimeError, 38783 "Unexpected error in an Op's C code. " 38784 "No Python exception was set."); 38785 } 38786 goto __label_774;} 38787 } 38788 if (!PyArray_Check(py_V773)) { 38789 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 38790 { 38791 __failure = 774; 38792 if (!PyErr_Occurred()) { 38793 PyErr_SetString(PyExc_RuntimeError, 38794 "Unexpected error in an Op's C code. " 38795 "No Python exception was set."); 38796 } 38797 goto __label_774;} 38798 } 38799 // We expect NPY_FLOAT64 38800 if (!PyArray_ISALIGNED((PyArrayObject*) py_V773)) { 38801 PyArrayObject * tmp = (PyArrayObject*) py_V773; 38802 PyErr_Format(PyExc_NotImplementedError, 38803 "expected an aligned array of type %ld " 38804 "(NPY_FLOAT64), got non-aligned array of type %ld" 38805 " with %ld dimensions, with 3 last dims " 38806 "%ld, %ld, %ld" 38807 " and 3 last strides %ld %ld, %ld.", 38808 (long int) NPY_FLOAT64, 38809 (long int) PyArray_TYPE((PyArrayObject*) py_V773), 38810 (long int) PyArray_NDIM(tmp), 38811 (long int) (PyArray_NDIM(tmp) >= 3 ? 38812 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 38813 (long int) (PyArray_NDIM(tmp) >= 2 ? 38814 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 38815 (long int) (PyArray_NDIM(tmp) >= 1 ? 38816 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 38817 (long int) (PyArray_NDIM(tmp) >= 3 ? 38818 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 38819 (long int) (PyArray_NDIM(tmp) >= 2 ? 38820 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 38821 (long int) (PyArray_NDIM(tmp) >= 1 ? 38822 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 38823 ); 38824 { 38825 __failure = 774; 38826 if (!PyErr_Occurred()) { 38827 PyErr_SetString(PyExc_RuntimeError, 38828 "Unexpected error in an Op's C code. " 38829 "No Python exception was set."); 38830 } 38831 goto __label_774;} 38832 } 38833 // This is a TypeError to be consistent with DEBUG_MODE 38834 // Note: DEBUG_MODE also tells the name of the container 38835 if (PyArray_TYPE((PyArrayObject*) py_V773) != NPY_FLOAT64) { 38836 PyErr_Format(PyExc_TypeError, 38837 "expected type_num %d (NPY_FLOAT64) got %d", 38838 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V773)); 38839 { 38840 __failure = 774; 38841 if (!PyErr_Occurred()) { 38842 PyErr_SetString(PyExc_RuntimeError, 38843 "Unexpected error in an Op's C code. " 38844 "No Python exception was set."); 38845 } 38846 goto __label_774;} 38847 } 38848 38849 V773 = (PyArrayObject*)(py_V773); 38850 Py_XINCREF(V773); 38851 38852 { 38853 38854 py_V775 = PyList_GET_ITEM(storage_V775, 0); 38855 {Py_XINCREF(py_V775);} 38856 38857 V775 = NULL; 38858 if (py_V775 == Py_None) { 38859 // We can either fail here or set V775 to NULL and rely on Ops 38860 // using tensors to handle the NULL case, but if they fail to do so 38861 // they'll end up with nasty segfaults, so this is public service. 38862 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 38863 { 38864 __failure = 776; 38865 if (!PyErr_Occurred()) { 38866 PyErr_SetString(PyExc_RuntimeError, 38867 "Unexpected error in an Op's C code. " 38868 "No Python exception was set."); 38869 } 38870 goto __label_776;} 38871 } 38872 if (!PyArray_Check(py_V775)) { 38873 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 38874 { 38875 __failure = 776; 38876 if (!PyErr_Occurred()) { 38877 PyErr_SetString(PyExc_RuntimeError, 38878 "Unexpected error in an Op's C code. " 38879 "No Python exception was set."); 38880 } 38881 goto __label_776;} 38882 } 38883 // We expect NPY_FLOAT64 38884 if (!PyArray_ISALIGNED((PyArrayObject*) py_V775)) { 38885 PyArrayObject * tmp = (PyArrayObject*) py_V775; 38886 PyErr_Format(PyExc_NotImplementedError, 38887 "expected an aligned array of type %ld " 38888 "(NPY_FLOAT64), got non-aligned array of type %ld" 38889 " with %ld dimensions, with 3 last dims " 38890 "%ld, %ld, %ld" 38891 " and 3 last strides %ld %ld, %ld.", 38892 (long int) NPY_FLOAT64, 38893 (long int) PyArray_TYPE((PyArrayObject*) py_V775), 38894 (long int) PyArray_NDIM(tmp), 38895 (long int) (PyArray_NDIM(tmp) >= 3 ? 38896 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 38897 (long int) (PyArray_NDIM(tmp) >= 2 ? 38898 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 38899 (long int) (PyArray_NDIM(tmp) >= 1 ? 38900 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 38901 (long int) (PyArray_NDIM(tmp) >= 3 ? 38902 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 38903 (long int) (PyArray_NDIM(tmp) >= 2 ? 38904 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 38905 (long int) (PyArray_NDIM(tmp) >= 1 ? 38906 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 38907 ); 38908 { 38909 __failure = 776; 38910 if (!PyErr_Occurred()) { 38911 PyErr_SetString(PyExc_RuntimeError, 38912 "Unexpected error in an Op's C code. " 38913 "No Python exception was set."); 38914 } 38915 goto __label_776;} 38916 } 38917 // This is a TypeError to be consistent with DEBUG_MODE 38918 // Note: DEBUG_MODE also tells the name of the container 38919 if (PyArray_TYPE((PyArrayObject*) py_V775) != NPY_FLOAT64) { 38920 PyErr_Format(PyExc_TypeError, 38921 "expected type_num %d (NPY_FLOAT64) got %d", 38922 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V775)); 38923 { 38924 __failure = 776; 38925 if (!PyErr_Occurred()) { 38926 PyErr_SetString(PyExc_RuntimeError, 38927 "Unexpected error in an Op's C code. " 38928 "No Python exception was set."); 38929 } 38930 goto __label_776;} 38931 } 38932 38933 V775 = (PyArrayObject*)(py_V775); 38934 Py_XINCREF(V775); 38935 38936 { 38937 38938 py_V777 = PyList_GET_ITEM(storage_V777, 0); 38939 {Py_XINCREF(py_V777);} 38940 38941 V777 = NULL; 38942 if (py_V777 == Py_None) { 38943 // We can either fail here or set V777 to NULL and rely on Ops 38944 // using tensors to handle the NULL case, but if they fail to do so 38945 // they'll end up with nasty segfaults, so this is public service. 38946 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 38947 { 38948 __failure = 778; 38949 if (!PyErr_Occurred()) { 38950 PyErr_SetString(PyExc_RuntimeError, 38951 "Unexpected error in an Op's C code. " 38952 "No Python exception was set."); 38953 } 38954 goto __label_778;} 38955 } 38956 if (!PyArray_Check(py_V777)) { 38957 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 38958 { 38959 __failure = 778; 38960 if (!PyErr_Occurred()) { 38961 PyErr_SetString(PyExc_RuntimeError, 38962 "Unexpected error in an Op's C code. " 38963 "No Python exception was set."); 38964 } 38965 goto __label_778;} 38966 } 38967 // We expect NPY_FLOAT64 38968 if (!PyArray_ISALIGNED((PyArrayObject*) py_V777)) { 38969 PyArrayObject * tmp = (PyArrayObject*) py_V777; 38970 PyErr_Format(PyExc_NotImplementedError, 38971 "expected an aligned array of type %ld " 38972 "(NPY_FLOAT64), got non-aligned array of type %ld" 38973 " with %ld dimensions, with 3 last dims " 38974 "%ld, %ld, %ld" 38975 " and 3 last strides %ld %ld, %ld.", 38976 (long int) NPY_FLOAT64, 38977 (long int) PyArray_TYPE((PyArrayObject*) py_V777), 38978 (long int) PyArray_NDIM(tmp), 38979 (long int) (PyArray_NDIM(tmp) >= 3 ? 38980 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 38981 (long int) (PyArray_NDIM(tmp) >= 2 ? 38982 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 38983 (long int) (PyArray_NDIM(tmp) >= 1 ? 38984 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 38985 (long int) (PyArray_NDIM(tmp) >= 3 ? 38986 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 38987 (long int) (PyArray_NDIM(tmp) >= 2 ? 38988 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 38989 (long int) (PyArray_NDIM(tmp) >= 1 ? 38990 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 38991 ); 38992 { 38993 __failure = 778; 38994 if (!PyErr_Occurred()) { 38995 PyErr_SetString(PyExc_RuntimeError, 38996 "Unexpected error in an Op's C code. " 38997 "No Python exception was set."); 38998 } 38999 goto __label_778;} 39000 } 39001 // This is a TypeError to be consistent with DEBUG_MODE 39002 // Note: DEBUG_MODE also tells the name of the container 39003 if (PyArray_TYPE((PyArrayObject*) py_V777) != NPY_FLOAT64) { 39004 PyErr_Format(PyExc_TypeError, 39005 "expected type_num %d (NPY_FLOAT64) got %d", 39006 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V777)); 39007 { 39008 __failure = 778; 39009 if (!PyErr_Occurred()) { 39010 PyErr_SetString(PyExc_RuntimeError, 39011 "Unexpected error in an Op's C code. " 39012 "No Python exception was set."); 39013 } 39014 goto __label_778;} 39015 } 39016 39017 V777 = (PyArrayObject*)(py_V777); 39018 Py_XINCREF(V777); 39019 39020 { 39021 39022 py_V779 = PyList_GET_ITEM(storage_V779, 0); 39023 {Py_XINCREF(py_V779);} 39024 39025 V779 = NULL; 39026 if (py_V779 == Py_None) { 39027 // We can either fail here or set V779 to NULL and rely on Ops 39028 // using tensors to handle the NULL case, but if they fail to do so 39029 // they'll end up with nasty segfaults, so this is public service. 39030 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 39031 { 39032 __failure = 780; 39033 if (!PyErr_Occurred()) { 39034 PyErr_SetString(PyExc_RuntimeError, 39035 "Unexpected error in an Op's C code. " 39036 "No Python exception was set."); 39037 } 39038 goto __label_780;} 39039 } 39040 if (!PyArray_Check(py_V779)) { 39041 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 39042 { 39043 __failure = 780; 39044 if (!PyErr_Occurred()) { 39045 PyErr_SetString(PyExc_RuntimeError, 39046 "Unexpected error in an Op's C code. " 39047 "No Python exception was set."); 39048 } 39049 goto __label_780;} 39050 } 39051 // We expect NPY_FLOAT64 39052 if (!PyArray_ISALIGNED((PyArrayObject*) py_V779)) { 39053 PyArrayObject * tmp = (PyArrayObject*) py_V779; 39054 PyErr_Format(PyExc_NotImplementedError, 39055 "expected an aligned array of type %ld " 39056 "(NPY_FLOAT64), got non-aligned array of type %ld" 39057 " with %ld dimensions, with 3 last dims " 39058 "%ld, %ld, %ld" 39059 " and 3 last strides %ld %ld, %ld.", 39060 (long int) NPY_FLOAT64, 39061 (long int) PyArray_TYPE((PyArrayObject*) py_V779), 39062 (long int) PyArray_NDIM(tmp), 39063 (long int) (PyArray_NDIM(tmp) >= 3 ? 39064 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 39065 (long int) (PyArray_NDIM(tmp) >= 2 ? 39066 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 39067 (long int) (PyArray_NDIM(tmp) >= 1 ? 39068 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 39069 (long int) (PyArray_NDIM(tmp) >= 3 ? 39070 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 39071 (long int) (PyArray_NDIM(tmp) >= 2 ? 39072 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 39073 (long int) (PyArray_NDIM(tmp) >= 1 ? 39074 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 39075 ); 39076 { 39077 __failure = 780; 39078 if (!PyErr_Occurred()) { 39079 PyErr_SetString(PyExc_RuntimeError, 39080 "Unexpected error in an Op's C code. " 39081 "No Python exception was set."); 39082 } 39083 goto __label_780;} 39084 } 39085 // This is a TypeError to be consistent with DEBUG_MODE 39086 // Note: DEBUG_MODE also tells the name of the container 39087 if (PyArray_TYPE((PyArrayObject*) py_V779) != NPY_FLOAT64) { 39088 PyErr_Format(PyExc_TypeError, 39089 "expected type_num %d (NPY_FLOAT64) got %d", 39090 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V779)); 39091 { 39092 __failure = 780; 39093 if (!PyErr_Occurred()) { 39094 PyErr_SetString(PyExc_RuntimeError, 39095 "Unexpected error in an Op's C code. " 39096 "No Python exception was set."); 39097 } 39098 goto __label_780;} 39099 } 39100 39101 V779 = (PyArrayObject*)(py_V779); 39102 Py_XINCREF(V779); 39103 39104 { 39105 39106 py_V781 = PyList_GET_ITEM(storage_V781, 0); 39107 {Py_XINCREF(py_V781);} 39108 39109 V781 = NULL; 39110 if (py_V781 == Py_None) { 39111 // We can either fail here or set V781 to NULL and rely on Ops 39112 // using tensors to handle the NULL case, but if they fail to do so 39113 // they'll end up with nasty segfaults, so this is public service. 39114 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 39115 { 39116 __failure = 782; 39117 if (!PyErr_Occurred()) { 39118 PyErr_SetString(PyExc_RuntimeError, 39119 "Unexpected error in an Op's C code. " 39120 "No Python exception was set."); 39121 } 39122 goto __label_782;} 39123 } 39124 if (!PyArray_Check(py_V781)) { 39125 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 39126 { 39127 __failure = 782; 39128 if (!PyErr_Occurred()) { 39129 PyErr_SetString(PyExc_RuntimeError, 39130 "Unexpected error in an Op's C code. " 39131 "No Python exception was set."); 39132 } 39133 goto __label_782;} 39134 } 39135 // We expect NPY_FLOAT64 39136 if (!PyArray_ISALIGNED((PyArrayObject*) py_V781)) { 39137 PyArrayObject * tmp = (PyArrayObject*) py_V781; 39138 PyErr_Format(PyExc_NotImplementedError, 39139 "expected an aligned array of type %ld " 39140 "(NPY_FLOAT64), got non-aligned array of type %ld" 39141 " with %ld dimensions, with 3 last dims " 39142 "%ld, %ld, %ld" 39143 " and 3 last strides %ld %ld, %ld.", 39144 (long int) NPY_FLOAT64, 39145 (long int) PyArray_TYPE((PyArrayObject*) py_V781), 39146 (long int) PyArray_NDIM(tmp), 39147 (long int) (PyArray_NDIM(tmp) >= 3 ? 39148 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 39149 (long int) (PyArray_NDIM(tmp) >= 2 ? 39150 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 39151 (long int) (PyArray_NDIM(tmp) >= 1 ? 39152 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 39153 (long int) (PyArray_NDIM(tmp) >= 3 ? 39154 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 39155 (long int) (PyArray_NDIM(tmp) >= 2 ? 39156 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 39157 (long int) (PyArray_NDIM(tmp) >= 1 ? 39158 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 39159 ); 39160 { 39161 __failure = 782; 39162 if (!PyErr_Occurred()) { 39163 PyErr_SetString(PyExc_RuntimeError, 39164 "Unexpected error in an Op's C code. " 39165 "No Python exception was set."); 39166 } 39167 goto __label_782;} 39168 } 39169 // This is a TypeError to be consistent with DEBUG_MODE 39170 // Note: DEBUG_MODE also tells the name of the container 39171 if (PyArray_TYPE((PyArrayObject*) py_V781) != NPY_FLOAT64) { 39172 PyErr_Format(PyExc_TypeError, 39173 "expected type_num %d (NPY_FLOAT64) got %d", 39174 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V781)); 39175 { 39176 __failure = 782; 39177 if (!PyErr_Occurred()) { 39178 PyErr_SetString(PyExc_RuntimeError, 39179 "Unexpected error in an Op's C code. " 39180 "No Python exception was set."); 39181 } 39182 goto __label_782;} 39183 } 39184 39185 V781 = (PyArrayObject*)(py_V781); 39186 Py_XINCREF(V781); 39187 39188 { 39189 39190 py_V783 = PyList_GET_ITEM(storage_V783, 0); 39191 {Py_XINCREF(py_V783);} 39192 39193 V783 = NULL; 39194 if (py_V783 == Py_None) { 39195 // We can either fail here or set V783 to NULL and rely on Ops 39196 // using tensors to handle the NULL case, but if they fail to do so 39197 // they'll end up with nasty segfaults, so this is public service. 39198 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 39199 { 39200 __failure = 784; 39201 if (!PyErr_Occurred()) { 39202 PyErr_SetString(PyExc_RuntimeError, 39203 "Unexpected error in an Op's C code. " 39204 "No Python exception was set."); 39205 } 39206 goto __label_784;} 39207 } 39208 if (!PyArray_Check(py_V783)) { 39209 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 39210 { 39211 __failure = 784; 39212 if (!PyErr_Occurred()) { 39213 PyErr_SetString(PyExc_RuntimeError, 39214 "Unexpected error in an Op's C code. " 39215 "No Python exception was set."); 39216 } 39217 goto __label_784;} 39218 } 39219 // We expect NPY_FLOAT64 39220 if (!PyArray_ISALIGNED((PyArrayObject*) py_V783)) { 39221 PyArrayObject * tmp = (PyArrayObject*) py_V783; 39222 PyErr_Format(PyExc_NotImplementedError, 39223 "expected an aligned array of type %ld " 39224 "(NPY_FLOAT64), got non-aligned array of type %ld" 39225 " with %ld dimensions, with 3 last dims " 39226 "%ld, %ld, %ld" 39227 " and 3 last strides %ld %ld, %ld.", 39228 (long int) NPY_FLOAT64, 39229 (long int) PyArray_TYPE((PyArrayObject*) py_V783), 39230 (long int) PyArray_NDIM(tmp), 39231 (long int) (PyArray_NDIM(tmp) >= 3 ? 39232 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 39233 (long int) (PyArray_NDIM(tmp) >= 2 ? 39234 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 39235 (long int) (PyArray_NDIM(tmp) >= 1 ? 39236 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 39237 (long int) (PyArray_NDIM(tmp) >= 3 ? 39238 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 39239 (long int) (PyArray_NDIM(tmp) >= 2 ? 39240 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 39241 (long int) (PyArray_NDIM(tmp) >= 1 ? 39242 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 39243 ); 39244 { 39245 __failure = 784; 39246 if (!PyErr_Occurred()) { 39247 PyErr_SetString(PyExc_RuntimeError, 39248 "Unexpected error in an Op's C code. " 39249 "No Python exception was set."); 39250 } 39251 goto __label_784;} 39252 } 39253 // This is a TypeError to be consistent with DEBUG_MODE 39254 // Note: DEBUG_MODE also tells the name of the container 39255 if (PyArray_TYPE((PyArrayObject*) py_V783) != NPY_FLOAT64) { 39256 PyErr_Format(PyExc_TypeError, 39257 "expected type_num %d (NPY_FLOAT64) got %d", 39258 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V783)); 39259 { 39260 __failure = 784; 39261 if (!PyErr_Occurred()) { 39262 PyErr_SetString(PyExc_RuntimeError, 39263 "Unexpected error in an Op's C code. " 39264 "No Python exception was set."); 39265 } 39266 goto __label_784;} 39267 } 39268 39269 V783 = (PyArrayObject*)(py_V783); 39270 Py_XINCREF(V783); 39271 39272 { 39273 39274 py_V785 = PyList_GET_ITEM(storage_V785, 0); 39275 {Py_XINCREF(py_V785);} 39276 39277 V785 = NULL; 39278 if (py_V785 == Py_None) { 39279 // We can either fail here or set V785 to NULL and rely on Ops 39280 // using tensors to handle the NULL case, but if they fail to do so 39281 // they'll end up with nasty segfaults, so this is public service. 39282 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 39283 { 39284 __failure = 786; 39285 if (!PyErr_Occurred()) { 39286 PyErr_SetString(PyExc_RuntimeError, 39287 "Unexpected error in an Op's C code. " 39288 "No Python exception was set."); 39289 } 39290 goto __label_786;} 39291 } 39292 if (!PyArray_Check(py_V785)) { 39293 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 39294 { 39295 __failure = 786; 39296 if (!PyErr_Occurred()) { 39297 PyErr_SetString(PyExc_RuntimeError, 39298 "Unexpected error in an Op's C code. " 39299 "No Python exception was set."); 39300 } 39301 goto __label_786;} 39302 } 39303 // We expect NPY_FLOAT64 39304 if (!PyArray_ISALIGNED((PyArrayObject*) py_V785)) { 39305 PyArrayObject * tmp = (PyArrayObject*) py_V785; 39306 PyErr_Format(PyExc_NotImplementedError, 39307 "expected an aligned array of type %ld " 39308 "(NPY_FLOAT64), got non-aligned array of type %ld" 39309 " with %ld dimensions, with 3 last dims " 39310 "%ld, %ld, %ld" 39311 " and 3 last strides %ld %ld, %ld.", 39312 (long int) NPY_FLOAT64, 39313 (long int) PyArray_TYPE((PyArrayObject*) py_V785), 39314 (long int) PyArray_NDIM(tmp), 39315 (long int) (PyArray_NDIM(tmp) >= 3 ? 39316 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 39317 (long int) (PyArray_NDIM(tmp) >= 2 ? 39318 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 39319 (long int) (PyArray_NDIM(tmp) >= 1 ? 39320 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 39321 (long int) (PyArray_NDIM(tmp) >= 3 ? 39322 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 39323 (long int) (PyArray_NDIM(tmp) >= 2 ? 39324 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 39325 (long int) (PyArray_NDIM(tmp) >= 1 ? 39326 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 39327 ); 39328 { 39329 __failure = 786; 39330 if (!PyErr_Occurred()) { 39331 PyErr_SetString(PyExc_RuntimeError, 39332 "Unexpected error in an Op's C code. " 39333 "No Python exception was set."); 39334 } 39335 goto __label_786;} 39336 } 39337 // This is a TypeError to be consistent with DEBUG_MODE 39338 // Note: DEBUG_MODE also tells the name of the container 39339 if (PyArray_TYPE((PyArrayObject*) py_V785) != NPY_FLOAT64) { 39340 PyErr_Format(PyExc_TypeError, 39341 "expected type_num %d (NPY_FLOAT64) got %d", 39342 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V785)); 39343 { 39344 __failure = 786; 39345 if (!PyErr_Occurred()) { 39346 PyErr_SetString(PyExc_RuntimeError, 39347 "Unexpected error in an Op's C code. " 39348 "No Python exception was set."); 39349 } 39350 goto __label_786;} 39351 } 39352 39353 V785 = (PyArrayObject*)(py_V785); 39354 Py_XINCREF(V785); 39355 39356 { 39357 39358 py_V787 = PyList_GET_ITEM(storage_V787, 0); 39359 {Py_XINCREF(py_V787);} 39360 39361 V787 = NULL; 39362 if (py_V787 == Py_None) { 39363 // We can either fail here or set V787 to NULL and rely on Ops 39364 // using tensors to handle the NULL case, but if they fail to do so 39365 // they'll end up with nasty segfaults, so this is public service. 39366 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 39367 { 39368 __failure = 788; 39369 if (!PyErr_Occurred()) { 39370 PyErr_SetString(PyExc_RuntimeError, 39371 "Unexpected error in an Op's C code. " 39372 "No Python exception was set."); 39373 } 39374 goto __label_788;} 39375 } 39376 if (!PyArray_Check(py_V787)) { 39377 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 39378 { 39379 __failure = 788; 39380 if (!PyErr_Occurred()) { 39381 PyErr_SetString(PyExc_RuntimeError, 39382 "Unexpected error in an Op's C code. " 39383 "No Python exception was set."); 39384 } 39385 goto __label_788;} 39386 } 39387 // We expect NPY_FLOAT64 39388 if (!PyArray_ISALIGNED((PyArrayObject*) py_V787)) { 39389 PyArrayObject * tmp = (PyArrayObject*) py_V787; 39390 PyErr_Format(PyExc_NotImplementedError, 39391 "expected an aligned array of type %ld " 39392 "(NPY_FLOAT64), got non-aligned array of type %ld" 39393 " with %ld dimensions, with 3 last dims " 39394 "%ld, %ld, %ld" 39395 " and 3 last strides %ld %ld, %ld.", 39396 (long int) NPY_FLOAT64, 39397 (long int) PyArray_TYPE((PyArrayObject*) py_V787), 39398 (long int) PyArray_NDIM(tmp), 39399 (long int) (PyArray_NDIM(tmp) >= 3 ? 39400 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 39401 (long int) (PyArray_NDIM(tmp) >= 2 ? 39402 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 39403 (long int) (PyArray_NDIM(tmp) >= 1 ? 39404 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 39405 (long int) (PyArray_NDIM(tmp) >= 3 ? 39406 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 39407 (long int) (PyArray_NDIM(tmp) >= 2 ? 39408 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 39409 (long int) (PyArray_NDIM(tmp) >= 1 ? 39410 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 39411 ); 39412 { 39413 __failure = 788; 39414 if (!PyErr_Occurred()) { 39415 PyErr_SetString(PyExc_RuntimeError, 39416 "Unexpected error in an Op's C code. " 39417 "No Python exception was set."); 39418 } 39419 goto __label_788;} 39420 } 39421 // This is a TypeError to be consistent with DEBUG_MODE 39422 // Note: DEBUG_MODE also tells the name of the container 39423 if (PyArray_TYPE((PyArrayObject*) py_V787) != NPY_FLOAT64) { 39424 PyErr_Format(PyExc_TypeError, 39425 "expected type_num %d (NPY_FLOAT64) got %d", 39426 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V787)); 39427 { 39428 __failure = 788; 39429 if (!PyErr_Occurred()) { 39430 PyErr_SetString(PyExc_RuntimeError, 39431 "Unexpected error in an Op's C code. " 39432 "No Python exception was set."); 39433 } 39434 goto __label_788;} 39435 } 39436 39437 V787 = (PyArrayObject*)(py_V787); 39438 Py_XINCREF(V787); 39439 39440 { 39441 39442 py_V789 = PyList_GET_ITEM(storage_V789, 0); 39443 {Py_XINCREF(py_V789);} 39444 39445 V789 = NULL; 39446 if (py_V789 == Py_None) { 39447 // We can either fail here or set V789 to NULL and rely on Ops 39448 // using tensors to handle the NULL case, but if they fail to do so 39449 // they'll end up with nasty segfaults, so this is public service. 39450 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 39451 { 39452 __failure = 790; 39453 if (!PyErr_Occurred()) { 39454 PyErr_SetString(PyExc_RuntimeError, 39455 "Unexpected error in an Op's C code. " 39456 "No Python exception was set."); 39457 } 39458 goto __label_790;} 39459 } 39460 if (!PyArray_Check(py_V789)) { 39461 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 39462 { 39463 __failure = 790; 39464 if (!PyErr_Occurred()) { 39465 PyErr_SetString(PyExc_RuntimeError, 39466 "Unexpected error in an Op's C code. " 39467 "No Python exception was set."); 39468 } 39469 goto __label_790;} 39470 } 39471 // We expect NPY_FLOAT64 39472 if (!PyArray_ISALIGNED((PyArrayObject*) py_V789)) { 39473 PyArrayObject * tmp = (PyArrayObject*) py_V789; 39474 PyErr_Format(PyExc_NotImplementedError, 39475 "expected an aligned array of type %ld " 39476 "(NPY_FLOAT64), got non-aligned array of type %ld" 39477 " with %ld dimensions, with 3 last dims " 39478 "%ld, %ld, %ld" 39479 " and 3 last strides %ld %ld, %ld.", 39480 (long int) NPY_FLOAT64, 39481 (long int) PyArray_TYPE((PyArrayObject*) py_V789), 39482 (long int) PyArray_NDIM(tmp), 39483 (long int) (PyArray_NDIM(tmp) >= 3 ? 39484 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 39485 (long int) (PyArray_NDIM(tmp) >= 2 ? 39486 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 39487 (long int) (PyArray_NDIM(tmp) >= 1 ? 39488 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 39489 (long int) (PyArray_NDIM(tmp) >= 3 ? 39490 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 39491 (long int) (PyArray_NDIM(tmp) >= 2 ? 39492 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 39493 (long int) (PyArray_NDIM(tmp) >= 1 ? 39494 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 39495 ); 39496 { 39497 __failure = 790; 39498 if (!PyErr_Occurred()) { 39499 PyErr_SetString(PyExc_RuntimeError, 39500 "Unexpected error in an Op's C code. " 39501 "No Python exception was set."); 39502 } 39503 goto __label_790;} 39504 } 39505 // This is a TypeError to be consistent with DEBUG_MODE 39506 // Note: DEBUG_MODE also tells the name of the container 39507 if (PyArray_TYPE((PyArrayObject*) py_V789) != NPY_FLOAT64) { 39508 PyErr_Format(PyExc_TypeError, 39509 "expected type_num %d (NPY_FLOAT64) got %d", 39510 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V789)); 39511 { 39512 __failure = 790; 39513 if (!PyErr_Occurred()) { 39514 PyErr_SetString(PyExc_RuntimeError, 39515 "Unexpected error in an Op's C code. " 39516 "No Python exception was set."); 39517 } 39518 goto __label_790;} 39519 } 39520 39521 V789 = (PyArrayObject*)(py_V789); 39522 Py_XINCREF(V789); 39523 39524 { 39525 39526 py_V791 = PyList_GET_ITEM(storage_V791, 0); 39527 {Py_XINCREF(py_V791);} 39528 39529 V791 = NULL; 39530 if (py_V791 == Py_None) { 39531 // We can either fail here or set V791 to NULL and rely on Ops 39532 // using tensors to handle the NULL case, but if they fail to do so 39533 // they'll end up with nasty segfaults, so this is public service. 39534 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 39535 { 39536 __failure = 792; 39537 if (!PyErr_Occurred()) { 39538 PyErr_SetString(PyExc_RuntimeError, 39539 "Unexpected error in an Op's C code. " 39540 "No Python exception was set."); 39541 } 39542 goto __label_792;} 39543 } 39544 if (!PyArray_Check(py_V791)) { 39545 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 39546 { 39547 __failure = 792; 39548 if (!PyErr_Occurred()) { 39549 PyErr_SetString(PyExc_RuntimeError, 39550 "Unexpected error in an Op's C code. " 39551 "No Python exception was set."); 39552 } 39553 goto __label_792;} 39554 } 39555 // We expect NPY_FLOAT64 39556 if (!PyArray_ISALIGNED((PyArrayObject*) py_V791)) { 39557 PyArrayObject * tmp = (PyArrayObject*) py_V791; 39558 PyErr_Format(PyExc_NotImplementedError, 39559 "expected an aligned array of type %ld " 39560 "(NPY_FLOAT64), got non-aligned array of type %ld" 39561 " with %ld dimensions, with 3 last dims " 39562 "%ld, %ld, %ld" 39563 " and 3 last strides %ld %ld, %ld.", 39564 (long int) NPY_FLOAT64, 39565 (long int) PyArray_TYPE((PyArrayObject*) py_V791), 39566 (long int) PyArray_NDIM(tmp), 39567 (long int) (PyArray_NDIM(tmp) >= 3 ? 39568 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 39569 (long int) (PyArray_NDIM(tmp) >= 2 ? 39570 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 39571 (long int) (PyArray_NDIM(tmp) >= 1 ? 39572 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 39573 (long int) (PyArray_NDIM(tmp) >= 3 ? 39574 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 39575 (long int) (PyArray_NDIM(tmp) >= 2 ? 39576 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 39577 (long int) (PyArray_NDIM(tmp) >= 1 ? 39578 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 39579 ); 39580 { 39581 __failure = 792; 39582 if (!PyErr_Occurred()) { 39583 PyErr_SetString(PyExc_RuntimeError, 39584 "Unexpected error in an Op's C code. " 39585 "No Python exception was set."); 39586 } 39587 goto __label_792;} 39588 } 39589 // This is a TypeError to be consistent with DEBUG_MODE 39590 // Note: DEBUG_MODE also tells the name of the container 39591 if (PyArray_TYPE((PyArrayObject*) py_V791) != NPY_FLOAT64) { 39592 PyErr_Format(PyExc_TypeError, 39593 "expected type_num %d (NPY_FLOAT64) got %d", 39594 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V791)); 39595 { 39596 __failure = 792; 39597 if (!PyErr_Occurred()) { 39598 PyErr_SetString(PyExc_RuntimeError, 39599 "Unexpected error in an Op's C code. " 39600 "No Python exception was set."); 39601 } 39602 goto __label_792;} 39603 } 39604 39605 V791 = (PyArrayObject*)(py_V791); 39606 Py_XINCREF(V791); 39607 39608 { 39609 39610 py_V793 = PyList_GET_ITEM(storage_V793, 0); 39611 {Py_XINCREF(py_V793);} 39612 39613 V793 = NULL; 39614 if (py_V793 == Py_None) { 39615 // We can either fail here or set V793 to NULL and rely on Ops 39616 // using tensors to handle the NULL case, but if they fail to do so 39617 // they'll end up with nasty segfaults, so this is public service. 39618 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 39619 { 39620 __failure = 794; 39621 if (!PyErr_Occurred()) { 39622 PyErr_SetString(PyExc_RuntimeError, 39623 "Unexpected error in an Op's C code. " 39624 "No Python exception was set."); 39625 } 39626 goto __label_794;} 39627 } 39628 if (!PyArray_Check(py_V793)) { 39629 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 39630 { 39631 __failure = 794; 39632 if (!PyErr_Occurred()) { 39633 PyErr_SetString(PyExc_RuntimeError, 39634 "Unexpected error in an Op's C code. " 39635 "No Python exception was set."); 39636 } 39637 goto __label_794;} 39638 } 39639 // We expect NPY_FLOAT64 39640 if (!PyArray_ISALIGNED((PyArrayObject*) py_V793)) { 39641 PyArrayObject * tmp = (PyArrayObject*) py_V793; 39642 PyErr_Format(PyExc_NotImplementedError, 39643 "expected an aligned array of type %ld " 39644 "(NPY_FLOAT64), got non-aligned array of type %ld" 39645 " with %ld dimensions, with 3 last dims " 39646 "%ld, %ld, %ld" 39647 " and 3 last strides %ld %ld, %ld.", 39648 (long int) NPY_FLOAT64, 39649 (long int) PyArray_TYPE((PyArrayObject*) py_V793), 39650 (long int) PyArray_NDIM(tmp), 39651 (long int) (PyArray_NDIM(tmp) >= 3 ? 39652 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 39653 (long int) (PyArray_NDIM(tmp) >= 2 ? 39654 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 39655 (long int) (PyArray_NDIM(tmp) >= 1 ? 39656 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 39657 (long int) (PyArray_NDIM(tmp) >= 3 ? 39658 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 39659 (long int) (PyArray_NDIM(tmp) >= 2 ? 39660 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 39661 (long int) (PyArray_NDIM(tmp) >= 1 ? 39662 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 39663 ); 39664 { 39665 __failure = 794; 39666 if (!PyErr_Occurred()) { 39667 PyErr_SetString(PyExc_RuntimeError, 39668 "Unexpected error in an Op's C code. " 39669 "No Python exception was set."); 39670 } 39671 goto __label_794;} 39672 } 39673 // This is a TypeError to be consistent with DEBUG_MODE 39674 // Note: DEBUG_MODE also tells the name of the container 39675 if (PyArray_TYPE((PyArrayObject*) py_V793) != NPY_FLOAT64) { 39676 PyErr_Format(PyExc_TypeError, 39677 "expected type_num %d (NPY_FLOAT64) got %d", 39678 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V793)); 39679 { 39680 __failure = 794; 39681 if (!PyErr_Occurred()) { 39682 PyErr_SetString(PyExc_RuntimeError, 39683 "Unexpected error in an Op's C code. " 39684 "No Python exception was set."); 39685 } 39686 goto __label_794;} 39687 } 39688 39689 V793 = (PyArrayObject*)(py_V793); 39690 Py_XINCREF(V793); 39691 39692 { 39693 39694 py_V795 = PyList_GET_ITEM(storage_V795, 0); 39695 {Py_XINCREF(py_V795);} 39696 39697 V795 = NULL; 39698 if (py_V795 == Py_None) { 39699 // We can either fail here or set V795 to NULL and rely on Ops 39700 // using tensors to handle the NULL case, but if they fail to do so 39701 // they'll end up with nasty segfaults, so this is public service. 39702 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 39703 { 39704 __failure = 796; 39705 if (!PyErr_Occurred()) { 39706 PyErr_SetString(PyExc_RuntimeError, 39707 "Unexpected error in an Op's C code. " 39708 "No Python exception was set."); 39709 } 39710 goto __label_796;} 39711 } 39712 if (!PyArray_Check(py_V795)) { 39713 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 39714 { 39715 __failure = 796; 39716 if (!PyErr_Occurred()) { 39717 PyErr_SetString(PyExc_RuntimeError, 39718 "Unexpected error in an Op's C code. " 39719 "No Python exception was set."); 39720 } 39721 goto __label_796;} 39722 } 39723 // We expect NPY_FLOAT64 39724 if (!PyArray_ISALIGNED((PyArrayObject*) py_V795)) { 39725 PyArrayObject * tmp = (PyArrayObject*) py_V795; 39726 PyErr_Format(PyExc_NotImplementedError, 39727 "expected an aligned array of type %ld " 39728 "(NPY_FLOAT64), got non-aligned array of type %ld" 39729 " with %ld dimensions, with 3 last dims " 39730 "%ld, %ld, %ld" 39731 " and 3 last strides %ld %ld, %ld.", 39732 (long int) NPY_FLOAT64, 39733 (long int) PyArray_TYPE((PyArrayObject*) py_V795), 39734 (long int) PyArray_NDIM(tmp), 39735 (long int) (PyArray_NDIM(tmp) >= 3 ? 39736 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 39737 (long int) (PyArray_NDIM(tmp) >= 2 ? 39738 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 39739 (long int) (PyArray_NDIM(tmp) >= 1 ? 39740 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 39741 (long int) (PyArray_NDIM(tmp) >= 3 ? 39742 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 39743 (long int) (PyArray_NDIM(tmp) >= 2 ? 39744 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 39745 (long int) (PyArray_NDIM(tmp) >= 1 ? 39746 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 39747 ); 39748 { 39749 __failure = 796; 39750 if (!PyErr_Occurred()) { 39751 PyErr_SetString(PyExc_RuntimeError, 39752 "Unexpected error in an Op's C code. " 39753 "No Python exception was set."); 39754 } 39755 goto __label_796;} 39756 } 39757 // This is a TypeError to be consistent with DEBUG_MODE 39758 // Note: DEBUG_MODE also tells the name of the container 39759 if (PyArray_TYPE((PyArrayObject*) py_V795) != NPY_FLOAT64) { 39760 PyErr_Format(PyExc_TypeError, 39761 "expected type_num %d (NPY_FLOAT64) got %d", 39762 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V795)); 39763 { 39764 __failure = 796; 39765 if (!PyErr_Occurred()) { 39766 PyErr_SetString(PyExc_RuntimeError, 39767 "Unexpected error in an Op's C code. " 39768 "No Python exception was set."); 39769 } 39770 goto __label_796;} 39771 } 39772 39773 V795 = (PyArrayObject*)(py_V795); 39774 Py_XINCREF(V795); 39775 39776 { 39777 39778 py_V797 = PyList_GET_ITEM(storage_V797, 0); 39779 {Py_XINCREF(py_V797);} 39780 39781 V797 = NULL; 39782 if (py_V797 == Py_None) { 39783 // We can either fail here or set V797 to NULL and rely on Ops 39784 // using tensors to handle the NULL case, but if they fail to do so 39785 // they'll end up with nasty segfaults, so this is public service. 39786 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 39787 { 39788 __failure = 798; 39789 if (!PyErr_Occurred()) { 39790 PyErr_SetString(PyExc_RuntimeError, 39791 "Unexpected error in an Op's C code. " 39792 "No Python exception was set."); 39793 } 39794 goto __label_798;} 39795 } 39796 if (!PyArray_Check(py_V797)) { 39797 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 39798 { 39799 __failure = 798; 39800 if (!PyErr_Occurred()) { 39801 PyErr_SetString(PyExc_RuntimeError, 39802 "Unexpected error in an Op's C code. " 39803 "No Python exception was set."); 39804 } 39805 goto __label_798;} 39806 } 39807 // We expect NPY_FLOAT64 39808 if (!PyArray_ISALIGNED((PyArrayObject*) py_V797)) { 39809 PyArrayObject * tmp = (PyArrayObject*) py_V797; 39810 PyErr_Format(PyExc_NotImplementedError, 39811 "expected an aligned array of type %ld " 39812 "(NPY_FLOAT64), got non-aligned array of type %ld" 39813 " with %ld dimensions, with 3 last dims " 39814 "%ld, %ld, %ld" 39815 " and 3 last strides %ld %ld, %ld.", 39816 (long int) NPY_FLOAT64, 39817 (long int) PyArray_TYPE((PyArrayObject*) py_V797), 39818 (long int) PyArray_NDIM(tmp), 39819 (long int) (PyArray_NDIM(tmp) >= 3 ? 39820 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 39821 (long int) (PyArray_NDIM(tmp) >= 2 ? 39822 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 39823 (long int) (PyArray_NDIM(tmp) >= 1 ? 39824 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 39825 (long int) (PyArray_NDIM(tmp) >= 3 ? 39826 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 39827 (long int) (PyArray_NDIM(tmp) >= 2 ? 39828 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 39829 (long int) (PyArray_NDIM(tmp) >= 1 ? 39830 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 39831 ); 39832 { 39833 __failure = 798; 39834 if (!PyErr_Occurred()) { 39835 PyErr_SetString(PyExc_RuntimeError, 39836 "Unexpected error in an Op's C code. " 39837 "No Python exception was set."); 39838 } 39839 goto __label_798;} 39840 } 39841 // This is a TypeError to be consistent with DEBUG_MODE 39842 // Note: DEBUG_MODE also tells the name of the container 39843 if (PyArray_TYPE((PyArrayObject*) py_V797) != NPY_FLOAT64) { 39844 PyErr_Format(PyExc_TypeError, 39845 "expected type_num %d (NPY_FLOAT64) got %d", 39846 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V797)); 39847 { 39848 __failure = 798; 39849 if (!PyErr_Occurred()) { 39850 PyErr_SetString(PyExc_RuntimeError, 39851 "Unexpected error in an Op's C code. " 39852 "No Python exception was set."); 39853 } 39854 goto __label_798;} 39855 } 39856 39857 V797 = (PyArrayObject*)(py_V797); 39858 Py_XINCREF(V797); 39859 39860 { 39861 39862 py_V799 = PyList_GET_ITEM(storage_V799, 0); 39863 {Py_XINCREF(py_V799);} 39864 39865 V799 = NULL; 39866 if (py_V799 == Py_None) { 39867 // We can either fail here or set V799 to NULL and rely on Ops 39868 // using tensors to handle the NULL case, but if they fail to do so 39869 // they'll end up with nasty segfaults, so this is public service. 39870 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 39871 { 39872 __failure = 800; 39873 if (!PyErr_Occurred()) { 39874 PyErr_SetString(PyExc_RuntimeError, 39875 "Unexpected error in an Op's C code. " 39876 "No Python exception was set."); 39877 } 39878 goto __label_800;} 39879 } 39880 if (!PyArray_Check(py_V799)) { 39881 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 39882 { 39883 __failure = 800; 39884 if (!PyErr_Occurred()) { 39885 PyErr_SetString(PyExc_RuntimeError, 39886 "Unexpected error in an Op's C code. " 39887 "No Python exception was set."); 39888 } 39889 goto __label_800;} 39890 } 39891 // We expect NPY_FLOAT64 39892 if (!PyArray_ISALIGNED((PyArrayObject*) py_V799)) { 39893 PyArrayObject * tmp = (PyArrayObject*) py_V799; 39894 PyErr_Format(PyExc_NotImplementedError, 39895 "expected an aligned array of type %ld " 39896 "(NPY_FLOAT64), got non-aligned array of type %ld" 39897 " with %ld dimensions, with 3 last dims " 39898 "%ld, %ld, %ld" 39899 " and 3 last strides %ld %ld, %ld.", 39900 (long int) NPY_FLOAT64, 39901 (long int) PyArray_TYPE((PyArrayObject*) py_V799), 39902 (long int) PyArray_NDIM(tmp), 39903 (long int) (PyArray_NDIM(tmp) >= 3 ? 39904 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 39905 (long int) (PyArray_NDIM(tmp) >= 2 ? 39906 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 39907 (long int) (PyArray_NDIM(tmp) >= 1 ? 39908 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 39909 (long int) (PyArray_NDIM(tmp) >= 3 ? 39910 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 39911 (long int) (PyArray_NDIM(tmp) >= 2 ? 39912 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 39913 (long int) (PyArray_NDIM(tmp) >= 1 ? 39914 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 39915 ); 39916 { 39917 __failure = 800; 39918 if (!PyErr_Occurred()) { 39919 PyErr_SetString(PyExc_RuntimeError, 39920 "Unexpected error in an Op's C code. " 39921 "No Python exception was set."); 39922 } 39923 goto __label_800;} 39924 } 39925 // This is a TypeError to be consistent with DEBUG_MODE 39926 // Note: DEBUG_MODE also tells the name of the container 39927 if (PyArray_TYPE((PyArrayObject*) py_V799) != NPY_FLOAT64) { 39928 PyErr_Format(PyExc_TypeError, 39929 "expected type_num %d (NPY_FLOAT64) got %d", 39930 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V799)); 39931 { 39932 __failure = 800; 39933 if (!PyErr_Occurred()) { 39934 PyErr_SetString(PyExc_RuntimeError, 39935 "Unexpected error in an Op's C code. " 39936 "No Python exception was set."); 39937 } 39938 goto __label_800;} 39939 } 39940 39941 V799 = (PyArrayObject*)(py_V799); 39942 Py_XINCREF(V799); 39943 39944 { 39945 39946 py_V801 = PyList_GET_ITEM(storage_V801, 0); 39947 {Py_XINCREF(py_V801);} 39948 39949 V801 = NULL; 39950 if (py_V801 == Py_None) { 39951 // We can either fail here or set V801 to NULL and rely on Ops 39952 // using tensors to handle the NULL case, but if they fail to do so 39953 // they'll end up with nasty segfaults, so this is public service. 39954 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 39955 { 39956 __failure = 802; 39957 if (!PyErr_Occurred()) { 39958 PyErr_SetString(PyExc_RuntimeError, 39959 "Unexpected error in an Op's C code. " 39960 "No Python exception was set."); 39961 } 39962 goto __label_802;} 39963 } 39964 if (!PyArray_Check(py_V801)) { 39965 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 39966 { 39967 __failure = 802; 39968 if (!PyErr_Occurred()) { 39969 PyErr_SetString(PyExc_RuntimeError, 39970 "Unexpected error in an Op's C code. " 39971 "No Python exception was set."); 39972 } 39973 goto __label_802;} 39974 } 39975 // We expect NPY_FLOAT64 39976 if (!PyArray_ISALIGNED((PyArrayObject*) py_V801)) { 39977 PyArrayObject * tmp = (PyArrayObject*) py_V801; 39978 PyErr_Format(PyExc_NotImplementedError, 39979 "expected an aligned array of type %ld " 39980 "(NPY_FLOAT64), got non-aligned array of type %ld" 39981 " with %ld dimensions, with 3 last dims " 39982 "%ld, %ld, %ld" 39983 " and 3 last strides %ld %ld, %ld.", 39984 (long int) NPY_FLOAT64, 39985 (long int) PyArray_TYPE((PyArrayObject*) py_V801), 39986 (long int) PyArray_NDIM(tmp), 39987 (long int) (PyArray_NDIM(tmp) >= 3 ? 39988 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 39989 (long int) (PyArray_NDIM(tmp) >= 2 ? 39990 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 39991 (long int) (PyArray_NDIM(tmp) >= 1 ? 39992 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 39993 (long int) (PyArray_NDIM(tmp) >= 3 ? 39994 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 39995 (long int) (PyArray_NDIM(tmp) >= 2 ? 39996 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 39997 (long int) (PyArray_NDIM(tmp) >= 1 ? 39998 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 39999 ); 40000 { 40001 __failure = 802; 40002 if (!PyErr_Occurred()) { 40003 PyErr_SetString(PyExc_RuntimeError, 40004 "Unexpected error in an Op's C code. " 40005 "No Python exception was set."); 40006 } 40007 goto __label_802;} 40008 } 40009 // This is a TypeError to be consistent with DEBUG_MODE 40010 // Note: DEBUG_MODE also tells the name of the container 40011 if (PyArray_TYPE((PyArrayObject*) py_V801) != NPY_FLOAT64) { 40012 PyErr_Format(PyExc_TypeError, 40013 "expected type_num %d (NPY_FLOAT64) got %d", 40014 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V801)); 40015 { 40016 __failure = 802; 40017 if (!PyErr_Occurred()) { 40018 PyErr_SetString(PyExc_RuntimeError, 40019 "Unexpected error in an Op's C code. " 40020 "No Python exception was set."); 40021 } 40022 goto __label_802;} 40023 } 40024 40025 V801 = (PyArrayObject*)(py_V801); 40026 Py_XINCREF(V801); 40027 40028 { 40029 40030 py_V803 = PyList_GET_ITEM(storage_V803, 0); 40031 {Py_XINCREF(py_V803);} 40032 40033 V803 = NULL; 40034 if (py_V803 == Py_None) { 40035 // We can either fail here or set V803 to NULL and rely on Ops 40036 // using tensors to handle the NULL case, but if they fail to do so 40037 // they'll end up with nasty segfaults, so this is public service. 40038 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 40039 { 40040 __failure = 804; 40041 if (!PyErr_Occurred()) { 40042 PyErr_SetString(PyExc_RuntimeError, 40043 "Unexpected error in an Op's C code. " 40044 "No Python exception was set."); 40045 } 40046 goto __label_804;} 40047 } 40048 if (!PyArray_Check(py_V803)) { 40049 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 40050 { 40051 __failure = 804; 40052 if (!PyErr_Occurred()) { 40053 PyErr_SetString(PyExc_RuntimeError, 40054 "Unexpected error in an Op's C code. " 40055 "No Python exception was set."); 40056 } 40057 goto __label_804;} 40058 } 40059 // We expect NPY_FLOAT64 40060 if (!PyArray_ISALIGNED((PyArrayObject*) py_V803)) { 40061 PyArrayObject * tmp = (PyArrayObject*) py_V803; 40062 PyErr_Format(PyExc_NotImplementedError, 40063 "expected an aligned array of type %ld " 40064 "(NPY_FLOAT64), got non-aligned array of type %ld" 40065 " with %ld dimensions, with 3 last dims " 40066 "%ld, %ld, %ld" 40067 " and 3 last strides %ld %ld, %ld.", 40068 (long int) NPY_FLOAT64, 40069 (long int) PyArray_TYPE((PyArrayObject*) py_V803), 40070 (long int) PyArray_NDIM(tmp), 40071 (long int) (PyArray_NDIM(tmp) >= 3 ? 40072 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 40073 (long int) (PyArray_NDIM(tmp) >= 2 ? 40074 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 40075 (long int) (PyArray_NDIM(tmp) >= 1 ? 40076 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 40077 (long int) (PyArray_NDIM(tmp) >= 3 ? 40078 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 40079 (long int) (PyArray_NDIM(tmp) >= 2 ? 40080 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 40081 (long int) (PyArray_NDIM(tmp) >= 1 ? 40082 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 40083 ); 40084 { 40085 __failure = 804; 40086 if (!PyErr_Occurred()) { 40087 PyErr_SetString(PyExc_RuntimeError, 40088 "Unexpected error in an Op's C code. " 40089 "No Python exception was set."); 40090 } 40091 goto __label_804;} 40092 } 40093 // This is a TypeError to be consistent with DEBUG_MODE 40094 // Note: DEBUG_MODE also tells the name of the container 40095 if (PyArray_TYPE((PyArrayObject*) py_V803) != NPY_FLOAT64) { 40096 PyErr_Format(PyExc_TypeError, 40097 "expected type_num %d (NPY_FLOAT64) got %d", 40098 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V803)); 40099 { 40100 __failure = 804; 40101 if (!PyErr_Occurred()) { 40102 PyErr_SetString(PyExc_RuntimeError, 40103 "Unexpected error in an Op's C code. " 40104 "No Python exception was set."); 40105 } 40106 goto __label_804;} 40107 } 40108 40109 V803 = (PyArrayObject*)(py_V803); 40110 Py_XINCREF(V803); 40111 40112 { 40113 40114 py_V805 = PyList_GET_ITEM(storage_V805, 0); 40115 {Py_XINCREF(py_V805);} 40116 40117 V805 = NULL; 40118 if (py_V805 == Py_None) { 40119 // We can either fail here or set V805 to NULL and rely on Ops 40120 // using tensors to handle the NULL case, but if they fail to do so 40121 // they'll end up with nasty segfaults, so this is public service. 40122 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 40123 { 40124 __failure = 806; 40125 if (!PyErr_Occurred()) { 40126 PyErr_SetString(PyExc_RuntimeError, 40127 "Unexpected error in an Op's C code. " 40128 "No Python exception was set."); 40129 } 40130 goto __label_806;} 40131 } 40132 if (!PyArray_Check(py_V805)) { 40133 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 40134 { 40135 __failure = 806; 40136 if (!PyErr_Occurred()) { 40137 PyErr_SetString(PyExc_RuntimeError, 40138 "Unexpected error in an Op's C code. " 40139 "No Python exception was set."); 40140 } 40141 goto __label_806;} 40142 } 40143 // We expect NPY_FLOAT64 40144 if (!PyArray_ISALIGNED((PyArrayObject*) py_V805)) { 40145 PyArrayObject * tmp = (PyArrayObject*) py_V805; 40146 PyErr_Format(PyExc_NotImplementedError, 40147 "expected an aligned array of type %ld " 40148 "(NPY_FLOAT64), got non-aligned array of type %ld" 40149 " with %ld dimensions, with 3 last dims " 40150 "%ld, %ld, %ld" 40151 " and 3 last strides %ld %ld, %ld.", 40152 (long int) NPY_FLOAT64, 40153 (long int) PyArray_TYPE((PyArrayObject*) py_V805), 40154 (long int) PyArray_NDIM(tmp), 40155 (long int) (PyArray_NDIM(tmp) >= 3 ? 40156 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 40157 (long int) (PyArray_NDIM(tmp) >= 2 ? 40158 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 40159 (long int) (PyArray_NDIM(tmp) >= 1 ? 40160 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 40161 (long int) (PyArray_NDIM(tmp) >= 3 ? 40162 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 40163 (long int) (PyArray_NDIM(tmp) >= 2 ? 40164 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 40165 (long int) (PyArray_NDIM(tmp) >= 1 ? 40166 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 40167 ); 40168 { 40169 __failure = 806; 40170 if (!PyErr_Occurred()) { 40171 PyErr_SetString(PyExc_RuntimeError, 40172 "Unexpected error in an Op's C code. " 40173 "No Python exception was set."); 40174 } 40175 goto __label_806;} 40176 } 40177 // This is a TypeError to be consistent with DEBUG_MODE 40178 // Note: DEBUG_MODE also tells the name of the container 40179 if (PyArray_TYPE((PyArrayObject*) py_V805) != NPY_FLOAT64) { 40180 PyErr_Format(PyExc_TypeError, 40181 "expected type_num %d (NPY_FLOAT64) got %d", 40182 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V805)); 40183 { 40184 __failure = 806; 40185 if (!PyErr_Occurred()) { 40186 PyErr_SetString(PyExc_RuntimeError, 40187 "Unexpected error in an Op's C code. " 40188 "No Python exception was set."); 40189 } 40190 goto __label_806;} 40191 } 40192 40193 V805 = (PyArrayObject*)(py_V805); 40194 Py_XINCREF(V805); 40195 40196 { 40197 40198 py_V807 = PyList_GET_ITEM(storage_V807, 0); 40199 {Py_XINCREF(py_V807);} 40200 40201 V807 = NULL; 40202 if (py_V807 == Py_None) { 40203 // We can either fail here or set V807 to NULL and rely on Ops 40204 // using tensors to handle the NULL case, but if they fail to do so 40205 // they'll end up with nasty segfaults, so this is public service. 40206 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 40207 { 40208 __failure = 808; 40209 if (!PyErr_Occurred()) { 40210 PyErr_SetString(PyExc_RuntimeError, 40211 "Unexpected error in an Op's C code. " 40212 "No Python exception was set."); 40213 } 40214 goto __label_808;} 40215 } 40216 if (!PyArray_Check(py_V807)) { 40217 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 40218 { 40219 __failure = 808; 40220 if (!PyErr_Occurred()) { 40221 PyErr_SetString(PyExc_RuntimeError, 40222 "Unexpected error in an Op's C code. " 40223 "No Python exception was set."); 40224 } 40225 goto __label_808;} 40226 } 40227 // We expect NPY_FLOAT64 40228 if (!PyArray_ISALIGNED((PyArrayObject*) py_V807)) { 40229 PyArrayObject * tmp = (PyArrayObject*) py_V807; 40230 PyErr_Format(PyExc_NotImplementedError, 40231 "expected an aligned array of type %ld " 40232 "(NPY_FLOAT64), got non-aligned array of type %ld" 40233 " with %ld dimensions, with 3 last dims " 40234 "%ld, %ld, %ld" 40235 " and 3 last strides %ld %ld, %ld.", 40236 (long int) NPY_FLOAT64, 40237 (long int) PyArray_TYPE((PyArrayObject*) py_V807), 40238 (long int) PyArray_NDIM(tmp), 40239 (long int) (PyArray_NDIM(tmp) >= 3 ? 40240 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 40241 (long int) (PyArray_NDIM(tmp) >= 2 ? 40242 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 40243 (long int) (PyArray_NDIM(tmp) >= 1 ? 40244 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 40245 (long int) (PyArray_NDIM(tmp) >= 3 ? 40246 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 40247 (long int) (PyArray_NDIM(tmp) >= 2 ? 40248 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 40249 (long int) (PyArray_NDIM(tmp) >= 1 ? 40250 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 40251 ); 40252 { 40253 __failure = 808; 40254 if (!PyErr_Occurred()) { 40255 PyErr_SetString(PyExc_RuntimeError, 40256 "Unexpected error in an Op's C code. " 40257 "No Python exception was set."); 40258 } 40259 goto __label_808;} 40260 } 40261 // This is a TypeError to be consistent with DEBUG_MODE 40262 // Note: DEBUG_MODE also tells the name of the container 40263 if (PyArray_TYPE((PyArrayObject*) py_V807) != NPY_FLOAT64) { 40264 PyErr_Format(PyExc_TypeError, 40265 "expected type_num %d (NPY_FLOAT64) got %d", 40266 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V807)); 40267 { 40268 __failure = 808; 40269 if (!PyErr_Occurred()) { 40270 PyErr_SetString(PyExc_RuntimeError, 40271 "Unexpected error in an Op's C code. " 40272 "No Python exception was set."); 40273 } 40274 goto __label_808;} 40275 } 40276 40277 V807 = (PyArrayObject*)(py_V807); 40278 Py_XINCREF(V807); 40279 40280 { 40281 40282 py_V809 = PyList_GET_ITEM(storage_V809, 0); 40283 {Py_XINCREF(py_V809);} 40284 40285 V809 = NULL; 40286 if (py_V809 == Py_None) { 40287 // We can either fail here or set V809 to NULL and rely on Ops 40288 // using tensors to handle the NULL case, but if they fail to do so 40289 // they'll end up with nasty segfaults, so this is public service. 40290 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 40291 { 40292 __failure = 810; 40293 if (!PyErr_Occurred()) { 40294 PyErr_SetString(PyExc_RuntimeError, 40295 "Unexpected error in an Op's C code. " 40296 "No Python exception was set."); 40297 } 40298 goto __label_810;} 40299 } 40300 if (!PyArray_Check(py_V809)) { 40301 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 40302 { 40303 __failure = 810; 40304 if (!PyErr_Occurred()) { 40305 PyErr_SetString(PyExc_RuntimeError, 40306 "Unexpected error in an Op's C code. " 40307 "No Python exception was set."); 40308 } 40309 goto __label_810;} 40310 } 40311 // We expect NPY_FLOAT64 40312 if (!PyArray_ISALIGNED((PyArrayObject*) py_V809)) { 40313 PyArrayObject * tmp = (PyArrayObject*) py_V809; 40314 PyErr_Format(PyExc_NotImplementedError, 40315 "expected an aligned array of type %ld " 40316 "(NPY_FLOAT64), got non-aligned array of type %ld" 40317 " with %ld dimensions, with 3 last dims " 40318 "%ld, %ld, %ld" 40319 " and 3 last strides %ld %ld, %ld.", 40320 (long int) NPY_FLOAT64, 40321 (long int) PyArray_TYPE((PyArrayObject*) py_V809), 40322 (long int) PyArray_NDIM(tmp), 40323 (long int) (PyArray_NDIM(tmp) >= 3 ? 40324 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 40325 (long int) (PyArray_NDIM(tmp) >= 2 ? 40326 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 40327 (long int) (PyArray_NDIM(tmp) >= 1 ? 40328 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 40329 (long int) (PyArray_NDIM(tmp) >= 3 ? 40330 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 40331 (long int) (PyArray_NDIM(tmp) >= 2 ? 40332 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 40333 (long int) (PyArray_NDIM(tmp) >= 1 ? 40334 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 40335 ); 40336 { 40337 __failure = 810; 40338 if (!PyErr_Occurred()) { 40339 PyErr_SetString(PyExc_RuntimeError, 40340 "Unexpected error in an Op's C code. " 40341 "No Python exception was set."); 40342 } 40343 goto __label_810;} 40344 } 40345 // This is a TypeError to be consistent with DEBUG_MODE 40346 // Note: DEBUG_MODE also tells the name of the container 40347 if (PyArray_TYPE((PyArrayObject*) py_V809) != NPY_FLOAT64) { 40348 PyErr_Format(PyExc_TypeError, 40349 "expected type_num %d (NPY_FLOAT64) got %d", 40350 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V809)); 40351 { 40352 __failure = 810; 40353 if (!PyErr_Occurred()) { 40354 PyErr_SetString(PyExc_RuntimeError, 40355 "Unexpected error in an Op's C code. " 40356 "No Python exception was set."); 40357 } 40358 goto __label_810;} 40359 } 40360 40361 V809 = (PyArrayObject*)(py_V809); 40362 Py_XINCREF(V809); 40363 40364 { 40365 40366 py_V811 = PyList_GET_ITEM(storage_V811, 0); 40367 {Py_XINCREF(py_V811);} 40368 40369 V811 = NULL; 40370 if (py_V811 == Py_None) { 40371 // We can either fail here or set V811 to NULL and rely on Ops 40372 // using tensors to handle the NULL case, but if they fail to do so 40373 // they'll end up with nasty segfaults, so this is public service. 40374 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 40375 { 40376 __failure = 812; 40377 if (!PyErr_Occurred()) { 40378 PyErr_SetString(PyExc_RuntimeError, 40379 "Unexpected error in an Op's C code. " 40380 "No Python exception was set."); 40381 } 40382 goto __label_812;} 40383 } 40384 if (!PyArray_Check(py_V811)) { 40385 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 40386 { 40387 __failure = 812; 40388 if (!PyErr_Occurred()) { 40389 PyErr_SetString(PyExc_RuntimeError, 40390 "Unexpected error in an Op's C code. " 40391 "No Python exception was set."); 40392 } 40393 goto __label_812;} 40394 } 40395 // We expect NPY_FLOAT64 40396 if (!PyArray_ISALIGNED((PyArrayObject*) py_V811)) { 40397 PyArrayObject * tmp = (PyArrayObject*) py_V811; 40398 PyErr_Format(PyExc_NotImplementedError, 40399 "expected an aligned array of type %ld " 40400 "(NPY_FLOAT64), got non-aligned array of type %ld" 40401 " with %ld dimensions, with 3 last dims " 40402 "%ld, %ld, %ld" 40403 " and 3 last strides %ld %ld, %ld.", 40404 (long int) NPY_FLOAT64, 40405 (long int) PyArray_TYPE((PyArrayObject*) py_V811), 40406 (long int) PyArray_NDIM(tmp), 40407 (long int) (PyArray_NDIM(tmp) >= 3 ? 40408 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 40409 (long int) (PyArray_NDIM(tmp) >= 2 ? 40410 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 40411 (long int) (PyArray_NDIM(tmp) >= 1 ? 40412 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 40413 (long int) (PyArray_NDIM(tmp) >= 3 ? 40414 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 40415 (long int) (PyArray_NDIM(tmp) >= 2 ? 40416 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 40417 (long int) (PyArray_NDIM(tmp) >= 1 ? 40418 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 40419 ); 40420 { 40421 __failure = 812; 40422 if (!PyErr_Occurred()) { 40423 PyErr_SetString(PyExc_RuntimeError, 40424 "Unexpected error in an Op's C code. " 40425 "No Python exception was set."); 40426 } 40427 goto __label_812;} 40428 } 40429 // This is a TypeError to be consistent with DEBUG_MODE 40430 // Note: DEBUG_MODE also tells the name of the container 40431 if (PyArray_TYPE((PyArrayObject*) py_V811) != NPY_FLOAT64) { 40432 PyErr_Format(PyExc_TypeError, 40433 "expected type_num %d (NPY_FLOAT64) got %d", 40434 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V811)); 40435 { 40436 __failure = 812; 40437 if (!PyErr_Occurred()) { 40438 PyErr_SetString(PyExc_RuntimeError, 40439 "Unexpected error in an Op's C code. " 40440 "No Python exception was set."); 40441 } 40442 goto __label_812;} 40443 } 40444 40445 V811 = (PyArrayObject*)(py_V811); 40446 Py_XINCREF(V811); 40447 40448 { 40449 40450 py_V813 = PyList_GET_ITEM(storage_V813, 0); 40451 {Py_XINCREF(py_V813);} 40452 40453 V813 = NULL; 40454 if (py_V813 == Py_None) { 40455 // We can either fail here or set V813 to NULL and rely on Ops 40456 // using tensors to handle the NULL case, but if they fail to do so 40457 // they'll end up with nasty segfaults, so this is public service. 40458 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 40459 { 40460 __failure = 814; 40461 if (!PyErr_Occurred()) { 40462 PyErr_SetString(PyExc_RuntimeError, 40463 "Unexpected error in an Op's C code. " 40464 "No Python exception was set."); 40465 } 40466 goto __label_814;} 40467 } 40468 if (!PyArray_Check(py_V813)) { 40469 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 40470 { 40471 __failure = 814; 40472 if (!PyErr_Occurred()) { 40473 PyErr_SetString(PyExc_RuntimeError, 40474 "Unexpected error in an Op's C code. " 40475 "No Python exception was set."); 40476 } 40477 goto __label_814;} 40478 } 40479 // We expect NPY_FLOAT64 40480 if (!PyArray_ISALIGNED((PyArrayObject*) py_V813)) { 40481 PyArrayObject * tmp = (PyArrayObject*) py_V813; 40482 PyErr_Format(PyExc_NotImplementedError, 40483 "expected an aligned array of type %ld " 40484 "(NPY_FLOAT64), got non-aligned array of type %ld" 40485 " with %ld dimensions, with 3 last dims " 40486 "%ld, %ld, %ld" 40487 " and 3 last strides %ld %ld, %ld.", 40488 (long int) NPY_FLOAT64, 40489 (long int) PyArray_TYPE((PyArrayObject*) py_V813), 40490 (long int) PyArray_NDIM(tmp), 40491 (long int) (PyArray_NDIM(tmp) >= 3 ? 40492 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 40493 (long int) (PyArray_NDIM(tmp) >= 2 ? 40494 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 40495 (long int) (PyArray_NDIM(tmp) >= 1 ? 40496 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 40497 (long int) (PyArray_NDIM(tmp) >= 3 ? 40498 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 40499 (long int) (PyArray_NDIM(tmp) >= 2 ? 40500 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 40501 (long int) (PyArray_NDIM(tmp) >= 1 ? 40502 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 40503 ); 40504 { 40505 __failure = 814; 40506 if (!PyErr_Occurred()) { 40507 PyErr_SetString(PyExc_RuntimeError, 40508 "Unexpected error in an Op's C code. " 40509 "No Python exception was set."); 40510 } 40511 goto __label_814;} 40512 } 40513 // This is a TypeError to be consistent with DEBUG_MODE 40514 // Note: DEBUG_MODE also tells the name of the container 40515 if (PyArray_TYPE((PyArrayObject*) py_V813) != NPY_FLOAT64) { 40516 PyErr_Format(PyExc_TypeError, 40517 "expected type_num %d (NPY_FLOAT64) got %d", 40518 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V813)); 40519 { 40520 __failure = 814; 40521 if (!PyErr_Occurred()) { 40522 PyErr_SetString(PyExc_RuntimeError, 40523 "Unexpected error in an Op's C code. " 40524 "No Python exception was set."); 40525 } 40526 goto __label_814;} 40527 } 40528 40529 V813 = (PyArrayObject*)(py_V813); 40530 Py_XINCREF(V813); 40531 40532 { 40533 40534 py_V815 = PyList_GET_ITEM(storage_V815, 0); 40535 {Py_XINCREF(py_V815);} 40536 40537 V815 = NULL; 40538 if (py_V815 == Py_None) { 40539 // We can either fail here or set V815 to NULL and rely on Ops 40540 // using tensors to handle the NULL case, but if they fail to do so 40541 // they'll end up with nasty segfaults, so this is public service. 40542 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 40543 { 40544 __failure = 816; 40545 if (!PyErr_Occurred()) { 40546 PyErr_SetString(PyExc_RuntimeError, 40547 "Unexpected error in an Op's C code. " 40548 "No Python exception was set."); 40549 } 40550 goto __label_816;} 40551 } 40552 if (!PyArray_Check(py_V815)) { 40553 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 40554 { 40555 __failure = 816; 40556 if (!PyErr_Occurred()) { 40557 PyErr_SetString(PyExc_RuntimeError, 40558 "Unexpected error in an Op's C code. " 40559 "No Python exception was set."); 40560 } 40561 goto __label_816;} 40562 } 40563 // We expect NPY_FLOAT64 40564 if (!PyArray_ISALIGNED((PyArrayObject*) py_V815)) { 40565 PyArrayObject * tmp = (PyArrayObject*) py_V815; 40566 PyErr_Format(PyExc_NotImplementedError, 40567 "expected an aligned array of type %ld " 40568 "(NPY_FLOAT64), got non-aligned array of type %ld" 40569 " with %ld dimensions, with 3 last dims " 40570 "%ld, %ld, %ld" 40571 " and 3 last strides %ld %ld, %ld.", 40572 (long int) NPY_FLOAT64, 40573 (long int) PyArray_TYPE((PyArrayObject*) py_V815), 40574 (long int) PyArray_NDIM(tmp), 40575 (long int) (PyArray_NDIM(tmp) >= 3 ? 40576 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 40577 (long int) (PyArray_NDIM(tmp) >= 2 ? 40578 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 40579 (long int) (PyArray_NDIM(tmp) >= 1 ? 40580 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 40581 (long int) (PyArray_NDIM(tmp) >= 3 ? 40582 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 40583 (long int) (PyArray_NDIM(tmp) >= 2 ? 40584 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 40585 (long int) (PyArray_NDIM(tmp) >= 1 ? 40586 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 40587 ); 40588 { 40589 __failure = 816; 40590 if (!PyErr_Occurred()) { 40591 PyErr_SetString(PyExc_RuntimeError, 40592 "Unexpected error in an Op's C code. " 40593 "No Python exception was set."); 40594 } 40595 goto __label_816;} 40596 } 40597 // This is a TypeError to be consistent with DEBUG_MODE 40598 // Note: DEBUG_MODE also tells the name of the container 40599 if (PyArray_TYPE((PyArrayObject*) py_V815) != NPY_FLOAT64) { 40600 PyErr_Format(PyExc_TypeError, 40601 "expected type_num %d (NPY_FLOAT64) got %d", 40602 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V815)); 40603 { 40604 __failure = 816; 40605 if (!PyErr_Occurred()) { 40606 PyErr_SetString(PyExc_RuntimeError, 40607 "Unexpected error in an Op's C code. " 40608 "No Python exception was set."); 40609 } 40610 goto __label_816;} 40611 } 40612 40613 V815 = (PyArrayObject*)(py_V815); 40614 Py_XINCREF(V815); 40615 40616 { 40617 40618 py_V817 = PyList_GET_ITEM(storage_V817, 0); 40619 {Py_XINCREF(py_V817);} 40620 40621 V817 = NULL; 40622 if (py_V817 == Py_None) { 40623 // We can either fail here or set V817 to NULL and rely on Ops 40624 // using tensors to handle the NULL case, but if they fail to do so 40625 // they'll end up with nasty segfaults, so this is public service. 40626 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 40627 { 40628 __failure = 818; 40629 if (!PyErr_Occurred()) { 40630 PyErr_SetString(PyExc_RuntimeError, 40631 "Unexpected error in an Op's C code. " 40632 "No Python exception was set."); 40633 } 40634 goto __label_818;} 40635 } 40636 if (!PyArray_Check(py_V817)) { 40637 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 40638 { 40639 __failure = 818; 40640 if (!PyErr_Occurred()) { 40641 PyErr_SetString(PyExc_RuntimeError, 40642 "Unexpected error in an Op's C code. " 40643 "No Python exception was set."); 40644 } 40645 goto __label_818;} 40646 } 40647 // We expect NPY_FLOAT64 40648 if (!PyArray_ISALIGNED((PyArrayObject*) py_V817)) { 40649 PyArrayObject * tmp = (PyArrayObject*) py_V817; 40650 PyErr_Format(PyExc_NotImplementedError, 40651 "expected an aligned array of type %ld " 40652 "(NPY_FLOAT64), got non-aligned array of type %ld" 40653 " with %ld dimensions, with 3 last dims " 40654 "%ld, %ld, %ld" 40655 " and 3 last strides %ld %ld, %ld.", 40656 (long int) NPY_FLOAT64, 40657 (long int) PyArray_TYPE((PyArrayObject*) py_V817), 40658 (long int) PyArray_NDIM(tmp), 40659 (long int) (PyArray_NDIM(tmp) >= 3 ? 40660 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 40661 (long int) (PyArray_NDIM(tmp) >= 2 ? 40662 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 40663 (long int) (PyArray_NDIM(tmp) >= 1 ? 40664 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 40665 (long int) (PyArray_NDIM(tmp) >= 3 ? 40666 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 40667 (long int) (PyArray_NDIM(tmp) >= 2 ? 40668 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 40669 (long int) (PyArray_NDIM(tmp) >= 1 ? 40670 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 40671 ); 40672 { 40673 __failure = 818; 40674 if (!PyErr_Occurred()) { 40675 PyErr_SetString(PyExc_RuntimeError, 40676 "Unexpected error in an Op's C code. " 40677 "No Python exception was set."); 40678 } 40679 goto __label_818;} 40680 } 40681 // This is a TypeError to be consistent with DEBUG_MODE 40682 // Note: DEBUG_MODE also tells the name of the container 40683 if (PyArray_TYPE((PyArrayObject*) py_V817) != NPY_FLOAT64) { 40684 PyErr_Format(PyExc_TypeError, 40685 "expected type_num %d (NPY_FLOAT64) got %d", 40686 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V817)); 40687 { 40688 __failure = 818; 40689 if (!PyErr_Occurred()) { 40690 PyErr_SetString(PyExc_RuntimeError, 40691 "Unexpected error in an Op's C code. " 40692 "No Python exception was set."); 40693 } 40694 goto __label_818;} 40695 } 40696 40697 V817 = (PyArrayObject*)(py_V817); 40698 Py_XINCREF(V817); 40699 40700 { 40701 40702 py_V819 = PyList_GET_ITEM(storage_V819, 0); 40703 {Py_XINCREF(py_V819);} 40704 40705 V819 = NULL; 40706 if (py_V819 == Py_None) { 40707 // We can either fail here or set V819 to NULL and rely on Ops 40708 // using tensors to handle the NULL case, but if they fail to do so 40709 // they'll end up with nasty segfaults, so this is public service. 40710 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 40711 { 40712 __failure = 820; 40713 if (!PyErr_Occurred()) { 40714 PyErr_SetString(PyExc_RuntimeError, 40715 "Unexpected error in an Op's C code. " 40716 "No Python exception was set."); 40717 } 40718 goto __label_820;} 40719 } 40720 if (!PyArray_Check(py_V819)) { 40721 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 40722 { 40723 __failure = 820; 40724 if (!PyErr_Occurred()) { 40725 PyErr_SetString(PyExc_RuntimeError, 40726 "Unexpected error in an Op's C code. " 40727 "No Python exception was set."); 40728 } 40729 goto __label_820;} 40730 } 40731 // We expect NPY_FLOAT64 40732 if (!PyArray_ISALIGNED((PyArrayObject*) py_V819)) { 40733 PyArrayObject * tmp = (PyArrayObject*) py_V819; 40734 PyErr_Format(PyExc_NotImplementedError, 40735 "expected an aligned array of type %ld " 40736 "(NPY_FLOAT64), got non-aligned array of type %ld" 40737 " with %ld dimensions, with 3 last dims " 40738 "%ld, %ld, %ld" 40739 " and 3 last strides %ld %ld, %ld.", 40740 (long int) NPY_FLOAT64, 40741 (long int) PyArray_TYPE((PyArrayObject*) py_V819), 40742 (long int) PyArray_NDIM(tmp), 40743 (long int) (PyArray_NDIM(tmp) >= 3 ? 40744 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 40745 (long int) (PyArray_NDIM(tmp) >= 2 ? 40746 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 40747 (long int) (PyArray_NDIM(tmp) >= 1 ? 40748 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 40749 (long int) (PyArray_NDIM(tmp) >= 3 ? 40750 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 40751 (long int) (PyArray_NDIM(tmp) >= 2 ? 40752 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 40753 (long int) (PyArray_NDIM(tmp) >= 1 ? 40754 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 40755 ); 40756 { 40757 __failure = 820; 40758 if (!PyErr_Occurred()) { 40759 PyErr_SetString(PyExc_RuntimeError, 40760 "Unexpected error in an Op's C code. " 40761 "No Python exception was set."); 40762 } 40763 goto __label_820;} 40764 } 40765 // This is a TypeError to be consistent with DEBUG_MODE 40766 // Note: DEBUG_MODE also tells the name of the container 40767 if (PyArray_TYPE((PyArrayObject*) py_V819) != NPY_FLOAT64) { 40768 PyErr_Format(PyExc_TypeError, 40769 "expected type_num %d (NPY_FLOAT64) got %d", 40770 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V819)); 40771 { 40772 __failure = 820; 40773 if (!PyErr_Occurred()) { 40774 PyErr_SetString(PyExc_RuntimeError, 40775 "Unexpected error in an Op's C code. " 40776 "No Python exception was set."); 40777 } 40778 goto __label_820;} 40779 } 40780 40781 V819 = (PyArrayObject*)(py_V819); 40782 Py_XINCREF(V819); 40783 40784 { 40785 40786 py_V821 = PyList_GET_ITEM(storage_V821, 0); 40787 {Py_XINCREF(py_V821);} 40788 40789 V821 = NULL; 40790 if (py_V821 == Py_None) { 40791 // We can either fail here or set V821 to NULL and rely on Ops 40792 // using tensors to handle the NULL case, but if they fail to do so 40793 // they'll end up with nasty segfaults, so this is public service. 40794 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 40795 { 40796 __failure = 822; 40797 if (!PyErr_Occurred()) { 40798 PyErr_SetString(PyExc_RuntimeError, 40799 "Unexpected error in an Op's C code. " 40800 "No Python exception was set."); 40801 } 40802 goto __label_822;} 40803 } 40804 if (!PyArray_Check(py_V821)) { 40805 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 40806 { 40807 __failure = 822; 40808 if (!PyErr_Occurred()) { 40809 PyErr_SetString(PyExc_RuntimeError, 40810 "Unexpected error in an Op's C code. " 40811 "No Python exception was set."); 40812 } 40813 goto __label_822;} 40814 } 40815 // We expect NPY_FLOAT64 40816 if (!PyArray_ISALIGNED((PyArrayObject*) py_V821)) { 40817 PyArrayObject * tmp = (PyArrayObject*) py_V821; 40818 PyErr_Format(PyExc_NotImplementedError, 40819 "expected an aligned array of type %ld " 40820 "(NPY_FLOAT64), got non-aligned array of type %ld" 40821 " with %ld dimensions, with 3 last dims " 40822 "%ld, %ld, %ld" 40823 " and 3 last strides %ld %ld, %ld.", 40824 (long int) NPY_FLOAT64, 40825 (long int) PyArray_TYPE((PyArrayObject*) py_V821), 40826 (long int) PyArray_NDIM(tmp), 40827 (long int) (PyArray_NDIM(tmp) >= 3 ? 40828 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 40829 (long int) (PyArray_NDIM(tmp) >= 2 ? 40830 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 40831 (long int) (PyArray_NDIM(tmp) >= 1 ? 40832 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 40833 (long int) (PyArray_NDIM(tmp) >= 3 ? 40834 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 40835 (long int) (PyArray_NDIM(tmp) >= 2 ? 40836 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 40837 (long int) (PyArray_NDIM(tmp) >= 1 ? 40838 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 40839 ); 40840 { 40841 __failure = 822; 40842 if (!PyErr_Occurred()) { 40843 PyErr_SetString(PyExc_RuntimeError, 40844 "Unexpected error in an Op's C code. " 40845 "No Python exception was set."); 40846 } 40847 goto __label_822;} 40848 } 40849 // This is a TypeError to be consistent with DEBUG_MODE 40850 // Note: DEBUG_MODE also tells the name of the container 40851 if (PyArray_TYPE((PyArrayObject*) py_V821) != NPY_FLOAT64) { 40852 PyErr_Format(PyExc_TypeError, 40853 "expected type_num %d (NPY_FLOAT64) got %d", 40854 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V821)); 40855 { 40856 __failure = 822; 40857 if (!PyErr_Occurred()) { 40858 PyErr_SetString(PyExc_RuntimeError, 40859 "Unexpected error in an Op's C code. " 40860 "No Python exception was set."); 40861 } 40862 goto __label_822;} 40863 } 40864 40865 V821 = (PyArrayObject*)(py_V821); 40866 Py_XINCREF(V821); 40867 40868 { 40869 40870 py_V823 = PyList_GET_ITEM(storage_V823, 0); 40871 {Py_XINCREF(py_V823);} 40872 40873 V823 = NULL; 40874 if (py_V823 == Py_None) { 40875 // We can either fail here or set V823 to NULL and rely on Ops 40876 // using tensors to handle the NULL case, but if they fail to do so 40877 // they'll end up with nasty segfaults, so this is public service. 40878 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 40879 { 40880 __failure = 824; 40881 if (!PyErr_Occurred()) { 40882 PyErr_SetString(PyExc_RuntimeError, 40883 "Unexpected error in an Op's C code. " 40884 "No Python exception was set."); 40885 } 40886 goto __label_824;} 40887 } 40888 if (!PyArray_Check(py_V823)) { 40889 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 40890 { 40891 __failure = 824; 40892 if (!PyErr_Occurred()) { 40893 PyErr_SetString(PyExc_RuntimeError, 40894 "Unexpected error in an Op's C code. " 40895 "No Python exception was set."); 40896 } 40897 goto __label_824;} 40898 } 40899 // We expect NPY_FLOAT64 40900 if (!PyArray_ISALIGNED((PyArrayObject*) py_V823)) { 40901 PyArrayObject * tmp = (PyArrayObject*) py_V823; 40902 PyErr_Format(PyExc_NotImplementedError, 40903 "expected an aligned array of type %ld " 40904 "(NPY_FLOAT64), got non-aligned array of type %ld" 40905 " with %ld dimensions, with 3 last dims " 40906 "%ld, %ld, %ld" 40907 " and 3 last strides %ld %ld, %ld.", 40908 (long int) NPY_FLOAT64, 40909 (long int) PyArray_TYPE((PyArrayObject*) py_V823), 40910 (long int) PyArray_NDIM(tmp), 40911 (long int) (PyArray_NDIM(tmp) >= 3 ? 40912 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 40913 (long int) (PyArray_NDIM(tmp) >= 2 ? 40914 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 40915 (long int) (PyArray_NDIM(tmp) >= 1 ? 40916 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 40917 (long int) (PyArray_NDIM(tmp) >= 3 ? 40918 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 40919 (long int) (PyArray_NDIM(tmp) >= 2 ? 40920 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 40921 (long int) (PyArray_NDIM(tmp) >= 1 ? 40922 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 40923 ); 40924 { 40925 __failure = 824; 40926 if (!PyErr_Occurred()) { 40927 PyErr_SetString(PyExc_RuntimeError, 40928 "Unexpected error in an Op's C code. " 40929 "No Python exception was set."); 40930 } 40931 goto __label_824;} 40932 } 40933 // This is a TypeError to be consistent with DEBUG_MODE 40934 // Note: DEBUG_MODE also tells the name of the container 40935 if (PyArray_TYPE((PyArrayObject*) py_V823) != NPY_FLOAT64) { 40936 PyErr_Format(PyExc_TypeError, 40937 "expected type_num %d (NPY_FLOAT64) got %d", 40938 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V823)); 40939 { 40940 __failure = 824; 40941 if (!PyErr_Occurred()) { 40942 PyErr_SetString(PyExc_RuntimeError, 40943 "Unexpected error in an Op's C code. " 40944 "No Python exception was set."); 40945 } 40946 goto __label_824;} 40947 } 40948 40949 V823 = (PyArrayObject*)(py_V823); 40950 Py_XINCREF(V823); 40951 40952 { 40953 40954 py_V825 = PyList_GET_ITEM(storage_V825, 0); 40955 {Py_XINCREF(py_V825);} 40956 40957 V825 = NULL; 40958 if (py_V825 == Py_None) { 40959 // We can either fail here or set V825 to NULL and rely on Ops 40960 // using tensors to handle the NULL case, but if they fail to do so 40961 // they'll end up with nasty segfaults, so this is public service. 40962 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 40963 { 40964 __failure = 826; 40965 if (!PyErr_Occurred()) { 40966 PyErr_SetString(PyExc_RuntimeError, 40967 "Unexpected error in an Op's C code. " 40968 "No Python exception was set."); 40969 } 40970 goto __label_826;} 40971 } 40972 if (!PyArray_Check(py_V825)) { 40973 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 40974 { 40975 __failure = 826; 40976 if (!PyErr_Occurred()) { 40977 PyErr_SetString(PyExc_RuntimeError, 40978 "Unexpected error in an Op's C code. " 40979 "No Python exception was set."); 40980 } 40981 goto __label_826;} 40982 } 40983 // We expect NPY_FLOAT64 40984 if (!PyArray_ISALIGNED((PyArrayObject*) py_V825)) { 40985 PyArrayObject * tmp = (PyArrayObject*) py_V825; 40986 PyErr_Format(PyExc_NotImplementedError, 40987 "expected an aligned array of type %ld " 40988 "(NPY_FLOAT64), got non-aligned array of type %ld" 40989 " with %ld dimensions, with 3 last dims " 40990 "%ld, %ld, %ld" 40991 " and 3 last strides %ld %ld, %ld.", 40992 (long int) NPY_FLOAT64, 40993 (long int) PyArray_TYPE((PyArrayObject*) py_V825), 40994 (long int) PyArray_NDIM(tmp), 40995 (long int) (PyArray_NDIM(tmp) >= 3 ? 40996 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 40997 (long int) (PyArray_NDIM(tmp) >= 2 ? 40998 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 40999 (long int) (PyArray_NDIM(tmp) >= 1 ? 41000 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 41001 (long int) (PyArray_NDIM(tmp) >= 3 ? 41002 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 41003 (long int) (PyArray_NDIM(tmp) >= 2 ? 41004 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 41005 (long int) (PyArray_NDIM(tmp) >= 1 ? 41006 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 41007 ); 41008 { 41009 __failure = 826; 41010 if (!PyErr_Occurred()) { 41011 PyErr_SetString(PyExc_RuntimeError, 41012 "Unexpected error in an Op's C code. " 41013 "No Python exception was set."); 41014 } 41015 goto __label_826;} 41016 } 41017 // This is a TypeError to be consistent with DEBUG_MODE 41018 // Note: DEBUG_MODE also tells the name of the container 41019 if (PyArray_TYPE((PyArrayObject*) py_V825) != NPY_FLOAT64) { 41020 PyErr_Format(PyExc_TypeError, 41021 "expected type_num %d (NPY_FLOAT64) got %d", 41022 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V825)); 41023 { 41024 __failure = 826; 41025 if (!PyErr_Occurred()) { 41026 PyErr_SetString(PyExc_RuntimeError, 41027 "Unexpected error in an Op's C code. " 41028 "No Python exception was set."); 41029 } 41030 goto __label_826;} 41031 } 41032 41033 V825 = (PyArrayObject*)(py_V825); 41034 Py_XINCREF(V825); 41035 41036 { 41037 41038 py_V827 = PyList_GET_ITEM(storage_V827, 0); 41039 {Py_XINCREF(py_V827);} 41040 41041 V827 = NULL; 41042 if (py_V827 == Py_None) { 41043 // We can either fail here or set V827 to NULL and rely on Ops 41044 // using tensors to handle the NULL case, but if they fail to do so 41045 // they'll end up with nasty segfaults, so this is public service. 41046 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 41047 { 41048 __failure = 828; 41049 if (!PyErr_Occurred()) { 41050 PyErr_SetString(PyExc_RuntimeError, 41051 "Unexpected error in an Op's C code. " 41052 "No Python exception was set."); 41053 } 41054 goto __label_828;} 41055 } 41056 if (!PyArray_Check(py_V827)) { 41057 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 41058 { 41059 __failure = 828; 41060 if (!PyErr_Occurred()) { 41061 PyErr_SetString(PyExc_RuntimeError, 41062 "Unexpected error in an Op's C code. " 41063 "No Python exception was set."); 41064 } 41065 goto __label_828;} 41066 } 41067 // We expect NPY_FLOAT64 41068 if (!PyArray_ISALIGNED((PyArrayObject*) py_V827)) { 41069 PyArrayObject * tmp = (PyArrayObject*) py_V827; 41070 PyErr_Format(PyExc_NotImplementedError, 41071 "expected an aligned array of type %ld " 41072 "(NPY_FLOAT64), got non-aligned array of type %ld" 41073 " with %ld dimensions, with 3 last dims " 41074 "%ld, %ld, %ld" 41075 " and 3 last strides %ld %ld, %ld.", 41076 (long int) NPY_FLOAT64, 41077 (long int) PyArray_TYPE((PyArrayObject*) py_V827), 41078 (long int) PyArray_NDIM(tmp), 41079 (long int) (PyArray_NDIM(tmp) >= 3 ? 41080 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 41081 (long int) (PyArray_NDIM(tmp) >= 2 ? 41082 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 41083 (long int) (PyArray_NDIM(tmp) >= 1 ? 41084 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 41085 (long int) (PyArray_NDIM(tmp) >= 3 ? 41086 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 41087 (long int) (PyArray_NDIM(tmp) >= 2 ? 41088 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 41089 (long int) (PyArray_NDIM(tmp) >= 1 ? 41090 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 41091 ); 41092 { 41093 __failure = 828; 41094 if (!PyErr_Occurred()) { 41095 PyErr_SetString(PyExc_RuntimeError, 41096 "Unexpected error in an Op's C code. " 41097 "No Python exception was set."); 41098 } 41099 goto __label_828;} 41100 } 41101 // This is a TypeError to be consistent with DEBUG_MODE 41102 // Note: DEBUG_MODE also tells the name of the container 41103 if (PyArray_TYPE((PyArrayObject*) py_V827) != NPY_FLOAT64) { 41104 PyErr_Format(PyExc_TypeError, 41105 "expected type_num %d (NPY_FLOAT64) got %d", 41106 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V827)); 41107 { 41108 __failure = 828; 41109 if (!PyErr_Occurred()) { 41110 PyErr_SetString(PyExc_RuntimeError, 41111 "Unexpected error in an Op's C code. " 41112 "No Python exception was set."); 41113 } 41114 goto __label_828;} 41115 } 41116 41117 V827 = (PyArrayObject*)(py_V827); 41118 Py_XINCREF(V827); 41119 41120 { 41121 41122 py_V829 = PyList_GET_ITEM(storage_V829, 0); 41123 {Py_XINCREF(py_V829);} 41124 41125 V829 = NULL; 41126 if (py_V829 == Py_None) { 41127 // We can either fail here or set V829 to NULL and rely on Ops 41128 // using tensors to handle the NULL case, but if they fail to do so 41129 // they'll end up with nasty segfaults, so this is public service. 41130 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 41131 { 41132 __failure = 830; 41133 if (!PyErr_Occurred()) { 41134 PyErr_SetString(PyExc_RuntimeError, 41135 "Unexpected error in an Op's C code. " 41136 "No Python exception was set."); 41137 } 41138 goto __label_830;} 41139 } 41140 if (!PyArray_Check(py_V829)) { 41141 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 41142 { 41143 __failure = 830; 41144 if (!PyErr_Occurred()) { 41145 PyErr_SetString(PyExc_RuntimeError, 41146 "Unexpected error in an Op's C code. " 41147 "No Python exception was set."); 41148 } 41149 goto __label_830;} 41150 } 41151 // We expect NPY_FLOAT64 41152 if (!PyArray_ISALIGNED((PyArrayObject*) py_V829)) { 41153 PyArrayObject * tmp = (PyArrayObject*) py_V829; 41154 PyErr_Format(PyExc_NotImplementedError, 41155 "expected an aligned array of type %ld " 41156 "(NPY_FLOAT64), got non-aligned array of type %ld" 41157 " with %ld dimensions, with 3 last dims " 41158 "%ld, %ld, %ld" 41159 " and 3 last strides %ld %ld, %ld.", 41160 (long int) NPY_FLOAT64, 41161 (long int) PyArray_TYPE((PyArrayObject*) py_V829), 41162 (long int) PyArray_NDIM(tmp), 41163 (long int) (PyArray_NDIM(tmp) >= 3 ? 41164 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 41165 (long int) (PyArray_NDIM(tmp) >= 2 ? 41166 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 41167 (long int) (PyArray_NDIM(tmp) >= 1 ? 41168 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 41169 (long int) (PyArray_NDIM(tmp) >= 3 ? 41170 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 41171 (long int) (PyArray_NDIM(tmp) >= 2 ? 41172 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 41173 (long int) (PyArray_NDIM(tmp) >= 1 ? 41174 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 41175 ); 41176 { 41177 __failure = 830; 41178 if (!PyErr_Occurred()) { 41179 PyErr_SetString(PyExc_RuntimeError, 41180 "Unexpected error in an Op's C code. " 41181 "No Python exception was set."); 41182 } 41183 goto __label_830;} 41184 } 41185 // This is a TypeError to be consistent with DEBUG_MODE 41186 // Note: DEBUG_MODE also tells the name of the container 41187 if (PyArray_TYPE((PyArrayObject*) py_V829) != NPY_FLOAT64) { 41188 PyErr_Format(PyExc_TypeError, 41189 "expected type_num %d (NPY_FLOAT64) got %d", 41190 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V829)); 41191 { 41192 __failure = 830; 41193 if (!PyErr_Occurred()) { 41194 PyErr_SetString(PyExc_RuntimeError, 41195 "Unexpected error in an Op's C code. " 41196 "No Python exception was set."); 41197 } 41198 goto __label_830;} 41199 } 41200 41201 V829 = (PyArrayObject*)(py_V829); 41202 Py_XINCREF(V829); 41203 41204 { 41205 41206 py_V831 = PyList_GET_ITEM(storage_V831, 0); 41207 {Py_XINCREF(py_V831);} 41208 41209 V831 = NULL; 41210 if (py_V831 == Py_None) { 41211 // We can either fail here or set V831 to NULL and rely on Ops 41212 // using tensors to handle the NULL case, but if they fail to do so 41213 // they'll end up with nasty segfaults, so this is public service. 41214 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 41215 { 41216 __failure = 832; 41217 if (!PyErr_Occurred()) { 41218 PyErr_SetString(PyExc_RuntimeError, 41219 "Unexpected error in an Op's C code. " 41220 "No Python exception was set."); 41221 } 41222 goto __label_832;} 41223 } 41224 if (!PyArray_Check(py_V831)) { 41225 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 41226 { 41227 __failure = 832; 41228 if (!PyErr_Occurred()) { 41229 PyErr_SetString(PyExc_RuntimeError, 41230 "Unexpected error in an Op's C code. " 41231 "No Python exception was set."); 41232 } 41233 goto __label_832;} 41234 } 41235 // We expect NPY_FLOAT64 41236 if (!PyArray_ISALIGNED((PyArrayObject*) py_V831)) { 41237 PyArrayObject * tmp = (PyArrayObject*) py_V831; 41238 PyErr_Format(PyExc_NotImplementedError, 41239 "expected an aligned array of type %ld " 41240 "(NPY_FLOAT64), got non-aligned array of type %ld" 41241 " with %ld dimensions, with 3 last dims " 41242 "%ld, %ld, %ld" 41243 " and 3 last strides %ld %ld, %ld.", 41244 (long int) NPY_FLOAT64, 41245 (long int) PyArray_TYPE((PyArrayObject*) py_V831), 41246 (long int) PyArray_NDIM(tmp), 41247 (long int) (PyArray_NDIM(tmp) >= 3 ? 41248 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 41249 (long int) (PyArray_NDIM(tmp) >= 2 ? 41250 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 41251 (long int) (PyArray_NDIM(tmp) >= 1 ? 41252 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 41253 (long int) (PyArray_NDIM(tmp) >= 3 ? 41254 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 41255 (long int) (PyArray_NDIM(tmp) >= 2 ? 41256 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 41257 (long int) (PyArray_NDIM(tmp) >= 1 ? 41258 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 41259 ); 41260 { 41261 __failure = 832; 41262 if (!PyErr_Occurred()) { 41263 PyErr_SetString(PyExc_RuntimeError, 41264 "Unexpected error in an Op's C code. " 41265 "No Python exception was set."); 41266 } 41267 goto __label_832;} 41268 } 41269 // This is a TypeError to be consistent with DEBUG_MODE 41270 // Note: DEBUG_MODE also tells the name of the container 41271 if (PyArray_TYPE((PyArrayObject*) py_V831) != NPY_FLOAT64) { 41272 PyErr_Format(PyExc_TypeError, 41273 "expected type_num %d (NPY_FLOAT64) got %d", 41274 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V831)); 41275 { 41276 __failure = 832; 41277 if (!PyErr_Occurred()) { 41278 PyErr_SetString(PyExc_RuntimeError, 41279 "Unexpected error in an Op's C code. " 41280 "No Python exception was set."); 41281 } 41282 goto __label_832;} 41283 } 41284 41285 V831 = (PyArrayObject*)(py_V831); 41286 Py_XINCREF(V831); 41287 41288 { 41289 41290 py_V833 = PyList_GET_ITEM(storage_V833, 0); 41291 {Py_XINCREF(py_V833);} 41292 41293 V833 = NULL; 41294 if (py_V833 == Py_None) { 41295 // We can either fail here or set V833 to NULL and rely on Ops 41296 // using tensors to handle the NULL case, but if they fail to do so 41297 // they'll end up with nasty segfaults, so this is public service. 41298 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 41299 { 41300 __failure = 834; 41301 if (!PyErr_Occurred()) { 41302 PyErr_SetString(PyExc_RuntimeError, 41303 "Unexpected error in an Op's C code. " 41304 "No Python exception was set."); 41305 } 41306 goto __label_834;} 41307 } 41308 if (!PyArray_Check(py_V833)) { 41309 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 41310 { 41311 __failure = 834; 41312 if (!PyErr_Occurred()) { 41313 PyErr_SetString(PyExc_RuntimeError, 41314 "Unexpected error in an Op's C code. " 41315 "No Python exception was set."); 41316 } 41317 goto __label_834;} 41318 } 41319 // We expect NPY_FLOAT64 41320 if (!PyArray_ISALIGNED((PyArrayObject*) py_V833)) { 41321 PyArrayObject * tmp = (PyArrayObject*) py_V833; 41322 PyErr_Format(PyExc_NotImplementedError, 41323 "expected an aligned array of type %ld " 41324 "(NPY_FLOAT64), got non-aligned array of type %ld" 41325 " with %ld dimensions, with 3 last dims " 41326 "%ld, %ld, %ld" 41327 " and 3 last strides %ld %ld, %ld.", 41328 (long int) NPY_FLOAT64, 41329 (long int) PyArray_TYPE((PyArrayObject*) py_V833), 41330 (long int) PyArray_NDIM(tmp), 41331 (long int) (PyArray_NDIM(tmp) >= 3 ? 41332 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 41333 (long int) (PyArray_NDIM(tmp) >= 2 ? 41334 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 41335 (long int) (PyArray_NDIM(tmp) >= 1 ? 41336 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 41337 (long int) (PyArray_NDIM(tmp) >= 3 ? 41338 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 41339 (long int) (PyArray_NDIM(tmp) >= 2 ? 41340 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 41341 (long int) (PyArray_NDIM(tmp) >= 1 ? 41342 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 41343 ); 41344 { 41345 __failure = 834; 41346 if (!PyErr_Occurred()) { 41347 PyErr_SetString(PyExc_RuntimeError, 41348 "Unexpected error in an Op's C code. " 41349 "No Python exception was set."); 41350 } 41351 goto __label_834;} 41352 } 41353 // This is a TypeError to be consistent with DEBUG_MODE 41354 // Note: DEBUG_MODE also tells the name of the container 41355 if (PyArray_TYPE((PyArrayObject*) py_V833) != NPY_FLOAT64) { 41356 PyErr_Format(PyExc_TypeError, 41357 "expected type_num %d (NPY_FLOAT64) got %d", 41358 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V833)); 41359 { 41360 __failure = 834; 41361 if (!PyErr_Occurred()) { 41362 PyErr_SetString(PyExc_RuntimeError, 41363 "Unexpected error in an Op's C code. " 41364 "No Python exception was set."); 41365 } 41366 goto __label_834;} 41367 } 41368 41369 V833 = (PyArrayObject*)(py_V833); 41370 Py_XINCREF(V833); 41371 41372 { 41373 41374 py_V835 = PyList_GET_ITEM(storage_V835, 0); 41375 {Py_XINCREF(py_V835);} 41376 41377 V835 = NULL; 41378 if (py_V835 == Py_None) { 41379 // We can either fail here or set V835 to NULL and rely on Ops 41380 // using tensors to handle the NULL case, but if they fail to do so 41381 // they'll end up with nasty segfaults, so this is public service. 41382 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 41383 { 41384 __failure = 836; 41385 if (!PyErr_Occurred()) { 41386 PyErr_SetString(PyExc_RuntimeError, 41387 "Unexpected error in an Op's C code. " 41388 "No Python exception was set."); 41389 } 41390 goto __label_836;} 41391 } 41392 if (!PyArray_Check(py_V835)) { 41393 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 41394 { 41395 __failure = 836; 41396 if (!PyErr_Occurred()) { 41397 PyErr_SetString(PyExc_RuntimeError, 41398 "Unexpected error in an Op's C code. " 41399 "No Python exception was set."); 41400 } 41401 goto __label_836;} 41402 } 41403 // We expect NPY_FLOAT64 41404 if (!PyArray_ISALIGNED((PyArrayObject*) py_V835)) { 41405 PyArrayObject * tmp = (PyArrayObject*) py_V835; 41406 PyErr_Format(PyExc_NotImplementedError, 41407 "expected an aligned array of type %ld " 41408 "(NPY_FLOAT64), got non-aligned array of type %ld" 41409 " with %ld dimensions, with 3 last dims " 41410 "%ld, %ld, %ld" 41411 " and 3 last strides %ld %ld, %ld.", 41412 (long int) NPY_FLOAT64, 41413 (long int) PyArray_TYPE((PyArrayObject*) py_V835), 41414 (long int) PyArray_NDIM(tmp), 41415 (long int) (PyArray_NDIM(tmp) >= 3 ? 41416 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 41417 (long int) (PyArray_NDIM(tmp) >= 2 ? 41418 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 41419 (long int) (PyArray_NDIM(tmp) >= 1 ? 41420 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 41421 (long int) (PyArray_NDIM(tmp) >= 3 ? 41422 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 41423 (long int) (PyArray_NDIM(tmp) >= 2 ? 41424 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 41425 (long int) (PyArray_NDIM(tmp) >= 1 ? 41426 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 41427 ); 41428 { 41429 __failure = 836; 41430 if (!PyErr_Occurred()) { 41431 PyErr_SetString(PyExc_RuntimeError, 41432 "Unexpected error in an Op's C code. " 41433 "No Python exception was set."); 41434 } 41435 goto __label_836;} 41436 } 41437 // This is a TypeError to be consistent with DEBUG_MODE 41438 // Note: DEBUG_MODE also tells the name of the container 41439 if (PyArray_TYPE((PyArrayObject*) py_V835) != NPY_FLOAT64) { 41440 PyErr_Format(PyExc_TypeError, 41441 "expected type_num %d (NPY_FLOAT64) got %d", 41442 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V835)); 41443 { 41444 __failure = 836; 41445 if (!PyErr_Occurred()) { 41446 PyErr_SetString(PyExc_RuntimeError, 41447 "Unexpected error in an Op's C code. " 41448 "No Python exception was set."); 41449 } 41450 goto __label_836;} 41451 } 41452 41453 V835 = (PyArrayObject*)(py_V835); 41454 Py_XINCREF(V835); 41455 41456 { 41457 41458 py_V837 = PyList_GET_ITEM(storage_V837, 0); 41459 {Py_XINCREF(py_V837);} 41460 41461 V837 = NULL; 41462 if (py_V837 == Py_None) { 41463 // We can either fail here or set V837 to NULL and rely on Ops 41464 // using tensors to handle the NULL case, but if they fail to do so 41465 // they'll end up with nasty segfaults, so this is public service. 41466 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 41467 { 41468 __failure = 838; 41469 if (!PyErr_Occurred()) { 41470 PyErr_SetString(PyExc_RuntimeError, 41471 "Unexpected error in an Op's C code. " 41472 "No Python exception was set."); 41473 } 41474 goto __label_838;} 41475 } 41476 if (!PyArray_Check(py_V837)) { 41477 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 41478 { 41479 __failure = 838; 41480 if (!PyErr_Occurred()) { 41481 PyErr_SetString(PyExc_RuntimeError, 41482 "Unexpected error in an Op's C code. " 41483 "No Python exception was set."); 41484 } 41485 goto __label_838;} 41486 } 41487 // We expect NPY_FLOAT64 41488 if (!PyArray_ISALIGNED((PyArrayObject*) py_V837)) { 41489 PyArrayObject * tmp = (PyArrayObject*) py_V837; 41490 PyErr_Format(PyExc_NotImplementedError, 41491 "expected an aligned array of type %ld " 41492 "(NPY_FLOAT64), got non-aligned array of type %ld" 41493 " with %ld dimensions, with 3 last dims " 41494 "%ld, %ld, %ld" 41495 " and 3 last strides %ld %ld, %ld.", 41496 (long int) NPY_FLOAT64, 41497 (long int) PyArray_TYPE((PyArrayObject*) py_V837), 41498 (long int) PyArray_NDIM(tmp), 41499 (long int) (PyArray_NDIM(tmp) >= 3 ? 41500 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 41501 (long int) (PyArray_NDIM(tmp) >= 2 ? 41502 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 41503 (long int) (PyArray_NDIM(tmp) >= 1 ? 41504 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 41505 (long int) (PyArray_NDIM(tmp) >= 3 ? 41506 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 41507 (long int) (PyArray_NDIM(tmp) >= 2 ? 41508 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 41509 (long int) (PyArray_NDIM(tmp) >= 1 ? 41510 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 41511 ); 41512 { 41513 __failure = 838; 41514 if (!PyErr_Occurred()) { 41515 PyErr_SetString(PyExc_RuntimeError, 41516 "Unexpected error in an Op's C code. " 41517 "No Python exception was set."); 41518 } 41519 goto __label_838;} 41520 } 41521 // This is a TypeError to be consistent with DEBUG_MODE 41522 // Note: DEBUG_MODE also tells the name of the container 41523 if (PyArray_TYPE((PyArrayObject*) py_V837) != NPY_FLOAT64) { 41524 PyErr_Format(PyExc_TypeError, 41525 "expected type_num %d (NPY_FLOAT64) got %d", 41526 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V837)); 41527 { 41528 __failure = 838; 41529 if (!PyErr_Occurred()) { 41530 PyErr_SetString(PyExc_RuntimeError, 41531 "Unexpected error in an Op's C code. " 41532 "No Python exception was set."); 41533 } 41534 goto __label_838;} 41535 } 41536 41537 V837 = (PyArrayObject*)(py_V837); 41538 Py_XINCREF(V837); 41539 41540 { 41541 41542 py_V839 = PyList_GET_ITEM(storage_V839, 0); 41543 {Py_XINCREF(py_V839);} 41544 41545 V839 = NULL; 41546 if (py_V839 == Py_None) { 41547 // We can either fail here or set V839 to NULL and rely on Ops 41548 // using tensors to handle the NULL case, but if they fail to do so 41549 // they'll end up with nasty segfaults, so this is public service. 41550 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 41551 { 41552 __failure = 840; 41553 if (!PyErr_Occurred()) { 41554 PyErr_SetString(PyExc_RuntimeError, 41555 "Unexpected error in an Op's C code. " 41556 "No Python exception was set."); 41557 } 41558 goto __label_840;} 41559 } 41560 if (!PyArray_Check(py_V839)) { 41561 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 41562 { 41563 __failure = 840; 41564 if (!PyErr_Occurred()) { 41565 PyErr_SetString(PyExc_RuntimeError, 41566 "Unexpected error in an Op's C code. " 41567 "No Python exception was set."); 41568 } 41569 goto __label_840;} 41570 } 41571 // We expect NPY_FLOAT64 41572 if (!PyArray_ISALIGNED((PyArrayObject*) py_V839)) { 41573 PyArrayObject * tmp = (PyArrayObject*) py_V839; 41574 PyErr_Format(PyExc_NotImplementedError, 41575 "expected an aligned array of type %ld " 41576 "(NPY_FLOAT64), got non-aligned array of type %ld" 41577 " with %ld dimensions, with 3 last dims " 41578 "%ld, %ld, %ld" 41579 " and 3 last strides %ld %ld, %ld.", 41580 (long int) NPY_FLOAT64, 41581 (long int) PyArray_TYPE((PyArrayObject*) py_V839), 41582 (long int) PyArray_NDIM(tmp), 41583 (long int) (PyArray_NDIM(tmp) >= 3 ? 41584 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 41585 (long int) (PyArray_NDIM(tmp) >= 2 ? 41586 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 41587 (long int) (PyArray_NDIM(tmp) >= 1 ? 41588 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 41589 (long int) (PyArray_NDIM(tmp) >= 3 ? 41590 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 41591 (long int) (PyArray_NDIM(tmp) >= 2 ? 41592 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 41593 (long int) (PyArray_NDIM(tmp) >= 1 ? 41594 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 41595 ); 41596 { 41597 __failure = 840; 41598 if (!PyErr_Occurred()) { 41599 PyErr_SetString(PyExc_RuntimeError, 41600 "Unexpected error in an Op's C code. " 41601 "No Python exception was set."); 41602 } 41603 goto __label_840;} 41604 } 41605 // This is a TypeError to be consistent with DEBUG_MODE 41606 // Note: DEBUG_MODE also tells the name of the container 41607 if (PyArray_TYPE((PyArrayObject*) py_V839) != NPY_FLOAT64) { 41608 PyErr_Format(PyExc_TypeError, 41609 "expected type_num %d (NPY_FLOAT64) got %d", 41610 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V839)); 41611 { 41612 __failure = 840; 41613 if (!PyErr_Occurred()) { 41614 PyErr_SetString(PyExc_RuntimeError, 41615 "Unexpected error in an Op's C code. " 41616 "No Python exception was set."); 41617 } 41618 goto __label_840;} 41619 } 41620 41621 V839 = (PyArrayObject*)(py_V839); 41622 Py_XINCREF(V839); 41623 41624 { 41625 41626 py_V841 = PyList_GET_ITEM(storage_V841, 0); 41627 {Py_XINCREF(py_V841);} 41628 41629 V841 = NULL; 41630 if (py_V841 == Py_None) { 41631 // We can either fail here or set V841 to NULL and rely on Ops 41632 // using tensors to handle the NULL case, but if they fail to do so 41633 // they'll end up with nasty segfaults, so this is public service. 41634 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 41635 { 41636 __failure = 842; 41637 if (!PyErr_Occurred()) { 41638 PyErr_SetString(PyExc_RuntimeError, 41639 "Unexpected error in an Op's C code. " 41640 "No Python exception was set."); 41641 } 41642 goto __label_842;} 41643 } 41644 if (!PyArray_Check(py_V841)) { 41645 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 41646 { 41647 __failure = 842; 41648 if (!PyErr_Occurred()) { 41649 PyErr_SetString(PyExc_RuntimeError, 41650 "Unexpected error in an Op's C code. " 41651 "No Python exception was set."); 41652 } 41653 goto __label_842;} 41654 } 41655 // We expect NPY_FLOAT64 41656 if (!PyArray_ISALIGNED((PyArrayObject*) py_V841)) { 41657 PyArrayObject * tmp = (PyArrayObject*) py_V841; 41658 PyErr_Format(PyExc_NotImplementedError, 41659 "expected an aligned array of type %ld " 41660 "(NPY_FLOAT64), got non-aligned array of type %ld" 41661 " with %ld dimensions, with 3 last dims " 41662 "%ld, %ld, %ld" 41663 " and 3 last strides %ld %ld, %ld.", 41664 (long int) NPY_FLOAT64, 41665 (long int) PyArray_TYPE((PyArrayObject*) py_V841), 41666 (long int) PyArray_NDIM(tmp), 41667 (long int) (PyArray_NDIM(tmp) >= 3 ? 41668 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 41669 (long int) (PyArray_NDIM(tmp) >= 2 ? 41670 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 41671 (long int) (PyArray_NDIM(tmp) >= 1 ? 41672 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 41673 (long int) (PyArray_NDIM(tmp) >= 3 ? 41674 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 41675 (long int) (PyArray_NDIM(tmp) >= 2 ? 41676 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 41677 (long int) (PyArray_NDIM(tmp) >= 1 ? 41678 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 41679 ); 41680 { 41681 __failure = 842; 41682 if (!PyErr_Occurred()) { 41683 PyErr_SetString(PyExc_RuntimeError, 41684 "Unexpected error in an Op's C code. " 41685 "No Python exception was set."); 41686 } 41687 goto __label_842;} 41688 } 41689 // This is a TypeError to be consistent with DEBUG_MODE 41690 // Note: DEBUG_MODE also tells the name of the container 41691 if (PyArray_TYPE((PyArrayObject*) py_V841) != NPY_FLOAT64) { 41692 PyErr_Format(PyExc_TypeError, 41693 "expected type_num %d (NPY_FLOAT64) got %d", 41694 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V841)); 41695 { 41696 __failure = 842; 41697 if (!PyErr_Occurred()) { 41698 PyErr_SetString(PyExc_RuntimeError, 41699 "Unexpected error in an Op's C code. " 41700 "No Python exception was set."); 41701 } 41702 goto __label_842;} 41703 } 41704 41705 V841 = (PyArrayObject*)(py_V841); 41706 Py_XINCREF(V841); 41707 41708 { 41709 41710 py_V843 = PyList_GET_ITEM(storage_V843, 0); 41711 {Py_XINCREF(py_V843);} 41712 41713 V843 = NULL; 41714 if (py_V843 == Py_None) { 41715 // We can either fail here or set V843 to NULL and rely on Ops 41716 // using tensors to handle the NULL case, but if they fail to do so 41717 // they'll end up with nasty segfaults, so this is public service. 41718 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 41719 { 41720 __failure = 844; 41721 if (!PyErr_Occurred()) { 41722 PyErr_SetString(PyExc_RuntimeError, 41723 "Unexpected error in an Op's C code. " 41724 "No Python exception was set."); 41725 } 41726 goto __label_844;} 41727 } 41728 if (!PyArray_Check(py_V843)) { 41729 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 41730 { 41731 __failure = 844; 41732 if (!PyErr_Occurred()) { 41733 PyErr_SetString(PyExc_RuntimeError, 41734 "Unexpected error in an Op's C code. " 41735 "No Python exception was set."); 41736 } 41737 goto __label_844;} 41738 } 41739 // We expect NPY_FLOAT64 41740 if (!PyArray_ISALIGNED((PyArrayObject*) py_V843)) { 41741 PyArrayObject * tmp = (PyArrayObject*) py_V843; 41742 PyErr_Format(PyExc_NotImplementedError, 41743 "expected an aligned array of type %ld " 41744 "(NPY_FLOAT64), got non-aligned array of type %ld" 41745 " with %ld dimensions, with 3 last dims " 41746 "%ld, %ld, %ld" 41747 " and 3 last strides %ld %ld, %ld.", 41748 (long int) NPY_FLOAT64, 41749 (long int) PyArray_TYPE((PyArrayObject*) py_V843), 41750 (long int) PyArray_NDIM(tmp), 41751 (long int) (PyArray_NDIM(tmp) >= 3 ? 41752 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 41753 (long int) (PyArray_NDIM(tmp) >= 2 ? 41754 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 41755 (long int) (PyArray_NDIM(tmp) >= 1 ? 41756 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 41757 (long int) (PyArray_NDIM(tmp) >= 3 ? 41758 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 41759 (long int) (PyArray_NDIM(tmp) >= 2 ? 41760 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 41761 (long int) (PyArray_NDIM(tmp) >= 1 ? 41762 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 41763 ); 41764 { 41765 __failure = 844; 41766 if (!PyErr_Occurred()) { 41767 PyErr_SetString(PyExc_RuntimeError, 41768 "Unexpected error in an Op's C code. " 41769 "No Python exception was set."); 41770 } 41771 goto __label_844;} 41772 } 41773 // This is a TypeError to be consistent with DEBUG_MODE 41774 // Note: DEBUG_MODE also tells the name of the container 41775 if (PyArray_TYPE((PyArrayObject*) py_V843) != NPY_FLOAT64) { 41776 PyErr_Format(PyExc_TypeError, 41777 "expected type_num %d (NPY_FLOAT64) got %d", 41778 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V843)); 41779 { 41780 __failure = 844; 41781 if (!PyErr_Occurred()) { 41782 PyErr_SetString(PyExc_RuntimeError, 41783 "Unexpected error in an Op's C code. " 41784 "No Python exception was set."); 41785 } 41786 goto __label_844;} 41787 } 41788 41789 V843 = (PyArrayObject*)(py_V843); 41790 Py_XINCREF(V843); 41791 41792 { 41793 41794 py_V845 = PyList_GET_ITEM(storage_V845, 0); 41795 {Py_XINCREF(py_V845);} 41796 41797 V845 = NULL; 41798 if (py_V845 == Py_None) { 41799 // We can either fail here or set V845 to NULL and rely on Ops 41800 // using tensors to handle the NULL case, but if they fail to do so 41801 // they'll end up with nasty segfaults, so this is public service. 41802 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 41803 { 41804 __failure = 846; 41805 if (!PyErr_Occurred()) { 41806 PyErr_SetString(PyExc_RuntimeError, 41807 "Unexpected error in an Op's C code. " 41808 "No Python exception was set."); 41809 } 41810 goto __label_846;} 41811 } 41812 if (!PyArray_Check(py_V845)) { 41813 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 41814 { 41815 __failure = 846; 41816 if (!PyErr_Occurred()) { 41817 PyErr_SetString(PyExc_RuntimeError, 41818 "Unexpected error in an Op's C code. " 41819 "No Python exception was set."); 41820 } 41821 goto __label_846;} 41822 } 41823 // We expect NPY_FLOAT64 41824 if (!PyArray_ISALIGNED((PyArrayObject*) py_V845)) { 41825 PyArrayObject * tmp = (PyArrayObject*) py_V845; 41826 PyErr_Format(PyExc_NotImplementedError, 41827 "expected an aligned array of type %ld " 41828 "(NPY_FLOAT64), got non-aligned array of type %ld" 41829 " with %ld dimensions, with 3 last dims " 41830 "%ld, %ld, %ld" 41831 " and 3 last strides %ld %ld, %ld.", 41832 (long int) NPY_FLOAT64, 41833 (long int) PyArray_TYPE((PyArrayObject*) py_V845), 41834 (long int) PyArray_NDIM(tmp), 41835 (long int) (PyArray_NDIM(tmp) >= 3 ? 41836 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 41837 (long int) (PyArray_NDIM(tmp) >= 2 ? 41838 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 41839 (long int) (PyArray_NDIM(tmp) >= 1 ? 41840 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 41841 (long int) (PyArray_NDIM(tmp) >= 3 ? 41842 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 41843 (long int) (PyArray_NDIM(tmp) >= 2 ? 41844 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 41845 (long int) (PyArray_NDIM(tmp) >= 1 ? 41846 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 41847 ); 41848 { 41849 __failure = 846; 41850 if (!PyErr_Occurred()) { 41851 PyErr_SetString(PyExc_RuntimeError, 41852 "Unexpected error in an Op's C code. " 41853 "No Python exception was set."); 41854 } 41855 goto __label_846;} 41856 } 41857 // This is a TypeError to be consistent with DEBUG_MODE 41858 // Note: DEBUG_MODE also tells the name of the container 41859 if (PyArray_TYPE((PyArrayObject*) py_V845) != NPY_FLOAT64) { 41860 PyErr_Format(PyExc_TypeError, 41861 "expected type_num %d (NPY_FLOAT64) got %d", 41862 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V845)); 41863 { 41864 __failure = 846; 41865 if (!PyErr_Occurred()) { 41866 PyErr_SetString(PyExc_RuntimeError, 41867 "Unexpected error in an Op's C code. " 41868 "No Python exception was set."); 41869 } 41870 goto __label_846;} 41871 } 41872 41873 V845 = (PyArrayObject*)(py_V845); 41874 Py_XINCREF(V845); 41875 41876 { 41877 41878 py_V847 = PyList_GET_ITEM(storage_V847, 0); 41879 {Py_XINCREF(py_V847);} 41880 41881 V847 = NULL; 41882 if (py_V847 == Py_None) { 41883 // We can either fail here or set V847 to NULL and rely on Ops 41884 // using tensors to handle the NULL case, but if they fail to do so 41885 // they'll end up with nasty segfaults, so this is public service. 41886 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 41887 { 41888 __failure = 848; 41889 if (!PyErr_Occurred()) { 41890 PyErr_SetString(PyExc_RuntimeError, 41891 "Unexpected error in an Op's C code. " 41892 "No Python exception was set."); 41893 } 41894 goto __label_848;} 41895 } 41896 if (!PyArray_Check(py_V847)) { 41897 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 41898 { 41899 __failure = 848; 41900 if (!PyErr_Occurred()) { 41901 PyErr_SetString(PyExc_RuntimeError, 41902 "Unexpected error in an Op's C code. " 41903 "No Python exception was set."); 41904 } 41905 goto __label_848;} 41906 } 41907 // We expect NPY_FLOAT64 41908 if (!PyArray_ISALIGNED((PyArrayObject*) py_V847)) { 41909 PyArrayObject * tmp = (PyArrayObject*) py_V847; 41910 PyErr_Format(PyExc_NotImplementedError, 41911 "expected an aligned array of type %ld " 41912 "(NPY_FLOAT64), got non-aligned array of type %ld" 41913 " with %ld dimensions, with 3 last dims " 41914 "%ld, %ld, %ld" 41915 " and 3 last strides %ld %ld, %ld.", 41916 (long int) NPY_FLOAT64, 41917 (long int) PyArray_TYPE((PyArrayObject*) py_V847), 41918 (long int) PyArray_NDIM(tmp), 41919 (long int) (PyArray_NDIM(tmp) >= 3 ? 41920 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 41921 (long int) (PyArray_NDIM(tmp) >= 2 ? 41922 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 41923 (long int) (PyArray_NDIM(tmp) >= 1 ? 41924 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 41925 (long int) (PyArray_NDIM(tmp) >= 3 ? 41926 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 41927 (long int) (PyArray_NDIM(tmp) >= 2 ? 41928 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 41929 (long int) (PyArray_NDIM(tmp) >= 1 ? 41930 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 41931 ); 41932 { 41933 __failure = 848; 41934 if (!PyErr_Occurred()) { 41935 PyErr_SetString(PyExc_RuntimeError, 41936 "Unexpected error in an Op's C code. " 41937 "No Python exception was set."); 41938 } 41939 goto __label_848;} 41940 } 41941 // This is a TypeError to be consistent with DEBUG_MODE 41942 // Note: DEBUG_MODE also tells the name of the container 41943 if (PyArray_TYPE((PyArrayObject*) py_V847) != NPY_FLOAT64) { 41944 PyErr_Format(PyExc_TypeError, 41945 "expected type_num %d (NPY_FLOAT64) got %d", 41946 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V847)); 41947 { 41948 __failure = 848; 41949 if (!PyErr_Occurred()) { 41950 PyErr_SetString(PyExc_RuntimeError, 41951 "Unexpected error in an Op's C code. " 41952 "No Python exception was set."); 41953 } 41954 goto __label_848;} 41955 } 41956 41957 V847 = (PyArrayObject*)(py_V847); 41958 Py_XINCREF(V847); 41959 41960 { 41961 41962 py_V849 = PyList_GET_ITEM(storage_V849, 0); 41963 {Py_XINCREF(py_V849);} 41964 41965 V849 = NULL; 41966 if (py_V849 == Py_None) { 41967 // We can either fail here or set V849 to NULL and rely on Ops 41968 // using tensors to handle the NULL case, but if they fail to do so 41969 // they'll end up with nasty segfaults, so this is public service. 41970 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 41971 { 41972 __failure = 850; 41973 if (!PyErr_Occurred()) { 41974 PyErr_SetString(PyExc_RuntimeError, 41975 "Unexpected error in an Op's C code. " 41976 "No Python exception was set."); 41977 } 41978 goto __label_850;} 41979 } 41980 if (!PyArray_Check(py_V849)) { 41981 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 41982 { 41983 __failure = 850; 41984 if (!PyErr_Occurred()) { 41985 PyErr_SetString(PyExc_RuntimeError, 41986 "Unexpected error in an Op's C code. " 41987 "No Python exception was set."); 41988 } 41989 goto __label_850;} 41990 } 41991 // We expect NPY_FLOAT64 41992 if (!PyArray_ISALIGNED((PyArrayObject*) py_V849)) { 41993 PyArrayObject * tmp = (PyArrayObject*) py_V849; 41994 PyErr_Format(PyExc_NotImplementedError, 41995 "expected an aligned array of type %ld " 41996 "(NPY_FLOAT64), got non-aligned array of type %ld" 41997 " with %ld dimensions, with 3 last dims " 41998 "%ld, %ld, %ld" 41999 " and 3 last strides %ld %ld, %ld.", 42000 (long int) NPY_FLOAT64, 42001 (long int) PyArray_TYPE((PyArrayObject*) py_V849), 42002 (long int) PyArray_NDIM(tmp), 42003 (long int) (PyArray_NDIM(tmp) >= 3 ? 42004 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 42005 (long int) (PyArray_NDIM(tmp) >= 2 ? 42006 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 42007 (long int) (PyArray_NDIM(tmp) >= 1 ? 42008 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 42009 (long int) (PyArray_NDIM(tmp) >= 3 ? 42010 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 42011 (long int) (PyArray_NDIM(tmp) >= 2 ? 42012 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 42013 (long int) (PyArray_NDIM(tmp) >= 1 ? 42014 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 42015 ); 42016 { 42017 __failure = 850; 42018 if (!PyErr_Occurred()) { 42019 PyErr_SetString(PyExc_RuntimeError, 42020 "Unexpected error in an Op's C code. " 42021 "No Python exception was set."); 42022 } 42023 goto __label_850;} 42024 } 42025 // This is a TypeError to be consistent with DEBUG_MODE 42026 // Note: DEBUG_MODE also tells the name of the container 42027 if (PyArray_TYPE((PyArrayObject*) py_V849) != NPY_FLOAT64) { 42028 PyErr_Format(PyExc_TypeError, 42029 "expected type_num %d (NPY_FLOAT64) got %d", 42030 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V849)); 42031 { 42032 __failure = 850; 42033 if (!PyErr_Occurred()) { 42034 PyErr_SetString(PyExc_RuntimeError, 42035 "Unexpected error in an Op's C code. " 42036 "No Python exception was set."); 42037 } 42038 goto __label_850;} 42039 } 42040 42041 V849 = (PyArrayObject*)(py_V849); 42042 Py_XINCREF(V849); 42043 42044 { 42045 42046 py_V851 = PyList_GET_ITEM(storage_V851, 0); 42047 {Py_XINCREF(py_V851);} 42048 42049 V851 = NULL; 42050 if (py_V851 == Py_None) { 42051 // We can either fail here or set V851 to NULL and rely on Ops 42052 // using tensors to handle the NULL case, but if they fail to do so 42053 // they'll end up with nasty segfaults, so this is public service. 42054 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 42055 { 42056 __failure = 852; 42057 if (!PyErr_Occurred()) { 42058 PyErr_SetString(PyExc_RuntimeError, 42059 "Unexpected error in an Op's C code. " 42060 "No Python exception was set."); 42061 } 42062 goto __label_852;} 42063 } 42064 if (!PyArray_Check(py_V851)) { 42065 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 42066 { 42067 __failure = 852; 42068 if (!PyErr_Occurred()) { 42069 PyErr_SetString(PyExc_RuntimeError, 42070 "Unexpected error in an Op's C code. " 42071 "No Python exception was set."); 42072 } 42073 goto __label_852;} 42074 } 42075 // We expect NPY_FLOAT64 42076 if (!PyArray_ISALIGNED((PyArrayObject*) py_V851)) { 42077 PyArrayObject * tmp = (PyArrayObject*) py_V851; 42078 PyErr_Format(PyExc_NotImplementedError, 42079 "expected an aligned array of type %ld " 42080 "(NPY_FLOAT64), got non-aligned array of type %ld" 42081 " with %ld dimensions, with 3 last dims " 42082 "%ld, %ld, %ld" 42083 " and 3 last strides %ld %ld, %ld.", 42084 (long int) NPY_FLOAT64, 42085 (long int) PyArray_TYPE((PyArrayObject*) py_V851), 42086 (long int) PyArray_NDIM(tmp), 42087 (long int) (PyArray_NDIM(tmp) >= 3 ? 42088 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 42089 (long int) (PyArray_NDIM(tmp) >= 2 ? 42090 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 42091 (long int) (PyArray_NDIM(tmp) >= 1 ? 42092 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 42093 (long int) (PyArray_NDIM(tmp) >= 3 ? 42094 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 42095 (long int) (PyArray_NDIM(tmp) >= 2 ? 42096 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 42097 (long int) (PyArray_NDIM(tmp) >= 1 ? 42098 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 42099 ); 42100 { 42101 __failure = 852; 42102 if (!PyErr_Occurred()) { 42103 PyErr_SetString(PyExc_RuntimeError, 42104 "Unexpected error in an Op's C code. " 42105 "No Python exception was set."); 42106 } 42107 goto __label_852;} 42108 } 42109 // This is a TypeError to be consistent with DEBUG_MODE 42110 // Note: DEBUG_MODE also tells the name of the container 42111 if (PyArray_TYPE((PyArrayObject*) py_V851) != NPY_FLOAT64) { 42112 PyErr_Format(PyExc_TypeError, 42113 "expected type_num %d (NPY_FLOAT64) got %d", 42114 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V851)); 42115 { 42116 __failure = 852; 42117 if (!PyErr_Occurred()) { 42118 PyErr_SetString(PyExc_RuntimeError, 42119 "Unexpected error in an Op's C code. " 42120 "No Python exception was set."); 42121 } 42122 goto __label_852;} 42123 } 42124 42125 V851 = (PyArrayObject*)(py_V851); 42126 Py_XINCREF(V851); 42127 42128 { 42129 42130 py_V853 = PyList_GET_ITEM(storage_V853, 0); 42131 {Py_XINCREF(py_V853);} 42132 42133 V853 = NULL; 42134 if (py_V853 == Py_None) { 42135 // We can either fail here or set V853 to NULL and rely on Ops 42136 // using tensors to handle the NULL case, but if they fail to do so 42137 // they'll end up with nasty segfaults, so this is public service. 42138 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 42139 { 42140 __failure = 854; 42141 if (!PyErr_Occurred()) { 42142 PyErr_SetString(PyExc_RuntimeError, 42143 "Unexpected error in an Op's C code. " 42144 "No Python exception was set."); 42145 } 42146 goto __label_854;} 42147 } 42148 if (!PyArray_Check(py_V853)) { 42149 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 42150 { 42151 __failure = 854; 42152 if (!PyErr_Occurred()) { 42153 PyErr_SetString(PyExc_RuntimeError, 42154 "Unexpected error in an Op's C code. " 42155 "No Python exception was set."); 42156 } 42157 goto __label_854;} 42158 } 42159 // We expect NPY_FLOAT64 42160 if (!PyArray_ISALIGNED((PyArrayObject*) py_V853)) { 42161 PyArrayObject * tmp = (PyArrayObject*) py_V853; 42162 PyErr_Format(PyExc_NotImplementedError, 42163 "expected an aligned array of type %ld " 42164 "(NPY_FLOAT64), got non-aligned array of type %ld" 42165 " with %ld dimensions, with 3 last dims " 42166 "%ld, %ld, %ld" 42167 " and 3 last strides %ld %ld, %ld.", 42168 (long int) NPY_FLOAT64, 42169 (long int) PyArray_TYPE((PyArrayObject*) py_V853), 42170 (long int) PyArray_NDIM(tmp), 42171 (long int) (PyArray_NDIM(tmp) >= 3 ? 42172 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 42173 (long int) (PyArray_NDIM(tmp) >= 2 ? 42174 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 42175 (long int) (PyArray_NDIM(tmp) >= 1 ? 42176 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 42177 (long int) (PyArray_NDIM(tmp) >= 3 ? 42178 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 42179 (long int) (PyArray_NDIM(tmp) >= 2 ? 42180 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 42181 (long int) (PyArray_NDIM(tmp) >= 1 ? 42182 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 42183 ); 42184 { 42185 __failure = 854; 42186 if (!PyErr_Occurred()) { 42187 PyErr_SetString(PyExc_RuntimeError, 42188 "Unexpected error in an Op's C code. " 42189 "No Python exception was set."); 42190 } 42191 goto __label_854;} 42192 } 42193 // This is a TypeError to be consistent with DEBUG_MODE 42194 // Note: DEBUG_MODE also tells the name of the container 42195 if (PyArray_TYPE((PyArrayObject*) py_V853) != NPY_FLOAT64) { 42196 PyErr_Format(PyExc_TypeError, 42197 "expected type_num %d (NPY_FLOAT64) got %d", 42198 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V853)); 42199 { 42200 __failure = 854; 42201 if (!PyErr_Occurred()) { 42202 PyErr_SetString(PyExc_RuntimeError, 42203 "Unexpected error in an Op's C code. " 42204 "No Python exception was set."); 42205 } 42206 goto __label_854;} 42207 } 42208 42209 V853 = (PyArrayObject*)(py_V853); 42210 Py_XINCREF(V853); 42211 42212 { 42213 42214 py_V855 = PyList_GET_ITEM(storage_V855, 0); 42215 {Py_XINCREF(py_V855);} 42216 42217 V855 = NULL; 42218 if (py_V855 == Py_None) { 42219 // We can either fail here or set V855 to NULL and rely on Ops 42220 // using tensors to handle the NULL case, but if they fail to do so 42221 // they'll end up with nasty segfaults, so this is public service. 42222 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 42223 { 42224 __failure = 856; 42225 if (!PyErr_Occurred()) { 42226 PyErr_SetString(PyExc_RuntimeError, 42227 "Unexpected error in an Op's C code. " 42228 "No Python exception was set."); 42229 } 42230 goto __label_856;} 42231 } 42232 if (!PyArray_Check(py_V855)) { 42233 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 42234 { 42235 __failure = 856; 42236 if (!PyErr_Occurred()) { 42237 PyErr_SetString(PyExc_RuntimeError, 42238 "Unexpected error in an Op's C code. " 42239 "No Python exception was set."); 42240 } 42241 goto __label_856;} 42242 } 42243 // We expect NPY_FLOAT64 42244 if (!PyArray_ISALIGNED((PyArrayObject*) py_V855)) { 42245 PyArrayObject * tmp = (PyArrayObject*) py_V855; 42246 PyErr_Format(PyExc_NotImplementedError, 42247 "expected an aligned array of type %ld " 42248 "(NPY_FLOAT64), got non-aligned array of type %ld" 42249 " with %ld dimensions, with 3 last dims " 42250 "%ld, %ld, %ld" 42251 " and 3 last strides %ld %ld, %ld.", 42252 (long int) NPY_FLOAT64, 42253 (long int) PyArray_TYPE((PyArrayObject*) py_V855), 42254 (long int) PyArray_NDIM(tmp), 42255 (long int) (PyArray_NDIM(tmp) >= 3 ? 42256 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 42257 (long int) (PyArray_NDIM(tmp) >= 2 ? 42258 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 42259 (long int) (PyArray_NDIM(tmp) >= 1 ? 42260 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 42261 (long int) (PyArray_NDIM(tmp) >= 3 ? 42262 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 42263 (long int) (PyArray_NDIM(tmp) >= 2 ? 42264 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 42265 (long int) (PyArray_NDIM(tmp) >= 1 ? 42266 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 42267 ); 42268 { 42269 __failure = 856; 42270 if (!PyErr_Occurred()) { 42271 PyErr_SetString(PyExc_RuntimeError, 42272 "Unexpected error in an Op's C code. " 42273 "No Python exception was set."); 42274 } 42275 goto __label_856;} 42276 } 42277 // This is a TypeError to be consistent with DEBUG_MODE 42278 // Note: DEBUG_MODE also tells the name of the container 42279 if (PyArray_TYPE((PyArrayObject*) py_V855) != NPY_FLOAT64) { 42280 PyErr_Format(PyExc_TypeError, 42281 "expected type_num %d (NPY_FLOAT64) got %d", 42282 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V855)); 42283 { 42284 __failure = 856; 42285 if (!PyErr_Occurred()) { 42286 PyErr_SetString(PyExc_RuntimeError, 42287 "Unexpected error in an Op's C code. " 42288 "No Python exception was set."); 42289 } 42290 goto __label_856;} 42291 } 42292 42293 V855 = (PyArrayObject*)(py_V855); 42294 Py_XINCREF(V855); 42295 42296 { 42297 42298 py_V857 = PyList_GET_ITEM(storage_V857, 0); 42299 {Py_XINCREF(py_V857);} 42300 42301 V857 = NULL; 42302 if (py_V857 == Py_None) { 42303 // We can either fail here or set V857 to NULL and rely on Ops 42304 // using tensors to handle the NULL case, but if they fail to do so 42305 // they'll end up with nasty segfaults, so this is public service. 42306 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 42307 { 42308 __failure = 858; 42309 if (!PyErr_Occurred()) { 42310 PyErr_SetString(PyExc_RuntimeError, 42311 "Unexpected error in an Op's C code. " 42312 "No Python exception was set."); 42313 } 42314 goto __label_858;} 42315 } 42316 if (!PyArray_Check(py_V857)) { 42317 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 42318 { 42319 __failure = 858; 42320 if (!PyErr_Occurred()) { 42321 PyErr_SetString(PyExc_RuntimeError, 42322 "Unexpected error in an Op's C code. " 42323 "No Python exception was set."); 42324 } 42325 goto __label_858;} 42326 } 42327 // We expect NPY_FLOAT64 42328 if (!PyArray_ISALIGNED((PyArrayObject*) py_V857)) { 42329 PyArrayObject * tmp = (PyArrayObject*) py_V857; 42330 PyErr_Format(PyExc_NotImplementedError, 42331 "expected an aligned array of type %ld " 42332 "(NPY_FLOAT64), got non-aligned array of type %ld" 42333 " with %ld dimensions, with 3 last dims " 42334 "%ld, %ld, %ld" 42335 " and 3 last strides %ld %ld, %ld.", 42336 (long int) NPY_FLOAT64, 42337 (long int) PyArray_TYPE((PyArrayObject*) py_V857), 42338 (long int) PyArray_NDIM(tmp), 42339 (long int) (PyArray_NDIM(tmp) >= 3 ? 42340 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 42341 (long int) (PyArray_NDIM(tmp) >= 2 ? 42342 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 42343 (long int) (PyArray_NDIM(tmp) >= 1 ? 42344 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 42345 (long int) (PyArray_NDIM(tmp) >= 3 ? 42346 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 42347 (long int) (PyArray_NDIM(tmp) >= 2 ? 42348 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 42349 (long int) (PyArray_NDIM(tmp) >= 1 ? 42350 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 42351 ); 42352 { 42353 __failure = 858; 42354 if (!PyErr_Occurred()) { 42355 PyErr_SetString(PyExc_RuntimeError, 42356 "Unexpected error in an Op's C code. " 42357 "No Python exception was set."); 42358 } 42359 goto __label_858;} 42360 } 42361 // This is a TypeError to be consistent with DEBUG_MODE 42362 // Note: DEBUG_MODE also tells the name of the container 42363 if (PyArray_TYPE((PyArrayObject*) py_V857) != NPY_FLOAT64) { 42364 PyErr_Format(PyExc_TypeError, 42365 "expected type_num %d (NPY_FLOAT64) got %d", 42366 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V857)); 42367 { 42368 __failure = 858; 42369 if (!PyErr_Occurred()) { 42370 PyErr_SetString(PyExc_RuntimeError, 42371 "Unexpected error in an Op's C code. " 42372 "No Python exception was set."); 42373 } 42374 goto __label_858;} 42375 } 42376 42377 V857 = (PyArrayObject*)(py_V857); 42378 Py_XINCREF(V857); 42379 42380 { 42381 42382 py_V859 = PyList_GET_ITEM(storage_V859, 0); 42383 {Py_XINCREF(py_V859);} 42384 42385 V859 = NULL; 42386 if (py_V859 == Py_None) { 42387 // We can either fail here or set V859 to NULL and rely on Ops 42388 // using tensors to handle the NULL case, but if they fail to do so 42389 // they'll end up with nasty segfaults, so this is public service. 42390 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 42391 { 42392 __failure = 860; 42393 if (!PyErr_Occurred()) { 42394 PyErr_SetString(PyExc_RuntimeError, 42395 "Unexpected error in an Op's C code. " 42396 "No Python exception was set."); 42397 } 42398 goto __label_860;} 42399 } 42400 if (!PyArray_Check(py_V859)) { 42401 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 42402 { 42403 __failure = 860; 42404 if (!PyErr_Occurred()) { 42405 PyErr_SetString(PyExc_RuntimeError, 42406 "Unexpected error in an Op's C code. " 42407 "No Python exception was set."); 42408 } 42409 goto __label_860;} 42410 } 42411 // We expect NPY_FLOAT64 42412 if (!PyArray_ISALIGNED((PyArrayObject*) py_V859)) { 42413 PyArrayObject * tmp = (PyArrayObject*) py_V859; 42414 PyErr_Format(PyExc_NotImplementedError, 42415 "expected an aligned array of type %ld " 42416 "(NPY_FLOAT64), got non-aligned array of type %ld" 42417 " with %ld dimensions, with 3 last dims " 42418 "%ld, %ld, %ld" 42419 " and 3 last strides %ld %ld, %ld.", 42420 (long int) NPY_FLOAT64, 42421 (long int) PyArray_TYPE((PyArrayObject*) py_V859), 42422 (long int) PyArray_NDIM(tmp), 42423 (long int) (PyArray_NDIM(tmp) >= 3 ? 42424 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 42425 (long int) (PyArray_NDIM(tmp) >= 2 ? 42426 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 42427 (long int) (PyArray_NDIM(tmp) >= 1 ? 42428 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 42429 (long int) (PyArray_NDIM(tmp) >= 3 ? 42430 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 42431 (long int) (PyArray_NDIM(tmp) >= 2 ? 42432 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 42433 (long int) (PyArray_NDIM(tmp) >= 1 ? 42434 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 42435 ); 42436 { 42437 __failure = 860; 42438 if (!PyErr_Occurred()) { 42439 PyErr_SetString(PyExc_RuntimeError, 42440 "Unexpected error in an Op's C code. " 42441 "No Python exception was set."); 42442 } 42443 goto __label_860;} 42444 } 42445 // This is a TypeError to be consistent with DEBUG_MODE 42446 // Note: DEBUG_MODE also tells the name of the container 42447 if (PyArray_TYPE((PyArrayObject*) py_V859) != NPY_FLOAT64) { 42448 PyErr_Format(PyExc_TypeError, 42449 "expected type_num %d (NPY_FLOAT64) got %d", 42450 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V859)); 42451 { 42452 __failure = 860; 42453 if (!PyErr_Occurred()) { 42454 PyErr_SetString(PyExc_RuntimeError, 42455 "Unexpected error in an Op's C code. " 42456 "No Python exception was set."); 42457 } 42458 goto __label_860;} 42459 } 42460 42461 V859 = (PyArrayObject*)(py_V859); 42462 Py_XINCREF(V859); 42463 42464 { 42465 42466 py_V861 = PyList_GET_ITEM(storage_V861, 0); 42467 {Py_XINCREF(py_V861);} 42468 42469 V861 = NULL; 42470 if (py_V861 == Py_None) { 42471 // We can either fail here or set V861 to NULL and rely on Ops 42472 // using tensors to handle the NULL case, but if they fail to do so 42473 // they'll end up with nasty segfaults, so this is public service. 42474 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 42475 { 42476 __failure = 862; 42477 if (!PyErr_Occurred()) { 42478 PyErr_SetString(PyExc_RuntimeError, 42479 "Unexpected error in an Op's C code. " 42480 "No Python exception was set."); 42481 } 42482 goto __label_862;} 42483 } 42484 if (!PyArray_Check(py_V861)) { 42485 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 42486 { 42487 __failure = 862; 42488 if (!PyErr_Occurred()) { 42489 PyErr_SetString(PyExc_RuntimeError, 42490 "Unexpected error in an Op's C code. " 42491 "No Python exception was set."); 42492 } 42493 goto __label_862;} 42494 } 42495 // We expect NPY_FLOAT64 42496 if (!PyArray_ISALIGNED((PyArrayObject*) py_V861)) { 42497 PyArrayObject * tmp = (PyArrayObject*) py_V861; 42498 PyErr_Format(PyExc_NotImplementedError, 42499 "expected an aligned array of type %ld " 42500 "(NPY_FLOAT64), got non-aligned array of type %ld" 42501 " with %ld dimensions, with 3 last dims " 42502 "%ld, %ld, %ld" 42503 " and 3 last strides %ld %ld, %ld.", 42504 (long int) NPY_FLOAT64, 42505 (long int) PyArray_TYPE((PyArrayObject*) py_V861), 42506 (long int) PyArray_NDIM(tmp), 42507 (long int) (PyArray_NDIM(tmp) >= 3 ? 42508 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 42509 (long int) (PyArray_NDIM(tmp) >= 2 ? 42510 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 42511 (long int) (PyArray_NDIM(tmp) >= 1 ? 42512 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 42513 (long int) (PyArray_NDIM(tmp) >= 3 ? 42514 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 42515 (long int) (PyArray_NDIM(tmp) >= 2 ? 42516 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 42517 (long int) (PyArray_NDIM(tmp) >= 1 ? 42518 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 42519 ); 42520 { 42521 __failure = 862; 42522 if (!PyErr_Occurred()) { 42523 PyErr_SetString(PyExc_RuntimeError, 42524 "Unexpected error in an Op's C code. " 42525 "No Python exception was set."); 42526 } 42527 goto __label_862;} 42528 } 42529 // This is a TypeError to be consistent with DEBUG_MODE 42530 // Note: DEBUG_MODE also tells the name of the container 42531 if (PyArray_TYPE((PyArrayObject*) py_V861) != NPY_FLOAT64) { 42532 PyErr_Format(PyExc_TypeError, 42533 "expected type_num %d (NPY_FLOAT64) got %d", 42534 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V861)); 42535 { 42536 __failure = 862; 42537 if (!PyErr_Occurred()) { 42538 PyErr_SetString(PyExc_RuntimeError, 42539 "Unexpected error in an Op's C code. " 42540 "No Python exception was set."); 42541 } 42542 goto __label_862;} 42543 } 42544 42545 V861 = (PyArrayObject*)(py_V861); 42546 Py_XINCREF(V861); 42547 42548 { 42549 42550 py_V863 = PyList_GET_ITEM(storage_V863, 0); 42551 {Py_XINCREF(py_V863);} 42552 42553 V863 = NULL; 42554 if (py_V863 == Py_None) { 42555 // We can either fail here or set V863 to NULL and rely on Ops 42556 // using tensors to handle the NULL case, but if they fail to do so 42557 // they'll end up with nasty segfaults, so this is public service. 42558 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 42559 { 42560 __failure = 864; 42561 if (!PyErr_Occurred()) { 42562 PyErr_SetString(PyExc_RuntimeError, 42563 "Unexpected error in an Op's C code. " 42564 "No Python exception was set."); 42565 } 42566 goto __label_864;} 42567 } 42568 if (!PyArray_Check(py_V863)) { 42569 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 42570 { 42571 __failure = 864; 42572 if (!PyErr_Occurred()) { 42573 PyErr_SetString(PyExc_RuntimeError, 42574 "Unexpected error in an Op's C code. " 42575 "No Python exception was set."); 42576 } 42577 goto __label_864;} 42578 } 42579 // We expect NPY_FLOAT64 42580 if (!PyArray_ISALIGNED((PyArrayObject*) py_V863)) { 42581 PyArrayObject * tmp = (PyArrayObject*) py_V863; 42582 PyErr_Format(PyExc_NotImplementedError, 42583 "expected an aligned array of type %ld " 42584 "(NPY_FLOAT64), got non-aligned array of type %ld" 42585 " with %ld dimensions, with 3 last dims " 42586 "%ld, %ld, %ld" 42587 " and 3 last strides %ld %ld, %ld.", 42588 (long int) NPY_FLOAT64, 42589 (long int) PyArray_TYPE((PyArrayObject*) py_V863), 42590 (long int) PyArray_NDIM(tmp), 42591 (long int) (PyArray_NDIM(tmp) >= 3 ? 42592 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 42593 (long int) (PyArray_NDIM(tmp) >= 2 ? 42594 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 42595 (long int) (PyArray_NDIM(tmp) >= 1 ? 42596 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 42597 (long int) (PyArray_NDIM(tmp) >= 3 ? 42598 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 42599 (long int) (PyArray_NDIM(tmp) >= 2 ? 42600 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 42601 (long int) (PyArray_NDIM(tmp) >= 1 ? 42602 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 42603 ); 42604 { 42605 __failure = 864; 42606 if (!PyErr_Occurred()) { 42607 PyErr_SetString(PyExc_RuntimeError, 42608 "Unexpected error in an Op's C code. " 42609 "No Python exception was set."); 42610 } 42611 goto __label_864;} 42612 } 42613 // This is a TypeError to be consistent with DEBUG_MODE 42614 // Note: DEBUG_MODE also tells the name of the container 42615 if (PyArray_TYPE((PyArrayObject*) py_V863) != NPY_FLOAT64) { 42616 PyErr_Format(PyExc_TypeError, 42617 "expected type_num %d (NPY_FLOAT64) got %d", 42618 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V863)); 42619 { 42620 __failure = 864; 42621 if (!PyErr_Occurred()) { 42622 PyErr_SetString(PyExc_RuntimeError, 42623 "Unexpected error in an Op's C code. " 42624 "No Python exception was set."); 42625 } 42626 goto __label_864;} 42627 } 42628 42629 V863 = (PyArrayObject*)(py_V863); 42630 Py_XINCREF(V863); 42631 42632 { 42633 42634 py_V865 = PyList_GET_ITEM(storage_V865, 0); 42635 {Py_XINCREF(py_V865);} 42636 42637 V865 = NULL; 42638 if (py_V865 == Py_None) { 42639 // We can either fail here or set V865 to NULL and rely on Ops 42640 // using tensors to handle the NULL case, but if they fail to do so 42641 // they'll end up with nasty segfaults, so this is public service. 42642 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 42643 { 42644 __failure = 866; 42645 if (!PyErr_Occurred()) { 42646 PyErr_SetString(PyExc_RuntimeError, 42647 "Unexpected error in an Op's C code. " 42648 "No Python exception was set."); 42649 } 42650 goto __label_866;} 42651 } 42652 if (!PyArray_Check(py_V865)) { 42653 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 42654 { 42655 __failure = 866; 42656 if (!PyErr_Occurred()) { 42657 PyErr_SetString(PyExc_RuntimeError, 42658 "Unexpected error in an Op's C code. " 42659 "No Python exception was set."); 42660 } 42661 goto __label_866;} 42662 } 42663 // We expect NPY_FLOAT64 42664 if (!PyArray_ISALIGNED((PyArrayObject*) py_V865)) { 42665 PyArrayObject * tmp = (PyArrayObject*) py_V865; 42666 PyErr_Format(PyExc_NotImplementedError, 42667 "expected an aligned array of type %ld " 42668 "(NPY_FLOAT64), got non-aligned array of type %ld" 42669 " with %ld dimensions, with 3 last dims " 42670 "%ld, %ld, %ld" 42671 " and 3 last strides %ld %ld, %ld.", 42672 (long int) NPY_FLOAT64, 42673 (long int) PyArray_TYPE((PyArrayObject*) py_V865), 42674 (long int) PyArray_NDIM(tmp), 42675 (long int) (PyArray_NDIM(tmp) >= 3 ? 42676 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 42677 (long int) (PyArray_NDIM(tmp) >= 2 ? 42678 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 42679 (long int) (PyArray_NDIM(tmp) >= 1 ? 42680 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 42681 (long int) (PyArray_NDIM(tmp) >= 3 ? 42682 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 42683 (long int) (PyArray_NDIM(tmp) >= 2 ? 42684 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 42685 (long int) (PyArray_NDIM(tmp) >= 1 ? 42686 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 42687 ); 42688 { 42689 __failure = 866; 42690 if (!PyErr_Occurred()) { 42691 PyErr_SetString(PyExc_RuntimeError, 42692 "Unexpected error in an Op's C code. " 42693 "No Python exception was set."); 42694 } 42695 goto __label_866;} 42696 } 42697 // This is a TypeError to be consistent with DEBUG_MODE 42698 // Note: DEBUG_MODE also tells the name of the container 42699 if (PyArray_TYPE((PyArrayObject*) py_V865) != NPY_FLOAT64) { 42700 PyErr_Format(PyExc_TypeError, 42701 "expected type_num %d (NPY_FLOAT64) got %d", 42702 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V865)); 42703 { 42704 __failure = 866; 42705 if (!PyErr_Occurred()) { 42706 PyErr_SetString(PyExc_RuntimeError, 42707 "Unexpected error in an Op's C code. " 42708 "No Python exception was set."); 42709 } 42710 goto __label_866;} 42711 } 42712 42713 V865 = (PyArrayObject*)(py_V865); 42714 Py_XINCREF(V865); 42715 42716 { 42717 42718 py_V867 = PyList_GET_ITEM(storage_V867, 0); 42719 {Py_XINCREF(py_V867);} 42720 42721 V867 = NULL; 42722 if (py_V867 == Py_None) { 42723 // We can either fail here or set V867 to NULL and rely on Ops 42724 // using tensors to handle the NULL case, but if they fail to do so 42725 // they'll end up with nasty segfaults, so this is public service. 42726 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 42727 { 42728 __failure = 868; 42729 if (!PyErr_Occurred()) { 42730 PyErr_SetString(PyExc_RuntimeError, 42731 "Unexpected error in an Op's C code. " 42732 "No Python exception was set."); 42733 } 42734 goto __label_868;} 42735 } 42736 if (!PyArray_Check(py_V867)) { 42737 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 42738 { 42739 __failure = 868; 42740 if (!PyErr_Occurred()) { 42741 PyErr_SetString(PyExc_RuntimeError, 42742 "Unexpected error in an Op's C code. " 42743 "No Python exception was set."); 42744 } 42745 goto __label_868;} 42746 } 42747 // We expect NPY_FLOAT64 42748 if (!PyArray_ISALIGNED((PyArrayObject*) py_V867)) { 42749 PyArrayObject * tmp = (PyArrayObject*) py_V867; 42750 PyErr_Format(PyExc_NotImplementedError, 42751 "expected an aligned array of type %ld " 42752 "(NPY_FLOAT64), got non-aligned array of type %ld" 42753 " with %ld dimensions, with 3 last dims " 42754 "%ld, %ld, %ld" 42755 " and 3 last strides %ld %ld, %ld.", 42756 (long int) NPY_FLOAT64, 42757 (long int) PyArray_TYPE((PyArrayObject*) py_V867), 42758 (long int) PyArray_NDIM(tmp), 42759 (long int) (PyArray_NDIM(tmp) >= 3 ? 42760 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 42761 (long int) (PyArray_NDIM(tmp) >= 2 ? 42762 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 42763 (long int) (PyArray_NDIM(tmp) >= 1 ? 42764 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 42765 (long int) (PyArray_NDIM(tmp) >= 3 ? 42766 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 42767 (long int) (PyArray_NDIM(tmp) >= 2 ? 42768 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 42769 (long int) (PyArray_NDIM(tmp) >= 1 ? 42770 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 42771 ); 42772 { 42773 __failure = 868; 42774 if (!PyErr_Occurred()) { 42775 PyErr_SetString(PyExc_RuntimeError, 42776 "Unexpected error in an Op's C code. " 42777 "No Python exception was set."); 42778 } 42779 goto __label_868;} 42780 } 42781 // This is a TypeError to be consistent with DEBUG_MODE 42782 // Note: DEBUG_MODE also tells the name of the container 42783 if (PyArray_TYPE((PyArrayObject*) py_V867) != NPY_FLOAT64) { 42784 PyErr_Format(PyExc_TypeError, 42785 "expected type_num %d (NPY_FLOAT64) got %d", 42786 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V867)); 42787 { 42788 __failure = 868; 42789 if (!PyErr_Occurred()) { 42790 PyErr_SetString(PyExc_RuntimeError, 42791 "Unexpected error in an Op's C code. " 42792 "No Python exception was set."); 42793 } 42794 goto __label_868;} 42795 } 42796 42797 V867 = (PyArrayObject*)(py_V867); 42798 Py_XINCREF(V867); 42799 42800 { 42801 42802 py_V869 = PyList_GET_ITEM(storage_V869, 0); 42803 {Py_XINCREF(py_V869);} 42804 42805 V869 = NULL; 42806 if (py_V869 == Py_None) { 42807 // We can either fail here or set V869 to NULL and rely on Ops 42808 // using tensors to handle the NULL case, but if they fail to do so 42809 // they'll end up with nasty segfaults, so this is public service. 42810 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 42811 { 42812 __failure = 870; 42813 if (!PyErr_Occurred()) { 42814 PyErr_SetString(PyExc_RuntimeError, 42815 "Unexpected error in an Op's C code. " 42816 "No Python exception was set."); 42817 } 42818 goto __label_870;} 42819 } 42820 if (!PyArray_Check(py_V869)) { 42821 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 42822 { 42823 __failure = 870; 42824 if (!PyErr_Occurred()) { 42825 PyErr_SetString(PyExc_RuntimeError, 42826 "Unexpected error in an Op's C code. " 42827 "No Python exception was set."); 42828 } 42829 goto __label_870;} 42830 } 42831 // We expect NPY_FLOAT64 42832 if (!PyArray_ISALIGNED((PyArrayObject*) py_V869)) { 42833 PyArrayObject * tmp = (PyArrayObject*) py_V869; 42834 PyErr_Format(PyExc_NotImplementedError, 42835 "expected an aligned array of type %ld " 42836 "(NPY_FLOAT64), got non-aligned array of type %ld" 42837 " with %ld dimensions, with 3 last dims " 42838 "%ld, %ld, %ld" 42839 " and 3 last strides %ld %ld, %ld.", 42840 (long int) NPY_FLOAT64, 42841 (long int) PyArray_TYPE((PyArrayObject*) py_V869), 42842 (long int) PyArray_NDIM(tmp), 42843 (long int) (PyArray_NDIM(tmp) >= 3 ? 42844 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 42845 (long int) (PyArray_NDIM(tmp) >= 2 ? 42846 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 42847 (long int) (PyArray_NDIM(tmp) >= 1 ? 42848 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 42849 (long int) (PyArray_NDIM(tmp) >= 3 ? 42850 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 42851 (long int) (PyArray_NDIM(tmp) >= 2 ? 42852 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 42853 (long int) (PyArray_NDIM(tmp) >= 1 ? 42854 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 42855 ); 42856 { 42857 __failure = 870; 42858 if (!PyErr_Occurred()) { 42859 PyErr_SetString(PyExc_RuntimeError, 42860 "Unexpected error in an Op's C code. " 42861 "No Python exception was set."); 42862 } 42863 goto __label_870;} 42864 } 42865 // This is a TypeError to be consistent with DEBUG_MODE 42866 // Note: DEBUG_MODE also tells the name of the container 42867 if (PyArray_TYPE((PyArrayObject*) py_V869) != NPY_FLOAT64) { 42868 PyErr_Format(PyExc_TypeError, 42869 "expected type_num %d (NPY_FLOAT64) got %d", 42870 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V869)); 42871 { 42872 __failure = 870; 42873 if (!PyErr_Occurred()) { 42874 PyErr_SetString(PyExc_RuntimeError, 42875 "Unexpected error in an Op's C code. " 42876 "No Python exception was set."); 42877 } 42878 goto __label_870;} 42879 } 42880 42881 V869 = (PyArrayObject*)(py_V869); 42882 Py_XINCREF(V869); 42883 42884 { 42885 42886 py_V871 = PyList_GET_ITEM(storage_V871, 0); 42887 {Py_XINCREF(py_V871);} 42888 42889 V871 = NULL; 42890 if (py_V871 == Py_None) { 42891 // We can either fail here or set V871 to NULL and rely on Ops 42892 // using tensors to handle the NULL case, but if they fail to do so 42893 // they'll end up with nasty segfaults, so this is public service. 42894 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 42895 { 42896 __failure = 872; 42897 if (!PyErr_Occurred()) { 42898 PyErr_SetString(PyExc_RuntimeError, 42899 "Unexpected error in an Op's C code. " 42900 "No Python exception was set."); 42901 } 42902 goto __label_872;} 42903 } 42904 if (!PyArray_Check(py_V871)) { 42905 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 42906 { 42907 __failure = 872; 42908 if (!PyErr_Occurred()) { 42909 PyErr_SetString(PyExc_RuntimeError, 42910 "Unexpected error in an Op's C code. " 42911 "No Python exception was set."); 42912 } 42913 goto __label_872;} 42914 } 42915 // We expect NPY_FLOAT64 42916 if (!PyArray_ISALIGNED((PyArrayObject*) py_V871)) { 42917 PyArrayObject * tmp = (PyArrayObject*) py_V871; 42918 PyErr_Format(PyExc_NotImplementedError, 42919 "expected an aligned array of type %ld " 42920 "(NPY_FLOAT64), got non-aligned array of type %ld" 42921 " with %ld dimensions, with 3 last dims " 42922 "%ld, %ld, %ld" 42923 " and 3 last strides %ld %ld, %ld.", 42924 (long int) NPY_FLOAT64, 42925 (long int) PyArray_TYPE((PyArrayObject*) py_V871), 42926 (long int) PyArray_NDIM(tmp), 42927 (long int) (PyArray_NDIM(tmp) >= 3 ? 42928 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 42929 (long int) (PyArray_NDIM(tmp) >= 2 ? 42930 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 42931 (long int) (PyArray_NDIM(tmp) >= 1 ? 42932 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 42933 (long int) (PyArray_NDIM(tmp) >= 3 ? 42934 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 42935 (long int) (PyArray_NDIM(tmp) >= 2 ? 42936 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 42937 (long int) (PyArray_NDIM(tmp) >= 1 ? 42938 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 42939 ); 42940 { 42941 __failure = 872; 42942 if (!PyErr_Occurred()) { 42943 PyErr_SetString(PyExc_RuntimeError, 42944 "Unexpected error in an Op's C code. " 42945 "No Python exception was set."); 42946 } 42947 goto __label_872;} 42948 } 42949 // This is a TypeError to be consistent with DEBUG_MODE 42950 // Note: DEBUG_MODE also tells the name of the container 42951 if (PyArray_TYPE((PyArrayObject*) py_V871) != NPY_FLOAT64) { 42952 PyErr_Format(PyExc_TypeError, 42953 "expected type_num %d (NPY_FLOAT64) got %d", 42954 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V871)); 42955 { 42956 __failure = 872; 42957 if (!PyErr_Occurred()) { 42958 PyErr_SetString(PyExc_RuntimeError, 42959 "Unexpected error in an Op's C code. " 42960 "No Python exception was set."); 42961 } 42962 goto __label_872;} 42963 } 42964 42965 V871 = (PyArrayObject*)(py_V871); 42966 Py_XINCREF(V871); 42967 42968 { 42969 42970 py_V873 = PyList_GET_ITEM(storage_V873, 0); 42971 {Py_XINCREF(py_V873);} 42972 42973 V873 = NULL; 42974 if (py_V873 == Py_None) { 42975 // We can either fail here or set V873 to NULL and rely on Ops 42976 // using tensors to handle the NULL case, but if they fail to do so 42977 // they'll end up with nasty segfaults, so this is public service. 42978 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 42979 { 42980 __failure = 874; 42981 if (!PyErr_Occurred()) { 42982 PyErr_SetString(PyExc_RuntimeError, 42983 "Unexpected error in an Op's C code. " 42984 "No Python exception was set."); 42985 } 42986 goto __label_874;} 42987 } 42988 if (!PyArray_Check(py_V873)) { 42989 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 42990 { 42991 __failure = 874; 42992 if (!PyErr_Occurred()) { 42993 PyErr_SetString(PyExc_RuntimeError, 42994 "Unexpected error in an Op's C code. " 42995 "No Python exception was set."); 42996 } 42997 goto __label_874;} 42998 } 42999 // We expect NPY_FLOAT64 43000 if (!PyArray_ISALIGNED((PyArrayObject*) py_V873)) { 43001 PyArrayObject * tmp = (PyArrayObject*) py_V873; 43002 PyErr_Format(PyExc_NotImplementedError, 43003 "expected an aligned array of type %ld " 43004 "(NPY_FLOAT64), got non-aligned array of type %ld" 43005 " with %ld dimensions, with 3 last dims " 43006 "%ld, %ld, %ld" 43007 " and 3 last strides %ld %ld, %ld.", 43008 (long int) NPY_FLOAT64, 43009 (long int) PyArray_TYPE((PyArrayObject*) py_V873), 43010 (long int) PyArray_NDIM(tmp), 43011 (long int) (PyArray_NDIM(tmp) >= 3 ? 43012 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 43013 (long int) (PyArray_NDIM(tmp) >= 2 ? 43014 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 43015 (long int) (PyArray_NDIM(tmp) >= 1 ? 43016 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 43017 (long int) (PyArray_NDIM(tmp) >= 3 ? 43018 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 43019 (long int) (PyArray_NDIM(tmp) >= 2 ? 43020 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 43021 (long int) (PyArray_NDIM(tmp) >= 1 ? 43022 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 43023 ); 43024 { 43025 __failure = 874; 43026 if (!PyErr_Occurred()) { 43027 PyErr_SetString(PyExc_RuntimeError, 43028 "Unexpected error in an Op's C code. " 43029 "No Python exception was set."); 43030 } 43031 goto __label_874;} 43032 } 43033 // This is a TypeError to be consistent with DEBUG_MODE 43034 // Note: DEBUG_MODE also tells the name of the container 43035 if (PyArray_TYPE((PyArrayObject*) py_V873) != NPY_FLOAT64) { 43036 PyErr_Format(PyExc_TypeError, 43037 "expected type_num %d (NPY_FLOAT64) got %d", 43038 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V873)); 43039 { 43040 __failure = 874; 43041 if (!PyErr_Occurred()) { 43042 PyErr_SetString(PyExc_RuntimeError, 43043 "Unexpected error in an Op's C code. " 43044 "No Python exception was set."); 43045 } 43046 goto __label_874;} 43047 } 43048 43049 V873 = (PyArrayObject*)(py_V873); 43050 Py_XINCREF(V873); 43051 43052 { 43053 43054 py_V875 = PyList_GET_ITEM(storage_V875, 0); 43055 {Py_XINCREF(py_V875);} 43056 43057 V875 = NULL; 43058 if (py_V875 == Py_None) { 43059 // We can either fail here or set V875 to NULL and rely on Ops 43060 // using tensors to handle the NULL case, but if they fail to do so 43061 // they'll end up with nasty segfaults, so this is public service. 43062 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 43063 { 43064 __failure = 876; 43065 if (!PyErr_Occurred()) { 43066 PyErr_SetString(PyExc_RuntimeError, 43067 "Unexpected error in an Op's C code. " 43068 "No Python exception was set."); 43069 } 43070 goto __label_876;} 43071 } 43072 if (!PyArray_Check(py_V875)) { 43073 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 43074 { 43075 __failure = 876; 43076 if (!PyErr_Occurred()) { 43077 PyErr_SetString(PyExc_RuntimeError, 43078 "Unexpected error in an Op's C code. " 43079 "No Python exception was set."); 43080 } 43081 goto __label_876;} 43082 } 43083 // We expect NPY_FLOAT64 43084 if (!PyArray_ISALIGNED((PyArrayObject*) py_V875)) { 43085 PyArrayObject * tmp = (PyArrayObject*) py_V875; 43086 PyErr_Format(PyExc_NotImplementedError, 43087 "expected an aligned array of type %ld " 43088 "(NPY_FLOAT64), got non-aligned array of type %ld" 43089 " with %ld dimensions, with 3 last dims " 43090 "%ld, %ld, %ld" 43091 " and 3 last strides %ld %ld, %ld.", 43092 (long int) NPY_FLOAT64, 43093 (long int) PyArray_TYPE((PyArrayObject*) py_V875), 43094 (long int) PyArray_NDIM(tmp), 43095 (long int) (PyArray_NDIM(tmp) >= 3 ? 43096 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 43097 (long int) (PyArray_NDIM(tmp) >= 2 ? 43098 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 43099 (long int) (PyArray_NDIM(tmp) >= 1 ? 43100 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 43101 (long int) (PyArray_NDIM(tmp) >= 3 ? 43102 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 43103 (long int) (PyArray_NDIM(tmp) >= 2 ? 43104 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 43105 (long int) (PyArray_NDIM(tmp) >= 1 ? 43106 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 43107 ); 43108 { 43109 __failure = 876; 43110 if (!PyErr_Occurred()) { 43111 PyErr_SetString(PyExc_RuntimeError, 43112 "Unexpected error in an Op's C code. " 43113 "No Python exception was set."); 43114 } 43115 goto __label_876;} 43116 } 43117 // This is a TypeError to be consistent with DEBUG_MODE 43118 // Note: DEBUG_MODE also tells the name of the container 43119 if (PyArray_TYPE((PyArrayObject*) py_V875) != NPY_FLOAT64) { 43120 PyErr_Format(PyExc_TypeError, 43121 "expected type_num %d (NPY_FLOAT64) got %d", 43122 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V875)); 43123 { 43124 __failure = 876; 43125 if (!PyErr_Occurred()) { 43126 PyErr_SetString(PyExc_RuntimeError, 43127 "Unexpected error in an Op's C code. " 43128 "No Python exception was set."); 43129 } 43130 goto __label_876;} 43131 } 43132 43133 V875 = (PyArrayObject*)(py_V875); 43134 Py_XINCREF(V875); 43135 43136 { 43137 43138 py_V877 = PyList_GET_ITEM(storage_V877, 0); 43139 {Py_XINCREF(py_V877);} 43140 43141 V877 = NULL; 43142 if (py_V877 == Py_None) { 43143 // We can either fail here or set V877 to NULL and rely on Ops 43144 // using tensors to handle the NULL case, but if they fail to do so 43145 // they'll end up with nasty segfaults, so this is public service. 43146 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 43147 { 43148 __failure = 878; 43149 if (!PyErr_Occurred()) { 43150 PyErr_SetString(PyExc_RuntimeError, 43151 "Unexpected error in an Op's C code. " 43152 "No Python exception was set."); 43153 } 43154 goto __label_878;} 43155 } 43156 if (!PyArray_Check(py_V877)) { 43157 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 43158 { 43159 __failure = 878; 43160 if (!PyErr_Occurred()) { 43161 PyErr_SetString(PyExc_RuntimeError, 43162 "Unexpected error in an Op's C code. " 43163 "No Python exception was set."); 43164 } 43165 goto __label_878;} 43166 } 43167 // We expect NPY_FLOAT64 43168 if (!PyArray_ISALIGNED((PyArrayObject*) py_V877)) { 43169 PyArrayObject * tmp = (PyArrayObject*) py_V877; 43170 PyErr_Format(PyExc_NotImplementedError, 43171 "expected an aligned array of type %ld " 43172 "(NPY_FLOAT64), got non-aligned array of type %ld" 43173 " with %ld dimensions, with 3 last dims " 43174 "%ld, %ld, %ld" 43175 " and 3 last strides %ld %ld, %ld.", 43176 (long int) NPY_FLOAT64, 43177 (long int) PyArray_TYPE((PyArrayObject*) py_V877), 43178 (long int) PyArray_NDIM(tmp), 43179 (long int) (PyArray_NDIM(tmp) >= 3 ? 43180 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 43181 (long int) (PyArray_NDIM(tmp) >= 2 ? 43182 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 43183 (long int) (PyArray_NDIM(tmp) >= 1 ? 43184 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 43185 (long int) (PyArray_NDIM(tmp) >= 3 ? 43186 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 43187 (long int) (PyArray_NDIM(tmp) >= 2 ? 43188 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 43189 (long int) (PyArray_NDIM(tmp) >= 1 ? 43190 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 43191 ); 43192 { 43193 __failure = 878; 43194 if (!PyErr_Occurred()) { 43195 PyErr_SetString(PyExc_RuntimeError, 43196 "Unexpected error in an Op's C code. " 43197 "No Python exception was set."); 43198 } 43199 goto __label_878;} 43200 } 43201 // This is a TypeError to be consistent with DEBUG_MODE 43202 // Note: DEBUG_MODE also tells the name of the container 43203 if (PyArray_TYPE((PyArrayObject*) py_V877) != NPY_FLOAT64) { 43204 PyErr_Format(PyExc_TypeError, 43205 "expected type_num %d (NPY_FLOAT64) got %d", 43206 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V877)); 43207 { 43208 __failure = 878; 43209 if (!PyErr_Occurred()) { 43210 PyErr_SetString(PyExc_RuntimeError, 43211 "Unexpected error in an Op's C code. " 43212 "No Python exception was set."); 43213 } 43214 goto __label_878;} 43215 } 43216 43217 V877 = (PyArrayObject*)(py_V877); 43218 Py_XINCREF(V877); 43219 43220 { 43221 43222 py_V879 = PyList_GET_ITEM(storage_V879, 0); 43223 {Py_XINCREF(py_V879);} 43224 43225 V879 = NULL; 43226 if (py_V879 == Py_None) { 43227 // We can either fail here or set V879 to NULL and rely on Ops 43228 // using tensors to handle the NULL case, but if they fail to do so 43229 // they'll end up with nasty segfaults, so this is public service. 43230 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 43231 { 43232 __failure = 880; 43233 if (!PyErr_Occurred()) { 43234 PyErr_SetString(PyExc_RuntimeError, 43235 "Unexpected error in an Op's C code. " 43236 "No Python exception was set."); 43237 } 43238 goto __label_880;} 43239 } 43240 if (!PyArray_Check(py_V879)) { 43241 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 43242 { 43243 __failure = 880; 43244 if (!PyErr_Occurred()) { 43245 PyErr_SetString(PyExc_RuntimeError, 43246 "Unexpected error in an Op's C code. " 43247 "No Python exception was set."); 43248 } 43249 goto __label_880;} 43250 } 43251 // We expect NPY_FLOAT64 43252 if (!PyArray_ISALIGNED((PyArrayObject*) py_V879)) { 43253 PyArrayObject * tmp = (PyArrayObject*) py_V879; 43254 PyErr_Format(PyExc_NotImplementedError, 43255 "expected an aligned array of type %ld " 43256 "(NPY_FLOAT64), got non-aligned array of type %ld" 43257 " with %ld dimensions, with 3 last dims " 43258 "%ld, %ld, %ld" 43259 " and 3 last strides %ld %ld, %ld.", 43260 (long int) NPY_FLOAT64, 43261 (long int) PyArray_TYPE((PyArrayObject*) py_V879), 43262 (long int) PyArray_NDIM(tmp), 43263 (long int) (PyArray_NDIM(tmp) >= 3 ? 43264 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 43265 (long int) (PyArray_NDIM(tmp) >= 2 ? 43266 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 43267 (long int) (PyArray_NDIM(tmp) >= 1 ? 43268 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 43269 (long int) (PyArray_NDIM(tmp) >= 3 ? 43270 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 43271 (long int) (PyArray_NDIM(tmp) >= 2 ? 43272 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 43273 (long int) (PyArray_NDIM(tmp) >= 1 ? 43274 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 43275 ); 43276 { 43277 __failure = 880; 43278 if (!PyErr_Occurred()) { 43279 PyErr_SetString(PyExc_RuntimeError, 43280 "Unexpected error in an Op's C code. " 43281 "No Python exception was set."); 43282 } 43283 goto __label_880;} 43284 } 43285 // This is a TypeError to be consistent with DEBUG_MODE 43286 // Note: DEBUG_MODE also tells the name of the container 43287 if (PyArray_TYPE((PyArrayObject*) py_V879) != NPY_FLOAT64) { 43288 PyErr_Format(PyExc_TypeError, 43289 "expected type_num %d (NPY_FLOAT64) got %d", 43290 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V879)); 43291 { 43292 __failure = 880; 43293 if (!PyErr_Occurred()) { 43294 PyErr_SetString(PyExc_RuntimeError, 43295 "Unexpected error in an Op's C code. " 43296 "No Python exception was set."); 43297 } 43298 goto __label_880;} 43299 } 43300 43301 V879 = (PyArrayObject*)(py_V879); 43302 Py_XINCREF(V879); 43303 43304 { 43305 43306 py_V881 = PyList_GET_ITEM(storage_V881, 0); 43307 {Py_XINCREF(py_V881);} 43308 43309 V881 = NULL; 43310 if (py_V881 == Py_None) { 43311 // We can either fail here or set V881 to NULL and rely on Ops 43312 // using tensors to handle the NULL case, but if they fail to do so 43313 // they'll end up with nasty segfaults, so this is public service. 43314 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 43315 { 43316 __failure = 882; 43317 if (!PyErr_Occurred()) { 43318 PyErr_SetString(PyExc_RuntimeError, 43319 "Unexpected error in an Op's C code. " 43320 "No Python exception was set."); 43321 } 43322 goto __label_882;} 43323 } 43324 if (!PyArray_Check(py_V881)) { 43325 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 43326 { 43327 __failure = 882; 43328 if (!PyErr_Occurred()) { 43329 PyErr_SetString(PyExc_RuntimeError, 43330 "Unexpected error in an Op's C code. " 43331 "No Python exception was set."); 43332 } 43333 goto __label_882;} 43334 } 43335 // We expect NPY_FLOAT64 43336 if (!PyArray_ISALIGNED((PyArrayObject*) py_V881)) { 43337 PyArrayObject * tmp = (PyArrayObject*) py_V881; 43338 PyErr_Format(PyExc_NotImplementedError, 43339 "expected an aligned array of type %ld " 43340 "(NPY_FLOAT64), got non-aligned array of type %ld" 43341 " with %ld dimensions, with 3 last dims " 43342 "%ld, %ld, %ld" 43343 " and 3 last strides %ld %ld, %ld.", 43344 (long int) NPY_FLOAT64, 43345 (long int) PyArray_TYPE((PyArrayObject*) py_V881), 43346 (long int) PyArray_NDIM(tmp), 43347 (long int) (PyArray_NDIM(tmp) >= 3 ? 43348 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 43349 (long int) (PyArray_NDIM(tmp) >= 2 ? 43350 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 43351 (long int) (PyArray_NDIM(tmp) >= 1 ? 43352 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 43353 (long int) (PyArray_NDIM(tmp) >= 3 ? 43354 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 43355 (long int) (PyArray_NDIM(tmp) >= 2 ? 43356 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 43357 (long int) (PyArray_NDIM(tmp) >= 1 ? 43358 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 43359 ); 43360 { 43361 __failure = 882; 43362 if (!PyErr_Occurred()) { 43363 PyErr_SetString(PyExc_RuntimeError, 43364 "Unexpected error in an Op's C code. " 43365 "No Python exception was set."); 43366 } 43367 goto __label_882;} 43368 } 43369 // This is a TypeError to be consistent with DEBUG_MODE 43370 // Note: DEBUG_MODE also tells the name of the container 43371 if (PyArray_TYPE((PyArrayObject*) py_V881) != NPY_FLOAT64) { 43372 PyErr_Format(PyExc_TypeError, 43373 "expected type_num %d (NPY_FLOAT64) got %d", 43374 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V881)); 43375 { 43376 __failure = 882; 43377 if (!PyErr_Occurred()) { 43378 PyErr_SetString(PyExc_RuntimeError, 43379 "Unexpected error in an Op's C code. " 43380 "No Python exception was set."); 43381 } 43382 goto __label_882;} 43383 } 43384 43385 V881 = (PyArrayObject*)(py_V881); 43386 Py_XINCREF(V881); 43387 43388 { 43389 43390 py_V883 = PyList_GET_ITEM(storage_V883, 0); 43391 {Py_XINCREF(py_V883);} 43392 43393 V883 = NULL; 43394 if (py_V883 == Py_None) { 43395 // We can either fail here or set V883 to NULL and rely on Ops 43396 // using tensors to handle the NULL case, but if they fail to do so 43397 // they'll end up with nasty segfaults, so this is public service. 43398 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 43399 { 43400 __failure = 884; 43401 if (!PyErr_Occurred()) { 43402 PyErr_SetString(PyExc_RuntimeError, 43403 "Unexpected error in an Op's C code. " 43404 "No Python exception was set."); 43405 } 43406 goto __label_884;} 43407 } 43408 if (!PyArray_Check(py_V883)) { 43409 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 43410 { 43411 __failure = 884; 43412 if (!PyErr_Occurred()) { 43413 PyErr_SetString(PyExc_RuntimeError, 43414 "Unexpected error in an Op's C code. " 43415 "No Python exception was set."); 43416 } 43417 goto __label_884;} 43418 } 43419 // We expect NPY_FLOAT64 43420 if (!PyArray_ISALIGNED((PyArrayObject*) py_V883)) { 43421 PyArrayObject * tmp = (PyArrayObject*) py_V883; 43422 PyErr_Format(PyExc_NotImplementedError, 43423 "expected an aligned array of type %ld " 43424 "(NPY_FLOAT64), got non-aligned array of type %ld" 43425 " with %ld dimensions, with 3 last dims " 43426 "%ld, %ld, %ld" 43427 " and 3 last strides %ld %ld, %ld.", 43428 (long int) NPY_FLOAT64, 43429 (long int) PyArray_TYPE((PyArrayObject*) py_V883), 43430 (long int) PyArray_NDIM(tmp), 43431 (long int) (PyArray_NDIM(tmp) >= 3 ? 43432 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 43433 (long int) (PyArray_NDIM(tmp) >= 2 ? 43434 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 43435 (long int) (PyArray_NDIM(tmp) >= 1 ? 43436 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 43437 (long int) (PyArray_NDIM(tmp) >= 3 ? 43438 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 43439 (long int) (PyArray_NDIM(tmp) >= 2 ? 43440 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 43441 (long int) (PyArray_NDIM(tmp) >= 1 ? 43442 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 43443 ); 43444 { 43445 __failure = 884; 43446 if (!PyErr_Occurred()) { 43447 PyErr_SetString(PyExc_RuntimeError, 43448 "Unexpected error in an Op's C code. " 43449 "No Python exception was set."); 43450 } 43451 goto __label_884;} 43452 } 43453 // This is a TypeError to be consistent with DEBUG_MODE 43454 // Note: DEBUG_MODE also tells the name of the container 43455 if (PyArray_TYPE((PyArrayObject*) py_V883) != NPY_FLOAT64) { 43456 PyErr_Format(PyExc_TypeError, 43457 "expected type_num %d (NPY_FLOAT64) got %d", 43458 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V883)); 43459 { 43460 __failure = 884; 43461 if (!PyErr_Occurred()) { 43462 PyErr_SetString(PyExc_RuntimeError, 43463 "Unexpected error in an Op's C code. " 43464 "No Python exception was set."); 43465 } 43466 goto __label_884;} 43467 } 43468 43469 V883 = (PyArrayObject*)(py_V883); 43470 Py_XINCREF(V883); 43471 43472 { 43473 43474 py_V885 = PyList_GET_ITEM(storage_V885, 0); 43475 {Py_XINCREF(py_V885);} 43476 43477 V885 = NULL; 43478 if (py_V885 == Py_None) { 43479 // We can either fail here or set V885 to NULL and rely on Ops 43480 // using tensors to handle the NULL case, but if they fail to do so 43481 // they'll end up with nasty segfaults, so this is public service. 43482 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 43483 { 43484 __failure = 886; 43485 if (!PyErr_Occurred()) { 43486 PyErr_SetString(PyExc_RuntimeError, 43487 "Unexpected error in an Op's C code. " 43488 "No Python exception was set."); 43489 } 43490 goto __label_886;} 43491 } 43492 if (!PyArray_Check(py_V885)) { 43493 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 43494 { 43495 __failure = 886; 43496 if (!PyErr_Occurred()) { 43497 PyErr_SetString(PyExc_RuntimeError, 43498 "Unexpected error in an Op's C code. " 43499 "No Python exception was set."); 43500 } 43501 goto __label_886;} 43502 } 43503 // We expect NPY_FLOAT64 43504 if (!PyArray_ISALIGNED((PyArrayObject*) py_V885)) { 43505 PyArrayObject * tmp = (PyArrayObject*) py_V885; 43506 PyErr_Format(PyExc_NotImplementedError, 43507 "expected an aligned array of type %ld " 43508 "(NPY_FLOAT64), got non-aligned array of type %ld" 43509 " with %ld dimensions, with 3 last dims " 43510 "%ld, %ld, %ld" 43511 " and 3 last strides %ld %ld, %ld.", 43512 (long int) NPY_FLOAT64, 43513 (long int) PyArray_TYPE((PyArrayObject*) py_V885), 43514 (long int) PyArray_NDIM(tmp), 43515 (long int) (PyArray_NDIM(tmp) >= 3 ? 43516 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 43517 (long int) (PyArray_NDIM(tmp) >= 2 ? 43518 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 43519 (long int) (PyArray_NDIM(tmp) >= 1 ? 43520 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 43521 (long int) (PyArray_NDIM(tmp) >= 3 ? 43522 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 43523 (long int) (PyArray_NDIM(tmp) >= 2 ? 43524 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 43525 (long int) (PyArray_NDIM(tmp) >= 1 ? 43526 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 43527 ); 43528 { 43529 __failure = 886; 43530 if (!PyErr_Occurred()) { 43531 PyErr_SetString(PyExc_RuntimeError, 43532 "Unexpected error in an Op's C code. " 43533 "No Python exception was set."); 43534 } 43535 goto __label_886;} 43536 } 43537 // This is a TypeError to be consistent with DEBUG_MODE 43538 // Note: DEBUG_MODE also tells the name of the container 43539 if (PyArray_TYPE((PyArrayObject*) py_V885) != NPY_FLOAT64) { 43540 PyErr_Format(PyExc_TypeError, 43541 "expected type_num %d (NPY_FLOAT64) got %d", 43542 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V885)); 43543 { 43544 __failure = 886; 43545 if (!PyErr_Occurred()) { 43546 PyErr_SetString(PyExc_RuntimeError, 43547 "Unexpected error in an Op's C code. " 43548 "No Python exception was set."); 43549 } 43550 goto __label_886;} 43551 } 43552 43553 V885 = (PyArrayObject*)(py_V885); 43554 Py_XINCREF(V885); 43555 43556 { 43557 43558 py_V887 = PyList_GET_ITEM(storage_V887, 0); 43559 {Py_XINCREF(py_V887);} 43560 43561 V887 = NULL; 43562 if (py_V887 == Py_None) { 43563 // We can either fail here or set V887 to NULL and rely on Ops 43564 // using tensors to handle the NULL case, but if they fail to do so 43565 // they'll end up with nasty segfaults, so this is public service. 43566 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 43567 { 43568 __failure = 888; 43569 if (!PyErr_Occurred()) { 43570 PyErr_SetString(PyExc_RuntimeError, 43571 "Unexpected error in an Op's C code. " 43572 "No Python exception was set."); 43573 } 43574 goto __label_888;} 43575 } 43576 if (!PyArray_Check(py_V887)) { 43577 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 43578 { 43579 __failure = 888; 43580 if (!PyErr_Occurred()) { 43581 PyErr_SetString(PyExc_RuntimeError, 43582 "Unexpected error in an Op's C code. " 43583 "No Python exception was set."); 43584 } 43585 goto __label_888;} 43586 } 43587 // We expect NPY_FLOAT64 43588 if (!PyArray_ISALIGNED((PyArrayObject*) py_V887)) { 43589 PyArrayObject * tmp = (PyArrayObject*) py_V887; 43590 PyErr_Format(PyExc_NotImplementedError, 43591 "expected an aligned array of type %ld " 43592 "(NPY_FLOAT64), got non-aligned array of type %ld" 43593 " with %ld dimensions, with 3 last dims " 43594 "%ld, %ld, %ld" 43595 " and 3 last strides %ld %ld, %ld.", 43596 (long int) NPY_FLOAT64, 43597 (long int) PyArray_TYPE((PyArrayObject*) py_V887), 43598 (long int) PyArray_NDIM(tmp), 43599 (long int) (PyArray_NDIM(tmp) >= 3 ? 43600 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 43601 (long int) (PyArray_NDIM(tmp) >= 2 ? 43602 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 43603 (long int) (PyArray_NDIM(tmp) >= 1 ? 43604 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 43605 (long int) (PyArray_NDIM(tmp) >= 3 ? 43606 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 43607 (long int) (PyArray_NDIM(tmp) >= 2 ? 43608 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 43609 (long int) (PyArray_NDIM(tmp) >= 1 ? 43610 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 43611 ); 43612 { 43613 __failure = 888; 43614 if (!PyErr_Occurred()) { 43615 PyErr_SetString(PyExc_RuntimeError, 43616 "Unexpected error in an Op's C code. " 43617 "No Python exception was set."); 43618 } 43619 goto __label_888;} 43620 } 43621 // This is a TypeError to be consistent with DEBUG_MODE 43622 // Note: DEBUG_MODE also tells the name of the container 43623 if (PyArray_TYPE((PyArrayObject*) py_V887) != NPY_FLOAT64) { 43624 PyErr_Format(PyExc_TypeError, 43625 "expected type_num %d (NPY_FLOAT64) got %d", 43626 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V887)); 43627 { 43628 __failure = 888; 43629 if (!PyErr_Occurred()) { 43630 PyErr_SetString(PyExc_RuntimeError, 43631 "Unexpected error in an Op's C code. " 43632 "No Python exception was set."); 43633 } 43634 goto __label_888;} 43635 } 43636 43637 V887 = (PyArrayObject*)(py_V887); 43638 Py_XINCREF(V887); 43639 43640 { 43641 43642 py_V889 = PyList_GET_ITEM(storage_V889, 0); 43643 {Py_XINCREF(py_V889);} 43644 43645 V889 = NULL; 43646 if (py_V889 == Py_None) { 43647 // We can either fail here or set V889 to NULL and rely on Ops 43648 // using tensors to handle the NULL case, but if they fail to do so 43649 // they'll end up with nasty segfaults, so this is public service. 43650 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 43651 { 43652 __failure = 890; 43653 if (!PyErr_Occurred()) { 43654 PyErr_SetString(PyExc_RuntimeError, 43655 "Unexpected error in an Op's C code. " 43656 "No Python exception was set."); 43657 } 43658 goto __label_890;} 43659 } 43660 if (!PyArray_Check(py_V889)) { 43661 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 43662 { 43663 __failure = 890; 43664 if (!PyErr_Occurred()) { 43665 PyErr_SetString(PyExc_RuntimeError, 43666 "Unexpected error in an Op's C code. " 43667 "No Python exception was set."); 43668 } 43669 goto __label_890;} 43670 } 43671 // We expect NPY_FLOAT64 43672 if (!PyArray_ISALIGNED((PyArrayObject*) py_V889)) { 43673 PyArrayObject * tmp = (PyArrayObject*) py_V889; 43674 PyErr_Format(PyExc_NotImplementedError, 43675 "expected an aligned array of type %ld " 43676 "(NPY_FLOAT64), got non-aligned array of type %ld" 43677 " with %ld dimensions, with 3 last dims " 43678 "%ld, %ld, %ld" 43679 " and 3 last strides %ld %ld, %ld.", 43680 (long int) NPY_FLOAT64, 43681 (long int) PyArray_TYPE((PyArrayObject*) py_V889), 43682 (long int) PyArray_NDIM(tmp), 43683 (long int) (PyArray_NDIM(tmp) >= 3 ? 43684 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 43685 (long int) (PyArray_NDIM(tmp) >= 2 ? 43686 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 43687 (long int) (PyArray_NDIM(tmp) >= 1 ? 43688 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 43689 (long int) (PyArray_NDIM(tmp) >= 3 ? 43690 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 43691 (long int) (PyArray_NDIM(tmp) >= 2 ? 43692 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 43693 (long int) (PyArray_NDIM(tmp) >= 1 ? 43694 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 43695 ); 43696 { 43697 __failure = 890; 43698 if (!PyErr_Occurred()) { 43699 PyErr_SetString(PyExc_RuntimeError, 43700 "Unexpected error in an Op's C code. " 43701 "No Python exception was set."); 43702 } 43703 goto __label_890;} 43704 } 43705 // This is a TypeError to be consistent with DEBUG_MODE 43706 // Note: DEBUG_MODE also tells the name of the container 43707 if (PyArray_TYPE((PyArrayObject*) py_V889) != NPY_FLOAT64) { 43708 PyErr_Format(PyExc_TypeError, 43709 "expected type_num %d (NPY_FLOAT64) got %d", 43710 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V889)); 43711 { 43712 __failure = 890; 43713 if (!PyErr_Occurred()) { 43714 PyErr_SetString(PyExc_RuntimeError, 43715 "Unexpected error in an Op's C code. " 43716 "No Python exception was set."); 43717 } 43718 goto __label_890;} 43719 } 43720 43721 V889 = (PyArrayObject*)(py_V889); 43722 Py_XINCREF(V889); 43723 43724 { 43725 43726 py_V891 = PyList_GET_ITEM(storage_V891, 0); 43727 {Py_XINCREF(py_V891);} 43728 43729 V891 = NULL; 43730 if (py_V891 == Py_None) { 43731 // We can either fail here or set V891 to NULL and rely on Ops 43732 // using tensors to handle the NULL case, but if they fail to do so 43733 // they'll end up with nasty segfaults, so this is public service. 43734 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 43735 { 43736 __failure = 892; 43737 if (!PyErr_Occurred()) { 43738 PyErr_SetString(PyExc_RuntimeError, 43739 "Unexpected error in an Op's C code. " 43740 "No Python exception was set."); 43741 } 43742 goto __label_892;} 43743 } 43744 if (!PyArray_Check(py_V891)) { 43745 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 43746 { 43747 __failure = 892; 43748 if (!PyErr_Occurred()) { 43749 PyErr_SetString(PyExc_RuntimeError, 43750 "Unexpected error in an Op's C code. " 43751 "No Python exception was set."); 43752 } 43753 goto __label_892;} 43754 } 43755 // We expect NPY_FLOAT64 43756 if (!PyArray_ISALIGNED((PyArrayObject*) py_V891)) { 43757 PyArrayObject * tmp = (PyArrayObject*) py_V891; 43758 PyErr_Format(PyExc_NotImplementedError, 43759 "expected an aligned array of type %ld " 43760 "(NPY_FLOAT64), got non-aligned array of type %ld" 43761 " with %ld dimensions, with 3 last dims " 43762 "%ld, %ld, %ld" 43763 " and 3 last strides %ld %ld, %ld.", 43764 (long int) NPY_FLOAT64, 43765 (long int) PyArray_TYPE((PyArrayObject*) py_V891), 43766 (long int) PyArray_NDIM(tmp), 43767 (long int) (PyArray_NDIM(tmp) >= 3 ? 43768 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 43769 (long int) (PyArray_NDIM(tmp) >= 2 ? 43770 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 43771 (long int) (PyArray_NDIM(tmp) >= 1 ? 43772 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 43773 (long int) (PyArray_NDIM(tmp) >= 3 ? 43774 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 43775 (long int) (PyArray_NDIM(tmp) >= 2 ? 43776 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 43777 (long int) (PyArray_NDIM(tmp) >= 1 ? 43778 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 43779 ); 43780 { 43781 __failure = 892; 43782 if (!PyErr_Occurred()) { 43783 PyErr_SetString(PyExc_RuntimeError, 43784 "Unexpected error in an Op's C code. " 43785 "No Python exception was set."); 43786 } 43787 goto __label_892;} 43788 } 43789 // This is a TypeError to be consistent with DEBUG_MODE 43790 // Note: DEBUG_MODE also tells the name of the container 43791 if (PyArray_TYPE((PyArrayObject*) py_V891) != NPY_FLOAT64) { 43792 PyErr_Format(PyExc_TypeError, 43793 "expected type_num %d (NPY_FLOAT64) got %d", 43794 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V891)); 43795 { 43796 __failure = 892; 43797 if (!PyErr_Occurred()) { 43798 PyErr_SetString(PyExc_RuntimeError, 43799 "Unexpected error in an Op's C code. " 43800 "No Python exception was set."); 43801 } 43802 goto __label_892;} 43803 } 43804 43805 V891 = (PyArrayObject*)(py_V891); 43806 Py_XINCREF(V891); 43807 43808 { 43809 43810 py_V893 = PyList_GET_ITEM(storage_V893, 0); 43811 {Py_XINCREF(py_V893);} 43812 43813 V893 = NULL; 43814 if (py_V893 == Py_None) { 43815 // We can either fail here or set V893 to NULL and rely on Ops 43816 // using tensors to handle the NULL case, but if they fail to do so 43817 // they'll end up with nasty segfaults, so this is public service. 43818 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 43819 { 43820 __failure = 894; 43821 if (!PyErr_Occurred()) { 43822 PyErr_SetString(PyExc_RuntimeError, 43823 "Unexpected error in an Op's C code. " 43824 "No Python exception was set."); 43825 } 43826 goto __label_894;} 43827 } 43828 if (!PyArray_Check(py_V893)) { 43829 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 43830 { 43831 __failure = 894; 43832 if (!PyErr_Occurred()) { 43833 PyErr_SetString(PyExc_RuntimeError, 43834 "Unexpected error in an Op's C code. " 43835 "No Python exception was set."); 43836 } 43837 goto __label_894;} 43838 } 43839 // We expect NPY_FLOAT64 43840 if (!PyArray_ISALIGNED((PyArrayObject*) py_V893)) { 43841 PyArrayObject * tmp = (PyArrayObject*) py_V893; 43842 PyErr_Format(PyExc_NotImplementedError, 43843 "expected an aligned array of type %ld " 43844 "(NPY_FLOAT64), got non-aligned array of type %ld" 43845 " with %ld dimensions, with 3 last dims " 43846 "%ld, %ld, %ld" 43847 " and 3 last strides %ld %ld, %ld.", 43848 (long int) NPY_FLOAT64, 43849 (long int) PyArray_TYPE((PyArrayObject*) py_V893), 43850 (long int) PyArray_NDIM(tmp), 43851 (long int) (PyArray_NDIM(tmp) >= 3 ? 43852 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 43853 (long int) (PyArray_NDIM(tmp) >= 2 ? 43854 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 43855 (long int) (PyArray_NDIM(tmp) >= 1 ? 43856 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 43857 (long int) (PyArray_NDIM(tmp) >= 3 ? 43858 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 43859 (long int) (PyArray_NDIM(tmp) >= 2 ? 43860 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 43861 (long int) (PyArray_NDIM(tmp) >= 1 ? 43862 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 43863 ); 43864 { 43865 __failure = 894; 43866 if (!PyErr_Occurred()) { 43867 PyErr_SetString(PyExc_RuntimeError, 43868 "Unexpected error in an Op's C code. " 43869 "No Python exception was set."); 43870 } 43871 goto __label_894;} 43872 } 43873 // This is a TypeError to be consistent with DEBUG_MODE 43874 // Note: DEBUG_MODE also tells the name of the container 43875 if (PyArray_TYPE((PyArrayObject*) py_V893) != NPY_FLOAT64) { 43876 PyErr_Format(PyExc_TypeError, 43877 "expected type_num %d (NPY_FLOAT64) got %d", 43878 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V893)); 43879 { 43880 __failure = 894; 43881 if (!PyErr_Occurred()) { 43882 PyErr_SetString(PyExc_RuntimeError, 43883 "Unexpected error in an Op's C code. " 43884 "No Python exception was set."); 43885 } 43886 goto __label_894;} 43887 } 43888 43889 V893 = (PyArrayObject*)(py_V893); 43890 Py_XINCREF(V893); 43891 43892 { 43893 43894 py_V895 = PyList_GET_ITEM(storage_V895, 0); 43895 {Py_XINCREF(py_V895);} 43896 43897 V895 = NULL; 43898 if (py_V895 == Py_None) { 43899 // We can either fail here or set V895 to NULL and rely on Ops 43900 // using tensors to handle the NULL case, but if they fail to do so 43901 // they'll end up with nasty segfaults, so this is public service. 43902 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 43903 { 43904 __failure = 896; 43905 if (!PyErr_Occurred()) { 43906 PyErr_SetString(PyExc_RuntimeError, 43907 "Unexpected error in an Op's C code. " 43908 "No Python exception was set."); 43909 } 43910 goto __label_896;} 43911 } 43912 if (!PyArray_Check(py_V895)) { 43913 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 43914 { 43915 __failure = 896; 43916 if (!PyErr_Occurred()) { 43917 PyErr_SetString(PyExc_RuntimeError, 43918 "Unexpected error in an Op's C code. " 43919 "No Python exception was set."); 43920 } 43921 goto __label_896;} 43922 } 43923 // We expect NPY_FLOAT64 43924 if (!PyArray_ISALIGNED((PyArrayObject*) py_V895)) { 43925 PyArrayObject * tmp = (PyArrayObject*) py_V895; 43926 PyErr_Format(PyExc_NotImplementedError, 43927 "expected an aligned array of type %ld " 43928 "(NPY_FLOAT64), got non-aligned array of type %ld" 43929 " with %ld dimensions, with 3 last dims " 43930 "%ld, %ld, %ld" 43931 " and 3 last strides %ld %ld, %ld.", 43932 (long int) NPY_FLOAT64, 43933 (long int) PyArray_TYPE((PyArrayObject*) py_V895), 43934 (long int) PyArray_NDIM(tmp), 43935 (long int) (PyArray_NDIM(tmp) >= 3 ? 43936 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 43937 (long int) (PyArray_NDIM(tmp) >= 2 ? 43938 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 43939 (long int) (PyArray_NDIM(tmp) >= 1 ? 43940 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 43941 (long int) (PyArray_NDIM(tmp) >= 3 ? 43942 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 43943 (long int) (PyArray_NDIM(tmp) >= 2 ? 43944 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 43945 (long int) (PyArray_NDIM(tmp) >= 1 ? 43946 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 43947 ); 43948 { 43949 __failure = 896; 43950 if (!PyErr_Occurred()) { 43951 PyErr_SetString(PyExc_RuntimeError, 43952 "Unexpected error in an Op's C code. " 43953 "No Python exception was set."); 43954 } 43955 goto __label_896;} 43956 } 43957 // This is a TypeError to be consistent with DEBUG_MODE 43958 // Note: DEBUG_MODE also tells the name of the container 43959 if (PyArray_TYPE((PyArrayObject*) py_V895) != NPY_FLOAT64) { 43960 PyErr_Format(PyExc_TypeError, 43961 "expected type_num %d (NPY_FLOAT64) got %d", 43962 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V895)); 43963 { 43964 __failure = 896; 43965 if (!PyErr_Occurred()) { 43966 PyErr_SetString(PyExc_RuntimeError, 43967 "Unexpected error in an Op's C code. " 43968 "No Python exception was set."); 43969 } 43970 goto __label_896;} 43971 } 43972 43973 V895 = (PyArrayObject*)(py_V895); 43974 Py_XINCREF(V895); 43975 43976 { 43977 43978 py_V897 = PyList_GET_ITEM(storage_V897, 0); 43979 {Py_XINCREF(py_V897);} 43980 43981 V897 = NULL; 43982 if (py_V897 == Py_None) { 43983 // We can either fail here or set V897 to NULL and rely on Ops 43984 // using tensors to handle the NULL case, but if they fail to do so 43985 // they'll end up with nasty segfaults, so this is public service. 43986 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 43987 { 43988 __failure = 898; 43989 if (!PyErr_Occurred()) { 43990 PyErr_SetString(PyExc_RuntimeError, 43991 "Unexpected error in an Op's C code. " 43992 "No Python exception was set."); 43993 } 43994 goto __label_898;} 43995 } 43996 if (!PyArray_Check(py_V897)) { 43997 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 43998 { 43999 __failure = 898; 44000 if (!PyErr_Occurred()) { 44001 PyErr_SetString(PyExc_RuntimeError, 44002 "Unexpected error in an Op's C code. " 44003 "No Python exception was set."); 44004 } 44005 goto __label_898;} 44006 } 44007 // We expect NPY_FLOAT64 44008 if (!PyArray_ISALIGNED((PyArrayObject*) py_V897)) { 44009 PyArrayObject * tmp = (PyArrayObject*) py_V897; 44010 PyErr_Format(PyExc_NotImplementedError, 44011 "expected an aligned array of type %ld " 44012 "(NPY_FLOAT64), got non-aligned array of type %ld" 44013 " with %ld dimensions, with 3 last dims " 44014 "%ld, %ld, %ld" 44015 " and 3 last strides %ld %ld, %ld.", 44016 (long int) NPY_FLOAT64, 44017 (long int) PyArray_TYPE((PyArrayObject*) py_V897), 44018 (long int) PyArray_NDIM(tmp), 44019 (long int) (PyArray_NDIM(tmp) >= 3 ? 44020 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 44021 (long int) (PyArray_NDIM(tmp) >= 2 ? 44022 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 44023 (long int) (PyArray_NDIM(tmp) >= 1 ? 44024 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 44025 (long int) (PyArray_NDIM(tmp) >= 3 ? 44026 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 44027 (long int) (PyArray_NDIM(tmp) >= 2 ? 44028 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 44029 (long int) (PyArray_NDIM(tmp) >= 1 ? 44030 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 44031 ); 44032 { 44033 __failure = 898; 44034 if (!PyErr_Occurred()) { 44035 PyErr_SetString(PyExc_RuntimeError, 44036 "Unexpected error in an Op's C code. " 44037 "No Python exception was set."); 44038 } 44039 goto __label_898;} 44040 } 44041 // This is a TypeError to be consistent with DEBUG_MODE 44042 // Note: DEBUG_MODE also tells the name of the container 44043 if (PyArray_TYPE((PyArrayObject*) py_V897) != NPY_FLOAT64) { 44044 PyErr_Format(PyExc_TypeError, 44045 "expected type_num %d (NPY_FLOAT64) got %d", 44046 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V897)); 44047 { 44048 __failure = 898; 44049 if (!PyErr_Occurred()) { 44050 PyErr_SetString(PyExc_RuntimeError, 44051 "Unexpected error in an Op's C code. " 44052 "No Python exception was set."); 44053 } 44054 goto __label_898;} 44055 } 44056 44057 V897 = (PyArrayObject*)(py_V897); 44058 Py_XINCREF(V897); 44059 44060 { 44061 44062 py_V899 = PyList_GET_ITEM(storage_V899, 0); 44063 {Py_XINCREF(py_V899);} 44064 44065 V899 = NULL; 44066 if (py_V899 == Py_None) { 44067 // We can either fail here or set V899 to NULL and rely on Ops 44068 // using tensors to handle the NULL case, but if they fail to do so 44069 // they'll end up with nasty segfaults, so this is public service. 44070 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 44071 { 44072 __failure = 900; 44073 if (!PyErr_Occurred()) { 44074 PyErr_SetString(PyExc_RuntimeError, 44075 "Unexpected error in an Op's C code. " 44076 "No Python exception was set."); 44077 } 44078 goto __label_900;} 44079 } 44080 if (!PyArray_Check(py_V899)) { 44081 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 44082 { 44083 __failure = 900; 44084 if (!PyErr_Occurred()) { 44085 PyErr_SetString(PyExc_RuntimeError, 44086 "Unexpected error in an Op's C code. " 44087 "No Python exception was set."); 44088 } 44089 goto __label_900;} 44090 } 44091 // We expect NPY_FLOAT64 44092 if (!PyArray_ISALIGNED((PyArrayObject*) py_V899)) { 44093 PyArrayObject * tmp = (PyArrayObject*) py_V899; 44094 PyErr_Format(PyExc_NotImplementedError, 44095 "expected an aligned array of type %ld " 44096 "(NPY_FLOAT64), got non-aligned array of type %ld" 44097 " with %ld dimensions, with 3 last dims " 44098 "%ld, %ld, %ld" 44099 " and 3 last strides %ld %ld, %ld.", 44100 (long int) NPY_FLOAT64, 44101 (long int) PyArray_TYPE((PyArrayObject*) py_V899), 44102 (long int) PyArray_NDIM(tmp), 44103 (long int) (PyArray_NDIM(tmp) >= 3 ? 44104 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 44105 (long int) (PyArray_NDIM(tmp) >= 2 ? 44106 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 44107 (long int) (PyArray_NDIM(tmp) >= 1 ? 44108 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 44109 (long int) (PyArray_NDIM(tmp) >= 3 ? 44110 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 44111 (long int) (PyArray_NDIM(tmp) >= 2 ? 44112 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 44113 (long int) (PyArray_NDIM(tmp) >= 1 ? 44114 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 44115 ); 44116 { 44117 __failure = 900; 44118 if (!PyErr_Occurred()) { 44119 PyErr_SetString(PyExc_RuntimeError, 44120 "Unexpected error in an Op's C code. " 44121 "No Python exception was set."); 44122 } 44123 goto __label_900;} 44124 } 44125 // This is a TypeError to be consistent with DEBUG_MODE 44126 // Note: DEBUG_MODE also tells the name of the container 44127 if (PyArray_TYPE((PyArrayObject*) py_V899) != NPY_FLOAT64) { 44128 PyErr_Format(PyExc_TypeError, 44129 "expected type_num %d (NPY_FLOAT64) got %d", 44130 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V899)); 44131 { 44132 __failure = 900; 44133 if (!PyErr_Occurred()) { 44134 PyErr_SetString(PyExc_RuntimeError, 44135 "Unexpected error in an Op's C code. " 44136 "No Python exception was set."); 44137 } 44138 goto __label_900;} 44139 } 44140 44141 V899 = (PyArrayObject*)(py_V899); 44142 Py_XINCREF(V899); 44143 44144 { 44145 44146 py_V901 = PyList_GET_ITEM(storage_V901, 0); 44147 {Py_XINCREF(py_V901);} 44148 44149 V901 = NULL; 44150 if (py_V901 == Py_None) { 44151 // We can either fail here or set V901 to NULL and rely on Ops 44152 // using tensors to handle the NULL case, but if they fail to do so 44153 // they'll end up with nasty segfaults, so this is public service. 44154 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 44155 { 44156 __failure = 902; 44157 if (!PyErr_Occurred()) { 44158 PyErr_SetString(PyExc_RuntimeError, 44159 "Unexpected error in an Op's C code. " 44160 "No Python exception was set."); 44161 } 44162 goto __label_902;} 44163 } 44164 if (!PyArray_Check(py_V901)) { 44165 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 44166 { 44167 __failure = 902; 44168 if (!PyErr_Occurred()) { 44169 PyErr_SetString(PyExc_RuntimeError, 44170 "Unexpected error in an Op's C code. " 44171 "No Python exception was set."); 44172 } 44173 goto __label_902;} 44174 } 44175 // We expect NPY_FLOAT64 44176 if (!PyArray_ISALIGNED((PyArrayObject*) py_V901)) { 44177 PyArrayObject * tmp = (PyArrayObject*) py_V901; 44178 PyErr_Format(PyExc_NotImplementedError, 44179 "expected an aligned array of type %ld " 44180 "(NPY_FLOAT64), got non-aligned array of type %ld" 44181 " with %ld dimensions, with 3 last dims " 44182 "%ld, %ld, %ld" 44183 " and 3 last strides %ld %ld, %ld.", 44184 (long int) NPY_FLOAT64, 44185 (long int) PyArray_TYPE((PyArrayObject*) py_V901), 44186 (long int) PyArray_NDIM(tmp), 44187 (long int) (PyArray_NDIM(tmp) >= 3 ? 44188 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 44189 (long int) (PyArray_NDIM(tmp) >= 2 ? 44190 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 44191 (long int) (PyArray_NDIM(tmp) >= 1 ? 44192 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 44193 (long int) (PyArray_NDIM(tmp) >= 3 ? 44194 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 44195 (long int) (PyArray_NDIM(tmp) >= 2 ? 44196 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 44197 (long int) (PyArray_NDIM(tmp) >= 1 ? 44198 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 44199 ); 44200 { 44201 __failure = 902; 44202 if (!PyErr_Occurred()) { 44203 PyErr_SetString(PyExc_RuntimeError, 44204 "Unexpected error in an Op's C code. " 44205 "No Python exception was set."); 44206 } 44207 goto __label_902;} 44208 } 44209 // This is a TypeError to be consistent with DEBUG_MODE 44210 // Note: DEBUG_MODE also tells the name of the container 44211 if (PyArray_TYPE((PyArrayObject*) py_V901) != NPY_FLOAT64) { 44212 PyErr_Format(PyExc_TypeError, 44213 "expected type_num %d (NPY_FLOAT64) got %d", 44214 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V901)); 44215 { 44216 __failure = 902; 44217 if (!PyErr_Occurred()) { 44218 PyErr_SetString(PyExc_RuntimeError, 44219 "Unexpected error in an Op's C code. " 44220 "No Python exception was set."); 44221 } 44222 goto __label_902;} 44223 } 44224 44225 V901 = (PyArrayObject*)(py_V901); 44226 Py_XINCREF(V901); 44227 44228 { 44229 44230 py_V903 = PyList_GET_ITEM(storage_V903, 0); 44231 {Py_XINCREF(py_V903);} 44232 44233 V903 = NULL; 44234 if (py_V903 == Py_None) { 44235 // We can either fail here or set V903 to NULL and rely on Ops 44236 // using tensors to handle the NULL case, but if they fail to do so 44237 // they'll end up with nasty segfaults, so this is public service. 44238 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 44239 { 44240 __failure = 904; 44241 if (!PyErr_Occurred()) { 44242 PyErr_SetString(PyExc_RuntimeError, 44243 "Unexpected error in an Op's C code. " 44244 "No Python exception was set."); 44245 } 44246 goto __label_904;} 44247 } 44248 if (!PyArray_Check(py_V903)) { 44249 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 44250 { 44251 __failure = 904; 44252 if (!PyErr_Occurred()) { 44253 PyErr_SetString(PyExc_RuntimeError, 44254 "Unexpected error in an Op's C code. " 44255 "No Python exception was set."); 44256 } 44257 goto __label_904;} 44258 } 44259 // We expect NPY_FLOAT64 44260 if (!PyArray_ISALIGNED((PyArrayObject*) py_V903)) { 44261 PyArrayObject * tmp = (PyArrayObject*) py_V903; 44262 PyErr_Format(PyExc_NotImplementedError, 44263 "expected an aligned array of type %ld " 44264 "(NPY_FLOAT64), got non-aligned array of type %ld" 44265 " with %ld dimensions, with 3 last dims " 44266 "%ld, %ld, %ld" 44267 " and 3 last strides %ld %ld, %ld.", 44268 (long int) NPY_FLOAT64, 44269 (long int) PyArray_TYPE((PyArrayObject*) py_V903), 44270 (long int) PyArray_NDIM(tmp), 44271 (long int) (PyArray_NDIM(tmp) >= 3 ? 44272 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 44273 (long int) (PyArray_NDIM(tmp) >= 2 ? 44274 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 44275 (long int) (PyArray_NDIM(tmp) >= 1 ? 44276 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 44277 (long int) (PyArray_NDIM(tmp) >= 3 ? 44278 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 44279 (long int) (PyArray_NDIM(tmp) >= 2 ? 44280 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 44281 (long int) (PyArray_NDIM(tmp) >= 1 ? 44282 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 44283 ); 44284 { 44285 __failure = 904; 44286 if (!PyErr_Occurred()) { 44287 PyErr_SetString(PyExc_RuntimeError, 44288 "Unexpected error in an Op's C code. " 44289 "No Python exception was set."); 44290 } 44291 goto __label_904;} 44292 } 44293 // This is a TypeError to be consistent with DEBUG_MODE 44294 // Note: DEBUG_MODE also tells the name of the container 44295 if (PyArray_TYPE((PyArrayObject*) py_V903) != NPY_FLOAT64) { 44296 PyErr_Format(PyExc_TypeError, 44297 "expected type_num %d (NPY_FLOAT64) got %d", 44298 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V903)); 44299 { 44300 __failure = 904; 44301 if (!PyErr_Occurred()) { 44302 PyErr_SetString(PyExc_RuntimeError, 44303 "Unexpected error in an Op's C code. " 44304 "No Python exception was set."); 44305 } 44306 goto __label_904;} 44307 } 44308 44309 V903 = (PyArrayObject*)(py_V903); 44310 Py_XINCREF(V903); 44311 44312 { 44313 44314 py_V905 = PyList_GET_ITEM(storage_V905, 0); 44315 {Py_XINCREF(py_V905);} 44316 44317 V905 = NULL; 44318 if (py_V905 == Py_None) { 44319 // We can either fail here or set V905 to NULL and rely on Ops 44320 // using tensors to handle the NULL case, but if they fail to do so 44321 // they'll end up with nasty segfaults, so this is public service. 44322 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 44323 { 44324 __failure = 906; 44325 if (!PyErr_Occurred()) { 44326 PyErr_SetString(PyExc_RuntimeError, 44327 "Unexpected error in an Op's C code. " 44328 "No Python exception was set."); 44329 } 44330 goto __label_906;} 44331 } 44332 if (!PyArray_Check(py_V905)) { 44333 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 44334 { 44335 __failure = 906; 44336 if (!PyErr_Occurred()) { 44337 PyErr_SetString(PyExc_RuntimeError, 44338 "Unexpected error in an Op's C code. " 44339 "No Python exception was set."); 44340 } 44341 goto __label_906;} 44342 } 44343 // We expect NPY_FLOAT64 44344 if (!PyArray_ISALIGNED((PyArrayObject*) py_V905)) { 44345 PyArrayObject * tmp = (PyArrayObject*) py_V905; 44346 PyErr_Format(PyExc_NotImplementedError, 44347 "expected an aligned array of type %ld " 44348 "(NPY_FLOAT64), got non-aligned array of type %ld" 44349 " with %ld dimensions, with 3 last dims " 44350 "%ld, %ld, %ld" 44351 " and 3 last strides %ld %ld, %ld.", 44352 (long int) NPY_FLOAT64, 44353 (long int) PyArray_TYPE((PyArrayObject*) py_V905), 44354 (long int) PyArray_NDIM(tmp), 44355 (long int) (PyArray_NDIM(tmp) >= 3 ? 44356 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 44357 (long int) (PyArray_NDIM(tmp) >= 2 ? 44358 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 44359 (long int) (PyArray_NDIM(tmp) >= 1 ? 44360 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 44361 (long int) (PyArray_NDIM(tmp) >= 3 ? 44362 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 44363 (long int) (PyArray_NDIM(tmp) >= 2 ? 44364 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 44365 (long int) (PyArray_NDIM(tmp) >= 1 ? 44366 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 44367 ); 44368 { 44369 __failure = 906; 44370 if (!PyErr_Occurred()) { 44371 PyErr_SetString(PyExc_RuntimeError, 44372 "Unexpected error in an Op's C code. " 44373 "No Python exception was set."); 44374 } 44375 goto __label_906;} 44376 } 44377 // This is a TypeError to be consistent with DEBUG_MODE 44378 // Note: DEBUG_MODE also tells the name of the container 44379 if (PyArray_TYPE((PyArrayObject*) py_V905) != NPY_FLOAT64) { 44380 PyErr_Format(PyExc_TypeError, 44381 "expected type_num %d (NPY_FLOAT64) got %d", 44382 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V905)); 44383 { 44384 __failure = 906; 44385 if (!PyErr_Occurred()) { 44386 PyErr_SetString(PyExc_RuntimeError, 44387 "Unexpected error in an Op's C code. " 44388 "No Python exception was set."); 44389 } 44390 goto __label_906;} 44391 } 44392 44393 V905 = (PyArrayObject*)(py_V905); 44394 Py_XINCREF(V905); 44395 44396 { 44397 44398 py_V907 = PyList_GET_ITEM(storage_V907, 0); 44399 {Py_XINCREF(py_V907);} 44400 44401 V907 = NULL; 44402 if (py_V907 == Py_None) { 44403 // We can either fail here or set V907 to NULL and rely on Ops 44404 // using tensors to handle the NULL case, but if they fail to do so 44405 // they'll end up with nasty segfaults, so this is public service. 44406 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 44407 { 44408 __failure = 908; 44409 if (!PyErr_Occurred()) { 44410 PyErr_SetString(PyExc_RuntimeError, 44411 "Unexpected error in an Op's C code. " 44412 "No Python exception was set."); 44413 } 44414 goto __label_908;} 44415 } 44416 if (!PyArray_Check(py_V907)) { 44417 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 44418 { 44419 __failure = 908; 44420 if (!PyErr_Occurred()) { 44421 PyErr_SetString(PyExc_RuntimeError, 44422 "Unexpected error in an Op's C code. " 44423 "No Python exception was set."); 44424 } 44425 goto __label_908;} 44426 } 44427 // We expect NPY_FLOAT64 44428 if (!PyArray_ISALIGNED((PyArrayObject*) py_V907)) { 44429 PyArrayObject * tmp = (PyArrayObject*) py_V907; 44430 PyErr_Format(PyExc_NotImplementedError, 44431 "expected an aligned array of type %ld " 44432 "(NPY_FLOAT64), got non-aligned array of type %ld" 44433 " with %ld dimensions, with 3 last dims " 44434 "%ld, %ld, %ld" 44435 " and 3 last strides %ld %ld, %ld.", 44436 (long int) NPY_FLOAT64, 44437 (long int) PyArray_TYPE((PyArrayObject*) py_V907), 44438 (long int) PyArray_NDIM(tmp), 44439 (long int) (PyArray_NDIM(tmp) >= 3 ? 44440 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 44441 (long int) (PyArray_NDIM(tmp) >= 2 ? 44442 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 44443 (long int) (PyArray_NDIM(tmp) >= 1 ? 44444 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 44445 (long int) (PyArray_NDIM(tmp) >= 3 ? 44446 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 44447 (long int) (PyArray_NDIM(tmp) >= 2 ? 44448 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 44449 (long int) (PyArray_NDIM(tmp) >= 1 ? 44450 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 44451 ); 44452 { 44453 __failure = 908; 44454 if (!PyErr_Occurred()) { 44455 PyErr_SetString(PyExc_RuntimeError, 44456 "Unexpected error in an Op's C code. " 44457 "No Python exception was set."); 44458 } 44459 goto __label_908;} 44460 } 44461 // This is a TypeError to be consistent with DEBUG_MODE 44462 // Note: DEBUG_MODE also tells the name of the container 44463 if (PyArray_TYPE((PyArrayObject*) py_V907) != NPY_FLOAT64) { 44464 PyErr_Format(PyExc_TypeError, 44465 "expected type_num %d (NPY_FLOAT64) got %d", 44466 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V907)); 44467 { 44468 __failure = 908; 44469 if (!PyErr_Occurred()) { 44470 PyErr_SetString(PyExc_RuntimeError, 44471 "Unexpected error in an Op's C code. " 44472 "No Python exception was set."); 44473 } 44474 goto __label_908;} 44475 } 44476 44477 V907 = (PyArrayObject*)(py_V907); 44478 Py_XINCREF(V907); 44479 44480 { 44481 44482 py_V909 = PyList_GET_ITEM(storage_V909, 0); 44483 {Py_XINCREF(py_V909);} 44484 44485 V909 = NULL; 44486 if (py_V909 == Py_None) { 44487 // We can either fail here or set V909 to NULL and rely on Ops 44488 // using tensors to handle the NULL case, but if they fail to do so 44489 // they'll end up with nasty segfaults, so this is public service. 44490 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 44491 { 44492 __failure = 910; 44493 if (!PyErr_Occurred()) { 44494 PyErr_SetString(PyExc_RuntimeError, 44495 "Unexpected error in an Op's C code. " 44496 "No Python exception was set."); 44497 } 44498 goto __label_910;} 44499 } 44500 if (!PyArray_Check(py_V909)) { 44501 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 44502 { 44503 __failure = 910; 44504 if (!PyErr_Occurred()) { 44505 PyErr_SetString(PyExc_RuntimeError, 44506 "Unexpected error in an Op's C code. " 44507 "No Python exception was set."); 44508 } 44509 goto __label_910;} 44510 } 44511 // We expect NPY_FLOAT64 44512 if (!PyArray_ISALIGNED((PyArrayObject*) py_V909)) { 44513 PyArrayObject * tmp = (PyArrayObject*) py_V909; 44514 PyErr_Format(PyExc_NotImplementedError, 44515 "expected an aligned array of type %ld " 44516 "(NPY_FLOAT64), got non-aligned array of type %ld" 44517 " with %ld dimensions, with 3 last dims " 44518 "%ld, %ld, %ld" 44519 " and 3 last strides %ld %ld, %ld.", 44520 (long int) NPY_FLOAT64, 44521 (long int) PyArray_TYPE((PyArrayObject*) py_V909), 44522 (long int) PyArray_NDIM(tmp), 44523 (long int) (PyArray_NDIM(tmp) >= 3 ? 44524 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1), 44525 (long int) (PyArray_NDIM(tmp) >= 2 ? 44526 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1), 44527 (long int) (PyArray_NDIM(tmp) >= 1 ? 44528 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1), 44529 (long int) (PyArray_NDIM(tmp) >= 3 ? 44530 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1), 44531 (long int) (PyArray_NDIM(tmp) >= 2 ? 44532 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1), 44533 (long int) (PyArray_NDIM(tmp) >= 1 ? 44534 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1) 44535 ); 44536 { 44537 __failure = 910; 44538 if (!PyErr_Occurred()) { 44539 PyErr_SetString(PyExc_RuntimeError, 44540 "Unexpected error in an Op's C code. " 44541 "No Python exception was set."); 44542 } 44543 goto __label_910;} 44544 } 44545 // This is a TypeError to be consistent with DEBUG_MODE 44546 // Note: DEBUG_MODE also tells the name of the container 44547 if (PyArray_TYPE((PyArrayObject*) py_V909) != NPY_FLOAT64) { 44548 PyErr_Format(PyExc_TypeError, 44549 "expected type_num %d (NPY_FLOAT64) got %d", 44550 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V909)); 44551 { 44552 __failure = 910; 44553 if (!PyErr_Occurred()) { 44554 PyErr_SetString(PyExc_RuntimeError, 44555 "Unexpected error in an Op's C code. " 44556 "No Python exception was set."); 44557 } 44558 goto __label_910;} 44559 } 44560 44561 V909 = (PyArrayObject*)(py_V909); 44562 Py_XINCREF(V909); 44563 44564 { 44565 // Op class Elemwise 44566 44567 npy_float64* V3_iter; 44568 44569 npy_float64* V5_iter; 44570 44571 npy_float64* V7_iter; 44572 44573 npy_float64* V9_iter; 44574 44575 npy_float64* V11_iter; 44576 44577 npy_float64* V13_iter; 44578 44579 npy_float64* V15_iter; 44580 44581 npy_float64* V17_iter; 44582 44583 npy_float64* V19_iter; 44584 44585 npy_float64* V21_iter; 44586 44587 npy_float64* V23_iter; 44588 44589 npy_float64* V25_iter; 44590 44591 npy_float64* V27_iter; 44592 44593 npy_float64* V29_iter; 44594 44595 npy_float64* V31_iter; 44596 44597 npy_float64* V33_iter; 44598 44599 npy_float64* V35_iter; 44600 44601 npy_float64* V37_iter; 44602 44603 npy_float64* V39_iter; 44604 44605 npy_float64* V41_iter; 44606 44607 npy_float64* V43_iter; 44608 44609 npy_float64* V45_iter; 44610 44611 npy_float64* V47_iter; 44612 44613 npy_float64* V49_iter; 44614 44615 npy_float64* V51_iter; 44616 44617 npy_float64* V53_iter; 44618 44619 npy_float64* V55_iter; 44620 44621 npy_float64* V57_iter; 44622 44623 npy_float64* V59_iter; 44624 44625 npy_float64* V61_iter; 44626 44627 npy_float64* V63_iter; 44628 44629 npy_float64* V65_iter; 44630 44631 npy_float64* V67_iter; 44632 44633 npy_float64* V69_iter; 44634 44635 npy_float64* V71_iter; 44636 44637 npy_float64* V73_iter; 44638 44639 npy_float64* V75_iter; 44640 44641 npy_float64* V77_iter; 44642 44643 npy_float64* V79_iter; 44644 44645 npy_float64* V81_iter; 44646 44647 npy_float64* V83_iter; 44648 44649 npy_float64* V85_iter; 44650 44651 npy_float64* V87_iter; 44652 44653 npy_float64* V89_iter; 44654 44655 npy_float64* V91_iter; 44656 44657 npy_float64* V93_iter; 44658 44659 npy_float64* V95_iter; 44660 44661 npy_float64* V97_iter; 44662 44663 npy_float64* V99_iter; 44664 44665 npy_float64* V101_iter; 44666 44667 npy_float64* V103_iter; 44668 44669 npy_float64* V105_iter; 44670 44671 npy_float64* V107_iter; 44672 44673 npy_float64* V109_iter; 44674 44675 npy_float64* V111_iter; 44676 44677 npy_float64* V113_iter; 44678 44679 npy_float64* V115_iter; 44680 44681 npy_float64* V117_iter; 44682 44683 npy_float64* V119_iter; 44684 44685 npy_float64* V121_iter; 44686 44687 npy_float64* V123_iter; 44688 44689 npy_float64* V125_iter; 44690 44691 npy_float64* V127_iter; 44692 44693 npy_float64* V129_iter; 44694 44695 npy_float64* V131_iter; 44696 44697 npy_float64* V133_iter; 44698 44699 npy_float64* V135_iter; 44700 44701 npy_float64* V137_iter; 44702 44703 npy_float64* V139_iter; 44704 44705 npy_float64* V141_iter; 44706 44707 npy_float64* V143_iter; 44708 44709 npy_float64* V145_iter; 44710 44711 npy_float64* V147_iter; 44712 44713 npy_float64* V149_iter; 44714 44715 npy_float64* V151_iter; 44716 44717 npy_float64* V153_iter; 44718 44719 npy_float64* V155_iter; 44720 44721 npy_float64* V157_iter; 44722 44723 npy_float64* V159_iter; 44724 44725 npy_float64* V161_iter; 44726 44727 npy_float64* V163_iter; 44728 44729 npy_float64* V165_iter; 44730 44731 npy_float64* V167_iter; 44732 44733 npy_float64* V169_iter; 44734 44735 npy_float64* V171_iter; 44736 44737 npy_float64* V173_iter; 44738 44739 npy_float64* V175_iter; 44740 44741 npy_float64* V177_iter; 44742 44743 npy_float64* V179_iter; 44744 44745 npy_float64* V181_iter; 44746 44747 npy_float64* V183_iter; 44748 44749 npy_float64* V185_iter; 44750 44751 npy_float64* V187_iter; 44752 44753 npy_float64* V189_iter; 44754 44755 npy_float64* V191_iter; 44756 44757 npy_float64* V193_iter; 44758 44759 npy_float64* V195_iter; 44760 44761 npy_float64* V197_iter; 44762 44763 npy_float64* V199_iter; 44764 44765 npy_float64* V201_iter; 44766 44767 npy_float64* V203_iter; 44768 44769 npy_float64* V205_iter; 44770 44771 npy_float64* V207_iter; 44772 44773 npy_float64* V209_iter; 44774 44775 npy_float64* V211_iter; 44776 44777 npy_float64* V213_iter; 44778 44779 npy_float64* V215_iter; 44780 44781 npy_float64* V217_iter; 44782 44783 npy_float64* V219_iter; 44784 44785 npy_float64* V221_iter; 44786 44787 npy_float64* V223_iter; 44788 44789 npy_float64* V225_iter; 44790 44791 npy_float64* V227_iter; 44792 44793 npy_float64* V229_iter; 44794 44795 npy_float64* V231_iter; 44796 44797 npy_float64* V233_iter; 44798 44799 npy_float64* V235_iter; 44800 44801 npy_float64* V237_iter; 44802 44803 npy_float64* V239_iter; 44804 44805 npy_float64* V241_iter; 44806 44807 npy_float64* V243_iter; 44808 44809 npy_float64* V245_iter; 44810 44811 npy_float64* V247_iter; 44812 44813 npy_float64* V249_iter; 44814 44815 npy_float64* V251_iter; 44816 44817 npy_float64* V253_iter; 44818 44819 npy_float64* V255_iter; 44820 44821 npy_float64* V257_iter; 44822 44823 npy_float64* V259_iter; 44824 44825 npy_float64* V261_iter; 44826 44827 npy_float64* V263_iter; 44828 44829 npy_float64* V265_iter; 44830 44831 npy_float64* V267_iter; 44832 44833 npy_float64* V269_iter; 44834 44835 npy_float64* V271_iter; 44836 44837 npy_float64* V273_iter; 44838 44839 npy_float64* V275_iter; 44840 44841 npy_float64* V277_iter; 44842 44843 npy_float64* V279_iter; 44844 44845 npy_float64* V281_iter; 44846 44847 npy_float64* V283_iter; 44848 44849 npy_float64* V285_iter; 44850 44851 npy_float64* V287_iter; 44852 44853 npy_float64* V289_iter; 44854 44855 npy_float64* V291_iter; 44856 44857 npy_float64* V293_iter; 44858 44859 npy_float64* V295_iter; 44860 44861 npy_float64* V297_iter; 44862 44863 npy_float64* V299_iter; 44864 44865 npy_float64* V301_iter; 44866 44867 npy_float64* V303_iter; 44868 44869 npy_float64* V305_iter; 44870 44871 npy_float64* V307_iter; 44872 44873 npy_float64* V309_iter; 44874 44875 npy_float64* V311_iter; 44876 44877 npy_float64* V313_iter; 44878 44879 npy_float64* V315_iter; 44880 44881 npy_float64* V317_iter; 44882 44883 npy_float64* V319_iter; 44884 44885 npy_float64* V321_iter; 44886 44887 npy_float64* V323_iter; 44888 44889 npy_float64* V325_iter; 44890 44891 npy_float64* V327_iter; 44892 44893 npy_float64* V329_iter; 44894 44895 npy_float64* V331_iter; 44896 44897 npy_float64* V333_iter; 44898 44899 npy_float64* V335_iter; 44900 44901 npy_float64* V337_iter; 44902 44903 npy_float64* V339_iter; 44904 44905 npy_float64* V341_iter; 44906 44907 npy_float64* V343_iter; 44908 44909 npy_float64* V345_iter; 44910 44911 npy_float64* V347_iter; 44912 44913 npy_float64* V349_iter; 44914 44915 npy_float64* V351_iter; 44916 44917 npy_float64* V353_iter; 44918 44919 npy_float64* V355_iter; 44920 44921 npy_float64* V357_iter; 44922 44923 npy_float64* V359_iter; 44924 44925 npy_float64* V361_iter; 44926 44927 npy_float64* V363_iter; 44928 44929 npy_float64* V365_iter; 44930 44931 npy_float64* V367_iter; 44932 44933 npy_float64* V369_iter; 44934 44935 npy_float64* V371_iter; 44936 44937 npy_float64* V373_iter; 44938 44939 npy_float64* V375_iter; 44940 44941 npy_float64* V377_iter; 44942 44943 npy_float64* V379_iter; 44944 44945 npy_float64* V381_iter; 44946 44947 npy_float64* V383_iter; 44948 44949 npy_float64* V385_iter; 44950 44951 npy_float64* V387_iter; 44952 44953 npy_float64* V389_iter; 44954 44955 npy_float64* V391_iter; 44956 44957 npy_float64* V393_iter; 44958 44959 npy_float64* V395_iter; 44960 44961 npy_float64* V397_iter; 44962 44963 npy_float64* V399_iter; 44964 44965 npy_float64* V401_iter; 44966 44967 npy_float64* V403_iter; 44968 44969 npy_float64* V405_iter; 44970 44971 npy_float64* V407_iter; 44972 44973 npy_float64* V409_iter; 44974 44975 npy_float64* V411_iter; 44976 44977 npy_float64* V413_iter; 44978 44979 npy_float64* V415_iter; 44980 44981 npy_float64* V417_iter; 44982 44983 npy_float64* V419_iter; 44984 44985 npy_float64* V421_iter; 44986 44987 npy_float64* V423_iter; 44988 44989 npy_float64* V425_iter; 44990 44991 npy_float64* V427_iter; 44992 44993 npy_float64* V429_iter; 44994 44995 npy_float64* V431_iter; 44996 44997 npy_float64* V433_iter; 44998 44999 npy_float64* V435_iter; 45000 45001 npy_float64* V437_iter; 45002 45003 npy_float64* V439_iter; 45004 45005 npy_float64* V441_iter; 45006 45007 npy_float64* V443_iter; 45008 45009 npy_float64* V445_iter; 45010 45011 npy_float64* V447_iter; 45012 45013 npy_float64* V449_iter; 45014 45015 npy_float64* V451_iter; 45016 45017 npy_float64* V453_iter; 45018 45019 npy_float64* V455_iter; 45020 45021 npy_float64* V457_iter; 45022 45023 npy_float64* V459_iter; 45024 45025 npy_float64* V461_iter; 45026 45027 npy_float64* V463_iter; 45028 45029 npy_float64* V465_iter; 45030 45031 npy_float64* V467_iter; 45032 45033 npy_float64* V469_iter; 45034 45035 npy_float64* V471_iter; 45036 45037 npy_float64* V473_iter; 45038 45039 npy_float64* V475_iter; 45040 45041 npy_float64* V477_iter; 45042 45043 npy_float64* V479_iter; 45044 45045 npy_float64* V481_iter; 45046 45047 npy_float64* V483_iter; 45048 45049 npy_float64* V485_iter; 45050 45051 npy_float64* V487_iter; 45052 45053 npy_float64* V489_iter; 45054 45055 npy_float64* V491_iter; 45056 45057 npy_float64* V493_iter; 45058 45059 npy_float64* V495_iter; 45060 45061 npy_float64* V497_iter; 45062 45063 npy_float64* V499_iter; 45064 45065 npy_float64* V501_iter; 45066 45067 npy_float64* V503_iter; 45068 45069 npy_float64* V505_iter; 45070 45071 npy_float64* V507_iter; 45072 45073 npy_float64* V509_iter; 45074 45075 npy_float64* V511_iter; 45076 45077 npy_float64* V513_iter; 45078 45079 npy_float64* V515_iter; 45080 45081 npy_float64* V517_iter; 45082 45083 npy_float64* V519_iter; 45084 45085 npy_float64* V521_iter; 45086 45087 npy_float64* V523_iter; 45088 45089 npy_float64* V525_iter; 45090 45091 npy_float64* V527_iter; 45092 45093 npy_float64* V529_iter; 45094 45095 npy_float64* V531_iter; 45096 45097 npy_float64* V533_iter; 45098 45099 npy_float64* V535_iter; 45100 45101 npy_float64* V537_iter; 45102 45103 npy_float64* V539_iter; 45104 45105 npy_float64* V541_iter; 45106 45107 npy_float64* V543_iter; 45108 45109 npy_float64* V545_iter; 45110 45111 npy_float64* V547_iter; 45112 45113 npy_float64* V549_iter; 45114 45115 npy_float64* V551_iter; 45116 45117 npy_float64* V553_iter; 45118 45119 npy_float64* V555_iter; 45120 45121 npy_float64* V557_iter; 45122 45123 npy_float64* V559_iter; 45124 45125 npy_float64* V561_iter; 45126 45127 npy_float64* V563_iter; 45128 45129 npy_float64* V565_iter; 45130 45131 npy_float64* V567_iter; 45132 45133 npy_float64* V569_iter; 45134 45135 npy_float64* V571_iter; 45136 45137 npy_float64* V573_iter; 45138 45139 npy_float64* V575_iter; 45140 45141 npy_float64* V577_iter; 45142 45143 npy_float64* V579_iter; 45144 45145 npy_float64* V581_iter; 45146 45147 npy_float64* V583_iter; 45148 45149 npy_float64* V585_iter; 45150 45151 npy_float64* V587_iter; 45152 45153 npy_float64* V589_iter; 45154 45155 npy_float64* V591_iter; 45156 45157 npy_float64* V593_iter; 45158 45159 npy_float64* V595_iter; 45160 45161 npy_float64* V597_iter; 45162 45163 npy_float64* V599_iter; 45164 45165 npy_float64* V601_iter; 45166 45167 npy_float64* V603_iter; 45168 45169 npy_float64* V605_iter; 45170 45171 npy_float64* V607_iter; 45172 45173 npy_float64* V609_iter; 45174 45175 npy_float64* V611_iter; 45176 45177 npy_float64* V613_iter; 45178 45179 npy_float64* V615_iter; 45180 45181 npy_float64* V617_iter; 45182 45183 npy_float64* V619_iter; 45184 45185 npy_float64* V621_iter; 45186 45187 npy_float64* V623_iter; 45188 45189 npy_float64* V625_iter; 45190 45191 npy_float64* V627_iter; 45192 45193 npy_float64* V629_iter; 45194 45195 npy_float64* V631_iter; 45196 45197 npy_float64* V633_iter; 45198 45199 npy_float64* V635_iter; 45200 45201 npy_float64* V637_iter; 45202 45203 npy_float64* V639_iter; 45204 45205 npy_float64* V641_iter; 45206 45207 npy_float64* V643_iter; 45208 45209 npy_float64* V645_iter; 45210 45211 npy_float64* V647_iter; 45212 45213 npy_float64* V649_iter; 45214 45215 npy_float64* V651_iter; 45216 45217 npy_float64* V653_iter; 45218 45219 npy_float64* V655_iter; 45220 45221 npy_float64* V657_iter; 45222 45223 npy_float64* V659_iter; 45224 45225 npy_float64* V661_iter; 45226 45227 npy_float64* V663_iter; 45228 45229 npy_float64* V665_iter; 45230 45231 npy_float64* V667_iter; 45232 45233 npy_float64* V669_iter; 45234 45235 npy_float64* V671_iter; 45236 45237 npy_float64* V673_iter; 45238 45239 npy_float64* V675_iter; 45240 45241 npy_float64* V677_iter; 45242 45243 npy_float64* V679_iter; 45244 45245 npy_float64* V681_iter; 45246 45247 npy_float64* V683_iter; 45248 45249 npy_float64* V685_iter; 45250 45251 npy_float64* V687_iter; 45252 45253 npy_float64* V689_iter; 45254 45255 npy_float64* V691_iter; 45256 45257 npy_float64* V693_iter; 45258 45259 npy_float64* V695_iter; 45260 45261 npy_float64* V697_iter; 45262 45263 npy_float64* V699_iter; 45264 45265 npy_float64* V701_iter; 45266 45267 npy_float64* V703_iter; 45268 45269 npy_float64* V705_iter; 45270 45271 npy_float64* V707_iter; 45272 45273 npy_float64* V709_iter; 45274 45275 npy_float64* V711_iter; 45276 45277 npy_float64* V713_iter; 45278 45279 npy_float64* V715_iter; 45280 45281 npy_float64* V717_iter; 45282 45283 npy_float64* V719_iter; 45284 45285 npy_float64* V721_iter; 45286 45287 npy_float64* V723_iter; 45288 45289 npy_float64* V725_iter; 45290 45291 npy_float64* V727_iter; 45292 45293 npy_float64* V729_iter; 45294 45295 npy_float64* V731_iter; 45296 45297 npy_float64* V733_iter; 45298 45299 npy_float64* V735_iter; 45300 45301 npy_float64* V737_iter; 45302 45303 npy_float64* V739_iter; 45304 45305 npy_float64* V741_iter; 45306 45307 npy_float64* V743_iter; 45308 45309 npy_float64* V745_iter; 45310 45311 npy_float64* V747_iter; 45312 45313 npy_float64* V749_iter; 45314 45315 npy_float64* V751_iter; 45316 45317 npy_float64* V753_iter; 45318 45319 npy_float64* V755_iter; 45320 45321 npy_float64* V757_iter; 45322 45323 npy_float64* V759_iter; 45324 45325 npy_float64* V761_iter; 45326 45327 npy_float64* V763_iter; 45328 45329 npy_float64* V765_iter; 45330 45331 npy_float64* V767_iter; 45332 45333 npy_float64* V769_iter; 45334 45335 npy_float64* V771_iter; 45336 45337 npy_float64* V773_iter; 45338 45339 npy_float64* V775_iter; 45340 45341 npy_float64* V777_iter; 45342 45343 npy_float64* V779_iter; 45344 45345 npy_float64* V781_iter; 45346 45347 npy_float64* V783_iter; 45348 45349 npy_float64* V785_iter; 45350 45351 npy_float64* V787_iter; 45352 45353 npy_float64* V789_iter; 45354 45355 npy_float64* V791_iter; 45356 45357 npy_float64* V793_iter; 45358 45359 npy_float64* V795_iter; 45360 45361 npy_float64* V797_iter; 45362 45363 npy_float64* V799_iter; 45364 45365 npy_float64* V801_iter; 45366 45367 npy_float64* V803_iter; 45368 45369 npy_float64* V805_iter; 45370 45371 npy_float64* V807_iter; 45372 45373 npy_float64* V809_iter; 45374 45375 npy_float64* V811_iter; 45376 45377 npy_float64* V813_iter; 45378 45379 npy_float64* V815_iter; 45380 45381 npy_float64* V817_iter; 45382 45383 npy_float64* V819_iter; 45384 45385 npy_float64* V821_iter; 45386 45387 npy_float64* V823_iter; 45388 45389 npy_float64* V825_iter; 45390 45391 npy_float64* V827_iter; 45392 45393 npy_float64* V829_iter; 45394 45395 npy_float64* V831_iter; 45396 45397 npy_float64* V833_iter; 45398 45399 npy_float64* V835_iter; 45400 45401 npy_float64* V837_iter; 45402 45403 npy_float64* V839_iter; 45404 45405 npy_float64* V841_iter; 45406 45407 npy_float64* V843_iter; 45408 45409 npy_float64* V845_iter; 45410 45411 npy_float64* V847_iter; 45412 45413 npy_float64* V849_iter; 45414 45415 npy_float64* V851_iter; 45416 45417 npy_float64* V853_iter; 45418 45419 npy_float64* V855_iter; 45420 45421 npy_float64* V857_iter; 45422 45423 npy_float64* V859_iter; 45424 45425 npy_float64* V861_iter; 45426 45427 npy_float64* V863_iter; 45428 45429 npy_float64* V865_iter; 45430 45431 npy_float64* V867_iter; 45432 45433 npy_float64* V869_iter; 45434 45435 npy_float64* V871_iter; 45436 45437 npy_float64* V873_iter; 45438 45439 npy_float64* V875_iter; 45440 45441 npy_float64* V877_iter; 45442 45443 npy_float64* V879_iter; 45444 45445 npy_float64* V881_iter; 45446 45447 npy_float64* V883_iter; 45448 45449 npy_float64* V885_iter; 45450 45451 npy_float64* V887_iter; 45452 45453 npy_float64* V889_iter; 45454 45455 npy_float64* V891_iter; 45456 45457 npy_float64* V893_iter; 45458 45459 npy_float64* V895_iter; 45460 45461 npy_float64* V897_iter; 45462 45463 npy_float64* V899_iter; 45464 45465 npy_float64* V901_iter; 45466 45467 npy_float64* V903_iter; 45468 45469 npy_float64* V905_iter; 45470 45471 npy_float64* V907_iter; 45472 45473 npy_float64* V909_iter; 45474 45475 45476 45477 npy_float64* V1_iter; 45478 45479 { 45480 npy_intp dims[0]; 45481 //npy_intp* dims = (npy_intp*)malloc(0 * sizeof(npy_intp)); 45482 45483 if (!V1) { 45484 V1 = (PyArrayObject*)PyArray_EMPTY(0, dims, 45485 NPY_FLOAT64, 45486 0); 45487 } 45488 else { 45489 PyArray_Dims new_dims; 45490 new_dims.len = 0; 45491 new_dims.ptr = dims; 45492 PyObject* success = PyArray_Resize(V1, &new_dims, 0, NPY_CORDER); 45493 if (!success) { 45494 // If we can't resize the ndarray we have we can allocate a new one. 45495 PyErr_Clear(); 45496 Py_XDECREF(V1); 45497 V1 = (PyArrayObject*)PyArray_EMPTY(0, dims, NPY_FLOAT64, 0); 45498 } 45499 } 45500 if (!V1) { 45501 { 45502 __failure = 911; 45503 if (!PyErr_Occurred()) { 45504 PyErr_SetString(PyExc_RuntimeError, 45505 "Unexpected error in an Op's C code. " 45506 "No Python exception was set."); 45507 } 45508 goto __label_911;} 45509 } 45510 } 45511 45512 45513 { 45514 45515 V3_iter = (npy_float64*)(PyArray_DATA(V3)); 45516 V5_iter = (npy_float64*)(PyArray_DATA(V5)); 45517 V7_iter = (npy_float64*)(PyArray_DATA(V7)); 45518 V9_iter = (npy_float64*)(PyArray_DATA(V9)); 45519 V11_iter = (npy_float64*)(PyArray_DATA(V11)); 45520 V13_iter = (npy_float64*)(PyArray_DATA(V13)); 45521 V15_iter = (npy_float64*)(PyArray_DATA(V15)); 45522 V17_iter = (npy_float64*)(PyArray_DATA(V17)); 45523 V19_iter = (npy_float64*)(PyArray_DATA(V19)); 45524 V21_iter = (npy_float64*)(PyArray_DATA(V21)); 45525 V23_iter = (npy_float64*)(PyArray_DATA(V23)); 45526 V25_iter = (npy_float64*)(PyArray_DATA(V25)); 45527 V27_iter = (npy_float64*)(PyArray_DATA(V27)); 45528 V29_iter = (npy_float64*)(PyArray_DATA(V29)); 45529 V31_iter = (npy_float64*)(PyArray_DATA(V31)); 45530 V33_iter = (npy_float64*)(PyArray_DATA(V33)); 45531 V35_iter = (npy_float64*)(PyArray_DATA(V35)); 45532 V37_iter = (npy_float64*)(PyArray_DATA(V37)); 45533 V39_iter = (npy_float64*)(PyArray_DATA(V39)); 45534 V41_iter = (npy_float64*)(PyArray_DATA(V41)); 45535 V43_iter = (npy_float64*)(PyArray_DATA(V43)); 45536 V45_iter = (npy_float64*)(PyArray_DATA(V45)); 45537 V47_iter = (npy_float64*)(PyArray_DATA(V47)); 45538 V49_iter = (npy_float64*)(PyArray_DATA(V49)); 45539 V51_iter = (npy_float64*)(PyArray_DATA(V51)); 45540 V53_iter = (npy_float64*)(PyArray_DATA(V53)); 45541 V55_iter = (npy_float64*)(PyArray_DATA(V55)); 45542 V57_iter = (npy_float64*)(PyArray_DATA(V57)); 45543 V59_iter = (npy_float64*)(PyArray_DATA(V59)); 45544 V61_iter = (npy_float64*)(PyArray_DATA(V61)); 45545 V63_iter = (npy_float64*)(PyArray_DATA(V63)); 45546 V65_iter = (npy_float64*)(PyArray_DATA(V65)); 45547 V67_iter = (npy_float64*)(PyArray_DATA(V67)); 45548 V69_iter = (npy_float64*)(PyArray_DATA(V69)); 45549 V71_iter = (npy_float64*)(PyArray_DATA(V71)); 45550 V73_iter = (npy_float64*)(PyArray_DATA(V73)); 45551 V75_iter = (npy_float64*)(PyArray_DATA(V75)); 45552 V77_iter = (npy_float64*)(PyArray_DATA(V77)); 45553 V79_iter = (npy_float64*)(PyArray_DATA(V79)); 45554 V81_iter = (npy_float64*)(PyArray_DATA(V81)); 45555 V83_iter = (npy_float64*)(PyArray_DATA(V83)); 45556 V85_iter = (npy_float64*)(PyArray_DATA(V85)); 45557 V87_iter = (npy_float64*)(PyArray_DATA(V87)); 45558 V89_iter = (npy_float64*)(PyArray_DATA(V89)); 45559 V91_iter = (npy_float64*)(PyArray_DATA(V91)); 45560 V93_iter = (npy_float64*)(PyArray_DATA(V93)); 45561 V95_iter = (npy_float64*)(PyArray_DATA(V95)); 45562 V97_iter = (npy_float64*)(PyArray_DATA(V97)); 45563 V99_iter = (npy_float64*)(PyArray_DATA(V99)); 45564 V101_iter = (npy_float64*)(PyArray_DATA(V101)); 45565 V103_iter = (npy_float64*)(PyArray_DATA(V103)); 45566 V105_iter = (npy_float64*)(PyArray_DATA(V105)); 45567 V107_iter = (npy_float64*)(PyArray_DATA(V107)); 45568 V109_iter = (npy_float64*)(PyArray_DATA(V109)); 45569 V111_iter = (npy_float64*)(PyArray_DATA(V111)); 45570 V113_iter = (npy_float64*)(PyArray_DATA(V113)); 45571 V115_iter = (npy_float64*)(PyArray_DATA(V115)); 45572 V117_iter = (npy_float64*)(PyArray_DATA(V117)); 45573 V119_iter = (npy_float64*)(PyArray_DATA(V119)); 45574 V121_iter = (npy_float64*)(PyArray_DATA(V121)); 45575 V123_iter = (npy_float64*)(PyArray_DATA(V123)); 45576 V125_iter = (npy_float64*)(PyArray_DATA(V125)); 45577 V127_iter = (npy_float64*)(PyArray_DATA(V127)); 45578 V129_iter = (npy_float64*)(PyArray_DATA(V129)); 45579 V131_iter = (npy_float64*)(PyArray_DATA(V131)); 45580 V133_iter = (npy_float64*)(PyArray_DATA(V133)); 45581 V135_iter = (npy_float64*)(PyArray_DATA(V135)); 45582 V137_iter = (npy_float64*)(PyArray_DATA(V137)); 45583 V139_iter = (npy_float64*)(PyArray_DATA(V139)); 45584 V141_iter = (npy_float64*)(PyArray_DATA(V141)); 45585 V143_iter = (npy_float64*)(PyArray_DATA(V143)); 45586 V145_iter = (npy_float64*)(PyArray_DATA(V145)); 45587 V147_iter = (npy_float64*)(PyArray_DATA(V147)); 45588 V149_iter = (npy_float64*)(PyArray_DATA(V149)); 45589 V151_iter = (npy_float64*)(PyArray_DATA(V151)); 45590 V153_iter = (npy_float64*)(PyArray_DATA(V153)); 45591 V155_iter = (npy_float64*)(PyArray_DATA(V155)); 45592 V157_iter = (npy_float64*)(PyArray_DATA(V157)); 45593 V159_iter = (npy_float64*)(PyArray_DATA(V159)); 45594 V161_iter = (npy_float64*)(PyArray_DATA(V161)); 45595 V163_iter = (npy_float64*)(PyArray_DATA(V163)); 45596 V165_iter = (npy_float64*)(PyArray_DATA(V165)); 45597 V167_iter = (npy_float64*)(PyArray_DATA(V167)); 45598 V169_iter = (npy_float64*)(PyArray_DATA(V169)); 45599 V171_iter = (npy_float64*)(PyArray_DATA(V171)); 45600 V173_iter = (npy_float64*)(PyArray_DATA(V173)); 45601 V175_iter = (npy_float64*)(PyArray_DATA(V175)); 45602 V177_iter = (npy_float64*)(PyArray_DATA(V177)); 45603 V179_iter = (npy_float64*)(PyArray_DATA(V179)); 45604 V181_iter = (npy_float64*)(PyArray_DATA(V181)); 45605 V183_iter = (npy_float64*)(PyArray_DATA(V183)); 45606 V185_iter = (npy_float64*)(PyArray_DATA(V185)); 45607 V187_iter = (npy_float64*)(PyArray_DATA(V187)); 45608 V189_iter = (npy_float64*)(PyArray_DATA(V189)); 45609 V191_iter = (npy_float64*)(PyArray_DATA(V191)); 45610 V193_iter = (npy_float64*)(PyArray_DATA(V193)); 45611 V195_iter = (npy_float64*)(PyArray_DATA(V195)); 45612 V197_iter = (npy_float64*)(PyArray_DATA(V197)); 45613 V199_iter = (npy_float64*)(PyArray_DATA(V199)); 45614 V201_iter = (npy_float64*)(PyArray_DATA(V201)); 45615 V203_iter = (npy_float64*)(PyArray_DATA(V203)); 45616 V205_iter = (npy_float64*)(PyArray_DATA(V205)); 45617 V207_iter = (npy_float64*)(PyArray_DATA(V207)); 45618 V209_iter = (npy_float64*)(PyArray_DATA(V209)); 45619 V211_iter = (npy_float64*)(PyArray_DATA(V211)); 45620 V213_iter = (npy_float64*)(PyArray_DATA(V213)); 45621 V215_iter = (npy_float64*)(PyArray_DATA(V215)); 45622 V217_iter = (npy_float64*)(PyArray_DATA(V217)); 45623 V219_iter = (npy_float64*)(PyArray_DATA(V219)); 45624 V221_iter = (npy_float64*)(PyArray_DATA(V221)); 45625 V223_iter = (npy_float64*)(PyArray_DATA(V223)); 45626 V225_iter = (npy_float64*)(PyArray_DATA(V225)); 45627 V227_iter = (npy_float64*)(PyArray_DATA(V227)); 45628 V229_iter = (npy_float64*)(PyArray_DATA(V229)); 45629 V231_iter = (npy_float64*)(PyArray_DATA(V231)); 45630 V233_iter = (npy_float64*)(PyArray_DATA(V233)); 45631 V235_iter = (npy_float64*)(PyArray_DATA(V235)); 45632 V237_iter = (npy_float64*)(PyArray_DATA(V237)); 45633 V239_iter = (npy_float64*)(PyArray_DATA(V239)); 45634 V241_iter = (npy_float64*)(PyArray_DATA(V241)); 45635 V243_iter = (npy_float64*)(PyArray_DATA(V243)); 45636 V245_iter = (npy_float64*)(PyArray_DATA(V245)); 45637 V247_iter = (npy_float64*)(PyArray_DATA(V247)); 45638 V249_iter = (npy_float64*)(PyArray_DATA(V249)); 45639 V251_iter = (npy_float64*)(PyArray_DATA(V251)); 45640 V253_iter = (npy_float64*)(PyArray_DATA(V253)); 45641 V255_iter = (npy_float64*)(PyArray_DATA(V255)); 45642 V257_iter = (npy_float64*)(PyArray_DATA(V257)); 45643 V259_iter = (npy_float64*)(PyArray_DATA(V259)); 45644 V261_iter = (npy_float64*)(PyArray_DATA(V261)); 45645 V263_iter = (npy_float64*)(PyArray_DATA(V263)); 45646 V265_iter = (npy_float64*)(PyArray_DATA(V265)); 45647 V267_iter = (npy_float64*)(PyArray_DATA(V267)); 45648 V269_iter = (npy_float64*)(PyArray_DATA(V269)); 45649 V271_iter = (npy_float64*)(PyArray_DATA(V271)); 45650 V273_iter = (npy_float64*)(PyArray_DATA(V273)); 45651 V275_iter = (npy_float64*)(PyArray_DATA(V275)); 45652 V277_iter = (npy_float64*)(PyArray_DATA(V277)); 45653 V279_iter = (npy_float64*)(PyArray_DATA(V279)); 45654 V281_iter = (npy_float64*)(PyArray_DATA(V281)); 45655 V283_iter = (npy_float64*)(PyArray_DATA(V283)); 45656 V285_iter = (npy_float64*)(PyArray_DATA(V285)); 45657 V287_iter = (npy_float64*)(PyArray_DATA(V287)); 45658 V289_iter = (npy_float64*)(PyArray_DATA(V289)); 45659 V291_iter = (npy_float64*)(PyArray_DATA(V291)); 45660 V293_iter = (npy_float64*)(PyArray_DATA(V293)); 45661 V295_iter = (npy_float64*)(PyArray_DATA(V295)); 45662 V297_iter = (npy_float64*)(PyArray_DATA(V297)); 45663 V299_iter = (npy_float64*)(PyArray_DATA(V299)); 45664 V301_iter = (npy_float64*)(PyArray_DATA(V301)); 45665 V303_iter = (npy_float64*)(PyArray_DATA(V303)); 45666 V305_iter = (npy_float64*)(PyArray_DATA(V305)); 45667 V307_iter = (npy_float64*)(PyArray_DATA(V307)); 45668 V309_iter = (npy_float64*)(PyArray_DATA(V309)); 45669 V311_iter = (npy_float64*)(PyArray_DATA(V311)); 45670 V313_iter = (npy_float64*)(PyArray_DATA(V313)); 45671 V315_iter = (npy_float64*)(PyArray_DATA(V315)); 45672 V317_iter = (npy_float64*)(PyArray_DATA(V317)); 45673 V319_iter = (npy_float64*)(PyArray_DATA(V319)); 45674 V321_iter = (npy_float64*)(PyArray_DATA(V321)); 45675 V323_iter = (npy_float64*)(PyArray_DATA(V323)); 45676 V325_iter = (npy_float64*)(PyArray_DATA(V325)); 45677 V327_iter = (npy_float64*)(PyArray_DATA(V327)); 45678 V329_iter = (npy_float64*)(PyArray_DATA(V329)); 45679 V331_iter = (npy_float64*)(PyArray_DATA(V331)); 45680 V333_iter = (npy_float64*)(PyArray_DATA(V333)); 45681 V335_iter = (npy_float64*)(PyArray_DATA(V335)); 45682 V337_iter = (npy_float64*)(PyArray_DATA(V337)); 45683 V339_iter = (npy_float64*)(PyArray_DATA(V339)); 45684 V341_iter = (npy_float64*)(PyArray_DATA(V341)); 45685 V343_iter = (npy_float64*)(PyArray_DATA(V343)); 45686 V345_iter = (npy_float64*)(PyArray_DATA(V345)); 45687 V347_iter = (npy_float64*)(PyArray_DATA(V347)); 45688 V349_iter = (npy_float64*)(PyArray_DATA(V349)); 45689 V351_iter = (npy_float64*)(PyArray_DATA(V351)); 45690 V353_iter = (npy_float64*)(PyArray_DATA(V353)); 45691 V355_iter = (npy_float64*)(PyArray_DATA(V355)); 45692 V357_iter = (npy_float64*)(PyArray_DATA(V357)); 45693 V359_iter = (npy_float64*)(PyArray_DATA(V359)); 45694 V361_iter = (npy_float64*)(PyArray_DATA(V361)); 45695 V363_iter = (npy_float64*)(PyArray_DATA(V363)); 45696 V365_iter = (npy_float64*)(PyArray_DATA(V365)); 45697 V367_iter = (npy_float64*)(PyArray_DATA(V367)); 45698 V369_iter = (npy_float64*)(PyArray_DATA(V369)); 45699 V371_iter = (npy_float64*)(PyArray_DATA(V371)); 45700 V373_iter = (npy_float64*)(PyArray_DATA(V373)); 45701 V375_iter = (npy_float64*)(PyArray_DATA(V375)); 45702 V377_iter = (npy_float64*)(PyArray_DATA(V377)); 45703 V379_iter = (npy_float64*)(PyArray_DATA(V379)); 45704 V381_iter = (npy_float64*)(PyArray_DATA(V381)); 45705 V383_iter = (npy_float64*)(PyArray_DATA(V383)); 45706 V385_iter = (npy_float64*)(PyArray_DATA(V385)); 45707 V387_iter = (npy_float64*)(PyArray_DATA(V387)); 45708 V389_iter = (npy_float64*)(PyArray_DATA(V389)); 45709 V391_iter = (npy_float64*)(PyArray_DATA(V391)); 45710 V393_iter = (npy_float64*)(PyArray_DATA(V393)); 45711 V395_iter = (npy_float64*)(PyArray_DATA(V395)); 45712 V397_iter = (npy_float64*)(PyArray_DATA(V397)); 45713 V399_iter = (npy_float64*)(PyArray_DATA(V399)); 45714 V401_iter = (npy_float64*)(PyArray_DATA(V401)); 45715 V403_iter = (npy_float64*)(PyArray_DATA(V403)); 45716 V405_iter = (npy_float64*)(PyArray_DATA(V405)); 45717 V407_iter = (npy_float64*)(PyArray_DATA(V407)); 45718 V409_iter = (npy_float64*)(PyArray_DATA(V409)); 45719 V411_iter = (npy_float64*)(PyArray_DATA(V411)); 45720 V413_iter = (npy_float64*)(PyArray_DATA(V413)); 45721 V415_iter = (npy_float64*)(PyArray_DATA(V415)); 45722 V417_iter = (npy_float64*)(PyArray_DATA(V417)); 45723 V419_iter = (npy_float64*)(PyArray_DATA(V419)); 45724 V421_iter = (npy_float64*)(PyArray_DATA(V421)); 45725 V423_iter = (npy_float64*)(PyArray_DATA(V423)); 45726 V425_iter = (npy_float64*)(PyArray_DATA(V425)); 45727 V427_iter = (npy_float64*)(PyArray_DATA(V427)); 45728 V429_iter = (npy_float64*)(PyArray_DATA(V429)); 45729 V431_iter = (npy_float64*)(PyArray_DATA(V431)); 45730 V433_iter = (npy_float64*)(PyArray_DATA(V433)); 45731 V435_iter = (npy_float64*)(PyArray_DATA(V435)); 45732 V437_iter = (npy_float64*)(PyArray_DATA(V437)); 45733 V439_iter = (npy_float64*)(PyArray_DATA(V439)); 45734 V441_iter = (npy_float64*)(PyArray_DATA(V441)); 45735 V443_iter = (npy_float64*)(PyArray_DATA(V443)); 45736 V445_iter = (npy_float64*)(PyArray_DATA(V445)); 45737 V447_iter = (npy_float64*)(PyArray_DATA(V447)); 45738 V449_iter = (npy_float64*)(PyArray_DATA(V449)); 45739 V451_iter = (npy_float64*)(PyArray_DATA(V451)); 45740 V453_iter = (npy_float64*)(PyArray_DATA(V453)); 45741 V455_iter = (npy_float64*)(PyArray_DATA(V455)); 45742 V457_iter = (npy_float64*)(PyArray_DATA(V457)); 45743 V459_iter = (npy_float64*)(PyArray_DATA(V459)); 45744 V461_iter = (npy_float64*)(PyArray_DATA(V461)); 45745 V463_iter = (npy_float64*)(PyArray_DATA(V463)); 45746 V465_iter = (npy_float64*)(PyArray_DATA(V465)); 45747 V467_iter = (npy_float64*)(PyArray_DATA(V467)); 45748 V469_iter = (npy_float64*)(PyArray_DATA(V469)); 45749 V471_iter = (npy_float64*)(PyArray_DATA(V471)); 45750 V473_iter = (npy_float64*)(PyArray_DATA(V473)); 45751 V475_iter = (npy_float64*)(PyArray_DATA(V475)); 45752 V477_iter = (npy_float64*)(PyArray_DATA(V477)); 45753 V479_iter = (npy_float64*)(PyArray_DATA(V479)); 45754 V481_iter = (npy_float64*)(PyArray_DATA(V481)); 45755 V483_iter = (npy_float64*)(PyArray_DATA(V483)); 45756 V485_iter = (npy_float64*)(PyArray_DATA(V485)); 45757 V487_iter = (npy_float64*)(PyArray_DATA(V487)); 45758 V489_iter = (npy_float64*)(PyArray_DATA(V489)); 45759 V491_iter = (npy_float64*)(PyArray_DATA(V491)); 45760 V493_iter = (npy_float64*)(PyArray_DATA(V493)); 45761 V495_iter = (npy_float64*)(PyArray_DATA(V495)); 45762 V497_iter = (npy_float64*)(PyArray_DATA(V497)); 45763 V499_iter = (npy_float64*)(PyArray_DATA(V499)); 45764 V501_iter = (npy_float64*)(PyArray_DATA(V501)); 45765 V503_iter = (npy_float64*)(PyArray_DATA(V503)); 45766 V505_iter = (npy_float64*)(PyArray_DATA(V505)); 45767 V507_iter = (npy_float64*)(PyArray_DATA(V507)); 45768 V509_iter = (npy_float64*)(PyArray_DATA(V509)); 45769 V511_iter = (npy_float64*)(PyArray_DATA(V511)); 45770 V513_iter = (npy_float64*)(PyArray_DATA(V513)); 45771 V515_iter = (npy_float64*)(PyArray_DATA(V515)); 45772 V517_iter = (npy_float64*)(PyArray_DATA(V517)); 45773 V519_iter = (npy_float64*)(PyArray_DATA(V519)); 45774 V521_iter = (npy_float64*)(PyArray_DATA(V521)); 45775 V523_iter = (npy_float64*)(PyArray_DATA(V523)); 45776 V525_iter = (npy_float64*)(PyArray_DATA(V525)); 45777 V527_iter = (npy_float64*)(PyArray_DATA(V527)); 45778 V529_iter = (npy_float64*)(PyArray_DATA(V529)); 45779 V531_iter = (npy_float64*)(PyArray_DATA(V531)); 45780 V533_iter = (npy_float64*)(PyArray_DATA(V533)); 45781 V535_iter = (npy_float64*)(PyArray_DATA(V535)); 45782 V537_iter = (npy_float64*)(PyArray_DATA(V537)); 45783 V539_iter = (npy_float64*)(PyArray_DATA(V539)); 45784 V541_iter = (npy_float64*)(PyArray_DATA(V541)); 45785 V543_iter = (npy_float64*)(PyArray_DATA(V543)); 45786 V545_iter = (npy_float64*)(PyArray_DATA(V545)); 45787 V547_iter = (npy_float64*)(PyArray_DATA(V547)); 45788 V549_iter = (npy_float64*)(PyArray_DATA(V549)); 45789 V551_iter = (npy_float64*)(PyArray_DATA(V551)); 45790 V553_iter = (npy_float64*)(PyArray_DATA(V553)); 45791 V555_iter = (npy_float64*)(PyArray_DATA(V555)); 45792 V557_iter = (npy_float64*)(PyArray_DATA(V557)); 45793 V559_iter = (npy_float64*)(PyArray_DATA(V559)); 45794 V561_iter = (npy_float64*)(PyArray_DATA(V561)); 45795 V563_iter = (npy_float64*)(PyArray_DATA(V563)); 45796 V565_iter = (npy_float64*)(PyArray_DATA(V565)); 45797 V567_iter = (npy_float64*)(PyArray_DATA(V567)); 45798 V569_iter = (npy_float64*)(PyArray_DATA(V569)); 45799 V571_iter = (npy_float64*)(PyArray_DATA(V571)); 45800 V573_iter = (npy_float64*)(PyArray_DATA(V573)); 45801 V575_iter = (npy_float64*)(PyArray_DATA(V575)); 45802 V577_iter = (npy_float64*)(PyArray_DATA(V577)); 45803 V579_iter = (npy_float64*)(PyArray_DATA(V579)); 45804 V581_iter = (npy_float64*)(PyArray_DATA(V581)); 45805 V583_iter = (npy_float64*)(PyArray_DATA(V583)); 45806 V585_iter = (npy_float64*)(PyArray_DATA(V585)); 45807 V587_iter = (npy_float64*)(PyArray_DATA(V587)); 45808 V589_iter = (npy_float64*)(PyArray_DATA(V589)); 45809 V591_iter = (npy_float64*)(PyArray_DATA(V591)); 45810 V593_iter = (npy_float64*)(PyArray_DATA(V593)); 45811 V595_iter = (npy_float64*)(PyArray_DATA(V595)); 45812 V597_iter = (npy_float64*)(PyArray_DATA(V597)); 45813 V599_iter = (npy_float64*)(PyArray_DATA(V599)); 45814 V601_iter = (npy_float64*)(PyArray_DATA(V601)); 45815 V603_iter = (npy_float64*)(PyArray_DATA(V603)); 45816 V605_iter = (npy_float64*)(PyArray_DATA(V605)); 45817 V607_iter = (npy_float64*)(PyArray_DATA(V607)); 45818 V609_iter = (npy_float64*)(PyArray_DATA(V609)); 45819 V611_iter = (npy_float64*)(PyArray_DATA(V611)); 45820 V613_iter = (npy_float64*)(PyArray_DATA(V613)); 45821 V615_iter = (npy_float64*)(PyArray_DATA(V615)); 45822 V617_iter = (npy_float64*)(PyArray_DATA(V617)); 45823 V619_iter = (npy_float64*)(PyArray_DATA(V619)); 45824 V621_iter = (npy_float64*)(PyArray_DATA(V621)); 45825 V623_iter = (npy_float64*)(PyArray_DATA(V623)); 45826 V625_iter = (npy_float64*)(PyArray_DATA(V625)); 45827 V627_iter = (npy_float64*)(PyArray_DATA(V627)); 45828 V629_iter = (npy_float64*)(PyArray_DATA(V629)); 45829 V631_iter = (npy_float64*)(PyArray_DATA(V631)); 45830 V633_iter = (npy_float64*)(PyArray_DATA(V633)); 45831 V635_iter = (npy_float64*)(PyArray_DATA(V635)); 45832 V637_iter = (npy_float64*)(PyArray_DATA(V637)); 45833 V639_iter = (npy_float64*)(PyArray_DATA(V639)); 45834 V641_iter = (npy_float64*)(PyArray_DATA(V641)); 45835 V643_iter = (npy_float64*)(PyArray_DATA(V643)); 45836 V645_iter = (npy_float64*)(PyArray_DATA(V645)); 45837 V647_iter = (npy_float64*)(PyArray_DATA(V647)); 45838 V649_iter = (npy_float64*)(PyArray_DATA(V649)); 45839 V651_iter = (npy_float64*)(PyArray_DATA(V651)); 45840 V653_iter = (npy_float64*)(PyArray_DATA(V653)); 45841 V655_iter = (npy_float64*)(PyArray_DATA(V655)); 45842 V657_iter = (npy_float64*)(PyArray_DATA(V657)); 45843 V659_iter = (npy_float64*)(PyArray_DATA(V659)); 45844 V661_iter = (npy_float64*)(PyArray_DATA(V661)); 45845 V663_iter = (npy_float64*)(PyArray_DATA(V663)); 45846 V665_iter = (npy_float64*)(PyArray_DATA(V665)); 45847 V667_iter = (npy_float64*)(PyArray_DATA(V667)); 45848 V669_iter = (npy_float64*)(PyArray_DATA(V669)); 45849 V671_iter = (npy_float64*)(PyArray_DATA(V671)); 45850 V673_iter = (npy_float64*)(PyArray_DATA(V673)); 45851 V675_iter = (npy_float64*)(PyArray_DATA(V675)); 45852 V677_iter = (npy_float64*)(PyArray_DATA(V677)); 45853 V679_iter = (npy_float64*)(PyArray_DATA(V679)); 45854 V681_iter = (npy_float64*)(PyArray_DATA(V681)); 45855 V683_iter = (npy_float64*)(PyArray_DATA(V683)); 45856 V685_iter = (npy_float64*)(PyArray_DATA(V685)); 45857 V687_iter = (npy_float64*)(PyArray_DATA(V687)); 45858 V689_iter = (npy_float64*)(PyArray_DATA(V689)); 45859 V691_iter = (npy_float64*)(PyArray_DATA(V691)); 45860 V693_iter = (npy_float64*)(PyArray_DATA(V693)); 45861 V695_iter = (npy_float64*)(PyArray_DATA(V695)); 45862 V697_iter = (npy_float64*)(PyArray_DATA(V697)); 45863 V699_iter = (npy_float64*)(PyArray_DATA(V699)); 45864 V701_iter = (npy_float64*)(PyArray_DATA(V701)); 45865 V703_iter = (npy_float64*)(PyArray_DATA(V703)); 45866 V705_iter = (npy_float64*)(PyArray_DATA(V705)); 45867 V707_iter = (npy_float64*)(PyArray_DATA(V707)); 45868 V709_iter = (npy_float64*)(PyArray_DATA(V709)); 45869 V711_iter = (npy_float64*)(PyArray_DATA(V711)); 45870 V713_iter = (npy_float64*)(PyArray_DATA(V713)); 45871 V715_iter = (npy_float64*)(PyArray_DATA(V715)); 45872 V717_iter = (npy_float64*)(PyArray_DATA(V717)); 45873 V719_iter = (npy_float64*)(PyArray_DATA(V719)); 45874 V721_iter = (npy_float64*)(PyArray_DATA(V721)); 45875 V723_iter = (npy_float64*)(PyArray_DATA(V723)); 45876 V725_iter = (npy_float64*)(PyArray_DATA(V725)); 45877 V727_iter = (npy_float64*)(PyArray_DATA(V727)); 45878 V729_iter = (npy_float64*)(PyArray_DATA(V729)); 45879 V731_iter = (npy_float64*)(PyArray_DATA(V731)); 45880 V733_iter = (npy_float64*)(PyArray_DATA(V733)); 45881 V735_iter = (npy_float64*)(PyArray_DATA(V735)); 45882 V737_iter = (npy_float64*)(PyArray_DATA(V737)); 45883 V739_iter = (npy_float64*)(PyArray_DATA(V739)); 45884 V741_iter = (npy_float64*)(PyArray_DATA(V741)); 45885 V743_iter = (npy_float64*)(PyArray_DATA(V743)); 45886 V745_iter = (npy_float64*)(PyArray_DATA(V745)); 45887 V747_iter = (npy_float64*)(PyArray_DATA(V747)); 45888 V749_iter = (npy_float64*)(PyArray_DATA(V749)); 45889 V751_iter = (npy_float64*)(PyArray_DATA(V751)); 45890 V753_iter = (npy_float64*)(PyArray_DATA(V753)); 45891 V755_iter = (npy_float64*)(PyArray_DATA(V755)); 45892 V757_iter = (npy_float64*)(PyArray_DATA(V757)); 45893 V759_iter = (npy_float64*)(PyArray_DATA(V759)); 45894 V761_iter = (npy_float64*)(PyArray_DATA(V761)); 45895 V763_iter = (npy_float64*)(PyArray_DATA(V763)); 45896 V765_iter = (npy_float64*)(PyArray_DATA(V765)); 45897 V767_iter = (npy_float64*)(PyArray_DATA(V767)); 45898 V769_iter = (npy_float64*)(PyArray_DATA(V769)); 45899 V771_iter = (npy_float64*)(PyArray_DATA(V771)); 45900 V773_iter = (npy_float64*)(PyArray_DATA(V773)); 45901 V775_iter = (npy_float64*)(PyArray_DATA(V775)); 45902 V777_iter = (npy_float64*)(PyArray_DATA(V777)); 45903 V779_iter = (npy_float64*)(PyArray_DATA(V779)); 45904 V781_iter = (npy_float64*)(PyArray_DATA(V781)); 45905 V783_iter = (npy_float64*)(PyArray_DATA(V783)); 45906 V785_iter = (npy_float64*)(PyArray_DATA(V785)); 45907 V787_iter = (npy_float64*)(PyArray_DATA(V787)); 45908 V789_iter = (npy_float64*)(PyArray_DATA(V789)); 45909 V791_iter = (npy_float64*)(PyArray_DATA(V791)); 45910 V793_iter = (npy_float64*)(PyArray_DATA(V793)); 45911 V795_iter = (npy_float64*)(PyArray_DATA(V795)); 45912 V797_iter = (npy_float64*)(PyArray_DATA(V797)); 45913 V799_iter = (npy_float64*)(PyArray_DATA(V799)); 45914 V801_iter = (npy_float64*)(PyArray_DATA(V801)); 45915 V803_iter = (npy_float64*)(PyArray_DATA(V803)); 45916 V805_iter = (npy_float64*)(PyArray_DATA(V805)); 45917 V807_iter = (npy_float64*)(PyArray_DATA(V807)); 45918 V809_iter = (npy_float64*)(PyArray_DATA(V809)); 45919 V811_iter = (npy_float64*)(PyArray_DATA(V811)); 45920 V813_iter = (npy_float64*)(PyArray_DATA(V813)); 45921 V815_iter = (npy_float64*)(PyArray_DATA(V815)); 45922 V817_iter = (npy_float64*)(PyArray_DATA(V817)); 45923 V819_iter = (npy_float64*)(PyArray_DATA(V819)); 45924 V821_iter = (npy_float64*)(PyArray_DATA(V821)); 45925 V823_iter = (npy_float64*)(PyArray_DATA(V823)); 45926 V825_iter = (npy_float64*)(PyArray_DATA(V825)); 45927 V827_iter = (npy_float64*)(PyArray_DATA(V827)); 45928 V829_iter = (npy_float64*)(PyArray_DATA(V829)); 45929 V831_iter = (npy_float64*)(PyArray_DATA(V831)); 45930 V833_iter = (npy_float64*)(PyArray_DATA(V833)); 45931 V835_iter = (npy_float64*)(PyArray_DATA(V835)); 45932 V837_iter = (npy_float64*)(PyArray_DATA(V837)); 45933 V839_iter = (npy_float64*)(PyArray_DATA(V839)); 45934 V841_iter = (npy_float64*)(PyArray_DATA(V841)); 45935 V843_iter = (npy_float64*)(PyArray_DATA(V843)); 45936 V845_iter = (npy_float64*)(PyArray_DATA(V845)); 45937 V847_iter = (npy_float64*)(PyArray_DATA(V847)); 45938 V849_iter = (npy_float64*)(PyArray_DATA(V849)); 45939 V851_iter = (npy_float64*)(PyArray_DATA(V851)); 45940 V853_iter = (npy_float64*)(PyArray_DATA(V853)); 45941 V855_iter = (npy_float64*)(PyArray_DATA(V855)); 45942 V857_iter = (npy_float64*)(PyArray_DATA(V857)); 45943 V859_iter = (npy_float64*)(PyArray_DATA(V859)); 45944 V861_iter = (npy_float64*)(PyArray_DATA(V861)); 45945 V863_iter = (npy_float64*)(PyArray_DATA(V863)); 45946 V865_iter = (npy_float64*)(PyArray_DATA(V865)); 45947 V867_iter = (npy_float64*)(PyArray_DATA(V867)); 45948 V869_iter = (npy_float64*)(PyArray_DATA(V869)); 45949 V871_iter = (npy_float64*)(PyArray_DATA(V871)); 45950 V873_iter = (npy_float64*)(PyArray_DATA(V873)); 45951 V875_iter = (npy_float64*)(PyArray_DATA(V875)); 45952 V877_iter = (npy_float64*)(PyArray_DATA(V877)); 45953 V879_iter = (npy_float64*)(PyArray_DATA(V879)); 45954 V881_iter = (npy_float64*)(PyArray_DATA(V881)); 45955 V883_iter = (npy_float64*)(PyArray_DATA(V883)); 45956 V885_iter = (npy_float64*)(PyArray_DATA(V885)); 45957 V887_iter = (npy_float64*)(PyArray_DATA(V887)); 45958 V889_iter = (npy_float64*)(PyArray_DATA(V889)); 45959 V891_iter = (npy_float64*)(PyArray_DATA(V891)); 45960 V893_iter = (npy_float64*)(PyArray_DATA(V893)); 45961 V895_iter = (npy_float64*)(PyArray_DATA(V895)); 45962 V897_iter = (npy_float64*)(PyArray_DATA(V897)); 45963 V899_iter = (npy_float64*)(PyArray_DATA(V899)); 45964 V901_iter = (npy_float64*)(PyArray_DATA(V901)); 45965 V903_iter = (npy_float64*)(PyArray_DATA(V903)); 45966 V905_iter = (npy_float64*)(PyArray_DATA(V905)); 45967 V907_iter = (npy_float64*)(PyArray_DATA(V907)); 45968 V909_iter = (npy_float64*)(PyArray_DATA(V909)); 45969 V1_iter = (npy_float64*)(PyArray_DATA(V1)); 45970 45971 npy_float64& V3_i = *V3_iter; 45972 npy_float64& V5_i = *V5_iter; 45973 npy_float64& V7_i = *V7_iter; 45974 npy_float64& V9_i = *V9_iter; 45975 npy_float64& V11_i = *V11_iter; 45976 npy_float64& V13_i = *V13_iter; 45977 npy_float64& V15_i = *V15_iter; 45978 npy_float64& V17_i = *V17_iter; 45979 npy_float64& V19_i = *V19_iter; 45980 npy_float64& V21_i = *V21_iter; 45981 npy_float64& V23_i = *V23_iter; 45982 npy_float64& V25_i = *V25_iter; 45983 npy_float64& V27_i = *V27_iter; 45984 npy_float64& V29_i = *V29_iter; 45985 npy_float64& V31_i = *V31_iter; 45986 npy_float64& V33_i = *V33_iter; 45987 npy_float64& V35_i = *V35_iter; 45988 npy_float64& V37_i = *V37_iter; 45989 npy_float64& V39_i = *V39_iter; 45990 npy_float64& V41_i = *V41_iter; 45991 npy_float64& V43_i = *V43_iter; 45992 npy_float64& V45_i = *V45_iter; 45993 npy_float64& V47_i = *V47_iter; 45994 npy_float64& V49_i = *V49_iter; 45995 npy_float64& V51_i = *V51_iter; 45996 npy_float64& V53_i = *V53_iter; 45997 npy_float64& V55_i = *V55_iter; 45998 npy_float64& V57_i = *V57_iter; 45999 npy_float64& V59_i = *V59_iter; 46000 npy_float64& V61_i = *V61_iter; 46001 npy_float64& V63_i = *V63_iter; 46002 npy_float64& V65_i = *V65_iter; 46003 npy_float64& V67_i = *V67_iter; 46004 npy_float64& V69_i = *V69_iter; 46005 npy_float64& V71_i = *V71_iter; 46006 npy_float64& V73_i = *V73_iter; 46007 npy_float64& V75_i = *V75_iter; 46008 npy_float64& V77_i = *V77_iter; 46009 npy_float64& V79_i = *V79_iter; 46010 npy_float64& V81_i = *V81_iter; 46011 npy_float64& V83_i = *V83_iter; 46012 npy_float64& V85_i = *V85_iter; 46013 npy_float64& V87_i = *V87_iter; 46014 npy_float64& V89_i = *V89_iter; 46015 npy_float64& V91_i = *V91_iter; 46016 npy_float64& V93_i = *V93_iter; 46017 npy_float64& V95_i = *V95_iter; 46018 npy_float64& V97_i = *V97_iter; 46019 npy_float64& V99_i = *V99_iter; 46020 npy_float64& V101_i = *V101_iter; 46021 npy_float64& V103_i = *V103_iter; 46022 npy_float64& V105_i = *V105_iter; 46023 npy_float64& V107_i = *V107_iter; 46024 npy_float64& V109_i = *V109_iter; 46025 npy_float64& V111_i = *V111_iter; 46026 npy_float64& V113_i = *V113_iter; 46027 npy_float64& V115_i = *V115_iter; 46028 npy_float64& V117_i = *V117_iter; 46029 npy_float64& V119_i = *V119_iter; 46030 npy_float64& V121_i = *V121_iter; 46031 npy_float64& V123_i = *V123_iter; 46032 npy_float64& V125_i = *V125_iter; 46033 npy_float64& V127_i = *V127_iter; 46034 npy_float64& V129_i = *V129_iter; 46035 npy_float64& V131_i = *V131_iter; 46036 npy_float64& V133_i = *V133_iter; 46037 npy_float64& V135_i = *V135_iter; 46038 npy_float64& V137_i = *V137_iter; 46039 npy_float64& V139_i = *V139_iter; 46040 npy_float64& V141_i = *V141_iter; 46041 npy_float64& V143_i = *V143_iter; 46042 npy_float64& V145_i = *V145_iter; 46043 npy_float64& V147_i = *V147_iter; 46044 npy_float64& V149_i = *V149_iter; 46045 npy_float64& V151_i = *V151_iter; 46046 npy_float64& V153_i = *V153_iter; 46047 npy_float64& V155_i = *V155_iter; 46048 npy_float64& V157_i = *V157_iter; 46049 npy_float64& V159_i = *V159_iter; 46050 npy_float64& V161_i = *V161_iter; 46051 npy_float64& V163_i = *V163_iter; 46052 npy_float64& V165_i = *V165_iter; 46053 npy_float64& V167_i = *V167_iter; 46054 npy_float64& V169_i = *V169_iter; 46055 npy_float64& V171_i = *V171_iter; 46056 npy_float64& V173_i = *V173_iter; 46057 npy_float64& V175_i = *V175_iter; 46058 npy_float64& V177_i = *V177_iter; 46059 npy_float64& V179_i = *V179_iter; 46060 npy_float64& V181_i = *V181_iter; 46061 npy_float64& V183_i = *V183_iter; 46062 npy_float64& V185_i = *V185_iter; 46063 npy_float64& V187_i = *V187_iter; 46064 npy_float64& V189_i = *V189_iter; 46065 npy_float64& V191_i = *V191_iter; 46066 npy_float64& V193_i = *V193_iter; 46067 npy_float64& V195_i = *V195_iter; 46068 npy_float64& V197_i = *V197_iter; 46069 npy_float64& V199_i = *V199_iter; 46070 npy_float64& V201_i = *V201_iter; 46071 npy_float64& V203_i = *V203_iter; 46072 npy_float64& V205_i = *V205_iter; 46073 npy_float64& V207_i = *V207_iter; 46074 npy_float64& V209_i = *V209_iter; 46075 npy_float64& V211_i = *V211_iter; 46076 npy_float64& V213_i = *V213_iter; 46077 npy_float64& V215_i = *V215_iter; 46078 npy_float64& V217_i = *V217_iter; 46079 npy_float64& V219_i = *V219_iter; 46080 npy_float64& V221_i = *V221_iter; 46081 npy_float64& V223_i = *V223_iter; 46082 npy_float64& V225_i = *V225_iter; 46083 npy_float64& V227_i = *V227_iter; 46084 npy_float64& V229_i = *V229_iter; 46085 npy_float64& V231_i = *V231_iter; 46086 npy_float64& V233_i = *V233_iter; 46087 npy_float64& V235_i = *V235_iter; 46088 npy_float64& V237_i = *V237_iter; 46089 npy_float64& V239_i = *V239_iter; 46090 npy_float64& V241_i = *V241_iter; 46091 npy_float64& V243_i = *V243_iter; 46092 npy_float64& V245_i = *V245_iter; 46093 npy_float64& V247_i = *V247_iter; 46094 npy_float64& V249_i = *V249_iter; 46095 npy_float64& V251_i = *V251_iter; 46096 npy_float64& V253_i = *V253_iter; 46097 npy_float64& V255_i = *V255_iter; 46098 npy_float64& V257_i = *V257_iter; 46099 npy_float64& V259_i = *V259_iter; 46100 npy_float64& V261_i = *V261_iter; 46101 npy_float64& V263_i = *V263_iter; 46102 npy_float64& V265_i = *V265_iter; 46103 npy_float64& V267_i = *V267_iter; 46104 npy_float64& V269_i = *V269_iter; 46105 npy_float64& V271_i = *V271_iter; 46106 npy_float64& V273_i = *V273_iter; 46107 npy_float64& V275_i = *V275_iter; 46108 npy_float64& V277_i = *V277_iter; 46109 npy_float64& V279_i = *V279_iter; 46110 npy_float64& V281_i = *V281_iter; 46111 npy_float64& V283_i = *V283_iter; 46112 npy_float64& V285_i = *V285_iter; 46113 npy_float64& V287_i = *V287_iter; 46114 npy_float64& V289_i = *V289_iter; 46115 npy_float64& V291_i = *V291_iter; 46116 npy_float64& V293_i = *V293_iter; 46117 npy_float64& V295_i = *V295_iter; 46118 npy_float64& V297_i = *V297_iter; 46119 npy_float64& V299_i = *V299_iter; 46120 npy_float64& V301_i = *V301_iter; 46121 npy_float64& V303_i = *V303_iter; 46122 npy_float64& V305_i = *V305_iter; 46123 npy_float64& V307_i = *V307_iter; 46124 npy_float64& V309_i = *V309_iter; 46125 npy_float64& V311_i = *V311_iter; 46126 npy_float64& V313_i = *V313_iter; 46127 npy_float64& V315_i = *V315_iter; 46128 npy_float64& V317_i = *V317_iter; 46129 npy_float64& V319_i = *V319_iter; 46130 npy_float64& V321_i = *V321_iter; 46131 npy_float64& V323_i = *V323_iter; 46132 npy_float64& V325_i = *V325_iter; 46133 npy_float64& V327_i = *V327_iter; 46134 npy_float64& V329_i = *V329_iter; 46135 npy_float64& V331_i = *V331_iter; 46136 npy_float64& V333_i = *V333_iter; 46137 npy_float64& V335_i = *V335_iter; 46138 npy_float64& V337_i = *V337_iter; 46139 npy_float64& V339_i = *V339_iter; 46140 npy_float64& V341_i = *V341_iter; 46141 npy_float64& V343_i = *V343_iter; 46142 npy_float64& V345_i = *V345_iter; 46143 npy_float64& V347_i = *V347_iter; 46144 npy_float64& V349_i = *V349_iter; 46145 npy_float64& V351_i = *V351_iter; 46146 npy_float64& V353_i = *V353_iter; 46147 npy_float64& V355_i = *V355_iter; 46148 npy_float64& V357_i = *V357_iter; 46149 npy_float64& V359_i = *V359_iter; 46150 npy_float64& V361_i = *V361_iter; 46151 npy_float64& V363_i = *V363_iter; 46152 npy_float64& V365_i = *V365_iter; 46153 npy_float64& V367_i = *V367_iter; 46154 npy_float64& V369_i = *V369_iter; 46155 npy_float64& V371_i = *V371_iter; 46156 npy_float64& V373_i = *V373_iter; 46157 npy_float64& V375_i = *V375_iter; 46158 npy_float64& V377_i = *V377_iter; 46159 npy_float64& V379_i = *V379_iter; 46160 npy_float64& V381_i = *V381_iter; 46161 npy_float64& V383_i = *V383_iter; 46162 npy_float64& V385_i = *V385_iter; 46163 npy_float64& V387_i = *V387_iter; 46164 npy_float64& V389_i = *V389_iter; 46165 npy_float64& V391_i = *V391_iter; 46166 npy_float64& V393_i = *V393_iter; 46167 npy_float64& V395_i = *V395_iter; 46168 npy_float64& V397_i = *V397_iter; 46169 npy_float64& V399_i = *V399_iter; 46170 npy_float64& V401_i = *V401_iter; 46171 npy_float64& V403_i = *V403_iter; 46172 npy_float64& V405_i = *V405_iter; 46173 npy_float64& V407_i = *V407_iter; 46174 npy_float64& V409_i = *V409_iter; 46175 npy_float64& V411_i = *V411_iter; 46176 npy_float64& V413_i = *V413_iter; 46177 npy_float64& V415_i = *V415_iter; 46178 npy_float64& V417_i = *V417_iter; 46179 npy_float64& V419_i = *V419_iter; 46180 npy_float64& V421_i = *V421_iter; 46181 npy_float64& V423_i = *V423_iter; 46182 npy_float64& V425_i = *V425_iter; 46183 npy_float64& V427_i = *V427_iter; 46184 npy_float64& V429_i = *V429_iter; 46185 npy_float64& V431_i = *V431_iter; 46186 npy_float64& V433_i = *V433_iter; 46187 npy_float64& V435_i = *V435_iter; 46188 npy_float64& V437_i = *V437_iter; 46189 npy_float64& V439_i = *V439_iter; 46190 npy_float64& V441_i = *V441_iter; 46191 npy_float64& V443_i = *V443_iter; 46192 npy_float64& V445_i = *V445_iter; 46193 npy_float64& V447_i = *V447_iter; 46194 npy_float64& V449_i = *V449_iter; 46195 npy_float64& V451_i = *V451_iter; 46196 npy_float64& V453_i = *V453_iter; 46197 npy_float64& V455_i = *V455_iter; 46198 npy_float64& V457_i = *V457_iter; 46199 npy_float64& V459_i = *V459_iter; 46200 npy_float64& V461_i = *V461_iter; 46201 npy_float64& V463_i = *V463_iter; 46202 npy_float64& V465_i = *V465_iter; 46203 npy_float64& V467_i = *V467_iter; 46204 npy_float64& V469_i = *V469_iter; 46205 npy_float64& V471_i = *V471_iter; 46206 npy_float64& V473_i = *V473_iter; 46207 npy_float64& V475_i = *V475_iter; 46208 npy_float64& V477_i = *V477_iter; 46209 npy_float64& V479_i = *V479_iter; 46210 npy_float64& V481_i = *V481_iter; 46211 npy_float64& V483_i = *V483_iter; 46212 npy_float64& V485_i = *V485_iter; 46213 npy_float64& V487_i = *V487_iter; 46214 npy_float64& V489_i = *V489_iter; 46215 npy_float64& V491_i = *V491_iter; 46216 npy_float64& V493_i = *V493_iter; 46217 npy_float64& V495_i = *V495_iter; 46218 npy_float64& V497_i = *V497_iter; 46219 npy_float64& V499_i = *V499_iter; 46220 npy_float64& V501_i = *V501_iter; 46221 npy_float64& V503_i = *V503_iter; 46222 npy_float64& V505_i = *V505_iter; 46223 npy_float64& V507_i = *V507_iter; 46224 npy_float64& V509_i = *V509_iter; 46225 npy_float64& V511_i = *V511_iter; 46226 npy_float64& V513_i = *V513_iter; 46227 npy_float64& V515_i = *V515_iter; 46228 npy_float64& V517_i = *V517_iter; 46229 npy_float64& V519_i = *V519_iter; 46230 npy_float64& V521_i = *V521_iter; 46231 npy_float64& V523_i = *V523_iter; 46232 npy_float64& V525_i = *V525_iter; 46233 npy_float64& V527_i = *V527_iter; 46234 npy_float64& V529_i = *V529_iter; 46235 npy_float64& V531_i = *V531_iter; 46236 npy_float64& V533_i = *V533_iter; 46237 npy_float64& V535_i = *V535_iter; 46238 npy_float64& V537_i = *V537_iter; 46239 npy_float64& V539_i = *V539_iter; 46240 npy_float64& V541_i = *V541_iter; 46241 npy_float64& V543_i = *V543_iter; 46242 npy_float64& V545_i = *V545_iter; 46243 npy_float64& V547_i = *V547_iter; 46244 npy_float64& V549_i = *V549_iter; 46245 npy_float64& V551_i = *V551_iter; 46246 npy_float64& V553_i = *V553_iter; 46247 npy_float64& V555_i = *V555_iter; 46248 npy_float64& V557_i = *V557_iter; 46249 npy_float64& V559_i = *V559_iter; 46250 npy_float64& V561_i = *V561_iter; 46251 npy_float64& V563_i = *V563_iter; 46252 npy_float64& V565_i = *V565_iter; 46253 npy_float64& V567_i = *V567_iter; 46254 npy_float64& V569_i = *V569_iter; 46255 npy_float64& V571_i = *V571_iter; 46256 npy_float64& V573_i = *V573_iter; 46257 npy_float64& V575_i = *V575_iter; 46258 npy_float64& V577_i = *V577_iter; 46259 npy_float64& V579_i = *V579_iter; 46260 npy_float64& V581_i = *V581_iter; 46261 npy_float64& V583_i = *V583_iter; 46262 npy_float64& V585_i = *V585_iter; 46263 npy_float64& V587_i = *V587_iter; 46264 npy_float64& V589_i = *V589_iter; 46265 npy_float64& V591_i = *V591_iter; 46266 npy_float64& V593_i = *V593_iter; 46267 npy_float64& V595_i = *V595_iter; 46268 npy_float64& V597_i = *V597_iter; 46269 npy_float64& V599_i = *V599_iter; 46270 npy_float64& V601_i = *V601_iter; 46271 npy_float64& V603_i = *V603_iter; 46272 npy_float64& V605_i = *V605_iter; 46273 npy_float64& V607_i = *V607_iter; 46274 npy_float64& V609_i = *V609_iter; 46275 npy_float64& V611_i = *V611_iter; 46276 npy_float64& V613_i = *V613_iter; 46277 npy_float64& V615_i = *V615_iter; 46278 npy_float64& V617_i = *V617_iter; 46279 npy_float64& V619_i = *V619_iter; 46280 npy_float64& V621_i = *V621_iter; 46281 npy_float64& V623_i = *V623_iter; 46282 npy_float64& V625_i = *V625_iter; 46283 npy_float64& V627_i = *V627_iter; 46284 npy_float64& V629_i = *V629_iter; 46285 npy_float64& V631_i = *V631_iter; 46286 npy_float64& V633_i = *V633_iter; 46287 npy_float64& V635_i = *V635_iter; 46288 npy_float64& V637_i = *V637_iter; 46289 npy_float64& V639_i = *V639_iter; 46290 npy_float64& V641_i = *V641_iter; 46291 npy_float64& V643_i = *V643_iter; 46292 npy_float64& V645_i = *V645_iter; 46293 npy_float64& V647_i = *V647_iter; 46294 npy_float64& V649_i = *V649_iter; 46295 npy_float64& V651_i = *V651_iter; 46296 npy_float64& V653_i = *V653_iter; 46297 npy_float64& V655_i = *V655_iter; 46298 npy_float64& V657_i = *V657_iter; 46299 npy_float64& V659_i = *V659_iter; 46300 npy_float64& V661_i = *V661_iter; 46301 npy_float64& V663_i = *V663_iter; 46302 npy_float64& V665_i = *V665_iter; 46303 npy_float64& V667_i = *V667_iter; 46304 npy_float64& V669_i = *V669_iter; 46305 npy_float64& V671_i = *V671_iter; 46306 npy_float64& V673_i = *V673_iter; 46307 npy_float64& V675_i = *V675_iter; 46308 npy_float64& V677_i = *V677_iter; 46309 npy_float64& V679_i = *V679_iter; 46310 npy_float64& V681_i = *V681_iter; 46311 npy_float64& V683_i = *V683_iter; 46312 npy_float64& V685_i = *V685_iter; 46313 npy_float64& V687_i = *V687_iter; 46314 npy_float64& V689_i = *V689_iter; 46315 npy_float64& V691_i = *V691_iter; 46316 npy_float64& V693_i = *V693_iter; 46317 npy_float64& V695_i = *V695_iter; 46318 npy_float64& V697_i = *V697_iter; 46319 npy_float64& V699_i = *V699_iter; 46320 npy_float64& V701_i = *V701_iter; 46321 npy_float64& V703_i = *V703_iter; 46322 npy_float64& V705_i = *V705_iter; 46323 npy_float64& V707_i = *V707_iter; 46324 npy_float64& V709_i = *V709_iter; 46325 npy_float64& V711_i = *V711_iter; 46326 npy_float64& V713_i = *V713_iter; 46327 npy_float64& V715_i = *V715_iter; 46328 npy_float64& V717_i = *V717_iter; 46329 npy_float64& V719_i = *V719_iter; 46330 npy_float64& V721_i = *V721_iter; 46331 npy_float64& V723_i = *V723_iter; 46332 npy_float64& V725_i = *V725_iter; 46333 npy_float64& V727_i = *V727_iter; 46334 npy_float64& V729_i = *V729_iter; 46335 npy_float64& V731_i = *V731_iter; 46336 npy_float64& V733_i = *V733_iter; 46337 npy_float64& V735_i = *V735_iter; 46338 npy_float64& V737_i = *V737_iter; 46339 npy_float64& V739_i = *V739_iter; 46340 npy_float64& V741_i = *V741_iter; 46341 npy_float64& V743_i = *V743_iter; 46342 npy_float64& V745_i = *V745_iter; 46343 npy_float64& V747_i = *V747_iter; 46344 npy_float64& V749_i = *V749_iter; 46345 npy_float64& V751_i = *V751_iter; 46346 npy_float64& V753_i = *V753_iter; 46347 npy_float64& V755_i = *V755_iter; 46348 npy_float64& V757_i = *V757_iter; 46349 npy_float64& V759_i = *V759_iter; 46350 npy_float64& V761_i = *V761_iter; 46351 npy_float64& V763_i = *V763_iter; 46352 npy_float64& V765_i = *V765_iter; 46353 npy_float64& V767_i = *V767_iter; 46354 npy_float64& V769_i = *V769_iter; 46355 npy_float64& V771_i = *V771_iter; 46356 npy_float64& V773_i = *V773_iter; 46357 npy_float64& V775_i = *V775_iter; 46358 npy_float64& V777_i = *V777_iter; 46359 npy_float64& V779_i = *V779_iter; 46360 npy_float64& V781_i = *V781_iter; 46361 npy_float64& V783_i = *V783_iter; 46362 npy_float64& V785_i = *V785_iter; 46363 npy_float64& V787_i = *V787_iter; 46364 npy_float64& V789_i = *V789_iter; 46365 npy_float64& V791_i = *V791_iter; 46366 npy_float64& V793_i = *V793_iter; 46367 npy_float64& V795_i = *V795_iter; 46368 npy_float64& V797_i = *V797_iter; 46369 npy_float64& V799_i = *V799_iter; 46370 npy_float64& V801_i = *V801_iter; 46371 npy_float64& V803_i = *V803_iter; 46372 npy_float64& V805_i = *V805_iter; 46373 npy_float64& V807_i = *V807_iter; 46374 npy_float64& V809_i = *V809_iter; 46375 npy_float64& V811_i = *V811_iter; 46376 npy_float64& V813_i = *V813_iter; 46377 npy_float64& V815_i = *V815_iter; 46378 npy_float64& V817_i = *V817_iter; 46379 npy_float64& V819_i = *V819_iter; 46380 npy_float64& V821_i = *V821_iter; 46381 npy_float64& V823_i = *V823_iter; 46382 npy_float64& V825_i = *V825_iter; 46383 npy_float64& V827_i = *V827_iter; 46384 npy_float64& V829_i = *V829_iter; 46385 npy_float64& V831_i = *V831_iter; 46386 npy_float64& V833_i = *V833_iter; 46387 npy_float64& V835_i = *V835_iter; 46388 npy_float64& V837_i = *V837_iter; 46389 npy_float64& V839_i = *V839_iter; 46390 npy_float64& V841_i = *V841_iter; 46391 npy_float64& V843_i = *V843_iter; 46392 npy_float64& V845_i = *V845_iter; 46393 npy_float64& V847_i = *V847_iter; 46394 npy_float64& V849_i = *V849_iter; 46395 npy_float64& V851_i = *V851_iter; 46396 npy_float64& V853_i = *V853_iter; 46397 npy_float64& V855_i = *V855_iter; 46398 npy_float64& V857_i = *V857_iter; 46399 npy_float64& V859_i = *V859_iter; 46400 npy_float64& V861_i = *V861_iter; 46401 npy_float64& V863_i = *V863_iter; 46402 npy_float64& V865_i = *V865_iter; 46403 npy_float64& V867_i = *V867_iter; 46404 npy_float64& V869_i = *V869_iter; 46405 npy_float64& V871_i = *V871_iter; 46406 npy_float64& V873_i = *V873_iter; 46407 npy_float64& V875_i = *V875_iter; 46408 npy_float64& V877_i = *V877_iter; 46409 npy_float64& V879_i = *V879_iter; 46410 npy_float64& V881_i = *V881_iter; 46411 npy_float64& V883_i = *V883_iter; 46412 npy_float64& V885_i = *V885_iter; 46413 npy_float64& V887_i = *V887_iter; 46414 npy_float64& V889_i = *V889_iter; 46415 npy_float64& V891_i = *V891_iter; 46416 npy_float64& V893_i = *V893_iter; 46417 npy_float64& V895_i = *V895_iter; 46418 npy_float64& V897_i = *V897_iter; 46419 npy_float64& V899_i = *V899_iter; 46420 npy_float64& V901_i = *V901_iter; 46421 npy_float64& V903_i = *V903_iter; 46422 npy_float64& V905_i = *V905_iter; 46423 npy_float64& V907_i = *V907_iter; 46424 npy_float64& V909_i = *V909_iter; 46425 npy_float64& V1_i = *V1_iter; 46426 46427 { 46428 npy_float64 V911_tmp1; 46429 { 46430 npy_float64 V911_0_tmp1; 46431 V911_0_tmp1 = 1.0 / V605_i; 46432 npy_float64 V911_0_tmp2; 46433 V911_0_tmp2 = log(V911_0_tmp1); 46434 V911_tmp1 = V7_i + V911_0_tmp2; 46435 } 46436 46437 npy_float64 V911_tmp2; 46438 { 46439 npy_float64 V911_1_tmp1; 46440 V911_1_tmp1 = 1.0 / V601_i; 46441 npy_float64 V911_1_tmp2; 46442 V911_1_tmp2 = log(V911_1_tmp1); 46443 V911_tmp2 = V7_i + V911_1_tmp2; 46444 } 46445 46446 npy_float64 V911_tmp3; 46447 { 46448 npy_float64 V911_2_tmp1; 46449 V911_2_tmp1 = 1.0 / V597_i; 46450 npy_float64 V911_2_tmp2; 46451 V911_2_tmp2 = log(V911_2_tmp1); 46452 V911_tmp3 = V7_i + V911_2_tmp2; 46453 } 46454 46455 npy_float64 V911_tmp4; 46456 { 46457 npy_float64 V911_3_tmp1; 46458 V911_3_tmp1 = 1.0 / V593_i; 46459 npy_float64 V911_3_tmp2; 46460 V911_3_tmp2 = log(V911_3_tmp1); 46461 V911_tmp4 = V7_i + V911_3_tmp2; 46462 } 46463 46464 npy_float64 V911_tmp5; 46465 { 46466 npy_float64 V911_4_tmp1; 46467 V911_4_tmp1 = 1.0 / V589_i; 46468 npy_float64 V911_4_tmp2; 46469 V911_4_tmp2 = log(V911_4_tmp1); 46470 V911_tmp5 = V7_i + V911_4_tmp2; 46471 } 46472 46473 npy_float64 V911_tmp6; 46474 { 46475 npy_float64 V911_5_tmp1; 46476 V911_5_tmp1 = 1.0 / V585_i; 46477 npy_float64 V911_5_tmp2; 46478 V911_5_tmp2 = log(V911_5_tmp1); 46479 V911_tmp6 = V7_i + V911_5_tmp2; 46480 } 46481 46482 npy_float64 V911_tmp7; 46483 { 46484 npy_float64 V911_6_tmp1; 46485 V911_6_tmp1 = 1.0 / V581_i; 46486 npy_float64 V911_6_tmp2; 46487 V911_6_tmp2 = log(V911_6_tmp1); 46488 V911_tmp7 = V7_i + V911_6_tmp2; 46489 } 46490 46491 npy_float64 V911_tmp8; 46492 { 46493 npy_float64 V911_7_tmp1; 46494 V911_7_tmp1 = 1.0 / V577_i; 46495 npy_float64 V911_7_tmp2; 46496 V911_7_tmp2 = log(V911_7_tmp1); 46497 V911_tmp8 = V7_i + V911_7_tmp2; 46498 } 46499 46500 npy_float64 V911_tmp9; 46501 { 46502 npy_float64 V911_8_tmp1; 46503 V911_8_tmp1 = 1.0 / V573_i; 46504 npy_float64 V911_8_tmp2; 46505 V911_8_tmp2 = log(V911_8_tmp1); 46506 V911_tmp9 = V7_i + V911_8_tmp2; 46507 } 46508 46509 npy_float64 V911_tmp10; 46510 { 46511 npy_float64 V911_9_tmp1; 46512 V911_9_tmp1 = 1.0 / V569_i; 46513 npy_float64 V911_9_tmp2; 46514 V911_9_tmp2 = log(V911_9_tmp1); 46515 V911_tmp10 = V7_i + V911_9_tmp2; 46516 } 46517 46518 npy_float64 V911_tmp11; 46519 { 46520 npy_float64 V911_10_tmp1; 46521 V911_10_tmp1 = 1.0 / V565_i; 46522 npy_float64 V911_10_tmp2; 46523 V911_10_tmp2 = log(V911_10_tmp1); 46524 V911_tmp11 = V7_i + V911_10_tmp2; 46525 } 46526 46527 npy_float64 V911_tmp12; 46528 { 46529 npy_float64 V911_11_tmp1; 46530 V911_11_tmp1 = 1.0 / V561_i; 46531 npy_float64 V911_11_tmp2; 46532 V911_11_tmp2 = log(V911_11_tmp1); 46533 V911_tmp12 = V7_i + V911_11_tmp2; 46534 } 46535 46536 npy_float64 V911_tmp13; 46537 { 46538 npy_float64 V911_12_tmp1; 46539 V911_12_tmp1 = 1.0 / V557_i; 46540 npy_float64 V911_12_tmp2; 46541 V911_12_tmp2 = log(V911_12_tmp1); 46542 V911_tmp13 = V7_i + V911_12_tmp2; 46543 } 46544 46545 npy_float64 V911_tmp14; 46546 { 46547 npy_float64 V911_13_tmp1; 46548 V911_13_tmp1 = 1.0 / V553_i; 46549 npy_float64 V911_13_tmp2; 46550 V911_13_tmp2 = log(V911_13_tmp1); 46551 V911_tmp14 = V7_i + V911_13_tmp2; 46552 } 46553 46554 npy_float64 V911_tmp15; 46555 { 46556 npy_float64 V911_14_tmp1; 46557 V911_14_tmp1 = 1.0 / V549_i; 46558 npy_float64 V911_14_tmp2; 46559 V911_14_tmp2 = log(V911_14_tmp1); 46560 V911_tmp15 = V7_i + V911_14_tmp2; 46561 } 46562 46563 npy_float64 V911_tmp16; 46564 { 46565 npy_float64 V911_15_tmp1; 46566 V911_15_tmp1 = 1.0 / V545_i; 46567 npy_float64 V911_15_tmp2; 46568 V911_15_tmp2 = log(V911_15_tmp1); 46569 V911_tmp16 = V7_i + V911_15_tmp2; 46570 } 46571 46572 npy_float64 V911_tmp17; 46573 { 46574 npy_float64 V911_16_tmp1; 46575 V911_16_tmp1 = 1.0 / V541_i; 46576 npy_float64 V911_16_tmp2; 46577 V911_16_tmp2 = log(V911_16_tmp1); 46578 V911_tmp17 = V7_i + V911_16_tmp2; 46579 } 46580 46581 npy_float64 V911_tmp18; 46582 { 46583 npy_float64 V911_17_tmp1; 46584 V911_17_tmp1 = 1.0 / V537_i; 46585 npy_float64 V911_17_tmp2; 46586 V911_17_tmp2 = log(V911_17_tmp1); 46587 V911_tmp18 = V7_i + V911_17_tmp2; 46588 } 46589 46590 npy_float64 V911_tmp19; 46591 { 46592 npy_float64 V911_18_tmp1; 46593 V911_18_tmp1 = 1.0 / V533_i; 46594 npy_float64 V911_18_tmp2; 46595 V911_18_tmp2 = log(V911_18_tmp1); 46596 V911_tmp19 = V7_i + V911_18_tmp2; 46597 } 46598 46599 npy_float64 V911_tmp20; 46600 { 46601 npy_float64 V911_19_tmp1; 46602 V911_19_tmp1 = 1.0 / V529_i; 46603 npy_float64 V911_19_tmp2; 46604 V911_19_tmp2 = log(V911_19_tmp1); 46605 V911_tmp20 = V7_i + V911_19_tmp2; 46606 } 46607 46608 npy_float64 V911_tmp21; 46609 { 46610 npy_float64 V911_20_tmp1; 46611 V911_20_tmp1 = 1.0 / V525_i; 46612 npy_float64 V911_20_tmp2; 46613 V911_20_tmp2 = log(V911_20_tmp1); 46614 V911_tmp21 = V7_i + V911_20_tmp2; 46615 } 46616 46617 npy_float64 V911_tmp22; 46618 { 46619 npy_float64 V911_21_tmp1; 46620 V911_21_tmp1 = 1.0 / V521_i; 46621 npy_float64 V911_21_tmp2; 46622 V911_21_tmp2 = log(V911_21_tmp1); 46623 V911_tmp22 = V7_i + V911_21_tmp2; 46624 } 46625 46626 npy_float64 V911_tmp23; 46627 { 46628 npy_float64 V911_22_tmp1; 46629 V911_22_tmp1 = 1.0 / V517_i; 46630 npy_float64 V911_22_tmp2; 46631 V911_22_tmp2 = log(V911_22_tmp1); 46632 V911_tmp23 = V7_i + V911_22_tmp2; 46633 } 46634 46635 npy_float64 V911_tmp24; 46636 { 46637 npy_float64 V911_23_tmp1; 46638 V911_23_tmp1 = 1.0 / V513_i; 46639 npy_float64 V911_23_tmp2; 46640 V911_23_tmp2 = log(V911_23_tmp1); 46641 V911_tmp24 = V7_i + V911_23_tmp2; 46642 } 46643 46644 npy_float64 V911_tmp25; 46645 { 46646 npy_float64 V911_24_tmp1; 46647 V911_24_tmp1 = 1.0 / V509_i; 46648 npy_float64 V911_24_tmp2; 46649 V911_24_tmp2 = log(V911_24_tmp1); 46650 V911_tmp25 = V7_i + V911_24_tmp2; 46651 } 46652 46653 npy_float64 V911_tmp26; 46654 { 46655 npy_float64 V911_25_tmp1; 46656 V911_25_tmp1 = 1.0 / V505_i; 46657 npy_float64 V911_25_tmp2; 46658 V911_25_tmp2 = log(V911_25_tmp1); 46659 V911_tmp26 = V7_i + V911_25_tmp2; 46660 } 46661 46662 npy_float64 V911_tmp27; 46663 { 46664 npy_float64 V911_26_tmp1; 46665 V911_26_tmp1 = 1.0 / V501_i; 46666 npy_float64 V911_26_tmp2; 46667 V911_26_tmp2 = log(V911_26_tmp1); 46668 V911_tmp27 = V7_i + V911_26_tmp2; 46669 } 46670 46671 npy_float64 V911_tmp28; 46672 { 46673 npy_float64 V911_27_tmp1; 46674 V911_27_tmp1 = 1.0 / V497_i; 46675 npy_float64 V911_27_tmp2; 46676 V911_27_tmp2 = log(V911_27_tmp1); 46677 V911_tmp28 = V7_i + V911_27_tmp2; 46678 } 46679 46680 npy_float64 V911_tmp29; 46681 { 46682 npy_float64 V911_28_tmp1; 46683 V911_28_tmp1 = 1.0 / V493_i; 46684 npy_float64 V911_28_tmp2; 46685 V911_28_tmp2 = log(V911_28_tmp1); 46686 V911_tmp29 = V7_i + V911_28_tmp2; 46687 } 46688 46689 npy_float64 V911_tmp30; 46690 { 46691 npy_float64 V911_29_tmp1; 46692 V911_29_tmp1 = 1.0 / V489_i; 46693 npy_float64 V911_29_tmp2; 46694 V911_29_tmp2 = log(V911_29_tmp1); 46695 V911_tmp30 = V7_i + V911_29_tmp2; 46696 } 46697 46698 npy_float64 V911_tmp31; 46699 { 46700 npy_float64 V911_30_tmp1; 46701 V911_30_tmp1 = 1.0 / V485_i; 46702 npy_float64 V911_30_tmp2; 46703 V911_30_tmp2 = log(V911_30_tmp1); 46704 V911_tmp31 = V7_i + V911_30_tmp2; 46705 } 46706 46707 npy_float64 V911_tmp32; 46708 { 46709 npy_float64 V911_31_tmp1; 46710 V911_31_tmp1 = 1.0 / V481_i; 46711 npy_float64 V911_31_tmp2; 46712 V911_31_tmp2 = log(V911_31_tmp1); 46713 V911_tmp32 = V7_i + V911_31_tmp2; 46714 } 46715 46716 npy_float64 V911_tmp33; 46717 { 46718 npy_float64 V911_32_tmp1; 46719 V911_32_tmp1 = 1.0 / V477_i; 46720 npy_float64 V911_32_tmp2; 46721 V911_32_tmp2 = log(V911_32_tmp1); 46722 V911_tmp33 = V7_i + V911_32_tmp2; 46723 } 46724 46725 npy_float64 V911_tmp34; 46726 { 46727 npy_float64 V911_33_tmp1; 46728 V911_33_tmp1 = 1.0 / V473_i; 46729 npy_float64 V911_33_tmp2; 46730 V911_33_tmp2 = log(V911_33_tmp1); 46731 V911_tmp34 = V7_i + V911_33_tmp2; 46732 } 46733 46734 npy_float64 V911_tmp35; 46735 { 46736 npy_float64 V911_34_tmp1; 46737 V911_34_tmp1 = 1.0 / V469_i; 46738 npy_float64 V911_34_tmp2; 46739 V911_34_tmp2 = log(V911_34_tmp1); 46740 V911_tmp35 = V7_i + V911_34_tmp2; 46741 } 46742 46743 npy_float64 V911_tmp36; 46744 { 46745 npy_float64 V911_35_tmp1; 46746 V911_35_tmp1 = 1.0 / V465_i; 46747 npy_float64 V911_35_tmp2; 46748 V911_35_tmp2 = log(V911_35_tmp1); 46749 V911_tmp36 = V7_i + V911_35_tmp2; 46750 } 46751 46752 npy_float64 V911_tmp37; 46753 { 46754 npy_float64 V911_36_tmp1; 46755 V911_36_tmp1 = 1.0 / V461_i; 46756 npy_float64 V911_36_tmp2; 46757 V911_36_tmp2 = log(V911_36_tmp1); 46758 V911_tmp37 = V7_i + V911_36_tmp2; 46759 } 46760 46761 npy_float64 V911_tmp38; 46762 { 46763 npy_float64 V911_37_tmp1; 46764 V911_37_tmp1 = 1.0 / V457_i; 46765 npy_float64 V911_37_tmp2; 46766 V911_37_tmp2 = log(V911_37_tmp1); 46767 V911_tmp38 = V7_i + V911_37_tmp2; 46768 } 46769 46770 npy_float64 V911_tmp39; 46771 { 46772 npy_float64 V911_38_tmp1; 46773 V911_38_tmp1 = 1.0 / V453_i; 46774 npy_float64 V911_38_tmp2; 46775 V911_38_tmp2 = log(V911_38_tmp1); 46776 V911_tmp39 = V7_i + V911_38_tmp2; 46777 } 46778 46779 npy_float64 V911_tmp40; 46780 { 46781 npy_float64 V911_39_tmp1; 46782 V911_39_tmp1 = 1.0 / V449_i; 46783 npy_float64 V911_39_tmp2; 46784 V911_39_tmp2 = log(V911_39_tmp1); 46785 V911_tmp40 = V7_i + V911_39_tmp2; 46786 } 46787 46788 npy_float64 V911_tmp41; 46789 { 46790 npy_float64 V911_40_tmp1; 46791 V911_40_tmp1 = 1.0 / V445_i; 46792 npy_float64 V911_40_tmp2; 46793 V911_40_tmp2 = log(V911_40_tmp1); 46794 V911_tmp41 = V7_i + V911_40_tmp2; 46795 } 46796 46797 npy_float64 V911_tmp42; 46798 { 46799 npy_float64 V911_41_tmp1; 46800 V911_41_tmp1 = 1.0 / V441_i; 46801 npy_float64 V911_41_tmp2; 46802 V911_41_tmp2 = log(V911_41_tmp1); 46803 V911_tmp42 = V7_i + V911_41_tmp2; 46804 } 46805 46806 npy_float64 V911_tmp43; 46807 { 46808 npy_float64 V911_42_tmp1; 46809 V911_42_tmp1 = 1.0 / V437_i; 46810 npy_float64 V911_42_tmp2; 46811 V911_42_tmp2 = log(V911_42_tmp1); 46812 V911_tmp43 = V7_i + V911_42_tmp2; 46813 } 46814 46815 npy_float64 V911_tmp44; 46816 { 46817 npy_float64 V911_43_tmp1; 46818 V911_43_tmp1 = 1.0 / V433_i; 46819 npy_float64 V911_43_tmp2; 46820 V911_43_tmp2 = log(V911_43_tmp1); 46821 V911_tmp44 = V7_i + V911_43_tmp2; 46822 } 46823 46824 npy_float64 V911_tmp45; 46825 { 46826 npy_float64 V911_44_tmp1; 46827 V911_44_tmp1 = 1.0 / V429_i; 46828 npy_float64 V911_44_tmp2; 46829 V911_44_tmp2 = log(V911_44_tmp1); 46830 V911_tmp45 = V7_i + V911_44_tmp2; 46831 } 46832 46833 npy_float64 V911_tmp46; 46834 { 46835 npy_float64 V911_45_tmp1; 46836 V911_45_tmp1 = 1.0 / V425_i; 46837 npy_float64 V911_45_tmp2; 46838 V911_45_tmp2 = log(V911_45_tmp1); 46839 V911_tmp46 = V7_i + V911_45_tmp2; 46840 } 46841 46842 npy_float64 V911_tmp47; 46843 { 46844 npy_float64 V911_46_tmp1; 46845 V911_46_tmp1 = 1.0 / V421_i; 46846 npy_float64 V911_46_tmp2; 46847 V911_46_tmp2 = log(V911_46_tmp1); 46848 V911_tmp47 = V7_i + V911_46_tmp2; 46849 } 46850 46851 npy_float64 V911_tmp48; 46852 { 46853 npy_float64 V911_47_tmp1; 46854 V911_47_tmp1 = 1.0 / V417_i; 46855 npy_float64 V911_47_tmp2; 46856 V911_47_tmp2 = log(V911_47_tmp1); 46857 V911_tmp48 = V7_i + V911_47_tmp2; 46858 } 46859 46860 npy_float64 V911_tmp49; 46861 { 46862 npy_float64 V911_48_tmp1; 46863 V911_48_tmp1 = 1.0 / V413_i; 46864 npy_float64 V911_48_tmp2; 46865 V911_48_tmp2 = log(V911_48_tmp1); 46866 V911_tmp49 = V7_i + V911_48_tmp2; 46867 } 46868 46869 npy_float64 V911_tmp50; 46870 { 46871 npy_float64 V911_49_tmp1; 46872 V911_49_tmp1 = 1.0 / V409_i; 46873 npy_float64 V911_49_tmp2; 46874 V911_49_tmp2 = log(V911_49_tmp1); 46875 V911_tmp50 = V7_i + V911_49_tmp2; 46876 } 46877 46878 npy_float64 V911_tmp51; 46879 { 46880 npy_float64 V911_50_tmp1; 46881 V911_50_tmp1 = 1.0 / V405_i; 46882 npy_float64 V911_50_tmp2; 46883 V911_50_tmp2 = log(V911_50_tmp1); 46884 V911_tmp51 = V7_i + V911_50_tmp2; 46885 } 46886 46887 npy_float64 V911_tmp52; 46888 { 46889 npy_float64 V911_51_tmp1; 46890 V911_51_tmp1 = 1.0 / V401_i; 46891 npy_float64 V911_51_tmp2; 46892 V911_51_tmp2 = log(V911_51_tmp1); 46893 V911_tmp52 = V7_i + V911_51_tmp2; 46894 } 46895 46896 npy_float64 V911_tmp53; 46897 { 46898 npy_float64 V911_52_tmp1; 46899 V911_52_tmp1 = 1.0 / V397_i; 46900 npy_float64 V911_52_tmp2; 46901 V911_52_tmp2 = log(V911_52_tmp1); 46902 V911_tmp53 = V7_i + V911_52_tmp2; 46903 } 46904 46905 npy_float64 V911_tmp54; 46906 { 46907 npy_float64 V911_53_tmp1; 46908 V911_53_tmp1 = 1.0 / V393_i; 46909 npy_float64 V911_53_tmp2; 46910 V911_53_tmp2 = log(V911_53_tmp1); 46911 V911_tmp54 = V7_i + V911_53_tmp2; 46912 } 46913 46914 npy_float64 V911_tmp55; 46915 { 46916 npy_float64 V911_54_tmp1; 46917 V911_54_tmp1 = 1.0 / V389_i; 46918 npy_float64 V911_54_tmp2; 46919 V911_54_tmp2 = log(V911_54_tmp1); 46920 V911_tmp55 = V7_i + V911_54_tmp2; 46921 } 46922 46923 npy_float64 V911_tmp56; 46924 { 46925 npy_float64 V911_55_tmp1; 46926 V911_55_tmp1 = 1.0 / V385_i; 46927 npy_float64 V911_55_tmp2; 46928 V911_55_tmp2 = log(V911_55_tmp1); 46929 V911_tmp56 = V7_i + V911_55_tmp2; 46930 } 46931 46932 npy_float64 V911_tmp57; 46933 { 46934 npy_float64 V911_56_tmp1; 46935 V911_56_tmp1 = 1.0 / V381_i; 46936 npy_float64 V911_56_tmp2; 46937 V911_56_tmp2 = log(V911_56_tmp1); 46938 V911_tmp57 = V7_i + V911_56_tmp2; 46939 } 46940 46941 npy_float64 V911_tmp58; 46942 { 46943 npy_float64 V911_57_tmp1; 46944 V911_57_tmp1 = 1.0 / V377_i; 46945 npy_float64 V911_57_tmp2; 46946 V911_57_tmp2 = log(V911_57_tmp1); 46947 V911_tmp58 = V7_i + V911_57_tmp2; 46948 } 46949 46950 npy_float64 V911_tmp59; 46951 { 46952 npy_float64 V911_58_tmp1; 46953 V911_58_tmp1 = 1.0 / V373_i; 46954 npy_float64 V911_58_tmp2; 46955 V911_58_tmp2 = log(V911_58_tmp1); 46956 V911_tmp59 = V7_i + V911_58_tmp2; 46957 } 46958 46959 npy_float64 V911_tmp60; 46960 { 46961 npy_float64 V911_59_tmp1; 46962 V911_59_tmp1 = 1.0 / V369_i; 46963 npy_float64 V911_59_tmp2; 46964 V911_59_tmp2 = log(V911_59_tmp1); 46965 V911_tmp60 = V7_i + V911_59_tmp2; 46966 } 46967 46968 npy_float64 V911_tmp61; 46969 { 46970 npy_float64 V911_60_tmp1; 46971 V911_60_tmp1 = 1.0 / V365_i; 46972 npy_float64 V911_60_tmp2; 46973 V911_60_tmp2 = log(V911_60_tmp1); 46974 V911_tmp61 = V7_i + V911_60_tmp2; 46975 } 46976 46977 npy_float64 V911_tmp62; 46978 { 46979 npy_float64 V911_61_tmp1; 46980 V911_61_tmp1 = 1.0 / V361_i; 46981 npy_float64 V911_61_tmp2; 46982 V911_61_tmp2 = log(V911_61_tmp1); 46983 V911_tmp62 = V7_i + V911_61_tmp2; 46984 } 46985 46986 npy_float64 V911_tmp63; 46987 { 46988 npy_float64 V911_62_tmp1; 46989 V911_62_tmp1 = 1.0 / V357_i; 46990 npy_float64 V911_62_tmp2; 46991 V911_62_tmp2 = log(V911_62_tmp1); 46992 V911_tmp63 = V7_i + V911_62_tmp2; 46993 } 46994 46995 npy_float64 V911_tmp64; 46996 { 46997 npy_float64 V911_63_tmp1; 46998 V911_63_tmp1 = 1.0 / V353_i; 46999 npy_float64 V911_63_tmp2; 47000 V911_63_tmp2 = log(V911_63_tmp1); 47001 V911_tmp64 = V7_i + V911_63_tmp2; 47002 } 47003 47004 npy_float64 V911_tmp65; 47005 { 47006 npy_float64 V911_64_tmp1; 47007 V911_64_tmp1 = 1.0 / V349_i; 47008 npy_float64 V911_64_tmp2; 47009 V911_64_tmp2 = log(V911_64_tmp1); 47010 V911_tmp65 = V7_i + V911_64_tmp2; 47011 } 47012 47013 npy_float64 V911_tmp66; 47014 { 47015 npy_float64 V911_65_tmp1; 47016 V911_65_tmp1 = 1.0 / V345_i; 47017 npy_float64 V911_65_tmp2; 47018 V911_65_tmp2 = log(V911_65_tmp1); 47019 V911_tmp66 = V7_i + V911_65_tmp2; 47020 } 47021 47022 npy_float64 V911_tmp67; 47023 { 47024 npy_float64 V911_66_tmp1; 47025 V911_66_tmp1 = 1.0 / V341_i; 47026 npy_float64 V911_66_tmp2; 47027 V911_66_tmp2 = log(V911_66_tmp1); 47028 V911_tmp67 = V7_i + V911_66_tmp2; 47029 } 47030 47031 npy_float64 V911_tmp68; 47032 { 47033 npy_float64 V911_67_tmp1; 47034 V911_67_tmp1 = 1.0 / V337_i; 47035 npy_float64 V911_67_tmp2; 47036 V911_67_tmp2 = log(V911_67_tmp1); 47037 V911_tmp68 = V7_i + V911_67_tmp2; 47038 } 47039 47040 npy_float64 V911_tmp69; 47041 { 47042 npy_float64 V911_68_tmp1; 47043 V911_68_tmp1 = 1.0 / V333_i; 47044 npy_float64 V911_68_tmp2; 47045 V911_68_tmp2 = log(V911_68_tmp1); 47046 V911_tmp69 = V7_i + V911_68_tmp2; 47047 } 47048 47049 npy_float64 V911_tmp70; 47050 { 47051 npy_float64 V911_69_tmp1; 47052 V911_69_tmp1 = 1.0 / V329_i; 47053 npy_float64 V911_69_tmp2; 47054 V911_69_tmp2 = log(V911_69_tmp1); 47055 V911_tmp70 = V7_i + V911_69_tmp2; 47056 } 47057 47058 npy_float64 V911_tmp71; 47059 { 47060 npy_float64 V911_70_tmp1; 47061 V911_70_tmp1 = 1.0 / V325_i; 47062 npy_float64 V911_70_tmp2; 47063 V911_70_tmp2 = log(V911_70_tmp1); 47064 V911_tmp71 = V7_i + V911_70_tmp2; 47065 } 47066 47067 npy_float64 V911_tmp72; 47068 { 47069 npy_float64 V911_71_tmp1; 47070 V911_71_tmp1 = 1.0 / V321_i; 47071 npy_float64 V911_71_tmp2; 47072 V911_71_tmp2 = log(V911_71_tmp1); 47073 V911_tmp72 = V7_i + V911_71_tmp2; 47074 } 47075 47076 npy_float64 V911_tmp73; 47077 { 47078 npy_float64 V911_72_tmp1; 47079 V911_72_tmp1 = 1.0 / V317_i; 47080 npy_float64 V911_72_tmp2; 47081 V911_72_tmp2 = log(V911_72_tmp1); 47082 V911_tmp73 = V7_i + V911_72_tmp2; 47083 } 47084 47085 npy_float64 V911_tmp74; 47086 { 47087 npy_float64 V911_73_tmp1; 47088 V911_73_tmp1 = 1.0 / V313_i; 47089 npy_float64 V911_73_tmp2; 47090 V911_73_tmp2 = log(V911_73_tmp1); 47091 V911_tmp74 = V7_i + V911_73_tmp2; 47092 } 47093 47094 npy_float64 V911_tmp75; 47095 { 47096 npy_float64 V911_74_tmp1; 47097 V911_74_tmp1 = 1.0 / V309_i; 47098 npy_float64 V911_74_tmp2; 47099 V911_74_tmp2 = log(V911_74_tmp1); 47100 V911_tmp75 = V7_i + V911_74_tmp2; 47101 } 47102 47103 npy_float64 V911_tmp76; 47104 { 47105 npy_float64 V911_75_tmp1; 47106 V911_75_tmp1 = 1.0 / V305_i; 47107 npy_float64 V911_75_tmp2; 47108 V911_75_tmp2 = log(V911_75_tmp1); 47109 V911_tmp76 = V7_i + V911_75_tmp2; 47110 } 47111 47112 npy_float64 V911_tmp77; 47113 { 47114 npy_float64 V911_76_tmp1; 47115 V911_76_tmp1 = 1.0 / V301_i; 47116 npy_float64 V911_76_tmp2; 47117 V911_76_tmp2 = log(V911_76_tmp1); 47118 V911_tmp77 = V7_i + V911_76_tmp2; 47119 } 47120 47121 npy_float64 V911_tmp78; 47122 { 47123 npy_float64 V911_77_tmp1; 47124 V911_77_tmp1 = 1.0 / V297_i; 47125 npy_float64 V911_77_tmp2; 47126 V911_77_tmp2 = log(V911_77_tmp1); 47127 V911_tmp78 = V7_i + V911_77_tmp2; 47128 } 47129 47130 npy_float64 V911_tmp79; 47131 { 47132 npy_float64 V911_78_tmp1; 47133 V911_78_tmp1 = 1.0 / V293_i; 47134 npy_float64 V911_78_tmp2; 47135 V911_78_tmp2 = log(V911_78_tmp1); 47136 V911_tmp79 = V7_i + V911_78_tmp2; 47137 } 47138 47139 npy_float64 V911_tmp80; 47140 { 47141 npy_float64 V911_79_tmp1; 47142 V911_79_tmp1 = 1.0 / V289_i; 47143 npy_float64 V911_79_tmp2; 47144 V911_79_tmp2 = log(V911_79_tmp1); 47145 V911_tmp80 = V7_i + V911_79_tmp2; 47146 } 47147 47148 npy_float64 V911_tmp81; 47149 { 47150 npy_float64 V911_80_tmp1; 47151 V911_80_tmp1 = 1.0 / V285_i; 47152 npy_float64 V911_80_tmp2; 47153 V911_80_tmp2 = log(V911_80_tmp1); 47154 V911_tmp81 = V7_i + V911_80_tmp2; 47155 } 47156 47157 npy_float64 V911_tmp82; 47158 { 47159 npy_float64 V911_81_tmp1; 47160 V911_81_tmp1 = 1.0 / V281_i; 47161 npy_float64 V911_81_tmp2; 47162 V911_81_tmp2 = log(V911_81_tmp1); 47163 V911_tmp82 = V7_i + V911_81_tmp2; 47164 } 47165 47166 npy_float64 V911_tmp83; 47167 { 47168 npy_float64 V911_82_tmp1; 47169 V911_82_tmp1 = 1.0 / V277_i; 47170 npy_float64 V911_82_tmp2; 47171 V911_82_tmp2 = log(V911_82_tmp1); 47172 V911_tmp83 = V7_i + V911_82_tmp2; 47173 } 47174 47175 npy_float64 V911_tmp84; 47176 { 47177 npy_float64 V911_83_tmp1; 47178 V911_83_tmp1 = 1.0 / V273_i; 47179 npy_float64 V911_83_tmp2; 47180 V911_83_tmp2 = log(V911_83_tmp1); 47181 V911_tmp84 = V7_i + V911_83_tmp2; 47182 } 47183 47184 npy_float64 V911_tmp85; 47185 { 47186 npy_float64 V911_84_tmp1; 47187 V911_84_tmp1 = 1.0 / V269_i; 47188 npy_float64 V911_84_tmp2; 47189 V911_84_tmp2 = log(V911_84_tmp1); 47190 V911_tmp85 = V7_i + V911_84_tmp2; 47191 } 47192 47193 npy_float64 V911_tmp86; 47194 { 47195 npy_float64 V911_85_tmp1; 47196 V911_85_tmp1 = 1.0 / V265_i; 47197 npy_float64 V911_85_tmp2; 47198 V911_85_tmp2 = log(V911_85_tmp1); 47199 V911_tmp86 = V7_i + V911_85_tmp2; 47200 } 47201 47202 npy_float64 V911_tmp87; 47203 { 47204 npy_float64 V911_86_tmp1; 47205 V911_86_tmp1 = 1.0 / V261_i; 47206 npy_float64 V911_86_tmp2; 47207 V911_86_tmp2 = log(V911_86_tmp1); 47208 V911_tmp87 = V7_i + V911_86_tmp2; 47209 } 47210 47211 npy_float64 V911_tmp88; 47212 { 47213 npy_float64 V911_87_tmp1; 47214 V911_87_tmp1 = 1.0 / V257_i; 47215 npy_float64 V911_87_tmp2; 47216 V911_87_tmp2 = log(V911_87_tmp1); 47217 V911_tmp88 = V7_i + V911_87_tmp2; 47218 } 47219 47220 npy_float64 V911_tmp89; 47221 { 47222 npy_float64 V911_88_tmp1; 47223 V911_88_tmp1 = 1.0 / V253_i; 47224 npy_float64 V911_88_tmp2; 47225 V911_88_tmp2 = log(V911_88_tmp1); 47226 V911_tmp89 = V7_i + V911_88_tmp2; 47227 } 47228 47229 npy_float64 V911_tmp90; 47230 { 47231 npy_float64 V911_89_tmp1; 47232 V911_89_tmp1 = 1.0 / V249_i; 47233 npy_float64 V911_89_tmp2; 47234 V911_89_tmp2 = log(V911_89_tmp1); 47235 V911_tmp90 = V7_i + V911_89_tmp2; 47236 } 47237 47238 npy_float64 V911_tmp91; 47239 { 47240 npy_float64 V911_90_tmp1; 47241 V911_90_tmp1 = 1.0 / V245_i; 47242 npy_float64 V911_90_tmp2; 47243 V911_90_tmp2 = log(V911_90_tmp1); 47244 V911_tmp91 = V7_i + V911_90_tmp2; 47245 } 47246 47247 npy_float64 V911_tmp92; 47248 { 47249 npy_float64 V911_91_tmp1; 47250 V911_91_tmp1 = 1.0 / V241_i; 47251 npy_float64 V911_91_tmp2; 47252 V911_91_tmp2 = log(V911_91_tmp1); 47253 V911_tmp92 = V7_i + V911_91_tmp2; 47254 } 47255 47256 npy_float64 V911_tmp93; 47257 { 47258 npy_float64 V911_92_tmp1; 47259 V911_92_tmp1 = 1.0 / V237_i; 47260 npy_float64 V911_92_tmp2; 47261 V911_92_tmp2 = log(V911_92_tmp1); 47262 V911_tmp93 = V7_i + V911_92_tmp2; 47263 } 47264 47265 npy_float64 V911_tmp94; 47266 { 47267 npy_float64 V911_93_tmp1; 47268 V911_93_tmp1 = 1.0 / V233_i; 47269 npy_float64 V911_93_tmp2; 47270 V911_93_tmp2 = log(V911_93_tmp1); 47271 V911_tmp94 = V7_i + V911_93_tmp2; 47272 } 47273 47274 npy_float64 V911_tmp95; 47275 { 47276 npy_float64 V911_94_tmp1; 47277 V911_94_tmp1 = 1.0 / V229_i; 47278 npy_float64 V911_94_tmp2; 47279 V911_94_tmp2 = log(V911_94_tmp1); 47280 V911_tmp95 = V7_i + V911_94_tmp2; 47281 } 47282 47283 npy_float64 V911_tmp96; 47284 { 47285 npy_float64 V911_95_tmp1; 47286 V911_95_tmp1 = 1.0 / V225_i; 47287 npy_float64 V911_95_tmp2; 47288 V911_95_tmp2 = log(V911_95_tmp1); 47289 V911_tmp96 = V7_i + V911_95_tmp2; 47290 } 47291 47292 npy_float64 V911_tmp97; 47293 { 47294 npy_float64 V911_96_tmp1; 47295 V911_96_tmp1 = 1.0 / V221_i; 47296 npy_float64 V911_96_tmp2; 47297 V911_96_tmp2 = log(V911_96_tmp1); 47298 V911_tmp97 = V7_i + V911_96_tmp2; 47299 } 47300 47301 npy_float64 V911_tmp98; 47302 { 47303 npy_float64 V911_97_tmp1; 47304 V911_97_tmp1 = 1.0 / V217_i; 47305 npy_float64 V911_97_tmp2; 47306 V911_97_tmp2 = log(V911_97_tmp1); 47307 V911_tmp98 = V7_i + V911_97_tmp2; 47308 } 47309 47310 npy_float64 V911_tmp99; 47311 { 47312 npy_float64 V911_98_tmp1; 47313 V911_98_tmp1 = 1.0 / V213_i; 47314 npy_float64 V911_98_tmp2; 47315 V911_98_tmp2 = log(V911_98_tmp1); 47316 V911_tmp99 = V7_i + V911_98_tmp2; 47317 } 47318 47319 npy_float64 V911_tmp100; 47320 { 47321 npy_float64 V911_99_tmp1; 47322 V911_99_tmp1 = 1.0 / V209_i; 47323 npy_float64 V911_99_tmp2; 47324 V911_99_tmp2 = log(V911_99_tmp1); 47325 V911_tmp100 = V7_i + V911_99_tmp2; 47326 } 47327 47328 npy_float64 V911_tmp101; 47329 { 47330 npy_float64 V911_100_tmp1; 47331 V911_100_tmp1 = 1.0 / V205_i; 47332 npy_float64 V911_100_tmp2; 47333 V911_100_tmp2 = log(V911_100_tmp1); 47334 V911_tmp101 = V7_i + V911_100_tmp2; 47335 } 47336 47337 npy_float64 V911_tmp102; 47338 { 47339 npy_float64 V911_101_tmp1; 47340 V911_101_tmp1 = 1.0 / V201_i; 47341 npy_float64 V911_101_tmp2; 47342 V911_101_tmp2 = log(V911_101_tmp1); 47343 V911_tmp102 = V7_i + V911_101_tmp2; 47344 } 47345 47346 npy_float64 V911_tmp103; 47347 { 47348 npy_float64 V911_102_tmp1; 47349 V911_102_tmp1 = 1.0 / V197_i; 47350 npy_float64 V911_102_tmp2; 47351 V911_102_tmp2 = log(V911_102_tmp1); 47352 V911_tmp103 = V7_i + V911_102_tmp2; 47353 } 47354 47355 npy_float64 V911_tmp104; 47356 { 47357 npy_float64 V911_103_tmp1; 47358 V911_103_tmp1 = 1.0 / V193_i; 47359 npy_float64 V911_103_tmp2; 47360 V911_103_tmp2 = log(V911_103_tmp1); 47361 V911_tmp104 = V7_i + V911_103_tmp2; 47362 } 47363 47364 npy_float64 V911_tmp105; 47365 { 47366 npy_float64 V911_104_tmp1; 47367 V911_104_tmp1 = 1.0 / V189_i; 47368 npy_float64 V911_104_tmp2; 47369 V911_104_tmp2 = log(V911_104_tmp1); 47370 V911_tmp105 = V7_i + V911_104_tmp2; 47371 } 47372 47373 npy_float64 V911_tmp106; 47374 { 47375 npy_float64 V911_105_tmp1; 47376 V911_105_tmp1 = 1.0 / V185_i; 47377 npy_float64 V911_105_tmp2; 47378 V911_105_tmp2 = log(V911_105_tmp1); 47379 V911_tmp106 = V7_i + V911_105_tmp2; 47380 } 47381 47382 npy_float64 V911_tmp107; 47383 { 47384 npy_float64 V911_106_tmp1; 47385 V911_106_tmp1 = 1.0 / V181_i; 47386 npy_float64 V911_106_tmp2; 47387 V911_106_tmp2 = log(V911_106_tmp1); 47388 V911_tmp107 = V7_i + V911_106_tmp2; 47389 } 47390 47391 npy_float64 V911_tmp108; 47392 { 47393 npy_float64 V911_107_tmp1; 47394 V911_107_tmp1 = 1.0 / V177_i; 47395 npy_float64 V911_107_tmp2; 47396 V911_107_tmp2 = log(V911_107_tmp1); 47397 V911_tmp108 = V7_i + V911_107_tmp2; 47398 } 47399 47400 npy_float64 V911_tmp109; 47401 { 47402 npy_float64 V911_108_tmp1; 47403 V911_108_tmp1 = 1.0 / V173_i; 47404 npy_float64 V911_108_tmp2; 47405 V911_108_tmp2 = log(V911_108_tmp1); 47406 V911_tmp109 = V7_i + V911_108_tmp2; 47407 } 47408 47409 npy_float64 V911_tmp110; 47410 { 47411 npy_float64 V911_109_tmp1; 47412 V911_109_tmp1 = 1.0 / V169_i; 47413 npy_float64 V911_109_tmp2; 47414 V911_109_tmp2 = log(V911_109_tmp1); 47415 V911_tmp110 = V7_i + V911_109_tmp2; 47416 } 47417 47418 npy_float64 V911_tmp111; 47419 { 47420 npy_float64 V911_110_tmp1; 47421 V911_110_tmp1 = 1.0 / V165_i; 47422 npy_float64 V911_110_tmp2; 47423 V911_110_tmp2 = log(V911_110_tmp1); 47424 V911_tmp111 = V7_i + V911_110_tmp2; 47425 } 47426 47427 npy_float64 V911_tmp112; 47428 { 47429 npy_float64 V911_111_tmp1; 47430 V911_111_tmp1 = 1.0 / V161_i; 47431 npy_float64 V911_111_tmp2; 47432 V911_111_tmp2 = log(V911_111_tmp1); 47433 V911_tmp112 = V7_i + V911_111_tmp2; 47434 } 47435 47436 npy_float64 V911_tmp113; 47437 { 47438 npy_float64 V911_112_tmp1; 47439 V911_112_tmp1 = 1.0 / V157_i; 47440 npy_float64 V911_112_tmp2; 47441 V911_112_tmp2 = log(V911_112_tmp1); 47442 V911_tmp113 = V7_i + V911_112_tmp2; 47443 } 47444 47445 npy_float64 V911_tmp114; 47446 { 47447 npy_float64 V911_113_tmp1; 47448 V911_113_tmp1 = 1.0 / V153_i; 47449 npy_float64 V911_113_tmp2; 47450 V911_113_tmp2 = log(V911_113_tmp1); 47451 V911_tmp114 = V7_i + V911_113_tmp2; 47452 } 47453 47454 npy_float64 V911_tmp115; 47455 { 47456 npy_float64 V911_114_tmp1; 47457 V911_114_tmp1 = 1.0 / V149_i; 47458 npy_float64 V911_114_tmp2; 47459 V911_114_tmp2 = log(V911_114_tmp1); 47460 V911_tmp115 = V7_i + V911_114_tmp2; 47461 } 47462 47463 npy_float64 V911_tmp116; 47464 { 47465 npy_float64 V911_115_tmp1; 47466 V911_115_tmp1 = 1.0 / V145_i; 47467 npy_float64 V911_115_tmp2; 47468 V911_115_tmp2 = log(V911_115_tmp1); 47469 V911_tmp116 = V7_i + V911_115_tmp2; 47470 } 47471 47472 npy_float64 V911_tmp117; 47473 { 47474 npy_float64 V911_116_tmp1; 47475 V911_116_tmp1 = 1.0 / V141_i; 47476 npy_float64 V911_116_tmp2; 47477 V911_116_tmp2 = log(V911_116_tmp1); 47478 V911_tmp117 = V7_i + V911_116_tmp2; 47479 } 47480 47481 npy_float64 V911_tmp118; 47482 { 47483 npy_float64 V911_117_tmp1; 47484 V911_117_tmp1 = 1.0 / V137_i; 47485 npy_float64 V911_117_tmp2; 47486 V911_117_tmp2 = log(V911_117_tmp1); 47487 V911_tmp118 = V7_i + V911_117_tmp2; 47488 } 47489 47490 npy_float64 V911_tmp119; 47491 { 47492 npy_float64 V911_118_tmp1; 47493 V911_118_tmp1 = 1.0 / V133_i; 47494 npy_float64 V911_118_tmp2; 47495 V911_118_tmp2 = log(V911_118_tmp1); 47496 V911_tmp119 = V7_i + V911_118_tmp2; 47497 } 47498 47499 npy_float64 V911_tmp120; 47500 { 47501 npy_float64 V911_119_tmp1; 47502 V911_119_tmp1 = 1.0 / V129_i; 47503 npy_float64 V911_119_tmp2; 47504 V911_119_tmp2 = log(V911_119_tmp1); 47505 V911_tmp120 = V7_i + V911_119_tmp2; 47506 } 47507 47508 npy_float64 V911_tmp121; 47509 { 47510 npy_float64 V911_120_tmp1; 47511 V911_120_tmp1 = 1.0 / V125_i; 47512 npy_float64 V911_120_tmp2; 47513 V911_120_tmp2 = log(V911_120_tmp1); 47514 V911_tmp121 = V7_i + V911_120_tmp2; 47515 } 47516 47517 npy_float64 V911_tmp122; 47518 { 47519 npy_float64 V911_121_tmp1; 47520 V911_121_tmp1 = 1.0 / V121_i; 47521 npy_float64 V911_121_tmp2; 47522 V911_121_tmp2 = log(V911_121_tmp1); 47523 V911_tmp122 = V7_i + V911_121_tmp2; 47524 } 47525 47526 npy_float64 V911_tmp123; 47527 { 47528 npy_float64 V911_122_tmp1; 47529 V911_122_tmp1 = 1.0 / V117_i; 47530 npy_float64 V911_122_tmp2; 47531 V911_122_tmp2 = log(V911_122_tmp1); 47532 V911_tmp123 = V7_i + V911_122_tmp2; 47533 } 47534 47535 npy_float64 V911_tmp124; 47536 { 47537 npy_float64 V911_123_tmp1; 47538 V911_123_tmp1 = 1.0 / V113_i; 47539 npy_float64 V911_123_tmp2; 47540 V911_123_tmp2 = log(V911_123_tmp1); 47541 V911_tmp124 = V7_i + V911_123_tmp2; 47542 } 47543 47544 npy_float64 V911_tmp125; 47545 { 47546 npy_float64 V911_124_tmp1; 47547 V911_124_tmp1 = 1.0 / V109_i; 47548 npy_float64 V911_124_tmp2; 47549 V911_124_tmp2 = log(V911_124_tmp1); 47550 V911_tmp125 = V7_i + V911_124_tmp2; 47551 } 47552 47553 npy_float64 V911_tmp126; 47554 { 47555 npy_float64 V911_125_tmp1; 47556 V911_125_tmp1 = 1.0 / V105_i; 47557 npy_float64 V911_125_tmp2; 47558 V911_125_tmp2 = log(V911_125_tmp1); 47559 V911_tmp126 = V7_i + V911_125_tmp2; 47560 } 47561 47562 npy_float64 V911_tmp127; 47563 { 47564 npy_float64 V911_126_tmp1; 47565 V911_126_tmp1 = 1.0 / V101_i; 47566 npy_float64 V911_126_tmp2; 47567 V911_126_tmp2 = log(V911_126_tmp1); 47568 V911_tmp127 = V7_i + V911_126_tmp2; 47569 } 47570 47571 npy_float64 V911_tmp128; 47572 { 47573 npy_float64 V911_127_tmp1; 47574 V911_127_tmp1 = 1.0 / V97_i; 47575 npy_float64 V911_127_tmp2; 47576 V911_127_tmp2 = log(V911_127_tmp1); 47577 V911_tmp128 = V7_i + V911_127_tmp2; 47578 } 47579 47580 npy_float64 V911_tmp129; 47581 { 47582 npy_float64 V911_128_tmp1; 47583 V911_128_tmp1 = 1.0 / V93_i; 47584 npy_float64 V911_128_tmp2; 47585 V911_128_tmp2 = log(V911_128_tmp1); 47586 V911_tmp129 = V7_i + V911_128_tmp2; 47587 } 47588 47589 npy_float64 V911_tmp130; 47590 { 47591 npy_float64 V911_129_tmp1; 47592 V911_129_tmp1 = 1.0 / V89_i; 47593 npy_float64 V911_129_tmp2; 47594 V911_129_tmp2 = log(V911_129_tmp1); 47595 V911_tmp130 = V7_i + V911_129_tmp2; 47596 } 47597 47598 npy_float64 V911_tmp131; 47599 { 47600 npy_float64 V911_130_tmp1; 47601 V911_130_tmp1 = 1.0 / V85_i; 47602 npy_float64 V911_130_tmp2; 47603 V911_130_tmp2 = log(V911_130_tmp1); 47604 V911_tmp131 = V7_i + V911_130_tmp2; 47605 } 47606 47607 npy_float64 V911_tmp132; 47608 { 47609 npy_float64 V911_131_tmp1; 47610 V911_131_tmp1 = 1.0 / V81_i; 47611 npy_float64 V911_131_tmp2; 47612 V911_131_tmp2 = log(V911_131_tmp1); 47613 V911_tmp132 = V7_i + V911_131_tmp2; 47614 } 47615 47616 npy_float64 V911_tmp133; 47617 { 47618 npy_float64 V911_132_tmp1; 47619 V911_132_tmp1 = 1.0 / V77_i; 47620 npy_float64 V911_132_tmp2; 47621 V911_132_tmp2 = log(V911_132_tmp1); 47622 V911_tmp133 = V7_i + V911_132_tmp2; 47623 } 47624 47625 npy_float64 V911_tmp134; 47626 { 47627 npy_float64 V911_133_tmp1; 47628 V911_133_tmp1 = 1.0 / V73_i; 47629 npy_float64 V911_133_tmp2; 47630 V911_133_tmp2 = log(V911_133_tmp1); 47631 V911_tmp134 = V7_i + V911_133_tmp2; 47632 } 47633 47634 npy_float64 V911_tmp135; 47635 { 47636 npy_float64 V911_134_tmp1; 47637 V911_134_tmp1 = 1.0 / V69_i; 47638 npy_float64 V911_134_tmp2; 47639 V911_134_tmp2 = log(V911_134_tmp1); 47640 V911_tmp135 = V7_i + V911_134_tmp2; 47641 } 47642 47643 npy_float64 V911_tmp136; 47644 { 47645 npy_float64 V911_135_tmp1; 47646 V911_135_tmp1 = 1.0 / V65_i; 47647 npy_float64 V911_135_tmp2; 47648 V911_135_tmp2 = log(V911_135_tmp1); 47649 V911_tmp136 = V7_i + V911_135_tmp2; 47650 } 47651 47652 npy_float64 V911_tmp137; 47653 { 47654 npy_float64 V911_136_tmp1; 47655 V911_136_tmp1 = 1.0 / V61_i; 47656 npy_float64 V911_136_tmp2; 47657 V911_136_tmp2 = log(V911_136_tmp1); 47658 V911_tmp137 = V7_i + V911_136_tmp2; 47659 } 47660 47661 npy_float64 V911_tmp138; 47662 { 47663 npy_float64 V911_137_tmp1; 47664 V911_137_tmp1 = 1.0 / V57_i; 47665 npy_float64 V911_137_tmp2; 47666 V911_137_tmp2 = log(V911_137_tmp1); 47667 V911_tmp138 = V7_i + V911_137_tmp2; 47668 } 47669 47670 npy_float64 V911_tmp139; 47671 { 47672 npy_float64 V911_138_tmp1; 47673 V911_138_tmp1 = 1.0 / V53_i; 47674 npy_float64 V911_138_tmp2; 47675 V911_138_tmp2 = log(V911_138_tmp1); 47676 V911_tmp139 = V7_i + V911_138_tmp2; 47677 } 47678 47679 npy_float64 V911_tmp140; 47680 { 47681 npy_float64 V911_139_tmp1; 47682 V911_139_tmp1 = 1.0 / V49_i; 47683 npy_float64 V911_139_tmp2; 47684 V911_139_tmp2 = log(V911_139_tmp1); 47685 V911_tmp140 = V7_i + V911_139_tmp2; 47686 } 47687 47688 npy_float64 V911_tmp141; 47689 { 47690 npy_float64 V911_140_tmp1; 47691 V911_140_tmp1 = 1.0 / V45_i; 47692 npy_float64 V911_140_tmp2; 47693 V911_140_tmp2 = log(V911_140_tmp1); 47694 V911_tmp141 = V7_i + V911_140_tmp2; 47695 } 47696 47697 npy_float64 V911_tmp142; 47698 { 47699 npy_float64 V911_141_tmp1; 47700 V911_141_tmp1 = 1.0 / V41_i; 47701 npy_float64 V911_141_tmp2; 47702 V911_141_tmp2 = log(V911_141_tmp1); 47703 V911_tmp142 = V7_i + V911_141_tmp2; 47704 } 47705 47706 npy_float64 V911_tmp143; 47707 { 47708 npy_float64 V911_142_tmp1; 47709 V911_142_tmp1 = 1.0 / V37_i; 47710 npy_float64 V911_142_tmp2; 47711 V911_142_tmp2 = log(V911_142_tmp1); 47712 V911_tmp143 = V7_i + V911_142_tmp2; 47713 } 47714 47715 npy_float64 V911_tmp144; 47716 { 47717 npy_float64 V911_143_tmp1; 47718 V911_143_tmp1 = 1.0 / V33_i; 47719 npy_float64 V911_143_tmp2; 47720 V911_143_tmp2 = log(V911_143_tmp1); 47721 V911_tmp144 = V7_i + V911_143_tmp2; 47722 } 47723 47724 npy_float64 V911_tmp145; 47725 { 47726 npy_float64 V911_144_tmp1; 47727 V911_144_tmp1 = 1.0 / V29_i; 47728 npy_float64 V911_144_tmp2; 47729 V911_144_tmp2 = log(V911_144_tmp1); 47730 V911_tmp145 = V7_i + V911_144_tmp2; 47731 } 47732 47733 npy_float64 V911_tmp146; 47734 { 47735 npy_float64 V911_145_tmp1; 47736 V911_145_tmp1 = 1.0 / V25_i; 47737 npy_float64 V911_145_tmp2; 47738 V911_145_tmp2 = log(V911_145_tmp1); 47739 V911_tmp146 = V7_i + V911_145_tmp2; 47740 } 47741 47742 npy_float64 V911_tmp147; 47743 { 47744 npy_float64 V911_146_tmp1; 47745 V911_146_tmp1 = 1.0 / V21_i; 47746 npy_float64 V911_146_tmp2; 47747 V911_146_tmp2 = log(V911_146_tmp1); 47748 V911_tmp147 = V7_i + V911_146_tmp2; 47749 } 47750 47751 npy_float64 V911_tmp148; 47752 { 47753 npy_float64 V911_147_tmp1; 47754 V911_147_tmp1 = 1.0 / V17_i; 47755 npy_float64 V911_147_tmp2; 47756 V911_147_tmp2 = log(V911_147_tmp1); 47757 V911_tmp148 = V7_i + V911_147_tmp2; 47758 } 47759 47760 npy_float64 V911_tmp149; 47761 { 47762 npy_float64 V911_148_tmp1; 47763 V911_148_tmp1 = 1.0 / V13_i; 47764 npy_float64 V911_148_tmp2; 47765 V911_148_tmp2 = log(V911_148_tmp1); 47766 V911_tmp149 = V7_i + V911_148_tmp2; 47767 } 47768 47769 npy_float64 V911_tmp150; 47770 { 47771 npy_float64 V911_149_tmp1; 47772 V911_149_tmp1 = 1.0 / V9_i; 47773 npy_float64 V911_149_tmp2; 47774 V911_149_tmp2 = log(V911_149_tmp1); 47775 V911_tmp150 = V7_i + V911_149_tmp2; 47776 } 47777 47778 npy_float64 V911_tmp151; 47779 V911_tmp151 = V911_tmp1 + V909_i; 47780 npy_float64 V911_tmp152; 47781 V911_tmp152 = V911_tmp1 + V607_i; 47782 npy_float64 V911_tmp153; 47783 V911_tmp153 = V911_tmp2 + V907_i; 47784 npy_float64 V911_tmp154; 47785 V911_tmp154 = V911_tmp2 + V603_i; 47786 npy_float64 V911_tmp155; 47787 V911_tmp155 = V911_tmp3 + V905_i; 47788 npy_float64 V911_tmp156; 47789 V911_tmp156 = V911_tmp3 + V599_i; 47790 npy_float64 V911_tmp157; 47791 V911_tmp157 = V911_tmp4 + V903_i; 47792 npy_float64 V911_tmp158; 47793 V911_tmp158 = V911_tmp4 + V595_i; 47794 npy_float64 V911_tmp159; 47795 V911_tmp159 = V911_tmp5 + V901_i; 47796 npy_float64 V911_tmp160; 47797 V911_tmp160 = V911_tmp5 + V591_i; 47798 npy_float64 V911_tmp161; 47799 V911_tmp161 = V911_tmp6 + V899_i; 47800 npy_float64 V911_tmp162; 47801 V911_tmp162 = V911_tmp6 + V587_i; 47802 npy_float64 V911_tmp163; 47803 V911_tmp163 = V911_tmp7 + V897_i; 47804 npy_float64 V911_tmp164; 47805 V911_tmp164 = V911_tmp7 + V583_i; 47806 npy_float64 V911_tmp165; 47807 V911_tmp165 = V911_tmp8 + V895_i; 47808 npy_float64 V911_tmp166; 47809 V911_tmp166 = V911_tmp8 + V579_i; 47810 npy_float64 V911_tmp167; 47811 V911_tmp167 = V911_tmp9 + V893_i; 47812 npy_float64 V911_tmp168; 47813 V911_tmp168 = V911_tmp9 + V575_i; 47814 npy_float64 V911_tmp169; 47815 V911_tmp169 = V911_tmp10 + V891_i; 47816 npy_float64 V911_tmp170; 47817 V911_tmp170 = V911_tmp10 + V571_i; 47818 npy_float64 V911_tmp171; 47819 V911_tmp171 = V911_tmp11 + V889_i; 47820 npy_float64 V911_tmp172; 47821 V911_tmp172 = V911_tmp11 + V567_i; 47822 npy_float64 V911_tmp173; 47823 V911_tmp173 = V911_tmp12 + V887_i; 47824 npy_float64 V911_tmp174; 47825 V911_tmp174 = V911_tmp12 + V563_i; 47826 npy_float64 V911_tmp175; 47827 V911_tmp175 = V911_tmp13 + V885_i; 47828 npy_float64 V911_tmp176; 47829 V911_tmp176 = V911_tmp13 + V559_i; 47830 npy_float64 V911_tmp177; 47831 V911_tmp177 = V911_tmp14 + V883_i; 47832 npy_float64 V911_tmp178; 47833 V911_tmp178 = V911_tmp14 + V555_i; 47834 npy_float64 V911_tmp179; 47835 V911_tmp179 = V911_tmp15 + V881_i; 47836 npy_float64 V911_tmp180; 47837 V911_tmp180 = V911_tmp15 + V551_i; 47838 npy_float64 V911_tmp181; 47839 V911_tmp181 = V911_tmp16 + V879_i; 47840 npy_float64 V911_tmp182; 47841 V911_tmp182 = V911_tmp16 + V547_i; 47842 npy_float64 V911_tmp183; 47843 V911_tmp183 = V911_tmp17 + V877_i; 47844 npy_float64 V911_tmp184; 47845 V911_tmp184 = V911_tmp17 + V543_i; 47846 npy_float64 V911_tmp185; 47847 V911_tmp185 = V911_tmp18 + V875_i; 47848 npy_float64 V911_tmp186; 47849 V911_tmp186 = V911_tmp18 + V539_i; 47850 npy_float64 V911_tmp187; 47851 V911_tmp187 = V911_tmp19 + V873_i; 47852 npy_float64 V911_tmp188; 47853 V911_tmp188 = V911_tmp19 + V535_i; 47854 npy_float64 V911_tmp189; 47855 V911_tmp189 = V911_tmp20 + V871_i; 47856 npy_float64 V911_tmp190; 47857 V911_tmp190 = V911_tmp20 + V531_i; 47858 npy_float64 V911_tmp191; 47859 V911_tmp191 = V911_tmp21 + V869_i; 47860 npy_float64 V911_tmp192; 47861 V911_tmp192 = V911_tmp21 + V527_i; 47862 npy_float64 V911_tmp193; 47863 V911_tmp193 = V911_tmp22 + V867_i; 47864 npy_float64 V911_tmp194; 47865 V911_tmp194 = V911_tmp22 + V523_i; 47866 npy_float64 V911_tmp195; 47867 V911_tmp195 = V911_tmp23 + V865_i; 47868 npy_float64 V911_tmp196; 47869 V911_tmp196 = V911_tmp23 + V519_i; 47870 npy_float64 V911_tmp197; 47871 V911_tmp197 = V911_tmp24 + V863_i; 47872 npy_float64 V911_tmp198; 47873 V911_tmp198 = V911_tmp24 + V515_i; 47874 npy_float64 V911_tmp199; 47875 V911_tmp199 = V911_tmp25 + V861_i; 47876 npy_float64 V911_tmp200; 47877 V911_tmp200 = V911_tmp25 + V511_i; 47878 npy_float64 V911_tmp201; 47879 V911_tmp201 = V911_tmp26 + V859_i; 47880 npy_float64 V911_tmp202; 47881 V911_tmp202 = V911_tmp26 + V507_i; 47882 npy_float64 V911_tmp203; 47883 V911_tmp203 = V911_tmp27 + V857_i; 47884 npy_float64 V911_tmp204; 47885 V911_tmp204 = V911_tmp27 + V503_i; 47886 npy_float64 V911_tmp205; 47887 V911_tmp205 = V911_tmp28 + V855_i; 47888 npy_float64 V911_tmp206; 47889 V911_tmp206 = V911_tmp28 + V499_i; 47890 npy_float64 V911_tmp207; 47891 V911_tmp207 = V911_tmp29 + V853_i; 47892 npy_float64 V911_tmp208; 47893 V911_tmp208 = V911_tmp29 + V495_i; 47894 npy_float64 V911_tmp209; 47895 V911_tmp209 = V911_tmp30 + V851_i; 47896 npy_float64 V911_tmp210; 47897 V911_tmp210 = V911_tmp30 + V491_i; 47898 npy_float64 V911_tmp211; 47899 V911_tmp211 = V911_tmp31 + V849_i; 47900 npy_float64 V911_tmp212; 47901 V911_tmp212 = V911_tmp31 + V487_i; 47902 npy_float64 V911_tmp213; 47903 V911_tmp213 = V911_tmp32 + V847_i; 47904 npy_float64 V911_tmp214; 47905 V911_tmp214 = V911_tmp32 + V483_i; 47906 npy_float64 V911_tmp215; 47907 V911_tmp215 = V911_tmp33 + V845_i; 47908 npy_float64 V911_tmp216; 47909 V911_tmp216 = V911_tmp33 + V479_i; 47910 npy_float64 V911_tmp217; 47911 V911_tmp217 = V911_tmp34 + V843_i; 47912 npy_float64 V911_tmp218; 47913 V911_tmp218 = V911_tmp34 + V475_i; 47914 npy_float64 V911_tmp219; 47915 V911_tmp219 = V911_tmp35 + V841_i; 47916 npy_float64 V911_tmp220; 47917 V911_tmp220 = V911_tmp35 + V471_i; 47918 npy_float64 V911_tmp221; 47919 V911_tmp221 = V911_tmp36 + V839_i; 47920 npy_float64 V911_tmp222; 47921 V911_tmp222 = V911_tmp36 + V467_i; 47922 npy_float64 V911_tmp223; 47923 V911_tmp223 = V911_tmp37 + V837_i; 47924 npy_float64 V911_tmp224; 47925 V911_tmp224 = V911_tmp37 + V463_i; 47926 npy_float64 V911_tmp225; 47927 V911_tmp225 = V911_tmp38 + V835_i; 47928 npy_float64 V911_tmp226; 47929 V911_tmp226 = V911_tmp38 + V459_i; 47930 npy_float64 V911_tmp227; 47931 V911_tmp227 = V911_tmp39 + V833_i; 47932 npy_float64 V911_tmp228; 47933 V911_tmp228 = V911_tmp39 + V455_i; 47934 npy_float64 V911_tmp229; 47935 V911_tmp229 = V911_tmp40 + V831_i; 47936 npy_float64 V911_tmp230; 47937 V911_tmp230 = V911_tmp40 + V451_i; 47938 npy_float64 V911_tmp231; 47939 V911_tmp231 = V911_tmp41 + V829_i; 47940 npy_float64 V911_tmp232; 47941 V911_tmp232 = V911_tmp41 + V447_i; 47942 npy_float64 V911_tmp233; 47943 V911_tmp233 = V911_tmp42 + V827_i; 47944 npy_float64 V911_tmp234; 47945 V911_tmp234 = V911_tmp42 + V443_i; 47946 npy_float64 V911_tmp235; 47947 V911_tmp235 = V911_tmp43 + V825_i; 47948 npy_float64 V911_tmp236; 47949 V911_tmp236 = V911_tmp43 + V439_i; 47950 npy_float64 V911_tmp237; 47951 V911_tmp237 = V911_tmp44 + V823_i; 47952 npy_float64 V911_tmp238; 47953 V911_tmp238 = V911_tmp44 + V435_i; 47954 npy_float64 V911_tmp239; 47955 V911_tmp239 = V911_tmp45 + V821_i; 47956 npy_float64 V911_tmp240; 47957 V911_tmp240 = V911_tmp45 + V431_i; 47958 npy_float64 V911_tmp241; 47959 V911_tmp241 = V911_tmp46 + V819_i; 47960 npy_float64 V911_tmp242; 47961 V911_tmp242 = V911_tmp46 + V427_i; 47962 npy_float64 V911_tmp243; 47963 V911_tmp243 = V911_tmp47 + V817_i; 47964 npy_float64 V911_tmp244; 47965 V911_tmp244 = V911_tmp47 + V423_i; 47966 npy_float64 V911_tmp245; 47967 V911_tmp245 = V911_tmp48 + V815_i; 47968 npy_float64 V911_tmp246; 47969 V911_tmp246 = V911_tmp48 + V419_i; 47970 npy_float64 V911_tmp247; 47971 V911_tmp247 = V911_tmp49 + V813_i; 47972 npy_float64 V911_tmp248; 47973 V911_tmp248 = V911_tmp49 + V415_i; 47974 npy_float64 V911_tmp249; 47975 V911_tmp249 = V911_tmp50 + V811_i; 47976 npy_float64 V911_tmp250; 47977 V911_tmp250 = V911_tmp50 + V411_i; 47978 npy_float64 V911_tmp251; 47979 V911_tmp251 = V911_tmp51 + V809_i; 47980 npy_float64 V911_tmp252; 47981 V911_tmp252 = V911_tmp51 + V407_i; 47982 npy_float64 V911_tmp253; 47983 V911_tmp253 = V911_tmp52 + V807_i; 47984 npy_float64 V911_tmp254; 47985 V911_tmp254 = V911_tmp52 + V403_i; 47986 npy_float64 V911_tmp255; 47987 V911_tmp255 = V911_tmp53 + V805_i; 47988 npy_float64 V911_tmp256; 47989 V911_tmp256 = V911_tmp53 + V399_i; 47990 npy_float64 V911_tmp257; 47991 V911_tmp257 = V911_tmp54 + V803_i; 47992 npy_float64 V911_tmp258; 47993 V911_tmp258 = V911_tmp54 + V395_i; 47994 npy_float64 V911_tmp259; 47995 V911_tmp259 = V911_tmp55 + V801_i; 47996 npy_float64 V911_tmp260; 47997 V911_tmp260 = V911_tmp55 + V391_i; 47998 npy_float64 V911_tmp261; 47999 V911_tmp261 = V911_tmp56 + V799_i; 48000 npy_float64 V911_tmp262; 48001 V911_tmp262 = V911_tmp56 + V387_i; 48002 npy_float64 V911_tmp263; 48003 V911_tmp263 = V911_tmp57 + V797_i; 48004 npy_float64 V911_tmp264; 48005 V911_tmp264 = V911_tmp57 + V383_i; 48006 npy_float64 V911_tmp265; 48007 V911_tmp265 = V911_tmp58 + V795_i; 48008 npy_float64 V911_tmp266; 48009 V911_tmp266 = V911_tmp58 + V379_i; 48010 npy_float64 V911_tmp267; 48011 V911_tmp267 = V911_tmp59 + V793_i; 48012 npy_float64 V911_tmp268; 48013 V911_tmp268 = V911_tmp59 + V375_i; 48014 npy_float64 V911_tmp269; 48015 V911_tmp269 = V911_tmp60 + V791_i; 48016 npy_float64 V911_tmp270; 48017 V911_tmp270 = V911_tmp60 + V371_i; 48018 npy_float64 V911_tmp271; 48019 V911_tmp271 = V911_tmp61 + V789_i; 48020 npy_float64 V911_tmp272; 48021 V911_tmp272 = V911_tmp61 + V367_i; 48022 npy_float64 V911_tmp273; 48023 V911_tmp273 = V911_tmp62 + V787_i; 48024 npy_float64 V911_tmp274; 48025 V911_tmp274 = V911_tmp62 + V363_i; 48026 npy_float64 V911_tmp275; 48027 V911_tmp275 = V911_tmp63 + V785_i; 48028 npy_float64 V911_tmp276; 48029 V911_tmp276 = V911_tmp63 + V359_i; 48030 npy_float64 V911_tmp277; 48031 V911_tmp277 = V911_tmp64 + V783_i; 48032 npy_float64 V911_tmp278; 48033 V911_tmp278 = V911_tmp64 + V355_i; 48034 npy_float64 V911_tmp279; 48035 V911_tmp279 = V911_tmp65 + V781_i; 48036 npy_float64 V911_tmp280; 48037 V911_tmp280 = V911_tmp65 + V351_i; 48038 npy_float64 V911_tmp281; 48039 V911_tmp281 = V911_tmp66 + V779_i; 48040 npy_float64 V911_tmp282; 48041 V911_tmp282 = V911_tmp66 + V347_i; 48042 npy_float64 V911_tmp283; 48043 V911_tmp283 = V911_tmp67 + V777_i; 48044 npy_float64 V911_tmp284; 48045 V911_tmp284 = V911_tmp67 + V343_i; 48046 npy_float64 V911_tmp285; 48047 V911_tmp285 = V911_tmp68 + V775_i; 48048 npy_float64 V911_tmp286; 48049 V911_tmp286 = V911_tmp68 + V339_i; 48050 npy_float64 V911_tmp287; 48051 V911_tmp287 = V911_tmp69 + V773_i; 48052 npy_float64 V911_tmp288; 48053 V911_tmp288 = V911_tmp69 + V335_i; 48054 npy_float64 V911_tmp289; 48055 V911_tmp289 = V911_tmp70 + V771_i; 48056 npy_float64 V911_tmp290; 48057 V911_tmp290 = V911_tmp70 + V331_i; 48058 npy_float64 V911_tmp291; 48059 V911_tmp291 = V911_tmp71 + V769_i; 48060 npy_float64 V911_tmp292; 48061 V911_tmp292 = V911_tmp71 + V327_i; 48062 npy_float64 V911_tmp293; 48063 V911_tmp293 = V911_tmp72 + V767_i; 48064 npy_float64 V911_tmp294; 48065 V911_tmp294 = V911_tmp72 + V323_i; 48066 npy_float64 V911_tmp295; 48067 V911_tmp295 = V911_tmp73 + V765_i; 48068 npy_float64 V911_tmp296; 48069 V911_tmp296 = V911_tmp73 + V319_i; 48070 npy_float64 V911_tmp297; 48071 V911_tmp297 = V911_tmp74 + V763_i; 48072 npy_float64 V911_tmp298; 48073 V911_tmp298 = V911_tmp74 + V315_i; 48074 npy_float64 V911_tmp299; 48075 V911_tmp299 = V911_tmp75 + V761_i; 48076 npy_float64 V911_tmp300; 48077 V911_tmp300 = V911_tmp75 + V311_i; 48078 npy_float64 V911_tmp301; 48079 V911_tmp301 = V911_tmp76 + V759_i; 48080 npy_float64 V911_tmp302; 48081 V911_tmp302 = V911_tmp76 + V307_i; 48082 npy_float64 V911_tmp303; 48083 V911_tmp303 = V911_tmp77 + V757_i; 48084 npy_float64 V911_tmp304; 48085 V911_tmp304 = V911_tmp77 + V303_i; 48086 npy_float64 V911_tmp305; 48087 V911_tmp305 = V911_tmp78 + V755_i; 48088 npy_float64 V911_tmp306; 48089 V911_tmp306 = V911_tmp78 + V299_i; 48090 npy_float64 V911_tmp307; 48091 V911_tmp307 = V911_tmp79 + V753_i; 48092 npy_float64 V911_tmp308; 48093 V911_tmp308 = V911_tmp79 + V295_i; 48094 npy_float64 V911_tmp309; 48095 V911_tmp309 = V911_tmp80 + V751_i; 48096 npy_float64 V911_tmp310; 48097 V911_tmp310 = V911_tmp80 + V291_i; 48098 npy_float64 V911_tmp311; 48099 V911_tmp311 = V911_tmp81 + V749_i; 48100 npy_float64 V911_tmp312; 48101 V911_tmp312 = V911_tmp81 + V287_i; 48102 npy_float64 V911_tmp313; 48103 V911_tmp313 = V911_tmp82 + V747_i; 48104 npy_float64 V911_tmp314; 48105 V911_tmp314 = V911_tmp82 + V283_i; 48106 npy_float64 V911_tmp315; 48107 V911_tmp315 = V911_tmp83 + V745_i; 48108 npy_float64 V911_tmp316; 48109 V911_tmp316 = V911_tmp83 + V279_i; 48110 npy_float64 V911_tmp317; 48111 V911_tmp317 = V911_tmp84 + V743_i; 48112 npy_float64 V911_tmp318; 48113 V911_tmp318 = V911_tmp84 + V275_i; 48114 npy_float64 V911_tmp319; 48115 V911_tmp319 = V911_tmp85 + V741_i; 48116 npy_float64 V911_tmp320; 48117 V911_tmp320 = V911_tmp85 + V271_i; 48118 npy_float64 V911_tmp321; 48119 V911_tmp321 = V911_tmp86 + V739_i; 48120 npy_float64 V911_tmp322; 48121 V911_tmp322 = V911_tmp86 + V267_i; 48122 npy_float64 V911_tmp323; 48123 V911_tmp323 = V911_tmp87 + V737_i; 48124 npy_float64 V911_tmp324; 48125 V911_tmp324 = V911_tmp87 + V263_i; 48126 npy_float64 V911_tmp325; 48127 V911_tmp325 = V911_tmp88 + V735_i; 48128 npy_float64 V911_tmp326; 48129 V911_tmp326 = V911_tmp88 + V259_i; 48130 npy_float64 V911_tmp327; 48131 V911_tmp327 = V911_tmp89 + V733_i; 48132 npy_float64 V911_tmp328; 48133 V911_tmp328 = V911_tmp89 + V255_i; 48134 npy_float64 V911_tmp329; 48135 V911_tmp329 = V911_tmp90 + V731_i; 48136 npy_float64 V911_tmp330; 48137 V911_tmp330 = V911_tmp90 + V251_i; 48138 npy_float64 V911_tmp331; 48139 V911_tmp331 = V911_tmp91 + V729_i; 48140 npy_float64 V911_tmp332; 48141 V911_tmp332 = V911_tmp91 + V247_i; 48142 npy_float64 V911_tmp333; 48143 V911_tmp333 = V911_tmp92 + V727_i; 48144 npy_float64 V911_tmp334; 48145 V911_tmp334 = V911_tmp92 + V243_i; 48146 npy_float64 V911_tmp335; 48147 V911_tmp335 = V911_tmp93 + V725_i; 48148 npy_float64 V911_tmp336; 48149 V911_tmp336 = V911_tmp93 + V239_i; 48150 npy_float64 V911_tmp337; 48151 V911_tmp337 = V911_tmp94 + V723_i; 48152 npy_float64 V911_tmp338; 48153 V911_tmp338 = V911_tmp94 + V235_i; 48154 npy_float64 V911_tmp339; 48155 V911_tmp339 = V911_tmp95 + V721_i; 48156 npy_float64 V911_tmp340; 48157 V911_tmp340 = V911_tmp95 + V231_i; 48158 npy_float64 V911_tmp341; 48159 V911_tmp341 = V911_tmp96 + V719_i; 48160 npy_float64 V911_tmp342; 48161 V911_tmp342 = V911_tmp96 + V227_i; 48162 npy_float64 V911_tmp343; 48163 V911_tmp343 = V911_tmp97 + V717_i; 48164 npy_float64 V911_tmp344; 48165 V911_tmp344 = V911_tmp97 + V223_i; 48166 npy_float64 V911_tmp345; 48167 V911_tmp345 = V911_tmp98 + V715_i; 48168 npy_float64 V911_tmp346; 48169 V911_tmp346 = V911_tmp98 + V219_i; 48170 npy_float64 V911_tmp347; 48171 V911_tmp347 = V911_tmp99 + V713_i; 48172 npy_float64 V911_tmp348; 48173 V911_tmp348 = V911_tmp99 + V215_i; 48174 npy_float64 V911_tmp349; 48175 V911_tmp349 = V911_tmp100 + V711_i; 48176 npy_float64 V911_tmp350; 48177 V911_tmp350 = V911_tmp100 + V211_i; 48178 npy_float64 V911_tmp351; 48179 V911_tmp351 = V911_tmp101 + V709_i; 48180 npy_float64 V911_tmp352; 48181 V911_tmp352 = V911_tmp101 + V207_i; 48182 npy_float64 V911_tmp353; 48183 V911_tmp353 = V911_tmp102 + V707_i; 48184 npy_float64 V911_tmp354; 48185 V911_tmp354 = V911_tmp102 + V203_i; 48186 npy_float64 V911_tmp355; 48187 V911_tmp355 = V911_tmp103 + V705_i; 48188 npy_float64 V911_tmp356; 48189 V911_tmp356 = V911_tmp103 + V199_i; 48190 npy_float64 V911_tmp357; 48191 V911_tmp357 = V911_tmp104 + V703_i; 48192 npy_float64 V911_tmp358; 48193 V911_tmp358 = V911_tmp104 + V195_i; 48194 npy_float64 V911_tmp359; 48195 V911_tmp359 = V911_tmp105 + V701_i; 48196 npy_float64 V911_tmp360; 48197 V911_tmp360 = V911_tmp105 + V191_i; 48198 npy_float64 V911_tmp361; 48199 V911_tmp361 = V911_tmp106 + V699_i; 48200 npy_float64 V911_tmp362; 48201 V911_tmp362 = V911_tmp106 + V187_i; 48202 npy_float64 V911_tmp363; 48203 V911_tmp363 = V911_tmp107 + V697_i; 48204 npy_float64 V911_tmp364; 48205 V911_tmp364 = V911_tmp107 + V183_i; 48206 npy_float64 V911_tmp365; 48207 V911_tmp365 = V911_tmp108 + V695_i; 48208 npy_float64 V911_tmp366; 48209 V911_tmp366 = V911_tmp108 + V179_i; 48210 npy_float64 V911_tmp367; 48211 V911_tmp367 = V911_tmp109 + V693_i; 48212 npy_float64 V911_tmp368; 48213 V911_tmp368 = V911_tmp109 + V175_i; 48214 npy_float64 V911_tmp369; 48215 V911_tmp369 = V911_tmp110 + V691_i; 48216 npy_float64 V911_tmp370; 48217 V911_tmp370 = V911_tmp110 + V171_i; 48218 npy_float64 V911_tmp371; 48219 V911_tmp371 = V911_tmp111 + V689_i; 48220 npy_float64 V911_tmp372; 48221 V911_tmp372 = V911_tmp111 + V167_i; 48222 npy_float64 V911_tmp373; 48223 V911_tmp373 = V911_tmp112 + V687_i; 48224 npy_float64 V911_tmp374; 48225 V911_tmp374 = V911_tmp112 + V163_i; 48226 npy_float64 V911_tmp375; 48227 V911_tmp375 = V911_tmp113 + V685_i; 48228 npy_float64 V911_tmp376; 48229 V911_tmp376 = V911_tmp113 + V159_i; 48230 npy_float64 V911_tmp377; 48231 V911_tmp377 = V911_tmp114 + V683_i; 48232 npy_float64 V911_tmp378; 48233 V911_tmp378 = V911_tmp114 + V155_i; 48234 npy_float64 V911_tmp379; 48235 V911_tmp379 = V911_tmp115 + V681_i; 48236 npy_float64 V911_tmp380; 48237 V911_tmp380 = V911_tmp115 + V151_i; 48238 npy_float64 V911_tmp381; 48239 V911_tmp381 = V911_tmp116 + V679_i; 48240 npy_float64 V911_tmp382; 48241 V911_tmp382 = V911_tmp116 + V147_i; 48242 npy_float64 V911_tmp383; 48243 V911_tmp383 = V911_tmp117 + V677_i; 48244 npy_float64 V911_tmp384; 48245 V911_tmp384 = V911_tmp117 + V143_i; 48246 npy_float64 V911_tmp385; 48247 V911_tmp385 = V911_tmp118 + V675_i; 48248 npy_float64 V911_tmp386; 48249 V911_tmp386 = V911_tmp118 + V139_i; 48250 npy_float64 V911_tmp387; 48251 V911_tmp387 = V911_tmp119 + V673_i; 48252 npy_float64 V911_tmp388; 48253 V911_tmp388 = V911_tmp119 + V135_i; 48254 npy_float64 V911_tmp389; 48255 V911_tmp389 = V911_tmp120 + V671_i; 48256 npy_float64 V911_tmp390; 48257 V911_tmp390 = V911_tmp120 + V131_i; 48258 npy_float64 V911_tmp391; 48259 V911_tmp391 = V911_tmp121 + V669_i; 48260 npy_float64 V911_tmp392; 48261 V911_tmp392 = V911_tmp121 + V127_i; 48262 npy_float64 V911_tmp393; 48263 V911_tmp393 = V911_tmp122 + V667_i; 48264 npy_float64 V911_tmp394; 48265 V911_tmp394 = V911_tmp122 + V123_i; 48266 npy_float64 V911_tmp395; 48267 V911_tmp395 = V911_tmp123 + V665_i; 48268 npy_float64 V911_tmp396; 48269 V911_tmp396 = V911_tmp123 + V119_i; 48270 npy_float64 V911_tmp397; 48271 V911_tmp397 = V911_tmp124 + V663_i; 48272 npy_float64 V911_tmp398; 48273 V911_tmp398 = V911_tmp124 + V115_i; 48274 npy_float64 V911_tmp399; 48275 V911_tmp399 = V911_tmp125 + V661_i; 48276 npy_float64 V911_tmp400; 48277 V911_tmp400 = V911_tmp125 + V111_i; 48278 npy_float64 V911_tmp401; 48279 V911_tmp401 = V911_tmp126 + V659_i; 48280 npy_float64 V911_tmp402; 48281 V911_tmp402 = V911_tmp126 + V107_i; 48282 npy_float64 V911_tmp403; 48283 V911_tmp403 = V911_tmp127 + V657_i; 48284 npy_float64 V911_tmp404; 48285 V911_tmp404 = V911_tmp127 + V103_i; 48286 npy_float64 V911_tmp405; 48287 V911_tmp405 = V911_tmp128 + V655_i; 48288 npy_float64 V911_tmp406; 48289 V911_tmp406 = V911_tmp128 + V99_i; 48290 npy_float64 V911_tmp407; 48291 V911_tmp407 = V911_tmp129 + V653_i; 48292 npy_float64 V911_tmp408; 48293 V911_tmp408 = V911_tmp129 + V95_i; 48294 npy_float64 V911_tmp409; 48295 V911_tmp409 = V911_tmp130 + V651_i; 48296 npy_float64 V911_tmp410; 48297 V911_tmp410 = V911_tmp130 + V91_i; 48298 npy_float64 V911_tmp411; 48299 V911_tmp411 = V911_tmp131 + V649_i; 48300 npy_float64 V911_tmp412; 48301 V911_tmp412 = V911_tmp131 + V87_i; 48302 npy_float64 V911_tmp413; 48303 V911_tmp413 = V911_tmp132 + V647_i; 48304 npy_float64 V911_tmp414; 48305 V911_tmp414 = V911_tmp132 + V83_i; 48306 npy_float64 V911_tmp415; 48307 V911_tmp415 = V911_tmp133 + V645_i; 48308 npy_float64 V911_tmp416; 48309 V911_tmp416 = V911_tmp133 + V79_i; 48310 npy_float64 V911_tmp417; 48311 V911_tmp417 = V911_tmp134 + V643_i; 48312 npy_float64 V911_tmp418; 48313 V911_tmp418 = V911_tmp134 + V75_i; 48314 npy_float64 V911_tmp419; 48315 V911_tmp419 = V911_tmp135 + V641_i; 48316 npy_float64 V911_tmp420; 48317 V911_tmp420 = V911_tmp135 + V71_i; 48318 npy_float64 V911_tmp421; 48319 V911_tmp421 = V911_tmp136 + V639_i; 48320 npy_float64 V911_tmp422; 48321 V911_tmp422 = V911_tmp136 + V67_i; 48322 npy_float64 V911_tmp423; 48323 V911_tmp423 = V911_tmp137 + V637_i; 48324 npy_float64 V911_tmp424; 48325 V911_tmp424 = V911_tmp137 + V63_i; 48326 npy_float64 V911_tmp425; 48327 V911_tmp425 = V911_tmp138 + V635_i; 48328 npy_float64 V911_tmp426; 48329 V911_tmp426 = V911_tmp138 + V59_i; 48330 npy_float64 V911_tmp427; 48331 V911_tmp427 = V911_tmp139 + V633_i; 48332 npy_float64 V911_tmp428; 48333 V911_tmp428 = V911_tmp139 + V55_i; 48334 npy_float64 V911_tmp429; 48335 V911_tmp429 = V911_tmp140 + V631_i; 48336 npy_float64 V911_tmp430; 48337 V911_tmp430 = V911_tmp140 + V51_i; 48338 npy_float64 V911_tmp431; 48339 V911_tmp431 = V911_tmp141 + V629_i; 48340 npy_float64 V911_tmp432; 48341 V911_tmp432 = V911_tmp141 + V47_i; 48342 npy_float64 V911_tmp433; 48343 V911_tmp433 = V911_tmp142 + V627_i; 48344 npy_float64 V911_tmp434; 48345 V911_tmp434 = V911_tmp142 + V43_i; 48346 npy_float64 V911_tmp435; 48347 V911_tmp435 = V911_tmp143 + V625_i; 48348 npy_float64 V911_tmp436; 48349 V911_tmp436 = V911_tmp143 + V39_i; 48350 npy_float64 V911_tmp437; 48351 V911_tmp437 = V911_tmp144 + V623_i; 48352 npy_float64 V911_tmp438; 48353 V911_tmp438 = V911_tmp144 + V35_i; 48354 npy_float64 V911_tmp439; 48355 V911_tmp439 = V911_tmp145 + V621_i; 48356 npy_float64 V911_tmp440; 48357 V911_tmp440 = V911_tmp145 + V31_i; 48358 npy_float64 V911_tmp441; 48359 V911_tmp441 = V911_tmp146 + V619_i; 48360 npy_float64 V911_tmp442; 48361 V911_tmp442 = V911_tmp146 + V27_i; 48362 npy_float64 V911_tmp443; 48363 V911_tmp443 = V911_tmp147 + V617_i; 48364 npy_float64 V911_tmp444; 48365 V911_tmp444 = V911_tmp147 + V23_i; 48366 npy_float64 V911_tmp445; 48367 V911_tmp445 = V911_tmp148 + V615_i; 48368 npy_float64 V911_tmp446; 48369 V911_tmp446 = V911_tmp148 + V19_i; 48370 npy_float64 V911_tmp447; 48371 V911_tmp447 = V911_tmp149 + V613_i; 48372 npy_float64 V911_tmp448; 48373 V911_tmp448 = V911_tmp149 + V15_i; 48374 npy_float64 V911_tmp449; 48375 V911_tmp449 = V911_tmp150 + V611_i; 48376 npy_float64 V911_tmp450; 48377 V911_tmp450 = V911_tmp150 + V11_i; 48378 npy_float64 V911_tmp451; 48379 V911_tmp451 = V5_i * V911_tmp151; 48380 npy_float64 V911_tmp452; 48381 V911_tmp452 = V5_i * V911_tmp152; 48382 npy_float64 V911_tmp453; 48383 V911_tmp453 = V5_i * V911_tmp153; 48384 npy_float64 V911_tmp454; 48385 V911_tmp454 = V5_i * V911_tmp154; 48386 npy_float64 V911_tmp455; 48387 V911_tmp455 = V5_i * V911_tmp155; 48388 npy_float64 V911_tmp456; 48389 V911_tmp456 = V5_i * V911_tmp156; 48390 npy_float64 V911_tmp457; 48391 V911_tmp457 = V5_i * V911_tmp157; 48392 npy_float64 V911_tmp458; 48393 V911_tmp458 = V5_i * V911_tmp158; 48394 npy_float64 V911_tmp459; 48395 V911_tmp459 = V5_i * V911_tmp159; 48396 npy_float64 V911_tmp460; 48397 V911_tmp460 = V5_i * V911_tmp160; 48398 npy_float64 V911_tmp461; 48399 V911_tmp461 = V5_i * V911_tmp161; 48400 npy_float64 V911_tmp462; 48401 V911_tmp462 = V5_i * V911_tmp162; 48402 npy_float64 V911_tmp463; 48403 V911_tmp463 = V5_i * V911_tmp163; 48404 npy_float64 V911_tmp464; 48405 V911_tmp464 = V5_i * V911_tmp164; 48406 npy_float64 V911_tmp465; 48407 V911_tmp465 = V5_i * V911_tmp165; 48408 npy_float64 V911_tmp466; 48409 V911_tmp466 = V5_i * V911_tmp166; 48410 npy_float64 V911_tmp467; 48411 V911_tmp467 = V5_i * V911_tmp167; 48412 npy_float64 V911_tmp468; 48413 V911_tmp468 = V5_i * V911_tmp168; 48414 npy_float64 V911_tmp469; 48415 V911_tmp469 = V5_i * V911_tmp169; 48416 npy_float64 V911_tmp470; 48417 V911_tmp470 = V5_i * V911_tmp170; 48418 npy_float64 V911_tmp471; 48419 V911_tmp471 = V5_i * V911_tmp171; 48420 npy_float64 V911_tmp472; 48421 V911_tmp472 = V5_i * V911_tmp172; 48422 npy_float64 V911_tmp473; 48423 V911_tmp473 = V5_i * V911_tmp173; 48424 npy_float64 V911_tmp474; 48425 V911_tmp474 = V5_i * V911_tmp174; 48426 npy_float64 V911_tmp475; 48427 V911_tmp475 = V5_i * V911_tmp175; 48428 npy_float64 V911_tmp476; 48429 V911_tmp476 = V5_i * V911_tmp176; 48430 npy_float64 V911_tmp477; 48431 V911_tmp477 = V5_i * V911_tmp177; 48432 npy_float64 V911_tmp478; 48433 V911_tmp478 = V5_i * V911_tmp178; 48434 npy_float64 V911_tmp479; 48435 V911_tmp479 = V5_i * V911_tmp179; 48436 npy_float64 V911_tmp480; 48437 V911_tmp480 = V5_i * V911_tmp180; 48438 npy_float64 V911_tmp481; 48439 V911_tmp481 = V5_i * V911_tmp181; 48440 npy_float64 V911_tmp482; 48441 V911_tmp482 = V5_i * V911_tmp182; 48442 npy_float64 V911_tmp483; 48443 V911_tmp483 = V5_i * V911_tmp183; 48444 npy_float64 V911_tmp484; 48445 V911_tmp484 = V5_i * V911_tmp184; 48446 npy_float64 V911_tmp485; 48447 V911_tmp485 = V5_i * V911_tmp185; 48448 npy_float64 V911_tmp486; 48449 V911_tmp486 = V5_i * V911_tmp186; 48450 npy_float64 V911_tmp487; 48451 V911_tmp487 = V5_i * V911_tmp187; 48452 npy_float64 V911_tmp488; 48453 V911_tmp488 = V5_i * V911_tmp188; 48454 npy_float64 V911_tmp489; 48455 V911_tmp489 = V5_i * V911_tmp189; 48456 npy_float64 V911_tmp490; 48457 V911_tmp490 = V5_i * V911_tmp190; 48458 npy_float64 V911_tmp491; 48459 V911_tmp491 = V5_i * V911_tmp191; 48460 npy_float64 V911_tmp492; 48461 V911_tmp492 = V5_i * V911_tmp192; 48462 npy_float64 V911_tmp493; 48463 V911_tmp493 = V5_i * V911_tmp193; 48464 npy_float64 V911_tmp494; 48465 V911_tmp494 = V5_i * V911_tmp194; 48466 npy_float64 V911_tmp495; 48467 V911_tmp495 = V5_i * V911_tmp195; 48468 npy_float64 V911_tmp496; 48469 V911_tmp496 = V5_i * V911_tmp196; 48470 npy_float64 V911_tmp497; 48471 V911_tmp497 = V5_i * V911_tmp197; 48472 npy_float64 V911_tmp498; 48473 V911_tmp498 = V5_i * V911_tmp198; 48474 npy_float64 V911_tmp499; 48475 V911_tmp499 = V5_i * V911_tmp199; 48476 npy_float64 V911_tmp500; 48477 V911_tmp500 = V5_i * V911_tmp200; 48478 npy_float64 V911_tmp501; 48479 V911_tmp501 = V5_i * V911_tmp201; 48480 npy_float64 V911_tmp502; 48481 V911_tmp502 = V5_i * V911_tmp202; 48482 npy_float64 V911_tmp503; 48483 V911_tmp503 = V5_i * V911_tmp203; 48484 npy_float64 V911_tmp504; 48485 V911_tmp504 = V5_i * V911_tmp204; 48486 npy_float64 V911_tmp505; 48487 V911_tmp505 = V5_i * V911_tmp205; 48488 npy_float64 V911_tmp506; 48489 V911_tmp506 = V5_i * V911_tmp206; 48490 npy_float64 V911_tmp507; 48491 V911_tmp507 = V5_i * V911_tmp207; 48492 npy_float64 V911_tmp508; 48493 V911_tmp508 = V5_i * V911_tmp208; 48494 npy_float64 V911_tmp509; 48495 V911_tmp509 = V5_i * V911_tmp209; 48496 npy_float64 V911_tmp510; 48497 V911_tmp510 = V5_i * V911_tmp210; 48498 npy_float64 V911_tmp511; 48499 V911_tmp511 = V5_i * V911_tmp211; 48500 npy_float64 V911_tmp512; 48501 V911_tmp512 = V5_i * V911_tmp212; 48502 npy_float64 V911_tmp513; 48503 V911_tmp513 = V5_i * V911_tmp213; 48504 npy_float64 V911_tmp514; 48505 V911_tmp514 = V5_i * V911_tmp214; 48506 npy_float64 V911_tmp515; 48507 V911_tmp515 = V5_i * V911_tmp215; 48508 npy_float64 V911_tmp516; 48509 V911_tmp516 = V5_i * V911_tmp216; 48510 npy_float64 V911_tmp517; 48511 V911_tmp517 = V5_i * V911_tmp217; 48512 npy_float64 V911_tmp518; 48513 V911_tmp518 = V5_i * V911_tmp218; 48514 npy_float64 V911_tmp519; 48515 V911_tmp519 = V5_i * V911_tmp219; 48516 npy_float64 V911_tmp520; 48517 V911_tmp520 = V5_i * V911_tmp220; 48518 npy_float64 V911_tmp521; 48519 V911_tmp521 = V5_i * V911_tmp221; 48520 npy_float64 V911_tmp522; 48521 V911_tmp522 = V5_i * V911_tmp222; 48522 npy_float64 V911_tmp523; 48523 V911_tmp523 = V5_i * V911_tmp223; 48524 npy_float64 V911_tmp524; 48525 V911_tmp524 = V5_i * V911_tmp224; 48526 npy_float64 V911_tmp525; 48527 V911_tmp525 = V5_i * V911_tmp225; 48528 npy_float64 V911_tmp526; 48529 V911_tmp526 = V5_i * V911_tmp226; 48530 npy_float64 V911_tmp527; 48531 V911_tmp527 = V5_i * V911_tmp227; 48532 npy_float64 V911_tmp528; 48533 V911_tmp528 = V5_i * V911_tmp228; 48534 npy_float64 V911_tmp529; 48535 V911_tmp529 = V5_i * V911_tmp229; 48536 npy_float64 V911_tmp530; 48537 V911_tmp530 = V5_i * V911_tmp230; 48538 npy_float64 V911_tmp531; 48539 V911_tmp531 = V5_i * V911_tmp231; 48540 npy_float64 V911_tmp532; 48541 V911_tmp532 = V5_i * V911_tmp232; 48542 npy_float64 V911_tmp533; 48543 V911_tmp533 = V5_i * V911_tmp233; 48544 npy_float64 V911_tmp534; 48545 V911_tmp534 = V5_i * V911_tmp234; 48546 npy_float64 V911_tmp535; 48547 V911_tmp535 = V5_i * V911_tmp235; 48548 npy_float64 V911_tmp536; 48549 V911_tmp536 = V5_i * V911_tmp236; 48550 npy_float64 V911_tmp537; 48551 V911_tmp537 = V5_i * V911_tmp237; 48552 npy_float64 V911_tmp538; 48553 V911_tmp538 = V5_i * V911_tmp238; 48554 npy_float64 V911_tmp539; 48555 V911_tmp539 = V5_i * V911_tmp239; 48556 npy_float64 V911_tmp540; 48557 V911_tmp540 = V5_i * V911_tmp240; 48558 npy_float64 V911_tmp541; 48559 V911_tmp541 = V5_i * V911_tmp241; 48560 npy_float64 V911_tmp542; 48561 V911_tmp542 = V5_i * V911_tmp242; 48562 npy_float64 V911_tmp543; 48563 V911_tmp543 = V5_i * V911_tmp243; 48564 npy_float64 V911_tmp544; 48565 V911_tmp544 = V5_i * V911_tmp244; 48566 npy_float64 V911_tmp545; 48567 V911_tmp545 = V5_i * V911_tmp245; 48568 npy_float64 V911_tmp546; 48569 V911_tmp546 = V5_i * V911_tmp246; 48570 npy_float64 V911_tmp547; 48571 V911_tmp547 = V5_i * V911_tmp247; 48572 npy_float64 V911_tmp548; 48573 V911_tmp548 = V5_i * V911_tmp248; 48574 npy_float64 V911_tmp549; 48575 V911_tmp549 = V5_i * V911_tmp249; 48576 npy_float64 V911_tmp550; 48577 V911_tmp550 = V5_i * V911_tmp250; 48578 npy_float64 V911_tmp551; 48579 V911_tmp551 = V5_i * V911_tmp251; 48580 npy_float64 V911_tmp552; 48581 V911_tmp552 = V5_i * V911_tmp252; 48582 npy_float64 V911_tmp553; 48583 V911_tmp553 = V5_i * V911_tmp253; 48584 npy_float64 V911_tmp554; 48585 V911_tmp554 = V5_i * V911_tmp254; 48586 npy_float64 V911_tmp555; 48587 V911_tmp555 = V5_i * V911_tmp255; 48588 npy_float64 V911_tmp556; 48589 V911_tmp556 = V5_i * V911_tmp256; 48590 npy_float64 V911_tmp557; 48591 V911_tmp557 = V5_i * V911_tmp257; 48592 npy_float64 V911_tmp558; 48593 V911_tmp558 = V5_i * V911_tmp258; 48594 npy_float64 V911_tmp559; 48595 V911_tmp559 = V5_i * V911_tmp259; 48596 npy_float64 V911_tmp560; 48597 V911_tmp560 = V5_i * V911_tmp260; 48598 npy_float64 V911_tmp561; 48599 V911_tmp561 = V5_i * V911_tmp261; 48600 npy_float64 V911_tmp562; 48601 V911_tmp562 = V5_i * V911_tmp262; 48602 npy_float64 V911_tmp563; 48603 V911_tmp563 = V5_i * V911_tmp263; 48604 npy_float64 V911_tmp564; 48605 V911_tmp564 = V5_i * V911_tmp264; 48606 npy_float64 V911_tmp565; 48607 V911_tmp565 = V5_i * V911_tmp265; 48608 npy_float64 V911_tmp566; 48609 V911_tmp566 = V5_i * V911_tmp266; 48610 npy_float64 V911_tmp567; 48611 V911_tmp567 = V5_i * V911_tmp267; 48612 npy_float64 V911_tmp568; 48613 V911_tmp568 = V5_i * V911_tmp268; 48614 npy_float64 V911_tmp569; 48615 V911_tmp569 = V5_i * V911_tmp269; 48616 npy_float64 V911_tmp570; 48617 V911_tmp570 = V5_i * V911_tmp270; 48618 npy_float64 V911_tmp571; 48619 V911_tmp571 = V5_i * V911_tmp271; 48620 npy_float64 V911_tmp572; 48621 V911_tmp572 = V5_i * V911_tmp272; 48622 npy_float64 V911_tmp573; 48623 V911_tmp573 = V5_i * V911_tmp273; 48624 npy_float64 V911_tmp574; 48625 V911_tmp574 = V5_i * V911_tmp274; 48626 npy_float64 V911_tmp575; 48627 V911_tmp575 = V5_i * V911_tmp275; 48628 npy_float64 V911_tmp576; 48629 V911_tmp576 = V5_i * V911_tmp276; 48630 npy_float64 V911_tmp577; 48631 V911_tmp577 = V5_i * V911_tmp277; 48632 npy_float64 V911_tmp578; 48633 V911_tmp578 = V5_i * V911_tmp278; 48634 npy_float64 V911_tmp579; 48635 V911_tmp579 = V5_i * V911_tmp279; 48636 npy_float64 V911_tmp580; 48637 V911_tmp580 = V5_i * V911_tmp280; 48638 npy_float64 V911_tmp581; 48639 V911_tmp581 = V5_i * V911_tmp281; 48640 npy_float64 V911_tmp582; 48641 V911_tmp582 = V5_i * V911_tmp282; 48642 npy_float64 V911_tmp583; 48643 V911_tmp583 = V5_i * V911_tmp283; 48644 npy_float64 V911_tmp584; 48645 V911_tmp584 = V5_i * V911_tmp284; 48646 npy_float64 V911_tmp585; 48647 V911_tmp585 = V5_i * V911_tmp285; 48648 npy_float64 V911_tmp586; 48649 V911_tmp586 = V5_i * V911_tmp286; 48650 npy_float64 V911_tmp587; 48651 V911_tmp587 = V5_i * V911_tmp287; 48652 npy_float64 V911_tmp588; 48653 V911_tmp588 = V5_i * V911_tmp288; 48654 npy_float64 V911_tmp589; 48655 V911_tmp589 = V5_i * V911_tmp289; 48656 npy_float64 V911_tmp590; 48657 V911_tmp590 = V5_i * V911_tmp290; 48658 npy_float64 V911_tmp591; 48659 V911_tmp591 = V5_i * V911_tmp291; 48660 npy_float64 V911_tmp592; 48661 V911_tmp592 = V5_i * V911_tmp292; 48662 npy_float64 V911_tmp593; 48663 V911_tmp593 = V5_i * V911_tmp293; 48664 npy_float64 V911_tmp594; 48665 V911_tmp594 = V5_i * V911_tmp294; 48666 npy_float64 V911_tmp595; 48667 V911_tmp595 = V5_i * V911_tmp295; 48668 npy_float64 V911_tmp596; 48669 V911_tmp596 = V5_i * V911_tmp296; 48670 npy_float64 V911_tmp597; 48671 V911_tmp597 = V5_i * V911_tmp297; 48672 npy_float64 V911_tmp598; 48673 V911_tmp598 = V5_i * V911_tmp298; 48674 npy_float64 V911_tmp599; 48675 V911_tmp599 = V5_i * V911_tmp299; 48676 npy_float64 V911_tmp600; 48677 V911_tmp600 = V5_i * V911_tmp300; 48678 npy_float64 V911_tmp601; 48679 V911_tmp601 = V5_i * V911_tmp301; 48680 npy_float64 V911_tmp602; 48681 V911_tmp602 = V5_i * V911_tmp302; 48682 npy_float64 V911_tmp603; 48683 V911_tmp603 = V5_i * V911_tmp303; 48684 npy_float64 V911_tmp604; 48685 V911_tmp604 = V5_i * V911_tmp304; 48686 npy_float64 V911_tmp605; 48687 V911_tmp605 = V5_i * V911_tmp305; 48688 npy_float64 V911_tmp606; 48689 V911_tmp606 = V5_i * V911_tmp306; 48690 npy_float64 V911_tmp607; 48691 V911_tmp607 = V5_i * V911_tmp307; 48692 npy_float64 V911_tmp608; 48693 V911_tmp608 = V5_i * V911_tmp308; 48694 npy_float64 V911_tmp609; 48695 V911_tmp609 = V5_i * V911_tmp309; 48696 npy_float64 V911_tmp610; 48697 V911_tmp610 = V5_i * V911_tmp310; 48698 npy_float64 V911_tmp611; 48699 V911_tmp611 = V5_i * V911_tmp311; 48700 npy_float64 V911_tmp612; 48701 V911_tmp612 = V5_i * V911_tmp312; 48702 npy_float64 V911_tmp613; 48703 V911_tmp613 = V5_i * V911_tmp313; 48704 npy_float64 V911_tmp614; 48705 V911_tmp614 = V5_i * V911_tmp314; 48706 npy_float64 V911_tmp615; 48707 V911_tmp615 = V5_i * V911_tmp315; 48708 npy_float64 V911_tmp616; 48709 V911_tmp616 = V5_i * V911_tmp316; 48710 npy_float64 V911_tmp617; 48711 V911_tmp617 = V5_i * V911_tmp317; 48712 npy_float64 V911_tmp618; 48713 V911_tmp618 = V5_i * V911_tmp318; 48714 npy_float64 V911_tmp619; 48715 V911_tmp619 = V5_i * V911_tmp319; 48716 npy_float64 V911_tmp620; 48717 V911_tmp620 = V5_i * V911_tmp320; 48718 npy_float64 V911_tmp621; 48719 V911_tmp621 = V5_i * V911_tmp321; 48720 npy_float64 V911_tmp622; 48721 V911_tmp622 = V5_i * V911_tmp322; 48722 npy_float64 V911_tmp623; 48723 V911_tmp623 = V5_i * V911_tmp323; 48724 npy_float64 V911_tmp624; 48725 V911_tmp624 = V5_i * V911_tmp324; 48726 npy_float64 V911_tmp625; 48727 V911_tmp625 = V5_i * V911_tmp325; 48728 npy_float64 V911_tmp626; 48729 V911_tmp626 = V5_i * V911_tmp326; 48730 npy_float64 V911_tmp627; 48731 V911_tmp627 = V5_i * V911_tmp327; 48732 npy_float64 V911_tmp628; 48733 V911_tmp628 = V5_i * V911_tmp328; 48734 npy_float64 V911_tmp629; 48735 V911_tmp629 = V5_i * V911_tmp329; 48736 npy_float64 V911_tmp630; 48737 V911_tmp630 = V5_i * V911_tmp330; 48738 npy_float64 V911_tmp631; 48739 V911_tmp631 = V5_i * V911_tmp331; 48740 npy_float64 V911_tmp632; 48741 V911_tmp632 = V5_i * V911_tmp332; 48742 npy_float64 V911_tmp633; 48743 V911_tmp633 = V5_i * V911_tmp333; 48744 npy_float64 V911_tmp634; 48745 V911_tmp634 = V5_i * V911_tmp334; 48746 npy_float64 V911_tmp635; 48747 V911_tmp635 = V5_i * V911_tmp335; 48748 npy_float64 V911_tmp636; 48749 V911_tmp636 = V5_i * V911_tmp336; 48750 npy_float64 V911_tmp637; 48751 V911_tmp637 = V5_i * V911_tmp337; 48752 npy_float64 V911_tmp638; 48753 V911_tmp638 = V5_i * V911_tmp338; 48754 npy_float64 V911_tmp639; 48755 V911_tmp639 = V5_i * V911_tmp339; 48756 npy_float64 V911_tmp640; 48757 V911_tmp640 = V5_i * V911_tmp340; 48758 npy_float64 V911_tmp641; 48759 V911_tmp641 = V5_i * V911_tmp341; 48760 npy_float64 V911_tmp642; 48761 V911_tmp642 = V5_i * V911_tmp342; 48762 npy_float64 V911_tmp643; 48763 V911_tmp643 = V5_i * V911_tmp343; 48764 npy_float64 V911_tmp644; 48765 V911_tmp644 = V5_i * V911_tmp344; 48766 npy_float64 V911_tmp645; 48767 V911_tmp645 = V5_i * V911_tmp345; 48768 npy_float64 V911_tmp646; 48769 V911_tmp646 = V5_i * V911_tmp346; 48770 npy_float64 V911_tmp647; 48771 V911_tmp647 = V5_i * V911_tmp347; 48772 npy_float64 V911_tmp648; 48773 V911_tmp648 = V5_i * V911_tmp348; 48774 npy_float64 V911_tmp649; 48775 V911_tmp649 = V5_i * V911_tmp349; 48776 npy_float64 V911_tmp650; 48777 V911_tmp650 = V5_i * V911_tmp350; 48778 npy_float64 V911_tmp651; 48779 V911_tmp651 = V5_i * V911_tmp351; 48780 npy_float64 V911_tmp652; 48781 V911_tmp652 = V5_i * V911_tmp352; 48782 npy_float64 V911_tmp653; 48783 V911_tmp653 = V5_i * V911_tmp353; 48784 npy_float64 V911_tmp654; 48785 V911_tmp654 = V5_i * V911_tmp354; 48786 npy_float64 V911_tmp655; 48787 V911_tmp655 = V5_i * V911_tmp355; 48788 npy_float64 V911_tmp656; 48789 V911_tmp656 = V5_i * V911_tmp356; 48790 npy_float64 V911_tmp657; 48791 V911_tmp657 = V5_i * V911_tmp357; 48792 npy_float64 V911_tmp658; 48793 V911_tmp658 = V5_i * V911_tmp358; 48794 npy_float64 V911_tmp659; 48795 V911_tmp659 = V5_i * V911_tmp359; 48796 npy_float64 V911_tmp660; 48797 V911_tmp660 = V5_i * V911_tmp360; 48798 npy_float64 V911_tmp661; 48799 V911_tmp661 = V5_i * V911_tmp361; 48800 npy_float64 V911_tmp662; 48801 V911_tmp662 = V5_i * V911_tmp362; 48802 npy_float64 V911_tmp663; 48803 V911_tmp663 = V5_i * V911_tmp363; 48804 npy_float64 V911_tmp664; 48805 V911_tmp664 = V5_i * V911_tmp364; 48806 npy_float64 V911_tmp665; 48807 V911_tmp665 = V5_i * V911_tmp365; 48808 npy_float64 V911_tmp666; 48809 V911_tmp666 = V5_i * V911_tmp366; 48810 npy_float64 V911_tmp667; 48811 V911_tmp667 = V5_i * V911_tmp367; 48812 npy_float64 V911_tmp668; 48813 V911_tmp668 = V5_i * V911_tmp368; 48814 npy_float64 V911_tmp669; 48815 V911_tmp669 = V5_i * V911_tmp369; 48816 npy_float64 V911_tmp670; 48817 V911_tmp670 = V5_i * V911_tmp370; 48818 npy_float64 V911_tmp671; 48819 V911_tmp671 = V5_i * V911_tmp371; 48820 npy_float64 V911_tmp672; 48821 V911_tmp672 = V5_i * V911_tmp372; 48822 npy_float64 V911_tmp673; 48823 V911_tmp673 = V5_i * V911_tmp373; 48824 npy_float64 V911_tmp674; 48825 V911_tmp674 = V5_i * V911_tmp374; 48826 npy_float64 V911_tmp675; 48827 V911_tmp675 = V5_i * V911_tmp375; 48828 npy_float64 V911_tmp676; 48829 V911_tmp676 = V5_i * V911_tmp376; 48830 npy_float64 V911_tmp677; 48831 V911_tmp677 = V5_i * V911_tmp377; 48832 npy_float64 V911_tmp678; 48833 V911_tmp678 = V5_i * V911_tmp378; 48834 npy_float64 V911_tmp679; 48835 V911_tmp679 = V5_i * V911_tmp379; 48836 npy_float64 V911_tmp680; 48837 V911_tmp680 = V5_i * V911_tmp380; 48838 npy_float64 V911_tmp681; 48839 V911_tmp681 = V5_i * V911_tmp381; 48840 npy_float64 V911_tmp682; 48841 V911_tmp682 = V5_i * V911_tmp382; 48842 npy_float64 V911_tmp683; 48843 V911_tmp683 = V5_i * V911_tmp383; 48844 npy_float64 V911_tmp684; 48845 V911_tmp684 = V5_i * V911_tmp384; 48846 npy_float64 V911_tmp685; 48847 V911_tmp685 = V5_i * V911_tmp385; 48848 npy_float64 V911_tmp686; 48849 V911_tmp686 = V5_i * V911_tmp386; 48850 npy_float64 V911_tmp687; 48851 V911_tmp687 = V5_i * V911_tmp387; 48852 npy_float64 V911_tmp688; 48853 V911_tmp688 = V5_i * V911_tmp388; 48854 npy_float64 V911_tmp689; 48855 V911_tmp689 = V5_i * V911_tmp389; 48856 npy_float64 V911_tmp690; 48857 V911_tmp690 = V5_i * V911_tmp390; 48858 npy_float64 V911_tmp691; 48859 V911_tmp691 = V5_i * V911_tmp391; 48860 npy_float64 V911_tmp692; 48861 V911_tmp692 = V5_i * V911_tmp392; 48862 npy_float64 V911_tmp693; 48863 V911_tmp693 = V5_i * V911_tmp393; 48864 npy_float64 V911_tmp694; 48865 V911_tmp694 = V5_i * V911_tmp394; 48866 npy_float64 V911_tmp695; 48867 V911_tmp695 = V5_i * V911_tmp395; 48868 npy_float64 V911_tmp696; 48869 V911_tmp696 = V5_i * V911_tmp396; 48870 npy_float64 V911_tmp697; 48871 V911_tmp697 = V5_i * V911_tmp397; 48872 npy_float64 V911_tmp698; 48873 V911_tmp698 = V5_i * V911_tmp398; 48874 npy_float64 V911_tmp699; 48875 V911_tmp699 = V5_i * V911_tmp399; 48876 npy_float64 V911_tmp700; 48877 V911_tmp700 = V5_i * V911_tmp400; 48878 npy_float64 V911_tmp701; 48879 V911_tmp701 = V5_i * V911_tmp401; 48880 npy_float64 V911_tmp702; 48881 V911_tmp702 = V5_i * V911_tmp402; 48882 npy_float64 V911_tmp703; 48883 V911_tmp703 = V5_i * V911_tmp403; 48884 npy_float64 V911_tmp704; 48885 V911_tmp704 = V5_i * V911_tmp404; 48886 npy_float64 V911_tmp705; 48887 V911_tmp705 = V5_i * V911_tmp405; 48888 npy_float64 V911_tmp706; 48889 V911_tmp706 = V5_i * V911_tmp406; 48890 npy_float64 V911_tmp707; 48891 V911_tmp707 = V5_i * V911_tmp407; 48892 npy_float64 V911_tmp708; 48893 V911_tmp708 = V5_i * V911_tmp408; 48894 npy_float64 V911_tmp709; 48895 V911_tmp709 = V5_i * V911_tmp409; 48896 npy_float64 V911_tmp710; 48897 V911_tmp710 = V5_i * V911_tmp410; 48898 npy_float64 V911_tmp711; 48899 V911_tmp711 = V5_i * V911_tmp411; 48900 npy_float64 V911_tmp712; 48901 V911_tmp712 = V5_i * V911_tmp412; 48902 npy_float64 V911_tmp713; 48903 V911_tmp713 = V5_i * V911_tmp413; 48904 npy_float64 V911_tmp714; 48905 V911_tmp714 = V5_i * V911_tmp414; 48906 npy_float64 V911_tmp715; 48907 V911_tmp715 = V5_i * V911_tmp415; 48908 npy_float64 V911_tmp716; 48909 V911_tmp716 = V5_i * V911_tmp416; 48910 npy_float64 V911_tmp717; 48911 V911_tmp717 = V5_i * V911_tmp417; 48912 npy_float64 V911_tmp718; 48913 V911_tmp718 = V5_i * V911_tmp418; 48914 npy_float64 V911_tmp719; 48915 V911_tmp719 = V5_i * V911_tmp419; 48916 npy_float64 V911_tmp720; 48917 V911_tmp720 = V5_i * V911_tmp420; 48918 npy_float64 V911_tmp721; 48919 V911_tmp721 = V5_i * V911_tmp421; 48920 npy_float64 V911_tmp722; 48921 V911_tmp722 = V5_i * V911_tmp422; 48922 npy_float64 V911_tmp723; 48923 V911_tmp723 = V5_i * V911_tmp423; 48924 npy_float64 V911_tmp724; 48925 V911_tmp724 = V5_i * V911_tmp424; 48926 npy_float64 V911_tmp725; 48927 V911_tmp725 = V5_i * V911_tmp425; 48928 npy_float64 V911_tmp726; 48929 V911_tmp726 = V5_i * V911_tmp426; 48930 npy_float64 V911_tmp727; 48931 V911_tmp727 = V5_i * V911_tmp427; 48932 npy_float64 V911_tmp728; 48933 V911_tmp728 = V5_i * V911_tmp428; 48934 npy_float64 V911_tmp729; 48935 V911_tmp729 = V5_i * V911_tmp429; 48936 npy_float64 V911_tmp730; 48937 V911_tmp730 = V5_i * V911_tmp430; 48938 npy_float64 V911_tmp731; 48939 V911_tmp731 = V5_i * V911_tmp431; 48940 npy_float64 V911_tmp732; 48941 V911_tmp732 = V5_i * V911_tmp432; 48942 npy_float64 V911_tmp733; 48943 V911_tmp733 = V5_i * V911_tmp433; 48944 npy_float64 V911_tmp734; 48945 V911_tmp734 = V5_i * V911_tmp434; 48946 npy_float64 V911_tmp735; 48947 V911_tmp735 = V5_i * V911_tmp435; 48948 npy_float64 V911_tmp736; 48949 V911_tmp736 = V5_i * V911_tmp436; 48950 npy_float64 V911_tmp737; 48951 V911_tmp737 = V5_i * V911_tmp437; 48952 npy_float64 V911_tmp738; 48953 V911_tmp738 = V5_i * V911_tmp438; 48954 npy_float64 V911_tmp739; 48955 V911_tmp739 = V5_i * V911_tmp439; 48956 npy_float64 V911_tmp740; 48957 V911_tmp740 = V5_i * V911_tmp440; 48958 npy_float64 V911_tmp741; 48959 V911_tmp741 = V5_i * V911_tmp441; 48960 npy_float64 V911_tmp742; 48961 V911_tmp742 = V5_i * V911_tmp442; 48962 npy_float64 V911_tmp743; 48963 V911_tmp743 = V5_i * V911_tmp443; 48964 npy_float64 V911_tmp744; 48965 V911_tmp744 = V5_i * V911_tmp444; 48966 npy_float64 V911_tmp745; 48967 V911_tmp745 = V5_i * V911_tmp445; 48968 npy_float64 V911_tmp746; 48969 V911_tmp746 = V5_i * V911_tmp446; 48970 npy_float64 V911_tmp747; 48971 V911_tmp747 = V5_i * V911_tmp447; 48972 npy_float64 V911_tmp748; 48973 V911_tmp748 = V5_i * V911_tmp448; 48974 npy_float64 V911_tmp749; 48975 V911_tmp749 = V5_i * V911_tmp449; 48976 npy_float64 V911_tmp750; 48977 V911_tmp750 = V5_i * V911_tmp450; 48978 npy_float64 V911_tmp751; 48979 V911_tmp751 = V609_i + V911_tmp749 + V911_tmp747 + V911_tmp745 + V911_tmp743 + V911_tmp741 + V911_tmp739 + V911_tmp737 + V911_tmp735 + V911_tmp733 + V911_tmp731 + V911_tmp729 + V911_tmp727 + V911_tmp725 + V911_tmp723 + V911_tmp721 + V911_tmp719 + V911_tmp717 + V911_tmp715 + V911_tmp713 + V911_tmp711 + V911_tmp709 + V911_tmp707 + V911_tmp705 + V911_tmp703 + V911_tmp701 + V911_tmp699 + V911_tmp697 + V911_tmp695 + V911_tmp693 + V911_tmp691 + V911_tmp689 + V911_tmp687 + V911_tmp685 + V911_tmp683 + V911_tmp681 + V911_tmp679 + V911_tmp677 + V911_tmp675 + V911_tmp673 + V911_tmp671 + V911_tmp669 + V911_tmp667 + V911_tmp665 + V911_tmp663 + V911_tmp661 + V911_tmp659 + V911_tmp657 + V911_tmp655 + V911_tmp653 + V911_tmp651 + V911_tmp649 + V911_tmp647 + V911_tmp645 + V911_tmp643 + V911_tmp641 + V911_tmp639 + V911_tmp637 + V911_tmp635 + V911_tmp633 + V911_tmp631 + V911_tmp629 + V911_tmp627 + V911_tmp625 + V911_tmp623 + V911_tmp621 + V911_tmp619 + V911_tmp617 + V911_tmp615 + V911_tmp613 + V911_tmp611 + V911_tmp609 + V911_tmp607 + V911_tmp605 + V911_tmp603 + V911_tmp601 + V911_tmp599 + V911_tmp597 + V911_tmp595 + V911_tmp593 + V911_tmp591 + V911_tmp589 + V911_tmp587 + V911_tmp585 + V911_tmp583 + V911_tmp581 + V911_tmp579 + V911_tmp577 + V911_tmp575 + V911_tmp573 + V911_tmp571 + V911_tmp569 + V911_tmp567 + V911_tmp565 + V911_tmp563 + V911_tmp561 + V911_tmp559 + V911_tmp557 + V911_tmp555 + V911_tmp553 + V911_tmp551 + V911_tmp549 + V911_tmp547 + V911_tmp545 + V911_tmp543 + V911_tmp541 + V911_tmp539 + V911_tmp537 + V911_tmp535 + V911_tmp533 + V911_tmp531 + V911_tmp529 + V911_tmp527 + V911_tmp525 + V911_tmp523 + V911_tmp521 + V911_tmp519 + V911_tmp517 + V911_tmp515 + V911_tmp513 + V911_tmp511 + V911_tmp509 + V911_tmp507 + V911_tmp505 + V911_tmp503 + V911_tmp501 + V911_tmp499 + V911_tmp497 + V911_tmp495 + V911_tmp493 + V911_tmp491 + V911_tmp489 + V911_tmp487 + V911_tmp485 + V911_tmp483 + V911_tmp481 + V911_tmp479 + V911_tmp477 + V911_tmp475 + V911_tmp473 + V911_tmp471 + V911_tmp469 + V911_tmp467 + V911_tmp465 + V911_tmp463 + V911_tmp461 + V911_tmp459 + V911_tmp457 + V911_tmp455 + V911_tmp453 + V911_tmp451; 48980 npy_float64 V911_tmp752; 48981 V911_tmp752 = V3_i + V911_tmp750 + V911_tmp748 + V911_tmp746 + V911_tmp744 + V911_tmp742 + V911_tmp740 + V911_tmp738 + V911_tmp736 + V911_tmp734 + V911_tmp732 + V911_tmp730 + V911_tmp728 + V911_tmp726 + V911_tmp724 + V911_tmp722 + V911_tmp720 + V911_tmp718 + V911_tmp716 + V911_tmp714 + V911_tmp712 + V911_tmp710 + V911_tmp708 + V911_tmp706 + V911_tmp704 + V911_tmp702 + V911_tmp700 + V911_tmp698 + V911_tmp696 + V911_tmp694 + V911_tmp692 + V911_tmp690 + V911_tmp688 + V911_tmp686 + V911_tmp684 + V911_tmp682 + V911_tmp680 + V911_tmp678 + V911_tmp676 + V911_tmp674 + V911_tmp672 + V911_tmp670 + V911_tmp668 + V911_tmp666 + V911_tmp664 + V911_tmp662 + V911_tmp660 + V911_tmp658 + V911_tmp656 + V911_tmp654 + V911_tmp652 + V911_tmp650 + V911_tmp648 + V911_tmp646 + V911_tmp644 + V911_tmp642 + V911_tmp640 + V911_tmp638 + V911_tmp636 + V911_tmp634 + V911_tmp632 + V911_tmp630 + V911_tmp628 + V911_tmp626 + V911_tmp624 + V911_tmp622 + V911_tmp620 + V911_tmp618 + V911_tmp616 + V911_tmp614 + V911_tmp612 + V911_tmp610 + V911_tmp608 + V911_tmp606 + V911_tmp604 + V911_tmp602 + V911_tmp600 + V911_tmp598 + V911_tmp596 + V911_tmp594 + V911_tmp592 + V911_tmp590 + V911_tmp588 + V911_tmp586 + V911_tmp584 + V911_tmp582 + V911_tmp580 + V911_tmp578 + V911_tmp576 + V911_tmp574 + V911_tmp572 + V911_tmp570 + V911_tmp568 + V911_tmp566 + V911_tmp564 + V911_tmp562 + V911_tmp560 + V911_tmp558 + V911_tmp556 + V911_tmp554 + V911_tmp552 + V911_tmp550 + V911_tmp548 + V911_tmp546 + V911_tmp544 + V911_tmp542 + V911_tmp540 + V911_tmp538 + V911_tmp536 + V911_tmp534 + V911_tmp532 + V911_tmp530 + V911_tmp528 + V911_tmp526 + V911_tmp524 + V911_tmp522 + V911_tmp520 + V911_tmp518 + V911_tmp516 + V911_tmp514 + V911_tmp512 + V911_tmp510 + V911_tmp508 + V911_tmp506 + V911_tmp504 + V911_tmp502 + V911_tmp500 + V911_tmp498 + V911_tmp496 + V911_tmp494 + V911_tmp492 + V911_tmp490 + V911_tmp488 + V911_tmp486 + V911_tmp484 + V911_tmp482 + V911_tmp480 + V911_tmp478 + V911_tmp476 + V911_tmp474 + V911_tmp472 + V911_tmp470 + V911_tmp468 + V911_tmp466 + V911_tmp464 + V911_tmp462 + V911_tmp460 + V911_tmp458 + V911_tmp456 + V911_tmp454 + V911_tmp452; 48982 V1_i = V911_tmp752 - V911_tmp751; 48983 } 48984 48985 48986 } 48987 __label_911: 48988 48989 double __DUMMY_911; 48990 48991 } 48992 __label_910: 48993 48994 if (V909) { 48995 Py_XDECREF(V909); 48996 } 48997 48998 {Py_XDECREF(py_V909);} 48999 49000 double __DUMMY_910; 49001 49002 } 49003 __label_908: 49004 49005 if (V907) { 49006 Py_XDECREF(V907); 49007 } 49008 49009 {Py_XDECREF(py_V907);} 49010 49011 double __DUMMY_908; 49012 49013 } 49014 __label_906: 49015 49016 if (V905) { 49017 Py_XDECREF(V905); 49018 } 49019 49020 {Py_XDECREF(py_V905);} 49021 49022 double __DUMMY_906; 49023 49024 } 49025 __label_904: 49026 49027 if (V903) { 49028 Py_XDECREF(V903); 49029 } 49030 49031 {Py_XDECREF(py_V903);} 49032 49033 double __DUMMY_904; 49034 49035 } 49036 __label_902: 49037 49038 if (V901) { 49039 Py_XDECREF(V901); 49040 } 49041 49042 {Py_XDECREF(py_V901);} 49043 49044 double __DUMMY_902; 49045 49046 } 49047 __label_900: 49048 49049 if (V899) { 49050 Py_XDECREF(V899); 49051 } 49052 49053 {Py_XDECREF(py_V899);} 49054 49055 double __DUMMY_900; 49056 49057 } 49058 __label_898: 49059 49060 if (V897) { 49061 Py_XDECREF(V897); 49062 } 49063 49064 {Py_XDECREF(py_V897);} 49065 49066 double __DUMMY_898; 49067 49068 } 49069 __label_896: 49070 49071 if (V895) { 49072 Py_XDECREF(V895); 49073 } 49074 49075 {Py_XDECREF(py_V895);} 49076 49077 double __DUMMY_896; 49078 49079 } 49080 __label_894: 49081 49082 if (V893) { 49083 Py_XDECREF(V893); 49084 } 49085 49086 {Py_XDECREF(py_V893);} 49087 49088 double __DUMMY_894; 49089 49090 } 49091 __label_892: 49092 49093 if (V891) { 49094 Py_XDECREF(V891); 49095 } 49096 49097 {Py_XDECREF(py_V891);} 49098 49099 double __DUMMY_892; 49100 49101 } 49102 __label_890: 49103 49104 if (V889) { 49105 Py_XDECREF(V889); 49106 } 49107 49108 {Py_XDECREF(py_V889);} 49109 49110 double __DUMMY_890; 49111 49112 } 49113 __label_888: 49114 49115 if (V887) { 49116 Py_XDECREF(V887); 49117 } 49118 49119 {Py_XDECREF(py_V887);} 49120 49121 double __DUMMY_888; 49122 49123 } 49124 __label_886: 49125 49126 if (V885) { 49127 Py_XDECREF(V885); 49128 } 49129 49130 {Py_XDECREF(py_V885);} 49131 49132 double __DUMMY_886; 49133 49134 } 49135 __label_884: 49136 49137 if (V883) { 49138 Py_XDECREF(V883); 49139 } 49140 49141 {Py_XDECREF(py_V883);} 49142 49143 double __DUMMY_884; 49144 49145 } 49146 __label_882: 49147 49148 if (V881) { 49149 Py_XDECREF(V881); 49150 } 49151 49152 {Py_XDECREF(py_V881);} 49153 49154 double __DUMMY_882; 49155 49156 } 49157 __label_880: 49158 49159 if (V879) { 49160 Py_XDECREF(V879); 49161 } 49162 49163 {Py_XDECREF(py_V879);} 49164 49165 double __DUMMY_880; 49166 49167 } 49168 __label_878: 49169 49170 if (V877) { 49171 Py_XDECREF(V877); 49172 } 49173 49174 {Py_XDECREF(py_V877);} 49175 49176 double __DUMMY_878; 49177 49178 } 49179 __label_876: 49180 49181 if (V875) { 49182 Py_XDECREF(V875); 49183 } 49184 49185 {Py_XDECREF(py_V875);} 49186 49187 double __DUMMY_876; 49188 49189 } 49190 __label_874: 49191 49192 if (V873) { 49193 Py_XDECREF(V873); 49194 } 49195 49196 {Py_XDECREF(py_V873);} 49197 49198 double __DUMMY_874; 49199 49200 } 49201 __label_872: 49202 49203 if (V871) { 49204 Py_XDECREF(V871); 49205 } 49206 49207 {Py_XDECREF(py_V871);} 49208 49209 double __DUMMY_872; 49210 49211 } 49212 __label_870: 49213 49214 if (V869) { 49215 Py_XDECREF(V869); 49216 } 49217 49218 {Py_XDECREF(py_V869);} 49219 49220 double __DUMMY_870; 49221 49222 } 49223 __label_868: 49224 49225 if (V867) { 49226 Py_XDECREF(V867); 49227 } 49228 49229 {Py_XDECREF(py_V867);} 49230 49231 double __DUMMY_868; 49232 49233 } 49234 __label_866: 49235 49236 if (V865) { 49237 Py_XDECREF(V865); 49238 } 49239 49240 {Py_XDECREF(py_V865);} 49241 49242 double __DUMMY_866; 49243 49244 } 49245 __label_864: 49246 49247 if (V863) { 49248 Py_XDECREF(V863); 49249 } 49250 49251 {Py_XDECREF(py_V863);} 49252 49253 double __DUMMY_864; 49254 49255 } 49256 __label_862: 49257 49258 if (V861) { 49259 Py_XDECREF(V861); 49260 } 49261 49262 {Py_XDECREF(py_V861);} 49263 49264 double __DUMMY_862; 49265 49266 } 49267 __label_860: 49268 49269 if (V859) { 49270 Py_XDECREF(V859); 49271 } 49272 49273 {Py_XDECREF(py_V859);} 49274 49275 double __DUMMY_860; 49276 49277 } 49278 __label_858: 49279 49280 if (V857) { 49281 Py_XDECREF(V857); 49282 } 49283 49284 {Py_XDECREF(py_V857);} 49285 49286 double __DUMMY_858; 49287 49288 } 49289 __label_856: 49290 49291 if (V855) { 49292 Py_XDECREF(V855); 49293 } 49294 49295 {Py_XDECREF(py_V855);} 49296 49297 double __DUMMY_856; 49298 49299 } 49300 __label_854: 49301 49302 if (V853) { 49303 Py_XDECREF(V853); 49304 } 49305 49306 {Py_XDECREF(py_V853);} 49307 49308 double __DUMMY_854; 49309 49310 } 49311 __label_852: 49312 49313 if (V851) { 49314 Py_XDECREF(V851); 49315 } 49316 49317 {Py_XDECREF(py_V851);} 49318 49319 double __DUMMY_852; 49320 49321 } 49322 __label_850: 49323 49324 if (V849) { 49325 Py_XDECREF(V849); 49326 } 49327 49328 {Py_XDECREF(py_V849);} 49329 49330 double __DUMMY_850; 49331 49332 } 49333 __label_848: 49334 49335 if (V847) { 49336 Py_XDECREF(V847); 49337 } 49338 49339 {Py_XDECREF(py_V847);} 49340 49341 double __DUMMY_848; 49342 49343 } 49344 __label_846: 49345 49346 if (V845) { 49347 Py_XDECREF(V845); 49348 } 49349 49350 {Py_XDECREF(py_V845);} 49351 49352 double __DUMMY_846; 49353 49354 } 49355 __label_844: 49356 49357 if (V843) { 49358 Py_XDECREF(V843); 49359 } 49360 49361 {Py_XDECREF(py_V843);} 49362 49363 double __DUMMY_844; 49364 49365 } 49366 __label_842: 49367 49368 if (V841) { 49369 Py_XDECREF(V841); 49370 } 49371 49372 {Py_XDECREF(py_V841);} 49373 49374 double __DUMMY_842; 49375 49376 } 49377 __label_840: 49378 49379 if (V839) { 49380 Py_XDECREF(V839); 49381 } 49382 49383 {Py_XDECREF(py_V839);} 49384 49385 double __DUMMY_840; 49386 49387 } 49388 __label_838: 49389 49390 if (V837) { 49391 Py_XDECREF(V837); 49392 } 49393 49394 {Py_XDECREF(py_V837);} 49395 49396 double __DUMMY_838; 49397 49398 } 49399 __label_836: 49400 49401 if (V835) { 49402 Py_XDECREF(V835); 49403 } 49404 49405 {Py_XDECREF(py_V835);} 49406 49407 double __DUMMY_836; 49408 49409 } 49410 __label_834: 49411 49412 if (V833) { 49413 Py_XDECREF(V833); 49414 } 49415 49416 {Py_XDECREF(py_V833);} 49417 49418 double __DUMMY_834; 49419 49420 } 49421 __label_832: 49422 49423 if (V831) { 49424 Py_XDECREF(V831); 49425 } 49426 49427 {Py_XDECREF(py_V831);} 49428 49429 double __DUMMY_832; 49430 49431 } 49432 __label_830: 49433 49434 if (V829) { 49435 Py_XDECREF(V829); 49436 } 49437 49438 {Py_XDECREF(py_V829);} 49439 49440 double __DUMMY_830; 49441 49442 } 49443 __label_828: 49444 49445 if (V827) { 49446 Py_XDECREF(V827); 49447 } 49448 49449 {Py_XDECREF(py_V827);} 49450 49451 double __DUMMY_828; 49452 49453 } 49454 __label_826: 49455 49456 if (V825) { 49457 Py_XDECREF(V825); 49458 } 49459 49460 {Py_XDECREF(py_V825);} 49461 49462 double __DUMMY_826; 49463 49464 } 49465 __label_824: 49466 49467 if (V823) { 49468 Py_XDECREF(V823); 49469 } 49470 49471 {Py_XDECREF(py_V823);} 49472 49473 double __DUMMY_824; 49474 49475 } 49476 __label_822: 49477 49478 if (V821) { 49479 Py_XDECREF(V821); 49480 } 49481 49482 {Py_XDECREF(py_V821);} 49483 49484 double __DUMMY_822; 49485 49486 } 49487 __label_820: 49488 49489 if (V819) { 49490 Py_XDECREF(V819); 49491 } 49492 49493 {Py_XDECREF(py_V819);} 49494 49495 double __DUMMY_820; 49496 49497 } 49498 __label_818: 49499 49500 if (V817) { 49501 Py_XDECREF(V817); 49502 } 49503 49504 {Py_XDECREF(py_V817);} 49505 49506 double __DUMMY_818; 49507 49508 } 49509 __label_816: 49510 49511 if (V815) { 49512 Py_XDECREF(V815); 49513 } 49514 49515 {Py_XDECREF(py_V815);} 49516 49517 double __DUMMY_816; 49518 49519 } 49520 __label_814: 49521 49522 if (V813) { 49523 Py_XDECREF(V813); 49524 } 49525 49526 {Py_XDECREF(py_V813);} 49527 49528 double __DUMMY_814; 49529 49530 } 49531 __label_812: 49532 49533 if (V811) { 49534 Py_XDECREF(V811); 49535 } 49536 49537 {Py_XDECREF(py_V811);} 49538 49539 double __DUMMY_812; 49540 49541 } 49542 __label_810: 49543 49544 if (V809) { 49545 Py_XDECREF(V809); 49546 } 49547 49548 {Py_XDECREF(py_V809);} 49549 49550 double __DUMMY_810; 49551 49552 } 49553 __label_808: 49554 49555 if (V807) { 49556 Py_XDECREF(V807); 49557 } 49558 49559 {Py_XDECREF(py_V807);} 49560 49561 double __DUMMY_808; 49562 49563 } 49564 __label_806: 49565 49566 if (V805) { 49567 Py_XDECREF(V805); 49568 } 49569 49570 {Py_XDECREF(py_V805);} 49571 49572 double __DUMMY_806; 49573 49574 } 49575 __label_804: 49576 49577 if (V803) { 49578 Py_XDECREF(V803); 49579 } 49580 49581 {Py_XDECREF(py_V803);} 49582 49583 double __DUMMY_804; 49584 49585 } 49586 __label_802: 49587 49588 if (V801) { 49589 Py_XDECREF(V801); 49590 } 49591 49592 {Py_XDECREF(py_V801);} 49593 49594 double __DUMMY_802; 49595 49596 } 49597 __label_800: 49598 49599 if (V799) { 49600 Py_XDECREF(V799); 49601 } 49602 49603 {Py_XDECREF(py_V799);} 49604 49605 double __DUMMY_800; 49606 49607 } 49608 __label_798: 49609 49610 if (V797) { 49611 Py_XDECREF(V797); 49612 } 49613 49614 {Py_XDECREF(py_V797);} 49615 49616 double __DUMMY_798; 49617 49618 } 49619 __label_796: 49620 49621 if (V795) { 49622 Py_XDECREF(V795); 49623 } 49624 49625 {Py_XDECREF(py_V795);} 49626 49627 double __DUMMY_796; 49628 49629 } 49630 __label_794: 49631 49632 if (V793) { 49633 Py_XDECREF(V793); 49634 } 49635 49636 {Py_XDECREF(py_V793);} 49637 49638 double __DUMMY_794; 49639 49640 } 49641 __label_792: 49642 49643 if (V791) { 49644 Py_XDECREF(V791); 49645 } 49646 49647 {Py_XDECREF(py_V791);} 49648 49649 double __DUMMY_792; 49650 49651 } 49652 __label_790: 49653 49654 if (V789) { 49655 Py_XDECREF(V789); 49656 } 49657 49658 {Py_XDECREF(py_V789);} 49659 49660 double __DUMMY_790; 49661 49662 } 49663 __label_788: 49664 49665 if (V787) { 49666 Py_XDECREF(V787); 49667 } 49668 49669 {Py_XDECREF(py_V787);} 49670 49671 double __DUMMY_788; 49672 49673 } 49674 __label_786: 49675 49676 if (V785) { 49677 Py_XDECREF(V785); 49678 } 49679 49680 {Py_XDECREF(py_V785);} 49681 49682 double __DUMMY_786; 49683 49684 } 49685 __label_784: 49686 49687 if (V783) { 49688 Py_XDECREF(V783); 49689 } 49690 49691 {Py_XDECREF(py_V783);} 49692 49693 double __DUMMY_784; 49694 49695 } 49696 __label_782: 49697 49698 if (V781) { 49699 Py_XDECREF(V781); 49700 } 49701 49702 {Py_XDECREF(py_V781);} 49703 49704 double __DUMMY_782; 49705 49706 } 49707 __label_780: 49708 49709 if (V779) { 49710 Py_XDECREF(V779); 49711 } 49712 49713 {Py_XDECREF(py_V779);} 49714 49715 double __DUMMY_780; 49716 49717 } 49718 __label_778: 49719 49720 if (V777) { 49721 Py_XDECREF(V777); 49722 } 49723 49724 {Py_XDECREF(py_V777);} 49725 49726 double __DUMMY_778; 49727 49728 } 49729 __label_776: 49730 49731 if (V775) { 49732 Py_XDECREF(V775); 49733 } 49734 49735 {Py_XDECREF(py_V775);} 49736 49737 double __DUMMY_776; 49738 49739 } 49740 __label_774: 49741 49742 if (V773) { 49743 Py_XDECREF(V773); 49744 } 49745 49746 {Py_XDECREF(py_V773);} 49747 49748 double __DUMMY_774; 49749 49750 } 49751 __label_772: 49752 49753 if (V771) { 49754 Py_XDECREF(V771); 49755 } 49756 49757 {Py_XDECREF(py_V771);} 49758 49759 double __DUMMY_772; 49760 49761 } 49762 __label_770: 49763 49764 if (V769) { 49765 Py_XDECREF(V769); 49766 } 49767 49768 {Py_XDECREF(py_V769);} 49769 49770 double __DUMMY_770; 49771 49772 } 49773 __label_768: 49774 49775 if (V767) { 49776 Py_XDECREF(V767); 49777 } 49778 49779 {Py_XDECREF(py_V767);} 49780 49781 double __DUMMY_768; 49782 49783 } 49784 __label_766: 49785 49786 if (V765) { 49787 Py_XDECREF(V765); 49788 } 49789 49790 {Py_XDECREF(py_V765);} 49791 49792 double __DUMMY_766; 49793 49794 } 49795 __label_764: 49796 49797 if (V763) { 49798 Py_XDECREF(V763); 49799 } 49800 49801 {Py_XDECREF(py_V763);} 49802 49803 double __DUMMY_764; 49804 49805 } 49806 __label_762: 49807 49808 if (V761) { 49809 Py_XDECREF(V761); 49810 } 49811 49812 {Py_XDECREF(py_V761);} 49813 49814 double __DUMMY_762; 49815 49816 } 49817 __label_760: 49818 49819 if (V759) { 49820 Py_XDECREF(V759); 49821 } 49822 49823 {Py_XDECREF(py_V759);} 49824 49825 double __DUMMY_760; 49826 49827 } 49828 __label_758: 49829 49830 if (V757) { 49831 Py_XDECREF(V757); 49832 } 49833 49834 {Py_XDECREF(py_V757);} 49835 49836 double __DUMMY_758; 49837 49838 } 49839 __label_756: 49840 49841 if (V755) { 49842 Py_XDECREF(V755); 49843 } 49844 49845 {Py_XDECREF(py_V755);} 49846 49847 double __DUMMY_756; 49848 49849 } 49850 __label_754: 49851 49852 if (V753) { 49853 Py_XDECREF(V753); 49854 } 49855 49856 {Py_XDECREF(py_V753);} 49857 49858 double __DUMMY_754; 49859 49860 } 49861 __label_752: 49862 49863 if (V751) { 49864 Py_XDECREF(V751); 49865 } 49866 49867 {Py_XDECREF(py_V751);} 49868 49869 double __DUMMY_752; 49870 49871 } 49872 __label_750: 49873 49874 if (V749) { 49875 Py_XDECREF(V749); 49876 } 49877 49878 {Py_XDECREF(py_V749);} 49879 49880 double __DUMMY_750; 49881 49882 } 49883 __label_748: 49884 49885 if (V747) { 49886 Py_XDECREF(V747); 49887 } 49888 49889 {Py_XDECREF(py_V747);} 49890 49891 double __DUMMY_748; 49892 49893 } 49894 __label_746: 49895 49896 if (V745) { 49897 Py_XDECREF(V745); 49898 } 49899 49900 {Py_XDECREF(py_V745);} 49901 49902 double __DUMMY_746; 49903 49904 } 49905 __label_744: 49906 49907 if (V743) { 49908 Py_XDECREF(V743); 49909 } 49910 49911 {Py_XDECREF(py_V743);} 49912 49913 double __DUMMY_744; 49914 49915 } 49916 __label_742: 49917 49918 if (V741) { 49919 Py_XDECREF(V741); 49920 } 49921 49922 {Py_XDECREF(py_V741);} 49923 49924 double __DUMMY_742; 49925 49926 } 49927 __label_740: 49928 49929 if (V739) { 49930 Py_XDECREF(V739); 49931 } 49932 49933 {Py_XDECREF(py_V739);} 49934 49935 double __DUMMY_740; 49936 49937 } 49938 __label_738: 49939 49940 if (V737) { 49941 Py_XDECREF(V737); 49942 } 49943 49944 {Py_XDECREF(py_V737);} 49945 49946 double __DUMMY_738; 49947 49948 } 49949 __label_736: 49950 49951 if (V735) { 49952 Py_XDECREF(V735); 49953 } 49954 49955 {Py_XDECREF(py_V735);} 49956 49957 double __DUMMY_736; 49958 49959 } 49960 __label_734: 49961 49962 if (V733) { 49963 Py_XDECREF(V733); 49964 } 49965 49966 {Py_XDECREF(py_V733);} 49967 49968 double __DUMMY_734; 49969 49970 } 49971 __label_732: 49972 49973 if (V731) { 49974 Py_XDECREF(V731); 49975 } 49976 49977 {Py_XDECREF(py_V731);} 49978 49979 double __DUMMY_732; 49980 49981 } 49982 __label_730: 49983 49984 if (V729) { 49985 Py_XDECREF(V729); 49986 } 49987 49988 {Py_XDECREF(py_V729);} 49989 49990 double __DUMMY_730; 49991 49992 } 49993 __label_728: 49994 49995 if (V727) { 49996 Py_XDECREF(V727); 49997 } 49998 49999 {Py_XDECREF(py_V727);} 50000 50001 double __DUMMY_728; 50002 50003 } 50004 __label_726: 50005 50006 if (V725) { 50007 Py_XDECREF(V725); 50008 } 50009 50010 {Py_XDECREF(py_V725);} 50011 50012 double __DUMMY_726; 50013 50014 } 50015 __label_724: 50016 50017 if (V723) { 50018 Py_XDECREF(V723); 50019 } 50020 50021 {Py_XDECREF(py_V723);} 50022 50023 double __DUMMY_724; 50024 50025 } 50026 __label_722: 50027 50028 if (V721) { 50029 Py_XDECREF(V721); 50030 } 50031 50032 {Py_XDECREF(py_V721);} 50033 50034 double __DUMMY_722; 50035 50036 } 50037 __label_720: 50038 50039 if (V719) { 50040 Py_XDECREF(V719); 50041 } 50042 50043 {Py_XDECREF(py_V719);} 50044 50045 double __DUMMY_720; 50046 50047 } 50048 __label_718: 50049 50050 if (V717) { 50051 Py_XDECREF(V717); 50052 } 50053 50054 {Py_XDECREF(py_V717);} 50055 50056 double __DUMMY_718; 50057 50058 } 50059 __label_716: 50060 50061 if (V715) { 50062 Py_XDECREF(V715); 50063 } 50064 50065 {Py_XDECREF(py_V715);} 50066 50067 double __DUMMY_716; 50068 50069 } 50070 __label_714: 50071 50072 if (V713) { 50073 Py_XDECREF(V713); 50074 } 50075 50076 {Py_XDECREF(py_V713);} 50077 50078 double __DUMMY_714; 50079 50080 } 50081 __label_712: 50082 50083 if (V711) { 50084 Py_XDECREF(V711); 50085 } 50086 50087 {Py_XDECREF(py_V711);} 50088 50089 double __DUMMY_712; 50090 50091 } 50092 __label_710: 50093 50094 if (V709) { 50095 Py_XDECREF(V709); 50096 } 50097 50098 {Py_XDECREF(py_V709);} 50099 50100 double __DUMMY_710; 50101 50102 } 50103 __label_708: 50104 50105 if (V707) { 50106 Py_XDECREF(V707); 50107 } 50108 50109 {Py_XDECREF(py_V707);} 50110 50111 double __DUMMY_708; 50112 50113 } 50114 __label_706: 50115 50116 if (V705) { 50117 Py_XDECREF(V705); 50118 } 50119 50120 {Py_XDECREF(py_V705);} 50121 50122 double __DUMMY_706; 50123 50124 } 50125 __label_704: 50126 50127 if (V703) { 50128 Py_XDECREF(V703); 50129 } 50130 50131 {Py_XDECREF(py_V703);} 50132 50133 double __DUMMY_704; 50134 50135 } 50136 __label_702: 50137 50138 if (V701) { 50139 Py_XDECREF(V701); 50140 } 50141 50142 {Py_XDECREF(py_V701);} 50143 50144 double __DUMMY_702; 50145 50146 } 50147 __label_700: 50148 50149 if (V699) { 50150 Py_XDECREF(V699); 50151 } 50152 50153 {Py_XDECREF(py_V699);} 50154 50155 double __DUMMY_700; 50156 50157 } 50158 __label_698: 50159 50160 if (V697) { 50161 Py_XDECREF(V697); 50162 } 50163 50164 {Py_XDECREF(py_V697);} 50165 50166 double __DUMMY_698; 50167 50168 } 50169 __label_696: 50170 50171 if (V695) { 50172 Py_XDECREF(V695); 50173 } 50174 50175 {Py_XDECREF(py_V695);} 50176 50177 double __DUMMY_696; 50178 50179 } 50180 __label_694: 50181 50182 if (V693) { 50183 Py_XDECREF(V693); 50184 } 50185 50186 {Py_XDECREF(py_V693);} 50187 50188 double __DUMMY_694; 50189 50190 } 50191 __label_692: 50192 50193 if (V691) { 50194 Py_XDECREF(V691); 50195 } 50196 50197 {Py_XDECREF(py_V691);} 50198 50199 double __DUMMY_692; 50200 50201 } 50202 __label_690: 50203 50204 if (V689) { 50205 Py_XDECREF(V689); 50206 } 50207 50208 {Py_XDECREF(py_V689);} 50209 50210 double __DUMMY_690; 50211 50212 } 50213 __label_688: 50214 50215 if (V687) { 50216 Py_XDECREF(V687); 50217 } 50218 50219 {Py_XDECREF(py_V687);} 50220 50221 double __DUMMY_688; 50222 50223 } 50224 __label_686: 50225 50226 if (V685) { 50227 Py_XDECREF(V685); 50228 } 50229 50230 {Py_XDECREF(py_V685);} 50231 50232 double __DUMMY_686; 50233 50234 } 50235 __label_684: 50236 50237 if (V683) { 50238 Py_XDECREF(V683); 50239 } 50240 50241 {Py_XDECREF(py_V683);} 50242 50243 double __DUMMY_684; 50244 50245 } 50246 __label_682: 50247 50248 if (V681) { 50249 Py_XDECREF(V681); 50250 } 50251 50252 {Py_XDECREF(py_V681);} 50253 50254 double __DUMMY_682; 50255 50256 } 50257 __label_680: 50258 50259 if (V679) { 50260 Py_XDECREF(V679); 50261 } 50262 50263 {Py_XDECREF(py_V679);} 50264 50265 double __DUMMY_680; 50266 50267 } 50268 __label_678: 50269 50270 if (V677) { 50271 Py_XDECREF(V677); 50272 } 50273 50274 {Py_XDECREF(py_V677);} 50275 50276 double __DUMMY_678; 50277 50278 } 50279 __label_676: 50280 50281 if (V675) { 50282 Py_XDECREF(V675); 50283 } 50284 50285 {Py_XDECREF(py_V675);} 50286 50287 double __DUMMY_676; 50288 50289 } 50290 __label_674: 50291 50292 if (V673) { 50293 Py_XDECREF(V673); 50294 } 50295 50296 {Py_XDECREF(py_V673);} 50297 50298 double __DUMMY_674; 50299 50300 } 50301 __label_672: 50302 50303 if (V671) { 50304 Py_XDECREF(V671); 50305 } 50306 50307 {Py_XDECREF(py_V671);} 50308 50309 double __DUMMY_672; 50310 50311 } 50312 __label_670: 50313 50314 if (V669) { 50315 Py_XDECREF(V669); 50316 } 50317 50318 {Py_XDECREF(py_V669);} 50319 50320 double __DUMMY_670; 50321 50322 } 50323 __label_668: 50324 50325 if (V667) { 50326 Py_XDECREF(V667); 50327 } 50328 50329 {Py_XDECREF(py_V667);} 50330 50331 double __DUMMY_668; 50332 50333 } 50334 __label_666: 50335 50336 if (V665) { 50337 Py_XDECREF(V665); 50338 } 50339 50340 {Py_XDECREF(py_V665);} 50341 50342 double __DUMMY_666; 50343 50344 } 50345 __label_664: 50346 50347 if (V663) { 50348 Py_XDECREF(V663); 50349 } 50350 50351 {Py_XDECREF(py_V663);} 50352 50353 double __DUMMY_664; 50354 50355 } 50356 __label_662: 50357 50358 if (V661) { 50359 Py_XDECREF(V661); 50360 } 50361 50362 {Py_XDECREF(py_V661);} 50363 50364 double __DUMMY_662; 50365 50366 } 50367 __label_660: 50368 50369 if (V659) { 50370 Py_XDECREF(V659); 50371 } 50372 50373 {Py_XDECREF(py_V659);} 50374 50375 double __DUMMY_660; 50376 50377 } 50378 __label_658: 50379 50380 if (V657) { 50381 Py_XDECREF(V657); 50382 } 50383 50384 {Py_XDECREF(py_V657);} 50385 50386 double __DUMMY_658; 50387 50388 } 50389 __label_656: 50390 50391 if (V655) { 50392 Py_XDECREF(V655); 50393 } 50394 50395 {Py_XDECREF(py_V655);} 50396 50397 double __DUMMY_656; 50398 50399 } 50400 __label_654: 50401 50402 if (V653) { 50403 Py_XDECREF(V653); 50404 } 50405 50406 {Py_XDECREF(py_V653);} 50407 50408 double __DUMMY_654; 50409 50410 } 50411 __label_652: 50412 50413 if (V651) { 50414 Py_XDECREF(V651); 50415 } 50416 50417 {Py_XDECREF(py_V651);} 50418 50419 double __DUMMY_652; 50420 50421 } 50422 __label_650: 50423 50424 if (V649) { 50425 Py_XDECREF(V649); 50426 } 50427 50428 {Py_XDECREF(py_V649);} 50429 50430 double __DUMMY_650; 50431 50432 } 50433 __label_648: 50434 50435 if (V647) { 50436 Py_XDECREF(V647); 50437 } 50438 50439 {Py_XDECREF(py_V647);} 50440 50441 double __DUMMY_648; 50442 50443 } 50444 __label_646: 50445 50446 if (V645) { 50447 Py_XDECREF(V645); 50448 } 50449 50450 {Py_XDECREF(py_V645);} 50451 50452 double __DUMMY_646; 50453 50454 } 50455 __label_644: 50456 50457 if (V643) { 50458 Py_XDECREF(V643); 50459 } 50460 50461 {Py_XDECREF(py_V643);} 50462 50463 double __DUMMY_644; 50464 50465 } 50466 __label_642: 50467 50468 if (V641) { 50469 Py_XDECREF(V641); 50470 } 50471 50472 {Py_XDECREF(py_V641);} 50473 50474 double __DUMMY_642; 50475 50476 } 50477 __label_640: 50478 50479 if (V639) { 50480 Py_XDECREF(V639); 50481 } 50482 50483 {Py_XDECREF(py_V639);} 50484 50485 double __DUMMY_640; 50486 50487 } 50488 __label_638: 50489 50490 if (V637) { 50491 Py_XDECREF(V637); 50492 } 50493 50494 {Py_XDECREF(py_V637);} 50495 50496 double __DUMMY_638; 50497 50498 } 50499 __label_636: 50500 50501 if (V635) { 50502 Py_XDECREF(V635); 50503 } 50504 50505 {Py_XDECREF(py_V635);} 50506 50507 double __DUMMY_636; 50508 50509 } 50510 __label_634: 50511 50512 if (V633) { 50513 Py_XDECREF(V633); 50514 } 50515 50516 {Py_XDECREF(py_V633);} 50517 50518 double __DUMMY_634; 50519 50520 } 50521 __label_632: 50522 50523 if (V631) { 50524 Py_XDECREF(V631); 50525 } 50526 50527 {Py_XDECREF(py_V631);} 50528 50529 double __DUMMY_632; 50530 50531 } 50532 __label_630: 50533 50534 if (V629) { 50535 Py_XDECREF(V629); 50536 } 50537 50538 {Py_XDECREF(py_V629);} 50539 50540 double __DUMMY_630; 50541 50542 } 50543 __label_628: 50544 50545 if (V627) { 50546 Py_XDECREF(V627); 50547 } 50548 50549 {Py_XDECREF(py_V627);} 50550 50551 double __DUMMY_628; 50552 50553 } 50554 __label_626: 50555 50556 if (V625) { 50557 Py_XDECREF(V625); 50558 } 50559 50560 {Py_XDECREF(py_V625);} 50561 50562 double __DUMMY_626; 50563 50564 } 50565 __label_624: 50566 50567 if (V623) { 50568 Py_XDECREF(V623); 50569 } 50570 50571 {Py_XDECREF(py_V623);} 50572 50573 double __DUMMY_624; 50574 50575 } 50576 __label_622: 50577 50578 if (V621) { 50579 Py_XDECREF(V621); 50580 } 50581 50582 {Py_XDECREF(py_V621);} 50583 50584 double __DUMMY_622; 50585 50586 } 50587 __label_620: 50588 50589 if (V619) { 50590 Py_XDECREF(V619); 50591 } 50592 50593 {Py_XDECREF(py_V619);} 50594 50595 double __DUMMY_620; 50596 50597 } 50598 __label_618: 50599 50600 if (V617) { 50601 Py_XDECREF(V617); 50602 } 50603 50604 {Py_XDECREF(py_V617);} 50605 50606 double __DUMMY_618; 50607 50608 } 50609 __label_616: 50610 50611 if (V615) { 50612 Py_XDECREF(V615); 50613 } 50614 50615 {Py_XDECREF(py_V615);} 50616 50617 double __DUMMY_616; 50618 50619 } 50620 __label_614: 50621 50622 if (V613) { 50623 Py_XDECREF(V613); 50624 } 50625 50626 {Py_XDECREF(py_V613);} 50627 50628 double __DUMMY_614; 50629 50630 } 50631 __label_612: 50632 50633 if (V611) { 50634 Py_XDECREF(V611); 50635 } 50636 50637 {Py_XDECREF(py_V611);} 50638 50639 double __DUMMY_612; 50640 50641 } 50642 __label_610: 50643 50644 if (V609) { 50645 Py_XDECREF(V609); 50646 } 50647 50648 {Py_XDECREF(py_V609);} 50649 50650 double __DUMMY_610; 50651 50652 } 50653 __label_608: 50654 50655 if (V607) { 50656 Py_XDECREF(V607); 50657 } 50658 50659 {Py_XDECREF(py_V607);} 50660 50661 double __DUMMY_608; 50662 50663 } 50664 __label_606: 50665 50666 if (V605) { 50667 Py_XDECREF(V605); 50668 } 50669 50670 {Py_XDECREF(py_V605);} 50671 50672 double __DUMMY_606; 50673 50674 } 50675 __label_604: 50676 50677 if (V603) { 50678 Py_XDECREF(V603); 50679 } 50680 50681 {Py_XDECREF(py_V603);} 50682 50683 double __DUMMY_604; 50684 50685 } 50686 __label_602: 50687 50688 if (V601) { 50689 Py_XDECREF(V601); 50690 } 50691 50692 {Py_XDECREF(py_V601);} 50693 50694 double __DUMMY_602; 50695 50696 } 50697 __label_600: 50698 50699 if (V599) { 50700 Py_XDECREF(V599); 50701 } 50702 50703 {Py_XDECREF(py_V599);} 50704 50705 double __DUMMY_600; 50706 50707 } 50708 __label_598: 50709 50710 if (V597) { 50711 Py_XDECREF(V597); 50712 } 50713 50714 {Py_XDECREF(py_V597);} 50715 50716 double __DUMMY_598; 50717 50718 } 50719 __label_596: 50720 50721 if (V595) { 50722 Py_XDECREF(V595); 50723 } 50724 50725 {Py_XDECREF(py_V595);} 50726 50727 double __DUMMY_596; 50728 50729 } 50730 __label_594: 50731 50732 if (V593) { 50733 Py_XDECREF(V593); 50734 } 50735 50736 {Py_XDECREF(py_V593);} 50737 50738 double __DUMMY_594; 50739 50740 } 50741 __label_592: 50742 50743 if (V591) { 50744 Py_XDECREF(V591); 50745 } 50746 50747 {Py_XDECREF(py_V591);} 50748 50749 double __DUMMY_592; 50750 50751 } 50752 __label_590: 50753 50754 if (V589) { 50755 Py_XDECREF(V589); 50756 } 50757 50758 {Py_XDECREF(py_V589);} 50759 50760 double __DUMMY_590; 50761 50762 } 50763 __label_588: 50764 50765 if (V587) { 50766 Py_XDECREF(V587); 50767 } 50768 50769 {Py_XDECREF(py_V587);} 50770 50771 double __DUMMY_588; 50772 50773 } 50774 __label_586: 50775 50776 if (V585) { 50777 Py_XDECREF(V585); 50778 } 50779 50780 {Py_XDECREF(py_V585);} 50781 50782 double __DUMMY_586; 50783 50784 } 50785 __label_584: 50786 50787 if (V583) { 50788 Py_XDECREF(V583); 50789 } 50790 50791 {Py_XDECREF(py_V583);} 50792 50793 double __DUMMY_584; 50794 50795 } 50796 __label_582: 50797 50798 if (V581) { 50799 Py_XDECREF(V581); 50800 } 50801 50802 {Py_XDECREF(py_V581);} 50803 50804 double __DUMMY_582; 50805 50806 } 50807 __label_580: 50808 50809 if (V579) { 50810 Py_XDECREF(V579); 50811 } 50812 50813 {Py_XDECREF(py_V579);} 50814 50815 double __DUMMY_580; 50816 50817 } 50818 __label_578: 50819 50820 if (V577) { 50821 Py_XDECREF(V577); 50822 } 50823 50824 {Py_XDECREF(py_V577);} 50825 50826 double __DUMMY_578; 50827 50828 } 50829 __label_576: 50830 50831 if (V575) { 50832 Py_XDECREF(V575); 50833 } 50834 50835 {Py_XDECREF(py_V575);} 50836 50837 double __DUMMY_576; 50838 50839 } 50840 __label_574: 50841 50842 if (V573) { 50843 Py_XDECREF(V573); 50844 } 50845 50846 {Py_XDECREF(py_V573);} 50847 50848 double __DUMMY_574; 50849 50850 } 50851 __label_572: 50852 50853 if (V571) { 50854 Py_XDECREF(V571); 50855 } 50856 50857 {Py_XDECREF(py_V571);} 50858 50859 double __DUMMY_572; 50860 50861 } 50862 __label_570: 50863 50864 if (V569) { 50865 Py_XDECREF(V569); 50866 } 50867 50868 {Py_XDECREF(py_V569);} 50869 50870 double __DUMMY_570; 50871 50872 } 50873 __label_568: 50874 50875 if (V567) { 50876 Py_XDECREF(V567); 50877 } 50878 50879 {Py_XDECREF(py_V567);} 50880 50881 double __DUMMY_568; 50882 50883 } 50884 __label_566: 50885 50886 if (V565) { 50887 Py_XDECREF(V565); 50888 } 50889 50890 {Py_XDECREF(py_V565);} 50891 50892 double __DUMMY_566; 50893 50894 } 50895 __label_564: 50896 50897 if (V563) { 50898 Py_XDECREF(V563); 50899 } 50900 50901 {Py_XDECREF(py_V563);} 50902 50903 double __DUMMY_564; 50904 50905 } 50906 __label_562: 50907 50908 if (V561) { 50909 Py_XDECREF(V561); 50910 } 50911 50912 {Py_XDECREF(py_V561);} 50913 50914 double __DUMMY_562; 50915 50916 } 50917 __label_560: 50918 50919 if (V559) { 50920 Py_XDECREF(V559); 50921 } 50922 50923 {Py_XDECREF(py_V559);} 50924 50925 double __DUMMY_560; 50926 50927 } 50928 __label_558: 50929 50930 if (V557) { 50931 Py_XDECREF(V557); 50932 } 50933 50934 {Py_XDECREF(py_V557);} 50935 50936 double __DUMMY_558; 50937 50938 } 50939 __label_556: 50940 50941 if (V555) { 50942 Py_XDECREF(V555); 50943 } 50944 50945 {Py_XDECREF(py_V555);} 50946 50947 double __DUMMY_556; 50948 50949 } 50950 __label_554: 50951 50952 if (V553) { 50953 Py_XDECREF(V553); 50954 } 50955 50956 {Py_XDECREF(py_V553);} 50957 50958 double __DUMMY_554; 50959 50960 } 50961 __label_552: 50962 50963 if (V551) { 50964 Py_XDECREF(V551); 50965 } 50966 50967 {Py_XDECREF(py_V551);} 50968 50969 double __DUMMY_552; 50970 50971 } 50972 __label_550: 50973 50974 if (V549) { 50975 Py_XDECREF(V549); 50976 } 50977 50978 {Py_XDECREF(py_V549);} 50979 50980 double __DUMMY_550; 50981 50982 } 50983 __label_548: 50984 50985 if (V547) { 50986 Py_XDECREF(V547); 50987 } 50988 50989 {Py_XDECREF(py_V547);} 50990 50991 double __DUMMY_548; 50992 50993 } 50994 __label_546: 50995 50996 if (V545) { 50997 Py_XDECREF(V545); 50998 } 50999 51000 {Py_XDECREF(py_V545);} 51001 51002 double __DUMMY_546; 51003 51004 } 51005 __label_544: 51006 51007 if (V543) { 51008 Py_XDECREF(V543); 51009 } 51010 51011 {Py_XDECREF(py_V543);} 51012 51013 double __DUMMY_544; 51014 51015 } 51016 __label_542: 51017 51018 if (V541) { 51019 Py_XDECREF(V541); 51020 } 51021 51022 {Py_XDECREF(py_V541);} 51023 51024 double __DUMMY_542; 51025 51026 } 51027 __label_540: 51028 51029 if (V539) { 51030 Py_XDECREF(V539); 51031 } 51032 51033 {Py_XDECREF(py_V539);} 51034 51035 double __DUMMY_540; 51036 51037 } 51038 __label_538: 51039 51040 if (V537) { 51041 Py_XDECREF(V537); 51042 } 51043 51044 {Py_XDECREF(py_V537);} 51045 51046 double __DUMMY_538; 51047 51048 } 51049 __label_536: 51050 51051 if (V535) { 51052 Py_XDECREF(V535); 51053 } 51054 51055 {Py_XDECREF(py_V535);} 51056 51057 double __DUMMY_536; 51058 51059 } 51060 __label_534: 51061 51062 if (V533) { 51063 Py_XDECREF(V533); 51064 } 51065 51066 {Py_XDECREF(py_V533);} 51067 51068 double __DUMMY_534; 51069 51070 } 51071 __label_532: 51072 51073 if (V531) { 51074 Py_XDECREF(V531); 51075 } 51076 51077 {Py_XDECREF(py_V531);} 51078 51079 double __DUMMY_532; 51080 51081 } 51082 __label_530: 51083 51084 if (V529) { 51085 Py_XDECREF(V529); 51086 } 51087 51088 {Py_XDECREF(py_V529);} 51089 51090 double __DUMMY_530; 51091 51092 } 51093 __label_528: 51094 51095 if (V527) { 51096 Py_XDECREF(V527); 51097 } 51098 51099 {Py_XDECREF(py_V527);} 51100 51101 double __DUMMY_528; 51102 51103 } 51104 __label_526: 51105 51106 if (V525) { 51107 Py_XDECREF(V525); 51108 } 51109 51110 {Py_XDECREF(py_V525);} 51111 51112 double __DUMMY_526; 51113 51114 } 51115 __label_524: 51116 51117 if (V523) { 51118 Py_XDECREF(V523); 51119 } 51120 51121 {Py_XDECREF(py_V523);} 51122 51123 double __DUMMY_524; 51124 51125 } 51126 __label_522: 51127 51128 if (V521) { 51129 Py_XDECREF(V521); 51130 } 51131 51132 {Py_XDECREF(py_V521);} 51133 51134 double __DUMMY_522; 51135 51136 } 51137 __label_520: 51138 51139 if (V519) { 51140 Py_XDECREF(V519); 51141 } 51142 51143 {Py_XDECREF(py_V519);} 51144 51145 double __DUMMY_520; 51146 51147 } 51148 __label_518: 51149 51150 if (V517) { 51151 Py_XDECREF(V517); 51152 } 51153 51154 {Py_XDECREF(py_V517);} 51155 51156 double __DUMMY_518; 51157 51158 } 51159 __label_516: 51160 51161 if (V515) { 51162 Py_XDECREF(V515); 51163 } 51164 51165 {Py_XDECREF(py_V515);} 51166 51167 double __DUMMY_516; 51168 51169 } 51170 __label_514: 51171 51172 if (V513) { 51173 Py_XDECREF(V513); 51174 } 51175 51176 {Py_XDECREF(py_V513);} 51177 51178 double __DUMMY_514; 51179 51180 } 51181 __label_512: 51182 51183 if (V511) { 51184 Py_XDECREF(V511); 51185 } 51186 51187 {Py_XDECREF(py_V511);} 51188 51189 double __DUMMY_512; 51190 51191 } 51192 __label_510: 51193 51194 if (V509) { 51195 Py_XDECREF(V509); 51196 } 51197 51198 {Py_XDECREF(py_V509);} 51199 51200 double __DUMMY_510; 51201 51202 } 51203 __label_508: 51204 51205 if (V507) { 51206 Py_XDECREF(V507); 51207 } 51208 51209 {Py_XDECREF(py_V507);} 51210 51211 double __DUMMY_508; 51212 51213 } 51214 __label_506: 51215 51216 if (V505) { 51217 Py_XDECREF(V505); 51218 } 51219 51220 {Py_XDECREF(py_V505);} 51221 51222 double __DUMMY_506; 51223 51224 } 51225 __label_504: 51226 51227 if (V503) { 51228 Py_XDECREF(V503); 51229 } 51230 51231 {Py_XDECREF(py_V503);} 51232 51233 double __DUMMY_504; 51234 51235 } 51236 __label_502: 51237 51238 if (V501) { 51239 Py_XDECREF(V501); 51240 } 51241 51242 {Py_XDECREF(py_V501);} 51243 51244 double __DUMMY_502; 51245 51246 } 51247 __label_500: 51248 51249 if (V499) { 51250 Py_XDECREF(V499); 51251 } 51252 51253 {Py_XDECREF(py_V499);} 51254 51255 double __DUMMY_500; 51256 51257 } 51258 __label_498: 51259 51260 if (V497) { 51261 Py_XDECREF(V497); 51262 } 51263 51264 {Py_XDECREF(py_V497);} 51265 51266 double __DUMMY_498; 51267 51268 } 51269 __label_496: 51270 51271 if (V495) { 51272 Py_XDECREF(V495); 51273 } 51274 51275 {Py_XDECREF(py_V495);} 51276 51277 double __DUMMY_496; 51278 51279 } 51280 __label_494: 51281 51282 if (V493) { 51283 Py_XDECREF(V493); 51284 } 51285 51286 {Py_XDECREF(py_V493);} 51287 51288 double __DUMMY_494; 51289 51290 } 51291 __label_492: 51292 51293 if (V491) { 51294 Py_XDECREF(V491); 51295 } 51296 51297 {Py_XDECREF(py_V491);} 51298 51299 double __DUMMY_492; 51300 51301 } 51302 __label_490: 51303 51304 if (V489) { 51305 Py_XDECREF(V489); 51306 } 51307 51308 {Py_XDECREF(py_V489);} 51309 51310 double __DUMMY_490; 51311 51312 } 51313 __label_488: 51314 51315 if (V487) { 51316 Py_XDECREF(V487); 51317 } 51318 51319 {Py_XDECREF(py_V487);} 51320 51321 double __DUMMY_488; 51322 51323 } 51324 __label_486: 51325 51326 if (V485) { 51327 Py_XDECREF(V485); 51328 } 51329 51330 {Py_XDECREF(py_V485);} 51331 51332 double __DUMMY_486; 51333 51334 } 51335 __label_484: 51336 51337 if (V483) { 51338 Py_XDECREF(V483); 51339 } 51340 51341 {Py_XDECREF(py_V483);} 51342 51343 double __DUMMY_484; 51344 51345 } 51346 __label_482: 51347 51348 if (V481) { 51349 Py_XDECREF(V481); 51350 } 51351 51352 {Py_XDECREF(py_V481);} 51353 51354 double __DUMMY_482; 51355 51356 } 51357 __label_480: 51358 51359 if (V479) { 51360 Py_XDECREF(V479); 51361 } 51362 51363 {Py_XDECREF(py_V479);} 51364 51365 double __DUMMY_480; 51366 51367 } 51368 __label_478: 51369 51370 if (V477) { 51371 Py_XDECREF(V477); 51372 } 51373 51374 {Py_XDECREF(py_V477);} 51375 51376 double __DUMMY_478; 51377 51378 } 51379 __label_476: 51380 51381 if (V475) { 51382 Py_XDECREF(V475); 51383 } 51384 51385 {Py_XDECREF(py_V475);} 51386 51387 double __DUMMY_476; 51388 51389 } 51390 __label_474: 51391 51392 if (V473) { 51393 Py_XDECREF(V473); 51394 } 51395 51396 {Py_XDECREF(py_V473);} 51397 51398 double __DUMMY_474; 51399 51400 } 51401 __label_472: 51402 51403 if (V471) { 51404 Py_XDECREF(V471); 51405 } 51406 51407 {Py_XDECREF(py_V471);} 51408 51409 double __DUMMY_472; 51410 51411 } 51412 __label_470: 51413 51414 if (V469) { 51415 Py_XDECREF(V469); 51416 } 51417 51418 {Py_XDECREF(py_V469);} 51419 51420 double __DUMMY_470; 51421 51422 } 51423 __label_468: 51424 51425 if (V467) { 51426 Py_XDECREF(V467); 51427 } 51428 51429 {Py_XDECREF(py_V467);} 51430 51431 double __DUMMY_468; 51432 51433 } 51434 __label_466: 51435 51436 if (V465) { 51437 Py_XDECREF(V465); 51438 } 51439 51440 {Py_XDECREF(py_V465);} 51441 51442 double __DUMMY_466; 51443 51444 } 51445 __label_464: 51446 51447 if (V463) { 51448 Py_XDECREF(V463); 51449 } 51450 51451 {Py_XDECREF(py_V463);} 51452 51453 double __DUMMY_464; 51454 51455 } 51456 __label_462: 51457 51458 if (V461) { 51459 Py_XDECREF(V461); 51460 } 51461 51462 {Py_XDECREF(py_V461);} 51463 51464 double __DUMMY_462; 51465 51466 } 51467 __label_460: 51468 51469 if (V459) { 51470 Py_XDECREF(V459); 51471 } 51472 51473 {Py_XDECREF(py_V459);} 51474 51475 double __DUMMY_460; 51476 51477 } 51478 __label_458: 51479 51480 if (V457) { 51481 Py_XDECREF(V457); 51482 } 51483 51484 {Py_XDECREF(py_V457);} 51485 51486 double __DUMMY_458; 51487 51488 } 51489 __label_456: 51490 51491 if (V455) { 51492 Py_XDECREF(V455); 51493 } 51494 51495 {Py_XDECREF(py_V455);} 51496 51497 double __DUMMY_456; 51498 51499 } 51500 __label_454: 51501 51502 if (V453) { 51503 Py_XDECREF(V453); 51504 } 51505 51506 {Py_XDECREF(py_V453);} 51507 51508 double __DUMMY_454; 51509 51510 } 51511 __label_452: 51512 51513 if (V451) { 51514 Py_XDECREF(V451); 51515 } 51516 51517 {Py_XDECREF(py_V451);} 51518 51519 double __DUMMY_452; 51520 51521 } 51522 __label_450: 51523 51524 if (V449) { 51525 Py_XDECREF(V449); 51526 } 51527 51528 {Py_XDECREF(py_V449);} 51529 51530 double __DUMMY_450; 51531 51532 } 51533 __label_448: 51534 51535 if (V447) { 51536 Py_XDECREF(V447); 51537 } 51538 51539 {Py_XDECREF(py_V447);} 51540 51541 double __DUMMY_448; 51542 51543 } 51544 __label_446: 51545 51546 if (V445) { 51547 Py_XDECREF(V445); 51548 } 51549 51550 {Py_XDECREF(py_V445);} 51551 51552 double __DUMMY_446; 51553 51554 } 51555 __label_444: 51556 51557 if (V443) { 51558 Py_XDECREF(V443); 51559 } 51560 51561 {Py_XDECREF(py_V443);} 51562 51563 double __DUMMY_444; 51564 51565 } 51566 __label_442: 51567 51568 if (V441) { 51569 Py_XDECREF(V441); 51570 } 51571 51572 {Py_XDECREF(py_V441);} 51573 51574 double __DUMMY_442; 51575 51576 } 51577 __label_440: 51578 51579 if (V439) { 51580 Py_XDECREF(V439); 51581 } 51582 51583 {Py_XDECREF(py_V439);} 51584 51585 double __DUMMY_440; 51586 51587 } 51588 __label_438: 51589 51590 if (V437) { 51591 Py_XDECREF(V437); 51592 } 51593 51594 {Py_XDECREF(py_V437);} 51595 51596 double __DUMMY_438; 51597 51598 } 51599 __label_436: 51600 51601 if (V435) { 51602 Py_XDECREF(V435); 51603 } 51604 51605 {Py_XDECREF(py_V435);} 51606 51607 double __DUMMY_436; 51608 51609 } 51610 __label_434: 51611 51612 if (V433) { 51613 Py_XDECREF(V433); 51614 } 51615 51616 {Py_XDECREF(py_V433);} 51617 51618 double __DUMMY_434; 51619 51620 } 51621 __label_432: 51622 51623 if (V431) { 51624 Py_XDECREF(V431); 51625 } 51626 51627 {Py_XDECREF(py_V431);} 51628 51629 double __DUMMY_432; 51630 51631 } 51632 __label_430: 51633 51634 if (V429) { 51635 Py_XDECREF(V429); 51636 } 51637 51638 {Py_XDECREF(py_V429);} 51639 51640 double __DUMMY_430; 51641 51642 } 51643 __label_428: 51644 51645 if (V427) { 51646 Py_XDECREF(V427); 51647 } 51648 51649 {Py_XDECREF(py_V427);} 51650 51651 double __DUMMY_428; 51652 51653 } 51654 __label_426: 51655 51656 if (V425) { 51657 Py_XDECREF(V425); 51658 } 51659 51660 {Py_XDECREF(py_V425);} 51661 51662 double __DUMMY_426; 51663 51664 } 51665 __label_424: 51666 51667 if (V423) { 51668 Py_XDECREF(V423); 51669 } 51670 51671 {Py_XDECREF(py_V423);} 51672 51673 double __DUMMY_424; 51674 51675 } 51676 __label_422: 51677 51678 if (V421) { 51679 Py_XDECREF(V421); 51680 } 51681 51682 {Py_XDECREF(py_V421);} 51683 51684 double __DUMMY_422; 51685 51686 } 51687 __label_420: 51688 51689 if (V419) { 51690 Py_XDECREF(V419); 51691 } 51692 51693 {Py_XDECREF(py_V419);} 51694 51695 double __DUMMY_420; 51696 51697 } 51698 __label_418: 51699 51700 if (V417) { 51701 Py_XDECREF(V417); 51702 } 51703 51704 {Py_XDECREF(py_V417);} 51705 51706 double __DUMMY_418; 51707 51708 } 51709 __label_416: 51710 51711 if (V415) { 51712 Py_XDECREF(V415); 51713 } 51714 51715 {Py_XDECREF(py_V415);} 51716 51717 double __DUMMY_416; 51718 51719 } 51720 __label_414: 51721 51722 if (V413) { 51723 Py_XDECREF(V413); 51724 } 51725 51726 {Py_XDECREF(py_V413);} 51727 51728 double __DUMMY_414; 51729 51730 } 51731 __label_412: 51732 51733 if (V411) { 51734 Py_XDECREF(V411); 51735 } 51736 51737 {Py_XDECREF(py_V411);} 51738 51739 double __DUMMY_412; 51740 51741 } 51742 __label_410: 51743 51744 if (V409) { 51745 Py_XDECREF(V409); 51746 } 51747 51748 {Py_XDECREF(py_V409);} 51749 51750 double __DUMMY_410; 51751 51752 } 51753 __label_408: 51754 51755 if (V407) { 51756 Py_XDECREF(V407); 51757 } 51758 51759 {Py_XDECREF(py_V407);} 51760 51761 double __DUMMY_408; 51762 51763 } 51764 __label_406: 51765 51766 if (V405) { 51767 Py_XDECREF(V405); 51768 } 51769 51770 {Py_XDECREF(py_V405);} 51771 51772 double __DUMMY_406; 51773 51774 } 51775 __label_404: 51776 51777 if (V403) { 51778 Py_XDECREF(V403); 51779 } 51780 51781 {Py_XDECREF(py_V403);} 51782 51783 double __DUMMY_404; 51784 51785 } 51786 __label_402: 51787 51788 if (V401) { 51789 Py_XDECREF(V401); 51790 } 51791 51792 {Py_XDECREF(py_V401);} 51793 51794 double __DUMMY_402; 51795 51796 } 51797 __label_400: 51798 51799 if (V399) { 51800 Py_XDECREF(V399); 51801 } 51802 51803 {Py_XDECREF(py_V399);} 51804 51805 double __DUMMY_400; 51806 51807 } 51808 __label_398: 51809 51810 if (V397) { 51811 Py_XDECREF(V397); 51812 } 51813 51814 {Py_XDECREF(py_V397);} 51815 51816 double __DUMMY_398; 51817 51818 } 51819 __label_396: 51820 51821 if (V395) { 51822 Py_XDECREF(V395); 51823 } 51824 51825 {Py_XDECREF(py_V395);} 51826 51827 double __DUMMY_396; 51828 51829 } 51830 __label_394: 51831 51832 if (V393) { 51833 Py_XDECREF(V393); 51834 } 51835 51836 {Py_XDECREF(py_V393);} 51837 51838 double __DUMMY_394; 51839 51840 } 51841 __label_392: 51842 51843 if (V391) { 51844 Py_XDECREF(V391); 51845 } 51846 51847 {Py_XDECREF(py_V391);} 51848 51849 double __DUMMY_392; 51850 51851 } 51852 __label_390: 51853 51854 if (V389) { 51855 Py_XDECREF(V389); 51856 } 51857 51858 {Py_XDECREF(py_V389);} 51859 51860 double __DUMMY_390; 51861 51862 } 51863 __label_388: 51864 51865 if (V387) { 51866 Py_XDECREF(V387); 51867 } 51868 51869 {Py_XDECREF(py_V387);} 51870 51871 double __DUMMY_388; 51872 51873 } 51874 __label_386: 51875 51876 if (V385) { 51877 Py_XDECREF(V385); 51878 } 51879 51880 {Py_XDECREF(py_V385);} 51881 51882 double __DUMMY_386; 51883 51884 } 51885 __label_384: 51886 51887 if (V383) { 51888 Py_XDECREF(V383); 51889 } 51890 51891 {Py_XDECREF(py_V383);} 51892 51893 double __DUMMY_384; 51894 51895 } 51896 __label_382: 51897 51898 if (V381) { 51899 Py_XDECREF(V381); 51900 } 51901 51902 {Py_XDECREF(py_V381);} 51903 51904 double __DUMMY_382; 51905 51906 } 51907 __label_380: 51908 51909 if (V379) { 51910 Py_XDECREF(V379); 51911 } 51912 51913 {Py_XDECREF(py_V379);} 51914 51915 double __DUMMY_380; 51916 51917 } 51918 __label_378: 51919 51920 if (V377) { 51921 Py_XDECREF(V377); 51922 } 51923 51924 {Py_XDECREF(py_V377);} 51925 51926 double __DUMMY_378; 51927 51928 } 51929 __label_376: 51930 51931 if (V375) { 51932 Py_XDECREF(V375); 51933 } 51934 51935 {Py_XDECREF(py_V375);} 51936 51937 double __DUMMY_376; 51938 51939 } 51940 __label_374: 51941 51942 if (V373) { 51943 Py_XDECREF(V373); 51944 } 51945 51946 {Py_XDECREF(py_V373);} 51947 51948 double __DUMMY_374; 51949 51950 } 51951 __label_372: 51952 51953 if (V371) { 51954 Py_XDECREF(V371); 51955 } 51956 51957 {Py_XDECREF(py_V371);} 51958 51959 double __DUMMY_372; 51960 51961 } 51962 __label_370: 51963 51964 if (V369) { 51965 Py_XDECREF(V369); 51966 } 51967 51968 {Py_XDECREF(py_V369);} 51969 51970 double __DUMMY_370; 51971 51972 } 51973 __label_368: 51974 51975 if (V367) { 51976 Py_XDECREF(V367); 51977 } 51978 51979 {Py_XDECREF(py_V367);} 51980 51981 double __DUMMY_368; 51982 51983 } 51984 __label_366: 51985 51986 if (V365) { 51987 Py_XDECREF(V365); 51988 } 51989 51990 {Py_XDECREF(py_V365);} 51991 51992 double __DUMMY_366; 51993 51994 } 51995 __label_364: 51996 51997 if (V363) { 51998 Py_XDECREF(V363); 51999 } 52000 52001 {Py_XDECREF(py_V363);} 52002 52003 double __DUMMY_364; 52004 52005 } 52006 __label_362: 52007 52008 if (V361) { 52009 Py_XDECREF(V361); 52010 } 52011 52012 {Py_XDECREF(py_V361);} 52013 52014 double __DUMMY_362; 52015 52016 } 52017 __label_360: 52018 52019 if (V359) { 52020 Py_XDECREF(V359); 52021 } 52022 52023 {Py_XDECREF(py_V359);} 52024 52025 double __DUMMY_360; 52026 52027 } 52028 __label_358: 52029 52030 if (V357) { 52031 Py_XDECREF(V357); 52032 } 52033 52034 {Py_XDECREF(py_V357);} 52035 52036 double __DUMMY_358; 52037 52038 } 52039 __label_356: 52040 52041 if (V355) { 52042 Py_XDECREF(V355); 52043 } 52044 52045 {Py_XDECREF(py_V355);} 52046 52047 double __DUMMY_356; 52048 52049 } 52050 __label_354: 52051 52052 if (V353) { 52053 Py_XDECREF(V353); 52054 } 52055 52056 {Py_XDECREF(py_V353);} 52057 52058 double __DUMMY_354; 52059 52060 } 52061 __label_352: 52062 52063 if (V351) { 52064 Py_XDECREF(V351); 52065 } 52066 52067 {Py_XDECREF(py_V351);} 52068 52069 double __DUMMY_352; 52070 52071 } 52072 __label_350: 52073 52074 if (V349) { 52075 Py_XDECREF(V349); 52076 } 52077 52078 {Py_XDECREF(py_V349);} 52079 52080 double __DUMMY_350; 52081 52082 } 52083 __label_348: 52084 52085 if (V347) { 52086 Py_XDECREF(V347); 52087 } 52088 52089 {Py_XDECREF(py_V347);} 52090 52091 double __DUMMY_348; 52092 52093 } 52094 __label_346: 52095 52096 if (V345) { 52097 Py_XDECREF(V345); 52098 } 52099 52100 {Py_XDECREF(py_V345);} 52101 52102 double __DUMMY_346; 52103 52104 } 52105 __label_344: 52106 52107 if (V343) { 52108 Py_XDECREF(V343); 52109 } 52110 52111 {Py_XDECREF(py_V343);} 52112 52113 double __DUMMY_344; 52114 52115 } 52116 __label_342: 52117 52118 if (V341) { 52119 Py_XDECREF(V341); 52120 } 52121 52122 {Py_XDECREF(py_V341);} 52123 52124 double __DUMMY_342; 52125 52126 } 52127 __label_340: 52128 52129 if (V339) { 52130 Py_XDECREF(V339); 52131 } 52132 52133 {Py_XDECREF(py_V339);} 52134 52135 double __DUMMY_340; 52136 52137 } 52138 __label_338: 52139 52140 if (V337) { 52141 Py_XDECREF(V337); 52142 } 52143 52144 {Py_XDECREF(py_V337);} 52145 52146 double __DUMMY_338; 52147 52148 } 52149 __label_336: 52150 52151 if (V335) { 52152 Py_XDECREF(V335); 52153 } 52154 52155 {Py_XDECREF(py_V335);} 52156 52157 double __DUMMY_336; 52158 52159 } 52160 __label_334: 52161 52162 if (V333) { 52163 Py_XDECREF(V333); 52164 } 52165 52166 {Py_XDECREF(py_V333);} 52167 52168 double __DUMMY_334; 52169 52170 } 52171 __label_332: 52172 52173 if (V331) { 52174 Py_XDECREF(V331); 52175 } 52176 52177 {Py_XDECREF(py_V331);} 52178 52179 double __DUMMY_332; 52180 52181 } 52182 __label_330: 52183 52184 if (V329) { 52185 Py_XDECREF(V329); 52186 } 52187 52188 {Py_XDECREF(py_V329);} 52189 52190 double __DUMMY_330; 52191 52192 } 52193 __label_328: 52194 52195 if (V327) { 52196 Py_XDECREF(V327); 52197 } 52198 52199 {Py_XDECREF(py_V327);} 52200 52201 double __DUMMY_328; 52202 52203 } 52204 __label_326: 52205 52206 if (V325) { 52207 Py_XDECREF(V325); 52208 } 52209 52210 {Py_XDECREF(py_V325);} 52211 52212 double __DUMMY_326; 52213 52214 } 52215 __label_324: 52216 52217 if (V323) { 52218 Py_XDECREF(V323); 52219 } 52220 52221 {Py_XDECREF(py_V323);} 52222 52223 double __DUMMY_324; 52224 52225 } 52226 __label_322: 52227 52228 if (V321) { 52229 Py_XDECREF(V321); 52230 } 52231 52232 {Py_XDECREF(py_V321);} 52233 52234 double __DUMMY_322; 52235 52236 } 52237 __label_320: 52238 52239 if (V319) { 52240 Py_XDECREF(V319); 52241 } 52242 52243 {Py_XDECREF(py_V319);} 52244 52245 double __DUMMY_320; 52246 52247 } 52248 __label_318: 52249 52250 if (V317) { 52251 Py_XDECREF(V317); 52252 } 52253 52254 {Py_XDECREF(py_V317);} 52255 52256 double __DUMMY_318; 52257 52258 } 52259 __label_316: 52260 52261 if (V315) { 52262 Py_XDECREF(V315); 52263 } 52264 52265 {Py_XDECREF(py_V315);} 52266 52267 double __DUMMY_316; 52268 52269 } 52270 __label_314: 52271 52272 if (V313) { 52273 Py_XDECREF(V313); 52274 } 52275 52276 {Py_XDECREF(py_V313);} 52277 52278 double __DUMMY_314; 52279 52280 } 52281 __label_312: 52282 52283 if (V311) { 52284 Py_XDECREF(V311); 52285 } 52286 52287 {Py_XDECREF(py_V311);} 52288 52289 double __DUMMY_312; 52290 52291 } 52292 __label_310: 52293 52294 if (V309) { 52295 Py_XDECREF(V309); 52296 } 52297 52298 {Py_XDECREF(py_V309);} 52299 52300 double __DUMMY_310; 52301 52302 } 52303 __label_308: 52304 52305 if (V307) { 52306 Py_XDECREF(V307); 52307 } 52308 52309 {Py_XDECREF(py_V307);} 52310 52311 double __DUMMY_308; 52312 52313 } 52314 __label_306: 52315 52316 if (V305) { 52317 Py_XDECREF(V305); 52318 } 52319 52320 {Py_XDECREF(py_V305);} 52321 52322 double __DUMMY_306; 52323 52324 } 52325 __label_304: 52326 52327 if (V303) { 52328 Py_XDECREF(V303); 52329 } 52330 52331 {Py_XDECREF(py_V303);} 52332 52333 double __DUMMY_304; 52334 52335 } 52336 __label_302: 52337 52338 if (V301) { 52339 Py_XDECREF(V301); 52340 } 52341 52342 {Py_XDECREF(py_V301);} 52343 52344 double __DUMMY_302; 52345 52346 } 52347 __label_300: 52348 52349 if (V299) { 52350 Py_XDECREF(V299); 52351 } 52352 52353 {Py_XDECREF(py_V299);} 52354 52355 double __DUMMY_300; 52356 52357 } 52358 __label_298: 52359 52360 if (V297) { 52361 Py_XDECREF(V297); 52362 } 52363 52364 {Py_XDECREF(py_V297);} 52365 52366 double __DUMMY_298; 52367 52368 } 52369 __label_296: 52370 52371 if (V295) { 52372 Py_XDECREF(V295); 52373 } 52374 52375 {Py_XDECREF(py_V295);} 52376 52377 double __DUMMY_296; 52378 52379 } 52380 __label_294: 52381 52382 if (V293) { 52383 Py_XDECREF(V293); 52384 } 52385 52386 {Py_XDECREF(py_V293);} 52387 52388 double __DUMMY_294; 52389 52390 } 52391 __label_292: 52392 52393 if (V291) { 52394 Py_XDECREF(V291); 52395 } 52396 52397 {Py_XDECREF(py_V291);} 52398 52399 double __DUMMY_292; 52400 52401 } 52402 __label_290: 52403 52404 if (V289) { 52405 Py_XDECREF(V289); 52406 } 52407 52408 {Py_XDECREF(py_V289);} 52409 52410 double __DUMMY_290; 52411 52412 } 52413 __label_288: 52414 52415 if (V287) { 52416 Py_XDECREF(V287); 52417 } 52418 52419 {Py_XDECREF(py_V287);} 52420 52421 double __DUMMY_288; 52422 52423 } 52424 __label_286: 52425 52426 if (V285) { 52427 Py_XDECREF(V285); 52428 } 52429 52430 {Py_XDECREF(py_V285);} 52431 52432 double __DUMMY_286; 52433 52434 } 52435 __label_284: 52436 52437 if (V283) { 52438 Py_XDECREF(V283); 52439 } 52440 52441 {Py_XDECREF(py_V283);} 52442 52443 double __DUMMY_284; 52444 52445 } 52446 __label_282: 52447 52448 if (V281) { 52449 Py_XDECREF(V281); 52450 } 52451 52452 {Py_XDECREF(py_V281);} 52453 52454 double __DUMMY_282; 52455 52456 } 52457 __label_280: 52458 52459 if (V279) { 52460 Py_XDECREF(V279); 52461 } 52462 52463 {Py_XDECREF(py_V279);} 52464 52465 double __DUMMY_280; 52466 52467 } 52468 __label_278: 52469 52470 if (V277) { 52471 Py_XDECREF(V277); 52472 } 52473 52474 {Py_XDECREF(py_V277);} 52475 52476 double __DUMMY_278; 52477 52478 } 52479 __label_276: 52480 52481 if (V275) { 52482 Py_XDECREF(V275); 52483 } 52484 52485 {Py_XDECREF(py_V275);} 52486 52487 double __DUMMY_276; 52488 52489 } 52490 __label_274: 52491 52492 if (V273) { 52493 Py_XDECREF(V273); 52494 } 52495 52496 {Py_XDECREF(py_V273);} 52497 52498 double __DUMMY_274; 52499 52500 } 52501 __label_272: 52502 52503 if (V271) { 52504 Py_XDECREF(V271); 52505 } 52506 52507 {Py_XDECREF(py_V271);} 52508 52509 double __DUMMY_272; 52510 52511 } 52512 __label_270: 52513 52514 if (V269) { 52515 Py_XDECREF(V269); 52516 } 52517 52518 {Py_XDECREF(py_V269);} 52519 52520 double __DUMMY_270; 52521 52522 } 52523 __label_268: 52524 52525 if (V267) { 52526 Py_XDECREF(V267); 52527 } 52528 52529 {Py_XDECREF(py_V267);} 52530 52531 double __DUMMY_268; 52532 52533 } 52534 __label_266: 52535 52536 if (V265) { 52537 Py_XDECREF(V265); 52538 } 52539 52540 {Py_XDECREF(py_V265);} 52541 52542 double __DUMMY_266; 52543 52544 } 52545 __label_264: 52546 52547 if (V263) { 52548 Py_XDECREF(V263); 52549 } 52550 52551 {Py_XDECREF(py_V263);} 52552 52553 double __DUMMY_264; 52554 52555 } 52556 __label_262: 52557 52558 if (V261) { 52559 Py_XDECREF(V261); 52560 } 52561 52562 {Py_XDECREF(py_V261);} 52563 52564 double __DUMMY_262; 52565 52566 } 52567 __label_260: 52568 52569 if (V259) { 52570 Py_XDECREF(V259); 52571 } 52572 52573 {Py_XDECREF(py_V259);} 52574 52575 double __DUMMY_260; 52576 52577 } 52578 __label_258: 52579 52580 if (V257) { 52581 Py_XDECREF(V257); 52582 } 52583 52584 {Py_XDECREF(py_V257);} 52585 52586 double __DUMMY_258; 52587 52588 } 52589 __label_256: 52590 52591 if (V255) { 52592 Py_XDECREF(V255); 52593 } 52594 52595 {Py_XDECREF(py_V255);} 52596 52597 double __DUMMY_256; 52598 52599 } 52600 __label_254: 52601 52602 if (V253) { 52603 Py_XDECREF(V253); 52604 } 52605 52606 {Py_XDECREF(py_V253);} 52607 52608 double __DUMMY_254; 52609 52610 } 52611 __label_252: 52612 52613 if (V251) { 52614 Py_XDECREF(V251); 52615 } 52616 52617 {Py_XDECREF(py_V251);} 52618 52619 double __DUMMY_252; 52620 52621 } 52622 __label_250: 52623 52624 if (V249) { 52625 Py_XDECREF(V249); 52626 } 52627 52628 {Py_XDECREF(py_V249);} 52629 52630 double __DUMMY_250; 52631 52632 } 52633 __label_248: 52634 52635 if (V247) { 52636 Py_XDECREF(V247); 52637 } 52638 52639 {Py_XDECREF(py_V247);} 52640 52641 double __DUMMY_248; 52642 52643 } 52644 __label_246: 52645 52646 if (V245) { 52647 Py_XDECREF(V245); 52648 } 52649 52650 {Py_XDECREF(py_V245);} 52651 52652 double __DUMMY_246; 52653 52654 } 52655 __label_244: 52656 52657 if (V243) { 52658 Py_XDECREF(V243); 52659 } 52660 52661 {Py_XDECREF(py_V243);} 52662 52663 double __DUMMY_244; 52664 52665 } 52666 __label_242: 52667 52668 if (V241) { 52669 Py_XDECREF(V241); 52670 } 52671 52672 {Py_XDECREF(py_V241);} 52673 52674 double __DUMMY_242; 52675 52676 } 52677 __label_240: 52678 52679 if (V239) { 52680 Py_XDECREF(V239); 52681 } 52682 52683 {Py_XDECREF(py_V239);} 52684 52685 double __DUMMY_240; 52686 52687 } 52688 __label_238: 52689 52690 if (V237) { 52691 Py_XDECREF(V237); 52692 } 52693 52694 {Py_XDECREF(py_V237);} 52695 52696 double __DUMMY_238; 52697 52698 } 52699 __label_236: 52700 52701 if (V235) { 52702 Py_XDECREF(V235); 52703 } 52704 52705 {Py_XDECREF(py_V235);} 52706 52707 double __DUMMY_236; 52708 52709 } 52710 __label_234: 52711 52712 if (V233) { 52713 Py_XDECREF(V233); 52714 } 52715 52716 {Py_XDECREF(py_V233);} 52717 52718 double __DUMMY_234; 52719 52720 } 52721 __label_232: 52722 52723 if (V231) { 52724 Py_XDECREF(V231); 52725 } 52726 52727 {Py_XDECREF(py_V231);} 52728 52729 double __DUMMY_232; 52730 52731 } 52732 __label_230: 52733 52734 if (V229) { 52735 Py_XDECREF(V229); 52736 } 52737 52738 {Py_XDECREF(py_V229);} 52739 52740 double __DUMMY_230; 52741 52742 } 52743 __label_228: 52744 52745 if (V227) { 52746 Py_XDECREF(V227); 52747 } 52748 52749 {Py_XDECREF(py_V227);} 52750 52751 double __DUMMY_228; 52752 52753 } 52754 __label_226: 52755 52756 if (V225) { 52757 Py_XDECREF(V225); 52758 } 52759 52760 {Py_XDECREF(py_V225);} 52761 52762 double __DUMMY_226; 52763 52764 } 52765 __label_224: 52766 52767 if (V223) { 52768 Py_XDECREF(V223); 52769 } 52770 52771 {Py_XDECREF(py_V223);} 52772 52773 double __DUMMY_224; 52774 52775 } 52776 __label_222: 52777 52778 if (V221) { 52779 Py_XDECREF(V221); 52780 } 52781 52782 {Py_XDECREF(py_V221);} 52783 52784 double __DUMMY_222; 52785 52786 } 52787 __label_220: 52788 52789 if (V219) { 52790 Py_XDECREF(V219); 52791 } 52792 52793 {Py_XDECREF(py_V219);} 52794 52795 double __DUMMY_220; 52796 52797 } 52798 __label_218: 52799 52800 if (V217) { 52801 Py_XDECREF(V217); 52802 } 52803 52804 {Py_XDECREF(py_V217);} 52805 52806 double __DUMMY_218; 52807 52808 } 52809 __label_216: 52810 52811 if (V215) { 52812 Py_XDECREF(V215); 52813 } 52814 52815 {Py_XDECREF(py_V215);} 52816 52817 double __DUMMY_216; 52818 52819 } 52820 __label_214: 52821 52822 if (V213) { 52823 Py_XDECREF(V213); 52824 } 52825 52826 {Py_XDECREF(py_V213);} 52827 52828 double __DUMMY_214; 52829 52830 } 52831 __label_212: 52832 52833 if (V211) { 52834 Py_XDECREF(V211); 52835 } 52836 52837 {Py_XDECREF(py_V211);} 52838 52839 double __DUMMY_212; 52840 52841 } 52842 __label_210: 52843 52844 if (V209) { 52845 Py_XDECREF(V209); 52846 } 52847 52848 {Py_XDECREF(py_V209);} 52849 52850 double __DUMMY_210; 52851 52852 } 52853 __label_208: 52854 52855 if (V207) { 52856 Py_XDECREF(V207); 52857 } 52858 52859 {Py_XDECREF(py_V207);} 52860 52861 double __DUMMY_208; 52862 52863 } 52864 __label_206: 52865 52866 if (V205) { 52867 Py_XDECREF(V205); 52868 } 52869 52870 {Py_XDECREF(py_V205);} 52871 52872 double __DUMMY_206; 52873 52874 } 52875 __label_204: 52876 52877 if (V203) { 52878 Py_XDECREF(V203); 52879 } 52880 52881 {Py_XDECREF(py_V203);} 52882 52883 double __DUMMY_204; 52884 52885 } 52886 __label_202: 52887 52888 if (V201) { 52889 Py_XDECREF(V201); 52890 } 52891 52892 {Py_XDECREF(py_V201);} 52893 52894 double __DUMMY_202; 52895 52896 } 52897 __label_200: 52898 52899 if (V199) { 52900 Py_XDECREF(V199); 52901 } 52902 52903 {Py_XDECREF(py_V199);} 52904 52905 double __DUMMY_200; 52906 52907 } 52908 __label_198: 52909 52910 if (V197) { 52911 Py_XDECREF(V197); 52912 } 52913 52914 {Py_XDECREF(py_V197);} 52915 52916 double __DUMMY_198; 52917 52918 } 52919 __label_196: 52920 52921 if (V195) { 52922 Py_XDECREF(V195); 52923 } 52924 52925 {Py_XDECREF(py_V195);} 52926 52927 double __DUMMY_196; 52928 52929 } 52930 __label_194: 52931 52932 if (V193) { 52933 Py_XDECREF(V193); 52934 } 52935 52936 {Py_XDECREF(py_V193);} 52937 52938 double __DUMMY_194; 52939 52940 } 52941 __label_192: 52942 52943 if (V191) { 52944 Py_XDECREF(V191); 52945 } 52946 52947 {Py_XDECREF(py_V191);} 52948 52949 double __DUMMY_192; 52950 52951 } 52952 __label_190: 52953 52954 if (V189) { 52955 Py_XDECREF(V189); 52956 } 52957 52958 {Py_XDECREF(py_V189);} 52959 52960 double __DUMMY_190; 52961 52962 } 52963 __label_188: 52964 52965 if (V187) { 52966 Py_XDECREF(V187); 52967 } 52968 52969 {Py_XDECREF(py_V187);} 52970 52971 double __DUMMY_188; 52972 52973 } 52974 __label_186: 52975 52976 if (V185) { 52977 Py_XDECREF(V185); 52978 } 52979 52980 {Py_XDECREF(py_V185);} 52981 52982 double __DUMMY_186; 52983 52984 } 52985 __label_184: 52986 52987 if (V183) { 52988 Py_XDECREF(V183); 52989 } 52990 52991 {Py_XDECREF(py_V183);} 52992 52993 double __DUMMY_184; 52994 52995 } 52996 __label_182: 52997 52998 if (V181) { 52999 Py_XDECREF(V181); 53000 } 53001 53002 {Py_XDECREF(py_V181);} 53003 53004 double __DUMMY_182; 53005 53006 } 53007 __label_180: 53008 53009 if (V179) { 53010 Py_XDECREF(V179); 53011 } 53012 53013 {Py_XDECREF(py_V179);} 53014 53015 double __DUMMY_180; 53016 53017 } 53018 __label_178: 53019 53020 if (V177) { 53021 Py_XDECREF(V177); 53022 } 53023 53024 {Py_XDECREF(py_V177);} 53025 53026 double __DUMMY_178; 53027 53028 } 53029 __label_176: 53030 53031 if (V175) { 53032 Py_XDECREF(V175); 53033 } 53034 53035 {Py_XDECREF(py_V175);} 53036 53037 double __DUMMY_176; 53038 53039 } 53040 __label_174: 53041 53042 if (V173) { 53043 Py_XDECREF(V173); 53044 } 53045 53046 {Py_XDECREF(py_V173);} 53047 53048 double __DUMMY_174; 53049 53050 } 53051 __label_172: 53052 53053 if (V171) { 53054 Py_XDECREF(V171); 53055 } 53056 53057 {Py_XDECREF(py_V171);} 53058 53059 double __DUMMY_172; 53060 53061 } 53062 __label_170: 53063 53064 if (V169) { 53065 Py_XDECREF(V169); 53066 } 53067 53068 {Py_XDECREF(py_V169);} 53069 53070 double __DUMMY_170; 53071 53072 } 53073 __label_168: 53074 53075 if (V167) { 53076 Py_XDECREF(V167); 53077 } 53078 53079 {Py_XDECREF(py_V167);} 53080 53081 double __DUMMY_168; 53082 53083 } 53084 __label_166: 53085 53086 if (V165) { 53087 Py_XDECREF(V165); 53088 } 53089 53090 {Py_XDECREF(py_V165);} 53091 53092 double __DUMMY_166; 53093 53094 } 53095 __label_164: 53096 53097 if (V163) { 53098 Py_XDECREF(V163); 53099 } 53100 53101 {Py_XDECREF(py_V163);} 53102 53103 double __DUMMY_164; 53104 53105 } 53106 __label_162: 53107 53108 if (V161) { 53109 Py_XDECREF(V161); 53110 } 53111 53112 {Py_XDECREF(py_V161);} 53113 53114 double __DUMMY_162; 53115 53116 } 53117 __label_160: 53118 53119 if (V159) { 53120 Py_XDECREF(V159); 53121 } 53122 53123 {Py_XDECREF(py_V159);} 53124 53125 double __DUMMY_160; 53126 53127 } 53128 __label_158: 53129 53130 if (V157) { 53131 Py_XDECREF(V157); 53132 } 53133 53134 {Py_XDECREF(py_V157);} 53135 53136 double __DUMMY_158; 53137 53138 } 53139 __label_156: 53140 53141 if (V155) { 53142 Py_XDECREF(V155); 53143 } 53144 53145 {Py_XDECREF(py_V155);} 53146 53147 double __DUMMY_156; 53148 53149 } 53150 __label_154: 53151 53152 if (V153) { 53153 Py_XDECREF(V153); 53154 } 53155 53156 {Py_XDECREF(py_V153);} 53157 53158 double __DUMMY_154; 53159 53160 } 53161 __label_152: 53162 53163 if (V151) { 53164 Py_XDECREF(V151); 53165 } 53166 53167 {Py_XDECREF(py_V151);} 53168 53169 double __DUMMY_152; 53170 53171 } 53172 __label_150: 53173 53174 if (V149) { 53175 Py_XDECREF(V149); 53176 } 53177 53178 {Py_XDECREF(py_V149);} 53179 53180 double __DUMMY_150; 53181 53182 } 53183 __label_148: 53184 53185 if (V147) { 53186 Py_XDECREF(V147); 53187 } 53188 53189 {Py_XDECREF(py_V147);} 53190 53191 double __DUMMY_148; 53192 53193 } 53194 __label_146: 53195 53196 if (V145) { 53197 Py_XDECREF(V145); 53198 } 53199 53200 {Py_XDECREF(py_V145);} 53201 53202 double __DUMMY_146; 53203 53204 } 53205 __label_144: 53206 53207 if (V143) { 53208 Py_XDECREF(V143); 53209 } 53210 53211 {Py_XDECREF(py_V143);} 53212 53213 double __DUMMY_144; 53214 53215 } 53216 __label_142: 53217 53218 if (V141) { 53219 Py_XDECREF(V141); 53220 } 53221 53222 {Py_XDECREF(py_V141);} 53223 53224 double __DUMMY_142; 53225 53226 } 53227 __label_140: 53228 53229 if (V139) { 53230 Py_XDECREF(V139); 53231 } 53232 53233 {Py_XDECREF(py_V139);} 53234 53235 double __DUMMY_140; 53236 53237 } 53238 __label_138: 53239 53240 if (V137) { 53241 Py_XDECREF(V137); 53242 } 53243 53244 {Py_XDECREF(py_V137);} 53245 53246 double __DUMMY_138; 53247 53248 } 53249 __label_136: 53250 53251 if (V135) { 53252 Py_XDECREF(V135); 53253 } 53254 53255 {Py_XDECREF(py_V135);} 53256 53257 double __DUMMY_136; 53258 53259 } 53260 __label_134: 53261 53262 if (V133) { 53263 Py_XDECREF(V133); 53264 } 53265 53266 {Py_XDECREF(py_V133);} 53267 53268 double __DUMMY_134; 53269 53270 } 53271 __label_132: 53272 53273 if (V131) { 53274 Py_XDECREF(V131); 53275 } 53276 53277 {Py_XDECREF(py_V131);} 53278 53279 double __DUMMY_132; 53280 53281 } 53282 __label_130: 53283 53284 if (V129) { 53285 Py_XDECREF(V129); 53286 } 53287 53288 {Py_XDECREF(py_V129);} 53289 53290 double __DUMMY_130; 53291 53292 } 53293 __label_128: 53294 53295 if (V127) { 53296 Py_XDECREF(V127); 53297 } 53298 53299 {Py_XDECREF(py_V127);} 53300 53301 double __DUMMY_128; 53302 53303 } 53304 __label_126: 53305 53306 if (V125) { 53307 Py_XDECREF(V125); 53308 } 53309 53310 {Py_XDECREF(py_V125);} 53311 53312 double __DUMMY_126; 53313 53314 } 53315 __label_124: 53316 53317 if (V123) { 53318 Py_XDECREF(V123); 53319 } 53320 53321 {Py_XDECREF(py_V123);} 53322 53323 double __DUMMY_124; 53324 53325 } 53326 __label_122: 53327 53328 if (V121) { 53329 Py_XDECREF(V121); 53330 } 53331 53332 {Py_XDECREF(py_V121);} 53333 53334 double __DUMMY_122; 53335 53336 } 53337 __label_120: 53338 53339 if (V119) { 53340 Py_XDECREF(V119); 53341 } 53342 53343 {Py_XDECREF(py_V119);} 53344 53345 double __DUMMY_120; 53346 53347 } 53348 __label_118: 53349 53350 if (V117) { 53351 Py_XDECREF(V117); 53352 } 53353 53354 {Py_XDECREF(py_V117);} 53355 53356 double __DUMMY_118; 53357 53358 } 53359 __label_116: 53360 53361 if (V115) { 53362 Py_XDECREF(V115); 53363 } 53364 53365 {Py_XDECREF(py_V115);} 53366 53367 double __DUMMY_116; 53368 53369 } 53370 __label_114: 53371 53372 if (V113) { 53373 Py_XDECREF(V113); 53374 } 53375 53376 {Py_XDECREF(py_V113);} 53377 53378 double __DUMMY_114; 53379 53380 } 53381 __label_112: 53382 53383 if (V111) { 53384 Py_XDECREF(V111); 53385 } 53386 53387 {Py_XDECREF(py_V111);} 53388 53389 double __DUMMY_112; 53390 53391 } 53392 __label_110: 53393 53394 if (V109) { 53395 Py_XDECREF(V109); 53396 } 53397 53398 {Py_XDECREF(py_V109);} 53399 53400 double __DUMMY_110; 53401 53402 } 53403 __label_108: 53404 53405 if (V107) { 53406 Py_XDECREF(V107); 53407 } 53408 53409 {Py_XDECREF(py_V107);} 53410 53411 double __DUMMY_108; 53412 53413 } 53414 __label_106: 53415 53416 if (V105) { 53417 Py_XDECREF(V105); 53418 } 53419 53420 {Py_XDECREF(py_V105);} 53421 53422 double __DUMMY_106; 53423 53424 } 53425 __label_104: 53426 53427 if (V103) { 53428 Py_XDECREF(V103); 53429 } 53430 53431 {Py_XDECREF(py_V103);} 53432 53433 double __DUMMY_104; 53434 53435 } 53436 __label_102: 53437 53438 if (V101) { 53439 Py_XDECREF(V101); 53440 } 53441 53442 {Py_XDECREF(py_V101);} 53443 53444 double __DUMMY_102; 53445 53446 } 53447 __label_100: 53448 53449 if (V99) { 53450 Py_XDECREF(V99); 53451 } 53452 53453 {Py_XDECREF(py_V99);} 53454 53455 double __DUMMY_100; 53456 53457 } 53458 __label_98: 53459 53460 if (V97) { 53461 Py_XDECREF(V97); 53462 } 53463 53464 {Py_XDECREF(py_V97);} 53465 53466 double __DUMMY_98; 53467 53468 } 53469 __label_96: 53470 53471 if (V95) { 53472 Py_XDECREF(V95); 53473 } 53474 53475 {Py_XDECREF(py_V95);} 53476 53477 double __DUMMY_96; 53478 53479 } 53480 __label_94: 53481 53482 if (V93) { 53483 Py_XDECREF(V93); 53484 } 53485 53486 {Py_XDECREF(py_V93);} 53487 53488 double __DUMMY_94; 53489 53490 } 53491 __label_92: 53492 53493 if (V91) { 53494 Py_XDECREF(V91); 53495 } 53496 53497 {Py_XDECREF(py_V91);} 53498 53499 double __DUMMY_92; 53500 53501 } 53502 __label_90: 53503 53504 if (V89) { 53505 Py_XDECREF(V89); 53506 } 53507 53508 {Py_XDECREF(py_V89);} 53509 53510 double __DUMMY_90; 53511 53512 } 53513 __label_88: 53514 53515 if (V87) { 53516 Py_XDECREF(V87); 53517 } 53518 53519 {Py_XDECREF(py_V87);} 53520 53521 double __DUMMY_88; 53522 53523 } 53524 __label_86: 53525 53526 if (V85) { 53527 Py_XDECREF(V85); 53528 } 53529 53530 {Py_XDECREF(py_V85);} 53531 53532 double __DUMMY_86; 53533 53534 } 53535 __label_84: 53536 53537 if (V83) { 53538 Py_XDECREF(V83); 53539 } 53540 53541 {Py_XDECREF(py_V83);} 53542 53543 double __DUMMY_84; 53544 53545 } 53546 __label_82: 53547 53548 if (V81) { 53549 Py_XDECREF(V81); 53550 } 53551 53552 {Py_XDECREF(py_V81);} 53553 53554 double __DUMMY_82; 53555 53556 } 53557 __label_80: 53558 53559 if (V79) { 53560 Py_XDECREF(V79); 53561 } 53562 53563 {Py_XDECREF(py_V79);} 53564 53565 double __DUMMY_80; 53566 53567 } 53568 __label_78: 53569 53570 if (V77) { 53571 Py_XDECREF(V77); 53572 } 53573 53574 {Py_XDECREF(py_V77);} 53575 53576 double __DUMMY_78; 53577 53578 } 53579 __label_76: 53580 53581 if (V75) { 53582 Py_XDECREF(V75); 53583 } 53584 53585 {Py_XDECREF(py_V75);} 53586 53587 double __DUMMY_76; 53588 53589 } 53590 __label_74: 53591 53592 if (V73) { 53593 Py_XDECREF(V73); 53594 } 53595 53596 {Py_XDECREF(py_V73);} 53597 53598 double __DUMMY_74; 53599 53600 } 53601 __label_72: 53602 53603 if (V71) { 53604 Py_XDECREF(V71); 53605 } 53606 53607 {Py_XDECREF(py_V71);} 53608 53609 double __DUMMY_72; 53610 53611 } 53612 __label_70: 53613 53614 if (V69) { 53615 Py_XDECREF(V69); 53616 } 53617 53618 {Py_XDECREF(py_V69);} 53619 53620 double __DUMMY_70; 53621 53622 } 53623 __label_68: 53624 53625 if (V67) { 53626 Py_XDECREF(V67); 53627 } 53628 53629 {Py_XDECREF(py_V67);} 53630 53631 double __DUMMY_68; 53632 53633 } 53634 __label_66: 53635 53636 if (V65) { 53637 Py_XDECREF(V65); 53638 } 53639 53640 {Py_XDECREF(py_V65);} 53641 53642 double __DUMMY_66; 53643 53644 } 53645 __label_64: 53646 53647 if (V63) { 53648 Py_XDECREF(V63); 53649 } 53650 53651 {Py_XDECREF(py_V63);} 53652 53653 double __DUMMY_64; 53654 53655 } 53656 __label_62: 53657 53658 if (V61) { 53659 Py_XDECREF(V61); 53660 } 53661 53662 {Py_XDECREF(py_V61);} 53663 53664 double __DUMMY_62; 53665 53666 } 53667 __label_60: 53668 53669 if (V59) { 53670 Py_XDECREF(V59); 53671 } 53672 53673 {Py_XDECREF(py_V59);} 53674 53675 double __DUMMY_60; 53676 53677 } 53678 __label_58: 53679 53680 if (V57) { 53681 Py_XDECREF(V57); 53682 } 53683 53684 {Py_XDECREF(py_V57);} 53685 53686 double __DUMMY_58; 53687 53688 } 53689 __label_56: 53690 53691 if (V55) { 53692 Py_XDECREF(V55); 53693 } 53694 53695 {Py_XDECREF(py_V55);} 53696 53697 double __DUMMY_56; 53698 53699 } 53700 __label_54: 53701 53702 if (V53) { 53703 Py_XDECREF(V53); 53704 } 53705 53706 {Py_XDECREF(py_V53);} 53707 53708 double __DUMMY_54; 53709 53710 } 53711 __label_52: 53712 53713 if (V51) { 53714 Py_XDECREF(V51); 53715 } 53716 53717 {Py_XDECREF(py_V51);} 53718 53719 double __DUMMY_52; 53720 53721 } 53722 __label_50: 53723 53724 if (V49) { 53725 Py_XDECREF(V49); 53726 } 53727 53728 {Py_XDECREF(py_V49);} 53729 53730 double __DUMMY_50; 53731 53732 } 53733 __label_48: 53734 53735 if (V47) { 53736 Py_XDECREF(V47); 53737 } 53738 53739 {Py_XDECREF(py_V47);} 53740 53741 double __DUMMY_48; 53742 53743 } 53744 __label_46: 53745 53746 if (V45) { 53747 Py_XDECREF(V45); 53748 } 53749 53750 {Py_XDECREF(py_V45);} 53751 53752 double __DUMMY_46; 53753 53754 } 53755 __label_44: 53756 53757 if (V43) { 53758 Py_XDECREF(V43); 53759 } 53760 53761 {Py_XDECREF(py_V43);} 53762 53763 double __DUMMY_44; 53764 53765 } 53766 __label_42: 53767 53768 if (V41) { 53769 Py_XDECREF(V41); 53770 } 53771 53772 {Py_XDECREF(py_V41);} 53773 53774 double __DUMMY_42; 53775 53776 } 53777 __label_40: 53778 53779 if (V39) { 53780 Py_XDECREF(V39); 53781 } 53782 53783 {Py_XDECREF(py_V39);} 53784 53785 double __DUMMY_40; 53786 53787 } 53788 __label_38: 53789 53790 if (V37) { 53791 Py_XDECREF(V37); 53792 } 53793 53794 {Py_XDECREF(py_V37);} 53795 53796 double __DUMMY_38; 53797 53798 } 53799 __label_36: 53800 53801 if (V35) { 53802 Py_XDECREF(V35); 53803 } 53804 53805 {Py_XDECREF(py_V35);} 53806 53807 double __DUMMY_36; 53808 53809 } 53810 __label_34: 53811 53812 if (V33) { 53813 Py_XDECREF(V33); 53814 } 53815 53816 {Py_XDECREF(py_V33);} 53817 53818 double __DUMMY_34; 53819 53820 } 53821 __label_32: 53822 53823 if (V31) { 53824 Py_XDECREF(V31); 53825 } 53826 53827 {Py_XDECREF(py_V31);} 53828 53829 double __DUMMY_32; 53830 53831 } 53832 __label_30: 53833 53834 if (V29) { 53835 Py_XDECREF(V29); 53836 } 53837 53838 {Py_XDECREF(py_V29);} 53839 53840 double __DUMMY_30; 53841 53842 } 53843 __label_28: 53844 53845 if (V27) { 53846 Py_XDECREF(V27); 53847 } 53848 53849 {Py_XDECREF(py_V27);} 53850 53851 double __DUMMY_28; 53852 53853 } 53854 __label_26: 53855 53856 if (V25) { 53857 Py_XDECREF(V25); 53858 } 53859 53860 {Py_XDECREF(py_V25);} 53861 53862 double __DUMMY_26; 53863 53864 } 53865 __label_24: 53866 53867 if (V23) { 53868 Py_XDECREF(V23); 53869 } 53870 53871 {Py_XDECREF(py_V23);} 53872 53873 double __DUMMY_24; 53874 53875 } 53876 __label_22: 53877 53878 if (V21) { 53879 Py_XDECREF(V21); 53880 } 53881 53882 {Py_XDECREF(py_V21);} 53883 53884 double __DUMMY_22; 53885 53886 } 53887 __label_20: 53888 53889 if (V19) { 53890 Py_XDECREF(V19); 53891 } 53892 53893 {Py_XDECREF(py_V19);} 53894 53895 double __DUMMY_20; 53896 53897 } 53898 __label_18: 53899 53900 if (V17) { 53901 Py_XDECREF(V17); 53902 } 53903 53904 {Py_XDECREF(py_V17);} 53905 53906 double __DUMMY_18; 53907 53908 } 53909 __label_16: 53910 53911 if (V15) { 53912 Py_XDECREF(V15); 53913 } 53914 53915 {Py_XDECREF(py_V15);} 53916 53917 double __DUMMY_16; 53918 53919 } 53920 __label_14: 53921 53922 if (V13) { 53923 Py_XDECREF(V13); 53924 } 53925 53926 {Py_XDECREF(py_V13);} 53927 53928 double __DUMMY_14; 53929 53930 } 53931 __label_12: 53932 53933 if (V11) { 53934 Py_XDECREF(V11); 53935 } 53936 53937 {Py_XDECREF(py_V11);} 53938 53939 double __DUMMY_12; 53940 53941 } 53942 __label_10: 53943 53944 if (V9) { 53945 Py_XDECREF(V9); 53946 } 53947 53948 {Py_XDECREF(py_V9);} 53949 53950 double __DUMMY_10; 53951 53952 } 53953 __label_8: 53954 53955 if (V7) { 53956 Py_XDECREF(V7); 53957 } 53958 53959 {Py_XDECREF(py_V7);} 53960 53961 double __DUMMY_8; 53962 53963 } 53964 __label_6: 53965 53966 if (V5) { 53967 Py_XDECREF(V5); 53968 } 53969 53970 {Py_XDECREF(py_V5);} 53971 53972 double __DUMMY_6; 53973 53974 } 53975 __label_4: 53976 53977 if (V3) { 53978 Py_XDECREF(V3); 53979 } 53980 53981 {Py_XDECREF(py_V3);} 53982 53983 double __DUMMY_4; 53984 53985 } 53986 __label_2: 53987 53988 if (!__failure) { 53989 53990 {Py_XDECREF(py_V1);} 53991 if (!V1) { 53992 Py_INCREF(Py_None); 53993 py_V1 = Py_None; 53994 } 53995 else if ((void*)py_V1 != (void*)V1) { 53996 py_V1 = (PyObject*)V1; 53997 } 53998 53999 {Py_XINCREF(py_V1);} 54000 54001 if (V1 && !PyArray_ISALIGNED((PyArrayObject*) py_V1)) { 54002 PyErr_Format(PyExc_NotImplementedError, 54003 "c_sync: expected an aligned array, got non-aligned array of type %ld" 54004 " with %ld dimensions, with 3 last dims " 54005 "%ld, %ld, %ld" 54006 " and 3 last strides %ld %ld, %ld.", 54007 (long int) PyArray_TYPE((PyArrayObject*) py_V1), 54008 (long int) PyArray_NDIM(V1), 54009 (long int) (PyArray_NDIM(V1) >= 3 ? 54010 PyArray_DIMS(V1)[PyArray_NDIM(V1)-3] : -1), 54011 (long int) (PyArray_NDIM(V1) >= 2 ? 54012 PyArray_DIMS(V1)[PyArray_NDIM(V1)-2] : -1), 54013 (long int) (PyArray_NDIM(V1) >= 1 ? 54014 PyArray_DIMS(V1)[PyArray_NDIM(V1)-1] : -1), 54015 (long int) (PyArray_NDIM(V1) >= 3 ? 54016 PyArray_STRIDES(V1)[PyArray_NDIM(V1)-3] : -1), 54017 (long int) (PyArray_NDIM(V1) >= 2 ? 54018 PyArray_STRIDES(V1)[PyArray_NDIM(V1)-2] : -1), 54019 (long int) (PyArray_NDIM(V1) >= 1 ? 54020 PyArray_STRIDES(V1)[PyArray_NDIM(V1)-1] : -1) 54021 ); 54022 { 54023 __failure = 2; 54024 if (!PyErr_Occurred()) { 54025 PyErr_SetString(PyExc_RuntimeError, 54026 "Unexpected error in an Op's C code. " 54027 "No Python exception was set."); 54028 } 54029 goto __label_2;} 54030 } 54031 54032 PyObject* old = PyList_GET_ITEM(storage_V1, 0); 54033 {Py_XINCREF(py_V1);} 54034 PyList_SET_ITEM(storage_V1, 0, py_V1); 54035 {Py_XDECREF(old);} 54036 } 54037 54038 if (V1) { 54039 Py_XDECREF(V1); 54040 } 54041 54042 {Py_XDECREF(py_V1);} 54043 54044 double __DUMMY_2; 54045 54046 } 54047 54048 54049 if (__failure) { 54050 // When there is a failure, this code puts the exception 54051 // in __ERROR. 54052 PyObject* err_type = NULL; 54053 PyObject* err_msg = NULL; 54054 PyObject* err_traceback = NULL; 54055 PyErr_Fetch(&err_type, &err_msg, &err_traceback); 54056 if (!err_type) {err_type = Py_None;Py_INCREF(Py_None);} 54057 if (!err_msg) {err_msg = Py_None; Py_INCREF(Py_None);} 54058 if (!err_traceback) {err_traceback = Py_None; Py_INCREF(Py_None);} 54059 PyObject* old_err_type = PyList_GET_ITEM(__ERROR, 0); 54060 PyObject* old_err_msg = PyList_GET_ITEM(__ERROR, 1); 54061 PyObject* old_err_traceback = PyList_GET_ITEM(__ERROR, 2); 54062 PyList_SET_ITEM(__ERROR, 0, err_type); 54063 PyList_SET_ITEM(__ERROR, 1, err_msg); 54064 PyList_SET_ITEM(__ERROR, 2, err_traceback); 54065 {Py_XDECREF(old_err_type);} 54066 {Py_XDECREF(old_err_msg);} 54067 {Py_XDECREF(old_err_traceback);} 54068 } 54069 // The failure code is returned to index what code block failed. 54070 return __failure; 54071 54072 } 54073 }; 54074 } 54075 54076 54077 static int __struct_compiled_op_m17e0841797488fe86115b4f81aba8732_executor(__struct_compiled_op_m17e0841797488fe86115b4f81aba8732 *self) { 54078 return self->run(); 54079 } 54080 54081 static void __struct_compiled_op_m17e0841797488fe86115b4f81aba8732_destructor(PyObject *capsule) { 54082 __struct_compiled_op_m17e0841797488fe86115b4f81aba8732 *self = (__struct_compiled_op_m17e0841797488fe86115b4f81aba8732 *)PyCapsule_GetContext(capsule); 54083 delete self; 54084 } 54085 54086 ////////////////////// 54087 //// Functions 54088 ////////////////////// 54089 static PyObject * instantiate(PyObject * self, PyObject *argtuple) { 54090 assert(PyTuple_Check(argtuple)); 54091 if (456 != PyTuple_Size(argtuple)){ 54092 PyErr_Format(PyExc_TypeError, "Wrong number of arguments, expected 456, got %i", (int)PyTuple_Size(argtuple)); 54093 return NULL; 54094 } 54095 __struct_compiled_op_m17e0841797488fe86115b4f81aba8732* struct_ptr = new __struct_compiled_op_m17e0841797488fe86115b4f81aba8732(); 54096 if (struct_ptr->init( PyTuple_GET_ITEM(argtuple, 0),PyTuple_GET_ITEM(argtuple, 1),PyTuple_GET_ITEM(argtuple, 2),PyTuple_GET_ITEM(argtuple, 3),PyTuple_GET_ITEM(argtuple, 4),PyTuple_GET_ITEM(argtuple, 5),PyTuple_GET_ITEM(argtuple, 6),PyTuple_GET_ITEM(argtuple, 7),PyTuple_GET_ITEM(argtuple, 8),PyTuple_GET_ITEM(argtuple, 9),PyTuple_GET_ITEM(argtuple, 10),PyTuple_GET_ITEM(argtuple, 11),PyTuple_GET_ITEM(argtuple, 12),PyTuple_GET_ITEM(argtuple, 13),PyTuple_GET_ITEM(argtuple, 14),PyTuple_GET_ITEM(argtuple, 15),PyTuple_GET_ITEM(argtuple, 16),PyTuple_GET_ITEM(argtuple, 17),PyTuple_GET_ITEM(argtuple, 18),PyTuple_GET_ITEM(argtuple, 19),PyTuple_GET_ITEM(argtuple, 20),PyTuple_GET_ITEM(argtuple, 21),PyTuple_GET_ITEM(argtuple, 22),PyTuple_GET_ITEM(argtuple, 23),PyTuple_GET_ITEM(argtuple, 24),PyTuple_GET_ITEM(argtuple, 25),PyTuple_GET_ITEM(argtuple, 26),PyTuple_GET_ITEM(argtuple, 27),PyTuple_GET_ITEM(argtuple, 28),PyTuple_GET_ITEM(argtuple, 29),PyTuple_GET_ITEM(argtuple, 30),PyTuple_GET_ITEM(argtuple, 31),PyTuple_GET_ITEM(argtuple, 32),PyTuple_GET_ITEM(argtuple, 33),PyTuple_GET_ITEM(argtuple, 34),PyTuple_GET_ITEM(argtuple, 35),PyTuple_GET_ITEM(argtuple, 36),PyTuple_GET_ITEM(argtuple, 37),PyTuple_GET_ITEM(argtuple, 38),PyTuple_GET_ITEM(argtuple, 39),PyTuple_GET_ITEM(argtuple, 40),PyTuple_GET_ITEM(argtuple, 41),PyTuple_GET_ITEM(argtuple, 42),PyTuple_GET_ITEM(argtuple, 43),PyTuple_GET_ITEM(argtuple, 44),PyTuple_GET_ITEM(argtuple, 45),PyTuple_GET_ITEM(argtuple, 46),PyTuple_GET_ITEM(argtuple, 47),PyTuple_GET_ITEM(argtuple, 48),PyTuple_GET_ITEM(argtuple, 49),PyTuple_GET_ITEM(argtuple, 50),PyTuple_GET_ITEM(argtuple, 51),PyTuple_GET_ITEM(argtuple, 52),PyTuple_GET_ITEM(argtuple, 53),PyTuple_GET_ITEM(argtuple, 54),PyTuple_GET_ITEM(argtuple, 55),PyTuple_GET_ITEM(argtuple, 56),PyTuple_GET_ITEM(argtuple, 57),PyTuple_GET_ITEM(argtuple, 58),PyTuple_GET_ITEM(argtuple, 59),PyTuple_GET_ITEM(argtuple, 60),PyTuple_GET_ITEM(argtuple, 61),PyTuple_GET_ITEM(argtuple, 62),PyTuple_GET_ITEM(argtuple, 63),PyTuple_GET_ITEM(argtuple, 64),PyTuple_GET_ITEM(argtuple, 65),PyTuple_GET_ITEM(argtuple, 66),PyTuple_GET_ITEM(argtuple, 67),PyTuple_GET_ITEM(argtuple, 68),PyTuple_GET_ITEM(argtuple, 69),PyTuple_GET_ITEM(argtuple, 70),PyTuple_GET_ITEM(argtuple, 71),PyTuple_GET_ITEM(argtuple, 72),PyTuple_GET_ITEM(argtuple, 73),PyTuple_GET_ITEM(argtuple, 74),PyTuple_GET_ITEM(argtuple, 75),PyTuple_GET_ITEM(argtuple, 76),PyTuple_GET_ITEM(argtuple, 77),PyTuple_GET_ITEM(argtuple, 78),PyTuple_GET_ITEM(argtuple, 79),PyTuple_GET_ITEM(argtuple, 80),PyTuple_GET_ITEM(argtuple, 81),PyTuple_GET_ITEM(argtuple, 82),PyTuple_GET_ITEM(argtuple, 83),PyTuple_GET_ITEM(argtuple, 84),PyTuple_GET_ITEM(argtuple, 85),PyTuple_GET_ITEM(argtuple, 86),PyTuple_GET_ITEM(argtuple, 87),PyTuple_GET_ITEM(argtuple, 88),PyTuple_GET_ITEM(argtuple, 89),PyTuple_GET_ITEM(argtuple, 90),PyTuple_GET_ITEM(argtuple, 91),PyTuple_GET_ITEM(argtuple, 92),PyTuple_GET_ITEM(argtuple, 93),PyTuple_GET_ITEM(argtuple, 94),PyTuple_GET_ITEM(argtuple, 95),PyTuple_GET_ITEM(argtuple, 96),PyTuple_GET_ITEM(argtuple, 97),PyTuple_GET_ITEM(argtuple, 98),PyTuple_GET_ITEM(argtuple, 99),PyTuple_GET_ITEM(argtuple, 100),PyTuple_GET_ITEM(argtuple, 101),PyTuple_GET_ITEM(argtuple, 102),PyTuple_GET_ITEM(argtuple, 103),PyTuple_GET_ITEM(argtuple, 104),PyTuple_GET_ITEM(argtuple, 105),PyTuple_GET_ITEM(argtuple, 106),PyTuple_GET_ITEM(argtuple, 107),PyTuple_GET_ITEM(argtuple, 108),PyTuple_GET_ITEM(argtuple, 109),PyTuple_GET_ITEM(argtuple, 110),PyTuple_GET_ITEM(argtuple, 111),PyTuple_GET_ITEM(argtuple, 112),PyTuple_GET_ITEM(argtuple, 113),PyTuple_GET_ITEM(argtuple, 114),PyTuple_GET_ITEM(argtuple, 115),PyTuple_GET_ITEM(argtuple, 116),PyTuple_GET_ITEM(argtuple, 117),PyTuple_GET_ITEM(argtuple, 118),PyTuple_GET_ITEM(argtuple, 119),PyTuple_GET_ITEM(argtuple, 120),PyTuple_GET_ITEM(argtuple, 121),PyTuple_GET_ITEM(argtuple, 122),PyTuple_GET_ITEM(argtuple, 123),PyTuple_GET_ITEM(argtuple, 124),PyTuple_GET_ITEM(argtuple, 125),PyTuple_GET_ITEM(argtuple, 126),PyTuple_GET_ITEM(argtuple, 127),PyTuple_GET_ITEM(argtuple, 128),PyTuple_GET_ITEM(argtuple, 129),PyTuple_GET_ITEM(argtuple, 130),PyTuple_GET_ITEM(argtuple, 131),PyTuple_GET_ITEM(argtuple, 132),PyTuple_GET_ITEM(argtuple, 133),PyTuple_GET_ITEM(argtuple, 134),PyTuple_GET_ITEM(argtuple, 135),PyTuple_GET_ITEM(argtuple, 136),PyTuple_GET_ITEM(argtuple, 137),PyTuple_GET_ITEM(argtuple, 138),PyTuple_GET_ITEM(argtuple, 139),PyTuple_GET_ITEM(argtuple, 140),PyTuple_GET_ITEM(argtuple, 141),PyTuple_GET_ITEM(argtuple, 142),PyTuple_GET_ITEM(argtuple, 143),PyTuple_GET_ITEM(argtuple, 144),PyTuple_GET_ITEM(argtuple, 145),PyTuple_GET_ITEM(argtuple, 146),PyTuple_GET_ITEM(argtuple, 147),PyTuple_GET_ITEM(argtuple, 148),PyTuple_GET_ITEM(argtuple, 149),PyTuple_GET_ITEM(argtuple, 150),PyTuple_GET_ITEM(argtuple, 151),PyTuple_GET_ITEM(argtuple, 152),PyTuple_GET_ITEM(argtuple, 153),PyTuple_GET_ITEM(argtuple, 154),PyTuple_GET_ITEM(argtuple, 155),PyTuple_GET_ITEM(argtuple, 156),PyTuple_GET_ITEM(argtuple, 157),PyTuple_GET_ITEM(argtuple, 158),PyTuple_GET_ITEM(argtuple, 159),PyTuple_GET_ITEM(argtuple, 160),PyTuple_GET_ITEM(argtuple, 161),PyTuple_GET_ITEM(argtuple, 162),PyTuple_GET_ITEM(argtuple, 163),PyTuple_GET_ITEM(argtuple, 164),PyTuple_GET_ITEM(argtuple, 165),PyTuple_GET_ITEM(argtuple, 166),PyTuple_GET_ITEM(argtuple, 167),PyTuple_GET_ITEM(argtuple, 168),PyTuple_GET_ITEM(argtuple, 169),PyTuple_GET_ITEM(argtuple, 170),PyTuple_GET_ITEM(argtuple, 171),PyTuple_GET_ITEM(argtuple, 172),PyTuple_GET_ITEM(argtuple, 173),PyTuple_GET_ITEM(argtuple, 174),PyTuple_GET_ITEM(argtuple, 175),PyTuple_GET_ITEM(argtuple, 176),PyTuple_GET_ITEM(argtuple, 177),PyTuple_GET_ITEM(argtuple, 178),PyTuple_GET_ITEM(argtuple, 179),PyTuple_GET_ITEM(argtuple, 180),PyTuple_GET_ITEM(argtuple, 181),PyTuple_GET_ITEM(argtuple, 182),PyTuple_GET_ITEM(argtuple, 183),PyTuple_GET_ITEM(argtuple, 184),PyTuple_GET_ITEM(argtuple, 185),PyTuple_GET_ITEM(argtuple, 186),PyTuple_GET_ITEM(argtuple, 187),PyTuple_GET_ITEM(argtuple, 188),PyTuple_GET_ITEM(argtuple, 189),PyTuple_GET_ITEM(argtuple, 190),PyTuple_GET_ITEM(argtuple, 191),PyTuple_GET_ITEM(argtuple, 192),PyTuple_GET_ITEM(argtuple, 193),PyTuple_GET_ITEM(argtuple, 194),PyTuple_GET_ITEM(argtuple, 195),PyTuple_GET_ITEM(argtuple, 196),PyTuple_GET_ITEM(argtuple, 197),PyTuple_GET_ITEM(argtuple, 198),PyTuple_GET_ITEM(argtuple, 199),PyTuple_GET_ITEM(argtuple, 200),PyTuple_GET_ITEM(argtuple, 201),PyTuple_GET_ITEM(argtuple, 202),PyTuple_GET_ITEM(argtuple, 203),PyTuple_GET_ITEM(argtuple, 204),PyTuple_GET_ITEM(argtuple, 205),PyTuple_GET_ITEM(argtuple, 206),PyTuple_GET_ITEM(argtuple, 207),PyTuple_GET_ITEM(argtuple, 208),PyTuple_GET_ITEM(argtuple, 209),PyTuple_GET_ITEM(argtuple, 210),PyTuple_GET_ITEM(argtuple, 211),PyTuple_GET_ITEM(argtuple, 212),PyTuple_GET_ITEM(argtuple, 213),PyTuple_GET_ITEM(argtuple, 214),PyTuple_GET_ITEM(argtuple, 215),PyTuple_GET_ITEM(argtuple, 216),PyTuple_GET_ITEM(argtuple, 217),PyTuple_GET_ITEM(argtuple, 218),PyTuple_GET_ITEM(argtuple, 219),PyTuple_GET_ITEM(argtuple, 220),PyTuple_GET_ITEM(argtuple, 221),PyTuple_GET_ITEM(argtuple, 222),PyTuple_GET_ITEM(argtuple, 223),PyTuple_GET_ITEM(argtuple, 224),PyTuple_GET_ITEM(argtuple, 225),PyTuple_GET_ITEM(argtuple, 226),PyTuple_GET_ITEM(argtuple, 227),PyTuple_GET_ITEM(argtuple, 228),PyTuple_GET_ITEM(argtuple, 229),PyTuple_GET_ITEM(argtuple, 230),PyTuple_GET_ITEM(argtuple, 231),PyTuple_GET_ITEM(argtuple, 232),PyTuple_GET_ITEM(argtuple, 233),PyTuple_GET_ITEM(argtuple, 234),PyTuple_GET_ITEM(argtuple, 235),PyTuple_GET_ITEM(argtuple, 236),PyTuple_GET_ITEM(argtuple, 237),PyTuple_GET_ITEM(argtuple, 238),PyTuple_GET_ITEM(argtuple, 239),PyTuple_GET_ITEM(argtuple, 240),PyTuple_GET_ITEM(argtuple, 241),PyTuple_GET_ITEM(argtuple, 242),PyTuple_GET_ITEM(argtuple, 243),PyTuple_GET_ITEM(argtuple, 244),PyTuple_GET_ITEM(argtuple, 245),PyTuple_GET_ITEM(argtuple, 246),PyTuple_GET_ITEM(argtuple, 247),PyTuple_GET_ITEM(argtuple, 248),PyTuple_GET_ITEM(argtuple, 249),PyTuple_GET_ITEM(argtuple, 250),PyTuple_GET_ITEM(argtuple, 251),PyTuple_GET_ITEM(argtuple, 252),PyTuple_GET_ITEM(argtuple, 253),PyTuple_GET_ITEM(argtuple, 254),PyTuple_GET_ITEM(argtuple, 255),PyTuple_GET_ITEM(argtuple, 256),PyTuple_GET_ITEM(argtuple, 257),PyTuple_GET_ITEM(argtuple, 258),PyTuple_GET_ITEM(argtuple, 259),PyTuple_GET_ITEM(argtuple, 260),PyTuple_GET_ITEM(argtuple, 261),PyTuple_GET_ITEM(argtuple, 262),PyTuple_GET_ITEM(argtuple, 263),PyTuple_GET_ITEM(argtuple, 264),PyTuple_GET_ITEM(argtuple, 265),PyTuple_GET_ITEM(argtuple, 266),PyTuple_GET_ITEM(argtuple, 267),PyTuple_GET_ITEM(argtuple, 268),PyTuple_GET_ITEM(argtuple, 269),PyTuple_GET_ITEM(argtuple, 270),PyTuple_GET_ITEM(argtuple, 271),PyTuple_GET_ITEM(argtuple, 272),PyTuple_GET_ITEM(argtuple, 273),PyTuple_GET_ITEM(argtuple, 274),PyTuple_GET_ITEM(argtuple, 275),PyTuple_GET_ITEM(argtuple, 276),PyTuple_GET_ITEM(argtuple, 277),PyTuple_GET_ITEM(argtuple, 278),PyTuple_GET_ITEM(argtuple, 279),PyTuple_GET_ITEM(argtuple, 280),PyTuple_GET_ITEM(argtuple, 281),PyTuple_GET_ITEM(argtuple, 282),PyTuple_GET_ITEM(argtuple, 283),PyTuple_GET_ITEM(argtuple, 284),PyTuple_GET_ITEM(argtuple, 285),PyTuple_GET_ITEM(argtuple, 286),PyTuple_GET_ITEM(argtuple, 287),PyTuple_GET_ITEM(argtuple, 288),PyTuple_GET_ITEM(argtuple, 289),PyTuple_GET_ITEM(argtuple, 290),PyTuple_GET_ITEM(argtuple, 291),PyTuple_GET_ITEM(argtuple, 292),PyTuple_GET_ITEM(argtuple, 293),PyTuple_GET_ITEM(argtuple, 294),PyTuple_GET_ITEM(argtuple, 295),PyTuple_GET_ITEM(argtuple, 296),PyTuple_GET_ITEM(argtuple, 297),PyTuple_GET_ITEM(argtuple, 298),PyTuple_GET_ITEM(argtuple, 299),PyTuple_GET_ITEM(argtuple, 300),PyTuple_GET_ITEM(argtuple, 301),PyTuple_GET_ITEM(argtuple, 302),PyTuple_GET_ITEM(argtuple, 303),PyTuple_GET_ITEM(argtuple, 304),PyTuple_GET_ITEM(argtuple, 305),PyTuple_GET_ITEM(argtuple, 306),PyTuple_GET_ITEM(argtuple, 307),PyTuple_GET_ITEM(argtuple, 308),PyTuple_GET_ITEM(argtuple, 309),PyTuple_GET_ITEM(argtuple, 310),PyTuple_GET_ITEM(argtuple, 311),PyTuple_GET_ITEM(argtuple, 312),PyTuple_GET_ITEM(argtuple, 313),PyTuple_GET_ITEM(argtuple, 314),PyTuple_GET_ITEM(argtuple, 315),PyTuple_GET_ITEM(argtuple, 316),PyTuple_GET_ITEM(argtuple, 317),PyTuple_GET_ITEM(argtuple, 318),PyTuple_GET_ITEM(argtuple, 319),PyTuple_GET_ITEM(argtuple, 320),PyTuple_GET_ITEM(argtuple, 321),PyTuple_GET_ITEM(argtuple, 322),PyTuple_GET_ITEM(argtuple, 323),PyTuple_GET_ITEM(argtuple, 324),PyTuple_GET_ITEM(argtuple, 325),PyTuple_GET_ITEM(argtuple, 326),PyTuple_GET_ITEM(argtuple, 327),PyTuple_GET_ITEM(argtuple, 328),PyTuple_GET_ITEM(argtuple, 329),PyTuple_GET_ITEM(argtuple, 330),PyTuple_GET_ITEM(argtuple, 331),PyTuple_GET_ITEM(argtuple, 332),PyTuple_GET_ITEM(argtuple, 333),PyTuple_GET_ITEM(argtuple, 334),PyTuple_GET_ITEM(argtuple, 335),PyTuple_GET_ITEM(argtuple, 336),PyTuple_GET_ITEM(argtuple, 337),PyTuple_GET_ITEM(argtuple, 338),PyTuple_GET_ITEM(argtuple, 339),PyTuple_GET_ITEM(argtuple, 340),PyTuple_GET_ITEM(argtuple, 341),PyTuple_GET_ITEM(argtuple, 342),PyTuple_GET_ITEM(argtuple, 343),PyTuple_GET_ITEM(argtuple, 344),PyTuple_GET_ITEM(argtuple, 345),PyTuple_GET_ITEM(argtuple, 346),PyTuple_GET_ITEM(argtuple, 347),PyTuple_GET_ITEM(argtuple, 348),PyTuple_GET_ITEM(argtuple, 349),PyTuple_GET_ITEM(argtuple, 350),PyTuple_GET_ITEM(argtuple, 351),PyTuple_GET_ITEM(argtuple, 352),PyTuple_GET_ITEM(argtuple, 353),PyTuple_GET_ITEM(argtuple, 354),PyTuple_GET_ITEM(argtuple, 355),PyTuple_GET_ITEM(argtuple, 356),PyTuple_GET_ITEM(argtuple, 357),PyTuple_GET_ITEM(argtuple, 358),PyTuple_GET_ITEM(argtuple, 359),PyTuple_GET_ITEM(argtuple, 360),PyTuple_GET_ITEM(argtuple, 361),PyTuple_GET_ITEM(argtuple, 362),PyTuple_GET_ITEM(argtuple, 363),PyTuple_GET_ITEM(argtuple, 364),PyTuple_GET_ITEM(argtuple, 365),PyTuple_GET_ITEM(argtuple, 366),PyTuple_GET_ITEM(argtuple, 367),PyTuple_GET_ITEM(argtuple, 368),PyTuple_GET_ITEM(argtuple, 369),PyTuple_GET_ITEM(argtuple, 370),PyTuple_GET_ITEM(argtuple, 371),PyTuple_GET_ITEM(argtuple, 372),PyTuple_GET_ITEM(argtuple, 373),PyTuple_GET_ITEM(argtuple, 374),PyTuple_GET_ITEM(argtuple, 375),PyTuple_GET_ITEM(argtuple, 376),PyTuple_GET_ITEM(argtuple, 377),PyTuple_GET_ITEM(argtuple, 378),PyTuple_GET_ITEM(argtuple, 379),PyTuple_GET_ITEM(argtuple, 380),PyTuple_GET_ITEM(argtuple, 381),PyTuple_GET_ITEM(argtuple, 382),PyTuple_GET_ITEM(argtuple, 383),PyTuple_GET_ITEM(argtuple, 384),PyTuple_GET_ITEM(argtuple, 385),PyTuple_GET_ITEM(argtuple, 386),PyTuple_GET_ITEM(argtuple, 387),PyTuple_GET_ITEM(argtuple, 388),PyTuple_GET_ITEM(argtuple, 389),PyTuple_GET_ITEM(argtuple, 390),PyTuple_GET_ITEM(argtuple, 391),PyTuple_GET_ITEM(argtuple, 392),PyTuple_GET_ITEM(argtuple, 393),PyTuple_GET_ITEM(argtuple, 394),PyTuple_GET_ITEM(argtuple, 395),PyTuple_GET_ITEM(argtuple, 396),PyTuple_GET_ITEM(argtuple, 397),PyTuple_GET_ITEM(argtuple, 398),PyTuple_GET_ITEM(argtuple, 399),PyTuple_GET_ITEM(argtuple, 400),PyTuple_GET_ITEM(argtuple, 401),PyTuple_GET_ITEM(argtuple, 402),PyTuple_GET_ITEM(argtuple, 403),PyTuple_GET_ITEM(argtuple, 404),PyTuple_GET_ITEM(argtuple, 405),PyTuple_GET_ITEM(argtuple, 406),PyTuple_GET_ITEM(argtuple, 407),PyTuple_GET_ITEM(argtuple, 408),PyTuple_GET_ITEM(argtuple, 409),PyTuple_GET_ITEM(argtuple, 410),PyTuple_GET_ITEM(argtuple, 411),PyTuple_GET_ITEM(argtuple, 412),PyTuple_GET_ITEM(argtuple, 413),PyTuple_GET_ITEM(argtuple, 414),PyTuple_GET_ITEM(argtuple, 415),PyTuple_GET_ITEM(argtuple, 416),PyTuple_GET_ITEM(argtuple, 417),PyTuple_GET_ITEM(argtuple, 418),PyTuple_GET_ITEM(argtuple, 419),PyTuple_GET_ITEM(argtuple, 420),PyTuple_GET_ITEM(argtuple, 421),PyTuple_GET_ITEM(argtuple, 422),PyTuple_GET_ITEM(argtuple, 423),PyTuple_GET_ITEM(argtuple, 424),PyTuple_GET_ITEM(argtuple, 425),PyTuple_GET_ITEM(argtuple, 426),PyTuple_GET_ITEM(argtuple, 427),PyTuple_GET_ITEM(argtuple, 428),PyTuple_GET_ITEM(argtuple, 429),PyTuple_GET_ITEM(argtuple, 430),PyTuple_GET_ITEM(argtuple, 431),PyTuple_GET_ITEM(argtuple, 432),PyTuple_GET_ITEM(argtuple, 433),PyTuple_GET_ITEM(argtuple, 434),PyTuple_GET_ITEM(argtuple, 435),PyTuple_GET_ITEM(argtuple, 436),PyTuple_GET_ITEM(argtuple, 437),PyTuple_GET_ITEM(argtuple, 438),PyTuple_GET_ITEM(argtuple, 439),PyTuple_GET_ITEM(argtuple, 440),PyTuple_GET_ITEM(argtuple, 441),PyTuple_GET_ITEM(argtuple, 442),PyTuple_GET_ITEM(argtuple, 443),PyTuple_GET_ITEM(argtuple, 444),PyTuple_GET_ITEM(argtuple, 445),PyTuple_GET_ITEM(argtuple, 446),PyTuple_GET_ITEM(argtuple, 447),PyTuple_GET_ITEM(argtuple, 448),PyTuple_GET_ITEM(argtuple, 449),PyTuple_GET_ITEM(argtuple, 450),PyTuple_GET_ITEM(argtuple, 451),PyTuple_GET_ITEM(argtuple, 452),PyTuple_GET_ITEM(argtuple, 453),PyTuple_GET_ITEM(argtuple, 454),PyTuple_GET_ITEM(argtuple, 455) ) != 0) { 54097 delete struct_ptr; 54098 return NULL; 54099 } 54100 PyObject* thunk = PyCapsule_New((void*)(&__struct_compiled_op_m17e0841797488fe86115b4f81aba8732_executor), NULL, __struct_compiled_op_m17e0841797488fe86115b4f81aba8732_destructor); 54101 if (thunk != NULL && PyCapsule_SetContext(thunk, struct_ptr) != 0) { 54102 PyErr_Clear(); 54103 Py_DECREF(thunk); 54104 thunk = NULL; 54105 } 54106 54107 return thunk; } 54108 54109 ////////////////////// 54110 //// Module init 54111 ////////////////////// 54112 static PyMethodDef MyMethods[] = { 54113 {"instantiate", instantiate, METH_VARARGS, "undocumented"} , 54114 {NULL, NULL, 0, NULL} 54115 }; 54116 static struct PyModuleDef moduledef = { 54117 PyModuleDef_HEAD_INIT, 54118 "m17e0841797488fe86115b4f81aba8732", 54119 NULL, 54120 -1, 54121 MyMethods, 54122 }; 54123 54124 PyMODINIT_FUNC PyInit_m17e0841797488fe86115b4f81aba8732(void) { 54125 import_array(); 54126 PyObject *m = PyModule_Create(&moduledef); 54127 return m; 54128 } 54129 Problem occurred during compilation with the command line below: /usr/bin/clang++ -dynamiclib -g -O3 -fno-math-errno -Wno-unused-label -Wno-unused-variable -Wno-write-strings -march=haswell -DNPY_NO_DEPRECATED_API=NPY_1_7_API_VERSION -m64 -fPIC -undefined dynamic_lookup -I/Users/fonnescj/anaconda3/envs/bios8366/lib/python3.5/site-packages/numpy/core/include -I/Users/fonnescj/anaconda3/envs/bios8366/include/python3.5m -I/Users/fonnescj/anaconda3/envs/bios8366/lib/python3.5/site-packages/theano/gof -L/Users/fonnescj/anaconda3/envs/bios8366/lib -fvisibility=hidden -o /Users/fonnescj/.theano/compiledir_Darwin-16.1.0-x86_64-i386-64bit-i386-3.5.2-64/tmpw1bwxf2l/m17e0841797488fe86115b4f81aba8732.so /Users/fonnescj/.theano/compiledir_Darwin-16.1.0-x86_64-i386-64bit-i386-3.5.2-64/tmpw1bwxf2l/mod.cpp
--------------------------------------------------------------------------- Exception Traceback (most recent call last) <ipython-input-34-8b56d4944e2f> in <module>() 1 with dp_mixture: ----> 2 step1 = pm.Metropolis(vars=[α, β, σ, μ]) 3 step2 = pm.CategoricalGibbsMetropolis(vars=[component]) 4 trace = pm.sample(10000, step=[step1, step2]) /Users/fonnescj/anaconda3/envs/bios8366/lib/python3.5/site-packages/pymc3/step_methods/arraystep.py in __new__(cls, *args, **kwargs) 58 # If we don't return the instance we have to manually 59 # call __init__ ---> 60 step.__init__([var], *args, **kwargs) 61 # Hack for creating the class correctly when unpickling. 62 step.__newargs = ([var], ) + args, kwargs /Users/fonnescj/anaconda3/envs/bios8366/lib/python3.5/site-packages/pymc3/step_methods/metropolis.py in __init__(self, vars, S, proposal_dist, scaling, tune, tune_interval, model, **kwargs) 96 97 shared = pm.make_shared_replacements(vars, model) ---> 98 self.delta_logp = delta_logp(model.logpt, vars, shared) 99 super(Metropolis, self).__init__(vars, shared) 100 /Users/fonnescj/anaconda3/envs/bios8366/lib/python3.5/site-packages/pymc3/step_methods/metropolis.py in delta_logp(logp, vars, shared) 431 logp1 = pm.CallableTensor(logp0)(inarray1) 432 --> 433 f = theano.function([inarray1, inarray0], logp1 - logp0) 434 f.trust_input = True 435 return f /Users/fonnescj/anaconda3/envs/bios8366/lib/python3.5/site-packages/theano/compile/function.py in function(inputs, outputs, mode, updates, givens, no_default_updates, accept_inplace, name, rebuild_strict, allow_input_downcast, profile, on_unused_input) 324 on_unused_input=on_unused_input, 325 profile=profile, --> 326 output_keys=output_keys) 327 # We need to add the flag check_aliased inputs if we have any mutable or 328 # borrowed used defined inputs /Users/fonnescj/anaconda3/envs/bios8366/lib/python3.5/site-packages/theano/compile/pfunc.py in pfunc(params, outputs, mode, updates, givens, no_default_updates, accept_inplace, name, rebuild_strict, allow_input_downcast, profile, on_unused_input, output_keys) 484 accept_inplace=accept_inplace, name=name, 485 profile=profile, on_unused_input=on_unused_input, --> 486 output_keys=output_keys) 487 488 /Users/fonnescj/anaconda3/envs/bios8366/lib/python3.5/site-packages/theano/compile/function_module.py in orig_function(inputs, outputs, mode, accept_inplace, name, profile, on_unused_input, output_keys) 1782 on_unused_input=on_unused_input, 1783 output_keys=output_keys).create( -> 1784 defaults) 1785 1786 t2 = time.time() /Users/fonnescj/anaconda3/envs/bios8366/lib/python3.5/site-packages/theano/compile/function_module.py in create(self, input_storage, trustme, storage_map) 1649 theano.config.traceback.limit = theano.config.traceback.compile_limit 1650 _fn, _i, _o = self.linker.make_thunk( -> 1651 input_storage=input_storage_lists, storage_map=storage_map) 1652 finally: 1653 theano.config.traceback.limit = limit_orig /Users/fonnescj/anaconda3/envs/bios8366/lib/python3.5/site-packages/theano/gof/link.py in make_thunk(self, input_storage, output_storage, storage_map) 697 return self.make_all(input_storage=input_storage, 698 output_storage=output_storage, --> 699 storage_map=storage_map)[:3] 700 701 def make_all(self, input_storage, output_storage): /Users/fonnescj/anaconda3/envs/bios8366/lib/python3.5/site-packages/theano/gof/vm.py in make_all(self, profiler, input_storage, output_storage, storage_map) 1055 compute_map, 1056 no_recycling, -> 1057 impl=impl)) 1058 linker_make_thunk_time[node] = time.time() - thunk_start 1059 if not hasattr(thunks[-1], 'lazy'): /Users/fonnescj/anaconda3/envs/bios8366/lib/python3.5/site-packages/theano/gof/op.py in make_thunk(self, node, storage_map, compute_map, no_recycling, impl) 922 try: 923 return self.make_c_thunk(node, storage_map, compute_map, --> 924 no_recycling) 925 except (NotImplementedError, utils.MethodNotDefined): 926 # We requested the c code, so don't catch the error. /Users/fonnescj/anaconda3/envs/bios8366/lib/python3.5/site-packages/theano/gof/op.py in make_c_thunk(self, node, storage_map, compute_map, no_recycling) 826 _logger.debug('Trying CLinker.make_thunk') 827 outputs = cl.make_thunk(input_storage=node_input_storage, --> 828 output_storage=node_output_storage) 829 fill_storage, node_input_filters, node_output_filters = outputs 830 /Users/fonnescj/anaconda3/envs/bios8366/lib/python3.5/site-packages/theano/gof/cc.py in make_thunk(self, input_storage, output_storage, storage_map, keep_lock) 1188 cthunk, in_storage, out_storage, error_storage = self.__compile__( 1189 input_storage, output_storage, storage_map, -> 1190 keep_lock=keep_lock) 1191 1192 res = _CThunk(cthunk, init_tasks, tasks, error_storage) /Users/fonnescj/anaconda3/envs/bios8366/lib/python3.5/site-packages/theano/gof/cc.py in __compile__(self, input_storage, output_storage, storage_map, keep_lock) 1129 output_storage, 1130 storage_map, -> 1131 keep_lock=keep_lock) 1132 return (thunk, 1133 [link.Container(input, storage) for input, storage in /Users/fonnescj/anaconda3/envs/bios8366/lib/python3.5/site-packages/theano/gof/cc.py in cthunk_factory(self, error_storage, in_storage, out_storage, storage_map, keep_lock) 1587 node.op.prepare_node(node, storage_map, None, 'c') 1588 module = get_module_cache().module_from_key( -> 1589 key=key, lnk=self, keep_lock=keep_lock) 1590 1591 vars = self.inputs + self.outputs + self.orphans /Users/fonnescj/anaconda3/envs/bios8366/lib/python3.5/site-packages/theano/gof/cmodule.py in module_from_key(self, key, lnk, keep_lock) 1153 try: 1154 location = dlimport_workdir(self.dirname) -> 1155 module = lnk.compile_cmodule(location) 1156 name = module.__file__ 1157 assert name.startswith(location) /Users/fonnescj/anaconda3/envs/bios8366/lib/python3.5/site-packages/theano/gof/cc.py in compile_cmodule(self, location) 1490 lib_dirs=self.lib_dirs(), 1491 libs=libs, -> 1492 preargs=preargs) 1493 except Exception as e: 1494 e.args += (str(self.fgraph),) /Users/fonnescj/anaconda3/envs/bios8366/lib/python3.5/site-packages/theano/gof/cmodule.py in compile_str(module_name, src_code, location, include_dirs, lib_dirs, libs, preargs, py_module, hide_symbols) 2321 # difficult to read. 2322 raise Exception('Compilation failed (return status=%s): %s' % -> 2323 (status, compile_stderr.replace('\n', '. '))) 2324 elif config.cmodule.compilation_warning and compile_stderr: 2325 # Print errors just below the command line. Exception: ('The following error happened while compiling the node', Elemwise{Composite{((i0 + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i3) + i4)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i5) + i6)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i7) + i8)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i9) + i10)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i11) + i12)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i13) + i14)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i15) + i16)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i17) + i18)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i19) + i20)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i21) + i22)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i23) + i24)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i25) + i26)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i27) + i28)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i29) + i30)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i31) + i32)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i33) + i34)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i35) + i36)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i37) + i38)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i39) + i40)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i41) + i42)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i43) + i44)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i45) + i46)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i47) + i48)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i49) + i50)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i51) + i52)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i53) + i54)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i55) + i56)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i57) + i58)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i59) + i60)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i61) + i62)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i63) + i64)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i65) + i66)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i67) + i68)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i69) + i70)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i71) + i72)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i73) + i74)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i75) + i76)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i77) + i78)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i79) + i80)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i81) + i82)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i83) + i84)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i85) + i86)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i87) + i88)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i89) + i90)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i91) + i92)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i93) + i94)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i95) + i96)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i97) + i98)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i99) + i100)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i101) + i102)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i103) + i104)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i105) + i106)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i107) + i108)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i109) + i110)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i111) + i112)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i113) + i114)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i115) + i116)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i117) + i118)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i119) + i120)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i121) + i122)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i123) + i124)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i125) + i126)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i127) + i128)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i129) + i130)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i131) + i132)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i133) + i134)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i135) + i136)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i137) + i138)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i139) + i140)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i141) + i142)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i143) + i144)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i145) + i146)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i147) + i148)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i149) + i150)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i151) + i152)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i153) + i154)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i155) + i156)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i157) + i158)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i159) + i160)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i161) + i162)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i163) + i164)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i165) + i166)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i167) + i168)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i169) + i170)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i171) + i172)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i173) + i174)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i175) + i176)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i177) + i178)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i179) + i180)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i181) + i182)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i183) + i184)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i185) + i186)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i187) + i188)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i189) + i190)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i191) + i192)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i193) + i194)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i195) + i196)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i197) + i198)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i199) + i200)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i201) + i202)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i203) + i204)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i205) + i206)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i207) + i208)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i209) + i210)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i211) + i212)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i213) + i214)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i215) + i216)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i217) + i218)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i219) + i220)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i221) + i222)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i223) + i224)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i225) + i226)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i227) + i228)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i229) + i230)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i231) + i232)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i233) + i234)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i235) + i236)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i237) + i238)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i239) + i240)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i241) + i242)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i243) + i244)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i245) + i246)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i247) + i248)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i249) + i250)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i251) + i252)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i253) + i254)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i255) + i256)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i257) + i258)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i259) + i260)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i261) + i262)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i263) + i264)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i265) + i266)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i267) + i268)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i269) + i270)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i271) + i272)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i273) + i274)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i275) + i276)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i277) + i278)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i279) + i280)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i281) + i282)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i283) + i284)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i285) + i286)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i287) + i288)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i289) + i290)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i291) + i292)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i293) + i294)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i295) + i296)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i297) + i298)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i299) + i300)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i301) + i302))) - (i303 + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i3) + i304)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i5) + i305)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i7) + i306)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i9) + i307)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i11) + i308)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i13) + i309)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i15) + i310)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i17) + i311)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i19) + i312)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i21) + i313)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i23) + i314)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i25) + i315)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i27) + i316)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i29) + i317)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i31) + i318)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i33) + i319)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i35) + i320)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i37) + i321)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i39) + i322)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i41) + i323)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i43) + i324)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i45) + i325)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i47) + i326)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i49) + i327)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i51) + i328)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i53) + i329)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i55) + i330)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i57) + i331)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i59) + i332)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i61) + i333)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i63) + i334)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i65) + i335)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i67) + i336)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i69) + i337)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i71) + i338)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i73) + i339)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i75) + i340)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i77) + i341)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i79) + i342)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i81) + i343)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i83) + i344)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i85) + i345)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i87) + i346)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i89) + i347)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i91) + i348)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i93) + i349)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i95) + i350)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i97) + i351)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i99) + i352)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i101) + i353)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i103) + i354)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i105) + i355)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i107) + i356)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i109) + i357)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i111) + i358)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i113) + i359)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i115) + i360)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i117) + i361)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i119) + i362)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i121) + i363)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i123) + i364)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i125) + i365)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i127) + i366)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i129) + i367)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i131) + i368)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i133) + i369)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i135) + i370)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i137) + i371)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i139) + i372)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i141) + i373)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i143) + i374)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i145) + i375)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i147) + i376)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i149) + i377)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i151) + i378)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i153) + i379)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i155) + i380)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i157) + i381)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i159) + i382)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i161) + i383)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i163) + i384)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i165) + i385)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i167) + i386)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i169) + i387)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i171) + i388)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i173) + i389)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i175) + i390)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i177) + i391)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i179) + i392)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i181) + i393)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i183) + i394)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i185) + i395)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i187) + i396)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i189) + i397)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i191) + i398)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i193) + i399)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i195) + i400)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i197) + i401)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i199) + i402)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i201) + i403)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i203) + i404)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i205) + i405)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i207) + i406)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i209) + i407)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i211) + i408)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i213) + i409)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i215) + i410)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i217) + i411)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i219) + i412)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i221) + i413)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i223) + i414)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i225) + i415)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i227) + i416)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i229) + i417)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i231) + i418)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i233) + i419)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i235) + i420)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i237) + i421)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i239) + i422)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i241) + i423)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i243) + i424)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i245) + i425)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i247) + i426)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i249) + i427)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i251) + i428)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i253) + i429)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i255) + i430)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i257) + i431)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i259) + i432)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i261) + i433)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i263) + i434)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i265) + i435)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i267) + i436)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i269) + i437)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i271) + i438)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i273) + i439)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i275) + i440)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i277) + i441)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i279) + i442)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i281) + i443)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i283) + i444)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i285) + i445)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i287) + i446)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i289) + i447)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i291) + i448)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i293) + i449)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i295) + i450)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i297) + i451)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i299) + i452)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i301) + i453))))}}(Sum{acc_dtype=float64}.0, TensorConstant{-0.5}, TensorConstant{3.6757541328186907}, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Det.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0, Sum{acc_dtype=float64}.0), '\n', 'Compilation failed (return status=1): /Users/fonnescj/.theano/compiledir_Darwin-16.1.0-x86_64-i386-64bit-i386-3.5.2-64/tmpw1bwxf2l/mod.cpp:27441:32: fatal error: bracket nesting level exceeded maximum of 256. if (!PyErr_Occurred()) {. ^. /Users/fonnescj/.theano/compiledir_Darwin-16.1.0-x86_64-i386-64bit-i386-3.5.2-64/tmpw1bwxf2l/mod.cpp:27441:32: note: use -fbracket-depth=N to increase maximum nesting level. 1 error generated.. ', '[Elemwise{Composite{((i0 + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i3) + i4)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i5) + i6)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i7) + i8)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i9) + i10)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i11) + i12)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i13) + i14)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i15) + i16)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i17) + i18)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i19) + i20)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i21) + i22)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i23) + i24)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i25) + i26)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i27) + i28)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i29) + i30)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i31) + i32)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i33) + i34)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i35) + i36)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i37) + i38)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i39) + i40)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i41) + i42)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i43) + i44)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i45) + i46)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i47) + i48)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i49) + i50)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i51) + i52)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i53) + i54)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i55) + i56)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i57) + i58)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i59) + i60)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i61) + i62)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i63) + i64)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i65) + i66)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i67) + i68)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i69) + i70)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i71) + i72)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i73) + i74)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i75) + i76)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i77) + i78)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i79) + i80)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i81) + i82)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i83) + i84)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i85) + i86)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i87) + i88)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i89) + i90)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i91) + i92)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i93) + i94)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i95) + i96)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i97) + i98)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i99) + i100)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i101) + i102)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i103) + i104)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i105) + i106)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i107) + i108)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i109) + i110)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i111) + i112)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i113) + i114)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i115) + i116)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i117) + i118)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i119) + i120)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i121) + i122)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i123) + i124)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i125) + i126)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i127) + i128)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i129) + i130)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i131) + i132)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i133) + i134)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i135) + i136)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i137) + i138)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i139) + i140)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i141) + i142)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i143) + i144)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i145) + i146)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i147) + i148)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i149) + i150)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i151) + i152)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i153) + i154)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i155) + i156)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i157) + i158)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i159) + i160)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i161) + i162)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i163) + i164)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i165) + i166)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i167) + i168)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i169) + i170)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i171) + i172)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i173) + i174)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i175) + i176)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i177) + i178)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i179) + i180)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i181) + i182)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i183) + i184)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i185) + i186)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i187) + i188)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i189) + i190)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i191) + i192)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i193) + i194)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i195) + i196)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i197) + i198)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i199) + i200)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i201) + i202)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i203) + i204)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i205) + i206)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i207) + i208)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i209) + i210)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i211) + i212)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i213) + i214)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i215) + i216)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i217) + i218)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i219) + i220)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i221) + i222)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i223) + i224)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i225) + i226)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i227) + i228)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i229) + i230)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i231) + i232)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i233) + i234)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i235) + i236)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i237) + i238)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i239) + i240)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i241) + i242)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i243) + i244)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i245) + i246)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i247) + i248)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i249) + i250)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i251) + i252)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i253) + i254)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i255) + i256)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i257) + i258)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i259) + i260)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i261) + i262)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i263) + i264)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i265) + i266)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i267) + i268)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i269) + i270)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i271) + i272)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i273) + i274)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i275) + i276)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i277) + i278)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i279) + i280)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i281) + i282)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i283) + i284)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i285) + i286)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i287) + i288)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i289) + i290)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i291) + i292)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i293) + i294)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i295) + i296)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i297) + i298)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i299) + i300)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i301) + i302))) - (i303 + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i3) + i304)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i5) + i305)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i7) + i306)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i9) + i307)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i11) + i308)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i13) + i309)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i15) + i310)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i17) + i311)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i19) + i312)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i21) + i313)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i23) + i314)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i25) + i315)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i27) + i316)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i29) + i317)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i31) + i318)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i33) + i319)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i35) + i320)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i37) + i321)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i39) + i322)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i41) + i323)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i43) + i324)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i45) + i325)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i47) + i326)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i49) + i327)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i51) + i328)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i53) + i329)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i55) + i330)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i57) + i331)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i59) + i332)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i61) + i333)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i63) + i334)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i65) + i335)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i67) + i336)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i69) + i337)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i71) + i338)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i73) + i339)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i75) + i340)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i77) + i341)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i79) + i342)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i81) + i343)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i83) + i344)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i85) + i345)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i87) + i346)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i89) + i347)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i91) + i348)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i93) + i349)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i95) + i350)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i97) + i351)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i99) + i352)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i101) + i353)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i103) + i354)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i105) + i355)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i107) + i356)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i109) + i357)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i111) + i358)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i113) + i359)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i115) + i360)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i117) + i361)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i119) + i362)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i121) + i363)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i123) + i364)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i125) + i365)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i127) + i366)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i129) + i367)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i131) + i368)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i133) + i369)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i135) + i370)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i137) + i371)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i139) + i372)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i141) + i373)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i143) + i374)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i145) + i375)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i147) + i376)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i149) + i377)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i151) + i378)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i153) + i379)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i155) + i380)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i157) + i381)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i159) + i382)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i161) + i383)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i163) + i384)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i165) + i385)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i167) + i386)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i169) + i387)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i171) + i388)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i173) + i389)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i175) + i390)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i177) + i391)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i179) + i392)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i181) + i393)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i183) + i394)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i185) + i395)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i187) + i396)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i189) + i397)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i191) + i398)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i193) + i399)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i195) + i400)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i197) + i401)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i199) + i402)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i201) + i403)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i203) + i404)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i205) + i405)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i207) + i406)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i209) + i407)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i211) + i408)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i213) + i409)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i215) + i410)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i217) + i411)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i219) + i412)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i221) + i413)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i223) + i414)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i225) + i415)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i227) + i416)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i229) + i417)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i231) + i418)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i233) + i419)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i235) + i420)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i237) + i421)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i239) + i422)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i241) + i423)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i243) + i424)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i245) + i425)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i247) + i426)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i249) + i427)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i251) + i428)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i253) + i429)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i255) + i430)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i257) + i431)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i259) + i432)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i261) + i433)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i263) + i434)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i265) + i435)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i267) + i436)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i269) + i437)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i271) + i438)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i273) + i439)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i275) + i440)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i277) + i441)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i279) + i442)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i281) + i443)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i283) + i444)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i285) + i445)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i287) + i446)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i289) + i447)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i291) + i448)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i293) + i449)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i295) + i450)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i297) + i451)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i299) + i452)) + (i1 * (Composite{(i0 + log(inv(i1)))}(i2, i301) + i453))))}}(<TensorType(float64, scalar)>, TensorConstant{-0.5}, TensorConstant{3.6757541328186907}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>)]')
pm.traceplot(trace, varnames=['α'])
array([[<matplotlib.axes._subplots.AxesSubplot object at 0x14b8618d0>, <matplotlib.axes._subplots.AxesSubplot object at 0x128dde048>]], dtype=object)
pm.forestplot(trace, varnames=['τ'])
<matplotlib.gridspec.GridSpec at 0x1250e0f98>
Initialize number of clusters to 1, and assign all observations to that cluster. Calculate cluster mean to be global mean.
Specify cluster penalty parameter $\lambda$
Initialize cluster indicators: $z_1 = z_2 = \ldots, = z_n = 1 $
Repeat until convergence:
For each data point $x_i$:
Generate clusters $l_1, \ldots, l_k$ from $z_1,\ldots,z_n$
Recompute cluster means: $\mu_j = \frac{1}{|l_j|} \sum_{x \in l_j} x$
def dp_means(x, lam, max_iter=100, tol=1e-5, metric='euclidean'):
x = np.array(x)
n = x.shape[0]
k = 1
# Initialize cluster indicators
z = np.ones(n, int)
# Initialize with single cluster of all observations
mu = [x.mean(0)]
# Initialize variables
converged = False
iteration = 0
ss = np.inf
# Iterate until converged or maxed out
while (not converged) and (iteration < max_iter):
# Calculate distances for all points
d = cdist(x, np.array(mu), metric=metric)
for i in range(n):
if np.min(d[i]) > lam:
# Create new group
k += 1
z[i] = k - 1
mu += [x[i]]
else:
# Assign to closest group
z[i] = np.argmin(d[i])
for j in range(k):
# Recalculate centroids
if (z==j).sum():
indices = np.where(z==j)[0]
mu[j] = np.mean(x[indices], 0)
ss_old = ss
# Calcuate sum of squared distances to use as convergence criterion
ss = np.sum([[(x[i,j] - mu[z[i]][j])**2 for j in range(2)] for i in range(n)])
ss_diff = ss_old - ss
if ss_diff < tol:
converged = True
iteration += 1
return(dict(centers=np.array(mu), z=z, k=k, iterations=iteration, converged=converged, ss=ss))
x,y = X_pca.T
fig, axes = plt.subplots(1, 3, figsize=(16, 4))
for i,c in enumerate([2, 3, 4]):
dpm = dp_means(X_pca, c, metric='seuclidean')
axes[i].scatter(x, y, c=dpm['z'])
axes[i].scatter(*dpm['centers'].T, c='r', marker='+', s=100)
axes[i].set_title(r'$\lambda$={0}, k={1}'.format(c, dpm['k']))
clusters = []
lambdas = np.linspace(2, 4)
for c in lambdas:
dpm = dp_means(X_pca, c, metric='euclidean')
clusters.append(len(dpm['centers']))
plt.plot(lambdas, clusters)
[<matplotlib.lines.Line2D at 0x13b7917f0>]
Kulis B and Jordan MI. Revisiting k-means: New Algorithms via Bayesian Nonparametrics. arXiv preprint arXiv:11110352 2011.