Construct CallCompiledFunctionKwArgsVariableStarDict

Kay Hayen

2024-05-01 12:04

Performance Diagrams

Source Code with Construct    "f": 9,
}


def calledRepeatedly():
    a = getUnknownValue()
    b = getUnknownValue()
    c = getUnknownValue()

    compiled_f = compiled_func

    # This is supposed to make a call to a compiled function, which is
    # being optimized separately.
    # construct_begin
    compiled_f(a=a, b=b, c=c, **arg_dict)
    compiled_f(a=a, b=b, c=c, **arg_dict)
    compiled_f(a=a, b=b, c=c, **arg_dict)
    # construct_alternative



    return compiled_f


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

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    "f": 9,
}


def calledRepeatedly():
    a = getUnknownValue()
    b = getUnknownValue()
    c = getUnknownValue()

    compiled_f = compiled_func

    # This is supposed to make a call to a compiled function, which is
    # being optimized separately.
    # construct_begin



    # construct_alternative
    pass
    # construct_end

    return compiled_f


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

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
	29	compiled_f = compiled_func		29	compiled_f = compiled_func
	30			30
	31	# This is supposed to make a call to a compiled function, which is		31	# This is supposed to make a call to a compiled function, which is
	32	# being optimized separately.		32	# being optimized separately.
	33	# construct_begin		33	# construct_begin
n	34	compiled_f(a=a, b=b, c=c, **arg_dict)	n
	35	compiled_f(a=a, b=b, c=c, **arg_dict)
	36	compiled_f(a=a, b=b, c=c, **arg_dict)
	37	# construct_alternative
	38			34
	39			35
t			t	36
				37	# construct_alternative
				38	pass
				39	# construct_end
	40			40
	41	return compiled_f		41	return compiled_f
	42			42
	43			43
	44	for x in itertools.repeat(None, 50000):		44	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[36];	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[36];	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 < 36; 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 < 36; 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
	84	static PyCodeObject *codeobj_c94661a76051ec1b857c01082905eac8;		84	static PyCodeObject *codeobj_c94661a76051ec1b857c01082905eac8;
	85	/* For use in "MainProgram.c". */		85	/* For use in "MainProgram.c". */
	86	PyCodeObject *codeobj_main = NULL;		86	PyCodeObject *codeobj_main = NULL;
	87			87
	88	static void createModuleCodeObjects(void) {		88	static void createModuleCodeObjects(void) {
n	89	module_filename_obj = mod_consts[21]; CHECK_OBJECT(module_filename_obj);	n	89	module_filename_obj = mod_consts[3]; CHECK_OBJECT(module_filename_obj);
	90	codeobj_ee574ec35a3ae81def00bbea488d8cd1 = MAKE_CODE_OBJECT(module_filename_obj, 1, CO_NOFREE \| CO_FUTURE_PRINT_FUNCTION, mod_consts[33], mod_consts[33], NULL, NULL, 0, 0, 0);		90	codeobj_ee574ec35a3ae81def00bbea488d8cd1 = MAKE_CODE_OBJECT(module_filename_obj, 1, CO_NOFREE \| CO_FUTURE_PRINT_FUNCTION, mod_consts[16], mod_consts[16], NULL, NULL, 0, 0, 0);
	91	codeobj_main = codeobj_ee574ec35a3ae81def00bbea488d8cd1;		91	codeobj_main = codeobj_ee574ec35a3ae81def00bbea488d8cd1;
n	92	codeobj_015426b79b96d6274990d164733eccfc = MAKE_CODE_OBJECT(module_filename_obj, 24, CO_OPTIMIZED \| CO_NEWLOCALS \| CO_NOFREE \| CO_FUTURE_PRINT_FUNCTION, mod_consts[27], mod_consts[27], mod_consts[34], NULL, 0, 0, 0);	n	92	codeobj_015426b79b96d6274990d164733eccfc = MAKE_CODE_OBJECT(module_filename_obj, 24, CO_OPTIMIZED \| CO_NEWLOCALS \| CO_NOFREE \| CO_FUTURE_PRINT_FUNCTION, mod_consts[10], mod_consts[10], mod_consts[17], NULL, 0, 0, 0);
	93	codeobj_db6b23e6fd989ed827c9babd2d57f5cc = MAKE_CODE_OBJECT(module_filename_obj, 9, CO_OPTIMIZED \| CO_NEWLOCALS \| CO_NOFREE \| CO_FUTURE_PRINT_FUNCTION, mod_consts[1], mod_consts[1], mod_consts[35], NULL, 6, 0, 0);		93	codeobj_db6b23e6fd989ed827c9babd2d57f5cc = MAKE_CODE_OBJECT(module_filename_obj, 9, CO_OPTIMIZED \| CO_NEWLOCALS \| CO_NOFREE \| CO_FUTURE_PRINT_FUNCTION, mod_consts[1], mod_consts[1], mod_consts[18], NULL, 6, 0, 0);
	94	codeobj_c94661a76051ec1b857c01082905eac8 = MAKE_CODE_OBJECT(module_filename_obj, 13, CO_OPTIMIZED \| CO_NEWLOCALS \| CO_NOFREE \| CO_FUTURE_PRINT_FUNCTION, mod_consts[0], mod_consts[0], NULL, NULL, 0, 0, 0);		94	codeobj_c94661a76051ec1b857c01082905eac8 = MAKE_CODE_OBJECT(module_filename_obj, 13, CO_OPTIMIZED \| CO_NEWLOCALS \| CO_NOFREE \| CO_FUTURE_PRINT_FUNCTION, mod_consts[0], mod_consts[0], NULL, NULL, 0, 0, 0);
	95	}		95	}
	96			96
	97	// The module function declarations.		97	// The module function declarations.
n	98	NUITKA_LOCAL_MODULE PyObject impl___main__$$$function__1_complex_call_helper_keywords_star_dict(PyThreadState tstate, PyObject **python_pars);	n
	99
	100
	101	NUITKA_LOCAL_MODULE PyObject impl___main__$$$function__2_get_callable_name_desc(PyThreadState tstate, PyObject **python_pars);
	102
	103
	104	static PyObject *MAKE_FUNCTION___main__$$$function__1_compiled_func();		98	static PyObject *MAKE_FUNCTION___main__$$$function__1_compiled_func();
	105			99
	106			100
	107	static PyObject *MAKE_FUNCTION___main__$$$function__2_getUnknownValue();		101	static PyObject *MAKE_FUNCTION___main__$$$function__2_getUnknownValue();
	108			102
	193	NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL;		187	NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL;
	194	PyObject *exception_type = NULL;		188	PyObject *exception_type = NULL;
	195	PyObject *exception_value = NULL;		189	PyObject *exception_value = NULL;
	196	PyTracebackObject *exception_tb = NULL;		190	PyTracebackObject *exception_tb = NULL;
	197	NUITKA_MAY_BE_UNUSED int exception_lineno = 0;		191	NUITKA_MAY_BE_UNUSED int exception_lineno = 0;
n	198	NUITKA_MAY_BE_UNUSED nuitka_void tmp_unused;	n
	199	int tmp_res;
	200	static struct Nuitka_FrameObject *cache_frame_015426b79b96d6274990d164733eccfc = NULL;		192	static struct Nuitka_FrameObject *cache_frame_015426b79b96d6274990d164733eccfc = NULL;
	201	PyObject *tmp_return_value = NULL;		193	PyObject *tmp_return_value = NULL;
	202	PyObject *exception_keeper_type_1;		194	PyObject *exception_keeper_type_1;
	203	PyObject *exception_keeper_value_1;		195	PyObject *exception_keeper_value_1;
	204	PyTracebackObject *exception_keeper_tb_1;		196	PyTracebackObject *exception_keeper_tb_1;
	354	goto frame_exception_exit_1;		346	goto frame_exception_exit_1;
	355	}		347	}
	356	assert(var_compiled_f == NULL);		348	assert(var_compiled_f == NULL);
	357	Py_INCREF(tmp_assign_source_4);		349	Py_INCREF(tmp_assign_source_4);
	358	var_compiled_f = tmp_assign_source_4;		350	var_compiled_f = tmp_assign_source_4;
