Construct CallCompiledFunctionKwArgsVariableStarDict

Performance Diagrams

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