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[18];	n	36	static PyObject *mod_consts[16];
	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__", 18);	n	45	loadConstantsBlob(&mod_consts[0], "__main__", 16);
	46			46
	47	constants_created = true;		47	constants_created = true;
	48	}		48	}
	49			49
	50	/* For multiprocessing, we want to be able to initialize the __main__ constants. */		50	/* For multiprocessing, we want to be able to initialize the __main__ constants. */
	58	#ifndef __NUITKA_NO_ASSERT__		58	#ifndef __NUITKA_NO_ASSERT__
	59	void checkModuleConstants___main__(void) {		59	void checkModuleConstants___main__(void) {
	60	// The module may not have been used at all, then ignore this.		60	// The module may not have been used at all, then ignore this.
	61	if (constants_created == false) return;		61	if (constants_created == false) return;
	62			62
n	63	checkConstantsBlob(&mod_consts[0], "__main__", 18);	n	63	checkConstantsBlob(&mod_consts[0], "__main__", 16);
	64	}		64	}
	65	#endif		65	#endif
	66			66
	67	// The module code objects.		67	// The module code objects.
	68	static PyCodeObject *codeobj_1b668ba03b46c40bbfd07633e286d2c2;		68	static PyCodeObject *codeobj_1b668ba03b46c40bbfd07633e286d2c2;
	69	static PyCodeObject *codeobj_540f5583231358dedc042e899801d940;		69	static PyCodeObject *codeobj_540f5583231358dedc042e899801d940;
n	70	static PyCodeObject *codeobj_81ef52d15720a47c85670c6504350aee;	n
	71	/* For use in "MainProgram.c". */		70	/* For use in "MainProgram.c". */
	72	PyCodeObject *codeobj_main = NULL;		71	PyCodeObject *codeobj_main = NULL;
	73			72
	74	static void createModuleCodeObjects(void) {		73	static void createModuleCodeObjects(void) {
n	75	module_filename_obj = mod_consts[4]; CHECK_OBJECT(module_filename_obj);	n	74	module_filename_obj = mod_consts[1]; CHECK_OBJECT(module_filename_obj);
	76	codeobj_1b668ba03b46c40bbfd07633e286d2c2 = MAKE_CODEOBJECT(module_filename_obj, 1, CO_NOFREE, mod_consts[16], NULL, NULL, 0, 0, 0);		75	codeobj_1b668ba03b46c40bbfd07633e286d2c2 = MAKE_CODEOBJECT(module_filename_obj, 1, CO_NOFREE, mod_consts[14], NULL, NULL, 0, 0, 0);
	77	codeobj_540f5583231358dedc042e899801d940 = MAKE_CODEOBJECT(module_filename_obj, 23, CO_OPTIMIZED \| CO_NEWLOCALS \| CO_NOFREE, mod_consts[8], mod_consts[17], NULL, 0, 0, 0);		76	codeobj_540f5583231358dedc042e899801d940 = MAKE_CODEOBJECT(module_filename_obj, 23, CO_OPTIMIZED \| CO_NEWLOCALS \| CO_NOFREE, mod_consts[6], mod_consts[15], NULL, 0, 0, 0);
	78	codeobj_81ef52d15720a47c85670c6504350aee = MAKE_CODEOBJECT(module_filename_obj, 26, CO_GENERATOR \| CO_OPTIMIZED \| CO_NEWLOCALS \| CO_NOFREE, mod_consts[0], NULL, NULL, 0, 0, 0);
	79	}		77	}
	80			78
	81	// The module function declarations.		79	// The module function declarations.
n	82	static PyObject *MAKE_GENERATOR___main__$$$function__1_calledRepeatedly$$$function__1_empty$$$genobj__1_empty();	n
	83
	84
	85	static PyObject *MAKE_FUNCTION___main__$$$function__1_calledRepeatedly();		80	static PyObject *MAKE_FUNCTION___main__$$$function__1_calledRepeatedly();
	86			81
	87			82
