Construct CallUncompiledFunctionComplexArgs

Kay Hayen

2024-04-25 12:37

Performance Diagrams

Source Code with Construct    # being optimized separately.

    # Force a frame for now.
    args = a

    # construct_begin
    python_f(3, *args)
    # construct_alternative



    return python_f, args


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

print("OK.")

#     Python test originally created or extracted from other peoples work. The
#     parts from me are licensed as below. It is at least Free Software where
#     it's copied from other people. In these cases, that will normally be
#     indicated.
#
#     Licensed under the Apache License, Version 2.0 (the "License");
#     you may not use this file except in compliance with the License.
#     You may obtain a copy of the License at
#
#         http://www.apache.org/licenses/LICENSE-2.0
#
#     Unless required by applicable law or agreed to in writing, software
#     distributed under the License is distributed on an "AS IS" BASIS,
#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#     See the License for the specific language governing permissions and
#     limitations under the License.

Source Code without Construct    # being optimized separately.

    # Force a frame for now.
    args = a

    # construct_begin

    # construct_alternative
    pass
    # construct_end

    return python_f, args


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

print("OK.")

#     Python test originally created or extracted from other peoples work. The
#     parts from me are licensed as below. It is at least Free Software where
#     it's copied from other people. In these cases, that will normally be
#     indicated.
#
#     Licensed under the Apache License, Version 2.0 (the "License");
#     you may not use this file except in compliance with the License.
#     You may obtain a copy of the License at
#
#         http://www.apache.org/licenses/LICENSE-2.0
#
#     Unless required by applicable law or agreed to in writing, software
#     distributed under the License is distributed on an "AS IS" BASIS,
#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#     See the License for the specific language governing permissions and
#     limitations under the License.

Context Diff of Source Code

	Construct			Baseline
	21			21
	22	# Force a frame for now.		22	# Force a frame for now.
	23	args = a		23	args = a
	24			24
	25	# construct_begin		25	# construct_begin
n	26	python_f(3, *args)	n	26
	27	# construct_alternative		27	# construct_alternative
t	28		t	28	pass
	29			29	# construct_end
	30			30
	31	return python_f, args		31	return python_f, args
	32			32
	33			33
	34	for x in itertools.repeat(None, 50000):		34	for x in itertools.repeat(None, 50000):

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[27];	n	36	static PyObject *mod_consts[19];
	37	#ifndef __NUITKA_NO_ASSERT__		37	#ifndef __NUITKA_NO_ASSERT__
