Construct FunctionCreationGeneratorLocal

Performance Diagrams

Construct FunctionCreationGeneratorLocal 00100000010000002000000200000030000003000000400000040000005000000500000060000006000000700000070000008000000800000090000009000000100000001000000011000000110000001200000012000000130000001300000014000000140000001500000015000000CPython 2.7Nuitka (master)Nuitka (develop)Nuitka (factory)1502901988.95192307692307257.0CPython 2.78251185242.31730769230768368.4448691407756Nuitka (master)6101484395.6826923076923403.7914336386366Nuitka (develop)6101484549.0480769230769403.7914336386366Nuitka (factory)Construct FunctionCreationGeneratorLocalTicks Construct FunctionCreationGeneratorLocal 00200000020000004000000400000060000006000000800000080000001000000010000000120000001200000014000000140000001600000016000000180000001800000020000000200000002200000022000000CPython 3.8Nuitka (master)Nuitka (develop)Nuitka (factory)2318077988.95192307692307257.0CPython 3.810900918242.31730769230768387.90770478586853Nuitka (master)10903630395.6826923076923387.8787938971069Nuitka (develop)10903630549.0480769230769387.8787938971069Nuitka (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 #ifndef __NUITKA_NO_ASSERT__ 37 #ifndef __NUITKA_NO_ASSERT__
n 38 static Py_hash_t mod_consts_hash[19]; n 38 static Py_hash_t mod_consts_hash[17];
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 < 19; i++) { n 53         for(int i = 0; i < 17; 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 < 19; i++) { n 73     for(int i = 0; i < 17; 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
79 79
80 // The module code objects. 80 // The module code objects.
81 static PyCodeObject *codeobj_ad669c260ec1bd3224f375392220b133; 81 static PyCodeObject *codeobj_ad669c260ec1bd3224f375392220b133;
82 static PyCodeObject *codeobj_a469c63f076448ddc772a9521dfaa2cd; 82 static PyCodeObject *codeobj_a469c63f076448ddc772a9521dfaa2cd;
n 83 static PyCodeObject *codeobj_92f5fea8d8bfb0297617f6456fd04960; n
84 /* For use in "MainProgram.c". */ 83 /* For use in "MainProgram.c". */
85 PyCodeObject *codeobj_main = NULL; 84 PyCodeObject *codeobj_main = NULL;
86 85
87 static void createModuleCodeObjects(void) { 86 static void createModuleCodeObjects(void) {
n 88     module_filename_obj = mod_consts[4]; CHECK_OBJECT(module_filename_obj); n 87     module_filename_obj = mod_consts[1]; CHECK_OBJECT(module_filename_obj);
89     codeobj_ad669c260ec1bd3224f375392220b133 = MAKE_CODEOBJECT(module_filename_obj, 1, CO_NOFREE, mod_consts[17], NULL, NULL, 0, 0, 0); 88     codeobj_ad669c260ec1bd3224f375392220b133 = MAKE_CODEOBJECT(module_filename_obj, 1, CO_NOFREE, mod_consts[15], NULL, NULL, 0, 0, 0);
90     codeobj_a469c63f076448ddc772a9521dfaa2cd = MAKE_CODEOBJECT(module_filename_obj, 23, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE, mod_consts[9], mod_consts[18], NULL, 0, 0, 0); 89     codeobj_a469c63f076448ddc772a9521dfaa2cd = MAKE_CODEOBJECT(module_filename_obj, 23, CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE, mod_consts[7], mod_consts[16], NULL, 0, 0, 0);
91     codeobj_92f5fea8d8bfb0297617f6456fd04960 = MAKE_CODEOBJECT(module_filename_obj, 26, CO_GENERATOR | CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE, mod_consts[0], NULL, NULL, 0, 0, 0);
92 } 90 }
93 91
94 // The module function declarations. 92 // The module function declarations.
n 95 static PyObject *MAKE_GENERATOR___main__$$$function__1_calledRepeatedly$$$function__1_empty$$$genobj__1_empty(); n
96  
97  
98 static PyObject *MAKE_FUNCTION___main__$$$function__1_calledRepeatedly(); 93 static PyObject *MAKE_FUNCTION___main__$$$function__1_calledRepeatedly();
99 94
100 95
n 101 static PyObject *MAKE_FUNCTION___main__$$$function__1_calledRepeatedly$$$function__1_empty(); n
102  
103  
104 // The module function definitions. 96 // The module function definitions.
n 105 static PyObject *impl___main__$$$function__1_calledRepeatedly(struct Nuitka_FunctionObject const *self, PyObject **python_pars) { n
106     // Preserve error status for checks
107 #ifndef __NUITKA_NO_ASSERT__
108     NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED();
109 #endif
110  
111     // Local variable declarations.
112     PyObject *var_empty = NULL;
113     PyObject *tmp_return_value = NULL;
114  
115     // Actual function body.
116     {
117         PyObject *tmp_assign_source_1;
118  
119  
120         tmp_assign_source_1 = MAKE_FUNCTION___main__$$$function__1_calledRepeatedly$$$function__1_empty();
121  
122         assert(var_empty == NULL);
123         var_empty = tmp_assign_source_1;
124     }
125     // Tried code:
126     CHECK_OBJECT(var_empty);
127     tmp_return_value = var_empty;
128     Py_INCREF(tmp_return_value);
129     goto try_return_handler_1;
130     NUITKA_CANNOT_GET_HERE("tried codes exits in all cases");
131     return NULL;
132     // Return handler code:
133     try_return_handler_1:;
134     CHECK_OBJECT(var_empty);
135     Py_DECREF(var_empty);
136     var_empty = NULL;
137     goto function_return_exit;
138     // End of try:
139  
140     NUITKA_CANNOT_GET_HERE("Return statement must have exited already.");
141     return NULL;
142  
143  
144 function_return_exit:
145    // Function cleanup code if any.
146  
147  
148    // Actual function exit with return value, making sure we did not make
149    // the error status worse despite non-NULL return.
150    CHECK_OBJECT(tmp_return_value);
151    assert(had_error || !ERROR_OCCURRED());
152    return tmp_return_value;
153 }
154  
155  
156 static PyObject *impl___main__$$$function__1_calledRepeatedly$$$function__1_empty(struct Nuitka_FunctionObject const *self, PyObject **python_pars) {
157     // Preserve error status for checks
158 #ifndef __NUITKA_NO_ASSERT__
159     NUITKA_MAY_BE_UNUSED bool had_error = ERROR_OCCURRED();
160 #endif
161  
162     // Local variable declarations.
163     PyObject *tmp_return_value = NULL;
164  
165     // Actual function body.
166  
167  
168     tmp_return_value = MAKE_GENERATOR___main__$$$function__1_calledRepeatedly$$$function__1_empty$$$genobj__1_empty();
169  
170     goto function_return_exit;
171  
172     NUITKA_CANNOT_GET_HERE("Return statement must have exited already.");
173     return NULL;
174  
175  
176 function_return_exit:
177    // Function cleanup code if any.
178  
179  
180    // Actual function exit with return value, making sure we did not make
181    // the error status worse despite non-NULL return.
182    CHECK_OBJECT(tmp_return_value);
183    assert(had_error || !ERROR_OCCURRED());
184    return tmp_return_value;
185 }
186  
187  
188  
189 struct __main__$$$function__1_calledRepeatedly$$$function__1_empty$$$genobj__1_empty_locals {
190     char const *type_description_1;
191     PyObject *exception_type;
192     PyObject *exception_value;
193     PyTracebackObject *exception_tb;
194     int exception_lineno;
195 };
196  
197 static PyObject *__main__$$$function__1_calledRepeatedly$$$function__1_empty$$$genobj__1_empty_context(struct Nuitka_GeneratorObject *generator, PyObject *yield_return_value) {
198     CHECK_OBJECT(generator);
199     assert(Nuitka_Generator_Check((PyObject *)generator));
200     CHECK_OBJECT_X(yield_return_value);
201  
202     // Heap access if used.
203     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;
204  
205     // Dispatch to yield based on return label index:
206     switch(generator->m_yield_return_index) {
207     case 1: goto yield_return_1;
208     }
209  
210     // Local variable initialization
211     NUITKA_MAY_BE_UNUSED nuitka_void tmp_unused;
212     static struct Nuitka_FrameObject *cache_m_frame = NULL;
213     generator_heap->type_description_1 = NULL;
214     generator_heap->exception_type = NULL;
215     generator_heap->exception_value = NULL;
216     generator_heap->exception_tb = NULL;
217     generator_heap->exception_lineno = 0;
218  
219     // Actual generator function body.
220     if (isFrameUnusable(cache_m_frame)) {
221         Py_XDECREF(cache_m_frame);
222  
223 #if _DEBUG_REFCOUNTS
224         if (cache_m_frame == NULL) {
225             count_active_frame_cache_instances += 1;
226         } else {
227             count_released_frame_cache_instances += 1;
228         }
229         count_allocated_frame_cache_instances += 1;
230 #endif
231         cache_m_frame = MAKE_FUNCTION_FRAME(codeobj_92f5fea8d8bfb0297617f6456fd04960, module___main__, 0);
232 #if _DEBUG_REFCOUNTS
233     } else {
234         count_hit_frame_cache_instances += 1;
235 #endif
236     }
237     generator->m_frame = cache_m_frame;
238  
239     // Mark the frame object as in use, ref count 1 will be up for reuse.
240     Py_INCREF(generator->m_frame);
241     assert(Py_REFCNT(generator->m_frame) == 2); // Frame stack
242  
243 #if PYTHON_VERSION >= 0x340
244     generator->m_frame->m_frame.f_gen = (PyObject *)generator;
245 #endif
246  
247     assert(generator->m_frame->m_frame.f_back == NULL);
248     Py_CLEAR(generator->m_frame->m_frame.f_back);
249  
250     generator->m_frame->m_frame.f_back = PyThreadState_GET()->frame;
251     Py_INCREF(generator->m_frame->m_frame.f_back);
252  
253     PyThreadState_GET()->frame = &generator->m_frame->m_frame;
254     Py_INCREF(generator->m_frame);
255  
256     Nuitka_Frame_MarkAsExecuting(generator->m_frame);
257  
258 #if PYTHON_VERSION >= 0x300
259     // Accept currently existing exception as the one to publish again when we
260     // yield or yield from.
261     {
262         PyThreadState *thread_state = PyThreadState_GET();
263  
264         EXC_TYPE_F(generator) = EXC_TYPE(thread_state);
265         if (EXC_TYPE_F(generator) == Py_None) EXC_TYPE_F(generator) = NULL;
266         Py_XINCREF(EXC_TYPE_F(generator));
267         EXC_VALUE_F(generator) = EXC_VALUE(thread_state);
268         Py_XINCREF(EXC_VALUE_F(generator));
269         EXC_TRACEBACK_F(generator) = EXC_TRACEBACK(thread_state);
270         Py_XINCREF(EXC_TRACEBACK_F(generator));
271     }
272  
273 #endif
274  
275     // Framed code:
276     {
277         PyObject *tmp_expression_name_1;
278         NUITKA_MAY_BE_UNUSED PyObject *tmp_yield_result_1;
279         tmp_expression_name_1 = mod_consts[2];
280         Py_INCREF(tmp_expression_name_1);
281         generator->m_yield_return_index = 1;
282         return tmp_expression_name_1;
283         yield_return_1:
284         if (yield_return_value == NULL) {
285             assert(ERROR_OCCURRED());
286  
287             FETCH_ERROR_OCCURRED(&generator_heap->exception_type, &generator_heap->exception_value, &generator_heap->exception_tb);
288  
289  
290             generator_heap->exception_lineno = 27;
291  
292             goto frame_exception_exit_1;
293         }
294         tmp_yield_result_1 = yield_return_value;
295     }
296  
297     Nuitka_Frame_MarkAsNotExecuting(generator->m_frame);
298  
299 #if PYTHON_VERSION >= 0x300
300     Py_CLEAR(EXC_TYPE_F(generator));
301     Py_CLEAR(EXC_VALUE_F(generator));
302     Py_CLEAR(EXC_TRACEBACK_F(generator));
303 #endif
304  
305     // Allow re-use of the frame again.
306     Py_DECREF(generator->m_frame);
307     goto frame_no_exception_1;
308  
309     frame_exception_exit_1:;
310  
311     // If it's not an exit exception, consider and create a traceback for it.
312     if (!EXCEPTION_MATCH_GENERATOR(generator_heap->exception_type)) {
313         if (generator_heap->exception_tb == NULL) {
314             generator_heap->exception_tb = MAKE_TRACEBACK(generator->m_frame, generator_heap->exception_lineno);
315         } else if (generator_heap->exception_tb->tb_frame != &generator->m_frame->m_frame) {
316             generator_heap->exception_tb = ADD_TRACEBACK(generator_heap->exception_tb, generator->m_frame, generator_heap->exception_lineno);
317         }
318  
319         Nuitka_Frame_AttachLocals(
320             generator->m_frame,
321             generator_heap->type_description_1
322         );
323  
324  
325         // Release cached frame if used for exception.
326         if (generator->m_frame == cache_m_frame) {
327 #if _DEBUG_REFCOUNTS
328             count_active_frame_cache_instances -= 1;
329             count_released_frame_cache_instances += 1;
330 #endif
331  
332             Py_DECREF(cache_m_frame);
333             cache_m_frame = NULL;
334         }
335  
336         assertFrameObject(generator->m_frame);
337     }
338  
339 #if PYTHON_VERSION >= 0x300
340     Py_CLEAR(EXC_TYPE_F(generator));
341     Py_CLEAR(EXC_VALUE_F(generator));
342     Py_CLEAR(EXC_TRACEBACK_F(generator));
343 #endif
344  
345     Py_DECREF(generator->m_frame);
346  
347     // Return the error.
348     goto function_exception_exit;
349  
350     frame_no_exception_1:;
351  
352  
353     return NULL;
354  
355     function_exception_exit:
356     assert(generator_heap->exception_type);
357     RESTORE_ERROR_OCCURRED(generator_heap->exception_type, generator_heap->exception_value, generator_heap->exception_tb);
358  
359     return NULL;
360  
361 }
362  
363 static PyObject *MAKE_GENERATOR___main__$$$function__1_calledRepeatedly$$$function__1_empty$$$genobj__1_empty() {
364     return Nuitka_Generator_New(
365         __main__$$$function__1_calledRepeatedly$$$function__1_empty$$$genobj__1_empty_context,
366         module___main__,
367         mod_consts[0],
368 #if PYTHON_VERSION >= 0x350
369         mod_consts[1],
370 #endif
371         codeobj_92f5fea8d8bfb0297617f6456fd04960,
372         NULL,
373         0,
374         sizeof(struct __main__$$$function__1_calledRepeatedly$$$function__1_empty$$$genobj__1_empty_locals)
375     );
376 }
377  
378  
379 97
380 static PyObject *MAKE_FUNCTION___main__$$$function__1_calledRepeatedly() { 98 static PyObject *MAKE_FUNCTION___main__$$$function__1_calledRepeatedly() {
381     struct Nuitka_FunctionObject *result = Nuitka_Function_New( 99     struct Nuitka_FunctionObject *result = Nuitka_Function_New(
n 382         impl___main__$$$function__1_calledRepeatedly, n 100         NULL,
383         mod_consts[9], 101         mod_consts[7],
384 #if PYTHON_VERSION >= 0x300 102 #if PYTHON_VERSION >= 0x300
385         NULL, 103         NULL,
386 #endif 104 #endif
387         codeobj_a469c63f076448ddc772a9521dfaa2cd, 105         codeobj_a469c63f076448ddc772a9521dfaa2cd,
388         NULL, 106         NULL,
393         module___main__, 111         module___main__,
394         NULL, 112         NULL,
395         NULL, 113         NULL,
396         0 114         0
397     ); 115     );
n 398   n 116     Nuitka_Function_EnableConstReturnGeneric(result, mod_consts[6]);
399  
400     return (PyObject *)result;
401 }
402  
403  
404  
405 static PyObject *MAKE_FUNCTION___main__$$$function__1_calledRepeatedly$$$function__1_empty() {
406     struct Nuitka_FunctionObject *result = Nuitka_Function_New(
407         impl___main__$$$function__1_calledRepeatedly$$$function__1_empty,
408         mod_consts[0],
409 #if PYTHON_VERSION >= 0x300
410         mod_consts[1],
411 #endif
412         codeobj_92f5fea8d8bfb0297617f6456fd04960,
413         NULL,
414 #if PYTHON_VERSION >= 0x300
415         NULL,
416         NULL,
417 #endif
418         module___main__,
419         NULL,
420         NULL,
421         0
422     );
423  
424 117
425     return (PyObject *)result; 118     return (PyObject *)result;
426 } 119 }
427 120
428 121
438 // Provide a way to create find a function via its C code and create it back 131 // Provide a way to create find a function via its C code and create it back
439 // in another process, useful for multiprocessing extensions like dill 132 // in another process, useful for multiprocessing extensions like dill
440 extern void registerDillPluginTables(char const *module_name, PyMethodDef *reduce_compiled_function, PyMethodDef *create_compiled_function); 133 extern void registerDillPluginTables(char const *module_name, PyMethodDef *reduce_compiled_function, PyMethodDef *create_compiled_function);
441 134
442 function_impl_code functable___main__[] = { 135 function_impl_code functable___main__[] = {
n 443     impl___main__$$$function__1_calledRepeatedly$$$function__1_empty, n 136     NULL,
444     impl___main__$$$function__1_calledRepeatedly,
445     NULL 137     NULL
446 }; 138 };
447 139
448 static char const *_reduce_compiled_function_argnames[] = { 140 static char const *_reduce_compiled_function_argnames[] = {
449     "func", 141     "func",
784 476
785     // Module code. 477     // Module code.
786     { 478     {
787         PyObject *tmp_assign_source_1; 479         PyObject *tmp_assign_source_1;
788         tmp_assign_source_1 = Py_None; 480         tmp_assign_source_1 = Py_None;
n 789         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[3], tmp_assign_source_1); n 481         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[0], tmp_assign_source_1);
790     } 482     }
791     { 483     {
792         PyObject *tmp_assign_source_2; 484         PyObject *tmp_assign_source_2;
n 793         tmp_assign_source_2 = mod_consts[4]; n 485         tmp_assign_source_2 = mod_consts[1];
794         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[5], tmp_assign_source_2); 486         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[2], tmp_assign_source_2);
795     } 487     }
796     { 488     {
797         PyObject *tmp_assign_source_3; 489         PyObject *tmp_assign_source_3;
798         tmp_assign_source_3 = Py_None; 490         tmp_assign_source_3 = Py_None;
n 799         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[6], tmp_assign_source_3); n 491         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[3], tmp_assign_source_3);
800     } 492     }
801     { 493     {
802         PyObject *tmp_assign_source_4; 494         PyObject *tmp_assign_source_4;
803         tmp_assign_source_4 = PyDict_New(); 495         tmp_assign_source_4 = PyDict_New();
n 804         UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[7], tmp_assign_source_4); n 496         UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[4], tmp_assign_source_4);
805     } 497     }
806     { 498     {
807         PyObject *tmp_assign_source_5; 499         PyObject *tmp_assign_source_5;
808         tmp_assign_source_5 = Py_None; 500         tmp_assign_source_5 = Py_None;
n 809         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[8], tmp_assign_source_5); n 501         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[5], tmp_assign_source_5);
810     } 502     }
811     { 503     {
812         PyObject *tmp_assign_source_6; 504         PyObject *tmp_assign_source_6;
813 505
814 506
815         tmp_assign_source_6 = MAKE_FUNCTION___main__$$$function__1_calledRepeatedly(); 507         tmp_assign_source_6 = MAKE_FUNCTION___main__$$$function__1_calledRepeatedly();
816 508
n 817         UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[9], tmp_assign_source_6); n 509         UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[7], tmp_assign_source_6);
818     } 510     }
819     { 511     {
820         PyObject *tmp_assign_source_7; 512         PyObject *tmp_assign_source_7;
821         PyObject *tmp_name_name_1; 513         PyObject *tmp_name_name_1;
822         PyObject *tmp_globals_arg_name_1; 514         PyObject *tmp_globals_arg_name_1;
823         PyObject *tmp_locals_arg_name_1; 515         PyObject *tmp_locals_arg_name_1;
824         PyObject *tmp_fromlist_name_1; 516         PyObject *tmp_fromlist_name_1;
825         PyObject *tmp_level_name_1; 517         PyObject *tmp_level_name_1;
n 826         tmp_name_name_1 = mod_consts[10]; n 518         tmp_name_name_1 = mod_consts[8];
827         tmp_globals_arg_name_1 = (PyObject *)moduledict___main__; 519         tmp_globals_arg_name_1 = (PyObject *)moduledict___main__;
828         tmp_locals_arg_name_1 = Py_None; 520         tmp_locals_arg_name_1 = Py_None;
829         tmp_fromlist_name_1 = Py_None; 521         tmp_fromlist_name_1 = Py_None;
n 830         tmp_level_name_1 = mod_consts[11]; n 522         tmp_level_name_1 = mod_consts[9];
831         tmp_assign_source_7 = IMPORT_MODULE5(tmp_name_name_1, tmp_globals_arg_name_1, tmp_locals_arg_name_1, tmp_fromlist_name_1, tmp_level_name_1); 523         tmp_assign_source_7 = IMPORT_MODULE5(tmp_name_name_1, tmp_globals_arg_name_1, tmp_locals_arg_name_1, tmp_fromlist_name_1, tmp_level_name_1);
832         assert(!(tmp_assign_source_7 == NULL)); 524         assert(!(tmp_assign_source_7 == NULL));
n 833         UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[10], tmp_assign_source_7); n 525         UPDATE_STRING_DICT1(moduledict___main__, (Nuitka_StringObject *)mod_consts[8], tmp_assign_source_7);
834     } 526     }
835     // Frame without reuse. 527     // Frame without reuse.
836     frame_ad669c260ec1bd3224f375392220b133 = MAKE_MODULE_FRAME(codeobj_ad669c260ec1bd3224f375392220b133, module___main__); 528     frame_ad669c260ec1bd3224f375392220b133 = MAKE_MODULE_FRAME(codeobj_ad669c260ec1bd3224f375392220b133, module___main__);
837 529
838     // Push the new frame as the currently active one, and we should be exclusively 530     // Push the new frame as the currently active one, and we should be exclusively
843     // Framed code: 535     // Framed code:
844     { 536     {
845         PyObject *tmp_assign_source_8; 537         PyObject *tmp_assign_source_8;
846         PyObject *tmp_iter_arg_1; 538         PyObject *tmp_iter_arg_1;
847         PyObject *tmp_called_instance_1; 539         PyObject *tmp_called_instance_1;
n 848         tmp_called_instance_1 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[10]); n 540         tmp_called_instance_1 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[8]);
849 541
850         if (unlikely(tmp_called_instance_1 == NULL)) { 542         if (unlikely(tmp_called_instance_1 == NULL)) {
n 851             tmp_called_instance_1 = GET_MODULE_VARIABLE_VALUE_FALLBACK(mod_consts[10]); n 543             tmp_called_instance_1 = GET_MODULE_VARIABLE_VALUE_FALLBACK(mod_consts[8]);
852         } 544         }
853 545
854         assert(!(tmp_called_instance_1 == NULL)); 546         assert(!(tmp_called_instance_1 == NULL));
855         frame_ad669c260ec1bd3224f375392220b133->m_frame.f_lineno = 36; 547         frame_ad669c260ec1bd3224f375392220b133->m_frame.f_lineno = 36;
856         tmp_iter_arg_1 = CALL_METHOD_WITH_ARGS2( 548         tmp_iter_arg_1 = CALL_METHOD_WITH_ARGS2(
857             tmp_called_instance_1, 549             tmp_called_instance_1,
n 858             mod_consts[12], n 550             mod_consts[10],
859             &PyTuple_GET_ITEM(mod_consts[13], 0) 551             &PyTuple_GET_ITEM(mod_consts[11], 0)
860         ); 552         );
861 553
862         if (tmp_iter_arg_1 == NULL) { 554         if (tmp_iter_arg_1 == NULL) {
863             assert(ERROR_OCCURRED()); 555             assert(ERROR_OCCURRED());
864 556
914     } 606     }
915     { 607     {
916         PyObject *tmp_assign_source_10; 608         PyObject *tmp_assign_source_10;
917         CHECK_OBJECT(tmp_for_loop_1__iter_value); 609         CHECK_OBJECT(tmp_for_loop_1__iter_value);
918         tmp_assign_source_10 = tmp_for_loop_1__iter_value; 610         tmp_assign_source_10 = tmp_for_loop_1__iter_value;
n 919         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[14], tmp_assign_source_10); n 611         UPDATE_STRING_DICT0(moduledict___main__, (Nuitka_StringObject *)mod_consts[12], tmp_assign_source_10);
920     } 612     }
921     { 613     {
922         PyObject *tmp_called_name_1; 614         PyObject *tmp_called_name_1;
923         PyObject *tmp_call_result_1; 615         PyObject *tmp_call_result_1;
n 924         tmp_called_name_1 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[9]); n 616         tmp_called_name_1 = GET_STRING_DICT_VALUE(moduledict___main__, (Nuitka_StringObject *)mod_consts[7]);
925 617
926         if (unlikely(tmp_called_name_1 == NULL)) { 618         if (unlikely(tmp_called_name_1 == NULL)) {
n 927             tmp_called_name_1 = GET_MODULE_VARIABLE_VALUE_FALLBACK(mod_consts[9]); n 619             tmp_called_name_1 = GET_MODULE_VARIABLE_VALUE_FALLBACK(mod_consts[7]);
928         } 620         }
929 621
930         if (tmp_called_name_1 == NULL) { 622         if (tmp_called_name_1 == NULL) {
931             assert(ERROR_OCCURRED()); 623             assert(ERROR_OCCURRED());
932 624
995     Py_DECREF(tmp_for_loop_1__for_iterator); 687     Py_DECREF(tmp_for_loop_1__for_iterator);
996     tmp_for_loop_1__for_iterator = NULL; 688     tmp_for_loop_1__for_iterator = NULL;
997     { 689     {
998         PyObject *tmp_called_name_2; 690         PyObject *tmp_called_name_2;
999         PyObject *tmp_call_result_2; 691         PyObject *tmp_call_result_2;
n 1000         tmp_called_name_2 = LOOKUP_BUILTIN(mod_consts[15]); n 692         tmp_called_name_2 = LOOKUP_BUILTIN(mod_consts[13]);
1001         assert(tmp_called_name_2 != NULL); 693         assert(tmp_called_name_2 != NULL);
1002         frame_ad669c260ec1bd3224f375392220b133->m_frame.f_lineno = 39; 694         frame_ad669c260ec1bd3224f375392220b133->m_frame.f_lineno = 39;
t 1003         tmp_call_result_2 = CALL_FUNCTION_WITH_POSARGS1(tmp_called_name_2, mod_consts[16]); t 695         tmp_call_result_2 = CALL_FUNCTION_WITH_POSARGS1(tmp_called_name_2, mod_consts[14]);
1004 696
1005         if (tmp_call_result_2 == NULL) { 697         if (tmp_call_result_2 == NULL) {
1006             assert(ERROR_OCCURRED()); 698             assert(ERROR_OCCURRED());
1007 699
1008             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb); 700             FETCH_ERROR_OCCURRED(&exception_type, &exception_value, &exception_tb);