n	359	}	n
	360	{
	361	PyObject *tmp_dircall_arg1_1;
	362	PyObject *tmp_dircall_arg2_1;
	363	PyObject *tmp_dict_key_1;
	364	PyObject *tmp_dict_value_1;
	365	PyObject *tmp_dircall_arg3_1;
	366	PyObject *tmp_call_result_1;
	367	CHECK_OBJECT(var_compiled_f);
	368	tmp_dircall_arg1_1 = var_compiled_f;
	369	CHECK_OBJECT(var_a);
	370	tmp_dict_value_1 = var_a;
	371	tmp_dict_key_1 = mod_consts[2];
	372	tmp_dircall_arg2_1 = _PyDict_NewPresized( 3 );
	373	tmp_res = PyDict_SetItem(tmp_dircall_arg2_1, tmp_dict_key_1, tmp_dict_value_1);
	374	assert(!(tmp_res != 0));
	375	CHECK_OBJECT(var_b);
	376	tmp_dict_value_1 = var_b;
	377	tmp_dict_key_1 = mod_consts[3];
	378	tmp_res = PyDict_SetItem(tmp_dircall_arg2_1, tmp_dict_key_1, tmp_dict_value_1);
	379	assert(!(tmp_res != 0));
	380	CHECK_OBJECT(var_c);
	381	tmp_dict_value_1 = var_c;
	382	tmp_dict_key_1 = mod_consts[4];
	383	tmp_res = PyDict_SetItem(tmp_dircall_arg2_1, tmp_dict_key_1, tmp_dict_value_1);
	384	assert(!(tmp_res != 0));
	385	tmp_dircall_arg3_1 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[5]);
	386
	387	if (unlikely(tmp_dircall_arg3_1 == NULL)) {
	388	tmp_dircall_arg3_1 = GET_MODULE_VARIABLE_VALUE_FALLBACK_IN_FUNCTION(tstate, mod_consts[5]);
	389	}
	390
	391	if (tmp_dircall_arg3_1 == NULL) {
	392	assert(HAS_ERROR_OCCURRED(tstate));
	393
	394	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	395	Py_DECREF(tmp_dircall_arg2_1);
	396
	397	exception_lineno = 34;
	398	type_description_1 = "oooo";
	399	goto frame_exception_exit_1;
	400	}
	401	Py_INCREF(tmp_dircall_arg1_1);
	402	Py_INCREF(tmp_dircall_arg3_1);
	403
	404	{
	405	PyObject *dir_call_args[] = {tmp_dircall_arg1_1, tmp_dircall_arg2_1, tmp_dircall_arg3_1};
	406	tmp_call_result_1 = impl___main__$$$function__1_complex_call_helper_keywords_star_dict(tstate, dir_call_args);
	407	}
	408	if (tmp_call_result_1 == NULL) {
	409	assert(HAS_ERROR_OCCURRED(tstate));
	410
	411	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	412
	413
	414	exception_lineno = 34;
	415	type_description_1 = "oooo";
	416	goto frame_exception_exit_1;
	417	}
	418	Py_DECREF(tmp_call_result_1);
	419	}
	420	{
	421	PyObject *tmp_dircall_arg1_2;
	422	PyObject *tmp_dircall_arg2_2;
	423	PyObject *tmp_dict_key_2;
	424	PyObject *tmp_dict_value_2;
	425	PyObject *tmp_dircall_arg3_2;
	426	PyObject *tmp_call_result_2;
	427	CHECK_OBJECT(var_compiled_f);
	428	tmp_dircall_arg1_2 = var_compiled_f;
	429	CHECK_OBJECT(var_a);
	430	tmp_dict_value_2 = var_a;
	431	tmp_dict_key_2 = mod_consts[2];
	432	tmp_dircall_arg2_2 = _PyDict_NewPresized( 3 );
	433	tmp_res = PyDict_SetItem(tmp_dircall_arg2_2, tmp_dict_key_2, tmp_dict_value_2);
	434	assert(!(tmp_res != 0));
	435	CHECK_OBJECT(var_b);
	436	tmp_dict_value_2 = var_b;
	437	tmp_dict_key_2 = mod_consts[3];
	438	tmp_res = PyDict_SetItem(tmp_dircall_arg2_2, tmp_dict_key_2, tmp_dict_value_2);
	439	assert(!(tmp_res != 0));
	440	CHECK_OBJECT(var_c);
	441	tmp_dict_value_2 = var_c;
	442	tmp_dict_key_2 = mod_consts[4];
	443	tmp_res = PyDict_SetItem(tmp_dircall_arg2_2, tmp_dict_key_2, tmp_dict_value_2);
	444	assert(!(tmp_res != 0));
	445	tmp_dircall_arg3_2 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[5]);
	446
	447	if (unlikely(tmp_dircall_arg3_2 == NULL)) {
	448	tmp_dircall_arg3_2 = GET_MODULE_VARIABLE_VALUE_FALLBACK_IN_FUNCTION(tstate, mod_consts[5]);
	449	}
	450
	451	if (tmp_dircall_arg3_2 == NULL) {
	452	assert(HAS_ERROR_OCCURRED(tstate));
	453
	454	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	455	Py_DECREF(tmp_dircall_arg2_2);
	456
	457	exception_lineno = 35;
	458	type_description_1 = "oooo";
	459	goto frame_exception_exit_1;
	460	}
	461	Py_INCREF(tmp_dircall_arg1_2);
	462	Py_INCREF(tmp_dircall_arg3_2);
	463
	464	{
	465	PyObject *dir_call_args[] = {tmp_dircall_arg1_2, tmp_dircall_arg2_2, tmp_dircall_arg3_2};
	466	tmp_call_result_2 = impl___main__$$$function__1_complex_call_helper_keywords_star_dict(tstate, dir_call_args);
	467	}
	468	if (tmp_call_result_2 == NULL) {
	469	assert(HAS_ERROR_OCCURRED(tstate));
	470
	471	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	472
	473
	474	exception_lineno = 35;
	475	type_description_1 = "oooo";
	476	goto frame_exception_exit_1;
	477	}
	478	Py_DECREF(tmp_call_result_2);
	479	}
	480	{
	481	PyObject *tmp_dircall_arg1_3;
	482	PyObject *tmp_dircall_arg2_3;
	483	PyObject *tmp_dict_key_3;
	484	PyObject *tmp_dict_value_3;
	485	PyObject *tmp_dircall_arg3_3;
	486	PyObject *tmp_call_result_3;
	487	CHECK_OBJECT(var_compiled_f);
	488	tmp_dircall_arg1_3 = var_compiled_f;
	489	CHECK_OBJECT(var_a);
	490	tmp_dict_value_3 = var_a;
	491	tmp_dict_key_3 = mod_consts[2];
	492	tmp_dircall_arg2_3 = _PyDict_NewPresized( 3 );
	493	tmp_res = PyDict_SetItem(tmp_dircall_arg2_3, tmp_dict_key_3, tmp_dict_value_3);
	494	assert(!(tmp_res != 0));
	495	CHECK_OBJECT(var_b);
	496	tmp_dict_value_3 = var_b;
	497	tmp_dict_key_3 = mod_consts[3];
	498	tmp_res = PyDict_SetItem(tmp_dircall_arg2_3, tmp_dict_key_3, tmp_dict_value_3);
	499	assert(!(tmp_res != 0));
	500	CHECK_OBJECT(var_c);
	501	tmp_dict_value_3 = var_c;
	502	tmp_dict_key_3 = mod_consts[4];
	503	tmp_res = PyDict_SetItem(tmp_dircall_arg2_3, tmp_dict_key_3, tmp_dict_value_3);
	504	assert(!(tmp_res != 0));
	505	tmp_dircall_arg3_3 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[5]);
	506
	507	if (unlikely(tmp_dircall_arg3_3 == NULL)) {
	508	tmp_dircall_arg3_3 = GET_MODULE_VARIABLE_VALUE_FALLBACK_IN_FUNCTION(tstate, mod_consts[5]);
	509	}
	510
	511	if (tmp_dircall_arg3_3 == NULL) {
	512	assert(HAS_ERROR_OCCURRED(tstate));
	513
	514	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	515	Py_DECREF(tmp_dircall_arg2_3);
	516
	517	exception_lineno = 36;
	518	type_description_1 = "oooo";
	519	goto frame_exception_exit_1;
	520	}
	521	Py_INCREF(tmp_dircall_arg1_3);
	522	Py_INCREF(tmp_dircall_arg3_3);
	523
	524	{
	525	PyObject *dir_call_args[] = {tmp_dircall_arg1_3, tmp_dircall_arg2_3, tmp_dircall_arg3_3};
	526	tmp_call_result_3 = impl___main__$$$function__1_complex_call_helper_keywords_star_dict(tstate, dir_call_args);
	527	}
	528	if (tmp_call_result_3 == NULL) {
	529	assert(HAS_ERROR_OCCURRED(tstate));
	530
	531	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	532
	533
	534	exception_lineno = 36;
	535	type_description_1 = "oooo";
	536	goto frame_exception_exit_1;
	537	}
	538	Py_DECREF(tmp_call_result_3);
	539	}		351	}
	540			352
	541			353
	542	// Put the previous frame back on top.		354	// Put the previous frame back on top.
	543	popFrameStack(tstate);		355	popFrameStack(tstate);
	617	var_a = NULL;		429	var_a = NULL;
	618	Py_XDECREF(var_b);		430	Py_XDECREF(var_b);
	619	var_b = NULL;		431	var_b = NULL;
	620	Py_XDECREF(var_c);		432	Py_XDECREF(var_c);
	621	var_c = NULL;		433	var_c = NULL;
n	622	Py_XDECREF(var_compiled_f);	n
	623	var_compiled_f = NULL;
	624	// Re-raise.		434	// Re-raise.
	625	exception_type = exception_keeper_type_1;		435	exception_type = exception_keeper_type_1;
	626	exception_value = exception_keeper_value_1;		436	exception_value = exception_keeper_value_1;
	627	exception_tb = exception_keeper_tb_1;		437	exception_tb = exception_keeper_tb_1;
	628	exception_lineno = exception_keeper_lineno_1;		438	exception_lineno = exception_keeper_lineno_1;
	650	assert(had_error \|\| !HAS_ERROR_OCCURRED(tstate));		460	assert(had_error \|\| !HAS_ERROR_OCCURRED(tstate));
	651	return tmp_return_value;		461	return tmp_return_value;
	652	}		462	}
	653			463
	654			464