n	38	static Py_hash_t mod_consts_hash[27];	n	38	static Py_hash_t mod_consts_hash[19];
	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(tstate, &mod_consts[0], UNTRANSLATE("__main__"));		49	loadConstantsBlob(tstate, &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 < 27; i++) {	n	53	for (int i = 0; i < 19; i++) {
	54	mod_consts_hash[i] = DEEP_HASH(tstate, mod_consts[i]);		54	mod_consts_hash[i] = DEEP_HASH(tstate, 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__(PyThreadState *tstate) {		69	void checkModuleConstants___main__(PyThreadState *tstate) {
	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 < 27; i++) {	n	73	for (int i = 0; i < 19; i++) {
	74	assert(mod_consts_hash[i] == DEEP_HASH(tstate, mod_consts[i]));		74	assert(mod_consts_hash[i] == DEEP_HASH(tstate, 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
	82	static PyCodeObject *codeobj_1b2ff76acce51bb1a893f908d5e99c62;		82	static PyCodeObject *codeobj_1b2ff76acce51bb1a893f908d5e99c62;
	83	/* For use in "MainProgram.c". */		83	/* For use in "MainProgram.c". */
	84	PyCodeObject *codeobj_main = NULL;		84	PyCodeObject *codeobj_main = NULL;
	85			85
	86	static void createModuleCodeObjects(void) {		86	static void createModuleCodeObjects(void) {
n	87	module_filename_obj = mod_consts[10]; CHECK_OBJECT(module_filename_obj);	n	87	module_filename_obj = mod_consts[2]; CHECK_OBJECT(module_filename_obj);
	88	codeobj_e7c9e3d4dd54f3b4308eb955790d80b8 = MAKE_CODE_OBJECT(module_filename_obj, 1, CO_NOFREE \| CO_FUTURE_PRINT_FUNCTION, mod_consts[25], mod_consts[25], NULL, NULL, 0, 0, 0);		88	codeobj_e7c9e3d4dd54f3b4308eb955790d80b8 = MAKE_CODE_OBJECT(module_filename_obj, 1, CO_NOFREE \| CO_FUTURE_PRINT_FUNCTION, mod_consts[17], mod_consts[17], NULL, NULL, 0, 0, 0);
	89	codeobj_main = codeobj_e7c9e3d4dd54f3b4308eb955790d80b8;		89	codeobj_main = codeobj_e7c9e3d4dd54f3b4308eb955790d80b8;
n	90	codeobj_1b2ff76acce51bb1a893f908d5e99c62 = MAKE_CODE_OBJECT(module_filename_obj, 18, CO_OPTIMIZED \| CO_NEWLOCALS \| CO_NOFREE \| CO_FUTURE_PRINT_FUNCTION, mod_consts[18], mod_consts[18], mod_consts[26], NULL, 1, 0, 0);	n	90	codeobj_1b2ff76acce51bb1a893f908d5e99c62 = MAKE_CODE_OBJECT(module_filename_obj, 18, CO_OPTIMIZED \| CO_NEWLOCALS \| CO_NOFREE \| CO_FUTURE_PRINT_FUNCTION, mod_consts[10], mod_consts[10], mod_consts[18], NULL, 1, 0, 0);
	91	}		91	}
	92			92
	93	// The module function declarations.		93	// The module function declarations.
n	94	NUITKA_LOCAL_MODULE PyObject impl___main__$$$function__1_complex_call_helper_pos_star_list(PyThreadState tstate, PyObject **python_pars);	n
	95
	96
	97	NUITKA_LOCAL_MODULE PyObject impl___main__$$$function__2_get_callable_name_desc(PyThreadState tstate, PyObject **python_pars);
	98
	99
	100	static PyObject *MAKE_FUNCTION___main__$$$function__1_calledRepeatedly();		94	static PyObject *MAKE_FUNCTION___main__$$$function__1_calledRepeatedly();
	101			95
	102			96
	103	// The module function definitions.		97	// The module function definitions.
	104	static PyObject impl___main__$$$function__1_calledRepeatedly(PyThreadState tstate, struct Nuitka_FunctionObject const self, PyObject *python_pars) {		98	static PyObject impl___main__$$$function__1_calledRepeatedly(PyThreadState tstate, struct Nuitka_FunctionObject const self, PyObject *python_pars) {
	114	NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL;		108	NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL;
	115	PyObject *exception_type = NULL;		109	PyObject *exception_type = NULL;
	116	PyObject *exception_value = NULL;		110	PyObject *exception_value = NULL;
	117	PyTracebackObject *exception_tb = NULL;		111	PyTracebackObject *exception_tb = NULL;
	118	NUITKA_MAY_BE_UNUSED int exception_lineno = 0;		112	NUITKA_MAY_BE_UNUSED int exception_lineno = 0;
n	119	NUITKA_MAY_BE_UNUSED nuitka_void tmp_unused;	n
	120	static struct Nuitka_FrameObject *cache_frame_1b2ff76acce51bb1a893f908d5e99c62 = NULL;		113	static struct Nuitka_FrameObject *cache_frame_1b2ff76acce51bb1a893f908d5e99c62 = NULL;
	121	PyObject *tmp_return_value = NULL;		114	PyObject *tmp_return_value = NULL;
	122	PyObject *exception_keeper_type_1;		115	PyObject *exception_keeper_type_1;
	123	PyObject *exception_keeper_value_1;		116	PyObject *exception_keeper_value_1;
	124	PyTracebackObject *exception_keeper_tb_1;		117	PyTracebackObject *exception_keeper_tb_1;
	172	goto frame_exception_exit_1;		165	goto frame_exception_exit_1;
	173	}		166	}
	174	assert(var_args == NULL);		167	assert(var_args == NULL);
	175	Py_INCREF(tmp_assign_source_1);		168	Py_INCREF(tmp_assign_source_1);
	176	var_args = tmp_assign_source_1;		169	var_args = tmp_assign_source_1;
n	177	}	n
	178	{
	179	PyObject *tmp_dircall_arg1_1;
	180	PyObject *tmp_dircall_arg2_1;
	181	PyObject *tmp_dircall_arg3_1;
	182	PyObject *tmp_call_result_1;
	183	CHECK_OBJECT(par_python_f);
	184	tmp_dircall_arg1_1 = par_python_f;
	185	tmp_dircall_arg2_1 = mod_consts[1];
	186	CHECK_OBJECT(var_args);
	187	tmp_dircall_arg3_1 = var_args;
	188	Py_INCREF(tmp_dircall_arg1_1);
	189	Py_INCREF(tmp_dircall_arg2_1);
	190	Py_INCREF(tmp_dircall_arg3_1);
	191
	192	{
	193	PyObject *dir_call_args[] = {tmp_dircall_arg1_1, tmp_dircall_arg2_1, tmp_dircall_arg3_1};
	194	tmp_call_result_1 = impl___main__$$$function__1_complex_call_helper_pos_star_list(tstate, dir_call_args);
	195	}
	196	if (tmp_call_result_1 == NULL) {
	197	assert(HAS_ERROR_OCCURRED(tstate));
	198
	199	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	200
	201
	202	exception_lineno = 26;
	203	type_description_1 = "oo";
	204	goto frame_exception_exit_1;
	205	}
	206	Py_DECREF(tmp_call_result_1);
	207	}		170	}
	208			171
	209			172
	210	// Put the previous frame back on top.		173	// Put the previous frame back on top.
	211	popFrameStack(tstate);		174	popFrameStack(tstate);
	275	exception_type = NULL;		238	exception_type = NULL;
	276	exception_value = NULL;		239	exception_value = NULL;
	277	exception_tb = NULL;		240	exception_tb = NULL;
	278	exception_lineno = 0;		241	exception_lineno = 0;
	279			242
n	280	Py_XDECREF(var_args);	n
	281	var_args = NULL;
	282	// Re-raise.		243	// Re-raise.
	283	exception_type = exception_keeper_type_1;		244	exception_type = exception_keeper_type_1;
	284	exception_value = exception_keeper_value_1;		245	exception_value = exception_keeper_value_1;
	285	exception_tb = exception_keeper_tb_1;		246	exception_tb = exception_keeper_tb_1;
	286	exception_lineno = exception_keeper_lineno_1;		247	exception_lineno = exception_keeper_lineno_1;
	310	assert(had_error \|\| !HAS_ERROR_OCCURRED(tstate));		271	assert(had_error \|\| !HAS_ERROR_OCCURRED(tstate));
	311	return tmp_return_value;		272	return tmp_return_value;
	312	}		273	}
	313			274
	314			275
n	315	NUITKA_LOCAL_MODULE PyObject impl___main__$$$function__1_complex_call_helper_pos_star_list(PyThreadState tstate, PyObject **python_pars) {	n
	316	#ifndef __NUITKA_NO_ASSERT__
	317	NUITKA_MAY_BE_UNUSED bool had_error = HAS_ERROR_OCCURRED(tstate);
	318	assert(!had_error); // Do not enter inlined functions with error set.
	319	#endif
	320
	321	// Local variable declarations.
	322	PyObject *par_called = python_pars[0];
	323	PyObject *par_args = python_pars[1];
	324	PyObject *par_star_arg_list = python_pars[2];
	325	PyObject *exception_type = NULL;
	326	PyObject *exception_value = NULL;
	327	PyTracebackObject *exception_tb = NULL;
	328	NUITKA_MAY_BE_UNUSED int exception_lineno = 0;
	329	PyObject *exception_keeper_type_1;
	330	PyObject *exception_keeper_value_1;
	331	PyTracebackObject *exception_keeper_tb_1;
	332	NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1;
	333	int tmp_res;
	334	PyObject *tmp_return_value = NULL;
	335
	336	// Actual function body.
	337	{
	338	bool tmp_condition_result_1;
	339	PyObject *tmp_cmp_expr_left_1;
	340	PyObject *tmp_cmp_expr_right_1;
	341	PyObject *tmp_type_arg_1;
	342	CHECK_OBJECT(par_star_arg_list);
	343	tmp_type_arg_1 = par_star_arg_list;
	344	tmp_cmp_expr_left_1 = BUILTIN_TYPE1(tmp_type_arg_1);
	345	assert(!(tmp_cmp_expr_left_1 == NULL));
	346	tmp_cmp_expr_right_1 = (PyObject *)&PyTuple_Type;
	347	tmp_condition_result_1 = (tmp_cmp_expr_left_1 != tmp_cmp_expr_right_1) ? true : false;
	348	Py_DECREF(tmp_cmp_expr_left_1);
	349	if (tmp_condition_result_1 != false) {
	350	goto branch_yes_1;
	351	} else {
	352	goto branch_no_1;
	353	}
	354	}
	355	branch_yes_1:;
	356	// Tried code:
	357	{
	358	PyObject *tmp_assign_source_1;
	359	PyObject *tmp_tuple_arg_1;
	360	CHECK_OBJECT(par_star_arg_list);
	361	tmp_tuple_arg_1 = par_star_arg_list;
	362	tmp_assign_source_1 = PySequence_Tuple(tmp_tuple_arg_1);
	363	if (tmp_assign_source_1 == NULL) {
	364	assert(HAS_ERROR_OCCURRED(tstate));
	365
	366	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	367
	368
	369
	370
	371	goto try_except_handler_1;
	372	}
	373	{
	374	PyObject *old = par_star_arg_list;
	375	assert(old != NULL);
	376	par_star_arg_list = tmp_assign_source_1;
	377	Py_DECREF(old);
	378	}
	379
	380	}
	381	goto try_end_1;
	382	// Exception handler code:
	383	try_except_handler_1:;
	384	exception_keeper_type_1 = exception_type;
	385	exception_keeper_value_1 = exception_value;
	386	exception_keeper_tb_1 = exception_tb;
	387	exception_keeper_lineno_1 = exception_lineno;
	388	exception_type = NULL;
	389	exception_value = NULL;
	390	exception_tb = NULL;
	391	exception_lineno = 0;
	392
	393	{
	394	bool tmp_condition_result_2;
	395	PyObject *tmp_cmp_expr_left_2;
	396	PyObject *tmp_cmp_expr_right_2;
	397	tmp_cmp_expr_left_2 = exception_keeper_type_1;
	398	tmp_cmp_expr_right_2 = PyExc_TypeError;
	399	tmp_res = EXCEPTION_MATCH_BOOL(tstate, tmp_cmp_expr_left_2, tmp_cmp_expr_right_2);
	400	assert(!(tmp_res == -1));
	401	tmp_condition_result_2 = (tmp_res != 0) ? true : false;
	402	if (tmp_condition_result_2 != false) {
	403	goto branch_yes_2;
	404	} else {
	405	goto branch_no_2;
	406	}
	407	}
	408	branch_yes_2:;
	409	{
	410	PyObject *tmp_raise_type_1;
	411	PyObject *tmp_make_exception_arg_1;
	412	PyObject *tmp_mod_expr_left_1;
	413	PyObject *tmp_mod_expr_right_1;
	414	PyObject *tmp_tuple_element_1;
	415	PyObject *tmp_dircall_arg1_1;
	416	tmp_mod_expr_left_1 = mod_consts[2];
	417	CHECK_OBJECT(par_called);
	418	tmp_dircall_arg1_1 = par_called;
	419	Py_INCREF(tmp_dircall_arg1_1);
	420
	421	{
	422	PyObject *dir_call_args[] = {tmp_dircall_arg1_1};
	423	tmp_tuple_element_1 = impl___main__$$$function__2_get_callable_name_desc(tstate, dir_call_args);
	424	}
	425	if (tmp_tuple_element_1 == NULL) {
	426	assert(HAS_ERROR_OCCURRED(tstate));
	427
	428	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	429
	430	Py_DECREF(exception_keeper_type_1);
	431	Py_XDECREF(exception_keeper_value_1);
	432	Py_XDECREF(exception_keeper_tb_1);
	433
	434
	435
	436	goto function_exception_exit;
	437	}
	438	tmp_mod_expr_right_1 = MAKE_TUPLE_EMPTY(2);
	439	{
	440	PyObject *tmp_expression_value_1;
	441	PyObject *tmp_type_arg_2;
	442	PyTuple_SET_ITEM(tmp_mod_expr_right_1, 0, tmp_tuple_element_1);
	443	CHECK_OBJECT(par_star_arg_list);
	444	tmp_type_arg_2 = par_star_arg_list;
	445	tmp_expression_value_1 = BUILTIN_TYPE1(tmp_type_arg_2);
	446	assert(!(tmp_expression_value_1 == NULL));
	447	tmp_tuple_element_1 = LOOKUP_ATTRIBUTE(tstate, tmp_expression_value_1, mod_consts[3]);
	448	Py_DECREF(tmp_expression_value_1);
	449	if (tmp_tuple_element_1 == NULL) {
	450	assert(HAS_ERROR_OCCURRED(tstate));
	451
	452	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	453
	454	Py_DECREF(exception_keeper_type_1);
	455	Py_XDECREF(exception_keeper_value_1);
	456	Py_XDECREF(exception_keeper_tb_1);
	457
	458
	459
	460	goto tuple_build_exception_1;
	461	}
	462	PyTuple_SET_ITEM(tmp_mod_expr_right_1, 1, tmp_tuple_element_1);
	463	}
	464	goto tuple_build_noexception_1;
	465	// Exception handling pass through code for tuple_build:
	466	tuple_build_exception_1:;
	467	Py_DECREF(tmp_mod_expr_right_1);
	468	Py_DECREF(exception_keeper_type_1);
	469	Py_XDECREF(exception_keeper_value_1);
	470	Py_XDECREF(exception_keeper_tb_1);
	471	goto function_exception_exit;
	472	// Finished with no exception for tuple_build:
	473	tuple_build_noexception_1:;
	474	tmp_make_exception_arg_1 = BINARY_OPERATION_MOD_OBJECT_STR_TUPLE(tmp_mod_expr_left_1, tmp_mod_expr_right_1);
	475	Py_DECREF(tmp_mod_expr_right_1);
	476	if (tmp_make_exception_arg_1 == NULL) {
	477	assert(HAS_ERROR_OCCURRED(tstate));
	478
	479	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	480
	481	Py_DECREF(exception_keeper_type_1);
	482	Py_XDECREF(exception_keeper_value_1);
	483	Py_XDECREF(exception_keeper_tb_1);
	484
	485
	486
	487	goto function_exception_exit;
	488	}
	489	tmp_raise_type_1 = CALL_FUNCTION_WITH_SINGLE_ARG(tstate, PyExc_TypeError, tmp_make_exception_arg_1);
	490	Py_DECREF(tmp_make_exception_arg_1);
	491	assert(!(tmp_raise_type_1 == NULL));
	492	exception_type = tmp_raise_type_1;
	493	RAISE_EXCEPTION_WITH_TYPE(tstate, &exception_type, &exception_value, &exception_tb);
	494
	495	goto function_exception_exit;
	496	}
	497	goto branch_end_2;
	498	branch_no_2:;
	499	// Re-raise.
	500	exception_type = exception_keeper_type_1;
	501	exception_value = exception_keeper_value_1;
	502	exception_tb = exception_keeper_tb_1;
	503	exception_lineno = exception_keeper_lineno_1;
	504
	505	goto function_exception_exit;
	506	branch_end_2:;
	507	// End of try:
	508	try_end_1:;
	509	branch_no_1:;
	510	{
	511	PyObject *tmp_called_value_1;
	512	PyObject *tmp_args_value_1;
	513	PyObject *tmp_add_expr_left_1;
	514	PyObject *tmp_add_expr_right_1;
	515	CHECK_OBJECT(par_called);
	516	tmp_called_value_1 = par_called;
	517	CHECK_OBJECT(par_args);
	518	tmp_add_expr_left_1 = par_args;
	519	CHECK_OBJECT(par_star_arg_list);
	520	tmp_add_expr_right_1 = par_star_arg_list;
	521	tmp_args_value_1 = BINARY_OPERATION_ADD_OBJECT_OBJECT_OBJECT(tmp_add_expr_left_1, tmp_add_expr_right_1);
	522	if (tmp_args_value_1 == NULL) {
	523	assert(HAS_ERROR_OCCURRED(tstate));
	524
	525	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	526
	527
	528
	529
	530	goto function_exception_exit;
	531	}
	532	tmp_return_value = CALL_FUNCTION_WITH_POSARGS(tstate, tmp_called_value_1, tmp_args_value_1);
	533	Py_DECREF(tmp_args_value_1);
	534	if (tmp_return_value == NULL) {
	535	assert(HAS_ERROR_OCCURRED(tstate));
	536
	537	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	538
	539
	540
	541
	542	goto function_exception_exit;
	543	}
	544	goto function_return_exit;
	545	}
	546
	547	NUITKA_CANNOT_GET_HERE("Return statement must have exited already.");
	548	return NULL;
	549
	550	function_exception_exit:
	551	CHECK_OBJECT(par_called);
	552	Py_DECREF(par_called);
	553	CHECK_OBJECT(par_args);
	554	Py_DECREF(par_args);
	555	CHECK_OBJECT(par_star_arg_list);
	556	Py_DECREF(par_star_arg_list);
	557	assert(exception_type);
	558	RESTORE_ERROR_OCCURRED(tstate, exception_type, exception_value, exception_tb);
	559
	560	return NULL;
	561
	562	function_return_exit:
	563	// Function cleanup code if any.
	564	CHECK_OBJECT(par_called);
	565	Py_DECREF(par_called);
	566	CHECK_OBJECT(par_args);
	567	Py_DECREF(par_args);
	568	CHECK_OBJECT(par_star_arg_list);
	569	Py_DECREF(par_star_arg_list);
	570
	571	// Actual function exit with return value, making sure we did not make
	572	// the error status worse despite non-NULL return.
	573	CHECK_OBJECT(tmp_return_value);
	574	assert(had_error \|\| !HAS_ERROR_OCCURRED(tstate));
	575	return tmp_return_value;
	576	}
	577
	578
	579	NUITKA_LOCAL_MODULE PyObject impl___main__$$$function__2_get_callable_name_desc(PyThreadState tstate, PyObject **python_pars) {
	580	#ifndef __NUITKA_NO_ASSERT__
	581	NUITKA_MAY_BE_UNUSED bool had_error = HAS_ERROR_OCCURRED(tstate);
	582	assert(!had_error); // Do not enter inlined functions with error set.
	583	#endif
	584
	585	// Local variable declarations.
	586	PyObject *par_called = python_pars[0];
	587	int tmp_res;
	588	PyObject *exception_type = NULL;
	589	PyObject *exception_value = NULL;
	590	PyTracebackObject *exception_tb = NULL;
	591	NUITKA_MAY_BE_UNUSED int exception_lineno = 0;
	592	PyObject *tmp_return_value = NULL;
	593
	594	// Actual function body.
	595	{
	596	nuitka_bool tmp_condition_result_1;
	597	PyObject *tmp_isinstance_inst_1;
	598	PyObject *tmp_isinstance_cls_1;
	599	CHECK_OBJECT(par_called);
	600	tmp_isinstance_inst_1 = par_called;
	601	tmp_isinstance_cls_1 = mod_consts[4];
	602	tmp_res = PyObject_IsInstance(tmp_isinstance_inst_1, tmp_isinstance_cls_1);
	603	if (tmp_res == -1) {
	604	assert(HAS_ERROR_OCCURRED(tstate));
	605
	606	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	607
	608
	609
	610
	611	goto function_exception_exit;
	612	}
	613	tmp_condition_result_1 = (tmp_res != 0) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
	614	if (tmp_condition_result_1 == NUITKA_BOOL_TRUE) {
	615	goto branch_yes_1;
	616	} else {
	617	goto branch_no_1;
	618	}
	619	}
	620	branch_yes_1:;
	621	{
	622	PyObject *tmp_add_expr_left_1;
	623	PyObject *tmp_add_expr_right_1;
	624	PyObject *tmp_expression_value_1;
	625	CHECK_OBJECT(par_called);
	626	tmp_expression_value_1 = par_called;
	627	tmp_add_expr_left_1 = LOOKUP_ATTRIBUTE(tstate, tmp_expression_value_1, mod_consts[3]);
	628	if (tmp_add_expr_left_1 == NULL) {
	629	assert(HAS_ERROR_OCCURRED(tstate));
	630
	631	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	632
	633
	634
	635
	636	goto function_exception_exit;
	637	}
	638	tmp_add_expr_right_1 = mod_consts[5];
	639	tmp_return_value = BINARY_OPERATION_ADD_OBJECT_OBJECT_STR(tmp_add_expr_left_1, tmp_add_expr_right_1);
	640	Py_DECREF(tmp_add_expr_left_1);
	641	if (tmp_return_value == NULL) {
	642	assert(HAS_ERROR_OCCURRED(tstate));
	643
	644	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	645
	646
	647
	648
	649	goto function_exception_exit;
	650	}
	651	goto function_return_exit;
	652	}
	653	goto branch_end_1;
	654	branch_no_1:;
	655	{
	656	nuitka_bool tmp_condition_result_2;
	657	PyObject *tmp_isinstance_inst_2;
	658	PyObject *tmp_isinstance_cls_2;
	659	CHECK_OBJECT(par_called);
	660	tmp_isinstance_inst_2 = par_called;
	661	tmp_isinstance_cls_2 = (PyObject *)&PyClass_Type;
	662	tmp_res = PyObject_IsInstance(tmp_isinstance_inst_2, tmp_isinstance_cls_2);
	663	if (tmp_res == -1) {
	664	assert(HAS_ERROR_OCCURRED(tstate));
	665
	666	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	667
	668
	669
	670
	671	goto function_exception_exit;
	672	}
	673	tmp_condition_result_2 = (tmp_res != 0) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
	674	if (tmp_condition_result_2 == NUITKA_BOOL_TRUE) {
	675	goto branch_yes_2;
	676	} else {
	677	goto branch_no_2;
	678	}
	679	}
	680	branch_yes_2:;
	681	{
	682	PyObject *tmp_add_expr_left_2;
	683	PyObject *tmp_add_expr_right_2;
	684	PyObject *tmp_expression_value_2;
	685	CHECK_OBJECT(par_called);
	686	tmp_expression_value_2 = par_called;
	687	tmp_add_expr_left_2 = LOOKUP_ATTRIBUTE(tstate, tmp_expression_value_2, mod_consts[3]);
	688	if (tmp_add_expr_left_2 == NULL) {
	689	assert(HAS_ERROR_OCCURRED(tstate));
	690
	691	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	692
	693
	694
	695
	696	goto function_exception_exit;
	697	}
	698	tmp_add_expr_right_2 = mod_consts[6];
	699	tmp_return_value = BINARY_OPERATION_ADD_OBJECT_OBJECT_STR(tmp_add_expr_left_2, tmp_add_expr_right_2);
	700	Py_DECREF(tmp_add_expr_left_2);
	701	if (tmp_return_value == NULL) {
	702	assert(HAS_ERROR_OCCURRED(tstate));
	703
	704	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	705
	706
	707
	708
	709	goto function_exception_exit;
	710	}
	711	goto function_return_exit;
	712	}
	713	goto branch_end_2;
	714	branch_no_2:;
	715	{
	716	nuitka_bool tmp_condition_result_3;
	717	PyObject *tmp_isinstance_inst_3;
	718	PyObject *tmp_isinstance_cls_3;
	719	CHECK_OBJECT(par_called);
	720	tmp_isinstance_inst_3 = par_called;
	721	tmp_isinstance_cls_3 = (PyObject *)&PyInstance_Type;
	722	tmp_res = PyObject_IsInstance(tmp_isinstance_inst_3, tmp_isinstance_cls_3);
	723	if (tmp_res == -1) {
	724	assert(HAS_ERROR_OCCURRED(tstate));
	725
	726	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	727
	728
	729
	730
	731	goto function_exception_exit;
	732	}
	733	tmp_condition_result_3 = (tmp_res != 0) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
	734	if (tmp_condition_result_3 == NUITKA_BOOL_TRUE) {
	735	goto branch_yes_3;
	736	} else {
	737	goto branch_no_3;
	738	}
	739	}
	740	branch_yes_3:;
	741	{
	742	PyObject *tmp_add_expr_left_3;
	743	PyObject *tmp_add_expr_right_3;
	744	PyObject *tmp_expression_value_3;
	745	PyObject *tmp_expression_value_4;
	746	CHECK_OBJECT(par_called);
	747	tmp_expression_value_4 = par_called;
	748	tmp_expression_value_3 = LOOKUP_ATTRIBUTE_CLASS_SLOT(tstate, tmp_expression_value_4);
	749	if (tmp_expression_value_3 == NULL) {
	750	assert(HAS_ERROR_OCCURRED(tstate));
	751
	752	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	753
	754
	755
	756
	757	goto function_exception_exit;
	758	}
	759	tmp_add_expr_left_3 = LOOKUP_ATTRIBUTE(tstate, tmp_expression_value_3, mod_consts[3]);
	760	Py_DECREF(tmp_expression_value_3);
	761	if (tmp_add_expr_left_3 == NULL) {
	762	assert(HAS_ERROR_OCCURRED(tstate));
	763
	764	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	765
	766
	767
	768
	769	goto function_exception_exit;
	770	}
	771	tmp_add_expr_right_3 = mod_consts[7];
	772	tmp_return_value = BINARY_OPERATION_ADD_OBJECT_OBJECT_STR(tmp_add_expr_left_3, tmp_add_expr_right_3);
	773	Py_DECREF(tmp_add_expr_left_3);
	774	if (tmp_return_value == NULL) {
	775	assert(HAS_ERROR_OCCURRED(tstate));
	776
	777	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	778
	779
	780
	781
	782	goto function_exception_exit;
	783	}
	784	goto function_return_exit;
	785	}
	786	goto branch_end_3;
	787	branch_no_3:;
	788	{
	789	PyObject *tmp_add_expr_left_4;
	790	PyObject *tmp_add_expr_right_4;
	791	PyObject *tmp_expression_value_5;
	792	PyObject *tmp_type_arg_1;
	793	CHECK_OBJECT(par_called);
	794	tmp_type_arg_1 = par_called;
	795	tmp_expression_value_5 = BUILTIN_TYPE1(tmp_type_arg_1);
	796	assert(!(tmp_expression_value_5 == NULL));
	797	tmp_add_expr_left_4 = LOOKUP_ATTRIBUTE(tstate, tmp_expression_value_5, mod_consts[3]);
	798	Py_DECREF(tmp_expression_value_5);
	799	if (tmp_add_expr_left_4 == NULL) {
	800	assert(HAS_ERROR_OCCURRED(tstate));
	801
	802	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	803
	804
	805
	806
	807	goto function_exception_exit;
	808	}
	809	tmp_add_expr_right_4 = mod_consts[8];
	810	tmp_return_value = BINARY_OPERATION_ADD_OBJECT_OBJECT_STR(tmp_add_expr_left_4, tmp_add_expr_right_4);
	811	Py_DECREF(tmp_add_expr_left_4);
	812	if (tmp_return_value == NULL) {
	813	assert(HAS_ERROR_OCCURRED(tstate));
	814
	815	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	816
	817
	818
	819
	820	goto function_exception_exit;
	821	}
	822	goto function_return_exit;
	823	}
	824	branch_end_3:;
	825	branch_end_2:;
	826	branch_end_1:;
	827
	828	NUITKA_CANNOT_GET_HERE("Return statement must have exited already.");
	829	return NULL;
	830
	831	function_exception_exit:
	832	CHECK_OBJECT(par_called);
	833	Py_DECREF(par_called);
	834	assert(exception_type);
	835	RESTORE_ERROR_OCCURRED(tstate, exception_type, exception_value, exception_tb);
	836
	837	return NULL;
	838
	839	function_return_exit:
	840	// Function cleanup code if any.
	841	CHECK_OBJECT(par_called);
	842	Py_DECREF(par_called);
	843
	844	// Actual function exit with return value, making sure we did not make
	845	// the error status worse despite non-NULL return.
	846	CHECK_OBJECT(tmp_return_value);
	847	assert(had_error \|\| !HAS_ERROR_OCCURRED(tstate));
	848	return tmp_return_value;
	849	}
	850
	851
	852			276
	853	static PyObject *MAKE_FUNCTION___main__$$$function__1_calledRepeatedly() {		277	static PyObject *MAKE_FUNCTION___main__$$$function__1_calledRepeatedly() {
	854	struct Nuitka_FunctionObject *result = Nuitka_Function_New(		278	struct Nuitka_FunctionObject *result = Nuitka_Function_New(
	855	impl___main__$$$function__1_calledRepeatedly,		279	impl___main__$$$function__1_calledRepeatedly,
n	856	mod_consts[18],	n	280	mod_consts[10],
	857	#if PYTHON_VERSION >= 0x300		281	#if PYTHON_VERSION >= 0x300
	858	NULL,		282	NULL,
	859	#endif		283	#endif
	860	codeobj_1b2ff76acce51bb1a893f908d5e99c62,		284	codeobj_1b2ff76acce51bb1a893f908d5e99c62,
	861	NULL,		285	NULL,
	1246			670
	1247	// Module code.		671	// Module code.
	1248	{		672	{
	1249	PyObject *tmp_assign_source_1;		673	PyObject *tmp_assign_source_1;
	1250	tmp_assign_source_1 = Py_None;		674	tmp_assign_source_1 = Py_None;
n	1251	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[9], tmp_assign_source_1);	n	675	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[1], tmp_assign_source_1);
	1252	}		676	}
	1253	{		677	{
	1254	PyObject *tmp_assign_source_2;		678	PyObject *tmp_assign_source_2;
n	1255	tmp_assign_source_2 = mod_consts[10];	n	679	tmp_assign_source_2 = mod_consts[2];
	1256	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[11], tmp_assign_source_2);		680	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[3], tmp_assign_source_2);
	1257	}		681	}
	1258	{		682	{
	1259	PyObject *tmp_assign_source_3;		683	PyObject *tmp_assign_source_3;
	1260	{		684	{
	1261	PyObject *hard_module = IMPORT_HARD___FUTURE__();		685	PyObject *hard_module = IMPORT_HARD___FUTURE__();
n	1262	tmp_assign_source_3 = LOOKUP_ATTRIBUTE(tstate, hard_module, mod_consts[12]);	n	686	tmp_assign_source_3 = LOOKUP_ATTRIBUTE(tstate, hard_module, mod_consts[4]);
	1263	}		687	}
	1264	assert(!(tmp_assign_source_3 == NULL));		688	assert(!(tmp_assign_source_3 == NULL));
n	1265	UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[12], tmp_assign_source_3);	n	689	UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[4], tmp_assign_source_3);
	1266	}		690	}
	1267	frame_e7c9e3d4dd54f3b4308eb955790d80b8 = MAKE_MODULE_FRAME(codeobj_e7c9e3d4dd54f3b4308eb955790d80b8, module___main__);		691	frame_e7c9e3d4dd54f3b4308eb955790d80b8 = MAKE_MODULE_FRAME(codeobj_e7c9e3d4dd54f3b4308eb955790d80b8, module___main__);
	1268			692
	1269	// Push the new frame as the currently active one, and we should be exclusively		693	// Push the new frame as the currently active one, and we should be exclusively
	1270	// owning it.		694	// owning it.
	1276	PyObject *tmp_assign_source_4;		700	PyObject *tmp_assign_source_4;
	1277	PyObject *tmp_name_value_1;		701	PyObject *tmp_name_value_1;
	1278	PyObject *tmp_globals_arg_value_1;		702	PyObject *tmp_globals_arg_value_1;
	1279	PyObject *tmp_locals_arg_value_1;		703	PyObject *tmp_locals_arg_value_1;
	1280	PyObject *tmp_fromlist_value_1;		704	PyObject *tmp_fromlist_value_1;
n	1281	tmp_name_value_1 = mod_consts[13];	n	705	tmp_name_value_1 = mod_consts[5];
	1282	tmp_globals_arg_value_1 = (PyObject *)moduledict___main__;		706	tmp_globals_arg_value_1 = (PyObject *)moduledict___main__;
	1283	tmp_locals_arg_value_1 = Py_None;		707	tmp_locals_arg_value_1 = Py_None;
	1284	tmp_fromlist_value_1 = Py_None;		708	tmp_fromlist_value_1 = Py_None;
	1285	frame_e7c9e3d4dd54f3b4308eb955790d80b8->m_frame.f_lineno = 6;		709	frame_e7c9e3d4dd54f3b4308eb955790d80b8->m_frame.f_lineno = 6;
	1286	tmp_assign_source_4 = IMPORT_MODULE4(tstate, tmp_name_value_1, tmp_globals_arg_value_1, tmp_locals_arg_value_1, tmp_fromlist_value_1);		710	tmp_assign_source_4 = IMPORT_MODULE4(tstate, tmp_name_value_1, tmp_globals_arg_value_1, tmp_locals_arg_value_1, tmp_fromlist_value_1);
	1292			716
	1293	exception_lineno = 6;		717	exception_lineno = 6;
	1294			718
	1295	goto frame_exception_exit_1;		719	goto frame_exception_exit_1;
	1296	}		720	}
