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			37
	38	static PyObject *module_filename_obj = NULL;		38	static PyObject *module_filename_obj = NULL;
	39			39
	40	/* Indicator if this modules private constants were created yet. */		40	/* Indicator if this modules private constants were created yet. */
	41	static bool constants_created = false;		41	static bool constants_created = false;
	42			42
	43	/* Function to create module private constants. */		43	/* Function to create module private constants. */
	44	static void createModuleConstants(void) {		44	static void createModuleConstants(void) {
n	45	loadConstantsBlob(&mod_consts[0], "__main__", 19);	n	45	loadConstantsBlob(&mod_consts[0], "__main__", 17);
	46			46
	47	constants_created = true;		47	constants_created = true;
	48	}		48	}
	49			49
	50	/* Function to verify module private constants for non-corruption. */		50	/* Function to verify module private constants for non-corruption. */
	51	#ifndef __NUITKA_NO_ASSERT__		51	#ifndef __NUITKA_NO_ASSERT__
	52	void checkModuleConstants___main__(void) {		52	void checkModuleConstants___main__(void) {
	53	// The module may not have been used at all, then ignore this.		53	// The module may not have been used at all, then ignore this.
	54	if (constants_created == false) return;		54	if (constants_created == false) return;
	55			55
n	56	checkConstantsBlob(&mod_consts[0], "__main__", 19);	n	56	checkConstantsBlob(&mod_consts[0], "__main__", 17);
	57	}		57	}
	58	#endif		58	#endif
	59			59
	60	// The module code objects.		60	// The module code objects.
	61	static PyCodeObject *codeobj_36d5271f971d22837d70bd77c2293acb;		61	static PyCodeObject *codeobj_36d5271f971d22837d70bd77c2293acb;
	62	static PyCodeObject *codeobj_bc7372d11aab4ed76b24e2b19bb865a3;		62	static PyCodeObject *codeobj_bc7372d11aab4ed76b24e2b19bb865a3;
n	63	static PyCodeObject *codeobj_5530992967f51ed7dda1dfa2bfc85f69;	n
	64	/* For use in "MainProgram.c". */		63	/* For use in "MainProgram.c". */
	65	PyCodeObject *codeobj_main = NULL;		64	PyCodeObject *codeobj_main = NULL;
	66			65
	67	static void createModuleCodeObjects(void) {		66	static void createModuleCodeObjects(void) {
n	68	module_filename_obj = mod_consts[4]; CHECK_OBJECT(module_filename_obj);	n	67	module_filename_obj = mod_consts[2]; CHECK_OBJECT(module_filename_obj);
	69	codeobj_36d5271f971d22837d70bd77c2293acb = MAKE_CODEOBJECT(module_filename_obj, 1, CO_NOFREE, mod_consts[16], mod_consts[17], 0, 0, 0);		68	codeobj_36d5271f971d22837d70bd77c2293acb = MAKE_CODEOBJECT(module_filename_obj, 1, CO_NOFREE, mod_consts[14], mod_consts[15], 0, 0, 0);
	70	codeobj_bc7372d11aab4ed76b24e2b19bb865a3 = MAKE_CODEOBJECT(module_filename_obj, 23, CO_OPTIMIZED \| CO_NEWLOCALS \| CO_NOFREE, mod_consts[8], mod_consts[18], 0, 0, 0);		69	codeobj_bc7372d11aab4ed76b24e2b19bb865a3 = MAKE_CODEOBJECT(module_filename_obj, 23, CO_OPTIMIZED \| CO_NEWLOCALS \| CO_NOFREE, mod_consts[6], mod_consts[16], 0, 0, 0);
	71	codeobj_5530992967f51ed7dda1dfa2bfc85f69 = MAKE_CODEOBJECT(module_filename_obj, 26, CO_GENERATOR \| CO_OPTIMIZED \| CO_NEWLOCALS \| CO_NOFREE, mod_consts[0], mod_consts[17], 0, 0, 0);
	72	}		70	}
	73			71
	74	// The module function declarations.		72	// The module function declarations.
n	75	static PyObject *MAKE_GENERATOR___main__$$$function_1_calledRepeatedly$$$function_1_empty$$$genobj_1_empty();	n
	76
	77
	78	static PyObject *MAKE_FUNCTION___main__$$$function_1_calledRepeatedly();		73	static PyObject *MAKE_FUNCTION___main__$$$function_1_calledRepeatedly();
