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_c5d0fa1f7bf1e6403f2b8dd49cce5c4c;		61	static PyCodeObject *codeobj_c5d0fa1f7bf1e6403f2b8dd49cce5c4c;
	62	static PyCodeObject *codeobj_5185d9f6e4494977166e105799e60c32;		62	static PyCodeObject *codeobj_5185d9f6e4494977166e105799e60c32;
n	63	static PyCodeObject *codeobj_e84f04252b636aae08a8b6a5fbb07936;	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[1]; CHECK_OBJECT(module_filename_obj);
	69	codeobj_c5d0fa1f7bf1e6403f2b8dd49cce5c4c = MAKE_CODEOBJECT(module_filename_obj, 1, CO_NOFREE, mod_consts[16], mod_consts[17], 0, 0, 0);		68	codeobj_c5d0fa1f7bf1e6403f2b8dd49cce5c4c = MAKE_CODEOBJECT(module_filename_obj, 1, CO_NOFREE, mod_consts[14], mod_consts[15], 0, 0, 0);
	70	codeobj_5185d9f6e4494977166e105799e60c32 = MAKE_CODEOBJECT(module_filename_obj, 23, CO_OPTIMIZED \| CO_NEWLOCALS \| CO_NOFREE, mod_consts[8], mod_consts[18], 0, 0, 0);		69	codeobj_5185d9f6e4494977166e105799e60c32 = MAKE_CODEOBJECT(module_filename_obj, 23, CO_OPTIMIZED \| CO_NEWLOCALS \| CO_NOFREE, mod_consts[6], mod_consts[16], 0, 0, 0);
	71	codeobj_e84f04252b636aae08a8b6a5fbb07936 = 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();
	79			74
	80			75
n	81	static PyObject *MAKE_FUNCTION___main__$$$function_1_calledRepeatedly$$$function_1_empty();	n
	82
	83
	84	// The module function definitions.		76	// The module function definitions.
