Construct FunctionCreationGeneratorLocal

Performance Diagrams

Construct FunctionCreationGeneratorLocal 00100000010000002000000200000030000003000000400000040000005000000500000060000006000000700000070000008000000800000090000009000000100000001000000011000000110000001200000012000000130000001300000014000000140000001500000015000000CPython 2.7Nuitka (master)Nuitka (develop)Nuitka (factory)1502605288.95192307692307257.0CPython 2.78700827242.31730769230768361.0233594728573Nuitka (master)8250797395.6826923076923368.42446100894017Nuitka (develop)8250797549.0480769230769368.42446100894017Nuitka (factory)Construct FunctionCreationGeneratorLocalTicks Construct FunctionCreationGeneratorLocal 00200000020000004000000400000060000006000000800000080000001000000010000000120000001200000014000000140000001600000016000000180000001800000020000000200000002200000022000000CPython 3.5Nuitka (master)Nuitka (develop)Nuitka (factory)2213225688.95192307692307257.0CPython 3.510551610242.31730769230768386.30248910841334Nuitka (master)10101714395.6826923076923391.3257557413731Nuitka (develop)10101713549.0480769230769391.3257669067683Nuitka (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[19]; n 36 static PyObject *mod_consts[17];
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__", 19); n 45     loadConstantsBlob(&mod_consts[0], "__main__", 17);
46 46
47     constants_created = true; 47     constants_created = true;
48 } 48 }
49 49
50 /* Function to verify module private constants for non-corruption. */ 50 /* Function to verify module private constants for non-corruption. */
51 #ifndef __NUITKA_NO_ASSERT__ 51 #ifndef __NUITKA_NO_ASSERT__
52 void checkModuleConstants___main__(void) { 52 void checkModuleConstants___main__(void) {
53     // The module may not have been used at all, then ignore this. 53     // The module may not have been used at all, then ignore this.
54     if (constants_created == false) return; 54     if (constants_created == false) return;
55 55
n 56     checkConstantsBlob(&mod_consts[0], "__main__", 19); n 56     checkConstantsBlob(&mod_consts[0], "__main__", 17);
57 } 57 }
58 #endif 58 #endif
59 59
60 // The module code objects. 60 // The module code objects.
61 static PyCodeObject *codeobj_c5d0fa1f7bf1e6403f2b8dd49cce5c4c; 61 static PyCodeObject *codeobj_c5d0fa1f7bf1e6403f2b8dd49cce5c4c;
62 static PyCodeObject *codeobj_5185d9f6e4494977166e105799e60c32; 62 static PyCodeObject *codeobj_5185d9f6e4494977166e105799e60c32;
n 63 static PyCodeObject *codeobj_e84f04252b636aae08a8b6a5fbb07936; n
64 /* For use in "MainProgram.c". */ 63 /* For use in "MainProgram.c". */
65 PyCodeObject *codeobj_main = NULL; 64 PyCodeObject *codeobj_main = NULL;
66 65
67 static void createModuleCodeObjects(void) { 66 static void createModuleCodeObjects(void) {
n 68     module_filename_obj = mod_consts[4]; CHECK_OBJECT(module_filename_obj); n 67     module_filename_obj = mod_consts[1]; CHECK_OBJECT(module_filename_obj);
69     codeobj_c5d0fa1f7bf1e6403f2b8dd49cce5c4c = MAKE_CODEOBJECT(module_filename_obj, 1, CO_NOFREE, mod_consts[16], mod_consts[17], 0, 0, 0); 68     codeobj_c5d0fa1f7bf1e6403f2b8dd49cce5c4c = MAKE_CODEOBJECT(module_filename_obj, 1, CO_NOFREE, mod_consts[14], mod_consts[15], 0, 0, 0);
70     codeobj_5185d9f6e4494977166e105799e60c32 = MAKE_CODEOBJECT(module_filename_obj, 23, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE, mod_consts[8], mod_consts[18], 0, 0, 0); 69     codeobj_5185d9f6e4494977166e105799e60c32 = MAKE_CODEOBJECT(module_filename_obj, 23, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE, mod_consts[6], mod_consts[16], 0, 0, 0);
71     codeobj_e84f04252b636aae08a8b6a5fbb07936 = MAKE_CODEOBJECT(module_filename_obj, 26, CO_GENERATOR | CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE, mod_consts[0], mod_consts[17], 0, 0, 0);
72 } 70 }
73 71
74 // The module function declarations. 72 // The module function declarations.
n 75 static PyObject *MAKE_GENERATOR___main__$$$function_1_calledRepeatedly$$$function_1_empty$$$genobj_1_empty(); n
76  
77  
78 static PyObject *MAKE_FUNCTION___main__$$$function_1_calledRepeatedly(); 73 static PyObject *MAKE_FUNCTION___main__$$$function_1_calledRepeatedly();
79 74
80 75
n 81 static PyObject *MAKE_FUNCTION___main__$$$function_1_calledRepeatedly$$$function_1_empty(); n
82  
83  
84 // The module function definitions. 76 // The module function definitions.
n 85 static PyObject *impl___main__$$$function_1_calledRepeatedly(struct Nuitka_FunctionObject const *self, PyObject **python_pars) { n
86     // Preserve error status for checks
87 #ifndef __NUITKA_NO_ASSERT__
88     NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED();
89 #endif
90  
91     // Local variable declarations.
92     PyObject *var_empty = NULL;
93     PyObject *tmp_return_value = NULL;
94  
95     // Actual function body.
96     {
97         PyObject *tmp_assign_source_1;
98  
99  
100         tmp_assign_source_1 = MAKE_FUNCTION___main__$$$function_1_calledRepeatedly$$$function_1_empty();
101  
102         assert(var_empty == NULL);
103         var_empty = tmp_assign_source_1;
104     }
105     // Tried code:
106     CHECK_OBJECT(var_empty);
107     tmp_return_value = var_empty;
108     Py_INCREF(tmp_return_value);
109     goto try_return_handler_1;
110     NUITKA_CANNOT_GET_HERE("tried codes exits in all cases");
111     return NULL;
112     // Return handler code:
113     try_return_handler_1:;
114     CHECK_OBJECT(var_empty);
115     Py_DECREF(var_empty);
116     var_empty = NULL;
117     goto function_return_exit;
118     // End of try:
119  
120     NUITKA_CANNOT_GET_HERE("Return statement must have exited already.");
121     return NULL;
122  
123  
124 function_return_exit:
125    // Function cleanup code if any.
126  
127  
128    // Actual function exit with return value, making sure we did not make
129    // the error status worse despite non-NULL return.
130    CHECK_OBJECT(tmp_return_value);
131    assert(had_error || !ERROR_OCCURRED());
132    return tmp_return_value;
133 }
134  
135  
136 static PyObject *impl___main__$$$function_1_calledRepeatedly$$$function_1_empty(struct Nuitka_FunctionObject const *self, PyObject **python_pars) {
137     // Preserve error status for checks
138 #ifndef __NUITKA_NO_ASSERT__
139     NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED();
140 #endif
141  
142     // Local variable declarations.
143     PyObject *tmp_return_value = NULL;
144  
145     // Actual function body.
146  
147  
148     tmp_return_value = MAKE_GENERATOR___main__$$$function_1_calledRepeatedly$$$function_1_empty$$$genobj_1_empty();
149  
150     goto function_return_exit;
151  
152     NUITKA_CANNOT_GET_HERE("Return statement must have exited already.");
153     return NULL;
154  
155  
156 function_return_exit:
157    // Function cleanup code if any.
158  
159  
160    // Actual function exit with return value, making sure we did not make
161    // the error status worse despite non-NULL return.
162    CHECK_OBJECT(tmp_return_value);
163    assert(had_error || !ERROR_OCCURRED());
164    return tmp_return_value;
165 }
166  
167  
168  
169 struct __main__$$$function_1_calledRepeatedly$$$function_1_empty$$$genobj_1_empty_locals {
170     char const *type_description_1;
171     PyObject *exception_type;
172     PyObject *exception_value;
173     PyTracebackObject *exception_tb;
174     int exception_lineno;
175 };
176  
177 static PyObject *__main__$$$function_1_calledRepeatedly$$$function_1_empty$$$genobj_1_empty_context(struct Nuitka_GeneratorObject *generator, PyObject *yield_return_value) {
178     CHECK_OBJECT(generator);
179     assert(Nuitka_Generator_Check((PyObject *)generator));
180     CHECK_OBJECT_X(yield_return_value);
181  
182     // Heap access if used.
183     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;
184  
185     // Dispatch to yield based on return label index:
186     switch(generator->m_yield_return_index) {
187     case 1: goto yield_return_1;
188     }
189  
190     // Local variable initialization
191     NUITKA_MAY_BE_UNUSED nuitka_void tmp_unused;
192     static struct Nuitka_FrameObject *cache_m_frame = NULL;
193     generator_heap->type_description_1 = NULL;
194     generator_heap->exception_type = NULL;
195     generator_heap->exception_value = NULL;
196     generator_heap->exception_tb = NULL;
197     generator_heap->exception_lineno = 0;
198  
199     // Actual generator function body.
200     if (isFrameUnusable(cache_m_frame)) {
201         Py_XDECREF(cache_m_frame);
202  
203 #if _DEBUG_REFCOUNTS
204         if (cache_m_frame == NULL) {
205             count_active_frame_cache_instances += 1;
206         } else {
207             count_released_frame_cache_instances += 1;
208         }
209         count_allocated_frame_cache_instances += 1;
210 #endif
211         cache_m_frame = MAKE_FUNCTION_FRAME(codeobj_e84f04252b636aae08a8b6a5fbb07936, module___main__, 0);
212 #if _DEBUG_REFCOUNTS
213     } else {
214         count_hit_frame_cache_instances += 1;
215 #endif
216     }
217     generator->m_frame = cache_m_frame;
218  
219     // Mark the frame object as in use, ref count 1 will be up for reuse.
220     Py_INCREF(generator->m_frame);
221     assert(Py_REFCNT(generator->m_frame) == 2); // Frame stack
222  
223 #if PYTHON_VERSION >= 340
224     generator->m_frame->m_frame.f_gen = (PyObject *)generator;
225 #endif
226  
227     assert(generator->m_frame->m_frame.f_back == NULL);
228     Py_CLEAR(generator->m_frame->m_frame.f_back);
229  
230     generator->m_frame->m_frame.f_back = PyThreadState_GET()->frame;
231     Py_INCREF(generator->m_frame->m_frame.f_back);
232  
233     PyThreadState_GET()->frame = &generator->m_frame->m_frame;
234     Py_INCREF(generator->m_frame);
235  
236     Nuitka_Frame_MarkAsExecuting(generator->m_frame);
237  
238 #if PYTHON_VERSION >= 300
239     // Accept currently existing exception as the one to publish again when we
240     // yield or yield from.
241     {
242         PyThreadState *thread_state = PyThreadState_GET();
243  
244         EXC_TYPE_F(generator) = EXC_TYPE(thread_state);
245         if (EXC_TYPE_F(generator) == Py_None) EXC_TYPE_F(generator) = NULL;
246         Py_XINCREF(EXC_TYPE_F(generator));
247         EXC_VALUE_F(generator) = EXC_VALUE(thread_state);
248         Py_XINCREF(EXC_VALUE_F(generator));
249         EXC_TRACEBACK_F(generator) = EXC_TRACEBACK(thread_state);
250         Py_XINCREF(EXC_TRACEBACK_F(generator));
251     }
252  
253 #endif
254  
255     // Framed code:
256     {
257         PyObject *tmp_expression_name_1;
258         NUITKA_MAY_BE_UNUSED PyObject *tmp_yield_result_1;
259         tmp_expression_name_1 = mod_consts[2];
260         Py_INCREF(tmp_expression_name_1);
261         generator->m_yield_return_index = 1;
262         return tmp_expression_name_1;
263         yield_return_1:
264         if (yield_return_value == NULL) {
265             assert(ERROR_OCCURRED());
266  
267             FETCH_ERROR_OCCURRED(&generator_heap->exception_type, &generator_heap->exception_value, &generator_heap->exception_tb);
268  
269  
270             generator_heap->exception_lineno = 27;
271  
272             goto frame_exception_exit_1;
273         }
274         tmp_yield_result_1 = yield_return_value;
275     }
276  
277     Nuitka_Frame_MarkAsNotExecuting(generator->m_frame);
278  
279 #if PYTHON_VERSION >= 300
280     Py_CLEAR(EXC_TYPE_F(generator));
281     Py_CLEAR(EXC_VALUE_F(generator));
282     Py_CLEAR(EXC_TRACEBACK_F(generator));
283 #endif
284  
285     // Allow re-use of the frame again.
286     Py_DECREF(generator->m_frame);
287     goto frame_no_exception_1;
288  
289     frame_exception_exit_1:;
290  
291     // If it's not an exit exception, consider and create a traceback for it.
292     if (!EXCEPTION_MATCH_GENERATOR(generator_heap->exception_type)) {
293         if (generator_heap->exception_tb == NULL) {
294             generator_heap->exception_tb = MAKE_TRACEBACK(generator->m_frame, generator_heap->exception_lineno);
295         } else if (generator_heap->exception_tb->tb_frame != &generator->m_frame->m_frame) {
296             generator_heap->exception_tb = ADD_TRACEBACK(generator_heap->exception_tb, generator->m_frame, generator_heap->exception_lineno);
297         }
298  
299         Nuitka_Frame_AttachLocals(
300             generator->m_frame,
301             generator_heap->type_description_1
302         );
303  
304  
305         // Release cached frame.
306         if (generator->m_frame == cache_m_frame) {
307 #if _DEBUG_REFCOUNTS
308             count_active_frame_cache_instances -= 1;
309             count_released_frame_cache_instances += 1;
310 #endif
311  
312             Py_DECREF(generator->m_frame);
313         }
314         cache_m_frame = NULL;
315  
316         assertFrameObject(generator->m_frame);
317     }
318  
319 #if PYTHON_VERSION >= 300
320     Py_CLEAR(EXC_TYPE_F(generator));
321     Py_CLEAR(EXC_VALUE_F(generator));
322     Py_CLEAR(EXC_TRACEBACK_F(generator));
323 #endif
324  
325     Py_DECREF(generator->m_frame);
326  
327     // Return the error.
328     goto function_exception_exit;
329  
330     frame_no_exception_1:;
331  
332  
333     return NULL;
334  
335     function_exception_exit:
336     assert(generator_heap->exception_type);
337     RESTORE_ERROR_OCCURRED(generator_heap->exception_type, generator_heap->exception_value, generator_heap->exception_tb);
338  
339     return NULL;
340  
341 }
342  
343 static PyObject *MAKE_GENERATOR___main__$$$function_1_calledRepeatedly$$$function_1_empty$$$genobj_1_empty() {
344     return Nuitka_Generator_New(
345         __main__$$$function_1_calledRepeatedly$$$function_1_empty$$$genobj_1_empty_context,
346         module___main__,
347         mod_consts[0],
348 #if PYTHON_VERSION >= 350
349         mod_consts[1],
350 #endif
351         codeobj_e84f04252b636aae08a8b6a5fbb07936,
352         NULL,
353         0,
354         sizeof(struct __main__$$$function_1_calledRepeatedly$$$function_1_empty$$$genobj_1_empty_locals)
355     );
356 }
357  
358  
359 77
360 static PyObject *MAKE_FUNCTION___main__$$$function_1_calledRepeatedly() { 78 static PyObject *MAKE_FUNCTION___main__$$$function_1_calledRepeatedly() {
361     struct Nuitka_FunctionObject *result = Nuitka_Function_New( 79     struct Nuitka_FunctionObject *result = Nuitka_Function_New(
n 362         impl___main__$$$function_1_calledRepeatedly, n 80         NULL,
363         mod_consts[8], 81         mod_consts[6],
364 #if PYTHON_VERSION >= 300 82 #if PYTHON_VERSION >= 300
365         NULL, 83         NULL,
366 #endif 84 #endif
367         codeobj_5185d9f6e4494977166e105799e60c32, 85         codeobj_5185d9f6e4494977166e105799e60c32,
368         NULL, 86         NULL,
373         module___main__, 91         module___main__,
374         NULL, 92         NULL,
375         NULL, 93         NULL,
376         0 94         0
377     ); 95     );
n 378   n 96     result->m_constant_return_value = mod_consts[5];
379  
380     return (PyObject *)result;
381 }
382  
383  
384  
385 static PyObject *MAKE_FUNCTION___main__$$$function_1_calledRepeatedly$$$function_1_empty() {
386     struct Nuitka_FunctionObject *result = Nuitka_Function_New(
387         impl___main__$$$function_1_calledRepeatedly$$$function_1_empty,
388         mod_consts[0],
389 #if PYTHON_VERSION >= 300
390         mod_consts[1],
391 #endif
392         codeobj_e84f04252b636aae08a8b6a5fbb07936,
393         NULL,
394 #if PYTHON_VERSION >= 300
395         NULL,
396         NULL,
397 #endif
398         module___main__,
399         NULL,
400         NULL,
401         0
402     );
403  
404 97
405     return (PyObject *)result; 98     return (PyObject *)result;
406 } 99 }
407 100
408 101
417 #ifdef _NUITKA_PLUGIN_DILL_ENABLED 110 #ifdef _NUITKA_PLUGIN_DILL_ENABLED
418 // Provide a way to create find a function via its C code and create it back 111 // Provide a way to create find a function via its C code and create it back
419 // in another process, useful for multiprocessing extensions like dill 112 // in another process, useful for multiprocessing extensions like dill
420 113
421 function_impl_code functable___main__[] = { 114 function_impl_code functable___main__[] = {
n 422     impl___main__$$$function_1_calledRepeatedly$$$function_1_empty, n 115     NULL,
423     impl___main__$$$function_1_calledRepeatedly,
424     NULL 116     NULL
425 }; 117 };
426 118
427 static char const *_reduce_compiled_function_argnames[] = { 119 static char const *_reduce_compiled_function_argnames[] = {
428     "func", 120     "func",
786 478
787     // Module code. 479     // Module code.
788     { 480     {
789         PyObject *tmp_assign_source_1; 481         PyObject *tmp_assign_source_1;
790         tmp_assign_source_1 = Py_None; 482         tmp_assign_source_1 = Py_None;
n 791         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[3], tmp_assign_source_1); n 483         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[0], tmp_assign_source_1);
792     } 484     }
793     { 485     {
794         PyObject *tmp_assign_source_2; 486         PyObject *tmp_assign_source_2;
n 795         tmp_assign_source_2 = mod_consts[4]; n 487         tmp_assign_source_2 = mod_consts[1];
796         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[5], tmp_assign_source_2); 488         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[2], tmp_assign_source_2);
797     } 489     }
798     { 490     {
799         PyObject *tmp_assign_source_3; 491         PyObject *tmp_assign_source_3;
800         tmp_assign_source_3 = Py_None; 492         tmp_assign_source_3 = Py_None;
n 801         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[6], tmp_assign_source_3); n 493         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[3], tmp_assign_source_3);
802     } 494     }
803     { 495     {
804         PyObject *tmp_assign_source_4; 496         PyObject *tmp_assign_source_4;
805         tmp_assign_source_4 = Py_None; 497         tmp_assign_source_4 = Py_None;
n 806         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[7], tmp_assign_source_4); n 498         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[4], tmp_assign_source_4);
807     } 499     }
808     { 500     {
809         PyObject *tmp_assign_source_5; 501         PyObject *tmp_assign_source_5;
810 502
811 503
812         tmp_assign_source_5 = MAKE_FUNCTION___main__$$$function_1_calledRepeatedly(); 504         tmp_assign_source_5 = MAKE_FUNCTION___main__$$$function_1_calledRepeatedly();
813 505
n 814         UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[8], tmp_assign_source_5); n 506         UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[6], tmp_assign_source_5);
815     } 507     }
816     { 508     {
817         PyObject *tmp_assign_source_6; 509         PyObject *tmp_assign_source_6;
818         PyObject *tmp_name_name_1; 510         PyObject *tmp_name_name_1;
819         PyObject *tmp_globals_name_1; 511         PyObject *tmp_globals_name_1;
820         PyObject *tmp_locals_name_1; 512         PyObject *tmp_locals_name_1;
821         PyObject *tmp_fromlist_name_1; 513         PyObject *tmp_fromlist_name_1;
822         PyObject *tmp_level_name_1; 514         PyObject *tmp_level_name_1;
n 823         tmp_name_name_1 = mod_consts[9]; n 515         tmp_name_name_1 = mod_consts[7];
824         tmp_globals_name_1 = (PyObject *)moduledict___main__; 516         tmp_globals_name_1 = (PyObject *)moduledict___main__;
825         tmp_locals_name_1 = Py_None; 517         tmp_locals_name_1 = Py_None;
826         tmp_fromlist_name_1 = Py_None; 518         tmp_fromlist_name_1 = Py_None;
n 827         tmp_level_name_1 = mod_consts[10]; n 519         tmp_level_name_1 = mod_consts[8];
828         tmp_assign_source_6 = IMPORT_MODULE5(tmp_name_name_1, tmp_globals_name_1, tmp_locals_name_1, tmp_fromlist_name_1, tmp_level_name_1); 520         tmp_assign_source_6 = IMPORT_MODULE5(tmp_name_name_1, tmp_globals_name_1, tmp_locals_name_1, tmp_fromlist_name_1, tmp_level_name_1);
829         assert(!(tmp_assign_source_6 == NULL)); 521         assert(!(tmp_assign_source_6 == NULL));
n 830         UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[9], tmp_assign_source_6); n 522         UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[7], tmp_assign_source_6);
831     } 523     }
832     // Frame without reuse. 524     // Frame without reuse.
833     frame_c5d0fa1f7bf1e6403f2b8dd49cce5c4c = MAKE_MODULE_FRAME(codeobj_c5d0fa1f7bf1e6403f2b8dd49cce5c4c, module___main__); 525     frame_c5d0fa1f7bf1e6403f2b8dd49cce5c4c = MAKE_MODULE_FRAME(codeobj_c5d0fa1f7bf1e6403f2b8dd49cce5c4c, module___main__);
834 526
835     // Push the new frame as the currently active one, and we should be exclusively 527     // Push the new frame as the currently active one, and we should be exclusively
840     // Framed code: 532     // Framed code:
841     { 533     {
842         PyObject *tmp_assign_source_7; 534         PyObject *tmp_assign_source_7;
843         PyObject *tmp_iter_arg_1; 535         PyObject *tmp_iter_arg_1;
844         PyObject *tmp_called_instance_1; 536         PyObject *tmp_called_instance_1;
n 845         tmp_called_instance_1 = GET_MODULE_VARIABLE_VALUE(moduledict___main__, mod_consts[9]); n 537         tmp_called_instance_1 = GET_MODULE_VARIABLE_VALUE(moduledict___main__, mod_consts[7]);
846         assert(!(tmp_called_instance_1 == NULL)); 538         assert(!(tmp_called_instance_1 == NULL));
847         frame_c5d0fa1f7bf1e6403f2b8dd49cce5c4c->m_frame.f_lineno = 36; 539         frame_c5d0fa1f7bf1e6403f2b8dd49cce5c4c->m_frame.f_lineno = 36;
n 848         tmp_iter_arg_1 = CALL_METHOD_WITH_ARGS2(tmp_called_instance_1, mod_consts[11], &PyTuple_GET_ITEM(mod_consts[12], 0)); n 540         tmp_iter_arg_1 = CALL_METHOD_WITH_ARGS2(tmp_called_instance_1, mod_consts[9], &PyTuple_GET_ITEM(mod_consts[10], 0));
849 541
850         if (tmp_iter_arg_1 == NULL) { 542         if (tmp_iter_arg_1 == NULL) {
851             assert(ERROR_OCCURRED()); 543             assert(ERROR_OCCURRED());
852 544
853             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb); 545             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
902     } 594     }
903     { 595     {
904         PyObject *tmp_assign_source_9; 596         PyObject *tmp_assign_source_9;
905         CHECK_OBJECT(tmp_for_loop_1__iter_value); 597         CHECK_OBJECT(tmp_for_loop_1__iter_value);
906         tmp_assign_source_9 = tmp_for_loop_1__iter_value; 598         tmp_assign_source_9 = tmp_for_loop_1__iter_value;
n 907         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[13], tmp_assign_source_9); n 599         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[11], tmp_assign_source_9);
908     } 600     }
909     { 601     {
910         PyObject *tmp_called_name_1; 602         PyObject *tmp_called_name_1;
911         PyObject *tmp_call_result_1; 603         PyObject *tmp_call_result_1;
n 912         tmp_called_name_1 = GET_MODULE_VARIABLE_VALUE(moduledict___main__, mod_consts[8]); n 604         tmp_called_name_1 = GET_MODULE_VARIABLE_VALUE(moduledict___main__, mod_consts[6]);
913         if (tmp_called_name_1 == NULL) { 605         if (tmp_called_name_1 == NULL) {
914             assert(ERROR_OCCURRED()); 606             assert(ERROR_OCCURRED());
915 607
916             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb); 608             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
917 609
978     Py_DECREF(tmp_for_loop_1__for_iterator); 670     Py_DECREF(tmp_for_loop_1__for_iterator);
979     tmp_for_loop_1__for_iterator = NULL; 671     tmp_for_loop_1__for_iterator = NULL;
980     { 672     {
981         PyObject *tmp_called_name_2; 673         PyObject *tmp_called_name_2;
982         PyObject *tmp_call_result_2; 674         PyObject *tmp_call_result_2;
n 983         tmp_called_name_2 = LOOKUP_BUILTIN(mod_consts[14]); n 675         tmp_called_name_2 = LOOKUP_BUILTIN(mod_consts[12]);
984         assert(tmp_called_name_2 != NULL); 676         assert(tmp_called_name_2 != NULL);
985         frame_c5d0fa1f7bf1e6403f2b8dd49cce5c4c->m_frame.f_lineno = 39; 677         frame_c5d0fa1f7bf1e6403f2b8dd49cce5c4c->m_frame.f_lineno = 39;
t 986         tmp_call_result_2 = CALL_FUNCTION_WITH_SINGLE_ARG(tmp_called_name_2, mod_consts[15]); t 678         tmp_call_result_2 = CALL_FUNCTION_WITH_SINGLE_ARG(tmp_called_name_2, mod_consts[13]);
987         if (tmp_call_result_2 == NULL) { 679         if (tmp_call_result_2 == NULL) {
988             assert(ERROR_OCCURRED()); 680             assert(ERROR_OCCURRED());
989 681
990             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb); 682             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);
991 683