n	1297	UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[13], tmp_assign_source_4);	n	721	UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[5], tmp_assign_source_4);
	1298	}		722	}
	1299	{		723	{
	1300	PyObject *tmp_assign_source_5;		724	PyObject *tmp_assign_source_5;
	1301	tmp_assign_source_5 = (PyObject *)moduledict___main__;		725	tmp_assign_source_5 = (PyObject *)moduledict___main__;
	1302	assert(tmp_exec_1__globals == NULL);		726	assert(tmp_exec_1__globals == NULL);
	1316	PyObject *tmp_exec_globals_1;		740	PyObject *tmp_exec_globals_1;
	1317	PyObject *tmp_exec_locals_1;		741	PyObject *tmp_exec_locals_1;
	1318	PyObject *tmp_exec_filename_1;		742	PyObject *tmp_exec_filename_1;
	1319	PyObject *tmp_exec_compiled_1;		743	PyObject *tmp_exec_compiled_1;
	1320	PyObject *tmp_exec_result_1;		744	PyObject *tmp_exec_result_1;
n	1321	tmp_exec_source_1 = mod_consts[14];	n	745	tmp_exec_source_1 = mod_consts[6];
	1322	CHECK_OBJECT(tmp_exec_1__globals);		746	CHECK_OBJECT(tmp_exec_1__globals);
	1323	tmp_exec_globals_1 = tmp_exec_1__globals;		747	tmp_exec_globals_1 = tmp_exec_1__globals;
	1324	CHECK_OBJECT(tmp_exec_1__locals);		748	CHECK_OBJECT(tmp_exec_1__locals);
	1325	tmp_exec_locals_1 = tmp_exec_1__locals;		749	tmp_exec_locals_1 = tmp_exec_1__locals;
n	1326	tmp_exec_filename_1 = mod_consts[15];	n	750	tmp_exec_filename_1 = mod_consts[7];
	1327	Py_INCREF(tmp_exec_filename_1);		751	Py_INCREF(tmp_exec_filename_1);
	1328	Py_INCREF(tmp_exec_source_1);		752	Py_INCREF(tmp_exec_source_1);
	1329	tmp_result = EXEC_FILE_ARG_HANDLING(tstate, &tmp_exec_source_1, &tmp_exec_filename_1);		753	tmp_result = EXEC_FILE_ARG_HANDLING(tstate, &tmp_exec_source_1, &tmp_exec_filename_1);
	1330	if (tmp_result == false) {		754	if (tmp_result == false) {
	1331	assert(HAS_ERROR_OCCURRED(tstate));		755	assert(HAS_ERROR_OCCURRED(tstate));
	1336			760
	1337	exception_lineno = 8;		761	exception_lineno = 8;
	1338			762
	1339	goto try_except_handler_1;		763	goto try_except_handler_1;
	1340	}		764	}
n	1341	tmp_exec_compiled_1 = COMPILE_CODE(tstate, tmp_exec_source_1, tmp_exec_filename_1, mod_consts[16], NULL, NULL);	n	765	tmp_exec_compiled_1 = COMPILE_CODE(tstate, tmp_exec_source_1, tmp_exec_filename_1, mod_consts[8], NULL, NULL);
	1342	Py_DECREF(tmp_exec_source_1);		766	Py_DECREF(tmp_exec_source_1);
	1343	Py_DECREF(tmp_exec_filename_1);		767	Py_DECREF(tmp_exec_filename_1);
	1344	if (tmp_exec_compiled_1 == NULL) {		768	if (tmp_exec_compiled_1 == NULL) {
	1345	assert(HAS_ERROR_OCCURRED(tstate));		769	assert(HAS_ERROR_OCCURRED(tstate));
	1346			770
	1398	CHECK_OBJECT(tmp_exec_1__locals);		822	CHECK_OBJECT(tmp_exec_1__locals);
	1399	Py_DECREF(tmp_exec_1__locals);		823	Py_DECREF(tmp_exec_1__locals);
	1400	tmp_exec_1__locals = NULL;		824	tmp_exec_1__locals = NULL;
	1401	{		825	{
	1402	PyObject *tmp_assign_source_7;		826	PyObject *tmp_assign_source_7;
n	1403	tmp_assign_source_7 = mod_consts[17];	n	827	tmp_assign_source_7 = mod_consts[9];
	1404	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[0], tmp_assign_source_7);		828	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[0], tmp_assign_source_7);
	1405	}		829	}
	1406	{		830	{
	1407	PyObject *tmp_assign_source_8;		831	PyObject *tmp_assign_source_8;
	1408			832
	1409			833
	1410	tmp_assign_source_8 = MAKE_FUNCTION___main__$$$function__1_calledRepeatedly();		834	tmp_assign_source_8 = MAKE_FUNCTION___main__$$$function__1_calledRepeatedly();
	1411			835
n	1412	UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[18], tmp_assign_source_8);	n	836	UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[10], tmp_assign_source_8);
	1413	}		837	}
	1414	{		838	{
	1415	PyObject *tmp_assign_source_9;		839	PyObject *tmp_assign_source_9;
	1416	PyObject *tmp_iter_arg_1;		840	PyObject *tmp_iter_arg_1;
	1417	PyObject *tmp_called_instance_1;		841	PyObject *tmp_called_instance_1;
n	1418	tmp_called_instance_1 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[13]);	n	842	tmp_called_instance_1 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[5]);
	1419			843
	1420	if (unlikely(tmp_called_instance_1 == NULL)) {		844	if (unlikely(tmp_called_instance_1 == NULL)) {
n	1421	tmp_called_instance_1 = GET_MODULE_VARIABLE_VALUE_FALLBACK(tstate, mod_consts[13]);	n	845	tmp_called_instance_1 = GET_MODULE_VARIABLE_VALUE_FALLBACK(tstate, mod_consts[5]);
	1422	}		846	}
	1423			847
	1424	if (tmp_called_instance_1 == NULL) {		848	if (tmp_called_instance_1 == NULL) {
	1425	assert(HAS_ERROR_OCCURRED(tstate));		849	assert(HAS_ERROR_OCCURRED(tstate));
	1426			850
	1433	}		857	}
	1434	frame_e7c9e3d4dd54f3b4308eb955790d80b8->m_frame.f_lineno = 34;		858	frame_e7c9e3d4dd54f3b4308eb955790d80b8->m_frame.f_lineno = 34;
	1435	tmp_iter_arg_1 = CALL_METHOD_WITH_ARGS2(		859	tmp_iter_arg_1 = CALL_METHOD_WITH_ARGS2(
	1436	tstate,		860	tstate,
	1437	tmp_called_instance_1,		861	tmp_called_instance_1,
n	1438	mod_consts[19],	n	862	mod_consts[11],
	1439	&PyTuple_GET_ITEM(mod_consts[20], 0)		863	&PyTuple_GET_ITEM(mod_consts[12], 0)
	1440	);		864	);
	1441			865
	1442	if (tmp_iter_arg_1 == NULL) {		866	if (tmp_iter_arg_1 == NULL) {
	1443	assert(HAS_ERROR_OCCURRED(tstate));		867	assert(HAS_ERROR_OCCURRED(tstate));
	1444			868
	1494	}		918	}
	1495	{		919	{
	1496	PyObject *tmp_assign_source_11;		920	PyObject *tmp_assign_source_11;
	1497	CHECK_OBJECT(tmp_for_loop_1__iter_value);		921	CHECK_OBJECT(tmp_for_loop_1__iter_value);
	1498	tmp_assign_source_11 = tmp_for_loop_1__iter_value;		922	tmp_assign_source_11 = tmp_for_loop_1__iter_value;
n	1499	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[21], tmp_assign_source_11);	n	923	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[13], tmp_assign_source_11);
	1500	}		924	}
	1501	{		925	{
	1502	PyObject *tmp_called_value_1;		926	PyObject *tmp_called_value_1;
	1503	PyObject *tmp_call_result_1;		927	PyObject *tmp_call_result_1;
	1504	PyObject *tmp_args_element_value_1;		928	PyObject *tmp_args_element_value_1;
n	1505	tmp_called_value_1 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[18]);	n	929	tmp_called_value_1 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[10]);
	1506			930
	1507	if (unlikely(tmp_called_value_1 == NULL)) {		931	if (unlikely(tmp_called_value_1 == NULL)) {
n	1508	tmp_called_value_1 = GET_MODULE_VARIABLE_VALUE_FALLBACK(tstate, mod_consts[18]);	n	932	tmp_called_value_1 = GET_MODULE_VARIABLE_VALUE_FALLBACK(tstate, mod_consts[10]);
	1509	}		933	}
	1510			934
	1511	if (tmp_called_value_1 == NULL) {		935	if (tmp_called_value_1 == NULL) {
	1512	assert(HAS_ERROR_OCCURRED(tstate));		936	assert(HAS_ERROR_OCCURRED(tstate));
	1513			937
	1516			940
	1517	exception_lineno = 35;		941	exception_lineno = 35;
	1518			942
	1519	goto try_except_handler_2;		943	goto try_except_handler_2;
	1520	}		944	}
