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;
	66	#endif		66	#endif
	67			67
	68	// The module code objects.		68	// The module code objects.
	69	static PyCodeObject *codeobj_b5d4cadc1cbd82f0425a8267dd24d2ca;		69	static PyCodeObject *codeobj_b5d4cadc1cbd82f0425a8267dd24d2ca;
	70	static PyCodeObject *codeobj_857b7d96b5b0e69e205af2cecc9c0ea9;		70	static PyCodeObject *codeobj_857b7d96b5b0e69e205af2cecc9c0ea9;
n	71	static PyCodeObject *codeobj_a8b80aaace1ce49e8c63e1c3a78b0f95;	n
	72	/* For use in "MainProgram.c". */		71	/* For use in "MainProgram.c". */
	73	PyCodeObject *codeobj_main = NULL;		72	PyCodeObject *codeobj_main = NULL;
	74			73
	75	static void createModuleCodeObjects(void) {		74	static void createModuleCodeObjects(void) {
n	76	module_filename_obj = mod_consts[4]; CHECK_OBJECT(module_filename_obj);	n	75	module_filename_obj = mod_consts[1]; CHECK_OBJECT(module_filename_obj);
	77	codeobj_b5d4cadc1cbd82f0425a8267dd24d2ca = MAKE_CODEOBJECT(module_filename_obj, 1, CO_NOFREE, mod_consts[17], NULL, NULL, 0, 0, 0);		76	codeobj_b5d4cadc1cbd82f0425a8267dd24d2ca = MAKE_CODEOBJECT(module_filename_obj, 1, CO_NOFREE, mod_consts[15], NULL, NULL, 0, 0, 0);
	78	codeobj_857b7d96b5b0e69e205af2cecc9c0ea9 = MAKE_CODEOBJECT(module_filename_obj, 23, CO_OPTIMIZED \| CO_NEWLOCALS \| CO_NOFREE, mod_consts[9], mod_consts[18], NULL, 0, 0, 0);		77	codeobj_857b7d96b5b0e69e205af2cecc9c0ea9 = MAKE_CODEOBJECT(module_filename_obj, 23, CO_OPTIMIZED \| CO_NEWLOCALS \| CO_NOFREE, mod_consts[7], mod_consts[16], NULL, 0, 0, 0);
	79	codeobj_a8b80aaace1ce49e8c63e1c3a78b0f95 = MAKE_CODEOBJECT(module_filename_obj, 26, CO_GENERATOR \| CO_OPTIMIZED \| CO_NEWLOCALS \| CO_NOFREE, mod_consts[0], NULL, NULL, 0, 0, 0);
	80	}		78	}
	81			79
	82	// The module function declarations.		80	// The module function declarations.
n	83	static PyObject *MAKE_GENERATOR___main__$$$function__1_calledRepeatedly$$$function__1_empty$$$genobj__1_empty();	n
	84
	85
	86	static PyObject *MAKE_FUNCTION___main__$$$function__1_calledRepeatedly();		81	static PyObject *MAKE_FUNCTION___main__$$$function__1_calledRepeatedly();
	87			82
	88			83
n	89	static PyObject *MAKE_FUNCTION___main__$$$function__1_calledRepeatedly$$$function__1_empty();	n
	90
	91
	92	// The module function definitions.		84	// The module function definitions.