n	85	static PyObject impl___main__$$$function_1_calledRepeatedly(struct Nuitka_FunctionObject const self, PyObject **python_pars) {	n
	86	// Preserve error status for checks
	87	#ifndef __NUITKA_NO_ASSERT__
	88	NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED();
	89	#endif
	90
	91	// Local variable declarations.
	92	PyObject *var_empty = NULL;
	93	PyObject *tmp_return_value = NULL;
	94
	95	// Actual function body.
	96	{
	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);
	109	goto try_return_handler_1;
	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	goto function_return_exit;
	118	// End of try:
	119
	120	NUITKA_CANNOT_GET_HERE("Return statement must have exited already.");
	121	return NULL;
	122
	123
	124	function_return_exit:
	125	// Function cleanup code if any.
	126
	127
	128	// Actual function exit with return value, making sure we did not make
	129	// the error status worse despite non-NULL return.
	130	CHECK_OBJECT(tmp_return_value);
	131	assert(had_error \|\| !ERROR_OCCURRED());
	132	return tmp_return_value;
	133	}
	134
	135
	136	static PyObject impl___main__$$$function_1_calledRepeatedly$$$function_1_empty(struct Nuitka_FunctionObject const self, PyObject **python_pars) {
	137	// Preserve error status for checks
	138	#ifndef __NUITKA_NO_ASSERT__
	139	NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED();
	140	#endif
	141
	142	// Local variable declarations.
	143	PyObject *tmp_return_value = NULL;
	144
	145	// Actual function body.
	146
	147
	148	tmp_return_value = MAKE_GENERATOR___main__$$$function_1_calledRepeatedly$$$function_1_empty$$$genobj_1_empty();
	149
	150	goto function_return_exit;
	151
	152	NUITKA_CANNOT_GET_HERE("Return statement must have exited already.");
	153	return NULL;
	154
	155
	156	function_return_exit:
	157	// Function cleanup code if any.
	158
	159
	160	// Actual function exit with return value, making sure we did not make
	161	// the error status worse despite non-NULL return.
	162	CHECK_OBJECT(tmp_return_value);
	163	assert(had_error \|\| !ERROR_OCCURRED());
	164	return tmp_return_value;
	165	}
	166
	167
	168
	169	struct __main__$$$function_1_calledRepeatedly$$$function_1_empty$$$genobj_1_empty_locals {
	170	char const *type_description_1;
	171	PyObject *exception_type;
	172	PyObject *exception_value;
	173	PyTracebackObject *exception_tb;
	174	int exception_lineno;
	175	};
	176
	177	static PyObject __main__$$$function_1_calledRepeatedly$$$function_1_empty$$$genobj_1_empty_context(struct Nuitka_GeneratorObject generator, PyObject *yield_return_value) {
	178	CHECK_OBJECT(generator);
	179	assert(Nuitka_Generator_Check((PyObject *)generator));
	180	CHECK_OBJECT_X(yield_return_value);
	181
	182	// Heap access if used.
	183	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;
	184
	185	// Dispatch to yield based on return label index:
	186	switch(generator->m_yield_return_index) {
	187	case 1: goto yield_return_1;
	188	}
	189
	190	// Local variable initialization
	191	NUITKA_MAY_BE_UNUSED nuitka_void tmp_unused;
	192	static struct Nuitka_FrameObject *cache_m_frame = NULL;
	193	generator_heap->type_description_1 = NULL;
	194	generator_heap->exception_type = NULL;
	195	generator_heap->exception_value = NULL;
	196	generator_heap->exception_tb = NULL;
	197	generator_heap->exception_lineno = 0;
	198
	199	// Actual generator function body.
	200	if (isFrameUnusable(cache_m_frame)) {
	201	Py_XDECREF(cache_m_frame);
	202
	203	#if _DEBUG_REFCOUNTS
	204	if (cache_m_frame == NULL) {
	205	count_active_frame_cache_instances += 1;
	206	} else {
	207	count_released_frame_cache_instances += 1;
	208	}
	209	count_allocated_frame_cache_instances += 1;
	210	#endif
	211	cache_m_frame = MAKE_FUNCTION_FRAME(codeobj_e84f04252b636aae08a8b6a5fbb07936, module___main__, 0);
	212	#if _DEBUG_REFCOUNTS
	213	} else {
	214	count_hit_frame_cache_instances += 1;
	215	#endif
	216	}
	217	generator->m_frame = cache_m_frame;
	218
	219	// Mark the frame object as in use, ref count 1 will be up for reuse.
	220	Py_INCREF(generator->m_frame);
	221	assert(Py_REFCNT(generator->m_frame) == 2); // Frame stack
	222
	223	#if PYTHON_VERSION >= 340
	224	generator->m_frame->m_frame.f_gen = (PyObject *)generator;
	225	#endif
	226
	227	assert(generator->m_frame->m_frame.f_back == NULL);
	228	Py_CLEAR(generator->m_frame->m_frame.f_back);
	229
	230	generator->m_frame->m_frame.f_back = PyThreadState_GET()->frame;
	231	Py_INCREF(generator->m_frame->m_frame.f_back);
	232
	233	PyThreadState_GET()->frame = &generator->m_frame->m_frame;
	234	Py_INCREF(generator->m_frame);
	235
	236	Nuitka_Frame_MarkAsExecuting(generator->m_frame);
	237
	238	#if PYTHON_VERSION >= 300
	239	// Accept currently existing exception as the one to publish again when we
	240	// yield or yield from.
	241	{
	242	PyThreadState *thread_state = PyThreadState_GET();
	243
	244	EXC_TYPE_F(generator) = EXC_TYPE(thread_state);
	245	if (EXC_TYPE_F(generator) == Py_None) EXC_TYPE_F(generator) = NULL;
	246	Py_XINCREF(EXC_TYPE_F(generator));
	247	EXC_VALUE_F(generator) = EXC_VALUE(thread_state);
	248	Py_XINCREF(EXC_VALUE_F(generator));
	249	EXC_TRACEBACK_F(generator) = EXC_TRACEBACK(thread_state);
	250	Py_XINCREF(EXC_TRACEBACK_F(generator));
	251	}
	252
	253	#endif
	254
	255	// Framed code:
	256	{
	257	PyObject *tmp_expression_name_1;
	258	NUITKA_MAY_BE_UNUSED PyObject *tmp_yield_result_1;
	259	tmp_expression_name_1 = mod_consts[2];
	260	Py_INCREF(tmp_expression_name_1);
	261	generator->m_yield_return_index = 1;
	262	return tmp_expression_name_1;
	263	yield_return_1:
	264	if (yield_return_value == NULL) {
	265	assert(ERROR_OCCURRED());
	266
	267	FETCH_ERROR_OCCURRED(&generator_heap->exception_type, &generator_heap->exception_value, &generator_heap->exception_tb);
	268
	269
	270	generator_heap->exception_lineno = 27;
	271
	272	goto frame_exception_exit_1;
	273	}
	274	tmp_yield_result_1 = yield_return_value;
	275	}
	276
	277	Nuitka_Frame_MarkAsNotExecuting(generator->m_frame);
	278
	279	#if PYTHON_VERSION >= 300
	280	Py_CLEAR(EXC_TYPE_F(generator));
	281	Py_CLEAR(EXC_VALUE_F(generator));
	282	Py_CLEAR(EXC_TRACEBACK_F(generator));
	283	#endif
	284
	285	// Allow re-use of the frame again.
	286	Py_DECREF(generator->m_frame);
	287	goto frame_no_exception_1;
	288
	289	frame_exception_exit_1:;
	290
	291	// If it's not an exit exception, consider and create a traceback for it.
	292	if (!EXCEPTION_MATCH_GENERATOR(generator_heap->exception_type)) {
	293	if (generator_heap->exception_tb == NULL) {
	294	generator_heap->exception_tb = MAKE_TRACEBACK(generator->m_frame, generator_heap->exception_lineno);
	295	} else if (generator_heap->exception_tb->tb_frame != &generator->m_frame->m_frame) {
	296	generator_heap->exception_tb = ADD_TRACEBACK(generator_heap->exception_tb, generator->m_frame, generator_heap->exception_lineno);
	297	}
	298
	299	Nuitka_Frame_AttachLocals(
	300	generator->m_frame,
	301	generator_heap->type_description_1
	302	);
	303
	304
	305	// Release cached frame.
	306	if (generator->m_frame == cache_m_frame) {
	307	#if _DEBUG_REFCOUNTS
	308	count_active_frame_cache_instances -= 1;
	309	count_released_frame_cache_instances += 1;
	310	#endif
	311
	312	Py_DECREF(generator->m_frame);
	313	}
	314	cache_m_frame = NULL;
	315
	316	assertFrameObject(generator->m_frame);
	317	}
	318
	319	#if PYTHON_VERSION >= 300
	320	Py_CLEAR(EXC_TYPE_F(generator));
	321	Py_CLEAR(EXC_VALUE_F(generator));
	322	Py_CLEAR(EXC_TRACEBACK_F(generator));
	323	#endif
	324
	325	Py_DECREF(generator->m_frame);
	326
	327	// Return the error.
	328	goto function_exception_exit;
	329
	330	frame_no_exception_1:;
	331
	332
	333	return NULL;
	334
	335	function_exception_exit:
	336	assert(generator_heap->exception_type);
	337	RESTORE_ERROR_OCCURRED(generator_heap->exception_type, generator_heap->exception_value, generator_heap->exception_tb);
	338
	339	return NULL;
	340
	341	}
	342
	343	static PyObject *MAKE_GENERATOR___main__$$$function_1_calledRepeatedly$$$function_1_empty$$$genobj_1_empty() {
	344	return Nuitka_Generator_New(
	345	__main__$$$function_1_calledRepeatedly$$$function_1_empty$$$genobj_1_empty_context,
	346	module___main__,
	347	mod_consts[0],
	348	#if PYTHON_VERSION >= 350
	349	mod_consts[1],
	350	#endif
	351	codeobj_e84f04252b636aae08a8b6a5fbb07936,
	352	NULL,
	353	0,
	354	sizeof(struct __main__$$$function_1_calledRepeatedly$$$function_1_empty$$$genobj_1_empty_locals)
	355	);
	356	}
	357
	358
	359			77
	360	static PyObject *MAKE_FUNCTION___main__$$$function_1_calledRepeatedly() {		78	static PyObject *MAKE_FUNCTION___main__$$$function_1_calledRepeatedly() {
	361	struct Nuitka_FunctionObject *result = Nuitka_Function_New(		79	struct Nuitka_FunctionObject *result = Nuitka_Function_New(
n	362	impl___main__$$$function_1_calledRepeatedly,	n	80	NULL,
	363	mod_consts[8],		81	mod_consts[6],
	364	#if PYTHON_VERSION >= 300		82	#if PYTHON_VERSION >= 300
	365	NULL,		83	NULL,
	366	#endif		84	#endif
	367	codeobj_5185d9f6e4494977166e105799e60c32,		85	codeobj_5185d9f6e4494977166e105799e60c32,
	368	NULL,		86	NULL,
	373	module___main__,		91	module___main__,
	374	NULL,		92	NULL,
	375	NULL,		93	NULL,
	376	0		94	0
	377	);		95	);
n	378		n	96	result->m_constant_return_value = mod_consts[5];
	379
	380	return (PyObject *)result;
	381	}
	382
	383
	384
	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_e84f04252b636aae08a8b6a5fbb07936,
	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			97
	405	return (PyObject *)result;		98	return (PyObject *)result;
	406	}		99	}
	407			100
	408			101
	417	#ifdef _NUITKA_PLUGIN_DILL_ENABLED		110	#ifdef _NUITKA_PLUGIN_DILL_ENABLED
	418	// Provide a way to create find a function via its C code and create it back		111	// Provide a way to create find a function via its C code and create it back
	419	// in another process, useful for multiprocessing extensions like dill		112	// in another process, useful for multiprocessing extensions like dill
	420			113
	421	function_impl_code functable___main__[] = {		114	function_impl_code functable___main__[] = {
n	422	impl___main__$$$function_1_calledRepeatedly$$$function_1_empty,	n	115	NULL,
	423	impl___main__$$$function_1_calledRepeatedly,
	424	NULL		116	NULL
	425	};		117	};
	426			118
	427	static char const *_reduce_compiled_function_argnames[] = {		119	static char const *_reduce_compiled_function_argnames[] = {
	428	"func",		120	"func",
	786			478
	787	// Module code.		479	// Module code.
	788	{		480	{
	789	PyObject *tmp_assign_source_1;		481	PyObject *tmp_assign_source_1;
	790	tmp_assign_source_1 = Py_None;		482	tmp_assign_source_1 = Py_None;
n	791	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[3], tmp_assign_source_1);	n	483	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[0], tmp_assign_source_1);
	792	}		484	}
	793	{		485	{
	794	PyObject *tmp_assign_source_2;		486	PyObject *tmp_assign_source_2;
n	795	tmp_assign_source_2 = mod_consts[4];	n	487	tmp_assign_source_2 = mod_consts[1];
	796	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[5], tmp_assign_source_2);		488	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[2], tmp_assign_source_2);
	797	}		489	}
	798	{		490	{
	799	PyObject *tmp_assign_source_3;		491	PyObject *tmp_assign_source_3;
	800	tmp_assign_source_3 = Py_None;		492	tmp_assign_source_3 = Py_None;
n	801	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[6], tmp_assign_source_3);	n	493	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[3], tmp_assign_source_3);
	802	}		494	}
	803	{		495	{
	804	PyObject *tmp_assign_source_4;		496	PyObject *tmp_assign_source_4;
	805	tmp_assign_source_4 = Py_None;		497	tmp_assign_source_4 = Py_None;
n	806	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[7], tmp_assign_source_4);	n	498	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[4], tmp_assign_source_4);
	807	}		499	}
	808	{		500	{
	809	PyObject *tmp_assign_source_5;		501	PyObject *tmp_assign_source_5;
	810			502
	811			503
	812	tmp_assign_source_5 = MAKE_FUNCTION___main__$$$function_1_calledRepeatedly();		504	tmp_assign_source_5 = MAKE_FUNCTION___main__$$$function_1_calledRepeatedly();
	813			505
n	814	UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[8], tmp_assign_source_5);	n	506	UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[6], tmp_assign_source_5);
	815	}		507	}
	816	{		508	{
	817	PyObject *tmp_assign_source_6;		509	PyObject *tmp_assign_source_6;
	818	PyObject *tmp_name_name_1;		510	PyObject *tmp_name_name_1;
	819	PyObject *tmp_globals_name_1;		511	PyObject *tmp_globals_name_1;
	820	PyObject *tmp_locals_name_1;		512	PyObject *tmp_locals_name_1;
	821	PyObject *tmp_fromlist_name_1;		513	PyObject *tmp_fromlist_name_1;
	822	PyObject *tmp_level_name_1;		514	PyObject *tmp_level_name_1;
n	823	tmp_name_name_1 = mod_consts[9];	n	515	tmp_name_name_1 = mod_consts[7];
	824	tmp_globals_name_1 = (PyObject *)moduledict___main__;		516	tmp_globals_name_1 = (PyObject *)moduledict___main__;
	825	tmp_locals_name_1 = Py_None;		517	tmp_locals_name_1 = Py_None;
	826	tmp_fromlist_name_1 = Py_None;		518	tmp_fromlist_name_1 = Py_None;
n	827	tmp_level_name_1 = mod_consts[10];	n	519	tmp_level_name_1 = mod_consts[8];
	828	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);		520	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);
	829	assert(!(tmp_assign_source_6 == NULL));		521	assert(!(tmp_assign_source_6 == NULL));
