Construct FunctionCreationGeneratorLocal

Kay Hayen

2013-08-15 08:15

Performance Diagrams

Source Code with Construct

module_var = None

def calledRepeatedly():
    # We measure making a local function that will remain unused.
# construct_begin
    def empty():
        yield 1
# construct_alternative



    return empty


import itertools
for x in itertools.repeat(None, 50000):
    calledRepeatedly()

print("OK.")

Source Code without Construct

module_var = None

def calledRepeatedly():
    # We measure making a local function that will remain unused.
# construct_begin


# construct_alternative
    empty = 1
# construct_end

    return empty


import itertools
for x in itertools.repeat(None, 50000):
    calledRepeatedly()

print("OK.")

Context Diff of Source Code

	Construct			Baseline
	21	module_var = None		21	module_var = None
	22			22
	23	def calledRepeatedly():		23	def calledRepeatedly():
	24	# We measure making a local function that will remain unused.		24	# We measure making a local function that will remain unused.
	25	# construct_begin		25	# construct_begin
n	26	def empty():	n
	27	yield 1
	28	# construct_alternative
	29			26
	30			27
t			t	28	# construct_alternative
				29	empty = 1
				30	# construct_end
	31			31
	32	return empty		32	return empty
	33			33
	34			34
	35	import itertools		35	import itertools

Context Diff of Generated Code

	Construct			Baseline
	31			31
	32	PyObject *module___main__;		32	PyObject *module___main__;
	33	PyDictObject *moduledict___main__;		33	PyDictObject *moduledict___main__;
	34			34
	35	/* The declarations of module constants used, if any. */		35	/* The declarations of module constants used, if any. */
n	36	static PyObject *mod_consts[19];	n	36	static PyObject *mod_consts[17];
	37	#ifndef __NUITKA_NO_ASSERT__		37	#ifndef __NUITKA_NO_ASSERT__
n	38	static Py_hash_t mod_consts_hash[19];	n	38	static Py_hash_t mod_consts_hash[17];
	39	#endif		39	#endif
	40			40
	41	static PyObject *module_filename_obj = NULL;		41	static PyObject *module_filename_obj = NULL;
	42			42
	43	/* Indicator if this modules private constants were created yet. */		43	/* Indicator if this modules private constants were created yet. */
	48	if (constants_created == false) {		48	if (constants_created == false) {
	49	loadConstantsBlob(&mod_consts[0], UNTRANSLATE("__main__"));		49	loadConstantsBlob(&mod_consts[0], UNTRANSLATE("__main__"));
	50	constants_created = true;		50	constants_created = true;
	51			51
	52	#ifndef __NUITKA_NO_ASSERT__		52	#ifndef __NUITKA_NO_ASSERT__
n	53	for(int i = 0; i < 19; i++) {	n	53	for(int i = 0; i < 17; i++) {
	54	mod_consts_hash[i] = DEEP_HASH(mod_consts[i]);		54	mod_consts_hash[i] = DEEP_HASH(mod_consts[i]);
	55	}		55	}
	56	#endif		56	#endif
	57	}		57	}
	58	}		58	}
	68	#ifndef __NUITKA_NO_ASSERT__		68	#ifndef __NUITKA_NO_ASSERT__
	69	void checkModuleConstants___main__(void) {		69	void checkModuleConstants___main__(void) {
	70	// The module may not have been used at all, then ignore this.		70	// The module may not have been used at all, then ignore this.
	71	if (constants_created == false) return;		71	if (constants_created == false) return;
	72			72
n	73	for(int i = 0; i < 19; i++) {	n	73	for(int i = 0; i < 17; i++) {
	74	assert(mod_consts_hash[i] == DEEP_HASH(mod_consts[i]));		74	assert(mod_consts_hash[i] == DEEP_HASH(mod_consts[i]));
	75	CHECK_OBJECT_DEEP(mod_consts[i]);		75	CHECK_OBJECT_DEEP(mod_consts[i]);
	76	}		76	}
	77	}		77	}
	78	#endif		78	#endif
	79			79
	80	// The module code objects.		80	// The module code objects.
	81	static PyCodeObject *codeobj_ad669c260ec1bd3224f375392220b133;		81	static PyCodeObject *codeobj_ad669c260ec1bd3224f375392220b133;
	82	static PyCodeObject *codeobj_a469c63f076448ddc772a9521dfaa2cd;		82	static PyCodeObject *codeobj_a469c63f076448ddc772a9521dfaa2cd;
