Construct FunctionCreationGeneratorLocal

Performance Diagrams

Construct FunctionCreationGeneratorLocal 00100000010000002000000200000030000003000000400000040000005000000500000060000006000000700000070000008000000800000090000009000000100000001000000011000000110000001200000012000000130000001300000014000000140000001500000015000000CPython 2.7Nuitka (master)Nuitka (develop)Nuitka (factory)1502595688.95192307692307257.0CPython 2.78151187242.31730769230768370.0617702844946Nuitka (master)8151187395.6826923076923370.0617702844946Nuitka (develop)8151187549.0480769230769370.0617702844946Nuitka (factory)Construct FunctionCreationGeneratorLocalTicks Construct FunctionCreationGeneratorLocal 00200000020000004000000400000060000006000000800000080000001000000010000000120000001200000014000000140000001600000016000000180000001800000020000000200000002200000022000000CPython 3.5Nuitka (master)Nuitka (develop)Nuitka (factory)2213225688.95192307692307257.0CPython 3.510003706242.31730769230768392.4200537928408Nuitka (master)10003709395.6826923076923392.42002029665525Nuitka (develop)10003709549.0480769230769392.42002029665525Nuitka (factory)Construct FunctionCreationGeneratorLocalTicks

Source Code with Construct

module_var = None

def calledRepeatedly():
    # We measure making a local function that will remain unused.
# construct_begin
    def empty():
        yield 1
# construct_alternative



    return empty


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

print("OK.")

Source Code without Construct

module_var = None

def calledRepeatedly():
    # We measure making a local function that will remain unused.
# construct_begin


# construct_alternative
    empty = 1
# construct_end

    return empty


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

print("OK.")

Context Diff of Source Code


