Construct CallCompiledFunctionKwArgsVariableStarDict

Performance Diagrams

Construct CallCompiledFunctionKwArgsVariableStarDict 00100000000100000000200000000200000000300000000300000000400000000400000000500000000500000000600000000600000000700000000700000000800000000800000000CPython 3.10Nuitka (main)Nuitka (develop)Nuitka (factory)65527109988.11538461538461304.26625050572454CPython 3.10810249043240.03846153846155257.0Nuitka (main)809365336391.96153846153845257.26951910289677Nuitka (develop)809353535543.8846153846154257.27311825389734Nuitka (factory)Construct CallCompiledFunctionKwArgsVariableStarDictTicks Construct CallCompiledFunctionKwArgsVariableStarDict 00100000000100000000200000000200000000300000000300000000400000000400000000500000000500000000600000000600000000700000000700000000800000000800000000CPython 3.8Nuitka (main)Nuitka (develop)Nuitka (factory)75030616988.11538461538461274.38943021725777CPython 3.8807101653240.03846153846155257.0Nuitka (main)806513048391.96153846153845257.18021689141744Nuitka (develop)806502317543.8846153846154257.1835024691169Nuitka (factory)Construct CallCompiledFunctionKwArgsVariableStarDictTicks Construct CallCompiledFunctionKwArgsVariableStarDict 00100000000100000000200000000200000000300000000300000000400000000400000000500000000500000000600000000600000000700000000700000000CPython 2.7Nuitka (main)Nuitka (develop)Nuitka (factory)57963343588.11538461538461300.0502013701799CPython 2.7701914615240.03846153846155257.00000809735764Nuitka (main)701914638391.96153846153845257.0Nuitka (develop)701914638543.8846153846154257.0Nuitka (factory)Construct CallCompiledFunctionKwArgsVariableStarDictTicks

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_9e3059e391f573b91d0d41fe346de2d7; 84 static PyCodeObject *codeobj_9e3059e391f573b91d0d41fe346de2d7;
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_15d28958c96e33d55e03c5155da65659 = 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_15d28958c96e33d55e03c5155da65659 = 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_15d28958c96e33d55e03c5155da65659; 91     codeobj_main = codeobj_15d28958c96e33d55e03c5155da65659;
n 92     codeobj_fabf4ac26d727fb3867e5afd2b02f1a1 = 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_fabf4ac26d727fb3867e5afd2b02f1a1 = 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_1aec8f300ae5a8896519f7b57e38714d = 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_1aec8f300ae5a8896519f7b57e38714d = 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_9e3059e391f573b91d0d41fe346de2d7 = 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_9e3059e391f573b91d0d41fe346de2d7 = 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_fabf4ac26d727fb3867e5afd2b02f1a1 = NULL; 192     static struct Nuitka_FrameObject *cache_frame_fabf4ac26d727fb3867e5afd2b02f1a1 = 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_fabf4ac26d727fb3867e5afd2b02f1a1, 523         codeobj_fabf4ac26d727fb3867e5afd2b02f1a1,
1810         NULL, 524         NULL,
2192 906
2193     // Module code. 907     // Module code.
2194     { 908     {
2195         PyObject *tmp_assign_source_1; 909         PyObject *tmp_assign_source_1;
2196         tmp_assign_source_1 = Py_None; 910         tmp_assign_source_1 = Py_None;
n 2197         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[20], tmp_assign_source_1); n 911         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[2], tmp_assign_source_1);
2198     } 912     }
2199     { 913     {
2200         PyObject *tmp_assign_source_2; 914         PyObject *tmp_assign_source_2;
n 2201         tmp_assign_source_2 = mod_consts[21]; n 915         tmp_assign_source_2 = mod_consts[3];
2202         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[22], tmp_assign_source_2); 916         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[4], tmp_assign_source_2);
2203     } 917     }
2204     { 918     {
2205         PyObject *tmp_assign_source_3; 919         PyObject *tmp_assign_source_3;
2206         { 920         {
2207             PyObject *hard_module = IMPORT_HARD___FUTURE__(); 921             PyObject *hard_module = IMPORT_HARD___FUTURE__();
n 2208             tmp_assign_source_3 = LOOKUP_ATTRIBUTE(tstate, hard_module, mod_consts[23]); n 922             tmp_assign_source_3 = LOOKUP_ATTRIBUTE(tstate, hard_module, mod_consts[5]);
2209         } 923         }
2210         assert(!(tmp_assign_source_3 == NULL)); 924         assert(!(tmp_assign_source_3 == NULL));
n 2211         UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[23], tmp_assign_source_3); n 925         UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[5], tmp_assign_source_3);
2212     } 926     }
2213     frame_15d28958c96e33d55e03c5155da65659 = MAKE_MODULE_FRAME(codeobj_15d28958c96e33d55e03c5155da65659, module___main__); 927     frame_15d28958c96e33d55e03c5155da65659 = MAKE_MODULE_FRAME(codeobj_15d28958c96e33d55e03c5155da65659, module___main__);
2214 928
2215     // Push the new frame as the currently active one, and we should be exclusively 929     // Push the new frame as the currently active one, and we should be exclusively
2216     // owning it. 930     // owning it.
2222         PyObject *tmp_assign_source_4; 936         PyObject *tmp_assign_source_4;
2223         PyObject *tmp_name_value_1; 937         PyObject *tmp_name_value_1;
2224         PyObject *tmp_globals_arg_value_1; 938         PyObject *tmp_globals_arg_value_1;
2225         PyObject *tmp_locals_arg_value_1; 939         PyObject *tmp_locals_arg_value_1;
2226         PyObject *tmp_fromlist_value_1; 940         PyObject *tmp_fromlist_value_1;
n 2227         tmp_name_value_1 = mod_consts[24]; n 941         tmp_name_value_1 = mod_consts[6];
2228         tmp_globals_arg_value_1 = (PyObject *)moduledict___main__; 942         tmp_globals_arg_value_1 = (PyObject *)moduledict___main__;
2229         tmp_locals_arg_value_1 = Py_None; 943         tmp_locals_arg_value_1 = Py_None;
2230         tmp_fromlist_value_1 = Py_None; 944         tmp_fromlist_value_1 = Py_None;
2231         frame_15d28958c96e33d55e03c5155da65659->m_frame.f_lineno = 6; 945         frame_15d28958c96e33d55e03c5155da65659->m_frame.f_lineno = 6;
2232         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); 946         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);
2238 952
2239             exception_lineno = 6; 953             exception_lineno = 6;
2240 954
2241             goto frame_exception_exit_1; 955             goto frame_exception_exit_1;
2242         } 956         }
n 2243         UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[24], tmp_assign_source_4); n 957         UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[6], tmp_assign_source_4);
2244     } 958     }
2245     { 959     {
2246         PyObject *tmp_assign_source_5; 960         PyObject *tmp_assign_source_5;
2247 961
2248 962
2258 972
2259         UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[0], tmp_assign_source_6); 973         UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[0], tmp_assign_source_6);
2260     } 974     }
2261     { 975     {
2262         PyObject *tmp_assign_source_7; 976         PyObject *tmp_assign_source_7;
n 2263         tmp_assign_source_7 = DICT_COPY(mod_consts[26]); n 977         tmp_assign_source_7 = DICT_COPY(mod_consts[8]);
2264         UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[5], tmp_assign_source_7); 978         UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[9], tmp_assign_source_7);
2265     } 979     }
2266     { 980     {
2267         PyObject *tmp_assign_source_8; 981         PyObject *tmp_assign_source_8;
2268 982
2269 983
2270         tmp_assign_source_8 = MAKE_FUNCTION___main__$$$function__3_calledRepeatedly(); 984         tmp_assign_source_8 = MAKE_FUNCTION___main__$$$function__3_calledRepeatedly();
2271 985
n 2272         UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[27], tmp_assign_source_8); n 986         UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[10], tmp_assign_source_8);
2273     } 987     }
2274     { 988     {
2275         PyObject *tmp_assign_source_9; 989         PyObject *tmp_assign_source_9;
2276         PyObject *tmp_iter_arg_1; 990         PyObject *tmp_iter_arg_1;
2277         PyObject *tmp_called_instance_1; 991         PyObject *tmp_called_instance_1;
n 2278         tmp_called_instance_1 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[24]); n 992         tmp_called_instance_1 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[6]);
2279 993
2280         if (unlikely(tmp_called_instance_1 == NULL)) { 994         if (unlikely(tmp_called_instance_1 == NULL)) {
n 2281             tmp_called_instance_1 = GET_MODULE_VARIABLE_VALUE_FALLBACK(tstate, mod_consts[24]); n 995             tmp_called_instance_1 = GET_MODULE_VARIABLE_VALUE_FALLBACK(tstate, mod_consts[6]);
2282         } 996         }
2283 997
2284         assert(!(tmp_called_instance_1 == NULL)); 998         assert(!(tmp_called_instance_1 == NULL));
2285         frame_15d28958c96e33d55e03c5155da65659->m_frame.f_lineno = 44; 999         frame_15d28958c96e33d55e03c5155da65659->m_frame.f_lineno = 44;
2286         tmp_iter_arg_1 = CALL_METHOD_WITH_ARGS2( 1000         tmp_iter_arg_1 = CALL_METHOD_WITH_ARGS2(
2287             tstate, 1001             tstate,
2288             tmp_called_instance_1, 1002             tmp_called_instance_1,
n 2289             mod_consts[28], n 1003             mod_consts[11],
2290             &PyTuple_GET_ITEM(mod_consts[29], 0) 1004             &PyTuple_GET_ITEM(mod_consts[12], 0)
2291         ); 1005         );
2292 1006
2293         if (tmp_iter_arg_1 == NULL) { 1007         if (tmp_iter_arg_1 == NULL) {
2294             assert(HAS_ERROR_OCCURRED(tstate)); 1008             assert(HAS_ERROR_OCCURRED(tstate));
2295 1009
2345     } 1059     }
2346     { 1060     {
2347         PyObject *tmp_assign_source_11; 1061         PyObject *tmp_assign_source_11;
2348         CHECK_OBJECT(tmp_for_loop_1__iter_value); 1062         CHECK_OBJECT(tmp_for_loop_1__iter_value);
2349         tmp_assign_source_11 = tmp_for_loop_1__iter_value; 1063         tmp_assign_source_11 = tmp_for_loop_1__iter_value;
n 2350         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[30], tmp_assign_source_11); n 1064         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[13], tmp_assign_source_11);
2351     } 1065     }
2352     { 1066     {
2353         PyObject *tmp_called_value_1; 1067         PyObject *tmp_called_value_1;
2354         PyObject *tmp_call_result_1; 1068         PyObject *tmp_call_result_1;
n 2355         tmp_called_value_1 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[27]); n 1069         tmp_called_value_1 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[10]);
2356 1070
2357         if (unlikely(tmp_called_value_1 == NULL)) { 1071         if (unlikely(tmp_called_value_1 == NULL)) {
n 2358             tmp_called_value_1 = GET_MODULE_VARIABLE_VALUE_FALLBACK(tstate, mod_consts[27]); n 1072             tmp_called_value_1 = GET_MODULE_VARIABLE_VALUE_FALLBACK(tstate, mod_consts[10]);
2359         } 1073         }
2360 1074
2361         if (tmp_called_value_1 == NULL) { 1075         if (tmp_called_value_1 == NULL) {
2362             assert(HAS_ERROR_OCCURRED(tstate)); 1076             assert(HAS_ERROR_OCCURRED(tstate));
2363 1077
2426     Py_DECREF(tmp_for_loop_1__for_iterator); 1140     Py_DECREF(tmp_for_loop_1__for_iterator);
2427     tmp_for_loop_1__for_iterator = NULL; 1141     tmp_for_loop_1__for_iterator = NULL;
2428     { 1142     {
2429         PyObject *tmp_called_value_2; 1143         PyObject *tmp_called_value_2;
2430         PyObject *tmp_call_result_2; 1144         PyObject *tmp_call_result_2;
n 2431         tmp_called_value_2 = LOOKUP_BUILTIN(mod_consts[31]); n 1145         tmp_called_value_2 = LOOKUP_BUILTIN(mod_consts[14]);
2432         assert(tmp_called_value_2 != NULL); 1146         assert(tmp_called_value_2 != NULL);
2433         frame_15d28958c96e33d55e03c5155da65659->m_frame.f_lineno = 47; 1147         frame_15d28958c96e33d55e03c5155da65659->m_frame.f_lineno = 47;
t 2434         tmp_call_result_2 = CALL_FUNCTION_WITH_POSARGS1(tstate, tmp_called_value_2, mod_consts[32]); t 1148         tmp_call_result_2 = CALL_FUNCTION_WITH_POSARGS1(tstate, tmp_called_value_2, mod_consts[15]);
2435 1149
2436         if (tmp_call_result_2 == NULL) { 1150         if (tmp_call_result_2 == NULL) {
2437             assert(HAS_ERROR_OCCURRED(tstate)); 1151             assert(HAS_ERROR_OCCURRED(tstate));
2438 1152
2439             FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb); 1153             FETCH_ERROR_OCCURRED(tstate, &exception_type, &exception_value, &exception_tb);