n	1521	tmp_args_element_value_1 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[22]);	n	945	tmp_args_element_value_1 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[14]);
	1522			946
	1523	if (unlikely(tmp_args_element_value_1 == NULL)) {		947	if (unlikely(tmp_args_element_value_1 == NULL)) {
n	1524	tmp_args_element_value_1 = GET_MODULE_VARIABLE_VALUE_FALLBACK(tstate, mod_consts[22]);	n	948	tmp_args_element_value_1 = GET_MODULE_VARIABLE_VALUE_FALLBACK(tstate, mod_consts[14]);
	1525	}		949	}
	1526			950
	1527	if (tmp_args_element_value_1 == NULL) {		951	if (tmp_args_element_value_1 == NULL) {
	1528	assert(HAS_ERROR_OCCURRED(tstate));		952	assert(HAS_ERROR_OCCURRED(tstate));
	1529			953
	1592	Py_DECREF(tmp_for_loop_1__for_iterator);		1016	Py_DECREF(tmp_for_loop_1__for_iterator);
	1593	tmp_for_loop_1__for_iterator = NULL;		1017	tmp_for_loop_1__for_iterator = NULL;
	1594	{		1018	{
	1595	PyObject *tmp_called_value_2;		1019	PyObject *tmp_called_value_2;
	1596	PyObject *tmp_call_result_2;		1020	PyObject *tmp_call_result_2;
n	1597	tmp_called_value_2 = LOOKUP_BUILTIN(mod_consts[23]);	n	1021	tmp_called_value_2 = LOOKUP_BUILTIN(mod_consts[15]);
	1598	assert(tmp_called_value_2 != NULL);		1022	assert(tmp_called_value_2 != NULL);
	1599	frame_e7c9e3d4dd54f3b4308eb955790d80b8->m_frame.f_lineno = 37;		1023	frame_e7c9e3d4dd54f3b4308eb955790d80b8->m_frame.f_lineno = 37;
t	1600	tmp_call_result_2 = CALL_FUNCTION_WITH_POSARGS1(tstate, tmp_called_value_2, mod_consts[24]);	t	1024	tmp_call_result_2 = CALL_FUNCTION_WITH_POSARGS1(tstate, tmp_called_value_2, mod_consts[16]);
	1601			1025
	1602	if (tmp_call_result_2 == NULL) {		1026	if (tmp_call_result_2 == NULL) {
	1603	assert(HAS_ERROR_OCCURRED(tstate));		1027	assert(HAS_ERROR_OCCURRED(tstate));
	1604			1028
	1605	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);		1029	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);