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:
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:
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.
%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.
data_file = 'UF Subsequent Interventions Data_Master_updated.xlsx'
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
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.
# %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
datasets = [d.assign(intervention_cat=d.intervention.replace(intervention_lookup)) for d in datasets]
intervention_categories = set(intervention_lookup.values())
intervention_categories
{'DROP', 'MRgFUS', 'ablation', 'control', 'hysterectomy', 'med_manage', 'myomectomy', 'uae'}
Import demographic information
demographics = pd.read_excel('data/' + data_file, sheetname='ALL_DEMO_DATA', na_values=missing)
demographics.columns
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
age_data = demographics.loc[demographics.Demo_Category=='Age', ['study_id', 'New Grouping', 'BL Mean', 'BL SD']]
Clean arm labels
age_data = age_data.assign(arm=age_data['New Grouping'].str.replace(':','')).drop('New Grouping', axis=1)
age_data.arm.unique()
array(['G2', 'G1', 'G1b', 'G1a', 'G3', 'CG', 'G1c', 'G1+G2', 'G1a+G1b+G1c'], dtype=object)
Concatenate all datasets
all_data = pd.concat(datasets)
Clean up study arm field
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)
all_data.arm.unique()
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.
all_data.study_id.unique()
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)
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)
all_data.study_id.unique()
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.
all_data.head()
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 |
all_data.groupby('intervention_cat')['study_id'].count()
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
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):
all_data_merged = all_data_merged.dropna(subset=['followup_interval'])
Parse followup intervals that are ranges, creating fup_min
and fup_max
fields.
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)
dataset.head()
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
dataset.loc[dataset.followup_n.isnull(), 'followup_n'] = dataset.loc[dataset.followup_n.isnull(), 'baseline_n']
dataset.loc[dataset.no_treatment.isnull(), 'no_treatment'] = dataset.followup_n - dataset[[ 'hysterectomy', 'myomectomy', 'uae',
'MRIgFUS', 'ablation', 'iud']].sum(1)[dataset.no_treatment.isnull()]
dataset.followup_interval.unique()
array([ 12. , 6. , -999. , 24. , 2. , 1. , 3. , 5.5, 9. , 18. , 0. , 7. , 60. ])
crossover_studies = 7155, 3324, 414, 95, 7139, 6903, 3721, 3181, 4858, 4960, 4258, 4789, 2006, 2318
uae_data = dataset[dataset.intervention_cat=='uae']
uae_data.columns
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')
studies = uae_data.study_id.unique()
studies
array([ 347, 1400, 1529, 1806, 2967, 3382, 3785, 5186, 3674, 3803, 1546, 3365, 3819, 4789, 2006])
study_index = np.array([np.argwhere(studies==i).squeeze() for i in uae_data.study_id])
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
n_studies = len(set(study_id))
n_studies
15
n_outcomes = 7
arms = len(outcomes)
Instantiate models
ablation_model = pm.Model()
hysterectomy_model = pm.Model()
med_manage_model = pm.Model()
myomectomy_model = pm.Model()
uae_model = pm.Model()
models = [ablation_model, hysterectomy_model, med_manage_model, myomectomy_model, uae_model]
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
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.
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_FLOAT64), got non-aligned array of type %ld" 19881 " with %ld dimensions, with 3 last dims " 19882 "%ld, %ld, %ld" 19883 " and 3 last strides %ld %ld, %ld.", 19884 (long int) NPY_FLOAT64, 19885 (long int) PyArray_TYPE((PyArrayObject*) py_V387), 19886 (long int) PyArray_NDIM(tmp), 19887 (long int) PyArray_NDIM(tmp) >= 3 ? 19888 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 19889 (long int) PyArray_NDIM(tmp) >= 2 ? 19890 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 19891 (long int) PyArray_NDIM(tmp) >= 1 ? 19892 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 19893 (long int) PyArray_NDIM(tmp) >= 3 ? 19894 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 19895 (long int) PyArray_NDIM(tmp) >= 2 ? 19896 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 19897 (long int) PyArray_NDIM(tmp) >= 1 ? 19898 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 19899 ); 19900 { 19901 __failure = 388; 19902 if (!PyErr_Occurred()) { 19903 PyErr_SetString(PyExc_RuntimeError, 19904 "Unexpected error in an Op's C code. " 19905 "No Python exception was set."); 19906 } 19907 goto __label_388;} 19908 } 19909 // This is a TypeError to be consistent with DEBUG_MODE 19910 // Note: DEBUG_MODE also tells the name of the container 19911 if (PyArray_TYPE((PyArrayObject*) py_V387) != NPY_FLOAT64) { 19912 PyErr_Format(PyExc_TypeError, 19913 "expected type_num %d (NPY_FLOAT64) got %d", 19914 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V387)); 19915 { 19916 __failure = 388; 19917 if (!PyErr_Occurred()) { 19918 PyErr_SetString(PyExc_RuntimeError, 19919 "Unexpected error in an Op's C code. " 19920 "No Python exception was set."); 19921 } 19922 goto __label_388;} 19923 } 19924 19925 V387 = (PyArrayObject*)(py_V387); 19926 Py_XINCREF(V387); 19927 19928 { 19929 19930 py_V389 = PyList_GET_ITEM(storage_V389, 0); 19931 {Py_XINCREF(py_V389);} 19932 19933 V389 = NULL; 19934 if (py_V389 == Py_None) { 19935 // We can either fail here or set V389 to NULL and rely on Ops 19936 // using tensors to handle the NULL case, but if they fail to do so 19937 // they'll end up with nasty segfaults, so this is public service. 19938 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 19939 { 19940 __failure = 390; 19941 if (!PyErr_Occurred()) { 19942 PyErr_SetString(PyExc_RuntimeError, 19943 "Unexpected error in an Op's C code. " 19944 "No Python exception was set."); 19945 } 19946 goto __label_390;} 19947 } 19948 if (!PyArray_Check(py_V389)) { 19949 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 19950 { 19951 __failure = 390; 19952 if (!PyErr_Occurred()) { 19953 PyErr_SetString(PyExc_RuntimeError, 19954 "Unexpected error in an Op's C code. " 19955 "No Python exception was set."); 19956 } 19957 goto __label_390;} 19958 } 19959 // We expect NPY_FLOAT64 19960 if (!PyArray_ISALIGNED((PyArrayObject*) py_V389)) { 19961 PyArrayObject * tmp = (PyArrayObject*) py_V389; 19962 PyErr_Format(PyExc_NotImplementedError, 19963 "expected an aligned array of type %ld " 19964 "(NPY_FLOAT64), got non-aligned array of type %ld" 19965 " with %ld dimensions, with 3 last dims " 19966 "%ld, %ld, %ld" 19967 " and 3 last strides %ld %ld, %ld.", 19968 (long int) NPY_FLOAT64, 19969 (long int) PyArray_TYPE((PyArrayObject*) py_V389), 19970 (long int) PyArray_NDIM(tmp), 19971 (long int) PyArray_NDIM(tmp) >= 3 ? 19972 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 19973 (long int) PyArray_NDIM(tmp) >= 2 ? 19974 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 19975 (long int) PyArray_NDIM(tmp) >= 1 ? 19976 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 19977 (long int) PyArray_NDIM(tmp) >= 3 ? 19978 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 19979 (long int) PyArray_NDIM(tmp) >= 2 ? 19980 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 19981 (long int) PyArray_NDIM(tmp) >= 1 ? 19982 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 19983 ); 19984 { 19985 __failure = 390; 19986 if (!PyErr_Occurred()) { 19987 PyErr_SetString(PyExc_RuntimeError, 19988 "Unexpected error in an Op's C code. " 19989 "No Python exception was set."); 19990 } 19991 goto __label_390;} 19992 } 19993 // This is a TypeError to be consistent with DEBUG_MODE 19994 // Note: DEBUG_MODE also tells the name of the container 19995 if (PyArray_TYPE((PyArrayObject*) py_V389) != NPY_FLOAT64) { 19996 PyErr_Format(PyExc_TypeError, 19997 "expected type_num %d (NPY_FLOAT64) got %d", 19998 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V389)); 19999 { 20000 __failure = 390; 20001 if (!PyErr_Occurred()) { 20002 PyErr_SetString(PyExc_RuntimeError, 20003 "Unexpected error in an Op's C code. " 20004 "No Python exception was set."); 20005 } 20006 goto __label_390;} 20007 } 20008 20009 V389 = (PyArrayObject*)(py_V389); 20010 Py_XINCREF(V389); 20011 20012 { 20013 20014 py_V391 = PyList_GET_ITEM(storage_V391, 0); 20015 {Py_XINCREF(py_V391);} 20016 20017 V391 = NULL; 20018 if (py_V391 == Py_None) { 20019 // We can either fail here or set V391 to NULL and rely on Ops 20020 // using tensors to handle the NULL case, but if they fail to do so 20021 // they'll end up with nasty segfaults, so this is public service. 20022 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 20023 { 20024 __failure = 392; 20025 if (!PyErr_Occurred()) { 20026 PyErr_SetString(PyExc_RuntimeError, 20027 "Unexpected error in an Op's C code. " 20028 "No Python exception was set."); 20029 } 20030 goto __label_392;} 20031 } 20032 if (!PyArray_Check(py_V391)) { 20033 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 20034 { 20035 __failure = 392; 20036 if (!PyErr_Occurred()) { 20037 PyErr_SetString(PyExc_RuntimeError, 20038 "Unexpected error in an Op's C code. " 20039 "No Python exception was set."); 20040 } 20041 goto __label_392;} 20042 } 20043 // We expect NPY_FLOAT64 20044 if (!PyArray_ISALIGNED((PyArrayObject*) py_V391)) { 20045 PyArrayObject * tmp = (PyArrayObject*) py_V391; 20046 PyErr_Format(PyExc_NotImplementedError, 20047 "expected an aligned array of type %ld " 20048 "(NPY_FLOAT64), got non-aligned array of type %ld" 20049 " with %ld dimensions, with 3 last dims " 20050 "%ld, %ld, %ld" 20051 " and 3 last strides %ld %ld, %ld.", 20052 (long int) NPY_FLOAT64, 20053 (long int) PyArray_TYPE((PyArrayObject*) py_V391), 20054 (long int) PyArray_NDIM(tmp), 20055 (long int) PyArray_NDIM(tmp) >= 3 ? 20056 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 20057 (long int) PyArray_NDIM(tmp) >= 2 ? 20058 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 20059 (long int) PyArray_NDIM(tmp) >= 1 ? 20060 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 20061 (long int) PyArray_NDIM(tmp) >= 3 ? 20062 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 20063 (long int) PyArray_NDIM(tmp) >= 2 ? 20064 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 20065 (long int) PyArray_NDIM(tmp) >= 1 ? 20066 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 20067 ); 20068 { 20069 __failure = 392; 20070 if (!PyErr_Occurred()) { 20071 PyErr_SetString(PyExc_RuntimeError, 20072 "Unexpected error in an Op's C code. " 20073 "No Python exception was set."); 20074 } 20075 goto __label_392;} 20076 } 20077 // This is a TypeError to be consistent with DEBUG_MODE 20078 // Note: DEBUG_MODE also tells the name of the container 20079 if (PyArray_TYPE((PyArrayObject*) py_V391) != NPY_FLOAT64) { 20080 PyErr_Format(PyExc_TypeError, 20081 "expected type_num %d (NPY_FLOAT64) got %d", 20082 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V391)); 20083 { 20084 __failure = 392; 20085 if (!PyErr_Occurred()) { 20086 PyErr_SetString(PyExc_RuntimeError, 20087 "Unexpected error in an Op's C code. " 20088 "No Python exception was set."); 20089 } 20090 goto __label_392;} 20091 } 20092 20093 V391 = (PyArrayObject*)(py_V391); 20094 Py_XINCREF(V391); 20095 20096 { 20097 20098 py_V393 = PyList_GET_ITEM(storage_V393, 0); 20099 {Py_XINCREF(py_V393);} 20100 20101 V393 = NULL; 20102 if (py_V393 == Py_None) { 20103 // We can either fail here or set V393 to NULL and rely on Ops 20104 // using tensors to handle the NULL case, but if they fail to do so 20105 // they'll end up with nasty segfaults, so this is public service. 20106 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 20107 { 20108 __failure = 394; 20109 if (!PyErr_Occurred()) { 20110 PyErr_SetString(PyExc_RuntimeError, 20111 "Unexpected error in an Op's C code. " 20112 "No Python exception was set."); 20113 } 20114 goto __label_394;} 20115 } 20116 if (!PyArray_Check(py_V393)) { 20117 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 20118 { 20119 __failure = 394; 20120 if (!PyErr_Occurred()) { 20121 PyErr_SetString(PyExc_RuntimeError, 20122 "Unexpected error in an Op's C code. " 20123 "No Python exception was set."); 20124 } 20125 goto __label_394;} 20126 } 20127 // We expect NPY_INT8 20128 if (!PyArray_ISALIGNED((PyArrayObject*) py_V393)) { 20129 PyArrayObject * tmp = (PyArrayObject*) py_V393; 20130 PyErr_Format(PyExc_NotImplementedError, 20131 "expected an aligned array of type %ld " 20132 "(NPY_INT8), got non-aligned array of type %ld" 20133 " with %ld dimensions, with 3 last dims " 20134 "%ld, %ld, %ld" 20135 " and 3 last strides %ld %ld, %ld.", 20136 (long int) NPY_INT8, 20137 (long int) PyArray_TYPE((PyArrayObject*) py_V393), 20138 (long int) PyArray_NDIM(tmp), 20139 (long int) PyArray_NDIM(tmp) >= 3 ? 20140 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 20141 (long int) PyArray_NDIM(tmp) >= 2 ? 20142 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 20143 (long int) PyArray_NDIM(tmp) >= 1 ? 20144 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 20145 (long int) PyArray_NDIM(tmp) >= 3 ? 20146 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 20147 (long int) PyArray_NDIM(tmp) >= 2 ? 20148 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 20149 (long int) PyArray_NDIM(tmp) >= 1 ? 20150 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 20151 ); 20152 { 20153 __failure = 394; 20154 if (!PyErr_Occurred()) { 20155 PyErr_SetString(PyExc_RuntimeError, 20156 "Unexpected error in an Op's C code. " 20157 "No Python exception was set."); 20158 } 20159 goto __label_394;} 20160 } 20161 // This is a TypeError to be consistent with DEBUG_MODE 20162 // Note: DEBUG_MODE also tells the name of the container 20163 if (PyArray_TYPE((PyArrayObject*) py_V393) != NPY_INT8) { 20164 PyErr_Format(PyExc_TypeError, 20165 "expected type_num %d (NPY_INT8) got %d", 20166 NPY_INT8, PyArray_TYPE((PyArrayObject*) py_V393)); 20167 { 20168 __failure = 394; 20169 if (!PyErr_Occurred()) { 20170 PyErr_SetString(PyExc_RuntimeError, 20171 "Unexpected error in an Op's C code. " 20172 "No Python exception was set."); 20173 } 20174 goto __label_394;} 20175 } 20176 20177 V393 = (PyArrayObject*)(py_V393); 20178 Py_XINCREF(V393); 20179 20180 { 20181 20182 py_V395 = PyList_GET_ITEM(storage_V395, 0); 20183 {Py_XINCREF(py_V395);} 20184 20185 V395 = NULL; 20186 if (py_V395 == Py_None) { 20187 // We can either fail here or set V395 to NULL and rely on Ops 20188 // using tensors to handle the NULL case, but if they fail to do so 20189 // they'll end up with nasty segfaults, so this is public service. 20190 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 20191 { 20192 __failure = 396; 20193 if (!PyErr_Occurred()) { 20194 PyErr_SetString(PyExc_RuntimeError, 20195 "Unexpected error in an Op's C code. " 20196 "No Python exception was set."); 20197 } 20198 goto __label_396;} 20199 } 20200 if (!PyArray_Check(py_V395)) { 20201 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 20202 { 20203 __failure = 396; 20204 if (!PyErr_Occurred()) { 20205 PyErr_SetString(PyExc_RuntimeError, 20206 "Unexpected error in an Op's C code. " 20207 "No Python exception was set."); 20208 } 20209 goto __label_396;} 20210 } 20211 // We expect NPY_FLOAT64 20212 if (!PyArray_ISALIGNED((PyArrayObject*) py_V395)) { 20213 PyArrayObject * tmp = (PyArrayObject*) py_V395; 20214 PyErr_Format(PyExc_NotImplementedError, 20215 "expected an aligned array of type %ld " 20216 "(NPY_FLOAT64), got non-aligned array of type %ld" 20217 " with %ld dimensions, with 3 last dims " 20218 "%ld, %ld, %ld" 20219 " and 3 last strides %ld %ld, %ld.", 20220 (long int) NPY_FLOAT64, 20221 (long int) PyArray_TYPE((PyArrayObject*) py_V395), 20222 (long int) PyArray_NDIM(tmp), 20223 (long int) PyArray_NDIM(tmp) >= 3 ? 20224 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 20225 (long int) PyArray_NDIM(tmp) >= 2 ? 20226 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 20227 (long int) PyArray_NDIM(tmp) >= 1 ? 20228 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 20229 (long int) PyArray_NDIM(tmp) >= 3 ? 20230 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 20231 (long int) PyArray_NDIM(tmp) >= 2 ? 20232 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 20233 (long int) PyArray_NDIM(tmp) >= 1 ? 20234 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 20235 ); 20236 { 20237 __failure = 396; 20238 if (!PyErr_Occurred()) { 20239 PyErr_SetString(PyExc_RuntimeError, 20240 "Unexpected error in an Op's C code. " 20241 "No Python exception was set."); 20242 } 20243 goto __label_396;} 20244 } 20245 // This is a TypeError to be consistent with DEBUG_MODE 20246 // Note: DEBUG_MODE also tells the name of the container 20247 if (PyArray_TYPE((PyArrayObject*) py_V395) != NPY_FLOAT64) { 20248 PyErr_Format(PyExc_TypeError, 20249 "expected type_num %d (NPY_FLOAT64) got %d", 20250 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V395)); 20251 { 20252 __failure = 396; 20253 if (!PyErr_Occurred()) { 20254 PyErr_SetString(PyExc_RuntimeError, 20255 "Unexpected error in an Op's C code. " 20256 "No Python exception was set."); 20257 } 20258 goto __label_396;} 20259 } 20260 20261 V395 = (PyArrayObject*)(py_V395); 20262 Py_XINCREF(V395); 20263 20264 { 20265 20266 py_V397 = PyList_GET_ITEM(storage_V397, 0); 20267 {Py_XINCREF(py_V397);} 20268 20269 V397 = NULL; 20270 if (py_V397 == Py_None) { 20271 // We can either fail here or set V397 to NULL and rely on Ops 20272 // using tensors to handle the NULL case, but if they fail to do so 20273 // they'll end up with nasty segfaults, so this is public service. 20274 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 20275 { 20276 __failure = 398; 20277 if (!PyErr_Occurred()) { 20278 PyErr_SetString(PyExc_RuntimeError, 20279 "Unexpected error in an Op's C code. " 20280 "No Python exception was set."); 20281 } 20282 goto __label_398;} 20283 } 20284 if (!PyArray_Check(py_V397)) { 20285 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 20286 { 20287 __failure = 398; 20288 if (!PyErr_Occurred()) { 20289 PyErr_SetString(PyExc_RuntimeError, 20290 "Unexpected error in an Op's C code. " 20291 "No Python exception was set."); 20292 } 20293 goto __label_398;} 20294 } 20295 // We expect NPY_FLOAT64 20296 if (!PyArray_ISALIGNED((PyArrayObject*) py_V397)) { 20297 PyArrayObject * tmp = (PyArrayObject*) py_V397; 20298 PyErr_Format(PyExc_NotImplementedError, 20299 "expected an aligned array of type %ld " 20300 "(NPY_FLOAT64), got non-aligned array of type %ld" 20301 " with %ld dimensions, with 3 last dims " 20302 "%ld, %ld, %ld" 20303 " and 3 last strides %ld %ld, %ld.", 20304 (long int) NPY_FLOAT64, 20305 (long int) PyArray_TYPE((PyArrayObject*) py_V397), 20306 (long int) PyArray_NDIM(tmp), 20307 (long int) PyArray_NDIM(tmp) >= 3 ? 20308 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 20309 (long int) PyArray_NDIM(tmp) >= 2 ? 20310 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 20311 (long int) PyArray_NDIM(tmp) >= 1 ? 20312 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 20313 (long int) PyArray_NDIM(tmp) >= 3 ? 20314 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 20315 (long int) PyArray_NDIM(tmp) >= 2 ? 20316 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 20317 (long int) PyArray_NDIM(tmp) >= 1 ? 20318 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 20319 ); 20320 { 20321 __failure = 398; 20322 if (!PyErr_Occurred()) { 20323 PyErr_SetString(PyExc_RuntimeError, 20324 "Unexpected error in an Op's C code. " 20325 "No Python exception was set."); 20326 } 20327 goto __label_398;} 20328 } 20329 // This is a TypeError to be consistent with DEBUG_MODE 20330 // Note: DEBUG_MODE also tells the name of the container 20331 if (PyArray_TYPE((PyArrayObject*) py_V397) != NPY_FLOAT64) { 20332 PyErr_Format(PyExc_TypeError, 20333 "expected type_num %d (NPY_FLOAT64) got %d", 20334 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V397)); 20335 { 20336 __failure = 398; 20337 if (!PyErr_Occurred()) { 20338 PyErr_SetString(PyExc_RuntimeError, 20339 "Unexpected error in an Op's C code. " 20340 "No Python exception was set."); 20341 } 20342 goto __label_398;} 20343 } 20344 20345 V397 = (PyArrayObject*)(py_V397); 20346 Py_XINCREF(V397); 20347 20348 { 20349 20350 py_V399 = PyList_GET_ITEM(storage_V399, 0); 20351 {Py_XINCREF(py_V399);} 20352 20353 V399 = NULL; 20354 if (py_V399 == Py_None) { 20355 // We can either fail here or set V399 to NULL and rely on Ops 20356 // using tensors to handle the NULL case, but if they fail to do so 20357 // they'll end up with nasty segfaults, so this is public service. 20358 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 20359 { 20360 __failure = 400; 20361 if (!PyErr_Occurred()) { 20362 PyErr_SetString(PyExc_RuntimeError, 20363 "Unexpected error in an Op's C code. " 20364 "No Python exception was set."); 20365 } 20366 goto __label_400;} 20367 } 20368 if (!PyArray_Check(py_V399)) { 20369 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 20370 { 20371 __failure = 400; 20372 if (!PyErr_Occurred()) { 20373 PyErr_SetString(PyExc_RuntimeError, 20374 "Unexpected error in an Op's C code. " 20375 "No Python exception was set."); 20376 } 20377 goto __label_400;} 20378 } 20379 // We expect NPY_FLOAT64 20380 if (!PyArray_ISALIGNED((PyArrayObject*) py_V399)) { 20381 PyArrayObject * tmp = (PyArrayObject*) py_V399; 20382 PyErr_Format(PyExc_NotImplementedError, 20383 "expected an aligned array of type %ld " 20384 "(NPY_FLOAT64), got non-aligned array of type %ld" 20385 " with %ld dimensions, with 3 last dims " 20386 "%ld, %ld, %ld" 20387 " and 3 last strides %ld %ld, %ld.", 20388 (long int) NPY_FLOAT64, 20389 (long int) PyArray_TYPE((PyArrayObject*) py_V399), 20390 (long int) PyArray_NDIM(tmp), 20391 (long int) PyArray_NDIM(tmp) >= 3 ? 20392 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 20393 (long int) PyArray_NDIM(tmp) >= 2 ? 20394 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 20395 (long int) PyArray_NDIM(tmp) >= 1 ? 20396 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 20397 (long int) PyArray_NDIM(tmp) >= 3 ? 20398 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 20399 (long int) PyArray_NDIM(tmp) >= 2 ? 20400 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 20401 (long int) PyArray_NDIM(tmp) >= 1 ? 20402 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 20403 ); 20404 { 20405 __failure = 400; 20406 if (!PyErr_Occurred()) { 20407 PyErr_SetString(PyExc_RuntimeError, 20408 "Unexpected error in an Op's C code. " 20409 "No Python exception was set."); 20410 } 20411 goto __label_400;} 20412 } 20413 // This is a TypeError to be consistent with DEBUG_MODE 20414 // Note: DEBUG_MODE also tells the name of the container 20415 if (PyArray_TYPE((PyArrayObject*) py_V399) != NPY_FLOAT64) { 20416 PyErr_Format(PyExc_TypeError, 20417 "expected type_num %d (NPY_FLOAT64) got %d", 20418 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V399)); 20419 { 20420 __failure = 400; 20421 if (!PyErr_Occurred()) { 20422 PyErr_SetString(PyExc_RuntimeError, 20423 "Unexpected error in an Op's C code. " 20424 "No Python exception was set."); 20425 } 20426 goto __label_400;} 20427 } 20428 20429 V399 = (PyArrayObject*)(py_V399); 20430 Py_XINCREF(V399); 20431 20432 { 20433 20434 py_V401 = PyList_GET_ITEM(storage_V401, 0); 20435 {Py_XINCREF(py_V401);} 20436 20437 V401 = NULL; 20438 if (py_V401 == Py_None) { 20439 // We can either fail here or set V401 to NULL and rely on Ops 20440 // using tensors to handle the NULL case, but if they fail to do so 20441 // they'll end up with nasty segfaults, so this is public service. 20442 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 20443 { 20444 __failure = 402; 20445 if (!PyErr_Occurred()) { 20446 PyErr_SetString(PyExc_RuntimeError, 20447 "Unexpected error in an Op's C code. " 20448 "No Python exception was set."); 20449 } 20450 goto __label_402;} 20451 } 20452 if (!PyArray_Check(py_V401)) { 20453 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 20454 { 20455 __failure = 402; 20456 if (!PyErr_Occurred()) { 20457 PyErr_SetString(PyExc_RuntimeError, 20458 "Unexpected error in an Op's C code. " 20459 "No Python exception was set."); 20460 } 20461 goto __label_402;} 20462 } 20463 // We expect NPY_FLOAT64 20464 if (!PyArray_ISALIGNED((PyArrayObject*) py_V401)) { 20465 PyArrayObject * tmp = (PyArrayObject*) py_V401; 20466 PyErr_Format(PyExc_NotImplementedError, 20467 "expected an aligned array of type %ld " 20468 "(NPY_FLOAT64), got non-aligned array of type %ld" 20469 " with %ld dimensions, with 3 last dims " 20470 "%ld, %ld, %ld" 20471 " and 3 last strides %ld %ld, %ld.", 20472 (long int) NPY_FLOAT64, 20473 (long int) PyArray_TYPE((PyArrayObject*) py_V401), 20474 (long int) PyArray_NDIM(tmp), 20475 (long int) PyArray_NDIM(tmp) >= 3 ? 20476 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 20477 (long int) PyArray_NDIM(tmp) >= 2 ? 20478 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 20479 (long int) PyArray_NDIM(tmp) >= 1 ? 20480 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 20481 (long int) PyArray_NDIM(tmp) >= 3 ? 20482 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 20483 (long int) PyArray_NDIM(tmp) >= 2 ? 20484 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 20485 (long int) PyArray_NDIM(tmp) >= 1 ? 20486 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 20487 ); 20488 { 20489 __failure = 402; 20490 if (!PyErr_Occurred()) { 20491 PyErr_SetString(PyExc_RuntimeError, 20492 "Unexpected error in an Op's C code. " 20493 "No Python exception was set."); 20494 } 20495 goto __label_402;} 20496 } 20497 // This is a TypeError to be consistent with DEBUG_MODE 20498 // Note: DEBUG_MODE also tells the name of the container 20499 if (PyArray_TYPE((PyArrayObject*) py_V401) != NPY_FLOAT64) { 20500 PyErr_Format(PyExc_TypeError, 20501 "expected type_num %d (NPY_FLOAT64) got %d", 20502 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V401)); 20503 { 20504 __failure = 402; 20505 if (!PyErr_Occurred()) { 20506 PyErr_SetString(PyExc_RuntimeError, 20507 "Unexpected error in an Op's C code. " 20508 "No Python exception was set."); 20509 } 20510 goto __label_402;} 20511 } 20512 20513 V401 = (PyArrayObject*)(py_V401); 20514 Py_XINCREF(V401); 20515 20516 { 20517 20518 py_V403 = PyList_GET_ITEM(storage_V403, 0); 20519 {Py_XINCREF(py_V403);} 20520 20521 V403 = NULL; 20522 if (py_V403 == Py_None) { 20523 // We can either fail here or set V403 to NULL and rely on Ops 20524 // using tensors to handle the NULL case, but if they fail to do so 20525 // they'll end up with nasty segfaults, so this is public service. 20526 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 20527 { 20528 __failure = 404; 20529 if (!PyErr_Occurred()) { 20530 PyErr_SetString(PyExc_RuntimeError, 20531 "Unexpected error in an Op's C code. " 20532 "No Python exception was set."); 20533 } 20534 goto __label_404;} 20535 } 20536 if (!PyArray_Check(py_V403)) { 20537 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 20538 { 20539 __failure = 404; 20540 if (!PyErr_Occurred()) { 20541 PyErr_SetString(PyExc_RuntimeError, 20542 "Unexpected error in an Op's C code. " 20543 "No Python exception was set."); 20544 } 20545 goto __label_404;} 20546 } 20547 // We expect NPY_FLOAT64 20548 if (!PyArray_ISALIGNED((PyArrayObject*) py_V403)) { 20549 PyArrayObject * tmp = (PyArrayObject*) py_V403; 20550 PyErr_Format(PyExc_NotImplementedError, 20551 "expected an aligned array of type %ld " 20552 "(NPY_FLOAT64), got non-aligned array of type %ld" 20553 " with %ld dimensions, with 3 last dims " 20554 "%ld, %ld, %ld" 20555 " and 3 last strides %ld %ld, %ld.", 20556 (long int) NPY_FLOAT64, 20557 (long int) PyArray_TYPE((PyArrayObject*) py_V403), 20558 (long int) PyArray_NDIM(tmp), 20559 (long int) PyArray_NDIM(tmp) >= 3 ? 20560 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 20561 (long int) PyArray_NDIM(tmp) >= 2 ? 20562 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 20563 (long int) PyArray_NDIM(tmp) >= 1 ? 20564 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 20565 (long int) PyArray_NDIM(tmp) >= 3 ? 20566 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 20567 (long int) PyArray_NDIM(tmp) >= 2 ? 20568 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 20569 (long int) PyArray_NDIM(tmp) >= 1 ? 20570 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 20571 ); 20572 { 20573 __failure = 404; 20574 if (!PyErr_Occurred()) { 20575 PyErr_SetString(PyExc_RuntimeError, 20576 "Unexpected error in an Op's C code. " 20577 "No Python exception was set."); 20578 } 20579 goto __label_404;} 20580 } 20581 // This is a TypeError to be consistent with DEBUG_MODE 20582 // Note: DEBUG_MODE also tells the name of the container 20583 if (PyArray_TYPE((PyArrayObject*) py_V403) != NPY_FLOAT64) { 20584 PyErr_Format(PyExc_TypeError, 20585 "expected type_num %d (NPY_FLOAT64) got %d", 20586 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V403)); 20587 { 20588 __failure = 404; 20589 if (!PyErr_Occurred()) { 20590 PyErr_SetString(PyExc_RuntimeError, 20591 "Unexpected error in an Op's C code. " 20592 "No Python exception was set."); 20593 } 20594 goto __label_404;} 20595 } 20596 20597 V403 = (PyArrayObject*)(py_V403); 20598 Py_XINCREF(V403); 20599 20600 { 20601 20602 py_V405 = PyList_GET_ITEM(storage_V405, 0); 20603 {Py_XINCREF(py_V405);} 20604 20605 V405 = NULL; 20606 if (py_V405 == Py_None) { 20607 // We can either fail here or set V405 to NULL and rely on Ops 20608 // using tensors to handle the NULL case, but if they fail to do so 20609 // they'll end up with nasty segfaults, so this is public service. 20610 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 20611 { 20612 __failure = 406; 20613 if (!PyErr_Occurred()) { 20614 PyErr_SetString(PyExc_RuntimeError, 20615 "Unexpected error in an Op's C code. " 20616 "No Python exception was set."); 20617 } 20618 goto __label_406;} 20619 } 20620 if (!PyArray_Check(py_V405)) { 20621 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 20622 { 20623 __failure = 406; 20624 if (!PyErr_Occurred()) { 20625 PyErr_SetString(PyExc_RuntimeError, 20626 "Unexpected error in an Op's C code. " 20627 "No Python exception was set."); 20628 } 20629 goto __label_406;} 20630 } 20631 // We expect NPY_FLOAT64 20632 if (!PyArray_ISALIGNED((PyArrayObject*) py_V405)) { 20633 PyArrayObject * tmp = (PyArrayObject*) py_V405; 20634 PyErr_Format(PyExc_NotImplementedError, 20635 "expected an aligned array of type %ld " 20636 "(NPY_FLOAT64), got non-aligned array of type %ld" 20637 " with %ld dimensions, with 3 last dims " 20638 "%ld, %ld, %ld" 20639 " and 3 last strides %ld %ld, %ld.", 20640 (long int) NPY_FLOAT64, 20641 (long int) PyArray_TYPE((PyArrayObject*) py_V405), 20642 (long int) PyArray_NDIM(tmp), 20643 (long int) PyArray_NDIM(tmp) >= 3 ? 20644 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 20645 (long int) PyArray_NDIM(tmp) >= 2 ? 20646 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 20647 (long int) PyArray_NDIM(tmp) >= 1 ? 20648 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 20649 (long int) PyArray_NDIM(tmp) >= 3 ? 20650 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 20651 (long int) PyArray_NDIM(tmp) >= 2 ? 20652 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 20653 (long int) PyArray_NDIM(tmp) >= 1 ? 20654 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 20655 ); 20656 { 20657 __failure = 406; 20658 if (!PyErr_Occurred()) { 20659 PyErr_SetString(PyExc_RuntimeError, 20660 "Unexpected error in an Op's C code. " 20661 "No Python exception was set."); 20662 } 20663 goto __label_406;} 20664 } 20665 // This is a TypeError to be consistent with DEBUG_MODE 20666 // Note: DEBUG_MODE also tells the name of the container 20667 if (PyArray_TYPE((PyArrayObject*) py_V405) != NPY_FLOAT64) { 20668 PyErr_Format(PyExc_TypeError, 20669 "expected type_num %d (NPY_FLOAT64) got %d", 20670 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V405)); 20671 { 20672 __failure = 406; 20673 if (!PyErr_Occurred()) { 20674 PyErr_SetString(PyExc_RuntimeError, 20675 "Unexpected error in an Op's C code. " 20676 "No Python exception was set."); 20677 } 20678 goto __label_406;} 20679 } 20680 20681 V405 = (PyArrayObject*)(py_V405); 20682 Py_XINCREF(V405); 20683 20684 { 20685 20686 py_V407 = PyList_GET_ITEM(storage_V407, 0); 20687 {Py_XINCREF(py_V407);} 20688 20689 V407 = NULL; 20690 if (py_V407 == Py_None) { 20691 // We can either fail here or set V407 to NULL and rely on Ops 20692 // using tensors to handle the NULL case, but if they fail to do so 20693 // they'll end up with nasty segfaults, so this is public service. 20694 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 20695 { 20696 __failure = 408; 20697 if (!PyErr_Occurred()) { 20698 PyErr_SetString(PyExc_RuntimeError, 20699 "Unexpected error in an Op's C code. " 20700 "No Python exception was set."); 20701 } 20702 goto __label_408;} 20703 } 20704 if (!PyArray_Check(py_V407)) { 20705 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 20706 { 20707 __failure = 408; 20708 if (!PyErr_Occurred()) { 20709 PyErr_SetString(PyExc_RuntimeError, 20710 "Unexpected error in an Op's C code. " 20711 "No Python exception was set."); 20712 } 20713 goto __label_408;} 20714 } 20715 // We expect NPY_INT8 20716 if (!PyArray_ISALIGNED((PyArrayObject*) py_V407)) { 20717 PyArrayObject * tmp = (PyArrayObject*) py_V407; 20718 PyErr_Format(PyExc_NotImplementedError, 20719 "expected an aligned array of type %ld " 20720 "(NPY_INT8), got non-aligned array of type %ld" 20721 " with %ld dimensions, with 3 last dims " 20722 "%ld, %ld, %ld" 20723 " and 3 last strides %ld %ld, %ld.", 20724 (long int) NPY_INT8, 20725 (long int) PyArray_TYPE((PyArrayObject*) py_V407), 20726 (long int) PyArray_NDIM(tmp), 20727 (long int) PyArray_NDIM(tmp) >= 3 ? 20728 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 20729 (long int) PyArray_NDIM(tmp) >= 2 ? 20730 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 20731 (long int) PyArray_NDIM(tmp) >= 1 ? 20732 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 20733 (long int) PyArray_NDIM(tmp) >= 3 ? 20734 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 20735 (long int) PyArray_NDIM(tmp) >= 2 ? 20736 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 20737 (long int) PyArray_NDIM(tmp) >= 1 ? 20738 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 20739 ); 20740 { 20741 __failure = 408; 20742 if (!PyErr_Occurred()) { 20743 PyErr_SetString(PyExc_RuntimeError, 20744 "Unexpected error in an Op's C code. " 20745 "No Python exception was set."); 20746 } 20747 goto __label_408;} 20748 } 20749 // This is a TypeError to be consistent with DEBUG_MODE 20750 // Note: DEBUG_MODE also tells the name of the container 20751 if (PyArray_TYPE((PyArrayObject*) py_V407) != NPY_INT8) { 20752 PyErr_Format(PyExc_TypeError, 20753 "expected type_num %d (NPY_INT8) got %d", 20754 NPY_INT8, PyArray_TYPE((PyArrayObject*) py_V407)); 20755 { 20756 __failure = 408; 20757 if (!PyErr_Occurred()) { 20758 PyErr_SetString(PyExc_RuntimeError, 20759 "Unexpected error in an Op's C code. " 20760 "No Python exception was set."); 20761 } 20762 goto __label_408;} 20763 } 20764 20765 V407 = (PyArrayObject*)(py_V407); 20766 Py_XINCREF(V407); 20767 20768 { 20769 20770 py_V409 = PyList_GET_ITEM(storage_V409, 0); 20771 {Py_XINCREF(py_V409);} 20772 20773 V409 = NULL; 20774 if (py_V409 == Py_None) { 20775 // We can either fail here or set V409 to NULL and rely on Ops 20776 // using tensors to handle the NULL case, but if they fail to do so 20777 // they'll end up with nasty segfaults, so this is public service. 20778 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 20779 { 20780 __failure = 410; 20781 if (!PyErr_Occurred()) { 20782 PyErr_SetString(PyExc_RuntimeError, 20783 "Unexpected error in an Op's C code. " 20784 "No Python exception was set."); 20785 } 20786 goto __label_410;} 20787 } 20788 if (!PyArray_Check(py_V409)) { 20789 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 20790 { 20791 __failure = 410; 20792 if (!PyErr_Occurred()) { 20793 PyErr_SetString(PyExc_RuntimeError, 20794 "Unexpected error in an Op's C code. " 20795 "No Python exception was set."); 20796 } 20797 goto __label_410;} 20798 } 20799 // We expect NPY_FLOAT64 20800 if (!PyArray_ISALIGNED((PyArrayObject*) py_V409)) { 20801 PyArrayObject * tmp = (PyArrayObject*) py_V409; 20802 PyErr_Format(PyExc_NotImplementedError, 20803 "expected an aligned array of type %ld " 20804 "(NPY_FLOAT64), got non-aligned array of type %ld" 20805 " with %ld dimensions, with 3 last dims " 20806 "%ld, %ld, %ld" 20807 " and 3 last strides %ld %ld, %ld.", 20808 (long int) NPY_FLOAT64, 20809 (long int) PyArray_TYPE((PyArrayObject*) py_V409), 20810 (long int) PyArray_NDIM(tmp), 20811 (long int) PyArray_NDIM(tmp) >= 3 ? 20812 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 20813 (long int) PyArray_NDIM(tmp) >= 2 ? 20814 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 20815 (long int) PyArray_NDIM(tmp) >= 1 ? 20816 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 20817 (long int) PyArray_NDIM(tmp) >= 3 ? 20818 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 20819 (long int) PyArray_NDIM(tmp) >= 2 ? 20820 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 20821 (long int) PyArray_NDIM(tmp) >= 1 ? 20822 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 20823 ); 20824 { 20825 __failure = 410; 20826 if (!PyErr_Occurred()) { 20827 PyErr_SetString(PyExc_RuntimeError, 20828 "Unexpected error in an Op's C code. " 20829 "No Python exception was set."); 20830 } 20831 goto __label_410;} 20832 } 20833 // This is a TypeError to be consistent with DEBUG_MODE 20834 // Note: DEBUG_MODE also tells the name of the container 20835 if (PyArray_TYPE((PyArrayObject*) py_V409) != NPY_FLOAT64) { 20836 PyErr_Format(PyExc_TypeError, 20837 "expected type_num %d (NPY_FLOAT64) got %d", 20838 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V409)); 20839 { 20840 __failure = 410; 20841 if (!PyErr_Occurred()) { 20842 PyErr_SetString(PyExc_RuntimeError, 20843 "Unexpected error in an Op's C code. " 20844 "No Python exception was set."); 20845 } 20846 goto __label_410;} 20847 } 20848 20849 V409 = (PyArrayObject*)(py_V409); 20850 Py_XINCREF(V409); 20851 20852 { 20853 20854 py_V411 = PyList_GET_ITEM(storage_V411, 0); 20855 {Py_XINCREF(py_V411);} 20856 20857 V411 = NULL; 20858 if (py_V411 == Py_None) { 20859 // We can either fail here or set V411 to NULL and rely on Ops 20860 // using tensors to handle the NULL case, but if they fail to do so 20861 // they'll end up with nasty segfaults, so this is public service. 20862 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 20863 { 20864 __failure = 412; 20865 if (!PyErr_Occurred()) { 20866 PyErr_SetString(PyExc_RuntimeError, 20867 "Unexpected error in an Op's C code. " 20868 "No Python exception was set."); 20869 } 20870 goto __label_412;} 20871 } 20872 if (!PyArray_Check(py_V411)) { 20873 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 20874 { 20875 __failure = 412; 20876 if (!PyErr_Occurred()) { 20877 PyErr_SetString(PyExc_RuntimeError, 20878 "Unexpected error in an Op's C code. " 20879 "No Python exception was set."); 20880 } 20881 goto __label_412;} 20882 } 20883 // We expect NPY_FLOAT64 20884 if (!PyArray_ISALIGNED((PyArrayObject*) py_V411)) { 20885 PyArrayObject * tmp = (PyArrayObject*) py_V411; 20886 PyErr_Format(PyExc_NotImplementedError, 20887 "expected an aligned array of type %ld " 20888 "(NPY_FLOAT64), got non-aligned array of type %ld" 20889 " with %ld dimensions, with 3 last dims " 20890 "%ld, %ld, %ld" 20891 " and 3 last strides %ld %ld, %ld.", 20892 (long int) NPY_FLOAT64, 20893 (long int) PyArray_TYPE((PyArrayObject*) py_V411), 20894 (long int) PyArray_NDIM(tmp), 20895 (long int) PyArray_NDIM(tmp) >= 3 ? 20896 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 20897 (long int) PyArray_NDIM(tmp) >= 2 ? 20898 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 20899 (long int) PyArray_NDIM(tmp) >= 1 ? 20900 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 20901 (long int) PyArray_NDIM(tmp) >= 3 ? 20902 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 20903 (long int) PyArray_NDIM(tmp) >= 2 ? 20904 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 20905 (long int) PyArray_NDIM(tmp) >= 1 ? 20906 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 20907 ); 20908 { 20909 __failure = 412; 20910 if (!PyErr_Occurred()) { 20911 PyErr_SetString(PyExc_RuntimeError, 20912 "Unexpected error in an Op's C code. " 20913 "No Python exception was set."); 20914 } 20915 goto __label_412;} 20916 } 20917 // This is a TypeError to be consistent with DEBUG_MODE 20918 // Note: DEBUG_MODE also tells the name of the container 20919 if (PyArray_TYPE((PyArrayObject*) py_V411) != NPY_FLOAT64) { 20920 PyErr_Format(PyExc_TypeError, 20921 "expected type_num %d (NPY_FLOAT64) got %d", 20922 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V411)); 20923 { 20924 __failure = 412; 20925 if (!PyErr_Occurred()) { 20926 PyErr_SetString(PyExc_RuntimeError, 20927 "Unexpected error in an Op's C code. " 20928 "No Python exception was set."); 20929 } 20930 goto __label_412;} 20931 } 20932 20933 V411 = (PyArrayObject*)(py_V411); 20934 Py_XINCREF(V411); 20935 20936 { 20937 20938 py_V413 = PyList_GET_ITEM(storage_V413, 0); 20939 {Py_XINCREF(py_V413);} 20940 20941 V413 = NULL; 20942 if (py_V413 == Py_None) { 20943 // We can either fail here or set V413 to NULL and rely on Ops 20944 // using tensors to handle the NULL case, but if they fail to do so 20945 // they'll end up with nasty segfaults, so this is public service. 20946 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 20947 { 20948 __failure = 414; 20949 if (!PyErr_Occurred()) { 20950 PyErr_SetString(PyExc_RuntimeError, 20951 "Unexpected error in an Op's C code. " 20952 "No Python exception was set."); 20953 } 20954 goto __label_414;} 20955 } 20956 if (!PyArray_Check(py_V413)) { 20957 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 20958 { 20959 __failure = 414; 20960 if (!PyErr_Occurred()) { 20961 PyErr_SetString(PyExc_RuntimeError, 20962 "Unexpected error in an Op's C code. " 20963 "No Python exception was set."); 20964 } 20965 goto __label_414;} 20966 } 20967 // We expect NPY_FLOAT64 20968 if (!PyArray_ISALIGNED((PyArrayObject*) py_V413)) { 20969 PyArrayObject * tmp = (PyArrayObject*) py_V413; 20970 PyErr_Format(PyExc_NotImplementedError, 20971 "expected an aligned array of type %ld " 20972 "(NPY_FLOAT64), got non-aligned array of type %ld" 20973 " with %ld dimensions, with 3 last dims " 20974 "%ld, %ld, %ld" 20975 " and 3 last strides %ld %ld, %ld.", 20976 (long int) NPY_FLOAT64, 20977 (long int) PyArray_TYPE((PyArrayObject*) py_V413), 20978 (long int) PyArray_NDIM(tmp), 20979 (long int) PyArray_NDIM(tmp) >= 3 ? 20980 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 20981 (long int) PyArray_NDIM(tmp) >= 2 ? 20982 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 20983 (long int) PyArray_NDIM(tmp) >= 1 ? 20984 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 20985 (long int) PyArray_NDIM(tmp) >= 3 ? 20986 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 20987 (long int) PyArray_NDIM(tmp) >= 2 ? 20988 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 20989 (long int) PyArray_NDIM(tmp) >= 1 ? 20990 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 20991 ); 20992 { 20993 __failure = 414; 20994 if (!PyErr_Occurred()) { 20995 PyErr_SetString(PyExc_RuntimeError, 20996 "Unexpected error in an Op's C code. " 20997 "No Python exception was set."); 20998 } 20999 goto __label_414;} 21000 } 21001 // This is a TypeError to be consistent with DEBUG_MODE 21002 // Note: DEBUG_MODE also tells the name of the container 21003 if (PyArray_TYPE((PyArrayObject*) py_V413) != NPY_FLOAT64) { 21004 PyErr_Format(PyExc_TypeError, 21005 "expected type_num %d (NPY_FLOAT64) got %d", 21006 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V413)); 21007 { 21008 __failure = 414; 21009 if (!PyErr_Occurred()) { 21010 PyErr_SetString(PyExc_RuntimeError, 21011 "Unexpected error in an Op's C code. " 21012 "No Python exception was set."); 21013 } 21014 goto __label_414;} 21015 } 21016 21017 V413 = (PyArrayObject*)(py_V413); 21018 Py_XINCREF(V413); 21019 21020 { 21021 21022 py_V415 = PyList_GET_ITEM(storage_V415, 0); 21023 {Py_XINCREF(py_V415);} 21024 21025 V415 = NULL; 21026 if (py_V415 == Py_None) { 21027 // We can either fail here or set V415 to NULL and rely on Ops 21028 // using tensors to handle the NULL case, but if they fail to do so 21029 // they'll end up with nasty segfaults, so this is public service. 21030 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 21031 { 21032 __failure = 416; 21033 if (!PyErr_Occurred()) { 21034 PyErr_SetString(PyExc_RuntimeError, 21035 "Unexpected error in an Op's C code. " 21036 "No Python exception was set."); 21037 } 21038 goto __label_416;} 21039 } 21040 if (!PyArray_Check(py_V415)) { 21041 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 21042 { 21043 __failure = 416; 21044 if (!PyErr_Occurred()) { 21045 PyErr_SetString(PyExc_RuntimeError, 21046 "Unexpected error in an Op's C code. " 21047 "No Python exception was set."); 21048 } 21049 goto __label_416;} 21050 } 21051 // We expect NPY_FLOAT64 21052 if (!PyArray_ISALIGNED((PyArrayObject*) py_V415)) { 21053 PyArrayObject * tmp = (PyArrayObject*) py_V415; 21054 PyErr_Format(PyExc_NotImplementedError, 21055 "expected an aligned array of type %ld " 21056 "(NPY_FLOAT64), got non-aligned array of type %ld" 21057 " with %ld dimensions, with 3 last dims " 21058 "%ld, %ld, %ld" 21059 " and 3 last strides %ld %ld, %ld.", 21060 (long int) NPY_FLOAT64, 21061 (long int) PyArray_TYPE((PyArrayObject*) py_V415), 21062 (long int) PyArray_NDIM(tmp), 21063 (long int) PyArray_NDIM(tmp) >= 3 ? 21064 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 21065 (long int) PyArray_NDIM(tmp) >= 2 ? 21066 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 21067 (long int) PyArray_NDIM(tmp) >= 1 ? 21068 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 21069 (long int) PyArray_NDIM(tmp) >= 3 ? 21070 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 21071 (long int) PyArray_NDIM(tmp) >= 2 ? 21072 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 21073 (long int) PyArray_NDIM(tmp) >= 1 ? 21074 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 21075 ); 21076 { 21077 __failure = 416; 21078 if (!PyErr_Occurred()) { 21079 PyErr_SetString(PyExc_RuntimeError, 21080 "Unexpected error in an Op's C code. " 21081 "No Python exception was set."); 21082 } 21083 goto __label_416;} 21084 } 21085 // This is a TypeError to be consistent with DEBUG_MODE 21086 // Note: DEBUG_MODE also tells the name of the container 21087 if (PyArray_TYPE((PyArrayObject*) py_V415) != NPY_FLOAT64) { 21088 PyErr_Format(PyExc_TypeError, 21089 "expected type_num %d (NPY_FLOAT64) got %d", 21090 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V415)); 21091 { 21092 __failure = 416; 21093 if (!PyErr_Occurred()) { 21094 PyErr_SetString(PyExc_RuntimeError, 21095 "Unexpected error in an Op's C code. " 21096 "No Python exception was set."); 21097 } 21098 goto __label_416;} 21099 } 21100 21101 V415 = (PyArrayObject*)(py_V415); 21102 Py_XINCREF(V415); 21103 21104 { 21105 21106 py_V417 = PyList_GET_ITEM(storage_V417, 0); 21107 {Py_XINCREF(py_V417);} 21108 21109 V417 = NULL; 21110 if (py_V417 == Py_None) { 21111 // We can either fail here or set V417 to NULL and rely on Ops 21112 // using tensors to handle the NULL case, but if they fail to do so 21113 // they'll end up with nasty segfaults, so this is public service. 21114 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 21115 { 21116 __failure = 418; 21117 if (!PyErr_Occurred()) { 21118 PyErr_SetString(PyExc_RuntimeError, 21119 "Unexpected error in an Op's C code. " 21120 "No Python exception was set."); 21121 } 21122 goto __label_418;} 21123 } 21124 if (!PyArray_Check(py_V417)) { 21125 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 21126 { 21127 __failure = 418; 21128 if (!PyErr_Occurred()) { 21129 PyErr_SetString(PyExc_RuntimeError, 21130 "Unexpected error in an Op's C code. " 21131 "No Python exception was set."); 21132 } 21133 goto __label_418;} 21134 } 21135 // We expect NPY_FLOAT64 21136 if (!PyArray_ISALIGNED((PyArrayObject*) py_V417)) { 21137 PyArrayObject * tmp = (PyArrayObject*) py_V417; 21138 PyErr_Format(PyExc_NotImplementedError, 21139 "expected an aligned array of type %ld " 21140 "(NPY_FLOAT64), got non-aligned array of type %ld" 21141 " with %ld dimensions, with 3 last dims " 21142 "%ld, %ld, %ld" 21143 " and 3 last strides %ld %ld, %ld.", 21144 (long int) NPY_FLOAT64, 21145 (long int) PyArray_TYPE((PyArrayObject*) py_V417), 21146 (long int) PyArray_NDIM(tmp), 21147 (long int) PyArray_NDIM(tmp) >= 3 ? 21148 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 21149 (long int) PyArray_NDIM(tmp) >= 2 ? 21150 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 21151 (long int) PyArray_NDIM(tmp) >= 1 ? 21152 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 21153 (long int) PyArray_NDIM(tmp) >= 3 ? 21154 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 21155 (long int) PyArray_NDIM(tmp) >= 2 ? 21156 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 21157 (long int) PyArray_NDIM(tmp) >= 1 ? 21158 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 21159 ); 21160 { 21161 __failure = 418; 21162 if (!PyErr_Occurred()) { 21163 PyErr_SetString(PyExc_RuntimeError, 21164 "Unexpected error in an Op's C code. " 21165 "No Python exception was set."); 21166 } 21167 goto __label_418;} 21168 } 21169 // This is a TypeError to be consistent with DEBUG_MODE 21170 // Note: DEBUG_MODE also tells the name of the container 21171 if (PyArray_TYPE((PyArrayObject*) py_V417) != NPY_FLOAT64) { 21172 PyErr_Format(PyExc_TypeError, 21173 "expected type_num %d (NPY_FLOAT64) got %d", 21174 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V417)); 21175 { 21176 __failure = 418; 21177 if (!PyErr_Occurred()) { 21178 PyErr_SetString(PyExc_RuntimeError, 21179 "Unexpected error in an Op's C code. " 21180 "No Python exception was set."); 21181 } 21182 goto __label_418;} 21183 } 21184 21185 V417 = (PyArrayObject*)(py_V417); 21186 Py_XINCREF(V417); 21187 21188 { 21189 21190 py_V419 = PyList_GET_ITEM(storage_V419, 0); 21191 {Py_XINCREF(py_V419);} 21192 21193 V419 = NULL; 21194 if (py_V419 == Py_None) { 21195 // We can either fail here or set V419 to NULL and rely on Ops 21196 // using tensors to handle the NULL case, but if they fail to do so 21197 // they'll end up with nasty segfaults, so this is public service. 21198 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 21199 { 21200 __failure = 420; 21201 if (!PyErr_Occurred()) { 21202 PyErr_SetString(PyExc_RuntimeError, 21203 "Unexpected error in an Op's C code. " 21204 "No Python exception was set."); 21205 } 21206 goto __label_420;} 21207 } 21208 if (!PyArray_Check(py_V419)) { 21209 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 21210 { 21211 __failure = 420; 21212 if (!PyErr_Occurred()) { 21213 PyErr_SetString(PyExc_RuntimeError, 21214 "Unexpected error in an Op's C code. " 21215 "No Python exception was set."); 21216 } 21217 goto __label_420;} 21218 } 21219 // We expect NPY_FLOAT64 21220 if (!PyArray_ISALIGNED((PyArrayObject*) py_V419)) { 21221 PyArrayObject * tmp = (PyArrayObject*) py_V419; 21222 PyErr_Format(PyExc_NotImplementedError, 21223 "expected an aligned array of type %ld " 21224 "(NPY_FLOAT64), got non-aligned array of type %ld" 21225 " with %ld dimensions, with 3 last dims " 21226 "%ld, %ld, %ld" 21227 " and 3 last strides %ld %ld, %ld.", 21228 (long int) NPY_FLOAT64, 21229 (long int) PyArray_TYPE((PyArrayObject*) py_V419), 21230 (long int) PyArray_NDIM(tmp), 21231 (long int) PyArray_NDIM(tmp) >= 3 ? 21232 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 21233 (long int) PyArray_NDIM(tmp) >= 2 ? 21234 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 21235 (long int) PyArray_NDIM(tmp) >= 1 ? 21236 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 21237 (long int) PyArray_NDIM(tmp) >= 3 ? 21238 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 21239 (long int) PyArray_NDIM(tmp) >= 2 ? 21240 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 21241 (long int) PyArray_NDIM(tmp) >= 1 ? 21242 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 21243 ); 21244 { 21245 __failure = 420; 21246 if (!PyErr_Occurred()) { 21247 PyErr_SetString(PyExc_RuntimeError, 21248 "Unexpected error in an Op's C code. " 21249 "No Python exception was set."); 21250 } 21251 goto __label_420;} 21252 } 21253 // This is a TypeError to be consistent with DEBUG_MODE 21254 // Note: DEBUG_MODE also tells the name of the container 21255 if (PyArray_TYPE((PyArrayObject*) py_V419) != NPY_FLOAT64) { 21256 PyErr_Format(PyExc_TypeError, 21257 "expected type_num %d (NPY_FLOAT64) got %d", 21258 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V419)); 21259 { 21260 __failure = 420; 21261 if (!PyErr_Occurred()) { 21262 PyErr_SetString(PyExc_RuntimeError, 21263 "Unexpected error in an Op's C code. " 21264 "No Python exception was set."); 21265 } 21266 goto __label_420;} 21267 } 21268 21269 V419 = (PyArrayObject*)(py_V419); 21270 Py_XINCREF(V419); 21271 21272 { 21273 21274 py_V421 = PyList_GET_ITEM(storage_V421, 0); 21275 {Py_XINCREF(py_V421);} 21276 21277 V421 = NULL; 21278 if (py_V421 == Py_None) { 21279 // We can either fail here or set V421 to NULL and rely on Ops 21280 // using tensors to handle the NULL case, but if they fail to do so 21281 // they'll end up with nasty segfaults, so this is public service. 21282 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 21283 { 21284 __failure = 422; 21285 if (!PyErr_Occurred()) { 21286 PyErr_SetString(PyExc_RuntimeError, 21287 "Unexpected error in an Op's C code. " 21288 "No Python exception was set."); 21289 } 21290 goto __label_422;} 21291 } 21292 if (!PyArray_Check(py_V421)) { 21293 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 21294 { 21295 __failure = 422; 21296 if (!PyErr_Occurred()) { 21297 PyErr_SetString(PyExc_RuntimeError, 21298 "Unexpected error in an Op's C code. " 21299 "No Python exception was set."); 21300 } 21301 goto __label_422;} 21302 } 21303 // We expect NPY_INT8 21304 if (!PyArray_ISALIGNED((PyArrayObject*) py_V421)) { 21305 PyArrayObject * tmp = (PyArrayObject*) py_V421; 21306 PyErr_Format(PyExc_NotImplementedError, 21307 "expected an aligned array of type %ld " 21308 "(NPY_INT8), got non-aligned array of type %ld" 21309 " with %ld dimensions, with 3 last dims " 21310 "%ld, %ld, %ld" 21311 " and 3 last strides %ld %ld, %ld.", 21312 (long int) NPY_INT8, 21313 (long int) PyArray_TYPE((PyArrayObject*) py_V421), 21314 (long int) PyArray_NDIM(tmp), 21315 (long int) PyArray_NDIM(tmp) >= 3 ? 21316 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 21317 (long int) PyArray_NDIM(tmp) >= 2 ? 21318 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 21319 (long int) PyArray_NDIM(tmp) >= 1 ? 21320 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 21321 (long int) PyArray_NDIM(tmp) >= 3 ? 21322 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 21323 (long int) PyArray_NDIM(tmp) >= 2 ? 21324 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 21325 (long int) PyArray_NDIM(tmp) >= 1 ? 21326 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 21327 ); 21328 { 21329 __failure = 422; 21330 if (!PyErr_Occurred()) { 21331 PyErr_SetString(PyExc_RuntimeError, 21332 "Unexpected error in an Op's C code. " 21333 "No Python exception was set."); 21334 } 21335 goto __label_422;} 21336 } 21337 // This is a TypeError to be consistent with DEBUG_MODE 21338 // Note: DEBUG_MODE also tells the name of the container 21339 if (PyArray_TYPE((PyArrayObject*) py_V421) != NPY_INT8) { 21340 PyErr_Format(PyExc_TypeError, 21341 "expected type_num %d (NPY_INT8) got %d", 21342 NPY_INT8, PyArray_TYPE((PyArrayObject*) py_V421)); 21343 { 21344 __failure = 422; 21345 if (!PyErr_Occurred()) { 21346 PyErr_SetString(PyExc_RuntimeError, 21347 "Unexpected error in an Op's C code. " 21348 "No Python exception was set."); 21349 } 21350 goto __label_422;} 21351 } 21352 21353 V421 = (PyArrayObject*)(py_V421); 21354 Py_XINCREF(V421); 21355 21356 { 21357 21358 py_V423 = PyList_GET_ITEM(storage_V423, 0); 21359 {Py_XINCREF(py_V423);} 21360 21361 V423 = NULL; 21362 if (py_V423 == Py_None) { 21363 // We can either fail here or set V423 to NULL and rely on Ops 21364 // using tensors to handle the NULL case, but if they fail to do so 21365 // they'll end up with nasty segfaults, so this is public service. 21366 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 21367 { 21368 __failure = 424; 21369 if (!PyErr_Occurred()) { 21370 PyErr_SetString(PyExc_RuntimeError, 21371 "Unexpected error in an Op's C code. " 21372 "No Python exception was set."); 21373 } 21374 goto __label_424;} 21375 } 21376 if (!PyArray_Check(py_V423)) { 21377 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 21378 { 21379 __failure = 424; 21380 if (!PyErr_Occurred()) { 21381 PyErr_SetString(PyExc_RuntimeError, 21382 "Unexpected error in an Op's C code. " 21383 "No Python exception was set."); 21384 } 21385 goto __label_424;} 21386 } 21387 // We expect NPY_FLOAT64 21388 if (!PyArray_ISALIGNED((PyArrayObject*) py_V423)) { 21389 PyArrayObject * tmp = (PyArrayObject*) py_V423; 21390 PyErr_Format(PyExc_NotImplementedError, 21391 "expected an aligned array of type %ld " 21392 "(NPY_FLOAT64), got non-aligned array of type %ld" 21393 " with %ld dimensions, with 3 last dims " 21394 "%ld, %ld, %ld" 21395 " and 3 last strides %ld %ld, %ld.", 21396 (long int) NPY_FLOAT64, 21397 (long int) PyArray_TYPE((PyArrayObject*) py_V423), 21398 (long int) PyArray_NDIM(tmp), 21399 (long int) PyArray_NDIM(tmp) >= 3 ? 21400 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 21401 (long int) PyArray_NDIM(tmp) >= 2 ? 21402 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 21403 (long int) PyArray_NDIM(tmp) >= 1 ? 21404 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 21405 (long int) PyArray_NDIM(tmp) >= 3 ? 21406 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 21407 (long int) PyArray_NDIM(tmp) >= 2 ? 21408 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 21409 (long int) PyArray_NDIM(tmp) >= 1 ? 21410 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 21411 ); 21412 { 21413 __failure = 424; 21414 if (!PyErr_Occurred()) { 21415 PyErr_SetString(PyExc_RuntimeError, 21416 "Unexpected error in an Op's C code. " 21417 "No Python exception was set."); 21418 } 21419 goto __label_424;} 21420 } 21421 // This is a TypeError to be consistent with DEBUG_MODE 21422 // Note: DEBUG_MODE also tells the name of the container 21423 if (PyArray_TYPE((PyArrayObject*) py_V423) != NPY_FLOAT64) { 21424 PyErr_Format(PyExc_TypeError, 21425 "expected type_num %d (NPY_FLOAT64) got %d", 21426 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V423)); 21427 { 21428 __failure = 424; 21429 if (!PyErr_Occurred()) { 21430 PyErr_SetString(PyExc_RuntimeError, 21431 "Unexpected error in an Op's C code. " 21432 "No Python exception was set."); 21433 } 21434 goto __label_424;} 21435 } 21436 21437 V423 = (PyArrayObject*)(py_V423); 21438 Py_XINCREF(V423); 21439 21440 { 21441 21442 py_V425 = PyList_GET_ITEM(storage_V425, 0); 21443 {Py_XINCREF(py_V425);} 21444 21445 V425 = NULL; 21446 if (py_V425 == Py_None) { 21447 // We can either fail here or set V425 to NULL and rely on Ops 21448 // using tensors to handle the NULL case, but if they fail to do so 21449 // they'll end up with nasty segfaults, so this is public service. 21450 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 21451 { 21452 __failure = 426; 21453 if (!PyErr_Occurred()) { 21454 PyErr_SetString(PyExc_RuntimeError, 21455 "Unexpected error in an Op's C code. " 21456 "No Python exception was set."); 21457 } 21458 goto __label_426;} 21459 } 21460 if (!PyArray_Check(py_V425)) { 21461 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 21462 { 21463 __failure = 426; 21464 if (!PyErr_Occurred()) { 21465 PyErr_SetString(PyExc_RuntimeError, 21466 "Unexpected error in an Op's C code. " 21467 "No Python exception was set."); 21468 } 21469 goto __label_426;} 21470 } 21471 // We expect NPY_FLOAT64 21472 if (!PyArray_ISALIGNED((PyArrayObject*) py_V425)) { 21473 PyArrayObject * tmp = (PyArrayObject*) py_V425; 21474 PyErr_Format(PyExc_NotImplementedError, 21475 "expected an aligned array of type %ld " 21476 "(NPY_FLOAT64), got non-aligned array of type %ld" 21477 " with %ld dimensions, with 3 last dims " 21478 "%ld, %ld, %ld" 21479 " and 3 last strides %ld %ld, %ld.", 21480 (long int) NPY_FLOAT64, 21481 (long int) PyArray_TYPE((PyArrayObject*) py_V425), 21482 (long int) PyArray_NDIM(tmp), 21483 (long int) PyArray_NDIM(tmp) >= 3 ? 21484 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 21485 (long int) PyArray_NDIM(tmp) >= 2 ? 21486 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 21487 (long int) PyArray_NDIM(tmp) >= 1 ? 21488 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 21489 (long int) PyArray_NDIM(tmp) >= 3 ? 21490 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 21491 (long int) PyArray_NDIM(tmp) >= 2 ? 21492 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 21493 (long int) PyArray_NDIM(tmp) >= 1 ? 21494 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 21495 ); 21496 { 21497 __failure = 426; 21498 if (!PyErr_Occurred()) { 21499 PyErr_SetString(PyExc_RuntimeError, 21500 "Unexpected error in an Op's C code. " 21501 "No Python exception was set."); 21502 } 21503 goto __label_426;} 21504 } 21505 // This is a TypeError to be consistent with DEBUG_MODE 21506 // Note: DEBUG_MODE also tells the name of the container 21507 if (PyArray_TYPE((PyArrayObject*) py_V425) != NPY_FLOAT64) { 21508 PyErr_Format(PyExc_TypeError, 21509 "expected type_num %d (NPY_FLOAT64) got %d", 21510 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V425)); 21511 { 21512 __failure = 426; 21513 if (!PyErr_Occurred()) { 21514 PyErr_SetString(PyExc_RuntimeError, 21515 "Unexpected error in an Op's C code. " 21516 "No Python exception was set."); 21517 } 21518 goto __label_426;} 21519 } 21520 21521 V425 = (PyArrayObject*)(py_V425); 21522 Py_XINCREF(V425); 21523 21524 { 21525 21526 py_V427 = PyList_GET_ITEM(storage_V427, 0); 21527 {Py_XINCREF(py_V427);} 21528 21529 V427 = NULL; 21530 if (py_V427 == Py_None) { 21531 // We can either fail here or set V427 to NULL and rely on Ops 21532 // using tensors to handle the NULL case, but if they fail to do so 21533 // they'll end up with nasty segfaults, so this is public service. 21534 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 21535 { 21536 __failure = 428; 21537 if (!PyErr_Occurred()) { 21538 PyErr_SetString(PyExc_RuntimeError, 21539 "Unexpected error in an Op's C code. " 21540 "No Python exception was set."); 21541 } 21542 goto __label_428;} 21543 } 21544 if (!PyArray_Check(py_V427)) { 21545 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 21546 { 21547 __failure = 428; 21548 if (!PyErr_Occurred()) { 21549 PyErr_SetString(PyExc_RuntimeError, 21550 "Unexpected error in an Op's C code. " 21551 "No Python exception was set."); 21552 } 21553 goto __label_428;} 21554 } 21555 // We expect NPY_FLOAT64 21556 if (!PyArray_ISALIGNED((PyArrayObject*) py_V427)) { 21557 PyArrayObject * tmp = (PyArrayObject*) py_V427; 21558 PyErr_Format(PyExc_NotImplementedError, 21559 "expected an aligned array of type %ld " 21560 "(NPY_FLOAT64), got non-aligned array of type %ld" 21561 " with %ld dimensions, with 3 last dims " 21562 "%ld, %ld, %ld" 21563 " and 3 last strides %ld %ld, %ld.", 21564 (long int) NPY_FLOAT64, 21565 (long int) PyArray_TYPE((PyArrayObject*) py_V427), 21566 (long int) PyArray_NDIM(tmp), 21567 (long int) PyArray_NDIM(tmp) >= 3 ? 21568 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 21569 (long int) PyArray_NDIM(tmp) >= 2 ? 21570 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 21571 (long int) PyArray_NDIM(tmp) >= 1 ? 21572 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 21573 (long int) PyArray_NDIM(tmp) >= 3 ? 21574 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 21575 (long int) PyArray_NDIM(tmp) >= 2 ? 21576 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 21577 (long int) PyArray_NDIM(tmp) >= 1 ? 21578 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 21579 ); 21580 { 21581 __failure = 428; 21582 if (!PyErr_Occurred()) { 21583 PyErr_SetString(PyExc_RuntimeError, 21584 "Unexpected error in an Op's C code. " 21585 "No Python exception was set."); 21586 } 21587 goto __label_428;} 21588 } 21589 // This is a TypeError to be consistent with DEBUG_MODE 21590 // Note: DEBUG_MODE also tells the name of the container 21591 if (PyArray_TYPE((PyArrayObject*) py_V427) != NPY_FLOAT64) { 21592 PyErr_Format(PyExc_TypeError, 21593 "expected type_num %d (NPY_FLOAT64) got %d", 21594 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V427)); 21595 { 21596 __failure = 428; 21597 if (!PyErr_Occurred()) { 21598 PyErr_SetString(PyExc_RuntimeError, 21599 "Unexpected error in an Op's C code. " 21600 "No Python exception was set."); 21601 } 21602 goto __label_428;} 21603 } 21604 21605 V427 = (PyArrayObject*)(py_V427); 21606 Py_XINCREF(V427); 21607 21608 { 21609 21610 py_V429 = PyList_GET_ITEM(storage_V429, 0); 21611 {Py_XINCREF(py_V429);} 21612 21613 V429 = NULL; 21614 if (py_V429 == Py_None) { 21615 // We can either fail here or set V429 to NULL and rely on Ops 21616 // using tensors to handle the NULL case, but if they fail to do so 21617 // they'll end up with nasty segfaults, so this is public service. 21618 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 21619 { 21620 __failure = 430; 21621 if (!PyErr_Occurred()) { 21622 PyErr_SetString(PyExc_RuntimeError, 21623 "Unexpected error in an Op's C code. " 21624 "No Python exception was set."); 21625 } 21626 goto __label_430;} 21627 } 21628 if (!PyArray_Check(py_V429)) { 21629 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 21630 { 21631 __failure = 430; 21632 if (!PyErr_Occurred()) { 21633 PyErr_SetString(PyExc_RuntimeError, 21634 "Unexpected error in an Op's C code. " 21635 "No Python exception was set."); 21636 } 21637 goto __label_430;} 21638 } 21639 // We expect NPY_FLOAT64 21640 if (!PyArray_ISALIGNED((PyArrayObject*) py_V429)) { 21641 PyArrayObject * tmp = (PyArrayObject*) py_V429; 21642 PyErr_Format(PyExc_NotImplementedError, 21643 "expected an aligned array of type %ld " 21644 "(NPY_FLOAT64), got non-aligned array of type %ld" 21645 " with %ld dimensions, with 3 last dims " 21646 "%ld, %ld, %ld" 21647 " and 3 last strides %ld %ld, %ld.", 21648 (long int) NPY_FLOAT64, 21649 (long int) PyArray_TYPE((PyArrayObject*) py_V429), 21650 (long int) PyArray_NDIM(tmp), 21651 (long int) PyArray_NDIM(tmp) >= 3 ? 21652 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 21653 (long int) PyArray_NDIM(tmp) >= 2 ? 21654 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 21655 (long int) PyArray_NDIM(tmp) >= 1 ? 21656 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 21657 (long int) PyArray_NDIM(tmp) >= 3 ? 21658 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 21659 (long int) PyArray_NDIM(tmp) >= 2 ? 21660 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 21661 (long int) PyArray_NDIM(tmp) >= 1 ? 21662 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 21663 ); 21664 { 21665 __failure = 430; 21666 if (!PyErr_Occurred()) { 21667 PyErr_SetString(PyExc_RuntimeError, 21668 "Unexpected error in an Op's C code. " 21669 "No Python exception was set."); 21670 } 21671 goto __label_430;} 21672 } 21673 // This is a TypeError to be consistent with DEBUG_MODE 21674 // Note: DEBUG_MODE also tells the name of the container 21675 if (PyArray_TYPE((PyArrayObject*) py_V429) != NPY_FLOAT64) { 21676 PyErr_Format(PyExc_TypeError, 21677 "expected type_num %d (NPY_FLOAT64) got %d", 21678 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V429)); 21679 { 21680 __failure = 430; 21681 if (!PyErr_Occurred()) { 21682 PyErr_SetString(PyExc_RuntimeError, 21683 "Unexpected error in an Op's C code. " 21684 "No Python exception was set."); 21685 } 21686 goto __label_430;} 21687 } 21688 21689 V429 = (PyArrayObject*)(py_V429); 21690 Py_XINCREF(V429); 21691 21692 { 21693 21694 py_V431 = PyList_GET_ITEM(storage_V431, 0); 21695 {Py_XINCREF(py_V431);} 21696 21697 V431 = NULL; 21698 if (py_V431 == Py_None) { 21699 // We can either fail here or set V431 to NULL and rely on Ops 21700 // using tensors to handle the NULL case, but if they fail to do so 21701 // they'll end up with nasty segfaults, so this is public service. 21702 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 21703 { 21704 __failure = 432; 21705 if (!PyErr_Occurred()) { 21706 PyErr_SetString(PyExc_RuntimeError, 21707 "Unexpected error in an Op's C code. " 21708 "No Python exception was set."); 21709 } 21710 goto __label_432;} 21711 } 21712 if (!PyArray_Check(py_V431)) { 21713 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 21714 { 21715 __failure = 432; 21716 if (!PyErr_Occurred()) { 21717 PyErr_SetString(PyExc_RuntimeError, 21718 "Unexpected error in an Op's C code. " 21719 "No Python exception was set."); 21720 } 21721 goto __label_432;} 21722 } 21723 // We expect NPY_FLOAT64 21724 if (!PyArray_ISALIGNED((PyArrayObject*) py_V431)) { 21725 PyArrayObject * tmp = (PyArrayObject*) py_V431; 21726 PyErr_Format(PyExc_NotImplementedError, 21727 "expected an aligned array of type %ld " 21728 "(NPY_FLOAT64), got non-aligned array of type %ld" 21729 " with %ld dimensions, with 3 last dims " 21730 "%ld, %ld, %ld" 21731 " and 3 last strides %ld %ld, %ld.", 21732 (long int) NPY_FLOAT64, 21733 (long int) PyArray_TYPE((PyArrayObject*) py_V431), 21734 (long int) PyArray_NDIM(tmp), 21735 (long int) PyArray_NDIM(tmp) >= 3 ? 21736 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 21737 (long int) PyArray_NDIM(tmp) >= 2 ? 21738 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 21739 (long int) PyArray_NDIM(tmp) >= 1 ? 21740 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 21741 (long int) PyArray_NDIM(tmp) >= 3 ? 21742 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 21743 (long int) PyArray_NDIM(tmp) >= 2 ? 21744 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 21745 (long int) PyArray_NDIM(tmp) >= 1 ? 21746 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 21747 ); 21748 { 21749 __failure = 432; 21750 if (!PyErr_Occurred()) { 21751 PyErr_SetString(PyExc_RuntimeError, 21752 "Unexpected error in an Op's C code. " 21753 "No Python exception was set."); 21754 } 21755 goto __label_432;} 21756 } 21757 // This is a TypeError to be consistent with DEBUG_MODE 21758 // Note: DEBUG_MODE also tells the name of the container 21759 if (PyArray_TYPE((PyArrayObject*) py_V431) != NPY_FLOAT64) { 21760 PyErr_Format(PyExc_TypeError, 21761 "expected type_num %d (NPY_FLOAT64) got %d", 21762 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V431)); 21763 { 21764 __failure = 432; 21765 if (!PyErr_Occurred()) { 21766 PyErr_SetString(PyExc_RuntimeError, 21767 "Unexpected error in an Op's C code. " 21768 "No Python exception was set."); 21769 } 21770 goto __label_432;} 21771 } 21772 21773 V431 = (PyArrayObject*)(py_V431); 21774 Py_XINCREF(V431); 21775 21776 { 21777 21778 py_V433 = PyList_GET_ITEM(storage_V433, 0); 21779 {Py_XINCREF(py_V433);} 21780 21781 V433 = NULL; 21782 if (py_V433 == Py_None) { 21783 // We can either fail here or set V433 to NULL and rely on Ops 21784 // using tensors to handle the NULL case, but if they fail to do so 21785 // they'll end up with nasty segfaults, so this is public service. 21786 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 21787 { 21788 __failure = 434; 21789 if (!PyErr_Occurred()) { 21790 PyErr_SetString(PyExc_RuntimeError, 21791 "Unexpected error in an Op's C code. " 21792 "No Python exception was set."); 21793 } 21794 goto __label_434;} 21795 } 21796 if (!PyArray_Check(py_V433)) { 21797 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 21798 { 21799 __failure = 434; 21800 if (!PyErr_Occurred()) { 21801 PyErr_SetString(PyExc_RuntimeError, 21802 "Unexpected error in an Op's C code. " 21803 "No Python exception was set."); 21804 } 21805 goto __label_434;} 21806 } 21807 // We expect NPY_FLOAT64 21808 if (!PyArray_ISALIGNED((PyArrayObject*) py_V433)) { 21809 PyArrayObject * tmp = (PyArrayObject*) py_V433; 21810 PyErr_Format(PyExc_NotImplementedError, 21811 "expected an aligned array of type %ld " 21812 "(NPY_FLOAT64), got non-aligned array of type %ld" 21813 " with %ld dimensions, with 3 last dims " 21814 "%ld, %ld, %ld" 21815 " and 3 last strides %ld %ld, %ld.", 21816 (long int) NPY_FLOAT64, 21817 (long int) PyArray_TYPE((PyArrayObject*) py_V433), 21818 (long int) PyArray_NDIM(tmp), 21819 (long int) PyArray_NDIM(tmp) >= 3 ? 21820 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 21821 (long int) PyArray_NDIM(tmp) >= 2 ? 21822 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 21823 (long int) PyArray_NDIM(tmp) >= 1 ? 21824 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 21825 (long int) PyArray_NDIM(tmp) >= 3 ? 21826 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 21827 (long int) PyArray_NDIM(tmp) >= 2 ? 21828 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 21829 (long int) PyArray_NDIM(tmp) >= 1 ? 21830 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 21831 ); 21832 { 21833 __failure = 434; 21834 if (!PyErr_Occurred()) { 21835 PyErr_SetString(PyExc_RuntimeError, 21836 "Unexpected error in an Op's C code. " 21837 "No Python exception was set."); 21838 } 21839 goto __label_434;} 21840 } 21841 // This is a TypeError to be consistent with DEBUG_MODE 21842 // Note: DEBUG_MODE also tells the name of the container 21843 if (PyArray_TYPE((PyArrayObject*) py_V433) != NPY_FLOAT64) { 21844 PyErr_Format(PyExc_TypeError, 21845 "expected type_num %d (NPY_FLOAT64) got %d", 21846 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V433)); 21847 { 21848 __failure = 434; 21849 if (!PyErr_Occurred()) { 21850 PyErr_SetString(PyExc_RuntimeError, 21851 "Unexpected error in an Op's C code. " 21852 "No Python exception was set."); 21853 } 21854 goto __label_434;} 21855 } 21856 21857 V433 = (PyArrayObject*)(py_V433); 21858 Py_XINCREF(V433); 21859 21860 { 21861 21862 py_V435 = PyList_GET_ITEM(storage_V435, 0); 21863 {Py_XINCREF(py_V435);} 21864 21865 V435 = NULL; 21866 if (py_V435 == Py_None) { 21867 // We can either fail here or set V435 to NULL and rely on Ops 21868 // using tensors to handle the NULL case, but if they fail to do so 21869 // they'll end up with nasty segfaults, so this is public service. 21870 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 21871 { 21872 __failure = 436; 21873 if (!PyErr_Occurred()) { 21874 PyErr_SetString(PyExc_RuntimeError, 21875 "Unexpected error in an Op's C code. " 21876 "No Python exception was set."); 21877 } 21878 goto __label_436;} 21879 } 21880 if (!PyArray_Check(py_V435)) { 21881 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 21882 { 21883 __failure = 436; 21884 if (!PyErr_Occurred()) { 21885 PyErr_SetString(PyExc_RuntimeError, 21886 "Unexpected error in an Op's C code. " 21887 "No Python exception was set."); 21888 } 21889 goto __label_436;} 21890 } 21891 // We expect NPY_FLOAT64 21892 if (!PyArray_ISALIGNED((PyArrayObject*) py_V435)) { 21893 PyArrayObject * tmp = (PyArrayObject*) py_V435; 21894 PyErr_Format(PyExc_NotImplementedError, 21895 "expected an aligned array of type %ld " 21896 "(NPY_FLOAT64), got non-aligned array of type %ld" 21897 " with %ld dimensions, with 3 last dims " 21898 "%ld, %ld, %ld" 21899 " and 3 last strides %ld %ld, %ld.", 21900 (long int) NPY_FLOAT64, 21901 (long int) PyArray_TYPE((PyArrayObject*) py_V435), 21902 (long int) PyArray_NDIM(tmp), 21903 (long int) PyArray_NDIM(tmp) >= 3 ? 21904 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 21905 (long int) PyArray_NDIM(tmp) >= 2 ? 21906 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 21907 (long int) PyArray_NDIM(tmp) >= 1 ? 21908 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 21909 (long int) PyArray_NDIM(tmp) >= 3 ? 21910 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 21911 (long int) PyArray_NDIM(tmp) >= 2 ? 21912 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 21913 (long int) PyArray_NDIM(tmp) >= 1 ? 21914 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 21915 ); 21916 { 21917 __failure = 436; 21918 if (!PyErr_Occurred()) { 21919 PyErr_SetString(PyExc_RuntimeError, 21920 "Unexpected error in an Op's C code. " 21921 "No Python exception was set."); 21922 } 21923 goto __label_436;} 21924 } 21925 // This is a TypeError to be consistent with DEBUG_MODE 21926 // Note: DEBUG_MODE also tells the name of the container 21927 if (PyArray_TYPE((PyArrayObject*) py_V435) != NPY_FLOAT64) { 21928 PyErr_Format(PyExc_TypeError, 21929 "expected type_num %d (NPY_FLOAT64) got %d", 21930 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V435)); 21931 { 21932 __failure = 436; 21933 if (!PyErr_Occurred()) { 21934 PyErr_SetString(PyExc_RuntimeError, 21935 "Unexpected error in an Op's C code. " 21936 "No Python exception was set."); 21937 } 21938 goto __label_436;} 21939 } 21940 21941 V435 = (PyArrayObject*)(py_V435); 21942 Py_XINCREF(V435); 21943 21944 { 21945 21946 py_V437 = PyList_GET_ITEM(storage_V437, 0); 21947 {Py_XINCREF(py_V437);} 21948 21949 V437 = NULL; 21950 if (py_V437 == Py_None) { 21951 // We can either fail here or set V437 to NULL and rely on Ops 21952 // using tensors to handle the NULL case, but if they fail to do so 21953 // they'll end up with nasty segfaults, so this is public service. 21954 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 21955 { 21956 __failure = 438; 21957 if (!PyErr_Occurred()) { 21958 PyErr_SetString(PyExc_RuntimeError, 21959 "Unexpected error in an Op's C code. " 21960 "No Python exception was set."); 21961 } 21962 goto __label_438;} 21963 } 21964 if (!PyArray_Check(py_V437)) { 21965 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 21966 { 21967 __failure = 438; 21968 if (!PyErr_Occurred()) { 21969 PyErr_SetString(PyExc_RuntimeError, 21970 "Unexpected error in an Op's C code. " 21971 "No Python exception was set."); 21972 } 21973 goto __label_438;} 21974 } 21975 // We expect NPY_INT8 21976 if (!PyArray_ISALIGNED((PyArrayObject*) py_V437)) { 21977 PyArrayObject * tmp = (PyArrayObject*) py_V437; 21978 PyErr_Format(PyExc_NotImplementedError, 21979 "expected an aligned array of type %ld " 21980 "(NPY_INT8), got non-aligned array of type %ld" 21981 " with %ld dimensions, with 3 last dims " 21982 "%ld, %ld, %ld" 21983 " and 3 last strides %ld %ld, %ld.", 21984 (long int) NPY_INT8, 21985 (long int) PyArray_TYPE((PyArrayObject*) py_V437), 21986 (long int) PyArray_NDIM(tmp), 21987 (long int) PyArray_NDIM(tmp) >= 3 ? 21988 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 21989 (long int) PyArray_NDIM(tmp) >= 2 ? 21990 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 21991 (long int) PyArray_NDIM(tmp) >= 1 ? 21992 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 21993 (long int) PyArray_NDIM(tmp) >= 3 ? 21994 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 21995 (long int) PyArray_NDIM(tmp) >= 2 ? 21996 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 21997 (long int) PyArray_NDIM(tmp) >= 1 ? 21998 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 21999 ); 22000 { 22001 __failure = 438; 22002 if (!PyErr_Occurred()) { 22003 PyErr_SetString(PyExc_RuntimeError, 22004 "Unexpected error in an Op's C code. " 22005 "No Python exception was set."); 22006 } 22007 goto __label_438;} 22008 } 22009 // This is a TypeError to be consistent with DEBUG_MODE 22010 // Note: DEBUG_MODE also tells the name of the container 22011 if (PyArray_TYPE((PyArrayObject*) py_V437) != NPY_INT8) { 22012 PyErr_Format(PyExc_TypeError, 22013 "expected type_num %d (NPY_INT8) got %d", 22014 NPY_INT8, PyArray_TYPE((PyArrayObject*) py_V437)); 22015 { 22016 __failure = 438; 22017 if (!PyErr_Occurred()) { 22018 PyErr_SetString(PyExc_RuntimeError, 22019 "Unexpected error in an Op's C code. " 22020 "No Python exception was set."); 22021 } 22022 goto __label_438;} 22023 } 22024 22025 V437 = (PyArrayObject*)(py_V437); 22026 Py_XINCREF(V437); 22027 22028 { 22029 22030 py_V439 = PyList_GET_ITEM(storage_V439, 0); 22031 {Py_XINCREF(py_V439);} 22032 22033 V439 = NULL; 22034 if (py_V439 == Py_None) { 22035 // We can either fail here or set V439 to NULL and rely on Ops 22036 // using tensors to handle the NULL case, but if they fail to do so 22037 // they'll end up with nasty segfaults, so this is public service. 22038 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 22039 { 22040 __failure = 440; 22041 if (!PyErr_Occurred()) { 22042 PyErr_SetString(PyExc_RuntimeError, 22043 "Unexpected error in an Op's C code. " 22044 "No Python exception was set."); 22045 } 22046 goto __label_440;} 22047 } 22048 if (!PyArray_Check(py_V439)) { 22049 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 22050 { 22051 __failure = 440; 22052 if (!PyErr_Occurred()) { 22053 PyErr_SetString(PyExc_RuntimeError, 22054 "Unexpected error in an Op's C code. " 22055 "No Python exception was set."); 22056 } 22057 goto __label_440;} 22058 } 22059 // We expect NPY_FLOAT64 22060 if (!PyArray_ISALIGNED((PyArrayObject*) py_V439)) { 22061 PyArrayObject * tmp = (PyArrayObject*) py_V439; 22062 PyErr_Format(PyExc_NotImplementedError, 22063 "expected an aligned array of type %ld " 22064 "(NPY_FLOAT64), got non-aligned array of type %ld" 22065 " with %ld dimensions, with 3 last dims " 22066 "%ld, %ld, %ld" 22067 " and 3 last strides %ld %ld, %ld.", 22068 (long int) NPY_FLOAT64, 22069 (long int) PyArray_TYPE((PyArrayObject*) py_V439), 22070 (long int) PyArray_NDIM(tmp), 22071 (long int) PyArray_NDIM(tmp) >= 3 ? 22072 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 22073 (long int) PyArray_NDIM(tmp) >= 2 ? 22074 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 22075 (long int) PyArray_NDIM(tmp) >= 1 ? 22076 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 22077 (long int) PyArray_NDIM(tmp) >= 3 ? 22078 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 22079 (long int) PyArray_NDIM(tmp) >= 2 ? 22080 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 22081 (long int) PyArray_NDIM(tmp) >= 1 ? 22082 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 22083 ); 22084 { 22085 __failure = 440; 22086 if (!PyErr_Occurred()) { 22087 PyErr_SetString(PyExc_RuntimeError, 22088 "Unexpected error in an Op's C code. " 22089 "No Python exception was set."); 22090 } 22091 goto __label_440;} 22092 } 22093 // This is a TypeError to be consistent with DEBUG_MODE 22094 // Note: DEBUG_MODE also tells the name of the container 22095 if (PyArray_TYPE((PyArrayObject*) py_V439) != NPY_FLOAT64) { 22096 PyErr_Format(PyExc_TypeError, 22097 "expected type_num %d (NPY_FLOAT64) got %d", 22098 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V439)); 22099 { 22100 __failure = 440; 22101 if (!PyErr_Occurred()) { 22102 PyErr_SetString(PyExc_RuntimeError, 22103 "Unexpected error in an Op's C code. " 22104 "No Python exception was set."); 22105 } 22106 goto __label_440;} 22107 } 22108 22109 V439 = (PyArrayObject*)(py_V439); 22110 Py_XINCREF(V439); 22111 22112 { 22113 22114 py_V441 = PyList_GET_ITEM(storage_V441, 0); 22115 {Py_XINCREF(py_V441);} 22116 22117 V441 = NULL; 22118 if (py_V441 == Py_None) { 22119 // We can either fail here or set V441 to NULL and rely on Ops 22120 // using tensors to handle the NULL case, but if they fail to do so 22121 // they'll end up with nasty segfaults, so this is public service. 22122 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 22123 { 22124 __failure = 442; 22125 if (!PyErr_Occurred()) { 22126 PyErr_SetString(PyExc_RuntimeError, 22127 "Unexpected error in an Op's C code. " 22128 "No Python exception was set."); 22129 } 22130 goto __label_442;} 22131 } 22132 if (!PyArray_Check(py_V441)) { 22133 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 22134 { 22135 __failure = 442; 22136 if (!PyErr_Occurred()) { 22137 PyErr_SetString(PyExc_RuntimeError, 22138 "Unexpected error in an Op's C code. " 22139 "No Python exception was set."); 22140 } 22141 goto __label_442;} 22142 } 22143 // We expect NPY_FLOAT64 22144 if (!PyArray_ISALIGNED((PyArrayObject*) py_V441)) { 22145 PyArrayObject * tmp = (PyArrayObject*) py_V441; 22146 PyErr_Format(PyExc_NotImplementedError, 22147 "expected an aligned array of type %ld " 22148 "(NPY_FLOAT64), got non-aligned array of type %ld" 22149 " with %ld dimensions, with 3 last dims " 22150 "%ld, %ld, %ld" 22151 " and 3 last strides %ld %ld, %ld.", 22152 (long int) NPY_FLOAT64, 22153 (long int) PyArray_TYPE((PyArrayObject*) py_V441), 22154 (long int) PyArray_NDIM(tmp), 22155 (long int) PyArray_NDIM(tmp) >= 3 ? 22156 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 22157 (long int) PyArray_NDIM(tmp) >= 2 ? 22158 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 22159 (long int) PyArray_NDIM(tmp) >= 1 ? 22160 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 22161 (long int) PyArray_NDIM(tmp) >= 3 ? 22162 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 22163 (long int) PyArray_NDIM(tmp) >= 2 ? 22164 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 22165 (long int) PyArray_NDIM(tmp) >= 1 ? 22166 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 22167 ); 22168 { 22169 __failure = 442; 22170 if (!PyErr_Occurred()) { 22171 PyErr_SetString(PyExc_RuntimeError, 22172 "Unexpected error in an Op's C code. " 22173 "No Python exception was set."); 22174 } 22175 goto __label_442;} 22176 } 22177 // This is a TypeError to be consistent with DEBUG_MODE 22178 // Note: DEBUG_MODE also tells the name of the container 22179 if (PyArray_TYPE((PyArrayObject*) py_V441) != NPY_FLOAT64) { 22180 PyErr_Format(PyExc_TypeError, 22181 "expected type_num %d (NPY_FLOAT64) got %d", 22182 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V441)); 22183 { 22184 __failure = 442; 22185 if (!PyErr_Occurred()) { 22186 PyErr_SetString(PyExc_RuntimeError, 22187 "Unexpected error in an Op's C code. " 22188 "No Python exception was set."); 22189 } 22190 goto __label_442;} 22191 } 22192 22193 V441 = (PyArrayObject*)(py_V441); 22194 Py_XINCREF(V441); 22195 22196 { 22197 22198 py_V443 = PyList_GET_ITEM(storage_V443, 0); 22199 {Py_XINCREF(py_V443);} 22200 22201 V443 = NULL; 22202 if (py_V443 == Py_None) { 22203 // We can either fail here or set V443 to NULL and rely on Ops 22204 // using tensors to handle the NULL case, but if they fail to do so 22205 // they'll end up with nasty segfaults, so this is public service. 22206 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 22207 { 22208 __failure = 444; 22209 if (!PyErr_Occurred()) { 22210 PyErr_SetString(PyExc_RuntimeError, 22211 "Unexpected error in an Op's C code. " 22212 "No Python exception was set."); 22213 } 22214 goto __label_444;} 22215 } 22216 if (!PyArray_Check(py_V443)) { 22217 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 22218 { 22219 __failure = 444; 22220 if (!PyErr_Occurred()) { 22221 PyErr_SetString(PyExc_RuntimeError, 22222 "Unexpected error in an Op's C code. " 22223 "No Python exception was set."); 22224 } 22225 goto __label_444;} 22226 } 22227 // We expect NPY_FLOAT64 22228 if (!PyArray_ISALIGNED((PyArrayObject*) py_V443)) { 22229 PyArrayObject * tmp = (PyArrayObject*) py_V443; 22230 PyErr_Format(PyExc_NotImplementedError, 22231 "expected an aligned array of type %ld " 22232 "(NPY_FLOAT64), got non-aligned array of type %ld" 22233 " with %ld dimensions, with 3 last dims " 22234 "%ld, %ld, %ld" 22235 " and 3 last strides %ld %ld, %ld.", 22236 (long int) NPY_FLOAT64, 22237 (long int) PyArray_TYPE((PyArrayObject*) py_V443), 22238 (long int) PyArray_NDIM(tmp), 22239 (long int) PyArray_NDIM(tmp) >= 3 ? 22240 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 22241 (long int) PyArray_NDIM(tmp) >= 2 ? 22242 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 22243 (long int) PyArray_NDIM(tmp) >= 1 ? 22244 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 22245 (long int) PyArray_NDIM(tmp) >= 3 ? 22246 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 22247 (long int) PyArray_NDIM(tmp) >= 2 ? 22248 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 22249 (long int) PyArray_NDIM(tmp) >= 1 ? 22250 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 22251 ); 22252 { 22253 __failure = 444; 22254 if (!PyErr_Occurred()) { 22255 PyErr_SetString(PyExc_RuntimeError, 22256 "Unexpected error in an Op's C code. " 22257 "No Python exception was set."); 22258 } 22259 goto __label_444;} 22260 } 22261 // This is a TypeError to be consistent with DEBUG_MODE 22262 // Note: DEBUG_MODE also tells the name of the container 22263 if (PyArray_TYPE((PyArrayObject*) py_V443) != NPY_FLOAT64) { 22264 PyErr_Format(PyExc_TypeError, 22265 "expected type_num %d (NPY_FLOAT64) got %d", 22266 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V443)); 22267 { 22268 __failure = 444; 22269 if (!PyErr_Occurred()) { 22270 PyErr_SetString(PyExc_RuntimeError, 22271 "Unexpected error in an Op's C code. " 22272 "No Python exception was set."); 22273 } 22274 goto __label_444;} 22275 } 22276 22277 V443 = (PyArrayObject*)(py_V443); 22278 Py_XINCREF(V443); 22279 22280 { 22281 22282 py_V445 = PyList_GET_ITEM(storage_V445, 0); 22283 {Py_XINCREF(py_V445);} 22284 22285 V445 = NULL; 22286 if (py_V445 == Py_None) { 22287 // We can either fail here or set V445 to NULL and rely on Ops 22288 // using tensors to handle the NULL case, but if they fail to do so 22289 // they'll end up with nasty segfaults, so this is public service. 22290 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 22291 { 22292 __failure = 446; 22293 if (!PyErr_Occurred()) { 22294 PyErr_SetString(PyExc_RuntimeError, 22295 "Unexpected error in an Op's C code. " 22296 "No Python exception was set."); 22297 } 22298 goto __label_446;} 22299 } 22300 if (!PyArray_Check(py_V445)) { 22301 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 22302 { 22303 __failure = 446; 22304 if (!PyErr_Occurred()) { 22305 PyErr_SetString(PyExc_RuntimeError, 22306 "Unexpected error in an Op's C code. " 22307 "No Python exception was set."); 22308 } 22309 goto __label_446;} 22310 } 22311 // We expect NPY_FLOAT64 22312 if (!PyArray_ISALIGNED((PyArrayObject*) py_V445)) { 22313 PyArrayObject * tmp = (PyArrayObject*) py_V445; 22314 PyErr_Format(PyExc_NotImplementedError, 22315 "expected an aligned array of type %ld " 22316 "(NPY_FLOAT64), got non-aligned array of type %ld" 22317 " with %ld dimensions, with 3 last dims " 22318 "%ld, %ld, %ld" 22319 " and 3 last strides %ld %ld, %ld.", 22320 (long int) NPY_FLOAT64, 22321 (long int) PyArray_TYPE((PyArrayObject*) py_V445), 22322 (long int) PyArray_NDIM(tmp), 22323 (long int) PyArray_NDIM(tmp) >= 3 ? 22324 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 22325 (long int) PyArray_NDIM(tmp) >= 2 ? 22326 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 22327 (long int) PyArray_NDIM(tmp) >= 1 ? 22328 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 22329 (long int) PyArray_NDIM(tmp) >= 3 ? 22330 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 22331 (long int) PyArray_NDIM(tmp) >= 2 ? 22332 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 22333 (long int) PyArray_NDIM(tmp) >= 1 ? 22334 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 22335 ); 22336 { 22337 __failure = 446; 22338 if (!PyErr_Occurred()) { 22339 PyErr_SetString(PyExc_RuntimeError, 22340 "Unexpected error in an Op's C code. " 22341 "No Python exception was set."); 22342 } 22343 goto __label_446;} 22344 } 22345 // This is a TypeError to be consistent with DEBUG_MODE 22346 // Note: DEBUG_MODE also tells the name of the container 22347 if (PyArray_TYPE((PyArrayObject*) py_V445) != NPY_FLOAT64) { 22348 PyErr_Format(PyExc_TypeError, 22349 "expected type_num %d (NPY_FLOAT64) got %d", 22350 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V445)); 22351 { 22352 __failure = 446; 22353 if (!PyErr_Occurred()) { 22354 PyErr_SetString(PyExc_RuntimeError, 22355 "Unexpected error in an Op's C code. " 22356 "No Python exception was set."); 22357 } 22358 goto __label_446;} 22359 } 22360 22361 V445 = (PyArrayObject*)(py_V445); 22362 Py_XINCREF(V445); 22363 22364 { 22365 22366 py_V447 = PyList_GET_ITEM(storage_V447, 0); 22367 {Py_XINCREF(py_V447);} 22368 22369 V447 = NULL; 22370 if (py_V447 == Py_None) { 22371 // We can either fail here or set V447 to NULL and rely on Ops 22372 // using tensors to handle the NULL case, but if they fail to do so 22373 // they'll end up with nasty segfaults, so this is public service. 22374 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 22375 { 22376 __failure = 448; 22377 if (!PyErr_Occurred()) { 22378 PyErr_SetString(PyExc_RuntimeError, 22379 "Unexpected error in an Op's C code. " 22380 "No Python exception was set."); 22381 } 22382 goto __label_448;} 22383 } 22384 if (!PyArray_Check(py_V447)) { 22385 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 22386 { 22387 __failure = 448; 22388 if (!PyErr_Occurred()) { 22389 PyErr_SetString(PyExc_RuntimeError, 22390 "Unexpected error in an Op's C code. " 22391 "No Python exception was set."); 22392 } 22393 goto __label_448;} 22394 } 22395 // We expect NPY_FLOAT64 22396 if (!PyArray_ISALIGNED((PyArrayObject*) py_V447)) { 22397 PyArrayObject * tmp = (PyArrayObject*) py_V447; 22398 PyErr_Format(PyExc_NotImplementedError, 22399 "expected an aligned array of type %ld " 22400 "(NPY_FLOAT64), got non-aligned array of type %ld" 22401 " with %ld dimensions, with 3 last dims " 22402 "%ld, %ld, %ld" 22403 " and 3 last strides %ld %ld, %ld.", 22404 (long int) NPY_FLOAT64, 22405 (long int) PyArray_TYPE((PyArrayObject*) py_V447), 22406 (long int) PyArray_NDIM(tmp), 22407 (long int) PyArray_NDIM(tmp) >= 3 ? 22408 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 22409 (long int) PyArray_NDIM(tmp) >= 2 ? 22410 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 22411 (long int) PyArray_NDIM(tmp) >= 1 ? 22412 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 22413 (long int) PyArray_NDIM(tmp) >= 3 ? 22414 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 22415 (long int) PyArray_NDIM(tmp) >= 2 ? 22416 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 22417 (long int) PyArray_NDIM(tmp) >= 1 ? 22418 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 22419 ); 22420 { 22421 __failure = 448; 22422 if (!PyErr_Occurred()) { 22423 PyErr_SetString(PyExc_RuntimeError, 22424 "Unexpected error in an Op's C code. " 22425 "No Python exception was set."); 22426 } 22427 goto __label_448;} 22428 } 22429 // This is a TypeError to be consistent with DEBUG_MODE 22430 // Note: DEBUG_MODE also tells the name of the container 22431 if (PyArray_TYPE((PyArrayObject*) py_V447) != NPY_FLOAT64) { 22432 PyErr_Format(PyExc_TypeError, 22433 "expected type_num %d (NPY_FLOAT64) got %d", 22434 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V447)); 22435 { 22436 __failure = 448; 22437 if (!PyErr_Occurred()) { 22438 PyErr_SetString(PyExc_RuntimeError, 22439 "Unexpected error in an Op's C code. " 22440 "No Python exception was set."); 22441 } 22442 goto __label_448;} 22443 } 22444 22445 V447 = (PyArrayObject*)(py_V447); 22446 Py_XINCREF(V447); 22447 22448 { 22449 22450 py_V449 = PyList_GET_ITEM(storage_V449, 0); 22451 {Py_XINCREF(py_V449);} 22452 22453 V449 = NULL; 22454 if (py_V449 == Py_None) { 22455 // We can either fail here or set V449 to NULL and rely on Ops 22456 // using tensors to handle the NULL case, but if they fail to do so 22457 // they'll end up with nasty segfaults, so this is public service. 22458 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 22459 { 22460 __failure = 450; 22461 if (!PyErr_Occurred()) { 22462 PyErr_SetString(PyExc_RuntimeError, 22463 "Unexpected error in an Op's C code. " 22464 "No Python exception was set."); 22465 } 22466 goto __label_450;} 22467 } 22468 if (!PyArray_Check(py_V449)) { 22469 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 22470 { 22471 __failure = 450; 22472 if (!PyErr_Occurred()) { 22473 PyErr_SetString(PyExc_RuntimeError, 22474 "Unexpected error in an Op's C code. " 22475 "No Python exception was set."); 22476 } 22477 goto __label_450;} 22478 } 22479 // We expect NPY_FLOAT64 22480 if (!PyArray_ISALIGNED((PyArrayObject*) py_V449)) { 22481 PyArrayObject * tmp = (PyArrayObject*) py_V449; 22482 PyErr_Format(PyExc_NotImplementedError, 22483 "expected an aligned array of type %ld " 22484 "(NPY_FLOAT64), got non-aligned array of type %ld" 22485 " with %ld dimensions, with 3 last dims " 22486 "%ld, %ld, %ld" 22487 " and 3 last strides %ld %ld, %ld.", 22488 (long int) NPY_FLOAT64, 22489 (long int) PyArray_TYPE((PyArrayObject*) py_V449), 22490 (long int) PyArray_NDIM(tmp), 22491 (long int) PyArray_NDIM(tmp) >= 3 ? 22492 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 22493 (long int) PyArray_NDIM(tmp) >= 2 ? 22494 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 22495 (long int) PyArray_NDIM(tmp) >= 1 ? 22496 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 22497 (long int) PyArray_NDIM(tmp) >= 3 ? 22498 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 22499 (long int) PyArray_NDIM(tmp) >= 2 ? 22500 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 22501 (long int) PyArray_NDIM(tmp) >= 1 ? 22502 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 22503 ); 22504 { 22505 __failure = 450; 22506 if (!PyErr_Occurred()) { 22507 PyErr_SetString(PyExc_RuntimeError, 22508 "Unexpected error in an Op's C code. " 22509 "No Python exception was set."); 22510 } 22511 goto __label_450;} 22512 } 22513 // This is a TypeError to be consistent with DEBUG_MODE 22514 // Note: DEBUG_MODE also tells the name of the container 22515 if (PyArray_TYPE((PyArrayObject*) py_V449) != NPY_FLOAT64) { 22516 PyErr_Format(PyExc_TypeError, 22517 "expected type_num %d (NPY_FLOAT64) got %d", 22518 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V449)); 22519 { 22520 __failure = 450; 22521 if (!PyErr_Occurred()) { 22522 PyErr_SetString(PyExc_RuntimeError, 22523 "Unexpected error in an Op's C code. " 22524 "No Python exception was set."); 22525 } 22526 goto __label_450;} 22527 } 22528 22529 V449 = (PyArrayObject*)(py_V449); 22530 Py_XINCREF(V449); 22531 22532 { 22533 22534 py_V451 = PyList_GET_ITEM(storage_V451, 0); 22535 {Py_XINCREF(py_V451);} 22536 22537 V451 = NULL; 22538 if (py_V451 == Py_None) { 22539 // We can either fail here or set V451 to NULL and rely on Ops 22540 // using tensors to handle the NULL case, but if they fail to do so 22541 // they'll end up with nasty segfaults, so this is public service. 22542 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 22543 { 22544 __failure = 452; 22545 if (!PyErr_Occurred()) { 22546 PyErr_SetString(PyExc_RuntimeError, 22547 "Unexpected error in an Op's C code. " 22548 "No Python exception was set."); 22549 } 22550 goto __label_452;} 22551 } 22552 if (!PyArray_Check(py_V451)) { 22553 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 22554 { 22555 __failure = 452; 22556 if (!PyErr_Occurred()) { 22557 PyErr_SetString(PyExc_RuntimeError, 22558 "Unexpected error in an Op's C code. " 22559 "No Python exception was set."); 22560 } 22561 goto __label_452;} 22562 } 22563 // We expect NPY_FLOAT64 22564 if (!PyArray_ISALIGNED((PyArrayObject*) py_V451)) { 22565 PyArrayObject * tmp = (PyArrayObject*) py_V451; 22566 PyErr_Format(PyExc_NotImplementedError, 22567 "expected an aligned array of type %ld " 22568 "(NPY_FLOAT64), got non-aligned array of type %ld" 22569 " with %ld dimensions, with 3 last dims " 22570 "%ld, %ld, %ld" 22571 " and 3 last strides %ld %ld, %ld.", 22572 (long int) NPY_FLOAT64, 22573 (long int) PyArray_TYPE((PyArrayObject*) py_V451), 22574 (long int) PyArray_NDIM(tmp), 22575 (long int) PyArray_NDIM(tmp) >= 3 ? 22576 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 22577 (long int) PyArray_NDIM(tmp) >= 2 ? 22578 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 22579 (long int) PyArray_NDIM(tmp) >= 1 ? 22580 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 22581 (long int) PyArray_NDIM(tmp) >= 3 ? 22582 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 22583 (long int) PyArray_NDIM(tmp) >= 2 ? 22584 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 22585 (long int) PyArray_NDIM(tmp) >= 1 ? 22586 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 22587 ); 22588 { 22589 __failure = 452; 22590 if (!PyErr_Occurred()) { 22591 PyErr_SetString(PyExc_RuntimeError, 22592 "Unexpected error in an Op's C code. " 22593 "No Python exception was set."); 22594 } 22595 goto __label_452;} 22596 } 22597 // This is a TypeError to be consistent with DEBUG_MODE 22598 // Note: DEBUG_MODE also tells the name of the container 22599 if (PyArray_TYPE((PyArrayObject*) py_V451) != NPY_FLOAT64) { 22600 PyErr_Format(PyExc_TypeError, 22601 "expected type_num %d (NPY_FLOAT64) got %d", 22602 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V451)); 22603 { 22604 __failure = 452; 22605 if (!PyErr_Occurred()) { 22606 PyErr_SetString(PyExc_RuntimeError, 22607 "Unexpected error in an Op's C code. " 22608 "No Python exception was set."); 22609 } 22610 goto __label_452;} 22611 } 22612 22613 V451 = (PyArrayObject*)(py_V451); 22614 Py_XINCREF(V451); 22615 22616 { 22617 22618 py_V453 = PyList_GET_ITEM(storage_V453, 0); 22619 {Py_XINCREF(py_V453);} 22620 22621 V453 = NULL; 22622 if (py_V453 == Py_None) { 22623 // We can either fail here or set V453 to NULL and rely on Ops 22624 // using tensors to handle the NULL case, but if they fail to do so 22625 // they'll end up with nasty segfaults, so this is public service. 22626 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 22627 { 22628 __failure = 454; 22629 if (!PyErr_Occurred()) { 22630 PyErr_SetString(PyExc_RuntimeError, 22631 "Unexpected error in an Op's C code. " 22632 "No Python exception was set."); 22633 } 22634 goto __label_454;} 22635 } 22636 if (!PyArray_Check(py_V453)) { 22637 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 22638 { 22639 __failure = 454; 22640 if (!PyErr_Occurred()) { 22641 PyErr_SetString(PyExc_RuntimeError, 22642 "Unexpected error in an Op's C code. " 22643 "No Python exception was set."); 22644 } 22645 goto __label_454;} 22646 } 22647 // We expect NPY_INT8 22648 if (!PyArray_ISALIGNED((PyArrayObject*) py_V453)) { 22649 PyArrayObject * tmp = (PyArrayObject*) py_V453; 22650 PyErr_Format(PyExc_NotImplementedError, 22651 "expected an aligned array of type %ld " 22652 "(NPY_INT8), got non-aligned array of type %ld" 22653 " with %ld dimensions, with 3 last dims " 22654 "%ld, %ld, %ld" 22655 " and 3 last strides %ld %ld, %ld.", 22656 (long int) NPY_INT8, 22657 (long int) PyArray_TYPE((PyArrayObject*) py_V453), 22658 (long int) PyArray_NDIM(tmp), 22659 (long int) PyArray_NDIM(tmp) >= 3 ? 22660 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 22661 (long int) PyArray_NDIM(tmp) >= 2 ? 22662 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 22663 (long int) PyArray_NDIM(tmp) >= 1 ? 22664 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 22665 (long int) PyArray_NDIM(tmp) >= 3 ? 22666 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 22667 (long int) PyArray_NDIM(tmp) >= 2 ? 22668 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 22669 (long int) PyArray_NDIM(tmp) >= 1 ? 22670 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 22671 ); 22672 { 22673 __failure = 454; 22674 if (!PyErr_Occurred()) { 22675 PyErr_SetString(PyExc_RuntimeError, 22676 "Unexpected error in an Op's C code. " 22677 "No Python exception was set."); 22678 } 22679 goto __label_454;} 22680 } 22681 // This is a TypeError to be consistent with DEBUG_MODE 22682 // Note: DEBUG_MODE also tells the name of the container 22683 if (PyArray_TYPE((PyArrayObject*) py_V453) != NPY_INT8) { 22684 PyErr_Format(PyExc_TypeError, 22685 "expected type_num %d (NPY_INT8) got %d", 22686 NPY_INT8, PyArray_TYPE((PyArrayObject*) py_V453)); 22687 { 22688 __failure = 454; 22689 if (!PyErr_Occurred()) { 22690 PyErr_SetString(PyExc_RuntimeError, 22691 "Unexpected error in an Op's C code. " 22692 "No Python exception was set."); 22693 } 22694 goto __label_454;} 22695 } 22696 22697 V453 = (PyArrayObject*)(py_V453); 22698 Py_XINCREF(V453); 22699 22700 { 22701 22702 py_V455 = PyList_GET_ITEM(storage_V455, 0); 22703 {Py_XINCREF(py_V455);} 22704 22705 V455 = NULL; 22706 if (py_V455 == Py_None) { 22707 // We can either fail here or set V455 to NULL and rely on Ops 22708 // using tensors to handle the NULL case, but if they fail to do so 22709 // they'll end up with nasty segfaults, so this is public service. 22710 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 22711 { 22712 __failure = 456; 22713 if (!PyErr_Occurred()) { 22714 PyErr_SetString(PyExc_RuntimeError, 22715 "Unexpected error in an Op's C code. " 22716 "No Python exception was set."); 22717 } 22718 goto __label_456;} 22719 } 22720 if (!PyArray_Check(py_V455)) { 22721 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 22722 { 22723 __failure = 456; 22724 if (!PyErr_Occurred()) { 22725 PyErr_SetString(PyExc_RuntimeError, 22726 "Unexpected error in an Op's C code. " 22727 "No Python exception was set."); 22728 } 22729 goto __label_456;} 22730 } 22731 // We expect NPY_FLOAT64 22732 if (!PyArray_ISALIGNED((PyArrayObject*) py_V455)) { 22733 PyArrayObject * tmp = (PyArrayObject*) py_V455; 22734 PyErr_Format(PyExc_NotImplementedError, 22735 "expected an aligned array of type %ld " 22736 "(NPY_FLOAT64), got non-aligned array of type %ld" 22737 " with %ld dimensions, with 3 last dims " 22738 "%ld, %ld, %ld" 22739 " and 3 last strides %ld %ld, %ld.", 22740 (long int) NPY_FLOAT64, 22741 (long int) PyArray_TYPE((PyArrayObject*) py_V455), 22742 (long int) PyArray_NDIM(tmp), 22743 (long int) PyArray_NDIM(tmp) >= 3 ? 22744 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 22745 (long int) PyArray_NDIM(tmp) >= 2 ? 22746 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 22747 (long int) PyArray_NDIM(tmp) >= 1 ? 22748 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 22749 (long int) PyArray_NDIM(tmp) >= 3 ? 22750 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 22751 (long int) PyArray_NDIM(tmp) >= 2 ? 22752 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 22753 (long int) PyArray_NDIM(tmp) >= 1 ? 22754 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 22755 ); 22756 { 22757 __failure = 456; 22758 if (!PyErr_Occurred()) { 22759 PyErr_SetString(PyExc_RuntimeError, 22760 "Unexpected error in an Op's C code. " 22761 "No Python exception was set."); 22762 } 22763 goto __label_456;} 22764 } 22765 // This is a TypeError to be consistent with DEBUG_MODE 22766 // Note: DEBUG_MODE also tells the name of the container 22767 if (PyArray_TYPE((PyArrayObject*) py_V455) != NPY_FLOAT64) { 22768 PyErr_Format(PyExc_TypeError, 22769 "expected type_num %d (NPY_FLOAT64) got %d", 22770 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V455)); 22771 { 22772 __failure = 456; 22773 if (!PyErr_Occurred()) { 22774 PyErr_SetString(PyExc_RuntimeError, 22775 "Unexpected error in an Op's C code. " 22776 "No Python exception was set."); 22777 } 22778 goto __label_456;} 22779 } 22780 22781 V455 = (PyArrayObject*)(py_V455); 22782 Py_XINCREF(V455); 22783 22784 { 22785 22786 py_V457 = PyList_GET_ITEM(storage_V457, 0); 22787 {Py_XINCREF(py_V457);} 22788 22789 V457 = NULL; 22790 if (py_V457 == Py_None) { 22791 // We can either fail here or set V457 to NULL and rely on Ops 22792 // using tensors to handle the NULL case, but if they fail to do so 22793 // they'll end up with nasty segfaults, so this is public service. 22794 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 22795 { 22796 __failure = 458; 22797 if (!PyErr_Occurred()) { 22798 PyErr_SetString(PyExc_RuntimeError, 22799 "Unexpected error in an Op's C code. " 22800 "No Python exception was set."); 22801 } 22802 goto __label_458;} 22803 } 22804 if (!PyArray_Check(py_V457)) { 22805 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 22806 { 22807 __failure = 458; 22808 if (!PyErr_Occurred()) { 22809 PyErr_SetString(PyExc_RuntimeError, 22810 "Unexpected error in an Op's C code. " 22811 "No Python exception was set."); 22812 } 22813 goto __label_458;} 22814 } 22815 // We expect NPY_FLOAT64 22816 if (!PyArray_ISALIGNED((PyArrayObject*) py_V457)) { 22817 PyArrayObject * tmp = (PyArrayObject*) py_V457; 22818 PyErr_Format(PyExc_NotImplementedError, 22819 "expected an aligned array of type %ld " 22820 "(NPY_FLOAT64), got non-aligned array of type %ld" 22821 " with %ld dimensions, with 3 last dims " 22822 "%ld, %ld, %ld" 22823 " and 3 last strides %ld %ld, %ld.", 22824 (long int) NPY_FLOAT64, 22825 (long int) PyArray_TYPE((PyArrayObject*) py_V457), 22826 (long int) PyArray_NDIM(tmp), 22827 (long int) PyArray_NDIM(tmp) >= 3 ? 22828 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 22829 (long int) PyArray_NDIM(tmp) >= 2 ? 22830 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 22831 (long int) PyArray_NDIM(tmp) >= 1 ? 22832 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 22833 (long int) PyArray_NDIM(tmp) >= 3 ? 22834 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 22835 (long int) PyArray_NDIM(tmp) >= 2 ? 22836 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 22837 (long int) PyArray_NDIM(tmp) >= 1 ? 22838 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 22839 ); 22840 { 22841 __failure = 458; 22842 if (!PyErr_Occurred()) { 22843 PyErr_SetString(PyExc_RuntimeError, 22844 "Unexpected error in an Op's C code. " 22845 "No Python exception was set."); 22846 } 22847 goto __label_458;} 22848 } 22849 // This is a TypeError to be consistent with DEBUG_MODE 22850 // Note: DEBUG_MODE also tells the name of the container 22851 if (PyArray_TYPE((PyArrayObject*) py_V457) != NPY_FLOAT64) { 22852 PyErr_Format(PyExc_TypeError, 22853 "expected type_num %d (NPY_FLOAT64) got %d", 22854 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V457)); 22855 { 22856 __failure = 458; 22857 if (!PyErr_Occurred()) { 22858 PyErr_SetString(PyExc_RuntimeError, 22859 "Unexpected error in an Op's C code. " 22860 "No Python exception was set."); 22861 } 22862 goto __label_458;} 22863 } 22864 22865 V457 = (PyArrayObject*)(py_V457); 22866 Py_XINCREF(V457); 22867 22868 { 22869 22870 py_V459 = PyList_GET_ITEM(storage_V459, 0); 22871 {Py_XINCREF(py_V459);} 22872 22873 V459 = NULL; 22874 if (py_V459 == Py_None) { 22875 // We can either fail here or set V459 to NULL and rely on Ops 22876 // using tensors to handle the NULL case, but if they fail to do so 22877 // they'll end up with nasty segfaults, so this is public service. 22878 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 22879 { 22880 __failure = 460; 22881 if (!PyErr_Occurred()) { 22882 PyErr_SetString(PyExc_RuntimeError, 22883 "Unexpected error in an Op's C code. " 22884 "No Python exception was set."); 22885 } 22886 goto __label_460;} 22887 } 22888 if (!PyArray_Check(py_V459)) { 22889 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 22890 { 22891 __failure = 460; 22892 if (!PyErr_Occurred()) { 22893 PyErr_SetString(PyExc_RuntimeError, 22894 "Unexpected error in an Op's C code. " 22895 "No Python exception was set."); 22896 } 22897 goto __label_460;} 22898 } 22899 // We expect NPY_FLOAT64 22900 if (!PyArray_ISALIGNED((PyArrayObject*) py_V459)) { 22901 PyArrayObject * tmp = (PyArrayObject*) py_V459; 22902 PyErr_Format(PyExc_NotImplementedError, 22903 "expected an aligned array of type %ld " 22904 "(NPY_FLOAT64), got non-aligned array of type %ld" 22905 " with %ld dimensions, with 3 last dims " 22906 "%ld, %ld, %ld" 22907 " and 3 last strides %ld %ld, %ld.", 22908 (long int) NPY_FLOAT64, 22909 (long int) PyArray_TYPE((PyArrayObject*) py_V459), 22910 (long int) PyArray_NDIM(tmp), 22911 (long int) PyArray_NDIM(tmp) >= 3 ? 22912 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 22913 (long int) PyArray_NDIM(tmp) >= 2 ? 22914 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 22915 (long int) PyArray_NDIM(tmp) >= 1 ? 22916 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 22917 (long int) PyArray_NDIM(tmp) >= 3 ? 22918 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 22919 (long int) PyArray_NDIM(tmp) >= 2 ? 22920 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 22921 (long int) PyArray_NDIM(tmp) >= 1 ? 22922 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 22923 ); 22924 { 22925 __failure = 460;
=============================== /Users/fonnescj/.theano/compiledir_Darwin-15.3.0-x86_64-i386-64bit-i386-3.5.1-64/tmpa5z86zdw/mod.cpp:24729:32: fatal error: bracket nesting level exceeded maximum of 256 if (!PyErr_Occurred()) { ^ /Users/fonnescj/.theano/compiledir_Darwin-15.3.0-x86_64-i386-64bit-i386-3.5.1-64/tmpa5z86zdw/mod.cpp:24729:32: note: use -fbracket-depth=N to increase maximum nesting level 1 error generated.
22926 if (!PyErr_Occurred()) { 22927 PyErr_SetString(PyExc_RuntimeError, 22928 "Unexpected error in an Op's C code. " 22929 "No Python exception was set."); 22930 } 22931 goto __label_460;} 22932 } 22933 // This is a TypeError to be consistent with DEBUG_MODE 22934 // Note: DEBUG_MODE also tells the name of the container 22935 if (PyArray_TYPE((PyArrayObject*) py_V459) != NPY_FLOAT64) { 22936 PyErr_Format(PyExc_TypeError, 22937 "expected type_num %d (NPY_FLOAT64) got %d", 22938 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V459)); 22939 { 22940 __failure = 460; 22941 if (!PyErr_Occurred()) { 22942 PyErr_SetString(PyExc_RuntimeError, 22943 "Unexpected error in an Op's C code. " 22944 "No Python exception was set."); 22945 } 22946 goto __label_460;} 22947 } 22948 22949 V459 = (PyArrayObject*)(py_V459); 22950 Py_XINCREF(V459); 22951 22952 { 22953 22954 py_V461 = PyList_GET_ITEM(storage_V461, 0); 22955 {Py_XINCREF(py_V461);} 22956 22957 V461 = NULL; 22958 if (py_V461 == Py_None) { 22959 // We can either fail here or set V461 to NULL and rely on Ops 22960 // using tensors to handle the NULL case, but if they fail to do so 22961 // they'll end up with nasty segfaults, so this is public service. 22962 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 22963 { 22964 __failure = 462; 22965 if (!PyErr_Occurred()) { 22966 PyErr_SetString(PyExc_RuntimeError, 22967 "Unexpected error in an Op's C code. " 22968 "No Python exception was set."); 22969 } 22970 goto __label_462;} 22971 } 22972 if (!PyArray_Check(py_V461)) { 22973 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 22974 { 22975 __failure = 462; 22976 if (!PyErr_Occurred()) { 22977 PyErr_SetString(PyExc_RuntimeError, 22978 "Unexpected error in an Op's C code. " 22979 "No Python exception was set."); 22980 } 22981 goto __label_462;} 22982 } 22983 // We expect NPY_FLOAT64 22984 if (!PyArray_ISALIGNED((PyArrayObject*) py_V461)) { 22985 PyArrayObject * tmp = (PyArrayObject*) py_V461; 22986 PyErr_Format(PyExc_NotImplementedError, 22987 "expected an aligned array of type %ld " 22988 "(NPY_FLOAT64), got non-aligned array of type %ld" 22989 " with %ld dimensions, with 3 last dims " 22990 "%ld, %ld, %ld" 22991 " and 3 last strides %ld %ld, %ld.", 22992 (long int) NPY_FLOAT64, 22993 (long int) PyArray_TYPE((PyArrayObject*) py_V461), 22994 (long int) PyArray_NDIM(tmp), 22995 (long int) PyArray_NDIM(tmp) >= 3 ? 22996 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 22997 (long int) PyArray_NDIM(tmp) >= 2 ? 22998 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 22999 (long int) PyArray_NDIM(tmp) >= 1 ? 23000 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 23001 (long int) PyArray_NDIM(tmp) >= 3 ? 23002 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 23003 (long int) PyArray_NDIM(tmp) >= 2 ? 23004 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 23005 (long int) PyArray_NDIM(tmp) >= 1 ? 23006 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 23007 ); 23008 { 23009 __failure = 462; 23010 if (!PyErr_Occurred()) { 23011 PyErr_SetString(PyExc_RuntimeError, 23012 "Unexpected error in an Op's C code. " 23013 "No Python exception was set."); 23014 } 23015 goto __label_462;} 23016 } 23017 // This is a TypeError to be consistent with DEBUG_MODE 23018 // Note: DEBUG_MODE also tells the name of the container 23019 if (PyArray_TYPE((PyArrayObject*) py_V461) != NPY_FLOAT64) { 23020 PyErr_Format(PyExc_TypeError, 23021 "expected type_num %d (NPY_FLOAT64) got %d", 23022 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V461)); 23023 { 23024 __failure = 462; 23025 if (!PyErr_Occurred()) { 23026 PyErr_SetString(PyExc_RuntimeError, 23027 "Unexpected error in an Op's C code. " 23028 "No Python exception was set."); 23029 } 23030 goto __label_462;} 23031 } 23032 23033 V461 = (PyArrayObject*)(py_V461); 23034 Py_XINCREF(V461); 23035 23036 { 23037 23038 py_V463 = PyList_GET_ITEM(storage_V463, 0); 23039 {Py_XINCREF(py_V463);} 23040 23041 V463 = NULL; 23042 if (py_V463 == Py_None) { 23043 // We can either fail here or set V463 to NULL and rely on Ops 23044 // using tensors to handle the NULL case, but if they fail to do so 23045 // they'll end up with nasty segfaults, so this is public service. 23046 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 23047 { 23048 __failure = 464; 23049 if (!PyErr_Occurred()) { 23050 PyErr_SetString(PyExc_RuntimeError, 23051 "Unexpected error in an Op's C code. " 23052 "No Python exception was set."); 23053 } 23054 goto __label_464;} 23055 } 23056 if (!PyArray_Check(py_V463)) { 23057 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 23058 { 23059 __failure = 464; 23060 if (!PyErr_Occurred()) { 23061 PyErr_SetString(PyExc_RuntimeError, 23062 "Unexpected error in an Op's C code. " 23063 "No Python exception was set."); 23064 } 23065 goto __label_464;} 23066 } 23067 // We expect NPY_FLOAT64 23068 if (!PyArray_ISALIGNED((PyArrayObject*) py_V463)) { 23069 PyArrayObject * tmp = (PyArrayObject*) py_V463; 23070 PyErr_Format(PyExc_NotImplementedError, 23071 "expected an aligned array of type %ld " 23072 "(NPY_FLOAT64), got non-aligned array of type %ld" 23073 " with %ld dimensions, with 3 last dims " 23074 "%ld, %ld, %ld" 23075 " and 3 last strides %ld %ld, %ld.", 23076 (long int) NPY_FLOAT64, 23077 (long int) PyArray_TYPE((PyArrayObject*) py_V463), 23078 (long int) PyArray_NDIM(tmp), 23079 (long int) PyArray_NDIM(tmp) >= 3 ? 23080 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 23081 (long int) PyArray_NDIM(tmp) >= 2 ? 23082 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 23083 (long int) PyArray_NDIM(tmp) >= 1 ? 23084 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 23085 (long int) PyArray_NDIM(tmp) >= 3 ? 23086 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 23087 (long int) PyArray_NDIM(tmp) >= 2 ? 23088 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 23089 (long int) PyArray_NDIM(tmp) >= 1 ? 23090 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 23091 ); 23092 { 23093 __failure = 464; 23094 if (!PyErr_Occurred()) { 23095 PyErr_SetString(PyExc_RuntimeError, 23096 "Unexpected error in an Op's C code. " 23097 "No Python exception was set."); 23098 } 23099 goto __label_464;} 23100 } 23101 // This is a TypeError to be consistent with DEBUG_MODE 23102 // Note: DEBUG_MODE also tells the name of the container 23103 if (PyArray_TYPE((PyArrayObject*) py_V463) != NPY_FLOAT64) { 23104 PyErr_Format(PyExc_TypeError, 23105 "expected type_num %d (NPY_FLOAT64) got %d", 23106 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V463)); 23107 { 23108 __failure = 464; 23109 if (!PyErr_Occurred()) { 23110 PyErr_SetString(PyExc_RuntimeError, 23111 "Unexpected error in an Op's C code. " 23112 "No Python exception was set."); 23113 } 23114 goto __label_464;} 23115 } 23116 23117 V463 = (PyArrayObject*)(py_V463); 23118 Py_XINCREF(V463); 23119 23120 { 23121 23122 py_V465 = PyList_GET_ITEM(storage_V465, 0); 23123 {Py_XINCREF(py_V465);} 23124 23125 V465 = NULL; 23126 if (py_V465 == Py_None) { 23127 // We can either fail here or set V465 to NULL and rely on Ops 23128 // using tensors to handle the NULL case, but if they fail to do so 23129 // they'll end up with nasty segfaults, so this is public service. 23130 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 23131 { 23132 __failure = 466; 23133 if (!PyErr_Occurred()) { 23134 PyErr_SetString(PyExc_RuntimeError, 23135 "Unexpected error in an Op's C code. " 23136 "No Python exception was set."); 23137 } 23138 goto __label_466;} 23139 } 23140 if (!PyArray_Check(py_V465)) { 23141 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 23142 { 23143 __failure = 466; 23144 if (!PyErr_Occurred()) { 23145 PyErr_SetString(PyExc_RuntimeError, 23146 "Unexpected error in an Op's C code. " 23147 "No Python exception was set."); 23148 } 23149 goto __label_466;} 23150 } 23151 // We expect NPY_FLOAT64 23152 if (!PyArray_ISALIGNED((PyArrayObject*) py_V465)) { 23153 PyArrayObject * tmp = (PyArrayObject*) py_V465; 23154 PyErr_Format(PyExc_NotImplementedError, 23155 "expected an aligned array of type %ld " 23156 "(NPY_FLOAT64), got non-aligned array of type %ld" 23157 " with %ld dimensions, with 3 last dims " 23158 "%ld, %ld, %ld" 23159 " and 3 last strides %ld %ld, %ld.", 23160 (long int) NPY_FLOAT64, 23161 (long int) PyArray_TYPE((PyArrayObject*) py_V465), 23162 (long int) PyArray_NDIM(tmp), 23163 (long int) PyArray_NDIM(tmp) >= 3 ? 23164 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 23165 (long int) PyArray_NDIM(tmp) >= 2 ? 23166 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 23167 (long int) PyArray_NDIM(tmp) >= 1 ? 23168 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 23169 (long int) PyArray_NDIM(tmp) >= 3 ? 23170 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 23171 (long int) PyArray_NDIM(tmp) >= 2 ? 23172 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 23173 (long int) PyArray_NDIM(tmp) >= 1 ? 23174 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 23175 ); 23176 { 23177 __failure = 466; 23178 if (!PyErr_Occurred()) { 23179 PyErr_SetString(PyExc_RuntimeError, 23180 "Unexpected error in an Op's C code. " 23181 "No Python exception was set."); 23182 } 23183 goto __label_466;} 23184 } 23185 // This is a TypeError to be consistent with DEBUG_MODE 23186 // Note: DEBUG_MODE also tells the name of the container 23187 if (PyArray_TYPE((PyArrayObject*) py_V465) != NPY_FLOAT64) { 23188 PyErr_Format(PyExc_TypeError, 23189 "expected type_num %d (NPY_FLOAT64) got %d", 23190 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V465)); 23191 { 23192 __failure = 466; 23193 if (!PyErr_Occurred()) { 23194 PyErr_SetString(PyExc_RuntimeError, 23195 "Unexpected error in an Op's C code. " 23196 "No Python exception was set."); 23197 } 23198 goto __label_466;} 23199 } 23200 23201 V465 = (PyArrayObject*)(py_V465); 23202 Py_XINCREF(V465); 23203 23204 { 23205 23206 py_V467 = PyList_GET_ITEM(storage_V467, 0); 23207 {Py_XINCREF(py_V467);} 23208 23209 V467 = NULL; 23210 if (py_V467 == Py_None) { 23211 // We can either fail here or set V467 to NULL and rely on Ops 23212 // using tensors to handle the NULL case, but if they fail to do so 23213 // they'll end up with nasty segfaults, so this is public service. 23214 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 23215 { 23216 __failure = 468; 23217 if (!PyErr_Occurred()) { 23218 PyErr_SetString(PyExc_RuntimeError, 23219 "Unexpected error in an Op's C code. " 23220 "No Python exception was set."); 23221 } 23222 goto __label_468;} 23223 } 23224 if (!PyArray_Check(py_V467)) { 23225 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 23226 { 23227 __failure = 468; 23228 if (!PyErr_Occurred()) { 23229 PyErr_SetString(PyExc_RuntimeError, 23230 "Unexpected error in an Op's C code. " 23231 "No Python exception was set."); 23232 } 23233 goto __label_468;} 23234 } 23235 // We expect NPY_INT8 23236 if (!PyArray_ISALIGNED((PyArrayObject*) py_V467)) { 23237 PyArrayObject * tmp = (PyArrayObject*) py_V467; 23238 PyErr_Format(PyExc_NotImplementedError, 23239 "expected an aligned array of type %ld " 23240 "(NPY_INT8), got non-aligned array of type %ld" 23241 " with %ld dimensions, with 3 last dims " 23242 "%ld, %ld, %ld" 23243 " and 3 last strides %ld %ld, %ld.", 23244 (long int) NPY_INT8, 23245 (long int) PyArray_TYPE((PyArrayObject*) py_V467), 23246 (long int) PyArray_NDIM(tmp), 23247 (long int) PyArray_NDIM(tmp) >= 3 ? 23248 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 23249 (long int) PyArray_NDIM(tmp) >= 2 ? 23250 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 23251 (long int) PyArray_NDIM(tmp) >= 1 ? 23252 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 23253 (long int) PyArray_NDIM(tmp) >= 3 ? 23254 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 23255 (long int) PyArray_NDIM(tmp) >= 2 ? 23256 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 23257 (long int) PyArray_NDIM(tmp) >= 1 ? 23258 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 23259 ); 23260 { 23261 __failure = 468; 23262 if (!PyErr_Occurred()) { 23263 PyErr_SetString(PyExc_RuntimeError, 23264 "Unexpected error in an Op's C code. " 23265 "No Python exception was set."); 23266 } 23267 goto __label_468;} 23268 } 23269 // This is a TypeError to be consistent with DEBUG_MODE 23270 // Note: DEBUG_MODE also tells the name of the container 23271 if (PyArray_TYPE((PyArrayObject*) py_V467) != NPY_INT8) { 23272 PyErr_Format(PyExc_TypeError, 23273 "expected type_num %d (NPY_INT8) got %d", 23274 NPY_INT8, PyArray_TYPE((PyArrayObject*) py_V467)); 23275 { 23276 __failure = 468; 23277 if (!PyErr_Occurred()) { 23278 PyErr_SetString(PyExc_RuntimeError, 23279 "Unexpected error in an Op's C code. " 23280 "No Python exception was set."); 23281 } 23282 goto __label_468;} 23283 } 23284 23285 V467 = (PyArrayObject*)(py_V467); 23286 Py_XINCREF(V467); 23287 23288 { 23289 23290 py_V469 = PyList_GET_ITEM(storage_V469, 0); 23291 {Py_XINCREF(py_V469);} 23292 23293 V469 = NULL; 23294 if (py_V469 == Py_None) { 23295 // We can either fail here or set V469 to NULL and rely on Ops 23296 // using tensors to handle the NULL case, but if they fail to do so 23297 // they'll end up with nasty segfaults, so this is public service. 23298 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 23299 { 23300 __failure = 470; 23301 if (!PyErr_Occurred()) { 23302 PyErr_SetString(PyExc_RuntimeError, 23303 "Unexpected error in an Op's C code. " 23304 "No Python exception was set."); 23305 } 23306 goto __label_470;} 23307 } 23308 if (!PyArray_Check(py_V469)) { 23309 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 23310 { 23311 __failure = 470; 23312 if (!PyErr_Occurred()) { 23313 PyErr_SetString(PyExc_RuntimeError, 23314 "Unexpected error in an Op's C code. " 23315 "No Python exception was set."); 23316 } 23317 goto __label_470;} 23318 } 23319 // We expect NPY_FLOAT64 23320 if (!PyArray_ISALIGNED((PyArrayObject*) py_V469)) { 23321 PyArrayObject * tmp = (PyArrayObject*) py_V469; 23322 PyErr_Format(PyExc_NotImplementedError, 23323 "expected an aligned array of type %ld " 23324 "(NPY_FLOAT64), got non-aligned array of type %ld" 23325 " with %ld dimensions, with 3 last dims " 23326 "%ld, %ld, %ld" 23327 " and 3 last strides %ld %ld, %ld.", 23328 (long int) NPY_FLOAT64, 23329 (long int) PyArray_TYPE((PyArrayObject*) py_V469), 23330 (long int) PyArray_NDIM(tmp), 23331 (long int) PyArray_NDIM(tmp) >= 3 ? 23332 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 23333 (long int) PyArray_NDIM(tmp) >= 2 ? 23334 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 23335 (long int) PyArray_NDIM(tmp) >= 1 ? 23336 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 23337 (long int) PyArray_NDIM(tmp) >= 3 ? 23338 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 23339 (long int) PyArray_NDIM(tmp) >= 2 ? 23340 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 23341 (long int) PyArray_NDIM(tmp) >= 1 ? 23342 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 23343 ); 23344 { 23345 __failure = 470; 23346 if (!PyErr_Occurred()) { 23347 PyErr_SetString(PyExc_RuntimeError, 23348 "Unexpected error in an Op's C code. " 23349 "No Python exception was set."); 23350 } 23351 goto __label_470;} 23352 } 23353 // This is a TypeError to be consistent with DEBUG_MODE 23354 // Note: DEBUG_MODE also tells the name of the container 23355 if (PyArray_TYPE((PyArrayObject*) py_V469) != NPY_FLOAT64) { 23356 PyErr_Format(PyExc_TypeError, 23357 "expected type_num %d (NPY_FLOAT64) got %d", 23358 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V469)); 23359 { 23360 __failure = 470; 23361 if (!PyErr_Occurred()) { 23362 PyErr_SetString(PyExc_RuntimeError, 23363 "Unexpected error in an Op's C code. " 23364 "No Python exception was set."); 23365 } 23366 goto __label_470;} 23367 } 23368 23369 V469 = (PyArrayObject*)(py_V469); 23370 Py_XINCREF(V469); 23371 23372 { 23373 23374 py_V471 = PyList_GET_ITEM(storage_V471, 0); 23375 {Py_XINCREF(py_V471);} 23376 23377 V471 = NULL; 23378 if (py_V471 == Py_None) { 23379 // We can either fail here or set V471 to NULL and rely on Ops 23380 // using tensors to handle the NULL case, but if they fail to do so 23381 // they'll end up with nasty segfaults, so this is public service. 23382 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 23383 { 23384 __failure = 472; 23385 if (!PyErr_Occurred()) { 23386 PyErr_SetString(PyExc_RuntimeError, 23387 "Unexpected error in an Op's C code. " 23388 "No Python exception was set."); 23389 } 23390 goto __label_472;} 23391 } 23392 if (!PyArray_Check(py_V471)) { 23393 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 23394 { 23395 __failure = 472; 23396 if (!PyErr_Occurred()) { 23397 PyErr_SetString(PyExc_RuntimeError, 23398 "Unexpected error in an Op's C code. " 23399 "No Python exception was set."); 23400 } 23401 goto __label_472;} 23402 } 23403 // We expect NPY_FLOAT64 23404 if (!PyArray_ISALIGNED((PyArrayObject*) py_V471)) { 23405 PyArrayObject * tmp = (PyArrayObject*) py_V471; 23406 PyErr_Format(PyExc_NotImplementedError, 23407 "expected an aligned array of type %ld " 23408 "(NPY_FLOAT64), got non-aligned array of type %ld" 23409 " with %ld dimensions, with 3 last dims " 23410 "%ld, %ld, %ld" 23411 " and 3 last strides %ld %ld, %ld.", 23412 (long int) NPY_FLOAT64, 23413 (long int) PyArray_TYPE((PyArrayObject*) py_V471), 23414 (long int) PyArray_NDIM(tmp), 23415 (long int) PyArray_NDIM(tmp) >= 3 ? 23416 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 23417 (long int) PyArray_NDIM(tmp) >= 2 ? 23418 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 23419 (long int) PyArray_NDIM(tmp) >= 1 ? 23420 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 23421 (long int) PyArray_NDIM(tmp) >= 3 ? 23422 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 23423 (long int) PyArray_NDIM(tmp) >= 2 ? 23424 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 23425 (long int) PyArray_NDIM(tmp) >= 1 ? 23426 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 23427 ); 23428 { 23429 __failure = 472; 23430 if (!PyErr_Occurred()) { 23431 PyErr_SetString(PyExc_RuntimeError, 23432 "Unexpected error in an Op's C code. " 23433 "No Python exception was set."); 23434 } 23435 goto __label_472;} 23436 } 23437 // This is a TypeError to be consistent with DEBUG_MODE 23438 // Note: DEBUG_MODE also tells the name of the container 23439 if (PyArray_TYPE((PyArrayObject*) py_V471) != NPY_FLOAT64) { 23440 PyErr_Format(PyExc_TypeError, 23441 "expected type_num %d (NPY_FLOAT64) got %d", 23442 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V471)); 23443 { 23444 __failure = 472; 23445 if (!PyErr_Occurred()) { 23446 PyErr_SetString(PyExc_RuntimeError, 23447 "Unexpected error in an Op's C code. " 23448 "No Python exception was set."); 23449 } 23450 goto __label_472;} 23451 } 23452 23453 V471 = (PyArrayObject*)(py_V471); 23454 Py_XINCREF(V471); 23455 23456 { 23457 23458 py_V473 = PyList_GET_ITEM(storage_V473, 0); 23459 {Py_XINCREF(py_V473);} 23460 23461 V473 = NULL; 23462 if (py_V473 == Py_None) { 23463 // We can either fail here or set V473 to NULL and rely on Ops 23464 // using tensors to handle the NULL case, but if they fail to do so 23465 // they'll end up with nasty segfaults, so this is public service. 23466 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 23467 { 23468 __failure = 474; 23469 if (!PyErr_Occurred()) { 23470 PyErr_SetString(PyExc_RuntimeError, 23471 "Unexpected error in an Op's C code. " 23472 "No Python exception was set."); 23473 } 23474 goto __label_474;} 23475 } 23476 if (!PyArray_Check(py_V473)) { 23477 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 23478 { 23479 __failure = 474; 23480 if (!PyErr_Occurred()) { 23481 PyErr_SetString(PyExc_RuntimeError, 23482 "Unexpected error in an Op's C code. " 23483 "No Python exception was set."); 23484 } 23485 goto __label_474;} 23486 } 23487 // We expect NPY_FLOAT64 23488 if (!PyArray_ISALIGNED((PyArrayObject*) py_V473)) { 23489 PyArrayObject * tmp = (PyArrayObject*) py_V473; 23490 PyErr_Format(PyExc_NotImplementedError, 23491 "expected an aligned array of type %ld " 23492 "(NPY_FLOAT64), got non-aligned array of type %ld" 23493 " with %ld dimensions, with 3 last dims " 23494 "%ld, %ld, %ld" 23495 " and 3 last strides %ld %ld, %ld.", 23496 (long int) NPY_FLOAT64, 23497 (long int) PyArray_TYPE((PyArrayObject*) py_V473), 23498 (long int) PyArray_NDIM(tmp), 23499 (long int) PyArray_NDIM(tmp) >= 3 ? 23500 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 23501 (long int) PyArray_NDIM(tmp) >= 2 ? 23502 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 23503 (long int) PyArray_NDIM(tmp) >= 1 ? 23504 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 23505 (long int) PyArray_NDIM(tmp) >= 3 ? 23506 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 23507 (long int) PyArray_NDIM(tmp) >= 2 ? 23508 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 23509 (long int) PyArray_NDIM(tmp) >= 1 ? 23510 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 23511 ); 23512 { 23513 __failure = 474; 23514 if (!PyErr_Occurred()) { 23515 PyErr_SetString(PyExc_RuntimeError, 23516 "Unexpected error in an Op's C code. " 23517 "No Python exception was set."); 23518 } 23519 goto __label_474;} 23520 } 23521 // This is a TypeError to be consistent with DEBUG_MODE 23522 // Note: DEBUG_MODE also tells the name of the container 23523 if (PyArray_TYPE((PyArrayObject*) py_V473) != NPY_FLOAT64) { 23524 PyErr_Format(PyExc_TypeError, 23525 "expected type_num %d (NPY_FLOAT64) got %d", 23526 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V473)); 23527 { 23528 __failure = 474; 23529 if (!PyErr_Occurred()) { 23530 PyErr_SetString(PyExc_RuntimeError, 23531 "Unexpected error in an Op's C code. " 23532 "No Python exception was set."); 23533 } 23534 goto __label_474;} 23535 } 23536 23537 V473 = (PyArrayObject*)(py_V473); 23538 Py_XINCREF(V473); 23539 23540 { 23541 23542 py_V475 = PyList_GET_ITEM(storage_V475, 0); 23543 {Py_XINCREF(py_V475);} 23544 23545 V475 = NULL; 23546 if (py_V475 == Py_None) { 23547 // We can either fail here or set V475 to NULL and rely on Ops 23548 // using tensors to handle the NULL case, but if they fail to do so 23549 // they'll end up with nasty segfaults, so this is public service. 23550 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 23551 { 23552 __failure = 476; 23553 if (!PyErr_Occurred()) { 23554 PyErr_SetString(PyExc_RuntimeError, 23555 "Unexpected error in an Op's C code. " 23556 "No Python exception was set."); 23557 } 23558 goto __label_476;} 23559 } 23560 if (!PyArray_Check(py_V475)) { 23561 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 23562 { 23563 __failure = 476; 23564 if (!PyErr_Occurred()) { 23565 PyErr_SetString(PyExc_RuntimeError, 23566 "Unexpected error in an Op's C code. " 23567 "No Python exception was set."); 23568 } 23569 goto __label_476;} 23570 } 23571 // We expect NPY_FLOAT64 23572 if (!PyArray_ISALIGNED((PyArrayObject*) py_V475)) { 23573 PyArrayObject * tmp = (PyArrayObject*) py_V475; 23574 PyErr_Format(PyExc_NotImplementedError, 23575 "expected an aligned array of type %ld " 23576 "(NPY_FLOAT64), got non-aligned array of type %ld" 23577 " with %ld dimensions, with 3 last dims " 23578 "%ld, %ld, %ld" 23579 " and 3 last strides %ld %ld, %ld.", 23580 (long int) NPY_FLOAT64, 23581 (long int) PyArray_TYPE((PyArrayObject*) py_V475), 23582 (long int) PyArray_NDIM(tmp), 23583 (long int) PyArray_NDIM(tmp) >= 3 ? 23584 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 23585 (long int) PyArray_NDIM(tmp) >= 2 ? 23586 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 23587 (long int) PyArray_NDIM(tmp) >= 1 ? 23588 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 23589 (long int) PyArray_NDIM(tmp) >= 3 ? 23590 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 23591 (long int) PyArray_NDIM(tmp) >= 2 ? 23592 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 23593 (long int) PyArray_NDIM(tmp) >= 1 ? 23594 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 23595 ); 23596 { 23597 __failure = 476; 23598 if (!PyErr_Occurred()) { 23599 PyErr_SetString(PyExc_RuntimeError, 23600 "Unexpected error in an Op's C code. " 23601 "No Python exception was set."); 23602 } 23603 goto __label_476;} 23604 } 23605 // This is a TypeError to be consistent with DEBUG_MODE 23606 // Note: DEBUG_MODE also tells the name of the container 23607 if (PyArray_TYPE((PyArrayObject*) py_V475) != NPY_FLOAT64) { 23608 PyErr_Format(PyExc_TypeError, 23609 "expected type_num %d (NPY_FLOAT64) got %d", 23610 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V475)); 23611 { 23612 __failure = 476; 23613 if (!PyErr_Occurred()) { 23614 PyErr_SetString(PyExc_RuntimeError, 23615 "Unexpected error in an Op's C code. " 23616 "No Python exception was set."); 23617 } 23618 goto __label_476;} 23619 } 23620 23621 V475 = (PyArrayObject*)(py_V475); 23622 Py_XINCREF(V475); 23623 23624 { 23625 23626 py_V477 = PyList_GET_ITEM(storage_V477, 0); 23627 {Py_XINCREF(py_V477);} 23628 23629 V477 = NULL; 23630 if (py_V477 == Py_None) { 23631 // We can either fail here or set V477 to NULL and rely on Ops 23632 // using tensors to handle the NULL case, but if they fail to do so 23633 // they'll end up with nasty segfaults, so this is public service. 23634 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 23635 { 23636 __failure = 478; 23637 if (!PyErr_Occurred()) { 23638 PyErr_SetString(PyExc_RuntimeError, 23639 "Unexpected error in an Op's C code. " 23640 "No Python exception was set."); 23641 } 23642 goto __label_478;} 23643 } 23644 if (!PyArray_Check(py_V477)) { 23645 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 23646 { 23647 __failure = 478; 23648 if (!PyErr_Occurred()) { 23649 PyErr_SetString(PyExc_RuntimeError, 23650 "Unexpected error in an Op's C code. " 23651 "No Python exception was set."); 23652 } 23653 goto __label_478;} 23654 } 23655 // We expect NPY_FLOAT64 23656 if (!PyArray_ISALIGNED((PyArrayObject*) py_V477)) { 23657 PyArrayObject * tmp = (PyArrayObject*) py_V477; 23658 PyErr_Format(PyExc_NotImplementedError, 23659 "expected an aligned array of type %ld " 23660 "(NPY_FLOAT64), got non-aligned array of type %ld" 23661 " with %ld dimensions, with 3 last dims " 23662 "%ld, %ld, %ld" 23663 " and 3 last strides %ld %ld, %ld.", 23664 (long int) NPY_FLOAT64, 23665 (long int) PyArray_TYPE((PyArrayObject*) py_V477), 23666 (long int) PyArray_NDIM(tmp), 23667 (long int) PyArray_NDIM(tmp) >= 3 ? 23668 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 23669 (long int) PyArray_NDIM(tmp) >= 2 ? 23670 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 23671 (long int) PyArray_NDIM(tmp) >= 1 ? 23672 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 23673 (long int) PyArray_NDIM(tmp) >= 3 ? 23674 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 23675 (long int) PyArray_NDIM(tmp) >= 2 ? 23676 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 23677 (long int) PyArray_NDIM(tmp) >= 1 ? 23678 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 23679 ); 23680 { 23681 __failure = 478; 23682 if (!PyErr_Occurred()) { 23683 PyErr_SetString(PyExc_RuntimeError, 23684 "Unexpected error in an Op's C code. " 23685 "No Python exception was set."); 23686 } 23687 goto __label_478;} 23688 } 23689 // This is a TypeError to be consistent with DEBUG_MODE 23690 // Note: DEBUG_MODE also tells the name of the container 23691 if (PyArray_TYPE((PyArrayObject*) py_V477) != NPY_FLOAT64) { 23692 PyErr_Format(PyExc_TypeError, 23693 "expected type_num %d (NPY_FLOAT64) got %d", 23694 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V477)); 23695 { 23696 __failure = 478; 23697 if (!PyErr_Occurred()) { 23698 PyErr_SetString(PyExc_RuntimeError, 23699 "Unexpected error in an Op's C code. " 23700 "No Python exception was set."); 23701 } 23702 goto __label_478;} 23703 } 23704 23705 V477 = (PyArrayObject*)(py_V477); 23706 Py_XINCREF(V477); 23707 23708 { 23709 23710 py_V479 = PyList_GET_ITEM(storage_V479, 0); 23711 {Py_XINCREF(py_V479);} 23712 23713 V479 = NULL; 23714 if (py_V479 == Py_None) { 23715 // We can either fail here or set V479 to NULL and rely on Ops 23716 // using tensors to handle the NULL case, but if they fail to do so 23717 // they'll end up with nasty segfaults, so this is public service. 23718 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 23719 { 23720 __failure = 480; 23721 if (!PyErr_Occurred()) { 23722 PyErr_SetString(PyExc_RuntimeError, 23723 "Unexpected error in an Op's C code. " 23724 "No Python exception was set."); 23725 } 23726 goto __label_480;} 23727 } 23728 if (!PyArray_Check(py_V479)) { 23729 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 23730 { 23731 __failure = 480; 23732 if (!PyErr_Occurred()) { 23733 PyErr_SetString(PyExc_RuntimeError, 23734 "Unexpected error in an Op's C code. " 23735 "No Python exception was set."); 23736 } 23737 goto __label_480;} 23738 } 23739 // We expect NPY_FLOAT64 23740 if (!PyArray_ISALIGNED((PyArrayObject*) py_V479)) { 23741 PyArrayObject * tmp = (PyArrayObject*) py_V479; 23742 PyErr_Format(PyExc_NotImplementedError, 23743 "expected an aligned array of type %ld " 23744 "(NPY_FLOAT64), got non-aligned array of type %ld" 23745 " with %ld dimensions, with 3 last dims " 23746 "%ld, %ld, %ld" 23747 " and 3 last strides %ld %ld, %ld.", 23748 (long int) NPY_FLOAT64, 23749 (long int) PyArray_TYPE((PyArrayObject*) py_V479), 23750 (long int) PyArray_NDIM(tmp), 23751 (long int) PyArray_NDIM(tmp) >= 3 ? 23752 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 23753 (long int) PyArray_NDIM(tmp) >= 2 ? 23754 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 23755 (long int) PyArray_NDIM(tmp) >= 1 ? 23756 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 23757 (long int) PyArray_NDIM(tmp) >= 3 ? 23758 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 23759 (long int) PyArray_NDIM(tmp) >= 2 ? 23760 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 23761 (long int) PyArray_NDIM(tmp) >= 1 ? 23762 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 23763 ); 23764 { 23765 __failure = 480; 23766 if (!PyErr_Occurred()) { 23767 PyErr_SetString(PyExc_RuntimeError, 23768 "Unexpected error in an Op's C code. " 23769 "No Python exception was set."); 23770 } 23771 goto __label_480;} 23772 } 23773 // This is a TypeError to be consistent with DEBUG_MODE 23774 // Note: DEBUG_MODE also tells the name of the container 23775 if (PyArray_TYPE((PyArrayObject*) py_V479) != NPY_FLOAT64) { 23776 PyErr_Format(PyExc_TypeError, 23777 "expected type_num %d (NPY_FLOAT64) got %d", 23778 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V479)); 23779 { 23780 __failure = 480; 23781 if (!PyErr_Occurred()) { 23782 PyErr_SetString(PyExc_RuntimeError, 23783 "Unexpected error in an Op's C code. " 23784 "No Python exception was set."); 23785 } 23786 goto __label_480;} 23787 } 23788 23789 V479 = (PyArrayObject*)(py_V479); 23790 Py_XINCREF(V479); 23791 23792 { 23793 23794 py_V481 = PyList_GET_ITEM(storage_V481, 0); 23795 {Py_XINCREF(py_V481);} 23796 23797 V481 = NULL; 23798 if (py_V481 == Py_None) { 23799 // We can either fail here or set V481 to NULL and rely on Ops 23800 // using tensors to handle the NULL case, but if they fail to do so 23801 // they'll end up with nasty segfaults, so this is public service. 23802 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 23803 { 23804 __failure = 482; 23805 if (!PyErr_Occurred()) { 23806 PyErr_SetString(PyExc_RuntimeError, 23807 "Unexpected error in an Op's C code. " 23808 "No Python exception was set."); 23809 } 23810 goto __label_482;} 23811 } 23812 if (!PyArray_Check(py_V481)) { 23813 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 23814 { 23815 __failure = 482; 23816 if (!PyErr_Occurred()) { 23817 PyErr_SetString(PyExc_RuntimeError, 23818 "Unexpected error in an Op's C code. " 23819 "No Python exception was set."); 23820 } 23821 goto __label_482;} 23822 } 23823 // We expect NPY_FLOAT64 23824 if (!PyArray_ISALIGNED((PyArrayObject*) py_V481)) { 23825 PyArrayObject * tmp = (PyArrayObject*) py_V481; 23826 PyErr_Format(PyExc_NotImplementedError, 23827 "expected an aligned array of type %ld " 23828 "(NPY_FLOAT64), got non-aligned array of type %ld" 23829 " with %ld dimensions, with 3 last dims " 23830 "%ld, %ld, %ld" 23831 " and 3 last strides %ld %ld, %ld.", 23832 (long int) NPY_FLOAT64, 23833 (long int) PyArray_TYPE((PyArrayObject*) py_V481), 23834 (long int) PyArray_NDIM(tmp), 23835 (long int) PyArray_NDIM(tmp) >= 3 ? 23836 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 23837 (long int) PyArray_NDIM(tmp) >= 2 ? 23838 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 23839 (long int) PyArray_NDIM(tmp) >= 1 ? 23840 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 23841 (long int) PyArray_NDIM(tmp) >= 3 ? 23842 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 23843 (long int) PyArray_NDIM(tmp) >= 2 ? 23844 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 23845 (long int) PyArray_NDIM(tmp) >= 1 ? 23846 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 23847 ); 23848 { 23849 __failure = 482; 23850 if (!PyErr_Occurred()) { 23851 PyErr_SetString(PyExc_RuntimeError, 23852 "Unexpected error in an Op's C code. " 23853 "No Python exception was set."); 23854 } 23855 goto __label_482;} 23856 } 23857 // This is a TypeError to be consistent with DEBUG_MODE 23858 // Note: DEBUG_MODE also tells the name of the container 23859 if (PyArray_TYPE((PyArrayObject*) py_V481) != NPY_FLOAT64) { 23860 PyErr_Format(PyExc_TypeError, 23861 "expected type_num %d (NPY_FLOAT64) got %d", 23862 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V481)); 23863 { 23864 __failure = 482; 23865 if (!PyErr_Occurred()) { 23866 PyErr_SetString(PyExc_RuntimeError, 23867 "Unexpected error in an Op's C code. " 23868 "No Python exception was set."); 23869 } 23870 goto __label_482;} 23871 } 23872 23873 V481 = (PyArrayObject*)(py_V481); 23874 Py_XINCREF(V481); 23875 23876 { 23877 23878 py_V483 = PyList_GET_ITEM(storage_V483, 0); 23879 {Py_XINCREF(py_V483);} 23880 23881 V483 = NULL; 23882 if (py_V483 == Py_None) { 23883 // We can either fail here or set V483 to NULL and rely on Ops 23884 // using tensors to handle the NULL case, but if they fail to do so 23885 // they'll end up with nasty segfaults, so this is public service. 23886 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 23887 { 23888 __failure = 484; 23889 if (!PyErr_Occurred()) { 23890 PyErr_SetString(PyExc_RuntimeError, 23891 "Unexpected error in an Op's C code. " 23892 "No Python exception was set."); 23893 } 23894 goto __label_484;} 23895 } 23896 if (!PyArray_Check(py_V483)) { 23897 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 23898 { 23899 __failure = 484; 23900 if (!PyErr_Occurred()) { 23901 PyErr_SetString(PyExc_RuntimeError, 23902 "Unexpected error in an Op's C code. " 23903 "No Python exception was set."); 23904 } 23905 goto __label_484;} 23906 } 23907 // We expect NPY_FLOAT64 23908 if (!PyArray_ISALIGNED((PyArrayObject*) py_V483)) { 23909 PyArrayObject * tmp = (PyArrayObject*) py_V483; 23910 PyErr_Format(PyExc_NotImplementedError, 23911 "expected an aligned array of type %ld " 23912 "(NPY_FLOAT64), got non-aligned array of type %ld" 23913 " with %ld dimensions, with 3 last dims " 23914 "%ld, %ld, %ld" 23915 " and 3 last strides %ld %ld, %ld.", 23916 (long int) NPY_FLOAT64, 23917 (long int) PyArray_TYPE((PyArrayObject*) py_V483), 23918 (long int) PyArray_NDIM(tmp), 23919 (long int) PyArray_NDIM(tmp) >= 3 ? 23920 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 23921 (long int) PyArray_NDIM(tmp) >= 2 ? 23922 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 23923 (long int) PyArray_NDIM(tmp) >= 1 ? 23924 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 23925 (long int) PyArray_NDIM(tmp) >= 3 ? 23926 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 23927 (long int) PyArray_NDIM(tmp) >= 2 ? 23928 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 23929 (long int) PyArray_NDIM(tmp) >= 1 ? 23930 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 23931 ); 23932 { 23933 __failure = 484; 23934 if (!PyErr_Occurred()) { 23935 PyErr_SetString(PyExc_RuntimeError, 23936 "Unexpected error in an Op's C code. " 23937 "No Python exception was set."); 23938 } 23939 goto __label_484;} 23940 } 23941 // This is a TypeError to be consistent with DEBUG_MODE 23942 // Note: DEBUG_MODE also tells the name of the container 23943 if (PyArray_TYPE((PyArrayObject*) py_V483) != NPY_FLOAT64) { 23944 PyErr_Format(PyExc_TypeError, 23945 "expected type_num %d (NPY_FLOAT64) got %d", 23946 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V483)); 23947 { 23948 __failure = 484; 23949 if (!PyErr_Occurred()) { 23950 PyErr_SetString(PyExc_RuntimeError, 23951 "Unexpected error in an Op's C code. " 23952 "No Python exception was set."); 23953 } 23954 goto __label_484;} 23955 } 23956 23957 V483 = (PyArrayObject*)(py_V483); 23958 Py_XINCREF(V483); 23959 23960 { 23961 23962 py_V485 = PyList_GET_ITEM(storage_V485, 0); 23963 {Py_XINCREF(py_V485);} 23964 23965 V485 = NULL; 23966 if (py_V485 == Py_None) { 23967 // We can either fail here or set V485 to NULL and rely on Ops 23968 // using tensors to handle the NULL case, but if they fail to do so 23969 // they'll end up with nasty segfaults, so this is public service. 23970 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 23971 { 23972 __failure = 486; 23973 if (!PyErr_Occurred()) { 23974 PyErr_SetString(PyExc_RuntimeError, 23975 "Unexpected error in an Op's C code. " 23976 "No Python exception was set."); 23977 } 23978 goto __label_486;} 23979 } 23980 if (!PyArray_Check(py_V485)) { 23981 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 23982 { 23983 __failure = 486; 23984 if (!PyErr_Occurred()) { 23985 PyErr_SetString(PyExc_RuntimeError, 23986 "Unexpected error in an Op's C code. " 23987 "No Python exception was set."); 23988 } 23989 goto __label_486;} 23990 } 23991 // We expect NPY_INT8 23992 if (!PyArray_ISALIGNED((PyArrayObject*) py_V485)) { 23993 PyArrayObject * tmp = (PyArrayObject*) py_V485; 23994 PyErr_Format(PyExc_NotImplementedError, 23995 "expected an aligned array of type %ld " 23996 "(NPY_INT8), got non-aligned array of type %ld" 23997 " with %ld dimensions, with 3 last dims " 23998 "%ld, %ld, %ld" 23999 " and 3 last strides %ld %ld, %ld.", 24000 (long int) NPY_INT8, 24001 (long int) PyArray_TYPE((PyArrayObject*) py_V485), 24002 (long int) PyArray_NDIM(tmp), 24003 (long int) PyArray_NDIM(tmp) >= 3 ? 24004 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 24005 (long int) PyArray_NDIM(tmp) >= 2 ? 24006 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 24007 (long int) PyArray_NDIM(tmp) >= 1 ? 24008 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 24009 (long int) PyArray_NDIM(tmp) >= 3 ? 24010 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 24011 (long int) PyArray_NDIM(tmp) >= 2 ? 24012 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 24013 (long int) PyArray_NDIM(tmp) >= 1 ? 24014 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 24015 ); 24016 { 24017 __failure = 486; 24018 if (!PyErr_Occurred()) { 24019 PyErr_SetString(PyExc_RuntimeError, 24020 "Unexpected error in an Op's C code. " 24021 "No Python exception was set."); 24022 } 24023 goto __label_486;} 24024 } 24025 // This is a TypeError to be consistent with DEBUG_MODE 24026 // Note: DEBUG_MODE also tells the name of the container 24027 if (PyArray_TYPE((PyArrayObject*) py_V485) != NPY_INT8) { 24028 PyErr_Format(PyExc_TypeError, 24029 "expected type_num %d (NPY_INT8) got %d", 24030 NPY_INT8, PyArray_TYPE((PyArrayObject*) py_V485)); 24031 { 24032 __failure = 486; 24033 if (!PyErr_Occurred()) { 24034 PyErr_SetString(PyExc_RuntimeError, 24035 "Unexpected error in an Op's C code. " 24036 "No Python exception was set."); 24037 } 24038 goto __label_486;} 24039 } 24040 24041 V485 = (PyArrayObject*)(py_V485); 24042 Py_XINCREF(V485); 24043 24044 { 24045 24046 py_V487 = PyList_GET_ITEM(storage_V487, 0); 24047 {Py_XINCREF(py_V487);} 24048 24049 V487 = NULL; 24050 if (py_V487 == Py_None) { 24051 // We can either fail here or set V487 to NULL and rely on Ops 24052 // using tensors to handle the NULL case, but if they fail to do so 24053 // they'll end up with nasty segfaults, so this is public service. 24054 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 24055 { 24056 __failure = 488; 24057 if (!PyErr_Occurred()) { 24058 PyErr_SetString(PyExc_RuntimeError, 24059 "Unexpected error in an Op's C code. " 24060 "No Python exception was set."); 24061 } 24062 goto __label_488;} 24063 } 24064 if (!PyArray_Check(py_V487)) { 24065 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 24066 { 24067 __failure = 488; 24068 if (!PyErr_Occurred()) { 24069 PyErr_SetString(PyExc_RuntimeError, 24070 "Unexpected error in an Op's C code. " 24071 "No Python exception was set."); 24072 } 24073 goto __label_488;} 24074 } 24075 // We expect NPY_FLOAT64 24076 if (!PyArray_ISALIGNED((PyArrayObject*) py_V487)) { 24077 PyArrayObject * tmp = (PyArrayObject*) py_V487; 24078 PyErr_Format(PyExc_NotImplementedError, 24079 "expected an aligned array of type %ld " 24080 "(NPY_FLOAT64), got non-aligned array of type %ld" 24081 " with %ld dimensions, with 3 last dims " 24082 "%ld, %ld, %ld" 24083 " and 3 last strides %ld %ld, %ld.", 24084 (long int) NPY_FLOAT64, 24085 (long int) PyArray_TYPE((PyArrayObject*) py_V487), 24086 (long int) PyArray_NDIM(tmp), 24087 (long int) PyArray_NDIM(tmp) >= 3 ? 24088 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 24089 (long int) PyArray_NDIM(tmp) >= 2 ? 24090 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 24091 (long int) PyArray_NDIM(tmp) >= 1 ? 24092 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 24093 (long int) PyArray_NDIM(tmp) >= 3 ? 24094 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 24095 (long int) PyArray_NDIM(tmp) >= 2 ? 24096 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 24097 (long int) PyArray_NDIM(tmp) >= 1 ? 24098 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 24099 ); 24100 { 24101 __failure = 488; 24102 if (!PyErr_Occurred()) { 24103 PyErr_SetString(PyExc_RuntimeError, 24104 "Unexpected error in an Op's C code. " 24105 "No Python exception was set."); 24106 } 24107 goto __label_488;} 24108 } 24109 // This is a TypeError to be consistent with DEBUG_MODE 24110 // Note: DEBUG_MODE also tells the name of the container 24111 if (PyArray_TYPE((PyArrayObject*) py_V487) != NPY_FLOAT64) { 24112 PyErr_Format(PyExc_TypeError, 24113 "expected type_num %d (NPY_FLOAT64) got %d", 24114 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V487)); 24115 { 24116 __failure = 488; 24117 if (!PyErr_Occurred()) { 24118 PyErr_SetString(PyExc_RuntimeError, 24119 "Unexpected error in an Op's C code. " 24120 "No Python exception was set."); 24121 } 24122 goto __label_488;} 24123 } 24124 24125 V487 = (PyArrayObject*)(py_V487); 24126 Py_XINCREF(V487); 24127 24128 { 24129 24130 py_V489 = PyList_GET_ITEM(storage_V489, 0); 24131 {Py_XINCREF(py_V489);} 24132 24133 V489 = NULL; 24134 if (py_V489 == Py_None) { 24135 // We can either fail here or set V489 to NULL and rely on Ops 24136 // using tensors to handle the NULL case, but if they fail to do so 24137 // they'll end up with nasty segfaults, so this is public service. 24138 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 24139 { 24140 __failure = 490; 24141 if (!PyErr_Occurred()) { 24142 PyErr_SetString(PyExc_RuntimeError, 24143 "Unexpected error in an Op's C code. " 24144 "No Python exception was set."); 24145 } 24146 goto __label_490;} 24147 } 24148 if (!PyArray_Check(py_V489)) { 24149 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 24150 { 24151 __failure = 490; 24152 if (!PyErr_Occurred()) { 24153 PyErr_SetString(PyExc_RuntimeError, 24154 "Unexpected error in an Op's C code. " 24155 "No Python exception was set."); 24156 } 24157 goto __label_490;} 24158 } 24159 // We expect NPY_FLOAT64 24160 if (!PyArray_ISALIGNED((PyArrayObject*) py_V489)) { 24161 PyArrayObject * tmp = (PyArrayObject*) py_V489; 24162 PyErr_Format(PyExc_NotImplementedError, 24163 "expected an aligned array of type %ld " 24164 "(NPY_FLOAT64), got non-aligned array of type %ld" 24165 " with %ld dimensions, with 3 last dims " 24166 "%ld, %ld, %ld" 24167 " and 3 last strides %ld %ld, %ld.", 24168 (long int) NPY_FLOAT64, 24169 (long int) PyArray_TYPE((PyArrayObject*) py_V489), 24170 (long int) PyArray_NDIM(tmp), 24171 (long int) PyArray_NDIM(tmp) >= 3 ? 24172 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 24173 (long int) PyArray_NDIM(tmp) >= 2 ? 24174 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 24175 (long int) PyArray_NDIM(tmp) >= 1 ? 24176 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 24177 (long int) PyArray_NDIM(tmp) >= 3 ? 24178 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 24179 (long int) PyArray_NDIM(tmp) >= 2 ? 24180 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 24181 (long int) PyArray_NDIM(tmp) >= 1 ? 24182 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 24183 ); 24184 { 24185 __failure = 490; 24186 if (!PyErr_Occurred()) { 24187 PyErr_SetString(PyExc_RuntimeError, 24188 "Unexpected error in an Op's C code. " 24189 "No Python exception was set."); 24190 } 24191 goto __label_490;} 24192 } 24193 // This is a TypeError to be consistent with DEBUG_MODE 24194 // Note: DEBUG_MODE also tells the name of the container 24195 if (PyArray_TYPE((PyArrayObject*) py_V489) != NPY_FLOAT64) { 24196 PyErr_Format(PyExc_TypeError, 24197 "expected type_num %d (NPY_FLOAT64) got %d", 24198 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V489)); 24199 { 24200 __failure = 490; 24201 if (!PyErr_Occurred()) { 24202 PyErr_SetString(PyExc_RuntimeError, 24203 "Unexpected error in an Op's C code. " 24204 "No Python exception was set."); 24205 } 24206 goto __label_490;} 24207 } 24208 24209 V489 = (PyArrayObject*)(py_V489); 24210 Py_XINCREF(V489); 24211 24212 { 24213 24214 py_V491 = PyList_GET_ITEM(storage_V491, 0); 24215 {Py_XINCREF(py_V491);} 24216 24217 V491 = NULL; 24218 if (py_V491 == Py_None) { 24219 // We can either fail here or set V491 to NULL and rely on Ops 24220 // using tensors to handle the NULL case, but if they fail to do so 24221 // they'll end up with nasty segfaults, so this is public service. 24222 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 24223 { 24224 __failure = 492; 24225 if (!PyErr_Occurred()) { 24226 PyErr_SetString(PyExc_RuntimeError, 24227 "Unexpected error in an Op's C code. " 24228 "No Python exception was set."); 24229 } 24230 goto __label_492;} 24231 } 24232 if (!PyArray_Check(py_V491)) { 24233 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 24234 { 24235 __failure = 492; 24236 if (!PyErr_Occurred()) { 24237 PyErr_SetString(PyExc_RuntimeError, 24238 "Unexpected error in an Op's C code. " 24239 "No Python exception was set."); 24240 } 24241 goto __label_492;} 24242 } 24243 // We expect NPY_FLOAT64 24244 if (!PyArray_ISALIGNED((PyArrayObject*) py_V491)) { 24245 PyArrayObject * tmp = (PyArrayObject*) py_V491; 24246 PyErr_Format(PyExc_NotImplementedError, 24247 "expected an aligned array of type %ld " 24248 "(NPY_FLOAT64), got non-aligned array of type %ld" 24249 " with %ld dimensions, with 3 last dims " 24250 "%ld, %ld, %ld" 24251 " and 3 last strides %ld %ld, %ld.", 24252 (long int) NPY_FLOAT64, 24253 (long int) PyArray_TYPE((PyArrayObject*) py_V491), 24254 (long int) PyArray_NDIM(tmp), 24255 (long int) PyArray_NDIM(tmp) >= 3 ? 24256 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 24257 (long int) PyArray_NDIM(tmp) >= 2 ? 24258 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 24259 (long int) PyArray_NDIM(tmp) >= 1 ? 24260 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 24261 (long int) PyArray_NDIM(tmp) >= 3 ? 24262 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 24263 (long int) PyArray_NDIM(tmp) >= 2 ? 24264 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 24265 (long int) PyArray_NDIM(tmp) >= 1 ? 24266 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 24267 ); 24268 { 24269 __failure = 492; 24270 if (!PyErr_Occurred()) { 24271 PyErr_SetString(PyExc_RuntimeError, 24272 "Unexpected error in an Op's C code. " 24273 "No Python exception was set."); 24274 } 24275 goto __label_492;} 24276 } 24277 // This is a TypeError to be consistent with DEBUG_MODE 24278 // Note: DEBUG_MODE also tells the name of the container 24279 if (PyArray_TYPE((PyArrayObject*) py_V491) != NPY_FLOAT64) { 24280 PyErr_Format(PyExc_TypeError, 24281 "expected type_num %d (NPY_FLOAT64) got %d", 24282 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V491)); 24283 { 24284 __failure = 492; 24285 if (!PyErr_Occurred()) { 24286 PyErr_SetString(PyExc_RuntimeError, 24287 "Unexpected error in an Op's C code. " 24288 "No Python exception was set."); 24289 } 24290 goto __label_492;} 24291 } 24292 24293 V491 = (PyArrayObject*)(py_V491); 24294 Py_XINCREF(V491); 24295 24296 { 24297 24298 py_V493 = PyList_GET_ITEM(storage_V493, 0); 24299 {Py_XINCREF(py_V493);} 24300 24301 V493 = NULL; 24302 if (py_V493 == Py_None) { 24303 // We can either fail here or set V493 to NULL and rely on Ops 24304 // using tensors to handle the NULL case, but if they fail to do so 24305 // they'll end up with nasty segfaults, so this is public service. 24306 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 24307 { 24308 __failure = 494; 24309 if (!PyErr_Occurred()) { 24310 PyErr_SetString(PyExc_RuntimeError, 24311 "Unexpected error in an Op's C code. " 24312 "No Python exception was set."); 24313 } 24314 goto __label_494;} 24315 } 24316 if (!PyArray_Check(py_V493)) { 24317 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 24318 { 24319 __failure = 494; 24320 if (!PyErr_Occurred()) { 24321 PyErr_SetString(PyExc_RuntimeError, 24322 "Unexpected error in an Op's C code. " 24323 "No Python exception was set."); 24324 } 24325 goto __label_494;} 24326 } 24327 // We expect NPY_FLOAT64 24328 if (!PyArray_ISALIGNED((PyArrayObject*) py_V493)) { 24329 PyArrayObject * tmp = (PyArrayObject*) py_V493; 24330 PyErr_Format(PyExc_NotImplementedError, 24331 "expected an aligned array of type %ld " 24332 "(NPY_FLOAT64), got non-aligned array of type %ld" 24333 " with %ld dimensions, with 3 last dims " 24334 "%ld, %ld, %ld" 24335 " and 3 last strides %ld %ld, %ld.", 24336 (long int) NPY_FLOAT64, 24337 (long int) PyArray_TYPE((PyArrayObject*) py_V493), 24338 (long int) PyArray_NDIM(tmp), 24339 (long int) PyArray_NDIM(tmp) >= 3 ? 24340 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 24341 (long int) PyArray_NDIM(tmp) >= 2 ? 24342 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 24343 (long int) PyArray_NDIM(tmp) >= 1 ? 24344 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 24345 (long int) PyArray_NDIM(tmp) >= 3 ? 24346 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 24347 (long int) PyArray_NDIM(tmp) >= 2 ? 24348 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 24349 (long int) PyArray_NDIM(tmp) >= 1 ? 24350 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 24351 ); 24352 { 24353 __failure = 494; 24354 if (!PyErr_Occurred()) { 24355 PyErr_SetString(PyExc_RuntimeError, 24356 "Unexpected error in an Op's C code. " 24357 "No Python exception was set."); 24358 } 24359 goto __label_494;} 24360 } 24361 // This is a TypeError to be consistent with DEBUG_MODE 24362 // Note: DEBUG_MODE also tells the name of the container 24363 if (PyArray_TYPE((PyArrayObject*) py_V493) != NPY_FLOAT64) { 24364 PyErr_Format(PyExc_TypeError, 24365 "expected type_num %d (NPY_FLOAT64) got %d", 24366 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V493)); 24367 { 24368 __failure = 494; 24369 if (!PyErr_Occurred()) { 24370 PyErr_SetString(PyExc_RuntimeError, 24371 "Unexpected error in an Op's C code. " 24372 "No Python exception was set."); 24373 } 24374 goto __label_494;} 24375 } 24376 24377 V493 = (PyArrayObject*)(py_V493); 24378 Py_XINCREF(V493); 24379 24380 { 24381 24382 py_V495 = PyList_GET_ITEM(storage_V495, 0); 24383 {Py_XINCREF(py_V495);} 24384 24385 V495 = NULL; 24386 if (py_V495 == Py_None) { 24387 // We can either fail here or set V495 to NULL and rely on Ops 24388 // using tensors to handle the NULL case, but if they fail to do so 24389 // they'll end up with nasty segfaults, so this is public service. 24390 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 24391 { 24392 __failure = 496; 24393 if (!PyErr_Occurred()) { 24394 PyErr_SetString(PyExc_RuntimeError, 24395 "Unexpected error in an Op's C code. " 24396 "No Python exception was set."); 24397 } 24398 goto __label_496;} 24399 } 24400 if (!PyArray_Check(py_V495)) { 24401 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 24402 { 24403 __failure = 496; 24404 if (!PyErr_Occurred()) { 24405 PyErr_SetString(PyExc_RuntimeError, 24406 "Unexpected error in an Op's C code. " 24407 "No Python exception was set."); 24408 } 24409 goto __label_496;} 24410 } 24411 // We expect NPY_FLOAT64 24412 if (!PyArray_ISALIGNED((PyArrayObject*) py_V495)) { 24413 PyArrayObject * tmp = (PyArrayObject*) py_V495; 24414 PyErr_Format(PyExc_NotImplementedError, 24415 "expected an aligned array of type %ld " 24416 "(NPY_FLOAT64), got non-aligned array of type %ld" 24417 " with %ld dimensions, with 3 last dims " 24418 "%ld, %ld, %ld" 24419 " and 3 last strides %ld %ld, %ld.", 24420 (long int) NPY_FLOAT64, 24421 (long int) PyArray_TYPE((PyArrayObject*) py_V495), 24422 (long int) PyArray_NDIM(tmp), 24423 (long int) PyArray_NDIM(tmp) >= 3 ? 24424 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 24425 (long int) PyArray_NDIM(tmp) >= 2 ? 24426 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 24427 (long int) PyArray_NDIM(tmp) >= 1 ? 24428 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 24429 (long int) PyArray_NDIM(tmp) >= 3 ? 24430 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 24431 (long int) PyArray_NDIM(tmp) >= 2 ? 24432 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 24433 (long int) PyArray_NDIM(tmp) >= 1 ? 24434 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 24435 ); 24436 { 24437 __failure = 496; 24438 if (!PyErr_Occurred()) { 24439 PyErr_SetString(PyExc_RuntimeError, 24440 "Unexpected error in an Op's C code. " 24441 "No Python exception was set."); 24442 } 24443 goto __label_496;} 24444 } 24445 // This is a TypeError to be consistent with DEBUG_MODE 24446 // Note: DEBUG_MODE also tells the name of the container 24447 if (PyArray_TYPE((PyArrayObject*) py_V495) != NPY_FLOAT64) { 24448 PyErr_Format(PyExc_TypeError, 24449 "expected type_num %d (NPY_FLOAT64) got %d", 24450 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V495)); 24451 { 24452 __failure = 496; 24453 if (!PyErr_Occurred()) { 24454 PyErr_SetString(PyExc_RuntimeError, 24455 "Unexpected error in an Op's C code. " 24456 "No Python exception was set."); 24457 } 24458 goto __label_496;} 24459 } 24460 24461 V495 = (PyArrayObject*)(py_V495); 24462 Py_XINCREF(V495); 24463 24464 { 24465 24466 py_V497 = PyList_GET_ITEM(storage_V497, 0); 24467 {Py_XINCREF(py_V497);} 24468 24469 V497 = NULL; 24470 if (py_V497 == Py_None) { 24471 // We can either fail here or set V497 to NULL and rely on Ops 24472 // using tensors to handle the NULL case, but if they fail to do so 24473 // they'll end up with nasty segfaults, so this is public service. 24474 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 24475 { 24476 __failure = 498; 24477 if (!PyErr_Occurred()) { 24478 PyErr_SetString(PyExc_RuntimeError, 24479 "Unexpected error in an Op's C code. " 24480 "No Python exception was set."); 24481 } 24482 goto __label_498;} 24483 } 24484 if (!PyArray_Check(py_V497)) { 24485 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 24486 { 24487 __failure = 498; 24488 if (!PyErr_Occurred()) { 24489 PyErr_SetString(PyExc_RuntimeError, 24490 "Unexpected error in an Op's C code. " 24491 "No Python exception was set."); 24492 } 24493 goto __label_498;} 24494 } 24495 // We expect NPY_FLOAT64 24496 if (!PyArray_ISALIGNED((PyArrayObject*) py_V497)) { 24497 PyArrayObject * tmp = (PyArrayObject*) py_V497; 24498 PyErr_Format(PyExc_NotImplementedError, 24499 "expected an aligned array of type %ld " 24500 "(NPY_FLOAT64), got non-aligned array of type %ld" 24501 " with %ld dimensions, with 3 last dims " 24502 "%ld, %ld, %ld" 24503 " and 3 last strides %ld %ld, %ld.", 24504 (long int) NPY_FLOAT64, 24505 (long int) PyArray_TYPE((PyArrayObject*) py_V497), 24506 (long int) PyArray_NDIM(tmp), 24507 (long int) PyArray_NDIM(tmp) >= 3 ? 24508 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 24509 (long int) PyArray_NDIM(tmp) >= 2 ? 24510 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 24511 (long int) PyArray_NDIM(tmp) >= 1 ? 24512 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 24513 (long int) PyArray_NDIM(tmp) >= 3 ? 24514 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 24515 (long int) PyArray_NDIM(tmp) >= 2 ? 24516 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 24517 (long int) PyArray_NDIM(tmp) >= 1 ? 24518 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 24519 ); 24520 { 24521 __failure = 498; 24522 if (!PyErr_Occurred()) { 24523 PyErr_SetString(PyExc_RuntimeError, 24524 "Unexpected error in an Op's C code. " 24525 "No Python exception was set."); 24526 } 24527 goto __label_498;} 24528 } 24529 // This is a TypeError to be consistent with DEBUG_MODE 24530 // Note: DEBUG_MODE also tells the name of the container 24531 if (PyArray_TYPE((PyArrayObject*) py_V497) != NPY_FLOAT64) { 24532 PyErr_Format(PyExc_TypeError, 24533 "expected type_num %d (NPY_FLOAT64) got %d", 24534 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V497)); 24535 { 24536 __failure = 498; 24537 if (!PyErr_Occurred()) { 24538 PyErr_SetString(PyExc_RuntimeError, 24539 "Unexpected error in an Op's C code. " 24540 "No Python exception was set."); 24541 } 24542 goto __label_498;} 24543 } 24544 24545 V497 = (PyArrayObject*)(py_V497); 24546 Py_XINCREF(V497); 24547 24548 { 24549 24550 py_V499 = PyList_GET_ITEM(storage_V499, 0); 24551 {Py_XINCREF(py_V499);} 24552 24553 V499 = NULL; 24554 if (py_V499 == Py_None) { 24555 // We can either fail here or set V499 to NULL and rely on Ops 24556 // using tensors to handle the NULL case, but if they fail to do so 24557 // they'll end up with nasty segfaults, so this is public service. 24558 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 24559 { 24560 __failure = 500; 24561 if (!PyErr_Occurred()) { 24562 PyErr_SetString(PyExc_RuntimeError, 24563 "Unexpected error in an Op's C code. " 24564 "No Python exception was set."); 24565 } 24566 goto __label_500;} 24567 } 24568 if (!PyArray_Check(py_V499)) { 24569 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 24570 { 24571 __failure = 500; 24572 if (!PyErr_Occurred()) { 24573 PyErr_SetString(PyExc_RuntimeError, 24574 "Unexpected error in an Op's C code. " 24575 "No Python exception was set."); 24576 } 24577 goto __label_500;} 24578 } 24579 // We expect NPY_INT8 24580 if (!PyArray_ISALIGNED((PyArrayObject*) py_V499)) { 24581 PyArrayObject * tmp = (PyArrayObject*) py_V499; 24582 PyErr_Format(PyExc_NotImplementedError, 24583 "expected an aligned array of type %ld " 24584 "(NPY_INT8), got non-aligned array of type %ld" 24585 " with %ld dimensions, with 3 last dims " 24586 "%ld, %ld, %ld" 24587 " and 3 last strides %ld %ld, %ld.", 24588 (long int) NPY_INT8, 24589 (long int) PyArray_TYPE((PyArrayObject*) py_V499), 24590 (long int) PyArray_NDIM(tmp), 24591 (long int) PyArray_NDIM(tmp) >= 3 ? 24592 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 24593 (long int) PyArray_NDIM(tmp) >= 2 ? 24594 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 24595 (long int) PyArray_NDIM(tmp) >= 1 ? 24596 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 24597 (long int) PyArray_NDIM(tmp) >= 3 ? 24598 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 24599 (long int) PyArray_NDIM(tmp) >= 2 ? 24600 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 24601 (long int) PyArray_NDIM(tmp) >= 1 ? 24602 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 24603 ); 24604 { 24605 __failure = 500; 24606 if (!PyErr_Occurred()) { 24607 PyErr_SetString(PyExc_RuntimeError, 24608 "Unexpected error in an Op's C code. " 24609 "No Python exception was set."); 24610 } 24611 goto __label_500;} 24612 } 24613 // This is a TypeError to be consistent with DEBUG_MODE 24614 // Note: DEBUG_MODE also tells the name of the container 24615 if (PyArray_TYPE((PyArrayObject*) py_V499) != NPY_INT8) { 24616 PyErr_Format(PyExc_TypeError, 24617 "expected type_num %d (NPY_INT8) got %d", 24618 NPY_INT8, PyArray_TYPE((PyArrayObject*) py_V499)); 24619 { 24620 __failure = 500; 24621 if (!PyErr_Occurred()) { 24622 PyErr_SetString(PyExc_RuntimeError, 24623 "Unexpected error in an Op's C code. " 24624 "No Python exception was set."); 24625 } 24626 goto __label_500;} 24627 } 24628 24629 V499 = (PyArrayObject*)(py_V499); 24630 Py_XINCREF(V499); 24631 24632 { 24633 24634 py_V501 = PyList_GET_ITEM(storage_V501, 0); 24635 {Py_XINCREF(py_V501);} 24636 24637 V501 = NULL; 24638 if (py_V501 == Py_None) { 24639 // We can either fail here or set V501 to NULL and rely on Ops 24640 // using tensors to handle the NULL case, but if they fail to do so 24641 // they'll end up with nasty segfaults, so this is public service. 24642 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 24643 { 24644 __failure = 502; 24645 if (!PyErr_Occurred()) { 24646 PyErr_SetString(PyExc_RuntimeError, 24647 "Unexpected error in an Op's C code. " 24648 "No Python exception was set."); 24649 } 24650 goto __label_502;} 24651 } 24652 if (!PyArray_Check(py_V501)) { 24653 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 24654 { 24655 __failure = 502; 24656 if (!PyErr_Occurred()) { 24657 PyErr_SetString(PyExc_RuntimeError, 24658 "Unexpected error in an Op's C code. " 24659 "No Python exception was set."); 24660 } 24661 goto __label_502;} 24662 } 24663 // We expect NPY_FLOAT64 24664 if (!PyArray_ISALIGNED((PyArrayObject*) py_V501)) { 24665 PyArrayObject * tmp = (PyArrayObject*) py_V501; 24666 PyErr_Format(PyExc_NotImplementedError, 24667 "expected an aligned array of type %ld " 24668 "(NPY_FLOAT64), got non-aligned array of type %ld" 24669 " with %ld dimensions, with 3 last dims " 24670 "%ld, %ld, %ld" 24671 " and 3 last strides %ld %ld, %ld.", 24672 (long int) NPY_FLOAT64, 24673 (long int) PyArray_TYPE((PyArrayObject*) py_V501), 24674 (long int) PyArray_NDIM(tmp), 24675 (long int) PyArray_NDIM(tmp) >= 3 ? 24676 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 24677 (long int) PyArray_NDIM(tmp) >= 2 ? 24678 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 24679 (long int) PyArray_NDIM(tmp) >= 1 ? 24680 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 24681 (long int) PyArray_NDIM(tmp) >= 3 ? 24682 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 24683 (long int) PyArray_NDIM(tmp) >= 2 ? 24684 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 24685 (long int) PyArray_NDIM(tmp) >= 1 ? 24686 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 24687 ); 24688 { 24689 __failure = 502; 24690 if (!PyErr_Occurred()) { 24691 PyErr_SetString(PyExc_RuntimeError, 24692 "Unexpected error in an Op's C code. " 24693 "No Python exception was set."); 24694 } 24695 goto __label_502;} 24696 } 24697 // This is a TypeError to be consistent with DEBUG_MODE 24698 // Note: DEBUG_MODE also tells the name of the container 24699 if (PyArray_TYPE((PyArrayObject*) py_V501) != NPY_FLOAT64) { 24700 PyErr_Format(PyExc_TypeError, 24701 "expected type_num %d (NPY_FLOAT64) got %d", 24702 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V501)); 24703 { 24704 __failure = 502; 24705 if (!PyErr_Occurred()) { 24706 PyErr_SetString(PyExc_RuntimeError, 24707 "Unexpected error in an Op's C code. " 24708 "No Python exception was set."); 24709 } 24710 goto __label_502;} 24711 } 24712 24713 V501 = (PyArrayObject*)(py_V501); 24714 Py_XINCREF(V501); 24715 24716 { 24717 24718 py_V503 = PyList_GET_ITEM(storage_V503, 0); 24719 {Py_XINCREF(py_V503);} 24720 24721 V503 = NULL; 24722 if (py_V503 == Py_None) { 24723 // We can either fail here or set V503 to NULL and rely on Ops 24724 // using tensors to handle the NULL case, but if they fail to do so 24725 // they'll end up with nasty segfaults, so this is public service. 24726 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 24727 { 24728 __failure = 504; 24729 if (!PyErr_Occurred()) { 24730 PyErr_SetString(PyExc_RuntimeError, 24731 "Unexpected error in an Op's C code. " 24732 "No Python exception was set."); 24733 } 24734 goto __label_504;} 24735 } 24736 if (!PyArray_Check(py_V503)) { 24737 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 24738 { 24739 __failure = 504; 24740 if (!PyErr_Occurred()) { 24741 PyErr_SetString(PyExc_RuntimeError, 24742 "Unexpected error in an Op's C code. " 24743 "No Python exception was set."); 24744 } 24745 goto __label_504;} 24746 } 24747 // We expect NPY_FLOAT64 24748 if (!PyArray_ISALIGNED((PyArrayObject*) py_V503)) { 24749 PyArrayObject * tmp = (PyArrayObject*) py_V503; 24750 PyErr_Format(PyExc_NotImplementedError, 24751 "expected an aligned array of type %ld " 24752 "(NPY_FLOAT64), got non-aligned array of type %ld" 24753 " with %ld dimensions, with 3 last dims " 24754 "%ld, %ld, %ld" 24755 " and 3 last strides %ld %ld, %ld.", 24756 (long int) NPY_FLOAT64, 24757 (long int) PyArray_TYPE((PyArrayObject*) py_V503), 24758 (long int) PyArray_NDIM(tmp), 24759 (long int) PyArray_NDIM(tmp) >= 3 ? 24760 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 24761 (long int) PyArray_NDIM(tmp) >= 2 ? 24762 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 24763 (long int) PyArray_NDIM(tmp) >= 1 ? 24764 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 24765 (long int) PyArray_NDIM(tmp) >= 3 ? 24766 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 24767 (long int) PyArray_NDIM(tmp) >= 2 ? 24768 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 24769 (long int) PyArray_NDIM(tmp) >= 1 ? 24770 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 24771 ); 24772 { 24773 __failure = 504; 24774 if (!PyErr_Occurred()) { 24775 PyErr_SetString(PyExc_RuntimeError, 24776 "Unexpected error in an Op's C code. " 24777 "No Python exception was set."); 24778 } 24779 goto __label_504;} 24780 } 24781 // This is a TypeError to be consistent with DEBUG_MODE 24782 // Note: DEBUG_MODE also tells the name of the container 24783 if (PyArray_TYPE((PyArrayObject*) py_V503) != NPY_FLOAT64) { 24784 PyErr_Format(PyExc_TypeError, 24785 "expected type_num %d (NPY_FLOAT64) got %d", 24786 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V503)); 24787 { 24788 __failure = 504; 24789 if (!PyErr_Occurred()) { 24790 PyErr_SetString(PyExc_RuntimeError, 24791 "Unexpected error in an Op's C code. " 24792 "No Python exception was set."); 24793 } 24794 goto __label_504;} 24795 } 24796 24797 V503 = (PyArrayObject*)(py_V503); 24798 Py_XINCREF(V503); 24799 24800 { 24801 24802 py_V505 = PyList_GET_ITEM(storage_V505, 0); 24803 {Py_XINCREF(py_V505);} 24804 24805 V505 = NULL; 24806 if (py_V505 == Py_None) { 24807 // We can either fail here or set V505 to NULL and rely on Ops 24808 // using tensors to handle the NULL case, but if they fail to do so 24809 // they'll end up with nasty segfaults, so this is public service. 24810 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 24811 { 24812 __failure = 506; 24813 if (!PyErr_Occurred()) { 24814 PyErr_SetString(PyExc_RuntimeError, 24815 "Unexpected error in an Op's C code. " 24816 "No Python exception was set."); 24817 } 24818 goto __label_506;} 24819 } 24820 if (!PyArray_Check(py_V505)) { 24821 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 24822 { 24823 __failure = 506; 24824 if (!PyErr_Occurred()) { 24825 PyErr_SetString(PyExc_RuntimeError, 24826 "Unexpected error in an Op's C code. " 24827 "No Python exception was set."); 24828 } 24829 goto __label_506;} 24830 } 24831 // We expect NPY_FLOAT64 24832 if (!PyArray_ISALIGNED((PyArrayObject*) py_V505)) { 24833 PyArrayObject * tmp = (PyArrayObject*) py_V505; 24834 PyErr_Format(PyExc_NotImplementedError, 24835 "expected an aligned array of type %ld " 24836 "(NPY_FLOAT64), got non-aligned array of type %ld" 24837 " with %ld dimensions, with 3 last dims " 24838 "%ld, %ld, %ld" 24839 " and 3 last strides %ld %ld, %ld.", 24840 (long int) NPY_FLOAT64, 24841 (long int) PyArray_TYPE((PyArrayObject*) py_V505), 24842 (long int) PyArray_NDIM(tmp), 24843 (long int) PyArray_NDIM(tmp) >= 3 ? 24844 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 24845 (long int) PyArray_NDIM(tmp) >= 2 ? 24846 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 24847 (long int) PyArray_NDIM(tmp) >= 1 ? 24848 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 24849 (long int) PyArray_NDIM(tmp) >= 3 ? 24850 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 24851 (long int) PyArray_NDIM(tmp) >= 2 ? 24852 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 24853 (long int) PyArray_NDIM(tmp) >= 1 ? 24854 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 24855 ); 24856 { 24857 __failure = 506; 24858 if (!PyErr_Occurred()) { 24859 PyErr_SetString(PyExc_RuntimeError, 24860 "Unexpected error in an Op's C code. " 24861 "No Python exception was set."); 24862 } 24863 goto __label_506;} 24864 } 24865 // This is a TypeError to be consistent with DEBUG_MODE 24866 // Note: DEBUG_MODE also tells the name of the container 24867 if (PyArray_TYPE((PyArrayObject*) py_V505) != NPY_FLOAT64) { 24868 PyErr_Format(PyExc_TypeError, 24869 "expected type_num %d (NPY_FLOAT64) got %d", 24870 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V505)); 24871 { 24872 __failure = 506; 24873 if (!PyErr_Occurred()) { 24874 PyErr_SetString(PyExc_RuntimeError, 24875 "Unexpected error in an Op's C code. " 24876 "No Python exception was set."); 24877 } 24878 goto __label_506;} 24879 } 24880 24881 V505 = (PyArrayObject*)(py_V505); 24882 Py_XINCREF(V505); 24883 24884 { 24885 24886 py_V507 = PyList_GET_ITEM(storage_V507, 0); 24887 {Py_XINCREF(py_V507);} 24888 24889 V507 = NULL; 24890 if (py_V507 == Py_None) { 24891 // We can either fail here or set V507 to NULL and rely on Ops 24892 // using tensors to handle the NULL case, but if they fail to do so 24893 // they'll end up with nasty segfaults, so this is public service. 24894 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 24895 { 24896 __failure = 508; 24897 if (!PyErr_Occurred()) { 24898 PyErr_SetString(PyExc_RuntimeError, 24899 "Unexpected error in an Op's C code. " 24900 "No Python exception was set."); 24901 } 24902 goto __label_508;} 24903 } 24904 if (!PyArray_Check(py_V507)) { 24905 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 24906 { 24907 __failure = 508; 24908 if (!PyErr_Occurred()) { 24909 PyErr_SetString(PyExc_RuntimeError, 24910 "Unexpected error in an Op's C code. " 24911 "No Python exception was set."); 24912 } 24913 goto __label_508;} 24914 } 24915 // We expect NPY_FLOAT64 24916 if (!PyArray_ISALIGNED((PyArrayObject*) py_V507)) { 24917 PyArrayObject * tmp = (PyArrayObject*) py_V507; 24918 PyErr_Format(PyExc_NotImplementedError, 24919 "expected an aligned array of type %ld " 24920 "(NPY_FLOAT64), got non-aligned array of type %ld" 24921 " with %ld dimensions, with 3 last dims " 24922 "%ld, %ld, %ld" 24923 " and 3 last strides %ld %ld, %ld.", 24924 (long int) NPY_FLOAT64, 24925 (long int) PyArray_TYPE((PyArrayObject*) py_V507), 24926 (long int) PyArray_NDIM(tmp), 24927 (long int) PyArray_NDIM(tmp) >= 3 ? 24928 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 24929 (long int) PyArray_NDIM(tmp) >= 2 ? 24930 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 24931 (long int) PyArray_NDIM(tmp) >= 1 ? 24932 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 24933 (long int) PyArray_NDIM(tmp) >= 3 ? 24934 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 24935 (long int) PyArray_NDIM(tmp) >= 2 ? 24936 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 24937 (long int) PyArray_NDIM(tmp) >= 1 ? 24938 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 24939 ); 24940 { 24941 __failure = 508; 24942 if (!PyErr_Occurred()) { 24943 PyErr_SetString(PyExc_RuntimeError, 24944 "Unexpected error in an Op's C code. " 24945 "No Python exception was set."); 24946 } 24947 goto __label_508;} 24948 } 24949 // This is a TypeError to be consistent with DEBUG_MODE 24950 // Note: DEBUG_MODE also tells the name of the container 24951 if (PyArray_TYPE((PyArrayObject*) py_V507) != NPY_FLOAT64) { 24952 PyErr_Format(PyExc_TypeError, 24953 "expected type_num %d (NPY_FLOAT64) got %d", 24954 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V507)); 24955 { 24956 __failure = 508; 24957 if (!PyErr_Occurred()) { 24958 PyErr_SetString(PyExc_RuntimeError, 24959 "Unexpected error in an Op's C code. " 24960 "No Python exception was set."); 24961 } 24962 goto __label_508;} 24963 } 24964 24965 V507 = (PyArrayObject*)(py_V507); 24966 Py_XINCREF(V507); 24967 24968 { 24969 24970 py_V509 = PyList_GET_ITEM(storage_V509, 0); 24971 {Py_XINCREF(py_V509);} 24972 24973 V509 = NULL; 24974 if (py_V509 == Py_None) { 24975 // We can either fail here or set V509 to NULL and rely on Ops 24976 // using tensors to handle the NULL case, but if they fail to do so 24977 // they'll end up with nasty segfaults, so this is public service. 24978 PyErr_SetString(PyExc_ValueError, "expected an ndarray, not None"); 24979 { 24980 __failure = 510; 24981 if (!PyErr_Occurred()) { 24982 PyErr_SetString(PyExc_RuntimeError, 24983 "Unexpected error in an Op's C code. " 24984 "No Python exception was set."); 24985 } 24986 goto __label_510;} 24987 } 24988 if (!PyArray_Check(py_V509)) { 24989 PyErr_SetString(PyExc_ValueError, "expected an ndarray"); 24990 { 24991 __failure = 510; 24992 if (!PyErr_Occurred()) { 24993 PyErr_SetString(PyExc_RuntimeError, 24994 "Unexpected error in an Op's C code. " 24995 "No Python exception was set."); 24996 } 24997 goto __label_510;} 24998 } 24999 // We expect NPY_FLOAT64 25000 if (!PyArray_ISALIGNED((PyArrayObject*) py_V509)) { 25001 PyArrayObject * tmp = (PyArrayObject*) py_V509; 25002 PyErr_Format(PyExc_NotImplementedError, 25003 "expected an aligned array of type %ld " 25004 "(NPY_FLOAT64), got non-aligned array of type %ld" 25005 " with %ld dimensions, with 3 last dims " 25006 "%ld, %ld, %ld" 25007 " and 3 last strides %ld %ld, %ld.", 25008 (long int) NPY_FLOAT64, 25009 (long int) PyArray_TYPE((PyArrayObject*) py_V509), 25010 (long int) PyArray_NDIM(tmp), 25011 (long int) PyArray_NDIM(tmp) >= 3 ? 25012 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-3] : -1, 25013 (long int) PyArray_NDIM(tmp) >= 2 ? 25014 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-2] : -1, 25015 (long int) PyArray_NDIM(tmp) >= 1 ? 25016 PyArray_DIMS(tmp)[PyArray_NDIM(tmp)-1] : -1, 25017 (long int) PyArray_NDIM(tmp) >= 3 ? 25018 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-3] : -1, 25019 (long int) PyArray_NDIM(tmp) >= 2 ? 25020 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-2] : -1, 25021 (long int) PyArray_NDIM(tmp) >= 1 ? 25022 PyArray_STRIDES(tmp)[PyArray_NDIM(tmp)-1] : -1 25023 ); 25024 { 25025 __failure = 510; 25026 if (!PyErr_Occurred()) { 25027 PyErr_SetString(PyExc_RuntimeError, 25028 "Unexpected error in an Op's C code. " 25029 "No Python exception was set."); 25030 } 25031 goto __label_510;} 25032 } 25033 // This is a TypeError to be consistent with DEBUG_MODE 25034 // Note: DEBUG_MODE also tells the name of the container 25035 if (PyArray_TYPE((PyArrayObject*) py_V509) != NPY_FLOAT64) { 25036 PyErr_Format(PyExc_TypeError, 25037 "expected type_num %d (NPY_FLOAT64) got %d", 25038 NPY_FLOAT64, PyArray_TYPE((PyArrayObject*) py_V509)); 25039 { 25040 __failure = 510; 25041 if (!PyErr_Occurred()) { 25042 PyErr_SetString(PyExc_RuntimeError, 25043 "Unexpected error in an Op's C code. " 25044 "No Python exception was set."); 25045 } 25046 goto __label_510;} 25047 } 25048 25049 V509 = (PyArrayObject*)(py_V509); 25050 Py_XINCREF(V509); 25051 25052 { 25053 // Op class Elemwise 25054 25055 npy_float64* V3_iter; 25056 25057 npy_int8* V5_iter; 25058 25059 npy_float64* V7_iter; 25060 25061 npy_float64* V9_iter; 25062 25063 npy_float64* V11_iter; 25064 25065 npy_float64* V13_iter; 25066 25067 npy_int8* V15_iter; 25068 25069 npy_float64* V17_iter; 25070 25071 npy_float64* V19_iter; 25072 25073 npy_float64* V21_iter; 25074 25075 npy_float64* V23_iter; 25076 25077 npy_int8* V25_iter; 25078 25079 npy_float64* V27_iter; 25080 25081 npy_float64* V29_iter; 25082 25083 npy_float64* V31_iter; 25084 25085 npy_float64* V33_iter; 25086 25087 npy_float64* V35_iter; 25088 25089 npy_float64* V37_iter; 25090 25091 npy_float64* V39_iter; 25092 25093 npy_int8* V41_iter; 25094 25095 npy_float64* V43_iter; 25096 25097 npy_float64* V45_iter; 25098 25099 npy_float64* V47_iter; 25100 25101 npy_float64* V49_iter; 25102 25103 npy_float64* V51_iter; 25104 25105 npy_float64* V53_iter; 25106 25107 npy_float64* V55_iter; 25108 25109 npy_int8* V57_iter; 25110 25111 npy_float64* V59_iter; 25112 25113 npy_float64* V61_iter; 25114 25115 npy_float64* V63_iter; 25116 25117 npy_float64* V65_iter; 25118 25119 npy_float64* V67_iter; 25120 25121 npy_float64* V69_iter; 25122 25123 npy_int8* V71_iter; 25124 25125 npy_float64* V73_iter; 25126 25127 npy_float64* V75_iter; 25128 25129 npy_float64* V77_iter; 25130 25131 npy_float64* V79_iter; 25132 25133 npy_float64* V81_iter; 25134 25135 npy_int8* V83_iter; 25136 25137 npy_float64* V85_iter; 25138 25139 npy_float64* V87_iter; 25140 25141 npy_float64* V89_iter; 25142 25143 npy_float64* V91_iter; 25144 25145 npy_float64* V93_iter; 25146 25147 npy_int8* V95_iter; 25148 25149 npy_float64* V97_iter; 25150 25151 npy_float64* V99_iter; 25152 25153 npy_float64* V101_iter; 25154 25155 npy_float64* V103_iter; 25156 25157 npy_float64* V105_iter; 25158 25159 npy_int8* V107_iter; 25160 25161 npy_float64* V109_iter; 25162 25163 npy_float64* V111_iter; 25164 25165 npy_float64* V113_iter; 25166 25167 npy_float64* V115_iter; 25168 25169 npy_float64* V117_iter; 25170 25171 npy_float64* V119_iter; 25172 25173 npy_int8* V121_iter; 25174 25175 npy_float64* V123_iter; 25176 25177 npy_float64* V125_iter; 25178 25179 npy_float64* V127_iter; 25180 25181 npy_float64* V129_iter; 25182 25183 npy_float64* V131_iter; 25184 25185 npy_float64* V133_iter; 25186 25187 npy_int8* V135_iter; 25188 25189 npy_float64* V137_iter; 25190 25191 npy_float64* V139_iter; 25192 25193 npy_float64* V141_iter; 25194 25195 npy_float64* V143_iter; 25196 25197 npy_float64* V145_iter; 25198 25199 npy_int8* V147_iter; 25200 25201 npy_float64* V149_iter; 25202 25203 npy_float64* V151_iter; 25204 25205 npy_float64* V153_iter; 25206 25207 npy_float64* V155_iter; 25208 25209 npy_float64* V157_iter; 25210 25211 npy_float64* V159_iter; 25212 25213 npy_int8* V161_iter; 25214 25215 npy_float64* V163_iter; 25216 25217 npy_float64* V165_iter; 25218 25219 npy_float64* V167_iter; 25220 25221 npy_float64* V169_iter; 25222 25223 npy_float64* V171_iter; 25224 25225 npy_float64* V173_iter; 25226 25227 npy_int8* V175_iter; 25228 25229 npy_float64* V177_iter; 25230 25231 npy_float64* V179_iter; 25232 25233 npy_float64* V181_iter; 25234 25235 npy_float64* V183_iter; 25236 25237 npy_float64* V185_iter; 25238 25239 npy_float64* V187_iter; 25240 25241 npy_int8* V189_iter; 25242 25243 npy_float64* V191_iter; 25244 25245 npy_float64* V193_iter; 25246 25247 npy_float64* V195_iter; 25248 25249 npy_float64* V197_iter; 25250 25251 npy_float64* V199_iter; 25252 25253 npy_float64* V201_iter; 25254 25255 npy_int8* V203_iter; 25256 25257 npy_float64* V205_iter; 25258 25259 npy_float64* V207_iter; 25260 25261 npy_float64* V209_iter; 25262 25263 npy_float64* V211_iter; 25264 25265 npy_float64* V213_iter; 25266 25267 npy_int8* V215_iter; 25268 25269 npy_float64* V217_iter; 25270 25271 npy_float64* V219_iter; 25272 25273 npy_float64* V221_iter; 25274 25275 npy_float64* V223_iter; 25276 25277 npy_float64* V225_iter; 25278 25279 npy_float64* V227_iter; 25280 25281 npy_int8* V229_iter; 25282 25283 npy_float64* V231_iter; 25284 25285 npy_float64* V233_iter; 25286 25287 npy_float64* V235_iter; 25288 25289 npy_float64* V237_iter; 25290 25291 npy_float64* V239_iter; 25292 25293 npy_float64* V241_iter; 25294 25295 npy_float64* V243_iter; 25296 25297 npy_int8* V245_iter; 25298 25299 npy_float64* V247_iter; 25300 25301 npy_float64* V249_iter; 25302 25303 npy_float64* V251_iter; 25304 25305 npy_float64* V253_iter; 25306 25307 npy_float64* V255_iter; 25308 25309 npy_float64* V257_iter; 25310 25311 npy_float64* V259_iter; 25312 25313 npy_int8* V261_iter; 25314 25315 npy_float64* V263_iter; 25316 25317 npy_float64* V265_iter; 25318 25319 npy_float64* V267_iter; 25320 25321 npy_float64* V269_iter; 25322 25323 npy_float64* V271_iter; 25324 25325 npy_float64* V273_iter; 25326 25327 npy_int8* V275_iter; 25328 25329 npy_float64* V277_iter; 25330 25331 npy_float64* V279_iter; 25332 25333 npy_float64* V281_iter; 25334 25335 npy_float64* V283_iter; 25336 25337 npy_float64* V285_iter; 25338 25339 npy_int8* V287_iter; 25340 25341 npy_float64* V289_iter; 25342 25343 npy_float64* V291_iter; 25344 25345 npy_float64* V293_iter; 25346 25347 npy_float64* V295_iter; 25348 25349 npy_float64* V297_iter; 25350 25351 npy_float64* V299_iter; 25352 25353 npy_int8* V301_iter; 25354 25355 npy_float64* V303_iter; 25356 25357 npy_float64* V305_iter; 25358 25359 npy_float64* V307_iter; 25360 25361 npy_float64* V309_iter; 25362 25363 npy_float64* V311_iter; 25364 25365 npy_float64* V313_iter; 25366 25367 npy_float64* V315_iter; 25368 25369 npy_int8* V317_iter; 25370 25371 npy_float64* V319_iter; 25372 25373 npy_float64* V321_iter; 25374 25375 npy_float64* V323_iter; 25376 25377 npy_float64* V325_iter; 25378 25379 npy_float64* V327_iter; 25380 25381 npy_float64* V329_iter; 25382 25383 npy_float64* V331_iter; 25384 25385 npy_int8* V333_iter; 25386 25387 npy_float64* V335_iter; 25388 25389 npy_float64* V337_iter; 25390 25391 npy_float64* V339_iter; 25392 25393 npy_float64* V341_iter; 25394 25395 npy_float64* V343_iter; 25396 25397 npy_float64* V345_iter; 25398 25399 npy_float64* V347_iter; 25400 25401 npy_int8* V349_iter; 25402 25403 npy_float64* V351_iter; 25404 25405 npy_float64* V353_iter; 25406 25407 npy_float64* V355_iter; 25408 25409 npy_float64* V357_iter; 25410 25411 npy_float64* V359_iter; 25412 25413 npy_float64* V361_iter; 25414 25415 npy_float64* V363_iter; 25416 25417 npy_int8* V365_iter; 25418 25419 npy_float64* V367_iter; 25420 25421 npy_float64* V369_iter; 25422 25423 npy_float64* V371_iter; 25424 25425 npy_float64* V373_iter; 25426 25427 npy_float64* V375_iter; 25428 25429 npy_float64* V377_iter; 25430 25431 npy_int8* V379_iter; 25432 25433 npy_float64* V381_iter; 25434 25435 npy_float64* V383_iter; 25436 25437 npy_float64* V385_iter; 25438 25439 npy_float64* V387_iter; 25440 25441 npy_float64* V389_iter; 25442 25443 npy_float64* V391_iter; 25444 25445 npy_int8* V393_iter; 25446 25447 npy_float64* V395_iter; 25448 25449 npy_float64* V397_iter; 25450 25451 npy_float64* V399_iter; 25452 25453 npy_float64* V401_iter; 25454 25455 npy_float64* V403_iter; 25456 25457 npy_float64* V405_iter; 25458 25459 npy_int8* V407_iter; 25460 25461 npy_float64* V409_iter; 25462 25463 npy_float64* V411_iter; 25464 25465 npy_float64* V413_iter; 25466 25467 npy_float64* V415_iter; 25468 25469 npy_float64* V417_iter; 25470 25471 npy_float64* V419_iter; 25472 25473 npy_int8* V421_iter; 25474 25475 npy_float64* V423_iter; 25476 25477 npy_float64* V425_iter; 25478 25479 npy_float64* V427_iter; 25480 25481 npy_float64* V429_iter; 25482 25483 npy_float64* V431_iter; 25484 25485 npy_float64* V433_iter; 25486 25487 npy_float64* V435_iter; 25488 25489 npy_int8* V437_iter; 25490 25491 npy_float64* V439_iter; 25492 25493 npy_float64* V441_iter; 25494 25495 npy_float64* V443_iter; 25496 25497 npy_float64* V445_iter; 25498 25499 npy_float64* V447_iter; 25500 25501 npy_float64* V449_iter; 25502 25503 npy_float64* V451_iter; 25504 25505 npy_int8* V453_iter; 25506 25507 npy_float64* V455_iter; 25508 25509 npy_float64* V457_iter; 25510 25511 npy_float64* V459_iter; 25512 25513 npy_float64* V461_iter; 25514 25515 npy_float64* V463_iter; 25516 25517 npy_float64* V465_iter; 25518 25519 npy_int8* V467_iter; 25520 25521 npy_float64* V469_iter; 25522 25523 npy_float64* V471_iter; 25524 25525 npy_float64* V473_iter; 25526 25527 npy_float64* V475_iter; 25528 25529 npy_float64* V477_iter; 25530 25531 npy_float64* V479_iter; 25532 25533 npy_float64* V481_iter; 25534 25535 npy_float64* V483_iter; 25536 25537 npy_int8* V485_iter; 25538 25539 npy_float64* V487_iter; 25540 25541 npy_float64* V489_iter; 25542 25543 npy_float64* V491_iter; 25544 25545 npy_float64* V493_iter; 25546 25547 npy_float64* V495_iter; 25548 25549 npy_float64* V497_iter; 25550 25551 npy_int8* V499_iter; 25552 25553 npy_float64* V501_iter; 25554 25555 npy_float64* V503_iter; 25556 25557 npy_float64* V505_iter; 25558 25559 npy_float64* V507_iter; 25560 25561 npy_float64* V509_iter; 25562 25563 25564 25565 npy_float64* V1_iter; 25566 25567 { 25568 npy_intp dims[0]; 25569 //npy_intp* dims = (npy_intp*)malloc(0 * sizeof(npy_intp)); 25570 25571 if (!V1) { 25572 V1 = (PyArrayObject*)PyArray_EMPTY(0, dims, 25573 NPY_FLOAT64, 25574 0); 25575 } 25576 else { 25577 PyArray_Dims new_dims; 25578 new_dims.len = 0; 25579 new_dims.ptr = dims; 25580 PyObject* success = PyArray_Resize(V1, &new_dims, 0, NPY_CORDER); 25581 if (!success) { 25582 // If we can't resize the ndarray we have we can allocate a new one. 25583 PyErr_Clear(); 25584 Py_XDECREF(V1); 25585 V1 = (PyArrayObject*)PyArray_EMPTY(0, dims, NPY_FLOAT64, 0); 25586 } 25587 } 25588 if (!V1) { 25589 { 25590 __failure = 511; 25591 if (!PyErr_Occurred()) { 25592 PyErr_SetString(PyExc_RuntimeError, 25593 "Unexpected error in an Op's C code. " 25594 "No Python exception was set."); 25595 } 25596 goto __label_511;} 25597 } 25598 } 25599 25600 25601 { 25602 25603 V3_iter = (npy_float64*)(PyArray_DATA(V3)); 25604 V5_iter = (npy_int8*)(PyArray_DATA(V5)); 25605 V7_iter = (npy_float64*)(PyArray_DATA(V7)); 25606 V9_iter = (npy_float64*)(PyArray_DATA(V9)); 25607 V11_iter = (npy_float64*)(PyArray_DATA(V11)); 25608 V13_iter = (npy_float64*)(PyArray_DATA(V13)); 25609 V15_iter = (npy_int8*)(PyArray_DATA(V15)); 25610 V17_iter = (npy_float64*)(PyArray_DATA(V17)); 25611 V19_iter = (npy_float64*)(PyArray_DATA(V19)); 25612 V21_iter = (npy_float64*)(PyArray_DATA(V21)); 25613 V23_iter = (npy_float64*)(PyArray_DATA(V23)); 25614 V25_iter = (npy_int8*)(PyArray_DATA(V25)); 25615 V27_iter = (npy_float64*)(PyArray_DATA(V27)); 25616 V29_iter = (npy_float64*)(PyArray_DATA(V29)); 25617 V31_iter = (npy_float64*)(PyArray_DATA(V31)); 25618 V33_iter = (npy_float64*)(PyArray_DATA(V33)); 25619 V35_iter = (npy_float64*)(PyArray_DATA(V35)); 25620 V37_iter = (npy_float64*)(PyArray_DATA(V37)); 25621 V39_iter = (npy_float64*)(PyArray_DATA(V39)); 25622 V41_iter = (npy_int8*)(PyArray_DATA(V41)); 25623 V43_iter = (npy_float64*)(PyArray_DATA(V43)); 25624 V45_iter = (npy_float64*)(PyArray_DATA(V45)); 25625 V47_iter = (npy_float64*)(PyArray_DATA(V47)); 25626 V49_iter = (npy_float64*)(PyArray_DATA(V49)); 25627 V51_iter = (npy_float64*)(PyArray_DATA(V51)); 25628 V53_iter = (npy_float64*)(PyArray_DATA(V53)); 25629 V55_iter = (npy_float64*)(PyArray_DATA(V55)); 25630 V57_iter = (npy_int8*)(PyArray_DATA(V57)); 25631 V59_iter = (npy_float64*)(PyArray_DATA(V59)); 25632 V61_iter = (npy_float64*)(PyArray_DATA(V61)); 25633 V63_iter = (npy_float64*)(PyArray_DATA(V63)); 25634 V65_iter = (npy_float64*)(PyArray_DATA(V65)); 25635 V67_iter = (npy_float64*)(PyArray_DATA(V67)); 25636 V69_iter = (npy_float64*)(PyArray_DATA(V69)); 25637 V71_iter = (npy_int8*)(PyArray_DATA(V71)); 25638 V73_iter = (npy_float64*)(PyArray_DATA(V73)); 25639 V75_iter = (npy_float64*)(PyArray_DATA(V75)); 25640 V77_iter = (npy_float64*)(PyArray_DATA(V77)); 25641 V79_iter = (npy_float64*)(PyArray_DATA(V79)); 25642 V81_iter = (npy_float64*)(PyArray_DATA(V81)); 25643 V83_iter = (npy_int8*)(PyArray_DATA(V83)); 25644 V85_iter = (npy_float64*)(PyArray_DATA(V85)); 25645 V87_iter = (npy_float64*)(PyArray_DATA(V87)); 25646 V89_iter = (npy_float64*)(PyArray_DATA(V89)); 25647 V91_iter = (npy_float64*)(PyArray_DATA(V91)); 25648 V93_iter = (npy_float64*)(PyArray_DATA(V93)); 25649 V95_iter = (npy_int8*)(PyArray_DATA(V95)); 25650 V97_iter = (npy_float64*)(PyArray_DATA(V97)); 25651 V99_iter = (npy_float64*)(PyArray_DATA(V99)); 25652 V101_iter = (npy_float64*)(PyArray_DATA(V101)); 25653 V103_iter = (npy_float64*)(PyArray_DATA(V103)); 25654 V105_iter = (npy_float64*)(PyArray_DATA(V105)); 25655 V107_iter = (npy_int8*)(PyArray_DATA(V107)); 25656 V109_iter = (npy_float64*)(PyArray_DATA(V109)); 25657 V111_iter = (npy_float64*)(PyArray_DATA(V111)); 25658 V113_iter = (npy_float64*)(PyArray_DATA(V113)); 25659 V115_iter = (npy_float64*)(PyArray_DATA(V115)); 25660 V117_iter = (npy_float64*)(PyArray_DATA(V117)); 25661 V119_iter = (npy_float64*)(PyArray_DATA(V119)); 25662 V121_iter = (npy_int8*)(PyArray_DATA(V121)); 25663 V123_iter = (npy_float64*)(PyArray_DATA(V123)); 25664 V125_iter = (npy_float64*)(PyArray_DATA(V125)); 25665 V127_iter = (npy_float64*)(PyArray_DATA(V127)); 25666 V129_iter = (npy_float64*)(PyArray_DATA(V129)); 25667 V131_iter = (npy_float64*)(PyArray_DATA(V131)); 25668 V133_iter = (npy_float64*)(PyArray_DATA(V133)); 25669 V135_iter = (npy_int8*)(PyArray_DATA(V135)); 25670 V137_iter = (npy_float64*)(PyArray_DATA(V137)); 25671 V139_iter = (npy_float64*)(PyArray_DATA(V139)); 25672 V141_iter = (npy_float64*)(PyArray_DATA(V141)); 25673 V143_iter = (npy_float64*)(PyArray_DATA(V143)); 25674 V145_iter = (npy_float64*)(PyArray_DATA(V145)); 25675 V147_iter = (npy_int8*)(PyArray_DATA(V147)); 25676 V149_iter = (npy_float64*)(PyArray_DATA(V149)); 25677 V151_iter = (npy_float64*)(PyArray_DATA(V151)); 25678 V153_iter = (npy_float64*)(PyArray_DATA(V153)); 25679 V155_iter = (npy_float64*)(PyArray_DATA(V155)); 25680 V157_iter = (npy_float64*)(PyArray_DATA(V157)); 25681 V159_iter = (npy_float64*)(PyArray_DATA(V159)); 25682 V161_iter = (npy_int8*)(PyArray_DATA(V161)); 25683 V163_iter = (npy_float64*)(PyArray_DATA(V163)); 25684 V165_iter = (npy_float64*)(PyArray_DATA(V165)); 25685 V167_iter = (npy_float64*)(PyArray_DATA(V167)); 25686 V169_iter = (npy_float64*)(PyArray_DATA(V169)); 25687 V171_iter = (npy_float64*)(PyArray_DATA(V171)); 25688 V173_iter = (npy_float64*)(PyArray_DATA(V173)); 25689 V175_iter = (npy_int8*)(PyArray_DATA(V175)); 25690 V177_iter = (npy_float64*)(PyArray_DATA(V177)); 25691 V179_iter = (npy_float64*)(PyArray_DATA(V179)); 25692 V181_iter = (npy_float64*)(PyArray_DATA(V181)); 25693 V183_iter = (npy_float64*)(PyArray_DATA(V183)); 25694 V185_iter = (npy_float64*)(PyArray_DATA(V185)); 25695 V187_iter = (npy_float64*)(PyArray_DATA(V187)); 25696 V189_iter = (npy_int8*)(PyArray_DATA(V189)); 25697 V191_iter = (npy_float64*)(PyArray_DATA(V191)); 25698 V193_iter = (npy_float64*)(PyArray_DATA(V193)); 25699 V195_iter = (npy_float64*)(PyArray_DATA(V195)); 25700 V197_iter = (npy_float64*)(PyArray_DATA(V197)); 25701 V199_iter = (npy_float64*)(PyArray_DATA(V199)); 25702 V201_iter = (npy_float64*)(PyArray_DATA(V201)); 25703 V203_iter = (npy_int8*)(PyArray_DATA(V203)); 25704 V205_iter = (npy_float64*)(PyArray_DATA(V205)); 25705 V207_iter = (npy_float64*)(PyArray_DATA(V207)); 25706 V209_iter = (npy_float64*)(PyArray_DATA(V209)); 25707 V211_iter = (npy_float64*)(PyArray_DATA(V211)); 25708 V213_iter = (npy_float64*)(PyArray_DATA(V213)); 25709 V215_iter = (npy_int8*)(PyArray_DATA(V215)); 25710 V217_iter = (npy_float64*)(PyArray_DATA(V217)); 25711 V219_iter = (npy_float64*)(PyArray_DATA(V219)); 25712 V221_iter = (npy_float64*)(PyArray_DATA(V221)); 25713 V223_iter = (npy_float64*)(PyArray_DATA(V223)); 25714 V225_iter = (npy_float64*)(PyArray_DATA(V225)); 25715 V227_iter = (npy_float64*)(PyArray_DATA(V227)); 25716 V229_iter = (npy_int8*)(PyArray_DATA(V229)); 25717 V231_iter = (npy_float64*)(PyArray_DATA(V231)); 25718 V233_iter = (npy_float64*)(PyArray_DATA(V233)); 25719 V235_iter = (npy_float64*)(PyArray_DATA(V235)); 25720 V237_iter = (npy_float64*)(PyArray_DATA(V237)); 25721 V239_iter = (npy_float64*)(PyArray_DATA(V239)); 25722 V241_iter = (npy_float64*)(PyArray_DATA(V241)); 25723 V243_iter = (npy_float64*)(PyArray_DATA(V243)); 25724 V245_iter = (npy_int8*)(PyArray_DATA(V245)); 25725 V247_iter = (npy_float64*)(PyArray_DATA(V247)); 25726 V249_iter = (npy_float64*)(PyArray_DATA(V249)); 25727 V251_iter = (npy_float64*)(PyArray_DATA(V251)); 25728 V253_iter = (npy_float64*)(PyArray_DATA(V253)); 25729 V255_iter = (npy_float64*)(PyArray_DATA(V255)); 25730 V257_iter = (npy_float64*)(PyArray_DATA(V257)); 25731 V259_iter = (npy_float64*)(PyArray_DATA(V259)); 25732 V261_iter = (npy_int8*)(PyArray_DATA(V261)); 25733 V263_iter = (npy_float64*)(PyArray_DATA(V263)); 25734 V265_iter = (npy_float64*)(PyArray_DATA(V265)); 25735 V267_iter = (npy_float64*)(PyArray_DATA(V267)); 25736 V269_iter = (npy_float64*)(PyArray_DATA(V269)); 25737 V271_iter = (npy_float64*)(PyArray_DATA(V271)); 25738 V273_iter = (npy_float64*)(PyArray_DATA(V273)); 25739 V275_iter = (npy_int8*)(PyArray_DATA(V275)); 25740 V277_iter = (npy_float64*)(PyArray_DATA(V277)); 25741 V279_iter = (npy_float64*)(PyArray_DATA(V279)); 25742 V281_iter = (npy_float64*)(PyArray_DATA(V281)); 25743 V283_iter = (npy_float64*)(PyArray_DATA(V283)); 25744 V285_iter = (npy_float64*)(PyArray_DATA(V285)); 25745 V287_iter = (npy_int8*)(PyArray_DATA(V287)); 25746 V289_iter = (npy_float64*)(PyArray_DATA(V289)); 25747 V291_iter = (npy_float64*)(PyArray_DATA(V291)); 25748 V293_iter = (npy_float64*)(PyArray_DATA(V293)); 25749 V295_iter = (npy_float64*)(PyArray_DATA(V295)); 25750 V297_iter = (npy_float64*)(PyArray_DATA(V297)); 25751 V299_iter = (npy_float64*)(PyArray_DATA(V299)); 25752 V301_iter = (npy_int8*)(PyArray_DATA(V301)); 25753 V303_iter = (npy_float64*)(PyArray_DATA(V303)); 25754 V305_iter = (npy_float64*)(PyArray_DATA(V305)); 25755 V307_iter = (npy_float64*)(PyArray_DATA(V307)); 25756 V309_iter = (npy_float64*)(PyArray_DATA(V309)); 25757 V311_iter = (npy_float64*)(PyArray_DATA(V311)); 25758 V313_iter = (npy_float64*)(PyArray_DATA(V313)); 25759 V315_iter = (npy_float64*)(PyArray_DATA(V315)); 25760 V317_iter = (npy_int8*)(PyArray_DATA(V317)); 25761 V319_iter = (npy_float64*)(PyArray_DATA(V319)); 25762 V321_iter = (npy_float64*)(PyArray_DATA(V321)); 25763 V323_iter = (npy_float64*)(PyArray_DATA(V323)); 25764 V325_iter = (npy_float64*)(PyArray_DATA(V325)); 25765 V327_iter = (npy_float64*)(PyArray_DATA(V327)); 25766 V329_iter = (npy_float64*)(PyArray_DATA(V329)); 25767 V331_iter = (npy_float64*)(PyArray_DATA(V331)); 25768 V333_iter = (npy_int8*)(PyArray_DATA(V333)); 25769 V335_iter = (npy_float64*)(PyArray_DATA(V335)); 25770 V337_iter = (npy_float64*)(PyArray_DATA(V337)); 25771 V339_iter = (npy_float64*)(PyArray_DATA(V339)); 25772 V341_iter = (npy_float64*)(PyArray_DATA(V341)); 25773 V343_iter = (npy_float64*)(PyArray_DATA(V343)); 25774 V345_iter = (npy_float64*)(PyArray_DATA(V345)); 25775 V347_iter = (npy_float64*)(PyArray_DATA(V347)); 25776 V349_iter = (npy_int8*)(PyArray_DATA(V349)); 25777 V351_iter = (npy_float64*)(PyArray_DATA(V351)); 25778 V353_iter = (npy_float64*)(PyArray_DATA(V353)); 25779 V355_iter = (npy_float64*)(PyArray_DATA(V355)); 25780 V357_iter = (npy_float64*)(PyArray_DATA(V357)); 25781 V359_iter = (npy_float64*)(PyArray_DATA(V359)); 25782 V361_iter = (npy_float64*)(PyArray_DATA(V361)); 25783 V363_iter = (npy_float64*)(PyArray_DATA(V363)); 25784 V365_iter = (npy_int8*)(PyArray_DATA(V365)); 25785 V367_iter = (npy_float64*)(PyArray_DATA(V367)); 25786 V369_iter = (npy_float64*)(PyArray_DATA(V369)); 25787 V371_iter = (npy_float64*)(PyArray_DATA(V371)); 25788 V373_iter = (npy_float64*)(PyArray_DATA(V373)); 25789 V375_iter = (npy_float64*)(PyArray_DATA(V375)); 25790 V377_iter = (npy_float64*)(PyArray_DATA(V377)); 25791 V379_iter = (npy_int8*)(PyArray_DATA(V379)); 25792 V381_iter = (npy_float64*)(PyArray_DATA(V381)); 25793 V383_iter = (npy_float64*)(PyArray_DATA(V383)); 25794 V385_iter = (npy_float64*)(PyArray_DATA(V385)); 25795 V387_iter = (npy_float64*)(PyArray_DATA(V387)); 25796 V389_iter = (npy_float64*)(PyArray_DATA(V389)); 25797 V391_iter = (npy_float64*)(PyArray_DATA(V391)); 25798 V393_iter = (npy_int8*)(PyArray_DATA(V393)); 25799 V395_iter = (npy_float64*)(PyArray_DATA(V395)); 25800 V397_iter = (npy_float64*)(PyArray_DATA(V397)); 25801 V399_iter = (npy_float64*)(PyArray_DATA(V399)); 25802 V401_iter = (npy_float64*)(PyArray_DATA(V401)); 25803 V403_iter = (npy_float64*)(PyArray_DATA(V403)); 25804 V405_iter = (npy_float64*)(PyArray_DATA(V405)); 25805 V407_iter = (npy_int8*)(PyArray_DATA(V407)); 25806 V409_iter = (npy_float64*)(PyArray_DATA(V409)); 25807 V411_iter = (npy_float64*)(PyArray_DATA(V411)); 25808 V413_iter = (npy_float64*)(PyArray_DATA(V413)); 25809 V415_iter = (npy_float64*)(PyArray_DATA(V415)); 25810 V417_iter = (npy_float64*)(PyArray_DATA(V417)); 25811 V419_iter = (npy_float64*)(PyArray_DATA(V419)); 25812 V421_iter = (npy_int8*)(PyArray_DATA(V421)); 25813 V423_iter = (npy_float64*)(PyArray_DATA(V423)); 25814 V425_iter = (npy_float64*)(PyArray_DATA(V425)); 25815 V427_iter = (npy_float64*)(PyArray_DATA(V427)); 25816 V429_iter = (npy_float64*)(PyArray_DATA(V429)); 25817 V431_iter = (npy_float64*)(PyArray_DATA(V431)); 25818 V433_iter = (npy_float64*)(PyArray_DATA(V433)); 25819 V435_iter = (npy_float64*)(PyArray_DATA(V435)); 25820 V437_iter = (npy_int8*)(PyArray_DATA(V437)); 25821 V439_iter = (npy_float64*)(PyArray_DATA(V439)); 25822 V441_iter = (npy_float64*)(PyArray_DATA(V441)); 25823 V443_iter = (npy_float64*)(PyArray_DATA(V443)); 25824 V445_iter = (npy_float64*)(PyArray_DATA(V445)); 25825 V447_iter = (npy_float64*)(PyArray_DATA(V447)); 25826 V449_iter = (npy_float64*)(PyArray_DATA(V449)); 25827 V451_iter = (npy_float64*)(PyArray_DATA(V451)); 25828 V453_iter = (npy_int8*)(PyArray_DATA(V453)); 25829 V455_iter = (npy_float64*)(PyArray_DATA(V455)); 25830 V457_iter = (npy_float64*)(PyArray_DATA(V457)); 25831 V459_iter = (npy_float64*)(PyArray_DATA(V459)); 25832 V461_iter = (npy_float64*)(PyArray_DATA(V461)); 25833 V463_iter = (npy_float64*)(PyArray_DATA(V463)); 25834 V465_iter = (npy_float64*)(PyArray_DATA(V465)); 25835 V467_iter = (npy_int8*)(PyArray_DATA(V467)); 25836 V469_iter = (npy_float64*)(PyArray_DATA(V469)); 25837 V471_iter = (npy_float64*)(PyArray_DATA(V471)); 25838 V473_iter = (npy_float64*)(PyArray_DATA(V473)); 25839 V475_iter = (npy_float64*)(PyArray_DATA(V475)); 25840 V477_iter = (npy_float64*)(PyArray_DATA(V477)); 25841 V479_iter = (npy_float64*)(PyArray_DATA(V479)); 25842 V481_iter = (npy_float64*)(PyArray_DATA(V481)); 25843 V483_iter = (npy_float64*)(PyArray_DATA(V483)); 25844 V485_iter = (npy_int8*)(PyArray_DATA(V485)); 25845 V487_iter = (npy_float64*)(PyArray_DATA(V487)); 25846 V489_iter = (npy_float64*)(PyArray_DATA(V489)); 25847 V491_iter = (npy_float64*)(PyArray_DATA(V491)); 25848 V493_iter = (npy_float64*)(PyArray_DATA(V493)); 25849 V495_iter = (npy_float64*)(PyArray_DATA(V495)); 25850 V497_iter = (npy_float64*)(PyArray_DATA(V497)); 25851 V499_iter = (npy_int8*)(PyArray_DATA(V499)); 25852 V501_iter = (npy_float64*)(PyArray_DATA(V501)); 25853 V503_iter = (npy_float64*)(PyArray_DATA(V503)); 25854 V505_iter = (npy_float64*)(PyArray_DATA(V505)); 25855 V507_iter = (npy_float64*)(PyArray_DATA(V507)); 25856 V509_iter = (npy_float64*)(PyArray_DATA(V509)); 25857 V1_iter = (npy_float64*)(PyArray_DATA(V1)); 25858 25859 npy_float64& V3_i = *V3_iter; 25860 npy_int8& V5_i = *V5_iter; 25861 npy_float64& V7_i = *V7_iter; 25862 npy_float64& V9_i = *V9_iter; 25863 npy_float64& V11_i = *V11_iter; 25864 npy_float64& V13_i = *V13_iter; 25865 npy_int8& V15_i = *V15_iter; 25866 npy_float64& V17_i = *V17_iter; 25867 npy_float64& V19_i = *V19_iter; 25868 npy_float64& V21_i = *V21_iter; 25869 npy_float64& V23_i = *V23_iter; 25870 npy_int8& V25_i = *V25_iter; 25871 npy_float64& V27_i = *V27_iter; 25872 npy_float64& V29_i = *V29_iter; 25873 npy_float64& V31_i = *V31_iter; 25874 npy_float64& V33_i = *V33_iter; 25875 npy_float64& V35_i = *V35_iter; 25876 npy_float64& V37_i = *V37_iter; 25877 npy_float64& V39_i = *V39_iter; 25878 npy_int8& V41_i = *V41_iter; 25879 npy_float64& V43_i = *V43_iter; 25880 npy_float64& V45_i = *V45_iter; 25881 npy_float64& V47_i = *V47_iter; 25882 npy_float64& V49_i = *V49_iter; 25883 npy_float64& V51_i = *V51_iter; 25884 npy_float64& V53_i = *V53_iter; 25885 npy_float64& V55_i = *V55_iter; 25886 npy_int8& V57_i = *V57_iter; 25887 npy_float64& V59_i = *V59_iter; 25888 npy_float64& V61_i = *V61_iter; 25889 npy_float64& V63_i = *V63_iter; 25890 npy_float64& V65_i = *V65_iter; 25891 npy_float64& V67_i = *V67_iter; 25892 npy_float64& V69_i = *V69_iter; 25893 npy_int8& V71_i = *V71_iter; 25894 npy_float64& V73_i = *V73_iter; 25895 npy_float64& V75_i = *V75_iter; 25896 npy_float64& V77_i = *V77_iter; 25897 npy_float64& V79_i = *V79_iter; 25898 npy_float64& V81_i = *V81_iter; 25899 npy_int8& V83_i = *V83_iter; 25900 npy_float64& V85_i = *V85_iter; 25901 npy_float64& V87_i = *V87_iter; 25902 npy_float64& V89_i = *V89_iter; 25903 npy_float64& V91_i = *V91_iter; 25904 npy_float64& V93_i = *V93_iter; 25905 npy_int8& V95_i = *V95_iter; 25906 npy_float64& V97_i = *V97_iter; 25907 npy_float64& V99_i = *V99_iter; 25908 npy_float64& V101_i = *V101_iter; 25909 npy_float64& V103_i = *V103_iter; 25910 npy_float64& V105_i = *V105_iter; 25911 npy_int8& V107_i = *V107_iter; 25912 npy_float64& V109_i = *V109_iter; 25913 npy_float64& V111_i = *V111_iter; 25914 npy_float64& V113_i = *V113_iter; 25915 npy_float64& V115_i = *V115_iter; 25916 npy_float64& V117_i = *V117_iter; 25917 npy_float64& V119_i = *V119_iter; 25918 npy_int8& V121_i = *V121_iter; 25919 npy_float64& V123_i = *V123_iter; 25920 npy_float64& V125_i = *V125_iter; 25921 npy_float64& V127_i = *V127_iter; 25922 npy_float64& V129_i = *V129_iter; 25923 npy_float64& V131_i = *V131_iter; 25924 npy_float64& V133_i = *V133_iter; 25925 npy_int8& V135_i = *V135_iter; 25926 npy_float64& V137_i = *V137_iter; 25927 npy_float64& V139_i = *V139_iter; 25928 npy_float64& V141_i = *V141_iter; 25929 npy_float64& V143_i = *V143_iter; 25930 npy_float64& V145_i = *V145_iter; 25931 npy_int8& V147_i = *V147_iter; 25932 npy_float64& V149_i = *V149_iter; 25933 npy_float64& V151_i = *V151_iter; 25934 npy_float64& V153_i = *V153_iter; 25935 npy_float64& V155_i = *V155_iter; 25936 npy_float64& V157_i = *V157_iter; 25937 npy_float64& V159_i = *V159_iter; 25938 npy_int8& V161_i = *V161_iter; 25939 npy_float64& V163_i = *V163_iter; 25940 npy_float64& V165_i = *V165_iter; 25941 npy_float64& V167_i = *V167_iter; 25942 npy_float64& V169_i = *V169_iter; 25943 npy_float64& V171_i = *V171_iter; 25944 npy_float64& V173_i = *V173_iter; 25945 npy_int8& V175_i = *V175_iter; 25946 npy_float64& V177_i = *V177_iter; 25947 npy_float64& V179_i = *V179_iter; 25948 npy_float64& V181_i = *V181_iter; 25949 npy_float64& V183_i = *V183_iter; 25950 npy_float64& V185_i = *V185_iter; 25951 npy_float64& V187_i = *V187_iter; 25952 npy_int8& V189_i = *V189_iter; 25953 npy_float64& V191_i = *V191_iter; 25954 npy_float64& V193_i = *V193_iter; 25955 npy_float64& V195_i = *V195_iter; 25956 npy_float64& V197_i = *V197_iter; 25957 npy_float64& V199_i = *V199_iter; 25958 npy_float64& V201_i = *V201_iter; 25959 npy_int8& V203_i = *V203_iter; 25960 npy_float64& V205_i = *V205_iter; 25961 npy_float64& V207_i = *V207_iter; 25962 npy_float64& V209_i = *V209_iter; 25963 npy_float64& V211_i = *V211_iter; 25964 npy_float64& V213_i = *V213_iter; 25965 npy_int8& V215_i = *V215_iter; 25966 npy_float64& V217_i = *V217_iter; 25967 npy_float64& V219_i = *V219_iter; 25968 npy_float64& V221_i = *V221_iter; 25969 npy_float64& V223_i = *V223_iter; 25970 npy_float64& V225_i = *V225_iter; 25971 npy_float64& V227_i = *V227_iter; 25972 npy_int8& V229_i = *V229_iter; 25973 npy_float64& V231_i = *V231_iter; 25974 npy_float64& V233_i = *V233_iter; 25975 npy_float64& V235_i = *V235_iter; 25976 npy_float64& V237_i = *V237_iter; 25977 npy_float64& V239_i = *V239_iter; 25978 npy_float64& V241_i = *V241_iter; 25979 npy_float64& V243_i = *V243_iter; 25980 npy_int8& V245_i = *V245_iter; 25981 npy_float64& V247_i = *V247_iter; 25982 npy_float64& V249_i = *V249_iter; 25983 npy_float64& V251_i = *V251_iter; 25984 npy_float64& V253_i = *V253_iter; 25985 npy_float64& V255_i = *V255_iter; 25986 npy_float64& V257_i = *V257_iter; 25987 npy_float64& V259_i = *V259_iter; 25988 npy_int8& V261_i = *V261_iter; 25989 npy_float64& V263_i = *V263_iter; 25990 npy_float64& V265_i = *V265_iter; 25991 npy_float64& V267_i = *V267_iter; 25992 npy_float64& V269_i = *V269_iter; 25993 npy_float64& V271_i = *V271_iter; 25994 npy_float64& V273_i = *V273_iter; 25995 npy_int8& V275_i = *V275_iter; 25996 npy_float64& V277_i = *V277_iter; 25997 npy_float64& V279_i = *V279_iter; 25998 npy_float64& V281_i = *V281_iter; 25999 npy_float64& V283_i = *V283_iter; 26000 npy_float64& V285_i = *V285_iter; 26001 npy_int8& V287_i = *V287_iter; 26002 npy_float64& V289_i = *V289_iter; 26003 npy_float64& V291_i = *V291_iter; 26004 npy_float64& V293_i = *V293_iter; 26005 npy_float64& V295_i = *V295_iter; 26006 npy_float64& V297_i = *V297_iter; 26007 npy_float64& V299_i = *V299_iter; 26008 npy_int8& V301_i = *V301_iter; 26009 npy_float64& V303_i = *V303_iter; 26010 npy_float64& V305_i = *V305_iter; 26011 npy_float64& V307_i = *V307_iter; 26012 npy_float64& V309_i = *V309_iter; 26013 npy_float64& V311_i = *V311_iter; 26014 npy_float64& V313_i = *V313_iter; 26015 npy_float64& V315_i = *V315_iter; 26016 npy_int8& V317_i = *V317_iter; 26017 npy_float64& V319_i = *V319_iter; 26018 npy_float64& V321_i = *V321_iter; 26019 npy_float64& V323_i = *V323_iter; 26020 npy_float64& V325_i = *V325_iter; 26021 npy_float64& V327_i = *V327_iter; 26022 npy_float64& V329_i = *V329_iter; 26023 npy_float64& V331_i = *V331_iter; 26024 npy_int8& V333_i = *V333_iter; 26025 npy_float64& V335_i = *V335_iter; 26026 npy_float64& V337_i = *V337_iter; 26027 npy_float64& V339_i = *V339_iter; 26028 npy_float64& V341_i = *V341_iter; 26029 npy_float64& V343_i = *V343_iter; 26030 npy_float64& V345_i = *V345_iter; 26031 npy_float64& V347_i = *V347_iter; 26032 npy_int8& V349_i = *V349_iter; 26033 npy_float64& V351_i = *V351_iter; 26034 npy_float64& V353_i = *V353_iter; 26035 npy_float64& V355_i = *V355_iter; 26036 npy_float64& V357_i = *V357_iter; 26037 npy_float64& V359_i = *V359_iter; 26038 npy_float64& V361_i = *V361_iter; 26039 npy_float64& V363_i = *V363_iter; 26040 npy_int8& V365_i = *V365_iter; 26041 npy_float64& V367_i = *V367_iter; 26042 npy_float64& V369_i = *V369_iter; 26043 npy_float64& V371_i = *V371_iter; 26044 npy_float64& V373_i = *V373_iter; 26045 npy_float64& V375_i = *V375_iter; 26046 npy_float64& V377_i = *V377_iter; 26047 npy_int8& V379_i = *V379_iter; 26048 npy_float64& V381_i = *V381_iter; 26049 npy_float64& V383_i = *V383_iter; 26050 npy_float64& V385_i = *V385_iter; 26051 npy_float64& V387_i = *V387_iter; 26052 npy_float64& V389_i = *V389_iter; 26053 npy_float64& V391_i = *V391_iter; 26054 npy_int8& V393_i = *V393_iter; 26055 npy_float64& V395_i = *V395_iter; 26056 npy_float64& V397_i = *V397_iter; 26057 npy_float64& V399_i = *V399_iter; 26058 npy_float64& V401_i = *V401_iter; 26059 npy_float64& V403_i = *V403_iter; 26060 npy_float64& V405_i = *V405_iter; 26061 npy_int8& V407_i = *V407_iter; 26062 npy_float64& V409_i = *V409_iter; 26063 npy_float64& V411_i = *V411_iter; 26064 npy_float64& V413_i = *V413_iter; 26065 npy_float64& V415_i = *V415_iter; 26066 npy_float64& V417_i = *V417_iter; 26067 npy_float64& V419_i = *V419_iter; 26068 npy_int8& V421_i = *V421_iter; 26069 npy_float64& V423_i = *V423_iter; 26070 npy_float64& V425_i = *V425_iter; 26071 npy_float64& V427_i = *V427_iter; 26072 npy_float64& V429_i = *V429_iter; 26073 npy_float64& V431_i = *V431_iter; 26074 npy_float64& V433_i = *V433_iter; 26075 npy_float64& V435_i = *V435_iter; 26076 npy_int8& V437_i = *V437_iter; 26077 npy_float64& V439_i = *V439_iter; 26078 npy_float64& V441_i = *V441_iter; 26079 npy_float64& V443_i = *V443_iter; 26080 npy_float64& V445_i = *V445_iter; 26081 npy_float64& V447_i = *V447_iter; 26082 npy_float64& V449_i = *V449_iter; 26083 npy_float64& V451_i = *V451_iter; 26084 npy_int8& V453_i = *V453_iter; 26085 npy_float64& V455_i = *V455_iter; 26086 npy_float64& V457_i = *V457_iter; 26087 npy_float64& V459_i = *V459_iter; 26088 npy_float64& V461_i = *V461_iter; 26089 npy_float64& V463_i = *V463_iter; 26090 npy_float64& V465_i = *V465_iter; 26091 npy_int8& V467_i = *V467_iter; 26092 npy_float64& V469_i = *V469_iter; 26093 npy_float64& V471_i = *V471_iter; 26094 npy_float64& V473_i = *V473_iter; 26095 npy_float64& V475_i = *V475_iter; 26096 npy_float64& V477_i = *V477_iter; 26097 npy_float64& V479_i = *V479_iter; 26098 npy_float64& V481_i = *V481_iter; 26099 npy_float64& V483_i = *V483_iter; 26100 npy_int8& V485_i = *V485_iter; 26101 npy_float64& V487_i = *V487_iter; 26102 npy_float64& V489_i = *V489_iter; 26103 npy_float64& V491_i = *V491_iter; 26104 npy_float64& V493_i = *V493_iter; 26105 npy_float64& V495_i = *V495_iter; 26106 npy_float64& V497_i = *V497_iter; 26107 npy_int8& V499_i = *V499_iter; 26108 npy_float64& V501_i = *V501_iter; 26109 npy_float64& V503_i = *V503_iter; 26110 npy_float64& V505_i = *V505_iter; 26111 npy_float64& V507_i = *V507_iter; 26112 npy_float64& V509_i = *V509_iter; 26113 npy_float64& V1_i = *V1_iter; 26114 26115 { 26116 npy_float64 V511_tmp1; 26117 V511_tmp1 = V9_i * V509_i * V501_i; 26118 npy_float64 V511_tmp2; 26119 V511_tmp2 = V505_i * V507_i; 26120 npy_float64 V511_tmp3; 26121 V511_tmp3 = V469_i * V9_i * V501_i * V503_i; 26122 npy_float64 V511_tmp4; 26123 V511_tmp4 = V483_i * V9_i * V497_i * V489_i; 26124 npy_float64 V511_tmp5; 26125 V511_tmp5 = V493_i * V483_i * V495_i; 26126 npy_float64 V511_tmp6; 26127 V511_tmp6 = V487_i * V9_i * V489_i * V491_i; 26128 npy_float64 V511_tmp7; 26129 V511_tmp7 = V481_i * V9_i; 26130 npy_float64 V511_tmp8; 26131 V511_tmp8 = V9_i * V479_i * V471_i; 26132 npy_float64 V511_tmp9; 26133 V511_tmp9 = V475_i * V477_i; 26134 npy_float64 V511_tmp10; 26135 V511_tmp10 = V469_i * V9_i * V471_i * V473_i; 26136 npy_float64 V511_tmp11; 26137 V511_tmp11 = V451_i * V9_i * V465_i * V457_i; 26138 npy_float64 V511_tmp12; 26139 V511_tmp12 = V461_i * V451_i * V463_i; 26140 npy_float64 V511_tmp13; 26141 V511_tmp13 = V455_i * V9_i * V457_i * V459_i; 26142 npy_float64 V511_tmp14; 26143 V511_tmp14 = V435_i * V9_i * V449_i * V441_i; 26144 npy_float64 V511_tmp15; 26145 V511_tmp15 = V445_i * V435_i * V447_i; 26146 npy_float64 V511_tmp16; 26147 V511_tmp16 = V439_i * V9_i * V441_i * V443_i; 26148 npy_float64 V511_tmp17; 26149 V511_tmp17 = V419_i * V9_i * V433_i * V425_i; 26150 npy_float64 V511_tmp18; 26151 V511_tmp18 = V429_i * V419_i * V431_i; 26152 npy_float64 V511_tmp19; 26153 V511_tmp19 = V423_i * V9_i * V425_i * V427_i; 26154 npy_float64 V511_tmp20; 26155 V511_tmp20 = V363_i * V9_i * V417_i * V409_i; 26156 npy_float64 V511_tmp21; 26157 V511_tmp21 = V413_i * V363_i * V415_i; 26158 npy_float64 V511_tmp22; 26159 V511_tmp22 = V367_i * V9_i * V409_i * V411_i; 26160 npy_float64 V511_tmp23; 26161 V511_tmp23 = V391_i * V9_i * V405_i * V397_i; 26162 npy_float64 V511_tmp24; 26163 V511_tmp24 = V401_i * V391_i * V403_i; 26164 npy_float64 V511_tmp25; 26165 V511_tmp25 = V395_i * V9_i * V397_i * V399_i; 26166 npy_float64 V511_tmp26; 26167 V511_tmp26 = V299_i * V9_i * V389_i * V381_i; 26168 npy_float64 V511_tmp27; 26169 V511_tmp27 = V385_i * V299_i * V387_i; 26170 npy_float64 V511_tmp28; 26171 V511_tmp28 = V303_i * V9_i * V381_i * V383_i; 26172 npy_float64 V511_tmp29; 26173 V511_tmp29 = V363_i * V9_i * V377_i * V369_i; 26174 npy_float64 V511_tmp30; 26175 V511_tmp30 = V373_i * V363_i * V375_i; 26176 npy_float64 V511_tmp31; 26177 V511_tmp31 = V367_i * V9_i * V369_i * V371_i; 26178 npy_float64 V511_tmp32; 26179 V511_tmp32 = V347_i * V9_i * V361_i * V353_i; 26180 npy_float64 V511_tmp33; 26181 V511_tmp33 = V357_i * V347_i * V359_i; 26182 npy_float64 V511_tmp34; 26183 V511_tmp34 = V351_i * V9_i * V353_i * V355_i; 26184 npy_float64 V511_tmp35; 26185 V511_tmp35 = V331_i * V9_i * V345_i * V337_i; 26186 npy_float64 V511_tmp36; 26187 V511_tmp36 = V341_i * V331_i * V343_i; 26188 npy_float64 V511_tmp37; 26189 V511_tmp37 = V335_i * V9_i * V337_i * V339_i; 26190 npy_float64 V511_tmp38; 26191 V511_tmp38 = V315_i * V9_i * V329_i * V321_i; 26192 npy_float64 V511_tmp39; 26193 V511_tmp39 = V325_i * V315_i * V327_i; 26194 npy_float64 V511_tmp40; 26195 V511_tmp40 = V319_i * V9_i * V321_i * V323_i; 26196 npy_float64 V511_tmp41; 26197 V511_tmp41 = V299_i * V9_i * V313_i * V305_i; 26198 npy_float64 V511_tmp42; 26199 V511_tmp42 = V309_i * V299_i * V311_i; 26200 npy_float64 V511_tmp43; 26201 V511_tmp43 = V303_i * V9_i * V305_i * V307_i; 26202 npy_float64 V511_tmp44; 26203 V511_tmp44 = V259_i * V9_i * V297_i * V289_i; 26204 npy_float64 V511_tmp45; 26205 V511_tmp45 = V293_i * V259_i * V295_i; 26206 npy_float64 V511_tmp46; 26207 V511_tmp46 = V263_i * V9_i * V289_i * V291_i; 26208 npy_float64 V511_tmp47; 26209 V511_tmp47 = V259_i * V9_i * V285_i * V277_i; 26210 npy_float64 V511_tmp48; 26211 V511_tmp48 = V281_i * V259_i * V283_i; 26212 npy_float64 V511_tmp49; 26213 V511_tmp49 = V263_i * V9_i * V277_i * V279_i; 26214 npy_float64 V511_tmp50; 26215 V511_tmp50 = V259_i * V9_i * V273_i * V265_i; 26216 npy_float64 V511_tmp51; 26217 V511_tmp51 = V269_i * V259_i * V271_i; 26218 npy_float64 V511_tmp52; 26219 V511_tmp52 = V263_i * V9_i * V265_i * V267_i; 26220 npy_float64 V511_tmp53; 26221 V511_tmp53 = V243_i * V9_i * V257_i * V249_i; 26222 npy_float64 V511_tmp54; 26223 V511_tmp54 = V253_i * V243_i * V255_i; 26224 npy_float64 V511_tmp55; 26225 V511_tmp55 = V247_i * V9_i * V249_i * V251_i; 26226 npy_float64 V511_tmp56; 26227 V511_tmp56 = V227_i * V9_i * V241_i * V233_i; 26228 npy_float64 V511_tmp57; 26229 V511_tmp57 = V237_i * V227_i * V239_i; 26230 npy_float64 V511_tmp58; 26231 V511_tmp58 = V231_i * V9_i * V233_i * V235_i; 26232 npy_float64 V511_tmp59; 26233 V511_tmp59 = V187_i * V9_i * V225_i * V217_i; 26234 npy_float64 V511_tmp60; 26235 V511_tmp60 = V221_i * V187_i * V223_i; 26236 npy_float64 V511_tmp61; 26237 V511_tmp61 = V191_i * V9_i * V217_i * V219_i; 26238 npy_float64 V511_tmp62; 26239 V511_tmp62 = V187_i * V9_i * V213_i * V205_i; 26240 npy_float64 V511_tmp63; 26241 V511_tmp63 = V209_i * V187_i * V211_i; 26242 npy_float64 V511_tmp64; 26243 V511_tmp64 = V191_i * V9_i * V205_i * V207_i; 26244 npy_float64 V511_tmp65; 26245 V511_tmp65 = V187_i * V9_i * V201_i * V193_i; 26246 npy_float64 V511_tmp66; 26247 V511_tmp66 = V197_i * V187_i * V199_i; 26248 npy_float64 V511_tmp67; 26249 V511_tmp67 = V191_i * V9_i * V193_i * V195_i; 26250 npy_float64 V511_tmp68; 26251 V511_tmp68 = V159_i * V9_i * V185_i * V177_i; 26252 npy_float64 V511_tmp69; 26253 V511_tmp69 = V181_i * V159_i * V183_i; 26254 npy_float64 V511_tmp70; 26255 V511_tmp70 = V163_i * V9_i * V177_i * V179_i; 26256 npy_float64 V511_tmp71; 26257 V511_tmp71 = V159_i * V9_i * V173_i * V165_i; 26258 npy_float64 V511_tmp72; 26259 V511_tmp72 = V169_i * V159_i * V171_i; 26260 npy_float64 V511_tmp73; 26261 V511_tmp73 = V163_i * V9_i * V165_i * V167_i; 26262 npy_float64 V511_tmp74; 26263 V511_tmp74 = V119_i * V9_i * V157_i * V149_i; 26264 npy_float64 V511_tmp75; 26265 V511_tmp75 = V153_i * V119_i * V155_i; 26266 npy_float64 V511_tmp76; 26267 V511_tmp76 = V123_i * V9_i * V149_i * V151_i; 26268 npy_float64 V511_tmp77; 26269 V511_tmp77 = V119_i * V9_i * V145_i * V137_i; 26270 npy_float64 V511_tmp78; 26271 V511_tmp78 = V141_i * V119_i * V143_i; 26272 npy_float64 V511_tmp79; 26273 V511_tmp79 = V123_i * V9_i * V137_i * V139_i; 26274 npy_float64 V511_tmp80; 26275 V511_tmp80 = V119_i * V9_i * V133_i * V125_i; 26276 npy_float64 V511_tmp81; 26277 V511_tmp81 = V129_i * V119_i * V131_i; 26278 npy_float64 V511_tmp82; 26279 V511_tmp82 = V123_i * V9_i * V125_i * V127_i; 26280 npy_float64 V511_tmp83; 26281 V511_tmp83 = V55_i * V9_i * V117_i * V109_i; 26282 npy_float64 V511_tmp84; 26283 V511_tmp84 = V113_i * V55_i * V115_i; 26284 npy_float64 V511_tmp85; 26285 V511_tmp85 = V59_i * V9_i * V109_i * V111_i; 26286 npy_float64 V511_tmp86; 26287 V511_tmp86 = V55_i * V9_i * V105_i * V97_i; 26288 npy_float64 V511_tmp87; 26289 V511_tmp87 = V101_i * V55_i * V103_i; 26290 npy_float64 V511_tmp88; 26291 V511_tmp88 = V59_i * V9_i * V97_i * V99_i; 26292 npy_float64 V511_tmp89; 26293 V511_tmp89 = V55_i * V9_i * V93_i * V85_i; 26294 npy_float64 V511_tmp90; 26295 V511_tmp90 = V89_i * V55_i * V91_i; 26296 npy_float64 V511_tmp91; 26297 V511_tmp91 = V59_i * V9_i * V85_i * V87_i; 26298 npy_float64 V511_tmp92; 26299 V511_tmp92 = V55_i * V9_i * V81_i * V73_i; 26300 npy_float64 V511_tmp93; 26301 V511_tmp93 = V77_i * V55_i * V79_i; 26302 npy_float64 V511_tmp94; 26303 V511_tmp94 = V59_i * V9_i * V73_i * V75_i; 26304 npy_float64 V511_tmp95; 26305 V511_tmp95 = V55_i * V9_i * V69_i * V61_i; 26306 npy_float64 V511_tmp96; 26307 V511_tmp96 = V65_i * V55_i * V67_i; 26308 npy_float64 V511_tmp97; 26309 V511_tmp97 = V59_i * V9_i * V61_i * V63_i; 26310 npy_float64 V511_tmp98; 26311 V511_tmp98 = V39_i * V9_i * V53_i * V45_i; 26312 npy_float64 V511_tmp99; 26313 V511_tmp99 = V49_i * V39_i * V51_i; 26314 npy_float64 V511_tmp100; 26315 V511_tmp100 = V43_i * V9_i * V45_i * V47_i; 26316 npy_float64 V511_tmp101; 26317 V511_tmp101 = V23_i * V9_i * V37_i * V29_i; 26318 npy_float64 V511_tmp102; 26319 V511_tmp102 = V33_i * V23_i * V35_i; 26320 npy_float64 V511_tmp103; 26321 V511_tmp103 = V27_i * V9_i * V29_i * V31_i; 26322 npy_float64 V511_tmp104; 26323 V511_tmp104 = V3_i * V9_i * V21_i * V11_i; 26324 npy_float64 V511_tmp105; 26325 V511_tmp105 = V17_i * V3_i * V19_i; 26326 npy_float64 V511_tmp106; 26327 V511_tmp106 = V7_i * V9_i * V11_i * V13_i; 26328 npy_float64 V511_tmp107; 26329 V511_tmp107 = V499_i ? V511_tmp2 : V15_i; 26330 npy_float64 V511_tmp108; 26331 V511_tmp108 = V499_i ? V511_tmp3 : V15_i; 26332 npy_float64 V511_tmp109; 26333 V511_tmp109 = V485_i ? V511_tmp5 : V15_i; 26334 npy_float64 V511_tmp110; 26335 V511_tmp110 = V485_i ? V511_tmp6 : V15_i; 26336 npy_float64 V511_tmp111; 26337 V511_tmp111 = V467_i ? V511_tmp9 : V15_i; 26338 npy_float64 V511_tmp112; 26339 V511_tmp112 = V467_i ? V511_tmp10 : V15_i; 26340 npy_float64 V511_tmp113; 26341 V511_tmp113 = V453_i ? V511_tmp12 : V15_i; 26342 npy_float64 V511_tmp114; 26343 V511_tmp114 = V453_i ? V511_tmp13 : V15_i; 26344 npy_float64 V511_tmp115; 26345 V511_tmp115 = V437_i ? V511_tmp15 : V15_i; 26346 npy_float64 V511_tmp116; 26347 V511_tmp116 = V437_i ? V511_tmp16 : V15_i; 26348 npy_float64 V511_tmp117; 26349 V511_tmp117 = V421_i ? V511_tmp18 : V15_i; 26350 npy_float64 V511_tmp118; 26351 V511_tmp118 = V421_i ? V511_tmp19 : V15_i; 26352 npy_float64 V511_tmp119; 26353 V511_tmp119 = V407_i ? V511_tmp21 : V15_i; 26354 npy_float64 V511_tmp120; 26355 V511_tmp120 = V407_i ? V511_tmp22 : V15_i; 26356 npy_float64 V511_tmp121; 26357 V511_tmp121 = V393_i ? V511_tmp24 : V15_i; 26358 npy_float64 V511_tmp122; 26359 V511_tmp122 = V393_i ? V511_tmp25 : V15_i; 26360 npy_float64 V511_tmp123; 26361 V511_tmp123 = V379_i ? V511_tmp27 : V15_i; 26362 npy_float64 V511_tmp124; 26363 V511_tmp124 = V379_i ? V511_tmp28 : V15_i; 26364 npy_float64 V511_tmp125; 26365 V511_tmp125 = V365_i ? V511_tmp30 : V15_i; 26366 npy_float64 V511_tmp126; 26367 V511_tmp126 = V365_i ? V511_tmp31 : V15_i; 26368 npy_float64 V511_tmp127; 26369 V511_tmp127 = V349_i ? V511_tmp33 : V15_i; 26370 npy_float64 V511_tmp128; 26371 V511_tmp128 = V349_i ? V511_tmp34 : V15_i; 26372 npy_float64 V511_tmp129; 26373 V511_tmp129 = V333_i ? V511_tmp36 : V15_i; 26374 npy_float64 V511_tmp130; 26375 V511_tmp130 = V333_i ? V511_tmp37 : V15_i; 26376 npy_float64 V511_tmp131; 26377 V511_tmp131 = V317_i ? V511_tmp39 : V15_i; 26378 npy_float64 V511_tmp132; 26379 V511_tmp132 = V317_i ? V511_tmp40 : V15_i; 26380 npy_float64 V511_tmp133; 26381 V511_tmp133 = V301_i ? V511_tmp42 : V15_i; 26382 npy_float64 V511_tmp134; 26383 V511_tmp134 = V301_i ? V511_tmp43 : V15_i; 26384 npy_float64 V511_tmp135; 26385 V511_tmp135 = V287_i ? V511_tmp45 : V15_i; 26386 npy_float64 V511_tmp136; 26387 V511_tmp136 = V287_i ? V511_tmp46 : V15_i; 26388 npy_float64 V511_tmp137; 26389 V511_tmp137 = V275_i ? V511_tmp48 : V15_i; 26390 npy_float64 V511_tmp138; 26391 V511_tmp138 = V275_i ? V511_tmp49 : V15_i; 26392 npy_float64 V511_tmp139; 26393 V511_tmp139 = V261_i ? V511_tmp51 : V15_i; 26394 npy_float64 V511_tmp140; 26395 V511_tmp140 = V261_i ? V511_tmp52 : V15_i; 26396 npy_float64 V511_tmp141; 26397 V511_tmp141 = V245_i ? V511_tmp54 : V15_i; 26398 npy_float64 V511_tmp142; 26399 V511_tmp142 = V245_i ? V511_tmp55 : V15_i; 26400 npy_float64 V511_tmp143; 26401 V511_tmp143 = V229_i ? V511_tmp57 : V15_i; 26402 npy_float64 V511_tmp144; 26403 V511_tmp144 = V229_i ? V511_tmp58 : V15_i; 26404 npy_float64 V511_tmp145; 26405 V511_tmp145 = V215_i ? V511_tmp60 : V15_i; 26406 npy_float64 V511_tmp146; 26407 V511_tmp146 = V215_i ? V511_tmp61 : V15_i; 26408 npy_float64 V511_tmp147; 26409 V511_tmp147 = V203_i ? V511_tmp63 : V15_i; 26410 npy_float64 V511_tmp148; 26411 V511_tmp148 = V203_i ? V511_tmp64 : V15_i; 26412 npy_float64 V511_tmp149; 26413 V511_tmp149 = V189_i ? V511_tmp66 : V15_i; 26414 npy_float64 V511_tmp150; 26415 V511_tmp150 = V189_i ? V511_tmp67 : V15_i; 26416 npy_float64 V511_tmp151; 26417 V511_tmp151 = V175_i ? V511_tmp69 : V15_i; 26418 npy_float64 V511_tmp152; 26419 V511_tmp152 = V175_i ? V511_tmp70 : V15_i; 26420 npy_float64 V511_tmp153; 26421 V511_tmp153 = V161_i ? V511_tmp72 : V15_i; 26422 npy_float64 V511_tmp154; 26423 V511_tmp154 = V161_i ? V511_tmp73 : V15_i; 26424 npy_float64 V511_tmp155; 26425 V511_tmp155 = V147_i ? V511_tmp75 : V15_i; 26426 npy_float64 V511_tmp156; 26427 V511_tmp156 = V147_i ? V511_tmp76 : V15_i; 26428 npy_float64 V511_tmp157; 26429 V511_tmp157 = V135_i ? V511_tmp78 : V15_i; 26430 npy_float64 V511_tmp158; 26431 V511_tmp158 = V135_i ? V511_tmp79 : V15_i; 26432 npy_float64 V511_tmp159; 26433 V511_tmp159 = V121_i ? V511_tmp81 : V15_i; 26434 npy_float64 V511_tmp160; 26435 V511_tmp160 = V121_i ? V511_tmp82 : V15_i; 26436 npy_float64 V511_tmp161; 26437 V511_tmp161 = V107_i ? V511_tmp84 : V15_i; 26438 npy_float64 V511_tmp162; 26439 V511_tmp162 = V107_i ? V511_tmp85 : V15_i; 26440 npy_float64 V511_tmp163; 26441 V511_tmp163 = V95_i ? V511_tmp87 : V15_i; 26442 npy_float64 V511_tmp164; 26443 V511_tmp164 = V95_i ? V511_tmp88 : V15_i; 26444 npy_float64 V511_tmp165; 26445 V511_tmp165 = V83_i ? V511_tmp90 : V15_i; 26446 npy_float64 V511_tmp166; 26447 V511_tmp166 = V83_i ? V511_tmp91 : V15_i; 26448 npy_float64 V511_tmp167; 26449 V511_tmp167 = V71_i ? V511_tmp93 : V15_i; 26450 npy_float64 V511_tmp168; 26451 V511_tmp168 = V71_i ? V511_tmp94 : V15_i; 26452 npy_float64 V511_tmp169; 26453 V511_tmp169 = V57_i ? V511_tmp96 : V15_i; 26454 npy_float64 V511_tmp170; 26455 V511_tmp170 = V57_i ? V511_tmp97 : V15_i; 26456 npy_float64 V511_tmp171; 26457 V511_tmp171 = V41_i ? V511_tmp99 : V15_i; 26458 npy_float64 V511_tmp172; 26459 V511_tmp172 = V41_i ? V511_tmp100 : V15_i; 26460 npy_float64 V511_tmp173; 26461 V511_tmp173 = V25_i ? V511_tmp102 : V15_i; 26462 npy_float64 V511_tmp174; 26463 V511_tmp174 = V25_i ? V511_tmp103 : V15_i; 26464 npy_float64 V511_tmp175; 26465 V511_tmp175 = V5_i ? V511_tmp105 : V15_i; 26466 npy_float64 V511_tmp176; 26467 V511_tmp176 = V5_i ? V511_tmp106 : V15_i; 26468 npy_float64 V511_tmp177; 26469 V511_tmp177 = V511_tmp108 + V511_tmp107; 26470 npy_float64 V511_tmp178; 26471 V511_tmp178 = V511_tmp110 + V511_tmp109; 26472 npy_float64 V511_tmp179; 26473 V511_tmp179 = V511_tmp112 + V511_tmp111; 26474 npy_float64 V511_tmp180; 26475 V511_tmp180 = V511_tmp114 + V511_tmp113; 26476 npy_float64 V511_tmp181; 26477 V511_tmp181 = V511_tmp116 + V511_tmp115; 26478 npy_float64 V511_tmp182; 26479 V511_tmp182 = V511_tmp118 + V511_tmp117; 26480 npy_float64 V511_tmp183; 26481 V511_tmp183 = V511_tmp120 + V511_tmp119; 26482 npy_float64 V511_tmp184; 26483 V511_tmp184 = V511_tmp122 + V511_tmp121; 26484 npy_float64 V511_tmp185; 26485 V511_tmp185 = V511_tmp124 + V511_tmp123; 26486 npy_float64 V511_tmp186; 26487 V511_tmp186 = V511_tmp126 + V511_tmp125; 26488 npy_float64 V511_tmp187; 26489 V511_tmp187 = V511_tmp128 + V511_tmp127; 26490 npy_float64 V511_tmp188; 26491 V511_tmp188 = V511_tmp130 + V511_tmp129; 26492 npy_float64 V511_tmp189; 26493 V511_tmp189 = V511_tmp132 + V511_tmp131; 26494 npy_float64 V511_tmp190; 26495 V511_tmp190 = V511_tmp134 + V511_tmp133; 26496 npy_float64 V511_tmp191; 26497 V511_tmp191 = V511_tmp136 + V511_tmp135; 26498 npy_float64 V511_tmp192; 26499 V511_tmp192 = V511_tmp138 + V511_tmp137; 26500 npy_float64 V511_tmp193; 26501 V511_tmp193 = V511_tmp140 + V511_tmp139; 26502 npy_float64 V511_tmp194; 26503 V511_tmp194 = V511_tmp142 + V511_tmp141; 26504 npy_float64 V511_tmp195; 26505 V511_tmp195 = V511_tmp144 + V511_tmp143; 26506 npy_float64 V511_tmp196; 26507 V511_tmp196 = V511_tmp146 + V511_tmp145; 26508 npy_float64 V511_tmp197; 26509 V511_tmp197 = V511_tmp148 + V511_tmp147; 26510 npy_float64 V511_tmp198; 26511 V511_tmp198 = V511_tmp150 + V511_tmp149; 26512 npy_float64 V511_tmp199; 26513 V511_tmp199 = V511_tmp152 + V511_tmp151; 26514 npy_float64 V511_tmp200; 26515 V511_tmp200 = V511_tmp154 + V511_tmp153; 26516 npy_float64 V511_tmp201; 26517 V511_tmp201 = V511_tmp156 + V511_tmp155; 26518 npy_float64 V511_tmp202; 26519 V511_tmp202 = V511_tmp158 + V511_tmp157; 26520 npy_float64 V511_tmp203; 26521 V511_tmp203 = V511_tmp160 + V511_tmp159; 26522 npy_float64 V511_tmp204; 26523 V511_tmp204 = V511_tmp162 + V511_tmp161; 26524 npy_float64 V511_tmp205; 26525 V511_tmp205 = V511_tmp164 + V511_tmp163; 26526 npy_float64 V511_tmp206; 26527 V511_tmp206 = V511_tmp166 + V511_tmp165; 26528 npy_float64 V511_tmp207; 26529 V511_tmp207 = V511_tmp168 + V511_tmp167; 26530 npy_float64 V511_tmp208; 26531 V511_tmp208 = V511_tmp170 + V511_tmp169; 26532 npy_float64 V511_tmp209; 26533 V511_tmp209 = V511_tmp172 + V511_tmp171; 26534 npy_float64 V511_tmp210; 26535 V511_tmp210 = V511_tmp174 + V511_tmp173; 26536 npy_float64 V511_tmp211; 26537 V511_tmp211 = V511_tmp176 + V511_tmp175; 26538 npy_float64 V511_tmp212; 26539 V511_tmp212 = V511_tmp177 * V501_i; 26540 npy_float64 V511_tmp213; 26541 V511_tmp213 = V511_tmp178 * V489_i; 26542 npy_float64 V511_tmp214; 26543 V511_tmp214 = V511_tmp179 * V471_i; 26544 npy_float64 V511_tmp215; 26545 V511_tmp215 = V511_tmp180 * V457_i; 26546 npy_float64 V511_tmp216; 26547 V511_tmp216 = V511_tmp181 * V441_i; 26548 npy_float64 V511_tmp217; 26549 V511_tmp217 = V511_tmp182 * V425_i; 26550 npy_float64 V511_tmp218; 26551 V511_tmp218 = V511_tmp183 * V409_i; 26552 npy_float64 V511_tmp219; 26553 V511_tmp219 = V511_tmp184 * V397_i; 26554 npy_float64 V511_tmp220; 26555 V511_tmp220 = V511_tmp185 * V381_i; 26556 npy_float64 V511_tmp221; 26557 V511_tmp221 = V511_tmp186 * V369_i; 26558 npy_float64 V511_tmp222; 26559 V511_tmp222 = V511_tmp187 * V353_i; 26560 npy_float64 V511_tmp223; 26561 V511_tmp223 = V511_tmp188 * V337_i; 26562 npy_float64 V511_tmp224; 26563 V511_tmp224 = V511_tmp189 * V321_i; 26564 npy_float64 V511_tmp225; 26565 V511_tmp225 = V511_tmp190 * V305_i; 26566 npy_float64 V511_tmp226; 26567 V511_tmp226 = V511_tmp191 * V289_i; 26568 npy_float64 V511_tmp227; 26569 V511_tmp227 = V511_tmp192 * V277_i; 26570 npy_float64 V511_tmp228; 26571 V511_tmp228 = V511_tmp193 * V265_i; 26572 npy_float64 V511_tmp229; 26573 V511_tmp229 = V511_tmp194 * V249_i; 26574 npy_float64 V511_tmp230; 26575 V511_tmp230 = V511_tmp195 * V233_i; 26576 npy_float64 V511_tmp231; 26577 V511_tmp231 = V511_tmp196 * V217_i; 26578 npy_float64 V511_tmp232; 26579 V511_tmp232 = V511_tmp197 * V205_i; 26580 npy_float64 V511_tmp233; 26581 V511_tmp233 = V511_tmp198 * V193_i; 26582 npy_float64 V511_tmp234; 26583 V511_tmp234 = V511_tmp199 * V177_i; 26584 npy_float64 V511_tmp235; 26585 V511_tmp235 = V511_tmp200 * V165_i; 26586 npy_float64 V511_tmp236; 26587 V511_tmp236 = V511_tmp201 * V149_i; 26588 npy_float64 V511_tmp237; 26589 V511_tmp237 = V511_tmp202 * V137_i; 26590 npy_float64 V511_tmp238; 26591 V511_tmp238 = V511_tmp203 * V125_i; 26592 npy_float64 V511_tmp239; 26593 V511_tmp239 = V511_tmp204 * V109_i; 26594 npy_float64 V511_tmp240; 26595 V511_tmp240 = V511_tmp205 * V97_i; 26596 npy_float64 V511_tmp241; 26597 V511_tmp241 = V511_tmp206 * V85_i; 26598 npy_float64 V511_tmp242; 26599 V511_tmp242 = V511_tmp207 * V73_i; 26600 npy_float64 V511_tmp243; 26601 V511_tmp243 = V511_tmp208 * V61_i; 26602 npy_float64 V511_tmp244; 26603 V511_tmp244 = V511_tmp209 * V45_i; 26604 npy_float64 V511_tmp245; 26605 V511_tmp245 = V511_tmp210 * V29_i; 26606 npy_float64 V511_tmp246; 26607 V511_tmp246 = V511_tmp211 * V11_i; 26608 npy_float64 V511_tmp247; 26609 V511_tmp247 = V511_tmp213 + V511_tmp4; 26610 npy_float64 V511_tmp248; 26611 V511_tmp248 = V511_tmp215 + V511_tmp11; 26612 npy_float64 V511_tmp249; 26613 V511_tmp249 = V511_tmp216 + V511_tmp14; 26614 npy_float64 V511_tmp250; 26615 V511_tmp250 = V511_tmp217 + V511_tmp17; 26616 npy_float64 V511_tmp251; 26617 V511_tmp251 = V511_tmp218 + V511_tmp20; 26618 npy_float64 V511_tmp252; 26619 V511_tmp252 = V511_tmp219 + V511_tmp23; 26620 npy_float64 V511_tmp253; 26621 V511_tmp253 = V511_tmp220 + V511_tmp26; 26622 npy_float64 V511_tmp254; 26623 V511_tmp254 = V511_tmp221 + V511_tmp29; 26624 npy_float64 V511_tmp255; 26625 V511_tmp255 = V511_tmp222 + V511_tmp32; 26626 npy_float64 V511_tmp256; 26627 V511_tmp256 = V511_tmp223 + V511_tmp35; 26628 npy_float64 V511_tmp257; 26629 V511_tmp257 = V511_tmp224 + V511_tmp38; 26630 npy_float64 V511_tmp258; 26631 V511_tmp258 = V511_tmp225 + V511_tmp41; 26632 npy_float64 V511_tmp259; 26633 V511_tmp259 = V511_tmp226 + V511_tmp44; 26634 npy_float64 V511_tmp260; 26635 V511_tmp260 = V511_tmp227 + V511_tmp47; 26636 npy_float64 V511_tmp261; 26637 V511_tmp261 = V511_tmp228 + V511_tmp50; 26638 npy_float64 V511_tmp262; 26639 V511_tmp262 = V511_tmp229 + V511_tmp53; 26640 npy_float64 V511_tmp263; 26641 V511_tmp263 = V511_tmp230 + V511_tmp56; 26642 npy_float64 V511_tmp264; 26643 V511_tmp264 = V511_tmp231 + V511_tmp59; 26644 npy_float64 V511_tmp265; 26645 V511_tmp265 = V511_tmp232 + V511_tmp62; 26646 npy_float64 V511_tmp266; 26647 V511_tmp266 = V511_tmp233 + V511_tmp65; 26648 npy_float64 V511_tmp267; 26649 V511_tmp267 = V511_tmp234 + V511_tmp68; 26650 npy_float64 V511_tmp268; 26651 V511_tmp268 = V511_tmp235 + V511_tmp71; 26652 npy_float64 V511_tmp269; 26653 V511_tmp269 = V511_tmp236 + V511_tmp74; 26654 npy_float64 V511_tmp270; 26655 V511_tmp270 = V511_tmp237 + V511_tmp77; 26656 npy_float64 V511_tmp271; 26657 V511_tmp271 = V511_tmp238 + V511_tmp80; 26658 npy_float64 V511_tmp272; 26659 V511_tmp272 = V511_tmp239 + V511_tmp83; 26660 npy_float64 V511_tmp273; 26661 V511_tmp273 = V511_tmp240 + V511_tmp86; 26662 npy_float64 V511_tmp274; 26663 V511_tmp274 = V511_tmp241 + V511_tmp89; 26664 npy_float64 V511_tmp275; 26665 V511_tmp275 = V511_tmp242 + V511_tmp92; 26666 npy_float64 V511_tmp276; 26667 V511_tmp276 = V511_tmp243 + V511_tmp95; 26668 npy_float64 V511_tmp277; 26669 V511_tmp277 = V511_tmp244 + V511_tmp98; 26670 npy_float64 V511_tmp278; 26671 V511_tmp278 = V511_tmp245 + V511_tmp101; 26672 npy_float64 V511_tmp279; 26673 V511_tmp279 = V511_tmp246 + V511_tmp104; 26674 npy_float64 V511_tmp280; 26675 V511_tmp280 = V483_i * V511_tmp247; 26676 npy_float64 V511_tmp281; 26677 V511_tmp281 = V451_i * V511_tmp248; 26678 npy_float64 V511_tmp282; 26679 V511_tmp282 = V435_i * V511_tmp249; 26680 npy_float64 V511_tmp283; 26681 V511_tmp283 = V419_i * V511_tmp250; 26682 npy_float64 V511_tmp284; 26683 V511_tmp284 = V363_i * V511_tmp251; 26684 npy_float64 V511_tmp285; 26685 V511_tmp285 = V391_i * V511_tmp252; 26686 npy_float64 V511_tmp286; 26687 V511_tmp286 = V299_i * V511_tmp253; 26688 npy_float64 V511_tmp287; 26689 V511_tmp287 = V363_i * V511_tmp254; 26690 npy_float64 V511_tmp288; 26691 V511_tmp288 = V347_i * V511_tmp255; 26692 npy_float64 V511_tmp289; 26693 V511_tmp289 = V331_i * V511_tmp256; 26694 npy_float64 V511_tmp290; 26695 V511_tmp290 = V315_i * V511_tmp257; 26696 npy_float64 V511_tmp291; 26697 V511_tmp291 = V299_i * V511_tmp258; 26698 npy_float64 V511_tmp292; 26699 V511_tmp292 = V259_i * V511_tmp259; 26700 npy_float64 V511_tmp293; 26701 V511_tmp293 = V259_i * V511_tmp260; 26702 npy_float64 V511_tmp294; 26703 V511_tmp294 = V259_i * V511_tmp261; 26704 npy_float64 V511_tmp295; 26705 V511_tmp295 = V243_i * V511_tmp262; 26706 npy_float64 V511_tmp296; 26707 V511_tmp296 = V227_i * V511_tmp263; 26708 npy_float64 V511_tmp297; 26709 V511_tmp297 = V187_i * V511_tmp264; 26710 npy_float64 V511_tmp298; 26711 V511_tmp298 = V187_i * V511_tmp265; 26712 npy_float64 V511_tmp299; 26713 V511_tmp299 = V187_i * V511_tmp266; 26714 npy_float64 V511_tmp300; 26715 V511_tmp300 = V159_i * V511_tmp267; 26716 npy_float64 V511_tmp301; 26717 V511_tmp301 = V159_i * V511_tmp268; 26718 npy_float64 V511_tmp302; 26719 V511_tmp302 = V119_i * V511_tmp269; 26720 npy_float64 V511_tmp303; 26721 V511_tmp303 = V119_i * V511_tmp270; 26722 npy_float64 V511_tmp304; 26723 V511_tmp304 = V119_i * V511_tmp271; 26724 npy_float64 V511_tmp305; 26725 V511_tmp305 = V55_i * V511_tmp272; 26726 npy_float64 V511_tmp306; 26727 V511_tmp306 = V55_i * V511_tmp273; 26728 npy_float64 V511_tmp307; 26729 V511_tmp307 = V55_i * V511_tmp274; 26730 npy_float64 V511_tmp308; 26731 V511_tmp308 = V55_i * V511_tmp275; 26732 npy_float64 V511_tmp309; 26733 V511_tmp309 = V55_i * V511_tmp276; 26734 npy_float64 V511_tmp310; 26735 V511_tmp310 = V39_i * V511_tmp277; 26736 npy_float64 V511_tmp311; 26737 V511_tmp311 = V23_i * V511_tmp278; 26738 npy_float64 V511_tmp312; 26739 V511_tmp312 = V3_i * V511_tmp279; 26740 V1_i = V511_tmp312 + V511_tmp311 + V511_tmp310 + V511_tmp309 + V511_tmp308 + V511_tmp307 + V511_tmp306 + V511_tmp305 + V511_tmp304 + V511_tmp303 + V511_tmp302 + V511_tmp301 + V511_tmp300 + V511_tmp299 + V511_tmp298 + V511_tmp297 + V511_tmp296 + V511_tmp295 + V511_tmp294 + V511_tmp293 + V511_tmp292 + V511_tmp291 + V511_tmp290 + V511_tmp289 + V511_tmp288 + V511_tmp287 + V511_tmp286 + V511_tmp285 + V511_tmp284 + V511_tmp283 + V511_tmp282 + V511_tmp281 + V511_tmp214 + V511_tmp8 + V511_tmp7 + V511_tmp280 + V511_tmp212 + V511_tmp1; 26741 } 26742 26743 26744 } 26745 __label_511: 26746 26747 double __DUMMY_511; 26748 26749 } 26750 __label_510: 26751 26752 if (V509) { 26753 Py_XDECREF(V509); 26754 } 26755 26756 {Py_XDECREF(py_V509);} 26757 26758 double __DUMMY_510; 26759 26760 } 26761 __label_508: 26762 26763 if (V507) { 26764 Py_XDECREF(V507); 26765 } 26766 26767 {Py_XDECREF(py_V507);} 26768 26769 double __DUMMY_508; 26770 26771 } 26772 __label_506: 26773 26774 if (V505) { 26775 Py_XDECREF(V505); 26776 } 26777 26778 {Py_XDECREF(py_V505);} 26779 26780 double __DUMMY_506; 26781 26782 } 26783 __label_504: 26784 26785 if (V503) { 26786 Py_XDECREF(V503); 26787 } 26788 26789 {Py_XDECREF(py_V503);} 26790 26791 double __DUMMY_504; 26792 26793 } 26794 __label_502: 26795 26796 if (V501) { 26797 Py_XDECREF(V501); 26798 } 26799 26800 {Py_XDECREF(py_V501);} 26801 26802 double __DUMMY_502; 26803 26804 } 26805 __label_500: 26806 26807 if (V499) { 26808 Py_XDECREF(V499); 26809 } 26810 26811 {Py_XDECREF(py_V499);} 26812 26813 double __DUMMY_500; 26814 26815 } 26816 __label_498: 26817 26818 if (V497) { 26819 Py_XDECREF(V497); 26820 } 26821 26822 {Py_XDECREF(py_V497);} 26823 26824 double __DUMMY_498; 26825 26826 } 26827 __label_496: 26828 26829 if (V495) { 26830 Py_XDECREF(V495); 26831 } 26832 26833 {Py_XDECREF(py_V495);} 26834 26835 double __DUMMY_496; 26836 26837 } 26838 __label_494: 26839 26840 if (V493) { 26841 Py_XDECREF(V493); 26842 } 26843 26844 {Py_XDECREF(py_V493);} 26845 26846 double __DUMMY_494; 26847 26848 } 26849 __label_492: 26850 26851 if (V491) { 26852 Py_XDECREF(V491); 26853 } 26854 26855 {Py_XDECREF(py_V491);} 26856 26857 double __DUMMY_492; 26858 26859 } 26860 __label_490: 26861 26862 if (V489) { 26863 Py_XDECREF(V489); 26864 } 26865 26866 {Py_XDECREF(py_V489);} 26867 26868 double __DUMMY_490; 26869 26870 } 26871 __label_488: 26872 26873 if (V487) { 26874 Py_XDECREF(V487); 26875 } 26876 26877 {Py_XDECREF(py_V487);} 26878 26879 double __DUMMY_488; 26880 26881 } 26882 __label_486: 26883 26884 if (V485) { 26885 Py_XDECREF(V485); 26886 } 26887 26888 {Py_XDECREF(py_V485);} 26889 26890 double __DUMMY_486; 26891 26892 } 26893 __label_484: 26894 26895 if (V483) { 26896 Py_XDECREF(V483); 26897 } 26898 26899 {Py_XDECREF(py_V483);} 26900 26901 double __DUMMY_484; 26902 26903 } 26904 __label_482: 26905 26906 if (V481) { 26907 Py_XDECREF(V481); 26908 } 26909 26910 {Py_XDECREF(py_V481);} 26911 26912 double __DUMMY_482; 26913 26914 } 26915 __label_480: 26916 26917 if (V479) { 26918 Py_XDECREF(V479); 26919 } 26920 26921 {Py_XDECREF(py_V479);} 26922 26923 double __DUMMY_480; 26924 26925 } 26926 __label_478: 26927 26928 if (V477) { 26929 Py_XDECREF(V477); 26930 } 26931 26932 {Py_XDECREF(py_V477);} 26933 26934 double __DUMMY_478; 26935 26936 } 26937 __label_476: 26938 26939 if (V475) { 26940 Py_XDECREF(V475); 26941 } 26942 26943 {Py_XDECREF(py_V475);} 26944 26945 double __DUMMY_476; 26946 26947 } 26948 __label_474: 26949 26950 if (V473) { 26951 Py_XDECREF(V473); 26952 } 26953 26954 {Py_XDECREF(py_V473);} 26955 26956 double __DUMMY_474; 26957 26958 } 26959 __label_472: 26960 26961 if (V471) { 26962 Py_XDECREF(V471); 26963 } 26964 26965 {Py_XDECREF(py_V471);} 26966 26967 double __DUMMY_472; 26968 26969 } 26970 __label_470: 26971 26972 if (V469) { 26973 Py_XDECREF(V469); 26974 } 26975 26976 {Py_XDECREF(py_V469);} 26977 26978 double __DUMMY_470; 26979 26980 } 26981 __label_468: 26982 26983 if (V467) { 26984 Py_XDECREF(V467); 26985 } 26986 26987 {Py_XDECREF(py_V467);} 26988 26989 double __DUMMY_468; 26990 26991 } 26992 __label_466: 26993 26994 if (V465) { 26995 Py_XDECREF(V465); 26996 } 26997 26998 {Py_XDECREF(py_V465);} 26999 27000 double __DUMMY_466; 27001 27002 } 27003 __label_464: 27004 27005 if (V463) { 27006 Py_XDECREF(V463); 27007 } 27008 27009 {Py_XDECREF(py_V463);} 27010 27011 double __DUMMY_464; 27012 27013 } 27014 __label_462: 27015 27016 if (V461) { 27017 Py_XDECREF(V461); 27018 } 27019 27020 {Py_XDECREF(py_V461);} 27021 27022 double __DUMMY_462; 27023 27024 } 27025 __label_460: 27026 27027 if (V459) { 27028 Py_XDECREF(V459); 27029 } 27030 27031 {Py_XDECREF(py_V459);} 27032 27033 double __DUMMY_460; 27034 27035 } 27036 __label_458: 27037 27038 if (V457) { 27039 Py_XDECREF(V457); 27040 } 27041 27042 {Py_XDECREF(py_V457);} 27043 27044 double __DUMMY_458; 27045 27046 } 27047 __label_456: 27048 27049 if (V455) { 27050 Py_XDECREF(V455); 27051 } 27052 27053 {Py_XDECREF(py_V455);} 27054 27055 double __DUMMY_456; 27056 27057 } 27058 __label_454: 27059 27060 if (V453) { 27061 Py_XDECREF(V453); 27062 } 27063 27064 {Py_XDECREF(py_V453);} 27065 27066 double __DUMMY_454; 27067 27068 } 27069 __label_452: 27070 27071 if (V451) { 27072 Py_XDECREF(V451); 27073 } 27074 27075 {Py_XDECREF(py_V451);} 27076 27077 double __DUMMY_452; 27078 27079 } 27080 __label_450: 27081 27082 if (V449) { 27083 Py_XDECREF(V449); 27084 } 27085 27086 {Py_XDECREF(py_V449);} 27087 27088 double __DUMMY_450; 27089 27090 } 27091 __label_448: 27092 27093 if (V447) { 27094 Py_XDECREF(V447); 27095 } 27096 27097 {Py_XDECREF(py_V447);} 27098 27099 double __DUMMY_448; 27100 27101 } 27102 __label_446: 27103 27104 if (V445) { 27105 Py_XDECREF(V445); 27106 } 27107 27108 {Py_XDECREF(py_V445);} 27109 27110 double __DUMMY_446; 27111 27112 } 27113 __label_444: 27114 27115 if (V443) { 27116 Py_XDECREF(V443); 27117 } 27118 27119 {Py_XDECREF(py_V443);} 27120 27121 double __DUMMY_444; 27122 27123 } 27124 __label_442: 27125 27126 if (V441) { 27127 Py_XDECREF(V441); 27128 } 27129 27130 {Py_XDECREF(py_V441);} 27131 27132 double __DUMMY_442; 27133 27134 } 27135 __label_440: 27136 27137 if (V439) { 27138 Py_XDECREF(V439); 27139 } 27140 27141 {Py_XDECREF(py_V439);} 27142 27143 double __DUMMY_440; 27144 27145 } 27146 __label_438: 27147 27148 if (V437) { 27149 Py_XDECREF(V437); 27150 } 27151 27152 {Py_XDECREF(py_V437);} 27153 27154 double __DUMMY_438; 27155 27156 } 27157 __label_436: 27158 27159 if (V435) { 27160 Py_XDECREF(V435); 27161 } 27162 27163 {Py_XDECREF(py_V435);} 27164 27165 double __DUMMY_436; 27166 27167 } 27168 __label_434: 27169 27170 if (V433) { 27171 Py_XDECREF(V433); 27172 } 27173 27174 {Py_XDECREF(py_V433);} 27175 27176 double __DUMMY_434; 27177 27178 } 27179 __label_432: 27180 27181 if (V431) { 27182 Py_XDECREF(V431); 27183 } 27184 27185 {Py_XDECREF(py_V431);} 27186 27187 double __DUMMY_432; 27188 27189 } 27190 __label_430: 27191 27192 if (V429) { 27193 Py_XDECREF(V429); 27194 } 27195 27196 {Py_XDECREF(py_V429);} 27197 27198 double __DUMMY_430; 27199 27200 } 27201 __label_428: 27202 27203 if (V427) { 27204 Py_XDECREF(V427); 27205 } 27206 27207 {Py_XDECREF(py_V427);} 27208 27209 double __DUMMY_428; 27210 27211 } 27212 __label_426: 27213 27214 if (V425) { 27215 Py_XDECREF(V425); 27216 } 27217 27218 {Py_XDECREF(py_V425);} 27219 27220 double __DUMMY_426; 27221 27222 } 27223 __label_424: 27224 27225 if (V423) { 27226 Py_XDECREF(V423); 27227 } 27228 27229 {Py_XDECREF(py_V423);} 27230 27231 double __DUMMY_424; 27232 27233 } 27234 __label_422: 27235 27236 if (V421) { 27237 Py_XDECREF(V421); 27238 } 27239 27240 {Py_XDECREF(py_V421);} 27241 27242 double __DUMMY_422; 27243 27244 } 27245 __label_420: 27246 27247 if (V419) { 27248 Py_XDECREF(V419); 27249 } 27250 27251 {Py_XDECREF(py_V419);} 27252 27253 double __DUMMY_420; 27254 27255 } 27256 __label_418: 27257 27258 if (V417) { 27259 Py_XDECREF(V417); 27260 } 27261 27262 {Py_XDECREF(py_V417);} 27263 27264 double __DUMMY_418; 27265 27266 } 27267 __label_416: 27268 27269 if (V415) { 27270 Py_XDECREF(V415); 27271 } 27272 27273 {Py_XDECREF(py_V415);} 27274 27275 double __DUMMY_416; 27276 27277 } 27278 __label_414: 27279 27280 if (V413) { 27281 Py_XDECREF(V413); 27282 } 27283 27284 {Py_XDECREF(py_V413);} 27285 27286 double __DUMMY_414; 27287 27288 } 27289 __label_412: 27290 27291 if (V411) { 27292 Py_XDECREF(V411); 27293 } 27294 27295 {Py_XDECREF(py_V411);} 27296 27297 double __DUMMY_412; 27298 27299 } 27300 __label_410: 27301 27302 if (V409) { 27303 Py_XDECREF(V409); 27304 } 27305 27306 {Py_XDECREF(py_V409);} 27307 27308 double __DUMMY_410; 27309 27310 } 27311 __label_408: 27312 27313 if (V407) { 27314 Py_XDECREF(V407); 27315 } 27316 27317 {Py_XDECREF(py_V407);} 27318 27319 double __DUMMY_408; 27320 27321 } 27322 __label_406: 27323 27324 if (V405) { 27325 Py_XDECREF(V405); 27326 } 27327 27328 {Py_XDECREF(py_V405);} 27329 27330 double __DUMMY_406; 27331 27332 } 27333 __label_404: 27334 27335 if (V403) { 27336 Py_XDECREF(V403); 27337 } 27338 27339 {Py_XDECREF(py_V403);} 27340 27341 double __DUMMY_404; 27342 27343 } 27344 __label_402: 27345 27346 if (V401) { 27347 Py_XDECREF(V401); 27348 } 27349 27350 {Py_XDECREF(py_V401);} 27351 27352 double __DUMMY_402; 27353 27354 } 27355 __label_400: 27356 27357 if (V399) { 27358 Py_XDECREF(V399); 27359 } 27360 27361 {Py_XDECREF(py_V399);} 27362 27363 double __DUMMY_400; 27364 27365 } 27366 __label_398: 27367 27368 if (V397) { 27369 Py_XDECREF(V397); 27370 } 27371 27372 {Py_XDECREF(py_V397);} 27373 27374 double __DUMMY_398; 27375 27376 } 27377 __label_396: 27378 27379 if (V395) { 27380 Py_XDECREF(V395); 27381 } 27382 27383 {Py_XDECREF(py_V395);} 27384 27385 double __DUMMY_396; 27386 27387 } 27388 __label_394: 27389 27390 if (V393) { 27391 Py_XDECREF(V393); 27392 } 27393 27394 {Py_XDECREF(py_V393);} 27395 27396 double __DUMMY_394; 27397 27398 } 27399 __label_392: 27400 27401 if (V391) { 27402 Py_XDECREF(V391); 27403 } 27404 27405 {Py_XDECREF(py_V391);} 27406 27407 double __DUMMY_392; 27408 27409 } 27410 __label_390: 27411 27412 if (V389) { 27413 Py_XDECREF(V389); 27414 } 27415 27416 {Py_XDECREF(py_V389);} 27417 27418 double __DUMMY_390; 27419 27420 } 27421 __label_388: 27422 27423 if (V387) { 27424 Py_XDECREF(V387); 27425 } 27426 27427 {Py_XDECREF(py_V387);} 27428 27429 double __DUMMY_388; 27430 27431 } 27432 __label_386: 27433 27434 if (V385) { 27435 Py_XDECREF(V385); 27436 } 27437 27438 {Py_XDECREF(py_V385);} 27439 27440 double __DUMMY_386; 27441 27442 } 27443 __label_384: 27444 27445 if (V383) { 27446 Py_XDECREF(V383); 27447 } 27448 27449 {Py_XDECREF(py_V383);} 27450 27451 double __DUMMY_384; 27452 27453 } 27454 __label_382: 27455 27456 if (V381) { 27457 Py_XDECREF(V381); 27458 } 27459 27460 {Py_XDECREF(py_V381);} 27461 27462 double __DUMMY_382; 27463 27464 } 27465 __label_380: 27466 27467 if (V379) { 27468 Py_XDECREF(V379); 27469 } 27470 27471 {Py_XDECREF(py_V379);} 27472 27473 double __DUMMY_380; 27474 27475 } 27476 __label_378: 27477 27478 if (V377) { 27479 Py_XDECREF(V377); 27480 } 27481 27482 {Py_XDECREF(py_V377);} 27483 27484 double __DUMMY_378; 27485 27486 } 27487 __label_376: 27488 27489 if (V375) { 27490 Py_XDECREF(V375); 27491 } 27492 27493 {Py_XDECREF(py_V375);} 27494 27495 double __DUMMY_376; 27496 27497 } 27498 __label_374: 27499 27500 if (V373) { 27501 Py_XDECREF(V373); 27502 } 27503 27504 {Py_XDECREF(py_V373);} 27505 27506 double __DUMMY_374; 27507 27508 } 27509 __label_372: 27510 27511 if (V371) { 27512 Py_XDECREF(V371); 27513 } 27514 27515 {Py_XDECREF(py_V371);} 27516 27517 double __DUMMY_372; 27518 27519 } 27520 __label_370: 27521 27522 if (V369) { 27523 Py_XDECREF(V369); 27524 } 27525 27526 {Py_XDECREF(py_V369);} 27527 27528 double __DUMMY_370; 27529 27530 } 27531 __label_368: 27532 27533 if (V367) { 27534 Py_XDECREF(V367); 27535 } 27536 27537 {Py_XDECREF(py_V367);} 27538 27539 double __DUMMY_368; 27540 27541 } 27542 __label_366: 27543 27544 if (V365) { 27545 Py_XDECREF(V365); 27546 } 27547 27548 {Py_XDECREF(py_V365);} 27549 27550 double __DUMMY_366; 27551 27552 } 27553 __label_364: 27554 27555 if (V363) { 27556 Py_XDECREF(V363); 27557 } 27558 27559 {Py_XDECREF(py_V363);} 27560 27561 double __DUMMY_364; 27562 27563 } 27564 __label_362: 27565 27566 if (V361) { 27567 Py_XDECREF(V361); 27568 } 27569 27570 {Py_XDECREF(py_V361);} 27571 27572 double __DUMMY_362; 27573 27574 } 27575 __label_360: 27576 27577 if (V359) { 27578 Py_XDECREF(V359); 27579 } 27580 27581 {Py_XDECREF(py_V359);} 27582 27583 double __DUMMY_360; 27584 27585 } 27586 __label_358: 27587 27588 if (V357) { 27589 Py_XDECREF(V357); 27590 } 27591 27592 {Py_XDECREF(py_V357);} 27593 27594 double __DUMMY_358; 27595 27596 } 27597 __label_356: 27598 27599 if (V355) { 27600 Py_XDECREF(V355); 27601 } 27602 27603 {Py_XDECREF(py_V355);} 27604 27605 double __DUMMY_356; 27606 27607 } 27608 __label_354: 27609 27610 if (V353) { 27611 Py_XDECREF(V353); 27612 } 27613 27614 {Py_XDECREF(py_V353);} 27615 27616 double __DUMMY_354; 27617 27618 } 27619 __label_352: 27620 27621 if (V351) { 27622 Py_XDECREF(V351); 27623 } 27624 27625 {Py_XDECREF(py_V351);} 27626 27627 double __DUMMY_352; 27628 27629 } 27630 __label_350: 27631 27632 if (V349) { 27633 Py_XDECREF(V349); 27634 } 27635 27636 {Py_XDECREF(py_V349);} 27637 27638 double __DUMMY_350; 27639 27640 } 27641 __label_348: 27642 27643 if (V347) { 27644 Py_XDECREF(V347); 27645 } 27646 27647 {Py_XDECREF(py_V347);} 27648 27649 double __DUMMY_348; 27650 27651 } 27652 __label_346: 27653 27654 if (V345) { 27655 Py_XDECREF(V345); 27656 } 27657 27658 {Py_XDECREF(py_V345);} 27659 27660 double __DUMMY_346; 27661 27662 } 27663 __label_344: 27664 27665 if (V343) { 27666 Py_XDECREF(V343); 27667 } 27668 27669 {Py_XDECREF(py_V343);} 27670 27671 double __DUMMY_344; 27672 27673 } 27674 __label_342: 27675 27676 if (V341) { 27677 Py_XDECREF(V341); 27678 } 27679 27680 {Py_XDECREF(py_V341);} 27681 27682 double __DUMMY_342; 27683 27684 } 27685 __label_340: 27686 27687 if (V339) { 27688 Py_XDECREF(V339); 27689 } 27690 27691 {Py_XDECREF(py_V339);} 27692 27693 double __DUMMY_340; 27694 27695 } 27696 __label_338: 27697 27698 if (V337) { 27699 Py_XDECREF(V337); 27700 } 27701 27702 {Py_XDECREF(py_V337);} 27703 27704 double __DUMMY_338; 27705 27706 } 27707 __label_336: 27708 27709 if (V335) { 27710 Py_XDECREF(V335); 27711 } 27712 27713 {Py_XDECREF(py_V335);} 27714 27715 double __DUMMY_336; 27716 27717 } 27718 __label_334: 27719 27720 if (V333) { 27721 Py_XDECREF(V333); 27722 } 27723 27724 {Py_XDECREF(py_V333);} 27725 27726 double __DUMMY_334; 27727 27728 } 27729 __label_332: 27730 27731 if (V331) { 27732 Py_XDECREF(V331); 27733 } 27734 27735 {Py_XDECREF(py_V331);} 27736 27737 double __DUMMY_332; 27738 27739 } 27740 __label_330: 27741 27742 if (V329) { 27743 Py_XDECREF(V329); 27744 } 27745 27746 {Py_XDECREF(py_V329);} 27747 27748 double __DUMMY_330; 27749 27750 } 27751 __label_328: 27752 27753 if (V327) { 27754 Py_XDECREF(V327); 27755 } 27756 27757 {Py_XDECREF(py_V327);} 27758 27759 double __DUMMY_328; 27760 27761 } 27762 __label_326: 27763 27764 if (V325) { 27765 Py_XDECREF(V325); 27766 } 27767 27768 {Py_XDECREF(py_V325);} 27769 27770 double __DUMMY_326; 27771 27772 } 27773 __label_324: 27774 27775 if (V323) { 27776 Py_XDECREF(V323); 27777 } 27778 27779 {Py_XDECREF(py_V323);} 27780 27781 double __DUMMY_324; 27782 27783 } 27784 __label_322: 27785 27786 if (V321) { 27787 Py_XDECREF(V321); 27788 } 27789 27790 {Py_XDECREF(py_V321);} 27791 27792 double __DUMMY_322; 27793 27794 } 27795 __label_320: 27796 27797 if (V319) { 27798 Py_XDECREF(V319); 27799 } 27800 27801 {Py_XDECREF(py_V319);} 27802 27803 double __DUMMY_320; 27804 27805 } 27806 __label_318: 27807 27808 if (V317) { 27809 Py_XDECREF(V317); 27810 } 27811 27812 {Py_XDECREF(py_V317);} 27813 27814 double __DUMMY_318; 27815 27816 } 27817 __label_316: 27818 27819 if (V315) { 27820 Py_XDECREF(V315); 27821 } 27822 27823 {Py_XDECREF(py_V315);} 27824 27825 double __DUMMY_316; 27826 27827 } 27828 __label_314: 27829 27830 if (V313) { 27831 Py_XDECREF(V313); 27832 } 27833 27834 {Py_XDECREF(py_V313);} 27835 27836 double __DUMMY_314; 27837 27838 } 27839 __label_312: 27840 27841 if (V311) { 27842 Py_XDECREF(V311); 27843 } 27844 27845 {Py_XDECREF(py_V311);} 27846 27847 double __DUMMY_312; 27848 27849 } 27850 __label_310: 27851 27852 if (V309) { 27853 Py_XDECREF(V309); 27854 } 27855 27856 {Py_XDECREF(py_V309);} 27857 27858 double __DUMMY_310; 27859 27860 } 27861 __label_308: 27862 27863 if (V307) { 27864 Py_XDECREF(V307); 27865 } 27866 27867 {Py_XDECREF(py_V307);} 27868 27869 double __DUMMY_308; 27870 27871 } 27872 __label_306: 27873 27874 if (V305) { 27875 Py_XDECREF(V305); 27876 } 27877 27878 {Py_XDECREF(py_V305);} 27879 27880 double __DUMMY_306; 27881 27882 } 27883 __label_304: 27884 27885 if (V303) { 27886 Py_XDECREF(V303); 27887 } 27888 27889 {Py_XDECREF(py_V303);} 27890 27891 double __DUMMY_304; 27892 27893 } 27894 __label_302: 27895 27896 if (V301) { 27897 Py_XDECREF(V301); 27898 } 27899 27900 {Py_XDECREF(py_V301);} 27901 27902 double __DUMMY_302; 27903 27904 } 27905 __label_300: 27906 27907 if (V299) { 27908 Py_XDECREF(V299); 27909 } 27910 27911 {Py_XDECREF(py_V299);} 27912 27913 double __DUMMY_300; 27914 27915 } 27916 __label_298: 27917 27918 if (V297) { 27919 Py_XDECREF(V297); 27920 } 27921 27922 {Py_XDECREF(py_V297);} 27923 27924 double __DUMMY_298; 27925 27926 } 27927 __label_296: 27928 27929 if (V295) { 27930 Py_XDECREF(V295); 27931 } 27932 27933 {Py_XDECREF(py_V295);} 27934 27935 double __DUMMY_296; 27936 27937 } 27938 __label_294: 27939 27940 if (V293) { 27941 Py_XDECREF(V293); 27942 } 27943 27944 {Py_XDECREF(py_V293);} 27945 27946 double __DUMMY_294; 27947 27948 } 27949 __label_292: 27950 27951 if (V291) { 27952 Py_XDECREF(V291); 27953 } 27954 27955 {Py_XDECREF(py_V291);} 27956 27957 double __DUMMY_292; 27958 27959 } 27960 __label_290: 27961 27962 if (V289) { 27963 Py_XDECREF(V289); 27964 } 27965 27966 {Py_XDECREF(py_V289);} 27967 27968 double __DUMMY_290; 27969 27970 } 27971 __label_288: 27972 27973 if (V287) { 27974 Py_XDECREF(V287); 27975 } 27976 27977 {Py_XDECREF(py_V287);} 27978 27979 double __DUMMY_288; 27980 27981 } 27982 __label_286: 27983 27984 if (V285) { 27985 Py_XDECREF(V285); 27986 } 27987 27988 {Py_XDECREF(py_V285);} 27989 27990 double __DUMMY_286; 27991 27992 } 27993 __label_284: 27994 27995 if (V283) { 27996 Py_XDECREF(V283); 27997 } 27998 27999 {Py_XDECREF(py_V283);} 28000 28001 double __DUMMY_284; 28002 28003 } 28004 __label_282: 28005 28006 if (V281) { 28007 Py_XDECREF(V281); 28008 } 28009 28010 {Py_XDECREF(py_V281);} 28011 28012 double __DUMMY_282; 28013 28014 } 28015 __label_280: 28016 28017 if (V279) { 28018 Py_XDECREF(V279); 28019 } 28020 28021 {Py_XDECREF(py_V279);} 28022 28023 double __DUMMY_280; 28024 28025 } 28026 __label_278: 28027 28028 if (V277) { 28029 Py_XDECREF(V277); 28030 } 28031 28032 {Py_XDECREF(py_V277);} 28033 28034 double __DUMMY_278; 28035 28036 } 28037 __label_276: 28038 28039 if (V275) { 28040 Py_XDECREF(V275); 28041 } 28042 28043 {Py_XDECREF(py_V275);} 28044 28045 double __DUMMY_276; 28046 28047 } 28048 __label_274: 28049 28050 if (V273) { 28051 Py_XDECREF(V273); 28052 } 28053 28054 {Py_XDECREF(py_V273);} 28055 28056 double __DUMMY_274; 28057 28058 } 28059 __label_272: 28060 28061 if (V271) { 28062 Py_XDECREF(V271); 28063 } 28064 28065 {Py_XDECREF(py_V271);} 28066 28067 double __DUMMY_272; 28068 28069 } 28070 __label_270: 28071 28072 if (V269) { 28073 Py_XDECREF(V269); 28074 } 28075 28076 {Py_XDECREF(py_V269);} 28077 28078 double __DUMMY_270; 28079 28080 } 28081 __label_268: 28082 28083 if (V267) { 28084 Py_XDECREF(V267); 28085 } 28086 28087 {Py_XDECREF(py_V267);} 28088 28089 double __DUMMY_268; 28090 28091 } 28092 __label_266: 28093 28094 if (V265) { 28095 Py_XDECREF(V265); 28096 } 28097 28098 {Py_XDECREF(py_V265);} 28099 28100 double __DUMMY_266; 28101 28102 } 28103 __label_264: 28104 28105 if (V263) { 28106 Py_XDECREF(V263); 28107 } 28108 28109 {Py_XDECREF(py_V263);} 28110 28111 double __DUMMY_264; 28112 28113 } 28114 __label_262: 28115 28116 if (V261) { 28117 Py_XDECREF(V261); 28118 } 28119 28120 {Py_XDECREF(py_V261);} 28121 28122 double __DUMMY_262; 28123 28124 } 28125 __label_260: 28126 28127 if (V259) { 28128 Py_XDECREF(V259); 28129 } 28130 28131 {Py_XDECREF(py_V259);} 28132 28133 double __DUMMY_260; 28134 28135 } 28136 __label_258: 28137 28138 if (V257) { 28139 Py_XDECREF(V257); 28140 } 28141 28142 {Py_XDECREF(py_V257);} 28143 28144 double __DUMMY_258; 28145 28146 } 28147 __label_256: 28148 28149 if (V255) { 28150 Py_XDECREF(V255); 28151 } 28152 28153 {Py_XDECREF(py_V255);} 28154 28155 double __DUMMY_256; 28156 28157 } 28158 __label_254: 28159 28160 if (V253) { 28161 Py_XDECREF(V253); 28162 } 28163 28164 {Py_XDECREF(py_V253);} 28165 28166 double __DUMMY_254; 28167 28168 } 28169 __label_252: 28170 28171 if (V251) { 28172 Py_XDECREF(V251); 28173 } 28174 28175 {Py_XDECREF(py_V251);} 28176 28177 double __DUMMY_252; 28178 28179 } 28180 __label_250: 28181 28182 if (V249) { 28183 Py_XDECREF(V249); 28184 } 28185 28186 {Py_XDECREF(py_V249);} 28187 28188 double __DUMMY_250; 28189 28190 } 28191 __label_248: 28192 28193 if (V247) { 28194 Py_XDECREF(V247); 28195 } 28196 28197 {Py_XDECREF(py_V247);} 28198 28199 double __DUMMY_248; 28200 28201 } 28202 __label_246: 28203 28204 if (V245) { 28205 Py_XDECREF(V245); 28206 } 28207 28208 {Py_XDECREF(py_V245);} 28209 28210 double __DUMMY_246; 28211 28212 } 28213 __label_244: 28214 28215 if (V243) { 28216 Py_XDECREF(V243); 28217 } 28218 28219 {Py_XDECREF(py_V243);} 28220 28221 double __DUMMY_244; 28222 28223 } 28224 __label_242: 28225 28226 if (V241) { 28227 Py_XDECREF(V241); 28228 } 28229 28230 {Py_XDECREF(py_V241);} 28231 28232 double __DUMMY_242; 28233 28234 } 28235 __label_240: 28236 28237 if (V239) { 28238 Py_XDECREF(V239); 28239 } 28240 28241 {Py_XDECREF(py_V239);} 28242 28243 double __DUMMY_240; 28244 28245 } 28246 __label_238: 28247 28248 if (V237) { 28249 Py_XDECREF(V237); 28250 } 28251 28252 {Py_XDECREF(py_V237);} 28253 28254 double __DUMMY_238; 28255 28256 } 28257 __label_236: 28258 28259 if (V235) { 28260 Py_XDECREF(V235); 28261 } 28262 28263 {Py_XDECREF(py_V235);} 28264 28265 double __DUMMY_236; 28266 28267 } 28268 __label_234: 28269 28270 if (V233) { 28271 Py_XDECREF(V233); 28272 } 28273 28274 {Py_XDECREF(py_V233);} 28275 28276 double __DUMMY_234; 28277 28278 } 28279 __label_232: 28280 28281 if (V231) { 28282 Py_XDECREF(V231); 28283 } 28284 28285 {Py_XDECREF(py_V231);} 28286 28287 double __DUMMY_232; 28288 28289 } 28290 __label_230: 28291 28292 if (V229) { 28293 Py_XDECREF(V229); 28294 } 28295 28296 {Py_XDECREF(py_V229);} 28297 28298 double __DUMMY_230; 28299 28300 } 28301 __label_228: 28302 28303 if (V227) { 28304 Py_XDECREF(V227); 28305 } 28306 28307 {Py_XDECREF(py_V227);} 28308 28309 double __DUMMY_228; 28310 28311 } 28312 __label_226: 28313 28314 if (V225) { 28315 Py_XDECREF(V225); 28316 } 28317 28318 {Py_XDECREF(py_V225);} 28319 28320 double __DUMMY_226; 28321 28322 } 28323 __label_224: 28324 28325 if (V223) { 28326 Py_XDECREF(V223); 28327 } 28328 28329 {Py_XDECREF(py_V223);} 28330 28331 double __DUMMY_224; 28332 28333 } 28334 __label_222: 28335 28336 if (V221) { 28337 Py_XDECREF(V221); 28338 } 28339 28340 {Py_XDECREF(py_V221);} 28341 28342 double __DUMMY_222; 28343 28344 } 28345 __label_220: 28346 28347 if (V219) { 28348 Py_XDECREF(V219); 28349 } 28350 28351 {Py_XDECREF(py_V219);} 28352 28353 double __DUMMY_220; 28354 28355 } 28356 __label_218: 28357 28358 if (V217) { 28359 Py_XDECREF(V217); 28360 } 28361 28362 {Py_XDECREF(py_V217);} 28363 28364 double __DUMMY_218; 28365 28366 } 28367 __label_216: 28368 28369 if (V215) { 28370 Py_XDECREF(V215); 28371 } 28372 28373 {Py_XDECREF(py_V215);} 28374 28375 double __DUMMY_216; 28376 28377 } 28378 __label_214: 28379 28380 if (V213) { 28381 Py_XDECREF(V213); 28382 } 28383 28384 {Py_XDECREF(py_V213);} 28385 28386 double __DUMMY_214; 28387 28388 } 28389 __label_212: 28390 28391 if (V211) { 28392 Py_XDECREF(V211); 28393 } 28394 28395 {Py_XDECREF(py_V211);} 28396 28397 double __DUMMY_212; 28398 28399 } 28400 __label_210: 28401 28402 if (V209) { 28403 Py_XDECREF(V209); 28404 } 28405 28406 {Py_XDECREF(py_V209);} 28407 28408 double __DUMMY_210; 28409 28410 } 28411 __label_208: 28412 28413 if (V207) { 28414 Py_XDECREF(V207); 28415 } 28416 28417 {Py_XDECREF(py_V207);} 28418 28419 double __DUMMY_208; 28420 28421 } 28422 __label_206: 28423 28424 if (V205) { 28425 Py_XDECREF(V205); 28426 } 28427 28428 {Py_XDECREF(py_V205);} 28429 28430 double __DUMMY_206; 28431 28432 } 28433 __label_204: 28434 28435 if (V203) { 28436 Py_XDECREF(V203); 28437 } 28438 28439 {Py_XDECREF(py_V203);} 28440 28441 double __DUMMY_204; 28442 28443 } 28444 __label_202: 28445 28446 if (V201) { 28447 Py_XDECREF(V201); 28448 } 28449 28450 {Py_XDECREF(py_V201);} 28451 28452 double __DUMMY_202; 28453 28454 } 28455 __label_200: 28456 28457 if (V199) { 28458 Py_XDECREF(V199); 28459 } 28460 28461 {Py_XDECREF(py_V199);} 28462 28463 double __DUMMY_200; 28464 28465 } 28466 __label_198: 28467 28468 if (V197) { 28469 Py_XDECREF(V197); 28470 } 28471 28472 {Py_XDECREF(py_V197);} 28473 28474 double __DUMMY_198; 28475 28476 } 28477 __label_196: 28478 28479 if (V195) { 28480 Py_XDECREF(V195); 28481 } 28482 28483 {Py_XDECREF(py_V195);} 28484 28485 double __DUMMY_196; 28486 28487 } 28488 __label_194: 28489 28490 if (V193) { 28491 Py_XDECREF(V193); 28492 } 28493 28494 {Py_XDECREF(py_V193);} 28495 28496 double __DUMMY_194; 28497 28498 } 28499 __label_192: 28500 28501 if (V191) { 28502 Py_XDECREF(V191); 28503 } 28504 28505 {Py_XDECREF(py_V191);} 28506 28507 double __DUMMY_192; 28508 28509 } 28510 __label_190: 28511 28512 if (V189) { 28513 Py_XDECREF(V189); 28514 } 28515 28516 {Py_XDECREF(py_V189);} 28517 28518 double __DUMMY_190; 28519 28520 } 28521 __label_188: 28522 28523 if (V187) { 28524 Py_XDECREF(V187); 28525 } 28526 28527 {Py_XDECREF(py_V187);} 28528 28529 double __DUMMY_188; 28530 28531 } 28532 __label_186: 28533 28534 if (V185) { 28535 Py_XDECREF(V185); 28536 } 28537 28538 {Py_XDECREF(py_V185);} 28539 28540 double __DUMMY_186; 28541 28542 } 28543 __label_184: 28544 28545 if (V183) { 28546 Py_XDECREF(V183); 28547 } 28548 28549 {Py_XDECREF(py_V183);} 28550 28551 double __DUMMY_184; 28552 28553 } 28554 __label_182: 28555 28556 if (V181) { 28557 Py_XDECREF(V181); 28558 } 28559 28560 {Py_XDECREF(py_V181);} 28561 28562 double __DUMMY_182; 28563 28564 } 28565 __label_180: 28566 28567 if (V179) { 28568 Py_XDECREF(V179); 28569 } 28570 28571 {Py_XDECREF(py_V179);} 28572 28573 double __DUMMY_180; 28574 28575 } 28576 __label_178: 28577 28578 if (V177) { 28579 Py_XDECREF(V177); 28580 } 28581 28582 {Py_XDECREF(py_V177);} 28583 28584 double __DUMMY_178; 28585 28586 } 28587 __label_176: 28588 28589 if (V175) { 28590 Py_XDECREF(V175); 28591 } 28592 28593 {Py_XDECREF(py_V175);} 28594 28595 double __DUMMY_176; 28596 28597 } 28598 __label_174: 28599 28600 if (V173) { 28601 Py_XDECREF(V173); 28602 } 28603 28604 {Py_XDECREF(py_V173);} 28605 28606 double __DUMMY_174; 28607 28608 } 28609 __label_172: 28610 28611 if (V171) { 28612 Py_XDECREF(V171); 28613 } 28614 28615 {Py_XDECREF(py_V171);} 28616 28617 double __DUMMY_172; 28618 28619 } 28620 __label_170: 28621 28622 if (V169) { 28623 Py_XDECREF(V169); 28624 } 28625 28626 {Py_XDECREF(py_V169);} 28627 28628 double __DUMMY_170; 28629 28630 } 28631 __label_168: 28632 28633 if (V167) { 28634 Py_XDECREF(V167); 28635 } 28636 28637 {Py_XDECREF(py_V167);} 28638 28639 double __DUMMY_168; 28640 28641 } 28642 __label_166: 28643 28644 if (V165) { 28645 Py_XDECREF(V165); 28646 } 28647 28648 {Py_XDECREF(py_V165);} 28649 28650 double __DUMMY_166; 28651 28652 } 28653 __label_164: 28654 28655 if (V163) { 28656 Py_XDECREF(V163); 28657 } 28658 28659 {Py_XDECREF(py_V163);} 28660 28661 double __DUMMY_164; 28662 28663 } 28664 __label_162: 28665 28666 if (V161) { 28667 Py_XDECREF(V161); 28668 } 28669 28670 {Py_XDECREF(py_V161);} 28671 28672 double __DUMMY_162; 28673 28674 } 28675 __label_160: 28676 28677 if (V159) { 28678 Py_XDECREF(V159); 28679 } 28680 28681 {Py_XDECREF(py_V159);} 28682 28683 double __DUMMY_160; 28684 28685 } 28686 __label_158: 28687 28688 if (V157) { 28689 Py_XDECREF(V157); 28690 } 28691 28692 {Py_XDECREF(py_V157);} 28693 28694 double __DUMMY_158; 28695 28696 } 28697 __label_156: 28698 28699 if (V155) { 28700 Py_XDECREF(V155); 28701 } 28702 28703 {Py_XDECREF(py_V155);} 28704 28705 double __DUMMY_156; 28706 28707 } 28708 __label_154: 28709 28710 if (V153) { 28711 Py_XDECREF(V153); 28712 } 28713 28714 {Py_XDECREF(py_V153);} 28715 28716 double __DUMMY_154; 28717 28718 } 28719 __label_152: 28720 28721 if (V151) { 28722 Py_XDECREF(V151); 28723 } 28724 28725 {Py_XDECREF(py_V151);} 28726 28727 double __DUMMY_152; 28728 28729 } 28730 __label_150: 28731 28732 if (V149) { 28733 Py_XDECREF(V149); 28734 } 28735 28736 {Py_XDECREF(py_V149);} 28737 28738 double __DUMMY_150; 28739 28740 } 28741 __label_148: 28742 28743 if (V147) { 28744 Py_XDECREF(V147); 28745 } 28746 28747 {Py_XDECREF(py_V147);} 28748 28749 double __DUMMY_148; 28750 28751 } 28752 __label_146: 28753 28754 if (V145) { 28755 Py_XDECREF(V145); 28756 } 28757 28758 {Py_XDECREF(py_V145);} 28759 28760 double __DUMMY_146; 28761 28762 } 28763 __label_144: 28764 28765 if (V143) { 28766 Py_XDECREF(V143); 28767 } 28768 28769 {Py_XDECREF(py_V143);} 28770 28771 double __DUMMY_144; 28772 28773 } 28774 __label_142: 28775 28776 if (V141) { 28777 Py_XDECREF(V141); 28778 } 28779 28780 {Py_XDECREF(py_V141);} 28781 28782 double __DUMMY_142; 28783 28784 } 28785 __label_140: 28786 28787 if (V139) { 28788 Py_XDECREF(V139); 28789 } 28790 28791 {Py_XDECREF(py_V139);} 28792 28793 double __DUMMY_140; 28794 28795 } 28796 __label_138: 28797 28798 if (V137) { 28799 Py_XDECREF(V137); 28800 } 28801 28802 {Py_XDECREF(py_V137);} 28803 28804 double __DUMMY_138; 28805 28806 } 28807 __label_136: 28808 28809 if (V135) { 28810 Py_XDECREF(V135); 28811 } 28812 28813 {Py_XDECREF(py_V135);} 28814 28815 double __DUMMY_136; 28816 28817 } 28818 __label_134: 28819 28820 if (V133) { 28821 Py_XDECREF(V133); 28822 } 28823 28824 {Py_XDECREF(py_V133);} 28825 28826 double __DUMMY_134; 28827 28828 } 28829 __label_132: 28830 28831 if (V131) { 28832 Py_XDECREF(V131); 28833 } 28834 28835 {Py_XDECREF(py_V131);} 28836 28837 double __DUMMY_132; 28838 28839 } 28840 __label_130: 28841 28842 if (V129) { 28843 Py_XDECREF(V129); 28844 } 28845 28846 {Py_XDECREF(py_V129);} 28847 28848 double __DUMMY_130; 28849 28850 } 28851 __label_128: 28852 28853 if (V127) { 28854 Py_XDECREF(V127); 28855 } 28856 28857 {Py_XDECREF(py_V127);} 28858 28859 double __DUMMY_128; 28860 28861 } 28862 __label_126: 28863 28864 if (V125) { 28865 Py_XDECREF(V125); 28866 } 28867 28868 {Py_XDECREF(py_V125);} 28869 28870 double __DUMMY_126; 28871 28872 } 28873 __label_124: 28874 28875 if (V123) { 28876 Py_XDECREF(V123); 28877 } 28878 28879 {Py_XDECREF(py_V123);} 28880 28881 double __DUMMY_124; 28882 28883 } 28884 __label_122: 28885 28886 if (V121) { 28887 Py_XDECREF(V121); 28888 } 28889 28890 {Py_XDECREF(py_V121);} 28891 28892 double __DUMMY_122; 28893 28894 } 28895 __label_120: 28896 28897 if (V119) { 28898 Py_XDECREF(V119); 28899 } 28900 28901 {Py_XDECREF(py_V119);} 28902 28903 double __DUMMY_120; 28904 28905 } 28906 __label_118: 28907 28908 if (V117) { 28909 Py_XDECREF(V117); 28910 } 28911 28912 {Py_XDECREF(py_V117);} 28913 28914 double __DUMMY_118; 28915 28916 } 28917 __label_116: 28918 28919 if (V115) { 28920 Py_XDECREF(V115); 28921 } 28922 28923 {Py_XDECREF(py_V115);} 28924 28925 double __DUMMY_116; 28926 28927 } 28928 __label_114: 28929 28930 if (V113) { 28931 Py_XDECREF(V113); 28932 } 28933 28934 {Py_XDECREF(py_V113);} 28935 28936 double __DUMMY_114; 28937 28938 } 28939 __label_112: 28940 28941 if (V111) { 28942 Py_XDECREF(V111); 28943 } 28944 28945 {Py_XDECREF(py_V111);} 28946 28947 double __DUMMY_112; 28948 28949 } 28950 __label_110: 28951 28952 if (V109) { 28953 Py_XDECREF(V109); 28954 } 28955 28956 {Py_XDECREF(py_V109);} 28957 28958 double __DUMMY_110; 28959 28960 } 28961 __label_108: 28962 28963 if (V107) { 28964 Py_XDECREF(V107); 28965 } 28966 28967 {Py_XDECREF(py_V107);} 28968 28969 double __DUMMY_108; 28970 28971 } 28972 __label_106: 28973 28974 if (V105) { 28975 Py_XDECREF(V105); 28976 } 28977 28978 {Py_XDECREF(py_V105);} 28979 28980 double __DUMMY_106; 28981 28982 } 28983 __label_104: 28984 28985 if (V103) { 28986 Py_XDECREF(V103); 28987 } 28988 28989 {Py_XDECREF(py_V103);} 28990 28991 double __DUMMY_104; 28992 28993 } 28994 __label_102: 28995 28996 if (V101) { 28997 Py_XDECREF(V101); 28998 } 28999 29000 {Py_XDECREF(py_V101);} 29001 29002 double __DUMMY_102; 29003 29004 } 29005 __label_100: 29006 29007 if (V99) { 29008 Py_XDECREF(V99); 29009 } 29010 29011 {Py_XDECREF(py_V99);} 29012 29013 double __DUMMY_100; 29014 29015 } 29016 __label_98: 29017 29018 if (V97) { 29019 Py_XDECREF(V97); 29020 } 29021 29022 {Py_XDECREF(py_V97);} 29023 29024 double __DUMMY_98; 29025 29026 } 29027 __label_96: 29028 29029 if (V95) { 29030 Py_XDECREF(V95); 29031 } 29032 29033 {Py_XDECREF(py_V95);} 29034 29035 double __DUMMY_96; 29036 29037 } 29038 __label_94: 29039 29040 if (V93) { 29041 Py_XDECREF(V93); 29042 } 29043 29044 {Py_XDECREF(py_V93);} 29045 29046 double __DUMMY_94; 29047 29048 } 29049 __label_92: 29050 29051 if (V91) { 29052 Py_XDECREF(V91); 29053 } 29054 29055 {Py_XDECREF(py_V91);} 29056 29057 double __DUMMY_92; 29058 29059 } 29060 __label_90: 29061 29062 if (V89) { 29063 Py_XDECREF(V89); 29064 } 29065 29066 {Py_XDECREF(py_V89);} 29067 29068 double __DUMMY_90; 29069 29070 } 29071 __label_88: 29072 29073 if (V87) { 29074 Py_XDECREF(V87); 29075 } 29076 29077 {Py_XDECREF(py_V87);} 29078 29079 double __DUMMY_88; 29080 29081 } 29082 __label_86: 29083 29084 if (V85) { 29085 Py_XDECREF(V85); 29086 } 29087 29088 {Py_XDECREF(py_V85);} 29089 29090 double __DUMMY_86; 29091 29092 } 29093 __label_84: 29094 29095 if (V83) { 29096 Py_XDECREF(V83); 29097 } 29098 29099 {Py_XDECREF(py_V83);} 29100 29101 double __DUMMY_84; 29102 29103 } 29104 __label_82: 29105 29106 if (V81) { 29107 Py_XDECREF(V81); 29108 } 29109 29110 {Py_XDECREF(py_V81);} 29111 29112 double __DUMMY_82; 29113 29114 } 29115 __label_80: 29116 29117 if (V79) { 29118 Py_XDECREF(V79); 29119 } 29120 29121 {Py_XDECREF(py_V79);} 29122 29123 double __DUMMY_80; 29124 29125 } 29126 __label_78: 29127 29128 if (V77) { 29129 Py_XDECREF(V77); 29130 } 29131 29132 {Py_XDECREF(py_V77);} 29133 29134 double __DUMMY_78; 29135 29136 } 29137 __label_76: 29138 29139 if (V75) { 29140 Py_XDECREF(V75); 29141 } 29142 29143 {Py_XDECREF(py_V75);} 29144 29145 double __DUMMY_76; 29146 29147 } 29148 __label_74: 29149 29150 if (V73) { 29151 Py_XDECREF(V73); 29152 } 29153 29154 {Py_XDECREF(py_V73);} 29155 29156 double __DUMMY_74; 29157 29158 } 29159 __label_72: 29160 29161 if (V71) { 29162 Py_XDECREF(V71); 29163 } 29164 29165 {Py_XDECREF(py_V71);} 29166 29167 double __DUMMY_72; 29168 29169 } 29170 __label_70: 29171 29172 if (V69) { 29173 Py_XDECREF(V69); 29174 } 29175 29176 {Py_XDECREF(py_V69);} 29177 29178 double __DUMMY_70; 29179 29180 } 29181 __label_68: 29182 29183 if (V67) { 29184 Py_XDECREF(V67); 29185 } 29186 29187 {Py_XDECREF(py_V67);} 29188 29189 double __DUMMY_68; 29190 29191 } 29192 __label_66: 29193 29194 if (V65) { 29195 Py_XDECREF(V65); 29196 } 29197 29198 {Py_XDECREF(py_V65);} 29199 29200 double __DUMMY_66; 29201 29202 } 29203 __label_64: 29204 29205 if (V63) { 29206 Py_XDECREF(V63); 29207 } 29208 29209 {Py_XDECREF(py_V63);} 29210 29211 double __DUMMY_64; 29212 29213 } 29214 __label_62: 29215 29216 if (V61) { 29217 Py_XDECREF(V61); 29218 } 29219 29220 {Py_XDECREF(py_V61);} 29221 29222 double __DUMMY_62; 29223 29224 } 29225 __label_60: 29226 29227 if (V59) { 29228 Py_XDECREF(V59); 29229 } 29230 29231 {Py_XDECREF(py_V59);} 29232 29233 double __DUMMY_60; 29234 29235 } 29236 __label_58: 29237 29238 if (V57) { 29239 Py_XDECREF(V57); 29240 } 29241 29242 {Py_XDECREF(py_V57);} 29243 29244 double __DUMMY_58; 29245 29246 } 29247 __label_56: 29248 29249 if (V55) { 29250 Py_XDECREF(V55); 29251 } 29252 29253 {Py_XDECREF(py_V55);} 29254 29255 double __DUMMY_56; 29256 29257 } 29258 __label_54: 29259 29260 if (V53) { 29261 Py_XDECREF(V53); 29262 } 29263 29264 {Py_XDECREF(py_V53);} 29265 29266 double __DUMMY_54; 29267 29268 } 29269 __label_52: 29270 29271 if (V51) { 29272 Py_XDECREF(V51); 29273 } 29274 29275 {Py_XDECREF(py_V51);} 29276 29277 double __DUMMY_52; 29278 29279 } 29280 __label_50: 29281 29282 if (V49) { 29283 Py_XDECREF(V49); 29284 } 29285 29286 {Py_XDECREF(py_V49);} 29287 29288 double __DUMMY_50; 29289 29290 } 29291 __label_48: 29292 29293 if (V47) { 29294 Py_XDECREF(V47); 29295 } 29296 29297 {Py_XDECREF(py_V47);} 29298 29299 double __DUMMY_48; 29300 29301 } 29302 __label_46: 29303 29304 if (V45) { 29305 Py_XDECREF(V45); 29306 } 29307 29308 {Py_XDECREF(py_V45);} 29309 29310 double __DUMMY_46; 29311 29312 } 29313 __label_44: 29314 29315 if (V43) { 29316 Py_XDECREF(V43); 29317 } 29318 29319 {Py_XDECREF(py_V43);} 29320 29321 double __DUMMY_44; 29322 29323 } 29324 __label_42: 29325 29326 if (V41) { 29327 Py_XDECREF(V41); 29328 } 29329 29330 {Py_XDECREF(py_V41);} 29331 29332 double __DUMMY_42; 29333 29334 } 29335 __label_40: 29336 29337 if (V39) { 29338 Py_XDECREF(V39); 29339 } 29340 29341 {Py_XDECREF(py_V39);} 29342 29343 double __DUMMY_40; 29344 29345 } 29346 __label_38: 29347 29348 if (V37) { 29349 Py_XDECREF(V37); 29350 } 29351 29352 {Py_XDECREF(py_V37);} 29353 29354 double __DUMMY_38; 29355 29356 } 29357 __label_36: 29358 29359 if (V35) { 29360 Py_XDECREF(V35); 29361 } 29362 29363 {Py_XDECREF(py_V35);} 29364 29365 double __DUMMY_36; 29366 29367 } 29368 __label_34: 29369 29370 if (V33) { 29371 Py_XDECREF(V33); 29372 } 29373 29374 {Py_XDECREF(py_V33);} 29375 29376 double __DUMMY_34; 29377 29378 } 29379 __label_32: 29380 29381 if (V31) { 29382 Py_XDECREF(V31); 29383 } 29384 29385 {Py_XDECREF(py_V31);} 29386 29387 double __DUMMY_32; 29388 29389 } 29390 __label_30: 29391 29392 if (V29) { 29393 Py_XDECREF(V29); 29394 } 29395 29396 {Py_XDECREF(py_V29);} 29397 29398 double __DUMMY_30; 29399 29400 } 29401 __label_28: 29402 29403 if (V27) { 29404 Py_XDECREF(V27); 29405 } 29406 29407 {Py_XDECREF(py_V27);} 29408 29409 double __DUMMY_28; 29410 29411 } 29412 __label_26: 29413 29414 if (V25) { 29415 Py_XDECREF(V25); 29416 } 29417 29418 {Py_XDECREF(py_V25);} 29419 29420 double __DUMMY_26; 29421 29422 } 29423 __label_24: 29424 29425 if (V23) { 29426 Py_XDECREF(V23); 29427 } 29428 29429 {Py_XDECREF(py_V23);} 29430 29431 double __DUMMY_24; 29432 29433 } 29434 __label_22: 29435 29436 if (V21) { 29437 Py_XDECREF(V21); 29438 } 29439 29440 {Py_XDECREF(py_V21);} 29441 29442 double __DUMMY_22; 29443 29444 } 29445 __label_20: 29446 29447 if (V19) { 29448 Py_XDECREF(V19); 29449 } 29450 29451 {Py_XDECREF(py_V19);} 29452 29453 double __DUMMY_20; 29454 29455 } 29456 __label_18: 29457 29458 if (V17) { 29459 Py_XDECREF(V17); 29460 } 29461 29462 {Py_XDECREF(py_V17);} 29463 29464 double __DUMMY_18; 29465 29466 } 29467 __label_16: 29468 29469 if (V15) { 29470 Py_XDECREF(V15); 29471 } 29472 29473 {Py_XDECREF(py_V15);} 29474 29475 double __DUMMY_16; 29476 29477 } 29478 __label_14: 29479 29480 if (V13) { 29481 Py_XDECREF(V13); 29482 } 29483 29484 {Py_XDECREF(py_V13);} 29485 29486 double __DUMMY_14; 29487 29488 } 29489 __label_12: 29490 29491 if (V11) { 29492 Py_XDECREF(V11); 29493 } 29494 29495 {Py_XDECREF(py_V11);} 29496 29497 double __DUMMY_12; 29498 29499 } 29500 __label_10: 29501 29502 if (V9) { 29503 Py_XDECREF(V9); 29504 } 29505 29506 {Py_XDECREF(py_V9);} 29507 29508 double __DUMMY_10; 29509 29510 } 29511 __label_8: 29512 29513 if (V7) { 29514 Py_XDECREF(V7); 29515 } 29516 29517 {Py_XDECREF(py_V7);} 29518 29519 double __DUMMY_8; 29520 29521 } 29522 __label_6: 29523 29524 if (V5) { 29525 Py_XDECREF(V5); 29526 } 29527 29528 {Py_XDECREF(py_V5);} 29529 29530 double __DUMMY_6; 29531 29532 } 29533 __label_4: 29534 29535 if (V3) { 29536 Py_XDECREF(V3); 29537 } 29538 29539 {Py_XDECREF(py_V3);} 29540 29541 double __DUMMY_4; 29542 29543 } 29544 __label_2: 29545 29546 if (!__failure) { 29547 29548 {Py_XDECREF(py_V1);} 29549 if (!V1) { 29550 Py_INCREF(Py_None); 29551 py_V1 = Py_None; 29552 } 29553 else if ((void*)py_V1 != (void*)V1) { 29554 py_V1 = (PyObject*)V1; 29555 } 29556 29557 {Py_XINCREF(py_V1);} 29558 29559 if (V1 && !PyArray_ISALIGNED((PyArrayObject*) py_V1)) { 29560 PyErr_Format(PyExc_NotImplementedError, 29561 "c_sync: expected an aligned array, got non-aligned array of type %ld" 29562 " with %ld dimensions, with 3 last dims " 29563 "%ld, %ld, %ld" 29564 " and 3 last strides %ld %ld, %ld.", 29565 (long int) PyArray_TYPE((PyArrayObject*) py_V1), 29566 (long int) PyArray_NDIM(V1), 29567 (long int) PyArray_NDIM(V1) >= 3 ? 29568 PyArray_DIMS(V1)[PyArray_NDIM(V1)-3] : -1, 29569 (long int) PyArray_NDIM(V1) >= 2 ? 29570 PyArray_DIMS(V1)[PyArray_NDIM(V1)-2] : -1, 29571 (long int) PyArray_NDIM(V1) >= 1 ? 29572 PyArray_DIMS(V1)[PyArray_NDIM(V1)-1] : -1, 29573 (long int) PyArray_NDIM(V1) >= 3 ? 29574 PyArray_STRIDES(V1)[PyArray_NDIM(V1)-3] : -1, 29575 (long int) PyArray_NDIM(V1) >= 2 ? 29576 PyArray_STRIDES(V1)[PyArray_NDIM(V1)-2] : -1, 29577 (long int) PyArray_NDIM(V1) >= 1 ? 29578 PyArray_STRIDES(V1)[PyArray_NDIM(V1)-1] : -1 29579 ); 29580 { 29581 __failure = 2; 29582 if (!PyErr_Occurred()) { 29583 PyErr_SetString(PyExc_RuntimeError, 29584 "Unexpected error in an Op's C code. " 29585 "No Python exception was set."); 29586 } 29587 goto __label_2;} 29588 } 29589 29590 PyObject* old = PyList_GET_ITEM(storage_V1, 0); 29591 {Py_XINCREF(py_V1);} 29592 PyList_SET_ITEM(storage_V1, 0, py_V1); 29593 {Py_XDECREF(old);} 29594 } 29595 29596 if (V1) { 29597 Py_XDECREF(V1); 29598 } 29599 29600 {Py_XDECREF(py_V1);} 29601 29602 double __DUMMY_2; 29603 29604 } 29605 29606 29607 if (__failure) { 29608 // When there is a failure, this code puts the exception 29609 // in __ERROR. 29610 PyObject* err_type = NULL; 29611 PyObject* err_msg = NULL; 29612 PyObject* err_traceback = NULL; 29613 PyErr_Fetch(&err_type, &err_msg, &err_traceback); 29614 if (!err_type) {err_type = Py_None;Py_INCREF(Py_None);} 29615 if (!err_msg) {err_msg = Py_None; Py_INCREF(Py_None);} 29616 if (!err_traceback) {err_traceback = Py_None; Py_INCREF(Py_None);} 29617 PyObject* old_err_type = PyList_GET_ITEM(__ERROR, 0); 29618 PyObject* old_err_msg = PyList_GET_ITEM(__ERROR, 1); 29619 PyObject* old_err_traceback = PyList_GET_ITEM(__ERROR, 2); 29620 PyList_SET_ITEM(__ERROR, 0, err_type); 29621 PyList_SET_ITEM(__ERROR, 1, err_msg); 29622 PyList_SET_ITEM(__ERROR, 2, err_traceback); 29623 {Py_XDECREF(old_err_type);} 29624 {Py_XDECREF(old_err_msg);} 29625 {Py_XDECREF(old_err_traceback);} 29626 } 29627 // The failure code is returned to index what code block failed. 29628 return __failure; 29629 29630 } 29631 }; 29632 } 29633 29634 29635 static int __struct_compiled_op_md48e5b5db0464960381d9655a49dfa63_executor(__struct_compiled_op_md48e5b5db0464960381d9655a49dfa63 *self) { 29636 return self->run(); 29637 } 29638 29639 static void __struct_compiled_op_md48e5b5db0464960381d9655a49dfa63_destructor(PyObject *capsule) { 29640 __struct_compiled_op_md48e5b5db0464960381d9655a49dfa63 *self = (__struct_compiled_op_md48e5b5db0464960381d9655a49dfa63 *)PyCapsule_GetContext(capsule); 29641 delete self; 29642 } 29643 29644 ////////////////////// 29645 //// Functions 29646 ////////////////////// 29647 static PyObject * instantiate(PyObject * self, PyObject *argtuple) { 29648 assert(PyTuple_Check(argtuple)); 29649 if (256 != PyTuple_Size(argtuple)){ 29650 PyErr_Format(PyExc_TypeError, "Wrong number of arguments, expected 256, got %i", (int)PyTuple_Size(argtuple)); 29651 return NULL; 29652 } 29653 __struct_compiled_op_md48e5b5db0464960381d9655a49dfa63* struct_ptr = new __struct_compiled_op_md48e5b5db0464960381d9655a49dfa63(); 29654 if (struct_ptr->init( PyTuple_GET_ITEM(argtuple, 0),PyTuple_GET_ITEM(argtuple, 1),PyTuple_GET_ITEM(argtuple, 2),PyTuple_GET_ITEM(argtuple, 3),PyTuple_GET_ITEM(argtuple, 4),PyTuple_GET_ITEM(argtuple, 5),PyTuple_GET_ITEM(argtuple, 6),PyTuple_GET_ITEM(argtuple, 7),PyTuple_GET_ITEM(argtuple, 8),PyTuple_GET_ITEM(argtuple, 9),PyTuple_GET_ITEM(argtuple, 10),PyTuple_GET_ITEM(argtuple, 11),PyTuple_GET_ITEM(argtuple, 12),PyTuple_GET_ITEM(argtuple, 13),PyTuple_GET_ITEM(argtuple, 14),PyTuple_GET_ITEM(argtuple, 15),PyTuple_GET_ITEM(argtuple, 16),PyTuple_GET_ITEM(argtuple, 17),PyTuple_GET_ITEM(argtuple, 18),PyTuple_GET_ITEM(argtuple, 19),PyTuple_GET_ITEM(argtuple, 20),PyTuple_GET_ITEM(argtuple, 21),PyTuple_GET_ITEM(argtuple, 22),PyTuple_GET_ITEM(argtuple, 23),PyTuple_GET_ITEM(argtuple, 24),PyTuple_GET_ITEM(argtuple, 25),PyTuple_GET_ITEM(argtuple, 26),PyTuple_GET_ITEM(argtuple, 27),PyTuple_GET_ITEM(argtuple, 28),PyTuple_GET_ITEM(argtuple, 29),PyTuple_GET_ITEM(argtuple, 30),PyTuple_GET_ITEM(argtuple, 31),PyTuple_GET_ITEM(argtuple, 32),PyTuple_GET_ITEM(argtuple, 33),PyTuple_GET_ITEM(argtuple, 34),PyTuple_GET_ITEM(argtuple, 35),PyTuple_GET_ITEM(argtuple, 36),PyTuple_GET_ITEM(argtuple, 37),PyTuple_GET_ITEM(argtuple, 38),PyTuple_GET_ITEM(argtuple, 39),PyTuple_GET_ITEM(argtuple, 40),PyTuple_GET_ITEM(argtuple, 41),PyTuple_GET_ITEM(argtuple, 42),PyTuple_GET_ITEM(argtuple, 43),PyTuple_GET_ITEM(argtuple, 44),PyTuple_GET_ITEM(argtuple, 45),PyTuple_GET_ITEM(argtuple, 46),PyTuple_GET_ITEM(argtuple, 47),PyTuple_GET_ITEM(argtuple, 48),PyTuple_GET_ITEM(argtuple, 49),PyTuple_GET_ITEM(argtuple, 50),PyTuple_GET_ITEM(argtuple, 51),PyTuple_GET_ITEM(argtuple, 52),PyTuple_GET_ITEM(argtuple, 53),PyTuple_GET_ITEM(argtuple, 54),PyTuple_GET_ITEM(argtuple, 55),PyTuple_GET_ITEM(argtuple, 56),PyTuple_GET_ITEM(argtuple, 57),PyTuple_GET_ITEM(argtuple, 58),PyTuple_GET_ITEM(argtuple, 59),PyTuple_GET_ITEM(argtuple, 60),PyTuple_GET_ITEM(argtuple, 61),PyTuple_GET_ITEM(argtuple, 62),PyTuple_GET_ITEM(argtuple, 63),PyTuple_GET_ITEM(argtuple, 64),PyTuple_GET_ITEM(argtuple, 65),PyTuple_GET_ITEM(argtuple, 66),PyTuple_GET_ITEM(argtuple, 67),PyTuple_GET_ITEM(argtuple, 68),PyTuple_GET_ITEM(argtuple, 69),PyTuple_GET_ITEM(argtuple, 70),PyTuple_GET_ITEM(argtuple, 71),PyTuple_GET_ITEM(argtuple, 72),PyTuple_GET_ITEM(argtuple, 73),PyTuple_GET_ITEM(argtuple, 74),PyTuple_GET_ITEM(argtuple, 75),PyTuple_GET_ITEM(argtuple, 76),PyTuple_GET_ITEM(argtuple, 77),PyTuple_GET_ITEM(argtuple, 78),PyTuple_GET_ITEM(argtuple, 79),PyTuple_GET_ITEM(argtuple, 80),PyTuple_GET_ITEM(argtuple, 81),PyTuple_GET_ITEM(argtuple, 82),PyTuple_GET_ITEM(argtuple, 83),PyTuple_GET_ITEM(argtuple, 84),PyTuple_GET_ITEM(argtuple, 85),PyTuple_GET_ITEM(argtuple, 86),PyTuple_GET_ITEM(argtuple, 87),PyTuple_GET_ITEM(argtuple, 88),PyTuple_GET_ITEM(argtuple, 89),PyTuple_GET_ITEM(argtuple, 90),PyTuple_GET_ITEM(argtuple, 91),PyTuple_GET_ITEM(argtuple, 92),PyTuple_GET_ITEM(argtuple, 93),PyTuple_GET_ITEM(argtuple, 94),PyTuple_GET_ITEM(argtuple, 95),PyTuple_GET_ITEM(argtuple, 96),PyTuple_GET_ITEM(argtuple, 97),PyTuple_GET_ITEM(argtuple, 98),PyTuple_GET_ITEM(argtuple, 99),PyTuple_GET_ITEM(argtuple, 100),PyTuple_GET_ITEM(argtuple, 101),PyTuple_GET_ITEM(argtuple, 102),PyTuple_GET_ITEM(argtuple, 103),PyTuple_GET_ITEM(argtuple, 104),PyTuple_GET_ITEM(argtuple, 105),PyTuple_GET_ITEM(argtuple, 106),PyTuple_GET_ITEM(argtuple, 107),PyTuple_GET_ITEM(argtuple, 108),PyTuple_GET_ITEM(argtuple, 109),PyTuple_GET_ITEM(argtuple, 110),PyTuple_GET_ITEM(argtuple, 111),PyTuple_GET_ITEM(argtuple, 112),PyTuple_GET_ITEM(argtuple, 113),PyTuple_GET_ITEM(argtuple, 114),PyTuple_GET_ITEM(argtuple, 115),PyTuple_GET_ITEM(argtuple, 116),PyTuple_GET_ITEM(argtuple, 117),PyTuple_GET_ITEM(argtuple, 118),PyTuple_GET_ITEM(argtuple, 119),PyTuple_GET_ITEM(argtuple, 120),PyTuple_GET_ITEM(argtuple, 121),PyTuple_GET_ITEM(argtuple, 122),PyTuple_GET_ITEM(argtuple, 123),PyTuple_GET_ITEM(argtuple, 124),PyTuple_GET_ITEM(argtuple, 125),PyTuple_GET_ITEM(argtuple, 126),PyTuple_GET_ITEM(argtuple, 127),PyTuple_GET_ITEM(argtuple, 128),PyTuple_GET_ITEM(argtuple, 129),PyTuple_GET_ITEM(argtuple, 130),PyTuple_GET_ITEM(argtuple, 131),PyTuple_GET_ITEM(argtuple, 132),PyTuple_GET_ITEM(argtuple, 133),PyTuple_GET_ITEM(argtuple, 134),PyTuple_GET_ITEM(argtuple, 135),PyTuple_GET_ITEM(argtuple, 136),PyTuple_GET_ITEM(argtuple, 137),PyTuple_GET_ITEM(argtuple, 138),PyTuple_GET_ITEM(argtuple, 139),PyTuple_GET_ITEM(argtuple, 140),PyTuple_GET_ITEM(argtuple, 141),PyTuple_GET_ITEM(argtuple, 142),PyTuple_GET_ITEM(argtuple, 143),PyTuple_GET_ITEM(argtuple, 144),PyTuple_GET_ITEM(argtuple, 145),PyTuple_GET_ITEM(argtuple, 146),PyTuple_GET_ITEM(argtuple, 147),PyTuple_GET_ITEM(argtuple, 148),PyTuple_GET_ITEM(argtuple, 149),PyTuple_GET_ITEM(argtuple, 150),PyTuple_GET_ITEM(argtuple, 151),PyTuple_GET_ITEM(argtuple, 152),PyTuple_GET_ITEM(argtuple, 153),PyTuple_GET_ITEM(argtuple, 154),PyTuple_GET_ITEM(argtuple, 155),PyTuple_GET_ITEM(argtuple, 156),PyTuple_GET_ITEM(argtuple, 157),PyTuple_GET_ITEM(argtuple, 158),PyTuple_GET_ITEM(argtuple, 159),PyTuple_GET_ITEM(argtuple, 160),PyTuple_GET_ITEM(argtuple, 161),PyTuple_GET_ITEM(argtuple, 162),PyTuple_GET_ITEM(argtuple, 163),PyTuple_GET_ITEM(argtuple, 164),PyTuple_GET_ITEM(argtuple, 165),PyTuple_GET_ITEM(argtuple, 166),PyTuple_GET_ITEM(argtuple, 167),PyTuple_GET_ITEM(argtuple, 168),PyTuple_GET_ITEM(argtuple, 169),PyTuple_GET_ITEM(argtuple, 170),PyTuple_GET_ITEM(argtuple, 171),PyTuple_GET_ITEM(argtuple, 172),PyTuple_GET_ITEM(argtuple, 173),PyTuple_GET_ITEM(argtuple, 174),PyTuple_GET_ITEM(argtuple, 175),PyTuple_GET_ITEM(argtuple, 176),PyTuple_GET_ITEM(argtuple, 177),PyTuple_GET_ITEM(argtuple, 178),PyTuple_GET_ITEM(argtuple, 179),PyTuple_GET_ITEM(argtuple, 180),PyTuple_GET_ITEM(argtuple, 181),PyTuple_GET_ITEM(argtuple, 182),PyTuple_GET_ITEM(argtuple, 183),PyTuple_GET_ITEM(argtuple, 184),PyTuple_GET_ITEM(argtuple, 185),PyTuple_GET_ITEM(argtuple, 186),PyTuple_GET_ITEM(argtuple, 187),PyTuple_GET_ITEM(argtuple, 188),PyTuple_GET_ITEM(argtuple, 189),PyTuple_GET_ITEM(argtuple, 190),PyTuple_GET_ITEM(argtuple, 191),PyTuple_GET_ITEM(argtuple, 192),PyTuple_GET_ITEM(argtuple, 193),PyTuple_GET_ITEM(argtuple, 194),PyTuple_GET_ITEM(argtuple, 195),PyTuple_GET_ITEM(argtuple, 196),PyTuple_GET_ITEM(argtuple, 197),PyTuple_GET_ITEM(argtuple, 198),PyTuple_GET_ITEM(argtuple, 199),PyTuple_GET_ITEM(argtuple, 200),PyTuple_GET_ITEM(argtuple, 201),PyTuple_GET_ITEM(argtuple, 202),PyTuple_GET_ITEM(argtuple, 203),PyTuple_GET_ITEM(argtuple, 204),PyTuple_GET_ITEM(argtuple, 205),PyTuple_GET_ITEM(argtuple, 206),PyTuple_GET_ITEM(argtuple, 207),PyTuple_GET_ITEM(argtuple, 208),PyTuple_GET_ITEM(argtuple, 209),PyTuple_GET_ITEM(argtuple, 210),PyTuple_GET_ITEM(argtuple, 211),PyTuple_GET_ITEM(argtuple, 212),PyTuple_GET_ITEM(argtuple, 213),PyTuple_GET_ITEM(argtuple, 214),PyTuple_GET_ITEM(argtuple, 215),PyTuple_GET_ITEM(argtuple, 216),PyTuple_GET_ITEM(argtuple, 217),PyTuple_GET_ITEM(argtuple, 218),PyTuple_GET_ITEM(argtuple, 219),PyTuple_GET_ITEM(argtuple, 220),PyTuple_GET_ITEM(argtuple, 221),PyTuple_GET_ITEM(argtuple, 222),PyTuple_GET_ITEM(argtuple, 223),PyTuple_GET_ITEM(argtuple, 224),PyTuple_GET_ITEM(argtuple, 225),PyTuple_GET_ITEM(argtuple, 226),PyTuple_GET_ITEM(argtuple, 227),PyTuple_GET_ITEM(argtuple, 228),PyTuple_GET_ITEM(argtuple, 229),PyTuple_GET_ITEM(argtuple, 230),PyTuple_GET_ITEM(argtuple, 231),PyTuple_GET_ITEM(argtuple, 232),PyTuple_GET_ITEM(argtuple, 233),PyTuple_GET_ITEM(argtuple, 234),PyTuple_GET_ITEM(argtuple, 235),PyTuple_GET_ITEM(argtuple, 236),PyTuple_GET_ITEM(argtuple, 237),PyTuple_GET_ITEM(argtuple, 238),PyTuple_GET_ITEM(argtuple, 239),PyTuple_GET_ITEM(argtuple, 240),PyTuple_GET_ITEM(argtuple, 241),PyTuple_GET_ITEM(argtuple, 242),PyTuple_GET_ITEM(argtuple, 243),PyTuple_GET_ITEM(argtuple, 244),PyTuple_GET_ITEM(argtuple, 245),PyTuple_GET_ITEM(argtuple, 246),PyTuple_GET_ITEM(argtuple, 247),PyTuple_GET_ITEM(argtuple, 248),PyTuple_GET_ITEM(argtuple, 249),PyTuple_GET_ITEM(argtuple, 250),PyTuple_GET_ITEM(argtuple, 251),PyTuple_GET_ITEM(argtuple, 252),PyTuple_GET_ITEM(argtuple, 253),PyTuple_GET_ITEM(argtuple, 254),PyTuple_GET_ITEM(argtuple, 255) ) != 0) { 29655 delete struct_ptr; 29656 return NULL; 29657 } 29658 PyObject* thunk = PyCapsule_New((void*)(&__struct_compiled_op_md48e5b5db0464960381d9655a49dfa63_executor), NULL, __struct_compiled_op_md48e5b5db0464960381d9655a49dfa63_destructor); 29659 if (thunk != NULL && PyCapsule_SetContext(thunk, struct_ptr) != 0) { 29660 PyErr_Clear(); 29661 Py_DECREF(thunk); 29662 thunk = NULL; 29663 } 29664 29665 return thunk; } 29666 29667 ////////////////////// 29668 //// Module init 29669 ////////////////////// 29670 static PyMethodDef MyMethods[] = { 29671 {"instantiate", instantiate, METH_VARARGS, "undocumented"} , 29672 {NULL, NULL, 0, NULL} 29673 }; 29674 static struct PyModuleDef moduledef = { 29675 PyModuleDef_HEAD_INIT, 29676 "md48e5b5db0464960381d9655a49dfa63", 29677 NULL, 29678 -1, 29679 MyMethods, 29680 }; 29681 29682 PyMODINIT_FUNC PyInit_md48e5b5db0464960381d9655a49dfa63(void) { 29683 import_array(); 29684 PyObject *m = PyModule_Create(&moduledef); 29685 return m; 29686 } 29687 Problem occurred during compilation with the command line below: /usr/bin/clang++ -dynamiclib -g -O3 -fno-math-errno -Wno-unused-label -Wno-unused-variable -Wno-write-strings -march=x86-64 -D NPY_NO_DEPRECATED_API=NPY_1_7_API_VERSION -m64 -fPIC -undefined dynamic_lookup -I/Users/fonnescj/anaconda3/lib/python3.5/site-packages/numpy/core/include -I/Users/fonnescj/anaconda3/include/python3.5m -I/Users/fonnescj/anaconda3/lib/python3.5/site-packages/theano/gof -fvisibility=hidden -o /Users/fonnescj/.theano/compiledir_Darwin-15.3.0-x86_64-i386-64bit-i386-3.5.1-64/tmpa5z86zdw/md48e5b5db0464960381d9655a49dfa63.so /Users/fonnescj/.theano/compiledir_Darwin-15.3.0-x86_64-i386-64bit-i386-3.5.1-64/tmpa5z86zdw/mod.cpp -L/Users/fonnescj/anaconda3/lib
--------------------------------------------------------------------------- Exception Traceback (most recent call last) <ipython-input-39-b89ce1e98510> in <module>() 3 if True: 4 ----> 5 trace_uae = pm.sample(5000) 6 7 else: /Users/fonnescj/Repositories/pymc3/pymc3/sampling.py in sample(draws, step, start, trace, chain, njobs, tune, progressbar, model, random_seed) 122 model = modelcontext(model) 123 --> 124 step = assign_step_methods(model, step) 125 126 if njobs is None: /Users/fonnescj/Repositories/pymc3/pymc3/sampling.py in assign_step_methods(model, step, methods) 67 68 # Instantiate all selected step methods ---> 69 steps += [s(vars=selected_steps[s]) for s in selected_steps if selected_steps[s]] 70 71 if len(steps)==1: /Users/fonnescj/Repositories/pymc3/pymc3/sampling.py in <listcomp>(.0) 67 68 # Instantiate all selected step methods ---> 69 steps += [s(vars=selected_steps[s]) for s in selected_steps if selected_steps[s]] 70 71 if len(steps)==1: /Users/fonnescj/Repositories/pymc3/pymc3/step_methods/nuts.py in __init__(self, vars, scaling, step_scale, is_cov, state, Emax, target_accept, gamma, k, t0, model, profile, **kwargs) 67 68 if isinstance(scaling, dict): ---> 69 scaling = guess_scaling(Point(scaling, model=model), model=model, vars = vars) 70 71 /Users/fonnescj/Repositories/pymc3/pymc3/tuning/scaling.py in guess_scaling(point, vars, model) 107 model = modelcontext(model) 108 try: --> 109 h = find_hessian_diag(point, vars, model=model) 110 except NotImplementedError: 111 h = fixed_hessian(point, vars, model=model) /Users/fonnescj/Repositories/pymc3/pymc3/tuning/scaling.py in find_hessian_diag(point, vars, model) 101 """ 102 model = modelcontext(model) --> 103 H = model.fastfn(hessian_diag(model.logpt, vars)) 104 return H(Point(point, model=model)) 105 /Users/fonnescj/Repositories/pymc3/pymc3/memoize.py in memoizer(*args, **kwargs) 12 13 if key not in cache: ---> 14 cache[key] = obj(*args, **kwargs) 15 16 return cache[key] /Users/fonnescj/Repositories/pymc3/pymc3/theanof.py in hessian_diag(f, vars) 101 102 if vars: --> 103 return -t.concatenate([hessian_diag1(f, v) for v in vars], axis=0) 104 else: 105 return empty_gradient /Users/fonnescj/Repositories/pymc3/pymc3/theanof.py in <listcomp>(.0) 101 102 if vars: --> 103 return -t.concatenate([hessian_diag1(f, v) for v in vars], axis=0) 104 else: 105 return empty_gradient /Users/fonnescj/Repositories/pymc3/pymc3/theanof.py in hessian_diag1(f, v) 92 return gradient1(g[i], v)[i] 93 ---> 94 return theano.map(hess_ii, idx)[0] 95 96 /Users/fonnescj/anaconda3/lib/python3.5/site-packages/theano/scan_module/scan_views.py in map(fn, sequences, non_sequences, truncate_gradient, go_backwards, mode, name) 67 go_backwards=go_backwards, 68 mode=mode, ---> 69 name=name) 70 71 /Users/fonnescj/anaconda3/lib/python3.5/site-packages/theano/scan_module/scan.py in scan(fn, sequences, outputs_info, non_sequences, n_steps, truncate_gradient, go_backwards, mode, name, profile, allow_gc, strict) 1042 pass 1043 scan_inputs += [arg] -> 1044 scan_outs = local_op(*scan_inputs) 1045 if type(scan_outs) not in (list, tuple): 1046 scan_outs = [scan_outs] /Users/fonnescj/anaconda3/lib/python3.5/site-packages/theano/gof/op.py in __call__(self, *inputs, **kwargs) 645 # compute output value once with test inputs to validate graph 646 thunk = node.op.make_thunk(node, storage_map, compute_map, --> 647 no_recycling=[]) 648 thunk.inputs = [storage_map[v] for v in node.inputs] 649 thunk.outputs = [storage_map[v] for v in node.outputs] /Users/fonnescj/anaconda3/lib/python3.5/site-packages/theano/scan_module/scan_op.py in make_thunk(self, node, storage_map, compute_map, no_recycling) 866 name=self.name, 867 profile=profile, --> 868 on_unused_input='ignore') 869 870 # Analyse the compile inner function to determine which inputs and /Users/fonnescj/anaconda3/lib/python3.5/site-packages/theano/compile/function.py in function(inputs, outputs, mode, updates, givens, no_default_updates, accept_inplace, name, rebuild_strict, allow_input_downcast, profile, on_unused_input) 315 on_unused_input=on_unused_input, 316 profile=profile, --> 317 output_keys=output_keys) 318 # We need to add the flag check_aliased inputs if we have any mutable or 319 # borrowed used defined inputs /Users/fonnescj/anaconda3/lib/python3.5/site-packages/theano/compile/pfunc.py in pfunc(params, outputs, mode, updates, givens, no_default_updates, accept_inplace, name, rebuild_strict, allow_input_downcast, profile, on_unused_input, output_keys) 524 accept_inplace=accept_inplace, name=name, 525 profile=profile, on_unused_input=on_unused_input, --> 526 output_keys=output_keys) 527 528 /Users/fonnescj/anaconda3/lib/python3.5/site-packages/theano/compile/function_module.py in orig_function(inputs, outputs, mode, accept_inplace, name, profile, on_unused_input, output_keys) 1776 on_unused_input=on_unused_input, 1777 output_keys=output_keys).create( -> 1778 defaults) 1779 1780 t2 = time.time() /Users/fonnescj/anaconda3/lib/python3.5/site-packages/theano/compile/function_module.py in create(self, input_storage, trustme, storage_map) 1640 theano.config.traceback.limit = 0 1641 _fn, _i, _o = self.linker.make_thunk( -> 1642 input_storage=input_storage_lists, storage_map=storage_map) 1643 finally: 1644 theano.config.traceback.limit = limit_orig /Users/fonnescj/anaconda3/lib/python3.5/site-packages/theano/gof/link.py in make_thunk(self, input_storage, output_storage, storage_map) 688 return self.make_all(input_storage=input_storage, 689 output_storage=output_storage, --> 690 storage_map=storage_map)[:3] 691 692 def make_all(self, input_storage, output_storage): /Users/fonnescj/anaconda3/lib/python3.5/site-packages/theano/gof/vm.py in make_all(self, profiler, input_storage, output_storage, storage_map) 1035 storage_map, 1036 compute_map, -> 1037 no_recycling)) 1038 if not hasattr(thunks[-1], 'lazy'): 1039 # We don't want all ops maker to think about lazy Ops. /Users/fonnescj/anaconda3/lib/python3.5/site-packages/theano/tensor/elemwise.py in make_thunk(self, node, storage_map, compute_map, no_recycling) 832 node.tag.sig = sig 833 return super(Elemwise, node_.op).make_thunk(node_, storage_map, --> 834 compute_map, no_recycling) 835 836 def perform(self, node, inputs, output_storage): /Users/fonnescj/anaconda3/lib/python3.5/site-packages/theano/gof/op.py in make_thunk(self, node, storage_map, compute_map, no_recycling) 1166 self.update_self_openmp() 1167 return super(OpenMPOp, self).make_thunk(node, storage_map, -> 1168 compute_map, no_recycling) 1169 1170 /Users/fonnescj/anaconda3/lib/python3.5/site-packages/theano/gof/op.py in make_thunk(self, node, storage_map, compute_map, no_recycling) 930 try: 931 return self.make_c_thunk(node, storage_map, compute_map, --> 932 no_recycling) 933 except (NotImplementedError, utils.MethodNotDefined): 934 logger.debug('Falling back on perform') /Users/fonnescj/anaconda3/lib/python3.5/site-packages/theano/gof/op.py in make_c_thunk(self, node, storage_map, compute_map, no_recycling) 848 logger.debug('Trying CLinker.make_thunk') 849 outputs = cl.make_thunk(input_storage=node_input_storage, --> 850 output_storage=node_output_storage) 851 fill_storage, node_input_filters, node_output_filters = outputs 852 /Users/fonnescj/anaconda3/lib/python3.5/site-packages/theano/gof/cc.py in make_thunk(self, input_storage, output_storage, storage_map, keep_lock) 1205 cthunk, in_storage, out_storage, error_storage = self.__compile__( 1206 input_storage, output_storage, storage_map, -> 1207 keep_lock=keep_lock) 1208 1209 res = _CThunk(cthunk, init_tasks, tasks, error_storage) /Users/fonnescj/anaconda3/lib/python3.5/site-packages/theano/gof/cc.py in __compile__(self, input_storage, output_storage, storage_map, keep_lock) 1150 output_storage, 1151 storage_map, -> 1152 keep_lock=keep_lock) 1153 return (thunk, 1154 [link.Container(input, storage) for input, storage in /Users/fonnescj/anaconda3/lib/python3.5/site-packages/theano/gof/cc.py in cthunk_factory(self, error_storage, in_storage, out_storage, storage_map, keep_lock) 1600 else: 1601 module = get_module_cache().module_from_key( -> 1602 key=key, lnk=self, keep_lock=keep_lock) 1603 1604 vars = self.inputs + self.outputs + self.orphans /Users/fonnescj/anaconda3/lib/python3.5/site-packages/theano/gof/cmodule.py in module_from_key(self, key, lnk, keep_lock) 1172 try: 1173 location = dlimport_workdir(self.dirname) -> 1174 module = lnk.compile_cmodule(location) 1175 name = module.__file__ 1176 assert name.startswith(location) /Users/fonnescj/anaconda3/lib/python3.5/site-packages/theano/gof/cc.py in compile_cmodule(self, location) 1511 lib_dirs=self.lib_dirs(), 1512 libs=libs, -> 1513 preargs=preargs) 1514 except Exception as e: 1515 e.args += (str(self.fgraph),) /Users/fonnescj/anaconda3/lib/python3.5/site-packages/theano/gof/cmodule.py in compile_str(module_name, src_code, location, include_dirs, lib_dirs, libs, preargs, py_module, hide_symbols) 2210 # difficult to read. 2211 raise Exception('Compilation failed (return status=%s): %s' % -> 2212 (status, compile_stderr.replace('\n', '. '))) 2213 elif config.cmodule.compilation_warning and compile_stderr: 2214 # Print errors just below the command line. Exception: ('The following error happened while compiling the node', Elemwise{Composite{((i0 * (((Switch(i1, (i2 * i3 * i4 * i5), i6) + Switch(i1, (i7 * i8 * i9), i6)) * i4) + (i0 * i3 * i10 * i4))) + (i11 * (((Switch(i12, (i13 * i3 * i14 * i15), i6) + Switch(i12, (i16 * i17 * i18), i6)) * i14) + (i11 * i3 * i19 * i14))) + (i20 * (((Switch(i21, (i22 * i3 * i23 * i24), i6) + Switch(i21, (i25 * i26 * i27), i6)) * i23) + (i20 * i3 * i28 * i23))) + (i29 * (((Switch(i30, (i31 * i3 * i32 * i33), i6) + Switch(i30, (i34 * i35 * i36), i6)) * i32) + (i29 * i3 * i37 * i32))) + (i29 * (((Switch(i38, (i31 * i3 * i39 * i40), i6) + Switch(i38, (i41 * i42 * i43), i6)) * i39) + (i29 * i3 * i44 * i39))) + (i29 * (((Switch(i45, (i31 * i3 * i46 * i47), i6) + Switch(i45, (i48 * i49 * i50), i6)) * i46) + (i29 * i3 * i51 * i46))) + (i29 * (((Switch(i52, (i31 * i3 * i53 * i54), i6) + Switch(i52, (i55 * i56 * i57), i6)) * i53) + (i29 * i3 * i58 * i53))) + (i29 * (((Switch(i59, (i31 * i3 * i60 * i61), i6) + Switch(i59, (i62 * i63 * i64), i6)) * i60) + (i29 * i3 * i65 * i60))) + (i66 * (((Switch(i67, (i68 * i3 * i69 * i70), i6) + Switch(i67, (i71 * i72 * i73), i6)) * i69) + (i66 * i3 * i74 * i69))) + (i66 * (((Switch(i75, (i68 * i3 * i76 * i77), i6) + Switch(i75, (i78 * i79 * i80), i6)) * i76) + (i66 * i3 * i81 * i76))) + (i66 * (((Switch(i82, (i68 * i3 * i83 * i84), i6) + Switch(i82, (i85 * i86 * i87), i6)) * i83) + (i66 * i3 * i88 * i83))) + (i89 * (((Switch(i90, (i91 * i3 * i92 * i93), i6) + Switch(i90, (i94 * i95 * i96), i6)) * i92) + (i89 * i3 * i97 * i92))) + (i89 * (((Switch(i98, (i91 * i3 * i99 * i100), i6) + Switch(i98, (i101 * i102 * i103), i6)) * i99) + (i89 * i3 * i104 * i99))) + (i105 * (((Switch(i106, (i107 * i3 * i108 * i109), i6) + Switch(i106, (i110 * i111 * i112), i6)) * i108) + (i105 * i3 * i113 * i108))) + (i105 * (((Switch(i114, (i107 * i3 * i115 * i116), i6) + Switch(i114, (i117 * i118 * i119), i6)) * i115) + (i105 * i3 * i120 * i115))) + (i105 * (((Switch(i121, (i107 * i3 * i122 * i123), i6) + Switch(i121, (i124 * i125 * i126), i6)) * i122) + (i105 * i3 * i127 * i122))) + (i128 * (((Switch(i129, (i130 * i3 * i131 * i132), i6) + Switch(i129, (i133 * i134 * i135), i6)) * i131) + (i128 * i3 * i136 * i131))) + (i137 * (((Switch(i138, (i139 * i3 * i140 * i141), i6) + Switch(i138, (i142 * i143 * i144), i6)) * i140) + (i137 * i3 * i145 * i140))) + (i146 * (((Switch(i147, (i148 * i3 * i149 * i150), i6) + Switch(i147, (i151 * i152 * i153), i6)) * i149) + (i146 * i3 * i154 * i149))) + (i146 * (((Switch(i155, (i148 * i3 * i156 * i157), i6) + Switch(i155, (i158 * i159 * i160), i6)) * i156) + (i146 * i3 * i161 * i156))) + (i146 * (((Switch(i162, (i148 * i3 * i163 * i164), i6) + Switch(i162, (i165 * i166 * i167), i6)) * i163) + (i146 * i3 * i168 * i163))) + (i169 * (((Switch(i170, (i171 * i3 * i172 * i173), i6) + Switch(i170, (i174 * i175 * i176), i6)) * i172) + (i169 * i3 * i177 * i172))) + (i178 * (((Switch(i179, (i180 * i3 * i181 * i182), i6) + Switch(i179, (i183 * i184 * i185), i6)) * i181) + (i178 * i3 * i186 * i181))) + (i187 * (((Switch(i188, (i189 * i3 * i190 * i191), i6) + Switch(i188, (i192 * i193 * i194), i6)) * i190) + (i187 * i3 * i195 * i190))) + (i196 * (((Switch(i197, (i198 * i3 * i199 * i200), i6) + Switch(i197, (i201 * i202 * i203), i6)) * i199) + (i196 * i3 * i204 * i199))) + (i205 * (((Switch(i206, (i207 * i3 * i208 * i209), i6) + Switch(i206, (i210 * i211 * i212), i6)) * i208) + (i205 * i3 * i213 * i208))) + (i169 * (((Switch(i214, (i171 * i3 * i215 * i216), i6) + Switch(i214, (i217 * i218 * i219), i6)) * i215) + (i169 * i3 * i220 * i215))) + (i221 * (((Switch(i222, (i223 * i3 * i224 * i225), i6) + Switch(i222, (i226 * i227 * i228), i6)) * i224) + (i221 * i3 * i229 * i224))) + (i205 * (((Switch(i230, (i207 * i3 * i231 * i232), i6) + Switch(i230, (i233 * i234 * i235), i6)) * i231) + (i205 * i3 * i236 * i231))) + (i237 * (((Switch(i238, (i239 * i3 * i240 * i241), i6) + Switch(i238, (i242 * i243 * i244), i6)) * i240) + (i237 * i3 * i245 * i240))) + (i246 * (((Switch(i247, (i248 * i3 * i249 * i250), i6) + Switch(i247, (i251 * i252 * i253), i6)) * i249) + (i246 * i3 * i254 * i249))) + (i255 * (((Switch(i256, (i257 * i3 * i258 * i259), i6) + Switch(i256, (i260 * i261 * i262), i6)) * i258) + (i255 * i3 * i263 * i258))) + ((Switch(i264, (i265 * i3 * i266 * i267), i6) + Switch(i264, (i268 * i269), i6)) * i266) + (i3 * i270 * i266) + (i271 * i3) + (i272 * (((Switch(i273, (i274 * i3 * i275 * i276), i6) + Switch(i273, (i277 * i278 * i279), i6)) * i275) + (i272 * i3 * i280 * i275))) + ((Switch(i281, (i265 * i3 * i282 * i283), i6) + Switch(i281, (i284 * i285), i6)) * i282) + (i3 * i286 * i282))}}(TensorConstant{10.0}, InplaceDimShuffle{}.0, TensorConstant{-10.0}, Subtensor{int64}.0, Subtensor{int64}.0, Elemwise{scalar_trigamma}.0, TensorConstant{0}, Elemwise{scalar_trigamma}.0, TensorConstant{10.0}, Sum{acc_dtype=float64}.0, Subtensor{int64}.0, TensorConstant{8.5}, InplaceDimShuffle{}.0, TensorConstant{-8.5}, Subtensor{int64}.0, Elemwise{scalar_trigamma}.0, Elemwise{scalar_trigamma}.0, TensorConstant{8.5}, Sum{acc_dtype=float64}.0, Subtensor{int64}.0, TensorConstant{6.399999999999999}, InplaceDimShuffle{}.0, TensorConstant{-6.399999999999999}, Subtensor{int64}.0, Elemwise{scalar_trigamma}.0, Elemwise{scalar_trigamma}.0, TensorConstant{6.399999999999999}, Sum{acc_dtype=float64}.0, Subtensor{int64}.0, TensorConstant{4.600000000000001}, InplaceDimShuffle{}.0, TensorConstant{-4.600000000000001}, Subtensor{int64}.0, Elemwise{scalar_trigamma}.0, Elemwise{scalar_trigamma}.0, TensorConstant{4.600000000000001}, Sum{acc_dtype=float64}.0, Subtensor{int64}.0, InplaceDimShuffle{}.0, Subtensor{int64}.0, Elemwise{scalar_trigamma}.0, Elemwise{scalar_trigamma}.0, TensorConstant{4.600000000000001}, Sum{acc_dtype=float64}.0, Subtensor{int64}.0, InplaceDimShuffle{}.0, Subtensor{int64}.0, Elemwise{scalar_trigamma}.0, Elemwise{scalar_trigamma}.0, TensorConstant{4.600000000000001}, Sum{acc_dtype=float64}.0, Subtensor{int64}.0, InplaceDimShuffle{}.0, Subtensor{int64}.0, Elemwise{scalar_trigamma}.0, Elemwise{scalar_trigamma}.0, TensorConstant{4.600000000000001}, Sum{acc_dtype=float64}.0, Subtensor{int64}.0, InplaceDimShuffle{}.0, Subtensor{int64}.0, Elemwise{scalar_trigamma}.0, Elemwise{scalar_trigamma}.0, TensorConstant{4.600000000000001}, Sum{acc_dtype=float64}.0, Subtensor{int64}.0, TensorConstant{3.6000000000000014}, InplaceDimShuffle{}.0, TensorConstant{-3.6000000000000014}, Subtensor{int64}.0, Elemwise{scalar_trigamma}.0, Elemwise{scalar_trigamma}.0, TensorConstant{3.6000000000000014}, Sum{acc_dtype=float64}.0, Subtensor{int64}.0, InplaceDimShuffle{}.0, Subtensor{int64}.0, Elemwise{scalar_trigamma}.0, Elemwise{scalar_trigamma}.0, TensorConstant{3.6000000000000014}, Sum{acc_dtype=float64}.0, Subtensor{int64}.0, InplaceDimShuffle{}.0, Subtensor{int64}.0, Elemwise{scalar_trigamma}.0, Elemwise{scalar_trigamma}.0, TensorConstant{3.6000000000000014}, Sum{acc_dtype=float64}.0, Subtensor{int64}.0, TensorConstant{3.200000000000003}, InplaceDimShuffle{}.0, TensorConstant{-3.200000000000003}, Subtensor{int64}.0, Elemwise{scalar_trigamma}.0, Elemwise{scalar_trigamma}.0, TensorConstant{3.200000000000003}, Sum{acc_dtype=float64}.0, Subtensor{int64}.0, InplaceDimShuffle{}.0, Subtensor{int64}.0, Elemwise{scalar_trigamma}.0, Elemwise{scalar_trigamma}.0, TensorConstant{3.200000000000003}, Sum{acc_dtype=float64}.0, Subtensor{int64}.0, TensorConstant{-7.700000000000003}, InplaceDimShuffle{}.0, TensorConstant{7.700000000000003}, Subtensor{int64}.0, Elemwise{scalar_trigamma}.0, Elemwise{scalar_trigamma}.0, TensorConstant{-7.700000000000003}, Sum{acc_dtype=float64}.0, Subtensor{int64}.0, InplaceDimShuffle{}.0, Subtensor{int64}.0, Elemwise{scalar_trigamma}.0, Elemwise{scalar_trigamma}.0, TensorConstant{-7.700000000000003}, Sum{acc_dtype=float64}.0, Subtensor{int64}.0, InplaceDimShuffle{}.0, Subtensor{int64}.0, Elemwise{scalar_trigamma}.0, Elemwise{scalar_trigamma}.0, TensorConstant{-7.700000000000003}, Sum{acc_dtype=float64}.0, Subtensor{int64}.0, TensorConstant{3.0}, InplaceDimShuffle{}.0, TensorConstant{-3.0}, Subtensor{int64}.0, Elemwise{scalar_trigamma}.0, Elemwise{scalar_trigamma}.0, TensorConstant{3.0}, Sum{acc_dtype=float64}.0, Subtensor{int64}.0, TensorConstant{-2.299999999999997}, InplaceDimShuffle{}.0, TensorConstant{2.299999999999997}, Subtensor{int64}.0, Elemwise{scalar_trigamma}.0, Elemwise{scalar_trigamma}.0, TensorConstant{-2.299999999999997}, Sum{acc_dtype=float64}.0, Subtensor{int64}.0, TensorConstant{3.1000000000000014}, InplaceDimShuffle{}.0, TensorConstant{-3.1000000000000014}, Subtensor{int64}.0, Elemwise{scalar_trigamma}.0, Elemwise{scalar_trigamma}.0, TensorConstant{3.1000000000000014}, Sum{acc_dtype=float64}.0, Subtensor{int64}.0, InplaceDimShuffle{}.0, Subtensor{int64}.0, Elemwise{scalar_trigamma}.0, Elemwise{scalar_trigamma}.0, TensorConstant{3.1000000000000014}, Sum{acc_dtype=float64}.0, Subtensor{int64}.0, InplaceDimShuffle{}.0, Subtensor{int64}.0, Elemwise{scalar_trigamma}.0, Elemwise{scalar_trigamma}.0, TensorConstant{3.1000000000000014}, Sum{acc_dtype=float64}.0, Subtensor{int64}.0, TensorConstant{4.899999999999999}, InplaceDimShuffle{}.0, TensorConstant{-4.899999999999999}, Subtensor{int64}.0, Elemwise{scalar_trigamma}.0, Elemwise{scalar_trigamma}.0, TensorConstant{4.899999999999999}, Sum{acc_dtype=float64}.0, Subtensor{int64}.0, TensorConstant{5.899999999999999}, InplaceDimShuffle{}.0, TensorConstant{-5.899999999999999}, Subtensor{int64}.0, Elemwise{scalar_trigamma}.0, Elemwise{scalar_trigamma}.0, TensorConstant{5.899999999999999}, Sum{acc_dtype=float64}.0, Subtensor{int64}.0, TensorConstant{3.299999999999997}, InplaceDimShuffle{}.0, TensorConstant{-3.299999999999997}, Subtensor{int64}.0, Elemwise{scalar_trigamma}.0, Elemwise{scalar_trigamma}.0, TensorConstant{3.299999999999997}, Sum{acc_dtype=float64}.0, Subtensor{int64}.0, TensorConstant{2.5}, InplaceDimShuffle{}.0, TensorConstant{-2.5}, Subtensor{int64}.0, Elemwise{scalar_trigamma}.0, Elemwise{scalar_trigamma}.0, TensorConstant{2.5}, Sum{acc_dtype=float64}.0, Subtensor{int64}.0, TensorConstant{5.0}, InplaceDimShuffle{}.0, TensorConstant{-5.0}, Subtensor{int64}.0, Elemwise{scalar_trigamma}.0, Elemwise{scalar_trigamma}.0, TensorConstant{5.0}, Sum{acc_dtype=float64}.0, Subtensor{int64}.0, InplaceDimShuffle{}.0, Subtensor{int64}.0, Elemwise{scalar_trigamma}.0, Elemwise{scalar_trigamma}.0, TensorConstant{4.899999999999999}, Sum{acc_dtype=float64}.0, Subtensor{int64}.0, TensorConstant{4.0}, InplaceDimShuffle{}.0, TensorConstant{-4.0}, Subtensor{int64}.0, Elemwise{scalar_trigamma}.0, Elemwise{scalar_trigamma}.0, TensorConstant{4.0}, Sum{acc_dtype=float64}.0, Subtensor{int64}.0, InplaceDimShuffle{}.0, Subtensor{int64}.0, Elemwise{scalar_trigamma}.0, Elemwise{scalar_trigamma}.0, TensorConstant{5.0}, Sum{acc_dtype=float64}.0, Subtensor{int64}.0, TensorConstant{2.700000000000003}, InplaceDimShuffle{}.0, TensorConstant{-2.700000000000003}, Subtensor{int64}.0, Elemwise{scalar_trigamma}.0, Elemwise{scalar_trigamma}.0, TensorConstant{2.700000000000003}, Sum{acc_dtype=float64}.0, Subtensor{int64}.0, TensorConstant{0.29999999999999716}, InplaceDimShuffle{}.0, TensorConstant{-0.29999999999999716}, Subtensor{int64}.0, Elemwise{scalar_trigamma}.0, Elemwise{scalar_trigamma}.0, TensorConstant{0.29999999999999716}, Sum{acc_dtype=float64}.0, Subtensor{int64}.0, TensorConstant{1.7000000000000028}, InplaceDimShuffle{}.0, TensorConstant{-1.7000000000000028}, Subtensor{int64}.0, Elemwise{scalar_trigamma}.0, Elemwise{scalar_trigamma}.0, TensorConstant{1.7000000000000028}, Sum{acc_dtype=float64}.0, Subtensor{int64}.0, InplaceDimShuffle{}.0, TensorConstant{-1.0}, Subtensor{int64}.0, Elemwise{scalar_trigamma}.0, Elemwise{scalar_trigamma}.0, Sum{acc_dtype=float64}.0, Subtensor{int64}.0, TensorConstant{-0.01}, TensorConstant{3.8999999999999986}, InplaceDimShuffle{}.0, TensorConstant{-3.8999999999999986}, Subtensor{int64}.0, Elemwise{scalar_trigamma}.0, Elemwise{scalar_trigamma}.0, TensorConstant{3.8999999999999986}, Sum{acc_dtype=float64}.0, Subtensor{int64}.0, InplaceDimShuffle{}.0, Subtensor{int64}.0, Elemwise{scalar_trigamma}.0, Elemwise{scalar_trigamma}.0, Sum{acc_dtype=float64}.0, Subtensor{int64}.0), '\n', 'Compilation failed (return status=1): /Users/fonnescj/.theano/compiledir_Darwin-15.3.0-x86_64-i386-64bit-i386-3.5.1-64/tmpa5z86zdw/mod.cpp:24729:32: fatal error: bracket nesting level exceeded maximum of 256. if (!PyErr_Occurred()) {. ^. /Users/fonnescj/.theano/compiledir_Darwin-15.3.0-x86_64-i386-64bit-i386-3.5.1-64/tmpa5z86zdw/mod.cpp:24729:32: note: use -fbracket-depth=N to increase maximum nesting level. 1 error generated.. ', '[Elemwise{Composite{((i0 * (((Switch(i1, (i2 * i3 * i4 * i5), i6) + Switch(i1, (i7 * i8 * i9), i6)) * i4) + (i0 * i3 * i10 * i4))) + (i11 * (((Switch(i12, (i13 * i3 * i14 * i15), i6) + Switch(i12, (i16 * i17 * i18), i6)) * i14) + (i11 * i3 * i19 * i14))) + (i20 * (((Switch(i21, (i22 * i3 * i23 * i24), i6) + Switch(i21, (i25 * i26 * i27), i6)) * i23) + (i20 * i3 * i28 * i23))) + (i29 * (((Switch(i30, (i31 * i3 * i32 * i33), i6) + Switch(i30, (i34 * i35 * i36), i6)) * i32) + (i29 * i3 * i37 * i32))) + (i29 * (((Switch(i38, (i31 * i3 * i39 * i40), i6) + Switch(i38, (i41 * i42 * i43), i6)) * i39) + (i29 * i3 * i44 * i39))) + (i29 * (((Switch(i45, (i31 * i3 * i46 * i47), i6) + Switch(i45, (i48 * i49 * i50), i6)) * i46) + (i29 * i3 * i51 * i46))) + (i29 * (((Switch(i52, (i31 * i3 * i53 * i54), i6) + Switch(i52, (i55 * i56 * i57), i6)) * i53) + (i29 * i3 * i58 * i53))) + (i29 * (((Switch(i59, (i31 * i3 * i60 * i61), i6) + Switch(i59, (i62 * i63 * i64), i6)) * i60) + (i29 * i3 * i65 * i60))) + (i66 * (((Switch(i67, (i68 * i3 * i69 * i70), i6) + Switch(i67, (i71 * i72 * i73), i6)) * i69) + (i66 * i3 * i74 * i69))) + (i66 * (((Switch(i75, (i68 * i3 * i76 * i77), i6) + Switch(i75, (i78 * i79 * i80), i6)) * i76) + (i66 * i3 * i81 * i76))) + (i66 * (((Switch(i82, (i68 * i3 * i83 * i84), i6) + Switch(i82, (i85 * i86 * i87), i6)) * i83) + (i66 * i3 * i88 * i83))) + (i89 * (((Switch(i90, (i91 * i3 * i92 * i93), i6) + Switch(i90, (i94 * i95 * i96), i6)) * i92) + (i89 * i3 * i97 * i92))) + (i89 * (((Switch(i98, (i91 * i3 * i99 * i100), i6) + Switch(i98, (i101 * i102 * i103), i6)) * i99) + (i89 * i3 * i104 * i99))) + (i105 * (((Switch(i106, (i107 * i3 * i108 * i109), i6) + Switch(i106, (i110 * i111 * i112), i6)) * i108) + (i105 * i3 * i113 * i108))) + (i105 * (((Switch(i114, (i107 * i3 * i115 * i116), i6) + Switch(i114, (i117 * i118 * i119), i6)) * i115) + (i105 * i3 * i120 * i115))) + (i105 * (((Switch(i121, (i107 * i3 * i122 * i123), i6) + Switch(i121, (i124 * i125 * i126), i6)) * i122) + (i105 * i3 * i127 * i122))) + (i128 * (((Switch(i129, (i130 * i3 * i131 * i132), i6) + Switch(i129, (i133 * i134 * i135), i6)) * i131) + (i128 * i3 * i136 * i131))) + (i137 * (((Switch(i138, (i139 * i3 * i140 * i141), i6) + Switch(i138, (i142 * i143 * i144), i6)) * i140) + (i137 * i3 * i145 * i140))) + (i146 * (((Switch(i147, (i148 * i3 * i149 * i150), i6) + Switch(i147, (i151 * i152 * i153), i6)) * i149) + (i146 * i3 * i154 * i149))) + (i146 * (((Switch(i155, (i148 * i3 * i156 * i157), i6) + Switch(i155, (i158 * i159 * i160), i6)) * i156) + (i146 * i3 * i161 * i156))) + (i146 * (((Switch(i162, (i148 * i3 * i163 * i164), i6) + Switch(i162, (i165 * i166 * i167), i6)) * i163) + (i146 * i3 * i168 * i163))) + (i169 * (((Switch(i170, (i171 * i3 * i172 * i173), i6) + Switch(i170, (i174 * i175 * i176), i6)) * i172) + (i169 * i3 * i177 * i172))) + (i178 * (((Switch(i179, (i180 * i3 * i181 * i182), i6) + Switch(i179, (i183 * i184 * i185), i6)) * i181) + (i178 * i3 * i186 * i181))) + (i187 * (((Switch(i188, (i189 * i3 * i190 * i191), i6) + Switch(i188, (i192 * i193 * i194), i6)) * i190) + (i187 * i3 * i195 * i190))) + (i196 * (((Switch(i197, (i198 * i3 * i199 * i200), i6) + Switch(i197, (i201 * i202 * i203), i6)) * i199) + (i196 * i3 * i204 * i199))) + (i205 * (((Switch(i206, (i207 * i3 * i208 * i209), i6) + Switch(i206, (i210 * i211 * i212), i6)) * i208) + (i205 * i3 * i213 * i208))) + (i169 * (((Switch(i214, (i171 * i3 * i215 * i216), i6) + Switch(i214, (i217 * i218 * i219), i6)) * i215) + (i169 * i3 * i220 * i215))) + (i221 * (((Switch(i222, (i223 * i3 * i224 * i225), i6) + Switch(i222, (i226 * i227 * i228), i6)) * i224) + (i221 * i3 * i229 * i224))) + (i205 * (((Switch(i230, (i207 * i3 * i231 * i232), i6) + Switch(i230, (i233 * i234 * i235), i6)) * i231) + (i205 * i3 * i236 * i231))) + (i237 * (((Switch(i238, (i239 * i3 * i240 * i241), i6) + Switch(i238, (i242 * i243 * i244), i6)) * i240) + (i237 * i3 * i245 * i240))) + (i246 * (((Switch(i247, (i248 * i3 * i249 * i250), i6) + Switch(i247, (i251 * i252 * i253), i6)) * i249) + (i246 * i3 * i254 * i249))) + (i255 * (((Switch(i256, (i257 * i3 * i258 * i259), i6) + Switch(i256, (i260 * i261 * i262), i6)) * i258) + (i255 * i3 * i263 * i258))) + ((Switch(i264, (i265 * i3 * i266 * i267), i6) + Switch(i264, (i268 * i269), i6)) * i266) + (i3 * i270 * i266) + (i271 * i3) + (i272 * (((Switch(i273, (i274 * i3 * i275 * i276), i6) + Switch(i273, (i277 * i278 * i279), i6)) * i275) + (i272 * i3 * i280 * i275))) + ((Switch(i281, (i265 * i3 * i282 * i283), i6) + Switch(i281, (i284 * i285), i6)) * i282) + (i3 * i286 * i282))}}(TensorConstant{10.0}, <TensorType(int8, scalar)>, TensorConstant{-10.0}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{0}, <TensorType(float64, scalar)>, TensorConstant{10.0}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{8.5}, <TensorType(int8, scalar)>, TensorConstant{-8.5}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{8.5}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{6.399999999999999}, <TensorType(int8, scalar)>, TensorConstant{-6.399999999999999}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{6.399999999999999}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{4.600000000000001}, <TensorType(int8, scalar)>, TensorConstant{-4.600000000000001}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{4.600000000000001}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(int8, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{4.600000000000001}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(int8, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{4.600000000000001}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(int8, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{4.600000000000001}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(int8, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{4.600000000000001}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{3.6000000000000014}, <TensorType(int8, scalar)>, TensorConstant{-3.6000000000000014}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{3.6000000000000014}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(int8, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{3.6000000000000014}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(int8, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{3.6000000000000014}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{3.200000000000003}, <TensorType(int8, scalar)>, TensorConstant{-3.200000000000003}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{3.200000000000003}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(int8, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{3.200000000000003}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{-7.700000000000003}, <TensorType(int8, scalar)>, TensorConstant{7.700000000000003}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{-7.700000000000003}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(int8, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{-7.700000000000003}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(int8, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{-7.700000000000003}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{3.0}, <TensorType(int8, scalar)>, TensorConstant{-3.0}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{3.0}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{-2.299999999999997}, <TensorType(int8, scalar)>, TensorConstant{2.299999999999997}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{-2.299999999999997}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{3.1000000000000014}, <TensorType(int8, scalar)>, TensorConstant{-3.1000000000000014}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{3.1000000000000014}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(int8, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{3.1000000000000014}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(int8, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{3.1000000000000014}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{4.899999999999999}, <TensorType(int8, scalar)>, TensorConstant{-4.899999999999999}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{4.899999999999999}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{5.899999999999999}, <TensorType(int8, scalar)>, TensorConstant{-5.899999999999999}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{5.899999999999999}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{3.299999999999997}, <TensorType(int8, scalar)>, TensorConstant{-3.299999999999997}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{3.299999999999997}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{2.5}, <TensorType(int8, scalar)>, TensorConstant{-2.5}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{2.5}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{5.0}, <TensorType(int8, scalar)>, TensorConstant{-5.0}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{5.0}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(int8, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{4.899999999999999}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{4.0}, <TensorType(int8, scalar)>, TensorConstant{-4.0}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{4.0}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(int8, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{5.0}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{2.700000000000003}, <TensorType(int8, scalar)>, TensorConstant{-2.700000000000003}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{2.700000000000003}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{0.29999999999999716}, <TensorType(int8, scalar)>, TensorConstant{-0.29999999999999716}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{0.29999999999999716}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{1.7000000000000028}, <TensorType(int8, scalar)>, TensorConstant{-1.7000000000000028}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{1.7000000000000028}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(int8, scalar)>, TensorConstant{-1.0}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{-0.01}, TensorConstant{3.8999999999999986}, <TensorType(int8, scalar)>, TensorConstant{-3.8999999999999986}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, TensorConstant{3.8999999999999986}, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(int8, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>, <TensorType(float64, scalar)>)]')
pm.forestplot(trace_uae, vars=['μ'])
<matplotlib.gridspec.GridSpec at 0x7f6737ff7dd8>
Follow-up time effect size estimates. Positive values indicate higher probability of event with increased follow-up time.
pm.forestplot(trace_uae, vars=['β_fup'], ylabels=plot_labels)
<matplotlib.gridspec.GridSpec at 0x7f6736604da0>
Age effect size estimates. Positive values suggest higher probability of event with each year above age 40.
pm.forestplot(trace_uae, vars=['β_age'], ylabels=plot_labels)
<matplotlib.gridspec.GridSpec at 0x7f673657fb70>
Estimated probabilities of follow-up interventions for 6-month followup and age 40.
plot_labels = dataset.columns[5:12]
pm.forestplot(trace_uae, vars=['p_6'], ylabels=plot_labels)
<matplotlib.gridspec.GridSpec at 0x7f67450e2e48>
pm.summary(trace_uae, vars=['p_6'])
p_6: Mean SD MC Error 95% HPD interval ------------------------------------------------------------------- 0.044 0.023 0.001 [0.005, 0.092] 0.022 0.017 0.001 [0.000, 0.053] 0.014 0.014 0.001 [0.000, 0.039] 0.001 0.006 0.000 [0.000, 0.007] 0.005 0.009 0.000 [0.000, 0.018] 0.002 0.006 0.000 [0.000, 0.009] 0.912 0.035 0.002 [0.844, 0.970] Posterior quantiles: 2.5 25 50 75 97.5 |--------------|==============|==============|--------------| 0.009 0.027 0.041 0.057 0.100 0.001 0.010 0.018 0.030 0.063 0.000 0.005 0.011 0.020 0.046 0.000 0.000 0.000 0.000 0.013 0.000 0.000 0.002 0.006 0.025 0.000 0.000 0.000 0.001 0.017 0.830 0.894 0.916 0.936 0.964
Estimated probabilities of follow-up interventions for 12-month followup and age 40.
pm.forestplot(trace_uae, vars=['p_12'], ylabels=plot_labels)
<matplotlib.gridspec.GridSpec at 0x7f6738324a90>
pm.summary(trace_uae, vars=['p_12'])
p_12: Mean SD MC Error 95% HPD interval ------------------------------------------------------------------- 0.053 0.026 0.001 [0.009, 0.106] 0.024 0.017 0.001 [0.000, 0.055] 0.018 0.014 0.001 [0.000, 0.046] 0.002 0.007 0.000 [0.000, 0.009] 0.005 0.008 0.000 [0.000, 0.017] 0.002 0.007 0.000 [0.000, 0.009] 0.896 0.037 0.002 [0.824, 0.961] Posterior quantiles: 2.5 25 50 75 97.5 |--------------|==============|==============|--------------| 0.013 0.034 0.050 0.068 0.113 0.002 0.011 0.020 0.032 0.066 0.001 0.008 0.015 0.025 0.054 0.000 0.000 0.000 0.001 0.015 0.000 0.000 0.002 0.006 0.028 0.000 0.000 0.000 0.001 0.018 0.811 0.877 0.901 0.921 0.954
Estimated probabilities of follow-up interventions for 12-month followup and age 50.
pm.forestplot(trace_uae, vars=['p_6_50'], ylabels=plot_labels)
<matplotlib.gridspec.GridSpec at 0x7f6736677048>
pm.summary(trace_uae, vars=['p_6_50'])
p_6_50: Mean SD MC Error 95% HPD interval ------------------------------------------------------------------- 0.080 0.033 0.003 [0.032, 0.163] 0.002 0.004 0.000 [0.000, 0.004] 0.005 0.006 0.000 [0.001, 0.010] 0.001 0.007 0.000 [0.000, 0.000] 0.002 0.005 0.000 [0.000, 0.004] 0.001 0.006 0.000 [0.000, 0.000] 0.910 0.037 0.004 [0.827, 0.960] Posterior quantiles: 2.5 25 50 75 97.5 |--------------|==============|==============|--------------| 0.034 0.061 0.072 0.090 0.165 0.000 0.001 0.002 0.002 0.006 0.001 0.002 0.004 0.006 0.011 0.000 0.000 0.000 0.000 0.001 0.000 0.000 0.001 0.002 0.005 0.000 0.000 0.000 0.000 0.003 0.825 0.902 0.920 0.931 0.959