n	93	static PyObject impl___main__$$$function__1_calledRepeatedly(struct Nuitka_FunctionObject const self, PyObject **python_pars) {	n
	94	// Preserve error status for checks
	95	#ifndef __NUITKA_NO_ASSERT__
	96	NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED();
	97	#endif
	98
	99	// Local variable declarations.
	100	PyObject *var_empty = NULL;
	101	PyObject *tmp_return_value = NULL;
	102
	103	// Actual function body.
	104	{
	105	PyObject *tmp_assign_source_1;
	106
	107
	108	tmp_assign_source_1 = MAKE_FUNCTION___main__$$$function__1_calledRepeatedly$$$function__1_empty();
	109
	110	assert(var_empty == NULL);
	111	var_empty = tmp_assign_source_1;
	112	}
	113	// Tried code:
	114	CHECK_OBJECT(var_empty);
	115	tmp_return_value = var_empty;
	116	Py_INCREF(tmp_return_value);
	117	goto try_return_handler_1;
	118	NUITKA_CANNOT_GET_HERE("tried codes exits in all cases");
	119	return NULL;
	120	// Return handler code:
	121	try_return_handler_1:;
	122	CHECK_OBJECT(var_empty);
	123	Py_DECREF(var_empty);
	124	var_empty = NULL;
	125	goto function_return_exit;
	126	// End of try:
	127
	128	NUITKA_CANNOT_GET_HERE("Return statement must have exited already.");
	129	return NULL;
	130
	131
	132	function_return_exit:
	133	// Function cleanup code if any.
	134
	135
	136	// Actual function exit with return value, making sure we did not make
	137	// the error status worse despite non-NULL return.
	138	CHECK_OBJECT(tmp_return_value);
	139	assert(had_error \|\| !ERROR_OCCURRED());
	140	return tmp_return_value;
	141	}
	142
	143
	144	static PyObject impl___main__$$$function__1_calledRepeatedly$$$function__1_empty(struct Nuitka_FunctionObject const self, PyObject **python_pars) {
	145	// Preserve error status for checks
	146	#ifndef __NUITKA_NO_ASSERT__
	147	NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED();
	148	#endif
	149
	150	// Local variable declarations.
	151	PyObject *tmp_return_value = NULL;
	152
	153	// Actual function body.
	154
	155
	156	tmp_return_value = MAKE_GENERATOR___main__$$$function__1_calledRepeatedly$$$function__1_empty$$$genobj__1_empty();
	157
	158	goto function_return_exit;
	159
	160	NUITKA_CANNOT_GET_HERE("Return statement must have exited already.");
	161	return NULL;
	162
	163
	164	function_return_exit:
	165	// Function cleanup code if any.
	166
	167
	168	// Actual function exit with return value, making sure we did not make
	169	// the error status worse despite non-NULL return.
	170	CHECK_OBJECT(tmp_return_value);
	171	assert(had_error \|\| !ERROR_OCCURRED());
	172	return tmp_return_value;
	173	}
	174
	175
	176
	177	struct __main__$$$function__1_calledRepeatedly$$$function__1_empty$$$genobj__1_empty_locals {
	178	char const *type_description_1;
	179	PyObject *exception_type;
	180	PyObject *exception_value;
	181	PyTracebackObject *exception_tb;
	182	int exception_lineno;
	183	};
	184
	185	static PyObject __main__$$$function__1_calledRepeatedly$$$function__1_empty$$$genobj__1_empty_context(struct Nuitka_GeneratorObject generator, PyObject *yield_return_value) {
	186	CHECK_OBJECT(generator);
	187	assert(Nuitka_Generator_Check((PyObject *)generator));
	188	CHECK_OBJECT_X(yield_return_value);
	189
	190	// Heap access if used.
	191	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;
	192
	193	// Dispatch to yield based on return label index:
	194	switch(generator->m_yield_return_index) {
	195	case 1: goto yield_return_1;
	196	}
	197
	198	// Local variable initialization
	199	NUITKA_MAY_BE_UNUSED nuitka_void tmp_unused;
	200	static struct Nuitka_FrameObject *cache_m_frame = NULL;
	201	generator_heap->type_description_1 = NULL;
	202	generator_heap->exception_type = NULL;
	203	generator_heap->exception_value = NULL;
	204	generator_heap->exception_tb = NULL;
	205	generator_heap->exception_lineno = 0;
	206
	207	// Actual generator function body.
	208	if (isFrameUnusable(cache_m_frame)) {
	209	Py_XDECREF(cache_m_frame);
	210
	211	#if _DEBUG_REFCOUNTS
	212	if (cache_m_frame == NULL) {
	213	count_active_frame_cache_instances += 1;
	214	} else {
	215	count_released_frame_cache_instances += 1;
	216	}
	217	count_allocated_frame_cache_instances += 1;
	218	#endif
	219	cache_m_frame = MAKE_FUNCTION_FRAME(codeobj_a8b80aaace1ce49e8c63e1c3a78b0f95, module___main__, 0);
	220	#if _DEBUG_REFCOUNTS
	221	} else {
	222	count_hit_frame_cache_instances += 1;
	223	#endif
	224	}
	225	generator->m_frame = cache_m_frame;
	226
	227	// Mark the frame object as in use, ref count 1 will be up for reuse.
	228	Py_INCREF(generator->m_frame);
	229	assert(Py_REFCNT(generator->m_frame) == 2); // Frame stack
	230
	231	#if PYTHON_VERSION >= 0x340
	232	generator->m_frame->m_frame.f_gen = (PyObject *)generator;
	233	#endif
	234
	235	assert(generator->m_frame->m_frame.f_back == NULL);
	236	Py_CLEAR(generator->m_frame->m_frame.f_back);
	237
	238	generator->m_frame->m_frame.f_back = PyThreadState_GET()->frame;
	239	Py_INCREF(generator->m_frame->m_frame.f_back);
	240
	241	PyThreadState_GET()->frame = &generator->m_frame->m_frame;
	242	Py_INCREF(generator->m_frame);
	243
	244	Nuitka_Frame_MarkAsExecuting(generator->m_frame);
	245
	246	#if PYTHON_VERSION >= 0x300
	247	// Accept currently existing exception as the one to publish again when we
	248	// yield or yield from.
	249	{
	250	PyThreadState *thread_state = PyThreadState_GET();
	251
	252	EXC_TYPE_F(generator) = EXC_TYPE(thread_state);
	253	if (EXC_TYPE_F(generator) == Py_None) EXC_TYPE_F(generator) = NULL;
	254	Py_XINCREF(EXC_TYPE_F(generator));
	255	EXC_VALUE_F(generator) = EXC_VALUE(thread_state);
	256	Py_XINCREF(EXC_VALUE_F(generator));
	257	EXC_TRACEBACK_F(generator) = EXC_TRACEBACK(thread_state);
	258	Py_XINCREF(EXC_TRACEBACK_F(generator));
	259	}
	260
	261	#endif
	262
	263	// Framed code:
	264	{
	265	PyObject *tmp_expression_name_1;
	266	NUITKA_MAY_BE_UNUSED PyObject *tmp_yield_result_1;
	267	tmp_expression_name_1 = mod_consts[2];
	268	Py_INCREF(tmp_expression_name_1);
	269	generator->m_yield_return_index = 1;
	270	return tmp_expression_name_1;
	271	yield_return_1:
	272	if (yield_return_value == NULL) {
	273	assert(ERROR_OCCURRED());
	274
	275	FETCH_ERROR_OCCURRED(&generator_heap->exception_type, &generator_heap->exception_value, &generator_heap->exception_tb);
	276
	277
	278	generator_heap->exception_lineno = 27;
	279
	280	goto frame_exception_exit_1;
	281	}
	282	tmp_yield_result_1 = yield_return_value;
	283	}
	284
	285	Nuitka_Frame_MarkAsNotExecuting(generator->m_frame);
	286
	287	#if PYTHON_VERSION >= 0x300
	288	Py_CLEAR(EXC_TYPE_F(generator));
	289	Py_CLEAR(EXC_VALUE_F(generator));
	290	Py_CLEAR(EXC_TRACEBACK_F(generator));
	291	#endif
	292
	293	// Allow re-use of the frame again.
	294	Py_DECREF(generator->m_frame);
	295	goto frame_no_exception_1;
	296
	297	frame_exception_exit_1:;
	298
	299	// If it's not an exit exception, consider and create a traceback for it.
	300	if (!EXCEPTION_MATCH_GENERATOR(generator_heap->exception_type)) {
	301	if (generator_heap->exception_tb == NULL) {
	302	generator_heap->exception_tb = MAKE_TRACEBACK(generator->m_frame, generator_heap->exception_lineno);
	303	} else if (generator_heap->exception_tb->tb_frame != &generator->m_frame->m_frame) {
	304	generator_heap->exception_tb = ADD_TRACEBACK(generator_heap->exception_tb, generator->m_frame, generator_heap->exception_lineno);
	305	}
	306
	307	Nuitka_Frame_AttachLocals(
	308	generator->m_frame,
	309	generator_heap->type_description_1
	310	);
	311
	312
	313	// Release cached frame if used for exception.
	314	if (generator->m_frame == cache_m_frame) {
	315	#if _DEBUG_REFCOUNTS
	316	count_active_frame_cache_instances -= 1;
	317	count_released_frame_cache_instances += 1;
	318	#endif
	319
	320	Py_DECREF(cache_m_frame);
	321	cache_m_frame = NULL;
	322	}
	323
	324	assertFrameObject(generator->m_frame);
	325	}
	326
	327	#if PYTHON_VERSION >= 0x300
	328	Py_CLEAR(EXC_TYPE_F(generator));
	329	Py_CLEAR(EXC_VALUE_F(generator));
	330	Py_CLEAR(EXC_TRACEBACK_F(generator));
	331	#endif
	332
	333	Py_DECREF(generator->m_frame);
	334
	335	// Return the error.
	336	goto function_exception_exit;
	337
	338	frame_no_exception_1:;
	339
	340
	341	return NULL;
	342
	343	function_exception_exit:
	344	assert(generator_heap->exception_type);
	345	RESTORE_ERROR_OCCURRED(generator_heap->exception_type, generator_heap->exception_value, generator_heap->exception_tb);
	346
	347	return NULL;
	348
	349	}
	350
	351	static PyObject *MAKE_GENERATOR___main__$$$function__1_calledRepeatedly$$$function__1_empty$$$genobj__1_empty() {
	352	return Nuitka_Generator_New(
	353	__main__$$$function__1_calledRepeatedly$$$function__1_empty$$$genobj__1_empty_context,
	354	module___main__,
	355	mod_consts[0],
	356	#if PYTHON_VERSION >= 0x350
	357	mod_consts[1],
	358	#endif
	359	codeobj_a8b80aaace1ce49e8c63e1c3a78b0f95,
	360	NULL,
	361	0,
	362	sizeof(struct __main__$$$function__1_calledRepeatedly$$$function__1_empty$$$genobj__1_empty_locals)
	363	);
	364	}
	365
	366
	367			85
	368	static PyObject *MAKE_FUNCTION___main__$$$function__1_calledRepeatedly() {		86	static PyObject *MAKE_FUNCTION___main__$$$function__1_calledRepeatedly() {
	369	struct Nuitka_FunctionObject *result = Nuitka_Function_New(		87	struct Nuitka_FunctionObject *result = Nuitka_Function_New(
n	370	impl___main__$$$function__1_calledRepeatedly,	n	88	NULL,
	371	mod_consts[9],		89	mod_consts[7],
	372	#if PYTHON_VERSION >= 0x300		90	#if PYTHON_VERSION >= 0x300
	373	NULL,		91	NULL,
	374	#endif		92	#endif
	375	codeobj_857b7d96b5b0e69e205af2cecc9c0ea9,		93	codeobj_857b7d96b5b0e69e205af2cecc9c0ea9,
	376	NULL,		94	NULL,
	381	module___main__,		99	module___main__,
	382	NULL,		100	NULL,
	383	NULL,		101	NULL,
	384	0		102	0
	385	);		103	);
n	386		n	104	Nuitka_Function_EnableConstReturnGeneric(result, mod_consts[6]);
	387
	388	return (PyObject *)result;
	389	}
	390
	391
	392
	393	static PyObject *MAKE_FUNCTION___main__$$$function__1_calledRepeatedly$$$function__1_empty() {
	394	struct Nuitka_FunctionObject *result = Nuitka_Function_New(
	395	impl___main__$$$function__1_calledRepeatedly$$$function__1_empty,
	396	mod_consts[0],
	397	#if PYTHON_VERSION >= 0x300
	398	mod_consts[1],
	399	#endif
	400	codeobj_a8b80aaace1ce49e8c63e1c3a78b0f95,
	401	NULL,
	402	#if PYTHON_VERSION >= 0x300
	403	NULL,
	404	NULL,
	405	#endif
	406	module___main__,
	407	NULL,
	408	NULL,
	409	0
	410	);
	411
	412			105
	413	return (PyObject *)result;		106	return (PyObject *)result;
	414	}		107	}
	415			108
	416			109
	426	// Provide a way to create find a function via its C code and create it back		119	// Provide a way to create find a function via its C code and create it back
	427	// in another process, useful for multiprocessing extensions like dill		120	// in another process, useful for multiprocessing extensions like dill
	428	extern void registerDillPluginTables(char const module_name, PyMethodDef reduce_compiled_function, PyMethodDef *create_compiled_function);		121	extern void registerDillPluginTables(char const module_name, PyMethodDef reduce_compiled_function, PyMethodDef *create_compiled_function);
	429			122
	430	function_impl_code functable___main__[] = {		123	function_impl_code functable___main__[] = {
n	431	impl___main__$$$function__1_calledRepeatedly$$$function__1_empty,	n	124	NULL,
	432	impl___main__$$$function__1_calledRepeatedly,
	433	NULL		125	NULL
	434	};		126	};
	435			127
	436	static char const *_reduce_compiled_function_argnames[] = {		128	static char const *_reduce_compiled_function_argnames[] = {
	437	"func",		129	"func",
	774			466
	775	// Module code.		467	// Module code.
	776	{		468	{
	777	PyObject *tmp_assign_source_1;		469	PyObject *tmp_assign_source_1;
	778	tmp_assign_source_1 = Py_None;		470	tmp_assign_source_1 = Py_None;
n	779	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[3], tmp_assign_source_1);	n	471	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[0], tmp_assign_source_1);
	780	}		472	}
	781	{		473	{
	782	PyObject *tmp_assign_source_2;		474	PyObject *tmp_assign_source_2;
n	783	tmp_assign_source_2 = mod_consts[4];	n	475	tmp_assign_source_2 = mod_consts[1];
	784	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[5], tmp_assign_source_2);		476	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[2], tmp_assign_source_2);
	785	}		477	}
	786	{		478	{
	787	PyObject *tmp_assign_source_3;		479	PyObject *tmp_assign_source_3;
	788	tmp_assign_source_3 = Py_None;		480	tmp_assign_source_3 = Py_None;
n	789	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[6], tmp_assign_source_3);	n	481	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[3], tmp_assign_source_3);
	790	}		482	}
	791	{		483	{
	792	PyObject *tmp_assign_source_4;		484	PyObject *tmp_assign_source_4;
	793	tmp_assign_source_4 = PyDict_New();		485	tmp_assign_source_4 = PyDict_New();
n	794	UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[7], tmp_assign_source_4);	n	486	UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[4], tmp_assign_source_4);
	795	}		487	}
	796	{		488	{
	797	PyObject *tmp_assign_source_5;		489	PyObject *tmp_assign_source_5;
	798	tmp_assign_source_5 = Py_None;		490	tmp_assign_source_5 = Py_None;
n	799	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[8], tmp_assign_source_5);	n	491	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[5], tmp_assign_source_5);
	800	}		492	}
	801	{		493	{
	802	PyObject *tmp_assign_source_6;		494	PyObject *tmp_assign_source_6;
	803			495
	804			496
	805	tmp_assign_source_6 = MAKE_FUNCTION___main__$$$function__1_calledRepeatedly();		497	tmp_assign_source_6 = MAKE_FUNCTION___main__$$$function__1_calledRepeatedly();
	806			498
n	807	UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[9], tmp_assign_source_6);	n	499	UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[7], tmp_assign_source_6);
	808	}		500	}
	809	{		501	{
	810	PyObject *tmp_assign_source_7;		502	PyObject *tmp_assign_source_7;
	811	PyObject *tmp_name_name_1;		503	PyObject *tmp_name_name_1;
	812	PyObject *tmp_globals_arg_name_1;		504	PyObject *tmp_globals_arg_name_1;
	813	PyObject *tmp_locals_arg_name_1;		505	PyObject *tmp_locals_arg_name_1;
	814	PyObject *tmp_fromlist_name_1;		506	PyObject *tmp_fromlist_name_1;
	815	PyObject *tmp_level_name_1;		507	PyObject *tmp_level_name_1;
n	816	tmp_name_name_1 = mod_consts[10];	n	508	tmp_name_name_1 = mod_consts[8];
	817	tmp_globals_arg_name_1 = (PyObject *)moduledict___main__;		509	tmp_globals_arg_name_1 = (PyObject *)moduledict___main__;
	818	tmp_locals_arg_name_1 = Py_None;		510	tmp_locals_arg_name_1 = Py_None;
	819	tmp_fromlist_name_1 = Py_None;		511	tmp_fromlist_name_1 = Py_None;
n	820	tmp_level_name_1 = mod_consts[11];	n	512	tmp_level_name_1 = mod_consts[9];
	821	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);		513	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);
	822	assert(!(tmp_assign_source_7 == NULL));		514	assert(!(tmp_assign_source_7 == NULL));