n	79		n
	80
	81	static PyObject *MAKE_FUNCTION___main__$$$function_1_calledRepeatedly$$$function_1_empty();
	82			74
	83			75
	84	// The module function definitions.		76	// The module function definitions.
	85	static PyObject impl___main__$$$function_1_calledRepeatedly(struct Nuitka_FunctionObject const self, PyObject **python_pars) {		77	static PyObject impl___main__$$$function_1_calledRepeatedly(struct Nuitka_FunctionObject const self, PyObject **python_pars) {
	86	// Preserve error status for checks		78	// Preserve error status for checks
	87	#ifndef __NUITKA_NO_ASSERT__		79	#ifndef __NUITKA_NO_ASSERT__
	88	NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED();		80	NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED();
	89	#endif		81	#endif
	90			82
	91	// Local variable declarations.		83	// Local variable declarations.
n	92	PyObject *var_empty = NULL;	n
	93	PyObject *tmp_return_value = NULL;		84	PyObject *tmp_return_value = NULL;
	94			85
	95	// Actual function body.		86	// Actual function body.
n	96	{	n	87	tmp_return_value = mod_consts[0];
	97	PyObject *tmp_assign_source_1;
	98
	99
	100	tmp_assign_source_1 = MAKE_FUNCTION___main__$$$function_1_calledRepeatedly$$$function_1_empty();
	101
	102	assert(var_empty == NULL);
	103	var_empty = tmp_assign_source_1;
	104	}
	105	// Tried code:
	106	CHECK_OBJECT(var_empty);
	107	tmp_return_value = var_empty;
	108	Py_INCREF(tmp_return_value);		88	Py_INCREF(tmp_return_value);
n	109	goto try_return_handler_1;	n
	110	NUITKA_CANNOT_GET_HERE("tried codes exits in all cases");
	111	return NULL;
	112	// Return handler code:
	113	try_return_handler_1:;
	114	CHECK_OBJECT(var_empty);
	115	Py_DECREF(var_empty);
	116	var_empty = NULL;
	117
	118	goto function_return_exit;		89	goto function_return_exit;
n	119	// End of try:	n
	120			90
	121	NUITKA_CANNOT_GET_HERE("Return statement must have exited already.");		91	NUITKA_CANNOT_GET_HERE("Return statement must have exited already.");
	122	return NULL;		92	return NULL;
	123			93
	124			94
	132	assert(had_error \|\| !ERROR_OCCURRED());		102	assert(had_error \|\| !ERROR_OCCURRED());
	133	return tmp_return_value;		103	return tmp_return_value;
	134	}		104	}
	135			105
	136			106