n	88	static PyObject *MAKE_FUNCTION___main__$$$function__1_calledRepeatedly$$$function__1_empty();	n
	89
	90
	91	// The module function definitions.		83	// The module function definitions.
n	92	static PyObject impl___main__$$$function__1_calledRepeatedly(struct Nuitka_FunctionObject const self, PyObject **python_pars) {	n
	93	// Preserve error status for checks
	94	#ifndef __NUITKA_NO_ASSERT__
	95	NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED();
	96	#endif
	97
	98	// Local variable declarations.
	99	PyObject *var_empty = NULL;
	100	PyObject *tmp_return_value = NULL;
	101
	102	// Actual function body.
	103	{
	104	PyObject *tmp_assign_source_1;
	105
	106
	107	tmp_assign_source_1 = MAKE_FUNCTION___main__$$$function__1_calledRepeatedly$$$function__1_empty();
	108
	109	assert(var_empty == NULL);
	110	var_empty = tmp_assign_source_1;
	111	}
	112	// Tried code:
	113	CHECK_OBJECT(var_empty);
	114	tmp_return_value = var_empty;
	115	Py_INCREF(tmp_return_value);
	116	goto try_return_handler_1;
	117	NUITKA_CANNOT_GET_HERE("tried codes exits in all cases");
	118	return NULL;
	119	// Return handler code:
	120	try_return_handler_1:;
	121	CHECK_OBJECT(var_empty);
	122	Py_DECREF(var_empty);
	123	var_empty = NULL;
	124	goto function_return_exit;
	125	// End of try:
	126
	127	NUITKA_CANNOT_GET_HERE("Return statement must have exited already.");
	128	return NULL;
	129
	130
	131	function_return_exit:
	132	// Function cleanup code if any.
	133
	134
	135	// Actual function exit with return value, making sure we did not make
	136	// the error status worse despite non-NULL return.
	137	CHECK_OBJECT(tmp_return_value);
	138	assert(had_error \|\| !ERROR_OCCURRED());
	139	return tmp_return_value;
	140	}
	141
	142
	143	static PyObject impl___main__$$$function__1_calledRepeatedly$$$function__1_empty(struct Nuitka_FunctionObject const self, PyObject **python_pars) {
	144	// Preserve error status for checks
	145	#ifndef __NUITKA_NO_ASSERT__
	146	NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED();
	147	#endif
	148
	149	// Local variable declarations.
	150	PyObject *tmp_return_value = NULL;
	151
	152	// Actual function body.
	153
	154
	155	tmp_return_value = MAKE_GENERATOR___main__$$$function__1_calledRepeatedly$$$function__1_empty$$$genobj__1_empty();
	156
	157	goto function_return_exit;
	158
	159	NUITKA_CANNOT_GET_HERE("Return statement must have exited already.");
	160	return NULL;
	161
	162
	163	function_return_exit:
	164	// Function cleanup code if any.
	165
	166
	167	// Actual function exit with return value, making sure we did not make
	168	// the error status worse despite non-NULL return.
	169	CHECK_OBJECT(tmp_return_value);
	170	assert(had_error \|\| !ERROR_OCCURRED());
	171	return tmp_return_value;
	172	}
	173
	174
	175
	176	struct __main__$$$function__1_calledRepeatedly$$$function__1_empty$$$genobj__1_empty_locals {
	177	char const *type_description_1;
	178	PyObject *exception_type;
	179	PyObject *exception_value;
	180	PyTracebackObject *exception_tb;
	181	int exception_lineno;
	182	};
	183
	184	static PyObject __main__$$$function__1_calledRepeatedly$$$function__1_empty$$$genobj__1_empty_context(struct Nuitka_GeneratorObject generator, PyObject *yield_return_value) {
	185	CHECK_OBJECT(generator);
	186	assert(Nuitka_Generator_Check((PyObject *)generator));
	187	CHECK_OBJECT_X(yield_return_value);
	188
	189	// Heap access if used.
	190	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;
	191
	192	// Dispatch to yield based on return label index:
	193	switch(generator->m_yield_return_index) {
	194	case 1: goto yield_return_1;
	195	}
	196
	197	// Local variable initialization
	198	NUITKA_MAY_BE_UNUSED nuitka_void tmp_unused;
	199	static struct Nuitka_FrameObject *cache_m_frame = NULL;
	200	generator_heap->type_description_1 = NULL;
	201	generator_heap->exception_type = NULL;
	202	generator_heap->exception_value = NULL;
	203	generator_heap->exception_tb = NULL;
	204	generator_heap->exception_lineno = 0;
	205
	206	// Actual generator function body.
	207	if (isFrameUnusable(cache_m_frame)) {
	208	Py_XDECREF(cache_m_frame);
	209
	210	#if _DEBUG_REFCOUNTS
	211	if (cache_m_frame == NULL) {
	212	count_active_frame_cache_instances += 1;
	213	} else {
	214	count_released_frame_cache_instances += 1;
	215	}
	216	count_allocated_frame_cache_instances += 1;
	217	#endif
	218	cache_m_frame = MAKE_FUNCTION_FRAME(codeobj_81ef52d15720a47c85670c6504350aee, module___main__, 0);
	219	#if _DEBUG_REFCOUNTS
	220	} else {
	221	count_hit_frame_cache_instances += 1;
	222	#endif
	223	}
	224	generator->m_frame = cache_m_frame;
	225
	226	// Mark the frame object as in use, ref count 1 will be up for reuse.
	227	Py_INCREF(generator->m_frame);
	228	assert(Py_REFCNT(generator->m_frame) == 2); // Frame stack
	229
	230	#if PYTHON_VERSION >= 0x340
	231	generator->m_frame->m_frame.f_gen = (PyObject *)generator;
	232	#endif
	233
	234	assert(generator->m_frame->m_frame.f_back == NULL);
	235	Py_CLEAR(generator->m_frame->m_frame.f_back);
	236
	237	generator->m_frame->m_frame.f_back = PyThreadState_GET()->frame;
	238	Py_INCREF(generator->m_frame->m_frame.f_back);
	239
	240	PyThreadState_GET()->frame = &generator->m_frame->m_frame;
	241	Py_INCREF(generator->m_frame);
	242
	243	Nuitka_Frame_MarkAsExecuting(generator->m_frame);
	244
	245	#if PYTHON_VERSION >= 0x300
	246	// Accept currently existing exception as the one to publish again when we
	247	// yield or yield from.
	248	{
	249	PyThreadState *thread_state = PyThreadState_GET();
	250
	251	EXC_TYPE_F(generator) = EXC_TYPE(thread_state);
	252	if (EXC_TYPE_F(generator) == Py_None) EXC_TYPE_F(generator) = NULL;
	253	Py_XINCREF(EXC_TYPE_F(generator));
	254	EXC_VALUE_F(generator) = EXC_VALUE(thread_state);
	255	Py_XINCREF(EXC_VALUE_F(generator));
	256	EXC_TRACEBACK_F(generator) = EXC_TRACEBACK(thread_state);
	257	Py_XINCREF(EXC_TRACEBACK_F(generator));
	258	}
	259
	260	#endif
	261
	262	// Framed code:
	263	{
	264	PyObject *tmp_expression_name_1;
	265	NUITKA_MAY_BE_UNUSED PyObject *tmp_yield_result_1;
	266	tmp_expression_name_1 = mod_consts[2];
	267	Py_INCREF(tmp_expression_name_1);
	268	generator->m_yield_return_index = 1;
	269	return tmp_expression_name_1;
	270	yield_return_1:
	271	if (yield_return_value == NULL) {
	272	assert(ERROR_OCCURRED());
	273
	274	FETCH_ERROR_OCCURRED(&generator_heap->exception_type, &generator_heap->exception_value, &generator_heap->exception_tb);
	275
	276
	277	generator_heap->exception_lineno = 27;
	278
	279	goto frame_exception_exit_1;
	280	}
	281	tmp_yield_result_1 = yield_return_value;
	282	}
	283
	284	Nuitka_Frame_MarkAsNotExecuting(generator->m_frame);
	285
	286	#if PYTHON_VERSION >= 0x300
	287	Py_CLEAR(EXC_TYPE_F(generator));
	288	Py_CLEAR(EXC_VALUE_F(generator));
	289	Py_CLEAR(EXC_TRACEBACK_F(generator));
	290	#endif
	291
	292	// Allow re-use of the frame again.
	293	Py_DECREF(generator->m_frame);
	294	goto frame_no_exception_1;
	295
	296	frame_exception_exit_1:;
	297
	298	// If it's not an exit exception, consider and create a traceback for it.
	299	if (!EXCEPTION_MATCH_GENERATOR(generator_heap->exception_type)) {
	300	if (generator_heap->exception_tb == NULL) {
	301	generator_heap->exception_tb = MAKE_TRACEBACK(generator->m_frame, generator_heap->exception_lineno);
	302	} else if (generator_heap->exception_tb->tb_frame != &generator->m_frame->m_frame) {
	303	generator_heap->exception_tb = ADD_TRACEBACK(generator_heap->exception_tb, generator->m_frame, generator_heap->exception_lineno);
	304	}
	305
	306	Nuitka_Frame_AttachLocals(
	307	generator->m_frame,
	308	generator_heap->type_description_1
	309	);
	310
	311
	312	// Release cached frame if used for exception.
	313	if (generator->m_frame == cache_m_frame) {
	314	#if _DEBUG_REFCOUNTS
	315	count_active_frame_cache_instances -= 1;
	316	count_released_frame_cache_instances += 1;
	317	#endif
	318
	319	Py_DECREF(cache_m_frame);
	320	cache_m_frame = NULL;
	321	}
	322
	323	assertFrameObject(generator->m_frame);
	324	}
	325
	326	#if PYTHON_VERSION >= 0x300
	327	Py_CLEAR(EXC_TYPE_F(generator));
	328	Py_CLEAR(EXC_VALUE_F(generator));
	329	Py_CLEAR(EXC_TRACEBACK_F(generator));
	330	#endif
	331
	332	Py_DECREF(generator->m_frame);
	333
	334	// Return the error.
	335	goto function_exception_exit;
	336
	337	frame_no_exception_1:;
	338
	339
	340	return NULL;
	341
	342	function_exception_exit:
	343	assert(generator_heap->exception_type);
	344	RESTORE_ERROR_OCCURRED(generator_heap->exception_type, generator_heap->exception_value, generator_heap->exception_tb);
	345
	346	return NULL;
	347
	348	}
	349
	350	static PyObject *MAKE_GENERATOR___main__$$$function__1_calledRepeatedly$$$function__1_empty$$$genobj__1_empty() {
	351	return Nuitka_Generator_New(
	352	__main__$$$function__1_calledRepeatedly$$$function__1_empty$$$genobj__1_empty_context,
	353	module___main__,
	354	mod_consts[0],
	355	#if PYTHON_VERSION >= 0x350
	356	mod_consts[1],
	357	#endif
	358	codeobj_81ef52d15720a47c85670c6504350aee,
	359	NULL,
	360	0,
	361	sizeof(struct __main__$$$function__1_calledRepeatedly$$$function__1_empty$$$genobj__1_empty_locals)
	362	);
	363	}
	364
	365
	366			84
	367	static PyObject *MAKE_FUNCTION___main__$$$function__1_calledRepeatedly() {		85	static PyObject *MAKE_FUNCTION___main__$$$function__1_calledRepeatedly() {
	368	struct Nuitka_FunctionObject *result = Nuitka_Function_New(		86	struct Nuitka_FunctionObject *result = Nuitka_Function_New(
n	369	impl___main__$$$function__1_calledRepeatedly,	n	87	NULL,
	370	mod_consts[8],		88	mod_consts[6],
	371	#if PYTHON_VERSION >= 0x300		89	#if PYTHON_VERSION >= 0x300
	372	NULL,		90	NULL,
	373	#endif		91	#endif
	374	codeobj_540f5583231358dedc042e899801d940,		92	codeobj_540f5583231358dedc042e899801d940,
	375	NULL,		93	NULL,
	380	module___main__,		98	module___main__,
	381	NULL,		99	NULL,
	382	NULL,		100	NULL,
	383	0		101	0
	384	);		102	);
n	385		n	103	Nuitka_Function_EnableConstReturnGeneric(result, mod_consts[5]);
	386
	387	return (PyObject *)result;
	388	}
	389
	390
	391
	392	static PyObject *MAKE_FUNCTION___main__$$$function__1_calledRepeatedly$$$function__1_empty() {
	393	struct Nuitka_FunctionObject *result = Nuitka_Function_New(
	394	impl___main__$$$function__1_calledRepeatedly$$$function__1_empty,
	395	mod_consts[0],
	396	#if PYTHON_VERSION >= 0x300
	397	mod_consts[1],
	398	#endif
	399	codeobj_81ef52d15720a47c85670c6504350aee,
	400	NULL,
	401	#if PYTHON_VERSION >= 0x300
	402	NULL,
	403	NULL,
	404	#endif
	405	module___main__,
	406	NULL,
	407	NULL,
	408	0
	409	);
	410
	411			104
	412	return (PyObject *)result;		105	return (PyObject *)result;
	413	}		106	}
	414			107
	415			108
	424	#ifdef _NUITKA_PLUGIN_DILL_ENABLED		117	#ifdef _NUITKA_PLUGIN_DILL_ENABLED
	425	// Provide a way to create find a function via its C code and create it back		118	// Provide a way to create find a function via its C code and create it back
	426	// in another process, useful for multiprocessing extensions like dill		119	// in another process, useful for multiprocessing extensions like dill
	427			120
	428	function_impl_code functable___main__[] = {		121	function_impl_code functable___main__[] = {
n	429	impl___main__$$$function__1_calledRepeatedly$$$function__1_empty,	n	122	NULL,
	430	impl___main__$$$function__1_calledRepeatedly,
	431	NULL		123	NULL
	432	};		124	};
	433			125
	434	static char const *_reduce_compiled_function_argnames[] = {		126	static char const *_reduce_compiled_function_argnames[] = {
	435	"func",		127	"func",
	801			493
	802	// Module code.		494	// Module code.
	803	{		495	{
	804	PyObject *tmp_assign_source_1;		496	PyObject *tmp_assign_source_1;
	805	tmp_assign_source_1 = Py_None;		497	tmp_assign_source_1 = Py_None;
n	806	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[3], tmp_assign_source_1);	n	498	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[0], tmp_assign_source_1);
	807	}		499	}
	808	{		500	{
	809	PyObject *tmp_assign_source_2;		501	PyObject *tmp_assign_source_2;
n	810	tmp_assign_source_2 = mod_consts[4];	n	502	tmp_assign_source_2 = mod_consts[1];
	811	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[5], tmp_assign_source_2);		503	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[2], tmp_assign_source_2);
	812	}		504	}
	813	{		505	{
	814	PyObject *tmp_assign_source_3;		506	PyObject *tmp_assign_source_3;
	815	tmp_assign_source_3 = Py_None;		507	tmp_assign_source_3 = Py_None;
n	816	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[6], tmp_assign_source_3);	n	508	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[3], tmp_assign_source_3);
	817	}		509	}
	818	{		510	{
	819	PyObject *tmp_assign_source_4;		511	PyObject *tmp_assign_source_4;
	820	tmp_assign_source_4 = Py_None;		512	tmp_assign_source_4 = Py_None;
n	821	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[7], tmp_assign_source_4);	n	513	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[4], tmp_assign_source_4);
	822	}		514	}
	823	{		515	{
	824	PyObject *tmp_assign_source_5;		516	PyObject *tmp_assign_source_5;
	825			517
	826			518
	827	tmp_assign_source_5 = MAKE_FUNCTION___main__$$$function__1_calledRepeatedly();		519	tmp_assign_source_5 = MAKE_FUNCTION___main__$$$function__1_calledRepeatedly();
	828			520
n	829	UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[8], tmp_assign_source_5);	n	521	UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[6], tmp_assign_source_5);
	830	}		522	}
	831	{		523	{
	832	PyObject *tmp_assign_source_6;		524	PyObject *tmp_assign_source_6;
	833	PyObject *tmp_name_name_1;		525	PyObject *tmp_name_name_1;
	834	PyObject *tmp_globals_arg_name_1;		526	PyObject *tmp_globals_arg_name_1;
	835	PyObject *tmp_locals_arg_name_1;		527	PyObject *tmp_locals_arg_name_1;
	836	PyObject *tmp_fromlist_name_1;		528	PyObject *tmp_fromlist_name_1;
	837	PyObject *tmp_level_name_1;		529	PyObject *tmp_level_name_1;
n	838	tmp_name_name_1 = mod_consts[9];	n	530	tmp_name_name_1 = mod_consts[7];
	839	tmp_globals_arg_name_1 = (PyObject *)moduledict___main__;		531	tmp_globals_arg_name_1 = (PyObject *)moduledict___main__;
	840	tmp_locals_arg_name_1 = Py_None;		532	tmp_locals_arg_name_1 = Py_None;
	841	tmp_fromlist_name_1 = Py_None;		533	tmp_fromlist_name_1 = Py_None;
n	842	tmp_level_name_1 = mod_consts[10];	n	534	tmp_level_name_1 = mod_consts[8];
	843	tmp_assign_source_6 = IMPORT_MODULE5(tmp_name_name_1, tmp_globals_arg_name_1, tmp_locals_arg_name_1, tmp_fromlist_name_1, tmp_level_name_1);		535	tmp_assign_source_6 = IMPORT_MODULE5(tmp_name_name_1, tmp_globals_arg_name_1, tmp_locals_arg_name_1, tmp_fromlist_name_1, tmp_level_name_1);
	844	assert(!(tmp_assign_source_6 == NULL));		536	assert(!(tmp_assign_source_6 == NULL));
n	845	UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[9], tmp_assign_source_6);	n	537	UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[7], tmp_assign_source_6);
	846	}		538	}
	847	// Frame without reuse.		539	// Frame without reuse.
	848	frame_1b668ba03b46c40bbfd07633e286d2c2 = MAKE_MODULE_FRAME(codeobj_1b668ba03b46c40bbfd07633e286d2c2, module___main__);		540	frame_1b668ba03b46c40bbfd07633e286d2c2 = MAKE_MODULE_FRAME(codeobj_1b668ba03b46c40bbfd07633e286d2c2, module___main__);
	849			541
	850	// Push the new frame as the currently active one, and we should be exclusively		542	// Push the new frame as the currently active one, and we should be exclusively
	855	// Framed code:		547	// Framed code:
	856	{		548	{
	857	PyObject *tmp_assign_source_7;		549	PyObject *tmp_assign_source_7;
	858	PyObject *tmp_iter_arg_1;		550	PyObject *tmp_iter_arg_1;
	859	PyObject *tmp_called_instance_1;		551	PyObject *tmp_called_instance_1;
n	860	tmp_called_instance_1 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[9]);	n	552	tmp_called_instance_1 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[7]);
	861			553
	862	if (unlikely(tmp_called_instance_1 == NULL)) {		554	if (unlikely(tmp_called_instance_1 == NULL)) {
n	863	tmp_called_instance_1 = GET_MODULE_VARIABLE_VALUE_FALLBACK(mod_consts[9]);	n	555	tmp_called_instance_1 = GET_MODULE_VARIABLE_VALUE_FALLBACK(mod_consts[7]);
	864	}		556	}
	865			557
	866	assert(!(tmp_called_instance_1 == NULL));		558	assert(!(tmp_called_instance_1 == NULL));
	867	frame_1b668ba03b46c40bbfd07633e286d2c2->m_frame.f_lineno = 36;		559	frame_1b668ba03b46c40bbfd07633e286d2c2->m_frame.f_lineno = 36;
