# Uterine fibroids follow-up treatment meta-analysis¶

Our goal is to estimate the probabilities of requiring one of a suite of candidate follow-up treatments following randomization to a given initial treatment for uterine fibroids. Specifically, we are interested in estimating:

$$Pr(I_2|I_1 =i,T=t)$$

where $I_1$ is an initial intervention, which take specific values $i = 1, 2, \ldots , K$ for each of $K$ candidate intervention types, $I_2$ is the followup intervention that also may take any of the same values of $i$, and $T$ is followup time in months, which will generally be either 6 or 12 months.

Our current set of candidate interventions include:

• Myomectomy
• Hysterectomy
• Ablation
• UAE
• Magnetic resonance imaging-guided high-intensity focused ultrasound (MRIgFUS)
• Ablation +/- hysteroscopic myomectomy
• No intervention

Rather than model each conditional probability independently, we will instead model the outcomes for a treatment arm as a multinomial random variable. That is,

$$\{X_{I_2} \} ∼ \text{Multinomial}(N_{I_1}=i, \{\pi_i\})$$

where $\{X_{I_2}\}$ is the vector of outcomes corresponding to each of the possible followup interventions listed above, $N_{I_1}=i$ is the number of women randomized to the initial intervention i, and $\{\pi_i\}$ is a vector of conditional transition probabilities corresponding to $Pr(I_2|I_1 = i, T = t)$, as specified above. The multinomial distribution is a multivariate generalization of the categorical distribution, which is what the above simplifies to when modeling the outcome for a single patient. The multivariate formulation allows us to model study-arm-specific outcomes, incorporating covariates that are specific to that arm or study.

The quantities of interest are the vectors of transition probabilities $\{\pi_i\}$ corresponding to each of the initial candidate interventions. A naive approach to modeling these is to assign a vague Dirichlet prior distribution to each set, and perform Bayesian inference using the multinomial likelihood, with which the Dirichlet is conjugate, to yield posterior estimates for each probability. However, there may be additional information with which to model these probabilities, which may include:

• followup time for each study
• arm-specific demographic covariates (e.g. race, mean age)
• study-specific random effects

hence, a given transition probability $\pi_{ijk}$ – the probability of transitioning from initial intervention $i$ to followup intervention $j$ in study $k$ – may be modeled as:

$$\text{logit}(\pi_{ijk})= \theta_{ij} + X_k \beta_{ij} + \epsilon_k$$

where $\theta_{ij}$ is a baseline transition probability (on the logit scale), $X_k$ a matrix of study(-arm)-specific covariates, $\beta_{ij}$ the corresponding coefficients, and $\epsilon_k$ a mean-zero random effect for study k. We will initially consider (1) follow-up time and (2) mean/median age as covariates.

An attractive benefit to using Bayesian inference to estimate this model is that it is easy to generate predictions from the model, via the posterior predictive distribution. For example, we could estimate the distribution of the expected proportion of women requiring a particular followup intervention; this estimate would factor in both the residual uncertainty in the transition probability estimates, as well as the sampling uncertainty of the intervention.

In [1]:
%matplotlib inline
import numpy as np
import pandas as pd
import pymc3 as pm
import seaborn as sns
sns.set()


Import data from worksheets in Excel spreadsheet.

In [2]:
data_file = 'UF Subsequent Interventions Data_Master_updated.xlsx'

In [3]:
missing = ['NA', 'NR', 'ND', '?', 'null']

misc_data = pd.read_excel('data/' + data_file, sheetname='MISC (SP)', na_values=missing)
misc_data = misc_data[~misc_data['baseline_n'].isnull()].drop('notes', axis=1)
rows, cols = misc_data.shape
print('Occlusion rows={0}, columns={1}, missing={2}'.format(rows, cols,
misc_data.isnull().sum().sum()))

med_vs_iac_data = pd.read_excel('data/' + data_file, sheetname='Med vs IAC JW', na_values=missing)
med_vs_iac_data = med_vs_iac_data[~med_vs_iac_data['trial_arm'].isnull()].drop('notes', axis=1)
rows, cols = med_vs_iac_data.shape
print('Med vs IAC rows={0}, columns={1}, missing={2}'.format(rows, cols,
med_vs_iac_data.isnull().sum().sum()))

med_vs_med_data = pd.read_excel('data/' + data_file, sheetname='Med vs Med DVE', na_values=missing)
med_vs_med_data = med_vs_med_data[~med_vs_med_data['baseline_n'].isnull()].drop('notes', axis=1)
rows, cols = med_vs_med_data.shape
print('Med vs Med rows={0}, columns={1}, missing={2}'.format(rows, cols,
med_vs_med_data.isnull().sum().sum()))

uae_data = pd.read_excel('data/' + data_file, sheetname='UAE SK')
uae_data = uae_data[~uae_data['baseline_n'].isnull()].drop('notes', axis=1)
rows, cols = uae_data.shape
print('UAE rows={0}, columns={1}, missing={2}'.format(rows, cols,
uae_data.isnull().sum().sum()))

datasets = [misc_data, med_vs_iac_data, med_vs_med_data, uae_data]

Occlusion rows=31, columns=13, missing=6
Med vs IAC rows=49, columns=13, missing=46
Med vs Med rows=67, columns=13, missing=13
UAE rows=32, columns=13, missing=0

In [4]:
unique_inerventions = set(np.concatenate([d.intervention.values for d in datasets]))


Use the following lookup table to create "intervention category" field in each dataset.

In [5]:
# %load intervention_lookup.py
intervention_lookup = {'Ablation': 'ablation',
'Ablation+/- hysteroscopic myomectomy': 'ablation',
'Asoprisnil 10 mg': 'med_manage',
'Asoprisnil 25 mg': 'med_manage',
'Asoprisnil 5 mg': 'med_manage',
'CD20 (Ulipristal)': 'med_manage',
'CDB10 (Ulipristal)': 'med_manage',
'Hysterectomy': 'hysterectomy',
'LBCUV': 'uae',
'LP + GnRH agonist plus raloxifene': 'med_manage',
'LP + placebo': 'med_manage',
'LPA+ MPA / LPA+placebo': 'med_manage',
'LPA+ placebo / LPA+MPA': 'med_manage',
'LUNA plus LBCUV': 'ablation',
'Myomectomy': 'myomectomy',
'No treatment': 'control',
'No treatment (control)': 'control',
'Placebo': 'control',
'Raloxifene, 180mg/day': 'med_manage',
'SC implant of 3.6 goserelin + placebo (3 months) then tibolone 2.5 mg daily (3 months)': 'med_manage',
'SC implant of 3.6 goserelin + placebo (6 months)': 'med_manage',
'SC implant of 3.6 goserelin + tibolone 2.5 mg daily (6 months)': 'med_manage',
'Surgery': 'DROP',
'Tibolone': 'med_manage',
'UAE': 'uae',
'UAE only': 'uae',
'UAE plus goserelin acetate depot': 'uae',
'buserelin + goserelin': 'med_manage',
'buserelin, intranasal': 'med_manage',
'cabergoline': 'med_manage',
'diphereline': 'med_manage',
'gestrinone, 2.5mg': 'med_manage',
'gestrinone, 2.5mg oral + gestrinone, 5mg oral + gestrinone, 5mg vaginal': 'med_manage',
'gestrinone, 5mg': 'med_manage',
'gestrinone, 5mg vaginal': 'med_manage',
'goserelin, subcutaneous': 'med_manage',
'healthy controls': 'control',
'hormone replacement therapy, transdermal': 'DROP',
'hysterectomy or myomectomy': 'DROP',
'letrozole, 2.5mg': 'med_manage',
'leuprolide': 'med_manage',
'leuprolide acetate depot (11.25 mg q 3 months) + Placebo': 'med_manage',
'leuprolide acetate depot (11.25 mg q 3 months) + tibolone 2.5 mg/d orally': 'med_manage',
'leuprolide acetate depot (3.75 mg/28 d) + placebo (B)': 'med_manage',
'leuprolide plus (tibolone 2.5 mg daily) (A)': 'med_manage',
'leuprolide plus MPA': 'med_manage',
'leuprolide plus estrogen-progestin': 'med_manage',
'leuprolide plus placebo': 'med_manage',
'leuprolide plus progestin': 'med_manage',
'leuprolide plus raloxifene 60 mg daily': 'med_manage',
'leuprolide, 1.88mg': 'med_manage',
'leuprolide, 3.75mg': 'med_manage',
'mifepristone, 10mg': 'med_manage',
'mifepristone, 10mg + mifepristone, 5mg': 'med_manage',
'mifepristone, 2.5mg': 'med_manage',
'mifepristone, 5mg': 'med_manage',
'placebo': 'control',
'raloxifene 180 mg daily': 'med_manage',
'raloxifene 60 mg daily': 'med_manage',
'tamoxifen 20 mg daily': 'med_manage',
'tibolone': 'med_manage',
'tibolone, 2.5mg': 'med_manage',
'transdermal estrogen replacement therapy': 'med_manage',
'triptorelin, 100ug': 'med_manage',
'triptorelin, 100ug + triptorelin, 20ug + triptorelin, 5ug': 'med_manage',
'triptorelin, 20ug': 'med_manage',
'triptorelin, 3.6mg/mo': 'med_manage',
'triptorelin, 5ug': 'med_manage',
'ulipristal acetate followed by placebo': 'med_manage',
'ulipristal acetate followed by progestin': 'med_manage',
'ulipristal, 10mg': 'med_manage',
'ulipristal, 5mg': 'med_manage',
'HIFU': 'MRgFUS',
'HIFU with CEUS': 'MRgFUS',
'LUAO': 'uae',
'UAE plus PVA': 'uae',
'UAE plus TAG': 'uae',
'UAE with PVA': 'uae',
'UAE with PVA particles, large': 'uae',
'UAE with PVA particles, small': 'uae',
'UAE with SPA': 'uae',
'UAE with SPVA': 'uae',
'UAE with TAG': 'uae',
'UAE with TAG microspheres': 'uae',
'myomectomy': 'myomectomy',
'myomectomy with vasopressin': 'myomectomy',
'myomectomy, abdominal': 'myomectomy',
'myomectomy, laparoscopic': 'myomectomy',
'myomectomy, loop ligation with vasopressin': 'myomectomy',
'myomectomy, minilaparotomic': 'myomectomy'}


In [6]:
datasets = [d.assign(intervention_cat=d.intervention.replace(intervention_lookup)) for d in datasets]

In [7]:
intervention_categories = set(intervention_lookup.values())
intervention_categories

Out[7]:
{'DROP',
'MRgFUS',
'ablation',
'control',
'hysterectomy',
'med_manage',
'myomectomy',
'uae'}

Import demographic information

In [8]:
demographics = pd.read_excel('data/' + data_file, sheetname='ALL_DEMO_DATA', na_values=missing)
demographics.columns

Out[8]:
Index(['study_id', 'Citation', 'FamCode', 'FamDesig', 'NCT', 'ArmsN',
'ArmCategory', 'Group_Desc', 'New Grouping', 'Demo_Category',
'Demo_specify', 'BL N', 'Denom_N', 'BL %', 'BL Mean', 'BL SD', 'BL_SE',
'BL_Median', 'BL Min', 'BL Max', 'BL 95% L', 'BL 95% H',
dtype='object')

Extract columns of interest

In [9]:
age_data = demographics.loc[demographics.Demo_Category=='Age', ['study_id', 'New Grouping', 'BL Mean', 'BL SD']]


Clean arm labels

In [10]:
age_data = age_data.assign(arm=age_data['New Grouping'].str.replace(':','')).drop('New Grouping', axis=1)

In [11]:
age_data.arm.unique()

Out[11]:
array(['G2', 'G1', 'G1b', 'G1a', 'G3', 'CG', 'G1c', 'G1+G2', 'G1a+G1b+G1c'], dtype=object)

Concatenate all datasets

In [12]:
all_data = pd.concat(datasets)


Clean up study arm field

In [13]:
all_arm = all_data.trial_arm.str.replace(':','').str.replace(' ', '').str.replace('Group', 'G')
all_data = all_data.assign(arm=all_arm).drop('trial_arm', axis=1)

In [14]:
all_data.arm.unique()

Out[14]:
array(['G1', 'G2', 'G3', 'CG', 'G1a', 'G1b', 'G1c', 'CG1', 'CG2', 'G1/CG',
'CG/G1', 'G1a+G1b', 'G1a+G1b+G1c', 'G1+G2'], dtype=object)

Clean up study ID field. Currently contains non-numeric entries. Will strip out the first study ID from the compund labels, as this is the parent study ID.

In [15]:
all_data.study_id.unique()

Out[15]:
array([23, 347, 1400, 1529, 1806, 1889, 2375, 2967, 3382, 3690, 3785, 5186,
5474, 414, 1849, 3016, 3181, 3324, 3674, 4258, 4468, 4858, 4960,
5276, 5302, 6091, 6263, 6696, 7155, 7504, 7797, 7936, 95.0, 629.0,
757.0, 1290.0, 2318.0, 2555.0, 2635.0, 3312.0, 3978.0, 4787.0,
4961.0, 5721.0, 6393.0, 6903.0, 7139.0, 7309.0, 7530.0, 7589.0,
7763.0, '3803_3052', 1546, '3365_2026_1657_986',
'3819_815_1986_2759_2971_\n3120_3175_3192_3678_3721', 4789, 2006], dtype=object)
In [16]:
str_mask = all_data.study_id.str.isnumeric()==False
all_data.study_id = all_data.study_id.astype(int)

In [17]:
all_data.study_id.unique()

Out[17]:
array([  23,  347, 1400, 1529, 1806, 1889, 2375, 2967, 3382, 3690, 3785,
5186, 5474,  414, 1849, 3016, 3181, 3324, 3674, 4258, 4468, 4858,
4960, 5276, 5302, 6091, 6263, 6696, 7155, 7504, 7797, 7936,   95,
629,  757, 1290, 2318, 2555, 2635, 3312, 3978, 4787, 4961, 5721,
6393, 6903, 7139, 7309, 7530, 7589, 7763, 3803, 1546, 3365, 3819,
4789, 2006])

Here is what the data look like after merging.

In [18]:
all_data.head()

Out[18]:
study_id intervention baseline_n followup_interval followup_n hysterectomy myomectomy uae MRIgFUS ablation iud no_treatment intervention_cat arm
0 23 HIFU with CEUS 17 12 17 0 0 0 1 0 0 16 MRgFUS G1
1 23 HIFU 16 12 16 0 0 0 3 0 0 13 MRgFUS G2
2 347 UAE with SPVA 30 12 27 1 0 0 0 0 0 26 uae G1
3 347 UAE with TAG 30 12 29 0 0 0 0 0 0 29 uae G2
4 1400 UAE 63 6 62 0 1 5 0 0 0 56 uae G1
In [19]:
all_data.groupby('intervention_cat')['study_id'].count()

Out[19]:
intervention_cat
DROP              8
MRgFUS            2
ablation          3
control          11
hysterectomy      7
med_manage      100
myomectomy       14
uae              34
Name: study_id, dtype: int64

Merge age data with outcomes

In [20]:
all_data_merged = pd.merge(all_data, age_data, on=['study_id', 'arm'])


For now, drop arms with no reported followup time (we may want to impute these):

In [21]:
all_data_merged = all_data_merged.dropna(subset=['followup_interval'])


Parse followup intervals that are ranges, creating fup_min and fup_max fields.

In [22]:
dataset = all_data_merged.assign(fup_min=0, fup_max=all_data.followup_interval.convert_objects(convert_numeric=True).max()+1)
range_index = dataset.followup_interval.str.contains('to').notnull()
range_vals = dataset[range_index].followup_interval.apply(lambda x: x.split(' '))
dataset.loc[range_index, ['fup_min']] = range_vals.apply(lambda x: float(x[0]))
dataset.loc[range_index, ['fup_max']] = range_vals.apply(lambda x: float(x[-1]))
dataset.loc[range_index, ['followup_interval']] = -999
dataset['followup_interval'] = dataset.followup_interval.astype(float)

In [23]:
dataset.head()

Out[23]:
study_id intervention baseline_n followup_interval followup_n hysterectomy myomectomy uae MRIgFUS ablation iud no_treatment intervention_cat arm BL Mean BL SD fup_max fup_min
0 23 HIFU with CEUS 17 12 17 0 0 0 1 0 0 16 MRgFUS G1 43.1 5.3 61 0
1 23 HIFU 16 12 16 0 0 0 3 0 0 13 MRgFUS G2 42 5.4 61 0
2 347 UAE with SPVA 30 12 27 1 0 0 0 0 0 26 uae G1 43.9 5.0 61 0
3 347 UAE with TAG 30 12 29 0 0 0 0 0 0 29 uae G2 41.7 5.4 61 0
4 1400 UAE 63 6 62 0 1 5 0 0 0 56 uae G1 41 3.5 61 0

Fill missing values

In [24]:
dataset.loc[dataset.followup_n.isnull(), 'followup_n'] = dataset.loc[dataset.followup_n.isnull(), 'baseline_n']

In [25]:
dataset.loc[dataset.no_treatment.isnull(), 'no_treatment'] = dataset.followup_n - dataset[[ 'hysterectomy', 'myomectomy', 'uae',
'MRIgFUS', 'ablation', 'iud']].sum(1)[dataset.no_treatment.isnull()]

In [26]:
dataset.followup_interval.unique()

Out[26]:
array([  12. ,    6. , -999. ,   24. ,    2. ,    1. ,    3. ,    5.5,
9. ,   18. ,    0. ,    7. ,   60. ])
In [27]:
crossover_studies = 7155, 3324, 414, 95, 7139, 6903, 3721, 3181, 4858, 4960, 4258, 4789, 2006, 2318

In [28]:
uae_data = dataset[dataset.intervention_cat=='uae']

In [29]:
uae_data.columns

Out[29]:
Index(['study_id', 'intervention', 'baseline_n', 'followup_interval',
'followup_n', 'hysterectomy', 'myomectomy', 'uae', 'MRIgFUS',
'ablation', 'iud', 'no_treatment', 'intervention_cat', 'arm', 'BL Mean',
'BL SD', 'fup_max', 'fup_min'],
dtype='object')
In [30]:
studies = uae_data.study_id.unique()
studies

Out[30]:
array([ 347, 1400, 1529, 1806, 2967, 3382, 3785, 5186, 3674, 3803, 1546,
3365, 3819, 4789, 2006])
In [31]:
study_index = np.array([np.argwhere(studies==i).squeeze() for i in uae_data.study_id])

In [32]:
from numpy.ma import masked_values

followup_min, followup_max = uae_data[['fup_min', 'fup_max']].values.T

outcomes = uae_data[[ 'hysterectomy', 'myomectomy', 'uae',
'MRIgFUS', 'ablation', 'iud', 'no_treatment']].values

followup_n = uae_data.followup_n.values

age = uae_data['BL Mean'].values
# Center age at 40
age_centered = age - 40

study_id = uae_data.study_id.values

In [33]:
n_studies = len(set(study_id))
n_studies

Out[33]:
15
In [34]:
n_outcomes = 7
arms = len(outcomes)


Instantiate models

In [35]:
ablation_model = pm.Model()
hysterectomy_model = pm.Model()
med_manage_model = pm.Model()
myomectomy_model = pm.Model()
uae_model = pm.Model()

In [36]:
models = [ablation_model, hysterectomy_model, med_manage_model, myomectomy_model, uae_model]

In [37]:
import theano.tensor as T

SumTo1 = pm.transforms.SumTo1()
inverse_logit = pm.transforms.inverse_logit

def specify_model(model, intervention):

intervention_data = dataset[dataset.intervention_cat==intervention]

followup_min, followup_max = intervention_data[['fup_min', 'fup_max']].values.T

outcomes = intervention_data[[ 'hysterectomy', 'myomectomy', 'uae',
'MRIgFUS', 'ablation', 'iud', 'no_treatment']].values

followup_n = intervention_data.followup_n.values

age = intervention_data['BL Mean'].values
# Center age at 40
age_centered = age - 40

study_id = intervention_data.study_id.values

with model:

# Impute followup times
followup_time = pm.Uniform('followup_time', followup_min, followup_max,
shape=len(followup_min),

# Mean probabilities (on logit scale)
μ = pm.Normal('μ', 0, 0.01, shape=n_outcomes, testval=[-2.]*n_outcomes)
# Followup time covariates
β_fup = pm.Normal('β_fup', 0, 0.01, shape=n_outcomes, testval=np.zeros(n_outcomes))
# Age covariate
β_age = pm.Normal('β_age', 0, 0.01, shape=n_outcomes, testval=np.zeros(n_outcomes))

# Study random effect
τ = pm.Exponential('τ', 0.1, testval=1)
ϵ = pm.Normal('ϵ', 0, τ, shape=n_studies, testval=np.zeros(n_studies))

# Expected value (on logit scale)
θ_uae = [T.exp(μ + β_fup*followup_time[i] + β_age*age_centered[i] + ϵ[study_index[i]])
for i in range(arms)]

# Inverse-logit transformation to convert to probabilities
π = [pm.Dirichlet('π_%i' % i, t, shape=n_outcomes, testval=np.ones(n_outcomes))
for i,t in enumerate(θ_uae)]

# Multinomial data likelihood
likelihood = [pm.Multinomial('likelihood_%i' % i, followup_n[i], π[i],
observed=outcomes[i]) for i in range(arms)]

p_6 = pm.Dirichlet('p_6', T.exp(μ + β_fup*6), shape=n_outcomes)
p_12 = pm.Dirichlet('p_12', T.exp(μ + β_fup*12), shape=n_outcomes)
p_6_50 = pm.Dirichlet('p_6_50', T.exp(μ + β_fup*6 + β_age*10), shape=n_outcomes)

return model

In [38]:
uae_model = specify_model(uae_model, 'uae')

Applied log-transform to τ and added transformed τ_log to model.
Applied stickbreaking-transform to π_0 and added transformed π_0_stickbreaking to model.
Applied stickbreaking-transform to π_1 and added transformed π_1_stickbreaking to model.
Applied stickbreaking-transform to π_2 and added transformed π_2_stickbreaking to model.
Applied stickbreaking-transform to π_3 and added transformed π_3_stickbreaking to model.
Applied stickbreaking-transform to π_4 and added transformed π_4_stickbreaking to model.
Applied stickbreaking-transform to π_5 and added transformed π_5_stickbreaking to model.
Applied stickbreaking-transform to π_6 and added transformed π_6_stickbreaking to model.
Applied stickbreaking-transform to π_7 and added transformed π_7_stickbreaking to model.
Applied stickbreaking-transform to π_8 and added transformed π_8_stickbreaking to model.
Applied stickbreaking-transform to π_9 and added transformed π_9_stickbreaking to model.
Applied stickbreaking-transform to π_10 and added transformed π_10_stickbreaking to model.
Applied stickbreaking-transform to π_11 and added transformed π_11_stickbreaking to model.
Applied stickbreaking-transform to π_12 and added transformed π_12_stickbreaking to model.
Applied stickbreaking-transform to π_13 and added transformed π_13_stickbreaking to model.
Applied stickbreaking-transform to π_14 and added transformed π_14_stickbreaking to model.
Applied stickbreaking-transform to π_15 and added transformed π_15_stickbreaking to model.
Applied stickbreaking-transform to π_16 and added transformed π_16_stickbreaking to model.
Applied stickbreaking-transform to π_17 and added transformed π_17_stickbreaking to model.
Applied stickbreaking-transform to π_18 and added transformed π_18_stickbreaking to model.
Applied stickbreaking-transform to π_19 and added transformed π_19_stickbreaking to model.
Applied stickbreaking-transform to π_20 and added transformed π_20_stickbreaking to model.
Applied stickbreaking-transform to π_21 and added transformed π_21_stickbreaking to model.
Applied stickbreaking-transform to π_22 and added transformed π_22_stickbreaking to model.
Applied stickbreaking-transform to π_23 and added transformed π_23_stickbreaking to model.
Applied stickbreaking-transform to π_24 and added transformed π_24_stickbreaking to model.
Applied stickbreaking-transform to π_25 and added transformed π_25_stickbreaking to model.
Applied stickbreaking-transform to π_26 and added transformed π_26_stickbreaking to model.
Applied stickbreaking-transform to π_27 and added transformed π_27_stickbreaking to model.
Applied stickbreaking-transform to π_28 and added transformed π_28_stickbreaking to model.
Applied stickbreaking-transform to π_29 and added transformed π_29_stickbreaking to model.
Applied stickbreaking-transform to π_30 and added transformed π_30_stickbreaking to model.
Applied stickbreaking-transform to π_31 and added transformed π_31_stickbreaking to model.
Applied stickbreaking-transform to π_32 and added transformed π_32_stickbreaking to model.
Applied stickbreaking-transform to π_33 and added transformed π_33_stickbreaking to model.
Applied stickbreaking-transform to p_6 and added transformed p_6_stickbreaking to model.
Applied stickbreaking-transform to p_12 and added transformed p_12_stickbreaking to model.
Applied stickbreaking-transform to p_6_50 and added transformed p_6_50_stickbreaking to model.

In [39]:
with uae_model:

if True:

trace_uae = pm.sample(5000)

else:
trace_uae = pm.sample(20000, step=pm.Metropolis())

Assigned NUTS to followup_time_missing
Assigned NUTS to μ
Assigned NUTS to β_fup
Assigned NUTS to β_age
Assigned NUTS to τ_log
Assigned NUTS to ϵ
Assigned NUTS to π_0_stickbreaking
Assigned NUTS to π_1_stickbreaking
Assigned NUTS to π_2_stickbreaking
Assigned NUTS to π_3_stickbreaking
Assigned NUTS to π_4_stickbreaking
Assigned NUTS to π_5_stickbreaking
Assigned NUTS to π_6_stickbreaking
Assigned NUTS to π_7_stickbreaking
Assigned NUTS to π_8_stickbreaking
Assigned NUTS to π_9_stickbreaking
Assigned NUTS to π_10_stickbreaking
Assigned NUTS to π_11_stickbreaking
Assigned NUTS to π_12_stickbreaking
Assigned NUTS to π_13_stickbreaking
Assigned NUTS to π_14_stickbreaking
Assigned NUTS to π_15_stickbreaking
Assigned NUTS to π_16_stickbreaking
Assigned NUTS to π_17_stickbreaking
Assigned NUTS to π_18_stickbreaking
Assigned NUTS to π_19_stickbreaking
Assigned NUTS to π_20_stickbreaking
Assigned NUTS to π_21_stickbreaking
Assigned NUTS to π_22_stickbreaking
Assigned NUTS to π_23_stickbreaking
Assigned NUTS to π_24_stickbreaking
Assigned NUTS to π_25_stickbreaking
Assigned NUTS to π_26_stickbreaking
Assigned NUTS to π_27_stickbreaking
Assigned NUTS to π_28_stickbreaking
Assigned NUTS to π_29_stickbreaking
Assigned NUTS to π_30_stickbreaking
Assigned NUTS to π_31_stickbreaking
Assigned NUTS to π_32_stickbreaking
Assigned NUTS to π_33_stickbreaking
Assigned NUTS to p_6_stickbreaking
Assigned NUTS to p_12_stickbreaking
Assigned NUTS to p_6_50_stickbreaking
===============================
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_md48e5b5db0464960381d9655a49dfa63 {
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_V1;
00273
00274
00275	        __struct_compiled_op_md48e5b5db0464960381d9655a49dfa63() {
00276	            // This is only somewhat safe because we:
00277	            //  1) Are not a virtual class
00278	            //  2) Do not use any virtual classes in the members
00279	            //  3) Deal with mostly POD and pointers
00280
00281	            // If this changes, we would have to revise this, but for
00282	            // now I am tired of chasing segfaults because
00283	            // initialization code had an error and some pointer has
00284	            // a junk value.
00285	            memset(this, 0, sizeof(*this));
00286	        }
00287	        ~__struct_compiled_op_md48e5b5db0464960381d9655a49dfa63(void) {
00288	            cleanup();
00289	        }
00290
00291	        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_V1) {
00292	            Py_XINCREF(storage_V3);
00293	Py_XINCREF(storage_V5);
00294	Py_XINCREF(storage_V7);
00295	Py_XINCREF(storage_V9);
00296	Py_XINCREF(storage_V11);
00297	Py_XINCREF(storage_V13);
00298	Py_XINCREF(storage_V15);
00299	Py_XINCREF(storage_V17);
00300	Py_XINCREF(storage_V19);
00301	Py_XINCREF(storage_V21);
00302	Py_XINCREF(storage_V23);
00303	Py_XINCREF(storage_V25);
00304	Py_XINCREF(storage_V27);
00305	Py_XINCREF(storage_V29);
00306	Py_XINCREF(storage_V31);
00307	Py_XINCREF(storage_V33);
00308	Py_XINCREF(storage_V35);
00309	Py_XINCREF(storage_V37);
00310	Py_XINCREF(storage_V39);
00311	Py_XINCREF(storage_V41);
00312	Py_XINCREF(storage_V43);
00313	Py_XINCREF(storage_V45);
00314	Py_XINCREF(storage_V47);
00315	Py_XINCREF(storage_V49);
00316	Py_XINCREF(storage_V51);
00317	Py_XINCREF(storage_V53);
00318	Py_XINCREF(storage_V55);
00319	Py_XINCREF(storage_V57);
00320	Py_XINCREF(storage_V59);
00321	Py_XINCREF(storage_V61);
00322	Py_XINCREF(storage_V63);
00323	Py_XINCREF(storage_V65);
00324	Py_XINCREF(storage_V67);
00325	Py_XINCREF(storage_V69);
00326	Py_XINCREF(storage_V71);
00327	Py_XINCREF(storage_V73);
00328	Py_XINCREF(storage_V75);
00329	Py_XINCREF(storage_V77);
00330	Py_XINCREF(storage_V79);
00331	Py_XINCREF(storage_V81);
00332	Py_XINCREF(storage_V83);
00333	Py_XINCREF(storage_V85);
00334	Py_XINCREF(storage_V87);
00335	Py_XINCREF(storage_V89);
00336	Py_XINCREF(storage_V91);
00337	Py_XINCREF(storage_V93);
00338	Py_XINCREF(storage_V95);
00339	Py_XINCREF(storage_V97);
00340	Py_XINCREF(storage_V99);
00341	Py_XINCREF(storage_V101);
00342	Py_XINCREF(storage_V103);
00343	Py_XINCREF(storage_V105);
00344	Py_XINCREF(storage_V107);
00345	Py_XINCREF(storage_V109);
00346	Py_XINCREF(storage_V111);
00347	Py_XINCREF(storage_V113);
00348	Py_XINCREF(storage_V115);
00349	Py_XINCREF(storage_V117);
00350	Py_XINCREF(storage_V119);
00351	Py_XINCREF(storage_V121);
00352	Py_XINCREF(storage_V123);
00353	Py_XINCREF(storage_V125);
00354	Py_XINCREF(storage_V127);
00355	Py_XINCREF(storage_V129);
00356	Py_XINCREF(storage_V131);
00357	Py_XINCREF(storage_V133);
00358	Py_XINCREF(storage_V135);
00359	Py_XINCREF(storage_V137);
00360	Py_XINCREF(storage_V139);
00361	Py_XINCREF(storage_V141);
00362	Py_XINCREF(storage_V143);
00363	Py_XINCREF(storage_V145);
00364	Py_XINCREF(storage_V147);
00365	Py_XINCREF(storage_V149);
00366	Py_XINCREF(storage_V151);
00367	Py_XINCREF(storage_V153);
00368	Py_XINCREF(storage_V155);
00369	Py_XINCREF(storage_V157);
00370	Py_XINCREF(storage_V159);
00371	Py_XINCREF(storage_V161);
00372	Py_XINCREF(storage_V163);
00373	Py_XINCREF(storage_V165);
00374	Py_XINCREF(storage_V167);
00375	Py_XINCREF(storage_V169);
00376	Py_XINCREF(storage_V171);
00377	Py_XINCREF(storage_V173);
00378	Py_XINCREF(storage_V175);
00379	Py_XINCREF(storage_V177);
00380	Py_XINCREF(storage_V179);
00381	Py_XINCREF(storage_V181);
00382	Py_XINCREF(storage_V183);
00383	Py_XINCREF(storage_V185);
00384	Py_XINCREF(storage_V187);
00385	Py_XINCREF(storage_V189);
00386	Py_XINCREF(storage_V191);
00387	Py_XINCREF(storage_V193);
00388	Py_XINCREF(storage_V195);
00389	Py_XINCREF(storage_V197);
00390	Py_XINCREF(storage_V199);
00391	Py_XINCREF(storage_V201);
00392	Py_XINCREF(storage_V203);
00393	Py_XINCREF(storage_V205);
00394	Py_XINCREF(storage_V207);
00395	Py_XINCREF(storage_V209);
00396	Py_XINCREF(storage_V211);
00397	Py_XINCREF(storage_V213);
00398	Py_XINCREF(storage_V215);
00399	Py_XINCREF(storage_V217);
00400	Py_XINCREF(storage_V219);
00401	Py_XINCREF(storage_V221);
00402	Py_XINCREF(storage_V223);
00403	Py_XINCREF(storage_V225);
00404	Py_XINCREF(storage_V227);
00405	Py_XINCREF(storage_V229);
00406	Py_XINCREF(storage_V231);
00407	Py_XINCREF(storage_V233);
00408	Py_XINCREF(storage_V235);
00409	Py_XINCREF(storage_V237);
00410	Py_XINCREF(storage_V239);
00411	Py_XINCREF(storage_V241);
00412	Py_XINCREF(storage_V243);
00413	Py_XINCREF(storage_V245);
00414	Py_XINCREF(storage_V247);
00415	Py_XINCREF(storage_V249);
00416	Py_XINCREF(storage_V251);
00417	Py_XINCREF(storage_V253);
00418	Py_XINCREF(storage_V255);
00419	Py_XINCREF(storage_V257);
00420	Py_XINCREF(storage_V259);
00421	Py_XINCREF(storage_V261);
00422	Py_XINCREF(storage_V263);
00423	Py_XINCREF(storage_V265);
00424	Py_XINCREF(storage_V267);
00425	Py_XINCREF(storage_V269);
00426	Py_XINCREF(storage_V271);
00427	Py_XINCREF(storage_V273);
00428	Py_XINCREF(storage_V275);
00429	Py_XINCREF(storage_V277);
00430	Py_XINCREF(storage_V279);
00431	Py_XINCREF(storage_V281);
00432	Py_XINCREF(storage_V283);
00433	Py_XINCREF(storage_V285);
00434	Py_XINCREF(storage_V287);
00435	Py_XINCREF(storage_V289);
00436	Py_XINCREF(storage_V291);
00437	Py_XINCREF(storage_V293);
00438	Py_XINCREF(storage_V295);
00439	Py_XINCREF(storage_V297);
00440	Py_XINCREF(storage_V299);
00441	Py_XINCREF(storage_V301);
00442	Py_XINCREF(storage_V303);
00443	Py_XINCREF(storage_V305);
00444	Py_XINCREF(storage_V307);
00445	Py_XINCREF(storage_V309);
00446	Py_XINCREF(storage_V311);
00447	Py_XINCREF(storage_V313);
00448	Py_XINCREF(storage_V315);
00449	Py_XINCREF(storage_V317);
00450	Py_XINCREF(storage_V319);
00451	Py_XINCREF(storage_V321);
00452	Py_XINCREF(storage_V323);
00453	Py_XINCREF(storage_V325);
00454	Py_XINCREF(storage_V327);
00455	Py_XINCREF(storage_V329);
00456	Py_XINCREF(storage_V331);
00457	Py_XINCREF(storage_V333);
00458	Py_XINCREF(storage_V335);
00459	Py_XINCREF(storage_V337);
00460	Py_XINCREF(storage_V339);
00461	Py_XINCREF(storage_V341);
00462	Py_XINCREF(storage_V343);
00463	Py_XINCREF(storage_V345);
00464	Py_XINCREF(storage_V347);
00465	Py_XINCREF(storage_V349);
00466	Py_XINCREF(storage_V351);
00467	Py_XINCREF(storage_V353);
00468	Py_XINCREF(storage_V355);
00469	Py_XINCREF(storage_V357);
00470	Py_XINCREF(storage_V359);
00471	Py_XINCREF(storage_V361);
00472	Py_XINCREF(storage_V363);
00473	Py_XINCREF(storage_V365);
00474	Py_XINCREF(storage_V367);
00475	Py_XINCREF(storage_V369);
00476	Py_XINCREF(storage_V371);
00477	Py_XINCREF(storage_V373);
00478	Py_XINCREF(storage_V375);
00479	Py_XINCREF(storage_V377);
00480	Py_XINCREF(storage_V379);
00481	Py_XINCREF(storage_V381);
00482	Py_XINCREF(storage_V383);
00483	Py_XINCREF(storage_V385);
00484	Py_XINCREF(storage_V387);
00485	Py_XINCREF(storage_V389);
00486	Py_XINCREF(storage_V391);
00487	Py_XINCREF(storage_V393);
00488	Py_XINCREF(storage_V395);
00489	Py_XINCREF(storage_V397);
00490	Py_XINCREF(storage_V399);
00491	Py_XINCREF(storage_V401);
00492	Py_XINCREF(storage_V403);
00493	Py_XINCREF(storage_V405);
00494	Py_XINCREF(storage_V407);
00495	Py_XINCREF(storage_V409);
00496	Py_XINCREF(storage_V411);
00497	Py_XINCREF(storage_V413);
00498	Py_XINCREF(storage_V415);
00499	Py_XINCREF(storage_V417);
00500	Py_XINCREF(storage_V419);
00501	Py_XINCREF(storage_V421);
00502	Py_XINCREF(storage_V423);
00503	Py_XINCREF(storage_V425);
00504	Py_XINCREF(storage_V427);
00505	Py_XINCREF(storage_V429);
00506	Py_XINCREF(storage_V431);
00507	Py_XINCREF(storage_V433);
00508	Py_XINCREF(storage_V435);
00509	Py_XINCREF(storage_V437);
00510	Py_XINCREF(storage_V439);
00511	Py_XINCREF(storage_V441);
00512	Py_XINCREF(storage_V443);
00513	Py_XINCREF(storage_V445);
00514	Py_XINCREF(storage_V447);
00515	Py_XINCREF(storage_V449);
00516	Py_XINCREF(storage_V451);
00517	Py_XINCREF(storage_V453);
00518	Py_XINCREF(storage_V455);
00519	Py_XINCREF(storage_V457);
00520	Py_XINCREF(storage_V459);
00521	Py_XINCREF(storage_V461);
00522	Py_XINCREF(storage_V463);
00523	Py_XINCREF(storage_V465);
00524	Py_XINCREF(storage_V467);
00525	Py_XINCREF(storage_V469);
00526	Py_XINCREF(storage_V471);
00527	Py_XINCREF(storage_V473);
00528	Py_XINCREF(storage_V475);
00529	Py_XINCREF(storage_V477);
00530	Py_XINCREF(storage_V479);
00531	Py_XINCREF(storage_V481);
00532	Py_XINCREF(storage_V483);
00533	Py_XINCREF(storage_V485);
00534	Py_XINCREF(storage_V487);
00535	Py_XINCREF(storage_V489);
00536	Py_XINCREF(storage_V491);
00537	Py_XINCREF(storage_V493);
00538	Py_XINCREF(storage_V495);
00539	Py_XINCREF(storage_V497);
00540	Py_XINCREF(storage_V499);
00541	Py_XINCREF(storage_V501);
00542	Py_XINCREF(storage_V503);
00543	Py_XINCREF(storage_V505);
00544	Py_XINCREF(storage_V507);
00545	Py_XINCREF(storage_V509);
00546	Py_XINCREF(storage_V1);
00547	            this->storage_V3 = storage_V3;
00548	this->storage_V5 = storage_V5;
00549	this->storage_V7 = storage_V7;
00550	this->storage_V9 = storage_V9;
00551	this->storage_V11 = storage_V11;
00552	this->storage_V13 = storage_V13;
00553	this->storage_V15 = storage_V15;
00554	this->storage_V17 = storage_V17;
00555	this->storage_V19 = storage_V19;
00556	this->storage_V21 = storage_V21;
00557	this->storage_V23 = storage_V23;
00558	this->storage_V25 = storage_V25;
00559	this->storage_V27 = storage_V27;
00560	this->storage_V29 = storage_V29;
00561	this->storage_V31 = storage_V31;
00562	this->storage_V33 = storage_V33;
00563	this->storage_V35 = storage_V35;
00564	this->storage_V37 = storage_V37;
00565	this->storage_V39 = storage_V39;
00566	this->storage_V41 = storage_V41;
00567	this->storage_V43 = storage_V43;
00568	this->storage_V45 = storage_V45;
00569	this->storage_V47 = storage_V47;
00570	this->storage_V49 = storage_V49;
00571	this->storage_V51 = storage_V51;
00572	this->storage_V53 = storage_V53;
00573	this->storage_V55 = storage_V55;
00574	this->storage_V57 = storage_V57;
00575	this->storage_V59 = storage_V59;
00576	this->storage_V61 = storage_V61;
00577	this->storage_V63 = storage_V63;
00578	this->storage_V65 = storage_V65;
00579	this->storage_V67 = storage_V67;
00580	this->storage_V69 = storage_V69;
00581	this->storage_V71 = storage_V71;
00582	this->storage_V73 = storage_V73;
00583	this->storage_V75 = storage_V75;
00584	this->storage_V77 = storage_V77;
00585	this->storage_V79 = storage_V79;
00586	this->storage_V81 = storage_V81;
00587	this->storage_V83 = storage_V83;
00588	this->storage_V85 = storage_V85;
00589	this->storage_V87 = storage_V87;
00590	this->storage_V89 = storage_V89;
00591	this->storage_V91 = storage_V91;
00592	this->storage_V93 = storage_V93;
00593	this->storage_V95 = storage_V95;
00594	this->storage_V97 = storage_V97;
00595	this->storage_V99 = storage_V99;
00596	this->storage_V101 = storage_V101;
00597	this->storage_V103 = storage_V103;
00598	this->storage_V105 = storage_V105;
00599	this->storage_V107 = storage_V107;
00600	this->storage_V109 = storage_V109;
00601	this->storage_V111 = storage_V111;
00602	this->storage_V113 = storage_V113;
00603	this->storage_V115 = storage_V115;
00604	this->storage_V117 = storage_V117;
00605	this->storage_V119 = storage_V119;
00606	this->storage_V121 = storage_V121;
00607	this->storage_V123 = storage_V123;
00608	this->storage_V125 = storage_V125;
00609	this->storage_V127 = storage_V127;
00610	this->storage_V129 = storage_V129;
00611	this->storage_V131 = storage_V131;
00612	this->storage_V133 = storage_V133;
00613	this->storage_V135 = storage_V135;
00614	this->storage_V137 = storage_V137;
00615	this->storage_V139 = storage_V139;
00616	this->storage_V141 = storage_V141;
00617	this->storage_V143 = storage_V143;
00618	this->storage_V145 = storage_V145;
00619	this->storage_V147 = storage_V147;
00620	this->storage_V149 = storage_V149;
00621	this->storage_V151 = storage_V151;
00622	this->storage_V153 = storage_V153;
00623	this->storage_V155 = storage_V155;
00624	this->storage_V157 = storage_V157;
00625	this->storage_V159 = storage_V159;
00626	this->storage_V161 = storage_V161;
00627	this->storage_V163 = storage_V163;
00628	this->storage_V165 = storage_V165;
00629	this->storage_V167 = storage_V167;
00630	this->storage_V169 = storage_V169;
00631	this->storage_V171 = storage_V171;
00632	this->storage_V173 = storage_V173;
00633	this->storage_V175 = storage_V175;
00634	this->storage_V177 = storage_V177;
00635	this->storage_V179 = storage_V179;
00636	this->storage_V181 = storage_V181;
00637	this->storage_V183 = storage_V183;
00638	this->storage_V185 = storage_V185;
00639	this->storage_V187 = storage_V187;
00640	this->storage_V189 = storage_V189;
00641	this->storage_V191 = storage_V191;
00642	this->storage_V193 = storage_V193;
00643	this->storage_V195 = storage_V195;
00644	this->storage_V197 = storage_V197;
00645	this->storage_V199 = storage_V199;
00646	this->storage_V201 = storage_V201;
00647	this->storage_V203 = storage_V203;
00648	this->storage_V205 = storage_V205;
00649	this->storage_V207 = storage_V207;
00650	this->storage_V209 = storage_V209;
00651	this->storage_V211 = storage_V211;
00652	this->storage_V213 = storage_V213;
00653	this->storage_V215 = storage_V215;
00654	this->storage_V217 = storage_V217;
00655	this->storage_V219 = storage_V219;
00656	this->storage_V221 = storage_V221;
00657	this->storage_V223 = storage_V223;
00658	this->storage_V225 = storage_V225;
00659	this->storage_V227 = storage_V227;
00660	this->storage_V229 = storage_V229;
00661	this->storage_V231 = storage_V231;
00662	this->storage_V233 = storage_V233;
00663	this->storage_V235 = storage_V235;
00664	this->storage_V237 = storage_V237;
00665	this->storage_V239 = storage_V239;
00666	this->storage_V241 = storage_V241;
00667	this->storage_V243 = storage_V243;
00668	this->storage_V245 = storage_V245;
00669	this->storage_V247 = storage_V247;
00670	this->storage_V249 = storage_V249;
00671	this->storage_V251 = storage_V251;
00672	this->storage_V253 = storage_V253;
00673	this->storage_V255 = storage_V255;
00674	this->storage_V257 = storage_V257;
00675	this->storage_V259 = storage_V259;
00676	this->storage_V261 = storage_V261;
00677	this->storage_V263 = storage_V263;
00678	this->storage_V265 = storage_V265;
00679	this->storage_V267 = storage_V267;
00680	this->storage_V269 = storage_V269;
00681	this->storage_V271 = storage_V271;
00682	this->storage_V273 = storage_V273;
00683	this->storage_V275 = storage_V275;
00684	this->storage_V277 = storage_V277;
00685	this->storage_V279 = storage_V279;
00686	this->storage_V281 = storage_V281;
00687	this->storage_V283 = storage_V283;
00688	this->storage_V285 = storage_V285;
00689	this->storage_V287 = storage_V287;
00690	this->storage_V289 = storage_V289;
00691	this->storage_V291 = storage_V291;
00692	this->storage_V293 = storage_V293;
00693	this->storage_V295 = storage_V295;
00694	this->storage_V297 = storage_V297;
00695	this->storage_V299 = storage_V299;
00696	this->storage_V301 = storage_V301;
00697	this->storage_V303 = storage_V303;
00698	this->storage_V305 = storage_V305;
00699	this->storage_V307 = storage_V307;
00700	this->storage_V309 = storage_V309;
00701	this->storage_V311 = storage_V311;
00702	this->storage_V313 = storage_V313;
00703	this->storage_V315 = storage_V315;
00704	this->storage_V317 = storage_V317;
00705	this->storage_V319 = storage_V319;
00706	this->storage_V321 = storage_V321;
00707	this->storage_V323 = storage_V323;
00708	this->storage_V325 = storage_V325;
00709	this->storage_V327 = storage_V327;
00710	this->storage_V329 = storage_V329;
00711	this->storage_V331 = storage_V331;
00712	this->storage_V333 = storage_V333;
00713	this->storage_V335 = storage_V335;
00714	this->storage_V337 = storage_V337;
00715	this->storage_V339 = storage_V339;
00716	this->storage_V341 = storage_V341;
00717	this->storage_V343 = storage_V343;
00718	this->storage_V345 = storage_V345;
00719	this->storage_V347 = storage_V347;
00720	this->storage_V349 = storage_V349;
00721	this->storage_V351 = storage_V351;
00722	this->storage_V353 = storage_V353;
00723	this->storage_V355 = storage_V355;
00724	this->storage_V357 = storage_V357;
00725	this->storage_V359 = storage_V359;
00726	this->storage_V361 = storage_V361;
00727	this->storage_V363 = storage_V363;
00728	this->storage_V365 = storage_V365;
00729	this->storage_V367 = storage_V367;
00730	this->storage_V369 = storage_V369;
00731	this->storage_V371 = storage_V371;
00732	this->storage_V373 = storage_V373;
00733	this->storage_V375 = storage_V375;
00734	this->storage_V377 = storage_V377;
00735	this->storage_V379 = storage_V379;
00736	this->storage_V381 = storage_V381;
00737	this->storage_V383 = storage_V383;
00738	this->storage_V385 = storage_V385;
00739	this->storage_V387 = storage_V387;
00740	this->storage_V389 = storage_V389;
00741	this->storage_V391 = storage_V391;
00742	this->storage_V393 = storage_V393;
00743	this->storage_V395 = storage_V395;
00744	this->storage_V397 = storage_V397;
00745	this->storage_V399 = storage_V399;
00746	this->storage_V401 = storage_V401;
00747	this->storage_V403 = storage_V403;
00748	this->storage_V405 = storage_V405;
00749	this->storage_V407 = storage_V407;
00750	this->storage_V409 = storage_V409;
00751	this->storage_V411 = storage_V411;
00752	this->storage_V413 = storage_V413;
00753	this->storage_V415 = storage_V415;
00754	this->storage_V417 = storage_V417;
00755	this->storage_V419 = storage_V419;
00756	this->storage_V421 = storage_V421;
00757	this->storage_V423 = storage_V423;
00758	this->storage_V425 = storage_V425;
00759	this->storage_V427 = storage_V427;
00760	this->storage_V429 = storage_V429;
00761	this->storage_V431 = storage_V431;
00762	this->storage_V433 = storage_V433;
00763	this->storage_V435 = storage_V435;
00764	this->storage_V437 = storage_V437;
00765	this->storage_V439 = storage_V439;
00766	this->storage_V441 = storage_V441;
00767	this->storage_V443 = storage_V443;
00768	this->storage_V445 = storage_V445;
00769	this->storage_V447 = storage_V447;
00770	this->storage_V449 = storage_V449;
00771	this->storage_V451 = storage_V451;
00772	this->storage_V453 = storage_V453;
00773	this->storage_V455 = storage_V455;
00774	this->storage_V457 = storage_V457;
00775	this->storage_V459 = storage_V459;
00776	this->storage_V461 = storage_V461;
00777	this->storage_V463 = storage_V463;
00778	this->storage_V465 = storage_V465;
00779	this->storage_V467 = storage_V467;
00780	this->storage_V469 = storage_V469;
00781	this->storage_V471 = storage_V471;
00782	this->storage_V473 = storage_V473;
00783	this->storage_V475 = storage_V475;
00784	this->storage_V477 = storage_V477;
00785	this->storage_V479 = storage_V479;
00786	this->storage_V481 = storage_V481;
00787	this->storage_V483 = storage_V483;
00788	this->storage_V485 = storage_V485;
00789	this->storage_V487 = storage_V487;
00790	this->storage_V489 = storage_V489;
00791	this->storage_V491 = storage_V491;
00792	this->storage_V493 = storage_V493;
00793	this->storage_V495 = storage_V495;
00794	this->storage_V497 = storage_V497;
00795	this->storage_V499 = storage_V499;
00796	this->storage_V501 = storage_V501;
00797	this->storage_V503 = storage_V503;
00798	this->storage_V505 = storage_V505;
00799	this->storage_V507 = storage_V507;
00800	this->storage_V509 = storage_V509;
00801	this->storage_V1 = storage_V1;
00802
00803
00804
00805
00806
00807
00808
00809
00810
00811
00812
00813
00814
00815
00816
00817
00818
00819
00820
00821
00822
00823
00824
00825
00826
00827
00828
00829
00830
00831
00832
00833
00834
00835
00836
00837
00838
00839
00840
00841
00842
00843
00844
00845
00846
00847
00848
00849
00850
00851
00852
00853
00854
00855
00856
00857
00858
00859
00860
00861
00862
00863
00864
00865
00866
00867
00868
00869
00870
00871
00872
00873
00874
00875
00876
00877
00878
00879
00880
00881
00882
00883
00884
00885
00886
00887
00888
00889
00890
00891
00892
00893
00894
00895
00896
00897
00898
00899
00900
00901
00902
00903
00904
00905
00906
00907
00908
00909
00910
00911
00912
00913
00914
00915
00916
00917
00918
00919
00920
00921
00922
00923
00924
00925
00926
00927
00928
00929
00930
00931
00932
00933
00934
00935
00936
00937
00938
00939
00940
00941
00942
00943
00944
00945
00946
00947
00948
00949
00950
00951
00952
00953
00954
00955
00956
00957
00958
00959
00960
00961
00962
00963
00964
00965
00966
00967
00968
00969
00970
00971
00972
00973
00974
00975
00976
00977
00978
00979
00980
00981
00982
00983
00984
00985
00986
00987
00988
00989
00990
00991
00992
00993
00994
00995
00996
00997
00998
00999
01000
01001
01002
01003
01004
01005
01006
01007
01008
01009
01010
01011
01012
01013
01014
01015
01016
01017
01018
01019
01020
01021
01022
01023
01024
01025
01026
01027
01028
01029
01030
01031
01032
01033
01034
01035
01036
01037
01038
01039
01040
01041
01042
01043
01044
01045
01046
01047
01048
01049
01050
01051
01052
01053
01054
01055
01056
01057
01058
01059	            this->__ERROR = __ERROR;
01060	            return 0;
01061	        }
01062	        void cleanup(void) {
01063	            __label_1:
01064
01065	double __DUMMY_1;
01066	__label_3:
01067
01068	double __DUMMY_3;
01069	__label_5:
01070
01071	double __DUMMY_5;
01072	__label_7:
01073
01074	double __DUMMY_7;
01075	__label_9:
01076
01077	double __DUMMY_9;
01078	__label_11:
01079
01080	double __DUMMY_11;
01081	__label_13:
01082
01083	double __DUMMY_13;
01084	__label_15:
01085
01086	double __DUMMY_15;
01087	__label_17:
01088
01089	double __DUMMY_17;
01090	__label_19:
01091
01092	double __DUMMY_19;
01093	__label_21:
01094
01095	double __DUMMY_21;
01096	__label_23:
01097
01098	double __DUMMY_23;
01099	__label_25:
01100
01101	double __DUMMY_25;
01102	__label_27:
01103
01104	double __DUMMY_27;
01105	__label_29:
01106
01107	double __DUMMY_29;
01108	__label_31:
01109
01110	double __DUMMY_31;
01111	__label_33:
01112
01113	double __DUMMY_33;
01114	__label_35:
01115
01116	double __DUMMY_35;
01117	__label_37:
01118
01119	double __DUMMY_37;
01120	__label_39:
01121
01122	double __DUMMY_39;
01123	__label_41:
01124
01125	double __DUMMY_41;
01126	__label_43:
01127
01128	double __DUMMY_43;
01129	__label_45:
01130
01131	double __DUMMY_45;
01132	__label_47:
01133
01134	double __DUMMY_47;
01135	__label_49:
01136
01137	double __DUMMY_49;
01138	__label_51:
01139
01140	double __DUMMY_51;
01141	__label_53:
01142
01143	double __DUMMY_53;
01144	__label_55:
01145
01146	double __DUMMY_55;
01147	__label_57:
01148
01149	double __DUMMY_57;
01150	__label_59:
01151
01152	double __DUMMY_59;
01153	__label_61:
01154
01155	double __DUMMY_61;
01156	__label_63:
01157
01158	double __DUMMY_63;
01159	__label_65:
01160
01161	double __DUMMY_65;
01162	__label_67:
01163
01164	double __DUMMY_67;
01165	__label_69:
01166
01167	double __DUMMY_69;
01168	__label_71:
01169
01170	double __DUMMY_71;
01171	__label_73:
01172
01173	double __DUMMY_73;
01174	__label_75:
01175
01176	double __DUMMY_75;
01177	__label_77:
01178
01179	double __DUMMY_77;
01180	__label_79:
01181
01182	double __DUMMY_79;
01183	__label_81:
01184
01185	double __DUMMY_81;
01186	__label_83:
01187
01188	double __DUMMY_83;
01189	__label_85:
01190
01191	double __DUMMY_85;
01192	__label_87:
01193
01194	double __DUMMY_87;
01195	__label_89:
01196
01197	double __DUMMY_89;
01198	__label_91:
01199
01200	double __DUMMY_91;
01201	__label_93:
01202
01203	double __DUMMY_93;
01204	__label_95:
01205
01206	double __DUMMY_95;
01207	__label_97:
01208
01209	double __DUMMY_97;
01210	__label_99:
01211
01212	double __DUMMY_99;
01213	__label_101:
01214
01215	double __DUMMY_101;
01216	__label_103:
01217
01218	double __DUMMY_103;
01219	__label_105:
01220
01221	double __DUMMY_105;
01222	__label_107:
01223
01224	double __DUMMY_107;
01225	__label_109:
01226
01227	double __DUMMY_109;
01228	__label_111:
01229
01230	double __DUMMY_111;
01231	__label_113:
01232
01233	double __DUMMY_113;
01234	__label_115:
01235
01236	double __DUMMY_115;
01237	__label_117:
01238
01239	double __DUMMY_117;
01240	__label_119:
01241
01242	double __DUMMY_119;
01243	__label_121:
01244
01245	double __DUMMY_121;
01246	__label_123:
01247
01248	double __DUMMY_123;
01249	__label_125:
01250
01251	double __DUMMY_125;
01252	__label_127:
01253
01254	double __DUMMY_127;
01255	__label_129:
01256
01257	double __DUMMY_129;
01258	__label_131:
01259
01260	double __DUMMY_131;
01261	__label_133:
01262
01263	double __DUMMY_133;
01264	__label_135:
01265
01266	double __DUMMY_135;
01267	__label_137:
01268
01269	double __DUMMY_137;
01270	__label_139:
01271
01272	double __DUMMY_139;
01273	__label_141:
01274
01275	double __DUMMY_141;
01276	__label_143:
01277
01278	double __DUMMY_143;
01279	__label_145:
01280
01281	double __DUMMY_145;
01282	__label_147:
01283
01284	double __DUMMY_147;
01285	__label_149:
01286
01287	double __DUMMY_149;
01288	__label_151:
01289
01290	double __DUMMY_151;
01291	__label_153:
01292
01293	double __DUMMY_153;
01294	__label_155:
01295
01296	double __DUMMY_155;
01297	__label_157:
01298
01299	double __DUMMY_157;
01300	__label_159:
01301
01302	double __DUMMY_159;
01303	__label_161:
01304
01305	double __DUMMY_161;
01306	__label_163:
01307
01308	double __DUMMY_163;
01309	__label_165:
01310
01311	double __DUMMY_165;
01312	__label_167:
01313
01314	double __DUMMY_167;
01315	__label_169:
01316
01317	double __DUMMY_169;
01318	__label_171:
01319
01320	double __DUMMY_171;
01321	__label_173:
01322
01323	double __DUMMY_173;
01324	__label_175:
01325
01326	double __DUMMY_175;
01327	__label_177:
01328
01329	double __DUMMY_177;
01330	__label_179:
01331
01332	double __DUMMY_179;
01333	__label_181:
01334
01335	double __DUMMY_181;
01336	__label_183:
01337
01338	double __DUMMY_183;
01339	__label_185:
01340
01341	double __DUMMY_185;
01342	__label_187:
01343
01344	double __DUMMY_187;
01345	__label_189:
01346
01347	double __DUMMY_189;
01348	__label_191:
01349
01350	double __DUMMY_191;
01351	__label_193:
01352
01353	double __DUMMY_193;
01354	__label_195:
01355
01356	double __DUMMY_195;
01357	__label_197:
01358
01359	double __DUMMY_197;
01360	__label_199:
01361
01362	double __DUMMY_199;
01363	__label_201:
01364
01365	double __DUMMY_201;
01366	__label_203:
01367
01368	double __DUMMY_203;
01369	__label_205:
01370
01371	double __DUMMY_205;
01372	__label_207:
01373
01374	double __DUMMY_207;
01375	__label_209:
01376
01377	double __DUMMY_209;
01378	__label_211:
01379
01380	double __DUMMY_211;
01381	__label_213:
01382
01383	double __DUMMY_213;
01384	__label_215:
01385
01386	double __DUMMY_215;
01387	__label_217:
01388
01389	double __DUMMY_217;
01390	__label_219:
01391
01392	double __DUMMY_219;
01393	__label_221:
01394
01395	double __DUMMY_221;
01396	__label_223:
01397
01398	double __DUMMY_223;
01399	__label_225:
01400
01401	double __DUMMY_225;
01402	__label_227:
01403
01404	double __DUMMY_227;
01405	__label_229:
01406
01407	double __DUMMY_229;
01408	__label_231:
01409
01410	double __DUMMY_231;
01411	__label_233:
01412
01413	double __DUMMY_233;
01414	__label_235:
01415
01416	double __DUMMY_235;
01417	__label_237:
01418
01419	double __DUMMY_237;
01420	__label_239:
01421
01422	double __DUMMY_239;
01423	__label_241:
01424
01425	double __DUMMY_241;
01426	__label_243:
01427
01428	double __DUMMY_243;
01429	__label_245:
01430
01431	double __DUMMY_245;
01432	__label_247:
01433
01434	double __DUMMY_247;
01435	__label_249:
01436
01437	double __DUMMY_249;
01438	__label_251:
01439
01440	double __DUMMY_251;
01441	__label_253:
01442
01443	double __DUMMY_253;
01444	__label_255:
01445
01446	double __DUMMY_255;
01447	__label_257:
01448
01449	double __DUMMY_257;
01450	__label_259:
01451
01452	double __DUMMY_259;
01453	__label_261:
01454
01455	double __DUMMY_261;
01456	__label_263:
01457
01458	double __DUMMY_263;
01459	__label_265:
01460
01461	double __DUMMY_265;
01462	__label_267:
01463
01464	double __DUMMY_267;
01465	__label_269:
01466
01467	double __DUMMY_269;
01468	__label_271:
01469
01470	double __DUMMY_271;
01471	__label_273:
01472
01473	double __DUMMY_273;
01474	__label_275:
01475
01476	double __DUMMY_275;
01477	__label_277:
01478
01479	double __DUMMY_277;
01480	__label_279:
01481
01482	double __DUMMY_279;
01483	__label_281:
01484
01485	double __DUMMY_281;
01486	__label_283:
01487
01488	double __DUMMY_283;
01489	__label_285:
01490
01491	double __DUMMY_285;
01492	__label_287:
01493
01494	double __DUMMY_287;
01495	__label_289:
01496
01497	double __DUMMY_289;
01498	__label_291:
01499
01500	double __DUMMY_291;
01501	__label_293:
01502
01503	double __DUMMY_293;
01504	__label_295:
01505
01506	double __DUMMY_295;
01507	__label_297:
01508
01509	double __DUMMY_297;
01510	__label_299:
01511
01512	double __DUMMY_299;
01513	__label_301:
01514
01515	double __DUMMY_301;
01516	__label_303:
01517
01518	double __DUMMY_303;
01519	__label_305:
01520
01521	double __DUMMY_305;
01522	__label_307:
01523
01524	double __DUMMY_307;
01525	__label_309:
01526
01527	double __DUMMY_309;
01528	__label_311:
01529
01530	double __DUMMY_311;
01531	__label_313:
01532
01533	double __DUMMY_313;
01534	__label_315:
01535
01536	double __DUMMY_315;
01537	__label_317:
01538
01539	double __DUMMY_317;
01540	__label_319:
01541
01542	double __DUMMY_319;
01543	__label_321:
01544
01545	double __DUMMY_321;
01546	__label_323:
01547
01548	double __DUMMY_323;
01549	__label_325:
01550
01551	double __DUMMY_325;
01552	__label_327:
01553
01554	double __DUMMY_327;
01555	__label_329:
01556
01557	double __DUMMY_329;
01558	__label_331:
01559
01560	double __DUMMY_331;
01561	__label_333:
01562
01563	double __DUMMY_333;
01564	__label_335:
01565
01566	double __DUMMY_335;
01567	__label_337:
01568
01569	double __DUMMY_337;
01570	__label_339:
01571
01572	double __DUMMY_339;
01573	__label_341:
01574
01575	double __DUMMY_341;
01576	__label_343:
01577
01578	double __DUMMY_343;
01579	__label_345:
01580
01581	double __DUMMY_345;
01582	__label_347:
01583
01584	double __DUMMY_347;
01585	__label_349:
01586
01587	double __DUMMY_349;
01588	__label_351:
01589
01590	double __DUMMY_351;
01591	__label_353:
01592
01593	double __DUMMY_353;
01594	__label_355:
01595
01596	double __DUMMY_355;
01597	__label_357:
01598
01599	double __DUMMY_357;
01600	__label_359:
01601
01602	double __DUMMY_359;
01603	__label_361:
01604
01605	double __DUMMY_361;
01606	__label_363:
01607
01608	double __DUMMY_363;
01609	__label_365:
01610
01611	double __DUMMY_365;
01612	__label_367:
01613
01614	double __DUMMY_367;
01615	__label_369:
01616
01617	double __DUMMY_369;
01618	__label_371:
01619
01620	double __DUMMY_371;
01621	__label_373:
01622
01623	double __DUMMY_373;
01624	__label_375:
01625
01626	double __DUMMY_375;
01627	__label_377:
01628
01629	double __DUMMY_377;
01630	__label_379:
01631
01632	double __DUMMY_379;
01633	__label_381:
01634
01635	double __DUMMY_381;
01636	__label_383:
01637
01638	double __DUMMY_383;
01639	__label_385:
01640
01641	double __DUMMY_385;
01642	__label_387:
01643
01644	double __DUMMY_387;
01645	__label_389:
01646
01647	double __DUMMY_389;
01648	__label_391:
01649
01650	double __DUMMY_391;
01651	__label_393:
01652
01653	double __DUMMY_393;
01654	__label_395:
01655
01656	double __DUMMY_395;
01657	__label_397:
01658
01659	double __DUMMY_397;
01660	__label_399:
01661
01662	double __DUMMY_399;
01663	__label_401:
01664
01665	double __DUMMY_401;
01666	__label_403:
01667
01668	double __DUMMY_403;
01669	__label_405:
01670
01671	double __DUMMY_405;
01672	__label_407:
01673
01674	double __DUMMY_407;
01675	__label_409:
01676
01677	double __DUMMY_409;
01678	__label_411:
01679
01680	double __DUMMY_411;
01681	__label_413:
01682
01683	double __DUMMY_413;
01684	__label_415:
01685
01686	double __DUMMY_415;
01687	__label_417:
01688
01689	double __DUMMY_417;
01690	__label_419:
01691
01692	double __DUMMY_419;
01693	__label_421:
01694
01695	double __DUMMY_421;
01696	__label_423:
01697
01698	double __DUMMY_423;
01699	__label_425:
01700
01701	double __DUMMY_425;
01702	__label_427:
01703
01704	double __DUMMY_427;
01705	__label_429:
01706
01707	double __DUMMY_429;
01708	__label_431:
01709
01710	double __DUMMY_431;
01711	__label_433:
01712
01713	double __DUMMY_433;
01714	__label_435:
01715
01716	double __DUMMY_435;
01717	__label_437:
01718
01719	double __DUMMY_437;
01720	__label_439:
01721
01722	double __DUMMY_439;
01723	__label_441:
01724
01725	double __DUMMY_441;
01726	__label_443:
01727
01728	double __DUMMY_443;
01729	__label_445:
01730
01731	double __DUMMY_445;
01732	__label_447:
01733
01734	double __DUMMY_447;
01735	__label_449:
01736
01737	double __DUMMY_449;
01738	__label_451:
01739
01740	double __DUMMY_451;
01741	__label_453:
01742
01743	double __DUMMY_453;
01744	__label_455:
01745
01746	double __DUMMY_455;
01747	__label_457:
01748
01749	double __DUMMY_457;
01750	__label_459:
01751
01752	double __DUMMY_459;
01753	__label_461:
01754
01755	double __DUMMY_461;
01756	__label_463:
01757
01758	double __DUMMY_463;
01759	__label_465:
01760
01761	double __DUMMY_465;
01762	__label_467:
01763
01764	double __DUMMY_467;
01765	__label_469:
01766
01767	double __DUMMY_469;
01768	__label_471:
01769
01770	double __DUMMY_471;
01771	__label_473:
01772
01773	double __DUMMY_473;
01774	__label_475:
01775
01776	double __DUMMY_475;
01777	__label_477:
01778
01779	double __DUMMY_477;
01780	__label_479:
01781
01782	double __DUMMY_479;
01783	__label_481:
01784
01785	double __DUMMY_481;
01786	__label_483:
01787
01788	double __DUMMY_483;
01789	__label_485:
01790
01791	double __DUMMY_485;
01792	__label_487:
01793
01794	double __DUMMY_487;
01795	__label_489:
01796
01797	double __DUMMY_489;
01798	__label_491:
01799
01800	double __DUMMY_491;
01801	__label_493:
01802
01803	double __DUMMY_493;
01804	__label_495:
01805
01806	double __DUMMY_495;
01807	__label_497:
01808
01809	double __DUMMY_497;
01810	__label_499:
01811
01812	double __DUMMY_499;
01813	__label_501:
01814
01815	double __DUMMY_501;
01816	__label_503:
01817
01818	double __DUMMY_503;
01819	__label_505:
01820
01821	double __DUMMY_505;
01822	__label_507:
01823
01824	double __DUMMY_507;
01825	__label_509:
01826
01827	double __DUMMY_509;
01828	__label_512:
01829
01830	double __DUMMY_512;
01831
01832	            Py_XDECREF(this->storage_V3);
01833	Py_XDECREF(this->storage_V5);
01834	Py_XDECREF(this->storage_V7);
01835	Py_XDECREF(this->storage_V9);
01836	Py_XDECREF(this->storage_V11);
01837	Py_XDECREF(this->storage_V13);
01838	Py_XDECREF(this->storage_V15);
01839	Py_XDECREF(this->storage_V17);
01840	Py_XDECREF(this->storage_V19);
01841	Py_XDECREF(this->storage_V21);
01842	Py_XDECREF(this->storage_V23);
01843	Py_XDECREF(this->storage_V25);
01844	Py_XDECREF(this->storage_V27);
01845	Py_XDECREF(this->storage_V29);
01846	Py_XDECREF(this->storage_V31);
01847	Py_XDECREF(this->storage_V33);
01848	Py_XDECREF(this->storage_V35);
01849	Py_XDECREF(this->storage_V37);
01850	Py_XDECREF(this->storage_V39);
01851	Py_XDECREF(this->storage_V41);
01852	Py_XDECREF(this->storage_V43);
01853	Py_XDECREF(this->storage_V45);
01854	Py_XDECREF(this->storage_V47);
01855	Py_XDECREF(this->storage_V49);
01856	Py_XDECREF(this->storage_V51);
01857	Py_XDECREF(this->storage_V53);
01858	Py_XDECREF(this->storage_V55);
01859	Py_XDECREF(this->storage_V57);
01860	Py_XDECREF(this->storage_V59);
01861	Py_XDECREF(this->storage_V61);
01862	Py_XDECREF(this->storage_V63);
01863	Py_XDECREF(this->storage_V65);
01864	Py_XDECREF(this->storage_V67);
01865	Py_XDECREF(this->storage_V69);
01866	Py_XDECREF(this->storage_V71);
01867	Py_XDECREF(this->storage_V73);
01868	Py_XDECREF(this->storage_V75);
01869	Py_XDECREF(this->storage_V77);
01870	Py_XDECREF(this->storage_V79);
01871	Py_XDECREF(this->storage_V81);
01872	Py_XDECREF(this->storage_V83);
01873	Py_XDECREF(this->storage_V85);
01874	Py_XDECREF(this->storage_V87);
01875	Py_XDECREF(this->storage_V89);
01876	Py_XDECREF(this->storage_V91);
01877	Py_XDECREF(this->storage_V93);
01878	Py_XDECREF(this->storage_V95);
01879	Py_XDECREF(this->storage_V97);
01880	Py_XDECREF(this->storage_V99);
01881	Py_XDECREF(this->storage_V101);
01882	Py_XDECREF(this->storage_V103);
01883	Py_XDECREF(this->storage_V105);
01884	Py_XDECREF(this->storage_V107);
01885	Py_XDECREF(this->storage_V109);
01886	Py_XDECREF(this->storage_V111);
01887	Py_XDECREF(this->storage_V113);
01888	Py_XDECREF(this->storage_V115);
01889	Py_XDECREF(this->storage_V117);
01890	Py_XDECREF(this->storage_V119);
01891	Py_XDECREF(this->storage_V121);
01892	Py_XDECREF(this->storage_V123);
01893	Py_XDECREF(this->storage_V125);
01894	Py_XDECREF(this->storage_V127);
01895	Py_XDECREF(this->storage_V129);
01896	Py_XDECREF(this->storage_V131);
01897	Py_XDECREF(this->storage_V133);
01898	Py_XDECREF(this->storage_V135);
01899	Py_XDECREF(this->storage_V137);
01900	Py_XDECREF(this->storage_V139);
01901	Py_XDECREF(this->storage_V141);
01902	Py_XDECREF(this->storage_V143);
01903	Py_XDECREF(this->storage_V145);
01904	Py_XDECREF(this->storage_V147);
01905	Py_XDECREF(this->storage_V149);
01906	Py_XDECREF(this->storage_V151);
01907	Py_XDECREF(this->storage_V153);
01908	Py_XDECREF(this->storage_V155);
01909	Py_XDECREF(this->storage_V157);
01910	Py_XDECREF(this->storage_V159);
01911	Py_XDECREF(this->storage_V161);
01912	Py_XDECREF(this->storage_V163);
01913	Py_XDECREF(this->storage_V165);
01914	Py_XDECREF(this->storage_V167);
01915	Py_XDECREF(this->storage_V169);
01916	Py_XDECREF(this->storage_V171);
01917	Py_XDECREF(this->storage_V173);
01918	Py_XDECREF(this->storage_V175);
01919	Py_XDECREF(this->storage_V177);
01920	Py_XDECREF(this->storage_V179);
01921	Py_XDECREF(this->storage_V181);
01922	Py_XDECREF(this->storage_V183);
01923	Py_XDECREF(this->storage_V185);
01924	Py_XDECREF(this->storage_V187);
01925	Py_XDECREF(this->storage_V189);
01926	Py_XDECREF(this->storage_V191);
01927	Py_XDECREF(this->storage_V193);
01928	Py_XDECREF(this->storage_V195);
01929	Py_XDECREF(this->storage_V197);
01930	Py_XDECREF(this->storage_V199);
01931	Py_XDECREF(this->storage_V201);
01932	Py_XDECREF(this->storage_V203);
01933	Py_XDECREF(this->storage_V205);
01934	Py_XDECREF(this->storage_V207);
01935	Py_XDECREF(this->storage_V209);
01936	Py_XDECREF(this->storage_V211);
01937	Py_XDECREF(this->storage_V213);
01938	Py_XDECREF(this->storage_V215);
01939	Py_XDECREF(this->storage_V217);
01940	Py_XDECREF(this->storage_V219);
01941	Py_XDECREF(this->storage_V221);
01942	Py_XDECREF(this->storage_V223);
01943	Py_XDECREF(this->storage_V225);
01944	Py_XDECREF(this->storage_V227);
01945	Py_XDECREF(this->storage_V229);
01946	Py_XDECREF(this->storage_V231);
01947	Py_XDECREF(this->storage_V233);
01948	Py_XDECREF(this->storage_V235);
01949	Py_XDECREF(this->storage_V237);
01950	Py_XDECREF(this->storage_V239);
01951	Py_XDECREF(this->storage_V241);
01952	Py_XDECREF(this->storage_V243);
01953	Py_XDECREF(this->storage_V245);
01954	Py_XDECREF(this->storage_V247);
01955	Py_XDECREF(this->storage_V249);
01956	Py_XDECREF(this->storage_V251);
01957	Py_XDECREF(this->storage_V253);
01958	Py_XDECREF(this->storage_V255);
01959	Py_XDECREF(this->storage_V257);
01960	Py_XDECREF(this->storage_V259);
01961	Py_XDECREF(this->storage_V261);
01962	Py_XDECREF(this->storage_V263);
01963	Py_XDECREF(this->storage_V265);
01964	Py_XDECREF(this->storage_V267);
01965	Py_XDECREF(this->storage_V269);
01966	Py_XDECREF(this->storage_V271);
01967	Py_XDECREF(this->storage_V273);
01968	Py_XDECREF(this->storage_V275);
01969	Py_XDECREF(this->storage_V277);
01970	Py_XDECREF(this->storage_V279);
01971	Py_XDECREF(this->storage_V281);
01972	Py_XDECREF(this->storage_V283);
01973	Py_XDECREF(this->storage_V285);
01974	Py_XDECREF(this->storage_V287);
01975	Py_XDECREF(this->storage_V289);
01976	Py_XDECREF(this->storage_V291);
01977	Py_XDECREF(this->storage_V293);
01978	Py_XDECREF(this->storage_V295);
01979	Py_XDECREF(this->storage_V297);
01980	Py_XDECREF(this->storage_V299);
01981	Py_XDECREF(this->storage_V301);
01982	Py_XDECREF(this->storage_V303);
01983	Py_XDECREF(this->storage_V305);
01984	Py_XDECREF(this->storage_V307);
01985	Py_XDECREF(this->storage_V309);
01986	Py_XDECREF(this->storage_V311);
01987	Py_XDECREF(this->storage_V313);
01988	Py_XDECREF(this->storage_V315);
01989	Py_XDECREF(this->storage_V317);
01990	Py_XDECREF(this->storage_V319);
01991	Py_XDECREF(this->storage_V321);
01992	Py_XDECREF(this->storage_V323);
01993	Py_XDECREF(this->storage_V325);
01994	Py_XDECREF(this->storage_V327);
01995	Py_XDECREF(this->storage_V329);
01996	Py_XDECREF(this->storage_V331);
01997	Py_XDECREF(this->storage_V333);
01998	Py_XDECREF(this->storage_V335);
01999	Py_XDECREF(this->storage_V337);
02000	Py_XDECREF(this->storage_V339);
02001	Py_XDECREF(this->storage_V341);
02002	Py_XDECREF(this->storage_V343);
02003	Py_XDECREF(this->storage_V345);
02004	Py_XDECREF(this->storage_V347);
02005	Py_XDECREF(this->storage_V349);
02006	Py_XDECREF(this->storage_V351);
02007	Py_XDECREF(this->storage_V353);
02008	Py_XDECREF(this->storage_V355);
02009	Py_XDECREF(this->storage_V357);
02010	Py_XDECREF(this->storage_V359);
02011	Py_XDECREF(this->storage_V361);
02012	Py_XDECREF(this->storage_V363);
02013	Py_XDECREF(this->storage_V365);
02014	Py_XDECREF(this->storage_V367);
02015	Py_XDECREF(this->storage_V369);
02016	Py_XDECREF(this->storage_V371);
02017	Py_XDECREF(this->storage_V373);
02018	Py_XDECREF(this->storage_V375);
02019	Py_XDECREF(this->storage_V377);
02020	Py_XDECREF(this->storage_V379);
02021	Py_XDECREF(this->storage_V381);
02022	Py_XDECREF(this->storage_V383);
02023	Py_XDECREF(this->storage_V385);
02024	Py_XDECREF(this->storage_V387);
02025	Py_XDECREF(this->storage_V389);
02026	Py_XDECREF(this->storage_V391);
02027	Py_XDECREF(this->storage_V393);
02028	Py_XDECREF(this->storage_V395);
02029	Py_XDECREF(this->storage_V397);
02030	Py_XDECREF(this->storage_V399);
02031	Py_XDECREF(this->storage_V401);
02032	Py_XDECREF(this->storage_V403);
02033	Py_XDECREF(this->storage_V405);
02034	Py_XDECREF(this->storage_V407);
02035	Py_XDECREF(this->storage_V409);
02036	Py_XDECREF(this->storage_V411);
02037	Py_XDECREF(this->storage_V413);
02038	Py_XDECREF(this->storage_V415);
02039	Py_XDECREF(this->storage_V417);
02040	Py_XDECREF(this->storage_V419);
02041	Py_XDECREF(this->storage_V421);
02042	Py_XDECREF(this->storage_V423);
02043	Py_XDECREF(this->storage_V425);
02044	Py_XDECREF(this->storage_V427);
02045	Py_XDECREF(this->storage_V429);
02046	Py_XDECREF(this->storage_V431);
02047	Py_XDECREF(this->storage_V433);
02048	Py_XDECREF(this->storage_V435);
02049	Py_XDECREF(this->storage_V437);
02050	Py_XDECREF(this->storage_V439);
02051	Py_XDECREF(this->storage_V441);
02052	Py_XDECREF(this->storage_V443);
02053	Py_XDECREF(this->storage_V445);
02054	Py_XDECREF(this->storage_V447);
02055	Py_XDECREF(this->storage_V449);
02056	Py_XDECREF(this->storage_V451);
02057	Py_XDECREF(this->storage_V453);
02058	Py_XDECREF(this->storage_V455);
02059	Py_XDECREF(this->storage_V457);
02060	Py_XDECREF(this->storage_V459);
02061	Py_XDECREF(this->storage_V461);
02062	Py_XDECREF(this->storage_V463);
02063	Py_XDECREF(this->storage_V465);
02064	Py_XDECREF(this->storage_V467);
02065	Py_XDECREF(this->storage_V469);
02066	Py_XDECREF(this->storage_V471);
02067	Py_XDECREF(this->storage_V473);
02068	Py_XDECREF(this->storage_V475);
02069	Py_XDECREF(this->storage_V477);
02070	Py_XDECREF(this->storage_V479);
02071	Py_XDECREF(this->storage_V481);
02072	Py_XDECREF(this->storage_V483);
02073	Py_XDECREF(this->storage_V485);
02074	Py_XDECREF(this->storage_V487);
02075	Py_XDECREF(this->storage_V489);
02076	Py_XDECREF(this->storage_V491);
02077	Py_XDECREF(this->storage_V493);
02078	Py_XDECREF(this->storage_V495);
02079	Py_XDECREF(this->storage_V497);
02080	Py_XDECREF(this->storage_V499);
02081	Py_XDECREF(this->storage_V501);
02082	Py_XDECREF(this->storage_V503);
02083	Py_XDECREF(this->storage_V505);
02084	Py_XDECREF(this->storage_V507);
02085	Py_XDECREF(this->storage_V509);
02086	Py_XDECREF(this->storage_V1);
02087	        }
02088	        int run(void) {
02089	            int __failure = 0;
02090
02091	    PyObject* py_V1;
02092
02093	        PyArrayObject* V1;
02094
02095	            typedef npy_float64 dtype_V1;
02096
02097	    PyObject* py_V3;
02098
02099	        PyArrayObject* V3;
02100
02101	            typedef npy_float64 dtype_V3;
02102
02103	    PyObject* py_V5;
02104
02105	        PyArrayObject* V5;
02106
02107	            typedef npy_int8 dtype_V5;
02108
02109	    PyObject* py_V7;
02110
02111	        PyArrayObject* V7;
02112
02113	            typedef npy_float64 dtype_V7;
02114
02115	    PyObject* py_V9;
02116
02117	        PyArrayObject* V9;
02118
02119	            typedef npy_float64 dtype_V9;
02120
02121	    PyObject* py_V11;
02122
02123	        PyArrayObject* V11;
02124
02125	            typedef npy_float64 dtype_V11;
02126
02127	    PyObject* py_V13;
02128
02129	        PyArrayObject* V13;
02130
02131	            typedef npy_float64 dtype_V13;
02132
02133	    PyObject* py_V15;
02134
02135	        PyArrayObject* V15;
02136
02137	            typedef npy_int8 dtype_V15;
02138
02139	    PyObject* py_V17;
02140
02141	        PyArrayObject* V17;
02142
02143	            typedef npy_float64 dtype_V17;
02144
02145	    PyObject* py_V19;
02146
02147	        PyArrayObject* V19;
02148
02149	            typedef npy_float64 dtype_V19;
02150
02151	    PyObject* py_V21;
02152
02153	        PyArrayObject* V21;
02154
02155	            typedef npy_float64 dtype_V21;
02156
02157	    PyObject* py_V23;
02158
02159	        PyArrayObject* V23;
02160
02161	            typedef npy_float64 dtype_V23;
02162
02163	    PyObject* py_V25;
02164
02165	        PyArrayObject* V25;
02166
02167	            typedef npy_int8 dtype_V25;
02168
02169	    PyObject* py_V27;
02170
02171	        PyArrayObject* V27;
02172
02173	            typedef npy_float64 dtype_V27;
02174
02175	    PyObject* py_V29;
02176
02177	        PyArrayObject* V29;
02178
02179	            typedef npy_float64 dtype_V29;
02180
02181	    PyObject* py_V31;
02182
02183	        PyArrayObject* V31;
02184
02185	            typedef npy_float64 dtype_V31;
02186
02187	    PyObject* py_V33;
02188
02189	        PyArrayObject* V33;
02190
02191	            typedef npy_float64 dtype_V33;
02192
02193	    PyObject* py_V35;
02194
02195	        PyArrayObject* V35;
02196
02197	            typedef npy_float64 dtype_V35;
02198
02199	    PyObject* py_V37;
02200
02201	        PyArrayObject* V37;
02202
02203	            typedef npy_float64 dtype_V37;
02204
02205	    PyObject* py_V39;
02206
02207	        PyArrayObject* V39;
02208
02209	            typedef npy_float64 dtype_V39;
02210
02211	    PyObject* py_V41;
02212
02213	        PyArrayObject* V41;
02214
02215	            typedef npy_int8 dtype_V41;
02216
02217	    PyObject* py_V43;
02218
02219	        PyArrayObject* V43;
02220
02221	            typedef npy_float64 dtype_V43;
02222
02223	    PyObject* py_V45;
02224
02225	        PyArrayObject* V45;
02226
02227	            typedef npy_float64 dtype_V45;
02228
02229	    PyObject* py_V47;
02230
02231	        PyArrayObject* V47;
02232
02233	            typedef npy_float64 dtype_V47;
02234
02235	    PyObject* py_V49;
02236
02237	        PyArrayObject* V49;
02238
02239	            typedef npy_float64 dtype_V49;
02240
02241	    PyObject* py_V51;
02242
02243	        PyArrayObject* V51;
02244
02245	            typedef npy_float64 dtype_V51;
02246
02247	    PyObject* py_V53;
02248
02249	        PyArrayObject* V53;
02250
02251	            typedef npy_float64 dtype_V53;
02252
02253	    PyObject* py_V55;
02254
02255	        PyArrayObject* V55;
02256
02257	            typedef npy_float64 dtype_V55;
02258
02259	    PyObject* py_V57;
02260
02261	        PyArrayObject* V57;
02262
02263	            typedef npy_int8 dtype_V57;
02264
02265	    PyObject* py_V59;
02266
02267	        PyArrayObject* V59;
02268
02269	            typedef npy_float64 dtype_V59;
02270
02271	    PyObject* py_V61;
02272
02273	        PyArrayObject* V61;
02274
02275	            typedef npy_float64 dtype_V61;
02276
02277	    PyObject* py_V63;
02278
02279	        PyArrayObject* V63;
02280
02281	            typedef npy_float64 dtype_V63;
02282
02283	    PyObject* py_V65;
02284
02285	        PyArrayObject* V65;
02286
02287	            typedef npy_float64 dtype_V65;
02288
02289	    PyObject* py_V67;
02290
02291	        PyArrayObject* V67;
02292
02293	            typedef npy_float64 dtype_V67;
02294
02295	    PyObject* py_V69;
02296
02297	        PyArrayObject* V69;
02298
02299	            typedef npy_float64 dtype_V69;
02300
02301	    PyObject* py_V71;
02302
02303	        PyArrayObject* V71;
02304
02305	            typedef npy_int8 dtype_V71;
02306
02307	    PyObject* py_V73;
02308
02309	        PyArrayObject* V73;
02310
02311	            typedef npy_float64 dtype_V73;
02312
02313	    PyObject* py_V75;
02314
02315	        PyArrayObject* V75;
02316
02317	            typedef npy_float64 dtype_V75;
02318
02319	    PyObject* py_V77;
02320
02321	        PyArrayObject* V77;
02322
02323	            typedef npy_float64 dtype_V77;
02324
02325	    PyObject* py_V79;
02326
02327	        PyArrayObject* V79;
02328
02329	            typedef npy_float64 dtype_V79;
02330
02331	    PyObject* py_V81;
02332
02333	        PyArrayObject* V81;
02334
02335	            typedef npy_float64 dtype_V81;
02336
02337	    PyObject* py_V83;
02338
02339	        PyArrayObject* V83;
02340
02341	            typedef npy_int8 dtype_V83;
02342
02343	    PyObject* py_V85;
02344
02345	        PyArrayObject* V85;
02346
02347	            typedef npy_float64 dtype_V85;
02348
02349	    PyObject* py_V87;
02350
02351	        PyArrayObject* V87;
02352
02353	            typedef npy_float64 dtype_V87;
02354
02355	    PyObject* py_V89;
02356
02357	        PyArrayObject* V89;
02358
02359	            typedef npy_float64 dtype_V89;
02360
02361	    PyObject* py_V91;
02362
02363	        PyArrayObject* V91;
02364
02365	            typedef npy_float64 dtype_V91;
02366
02367	    PyObject* py_V93;
02368
02369	        PyArrayObject* V93;
02370
02371	            typedef npy_float64 dtype_V93;
02372
02373	    PyObject* py_V95;
02374
02375	        PyArrayObject* V95;
02376
02377	            typedef npy_int8 dtype_V95;
02378
02379	    PyObject* py_V97;
02380
02381	        PyArrayObject* V97;
02382
02383	            typedef npy_float64 dtype_V97;
02384
02385	    PyObject* py_V99;
02386
02387	        PyArrayObject* V99;
02388
02389	            typedef npy_float64 dtype_V99;
02390
02391	    PyObject* py_V101;
02392
02393	        PyArrayObject* V101;
02394
02395	            typedef npy_float64 dtype_V101;
02396
02397	    PyObject* py_V103;
02398
02399	        PyArrayObject* V103;
02400
02401	            typedef npy_float64 dtype_V103;
02402
02403	    PyObject* py_V105;
02404
02405	        PyArrayObject* V105;
02406
02407	            typedef npy_float64 dtype_V105;
02408
02409	    PyObject* py_V107;
02410
02411	        PyArrayObject* V107;
02412
02413	            typedef npy_int8 dtype_V107;
02414
02415	    PyObject* py_V109;
02416
02417	        PyArrayObject* V109;
02418
02419	            typedef npy_float64 dtype_V109;
02420
02421	    PyObject* py_V111;
02422
02423	        PyArrayObject* V111;
02424
02425	            typedef npy_float64 dtype_V111;
02426
02427	    PyObject* py_V113;
02428
02429	        PyArrayObject* V113;
02430
02431	            typedef npy_float64 dtype_V113;
02432
02433	    PyObject* py_V115;
02434
02435	        PyArrayObject* V115;
02436
02437	            typedef npy_float64 dtype_V115;
02438
02439	    PyObject* py_V117;
02440
02441	        PyArrayObject* V117;
02442
02443	            typedef npy_float64 dtype_V117;
02444
02445	    PyObject* py_V119;
02446
02447	        PyArrayObject* V119;
02448
02449	            typedef npy_float64 dtype_V119;
02450
02451	    PyObject* py_V121;
02452
02453	        PyArrayObject* V121;
02454
02455	            typedef npy_int8 dtype_V121;
02456
02457	    PyObject* py_V123;
02458
02459	        PyArrayObject* V123;
02460
02461	            typedef npy_float64 dtype_V123;
02462
02463	    PyObject* py_V125;
02464
02465	        PyArrayObject* V125;
02466
02467	            typedef npy_float64 dtype_V125;
02468
02469	    PyObject* py_V127;
02470
02471	        PyArrayObject* V127;
02472
02473	            typedef npy_float64 dtype_V127;
02474
02475	    PyObject* py_V129;
02476
02477	        PyArrayObject* V129;
02478
02479	            typedef npy_float64 dtype_V129;
02480
02481	    PyObject* py_V131;
02482
02483	        PyArrayObject* V131;
02484
02485	            typedef npy_float64 dtype_V131;
02486
02487	    PyObject* py_V133;
02488
02489	        PyArrayObject* V133;
02490
02491	            typedef npy_float64 dtype_V133;
02492
02493	    PyObject* py_V135;
02494
02495	        PyArrayObject* V135;
02496
02497	            typedef npy_int8 dtype_V135;
02498
02499	    PyObject* py_V137;
02500
02501	        PyArrayObject* V137;
02502
02503	            typedef npy_float64 dtype_V137;
02504
02505	    PyObject* py_V139;
02506
02507	        PyArrayObject* V139;
02508
02509	            typedef npy_float64 dtype_V139;
02510
02511	    PyObject* py_V141;
02512
02513	        PyArrayObject* V141;
02514
02515	            typedef npy_float64 dtype_V141;
02516
02517	    PyObject* py_V143;
02518
02519	        PyArrayObject* V143;
02520
02521	            typedef npy_float64 dtype_V143;
02522
02523	    PyObject* py_V145;
02524
02525	        PyArrayObject* V145;
02526
02527	            typedef npy_float64 dtype_V145;
02528
02529	    PyObject* py_V147;
02530
02531	        PyArrayObject* V147;
02532
02533	            typedef npy_int8 dtype_V147;
02534
02535	    PyObject* py_V149;
02536
02537	        PyArrayObject* V149;
02538
02539	            typedef npy_float64 dtype_V149;
02540
02541	    PyObject* py_V151;
02542
02543	        PyArrayObject* V151;
02544
02545	            typedef npy_float64 dtype_V151;
02546
02547	    PyObject* py_V153;
02548
02549	        PyArrayObject* V153;
02550
02551	            typedef npy_float64 dtype_V153;
02552
02553	    PyObject* py_V155;
02554
02555	        PyArrayObject* V155;
02556
02557	            typedef npy_float64 dtype_V155;
02558
02559	    PyObject* py_V157;
02560
02561	        PyArrayObject* V157;
02562
02563	            typedef npy_float64 dtype_V157;
02564
02565	    PyObject* py_V159;
02566
02567	        PyArrayObject* V159;
02568
02569	            typedef npy_float64 dtype_V159;
02570
02571	    PyObject* py_V161;
02572
02573	        PyArrayObject* V161;
02574
02575	            typedef npy_int8 dtype_V161;
02576
02577	    PyObject* py_V163;
02578
02579	        PyArrayObject* V163;
02580
02581	            typedef npy_float64 dtype_V163;
02582
02583	    PyObject* py_V165;
02584
02585	        PyArrayObject* V165;
02586
02587	            typedef npy_float64 dtype_V165;
02588
02589	    PyObject* py_V167;
02590
02591	        PyArrayObject* V167;
02592
02593	            typedef npy_float64 dtype_V167;
02594
02595	    PyObject* py_V169;
02596
02597	        PyArrayObject* V169;
02598
02599	            typedef npy_float64 dtype_V169;
02600
02601	    PyObject* py_V171;
02602
02603	        PyArrayObject* V171;
02604
02605	            typedef npy_float64 dtype_V171;
02606
02607	    PyObject* py_V173;
02608
02609	        PyArrayObject* V173;
02610
02611	            typedef npy_float64 dtype_V173;
02612
02613	    PyObject* py_V175;
02614
02615	        PyArrayObject* V175;
02616
02617	            typedef npy_int8 dtype_V175;
02618
02619	    PyObject* py_V177;
02620
02621	        PyArrayObject* V177;
02622
02623	            typedef npy_float64 dtype_V177;
02624
02625	    PyObject* py_V179;
02626
02627	        PyArrayObject* V179;
02628
02629	            typedef npy_float64 dtype_V179;
02630
02631	    PyObject* py_V181;
02632
02633	        PyArrayObject* V181;
02634
02635	            typedef npy_float64 dtype_V181;
02636
02637	    PyObject* py_V183;
02638
02639	        PyArrayObject* V183;
02640
02641	            typedef npy_float64 dtype_V183;
02642
02643	    PyObject* py_V185;
02644
02645	        PyArrayObject* V185;
02646
02647	            typedef npy_float64 dtype_V185;
02648
02649	    PyObject* py_V187;
02650
02651	        PyArrayObject* V187;
02652
02653	            typedef npy_float64 dtype_V187;
02654
02655	    PyObject* py_V189;
02656
02657	        PyArrayObject* V189;
02658
02659	            typedef npy_int8 dtype_V189;
02660
02661	    PyObject* py_V191;
02662
02663	        PyArrayObject* V191;
02664
02665	            typedef npy_float64 dtype_V191;
02666
02667	    PyObject* py_V193;
02668
02669	        PyArrayObject* V193;
02670
02671	            typedef npy_float64 dtype_V193;
02672
02673	    PyObject* py_V195;
02674
02675	        PyArrayObject* V195;
02676
02677	            typedef npy_float64 dtype_V195;
02678
02679	    PyObject* py_V197;
02680
02681	        PyArrayObject* V197;
02682
02683	            typedef npy_float64 dtype_V197;
02684
02685	    PyObject* py_V199;
02686
02687	        PyArrayObject* V199;
02688
02689	            typedef npy_float64 dtype_V199;
02690
02691	    PyObject* py_V201;
02692
02693	        PyArrayObject* V201;
02694
02695	            typedef npy_float64 dtype_V201;
02696
02697	    PyObject* py_V203;
02698
02699	        PyArrayObject* V203;
02700
02701	            typedef npy_int8 dtype_V203;
02702
02703	    PyObject* py_V205;
02704
02705	        PyArrayObject* V205;
02706
02707	            typedef npy_float64 dtype_V205;
02708
02709	    PyObject* py_V207;
02710
02711	        PyArrayObject* V207;
02712
02713	            typedef npy_float64 dtype_V207;
02714
02715	    PyObject* py_V209;
02716
02717	        PyArrayObject* V209;
02718
02719	            typedef npy_float64 dtype_V209;
02720
02721	    PyObject* py_V211;
02722
02723	        PyArrayObject* V211;
02724
02725	            typedef npy_float64 dtype_V211;
02726
02727	    PyObject* py_V213;
02728
02729	        PyArrayObject* V213;
02730
02731	            typedef npy_float64 dtype_V213;
02732
02733	    PyObject* py_V215;
02734
02735	        PyArrayObject* V215;
02736
02737	            typedef npy_int8 dtype_V215;
02738
02739	    PyObject* py_V217;
02740
02741	        PyArrayObject* V217;
02742
02743	            typedef npy_float64 dtype_V217;
02744
02745	    PyObject* py_V219;
02746
02747	        PyArrayObject* V219;
02748
02749	            typedef npy_float64 dtype_V219;
02750
02751	    PyObject* py_V221;
02752
02753	        PyArrayObject* V221;
02754
02755	            typedef npy_float64 dtype_V221;
02756
02757	    PyObject* py_V223;
02758
02759	        PyArrayObject* V223;
02760
02761	            typedef npy_float64 dtype_V223;
02762
02763	    PyObject* py_V225;
02764
02765	        PyArrayObject* V225;
02766
02767	            typedef npy_float64 dtype_V225;
02768
02769	    PyObject* py_V227;
02770
02771	        PyArrayObject* V227;
02772
02773	            typedef npy_float64 dtype_V227;
02774
02775	    PyObject* py_V229;
02776
02777	        PyArrayObject* V229;
02778
02779	            typedef npy_int8 dtype_V229;
02780
02781	    PyObject* py_V231;
02782
02783	        PyArrayObject* V231;
02784
02785	            typedef npy_float64 dtype_V231;
02786
02787	    PyObject* py_V233;
02788
02789	        PyArrayObject* V233;
02790
02791	            typedef npy_float64 dtype_V233;
02792
02793	    PyObject* py_V235;
02794
02795	        PyArrayObject* V235;
02796
02797	            typedef npy_float64 dtype_V235;
02798
02799	    PyObject* py_V237;
02800
02801	        PyArrayObject* V237;
02802
02803	            typedef npy_float64 dtype_V237;
02804
02805	    PyObject* py_V239;
02806
02807	        PyArrayObject* V239;
02808
02809	            typedef npy_float64 dtype_V239;
02810
02811	    PyObject* py_V241;
02812
02813	        PyArrayObject* V241;
02814
02815	            typedef npy_float64 dtype_V241;
02816
02817	    PyObject* py_V243;
02818
02819	        PyArrayObject* V243;
02820
02821	            typedef npy_float64 dtype_V243;
02822
02823	    PyObject* py_V245;
02824
02825	        PyArrayObject* V245;
02826
02827	            typedef npy_int8 dtype_V245;
02828
02829	    PyObject* py_V247;
02830
02831	        PyArrayObject* V247;
02832
02833	            typedef npy_float64 dtype_V247;
02834
02835	    PyObject* py_V249;
02836
02837	        PyArrayObject* V249;
02838
02839	            typedef npy_float64 dtype_V249;
02840
02841	    PyObject* py_V251;
02842
02843	        PyArrayObject* V251;
02844
02845	            typedef npy_float64 dtype_V251;
02846
02847	    PyObject* py_V253;
02848
02849	        PyArrayObject* V253;
02850
02851	            typedef npy_float64 dtype_V253;
02852
02853	    PyObject* py_V255;
02854
02855	        PyArrayObject* V255;
02856
02857	            typedef npy_float64 dtype_V255;
02858
02859	    PyObject* py_V257;
02860
02861	        PyArrayObject* V257;
02862
02863	            typedef npy_float64 dtype_V257;
02864
02865	    PyObject* py_V259;
02866
02867	        PyArrayObject* V259;
02868
02869	            typedef npy_float64 dtype_V259;
02870
02871	    PyObject* py_V261;
02872
02873	        PyArrayObject* V261;
02874
02875	            typedef npy_int8 dtype_V261;
02876
02877	    PyObject* py_V263;
02878
02879	        PyArrayObject* V263;
02880
02881	            typedef npy_float64 dtype_V263;
02882
02883	    PyObject* py_V265;
02884
02885	        PyArrayObject* V265;
02886
02887	            typedef npy_float64 dtype_V265;
02888
02889	    PyObject* py_V267;
02890
02891	        PyArrayObject* V267;
02892
02893	            typedef npy_float64 dtype_V267;
02894
02895	    PyObject* py_V269;
02896
02897	        PyArrayObject* V269;
02898
02899	            typedef npy_float64 dtype_V269;
02900
02901	    PyObject* py_V271;
02902
02903	        PyArrayObject* V271;
02904
02905	            typedef npy_float64 dtype_V271;
02906
02907	    PyObject* py_V273;
02908
02909	        PyArrayObject* V273;
02910
02911	            typedef npy_float64 dtype_V273;
02912
02913	    PyObject* py_V275;
02914
02915	        PyArrayObject* V275;
02916
02917	            typedef npy_int8 dtype_V275;
02918
02919	    PyObject* py_V277;
02920
02921	        PyArrayObject* V277;
02922
02923	            typedef npy_float64 dtype_V277;
02924
02925	    PyObject* py_V279;
02926
02927	        PyArrayObject* V279;
02928
02929	            typedef npy_float64 dtype_V279;
02930
02931	    PyObject* py_V281;
02932
02933	        PyArrayObject* V281;
02934
02935	            typedef npy_float64 dtype_V281;
02936
02937	    PyObject* py_V283;
02938
02939	        PyArrayObject* V283;
02940
02941	            typedef npy_float64 dtype_V283;
02942
02943	    PyObject* py_V285;
02944
02945	        PyArrayObject* V285;
02946
02947	            typedef npy_float64 dtype_V285;
02948
02949	    PyObject* py_V287;
02950
02951	        PyArrayObject* V287;
02952
02953	            typedef npy_int8 dtype_V287;
02954
02955	    PyObject* py_V289;
02956
02957	        PyArrayObject* V289;
02958
02959	            typedef npy_float64 dtype_V289;
02960
02961	    PyObject* py_V291;
02962
02963	        PyArrayObject* V291;
02964
02965	            typedef npy_float64 dtype_V291;
02966
02967	    PyObject* py_V293;
02968
02969	        PyArrayObject* V293;
02970
02971	            typedef npy_float64 dtype_V293;
02972
02973	    PyObject* py_V295;
02974
02975	        PyArrayObject* V295;
02976
02977	            typedef npy_float64 dtype_V295;
02978
02979	    PyObject* py_V297;
02980
02981	        PyArrayObject* V297;
02982
02983	            typedef npy_float64 dtype_V297;
02984
02985	    PyObject* py_V299;
02986
02987	        PyArrayObject* V299;
02988
02989	            typedef npy_float64 dtype_V299;
02990
02991	    PyObject* py_V301;
02992
02993	        PyArrayObject* V301;
02994
02995	            typedef npy_int8 dtype_V301;
02996
02997	    PyObject* py_V303;
02998
02999	        PyArrayObject* V303;
03000
03001	            typedef npy_float64 dtype_V303;
03002
03003	    PyObject* py_V305;
03004
03005	        PyArrayObject* V305;
03006
03007	            typedef npy_float64 dtype_V305;
03008
03009	    PyObject* py_V307;
03010
03011	        PyArrayObject* V307;
03012
03013	            typedef npy_float64 dtype_V307;
03014
03015	    PyObject* py_V309;
03016
03017	        PyArrayObject* V309;
03018
03019	            typedef npy_float64 dtype_V309;
03020
03021	    PyObject* py_V311;
03022
03023	        PyArrayObject* V311;
03024
03025	            typedef npy_float64 dtype_V311;
03026
03027	    PyObject* py_V313;
03028
03029	        PyArrayObject* V313;
03030
03031	            typedef npy_float64 dtype_V313;
03032
03033	    PyObject* py_V315;
03034
03035	        PyArrayObject* V315;
03036
03037	            typedef npy_float64 dtype_V315;
03038
03039	    PyObject* py_V317;
03040
03041	        PyArrayObject* V317;
03042
03043	            typedef npy_int8 dtype_V317;
03044
03045	    PyObject* py_V319;
03046
03047	        PyArrayObject* V319;
03048
03049	            typedef npy_float64 dtype_V319;
03050
03051	    PyObject* py_V321;
03052
03053	        PyArrayObject* V321;
03054
03055	            typedef npy_float64 dtype_V321;
03056
03057	    PyObject* py_V323;
03058
03059	        PyArrayObject* V323;
03060
03061	            typedef npy_float64 dtype_V323;
03062
03063	    PyObject* py_V325;
03064
03065	        PyArrayObject* V325;
03066
03067	            typedef npy_float64 dtype_V325;
03068
03069	    PyObject* py_V327;
03070
03071	        PyArrayObject* V327;
03072
03073	            typedef npy_float64 dtype_V327;
03074
03075	    PyObject* py_V329;
03076
03077	        PyArrayObject* V329;
03078
03079	            typedef npy_float64 dtype_V329;
03080
03081	    PyObject* py_V331;
03082
03083	        PyArrayObject* V331;
03084
03085	            typedef npy_float64 dtype_V331;
03086
03087	    PyObject* py_V333;
03088
03089	        PyArrayObject* V333;
03090
03091	            typedef npy_int8 dtype_V333;
03092
03093	    PyObject* py_V335;
03094
03095	        PyArrayObject* V335;
03096
03097	            typedef npy_float64 dtype_V335;
03098
03099	    PyObject* py_V337;
03100
03101	        PyArrayObject* V337;
03102
03103	            typedef npy_float64 dtype_V337;
03104
03105	    PyObject* py_V339;
03106
03107	        PyArrayObject* V339;
03108
03109	            typedef npy_float64 dtype_V339;
03110
03111	    PyObject* py_V341;
03112
03113	        PyArrayObject* V341;
03114
03115	            typedef npy_float64 dtype_V341;
03116
03117	    PyObject* py_V343;
03118
03119	        PyArrayObject* V343;
03120
03121	            typedef npy_float64 dtype_V343;
03122
03123	    PyObject* py_V345;
03124
03125	        PyArrayObject* V345;
03126
03127	            typedef npy_float64 dtype_V345;
03128
03129	    PyObject* py_V347;
03130
03131	        PyArrayObject* V347;
03132
03133	            typedef npy_float64 dtype_V347;
03134
03135	    PyObject* py_V349;
03136
03137	        PyArrayObject* V349;
03138
03139	            typedef npy_int8 dtype_V349;
03140
03141	    PyObject* py_V351;
03142
03143	        PyArrayObject* V351;
03144
03145	            typedef npy_float64 dtype_V351;
03146
03147	    PyObject* py_V353;
03148
03149	        PyArrayObject* V353;
03150
03151	            typedef npy_float64 dtype_V353;
03152
03153	    PyObject* py_V355;
03154
03155	        PyArrayObject* V355;
03156
03157	            typedef npy_float64 dtype_V355;
03158
03159	    PyObject* py_V357;
03160
03161	        PyArrayObject* V357;
03162
03163	            typedef npy_float64 dtype_V357;
03164
03165	    PyObject* py_V359;
03166
03167	        PyArrayObject* V359;
03168
03169	            typedef npy_float64 dtype_V359;
03170
03171	    PyObject* py_V361;
03172
03173	        PyArrayObject* V361;
03174
03175	            typedef npy_float64 dtype_V361;
03176
03177	    PyObject* py_V363;
03178
03179	        PyArrayObject* V363;
03180
03181	            typedef npy_float64 dtype_V363;
03182
03183	    PyObject* py_V365;
03184
03185	        PyArrayObject* V365;
03186
03187	            typedef npy_int8 dtype_V365;
03188
03189	    PyObject* py_V367;
03190
03191	        PyArrayObject* V367;
03192
03193	            typedef npy_float64 dtype_V367;
03194
03195	    PyObject* py_V369;
03196
03197	        PyArrayObject* V369;
03198
03199	            typedef npy_float64 dtype_V369;
03200
03201	    PyObject* py_V371;
03202
03203	        PyArrayObject* V371;
03204
03205	            typedef npy_float64 dtype_V371;
03206
03207	    PyObject* py_V373;
03208
03209	        PyArrayObject* V373;
03210
03211	            typedef npy_float64 dtype_V373;
03212
03213	    PyObject* py_V375;
03214
03215	        PyArrayObject* V375;
03216
03217	            typedef npy_float64 dtype_V375;
03218
03219	    PyObject* py_V377;
03220
03221	        PyArrayObject* V377;
03222
03223	            typedef npy_float64 dtype_V377;
03224
03225	    PyObject* py_V379;
03226
03227	        PyArrayObject* V379;
03228
03229	            typedef npy_int8 dtype_V379;
03230
03231	    PyObject* py_V381;
03232
03233	        PyArrayObject* V381;
03234
03235	            typedef npy_float64 dtype_V381;
03236
03237	    PyObject* py_V383;
03238
03239	        PyArrayObject* V383;
03240
03241	            typedef npy_float64 dtype_V383;
03242
03243	    PyObject* py_V385;
03244
03245	        PyArrayObject* V385;
03246
03247	            typedef npy_float64 dtype_V385;
03248
03249	    PyObject* py_V387;
03250
03251	        PyArrayObject* V387;
03252
03253	            typedef npy_float64 dtype_V387;
03254
03255	    PyObject* py_V389;
03256
03257	        PyArrayObject* V389;
03258
03259	            typedef npy_float64 dtype_V389;
03260
03261	    PyObject* py_V391;
03262
03263	        PyArrayObject* V391;
03264
03265	            typedef npy_float64 dtype_V391;
03266
03267	    PyObject* py_V393;
03268
03269	        PyArrayObject* V393;
03270
03271	            typedef npy_int8 dtype_V393;
03272
03273	    PyObject* py_V395;
03274
03275	        PyArrayObject* V395;
03276
03277	            typedef npy_float64 dtype_V395;
03278
03279	    PyObject* py_V397;
03280
03281	        PyArrayObject* V397;
03282
03283	            typedef npy_float64 dtype_V397;
03284
03285	    PyObject* py_V399;
03286
03287	        PyArrayObject* V399;
03288
03289	            typedef npy_float64 dtype_V399;
03290
03291	    PyObject* py_V401;
03292
03293	        PyArrayObject* V401;
03294
03295	            typedef npy_float64 dtype_V401;
03296
03297	    PyObject* py_V403;
03298
03299	        PyArrayObject* V403;
03300
03301	            typedef npy_float64 dtype_V403;
03302
03303	    PyObject* py_V405;
03304
03305	        PyArrayObject* V405;
03306
03307	            typedef npy_float64 dtype_V405;
03308
03309	    PyObject* py_V407;
03310
03311	        PyArrayObject* V407;
03312
03313	            typedef npy_int8 dtype_V407;
03314
03315	    PyObject* py_V409;
03316
03317	        PyArrayObject* V409;
03318
03319	            typedef npy_float64 dtype_V409;
03320
03321	    PyObject* py_V411;
03322
03323	        PyArrayObject* V411;
03324
03325	            typedef npy_float64 dtype_V411;
03326
03327	    PyObject* py_V413;
03328
03329	        PyArrayObject* V413;
03330
03331	            typedef npy_float64 dtype_V413;
03332
03333	    PyObject* py_V415;
03334
03335	        PyArrayObject* V415;
03336
03337	            typedef npy_float64 dtype_V415;
03338
03339	    PyObject* py_V417;
03340
03341	        PyArrayObject* V417;
03342
03343	            typedef npy_float64 dtype_V417;
03344
03345	    PyObject* py_V419;
03346
03347	        PyArrayObject* V419;
03348
03349	            typedef npy_float64 dtype_V419;
03350
03351	    PyObject* py_V421;
03352
03353	        PyArrayObject* V421;
03354
03355	            typedef npy_int8 dtype_V421;
03356
03357	    PyObject* py_V423;
03358
03359	        PyArrayObject* V423;
03360
03361	            typedef npy_float64 dtype_V423;
03362
03363	    PyObject* py_V425;
03364
03365	        PyArrayObject* V425;
03366
03367	            typedef npy_float64 dtype_V425;
03368
03369	    PyObject* py_V427;
03370
03371	        PyArrayObject* V427;
03372
03373	            typedef npy_float64 dtype_V427;
03374
03375	    PyObject* py_V429;
03376
03377	        PyArrayObject* V429;
03378
03379	            typedef npy_float64 dtype_V429;
03380
03381	    PyObject* py_V431;
03382
03383	        PyArrayObject* V431;
03384
03385	            typedef npy_float64 dtype_V431;
03386
03387	    PyObject* py_V433;
03388
03389	        PyArrayObject* V433;
03390
03391	            typedef npy_float64 dtype_V433;
03392
03393	    PyObject* py_V435;
03394
03395	        PyArrayObject* V435;
03396
03397	            typedef npy_float64 dtype_V435;
03398
03399	    PyObject* py_V437;
03400
03401	        PyArrayObject* V437;
03402
03403	            typedef npy_int8 dtype_V437;
03404
03405	    PyObject* py_V439;
03406
03407	        PyArrayObject* V439;
03408
03409	            typedef npy_float64 dtype_V439;
03410
03411	    PyObject* py_V441;
03412
03413	        PyArrayObject* V441;
03414
03415	            typedef npy_float64 dtype_V441;
03416
03417	    PyObject* py_V443;
03418
03419	        PyArrayObject* V443;
03420
03421	            typedef npy_float64 dtype_V443;
03422
03423	    PyObject* py_V445;
03424
03425	        PyArrayObject* V445;
03426
03427	            typedef npy_float64 dtype_V445;
03428
03429	    PyObject* py_V447;
03430
03431	        PyArrayObject* V447;
03432
03433	            typedef npy_float64 dtype_V447;
03434
03435	    PyObject* py_V449;
03436
03437	        PyArrayObject* V449;
03438
03439	            typedef npy_float64 dtype_V449;
03440
03441	    PyObject* py_V451;
03442
03443	        PyArrayObject* V451;
03444
03445	            typedef npy_float64 dtype_V451;
03446
03447	    PyObject* py_V453;
03448
03449	        PyArrayObject* V453;
03450
03451	            typedef npy_int8 dtype_V453;
03452
03453	    PyObject* py_V455;
03454
03455	        PyArrayObject* V455;
03456
03457	            typedef npy_float64 dtype_V455;
03458
03459	    PyObject* py_V457;
03460
03461	        PyArrayObject* V457;
03462
03463	            typedef npy_float64 dtype_V457;
03464
03465	    PyObject* py_V459;
03466
03467	        PyArrayObject* V459;
03468
03469	            typedef npy_float64 dtype_V459;
03470
03471	    PyObject* py_V461;
03472
03473	        PyArrayObject* V461;
03474
03475	            typedef npy_float64 dtype_V461;
03476
03477	    PyObject* py_V463;
03478
03479	        PyArrayObject* V463;
03480
03481	            typedef npy_float64 dtype_V463;
03482
03483	    PyObject* py_V465;
03484
03485	        PyArrayObject* V465;
03486
03487	            typedef npy_float64 dtype_V465;
03488
03489	    PyObject* py_V467;
03490
03491	        PyArrayObject* V467;
03492
03493	            typedef npy_int8 dtype_V467;
03494
03495	    PyObject* py_V469;
03496
03497	        PyArrayObject* V469;
03498
03499	            typedef npy_float64 dtype_V469;
03500
03501	    PyObject* py_V471;
03502
03503	        PyArrayObject* V471;
03504
03505	            typedef npy_float64 dtype_V471;
03506
03507	    PyObject* py_V473;
03508
03509	        PyArrayObject* V473;
03510
03511	            typedef npy_float64 dtype_V473;
03512
03513	    PyObject* py_V475;
03514
03515	        PyArrayObject* V475;
03516
03517	            typedef npy_float64 dtype_V475;
03518
03519	    PyObject* py_V477;
03520
03521	        PyArrayObject* V477;
03522
03523	            typedef npy_float64 dtype_V477;
03524
03525	    PyObject* py_V479;
03526
03527	        PyArrayObject* V479;
03528
03529	            typedef npy_float64 dtype_V479;
03530
03531	    PyObject* py_V481;
03532
03533	        PyArrayObject* V481;
03534
03535	            typedef npy_float64 dtype_V481;
03536
03537	    PyObject* py_V483;
03538
03539	        PyArrayObject* V483;
03540
03541	            typedef npy_float64 dtype_V483;
03542
03543	    PyObject* py_V485;
03544
03545	        PyArrayObject* V485;
03546
03547	            typedef npy_int8 dtype_V485;
03548
03549	    PyObject* py_V487;
03550
03551	        PyArrayObject* V487;
03552
03553	            typedef npy_float64 dtype_V487;
03554
03555	    PyObject* py_V489;
03556
03557	        PyArrayObject* V489;
03558
03559	            typedef npy_float64 dtype_V489;
03560
03561	    PyObject* py_V491;
03562
03563	        PyArrayObject* V491;
03564
03565	            typedef npy_float64 dtype_V491;
03566
03567	    PyObject* py_V493;
03568
03569	        PyArrayObject* V493;
03570
03571	            typedef npy_float64 dtype_V493;
03572
03573	    PyObject* py_V495;
03574
03575	        PyArrayObject* V495;
03576
03577	            typedef npy_float64 dtype_V495;
03578
03579	    PyObject* py_V497;
03580
03581	        PyArrayObject* V497;
03582
03583	            typedef npy_float64 dtype_V497;
03584
03585	    PyObject* py_V499;
03586
03587	        PyArrayObject* V499;
03588
03589	            typedef npy_int8 dtype_V499;
03590
03591	    PyObject* py_V501;
03592
03593	        PyArrayObject* V501;
03594
03595	            typedef npy_float64 dtype_V501;
03596
03597	    PyObject* py_V503;
03598
03599	        PyArrayObject* V503;
03600
03601	            typedef npy_float64 dtype_V503;
03602
03603	    PyObject* py_V505;
03604
03605	        PyArrayObject* V505;
03606
03607	            typedef npy_float64 dtype_V505;
03608
03609	    PyObject* py_V507;
03610
03611	        PyArrayObject* V507;
03612
03613	            typedef npy_float64 dtype_V507;
03614
03615	    PyObject* py_V509;
03616
03617	        PyArrayObject* V509;
03618
03619	            typedef npy_float64 dtype_V509;
03620
03621	{
03622
03623	    py_V1 = PyList_GET_ITEM(storage_V1, 0);
03624	    {Py_XINCREF(py_V1);}
03625
03626	        if (py_V1 == Py_None)
03627	        {
03628
03629	        V1 = NULL;
03630
03631	        }
03632	        else
03633	        {
03634
03635	            V1 = NULL;
03636	            if (py_V1 == Py_None) {
03637	                // We can either fail here or set V1 to NULL and rely on Ops
03638	                // using tensors to handle the NULL case, but if they fail to do so
03639	                // they'll end up with nasty segfaults, so this is public service.
03640	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
03641	                {
03642	        __failure = 2;
03643	        if (!PyErr_Occurred()) {
03644	            PyErr_SetString(PyExc_RuntimeError,
03645	                "Unexpected error in an Op's C code. "
03646	                "No Python exception was set.");
03647	            }
03648	        goto __label_2;}
03649	            }
03650	            if (!PyArray_Check(py_V1)) {
03651	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
03652	                {
03653	        __failure = 2;
03654	        if (!PyErr_Occurred()) {
03655	            PyErr_SetString(PyExc_RuntimeError,
03656	                "Unexpected error in an Op's C code. "
03657	                "No Python exception was set.");
03658	            }
03659	        goto __label_2;}
03660	            }
03661	            // We expect NPY_FLOAT64
03662	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V1)) {
03663	                PyArrayObject * tmp = (PyArrayObject*) py_V1;
03664	                PyErr_Format(PyExc_NotImplementedError,
03665	                             "expected an aligned array of type %ld "
03666	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
03667	                             " with %ld dimensions, with 3 last dims "
03668	                             "%ld, %ld, %ld"
03669	                             " and 3 last strides %ld %ld, %ld.",
03670	                             (long int) NPY_FLOAT64,
03671	                             (long int) PyArray_TYPE((PyArrayObject*) py_V1),
03672	                             (long int) PyArray_NDIM(tmp),
03673	                             (long int) PyArray_NDIM(tmp) >= 3 ?
03674	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
03675	                             (long int) PyArray_NDIM(tmp) >= 2 ?
03676	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
03677	                             (long int) PyArray_NDIM(tmp) >= 1 ?
03678	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
03679	                             (long int) PyArray_NDIM(tmp) >= 3 ?
03680	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
03681	                             (long int) PyArray_NDIM(tmp) >= 2 ?
03682	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
03683	                             (long int) PyArray_NDIM(tmp) >= 1 ?
03684	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
03685	            );
03686	                {
03687	        __failure = 2;
03688	        if (!PyErr_Occurred()) {
03689	            PyErr_SetString(PyExc_RuntimeError,
03690	                "Unexpected error in an Op's C code. "
03691	                "No Python exception was set.");
03692	            }
03693	        goto __label_2;}
03694	            }
03695	            // This is a TypeError to be consistent with DEBUG_MODE
03696	            // Note: DEBUG_MODE also tells the name of the container
03697	            if (PyArray_TYPE((PyArrayObject*) py_V1) != NPY_FLOAT64) {
03698	                PyErr_Format(PyExc_TypeError,
03699	                             "expected type_num %d (NPY_FLOAT64) got %d",
03700	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V1));
03701	                {
03702	        __failure = 2;
03703	        if (!PyErr_Occurred()) {
03704	            PyErr_SetString(PyExc_RuntimeError,
03705	                "Unexpected error in an Op's C code. "
03706	                "No Python exception was set.");
03707	            }
03708	        goto __label_2;}
03709	            }
03710
03711	        V1 = (PyArrayObject*)(py_V1);
03712	        Py_XINCREF(V1);
03713
03714	        }
03715
03716	{
03717
03718	    py_V3 = PyList_GET_ITEM(storage_V3, 0);
03719	    {Py_XINCREF(py_V3);}
03720
03721	            V3 = NULL;
03722	            if (py_V3 == Py_None) {
03723	                // We can either fail here or set V3 to NULL and rely on Ops
03724	                // using tensors to handle the NULL case, but if they fail to do so
03725	                // they'll end up with nasty segfaults, so this is public service.
03726	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
03727	                {
03728	        __failure = 4;
03729	        if (!PyErr_Occurred()) {
03730	            PyErr_SetString(PyExc_RuntimeError,
03731	                "Unexpected error in an Op's C code. "
03732	                "No Python exception was set.");
03733	            }
03734	        goto __label_4;}
03735	            }
03736	            if (!PyArray_Check(py_V3)) {
03737	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
03738	                {
03739	        __failure = 4;
03740	        if (!PyErr_Occurred()) {
03741	            PyErr_SetString(PyExc_RuntimeError,
03742	                "Unexpected error in an Op's C code. "
03743	                "No Python exception was set.");
03744	            }
03745	        goto __label_4;}
03746	            }
03747	            // We expect NPY_FLOAT64
03748	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V3)) {
03749	                PyArrayObject * tmp = (PyArrayObject*) py_V3;
03750	                PyErr_Format(PyExc_NotImplementedError,
03751	                             "expected an aligned array of type %ld "
03752	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
03753	                             " with %ld dimensions, with 3 last dims "
03754	                             "%ld, %ld, %ld"
03755	                             " and 3 last strides %ld %ld, %ld.",
03756	                             (long int) NPY_FLOAT64,
03757	                             (long int) PyArray_TYPE((PyArrayObject*) py_V3),
03758	                             (long int) PyArray_NDIM(tmp),
03759	                             (long int) PyArray_NDIM(tmp) >= 3 ?
03760	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
03761	                             (long int) PyArray_NDIM(tmp) >= 2 ?
03762	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
03763	                             (long int) PyArray_NDIM(tmp) >= 1 ?
03764	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
03765	                             (long int) PyArray_NDIM(tmp) >= 3 ?
03766	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
03767	                             (long int) PyArray_NDIM(tmp) >= 2 ?
03768	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
03769	                             (long int) PyArray_NDIM(tmp) >= 1 ?
03770	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
03771	            );
03772	                {
03773	        __failure = 4;
03774	        if (!PyErr_Occurred()) {
03775	            PyErr_SetString(PyExc_RuntimeError,
03776	                "Unexpected error in an Op's C code. "
03777	                "No Python exception was set.");
03778	            }
03779	        goto __label_4;}
03780	            }
03781	            // This is a TypeError to be consistent with DEBUG_MODE
03782	            // Note: DEBUG_MODE also tells the name of the container
03783	            if (PyArray_TYPE((PyArrayObject*) py_V3) != NPY_FLOAT64) {
03784	                PyErr_Format(PyExc_TypeError,
03785	                             "expected type_num %d (NPY_FLOAT64) got %d",
03786	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V3));
03787	                {
03788	        __failure = 4;
03789	        if (!PyErr_Occurred()) {
03790	            PyErr_SetString(PyExc_RuntimeError,
03791	                "Unexpected error in an Op's C code. "
03792	                "No Python exception was set.");
03793	            }
03794	        goto __label_4;}
03795	            }
03796
03797	        V3 = (PyArrayObject*)(py_V3);
03798	        Py_XINCREF(V3);
03799
03800	{
03801
03802	    py_V5 = PyList_GET_ITEM(storage_V5, 0);
03803	    {Py_XINCREF(py_V5);}
03804
03805	            V5 = NULL;
03806	            if (py_V5 == Py_None) {
03807	                // We can either fail here or set V5 to NULL and rely on Ops
03808	                // using tensors to handle the NULL case, but if they fail to do so
03809	                // they'll end up with nasty segfaults, so this is public service.
03810	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
03811	                {
03812	        __failure = 6;
03813	        if (!PyErr_Occurred()) {
03814	            PyErr_SetString(PyExc_RuntimeError,
03815	                "Unexpected error in an Op's C code. "
03816	                "No Python exception was set.");
03817	            }
03818	        goto __label_6;}
03819	            }
03820	            if (!PyArray_Check(py_V5)) {
03821	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
03822	                {
03823	        __failure = 6;
03824	        if (!PyErr_Occurred()) {
03825	            PyErr_SetString(PyExc_RuntimeError,
03826	                "Unexpected error in an Op's C code. "
03827	                "No Python exception was set.");
03828	            }
03829	        goto __label_6;}
03830	            }
03831	            // We expect NPY_INT8
03832	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V5)) {
03833	                PyArrayObject * tmp = (PyArrayObject*) py_V5;
03834	                PyErr_Format(PyExc_NotImplementedError,
03835	                             "expected an aligned array of type %ld "
03836	                             "(NPY_INT8), got non-aligned array of type %ld"
03837	                             " with %ld dimensions, with 3 last dims "
03838	                             "%ld, %ld, %ld"
03839	                             " and 3 last strides %ld %ld, %ld.",
03840	                             (long int) NPY_INT8,
03841	                             (long int) PyArray_TYPE((PyArrayObject*) py_V5),
03842	                             (long int) PyArray_NDIM(tmp),
03843	                             (long int) PyArray_NDIM(tmp) >= 3 ?
03844	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
03845	                             (long int) PyArray_NDIM(tmp) >= 2 ?
03846	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
03847	                             (long int) PyArray_NDIM(tmp) >= 1 ?
03848	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
03849	                             (long int) PyArray_NDIM(tmp) >= 3 ?
03850	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
03851	                             (long int) PyArray_NDIM(tmp) >= 2 ?
03852	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
03853	                             (long int) PyArray_NDIM(tmp) >= 1 ?
03854	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
03855	            );
03856	                {
03857	        __failure = 6;
03858	        if (!PyErr_Occurred()) {
03859	            PyErr_SetString(PyExc_RuntimeError,
03860	                "Unexpected error in an Op's C code. "
03861	                "No Python exception was set.");
03862	            }
03863	        goto __label_6;}
03864	            }
03865	            // This is a TypeError to be consistent with DEBUG_MODE
03866	            // Note: DEBUG_MODE also tells the name of the container
03867	            if (PyArray_TYPE((PyArrayObject*) py_V5) != NPY_INT8) {
03868	                PyErr_Format(PyExc_TypeError,
03869	                             "expected type_num %d (NPY_INT8) got %d",
03870	                             NPY_INT8, PyArray_TYPE((PyArrayObject*) py_V5));
03871	                {
03872	        __failure = 6;
03873	        if (!PyErr_Occurred()) {
03874	            PyErr_SetString(PyExc_RuntimeError,
03875	                "Unexpected error in an Op's C code. "
03876	                "No Python exception was set.");
03877	            }
03878	        goto __label_6;}
03879	            }
03880
03881	        V5 = (PyArrayObject*)(py_V5);
03882	        Py_XINCREF(V5);
03883
03884	{
03885
03886	    py_V7 = PyList_GET_ITEM(storage_V7, 0);
03887	    {Py_XINCREF(py_V7);}
03888
03889	            V7 = NULL;
03890	            if (py_V7 == Py_None) {
03891	                // We can either fail here or set V7 to NULL and rely on Ops
03892	                // using tensors to handle the NULL case, but if they fail to do so
03893	                // they'll end up with nasty segfaults, so this is public service.
03894	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
03895	                {
03896	        __failure = 8;
03897	        if (!PyErr_Occurred()) {
03898	            PyErr_SetString(PyExc_RuntimeError,
03899	                "Unexpected error in an Op's C code. "
03900	                "No Python exception was set.");
03901	            }
03902	        goto __label_8;}
03903	            }
03904	            if (!PyArray_Check(py_V7)) {
03905	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
03906	                {
03907	        __failure = 8;
03908	        if (!PyErr_Occurred()) {
03909	            PyErr_SetString(PyExc_RuntimeError,
03910	                "Unexpected error in an Op's C code. "
03911	                "No Python exception was set.");
03912	            }
03913	        goto __label_8;}
03914	            }
03915	            // We expect NPY_FLOAT64
03916	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V7)) {
03917	                PyArrayObject * tmp = (PyArrayObject*) py_V7;
03918	                PyErr_Format(PyExc_NotImplementedError,
03919	                             "expected an aligned array of type %ld "
03920	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
03921	                             " with %ld dimensions, with 3 last dims "
03922	                             "%ld, %ld, %ld"
03923	                             " and 3 last strides %ld %ld, %ld.",
03924	                             (long int) NPY_FLOAT64,
03925	                             (long int) PyArray_TYPE((PyArrayObject*) py_V7),
03926	                             (long int) PyArray_NDIM(tmp),
03927	                             (long int) PyArray_NDIM(tmp) >= 3 ?
03928	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
03929	                             (long int) PyArray_NDIM(tmp) >= 2 ?
03930	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
03931	                             (long int) PyArray_NDIM(tmp) >= 1 ?
03932	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
03933	                             (long int) PyArray_NDIM(tmp) >= 3 ?
03934	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
03935	                             (long int) PyArray_NDIM(tmp) >= 2 ?
03936	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
03937	                             (long int) PyArray_NDIM(tmp) >= 1 ?
03938	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
03939	            );
03940	                {
03941	        __failure = 8;
03942	        if (!PyErr_Occurred()) {
03943	            PyErr_SetString(PyExc_RuntimeError,
03944	                "Unexpected error in an Op's C code. "
03945	                "No Python exception was set.");
03946	            }
03947	        goto __label_8;}
03948	            }
03949	            // This is a TypeError to be consistent with DEBUG_MODE
03950	            // Note: DEBUG_MODE also tells the name of the container
03951	            if (PyArray_TYPE((PyArrayObject*) py_V7) != NPY_FLOAT64) {
03952	                PyErr_Format(PyExc_TypeError,
03953	                             "expected type_num %d (NPY_FLOAT64) got %d",
03954	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V7));
03955	                {
03956	        __failure = 8;
03957	        if (!PyErr_Occurred()) {
03958	            PyErr_SetString(PyExc_RuntimeError,
03959	                "Unexpected error in an Op's C code. "
03960	                "No Python exception was set.");
03961	            }
03962	        goto __label_8;}
03963	            }
03964
03965	        V7 = (PyArrayObject*)(py_V7);
03966	        Py_XINCREF(V7);
03967
03968	{
03969
03970	    py_V9 = PyList_GET_ITEM(storage_V9, 0);
03971	    {Py_XINCREF(py_V9);}
03972
03973	            V9 = NULL;
03974	            if (py_V9 == Py_None) {
03975	                // We can either fail here or set V9 to NULL and rely on Ops
03976	                // using tensors to handle the NULL case, but if they fail to do so
03977	                // they'll end up with nasty segfaults, so this is public service.
03978	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
03979	                {
03980	        __failure = 10;
03981	        if (!PyErr_Occurred()) {
03982	            PyErr_SetString(PyExc_RuntimeError,
03983	                "Unexpected error in an Op's C code. "
03984	                "No Python exception was set.");
03985	            }
03986	        goto __label_10;}
03987	            }
03988	            if (!PyArray_Check(py_V9)) {
03989	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
03990	                {
03991	        __failure = 10;
03992	        if (!PyErr_Occurred()) {
03993	            PyErr_SetString(PyExc_RuntimeError,
03994	                "Unexpected error in an Op's C code. "
03995	                "No Python exception was set.");
03996	            }
03997	        goto __label_10;}
03998	            }
03999	            // We expect NPY_FLOAT64
04000	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V9)) {
04001	                PyArrayObject * tmp = (PyArrayObject*) py_V9;
04002	                PyErr_Format(PyExc_NotImplementedError,
04003	                             "expected an aligned array of type %ld "
04004	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
04005	                             " with %ld dimensions, with 3 last dims "
04006	                             "%ld, %ld, %ld"
04007	                             " and 3 last strides %ld %ld, %ld.",
04008	                             (long int) NPY_FLOAT64,
04009	                             (long int) PyArray_TYPE((PyArrayObject*) py_V9),
04010	                             (long int) PyArray_NDIM(tmp),
04011	                             (long int) PyArray_NDIM(tmp) >= 3 ?
04012	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
04013	                             (long int) PyArray_NDIM(tmp) >= 2 ?
04014	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
04015	                             (long int) PyArray_NDIM(tmp) >= 1 ?
04016	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
04017	                             (long int) PyArray_NDIM(tmp) >= 3 ?
04018	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
04019	                             (long int) PyArray_NDIM(tmp) >= 2 ?
04020	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
04021	                             (long int) PyArray_NDIM(tmp) >= 1 ?
04022	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
04023	            );
04024	                {
04025	        __failure = 10;
04026	        if (!PyErr_Occurred()) {
04027	            PyErr_SetString(PyExc_RuntimeError,
04028	                "Unexpected error in an Op's C code. "
04029	                "No Python exception was set.");
04030	            }
04031	        goto __label_10;}
04032	            }
04033	            // This is a TypeError to be consistent with DEBUG_MODE
04034	            // Note: DEBUG_MODE also tells the name of the container
04035	            if (PyArray_TYPE((PyArrayObject*) py_V9) != NPY_FLOAT64) {
04036	                PyErr_Format(PyExc_TypeError,
04037	                             "expected type_num %d (NPY_FLOAT64) got %d",
04038	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V9));
04039	                {
04040	        __failure = 10;
04041	        if (!PyErr_Occurred()) {
04042	            PyErr_SetString(PyExc_RuntimeError,
04043	                "Unexpected error in an Op's C code. "
04044	                "No Python exception was set.");
04045	            }
04046	        goto __label_10;}
04047	            }
04048
04049	        V9 = (PyArrayObject*)(py_V9);
04050	        Py_XINCREF(V9);
04051
04052	{
04053
04054	    py_V11 = PyList_GET_ITEM(storage_V11, 0);
04055	    {Py_XINCREF(py_V11);}
04056
04057	            V11 = NULL;
04058	            if (py_V11 == Py_None) {
04059	                // We can either fail here or set V11 to NULL and rely on Ops
04060	                // using tensors to handle the NULL case, but if they fail to do so
04061	                // they'll end up with nasty segfaults, so this is public service.
04062	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
04063	                {
04064	        __failure = 12;
04065	        if (!PyErr_Occurred()) {
04066	            PyErr_SetString(PyExc_RuntimeError,
04067	                "Unexpected error in an Op's C code. "
04068	                "No Python exception was set.");
04069	            }
04070	        goto __label_12;}
04071	            }
04072	            if (!PyArray_Check(py_V11)) {
04073	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
04074	                {
04075	        __failure = 12;
04076	        if (!PyErr_Occurred()) {
04077	            PyErr_SetString(PyExc_RuntimeError,
04078	                "Unexpected error in an Op's C code. "
04079	                "No Python exception was set.");
04080	            }
04081	        goto __label_12;}
04082	            }
04083	            // We expect NPY_FLOAT64
04084	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V11)) {
04085	                PyArrayObject * tmp = (PyArrayObject*) py_V11;
04086	                PyErr_Format(PyExc_NotImplementedError,
04087	                             "expected an aligned array of type %ld "
04088	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
04089	                             " with %ld dimensions, with 3 last dims "
04090	                             "%ld, %ld, %ld"
04091	                             " and 3 last strides %ld %ld, %ld.",
04092	                             (long int) NPY_FLOAT64,
04093	                             (long int) PyArray_TYPE((PyArrayObject*) py_V11),
04094	                             (long int) PyArray_NDIM(tmp),
04095	                             (long int) PyArray_NDIM(tmp) >= 3 ?
04096	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
04097	                             (long int) PyArray_NDIM(tmp) >= 2 ?
04098	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
04099	                             (long int) PyArray_NDIM(tmp) >= 1 ?
04100	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
04101	                             (long int) PyArray_NDIM(tmp) >= 3 ?
04102	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
04103	                             (long int) PyArray_NDIM(tmp) >= 2 ?
04104	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
04105	                             (long int) PyArray_NDIM(tmp) >= 1 ?
04106	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
04107	            );
04108	                {
04109	        __failure = 12;
04110	        if (!PyErr_Occurred()) {
04111	            PyErr_SetString(PyExc_RuntimeError,
04112	                "Unexpected error in an Op's C code. "
04113	                "No Python exception was set.");
04114	            }
04115	        goto __label_12;}
04116	            }
04117	            // This is a TypeError to be consistent with DEBUG_MODE
04118	            // Note: DEBUG_MODE also tells the name of the container
04119	            if (PyArray_TYPE((PyArrayObject*) py_V11) != NPY_FLOAT64) {
04120	                PyErr_Format(PyExc_TypeError,
04121	                             "expected type_num %d (NPY_FLOAT64) got %d",
04122	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V11));
04123	                {
04124	        __failure = 12;
04125	        if (!PyErr_Occurred()) {
04126	            PyErr_SetString(PyExc_RuntimeError,
04127	                "Unexpected error in an Op's C code. "
04128	                "No Python exception was set.");
04129	            }
04130	        goto __label_12;}
04131	            }
04132
04133	        V11 = (PyArrayObject*)(py_V11);
04134	        Py_XINCREF(V11);
04135
04136	{
04137
04138	    py_V13 = PyList_GET_ITEM(storage_V13, 0);
04139	    {Py_XINCREF(py_V13);}
04140
04141	            V13 = NULL;
04142	            if (py_V13 == Py_None) {
04143	                // We can either fail here or set V13 to NULL and rely on Ops
04144	                // using tensors to handle the NULL case, but if they fail to do so
04145	                // they'll end up with nasty segfaults, so this is public service.
04146	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
04147	                {
04148	        __failure = 14;
04149	        if (!PyErr_Occurred()) {
04150	            PyErr_SetString(PyExc_RuntimeError,
04151	                "Unexpected error in an Op's C code. "
04152	                "No Python exception was set.");
04153	            }
04154	        goto __label_14;}
04155	            }
04156	            if (!PyArray_Check(py_V13)) {
04157	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
04158	                {
04159	        __failure = 14;
04160	        if (!PyErr_Occurred()) {
04161	            PyErr_SetString(PyExc_RuntimeError,
04162	                "Unexpected error in an Op's C code. "
04163	                "No Python exception was set.");
04164	            }
04165	        goto __label_14;}
04166	            }
04167	            // We expect NPY_FLOAT64
04168	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V13)) {
04169	                PyArrayObject * tmp = (PyArrayObject*) py_V13;
04170	                PyErr_Format(PyExc_NotImplementedError,
04171	                             "expected an aligned array of type %ld "
04172	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
04173	                             " with %ld dimensions, with 3 last dims "
04174	                             "%ld, %ld, %ld"
04175	                             " and 3 last strides %ld %ld, %ld.",
04176	                             (long int) NPY_FLOAT64,
04177	                             (long int) PyArray_TYPE((PyArrayObject*) py_V13),
04178	                             (long int) PyArray_NDIM(tmp),
04179	                             (long int) PyArray_NDIM(tmp) >= 3 ?
04180	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
04181	                             (long int) PyArray_NDIM(tmp) >= 2 ?
04182	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
04183	                             (long int) PyArray_NDIM(tmp) >= 1 ?
04184	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
04185	                             (long int) PyArray_NDIM(tmp) >= 3 ?
04186	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
04187	                             (long int) PyArray_NDIM(tmp) >= 2 ?
04188	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
04189	                             (long int) PyArray_NDIM(tmp) >= 1 ?
04190	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
04191	            );
04192	                {
04193	        __failure = 14;
04194	        if (!PyErr_Occurred()) {
04195	            PyErr_SetString(PyExc_RuntimeError,
04196	                "Unexpected error in an Op's C code. "
04197	                "No Python exception was set.");
04198	            }
04199	        goto __label_14;}
04200	            }
04201	            // This is a TypeError to be consistent with DEBUG_MODE
04202	            // Note: DEBUG_MODE also tells the name of the container
04203	            if (PyArray_TYPE((PyArrayObject*) py_V13) != NPY_FLOAT64) {
04204	                PyErr_Format(PyExc_TypeError,
04205	                             "expected type_num %d (NPY_FLOAT64) got %d",
04206	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V13));
04207	                {
04208	        __failure = 14;
04209	        if (!PyErr_Occurred()) {
04210	            PyErr_SetString(PyExc_RuntimeError,
04211	                "Unexpected error in an Op's C code. "
04212	                "No Python exception was set.");
04213	            }
04214	        goto __label_14;}
04215	            }
04216
04217	        V13 = (PyArrayObject*)(py_V13);
04218	        Py_XINCREF(V13);
04219
04220	{
04221
04222	    py_V15 = PyList_GET_ITEM(storage_V15, 0);
04223	    {Py_XINCREF(py_V15);}
04224
04225	            V15 = NULL;
04226	            if (py_V15 == Py_None) {
04227	                // We can either fail here or set V15 to NULL and rely on Ops
04228	                // using tensors to handle the NULL case, but if they fail to do so
04229	                // they'll end up with nasty segfaults, so this is public service.
04230	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
04231	                {
04232	        __failure = 16;
04233	        if (!PyErr_Occurred()) {
04234	            PyErr_SetString(PyExc_RuntimeError,
04235	                "Unexpected error in an Op's C code. "
04236	                "No Python exception was set.");
04237	            }
04238	        goto __label_16;}
04239	            }
04240	            if (!PyArray_Check(py_V15)) {
04241	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
04242	                {
04243	        __failure = 16;
04244	        if (!PyErr_Occurred()) {
04245	            PyErr_SetString(PyExc_RuntimeError,
04246	                "Unexpected error in an Op's C code. "
04247	                "No Python exception was set.");
04248	            }
04249	        goto __label_16;}
04250	            }
04251	            // We expect NPY_INT8
04252	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V15)) {
04253	                PyArrayObject * tmp = (PyArrayObject*) py_V15;
04254	                PyErr_Format(PyExc_NotImplementedError,
04255	                             "expected an aligned array of type %ld "
04256	                             "(NPY_INT8), got non-aligned array of type %ld"
04257	                             " with %ld dimensions, with 3 last dims "
04258	                             "%ld, %ld, %ld"
04259	                             " and 3 last strides %ld %ld, %ld.",
04260	                             (long int) NPY_INT8,
04261	                             (long int) PyArray_TYPE((PyArrayObject*) py_V15),
04262	                             (long int) PyArray_NDIM(tmp),
04263	                             (long int) PyArray_NDIM(tmp) >= 3 ?
04264	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
04265	                             (long int) PyArray_NDIM(tmp) >= 2 ?
04266	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
04267	                             (long int) PyArray_NDIM(tmp) >= 1 ?
04268	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
04269	                             (long int) PyArray_NDIM(tmp) >= 3 ?
04270	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
04271	                             (long int) PyArray_NDIM(tmp) >= 2 ?
04272	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
04273	                             (long int) PyArray_NDIM(tmp) >= 1 ?
04274	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
04275	            );
04276	                {
04277	        __failure = 16;
04278	        if (!PyErr_Occurred()) {
04279	            PyErr_SetString(PyExc_RuntimeError,
04280	                "Unexpected error in an Op's C code. "
04281	                "No Python exception was set.");
04282	            }
04283	        goto __label_16;}
04284	            }
04285	            // This is a TypeError to be consistent with DEBUG_MODE
04286	            // Note: DEBUG_MODE also tells the name of the container
04287	            if (PyArray_TYPE((PyArrayObject*) py_V15) != NPY_INT8) {
04288	                PyErr_Format(PyExc_TypeError,
04289	                             "expected type_num %d (NPY_INT8) got %d",
04290	                             NPY_INT8, PyArray_TYPE((PyArrayObject*) py_V15));
04291	                {
04292	        __failure = 16;
04293	        if (!PyErr_Occurred()) {
04294	            PyErr_SetString(PyExc_RuntimeError,
04295	                "Unexpected error in an Op's C code. "
04296	                "No Python exception was set.");
04297	            }
04298	        goto __label_16;}
04299	            }
04300
04301	        V15 = (PyArrayObject*)(py_V15);
04302	        Py_XINCREF(V15);
04303
04304	{
04305
04306	    py_V17 = PyList_GET_ITEM(storage_V17, 0);
04307	    {Py_XINCREF(py_V17);}
04308
04309	            V17 = NULL;
04310	            if (py_V17 == Py_None) {
04311	                // We can either fail here or set V17 to NULL and rely on Ops
04312	                // using tensors to handle the NULL case, but if they fail to do so
04313	                // they'll end up with nasty segfaults, so this is public service.
04314	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
04315	                {
04316	        __failure = 18;
04317	        if (!PyErr_Occurred()) {
04318	            PyErr_SetString(PyExc_RuntimeError,
04319	                "Unexpected error in an Op's C code. "
04320	                "No Python exception was set.");
04321	            }
04322	        goto __label_18;}
04323	            }
04324	            if (!PyArray_Check(py_V17)) {
04325	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
04326	                {
04327	        __failure = 18;
04328	        if (!PyErr_Occurred()) {
04329	            PyErr_SetString(PyExc_RuntimeError,
04330	                "Unexpected error in an Op's C code. "
04331	                "No Python exception was set.");
04332	            }
04333	        goto __label_18;}
04334	            }
04335	            // We expect NPY_FLOAT64
04336	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V17)) {
04337	                PyArrayObject * tmp = (PyArrayObject*) py_V17;
04338	                PyErr_Format(PyExc_NotImplementedError,
04339	                             "expected an aligned array of type %ld "
04340	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
04341	                             " with %ld dimensions, with 3 last dims "
04342	                             "%ld, %ld, %ld"
04343	                             " and 3 last strides %ld %ld, %ld.",
04344	                             (long int) NPY_FLOAT64,
04345	                             (long int) PyArray_TYPE((PyArrayObject*) py_V17),
04346	                             (long int) PyArray_NDIM(tmp),
04347	                             (long int) PyArray_NDIM(tmp) >= 3 ?
04348	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
04349	                             (long int) PyArray_NDIM(tmp) >= 2 ?
04350	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
04351	                             (long int) PyArray_NDIM(tmp) >= 1 ?
04352	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
04353	                             (long int) PyArray_NDIM(tmp) >= 3 ?
04354	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
04355	                             (long int) PyArray_NDIM(tmp) >= 2 ?
04356	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
04357	                             (long int) PyArray_NDIM(tmp) >= 1 ?
04358	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
04359	            );
04360	                {
04361	        __failure = 18;
04362	        if (!PyErr_Occurred()) {
04363	            PyErr_SetString(PyExc_RuntimeError,
04364	                "Unexpected error in an Op's C code. "
04365	                "No Python exception was set.");
04366	            }
04367	        goto __label_18;}
04368	            }
04369	            // This is a TypeError to be consistent with DEBUG_MODE
04370	            // Note: DEBUG_MODE also tells the name of the container
04371	            if (PyArray_TYPE((PyArrayObject*) py_V17) != NPY_FLOAT64) {
04372	                PyErr_Format(PyExc_TypeError,
04373	                             "expected type_num %d (NPY_FLOAT64) got %d",
04374	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V17));
04375	                {
04376	        __failure = 18;
04377	        if (!PyErr_Occurred()) {
04378	            PyErr_SetString(PyExc_RuntimeError,
04379	                "Unexpected error in an Op's C code. "
04380	                "No Python exception was set.");
04381	            }
04382	        goto __label_18;}
04383	            }
04384
04385	        V17 = (PyArrayObject*)(py_V17);
04386	        Py_XINCREF(V17);
04387
04388	{
04389
04390	    py_V19 = PyList_GET_ITEM(storage_V19, 0);
04391	    {Py_XINCREF(py_V19);}
04392
04393	            V19 = NULL;
04394	            if (py_V19 == Py_None) {
04395	                // We can either fail here or set V19 to NULL and rely on Ops
04396	                // using tensors to handle the NULL case, but if they fail to do so
04397	                // they'll end up with nasty segfaults, so this is public service.
04398	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
04399	                {
04400	        __failure = 20;
04401	        if (!PyErr_Occurred()) {
04402	            PyErr_SetString(PyExc_RuntimeError,
04403	                "Unexpected error in an Op's C code. "
04404	                "No Python exception was set.");
04405	            }
04406	        goto __label_20;}
04407	            }
04408	            if (!PyArray_Check(py_V19)) {
04409	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
04410	                {
04411	        __failure = 20;
04412	        if (!PyErr_Occurred()) {
04413	            PyErr_SetString(PyExc_RuntimeError,
04414	                "Unexpected error in an Op's C code. "
04415	                "No Python exception was set.");
04416	            }
04417	        goto __label_20;}
04418	            }
04419	            // We expect NPY_FLOAT64
04420	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V19)) {
04421	                PyArrayObject * tmp = (PyArrayObject*) py_V19;
04422	                PyErr_Format(PyExc_NotImplementedError,
04423	                             "expected an aligned array of type %ld "
04424	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
04425	                             " with %ld dimensions, with 3 last dims "
04426	                             "%ld, %ld, %ld"
04427	                             " and 3 last strides %ld %ld, %ld.",
04428	                             (long int) NPY_FLOAT64,
04429	                             (long int) PyArray_TYPE((PyArrayObject*) py_V19),
04430	                             (long int) PyArray_NDIM(tmp),
04431	                             (long int) PyArray_NDIM(tmp) >= 3 ?
04432	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
04433	                             (long int) PyArray_NDIM(tmp) >= 2 ?
04434	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
04435	                             (long int) PyArray_NDIM(tmp) >= 1 ?
04436	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
04437	                             (long int) PyArray_NDIM(tmp) >= 3 ?
04438	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
04439	                             (long int) PyArray_NDIM(tmp) >= 2 ?
04440	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
04441	                             (long int) PyArray_NDIM(tmp) >= 1 ?
04442	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
04443	            );
04444	                {
04445	        __failure = 20;
04446	        if (!PyErr_Occurred()) {
04447	            PyErr_SetString(PyExc_RuntimeError,
04448	                "Unexpected error in an Op's C code. "
04449	                "No Python exception was set.");
04450	            }
04451	        goto __label_20;}
04452	            }
04453	            // This is a TypeError to be consistent with DEBUG_MODE
04454	            // Note: DEBUG_MODE also tells the name of the container
04455	            if (PyArray_TYPE((PyArrayObject*) py_V19) != NPY_FLOAT64) {
04456	                PyErr_Format(PyExc_TypeError,
04457	                             "expected type_num %d (NPY_FLOAT64) got %d",
04458	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V19));
04459	                {
04460	        __failure = 20;
04461	        if (!PyErr_Occurred()) {
04462	            PyErr_SetString(PyExc_RuntimeError,
04463	                "Unexpected error in an Op's C code. "
04464	                "No Python exception was set.");
04465	            }
04466	        goto __label_20;}
04467	            }
04468
04469	        V19 = (PyArrayObject*)(py_V19);
04470	        Py_XINCREF(V19);
04471
04472	{
04473
04474	    py_V21 = PyList_GET_ITEM(storage_V21, 0);
04475	    {Py_XINCREF(py_V21);}
04476
04477	            V21 = NULL;
04478	            if (py_V21 == Py_None) {
04479	                // We can either fail here or set V21 to NULL and rely on Ops
04480	                // using tensors to handle the NULL case, but if they fail to do so
04481	                // they'll end up with nasty segfaults, so this is public service.
04482	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
04483	                {
04484	        __failure = 22;
04485	        if (!PyErr_Occurred()) {
04486	            PyErr_SetString(PyExc_RuntimeError,
04487	                "Unexpected error in an Op's C code. "
04488	                "No Python exception was set.");
04489	            }
04490	        goto __label_22;}
04491	            }
04492	            if (!PyArray_Check(py_V21)) {
04493	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
04494	                {
04495	        __failure = 22;
04496	        if (!PyErr_Occurred()) {
04497	            PyErr_SetString(PyExc_RuntimeError,
04498	                "Unexpected error in an Op's C code. "
04499	                "No Python exception was set.");
04500	            }
04501	        goto __label_22;}
04502	            }
04503	            // We expect NPY_FLOAT64
04504	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V21)) {
04505	                PyArrayObject * tmp = (PyArrayObject*) py_V21;
04506	                PyErr_Format(PyExc_NotImplementedError,
04507	                             "expected an aligned array of type %ld "
04508	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
04509	                             " with %ld dimensions, with 3 last dims "
04510	                             "%ld, %ld, %ld"
04511	                             " and 3 last strides %ld %ld, %ld.",
04512	                             (long int) NPY_FLOAT64,
04513	                             (long int) PyArray_TYPE((PyArrayObject*) py_V21),
04514	                             (long int) PyArray_NDIM(tmp),
04515	                             (long int) PyArray_NDIM(tmp) >= 3 ?
04516	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
04517	                             (long int) PyArray_NDIM(tmp) >= 2 ?
04518	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
04519	                             (long int) PyArray_NDIM(tmp) >= 1 ?
04520	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
04521	                             (long int) PyArray_NDIM(tmp) >= 3 ?
04522	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
04523	                             (long int) PyArray_NDIM(tmp) >= 2 ?
04524	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
04525	                             (long int) PyArray_NDIM(tmp) >= 1 ?
04526	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
04527	            );
04528	                {
04529	        __failure = 22;
04530	        if (!PyErr_Occurred()) {
04531	            PyErr_SetString(PyExc_RuntimeError,
04532	                "Unexpected error in an Op's C code. "
04533	                "No Python exception was set.");
04534	            }
04535	        goto __label_22;}
04536	            }
04537	            // This is a TypeError to be consistent with DEBUG_MODE
04538	            // Note: DEBUG_MODE also tells the name of the container
04539	            if (PyArray_TYPE((PyArrayObject*) py_V21) != NPY_FLOAT64) {
04540	                PyErr_Format(PyExc_TypeError,
04541	                             "expected type_num %d (NPY_FLOAT64) got %d",
04542	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V21));
04543	                {
04544	        __failure = 22;
04545	        if (!PyErr_Occurred()) {
04546	            PyErr_SetString(PyExc_RuntimeError,
04547	                "Unexpected error in an Op's C code. "
04548	                "No Python exception was set.");
04549	            }
04550	        goto __label_22;}
04551	            }
04552
04553	        V21 = (PyArrayObject*)(py_V21);
04554	        Py_XINCREF(V21);
04555
04556	{
04557
04558	    py_V23 = PyList_GET_ITEM(storage_V23, 0);
04559	    {Py_XINCREF(py_V23);}
04560
04561	            V23 = NULL;
04562	            if (py_V23 == Py_None) {
04563	                // We can either fail here or set V23 to NULL and rely on Ops
04564	                // using tensors to handle the NULL case, but if they fail to do so
04565	                // they'll end up with nasty segfaults, so this is public service.
04566	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
04567	                {
04568	        __failure = 24;
04569	        if (!PyErr_Occurred()) {
04570	            PyErr_SetString(PyExc_RuntimeError,
04571	                "Unexpected error in an Op's C code. "
04572	                "No Python exception was set.");
04573	            }
04574	        goto __label_24;}
04575	            }
04576	            if (!PyArray_Check(py_V23)) {
04577	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
04578	                {
04579	        __failure = 24;
04580	        if (!PyErr_Occurred()) {
04581	            PyErr_SetString(PyExc_RuntimeError,
04582	                "Unexpected error in an Op's C code. "
04583	                "No Python exception was set.");
04584	            }
04585	        goto __label_24;}
04586	            }
04587	            // We expect NPY_FLOAT64
04588	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V23)) {
04589	                PyArrayObject * tmp = (PyArrayObject*) py_V23;
04590	                PyErr_Format(PyExc_NotImplementedError,
04591	                             "expected an aligned array of type %ld "
04592	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
04593	                             " with %ld dimensions, with 3 last dims "
04594	                             "%ld, %ld, %ld"
04595	                             " and 3 last strides %ld %ld, %ld.",
04596	                             (long int) NPY_FLOAT64,
04597	                             (long int) PyArray_TYPE((PyArrayObject*) py_V23),
04598	                             (long int) PyArray_NDIM(tmp),
04599	                             (long int) PyArray_NDIM(tmp) >= 3 ?
04600	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
04601	                             (long int) PyArray_NDIM(tmp) >= 2 ?
04602	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
04603	                             (long int) PyArray_NDIM(tmp) >= 1 ?
04604	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
04605	                             (long int) PyArray_NDIM(tmp) >= 3 ?
04606	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
04607	                             (long int) PyArray_NDIM(tmp) >= 2 ?
04608	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
04609	                             (long int) PyArray_NDIM(tmp) >= 1 ?
04610	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
04611	            );
04612	                {
04613	        __failure = 24;
04614	        if (!PyErr_Occurred()) {
04615	            PyErr_SetString(PyExc_RuntimeError,
04616	                "Unexpected error in an Op's C code. "
04617	                "No Python exception was set.");
04618	            }
04619	        goto __label_24;}
04620	            }
04621	            // This is a TypeError to be consistent with DEBUG_MODE
04622	            // Note: DEBUG_MODE also tells the name of the container
04623	            if (PyArray_TYPE((PyArrayObject*) py_V23) != NPY_FLOAT64) {
04624	                PyErr_Format(PyExc_TypeError,
04625	                             "expected type_num %d (NPY_FLOAT64) got %d",
04626	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V23));
04627	                {
04628	        __failure = 24;
04629	        if (!PyErr_Occurred()) {
04630	            PyErr_SetString(PyExc_RuntimeError,
04631	                "Unexpected error in an Op's C code. "
04632	                "No Python exception was set.");
04633	            }
04634	        goto __label_24;}
04635	            }
04636
04637	        V23 = (PyArrayObject*)(py_V23);
04638	        Py_XINCREF(V23);
04639
04640	{
04641
04642	    py_V25 = PyList_GET_ITEM(storage_V25, 0);
04643	    {Py_XINCREF(py_V25);}
04644
04645	            V25 = NULL;
04646	            if (py_V25 == Py_None) {
04647	                // We can either fail here or set V25 to NULL and rely on Ops
04648	                // using tensors to handle the NULL case, but if they fail to do so
04649	                // they'll end up with nasty segfaults, so this is public service.
04650	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
04651	                {
04652	        __failure = 26;
04653	        if (!PyErr_Occurred()) {
04654	            PyErr_SetString(PyExc_RuntimeError,
04655	                "Unexpected error in an Op's C code. "
04656	                "No Python exception was set.");
04657	            }
04658	        goto __label_26;}
04659	            }
04660	            if (!PyArray_Check(py_V25)) {
04661	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
04662	                {
04663	        __failure = 26;
04664	        if (!PyErr_Occurred()) {
04665	            PyErr_SetString(PyExc_RuntimeError,
04666	                "Unexpected error in an Op's C code. "
04667	                "No Python exception was set.");
04668	            }
04669	        goto __label_26;}
04670	            }
04671	            // We expect NPY_INT8
04672	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V25)) {
04673	                PyArrayObject * tmp = (PyArrayObject*) py_V25;
04674	                PyErr_Format(PyExc_NotImplementedError,
04675	                             "expected an aligned array of type %ld "
04676	                             "(NPY_INT8), got non-aligned array of type %ld"
04677	                             " with %ld dimensions, with 3 last dims "
04678	                             "%ld, %ld, %ld"
04679	                             " and 3 last strides %ld %ld, %ld.",
04680	                             (long int) NPY_INT8,
04681	                             (long int) PyArray_TYPE((PyArrayObject*) py_V25),
04682	                             (long int) PyArray_NDIM(tmp),
04683	                             (long int) PyArray_NDIM(tmp) >= 3 ?
04684	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
04685	                             (long int) PyArray_NDIM(tmp) >= 2 ?
04686	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
04687	                             (long int) PyArray_NDIM(tmp) >= 1 ?
04688	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
04689	                             (long int) PyArray_NDIM(tmp) >= 3 ?
04690	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
04691	                             (long int) PyArray_NDIM(tmp) >= 2 ?
04692	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
04693	                             (long int) PyArray_NDIM(tmp) >= 1 ?
04694	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
04695	            );
04696	                {
04697	        __failure = 26;
04698	        if (!PyErr_Occurred()) {
04699	            PyErr_SetString(PyExc_RuntimeError,
04700	                "Unexpected error in an Op's C code. "
04701	                "No Python exception was set.");
04702	            }
04703	        goto __label_26;}
04704	            }
04705	            // This is a TypeError to be consistent with DEBUG_MODE
04706	            // Note: DEBUG_MODE also tells the name of the container
04707	            if (PyArray_TYPE((PyArrayObject*) py_V25) != NPY_INT8) {
04708	                PyErr_Format(PyExc_TypeError,
04709	                             "expected type_num %d (NPY_INT8) got %d",
04710	                             NPY_INT8, PyArray_TYPE((PyArrayObject*) py_V25));
04711	                {
04712	        __failure = 26;
04713	        if (!PyErr_Occurred()) {
04714	            PyErr_SetString(PyExc_RuntimeError,
04715	                "Unexpected error in an Op's C code. "
04716	                "No Python exception was set.");
04717	            }
04718	        goto __label_26;}
04719	            }
04720
04721	        V25 = (PyArrayObject*)(py_V25);
04722	        Py_XINCREF(V25);
04723
04724	{
04725
04726	    py_V27 = PyList_GET_ITEM(storage_V27, 0);
04727	    {Py_XINCREF(py_V27);}
04728
04729	            V27 = NULL;
04730	            if (py_V27 == Py_None) {
04731	                // We can either fail here or set V27 to NULL and rely on Ops
04732	                // using tensors to handle the NULL case, but if they fail to do so
04733	                // they'll end up with nasty segfaults, so this is public service.
04734	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
04735	                {
04736	        __failure = 28;
04737	        if (!PyErr_Occurred()) {
04738	            PyErr_SetString(PyExc_RuntimeError,
04739	                "Unexpected error in an Op's C code. "
04740	                "No Python exception was set.");
04741	            }
04742	        goto __label_28;}
04743	            }
04744	            if (!PyArray_Check(py_V27)) {
04745	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
04746	                {
04747	        __failure = 28;
04748	        if (!PyErr_Occurred()) {
04749	            PyErr_SetString(PyExc_RuntimeError,
04750	                "Unexpected error in an Op's C code. "
04751	                "No Python exception was set.");
04752	            }
04753	        goto __label_28;}
04754	            }
04755	            // We expect NPY_FLOAT64
04756	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V27)) {
04757	                PyArrayObject * tmp = (PyArrayObject*) py_V27;
04758	                PyErr_Format(PyExc_NotImplementedError,
04759	                             "expected an aligned array of type %ld "
04760	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
04761	                             " with %ld dimensions, with 3 last dims "
04762	                             "%ld, %ld, %ld"
04763	                             " and 3 last strides %ld %ld, %ld.",
04764	                             (long int) NPY_FLOAT64,
04765	                             (long int) PyArray_TYPE((PyArrayObject*) py_V27),
04766	                             (long int) PyArray_NDIM(tmp),
04767	                             (long int) PyArray_NDIM(tmp) >= 3 ?
04768	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
04769	                             (long int) PyArray_NDIM(tmp) >= 2 ?
04770	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
04771	                             (long int) PyArray_NDIM(tmp) >= 1 ?
04772	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
04773	                             (long int) PyArray_NDIM(tmp) >= 3 ?
04774	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
04775	                             (long int) PyArray_NDIM(tmp) >= 2 ?
04776	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
04777	                             (long int) PyArray_NDIM(tmp) >= 1 ?
04778	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
04779	            );
04780	                {
04781	        __failure = 28;
04782	        if (!PyErr_Occurred()) {
04783	            PyErr_SetString(PyExc_RuntimeError,
04784	                "Unexpected error in an Op's C code. "
04785	                "No Python exception was set.");
04786	            }
04787	        goto __label_28;}
04788	            }
04789	            // This is a TypeError to be consistent with DEBUG_MODE
04790	            // Note: DEBUG_MODE also tells the name of the container
04791	            if (PyArray_TYPE((PyArrayObject*) py_V27) != NPY_FLOAT64) {
04792	                PyErr_Format(PyExc_TypeError,
04793	                             "expected type_num %d (NPY_FLOAT64) got %d",
04794	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V27));
04795	                {
04796	        __failure = 28;
04797	        if (!PyErr_Occurred()) {
04798	            PyErr_SetString(PyExc_RuntimeError,
04799	                "Unexpected error in an Op's C code. "
04800	                "No Python exception was set.");
04801	            }
04802	        goto __label_28;}
04803	            }
04804
04805	        V27 = (PyArrayObject*)(py_V27);
04806	        Py_XINCREF(V27);
04807
04808	{
04809
04810	    py_V29 = PyList_GET_ITEM(storage_V29, 0);
04811	    {Py_XINCREF(py_V29);}
04812
04813	            V29 = NULL;
04814	            if (py_V29 == Py_None) {
04815	                // We can either fail here or set V29 to NULL and rely on Ops
04816	                // using tensors to handle the NULL case, but if they fail to do so
04817	                // they'll end up with nasty segfaults, so this is public service.
04818	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
04819	                {
04820	        __failure = 30;
04821	        if (!PyErr_Occurred()) {
04822	            PyErr_SetString(PyExc_RuntimeError,
04823	                "Unexpected error in an Op's C code. "
04824	                "No Python exception was set.");
04825	            }
04826	        goto __label_30;}
04827	            }
04828	            if (!PyArray_Check(py_V29)) {
04829	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
04830	                {
04831	        __failure = 30;
04832	        if (!PyErr_Occurred()) {
04833	            PyErr_SetString(PyExc_RuntimeError,
04834	                "Unexpected error in an Op's C code. "
04835	                "No Python exception was set.");
04836	            }
04837	        goto __label_30;}
04838	            }
04839	            // We expect NPY_FLOAT64
04840	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V29)) {
04841	                PyArrayObject * tmp = (PyArrayObject*) py_V29;
04842	                PyErr_Format(PyExc_NotImplementedError,
04843	                             "expected an aligned array of type %ld "
04844	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
04845	                             " with %ld dimensions, with 3 last dims "
04846	                             "%ld, %ld, %ld"
04847	                             " and 3 last strides %ld %ld, %ld.",
04848	                             (long int) NPY_FLOAT64,
04849	                             (long int) PyArray_TYPE((PyArrayObject*) py_V29),
04850	                             (long int) PyArray_NDIM(tmp),
04851	                             (long int) PyArray_NDIM(tmp) >= 3 ?
04852	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
04853	                             (long int) PyArray_NDIM(tmp) >= 2 ?
04854	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
04855	                             (long int) PyArray_NDIM(tmp) >= 1 ?
04856	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
04857	                             (long int) PyArray_NDIM(tmp) >= 3 ?
04858	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
04859	                             (long int) PyArray_NDIM(tmp) >= 2 ?
04860	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
04861	                             (long int) PyArray_NDIM(tmp) >= 1 ?
04862	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
04863	            );
04864	                {
04865	        __failure = 30;
04866	        if (!PyErr_Occurred()) {
04867	            PyErr_SetString(PyExc_RuntimeError,
04868	                "Unexpected error in an Op's C code. "
04869	                "No Python exception was set.");
04870	            }
04871	        goto __label_30;}
04872	            }
04873	            // This is a TypeError to be consistent with DEBUG_MODE
04874	            // Note: DEBUG_MODE also tells the name of the container
04875	            if (PyArray_TYPE((PyArrayObject*) py_V29) != NPY_FLOAT64) {
04876	                PyErr_Format(PyExc_TypeError,
04877	                             "expected type_num %d (NPY_FLOAT64) got %d",
04878	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V29));
04879	                {
04880	        __failure = 30;
04881	        if (!PyErr_Occurred()) {
04882	            PyErr_SetString(PyExc_RuntimeError,
04883	                "Unexpected error in an Op's C code. "
04884	                "No Python exception was set.");
04885	            }
04886	        goto __label_30;}
04887	            }
04888
04889	        V29 = (PyArrayObject*)(py_V29);
04890	        Py_XINCREF(V29);
04891
04892	{
04893
04894	    py_V31 = PyList_GET_ITEM(storage_V31, 0);
04895	    {Py_XINCREF(py_V31);}
04896
04897	            V31 = NULL;
04898	            if (py_V31 == Py_None) {
04899	                // We can either fail here or set V31 to NULL and rely on Ops
04900	                // using tensors to handle the NULL case, but if they fail to do so
04901	                // they'll end up with nasty segfaults, so this is public service.
04902	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
04903	                {
04904	        __failure = 32;
04905	        if (!PyErr_Occurred()) {
04906	            PyErr_SetString(PyExc_RuntimeError,
04907	                "Unexpected error in an Op's C code. "
04908	                "No Python exception was set.");
04909	            }
04910	        goto __label_32;}
04911	            }
04912	            if (!PyArray_Check(py_V31)) {
04913	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
04914	                {
04915	        __failure = 32;
04916	        if (!PyErr_Occurred()) {
04917	            PyErr_SetString(PyExc_RuntimeError,
04918	                "Unexpected error in an Op's C code. "
04919	                "No Python exception was set.");
04920	            }
04921	        goto __label_32;}
04922	            }
04923	            // We expect NPY_FLOAT64
04924	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V31)) {
04925	                PyArrayObject * tmp = (PyArrayObject*) py_V31;
04926	                PyErr_Format(PyExc_NotImplementedError,
04927	                             "expected an aligned array of type %ld "
04928	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
04929	                             " with %ld dimensions, with 3 last dims "
04930	                             "%ld, %ld, %ld"
04931	                             " and 3 last strides %ld %ld, %ld.",
04932	                             (long int) NPY_FLOAT64,
04933	                             (long int) PyArray_TYPE((PyArrayObject*) py_V31),
04934	                             (long int) PyArray_NDIM(tmp),
04935	                             (long int) PyArray_NDIM(tmp) >= 3 ?
04936	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
04937	                             (long int) PyArray_NDIM(tmp) >= 2 ?
04938	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
04939	                             (long int) PyArray_NDIM(tmp) >= 1 ?
04940	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
04941	                             (long int) PyArray_NDIM(tmp) >= 3 ?
04942	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
04943	                             (long int) PyArray_NDIM(tmp) >= 2 ?
04944	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
04945	                             (long int) PyArray_NDIM(tmp) >= 1 ?
04946	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
04947	            );
04948	                {
04949	        __failure = 32;
04950	        if (!PyErr_Occurred()) {
04951	            PyErr_SetString(PyExc_RuntimeError,
04952	                "Unexpected error in an Op's C code. "
04953	                "No Python exception was set.");
04954	            }
04955	        goto __label_32;}
04956	            }
04957	            // This is a TypeError to be consistent with DEBUG_MODE
04958	            // Note: DEBUG_MODE also tells the name of the container
04959	            if (PyArray_TYPE((PyArrayObject*) py_V31) != NPY_FLOAT64) {
04960	                PyErr_Format(PyExc_TypeError,
04961	                             "expected type_num %d (NPY_FLOAT64) got %d",
04962	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V31));
04963	                {
04964	        __failure = 32;
04965	        if (!PyErr_Occurred()) {
04966	            PyErr_SetString(PyExc_RuntimeError,
04967	                "Unexpected error in an Op's C code. "
04968	                "No Python exception was set.");
04969	            }
04970	        goto __label_32;}
04971	            }
04972
04973	        V31 = (PyArrayObject*)(py_V31);
04974	        Py_XINCREF(V31);
04975
04976	{
04977
04978	    py_V33 = PyList_GET_ITEM(storage_V33, 0);
04979	    {Py_XINCREF(py_V33);}
04980
04981	            V33 = NULL;
04982	            if (py_V33 == Py_None) {
04983	                // We can either fail here or set V33 to NULL and rely on Ops
04984	                // using tensors to handle the NULL case, but if they fail to do so
04985	                // they'll end up with nasty segfaults, so this is public service.
04986	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
04987	                {
04988	        __failure = 34;
04989	        if (!PyErr_Occurred()) {
04990	            PyErr_SetString(PyExc_RuntimeError,
04991	                "Unexpected error in an Op's C code. "
04992	                "No Python exception was set.");
04993	            }
04994	        goto __label_34;}
04995	            }
04996	            if (!PyArray_Check(py_V33)) {
04997	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
04998	                {
04999	        __failure = 34;
05000	        if (!PyErr_Occurred()) {
05001	            PyErr_SetString(PyExc_RuntimeError,
05002	                "Unexpected error in an Op's C code. "
05003	                "No Python exception was set.");
05004	            }
05005	        goto __label_34;}
05006	            }
05007	            // We expect NPY_FLOAT64
05008	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V33)) {
05009	                PyArrayObject * tmp = (PyArrayObject*) py_V33;
05010	                PyErr_Format(PyExc_NotImplementedError,
05011	                             "expected an aligned array of type %ld "
05012	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
05013	                             " with %ld dimensions, with 3 last dims "
05014	                             "%ld, %ld, %ld"
05015	                             " and 3 last strides %ld %ld, %ld.",
05016	                             (long int) NPY_FLOAT64,
05017	                             (long int) PyArray_TYPE((PyArrayObject*) py_V33),
05018	                             (long int) PyArray_NDIM(tmp),
05019	                             (long int) PyArray_NDIM(tmp) >= 3 ?
05020	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
05021	                             (long int) PyArray_NDIM(tmp) >= 2 ?
05022	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
05023	                             (long int) PyArray_NDIM(tmp) >= 1 ?
05024	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
05025	                             (long int) PyArray_NDIM(tmp) >= 3 ?
05026	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
05027	                             (long int) PyArray_NDIM(tmp) >= 2 ?
05028	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
05029	                             (long int) PyArray_NDIM(tmp) >= 1 ?
05030	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
05031	            );
05032	                {
05033	        __failure = 34;
05034	        if (!PyErr_Occurred()) {
05035	            PyErr_SetString(PyExc_RuntimeError,
05036	                "Unexpected error in an Op's C code. "
05037	                "No Python exception was set.");
05038	            }
05039	        goto __label_34;}
05040	            }
05041	            // This is a TypeError to be consistent with DEBUG_MODE
05042	            // Note: DEBUG_MODE also tells the name of the container
05043	            if (PyArray_TYPE((PyArrayObject*) py_V33) != NPY_FLOAT64) {
05044	                PyErr_Format(PyExc_TypeError,
05045	                             "expected type_num %d (NPY_FLOAT64) got %d",
05046	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V33));
05047	                {
05048	        __failure = 34;
05049	        if (!PyErr_Occurred()) {
05050	            PyErr_SetString(PyExc_RuntimeError,
05051	                "Unexpected error in an Op's C code. "
05052	                "No Python exception was set.");
05053	            }
05054	        goto __label_34;}
05055	            }
05056
05057	        V33 = (PyArrayObject*)(py_V33);
05058	        Py_XINCREF(V33);
05059
05060	{
05061
05062	    py_V35 = PyList_GET_ITEM(storage_V35, 0);
05063	    {Py_XINCREF(py_V35);}
05064
05065	            V35 = NULL;
05066	            if (py_V35 == Py_None) {
05067	                // We can either fail here or set V35 to NULL and rely on Ops
05068	                // using tensors to handle the NULL case, but if they fail to do so
05069	                // they'll end up with nasty segfaults, so this is public service.
05070	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
05071	                {
05072	        __failure = 36;
05073	        if (!PyErr_Occurred()) {
05074	            PyErr_SetString(PyExc_RuntimeError,
05075	                "Unexpected error in an Op's C code. "
05076	                "No Python exception was set.");
05077	            }
05078	        goto __label_36;}
05079	            }
05080	            if (!PyArray_Check(py_V35)) {
05081	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
05082	                {
05083	        __failure = 36;
05084	        if (!PyErr_Occurred()) {
05085	            PyErr_SetString(PyExc_RuntimeError,
05086	                "Unexpected error in an Op's C code. "
05087	                "No Python exception was set.");
05088	            }
05089	        goto __label_36;}
05090	            }
05091	            // We expect NPY_FLOAT64
05092	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V35)) {
05093	                PyArrayObject * tmp = (PyArrayObject*) py_V35;
05094	                PyErr_Format(PyExc_NotImplementedError,
05095	                             "expected an aligned array of type %ld "
05096	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
05097	                             " with %ld dimensions, with 3 last dims "
05098	                             "%ld, %ld, %ld"
05099	                             " and 3 last strides %ld %ld, %ld.",
05100	                             (long int) NPY_FLOAT64,
05101	                             (long int) PyArray_TYPE((PyArrayObject*) py_V35),
05102	                             (long int) PyArray_NDIM(tmp),
05103	                             (long int) PyArray_NDIM(tmp) >= 3 ?
05104	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
05105	                             (long int) PyArray_NDIM(tmp) >= 2 ?
05106	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
05107	                             (long int) PyArray_NDIM(tmp) >= 1 ?
05108	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
05109	                             (long int) PyArray_NDIM(tmp) >= 3 ?
05110	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
05111	                             (long int) PyArray_NDIM(tmp) >= 2 ?
05112	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
05113	                             (long int) PyArray_NDIM(tmp) >= 1 ?
05114	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
05115	            );
05116	                {
05117	        __failure = 36;
05118	        if (!PyErr_Occurred()) {
05119	            PyErr_SetString(PyExc_RuntimeError,
05120	                "Unexpected error in an Op's C code. "
05121	                "No Python exception was set.");
05122	            }
05123	        goto __label_36;}
05124	            }
05125	            // This is a TypeError to be consistent with DEBUG_MODE
05126	            // Note: DEBUG_MODE also tells the name of the container
05127	            if (PyArray_TYPE((PyArrayObject*) py_V35) != NPY_FLOAT64) {
05128	                PyErr_Format(PyExc_TypeError,
05129	                             "expected type_num %d (NPY_FLOAT64) got %d",
05130	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V35));
05131	                {
05132	        __failure = 36;
05133	        if (!PyErr_Occurred()) {
05134	            PyErr_SetString(PyExc_RuntimeError,
05135	                "Unexpected error in an Op's C code. "
05136	                "No Python exception was set.");
05137	            }
05138	        goto __label_36;}
05139	            }
05140
05141	        V35 = (PyArrayObject*)(py_V35);
05142	        Py_XINCREF(V35);
05143
05144	{
05145
05146	    py_V37 = PyList_GET_ITEM(storage_V37, 0);
05147	    {Py_XINCREF(py_V37);}
05148
05149	            V37 = NULL;
05150	            if (py_V37 == Py_None) {
05151	                // We can either fail here or set V37 to NULL and rely on Ops
05152	                // using tensors to handle the NULL case, but if they fail to do so
05153	                // they'll end up with nasty segfaults, so this is public service.
05154	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
05155	                {
05156	        __failure = 38;
05157	        if (!PyErr_Occurred()) {
05158	            PyErr_SetString(PyExc_RuntimeError,
05159	                "Unexpected error in an Op's C code. "
05160	                "No Python exception was set.");
05161	            }
05162	        goto __label_38;}
05163	            }
05164	            if (!PyArray_Check(py_V37)) {
05165	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
05166	                {
05167	        __failure = 38;
05168	        if (!PyErr_Occurred()) {
05169	            PyErr_SetString(PyExc_RuntimeError,
05170	                "Unexpected error in an Op's C code. "
05171	                "No Python exception was set.");
05172	            }
05173	        goto __label_38;}
05174	            }
05175	            // We expect NPY_FLOAT64
05176	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V37)) {
05177	                PyArrayObject * tmp = (PyArrayObject*) py_V37;
05178	                PyErr_Format(PyExc_NotImplementedError,
05179	                             "expected an aligned array of type %ld "
05180	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
05181	                             " with %ld dimensions, with 3 last dims "
05182	                             "%ld, %ld, %ld"
05183	                             " and 3 last strides %ld %ld, %ld.",
05184	                             (long int) NPY_FLOAT64,
05185	                             (long int) PyArray_TYPE((PyArrayObject*) py_V37),
05186	                             (long int) PyArray_NDIM(tmp),
05187	                             (long int) PyArray_NDIM(tmp) >= 3 ?
05188	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
05189	                             (long int) PyArray_NDIM(tmp) >= 2 ?
05190	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
05191	                             (long int) PyArray_NDIM(tmp) >= 1 ?
05192	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
05193	                             (long int) PyArray_NDIM(tmp) >= 3 ?
05194	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
05195	                             (long int) PyArray_NDIM(tmp) >= 2 ?
05196	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
05197	                             (long int) PyArray_NDIM(tmp) >= 1 ?
05198	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
05199	            );
05200	                {
05201	        __failure = 38;
05202	        if (!PyErr_Occurred()) {
05203	            PyErr_SetString(PyExc_RuntimeError,
05204	                "Unexpected error in an Op's C code. "
05205	                "No Python exception was set.");
05206	            }
05207	        goto __label_38;}
05208	            }
05209	            // This is a TypeError to be consistent with DEBUG_MODE
05210	            // Note: DEBUG_MODE also tells the name of the container
05211	            if (PyArray_TYPE((PyArrayObject*) py_V37) != NPY_FLOAT64) {
05212	                PyErr_Format(PyExc_TypeError,
05213	                             "expected type_num %d (NPY_FLOAT64) got %d",
05214	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V37));
05215	                {
05216	        __failure = 38;
05217	        if (!PyErr_Occurred()) {
05218	            PyErr_SetString(PyExc_RuntimeError,
05219	                "Unexpected error in an Op's C code. "
05220	                "No Python exception was set.");
05221	            }
05222	        goto __label_38;}
05223	            }
05224
05225	        V37 = (PyArrayObject*)(py_V37);
05226	        Py_XINCREF(V37);
05227
05228	{
05229
05230	    py_V39 = PyList_GET_ITEM(storage_V39, 0);
05231	    {Py_XINCREF(py_V39);}
05232
05233	            V39 = NULL;
05234	            if (py_V39 == Py_None) {
05235	                // We can either fail here or set V39 to NULL and rely on Ops
05236	                // using tensors to handle the NULL case, but if they fail to do so
05237	                // they'll end up with nasty segfaults, so this is public service.
05238	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
05239	                {
05240	        __failure = 40;
05241	        if (!PyErr_Occurred()) {
05242	            PyErr_SetString(PyExc_RuntimeError,
05243	                "Unexpected error in an Op's C code. "
05244	                "No Python exception was set.");
05245	            }
05246	        goto __label_40;}
05247	            }
05248	            if (!PyArray_Check(py_V39)) {
05249	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
05250	                {
05251	        __failure = 40;
05252	        if (!PyErr_Occurred()) {
05253	            PyErr_SetString(PyExc_RuntimeError,
05254	                "Unexpected error in an Op's C code. "
05255	                "No Python exception was set.");
05256	            }
05257	        goto __label_40;}
05258	            }
05259	            // We expect NPY_FLOAT64
05260	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V39)) {
05261	                PyArrayObject * tmp = (PyArrayObject*) py_V39;
05262	                PyErr_Format(PyExc_NotImplementedError,
05263	                             "expected an aligned array of type %ld "
05264	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
05265	                             " with %ld dimensions, with 3 last dims "
05266	                             "%ld, %ld, %ld"
05267	                             " and 3 last strides %ld %ld, %ld.",
05268	                             (long int) NPY_FLOAT64,
05269	                             (long int) PyArray_TYPE((PyArrayObject*) py_V39),
05270	                             (long int) PyArray_NDIM(tmp),
05271	                             (long int) PyArray_NDIM(tmp) >= 3 ?
05272	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
05273	                             (long int) PyArray_NDIM(tmp) >= 2 ?
05274	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
05275	                             (long int) PyArray_NDIM(tmp) >= 1 ?
05276	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
05277	                             (long int) PyArray_NDIM(tmp) >= 3 ?
05278	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
05279	                             (long int) PyArray_NDIM(tmp) >= 2 ?
05280	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
05281	                             (long int) PyArray_NDIM(tmp) >= 1 ?
05282	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
05283	            );
05284	                {
05285	        __failure = 40;
05286	        if (!PyErr_Occurred()) {
05287	            PyErr_SetString(PyExc_RuntimeError,
05288	                "Unexpected error in an Op's C code. "
05289	                "No Python exception was set.");
05290	            }
05291	        goto __label_40;}
05292	            }
05293	            // This is a TypeError to be consistent with DEBUG_MODE
05294	            // Note: DEBUG_MODE also tells the name of the container
05295	            if (PyArray_TYPE((PyArrayObject*) py_V39) != NPY_FLOAT64) {
05296	                PyErr_Format(PyExc_TypeError,
05297	                             "expected type_num %d (NPY_FLOAT64) got %d",
05298	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V39));
05299	                {
05300	        __failure = 40;
05301	        if (!PyErr_Occurred()) {
05302	            PyErr_SetString(PyExc_RuntimeError,
05303	                "Unexpected error in an Op's C code. "
05304	                "No Python exception was set.");
05305	            }
05306	        goto __label_40;}
05307	            }
05308
05309	        V39 = (PyArrayObject*)(py_V39);
05310	        Py_XINCREF(V39);
05311
05312	{
05313
05314	    py_V41 = PyList_GET_ITEM(storage_V41, 0);
05315	    {Py_XINCREF(py_V41);}
05316
05317	            V41 = NULL;
05318	            if (py_V41 == Py_None) {
05319	                // We can either fail here or set V41 to NULL and rely on Ops
05320	                // using tensors to handle the NULL case, but if they fail to do so
05321	                // they'll end up with nasty segfaults, so this is public service.
05322	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
05323	                {
05324	        __failure = 42;
05325	        if (!PyErr_Occurred()) {
05326	            PyErr_SetString(PyExc_RuntimeError,
05327	                "Unexpected error in an Op's C code. "
05328	                "No Python exception was set.");
05329	            }
05330	        goto __label_42;}
05331	            }
05332	            if (!PyArray_Check(py_V41)) {
05333	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
05334	                {
05335	        __failure = 42;
05336	        if (!PyErr_Occurred()) {
05337	            PyErr_SetString(PyExc_RuntimeError,
05338	                "Unexpected error in an Op's C code. "
05339	                "No Python exception was set.");
05340	            }
05341	        goto __label_42;}
05342	            }
05343	            // We expect NPY_INT8
05344	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V41)) {
05345	                PyArrayObject * tmp = (PyArrayObject*) py_V41;
05346	                PyErr_Format(PyExc_NotImplementedError,
05347	                             "expected an aligned array of type %ld "
05348	                             "(NPY_INT8), got non-aligned array of type %ld"
05349	                             " with %ld dimensions, with 3 last dims "
05350	                             "%ld, %ld, %ld"
05351	                             " and 3 last strides %ld %ld, %ld.",
05352	                             (long int) NPY_INT8,
05353	                             (long int) PyArray_TYPE((PyArrayObject*) py_V41),
05354	                             (long int) PyArray_NDIM(tmp),
05355	                             (long int) PyArray_NDIM(tmp) >= 3 ?
05356	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
05357	                             (long int) PyArray_NDIM(tmp) >= 2 ?
05358	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
05359	                             (long int) PyArray_NDIM(tmp) >= 1 ?
05360	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
05361	                             (long int) PyArray_NDIM(tmp) >= 3 ?
05362	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
05363	                             (long int) PyArray_NDIM(tmp) >= 2 ?
05364	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
05365	                             (long int) PyArray_NDIM(tmp) >= 1 ?
05366	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
05367	            );
05368	                {
05369	        __failure = 42;
05370	        if (!PyErr_Occurred()) {
05371	            PyErr_SetString(PyExc_RuntimeError,
05372	                "Unexpected error in an Op's C code. "
05373	                "No Python exception was set.");
05374	            }
05375	        goto __label_42;}
05376	            }
05377	            // This is a TypeError to be consistent with DEBUG_MODE
05378	            // Note: DEBUG_MODE also tells the name of the container
05379	            if (PyArray_TYPE((PyArrayObject*) py_V41) != NPY_INT8) {
05380	                PyErr_Format(PyExc_TypeError,
05381	                             "expected type_num %d (NPY_INT8) got %d",
05382	                             NPY_INT8, PyArray_TYPE((PyArrayObject*) py_V41));
05383	                {
05384	        __failure = 42;
05385	        if (!PyErr_Occurred()) {
05386	            PyErr_SetString(PyExc_RuntimeError,
05387	                "Unexpected error in an Op's C code. "
05388	                "No Python exception was set.");
05389	            }
05390	        goto __label_42;}
05391	            }
05392
05393	        V41 = (PyArrayObject*)(py_V41);
05394	        Py_XINCREF(V41);
05395
05396	{
05397
05398	    py_V43 = PyList_GET_ITEM(storage_V43, 0);
05399	    {Py_XINCREF(py_V43);}
05400
05401	            V43 = NULL;
05402	            if (py_V43 == Py_None) {
05403	                // We can either fail here or set V43 to NULL and rely on Ops
05404	                // using tensors to handle the NULL case, but if they fail to do so
05405	                // they'll end up with nasty segfaults, so this is public service.
05406	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
05407	                {
05408	        __failure = 44;
05409	        if (!PyErr_Occurred()) {
05410	            PyErr_SetString(PyExc_RuntimeError,
05411	                "Unexpected error in an Op's C code. "
05412	                "No Python exception was set.");
05413	            }
05414	        goto __label_44;}
05415	            }
05416	            if (!PyArray_Check(py_V43)) {
05417	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
05418	                {
05419	        __failure = 44;
05420	        if (!PyErr_Occurred()) {
05421	            PyErr_SetString(PyExc_RuntimeError,
05422	                "Unexpected error in an Op's C code. "
05423	                "No Python exception was set.");
05424	            }
05425	        goto __label_44;}
05426	            }
05427	            // We expect NPY_FLOAT64
05428	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V43)) {
05429	                PyArrayObject * tmp = (PyArrayObject*) py_V43;
05430	                PyErr_Format(PyExc_NotImplementedError,
05431	                             "expected an aligned array of type %ld "
05432	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
05433	                             " with %ld dimensions, with 3 last dims "
05434	                             "%ld, %ld, %ld"
05435	                             " and 3 last strides %ld %ld, %ld.",
05436	                             (long int) NPY_FLOAT64,
05437	                             (long int) PyArray_TYPE((PyArrayObject*) py_V43),
05438	                             (long int) PyArray_NDIM(tmp),
05439	                             (long int) PyArray_NDIM(tmp) >= 3 ?
05440	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
05441	                             (long int) PyArray_NDIM(tmp) >= 2 ?
05442	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
05443	                             (long int) PyArray_NDIM(tmp) >= 1 ?
05444	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
05445	                             (long int) PyArray_NDIM(tmp) >= 3 ?
05446	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
05447	                             (long int) PyArray_NDIM(tmp) >= 2 ?
05448	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
05449	                             (long int) PyArray_NDIM(tmp) >= 1 ?
05450	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
05451	            );
05452	                {
05453	        __failure = 44;
05454	        if (!PyErr_Occurred()) {
05455	            PyErr_SetString(PyExc_RuntimeError,
05456	                "Unexpected error in an Op's C code. "
05457	                "No Python exception was set.");
05458	            }
05459	        goto __label_44;}
05460	            }
05461	            // This is a TypeError to be consistent with DEBUG_MODE
05462	            // Note: DEBUG_MODE also tells the name of the container
05463	            if (PyArray_TYPE((PyArrayObject*) py_V43) != NPY_FLOAT64) {
05464	                PyErr_Format(PyExc_TypeError,
05465	                             "expected type_num %d (NPY_FLOAT64) got %d",
05466	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V43));
05467	                {
05468	        __failure = 44;
05469	        if (!PyErr_Occurred()) {
05470	            PyErr_SetString(PyExc_RuntimeError,
05471	                "Unexpected error in an Op's C code. "
05472	                "No Python exception was set.");
05473	            }
05474	        goto __label_44;}
05475	            }
05476
05477	        V43 = (PyArrayObject*)(py_V43);
05478	        Py_XINCREF(V43);
05479
05480	{
05481
05482	    py_V45 = PyList_GET_ITEM(storage_V45, 0);
05483	    {Py_XINCREF(py_V45);}
05484
05485	            V45 = NULL;
05486	            if (py_V45 == Py_None) {
05487	                // We can either fail here or set V45 to NULL and rely on Ops
05488	                // using tensors to handle the NULL case, but if they fail to do so
05489	                // they'll end up with nasty segfaults, so this is public service.
05490	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
05491	                {
05492	        __failure = 46;
05493	        if (!PyErr_Occurred()) {
05494	            PyErr_SetString(PyExc_RuntimeError,
05495	                "Unexpected error in an Op's C code. "
05496	                "No Python exception was set.");
05497	            }
05498	        goto __label_46;}
05499	            }
05500	            if (!PyArray_Check(py_V45)) {
05501	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
05502	                {
05503	        __failure = 46;
05504	        if (!PyErr_Occurred()) {
05505	            PyErr_SetString(PyExc_RuntimeError,
05506	                "Unexpected error in an Op's C code. "
05507	                "No Python exception was set.");
05508	            }
05509	        goto __label_46;}
05510	            }
05511	            // We expect NPY_FLOAT64
05512	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V45)) {
05513	                PyArrayObject * tmp = (PyArrayObject*) py_V45;
05514	                PyErr_Format(PyExc_NotImplementedError,
05515	                             "expected an aligned array of type %ld "
05516	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
05517	                             " with %ld dimensions, with 3 last dims "
05518	                             "%ld, %ld, %ld"
05519	                             " and 3 last strides %ld %ld, %ld.",
05520	                             (long int) NPY_FLOAT64,
05521	                             (long int) PyArray_TYPE((PyArrayObject*) py_V45),
05522	                             (long int) PyArray_NDIM(tmp),
05523	                             (long int) PyArray_NDIM(tmp) >= 3 ?
05524	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
05525	                             (long int) PyArray_NDIM(tmp) >= 2 ?
05526	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
05527	                             (long int) PyArray_NDIM(tmp) >= 1 ?
05528	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
05529	                             (long int) PyArray_NDIM(tmp) >= 3 ?
05530	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
05531	                             (long int) PyArray_NDIM(tmp) >= 2 ?
05532	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
05533	                             (long int) PyArray_NDIM(tmp) >= 1 ?
05534	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
05535	            );
05536	                {
05537	        __failure = 46;
05538	        if (!PyErr_Occurred()) {
05539	            PyErr_SetString(PyExc_RuntimeError,
05540	                "Unexpected error in an Op's C code. "
05541	                "No Python exception was set.");
05542	            }
05543	        goto __label_46;}
05544	            }
05545	            // This is a TypeError to be consistent with DEBUG_MODE
05546	            // Note: DEBUG_MODE also tells the name of the container
05547	            if (PyArray_TYPE((PyArrayObject*) py_V45) != NPY_FLOAT64) {
05548	                PyErr_Format(PyExc_TypeError,
05549	                             "expected type_num %d (NPY_FLOAT64) got %d",
05550	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V45));
05551	                {
05552	        __failure = 46;
05553	        if (!PyErr_Occurred()) {
05554	            PyErr_SetString(PyExc_RuntimeError,
05555	                "Unexpected error in an Op's C code. "
05556	                "No Python exception was set.");
05557	            }
05558	        goto __label_46;}
05559	            }
05560
05561	        V45 = (PyArrayObject*)(py_V45);
05562	        Py_XINCREF(V45);
05563
05564	{
05565
05566	    py_V47 = PyList_GET_ITEM(storage_V47, 0);
05567	    {Py_XINCREF(py_V47);}
05568
05569	            V47 = NULL;
05570	            if (py_V47 == Py_None) {
05571	                // We can either fail here or set V47 to NULL and rely on Ops
05572	                // using tensors to handle the NULL case, but if they fail to do so
05573	                // they'll end up with nasty segfaults, so this is public service.
05574	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
05575	                {
05576	        __failure = 48;
05577	        if (!PyErr_Occurred()) {
05578	            PyErr_SetString(PyExc_RuntimeError,
05579	                "Unexpected error in an Op's C code. "
05580	                "No Python exception was set.");
05581	            }
05582	        goto __label_48;}
05583	            }
05584	            if (!PyArray_Check(py_V47)) {
05585	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
05586	                {
05587	        __failure = 48;
05588	        if (!PyErr_Occurred()) {
05589	            PyErr_SetString(PyExc_RuntimeError,
05590	                "Unexpected error in an Op's C code. "
05591	                "No Python exception was set.");
05592	            }
05593	        goto __label_48;}
05594	            }
05595	            // We expect NPY_FLOAT64
05596	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V47)) {
05597	                PyArrayObject * tmp = (PyArrayObject*) py_V47;
05598	                PyErr_Format(PyExc_NotImplementedError,
05599	                             "expected an aligned array of type %ld "
05600	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
05601	                             " with %ld dimensions, with 3 last dims "
05602	                             "%ld, %ld, %ld"
05603	                             " and 3 last strides %ld %ld, %ld.",
05604	                             (long int) NPY_FLOAT64,
05605	                             (long int) PyArray_TYPE((PyArrayObject*) py_V47),
05606	                             (long int) PyArray_NDIM(tmp),
05607	                             (long int) PyArray_NDIM(tmp) >= 3 ?
05608	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
05609	                             (long int) PyArray_NDIM(tmp) >= 2 ?
05610	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
05611	                             (long int) PyArray_NDIM(tmp) >= 1 ?
05612	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
05613	                             (long int) PyArray_NDIM(tmp) >= 3 ?
05614	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
05615	                             (long int) PyArray_NDIM(tmp) >= 2 ?
05616	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
05617	                             (long int) PyArray_NDIM(tmp) >= 1 ?
05618	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
05619	            );
05620	                {
05621	        __failure = 48;
05622	        if (!PyErr_Occurred()) {
05623	            PyErr_SetString(PyExc_RuntimeError,
05624	                "Unexpected error in an Op's C code. "
05625	                "No Python exception was set.");
05626	            }
05627	        goto __label_48;}
05628	            }
05629	            // This is a TypeError to be consistent with DEBUG_MODE
05630	            // Note: DEBUG_MODE also tells the name of the container
05631	            if (PyArray_TYPE((PyArrayObject*) py_V47) != NPY_FLOAT64) {
05632	                PyErr_Format(PyExc_TypeError,
05633	                             "expected type_num %d (NPY_FLOAT64) got %d",
05634	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V47));
05635	                {
05636	        __failure = 48;
05637	        if (!PyErr_Occurred()) {
05638	            PyErr_SetString(PyExc_RuntimeError,
05639	                "Unexpected error in an Op's C code. "
05640	                "No Python exception was set.");
05641	            }
05642	        goto __label_48;}
05643	            }
05644
05645	        V47 = (PyArrayObject*)(py_V47);
05646	        Py_XINCREF(V47);
05647
05648	{
05649
05650	    py_V49 = PyList_GET_ITEM(storage_V49, 0);
05651	    {Py_XINCREF(py_V49);}
05652
05653	            V49 = NULL;
05654	            if (py_V49 == Py_None) {
05655	                // We can either fail here or set V49 to NULL and rely on Ops
05656	                // using tensors to handle the NULL case, but if they fail to do so
05657	                // they'll end up with nasty segfaults, so this is public service.
05658	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
05659	                {
05660	        __failure = 50;
05661	        if (!PyErr_Occurred()) {
05662	            PyErr_SetString(PyExc_RuntimeError,
05663	                "Unexpected error in an Op's C code. "
05664	                "No Python exception was set.");
05665	            }
05666	        goto __label_50;}
05667	            }
05668	            if (!PyArray_Check(py_V49)) {
05669	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
05670	                {
05671	        __failure = 50;
05672	        if (!PyErr_Occurred()) {
05673	            PyErr_SetString(PyExc_RuntimeError,
05674	                "Unexpected error in an Op's C code. "
05675	                "No Python exception was set.");
05676	            }
05677	        goto __label_50;}
05678	            }
05679	            // We expect NPY_FLOAT64
05680	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V49)) {
05681	                PyArrayObject * tmp = (PyArrayObject*) py_V49;
05682	                PyErr_Format(PyExc_NotImplementedError,
05683	                             "expected an aligned array of type %ld "
05684	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
05685	                             " with %ld dimensions, with 3 last dims "
05686	                             "%ld, %ld, %ld"
05687	                             " and 3 last strides %ld %ld, %ld.",
05688	                             (long int) NPY_FLOAT64,
05689	                             (long int) PyArray_TYPE((PyArrayObject*) py_V49),
05690	                             (long int) PyArray_NDIM(tmp),
05691	                             (long int) PyArray_NDIM(tmp) >= 3 ?
05692	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
05693	                             (long int) PyArray_NDIM(tmp) >= 2 ?
05694	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
05695	                             (long int) PyArray_NDIM(tmp) >= 1 ?
05696	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
05697	                             (long int) PyArray_NDIM(tmp) >= 3 ?
05698	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
05699	                             (long int) PyArray_NDIM(tmp) >= 2 ?
05700	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
05701	                             (long int) PyArray_NDIM(tmp) >= 1 ?
05702	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
05703	            );
05704	                {
05705	        __failure = 50;
05706	        if (!PyErr_Occurred()) {
05707	            PyErr_SetString(PyExc_RuntimeError,
05708	                "Unexpected error in an Op's C code. "
05709	                "No Python exception was set.");
05710	            }
05711	        goto __label_50;}
05712	            }
05713	            // This is a TypeError to be consistent with DEBUG_MODE
05714	            // Note: DEBUG_MODE also tells the name of the container
05715	            if (PyArray_TYPE((PyArrayObject*) py_V49) != NPY_FLOAT64) {
05716	                PyErr_Format(PyExc_TypeError,
05717	                             "expected type_num %d (NPY_FLOAT64) got %d",
05718	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V49));
05719	                {
05720	        __failure = 50;
05721	        if (!PyErr_Occurred()) {
05722	            PyErr_SetString(PyExc_RuntimeError,
05723	                "Unexpected error in an Op's C code. "
05724	                "No Python exception was set.");
05725	            }
05726	        goto __label_50;}
05727	            }
05728
05729	        V49 = (PyArrayObject*)(py_V49);
05730	        Py_XINCREF(V49);
05731
05732	{
05733
05734	    py_V51 = PyList_GET_ITEM(storage_V51, 0);
05735	    {Py_XINCREF(py_V51);}
05736
05737	            V51 = NULL;
05738	            if (py_V51 == Py_None) {
05739	                // We can either fail here or set V51 to NULL and rely on Ops
05740	                // using tensors to handle the NULL case, but if they fail to do so
05741	                // they'll end up with nasty segfaults, so this is public service.
05742	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
05743	                {
05744	        __failure = 52;
05745	        if (!PyErr_Occurred()) {
05746	            PyErr_SetString(PyExc_RuntimeError,
05747	                "Unexpected error in an Op's C code. "
05748	                "No Python exception was set.");
05749	            }
05750	        goto __label_52;}
05751	            }
05752	            if (!PyArray_Check(py_V51)) {
05753	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
05754	                {
05755	        __failure = 52;
05756	        if (!PyErr_Occurred()) {
05757	            PyErr_SetString(PyExc_RuntimeError,
05758	                "Unexpected error in an Op's C code. "
05759	                "No Python exception was set.");
05760	            }
05761	        goto __label_52;}
05762	            }
05763	            // We expect NPY_FLOAT64
05764	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V51)) {
05765	                PyArrayObject * tmp = (PyArrayObject*) py_V51;
05766	                PyErr_Format(PyExc_NotImplementedError,
05767	                             "expected an aligned array of type %ld "
05768	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
05769	                             " with %ld dimensions, with 3 last dims "
05770	                             "%ld, %ld, %ld"
05771	                             " and 3 last strides %ld %ld, %ld.",
05772	                             (long int) NPY_FLOAT64,
05773	                             (long int) PyArray_TYPE((PyArrayObject*) py_V51),
05774	                             (long int) PyArray_NDIM(tmp),
05775	                             (long int) PyArray_NDIM(tmp) >= 3 ?
05776	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
05777	                             (long int) PyArray_NDIM(tmp) >= 2 ?
05778	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
05779	                             (long int) PyArray_NDIM(tmp) >= 1 ?
05780	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
05781	                             (long int) PyArray_NDIM(tmp) >= 3 ?
05782	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
05783	                             (long int) PyArray_NDIM(tmp) >= 2 ?
05784	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
05785	                             (long int) PyArray_NDIM(tmp) >= 1 ?
05786	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
05787	            );
05788	                {
05789	        __failure = 52;
05790	        if (!PyErr_Occurred()) {
05791	            PyErr_SetString(PyExc_RuntimeError,
05792	                "Unexpected error in an Op's C code. "
05793	                "No Python exception was set.");
05794	            }
05795	        goto __label_52;}
05796	            }
05797	            // This is a TypeError to be consistent with DEBUG_MODE
05798	            // Note: DEBUG_MODE also tells the name of the container
05799	            if (PyArray_TYPE((PyArrayObject*) py_V51) != NPY_FLOAT64) {
05800	                PyErr_Format(PyExc_TypeError,
05801	                             "expected type_num %d (NPY_FLOAT64) got %d",
05802	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V51));
05803	                {
05804	        __failure = 52;
05805	        if (!PyErr_Occurred()) {
05806	            PyErr_SetString(PyExc_RuntimeError,
05807	                "Unexpected error in an Op's C code. "
05808	                "No Python exception was set.");
05809	            }
05810	        goto __label_52;}
05811	            }
05812
05813	        V51 = (PyArrayObject*)(py_V51);
05814	        Py_XINCREF(V51);
05815
05816	{
05817
05818	    py_V53 = PyList_GET_ITEM(storage_V53, 0);
05819	    {Py_XINCREF(py_V53);}
05820
05821	            V53 = NULL;
05822	            if (py_V53 == Py_None) {
05823	                // We can either fail here or set V53 to NULL and rely on Ops
05824	                // using tensors to handle the NULL case, but if they fail to do so
05825	                // they'll end up with nasty segfaults, so this is public service.
05826	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
05827	                {
05828	        __failure = 54;
05829	        if (!PyErr_Occurred()) {
05830	            PyErr_SetString(PyExc_RuntimeError,
05831	                "Unexpected error in an Op's C code. "
05832	                "No Python exception was set.");
05833	            }
05834	        goto __label_54;}
05835	            }
05836	            if (!PyArray_Check(py_V53)) {
05837	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
05838	                {
05839	        __failure = 54;
05840	        if (!PyErr_Occurred()) {
05841	            PyErr_SetString(PyExc_RuntimeError,
05842	                "Unexpected error in an Op's C code. "
05843	                "No Python exception was set.");
05844	            }
05845	        goto __label_54;}
05846	            }
05847	            // We expect NPY_FLOAT64
05848	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V53)) {
05849	                PyArrayObject * tmp = (PyArrayObject*) py_V53;
05850	                PyErr_Format(PyExc_NotImplementedError,
05851	                             "expected an aligned array of type %ld "
05852	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
05853	                             " with %ld dimensions, with 3 last dims "
05854	                             "%ld, %ld, %ld"
05855	                             " and 3 last strides %ld %ld, %ld.",
05856	                             (long int) NPY_FLOAT64,
05857	                             (long int) PyArray_TYPE((PyArrayObject*) py_V53),
05858	                             (long int) PyArray_NDIM(tmp),
05859	                             (long int) PyArray_NDIM(tmp) >= 3 ?
05860	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
05861	                             (long int) PyArray_NDIM(tmp) >= 2 ?
05862	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
05863	                             (long int) PyArray_NDIM(tmp) >= 1 ?
05864	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
05865	                             (long int) PyArray_NDIM(tmp) >= 3 ?
05866	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
05867	                             (long int) PyArray_NDIM(tmp) >= 2 ?
05868	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
05869	                             (long int) PyArray_NDIM(tmp) >= 1 ?
05870	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
05871	            );
05872	                {
05873	        __failure = 54;
05874	        if (!PyErr_Occurred()) {
05875	            PyErr_SetString(PyExc_RuntimeError,
05876	                "Unexpected error in an Op's C code. "
05877	                "No Python exception was set.");
05878	            }
05879	        goto __label_54;}
05880	            }
05881	            // This is a TypeError to be consistent with DEBUG_MODE
05882	            // Note: DEBUG_MODE also tells the name of the container
05883	            if (PyArray_TYPE((PyArrayObject*) py_V53) != NPY_FLOAT64) {
05884	                PyErr_Format(PyExc_TypeError,
05885	                             "expected type_num %d (NPY_FLOAT64) got %d",
05886	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V53));
05887	                {
05888	        __failure = 54;
05889	        if (!PyErr_Occurred()) {
05890	            PyErr_SetString(PyExc_RuntimeError,
05891	                "Unexpected error in an Op's C code. "
05892	                "No Python exception was set.");
05893	            }
05894	        goto __label_54;}
05895	            }
05896
05897	        V53 = (PyArrayObject*)(py_V53);
05898	        Py_XINCREF(V53);
05899
05900	{
05901
05902	    py_V55 = PyList_GET_ITEM(storage_V55, 0);
05903	    {Py_XINCREF(py_V55);}
05904
05905	            V55 = NULL;
05906	            if (py_V55 == Py_None) {
05907	                // We can either fail here or set V55 to NULL and rely on Ops
05908	                // using tensors to handle the NULL case, but if they fail to do so
05909	                // they'll end up with nasty segfaults, so this is public service.
05910	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
05911	                {
05912	        __failure = 56;
05913	        if (!PyErr_Occurred()) {
05914	            PyErr_SetString(PyExc_RuntimeError,
05915	                "Unexpected error in an Op's C code. "
05916	                "No Python exception was set.");
05917	            }
05918	        goto __label_56;}
05919	            }
05920	            if (!PyArray_Check(py_V55)) {
05921	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
05922	                {
05923	        __failure = 56;
05924	        if (!PyErr_Occurred()) {
05925	            PyErr_SetString(PyExc_RuntimeError,
05926	                "Unexpected error in an Op's C code. "
05927	                "No Python exception was set.");
05928	            }
05929	        goto __label_56;}
05930	            }
05931	            // We expect NPY_FLOAT64
05932	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V55)) {
05933	                PyArrayObject * tmp = (PyArrayObject*) py_V55;
05934	                PyErr_Format(PyExc_NotImplementedError,
05935	                             "expected an aligned array of type %ld "
05936	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
05937	                             " with %ld dimensions, with 3 last dims "
05938	                             "%ld, %ld, %ld"
05939	                             " and 3 last strides %ld %ld, %ld.",
05940	                             (long int) NPY_FLOAT64,
05941	                             (long int) PyArray_TYPE((PyArrayObject*) py_V55),
05942	                             (long int) PyArray_NDIM(tmp),
05943	                             (long int) PyArray_NDIM(tmp) >= 3 ?
05944	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
05945	                             (long int) PyArray_NDIM(tmp) >= 2 ?
05946	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
05947	                             (long int) PyArray_NDIM(tmp) >= 1 ?
05948	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
05949	                             (long int) PyArray_NDIM(tmp) >= 3 ?
05950	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
05951	                             (long int) PyArray_NDIM(tmp) >= 2 ?
05952	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
05953	                             (long int) PyArray_NDIM(tmp) >= 1 ?
05954	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
05955	            );
05956	                {
05957	        __failure = 56;
05958	        if (!PyErr_Occurred()) {
05959	            PyErr_SetString(PyExc_RuntimeError,
05960	                "Unexpected error in an Op's C code. "
05961	                "No Python exception was set.");
05962	            }
05963	        goto __label_56;}
05964	            }
05965	            // This is a TypeError to be consistent with DEBUG_MODE
05966	            // Note: DEBUG_MODE also tells the name of the container
05967	            if (PyArray_TYPE((PyArrayObject*) py_V55) != NPY_FLOAT64) {
05968	                PyErr_Format(PyExc_TypeError,
05969	                             "expected type_num %d (NPY_FLOAT64) got %d",
05970	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V55));
05971	                {
05972	        __failure = 56;
05973	        if (!PyErr_Occurred()) {
05974	            PyErr_SetString(PyExc_RuntimeError,
05975	                "Unexpected error in an Op's C code. "
05976	                "No Python exception was set.");
05977	            }
05978	        goto __label_56;}
05979	            }
05980
05981	        V55 = (PyArrayObject*)(py_V55);
05982	        Py_XINCREF(V55);
05983
05984	{
05985
05986	    py_V57 = PyList_GET_ITEM(storage_V57, 0);
05987	    {Py_XINCREF(py_V57);}
05988
05989	            V57 = NULL;
05990	            if (py_V57 == Py_None) {
05991	                // We can either fail here or set V57 to NULL and rely on Ops
05992	                // using tensors to handle the NULL case, but if they fail to do so
05993	                // they'll end up with nasty segfaults, so this is public service.
05994	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
05995	                {
05996	        __failure = 58;
05997	        if (!PyErr_Occurred()) {
05998	            PyErr_SetString(PyExc_RuntimeError,
05999	                "Unexpected error in an Op's C code. "
06000	                "No Python exception was set.");
06001	            }
06002	        goto __label_58;}
06003	            }
06004	            if (!PyArray_Check(py_V57)) {
06005	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
06006	                {
06007	        __failure = 58;
06008	        if (!PyErr_Occurred()) {
06009	            PyErr_SetString(PyExc_RuntimeError,
06010	                "Unexpected error in an Op's C code. "
06011	                "No Python exception was set.");
06012	            }
06013	        goto __label_58;}
06014	            }
06015	            // We expect NPY_INT8
06016	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V57)) {
06017	                PyArrayObject * tmp = (PyArrayObject*) py_V57;
06018	                PyErr_Format(PyExc_NotImplementedError,
06019	                             "expected an aligned array of type %ld "
06020	                             "(NPY_INT8), got non-aligned array of type %ld"
06021	                             " with %ld dimensions, with 3 last dims "
06022	                             "%ld, %ld, %ld"
06023	                             " and 3 last strides %ld %ld, %ld.",
06024	                             (long int) NPY_INT8,
06025	                             (long int) PyArray_TYPE((PyArrayObject*) py_V57),
06026	                             (long int) PyArray_NDIM(tmp),
06027	                             (long int) PyArray_NDIM(tmp) >= 3 ?
06028	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
06029	                             (long int) PyArray_NDIM(tmp) >= 2 ?
06030	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
06031	                             (long int) PyArray_NDIM(tmp) >= 1 ?
06032	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
06033	                             (long int) PyArray_NDIM(tmp) >= 3 ?
06034	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
06035	                             (long int) PyArray_NDIM(tmp) >= 2 ?
06036	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
06037	                             (long int) PyArray_NDIM(tmp) >= 1 ?
06038	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
06039	            );
06040	                {
06041	        __failure = 58;
06042	        if (!PyErr_Occurred()) {
06043	            PyErr_SetString(PyExc_RuntimeError,
06044	                "Unexpected error in an Op's C code. "
06045	                "No Python exception was set.");
06046	            }
06047	        goto __label_58;}
06048	            }
06049	            // This is a TypeError to be consistent with DEBUG_MODE
06050	            // Note: DEBUG_MODE also tells the name of the container
06051	            if (PyArray_TYPE((PyArrayObject*) py_V57) != NPY_INT8) {
06052	                PyErr_Format(PyExc_TypeError,
06053	                             "expected type_num %d (NPY_INT8) got %d",
06054	                             NPY_INT8, PyArray_TYPE((PyArrayObject*) py_V57));
06055	                {
06056	        __failure = 58;
06057	        if (!PyErr_Occurred()) {
06058	            PyErr_SetString(PyExc_RuntimeError,
06059	                "Unexpected error in an Op's C code. "
06060	                "No Python exception was set.");
06061	            }
06062	        goto __label_58;}
06063	            }
06064
06065	        V57 = (PyArrayObject*)(py_V57);
06066	        Py_XINCREF(V57);
06067
06068	{
06069
06070	    py_V59 = PyList_GET_ITEM(storage_V59, 0);
06071	    {Py_XINCREF(py_V59);}
06072
06073	            V59 = NULL;
06074	            if (py_V59 == Py_None) {
06075	                // We can either fail here or set V59 to NULL and rely on Ops
06076	                // using tensors to handle the NULL case, but if they fail to do so
06077	                // they'll end up with nasty segfaults, so this is public service.
06078	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
06079	                {
06080	        __failure = 60;
06081	        if (!PyErr_Occurred()) {
06082	            PyErr_SetString(PyExc_RuntimeError,
06083	                "Unexpected error in an Op's C code. "
06084	                "No Python exception was set.");
06085	            }
06086	        goto __label_60;}
06087	            }
06088	            if (!PyArray_Check(py_V59)) {
06089	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
06090	                {
06091	        __failure = 60;
06092	        if (!PyErr_Occurred()) {
06093	            PyErr_SetString(PyExc_RuntimeError,
06094	                "Unexpected error in an Op's C code. "
06095	                "No Python exception was set.");
06096	            }
06097	        goto __label_60;}
06098	            }
06099	            // We expect NPY_FLOAT64
06100	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V59)) {
06101	                PyArrayObject * tmp = (PyArrayObject*) py_V59;
06102	                PyErr_Format(PyExc_NotImplementedError,
06103	                             "expected an aligned array of type %ld "
06104	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
06105	                             " with %ld dimensions, with 3 last dims "
06106	                             "%ld, %ld, %ld"
06107	                             " and 3 last strides %ld %ld, %ld.",
06108	                             (long int) NPY_FLOAT64,
06109	                             (long int) PyArray_TYPE((PyArrayObject*) py_V59),
06110	                             (long int) PyArray_NDIM(tmp),
06111	                             (long int) PyArray_NDIM(tmp) >= 3 ?
06112	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
06113	                             (long int) PyArray_NDIM(tmp) >= 2 ?
06114	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
06115	                             (long int) PyArray_NDIM(tmp) >= 1 ?
06116	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
06117	                             (long int) PyArray_NDIM(tmp) >= 3 ?
06118	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
06119	                             (long int) PyArray_NDIM(tmp) >= 2 ?
06120	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
06121	                             (long int) PyArray_NDIM(tmp) >= 1 ?
06122	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
06123	            );
06124	                {
06125	        __failure = 60;
06126	        if (!PyErr_Occurred()) {
06127	            PyErr_SetString(PyExc_RuntimeError,
06128	                "Unexpected error in an Op's C code. "
06129	                "No Python exception was set.");
06130	            }
06131	        goto __label_60;}
06132	            }
06133	            // This is a TypeError to be consistent with DEBUG_MODE
06134	            // Note: DEBUG_MODE also tells the name of the container
06135	            if (PyArray_TYPE((PyArrayObject*) py_V59) != NPY_FLOAT64) {
06136	                PyErr_Format(PyExc_TypeError,
06137	                             "expected type_num %d (NPY_FLOAT64) got %d",
06138	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V59));
06139	                {
06140	        __failure = 60;
06141	        if (!PyErr_Occurred()) {
06142	            PyErr_SetString(PyExc_RuntimeError,
06143	                "Unexpected error in an Op's C code. "
06144	                "No Python exception was set.");
06145	            }
06146	        goto __label_60;}
06147	            }
06148
06149	        V59 = (PyArrayObject*)(py_V59);
06150	        Py_XINCREF(V59);
06151
06152	{
06153
06154	    py_V61 = PyList_GET_ITEM(storage_V61, 0);
06155	    {Py_XINCREF(py_V61);}
06156
06157	            V61 = NULL;
06158	            if (py_V61 == Py_None) {
06159	                // We can either fail here or set V61 to NULL and rely on Ops
06160	                // using tensors to handle the NULL case, but if they fail to do so
06161	                // they'll end up with nasty segfaults, so this is public service.
06162	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
06163	                {
06164	        __failure = 62;
06165	        if (!PyErr_Occurred()) {
06166	            PyErr_SetString(PyExc_RuntimeError,
06167	                "Unexpected error in an Op's C code. "
06168	                "No Python exception was set.");
06169	            }
06170	        goto __label_62;}
06171	            }
06172	            if (!PyArray_Check(py_V61)) {
06173	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
06174	                {
06175	        __failure = 62;
06176	        if (!PyErr_Occurred()) {
06177	            PyErr_SetString(PyExc_RuntimeError,
06178	                "Unexpected error in an Op's C code. "
06179	                "No Python exception was set.");
06180	            }
06181	        goto __label_62;}
06182	            }
06183	            // We expect NPY_FLOAT64
06184	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V61)) {
06185	                PyArrayObject * tmp = (PyArrayObject*) py_V61;
06186	                PyErr_Format(PyExc_NotImplementedError,
06187	                             "expected an aligned array of type %ld "
06188	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
06189	                             " with %ld dimensions, with 3 last dims "
06190	                             "%ld, %ld, %ld"
06191	                             " and 3 last strides %ld %ld, %ld.",
06192	                             (long int) NPY_FLOAT64,
06193	                             (long int) PyArray_TYPE((PyArrayObject*) py_V61),
06194	                             (long int) PyArray_NDIM(tmp),
06195	                             (long int) PyArray_NDIM(tmp) >= 3 ?
06196	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
06197	                             (long int) PyArray_NDIM(tmp) >= 2 ?
06198	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
06199	                             (long int) PyArray_NDIM(tmp) >= 1 ?
06200	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
06201	                             (long int) PyArray_NDIM(tmp) >= 3 ?
06202	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
06203	                             (long int) PyArray_NDIM(tmp) >= 2 ?
06204	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
06205	                             (long int) PyArray_NDIM(tmp) >= 1 ?
06206	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
06207	            );
06208	                {
06209	        __failure = 62;
06210	        if (!PyErr_Occurred()) {
06211	            PyErr_SetString(PyExc_RuntimeError,
06212	                "Unexpected error in an Op's C code. "
06213	                "No Python exception was set.");
06214	            }
06215	        goto __label_62;}
06216	            }
06217	            // This is a TypeError to be consistent with DEBUG_MODE
06218	            // Note: DEBUG_MODE also tells the name of the container
06219	            if (PyArray_TYPE((PyArrayObject*) py_V61) != NPY_FLOAT64) {
06220	                PyErr_Format(PyExc_TypeError,
06221	                             "expected type_num %d (NPY_FLOAT64) got %d",
06222	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V61));
06223	                {
06224	        __failure = 62;
06225	        if (!PyErr_Occurred()) {
06226	            PyErr_SetString(PyExc_RuntimeError,
06227	                "Unexpected error in an Op's C code. "
06228	                "No Python exception was set.");
06229	            }
06230	        goto __label_62;}
06231	            }
06232
06233	        V61 = (PyArrayObject*)(py_V61);
06234	        Py_XINCREF(V61);
06235
06236	{
06237
06238	    py_V63 = PyList_GET_ITEM(storage_V63, 0);
06239	    {Py_XINCREF(py_V63);}
06240
06241	            V63 = NULL;
06242	            if (py_V63 == Py_None) {
06243	                // We can either fail here or set V63 to NULL and rely on Ops
06244	                // using tensors to handle the NULL case, but if they fail to do so
06245	                // they'll end up with nasty segfaults, so this is public service.
06246	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
06247	                {
06248	        __failure = 64;
06249	        if (!PyErr_Occurred()) {
06250	            PyErr_SetString(PyExc_RuntimeError,
06251	                "Unexpected error in an Op's C code. "
06252	                "No Python exception was set.");
06253	            }
06254	        goto __label_64;}
06255	            }
06256	            if (!PyArray_Check(py_V63)) {
06257	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
06258	                {
06259	        __failure = 64;
06260	        if (!PyErr_Occurred()) {
06261	            PyErr_SetString(PyExc_RuntimeError,
06262	                "Unexpected error in an Op's C code. "
06263	                "No Python exception was set.");
06264	            }
06265	        goto __label_64;}
06266	            }
06267	            // We expect NPY_FLOAT64
06268	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V63)) {
06269	                PyArrayObject * tmp = (PyArrayObject*) py_V63;
06270	                PyErr_Format(PyExc_NotImplementedError,
06271	                             "expected an aligned array of type %ld "
06272	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
06273	                             " with %ld dimensions, with 3 last dims "
06274	                             "%ld, %ld, %ld"
06275	                             " and 3 last strides %ld %ld, %ld.",
06276	                             (long int) NPY_FLOAT64,
06277	                             (long int) PyArray_TYPE((PyArrayObject*) py_V63),
06278	                             (long int) PyArray_NDIM(tmp),
06279	                             (long int) PyArray_NDIM(tmp) >= 3 ?
06280	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
06281	                             (long int) PyArray_NDIM(tmp) >= 2 ?
06282	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
06283	                             (long int) PyArray_NDIM(tmp) >= 1 ?
06284	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
06285	                             (long int) PyArray_NDIM(tmp) >= 3 ?
06286	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
06287	                             (long int) PyArray_NDIM(tmp) >= 2 ?
06288	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
06289	                             (long int) PyArray_NDIM(tmp) >= 1 ?
06290	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
06291	            );
06292	                {
06293	        __failure = 64;
06294	        if (!PyErr_Occurred()) {
06295	            PyErr_SetString(PyExc_RuntimeError,
06296	                "Unexpected error in an Op's C code. "
06297	                "No Python exception was set.");
06298	            }
06299	        goto __label_64;}
06300	            }
06301	            // This is a TypeError to be consistent with DEBUG_MODE
06302	            // Note: DEBUG_MODE also tells the name of the container
06303	            if (PyArray_TYPE((PyArrayObject*) py_V63) != NPY_FLOAT64) {
06304	                PyErr_Format(PyExc_TypeError,
06305	                             "expected type_num %d (NPY_FLOAT64) got %d",
06306	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V63));
06307	                {
06308	        __failure = 64;
06309	        if (!PyErr_Occurred()) {
06310	            PyErr_SetString(PyExc_RuntimeError,
06311	                "Unexpected error in an Op's C code. "
06312	                "No Python exception was set.");
06313	            }
06314	        goto __label_64;}
06315	            }
06316
06317	        V63 = (PyArrayObject*)(py_V63);
06318	        Py_XINCREF(V63);
06319
06320	{
06321
06322	    py_V65 = PyList_GET_ITEM(storage_V65, 0);
06323	    {Py_XINCREF(py_V65);}
06324
06325	            V65 = NULL;
06326	            if (py_V65 == Py_None) {
06327	                // We can either fail here or set V65 to NULL and rely on Ops
06328	                // using tensors to handle the NULL case, but if they fail to do so
06329	                // they'll end up with nasty segfaults, so this is public service.
06330	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
06331	                {
06332	        __failure = 66;
06333	        if (!PyErr_Occurred()) {
06334	            PyErr_SetString(PyExc_RuntimeError,
06335	                "Unexpected error in an Op's C code. "
06336	                "No Python exception was set.");
06337	            }
06338	        goto __label_66;}
06339	            }
06340	            if (!PyArray_Check(py_V65)) {
06341	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
06342	                {
06343	        __failure = 66;
06344	        if (!PyErr_Occurred()) {
06345	            PyErr_SetString(PyExc_RuntimeError,
06346	                "Unexpected error in an Op's C code. "
06347	                "No Python exception was set.");
06348	            }
06349	        goto __label_66;}
06350	            }
06351	            // We expect NPY_FLOAT64
06352	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V65)) {
06353	                PyArrayObject * tmp = (PyArrayObject*) py_V65;
06354	                PyErr_Format(PyExc_NotImplementedError,
06355	                             "expected an aligned array of type %ld "
06356	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
06357	                             " with %ld dimensions, with 3 last dims "
06358	                             "%ld, %ld, %ld"
06359	                             " and 3 last strides %ld %ld, %ld.",
06360	                             (long int) NPY_FLOAT64,
06361	                             (long int) PyArray_TYPE((PyArrayObject*) py_V65),
06362	                             (long int) PyArray_NDIM(tmp),
06363	                             (long int) PyArray_NDIM(tmp) >= 3 ?
06364	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
06365	                             (long int) PyArray_NDIM(tmp) >= 2 ?
06366	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
06367	                             (long int) PyArray_NDIM(tmp) >= 1 ?
06368	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
06369	                             (long int) PyArray_NDIM(tmp) >= 3 ?
06370	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
06371	                             (long int) PyArray_NDIM(tmp) >= 2 ?
06372	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
06373	                             (long int) PyArray_NDIM(tmp) >= 1 ?
06374	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
06375	            );
06376	                {
06377	        __failure = 66;
06378	        if (!PyErr_Occurred()) {
06379	            PyErr_SetString(PyExc_RuntimeError,
06380	                "Unexpected error in an Op's C code. "
06381	                "No Python exception was set.");
06382	            }
06383	        goto __label_66;}
06384	            }
06385	            // This is a TypeError to be consistent with DEBUG_MODE
06386	            // Note: DEBUG_MODE also tells the name of the container
06387	            if (PyArray_TYPE((PyArrayObject*) py_V65) != NPY_FLOAT64) {
06388	                PyErr_Format(PyExc_TypeError,
06389	                             "expected type_num %d (NPY_FLOAT64) got %d",
06390	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V65));
06391	                {
06392	        __failure = 66;
06393	        if (!PyErr_Occurred()) {
06394	            PyErr_SetString(PyExc_RuntimeError,
06395	                "Unexpected error in an Op's C code. "
06396	                "No Python exception was set.");
06397	            }
06398	        goto __label_66;}
06399	            }
06400
06401	        V65 = (PyArrayObject*)(py_V65);
06402	        Py_XINCREF(V65);
06403
06404	{
06405
06406	    py_V67 = PyList_GET_ITEM(storage_V67, 0);
06407	    {Py_XINCREF(py_V67);}
06408
06409	            V67 = NULL;
06410	            if (py_V67 == Py_None) {
06411	                // We can either fail here or set V67 to NULL and rely on Ops
06412	                // using tensors to handle the NULL case, but if they fail to do so
06413	                // they'll end up with nasty segfaults, so this is public service.
06414	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
06415	                {
06416	        __failure = 68;
06417	        if (!PyErr_Occurred()) {
06418	            PyErr_SetString(PyExc_RuntimeError,
06419	                "Unexpected error in an Op's C code. "
06420	                "No Python exception was set.");
06421	            }
06422	        goto __label_68;}
06423	            }
06424	            if (!PyArray_Check(py_V67)) {
06425	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
06426	                {
06427	        __failure = 68;
06428	        if (!PyErr_Occurred()) {
06429	            PyErr_SetString(PyExc_RuntimeError,
06430	                "Unexpected error in an Op's C code. "
06431	                "No Python exception was set.");
06432	            }
06433	        goto __label_68;}
06434	            }
06435	            // We expect NPY_FLOAT64
06436	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V67)) {
06437	                PyArrayObject * tmp = (PyArrayObject*) py_V67;
06438	                PyErr_Format(PyExc_NotImplementedError,
06439	                             "expected an aligned array of type %ld "
06440	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
06441	                             " with %ld dimensions, with 3 last dims "
06442	                             "%ld, %ld, %ld"
06443	                             " and 3 last strides %ld %ld, %ld.",
06444	                             (long int) NPY_FLOAT64,
06445	                             (long int) PyArray_TYPE((PyArrayObject*) py_V67),
06446	                             (long int) PyArray_NDIM(tmp),
06447	                             (long int) PyArray_NDIM(tmp) >= 3 ?
06448	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
06449	                             (long int) PyArray_NDIM(tmp) >= 2 ?
06450	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
06451	                             (long int) PyArray_NDIM(tmp) >= 1 ?
06452	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
06453	                             (long int) PyArray_NDIM(tmp) >= 3 ?
06454	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
06455	                             (long int) PyArray_NDIM(tmp) >= 2 ?
06456	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
06457	                             (long int) PyArray_NDIM(tmp) >= 1 ?
06458	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
06459	            );
06460	                {
06461	        __failure = 68;
06462	        if (!PyErr_Occurred()) {
06463	            PyErr_SetString(PyExc_RuntimeError,
06464	                "Unexpected error in an Op's C code. "
06465	                "No Python exception was set.");
06466	            }
06467	        goto __label_68;}
06468	            }
06469	            // This is a TypeError to be consistent with DEBUG_MODE
06470	            // Note: DEBUG_MODE also tells the name of the container
06471	            if (PyArray_TYPE((PyArrayObject*) py_V67) != NPY_FLOAT64) {
06472	                PyErr_Format(PyExc_TypeError,
06473	                             "expected type_num %d (NPY_FLOAT64) got %d",
06474	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V67));
06475	                {
06476	        __failure = 68;
06477	        if (!PyErr_Occurred()) {
06478	            PyErr_SetString(PyExc_RuntimeError,
06479	                "Unexpected error in an Op's C code. "
06480	                "No Python exception was set.");
06481	            }
06482	        goto __label_68;}
06483	            }
06484
06485	        V67 = (PyArrayObject*)(py_V67);
06486	        Py_XINCREF(V67);
06487
06488	{
06489
06490	    py_V69 = PyList_GET_ITEM(storage_V69, 0);
06491	    {Py_XINCREF(py_V69);}
06492
06493	            V69 = NULL;
06494	            if (py_V69 == Py_None) {
06495	                // We can either fail here or set V69 to NULL and rely on Ops
06496	                // using tensors to handle the NULL case, but if they fail to do so
06497	                // they'll end up with nasty segfaults, so this is public service.
06498	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
06499	                {
06500	        __failure = 70;
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_70;}
06507	            }
06508	            if (!PyArray_Check(py_V69)) {
06509	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
06510	                {
06511	        __failure = 70;
06512	        if (!PyErr_Occurred()) {
06513	            PyErr_SetString(PyExc_RuntimeError,
06514	                "Unexpected error in an Op's C code. "
06515	                "No Python exception was set.");
06516	            }
06517	        goto __label_70;}
06518	            }
06519	            // We expect NPY_FLOAT64
06520	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V69)) {
06521	                PyArrayObject * tmp = (PyArrayObject*) py_V69;
06522	                PyErr_Format(PyExc_NotImplementedError,
06523	                             "expected an aligned array of type %ld "
06524	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
06525	                             " with %ld dimensions, with 3 last dims "
06526	                             "%ld, %ld, %ld"
06527	                             " and 3 last strides %ld %ld, %ld.",
06528	                             (long int) NPY_FLOAT64,
06529	                             (long int) PyArray_TYPE((PyArrayObject*) py_V69),
06530	                             (long int) PyArray_NDIM(tmp),
06531	                             (long int) PyArray_NDIM(tmp) >= 3 ?
06532	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
06533	                             (long int) PyArray_NDIM(tmp) >= 2 ?
06534	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
06535	                             (long int) PyArray_NDIM(tmp) >= 1 ?
06536	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
06537	                             (long int) PyArray_NDIM(tmp) >= 3 ?
06538	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
06539	                             (long int) PyArray_NDIM(tmp) >= 2 ?
06540	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
06541	                             (long int) PyArray_NDIM(tmp) >= 1 ?
06542	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
06543	            );
06544	                {
06545	        __failure = 70;
06546	        if (!PyErr_Occurred()) {
06547	            PyErr_SetString(PyExc_RuntimeError,
06548	                "Unexpected error in an Op's C code. "
06549	                "No Python exception was set.");
06550	            }
06551	        goto __label_70;}
06552	            }
06553	            // This is a TypeError to be consistent with DEBUG_MODE
06554	            // Note: DEBUG_MODE also tells the name of the container
06555	            if (PyArray_TYPE((PyArrayObject*) py_V69) != NPY_FLOAT64) {
06556	                PyErr_Format(PyExc_TypeError,
06557	                             "expected type_num %d (NPY_FLOAT64) got %d",
06558	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V69));
06559	                {
06560	        __failure = 70;
06561	        if (!PyErr_Occurred()) {
06562	            PyErr_SetString(PyExc_RuntimeError,
06563	                "Unexpected error in an Op's C code. "
06564	                "No Python exception was set.");
06565	            }
06566	        goto __label_70;}
06567	            }
06568
06569	        V69 = (PyArrayObject*)(py_V69);
06570	        Py_XINCREF(V69);
06571
06572	{
06573
06574	    py_V71 = PyList_GET_ITEM(storage_V71, 0);
06575	    {Py_XINCREF(py_V71);}
06576
06577	            V71 = NULL;
06578	            if (py_V71 == Py_None) {
06579	                // We can either fail here or set V71 to NULL and rely on Ops
06580	                // using tensors to handle the NULL case, but if they fail to do so
06581	                // they'll end up with nasty segfaults, so this is public service.
06582	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
06583	                {
06584	        __failure = 72;
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_72;}
06591	            }
06592	            if (!PyArray_Check(py_V71)) {
06593	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
06594	                {
06595	        __failure = 72;
06596	        if (!PyErr_Occurred()) {
06597	            PyErr_SetString(PyExc_RuntimeError,
06598	                "Unexpected error in an Op's C code. "
06599	                "No Python exception was set.");
06600	            }
06601	        goto __label_72;}
06602	            }
06603	            // We expect NPY_INT8
06604	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V71)) {
06605	                PyArrayObject * tmp = (PyArrayObject*) py_V71;
06606	                PyErr_Format(PyExc_NotImplementedError,
06607	                             "expected an aligned array of type %ld "
06608	                             "(NPY_INT8), got non-aligned array of type %ld"
06609	                             " with %ld dimensions, with 3 last dims "
06610	                             "%ld, %ld, %ld"
06611	                             " and 3 last strides %ld %ld, %ld.",
06612	                             (long int) NPY_INT8,
06613	                             (long int) PyArray_TYPE((PyArrayObject*) py_V71),
06614	                             (long int) PyArray_NDIM(tmp),
06615	                             (long int) PyArray_NDIM(tmp) >= 3 ?
06616	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
06617	                             (long int) PyArray_NDIM(tmp) >= 2 ?
06618	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
06619	                             (long int) PyArray_NDIM(tmp) >= 1 ?
06620	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
06621	                             (long int) PyArray_NDIM(tmp) >= 3 ?
06622	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
06623	                             (long int) PyArray_NDIM(tmp) >= 2 ?
06624	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
06625	                             (long int) PyArray_NDIM(tmp) >= 1 ?
06626	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
06627	            );
06628	                {
06629	        __failure = 72;
06630	        if (!PyErr_Occurred()) {
06631	            PyErr_SetString(PyExc_RuntimeError,
06632	                "Unexpected error in an Op's C code. "
06633	                "No Python exception was set.");
06634	            }
06635	        goto __label_72;}
06636	            }
06637	            // This is a TypeError to be consistent with DEBUG_MODE
06638	            // Note: DEBUG_MODE also tells the name of the container
06639	            if (PyArray_TYPE((PyArrayObject*) py_V71) != NPY_INT8) {
06640	                PyErr_Format(PyExc_TypeError,
06641	                             "expected type_num %d (NPY_INT8) got %d",
06642	                             NPY_INT8, PyArray_TYPE((PyArrayObject*) py_V71));
06643	                {
06644	        __failure = 72;
06645	        if (!PyErr_Occurred()) {
06646	            PyErr_SetString(PyExc_RuntimeError,
06647	                "Unexpected error in an Op's C code. "
06648	                "No Python exception was set.");
06649	            }
06650	        goto __label_72;}
06651	            }
06652
06653	        V71 = (PyArrayObject*)(py_V71);
06654	        Py_XINCREF(V71);
06655
06656	{
06657
06658	    py_V73 = PyList_GET_ITEM(storage_V73, 0);
06659	    {Py_XINCREF(py_V73);}
06660
06661	            V73 = NULL;
06662	            if (py_V73 == Py_None) {
06663	                // We can either fail here or set V73 to NULL and rely on Ops
06664	                // using tensors to handle the NULL case, but if they fail to do so
06665	                // they'll end up with nasty segfaults, so this is public service.
06666	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
06667	                {
06668	        __failure = 74;
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_74;}
06675	            }
06676	            if (!PyArray_Check(py_V73)) {
06677	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
06678	                {
06679	        __failure = 74;
06680	        if (!PyErr_Occurred()) {
06681	            PyErr_SetString(PyExc_RuntimeError,
06682	                "Unexpected error in an Op's C code. "
06683	                "No Python exception was set.");
06684	            }
06685	        goto __label_74;}
06686	            }
06687	            // We expect NPY_FLOAT64
06688	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V73)) {
06689	                PyArrayObject * tmp = (PyArrayObject*) py_V73;
06690	                PyErr_Format(PyExc_NotImplementedError,
06691	                             "expected an aligned array of type %ld "
06692	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
06693	                             " with %ld dimensions, with 3 last dims "
06694	                             "%ld, %ld, %ld"
06695	                             " and 3 last strides %ld %ld, %ld.",
06696	                             (long int) NPY_FLOAT64,
06697	                             (long int) PyArray_TYPE((PyArrayObject*) py_V73),
06698	                             (long int) PyArray_NDIM(tmp),
06699	                             (long int) PyArray_NDIM(tmp) >= 3 ?
06700	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
06701	                             (long int) PyArray_NDIM(tmp) >= 2 ?
06702	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
06703	                             (long int) PyArray_NDIM(tmp) >= 1 ?
06704	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
06705	                             (long int) PyArray_NDIM(tmp) >= 3 ?
06706	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
06707	                             (long int) PyArray_NDIM(tmp) >= 2 ?
06708	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
06709	                             (long int) PyArray_NDIM(tmp) >= 1 ?
06710	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
06711	            );
06712	                {
06713	        __failure = 74;
06714	        if (!PyErr_Occurred()) {
06715	            PyErr_SetString(PyExc_RuntimeError,
06716	                "Unexpected error in an Op's C code. "
06717	                "No Python exception was set.");
06718	            }
06719	        goto __label_74;}
06720	            }
06721	            // This is a TypeError to be consistent with DEBUG_MODE
06722	            // Note: DEBUG_MODE also tells the name of the container
06723	            if (PyArray_TYPE((PyArrayObject*) py_V73) != NPY_FLOAT64) {
06724	                PyErr_Format(PyExc_TypeError,
06725	                             "expected type_num %d (NPY_FLOAT64) got %d",
06726	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V73));
06727	                {
06728	        __failure = 74;
06729	        if (!PyErr_Occurred()) {
06730	            PyErr_SetString(PyExc_RuntimeError,
06731	                "Unexpected error in an Op's C code. "
06732	                "No Python exception was set.");
06733	            }
06734	        goto __label_74;}
06735	            }
06736
06737	        V73 = (PyArrayObject*)(py_V73);
06738	        Py_XINCREF(V73);
06739
06740	{
06741
06742	    py_V75 = PyList_GET_ITEM(storage_V75, 0);
06743	    {Py_XINCREF(py_V75);}
06744
06745	            V75 = NULL;
06746	            if (py_V75 == Py_None) {
06747	                // We can either fail here or set V75 to NULL and rely on Ops
06748	                // using tensors to handle the NULL case, but if they fail to do so
06749	                // they'll end up with nasty segfaults, so this is public service.
06750	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
06751	                {
06752	        __failure = 76;
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_76;}
06759	            }
06760	            if (!PyArray_Check(py_V75)) {
06761	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
06762	                {
06763	        __failure = 76;
06764	        if (!PyErr_Occurred()) {
06765	            PyErr_SetString(PyExc_RuntimeError,
06766	                "Unexpected error in an Op's C code. "
06767	                "No Python exception was set.");
06768	            }
06769	        goto __label_76;}
06770	            }
06771	            // We expect NPY_FLOAT64
06772	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V75)) {
06773	                PyArrayObject * tmp = (PyArrayObject*) py_V75;
06774	                PyErr_Format(PyExc_NotImplementedError,
06775	                             "expected an aligned array of type %ld "
06776	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
06777	                             " with %ld dimensions, with 3 last dims "
06778	                             "%ld, %ld, %ld"
06779	                             " and 3 last strides %ld %ld, %ld.",
06780	                             (long int) NPY_FLOAT64,
06781	                             (long int) PyArray_TYPE((PyArrayObject*) py_V75),
06782	                             (long int) PyArray_NDIM(tmp),
06783	                             (long int) PyArray_NDIM(tmp) >= 3 ?
06784	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
06785	                             (long int) PyArray_NDIM(tmp) >= 2 ?
06786	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
06787	                             (long int) PyArray_NDIM(tmp) >= 1 ?
06788	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
06789	                             (long int) PyArray_NDIM(tmp) >= 3 ?
06790	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
06791	                             (long int) PyArray_NDIM(tmp) >= 2 ?
06792	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
06793	                             (long int) PyArray_NDIM(tmp) >= 1 ?
06794	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
06795	            );
06796	                {
06797	        __failure = 76;
06798	        if (!PyErr_Occurred()) {
06799	            PyErr_SetString(PyExc_RuntimeError,
06800	                "Unexpected error in an Op's C code. "
06801	                "No Python exception was set.");
06802	            }
06803	        goto __label_76;}
06804	            }
06805	            // This is a TypeError to be consistent with DEBUG_MODE
06806	            // Note: DEBUG_MODE also tells the name of the container
06807	            if (PyArray_TYPE((PyArrayObject*) py_V75) != NPY_FLOAT64) {
06808	                PyErr_Format(PyExc_TypeError,
06809	                             "expected type_num %d (NPY_FLOAT64) got %d",
06810	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V75));
06811	                {
06812	        __failure = 76;
06813	        if (!PyErr_Occurred()) {
06814	            PyErr_SetString(PyExc_RuntimeError,
06815	                "Unexpected error in an Op's C code. "
06816	                "No Python exception was set.");
06817	            }
06818	        goto __label_76;}
06819	            }
06820
06821	        V75 = (PyArrayObject*)(py_V75);
06822	        Py_XINCREF(V75);
06823
06824	{
06825
06826	    py_V77 = PyList_GET_ITEM(storage_V77, 0);
06827	    {Py_XINCREF(py_V77);}
06828
06829	            V77 = NULL;
06830	            if (py_V77 == Py_None) {
06831	                // We can either fail here or set V77 to NULL and rely on Ops
06832	                // using tensors to handle the NULL case, but if they fail to do so
06833	                // they'll end up with nasty segfaults, so this is public service.
06834	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
06835	                {
06836	        __failure = 78;
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_78;}
06843	            }
06844	            if (!PyArray_Check(py_V77)) {
06845	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
06846	                {
06847	        __failure = 78;
06848	        if (!PyErr_Occurred()) {
06849	            PyErr_SetString(PyExc_RuntimeError,
06850	                "Unexpected error in an Op's C code. "
06851	                "No Python exception was set.");
06852	            }
06853	        goto __label_78;}
06854	            }
06855	            // We expect NPY_FLOAT64
06856	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V77)) {
06857	                PyArrayObject * tmp = (PyArrayObject*) py_V77;
06858	                PyErr_Format(PyExc_NotImplementedError,
06859	                             "expected an aligned array of type %ld "
06860	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
06861	                             " with %ld dimensions, with 3 last dims "
06862	                             "%ld, %ld, %ld"
06863	                             " and 3 last strides %ld %ld, %ld.",
06864	                             (long int) NPY_FLOAT64,
06865	                             (long int) PyArray_TYPE((PyArrayObject*) py_V77),
06866	                             (long int) PyArray_NDIM(tmp),
06867	                             (long int) PyArray_NDIM(tmp) >= 3 ?
06868	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
06869	                             (long int) PyArray_NDIM(tmp) >= 2 ?
06870	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
06871	                             (long int) PyArray_NDIM(tmp) >= 1 ?
06872	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
06873	                             (long int) PyArray_NDIM(tmp) >= 3 ?
06874	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
06875	                             (long int) PyArray_NDIM(tmp) >= 2 ?
06876	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
06877	                             (long int) PyArray_NDIM(tmp) >= 1 ?
06878	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
06879	            );
06880	                {
06881	        __failure = 78;
06882	        if (!PyErr_Occurred()) {
06883	            PyErr_SetString(PyExc_RuntimeError,
06884	                "Unexpected error in an Op's C code. "
06885	                "No Python exception was set.");
06886	            }
06887	        goto __label_78;}
06888	            }
06889	            // This is a TypeError to be consistent with DEBUG_MODE
06890	            // Note: DEBUG_MODE also tells the name of the container
06891	            if (PyArray_TYPE((PyArrayObject*) py_V77) != NPY_FLOAT64) {
06892	                PyErr_Format(PyExc_TypeError,
06893	                             "expected type_num %d (NPY_FLOAT64) got %d",
06894	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V77));
06895	                {
06896	        __failure = 78;
06897	        if (!PyErr_Occurred()) {
06898	            PyErr_SetString(PyExc_RuntimeError,
06899	                "Unexpected error in an Op's C code. "
06900	                "No Python exception was set.");
06901	            }
06902	        goto __label_78;}
06903	            }
06904
06905	        V77 = (PyArrayObject*)(py_V77);
06906	        Py_XINCREF(V77);
06907
06908	{
06909
06910	    py_V79 = PyList_GET_ITEM(storage_V79, 0);
06911	    {Py_XINCREF(py_V79);}
06912
06913	            V79 = NULL;
06914	            if (py_V79 == Py_None) {
06915	                // We can either fail here or set V79 to NULL and rely on Ops
06916	                // using tensors to handle the NULL case, but if they fail to do so
06917	                // they'll end up with nasty segfaults, so this is public service.
06918	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
06919	                {
06920	        __failure = 80;
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_80;}
06927	            }
06928	            if (!PyArray_Check(py_V79)) {
06929	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
06930	                {
06931	        __failure = 80;
06932	        if (!PyErr_Occurred()) {
06933	            PyErr_SetString(PyExc_RuntimeError,
06934	                "Unexpected error in an Op's C code. "
06935	                "No Python exception was set.");
06936	            }
06937	        goto __label_80;}
06938	            }
06939	            // We expect NPY_FLOAT64
06940	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V79)) {
06941	                PyArrayObject * tmp = (PyArrayObject*) py_V79;
06942	                PyErr_Format(PyExc_NotImplementedError,
06943	                             "expected an aligned array of type %ld "
06944	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
06945	                             " with %ld dimensions, with 3 last dims "
06946	                             "%ld, %ld, %ld"
06947	                             " and 3 last strides %ld %ld, %ld.",
06948	                             (long int) NPY_FLOAT64,
06949	                             (long int) PyArray_TYPE((PyArrayObject*) py_V79),
06950	                             (long int) PyArray_NDIM(tmp),
06951	                             (long int) PyArray_NDIM(tmp) >= 3 ?
06952	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
06953	                             (long int) PyArray_NDIM(tmp) >= 2 ?
06954	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
06955	                             (long int) PyArray_NDIM(tmp) >= 1 ?
06956	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
06957	                             (long int) PyArray_NDIM(tmp) >= 3 ?
06958	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
06959	                             (long int) PyArray_NDIM(tmp) >= 2 ?
06960	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
06961	                             (long int) PyArray_NDIM(tmp) >= 1 ?
06962	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
06963	            );
06964	                {
06965	        __failure = 80;
06966	        if (!PyErr_Occurred()) {
06967	            PyErr_SetString(PyExc_RuntimeError,
06968	                "Unexpected error in an Op's C code. "
06969	                "No Python exception was set.");
06970	            }
06971	        goto __label_80;}
06972	            }
06973	            // This is a TypeError to be consistent with DEBUG_MODE
06974	            // Note: DEBUG_MODE also tells the name of the container
06975	            if (PyArray_TYPE((PyArrayObject*) py_V79) != NPY_FLOAT64) {
06976	                PyErr_Format(PyExc_TypeError,
06977	                             "expected type_num %d (NPY_FLOAT64) got %d",
06978	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V79));
06979	                {
06980	        __failure = 80;
06981	        if (!PyErr_Occurred()) {
06982	            PyErr_SetString(PyExc_RuntimeError,
06983	                "Unexpected error in an Op's C code. "
06984	                "No Python exception was set.");
06985	            }
06986	        goto __label_80;}
06987	            }
06988
06989	        V79 = (PyArrayObject*)(py_V79);
06990	        Py_XINCREF(V79);
06991
06992	{
06993
06994	    py_V81 = PyList_GET_ITEM(storage_V81, 0);
06995	    {Py_XINCREF(py_V81);}
06996
06997	            V81 = NULL;
06998	            if (py_V81 == Py_None) {
06999	                // We can either fail here or set V81 to NULL and rely on Ops
07000	                // using tensors to handle the NULL case, but if they fail to do so
07001	                // they'll end up with nasty segfaults, so this is public service.
07002	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
07003	                {
07004	        __failure = 82;
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_82;}
07011	            }
07012	            if (!PyArray_Check(py_V81)) {
07013	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
07014	                {
07015	        __failure = 82;
07016	        if (!PyErr_Occurred()) {
07017	            PyErr_SetString(PyExc_RuntimeError,
07018	                "Unexpected error in an Op's C code. "
07019	                "No Python exception was set.");
07020	            }
07021	        goto __label_82;}
07022	            }
07023	            // We expect NPY_FLOAT64
07024	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V81)) {
07025	                PyArrayObject * tmp = (PyArrayObject*) py_V81;
07026	                PyErr_Format(PyExc_NotImplementedError,
07027	                             "expected an aligned array of type %ld "
07028	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
07029	                             " with %ld dimensions, with 3 last dims "
07030	                             "%ld, %ld, %ld"
07031	                             " and 3 last strides %ld %ld, %ld.",
07032	                             (long int) NPY_FLOAT64,
07033	                             (long int) PyArray_TYPE((PyArrayObject*) py_V81),
07034	                             (long int) PyArray_NDIM(tmp),
07035	                             (long int) PyArray_NDIM(tmp) >= 3 ?
07036	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
07037	                             (long int) PyArray_NDIM(tmp) >= 2 ?
07038	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
07039	                             (long int) PyArray_NDIM(tmp) >= 1 ?
07040	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
07041	                             (long int) PyArray_NDIM(tmp) >= 3 ?
07042	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
07043	                             (long int) PyArray_NDIM(tmp) >= 2 ?
07044	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
07045	                             (long int) PyArray_NDIM(tmp) >= 1 ?
07046	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
07047	            );
07048	                {
07049	        __failure = 82;
07050	        if (!PyErr_Occurred()) {
07051	            PyErr_SetString(PyExc_RuntimeError,
07052	                "Unexpected error in an Op's C code. "
07053	                "No Python exception was set.");
07054	            }
07055	        goto __label_82;}
07056	            }
07057	            // This is a TypeError to be consistent with DEBUG_MODE
07058	            // Note: DEBUG_MODE also tells the name of the container
07059	            if (PyArray_TYPE((PyArrayObject*) py_V81) != NPY_FLOAT64) {
07060	                PyErr_Format(PyExc_TypeError,
07061	                             "expected type_num %d (NPY_FLOAT64) got %d",
07062	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V81));
07063	                {
07064	        __failure = 82;
07065	        if (!PyErr_Occurred()) {
07066	            PyErr_SetString(PyExc_RuntimeError,
07067	                "Unexpected error in an Op's C code. "
07068	                "No Python exception was set.");
07069	            }
07070	        goto __label_82;}
07071	            }
07072
07073	        V81 = (PyArrayObject*)(py_V81);
07074	        Py_XINCREF(V81);
07075
07076	{
07077
07078	    py_V83 = PyList_GET_ITEM(storage_V83, 0);
07079	    {Py_XINCREF(py_V83);}
07080
07081	            V83 = NULL;
07082	            if (py_V83 == Py_None) {
07083	                // We can either fail here or set V83 to NULL and rely on Ops
07084	                // using tensors to handle the NULL case, but if they fail to do so
07085	                // they'll end up with nasty segfaults, so this is public service.
07086	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
07087	                {
07088	        __failure = 84;
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_84;}
07095	            }
07096	            if (!PyArray_Check(py_V83)) {
07097	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
07098	                {
07099	        __failure = 84;
07100	        if (!PyErr_Occurred()) {
07101	            PyErr_SetString(PyExc_RuntimeError,
07102	                "Unexpected error in an Op's C code. "
07103	                "No Python exception was set.");
07104	            }
07105	        goto __label_84;}
07106	            }
07107	            // We expect NPY_INT8
07108	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V83)) {
07109	                PyArrayObject * tmp = (PyArrayObject*) py_V83;
07110	                PyErr_Format(PyExc_NotImplementedError,
07111	                             "expected an aligned array of type %ld "
07112	                             "(NPY_INT8), got non-aligned array of type %ld"
07113	                             " with %ld dimensions, with 3 last dims "
07114	                             "%ld, %ld, %ld"
07115	                             " and 3 last strides %ld %ld, %ld.",
07116	                             (long int) NPY_INT8,
07117	                             (long int) PyArray_TYPE((PyArrayObject*) py_V83),
07118	                             (long int) PyArray_NDIM(tmp),
07119	                             (long int) PyArray_NDIM(tmp) >= 3 ?
07120	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
07121	                             (long int) PyArray_NDIM(tmp) >= 2 ?
07122	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
07123	                             (long int) PyArray_NDIM(tmp) >= 1 ?
07124	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
07125	                             (long int) PyArray_NDIM(tmp) >= 3 ?
07126	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
07127	                             (long int) PyArray_NDIM(tmp) >= 2 ?
07128	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
07129	                             (long int) PyArray_NDIM(tmp) >= 1 ?
07130	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
07131	            );
07132	                {
07133	        __failure = 84;
07134	        if (!PyErr_Occurred()) {
07135	            PyErr_SetString(PyExc_RuntimeError,
07136	                "Unexpected error in an Op's C code. "
07137	                "No Python exception was set.");
07138	            }
07139	        goto __label_84;}
07140	            }
07141	            // This is a TypeError to be consistent with DEBUG_MODE
07142	            // Note: DEBUG_MODE also tells the name of the container
07143	            if (PyArray_TYPE((PyArrayObject*) py_V83) != NPY_INT8) {
07144	                PyErr_Format(PyExc_TypeError,
07145	                             "expected type_num %d (NPY_INT8) got %d",
07146	                             NPY_INT8, PyArray_TYPE((PyArrayObject*) py_V83));
07147	                {
07148	        __failure = 84;
07149	        if (!PyErr_Occurred()) {
07150	            PyErr_SetString(PyExc_RuntimeError,
07151	                "Unexpected error in an Op's C code. "
07152	                "No Python exception was set.");
07153	            }
07154	        goto __label_84;}
07155	            }
07156
07157	        V83 = (PyArrayObject*)(py_V83);
07158	        Py_XINCREF(V83);
07159
07160	{
07161
07162	    py_V85 = PyList_GET_ITEM(storage_V85, 0);
07163	    {Py_XINCREF(py_V85);}
07164
07165	            V85 = NULL;
07166	            if (py_V85 == Py_None) {
07167	                // We can either fail here or set V85 to NULL and rely on Ops
07168	                // using tensors to handle the NULL case, but if they fail to do so
07169	                // they'll end up with nasty segfaults, so this is public service.
07170	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
07171	                {
07172	        __failure = 86;
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_86;}
07179	            }
07180	            if (!PyArray_Check(py_V85)) {
07181	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
07182	                {
07183	        __failure = 86;
07184	        if (!PyErr_Occurred()) {
07185	            PyErr_SetString(PyExc_RuntimeError,
07186	                "Unexpected error in an Op's C code. "
07187	                "No Python exception was set.");
07188	            }
07189	        goto __label_86;}
07190	            }
07191	            // We expect NPY_FLOAT64
07192	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V85)) {
07193	                PyArrayObject * tmp = (PyArrayObject*) py_V85;
07194	                PyErr_Format(PyExc_NotImplementedError,
07195	                             "expected an aligned array of type %ld "
07196	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
07197	                             " with %ld dimensions, with 3 last dims "
07198	                             "%ld, %ld, %ld"
07199	                             " and 3 last strides %ld %ld, %ld.",
07200	                             (long int) NPY_FLOAT64,
07201	                             (long int) PyArray_TYPE((PyArrayObject*) py_V85),
07202	                             (long int) PyArray_NDIM(tmp),
07203	                             (long int) PyArray_NDIM(tmp) >= 3 ?
07204	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
07205	                             (long int) PyArray_NDIM(tmp) >= 2 ?
07206	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
07207	                             (long int) PyArray_NDIM(tmp) >= 1 ?
07208	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
07209	                             (long int) PyArray_NDIM(tmp) >= 3 ?
07210	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
07211	                             (long int) PyArray_NDIM(tmp) >= 2 ?
07212	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
07213	                             (long int) PyArray_NDIM(tmp) >= 1 ?
07214	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
07215	            );
07216	                {
07217	        __failure = 86;
07218	        if (!PyErr_Occurred()) {
07219	            PyErr_SetString(PyExc_RuntimeError,
07220	                "Unexpected error in an Op's C code. "
07221	                "No Python exception was set.");
07222	            }
07223	        goto __label_86;}
07224	            }
07225	            // This is a TypeError to be consistent with DEBUG_MODE
07226	            // Note: DEBUG_MODE also tells the name of the container
07227	            if (PyArray_TYPE((PyArrayObject*) py_V85) != NPY_FLOAT64) {
07228	                PyErr_Format(PyExc_TypeError,
07229	                             "expected type_num %d (NPY_FLOAT64) got %d",
07230	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V85));
07231	                {
07232	        __failure = 86;
07233	        if (!PyErr_Occurred()) {
07234	            PyErr_SetString(PyExc_RuntimeError,
07235	                "Unexpected error in an Op's C code. "
07236	                "No Python exception was set.");
07237	            }
07238	        goto __label_86;}
07239	            }
07240
07241	        V85 = (PyArrayObject*)(py_V85);
07242	        Py_XINCREF(V85);
07243
07244	{
07245
07246	    py_V87 = PyList_GET_ITEM(storage_V87, 0);
07247	    {Py_XINCREF(py_V87);}
07248
07249	            V87 = NULL;
07250	            if (py_V87 == Py_None) {
07251	                // We can either fail here or set V87 to NULL and rely on Ops
07252	                // using tensors to handle the NULL case, but if they fail to do so
07253	                // they'll end up with nasty segfaults, so this is public service.
07254	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
07255	                {
07256	        __failure = 88;
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_88;}
07263	            }
07264	            if (!PyArray_Check(py_V87)) {
07265	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
07266	                {
07267	        __failure = 88;
07268	        if (!PyErr_Occurred()) {
07269	            PyErr_SetString(PyExc_RuntimeError,
07270	                "Unexpected error in an Op's C code. "
07271	                "No Python exception was set.");
07272	            }
07273	        goto __label_88;}
07274	            }
07275	            // We expect NPY_FLOAT64
07276	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V87)) {
07277	                PyArrayObject * tmp = (PyArrayObject*) py_V87;
07278	                PyErr_Format(PyExc_NotImplementedError,
07279	                             "expected an aligned array of type %ld "
07280	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
07281	                             " with %ld dimensions, with 3 last dims "
07282	                             "%ld, %ld, %ld"
07283	                             " and 3 last strides %ld %ld, %ld.",
07284	                             (long int) NPY_FLOAT64,
07285	                             (long int) PyArray_TYPE((PyArrayObject*) py_V87),
07286	                             (long int) PyArray_NDIM(tmp),
07287	                             (long int) PyArray_NDIM(tmp) >= 3 ?
07288	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
07289	                             (long int) PyArray_NDIM(tmp) >= 2 ?
07290	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
07291	                             (long int) PyArray_NDIM(tmp) >= 1 ?
07292	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
07293	                             (long int) PyArray_NDIM(tmp) >= 3 ?
07294	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
07295	                             (long int) PyArray_NDIM(tmp) >= 2 ?
07296	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
07297	                             (long int) PyArray_NDIM(tmp) >= 1 ?
07298	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
07299	            );
07300	                {
07301	        __failure = 88;
07302	        if (!PyErr_Occurred()) {
07303	            PyErr_SetString(PyExc_RuntimeError,
07304	                "Unexpected error in an Op's C code. "
07305	                "No Python exception was set.");
07306	            }
07307	        goto __label_88;}
07308	            }
07309	            // This is a TypeError to be consistent with DEBUG_MODE
07310	            // Note: DEBUG_MODE also tells the name of the container
07311	            if (PyArray_TYPE((PyArrayObject*) py_V87) != NPY_FLOAT64) {
07312	                PyErr_Format(PyExc_TypeError,
07313	                             "expected type_num %d (NPY_FLOAT64) got %d",
07314	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V87));
07315	                {
07316	        __failure = 88;
07317	        if (!PyErr_Occurred()) {
07318	            PyErr_SetString(PyExc_RuntimeError,
07319	                "Unexpected error in an Op's C code. "
07320	                "No Python exception was set.");
07321	            }
07322	        goto __label_88;}
07323	            }
07324
07325	        V87 = (PyArrayObject*)(py_V87);
07326	        Py_XINCREF(V87);
07327
07328	{
07329
07330	    py_V89 = PyList_GET_ITEM(storage_V89, 0);
07331	    {Py_XINCREF(py_V89);}
07332
07333	            V89 = NULL;
07334	            if (py_V89 == Py_None) {
07335	                // We can either fail here or set V89 to NULL and rely on Ops
07336	                // using tensors to handle the NULL case, but if they fail to do so
07337	                // they'll end up with nasty segfaults, so this is public service.
07338	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
07339	                {
07340	        __failure = 90;
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_90;}
07347	            }
07348	            if (!PyArray_Check(py_V89)) {
07349	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
07350	                {
07351	        __failure = 90;
07352	        if (!PyErr_Occurred()) {
07353	            PyErr_SetString(PyExc_RuntimeError,
07354	                "Unexpected error in an Op's C code. "
07355	                "No Python exception was set.");
07356	            }
07357	        goto __label_90;}
07358	            }
07359	            // We expect NPY_FLOAT64
07360	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V89)) {
07361	                PyArrayObject * tmp = (PyArrayObject*) py_V89;
07362	                PyErr_Format(PyExc_NotImplementedError,
07363	                             "expected an aligned array of type %ld "
07364	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
07365	                             " with %ld dimensions, with 3 last dims "
07366	                             "%ld, %ld, %ld"
07367	                             " and 3 last strides %ld %ld, %ld.",
07368	                             (long int) NPY_FLOAT64,
07369	                             (long int) PyArray_TYPE((PyArrayObject*) py_V89),
07370	                             (long int) PyArray_NDIM(tmp),
07371	                             (long int) PyArray_NDIM(tmp) >= 3 ?
07372	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
07373	                             (long int) PyArray_NDIM(tmp) >= 2 ?
07374	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
07375	                             (long int) PyArray_NDIM(tmp) >= 1 ?
07376	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
07377	                             (long int) PyArray_NDIM(tmp) >= 3 ?
07378	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
07379	                             (long int) PyArray_NDIM(tmp) >= 2 ?
07380	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
07381	                             (long int) PyArray_NDIM(tmp) >= 1 ?
07382	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
07383	            );
07384	                {
07385	        __failure = 90;
07386	        if (!PyErr_Occurred()) {
07387	            PyErr_SetString(PyExc_RuntimeError,
07388	                "Unexpected error in an Op's C code. "
07389	                "No Python exception was set.");
07390	            }
07391	        goto __label_90;}
07392	            }
07393	            // This is a TypeError to be consistent with DEBUG_MODE
07394	            // Note: DEBUG_MODE also tells the name of the container
07395	            if (PyArray_TYPE((PyArrayObject*) py_V89) != NPY_FLOAT64) {
07396	                PyErr_Format(PyExc_TypeError,
07397	                             "expected type_num %d (NPY_FLOAT64) got %d",
07398	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V89));
07399	                {
07400	        __failure = 90;
07401	        if (!PyErr_Occurred()) {
07402	            PyErr_SetString(PyExc_RuntimeError,
07403	                "Unexpected error in an Op's C code. "
07404	                "No Python exception was set.");
07405	            }
07406	        goto __label_90;}
07407	            }
07408
07409	        V89 = (PyArrayObject*)(py_V89);
07410	        Py_XINCREF(V89);
07411
07412	{
07413
07414	    py_V91 = PyList_GET_ITEM(storage_V91, 0);
07415	    {Py_XINCREF(py_V91);}
07416
07417	            V91 = NULL;
07418	            if (py_V91 == Py_None) {
07419	                // We can either fail here or set V91 to NULL and rely on Ops
07420	                // using tensors to handle the NULL case, but if they fail to do so
07421	                // they'll end up with nasty segfaults, so this is public service.
07422	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
07423	                {
07424	        __failure = 92;
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_92;}
07431	            }
07432	            if (!PyArray_Check(py_V91)) {
07433	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
07434	                {
07435	        __failure = 92;
07436	        if (!PyErr_Occurred()) {
07437	            PyErr_SetString(PyExc_RuntimeError,
07438	                "Unexpected error in an Op's C code. "
07439	                "No Python exception was set.");
07440	            }
07441	        goto __label_92;}
07442	            }
07443	            // We expect NPY_FLOAT64
07444	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V91)) {
07445	                PyArrayObject * tmp = (PyArrayObject*) py_V91;
07446	                PyErr_Format(PyExc_NotImplementedError,
07447	                             "expected an aligned array of type %ld "
07448	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
07449	                             " with %ld dimensions, with 3 last dims "
07450	                             "%ld, %ld, %ld"
07451	                             " and 3 last strides %ld %ld, %ld.",
07452	                             (long int) NPY_FLOAT64,
07453	                             (long int) PyArray_TYPE((PyArrayObject*) py_V91),
07454	                             (long int) PyArray_NDIM(tmp),
07455	                             (long int) PyArray_NDIM(tmp) >= 3 ?
07456	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
07457	                             (long int) PyArray_NDIM(tmp) >= 2 ?
07458	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
07459	                             (long int) PyArray_NDIM(tmp) >= 1 ?
07460	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
07461	                             (long int) PyArray_NDIM(tmp) >= 3 ?
07462	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
07463	                             (long int) PyArray_NDIM(tmp) >= 2 ?
07464	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
07465	                             (long int) PyArray_NDIM(tmp) >= 1 ?
07466	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
07467	            );
07468	                {
07469	        __failure = 92;
07470	        if (!PyErr_Occurred()) {
07471	            PyErr_SetString(PyExc_RuntimeError,
07472	                "Unexpected error in an Op's C code. "
07473	                "No Python exception was set.");
07474	            }
07475	        goto __label_92;}
07476	            }
07477	            // This is a TypeError to be consistent with DEBUG_MODE
07478	            // Note: DEBUG_MODE also tells the name of the container
07479	            if (PyArray_TYPE((PyArrayObject*) py_V91) != NPY_FLOAT64) {
07480	                PyErr_Format(PyExc_TypeError,
07481	                             "expected type_num %d (NPY_FLOAT64) got %d",
07482	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V91));
07483	                {
07484	        __failure = 92;
07485	        if (!PyErr_Occurred()) {
07486	            PyErr_SetString(PyExc_RuntimeError,
07487	                "Unexpected error in an Op's C code. "
07488	                "No Python exception was set.");
07489	            }
07490	        goto __label_92;}
07491	            }
07492
07493	        V91 = (PyArrayObject*)(py_V91);
07494	        Py_XINCREF(V91);
07495
07496	{
07497
07498	    py_V93 = PyList_GET_ITEM(storage_V93, 0);
07499	    {Py_XINCREF(py_V93);}
07500
07501	            V93 = NULL;
07502	            if (py_V93 == Py_None) {
07503	                // We can either fail here or set V93 to NULL and rely on Ops
07504	                // using tensors to handle the NULL case, but if they fail to do so
07505	                // they'll end up with nasty segfaults, so this is public service.
07506	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
07507	                {
07508	        __failure = 94;
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_94;}
07515	            }
07516	            if (!PyArray_Check(py_V93)) {
07517	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
07518	                {
07519	        __failure = 94;
07520	        if (!PyErr_Occurred()) {
07521	            PyErr_SetString(PyExc_RuntimeError,
07522	                "Unexpected error in an Op's C code. "
07523	                "No Python exception was set.");
07524	            }
07525	        goto __label_94;}
07526	            }
07527	            // We expect NPY_FLOAT64
07528	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V93)) {
07529	                PyArrayObject * tmp = (PyArrayObject*) py_V93;
07530	                PyErr_Format(PyExc_NotImplementedError,
07531	                             "expected an aligned array of type %ld "
07532	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
07533	                             " with %ld dimensions, with 3 last dims "
07534	                             "%ld, %ld, %ld"
07535	                             " and 3 last strides %ld %ld, %ld.",
07536	                             (long int) NPY_FLOAT64,
07537	                             (long int) PyArray_TYPE((PyArrayObject*) py_V93),
07538	                             (long int) PyArray_NDIM(tmp),
07539	                             (long int) PyArray_NDIM(tmp) >= 3 ?
07540	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
07541	                             (long int) PyArray_NDIM(tmp) >= 2 ?
07542	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
07543	                             (long int) PyArray_NDIM(tmp) >= 1 ?
07544	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
07545	                             (long int) PyArray_NDIM(tmp) >= 3 ?
07546	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
07547	                             (long int) PyArray_NDIM(tmp) >= 2 ?
07548	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
07549	                             (long int) PyArray_NDIM(tmp) >= 1 ?
07550	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
07551	            );
07552	                {
07553	        __failure = 94;
07554	        if (!PyErr_Occurred()) {
07555	            PyErr_SetString(PyExc_RuntimeError,
07556	                "Unexpected error in an Op's C code. "
07557	                "No Python exception was set.");
07558	            }
07559	        goto __label_94;}
07560	            }
07561	            // This is a TypeError to be consistent with DEBUG_MODE
07562	            // Note: DEBUG_MODE also tells the name of the container
07563	            if (PyArray_TYPE((PyArrayObject*) py_V93) != NPY_FLOAT64) {
07564	                PyErr_Format(PyExc_TypeError,
07565	                             "expected type_num %d (NPY_FLOAT64) got %d",
07566	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V93));
07567	                {
07568	        __failure = 94;
07569	        if (!PyErr_Occurred()) {
07570	            PyErr_SetString(PyExc_RuntimeError,
07571	                "Unexpected error in an Op's C code. "
07572	                "No Python exception was set.");
07573	            }
07574	        goto __label_94;}
07575	            }
07576
07577	        V93 = (PyArrayObject*)(py_V93);
07578	        Py_XINCREF(V93);
07579
07580	{
07581
07582	    py_V95 = PyList_GET_ITEM(storage_V95, 0);
07583	    {Py_XINCREF(py_V95);}
07584
07585	            V95 = NULL;
07586	            if (py_V95 == Py_None) {
07587	                // We can either fail here or set V95 to NULL and rely on Ops
07588	                // using tensors to handle the NULL case, but if they fail to do so
07589	                // they'll end up with nasty segfaults, so this is public service.
07590	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
07591	                {
07592	        __failure = 96;
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_96;}
07599	            }
07600	            if (!PyArray_Check(py_V95)) {
07601	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
07602	                {
07603	        __failure = 96;
07604	        if (!PyErr_Occurred()) {
07605	            PyErr_SetString(PyExc_RuntimeError,
07606	                "Unexpected error in an Op's C code. "
07607	                "No Python exception was set.");
07608	            }
07609	        goto __label_96;}
07610	            }
07611	            // We expect NPY_INT8
07612	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V95)) {
07613	                PyArrayObject * tmp = (PyArrayObject*) py_V95;
07614	                PyErr_Format(PyExc_NotImplementedError,
07615	                             "expected an aligned array of type %ld "
07616	                             "(NPY_INT8), got non-aligned array of type %ld"
07617	                             " with %ld dimensions, with 3 last dims "
07618	                             "%ld, %ld, %ld"
07619	                             " and 3 last strides %ld %ld, %ld.",
07620	                             (long int) NPY_INT8,
07621	                             (long int) PyArray_TYPE((PyArrayObject*) py_V95),
07622	                             (long int) PyArray_NDIM(tmp),
07623	                             (long int) PyArray_NDIM(tmp) >= 3 ?
07624	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
07625	                             (long int) PyArray_NDIM(tmp) >= 2 ?
07626	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
07627	                             (long int) PyArray_NDIM(tmp) >= 1 ?
07628	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
07629	                             (long int) PyArray_NDIM(tmp) >= 3 ?
07630	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
07631	                             (long int) PyArray_NDIM(tmp) >= 2 ?
07632	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
07633	                             (long int) PyArray_NDIM(tmp) >= 1 ?
07634	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
07635	            );
07636	                {
07637	        __failure = 96;
07638	        if (!PyErr_Occurred()) {
07639	            PyErr_SetString(PyExc_RuntimeError,
07640	                "Unexpected error in an Op's C code. "
07641	                "No Python exception was set.");
07642	            }
07643	        goto __label_96;}
07644	            }
07645	            // This is a TypeError to be consistent with DEBUG_MODE
07646	            // Note: DEBUG_MODE also tells the name of the container
07647	            if (PyArray_TYPE((PyArrayObject*) py_V95) != NPY_INT8) {
07648	                PyErr_Format(PyExc_TypeError,
07649	                             "expected type_num %d (NPY_INT8) got %d",
07650	                             NPY_INT8, PyArray_TYPE((PyArrayObject*) py_V95));
07651	                {
07652	        __failure = 96;
07653	        if (!PyErr_Occurred()) {
07654	            PyErr_SetString(PyExc_RuntimeError,
07655	                "Unexpected error in an Op's C code. "
07656	                "No Python exception was set.");
07657	            }
07658	        goto __label_96;}
07659	            }
07660
07661	        V95 = (PyArrayObject*)(py_V95);
07662	        Py_XINCREF(V95);
07663
07664	{
07665
07666	    py_V97 = PyList_GET_ITEM(storage_V97, 0);
07667	    {Py_XINCREF(py_V97);}
07668
07669	            V97 = NULL;
07670	            if (py_V97 == Py_None) {
07671	                // We can either fail here or set V97 to NULL and rely on Ops
07672	                // using tensors to handle the NULL case, but if they fail to do so
07673	                // they'll end up with nasty segfaults, so this is public service.
07674	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
07675	                {
07676	        __failure = 98;
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_98;}
07683	            }
07684	            if (!PyArray_Check(py_V97)) {
07685	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
07686	                {
07687	        __failure = 98;
07688	        if (!PyErr_Occurred()) {
07689	            PyErr_SetString(PyExc_RuntimeError,
07690	                "Unexpected error in an Op's C code. "
07691	                "No Python exception was set.");
07692	            }
07693	        goto __label_98;}
07694	            }
07695	            // We expect NPY_FLOAT64
07696	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V97)) {
07697	                PyArrayObject * tmp = (PyArrayObject*) py_V97;
07698	                PyErr_Format(PyExc_NotImplementedError,
07699	                             "expected an aligned array of type %ld "
07700	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
07701	                             " with %ld dimensions, with 3 last dims "
07702	                             "%ld, %ld, %ld"
07703	                             " and 3 last strides %ld %ld, %ld.",
07704	                             (long int) NPY_FLOAT64,
07705	                             (long int) PyArray_TYPE((PyArrayObject*) py_V97),
07706	                             (long int) PyArray_NDIM(tmp),
07707	                             (long int) PyArray_NDIM(tmp) >= 3 ?
07708	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
07709	                             (long int) PyArray_NDIM(tmp) >= 2 ?
07710	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
07711	                             (long int) PyArray_NDIM(tmp) >= 1 ?
07712	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
07713	                             (long int) PyArray_NDIM(tmp) >= 3 ?
07714	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
07715	                             (long int) PyArray_NDIM(tmp) >= 2 ?
07716	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
07717	                             (long int) PyArray_NDIM(tmp) >= 1 ?
07718	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
07719	            );
07720	                {
07721	        __failure = 98;
07722	        if (!PyErr_Occurred()) {
07723	            PyErr_SetString(PyExc_RuntimeError,
07724	                "Unexpected error in an Op's C code. "
07725	                "No Python exception was set.");
07726	            }
07727	        goto __label_98;}
07728	            }
07729	            // This is a TypeError to be consistent with DEBUG_MODE
07730	            // Note: DEBUG_MODE also tells the name of the container
07731	            if (PyArray_TYPE((PyArrayObject*) py_V97) != NPY_FLOAT64) {
07732	                PyErr_Format(PyExc_TypeError,
07733	                             "expected type_num %d (NPY_FLOAT64) got %d",
07734	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V97));
07735	                {
07736	        __failure = 98;
07737	        if (!PyErr_Occurred()) {
07738	            PyErr_SetString(PyExc_RuntimeError,
07739	                "Unexpected error in an Op's C code. "
07740	                "No Python exception was set.");
07741	            }
07742	        goto __label_98;}
07743	            }
07744
07745	        V97 = (PyArrayObject*)(py_V97);
07746	        Py_XINCREF(V97);
07747
07748	{
07749
07750	    py_V99 = PyList_GET_ITEM(storage_V99, 0);
07751	    {Py_XINCREF(py_V99);}
07752
07753	            V99 = NULL;
07754	            if (py_V99 == Py_None) {
07755	                // We can either fail here or set V99 to NULL and rely on Ops
07756	                // using tensors to handle the NULL case, but if they fail to do so
07757	                // they'll end up with nasty segfaults, so this is public service.
07758	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
07759	                {
07760	        __failure = 100;
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_100;}
07767	            }
07768	            if (!PyArray_Check(py_V99)) {
07769	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
07770	                {
07771	        __failure = 100;
07772	        if (!PyErr_Occurred()) {
07773	            PyErr_SetString(PyExc_RuntimeError,
07774	                "Unexpected error in an Op's C code. "
07775	                "No Python exception was set.");
07776	            }
07777	        goto __label_100;}
07778	            }
07779	            // We expect NPY_FLOAT64
07780	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V99)) {
07781	                PyArrayObject * tmp = (PyArrayObject*) py_V99;
07782	                PyErr_Format(PyExc_NotImplementedError,
07783	                             "expected an aligned array of type %ld "
07784	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
07785	                             " with %ld dimensions, with 3 last dims "
07786	                             "%ld, %ld, %ld"
07787	                             " and 3 last strides %ld %ld, %ld.",
07788	                             (long int) NPY_FLOAT64,
07789	                             (long int) PyArray_TYPE((PyArrayObject*) py_V99),
07790	                             (long int) PyArray_NDIM(tmp),
07791	                             (long int) PyArray_NDIM(tmp) >= 3 ?
07792	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
07793	                             (long int) PyArray_NDIM(tmp) >= 2 ?
07794	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
07795	                             (long int) PyArray_NDIM(tmp) >= 1 ?
07796	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
07797	                             (long int) PyArray_NDIM(tmp) >= 3 ?
07798	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
07799	                             (long int) PyArray_NDIM(tmp) >= 2 ?
07800	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
07801	                             (long int) PyArray_NDIM(tmp) >= 1 ?
07802	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
07803	            );
07804	                {
07805	        __failure = 100;
07806	        if (!PyErr_Occurred()) {
07807	            PyErr_SetString(PyExc_RuntimeError,
07808	                "Unexpected error in an Op's C code. "
07809	                "No Python exception was set.");
07810	            }
07811	        goto __label_100;}
07812	            }
07813	            // This is a TypeError to be consistent with DEBUG_MODE
07814	            // Note: DEBUG_MODE also tells the name of the container
07815	            if (PyArray_TYPE((PyArrayObject*) py_V99) != NPY_FLOAT64) {
07816	                PyErr_Format(PyExc_TypeError,
07817	                             "expected type_num %d (NPY_FLOAT64) got %d",
07818	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V99));
07819	                {
07820	        __failure = 100;
07821	        if (!PyErr_Occurred()) {
07822	            PyErr_SetString(PyExc_RuntimeError,
07823	                "Unexpected error in an Op's C code. "
07824	                "No Python exception was set.");
07825	            }
07826	        goto __label_100;}
07827	            }
07828
07829	        V99 = (PyArrayObject*)(py_V99);
07830	        Py_XINCREF(V99);
07831
07832	{
07833
07834	    py_V101 = PyList_GET_ITEM(storage_V101, 0);
07835	    {Py_XINCREF(py_V101);}
07836
07837	            V101 = NULL;
07838	            if (py_V101 == Py_None) {
07839	                // We can either fail here or set V101 to NULL and rely on Ops
07840	                // using tensors to handle the NULL case, but if they fail to do so
07841	                // they'll end up with nasty segfaults, so this is public service.
07842	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
07843	                {
07844	        __failure = 102;
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_102;}
07851	            }
07852	            if (!PyArray_Check(py_V101)) {
07853	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
07854	                {
07855	        __failure = 102;
07856	        if (!PyErr_Occurred()) {
07857	            PyErr_SetString(PyExc_RuntimeError,
07858	                "Unexpected error in an Op's C code. "
07859	                "No Python exception was set.");
07860	            }
07861	        goto __label_102;}
07862	            }
07863	            // We expect NPY_FLOAT64
07864	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V101)) {
07865	                PyArrayObject * tmp = (PyArrayObject*) py_V101;
07866	                PyErr_Format(PyExc_NotImplementedError,
07867	                             "expected an aligned array of type %ld "
07868	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
07869	                             " with %ld dimensions, with 3 last dims "
07870	                             "%ld, %ld, %ld"
07871	                             " and 3 last strides %ld %ld, %ld.",
07872	                             (long int) NPY_FLOAT64,
07873	                             (long int) PyArray_TYPE((PyArrayObject*) py_V101),
07874	                             (long int) PyArray_NDIM(tmp),
07875	                             (long int) PyArray_NDIM(tmp) >= 3 ?
07876	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
07877	                             (long int) PyArray_NDIM(tmp) >= 2 ?
07878	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
07879	                             (long int) PyArray_NDIM(tmp) >= 1 ?
07880	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
07881	                             (long int) PyArray_NDIM(tmp) >= 3 ?
07882	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
07883	                             (long int) PyArray_NDIM(tmp) >= 2 ?
07884	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
07885	                             (long int) PyArray_NDIM(tmp) >= 1 ?
07886	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
07887	            );
07888	                {
07889	        __failure = 102;
07890	        if (!PyErr_Occurred()) {
07891	            PyErr_SetString(PyExc_RuntimeError,
07892	                "Unexpected error in an Op's C code. "
07893	                "No Python exception was set.");
07894	            }
07895	        goto __label_102;}
07896	            }
07897	            // This is a TypeError to be consistent with DEBUG_MODE
07898	            // Note: DEBUG_MODE also tells the name of the container
07899	            if (PyArray_TYPE((PyArrayObject*) py_V101) != NPY_FLOAT64) {
07900	                PyErr_Format(PyExc_TypeError,
07901	                             "expected type_num %d (NPY_FLOAT64) got %d",
07902	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V101));
07903	                {
07904	        __failure = 102;
07905	        if (!PyErr_Occurred()) {
07906	            PyErr_SetString(PyExc_RuntimeError,
07907	                "Unexpected error in an Op's C code. "
07908	                "No Python exception was set.");
07909	            }
07910	        goto __label_102;}
07911	            }
07912
07913	        V101 = (PyArrayObject*)(py_V101);
07914	        Py_XINCREF(V101);
07915
07916	{
07917
07918	    py_V103 = PyList_GET_ITEM(storage_V103, 0);
07919	    {Py_XINCREF(py_V103);}
07920
07921	            V103 = NULL;
07922	            if (py_V103 == Py_None) {
07923	                // We can either fail here or set V103 to NULL and rely on Ops
07924	                // using tensors to handle the NULL case, but if they fail to do so
07925	                // they'll end up with nasty segfaults, so this is public service.
07926	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
07927	                {
07928	        __failure = 104;
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_104;}
07935	            }
07936	            if (!PyArray_Check(py_V103)) {
07937	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
07938	                {
07939	        __failure = 104;
07940	        if (!PyErr_Occurred()) {
07941	            PyErr_SetString(PyExc_RuntimeError,
07942	                "Unexpected error in an Op's C code. "
07943	                "No Python exception was set.");
07944	            }
07945	        goto __label_104;}
07946	            }
07947	            // We expect NPY_FLOAT64
07948	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V103)) {
07949	                PyArrayObject * tmp = (PyArrayObject*) py_V103;
07950	                PyErr_Format(PyExc_NotImplementedError,
07951	                             "expected an aligned array of type %ld "
07952	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
07953	                             " with %ld dimensions, with 3 last dims "
07954	                             "%ld, %ld, %ld"
07955	                             " and 3 last strides %ld %ld, %ld.",
07956	                             (long int) NPY_FLOAT64,
07957	                             (long int) PyArray_TYPE((PyArrayObject*) py_V103),
07958	                             (long int) PyArray_NDIM(tmp),
07959	                             (long int) PyArray_NDIM(tmp) >= 3 ?
07960	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
07961	                             (long int) PyArray_NDIM(tmp) >= 2 ?
07962	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
07963	                             (long int) PyArray_NDIM(tmp) >= 1 ?
07964	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
07965	                             (long int) PyArray_NDIM(tmp) >= 3 ?
07966	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
07967	                             (long int) PyArray_NDIM(tmp) >= 2 ?
07968	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
07969	                             (long int) PyArray_NDIM(tmp) >= 1 ?
07970	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
07971	            );
07972	                {
07973	        __failure = 104;
07974	        if (!PyErr_Occurred()) {
07975	            PyErr_SetString(PyExc_RuntimeError,
07976	                "Unexpected error in an Op's C code. "
07977	                "No Python exception was set.");
07978	            }
07979	        goto __label_104;}
07980	            }
07981	            // This is a TypeError to be consistent with DEBUG_MODE
07982	            // Note: DEBUG_MODE also tells the name of the container
07983	            if (PyArray_TYPE((PyArrayObject*) py_V103) != NPY_FLOAT64) {
07984	                PyErr_Format(PyExc_TypeError,
07985	                             "expected type_num %d (NPY_FLOAT64) got %d",
07986	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V103));
07987	                {
07988	        __failure = 104;
07989	        if (!PyErr_Occurred()) {
07990	            PyErr_SetString(PyExc_RuntimeError,
07991	                "Unexpected error in an Op's C code. "
07992	                "No Python exception was set.");
07993	            }
07994	        goto __label_104;}
07995	            }
07996
07997	        V103 = (PyArrayObject*)(py_V103);
07998	        Py_XINCREF(V103);
07999
08000	{
08001
08002	    py_V105 = PyList_GET_ITEM(storage_V105, 0);
08003	    {Py_XINCREF(py_V105);}
08004
08005	            V105 = NULL;
08006	            if (py_V105 == Py_None) {
08007	                // We can either fail here or set V105 to NULL and rely on Ops
08008	                // using tensors to handle the NULL case, but if they fail to do so
08009	                // they'll end up with nasty segfaults, so this is public service.
08010	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
08011	                {
08012	        __failure = 106;
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_106;}
08019	            }
08020	            if (!PyArray_Check(py_V105)) {
08021	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
08022	                {
08023	        __failure = 106;
08024	        if (!PyErr_Occurred()) {
08025	            PyErr_SetString(PyExc_RuntimeError,
08026	                "Unexpected error in an Op's C code. "
08027	                "No Python exception was set.");
08028	            }
08029	        goto __label_106;}
08030	            }
08031	            // We expect NPY_FLOAT64
08032	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V105)) {
08033	                PyArrayObject * tmp = (PyArrayObject*) py_V105;
08034	                PyErr_Format(PyExc_NotImplementedError,
08035	                             "expected an aligned array of type %ld "
08036	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
08037	                             " with %ld dimensions, with 3 last dims "
08038	                             "%ld, %ld, %ld"
08039	                             " and 3 last strides %ld %ld, %ld.",
08040	                             (long int) NPY_FLOAT64,
08041	                             (long int) PyArray_TYPE((PyArrayObject*) py_V105),
08042	                             (long int) PyArray_NDIM(tmp),
08043	                             (long int) PyArray_NDIM(tmp) >= 3 ?
08044	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
08045	                             (long int) PyArray_NDIM(tmp) >= 2 ?
08046	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
08047	                             (long int) PyArray_NDIM(tmp) >= 1 ?
08048	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
08049	                             (long int) PyArray_NDIM(tmp) >= 3 ?
08050	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
08051	                             (long int) PyArray_NDIM(tmp) >= 2 ?
08052	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
08053	                             (long int) PyArray_NDIM(tmp) >= 1 ?
08054	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
08055	            );
08056	                {
08057	        __failure = 106;
08058	        if (!PyErr_Occurred()) {
08059	            PyErr_SetString(PyExc_RuntimeError,
08060	                "Unexpected error in an Op's C code. "
08061	                "No Python exception was set.");
08062	            }
08063	        goto __label_106;}
08064	            }
08065	            // This is a TypeError to be consistent with DEBUG_MODE
08066	            // Note: DEBUG_MODE also tells the name of the container
08067	            if (PyArray_TYPE((PyArrayObject*) py_V105) != NPY_FLOAT64) {
08068	                PyErr_Format(PyExc_TypeError,
08069	                             "expected type_num %d (NPY_FLOAT64) got %d",
08070	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V105));
08071	                {
08072	        __failure = 106;
08073	        if (!PyErr_Occurred()) {
08074	            PyErr_SetString(PyExc_RuntimeError,
08075	                "Unexpected error in an Op's C code. "
08076	                "No Python exception was set.");
08077	            }
08078	        goto __label_106;}
08079	            }
08080
08081	        V105 = (PyArrayObject*)(py_V105);
08082	        Py_XINCREF(V105);
08083
08084	{
08085
08086	    py_V107 = PyList_GET_ITEM(storage_V107, 0);
08087	    {Py_XINCREF(py_V107);}
08088
08089	            V107 = NULL;
08090	            if (py_V107 == Py_None) {
08091	                // We can either fail here or set V107 to NULL and rely on Ops
08092	                // using tensors to handle the NULL case, but if they fail to do so
08093	                // they'll end up with nasty segfaults, so this is public service.
08094	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
08095	                {
08096	        __failure = 108;
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_108;}
08103	            }
08104	            if (!PyArray_Check(py_V107)) {
08105	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
08106	                {
08107	        __failure = 108;
08108	        if (!PyErr_Occurred()) {
08109	            PyErr_SetString(PyExc_RuntimeError,
08110	                "Unexpected error in an Op's C code. "
08111	                "No Python exception was set.");
08112	            }
08113	        goto __label_108;}
08114	            }
08115	            // We expect NPY_INT8
08116	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V107)) {
08117	                PyArrayObject * tmp = (PyArrayObject*) py_V107;
08118	                PyErr_Format(PyExc_NotImplementedError,
08119	                             "expected an aligned array of type %ld "
08120	                             "(NPY_INT8), got non-aligned array of type %ld"
08121	                             " with %ld dimensions, with 3 last dims "
08122	                             "%ld, %ld, %ld"
08123	                             " and 3 last strides %ld %ld, %ld.",
08124	                             (long int) NPY_INT8,
08125	                             (long int) PyArray_TYPE((PyArrayObject*) py_V107),
08126	                             (long int) PyArray_NDIM(tmp),
08127	                             (long int) PyArray_NDIM(tmp) >= 3 ?
08128	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
08129	                             (long int) PyArray_NDIM(tmp) >= 2 ?
08130	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
08131	                             (long int) PyArray_NDIM(tmp) >= 1 ?
08132	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
08133	                             (long int) PyArray_NDIM(tmp) >= 3 ?
08134	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
08135	                             (long int) PyArray_NDIM(tmp) >= 2 ?
08136	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
08137	                             (long int) PyArray_NDIM(tmp) >= 1 ?
08138	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
08139	            );
08140	                {
08141	        __failure = 108;
08142	        if (!PyErr_Occurred()) {
08143	            PyErr_SetString(PyExc_RuntimeError,
08144	                "Unexpected error in an Op's C code. "
08145	                "No Python exception was set.");
08146	            }
08147	        goto __label_108;}
08148	            }
08149	            // This is a TypeError to be consistent with DEBUG_MODE
08150	            // Note: DEBUG_MODE also tells the name of the container
08151	            if (PyArray_TYPE((PyArrayObject*) py_V107) != NPY_INT8) {
08152	                PyErr_Format(PyExc_TypeError,
08153	                             "expected type_num %d (NPY_INT8) got %d",
08154	                             NPY_INT8, PyArray_TYPE((PyArrayObject*) py_V107));
08155	                {
08156	        __failure = 108;
08157	        if (!PyErr_Occurred()) {
08158	            PyErr_SetString(PyExc_RuntimeError,
08159	                "Unexpected error in an Op's C code. "
08160	                "No Python exception was set.");
08161	            }
08162	        goto __label_108;}
08163	            }
08164
08165	        V107 = (PyArrayObject*)(py_V107);
08166	        Py_XINCREF(V107);
08167
08168	{
08169
08170	    py_V109 = PyList_GET_ITEM(storage_V109, 0);
08171	    {Py_XINCREF(py_V109);}
08172
08173	            V109 = NULL;
08174	            if (py_V109 == Py_None) {
08175	                // We can either fail here or set V109 to NULL and rely on Ops
08176	                // using tensors to handle the NULL case, but if they fail to do so
08177	                // they'll end up with nasty segfaults, so this is public service.
08178	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
08179	                {
08180	        __failure = 110;
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_110;}
08187	            }
08188	            if (!PyArray_Check(py_V109)) {
08189	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
08190	                {
08191	        __failure = 110;
08192	        if (!PyErr_Occurred()) {
08193	            PyErr_SetString(PyExc_RuntimeError,
08194	                "Unexpected error in an Op's C code. "
08195	                "No Python exception was set.");
08196	            }
08197	        goto __label_110;}
08198	            }
08199	            // We expect NPY_FLOAT64
08200	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V109)) {
08201	                PyArrayObject * tmp = (PyArrayObject*) py_V109;
08202	                PyErr_Format(PyExc_NotImplementedError,
08203	                             "expected an aligned array of type %ld "
08204	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
08205	                             " with %ld dimensions, with 3 last dims "
08206	                             "%ld, %ld, %ld"
08207	                             " and 3 last strides %ld %ld, %ld.",
08208	                             (long int) NPY_FLOAT64,
08209	                             (long int) PyArray_TYPE((PyArrayObject*) py_V109),
08210	                             (long int) PyArray_NDIM(tmp),
08211	                             (long int) PyArray_NDIM(tmp) >= 3 ?
08212	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
08213	                             (long int) PyArray_NDIM(tmp) >= 2 ?
08214	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
08215	                             (long int) PyArray_NDIM(tmp) >= 1 ?
08216	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
08217	                             (long int) PyArray_NDIM(tmp) >= 3 ?
08218	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
08219	                             (long int) PyArray_NDIM(tmp) >= 2 ?
08220	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
08221	                             (long int) PyArray_NDIM(tmp) >= 1 ?
08222	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
08223	            );
08224	                {
08225	        __failure = 110;
08226	        if (!PyErr_Occurred()) {
08227	            PyErr_SetString(PyExc_RuntimeError,
08228	                "Unexpected error in an Op's C code. "
08229	                "No Python exception was set.");
08230	            }
08231	        goto __label_110;}
08232	            }
08233	            // This is a TypeError to be consistent with DEBUG_MODE
08234	            // Note: DEBUG_MODE also tells the name of the container
08235	            if (PyArray_TYPE((PyArrayObject*) py_V109) != NPY_FLOAT64) {
08236	                PyErr_Format(PyExc_TypeError,
08237	                             "expected type_num %d (NPY_FLOAT64) got %d",
08238	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V109));
08239	                {
08240	        __failure = 110;
08241	        if (!PyErr_Occurred()) {
08242	            PyErr_SetString(PyExc_RuntimeError,
08243	                "Unexpected error in an Op's C code. "
08244	                "No Python exception was set.");
08245	            }
08246	        goto __label_110;}
08247	            }
08248
08249	        V109 = (PyArrayObject*)(py_V109);
08250	        Py_XINCREF(V109);
08251
08252	{
08253
08254	    py_V111 = PyList_GET_ITEM(storage_V111, 0);
08255	    {Py_XINCREF(py_V111);}
08256
08257	            V111 = NULL;
08258	            if (py_V111 == Py_None) {
08259	                // We can either fail here or set V111 to NULL and rely on Ops
08260	                // using tensors to handle the NULL case, but if they fail to do so
08261	                // they'll end up with nasty segfaults, so this is public service.
08262	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
08263	                {
08264	        __failure = 112;
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_112;}
08271	            }
08272	            if (!PyArray_Check(py_V111)) {
08273	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
08274	                {
08275	        __failure = 112;
08276	        if (!PyErr_Occurred()) {
08277	            PyErr_SetString(PyExc_RuntimeError,
08278	                "Unexpected error in an Op's C code. "
08279	                "No Python exception was set.");
08280	            }
08281	        goto __label_112;}
08282	            }
08283	            // We expect NPY_FLOAT64
08284	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V111)) {
08285	                PyArrayObject * tmp = (PyArrayObject*) py_V111;
08286	                PyErr_Format(PyExc_NotImplementedError,
08287	                             "expected an aligned array of type %ld "
08288	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
08289	                             " with %ld dimensions, with 3 last dims "
08290	                             "%ld, %ld, %ld"
08291	                             " and 3 last strides %ld %ld, %ld.",
08292	                             (long int) NPY_FLOAT64,
08293	                             (long int) PyArray_TYPE((PyArrayObject*) py_V111),
08294	                             (long int) PyArray_NDIM(tmp),
08295	                             (long int) PyArray_NDIM(tmp) >= 3 ?
08296	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
08297	                             (long int) PyArray_NDIM(tmp) >= 2 ?
08298	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
08299	                             (long int) PyArray_NDIM(tmp) >= 1 ?
08300	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
08301	                             (long int) PyArray_NDIM(tmp) >= 3 ?
08302	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
08303	                             (long int) PyArray_NDIM(tmp) >= 2 ?
08304	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
08305	                             (long int) PyArray_NDIM(tmp) >= 1 ?
08306	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
08307	            );
08308	                {
08309	        __failure = 112;
08310	        if (!PyErr_Occurred()) {
08311	            PyErr_SetString(PyExc_RuntimeError,
08312	                "Unexpected error in an Op's C code. "
08313	                "No Python exception was set.");
08314	            }
08315	        goto __label_112;}
08316	            }
08317	            // This is a TypeError to be consistent with DEBUG_MODE
08318	            // Note: DEBUG_MODE also tells the name of the container
08319	            if (PyArray_TYPE((PyArrayObject*) py_V111) != NPY_FLOAT64) {
08320	                PyErr_Format(PyExc_TypeError,
08321	                             "expected type_num %d (NPY_FLOAT64) got %d",
08322	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V111));
08323	                {
08324	        __failure = 112;
08325	        if (!PyErr_Occurred()) {
08326	            PyErr_SetString(PyExc_RuntimeError,
08327	                "Unexpected error in an Op's C code. "
08328	                "No Python exception was set.");
08329	            }
08330	        goto __label_112;}
08331	            }
08332
08333	        V111 = (PyArrayObject*)(py_V111);
08334	        Py_XINCREF(V111);
08335
08336	{
08337
08338	    py_V113 = PyList_GET_ITEM(storage_V113, 0);
08339	    {Py_XINCREF(py_V113);}
08340
08341	            V113 = NULL;
08342	            if (py_V113 == Py_None) {
08343	                // We can either fail here or set V113 to NULL and rely on Ops
08344	                // using tensors to handle the NULL case, but if they fail to do so
08345	                // they'll end up with nasty segfaults, so this is public service.
08346	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
08347	                {
08348	        __failure = 114;
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_114;}
08355	            }
08356	            if (!PyArray_Check(py_V113)) {
08357	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
08358	                {
08359	        __failure = 114;
08360	        if (!PyErr_Occurred()) {
08361	            PyErr_SetString(PyExc_RuntimeError,
08362	                "Unexpected error in an Op's C code. "
08363	                "No Python exception was set.");
08364	            }
08365	        goto __label_114;}
08366	            }
08367	            // We expect NPY_FLOAT64
08368	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V113)) {
08369	                PyArrayObject * tmp = (PyArrayObject*) py_V113;
08370	                PyErr_Format(PyExc_NotImplementedError,
08371	                             "expected an aligned array of type %ld "
08372	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
08373	                             " with %ld dimensions, with 3 last dims "
08374	                             "%ld, %ld, %ld"
08375	                             " and 3 last strides %ld %ld, %ld.",
08376	                             (long int) NPY_FLOAT64,
08377	                             (long int) PyArray_TYPE((PyArrayObject*) py_V113),
08378	                             (long int) PyArray_NDIM(tmp),
08379	                             (long int) PyArray_NDIM(tmp) >= 3 ?
08380	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
08381	                             (long int) PyArray_NDIM(tmp) >= 2 ?
08382	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
08383	                             (long int) PyArray_NDIM(tmp) >= 1 ?
08384	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
08385	                             (long int) PyArray_NDIM(tmp) >= 3 ?
08386	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
08387	                             (long int) PyArray_NDIM(tmp) >= 2 ?
08388	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
08389	                             (long int) PyArray_NDIM(tmp) >= 1 ?
08390	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
08391	            );
08392	                {
08393	        __failure = 114;
08394	        if (!PyErr_Occurred()) {
08395	            PyErr_SetString(PyExc_RuntimeError,
08396	                "Unexpected error in an Op's C code. "
08397	                "No Python exception was set.");
08398	            }
08399	        goto __label_114;}
08400	            }
08401	            // This is a TypeError to be consistent with DEBUG_MODE
08402	            // Note: DEBUG_MODE also tells the name of the container
08403	            if (PyArray_TYPE((PyArrayObject*) py_V113) != NPY_FLOAT64) {
08404	                PyErr_Format(PyExc_TypeError,
08405	                             "expected type_num %d (NPY_FLOAT64) got %d",
08406	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V113));
08407	                {
08408	        __failure = 114;
08409	        if (!PyErr_Occurred()) {
08410	            PyErr_SetString(PyExc_RuntimeError,
08411	                "Unexpected error in an Op's C code. "
08412	                "No Python exception was set.");
08413	            }
08414	        goto __label_114;}
08415	            }
08416
08417	        V113 = (PyArrayObject*)(py_V113);
08418	        Py_XINCREF(V113);
08419
08420	{
08421
08422	    py_V115 = PyList_GET_ITEM(storage_V115, 0);
08423	    {Py_XINCREF(py_V115);}
08424
08425	            V115 = NULL;
08426	            if (py_V115 == Py_None) {
08427	                // We can either fail here or set V115 to NULL and rely on Ops
08428	                // using tensors to handle the NULL case, but if they fail to do so
08429	                // they'll end up with nasty segfaults, so this is public service.
08430	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
08431	                {
08432	        __failure = 116;
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_116;}
08439	            }
08440	            if (!PyArray_Check(py_V115)) {
08441	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
08442	                {
08443	        __failure = 116;
08444	        if (!PyErr_Occurred()) {
08445	            PyErr_SetString(PyExc_RuntimeError,
08446	                "Unexpected error in an Op's C code. "
08447	                "No Python exception was set.");
08448	            }
08449	        goto __label_116;}
08450	            }
08451	            // We expect NPY_FLOAT64
08452	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V115)) {
08453	                PyArrayObject * tmp = (PyArrayObject*) py_V115;
08454	                PyErr_Format(PyExc_NotImplementedError,
08455	                             "expected an aligned array of type %ld "
08456	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
08457	                             " with %ld dimensions, with 3 last dims "
08458	                             "%ld, %ld, %ld"
08459	                             " and 3 last strides %ld %ld, %ld.",
08460	                             (long int) NPY_FLOAT64,
08461	                             (long int) PyArray_TYPE((PyArrayObject*) py_V115),
08462	                             (long int) PyArray_NDIM(tmp),
08463	                             (long int) PyArray_NDIM(tmp) >= 3 ?
08464	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
08465	                             (long int) PyArray_NDIM(tmp) >= 2 ?
08466	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
08467	                             (long int) PyArray_NDIM(tmp) >= 1 ?
08468	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
08469	                             (long int) PyArray_NDIM(tmp) >= 3 ?
08470	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
08471	                             (long int) PyArray_NDIM(tmp) >= 2 ?
08472	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
08473	                             (long int) PyArray_NDIM(tmp) >= 1 ?
08474	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
08475	            );
08476	                {
08477	        __failure = 116;
08478	        if (!PyErr_Occurred()) {
08479	            PyErr_SetString(PyExc_RuntimeError,
08480	                "Unexpected error in an Op's C code. "
08481	                "No Python exception was set.");
08482	            }
08483	        goto __label_116;}
08484	            }
08485	            // This is a TypeError to be consistent with DEBUG_MODE
08486	            // Note: DEBUG_MODE also tells the name of the container
08487	            if (PyArray_TYPE((PyArrayObject*) py_V115) != NPY_FLOAT64) {
08488	                PyErr_Format(PyExc_TypeError,
08489	                             "expected type_num %d (NPY_FLOAT64) got %d",
08490	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V115));
08491	                {
08492	        __failure = 116;
08493	        if (!PyErr_Occurred()) {
08494	            PyErr_SetString(PyExc_RuntimeError,
08495	                "Unexpected error in an Op's C code. "
08496	                "No Python exception was set.");
08497	            }
08498	        goto __label_116;}
08499	            }
08500
08501	        V115 = (PyArrayObject*)(py_V115);
08502	        Py_XINCREF(V115);
08503
08504	{
08505
08506	    py_V117 = PyList_GET_ITEM(storage_V117, 0);
08507	    {Py_XINCREF(py_V117);}
08508
08509	            V117 = NULL;
08510	            if (py_V117 == Py_None) {
08511	                // We can either fail here or set V117 to NULL and rely on Ops
08512	                // using tensors to handle the NULL case, but if they fail to do so
08513	                // they'll end up with nasty segfaults, so this is public service.
08514	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
08515	                {
08516	        __failure = 118;
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_118;}
08523	            }
08524	            if (!PyArray_Check(py_V117)) {
08525	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
08526	                {
08527	        __failure = 118;
08528	        if (!PyErr_Occurred()) {
08529	            PyErr_SetString(PyExc_RuntimeError,
08530	                "Unexpected error in an Op's C code. "
08531	                "No Python exception was set.");
08532	            }
08533	        goto __label_118;}
08534	            }
08535	            // We expect NPY_FLOAT64
08536	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V117)) {
08537	                PyArrayObject * tmp = (PyArrayObject*) py_V117;
08538	                PyErr_Format(PyExc_NotImplementedError,
08539	                             "expected an aligned array of type %ld "
08540	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
08541	                             " with %ld dimensions, with 3 last dims "
08542	                             "%ld, %ld, %ld"
08543	                             " and 3 last strides %ld %ld, %ld.",
08544	                             (long int) NPY_FLOAT64,
08545	                             (long int) PyArray_TYPE((PyArrayObject*) py_V117),
08546	                             (long int) PyArray_NDIM(tmp),
08547	                             (long int) PyArray_NDIM(tmp) >= 3 ?
08548	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
08549	                             (long int) PyArray_NDIM(tmp) >= 2 ?
08550	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
08551	                             (long int) PyArray_NDIM(tmp) >= 1 ?
08552	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
08553	                             (long int) PyArray_NDIM(tmp) >= 3 ?
08554	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
08555	                             (long int) PyArray_NDIM(tmp) >= 2 ?
08556	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
08557	                             (long int) PyArray_NDIM(tmp) >= 1 ?
08558	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
08559	            );
08560	                {
08561	        __failure = 118;
08562	        if (!PyErr_Occurred()) {
08563	            PyErr_SetString(PyExc_RuntimeError,
08564	                "Unexpected error in an Op's C code. "
08565	                "No Python exception was set.");
08566	            }
08567	        goto __label_118;}
08568	            }
08569	            // This is a TypeError to be consistent with DEBUG_MODE
08570	            // Note: DEBUG_MODE also tells the name of the container
08571	            if (PyArray_TYPE((PyArrayObject*) py_V117) != NPY_FLOAT64) {
08572	                PyErr_Format(PyExc_TypeError,
08573	                             "expected type_num %d (NPY_FLOAT64) got %d",
08574	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V117));
08575	                {
08576	        __failure = 118;
08577	        if (!PyErr_Occurred()) {
08578	            PyErr_SetString(PyExc_RuntimeError,
08579	                "Unexpected error in an Op's C code. "
08580	                "No Python exception was set.");
08581	            }
08582	        goto __label_118;}
08583	            }
08584
08585	        V117 = (PyArrayObject*)(py_V117);
08586	        Py_XINCREF(V117);
08587
08588	{
08589
08590	    py_V119 = PyList_GET_ITEM(storage_V119, 0);
08591	    {Py_XINCREF(py_V119);}
08592
08593	            V119 = NULL;
08594	            if (py_V119 == Py_None) {
08595	                // We can either fail here or set V119 to NULL and rely on Ops
08596	                // using tensors to handle the NULL case, but if they fail to do so
08597	                // they'll end up with nasty segfaults, so this is public service.
08598	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
08599	                {
08600	        __failure = 120;
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_120;}
08607	            }
08608	            if (!PyArray_Check(py_V119)) {
08609	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
08610	                {
08611	        __failure = 120;
08612	        if (!PyErr_Occurred()) {
08613	            PyErr_SetString(PyExc_RuntimeError,
08614	                "Unexpected error in an Op's C code. "
08615	                "No Python exception was set.");
08616	            }
08617	        goto __label_120;}
08618	            }
08619	            // We expect NPY_FLOAT64
08620	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V119)) {
08621	                PyArrayObject * tmp = (PyArrayObject*) py_V119;
08622	                PyErr_Format(PyExc_NotImplementedError,
08623	                             "expected an aligned array of type %ld "
08624	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
08625	                             " with %ld dimensions, with 3 last dims "
08626	                             "%ld, %ld, %ld"
08627	                             " and 3 last strides %ld %ld, %ld.",
08628	                             (long int) NPY_FLOAT64,
08629	                             (long int) PyArray_TYPE((PyArrayObject*) py_V119),
08630	                             (long int) PyArray_NDIM(tmp),
08631	                             (long int) PyArray_NDIM(tmp) >= 3 ?
08632	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
08633	                             (long int) PyArray_NDIM(tmp) >= 2 ?
08634	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
08635	                             (long int) PyArray_NDIM(tmp) >= 1 ?
08636	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
08637	                             (long int) PyArray_NDIM(tmp) >= 3 ?
08638	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
08639	                             (long int) PyArray_NDIM(tmp) >= 2 ?
08640	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
08641	                             (long int) PyArray_NDIM(tmp) >= 1 ?
08642	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
08643	            );
08644	                {
08645	        __failure = 120;
08646	        if (!PyErr_Occurred()) {
08647	            PyErr_SetString(PyExc_RuntimeError,
08648	                "Unexpected error in an Op's C code. "
08649	                "No Python exception was set.");
08650	            }
08651	        goto __label_120;}
08652	            }
08653	            // This is a TypeError to be consistent with DEBUG_MODE
08654	            // Note: DEBUG_MODE also tells the name of the container
08655	            if (PyArray_TYPE((PyArrayObject*) py_V119) != NPY_FLOAT64) {
08656	                PyErr_Format(PyExc_TypeError,
08657	                             "expected type_num %d (NPY_FLOAT64) got %d",
08658	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V119));
08659	                {
08660	        __failure = 120;
08661	        if (!PyErr_Occurred()) {
08662	            PyErr_SetString(PyExc_RuntimeError,
08663	                "Unexpected error in an Op's C code. "
08664	                "No Python exception was set.");
08665	            }
08666	        goto __label_120;}
08667	            }
08668
08669	        V119 = (PyArrayObject*)(py_V119);
08670	        Py_XINCREF(V119);
08671
08672	{
08673
08674	    py_V121 = PyList_GET_ITEM(storage_V121, 0);
08675	    {Py_XINCREF(py_V121);}
08676
08677	            V121 = NULL;
08678	            if (py_V121 == Py_None) {
08679	                // We can either fail here or set V121 to NULL and rely on Ops
08680	                // using tensors to handle the NULL case, but if they fail to do so
08681	                // they'll end up with nasty segfaults, so this is public service.
08682	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
08683	                {
08684	        __failure = 122;
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_122;}
08691	            }
08692	            if (!PyArray_Check(py_V121)) {
08693	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
08694	                {
08695	        __failure = 122;
08696	        if (!PyErr_Occurred()) {
08697	            PyErr_SetString(PyExc_RuntimeError,
08698	                "Unexpected error in an Op's C code. "
08699	                "No Python exception was set.");
08700	            }
08701	        goto __label_122;}
08702	            }
08703	            // We expect NPY_INT8
08704	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V121)) {
08705	                PyArrayObject * tmp = (PyArrayObject*) py_V121;
08706	                PyErr_Format(PyExc_NotImplementedError,
08707	                             "expected an aligned array of type %ld "
08708	                             "(NPY_INT8), got non-aligned array of type %ld"
08709	                             " with %ld dimensions, with 3 last dims "
08710	                             "%ld, %ld, %ld"
08711	                             " and 3 last strides %ld %ld, %ld.",
08712	                             (long int) NPY_INT8,
08713	                             (long int) PyArray_TYPE((PyArrayObject*) py_V121),
08714	                             (long int) PyArray_NDIM(tmp),
08715	                             (long int) PyArray_NDIM(tmp) >= 3 ?
08716	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
08717	                             (long int) PyArray_NDIM(tmp) >= 2 ?
08718	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
08719	                             (long int) PyArray_NDIM(tmp) >= 1 ?
08720	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
08721	                             (long int) PyArray_NDIM(tmp) >= 3 ?
08722	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
08723	                             (long int) PyArray_NDIM(tmp) >= 2 ?
08724	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
08725	                             (long int) PyArray_NDIM(tmp) >= 1 ?
08726	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
08727	            );
08728	                {
08729	        __failure = 122;
08730	        if (!PyErr_Occurred()) {
08731	            PyErr_SetString(PyExc_RuntimeError,
08732	                "Unexpected error in an Op's C code. "
08733	                "No Python exception was set.");
08734	            }
08735	        goto __label_122;}
08736	            }
08737	            // This is a TypeError to be consistent with DEBUG_MODE
08738	            // Note: DEBUG_MODE also tells the name of the container
08739	            if (PyArray_TYPE((PyArrayObject*) py_V121) != NPY_INT8) {
08740	                PyErr_Format(PyExc_TypeError,
08741	                             "expected type_num %d (NPY_INT8) got %d",
08742	                             NPY_INT8, PyArray_TYPE((PyArrayObject*) py_V121));
08743	                {
08744	        __failure = 122;
08745	        if (!PyErr_Occurred()) {
08746	            PyErr_SetString(PyExc_RuntimeError,
08747	                "Unexpected error in an Op's C code. "
08748	                "No Python exception was set.");
08749	            }
08750	        goto __label_122;}
08751	            }
08752
08753	        V121 = (PyArrayObject*)(py_V121);
08754	        Py_XINCREF(V121);
08755
08756	{
08757
08758	    py_V123 = PyList_GET_ITEM(storage_V123, 0);
08759	    {Py_XINCREF(py_V123);}
08760
08761	            V123 = NULL;
08762	            if (py_V123 == Py_None) {
08763	                // We can either fail here or set V123 to NULL and rely on Ops
08764	                // using tensors to handle the NULL case, but if they fail to do so
08765	                // they'll end up with nasty segfaults, so this is public service.
08766	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
08767	                {
08768	        __failure = 124;
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_124;}
08775	            }
08776	            if (!PyArray_Check(py_V123)) {
08777	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
08778	                {
08779	        __failure = 124;
08780	        if (!PyErr_Occurred()) {
08781	            PyErr_SetString(PyExc_RuntimeError,
08782	                "Unexpected error in an Op's C code. "
08783	                "No Python exception was set.");
08784	            }
08785	        goto __label_124;}
08786	            }
08787	            // We expect NPY_FLOAT64
08788	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V123)) {
08789	                PyArrayObject * tmp = (PyArrayObject*) py_V123;
08790	                PyErr_Format(PyExc_NotImplementedError,
08791	                             "expected an aligned array of type %ld "
08792	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
08793	                             " with %ld dimensions, with 3 last dims "
08794	                             "%ld, %ld, %ld"
08795	                             " and 3 last strides %ld %ld, %ld.",
08796	                             (long int) NPY_FLOAT64,
08797	                             (long int) PyArray_TYPE((PyArrayObject*) py_V123),
08798	                             (long int) PyArray_NDIM(tmp),
08799	                             (long int) PyArray_NDIM(tmp) >= 3 ?
08800	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
08801	                             (long int) PyArray_NDIM(tmp) >= 2 ?
08802	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
08803	                             (long int) PyArray_NDIM(tmp) >= 1 ?
08804	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
08805	                             (long int) PyArray_NDIM(tmp) >= 3 ?
08806	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
08807	                             (long int) PyArray_NDIM(tmp) >= 2 ?
08808	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
08809	                             (long int) PyArray_NDIM(tmp) >= 1 ?
08810	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
08811	            );
08812	                {
08813	        __failure = 124;
08814	        if (!PyErr_Occurred()) {
08815	            PyErr_SetString(PyExc_RuntimeError,
08816	                "Unexpected error in an Op's C code. "
08817	                "No Python exception was set.");
08818	            }
08819	        goto __label_124;}
08820	            }
08821	            // This is a TypeError to be consistent with DEBUG_MODE
08822	            // Note: DEBUG_MODE also tells the name of the container
08823	            if (PyArray_TYPE((PyArrayObject*) py_V123) != NPY_FLOAT64) {
08824	                PyErr_Format(PyExc_TypeError,
08825	                             "expected type_num %d (NPY_FLOAT64) got %d",
08826	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V123));
08827	                {
08828	        __failure = 124;
08829	        if (!PyErr_Occurred()) {
08830	            PyErr_SetString(PyExc_RuntimeError,
08831	                "Unexpected error in an Op's C code. "
08832	                "No Python exception was set.");
08833	            }
08834	        goto __label_124;}
08835	            }
08836
08837	        V123 = (PyArrayObject*)(py_V123);
08838	        Py_XINCREF(V123);
08839
08840	{
08841
08842	    py_V125 = PyList_GET_ITEM(storage_V125, 0);
08843	    {Py_XINCREF(py_V125);}
08844
08845	            V125 = NULL;
08846	            if (py_V125 == Py_None) {
08847	                // We can either fail here or set V125 to NULL and rely on Ops
08848	                // using tensors to handle the NULL case, but if they fail to do so
08849	                // they'll end up with nasty segfaults, so this is public service.
08850	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
08851	                {
08852	        __failure = 126;
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_126;}
08859	            }
08860	            if (!PyArray_Check(py_V125)) {
08861	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
08862	                {
08863	        __failure = 126;
08864	        if (!PyErr_Occurred()) {
08865	            PyErr_SetString(PyExc_RuntimeError,
08866	                "Unexpected error in an Op's C code. "
08867	                "No Python exception was set.");
08868	            }
08869	        goto __label_126;}
08870	            }
08871	            // We expect NPY_FLOAT64
08872	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V125)) {
08873	                PyArrayObject * tmp = (PyArrayObject*) py_V125;
08874	                PyErr_Format(PyExc_NotImplementedError,
08875	                             "expected an aligned array of type %ld "
08876	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
08877	                             " with %ld dimensions, with 3 last dims "
08878	                             "%ld, %ld, %ld"
08879	                             " and 3 last strides %ld %ld, %ld.",
08880	                             (long int) NPY_FLOAT64,
08881	                             (long int) PyArray_TYPE((PyArrayObject*) py_V125),
08882	                             (long int) PyArray_NDIM(tmp),
08883	                             (long int) PyArray_NDIM(tmp) >= 3 ?
08884	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
08885	                             (long int) PyArray_NDIM(tmp) >= 2 ?
08886	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
08887	                             (long int) PyArray_NDIM(tmp) >= 1 ?
08888	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
08889	                             (long int) PyArray_NDIM(tmp) >= 3 ?
08890	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
08891	                             (long int) PyArray_NDIM(tmp) >= 2 ?
08892	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
08893	                             (long int) PyArray_NDIM(tmp) >= 1 ?
08894	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
08895	            );
08896	                {
08897	        __failure = 126;
08898	        if (!PyErr_Occurred()) {
08899	            PyErr_SetString(PyExc_RuntimeError,
08900	                "Unexpected error in an Op's C code. "
08901	                "No Python exception was set.");
08902	            }
08903	        goto __label_126;}
08904	            }
08905	            // This is a TypeError to be consistent with DEBUG_MODE
08906	            // Note: DEBUG_MODE also tells the name of the container
08907	            if (PyArray_TYPE((PyArrayObject*) py_V125) != NPY_FLOAT64) {
08908	                PyErr_Format(PyExc_TypeError,
08909	                             "expected type_num %d (NPY_FLOAT64) got %d",
08910	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V125));
08911	                {
08912	        __failure = 126;
08913	        if (!PyErr_Occurred()) {
08914	            PyErr_SetString(PyExc_RuntimeError,
08915	                "Unexpected error in an Op's C code. "
08916	                "No Python exception was set.");
08917	            }
08918	        goto __label_126;}
08919	            }
08920
08921	        V125 = (PyArrayObject*)(py_V125);
08922	        Py_XINCREF(V125);
08923
08924	{
08925
08926	    py_V127 = PyList_GET_ITEM(storage_V127, 0);
08927	    {Py_XINCREF(py_V127);}
08928
08929	            V127 = NULL;
08930	            if (py_V127 == Py_None) {
08931	                // We can either fail here or set V127 to NULL and rely on Ops
08932	                // using tensors to handle the NULL case, but if they fail to do so
08933	                // they'll end up with nasty segfaults, so this is public service.
08934	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
08935	                {
08936	        __failure = 128;
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_128;}
08943	            }
08944	            if (!PyArray_Check(py_V127)) {
08945	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
08946	                {
08947	        __failure = 128;
08948	        if (!PyErr_Occurred()) {
08949	            PyErr_SetString(PyExc_RuntimeError,
08950	                "Unexpected error in an Op's C code. "
08951	                "No Python exception was set.");
08952	            }
08953	        goto __label_128;}
08954	            }
08955	            // We expect NPY_FLOAT64
08956	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V127)) {
08957	                PyArrayObject * tmp = (PyArrayObject*) py_V127;
08958	                PyErr_Format(PyExc_NotImplementedError,
08959	                             "expected an aligned array of type %ld "
08960	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
08961	                             " with %ld dimensions, with 3 last dims "
08962	                             "%ld, %ld, %ld"
08963	                             " and 3 last strides %ld %ld, %ld.",
08964	                             (long int) NPY_FLOAT64,
08965	                             (long int) PyArray_TYPE((PyArrayObject*) py_V127),
08966	                             (long int) PyArray_NDIM(tmp),
08967	                             (long int) PyArray_NDIM(tmp) >= 3 ?
08968	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
08969	                             (long int) PyArray_NDIM(tmp) >= 2 ?
08970	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
08971	                             (long int) PyArray_NDIM(tmp) >= 1 ?
08972	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
08973	                             (long int) PyArray_NDIM(tmp) >= 3 ?
08974	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
08975	                             (long int) PyArray_NDIM(tmp) >= 2 ?
08976	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
08977	                             (long int) PyArray_NDIM(tmp) >= 1 ?
08978	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
08979	            );
08980	                {
08981	        __failure = 128;
08982	        if (!PyErr_Occurred()) {
08983	            PyErr_SetString(PyExc_RuntimeError,
08984	                "Unexpected error in an Op's C code. "
08985	                "No Python exception was set.");
08986	            }
08987	        goto __label_128;}
08988	            }
08989	            // This is a TypeError to be consistent with DEBUG_MODE
08990	            // Note: DEBUG_MODE also tells the name of the container
08991	            if (PyArray_TYPE((PyArrayObject*) py_V127) != NPY_FLOAT64) {
08992	                PyErr_Format(PyExc_TypeError,
08993	                             "expected type_num %d (NPY_FLOAT64) got %d",
08994	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V127));
08995	                {
08996	        __failure = 128;
08997	        if (!PyErr_Occurred()) {
08998	            PyErr_SetString(PyExc_RuntimeError,
08999	                "Unexpected error in an Op's C code. "
09000	                "No Python exception was set.");
09001	            }
09002	        goto __label_128;}
09003	            }
09004
09005	        V127 = (PyArrayObject*)(py_V127);
09006	        Py_XINCREF(V127);
09007
09008	{
09009
09010	    py_V129 = PyList_GET_ITEM(storage_V129, 0);
09011	    {Py_XINCREF(py_V129);}
09012
09013	            V129 = NULL;
09014	            if (py_V129 == Py_None) {
09015	                // We can either fail here or set V129 to NULL and rely on Ops
09016	                // using tensors to handle the NULL case, but if they fail to do so
09017	                // they'll end up with nasty segfaults, so this is public service.
09018	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
09019	                {
09020	        __failure = 130;
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_130;}
09027	            }
09028	            if (!PyArray_Check(py_V129)) {
09029	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
09030	                {
09031	        __failure = 130;
09032	        if (!PyErr_Occurred()) {
09033	            PyErr_SetString(PyExc_RuntimeError,
09034	                "Unexpected error in an Op's C code. "
09035	                "No Python exception was set.");
09036	            }
09037	        goto __label_130;}
09038	            }
09039	            // We expect NPY_FLOAT64
09040	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V129)) {
09041	                PyArrayObject * tmp = (PyArrayObject*) py_V129;
09042	                PyErr_Format(PyExc_NotImplementedError,
09043	                             "expected an aligned array of type %ld "
09044	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
09045	                             " with %ld dimensions, with 3 last dims "
09046	                             "%ld, %ld, %ld"
09047	                             " and 3 last strides %ld %ld, %ld.",
09048	                             (long int) NPY_FLOAT64,
09049	                             (long int) PyArray_TYPE((PyArrayObject*) py_V129),
09050	                             (long int) PyArray_NDIM(tmp),
09051	                             (long int) PyArray_NDIM(tmp) >= 3 ?
09052	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
09053	                             (long int) PyArray_NDIM(tmp) >= 2 ?
09054	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
09055	                             (long int) PyArray_NDIM(tmp) >= 1 ?
09056	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
09057	                             (long int) PyArray_NDIM(tmp) >= 3 ?
09058	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
09059	                             (long int) PyArray_NDIM(tmp) >= 2 ?
09060	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
09061	                             (long int) PyArray_NDIM(tmp) >= 1 ?
09062	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
09063	            );
09064	                {
09065	        __failure = 130;
09066	        if (!PyErr_Occurred()) {
09067	            PyErr_SetString(PyExc_RuntimeError,
09068	                "Unexpected error in an Op's C code. "
09069	                "No Python exception was set.");
09070	            }
09071	        goto __label_130;}
09072	            }
09073	            // This is a TypeError to be consistent with DEBUG_MODE
09074	            // Note: DEBUG_MODE also tells the name of the container
09075	            if (PyArray_TYPE((PyArrayObject*) py_V129) != NPY_FLOAT64) {
09076	                PyErr_Format(PyExc_TypeError,
09077	                             "expected type_num %d (NPY_FLOAT64) got %d",
09078	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V129));
09079	                {
09080	        __failure = 130;
09081	        if (!PyErr_Occurred()) {
09082	            PyErr_SetString(PyExc_RuntimeError,
09083	                "Unexpected error in an Op's C code. "
09084	                "No Python exception was set.");
09085	            }
09086	        goto __label_130;}
09087	            }
09088
09089	        V129 = (PyArrayObject*)(py_V129);
09090	        Py_XINCREF(V129);
09091
09092	{
09093
09094	    py_V131 = PyList_GET_ITEM(storage_V131, 0);
09095	    {Py_XINCREF(py_V131);}
09096
09097	            V131 = NULL;
09098	            if (py_V131 == Py_None) {
09099	                // We can either fail here or set V131 to NULL and rely on Ops
09100	                // using tensors to handle the NULL case, but if they fail to do so
09101	                // they'll end up with nasty segfaults, so this is public service.
09102	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
09103	                {
09104	        __failure = 132;
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_132;}
09111	            }
09112	            if (!PyArray_Check(py_V131)) {
09113	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
09114	                {
09115	        __failure = 132;
09116	        if (!PyErr_Occurred()) {
09117	            PyErr_SetString(PyExc_RuntimeError,
09118	                "Unexpected error in an Op's C code. "
09119	                "No Python exception was set.");
09120	            }
09121	        goto __label_132;}
09122	            }
09123	            // We expect NPY_FLOAT64
09124	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V131)) {
09125	                PyArrayObject * tmp = (PyArrayObject*) py_V131;
09126	                PyErr_Format(PyExc_NotImplementedError,
09127	                             "expected an aligned array of type %ld "
09128	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
09129	                             " with %ld dimensions, with 3 last dims "
09130	                             "%ld, %ld, %ld"
09131	                             " and 3 last strides %ld %ld, %ld.",
09132	                             (long int) NPY_FLOAT64,
09133	                             (long int) PyArray_TYPE((PyArrayObject*) py_V131),
09134	                             (long int) PyArray_NDIM(tmp),
09135	                             (long int) PyArray_NDIM(tmp) >= 3 ?
09136	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
09137	                             (long int) PyArray_NDIM(tmp) >= 2 ?
09138	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
09139	                             (long int) PyArray_NDIM(tmp) >= 1 ?
09140	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
09141	                             (long int) PyArray_NDIM(tmp) >= 3 ?
09142	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
09143	                             (long int) PyArray_NDIM(tmp) >= 2 ?
09144	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
09145	                             (long int) PyArray_NDIM(tmp) >= 1 ?
09146	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
09147	            );
09148	                {
09149	        __failure = 132;
09150	        if (!PyErr_Occurred()) {
09151	            PyErr_SetString(PyExc_RuntimeError,
09152	                "Unexpected error in an Op's C code. "
09153	                "No Python exception was set.");
09154	            }
09155	        goto __label_132;}
09156	            }
09157	            // This is a TypeError to be consistent with DEBUG_MODE
09158	            // Note: DEBUG_MODE also tells the name of the container
09159	            if (PyArray_TYPE((PyArrayObject*) py_V131) != NPY_FLOAT64) {
09160	                PyErr_Format(PyExc_TypeError,
09161	                             "expected type_num %d (NPY_FLOAT64) got %d",
09162	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V131));
09163	                {
09164	        __failure = 132;
09165	        if (!PyErr_Occurred()) {
09166	            PyErr_SetString(PyExc_RuntimeError,
09167	                "Unexpected error in an Op's C code. "
09168	                "No Python exception was set.");
09169	            }
09170	        goto __label_132;}
09171	            }
09172
09173	        V131 = (PyArrayObject*)(py_V131);
09174	        Py_XINCREF(V131);
09175
09176	{
09177
09178	    py_V133 = PyList_GET_ITEM(storage_V133, 0);
09179	    {Py_XINCREF(py_V133);}
09180
09181	            V133 = NULL;
09182	            if (py_V133 == Py_None) {
09183	                // We can either fail here or set V133 to NULL and rely on Ops
09184	                // using tensors to handle the NULL case, but if they fail to do so
09185	                // they'll end up with nasty segfaults, so this is public service.
09186	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
09187	                {
09188	        __failure = 134;
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_134;}
09195	            }
09196	            if (!PyArray_Check(py_V133)) {
09197	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
09198	                {
09199	        __failure = 134;
09200	        if (!PyErr_Occurred()) {
09201	            PyErr_SetString(PyExc_RuntimeError,
09202	                "Unexpected error in an Op's C code. "
09203	                "No Python exception was set.");
09204	            }
09205	        goto __label_134;}
09206	            }
09207	            // We expect NPY_FLOAT64
09208	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V133)) {
09209	                PyArrayObject * tmp = (PyArrayObject*) py_V133;
09210	                PyErr_Format(PyExc_NotImplementedError,
09211	                             "expected an aligned array of type %ld "
09212	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
09213	                             " with %ld dimensions, with 3 last dims "
09214	                             "%ld, %ld, %ld"
09215	                             " and 3 last strides %ld %ld, %ld.",
09216	                             (long int) NPY_FLOAT64,
09217	                             (long int) PyArray_TYPE((PyArrayObject*) py_V133),
09218	                             (long int) PyArray_NDIM(tmp),
09219	                             (long int) PyArray_NDIM(tmp) >= 3 ?
09220	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
09221	                             (long int) PyArray_NDIM(tmp) >= 2 ?
09222	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
09223	                             (long int) PyArray_NDIM(tmp) >= 1 ?
09224	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
09225	                             (long int) PyArray_NDIM(tmp) >= 3 ?
09226	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
09227	                             (long int) PyArray_NDIM(tmp) >= 2 ?
09228	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
09229	                             (long int) PyArray_NDIM(tmp) >= 1 ?
09230	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
09231	            );
09232	                {
09233	        __failure = 134;
09234	        if (!PyErr_Occurred()) {
09235	            PyErr_SetString(PyExc_RuntimeError,
09236	                "Unexpected error in an Op's C code. "
09237	                "No Python exception was set.");
09238	            }
09239	        goto __label_134;}
09240	            }
09241	            // This is a TypeError to be consistent with DEBUG_MODE
09242	            // Note: DEBUG_MODE also tells the name of the container
09243	            if (PyArray_TYPE((PyArrayObject*) py_V133) != NPY_FLOAT64) {
09244	                PyErr_Format(PyExc_TypeError,
09245	                             "expected type_num %d (NPY_FLOAT64) got %d",
09246	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V133));
09247	                {
09248	        __failure = 134;
09249	        if (!PyErr_Occurred()) {
09250	            PyErr_SetString(PyExc_RuntimeError,
09251	                "Unexpected error in an Op's C code. "
09252	                "No Python exception was set.");
09253	            }
09254	        goto __label_134;}
09255	            }
09256
09257	        V133 = (PyArrayObject*)(py_V133);
09258	        Py_XINCREF(V133);
09259
09260	{
09261
09262	    py_V135 = PyList_GET_ITEM(storage_V135, 0);
09263	    {Py_XINCREF(py_V135);}
09264
09265	            V135 = NULL;
09266	            if (py_V135 == Py_None) {
09267	                // We can either fail here or set V135 to NULL and rely on Ops
09268	                // using tensors to handle the NULL case, but if they fail to do so
09269	                // they'll end up with nasty segfaults, so this is public service.
09270	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
09271	                {
09272	        __failure = 136;
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_136;}
09279	            }
09280	            if (!PyArray_Check(py_V135)) {
09281	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
09282	                {
09283	        __failure = 136;
09284	        if (!PyErr_Occurred()) {
09285	            PyErr_SetString(PyExc_RuntimeError,
09286	                "Unexpected error in an Op's C code. "
09287	                "No Python exception was set.");
09288	            }
09289	        goto __label_136;}
09290	            }
09291	            // We expect NPY_INT8
09292	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V135)) {
09293	                PyArrayObject * tmp = (PyArrayObject*) py_V135;
09294	                PyErr_Format(PyExc_NotImplementedError,
09295	                             "expected an aligned array of type %ld "
09296	                             "(NPY_INT8), got non-aligned array of type %ld"
09297	                             " with %ld dimensions, with 3 last dims "
09298	                             "%ld, %ld, %ld"
09299	                             " and 3 last strides %ld %ld, %ld.",
09300	                             (long int) NPY_INT8,
09301	                             (long int) PyArray_TYPE((PyArrayObject*) py_V135),
09302	                             (long int) PyArray_NDIM(tmp),
09303	                             (long int) PyArray_NDIM(tmp) >= 3 ?
09304	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
09305	                             (long int) PyArray_NDIM(tmp) >= 2 ?
09306	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
09307	                             (long int) PyArray_NDIM(tmp) >= 1 ?
09308	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
09309	                             (long int) PyArray_NDIM(tmp) >= 3 ?
09310	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
09311	                             (long int) PyArray_NDIM(tmp) >= 2 ?
09312	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
09313	                             (long int) PyArray_NDIM(tmp) >= 1 ?
09314	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
09315	            );
09316	                {
09317	        __failure = 136;
09318	        if (!PyErr_Occurred()) {
09319	            PyErr_SetString(PyExc_RuntimeError,
09320	                "Unexpected error in an Op's C code. "
09321	                "No Python exception was set.");
09322	            }
09323	        goto __label_136;}
09324	            }
09325	            // This is a TypeError to be consistent with DEBUG_MODE
09326	            // Note: DEBUG_MODE also tells the name of the container
09327	            if (PyArray_TYPE((PyArrayObject*) py_V135) != NPY_INT8) {
09328	                PyErr_Format(PyExc_TypeError,
09329	                             "expected type_num %d (NPY_INT8) got %d",
09330	                             NPY_INT8, PyArray_TYPE((PyArrayObject*) py_V135));
09331	                {
09332	        __failure = 136;
09333	        if (!PyErr_Occurred()) {
09334	            PyErr_SetString(PyExc_RuntimeError,
09335	                "Unexpected error in an Op's C code. "
09336	                "No Python exception was set.");
09337	            }
09338	        goto __label_136;}
09339	            }
09340
09341	        V135 = (PyArrayObject*)(py_V135);
09342	        Py_XINCREF(V135);
09343
09344	{
09345
09346	    py_V137 = PyList_GET_ITEM(storage_V137, 0);
09347	    {Py_XINCREF(py_V137);}
09348
09349	            V137 = NULL;
09350	            if (py_V137 == Py_None) {
09351	                // We can either fail here or set V137 to NULL and rely on Ops
09352	                // using tensors to handle the NULL case, but if they fail to do so
09353	                // they'll end up with nasty segfaults, so this is public service.
09354	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
09355	                {
09356	        __failure = 138;
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_138;}
09363	            }
09364	            if (!PyArray_Check(py_V137)) {
09365	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
09366	                {
09367	        __failure = 138;
09368	        if (!PyErr_Occurred()) {
09369	            PyErr_SetString(PyExc_RuntimeError,
09370	                "Unexpected error in an Op's C code. "
09371	                "No Python exception was set.");
09372	            }
09373	        goto __label_138;}
09374	            }
09375	            // We expect NPY_FLOAT64
09376	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V137)) {
09377	                PyArrayObject * tmp = (PyArrayObject*) py_V137;
09378	                PyErr_Format(PyExc_NotImplementedError,
09379	                             "expected an aligned array of type %ld "
09380	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
09381	                             " with %ld dimensions, with 3 last dims "
09382	                             "%ld, %ld, %ld"
09383	                             " and 3 last strides %ld %ld, %ld.",
09384	                             (long int) NPY_FLOAT64,
09385	                             (long int) PyArray_TYPE((PyArrayObject*) py_V137),
09386	                             (long int) PyArray_NDIM(tmp),
09387	                             (long int) PyArray_NDIM(tmp) >= 3 ?
09388	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
09389	                             (long int) PyArray_NDIM(tmp) >= 2 ?
09390	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
09391	                             (long int) PyArray_NDIM(tmp) >= 1 ?
09392	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
09393	                             (long int) PyArray_NDIM(tmp) >= 3 ?
09394	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
09395	                             (long int) PyArray_NDIM(tmp) >= 2 ?
09396	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
09397	                             (long int) PyArray_NDIM(tmp) >= 1 ?
09398	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
09399	            );
09400	                {
09401	        __failure = 138;
09402	        if (!PyErr_Occurred()) {
09403	            PyErr_SetString(PyExc_RuntimeError,
09404	                "Unexpected error in an Op's C code. "
09405	                "No Python exception was set.");
09406	            }
09407	        goto __label_138;}
09408	            }
09409	            // This is a TypeError to be consistent with DEBUG_MODE
09410	            // Note: DEBUG_MODE also tells the name of the container
09411	            if (PyArray_TYPE((PyArrayObject*) py_V137) != NPY_FLOAT64) {
09412	                PyErr_Format(PyExc_TypeError,
09413	                             "expected type_num %d (NPY_FLOAT64) got %d",
09414	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V137));
09415	                {
09416	        __failure = 138;
09417	        if (!PyErr_Occurred()) {
09418	            PyErr_SetString(PyExc_RuntimeError,
09419	                "Unexpected error in an Op's C code. "
09420	                "No Python exception was set.");
09421	            }
09422	        goto __label_138;}
09423	            }
09424
09425	        V137 = (PyArrayObject*)(py_V137);
09426	        Py_XINCREF(V137);
09427
09428	{
09429
09430	    py_V139 = PyList_GET_ITEM(storage_V139, 0);
09431	    {Py_XINCREF(py_V139);}
09432
09433	            V139 = NULL;
09434	            if (py_V139 == Py_None) {
09435	                // We can either fail here or set V139 to NULL and rely on Ops
09436	                // using tensors to handle the NULL case, but if they fail to do so
09437	                // they'll end up with nasty segfaults, so this is public service.
09438	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
09439	                {
09440	        __failure = 140;
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_140;}
09447	            }
09448	            if (!PyArray_Check(py_V139)) {
09449	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
09450	                {
09451	        __failure = 140;
09452	        if (!PyErr_Occurred()) {
09453	            PyErr_SetString(PyExc_RuntimeError,
09454	                "Unexpected error in an Op's C code. "
09455	                "No Python exception was set.");
09456	            }
09457	        goto __label_140;}
09458	            }
09459	            // We expect NPY_FLOAT64
09460	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V139)) {
09461	                PyArrayObject * tmp = (PyArrayObject*) py_V139;
09462	                PyErr_Format(PyExc_NotImplementedError,
09463	                             "expected an aligned array of type %ld "
09464	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
09465	                             " with %ld dimensions, with 3 last dims "
09466	                             "%ld, %ld, %ld"
09467	                             " and 3 last strides %ld %ld, %ld.",
09468	                             (long int) NPY_FLOAT64,
09469	                             (long int) PyArray_TYPE((PyArrayObject*) py_V139),
09470	                             (long int) PyArray_NDIM(tmp),
09471	                             (long int) PyArray_NDIM(tmp) >= 3 ?
09472	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
09473	                             (long int) PyArray_NDIM(tmp) >= 2 ?
09474	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
09475	                             (long int) PyArray_NDIM(tmp) >= 1 ?
09476	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
09477	                             (long int) PyArray_NDIM(tmp) >= 3 ?
09478	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
09479	                             (long int) PyArray_NDIM(tmp) >= 2 ?
09480	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
09481	                             (long int) PyArray_NDIM(tmp) >= 1 ?
09482	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
09483	            );
09484	                {
09485	        __failure = 140;
09486	        if (!PyErr_Occurred()) {
09487	            PyErr_SetString(PyExc_RuntimeError,
09488	                "Unexpected error in an Op's C code. "
09489	                "No Python exception was set.");
09490	            }
09491	        goto __label_140;}
09492	            }
09493	            // This is a TypeError to be consistent with DEBUG_MODE
09494	            // Note: DEBUG_MODE also tells the name of the container
09495	            if (PyArray_TYPE((PyArrayObject*) py_V139) != NPY_FLOAT64) {
09496	                PyErr_Format(PyExc_TypeError,
09497	                             "expected type_num %d (NPY_FLOAT64) got %d",
09498	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V139));
09499	                {
09500	        __failure = 140;
09501	        if (!PyErr_Occurred()) {
09502	            PyErr_SetString(PyExc_RuntimeError,
09503	                "Unexpected error in an Op's C code. "
09504	                "No Python exception was set.");
09505	            }
09506	        goto __label_140;}
09507	            }
09508
09509	        V139 = (PyArrayObject*)(py_V139);
09510	        Py_XINCREF(V139);
09511
09512	{
09513
09514	    py_V141 = PyList_GET_ITEM(storage_V141, 0);
09515	    {Py_XINCREF(py_V141);}
09516
09517	            V141 = NULL;
09518	            if (py_V141 == Py_None) {
09519	                // We can either fail here or set V141 to NULL and rely on Ops
09520	                // using tensors to handle the NULL case, but if they fail to do so
09521	                // they'll end up with nasty segfaults, so this is public service.
09522	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
09523	                {
09524	        __failure = 142;
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_142;}
09531	            }
09532	            if (!PyArray_Check(py_V141)) {
09533	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
09534	                {
09535	        __failure = 142;
09536	        if (!PyErr_Occurred()) {
09537	            PyErr_SetString(PyExc_RuntimeError,
09538	                "Unexpected error in an Op's C code. "
09539	                "No Python exception was set.");
09540	            }
09541	        goto __label_142;}
09542	            }
09543	            // We expect NPY_FLOAT64
09544	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V141)) {
09545	                PyArrayObject * tmp = (PyArrayObject*) py_V141;
09546	                PyErr_Format(PyExc_NotImplementedError,
09547	                             "expected an aligned array of type %ld "
09548	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
09549	                             " with %ld dimensions, with 3 last dims "
09550	                             "%ld, %ld, %ld"
09551	                             " and 3 last strides %ld %ld, %ld.",
09552	                             (long int) NPY_FLOAT64,
09553	                             (long int) PyArray_TYPE((PyArrayObject*) py_V141),
09554	                             (long int) PyArray_NDIM(tmp),
09555	                             (long int) PyArray_NDIM(tmp) >= 3 ?
09556	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
09557	                             (long int) PyArray_NDIM(tmp) >= 2 ?
09558	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
09559	                             (long int) PyArray_NDIM(tmp) >= 1 ?
09560	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
09561	                             (long int) PyArray_NDIM(tmp) >= 3 ?
09562	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
09563	                             (long int) PyArray_NDIM(tmp) >= 2 ?
09564	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
09565	                             (long int) PyArray_NDIM(tmp) >= 1 ?
09566	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
09567	            );
09568	                {
09569	        __failure = 142;
09570	        if (!PyErr_Occurred()) {
09571	            PyErr_SetString(PyExc_RuntimeError,
09572	                "Unexpected error in an Op's C code. "
09573	                "No Python exception was set.");
09574	            }
09575	        goto __label_142;}
09576	            }
09577	            // This is a TypeError to be consistent with DEBUG_MODE
09578	            // Note: DEBUG_MODE also tells the name of the container
09579	            if (PyArray_TYPE((PyArrayObject*) py_V141) != NPY_FLOAT64) {
09580	                PyErr_Format(PyExc_TypeError,
09581	                             "expected type_num %d (NPY_FLOAT64) got %d",
09582	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V141));
09583	                {
09584	        __failure = 142;
09585	        if (!PyErr_Occurred()) {
09586	            PyErr_SetString(PyExc_RuntimeError,
09587	                "Unexpected error in an Op's C code. "
09588	                "No Python exception was set.");
09589	            }
09590	        goto __label_142;}
09591	            }
09592
09593	        V141 = (PyArrayObject*)(py_V141);
09594	        Py_XINCREF(V141);
09595
09596	{
09597
09598	    py_V143 = PyList_GET_ITEM(storage_V143, 0);
09599	    {Py_XINCREF(py_V143);}
09600
09601	            V143 = NULL;
09602	            if (py_V143 == Py_None) {
09603	                // We can either fail here or set V143 to NULL and rely on Ops
09604	                // using tensors to handle the NULL case, but if they fail to do so
09605	                // they'll end up with nasty segfaults, so this is public service.
09606	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
09607	                {
09608	        __failure = 144;
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_144;}
09615	            }
09616	            if (!PyArray_Check(py_V143)) {
09617	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
09618	                {
09619	        __failure = 144;
09620	        if (!PyErr_Occurred()) {
09621	            PyErr_SetString(PyExc_RuntimeError,
09622	                "Unexpected error in an Op's C code. "
09623	                "No Python exception was set.");
09624	            }
09625	        goto __label_144;}
09626	            }
09627	            // We expect NPY_FLOAT64
09628	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V143)) {
09629	                PyArrayObject * tmp = (PyArrayObject*) py_V143;
09630	                PyErr_Format(PyExc_NotImplementedError,
09631	                             "expected an aligned array of type %ld "
09632	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
09633	                             " with %ld dimensions, with 3 last dims "
09634	                             "%ld, %ld, %ld"
09635	                             " and 3 last strides %ld %ld, %ld.",
09636	                             (long int) NPY_FLOAT64,
09637	                             (long int) PyArray_TYPE((PyArrayObject*) py_V143),
09638	                             (long int) PyArray_NDIM(tmp),
09639	                             (long int) PyArray_NDIM(tmp) >= 3 ?
09640	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
09641	                             (long int) PyArray_NDIM(tmp) >= 2 ?
09642	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
09643	                             (long int) PyArray_NDIM(tmp) >= 1 ?
09644	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
09645	                             (long int) PyArray_NDIM(tmp) >= 3 ?
09646	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
09647	                             (long int) PyArray_NDIM(tmp) >= 2 ?
09648	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
09649	                             (long int) PyArray_NDIM(tmp) >= 1 ?
09650	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
09651	            );
09652	                {
09653	        __failure = 144;
09654	        if (!PyErr_Occurred()) {
09655	            PyErr_SetString(PyExc_RuntimeError,
09656	                "Unexpected error in an Op's C code. "
09657	                "No Python exception was set.");
09658	            }
09659	        goto __label_144;}
09660	            }
09661	            // This is a TypeError to be consistent with DEBUG_MODE
09662	            // Note: DEBUG_MODE also tells the name of the container
09663	            if (PyArray_TYPE((PyArrayObject*) py_V143) != NPY_FLOAT64) {
09664	                PyErr_Format(PyExc_TypeError,
09665	                             "expected type_num %d (NPY_FLOAT64) got %d",
09666	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V143));
09667	                {
09668	        __failure = 144;
09669	        if (!PyErr_Occurred()) {
09670	            PyErr_SetString(PyExc_RuntimeError,
09671	                "Unexpected error in an Op's C code. "
09672	                "No Python exception was set.");
09673	            }
09674	        goto __label_144;}
09675	            }
09676
09677	        V143 = (PyArrayObject*)(py_V143);
09678	        Py_XINCREF(V143);
09679
09680	{
09681
09682	    py_V145 = PyList_GET_ITEM(storage_V145, 0);
09683	    {Py_XINCREF(py_V145);}
09684
09685	            V145 = NULL;
09686	            if (py_V145 == Py_None) {
09687	                // We can either fail here or set V145 to NULL and rely on Ops
09688	                // using tensors to handle the NULL case, but if they fail to do so
09689	                // they'll end up with nasty segfaults, so this is public service.
09690	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
09691	                {
09692	        __failure = 146;
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_146;}
09699	            }
09700	            if (!PyArray_Check(py_V145)) {
09701	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
09702	                {
09703	        __failure = 146;
09704	        if (!PyErr_Occurred()) {
09705	            PyErr_SetString(PyExc_RuntimeError,
09706	                "Unexpected error in an Op's C code. "
09707	                "No Python exception was set.");
09708	            }
09709	        goto __label_146;}
09710	            }
09711	            // We expect NPY_FLOAT64
09712	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V145)) {
09713	                PyArrayObject * tmp = (PyArrayObject*) py_V145;
09714	                PyErr_Format(PyExc_NotImplementedError,
09715	                             "expected an aligned array of type %ld "
09716	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
09717	                             " with %ld dimensions, with 3 last dims "
09718	                             "%ld, %ld, %ld"
09719	                             " and 3 last strides %ld %ld, %ld.",
09720	                             (long int) NPY_FLOAT64,
09721	                             (long int) PyArray_TYPE((PyArrayObject*) py_V145),
09722	                             (long int) PyArray_NDIM(tmp),
09723	                             (long int) PyArray_NDIM(tmp) >= 3 ?
09724	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
09725	                             (long int) PyArray_NDIM(tmp) >= 2 ?
09726	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
09727	                             (long int) PyArray_NDIM(tmp) >= 1 ?
09728	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
09729	                             (long int) PyArray_NDIM(tmp) >= 3 ?
09730	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
09731	                             (long int) PyArray_NDIM(tmp) >= 2 ?
09732	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
09733	                             (long int) PyArray_NDIM(tmp) >= 1 ?
09734	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
09735	            );
09736	                {
09737	        __failure = 146;
09738	        if (!PyErr_Occurred()) {
09739	            PyErr_SetString(PyExc_RuntimeError,
09740	                "Unexpected error in an Op's C code. "
09741	                "No Python exception was set.");
09742	            }
09743	        goto __label_146;}
09744	            }
09745	            // This is a TypeError to be consistent with DEBUG_MODE
09746	            // Note: DEBUG_MODE also tells the name of the container
09747	            if (PyArray_TYPE((PyArrayObject*) py_V145) != NPY_FLOAT64) {
09748	                PyErr_Format(PyExc_TypeError,
09749	                             "expected type_num %d (NPY_FLOAT64) got %d",
09750	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V145));
09751	                {
09752	        __failure = 146;
09753	        if (!PyErr_Occurred()) {
09754	            PyErr_SetString(PyExc_RuntimeError,
09755	                "Unexpected error in an Op's C code. "
09756	                "No Python exception was set.");
09757	            }
09758	        goto __label_146;}
09759	            }
09760
09761	        V145 = (PyArrayObject*)(py_V145);
09762	        Py_XINCREF(V145);
09763
09764	{
09765
09766	    py_V147 = PyList_GET_ITEM(storage_V147, 0);
09767	    {Py_XINCREF(py_V147);}
09768
09769	            V147 = NULL;
09770	            if (py_V147 == Py_None) {
09771	                // We can either fail here or set V147 to NULL and rely on Ops
09772	                // using tensors to handle the NULL case, but if they fail to do so
09773	                // they'll end up with nasty segfaults, so this is public service.
09774	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
09775	                {
09776	        __failure = 148;
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_148;}
09783	            }
09784	            if (!PyArray_Check(py_V147)) {
09785	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
09786	                {
09787	        __failure = 148;
09788	        if (!PyErr_Occurred()) {
09789	            PyErr_SetString(PyExc_RuntimeError,
09790	                "Unexpected error in an Op's C code. "
09791	                "No Python exception was set.");
09792	            }
09793	        goto __label_148;}
09794	            }
09795	            // We expect NPY_INT8
09796	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V147)) {
09797	                PyArrayObject * tmp = (PyArrayObject*) py_V147;
09798	                PyErr_Format(PyExc_NotImplementedError,
09799	                             "expected an aligned array of type %ld "
09800	                             "(NPY_INT8), got non-aligned array of type %ld"
09801	                             " with %ld dimensions, with 3 last dims "
09802	                             "%ld, %ld, %ld"
09803	                             " and 3 last strides %ld %ld, %ld.",
09804	                             (long int) NPY_INT8,
09805	                             (long int) PyArray_TYPE((PyArrayObject*) py_V147),
09806	                             (long int) PyArray_NDIM(tmp),
09807	                             (long int) PyArray_NDIM(tmp) >= 3 ?
09808	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
09809	                             (long int) PyArray_NDIM(tmp) >= 2 ?
09810	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
09811	                             (long int) PyArray_NDIM(tmp) >= 1 ?
09812	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
09813	                             (long int) PyArray_NDIM(tmp) >= 3 ?
09814	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
09815	                             (long int) PyArray_NDIM(tmp) >= 2 ?
09816	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
09817	                             (long int) PyArray_NDIM(tmp) >= 1 ?
09818	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
09819	            );
09820	                {
09821	        __failure = 148;
09822	        if (!PyErr_Occurred()) {
09823	            PyErr_SetString(PyExc_RuntimeError,
09824	                "Unexpected error in an Op's C code. "
09825	                "No Python exception was set.");
09826	            }
09827	        goto __label_148;}
09828	            }
09829	            // This is a TypeError to be consistent with DEBUG_MODE
09830	            // Note: DEBUG_MODE also tells the name of the container
09831	            if (PyArray_TYPE((PyArrayObject*) py_V147) != NPY_INT8) {
09832	                PyErr_Format(PyExc_TypeError,
09833	                             "expected type_num %d (NPY_INT8) got %d",
09834	                             NPY_INT8, PyArray_TYPE((PyArrayObject*) py_V147));
09835	                {
09836	        __failure = 148;
09837	        if (!PyErr_Occurred()) {
09838	            PyErr_SetString(PyExc_RuntimeError,
09839	                "Unexpected error in an Op's C code. "
09840	                "No Python exception was set.");
09841	            }
09842	        goto __label_148;}
09843	            }
09844
09845	        V147 = (PyArrayObject*)(py_V147);
09846	        Py_XINCREF(V147);
09847
09848	{
09849
09850	    py_V149 = PyList_GET_ITEM(storage_V149, 0);
09851	    {Py_XINCREF(py_V149);}
09852
09853	            V149 = NULL;
09854	            if (py_V149 == Py_None) {
09855	                // We can either fail here or set V149 to NULL and rely on Ops
09856	                // using tensors to handle the NULL case, but if they fail to do so
09857	                // they'll end up with nasty segfaults, so this is public service.
09858	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
09859	                {
09860	        __failure = 150;
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_150;}
09867	            }
09868	            if (!PyArray_Check(py_V149)) {
09869	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
09870	                {
09871	        __failure = 150;
09872	        if (!PyErr_Occurred()) {
09873	            PyErr_SetString(PyExc_RuntimeError,
09874	                "Unexpected error in an Op's C code. "
09875	                "No Python exception was set.");
09876	            }
09877	        goto __label_150;}
09878	            }
09879	            // We expect NPY_FLOAT64
09880	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V149)) {
09881	                PyArrayObject * tmp = (PyArrayObject*) py_V149;
09882	                PyErr_Format(PyExc_NotImplementedError,
09883	                             "expected an aligned array of type %ld "
09884	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
09885	                             " with %ld dimensions, with 3 last dims "
09886	                             "%ld, %ld, %ld"
09887	                             " and 3 last strides %ld %ld, %ld.",
09888	                             (long int) NPY_FLOAT64,
09889	                             (long int) PyArray_TYPE((PyArrayObject*) py_V149),
09890	                             (long int) PyArray_NDIM(tmp),
09891	                             (long int) PyArray_NDIM(tmp) >= 3 ?
09892	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
09893	                             (long int) PyArray_NDIM(tmp) >= 2 ?
09894	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
09895	                             (long int) PyArray_NDIM(tmp) >= 1 ?
09896	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
09897	                             (long int) PyArray_NDIM(tmp) >= 3 ?
09898	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
09899	                             (long int) PyArray_NDIM(tmp) >= 2 ?
09900	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
09901	                             (long int) PyArray_NDIM(tmp) >= 1 ?
09902	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
09903	            );
09904	                {
09905	        __failure = 150;
09906	        if (!PyErr_Occurred()) {
09907	            PyErr_SetString(PyExc_RuntimeError,
09908	                "Unexpected error in an Op's C code. "
09909	                "No Python exception was set.");
09910	            }
09911	        goto __label_150;}
09912	            }
09913	            // This is a TypeError to be consistent with DEBUG_MODE
09914	            // Note: DEBUG_MODE also tells the name of the container
09915	            if (PyArray_TYPE((PyArrayObject*) py_V149) != NPY_FLOAT64) {
09916	                PyErr_Format(PyExc_TypeError,
09917	                             "expected type_num %d (NPY_FLOAT64) got %d",
09918	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V149));
09919	                {
09920	        __failure = 150;
09921	        if (!PyErr_Occurred()) {
09922	            PyErr_SetString(PyExc_RuntimeError,
09923	                "Unexpected error in an Op's C code. "
09924	                "No Python exception was set.");
09925	            }
09926	        goto __label_150;}
09927	            }
09928
09929	        V149 = (PyArrayObject*)(py_V149);
09930	        Py_XINCREF(V149);
09931
09932	{
09933
09934	    py_V151 = PyList_GET_ITEM(storage_V151, 0);
09935	    {Py_XINCREF(py_V151);}
09936
09937	            V151 = NULL;
09938	            if (py_V151 == Py_None) {
09939	                // We can either fail here or set V151 to NULL and rely on Ops
09940	                // using tensors to handle the NULL case, but if they fail to do so
09941	                // they'll end up with nasty segfaults, so this is public service.
09942	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
09943	                {
09944	        __failure = 152;
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_152;}
09951	            }
09952	            if (!PyArray_Check(py_V151)) {
09953	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
09954	                {
09955	        __failure = 152;
09956	        if (!PyErr_Occurred()) {
09957	            PyErr_SetString(PyExc_RuntimeError,
09958	                "Unexpected error in an Op's C code. "
09959	                "No Python exception was set.");
09960	            }
09961	        goto __label_152;}
09962	            }
09963	            // We expect NPY_FLOAT64
09964	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V151)) {
09965	                PyArrayObject * tmp = (PyArrayObject*) py_V151;
09966	                PyErr_Format(PyExc_NotImplementedError,
09967	                             "expected an aligned array of type %ld "
09968	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
09969	                             " with %ld dimensions, with 3 last dims "
09970	                             "%ld, %ld, %ld"
09971	                             " and 3 last strides %ld %ld, %ld.",
09972	                             (long int) NPY_FLOAT64,
09973	                             (long int) PyArray_TYPE((PyArrayObject*) py_V151),
09974	                             (long int) PyArray_NDIM(tmp),
09975	                             (long int) PyArray_NDIM(tmp) >= 3 ?
09976	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
09977	                             (long int) PyArray_NDIM(tmp) >= 2 ?
09978	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
09979	                             (long int) PyArray_NDIM(tmp) >= 1 ?
09980	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
09981	                             (long int) PyArray_NDIM(tmp) >= 3 ?
09982	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
09983	                             (long int) PyArray_NDIM(tmp) >= 2 ?
09984	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
09985	                             (long int) PyArray_NDIM(tmp) >= 1 ?
09986	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
09987	            );
09988	                {
09989	        __failure = 152;
09990	        if (!PyErr_Occurred()) {
09991	            PyErr_SetString(PyExc_RuntimeError,
09992	                "Unexpected error in an Op's C code. "
09993	                "No Python exception was set.");
09994	            }
09995	        goto __label_152;}
09996	            }
09997	            // This is a TypeError to be consistent with DEBUG_MODE
09998	            // Note: DEBUG_MODE also tells the name of the container
09999	            if (PyArray_TYPE((PyArrayObject*) py_V151) != NPY_FLOAT64) {
10000	                PyErr_Format(PyExc_TypeError,
10001	                             "expected type_num %d (NPY_FLOAT64) got %d",
10002	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V151));
10003	                {
10004	        __failure = 152;
10005	        if (!PyErr_Occurred()) {
10006	            PyErr_SetString(PyExc_RuntimeError,
10007	                "Unexpected error in an Op's C code. "
10008	                "No Python exception was set.");
10009	            }
10010	        goto __label_152;}
10011	            }
10012
10013	        V151 = (PyArrayObject*)(py_V151);
10014	        Py_XINCREF(V151);
10015
10016	{
10017
10018	    py_V153 = PyList_GET_ITEM(storage_V153, 0);
10019	    {Py_XINCREF(py_V153);}
10020
10021	            V153 = NULL;
10022	            if (py_V153 == Py_None) {
10023	                // We can either fail here or set V153 to NULL and rely on Ops
10024	                // using tensors to handle the NULL case, but if they fail to do so
10025	                // they'll end up with nasty segfaults, so this is public service.
10026	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
10027	                {
10028	        __failure = 154;
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_154;}
10035	            }
10036	            if (!PyArray_Check(py_V153)) {
10037	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
10038	                {
10039	        __failure = 154;
10040	        if (!PyErr_Occurred()) {
10041	            PyErr_SetString(PyExc_RuntimeError,
10042	                "Unexpected error in an Op's C code. "
10043	                "No Python exception was set.");
10044	            }
10045	        goto __label_154;}
10046	            }
10047	            // We expect NPY_FLOAT64
10048	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V153)) {
10049	                PyArrayObject * tmp = (PyArrayObject*) py_V153;
10050	                PyErr_Format(PyExc_NotImplementedError,
10051	                             "expected an aligned array of type %ld "
10052	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
10053	                             " with %ld dimensions, with 3 last dims "
10054	                             "%ld, %ld, %ld"
10055	                             " and 3 last strides %ld %ld, %ld.",
10056	                             (long int) NPY_FLOAT64,
10057	                             (long int) PyArray_TYPE((PyArrayObject*) py_V153),
10058	                             (long int) PyArray_NDIM(tmp),
10059	                             (long int) PyArray_NDIM(tmp) >= 3 ?
10060	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
10061	                             (long int) PyArray_NDIM(tmp) >= 2 ?
10062	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
10063	                             (long int) PyArray_NDIM(tmp) >= 1 ?
10064	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
10065	                             (long int) PyArray_NDIM(tmp) >= 3 ?
10066	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
10067	                             (long int) PyArray_NDIM(tmp) >= 2 ?
10068	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
10069	                             (long int) PyArray_NDIM(tmp) >= 1 ?
10070	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
10071	            );
10072	                {
10073	        __failure = 154;
10074	        if (!PyErr_Occurred()) {
10075	            PyErr_SetString(PyExc_RuntimeError,
10076	                "Unexpected error in an Op's C code. "
10077	                "No Python exception was set.");
10078	            }
10079	        goto __label_154;}
10080	            }
10081	            // This is a TypeError to be consistent with DEBUG_MODE
10082	            // Note: DEBUG_MODE also tells the name of the container
10083	            if (PyArray_TYPE((PyArrayObject*) py_V153) != NPY_FLOAT64) {
10084	                PyErr_Format(PyExc_TypeError,
10085	                             "expected type_num %d (NPY_FLOAT64) got %d",
10086	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V153));
10087	                {
10088	        __failure = 154;
10089	        if (!PyErr_Occurred()) {
10090	            PyErr_SetString(PyExc_RuntimeError,
10091	                "Unexpected error in an Op's C code. "
10092	                "No Python exception was set.");
10093	            }
10094	        goto __label_154;}
10095	            }
10096
10097	        V153 = (PyArrayObject*)(py_V153);
10098	        Py_XINCREF(V153);
10099
10100	{
10101
10102	    py_V155 = PyList_GET_ITEM(storage_V155, 0);
10103	    {Py_XINCREF(py_V155);}
10104
10105	            V155 = NULL;
10106	            if (py_V155 == Py_None) {
10107	                // We can either fail here or set V155 to NULL and rely on Ops
10108	                // using tensors to handle the NULL case, but if they fail to do so
10109	                // they'll end up with nasty segfaults, so this is public service.
10110	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
10111	                {
10112	        __failure = 156;
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_156;}
10119	            }
10120	            if (!PyArray_Check(py_V155)) {
10121	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
10122	                {
10123	        __failure = 156;
10124	        if (!PyErr_Occurred()) {
10125	            PyErr_SetString(PyExc_RuntimeError,
10126	                "Unexpected error in an Op's C code. "
10127	                "No Python exception was set.");
10128	            }
10129	        goto __label_156;}
10130	            }
10131	            // We expect NPY_FLOAT64
10132	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V155)) {
10133	                PyArrayObject * tmp = (PyArrayObject*) py_V155;
10134	                PyErr_Format(PyExc_NotImplementedError,
10135	                             "expected an aligned array of type %ld "
10136	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
10137	                             " with %ld dimensions, with 3 last dims "
10138	                             "%ld, %ld, %ld"
10139	                             " and 3 last strides %ld %ld, %ld.",
10140	                             (long int) NPY_FLOAT64,
10141	                             (long int) PyArray_TYPE((PyArrayObject*) py_V155),
10142	                             (long int) PyArray_NDIM(tmp),
10143	                             (long int) PyArray_NDIM(tmp) >= 3 ?
10144	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
10145	                             (long int) PyArray_NDIM(tmp) >= 2 ?
10146	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
10147	                             (long int) PyArray_NDIM(tmp) >= 1 ?
10148	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
10149	                             (long int) PyArray_NDIM(tmp) >= 3 ?
10150	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
10151	                             (long int) PyArray_NDIM(tmp) >= 2 ?
10152	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
10153	                             (long int) PyArray_NDIM(tmp) >= 1 ?
10154	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
10155	            );
10156	                {
10157	        __failure = 156;
10158	        if (!PyErr_Occurred()) {
10159	            PyErr_SetString(PyExc_RuntimeError,
10160	                "Unexpected error in an Op's C code. "
10161	                "No Python exception was set.");
10162	            }
10163	        goto __label_156;}
10164	            }
10165	            // This is a TypeError to be consistent with DEBUG_MODE
10166	            // Note: DEBUG_MODE also tells the name of the container
10167	            if (PyArray_TYPE((PyArrayObject*) py_V155) != NPY_FLOAT64) {
10168	                PyErr_Format(PyExc_TypeError,
10169	                             "expected type_num %d (NPY_FLOAT64) got %d",
10170	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V155));
10171	                {
10172	        __failure = 156;
10173	        if (!PyErr_Occurred()) {
10174	            PyErr_SetString(PyExc_RuntimeError,
10175	                "Unexpected error in an Op's C code. "
10176	                "No Python exception was set.");
10177	            }
10178	        goto __label_156;}
10179	            }
10180
10181	        V155 = (PyArrayObject*)(py_V155);
10182	        Py_XINCREF(V155);
10183
10184	{
10185
10186	    py_V157 = PyList_GET_ITEM(storage_V157, 0);
10187	    {Py_XINCREF(py_V157);}
10188
10189	            V157 = NULL;
10190	            if (py_V157 == Py_None) {
10191	                // We can either fail here or set V157 to NULL and rely on Ops
10192	                // using tensors to handle the NULL case, but if they fail to do so
10193	                // they'll end up with nasty segfaults, so this is public service.
10194	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
10195	                {
10196	        __failure = 158;
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_158;}
10203	            }
10204	            if (!PyArray_Check(py_V157)) {
10205	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
10206	                {
10207	        __failure = 158;
10208	        if (!PyErr_Occurred()) {
10209	            PyErr_SetString(PyExc_RuntimeError,
10210	                "Unexpected error in an Op's C code. "
10211	                "No Python exception was set.");
10212	            }
10213	        goto __label_158;}
10214	            }
10215	            // We expect NPY_FLOAT64
10216	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V157)) {
10217	                PyArrayObject * tmp = (PyArrayObject*) py_V157;
10218	                PyErr_Format(PyExc_NotImplementedError,
10219	                             "expected an aligned array of type %ld "
10220	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
10221	                             " with %ld dimensions, with 3 last dims "
10222	                             "%ld, %ld, %ld"
10223	                             " and 3 last strides %ld %ld, %ld.",
10224	                             (long int) NPY_FLOAT64,
10225	                             (long int) PyArray_TYPE((PyArrayObject*) py_V157),
10226	                             (long int) PyArray_NDIM(tmp),
10227	                             (long int) PyArray_NDIM(tmp) >= 3 ?
10228	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
10229	                             (long int) PyArray_NDIM(tmp) >= 2 ?
10230	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
10231	                             (long int) PyArray_NDIM(tmp) >= 1 ?
10232	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
10233	                             (long int) PyArray_NDIM(tmp) >= 3 ?
10234	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
10235	                             (long int) PyArray_NDIM(tmp) >= 2 ?
10236	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
10237	                             (long int) PyArray_NDIM(tmp) >= 1 ?
10238	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
10239	            );
10240	                {
10241	        __failure = 158;
10242	        if (!PyErr_Occurred()) {
10243	            PyErr_SetString(PyExc_RuntimeError,
10244	                "Unexpected error in an Op's C code. "
10245	                "No Python exception was set.");
10246	            }
10247	        goto __label_158;}
10248	            }
10249	            // This is a TypeError to be consistent with DEBUG_MODE
10250	            // Note: DEBUG_MODE also tells the name of the container
10251	            if (PyArray_TYPE((PyArrayObject*) py_V157) != NPY_FLOAT64) {
10252	                PyErr_Format(PyExc_TypeError,
10253	                             "expected type_num %d (NPY_FLOAT64) got %d",
10254	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V157));
10255	                {
10256	        __failure = 158;
10257	        if (!PyErr_Occurred()) {
10258	            PyErr_SetString(PyExc_RuntimeError,
10259	                "Unexpected error in an Op's C code. "
10260	                "No Python exception was set.");
10261	            }
10262	        goto __label_158;}
10263	            }
10264
10265	        V157 = (PyArrayObject*)(py_V157);
10266	        Py_XINCREF(V157);
10267
10268	{
10269
10270	    py_V159 = PyList_GET_ITEM(storage_V159, 0);
10271	    {Py_XINCREF(py_V159);}
10272
10273	            V159 = NULL;
10274	            if (py_V159 == Py_None) {
10275	                // We can either fail here or set V159 to NULL and rely on Ops
10276	                // using tensors to handle the NULL case, but if they fail to do so
10277	                // they'll end up with nasty segfaults, so this is public service.
10278	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
10279	                {
10280	        __failure = 160;
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_160;}
10287	            }
10288	            if (!PyArray_Check(py_V159)) {
10289	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
10290	                {
10291	        __failure = 160;
10292	        if (!PyErr_Occurred()) {
10293	            PyErr_SetString(PyExc_RuntimeError,
10294	                "Unexpected error in an Op's C code. "
10295	                "No Python exception was set.");
10296	            }
10297	        goto __label_160;}
10298	            }
10299	            // We expect NPY_FLOAT64
10300	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V159)) {
10301	                PyArrayObject * tmp = (PyArrayObject*) py_V159;
10302	                PyErr_Format(PyExc_NotImplementedError,
10303	                             "expected an aligned array of type %ld "
10304	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
10305	                             " with %ld dimensions, with 3 last dims "
10306	                             "%ld, %ld, %ld"
10307	                             " and 3 last strides %ld %ld, %ld.",
10308	                             (long int) NPY_FLOAT64,
10309	                             (long int) PyArray_TYPE((PyArrayObject*) py_V159),
10310	                             (long int) PyArray_NDIM(tmp),
10311	                             (long int) PyArray_NDIM(tmp) >= 3 ?
10312	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
10313	                             (long int) PyArray_NDIM(tmp) >= 2 ?
10314	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
10315	                             (long int) PyArray_NDIM(tmp) >= 1 ?
10316	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
10317	                             (long int) PyArray_NDIM(tmp) >= 3 ?
10318	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
10319	                             (long int) PyArray_NDIM(tmp) >= 2 ?
10320	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
10321	                             (long int) PyArray_NDIM(tmp) >= 1 ?
10322	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
10323	            );
10324	                {
10325	        __failure = 160;
10326	        if (!PyErr_Occurred()) {
10327	            PyErr_SetString(PyExc_RuntimeError,
10328	                "Unexpected error in an Op's C code. "
10329	                "No Python exception was set.");
10330	            }
10331	        goto __label_160;}
10332	            }
10333	            // This is a TypeError to be consistent with DEBUG_MODE
10334	            // Note: DEBUG_MODE also tells the name of the container
10335	            if (PyArray_TYPE((PyArrayObject*) py_V159) != NPY_FLOAT64) {
10336	                PyErr_Format(PyExc_TypeError,
10337	                             "expected type_num %d (NPY_FLOAT64) got %d",
10338	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V159));
10339	                {
10340	        __failure = 160;
10341	        if (!PyErr_Occurred()) {
10342	            PyErr_SetString(PyExc_RuntimeError,
10343	                "Unexpected error in an Op's C code. "
10344	                "No Python exception was set.");
10345	            }
10346	        goto __label_160;}
10347	            }
10348
10349	        V159 = (PyArrayObject*)(py_V159);
10350	        Py_XINCREF(V159);
10351
10352	{
10353
10354	    py_V161 = PyList_GET_ITEM(storage_V161, 0);
10355	    {Py_XINCREF(py_V161);}
10356
10357	            V161 = NULL;
10358	            if (py_V161 == Py_None) {
10359	                // We can either fail here or set V161 to NULL and rely on Ops
10360	                // using tensors to handle the NULL case, but if they fail to do so
10361	                // they'll end up with nasty segfaults, so this is public service.
10362	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
10363	                {
10364	        __failure = 162;
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_162;}
10371	            }
10372	            if (!PyArray_Check(py_V161)) {
10373	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
10374	                {
10375	        __failure = 162;
10376	        if (!PyErr_Occurred()) {
10377	            PyErr_SetString(PyExc_RuntimeError,
10378	                "Unexpected error in an Op's C code. "
10379	                "No Python exception was set.");
10380	            }
10381	        goto __label_162;}
10382	            }
10383	            // We expect NPY_INT8
10384	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V161)) {
10385	                PyArrayObject * tmp = (PyArrayObject*) py_V161;
10386	                PyErr_Format(PyExc_NotImplementedError,
10387	                             "expected an aligned array of type %ld "
10388	                             "(NPY_INT8), got non-aligned array of type %ld"
10389	                             " with %ld dimensions, with 3 last dims "
10390	                             "%ld, %ld, %ld"
10391	                             " and 3 last strides %ld %ld, %ld.",
10392	                             (long int) NPY_INT8,
10393	                             (long int) PyArray_TYPE((PyArrayObject*) py_V161),
10394	                             (long int) PyArray_NDIM(tmp),
10395	                             (long int) PyArray_NDIM(tmp) >= 3 ?
10396	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
10397	                             (long int) PyArray_NDIM(tmp) >= 2 ?
10398	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
10399	                             (long int) PyArray_NDIM(tmp) >= 1 ?
10400	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
10401	                             (long int) PyArray_NDIM(tmp) >= 3 ?
10402	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
10403	                             (long int) PyArray_NDIM(tmp) >= 2 ?
10404	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
10405	                             (long int) PyArray_NDIM(tmp) >= 1 ?
10406	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
10407	            );
10408	                {
10409	        __failure = 162;
10410	        if (!PyErr_Occurred()) {
10411	            PyErr_SetString(PyExc_RuntimeError,
10412	                "Unexpected error in an Op's C code. "
10413	                "No Python exception was set.");
10414	            }
10415	        goto __label_162;}
10416	            }
10417	            // This is a TypeError to be consistent with DEBUG_MODE
10418	            // Note: DEBUG_MODE also tells the name of the container
10419	            if (PyArray_TYPE((PyArrayObject*) py_V161) != NPY_INT8) {
10420	                PyErr_Format(PyExc_TypeError,
10421	                             "expected type_num %d (NPY_INT8) got %d",
10422	                             NPY_INT8, PyArray_TYPE((PyArrayObject*) py_V161));
10423	                {
10424	        __failure = 162;
10425	        if (!PyErr_Occurred()) {
10426	            PyErr_SetString(PyExc_RuntimeError,
10427	                "Unexpected error in an Op's C code. "
10428	                "No Python exception was set.");
10429	            }
10430	        goto __label_162;}
10431	            }
10432
10433	        V161 = (PyArrayObject*)(py_V161);
10434	        Py_XINCREF(V161);
10435
10436	{
10437
10438	    py_V163 = PyList_GET_ITEM(storage_V163, 0);
10439	    {Py_XINCREF(py_V163);}
10440
10441	            V163 = NULL;
10442	            if (py_V163 == Py_None) {
10443	                // We can either fail here or set V163 to NULL and rely on Ops
10444	                // using tensors to handle the NULL case, but if they fail to do so
10445	                // they'll end up with nasty segfaults, so this is public service.
10446	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
10447	                {
10448	        __failure = 164;
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_164;}
10455	            }
10456	            if (!PyArray_Check(py_V163)) {
10457	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
10458	                {
10459	        __failure = 164;
10460	        if (!PyErr_Occurred()) {
10461	            PyErr_SetString(PyExc_RuntimeError,
10462	                "Unexpected error in an Op's C code. "
10463	                "No Python exception was set.");
10464	            }
10465	        goto __label_164;}
10466	            }
10467	            // We expect NPY_FLOAT64
10468	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V163)) {
10469	                PyArrayObject * tmp = (PyArrayObject*) py_V163;
10470	                PyErr_Format(PyExc_NotImplementedError,
10471	                             "expected an aligned array of type %ld "
10472	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
10473	                             " with %ld dimensions, with 3 last dims "
10474	                             "%ld, %ld, %ld"
10475	                             " and 3 last strides %ld %ld, %ld.",
10476	                             (long int) NPY_FLOAT64,
10477	                             (long int) PyArray_TYPE((PyArrayObject*) py_V163),
10478	                             (long int) PyArray_NDIM(tmp),
10479	                             (long int) PyArray_NDIM(tmp) >= 3 ?
10480	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
10481	                             (long int) PyArray_NDIM(tmp) >= 2 ?
10482	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
10483	                             (long int) PyArray_NDIM(tmp) >= 1 ?
10484	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
10485	                             (long int) PyArray_NDIM(tmp) >= 3 ?
10486	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
10487	                             (long int) PyArray_NDIM(tmp) >= 2 ?
10488	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
10489	                             (long int) PyArray_NDIM(tmp) >= 1 ?
10490	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
10491	            );
10492	                {
10493	        __failure = 164;
10494	        if (!PyErr_Occurred()) {
10495	            PyErr_SetString(PyExc_RuntimeError,
10496	                "Unexpected error in an Op's C code. "
10497	                "No Python exception was set.");
10498	            }
10499	        goto __label_164;}
10500	            }
10501	            // This is a TypeError to be consistent with DEBUG_MODE
10502	            // Note: DEBUG_MODE also tells the name of the container
10503	            if (PyArray_TYPE((PyArrayObject*) py_V163) != NPY_FLOAT64) {
10504	                PyErr_Format(PyExc_TypeError,
10505	                             "expected type_num %d (NPY_FLOAT64) got %d",
10506	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V163));
10507	                {
10508	        __failure = 164;
10509	        if (!PyErr_Occurred()) {
10510	            PyErr_SetString(PyExc_RuntimeError,
10511	                "Unexpected error in an Op's C code. "
10512	                "No Python exception was set.");
10513	            }
10514	        goto __label_164;}
10515	            }
10516
10517	        V163 = (PyArrayObject*)(py_V163);
10518	        Py_XINCREF(V163);
10519
10520	{
10521
10522	    py_V165 = PyList_GET_ITEM(storage_V165, 0);
10523	    {Py_XINCREF(py_V165);}
10524
10525	            V165 = NULL;
10526	            if (py_V165 == Py_None) {
10527	                // We can either fail here or set V165 to NULL and rely on Ops
10528	                // using tensors to handle the NULL case, but if they fail to do so
10529	                // they'll end up with nasty segfaults, so this is public service.
10530	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
10531	                {
10532	        __failure = 166;
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_166;}
10539	            }
10540	            if (!PyArray_Check(py_V165)) {
10541	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
10542	                {
10543	        __failure = 166;
10544	        if (!PyErr_Occurred()) {
10545	            PyErr_SetString(PyExc_RuntimeError,
10546	                "Unexpected error in an Op's C code. "
10547	                "No Python exception was set.");
10548	            }
10549	        goto __label_166;}
10550	            }
10551	            // We expect NPY_FLOAT64
10552	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V165)) {
10553	                PyArrayObject * tmp = (PyArrayObject*) py_V165;
10554	                PyErr_Format(PyExc_NotImplementedError,
10555	                             "expected an aligned array of type %ld "
10556	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
10557	                             " with %ld dimensions, with 3 last dims "
10558	                             "%ld, %ld, %ld"
10559	                             " and 3 last strides %ld %ld, %ld.",
10560	                             (long int) NPY_FLOAT64,
10561	                             (long int) PyArray_TYPE((PyArrayObject*) py_V165),
10562	                             (long int) PyArray_NDIM(tmp),
10563	                             (long int) PyArray_NDIM(tmp) >= 3 ?
10564	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
10565	                             (long int) PyArray_NDIM(tmp) >= 2 ?
10566	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
10567	                             (long int) PyArray_NDIM(tmp) >= 1 ?
10568	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
10569	                             (long int) PyArray_NDIM(tmp) >= 3 ?
10570	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
10571	                             (long int) PyArray_NDIM(tmp) >= 2 ?
10572	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
10573	                             (long int) PyArray_NDIM(tmp) >= 1 ?
10574	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
10575	            );
10576	                {
10577	        __failure = 166;
10578	        if (!PyErr_Occurred()) {
10579	            PyErr_SetString(PyExc_RuntimeError,
10580	                "Unexpected error in an Op's C code. "
10581	                "No Python exception was set.");
10582	            }
10583	        goto __label_166;}
10584	            }
10585	            // This is a TypeError to be consistent with DEBUG_MODE
10586	            // Note: DEBUG_MODE also tells the name of the container
10587	            if (PyArray_TYPE((PyArrayObject*) py_V165) != NPY_FLOAT64) {
10588	                PyErr_Format(PyExc_TypeError,
10589	                             "expected type_num %d (NPY_FLOAT64) got %d",
10590	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V165));
10591	                {
10592	        __failure = 166;
10593	        if (!PyErr_Occurred()) {
10594	            PyErr_SetString(PyExc_RuntimeError,
10595	                "Unexpected error in an Op's C code. "
10596	                "No Python exception was set.");
10597	            }
10598	        goto __label_166;}
10599	            }
10600
10601	        V165 = (PyArrayObject*)(py_V165);
10602	        Py_XINCREF(V165);
10603
10604	{
10605
10606	    py_V167 = PyList_GET_ITEM(storage_V167, 0);
10607	    {Py_XINCREF(py_V167);}
10608
10609	            V167 = NULL;
10610	            if (py_V167 == Py_None) {
10611	                // We can either fail here or set V167 to NULL and rely on Ops
10612	                // using tensors to handle the NULL case, but if they fail to do so
10613	                // they'll end up with nasty segfaults, so this is public service.
10614	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
10615	                {
10616	        __failure = 168;
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_168;}
10623	            }
10624	            if (!PyArray_Check(py_V167)) {
10625	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
10626	                {
10627	        __failure = 168;
10628	        if (!PyErr_Occurred()) {
10629	            PyErr_SetString(PyExc_RuntimeError,
10630	                "Unexpected error in an Op's C code. "
10631	                "No Python exception was set.");
10632	            }
10633	        goto __label_168;}
10634	            }
10635	            // We expect NPY_FLOAT64
10636	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V167)) {
10637	                PyArrayObject * tmp = (PyArrayObject*) py_V167;
10638	                PyErr_Format(PyExc_NotImplementedError,
10639	                             "expected an aligned array of type %ld "
10640	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
10641	                             " with %ld dimensions, with 3 last dims "
10642	                             "%ld, %ld, %ld"
10643	                             " and 3 last strides %ld %ld, %ld.",
10644	                             (long int) NPY_FLOAT64,
10645	                             (long int) PyArray_TYPE((PyArrayObject*) py_V167),
10646	                             (long int) PyArray_NDIM(tmp),
10647	                             (long int) PyArray_NDIM(tmp) >= 3 ?
10648	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
10649	                             (long int) PyArray_NDIM(tmp) >= 2 ?
10650	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
10651	                             (long int) PyArray_NDIM(tmp) >= 1 ?
10652	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
10653	                             (long int) PyArray_NDIM(tmp) >= 3 ?
10654	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
10655	                             (long int) PyArray_NDIM(tmp) >= 2 ?
10656	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
10657	                             (long int) PyArray_NDIM(tmp) >= 1 ?
10658	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
10659	            );
10660	                {
10661	        __failure = 168;
10662	        if (!PyErr_Occurred()) {
10663	            PyErr_SetString(PyExc_RuntimeError,
10664	                "Unexpected error in an Op's C code. "
10665	                "No Python exception was set.");
10666	            }
10667	        goto __label_168;}
10668	            }
10669	            // This is a TypeError to be consistent with DEBUG_MODE
10670	            // Note: DEBUG_MODE also tells the name of the container
10671	            if (PyArray_TYPE((PyArrayObject*) py_V167) != NPY_FLOAT64) {
10672	                PyErr_Format(PyExc_TypeError,
10673	                             "expected type_num %d (NPY_FLOAT64) got %d",
10674	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V167));
10675	                {
10676	        __failure = 168;
10677	        if (!PyErr_Occurred()) {
10678	            PyErr_SetString(PyExc_RuntimeError,
10679	                "Unexpected error in an Op's C code. "
10680	                "No Python exception was set.");
10681	            }
10682	        goto __label_168;}
10683	            }
10684
10685	        V167 = (PyArrayObject*)(py_V167);
10686	        Py_XINCREF(V167);
10687
10688	{
10689
10690	    py_V169 = PyList_GET_ITEM(storage_V169, 0);
10691	    {Py_XINCREF(py_V169);}
10692
10693	            V169 = NULL;
10694	            if (py_V169 == Py_None) {
10695	                // We can either fail here or set V169 to NULL and rely on Ops
10696	                // using tensors to handle the NULL case, but if they fail to do so
10697	                // they'll end up with nasty segfaults, so this is public service.
10698	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
10699	                {
10700	        __failure = 170;
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_170;}
10707	            }
10708	            if (!PyArray_Check(py_V169)) {
10709	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
10710	                {
10711	        __failure = 170;
10712	        if (!PyErr_Occurred()) {
10713	            PyErr_SetString(PyExc_RuntimeError,
10714	                "Unexpected error in an Op's C code. "
10715	                "No Python exception was set.");
10716	            }
10717	        goto __label_170;}
10718	            }
10719	            // We expect NPY_FLOAT64
10720	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V169)) {
10721	                PyArrayObject * tmp = (PyArrayObject*) py_V169;
10722	                PyErr_Format(PyExc_NotImplementedError,
10723	                             "expected an aligned array of type %ld "
10724	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
10725	                             " with %ld dimensions, with 3 last dims "
10726	                             "%ld, %ld, %ld"
10727	                             " and 3 last strides %ld %ld, %ld.",
10728	                             (long int) NPY_FLOAT64,
10729	                             (long int) PyArray_TYPE((PyArrayObject*) py_V169),
10730	                             (long int) PyArray_NDIM(tmp),
10731	                             (long int) PyArray_NDIM(tmp) >= 3 ?
10732	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
10733	                             (long int) PyArray_NDIM(tmp) >= 2 ?
10734	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
10735	                             (long int) PyArray_NDIM(tmp) >= 1 ?
10736	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
10737	                             (long int) PyArray_NDIM(tmp) >= 3 ?
10738	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
10739	                             (long int) PyArray_NDIM(tmp) >= 2 ?
10740	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
10741	                             (long int) PyArray_NDIM(tmp) >= 1 ?
10742	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
10743	            );
10744	                {
10745	        __failure = 170;
10746	        if (!PyErr_Occurred()) {
10747	            PyErr_SetString(PyExc_RuntimeError,
10748	                "Unexpected error in an Op's C code. "
10749	                "No Python exception was set.");
10750	            }
10751	        goto __label_170;}
10752	            }
10753	            // This is a TypeError to be consistent with DEBUG_MODE
10754	            // Note: DEBUG_MODE also tells the name of the container
10755	            if (PyArray_TYPE((PyArrayObject*) py_V169) != NPY_FLOAT64) {
10756	                PyErr_Format(PyExc_TypeError,
10757	                             "expected type_num %d (NPY_FLOAT64) got %d",
10758	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V169));
10759	                {
10760	        __failure = 170;
10761	        if (!PyErr_Occurred()) {
10762	            PyErr_SetString(PyExc_RuntimeError,
10763	                "Unexpected error in an Op's C code. "
10764	                "No Python exception was set.");
10765	            }
10766	        goto __label_170;}
10767	            }
10768
10769	        V169 = (PyArrayObject*)(py_V169);
10770	        Py_XINCREF(V169);
10771
10772	{
10773
10774	    py_V171 = PyList_GET_ITEM(storage_V171, 0);
10775	    {Py_XINCREF(py_V171);}
10776
10777	            V171 = NULL;
10778	            if (py_V171 == Py_None) {
10779	                // We can either fail here or set V171 to NULL and rely on Ops
10780	                // using tensors to handle the NULL case, but if they fail to do so
10781	                // they'll end up with nasty segfaults, so this is public service.
10782	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
10783	                {
10784	        __failure = 172;
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_172;}
10791	            }
10792	            if (!PyArray_Check(py_V171)) {
10793	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
10794	                {
10795	        __failure = 172;
10796	        if (!PyErr_Occurred()) {
10797	            PyErr_SetString(PyExc_RuntimeError,
10798	                "Unexpected error in an Op's C code. "
10799	                "No Python exception was set.");
10800	            }
10801	        goto __label_172;}
10802	            }
10803	            // We expect NPY_FLOAT64
10804	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V171)) {
10805	                PyArrayObject * tmp = (PyArrayObject*) py_V171;
10806	                PyErr_Format(PyExc_NotImplementedError,
10807	                             "expected an aligned array of type %ld "
10808	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
10809	                             " with %ld dimensions, with 3 last dims "
10810	                             "%ld, %ld, %ld"
10811	                             " and 3 last strides %ld %ld, %ld.",
10812	                             (long int) NPY_FLOAT64,
10813	                             (long int) PyArray_TYPE((PyArrayObject*) py_V171),
10814	                             (long int) PyArray_NDIM(tmp),
10815	                             (long int) PyArray_NDIM(tmp) >= 3 ?
10816	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
10817	                             (long int) PyArray_NDIM(tmp) >= 2 ?
10818	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
10819	                             (long int) PyArray_NDIM(tmp) >= 1 ?
10820	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
10821	                             (long int) PyArray_NDIM(tmp) >= 3 ?
10822	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
10823	                             (long int) PyArray_NDIM(tmp) >= 2 ?
10824	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
10825	                             (long int) PyArray_NDIM(tmp) >= 1 ?
10826	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
10827	            );
10828	                {
10829	        __failure = 172;
10830	        if (!PyErr_Occurred()) {
10831	            PyErr_SetString(PyExc_RuntimeError,
10832	                "Unexpected error in an Op's C code. "
10833	                "No Python exception was set.");
10834	            }
10835	        goto __label_172;}
10836	            }
10837	            // This is a TypeError to be consistent with DEBUG_MODE
10838	            // Note: DEBUG_MODE also tells the name of the container
10839	            if (PyArray_TYPE((PyArrayObject*) py_V171) != NPY_FLOAT64) {
10840	                PyErr_Format(PyExc_TypeError,
10841	                             "expected type_num %d (NPY_FLOAT64) got %d",
10842	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V171));
10843	                {
10844	        __failure = 172;
10845	        if (!PyErr_Occurred()) {
10846	            PyErr_SetString(PyExc_RuntimeError,
10847	                "Unexpected error in an Op's C code. "
10848	                "No Python exception was set.");
10849	            }
10850	        goto __label_172;}
10851	            }
10852
10853	        V171 = (PyArrayObject*)(py_V171);
10854	        Py_XINCREF(V171);
10855
10856	{
10857
10858	    py_V173 = PyList_GET_ITEM(storage_V173, 0);
10859	    {Py_XINCREF(py_V173);}
10860
10861	            V173 = NULL;
10862	            if (py_V173 == Py_None) {
10863	                // We can either fail here or set V173 to NULL and rely on Ops
10864	                // using tensors to handle the NULL case, but if they fail to do so
10865	                // they'll end up with nasty segfaults, so this is public service.
10866	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
10867	                {
10868	        __failure = 174;
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_174;}
10875	            }
10876	            if (!PyArray_Check(py_V173)) {
10877	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
10878	                {
10879	        __failure = 174;
10880	        if (!PyErr_Occurred()) {
10881	            PyErr_SetString(PyExc_RuntimeError,
10882	                "Unexpected error in an Op's C code. "
10883	                "No Python exception was set.");
10884	            }
10885	        goto __label_174;}
10886	            }
10887	            // We expect NPY_FLOAT64
10888	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V173)) {
10889	                PyArrayObject * tmp = (PyArrayObject*) py_V173;
10890	                PyErr_Format(PyExc_NotImplementedError,
10891	                             "expected an aligned array of type %ld "
10892	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
10893	                             " with %ld dimensions, with 3 last dims "
10894	                             "%ld, %ld, %ld"
10895	                             " and 3 last strides %ld %ld, %ld.",
10896	                             (long int) NPY_FLOAT64,
10897	                             (long int) PyArray_TYPE((PyArrayObject*) py_V173),
10898	                             (long int) PyArray_NDIM(tmp),
10899	                             (long int) PyArray_NDIM(tmp) >= 3 ?
10900	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
10901	                             (long int) PyArray_NDIM(tmp) >= 2 ?
10902	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
10903	                             (long int) PyArray_NDIM(tmp) >= 1 ?
10904	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
10905	                             (long int) PyArray_NDIM(tmp) >= 3 ?
10906	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
10907	                             (long int) PyArray_NDIM(tmp) >= 2 ?
10908	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
10909	                             (long int) PyArray_NDIM(tmp) >= 1 ?
10910	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
10911	            );
10912	                {
10913	        __failure = 174;
10914	        if (!PyErr_Occurred()) {
10915	            PyErr_SetString(PyExc_RuntimeError,
10916	                "Unexpected error in an Op's C code. "
10917	                "No Python exception was set.");
10918	            }
10919	        goto __label_174;}
10920	            }
10921	            // This is a TypeError to be consistent with DEBUG_MODE
10922	            // Note: DEBUG_MODE also tells the name of the container
10923	            if (PyArray_TYPE((PyArrayObject*) py_V173) != NPY_FLOAT64) {
10924	                PyErr_Format(PyExc_TypeError,
10925	                             "expected type_num %d (NPY_FLOAT64) got %d",
10926	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V173));
10927	                {
10928	        __failure = 174;
10929	        if (!PyErr_Occurred()) {
10930	            PyErr_SetString(PyExc_RuntimeError,
10931	                "Unexpected error in an Op's C code. "
10932	                "No Python exception was set.");
10933	            }
10934	        goto __label_174;}
10935	            }
10936
10937	        V173 = (PyArrayObject*)(py_V173);
10938	        Py_XINCREF(V173);
10939
10940	{
10941
10942	    py_V175 = PyList_GET_ITEM(storage_V175, 0);
10943	    {Py_XINCREF(py_V175);}
10944
10945	            V175 = NULL;
10946	            if (py_V175 == Py_None) {
10947	                // We can either fail here or set V175 to NULL and rely on Ops
10948	                // using tensors to handle the NULL case, but if they fail to do so
10949	                // they'll end up with nasty segfaults, so this is public service.
10950	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
10951	                {
10952	        __failure = 176;
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_176;}
10959	            }
10960	            if (!PyArray_Check(py_V175)) {
10961	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
10962	                {
10963	        __failure = 176;
10964	        if (!PyErr_Occurred()) {
10965	            PyErr_SetString(PyExc_RuntimeError,
10966	                "Unexpected error in an Op's C code. "
10967	                "No Python exception was set.");
10968	            }
10969	        goto __label_176;}
10970	            }
10971	            // We expect NPY_INT8
10972	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V175)) {
10973	                PyArrayObject * tmp = (PyArrayObject*) py_V175;
10974	                PyErr_Format(PyExc_NotImplementedError,
10975	                             "expected an aligned array of type %ld "
10976	                             "(NPY_INT8), got non-aligned array of type %ld"
10977	                             " with %ld dimensions, with 3 last dims "
10978	                             "%ld, %ld, %ld"
10979	                             " and 3 last strides %ld %ld, %ld.",
10980	                             (long int) NPY_INT8,
10981	                             (long int) PyArray_TYPE((PyArrayObject*) py_V175),
10982	                             (long int) PyArray_NDIM(tmp),
10983	                             (long int) PyArray_NDIM(tmp) >= 3 ?
10984	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
10985	                             (long int) PyArray_NDIM(tmp) >= 2 ?
10986	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
10987	                             (long int) PyArray_NDIM(tmp) >= 1 ?
10988	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
10989	                             (long int) PyArray_NDIM(tmp) >= 3 ?
10990	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
10991	                             (long int) PyArray_NDIM(tmp) >= 2 ?
10992	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
10993	                             (long int) PyArray_NDIM(tmp) >= 1 ?
10994	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
10995	            );
10996	                {
10997	        __failure = 176;
10998	        if (!PyErr_Occurred()) {
10999	            PyErr_SetString(PyExc_RuntimeError,
11000	                "Unexpected error in an Op's C code. "
11001	                "No Python exception was set.");
11002	            }
11003	        goto __label_176;}
11004	            }
11005	            // This is a TypeError to be consistent with DEBUG_MODE
11006	            // Note: DEBUG_MODE also tells the name of the container
11007	            if (PyArray_TYPE((PyArrayObject*) py_V175) != NPY_INT8) {
11008	                PyErr_Format(PyExc_TypeError,
11009	                             "expected type_num %d (NPY_INT8) got %d",
11010	                             NPY_INT8, PyArray_TYPE((PyArrayObject*) py_V175));
11011	                {
11012	        __failure = 176;
11013	        if (!PyErr_Occurred()) {
11014	            PyErr_SetString(PyExc_RuntimeError,
11015	                "Unexpected error in an Op's C code. "
11016	                "No Python exception was set.");
11017	            }
11018	        goto __label_176;}
11019	            }
11020
11021	        V175 = (PyArrayObject*)(py_V175);
11022	        Py_XINCREF(V175);
11023
11024	{
11025
11026	    py_V177 = PyList_GET_ITEM(storage_V177, 0);
11027	    {Py_XINCREF(py_V177);}
11028
11029	            V177 = NULL;
11030	            if (py_V177 == Py_None) {
11031	                // We can either fail here or set V177 to NULL and rely on Ops
11032	                // using tensors to handle the NULL case, but if they fail to do so
11033	                // they'll end up with nasty segfaults, so this is public service.
11034	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
11035	                {
11036	        __failure = 178;
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_178;}
11043	            }
11044	            if (!PyArray_Check(py_V177)) {
11045	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
11046	                {
11047	        __failure = 178;
11048	        if (!PyErr_Occurred()) {
11049	            PyErr_SetString(PyExc_RuntimeError,
11050	                "Unexpected error in an Op's C code. "
11051	                "No Python exception was set.");
11052	            }
11053	        goto __label_178;}
11054	            }
11055	            // We expect NPY_FLOAT64
11056	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V177)) {
11057	                PyArrayObject * tmp = (PyArrayObject*) py_V177;
11058	                PyErr_Format(PyExc_NotImplementedError,
11059	                             "expected an aligned array of type %ld "
11060	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
11061	                             " with %ld dimensions, with 3 last dims "
11062	                             "%ld, %ld, %ld"
11063	                             " and 3 last strides %ld %ld, %ld.",
11064	                             (long int) NPY_FLOAT64,
11065	                             (long int) PyArray_TYPE((PyArrayObject*) py_V177),
11066	                             (long int) PyArray_NDIM(tmp),
11067	                             (long int) PyArray_NDIM(tmp) >= 3 ?
11068	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
11069	                             (long int) PyArray_NDIM(tmp) >= 2 ?
11070	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
11071	                             (long int) PyArray_NDIM(tmp) >= 1 ?
11072	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
11073	                             (long int) PyArray_NDIM(tmp) >= 3 ?
11074	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
11075	                             (long int) PyArray_NDIM(tmp) >= 2 ?
11076	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
11077	                             (long int) PyArray_NDIM(tmp) >= 1 ?
11078	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
11079	            );
11080	                {
11081	        __failure = 178;
11082	        if (!PyErr_Occurred()) {
11083	            PyErr_SetString(PyExc_RuntimeError,
11084	                "Unexpected error in an Op's C code. "
11085	                "No Python exception was set.");
11086	            }
11087	        goto __label_178;}
11088	            }
11089	            // This is a TypeError to be consistent with DEBUG_MODE
11090	            // Note: DEBUG_MODE also tells the name of the container
11091	            if (PyArray_TYPE((PyArrayObject*) py_V177) != NPY_FLOAT64) {
11092	                PyErr_Format(PyExc_TypeError,
11093	                             "expected type_num %d (NPY_FLOAT64) got %d",
11094	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V177));
11095	                {
11096	        __failure = 178;
11097	        if (!PyErr_Occurred()) {
11098	            PyErr_SetString(PyExc_RuntimeError,
11099	                "Unexpected error in an Op's C code. "
11100	                "No Python exception was set.");
11101	            }
11102	        goto __label_178;}
11103	            }
11104
11105	        V177 = (PyArrayObject*)(py_V177);
11106	        Py_XINCREF(V177);
11107
11108	{
11109
11110	    py_V179 = PyList_GET_ITEM(storage_V179, 0);
11111	    {Py_XINCREF(py_V179);}
11112
11113	            V179 = NULL;
11114	            if (py_V179 == Py_None) {
11115	                // We can either fail here or set V179 to NULL and rely on Ops
11116	                // using tensors to handle the NULL case, but if they fail to do so
11117	                // they'll end up with nasty segfaults, so this is public service.
11118	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
11119	                {
11120	        __failure = 180;
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_180;}
11127	            }
11128	            if (!PyArray_Check(py_V179)) {
11129	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
11130	                {
11131	        __failure = 180;
11132	        if (!PyErr_Occurred()) {
11133	            PyErr_SetString(PyExc_RuntimeError,
11134	                "Unexpected error in an Op's C code. "
11135	                "No Python exception was set.");
11136	            }
11137	        goto __label_180;}
11138	            }
11139	            // We expect NPY_FLOAT64
11140	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V179)) {
11141	                PyArrayObject * tmp = (PyArrayObject*) py_V179;
11142	                PyErr_Format(PyExc_NotImplementedError,
11143	                             "expected an aligned array of type %ld "
11144	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
11145	                             " with %ld dimensions, with 3 last dims "
11146	                             "%ld, %ld, %ld"
11147	                             " and 3 last strides %ld %ld, %ld.",
11148	                             (long int) NPY_FLOAT64,
11149	                             (long int) PyArray_TYPE((PyArrayObject*) py_V179),
11150	                             (long int) PyArray_NDIM(tmp),
11151	                             (long int) PyArray_NDIM(tmp) >= 3 ?
11152	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
11153	                             (long int) PyArray_NDIM(tmp) >= 2 ?
11154	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
11155	                             (long int) PyArray_NDIM(tmp) >= 1 ?
11156	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
11157	                             (long int) PyArray_NDIM(tmp) >= 3 ?
11158	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
11159	                             (long int) PyArray_NDIM(tmp) >= 2 ?
11160	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
11161	                             (long int) PyArray_NDIM(tmp) >= 1 ?
11162	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
11163	            );
11164	                {
11165	        __failure = 180;
11166	        if (!PyErr_Occurred()) {
11167	            PyErr_SetString(PyExc_RuntimeError,
11168	                "Unexpected error in an Op's C code. "
11169	                "No Python exception was set.");
11170	            }
11171	        goto __label_180;}
11172	            }
11173	            // This is a TypeError to be consistent with DEBUG_MODE
11174	            // Note: DEBUG_MODE also tells the name of the container
11175	            if (PyArray_TYPE((PyArrayObject*) py_V179) != NPY_FLOAT64) {
11176	                PyErr_Format(PyExc_TypeError,
11177	                             "expected type_num %d (NPY_FLOAT64) got %d",
11178	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V179));
11179	                {
11180	        __failure = 180;
11181	        if (!PyErr_Occurred()) {
11182	            PyErr_SetString(PyExc_RuntimeError,
11183	                "Unexpected error in an Op's C code. "
11184	                "No Python exception was set.");
11185	            }
11186	        goto __label_180;}
11187	            }
11188
11189	        V179 = (PyArrayObject*)(py_V179);
11190	        Py_XINCREF(V179);
11191
11192	{
11193
11194	    py_V181 = PyList_GET_ITEM(storage_V181, 0);
11195	    {Py_XINCREF(py_V181);}
11196
11197	            V181 = NULL;
11198	            if (py_V181 == Py_None) {
11199	                // We can either fail here or set V181 to NULL and rely on Ops
11200	                // using tensors to handle the NULL case, but if they fail to do so
11201	                // they'll end up with nasty segfaults, so this is public service.
11202	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
11203	                {
11204	        __failure = 182;
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_182;}
11211	            }
11212	            if (!PyArray_Check(py_V181)) {
11213	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
11214	                {
11215	        __failure = 182;
11216	        if (!PyErr_Occurred()) {
11217	            PyErr_SetString(PyExc_RuntimeError,
11218	                "Unexpected error in an Op's C code. "
11219	                "No Python exception was set.");
11220	            }
11221	        goto __label_182;}
11222	            }
11223	            // We expect NPY_FLOAT64
11224	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V181)) {
11225	                PyArrayObject * tmp = (PyArrayObject*) py_V181;
11226	                PyErr_Format(PyExc_NotImplementedError,
11227	                             "expected an aligned array of type %ld "
11228	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
11229	                             " with %ld dimensions, with 3 last dims "
11230	                             "%ld, %ld, %ld"
11231	                             " and 3 last strides %ld %ld, %ld.",
11232	                             (long int) NPY_FLOAT64,
11233	                             (long int) PyArray_TYPE((PyArrayObject*) py_V181),
11234	                             (long int) PyArray_NDIM(tmp),
11235	                             (long int) PyArray_NDIM(tmp) >= 3 ?
11236	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
11237	                             (long int) PyArray_NDIM(tmp) >= 2 ?
11238	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
11239	                             (long int) PyArray_NDIM(tmp) >= 1 ?
11240	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
11241	                             (long int) PyArray_NDIM(tmp) >= 3 ?
11242	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
11243	                             (long int) PyArray_NDIM(tmp) >= 2 ?
11244	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
11245	                             (long int) PyArray_NDIM(tmp) >= 1 ?
11246	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
11247	            );
11248	                {
11249	        __failure = 182;
11250	        if (!PyErr_Occurred()) {
11251	            PyErr_SetString(PyExc_RuntimeError,
11252	                "Unexpected error in an Op's C code. "
11253	                "No Python exception was set.");
11254	            }
11255	        goto __label_182;}
11256	            }
11257	            // This is a TypeError to be consistent with DEBUG_MODE
11258	            // Note: DEBUG_MODE also tells the name of the container
11259	            if (PyArray_TYPE((PyArrayObject*) py_V181) != NPY_FLOAT64) {
11260	                PyErr_Format(PyExc_TypeError,
11261	                             "expected type_num %d (NPY_FLOAT64) got %d",
11262	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V181));
11263	                {
11264	        __failure = 182;
11265	        if (!PyErr_Occurred()) {
11266	            PyErr_SetString(PyExc_RuntimeError,
11267	                "Unexpected error in an Op's C code. "
11268	                "No Python exception was set.");
11269	            }
11270	        goto __label_182;}
11271	            }
11272
11273	        V181 = (PyArrayObject*)(py_V181);
11274	        Py_XINCREF(V181);
11275
11276	{
11277
11278	    py_V183 = PyList_GET_ITEM(storage_V183, 0);
11279	    {Py_XINCREF(py_V183);}
11280
11281	            V183 = NULL;
11282	            if (py_V183 == Py_None) {
11283	                // We can either fail here or set V183 to NULL and rely on Ops
11284	                // using tensors to handle the NULL case, but if they fail to do so
11285	                // they'll end up with nasty segfaults, so this is public service.
11286	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
11287	                {
11288	        __failure = 184;
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_184;}
11295	            }
11296	            if (!PyArray_Check(py_V183)) {
11297	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
11298	                {
11299	        __failure = 184;
11300	        if (!PyErr_Occurred()) {
11301	            PyErr_SetString(PyExc_RuntimeError,
11302	                "Unexpected error in an Op's C code. "
11303	                "No Python exception was set.");
11304	            }
11305	        goto __label_184;}
11306	            }
11307	            // We expect NPY_FLOAT64
11308	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V183)) {
11309	                PyArrayObject * tmp = (PyArrayObject*) py_V183;
11310	                PyErr_Format(PyExc_NotImplementedError,
11311	                             "expected an aligned array of type %ld "
11312	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
11313	                             " with %ld dimensions, with 3 last dims "
11314	                             "%ld, %ld, %ld"
11315	                             " and 3 last strides %ld %ld, %ld.",
11316	                             (long int) NPY_FLOAT64,
11317	                             (long int) PyArray_TYPE((PyArrayObject*) py_V183),
11318	                             (long int) PyArray_NDIM(tmp),
11319	                             (long int) PyArray_NDIM(tmp) >= 3 ?
11320	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
11321	                             (long int) PyArray_NDIM(tmp) >= 2 ?
11322	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
11323	                             (long int) PyArray_NDIM(tmp) >= 1 ?
11324	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
11325	                             (long int) PyArray_NDIM(tmp) >= 3 ?
11326	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
11327	                             (long int) PyArray_NDIM(tmp) >= 2 ?
11328	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
11329	                             (long int) PyArray_NDIM(tmp) >= 1 ?
11330	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
11331	            );
11332	                {
11333	        __failure = 184;
11334	        if (!PyErr_Occurred()) {
11335	            PyErr_SetString(PyExc_RuntimeError,
11336	                "Unexpected error in an Op's C code. "
11337	                "No Python exception was set.");
11338	            }
11339	        goto __label_184;}
11340	            }
11341	            // This is a TypeError to be consistent with DEBUG_MODE
11342	            // Note: DEBUG_MODE also tells the name of the container
11343	            if (PyArray_TYPE((PyArrayObject*) py_V183) != NPY_FLOAT64) {
11344	                PyErr_Format(PyExc_TypeError,
11345	                             "expected type_num %d (NPY_FLOAT64) got %d",
11346	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V183));
11347	                {
11348	        __failure = 184;
11349	        if (!PyErr_Occurred()) {
11350	            PyErr_SetString(PyExc_RuntimeError,
11351	                "Unexpected error in an Op's C code. "
11352	                "No Python exception was set.");
11353	            }
11354	        goto __label_184;}
11355	            }
11356
11357	        V183 = (PyArrayObject*)(py_V183);
11358	        Py_XINCREF(V183);
11359
11360	{
11361
11362	    py_V185 = PyList_GET_ITEM(storage_V185, 0);
11363	    {Py_XINCREF(py_V185);}
11364
11365	            V185 = NULL;
11366	            if (py_V185 == Py_None) {
11367	                // We can either fail here or set V185 to NULL and rely on Ops
11368	                // using tensors to handle the NULL case, but if they fail to do so
11369	                // they'll end up with nasty segfaults, so this is public service.
11370	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
11371	                {
11372	        __failure = 186;
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_186;}
11379	            }
11380	            if (!PyArray_Check(py_V185)) {
11381	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
11382	                {
11383	        __failure = 186;
11384	        if (!PyErr_Occurred()) {
11385	            PyErr_SetString(PyExc_RuntimeError,
11386	                "Unexpected error in an Op's C code. "
11387	                "No Python exception was set.");
11388	            }
11389	        goto __label_186;}
11390	            }
11391	            // We expect NPY_FLOAT64
11392	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V185)) {
11393	                PyArrayObject * tmp = (PyArrayObject*) py_V185;
11394	                PyErr_Format(PyExc_NotImplementedError,
11395	                             "expected an aligned array of type %ld "
11396	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
11397	                             " with %ld dimensions, with 3 last dims "
11398	                             "%ld, %ld, %ld"
11399	                             " and 3 last strides %ld %ld, %ld.",
11400	                             (long int) NPY_FLOAT64,
11401	                             (long int) PyArray_TYPE((PyArrayObject*) py_V185),
11402	                             (long int) PyArray_NDIM(tmp),
11403	                             (long int) PyArray_NDIM(tmp) >= 3 ?
11404	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
11405	                             (long int) PyArray_NDIM(tmp) >= 2 ?
11406	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
11407	                             (long int) PyArray_NDIM(tmp) >= 1 ?
11408	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
11409	                             (long int) PyArray_NDIM(tmp) >= 3 ?
11410	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
11411	                             (long int) PyArray_NDIM(tmp) >= 2 ?
11412	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
11413	                             (long int) PyArray_NDIM(tmp) >= 1 ?
11414	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
11415	            );
11416	                {
11417	        __failure = 186;
11418	        if (!PyErr_Occurred()) {
11419	            PyErr_SetString(PyExc_RuntimeError,
11420	                "Unexpected error in an Op's C code. "
11421	                "No Python exception was set.");
11422	            }
11423	        goto __label_186;}
11424	            }
11425	            // This is a TypeError to be consistent with DEBUG_MODE
11426	            // Note: DEBUG_MODE also tells the name of the container
11427	            if (PyArray_TYPE((PyArrayObject*) py_V185) != NPY_FLOAT64) {
11428	                PyErr_Format(PyExc_TypeError,
11429	                             "expected type_num %d (NPY_FLOAT64) got %d",
11430	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V185));
11431	                {
11432	        __failure = 186;
11433	        if (!PyErr_Occurred()) {
11434	            PyErr_SetString(PyExc_RuntimeError,
11435	                "Unexpected error in an Op's C code. "
11436	                "No Python exception was set.");
11437	            }
11438	        goto __label_186;}
11439	            }
11440
11441	        V185 = (PyArrayObject*)(py_V185);
11442	        Py_XINCREF(V185);
11443
11444	{
11445
11446	    py_V187 = PyList_GET_ITEM(storage_V187, 0);
11447	    {Py_XINCREF(py_V187);}
11448
11449	            V187 = NULL;
11450	            if (py_V187 == Py_None) {
11451	                // We can either fail here or set V187 to NULL and rely on Ops
11452	                // using tensors to handle the NULL case, but if they fail to do so
11453	                // they'll end up with nasty segfaults, so this is public service.
11454	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
11455	                {
11456	        __failure = 188;
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_188;}
11463	            }
11464	            if (!PyArray_Check(py_V187)) {
11465	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
11466	                {
11467	        __failure = 188;
11468	        if (!PyErr_Occurred()) {
11469	            PyErr_SetString(PyExc_RuntimeError,
11470	                "Unexpected error in an Op's C code. "
11471	                "No Python exception was set.");
11472	            }
11473	        goto __label_188;}
11474	            }
11475	            // We expect NPY_FLOAT64
11476	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V187)) {
11477	                PyArrayObject * tmp = (PyArrayObject*) py_V187;
11478	                PyErr_Format(PyExc_NotImplementedError,
11479	                             "expected an aligned array of type %ld "
11480	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
11481	                             " with %ld dimensions, with 3 last dims "
11482	                             "%ld, %ld, %ld"
11483	                             " and 3 last strides %ld %ld, %ld.",
11484	                             (long int) NPY_FLOAT64,
11485	                             (long int) PyArray_TYPE((PyArrayObject*) py_V187),
11486	                             (long int) PyArray_NDIM(tmp),
11487	                             (long int) PyArray_NDIM(tmp) >= 3 ?
11488	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
11489	                             (long int) PyArray_NDIM(tmp) >= 2 ?
11490	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
11491	                             (long int) PyArray_NDIM(tmp) >= 1 ?
11492	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
11493	                             (long int) PyArray_NDIM(tmp) >= 3 ?
11494	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
11495	                             (long int) PyArray_NDIM(tmp) >= 2 ?
11496	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
11497	                             (long int) PyArray_NDIM(tmp) >= 1 ?
11498	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
11499	            );
11500	                {
11501	        __failure = 188;
11502	        if (!PyErr_Occurred()) {
11503	            PyErr_SetString(PyExc_RuntimeError,
11504	                "Unexpected error in an Op's C code. "
11505	                "No Python exception was set.");
11506	            }
11507	        goto __label_188;}
11508	            }
11509	            // This is a TypeError to be consistent with DEBUG_MODE
11510	            // Note: DEBUG_MODE also tells the name of the container
11511	            if (PyArray_TYPE((PyArrayObject*) py_V187) != NPY_FLOAT64) {
11512	                PyErr_Format(PyExc_TypeError,
11513	                             "expected type_num %d (NPY_FLOAT64) got %d",
11514	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V187));
11515	                {
11516	        __failure = 188;
11517	        if (!PyErr_Occurred()) {
11518	            PyErr_SetString(PyExc_RuntimeError,
11519	                "Unexpected error in an Op's C code. "
11520	                "No Python exception was set.");
11521	            }
11522	        goto __label_188;}
11523	            }
11524
11525	        V187 = (PyArrayObject*)(py_V187);
11526	        Py_XINCREF(V187);
11527
11528	{
11529
11530	    py_V189 = PyList_GET_ITEM(storage_V189, 0);
11531	    {Py_XINCREF(py_V189);}
11532
11533	            V189 = NULL;
11534	            if (py_V189 == Py_None) {
11535	                // We can either fail here or set V189 to NULL and rely on Ops
11536	                // using tensors to handle the NULL case, but if they fail to do so
11537	                // they'll end up with nasty segfaults, so this is public service.
11538	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
11539	                {
11540	        __failure = 190;
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_190;}
11547	            }
11548	            if (!PyArray_Check(py_V189)) {
11549	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
11550	                {
11551	        __failure = 190;
11552	        if (!PyErr_Occurred()) {
11553	            PyErr_SetString(PyExc_RuntimeError,
11554	                "Unexpected error in an Op's C code. "
11555	                "No Python exception was set.");
11556	            }
11557	        goto __label_190;}
11558	            }
11559	            // We expect NPY_INT8
11560	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V189)) {
11561	                PyArrayObject * tmp = (PyArrayObject*) py_V189;
11562	                PyErr_Format(PyExc_NotImplementedError,
11563	                             "expected an aligned array of type %ld "
11564	                             "(NPY_INT8), got non-aligned array of type %ld"
11565	                             " with %ld dimensions, with 3 last dims "
11566	                             "%ld, %ld, %ld"
11567	                             " and 3 last strides %ld %ld, %ld.",
11568	                             (long int) NPY_INT8,
11569	                             (long int) PyArray_TYPE((PyArrayObject*) py_V189),
11570	                             (long int) PyArray_NDIM(tmp),
11571	                             (long int) PyArray_NDIM(tmp) >= 3 ?
11572	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
11573	                             (long int) PyArray_NDIM(tmp) >= 2 ?
11574	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
11575	                             (long int) PyArray_NDIM(tmp) >= 1 ?
11576	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
11577	                             (long int) PyArray_NDIM(tmp) >= 3 ?
11578	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
11579	                             (long int) PyArray_NDIM(tmp) >= 2 ?
11580	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
11581	                             (long int) PyArray_NDIM(tmp) >= 1 ?
11582	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
11583	            );
11584	                {
11585	        __failure = 190;
11586	        if (!PyErr_Occurred()) {
11587	            PyErr_SetString(PyExc_RuntimeError,
11588	                "Unexpected error in an Op's C code. "
11589	                "No Python exception was set.");
11590	            }
11591	        goto __label_190;}
11592	            }
11593	            // This is a TypeError to be consistent with DEBUG_MODE
11594	            // Note: DEBUG_MODE also tells the name of the container
11595	            if (PyArray_TYPE((PyArrayObject*) py_V189) != NPY_INT8) {
11596	                PyErr_Format(PyExc_TypeError,
11597	                             "expected type_num %d (NPY_INT8) got %d",
11598	                             NPY_INT8, PyArray_TYPE((PyArrayObject*) py_V189));
11599	                {
11600	        __failure = 190;
11601	        if (!PyErr_Occurred()) {
11602	            PyErr_SetString(PyExc_RuntimeError,
11603	                "Unexpected error in an Op's C code. "
11604	                "No Python exception was set.");
11605	            }
11606	        goto __label_190;}
11607	            }
11608
11609	        V189 = (PyArrayObject*)(py_V189);
11610	        Py_XINCREF(V189);
11611
11612	{
11613
11614	    py_V191 = PyList_GET_ITEM(storage_V191, 0);
11615	    {Py_XINCREF(py_V191);}
11616
11617	            V191 = NULL;
11618	            if (py_V191 == Py_None) {
11619	                // We can either fail here or set V191 to NULL and rely on Ops
11620	                // using tensors to handle the NULL case, but if they fail to do so
11621	                // they'll end up with nasty segfaults, so this is public service.
11622	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
11623	                {
11624	        __failure = 192;
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_192;}
11631	            }
11632	            if (!PyArray_Check(py_V191)) {
11633	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
11634	                {
11635	        __failure = 192;
11636	        if (!PyErr_Occurred()) {
11637	            PyErr_SetString(PyExc_RuntimeError,
11638	                "Unexpected error in an Op's C code. "
11639	                "No Python exception was set.");
11640	            }
11641	        goto __label_192;}
11642	            }
11643	            // We expect NPY_FLOAT64
11644	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V191)) {
11645	                PyArrayObject * tmp = (PyArrayObject*) py_V191;
11646	                PyErr_Format(PyExc_NotImplementedError,
11647	                             "expected an aligned array of type %ld "
11648	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
11649	                             " with %ld dimensions, with 3 last dims "
11650	                             "%ld, %ld, %ld"
11651	                             " and 3 last strides %ld %ld, %ld.",
11652	                             (long int) NPY_FLOAT64,
11653	                             (long int) PyArray_TYPE((PyArrayObject*) py_V191),
11654	                             (long int) PyArray_NDIM(tmp),
11655	                             (long int) PyArray_NDIM(tmp) >= 3 ?
11656	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
11657	                             (long int) PyArray_NDIM(tmp) >= 2 ?
11658	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
11659	                             (long int) PyArray_NDIM(tmp) >= 1 ?
11660	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
11661	                             (long int) PyArray_NDIM(tmp) >= 3 ?
11662	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
11663	                             (long int) PyArray_NDIM(tmp) >= 2 ?
11664	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
11665	                             (long int) PyArray_NDIM(tmp) >= 1 ?
11666	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
11667	            );
11668	                {
11669	        __failure = 192;
11670	        if (!PyErr_Occurred()) {
11671	            PyErr_SetString(PyExc_RuntimeError,
11672	                "Unexpected error in an Op's C code. "
11673	                "No Python exception was set.");
11674	            }
11675	        goto __label_192;}
11676	            }
11677	            // This is a TypeError to be consistent with DEBUG_MODE
11678	            // Note: DEBUG_MODE also tells the name of the container
11679	            if (PyArray_TYPE((PyArrayObject*) py_V191) != NPY_FLOAT64) {
11680	                PyErr_Format(PyExc_TypeError,
11681	                             "expected type_num %d (NPY_FLOAT64) got %d",
11682	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V191));
11683	                {
11684	        __failure = 192;
11685	        if (!PyErr_Occurred()) {
11686	            PyErr_SetString(PyExc_RuntimeError,
11687	                "Unexpected error in an Op's C code. "
11688	                "No Python exception was set.");
11689	            }
11690	        goto __label_192;}
11691	            }
11692
11693	        V191 = (PyArrayObject*)(py_V191);
11694	        Py_XINCREF(V191);
11695
11696	{
11697
11698	    py_V193 = PyList_GET_ITEM(storage_V193, 0);
11699	    {Py_XINCREF(py_V193);}
11700
11701	            V193 = NULL;
11702	            if (py_V193 == Py_None) {
11703	                // We can either fail here or set V193 to NULL and rely on Ops
11704	                // using tensors to handle the NULL case, but if they fail to do so
11705	                // they'll end up with nasty segfaults, so this is public service.
11706	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
11707	                {
11708	        __failure = 194;
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_194;}
11715	            }
11716	            if (!PyArray_Check(py_V193)) {
11717	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
11718	                {
11719	        __failure = 194;
11720	        if (!PyErr_Occurred()) {
11721	            PyErr_SetString(PyExc_RuntimeError,
11722	                "Unexpected error in an Op's C code. "
11723	                "No Python exception was set.");
11724	            }
11725	        goto __label_194;}
11726	            }
11727	            // We expect NPY_FLOAT64
11728	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V193)) {
11729	                PyArrayObject * tmp = (PyArrayObject*) py_V193;
11730	                PyErr_Format(PyExc_NotImplementedError,
11731	                             "expected an aligned array of type %ld "
11732	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
11733	                             " with %ld dimensions, with 3 last dims "
11734	                             "%ld, %ld, %ld"
11735	                             " and 3 last strides %ld %ld, %ld.",
11736	                             (long int) NPY_FLOAT64,
11737	                             (long int) PyArray_TYPE((PyArrayObject*) py_V193),
11738	                             (long int) PyArray_NDIM(tmp),
11739	                             (long int) PyArray_NDIM(tmp) >= 3 ?
11740	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
11741	                             (long int) PyArray_NDIM(tmp) >= 2 ?
11742	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
11743	                             (long int) PyArray_NDIM(tmp) >= 1 ?
11744	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
11745	                             (long int) PyArray_NDIM(tmp) >= 3 ?
11746	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
11747	                             (long int) PyArray_NDIM(tmp) >= 2 ?
11748	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
11749	                             (long int) PyArray_NDIM(tmp) >= 1 ?
11750	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
11751	            );
11752	                {
11753	        __failure = 194;
11754	        if (!PyErr_Occurred()) {
11755	            PyErr_SetString(PyExc_RuntimeError,
11756	                "Unexpected error in an Op's C code. "
11757	                "No Python exception was set.");
11758	            }
11759	        goto __label_194;}
11760	            }
11761	            // This is a TypeError to be consistent with DEBUG_MODE
11762	            // Note: DEBUG_MODE also tells the name of the container
11763	            if (PyArray_TYPE((PyArrayObject*) py_V193) != NPY_FLOAT64) {
11764	                PyErr_Format(PyExc_TypeError,
11765	                             "expected type_num %d (NPY_FLOAT64) got %d",
11766	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V193));
11767	                {
11768	        __failure = 194;
11769	        if (!PyErr_Occurred()) {
11770	            PyErr_SetString(PyExc_RuntimeError,
11771	                "Unexpected error in an Op's C code. "
11772	                "No Python exception was set.");
11773	            }
11774	        goto __label_194;}
11775	            }
11776
11777	        V193 = (PyArrayObject*)(py_V193);
11778	        Py_XINCREF(V193);
11779
11780	{
11781
11782	    py_V195 = PyList_GET_ITEM(storage_V195, 0);
11783	    {Py_XINCREF(py_V195);}
11784
11785	            V195 = NULL;
11786	            if (py_V195 == Py_None) {
11787	                // We can either fail here or set V195 to NULL and rely on Ops
11788	                // using tensors to handle the NULL case, but if they fail to do so
11789	                // they'll end up with nasty segfaults, so this is public service.
11790	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
11791	                {
11792	        __failure = 196;
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_196;}
11799	            }
11800	            if (!PyArray_Check(py_V195)) {
11801	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
11802	                {
11803	        __failure = 196;
11804	        if (!PyErr_Occurred()) {
11805	            PyErr_SetString(PyExc_RuntimeError,
11806	                "Unexpected error in an Op's C code. "
11807	                "No Python exception was set.");
11808	            }
11809	        goto __label_196;}
11810	            }
11811	            // We expect NPY_FLOAT64
11812	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V195)) {
11813	                PyArrayObject * tmp = (PyArrayObject*) py_V195;
11814	                PyErr_Format(PyExc_NotImplementedError,
11815	                             "expected an aligned array of type %ld "
11816	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
11817	                             " with %ld dimensions, with 3 last dims "
11818	                             "%ld, %ld, %ld"
11819	                             " and 3 last strides %ld %ld, %ld.",
11820	                             (long int) NPY_FLOAT64,
11821	                             (long int) PyArray_TYPE((PyArrayObject*) py_V195),
11822	                             (long int) PyArray_NDIM(tmp),
11823	                             (long int) PyArray_NDIM(tmp) >= 3 ?
11824	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
11825	                             (long int) PyArray_NDIM(tmp) >= 2 ?
11826	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
11827	                             (long int) PyArray_NDIM(tmp) >= 1 ?
11828	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
11829	                             (long int) PyArray_NDIM(tmp) >= 3 ?
11830	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
11831	                             (long int) PyArray_NDIM(tmp) >= 2 ?
11832	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
11833	                             (long int) PyArray_NDIM(tmp) >= 1 ?
11834	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
11835	            );
11836	                {
11837	        __failure = 196;
11838	        if (!PyErr_Occurred()) {
11839	            PyErr_SetString(PyExc_RuntimeError,
11840	                "Unexpected error in an Op's C code. "
11841	                "No Python exception was set.");
11842	            }
11843	        goto __label_196;}
11844	            }
11845	            // This is a TypeError to be consistent with DEBUG_MODE
11846	            // Note: DEBUG_MODE also tells the name of the container
11847	            if (PyArray_TYPE((PyArrayObject*) py_V195) != NPY_FLOAT64) {
11848	                PyErr_Format(PyExc_TypeError,
11849	                             "expected type_num %d (NPY_FLOAT64) got %d",
11850	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V195));
11851	                {
11852	        __failure = 196;
11853	        if (!PyErr_Occurred()) {
11854	            PyErr_SetString(PyExc_RuntimeError,
11855	                "Unexpected error in an Op's C code. "
11856	                "No Python exception was set.");
11857	            }
11858	        goto __label_196;}
11859	            }
11860
11861	        V195 = (PyArrayObject*)(py_V195);
11862	        Py_XINCREF(V195);
11863
11864	{
11865
11866	    py_V197 = PyList_GET_ITEM(storage_V197, 0);
11867	    {Py_XINCREF(py_V197);}
11868
11869	            V197 = NULL;
11870	            if (py_V197 == Py_None) {
11871	                // We can either fail here or set V197 to NULL and rely on Ops
11872	                // using tensors to handle the NULL case, but if they fail to do so
11873	                // they'll end up with nasty segfaults, so this is public service.
11874	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
11875	                {
11876	        __failure = 198;
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_198;}
11883	            }
11884	            if (!PyArray_Check(py_V197)) {
11885	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
11886	                {
11887	        __failure = 198;
11888	        if (!PyErr_Occurred()) {
11889	            PyErr_SetString(PyExc_RuntimeError,
11890	                "Unexpected error in an Op's C code. "
11891	                "No Python exception was set.");
11892	            }
11893	        goto __label_198;}
11894	            }
11895	            // We expect NPY_FLOAT64
11896	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V197)) {
11897	                PyArrayObject * tmp = (PyArrayObject*) py_V197;
11898	                PyErr_Format(PyExc_NotImplementedError,
11899	                             "expected an aligned array of type %ld "
11900	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
11901	                             " with %ld dimensions, with 3 last dims "
11902	                             "%ld, %ld, %ld"
11903	                             " and 3 last strides %ld %ld, %ld.",
11904	                             (long int) NPY_FLOAT64,
11905	                             (long int) PyArray_TYPE((PyArrayObject*) py_V197),
11906	                             (long int) PyArray_NDIM(tmp),
11907	                             (long int) PyArray_NDIM(tmp) >= 3 ?
11908	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
11909	                             (long int) PyArray_NDIM(tmp) >= 2 ?
11910	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
11911	                             (long int) PyArray_NDIM(tmp) >= 1 ?
11912	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
11913	                             (long int) PyArray_NDIM(tmp) >= 3 ?
11914	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
11915	                             (long int) PyArray_NDIM(tmp) >= 2 ?
11916	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
11917	                             (long int) PyArray_NDIM(tmp) >= 1 ?
11918	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
11919	            );
11920	                {
11921	        __failure = 198;
11922	        if (!PyErr_Occurred()) {
11923	            PyErr_SetString(PyExc_RuntimeError,
11924	                "Unexpected error in an Op's C code. "
11925	                "No Python exception was set.");
11926	            }
11927	        goto __label_198;}
11928	            }
11929	            // This is a TypeError to be consistent with DEBUG_MODE
11930	            // Note: DEBUG_MODE also tells the name of the container
11931	            if (PyArray_TYPE((PyArrayObject*) py_V197) != NPY_FLOAT64) {
11932	                PyErr_Format(PyExc_TypeError,
11933	                             "expected type_num %d (NPY_FLOAT64) got %d",
11934	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V197));
11935	                {
11936	        __failure = 198;
11937	        if (!PyErr_Occurred()) {
11938	            PyErr_SetString(PyExc_RuntimeError,
11939	                "Unexpected error in an Op's C code. "
11940	                "No Python exception was set.");
11941	            }
11942	        goto __label_198;}
11943	            }
11944
11945	        V197 = (PyArrayObject*)(py_V197);
11946	        Py_XINCREF(V197);
11947
11948	{
11949
11950	    py_V199 = PyList_GET_ITEM(storage_V199, 0);
11951	    {Py_XINCREF(py_V199);}
11952
11953	            V199 = NULL;
11954	            if (py_V199 == Py_None) {
11955	                // We can either fail here or set V199 to NULL and rely on Ops
11956	                // using tensors to handle the NULL case, but if they fail to do so
11957	                // they'll end up with nasty segfaults, so this is public service.
11958	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
11959	                {
11960	        __failure = 200;
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_200;}
11967	            }
11968	            if (!PyArray_Check(py_V199)) {
11969	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
11970	                {
11971	        __failure = 200;
11972	        if (!PyErr_Occurred()) {
11973	            PyErr_SetString(PyExc_RuntimeError,
11974	                "Unexpected error in an Op's C code. "
11975	                "No Python exception was set.");
11976	            }
11977	        goto __label_200;}
11978	            }
11979	            // We expect NPY_FLOAT64
11980	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V199)) {
11981	                PyArrayObject * tmp = (PyArrayObject*) py_V199;
11982	                PyErr_Format(PyExc_NotImplementedError,
11983	                             "expected an aligned array of type %ld "
11984	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
11985	                             " with %ld dimensions, with 3 last dims "
11986	                             "%ld, %ld, %ld"
11987	                             " and 3 last strides %ld %ld, %ld.",
11988	                             (long int) NPY_FLOAT64,
11989	                             (long int) PyArray_TYPE((PyArrayObject*) py_V199),
11990	                             (long int) PyArray_NDIM(tmp),
11991	                             (long int) PyArray_NDIM(tmp) >= 3 ?
11992	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
11993	                             (long int) PyArray_NDIM(tmp) >= 2 ?
11994	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
11995	                             (long int) PyArray_NDIM(tmp) >= 1 ?
11996	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
11997	                             (long int) PyArray_NDIM(tmp) >= 3 ?
11998	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
11999	                             (long int) PyArray_NDIM(tmp) >= 2 ?
12000	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
12001	                             (long int) PyArray_NDIM(tmp) >= 1 ?
12002	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
12003	            );
12004	                {
12005	        __failure = 200;
12006	        if (!PyErr_Occurred()) {
12007	            PyErr_SetString(PyExc_RuntimeError,
12008	                "Unexpected error in an Op's C code. "
12009	                "No Python exception was set.");
12010	            }
12011	        goto __label_200;}
12012	            }
12013	            // This is a TypeError to be consistent with DEBUG_MODE
12014	            // Note: DEBUG_MODE also tells the name of the container
12015	            if (PyArray_TYPE((PyArrayObject*) py_V199) != NPY_FLOAT64) {
12016	                PyErr_Format(PyExc_TypeError,
12017	                             "expected type_num %d (NPY_FLOAT64) got %d",
12018	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V199));
12019	                {
12020	        __failure = 200;
12021	        if (!PyErr_Occurred()) {
12022	            PyErr_SetString(PyExc_RuntimeError,
12023	                "Unexpected error in an Op's C code. "
12024	                "No Python exception was set.");
12025	            }
12026	        goto __label_200;}
12027	            }
12028
12029	        V199 = (PyArrayObject*)(py_V199);
12030	        Py_XINCREF(V199);
12031
12032	{
12033
12034	    py_V201 = PyList_GET_ITEM(storage_V201, 0);
12035	    {Py_XINCREF(py_V201);}
12036
12037	            V201 = NULL;
12038	            if (py_V201 == Py_None) {
12039	                // We can either fail here or set V201 to NULL and rely on Ops
12040	                // using tensors to handle the NULL case, but if they fail to do so
12041	                // they'll end up with nasty segfaults, so this is public service.
12042	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
12043	                {
12044	        __failure = 202;
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_202;}
12051	            }
12052	            if (!PyArray_Check(py_V201)) {
12053	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
12054	                {
12055	        __failure = 202;
12056	        if (!PyErr_Occurred()) {
12057	            PyErr_SetString(PyExc_RuntimeError,
12058	                "Unexpected error in an Op's C code. "
12059	                "No Python exception was set.");
12060	            }
12061	        goto __label_202;}
12062	            }
12063	            // We expect NPY_FLOAT64
12064	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V201)) {
12065	                PyArrayObject * tmp = (PyArrayObject*) py_V201;
12066	                PyErr_Format(PyExc_NotImplementedError,
12067	                             "expected an aligned array of type %ld "
12068	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
12069	                             " with %ld dimensions, with 3 last dims "
12070	                             "%ld, %ld, %ld"
12071	                             " and 3 last strides %ld %ld, %ld.",
12072	                             (long int) NPY_FLOAT64,
12073	                             (long int) PyArray_TYPE((PyArrayObject*) py_V201),
12074	                             (long int) PyArray_NDIM(tmp),
12075	                             (long int) PyArray_NDIM(tmp) >= 3 ?
12076	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
12077	                             (long int) PyArray_NDIM(tmp) >= 2 ?
12078	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
12079	                             (long int) PyArray_NDIM(tmp) >= 1 ?
12080	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
12081	                             (long int) PyArray_NDIM(tmp) >= 3 ?
12082	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
12083	                             (long int) PyArray_NDIM(tmp) >= 2 ?
12084	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
12085	                             (long int) PyArray_NDIM(tmp) >= 1 ?
12086	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
12087	            );
12088	                {
12089	        __failure = 202;
12090	        if (!PyErr_Occurred()) {
12091	            PyErr_SetString(PyExc_RuntimeError,
12092	                "Unexpected error in an Op's C code. "
12093	                "No Python exception was set.");
12094	            }
12095	        goto __label_202;}
12096	            }
12097	            // This is a TypeError to be consistent with DEBUG_MODE
12098	            // Note: DEBUG_MODE also tells the name of the container
12099	            if (PyArray_TYPE((PyArrayObject*) py_V201) != NPY_FLOAT64) {
12100	                PyErr_Format(PyExc_TypeError,
12101	                             "expected type_num %d (NPY_FLOAT64) got %d",
12102	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V201));
12103	                {
12104	        __failure = 202;
12105	        if (!PyErr_Occurred()) {
12106	            PyErr_SetString(PyExc_RuntimeError,
12107	                "Unexpected error in an Op's C code. "
12108	                "No Python exception was set.");
12109	            }
12110	        goto __label_202;}
12111	            }
12112
12113	        V201 = (PyArrayObject*)(py_V201);
12114	        Py_XINCREF(V201);
12115
12116	{
12117
12118	    py_V203 = PyList_GET_ITEM(storage_V203, 0);
12119	    {Py_XINCREF(py_V203);}
12120
12121	            V203 = NULL;
12122	            if (py_V203 == Py_None) {
12123	                // We can either fail here or set V203 to NULL and rely on Ops
12124	                // using tensors to handle the NULL case, but if they fail to do so
12125	                // they'll end up with nasty segfaults, so this is public service.
12126	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
12127	                {
12128	        __failure = 204;
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_204;}
12135	            }
12136	            if (!PyArray_Check(py_V203)) {
12137	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
12138	                {
12139	        __failure = 204;
12140	        if (!PyErr_Occurred()) {
12141	            PyErr_SetString(PyExc_RuntimeError,
12142	                "Unexpected error in an Op's C code. "
12143	                "No Python exception was set.");
12144	            }
12145	        goto __label_204;}
12146	            }
12147	            // We expect NPY_INT8
12148	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V203)) {
12149	                PyArrayObject * tmp = (PyArrayObject*) py_V203;
12150	                PyErr_Format(PyExc_NotImplementedError,
12151	                             "expected an aligned array of type %ld "
12152	                             "(NPY_INT8), got non-aligned array of type %ld"
12153	                             " with %ld dimensions, with 3 last dims "
12154	                             "%ld, %ld, %ld"
12155	                             " and 3 last strides %ld %ld, %ld.",
12156	                             (long int) NPY_INT8,
12157	                             (long int) PyArray_TYPE((PyArrayObject*) py_V203),
12158	                             (long int) PyArray_NDIM(tmp),
12159	                             (long int) PyArray_NDIM(tmp) >= 3 ?
12160	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
12161	                             (long int) PyArray_NDIM(tmp) >= 2 ?
12162	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
12163	                             (long int) PyArray_NDIM(tmp) >= 1 ?
12164	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
12165	                             (long int) PyArray_NDIM(tmp) >= 3 ?
12166	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
12167	                             (long int) PyArray_NDIM(tmp) >= 2 ?
12168	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
12169	                             (long int) PyArray_NDIM(tmp) >= 1 ?
12170	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
12171	            );
12172	                {
12173	        __failure = 204;
12174	        if (!PyErr_Occurred()) {
12175	            PyErr_SetString(PyExc_RuntimeError,
12176	                "Unexpected error in an Op's C code. "
12177	                "No Python exception was set.");
12178	            }
12179	        goto __label_204;}
12180	            }
12181	            // This is a TypeError to be consistent with DEBUG_MODE
12182	            // Note: DEBUG_MODE also tells the name of the container
12183	            if (PyArray_TYPE((PyArrayObject*) py_V203) != NPY_INT8) {
12184	                PyErr_Format(PyExc_TypeError,
12185	                             "expected type_num %d (NPY_INT8) got %d",
12186	                             NPY_INT8, PyArray_TYPE((PyArrayObject*) py_V203));
12187	                {
12188	        __failure = 204;
12189	        if (!PyErr_Occurred()) {
12190	            PyErr_SetString(PyExc_RuntimeError,
12191	                "Unexpected error in an Op's C code. "
12192	                "No Python exception was set.");
12193	            }
12194	        goto __label_204;}
12195	            }
12196
12197	        V203 = (PyArrayObject*)(py_V203);
12198	        Py_XINCREF(V203);
12199
12200	{
12201
12202	    py_V205 = PyList_GET_ITEM(storage_V205, 0);
12203	    {Py_XINCREF(py_V205);}
12204
12205	            V205 = NULL;
12206	            if (py_V205 == Py_None) {
12207	                // We can either fail here or set V205 to NULL and rely on Ops
12208	                // using tensors to handle the NULL case, but if they fail to do so
12209	                // they'll end up with nasty segfaults, so this is public service.
12210	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
12211	                {
12212	        __failure = 206;
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_206;}
12219	            }
12220	            if (!PyArray_Check(py_V205)) {
12221	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
12222	                {
12223	        __failure = 206;
12224	        if (!PyErr_Occurred()) {
12225	            PyErr_SetString(PyExc_RuntimeError,
12226	                "Unexpected error in an Op's C code. "
12227	                "No Python exception was set.");
12228	            }
12229	        goto __label_206;}
12230	            }
12231	            // We expect NPY_FLOAT64
12232	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V205)) {
12233	                PyArrayObject * tmp = (PyArrayObject*) py_V205;
12234	                PyErr_Format(PyExc_NotImplementedError,
12235	                             "expected an aligned array of type %ld "
12236	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
12237	                             " with %ld dimensions, with 3 last dims "
12238	                             "%ld, %ld, %ld"
12239	                             " and 3 last strides %ld %ld, %ld.",
12240	                             (long int) NPY_FLOAT64,
12241	                             (long int) PyArray_TYPE((PyArrayObject*) py_V205),
12242	                             (long int) PyArray_NDIM(tmp),
12243	                             (long int) PyArray_NDIM(tmp) >= 3 ?
12244	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
12245	                             (long int) PyArray_NDIM(tmp) >= 2 ?
12246	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
12247	                             (long int) PyArray_NDIM(tmp) >= 1 ?
12248	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
12249	                             (long int) PyArray_NDIM(tmp) >= 3 ?
12250	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
12251	                             (long int) PyArray_NDIM(tmp) >= 2 ?
12252	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
12253	                             (long int) PyArray_NDIM(tmp) >= 1 ?
12254	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
12255	            );
12256	                {
12257	        __failure = 206;
12258	        if (!PyErr_Occurred()) {
12259	            PyErr_SetString(PyExc_RuntimeError,
12260	                "Unexpected error in an Op's C code. "
12261	                "No Python exception was set.");
12262	            }
12263	        goto __label_206;}
12264	            }
12265	            // This is a TypeError to be consistent with DEBUG_MODE
12266	            // Note: DEBUG_MODE also tells the name of the container
12267	            if (PyArray_TYPE((PyArrayObject*) py_V205) != NPY_FLOAT64) {
12268	                PyErr_Format(PyExc_TypeError,
12269	                             "expected type_num %d (NPY_FLOAT64) got %d",
12270	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V205));
12271	                {
12272	        __failure = 206;
12273	        if (!PyErr_Occurred()) {
12274	            PyErr_SetString(PyExc_RuntimeError,
12275	                "Unexpected error in an Op's C code. "
12276	                "No Python exception was set.");
12277	            }
12278	        goto __label_206;}
12279	            }
12280
12281	        V205 = (PyArrayObject*)(py_V205);
12282	        Py_XINCREF(V205);
12283
12284	{
12285
12286	    py_V207 = PyList_GET_ITEM(storage_V207, 0);
12287	    {Py_XINCREF(py_V207);}
12288
12289	            V207 = NULL;
12290	            if (py_V207 == Py_None) {
12291	                // We can either fail here or set V207 to NULL and rely on Ops
12292	                // using tensors to handle the NULL case, but if they fail to do so
12293	                // they'll end up with nasty segfaults, so this is public service.
12294	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
12295	                {
12296	        __failure = 208;
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_208;}
12303	            }
12304	            if (!PyArray_Check(py_V207)) {
12305	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
12306	                {
12307	        __failure = 208;
12308	        if (!PyErr_Occurred()) {
12309	            PyErr_SetString(PyExc_RuntimeError,
12310	                "Unexpected error in an Op's C code. "
12311	                "No Python exception was set.");
12312	            }
12313	        goto __label_208;}
12314	            }
12315	            // We expect NPY_FLOAT64
12316	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V207)) {
12317	                PyArrayObject * tmp = (PyArrayObject*) py_V207;
12318	                PyErr_Format(PyExc_NotImplementedError,
12319	                             "expected an aligned array of type %ld "
12320	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
12321	                             " with %ld dimensions, with 3 last dims "
12322	                             "%ld, %ld, %ld"
12323	                             " and 3 last strides %ld %ld, %ld.",
12324	                             (long int) NPY_FLOAT64,
12325	                             (long int) PyArray_TYPE((PyArrayObject*) py_V207),
12326	                             (long int) PyArray_NDIM(tmp),
12327	                             (long int) PyArray_NDIM(tmp) >= 3 ?
12328	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
12329	                             (long int) PyArray_NDIM(tmp) >= 2 ?
12330	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
12331	                             (long int) PyArray_NDIM(tmp) >= 1 ?
12332	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
12333	                             (long int) PyArray_NDIM(tmp) >= 3 ?
12334	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
12335	                             (long int) PyArray_NDIM(tmp) >= 2 ?
12336	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
12337	                             (long int) PyArray_NDIM(tmp) >= 1 ?
12338	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
12339	            );
12340	                {
12341	        __failure = 208;
12342	        if (!PyErr_Occurred()) {
12343	            PyErr_SetString(PyExc_RuntimeError,
12344	                "Unexpected error in an Op's C code. "
12345	                "No Python exception was set.");
12346	            }
12347	        goto __label_208;}
12348	            }
12349	            // This is a TypeError to be consistent with DEBUG_MODE
12350	            // Note: DEBUG_MODE also tells the name of the container
12351	            if (PyArray_TYPE((PyArrayObject*) py_V207) != NPY_FLOAT64) {
12352	                PyErr_Format(PyExc_TypeError,
12353	                             "expected type_num %d (NPY_FLOAT64) got %d",
12354	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V207));
12355	                {
12356	        __failure = 208;
12357	        if (!PyErr_Occurred()) {
12358	            PyErr_SetString(PyExc_RuntimeError,
12359	                "Unexpected error in an Op's C code. "
12360	                "No Python exception was set.");
12361	            }
12362	        goto __label_208;}
12363	            }
12364
12365	        V207 = (PyArrayObject*)(py_V207);
12366	        Py_XINCREF(V207);
12367
12368	{
12369
12370	    py_V209 = PyList_GET_ITEM(storage_V209, 0);
12371	    {Py_XINCREF(py_V209);}
12372
12373	            V209 = NULL;
12374	            if (py_V209 == Py_None) {
12375	                // We can either fail here or set V209 to NULL and rely on Ops
12376	                // using tensors to handle the NULL case, but if they fail to do so
12377	                // they'll end up with nasty segfaults, so this is public service.
12378	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
12379	                {
12380	        __failure = 210;
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_210;}
12387	            }
12388	            if (!PyArray_Check(py_V209)) {
12389	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
12390	                {
12391	        __failure = 210;
12392	        if (!PyErr_Occurred()) {
12393	            PyErr_SetString(PyExc_RuntimeError,
12394	                "Unexpected error in an Op's C code. "
12395	                "No Python exception was set.");
12396	            }
12397	        goto __label_210;}
12398	            }
12399	            // We expect NPY_FLOAT64
12400	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V209)) {
12401	                PyArrayObject * tmp = (PyArrayObject*) py_V209;
12402	                PyErr_Format(PyExc_NotImplementedError,
12403	                             "expected an aligned array of type %ld "
12404	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
12405	                             " with %ld dimensions, with 3 last dims "
12406	                             "%ld, %ld, %ld"
12407	                             " and 3 last strides %ld %ld, %ld.",
12408	                             (long int) NPY_FLOAT64,
12409	                             (long int) PyArray_TYPE((PyArrayObject*) py_V209),
12410	                             (long int) PyArray_NDIM(tmp),
12411	                             (long int) PyArray_NDIM(tmp) >= 3 ?
12412	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
12413	                             (long int) PyArray_NDIM(tmp) >= 2 ?
12414	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
12415	                             (long int) PyArray_NDIM(tmp) >= 1 ?
12416	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
12417	                             (long int) PyArray_NDIM(tmp) >= 3 ?
12418	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
12419	                             (long int) PyArray_NDIM(tmp) >= 2 ?
12420	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
12421	                             (long int) PyArray_NDIM(tmp) >= 1 ?
12422	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
12423	            );
12424	                {
12425	        __failure = 210;
12426	        if (!PyErr_Occurred()) {
12427	            PyErr_SetString(PyExc_RuntimeError,
12428	                "Unexpected error in an Op's C code. "
12429	                "No Python exception was set.");
12430	            }
12431	        goto __label_210;}
12432	            }
12433	            // This is a TypeError to be consistent with DEBUG_MODE
12434	            // Note: DEBUG_MODE also tells the name of the container
12435	            if (PyArray_TYPE((PyArrayObject*) py_V209) != NPY_FLOAT64) {
12436	                PyErr_Format(PyExc_TypeError,
12437	                             "expected type_num %d (NPY_FLOAT64) got %d",
12438	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V209));
12439	                {
12440	        __failure = 210;
12441	        if (!PyErr_Occurred()) {
12442	            PyErr_SetString(PyExc_RuntimeError,
12443	                "Unexpected error in an Op's C code. "
12444	                "No Python exception was set.");
12445	            }
12446	        goto __label_210;}
12447	            }
12448
12449	        V209 = (PyArrayObject*)(py_V209);
12450	        Py_XINCREF(V209);
12451
12452	{
12453
12454	    py_V211 = PyList_GET_ITEM(storage_V211, 0);
12455	    {Py_XINCREF(py_V211);}
12456
12457	            V211 = NULL;
12458	            if (py_V211 == Py_None) {
12459	                // We can either fail here or set V211 to NULL and rely on Ops
12460	                // using tensors to handle the NULL case, but if they fail to do so
12461	                // they'll end up with nasty segfaults, so this is public service.
12462	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
12463	                {
12464	        __failure = 212;
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_212;}
12471	            }
12472	            if (!PyArray_Check(py_V211)) {
12473	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
12474	                {
12475	        __failure = 212;
12476	        if (!PyErr_Occurred()) {
12477	            PyErr_SetString(PyExc_RuntimeError,
12478	                "Unexpected error in an Op's C code. "
12479	                "No Python exception was set.");
12480	            }
12481	        goto __label_212;}
12482	            }
12483	            // We expect NPY_FLOAT64
12484	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V211)) {
12485	                PyArrayObject * tmp = (PyArrayObject*) py_V211;
12486	                PyErr_Format(PyExc_NotImplementedError,
12487	                             "expected an aligned array of type %ld "
12488	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
12489	                             " with %ld dimensions, with 3 last dims "
12490	                             "%ld, %ld, %ld"
12491	                             " and 3 last strides %ld %ld, %ld.",
12492	                             (long int) NPY_FLOAT64,
12493	                             (long int) PyArray_TYPE((PyArrayObject*) py_V211),
12494	                             (long int) PyArray_NDIM(tmp),
12495	                             (long int) PyArray_NDIM(tmp) >= 3 ?
12496	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
12497	                             (long int) PyArray_NDIM(tmp) >= 2 ?
12498	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
12499	                             (long int) PyArray_NDIM(tmp) >= 1 ?
12500	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
12501	                             (long int) PyArray_NDIM(tmp) >= 3 ?
12502	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
12503	                             (long int) PyArray_NDIM(tmp) >= 2 ?
12504	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
12505	                             (long int) PyArray_NDIM(tmp) >= 1 ?
12506	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
12507	            );
12508	                {
12509	        __failure = 212;
12510	        if (!PyErr_Occurred()) {
12511	            PyErr_SetString(PyExc_RuntimeError,
12512	                "Unexpected error in an Op's C code. "
12513	                "No Python exception was set.");
12514	            }
12515	        goto __label_212;}
12516	            }
12517	            // This is a TypeError to be consistent with DEBUG_MODE
12518	            // Note: DEBUG_MODE also tells the name of the container
12519	            if (PyArray_TYPE((PyArrayObject*) py_V211) != NPY_FLOAT64) {
12520	                PyErr_Format(PyExc_TypeError,
12521	                             "expected type_num %d (NPY_FLOAT64) got %d",
12522	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V211));
12523	                {
12524	        __failure = 212;
12525	        if (!PyErr_Occurred()) {
12526	            PyErr_SetString(PyExc_RuntimeError,
12527	                "Unexpected error in an Op's C code. "
12528	                "No Python exception was set.");
12529	            }
12530	        goto __label_212;}
12531	            }
12532
12533	        V211 = (PyArrayObject*)(py_V211);
12534	        Py_XINCREF(V211);
12535
12536	{
12537
12538	    py_V213 = PyList_GET_ITEM(storage_V213, 0);
12539	    {Py_XINCREF(py_V213);}
12540
12541	            V213 = NULL;
12542	            if (py_V213 == Py_None) {
12543	                // We can either fail here or set V213 to NULL and rely on Ops
12544	                // using tensors to handle the NULL case, but if they fail to do so
12545	                // they'll end up with nasty segfaults, so this is public service.
12546	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
12547	                {
12548	        __failure = 214;
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_214;}
12555	            }
12556	            if (!PyArray_Check(py_V213)) {
12557	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
12558	                {
12559	        __failure = 214;
12560	        if (!PyErr_Occurred()) {
12561	            PyErr_SetString(PyExc_RuntimeError,
12562	                "Unexpected error in an Op's C code. "
12563	                "No Python exception was set.");
12564	            }
12565	        goto __label_214;}
12566	            }
12567	            // We expect NPY_FLOAT64
12568	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V213)) {
12569	                PyArrayObject * tmp = (PyArrayObject*) py_V213;
12570	                PyErr_Format(PyExc_NotImplementedError,
12571	                             "expected an aligned array of type %ld "
12572	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
12573	                             " with %ld dimensions, with 3 last dims "
12574	                             "%ld, %ld, %ld"
12575	                             " and 3 last strides %ld %ld, %ld.",
12576	                             (long int) NPY_FLOAT64,
12577	                             (long int) PyArray_TYPE((PyArrayObject*) py_V213),
12578	                             (long int) PyArray_NDIM(tmp),
12579	                             (long int) PyArray_NDIM(tmp) >= 3 ?
12580	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
12581	                             (long int) PyArray_NDIM(tmp) >= 2 ?
12582	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
12583	                             (long int) PyArray_NDIM(tmp) >= 1 ?
12584	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
12585	                             (long int) PyArray_NDIM(tmp) >= 3 ?
12586	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
12587	                             (long int) PyArray_NDIM(tmp) >= 2 ?
12588	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
12589	                             (long int) PyArray_NDIM(tmp) >= 1 ?
12590	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
12591	            );
12592	                {
12593	        __failure = 214;
12594	        if (!PyErr_Occurred()) {
12595	            PyErr_SetString(PyExc_RuntimeError,
12596	                "Unexpected error in an Op's C code. "
12597	                "No Python exception was set.");
12598	            }
12599	        goto __label_214;}
12600	            }
12601	            // This is a TypeError to be consistent with DEBUG_MODE
12602	            // Note: DEBUG_MODE also tells the name of the container
12603	            if (PyArray_TYPE((PyArrayObject*) py_V213) != NPY_FLOAT64) {
12604	                PyErr_Format(PyExc_TypeError,
12605	                             "expected type_num %d (NPY_FLOAT64) got %d",
12606	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V213));
12607	                {
12608	        __failure = 214;
12609	        if (!PyErr_Occurred()) {
12610	            PyErr_SetString(PyExc_RuntimeError,
12611	                "Unexpected error in an Op's C code. "
12612	                "No Python exception was set.");
12613	            }
12614	        goto __label_214;}
12615	            }
12616
12617	        V213 = (PyArrayObject*)(py_V213);
12618	        Py_XINCREF(V213);
12619
12620	{
12621
12622	    py_V215 = PyList_GET_ITEM(storage_V215, 0);
12623	    {Py_XINCREF(py_V215);}
12624
12625	            V215 = NULL;
12626	            if (py_V215 == Py_None) {
12627	                // We can either fail here or set V215 to NULL and rely on Ops
12628	                // using tensors to handle the NULL case, but if they fail to do so
12629	                // they'll end up with nasty segfaults, so this is public service.
12630	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
12631	                {
12632	        __failure = 216;
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_216;}
12639	            }
12640	            if (!PyArray_Check(py_V215)) {
12641	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
12642	                {
12643	        __failure = 216;
12644	        if (!PyErr_Occurred()) {
12645	            PyErr_SetString(PyExc_RuntimeError,
12646	                "Unexpected error in an Op's C code. "
12647	                "No Python exception was set.");
12648	            }
12649	        goto __label_216;}
12650	            }
12651	            // We expect NPY_INT8
12652	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V215)) {
12653	                PyArrayObject * tmp = (PyArrayObject*) py_V215;
12654	                PyErr_Format(PyExc_NotImplementedError,
12655	                             "expected an aligned array of type %ld "
12656	                             "(NPY_INT8), got non-aligned array of type %ld"
12657	                             " with %ld dimensions, with 3 last dims "
12658	                             "%ld, %ld, %ld"
12659	                             " and 3 last strides %ld %ld, %ld.",
12660	                             (long int) NPY_INT8,
12661	                             (long int) PyArray_TYPE((PyArrayObject*) py_V215),
12662	                             (long int) PyArray_NDIM(tmp),
12663	                             (long int) PyArray_NDIM(tmp) >= 3 ?
12664	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
12665	                             (long int) PyArray_NDIM(tmp) >= 2 ?
12666	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
12667	                             (long int) PyArray_NDIM(tmp) >= 1 ?
12668	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
12669	                             (long int) PyArray_NDIM(tmp) >= 3 ?
12670	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
12671	                             (long int) PyArray_NDIM(tmp) >= 2 ?
12672	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
12673	                             (long int) PyArray_NDIM(tmp) >= 1 ?
12674	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
12675	            );
12676	                {
12677	        __failure = 216;
12678	        if (!PyErr_Occurred()) {
12679	            PyErr_SetString(PyExc_RuntimeError,
12680	                "Unexpected error in an Op's C code. "
12681	                "No Python exception was set.");
12682	            }
12683	        goto __label_216;}
12684	            }
12685	            // This is a TypeError to be consistent with DEBUG_MODE
12686	            // Note: DEBUG_MODE also tells the name of the container
12687	            if (PyArray_TYPE((PyArrayObject*) py_V215) != NPY_INT8) {
12688	                PyErr_Format(PyExc_TypeError,
12689	                             "expected type_num %d (NPY_INT8) got %d",
12690	                             NPY_INT8, PyArray_TYPE((PyArrayObject*) py_V215));
12691	                {
12692	        __failure = 216;
12693	        if (!PyErr_Occurred()) {
12694	            PyErr_SetString(PyExc_RuntimeError,
12695	                "Unexpected error in an Op's C code. "
12696	                "No Python exception was set.");
12697	            }
12698	        goto __label_216;}
12699	            }
12700
12701	        V215 = (PyArrayObject*)(py_V215);
12702	        Py_XINCREF(V215);
12703
12704	{
12705
12706	    py_V217 = PyList_GET_ITEM(storage_V217, 0);
12707	    {Py_XINCREF(py_V217);}
12708
12709	            V217 = NULL;
12710	            if (py_V217 == Py_None) {
12711	                // We can either fail here or set V217 to NULL and rely on Ops
12712	                // using tensors to handle the NULL case, but if they fail to do so
12713	                // they'll end up with nasty segfaults, so this is public service.
12714	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
12715	                {
12716	        __failure = 218;
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_218;}
12723	            }
12724	            if (!PyArray_Check(py_V217)) {
12725	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
12726	                {
12727	        __failure = 218;
12728	        if (!PyErr_Occurred()) {
12729	            PyErr_SetString(PyExc_RuntimeError,
12730	                "Unexpected error in an Op's C code. "
12731	                "No Python exception was set.");
12732	            }
12733	        goto __label_218;}
12734	            }
12735	            // We expect NPY_FLOAT64
12736	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V217)) {
12737	                PyArrayObject * tmp = (PyArrayObject*) py_V217;
12738	                PyErr_Format(PyExc_NotImplementedError,
12739	                             "expected an aligned array of type %ld "
12740	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
12741	                             " with %ld dimensions, with 3 last dims "
12742	                             "%ld, %ld, %ld"
12743	                             " and 3 last strides %ld %ld, %ld.",
12744	                             (long int) NPY_FLOAT64,
12745	                             (long int) PyArray_TYPE((PyArrayObject*) py_V217),
12746	                             (long int) PyArray_NDIM(tmp),
12747	                             (long int) PyArray_NDIM(tmp) >= 3 ?
12748	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
12749	                             (long int) PyArray_NDIM(tmp) >= 2 ?
12750	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
12751	                             (long int) PyArray_NDIM(tmp) >= 1 ?
12752	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
12753	                             (long int) PyArray_NDIM(tmp) >= 3 ?
12754	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
12755	                             (long int) PyArray_NDIM(tmp) >= 2 ?
12756	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
12757	                             (long int) PyArray_NDIM(tmp) >= 1 ?
12758	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
12759	            );
12760	                {
12761	        __failure = 218;
12762	        if (!PyErr_Occurred()) {
12763	            PyErr_SetString(PyExc_RuntimeError,
12764	                "Unexpected error in an Op's C code. "
12765	                "No Python exception was set.");
12766	            }
12767	        goto __label_218;}
12768	            }
12769	            // This is a TypeError to be consistent with DEBUG_MODE
12770	            // Note: DEBUG_MODE also tells the name of the container
12771	            if (PyArray_TYPE((PyArrayObject*) py_V217) != NPY_FLOAT64) {
12772	                PyErr_Format(PyExc_TypeError,
12773	                             "expected type_num %d (NPY_FLOAT64) got %d",
12774	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V217));
12775	                {
12776	        __failure = 218;
12777	        if (!PyErr_Occurred()) {
12778	            PyErr_SetString(PyExc_RuntimeError,
12779	                "Unexpected error in an Op's C code. "
12780	                "No Python exception was set.");
12781	            }
12782	        goto __label_218;}
12783	            }
12784
12785	        V217 = (PyArrayObject*)(py_V217);
12786	        Py_XINCREF(V217);
12787
12788	{
12789
12790	    py_V219 = PyList_GET_ITEM(storage_V219, 0);
12791	    {Py_XINCREF(py_V219);}
12792
12793	            V219 = NULL;
12794	            if (py_V219 == Py_None) {
12795	                // We can either fail here or set V219 to NULL and rely on Ops
12796	                // using tensors to handle the NULL case, but if they fail to do so
12797	                // they'll end up with nasty segfaults, so this is public service.
12798	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
12799	                {
12800	        __failure = 220;
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_220;}
12807	            }
12808	            if (!PyArray_Check(py_V219)) {
12809	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
12810	                {
12811	        __failure = 220;
12812	        if (!PyErr_Occurred()) {
12813	            PyErr_SetString(PyExc_RuntimeError,
12814	                "Unexpected error in an Op's C code. "
12815	                "No Python exception was set.");
12816	            }
12817	        goto __label_220;}
12818	            }
12819	            // We expect NPY_FLOAT64
12820	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V219)) {
12821	                PyArrayObject * tmp = (PyArrayObject*) py_V219;
12822	                PyErr_Format(PyExc_NotImplementedError,
12823	                             "expected an aligned array of type %ld "
12824	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
12825	                             " with %ld dimensions, with 3 last dims "
12826	                             "%ld, %ld, %ld"
12827	                             " and 3 last strides %ld %ld, %ld.",
12828	                             (long int) NPY_FLOAT64,
12829	                             (long int) PyArray_TYPE((PyArrayObject*) py_V219),
12830	                             (long int) PyArray_NDIM(tmp),
12831	                             (long int) PyArray_NDIM(tmp) >= 3 ?
12832	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
12833	                             (long int) PyArray_NDIM(tmp) >= 2 ?
12834	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
12835	                             (long int) PyArray_NDIM(tmp) >= 1 ?
12836	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
12837	                             (long int) PyArray_NDIM(tmp) >= 3 ?
12838	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
12839	                             (long int) PyArray_NDIM(tmp) >= 2 ?
12840	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
12841	                             (long int) PyArray_NDIM(tmp) >= 1 ?
12842	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
12843	            );
12844	                {
12845	        __failure = 220;
12846	        if (!PyErr_Occurred()) {
12847	            PyErr_SetString(PyExc_RuntimeError,
12848	                "Unexpected error in an Op's C code. "
12849	                "No Python exception was set.");
12850	            }
12851	        goto __label_220;}
12852	            }
12853	            // This is a TypeError to be consistent with DEBUG_MODE
12854	            // Note: DEBUG_MODE also tells the name of the container
12855	            if (PyArray_TYPE((PyArrayObject*) py_V219) != NPY_FLOAT64) {
12856	                PyErr_Format(PyExc_TypeError,
12857	                             "expected type_num %d (NPY_FLOAT64) got %d",
12858	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V219));
12859	                {
12860	        __failure = 220;
12861	        if (!PyErr_Occurred()) {
12862	            PyErr_SetString(PyExc_RuntimeError,
12863	                "Unexpected error in an Op's C code. "
12864	                "No Python exception was set.");
12865	            }
12866	        goto __label_220;}
12867	            }
12868
12869	        V219 = (PyArrayObject*)(py_V219);
12870	        Py_XINCREF(V219);
12871
12872	{
12873
12874	    py_V221 = PyList_GET_ITEM(storage_V221, 0);
12875	    {Py_XINCREF(py_V221);}
12876
12877	            V221 = NULL;
12878	            if (py_V221 == Py_None) {
12879	                // We can either fail here or set V221 to NULL and rely on Ops
12880	                // using tensors to handle the NULL case, but if they fail to do so
12881	                // they'll end up with nasty segfaults, so this is public service.
12882	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
12883	                {
12884	        __failure = 222;
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_222;}
12891	            }
12892	            if (!PyArray_Check(py_V221)) {
12893	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
12894	                {
12895	        __failure = 222;
12896	        if (!PyErr_Occurred()) {
12897	            PyErr_SetString(PyExc_RuntimeError,
12898	                "Unexpected error in an Op's C code. "
12899	                "No Python exception was set.");
12900	            }
12901	        goto __label_222;}
12902	            }
12903	            // We expect NPY_FLOAT64
12904	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V221)) {
12905	                PyArrayObject * tmp = (PyArrayObject*) py_V221;
12906	                PyErr_Format(PyExc_NotImplementedError,
12907	                             "expected an aligned array of type %ld "
12908	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
12909	                             " with %ld dimensions, with 3 last dims "
12910	                             "%ld, %ld, %ld"
12911	                             " and 3 last strides %ld %ld, %ld.",
12912	                             (long int) NPY_FLOAT64,
12913	                             (long int) PyArray_TYPE((PyArrayObject*) py_V221),
12914	                             (long int) PyArray_NDIM(tmp),
12915	                             (long int) PyArray_NDIM(tmp) >= 3 ?
12916	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
12917	                             (long int) PyArray_NDIM(tmp) >= 2 ?
12918	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
12919	                             (long int) PyArray_NDIM(tmp) >= 1 ?
12920	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
12921	                             (long int) PyArray_NDIM(tmp) >= 3 ?
12922	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
12923	                             (long int) PyArray_NDIM(tmp) >= 2 ?
12924	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
12925	                             (long int) PyArray_NDIM(tmp) >= 1 ?
12926	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
12927	            );
12928	                {
12929	        __failure = 222;
12930	        if (!PyErr_Occurred()) {
12931	            PyErr_SetString(PyExc_RuntimeError,
12932	                "Unexpected error in an Op's C code. "
12933	                "No Python exception was set.");
12934	            }
12935	        goto __label_222;}
12936	            }
12937	            // This is a TypeError to be consistent with DEBUG_MODE
12938	            // Note: DEBUG_MODE also tells the name of the container
12939	            if (PyArray_TYPE((PyArrayObject*) py_V221) != NPY_FLOAT64) {
12940	                PyErr_Format(PyExc_TypeError,
12941	                             "expected type_num %d (NPY_FLOAT64) got %d",
12942	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V221));
12943	                {
12944	        __failure = 222;
12945	        if (!PyErr_Occurred()) {
12946	            PyErr_SetString(PyExc_RuntimeError,
12947	                "Unexpected error in an Op's C code. "
12948	                "No Python exception was set.");
12949	            }
12950	        goto __label_222;}
12951	            }
12952
12953	        V221 = (PyArrayObject*)(py_V221);
12954	        Py_XINCREF(V221);
12955
12956	{
12957
12958	    py_V223 = PyList_GET_ITEM(storage_V223, 0);
12959	    {Py_XINCREF(py_V223);}
12960
12961	            V223 = NULL;
12962	            if (py_V223 == Py_None) {
12963	                // We can either fail here or set V223 to NULL and rely on Ops
12964	                // using tensors to handle the NULL case, but if they fail to do so
12965	                // they'll end up with nasty segfaults, so this is public service.
12966	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
12967	                {
12968	        __failure = 224;
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_224;}
12975	            }
12976	            if (!PyArray_Check(py_V223)) {
12977	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
12978	                {
12979	        __failure = 224;
12980	        if (!PyErr_Occurred()) {
12981	            PyErr_SetString(PyExc_RuntimeError,
12982	                "Unexpected error in an Op's C code. "
12983	                "No Python exception was set.");
12984	            }
12985	        goto __label_224;}
12986	            }
12987	            // We expect NPY_FLOAT64
12988	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V223)) {
12989	                PyArrayObject * tmp = (PyArrayObject*) py_V223;
12990	                PyErr_Format(PyExc_NotImplementedError,
12991	                             "expected an aligned array of type %ld "
12992	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
12993	                             " with %ld dimensions, with 3 last dims "
12994	                             "%ld, %ld, %ld"
12995	                             " and 3 last strides %ld %ld, %ld.",
12996	                             (long int) NPY_FLOAT64,
12997	                             (long int) PyArray_TYPE((PyArrayObject*) py_V223),
12998	                             (long int) PyArray_NDIM(tmp),
12999	                             (long int) PyArray_NDIM(tmp) >= 3 ?
13000	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
13001	                             (long int) PyArray_NDIM(tmp) >= 2 ?
13002	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
13003	                             (long int) PyArray_NDIM(tmp) >= 1 ?
13004	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
13005	                             (long int) PyArray_NDIM(tmp) >= 3 ?
13006	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
13007	                             (long int) PyArray_NDIM(tmp) >= 2 ?
13008	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
13009	                             (long int) PyArray_NDIM(tmp) >= 1 ?
13010	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
13011	            );
13012	                {
13013	        __failure = 224;
13014	        if (!PyErr_Occurred()) {
13015	            PyErr_SetString(PyExc_RuntimeError,
13016	                "Unexpected error in an Op's C code. "
13017	                "No Python exception was set.");
13018	            }
13019	        goto __label_224;}
13020	            }
13021	            // This is a TypeError to be consistent with DEBUG_MODE
13022	            // Note: DEBUG_MODE also tells the name of the container
13023	            if (PyArray_TYPE((PyArrayObject*) py_V223) != NPY_FLOAT64) {
13024	                PyErr_Format(PyExc_TypeError,
13025	                             "expected type_num %d (NPY_FLOAT64) got %d",
13026	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V223));
13027	                {
13028	        __failure = 224;
13029	        if (!PyErr_Occurred()) {
13030	            PyErr_SetString(PyExc_RuntimeError,
13031	                "Unexpected error in an Op's C code. "
13032	                "No Python exception was set.");
13033	            }
13034	        goto __label_224;}
13035	            }
13036
13037	        V223 = (PyArrayObject*)(py_V223);
13038	        Py_XINCREF(V223);
13039
13040	{
13041
13042	    py_V225 = PyList_GET_ITEM(storage_V225, 0);
13043	    {Py_XINCREF(py_V225);}
13044
13045	            V225 = NULL;
13046	            if (py_V225 == Py_None) {
13047	                // We can either fail here or set V225 to NULL and rely on Ops
13048	                // using tensors to handle the NULL case, but if they fail to do so
13049	                // they'll end up with nasty segfaults, so this is public service.
13050	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
13051	                {
13052	        __failure = 226;
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_226;}
13059	            }
13060	            if (!PyArray_Check(py_V225)) {
13061	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
13062	                {
13063	        __failure = 226;
13064	        if (!PyErr_Occurred()) {
13065	            PyErr_SetString(PyExc_RuntimeError,
13066	                "Unexpected error in an Op's C code. "
13067	                "No Python exception was set.");
13068	            }
13069	        goto __label_226;}
13070	            }
13071	            // We expect NPY_FLOAT64
13072	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V225)) {
13073	                PyArrayObject * tmp = (PyArrayObject*) py_V225;
13074	                PyErr_Format(PyExc_NotImplementedError,
13075	                             "expected an aligned array of type %ld "
13076	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
13077	                             " with %ld dimensions, with 3 last dims "
13078	                             "%ld, %ld, %ld"
13079	                             " and 3 last strides %ld %ld, %ld.",
13080	                             (long int) NPY_FLOAT64,
13081	                             (long int) PyArray_TYPE((PyArrayObject*) py_V225),
13082	                             (long int) PyArray_NDIM(tmp),
13083	                             (long int) PyArray_NDIM(tmp) >= 3 ?
13084	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
13085	                             (long int) PyArray_NDIM(tmp) >= 2 ?
13086	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
13087	                             (long int) PyArray_NDIM(tmp) >= 1 ?
13088	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
13089	                             (long int) PyArray_NDIM(tmp) >= 3 ?
13090	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
13091	                             (long int) PyArray_NDIM(tmp) >= 2 ?
13092	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
13093	                             (long int) PyArray_NDIM(tmp) >= 1 ?
13094	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
13095	            );
13096	                {
13097	        __failure = 226;
13098	        if (!PyErr_Occurred()) {
13099	            PyErr_SetString(PyExc_RuntimeError,
13100	                "Unexpected error in an Op's C code. "
13101	                "No Python exception was set.");
13102	            }
13103	        goto __label_226;}
13104	            }
13105	            // This is a TypeError to be consistent with DEBUG_MODE
13106	            // Note: DEBUG_MODE also tells the name of the container
13107	            if (PyArray_TYPE((PyArrayObject*) py_V225) != NPY_FLOAT64) {
13108	                PyErr_Format(PyExc_TypeError,
13109	                             "expected type_num %d (NPY_FLOAT64) got %d",
13110	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V225));
13111	                {
13112	        __failure = 226;
13113	        if (!PyErr_Occurred()) {
13114	            PyErr_SetString(PyExc_RuntimeError,
13115	                "Unexpected error in an Op's C code. "
13116	                "No Python exception was set.");
13117	            }
13118	        goto __label_226;}
13119	            }
13120
13121	        V225 = (PyArrayObject*)(py_V225);
13122	        Py_XINCREF(V225);
13123
13124	{
13125
13126	    py_V227 = PyList_GET_ITEM(storage_V227, 0);
13127	    {Py_XINCREF(py_V227);}
13128
13129	            V227 = NULL;
13130	            if (py_V227 == Py_None) {
13131	                // We can either fail here or set V227 to NULL and rely on Ops
13132	                // using tensors to handle the NULL case, but if they fail to do so
13133	                // they'll end up with nasty segfaults, so this is public service.
13134	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
13135	                {
13136	        __failure = 228;
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_228;}
13143	            }
13144	            if (!PyArray_Check(py_V227)) {
13145	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
13146	                {
13147	        __failure = 228;
13148	        if (!PyErr_Occurred()) {
13149	            PyErr_SetString(PyExc_RuntimeError,
13150	                "Unexpected error in an Op's C code. "
13151	                "No Python exception was set.");
13152	            }
13153	        goto __label_228;}
13154	            }
13155	            // We expect NPY_FLOAT64
13156	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V227)) {
13157	                PyArrayObject * tmp = (PyArrayObject*) py_V227;
13158	                PyErr_Format(PyExc_NotImplementedError,
13159	                             "expected an aligned array of type %ld "
13160	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
13161	                             " with %ld dimensions, with 3 last dims "
13162	                             "%ld, %ld, %ld"
13163	                             " and 3 last strides %ld %ld, %ld.",
13164	                             (long int) NPY_FLOAT64,
13165	                             (long int) PyArray_TYPE((PyArrayObject*) py_V227),
13166	                             (long int) PyArray_NDIM(tmp),
13167	                             (long int) PyArray_NDIM(tmp) >= 3 ?
13168	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
13169	                             (long int) PyArray_NDIM(tmp) >= 2 ?
13170	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
13171	                             (long int) PyArray_NDIM(tmp) >= 1 ?
13172	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
13173	                             (long int) PyArray_NDIM(tmp) >= 3 ?
13174	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
13175	                             (long int) PyArray_NDIM(tmp) >= 2 ?
13176	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
13177	                             (long int) PyArray_NDIM(tmp) >= 1 ?
13178	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
13179	            );
13180	                {
13181	        __failure = 228;
13182	        if (!PyErr_Occurred()) {
13183	            PyErr_SetString(PyExc_RuntimeError,
13184	                "Unexpected error in an Op's C code. "
13185	                "No Python exception was set.");
13186	            }
13187	        goto __label_228;}
13188	            }
13189	            // This is a TypeError to be consistent with DEBUG_MODE
13190	            // Note: DEBUG_MODE also tells the name of the container
13191	            if (PyArray_TYPE((PyArrayObject*) py_V227) != NPY_FLOAT64) {
13192	                PyErr_Format(PyExc_TypeError,
13193	                             "expected type_num %d (NPY_FLOAT64) got %d",
13194	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V227));
13195	                {
13196	        __failure = 228;
13197	        if (!PyErr_Occurred()) {
13198	            PyErr_SetString(PyExc_RuntimeError,
13199	                "Unexpected error in an Op's C code. "
13200	                "No Python exception was set.");
13201	            }
13202	        goto __label_228;}
13203	            }
13204
13205	        V227 = (PyArrayObject*)(py_V227);
13206	        Py_XINCREF(V227);
13207
13208	{
13209
13210	    py_V229 = PyList_GET_ITEM(storage_V229, 0);
13211	    {Py_XINCREF(py_V229);}
13212
13213	            V229 = NULL;
13214	            if (py_V229 == Py_None) {
13215	                // We can either fail here or set V229 to NULL and rely on Ops
13216	                // using tensors to handle the NULL case, but if they fail to do so
13217	                // they'll end up with nasty segfaults, so this is public service.
13218	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
13219	                {
13220	        __failure = 230;
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_230;}
13227	            }
13228	            if (!PyArray_Check(py_V229)) {
13229	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
13230	                {
13231	        __failure = 230;
13232	        if (!PyErr_Occurred()) {
13233	            PyErr_SetString(PyExc_RuntimeError,
13234	                "Unexpected error in an Op's C code. "
13235	                "No Python exception was set.");
13236	            }
13237	        goto __label_230;}
13238	            }
13239	            // We expect NPY_INT8
13240	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V229)) {
13241	                PyArrayObject * tmp = (PyArrayObject*) py_V229;
13242	                PyErr_Format(PyExc_NotImplementedError,
13243	                             "expected an aligned array of type %ld "
13244	                             "(NPY_INT8), got non-aligned array of type %ld"
13245	                             " with %ld dimensions, with 3 last dims "
13246	                             "%ld, %ld, %ld"
13247	                             " and 3 last strides %ld %ld, %ld.",
13248	                             (long int) NPY_INT8,
13249	                             (long int) PyArray_TYPE((PyArrayObject*) py_V229),
13250	                             (long int) PyArray_NDIM(tmp),
13251	                             (long int) PyArray_NDIM(tmp) >= 3 ?
13252	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
13253	                             (long int) PyArray_NDIM(tmp) >= 2 ?
13254	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
13255	                             (long int) PyArray_NDIM(tmp) >= 1 ?
13256	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
13257	                             (long int) PyArray_NDIM(tmp) >= 3 ?
13258	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
13259	                             (long int) PyArray_NDIM(tmp) >= 2 ?
13260	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
13261	                             (long int) PyArray_NDIM(tmp) >= 1 ?
13262	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
13263	            );
13264	                {
13265	        __failure = 230;
13266	        if (!PyErr_Occurred()) {
13267	            PyErr_SetString(PyExc_RuntimeError,
13268	                "Unexpected error in an Op's C code. "
13269	                "No Python exception was set.");
13270	            }
13271	        goto __label_230;}
13272	            }
13273	            // This is a TypeError to be consistent with DEBUG_MODE
13274	            // Note: DEBUG_MODE also tells the name of the container
13275	            if (PyArray_TYPE((PyArrayObject*) py_V229) != NPY_INT8) {
13276	                PyErr_Format(PyExc_TypeError,
13277	                             "expected type_num %d (NPY_INT8) got %d",
13278	                             NPY_INT8, PyArray_TYPE((PyArrayObject*) py_V229));
13279	                {
13280	        __failure = 230;
13281	        if (!PyErr_Occurred()) {
13282	            PyErr_SetString(PyExc_RuntimeError,
13283	                "Unexpected error in an Op's C code. "
13284	                "No Python exception was set.");
13285	            }
13286	        goto __label_230;}
13287	            }
13288
13289	        V229 = (PyArrayObject*)(py_V229);
13290	        Py_XINCREF(V229);
13291
13292	{
13293
13294	    py_V231 = PyList_GET_ITEM(storage_V231, 0);
13295	    {Py_XINCREF(py_V231);}
13296
13297	            V231 = NULL;
13298	            if (py_V231 == Py_None) {
13299	                // We can either fail here or set V231 to NULL and rely on Ops
13300	                // using tensors to handle the NULL case, but if they fail to do so
13301	                // they'll end up with nasty segfaults, so this is public service.
13302	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
13303	                {
13304	        __failure = 232;
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_232;}
13311	            }
13312	            if (!PyArray_Check(py_V231)) {
13313	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
13314	                {
13315	        __failure = 232;
13316	        if (!PyErr_Occurred()) {
13317	            PyErr_SetString(PyExc_RuntimeError,
13318	                "Unexpected error in an Op's C code. "
13319	                "No Python exception was set.");
13320	            }
13321	        goto __label_232;}
13322	            }
13323	            // We expect NPY_FLOAT64
13324	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V231)) {
13325	                PyArrayObject * tmp = (PyArrayObject*) py_V231;
13326	                PyErr_Format(PyExc_NotImplementedError,
13327	                             "expected an aligned array of type %ld "
13328	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
13329	                             " with %ld dimensions, with 3 last dims "
13330	                             "%ld, %ld, %ld"
13331	                             " and 3 last strides %ld %ld, %ld.",
13332	                             (long int) NPY_FLOAT64,
13333	                             (long int) PyArray_TYPE((PyArrayObject*) py_V231),
13334	                             (long int) PyArray_NDIM(tmp),
13335	                             (long int) PyArray_NDIM(tmp) >= 3 ?
13336	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
13337	                             (long int) PyArray_NDIM(tmp) >= 2 ?
13338	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
13339	                             (long int) PyArray_NDIM(tmp) >= 1 ?
13340	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
13341	                             (long int) PyArray_NDIM(tmp) >= 3 ?
13342	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
13343	                             (long int) PyArray_NDIM(tmp) >= 2 ?
13344	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
13345	                             (long int) PyArray_NDIM(tmp) >= 1 ?
13346	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
13347	            );
13348	                {
13349	        __failure = 232;
13350	        if (!PyErr_Occurred()) {
13351	            PyErr_SetString(PyExc_RuntimeError,
13352	                "Unexpected error in an Op's C code. "
13353	                "No Python exception was set.");
13354	            }
13355	        goto __label_232;}
13356	            }
13357	            // This is a TypeError to be consistent with DEBUG_MODE
13358	            // Note: DEBUG_MODE also tells the name of the container
13359	            if (PyArray_TYPE((PyArrayObject*) py_V231) != NPY_FLOAT64) {
13360	                PyErr_Format(PyExc_TypeError,
13361	                             "expected type_num %d (NPY_FLOAT64) got %d",
13362	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V231));
13363	                {
13364	        __failure = 232;
13365	        if (!PyErr_Occurred()) {
13366	            PyErr_SetString(PyExc_RuntimeError,
13367	                "Unexpected error in an Op's C code. "
13368	                "No Python exception was set.");
13369	            }
13370	        goto __label_232;}
13371	            }
13372
13373	        V231 = (PyArrayObject*)(py_V231);
13374	        Py_XINCREF(V231);
13375
13376	{
13377
13378	    py_V233 = PyList_GET_ITEM(storage_V233, 0);
13379	    {Py_XINCREF(py_V233);}
13380
13381	            V233 = NULL;
13382	            if (py_V233 == Py_None) {
13383	                // We can either fail here or set V233 to NULL and rely on Ops
13384	                // using tensors to handle the NULL case, but if they fail to do so
13385	                // they'll end up with nasty segfaults, so this is public service.
13386	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
13387	                {
13388	        __failure = 234;
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_234;}
13395	            }
13396	            if (!PyArray_Check(py_V233)) {
13397	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
13398	                {
13399	        __failure = 234;
13400	        if (!PyErr_Occurred()) {
13401	            PyErr_SetString(PyExc_RuntimeError,
13402	                "Unexpected error in an Op's C code. "
13403	                "No Python exception was set.");
13404	            }
13405	        goto __label_234;}
13406	            }
13407	            // We expect NPY_FLOAT64
13408	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V233)) {
13409	                PyArrayObject * tmp = (PyArrayObject*) py_V233;
13410	                PyErr_Format(PyExc_NotImplementedError,
13411	                             "expected an aligned array of type %ld "
13412	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
13413	                             " with %ld dimensions, with 3 last dims "
13414	                             "%ld, %ld, %ld"
13415	                             " and 3 last strides %ld %ld, %ld.",
13416	                             (long int) NPY_FLOAT64,
13417	                             (long int) PyArray_TYPE((PyArrayObject*) py_V233),
13418	                             (long int) PyArray_NDIM(tmp),
13419	                             (long int) PyArray_NDIM(tmp) >= 3 ?
13420	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
13421	                             (long int) PyArray_NDIM(tmp) >= 2 ?
13422	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
13423	                             (long int) PyArray_NDIM(tmp) >= 1 ?
13424	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
13425	                             (long int) PyArray_NDIM(tmp) >= 3 ?
13426	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
13427	                             (long int) PyArray_NDIM(tmp) >= 2 ?
13428	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
13429	                             (long int) PyArray_NDIM(tmp) >= 1 ?
13430	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
13431	            );
13432	                {
13433	        __failure = 234;
13434	        if (!PyErr_Occurred()) {
13435	            PyErr_SetString(PyExc_RuntimeError,
13436	                "Unexpected error in an Op's C code. "
13437	                "No Python exception was set.");
13438	            }
13439	        goto __label_234;}
13440	            }
13441	            // This is a TypeError to be consistent with DEBUG_MODE
13442	            // Note: DEBUG_MODE also tells the name of the container
13443	            if (PyArray_TYPE((PyArrayObject*) py_V233) != NPY_FLOAT64) {
13444	                PyErr_Format(PyExc_TypeError,
13445	                             "expected type_num %d (NPY_FLOAT64) got %d",
13446	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V233));
13447	                {
13448	        __failure = 234;
13449	        if (!PyErr_Occurred()) {
13450	            PyErr_SetString(PyExc_RuntimeError,
13451	                "Unexpected error in an Op's C code. "
13452	                "No Python exception was set.");
13453	            }
13454	        goto __label_234;}
13455	            }
13456
13457	        V233 = (PyArrayObject*)(py_V233);
13458	        Py_XINCREF(V233);
13459
13460	{
13461
13462	    py_V235 = PyList_GET_ITEM(storage_V235, 0);
13463	    {Py_XINCREF(py_V235);}
13464
13465	            V235 = NULL;
13466	            if (py_V235 == Py_None) {
13467	                // We can either fail here or set V235 to NULL and rely on Ops
13468	                // using tensors to handle the NULL case, but if they fail to do so
13469	                // they'll end up with nasty segfaults, so this is public service.
13470	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
13471	                {
13472	        __failure = 236;
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_236;}
13479	            }
13480	            if (!PyArray_Check(py_V235)) {
13481	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
13482	                {
13483	        __failure = 236;
13484	        if (!PyErr_Occurred()) {
13485	            PyErr_SetString(PyExc_RuntimeError,
13486	                "Unexpected error in an Op's C code. "
13487	                "No Python exception was set.");
13488	            }
13489	        goto __label_236;}
13490	            }
13491	            // We expect NPY_FLOAT64
13492	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V235)) {
13493	                PyArrayObject * tmp = (PyArrayObject*) py_V235;
13494	                PyErr_Format(PyExc_NotImplementedError,
13495	                             "expected an aligned array of type %ld "
13496	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
13497	                             " with %ld dimensions, with 3 last dims "
13498	                             "%ld, %ld, %ld"
13499	                             " and 3 last strides %ld %ld, %ld.",
13500	                             (long int) NPY_FLOAT64,
13501	                             (long int) PyArray_TYPE((PyArrayObject*) py_V235),
13502	                             (long int) PyArray_NDIM(tmp),
13503	                             (long int) PyArray_NDIM(tmp) >= 3 ?
13504	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
13505	                             (long int) PyArray_NDIM(tmp) >= 2 ?
13506	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
13507	                             (long int) PyArray_NDIM(tmp) >= 1 ?
13508	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
13509	                             (long int) PyArray_NDIM(tmp) >= 3 ?
13510	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
13511	                             (long int) PyArray_NDIM(tmp) >= 2 ?
13512	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
13513	                             (long int) PyArray_NDIM(tmp) >= 1 ?
13514	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
13515	            );
13516	                {
13517	        __failure = 236;
13518	        if (!PyErr_Occurred()) {
13519	            PyErr_SetString(PyExc_RuntimeError,
13520	                "Unexpected error in an Op's C code. "
13521	                "No Python exception was set.");
13522	            }
13523	        goto __label_236;}
13524	            }
13525	            // This is a TypeError to be consistent with DEBUG_MODE
13526	            // Note: DEBUG_MODE also tells the name of the container
13527	            if (PyArray_TYPE((PyArrayObject*) py_V235) != NPY_FLOAT64) {
13528	                PyErr_Format(PyExc_TypeError,
13529	                             "expected type_num %d (NPY_FLOAT64) got %d",
13530	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V235));
13531	                {
13532	        __failure = 236;
13533	        if (!PyErr_Occurred()) {
13534	            PyErr_SetString(PyExc_RuntimeError,
13535	                "Unexpected error in an Op's C code. "
13536	                "No Python exception was set.");
13537	            }
13538	        goto __label_236;}
13539	            }
13540
13541	        V235 = (PyArrayObject*)(py_V235);
13542	        Py_XINCREF(V235);
13543
13544	{
13545
13546	    py_V237 = PyList_GET_ITEM(storage_V237, 0);
13547	    {Py_XINCREF(py_V237);}
13548
13549	            V237 = NULL;
13550	            if (py_V237 == Py_None) {
13551	                // We can either fail here or set V237 to NULL and rely on Ops
13552	                // using tensors to handle the NULL case, but if they fail to do so
13553	                // they'll end up with nasty segfaults, so this is public service.
13554	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
13555	                {
13556	        __failure = 238;
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_238;}
13563	            }
13564	            if (!PyArray_Check(py_V237)) {
13565	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
13566	                {
13567	        __failure = 238;
13568	        if (!PyErr_Occurred()) {
13569	            PyErr_SetString(PyExc_RuntimeError,
13570	                "Unexpected error in an Op's C code. "
13571	                "No Python exception was set.");
13572	            }
13573	        goto __label_238;}
13574	            }
13575	            // We expect NPY_FLOAT64
13576	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V237)) {
13577	                PyArrayObject * tmp = (PyArrayObject*) py_V237;
13578	                PyErr_Format(PyExc_NotImplementedError,
13579	                             "expected an aligned array of type %ld "
13580	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
13581	                             " with %ld dimensions, with 3 last dims "
13582	                             "%ld, %ld, %ld"
13583	                             " and 3 last strides %ld %ld, %ld.",
13584	                             (long int) NPY_FLOAT64,
13585	                             (long int) PyArray_TYPE((PyArrayObject*) py_V237),
13586	                             (long int) PyArray_NDIM(tmp),
13587	                             (long int) PyArray_NDIM(tmp) >= 3 ?
13588	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
13589	                             (long int) PyArray_NDIM(tmp) >= 2 ?
13590	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
13591	                             (long int) PyArray_NDIM(tmp) >= 1 ?
13592	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
13593	                             (long int) PyArray_NDIM(tmp) >= 3 ?
13594	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
13595	                             (long int) PyArray_NDIM(tmp) >= 2 ?
13596	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
13597	                             (long int) PyArray_NDIM(tmp) >= 1 ?
13598	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
13599	            );
13600	                {
13601	        __failure = 238;
13602	        if (!PyErr_Occurred()) {
13603	            PyErr_SetString(PyExc_RuntimeError,
13604	                "Unexpected error in an Op's C code. "
13605	                "No Python exception was set.");
13606	            }
13607	        goto __label_238;}
13608	            }
13609	            // This is a TypeError to be consistent with DEBUG_MODE
13610	            // Note: DEBUG_MODE also tells the name of the container
13611	            if (PyArray_TYPE((PyArrayObject*) py_V237) != NPY_FLOAT64) {
13612	                PyErr_Format(PyExc_TypeError,
13613	                             "expected type_num %d (NPY_FLOAT64) got %d",
13614	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V237));
13615	                {
13616	        __failure = 238;
13617	        if (!PyErr_Occurred()) {
13618	            PyErr_SetString(PyExc_RuntimeError,
13619	                "Unexpected error in an Op's C code. "
13620	                "No Python exception was set.");
13621	            }
13622	        goto __label_238;}
13623	            }
13624
13625	        V237 = (PyArrayObject*)(py_V237);
13626	        Py_XINCREF(V237);
13627
13628	{
13629
13630	    py_V239 = PyList_GET_ITEM(storage_V239, 0);
13631	    {Py_XINCREF(py_V239);}
13632
13633	            V239 = NULL;
13634	            if (py_V239 == Py_None) {
13635	                // We can either fail here or set V239 to NULL and rely on Ops
13636	                // using tensors to handle the NULL case, but if they fail to do so
13637	                // they'll end up with nasty segfaults, so this is public service.
13638	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
13639	                {
13640	        __failure = 240;
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_240;}
13647	            }
13648	            if (!PyArray_Check(py_V239)) {
13649	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
13650	                {
13651	        __failure = 240;
13652	        if (!PyErr_Occurred()) {
13653	            PyErr_SetString(PyExc_RuntimeError,
13654	                "Unexpected error in an Op's C code. "
13655	                "No Python exception was set.");
13656	            }
13657	        goto __label_240;}
13658	            }
13659	            // We expect NPY_FLOAT64
13660	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V239)) {
13661	                PyArrayObject * tmp = (PyArrayObject*) py_V239;
13662	                PyErr_Format(PyExc_NotImplementedError,
13663	                             "expected an aligned array of type %ld "
13664	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
13665	                             " with %ld dimensions, with 3 last dims "
13666	                             "%ld, %ld, %ld"
13667	                             " and 3 last strides %ld %ld, %ld.",
13668	                             (long int) NPY_FLOAT64,
13669	                             (long int) PyArray_TYPE((PyArrayObject*) py_V239),
13670	                             (long int) PyArray_NDIM(tmp),
13671	                             (long int) PyArray_NDIM(tmp) >= 3 ?
13672	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
13673	                             (long int) PyArray_NDIM(tmp) >= 2 ?
13674	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
13675	                             (long int) PyArray_NDIM(tmp) >= 1 ?
13676	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
13677	                             (long int) PyArray_NDIM(tmp) >= 3 ?
13678	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
13679	                             (long int) PyArray_NDIM(tmp) >= 2 ?
13680	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
13681	                             (long int) PyArray_NDIM(tmp) >= 1 ?
13682	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
13683	            );
13684	                {
13685	        __failure = 240;
13686	        if (!PyErr_Occurred()) {
13687	            PyErr_SetString(PyExc_RuntimeError,
13688	                "Unexpected error in an Op's C code. "
13689	                "No Python exception was set.");
13690	            }
13691	        goto __label_240;}
13692	            }
13693	            // This is a TypeError to be consistent with DEBUG_MODE
13694	            // Note: DEBUG_MODE also tells the name of the container
13695	            if (PyArray_TYPE((PyArrayObject*) py_V239) != NPY_FLOAT64) {
13696	                PyErr_Format(PyExc_TypeError,
13697	                             "expected type_num %d (NPY_FLOAT64) got %d",
13698	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V239));
13699	                {
13700	        __failure = 240;
13701	        if (!PyErr_Occurred()) {
13702	            PyErr_SetString(PyExc_RuntimeError,
13703	                "Unexpected error in an Op's C code. "
13704	                "No Python exception was set.");
13705	            }
13706	        goto __label_240;}
13707	            }
13708
13709	        V239 = (PyArrayObject*)(py_V239);
13710	        Py_XINCREF(V239);
13711
13712	{
13713
13714	    py_V241 = PyList_GET_ITEM(storage_V241, 0);
13715	    {Py_XINCREF(py_V241);}
13716
13717	            V241 = NULL;
13718	            if (py_V241 == Py_None) {
13719	                // We can either fail here or set V241 to NULL and rely on Ops
13720	                // using tensors to handle the NULL case, but if they fail to do so
13721	                // they'll end up with nasty segfaults, so this is public service.
13722	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
13723	                {
13724	        __failure = 242;
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_242;}
13731	            }
13732	            if (!PyArray_Check(py_V241)) {
13733	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
13734	                {
13735	        __failure = 242;
13736	        if (!PyErr_Occurred()) {
13737	            PyErr_SetString(PyExc_RuntimeError,
13738	                "Unexpected error in an Op's C code. "
13739	                "No Python exception was set.");
13740	            }
13741	        goto __label_242;}
13742	            }
13743	            // We expect NPY_FLOAT64
13744	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V241)) {
13745	                PyArrayObject * tmp = (PyArrayObject*) py_V241;
13746	                PyErr_Format(PyExc_NotImplementedError,
13747	                             "expected an aligned array of type %ld "
13748	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
13749	                             " with %ld dimensions, with 3 last dims "
13750	                             "%ld, %ld, %ld"
13751	                             " and 3 last strides %ld %ld, %ld.",
13752	                             (long int) NPY_FLOAT64,
13753	                             (long int) PyArray_TYPE((PyArrayObject*) py_V241),
13754	                             (long int) PyArray_NDIM(tmp),
13755	                             (long int) PyArray_NDIM(tmp) >= 3 ?
13756	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
13757	                             (long int) PyArray_NDIM(tmp) >= 2 ?
13758	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
13759	                             (long int) PyArray_NDIM(tmp) >= 1 ?
13760	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
13761	                             (long int) PyArray_NDIM(tmp) >= 3 ?
13762	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
13763	                             (long int) PyArray_NDIM(tmp) >= 2 ?
13764	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
13765	                             (long int) PyArray_NDIM(tmp) >= 1 ?
13766	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
13767	            );
13768	                {
13769	        __failure = 242;
13770	        if (!PyErr_Occurred()) {
13771	            PyErr_SetString(PyExc_RuntimeError,
13772	                "Unexpected error in an Op's C code. "
13773	                "No Python exception was set.");
13774	            }
13775	        goto __label_242;}
13776	            }
13777	            // This is a TypeError to be consistent with DEBUG_MODE
13778	            // Note: DEBUG_MODE also tells the name of the container
13779	            if (PyArray_TYPE((PyArrayObject*) py_V241) != NPY_FLOAT64) {
13780	                PyErr_Format(PyExc_TypeError,
13781	                             "expected type_num %d (NPY_FLOAT64) got %d",
13782	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V241));
13783	                {
13784	        __failure = 242;
13785	        if (!PyErr_Occurred()) {
13786	            PyErr_SetString(PyExc_RuntimeError,
13787	                "Unexpected error in an Op's C code. "
13788	                "No Python exception was set.");
13789	            }
13790	        goto __label_242;}
13791	            }
13792
13793	        V241 = (PyArrayObject*)(py_V241);
13794	        Py_XINCREF(V241);
13795
13796	{
13797
13798	    py_V243 = PyList_GET_ITEM(storage_V243, 0);
13799	    {Py_XINCREF(py_V243);}
13800
13801	            V243 = NULL;
13802	            if (py_V243 == Py_None) {
13803	                // We can either fail here or set V243 to NULL and rely on Ops
13804	                // using tensors to handle the NULL case, but if they fail to do so
13805	                // they'll end up with nasty segfaults, so this is public service.
13806	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
13807	                {
13808	        __failure = 244;
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_244;}
13815	            }
13816	            if (!PyArray_Check(py_V243)) {
13817	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
13818	                {
13819	        __failure = 244;
13820	        if (!PyErr_Occurred()) {
13821	            PyErr_SetString(PyExc_RuntimeError,
13822	                "Unexpected error in an Op's C code. "
13823	                "No Python exception was set.");
13824	            }
13825	        goto __label_244;}
13826	            }
13827	            // We expect NPY_FLOAT64
13828	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V243)) {
13829	                PyArrayObject * tmp = (PyArrayObject*) py_V243;
13830	                PyErr_Format(PyExc_NotImplementedError,
13831	                             "expected an aligned array of type %ld "
13832	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
13833	                             " with %ld dimensions, with 3 last dims "
13834	                             "%ld, %ld, %ld"
13835	                             " and 3 last strides %ld %ld, %ld.",
13836	                             (long int) NPY_FLOAT64,
13837	                             (long int) PyArray_TYPE((PyArrayObject*) py_V243),
13838	                             (long int) PyArray_NDIM(tmp),
13839	                             (long int) PyArray_NDIM(tmp) >= 3 ?
13840	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
13841	                             (long int) PyArray_NDIM(tmp) >= 2 ?
13842	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
13843	                             (long int) PyArray_NDIM(tmp) >= 1 ?
13844	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
13845	                             (long int) PyArray_NDIM(tmp) >= 3 ?
13846	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
13847	                             (long int) PyArray_NDIM(tmp) >= 2 ?
13848	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
13849	                             (long int) PyArray_NDIM(tmp) >= 1 ?
13850	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
13851	            );
13852	                {
13853	        __failure = 244;
13854	        if (!PyErr_Occurred()) {
13855	            PyErr_SetString(PyExc_RuntimeError,
13856	                "Unexpected error in an Op's C code. "
13857	                "No Python exception was set.");
13858	            }
13859	        goto __label_244;}
13860	            }
13861	            // This is a TypeError to be consistent with DEBUG_MODE
13862	            // Note: DEBUG_MODE also tells the name of the container
13863	            if (PyArray_TYPE((PyArrayObject*) py_V243) != NPY_FLOAT64) {
13864	                PyErr_Format(PyExc_TypeError,
13865	                             "expected type_num %d (NPY_FLOAT64) got %d",
13866	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V243));
13867	                {
13868	        __failure = 244;
13869	        if (!PyErr_Occurred()) {
13870	            PyErr_SetString(PyExc_RuntimeError,
13871	                "Unexpected error in an Op's C code. "
13872	                "No Python exception was set.");
13873	            }
13874	        goto __label_244;}
13875	            }
13876
13877	        V243 = (PyArrayObject*)(py_V243);
13878	        Py_XINCREF(V243);
13879
13880	{
13881
13882	    py_V245 = PyList_GET_ITEM(storage_V245, 0);
13883	    {Py_XINCREF(py_V245);}
13884
13885	            V245 = NULL;
13886	            if (py_V245 == Py_None) {
13887	                // We can either fail here or set V245 to NULL and rely on Ops
13888	                // using tensors to handle the NULL case, but if they fail to do so
13889	                // they'll end up with nasty segfaults, so this is public service.
13890	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
13891	                {
13892	        __failure = 246;
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_246;}
13899	            }
13900	            if (!PyArray_Check(py_V245)) {
13901	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
13902	                {
13903	        __failure = 246;
13904	        if (!PyErr_Occurred()) {
13905	            PyErr_SetString(PyExc_RuntimeError,
13906	                "Unexpected error in an Op's C code. "
13907	                "No Python exception was set.");
13908	            }
13909	        goto __label_246;}
13910	            }
13911	            // We expect NPY_INT8
13912	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V245)) {
13913	                PyArrayObject * tmp = (PyArrayObject*) py_V245;
13914	                PyErr_Format(PyExc_NotImplementedError,
13915	                             "expected an aligned array of type %ld "
13916	                             "(NPY_INT8), got non-aligned array of type %ld"
13917	                             " with %ld dimensions, with 3 last dims "
13918	                             "%ld, %ld, %ld"
13919	                             " and 3 last strides %ld %ld, %ld.",
13920	                             (long int) NPY_INT8,
13921	                             (long int) PyArray_TYPE((PyArrayObject*) py_V245),
13922	                             (long int) PyArray_NDIM(tmp),
13923	                             (long int) PyArray_NDIM(tmp) >= 3 ?
13924	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
13925	                             (long int) PyArray_NDIM(tmp) >= 2 ?
13926	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
13927	                             (long int) PyArray_NDIM(tmp) >= 1 ?
13928	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
13929	                             (long int) PyArray_NDIM(tmp) >= 3 ?
13930	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
13931	                             (long int) PyArray_NDIM(tmp) >= 2 ?
13932	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
13933	                             (long int) PyArray_NDIM(tmp) >= 1 ?
13934	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
13935	            );
13936	                {
13937	        __failure = 246;
13938	        if (!PyErr_Occurred()) {
13939	            PyErr_SetString(PyExc_RuntimeError,
13940	                "Unexpected error in an Op's C code. "
13941	                "No Python exception was set.");
13942	            }
13943	        goto __label_246;}
13944	            }
13945	            // This is a TypeError to be consistent with DEBUG_MODE
13946	            // Note: DEBUG_MODE also tells the name of the container
13947	            if (PyArray_TYPE((PyArrayObject*) py_V245) != NPY_INT8) {
13948	                PyErr_Format(PyExc_TypeError,
13949	                             "expected type_num %d (NPY_INT8) got %d",
13950	                             NPY_INT8, PyArray_TYPE((PyArrayObject*) py_V245));
13951	                {
13952	        __failure = 246;
13953	        if (!PyErr_Occurred()) {
13954	            PyErr_SetString(PyExc_RuntimeError,
13955	                "Unexpected error in an Op's C code. "
13956	                "No Python exception was set.");
13957	            }
13958	        goto __label_246;}
13959	            }
13960
13961	        V245 = (PyArrayObject*)(py_V245);
13962	        Py_XINCREF(V245);
13963
13964	{
13965
13966	    py_V247 = PyList_GET_ITEM(storage_V247, 0);
13967	    {Py_XINCREF(py_V247);}
13968
13969	            V247 = NULL;
13970	            if (py_V247 == Py_None) {
13971	                // We can either fail here or set V247 to NULL and rely on Ops
13972	                // using tensors to handle the NULL case, but if they fail to do so
13973	                // they'll end up with nasty segfaults, so this is public service.
13974	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
13975	                {
13976	        __failure = 248;
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_248;}
13983	            }
13984	            if (!PyArray_Check(py_V247)) {
13985	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
13986	                {
13987	        __failure = 248;
13988	        if (!PyErr_Occurred()) {
13989	            PyErr_SetString(PyExc_RuntimeError,
13990	                "Unexpected error in an Op's C code. "
13991	                "No Python exception was set.");
13992	            }
13993	        goto __label_248;}
13994	            }
13995	            // We expect NPY_FLOAT64
13996	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V247)) {
13997	                PyArrayObject * tmp = (PyArrayObject*) py_V247;
13998	                PyErr_Format(PyExc_NotImplementedError,
13999	                             "expected an aligned array of type %ld "
14000	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
14001	                             " with %ld dimensions, with 3 last dims "
14002	                             "%ld, %ld, %ld"
14003	                             " and 3 last strides %ld %ld, %ld.",
14004	                             (long int) NPY_FLOAT64,
14005	                             (long int) PyArray_TYPE((PyArrayObject*) py_V247),
14006	                             (long int) PyArray_NDIM(tmp),
14007	                             (long int) PyArray_NDIM(tmp) >= 3 ?
14008	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
14009	                             (long int) PyArray_NDIM(tmp) >= 2 ?
14010	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
14011	                             (long int) PyArray_NDIM(tmp) >= 1 ?
14012	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
14013	                             (long int) PyArray_NDIM(tmp) >= 3 ?
14014	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
14015	                             (long int) PyArray_NDIM(tmp) >= 2 ?
14016	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
14017	                             (long int) PyArray_NDIM(tmp) >= 1 ?
14018	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
14019	            );
14020	                {
14021	        __failure = 248;
14022	        if (!PyErr_Occurred()) {
14023	            PyErr_SetString(PyExc_RuntimeError,
14024	                "Unexpected error in an Op's C code. "
14025	                "No Python exception was set.");
14026	            }
14027	        goto __label_248;}
14028	            }
14029	            // This is a TypeError to be consistent with DEBUG_MODE
14030	            // Note: DEBUG_MODE also tells the name of the container
14031	            if (PyArray_TYPE((PyArrayObject*) py_V247) != NPY_FLOAT64) {
14032	                PyErr_Format(PyExc_TypeError,
14033	                             "expected type_num %d (NPY_FLOAT64) got %d",
14034	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V247));
14035	                {
14036	        __failure = 248;
14037	        if (!PyErr_Occurred()) {
14038	            PyErr_SetString(PyExc_RuntimeError,
14039	                "Unexpected error in an Op's C code. "
14040	                "No Python exception was set.");
14041	            }
14042	        goto __label_248;}
14043	            }
14044
14045	        V247 = (PyArrayObject*)(py_V247);
14046	        Py_XINCREF(V247);
14047
14048	{
14049
14050	    py_V249 = PyList_GET_ITEM(storage_V249, 0);
14051	    {Py_XINCREF(py_V249);}
14052
14053	            V249 = NULL;
14054	            if (py_V249 == Py_None) {
14055	                // We can either fail here or set V249 to NULL and rely on Ops
14056	                // using tensors to handle the NULL case, but if they fail to do so
14057	                // they'll end up with nasty segfaults, so this is public service.
14058	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
14059	                {
14060	        __failure = 250;
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_250;}
14067	            }
14068	            if (!PyArray_Check(py_V249)) {
14069	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
14070	                {
14071	        __failure = 250;
14072	        if (!PyErr_Occurred()) {
14073	            PyErr_SetString(PyExc_RuntimeError,
14074	                "Unexpected error in an Op's C code. "
14075	                "No Python exception was set.");
14076	            }
14077	        goto __label_250;}
14078	            }
14079	            // We expect NPY_FLOAT64
14080	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V249)) {
14081	                PyArrayObject * tmp = (PyArrayObject*) py_V249;
14082	                PyErr_Format(PyExc_NotImplementedError,
14083	                             "expected an aligned array of type %ld "
14084	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
14085	                             " with %ld dimensions, with 3 last dims "
14086	                             "%ld, %ld, %ld"
14087	                             " and 3 last strides %ld %ld, %ld.",
14088	                             (long int) NPY_FLOAT64,
14089	                             (long int) PyArray_TYPE((PyArrayObject*) py_V249),
14090	                             (long int) PyArray_NDIM(tmp),
14091	                             (long int) PyArray_NDIM(tmp) >= 3 ?
14092	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
14093	                             (long int) PyArray_NDIM(tmp) >= 2 ?
14094	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
14095	                             (long int) PyArray_NDIM(tmp) >= 1 ?
14096	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
14097	                             (long int) PyArray_NDIM(tmp) >= 3 ?
14098	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
14099	                             (long int) PyArray_NDIM(tmp) >= 2 ?
14100	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
14101	                             (long int) PyArray_NDIM(tmp) >= 1 ?
14102	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
14103	            );
14104	                {
14105	        __failure = 250;
14106	        if (!PyErr_Occurred()) {
14107	            PyErr_SetString(PyExc_RuntimeError,
14108	                "Unexpected error in an Op's C code. "
14109	                "No Python exception was set.");
14110	            }
14111	        goto __label_250;}
14112	            }
14113	            // This is a TypeError to be consistent with DEBUG_MODE
14114	            // Note: DEBUG_MODE also tells the name of the container
14115	            if (PyArray_TYPE((PyArrayObject*) py_V249) != NPY_FLOAT64) {
14116	                PyErr_Format(PyExc_TypeError,
14117	                             "expected type_num %d (NPY_FLOAT64) got %d",
14118	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V249));
14119	                {
14120	        __failure = 250;
14121	        if (!PyErr_Occurred()) {
14122	            PyErr_SetString(PyExc_RuntimeError,
14123	                "Unexpected error in an Op's C code. "
14124	                "No Python exception was set.");
14125	            }
14126	        goto __label_250;}
14127	            }
14128
14129	        V249 = (PyArrayObject*)(py_V249);
14130	        Py_XINCREF(V249);
14131
14132	{
14133
14134	    py_V251 = PyList_GET_ITEM(storage_V251, 0);
14135	    {Py_XINCREF(py_V251);}
14136
14137	            V251 = NULL;
14138	            if (py_V251 == Py_None) {
14139	                // We can either fail here or set V251 to NULL and rely on Ops
14140	                // using tensors to handle the NULL case, but if they fail to do so
14141	                // they'll end up with nasty segfaults, so this is public service.
14142	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
14143	                {
14144	        __failure = 252;
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_252;}
14151	            }
14152	            if (!PyArray_Check(py_V251)) {
14153	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
14154	                {
14155	        __failure = 252;
14156	        if (!PyErr_Occurred()) {
14157	            PyErr_SetString(PyExc_RuntimeError,
14158	                "Unexpected error in an Op's C code. "
14159	                "No Python exception was set.");
14160	            }
14161	        goto __label_252;}
14162	            }
14163	            // We expect NPY_FLOAT64
14164	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V251)) {
14165	                PyArrayObject * tmp = (PyArrayObject*) py_V251;
14166	                PyErr_Format(PyExc_NotImplementedError,
14167	                             "expected an aligned array of type %ld "
14168	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
14169	                             " with %ld dimensions, with 3 last dims "
14170	                             "%ld, %ld, %ld"
14171	                             " and 3 last strides %ld %ld, %ld.",
14172	                             (long int) NPY_FLOAT64,
14173	                             (long int) PyArray_TYPE((PyArrayObject*) py_V251),
14174	                             (long int) PyArray_NDIM(tmp),
14175	                             (long int) PyArray_NDIM(tmp) >= 3 ?
14176	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
14177	                             (long int) PyArray_NDIM(tmp) >= 2 ?
14178	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
14179	                             (long int) PyArray_NDIM(tmp) >= 1 ?
14180	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
14181	                             (long int) PyArray_NDIM(tmp) >= 3 ?
14182	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
14183	                             (long int) PyArray_NDIM(tmp) >= 2 ?
14184	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
14185	                             (long int) PyArray_NDIM(tmp) >= 1 ?
14186	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
14187	            );
14188	                {
14189	        __failure = 252;
14190	        if (!PyErr_Occurred()) {
14191	            PyErr_SetString(PyExc_RuntimeError,
14192	                "Unexpected error in an Op's C code. "
14193	                "No Python exception was set.");
14194	            }
14195	        goto __label_252;}
14196	            }
14197	            // This is a TypeError to be consistent with DEBUG_MODE
14198	            // Note: DEBUG_MODE also tells the name of the container
14199	            if (PyArray_TYPE((PyArrayObject*) py_V251) != NPY_FLOAT64) {
14200	                PyErr_Format(PyExc_TypeError,
14201	                             "expected type_num %d (NPY_FLOAT64) got %d",
14202	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V251));
14203	                {
14204	        __failure = 252;
14205	        if (!PyErr_Occurred()) {
14206	            PyErr_SetString(PyExc_RuntimeError,
14207	                "Unexpected error in an Op's C code. "
14208	                "No Python exception was set.");
14209	            }
14210	        goto __label_252;}
14211	            }
14212
14213	        V251 = (PyArrayObject*)(py_V251);
14214	        Py_XINCREF(V251);
14215
14216	{
14217
14218	    py_V253 = PyList_GET_ITEM(storage_V253, 0);
14219	    {Py_XINCREF(py_V253);}
14220
14221	            V253 = NULL;
14222	            if (py_V253 == Py_None) {
14223	                // We can either fail here or set V253 to NULL and rely on Ops
14224	                // using tensors to handle the NULL case, but if they fail to do so
14225	                // they'll end up with nasty segfaults, so this is public service.
14226	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
14227	                {
14228	        __failure = 254;
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_254;}
14235	            }
14236	            if (!PyArray_Check(py_V253)) {
14237	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
14238	                {
14239	        __failure = 254;
14240	        if (!PyErr_Occurred()) {
14241	            PyErr_SetString(PyExc_RuntimeError,
14242	                "Unexpected error in an Op's C code. "
14243	                "No Python exception was set.");
14244	            }
14245	        goto __label_254;}
14246	            }
14247	            // We expect NPY_FLOAT64
14248	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V253)) {
14249	                PyArrayObject * tmp = (PyArrayObject*) py_V253;
14250	                PyErr_Format(PyExc_NotImplementedError,
14251	                             "expected an aligned array of type %ld "
14252	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
14253	                             " with %ld dimensions, with 3 last dims "
14254	                             "%ld, %ld, %ld"
14255	                             " and 3 last strides %ld %ld, %ld.",
14256	                             (long int) NPY_FLOAT64,
14257	                             (long int) PyArray_TYPE((PyArrayObject*) py_V253),
14258	                             (long int) PyArray_NDIM(tmp),
14259	                             (long int) PyArray_NDIM(tmp) >= 3 ?
14260	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
14261	                             (long int) PyArray_NDIM(tmp) >= 2 ?
14262	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
14263	                             (long int) PyArray_NDIM(tmp) >= 1 ?
14264	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
14265	                             (long int) PyArray_NDIM(tmp) >= 3 ?
14266	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
14267	                             (long int) PyArray_NDIM(tmp) >= 2 ?
14268	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
14269	                             (long int) PyArray_NDIM(tmp) >= 1 ?
14270	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
14271	            );
14272	                {
14273	        __failure = 254;
14274	        if (!PyErr_Occurred()) {
14275	            PyErr_SetString(PyExc_RuntimeError,
14276	                "Unexpected error in an Op's C code. "
14277	                "No Python exception was set.");
14278	            }
14279	        goto __label_254;}
14280	            }
14281	            // This is a TypeError to be consistent with DEBUG_MODE
14282	            // Note: DEBUG_MODE also tells the name of the container
14283	            if (PyArray_TYPE((PyArrayObject*) py_V253) != NPY_FLOAT64) {
14284	                PyErr_Format(PyExc_TypeError,
14285	                             "expected type_num %d (NPY_FLOAT64) got %d",
14286	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V253));
14287	                {
14288	        __failure = 254;
14289	        if (!PyErr_Occurred()) {
14290	            PyErr_SetString(PyExc_RuntimeError,
14291	                "Unexpected error in an Op's C code. "
14292	                "No Python exception was set.");
14293	            }
14294	        goto __label_254;}
14295	            }
14296
14297	        V253 = (PyArrayObject*)(py_V253);
14298	        Py_XINCREF(V253);
14299
14300	{
14301
14302	    py_V255 = PyList_GET_ITEM(storage_V255, 0);
14303	    {Py_XINCREF(py_V255);}
14304
14305	            V255 = NULL;
14306	            if (py_V255 == Py_None) {
14307	                // We can either fail here or set V255 to NULL and rely on Ops
14308	                // using tensors to handle the NULL case, but if they fail to do so
14309	                // they'll end up with nasty segfaults, so this is public service.
14310	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
14311	                {
14312	        __failure = 256;
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_256;}
14319	            }
14320	            if (!PyArray_Check(py_V255)) {
14321	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
14322	                {
14323	        __failure = 256;
14324	        if (!PyErr_Occurred()) {
14325	            PyErr_SetString(PyExc_RuntimeError,
14326	                "Unexpected error in an Op's C code. "
14327	                "No Python exception was set.");
14328	            }
14329	        goto __label_256;}
14330	            }
14331	            // We expect NPY_FLOAT64
14332	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V255)) {
14333	                PyArrayObject * tmp = (PyArrayObject*) py_V255;
14334	                PyErr_Format(PyExc_NotImplementedError,
14335	                             "expected an aligned array of type %ld "
14336	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
14337	                             " with %ld dimensions, with 3 last dims "
14338	                             "%ld, %ld, %ld"
14339	                             " and 3 last strides %ld %ld, %ld.",
14340	                             (long int) NPY_FLOAT64,
14341	                             (long int) PyArray_TYPE((PyArrayObject*) py_V255),
14342	                             (long int) PyArray_NDIM(tmp),
14343	                             (long int) PyArray_NDIM(tmp) >= 3 ?
14344	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
14345	                             (long int) PyArray_NDIM(tmp) >= 2 ?
14346	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
14347	                             (long int) PyArray_NDIM(tmp) >= 1 ?
14348	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
14349	                             (long int) PyArray_NDIM(tmp) >= 3 ?
14350	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
14351	                             (long int) PyArray_NDIM(tmp) >= 2 ?
14352	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
14353	                             (long int) PyArray_NDIM(tmp) >= 1 ?
14354	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
14355	            );
14356	                {
14357	        __failure = 256;
14358	        if (!PyErr_Occurred()) {
14359	            PyErr_SetString(PyExc_RuntimeError,
14360	                "Unexpected error in an Op's C code. "
14361	                "No Python exception was set.");
14362	            }
14363	        goto __label_256;}
14364	            }
14365	            // This is a TypeError to be consistent with DEBUG_MODE
14366	            // Note: DEBUG_MODE also tells the name of the container
14367	            if (PyArray_TYPE((PyArrayObject*) py_V255) != NPY_FLOAT64) {
14368	                PyErr_Format(PyExc_TypeError,
14369	                             "expected type_num %d (NPY_FLOAT64) got %d",
14370	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V255));
14371	                {
14372	        __failure = 256;
14373	        if (!PyErr_Occurred()) {
14374	            PyErr_SetString(PyExc_RuntimeError,
14375	                "Unexpected error in an Op's C code. "
14376	                "No Python exception was set.");
14377	            }
14378	        goto __label_256;}
14379	            }
14380
14381	        V255 = (PyArrayObject*)(py_V255);
14382	        Py_XINCREF(V255);
14383
14384	{
14385
14386	    py_V257 = PyList_GET_ITEM(storage_V257, 0);
14387	    {Py_XINCREF(py_V257);}
14388
14389	            V257 = NULL;
14390	            if (py_V257 == Py_None) {
14391	                // We can either fail here or set V257 to NULL and rely on Ops
14392	                // using tensors to handle the NULL case, but if they fail to do so
14393	                // they'll end up with nasty segfaults, so this is public service.
14394	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
14395	                {
14396	        __failure = 258;
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_258;}
14403	            }
14404	            if (!PyArray_Check(py_V257)) {
14405	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
14406	                {
14407	        __failure = 258;
14408	        if (!PyErr_Occurred()) {
14409	            PyErr_SetString(PyExc_RuntimeError,
14410	                "Unexpected error in an Op's C code. "
14411	                "No Python exception was set.");
14412	            }
14413	        goto __label_258;}
14414	            }
14415	            // We expect NPY_FLOAT64
14416	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V257)) {
14417	                PyArrayObject * tmp = (PyArrayObject*) py_V257;
14418	                PyErr_Format(PyExc_NotImplementedError,
14419	                             "expected an aligned array of type %ld "
14420	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
14421	                             " with %ld dimensions, with 3 last dims "
14422	                             "%ld, %ld, %ld"
14423	                             " and 3 last strides %ld %ld, %ld.",
14424	                             (long int) NPY_FLOAT64,
14425	                             (long int) PyArray_TYPE((PyArrayObject*) py_V257),
14426	                             (long int) PyArray_NDIM(tmp),
14427	                             (long int) PyArray_NDIM(tmp) >= 3 ?
14428	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
14429	                             (long int) PyArray_NDIM(tmp) >= 2 ?
14430	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
14431	                             (long int) PyArray_NDIM(tmp) >= 1 ?
14432	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
14433	                             (long int) PyArray_NDIM(tmp) >= 3 ?
14434	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
14435	                             (long int) PyArray_NDIM(tmp) >= 2 ?
14436	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
14437	                             (long int) PyArray_NDIM(tmp) >= 1 ?
14438	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
14439	            );
14440	                {
14441	        __failure = 258;
14442	        if (!PyErr_Occurred()) {
14443	            PyErr_SetString(PyExc_RuntimeError,
14444	                "Unexpected error in an Op's C code. "
14445	                "No Python exception was set.");
14446	            }
14447	        goto __label_258;}
14448	            }
14449	            // This is a TypeError to be consistent with DEBUG_MODE
14450	            // Note: DEBUG_MODE also tells the name of the container
14451	            if (PyArray_TYPE((PyArrayObject*) py_V257) != NPY_FLOAT64) {
14452	                PyErr_Format(PyExc_TypeError,
14453	                             "expected type_num %d (NPY_FLOAT64) got %d",
14454	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V257));
14455	                {
14456	        __failure = 258;
14457	        if (!PyErr_Occurred()) {
14458	            PyErr_SetString(PyExc_RuntimeError,
14459	                "Unexpected error in an Op's C code. "
14460	                "No Python exception was set.");
14461	            }
14462	        goto __label_258;}
14463	            }
14464
14465	        V257 = (PyArrayObject*)(py_V257);
14466	        Py_XINCREF(V257);
14467
14468	{
14469
14470	    py_V259 = PyList_GET_ITEM(storage_V259, 0);
14471	    {Py_XINCREF(py_V259);}
14472
14473	            V259 = NULL;
14474	            if (py_V259 == Py_None) {
14475	                // We can either fail here or set V259 to NULL and rely on Ops
14476	                // using tensors to handle the NULL case, but if they fail to do so
14477	                // they'll end up with nasty segfaults, so this is public service.
14478	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
14479	                {
14480	        __failure = 260;
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_260;}
14487	            }
14488	            if (!PyArray_Check(py_V259)) {
14489	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
14490	                {
14491	        __failure = 260;
14492	        if (!PyErr_Occurred()) {
14493	            PyErr_SetString(PyExc_RuntimeError,
14494	                "Unexpected error in an Op's C code. "
14495	                "No Python exception was set.");
14496	            }
14497	        goto __label_260;}
14498	            }
14499	            // We expect NPY_FLOAT64
14500	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V259)) {
14501	                PyArrayObject * tmp = (PyArrayObject*) py_V259;
14502	                PyErr_Format(PyExc_NotImplementedError,
14503	                             "expected an aligned array of type %ld "
14504	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
14505	                             " with %ld dimensions, with 3 last dims "
14506	                             "%ld, %ld, %ld"
14507	                             " and 3 last strides %ld %ld, %ld.",
14508	                             (long int) NPY_FLOAT64,
14509	                             (long int) PyArray_TYPE((PyArrayObject*) py_V259),
14510	                             (long int) PyArray_NDIM(tmp),
14511	                             (long int) PyArray_NDIM(tmp) >= 3 ?
14512	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
14513	                             (long int) PyArray_NDIM(tmp) >= 2 ?
14514	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
14515	                             (long int) PyArray_NDIM(tmp) >= 1 ?
14516	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
14517	                             (long int) PyArray_NDIM(tmp) >= 3 ?
14518	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
14519	                             (long int) PyArray_NDIM(tmp) >= 2 ?
14520	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
14521	                             (long int) PyArray_NDIM(tmp) >= 1 ?
14522	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
14523	            );
14524	                {
14525	        __failure = 260;
14526	        if (!PyErr_Occurred()) {
14527	            PyErr_SetString(PyExc_RuntimeError,
14528	                "Unexpected error in an Op's C code. "
14529	                "No Python exception was set.");
14530	            }
14531	        goto __label_260;}
14532	            }
14533	            // This is a TypeError to be consistent with DEBUG_MODE
14534	            // Note: DEBUG_MODE also tells the name of the container
14535	            if (PyArray_TYPE((PyArrayObject*) py_V259) != NPY_FLOAT64) {
14536	                PyErr_Format(PyExc_TypeError,
14537	                             "expected type_num %d (NPY_FLOAT64) got %d",
14538	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V259));
14539	                {
14540	        __failure = 260;
14541	        if (!PyErr_Occurred()) {
14542	            PyErr_SetString(PyExc_RuntimeError,
14543	                "Unexpected error in an Op's C code. "
14544	                "No Python exception was set.");
14545	            }
14546	        goto __label_260;}
14547	            }
14548
14549	        V259 = (PyArrayObject*)(py_V259);
14550	        Py_XINCREF(V259);
14551
14552	{
14553
14554	    py_V261 = PyList_GET_ITEM(storage_V261, 0);
14555	    {Py_XINCREF(py_V261);}
14556
14557	            V261 = NULL;
14558	            if (py_V261 == Py_None) {
14559	                // We can either fail here or set V261 to NULL and rely on Ops
14560	                // using tensors to handle the NULL case, but if they fail to do so
14561	                // they'll end up with nasty segfaults, so this is public service.
14562	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
14563	                {
14564	        __failure = 262;
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_262;}
14571	            }
14572	            if (!PyArray_Check(py_V261)) {
14573	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
14574	                {
14575	        __failure = 262;
14576	        if (!PyErr_Occurred()) {
14577	            PyErr_SetString(PyExc_RuntimeError,
14578	                "Unexpected error in an Op's C code. "
14579	                "No Python exception was set.");
14580	            }
14581	        goto __label_262;}
14582	            }
14583	            // We expect NPY_INT8
14584	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V261)) {
14585	                PyArrayObject * tmp = (PyArrayObject*) py_V261;
14586	                PyErr_Format(PyExc_NotImplementedError,
14587	                             "expected an aligned array of type %ld "
14588	                             "(NPY_INT8), got non-aligned array of type %ld"
14589	                             " with %ld dimensions, with 3 last dims "
14590	                             "%ld, %ld, %ld"
14591	                             " and 3 last strides %ld %ld, %ld.",
14592	                             (long int) NPY_INT8,
14593	                             (long int) PyArray_TYPE((PyArrayObject*) py_V261),
14594	                             (long int) PyArray_NDIM(tmp),
14595	                             (long int) PyArray_NDIM(tmp) >= 3 ?
14596	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
14597	                             (long int) PyArray_NDIM(tmp) >= 2 ?
14598	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
14599	                             (long int) PyArray_NDIM(tmp) >= 1 ?
14600	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
14601	                             (long int) PyArray_NDIM(tmp) >= 3 ?
14602	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
14603	                             (long int) PyArray_NDIM(tmp) >= 2 ?
14604	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
14605	                             (long int) PyArray_NDIM(tmp) >= 1 ?
14606	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
14607	            );
14608	                {
14609	        __failure = 262;
14610	        if (!PyErr_Occurred()) {
14611	            PyErr_SetString(PyExc_RuntimeError,
14612	                "Unexpected error in an Op's C code. "
14613	                "No Python exception was set.");
14614	            }
14615	        goto __label_262;}
14616	            }
14617	            // This is a TypeError to be consistent with DEBUG_MODE
14618	            // Note: DEBUG_MODE also tells the name of the container
14619	            if (PyArray_TYPE((PyArrayObject*) py_V261) != NPY_INT8) {
14620	                PyErr_Format(PyExc_TypeError,
14621	                             "expected type_num %d (NPY_INT8) got %d",
14622	                             NPY_INT8, PyArray_TYPE((PyArrayObject*) py_V261));
14623	                {
14624	        __failure = 262;
14625	        if (!PyErr_Occurred()) {
14626	            PyErr_SetString(PyExc_RuntimeError,
14627	                "Unexpected error in an Op's C code. "
14628	                "No Python exception was set.");
14629	            }
14630	        goto __label_262;}
14631	            }
14632
14633	        V261 = (PyArrayObject*)(py_V261);
14634	        Py_XINCREF(V261);
14635
14636	{
14637
14638	    py_V263 = PyList_GET_ITEM(storage_V263, 0);
14639	    {Py_XINCREF(py_V263);}
14640
14641	            V263 = NULL;
14642	            if (py_V263 == Py_None) {
14643	                // We can either fail here or set V263 to NULL and rely on Ops
14644	                // using tensors to handle the NULL case, but if they fail to do so
14645	                // they'll end up with nasty segfaults, so this is public service.
14646	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
14647	                {
14648	        __failure = 264;
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_264;}
14655	            }
14656	            if (!PyArray_Check(py_V263)) {
14657	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
14658	                {
14659	        __failure = 264;
14660	        if (!PyErr_Occurred()) {
14661	            PyErr_SetString(PyExc_RuntimeError,
14662	                "Unexpected error in an Op's C code. "
14663	                "No Python exception was set.");
14664	            }
14665	        goto __label_264;}
14666	            }
14667	            // We expect NPY_FLOAT64
14668	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V263)) {
14669	                PyArrayObject * tmp = (PyArrayObject*) py_V263;
14670	                PyErr_Format(PyExc_NotImplementedError,
14671	                             "expected an aligned array of type %ld "
14672	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
14673	                             " with %ld dimensions, with 3 last dims "
14674	                             "%ld, %ld, %ld"
14675	                             " and 3 last strides %ld %ld, %ld.",
14676	                             (long int) NPY_FLOAT64,
14677	                             (long int) PyArray_TYPE((PyArrayObject*) py_V263),
14678	                             (long int) PyArray_NDIM(tmp),
14679	                             (long int) PyArray_NDIM(tmp) >= 3 ?
14680	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
14681	                             (long int) PyArray_NDIM(tmp) >= 2 ?
14682	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
14683	                             (long int) PyArray_NDIM(tmp) >= 1 ?
14684	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
14685	                             (long int) PyArray_NDIM(tmp) >= 3 ?
14686	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
14687	                             (long int) PyArray_NDIM(tmp) >= 2 ?
14688	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
14689	                             (long int) PyArray_NDIM(tmp) >= 1 ?
14690	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
14691	            );
14692	                {
14693	        __failure = 264;
14694	        if (!PyErr_Occurred()) {
14695	            PyErr_SetString(PyExc_RuntimeError,
14696	                "Unexpected error in an Op's C code. "
14697	                "No Python exception was set.");
14698	            }
14699	        goto __label_264;}
14700	            }
14701	            // This is a TypeError to be consistent with DEBUG_MODE
14702	            // Note: DEBUG_MODE also tells the name of the container
14703	            if (PyArray_TYPE((PyArrayObject*) py_V263) != NPY_FLOAT64) {
14704	                PyErr_Format(PyExc_TypeError,
14705	                             "expected type_num %d (NPY_FLOAT64) got %d",
14706	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V263));
14707	                {
14708	        __failure = 264;
14709	        if (!PyErr_Occurred()) {
14710	            PyErr_SetString(PyExc_RuntimeError,
14711	                "Unexpected error in an Op's C code. "
14712	                "No Python exception was set.");
14713	            }
14714	        goto __label_264;}
14715	            }
14716
14717	        V263 = (PyArrayObject*)(py_V263);
14718	        Py_XINCREF(V263);
14719
14720	{
14721
14722	    py_V265 = PyList_GET_ITEM(storage_V265, 0);
14723	    {Py_XINCREF(py_V265);}
14724
14725	            V265 = NULL;
14726	            if (py_V265 == Py_None) {
14727	                // We can either fail here or set V265 to NULL and rely on Ops
14728	                // using tensors to handle the NULL case, but if they fail to do so
14729	                // they'll end up with nasty segfaults, so this is public service.
14730	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
14731	                {
14732	        __failure = 266;
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_266;}
14739	            }
14740	            if (!PyArray_Check(py_V265)) {
14741	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
14742	                {
14743	        __failure = 266;
14744	        if (!PyErr_Occurred()) {
14745	            PyErr_SetString(PyExc_RuntimeError,
14746	                "Unexpected error in an Op's C code. "
14747	                "No Python exception was set.");
14748	            }
14749	        goto __label_266;}
14750	            }
14751	            // We expect NPY_FLOAT64
14752	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V265)) {
14753	                PyArrayObject * tmp = (PyArrayObject*) py_V265;
14754	                PyErr_Format(PyExc_NotImplementedError,
14755	                             "expected an aligned array of type %ld "
14756	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
14757	                             " with %ld dimensions, with 3 last dims "
14758	                             "%ld, %ld, %ld"
14759	                             " and 3 last strides %ld %ld, %ld.",
14760	                             (long int) NPY_FLOAT64,
14761	                             (long int) PyArray_TYPE((PyArrayObject*) py_V265),
14762	                             (long int) PyArray_NDIM(tmp),
14763	                             (long int) PyArray_NDIM(tmp) >= 3 ?
14764	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
14765	                             (long int) PyArray_NDIM(tmp) >= 2 ?
14766	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
14767	                             (long int) PyArray_NDIM(tmp) >= 1 ?
14768	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
14769	                             (long int) PyArray_NDIM(tmp) >= 3 ?
14770	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
14771	                             (long int) PyArray_NDIM(tmp) >= 2 ?
14772	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
14773	                             (long int) PyArray_NDIM(tmp) >= 1 ?
14774	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
14775	            );
14776	                {
14777	        __failure = 266;
14778	        if (!PyErr_Occurred()) {
14779	            PyErr_SetString(PyExc_RuntimeError,
14780	                "Unexpected error in an Op's C code. "
14781	                "No Python exception was set.");
14782	            }
14783	        goto __label_266;}
14784	            }
14785	            // This is a TypeError to be consistent with DEBUG_MODE
14786	            // Note: DEBUG_MODE also tells the name of the container
14787	            if (PyArray_TYPE((PyArrayObject*) py_V265) != NPY_FLOAT64) {
14788	                PyErr_Format(PyExc_TypeError,
14789	                             "expected type_num %d (NPY_FLOAT64) got %d",
14790	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V265));
14791	                {
14792	        __failure = 266;
14793	        if (!PyErr_Occurred()) {
14794	            PyErr_SetString(PyExc_RuntimeError,
14795	                "Unexpected error in an Op's C code. "
14796	                "No Python exception was set.");
14797	            }
14798	        goto __label_266;}
14799	            }
14800
14801	        V265 = (PyArrayObject*)(py_V265);
14802	        Py_XINCREF(V265);
14803
14804	{
14805
14806	    py_V267 = PyList_GET_ITEM(storage_V267, 0);
14807	    {Py_XINCREF(py_V267);}
14808
14809	            V267 = NULL;
14810	            if (py_V267 == Py_None) {
14811	                // We can either fail here or set V267 to NULL and rely on Ops
14812	                // using tensors to handle the NULL case, but if they fail to do so
14813	                // they'll end up with nasty segfaults, so this is public service.
14814	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
14815	                {
14816	        __failure = 268;
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_268;}
14823	            }
14824	            if (!PyArray_Check(py_V267)) {
14825	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
14826	                {
14827	        __failure = 268;
14828	        if (!PyErr_Occurred()) {
14829	            PyErr_SetString(PyExc_RuntimeError,
14830	                "Unexpected error in an Op's C code. "
14831	                "No Python exception was set.");
14832	            }
14833	        goto __label_268;}
14834	            }
14835	            // We expect NPY_FLOAT64
14836	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V267)) {
14837	                PyArrayObject * tmp = (PyArrayObject*) py_V267;
14838	                PyErr_Format(PyExc_NotImplementedError,
14839	                             "expected an aligned array of type %ld "
14840	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
14841	                             " with %ld dimensions, with 3 last dims "
14842	                             "%ld, %ld, %ld"
14843	                             " and 3 last strides %ld %ld, %ld.",
14844	                             (long int) NPY_FLOAT64,
14845	                             (long int) PyArray_TYPE((PyArrayObject*) py_V267),
14846	                             (long int) PyArray_NDIM(tmp),
14847	                             (long int) PyArray_NDIM(tmp) >= 3 ?
14848	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
14849	                             (long int) PyArray_NDIM(tmp) >= 2 ?
14850	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
14851	                             (long int) PyArray_NDIM(tmp) >= 1 ?
14852	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
14853	                             (long int) PyArray_NDIM(tmp) >= 3 ?
14854	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
14855	                             (long int) PyArray_NDIM(tmp) >= 2 ?
14856	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
14857	                             (long int) PyArray_NDIM(tmp) >= 1 ?
14858	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
14859	            );
14860	                {
14861	        __failure = 268;
14862	        if (!PyErr_Occurred()) {
14863	            PyErr_SetString(PyExc_RuntimeError,
14864	                "Unexpected error in an Op's C code. "
14865	                "No Python exception was set.");
14866	            }
14867	        goto __label_268;}
14868	            }
14869	            // This is a TypeError to be consistent with DEBUG_MODE
14870	            // Note: DEBUG_MODE also tells the name of the container
14871	            if (PyArray_TYPE((PyArrayObject*) py_V267) != NPY_FLOAT64) {
14872	                PyErr_Format(PyExc_TypeError,
14873	                             "expected type_num %d (NPY_FLOAT64) got %d",
14874	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V267));
14875	                {
14876	        __failure = 268;
14877	        if (!PyErr_Occurred()) {
14878	            PyErr_SetString(PyExc_RuntimeError,
14879	                "Unexpected error in an Op's C code. "
14880	                "No Python exception was set.");
14881	            }
14882	        goto __label_268;}
14883	            }
14884
14885	        V267 = (PyArrayObject*)(py_V267);
14886	        Py_XINCREF(V267);
14887
14888	{
14889
14890	    py_V269 = PyList_GET_ITEM(storage_V269, 0);
14891	    {Py_XINCREF(py_V269);}
14892
14893	            V269 = NULL;
14894	            if (py_V269 == Py_None) {
14895	                // We can either fail here or set V269 to NULL and rely on Ops
14896	                // using tensors to handle the NULL case, but if they fail to do so
14897	                // they'll end up with nasty segfaults, so this is public service.
14898	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
14899	                {
14900	        __failure = 270;
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_270;}
14907	            }
14908	            if (!PyArray_Check(py_V269)) {
14909	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
14910	                {
14911	        __failure = 270;
14912	        if (!PyErr_Occurred()) {
14913	            PyErr_SetString(PyExc_RuntimeError,
14914	                "Unexpected error in an Op's C code. "
14915	                "No Python exception was set.");
14916	            }
14917	        goto __label_270;}
14918	            }
14919	            // We expect NPY_FLOAT64
14920	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V269)) {
14921	                PyArrayObject * tmp = (PyArrayObject*) py_V269;
14922	                PyErr_Format(PyExc_NotImplementedError,
14923	                             "expected an aligned array of type %ld "
14924	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
14925	                             " with %ld dimensions, with 3 last dims "
14926	                             "%ld, %ld, %ld"
14927	                             " and 3 last strides %ld %ld, %ld.",
14928	                             (long int) NPY_FLOAT64,
14929	                             (long int) PyArray_TYPE((PyArrayObject*) py_V269),
14930	                             (long int) PyArray_NDIM(tmp),
14931	                             (long int) PyArray_NDIM(tmp) >= 3 ?
14932	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
14933	                             (long int) PyArray_NDIM(tmp) >= 2 ?
14934	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
14935	                             (long int) PyArray_NDIM(tmp) >= 1 ?
14936	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
14937	                             (long int) PyArray_NDIM(tmp) >= 3 ?
14938	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
14939	                             (long int) PyArray_NDIM(tmp) >= 2 ?
14940	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
14941	                             (long int) PyArray_NDIM(tmp) >= 1 ?
14942	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
14943	            );
14944	                {
14945	        __failure = 270;
14946	        if (!PyErr_Occurred()) {
14947	            PyErr_SetString(PyExc_RuntimeError,
14948	                "Unexpected error in an Op's C code. "
14949	                "No Python exception was set.");
14950	            }
14951	        goto __label_270;}
14952	            }
14953	            // This is a TypeError to be consistent with DEBUG_MODE
14954	            // Note: DEBUG_MODE also tells the name of the container
14955	            if (PyArray_TYPE((PyArrayObject*) py_V269) != NPY_FLOAT64) {
14956	                PyErr_Format(PyExc_TypeError,
14957	                             "expected type_num %d (NPY_FLOAT64) got %d",
14958	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V269));
14959	                {
14960	        __failure = 270;
14961	        if (!PyErr_Occurred()) {
14962	            PyErr_SetString(PyExc_RuntimeError,
14963	                "Unexpected error in an Op's C code. "
14964	                "No Python exception was set.");
14965	            }
14966	        goto __label_270;}
14967	            }
14968
14969	        V269 = (PyArrayObject*)(py_V269);
14970	        Py_XINCREF(V269);
14971
14972	{
14973
14974	    py_V271 = PyList_GET_ITEM(storage_V271, 0);
14975	    {Py_XINCREF(py_V271);}
14976
14977	            V271 = NULL;
14978	            if (py_V271 == Py_None) {
14979	                // We can either fail here or set V271 to NULL and rely on Ops
14980	                // using tensors to handle the NULL case, but if they fail to do so
14981	                // they'll end up with nasty segfaults, so this is public service.
14982	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
14983	                {
14984	        __failure = 272;
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_272;}
14991	            }
14992	            if (!PyArray_Check(py_V271)) {
14993	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
14994	                {
14995	        __failure = 272;
14996	        if (!PyErr_Occurred()) {
14997	            PyErr_SetString(PyExc_RuntimeError,
14998	                "Unexpected error in an Op's C code. "
14999	                "No Python exception was set.");
15000	            }
15001	        goto __label_272;}
15002	            }
15003	            // We expect NPY_FLOAT64
15004	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V271)) {
15005	                PyArrayObject * tmp = (PyArrayObject*) py_V271;
15006	                PyErr_Format(PyExc_NotImplementedError,
15007	                             "expected an aligned array of type %ld "
15008	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
15009	                             " with %ld dimensions, with 3 last dims "
15010	                             "%ld, %ld, %ld"
15011	                             " and 3 last strides %ld %ld, %ld.",
15012	                             (long int) NPY_FLOAT64,
15013	                             (long int) PyArray_TYPE((PyArrayObject*) py_V271),
15014	                             (long int) PyArray_NDIM(tmp),
15015	                             (long int) PyArray_NDIM(tmp) >= 3 ?
15016	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
15017	                             (long int) PyArray_NDIM(tmp) >= 2 ?
15018	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
15019	                             (long int) PyArray_NDIM(tmp) >= 1 ?
15020	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
15021	                             (long int) PyArray_NDIM(tmp) >= 3 ?
15022	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
15023	                             (long int) PyArray_NDIM(tmp) >= 2 ?
15024	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
15025	                             (long int) PyArray_NDIM(tmp) >= 1 ?
15026	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
15027	            );
15028	                {
15029	        __failure = 272;
15030	        if (!PyErr_Occurred()) {
15031	            PyErr_SetString(PyExc_RuntimeError,
15032	                "Unexpected error in an Op's C code. "
15033	                "No Python exception was set.");
15034	            }
15035	        goto __label_272;}
15036	            }
15037	            // This is a TypeError to be consistent with DEBUG_MODE
15038	            // Note: DEBUG_MODE also tells the name of the container
15039	            if (PyArray_TYPE((PyArrayObject*) py_V271) != NPY_FLOAT64) {
15040	                PyErr_Format(PyExc_TypeError,
15041	                             "expected type_num %d (NPY_FLOAT64) got %d",
15042	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V271));
15043	                {
15044	        __failure = 272;
15045	        if (!PyErr_Occurred()) {
15046	            PyErr_SetString(PyExc_RuntimeError,
15047	                "Unexpected error in an Op's C code. "
15048	                "No Python exception was set.");
15049	            }
15050	        goto __label_272;}
15051	            }
15052
15053	        V271 = (PyArrayObject*)(py_V271);
15054	        Py_XINCREF(V271);
15055
15056	{
15057
15058	    py_V273 = PyList_GET_ITEM(storage_V273, 0);
15059	    {Py_XINCREF(py_V273);}
15060
15061	            V273 = NULL;
15062	            if (py_V273 == Py_None) {
15063	                // We can either fail here or set V273 to NULL and rely on Ops
15064	                // using tensors to handle the NULL case, but if they fail to do so
15065	                // they'll end up with nasty segfaults, so this is public service.
15066	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
15067	                {
15068	        __failure = 274;
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_274;}
15075	            }
15076	            if (!PyArray_Check(py_V273)) {
15077	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
15078	                {
15079	        __failure = 274;
15080	        if (!PyErr_Occurred()) {
15081	            PyErr_SetString(PyExc_RuntimeError,
15082	                "Unexpected error in an Op's C code. "
15083	                "No Python exception was set.");
15084	            }
15085	        goto __label_274;}
15086	            }
15087	            // We expect NPY_FLOAT64
15088	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V273)) {
15089	                PyArrayObject * tmp = (PyArrayObject*) py_V273;
15090	                PyErr_Format(PyExc_NotImplementedError,
15091	                             "expected an aligned array of type %ld "
15092	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
15093	                             " with %ld dimensions, with 3 last dims "
15094	                             "%ld, %ld, %ld"
15095	                             " and 3 last strides %ld %ld, %ld.",
15096	                             (long int) NPY_FLOAT64,
15097	                             (long int) PyArray_TYPE((PyArrayObject*) py_V273),
15098	                             (long int) PyArray_NDIM(tmp),
15099	                             (long int) PyArray_NDIM(tmp) >= 3 ?
15100	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
15101	                             (long int) PyArray_NDIM(tmp) >= 2 ?
15102	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
15103	                             (long int) PyArray_NDIM(tmp) >= 1 ?
15104	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
15105	                             (long int) PyArray_NDIM(tmp) >= 3 ?
15106	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
15107	                             (long int) PyArray_NDIM(tmp) >= 2 ?
15108	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
15109	                             (long int) PyArray_NDIM(tmp) >= 1 ?
15110	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
15111	            );
15112	                {
15113	        __failure = 274;
15114	        if (!PyErr_Occurred()) {
15115	            PyErr_SetString(PyExc_RuntimeError,
15116	                "Unexpected error in an Op's C code. "
15117	                "No Python exception was set.");
15118	            }
15119	        goto __label_274;}
15120	            }
15121	            // This is a TypeError to be consistent with DEBUG_MODE
15122	            // Note: DEBUG_MODE also tells the name of the container
15123	            if (PyArray_TYPE((PyArrayObject*) py_V273) != NPY_FLOAT64) {
15124	                PyErr_Format(PyExc_TypeError,
15125	                             "expected type_num %d (NPY_FLOAT64) got %d",
15126	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V273));
15127	                {
15128	        __failure = 274;
15129	        if (!PyErr_Occurred()) {
15130	            PyErr_SetString(PyExc_RuntimeError,
15131	                "Unexpected error in an Op's C code. "
15132	                "No Python exception was set.");
15133	            }
15134	        goto __label_274;}
15135	            }
15136
15137	        V273 = (PyArrayObject*)(py_V273);
15138	        Py_XINCREF(V273);
15139
15140	{
15141
15142	    py_V275 = PyList_GET_ITEM(storage_V275, 0);
15143	    {Py_XINCREF(py_V275);}
15144
15145	            V275 = NULL;
15146	            if (py_V275 == Py_None) {
15147	                // We can either fail here or set V275 to NULL and rely on Ops
15148	                // using tensors to handle the NULL case, but if they fail to do so
15149	                // they'll end up with nasty segfaults, so this is public service.
15150	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
15151	                {
15152	        __failure = 276;
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_276;}
15159	            }
15160	            if (!PyArray_Check(py_V275)) {
15161	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
15162	                {
15163	        __failure = 276;
15164	        if (!PyErr_Occurred()) {
15165	            PyErr_SetString(PyExc_RuntimeError,
15166	                "Unexpected error in an Op's C code. "
15167	                "No Python exception was set.");
15168	            }
15169	        goto __label_276;}
15170	            }
15171	            // We expect NPY_INT8
15172	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V275)) {
15173	                PyArrayObject * tmp = (PyArrayObject*) py_V275;
15174	                PyErr_Format(PyExc_NotImplementedError,
15175	                             "expected an aligned array of type %ld "
15176	                             "(NPY_INT8), got non-aligned array of type %ld"
15177	                             " with %ld dimensions, with 3 last dims "
15178	                             "%ld, %ld, %ld"
15179	                             " and 3 last strides %ld %ld, %ld.",
15180	                             (long int) NPY_INT8,
15181	                             (long int) PyArray_TYPE((PyArrayObject*) py_V275),
15182	                             (long int) PyArray_NDIM(tmp),
15183	                             (long int) PyArray_NDIM(tmp) >= 3 ?
15184	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
15185	                             (long int) PyArray_NDIM(tmp) >= 2 ?
15186	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
15187	                             (long int) PyArray_NDIM(tmp) >= 1 ?
15188	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
15189	                             (long int) PyArray_NDIM(tmp) >= 3 ?
15190	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
15191	                             (long int) PyArray_NDIM(tmp) >= 2 ?
15192	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
15193	                             (long int) PyArray_NDIM(tmp) >= 1 ?
15194	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
15195	            );
15196	                {
15197	        __failure = 276;
15198	        if (!PyErr_Occurred()) {
15199	            PyErr_SetString(PyExc_RuntimeError,
15200	                "Unexpected error in an Op's C code. "
15201	                "No Python exception was set.");
15202	            }
15203	        goto __label_276;}
15204	            }
15205	            // This is a TypeError to be consistent with DEBUG_MODE
15206	            // Note: DEBUG_MODE also tells the name of the container
15207	            if (PyArray_TYPE((PyArrayObject*) py_V275) != NPY_INT8) {
15208	                PyErr_Format(PyExc_TypeError,
15209	                             "expected type_num %d (NPY_INT8) got %d",
15210	                             NPY_INT8, PyArray_TYPE((PyArrayObject*) py_V275));
15211	                {
15212	        __failure = 276;
15213	        if (!PyErr_Occurred()) {
15214	            PyErr_SetString(PyExc_RuntimeError,
15215	                "Unexpected error in an Op's C code. "
15216	                "No Python exception was set.");
15217	            }
15218	        goto __label_276;}
15219	            }
15220
15221	        V275 = (PyArrayObject*)(py_V275);
15222	        Py_XINCREF(V275);
15223
15224	{
15225
15226	    py_V277 = PyList_GET_ITEM(storage_V277, 0);
15227	    {Py_XINCREF(py_V277);}
15228
15229	            V277 = NULL;
15230	            if (py_V277 == Py_None) {
15231	                // We can either fail here or set V277 to NULL and rely on Ops
15232	                // using tensors to handle the NULL case, but if they fail to do so
15233	                // they'll end up with nasty segfaults, so this is public service.
15234	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
15235	                {
15236	        __failure = 278;
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_278;}
15243	            }
15244	            if (!PyArray_Check(py_V277)) {
15245	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
15246	                {
15247	        __failure = 278;
15248	        if (!PyErr_Occurred()) {
15249	            PyErr_SetString(PyExc_RuntimeError,
15250	                "Unexpected error in an Op's C code. "
15251	                "No Python exception was set.");
15252	            }
15253	        goto __label_278;}
15254	            }
15255	            // We expect NPY_FLOAT64
15256	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V277)) {
15257	                PyArrayObject * tmp = (PyArrayObject*) py_V277;
15258	                PyErr_Format(PyExc_NotImplementedError,
15259	                             "expected an aligned array of type %ld "
15260	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
15261	                             " with %ld dimensions, with 3 last dims "
15262	                             "%ld, %ld, %ld"
15263	                             " and 3 last strides %ld %ld, %ld.",
15264	                             (long int) NPY_FLOAT64,
15265	                             (long int) PyArray_TYPE((PyArrayObject*) py_V277),
15266	                             (long int) PyArray_NDIM(tmp),
15267	                             (long int) PyArray_NDIM(tmp) >= 3 ?
15268	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
15269	                             (long int) PyArray_NDIM(tmp) >= 2 ?
15270	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
15271	                             (long int) PyArray_NDIM(tmp) >= 1 ?
15272	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
15273	                             (long int) PyArray_NDIM(tmp) >= 3 ?
15274	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
15275	                             (long int) PyArray_NDIM(tmp) >= 2 ?
15276	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
15277	                             (long int) PyArray_NDIM(tmp) >= 1 ?
15278	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
15279	            );
15280	                {
15281	        __failure = 278;
15282	        if (!PyErr_Occurred()) {
15283	            PyErr_SetString(PyExc_RuntimeError,
15284	                "Unexpected error in an Op's C code. "
15285	                "No Python exception was set.");
15286	            }
15287	        goto __label_278;}
15288	            }
15289	            // This is a TypeError to be consistent with DEBUG_MODE
15290	            // Note: DEBUG_MODE also tells the name of the container
15291	            if (PyArray_TYPE((PyArrayObject*) py_V277) != NPY_FLOAT64) {
15292	                PyErr_Format(PyExc_TypeError,
15293	                             "expected type_num %d (NPY_FLOAT64) got %d",
15294	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V277));
15295	                {
15296	        __failure = 278;
15297	        if (!PyErr_Occurred()) {
15298	            PyErr_SetString(PyExc_RuntimeError,
15299	                "Unexpected error in an Op's C code. "
15300	                "No Python exception was set.");
15301	            }
15302	        goto __label_278;}
15303	            }
15304
15305	        V277 = (PyArrayObject*)(py_V277);
15306	        Py_XINCREF(V277);
15307
15308	{
15309
15310	    py_V279 = PyList_GET_ITEM(storage_V279, 0);
15311	    {Py_XINCREF(py_V279);}
15312
15313	            V279 = NULL;
15314	            if (py_V279 == Py_None) {
15315	                // We can either fail here or set V279 to NULL and rely on Ops
15316	                // using tensors to handle the NULL case, but if they fail to do so
15317	                // they'll end up with nasty segfaults, so this is public service.
15318	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
15319	                {
15320	        __failure = 280;
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_280;}
15327	            }
15328	            if (!PyArray_Check(py_V279)) {
15329	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
15330	                {
15331	        __failure = 280;
15332	        if (!PyErr_Occurred()) {
15333	            PyErr_SetString(PyExc_RuntimeError,
15334	                "Unexpected error in an Op's C code. "
15335	                "No Python exception was set.");
15336	            }
15337	        goto __label_280;}
15338	            }
15339	            // We expect NPY_FLOAT64
15340	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V279)) {
15341	                PyArrayObject * tmp = (PyArrayObject*) py_V279;
15342	                PyErr_Format(PyExc_NotImplementedError,
15343	                             "expected an aligned array of type %ld "
15344	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
15345	                             " with %ld dimensions, with 3 last dims "
15346	                             "%ld, %ld, %ld"
15347	                             " and 3 last strides %ld %ld, %ld.",
15348	                             (long int) NPY_FLOAT64,
15349	                             (long int) PyArray_TYPE((PyArrayObject*) py_V279),
15350	                             (long int) PyArray_NDIM(tmp),
15351	                             (long int) PyArray_NDIM(tmp) >= 3 ?
15352	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
15353	                             (long int) PyArray_NDIM(tmp) >= 2 ?
15354	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
15355	                             (long int) PyArray_NDIM(tmp) >= 1 ?
15356	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
15357	                             (long int) PyArray_NDIM(tmp) >= 3 ?
15358	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
15359	                             (long int) PyArray_NDIM(tmp) >= 2 ?
15360	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
15361	                             (long int) PyArray_NDIM(tmp) >= 1 ?
15362	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
15363	            );
15364	                {
15365	        __failure = 280;
15366	        if (!PyErr_Occurred()) {
15367	            PyErr_SetString(PyExc_RuntimeError,
15368	                "Unexpected error in an Op's C code. "
15369	                "No Python exception was set.");
15370	            }
15371	        goto __label_280;}
15372	            }
15373	            // This is a TypeError to be consistent with DEBUG_MODE
15374	            // Note: DEBUG_MODE also tells the name of the container
15375	            if (PyArray_TYPE((PyArrayObject*) py_V279) != NPY_FLOAT64) {
15376	                PyErr_Format(PyExc_TypeError,
15377	                             "expected type_num %d (NPY_FLOAT64) got %d",
15378	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V279));
15379	                {
15380	        __failure = 280;
15381	        if (!PyErr_Occurred()) {
15382	            PyErr_SetString(PyExc_RuntimeError,
15383	                "Unexpected error in an Op's C code. "
15384	                "No Python exception was set.");
15385	            }
15386	        goto __label_280;}
15387	            }
15388
15389	        V279 = (PyArrayObject*)(py_V279);
15390	        Py_XINCREF(V279);
15391
15392	{
15393
15394	    py_V281 = PyList_GET_ITEM(storage_V281, 0);
15395	    {Py_XINCREF(py_V281);}
15396
15397	            V281 = NULL;
15398	            if (py_V281 == Py_None) {
15399	                // We can either fail here or set V281 to NULL and rely on Ops
15400	                // using tensors to handle the NULL case, but if they fail to do so
15401	                // they'll end up with nasty segfaults, so this is public service.
15402	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
15403	                {
15404	        __failure = 282;
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_282;}
15411	            }
15412	            if (!PyArray_Check(py_V281)) {
15413	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
15414	                {
15415	        __failure = 282;
15416	        if (!PyErr_Occurred()) {
15417	            PyErr_SetString(PyExc_RuntimeError,
15418	                "Unexpected error in an Op's C code. "
15419	                "No Python exception was set.");
15420	            }
15421	        goto __label_282;}
15422	            }
15423	            // We expect NPY_FLOAT64
15424	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V281)) {
15425	                PyArrayObject * tmp = (PyArrayObject*) py_V281;
15426	                PyErr_Format(PyExc_NotImplementedError,
15427	                             "expected an aligned array of type %ld "
15428	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
15429	                             " with %ld dimensions, with 3 last dims "
15430	                             "%ld, %ld, %ld"
15431	                             " and 3 last strides %ld %ld, %ld.",
15432	                             (long int) NPY_FLOAT64,
15433	                             (long int) PyArray_TYPE((PyArrayObject*) py_V281),
15434	                             (long int) PyArray_NDIM(tmp),
15435	                             (long int) PyArray_NDIM(tmp) >= 3 ?
15436	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
15437	                             (long int) PyArray_NDIM(tmp) >= 2 ?
15438	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
15439	                             (long int) PyArray_NDIM(tmp) >= 1 ?
15440	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
15441	                             (long int) PyArray_NDIM(tmp) >= 3 ?
15442	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
15443	                             (long int) PyArray_NDIM(tmp) >= 2 ?
15444	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
15445	                             (long int) PyArray_NDIM(tmp) >= 1 ?
15446	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
15447	            );
15448	                {
15449	        __failure = 282;
15450	        if (!PyErr_Occurred()) {
15451	            PyErr_SetString(PyExc_RuntimeError,
15452	                "Unexpected error in an Op's C code. "
15453	                "No Python exception was set.");
15454	            }
15455	        goto __label_282;}
15456	            }
15457	            // This is a TypeError to be consistent with DEBUG_MODE
15458	            // Note: DEBUG_MODE also tells the name of the container
15459	            if (PyArray_TYPE((PyArrayObject*) py_V281) != NPY_FLOAT64) {
15460	                PyErr_Format(PyExc_TypeError,
15461	                             "expected type_num %d (NPY_FLOAT64) got %d",
15462	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V281));
15463	                {
15464	        __failure = 282;
15465	        if (!PyErr_Occurred()) {
15466	            PyErr_SetString(PyExc_RuntimeError,
15467	                "Unexpected error in an Op's C code. "
15468	                "No Python exception was set.");
15469	            }
15470	        goto __label_282;}
15471	            }
15472
15473	        V281 = (PyArrayObject*)(py_V281);
15474	        Py_XINCREF(V281);
15475
15476	{
15477
15478	    py_V283 = PyList_GET_ITEM(storage_V283, 0);
15479	    {Py_XINCREF(py_V283);}
15480
15481	            V283 = NULL;
15482	            if (py_V283 == Py_None) {
15483	                // We can either fail here or set V283 to NULL and rely on Ops
15484	                // using tensors to handle the NULL case, but if they fail to do so
15485	                // they'll end up with nasty segfaults, so this is public service.
15486	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
15487	                {
15488	        __failure = 284;
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_284;}
15495	            }
15496	            if (!PyArray_Check(py_V283)) {
15497	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
15498	                {
15499	        __failure = 284;
15500	        if (!PyErr_Occurred()) {
15501	            PyErr_SetString(PyExc_RuntimeError,
15502	                "Unexpected error in an Op's C code. "
15503	                "No Python exception was set.");
15504	            }
15505	        goto __label_284;}
15506	            }
15507	            // We expect NPY_FLOAT64
15508	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V283)) {
15509	                PyArrayObject * tmp = (PyArrayObject*) py_V283;
15510	                PyErr_Format(PyExc_NotImplementedError,
15511	                             "expected an aligned array of type %ld "
15512	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
15513	                             " with %ld dimensions, with 3 last dims "
15514	                             "%ld, %ld, %ld"
15515	                             " and 3 last strides %ld %ld, %ld.",
15516	                             (long int) NPY_FLOAT64,
15517	                             (long int) PyArray_TYPE((PyArrayObject*) py_V283),
15518	                             (long int) PyArray_NDIM(tmp),
15519	                             (long int) PyArray_NDIM(tmp) >= 3 ?
15520	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
15521	                             (long int) PyArray_NDIM(tmp) >= 2 ?
15522	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
15523	                             (long int) PyArray_NDIM(tmp) >= 1 ?
15524	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
15525	                             (long int) PyArray_NDIM(tmp) >= 3 ?
15526	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
15527	                             (long int) PyArray_NDIM(tmp) >= 2 ?
15528	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
15529	                             (long int) PyArray_NDIM(tmp) >= 1 ?
15530	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
15531	            );
15532	                {
15533	        __failure = 284;
15534	        if (!PyErr_Occurred()) {
15535	            PyErr_SetString(PyExc_RuntimeError,
15536	                "Unexpected error in an Op's C code. "
15537	                "No Python exception was set.");
15538	            }
15539	        goto __label_284;}
15540	            }
15541	            // This is a TypeError to be consistent with DEBUG_MODE
15542	            // Note: DEBUG_MODE also tells the name of the container
15543	            if (PyArray_TYPE((PyArrayObject*) py_V283) != NPY_FLOAT64) {
15544	                PyErr_Format(PyExc_TypeError,
15545	                             "expected type_num %d (NPY_FLOAT64) got %d",
15546	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V283));
15547	                {
15548	        __failure = 284;
15549	        if (!PyErr_Occurred()) {
15550	            PyErr_SetString(PyExc_RuntimeError,
15551	                "Unexpected error in an Op's C code. "
15552	                "No Python exception was set.");
15553	            }
15554	        goto __label_284;}
15555	            }
15556
15557	        V283 = (PyArrayObject*)(py_V283);
15558	        Py_XINCREF(V283);
15559
15560	{
15561
15562	    py_V285 = PyList_GET_ITEM(storage_V285, 0);
15563	    {Py_XINCREF(py_V285);}
15564
15565	            V285 = NULL;
15566	            if (py_V285 == Py_None) {
15567	                // We can either fail here or set V285 to NULL and rely on Ops
15568	                // using tensors to handle the NULL case, but if they fail to do so
15569	                // they'll end up with nasty segfaults, so this is public service.
15570	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
15571	                {
15572	        __failure = 286;
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_286;}
15579	            }
15580	            if (!PyArray_Check(py_V285)) {
15581	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
15582	                {
15583	        __failure = 286;
15584	        if (!PyErr_Occurred()) {
15585	            PyErr_SetString(PyExc_RuntimeError,
15586	                "Unexpected error in an Op's C code. "
15587	                "No Python exception was set.");
15588	            }
15589	        goto __label_286;}
15590	            }
15591	            // We expect NPY_FLOAT64
15592	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V285)) {
15593	                PyArrayObject * tmp = (PyArrayObject*) py_V285;
15594	                PyErr_Format(PyExc_NotImplementedError,
15595	                             "expected an aligned array of type %ld "
15596	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
15597	                             " with %ld dimensions, with 3 last dims "
15598	                             "%ld, %ld, %ld"
15599	                             " and 3 last strides %ld %ld, %ld.",
15600	                             (long int) NPY_FLOAT64,
15601	                             (long int) PyArray_TYPE((PyArrayObject*) py_V285),
15602	                             (long int) PyArray_NDIM(tmp),
15603	                             (long int) PyArray_NDIM(tmp) >= 3 ?
15604	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
15605	                             (long int) PyArray_NDIM(tmp) >= 2 ?
15606	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
15607	                             (long int) PyArray_NDIM(tmp) >= 1 ?
15608	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
15609	                             (long int) PyArray_NDIM(tmp) >= 3 ?
15610	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
15611	                             (long int) PyArray_NDIM(tmp) >= 2 ?
15612	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
15613	                             (long int) PyArray_NDIM(tmp) >= 1 ?
15614	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
15615	            );
15616	                {
15617	        __failure = 286;
15618	        if (!PyErr_Occurred()) {
15619	            PyErr_SetString(PyExc_RuntimeError,
15620	                "Unexpected error in an Op's C code. "
15621	                "No Python exception was set.");
15622	            }
15623	        goto __label_286;}
15624	            }
15625	            // This is a TypeError to be consistent with DEBUG_MODE
15626	            // Note: DEBUG_MODE also tells the name of the container
15627	            if (PyArray_TYPE((PyArrayObject*) py_V285) != NPY_FLOAT64) {
15628	                PyErr_Format(PyExc_TypeError,
15629	                             "expected type_num %d (NPY_FLOAT64) got %d",
15630	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V285));
15631	                {
15632	        __failure = 286;
15633	        if (!PyErr_Occurred()) {
15634	            PyErr_SetString(PyExc_RuntimeError,
15635	                "Unexpected error in an Op's C code. "
15636	                "No Python exception was set.");
15637	            }
15638	        goto __label_286;}
15639	            }
15640
15641	        V285 = (PyArrayObject*)(py_V285);
15642	        Py_XINCREF(V285);
15643
15644	{
15645
15646	    py_V287 = PyList_GET_ITEM(storage_V287, 0);
15647	    {Py_XINCREF(py_V287);}
15648
15649	            V287 = NULL;
15650	            if (py_V287 == Py_None) {
15651	                // We can either fail here or set V287 to NULL and rely on Ops
15652	                // using tensors to handle the NULL case, but if they fail to do so
15653	                // they'll end up with nasty segfaults, so this is public service.
15654	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
15655	                {
15656	        __failure = 288;
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_288;}
15663	            }
15664	            if (!PyArray_Check(py_V287)) {
15665	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
15666	                {
15667	        __failure = 288;
15668	        if (!PyErr_Occurred()) {
15669	            PyErr_SetString(PyExc_RuntimeError,
15670	                "Unexpected error in an Op's C code. "
15671	                "No Python exception was set.");
15672	            }
15673	        goto __label_288;}
15674	            }
15675	            // We expect NPY_INT8
15676	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V287)) {
15677	                PyArrayObject * tmp = (PyArrayObject*) py_V287;
15678	                PyErr_Format(PyExc_NotImplementedError,
15679	                             "expected an aligned array of type %ld "
15680	                             "(NPY_INT8), got non-aligned array of type %ld"
15681	                             " with %ld dimensions, with 3 last dims "
15682	                             "%ld, %ld, %ld"
15683	                             " and 3 last strides %ld %ld, %ld.",
15684	                             (long int) NPY_INT8,
15685	                             (long int) PyArray_TYPE((PyArrayObject*) py_V287),
15686	                             (long int) PyArray_NDIM(tmp),
15687	                             (long int) PyArray_NDIM(tmp) >= 3 ?
15688	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
15689	                             (long int) PyArray_NDIM(tmp) >= 2 ?
15690	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
15691	                             (long int) PyArray_NDIM(tmp) >= 1 ?
15692	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
15693	                             (long int) PyArray_NDIM(tmp) >= 3 ?
15694	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
15695	                             (long int) PyArray_NDIM(tmp) >= 2 ?
15696	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
15697	                             (long int) PyArray_NDIM(tmp) >= 1 ?
15698	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
15699	            );
15700	                {
15701	        __failure = 288;
15702	        if (!PyErr_Occurred()) {
15703	            PyErr_SetString(PyExc_RuntimeError,
15704	                "Unexpected error in an Op's C code. "
15705	                "No Python exception was set.");
15706	            }
15707	        goto __label_288;}
15708	            }
15709	            // This is a TypeError to be consistent with DEBUG_MODE
15710	            // Note: DEBUG_MODE also tells the name of the container
15711	            if (PyArray_TYPE((PyArrayObject*) py_V287) != NPY_INT8) {
15712	                PyErr_Format(PyExc_TypeError,
15713	                             "expected type_num %d (NPY_INT8) got %d",
15714	                             NPY_INT8, PyArray_TYPE((PyArrayObject*) py_V287));
15715	                {
15716	        __failure = 288;
15717	        if (!PyErr_Occurred()) {
15718	            PyErr_SetString(PyExc_RuntimeError,
15719	                "Unexpected error in an Op's C code. "
15720	                "No Python exception was set.");
15721	            }
15722	        goto __label_288;}
15723	            }
15724
15725	        V287 = (PyArrayObject*)(py_V287);
15726	        Py_XINCREF(V287);
15727
15728	{
15729
15730	    py_V289 = PyList_GET_ITEM(storage_V289, 0);
15731	    {Py_XINCREF(py_V289);}
15732
15733	            V289 = NULL;
15734	            if (py_V289 == Py_None) {
15735	                // We can either fail here or set V289 to NULL and rely on Ops
15736	                // using tensors to handle the NULL case, but if they fail to do so
15737	                // they'll end up with nasty segfaults, so this is public service.
15738	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
15739	                {
15740	        __failure = 290;
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_290;}
15747	            }
15748	            if (!PyArray_Check(py_V289)) {
15749	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
15750	                {
15751	        __failure = 290;
15752	        if (!PyErr_Occurred()) {
15753	            PyErr_SetString(PyExc_RuntimeError,
15754	                "Unexpected error in an Op's C code. "
15755	                "No Python exception was set.");
15756	            }
15757	        goto __label_290;}
15758	            }
15759	            // We expect NPY_FLOAT64
15760	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V289)) {
15761	                PyArrayObject * tmp = (PyArrayObject*) py_V289;
15762	                PyErr_Format(PyExc_NotImplementedError,
15763	                             "expected an aligned array of type %ld "
15764	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
15765	                             " with %ld dimensions, with 3 last dims "
15766	                             "%ld, %ld, %ld"
15767	                             " and 3 last strides %ld %ld, %ld.",
15768	                             (long int) NPY_FLOAT64,
15769	                             (long int) PyArray_TYPE((PyArrayObject*) py_V289),
15770	                             (long int) PyArray_NDIM(tmp),
15771	                             (long int) PyArray_NDIM(tmp) >= 3 ?
15772	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
15773	                             (long int) PyArray_NDIM(tmp) >= 2 ?
15774	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
15775	                             (long int) PyArray_NDIM(tmp) >= 1 ?
15776	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
15777	                             (long int) PyArray_NDIM(tmp) >= 3 ?
15778	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
15779	                             (long int) PyArray_NDIM(tmp) >= 2 ?
15780	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
15781	                             (long int) PyArray_NDIM(tmp) >= 1 ?
15782	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
15783	            );
15784	                {
15785	        __failure = 290;
15786	        if (!PyErr_Occurred()) {
15787	            PyErr_SetString(PyExc_RuntimeError,
15788	                "Unexpected error in an Op's C code. "
15789	                "No Python exception was set.");
15790	            }
15791	        goto __label_290;}
15792	            }
15793	            // This is a TypeError to be consistent with DEBUG_MODE
15794	            // Note: DEBUG_MODE also tells the name of the container
15795	            if (PyArray_TYPE((PyArrayObject*) py_V289) != NPY_FLOAT64) {
15796	                PyErr_Format(PyExc_TypeError,
15797	                             "expected type_num %d (NPY_FLOAT64) got %d",
15798	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V289));
15799	                {
15800	        __failure = 290;
15801	        if (!PyErr_Occurred()) {
15802	            PyErr_SetString(PyExc_RuntimeError,
15803	                "Unexpected error in an Op's C code. "
15804	                "No Python exception was set.");
15805	            }
15806	        goto __label_290;}
15807	            }
15808
15809	        V289 = (PyArrayObject*)(py_V289);
15810	        Py_XINCREF(V289);
15811
15812	{
15813
15814	    py_V291 = PyList_GET_ITEM(storage_V291, 0);
15815	    {Py_XINCREF(py_V291);}
15816
15817	            V291 = NULL;
15818	            if (py_V291 == Py_None) {
15819	                // We can either fail here or set V291 to NULL and rely on Ops
15820	                // using tensors to handle the NULL case, but if they fail to do so
15821	                // they'll end up with nasty segfaults, so this is public service.
15822	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
15823	                {
15824	        __failure = 292;
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_292;}
15831	            }
15832	            if (!PyArray_Check(py_V291)) {
15833	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
15834	                {
15835	        __failure = 292;
15836	        if (!PyErr_Occurred()) {
15837	            PyErr_SetString(PyExc_RuntimeError,
15838	                "Unexpected error in an Op's C code. "
15839	                "No Python exception was set.");
15840	            }
15841	        goto __label_292;}
15842	            }
15843	            // We expect NPY_FLOAT64
15844	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V291)) {
15845	                PyArrayObject * tmp = (PyArrayObject*) py_V291;
15846	                PyErr_Format(PyExc_NotImplementedError,
15847	                             "expected an aligned array of type %ld "
15848	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
15849	                             " with %ld dimensions, with 3 last dims "
15850	                             "%ld, %ld, %ld"
15851	                             " and 3 last strides %ld %ld, %ld.",
15852	                             (long int) NPY_FLOAT64,
15853	                             (long int) PyArray_TYPE((PyArrayObject*) py_V291),
15854	                             (long int) PyArray_NDIM(tmp),
15855	                             (long int) PyArray_NDIM(tmp) >= 3 ?
15856	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
15857	                             (long int) PyArray_NDIM(tmp) >= 2 ?
15858	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
15859	                             (long int) PyArray_NDIM(tmp) >= 1 ?
15860	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
15861	                             (long int) PyArray_NDIM(tmp) >= 3 ?
15862	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
15863	                             (long int) PyArray_NDIM(tmp) >= 2 ?
15864	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
15865	                             (long int) PyArray_NDIM(tmp) >= 1 ?
15866	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
15867	            );
15868	                {
15869	        __failure = 292;
15870	        if (!PyErr_Occurred()) {
15871	            PyErr_SetString(PyExc_RuntimeError,
15872	                "Unexpected error in an Op's C code. "
15873	                "No Python exception was set.");
15874	            }
15875	        goto __label_292;}
15876	            }
15877	            // This is a TypeError to be consistent with DEBUG_MODE
15878	            // Note: DEBUG_MODE also tells the name of the container
15879	            if (PyArray_TYPE((PyArrayObject*) py_V291) != NPY_FLOAT64) {
15880	                PyErr_Format(PyExc_TypeError,
15881	                             "expected type_num %d (NPY_FLOAT64) got %d",
15882	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V291));
15883	                {
15884	        __failure = 292;
15885	        if (!PyErr_Occurred()) {
15886	            PyErr_SetString(PyExc_RuntimeError,
15887	                "Unexpected error in an Op's C code. "
15888	                "No Python exception was set.");
15889	            }
15890	        goto __label_292;}
15891	            }
15892
15893	        V291 = (PyArrayObject*)(py_V291);
15894	        Py_XINCREF(V291);
15895
15896	{
15897
15898	    py_V293 = PyList_GET_ITEM(storage_V293, 0);
15899	    {Py_XINCREF(py_V293);}
15900
15901	            V293 = NULL;
15902	            if (py_V293 == Py_None) {
15903	                // We can either fail here or set V293 to NULL and rely on Ops
15904	                // using tensors to handle the NULL case, but if they fail to do so
15905	                // they'll end up with nasty segfaults, so this is public service.
15906	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
15907	                {
15908	        __failure = 294;
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_294;}
15915	            }
15916	            if (!PyArray_Check(py_V293)) {
15917	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
15918	                {
15919	        __failure = 294;
15920	        if (!PyErr_Occurred()) {
15921	            PyErr_SetString(PyExc_RuntimeError,
15922	                "Unexpected error in an Op's C code. "
15923	                "No Python exception was set.");
15924	            }
15925	        goto __label_294;}
15926	            }
15927	            // We expect NPY_FLOAT64
15928	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V293)) {
15929	                PyArrayObject * tmp = (PyArrayObject*) py_V293;
15930	                PyErr_Format(PyExc_NotImplementedError,
15931	                             "expected an aligned array of type %ld "
15932	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
15933	                             " with %ld dimensions, with 3 last dims "
15934	                             "%ld, %ld, %ld"
15935	                             " and 3 last strides %ld %ld, %ld.",
15936	                             (long int) NPY_FLOAT64,
15937	                             (long int) PyArray_TYPE((PyArrayObject*) py_V293),
15938	                             (long int) PyArray_NDIM(tmp),
15939	                             (long int) PyArray_NDIM(tmp) >= 3 ?
15940	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
15941	                             (long int) PyArray_NDIM(tmp) >= 2 ?
15942	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
15943	                             (long int) PyArray_NDIM(tmp) >= 1 ?
15944	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
15945	                             (long int) PyArray_NDIM(tmp) >= 3 ?
15946	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
15947	                             (long int) PyArray_NDIM(tmp) >= 2 ?
15948	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
15949	                             (long int) PyArray_NDIM(tmp) >= 1 ?
15950	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
15951	            );
15952	                {
15953	        __failure = 294;
15954	        if (!PyErr_Occurred()) {
15955	            PyErr_SetString(PyExc_RuntimeError,
15956	                "Unexpected error in an Op's C code. "
15957	                "No Python exception was set.");
15958	            }
15959	        goto __label_294;}
15960	            }
15961	            // This is a TypeError to be consistent with DEBUG_MODE
15962	            // Note: DEBUG_MODE also tells the name of the container
15963	            if (PyArray_TYPE((PyArrayObject*) py_V293) != NPY_FLOAT64) {
15964	                PyErr_Format(PyExc_TypeError,
15965	                             "expected type_num %d (NPY_FLOAT64) got %d",
15966	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V293));
15967	                {
15968	        __failure = 294;
15969	        if (!PyErr_Occurred()) {
15970	            PyErr_SetString(PyExc_RuntimeError,
15971	                "Unexpected error in an Op's C code. "
15972	                "No Python exception was set.");
15973	            }
15974	        goto __label_294;}
15975	            }
15976
15977	        V293 = (PyArrayObject*)(py_V293);
15978	        Py_XINCREF(V293);
15979
15980	{
15981
15982	    py_V295 = PyList_GET_ITEM(storage_V295, 0);
15983	    {Py_XINCREF(py_V295);}
15984
15985	            V295 = NULL;
15986	            if (py_V295 == Py_None) {
15987	                // We can either fail here or set V295 to NULL and rely on Ops
15988	                // using tensors to handle the NULL case, but if they fail to do so
15989	                // they'll end up with nasty segfaults, so this is public service.
15990	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
15991	                {
15992	        __failure = 296;
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_296;}
15999	            }
16000	            if (!PyArray_Check(py_V295)) {
16001	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
16002	                {
16003	        __failure = 296;
16004	        if (!PyErr_Occurred()) {
16005	            PyErr_SetString(PyExc_RuntimeError,
16006	                "Unexpected error in an Op's C code. "
16007	                "No Python exception was set.");
16008	            }
16009	        goto __label_296;}
16010	            }
16011	            // We expect NPY_FLOAT64
16012	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V295)) {
16013	                PyArrayObject * tmp = (PyArrayObject*) py_V295;
16014	                PyErr_Format(PyExc_NotImplementedError,
16015	                             "expected an aligned array of type %ld "
16016	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
16017	                             " with %ld dimensions, with 3 last dims "
16018	                             "%ld, %ld, %ld"
16019	                             " and 3 last strides %ld %ld, %ld.",
16020	                             (long int) NPY_FLOAT64,
16021	                             (long int) PyArray_TYPE((PyArrayObject*) py_V295),
16022	                             (long int) PyArray_NDIM(tmp),
16023	                             (long int) PyArray_NDIM(tmp) >= 3 ?
16024	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
16025	                             (long int) PyArray_NDIM(tmp) >= 2 ?
16026	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
16027	                             (long int) PyArray_NDIM(tmp) >= 1 ?
16028	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
16029	                             (long int) PyArray_NDIM(tmp) >= 3 ?
16030	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
16031	                             (long int) PyArray_NDIM(tmp) >= 2 ?
16032	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
16033	                             (long int) PyArray_NDIM(tmp) >= 1 ?
16034	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
16035	            );
16036	                {
16037	        __failure = 296;
16038	        if (!PyErr_Occurred()) {
16039	            PyErr_SetString(PyExc_RuntimeError,
16040	                "Unexpected error in an Op's C code. "
16041	                "No Python exception was set.");
16042	            }
16043	        goto __label_296;}
16044	            }
16045	            // This is a TypeError to be consistent with DEBUG_MODE
16046	            // Note: DEBUG_MODE also tells the name of the container
16047	            if (PyArray_TYPE((PyArrayObject*) py_V295) != NPY_FLOAT64) {
16048	                PyErr_Format(PyExc_TypeError,
16049	                             "expected type_num %d (NPY_FLOAT64) got %d",
16050	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V295));
16051	                {
16052	        __failure = 296;
16053	        if (!PyErr_Occurred()) {
16054	            PyErr_SetString(PyExc_RuntimeError,
16055	                "Unexpected error in an Op's C code. "
16056	                "No Python exception was set.");
16057	            }
16058	        goto __label_296;}
16059	            }
16060
16061	        V295 = (PyArrayObject*)(py_V295);
16062	        Py_XINCREF(V295);
16063
16064	{
16065
16066	    py_V297 = PyList_GET_ITEM(storage_V297, 0);
16067	    {Py_XINCREF(py_V297);}
16068
16069	            V297 = NULL;
16070	            if (py_V297 == Py_None) {
16071	                // We can either fail here or set V297 to NULL and rely on Ops
16072	                // using tensors to handle the NULL case, but if they fail to do so
16073	                // they'll end up with nasty segfaults, so this is public service.
16074	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
16075	                {
16076	        __failure = 298;
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_298;}
16083	            }
16084	            if (!PyArray_Check(py_V297)) {
16085	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
16086	                {
16087	        __failure = 298;
16088	        if (!PyErr_Occurred()) {
16089	            PyErr_SetString(PyExc_RuntimeError,
16090	                "Unexpected error in an Op's C code. "
16091	                "No Python exception was set.");
16092	            }
16093	        goto __label_298;}
16094	            }
16095	            // We expect NPY_FLOAT64
16096	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V297)) {
16097	                PyArrayObject * tmp = (PyArrayObject*) py_V297;
16098	                PyErr_Format(PyExc_NotImplementedError,
16099	                             "expected an aligned array of type %ld "
16100	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
16101	                             " with %ld dimensions, with 3 last dims "
16102	                             "%ld, %ld, %ld"
16103	                             " and 3 last strides %ld %ld, %ld.",
16104	                             (long int) NPY_FLOAT64,
16105	                             (long int) PyArray_TYPE((PyArrayObject*) py_V297),
16106	                             (long int) PyArray_NDIM(tmp),
16107	                             (long int) PyArray_NDIM(tmp) >= 3 ?
16108	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
16109	                             (long int) PyArray_NDIM(tmp) >= 2 ?
16110	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
16111	                             (long int) PyArray_NDIM(tmp) >= 1 ?
16112	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
16113	                             (long int) PyArray_NDIM(tmp) >= 3 ?
16114	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
16115	                             (long int) PyArray_NDIM(tmp) >= 2 ?
16116	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
16117	                             (long int) PyArray_NDIM(tmp) >= 1 ?
16118	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
16119	            );
16120	                {
16121	        __failure = 298;
16122	        if (!PyErr_Occurred()) {
16123	            PyErr_SetString(PyExc_RuntimeError,
16124	                "Unexpected error in an Op's C code. "
16125	                "No Python exception was set.");
16126	            }
16127	        goto __label_298;}
16128	            }
16129	            // This is a TypeError to be consistent with DEBUG_MODE
16130	            // Note: DEBUG_MODE also tells the name of the container
16131	            if (PyArray_TYPE((PyArrayObject*) py_V297) != NPY_FLOAT64) {
16132	                PyErr_Format(PyExc_TypeError,
16133	                             "expected type_num %d (NPY_FLOAT64) got %d",
16134	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V297));
16135	                {
16136	        __failure = 298;
16137	        if (!PyErr_Occurred()) {
16138	            PyErr_SetString(PyExc_RuntimeError,
16139	                "Unexpected error in an Op's C code. "
16140	                "No Python exception was set.");
16141	            }
16142	        goto __label_298;}
16143	            }
16144
16145	        V297 = (PyArrayObject*)(py_V297);
16146	        Py_XINCREF(V297);
16147
16148	{
16149
16150	    py_V299 = PyList_GET_ITEM(storage_V299, 0);
16151	    {Py_XINCREF(py_V299);}
16152
16153	            V299 = NULL;
16154	            if (py_V299 == Py_None) {
16155	                // We can either fail here or set V299 to NULL and rely on Ops
16156	                // using tensors to handle the NULL case, but if they fail to do so
16157	                // they'll end up with nasty segfaults, so this is public service.
16158	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
16159	                {
16160	        __failure = 300;
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_300;}
16167	            }
16168	            if (!PyArray_Check(py_V299)) {
16169	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
16170	                {
16171	        __failure = 300;
16172	        if (!PyErr_Occurred()) {
16173	            PyErr_SetString(PyExc_RuntimeError,
16174	                "Unexpected error in an Op's C code. "
16175	                "No Python exception was set.");
16176	            }
16177	        goto __label_300;}
16178	            }
16179	            // We expect NPY_FLOAT64
16180	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V299)) {
16181	                PyArrayObject * tmp = (PyArrayObject*) py_V299;
16182	                PyErr_Format(PyExc_NotImplementedError,
16183	                             "expected an aligned array of type %ld "
16184	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
16185	                             " with %ld dimensions, with 3 last dims "
16186	                             "%ld, %ld, %ld"
16187	                             " and 3 last strides %ld %ld, %ld.",
16188	                             (long int) NPY_FLOAT64,
16189	                             (long int) PyArray_TYPE((PyArrayObject*) py_V299),
16190	                             (long int) PyArray_NDIM(tmp),
16191	                             (long int) PyArray_NDIM(tmp) >= 3 ?
16192	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
16193	                             (long int) PyArray_NDIM(tmp) >= 2 ?
16194	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
16195	                             (long int) PyArray_NDIM(tmp) >= 1 ?
16196	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
16197	                             (long int) PyArray_NDIM(tmp) >= 3 ?
16198	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
16199	                             (long int) PyArray_NDIM(tmp) >= 2 ?
16200	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
16201	                             (long int) PyArray_NDIM(tmp) >= 1 ?
16202	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
16203	            );
16204	                {
16205	        __failure = 300;
16206	        if (!PyErr_Occurred()) {
16207	            PyErr_SetString(PyExc_RuntimeError,
16208	                "Unexpected error in an Op's C code. "
16209	                "No Python exception was set.");
16210	            }
16211	        goto __label_300;}
16212	            }
16213	            // This is a TypeError to be consistent with DEBUG_MODE
16214	            // Note: DEBUG_MODE also tells the name of the container
16215	            if (PyArray_TYPE((PyArrayObject*) py_V299) != NPY_FLOAT64) {
16216	                PyErr_Format(PyExc_TypeError,
16217	                             "expected type_num %d (NPY_FLOAT64) got %d",
16218	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V299));
16219	                {
16220	        __failure = 300;
16221	        if (!PyErr_Occurred()) {
16222	            PyErr_SetString(PyExc_RuntimeError,
16223	                "Unexpected error in an Op's C code. "
16224	                "No Python exception was set.");
16225	            }
16226	        goto __label_300;}
16227	            }
16228
16229	        V299 = (PyArrayObject*)(py_V299);
16230	        Py_XINCREF(V299);
16231
16232	{
16233
16234	    py_V301 = PyList_GET_ITEM(storage_V301, 0);
16235	    {Py_XINCREF(py_V301);}
16236
16237	            V301 = NULL;
16238	            if (py_V301 == Py_None) {
16239	                // We can either fail here or set V301 to NULL and rely on Ops
16240	                // using tensors to handle the NULL case, but if they fail to do so
16241	                // they'll end up with nasty segfaults, so this is public service.
16242	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
16243	                {
16244	        __failure = 302;
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_302;}
16251	            }
16252	            if (!PyArray_Check(py_V301)) {
16253	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
16254	                {
16255	        __failure = 302;
16256	        if (!PyErr_Occurred()) {
16257	            PyErr_SetString(PyExc_RuntimeError,
16258	                "Unexpected error in an Op's C code. "
16259	                "No Python exception was set.");
16260	            }
16261	        goto __label_302;}
16262	            }
16263	            // We expect NPY_INT8
16264	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V301)) {
16265	                PyArrayObject * tmp = (PyArrayObject*) py_V301;
16266	                PyErr_Format(PyExc_NotImplementedError,
16267	                             "expected an aligned array of type %ld "
16268	                             "(NPY_INT8), got non-aligned array of type %ld"
16269	                             " with %ld dimensions, with 3 last dims "
16270	                             "%ld, %ld, %ld"
16271	                             " and 3 last strides %ld %ld, %ld.",
16272	                             (long int) NPY_INT8,
16273	                             (long int) PyArray_TYPE((PyArrayObject*) py_V301),
16274	                             (long int) PyArray_NDIM(tmp),
16275	                             (long int) PyArray_NDIM(tmp) >= 3 ?
16276	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
16277	                             (long int) PyArray_NDIM(tmp) >= 2 ?
16278	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
16279	                             (long int) PyArray_NDIM(tmp) >= 1 ?
16280	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
16281	                             (long int) PyArray_NDIM(tmp) >= 3 ?
16282	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
16283	                             (long int) PyArray_NDIM(tmp) >= 2 ?
16284	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
16285	                             (long int) PyArray_NDIM(tmp) >= 1 ?
16286	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
16287	            );
16288	                {
16289	        __failure = 302;
16290	        if (!PyErr_Occurred()) {
16291	            PyErr_SetString(PyExc_RuntimeError,
16292	                "Unexpected error in an Op's C code. "
16293	                "No Python exception was set.");
16294	            }
16295	        goto __label_302;}
16296	            }
16297	            // This is a TypeError to be consistent with DEBUG_MODE
16298	            // Note: DEBUG_MODE also tells the name of the container
16299	            if (PyArray_TYPE((PyArrayObject*) py_V301) != NPY_INT8) {
16300	                PyErr_Format(PyExc_TypeError,
16301	                             "expected type_num %d (NPY_INT8) got %d",
16302	                             NPY_INT8, PyArray_TYPE((PyArrayObject*) py_V301));
16303	                {
16304	        __failure = 302;
16305	        if (!PyErr_Occurred()) {
16306	            PyErr_SetString(PyExc_RuntimeError,
16307	                "Unexpected error in an Op's C code. "
16308	                "No Python exception was set.");
16309	            }
16310	        goto __label_302;}
16311	            }
16312
16313	        V301 = (PyArrayObject*)(py_V301);
16314	        Py_XINCREF(V301);
16315
16316	{
16317
16318	    py_V303 = PyList_GET_ITEM(storage_V303, 0);
16319	    {Py_XINCREF(py_V303);}
16320
16321	            V303 = NULL;
16322	            if (py_V303 == Py_None) {
16323	                // We can either fail here or set V303 to NULL and rely on Ops
16324	                // using tensors to handle the NULL case, but if they fail to do so
16325	                // they'll end up with nasty segfaults, so this is public service.
16326	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
16327	                {
16328	        __failure = 304;
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_304;}
16335	            }
16336	            if (!PyArray_Check(py_V303)) {
16337	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
16338	                {
16339	        __failure = 304;
16340	        if (!PyErr_Occurred()) {
16341	            PyErr_SetString(PyExc_RuntimeError,
16342	                "Unexpected error in an Op's C code. "
16343	                "No Python exception was set.");
16344	            }
16345	        goto __label_304;}
16346	            }
16347	            // We expect NPY_FLOAT64
16348	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V303)) {
16349	                PyArrayObject * tmp = (PyArrayObject*) py_V303;
16350	                PyErr_Format(PyExc_NotImplementedError,
16351	                             "expected an aligned array of type %ld "
16352	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
16353	                             " with %ld dimensions, with 3 last dims "
16354	                             "%ld, %ld, %ld"
16355	                             " and 3 last strides %ld %ld, %ld.",
16356	                             (long int) NPY_FLOAT64,
16357	                             (long int) PyArray_TYPE((PyArrayObject*) py_V303),
16358	                             (long int) PyArray_NDIM(tmp),
16359	                             (long int) PyArray_NDIM(tmp) >= 3 ?
16360	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
16361	                             (long int) PyArray_NDIM(tmp) >= 2 ?
16362	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
16363	                             (long int) PyArray_NDIM(tmp) >= 1 ?
16364	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
16365	                             (long int) PyArray_NDIM(tmp) >= 3 ?
16366	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
16367	                             (long int) PyArray_NDIM(tmp) >= 2 ?
16368	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
16369	                             (long int) PyArray_NDIM(tmp) >= 1 ?
16370	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
16371	            );
16372	                {
16373	        __failure = 304;
16374	        if (!PyErr_Occurred()) {
16375	            PyErr_SetString(PyExc_RuntimeError,
16376	                "Unexpected error in an Op's C code. "
16377	                "No Python exception was set.");
16378	            }
16379	        goto __label_304;}
16380	            }
16381	            // This is a TypeError to be consistent with DEBUG_MODE
16382	            // Note: DEBUG_MODE also tells the name of the container
16383	            if (PyArray_TYPE((PyArrayObject*) py_V303) != NPY_FLOAT64) {
16384	                PyErr_Format(PyExc_TypeError,
16385	                             "expected type_num %d (NPY_FLOAT64) got %d",
16386	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V303));
16387	                {
16388	        __failure = 304;
16389	        if (!PyErr_Occurred()) {
16390	            PyErr_SetString(PyExc_RuntimeError,
16391	                "Unexpected error in an Op's C code. "
16392	                "No Python exception was set.");
16393	            }
16394	        goto __label_304;}
16395	            }
16396
16397	        V303 = (PyArrayObject*)(py_V303);
16398	        Py_XINCREF(V303);
16399
16400	{
16401
16402	    py_V305 = PyList_GET_ITEM(storage_V305, 0);
16403	    {Py_XINCREF(py_V305);}
16404
16405	            V305 = NULL;
16406	            if (py_V305 == Py_None) {
16407	                // We can either fail here or set V305 to NULL and rely on Ops
16408	                // using tensors to handle the NULL case, but if they fail to do so
16409	                // they'll end up with nasty segfaults, so this is public service.
16410	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
16411	                {
16412	        __failure = 306;
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_306;}
16419	            }
16420	            if (!PyArray_Check(py_V305)) {
16421	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
16422	                {
16423	        __failure = 306;
16424	        if (!PyErr_Occurred()) {
16425	            PyErr_SetString(PyExc_RuntimeError,
16426	                "Unexpected error in an Op's C code. "
16427	                "No Python exception was set.");
16428	            }
16429	        goto __label_306;}
16430	            }
16431	            // We expect NPY_FLOAT64
16432	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V305)) {
16433	                PyArrayObject * tmp = (PyArrayObject*) py_V305;
16434	                PyErr_Format(PyExc_NotImplementedError,
16435	                             "expected an aligned array of type %ld "
16436	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
16437	                             " with %ld dimensions, with 3 last dims "
16438	                             "%ld, %ld, %ld"
16439	                             " and 3 last strides %ld %ld, %ld.",
16440	                             (long int) NPY_FLOAT64,
16441	                             (long int) PyArray_TYPE((PyArrayObject*) py_V305),
16442	                             (long int) PyArray_NDIM(tmp),
16443	                             (long int) PyArray_NDIM(tmp) >= 3 ?
16444	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
16445	                             (long int) PyArray_NDIM(tmp) >= 2 ?
16446	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
16447	                             (long int) PyArray_NDIM(tmp) >= 1 ?
16448	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
16449	                             (long int) PyArray_NDIM(tmp) >= 3 ?
16450	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
16451	                             (long int) PyArray_NDIM(tmp) >= 2 ?
16452	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
16453	                             (long int) PyArray_NDIM(tmp) >= 1 ?
16454	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
16455	            );
16456	                {
16457	        __failure = 306;
16458	        if (!PyErr_Occurred()) {
16459	            PyErr_SetString(PyExc_RuntimeError,
16460	                "Unexpected error in an Op's C code. "
16461	                "No Python exception was set.");
16462	            }
16463	        goto __label_306;}
16464	            }
16465	            // This is a TypeError to be consistent with DEBUG_MODE
16466	            // Note: DEBUG_MODE also tells the name of the container
16467	            if (PyArray_TYPE((PyArrayObject*) py_V305) != NPY_FLOAT64) {
16468	                PyErr_Format(PyExc_TypeError,
16469	                             "expected type_num %d (NPY_FLOAT64) got %d",
16470	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V305));
16471	                {
16472	        __failure = 306;
16473	        if (!PyErr_Occurred()) {
16474	            PyErr_SetString(PyExc_RuntimeError,
16475	                "Unexpected error in an Op's C code. "
16476	                "No Python exception was set.");
16477	            }
16478	        goto __label_306;}
16479	            }
16480
16481	        V305 = (PyArrayObject*)(py_V305);
16482	        Py_XINCREF(V305);
16483
16484	{
16485
16486	    py_V307 = PyList_GET_ITEM(storage_V307, 0);
16487	    {Py_XINCREF(py_V307);}
16488
16489	            V307 = NULL;
16490	            if (py_V307 == Py_None) {
16491	                // We can either fail here or set V307 to NULL and rely on Ops
16492	                // using tensors to handle the NULL case, but if they fail to do so
16493	                // they'll end up with nasty segfaults, so this is public service.
16494	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
16495	                {
16496	        __failure = 308;
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_308;}
16503	            }
16504	            if (!PyArray_Check(py_V307)) {
16505	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
16506	                {
16507	        __failure = 308;
16508	        if (!PyErr_Occurred()) {
16509	            PyErr_SetString(PyExc_RuntimeError,
16510	                "Unexpected error in an Op's C code. "
16511	                "No Python exception was set.");
16512	            }
16513	        goto __label_308;}
16514	            }
16515	            // We expect NPY_FLOAT64
16516	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V307)) {
16517	                PyArrayObject * tmp = (PyArrayObject*) py_V307;
16518	                PyErr_Format(PyExc_NotImplementedError,
16519	                             "expected an aligned array of type %ld "
16520	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
16521	                             " with %ld dimensions, with 3 last dims "
16522	                             "%ld, %ld, %ld"
16523	                             " and 3 last strides %ld %ld, %ld.",
16524	                             (long int) NPY_FLOAT64,
16525	                             (long int) PyArray_TYPE((PyArrayObject*) py_V307),
16526	                             (long int) PyArray_NDIM(tmp),
16527	                             (long int) PyArray_NDIM(tmp) >= 3 ?
16528	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
16529	                             (long int) PyArray_NDIM(tmp) >= 2 ?
16530	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
16531	                             (long int) PyArray_NDIM(tmp) >= 1 ?
16532	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
16533	                             (long int) PyArray_NDIM(tmp) >= 3 ?
16534	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
16535	                             (long int) PyArray_NDIM(tmp) >= 2 ?
16536	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
16537	                             (long int) PyArray_NDIM(tmp) >= 1 ?
16538	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
16539	            );
16540	                {
16541	        __failure = 308;
16542	        if (!PyErr_Occurred()) {
16543	            PyErr_SetString(PyExc_RuntimeError,
16544	                "Unexpected error in an Op's C code. "
16545	                "No Python exception was set.");
16546	            }
16547	        goto __label_308;}
16548	            }
16549	            // This is a TypeError to be consistent with DEBUG_MODE
16550	            // Note: DEBUG_MODE also tells the name of the container
16551	            if (PyArray_TYPE((PyArrayObject*) py_V307) != NPY_FLOAT64) {
16552	                PyErr_Format(PyExc_TypeError,
16553	                             "expected type_num %d (NPY_FLOAT64) got %d",
16554	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V307));
16555	                {
16556	        __failure = 308;
16557	        if (!PyErr_Occurred()) {
16558	            PyErr_SetString(PyExc_RuntimeError,
16559	                "Unexpected error in an Op's C code. "
16560	                "No Python exception was set.");
16561	            }
16562	        goto __label_308;}
16563	            }
16564
16565	        V307 = (PyArrayObject*)(py_V307);
16566	        Py_XINCREF(V307);
16567
16568	{
16569
16570	    py_V309 = PyList_GET_ITEM(storage_V309, 0);
16571	    {Py_XINCREF(py_V309);}
16572
16573	            V309 = NULL;
16574	            if (py_V309 == Py_None) {
16575	                // We can either fail here or set V309 to NULL and rely on Ops
16576	                // using tensors to handle the NULL case, but if they fail to do so
16577	                // they'll end up with nasty segfaults, so this is public service.
16578	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
16579	                {
16580	        __failure = 310;
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_310;}
16587	            }
16588	            if (!PyArray_Check(py_V309)) {
16589	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
16590	                {
16591	        __failure = 310;
16592	        if (!PyErr_Occurred()) {
16593	            PyErr_SetString(PyExc_RuntimeError,
16594	                "Unexpected error in an Op's C code. "
16595	                "No Python exception was set.");
16596	            }
16597	        goto __label_310;}
16598	            }
16599	            // We expect NPY_FLOAT64
16600	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V309)) {
16601	                PyArrayObject * tmp = (PyArrayObject*) py_V309;
16602	                PyErr_Format(PyExc_NotImplementedError,
16603	                             "expected an aligned array of type %ld "
16604	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
16605	                             " with %ld dimensions, with 3 last dims "
16606	                             "%ld, %ld, %ld"
16607	                             " and 3 last strides %ld %ld, %ld.",
16608	                             (long int) NPY_FLOAT64,
16609	                             (long int) PyArray_TYPE((PyArrayObject*) py_V309),
16610	                             (long int) PyArray_NDIM(tmp),
16611	                             (long int) PyArray_NDIM(tmp) >= 3 ?
16612	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
16613	                             (long int) PyArray_NDIM(tmp) >= 2 ?
16614	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
16615	                             (long int) PyArray_NDIM(tmp) >= 1 ?
16616	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
16617	                             (long int) PyArray_NDIM(tmp) >= 3 ?
16618	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
16619	                             (long int) PyArray_NDIM(tmp) >= 2 ?
16620	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
16621	                             (long int) PyArray_NDIM(tmp) >= 1 ?
16622	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
16623	            );
16624	                {
16625	        __failure = 310;
16626	        if (!PyErr_Occurred()) {
16627	            PyErr_SetString(PyExc_RuntimeError,
16628	                "Unexpected error in an Op's C code. "
16629	                "No Python exception was set.");
16630	            }
16631	        goto __label_310;}
16632	            }
16633	            // This is a TypeError to be consistent with DEBUG_MODE
16634	            // Note: DEBUG_MODE also tells the name of the container
16635	            if (PyArray_TYPE((PyArrayObject*) py_V309) != NPY_FLOAT64) {
16636	                PyErr_Format(PyExc_TypeError,
16637	                             "expected type_num %d (NPY_FLOAT64) got %d",
16638	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V309));
16639	                {
16640	        __failure = 310;
16641	        if (!PyErr_Occurred()) {
16642	            PyErr_SetString(PyExc_RuntimeError,
16643	                "Unexpected error in an Op's C code. "
16644	                "No Python exception was set.");
16645	            }
16646	        goto __label_310;}
16647	            }
16648
16649	        V309 = (PyArrayObject*)(py_V309);
16650	        Py_XINCREF(V309);
16651
16652	{
16653
16654	    py_V311 = PyList_GET_ITEM(storage_V311, 0);
16655	    {Py_XINCREF(py_V311);}
16656
16657	            V311 = NULL;
16658	            if (py_V311 == Py_None) {
16659	                // We can either fail here or set V311 to NULL and rely on Ops
16660	                // using tensors to handle the NULL case, but if they fail to do so
16661	                // they'll end up with nasty segfaults, so this is public service.
16662	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
16663	                {
16664	        __failure = 312;
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_312;}
16671	            }
16672	            if (!PyArray_Check(py_V311)) {
16673	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
16674	                {
16675	        __failure = 312;
16676	        if (!PyErr_Occurred()) {
16677	            PyErr_SetString(PyExc_RuntimeError,
16678	                "Unexpected error in an Op's C code. "
16679	                "No Python exception was set.");
16680	            }
16681	        goto __label_312;}
16682	            }
16683	            // We expect NPY_FLOAT64
16684	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V311)) {
16685	                PyArrayObject * tmp = (PyArrayObject*) py_V311;
16686	                PyErr_Format(PyExc_NotImplementedError,
16687	                             "expected an aligned array of type %ld "
16688	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
16689	                             " with %ld dimensions, with 3 last dims "
16690	                             "%ld, %ld, %ld"
16691	                             " and 3 last strides %ld %ld, %ld.",
16692	                             (long int) NPY_FLOAT64,
16693	                             (long int) PyArray_TYPE((PyArrayObject*) py_V311),
16694	                             (long int) PyArray_NDIM(tmp),
16695	                             (long int) PyArray_NDIM(tmp) >= 3 ?
16696	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
16697	                             (long int) PyArray_NDIM(tmp) >= 2 ?
16698	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
16699	                             (long int) PyArray_NDIM(tmp) >= 1 ?
16700	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
16701	                             (long int) PyArray_NDIM(tmp) >= 3 ?
16702	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
16703	                             (long int) PyArray_NDIM(tmp) >= 2 ?
16704	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
16705	                             (long int) PyArray_NDIM(tmp) >= 1 ?
16706	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
16707	            );
16708	                {
16709	        __failure = 312;
16710	        if (!PyErr_Occurred()) {
16711	            PyErr_SetString(PyExc_RuntimeError,
16712	                "Unexpected error in an Op's C code. "
16713	                "No Python exception was set.");
16714	            }
16715	        goto __label_312;}
16716	            }
16717	            // This is a TypeError to be consistent with DEBUG_MODE
16718	            // Note: DEBUG_MODE also tells the name of the container
16719	            if (PyArray_TYPE((PyArrayObject*) py_V311) != NPY_FLOAT64) {
16720	                PyErr_Format(PyExc_TypeError,
16721	                             "expected type_num %d (NPY_FLOAT64) got %d",
16722	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V311));
16723	                {
16724	        __failure = 312;
16725	        if (!PyErr_Occurred()) {
16726	            PyErr_SetString(PyExc_RuntimeError,
16727	                "Unexpected error in an Op's C code. "
16728	                "No Python exception was set.");
16729	            }
16730	        goto __label_312;}
16731	            }
16732
16733	        V311 = (PyArrayObject*)(py_V311);
16734	        Py_XINCREF(V311);
16735
16736	{
16737
16738	    py_V313 = PyList_GET_ITEM(storage_V313, 0);
16739	    {Py_XINCREF(py_V313);}
16740
16741	            V313 = NULL;
16742	            if (py_V313 == Py_None) {
16743	                // We can either fail here or set V313 to NULL and rely on Ops
16744	                // using tensors to handle the NULL case, but if they fail to do so
16745	                // they'll end up with nasty segfaults, so this is public service.
16746	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
16747	                {
16748	        __failure = 314;
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_314;}
16755	            }
16756	            if (!PyArray_Check(py_V313)) {
16757	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
16758	                {
16759	        __failure = 314;
16760	        if (!PyErr_Occurred()) {
16761	            PyErr_SetString(PyExc_RuntimeError,
16762	                "Unexpected error in an Op's C code. "
16763	                "No Python exception was set.");
16764	            }
16765	        goto __label_314;}
16766	            }
16767	            // We expect NPY_FLOAT64
16768	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V313)) {
16769	                PyArrayObject * tmp = (PyArrayObject*) py_V313;
16770	                PyErr_Format(PyExc_NotImplementedError,
16771	                             "expected an aligned array of type %ld "
16772	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
16773	                             " with %ld dimensions, with 3 last dims "
16774	                             "%ld, %ld, %ld"
16775	                             " and 3 last strides %ld %ld, %ld.",
16776	                             (long int) NPY_FLOAT64,
16777	                             (long int) PyArray_TYPE((PyArrayObject*) py_V313),
16778	                             (long int) PyArray_NDIM(tmp),
16779	                             (long int) PyArray_NDIM(tmp) >= 3 ?
16780	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
16781	                             (long int) PyArray_NDIM(tmp) >= 2 ?
16782	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
16783	                             (long int) PyArray_NDIM(tmp) >= 1 ?
16784	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
16785	                             (long int) PyArray_NDIM(tmp) >= 3 ?
16786	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
16787	                             (long int) PyArray_NDIM(tmp) >= 2 ?
16788	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
16789	                             (long int) PyArray_NDIM(tmp) >= 1 ?
16790	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
16791	            );
16792	                {
16793	        __failure = 314;
16794	        if (!PyErr_Occurred()) {
16795	            PyErr_SetString(PyExc_RuntimeError,
16796	                "Unexpected error in an Op's C code. "
16797	                "No Python exception was set.");
16798	            }
16799	        goto __label_314;}
16800	            }
16801	            // This is a TypeError to be consistent with DEBUG_MODE
16802	            // Note: DEBUG_MODE also tells the name of the container
16803	            if (PyArray_TYPE((PyArrayObject*) py_V313) != NPY_FLOAT64) {
16804	                PyErr_Format(PyExc_TypeError,
16805	                             "expected type_num %d (NPY_FLOAT64) got %d",
16806	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V313));
16807	                {
16808	        __failure = 314;
16809	        if (!PyErr_Occurred()) {
16810	            PyErr_SetString(PyExc_RuntimeError,
16811	                "Unexpected error in an Op's C code. "
16812	                "No Python exception was set.");
16813	            }
16814	        goto __label_314;}
16815	            }
16816
16817	        V313 = (PyArrayObject*)(py_V313);
16818	        Py_XINCREF(V313);
16819
16820	{
16821
16822	    py_V315 = PyList_GET_ITEM(storage_V315, 0);
16823	    {Py_XINCREF(py_V315);}
16824
16825	            V315 = NULL;
16826	            if (py_V315 == Py_None) {
16827	                // We can either fail here or set V315 to NULL and rely on Ops
16828	                // using tensors to handle the NULL case, but if they fail to do so
16829	                // they'll end up with nasty segfaults, so this is public service.
16830	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
16831	                {
16832	        __failure = 316;
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_316;}
16839	            }
16840	            if (!PyArray_Check(py_V315)) {
16841	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
16842	                {
16843	        __failure = 316;
16844	        if (!PyErr_Occurred()) {
16845	            PyErr_SetString(PyExc_RuntimeError,
16846	                "Unexpected error in an Op's C code. "
16847	                "No Python exception was set.");
16848	            }
16849	        goto __label_316;}
16850	            }
16851	            // We expect NPY_FLOAT64
16852	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V315)) {
16853	                PyArrayObject * tmp = (PyArrayObject*) py_V315;
16854	                PyErr_Format(PyExc_NotImplementedError,
16855	                             "expected an aligned array of type %ld "
16856	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
16857	                             " with %ld dimensions, with 3 last dims "
16858	                             "%ld, %ld, %ld"
16859	                             " and 3 last strides %ld %ld, %ld.",
16860	                             (long int) NPY_FLOAT64,
16861	                             (long int) PyArray_TYPE((PyArrayObject*) py_V315),
16862	                             (long int) PyArray_NDIM(tmp),
16863	                             (long int) PyArray_NDIM(tmp) >= 3 ?
16864	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
16865	                             (long int) PyArray_NDIM(tmp) >= 2 ?
16866	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
16867	                             (long int) PyArray_NDIM(tmp) >= 1 ?
16868	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
16869	                             (long int) PyArray_NDIM(tmp) >= 3 ?
16870	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
16871	                             (long int) PyArray_NDIM(tmp) >= 2 ?
16872	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
16873	                             (long int) PyArray_NDIM(tmp) >= 1 ?
16874	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
16875	            );
16876	                {
16877	        __failure = 316;
16878	        if (!PyErr_Occurred()) {
16879	            PyErr_SetString(PyExc_RuntimeError,
16880	                "Unexpected error in an Op's C code. "
16881	                "No Python exception was set.");
16882	            }
16883	        goto __label_316;}
16884	            }
16885	            // This is a TypeError to be consistent with DEBUG_MODE
16886	            // Note: DEBUG_MODE also tells the name of the container
16887	            if (PyArray_TYPE((PyArrayObject*) py_V315) != NPY_FLOAT64) {
16888	                PyErr_Format(PyExc_TypeError,
16889	                             "expected type_num %d (NPY_FLOAT64) got %d",
16890	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V315));
16891	                {
16892	        __failure = 316;
16893	        if (!PyErr_Occurred()) {
16894	            PyErr_SetString(PyExc_RuntimeError,
16895	                "Unexpected error in an Op's C code. "
16896	                "No Python exception was set.");
16897	            }
16898	        goto __label_316;}
16899	            }
16900
16901	        V315 = (PyArrayObject*)(py_V315);
16902	        Py_XINCREF(V315);
16903
16904	{
16905
16906	    py_V317 = PyList_GET_ITEM(storage_V317, 0);
16907	    {Py_XINCREF(py_V317);}
16908
16909	            V317 = NULL;
16910	            if (py_V317 == Py_None) {
16911	                // We can either fail here or set V317 to NULL and rely on Ops
16912	                // using tensors to handle the NULL case, but if they fail to do so
16913	                // they'll end up with nasty segfaults, so this is public service.
16914	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
16915	                {
16916	        __failure = 318;
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_318;}
16923	            }
16924	            if (!PyArray_Check(py_V317)) {
16925	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
16926	                {
16927	        __failure = 318;
16928	        if (!PyErr_Occurred()) {
16929	            PyErr_SetString(PyExc_RuntimeError,
16930	                "Unexpected error in an Op's C code. "
16931	                "No Python exception was set.");
16932	            }
16933	        goto __label_318;}
16934	            }
16935	            // We expect NPY_INT8
16936	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V317)) {
16937	                PyArrayObject * tmp = (PyArrayObject*) py_V317;
16938	                PyErr_Format(PyExc_NotImplementedError,
16939	                             "expected an aligned array of type %ld "
16940	                             "(NPY_INT8), got non-aligned array of type %ld"
16941	                             " with %ld dimensions, with 3 last dims "
16942	                             "%ld, %ld, %ld"
16943	                             " and 3 last strides %ld %ld, %ld.",
16944	                             (long int) NPY_INT8,
16945	                             (long int) PyArray_TYPE((PyArrayObject*) py_V317),
16946	                             (long int) PyArray_NDIM(tmp),
16947	                             (long int) PyArray_NDIM(tmp) >= 3 ?
16948	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
16949	                             (long int) PyArray_NDIM(tmp) >= 2 ?
16950	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
16951	                             (long int) PyArray_NDIM(tmp) >= 1 ?
16952	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
16953	                             (long int) PyArray_NDIM(tmp) >= 3 ?
16954	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
16955	                             (long int) PyArray_NDIM(tmp) >= 2 ?
16956	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
16957	                             (long int) PyArray_NDIM(tmp) >= 1 ?
16958	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
16959	            );
16960	                {
16961	        __failure = 318;
16962	        if (!PyErr_Occurred()) {
16963	            PyErr_SetString(PyExc_RuntimeError,
16964	                "Unexpected error in an Op's C code. "
16965	                "No Python exception was set.");
16966	            }
16967	        goto __label_318;}
16968	            }
16969	            // This is a TypeError to be consistent with DEBUG_MODE
16970	            // Note: DEBUG_MODE also tells the name of the container
16971	            if (PyArray_TYPE((PyArrayObject*) py_V317) != NPY_INT8) {
16972	                PyErr_Format(PyExc_TypeError,
16973	                             "expected type_num %d (NPY_INT8) got %d",
16974	                             NPY_INT8, PyArray_TYPE((PyArrayObject*) py_V317));
16975	                {
16976	        __failure = 318;
16977	        if (!PyErr_Occurred()) {
16978	            PyErr_SetString(PyExc_RuntimeError,
16979	                "Unexpected error in an Op's C code. "
16980	                "No Python exception was set.");
16981	            }
16982	        goto __label_318;}
16983	            }
16984
16985	        V317 = (PyArrayObject*)(py_V317);
16986	        Py_XINCREF(V317);
16987
16988	{
16989
16990	    py_V319 = PyList_GET_ITEM(storage_V319, 0);
16991	    {Py_XINCREF(py_V319);}
16992
16993	            V319 = NULL;
16994	            if (py_V319 == Py_None) {
16995	                // We can either fail here or set V319 to NULL and rely on Ops
16996	                // using tensors to handle the NULL case, but if they fail to do so
16997	                // they'll end up with nasty segfaults, so this is public service.
16998	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
16999	                {
17000	        __failure = 320;
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_320;}
17007	            }
17008	            if (!PyArray_Check(py_V319)) {
17009	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
17010	                {
17011	        __failure = 320;
17012	        if (!PyErr_Occurred()) {
17013	            PyErr_SetString(PyExc_RuntimeError,
17014	                "Unexpected error in an Op's C code. "
17015	                "No Python exception was set.");
17016	            }
17017	        goto __label_320;}
17018	            }
17019	            // We expect NPY_FLOAT64
17020	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V319)) {
17021	                PyArrayObject * tmp = (PyArrayObject*) py_V319;
17022	                PyErr_Format(PyExc_NotImplementedError,
17023	                             "expected an aligned array of type %ld "
17024	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
17025	                             " with %ld dimensions, with 3 last dims "
17026	                             "%ld, %ld, %ld"
17027	                             " and 3 last strides %ld %ld, %ld.",
17028	                             (long int) NPY_FLOAT64,
17029	                             (long int) PyArray_TYPE((PyArrayObject*) py_V319),
17030	                             (long int) PyArray_NDIM(tmp),
17031	                             (long int) PyArray_NDIM(tmp) >= 3 ?
17032	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
17033	                             (long int) PyArray_NDIM(tmp) >= 2 ?
17034	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
17035	                             (long int) PyArray_NDIM(tmp) >= 1 ?
17036	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
17037	                             (long int) PyArray_NDIM(tmp) >= 3 ?
17038	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
17039	                             (long int) PyArray_NDIM(tmp) >= 2 ?
17040	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
17041	                             (long int) PyArray_NDIM(tmp) >= 1 ?
17042	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
17043	            );
17044	                {
17045	        __failure = 320;
17046	        if (!PyErr_Occurred()) {
17047	            PyErr_SetString(PyExc_RuntimeError,
17048	                "Unexpected error in an Op's C code. "
17049	                "No Python exception was set.");
17050	            }
17051	        goto __label_320;}
17052	            }
17053	            // This is a TypeError to be consistent with DEBUG_MODE
17054	            // Note: DEBUG_MODE also tells the name of the container
17055	            if (PyArray_TYPE((PyArrayObject*) py_V319) != NPY_FLOAT64) {
17056	                PyErr_Format(PyExc_TypeError,
17057	                             "expected type_num %d (NPY_FLOAT64) got %d",
17058	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V319));
17059	                {
17060	        __failure = 320;
17061	        if (!PyErr_Occurred()) {
17062	            PyErr_SetString(PyExc_RuntimeError,
17063	                "Unexpected error in an Op's C code. "
17064	                "No Python exception was set.");
17065	            }
17066	        goto __label_320;}
17067	            }
17068
17069	        V319 = (PyArrayObject*)(py_V319);
17070	        Py_XINCREF(V319);
17071
17072	{
17073
17074	    py_V321 = PyList_GET_ITEM(storage_V321, 0);
17075	    {Py_XINCREF(py_V321);}
17076
17077	            V321 = NULL;
17078	            if (py_V321 == Py_None) {
17079	                // We can either fail here or set V321 to NULL and rely on Ops
17080	                // using tensors to handle the NULL case, but if they fail to do so
17081	                // they'll end up with nasty segfaults, so this is public service.
17082	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
17083	                {
17084	        __failure = 322;
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_322;}
17091	            }
17092	            if (!PyArray_Check(py_V321)) {
17093	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
17094	                {
17095	        __failure = 322;
17096	        if (!PyErr_Occurred()) {
17097	            PyErr_SetString(PyExc_RuntimeError,
17098	                "Unexpected error in an Op's C code. "
17099	                "No Python exception was set.");
17100	            }
17101	        goto __label_322;}
17102	            }
17103	            // We expect NPY_FLOAT64
17104	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V321)) {
17105	                PyArrayObject * tmp = (PyArrayObject*) py_V321;
17106	                PyErr_Format(PyExc_NotImplementedError,
17107	                             "expected an aligned array of type %ld "
17108	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
17109	                             " with %ld dimensions, with 3 last dims "
17110	                             "%ld, %ld, %ld"
17111	                             " and 3 last strides %ld %ld, %ld.",
17112	                             (long int) NPY_FLOAT64,
17113	                             (long int) PyArray_TYPE((PyArrayObject*) py_V321),
17114	                             (long int) PyArray_NDIM(tmp),
17115	                             (long int) PyArray_NDIM(tmp) >= 3 ?
17116	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
17117	                             (long int) PyArray_NDIM(tmp) >= 2 ?
17118	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
17119	                             (long int) PyArray_NDIM(tmp) >= 1 ?
17120	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
17121	                             (long int) PyArray_NDIM(tmp) >= 3 ?
17122	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
17123	                             (long int) PyArray_NDIM(tmp) >= 2 ?
17124	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
17125	                             (long int) PyArray_NDIM(tmp) >= 1 ?
17126	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
17127	            );
17128	                {
17129	        __failure = 322;
17130	        if (!PyErr_Occurred()) {
17131	            PyErr_SetString(PyExc_RuntimeError,
17132	                "Unexpected error in an Op's C code. "
17133	                "No Python exception was set.");
17134	            }
17135	        goto __label_322;}
17136	            }
17137	            // This is a TypeError to be consistent with DEBUG_MODE
17138	            // Note: DEBUG_MODE also tells the name of the container
17139	            if (PyArray_TYPE((PyArrayObject*) py_V321) != NPY_FLOAT64) {
17140	                PyErr_Format(PyExc_TypeError,
17141	                             "expected type_num %d (NPY_FLOAT64) got %d",
17142	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V321));
17143	                {
17144	        __failure = 322;
17145	        if (!PyErr_Occurred()) {
17146	            PyErr_SetString(PyExc_RuntimeError,
17147	                "Unexpected error in an Op's C code. "
17148	                "No Python exception was set.");
17149	            }
17150	        goto __label_322;}
17151	            }
17152
17153	        V321 = (PyArrayObject*)(py_V321);
17154	        Py_XINCREF(V321);
17155
17156	{
17157
17158	    py_V323 = PyList_GET_ITEM(storage_V323, 0);
17159	    {Py_XINCREF(py_V323);}
17160
17161	            V323 = NULL;
17162	            if (py_V323 == Py_None) {
17163	                // We can either fail here or set V323 to NULL and rely on Ops
17164	                // using tensors to handle the NULL case, but if they fail to do so
17165	                // they'll end up with nasty segfaults, so this is public service.
17166	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
17167	                {
17168	        __failure = 324;
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_324;}
17175	            }
17176	            if (!PyArray_Check(py_V323)) {
17177	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
17178	                {
17179	        __failure = 324;
17180	        if (!PyErr_Occurred()) {
17181	            PyErr_SetString(PyExc_RuntimeError,
17182	                "Unexpected error in an Op's C code. "
17183	                "No Python exception was set.");
17184	            }
17185	        goto __label_324;}
17186	            }
17187	            // We expect NPY_FLOAT64
17188	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V323)) {
17189	                PyArrayObject * tmp = (PyArrayObject*) py_V323;
17190	                PyErr_Format(PyExc_NotImplementedError,
17191	                             "expected an aligned array of type %ld "
17192	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
17193	                             " with %ld dimensions, with 3 last dims "
17194	                             "%ld, %ld, %ld"
17195	                             " and 3 last strides %ld %ld, %ld.",
17196	                             (long int) NPY_FLOAT64,
17197	                             (long int) PyArray_TYPE((PyArrayObject*) py_V323),
17198	                             (long int) PyArray_NDIM(tmp),
17199	                             (long int) PyArray_NDIM(tmp) >= 3 ?
17200	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
17201	                             (long int) PyArray_NDIM(tmp) >= 2 ?
17202	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
17203	                             (long int) PyArray_NDIM(tmp) >= 1 ?
17204	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
17205	                             (long int) PyArray_NDIM(tmp) >= 3 ?
17206	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
17207	                             (long int) PyArray_NDIM(tmp) >= 2 ?
17208	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
17209	                             (long int) PyArray_NDIM(tmp) >= 1 ?
17210	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
17211	            );
17212	                {
17213	        __failure = 324;
17214	        if (!PyErr_Occurred()) {
17215	            PyErr_SetString(PyExc_RuntimeError,
17216	                "Unexpected error in an Op's C code. "
17217	                "No Python exception was set.");
17218	            }
17219	        goto __label_324;}
17220	            }
17221	            // This is a TypeError to be consistent with DEBUG_MODE
17222	            // Note: DEBUG_MODE also tells the name of the container
17223	            if (PyArray_TYPE((PyArrayObject*) py_V323) != NPY_FLOAT64) {
17224	                PyErr_Format(PyExc_TypeError,
17225	                             "expected type_num %d (NPY_FLOAT64) got %d",
17226	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V323));
17227	                {
17228	        __failure = 324;
17229	        if (!PyErr_Occurred()) {
17230	            PyErr_SetString(PyExc_RuntimeError,
17231	                "Unexpected error in an Op's C code. "
17232	                "No Python exception was set.");
17233	            }
17234	        goto __label_324;}
17235	            }
17236
17237	        V323 = (PyArrayObject*)(py_V323);
17238	        Py_XINCREF(V323);
17239
17240	{
17241
17242	    py_V325 = PyList_GET_ITEM(storage_V325, 0);
17243	    {Py_XINCREF(py_V325);}
17244
17245	            V325 = NULL;
17246	            if (py_V325 == Py_None) {
17247	                // We can either fail here or set V325 to NULL and rely on Ops
17248	                // using tensors to handle the NULL case, but if they fail to do so
17249	                // they'll end up with nasty segfaults, so this is public service.
17250	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
17251	                {
17252	        __failure = 326;
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_326;}
17259	            }
17260	            if (!PyArray_Check(py_V325)) {
17261	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
17262	                {
17263	        __failure = 326;
17264	        if (!PyErr_Occurred()) {
17265	            PyErr_SetString(PyExc_RuntimeError,
17266	                "Unexpected error in an Op's C code. "
17267	                "No Python exception was set.");
17268	            }
17269	        goto __label_326;}
17270	            }
17271	            // We expect NPY_FLOAT64
17272	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V325)) {
17273	                PyArrayObject * tmp = (PyArrayObject*) py_V325;
17274	                PyErr_Format(PyExc_NotImplementedError,
17275	                             "expected an aligned array of type %ld "
17276	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
17277	                             " with %ld dimensions, with 3 last dims "
17278	                             "%ld, %ld, %ld"
17279	                             " and 3 last strides %ld %ld, %ld.",
17280	                             (long int) NPY_FLOAT64,
17281	                             (long int) PyArray_TYPE((PyArrayObject*) py_V325),
17282	                             (long int) PyArray_NDIM(tmp),
17283	                             (long int) PyArray_NDIM(tmp) >= 3 ?
17284	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
17285	                             (long int) PyArray_NDIM(tmp) >= 2 ?
17286	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
17287	                             (long int) PyArray_NDIM(tmp) >= 1 ?
17288	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
17289	                             (long int) PyArray_NDIM(tmp) >= 3 ?
17290	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
17291	                             (long int) PyArray_NDIM(tmp) >= 2 ?
17292	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
17293	                             (long int) PyArray_NDIM(tmp) >= 1 ?
17294	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
17295	            );
17296	                {
17297	        __failure = 326;
17298	        if (!PyErr_Occurred()) {
17299	            PyErr_SetString(PyExc_RuntimeError,
17300	                "Unexpected error in an Op's C code. "
17301	                "No Python exception was set.");
17302	            }
17303	        goto __label_326;}
17304	            }
17305	            // This is a TypeError to be consistent with DEBUG_MODE
17306	            // Note: DEBUG_MODE also tells the name of the container
17307	            if (PyArray_TYPE((PyArrayObject*) py_V325) != NPY_FLOAT64) {
17308	                PyErr_Format(PyExc_TypeError,
17309	                             "expected type_num %d (NPY_FLOAT64) got %d",
17310	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V325));
17311	                {
17312	        __failure = 326;
17313	        if (!PyErr_Occurred()) {
17314	            PyErr_SetString(PyExc_RuntimeError,
17315	                "Unexpected error in an Op's C code. "
17316	                "No Python exception was set.");
17317	            }
17318	        goto __label_326;}
17319	            }
17320
17321	        V325 = (PyArrayObject*)(py_V325);
17322	        Py_XINCREF(V325);
17323
17324	{
17325
17326	    py_V327 = PyList_GET_ITEM(storage_V327, 0);
17327	    {Py_XINCREF(py_V327);}
17328
17329	            V327 = NULL;
17330	            if (py_V327 == Py_None) {
17331	                // We can either fail here or set V327 to NULL and rely on Ops
17332	                // using tensors to handle the NULL case, but if they fail to do so
17333	                // they'll end up with nasty segfaults, so this is public service.
17334	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
17335	                {
17336	        __failure = 328;
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_328;}
17343	            }
17344	            if (!PyArray_Check(py_V327)) {
17345	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
17346	                {
17347	        __failure = 328;
17348	        if (!PyErr_Occurred()) {
17349	            PyErr_SetString(PyExc_RuntimeError,
17350	                "Unexpected error in an Op's C code. "
17351	                "No Python exception was set.");
17352	            }
17353	        goto __label_328;}
17354	            }
17355	            // We expect NPY_FLOAT64
17356	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V327)) {
17357	                PyArrayObject * tmp = (PyArrayObject*) py_V327;
17358	                PyErr_Format(PyExc_NotImplementedError,
17359	                             "expected an aligned array of type %ld "
17360	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
17361	                             " with %ld dimensions, with 3 last dims "
17362	                             "%ld, %ld, %ld"
17363	                             " and 3 last strides %ld %ld, %ld.",
17364	                             (long int) NPY_FLOAT64,
17365	                             (long int) PyArray_TYPE((PyArrayObject*) py_V327),
17366	                             (long int) PyArray_NDIM(tmp),
17367	                             (long int) PyArray_NDIM(tmp) >= 3 ?
17368	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
17369	                             (long int) PyArray_NDIM(tmp) >= 2 ?
17370	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
17371	                             (long int) PyArray_NDIM(tmp) >= 1 ?
17372	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
17373	                             (long int) PyArray_NDIM(tmp) >= 3 ?
17374	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
17375	                             (long int) PyArray_NDIM(tmp) >= 2 ?
17376	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
17377	                             (long int) PyArray_NDIM(tmp) >= 1 ?
17378	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
17379	            );
17380	                {
17381	        __failure = 328;
17382	        if (!PyErr_Occurred()) {
17383	            PyErr_SetString(PyExc_RuntimeError,
17384	                "Unexpected error in an Op's C code. "
17385	                "No Python exception was set.");
17386	            }
17387	        goto __label_328;}
17388	            }
17389	            // This is a TypeError to be consistent with DEBUG_MODE
17390	            // Note: DEBUG_MODE also tells the name of the container
17391	            if (PyArray_TYPE((PyArrayObject*) py_V327) != NPY_FLOAT64) {
17392	                PyErr_Format(PyExc_TypeError,
17393	                             "expected type_num %d (NPY_FLOAT64) got %d",
17394	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V327));
17395	                {
17396	        __failure = 328;
17397	        if (!PyErr_Occurred()) {
17398	            PyErr_SetString(PyExc_RuntimeError,
17399	                "Unexpected error in an Op's C code. "
17400	                "No Python exception was set.");
17401	            }
17402	        goto __label_328;}
17403	            }
17404
17405	        V327 = (PyArrayObject*)(py_V327);
17406	        Py_XINCREF(V327);
17407
17408	{
17409
17410	    py_V329 = PyList_GET_ITEM(storage_V329, 0);
17411	    {Py_XINCREF(py_V329);}
17412
17413	            V329 = NULL;
17414	            if (py_V329 == Py_None) {
17415	                // We can either fail here or set V329 to NULL and rely on Ops
17416	                // using tensors to handle the NULL case, but if they fail to do so
17417	                // they'll end up with nasty segfaults, so this is public service.
17418	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
17419	                {
17420	        __failure = 330;
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_330;}
17427	            }
17428	            if (!PyArray_Check(py_V329)) {
17429	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
17430	                {
17431	        __failure = 330;
17432	        if (!PyErr_Occurred()) {
17433	            PyErr_SetString(PyExc_RuntimeError,
17434	                "Unexpected error in an Op's C code. "
17435	                "No Python exception was set.");
17436	            }
17437	        goto __label_330;}
17438	            }
17439	            // We expect NPY_FLOAT64
17440	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V329)) {
17441	                PyArrayObject * tmp = (PyArrayObject*) py_V329;
17442	                PyErr_Format(PyExc_NotImplementedError,
17443	                             "expected an aligned array of type %ld "
17444	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
17445	                             " with %ld dimensions, with 3 last dims "
17446	                             "%ld, %ld, %ld"
17447	                             " and 3 last strides %ld %ld, %ld.",
17448	                             (long int) NPY_FLOAT64,
17449	                             (long int) PyArray_TYPE((PyArrayObject*) py_V329),
17450	                             (long int) PyArray_NDIM(tmp),
17451	                             (long int) PyArray_NDIM(tmp) >= 3 ?
17452	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
17453	                             (long int) PyArray_NDIM(tmp) >= 2 ?
17454	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
17455	                             (long int) PyArray_NDIM(tmp) >= 1 ?
17456	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
17457	                             (long int) PyArray_NDIM(tmp) >= 3 ?
17458	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
17459	                             (long int) PyArray_NDIM(tmp) >= 2 ?
17460	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
17461	                             (long int) PyArray_NDIM(tmp) >= 1 ?
17462	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
17463	            );
17464	                {
17465	        __failure = 330;
17466	        if (!PyErr_Occurred()) {
17467	            PyErr_SetString(PyExc_RuntimeError,
17468	                "Unexpected error in an Op's C code. "
17469	                "No Python exception was set.");
17470	            }
17471	        goto __label_330;}
17472	            }
17473	            // This is a TypeError to be consistent with DEBUG_MODE
17474	            // Note: DEBUG_MODE also tells the name of the container
17475	            if (PyArray_TYPE((PyArrayObject*) py_V329) != NPY_FLOAT64) {
17476	                PyErr_Format(PyExc_TypeError,
17477	                             "expected type_num %d (NPY_FLOAT64) got %d",
17478	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V329));
17479	                {
17480	        __failure = 330;
17481	        if (!PyErr_Occurred()) {
17482	            PyErr_SetString(PyExc_RuntimeError,
17483	                "Unexpected error in an Op's C code. "
17484	                "No Python exception was set.");
17485	            }
17486	        goto __label_330;}
17487	            }
17488
17489	        V329 = (PyArrayObject*)(py_V329);
17490	        Py_XINCREF(V329);
17491
17492	{
17493
17494	    py_V331 = PyList_GET_ITEM(storage_V331, 0);
17495	    {Py_XINCREF(py_V331);}
17496
17497	            V331 = NULL;
17498	            if (py_V331 == Py_None) {
17499	                // We can either fail here or set V331 to NULL and rely on Ops
17500	                // using tensors to handle the NULL case, but if they fail to do so
17501	                // they'll end up with nasty segfaults, so this is public service.
17502	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
17503	                {
17504	        __failure = 332;
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_332;}
17511	            }
17512	            if (!PyArray_Check(py_V331)) {
17513	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
17514	                {
17515	        __failure = 332;
17516	        if (!PyErr_Occurred()) {
17517	            PyErr_SetString(PyExc_RuntimeError,
17518	                "Unexpected error in an Op's C code. "
17519	                "No Python exception was set.");
17520	            }
17521	        goto __label_332;}
17522	            }
17523	            // We expect NPY_FLOAT64
17524	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V331)) {
17525	                PyArrayObject * tmp = (PyArrayObject*) py_V331;
17526	                PyErr_Format(PyExc_NotImplementedError,
17527	                             "expected an aligned array of type %ld "
17528	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
17529	                             " with %ld dimensions, with 3 last dims "
17530	                             "%ld, %ld, %ld"
17531	                             " and 3 last strides %ld %ld, %ld.",
17532	                             (long int) NPY_FLOAT64,
17533	                             (long int) PyArray_TYPE((PyArrayObject*) py_V331),
17534	                             (long int) PyArray_NDIM(tmp),
17535	                             (long int) PyArray_NDIM(tmp) >= 3 ?
17536	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
17537	                             (long int) PyArray_NDIM(tmp) >= 2 ?
17538	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
17539	                             (long int) PyArray_NDIM(tmp) >= 1 ?
17540	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
17541	                             (long int) PyArray_NDIM(tmp) >= 3 ?
17542	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
17543	                             (long int) PyArray_NDIM(tmp) >= 2 ?
17544	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
17545	                             (long int) PyArray_NDIM(tmp) >= 1 ?
17546	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
17547	            );
17548	                {
17549	        __failure = 332;
17550	        if (!PyErr_Occurred()) {
17551	            PyErr_SetString(PyExc_RuntimeError,
17552	                "Unexpected error in an Op's C code. "
17553	                "No Python exception was set.");
17554	            }
17555	        goto __label_332;}
17556	            }
17557	            // This is a TypeError to be consistent with DEBUG_MODE
17558	            // Note: DEBUG_MODE also tells the name of the container
17559	            if (PyArray_TYPE((PyArrayObject*) py_V331) != NPY_FLOAT64) {
17560	                PyErr_Format(PyExc_TypeError,
17561	                             "expected type_num %d (NPY_FLOAT64) got %d",
17562	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V331));
17563	                {
17564	        __failure = 332;
17565	        if (!PyErr_Occurred()) {
17566	            PyErr_SetString(PyExc_RuntimeError,
17567	                "Unexpected error in an Op's C code. "
17568	                "No Python exception was set.");
17569	            }
17570	        goto __label_332;}
17571	            }
17572
17573	        V331 = (PyArrayObject*)(py_V331);
17574	        Py_XINCREF(V331);
17575
17576	{
17577
17578	    py_V333 = PyList_GET_ITEM(storage_V333, 0);
17579	    {Py_XINCREF(py_V333);}
17580
17581	            V333 = NULL;
17582	            if (py_V333 == Py_None) {
17583	                // We can either fail here or set V333 to NULL and rely on Ops
17584	                // using tensors to handle the NULL case, but if they fail to do so
17585	                // they'll end up with nasty segfaults, so this is public service.
17586	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
17587	                {
17588	        __failure = 334;
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_334;}
17595	            }
17596	            if (!PyArray_Check(py_V333)) {
17597	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
17598	                {
17599	        __failure = 334;
17600	        if (!PyErr_Occurred()) {
17601	            PyErr_SetString(PyExc_RuntimeError,
17602	                "Unexpected error in an Op's C code. "
17603	                "No Python exception was set.");
17604	            }
17605	        goto __label_334;}
17606	            }
17607	            // We expect NPY_INT8
17608	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V333)) {
17609	                PyArrayObject * tmp = (PyArrayObject*) py_V333;
17610	                PyErr_Format(PyExc_NotImplementedError,
17611	                             "expected an aligned array of type %ld "
17612	                             "(NPY_INT8), got non-aligned array of type %ld"
17613	                             " with %ld dimensions, with 3 last dims "
17614	                             "%ld, %ld, %ld"
17615	                             " and 3 last strides %ld %ld, %ld.",
17616	                             (long int) NPY_INT8,
17617	                             (long int) PyArray_TYPE((PyArrayObject*) py_V333),
17618	                             (long int) PyArray_NDIM(tmp),
17619	                             (long int) PyArray_NDIM(tmp) >= 3 ?
17620	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
17621	                             (long int) PyArray_NDIM(tmp) >= 2 ?
17622	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
17623	                             (long int) PyArray_NDIM(tmp) >= 1 ?
17624	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
17625	                             (long int) PyArray_NDIM(tmp) >= 3 ?
17626	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
17627	                             (long int) PyArray_NDIM(tmp) >= 2 ?
17628	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
17629	                             (long int) PyArray_NDIM(tmp) >= 1 ?
17630	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
17631	            );
17632	                {
17633	        __failure = 334;
17634	        if (!PyErr_Occurred()) {
17635	            PyErr_SetString(PyExc_RuntimeError,
17636	                "Unexpected error in an Op's C code. "
17637	                "No Python exception was set.");
17638	            }
17639	        goto __label_334;}
17640	            }
17641	            // This is a TypeError to be consistent with DEBUG_MODE
17642	            // Note: DEBUG_MODE also tells the name of the container
17643	            if (PyArray_TYPE((PyArrayObject*) py_V333) != NPY_INT8) {
17644	                PyErr_Format(PyExc_TypeError,
17645	                             "expected type_num %d (NPY_INT8) got %d",
17646	                             NPY_INT8, PyArray_TYPE((PyArrayObject*) py_V333));
17647	                {
17648	        __failure = 334;
17649	        if (!PyErr_Occurred()) {
17650	            PyErr_SetString(PyExc_RuntimeError,
17651	                "Unexpected error in an Op's C code. "
17652	                "No Python exception was set.");
17653	            }
17654	        goto __label_334;}
17655	            }
17656
17657	        V333 = (PyArrayObject*)(py_V333);
17658	        Py_XINCREF(V333);
17659
17660	{
17661
17662	    py_V335 = PyList_GET_ITEM(storage_V335, 0);
17663	    {Py_XINCREF(py_V335);}
17664
17665	            V335 = NULL;
17666	            if (py_V335 == Py_None) {
17667	                // We can either fail here or set V335 to NULL and rely on Ops
17668	                // using tensors to handle the NULL case, but if they fail to do so
17669	                // they'll end up with nasty segfaults, so this is public service.
17670	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
17671	                {
17672	        __failure = 336;
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_336;}
17679	            }
17680	            if (!PyArray_Check(py_V335)) {
17681	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
17682	                {
17683	        __failure = 336;
17684	        if (!PyErr_Occurred()) {
17685	            PyErr_SetString(PyExc_RuntimeError,
17686	                "Unexpected error in an Op's C code. "
17687	                "No Python exception was set.");
17688	            }
17689	        goto __label_336;}
17690	            }
17691	            // We expect NPY_FLOAT64
17692	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V335)) {
17693	                PyArrayObject * tmp = (PyArrayObject*) py_V335;
17694	                PyErr_Format(PyExc_NotImplementedError,
17695	                             "expected an aligned array of type %ld "
17696	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
17697	                             " with %ld dimensions, with 3 last dims "
17698	                             "%ld, %ld, %ld"
17699	                             " and 3 last strides %ld %ld, %ld.",
17700	                             (long int) NPY_FLOAT64,
17701	                             (long int) PyArray_TYPE((PyArrayObject*) py_V335),
17702	                             (long int) PyArray_NDIM(tmp),
17703	                             (long int) PyArray_NDIM(tmp) >= 3 ?
17704	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
17705	                             (long int) PyArray_NDIM(tmp) >= 2 ?
17706	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
17707	                             (long int) PyArray_NDIM(tmp) >= 1 ?
17708	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
17709	                             (long int) PyArray_NDIM(tmp) >= 3 ?
17710	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
17711	                             (long int) PyArray_NDIM(tmp) >= 2 ?
17712	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
17713	                             (long int) PyArray_NDIM(tmp) >= 1 ?
17714	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
17715	            );
17716	                {
17717	        __failure = 336;
17718	        if (!PyErr_Occurred()) {
17719	            PyErr_SetString(PyExc_RuntimeError,
17720	                "Unexpected error in an Op's C code. "
17721	                "No Python exception was set.");
17722	            }
17723	        goto __label_336;}
17724	            }
17725	            // This is a TypeError to be consistent with DEBUG_MODE
17726	            // Note: DEBUG_MODE also tells the name of the container
17727	            if (PyArray_TYPE((PyArrayObject*) py_V335) != NPY_FLOAT64) {
17728	                PyErr_Format(PyExc_TypeError,
17729	                             "expected type_num %d (NPY_FLOAT64) got %d",
17730	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V335));
17731	                {
17732	        __failure = 336;
17733	        if (!PyErr_Occurred()) {
17734	            PyErr_SetString(PyExc_RuntimeError,
17735	                "Unexpected error in an Op's C code. "
17736	                "No Python exception was set.");
17737	            }
17738	        goto __label_336;}
17739	            }
17740
17741	        V335 = (PyArrayObject*)(py_V335);
17742	        Py_XINCREF(V335);
17743
17744	{
17745
17746	    py_V337 = PyList_GET_ITEM(storage_V337, 0);
17747	    {Py_XINCREF(py_V337);}
17748
17749	            V337 = NULL;
17750	            if (py_V337 == Py_None) {
17751	                // We can either fail here or set V337 to NULL and rely on Ops
17752	                // using tensors to handle the NULL case, but if they fail to do so
17753	                // they'll end up with nasty segfaults, so this is public service.
17754	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
17755	                {
17756	        __failure = 338;
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_338;}
17763	            }
17764	            if (!PyArray_Check(py_V337)) {
17765	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
17766	                {
17767	        __failure = 338;
17768	        if (!PyErr_Occurred()) {
17769	            PyErr_SetString(PyExc_RuntimeError,
17770	                "Unexpected error in an Op's C code. "
17771	                "No Python exception was set.");
17772	            }
17773	        goto __label_338;}
17774	            }
17775	            // We expect NPY_FLOAT64
17776	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V337)) {
17777	                PyArrayObject * tmp = (PyArrayObject*) py_V337;
17778	                PyErr_Format(PyExc_NotImplementedError,
17779	                             "expected an aligned array of type %ld "
17780	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
17781	                             " with %ld dimensions, with 3 last dims "
17782	                             "%ld, %ld, %ld"
17783	                             " and 3 last strides %ld %ld, %ld.",
17784	                             (long int) NPY_FLOAT64,
17785	                             (long int) PyArray_TYPE((PyArrayObject*) py_V337),
17786	                             (long int) PyArray_NDIM(tmp),
17787	                             (long int) PyArray_NDIM(tmp) >= 3 ?
17788	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
17789	                             (long int) PyArray_NDIM(tmp) >= 2 ?
17790	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
17791	                             (long int) PyArray_NDIM(tmp) >= 1 ?
17792	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
17793	                             (long int) PyArray_NDIM(tmp) >= 3 ?
17794	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
17795	                             (long int) PyArray_NDIM(tmp) >= 2 ?
17796	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
17797	                             (long int) PyArray_NDIM(tmp) >= 1 ?
17798	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
17799	            );
17800	                {
17801	        __failure = 338;
17802	        if (!PyErr_Occurred()) {
17803	            PyErr_SetString(PyExc_RuntimeError,
17804	                "Unexpected error in an Op's C code. "
17805	                "No Python exception was set.");
17806	            }
17807	        goto __label_338;}
17808	            }
17809	            // This is a TypeError to be consistent with DEBUG_MODE
17810	            // Note: DEBUG_MODE also tells the name of the container
17811	            if (PyArray_TYPE((PyArrayObject*) py_V337) != NPY_FLOAT64) {
17812	                PyErr_Format(PyExc_TypeError,
17813	                             "expected type_num %d (NPY_FLOAT64) got %d",
17814	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V337));
17815	                {
17816	        __failure = 338;
17817	        if (!PyErr_Occurred()) {
17818	            PyErr_SetString(PyExc_RuntimeError,
17819	                "Unexpected error in an Op's C code. "
17820	                "No Python exception was set.");
17821	            }
17822	        goto __label_338;}
17823	            }
17824
17825	        V337 = (PyArrayObject*)(py_V337);
17826	        Py_XINCREF(V337);
17827
17828	{
17829
17830	    py_V339 = PyList_GET_ITEM(storage_V339, 0);
17831	    {Py_XINCREF(py_V339);}
17832
17833	            V339 = NULL;
17834	            if (py_V339 == Py_None) {
17835	                // We can either fail here or set V339 to NULL and rely on Ops
17836	                // using tensors to handle the NULL case, but if they fail to do so
17837	                // they'll end up with nasty segfaults, so this is public service.
17838	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
17839	                {
17840	        __failure = 340;
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_340;}
17847	            }
17848	            if (!PyArray_Check(py_V339)) {
17849	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
17850	                {
17851	        __failure = 340;
17852	        if (!PyErr_Occurred()) {
17853	            PyErr_SetString(PyExc_RuntimeError,
17854	                "Unexpected error in an Op's C code. "
17855	                "No Python exception was set.");
17856	            }
17857	        goto __label_340;}
17858	            }
17859	            // We expect NPY_FLOAT64
17860	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V339)) {
17861	                PyArrayObject * tmp = (PyArrayObject*) py_V339;
17862	                PyErr_Format(PyExc_NotImplementedError,
17863	                             "expected an aligned array of type %ld "
17864	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
17865	                             " with %ld dimensions, with 3 last dims "
17866	                             "%ld, %ld, %ld"
17867	                             " and 3 last strides %ld %ld, %ld.",
17868	                             (long int) NPY_FLOAT64,
17869	                             (long int) PyArray_TYPE((PyArrayObject*) py_V339),
17870	                             (long int) PyArray_NDIM(tmp),
17871	                             (long int) PyArray_NDIM(tmp) >= 3 ?
17872	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
17873	                             (long int) PyArray_NDIM(tmp) >= 2 ?
17874	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
17875	                             (long int) PyArray_NDIM(tmp) >= 1 ?
17876	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
17877	                             (long int) PyArray_NDIM(tmp) >= 3 ?
17878	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
17879	                             (long int) PyArray_NDIM(tmp) >= 2 ?
17880	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
17881	                             (long int) PyArray_NDIM(tmp) >= 1 ?
17882	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
17883	            );
17884	                {
17885	        __failure = 340;
17886	        if (!PyErr_Occurred()) {
17887	            PyErr_SetString(PyExc_RuntimeError,
17888	                "Unexpected error in an Op's C code. "
17889	                "No Python exception was set.");
17890	            }
17891	        goto __label_340;}
17892	            }
17893	            // This is a TypeError to be consistent with DEBUG_MODE
17894	            // Note: DEBUG_MODE also tells the name of the container
17895	            if (PyArray_TYPE((PyArrayObject*) py_V339) != NPY_FLOAT64) {
17896	                PyErr_Format(PyExc_TypeError,
17897	                             "expected type_num %d (NPY_FLOAT64) got %d",
17898	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V339));
17899	                {
17900	        __failure = 340;
17901	        if (!PyErr_Occurred()) {
17902	            PyErr_SetString(PyExc_RuntimeError,
17903	                "Unexpected error in an Op's C code. "
17904	                "No Python exception was set.");
17905	            }
17906	        goto __label_340;}
17907	            }
17908
17909	        V339 = (PyArrayObject*)(py_V339);
17910	        Py_XINCREF(V339);
17911
17912	{
17913
17914	    py_V341 = PyList_GET_ITEM(storage_V341, 0);
17915	    {Py_XINCREF(py_V341);}
17916
17917	            V341 = NULL;
17918	            if (py_V341 == Py_None) {
17919	                // We can either fail here or set V341 to NULL and rely on Ops
17920	                // using tensors to handle the NULL case, but if they fail to do so
17921	                // they'll end up with nasty segfaults, so this is public service.
17922	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
17923	                {
17924	        __failure = 342;
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_342;}
17931	            }
17932	            if (!PyArray_Check(py_V341)) {
17933	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
17934	                {
17935	        __failure = 342;
17936	        if (!PyErr_Occurred()) {
17937	            PyErr_SetString(PyExc_RuntimeError,
17938	                "Unexpected error in an Op's C code. "
17939	                "No Python exception was set.");
17940	            }
17941	        goto __label_342;}
17942	            }
17943	            // We expect NPY_FLOAT64
17944	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V341)) {
17945	                PyArrayObject * tmp = (PyArrayObject*) py_V341;
17946	                PyErr_Format(PyExc_NotImplementedError,
17947	                             "expected an aligned array of type %ld "
17948	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
17949	                             " with %ld dimensions, with 3 last dims "
17950	                             "%ld, %ld, %ld"
17951	                             " and 3 last strides %ld %ld, %ld.",
17952	                             (long int) NPY_FLOAT64,
17953	                             (long int) PyArray_TYPE((PyArrayObject*) py_V341),
17954	                             (long int) PyArray_NDIM(tmp),
17955	                             (long int) PyArray_NDIM(tmp) >= 3 ?
17956	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
17957	                             (long int) PyArray_NDIM(tmp) >= 2 ?
17958	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
17959	                             (long int) PyArray_NDIM(tmp) >= 1 ?
17960	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
17961	                             (long int) PyArray_NDIM(tmp) >= 3 ?
17962	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
17963	                             (long int) PyArray_NDIM(tmp) >= 2 ?
17964	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
17965	                             (long int) PyArray_NDIM(tmp) >= 1 ?
17966	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
17967	            );
17968	                {
17969	        __failure = 342;
17970	        if (!PyErr_Occurred()) {
17971	            PyErr_SetString(PyExc_RuntimeError,
17972	                "Unexpected error in an Op's C code. "
17973	                "No Python exception was set.");
17974	            }
17975	        goto __label_342;}
17976	            }
17977	            // This is a TypeError to be consistent with DEBUG_MODE
17978	            // Note: DEBUG_MODE also tells the name of the container
17979	            if (PyArray_TYPE((PyArrayObject*) py_V341) != NPY_FLOAT64) {
17980	                PyErr_Format(PyExc_TypeError,
17981	                             "expected type_num %d (NPY_FLOAT64) got %d",
17982	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V341));
17983	                {
17984	        __failure = 342;
17985	        if (!PyErr_Occurred()) {
17986	            PyErr_SetString(PyExc_RuntimeError,
17987	                "Unexpected error in an Op's C code. "
17988	                "No Python exception was set.");
17989	            }
17990	        goto __label_342;}
17991	            }
17992
17993	        V341 = (PyArrayObject*)(py_V341);
17994	        Py_XINCREF(V341);
17995
17996	{
17997
17998	    py_V343 = PyList_GET_ITEM(storage_V343, 0);
17999	    {Py_XINCREF(py_V343);}
18000
18001	            V343 = NULL;
18002	            if (py_V343 == Py_None) {
18003	                // We can either fail here or set V343 to NULL and rely on Ops
18004	                // using tensors to handle the NULL case, but if they fail to do so
18005	                // they'll end up with nasty segfaults, so this is public service.
18006	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
18007	                {
18008	        __failure = 344;
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_344;}
18015	            }
18016	            if (!PyArray_Check(py_V343)) {
18017	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
18018	                {
18019	        __failure = 344;
18020	        if (!PyErr_Occurred()) {
18021	            PyErr_SetString(PyExc_RuntimeError,
18022	                "Unexpected error in an Op's C code. "
18023	                "No Python exception was set.");
18024	            }
18025	        goto __label_344;}
18026	            }
18027	            // We expect NPY_FLOAT64
18028	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V343)) {
18029	                PyArrayObject * tmp = (PyArrayObject*) py_V343;
18030	                PyErr_Format(PyExc_NotImplementedError,
18031	                             "expected an aligned array of type %ld "
18032	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
18033	                             " with %ld dimensions, with 3 last dims "
18034	                             "%ld, %ld, %ld"
18035	                             " and 3 last strides %ld %ld, %ld.",
18036	                             (long int) NPY_FLOAT64,
18037	                             (long int) PyArray_TYPE((PyArrayObject*) py_V343),
18038	                             (long int) PyArray_NDIM(tmp),
18039	                             (long int) PyArray_NDIM(tmp) >= 3 ?
18040	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
18041	                             (long int) PyArray_NDIM(tmp) >= 2 ?
18042	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
18043	                             (long int) PyArray_NDIM(tmp) >= 1 ?
18044	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
18045	                             (long int) PyArray_NDIM(tmp) >= 3 ?
18046	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
18047	                             (long int) PyArray_NDIM(tmp) >= 2 ?
18048	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
18049	                             (long int) PyArray_NDIM(tmp) >= 1 ?
18050	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
18051	            );
18052	                {
18053	        __failure = 344;
18054	        if (!PyErr_Occurred()) {
18055	            PyErr_SetString(PyExc_RuntimeError,
18056	                "Unexpected error in an Op's C code. "
18057	                "No Python exception was set.");
18058	            }
18059	        goto __label_344;}
18060	            }
18061	            // This is a TypeError to be consistent with DEBUG_MODE
18062	            // Note: DEBUG_MODE also tells the name of the container
18063	            if (PyArray_TYPE((PyArrayObject*) py_V343) != NPY_FLOAT64) {
18064	                PyErr_Format(PyExc_TypeError,
18065	                             "expected type_num %d (NPY_FLOAT64) got %d",
18066	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V343));
18067	                {
18068	        __failure = 344;
18069	        if (!PyErr_Occurred()) {
18070	            PyErr_SetString(PyExc_RuntimeError,
18071	                "Unexpected error in an Op's C code. "
18072	                "No Python exception was set.");
18073	            }
18074	        goto __label_344;}
18075	            }
18076
18077	        V343 = (PyArrayObject*)(py_V343);
18078	        Py_XINCREF(V343);
18079
18080	{
18081
18082	    py_V345 = PyList_GET_ITEM(storage_V345, 0);
18083	    {Py_XINCREF(py_V345);}
18084
18085	            V345 = NULL;
18086	            if (py_V345 == Py_None) {
18087	                // We can either fail here or set V345 to NULL and rely on Ops
18088	                // using tensors to handle the NULL case, but if they fail to do so
18089	                // they'll end up with nasty segfaults, so this is public service.
18090	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
18091	                {
18092	        __failure = 346;
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_346;}
18099	            }
18100	            if (!PyArray_Check(py_V345)) {
18101	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
18102	                {
18103	        __failure = 346;
18104	        if (!PyErr_Occurred()) {
18105	            PyErr_SetString(PyExc_RuntimeError,
18106	                "Unexpected error in an Op's C code. "
18107	                "No Python exception was set.");
18108	            }
18109	        goto __label_346;}
18110	            }
18111	            // We expect NPY_FLOAT64
18112	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V345)) {
18113	                PyArrayObject * tmp = (PyArrayObject*) py_V345;
18114	                PyErr_Format(PyExc_NotImplementedError,
18115	                             "expected an aligned array of type %ld "
18116	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
18117	                             " with %ld dimensions, with 3 last dims "
18118	                             "%ld, %ld, %ld"
18119	                             " and 3 last strides %ld %ld, %ld.",
18120	                             (long int) NPY_FLOAT64,
18121	                             (long int) PyArray_TYPE((PyArrayObject*) py_V345),
18122	                             (long int) PyArray_NDIM(tmp),
18123	                             (long int) PyArray_NDIM(tmp) >= 3 ?
18124	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
18125	                             (long int) PyArray_NDIM(tmp) >= 2 ?
18126	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
18127	                             (long int) PyArray_NDIM(tmp) >= 1 ?
18128	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
18129	                             (long int) PyArray_NDIM(tmp) >= 3 ?
18130	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
18131	                             (long int) PyArray_NDIM(tmp) >= 2 ?
18132	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
18133	                             (long int) PyArray_NDIM(tmp) >= 1 ?
18134	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
18135	            );
18136	                {
18137	        __failure = 346;
18138	        if (!PyErr_Occurred()) {
18139	            PyErr_SetString(PyExc_RuntimeError,
18140	                "Unexpected error in an Op's C code. "
18141	                "No Python exception was set.");
18142	            }
18143	        goto __label_346;}
18144	            }
18145	            // This is a TypeError to be consistent with DEBUG_MODE
18146	            // Note: DEBUG_MODE also tells the name of the container
18147	            if (PyArray_TYPE((PyArrayObject*) py_V345) != NPY_FLOAT64) {
18148	                PyErr_Format(PyExc_TypeError,
18149	                             "expected type_num %d (NPY_FLOAT64) got %d",
18150	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V345));
18151	                {
18152	        __failure = 346;
18153	        if (!PyErr_Occurred()) {
18154	            PyErr_SetString(PyExc_RuntimeError,
18155	                "Unexpected error in an Op's C code. "
18156	                "No Python exception was set.");
18157	            }
18158	        goto __label_346;}
18159	            }
18160
18161	        V345 = (PyArrayObject*)(py_V345);
18162	        Py_XINCREF(V345);
18163
18164	{
18165
18166	    py_V347 = PyList_GET_ITEM(storage_V347, 0);
18167	    {Py_XINCREF(py_V347);}
18168
18169	            V347 = NULL;
18170	            if (py_V347 == Py_None) {
18171	                // We can either fail here or set V347 to NULL and rely on Ops
18172	                // using tensors to handle the NULL case, but if they fail to do so
18173	                // they'll end up with nasty segfaults, so this is public service.
18174	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
18175	                {
18176	        __failure = 348;
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_348;}
18183	            }
18184	            if (!PyArray_Check(py_V347)) {
18185	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
18186	                {
18187	        __failure = 348;
18188	        if (!PyErr_Occurred()) {
18189	            PyErr_SetString(PyExc_RuntimeError,
18190	                "Unexpected error in an Op's C code. "
18191	                "No Python exception was set.");
18192	            }
18193	        goto __label_348;}
18194	            }
18195	            // We expect NPY_FLOAT64
18196	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V347)) {
18197	                PyArrayObject * tmp = (PyArrayObject*) py_V347;
18198	                PyErr_Format(PyExc_NotImplementedError,
18199	                             "expected an aligned array of type %ld "
18200	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
18201	                             " with %ld dimensions, with 3 last dims "
18202	                             "%ld, %ld, %ld"
18203	                             " and 3 last strides %ld %ld, %ld.",
18204	                             (long int) NPY_FLOAT64,
18205	                             (long int) PyArray_TYPE((PyArrayObject*) py_V347),
18206	                             (long int) PyArray_NDIM(tmp),
18207	                             (long int) PyArray_NDIM(tmp) >= 3 ?
18208	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
18209	                             (long int) PyArray_NDIM(tmp) >= 2 ?
18210	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
18211	                             (long int) PyArray_NDIM(tmp) >= 1 ?
18212	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
18213	                             (long int) PyArray_NDIM(tmp) >= 3 ?
18214	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
18215	                             (long int) PyArray_NDIM(tmp) >= 2 ?
18216	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
18217	                             (long int) PyArray_NDIM(tmp) >= 1 ?
18218	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
18219	            );
18220	                {
18221	        __failure = 348;
18222	        if (!PyErr_Occurred()) {
18223	            PyErr_SetString(PyExc_RuntimeError,
18224	                "Unexpected error in an Op's C code. "
18225	                "No Python exception was set.");
18226	            }
18227	        goto __label_348;}
18228	            }
18229	            // This is a TypeError to be consistent with DEBUG_MODE
18230	            // Note: DEBUG_MODE also tells the name of the container
18231	            if (PyArray_TYPE((PyArrayObject*) py_V347) != NPY_FLOAT64) {
18232	                PyErr_Format(PyExc_TypeError,
18233	                             "expected type_num %d (NPY_FLOAT64) got %d",
18234	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V347));
18235	                {
18236	        __failure = 348;
18237	        if (!PyErr_Occurred()) {
18238	            PyErr_SetString(PyExc_RuntimeError,
18239	                "Unexpected error in an Op's C code. "
18240	                "No Python exception was set.");
18241	            }
18242	        goto __label_348;}
18243	            }
18244
18245	        V347 = (PyArrayObject*)(py_V347);
18246	        Py_XINCREF(V347);
18247
18248	{
18249
18250	    py_V349 = PyList_GET_ITEM(storage_V349, 0);
18251	    {Py_XINCREF(py_V349);}
18252
18253	            V349 = NULL;
18254	            if (py_V349 == Py_None) {
18255	                // We can either fail here or set V349 to NULL and rely on Ops
18256	                // using tensors to handle the NULL case, but if they fail to do so
18257	                // they'll end up with nasty segfaults, so this is public service.
18258	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
18259	                {
18260	        __failure = 350;
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_350;}
18267	            }
18268	            if (!PyArray_Check(py_V349)) {
18269	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
18270	                {
18271	        __failure = 350;
18272	        if (!PyErr_Occurred()) {
18273	            PyErr_SetString(PyExc_RuntimeError,
18274	                "Unexpected error in an Op's C code. "
18275	                "No Python exception was set.");
18276	            }
18277	        goto __label_350;}
18278	            }
18279	            // We expect NPY_INT8
18280	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V349)) {
18281	                PyArrayObject * tmp = (PyArrayObject*) py_V349;
18282	                PyErr_Format(PyExc_NotImplementedError,
18283	                             "expected an aligned array of type %ld "
18284	                             "(NPY_INT8), got non-aligned array of type %ld"
18285	                             " with %ld dimensions, with 3 last dims "
18286	                             "%ld, %ld, %ld"
18287	                             " and 3 last strides %ld %ld, %ld.",
18288	                             (long int) NPY_INT8,
18289	                             (long int) PyArray_TYPE((PyArrayObject*) py_V349),
18290	                             (long int) PyArray_NDIM(tmp),
18291	                             (long int) PyArray_NDIM(tmp) >= 3 ?
18292	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
18293	                             (long int) PyArray_NDIM(tmp) >= 2 ?
18294	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
18295	                             (long int) PyArray_NDIM(tmp) >= 1 ?
18296	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
18297	                             (long int) PyArray_NDIM(tmp) >= 3 ?
18298	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
18299	                             (long int) PyArray_NDIM(tmp) >= 2 ?
18300	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
18301	                             (long int) PyArray_NDIM(tmp) >= 1 ?
18302	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
18303	            );
18304	                {
18305	        __failure = 350;
18306	        if (!PyErr_Occurred()) {
18307	            PyErr_SetString(PyExc_RuntimeError,
18308	                "Unexpected error in an Op's C code. "
18309	                "No Python exception was set.");
18310	            }
18311	        goto __label_350;}
18312	            }
18313	            // This is a TypeError to be consistent with DEBUG_MODE
18314	            // Note: DEBUG_MODE also tells the name of the container
18315	            if (PyArray_TYPE((PyArrayObject*) py_V349) != NPY_INT8) {
18316	                PyErr_Format(PyExc_TypeError,
18317	                             "expected type_num %d (NPY_INT8) got %d",
18318	                             NPY_INT8, PyArray_TYPE((PyArrayObject*) py_V349));
18319	                {
18320	        __failure = 350;
18321	        if (!PyErr_Occurred()) {
18322	            PyErr_SetString(PyExc_RuntimeError,
18323	                "Unexpected error in an Op's C code. "
18324	                "No Python exception was set.");
18325	            }
18326	        goto __label_350;}
18327	            }
18328
18329	        V349 = (PyArrayObject*)(py_V349);
18330	        Py_XINCREF(V349);
18331
18332	{
18333
18334	    py_V351 = PyList_GET_ITEM(storage_V351, 0);
18335	    {Py_XINCREF(py_V351);}
18336
18337	            V351 = NULL;
18338	            if (py_V351 == Py_None) {
18339	                // We can either fail here or set V351 to NULL and rely on Ops
18340	                // using tensors to handle the NULL case, but if they fail to do so
18341	                // they'll end up with nasty segfaults, so this is public service.
18342	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
18343	                {
18344	        __failure = 352;
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_352;}
18351	            }
18352	            if (!PyArray_Check(py_V351)) {
18353	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
18354	                {
18355	        __failure = 352;
18356	        if (!PyErr_Occurred()) {
18357	            PyErr_SetString(PyExc_RuntimeError,
18358	                "Unexpected error in an Op's C code. "
18359	                "No Python exception was set.");
18360	            }
18361	        goto __label_352;}
18362	            }
18363	            // We expect NPY_FLOAT64
18364	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V351)) {
18365	                PyArrayObject * tmp = (PyArrayObject*) py_V351;
18366	                PyErr_Format(PyExc_NotImplementedError,
18367	                             "expected an aligned array of type %ld "
18368	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
18369	                             " with %ld dimensions, with 3 last dims "
18370	                             "%ld, %ld, %ld"
18371	                             " and 3 last strides %ld %ld, %ld.",
18372	                             (long int) NPY_FLOAT64,
18373	                             (long int) PyArray_TYPE((PyArrayObject*) py_V351),
18374	                             (long int) PyArray_NDIM(tmp),
18375	                             (long int) PyArray_NDIM(tmp) >= 3 ?
18376	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
18377	                             (long int) PyArray_NDIM(tmp) >= 2 ?
18378	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
18379	                             (long int) PyArray_NDIM(tmp) >= 1 ?
18380	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
18381	                             (long int) PyArray_NDIM(tmp) >= 3 ?
18382	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
18383	                             (long int) PyArray_NDIM(tmp) >= 2 ?
18384	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
18385	                             (long int) PyArray_NDIM(tmp) >= 1 ?
18386	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
18387	            );
18388	                {
18389	        __failure = 352;
18390	        if (!PyErr_Occurred()) {
18391	            PyErr_SetString(PyExc_RuntimeError,
18392	                "Unexpected error in an Op's C code. "
18393	                "No Python exception was set.");
18394	            }
18395	        goto __label_352;}
18396	            }
18397	            // This is a TypeError to be consistent with DEBUG_MODE
18398	            // Note: DEBUG_MODE also tells the name of the container
18399	            if (PyArray_TYPE((PyArrayObject*) py_V351) != NPY_FLOAT64) {
18400	                PyErr_Format(PyExc_TypeError,
18401	                             "expected type_num %d (NPY_FLOAT64) got %d",
18402	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V351));
18403	                {
18404	        __failure = 352;
18405	        if (!PyErr_Occurred()) {
18406	            PyErr_SetString(PyExc_RuntimeError,
18407	                "Unexpected error in an Op's C code. "
18408	                "No Python exception was set.");
18409	            }
18410	        goto __label_352;}
18411	            }
18412
18413	        V351 = (PyArrayObject*)(py_V351);
18414	        Py_XINCREF(V351);
18415
18416	{
18417
18418	    py_V353 = PyList_GET_ITEM(storage_V353, 0);
18419	    {Py_XINCREF(py_V353);}
18420
18421	            V353 = NULL;
18422	            if (py_V353 == Py_None) {
18423	                // We can either fail here or set V353 to NULL and rely on Ops
18424	                // using tensors to handle the NULL case, but if they fail to do so
18425	                // they'll end up with nasty segfaults, so this is public service.
18426	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
18427	                {
18428	        __failure = 354;
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_354;}
18435	            }
18436	            if (!PyArray_Check(py_V353)) {
18437	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
18438	                {
18439	        __failure = 354;
18440	        if (!PyErr_Occurred()) {
18441	            PyErr_SetString(PyExc_RuntimeError,
18442	                "Unexpected error in an Op's C code. "
18443	                "No Python exception was set.");
18444	            }
18445	        goto __label_354;}
18446	            }
18447	            // We expect NPY_FLOAT64
18448	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V353)) {
18449	                PyArrayObject * tmp = (PyArrayObject*) py_V353;
18450	                PyErr_Format(PyExc_NotImplementedError,
18451	                             "expected an aligned array of type %ld "
18452	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
18453	                             " with %ld dimensions, with 3 last dims "
18454	                             "%ld, %ld, %ld"
18455	                             " and 3 last strides %ld %ld, %ld.",
18456	                             (long int) NPY_FLOAT64,
18457	                             (long int) PyArray_TYPE((PyArrayObject*) py_V353),
18458	                             (long int) PyArray_NDIM(tmp),
18459	                             (long int) PyArray_NDIM(tmp) >= 3 ?
18460	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
18461	                             (long int) PyArray_NDIM(tmp) >= 2 ?
18462	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
18463	                             (long int) PyArray_NDIM(tmp) >= 1 ?
18464	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
18465	                             (long int) PyArray_NDIM(tmp) >= 3 ?
18466	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
18467	                             (long int) PyArray_NDIM(tmp) >= 2 ?
18468	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
18469	                             (long int) PyArray_NDIM(tmp) >= 1 ?
18470	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
18471	            );
18472	                {
18473	        __failure = 354;
18474	        if (!PyErr_Occurred()) {
18475	            PyErr_SetString(PyExc_RuntimeError,
18476	                "Unexpected error in an Op's C code. "
18477	                "No Python exception was set.");
18478	            }
18479	        goto __label_354;}
18480	            }
18481	            // This is a TypeError to be consistent with DEBUG_MODE
18482	            // Note: DEBUG_MODE also tells the name of the container
18483	            if (PyArray_TYPE((PyArrayObject*) py_V353) != NPY_FLOAT64) {
18484	                PyErr_Format(PyExc_TypeError,
18485	                             "expected type_num %d (NPY_FLOAT64) got %d",
18486	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V353));
18487	                {
18488	        __failure = 354;
18489	        if (!PyErr_Occurred()) {
18490	            PyErr_SetString(PyExc_RuntimeError,
18491	                "Unexpected error in an Op's C code. "
18492	                "No Python exception was set.");
18493	            }
18494	        goto __label_354;}
18495	            }
18496
18497	        V353 = (PyArrayObject*)(py_V353);
18498	        Py_XINCREF(V353);
18499
18500	{
18501
18502	    py_V355 = PyList_GET_ITEM(storage_V355, 0);
18503	    {Py_XINCREF(py_V355);}
18504
18505	            V355 = NULL;
18506	            if (py_V355 == Py_None) {
18507	                // We can either fail here or set V355 to NULL and rely on Ops
18508	                // using tensors to handle the NULL case, but if they fail to do so
18509	                // they'll end up with nasty segfaults, so this is public service.
18510	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
18511	                {
18512	        __failure = 356;
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_356;}
18519	            }
18520	            if (!PyArray_Check(py_V355)) {
18521	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
18522	                {
18523	        __failure = 356;
18524	        if (!PyErr_Occurred()) {
18525	            PyErr_SetString(PyExc_RuntimeError,
18526	                "Unexpected error in an Op's C code. "
18527	                "No Python exception was set.");
18528	            }
18529	        goto __label_356;}
18530	            }
18531	            // We expect NPY_FLOAT64
18532	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V355)) {
18533	                PyArrayObject * tmp = (PyArrayObject*) py_V355;
18534	                PyErr_Format(PyExc_NotImplementedError,
18535	                             "expected an aligned array of type %ld "
18536	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
18537	                             " with %ld dimensions, with 3 last dims "
18538	                             "%ld, %ld, %ld"
18539	                             " and 3 last strides %ld %ld, %ld.",
18540	                             (long int) NPY_FLOAT64,
18541	                             (long int) PyArray_TYPE((PyArrayObject*) py_V355),
18542	                             (long int) PyArray_NDIM(tmp),
18543	                             (long int) PyArray_NDIM(tmp) >= 3 ?
18544	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
18545	                             (long int) PyArray_NDIM(tmp) >= 2 ?
18546	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
18547	                             (long int) PyArray_NDIM(tmp) >= 1 ?
18548	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
18549	                             (long int) PyArray_NDIM(tmp) >= 3 ?
18550	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
18551	                             (long int) PyArray_NDIM(tmp) >= 2 ?
18552	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
18553	                             (long int) PyArray_NDIM(tmp) >= 1 ?
18554	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
18555	            );
18556	                {
18557	        __failure = 356;
18558	        if (!PyErr_Occurred()) {
18559	            PyErr_SetString(PyExc_RuntimeError,
18560	                "Unexpected error in an Op's C code. "
18561	                "No Python exception was set.");
18562	            }
18563	        goto __label_356;}
18564	            }
18565	            // This is a TypeError to be consistent with DEBUG_MODE
18566	            // Note: DEBUG_MODE also tells the name of the container
18567	            if (PyArray_TYPE((PyArrayObject*) py_V355) != NPY_FLOAT64) {
18568	                PyErr_Format(PyExc_TypeError,
18569	                             "expected type_num %d (NPY_FLOAT64) got %d",
18570	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V355));
18571	                {
18572	        __failure = 356;
18573	        if (!PyErr_Occurred()) {
18574	            PyErr_SetString(PyExc_RuntimeError,
18575	                "Unexpected error in an Op's C code. "
18576	                "No Python exception was set.");
18577	            }
18578	        goto __label_356;}
18579	            }
18580
18581	        V355 = (PyArrayObject*)(py_V355);
18582	        Py_XINCREF(V355);
18583
18584	{
18585
18586	    py_V357 = PyList_GET_ITEM(storage_V357, 0);
18587	    {Py_XINCREF(py_V357);}
18588
18589	            V357 = NULL;
18590	            if (py_V357 == Py_None) {
18591	                // We can either fail here or set V357 to NULL and rely on Ops
18592	                // using tensors to handle the NULL case, but if they fail to do so
18593	                // they'll end up with nasty segfaults, so this is public service.
18594	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
18595	                {
18596	        __failure = 358;
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_358;}
18603	            }
18604	            if (!PyArray_Check(py_V357)) {
18605	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
18606	                {
18607	        __failure = 358;
18608	        if (!PyErr_Occurred()) {
18609	            PyErr_SetString(PyExc_RuntimeError,
18610	                "Unexpected error in an Op's C code. "
18611	                "No Python exception was set.");
18612	            }
18613	        goto __label_358;}
18614	            }
18615	            // We expect NPY_FLOAT64
18616	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V357)) {
18617	                PyArrayObject * tmp = (PyArrayObject*) py_V357;
18618	                PyErr_Format(PyExc_NotImplementedError,
18619	                             "expected an aligned array of type %ld "
18620	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
18621	                             " with %ld dimensions, with 3 last dims "
18622	                             "%ld, %ld, %ld"
18623	                             " and 3 last strides %ld %ld, %ld.",
18624	                             (long int) NPY_FLOAT64,
18625	                             (long int) PyArray_TYPE((PyArrayObject*) py_V357),
18626	                             (long int) PyArray_NDIM(tmp),
18627	                             (long int) PyArray_NDIM(tmp) >= 3 ?
18628	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
18629	                             (long int) PyArray_NDIM(tmp) >= 2 ?
18630	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
18631	                             (long int) PyArray_NDIM(tmp) >= 1 ?
18632	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
18633	                             (long int) PyArray_NDIM(tmp) >= 3 ?
18634	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
18635	                             (long int) PyArray_NDIM(tmp) >= 2 ?
18636	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
18637	                             (long int) PyArray_NDIM(tmp) >= 1 ?
18638	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
18639	            );
18640	                {
18641	        __failure = 358;
18642	        if (!PyErr_Occurred()) {
18643	            PyErr_SetString(PyExc_RuntimeError,
18644	                "Unexpected error in an Op's C code. "
18645	                "No Python exception was set.");
18646	            }
18647	        goto __label_358;}
18648	            }
18649	            // This is a TypeError to be consistent with DEBUG_MODE
18650	            // Note: DEBUG_MODE also tells the name of the container
18651	            if (PyArray_TYPE((PyArrayObject*) py_V357) != NPY_FLOAT64) {
18652	                PyErr_Format(PyExc_TypeError,
18653	                             "expected type_num %d (NPY_FLOAT64) got %d",
18654	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V357));
18655	                {
18656	        __failure = 358;
18657	        if (!PyErr_Occurred()) {
18658	            PyErr_SetString(PyExc_RuntimeError,
18659	                "Unexpected error in an Op's C code. "
18660	                "No Python exception was set.");
18661	            }
18662	        goto __label_358;}
18663	            }
18664
18665	        V357 = (PyArrayObject*)(py_V357);
18666	        Py_XINCREF(V357);
18667
18668	{
18669
18670	    py_V359 = PyList_GET_ITEM(storage_V359, 0);
18671	    {Py_XINCREF(py_V359);}
18672
18673	            V359 = NULL;
18674	            if (py_V359 == Py_None) {
18675	                // We can either fail here or set V359 to NULL and rely on Ops
18676	                // using tensors to handle the NULL case, but if they fail to do so
18677	                // they'll end up with nasty segfaults, so this is public service.
18678	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
18679	                {
18680	        __failure = 360;
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_360;}
18687	            }
18688	            if (!PyArray_Check(py_V359)) {
18689	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
18690	                {
18691	        __failure = 360;
18692	        if (!PyErr_Occurred()) {
18693	            PyErr_SetString(PyExc_RuntimeError,
18694	                "Unexpected error in an Op's C code. "
18695	                "No Python exception was set.");
18696	            }
18697	        goto __label_360;}
18698	            }
18699	            // We expect NPY_FLOAT64
18700	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V359)) {
18701	                PyArrayObject * tmp = (PyArrayObject*) py_V359;
18702	                PyErr_Format(PyExc_NotImplementedError,
18703	                             "expected an aligned array of type %ld "
18704	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
18705	                             " with %ld dimensions, with 3 last dims "
18706	                             "%ld, %ld, %ld"
18707	                             " and 3 last strides %ld %ld, %ld.",
18708	                             (long int) NPY_FLOAT64,
18709	                             (long int) PyArray_TYPE((PyArrayObject*) py_V359),
18710	                             (long int) PyArray_NDIM(tmp),
18711	                             (long int) PyArray_NDIM(tmp) >= 3 ?
18712	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
18713	                             (long int) PyArray_NDIM(tmp) >= 2 ?
18714	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
18715	                             (long int) PyArray_NDIM(tmp) >= 1 ?
18716	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
18717	                             (long int) PyArray_NDIM(tmp) >= 3 ?
18718	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
18719	                             (long int) PyArray_NDIM(tmp) >= 2 ?
18720	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
18721	                             (long int) PyArray_NDIM(tmp) >= 1 ?
18722	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
18723	            );
18724	                {
18725	        __failure = 360;
18726	        if (!PyErr_Occurred()) {
18727	            PyErr_SetString(PyExc_RuntimeError,
18728	                "Unexpected error in an Op's C code. "
18729	                "No Python exception was set.");
18730	            }
18731	        goto __label_360;}
18732	            }
18733	            // This is a TypeError to be consistent with DEBUG_MODE
18734	            // Note: DEBUG_MODE also tells the name of the container
18735	            if (PyArray_TYPE((PyArrayObject*) py_V359) != NPY_FLOAT64) {
18736	                PyErr_Format(PyExc_TypeError,
18737	                             "expected type_num %d (NPY_FLOAT64) got %d",
18738	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V359));
18739	                {
18740	        __failure = 360;
18741	        if (!PyErr_Occurred()) {
18742	            PyErr_SetString(PyExc_RuntimeError,
18743	                "Unexpected error in an Op's C code. "
18744	                "No Python exception was set.");
18745	            }
18746	        goto __label_360;}
18747	            }
18748
18749	        V359 = (PyArrayObject*)(py_V359);
18750	        Py_XINCREF(V359);
18751
18752	{
18753
18754	    py_V361 = PyList_GET_ITEM(storage_V361, 0);
18755	    {Py_XINCREF(py_V361);}
18756
18757	            V361 = NULL;
18758	            if (py_V361 == Py_None) {
18759	                // We can either fail here or set V361 to NULL and rely on Ops
18760	                // using tensors to handle the NULL case, but if they fail to do so
18761	                // they'll end up with nasty segfaults, so this is public service.
18762	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
18763	                {
18764	        __failure = 362;
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_362;}
18771	            }
18772	            if (!PyArray_Check(py_V361)) {
18773	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
18774	                {
18775	        __failure = 362;
18776	        if (!PyErr_Occurred()) {
18777	            PyErr_SetString(PyExc_RuntimeError,
18778	                "Unexpected error in an Op's C code. "
18779	                "No Python exception was set.");
18780	            }
18781	        goto __label_362;}
18782	            }
18783	            // We expect NPY_FLOAT64
18784	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V361)) {
18785	                PyArrayObject * tmp = (PyArrayObject*) py_V361;
18786	                PyErr_Format(PyExc_NotImplementedError,
18787	                             "expected an aligned array of type %ld "
18788	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
18789	                             " with %ld dimensions, with 3 last dims "
18790	                             "%ld, %ld, %ld"
18791	                             " and 3 last strides %ld %ld, %ld.",
18792	                             (long int) NPY_FLOAT64,
18793	                             (long int) PyArray_TYPE((PyArrayObject*) py_V361),
18794	                             (long int) PyArray_NDIM(tmp),
18795	                             (long int) PyArray_NDIM(tmp) >= 3 ?
18796	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
18797	                             (long int) PyArray_NDIM(tmp) >= 2 ?
18798	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
18799	                             (long int) PyArray_NDIM(tmp) >= 1 ?
18800	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
18801	                             (long int) PyArray_NDIM(tmp) >= 3 ?
18802	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
18803	                             (long int) PyArray_NDIM(tmp) >= 2 ?
18804	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
18805	                             (long int) PyArray_NDIM(tmp) >= 1 ?
18806	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
18807	            );
18808	                {
18809	        __failure = 362;
18810	        if (!PyErr_Occurred()) {
18811	            PyErr_SetString(PyExc_RuntimeError,
18812	                "Unexpected error in an Op's C code. "
18813	                "No Python exception was set.");
18814	            }
18815	        goto __label_362;}
18816	            }
18817	            // This is a TypeError to be consistent with DEBUG_MODE
18818	            // Note: DEBUG_MODE also tells the name of the container
18819	            if (PyArray_TYPE((PyArrayObject*) py_V361) != NPY_FLOAT64) {
18820	                PyErr_Format(PyExc_TypeError,
18821	                             "expected type_num %d (NPY_FLOAT64) got %d",
18822	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V361));
18823	                {
18824	        __failure = 362;
18825	        if (!PyErr_Occurred()) {
18826	            PyErr_SetString(PyExc_RuntimeError,
18827	                "Unexpected error in an Op's C code. "
18828	                "No Python exception was set.");
18829	            }
18830	        goto __label_362;}
18831	            }
18832
18833	        V361 = (PyArrayObject*)(py_V361);
18834	        Py_XINCREF(V361);
18835
18836	{
18837
18838	    py_V363 = PyList_GET_ITEM(storage_V363, 0);
18839	    {Py_XINCREF(py_V363);}
18840
18841	            V363 = NULL;
18842	            if (py_V363 == Py_None) {
18843	                // We can either fail here or set V363 to NULL and rely on Ops
18844	                // using tensors to handle the NULL case, but if they fail to do so
18845	                // they'll end up with nasty segfaults, so this is public service.
18846	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
18847	                {
18848	        __failure = 364;
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_364;}
18855	            }
18856	            if (!PyArray_Check(py_V363)) {
18857	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
18858	                {
18859	        __failure = 364;
18860	        if (!PyErr_Occurred()) {
18861	            PyErr_SetString(PyExc_RuntimeError,
18862	                "Unexpected error in an Op's C code. "
18863	                "No Python exception was set.");
18864	            }
18865	        goto __label_364;}
18866	            }
18867	            // We expect NPY_FLOAT64
18868	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V363)) {
18869	                PyArrayObject * tmp = (PyArrayObject*) py_V363;
18870	                PyErr_Format(PyExc_NotImplementedError,
18871	                             "expected an aligned array of type %ld "
18872	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
18873	                             " with %ld dimensions, with 3 last dims "
18874	                             "%ld, %ld, %ld"
18875	                             " and 3 last strides %ld %ld, %ld.",
18876	                             (long int) NPY_FLOAT64,
18877	                             (long int) PyArray_TYPE((PyArrayObject*) py_V363),
18878	                             (long int) PyArray_NDIM(tmp),
18879	                             (long int) PyArray_NDIM(tmp) >= 3 ?
18880	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
18881	                             (long int) PyArray_NDIM(tmp) >= 2 ?
18882	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
18883	                             (long int) PyArray_NDIM(tmp) >= 1 ?
18884	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
18885	                             (long int) PyArray_NDIM(tmp) >= 3 ?
18886	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
18887	                             (long int) PyArray_NDIM(tmp) >= 2 ?
18888	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
18889	                             (long int) PyArray_NDIM(tmp) >= 1 ?
18890	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
18891	            );
18892	                {
18893	        __failure = 364;
18894	        if (!PyErr_Occurred()) {
18895	            PyErr_SetString(PyExc_RuntimeError,
18896	                "Unexpected error in an Op's C code. "
18897	                "No Python exception was set.");
18898	            }
18899	        goto __label_364;}
18900	            }
18901	            // This is a TypeError to be consistent with DEBUG_MODE
18902	            // Note: DEBUG_MODE also tells the name of the container
18903	            if (PyArray_TYPE((PyArrayObject*) py_V363) != NPY_FLOAT64) {
18904	                PyErr_Format(PyExc_TypeError,
18905	                             "expected type_num %d (NPY_FLOAT64) got %d",
18906	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V363));
18907	                {
18908	        __failure = 364;
18909	        if (!PyErr_Occurred()) {
18910	            PyErr_SetString(PyExc_RuntimeError,
18911	                "Unexpected error in an Op's C code. "
18912	                "No Python exception was set.");
18913	            }
18914	        goto __label_364;}
18915	            }
18916
18917	        V363 = (PyArrayObject*)(py_V363);
18918	        Py_XINCREF(V363);
18919
18920	{
18921
18922	    py_V365 = PyList_GET_ITEM(storage_V365, 0);
18923	    {Py_XINCREF(py_V365);}
18924
18925	            V365 = NULL;
18926	            if (py_V365 == Py_None) {
18927	                // We can either fail here or set V365 to NULL and rely on Ops
18928	                // using tensors to handle the NULL case, but if they fail to do so
18929	                // they'll end up with nasty segfaults, so this is public service.
18930	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
18931	                {
18932	        __failure = 366;
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_366;}
18939	            }
18940	            if (!PyArray_Check(py_V365)) {
18941	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
18942	                {
18943	        __failure = 366;
18944	        if (!PyErr_Occurred()) {
18945	            PyErr_SetString(PyExc_RuntimeError,
18946	                "Unexpected error in an Op's C code. "
18947	                "No Python exception was set.");
18948	            }
18949	        goto __label_366;}
18950	            }
18951	            // We expect NPY_INT8
18952	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V365)) {
18953	                PyArrayObject * tmp = (PyArrayObject*) py_V365;
18954	                PyErr_Format(PyExc_NotImplementedError,
18955	                             "expected an aligned array of type %ld "
18956	                             "(NPY_INT8), got non-aligned array of type %ld"
18957	                             " with %ld dimensions, with 3 last dims "
18958	                             "%ld, %ld, %ld"
18959	                             " and 3 last strides %ld %ld, %ld.",
18960	                             (long int) NPY_INT8,
18961	                             (long int) PyArray_TYPE((PyArrayObject*) py_V365),
18962	                             (long int) PyArray_NDIM(tmp),
18963	                             (long int) PyArray_NDIM(tmp) >= 3 ?
18964	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
18965	                             (long int) PyArray_NDIM(tmp) >= 2 ?
18966	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
18967	                             (long int) PyArray_NDIM(tmp) >= 1 ?
18968	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
18969	                             (long int) PyArray_NDIM(tmp) >= 3 ?
18970	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
18971	                             (long int) PyArray_NDIM(tmp) >= 2 ?
18972	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
18973	                             (long int) PyArray_NDIM(tmp) >= 1 ?
18974	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
18975	            );
18976	                {
18977	        __failure = 366;
18978	        if (!PyErr_Occurred()) {
18979	            PyErr_SetString(PyExc_RuntimeError,
18980	                "Unexpected error in an Op's C code. "
18981	                "No Python exception was set.");
18982	            }
18983	        goto __label_366;}
18984	            }
18985	            // This is a TypeError to be consistent with DEBUG_MODE
18986	            // Note: DEBUG_MODE also tells the name of the container
18987	            if (PyArray_TYPE((PyArrayObject*) py_V365) != NPY_INT8) {
18988	                PyErr_Format(PyExc_TypeError,
18989	                             "expected type_num %d (NPY_INT8) got %d",
18990	                             NPY_INT8, PyArray_TYPE((PyArrayObject*) py_V365));
18991	                {
18992	        __failure = 366;
18993	        if (!PyErr_Occurred()) {
18994	            PyErr_SetString(PyExc_RuntimeError,
18995	                "Unexpected error in an Op's C code. "
18996	                "No Python exception was set.");
18997	            }
18998	        goto __label_366;}
18999	            }
19000
19001	        V365 = (PyArrayObject*)(py_V365);
19002	        Py_XINCREF(V365);
19003
19004	{
19005
19006	    py_V367 = PyList_GET_ITEM(storage_V367, 0);
19007	    {Py_XINCREF(py_V367);}
19008
19009	            V367 = NULL;
19010	            if (py_V367 == Py_None) {
19011	                // We can either fail here or set V367 to NULL and rely on Ops
19012	                // using tensors to handle the NULL case, but if they fail to do so
19013	                // they'll end up with nasty segfaults, so this is public service.
19014	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
19015	                {
19016	        __failure = 368;
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_368;}
19023	            }
19024	            if (!PyArray_Check(py_V367)) {
19025	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
19026	                {
19027	        __failure = 368;
19028	        if (!PyErr_Occurred()) {
19029	            PyErr_SetString(PyExc_RuntimeError,
19030	                "Unexpected error in an Op's C code. "
19031	                "No Python exception was set.");
19032	            }
19033	        goto __label_368;}
19034	            }
19035	            // We expect NPY_FLOAT64
19036	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V367)) {
19037	                PyArrayObject * tmp = (PyArrayObject*) py_V367;
19038	                PyErr_Format(PyExc_NotImplementedError,
19039	                             "expected an aligned array of type %ld "
19040	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
19041	                             " with %ld dimensions, with 3 last dims "
19042	                             "%ld, %ld, %ld"
19043	                             " and 3 last strides %ld %ld, %ld.",
19044	                             (long int) NPY_FLOAT64,
19045	                             (long int) PyArray_TYPE((PyArrayObject*) py_V367),
19046	                             (long int) PyArray_NDIM(tmp),
19047	                             (long int) PyArray_NDIM(tmp) >= 3 ?
19048	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
19049	                             (long int) PyArray_NDIM(tmp) >= 2 ?
19050	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
19051	                             (long int) PyArray_NDIM(tmp) >= 1 ?
19052	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
19053	                             (long int) PyArray_NDIM(tmp) >= 3 ?
19054	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
19055	                             (long int) PyArray_NDIM(tmp) >= 2 ?
19056	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
19057	                             (long int) PyArray_NDIM(tmp) >= 1 ?
19058	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
19059	            );
19060	                {
19061	        __failure = 368;
19062	        if (!PyErr_Occurred()) {
19063	            PyErr_SetString(PyExc_RuntimeError,
19064	                "Unexpected error in an Op's C code. "
19065	                "No Python exception was set.");
19066	            }
19067	        goto __label_368;}
19068	            }
19069	            // This is a TypeError to be consistent with DEBUG_MODE
19070	            // Note: DEBUG_MODE also tells the name of the container
19071	            if (PyArray_TYPE((PyArrayObject*) py_V367) != NPY_FLOAT64) {
19072	                PyErr_Format(PyExc_TypeError,
19073	                             "expected type_num %d (NPY_FLOAT64) got %d",
19074	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V367));
19075	                {
19076	        __failure = 368;
19077	        if (!PyErr_Occurred()) {
19078	            PyErr_SetString(PyExc_RuntimeError,
19079	                "Unexpected error in an Op's C code. "
19080	                "No Python exception was set.");
19081	            }
19082	        goto __label_368;}
19083	            }
19084
19085	        V367 = (PyArrayObject*)(py_V367);
19086	        Py_XINCREF(V367);
19087
19088	{
19089
19090	    py_V369 = PyList_GET_ITEM(storage_V369, 0);
19091	    {Py_XINCREF(py_V369);}
19092
19093	            V369 = NULL;
19094	            if (py_V369 == Py_None) {
19095	                // We can either fail here or set V369 to NULL and rely on Ops
19096	                // using tensors to handle the NULL case, but if they fail to do so
19097	                // they'll end up with nasty segfaults, so this is public service.
19098	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
19099	                {
19100	        __failure = 370;
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_370;}
19107	            }
19108	            if (!PyArray_Check(py_V369)) {
19109	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
19110	                {
19111	        __failure = 370;
19112	        if (!PyErr_Occurred()) {
19113	            PyErr_SetString(PyExc_RuntimeError,
19114	                "Unexpected error in an Op's C code. "
19115	                "No Python exception was set.");
19116	            }
19117	        goto __label_370;}
19118	            }
19119	            // We expect NPY_FLOAT64
19120	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V369)) {
19121	                PyArrayObject * tmp = (PyArrayObject*) py_V369;
19122	                PyErr_Format(PyExc_NotImplementedError,
19123	                             "expected an aligned array of type %ld "
19124	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
19125	                             " with %ld dimensions, with 3 last dims "
19126	                             "%ld, %ld, %ld"
19127	                             " and 3 last strides %ld %ld, %ld.",
19128	                             (long int) NPY_FLOAT64,
19129	                             (long int) PyArray_TYPE((PyArrayObject*) py_V369),
19130	                             (long int) PyArray_NDIM(tmp),
19131	                             (long int) PyArray_NDIM(tmp) >= 3 ?
19132	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
19133	                             (long int) PyArray_NDIM(tmp) >= 2 ?
19134	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
19135	                             (long int) PyArray_NDIM(tmp) >= 1 ?
19136	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
19137	                             (long int) PyArray_NDIM(tmp) >= 3 ?
19138	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
19139	                             (long int) PyArray_NDIM(tmp) >= 2 ?
19140	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
19141	                             (long int) PyArray_NDIM(tmp) >= 1 ?
19142	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
19143	            );
19144	                {
19145	        __failure = 370;
19146	        if (!PyErr_Occurred()) {
19147	            PyErr_SetString(PyExc_RuntimeError,
19148	                "Unexpected error in an Op's C code. "
19149	                "No Python exception was set.");
19150	            }
19151	        goto __label_370;}
19152	            }
19153	            // This is a TypeError to be consistent with DEBUG_MODE
19154	            // Note: DEBUG_MODE also tells the name of the container
19155	            if (PyArray_TYPE((PyArrayObject*) py_V369) != NPY_FLOAT64) {
19156	                PyErr_Format(PyExc_TypeError,
19157	                             "expected type_num %d (NPY_FLOAT64) got %d",
19158	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V369));
19159	                {
19160	        __failure = 370;
19161	        if (!PyErr_Occurred()) {
19162	            PyErr_SetString(PyExc_RuntimeError,
19163	                "Unexpected error in an Op's C code. "
19164	                "No Python exception was set.");
19165	            }
19166	        goto __label_370;}
19167	            }
19168
19169	        V369 = (PyArrayObject*)(py_V369);
19170	        Py_XINCREF(V369);
19171
19172	{
19173
19174	    py_V371 = PyList_GET_ITEM(storage_V371, 0);
19175	    {Py_XINCREF(py_V371);}
19176
19177	            V371 = NULL;
19178	            if (py_V371 == Py_None) {
19179	                // We can either fail here or set V371 to NULL and rely on Ops
19180	                // using tensors to handle the NULL case, but if they fail to do so
19181	                // they'll end up with nasty segfaults, so this is public service.
19182	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
19183	                {
19184	        __failure = 372;
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_372;}
19191	            }
19192	            if (!PyArray_Check(py_V371)) {
19193	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
19194	                {
19195	        __failure = 372;
19196	        if (!PyErr_Occurred()) {
19197	            PyErr_SetString(PyExc_RuntimeError,
19198	                "Unexpected error in an Op's C code. "
19199	                "No Python exception was set.");
19200	            }
19201	        goto __label_372;}
19202	            }
19203	            // We expect NPY_FLOAT64
19204	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V371)) {
19205	                PyArrayObject * tmp = (PyArrayObject*) py_V371;
19206	                PyErr_Format(PyExc_NotImplementedError,
19207	                             "expected an aligned array of type %ld "
19208	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
19209	                             " with %ld dimensions, with 3 last dims "
19210	                             "%ld, %ld, %ld"
19211	                             " and 3 last strides %ld %ld, %ld.",
19212	                             (long int) NPY_FLOAT64,
19213	                             (long int) PyArray_TYPE((PyArrayObject*) py_V371),
19214	                             (long int) PyArray_NDIM(tmp),
19215	                             (long int) PyArray_NDIM(tmp) >= 3 ?
19216	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
19217	                             (long int) PyArray_NDIM(tmp) >= 2 ?
19218	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
19219	                             (long int) PyArray_NDIM(tmp) >= 1 ?
19220	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
19221	                             (long int) PyArray_NDIM(tmp) >= 3 ?
19222	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
19223	                             (long int) PyArray_NDIM(tmp) >= 2 ?
19224	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
19225	                             (long int) PyArray_NDIM(tmp) >= 1 ?
19226	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
19227	            );
19228	                {
19229	        __failure = 372;
19230	        if (!PyErr_Occurred()) {
19231	            PyErr_SetString(PyExc_RuntimeError,
19232	                "Unexpected error in an Op's C code. "
19233	                "No Python exception was set.");
19234	            }
19235	        goto __label_372;}
19236	            }
19237	            // This is a TypeError to be consistent with DEBUG_MODE
19238	            // Note: DEBUG_MODE also tells the name of the container
19239	            if (PyArray_TYPE((PyArrayObject*) py_V371) != NPY_FLOAT64) {
19240	                PyErr_Format(PyExc_TypeError,
19241	                             "expected type_num %d (NPY_FLOAT64) got %d",
19242	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V371));
19243	                {
19244	        __failure = 372;
19245	        if (!PyErr_Occurred()) {
19246	            PyErr_SetString(PyExc_RuntimeError,
19247	                "Unexpected error in an Op's C code. "
19248	                "No Python exception was set.");
19249	            }
19250	        goto __label_372;}
19251	            }
19252
19253	        V371 = (PyArrayObject*)(py_V371);
19254	        Py_XINCREF(V371);
19255
19256	{
19257
19258	    py_V373 = PyList_GET_ITEM(storage_V373, 0);
19259	    {Py_XINCREF(py_V373);}
19260
19261	            V373 = NULL;
19262	            if (py_V373 == Py_None) {
19263	                // We can either fail here or set V373 to NULL and rely on Ops
19264	                // using tensors to handle the NULL case, but if they fail to do so
19265	                // they'll end up with nasty segfaults, so this is public service.
19266	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
19267	                {
19268	        __failure = 374;
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_374;}
19275	            }
19276	            if (!PyArray_Check(py_V373)) {
19277	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
19278	                {
19279	        __failure = 374;
19280	        if (!PyErr_Occurred()) {
19281	            PyErr_SetString(PyExc_RuntimeError,
19282	                "Unexpected error in an Op's C code. "
19283	                "No Python exception was set.");
19284	            }
19285	        goto __label_374;}
19286	            }
19287	            // We expect NPY_FLOAT64
19288	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V373)) {
19289	                PyArrayObject * tmp = (PyArrayObject*) py_V373;
19290	                PyErr_Format(PyExc_NotImplementedError,
19291	                             "expected an aligned array of type %ld "
19292	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
19293	                             " with %ld dimensions, with 3 last dims "
19294	                             "%ld, %ld, %ld"
19295	                             " and 3 last strides %ld %ld, %ld.",
19296	                             (long int) NPY_FLOAT64,
19297	                             (long int) PyArray_TYPE((PyArrayObject*) py_V373),
19298	                             (long int) PyArray_NDIM(tmp),
19299	                             (long int) PyArray_NDIM(tmp) >= 3 ?
19300	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
19301	                             (long int) PyArray_NDIM(tmp) >= 2 ?
19302	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
19303	                             (long int) PyArray_NDIM(tmp) >= 1 ?
19304	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
19305	                             (long int) PyArray_NDIM(tmp) >= 3 ?
19306	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
19307	                             (long int) PyArray_NDIM(tmp) >= 2 ?
19308	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
19309	                             (long int) PyArray_NDIM(tmp) >= 1 ?
19310	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
19311	            );
19312	                {
19313	        __failure = 374;
19314	        if (!PyErr_Occurred()) {
19315	            PyErr_SetString(PyExc_RuntimeError,
19316	                "Unexpected error in an Op's C code. "
19317	                "No Python exception was set.");
19318	            }
19319	        goto __label_374;}
19320	            }
19321	            // This is a TypeError to be consistent with DEBUG_MODE
19322	            // Note: DEBUG_MODE also tells the name of the container
19323	            if (PyArray_TYPE((PyArrayObject*) py_V373) != NPY_FLOAT64) {
19324	                PyErr_Format(PyExc_TypeError,
19325	                             "expected type_num %d (NPY_FLOAT64) got %d",
19326	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V373));
19327	                {
19328	        __failure = 374;
19329	        if (!PyErr_Occurred()) {
19330	            PyErr_SetString(PyExc_RuntimeError,
19331	                "Unexpected error in an Op's C code. "
19332	                "No Python exception was set.");
19333	            }
19334	        goto __label_374;}
19335	            }
19336
19337	        V373 = (PyArrayObject*)(py_V373);
19338	        Py_XINCREF(V373);
19339
19340	{
19341
19342	    py_V375 = PyList_GET_ITEM(storage_V375, 0);
19343	    {Py_XINCREF(py_V375);}
19344
19345	            V375 = NULL;
19346	            if (py_V375 == Py_None) {
19347	                // We can either fail here or set V375 to NULL and rely on Ops
19348	                // using tensors to handle the NULL case, but if they fail to do so
19349	                // they'll end up with nasty segfaults, so this is public service.
19350	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
19351	                {
19352	        __failure = 376;
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_376;}
19359	            }
19360	            if (!PyArray_Check(py_V375)) {
19361	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
19362	                {
19363	        __failure = 376;
19364	        if (!PyErr_Occurred()) {
19365	            PyErr_SetString(PyExc_RuntimeError,
19366	                "Unexpected error in an Op's C code. "
19367	                "No Python exception was set.");
19368	            }
19369	        goto __label_376;}
19370	            }
19371	            // We expect NPY_FLOAT64
19372	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V375)) {
19373	                PyArrayObject * tmp = (PyArrayObject*) py_V375;
19374	                PyErr_Format(PyExc_NotImplementedError,
19375	                             "expected an aligned array of type %ld "
19376	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
19377	                             " with %ld dimensions, with 3 last dims "
19378	                             "%ld, %ld, %ld"
19379	                             " and 3 last strides %ld %ld, %ld.",
19380	                             (long int) NPY_FLOAT64,
19381	                             (long int) PyArray_TYPE((PyArrayObject*) py_V375),
19382	                             (long int) PyArray_NDIM(tmp),
19383	                             (long int) PyArray_NDIM(tmp) >= 3 ?
19384	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
19385	                             (long int) PyArray_NDIM(tmp) >= 2 ?
19386	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
19387	                             (long int) PyArray_NDIM(tmp) >= 1 ?
19388	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
19389	                             (long int) PyArray_NDIM(tmp) >= 3 ?
19390	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
19391	                             (long int) PyArray_NDIM(tmp) >= 2 ?
19392	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
19393	                             (long int) PyArray_NDIM(tmp) >= 1 ?
19394	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
19395	            );
19396	                {
19397	        __failure = 376;
19398	        if (!PyErr_Occurred()) {
19399	            PyErr_SetString(PyExc_RuntimeError,
19400	                "Unexpected error in an Op's C code. "
19401	                "No Python exception was set.");
19402	            }
19403	        goto __label_376;}
19404	            }
19405	            // This is a TypeError to be consistent with DEBUG_MODE
19406	            // Note: DEBUG_MODE also tells the name of the container
19407	            if (PyArray_TYPE((PyArrayObject*) py_V375) != NPY_FLOAT64) {
19408	                PyErr_Format(PyExc_TypeError,
19409	                             "expected type_num %d (NPY_FLOAT64) got %d",
19410	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V375));
19411	                {
19412	        __failure = 376;
19413	        if (!PyErr_Occurred()) {
19414	            PyErr_SetString(PyExc_RuntimeError,
19415	                "Unexpected error in an Op's C code. "
19416	                "No Python exception was set.");
19417	            }
19418	        goto __label_376;}
19419	            }
19420
19421	        V375 = (PyArrayObject*)(py_V375);
19422	        Py_XINCREF(V375);
19423
19424	{
19425
19426	    py_V377 = PyList_GET_ITEM(storage_V377, 0);
19427	    {Py_XINCREF(py_V377);}
19428
19429	            V377 = NULL;
19430	            if (py_V377 == Py_None) {
19431	                // We can either fail here or set V377 to NULL and rely on Ops
19432	                // using tensors to handle the NULL case, but if they fail to do so
19433	                // they'll end up with nasty segfaults, so this is public service.
19434	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
19435	                {
19436	        __failure = 378;
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_378;}
19443	            }
19444	            if (!PyArray_Check(py_V377)) {
19445	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
19446	                {
19447	        __failure = 378;
19448	        if (!PyErr_Occurred()) {
19449	            PyErr_SetString(PyExc_RuntimeError,
19450	                "Unexpected error in an Op's C code. "
19451	                "No Python exception was set.");
19452	            }
19453	        goto __label_378;}
19454	            }
19455	            // We expect NPY_FLOAT64
19456	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V377)) {
19457	                PyArrayObject * tmp = (PyArrayObject*) py_V377;
19458	                PyErr_Format(PyExc_NotImplementedError,
19459	                             "expected an aligned array of type %ld "
19460	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
19461	                             " with %ld dimensions, with 3 last dims "
19462	                             "%ld, %ld, %ld"
19463	                             " and 3 last strides %ld %ld, %ld.",
19464	                             (long int) NPY_FLOAT64,
19465	                             (long int) PyArray_TYPE((PyArrayObject*) py_V377),
19466	                             (long int) PyArray_NDIM(tmp),
19467	                             (long int) PyArray_NDIM(tmp) >= 3 ?
19468	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
19469	                             (long int) PyArray_NDIM(tmp) >= 2 ?
19470	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
19471	                             (long int) PyArray_NDIM(tmp) >= 1 ?
19472	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
19473	                             (long int) PyArray_NDIM(tmp) >= 3 ?
19474	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
19475	                             (long int) PyArray_NDIM(tmp) >= 2 ?
19476	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
19477	                             (long int) PyArray_NDIM(tmp) >= 1 ?
19478	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
19479	            );
19480	                {
19481	        __failure = 378;
19482	        if (!PyErr_Occurred()) {
19483	            PyErr_SetString(PyExc_RuntimeError,
19484	                "Unexpected error in an Op's C code. "
19485	                "No Python exception was set.");
19486	            }
19487	        goto __label_378;}
19488	            }
19489	            // This is a TypeError to be consistent with DEBUG_MODE
19490	            // Note: DEBUG_MODE also tells the name of the container
19491	            if (PyArray_TYPE((PyArrayObject*) py_V377) != NPY_FLOAT64) {
19492	                PyErr_Format(PyExc_TypeError,
19493	                             "expected type_num %d (NPY_FLOAT64) got %d",
19494	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V377));
19495	                {
19496	        __failure = 378;
19497	        if (!PyErr_Occurred()) {
19498	            PyErr_SetString(PyExc_RuntimeError,
19499	                "Unexpected error in an Op's C code. "
19500	                "No Python exception was set.");
19501	            }
19502	        goto __label_378;}
19503	            }
19504
19505	        V377 = (PyArrayObject*)(py_V377);
19506	        Py_XINCREF(V377);
19507
19508	{
19509
19510	    py_V379 = PyList_GET_ITEM(storage_V379, 0);
19511	    {Py_XINCREF(py_V379);}
19512
19513	            V379 = NULL;
19514	            if (py_V379 == Py_None) {
19515	                // We can either fail here or set V379 to NULL and rely on Ops
19516	                // using tensors to handle the NULL case, but if they fail to do so
19517	                // they'll end up with nasty segfaults, so this is public service.
19518	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
19519	                {
19520	        __failure = 380;
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_380;}
19527	            }
19528	            if (!PyArray_Check(py_V379)) {
19529	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
19530	                {
19531	        __failure = 380;
19532	        if (!PyErr_Occurred()) {
19533	            PyErr_SetString(PyExc_RuntimeError,
19534	                "Unexpected error in an Op's C code. "
19535	                "No Python exception was set.");
19536	            }
19537	        goto __label_380;}
19538	            }
19539	            // We expect NPY_INT8
19540	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V379)) {
19541	                PyArrayObject * tmp = (PyArrayObject*) py_V379;
19542	                PyErr_Format(PyExc_NotImplementedError,
19543	                             "expected an aligned array of type %ld "
19544	                             "(NPY_INT8), got non-aligned array of type %ld"
19545	                             " with %ld dimensions, with 3 last dims "
19546	                             "%ld, %ld, %ld"
19547	                             " and 3 last strides %ld %ld, %ld.",
19548	                             (long int) NPY_INT8,
19549	                             (long int) PyArray_TYPE((PyArrayObject*) py_V379),
19550	                             (long int) PyArray_NDIM(tmp),
19551	                             (long int) PyArray_NDIM(tmp) >= 3 ?
19552	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
19553	                             (long int) PyArray_NDIM(tmp) >= 2 ?
19554	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
19555	                             (long int) PyArray_NDIM(tmp) >= 1 ?
19556	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
19557	                             (long int) PyArray_NDIM(tmp) >= 3 ?
19558	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
19559	                             (long int) PyArray_NDIM(tmp) >= 2 ?
19560	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
19561	                             (long int) PyArray_NDIM(tmp) >= 1 ?
19562	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
19563	            );
19564	                {
19565	        __failure = 380;
19566	        if (!PyErr_Occurred()) {
19567	            PyErr_SetString(PyExc_RuntimeError,
19568	                "Unexpected error in an Op's C code. "
19569	                "No Python exception was set.");
19570	            }
19571	        goto __label_380;}
19572	            }
19573	            // This is a TypeError to be consistent with DEBUG_MODE
19574	            // Note: DEBUG_MODE also tells the name of the container
19575	            if (PyArray_TYPE((PyArrayObject*) py_V379) != NPY_INT8) {
19576	                PyErr_Format(PyExc_TypeError,
19577	                             "expected type_num %d (NPY_INT8) got %d",
19578	                             NPY_INT8, PyArray_TYPE((PyArrayObject*) py_V379));
19579	                {
19580	        __failure = 380;
19581	        if (!PyErr_Occurred()) {
19582	            PyErr_SetString(PyExc_RuntimeError,
19583	                "Unexpected error in an Op's C code. "
19584	                "No Python exception was set.");
19585	            }
19586	        goto __label_380;}
19587	            }
19588
19589	        V379 = (PyArrayObject*)(py_V379);
19590	        Py_XINCREF(V379);
19591
19592	{
19593
19594	    py_V381 = PyList_GET_ITEM(storage_V381, 0);
19595	    {Py_XINCREF(py_V381);}
19596
19597	            V381 = NULL;
19598	            if (py_V381 == Py_None) {
19599	                // We can either fail here or set V381 to NULL and rely on Ops
19600	                // using tensors to handle the NULL case, but if they fail to do so
19601	                // they'll end up with nasty segfaults, so this is public service.
19602	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
19603	                {
19604	        __failure = 382;
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_382;}
19611	            }
19612	            if (!PyArray_Check(py_V381)) {
19613	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
19614	                {
19615	        __failure = 382;
19616	        if (!PyErr_Occurred()) {
19617	            PyErr_SetString(PyExc_RuntimeError,
19618	                "Unexpected error in an Op's C code. "
19619	                "No Python exception was set.");
19620	            }
19621	        goto __label_382;}
19622	            }
19623	            // We expect NPY_FLOAT64
19624	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V381)) {
19625	                PyArrayObject * tmp = (PyArrayObject*) py_V381;
19626	                PyErr_Format(PyExc_NotImplementedError,
19627	                             "expected an aligned array of type %ld "
19628	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
19629	                             " with %ld dimensions, with 3 last dims "
19630	                             "%ld, %ld, %ld"
19631	                             " and 3 last strides %ld %ld, %ld.",
19632	                             (long int) NPY_FLOAT64,
19633	                             (long int) PyArray_TYPE((PyArrayObject*) py_V381),
19634	                             (long int) PyArray_NDIM(tmp),
19635	                             (long int) PyArray_NDIM(tmp) >= 3 ?
19636	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
19637	                             (long int) PyArray_NDIM(tmp) >= 2 ?
19638	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
19639	                             (long int) PyArray_NDIM(tmp) >= 1 ?
19640	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
19641	                             (long int) PyArray_NDIM(tmp) >= 3 ?
19642	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
19643	                             (long int) PyArray_NDIM(tmp) >= 2 ?
19644	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
19645	                             (long int) PyArray_NDIM(tmp) >= 1 ?
19646	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
19647	            );
19648	                {
19649	        __failure = 382;
19650	        if (!PyErr_Occurred()) {
19651	            PyErr_SetString(PyExc_RuntimeError,
19652	                "Unexpected error in an Op's C code. "
19653	                "No Python exception was set.");
19654	            }
19655	        goto __label_382;}
19656	            }
19657	            // This is a TypeError to be consistent with DEBUG_MODE
19658	            // Note: DEBUG_MODE also tells the name of the container
19659	            if (PyArray_TYPE((PyArrayObject*) py_V381) != NPY_FLOAT64) {
19660	                PyErr_Format(PyExc_TypeError,
19661	                             "expected type_num %d (NPY_FLOAT64) got %d",
19662	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V381));
19663	                {
19664	        __failure = 382;
19665	        if (!PyErr_Occurred()) {
19666	            PyErr_SetString(PyExc_RuntimeError,
19667	                "Unexpected error in an Op's C code. "
19668	                "No Python exception was set.");
19669	            }
19670	        goto __label_382;}
19671	            }
19672
19673	        V381 = (PyArrayObject*)(py_V381);
19674	        Py_XINCREF(V381);
19675
19676	{
19677
19678	    py_V383 = PyList_GET_ITEM(storage_V383, 0);
19679	    {Py_XINCREF(py_V383);}
19680
19681	            V383 = NULL;
19682	            if (py_V383 == Py_None) {
19683	                // We can either fail here or set V383 to NULL and rely on Ops
19684	                // using tensors to handle the NULL case, but if they fail to do so
19685	                // they'll end up with nasty segfaults, so this is public service.
19686	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
19687	                {
19688	        __failure = 384;
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_384;}
19695	            }
19696	            if (!PyArray_Check(py_V383)) {
19697	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
19698	                {
19699	        __failure = 384;
19700	        if (!PyErr_Occurred()) {
19701	            PyErr_SetString(PyExc_RuntimeError,
19702	                "Unexpected error in an Op's C code. "
19703	                "No Python exception was set.");
19704	            }
19705	        goto __label_384;}
19706	            }
19707	            // We expect NPY_FLOAT64
19708	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V383)) {
19709	                PyArrayObject * tmp = (PyArrayObject*) py_V383;
19710	                PyErr_Format(PyExc_NotImplementedError,
19711	                             "expected an aligned array of type %ld "
19712	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
19713	                             " with %ld dimensions, with 3 last dims "
19714	                             "%ld, %ld, %ld"
19715	                             " and 3 last strides %ld %ld, %ld.",
19716	                             (long int) NPY_FLOAT64,
19717	                             (long int) PyArray_TYPE((PyArrayObject*) py_V383),
19718	                             (long int) PyArray_NDIM(tmp),
19719	                             (long int) PyArray_NDIM(tmp) >= 3 ?
19720	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
19721	                             (long int) PyArray_NDIM(tmp) >= 2 ?
19722	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
19723	                             (long int) PyArray_NDIM(tmp) >= 1 ?
19724	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
19725	                             (long int) PyArray_NDIM(tmp) >= 3 ?
19726	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
19727	                             (long int) PyArray_NDIM(tmp) >= 2 ?
19728	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
19729	                             (long int) PyArray_NDIM(tmp) >= 1 ?
19730	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
19731	            );
19732	                {
19733	        __failure = 384;
19734	        if (!PyErr_Occurred()) {
19735	            PyErr_SetString(PyExc_RuntimeError,
19736	                "Unexpected error in an Op's C code. "
19737	                "No Python exception was set.");
19738	            }
19739	        goto __label_384;}
19740	            }
19741	            // This is a TypeError to be consistent with DEBUG_MODE
19742	            // Note: DEBUG_MODE also tells the name of the container
19743	            if (PyArray_TYPE((PyArrayObject*) py_V383) != NPY_FLOAT64) {
19744	                PyErr_Format(PyExc_TypeError,
19745	                             "expected type_num %d (NPY_FLOAT64) got %d",
19746	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V383));
19747	                {
19748	        __failure = 384;
19749	        if (!PyErr_Occurred()) {
19750	            PyErr_SetString(PyExc_RuntimeError,
19751	                "Unexpected error in an Op's C code. "
19752	                "No Python exception was set.");
19753	            }
19754	        goto __label_384;}
19755	            }
19756
19757	        V383 = (PyArrayObject*)(py_V383);
19758	        Py_XINCREF(V383);
19759
19760	{
19761
19762	    py_V385 = PyList_GET_ITEM(storage_V385, 0);
19763	    {Py_XINCREF(py_V385);}
19764
19765	            V385 = NULL;
19766	            if (py_V385 == Py_None) {
19767	                // We can either fail here or set V385 to NULL and rely on Ops
19768	                // using tensors to handle the NULL case, but if they fail to do so
19769	                // they'll end up with nasty segfaults, so this is public service.
19770	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
19771	                {
19772	        __failure = 386;
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_386;}
19779	            }
19780	            if (!PyArray_Check(py_V385)) {
19781	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
19782	                {
19783	        __failure = 386;
19784	        if (!PyErr_Occurred()) {
19785	            PyErr_SetString(PyExc_RuntimeError,
19786	                "Unexpected error in an Op's C code. "
19787	                "No Python exception was set.");
19788	            }
19789	        goto __label_386;}
19790	            }
19791	            // We expect NPY_FLOAT64
19792	            if (!PyArray_ISALIGNED((PyArrayObject*) py_V385)) {
19793	                PyArrayObject * tmp = (PyArrayObject*) py_V385;
19794	                PyErr_Format(PyExc_NotImplementedError,
19795	                             "expected an aligned array of type %ld "
19796	                             "(NPY_FLOAT64), got non-aligned array of type %ld"
19797	                             " with %ld dimensions, with 3 last dims "
19798	                             "%ld, %ld, %ld"
19799	                             " and 3 last strides %ld %ld, %ld.",
19800	                             (long int) NPY_FLOAT64,
19801	                             (long int) PyArray_TYPE((PyArrayObject*) py_V385),
19802	                             (long int) PyArray_NDIM(tmp),
19803	                             (long int) PyArray_NDIM(tmp) >= 3 ?
19804	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1,
19805	                             (long int) PyArray_NDIM(tmp) >= 2 ?
19806	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1,
19807	                             (long int) PyArray_NDIM(tmp) >= 1 ?
19808	            PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1,
19809	                             (long int) PyArray_NDIM(tmp) >= 3 ?
19810	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1,
19811	                             (long int) PyArray_NDIM(tmp) >= 2 ?
19812	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1,
19813	                             (long int) PyArray_NDIM(tmp) >= 1 ?
19814	            PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1
19815	            );
19816	                {
19817	        __failure = 386;
19818	        if (!PyErr_Occurred()) {
19819	            PyErr_SetString(PyExc_RuntimeError,
19820	                "Unexpected error in an Op's C code. "
19821	                "No Python exception was set.");
19822	            }
19823	        goto __label_386;}
19824	            }
19825	            // This is a TypeError to be consistent with DEBUG_MODE
19826	            // Note: DEBUG_MODE also tells the name of the container
19827	            if (PyArray_TYPE((PyArrayObject*) py_V385) != NPY_FLOAT64) {
19828	                PyErr_Format(PyExc_TypeError,
19829	                             "expected type_num %d (NPY_FLOAT64) got %d",
19830	                             NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V385));
19831	                {
19832	        __failure = 386;
19833	        if (!PyErr_Occurred()) {
19834	            PyErr_SetString(PyExc_RuntimeError,
19835	                "Unexpected error in an Op's C code. "
19836	                "No Python exception was set.");
19837	            }
19838	        goto __label_386;}
19839	            }
19840
19841	        V385 = (PyArrayObject*)(py_V385);
19842	        Py_XINCREF(V385);
19843
19844	{
19845
19846	    py_V387 = PyList_GET_ITEM(storage_V387, 0);
19847	    {Py_XINCREF(py_V387);}
19848
19849	            V387 = NULL;
19850	            if (py_V387 == Py_None) {
19851	                // We can either fail here or set V387 to NULL and rely on Ops
19852	                // using tensors to handle the NULL case, but if they fail to do so
19853	                // they'll end up with nasty segfaults, so this is public service.
19854	                PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None");
19855	                {
19856	        __failure = 388;
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_388;}
19863	            }
19864	            if (!PyArray_Check(py_V387)) {
19865	                PyErr_SetString(PyExc_ValueError, "expected an ndarray");
19866	                {
19867	        __failure = 388;
19868	        if (!PyErr_Occurred()) {
19869	            PyErr_SetString(PyExc_RuntimeError,
19870	                "Unexpected error in an Op's C code. "
19871	                "No Python exception was set.");
19872	            }
19873	        goto __label_388;}
19874	            }
19875	            // We expect NPY_FLOAT64
19876	            if (!PyArray_ISALIGNED((PyArrayObject*)