n	655	NUITKA_LOCAL_MODULE PyObject impl___main__$$$function__1_complex_call_helper_keywords_star_dict(PyThreadState tstate, PyObject **python_pars) {	n
	656	#ifndef __NUITKA_NO_ASSERT__
	657	NUITKA_MAY_BE_UNUSED bool had_error = HAS_ERROR_OCCURRED(tstate);
	658	assert(!had_error); // Do not enter inlined functions with error set.
	659	#endif
	660
	661	// Local variable declarations.
	662	PyObject *par_called = python_pars[0];
	663	PyObject *par_kw = python_pars[1];
	664	PyObject *par_star_arg_dict = python_pars[2];
	665	PyObject *tmp_dict_1__iter = NULL;
	666	PyObject *tmp_dict_1__key_xxx = NULL;
	667	PyObject *tmp_dict_1__keys = NULL;
	668	PyObject *tmp_dict_2__item = NULL;
	669	PyObject *tmp_dict_2__iter = NULL;
	670	PyObject *tmp_dict_2__key = NULL;
	671	PyObject *exception_type = NULL;
	672	PyObject *exception_value = NULL;
	673	PyTracebackObject *exception_tb = NULL;
	674	NUITKA_MAY_BE_UNUSED int exception_lineno = 0;
	675	PyObject *exception_keeper_type_1;
	676	PyObject *exception_keeper_value_1;
	677	PyTracebackObject *exception_keeper_tb_1;
	678	NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1;
	679	int tmp_res;
	680	bool tmp_result;
	681	PyObject *exception_keeper_type_2;
	682	PyObject *exception_keeper_value_2;
	683	PyTracebackObject *exception_keeper_tb_2;
	684	NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_2;
	685	PyObject *tmp_return_value = NULL;
	686
	687	// Actual function body.
	688	// Tried code:
	689	{
	690	bool tmp_condition_result_1;
	691	PyObject *tmp_cmp_expr_left_1;
	692	PyObject *tmp_cmp_expr_right_1;
	693	PyObject *tmp_type_arg_1;
	694	CHECK_OBJECT(par_star_arg_dict);
	695	tmp_type_arg_1 = par_star_arg_dict;
	696	tmp_cmp_expr_left_1 = BUILTIN_TYPE1(tmp_type_arg_1);
	697	assert(!(tmp_cmp_expr_left_1 == NULL));
	698	tmp_cmp_expr_right_1 = (PyObject *)&PyDict_Type;
	699	tmp_condition_result_1 = (tmp_cmp_expr_left_1 != tmp_cmp_expr_right_1) ? true : false;
	700	Py_DECREF(tmp_cmp_expr_left_1);
	701	if (tmp_condition_result_1 != false) {
	702	goto branch_yes_1;
	703	} else {
	704	goto branch_no_1;
	705	}
	706	}
	707	branch_yes_1:;
	708	// Tried code:
	709	{
	710	PyObject *tmp_assign_source_1;
	711	PyObject *tmp_called_value_1;
	712	PyObject *tmp_expression_value_1;
	713	CHECK_OBJECT(par_star_arg_dict);
	714	tmp_expression_value_1 = par_star_arg_dict;
	715	tmp_called_value_1 = LOOKUP_ATTRIBUTE(tstate, tmp_expression_value_1, mod_consts[6]);
	716	if (tmp_called_value_1 == NULL) {
	717	assert(HAS_ERROR_OCCURRED(tstate));
	718
	719	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	720
	721
	722
	723
	724	goto try_except_handler_2;
	725	}
	726	tmp_assign_source_1 = CALL_FUNCTION_NO_ARGS(tstate, tmp_called_value_1);
	727	Py_DECREF(tmp_called_value_1);
	728	if (tmp_assign_source_1 == NULL) {
	729	assert(HAS_ERROR_OCCURRED(tstate));
	730
	731	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	732
	733
	734
	735
	736	goto try_except_handler_2;
	737	}
	738	assert(tmp_dict_1__keys == NULL);
	739	tmp_dict_1__keys = tmp_assign_source_1;
	740	}
	741	goto try_end_1;
	742	// Exception handler code:
	743	try_except_handler_2:;
	744	exception_keeper_type_1 = exception_type;
	745	exception_keeper_value_1 = exception_value;
	746	exception_keeper_tb_1 = exception_tb;
	747	exception_keeper_lineno_1 = exception_lineno;
	748	exception_type = NULL;
	749	exception_value = NULL;
	750	exception_tb = NULL;
	751	exception_lineno = 0;
	752
	753	{
	754	bool tmp_condition_result_2;
	755	PyObject *tmp_cmp_expr_left_2;
	756	PyObject *tmp_cmp_expr_right_2;
	757	tmp_cmp_expr_left_2 = exception_keeper_type_1;
	758	tmp_cmp_expr_right_2 = PyExc_AttributeError;
	759	tmp_res = EXCEPTION_MATCH_BOOL(tstate, tmp_cmp_expr_left_2, tmp_cmp_expr_right_2);
	760	assert(!(tmp_res == -1));
	761	tmp_condition_result_2 = (tmp_res != 0) ? true : false;
	762	if (tmp_condition_result_2 != false) {
	763	goto branch_yes_2;
	764	} else {
	765	goto branch_no_2;
	766	}
	767	}
	768	branch_yes_2:;
	769	{
	770	PyObject *tmp_raise_type_1;
	771	PyObject *tmp_make_exception_arg_1;
	772	PyObject *tmp_mod_expr_left_1;
	773	PyObject *tmp_mod_expr_right_1;
	774	PyObject *tmp_tuple_element_1;
	775	PyObject *tmp_dircall_arg1_1;
	776	tmp_mod_expr_left_1 = mod_consts[7];
	777	CHECK_OBJECT(par_called);
	778	tmp_dircall_arg1_1 = par_called;
	779	Py_INCREF(tmp_dircall_arg1_1);
	780
	781	{
	782	PyObject *dir_call_args[] = {tmp_dircall_arg1_1};
	783	tmp_tuple_element_1 = impl___main__$$$function__2_get_callable_name_desc(tstate, dir_call_args);
	784	}
	785	if (tmp_tuple_element_1 == NULL) {
	786	assert(HAS_ERROR_OCCURRED(tstate));
	787
	788	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	789
	790	Py_DECREF(exception_keeper_type_1);
	791	Py_XDECREF(exception_keeper_value_1);
	792	Py_XDECREF(exception_keeper_tb_1);
	793
	794
	795
	796	goto try_except_handler_1;
	797	}
	798	tmp_mod_expr_right_1 = MAKE_TUPLE_EMPTY(2);
	799	{
	800	PyObject *tmp_expression_value_2;
	801	PyObject *tmp_type_arg_2;
	802	PyTuple_SET_ITEM(tmp_mod_expr_right_1, 0, tmp_tuple_element_1);
	803	CHECK_OBJECT(par_star_arg_dict);
	804	tmp_type_arg_2 = par_star_arg_dict;
	805	tmp_expression_value_2 = BUILTIN_TYPE1(tmp_type_arg_2);
	806	assert(!(tmp_expression_value_2 == NULL));
	807	tmp_tuple_element_1 = LOOKUP_ATTRIBUTE(tstate, tmp_expression_value_2, mod_consts[8]);
	808	Py_DECREF(tmp_expression_value_2);
	809	if (tmp_tuple_element_1 == NULL) {
	810	assert(HAS_ERROR_OCCURRED(tstate));
	811
	812	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	813
	814	Py_DECREF(exception_keeper_type_1);
	815	Py_XDECREF(exception_keeper_value_1);
	816	Py_XDECREF(exception_keeper_tb_1);
	817
	818
	819
	820	goto tuple_build_exception_1;
	821	}
	822	PyTuple_SET_ITEM(tmp_mod_expr_right_1, 1, tmp_tuple_element_1);
	823	}
	824	goto tuple_build_noexception_1;
	825	// Exception handling pass through code for tuple_build:
	826	tuple_build_exception_1:;
	827	Py_DECREF(tmp_mod_expr_right_1);
	828	Py_DECREF(exception_keeper_type_1);
	829	Py_XDECREF(exception_keeper_value_1);
	830	Py_XDECREF(exception_keeper_tb_1);
	831	goto try_except_handler_1;
	832	// Finished with no exception for tuple_build:
	833	tuple_build_noexception_1:;
	834	tmp_make_exception_arg_1 = BINARY_OPERATION_MOD_OBJECT_STR_TUPLE(tmp_mod_expr_left_1, tmp_mod_expr_right_1);
	835	Py_DECREF(tmp_mod_expr_right_1);
	836	if (tmp_make_exception_arg_1 == NULL) {
	837	assert(HAS_ERROR_OCCURRED(tstate));
	838
	839	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	840
	841	Py_DECREF(exception_keeper_type_1);
	842	Py_XDECREF(exception_keeper_value_1);
	843	Py_XDECREF(exception_keeper_tb_1);
	844
	845
	846
	847	goto try_except_handler_1;
	848	}
	849	tmp_raise_type_1 = CALL_FUNCTION_WITH_SINGLE_ARG(tstate, PyExc_TypeError, tmp_make_exception_arg_1);
	850	Py_DECREF(tmp_make_exception_arg_1);
	851	assert(!(tmp_raise_type_1 == NULL));
	852	exception_type = tmp_raise_type_1;
	853	RAISE_EXCEPTION_WITH_TYPE(tstate, &exception_type, &exception_value, &exception_tb);
	854
	855	goto try_except_handler_1;
	856	}
	857	goto branch_end_2;
	858	branch_no_2:;
	859	// Re-raise.
	860	exception_type = exception_keeper_type_1;
	861	exception_value = exception_keeper_value_1;
	862	exception_tb = exception_keeper_tb_1;
	863	exception_lineno = exception_keeper_lineno_1;
	864
	865	goto try_except_handler_1;
	866	branch_end_2:;
	867	// End of try:
	868	try_end_1:;
	869	{
	870	PyObject *tmp_assign_source_2;
	871	PyObject *tmp_iter_arg_1;
	872	CHECK_OBJECT(tmp_dict_1__keys);
	873	tmp_iter_arg_1 = tmp_dict_1__keys;
	874	tmp_assign_source_2 = MAKE_ITERATOR(tstate, tmp_iter_arg_1);
	875	if (tmp_assign_source_2 == NULL) {
	876	assert(HAS_ERROR_OCCURRED(tstate));
	877
	878	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	879
	880
	881
	882
	883	goto try_except_handler_1;
	884	}
	885	assert(tmp_dict_1__iter == NULL);
	886	tmp_dict_1__iter = tmp_assign_source_2;
	887	}
	888	loop_start_1:;
	889	{
	890	PyObject *tmp_next_source_1;
	891	PyObject *tmp_assign_source_3;
	892	CHECK_OBJECT(tmp_dict_1__iter);
	893	tmp_next_source_1 = tmp_dict_1__iter;
	894	tmp_assign_source_3 = ITERATOR_NEXT(tmp_next_source_1);
	895	if (tmp_assign_source_3 == NULL) {
	896	if (CHECK_AND_CLEAR_STOP_ITERATION_OCCURRED(tstate)) {
	897
	898	goto loop_end_1;
	899	} else {
	900
	901	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	902
	903
	904	goto try_except_handler_1;
	905	}
	906	}
	907
	908	{
	909	PyObject *old = tmp_dict_1__key_xxx;
	910	tmp_dict_1__key_xxx = tmp_assign_source_3;
	911	Py_XDECREF(old);
	912	}
	913
	914	}
	915	{
	916	bool tmp_condition_result_3;
	917	PyObject *tmp_cmp_expr_left_3;
	918	PyObject *tmp_cmp_expr_right_3;
	919	CHECK_OBJECT(tmp_dict_1__key_xxx);
	920	tmp_cmp_expr_left_3 = tmp_dict_1__key_xxx;
	921	if (par_kw == NULL) {
	922
	923	FORMAT_UNBOUND_LOCAL_ERROR(&exception_type, &exception_value, mod_consts[9]);
	924	exception_tb = NULL;
	925
	926
	927
	928	goto try_except_handler_1;
	929	}
	930
	931	tmp_cmp_expr_right_3 = par_kw;
	932	tmp_res = PySequence_Contains(tmp_cmp_expr_right_3, tmp_cmp_expr_left_3);
	933	if (tmp_res == -1) {
	934	assert(HAS_ERROR_OCCURRED(tstate));
	935
	936	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	937
	938
	939
	940
	941	goto try_except_handler_1;
	942	}
	943	tmp_condition_result_3 = (tmp_res == 1) ? true : false;
	944	if (tmp_condition_result_3 != false) {
	945	goto branch_yes_3;
	946	} else {
	947	goto branch_no_3;
	948	}
	949	}
	950	branch_yes_3:;
	951	{
	952	PyObject *tmp_raise_type_2;
	953	PyObject *tmp_make_exception_arg_2;
	954	PyObject *tmp_mod_expr_left_2;
	955	PyObject *tmp_mod_expr_right_2;
	956	PyObject *tmp_tuple_element_2;
	957	PyObject *tmp_dircall_arg1_2;
	958	tmp_mod_expr_left_2 = mod_consts[10];
	959	if (par_called == NULL) {
	960
	961	FORMAT_UNBOUND_LOCAL_ERROR(&exception_type, &exception_value, mod_consts[11]);
	962	exception_tb = NULL;
	963
	964
	965
	966	goto try_except_handler_1;
	967	}
	968
	969	tmp_dircall_arg1_2 = par_called;
	970	Py_INCREF(tmp_dircall_arg1_2);
	971
	972	{
	973	PyObject *dir_call_args[] = {tmp_dircall_arg1_2};
	974	tmp_tuple_element_2 = impl___main__$$$function__2_get_callable_name_desc(tstate, dir_call_args);
	975	}
	976	if (tmp_tuple_element_2 == NULL) {
	977	assert(HAS_ERROR_OCCURRED(tstate));
	978
	979	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	980
	981
	982
	983
	984	goto try_except_handler_1;
	985	}
	986	tmp_mod_expr_right_2 = MAKE_TUPLE_EMPTY(2);
	987	PyTuple_SET_ITEM(tmp_mod_expr_right_2, 0, tmp_tuple_element_2);
	988	CHECK_OBJECT(tmp_dict_1__key_xxx);
	989	tmp_tuple_element_2 = tmp_dict_1__key_xxx;
	990	PyTuple_SET_ITEM0(tmp_mod_expr_right_2, 1, tmp_tuple_element_2);
	991	tmp_make_exception_arg_2 = BINARY_OPERATION_MOD_OBJECT_STR_TUPLE(tmp_mod_expr_left_2, tmp_mod_expr_right_2);
	992	Py_DECREF(tmp_mod_expr_right_2);
	993	if (tmp_make_exception_arg_2 == NULL) {
	994	assert(HAS_ERROR_OCCURRED(tstate));
	995
	996	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	997
	998
	999
	1000
	1001	goto try_except_handler_1;
	1002	}
	1003	tmp_raise_type_2 = CALL_FUNCTION_WITH_SINGLE_ARG(tstate, PyExc_TypeError, tmp_make_exception_arg_2);
	1004	Py_DECREF(tmp_make_exception_arg_2);
	1005	assert(!(tmp_raise_type_2 == NULL));
	1006	exception_type = tmp_raise_type_2;
	1007	RAISE_EXCEPTION_WITH_TYPE(tstate, &exception_type, &exception_value, &exception_tb);
	1008
	1009	goto try_except_handler_1;
	1010	}
	1011	branch_no_3:;
	1012	{
	1013	PyObject *tmp_ass_subvalue_1;
	1014	PyObject *tmp_expression_value_3;
	1015	PyObject *tmp_subscript_value_1;
	1016	PyObject *tmp_ass_subscribed_1;
	1017	PyObject *tmp_ass_subscript_1;
	1018	if (par_star_arg_dict == NULL) {
	1019
	1020	FORMAT_UNBOUND_LOCAL_ERROR(&exception_type, &exception_value, mod_consts[12]);
	1021	exception_tb = NULL;
	1022
	1023
	1024
	1025	goto try_except_handler_1;
	1026	}
	1027
	1028	tmp_expression_value_3 = par_star_arg_dict;
	1029	CHECK_OBJECT(tmp_dict_1__key_xxx);
	1030	tmp_subscript_value_1 = tmp_dict_1__key_xxx;
	1031	tmp_ass_subvalue_1 = LOOKUP_SUBSCRIPT(tstate, tmp_expression_value_3, tmp_subscript_value_1);
	1032	if (tmp_ass_subvalue_1 == NULL) {
	1033	assert(HAS_ERROR_OCCURRED(tstate));
	1034
	1035	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	1036
	1037
	1038
	1039
	1040	goto try_except_handler_1;
	1041	}
	1042	if (par_kw == NULL) {
	1043	Py_DECREF(tmp_ass_subvalue_1);
	1044	FORMAT_UNBOUND_LOCAL_ERROR(&exception_type, &exception_value, mod_consts[9]);
	1045	exception_tb = NULL;
	1046
	1047
	1048
	1049	goto try_except_handler_1;
	1050	}
	1051
	1052	tmp_ass_subscribed_1 = par_kw;
	1053	CHECK_OBJECT(tmp_dict_1__key_xxx);
	1054	tmp_ass_subscript_1 = tmp_dict_1__key_xxx;
	1055	tmp_result = SET_SUBSCRIPT(tstate, tmp_ass_subscribed_1, tmp_ass_subscript_1, tmp_ass_subvalue_1);
	1056	Py_DECREF(tmp_ass_subvalue_1);
	1057	if (tmp_result == false) {
	1058	assert(HAS_ERROR_OCCURRED(tstate));
	1059
	1060	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	1061
	1062
	1063
	1064
	1065	goto try_except_handler_1;
	1066	}
	1067	}
	1068	if (CONSIDER_THREADING(tstate) == false) {
	1069	assert(HAS_ERROR_OCCURRED(tstate));
	1070
	1071	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	1072
	1073
	1074
	1075
	1076	goto try_except_handler_1;
	1077	}
	1078	goto loop_start_1;
	1079	loop_end_1:;
	1080	goto branch_end_1;
	1081	branch_no_1:;
	1082	{
	1083	nuitka_bool tmp_condition_result_4;
	1084	int tmp_truth_name_1;
	1085	CHECK_OBJECT(par_star_arg_dict);
	1086	tmp_truth_name_1 = CHECK_IF_TRUE(par_star_arg_dict);
	1087	if (tmp_truth_name_1 == -1) {
	1088	assert(HAS_ERROR_OCCURRED(tstate));
	1089
	1090	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	1091
	1092
	1093
	1094
	1095	goto try_except_handler_1;
	1096	}
	1097	tmp_condition_result_4 = tmp_truth_name_1 == 0 ? NUITKA_BOOL_FALSE : NUITKA_BOOL_TRUE;
	1098	if (tmp_condition_result_4 == NUITKA_BOOL_TRUE) {
	1099	goto branch_yes_4;
	1100	} else {
	1101	goto branch_no_4;
	1102	}
	1103	}
	1104	branch_yes_4:;
	1105	{
	1106	PyObject *tmp_assign_source_4;
	1107	PyObject *tmp_dict_seq_1;
	1108	CHECK_OBJECT(par_kw);
	1109	tmp_dict_seq_1 = par_kw;
	1110	tmp_assign_source_4 = TO_DICT(tstate, tmp_dict_seq_1, NULL);
	1111	if (tmp_assign_source_4 == NULL) {
	1112	assert(HAS_ERROR_OCCURRED(tstate));
	1113
	1114	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	1115
	1116
	1117
	1118
	1119	goto try_except_handler_1;
	1120	}
	1121	{
	1122	PyObject *old = par_kw;
	1123	assert(old != NULL);
	1124	par_kw = tmp_assign_source_4;
	1125	Py_DECREF(old);
	1126	}
	1127
	1128	}
	1129	{
	1130	PyObject *tmp_assign_source_5;
	1131	PyObject *tmp_iter_arg_2;
	1132	PyObject *tmp_dict_arg_1;
	1133	CHECK_OBJECT(par_star_arg_dict);
	1134	tmp_dict_arg_1 = par_star_arg_dict;
	1135	tmp_iter_arg_2 = DICT_ITERITEMS(tmp_dict_arg_1);
	1136	assert(!(tmp_iter_arg_2 == NULL));
	1137	tmp_assign_source_5 = MAKE_ITERATOR(tstate, tmp_iter_arg_2);
	1138	Py_DECREF(tmp_iter_arg_2);
	1139	if (tmp_assign_source_5 == NULL) {
	1140	assert(HAS_ERROR_OCCURRED(tstate));
	1141
	1142	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	1143
	1144
	1145
	1146
	1147	goto try_except_handler_1;
	1148	}
	1149	assert(tmp_dict_2__iter == NULL);
	1150	tmp_dict_2__iter = tmp_assign_source_5;
	1151	}
	1152	loop_start_2:;
	1153	{
	1154	PyObject *tmp_next_source_2;
	1155	PyObject *tmp_assign_source_6;
	1156	CHECK_OBJECT(tmp_dict_2__iter);
	1157	tmp_next_source_2 = tmp_dict_2__iter;
	1158	tmp_assign_source_6 = ITERATOR_NEXT(tmp_next_source_2);
	1159	if (tmp_assign_source_6 == NULL) {
	1160	if (CHECK_AND_CLEAR_STOP_ITERATION_OCCURRED(tstate)) {
	1161
	1162	goto loop_end_2;
	1163	} else {
	1164
	1165	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	1166
	1167
	1168	goto try_except_handler_1;
	1169	}
	1170	}
	1171
	1172	{
	1173	PyObject *old = tmp_dict_2__item;
	1174	tmp_dict_2__item = tmp_assign_source_6;
	1175	Py_XDECREF(old);
	1176	}
	1177
	1178	}
	1179	{
	1180	PyObject *tmp_assign_source_7;
	1181	PyObject *tmp_expression_value_4;
	1182	PyObject *tmp_subscript_value_2;
	1183	CHECK_OBJECT(tmp_dict_2__item);
	1184	tmp_expression_value_4 = tmp_dict_2__item;
	1185	tmp_subscript_value_2 = mod_consts[13];
	1186	tmp_assign_source_7 = LOOKUP_SUBSCRIPT_CONST(tstate, tmp_expression_value_4, tmp_subscript_value_2, 0);
	1187	if (tmp_assign_source_7 == NULL) {
	1188	assert(HAS_ERROR_OCCURRED(tstate));
	1189
	1190	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	1191
	1192
	1193
	1194
	1195	goto try_except_handler_1;
	1196	}
	1197	{
	1198	PyObject *old = tmp_dict_2__key;
	1199	tmp_dict_2__key = tmp_assign_source_7;
	1200	Py_XDECREF(old);
	1201	}
	1202
	1203	}
	1204	{
	1205	bool tmp_condition_result_5;
	1206	PyObject *tmp_cmp_expr_left_4;
	1207	PyObject *tmp_cmp_expr_right_4;
	1208	CHECK_OBJECT(tmp_dict_2__key);
	1209	tmp_cmp_expr_left_4 = tmp_dict_2__key;
	1210	if (par_kw == NULL) {
	1211
	1212	FORMAT_UNBOUND_LOCAL_ERROR(&exception_type, &exception_value, mod_consts[9]);
	1213	exception_tb = NULL;
	1214
	1215
	1216
	1217	goto try_except_handler_1;
	1218	}
	1219
	1220	tmp_cmp_expr_right_4 = par_kw;
	1221	tmp_res = PySequence_Contains(tmp_cmp_expr_right_4, tmp_cmp_expr_left_4);
	1222	if (tmp_res == -1) {
	1223	assert(HAS_ERROR_OCCURRED(tstate));
	1224
	1225	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	1226
	1227
	1228
	1229
	1230	goto try_except_handler_1;
	1231	}
	1232	tmp_condition_result_5 = (tmp_res == 1) ? true : false;
	1233	if (tmp_condition_result_5 != false) {
	1234	goto branch_yes_5;
	1235	} else {
	1236	goto branch_no_5;
	1237	}
	1238	}
	1239	branch_yes_5:;
	1240	{
	1241	PyObject *tmp_raise_type_3;
	1242	PyObject *tmp_make_exception_arg_3;
	1243	PyObject *tmp_mod_expr_left_3;
	1244	PyObject *tmp_mod_expr_right_3;
	1245	PyObject *tmp_tuple_element_3;
	1246	PyObject *tmp_dircall_arg1_3;
	1247	tmp_mod_expr_left_3 = mod_consts[10];
	1248	if (par_called == NULL) {
	1249
	1250	FORMAT_UNBOUND_LOCAL_ERROR(&exception_type, &exception_value, mod_consts[11]);
	1251	exception_tb = NULL;
	1252
	1253
	1254
	1255	goto try_except_handler_1;
	1256	}
	1257
	1258	tmp_dircall_arg1_3 = par_called;
	1259	Py_INCREF(tmp_dircall_arg1_3);
	1260
	1261	{
	1262	PyObject *dir_call_args[] = {tmp_dircall_arg1_3};
	1263	tmp_tuple_element_3 = impl___main__$$$function__2_get_callable_name_desc(tstate, dir_call_args);
	1264	}
	1265	if (tmp_tuple_element_3 == NULL) {
	1266	assert(HAS_ERROR_OCCURRED(tstate));
	1267
	1268	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	1269
	1270
	1271
	1272
	1273	goto try_except_handler_1;
	1274	}
	1275	tmp_mod_expr_right_3 = MAKE_TUPLE_EMPTY(2);
	1276	PyTuple_SET_ITEM(tmp_mod_expr_right_3, 0, tmp_tuple_element_3);
	1277	CHECK_OBJECT(tmp_dict_2__key);
	1278	tmp_tuple_element_3 = tmp_dict_2__key;
	1279	PyTuple_SET_ITEM0(tmp_mod_expr_right_3, 1, tmp_tuple_element_3);
	1280	tmp_make_exception_arg_3 = BINARY_OPERATION_MOD_OBJECT_STR_TUPLE(tmp_mod_expr_left_3, tmp_mod_expr_right_3);
	1281	Py_DECREF(tmp_mod_expr_right_3);
	1282	if (tmp_make_exception_arg_3 == NULL) {
	1283	assert(HAS_ERROR_OCCURRED(tstate));
	1284
	1285	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	1286
	1287
	1288
	1289
	1290	goto try_except_handler_1;
	1291	}
	1292	tmp_raise_type_3 = CALL_FUNCTION_WITH_SINGLE_ARG(tstate, PyExc_TypeError, tmp_make_exception_arg_3);
	1293	Py_DECREF(tmp_make_exception_arg_3);
	1294	assert(!(tmp_raise_type_3 == NULL));
	1295	exception_type = tmp_raise_type_3;
	1296	RAISE_EXCEPTION_WITH_TYPE(tstate, &exception_type, &exception_value, &exception_tb);
	1297
	1298	goto try_except_handler_1;
	1299	}
	1300	branch_no_5:;
	1301	{
	1302	PyObject *tmp_ass_subvalue_2;
	1303	PyObject *tmp_expression_value_5;
	1304	PyObject *tmp_subscript_value_3;
	1305	PyObject *tmp_ass_subscribed_2;
	1306	PyObject *tmp_ass_subscript_2;
	1307	CHECK_OBJECT(tmp_dict_2__item);
	1308	tmp_expression_value_5 = tmp_dict_2__item;
	1309	tmp_subscript_value_3 = mod_consts[14];
	1310	tmp_ass_subvalue_2 = LOOKUP_SUBSCRIPT_CONST(tstate, tmp_expression_value_5, tmp_subscript_value_3, 1);
	1311	if (tmp_ass_subvalue_2 == NULL) {
	1312	assert(HAS_ERROR_OCCURRED(tstate));
	1313
	1314	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	1315
	1316
	1317
	1318
	1319	goto try_except_handler_1;
	1320	}
	1321	if (par_kw == NULL) {
	1322	Py_DECREF(tmp_ass_subvalue_2);
	1323	FORMAT_UNBOUND_LOCAL_ERROR(&exception_type, &exception_value, mod_consts[9]);
	1324	exception_tb = NULL;
	1325
	1326
	1327
	1328	goto try_except_handler_1;
	1329	}
	1330
	1331	tmp_ass_subscribed_2 = par_kw;
	1332	CHECK_OBJECT(tmp_dict_2__key);
	1333	tmp_ass_subscript_2 = tmp_dict_2__key;
	1334	tmp_result = SET_SUBSCRIPT(tstate, tmp_ass_subscribed_2, tmp_ass_subscript_2, tmp_ass_subvalue_2);
	1335	Py_DECREF(tmp_ass_subvalue_2);
	1336	if (tmp_result == false) {
	1337	assert(HAS_ERROR_OCCURRED(tstate));
	1338
	1339	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	1340
	1341
	1342
	1343
	1344	goto try_except_handler_1;
	1345	}
	1346	}
	1347	if (CONSIDER_THREADING(tstate) == false) {
	1348	assert(HAS_ERROR_OCCURRED(tstate));
	1349
	1350	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	1351
	1352
	1353
	1354
	1355	goto try_except_handler_1;
	1356	}
	1357	goto loop_start_2;
	1358	loop_end_2:;
	1359	branch_no_4:;
	1360	branch_end_1:;
	1361	goto try_end_2;
	1362	// Exception handler code:
	1363	try_except_handler_1:;
	1364	exception_keeper_type_2 = exception_type;
	1365	exception_keeper_value_2 = exception_value;
	1366	exception_keeper_tb_2 = exception_tb;
	1367	exception_keeper_lineno_2 = exception_lineno;
	1368	exception_type = NULL;
	1369	exception_value = NULL;
	1370	exception_tb = NULL;
	1371	exception_lineno = 0;
	1372
	1373	Py_XDECREF(tmp_dict_1__iter);
	1374	tmp_dict_1__iter = NULL;
	1375	Py_XDECREF(tmp_dict_1__keys);
	1376	tmp_dict_1__keys = NULL;
	1377	Py_XDECREF(tmp_dict_1__key_xxx);
	1378	tmp_dict_1__key_xxx = NULL;
	1379	Py_XDECREF(tmp_dict_2__iter);
	1380	tmp_dict_2__iter = NULL;
	1381	Py_XDECREF(tmp_dict_2__item);
	1382	tmp_dict_2__item = NULL;
	1383	Py_XDECREF(tmp_dict_2__key);
	1384	tmp_dict_2__key = NULL;
	1385	// Re-raise.
	1386	exception_type = exception_keeper_type_2;
	1387	exception_value = exception_keeper_value_2;
	1388	exception_tb = exception_keeper_tb_2;
	1389	exception_lineno = exception_keeper_lineno_2;
	1390
	1391	goto function_exception_exit;
	1392	// End of try:
	1393	try_end_2:;
	1394	Py_XDECREF(tmp_dict_1__iter);
	1395	tmp_dict_1__iter = NULL;
	1396	Py_XDECREF(tmp_dict_1__keys);
	1397	tmp_dict_1__keys = NULL;
	1398	Py_XDECREF(tmp_dict_1__key_xxx);
	1399	tmp_dict_1__key_xxx = NULL;
	1400	Py_XDECREF(tmp_dict_2__iter);
	1401	tmp_dict_2__iter = NULL;
	1402	Py_XDECREF(tmp_dict_2__item);
	1403	tmp_dict_2__item = NULL;
	1404	Py_XDECREF(tmp_dict_2__key);
	1405	tmp_dict_2__key = NULL;
	1406	{
	1407	PyObject *tmp_called_value_2;
	1408	PyObject *tmp_kw_dict_1;
	1409	if (par_called == NULL) {
	1410
	1411	FORMAT_UNBOUND_LOCAL_ERROR(&exception_type, &exception_value, mod_consts[11]);
	1412	exception_tb = NULL;
	1413
	1414
	1415
	1416	goto function_exception_exit;
	1417	}
	1418
	1419	tmp_called_value_2 = par_called;
	1420	if (par_kw == NULL) {
	1421
	1422	FORMAT_UNBOUND_LOCAL_ERROR(&exception_type, &exception_value, mod_consts[9]);
	1423	exception_tb = NULL;
	1424
	1425
	1426
	1427	goto function_exception_exit;
	1428	}
	1429
	1430	tmp_kw_dict_1 = par_kw;
	1431	tmp_return_value = CALL_FUNCTION_WITH_KEYARGS(tstate, tmp_called_value_2, tmp_kw_dict_1);
	1432
	1433	if (tmp_return_value == NULL) {
	1434	assert(HAS_ERROR_OCCURRED(tstate));
	1435
	1436	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	1437
	1438
	1439
	1440
	1441	goto function_exception_exit;
	1442	}
	1443	goto function_return_exit;
	1444	}
	1445
	1446	NUITKA_CANNOT_GET_HERE("Return statement must have exited already.");
	1447	return NULL;
	1448
	1449	function_exception_exit:
	1450	CHECK_OBJECT(par_called);
	1451	Py_DECREF(par_called);
	1452	CHECK_OBJECT(par_kw);
	1453	Py_DECREF(par_kw);
	1454	CHECK_OBJECT(par_star_arg_dict);
	1455	Py_DECREF(par_star_arg_dict);
	1456	assert(exception_type);
	1457	RESTORE_ERROR_OCCURRED(tstate, exception_type, exception_value, exception_tb);
	1458
	1459	return NULL;
	1460
	1461	function_return_exit:
	1462	// Function cleanup code if any.
	1463	CHECK_OBJECT(par_called);
	1464	Py_DECREF(par_called);
	1465	CHECK_OBJECT(par_kw);
	1466	Py_DECREF(par_kw);
	1467	CHECK_OBJECT(par_star_arg_dict);
	1468	Py_DECREF(par_star_arg_dict);
	1469
	1470	// Actual function exit with return value, making sure we did not make
	1471	// the error status worse despite non-NULL return.
	1472	CHECK_OBJECT(tmp_return_value);
	1473	assert(had_error \|\| !HAS_ERROR_OCCURRED(tstate));
	1474	return tmp_return_value;
	1475	}
	1476
	1477
	1478	NUITKA_LOCAL_MODULE PyObject impl___main__$$$function__2_get_callable_name_desc(PyThreadState tstate, PyObject **python_pars) {
	1479	#ifndef __NUITKA_NO_ASSERT__
	1480	NUITKA_MAY_BE_UNUSED bool had_error = HAS_ERROR_OCCURRED(tstate);
	1481	assert(!had_error); // Do not enter inlined functions with error set.
	1482	#endif
	1483
	1484	// Local variable declarations.
	1485	PyObject *par_called = python_pars[0];
	1486	int tmp_res;
	1487	PyObject *exception_type = NULL;
	1488	PyObject *exception_value = NULL;
	1489	PyTracebackObject *exception_tb = NULL;
	1490	NUITKA_MAY_BE_UNUSED int exception_lineno = 0;
	1491	PyObject *tmp_return_value = NULL;
	1492
	1493	// Actual function body.
	1494	{
	1495	nuitka_bool tmp_condition_result_1;
	1496	PyObject *tmp_isinstance_inst_1;
	1497	PyObject *tmp_isinstance_cls_1;
	1498	CHECK_OBJECT(par_called);
	1499	tmp_isinstance_inst_1 = par_called;
	1500	tmp_isinstance_cls_1 = mod_consts[15];
	1501	tmp_res = PyObject_IsInstance(tmp_isinstance_inst_1, tmp_isinstance_cls_1);
	1502	if (tmp_res == -1) {
	1503	assert(HAS_ERROR_OCCURRED(tstate));
	1504
	1505	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	1506
	1507
	1508
	1509
	1510	goto function_exception_exit;
	1511	}
	1512	tmp_condition_result_1 = (tmp_res != 0) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
	1513	if (tmp_condition_result_1 == NUITKA_BOOL_TRUE) {
	1514	goto branch_yes_1;
	1515	} else {
	1516	goto branch_no_1;
	1517	}
	1518	}
	1519	branch_yes_1:;
	1520	{
	1521	PyObject *tmp_add_expr_left_1;
	1522	PyObject *tmp_add_expr_right_1;
	1523	PyObject *tmp_expression_value_1;
	1524	CHECK_OBJECT(par_called);
	1525	tmp_expression_value_1 = par_called;
	1526	tmp_add_expr_left_1 = LOOKUP_ATTRIBUTE(tstate, tmp_expression_value_1, mod_consts[8]);
	1527	if (tmp_add_expr_left_1 == NULL) {
	1528	assert(HAS_ERROR_OCCURRED(tstate));
	1529
	1530	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	1531
	1532
	1533
	1534
	1535	goto function_exception_exit;
	1536	}
	1537	tmp_add_expr_right_1 = mod_consts[16];
	1538	tmp_return_value = BINARY_OPERATION_ADD_OBJECT_OBJECT_STR(tmp_add_expr_left_1, tmp_add_expr_right_1);
	1539	Py_DECREF(tmp_add_expr_left_1);
	1540	if (tmp_return_value == NULL) {
	1541	assert(HAS_ERROR_OCCURRED(tstate));
	1542
	1543	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	1544
	1545
	1546
	1547
	1548	goto function_exception_exit;
	1549	}
	1550	goto function_return_exit;
	1551	}
	1552	goto branch_end_1;
	1553	branch_no_1:;
	1554	{
	1555	nuitka_bool tmp_condition_result_2;
	1556	PyObject *tmp_isinstance_inst_2;
	1557	PyObject *tmp_isinstance_cls_2;
	1558	CHECK_OBJECT(par_called);
	1559	tmp_isinstance_inst_2 = par_called;
	1560	tmp_isinstance_cls_2 = (PyObject *)&PyClass_Type;
	1561	tmp_res = PyObject_IsInstance(tmp_isinstance_inst_2, tmp_isinstance_cls_2);
	1562	if (tmp_res == -1) {
	1563	assert(HAS_ERROR_OCCURRED(tstate));
	1564
	1565	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	1566
	1567
	1568
	1569
	1570	goto function_exception_exit;
	1571	}
	1572	tmp_condition_result_2 = (tmp_res != 0) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
	1573	if (tmp_condition_result_2 == NUITKA_BOOL_TRUE) {
	1574	goto branch_yes_2;
	1575	} else {
	1576	goto branch_no_2;
	1577	}
	1578	}
	1579	branch_yes_2:;
	1580	{
	1581	PyObject *tmp_add_expr_left_2;
	1582	PyObject *tmp_add_expr_right_2;
	1583	PyObject *tmp_expression_value_2;
	1584	CHECK_OBJECT(par_called);
	1585	tmp_expression_value_2 = par_called;
	1586	tmp_add_expr_left_2 = LOOKUP_ATTRIBUTE(tstate, tmp_expression_value_2, mod_consts[8]);
	1587	if (tmp_add_expr_left_2 == NULL) {
	1588	assert(HAS_ERROR_OCCURRED(tstate));
	1589
	1590	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	1591
	1592
	1593
	1594
	1595	goto function_exception_exit;
	1596	}
	1597	tmp_add_expr_right_2 = mod_consts[17];
	1598	tmp_return_value = BINARY_OPERATION_ADD_OBJECT_OBJECT_STR(tmp_add_expr_left_2, tmp_add_expr_right_2);
	1599	Py_DECREF(tmp_add_expr_left_2);
	1600	if (tmp_return_value == NULL) {
	1601	assert(HAS_ERROR_OCCURRED(tstate));
	1602
	1603	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	1604
	1605
	1606
	1607
	1608	goto function_exception_exit;
	1609	}
	1610	goto function_return_exit;
	1611	}
	1612	goto branch_end_2;
	1613	branch_no_2:;
	1614	{
	1615	nuitka_bool tmp_condition_result_3;
	1616	PyObject *tmp_isinstance_inst_3;
	1617	PyObject *tmp_isinstance_cls_3;
	1618	CHECK_OBJECT(par_called);
	1619	tmp_isinstance_inst_3 = par_called;
	1620	tmp_isinstance_cls_3 = (PyObject *)&PyInstance_Type;
	1621	tmp_res = PyObject_IsInstance(tmp_isinstance_inst_3, tmp_isinstance_cls_3);
	1622	if (tmp_res == -1) {
	1623	assert(HAS_ERROR_OCCURRED(tstate));
	1624
	1625	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	1626
	1627
	1628
	1629
	1630	goto function_exception_exit;
	1631	}
	1632	tmp_condition_result_3 = (tmp_res != 0) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
	1633	if (tmp_condition_result_3 == NUITKA_BOOL_TRUE) {
	1634	goto branch_yes_3;
	1635	} else {
	1636	goto branch_no_3;
	1637	}
	1638	}
	1639	branch_yes_3:;
	1640	{
	1641	PyObject *tmp_add_expr_left_3;
	1642	PyObject *tmp_add_expr_right_3;
	1643	PyObject *tmp_expression_value_3;
	1644	PyObject *tmp_expression_value_4;
	1645	CHECK_OBJECT(par_called);
	1646	tmp_expression_value_4 = par_called;
	1647	tmp_expression_value_3 = LOOKUP_ATTRIBUTE_CLASS_SLOT(tstate, tmp_expression_value_4);
	1648	if (tmp_expression_value_3 == NULL) {
	1649	assert(HAS_ERROR_OCCURRED(tstate));
	1650
	1651	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	1652
	1653
	1654
	1655
	1656	goto function_exception_exit;
	1657	}
	1658	tmp_add_expr_left_3 = LOOKUP_ATTRIBUTE(tstate, tmp_expression_value_3, mod_consts[8]);
	1659	Py_DECREF(tmp_expression_value_3);
	1660	if (tmp_add_expr_left_3 == NULL) {
	1661	assert(HAS_ERROR_OCCURRED(tstate));
	1662
	1663	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	1664
	1665
	1666
	1667
	1668	goto function_exception_exit;
	1669	}
	1670	tmp_add_expr_right_3 = mod_consts[18];
	1671	tmp_return_value = BINARY_OPERATION_ADD_OBJECT_OBJECT_STR(tmp_add_expr_left_3, tmp_add_expr_right_3);
	1672	Py_DECREF(tmp_add_expr_left_3);
	1673	if (tmp_return_value == NULL) {
	1674	assert(HAS_ERROR_OCCURRED(tstate));
	1675
	1676	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	1677
	1678
	1679
	1680
	1681	goto function_exception_exit;
	1682	}
	1683	goto function_return_exit;
	1684	}
	1685	goto branch_end_3;
	1686	branch_no_3:;
	1687	{
	1688	PyObject *tmp_add_expr_left_4;
	1689	PyObject *tmp_add_expr_right_4;
	1690	PyObject *tmp_expression_value_5;
	1691	PyObject *tmp_type_arg_1;
	1692	CHECK_OBJECT(par_called);
	1693	tmp_type_arg_1 = par_called;
	1694	tmp_expression_value_5 = BUILTIN_TYPE1(tmp_type_arg_1);
	1695	assert(!(tmp_expression_value_5 == NULL));
	1696	tmp_add_expr_left_4 = LOOKUP_ATTRIBUTE(tstate, tmp_expression_value_5, mod_consts[8]);
	1697	Py_DECREF(tmp_expression_value_5);
	1698	if (tmp_add_expr_left_4 == NULL) {
	1699	assert(HAS_ERROR_OCCURRED(tstate));
	1700
	1701	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	1702
	1703
	1704
	1705
	1706	goto function_exception_exit;
	1707	}
	1708	tmp_add_expr_right_4 = mod_consts[19];
	1709	tmp_return_value = BINARY_OPERATION_ADD_OBJECT_OBJECT_STR(tmp_add_expr_left_4, tmp_add_expr_right_4);
	1710	Py_DECREF(tmp_add_expr_left_4);
	1711	if (tmp_return_value == NULL) {
	1712	assert(HAS_ERROR_OCCURRED(tstate));
	1713
	1714	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);
	1715
	1716
	1717
	1718
	1719	goto function_exception_exit;
	1720	}
	1721	goto function_return_exit;
	1722	}
	1723	branch_end_3:;
	1724	branch_end_2:;
	1725	branch_end_1:;
	1726
	1727	NUITKA_CANNOT_GET_HERE("Return statement must have exited already.");
	1728	return NULL;
	1729
	1730	function_exception_exit:
	1731	CHECK_OBJECT(par_called);
	1732	Py_DECREF(par_called);
	1733	assert(exception_type);
	1734	RESTORE_ERROR_OCCURRED(tstate, exception_type, exception_value, exception_tb);
	1735
	1736	return NULL;
	1737
	1738	function_return_exit:
	1739	// Function cleanup code if any.
	1740	CHECK_OBJECT(par_called);
	1741	Py_DECREF(par_called);
	1742
	1743	// Actual function exit with return value, making sure we did not make
	1744	// the error status worse despite non-NULL return.
	1745	CHECK_OBJECT(tmp_return_value);
	1746	assert(had_error \|\| !HAS_ERROR_OCCURRED(tstate));
	1747	return tmp_return_value;
	1748	}
	1749
	1750
	1751			465
	1752	static PyObject *MAKE_FUNCTION___main__$$$function__1_compiled_func() {		466	static PyObject *MAKE_FUNCTION___main__$$$function__1_compiled_func() {
	1753	struct Nuitka_FunctionObject *result = Nuitka_Function_New(		467	struct Nuitka_FunctionObject *result = Nuitka_Function_New(
	1754	impl___main__$$$function__1_compiled_func,		468	impl___main__$$$function__1_compiled_func,
	1755	mod_consts[1],		469	mod_consts[1],
	1790	module___main__,		504	module___main__,
	1791	NULL,		505	NULL,
	1792	NULL,		506	NULL,
	1793	0		507	0
	1794	);		508	);
n	1795	Nuitka_Function_EnableConstReturnGeneric(result, mod_consts[25]);	n	509	Nuitka_Function_EnableConstReturnGeneric(result, mod_consts[7]);
	1796			510
	1797	return (PyObject *)result;		511	return (PyObject *)result;
	1798	}		512	}
	1799			513
	1800			514
	1801			515
	1802	static PyObject *MAKE_FUNCTION___main__$$$function__3_calledRepeatedly() {		516	static PyObject *MAKE_FUNCTION___main__$$$function__3_calledRepeatedly() {
	1803	struct Nuitka_FunctionObject *result = Nuitka_Function_New(		517	struct Nuitka_FunctionObject *result = Nuitka_Function_New(
	1804	impl___main__$$$function__3_calledRepeatedly,		518	impl___main__$$$function__3_calledRepeatedly,
n	1805	mod_consts[27],	n	519	mod_consts[10],
	1806	#if PYTHON_VERSION >= 0x300		520	#if PYTHON_VERSION >= 0x300
	1807	NULL,		521	NULL,
	1808	#endif		522	#endif
	1809	codeobj_015426b79b96d6274990d164733eccfc,		523	codeobj_015426b79b96d6274990d164733eccfc,
	1810	NULL,		524	NULL,
	2189			903
	2190	// Module code.		904	// Module code.
	2191	{		905	{
	2192	PyObject *tmp_assign_source_1;		906	PyObject *tmp_assign_source_1;
	2193	tmp_assign_source_1 = Py_None;		907	tmp_assign_source_1 = Py_None;
n	2194	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[20], tmp_assign_source_1);	n	908	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[2], tmp_assign_source_1);
	2195	}		909	}
	2196	{		910	{
	2197	PyObject *tmp_assign_source_2;		911	PyObject *tmp_assign_source_2;
n	2198	tmp_assign_source_2 = mod_consts[21];	n	912	tmp_assign_source_2 = mod_consts[3];
	2199	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[22], tmp_assign_source_2);		913	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[4], tmp_assign_source_2);
	2200	}		914	}
	2201	{		915	{
	2202	PyObject *tmp_assign_source_3;		916	PyObject *tmp_assign_source_3;
	2203	{		917	{
	2204	PyObject *hard_module = IMPORT_HARD___FUTURE__();		918	PyObject *hard_module = IMPORT_HARD___FUTURE__();
n	2205	tmp_assign_source_3 = LOOKUP_ATTRIBUTE(tstate, hard_module, mod_consts[23]);	n	919	tmp_assign_source_3 = LOOKUP_ATTRIBUTE(tstate, hard_module, mod_consts[5]);
	2206	}		920	}
	2207	assert(!(tmp_assign_source_3 == NULL));		921	assert(!(tmp_assign_source_3 == NULL));
n	2208	UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[23], tmp_assign_source_3);	n	922	UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[5], tmp_assign_source_3);
	2209	}		923	}
	2210	frame_ee574ec35a3ae81def00bbea488d8cd1 = MAKE_MODULE_FRAME(codeobj_ee574ec35a3ae81def00bbea488d8cd1, module___main__);		924	frame_ee574ec35a3ae81def00bbea488d8cd1 = MAKE_MODULE_FRAME(codeobj_ee574ec35a3ae81def00bbea488d8cd1, module___main__);
	2211			925
	2212	// Push the new frame as the currently active one, and we should be exclusively		926	// Push the new frame as the currently active one, and we should be exclusively
	2213	// owning it.		927	// owning it.
	2219	PyObject *tmp_assign_source_4;		933	PyObject *tmp_assign_source_4;
	2220	PyObject *tmp_name_value_1;		934	PyObject *tmp_name_value_1;
	2221	PyObject *tmp_globals_arg_value_1;		935	PyObject *tmp_globals_arg_value_1;
	2222	PyObject *tmp_locals_arg_value_1;		936	PyObject *tmp_locals_arg_value_1;
	2223	PyObject *tmp_fromlist_value_1;		937	PyObject *tmp_fromlist_value_1;