n	83	static PyCodeObject *codeobj_92f5fea8d8bfb0297617f6456fd04960;	n
	84	/* For use in "MainProgram.c". */		83	/* For use in "MainProgram.c". */
	85	PyCodeObject *codeobj_main = NULL;		84	PyCodeObject *codeobj_main = NULL;
	86			85
	87	static void createModuleCodeObjects(void) {		86	static void createModuleCodeObjects(void) {
n	88	module_filename_obj = mod_consts[4]; CHECK_OBJECT(module_filename_obj);	n	87	module_filename_obj = mod_consts[1]; CHECK_OBJECT(module_filename_obj);
	89	codeobj_ad669c260ec1bd3224f375392220b133 = MAKE_CODEOBJECT(module_filename_obj, 1, CO_NOFREE, mod_consts[17], NULL, NULL, 0, 0, 0);		88	codeobj_ad669c260ec1bd3224f375392220b133 = MAKE_CODEOBJECT(module_filename_obj, 1, CO_NOFREE, mod_consts[15], NULL, NULL, 0, 0, 0);
	90	codeobj_a469c63f076448ddc772a9521dfaa2cd = MAKE_CODEOBJECT(module_filename_obj, 23, CO_OPTIMIZED \| CO_NEWLOCALS \| CO_NOFREE, mod_consts[9], mod_consts[18], NULL, 0, 0, 0);		89	codeobj_a469c63f076448ddc772a9521dfaa2cd = MAKE_CODEOBJECT(module_filename_obj, 23, CO_OPTIMIZED \| CO_NEWLOCALS \| CO_NOFREE, mod_consts[7], mod_consts[16], NULL, 0, 0, 0);
	91	codeobj_92f5fea8d8bfb0297617f6456fd04960 = MAKE_CODEOBJECT(module_filename_obj, 26, CO_GENERATOR \| CO_OPTIMIZED \| CO_NEWLOCALS \| CO_NOFREE, mod_consts[0], NULL, NULL, 0, 0, 0);
	92	}		90	}
	93			91
	94	// The module function declarations.		92	// The module function declarations.
n	95	static PyObject *MAKE_GENERATOR___main__$$$function__1_calledRepeatedly$$$function__1_empty$$$genobj__1_empty();	n
	96
	97
	98	static PyObject *MAKE_FUNCTION___main__$$$function__1_calledRepeatedly();		93	static PyObject *MAKE_FUNCTION___main__$$$function__1_calledRepeatedly();
	99			94
	100			95
n	101	static PyObject *MAKE_FUNCTION___main__$$$function__1_calledRepeatedly$$$function__1_empty();	n
	102
	103
	104	// The module function definitions.		96	// The module function definitions.
