Construct CallCompiledFunctionKwArgsVariableStarDict

Performance Diagrams

Construct CallCompiledFunctionKwArgsVariableStarDict 00100000000100000000200000000200000000300000000300000000400000000400000000500000000500000000600000000600000000700000000700000000800000000800000000CPython 2.7Nuitka (master)Nuitka (develop)Nuitka (factory)58966971388.11538461538461338.6685879856486CPython 2.7880745115240.03846153846155257.0Nuitka (master)809890686391.96153846153845276.88000747984677Nuitka (develop)809890686543.8846153846154276.88000747984677Nuitka (factory)Construct CallCompiledFunctionKwArgsVariableStarDictTicks Construct CallCompiledFunctionKwArgsVariableStarDict 0010000000010000000020000000020000000030000000030000000040000000040000000050000000050000000060000000060000000070000000070000000080000000080000000090000000090000000010000000001000000000CPython 3.8Nuitka (master)Nuitka (develop)Nuitka (factory)74999568287.27884615384615329.3162503725802CPython 3.81060276827237.75961538461542257.0Nuitka (master)1039123580388.2403846153846261.93012073371403Nuitka (develop)1039123580538.7211538461538261.93012073371403Nuitka (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[37]; 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[37]; 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 < 37; 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 < 37; 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_d714a92027e3da0b5f47a89f7881fe78; 84 static PyCodeObject *codeobj_d714a92027e3da0b5f47a89f7881fe78;
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[20]; CHECK_OBJECT(module_filename_obj); n 89     module_filename_obj = mod_consts[3]; CHECK_OBJECT(module_filename_obj);
90     codeobj_266d472510eb96ff5edb40878163dfa1 = MAKE_CODEOBJECT(module_filename_obj, 1, CO_NOFREE, mod_consts[34], NULL, NULL, 0, 0, 0); 90     codeobj_266d472510eb96ff5edb40878163dfa1 = MAKE_CODEOBJECT(module_filename_obj, 1, CO_NOFREE, mod_consts[19], NULL, NULL, 0, 0, 0);
91     codeobj_af34e7c1e8d078d092ea230386e8b765 = MAKE_CODEOBJECT(module_filename_obj, 34, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE, mod_consts[27], mod_consts[35], NULL, 0, 0, 0); 91     codeobj_af34e7c1e8d078d092ea230386e8b765 = MAKE_CODEOBJECT(module_filename_obj, 34, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE, mod_consts[11], mod_consts[20], NULL, 0, 0, 0);
92     codeobj_eadde4f836a69b6011d58afd3e60fe83 = MAKE_CODEOBJECT(module_filename_obj, 22, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE, mod_consts[1], mod_consts[36], NULL, 6, 0, 0); 92     codeobj_eadde4f836a69b6011d58afd3e60fe83 = MAKE_CODEOBJECT(module_filename_obj, 22, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE, mod_consts[1], mod_consts[21], NULL, 6, 0, 0);
93     codeobj_d714a92027e3da0b5f47a89f7881fe78 = MAKE_CODEOBJECT(module_filename_obj, 25, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE, mod_consts[0], NULL, NULL, 0, 0, 0); 93     codeobj_d714a92027e3da0b5f47a89f7881fe78 = 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_af34e7c1e8d078d092ea230386e8b765 = NULL; 191     static struct Nuitka_FrameObject *cache_frame_af34e7c1e8d078d092ea230386e8b765 = 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_af34e7c1e8d078d092ea230386e8b765); 353     RESTORE_FRAME_EXCEPTION(frame_af34e7c1e8d078d092ea230386e8b765);
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__dict = NULL;
673     PyObject *tmp_dict_1__iter = NULL;
674     PyObject *tmp_dict_1__key_xxx = NULL;
675     PyObject *tmp_dict_1__keys = NULL;
676     PyObject *tmp_dict_2__item = NULL;
677     PyObject *tmp_dict_2__iter = NULL;
678     PyObject *tmp_dict_2__key = NULL;
679     PyObject *exception_type = NULL;
680     PyObject *exception_value = NULL;
681     PyTracebackObject *exception_tb = NULL;
682     NUITKA_MAY_BE_UNUSED int exception_lineno = 0;
683     PyObject *exception_keeper_type_1;
684     PyObject *exception_keeper_value_1;
685     PyTracebackObject *exception_keeper_tb_1;
686     NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_1;
687     int tmp_res;
688     bool tmp_result;
689     PyObject *exception_keeper_type_2;
690     PyObject *exception_keeper_value_2;
691     PyTracebackObject *exception_keeper_tb_2;
692     NUITKA_MAY_BE_UNUSED int exception_keeper_lineno_2;
693     PyObject *tmp_return_value = NULL;
694  
695     // Actual function body.
696     // Tried code:
697     {
698         bool tmp_condition_result_1;
699         PyObject *tmp_compexpr_left_1;
700         PyObject *tmp_compexpr_right_1;
701         PyObject *tmp_type_arg_1;
702         CHECK_OBJECT(par_star_arg_dict);
703         tmp_type_arg_1 = par_star_arg_dict;
704         tmp_compexpr_left_1 = BUILTIN_TYPE1(tmp_type_arg_1);
705         assert(!(tmp_compexpr_left_1 == NULL));
706         tmp_compexpr_right_1 = (PyObject *)&PyDict_Type;
707         tmp_condition_result_1 = (tmp_compexpr_left_1 != tmp_compexpr_right_1) ? true : false;
708         Py_DECREF(tmp_compexpr_left_1);
709         if (tmp_condition_result_1 != false) {
710             goto branch_yes_1;
711         } else {
712             goto branch_no_1;
713         }
714     }
715     branch_yes_1:;
716     // Tried code:
717     {
718         PyObject *tmp_assign_source_1;
719         PyObject *tmp_called_instance_1;
720         CHECK_OBJECT(par_star_arg_dict);
721         tmp_called_instance_1 = par_star_arg_dict;
722         tmp_assign_source_1 = CALL_METHOD_NO_ARGS(tmp_called_instance_1, mod_consts[6]);
723         if (tmp_assign_source_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         assert(tmp_dict_1__keys == NULL);
734         tmp_dict_1__keys = tmp_assign_source_1;
735     }
736     goto try_end_1;
737     // Exception handler code:
738     try_except_handler_2:;
739     exception_keeper_type_1 = exception_type;
740     exception_keeper_value_1 = exception_value;
741     exception_keeper_tb_1 = exception_tb;
742     exception_keeper_lineno_1 = exception_lineno;
743     exception_type = NULL;
744     exception_value = NULL;
745     exception_tb = NULL;
746     exception_lineno = 0;
747  
748     {
749         bool tmp_condition_result_2;
750         PyObject *tmp_compexpr_left_2;
751         PyObject *tmp_compexpr_right_2;
752         tmp_compexpr_left_2 = exception_keeper_type_1;
753         tmp_compexpr_right_2 = PyExc_AttributeError;
754         tmp_res = EXCEPTION_MATCH_BOOL(tmp_compexpr_left_2, tmp_compexpr_right_2);
755         assert(!(tmp_res == -1));
756         tmp_condition_result_2 = (tmp_res != 0) ? true : false;
757         if (tmp_condition_result_2 != false) {
758             goto branch_yes_2;
759         } else {
760             goto branch_no_2;
761         }
762     }
763     branch_yes_2:;
764     {
765         PyObject *tmp_raise_type_1;
766         PyObject *tmp_make_exception_arg_1;
767         PyObject *tmp_left_name_1;
768         PyObject *tmp_right_name_1;
769         PyObject *tmp_tuple_element_1;
770         PyObject *tmp_dircall_arg1_1;
771         tmp_left_name_1 = mod_consts[7];
772         CHECK_OBJECT(par_called);
773         tmp_dircall_arg1_1 = par_called;
774         Py_INCREF(tmp_dircall_arg1_1);
775  
776         {
777             PyObject *dir_call_args[] = {tmp_dircall_arg1_1};
778             tmp_tuple_element_1 = impl___main__$$$function__2_get_callable_name_desc(dir_call_args);
779         }
780         if (tmp_tuple_element_1 == NULL) {
781             assert(ERROR_OCCURRED());
782  
783             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
784  
785             Py_DECREF(exception_keeper_type_1);
786             Py_XDECREF(exception_keeper_value_1);
787             Py_XDECREF(exception_keeper_tb_1);
788  
789  
790  
791             goto try_except_handler_1;
792         }
793         tmp_right_name_1 = PyTuple_New(2);
794         {
795             PyObject *tmp_expression_name_1;
796             PyObject *tmp_type_arg_2;
797             PyTuple_SET_ITEM(tmp_right_name_1, 0, tmp_tuple_element_1);
798             CHECK_OBJECT(par_star_arg_dict);
799             tmp_type_arg_2 = par_star_arg_dict;
800             tmp_expression_name_1 = BUILTIN_TYPE1(tmp_type_arg_2);
801             assert(!(tmp_expression_name_1 == NULL));
802             tmp_tuple_element_1 = LOOKUP_ATTRIBUTE(tmp_expression_name_1, mod_consts[8]);
803             Py_DECREF(tmp_expression_name_1);
804             if (tmp_tuple_element_1 == NULL) {
805                 assert(ERROR_OCCURRED());
806  
807                 FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
808  
809                 Py_DECREF(exception_keeper_type_1);
810                 Py_XDECREF(exception_keeper_value_1);
811                 Py_XDECREF(exception_keeper_tb_1);
812  
813  
814  
815                 goto tuple_build_exception_1;
816             }
817             PyTuple_SET_ITEM(tmp_right_name_1, 1, tmp_tuple_element_1);
818         }
819         goto tuple_build_noexception_1;
820         // Exception handling pass through code for tuple_build:
821         tuple_build_exception_1:;
822         Py_DECREF(tmp_right_name_1);
823         Py_DECREF(exception_keeper_type_1);
824         Py_XDECREF(exception_keeper_value_1);
825         Py_XDECREF(exception_keeper_tb_1);
826         goto try_except_handler_1;
827         // Finished with no exception for tuple_build:
828         tuple_build_noexception_1:;
829         tmp_make_exception_arg_1 = BINARY_OPERATION_MOD_OBJECT_UNICODE_TUPLE(tmp_left_name_1, tmp_right_name_1);
830         Py_DECREF(tmp_right_name_1);
831         if (tmp_make_exception_arg_1 == NULL) {
832             assert(ERROR_OCCURRED());
833  
834             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
835  
836             Py_DECREF(exception_keeper_type_1);
837             Py_XDECREF(exception_keeper_value_1);
838             Py_XDECREF(exception_keeper_tb_1);
839  
840  
841  
842             goto try_except_handler_1;
843         }
844         tmp_raise_type_1 = CALL_FUNCTION_WITH_SINGLE_ARG(PyExc_TypeError, tmp_make_exception_arg_1);
845         Py_DECREF(tmp_make_exception_arg_1);
846         assert(!(tmp_raise_type_1 == NULL));
847         exception_type = tmp_raise_type_1;
848         RAISE_EXCEPTION_WITH_TYPE(&exception_type, &exception_value, &exception_tb);
849  
850         goto try_except_handler_1;
851     }
852     goto branch_end_2;
853     branch_no_2:;
854     // Re-raise.
855     exception_type = exception_keeper_type_1;
856     exception_value = exception_keeper_value_1;
857     exception_tb = exception_keeper_tb_1;
858     exception_lineno = exception_keeper_lineno_1;
859  
860     goto try_except_handler_1;
861     branch_end_2:;
862     // End of try:
863     try_end_1:;
864     {
865         PyObject *tmp_assign_source_2;
866         PyObject *tmp_iter_arg_1;
867         CHECK_OBJECT(tmp_dict_1__keys);
868         tmp_iter_arg_1 = tmp_dict_1__keys;
869         tmp_assign_source_2 = MAKE_ITERATOR(tmp_iter_arg_1);
870         if (tmp_assign_source_2 == NULL) {
871             assert(ERROR_OCCURRED());
872  
873             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
874  
875  
876  
877  
878             goto try_except_handler_1;
879         }
880         assert(tmp_dict_1__iter == NULL);
881         tmp_dict_1__iter = tmp_assign_source_2;
882     }
883     {
884         PyObject *tmp_assign_source_3;
885         tmp_assign_source_3 = PyDict_New();
886         assert(tmp_dict_1__dict == NULL);
887         tmp_dict_1__dict = tmp_assign_source_3;
888     }
889     loop_start_1:;
890     {
891         PyObject *tmp_next_source_1;
892         PyObject *tmp_assign_source_4;
893         CHECK_OBJECT(tmp_dict_1__iter);
894         tmp_next_source_1 = tmp_dict_1__iter;
895         tmp_assign_source_4 = ITERATOR_NEXT(tmp_next_source_1);
896         if (tmp_assign_source_4 == NULL) {
897             if (CHECK_AND_CLEAR_STOP_ITERATION_OCCURRED()) {
898  
899                 goto loop_end_1;
900             } else {
901  
902                 FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
903  
904  
905                 goto try_except_handler_1;
906             }
907         }
908  
909         {
910             PyObject *old = tmp_dict_1__key_xxx;
911             tmp_dict_1__key_xxx = tmp_assign_source_4;
912             Py_XDECREF(old);
913         }
914  
915     }
916     {
917         bool tmp_condition_result_3;
918         PyObject *tmp_compexpr_left_3;
919         PyObject *tmp_compexpr_right_3;
920         CHECK_OBJECT(tmp_dict_1__key_xxx);
921         tmp_compexpr_left_3 = tmp_dict_1__key_xxx;
922         if (par_kw == NULL) {
923  
924             FORMAT_UNBOUND_LOCAL_ERROR(&exception_type, &exception_value, mod_consts[9]);
925             exception_tb = NULL;
926             NORMALIZE_EXCEPTION(&exception_type, &exception_value, &exception_tb);
927             CHAIN_EXCEPTION(exception_value);
928  
929  
930  
931             goto try_except_handler_1;
932         }
933  
934         tmp_compexpr_right_3 = par_kw;
935         tmp_res = PySequence_Contains(tmp_compexpr_right_3, tmp_compexpr_left_3);
936         if (tmp_res == -1) {
937             assert(ERROR_OCCURRED());
938  
939             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
940  
941  
942  
943  
944             goto try_except_handler_1;
945         }
946         tmp_condition_result_3 = (tmp_res == 1) ? true : false;
947         if (tmp_condition_result_3 != false) {
948             goto branch_yes_3;
949         } else {
950             goto branch_no_3;
951         }
952     }
953     branch_yes_3:;
954     {
955         PyObject *tmp_raise_type_2;
956         PyObject *tmp_make_exception_arg_2;
957         PyObject *tmp_left_name_2;
958         PyObject *tmp_right_name_2;
959         PyObject *tmp_tuple_element_2;
960         PyObject *tmp_dircall_arg1_2;
961         tmp_left_name_2 = mod_consts[10];
962         if (par_called == NULL) {
963  
964             FORMAT_UNBOUND_LOCAL_ERROR(&exception_type, &exception_value, mod_consts[11]);
965             exception_tb = NULL;
966             NORMALIZE_EXCEPTION(&exception_type, &exception_value, &exception_tb);
967             CHAIN_EXCEPTION(exception_value);
968  
969  
970  
971             goto try_except_handler_1;
972         }
973  
974         tmp_dircall_arg1_2 = par_called;
975         Py_INCREF(tmp_dircall_arg1_2);
976  
977         {
978             PyObject *dir_call_args[] = {tmp_dircall_arg1_2};
979             tmp_tuple_element_2 = impl___main__$$$function__2_get_callable_name_desc(dir_call_args);
980         }
981         if (tmp_tuple_element_2 == NULL) {
982             assert(ERROR_OCCURRED());
983  
984             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
985  
986  
987  
988  
989             goto try_except_handler_1;
990         }
991         tmp_right_name_2 = PyTuple_New(2);
992         PyTuple_SET_ITEM(tmp_right_name_2, 0, tmp_tuple_element_2);
993         CHECK_OBJECT(tmp_dict_1__key_xxx);
994         tmp_tuple_element_2 = tmp_dict_1__key_xxx;
995         PyTuple_SET_ITEM0(tmp_right_name_2, 1, tmp_tuple_element_2);
996         tmp_make_exception_arg_2 = BINARY_OPERATION_MOD_OBJECT_UNICODE_TUPLE(tmp_left_name_2, tmp_right_name_2);
997         Py_DECREF(tmp_right_name_2);
998         if (tmp_make_exception_arg_2 == NULL) {
999             assert(ERROR_OCCURRED());
1000  
1001             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
1002  
1003  
1004  
1005  
1006             goto try_except_handler_1;
1007         }
1008         tmp_raise_type_2 = CALL_FUNCTION_WITH_SINGLE_ARG(PyExc_TypeError, tmp_make_exception_arg_2);
1009         Py_DECREF(tmp_make_exception_arg_2);
1010         assert(!(tmp_raise_type_2 == NULL));
1011         exception_type = tmp_raise_type_2;
1012         RAISE_EXCEPTION_WITH_TYPE(&exception_type, &exception_value, &exception_tb);
1013  
1014         goto try_except_handler_1;
1015     }
1016     branch_no_3:;
1017     {
1018         PyObject *tmp_ass_subvalue_1;
1019         PyObject *tmp_expression_name_2;
1020         PyObject *tmp_subscript_name_1;
1021         PyObject *tmp_ass_subscribed_1;
1022         PyObject *tmp_ass_subscript_1;
1023         if (par_star_arg_dict == NULL) {
1024  
1025             FORMAT_UNBOUND_LOCAL_ERROR(&exception_type, &exception_value, mod_consts[12]);
1026             exception_tb = NULL;
1027             NORMALIZE_EXCEPTION(&exception_type, &exception_value, &exception_tb);
1028             CHAIN_EXCEPTION(exception_value);
1029  
1030  
1031  
1032             goto try_except_handler_1;
1033         }
1034  
1035         tmp_expression_name_2 = par_star_arg_dict;
1036         CHECK_OBJECT(tmp_dict_1__key_xxx);
1037         tmp_subscript_name_1 = tmp_dict_1__key_xxx;
1038         tmp_ass_subvalue_1 = LOOKUP_SUBSCRIPT(tmp_expression_name_2, tmp_subscript_name_1);
1039         if (tmp_ass_subvalue_1 == NULL) {
1040             assert(ERROR_OCCURRED());
1041  
1042             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
1043  
1044  
1045  
1046  
1047             goto try_except_handler_1;
1048         }
1049         if (par_kw == NULL) {
1050             Py_DECREF(tmp_ass_subvalue_1);
1051             FORMAT_UNBOUND_LOCAL_ERROR(&exception_type, &exception_value, mod_consts[9]);
1052             exception_tb = NULL;
1053             NORMALIZE_EXCEPTION(&exception_type, &exception_value, &exception_tb);
1054             CHAIN_EXCEPTION(exception_value);
1055  
1056  
1057  
1058             goto try_except_handler_1;
1059         }
1060  
1061         tmp_ass_subscribed_1 = par_kw;
1062         CHECK_OBJECT(tmp_dict_1__key_xxx);
1063         tmp_ass_subscript_1 = tmp_dict_1__key_xxx;
1064         tmp_result = SET_SUBSCRIPT(tmp_ass_subscribed_1, tmp_ass_subscript_1, tmp_ass_subvalue_1);
1065         Py_DECREF(tmp_ass_subvalue_1);
1066         if (tmp_result == false) {
1067             assert(ERROR_OCCURRED());
1068  
1069             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
1070  
1071  
1072  
1073  
1074             goto try_except_handler_1;
1075         }
1076     }
1077     if (CONSIDER_THREADING() == false) {
1078         assert(ERROR_OCCURRED());
1079  
1080         FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
1081  
1082  
1083  
1084  
1085         goto try_except_handler_1;
1086     }
1087     goto loop_start_1;
1088     loop_end_1:;
1089     goto branch_end_1;
1090     branch_no_1:;
1091     {
1092         nuitka_bool tmp_condition_result_4;
1093         int tmp_truth_name_1;
1094         CHECK_OBJECT(par_star_arg_dict);
1095         tmp_truth_name_1 = CHECK_IF_TRUE(par_star_arg_dict);
1096         if (tmp_truth_name_1 == -1) {
1097             assert(ERROR_OCCURRED());
1098  
1099             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
1100  
1101  
1102  
1103  
1104             goto try_except_handler_1;
1105         }
1106         tmp_condition_result_4 = tmp_truth_name_1 == 0 ? NUITKA_BOOL_FALSE : NUITKA_BOOL_TRUE;
1107         if (tmp_condition_result_4 == NUITKA_BOOL_TRUE) {
1108             goto branch_yes_4;
1109         } else {
1110             goto branch_no_4;
1111         }
1112     }
1113     branch_yes_4:;
1114     {
1115         PyObject *tmp_assign_source_5;
1116         PyObject *tmp_dict_seq_1;
1117         CHECK_OBJECT(par_kw);
1118         tmp_dict_seq_1 = par_kw;
1119         tmp_assign_source_5 = TO_DICT(tmp_dict_seq_1, NULL);
1120         if (tmp_assign_source_5 == NULL) {
1121             assert(ERROR_OCCURRED());
1122  
1123             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
1124  
1125  
1126  
1127  
1128             goto try_except_handler_1;
1129         }
1130         {
1131             PyObject *old = par_kw;
1132             assert(old != NULL);
1133             par_kw = tmp_assign_source_5;
1134             Py_DECREF(old);
1135         }
1136  
1137     }
1138     {
1139         PyObject *tmp_assign_source_6;
1140         PyObject *tmp_iter_arg_2;
1141         PyObject *tmp_called_instance_2;
1142         CHECK_OBJECT(par_star_arg_dict);
1143         tmp_called_instance_2 = par_star_arg_dict;
1144         tmp_iter_arg_2 = CALL_METHOD_NO_ARGS(tmp_called_instance_2, mod_consts[13]);
1145         if (tmp_iter_arg_2 == NULL) {
1146             assert(ERROR_OCCURRED());
1147  
1148             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
1149  
1150  
1151  
1152  
1153             goto try_except_handler_1;
1154         }
1155         tmp_assign_source_6 = MAKE_ITERATOR(tmp_iter_arg_2);
1156         Py_DECREF(tmp_iter_arg_2);
1157         if (tmp_assign_source_6 == NULL) {
1158             assert(ERROR_OCCURRED());
1159  
1160             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
1161  
1162  
1163  
1164  
1165             goto try_except_handler_1;
1166         }
1167         assert(tmp_dict_2__iter == NULL);
1168         tmp_dict_2__iter = tmp_assign_source_6;
1169     }
1170     loop_start_2:;
1171     {
1172         PyObject *tmp_next_source_2;
1173         PyObject *tmp_assign_source_7;
1174         CHECK_OBJECT(tmp_dict_2__iter);
1175         tmp_next_source_2 = tmp_dict_2__iter;
1176         tmp_assign_source_7 = ITERATOR_NEXT(tmp_next_source_2);
1177         if (tmp_assign_source_7 == NULL) {
1178             if (CHECK_AND_CLEAR_STOP_ITERATION_OCCURRED()) {
1179  
1180                 goto loop_end_2;
1181             } else {
1182  
1183                 FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
1184  
1185  
1186                 goto try_except_handler_1;
1187             }
1188         }
1189  
1190         {
1191             PyObject *old = tmp_dict_2__item;
1192             tmp_dict_2__item = tmp_assign_source_7;
1193             Py_XDECREF(old);
1194         }
1195  
1196     }
1197     {
1198         PyObject *tmp_assign_source_8;
1199         PyObject *tmp_expression_name_3;
1200         PyObject *tmp_subscript_name_2;
1201         CHECK_OBJECT(tmp_dict_2__item);
1202         tmp_expression_name_3 = tmp_dict_2__item;
1203         tmp_subscript_name_2 = mod_consts[14];
1204         tmp_assign_source_8 = LOOKUP_SUBSCRIPT_CONST(tmp_expression_name_3, tmp_subscript_name_2, 0);
1205         if (tmp_assign_source_8 == NULL) {
1206             assert(ERROR_OCCURRED());
1207  
1208             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
1209  
1210  
1211  
1212  
1213             goto try_except_handler_1;
1214         }
1215         {
1216             PyObject *old = tmp_dict_2__key;
1217             tmp_dict_2__key = tmp_assign_source_8;
1218             Py_XDECREF(old);
1219         }
1220  
1221     }
1222     {
1223         bool tmp_condition_result_5;
1224         PyObject *tmp_compexpr_left_4;
1225         PyObject *tmp_compexpr_right_4;
1226         CHECK_OBJECT(tmp_dict_2__key);
1227         tmp_compexpr_left_4 = tmp_dict_2__key;
1228         if (par_kw == NULL) {
1229  
1230             FORMAT_UNBOUND_LOCAL_ERROR(&exception_type, &exception_value, mod_consts[9]);
1231             exception_tb = NULL;
1232             NORMALIZE_EXCEPTION(&exception_type, &exception_value, &exception_tb);
1233             CHAIN_EXCEPTION(exception_value);
1234  
1235  
1236  
1237             goto try_except_handler_1;
1238         }
1239  
1240         tmp_compexpr_right_4 = par_kw;
1241         tmp_res = PySequence_Contains(tmp_compexpr_right_4, tmp_compexpr_left_4);
1242         if (tmp_res == -1) {
1243             assert(ERROR_OCCURRED());
1244  
1245             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
1246  
1247  
1248  
1249  
1250             goto try_except_handler_1;
1251         }
1252         tmp_condition_result_5 = (tmp_res == 1) ? true : false;
1253         if (tmp_condition_result_5 != false) {
1254             goto branch_yes_5;
1255         } else {
1256             goto branch_no_5;
1257         }
1258     }
1259     branch_yes_5:;
1260     {
1261         PyObject *tmp_raise_type_3;
1262         PyObject *tmp_make_exception_arg_3;
1263         PyObject *tmp_left_name_3;
1264         PyObject *tmp_right_name_3;
1265         PyObject *tmp_tuple_element_3;
1266         PyObject *tmp_dircall_arg1_3;
1267         tmp_left_name_3 = mod_consts[10];
1268         if (par_called == NULL) {
1269  
1270             FORMAT_UNBOUND_LOCAL_ERROR(&exception_type, &exception_value, mod_consts[11]);
1271             exception_tb = NULL;
1272             NORMALIZE_EXCEPTION(&exception_type, &exception_value, &exception_tb);
1273             CHAIN_EXCEPTION(exception_value);
1274  
1275  
1276  
1277             goto try_except_handler_1;
1278         }
1279  
1280         tmp_dircall_arg1_3 = par_called;
1281         Py_INCREF(tmp_dircall_arg1_3);
1282  
1283         {
1284             PyObject *dir_call_args[] = {tmp_dircall_arg1_3};
1285             tmp_tuple_element_3 = impl___main__$$$function__2_get_callable_name_desc(dir_call_args);
1286         }
1287         if (tmp_tuple_element_3 == NULL) {
1288             assert(ERROR_OCCURRED());
1289  
1290             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
1291  
1292  
1293  
1294  
1295             goto try_except_handler_1;
1296         }
1297         tmp_right_name_3 = PyTuple_New(2);
1298         PyTuple_SET_ITEM(tmp_right_name_3, 0, tmp_tuple_element_3);
1299         CHECK_OBJECT(tmp_dict_2__key);
1300         tmp_tuple_element_3 = tmp_dict_2__key;
1301         PyTuple_SET_ITEM0(tmp_right_name_3, 1, tmp_tuple_element_3);
1302         tmp_make_exception_arg_3 = BINARY_OPERATION_MOD_OBJECT_UNICODE_TUPLE(tmp_left_name_3, tmp_right_name_3);
1303         Py_DECREF(tmp_right_name_3);
1304         if (tmp_make_exception_arg_3 == NULL) {
1305             assert(ERROR_OCCURRED());
1306  
1307             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
1308  
1309  
1310  
1311  
1312             goto try_except_handler_1;
1313         }
1314         tmp_raise_type_3 = CALL_FUNCTION_WITH_SINGLE_ARG(PyExc_TypeError, tmp_make_exception_arg_3);
1315         Py_DECREF(tmp_make_exception_arg_3);
1316         assert(!(tmp_raise_type_3 == NULL));
1317         exception_type = tmp_raise_type_3;
1318         RAISE_EXCEPTION_WITH_TYPE(&exception_type, &exception_value, &exception_tb);
1319  
1320         goto try_except_handler_1;
1321     }
1322     branch_no_5:;
1323     {
1324         PyObject *tmp_ass_subvalue_2;
1325         PyObject *tmp_expression_name_4;
1326         PyObject *tmp_subscript_name_3;
1327         PyObject *tmp_ass_subscribed_2;
1328         PyObject *tmp_ass_subscript_2;
1329         CHECK_OBJECT(tmp_dict_2__item);
1330         tmp_expression_name_4 = tmp_dict_2__item;
1331         tmp_subscript_name_3 = mod_consts[15];
1332         tmp_ass_subvalue_2 = LOOKUP_SUBSCRIPT_CONST(tmp_expression_name_4, tmp_subscript_name_3, 1);
1333         if (tmp_ass_subvalue_2 == NULL) {
1334             assert(ERROR_OCCURRED());
1335  
1336             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
1337  
1338  
1339  
1340  
1341             goto try_except_handler_1;
1342         }
1343         if (par_kw == NULL) {
1344             Py_DECREF(tmp_ass_subvalue_2);
1345             FORMAT_UNBOUND_LOCAL_ERROR(&exception_type, &exception_value, mod_consts[9]);
1346             exception_tb = NULL;
1347             NORMALIZE_EXCEPTION(&exception_type, &exception_value, &exception_tb);
1348             CHAIN_EXCEPTION(exception_value);
1349  
1350  
1351  
1352             goto try_except_handler_1;
1353         }
1354  
1355         tmp_ass_subscribed_2 = par_kw;
1356         CHECK_OBJECT(tmp_dict_2__key);
1357         tmp_ass_subscript_2 = tmp_dict_2__key;
1358         tmp_result = SET_SUBSCRIPT(tmp_ass_subscribed_2, tmp_ass_subscript_2, tmp_ass_subvalue_2);
1359         Py_DECREF(tmp_ass_subvalue_2);
1360         if (tmp_result == false) {
1361             assert(ERROR_OCCURRED());
1362  
1363             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
1364  
1365  
1366  
1367  
1368             goto try_except_handler_1;
1369         }
1370     }
1371     if (CONSIDER_THREADING() == false) {
1372         assert(ERROR_OCCURRED());
1373  
1374         FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
1375  
1376  
1377  
1378  
1379         goto try_except_handler_1;
1380     }
1381     goto loop_start_2;
1382     loop_end_2:;
1383     branch_no_4:;
1384     branch_end_1:;
1385     goto try_end_2;
1386     // Exception handler code:
1387     try_except_handler_1:;
1388     exception_keeper_type_2 = exception_type;
1389     exception_keeper_value_2 = exception_value;
1390     exception_keeper_tb_2 = exception_tb;
1391     exception_keeper_lineno_2 = exception_lineno;
1392     exception_type = NULL;
1393     exception_value = NULL;
1394     exception_tb = NULL;
1395     exception_lineno = 0;
1396  
1397     Py_XDECREF(tmp_dict_1__dict);
1398     tmp_dict_1__dict = NULL;
1399     Py_XDECREF(tmp_dict_1__iter);
1400     tmp_dict_1__iter = NULL;
1401     Py_XDECREF(tmp_dict_1__keys);
1402     tmp_dict_1__keys = NULL;
1403     Py_XDECREF(tmp_dict_1__key_xxx);
1404     tmp_dict_1__key_xxx = NULL;
1405     Py_XDECREF(tmp_dict_2__iter);
1406     tmp_dict_2__iter = NULL;
1407     Py_XDECREF(tmp_dict_2__item);
1408     tmp_dict_2__item = NULL;
1409     Py_XDECREF(tmp_dict_2__key);
1410     tmp_dict_2__key = NULL;
1411     // Re-raise.
1412     exception_type = exception_keeper_type_2;
1413     exception_value = exception_keeper_value_2;
1414     exception_tb = exception_keeper_tb_2;
1415     exception_lineno = exception_keeper_lineno_2;
1416  
1417     goto function_exception_exit;
1418     // End of try:
1419     try_end_2:;
1420     Py_XDECREF(tmp_dict_1__dict);
1421     tmp_dict_1__dict = NULL;
1422     Py_XDECREF(tmp_dict_1__iter);
1423     tmp_dict_1__iter = NULL;
1424     Py_XDECREF(tmp_dict_1__keys);
1425     tmp_dict_1__keys = NULL;
1426     Py_XDECREF(tmp_dict_1__key_xxx);
1427     tmp_dict_1__key_xxx = NULL;
1428     Py_XDECREF(tmp_dict_2__iter);
1429     tmp_dict_2__iter = NULL;
1430     Py_XDECREF(tmp_dict_2__item);
1431     tmp_dict_2__item = NULL;
1432     Py_XDECREF(tmp_dict_2__key);
1433     tmp_dict_2__key = NULL;
1434     {
1435         PyObject *tmp_called_name_1;
1436         PyObject *tmp_kw_dict_1;
1437         if (par_called == NULL) {
1438  
1439             FORMAT_UNBOUND_LOCAL_ERROR(&exception_type, &exception_value, mod_consts[11]);
1440             exception_tb = NULL;
1441             NORMALIZE_EXCEPTION(&exception_type, &exception_value, &exception_tb);
1442             CHAIN_EXCEPTION(exception_value);
1443  
1444  
1445  
1446             goto function_exception_exit;
1447         }
1448  
1449         tmp_called_name_1 = par_called;
1450         if (par_kw == NULL) {
1451  
1452             FORMAT_UNBOUND_LOCAL_ERROR(&exception_type, &exception_value, mod_consts[9]);
1453             exception_tb = NULL;
1454             NORMALIZE_EXCEPTION(&exception_type, &exception_value, &exception_tb);
1455             CHAIN_EXCEPTION(exception_value);
1456  
1457  
1458  
1459             goto function_exception_exit;
1460         }
1461  
1462         tmp_kw_dict_1 = par_kw;
1463         tmp_return_value = CALL_FUNCTION_WITH_KEYARGS(tmp_called_name_1, tmp_kw_dict_1);
1464  
1465         if (tmp_return_value == NULL) {
1466             assert(ERROR_OCCURRED());
1467  
1468             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
1469  
1470  
1471  
1472  
1473             goto function_exception_exit;
1474         }
1475         goto function_return_exit;
1476     }
1477  
1478     NUITKA_CANNOT_GET_HERE("Return statement must have exited already.");
1479     return NULL;
1480  
1481 function_exception_exit:
1482     CHECK_OBJECT(par_called);
1483     Py_DECREF(par_called);
1484     CHECK_OBJECT(par_kw);
1485     Py_DECREF(par_kw);
1486     CHECK_OBJECT(par_star_arg_dict);
1487     Py_DECREF(par_star_arg_dict);    assert(exception_type);
1488     RESTORE_ERROR_OCCURRED(exception_type, exception_value, exception_tb);
1489  
1490     return NULL;
1491  
1492 function_return_exit:
1493    // Function cleanup code if any.
1494     CHECK_OBJECT(par_called);
1495     Py_DECREF(par_called);
1496     CHECK_OBJECT(par_kw);
1497     Py_DECREF(par_kw);
1498     CHECK_OBJECT(par_star_arg_dict);
1499     Py_DECREF(par_star_arg_dict);
1500  
1501    // Actual function exit with return value, making sure we did not make
1502    // the error status worse despite non-NULL return.
1503    CHECK_OBJECT(tmp_return_value);
1504    assert(had_error || !ERROR_OCCURRED());
1505    return tmp_return_value;
1506 }
1507  
1508  
1509 NUITKA_LOCAL_MODULE PyObject *impl___main__$$$function__2_get_callable_name_desc(PyObject **python_pars) {
1510 #ifndef __NUITKA_NO_ASSERT__
1511     NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED();
1512     assert(!had_error); // Do not enter inlined functions with error set.
1513 #endif
1514  
1515     // Local variable declarations.
1516     PyObject *par_called = python_pars[0];
1517     int tmp_res;
1518     PyObject *exception_type = NULL;
1519     PyObject *exception_value = NULL;
1520     PyTracebackObject *exception_tb = NULL;
1521     NUITKA_MAY_BE_UNUSED int exception_lineno = 0;
1522     PyObject *tmp_return_value = NULL;
1523  
1524     // Actual function body.
1525     {
1526         nuitka_bool tmp_condition_result_1;
1527         PyObject *tmp_isinstance_inst_1;
1528         PyObject *tmp_isinstance_cls_1;
1529         CHECK_OBJECT(par_called);
1530         tmp_isinstance_inst_1 = par_called;
1531         tmp_isinstance_cls_1 = mod_consts[16];
1532         tmp_res = Nuitka_IsInstance(tmp_isinstance_inst_1, tmp_isinstance_cls_1);
1533         if (tmp_res == -1) {
1534             assert(ERROR_OCCURRED());
1535  
1536             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
1537  
1538  
1539  
1540  
1541             goto function_exception_exit;
1542         }
1543         tmp_condition_result_1 = (tmp_res != 0) ? NUITKA_BOOL_TRUE : NUITKA_BOOL_FALSE;
1544         if (tmp_condition_result_1 == NUITKA_BOOL_TRUE) {
1545             goto branch_yes_1;
1546         } else {
1547             goto branch_no_1;
1548         }
1549     }
1550     branch_yes_1:;
1551     {
1552         PyObject *tmp_left_name_1;
1553         PyObject *tmp_expression_name_1;
1554         PyObject *tmp_right_name_1;
1555         CHECK_OBJECT(par_called);
1556         tmp_expression_name_1 = par_called;
1557         tmp_left_name_1 = LOOKUP_ATTRIBUTE(tmp_expression_name_1, mod_consts[8]);
1558         if (tmp_left_name_1 == NULL) {
1559             assert(ERROR_OCCURRED());
1560  
1561             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
1562  
1563  
1564  
1565  
1566             goto function_exception_exit;
1567         }
1568         tmp_right_name_1 = mod_consts[17];
1569         tmp_return_value = BINARY_OPERATION_ADD_OBJECT_OBJECT_UNICODE(tmp_left_name_1, tmp_right_name_1);
1570         Py_DECREF(tmp_left_name_1);
1571         if (tmp_return_value == NULL) {
1572             assert(ERROR_OCCURRED());
1573  
1574             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
1575  
1576  
1577  
1578  
1579             goto function_exception_exit;
1580         }
1581         goto function_return_exit;
1582     }
1583     goto branch_end_1;
1584     branch_no_1:;
1585     {
1586         PyObject *tmp_left_name_2;
1587         PyObject *tmp_expression_name_2;
1588         PyObject *tmp_type_arg_1;
1589         PyObject *tmp_right_name_2;
1590         CHECK_OBJECT(par_called);
1591         tmp_type_arg_1 = par_called;
1592         tmp_expression_name_2 = BUILTIN_TYPE1(tmp_type_arg_1);
1593         assert(!(tmp_expression_name_2 == NULL));
1594         tmp_left_name_2 = LOOKUP_ATTRIBUTE(tmp_expression_name_2, mod_consts[8]);
1595         Py_DECREF(tmp_expression_name_2);
1596         if (tmp_left_name_2 == NULL) {
1597             assert(ERROR_OCCURRED());
1598  
1599             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
1600  
1601  
1602  
1603  
1604             goto function_exception_exit;
1605         }
1606         tmp_right_name_2 = mod_consts[18];
1607         tmp_return_value = BINARY_OPERATION_ADD_OBJECT_OBJECT_UNICODE(tmp_left_name_2, tmp_right_name_2);
1608         Py_DECREF(tmp_left_name_2);
1609         if (tmp_return_value == NULL) {
1610             assert(ERROR_OCCURRED());
1611  
1612             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
1613  
1614  
1615  
1616  
1617             goto function_exception_exit;
1618         }
1619         goto function_return_exit;
1620     }
1621     branch_end_1:;
1622  
1623     NUITKA_CANNOT_GET_HERE("Return statement must have exited already.");
1624     return NULL;
1625  
1626 function_exception_exit:
1627     CHECK_OBJECT(par_called);
1628     Py_DECREF(par_called);    assert(exception_type);
1629     RESTORE_ERROR_OCCURRED(exception_type, exception_value, exception_tb);
1630  
1631     return NULL;
1632  
1633 function_return_exit:
1634    // Function cleanup code if any.
1635     CHECK_OBJECT(par_called);
1636     Py_DECREF(par_called);
1637  
1638    // Actual function exit with return value, making sure we did not make
1639    // the error status worse despite non-NULL return.
1640    CHECK_OBJECT(tmp_return_value);
1641    assert(had_error || !ERROR_OCCURRED());
1642    return tmp_return_value;
1643 }
1644  
1645  
1646 472
1647 static PyObject *MAKE_FUNCTION___main__$$$function__1_compiled_func() { 473 static PyObject *MAKE_FUNCTION___main__$$$function__1_compiled_func() {
1648     struct Nuitka_FunctionObject *result = Nuitka_Function_New( 474     struct Nuitka_FunctionObject *result = Nuitka_Function_New(
1649         impl___main__$$$function__1_compiled_func, 475         impl___main__$$$function__1_compiled_func,
1650         mod_consts[1], 476         mod_consts[1],
1685         module___main__, 511         module___main__,
1686         NULL, 512         NULL,
1687         NULL, 513         NULL,
1688         0 514         0
1689     ); 515     );
n 1690     Nuitka_Function_EnableConstReturnGeneric(result, mod_consts[25]); n 516     Nuitka_Function_EnableConstReturnGeneric(result, mod_consts[8]);
1691 517
1692     return (PyObject *)result; 518     return (PyObject *)result;
1693 } 519 }
1694 520
1695 521
1696 522
1697 static PyObject *MAKE_FUNCTION___main__$$$function__3_calledRepeatedly() { 523 static PyObject *MAKE_FUNCTION___main__$$$function__3_calledRepeatedly() {
1698     struct Nuitka_FunctionObject *result = Nuitka_Function_New( 524     struct Nuitka_FunctionObject *result = Nuitka_Function_New(
1699         impl___main__$$$function__3_calledRepeatedly, 525         impl___main__$$$function__3_calledRepeatedly,
n 1700         mod_consts[27], n 526         mod_consts[11],
1701 #if PYTHON_VERSION >= 0x300 527 #if PYTHON_VERSION >= 0x300
1702         NULL, 528         NULL,
1703 #endif 529 #endif
1704         codeobj_af34e7c1e8d078d092ea230386e8b765, 530         codeobj_af34e7c1e8d078d092ea230386e8b765,
1705         NULL, 531         NULL,
2077 903
2078     // Module code. 904     // Module code.
2079     { 905     {
2080         PyObject *tmp_assign_source_1; 906         PyObject *tmp_assign_source_1;
2081         tmp_assign_source_1 = Py_None; 907         tmp_assign_source_1 = Py_None;
n 2082         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[19], tmp_assign_source_1); n 908         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[2], tmp_assign_source_1);
2083     } 909     }
2084     { 910     {
2085         PyObject *tmp_assign_source_2; 911         PyObject *tmp_assign_source_2;
n 2086         tmp_assign_source_2 = mod_consts[20]; n 912         tmp_assign_source_2 = mod_consts[3];
2087         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[21], tmp_assign_source_2); 913         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[4], tmp_assign_source_2);
2088     } 914     }
2089     { 915     {
2090         PyObject *tmp_assign_source_3; 916         PyObject *tmp_assign_source_3;
2091         tmp_assign_source_3 = Py_None; 917         tmp_assign_source_3 = Py_None;
n 2092         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[22], tmp_assign_source_3); n 918         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[5], tmp_assign_source_3);
2093     } 919     }
2094     { 920     {
2095         PyObject *tmp_assign_source_4; 921         PyObject *tmp_assign_source_4;
2096         tmp_assign_source_4 = PyDict_New(); 922         tmp_assign_source_4 = PyDict_New();
n 2097         UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[23], tmp_assign_source_4); n 923         UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[6], tmp_assign_source_4);
2098     } 924     }
2099     { 925     {
2100         PyObject *tmp_assign_source_5; 926         PyObject *tmp_assign_source_5;
2101         { 927         {
2102             PyObject *hard_module = IMPORT_HARD___FUTURE__(); 928             PyObject *hard_module = IMPORT_HARD___FUTURE__();
n 2103             tmp_assign_source_5 = LOOKUP_ATTRIBUTE(hard_module, mod_consts[24]); n 929             tmp_assign_source_5 = LOOKUP_ATTRIBUTE(hard_module, mod_consts[7]);
2104         } 930         }
2105 931
2106         assert(!(tmp_assign_source_5 == NULL)); 932         assert(!(tmp_assign_source_5 == NULL));
n 2107         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[24], tmp_assign_source_5); n 933         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[7], tmp_assign_source_5);
2108     } 934     }
2109     { 935     {
2110         PyObject *tmp_assign_source_6; 936         PyObject *tmp_assign_source_6;
2111 937
2112 938
2122 948
2123         UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[0], tmp_assign_source_7); 949         UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[0], tmp_assign_source_7);
2124     } 950     }
2125     { 951     {
2126         PyObject *tmp_assign_source_8; 952         PyObject *tmp_assign_source_8;
n 2127         tmp_assign_source_8 = PyDict_Copy(mod_consts[26]); n 953         tmp_assign_source_8 = PyDict_Copy(mod_consts[9]);
2128         UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[5], tmp_assign_source_8); 954         UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[10], tmp_assign_source_8);
2129     } 955     }
2130     { 956     {
2131         PyObject *tmp_assign_source_9; 957         PyObject *tmp_assign_source_9;
2132 958
2133 959
2134         tmp_assign_source_9 = MAKE_FUNCTION___main__$$$function__3_calledRepeatedly(); 960         tmp_assign_source_9 = MAKE_FUNCTION___main__$$$function__3_calledRepeatedly();
2135 961
n 2136         UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[27], tmp_assign_source_9); n 962         UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[11], tmp_assign_source_9);
2137     } 963     }
2138     { 964     {
2139         PyObject *tmp_assign_source_10; 965         PyObject *tmp_assign_source_10;
2140         PyObject *tmp_name_name_1; 966         PyObject *tmp_name_name_1;
2141         PyObject *tmp_globals_arg_name_1; 967         PyObject *tmp_globals_arg_name_1;
2142         PyObject *tmp_locals_arg_name_1; 968         PyObject *tmp_locals_arg_name_1;
2143         PyObject *tmp_fromlist_name_1; 969         PyObject *tmp_fromlist_name_1;
2144         PyObject *tmp_level_name_1; 970         PyObject *tmp_level_name_1;
n 2145         tmp_name_name_1 = mod_consts[28]; n 971         tmp_name_name_1 = mod_consts[12];
2146         tmp_globals_arg_name_1 = (PyObject *)moduledict___main__; 972         tmp_globals_arg_name_1 = (PyObject *)moduledict___main__;
2147         tmp_locals_arg_name_1 = Py_None; 973         tmp_locals_arg_name_1 = Py_None;
2148         tmp_fromlist_name_1 = Py_None; 974         tmp_fromlist_name_1 = Py_None;
n 2149         tmp_level_name_1 = mod_consts[14]; n 975         tmp_level_name_1 = mod_consts[13];
2150         tmp_assign_source_10 = IMPORT_MODULE5(tmp_name_name_1, tmp_globals_arg_name_1, tmp_locals_arg_name_1, tmp_fromlist_name_1, tmp_level_name_1); 976         tmp_assign_source_10 = IMPORT_MODULE5(tmp_name_name_1, tmp_globals_arg_name_1, tmp_locals_arg_name_1, tmp_fromlist_name_1, tmp_level_name_1);
2151         assert(!(tmp_assign_source_10 == NULL)); 977         assert(!(tmp_assign_source_10 == NULL));
n 2152         UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[28], tmp_assign_source_10); n 978         UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[12], tmp_assign_source_10);
2153     } 979     }
2154     // Frame without reuse. 980     // Frame without reuse.
2155     frame_266d472510eb96ff5edb40878163dfa1 = MAKE_MODULE_FRAME(codeobj_266d472510eb96ff5edb40878163dfa1, module___main__); 981     frame_266d472510eb96ff5edb40878163dfa1 = MAKE_MODULE_FRAME(codeobj_266d472510eb96ff5edb40878163dfa1, module___main__);
2156 982
2157     // Push the new frame as the currently active one, and we should be exclusively 983     // Push the new frame as the currently active one, and we should be exclusively
2162     // Framed code: 988     // Framed code:
2163     { 989     {
2164         PyObject *tmp_assign_source_11; 990         PyObject *tmp_assign_source_11;
2165         PyObject *tmp_iter_arg_1; 991         PyObject *tmp_iter_arg_1;
2166         PyObject *tmp_called_instance_1; 992         PyObject *tmp_called_instance_1;
n 2167         tmp_called_instance_1 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[28]); n 993         tmp_called_instance_1 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[12]);
2168 994
2169         if (unlikely(tmp_called_instance_1 == NULL)) { 995         if (unlikely(tmp_called_instance_1 == NULL)) {
n 2170             tmp_called_instance_1 = GET_MODULE_VARIABLE_VALUE_FALLBACK(mod_consts[28]); n 996             tmp_called_instance_1 = GET_MODULE_VARIABLE_VALUE_FALLBACK(mod_consts[12]);
2171         } 997         }
2172 998
2173         assert(!(tmp_called_instance_1 == NULL)); 999         assert(!(tmp_called_instance_1 == NULL));
2174         frame_266d472510eb96ff5edb40878163dfa1->m_frame.f_lineno = 54; 1000         frame_266d472510eb96ff5edb40878163dfa1->m_frame.f_lineno = 54;
2175         tmp_iter_arg_1 = CALL_METHOD_WITH_ARGS2( 1001         tmp_iter_arg_1 = CALL_METHOD_WITH_ARGS2(
2176             tmp_called_instance_1, 1002             tmp_called_instance_1,
n 2177             mod_consts[29], n 1003             mod_consts[14],
2178             &PyTuple_GET_ITEM(mod_consts[30], 0) 1004             &PyTuple_GET_ITEM(mod_consts[15], 0)
2179         ); 1005         );
2180 1006
2181         if (tmp_iter_arg_1 == NULL) { 1007         if (tmp_iter_arg_1 == NULL) {
2182             assert(ERROR_OCCURRED()); 1008             assert(ERROR_OCCURRED());
2183 1009
2233     } 1059     }
2234     { 1060     {
2235         PyObject *tmp_assign_source_13; 1061         PyObject *tmp_assign_source_13;
2236         CHECK_OBJECT(tmp_for_loop_1__iter_value); 1062         CHECK_OBJECT(tmp_for_loop_1__iter_value);
2237         tmp_assign_source_13 = tmp_for_loop_1__iter_value; 1063         tmp_assign_source_13 = tmp_for_loop_1__iter_value;
n 2238         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[31], tmp_assign_source_13); n 1064         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[16], tmp_assign_source_13);
2239     } 1065     }
2240     { 1066     {
2241         PyObject *tmp_called_name_1; 1067         PyObject *tmp_called_name_1;
2242         PyObject *tmp_call_result_1; 1068         PyObject *tmp_call_result_1;
n 2243         tmp_called_name_1 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[27]); n 1069         tmp_called_name_1 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[11]);
2244 1070
2245         if (unlikely(tmp_called_name_1 == NULL)) { 1071         if (unlikely(tmp_called_name_1 == NULL)) {
n 2246             tmp_called_name_1 = GET_MODULE_VARIABLE_VALUE_FALLBACK(mod_consts[27]); n 1072             tmp_called_name_1 = GET_MODULE_VARIABLE_VALUE_FALLBACK(mod_consts[11]);
2247         } 1073         }
2248 1074
2249         if (tmp_called_name_1 == NULL) { 1075         if (tmp_called_name_1 == NULL) {
2250             assert(ERROR_OCCURRED()); 1076             assert(ERROR_OCCURRED());
2251 1077
2314     Py_DECREF(tmp_for_loop_1__for_iterator); 1140     Py_DECREF(tmp_for_loop_1__for_iterator);
2315     tmp_for_loop_1__for_iterator = NULL; 1141     tmp_for_loop_1__for_iterator = NULL;
2316     { 1142     {
2317         PyObject *tmp_called_name_2; 1143         PyObject *tmp_called_name_2;
2318         PyObject *tmp_call_result_2; 1144         PyObject *tmp_call_result_2;
n 2319         tmp_called_name_2 = LOOKUP_BUILTIN(mod_consts[32]); n 1145         tmp_called_name_2 = LOOKUP_BUILTIN(mod_consts[17]);
2320         assert(tmp_called_name_2 != NULL); 1146         assert(tmp_called_name_2 != NULL);
2321         frame_266d472510eb96ff5edb40878163dfa1->m_frame.f_lineno = 57; 1147         frame_266d472510eb96ff5edb40878163dfa1->m_frame.f_lineno = 57;
t 2322         tmp_call_result_2 = CALL_FUNCTION_WITH_POSARGS1(tmp_called_name_2, mod_consts[33]); t 1148         tmp_call_result_2 = CALL_FUNCTION_WITH_POSARGS1(tmp_called_name_2, mod_consts[18]);
2323 1149
2324         if (tmp_call_result_2 == NULL) { 1150         if (tmp_call_result_2 == NULL) {
2325             assert(ERROR_OCCURRED()); 1151             assert(ERROR_OCCURRED());
2326 1152
2327             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb); 1153             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);