n	137	static PyObject impl___main__$$$function_1_calledRepeatedly$$$function_1_empty(struct Nuitka_FunctionObject const self, PyObject **python_pars) {	n
	138	// Preserve error status for checks
	139	#ifndef __NUITKA_NO_ASSERT__
	140	NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED();
	141	#endif
	142
	143	// Local variable declarations.
	144	PyObject *tmp_return_value = NULL;
	145
	146	// Actual function body.
	147
	148
	149	tmp_return_value = MAKE_GENERATOR___main__$$$function_1_calledRepeatedly$$$function_1_empty$$$genobj_1_empty();
	150
	151	goto function_return_exit;
	152
	153	NUITKA_CANNOT_GET_HERE("Return statement must have exited already.");
	154	return NULL;
	155
	156
	157	function_return_exit:
	158	// Function cleanup code if any.
	159
	160
	161	// Actual function exit with return value, making sure we did not make
	162	// the error status worse despite non-NULL return.
	163	CHECK_OBJECT(tmp_return_value);
	164	assert(had_error \|\| !ERROR_OCCURRED());
	165	return tmp_return_value;
	166	}
	167
	168
	169
	170	struct __main__$$$function_1_calledRepeatedly$$$function_1_empty$$$genobj_1_empty_locals {
	171	char const *type_description_1;
	172	PyObject *exception_type;
	173	PyObject *exception_value;
	174	PyTracebackObject *exception_tb;
	175	int exception_lineno;
	176	};
	177
	178	static PyObject __main__$$$function_1_calledRepeatedly$$$function_1_empty$$$genobj_1_empty_context(struct Nuitka_GeneratorObject generator, PyObject *yield_return_value) {
	179	CHECK_OBJECT(generator);
	180	assert(Nuitka_Generator_Check((PyObject *)generator));
	181	CHECK_OBJECT_X(yield_return_value);
	182
	183	// Heap access if used.
	184	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;
	185
	186	// Dispatch to yield based on return label index:
	187	switch(generator->m_yield_return_index) {
	188	case 1: goto yield_return_1;
	189	}
	190
	191	// Local variable initialization
	192	NUITKA_MAY_BE_UNUSED nuitka_void tmp_unused;
	193	static struct Nuitka_FrameObject *cache_m_frame = NULL;
	194	generator_heap->type_description_1 = NULL;
	195	generator_heap->exception_type = NULL;
	196	generator_heap->exception_value = NULL;
	197	generator_heap->exception_tb = NULL;
	198	generator_heap->exception_lineno = 0;
	199
	200	// Actual generator function body.
	201	if (isFrameUnusable(cache_m_frame)) {
	202	Py_XDECREF(cache_m_frame);
	203
	204	#if _DEBUG_REFCOUNTS
	205	if (cache_m_frame == NULL) {
	206	count_active_frame_cache_instances += 1;
	207	} else {
	208	count_released_frame_cache_instances += 1;
	209	}
	210	count_allocated_frame_cache_instances += 1;
	211	#endif
	212	cache_m_frame = MAKE_FUNCTION_FRAME(codeobj_5530992967f51ed7dda1dfa2bfc85f69, module___main__, 0);
	213	#if _DEBUG_REFCOUNTS
	214	} else {
	215	count_hit_frame_cache_instances += 1;
	216	#endif
	217	}
	218	generator->m_frame = cache_m_frame;
	219
	220	// Mark the frame object as in use, ref count 1 will be up for reuse.
	221	Py_INCREF(generator->m_frame);
	222	assert(Py_REFCNT(generator->m_frame) == 2); // Frame stack
	223
	224	#if PYTHON_VERSION >= 340
	225	generator->m_frame->m_frame.f_gen = (PyObject *)generator;
	226	#endif
	227
	228	assert(generator->m_frame->m_frame.f_back == NULL);
	229	Py_CLEAR(generator->m_frame->m_frame.f_back);
	230
	231	generator->m_frame->m_frame.f_back = PyThreadState_GET()->frame;
	232	Py_INCREF(generator->m_frame->m_frame.f_back);
	233
	234	PyThreadState_GET()->frame = &generator->m_frame->m_frame;
	235	Py_INCREF(generator->m_frame);
	236
	237	Nuitka_Frame_MarkAsExecuting(generator->m_frame);
	238
	239	#if PYTHON_VERSION >= 300
	240	// Accept currently existing exception as the one to publish again when we
	241	// yield or yield from.
	242	{
	243	PyThreadState *thread_state = PyThreadState_GET();
	244
	245	EXC_TYPE_F(generator) = EXC_TYPE(thread_state);
	246	if (EXC_TYPE_F(generator) == Py_None) EXC_TYPE_F(generator) = NULL;
	247	Py_XINCREF(EXC_TYPE_F(generator));
	248	EXC_VALUE_F(generator) = EXC_VALUE(thread_state);
	249	Py_XINCREF(EXC_VALUE_F(generator));
	250	EXC_TRACEBACK_F(generator) = EXC_TRACEBACK(thread_state);
	251	Py_XINCREF(EXC_TRACEBACK_F(generator));
	252	}
	253
	254	#endif
	255
	256	// Framed code:
	257	{
	258	PyObject *tmp_expression_name_1;
	259	NUITKA_MAY_BE_UNUSED PyObject *tmp_yield_result_1;
	260	tmp_expression_name_1 = mod_consts[2];
	261	Py_INCREF(tmp_expression_name_1);
	262	generator->m_yield_return_index = 1;
	263	return tmp_expression_name_1;
	264	yield_return_1:
	265	if (yield_return_value == NULL) {
	266	assert(ERROR_OCCURRED());
	267
	268	FETCH_ERROR_OCCURRED(&generator_heap->exception_type, &generator_heap->exception_value, &generator_heap->exception_tb);
	269
	270
	271	generator_heap->exception_lineno = 27;
	272
	273	goto frame_exception_exit_1;
	274	}
	275	tmp_yield_result_1 = yield_return_value;
	276	}
	277
	278	Nuitka_Frame_MarkAsNotExecuting(generator->m_frame);
	279
	280	#if PYTHON_VERSION >= 300
	281	Py_CLEAR(EXC_TYPE_F(generator));
	282	Py_CLEAR(EXC_VALUE_F(generator));
	283	Py_CLEAR(EXC_TRACEBACK_F(generator));
	284	#endif
	285
	286	// Allow re-use of the frame again.
	287	Py_DECREF(generator->m_frame);
	288	goto frame_no_exception_1;
	289
	290	frame_exception_exit_1:;
	291
	292	// If it's not an exit exception, consider and create a traceback for it.
	293	if (!EXCEPTION_MATCH_GENERATOR(generator_heap->exception_type)) {
	294	if (generator_heap->exception_tb == NULL) {
	295	generator_heap->exception_tb = MAKE_TRACEBACK(generator->m_frame, generator_heap->exception_lineno);
	296	} else if (generator_heap->exception_tb->tb_frame != &generator->m_frame->m_frame) {
	297	generator_heap->exception_tb = ADD_TRACEBACK(generator_heap->exception_tb, generator->m_frame, generator_heap->exception_lineno);
	298	}
	299
	300	Nuitka_Frame_AttachLocals(
	301	generator->m_frame,
	302	generator_heap->type_description_1
	303	);
	304
	305
	306	// Release cached frame.
	307	if (generator->m_frame == cache_m_frame) {
	308	#if _DEBUG_REFCOUNTS
	309	count_active_frame_cache_instances -= 1;
	310	count_released_frame_cache_instances += 1;
	311	#endif
	312
	313	Py_DECREF(generator->m_frame);
	314	}
	315	cache_m_frame = NULL;
	316
	317	assertFrameObject(generator->m_frame);
	318	}
	319
	320	#if PYTHON_VERSION >= 300
	321	Py_CLEAR(EXC_TYPE_F(generator));
	322	Py_CLEAR(EXC_VALUE_F(generator));
	323	Py_CLEAR(EXC_TRACEBACK_F(generator));
	324	#endif
	325
	326	Py_DECREF(generator->m_frame);
	327
	328	// Return the error.
	329	goto function_exception_exit;
	330
	331	frame_no_exception_1:;
	332
	333
	334	return NULL;
	335
	336	function_exception_exit:
	337	assert(generator_heap->exception_type);
	338	RESTORE_ERROR_OCCURRED(generator_heap->exception_type, generator_heap->exception_value, generator_heap->exception_tb);
	339
	340	return NULL;
	341
	342	}
	343
	344	static PyObject *MAKE_GENERATOR___main__$$$function_1_calledRepeatedly$$$function_1_empty$$$genobj_1_empty() {
	345	return Nuitka_Generator_New(
	346	__main__$$$function_1_calledRepeatedly$$$function_1_empty$$$genobj_1_empty_context,
	347	module___main__,
	348	mod_consts[0],
	349	#if PYTHON_VERSION >= 350
	350	mod_consts[1],
	351	#endif
	352	codeobj_5530992967f51ed7dda1dfa2bfc85f69,
	353	NULL,
	354	0,
	355	sizeof(struct __main__$$$function_1_calledRepeatedly$$$function_1_empty$$$genobj_1_empty_locals)
	356	);
	357	}
	358
	359
	360			107
	361	static PyObject *MAKE_FUNCTION___main__$$$function_1_calledRepeatedly() {		108	static PyObject *MAKE_FUNCTION___main__$$$function_1_calledRepeatedly() {
	362	struct Nuitka_FunctionObject *result = Nuitka_Function_New(		109	struct Nuitka_FunctionObject *result = Nuitka_Function_New(
	363	impl___main__$$$function_1_calledRepeatedly,		110	impl___main__$$$function_1_calledRepeatedly,
n	364	mod_consts[8],	n	111	mod_consts[6],
	365	#if PYTHON_VERSION >= 300		112	#if PYTHON_VERSION >= 300
	366	NULL,		113	NULL,
	367	#endif		114	#endif
	368	codeobj_bc7372d11aab4ed76b24e2b19bb865a3,		115	codeobj_bc7372d11aab4ed76b24e2b19bb865a3,
	369	NULL,		116	NULL,
	379			126
	380	return (PyObject *)result;		127	return (PyObject *)result;
	381	}		128	}
	382			129
	383			130
n	384		n
	385	static PyObject *MAKE_FUNCTION___main__$$$function_1_calledRepeatedly$$$function_1_empty() {
	386	struct Nuitka_FunctionObject *result = Nuitka_Function_New(
	387	impl___main__$$$function_1_calledRepeatedly$$$function_1_empty,
	388	mod_consts[0],
	389	#if PYTHON_VERSION >= 300
	390	mod_consts[1],
	391	#endif
	392	codeobj_5530992967f51ed7dda1dfa2bfc85f69,
	393	NULL,
	394	#if PYTHON_VERSION >= 300
	395	NULL,
	396	NULL,
	397	#endif
	398	module___main__,
	399	NULL,
	400	NULL,
	401	0
	402	);
	403
	404	return (PyObject *)result;
	405	}
	406
	407
	408	extern void _initCompiledCellType();		131	extern void _initCompiledCellType();
	409	extern void _initCompiledGeneratorType();		132	extern void _initCompiledGeneratorType();
	410	extern void _initCompiledFunctionType();		133	extern void _initCompiledFunctionType();
	411	extern void _initCompiledMethodType();		134	extern void _initCompiledMethodType();
	412	extern void _initCompiledFrameType();		135	extern void _initCompiledFrameType();
	416	#ifdef _NUITKA_PLUGIN_DILL_ENABLED		139	#ifdef _NUITKA_PLUGIN_DILL_ENABLED
	417	// Provide a way to create find a function via its C code and create it back		140	// Provide a way to create find a function via its C code and create it back
	418	// in another process, useful for multiprocessing extensions like dill		141	// in another process, useful for multiprocessing extensions like dill
	419			142
	420	function_impl_code functable___main__[] = {		143	function_impl_code functable___main__[] = {
n	421	impl___main__$$$function_1_calledRepeatedly$$$function_1_empty,	n
	422	impl___main__$$$function_1_calledRepeatedly,		144	impl___main__$$$function_1_calledRepeatedly,
	423	NULL		145	NULL
	424	};		146	};
	425			147
	426	static char const *_reduce_compiled_function_argnames[] = {		148	static char const *_reduce_compiled_function_argnames[] = {
	785			507
	786	// Module code.		508	// Module code.
	787	{		509	{
	788	PyObject *tmp_assign_source_1;		510	PyObject *tmp_assign_source_1;
	789	tmp_assign_source_1 = Py_None;		511	tmp_assign_source_1 = Py_None;
n	790	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[3], tmp_assign_source_1);	n	512	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[1], tmp_assign_source_1);
	791	}		513	}
	792	{		514	{
	793	PyObject *tmp_assign_source_2;		515	PyObject *tmp_assign_source_2;
n	794	tmp_assign_source_2 = mod_consts[4];	n	516	tmp_assign_source_2 = mod_consts[2];
	795	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[5], tmp_assign_source_2);		517	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[3], tmp_assign_source_2);
	796	}		518	}
	797	{		519	{
	798	PyObject *tmp_assign_source_3;		520	PyObject *tmp_assign_source_3;
	799	tmp_assign_source_3 = Py_None;		521	tmp_assign_source_3 = Py_None;
n	800	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[6], tmp_assign_source_3);	n	522	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[4], tmp_assign_source_3);
	801	}		523	}
	802	{		524	{
	803	PyObject *tmp_assign_source_4;		525	PyObject *tmp_assign_source_4;
	804	tmp_assign_source_4 = Py_None;		526	tmp_assign_source_4 = Py_None;
n	805	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[7], tmp_assign_source_4);	n	527	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[5], tmp_assign_source_4);
	806	}		528	}
	807	{		529	{
	808	PyObject *tmp_assign_source_5;		530	PyObject *tmp_assign_source_5;
	809			531
	810			532
	811	tmp_assign_source_5 = MAKE_FUNCTION___main__$$$function_1_calledRepeatedly();		533	tmp_assign_source_5 = MAKE_FUNCTION___main__$$$function_1_calledRepeatedly();
	812			534
n	813	UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[8], tmp_assign_source_5);	n	535	UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[6], tmp_assign_source_5);
	814	}		536	}
	815	{		537	{
	816	PyObject *tmp_assign_source_6;		538	PyObject *tmp_assign_source_6;
	817	PyObject *tmp_name_name_1;		539	PyObject *tmp_name_name_1;
	818	PyObject *tmp_globals_name_1;		540	PyObject *tmp_globals_name_1;
	819	PyObject *tmp_locals_name_1;		541	PyObject *tmp_locals_name_1;
	820	PyObject *tmp_fromlist_name_1;		542	PyObject *tmp_fromlist_name_1;
	821	PyObject *tmp_level_name_1;		543	PyObject *tmp_level_name_1;
n	822	tmp_name_name_1 = mod_consts[9];	n	544	tmp_name_name_1 = mod_consts[7];
	823	tmp_globals_name_1 = (PyObject *)moduledict___main__;		545	tmp_globals_name_1 = (PyObject *)moduledict___main__;
	824	tmp_locals_name_1 = Py_None;		546	tmp_locals_name_1 = Py_None;
	825	tmp_fromlist_name_1 = Py_None;		547	tmp_fromlist_name_1 = Py_None;
n	826	tmp_level_name_1 = mod_consts[10];	n	548	tmp_level_name_1 = mod_consts[8];
	827	tmp_assign_source_6 = IMPORT_MODULE5(tmp_name_name_1, tmp_globals_name_1, tmp_locals_name_1, tmp_fromlist_name_1, tmp_level_name_1);		549	tmp_assign_source_6 = IMPORT_MODULE5(tmp_name_name_1, tmp_globals_name_1, tmp_locals_name_1, tmp_fromlist_name_1, tmp_level_name_1);
	828	assert(!(tmp_assign_source_6 == NULL));		550	assert(!(tmp_assign_source_6 == NULL));
n	829	UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[9], tmp_assign_source_6);	n	551	UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[7], tmp_assign_source_6);
	830	}		552	}
	831	// Frame without reuse.		553	// Frame without reuse.
	832	frame_36d5271f971d22837d70bd77c2293acb = MAKE_MODULE_FRAME(codeobj_36d5271f971d22837d70bd77c2293acb, module___main__);		554	frame_36d5271f971d22837d70bd77c2293acb = MAKE_MODULE_FRAME(codeobj_36d5271f971d22837d70bd77c2293acb, module___main__);
	833			555
	834	// Push the new frame as the currently active one, and we should be exclusively		556	// Push the new frame as the currently active one, and we should be exclusively
	840	{		562	{
	841	PyObject *tmp_assign_source_7;		563	PyObject *tmp_assign_source_7;
	842	PyObject *tmp_iter_arg_1;		564	PyObject *tmp_iter_arg_1;
	843	PyObject *tmp_called_instance_1;		565	PyObject *tmp_called_instance_1;
	844	PyObject *tmp_mvar_value_1;		566	PyObject *tmp_mvar_value_1;
n	845	tmp_mvar_value_1 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[9]);	n	567	tmp_mvar_value_1 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[7]);
	846			568
	847	if (unlikely(tmp_mvar_value_1 == NULL)) {		569	if (unlikely(tmp_mvar_value_1 == NULL)) {
n	848	tmp_mvar_value_1 = GET_STRING_DICT_VALUE(dict_builtin, (Nuitka_StringObject *)mod_consts[9]);	n	570	tmp_mvar_value_1 = GET_STRING_DICT_VALUE(dict_builtin, (Nuitka_StringObject *)mod_consts[7]);
	849	}		571	}
	850			572
	851	CHECK_OBJECT(tmp_mvar_value_1);		573	CHECK_OBJECT(tmp_mvar_value_1);
	852	tmp_called_instance_1 = tmp_mvar_value_1;		574	tmp_called_instance_1 = tmp_mvar_value_1;
	853	frame_36d5271f971d22837d70bd77c2293acb->m_frame.f_lineno = 36;		575	frame_36d5271f971d22837d70bd77c2293acb->m_frame.f_lineno = 36;