n	105	static PyObject impl___main__$$$function__1_calledRepeatedly(struct Nuitka_FunctionObject const self, PyObject **python_pars) {	n
	106	// Preserve error status for checks
	107	#ifndef __NUITKA_NO_ASSERT__
	108	NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED();
	109	#endif
	110
	111	// Local variable declarations.
	112	PyObject *var_empty = NULL;
	113	PyObject *tmp_return_value = NULL;
	114
	115	// Actual function body.
	116	{
	117	PyObject *tmp_assign_source_1;
	118
	119
	120	tmp_assign_source_1 = MAKE_FUNCTION___main__$$$function__1_calledRepeatedly$$$function__1_empty();
	121
	122	assert(var_empty == NULL);
	123	var_empty = tmp_assign_source_1;
	124	}
	125	// Tried code:
	126	CHECK_OBJECT(var_empty);
	127	tmp_return_value = var_empty;
	128	Py_INCREF(tmp_return_value);
	129	goto try_return_handler_1;
	130	NUITKA_CANNOT_GET_HERE("tried codes exits in all cases");
	131	return NULL;
	132	// Return handler code:
	133	try_return_handler_1:;
	134	CHECK_OBJECT(var_empty);
	135	Py_DECREF(var_empty);
	136	var_empty = NULL;
	137	goto function_return_exit;
	138	// End of try:
	139
	140	NUITKA_CANNOT_GET_HERE("Return statement must have exited already.");
	141	return NULL;
	142
	143
	144	function_return_exit:
	145	// Function cleanup code if any.
	146
	147
	148	// Actual function exit with return value, making sure we did not make
	149	// the error status worse despite non-NULL return.
	150	CHECK_OBJECT(tmp_return_value);
	151	assert(had_error \|\| !ERROR_OCCURRED());
	152	return tmp_return_value;
	153	}
	154
	155
	156	static PyObject impl___main__$$$function__1_calledRepeatedly$$$function__1_empty(struct Nuitka_FunctionObject const self, PyObject **python_pars) {
	157	// Preserve error status for checks
	158	#ifndef __NUITKA_NO_ASSERT__
	159	NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED();
	160	#endif
	161
	162	// Local variable declarations.
	163	PyObject *tmp_return_value = NULL;
	164
	165	// Actual function body.
	166
	167
	168	tmp_return_value = MAKE_GENERATOR___main__$$$function__1_calledRepeatedly$$$function__1_empty$$$genobj__1_empty();
	169
	170	goto function_return_exit;
	171
	172	NUITKA_CANNOT_GET_HERE("Return statement must have exited already.");
	173	return NULL;
	174
	175
	176	function_return_exit:
	177	// Function cleanup code if any.
	178
	179
	180	// Actual function exit with return value, making sure we did not make
	181	// the error status worse despite non-NULL return.
	182	CHECK_OBJECT(tmp_return_value);
	183	assert(had_error \|\| !ERROR_OCCURRED());
	184	return tmp_return_value;
	185	}
	186
	187
	188
	189	struct __main__$$$function__1_calledRepeatedly$$$function__1_empty$$$genobj__1_empty_locals {
	190	char const *type_description_1;
	191	PyObject *exception_type;
	192	PyObject *exception_value;
	193	PyTracebackObject *exception_tb;
	194	int exception_lineno;
	195	};
	196
	197	static PyObject __main__$$$function__1_calledRepeatedly$$$function__1_empty$$$genobj__1_empty_context(struct Nuitka_GeneratorObject generator, PyObject *yield_return_value) {
	198	CHECK_OBJECT(generator);
	199	assert(Nuitka_Generator_Check((PyObject *)generator));
	200	CHECK_OBJECT_X(yield_return_value);
	201
	202	// Heap access if used.
	203	struct __main__$$$function__1_calledRepeatedly$$$function__1_empty$$$genobj__1_empty_locals generator_heap = (struct __main__$$$function__1_calledRepeatedly$$$function__1_empty$$$genobj__1_empty_locals )generator->m_heap_storage;
	204
	205	// Dispatch to yield based on return label index:
	206	switch(generator->m_yield_return_index) {
	207	case 1: goto yield_return_1;
	208	}
	209
	210	// Local variable initialization
	211	NUITKA_MAY_BE_UNUSED nuitka_void tmp_unused;
	212	static struct Nuitka_FrameObject *cache_m_frame = NULL;
	213	generator_heap->type_description_1 = NULL;
	214	generator_heap->exception_type = NULL;
	215	generator_heap->exception_value = NULL;
	216	generator_heap->exception_tb = NULL;
	217	generator_heap->exception_lineno = 0;
	218
	219	// Actual generator function body.
	220	if (isFrameUnusable(cache_m_frame)) {
	221	Py_XDECREF(cache_m_frame);
	222
	223	#if _DEBUG_REFCOUNTS
	224	if (cache_m_frame == NULL) {
	225	count_active_frame_cache_instances += 1;
	226	} else {
	227	count_released_frame_cache_instances += 1;
	228	}
	229	count_allocated_frame_cache_instances += 1;
	230	#endif
	231	cache_m_frame = MAKE_FUNCTION_FRAME(codeobj_92f5fea8d8bfb0297617f6456fd04960, module___main__, 0);
	232	#if _DEBUG_REFCOUNTS
	233	} else {
	234	count_hit_frame_cache_instances += 1;
	235	#endif
	236	}
	237	generator->m_frame = cache_m_frame;
	238
	239	// Mark the frame object as in use, ref count 1 will be up for reuse.
	240	Py_INCREF(generator->m_frame);
	241	assert(Py_REFCNT(generator->m_frame) == 2); // Frame stack
	242
	243	#if PYTHON_VERSION >= 0x340
	244	generator->m_frame->m_frame.f_gen = (PyObject *)generator;
	245	#endif
	246
	247	assert(generator->m_frame->m_frame.f_back == NULL);
	248	Py_CLEAR(generator->m_frame->m_frame.f_back);
	249
	250	generator->m_frame->m_frame.f_back = PyThreadState_GET()->frame;
	251	Py_INCREF(generator->m_frame->m_frame.f_back);
	252
	253	PyThreadState_GET()->frame = &generator->m_frame->m_frame;
	254	Py_INCREF(generator->m_frame);
	255
	256	Nuitka_Frame_MarkAsExecuting(generator->m_frame);
	257
	258	#if PYTHON_VERSION >= 0x300
	259	// Accept currently existing exception as the one to publish again when we
	260	// yield or yield from.
	261	{
	262	PyThreadState *thread_state = PyThreadState_GET();
	263
	264	EXC_TYPE_F(generator) = EXC_TYPE(thread_state);
	265	if (EXC_TYPE_F(generator) == Py_None) EXC_TYPE_F(generator) = NULL;
	266	Py_XINCREF(EXC_TYPE_F(generator));
	267	EXC_VALUE_F(generator) = EXC_VALUE(thread_state);
	268	Py_XINCREF(EXC_VALUE_F(generator));
	269	EXC_TRACEBACK_F(generator) = EXC_TRACEBACK(thread_state);
	270	Py_XINCREF(EXC_TRACEBACK_F(generator));
	271	}
	272
	273	#endif
	274
	275	// Framed code:
	276	{
	277	PyObject *tmp_expression_name_1;
	278	NUITKA_MAY_BE_UNUSED PyObject *tmp_yield_result_1;
	279	tmp_expression_name_1 = mod_consts[2];
	280	Py_INCREF(tmp_expression_name_1);
	281	generator->m_yield_return_index = 1;
	282	return tmp_expression_name_1;
	283	yield_return_1:
	284	if (yield_return_value == NULL) {
	285	assert(ERROR_OCCURRED());
	286
	287	FETCH_ERROR_OCCURRED(&generator_heap->exception_type, &generator_heap->exception_value, &generator_heap->exception_tb);
	288
	289
	290	generator_heap->exception_lineno = 27;
	291
	292	goto frame_exception_exit_1;
	293	}
	294	tmp_yield_result_1 = yield_return_value;
	295	}
	296
	297	Nuitka_Frame_MarkAsNotExecuting(generator->m_frame);
	298
	299	#if PYTHON_VERSION >= 0x300
	300	Py_CLEAR(EXC_TYPE_F(generator));
	301	Py_CLEAR(EXC_VALUE_F(generator));
	302	Py_CLEAR(EXC_TRACEBACK_F(generator));
	303	#endif
	304
	305	// Allow re-use of the frame again.
	306	Py_DECREF(generator->m_frame);
	307	goto frame_no_exception_1;
	308
	309	frame_exception_exit_1:;
	310
	311	// If it's not an exit exception, consider and create a traceback for it.
	312	if (!EXCEPTION_MATCH_GENERATOR(generator_heap->exception_type)) {
	313	if (generator_heap->exception_tb == NULL) {
	314	generator_heap->exception_tb = MAKE_TRACEBACK(generator->m_frame, generator_heap->exception_lineno);
	315	} else if (generator_heap->exception_tb->tb_frame != &generator->m_frame->m_frame) {
	316	generator_heap->exception_tb = ADD_TRACEBACK(generator_heap->exception_tb, generator->m_frame, generator_heap->exception_lineno);
	317	}
	318
	319	Nuitka_Frame_AttachLocals(
	320	generator->m_frame,
	321	generator_heap->type_description_1
	322	);
	323
	324
	325	// Release cached frame if used for exception.
	326	if (generator->m_frame == cache_m_frame) {
	327	#if _DEBUG_REFCOUNTS
	328	count_active_frame_cache_instances -= 1;
	329	count_released_frame_cache_instances += 1;
	330	#endif
	331
	332	Py_DECREF(cache_m_frame);
	333	cache_m_frame = NULL;
	334	}
	335
	336	assertFrameObject(generator->m_frame);
	337	}
	338
	339	#if PYTHON_VERSION >= 0x300
	340	Py_CLEAR(EXC_TYPE_F(generator));
	341	Py_CLEAR(EXC_VALUE_F(generator));
	342	Py_CLEAR(EXC_TRACEBACK_F(generator));
	343	#endif
	344
	345	Py_DECREF(generator->m_frame);
	346
	347	// Return the error.
	348	goto function_exception_exit;
	349
	350	frame_no_exception_1:;
	351
	352
	353	return NULL;
	354
	355	function_exception_exit:
	356	assert(generator_heap->exception_type);
	357	RESTORE_ERROR_OCCURRED(generator_heap->exception_type, generator_heap->exception_value, generator_heap->exception_tb);
	358
	359	return NULL;
	360
	361	}
	362
	363	static PyObject *MAKE_GENERATOR___main__$$$function__1_calledRepeatedly$$$function__1_empty$$$genobj__1_empty() {
	364	return Nuitka_Generator_New(
	365	__main__$$$function__1_calledRepeatedly$$$function__1_empty$$$genobj__1_empty_context,
	366	module___main__,
	367	mod_consts[0],
	368	#if PYTHON_VERSION >= 0x350
	369	mod_consts[1],
	370	#endif
	371	codeobj_92f5fea8d8bfb0297617f6456fd04960,
	372	NULL,
	373	0,
	374	sizeof(struct __main__$$$function__1_calledRepeatedly$$$function__1_empty$$$genobj__1_empty_locals)
	375	);
	376	}
	377
	378
	379			97
	380	static PyObject *MAKE_FUNCTION___main__$$$function__1_calledRepeatedly() {		98	static PyObject *MAKE_FUNCTION___main__$$$function__1_calledRepeatedly() {
	381	struct Nuitka_FunctionObject *result = Nuitka_Function_New(		99	struct Nuitka_FunctionObject *result = Nuitka_Function_New(
n	382	impl___main__$$$function__1_calledRepeatedly,	n	100	NULL,
	383	mod_consts[9],		101	mod_consts[7],
	384	#if PYTHON_VERSION >= 0x300		102	#if PYTHON_VERSION >= 0x300
	385	NULL,		103	NULL,
	386	#endif		104	#endif
	387	codeobj_a469c63f076448ddc772a9521dfaa2cd,		105	codeobj_a469c63f076448ddc772a9521dfaa2cd,
	388	NULL,		106	NULL,
	393	module___main__,		111	module___main__,
	394	NULL,		112	NULL,
	395	NULL,		113	NULL,
	396	0		114	0
	397	);		115	);
n	398		n	116	Nuitka_Function_EnableConstReturnGeneric(result, mod_consts[6]);
	399
	400	return (PyObject *)result;
	401	}
	402
	403
	404
	405	static PyObject *MAKE_FUNCTION___main__$$$function__1_calledRepeatedly$$$function__1_empty() {
	406	struct Nuitka_FunctionObject *result = Nuitka_Function_New(
	407	impl___main__$$$function__1_calledRepeatedly$$$function__1_empty,
	408	mod_consts[0],
	409	#if PYTHON_VERSION >= 0x300
	410	mod_consts[1],
	411	#endif
	412	codeobj_92f5fea8d8bfb0297617f6456fd04960,
	413	NULL,
	414	#if PYTHON_VERSION >= 0x300
	415	NULL,
	416	NULL,
	417	#endif
	418	module___main__,
	419	NULL,
	420	NULL,
	421	0
	422	);
	423
	424			117
	425	return (PyObject *)result;		118	return (PyObject *)result;
	426	}		119	}
	427			120
	428			121
	438	// Provide a way to create find a function via its C code and create it back		131	// Provide a way to create find a function via its C code and create it back
	439	// in another process, useful for multiprocessing extensions like dill		132	// in another process, useful for multiprocessing extensions like dill
	440	extern void registerDillPluginTables(char const module_name, PyMethodDef reduce_compiled_function, PyMethodDef *create_compiled_function);		133	extern void registerDillPluginTables(char const module_name, PyMethodDef reduce_compiled_function, PyMethodDef *create_compiled_function);
	441			134
	442	function_impl_code functable___main__[] = {		135	function_impl_code functable___main__[] = {
n	443	impl___main__$$$function__1_calledRepeatedly$$$function__1_empty,	n	136	NULL,
	444	impl___main__$$$function__1_calledRepeatedly,
	445	NULL		137	NULL
	446	};		138	};
	447			139
	448	static char const *_reduce_compiled_function_argnames[] = {		140	static char const *_reduce_compiled_function_argnames[] = {
	449	"func",		141	"func",
	784			476
	785	// Module code.		477	// Module code.
	786	{		478	{
	787	PyObject *tmp_assign_source_1;		479	PyObject *tmp_assign_source_1;
	788	tmp_assign_source_1 = Py_None;		480	tmp_assign_source_1 = Py_None;
n	789	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[3], tmp_assign_source_1);	n	481	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[0], tmp_assign_source_1);
	790	}		482	}
	791	{		483	{
	792	PyObject *tmp_assign_source_2;		484	PyObject *tmp_assign_source_2;
n	793	tmp_assign_source_2 = mod_consts[4];	n	485	tmp_assign_source_2 = mod_consts[1];
	794	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[5], tmp_assign_source_2);		486	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[2], tmp_assign_source_2);
	795	}		487	}
	796	{		488	{
	797	PyObject *tmp_assign_source_3;		489	PyObject *tmp_assign_source_3;
	798	tmp_assign_source_3 = Py_None;		490	tmp_assign_source_3 = Py_None;
n	799	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[6], tmp_assign_source_3);	n	491	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[3], tmp_assign_source_3);
	800	}		492	}
	801	{		493	{
	802	PyObject *tmp_assign_source_4;		494	PyObject *tmp_assign_source_4;
	803	tmp_assign_source_4 = PyDict_New();		495	tmp_assign_source_4 = PyDict_New();
n	804	UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[7], tmp_assign_source_4);	n	496	UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[4], tmp_assign_source_4);
	805	}		497	}
	806	{		498	{
	807	PyObject *tmp_assign_source_5;		499	PyObject *tmp_assign_source_5;
	808	tmp_assign_source_5 = Py_None;		500	tmp_assign_source_5 = Py_None;
n	809	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[8], tmp_assign_source_5);	n	501	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[5], tmp_assign_source_5);
	810	}		502	}
	811	{		503	{
	812	PyObject *tmp_assign_source_6;		504	PyObject *tmp_assign_source_6;
	813			505
	814			506
	815	tmp_assign_source_6 = MAKE_FUNCTION___main__$$$function__1_calledRepeatedly();		507	tmp_assign_source_6 = MAKE_FUNCTION___main__$$$function__1_calledRepeatedly();
	816			508
n	817	UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[9], tmp_assign_source_6);	n	509	UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[7], tmp_assign_source_6);
	818	}		510	}
	819	{		511	{
	820	PyObject *tmp_assign_source_7;		512	PyObject *tmp_assign_source_7;
	821	PyObject *tmp_name_name_1;		513	PyObject *tmp_name_name_1;
	822	PyObject *tmp_globals_arg_name_1;		514	PyObject *tmp_globals_arg_name_1;
	823	PyObject *tmp_locals_arg_name_1;		515	PyObject *tmp_locals_arg_name_1;
	824	PyObject *tmp_fromlist_name_1;		516	PyObject *tmp_fromlist_name_1;
	825	PyObject *tmp_level_name_1;		517	PyObject *tmp_level_name_1;
n	826	tmp_name_name_1 = mod_consts[10];	n	518	tmp_name_name_1 = mod_consts[8];
	827	tmp_globals_arg_name_1 = (PyObject *)moduledict___main__;		519	tmp_globals_arg_name_1 = (PyObject *)moduledict___main__;
	828	tmp_locals_arg_name_1 = Py_None;		520	tmp_locals_arg_name_1 = Py_None;
	829	tmp_fromlist_name_1 = Py_None;		521	tmp_fromlist_name_1 = Py_None;
n	830	tmp_level_name_1 = mod_consts[11];	n	522	tmp_level_name_1 = mod_consts[9];
	831	tmp_assign_source_7 = IMPORT_MODULE5(tmp_name_name_1, tmp_globals_arg_name_1, tmp_locals_arg_name_1, tmp_fromlist_name_1, tmp_level_name_1);		523	tmp_assign_source_7 = IMPORT_MODULE5(tmp_name_name_1, tmp_globals_arg_name_1, tmp_locals_arg_name_1, tmp_fromlist_name_1, tmp_level_name_1);
	832	assert(!(tmp_assign_source_7 == NULL));		524	assert(!(tmp_assign_source_7 == NULL));
n	833	UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[10], tmp_assign_source_7);	n	525	UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[8], tmp_assign_source_7);
	834	}		526	}
	835	// Frame without reuse.		527	// Frame without reuse.
	836	frame_ad669c260ec1bd3224f375392220b133 = MAKE_MODULE_FRAME(codeobj_ad669c260ec1bd3224f375392220b133, module___main__);		528	frame_ad669c260ec1bd3224f375392220b133 = MAKE_MODULE_FRAME(codeobj_ad669c260ec1bd3224f375392220b133, module___main__);
	837			529
	838	// Push the new frame as the currently active one, and we should be exclusively		530	// Push the new frame as the currently active one, and we should be exclusively
	843	// Framed code:		535	// Framed code:
	844	{		536	{
	845	PyObject *tmp_assign_source_8;		537	PyObject *tmp_assign_source_8;
	846	PyObject *tmp_iter_arg_1;		538	PyObject *tmp_iter_arg_1;
	847	PyObject *tmp_called_instance_1;		539	PyObject *tmp_called_instance_1;
n	848	tmp_called_instance_1 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[10]);	n	540	tmp_called_instance_1 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[8]);
	849			541
	850	if (unlikely(tmp_called_instance_1 == NULL)) {		542	if (unlikely(tmp_called_instance_1 == NULL)) {
n	851	tmp_called_instance_1 = GET_MODULE_VARIABLE_VALUE_FALLBACK(mod_consts[10]);	n	543	tmp_called_instance_1 = GET_MODULE_VARIABLE_VALUE_FALLBACK(mod_consts[8]);
	852	}		544	}
	853			545
	854	assert(!(tmp_called_instance_1 == NULL));		546	assert(!(tmp_called_instance_1 == NULL));
	855	frame_ad669c260ec1bd3224f375392220b133->m_frame.f_lineno = 36;		547	frame_ad669c260ec1bd3224f375392220b133->m_frame.f_lineno = 36;
	856	tmp_iter_arg_1 = CALL_METHOD_WITH_ARGS2(		548	tmp_iter_arg_1 = CALL_METHOD_WITH_ARGS2(
	857	tmp_called_instance_1,		549	tmp_called_instance_1,
n	858	mod_consts[12],	n	550	mod_consts[10],
	859	&PyTuple_GET_ITEM(mod_consts[13], 0)		551	&PyTuple_GET_ITEM(mod_consts[11], 0)
	860	);		552	);
	861			553
	862	if (tmp_iter_arg_1 == NULL) {		554	if (tmp_iter_arg_1 == NULL) {
	863	assert(ERROR_OCCURRED());		555	assert(ERROR_OCCURRED());
	864			556
	914	}		606	}
	915	{		607	{
	916	PyObject *tmp_assign_source_10;		608	PyObject *tmp_assign_source_10;
	917	CHECK_OBJECT(tmp_for_loop_1__iter_value);		609	CHECK_OBJECT(tmp_for_loop_1__iter_value);
	918	tmp_assign_source_10 = tmp_for_loop_1__iter_value;		610	tmp_assign_source_10 = tmp_for_loop_1__iter_value;
n	919	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[14], tmp_assign_source_10);	n	611	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[12], tmp_assign_source_10);
	920	}		612	}
	921	{		613	{
	922	PyObject *tmp_called_name_1;		614	PyObject *tmp_called_name_1;
	923	PyObject *tmp_call_result_1;		615	PyObject *tmp_call_result_1;
n	924	tmp_called_name_1 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[9]);	n	616	tmp_called_name_1 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[7]);
	925			617
	926	if (unlikely(tmp_called_name_1 == NULL)) {		618	if (unlikely(tmp_called_name_1 == NULL)) {
n	927	tmp_called_name_1 = GET_MODULE_VARIABLE_VALUE_FALLBACK(mod_consts[9]);	n	619	tmp_called_name_1 = GET_MODULE_VARIABLE_VALUE_FALLBACK(mod_consts[7]);
	928	}		620	}
	929			621
	930	if (tmp_called_name_1 == NULL) {		622	if (tmp_called_name_1 == NULL) {
	931	assert(ERROR_OCCURRED());		623	assert(ERROR_OCCURRED());
	932			624
	995	Py_DECREF(tmp_for_loop_1__for_iterator);		687	Py_DECREF(tmp_for_loop_1__for_iterator);
	996	tmp_for_loop_1__for_iterator = NULL;		688	tmp_for_loop_1__for_iterator = NULL;
	997	{		689	{
	998	PyObject *tmp_called_name_2;		690	PyObject *tmp_called_name_2;
	999	PyObject *tmp_call_result_2;		691	PyObject *tmp_call_result_2;
n	1000	tmp_called_name_2 = LOOKUP_BUILTIN(mod_consts[15]);	n	692	tmp_called_name_2 = LOOKUP_BUILTIN(mod_consts[13]);
	1001	assert(tmp_called_name_2 != NULL);		693	assert(tmp_called_name_2 != NULL);
	1002	frame_ad669c260ec1bd3224f375392220b133->m_frame.f_lineno = 39;		694	frame_ad669c260ec1bd3224f375392220b133->m_frame.f_lineno = 39;
t	1003	tmp_call_result_2 = CALL_FUNCTION_WITH_POSARGS1(tmp_called_name_2, mod_consts[16]);	t	695	tmp_call_result_2 = CALL_FUNCTION_WITH_POSARGS1(tmp_called_name_2, mod_consts[14]);
	1004			696
	1005	if (tmp_call_result_2 == NULL) {		697	if (tmp_call_result_2 == NULL) {
	1006	assert(ERROR_OCCURRED());		698	assert(ERROR_OCCURRED());
	1007			699
	1008	FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);		700	FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);