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'}

Assign intervention categories to each arm

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',
       'BL_group_diff', 'Comments'],
      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.loc[str_mask, 'study_id'] = all_data.study_id[str_mask].apply(lambda x: x[:x.find('_')])
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_masked = masked_values(uae_data.followup_interval.values, -999)
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_masked = masked_values(intervention_data.followup_interval.values, -999)
    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), 
                                   observed=followup_masked)

        # 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*) py_V387)) {
19877	                PyArrayObject * tmp = (PyArrayObject*) py_V387;
19878	                PyErr_Format(PyExc_NotImplementedError,
19879	                             "expected an aligned array of type %ld "
19880	                             "(NPY_FLOA