n	854	tmp_iter_arg_1 = CALL_METHOD_WITH_ARGS2(tmp_called_instance_1, mod_consts[11], &PyTuple_GET_ITEM(mod_consts[12], 0));	n	576	tmp_iter_arg_1 = CALL_METHOD_WITH_ARGS2(tmp_called_instance_1, mod_consts[9], &PyTuple_GET_ITEM(mod_consts[10], 0));
	855			577
	856	if (tmp_iter_arg_1 == NULL) {		578	if (tmp_iter_arg_1 == NULL) {
	857	assert(ERROR_OCCURRED());		579	assert(ERROR_OCCURRED());
	858			580
	859	FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);		581	FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
	908	}		630	}
	909	{		631	{
	910	PyObject *tmp_assign_source_9;		632	PyObject *tmp_assign_source_9;
	911	CHECK_OBJECT(tmp_for_loop_1__iter_value);		633	CHECK_OBJECT(tmp_for_loop_1__iter_value);
	912	tmp_assign_source_9 = tmp_for_loop_1__iter_value;		634	tmp_assign_source_9 = tmp_for_loop_1__iter_value;
n	913	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[13], tmp_assign_source_9);	n	635	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[11], tmp_assign_source_9);
	914	}		636	}
	915	{		637	{
	916	PyObject *tmp_called_name_1;		638	PyObject *tmp_called_name_1;
	917	PyObject *tmp_mvar_value_2;		639	PyObject *tmp_mvar_value_2;
	918	PyObject *tmp_call_result_1;		640	PyObject *tmp_call_result_1;
n	919	tmp_mvar_value_2 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[8]);	n	641	tmp_mvar_value_2 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[6]);
	920			642
	921	if (unlikely(tmp_mvar_value_2 == NULL)) {		643	if (unlikely(tmp_mvar_value_2 == NULL)) {
n	922	tmp_mvar_value_2 = GET_STRING_DICT_VALUE(dict_builtin, (Nuitka_StringObject *)mod_consts[8]);	n	644	tmp_mvar_value_2 = GET_STRING_DICT_VALUE(dict_builtin, (Nuitka_StringObject *)mod_consts[6]);
	923	}		645	}
	924			646
	925	if (unlikely(tmp_mvar_value_2 == NULL)) {		647	if (unlikely(tmp_mvar_value_2 == NULL)) {
	926			648
n	927	FORMAT_NAME_ERROR(&exception_type, &exception_value, mod_consts[8]);	n	649	FORMAT_NAME_ERROR(&exception_type, &exception_value, mod_consts[6]);
	928	NORMALIZE_EXCEPTION(&exception_type, &exception_value, &exception_tb);		650	NORMALIZE_EXCEPTION(&exception_type, &exception_value, &exception_tb);
	929	CHAIN_EXCEPTION(exception_value);		651	CHAIN_EXCEPTION(exception_value);
	930			652
	931	exception_lineno = 37;		653	exception_lineno = 37;
	932			654
	996	tmp_for_loop_1__for_iterator = NULL;		718	tmp_for_loop_1__for_iterator = NULL;
	997			719
	998	{		720	{
	999	PyObject *tmp_called_name_2;		721	PyObject *tmp_called_name_2;
	1000	PyObject *tmp_call_result_2;		722	PyObject *tmp_call_result_2;
n	1001	tmp_called_name_2 = LOOKUP_BUILTIN(mod_consts[14]);	n	723	tmp_called_name_2 = LOOKUP_BUILTIN(mod_consts[12]);
	1002	assert(tmp_called_name_2 != NULL);		724	assert(tmp_called_name_2 != NULL);
	1003	frame_36d5271f971d22837d70bd77c2293acb->m_frame.f_lineno = 39;		725	frame_36d5271f971d22837d70bd77c2293acb->m_frame.f_lineno = 39;
t	1004	tmp_call_result_2 = CALL_FUNCTION_WITH_SINGLE_ARG(tmp_called_name_2, mod_consts[15]);	t	726	tmp_call_result_2 = CALL_FUNCTION_WITH_SINGLE_ARG(tmp_called_name_2, mod_consts[13]);
	1005	if (tmp_call_result_2 == NULL) {		727	if (tmp_call_result_2 == NULL) {
	1006	assert(ERROR_OCCURRED());		728	assert(ERROR_OCCURRED());
	1007			729
	1008	FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);		730	FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
	1009			731