Construct CallCompiledFunctionKwArgsVariableStarDict

Performance Diagrams

Construct CallCompiledFunctionKwArgsVariableStarDict 00100000000100000000200000000200000000300000000300000000400000000400000000500000000500000000600000000600000000700000000700000000800000000800000000CPython 2.7Nuitka (main)Nuitka (develop)Nuitka (factory)58966971388.11538461538461324.46069351205006CPython 2.7811091670240.03846153846155257.00005849664643Nuitka (main)811091862391.96153846153845257.0Nuitka (develop)811091862543.8846153846154257.0Nuitka (factory)Construct CallCompiledFunctionKwArgsVariableStarDictTicks Construct CallCompiledFunctionKwArgsVariableStarDict 0010000000010000000020000000020000000030000000030000000040000000040000000050000000050000000060000000060000000070000000070000000080000000080000000090000000090000000010000000001000000000CPython 3.8Nuitka (main)Nuitka (develop)Nuitka (factory)74999568287.27884615384615327.44095907516953CPython 3.81049019598237.75961538461542257.0007154177594Nuitka (main)1049022635388.2403846153846257.0Nuitka (develop)1049022635538.7211538461538257.0Nuitka (factory)Construct CallCompiledFunctionKwArgsVariableStarDictTicks

Source Code with Construct

from __future__ import print_function

def compiled_func(a,b,c, d, e, f):
    return a, b, c, d, e, f

def getUnknownValue():
    return 8