n	823	UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[10], tmp_assign_source_7);	n	515	UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[8], tmp_assign_source_7);
	824	}		516	}
	825	// Frame without reuse.		517	// Frame without reuse.
	826	frame_b5d4cadc1cbd82f0425a8267dd24d2ca = MAKE_MODULE_FRAME(codeobj_b5d4cadc1cbd82f0425a8267dd24d2ca, module___main__);		518	frame_b5d4cadc1cbd82f0425a8267dd24d2ca = MAKE_MODULE_FRAME(codeobj_b5d4cadc1cbd82f0425a8267dd24d2ca, module___main__);
	827			519
	828	// Push the new frame as the currently active one, and we should be exclusively		520	// Push the new frame as the currently active one, and we should be exclusively
	833	// Framed code:		525	// Framed code:
	834	{		526	{
	835	PyObject *tmp_assign_source_8;		527	PyObject *tmp_assign_source_8;
	836	PyObject *tmp_iter_arg_1;		528	PyObject *tmp_iter_arg_1;
	837	PyObject *tmp_called_instance_1;		529	PyObject *tmp_called_instance_1;
n	838	tmp_called_instance_1 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[10]);	n	530	tmp_called_instance_1 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[8]);
	839			531
	840	if (unlikely(tmp_called_instance_1 == NULL)) {		532	if (unlikely(tmp_called_instance_1 == NULL)) {
n	841	tmp_called_instance_1 = GET_MODULE_VARIABLE_VALUE_FALLBACK(mod_consts[10]);	n	533	tmp_called_instance_1 = GET_MODULE_VARIABLE_VALUE_FALLBACK(mod_consts[8]);
	842	}		534	}
	843			535
	844	assert(!(tmp_called_instance_1 == NULL));		536	assert(!(tmp_called_instance_1 == NULL));
	845	frame_b5d4cadc1cbd82f0425a8267dd24d2ca->m_frame.f_lineno = 36;		537	frame_b5d4cadc1cbd82f0425a8267dd24d2ca->m_frame.f_lineno = 36;
	846	tmp_iter_arg_1 = CALL_METHOD_WITH_ARGS2(		538	tmp_iter_arg_1 = CALL_METHOD_WITH_ARGS2(
	847	tmp_called_instance_1,		539	tmp_called_instance_1,
n	848	mod_consts[12],	n	540	mod_consts[10],
	849	&PyTuple_GET_ITEM(mod_consts[13], 0)		541	&PyTuple_GET_ITEM(mod_consts[11], 0)
	850	);		542	);
	851			543
	852	if (tmp_iter_arg_1 == NULL) {		544	if (tmp_iter_arg_1 == NULL) {
	853	assert(ERROR_OCCURRED());		545	assert(ERROR_OCCURRED());
	854			546
	904	}		596	}
	905	{		597	{
	906	PyObject *tmp_assign_source_10;		598	PyObject *tmp_assign_source_10;
	907	CHECK_OBJECT(tmp_for_loop_1__iter_value);		599	CHECK_OBJECT(tmp_for_loop_1__iter_value);
	908	tmp_assign_source_10 = tmp_for_loop_1__iter_value;		600	tmp_assign_source_10 = tmp_for_loop_1__iter_value;
n	909	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[14], tmp_assign_source_10);	n	601	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[12], tmp_assign_source_10);
	910	}		602	}
	911	{		603	{
	912	PyObject *tmp_called_name_1;		604	PyObject *tmp_called_name_1;
	913	PyObject *tmp_call_result_1;		605	PyObject *tmp_call_result_1;
n	914	tmp_called_name_1 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[9]);	n	606	tmp_called_name_1 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[7]);
	915			607
	916	if (unlikely(tmp_called_name_1 == NULL)) {		608	if (unlikely(tmp_called_name_1 == NULL)) {
n	917	tmp_called_name_1 = GET_MODULE_VARIABLE_VALUE_FALLBACK(mod_consts[9]);	n	609	tmp_called_name_1 = GET_MODULE_VARIABLE_VALUE_FALLBACK(mod_consts[7]);
	918	}		610	}
	919			611
	920	if (tmp_called_name_1 == NULL) {		612	if (tmp_called_name_1 == NULL) {
	921	assert(ERROR_OCCURRED());		613	assert(ERROR_OCCURRED());
	922			614
	983	Py_XDECREF(tmp_for_loop_1__for_iterator);		675	Py_XDECREF(tmp_for_loop_1__for_iterator);
	984	tmp_for_loop_1__for_iterator = NULL;		676	tmp_for_loop_1__for_iterator = NULL;
	985	{		677	{
	986	PyObject *tmp_called_name_2;		678	PyObject *tmp_called_name_2;
	987	PyObject *tmp_call_result_2;		679	PyObject *tmp_call_result_2;
n	988	tmp_called_name_2 = LOOKUP_BUILTIN(mod_consts[15]);	n	680	tmp_called_name_2 = LOOKUP_BUILTIN(mod_consts[13]);
	989	assert(tmp_called_name_2 != NULL);		681	assert(tmp_called_name_2 != NULL);
	990	frame_b5d4cadc1cbd82f0425a8267dd24d2ca->m_frame.f_lineno = 39;		682	frame_b5d4cadc1cbd82f0425a8267dd24d2ca->m_frame.f_lineno = 39;
t	991	tmp_call_result_2 = CALL_FUNCTION_WITH_SINGLE_ARG(tmp_called_name_2, mod_consts[16]);	t	683	tmp_call_result_2 = CALL_FUNCTION_WITH_SINGLE_ARG(tmp_called_name_2, mod_consts[14]);
	992	if (tmp_call_result_2 == NULL) {		684	if (tmp_call_result_2 == NULL) {
	993	assert(ERROR_OCCURRED());		685	assert(ERROR_OCCURRED());
	994			686
	995	FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);		687	FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
	996			688