Construct FunctionCreationGeneratorLocal

Kay Hayen

2013-08-15 08:15

Performance Diagrams

Source Code with Construct

module_var = None

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



    return empty


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

print("OK.")

Source Code without Construct

module_var = None

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


# construct_alternative
    empty = 1
# construct_end

    return empty


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

print("OK.")

Context Diff of Source Code

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

Context Diff of Generated Code

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