n	868	tmp_iter_arg_1 = CALL_METHOD_WITH_ARGS2(tmp_called_instance_1, mod_consts[11], &PyTuple_GET_ITEM(mod_consts[12], 0));	n	560	tmp_iter_arg_1 = CALL_METHOD_WITH_ARGS2(tmp_called_instance_1, mod_consts[9], &PyTuple_GET_ITEM(mod_consts[10], 0));
	869			561
	870	if (tmp_iter_arg_1 == NULL) {		562	if (tmp_iter_arg_1 == NULL) {
	871	assert(ERROR_OCCURRED());		563	assert(ERROR_OCCURRED());
	872			564
	873	FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);		565	FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
	922	}		614	}
	923	{		615	{
	924	PyObject *tmp_assign_source_9;		616	PyObject *tmp_assign_source_9;
	925	CHECK_OBJECT(tmp_for_loop_1__iter_value);		617	CHECK_OBJECT(tmp_for_loop_1__iter_value);
	926	tmp_assign_source_9 = tmp_for_loop_1__iter_value;		618	tmp_assign_source_9 = tmp_for_loop_1__iter_value;
n	927	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[13], tmp_assign_source_9);	n	619	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[11], tmp_assign_source_9);
	928	}		620	}
	929	{		621	{
	930	PyObject *tmp_called_name_1;		622	PyObject *tmp_called_name_1;
	931	PyObject *tmp_call_result_1;		623	PyObject *tmp_call_result_1;
n	932	tmp_called_name_1 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[8]);	n	624	tmp_called_name_1 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[6]);
	933			625
	934	if (unlikely(tmp_called_name_1 == NULL)) {		626	if (unlikely(tmp_called_name_1 == NULL)) {
n	935	tmp_called_name_1 = GET_MODULE_VARIABLE_VALUE_FALLBACK(mod_consts[8]);	n	627	tmp_called_name_1 = GET_MODULE_VARIABLE_VALUE_FALLBACK(mod_consts[6]);
	936	}		628	}
	937			629
	938	if (tmp_called_name_1 == NULL) {		630	if (tmp_called_name_1 == NULL) {
	939	assert(ERROR_OCCURRED());		631	assert(ERROR_OCCURRED());
	940			632
	1001	Py_XDECREF(tmp_for_loop_1__for_iterator);		693	Py_XDECREF(tmp_for_loop_1__for_iterator);
	1002	tmp_for_loop_1__for_iterator = NULL;		694	tmp_for_loop_1__for_iterator = NULL;
	1003	{		695	{
	1004	PyObject *tmp_called_name_2;		696	PyObject *tmp_called_name_2;
	1005	PyObject *tmp_call_result_2;		697	PyObject *tmp_call_result_2;
n	1006	tmp_called_name_2 = LOOKUP_BUILTIN(mod_consts[14]);	n	698	tmp_called_name_2 = LOOKUP_BUILTIN(mod_consts[12]);
	1007	assert(tmp_called_name_2 != NULL);		699	assert(tmp_called_name_2 != NULL);
	1008	frame_1b668ba03b46c40bbfd07633e286d2c2->m_frame.f_lineno = 39;		700	frame_1b668ba03b46c40bbfd07633e286d2c2->m_frame.f_lineno = 39;
t	1009	tmp_call_result_2 = CALL_FUNCTION_WITH_SINGLE_ARG(tmp_called_name_2, mod_consts[15]);	t	701	tmp_call_result_2 = CALL_FUNCTION_WITH_SINGLE_ARG(tmp_called_name_2, mod_consts[13]);
	1010	if (tmp_call_result_2 == NULL) {		702	if (tmp_call_result_2 == NULL) {
	1011	assert(ERROR_OCCURRED());		703	assert(ERROR_OCCURRED());
	1012			704
	1013	FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);		705	FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
	1014			706