arg_dict = {
    "d" : 9,
    "e" : 9,
    "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

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

print("OK.")

Source Code without Construct

from __future__ import print_function

def compiled_func(a,b,c, d, e, f):
    return a, b, c, d, e, f

def getUnknownValue():
    return 8

arg_dict = {
    "d" : 9,
    "e" : 9,
    "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

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

print("OK.")

Context Diff of Source Code


Construct
Baseline
39     compiled_f = compiled_func 39     compiled_f = compiled_func
40 40
41     # This is supposed to make a call to a compiled function, which is 41     # This is supposed to make a call to a compiled function, which is
42     # being optimized separately. 42     # being optimized separately.
43 # construct_begin 43 # construct_begin
n 44     compiled_f(a=a, b=b, c=c, **arg_dict) n
45     compiled_f(a=a, b=b, c=c, **arg_dict)
46     compiled_f(a=a, b=b, c=c, **arg_dict)
47 # construct_alternative
48 44
49 45
t t 46  
47 # construct_alternative
48     pass
49 # construct_end
50 50
51     return compiled_f 51     return compiled_f
52 52
53 import itertools 53 import itertools
54 for x in itertools.repeat(None, 50000): 54 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[35]; n 36 static PyObject *mod_consts[22];
37 #ifndef __NUITKA_NO_ASSERT__ 37 #ifndef __NUITKA_NO_ASSERT__
n 38 static Py_hash_t mod_consts_hash[35]; n 38 static Py_hash_t mod_consts_hash[22];
39 #endif 39 #endif
40 40
41 static PyObject *module_filename_obj = NULL; 41 static PyObject *module_filename_obj = NULL;
42 42
43 /* Indicator if this modules private constants were created yet. */ 43 /* Indicator if this modules private constants were created yet. */
48     if (constants_created == false) { 48     if (constants_created == false) {
49         loadConstantsBlob(&mod_consts[0], UNTRANSLATE("__main__")); 49         loadConstantsBlob(&mod_consts[0], UNTRANSLATE("__main__"));
50         constants_created = true; 50         constants_created = true;
51 51
52 #ifndef __NUITKA_NO_ASSERT__ 52 #ifndef __NUITKA_NO_ASSERT__
n 53         for(int i = 0; i < 35; i++) { n 53         for(int i = 0; i < 22; i++) {
54             mod_consts_hash[i] = DEEP_HASH(mod_consts[i]); 54             mod_consts_hash[i] = DEEP_HASH(mod_consts[i]);
55         } 55         }
56 #endif 56 #endif
57     } 57     }
58 } 58 }
68 #ifndef __NUITKA_NO_ASSERT__ 68 #ifndef __NUITKA_NO_ASSERT__
69 void checkModuleConstants___main__(void) { 69 void checkModuleConstants___main__(void) {
70     // The module may not have been used at all, then ignore this. 70     // The module may not have been used at all, then ignore this.
71     if (constants_created == false) return; 71     if (constants_created == false) return;
72 72
n 73     for(int i = 0; i < 35; i++) { n 73     for(int i = 0; i < 22; i++) {
74         assert(mod_consts_hash[i] == DEEP_HASH(mod_consts[i])); 74         assert(mod_consts_hash[i] == DEEP_HASH(mod_consts[i]));
75         CHECK_OBJECT_DEEP(mod_consts[i]); 75         CHECK_OBJECT_DEEP(mod_consts[i]);
76     } 76     }
77 } 77 }
78 #endif 78 #endif
84 static PyCodeObject *codeobj_b0f8ffddbeb16921ed3f4d7978951dd1; 84 static PyCodeObject *codeobj_b0f8ffddbeb16921ed3f4d7978951dd1;
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[18]; CHECK_OBJECT(module_filename_obj); n 89     module_filename_obj = mod_consts[3]; CHECK_OBJECT(module_filename_obj);
90     codeobj_a2dd8b68076bca397252eb5ed9e6e875 = MAKE_CODEOBJECT(module_filename_obj, 1, CO_NOFREE, mod_consts[32], NULL, NULL, 0, 0, 0); 90     codeobj_a2dd8b68076bca397252eb5ed9e6e875 = MAKE_CODEOBJECT(module_filename_obj, 1, CO_NOFREE, mod_consts[19], NULL, NULL, 0, 0, 0);
91     codeobj_fdf994e132a3c9da036a7f384d7af412 = MAKE_CODEOBJECT(module_filename_obj, 34, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE, mod_consts[25], mod_consts[33], NULL, 0, 0, 0); 91     codeobj_fdf994e132a3c9da036a7f384d7af412 = MAKE_CODEOBJECT(module_filename_obj, 34, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE, mod_consts[11], mod_consts[20], NULL, 0, 0, 0);
92     codeobj_b31b7f9e81746b530a284601cf7c7399 = MAKE_CODEOBJECT(module_filename_obj, 22, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE, mod_consts[1], mod_consts[34], NULL, 6, 0, 0); 92     codeobj_b31b7f9e81746b530a284601cf7c7399 = MAKE_CODEOBJECT(module_filename_obj, 22, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE, mod_consts[1], mod_consts[21], NULL, 6, 0, 0);
93     codeobj_b0f8ffddbeb16921ed3f4d7978951dd1 = MAKE_CODEOBJECT(module_filename_obj, 25, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE, mod_consts[0], NULL, NULL, 0, 0, 0); 93     codeobj_b0f8ffddbeb16921ed3f4d7978951dd1 = MAKE_CODEOBJECT(module_filename_obj, 25, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE, mod_consts[0], NULL, NULL, 0, 0, 0);
94 } 94 }
95 95
96 // The module function declarations. 96 // The module function declarations.
n 97 NUITKA_LOCAL_MODULE PyObject *impl___main__$$$function__1_complex_call_helper_keywords_star_dict(PyObject **python_pars); n
98  
99  
100 NUITKA_LOCAL_MODULE PyObject *impl___main__$$$function__2_get_callable_name_desc(PyObject **python_pars);
101  
102  
103 static PyObject *MAKE_FUNCTION___main__$$$function__1_compiled_func(); 97 static PyObject *MAKE_FUNCTION___main__$$$function__1_compiled_func();
104 98
105 99
106 static PyObject *MAKE_FUNCTION___main__$$$function__2_getUnknownValue(); 100 static PyObject *MAKE_FUNCTION___main__$$$function__2_getUnknownValue();
107 101
192     NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL; 186     NUITKA_MAY_BE_UNUSED char const *type_description_1 = NULL;
193     PyObject *exception_type = NULL; 187     PyObject *exception_type = NULL;
194     PyObject *exception_value = NULL; 188     PyObject *exception_value = NULL;
195     PyTracebackObject *exception_tb = NULL; 189     PyTracebackObject *exception_tb = NULL;
196     NUITKA_MAY_BE_UNUSED int exception_lineno = 0; 190     NUITKA_MAY_BE_UNUSED int exception_lineno = 0;
n 197     NUITKA_MAY_BE_UNUSED nuitka_void tmp_unused; n
198     int tmp_res;
199     static struct Nuitka_FrameObject *cache_frame_fdf994e132a3c9da036a7f384d7af412 = NULL; 191     static struct Nuitka_FrameObject *cache_frame_fdf994e132a3c9da036a7f384d7af412 = NULL;
200     PyObject *tmp_return_value = NULL; 192     PyObject *tmp_return_value = NULL;
201     PyObject *exception_keeper_type_1; 193     PyObject *exception_keeper_type_1;
202     PyObject *exception_keeper_value_1; 194     PyObject *exception_keeper_value_1;
203     PyTracebackObject *exception_keeper_tb_1; 195     PyTracebackObject *exception_keeper_tb_1;
353             goto frame_exception_exit_1; 345             goto frame_exception_exit_1;
354         } 346         }
355         assert(var_compiled_f == NULL); 347         assert(var_compiled_f == NULL);
356         Py_INCREF(tmp_assign_source_4); 348         Py_INCREF(tmp_assign_source_4);
357         var_compiled_f = tmp_assign_source_4; 349         var_compiled_f = tmp_assign_source_4;
n 358     } n
359     {
360         PyObject *tmp_dircall_arg1_1;
361         PyObject *tmp_dircall_arg2_1;
362         PyObject *tmp_dict_key_1;
363         PyObject *tmp_dict_value_1;
364         PyObject *tmp_dircall_arg3_1;
365         PyObject *tmp_call_result_1;
366         CHECK_OBJECT(var_compiled_f);
367         tmp_dircall_arg1_1 = var_compiled_f;
368         tmp_dict_key_1 = mod_consts[2];
369         CHECK_OBJECT(var_a);
370         tmp_dict_value_1 = var_a;
371         tmp_dircall_arg2_1 = _PyDict_NewPresized( 3 );
372         tmp_res = PyDict_SetItem(tmp_dircall_arg2_1, tmp_dict_key_1, tmp_dict_value_1);
373         assert(!(tmp_res != 0));
374         tmp_dict_key_1 = mod_consts[3];
375         CHECK_OBJECT(var_b);
376         tmp_dict_value_1 = var_b;
377         tmp_res = PyDict_SetItem(tmp_dircall_arg2_1, tmp_dict_key_1, tmp_dict_value_1);
378         assert(!(tmp_res != 0));
379         tmp_dict_key_1 = mod_consts[4];
380         CHECK_OBJECT(var_c);
381         tmp_dict_value_1 = var_c;
382         tmp_res = PyDict_SetItem(tmp_dircall_arg2_1, tmp_dict_key_1, tmp_dict_value_1);
383         assert(!(tmp_res != 0));
384         tmp_dircall_arg3_1 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[5]);
385  
386         if (unlikely(tmp_dircall_arg3_1 == NULL)) {
387             tmp_dircall_arg3_1 = GET_MODULE_VARIABLE_VALUE_FALLBACK(mod_consts[5]);
388         }
389  
390         if (tmp_dircall_arg3_1 == NULL) {
391             assert(ERROR_OCCURRED());
392  
393             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
394             Py_DECREF(tmp_dircall_arg2_1);
395  
396             exception_lineno = 44;
397             type_description_1 = "oooo";
398             goto frame_exception_exit_1;
399         }
400         Py_INCREF(tmp_dircall_arg1_1);
401         Py_INCREF(tmp_dircall_arg3_1);
402  
403         {
404             PyObject *dir_call_args[] = {tmp_dircall_arg1_1, tmp_dircall_arg2_1, tmp_dircall_arg3_1};
405             tmp_call_result_1 = impl___main__$$$function__1_complex_call_helper_keywords_star_dict(dir_call_args);
406         }
407         if (tmp_call_result_1 == NULL) {
408             assert(ERROR_OCCURRED());
409  
410             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
411  
412  
413             exception_lineno = 44;
414             type_description_1 = "oooo";
415             goto frame_exception_exit_1;
416         }
417         Py_DECREF(tmp_call_result_1);
418     }
419     {
420         PyObject *tmp_dircall_arg1_2;
421         PyObject *tmp_dircall_arg2_2;
422         PyObject *tmp_dict_key_2;
423         PyObject *tmp_dict_value_2;
424         PyObject *tmp_dircall_arg3_2;
425         PyObject *tmp_call_result_2;
426         CHECK_OBJECT(var_compiled_f);
427         tmp_dircall_arg1_2 = var_compiled_f;
428         tmp_dict_key_2 = mod_consts[2];
429         CHECK_OBJECT(var_a);
430         tmp_dict_value_2 = var_a;
431         tmp_dircall_arg2_2 = _PyDict_NewPresized( 3 );
432         tmp_res = PyDict_SetItem(tmp_dircall_arg2_2, tmp_dict_key_2, tmp_dict_value_2);
433         assert(!(tmp_res != 0));
434         tmp_dict_key_2 = mod_consts[3];
435         CHECK_OBJECT(var_b);
436         tmp_dict_value_2 = var_b;
437         tmp_res = PyDict_SetItem(tmp_dircall_arg2_2, tmp_dict_key_2, tmp_dict_value_2);
438         assert(!(tmp_res != 0));
439         tmp_dict_key_2 = mod_consts[4];
440         CHECK_OBJECT(var_c);
441         tmp_dict_value_2 = var_c;
442         tmp_res = PyDict_SetItem(tmp_dircall_arg2_2, tmp_dict_key_2, tmp_dict_value_2);
443         assert(!(tmp_res != 0));
444         tmp_dircall_arg3_2 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[5]);
445  
446         if (unlikely(tmp_dircall_arg3_2 == NULL)) {
447             tmp_dircall_arg3_2 = GET_MODULE_VARIABLE_VALUE_FALLBACK(mod_consts[5]);
448         }
449  
450         if (tmp_dircall_arg3_2 == NULL) {
451             assert(ERROR_OCCURRED());
452  
453             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
454             Py_DECREF(tmp_dircall_arg2_2);
455  
456             exception_lineno = 45;
457             type_description_1 = "oooo";
458             goto frame_exception_exit_1;
459         }
460         Py_INCREF(tmp_dircall_arg1_2);
461         Py_INCREF(tmp_dircall_arg3_2);
462  
463         {
464             PyObject *dir_call_args[] = {tmp_dircall_arg1_2, tmp_dircall_arg2_2, tmp_dircall_arg3_2};
465             tmp_call_result_2 = impl___main__$$$function__1_complex_call_helper_keywords_star_dict(dir_call_args);
466         }
467         if (tmp_call_result_2 == NULL) {
468             assert(ERROR_OCCURRED());
469  
470             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
471  
472  
473             exception_lineno = 45;
474             type_description_1 = "oooo";
475             goto frame_exception_exit_1;
476         }
477         Py_DECREF(tmp_call_result_2);
478     }
479     {
480         PyObject *tmp_dircall_arg1_3;
481         PyObject *tmp_dircall_arg2_3;
482         PyObject *tmp_dict_key_3;
483         PyObject *tmp_dict_value_3;
484         PyObject *tmp_dircall_arg3_3;
485         PyObject *tmp_call_result_3;
486         CHECK_OBJECT(var_compiled_f);
487         tmp_dircall_arg1_3 = var_compiled_f;
488         tmp_dict_key_3 = mod_consts[2];
489         CHECK_OBJECT(var_a);
490         tmp_dict_value_3 = var_a;
491         tmp_dircall_arg2_3 = _PyDict_NewPresized( 3 );
492         tmp_res = PyDict_SetItem(tmp_dircall_arg2_3, tmp_dict_key_3, tmp_dict_value_3);
493         assert(!(tmp_res != 0));
494         tmp_dict_key_3 = mod_consts[3];
495         CHECK_OBJECT(var_b);
496         tmp_dict_value_3 = var_b;
497         tmp_res = PyDict_SetItem(tmp_dircall_arg2_3, tmp_dict_key_3, tmp_dict_value_3);
498         assert(!(tmp_res != 0));
499         tmp_dict_key_3 = mod_consts[4];
500         CHECK_OBJECT(var_c);
501         tmp_dict_value_3 = var_c;
502         tmp_res = PyDict_SetItem(tmp_dircall_arg2_3, tmp_dict_key_3, tmp_dict_value_3);
503         assert(!(tmp_res != 0));
504         tmp_dircall_arg3_3 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[5]);
505  
506         if (unlikely(tmp_dircall_arg3_3 == NULL)) {
507             tmp_dircall_arg3_3 = GET_MODULE_VARIABLE_VALUE_FALLBACK(mod_consts[5]);
508         }
509  
510         if (tmp_dircall_arg3_3 == NULL) {
511             assert(ERROR_OCCURRED());
512  
513             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
514             Py_DECREF(tmp_dircall_arg2_3);
515  
516             exception_lineno = 46;
517             type_description_1 = "oooo";
518             goto frame_exception_exit_1;
519         }
520         Py_INCREF(tmp_dircall_arg1_3);
521         Py_INCREF(tmp_dircall_arg3_3);
522  
523         {
524             PyObject *dir_call_args[] = {tmp_dircall_arg1_3, tmp_dircall_arg2_3, tmp_dircall_arg3_3};
525             tmp_call_result_3 = impl___main__$$$function__1_complex_call_helper_keywords_star_dict(dir_call_args);
526         }
527         if (tmp_call_result_3 == NULL) {
528             assert(ERROR_OCCURRED());
529  
530             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
531  
532  
533             exception_lineno = 46;
534             type_description_1 = "oooo";
535             goto frame_exception_exit_1;
536         }
537         Py_DECREF(tmp_call_result_3);
538     } 350     }
539 351
540 #if 0 352 #if 0
541     RESTORE_FRAME_EXCEPTION(frame_fdf994e132a3c9da036a7f384d7af412); 353     RESTORE_FRAME_EXCEPTION(frame_fdf994e132a3c9da036a7f384d7af412);
542 #endif 354 #endif
625     var_a = NULL; 437     var_a = NULL;
626     Py_XDECREF(var_b); 438     Py_XDECREF(var_b);
627     var_b = NULL; 439     var_b = NULL;
628     Py_XDECREF(var_c); 440     Py_XDECREF(var_c);
629     var_c = NULL; 441     var_c = NULL;
n 630     Py_XDECREF(var_compiled_f); n
631     var_compiled_f = NULL;
632     // Re-raise. 442     // Re-raise.
633     exception_type = exception_keeper_type_1; 443     exception_type = exception_keeper_type_1;
634     exception_value = exception_keeper_value_1; 444     exception_value = exception_keeper_value_1;
635     exception_tb = exception_keeper_tb_1; 445     exception_tb = exception_keeper_tb_1;
636     exception_lineno = exception_keeper_lineno_1; 446     exception_lineno = exception_keeper_lineno_1;
657    assert(had_error || !ERROR_OCCURRED()); 467    assert(had_error || !ERROR_OCCURRED());
658    return tmp_return_value; 468    return tmp_return_value;
659 } 469 }
660 470
661 471
n 662 NUITKA_LOCAL_MODULE PyObject *impl___main__$$$function__1_complex_call_helper_keywords_star_dict(PyObject **python_pars) { n
663 #ifndef __NUITKA_NO_ASSERT__
664     NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED();
665     assert(!had_error); // Do not enter inlined functions with error set.
666 #endif
667  
668     // Local variable declarations.
669     PyObject *par_called = python_pars[0];
670     PyObject *par_kw = python_pars[1];
671     PyObject *par_star_arg_dict = python_pars[2];
672     PyObject *tmp_dict_1__iter = NULL;
673     PyObject *tmp_dict_1__key_xxx = NULL;
674     PyObject *tmp_dict_1__keys = NULL;
675     PyObject *tmp_dict_2__item = NULL;
676     PyObject *tmp_dict_2__iter = NULL;
677     PyObject *tmp_dict_2__key = NULL;
678     PyObject *exception_type = NULL;
679     PyObject *exception_value = NULL;
680     PyTracebackObject *exception_tb = NULL;
681     NUITKA_MAY_BE_UNUSED int exception_lineno = 0;
682     PyObject *exception_keeper_type_1;
683     PyObject *exception_keeper_value_1;
684     PyTracebackObject *exception_keeper_tb_1;
685     NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1;
686     int tmp_res;
687     bool tmp_result;
688     PyObject *exception_keeper_type_2;
689     PyObject *exception_keeper_value_2;
690     PyTracebackObject *exception_keeper_tb_2;
691     NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_2;
692     PyObject *tmp_return_value = NULL;
693  
694     // Actual function body.
695     // Tried code:
696     {
697         bool tmp_condition_result_1;
698         PyObject *tmp_compexpr_left_1;
699         PyObject *tmp_compexpr_right_1;
700         PyObject *tmp_type_arg_1;
701         CHECK_OBJECT(par_star_arg_dict);
702         tmp_type_arg_1 = par_star_arg_dict;
703         tmp_compexpr_left_1 = BUILTIN_TYPE1(tmp_type_arg_1);
704         assert(!(tmp_compexpr_left_1 == NULL));
705         tmp_compexpr_right_1 = (PyObject *)&PyDict_Type;
706         tmp_condition_result_1 = (tmp_compexpr_left_1 != tmp_compexpr_right_1) ? true : false;
707         Py_DECREF(tmp_compexpr_left_1);
708         if (tmp_condition_result_1 != false) {
709             goto branch_yes_1;
710         } else {
711             goto branch_no_1;
712         }
713     }
714     branch_yes_1:;
715     // Tried code:
716     {
717         PyObject *tmp_assign_source_1;
718         PyObject *tmp_called_value_1;
719         PyObject *tmp_expression_value_1;
720         CHECK_OBJECT(par_star_arg_dict);
721         tmp_expression_value_1 = par_star_arg_dict;
722         tmp_called_value_1 = LOOKUP_ATTRIBUTE(tmp_expression_value_1, mod_consts[6]);
723         if (tmp_called_value_1 == NULL) {
724             assert(ERROR_OCCURRED());
725  
726             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
727  
728  
729  
730  
731             goto try_except_handler_2;
732         }
733         tmp_assign_source_1 = CALL_FUNCTION_NO_ARGS(tmp_called_value_1);
734         Py_DECREF(tmp_called_value_1);
735         if (tmp_assign_source_1 == NULL) {
736             assert(ERROR_OCCURRED());
737  
738             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
739  
740  
741  
742  
743             goto try_except_handler_2;
744         }
745         assert(tmp_dict_1__keys == NULL);
746         tmp_dict_1__keys = tmp_assign_source_1;
747     }
748     goto try_end_1;
749     // Exception handler code:
750     try_except_handler_2:;
751     exception_keeper_type_1 = exception_type;
752     exception_keeper_value_1 = exception_value;
753     exception_keeper_tb_1 = exception_tb;
754     exception_keeper_lineno_1 = exception_lineno;
755     exception_type = NULL;
756     exception_value = NULL;
757     exception_tb = NULL;
758     exception_lineno = 0;
759  
760     {
761         bool tmp_condition_result_2;
762         PyObject *tmp_compexpr_left_2;
763         PyObject *tmp_compexpr_right_2;
764         tmp_compexpr_left_2 = exception_keeper_type_1;
765         tmp_compexpr_right_2 = PyExc_AttributeError;
766         tmp_res = EXCEPTION_MATCH_BOOL(tmp_compexpr_left_2, tmp_compexpr_right_2);
767         assert(!(tmp_res == -1));
768         tmp_condition_result_2 = (tmp_res != 0) ? true : false;
769         if (tmp_condition_result_2 != false) {
770             goto branch_yes_2;
771         } else {
772             goto branch_no_2;
773         }
774     }
775     branch_yes_2:;
776     {
777         PyObject *tmp_raise_type_1;
778         PyObject *tmp_make_exception_arg_1;
779         PyObject *tmp_left_value_1;
780         PyObject *tmp_right_value_1;
781         PyObject *tmp_tuple_element_1;
782         PyObject *tmp_dircall_arg1_1;
783         tmp_left_value_1 = mod_consts[7];
784         CHECK_OBJECT(par_called);
785         tmp_dircall_arg1_1 = par_called;
786         Py_INCREF(tmp_dircall_arg1_1);
787  
788         {
789             PyObject *dir_call_args[] = {tmp_dircall_arg1_1};
790             tmp_tuple_element_1 = impl___main__$$$function__2_get_callable_name_desc(dir_call_args);
791         }
792         if (tmp_tuple_element_1 == NULL) {
793             assert(ERROR_OCCURRED());
794  
795             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
796  
797             Py_DECREF(exception_keeper_type_1);
798             Py_XDECREF(exception_keeper_value_1);
799             Py_XDECREF(exception_keeper_tb_1);
800  
801  
802  
803             goto try_except_handler_1;
804         }
805         tmp_right_value_1 = PyTuple_New(2);
806         {
807             PyObject *tmp_expression_value_2;
808             PyObject *tmp_type_arg_2;
809             PyTuple_SET_ITEM(tmp_right_value_1, 0, tmp_tuple_element_1);
810             CHECK_OBJECT(par_star_arg_dict);
811             tmp_type_arg_2 = par_star_arg_dict;
812             tmp_expression_value_2 = BUILTIN_TYPE1(tmp_type_arg_2);
813             assert(!(tmp_expression_value_2 == NULL));
814             tmp_tuple_element_1 = LOOKUP_ATTRIBUTE(tmp_expression_value_2, mod_consts[8]);
815             Py_DECREF(tmp_expression_value_2);
816             if (tmp_tuple_element_1 == NULL) {
817                 assert(ERROR_OCCURRED());
818  
819                 FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
820  
821                 Py_DECREF(exception_keeper_type_1);
822                 Py_XDECREF(exception_keeper_value_1);
823                 Py_XDECREF(exception_keeper_tb_1);
824  
825  
826  
827                 goto tuple_build_exception_1;
828             }
829             PyTuple_SET_ITEM(tmp_right_value_1, 1, tmp_tuple_element_1);
830         }
831         goto tuple_build_noexception_1;
832         // Exception handling pass through code for tuple_build:
833         tuple_build_exception_1:;
834         Py_DECREF(tmp_right_value_1);
835         Py_DECREF(exception_keeper_type_1);
836         Py_XDECREF(exception_keeper_value_1);
837         Py_XDECREF(exception_keeper_tb_1);
838         goto try_except_handler_1;
839         // Finished with no exception for tuple_build:
840         tuple_build_noexception_1:;
841         tmp_make_exception_arg_1 = BINARY_OPERATION_MOD_OBJECT_UNICODE_TUPLE(tmp_left_value_1, tmp_right_value_1);
842         Py_DECREF(tmp_right_value_1);
843         if (tmp_make_exception_arg_1 == NULL) {
844             assert(ERROR_OCCURRED());
845  
846             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
847  
848             Py_DECREF(exception_keeper_type_1);
849             Py_XDECREF(exception_keeper_value_1);
850             Py_XDECREF(exception_keeper_tb_1);
851  
852  
853  
854             goto try_except_handler_1;
855         }
856         tmp_raise_type_1 = CALL_FUNCTION_WITH_SINGLE_ARG(PyExc_TypeError, tmp_make_exception_arg_1);
857         Py_DECREF(tmp_make_exception_arg_1);
858         assert(!(tmp_raise_type_1 == NULL));
859         exception_type = tmp_raise_type_1;
860         RAISE_EXCEPTION_WITH_TYPE(&exception_type, &exception_value, &exception_tb);
861  
862         goto try_except_handler_1;
863     }
864     goto branch_end_2;
865     branch_no_2:;
866     // Re-raise.
867     exception_type = exception_keeper_type_1;
868     exception_value = exception_keeper_value_1;
869     exception_tb = exception_keeper_tb_1;
870     exception_lineno = exception_keeper_lineno_1;
871  
872     goto try_except_handler_1;
873     branch_end_2:;
874     // End of try:
875     try_end_1:;
876     {
877         PyObject *tmp_assign_source_2;
878         PyObject *tmp_iter_arg_1;
879         CHECK_OBJECT(tmp_dict_1__keys);
880         tmp_iter_arg_1 = tmp_dict_1__keys;
881         tmp_assign_source_2 = MAKE_ITERATOR(tmp_iter_arg_1);
882         if (tmp_assign_source_2 == NULL) {
883             assert(ERROR_OCCURRED());
884  
885             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
886  
887  
888  
889  
890             goto try_except_handler_1;
891         }
892         assert(tmp_dict_1__iter == NULL);
893         tmp_dict_1__iter = tmp_assign_source_2;
894     }
895     loop_start_1:;
896     {
897         PyObject *tmp_next_source_1;
898         PyObject *tmp_assign_source_3;
899         CHECK_OBJECT(tmp_dict_1__iter);
900         tmp_next_source_1 = tmp_dict_1__iter;
901         tmp_assign_source_3 = ITERATOR_NEXT(tmp_next_source_1);
902         if (tmp_assign_source_3 == NULL) {
903             if (CHECK_AND_CLEAR_STOP_ITERATION_OCCURRED()) {
904  
905                 goto loop_end_1;
906             } else {
907  
908                 FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
909  
910  
911                 goto try_except_handler_1;
912             }
913         }
914  
915         {
916             PyObject *old = tmp_dict_1__key_xxx;
917             tmp_dict_1__key_xxx = tmp_assign_source_3;
918             Py_XDECREF(old);
919         }
920  
921     }
922     {
923         bool tmp_condition_result_3;
924         PyObject *tmp_compexpr_left_3;
925         PyObject *tmp_compexpr_right_3;
926         CHECK_OBJECT(tmp_dict_1__key_xxx);
927         tmp_compexpr_left_3 = tmp_dict_1__key_xxx;
928         if (par_kw == NULL) {
929  
930             FORMAT_UNBOUND_LOCAL_ERROR(&exception_type, &exception_value, mod_consts[9]);
931             exception_tb = NULL;
932             NORMALIZE_EXCEPTION(&exception_type, &exception_value, &exception_tb);
933             CHAIN_EXCEPTION(exception_value);
934  
935  
936  
937             goto try_except_handler_1;
938         }
939  
940         tmp_compexpr_right_3 = par_kw;
941         tmp_res = PySequence_Contains(tmp_compexpr_right_3, tmp_compexpr_left_3);
942         if (tmp_res == -1) {
943             assert(ERROR_OCCURRED());
944  
945             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
946  
947  
948  
949  
950             goto try_except_handler_1;
951         }
952         tmp_condition_result_3 = (tmp_res == 1) ? true : false;
953         if (tmp_condition_result_3 != false) {
954             goto branch_yes_3;
955         } else {
956             goto branch_no_3;
957         }
958     }
959     branch_yes_3:;
960     {
961         PyObject *tmp_raise_type_2;
962         PyObject *tmp_make_exception_arg_2;
963         PyObject *tmp_left_value_2;
964         PyObject *tmp_right_value_2;
965         PyObject *tmp_tuple_element_2;
966         PyObject *tmp_dircall_arg1_2;
967         tmp_left_value_2 = mod_consts[10];
968         CHECK_OBJECT(par_called);
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(dir_call_args);
975         }
976         if (tmp_tuple_element_2 == NULL) {
977             assert(ERROR_OCCURRED());
978  
979             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
980  
981  
982  
983  
984             goto try_except_handler_1;
985         }
986         tmp_right_value_2 = PyTuple_New(2);
987         PyTuple_SET_ITEM(tmp_right_value_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_right_value_2, 1, tmp_tuple_element_2);
991         tmp_make_exception_arg_2 = BINARY_OPERATION_MOD_OBJECT_UNICODE_TUPLE(tmp_left_value_2, tmp_right_value_2);
992         Py_DECREF(tmp_right_value_2);
993         if (tmp_make_exception_arg_2 == NULL) {
994             assert(ERROR_OCCURRED());
995  
996             FETCH_ERROR_OCCURRED(&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(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(&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         CHECK_OBJECT(par_star_arg_dict);
1019         tmp_expression_value_3 = par_star_arg_dict;
1020         CHECK_OBJECT(tmp_dict_1__key_xxx);
1021         tmp_subscript_value_1 = tmp_dict_1__key_xxx;
1022         tmp_ass_subvalue_1 = LOOKUP_SUBSCRIPT(tmp_expression_value_3, tmp_subscript_value_1);
1023         if (tmp_ass_subvalue_1 == NULL) {
1024             assert(ERROR_OCCURRED());
1025  
1026             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
1027  
1028  
1029  
1030  
1031             goto try_except_handler_1;
1032         }
1033         if (par_kw == NULL) {
1034             Py_DECREF(tmp_ass_subvalue_1);
1035             FORMAT_UNBOUND_LOCAL_ERROR(&exception_type, &exception_value, mod_consts[9]);
1036             exception_tb = NULL;
1037             NORMALIZE_EXCEPTION(&exception_type, &exception_value, &exception_tb);
1038             CHAIN_EXCEPTION(exception_value);
1039  
1040  
1041  
1042             goto try_except_handler_1;
1043         }
1044  
1045         tmp_ass_subscribed_1 = par_kw;
1046         CHECK_OBJECT(tmp_dict_1__key_xxx);
1047         tmp_ass_subscript_1 = tmp_dict_1__key_xxx;
1048         tmp_result = SET_SUBSCRIPT(tmp_ass_subscribed_1, tmp_ass_subscript_1, tmp_ass_subvalue_1);
1049         Py_DECREF(tmp_ass_subvalue_1);
1050         if (tmp_result == false) {
1051             assert(ERROR_OCCURRED());
1052  
1053             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
1054  
1055  
1056  
1057  
1058             goto try_except_handler_1;
1059         }
1060     }
1061     if (CONSIDER_THREADING() == false) {
1062         assert(ERROR_OCCURRED());
1063  
1064         FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
1065  
1066  
1067  
1068  
1069         goto try_except_handler_1;
1070     }
1071     goto loop_start_1;
1072     loop_end_1:;
1073     goto branch_end_1;
1074     branch_no_1:;
1075     {
1076         nuitka_bool tmp_condition_result_4;
1077         int tmp_truth_name_1;
1078         CHECK_OBJECT(par_star_arg_dict);
1079         tmp_truth_name_1 = CHECK_IF_TRUE(par_star_arg_dict);
1080         if (tmp_truth_name_1 == -1) {
1081             assert(ERROR_OCCURRED());
1082  
1083             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
1084  
1085  
1086  
1087  
1088             goto try_except_handler_1;
1089         }
1090         tmp_condition_result_4 = tmp_truth_name_1 == 0 ? NUITKA_BOOL_FALSE : NUITKA_BOOL_TRUE;
1091         if (tmp_condition_result_4 == NUITKA_BOOL_TRUE) {
1092             goto branch_yes_4;
1093         } else {
1094             goto branch_no_4;
1095         }
1096     }
1097     branch_yes_4:;
1098     {
1099         PyObject *tmp_assign_source_4;
1100         PyObject *tmp_dict_seq_1;
1101         CHECK_OBJECT(par_kw);
1102         tmp_dict_seq_1 = par_kw;
1103         tmp_assign_source_4 = TO_DICT(tmp_dict_seq_1, NULL);
1104         if (tmp_assign_source_4 == NULL) {
1105             assert(ERROR_OCCURRED());
1106  
1107             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
1108  
1109  
1110  
1111  
1112             goto try_except_handler_1;
1113         }
1114         {
1115             PyObject *old = par_kw;
1116             assert(old != NULL);
1117             par_kw = tmp_assign_source_4;
1118             Py_DECREF(old);
1119         }
1120  
1121     }
1122     {
1123         PyObject *tmp_assign_source_5;
1124         PyObject *tmp_iter_arg_2;
1125         PyObject *tmp_called_value_2;
1126         PyObject *tmp_expression_value_4;
1127         CHECK_OBJECT(par_star_arg_dict);
1128         tmp_expression_value_4 = par_star_arg_dict;
1129         tmp_called_value_2 = LOOKUP_ATTRIBUTE(tmp_expression_value_4, mod_consts[11]);
1130         if (tmp_called_value_2 == NULL) {
1131             assert(ERROR_OCCURRED());
1132  
1133             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
1134  
1135  
1136  
1137  
1138             goto try_except_handler_1;
1139         }
1140         tmp_iter_arg_2 = CALL_FUNCTION_NO_ARGS(tmp_called_value_2);
1141         Py_DECREF(tmp_called_value_2);
1142         if (tmp_iter_arg_2 == NULL) {
1143             assert(ERROR_OCCURRED());
1144  
1145             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
1146  
1147  
1148  
1149  
1150             goto try_except_handler_1;
1151         }
1152         tmp_assign_source_5 = MAKE_ITERATOR(tmp_iter_arg_2);
1153         Py_DECREF(tmp_iter_arg_2);
1154         if (tmp_assign_source_5 == NULL) {
1155             assert(ERROR_OCCURRED());
1156  
1157             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
1158  
1159  
1160  
1161  
1162             goto try_except_handler_1;
1163         }
1164         assert(tmp_dict_2__iter == NULL);
1165         tmp_dict_2__iter = tmp_assign_source_5;
1166     }
1167     loop_start_2:;
1168     {
1169         PyObject *tmp_next_source_2;
1170         PyObject *tmp_assign_source_6;
1171         CHECK_OBJECT(tmp_dict_2__iter);
1172         tmp_next_source_2 = tmp_dict_2__iter;
1173         tmp_assign_source_6 = ITERATOR_NEXT(tmp_next_source_2);
1174         if (tmp_assign_source_6 == NULL) {
1175             if (CHECK_AND_CLEAR_STOP_ITERATION_OCCURRED()) {
1176  
1177                 goto loop_end_2;
1178             } else {
1179  
1180                 FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
1181  
1182  
1183                 goto try_except_handler_1;
1184             }
1185         }
1186  
1187         {
1188             PyObject *old = tmp_dict_2__item;
1189             tmp_dict_2__item = tmp_assign_source_6;
1190             Py_XDECREF(old);
1191         }
1192  
1193     }
1194     {
1195         PyObject *tmp_assign_source_7;
1196         PyObject *tmp_expression_value_5;
1197         PyObject *tmp_subscript_value_2;
1198         CHECK_OBJECT(tmp_dict_2__item);
1199         tmp_expression_value_5 = tmp_dict_2__item;
1200         tmp_subscript_value_2 = mod_consts[12];
1201         tmp_assign_source_7 = LOOKUP_SUBSCRIPT_CONST(tmp_expression_value_5, tmp_subscript_value_2, 0);
1202         if (tmp_assign_source_7 == NULL) {
1203             assert(ERROR_OCCURRED());
1204  
1205             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
1206  
1207  
1208  
1209  
1210             goto try_except_handler_1;
1211         }
1212         {
1213             PyObject *old = tmp_dict_2__key;
1214             tmp_dict_2__key = tmp_assign_source_7;
1215             Py_XDECREF(old);
1216         }
1217  
1218     }
1219     {
1220         bool tmp_condition_result_5;
1221         PyObject *tmp_compexpr_left_4;
1222         PyObject *tmp_compexpr_right_4;
1223         CHECK_OBJECT(tmp_dict_2__key);
1224         tmp_compexpr_left_4 = tmp_dict_2__key;
1225         if (par_kw == NULL) {
1226  
1227             FORMAT_UNBOUND_LOCAL_ERROR(&exception_type, &exception_value, mod_consts[9]);
1228             exception_tb = NULL;
1229             NORMALIZE_EXCEPTION(&exception_type, &exception_value, &exception_tb);
1230             CHAIN_EXCEPTION(exception_value);
1231  
1232  
1233  
1234             goto try_except_handler_1;
1235         }
1236  
1237         tmp_compexpr_right_4 = par_kw;
1238         tmp_res = PySequence_Contains(tmp_compexpr_right_4, tmp_compexpr_left_4);
1239         if (tmp_res == -1) {
1240             assert(ERROR_OCCURRED());
1241  
1242             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
1243  
1244  
1245  
1246  
1247             goto try_except_handler_1;
1248         }
1249         tmp_condition_result_5 = (tmp_res == 1) ? true : false;
1250         if (tmp_condition_result_5 != false) {
1251             goto branch_yes_5;
1252         } else {
1253             goto branch_no_5;
1254         }
1255     }
1256     branch_yes_5:;
1257     {
1258         PyObject *tmp_raise_type_3;
1259         PyObject *tmp_make_exception_arg_3;
1260         PyObject *tmp_left_value_3;
1261         PyObject *tmp_right_value_3;
1262         PyObject *tmp_tuple_element_3;
1263         PyObject *tmp_dircall_arg1_3;
1264         tmp_left_value_3 = mod_consts[10];
1265         CHECK_OBJECT(par_called);
1266         tmp_dircall_arg1_3 = par_called;
1267         Py_INCREF(tmp_dircall_arg1_3);
1268  
1269         {
1270             PyObject *dir_call_args[] = {tmp_dircall_arg1_3};
1271             tmp_tuple_element_3 = impl___main__$$$function__2_get_callable_name_desc(dir_call_args);
1272         }
1273         if (tmp_tuple_element_3 == NULL) {
1274             assert(ERROR_OCCURRED());
1275  
1276             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
1277  
1278  
1279  
1280  
1281             goto try_except_handler_1;
1282         }
1283         tmp_right_value_3 = PyTuple_New(2);
1284         PyTuple_SET_ITEM(tmp_right_value_3, 0, tmp_tuple_element_3);
1285         CHECK_OBJECT(tmp_dict_2__key);
1286         tmp_tuple_element_3 = tmp_dict_2__key;
1287         PyTuple_SET_ITEM0(tmp_right_value_3, 1, tmp_tuple_element_3);
1288         tmp_make_exception_arg_3 = BINARY_OPERATION_MOD_OBJECT_UNICODE_TUPLE(tmp_left_value_3, tmp_right_value_3);
1289         Py_DECREF(tmp_right_value_3);
1290         if (tmp_make_exception_arg_3 == NULL) {
1291             assert(ERROR_OCCURRED());
1292  
1293             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
1294  
1295  
1296  
1297  
1298             goto try_except_handler_1;
1299         }
1300         tmp_raise_type_3 = CALL_FUNCTION_WITH_SINGLE_ARG(PyExc_TypeError, tmp_make_exception_arg_3);
1301         Py_DECREF(tmp_make_exception_arg_3);
1302         assert(!(tmp_raise_type_3 == NULL));
1303         exception_type = tmp_raise_type_3;
1304         RAISE_EXCEPTION_WITH_TYPE(&exception_type, &exception_value, &exception_tb);
1305  
1306         goto try_except_handler_1;
1307     }
1308     branch_no_5:;
1309     {
1310         PyObject *tmp_ass_subvalue_2;
1311         PyObject *tmp_expression_value_6;
1312         PyObject *tmp_subscript_value_3;
1313         PyObject *tmp_ass_subscribed_2;
1314         PyObject *tmp_ass_subscript_2;
1315         CHECK_OBJECT(tmp_dict_2__item);
1316         tmp_expression_value_6 = tmp_dict_2__item;
1317         tmp_subscript_value_3 = mod_consts[13];
1318         tmp_ass_subvalue_2 = LOOKUP_SUBSCRIPT_CONST(tmp_expression_value_6, tmp_subscript_value_3, 1);
1319         if (tmp_ass_subvalue_2 == NULL) {
1320             assert(ERROR_OCCURRED());
1321  
1322             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
1323  
1324  
1325  
1326  
1327             goto try_except_handler_1;
1328         }
1329         if (par_kw == NULL) {
1330             Py_DECREF(tmp_ass_subvalue_2);
1331             FORMAT_UNBOUND_LOCAL_ERROR(&exception_type, &exception_value, mod_consts[9]);
1332             exception_tb = NULL;
1333             NORMALIZE_EXCEPTION(&exception_type, &exception_value, &exception_tb);
1334             CHAIN_EXCEPTION(exception_value);
1335  
1336  
1337  
1338             goto try_except_handler_1;
1339         }
1340  
1341         tmp_ass_subscribed_2 = par_kw;
1342         CHECK_OBJECT(tmp_dict_2__key);
1343         tmp_ass_subscript_2 = tmp_dict_2__key;
1344         tmp_result = SET_SUBSCRIPT(tmp_ass_subscribed_2, tmp_ass_subscript_2, tmp_ass_subvalue_2);
1345         Py_DECREF(tmp_ass_subvalue_2);
1346         if (tmp_result == false) {
1347             assert(ERROR_OCCURRED());
1348  
1349             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
1350  
1351  
1352  
1353  
1354             goto try_except_handler_1;
1355         }
1356     }
1357     if (CONSIDER_THREADING() == false) {
1358         assert(ERROR_OCCURRED());
1359  
1360         FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
1361  
1362  
1363  
1364  
1365         goto try_except_handler_1;
1366     }
1367     goto loop_start_2;
1368     loop_end_2:;
1369     branch_no_4:;
1370     branch_end_1:;
1371     goto try_end_2;
1372     // Exception handler code:
1373     try_except_handler_1:;
1374     exception_keeper_type_2 = exception_type;
1375     exception_keeper_value_2 = exception_value;
1376     exception_keeper_tb_2 = exception_tb;
1377     exception_keeper_lineno_2 = exception_lineno;
1378     exception_type = NULL;
1379     exception_value = NULL;
1380     exception_tb = NULL;
1381     exception_lineno = 0;
1382  
1383     Py_XDECREF(tmp_dict_1__iter);
1384     tmp_dict_1__iter = NULL;
1385     Py_XDECREF(tmp_dict_1__keys);
1386     tmp_dict_1__keys = NULL;
1387     Py_XDECREF(tmp_dict_1__key_xxx);
1388     tmp_dict_1__key_xxx = NULL;
1389     Py_XDECREF(tmp_dict_2__iter);
1390     tmp_dict_2__iter = NULL;
1391     Py_XDECREF(tmp_dict_2__item);
1392     tmp_dict_2__item = NULL;
1393     Py_XDECREF(tmp_dict_2__key);
1394     tmp_dict_2__key = NULL;
1395     // Re-raise.
1396     exception_type = exception_keeper_type_2;
1397     exception_value = exception_keeper_value_2;
1398     exception_tb = exception_keeper_tb_2;
1399     exception_lineno = exception_keeper_lineno_2;
1400  
1401     goto function_exception_exit;
1402     // End of try:
1403     try_end_2:;
1404     Py_XDECREF(tmp_dict_1__iter);
1405     tmp_dict_1__iter = NULL;
1406     Py_XDECREF(tmp_dict_1__keys);
1407     tmp_dict_1__keys = NULL;
1408     Py_XDECREF(tmp_dict_1__key_xxx);
1409     tmp_dict_1__key_xxx = NULL;
1410     Py_XDECREF(tmp_dict_2__iter);
1411     tmp_dict_2__iter = NULL;
1412     Py_XDECREF(tmp_dict_2__item);
1413     tmp_dict_2__item = NULL;
1414     Py_XDECREF(tmp_dict_2__key);
1415     tmp_dict_2__key = NULL;
1416     {
1417         PyObject *tmp_called_value_3;
1418         PyObject *tmp_kw_dict_1;
1419         CHECK_OBJECT(par_called);
1420         tmp_called_value_3 = par_called;
1421         if (par_kw == NULL) {
1422  
1423             FORMAT_UNBOUND_LOCAL_ERROR(&exception_type, &exception_value, mod_consts[9]);
1424             exception_tb = NULL;
1425             NORMALIZE_EXCEPTION(&exception_type, &exception_value, &exception_tb);
1426             CHAIN_EXCEPTION(exception_value);
1427  
1428  
1429  
1430             goto function_exception_exit;
1431         }
1432  
1433         tmp_kw_dict_1 = par_kw;
1434         tmp_return_value = CALL_FUNCTION_WITH_KEYARGS(tmp_called_value_3, tmp_kw_dict_1);
1435  
1436         if (tmp_return_value == NULL) {
1437             assert(ERROR_OCCURRED());
1438  
1439             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
1440  
1441  
1442  
1443  
1444             goto function_exception_exit;
1445         }
1446         goto function_return_exit;
1447     }
1448  
1449     NUITKA_CANNOT_GET_HERE("Return statement must have exited already.");
1450     return NULL;
1451  
1452 function_exception_exit:
1453     CHECK_OBJECT(par_called);
1454     Py_DECREF(par_called);
1455     CHECK_OBJECT(par_kw);
1456     Py_DECREF(par_kw);
1457     CHECK_OBJECT(par_star_arg_dict);
1458     Py_DECREF(par_star_arg_dict);    assert(exception_type);
1459     RESTORE_ERROR_OCCURRED(exception_type, exception_value, exception_tb);
1460  
1461     return NULL;
1462  
1463 function_return_exit:
1464    // Function cleanup code if any.
1465     CHECK_OBJECT(par_called);
1466     Py_DECREF(par_called);
1467     CHECK_OBJECT(par_kw);
1468     Py_DECREF(par_kw);
1469     CHECK_OBJECT(par_star_arg_dict);
1470     Py_DECREF(par_star_arg_dict);
1471  
1472    // Actual function exit with return value, making sure we did not make
1473    // the error status worse despite non-NULL return.
1474    CHECK_OBJECT(tmp_return_value);
1475    assert(had_error || !ERROR_OCCURRED());
1476    return tmp_return_value;
1477 }
1478  
1479  
1480 NUITKA_LOCAL_MODULE PyObject *impl___main__$$$function__2_get_callable_name_desc(PyObject **python_pars) {
1481 #ifndef __NUITKA_NO_ASSERT__
1482     NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED();
1483     assert(!had_error); // Do not enter inlined functions with error set.
1484 #endif
1485  
1486     // Local variable declarations.
1487     PyObject *par_called = python_pars[0];
1488     int tmp_res;
1489     PyObject *exception_type = NULL;
1490     PyObject *exception_value = NULL;
1491     PyTracebackObject *exception_tb = NULL;
1492     NUITKA_MAY_BE_UNUSED int exception_lineno = 0;
1493     PyObject *tmp_return_value = NULL;
1494  
1495     // Actual function body.
1496     {
1497         nuitka_bool tmp_condition_result_1;
1498         PyObject *tmp_isinstance_inst_1;
1499         PyObject *tmp_isinstance_cls_1;
1500         CHECK_OBJECT(par_called);
1501         tmp_isinstance_inst_1 = par_called;
1502         tmp_isinstance_cls_1 = mod_consts[14];
1503         tmp_res = Nuitka_IsInstance(tmp_isinstance_inst_1, tmp_isinstance_cls_1);
1504         if (tmp_res == -1) {
1505             assert(ERROR_OCCURRED());
1506  
1507             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
1508  
1509  
1510  
1511  
1512             goto function_exception_exit;
1513         }
1514         tmp_condition_result_1 = (tmp_res != 0) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
1515         if (tmp_condition_result_1 == NUITKA_BOOL_TRUE) {
1516             goto branch_yes_1;
1517         } else {
1518             goto branch_no_1;
1519         }
1520     }
1521     branch_yes_1:;
1522     {
1523         PyObject *tmp_left_value_1;
1524         PyObject *tmp_expression_value_1;
1525         PyObject *tmp_right_value_1;
1526         CHECK_OBJECT(par_called);
1527         tmp_expression_value_1 = par_called;
1528         tmp_left_value_1 = LOOKUP_ATTRIBUTE(tmp_expression_value_1, mod_consts[8]);
1529         if (tmp_left_value_1 == NULL) {
1530             assert(ERROR_OCCURRED());
1531  
1532             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
1533  
1534  
1535  
1536  
1537             goto function_exception_exit;
1538         }
1539         tmp_right_value_1 = mod_consts[15];
1540         tmp_return_value = BINARY_OPERATION_ADD_OBJECT_OBJECT_UNICODE(tmp_left_value_1, tmp_right_value_1);
1541         Py_DECREF(tmp_left_value_1);
1542         if (tmp_return_value == NULL) {
1543             assert(ERROR_OCCURRED());
1544  
1545             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
1546  
1547  
1548  
1549  
1550             goto function_exception_exit;
1551         }
1552         goto function_return_exit;
1553     }
1554     goto branch_end_1;
1555     branch_no_1:;
1556     {
1557         PyObject *tmp_left_value_2;
1558         PyObject *tmp_expression_value_2;
1559         PyObject *tmp_type_arg_1;
1560         PyObject *tmp_right_value_2;
1561         CHECK_OBJECT(par_called);
1562         tmp_type_arg_1 = par_called;
1563         tmp_expression_value_2 = BUILTIN_TYPE1(tmp_type_arg_1);
1564         assert(!(tmp_expression_value_2 == NULL));
1565         tmp_left_value_2 = LOOKUP_ATTRIBUTE(tmp_expression_value_2, mod_consts[8]);
1566         Py_DECREF(tmp_expression_value_2);
1567         if (tmp_left_value_2 == NULL) {
1568             assert(ERROR_OCCURRED());
1569  
1570             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
1571  
1572  
1573  
1574  
1575             goto function_exception_exit;
1576         }
1577         tmp_right_value_2 = mod_consts[16];
1578         tmp_return_value = BINARY_OPERATION_ADD_OBJECT_OBJECT_UNICODE(tmp_left_value_2, tmp_right_value_2);
1579         Py_DECREF(tmp_left_value_2);
1580         if (tmp_return_value == NULL) {
1581             assert(ERROR_OCCURRED());
1582  
1583             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
1584  
1585  
1586  
1587  
1588             goto function_exception_exit;
1589         }
1590         goto function_return_exit;
1591     }
1592     branch_end_1:;
1593  
1594     NUITKA_CANNOT_GET_HERE("Return statement must have exited already.");
1595     return NULL;
1596  
1597 function_exception_exit:
1598     CHECK_OBJECT(par_called);
1599     Py_DECREF(par_called);    assert(exception_type);
1600     RESTORE_ERROR_OCCURRED(exception_type, exception_value, exception_tb);
1601  
1602     return NULL;
1603  
1604 function_return_exit:
1605    // Function cleanup code if any.
1606     CHECK_OBJECT(par_called);
1607     Py_DECREF(par_called);
1608  
1609    // Actual function exit with return value, making sure we did not make
1610    // the error status worse despite non-NULL return.
1611    CHECK_OBJECT(tmp_return_value);
1612    assert(had_error || !ERROR_OCCURRED());
1613    return tmp_return_value;
1614 }
1615  
1616  
1617 472
1618 static PyObject *MAKE_FUNCTION___main__$$$function__1_compiled_func() { 473 static PyObject *MAKE_FUNCTION___main__$$$function__1_compiled_func() {
1619     struct Nuitka_FunctionObject *result = Nuitka_Function_New( 474     struct Nuitka_FunctionObject *result = Nuitka_Function_New(
1620         impl___main__$$$function__1_compiled_func, 475         impl___main__$$$function__1_compiled_func,
1621         mod_consts[1], 476         mod_consts[1],
1656         module___main__, 511         module___main__,
1657         NULL, 512         NULL,
1658         NULL, 513         NULL,
1659         0 514         0
1660     ); 515     );
n 1661     Nuitka_Function_EnableConstReturnGeneric(result, mod_consts[23]); n 516     Nuitka_Function_EnableConstReturnGeneric(result, mod_consts[8]);
1662 517
1663     return (PyObject *)result; 518     return (PyObject *)result;
1664 } 519 }
1665 520
1666 521
1667 522
1668 static PyObject *MAKE_FUNCTION___main__$$$function__3_calledRepeatedly() { 523 static PyObject *MAKE_FUNCTION___main__$$$function__3_calledRepeatedly() {
1669     struct Nuitka_FunctionObject *result = Nuitka_Function_New( 524     struct Nuitka_FunctionObject *result = Nuitka_Function_New(
1670         impl___main__$$$function__3_calledRepeatedly, 525         impl___main__$$$function__3_calledRepeatedly,
n 1671         mod_consts[25], n 526         mod_consts[11],
1672 #if PYTHON_VERSION >= 0x300 527 #if PYTHON_VERSION >= 0x300
1673         NULL, 528         NULL,
1674 #endif 529 #endif
1675         codeobj_fdf994e132a3c9da036a7f384d7af412, 530         codeobj_fdf994e132a3c9da036a7f384d7af412,
1676         NULL, 531         NULL,
2053 908
2054     // Module code. 909     // Module code.
2055     { 910     {
2056         PyObject *tmp_assign_source_1; 911         PyObject *tmp_assign_source_1;
2057         tmp_assign_source_1 = Py_None; 912         tmp_assign_source_1 = Py_None;
n 2058         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[17], tmp_assign_source_1); n 913         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[2], tmp_assign_source_1);
2059     } 914     }
2060     { 915     {
2061         PyObject *tmp_assign_source_2; 916         PyObject *tmp_assign_source_2;
n 2062         tmp_assign_source_2 = mod_consts[18]; n 917         tmp_assign_source_2 = mod_consts[3];
2063         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[19], tmp_assign_source_2); 918         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[4], tmp_assign_source_2);
2064     } 919     }
2065     { 920     {
2066         PyObject *tmp_assign_source_3; 921         PyObject *tmp_assign_source_3;
2067         tmp_assign_source_3 = Py_None; 922         tmp_assign_source_3 = Py_None;
n 2068         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[20], tmp_assign_source_3); n 923         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[5], tmp_assign_source_3);
2069     } 924     }
2070     { 925     {
2071         PyObject *tmp_assign_source_4; 926         PyObject *tmp_assign_source_4;
2072         tmp_assign_source_4 = PyDict_New(); 927         tmp_assign_source_4 = PyDict_New();
n 2073         UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[21], tmp_assign_source_4); n 928         UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[6], tmp_assign_source_4);
2074     } 929     }
2075     { 930     {
2076         PyObject *tmp_assign_source_5; 931         PyObject *tmp_assign_source_5;
2077         { 932         {
2078             PyObject *hard_module = IMPORT_HARD___FUTURE__(); 933             PyObject *hard_module = IMPORT_HARD___FUTURE__();
n 2079             tmp_assign_source_5 = LOOKUP_ATTRIBUTE(hard_module, mod_consts[22]); n 934             tmp_assign_source_5 = LOOKUP_ATTRIBUTE(hard_module, mod_consts[7]);
2080         } 935         }
2081 936
2082         assert(!(tmp_assign_source_5 == NULL)); 937         assert(!(tmp_assign_source_5 == NULL));
n 2083         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[22], tmp_assign_source_5); n 938         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[7], tmp_assign_source_5);
2084     } 939     }
2085     { 940     {
2086         PyObject *tmp_assign_source_6; 941         PyObject *tmp_assign_source_6;
2087 942
2088 943
2098 953
2099         UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[0], tmp_assign_source_7); 954         UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[0], tmp_assign_source_7);
2100     } 955     }
2101     { 956     {
2102         PyObject *tmp_assign_source_8; 957         PyObject *tmp_assign_source_8;
n 2103         tmp_assign_source_8 = PyDict_Copy(mod_consts[24]); n 958         tmp_assign_source_8 = PyDict_Copy(mod_consts[9]);
2104         UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[5], tmp_assign_source_8); 959         UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[10], tmp_assign_source_8);
2105     } 960     }
2106     { 961     {
2107         PyObject *tmp_assign_source_9; 962         PyObject *tmp_assign_source_9;
2108 963
2109 964
2110         tmp_assign_source_9 = MAKE_FUNCTION___main__$$$function__3_calledRepeatedly(); 965         tmp_assign_source_9 = MAKE_FUNCTION___main__$$$function__3_calledRepeatedly();
2111 966
n 2112         UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[25], tmp_assign_source_9); n 967         UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[11], tmp_assign_source_9);
2113     } 968     }
2114     { 969     {
2115         PyObject *tmp_assign_source_10; 970         PyObject *tmp_assign_source_10;
2116         PyObject *tmp_name_value_1; 971         PyObject *tmp_name_value_1;
2117         PyObject *tmp_globals_arg_value_1; 972         PyObject *tmp_globals_arg_value_1;
2118         PyObject *tmp_locals_arg_value_1; 973         PyObject *tmp_locals_arg_value_1;
2119         PyObject *tmp_fromlist_value_1; 974         PyObject *tmp_fromlist_value_1;
2120         PyObject *tmp_level_value_1; 975         PyObject *tmp_level_value_1;
n 2121         tmp_name_value_1 = mod_consts[26]; n 976         tmp_name_value_1 = mod_consts[12];
2122         tmp_globals_arg_value_1 = (PyObject *)moduledict___main__; 977         tmp_globals_arg_value_1 = (PyObject *)moduledict___main__;
2123         tmp_locals_arg_value_1 = Py_None; 978         tmp_locals_arg_value_1 = Py_None;
2124         tmp_fromlist_value_1 = Py_None; 979         tmp_fromlist_value_1 = Py_None;
n 2125         tmp_level_value_1 = mod_consts[12]; n 980         tmp_level_value_1 = mod_consts[13];
2126         tmp_assign_source_10 = IMPORT_MODULE5(tmp_name_value_1, tmp_globals_arg_value_1, tmp_locals_arg_value_1, tmp_fromlist_value_1, tmp_level_value_1); 981         tmp_assign_source_10 = IMPORT_MODULE5(tmp_name_value_1, tmp_globals_arg_value_1, tmp_locals_arg_value_1, tmp_fromlist_value_1, tmp_level_value_1);
2127         assert(!(tmp_assign_source_10 == NULL)); 982         assert(!(tmp_assign_source_10 == NULL));
n 2128         UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[26], tmp_assign_source_10); n 983         UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[12], tmp_assign_source_10);
2129     } 984     }
2130     // Frame without reuse. 985     // Frame without reuse.
2131     frame_a2dd8b68076bca397252eb5ed9e6e875 = MAKE_MODULE_FRAME(codeobj_a2dd8b68076bca397252eb5ed9e6e875, module___main__); 986     frame_a2dd8b68076bca397252eb5ed9e6e875 = MAKE_MODULE_FRAME(codeobj_a2dd8b68076bca397252eb5ed9e6e875, module___main__);
2132 987
2133     // Push the new frame as the currently active one, and we should be exclusively 988     // Push the new frame as the currently active one, and we should be exclusively
2138     // Framed code: 993     // Framed code:
2139     { 994     {
2140         PyObject *tmp_assign_source_11; 995         PyObject *tmp_assign_source_11;
2141         PyObject *tmp_iter_arg_1; 996         PyObject *tmp_iter_arg_1;
2142         PyObject *tmp_called_instance_1; 997         PyObject *tmp_called_instance_1;
n 2143         tmp_called_instance_1 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[26]); n 998         tmp_called_instance_1 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[12]);
2144 999
2145         if (unlikely(tmp_called_instance_1 == NULL)) { 1000         if (unlikely(tmp_called_instance_1 == NULL)) {
n 2146             tmp_called_instance_1 = GET_MODULE_VARIABLE_VALUE_FALLBACK(mod_consts[26]); n 1001             tmp_called_instance_1 = GET_MODULE_VARIABLE_VALUE_FALLBACK(mod_consts[12]);
2147         } 1002         }
2148 1003
2149         assert(!(tmp_called_instance_1 == NULL)); 1004         assert(!(tmp_called_instance_1 == NULL));
2150         frame_a2dd8b68076bca397252eb5ed9e6e875->m_frame.f_lineno = 54; 1005         frame_a2dd8b68076bca397252eb5ed9e6e875->m_frame.f_lineno = 54;
2151         tmp_iter_arg_1 = CALL_METHOD_WITH_ARGS2( 1006         tmp_iter_arg_1 = CALL_METHOD_WITH_ARGS2(
2152             tmp_called_instance_1, 1007             tmp_called_instance_1,
n 2153             mod_consts[27], n 1008             mod_consts[14],
2154             &PyTuple_GET_ITEM(mod_consts[28], 0) 1009             &PyTuple_GET_ITEM(mod_consts[15], 0)
2155         ); 1010         );
2156 1011
2157         if (tmp_iter_arg_1 == NULL) { 1012         if (tmp_iter_arg_1 == NULL) {
2158             assert(ERROR_OCCURRED()); 1013             assert(ERROR_OCCURRED());
2159 1014
2209     } 1064     }
2210     { 1065     {
2211         PyObject *tmp_assign_source_13; 1066         PyObject *tmp_assign_source_13;
2212         CHECK_OBJECT(tmp_for_loop_1__iter_value); 1067         CHECK_OBJECT(tmp_for_loop_1__iter_value);
2213         tmp_assign_source_13 = tmp_for_loop_1__iter_value; 1068         tmp_assign_source_13 = tmp_for_loop_1__iter_value;
n 2214         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[29], tmp_assign_source_13); n 1069         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[16], tmp_assign_source_13);
2215     } 1070     }
2216     { 1071     {
2217         PyObject *tmp_called_value_1; 1072         PyObject *tmp_called_value_1;
2218         PyObject *tmp_call_result_1; 1073         PyObject *tmp_call_result_1;
n 2219         tmp_called_value_1 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[25]); n 1074         tmp_called_value_1 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[11]);
2220 1075
2221         if (unlikely(tmp_called_value_1 == NULL)) { 1076         if (unlikely(tmp_called_value_1 == NULL)) {
n 2222             tmp_called_value_1 = GET_MODULE_VARIABLE_VALUE_FALLBACK(mod_consts[25]); n 1077             tmp_called_value_1 = GET_MODULE_VARIABLE_VALUE_FALLBACK(mod_consts[11]);
2223         } 1078         }
2224 1079
2225         if (tmp_called_value_1 == NULL) { 1080         if (tmp_called_value_1 == NULL) {
2226             assert(ERROR_OCCURRED()); 1081             assert(ERROR_OCCURRED());
2227 1082
2290     Py_DECREF(tmp_for_loop_1__for_iterator); 1145     Py_DECREF(tmp_for_loop_1__for_iterator);
2291     tmp_for_loop_1__for_iterator = NULL; 1146     tmp_for_loop_1__for_iterator = NULL;
2292     { 1147     {
2293         PyObject *tmp_called_value_2; 1148         PyObject *tmp_called_value_2;
2294         PyObject *tmp_call_result_2; 1149         PyObject *tmp_call_result_2;
n 2295         tmp_called_value_2 = LOOKUP_BUILTIN(mod_consts[30]); n 1150         tmp_called_value_2 = LOOKUP_BUILTIN(mod_consts[17]);
2296         assert(tmp_called_value_2 != NULL); 1151         assert(tmp_called_value_2 != NULL);
2297         frame_a2dd8b68076bca397252eb5ed9e6e875->m_frame.f_lineno = 57; 1152         frame_a2dd8b68076bca397252eb5ed9e6e875->m_frame.f_lineno = 57;
t 2298         tmp_call_result_2 = CALL_FUNCTION_WITH_POSARGS1(tmp_called_value_2, mod_consts[31]); t 1153         tmp_call_result_2 = CALL_FUNCTION_WITH_POSARGS1(tmp_called_value_2, mod_consts[18]);
2299 1154
2300         if (tmp_call_result_2 == NULL) { 1155         if (tmp_call_result_2 == NULL) {
2301             assert(ERROR_OCCURRED()); 1156             assert(ERROR_OCCURRED());
2302 1157
2303             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb); 1158             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);