n	2224	tmp_name_value_1 = mod_consts[24];	n	938	tmp_name_value_1 = mod_consts[6];
	2225	tmp_globals_arg_value_1 = (PyObject *)moduledict___main__;		939	tmp_globals_arg_value_1 = (PyObject *)moduledict___main__;
	2226	tmp_locals_arg_value_1 = Py_None;		940	tmp_locals_arg_value_1 = Py_None;
	2227	tmp_fromlist_value_1 = Py_None;		941	tmp_fromlist_value_1 = Py_None;
	2228	frame_ee574ec35a3ae81def00bbea488d8cd1->m_frame.f_lineno = 6;		942	frame_ee574ec35a3ae81def00bbea488d8cd1->m_frame.f_lineno = 6;
	2229	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);		943	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);
	2235			949
	2236	exception_lineno = 6;		950	exception_lineno = 6;
	2237			951
	2238	goto frame_exception_exit_1;		952	goto frame_exception_exit_1;
	2239	}		953	}
n	2240	UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[24], tmp_assign_source_4);	n	954	UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[6], tmp_assign_source_4);
	2241	}		955	}
	2242	{		956	{
	2243	PyObject *tmp_assign_source_5;		957	PyObject *tmp_assign_source_5;
	2244			958
	2245			959
	2255			969
	2256	UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[0], tmp_assign_source_6);		970	UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[0], tmp_assign_source_6);
	2257	}		971	}
	2258	{		972	{
	2259	PyObject *tmp_assign_source_7;		973	PyObject *tmp_assign_source_7;
n	2260	tmp_assign_source_7 = DICT_COPY(mod_consts[26]);	n	974	tmp_assign_source_7 = DICT_COPY(mod_consts[8]);
	2261	UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[5], tmp_assign_source_7);		975	UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[9], tmp_assign_source_7);
	2262	}		976	}
	2263	{		977	{
	2264	PyObject *tmp_assign_source_8;		978	PyObject *tmp_assign_source_8;
	2265			979
	2266			980
	2267	tmp_assign_source_8 = MAKE_FUNCTION___main__$$$function__3_calledRepeatedly();		981	tmp_assign_source_8 = MAKE_FUNCTION___main__$$$function__3_calledRepeatedly();
	2268			982
n	2269	UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[27], tmp_assign_source_8);	n	983	UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[10], tmp_assign_source_8);
	2270	}		984	}
	2271	{		985	{
	2272	PyObject *tmp_assign_source_9;		986	PyObject *tmp_assign_source_9;
	2273	PyObject *tmp_iter_arg_1;		987	PyObject *tmp_iter_arg_1;
	2274	PyObject *tmp_called_instance_1;		988	PyObject *tmp_called_instance_1;
n	2275	tmp_called_instance_1 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[24]);	n	989	tmp_called_instance_1 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[6]);
	2276			990
	2277	if (unlikely(tmp_called_instance_1 == NULL)) {		991	if (unlikely(tmp_called_instance_1 == NULL)) {
n	2278	tmp_called_instance_1 = GET_MODULE_VARIABLE_VALUE_FALLBACK(tstate, mod_consts[24]);	n	992	tmp_called_instance_1 = GET_MODULE_VARIABLE_VALUE_FALLBACK(tstate, mod_consts[6]);
	2279	}		993	}
	2280			994
	2281	assert(!(tmp_called_instance_1 == NULL));		995	assert(!(tmp_called_instance_1 == NULL));
	2282	frame_ee574ec35a3ae81def00bbea488d8cd1->m_frame.f_lineno = 44;		996	frame_ee574ec35a3ae81def00bbea488d8cd1->m_frame.f_lineno = 44;
	2283	tmp_iter_arg_1 = CALL_METHOD_WITH_ARGS2(		997	tmp_iter_arg_1 = CALL_METHOD_WITH_ARGS2(
	2284	tstate,		998	tstate,
	2285	tmp_called_instance_1,		999	tmp_called_instance_1,
n	2286	mod_consts[28],	n	1000	mod_consts[11],
	2287	&PyTuple_GET_ITEM(mod_consts[29], 0)		1001	&PyTuple_GET_ITEM(mod_consts[12], 0)
	2288	);		1002	);
	2289			1003
	2290	if (tmp_iter_arg_1 == NULL) {		1004	if (tmp_iter_arg_1 == NULL) {
	2291	assert(HAS_ERROR_OCCURRED(tstate));		1005	assert(HAS_ERROR_OCCURRED(tstate));
	2292			1006
	2342	}		1056	}
	2343	{		1057	{
	2344	PyObject *tmp_assign_source_11;		1058	PyObject *tmp_assign_source_11;
	2345	CHECK_OBJECT(tmp_for_loop_1__iter_value);		1059	CHECK_OBJECT(tmp_for_loop_1__iter_value);
	2346	tmp_assign_source_11 = tmp_for_loop_1__iter_value;		1060	tmp_assign_source_11 = tmp_for_loop_1__iter_value;
n	2347	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[30], tmp_assign_source_11);	n	1061	UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[13], tmp_assign_source_11);
	2348	}		1062	}
	2349	{		1063	{
	2350	PyObject *tmp_called_value_1;		1064	PyObject *tmp_called_value_1;
	2351	PyObject *tmp_call_result_1;		1065	PyObject *tmp_call_result_1;
n	2352	tmp_called_value_1 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[27]);	n	1066	tmp_called_value_1 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[10]);
	2353			1067
	2354	if (unlikely(tmp_called_value_1 == NULL)) {		1068	if (unlikely(tmp_called_value_1 == NULL)) {
n	2355	tmp_called_value_1 = GET_MODULE_VARIABLE_VALUE_FALLBACK(tstate, mod_consts[27]);	n	1069	tmp_called_value_1 = GET_MODULE_VARIABLE_VALUE_FALLBACK(tstate, mod_consts[10]);
	2356	}		1070	}
	2357			1071
	2358	if (tmp_called_value_1 == NULL) {		1072	if (tmp_called_value_1 == NULL) {
	2359	assert(HAS_ERROR_OCCURRED(tstate));		1073	assert(HAS_ERROR_OCCURRED(tstate));
	2360			1074
	2423	Py_DECREF(tmp_for_loop_1__for_iterator);		1137	Py_DECREF(tmp_for_loop_1__for_iterator);
	2424	tmp_for_loop_1__for_iterator = NULL;		1138	tmp_for_loop_1__for_iterator = NULL;
	2425	{		1139	{
	2426	PyObject *tmp_called_value_2;		1140	PyObject *tmp_called_value_2;
	2427	PyObject *tmp_call_result_2;		1141	PyObject *tmp_call_result_2;
n	2428	tmp_called_value_2 = LOOKUP_BUILTIN(mod_consts[31]);	n	1142	tmp_called_value_2 = LOOKUP_BUILTIN(mod_consts[14]);
	2429	assert(tmp_called_value_2 != NULL);		1143	assert(tmp_called_value_2 != NULL);
	2430	frame_ee574ec35a3ae81def00bbea488d8cd1->m_frame.f_lineno = 47;		1144	frame_ee574ec35a3ae81def00bbea488d8cd1->m_frame.f_lineno = 47;
t	2431	tmp_call_result_2 = CALL_FUNCTION_WITH_POSARGS1(tstate, tmp_called_value_2, mod_consts[32]);	t	1145	tmp_call_result_2 = CALL_FUNCTION_WITH_POSARGS1(tstate, tmp_called_value_2, mod_consts[15]);
	2432			1146
	2433	if (tmp_call_result_2 == NULL) {		1147	if (tmp_call_result_2 == NULL) {
	2434	assert(HAS_ERROR_OCCURRED(tstate));		1148	assert(HAS_ERROR_OCCURRED(tstate));
	2435			1149
	2436	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);		1150	FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);