n	830	UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[9], tmp_assign_source_6);	n	522	UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[7], tmp_assign_source_6);
	831	}		523	}
	832	// Frame without reuse.		524	// Frame without reuse.
	833	frame_c5d0fa1f7bf1e6403f2b8dd49cce5c4c = MAKE_MODULE_FRAME(codeobj_c5d0fa1f7bf1e6403f2b8dd49cce5c4c, module___main__);		525	frame_c5d0fa1f7bf1e6403f2b8dd49cce5c4c = MAKE_MODULE_FRAME(codeobj_c5d0fa1f7bf1e6403f2b8dd49cce5c4c, module___main__);
	834			526
	835	// Push the new frame as the currently active one, and we should be exclusively		527	// Push the new frame as the currently active one, and we should be exclusively
	840	// Framed code:		532	// Framed code:
	841	{		533	{
	842	PyObject *tmp_assign_source_7;		534	PyObject *tmp_assign_source_7;
	843	PyObject *tmp_iter_arg_1;		535	PyObject *tmp_iter_arg_1;
	844	PyObject *tmp_called_instance_1;		536	PyObject *tmp_called_instance_1;
n	845	tmp_called_instance_1 = GET_MODULE_VARIABLE_VALUE(moduledict___main__, mod_consts[9]);	n	537	tmp_called_instance_1 = GET_MODULE_VARIABLE_VALUE(moduledict___main__, mod_consts[7]);
	846	assert(!(tmp_called_instance_1 == NULL));		538	assert(!(tmp_called_instance_1 == NULL));
	847	frame_c5d0fa1f7bf1e6403f2b8dd49cce5c4c->m_frame.f_lineno = 36;		539	frame_c5d0fa1f7bf1e6403f2b8dd49cce5c4c->m_frame.f_lineno = 36;
n	848	tmp_iter_arg_1 = CALL_METHOD_WITH_ARGS2(tmp_called_instance_1, mod_consts[11], &PyTuple_GET_ITEM(mod_consts[12], 0));	n	540	tmp_iter_arg_1 = CALL_METHOD_WITH_ARGS2(tmp_called_instance_1, mod_consts[9], &PyTuple_GET_ITEM(mod_consts[10], 0));
	849			541
	850	if (tmp_iter_arg_1 == NULL) {		542	if (tmp_iter_arg_1 == NULL) {
	851	assert(ERROR_OCCURRED());		543	assert(ERROR_OCCURRED());
	852			544
	853	FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);		545	FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
	902	}		594	}
	903	{		595	{
	904	PyObject *tmp_assign_source_9;		596	PyObject *tmp_assign_source_9;
	905	CHECK_OBJECT(tmp_for_loop_1__iter_value);		597	CHECK_OBJECT(tmp_for_loop_1__iter_value);
	906	tmp_assign_source_9 = tmp_for_loop_1__iter_value;		598	tmp_assign_source_9 = tmp_for_loop_1__iter_value;
n	907	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[13], tmp_assign_source_9);	n	599	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[11], tmp_assign_source_9);
	908	}		600	}
	909	{		601	{
	910	PyObject *tmp_called_name_1;		602	PyObject *tmp_called_name_1;
	911	PyObject *tmp_call_result_1;		603	PyObject *tmp_call_result_1;
n	912	tmp_called_name_1 = GET_MODULE_VARIABLE_VALUE(moduledict___main__, mod_consts[8]);	n	604	tmp_called_name_1 = GET_MODULE_VARIABLE_VALUE(moduledict___main__, mod_consts[6]);
	913	if (tmp_called_name_1 == NULL) {		605	if (tmp_called_name_1 == NULL) {
	914	assert(ERROR_OCCURRED());		606	assert(ERROR_OCCURRED());
	915			607
	916	FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);		608	FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
	917			609
	978	Py_DECREF(tmp_for_loop_1__for_iterator);		670	Py_DECREF(tmp_for_loop_1__for_iterator);
	979	tmp_for_loop_1__for_iterator = NULL;		671	tmp_for_loop_1__for_iterator = NULL;
	980	{		672	{
	981	PyObject *tmp_called_name_2;		673	PyObject *tmp_called_name_2;
	982	PyObject *tmp_call_result_2;		674	PyObject *tmp_call_result_2;
n	983	tmp_called_name_2 = LOOKUP_BUILTIN(mod_consts[14]);	n	675	tmp_called_name_2 = LOOKUP_BUILTIN(mod_consts[12]);
	984	assert(tmp_called_name_2 != NULL);		676	assert(tmp_called_name_2 != NULL);
	985	frame_c5d0fa1f7bf1e6403f2b8dd49cce5c4c->m_frame.f_lineno = 39;		677	frame_c5d0fa1f7bf1e6403f2b8dd49cce5c4c->m_frame.f_lineno = 39;
t	986	tmp_call_result_2 = CALL_FUNCTION_WITH_SINGLE_ARG(tmp_called_name_2, mod_consts[15]);	t	678	tmp_call_result_2 = CALL_FUNCTION_WITH_SINGLE_ARG(tmp_called_name_2, mod_consts[13]);
	987	if (tmp_call_result_2 == NULL) {		679	if (tmp_call_result_2 == NULL) {
	988	assert(ERROR_OCCURRED());		680	assert(ERROR_OCCURRED());
	989			681
	990	FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);		682	FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
	991			683