Construct
Baseline
21 module_var = None 21 module_var = None
22 22
23 def calledRepeatedly(): 23 def calledRepeatedly():
24     # We measure making a local function that will remain unused. 24     # We measure making a local function that will remain unused.
25 # construct_begin 25 # construct_begin
n 26     def empty(): n
27         yield 1
28 # construct_alternative
29 26
30 27
t t 28 # construct_alternative
29     empty = 1
30 # construct_end
31 31
32     return empty 32     return empty
33 33
34 34
35 import itertools 35 import itertools

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[18]; n 36 static PyObject *mod_consts[16];
37 37
38 static PyObject *module_filename_obj = NULL; 38 static PyObject *module_filename_obj = NULL;
39 39
40 /* Indicator if this modules private constants were created yet. */ 40 /* Indicator if this modules private constants were created yet. */
41 static bool constants_created = false; 41 static bool constants_created = false;
42 42
43 /* Function to create module private constants. */ 43 /* Function to create module private constants. */
44 static void createModuleConstants(void) { 44 static void createModuleConstants(void) {
n 45     loadConstantsBlob(&mod_consts[0], "__main__", 18); n 45     loadConstantsBlob(&mod_consts[0], "__main__", 16);
46 46
47     constants_created = true; 47     constants_created = true;
48 } 48 }
49 49
50 /* For multiprocessing, we want to be able to initialize the __main__ constants. */ 50 /* For multiprocessing, we want to be able to initialize the __main__ constants. */
58 #ifndef __NUITKA_NO_ASSERT__ 58 #ifndef __NUITKA_NO_ASSERT__
59 void checkModuleConstants___main__(void) { 59 void checkModuleConstants___main__(void) {
60     // The module may not have been used at all, then ignore this. 60     // The module may not have been used at all, then ignore this.
61     if (constants_created == false) return; 61     if (constants_created == false) return;
62 62
n 63     checkConstantsBlob(&mod_consts[0], "__main__", 18); n 63     checkConstantsBlob(&mod_consts[0], "__main__", 16);
64 } 64 }
65 #endif 65 #endif
66 66
67 // The module code objects. 67 // The module code objects.
68 static PyCodeObject *codeobj_1b668ba03b46c40bbfd07633e286d2c2; 68 static PyCodeObject *codeobj_1b668ba03b46c40bbfd07633e286d2c2;
69 static PyCodeObject *codeobj_540f5583231358dedc042e899801d940; 69 static PyCodeObject *codeobj_540f5583231358dedc042e899801d940;
n 70 static PyCodeObject *codeobj_81ef52d15720a47c85670c6504350aee; n
71 /* For use in "MainProgram.c". */ 70 /* For use in "MainProgram.c". */
72 PyCodeObject *codeobj_main = NULL; 71 PyCodeObject *codeobj_main = NULL;
73 72
74 static void createModuleCodeObjects(void) { 73 static void createModuleCodeObjects(void) {
n 75     module_filename_obj = mod_consts[4]; CHECK_OBJECT(module_filename_obj); n 74     module_filename_obj = mod_consts[1]; CHECK_OBJECT(module_filename_obj);
76     codeobj_1b668ba03b46c40bbfd07633e286d2c2 = MAKE_CODEOBJECT(module_filename_obj, 1, CO_NOFREE, mod_consts[16], NULL, NULL, 0, 0, 0); 75     codeobj_1b668ba03b46c40bbfd07633e286d2c2 = MAKE_CODEOBJECT(module_filename_obj, 1, CO_NOFREE, mod_consts[14], NULL, NULL, 0, 0, 0);
77     codeobj_540f5583231358dedc042e899801d940 = MAKE_CODEOBJECT(module_filename_obj, 23, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE, mod_consts[8], mod_consts[17], NULL, 0, 0, 0); 76     codeobj_540f5583231358dedc042e899801d940 = MAKE_CODEOBJECT(module_filename_obj, 23, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE, mod_consts[6], mod_consts[15], NULL, 0, 0, 0);
78     codeobj_81ef52d15720a47c85670c6504350aee = MAKE_CODEOBJECT(module_filename_obj, 26, CO_GENERATOR | CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE, mod_consts[0], NULL, NULL, 0, 0, 0);
79 } 77 }
80 78
81 // The module function declarations. 79 // The module function declarations.
n 82 static PyObject *MAKE_GENERATOR___main__$$$function__1_calledRepeatedly$$$function__1_empty$$$genobj__1_empty(); n
83  
84  
85 static PyObject *MAKE_FUNCTION___main__$$$function__1_calledRepeatedly(); 80 static PyObject *MAKE_FUNCTION___main__$$$function__1_calledRepeatedly();
86 81
87 82
n 88 static PyObject *MAKE_FUNCTION___main__$$$function__1_calledRepeatedly$$$function__1_empty(); n
89  
90  
91 // The module function definitions. 83 // The module function definitions.
n 92 static PyObject *impl___main__$$$function__1_calledRepeatedly(struct Nuitka_FunctionObject const *self, PyObject **python_pars) { n
93     // Preserve error status for checks
94 #ifndef __NUITKA_NO_ASSERT__
95     NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED();
96 #endif
97  
98     // Local variable declarations.
99     PyObject *var_empty = NULL;
100     PyObject *tmp_return_value = NULL;
101  
102     // Actual function body.
103     {
104         PyObject *tmp_assign_source_1;
105  
106  
107         tmp_assign_source_1 = MAKE_FUNCTION___main__$$$function__1_calledRepeatedly$$$function__1_empty();
108  
109         assert(var_empty == NULL);
110         var_empty = tmp_assign_source_1;
111     }
112     // Tried code:
113     CHECK_OBJECT(var_empty);
114     tmp_return_value = var_empty;
115     Py_INCREF(tmp_return_value);
116     goto try_return_handler_1;
117     NUITKA_CANNOT_GET_HERE("tried codes exits in all cases");
118     return NULL;
119     // Return handler code:
120     try_return_handler_1:;
121     CHECK_OBJECT(var_empty);
122     Py_DECREF(var_empty);
123     var_empty = NULL;
124     goto function_return_exit;
125     // End of try:
126  
127     NUITKA_CANNOT_GET_HERE("Return statement must have exited already.");
128     return NULL;
129  
130  
131 function_return_exit:
132    // Function cleanup code if any.
133  
134  
135    // Actual function exit with return value, making sure we did not make
136    // the error status worse despite non-NULL return.
137    CHECK_OBJECT(tmp_return_value);
138    assert(had_error || !ERROR_OCCURRED());
139    return tmp_return_value;
140 }
141  
142  
143 static PyObject *impl___main__$$$function__1_calledRepeatedly$$$function__1_empty(struct Nuitka_FunctionObject const *self, PyObject **python_pars) {
144     // Preserve error status for checks
145 #ifndef __NUITKA_NO_ASSERT__
146     NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED();
147 #endif
148  
149     // Local variable declarations.
150     PyObject *tmp_return_value = NULL;
151  
152     // Actual function body.
153  
154  
155     tmp_return_value = MAKE_GENERATOR___main__$$$function__1_calledRepeatedly$$$function__1_empty$$$genobj__1_empty();
156  
157     goto function_return_exit;
158  
159     NUITKA_CANNOT_GET_HERE("Return statement must have exited already.");
160     return NULL;
161  
162  
163 function_return_exit:
164    // Function cleanup code if any.
165  
166  
167    // Actual function exit with return value, making sure we did not make
168    // the error status worse despite non-NULL return.
169    CHECK_OBJECT(tmp_return_value);
170    assert(had_error || !ERROR_OCCURRED());
171    return tmp_return_value;
172 }
173  
174  
175  
176 struct __main__$$$function__1_calledRepeatedly$$$function__1_empty$$$genobj__1_empty_locals {
177     char const *type_description_1;
178     PyObject *exception_type;
179     PyObject *exception_value;
180     PyTracebackObject *exception_tb;
181     int exception_lineno;
182 };
183  
184 static PyObject *__main__$$$function__1_calledRepeatedly$$$function__1_empty$$$genobj__1_empty_context(struct Nuitka_GeneratorObject *generator, PyObject *yield_return_value) {
185     CHECK_OBJECT(generator);
186     assert(Nuitka_Generator_Check((PyObject *)generator));
187     CHECK_OBJECT_X(yield_return_value);
188  
189     // Heap access if used.
190     struct __main__$$$function__1_calledRepeatedly$$$function__1_empty$$$genobj__1_empty_locals *generator_heap = (struct __main__$$$function__1_calledRepeatedly$$$function__1_empty$$$genobj__1_empty_locals *)generator->m_heap_storage;
191  
192     // Dispatch to yield based on return label index:
193     switch(generator->m_yield_return_index) {
194     case 1: goto yield_return_1;
195     }
196  
197     // Local variable initialization
198     NUITKA_MAY_BE_UNUSED nuitka_void tmp_unused;
199     static struct Nuitka_FrameObject *cache_m_frame = NULL;
200     generator_heap->type_description_1 = NULL;
201     generator_heap->exception_type = NULL;
202     generator_heap->exception_value = NULL;
203     generator_heap->exception_tb = NULL;
204     generator_heap->exception_lineno = 0;
205  
206     // Actual generator function body.
207     if (isFrameUnusable(cache_m_frame)) {
208         Py_XDECREF(cache_m_frame);
209  
210 #if _DEBUG_REFCOUNTS
211         if (cache_m_frame == NULL) {
212             count_active_frame_cache_instances += 1;
213         } else {
214             count_released_frame_cache_instances += 1;
215         }
216         count_allocated_frame_cache_instances += 1;
217 #endif
218         cache_m_frame = MAKE_FUNCTION_FRAME(codeobj_81ef52d15720a47c85670c6504350aee, module___main__, 0);
219 #if _DEBUG_REFCOUNTS
220     } else {
221         count_hit_frame_cache_instances += 1;
222 #endif
223     }
224     generator->m_frame = cache_m_frame;
225  
226     // Mark the frame object as in use, ref count 1 will be up for reuse.
227     Py_INCREF(generator->m_frame);
228     assert(Py_REFCNT(generator->m_frame) == 2); // Frame stack
229  
230 #if PYTHON_VERSION >= 0x340
231     generator->m_frame->m_frame.f_gen = (PyObject *)generator;
232 #endif
233  
234     assert(generator->m_frame->m_frame.f_back == NULL);
235     Py_CLEAR(generator->m_frame->m_frame.f_back);
236  
237     generator->m_frame->m_frame.f_back = PyThreadState_GET()->frame;
238     Py_INCREF(generator->m_frame->m_frame.f_back);
239  
240     PyThreadState_GET()->frame = &generator->m_frame->m_frame;
241     Py_INCREF(generator->m_frame);
242  
243     Nuitka_Frame_MarkAsExecuting(generator->m_frame);
244  
245 #if PYTHON_VERSION >= 0x300
246     // Accept currently existing exception as the one to publish again when we
247     // yield or yield from.
248     {
249         PyThreadState *thread_state = PyThreadState_GET();
250  
251         EXC_TYPE_F(generator) = EXC_TYPE(thread_state);
252         if (EXC_TYPE_F(generator) == Py_None) EXC_TYPE_F(generator) = NULL;
253         Py_XINCREF(EXC_TYPE_F(generator));
254         EXC_VALUE_F(generator) = EXC_VALUE(thread_state);
255         Py_XINCREF(EXC_VALUE_F(generator));
256         EXC_TRACEBACK_F(generator) = EXC_TRACEBACK(thread_state);
257         Py_XINCREF(EXC_TRACEBACK_F(generator));
258     }
259  
260 #endif
261  
262     // Framed code:
263     {
264         PyObject *tmp_expression_name_1;
265         NUITKA_MAY_BE_UNUSED PyObject *tmp_yield_result_1;
266         tmp_expression_name_1 = mod_consts[2];
267         Py_INCREF(tmp_expression_name_1);
268         generator->m_yield_return_index = 1;
269         return tmp_expression_name_1;
270         yield_return_1:
271         if (yield_return_value == NULL) {
272             assert(ERROR_OCCURRED());
273  
274             FETCH_ERROR_OCCURRED(&generator_heap->exception_type, &generator_heap->exception_value, &generator_heap->exception_tb);
275  
276  
277             generator_heap->exception_lineno = 27;
278  
279             goto frame_exception_exit_1;
280         }
281         tmp_yield_result_1 = yield_return_value;
282     }
283  
284     Nuitka_Frame_MarkAsNotExecuting(generator->m_frame);
285  
286 #if PYTHON_VERSION >= 0x300
287     Py_CLEAR(EXC_TYPE_F(generator));
288     Py_CLEAR(EXC_VALUE_F(generator));
289     Py_CLEAR(EXC_TRACEBACK_F(generator));
290 #endif
291  
292     // Allow re-use of the frame again.
293     Py_DECREF(generator->m_frame);
294     goto frame_no_exception_1;
295  
296     frame_exception_exit_1:;
297  
298     // If it's not an exit exception, consider and create a traceback for it.
299     if (!EXCEPTION_MATCH_GENERATOR(generator_heap->exception_type)) {
300         if (generator_heap->exception_tb == NULL) {
301             generator_heap->exception_tb = MAKE_TRACEBACK(generator->m_frame, generator_heap->exception_lineno);
302         } else if (generator_heap->exception_tb->tb_frame != &generator->m_frame->m_frame) {
303             generator_heap->exception_tb = ADD_TRACEBACK(generator_heap->exception_tb, generator->m_frame, generator_heap->exception_lineno);
304         }
305  
306         Nuitka_Frame_AttachLocals(
307             generator->m_frame,
308             generator_heap->type_description_1
309         );
310  
311  
312         // Release cached frame if used for exception.
313         if (generator->m_frame == cache_m_frame) {
314 #if _DEBUG_REFCOUNTS
315             count_active_frame_cache_instances -= 1;
316             count_released_frame_cache_instances += 1;
317 #endif
318  
319             Py_DECREF(cache_m_frame);
320             cache_m_frame = NULL;
321         }
322  
323         assertFrameObject(generator->m_frame);
324     }
325  
326 #if PYTHON_VERSION >= 0x300
327     Py_CLEAR(EXC_TYPE_F(generator));
328     Py_CLEAR(EXC_VALUE_F(generator));
329     Py_CLEAR(EXC_TRACEBACK_F(generator));
330 #endif
331  
332     Py_DECREF(generator->m_frame);
333  
334     // Return the error.
335     goto function_exception_exit;
336  
337     frame_no_exception_1:;
338  
339  
340     return NULL;
341  
342     function_exception_exit:
343     assert(generator_heap->exception_type);
344     RESTORE_ERROR_OCCURRED(generator_heap->exception_type, generator_heap->exception_value, generator_heap->exception_tb);
345  
346     return NULL;
347  
348 }
349  
350 static PyObject *MAKE_GENERATOR___main__$$$function__1_calledRepeatedly$$$function__1_empty$$$genobj__1_empty() {
351     return Nuitka_Generator_New(
352         __main__$$$function__1_calledRepeatedly$$$function__1_empty$$$genobj__1_empty_context,
353         module___main__,
354         mod_consts[0],
355 #if PYTHON_VERSION >= 0x350
356         mod_consts[1],
357 #endif
358         codeobj_81ef52d15720a47c85670c6504350aee,
359         NULL,
360         0,
361         sizeof(struct __main__$$$function__1_calledRepeatedly$$$function__1_empty$$$genobj__1_empty_locals)
362     );
363 }
364  
365  
366 84
367 static PyObject *MAKE_FUNCTION___main__$$$function__1_calledRepeatedly() { 85 static PyObject *MAKE_FUNCTION___main__$$$function__1_calledRepeatedly() {
368     struct Nuitka_FunctionObject *result = Nuitka_Function_New( 86     struct Nuitka_FunctionObject *result = Nuitka_Function_New(
n 369         impl___main__$$$function__1_calledRepeatedly, n 87         NULL,
370         mod_consts[8], 88         mod_consts[6],
371 #if PYTHON_VERSION >= 0x300 89 #if PYTHON_VERSION >= 0x300
372         NULL, 90         NULL,
373 #endif 91 #endif
374         codeobj_540f5583231358dedc042e899801d940, 92         codeobj_540f5583231358dedc042e899801d940,
375         NULL, 93         NULL,
380         module___main__, 98         module___main__,
381         NULL, 99         NULL,
382         NULL, 100         NULL,
383         0 101         0
384     ); 102     );
n 385   n 103     Nuitka_Function_EnableConstReturnGeneric(result, mod_consts[5]);
386  
387     return (PyObject *)result;
388 }
389  
390  
391  
392 static PyObject *MAKE_FUNCTION___main__$$$function__1_calledRepeatedly$$$function__1_empty() {
393     struct Nuitka_FunctionObject *result = Nuitka_Function_New(
394         impl___main__$$$function__1_calledRepeatedly$$$function__1_empty,
395         mod_consts[0],
396 #if PYTHON_VERSION >= 0x300
397         mod_consts[1],
398 #endif
399         codeobj_81ef52d15720a47c85670c6504350aee,
400         NULL,
401 #if PYTHON_VERSION >= 0x300
402         NULL,
403         NULL,
404 #endif
405         module___main__,
406         NULL,
407         NULL,
408         0
409     );
410  
411 104
412     return (PyObject *)result; 105     return (PyObject *)result;
413 } 106 }
414 107
415 108
424 #ifdef _NUITKA_PLUGIN_DILL_ENABLED 117 #ifdef _NUITKA_PLUGIN_DILL_ENABLED
425 // Provide a way to create find a function via its C code and create it back 118 // Provide a way to create find a function via its C code and create it back
426 // in another process, useful for multiprocessing extensions like dill 119 // in another process, useful for multiprocessing extensions like dill
427 120
428 function_impl_code functable___main__[] = { 121 function_impl_code functable___main__[] = {
n 429     impl___main__$$$function__1_calledRepeatedly$$$function__1_empty, n 122     NULL,
430     impl___main__$$$function__1_calledRepeatedly,
431     NULL 123     NULL
432 }; 124 };
433 125
434 static char const *_reduce_compiled_function_argnames[] = { 126 static char const *_reduce_compiled_function_argnames[] = {
435     "func", 127     "func",
801 493
802     // Module code. 494     // Module code.
803     { 495     {
804         PyObject *tmp_assign_source_1; 496         PyObject *tmp_assign_source_1;
805         tmp_assign_source_1 = Py_None; 497         tmp_assign_source_1 = Py_None;
n 806         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[3], tmp_assign_source_1); n 498         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[0], tmp_assign_source_1);
807     } 499     }
808     { 500     {
809         PyObject *tmp_assign_source_2; 501         PyObject *tmp_assign_source_2;
n 810         tmp_assign_source_2 = mod_consts[4]; n 502         tmp_assign_source_2 = mod_consts[1];
811         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[5], tmp_assign_source_2); 503         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[2], tmp_assign_source_2);
812     } 504     }
813     { 505     {
814         PyObject *tmp_assign_source_3; 506         PyObject *tmp_assign_source_3;
815         tmp_assign_source_3 = Py_None; 507         tmp_assign_source_3 = Py_None;
n 816         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[6], tmp_assign_source_3); n 508         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[3], tmp_assign_source_3);
817     } 509     }
818     { 510     {
819         PyObject *tmp_assign_source_4; 511         PyObject *tmp_assign_source_4;
820         tmp_assign_source_4 = Py_None; 512         tmp_assign_source_4 = Py_None;
n 821         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[7], tmp_assign_source_4); n 513         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[4], tmp_assign_source_4);
822     } 514     }
823     { 515     {
824         PyObject *tmp_assign_source_5; 516         PyObject *tmp_assign_source_5;
825 517
826 518
827         tmp_assign_source_5 = MAKE_FUNCTION___main__$$$function__1_calledRepeatedly(); 519         tmp_assign_source_5 = MAKE_FUNCTION___main__$$$function__1_calledRepeatedly();
828 520
n 829         UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[8], tmp_assign_source_5); n 521         UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[6], tmp_assign_source_5);
830     } 522     }
831     { 523     {
832         PyObject *tmp_assign_source_6; 524         PyObject *tmp_assign_source_6;
833         PyObject *tmp_name_name_1; 525         PyObject *tmp_name_name_1;
834         PyObject *tmp_globals_arg_name_1; 526         PyObject *tmp_globals_arg_name_1;
835         PyObject *tmp_locals_arg_name_1; 527         PyObject *tmp_locals_arg_name_1;
836         PyObject *tmp_fromlist_name_1; 528         PyObject *tmp_fromlist_name_1;
837         PyObject *tmp_level_name_1; 529         PyObject *tmp_level_name_1;
n 838         tmp_name_name_1 = mod_consts[9]; n 530         tmp_name_name_1 = mod_consts[7];
839         tmp_globals_arg_name_1 = (PyObject *)moduledict___main__; 531         tmp_globals_arg_name_1 = (PyObject *)moduledict___main__;
840         tmp_locals_arg_name_1 = Py_None; 532         tmp_locals_arg_name_1 = Py_None;
841         tmp_fromlist_name_1 = Py_None; 533         tmp_fromlist_name_1 = Py_None;
n 842         tmp_level_name_1 = mod_consts[10]; n 534         tmp_level_name_1 = mod_consts[8];
843         tmp_assign_source_6 = IMPORT_MODULE5(tmp_name_name_1, tmp_globals_arg_name_1, tmp_locals_arg_name_1, tmp_fromlist_name_1, tmp_level_name_1); 535         tmp_assign_source_6 = IMPORT_MODULE5(tmp_name_name_1, tmp_globals_arg_name_1, tmp_locals_arg_name_1, tmp_fromlist_name_1, tmp_level_name_1);
844         assert(!(tmp_assign_source_6 == NULL)); 536         assert(!(tmp_assign_source_6 == NULL));
n 845         UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[9], tmp_assign_source_6); n 537         UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[7], tmp_assign_source_6);
846     } 538     }
847     // Frame without reuse. 539     // Frame without reuse.
848     frame_1b668ba03b46c40bbfd07633e286d2c2 = MAKE_MODULE_FRAME(codeobj_1b668ba03b46c40bbfd07633e286d2c2, module___main__); 540     frame_1b668ba03b46c40bbfd07633e286d2c2 = MAKE_MODULE_FRAME(codeobj_1b668ba03b46c40bbfd07633e286d2c2, module___main__);
849 541
850     // Push the new frame as the currently active one, and we should be exclusively 542     // Push the new frame as the currently active one, and we should be exclusively
855     // Framed code: 547     // Framed code:
856     { 548     {
857         PyObject *tmp_assign_source_7; 549         PyObject *tmp_assign_source_7;
858         PyObject *tmp_iter_arg_1; 550         PyObject *tmp_iter_arg_1;
859         PyObject *tmp_called_instance_1; 551         PyObject *tmp_called_instance_1;
n 860         tmp_called_instance_1 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[9]); n 552         tmp_called_instance_1 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[7]);
861 553
862         if (unlikely(tmp_called_instance_1 == NULL)) { 554         if (unlikely(tmp_called_instance_1 == NULL)) {
n 863             tmp_called_instance_1 = GET_MODULE_VARIABLE_VALUE_FALLBACK(mod_consts[9]); n 555             tmp_called_instance_1 = GET_MODULE_VARIABLE_VALUE_FALLBACK(mod_consts[7]);
864         } 556         }
865 557
866         assert(!(tmp_called_instance_1 == NULL)); 558         assert(!(tmp_called_instance_1 == NULL));
867         frame_1b668ba03b46c40bbfd07633e286d2c2->m_frame.f_lineno = 36; 559         frame_1b668ba03b46c40bbfd07633e286d2c2->m_frame.f_lineno = 36;
n 868         tmp_iter_arg_1 = CALL_METHOD_WITH_ARGS2(tmp_called_instance_1, mod_consts[11], &PyTuple_GET_ITEM(mod_consts[12], 0)); n 560         tmp_iter_arg_1 = CALL_METHOD_WITH_ARGS2(tmp_called_instance_1, mod_consts[9], &PyTuple_GET_ITEM(mod_consts[10], 0));
869 561
870         if (tmp_iter_arg_1 == NULL) { 562         if (tmp_iter_arg_1 == NULL) {
871             assert(ERROR_OCCURRED()); 563             assert(ERROR_OCCURRED());
872 564
873             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb); 565             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
922     } 614     }
923     { 615     {
924         PyObject *tmp_assign_source_9; 616         PyObject *tmp_assign_source_9;
925         CHECK_OBJECT(tmp_for_loop_1__iter_value); 617         CHECK_OBJECT(tmp_for_loop_1__iter_value);
926         tmp_assign_source_9 = tmp_for_loop_1__iter_value; 618         tmp_assign_source_9 = tmp_for_loop_1__iter_value;
n 927         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[13], tmp_assign_source_9); n 619         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[11], tmp_assign_source_9);
928     } 620     }
929     { 621     {
930         PyObject *tmp_called_name_1; 622         PyObject *tmp_called_name_1;
931         PyObject *tmp_call_result_1; 623         PyObject *tmp_call_result_1;
n 932         tmp_called_name_1 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[8]); n 624         tmp_called_name_1 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[6]);
933 625
934         if (unlikely(tmp_called_name_1 == NULL)) { 626         if (unlikely(tmp_called_name_1 == NULL)) {
n 935             tmp_called_name_1 = GET_MODULE_VARIABLE_VALUE_FALLBACK(mod_consts[8]); n 627             tmp_called_name_1 = GET_MODULE_VARIABLE_VALUE_FALLBACK(mod_consts[6]);
936         } 628         }
937 629
938         if (tmp_called_name_1 == NULL) { 630         if (tmp_called_name_1 == NULL) {
939             assert(ERROR_OCCURRED()); 631             assert(ERROR_OCCURRED());
940 632
1001     Py_XDECREF(tmp_for_loop_1__for_iterator); 693     Py_XDECREF(tmp_for_loop_1__for_iterator);
1002     tmp_for_loop_1__for_iterator = NULL; 694     tmp_for_loop_1__for_iterator = NULL;
1003     { 695     {
1004         PyObject *tmp_called_name_2; 696         PyObject *tmp_called_name_2;
1005         PyObject *tmp_call_result_2; 697         PyObject *tmp_call_result_2;
n 1006         tmp_called_name_2 = LOOKUP_BUILTIN(mod_consts[14]); n 698         tmp_called_name_2 = LOOKUP_BUILTIN(mod_consts[12]);
1007         assert(tmp_called_name_2 != NULL); 699         assert(tmp_called_name_2 != NULL);
1008         frame_1b668ba03b46c40bbfd07633e286d2c2->m_frame.f_lineno = 39; 700         frame_1b668ba03b46c40bbfd07633e286d2c2->m_frame.f_lineno = 39;
t 1009         tmp_call_result_2 = CALL_FUNCTION_WITH_SINGLE_ARG(tmp_called_name_2, mod_consts[15]); t 701         tmp_call_result_2 = CALL_FUNCTION_WITH_SINGLE_ARG(tmp_called_name_2, mod_consts[13]);
1010         if (tmp_call_result_2 == NULL) { 702         if (tmp_call_result_2 == NULL) {
1011             assert(ERROR_OCCURRED()); 703             assert(ERROR_OCCURRED());
1012 704
1013             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb); 705             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
1014 706