Merge 74937f4b8c into 8514e46034

Automatic update of ./internal/source
Merge pull request #478 from a740g/logical-operators
2024-05-10 01:30:13 +00:00 · 2024-04-11 09:28:02 +03:00 · 2024-04-10 17:52:08 +00:00 · 2024-04-10 23:03:36 +05:30 · 2024-04-10 20:06:57 +05:30 · 2024-04-06 22:19:13 +05:30
501 changed files with 102815 additions and 102477 deletions
--- a/internal/c/libqb.cpp
+++ b/internal/c/libqb.cpp
@ -27227,49 +27227,61 @@ void GLUT_SPECIAL_FUNC(int key, int x, int y) {
 }
 void GLUT_SPECIALUP_FUNC(int key, int x, int y) { GLUT_key_special(key, 0); }

-#ifdef QB64_WINDOWS
-void GLUT_TIMER_EVENT(int ignore) {
-    libqb_process_glut_queue();
+static int64_t lastTick = 0;
+static double deltaTick = 0;

-#    ifdef QB64_GLUT
-    glutPostRedisplay();
-    int32 msdelay = 1000.0 / max_fps;
-    Sleep(4);
-    msdelay -= 4; // this forces GLUT to relinquish some CPU time to other threads but still allow for _FPS 100+
-    if (msdelay < 1)
-        msdelay = 1;
-    glutTimerFunc(msdelay, GLUT_TIMER_EVENT, 0);
-#    endif
-}
-#else
 void GLUT_IDLEFUNC() {
    libqb_process_glut_queue();

-#    ifdef QB64_MACOSX
-#        ifdef DEPENDENCY_DEVICEINPUT
+#ifdef QB64_MACOSX
+#    ifdef DEPENDENCY_DEVICEINPUT
    // must be in same thread as GLUT for OSX
    QB64_GAMEPAD_POLL();
    //[[[[NSApplication sharedApplication] mainWindow] standardWindowButton:NSWindowCloseButton] setEnabled:YES];
-#        endif
 #    endif
+#endif

-#    ifdef QB64_GLUT
+#ifdef QB64_GLUT

+#    ifdef QB64_LINUX
    if (x11_lock_request) {
        x11_locked = 1;
        x11_lock_request = 0;
        while (x11_locked)
            Sleep(1);
    }
+#    endif
+    int64_t curTime = GetTicks();
+
+    // This is how long the frame took to render
+    int64_t elapsed = curTime - lastTick;
+
+    // Calculate out the error between how long the frame was 'supposed' to take vs. how long it actually took.
+    deltaTick += ((double)1000 / max_fps) - (double)elapsed;
+
+    lastTick = curTime;
+
+    // If the error is positive, we sleep for that period of time.
+    if (deltaTick > 0) {
+        int32 msdelay = deltaTick;
+        Sleep(msdelay);
+
+        int64_t sleepTime = GetTicks();
+
+        // Subtract off the time we spent sleeping. This should leave deltaTick at zero or slightly negative.
+        // If it ends up negative, then we'll sleep less next frame to compensate
+        deltaTick -= sleepTime - lastTick;
+        lastTick = sleepTime;
+    } else {
+        // If we fall behind by a full frame or more, then skip to the next one
+        while (deltaTick < -((double)1000 / max_fps))
+            deltaTick += ((double)1000 / max_fps);
+    }

    glutPostRedisplay();
-    int32 msdelay = 1000.0 / max_fps;
-    if (msdelay < 1)
-        msdelay = 1;
-    Sleep(msdelay);
-#    endif
-}
 #endif
+}
+

 #ifdef QB64_MACOSX
 #    include <sys/sysctl.h>
@ -29468,6 +29480,8 @@ int32 func__scaledheight() { return environment_2d__screen_scaled_height; }
 extern void set_dynamic_info();

 int main(int argc, char *argv[]) {
+    clock_init();
+

 #if defined(QB64_LINUX) && defined(X11)
    XInitThreads();
--- a/internal/c/libqb/include/datetime.h
+++ b/internal/c/libqb/include/datetime.h
@ -4,6 +4,14 @@
 #include <stdint.h>
 #include "qbs.h"

+#ifdef QB64_LINUX
+// Initializes the clock returned by 'GetTicks()' so that it starts from zero
+// Should be called at the very beginning of the program
+void clock_init();
+#else
+static inline void clock_init() { }
+#endif
+
 int64_t GetTicks();

 double func_timer(double accuracy, int32_t passed);
--- a/internal/c/libqb/src/datetime.cpp
+++ b/internal/c/libqb/src/datetime.cpp
@ -37,10 +37,18 @@ static int64_t orwl_gettime(void) {
 #endif

 #ifdef QB64_LINUX
+static int64_t initial_tick = 0;
+
+void clock_init() {
+    // When GetTicks() is called here initial_tick is zero, so as a result
+    // GetTicks() returns the original value of the clock.
+    initial_tick = GetTicks();
+}
+
 int64_t GetTicks() {
    struct timespec tp;
    clock_gettime(CLOCK_MONOTONIC, &tp);
-    return tp.tv_sec * 1000 + tp.tv_nsec / 1000000;
+    return (tp.tv_sec * 1000 + tp.tv_nsec / 1000000) - initial_tick;
 }
 #elif defined QB64_MACOSX
 int64_t GetTicks() { return orwl_gettime(); }
--- a/internal/c/libqb/src/glut-main-thread.cpp
+++ b/internal/c/libqb/src/glut-main-thread.cpp
@ -43,11 +43,7 @@ void GLUT_MOTION_FUNC(int x, int y);
 void GLUT_PASSIVEMOTION_FUNC(int x, int y);
 void GLUT_RESHAPE_FUNC(int width, int height);

-#ifdef QB64_WINDOWS
-void GLUT_TIMER_EVENT(int ignore);
-#else
 void GLUT_IDLEFUNC();
-#endif

 #ifdef CORE_FREEGLUT
 void GLUT_MOUSEWHEEL_FUNC(int wheel, int direction, int x, int y);
@ -97,11 +93,7 @@ static void initialize_glut(int argc, char **argv) {

    glutDisplayFunc(GLUT_DISPLAY_REQUEST);

-#ifdef QB64_WINDOWS
-    glutTimerFunc(8, GLUT_TIMER_EVENT, 0);
-#else
    glutIdleFunc(GLUT_IDLEFUNC);
-#endif

    glutKeyboardFunc(GLUT_KEYBOARD_FUNC);
    glutKeyboardUpFunc(GLUT_KEYBOARDUP_FUNC);
--- a/internal/source/data1.txt
+++ b/internal/source/data1.txt
@ -5,13 +5,13 @@ if(_FUNC_PARSECMDLINEARGS_LONG_I==NULL){
 _FUNC_PARSECMDLINEARGS_LONG_I=(int32*)mem_static_malloc(4);
 *_FUNC_PARSECMDLINEARGS_LONG_I=0;
 }
-int64 fornext_value2174;
-int64 fornext_finalvalue2174;
-int64 fornext_step2174;
-uint8 fornext_step_negative2174;
+int64 fornext_value2180;
+int64 fornext_finalvalue2180;
+int64 fornext_step2180;
+uint8 fornext_step_negative2180;
 qbs *_FUNC_PARSECMDLINEARGS_STRING_TOKEN=NULL;
 if (!_FUNC_PARSECMDLINEARGS_STRING_TOKEN)_FUNC_PARSECMDLINEARGS_STRING_TOKEN=qbs_new(0,0);
-static qbs *sc_2175=qbs_new(0,0);
+static qbs *sc_2181=qbs_new(0,0);
 int32 *_FUNC_PARSECMDLINEARGS_LONG_CMDLINESWITCH=NULL;
 if(_FUNC_PARSECMDLINEARGS_LONG_CMDLINESWITCH==NULL){
 _FUNC_PARSECMDLINEARGS_LONG_CMDLINESWITCH=(int32*)mem_static_malloc(4);
@ -22,16 +22,16 @@ if(_FUNC_PARSECMDLINEARGS_LONG_SETTINGSMODE==NULL){
 _FUNC_PARSECMDLINEARGS_LONG_SETTINGSMODE=(int32*)mem_static_malloc(4);
 *_FUNC_PARSECMDLINEARGS_LONG_SETTINGSMODE=0;
 }
-static qbs *sc_2202=qbs_new(0,0);
+static qbs *sc_2208=qbs_new(0,0);
 qbs *_FUNC_PARSECMDLINEARGS_STRING_DEBUGINFOINIWARNING=NULL;
 if (!_FUNC_PARSECMDLINEARGS_STRING_DEBUGINFOINIWARNING)_FUNC_PARSECMDLINEARGS_STRING_DEBUGINFOINIWARNING=qbs_new(0,0);
-int32 pass2218;
-int32 pass2220;
+int32 pass2224;
 int32 pass2226;
-static qbs *sc_2227=qbs_new(0,0);
+int32 pass2232;
+static qbs *sc_2233=qbs_new(0,0);
 qbs *_FUNC_PARSECMDLINEARGS_STRING_PASSEDFILENAME=NULL;
 if (!_FUNC_PARSECMDLINEARGS_STRING_PASSEDFILENAME)_FUNC_PARSECMDLINEARGS_STRING_PASSEDFILENAME=qbs_new(0,0);
-byte_element_struct *byte_element_2228=NULL;
-if (!byte_element_2228){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2228=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2228=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_2234=NULL;
+if (!byte_element_2234){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2234=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2234=(byte_element_struct*)mem_static_malloc(12);
 }
--- a/internal/source/data10.txt
+++ b/internal/source/data10.txt
@ -1,22 +1,22 @@
-qbs*oldstr2347=NULL;
+qbs*oldstr2353=NULL;
 if(_SUB_ASSIGN_STRING_A->tmp||_SUB_ASSIGN_STRING_A->fixed||_SUB_ASSIGN_STRING_A->readonly){
-oldstr2347=_SUB_ASSIGN_STRING_A;
-if (oldstr2347->cmem_descriptor){
-_SUB_ASSIGN_STRING_A=qbs_new_cmem(oldstr2347->len,0);
+oldstr2353=_SUB_ASSIGN_STRING_A;
+if (oldstr2353->cmem_descriptor){
+_SUB_ASSIGN_STRING_A=qbs_new_cmem(oldstr2353->len,0);
 }else{
-_SUB_ASSIGN_STRING_A=qbs_new(oldstr2347->len,0);
+_SUB_ASSIGN_STRING_A=qbs_new(oldstr2353->len,0);
 }
-memcpy(_SUB_ASSIGN_STRING_A->chr,oldstr2347->chr,oldstr2347->len);
+memcpy(_SUB_ASSIGN_STRING_A->chr,oldstr2353->chr,oldstr2353->len);
 }
 int32 *_SUB_ASSIGN_LONG_I=NULL;
 if(_SUB_ASSIGN_LONG_I==NULL){
 _SUB_ASSIGN_LONG_I=(int32*)mem_static_malloc(4);
 *_SUB_ASSIGN_LONG_I=0;
 }
-int64 fornext_value2349;
-int64 fornext_finalvalue2349;
-int64 fornext_step2349;
-uint8 fornext_step_negative2349;
+int64 fornext_value2355;
+int64 fornext_finalvalue2355;
+int64 fornext_step2355;
+uint8 fornext_step_negative2355;
 int32 *_SUB_ASSIGN_LONG_C=NULL;
 if(_SUB_ASSIGN_LONG_C==NULL){
 _SUB_ASSIGN_LONG_C=(int32*)mem_static_malloc(4);
@ -29,8 +29,8 @@ _SUB_ASSIGN_LONG_B=(int32*)mem_static_malloc(4);
 }
 qbs *_SUB_ASSIGN_STRING_A2=NULL;
 if (!_SUB_ASSIGN_STRING_A2)_SUB_ASSIGN_STRING_A2=qbs_new(0,0);
-int32 pass2350;
-int32 pass2351;
+int32 pass2356;
+int32 pass2357;
 qbs *_SUB_ASSIGN_STRING_L=NULL;
 if (!_SUB_ASSIGN_STRING_L)_SUB_ASSIGN_STRING_L=qbs_new(0,0);
 int32 *_SUB_ASSIGN_LONG_TRY=NULL;
@ -43,5 +43,5 @@ if(_SUB_ASSIGN_LONG_TYP==NULL){
 _SUB_ASSIGN_LONG_TYP=(int32*)mem_static_malloc(4);
 *_SUB_ASSIGN_LONG_TYP=0;
 }
-int32 pass2353;
-int32 pass2354;
+int32 pass2359;
+int32 pass2360;
--- a/internal/source/data100.txt
+++ b/internal/source/data100.txt
@ -1,13 +1,13 @@
 qbs *_FUNC_GETELEMENTSBEFORE_STRING_GETELEMENTSBEFORE=NULL;
 if (!_FUNC_GETELEMENTSBEFORE_STRING_GETELEMENTSBEFORE)_FUNC_GETELEMENTSBEFORE_STRING_GETELEMENTSBEFORE=qbs_new(0,0);
-qbs*oldstr3667=NULL;
+qbs*oldstr3674=NULL;
 if(_FUNC_GETELEMENTSBEFORE_STRING_A->tmp||_FUNC_GETELEMENTSBEFORE_STRING_A->fixed||_FUNC_GETELEMENTSBEFORE_STRING_A->readonly){
-oldstr3667=_FUNC_GETELEMENTSBEFORE_STRING_A;
-if (oldstr3667->cmem_descriptor){
-_FUNC_GETELEMENTSBEFORE_STRING_A=qbs_new_cmem(oldstr3667->len,0);
+oldstr3674=_FUNC_GETELEMENTSBEFORE_STRING_A;
+if (oldstr3674->cmem_descriptor){
+_FUNC_GETELEMENTSBEFORE_STRING_A=qbs_new_cmem(oldstr3674->len,0);
 }else{
-_FUNC_GETELEMENTSBEFORE_STRING_A=qbs_new(oldstr3667->len,0);
+_FUNC_GETELEMENTSBEFORE_STRING_A=qbs_new(oldstr3674->len,0);
 }
-memcpy(_FUNC_GETELEMENTSBEFORE_STRING_A->chr,oldstr3667->chr,oldstr3667->len);
+memcpy(_FUNC_GETELEMENTSBEFORE_STRING_A->chr,oldstr3674->chr,oldstr3674->len);
 }
-int32 pass3668;
+int32 pass3675;
--- a/internal/source/data101.txt
+++ b/internal/source/data101.txt
@ -1,14 +1,14 @@
 qbs *_FUNC_GETELEMENTSAFTER_STRING_GETELEMENTSAFTER=NULL;
 if (!_FUNC_GETELEMENTSAFTER_STRING_GETELEMENTSAFTER)_FUNC_GETELEMENTSAFTER_STRING_GETELEMENTSAFTER=qbs_new(0,0);
-qbs*oldstr3669=NULL;
+qbs*oldstr3676=NULL;
 if(_FUNC_GETELEMENTSAFTER_STRING_A->tmp||_FUNC_GETELEMENTSAFTER_STRING_A->fixed||_FUNC_GETELEMENTSAFTER_STRING_A->readonly){
-oldstr3669=_FUNC_GETELEMENTSAFTER_STRING_A;
-if (oldstr3669->cmem_descriptor){
-_FUNC_GETELEMENTSAFTER_STRING_A=qbs_new_cmem(oldstr3669->len,0);
+oldstr3676=_FUNC_GETELEMENTSAFTER_STRING_A;
+if (oldstr3676->cmem_descriptor){
+_FUNC_GETELEMENTSAFTER_STRING_A=qbs_new_cmem(oldstr3676->len,0);
 }else{
-_FUNC_GETELEMENTSAFTER_STRING_A=qbs_new(oldstr3669->len,0);
+_FUNC_GETELEMENTSAFTER_STRING_A=qbs_new(oldstr3676->len,0);
 }
-memcpy(_FUNC_GETELEMENTSAFTER_STRING_A->chr,oldstr3669->chr,oldstr3669->len);
+memcpy(_FUNC_GETELEMENTSAFTER_STRING_A->chr,oldstr3676->chr,oldstr3676->len);
 }
 int32 *_FUNC_GETELEMENTSAFTER_LONG_P=NULL;
 if(_FUNC_GETELEMENTSAFTER_LONG_P==NULL){
@ -25,7 +25,7 @@ if(_FUNC_GETELEMENTSAFTER_LONG_I==NULL){
 _FUNC_GETELEMENTSAFTER_LONG_I=(int32*)mem_static_malloc(4);
 *_FUNC_GETELEMENTSAFTER_LONG_I=0;
 }
-byte_element_struct *byte_element_3670=NULL;
-if (!byte_element_3670){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3670=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3670=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3677=NULL;
+if (!byte_element_3677){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3677=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3677=(byte_element_struct*)mem_static_malloc(12);
 }
--- a/internal/source/data102.txt
+++ b/internal/source/data102.txt
@ -1,22 +1,22 @@
-qbs*oldstr3671=NULL;
+qbs*oldstr3678=NULL;
 if(_SUB_INSERTELEMENTS_STRING_A->tmp||_SUB_INSERTELEMENTS_STRING_A->fixed||_SUB_INSERTELEMENTS_STRING_A->readonly){
-oldstr3671=_SUB_INSERTELEMENTS_STRING_A;
-if (oldstr3671->cmem_descriptor){
-_SUB_INSERTELEMENTS_STRING_A=qbs_new_cmem(oldstr3671->len,0);
+oldstr3678=_SUB_INSERTELEMENTS_STRING_A;
+if (oldstr3678->cmem_descriptor){
+_SUB_INSERTELEMENTS_STRING_A=qbs_new_cmem(oldstr3678->len,0);
 }else{
-_SUB_INSERTELEMENTS_STRING_A=qbs_new(oldstr3671->len,0);
+_SUB_INSERTELEMENTS_STRING_A=qbs_new(oldstr3678->len,0);
 }
-memcpy(_SUB_INSERTELEMENTS_STRING_A->chr,oldstr3671->chr,oldstr3671->len);
+memcpy(_SUB_INSERTELEMENTS_STRING_A->chr,oldstr3678->chr,oldstr3678->len);
 }
-qbs*oldstr3672=NULL;
+qbs*oldstr3679=NULL;
 if(_SUB_INSERTELEMENTS_STRING_ELEMENTS->tmp||_SUB_INSERTELEMENTS_STRING_ELEMENTS->fixed||_SUB_INSERTELEMENTS_STRING_ELEMENTS->readonly){
-oldstr3672=_SUB_INSERTELEMENTS_STRING_ELEMENTS;
-if (oldstr3672->cmem_descriptor){
-_SUB_INSERTELEMENTS_STRING_ELEMENTS=qbs_new_cmem(oldstr3672->len,0);
+oldstr3679=_SUB_INSERTELEMENTS_STRING_ELEMENTS;
+if (oldstr3679->cmem_descriptor){
+_SUB_INSERTELEMENTS_STRING_ELEMENTS=qbs_new_cmem(oldstr3679->len,0);
 }else{
-_SUB_INSERTELEMENTS_STRING_ELEMENTS=qbs_new(oldstr3672->len,0);
+_SUB_INSERTELEMENTS_STRING_ELEMENTS=qbs_new(oldstr3679->len,0);
 }
-memcpy(_SUB_INSERTELEMENTS_STRING_ELEMENTS->chr,oldstr3672->chr,oldstr3672->len);
+memcpy(_SUB_INSERTELEMENTS_STRING_ELEMENTS->chr,oldstr3679->chr,oldstr3679->len);
 }
 qbs *_SUB_INSERTELEMENTS_STRING_A2=NULL;
 if (!_SUB_INSERTELEMENTS_STRING_A2)_SUB_INSERTELEMENTS_STRING_A2=qbs_new(0,0);
@ -30,7 +30,7 @@ if(_SUB_INSERTELEMENTS_LONG_I2==NULL){
 _SUB_INSERTELEMENTS_LONG_I2=(int32*)mem_static_malloc(4);
 *_SUB_INSERTELEMENTS_LONG_I2=0;
 }
-int64 fornext_value3674;
-int64 fornext_finalvalue3674;
-int64 fornext_step3674;
-uint8 fornext_step_negative3674;
+int64 fornext_value3681;
+int64 fornext_finalvalue3681;
+int64 fornext_step3681;
+uint8 fornext_step_negative3681;
--- a/internal/source/data103.txt
+++ b/internal/source/data103.txt
@ -3,15 +3,15 @@ if(_FUNC_NUMELEMENTS_LONG_NUMELEMENTS==NULL){
 _FUNC_NUMELEMENTS_LONG_NUMELEMENTS=(int32*)mem_static_malloc(4);
 *_FUNC_NUMELEMENTS_LONG_NUMELEMENTS=0;
 }
-qbs*oldstr3675=NULL;
+qbs*oldstr3682=NULL;
 if(_FUNC_NUMELEMENTS_STRING_A->tmp||_FUNC_NUMELEMENTS_STRING_A->fixed||_FUNC_NUMELEMENTS_STRING_A->readonly){
-oldstr3675=_FUNC_NUMELEMENTS_STRING_A;
-if (oldstr3675->cmem_descriptor){
-_FUNC_NUMELEMENTS_STRING_A=qbs_new_cmem(oldstr3675->len,0);
+oldstr3682=_FUNC_NUMELEMENTS_STRING_A;
+if (oldstr3682->cmem_descriptor){
+_FUNC_NUMELEMENTS_STRING_A=qbs_new_cmem(oldstr3682->len,0);
 }else{
-_FUNC_NUMELEMENTS_STRING_A=qbs_new(oldstr3675->len,0);
+_FUNC_NUMELEMENTS_STRING_A=qbs_new(oldstr3682->len,0);
 }
-memcpy(_FUNC_NUMELEMENTS_STRING_A->chr,oldstr3675->chr,oldstr3675->len);
+memcpy(_FUNC_NUMELEMENTS_STRING_A->chr,oldstr3682->chr,oldstr3682->len);
 }
 int32 *_FUNC_NUMELEMENTS_LONG_P=NULL;
 if(_FUNC_NUMELEMENTS_LONG_P==NULL){
--- a/internal/source/data104.txt
+++ b/internal/source/data104.txt
@ -1,12 +1,12 @@
-qbs*oldstr3676=NULL;
+qbs*oldstr3683=NULL;
 if(_SUB_REMOVEELEMENTS_STRING_A->tmp||_SUB_REMOVEELEMENTS_STRING_A->fixed||_SUB_REMOVEELEMENTS_STRING_A->readonly){
-oldstr3676=_SUB_REMOVEELEMENTS_STRING_A;
-if (oldstr3676->cmem_descriptor){
-_SUB_REMOVEELEMENTS_STRING_A=qbs_new_cmem(oldstr3676->len,0);
+oldstr3683=_SUB_REMOVEELEMENTS_STRING_A;
+if (oldstr3683->cmem_descriptor){
+_SUB_REMOVEELEMENTS_STRING_A=qbs_new_cmem(oldstr3683->len,0);
 }else{
-_SUB_REMOVEELEMENTS_STRING_A=qbs_new(oldstr3676->len,0);
+_SUB_REMOVEELEMENTS_STRING_A=qbs_new(oldstr3683->len,0);
 }
-memcpy(_SUB_REMOVEELEMENTS_STRING_A->chr,oldstr3676->chr,oldstr3676->len);
+memcpy(_SUB_REMOVEELEMENTS_STRING_A->chr,oldstr3683->chr,oldstr3683->len);
 }
 int32 *_SUB_REMOVEELEMENTS_LONG_N=NULL;
 if(_SUB_REMOVEELEMENTS_LONG_N==NULL){
@ -20,11 +20,11 @@ _SUB_REMOVEELEMENTS_LONG_I=(int32*)mem_static_malloc(4);
 }
 qbs *_SUB_REMOVEELEMENTS_STRING_A2=NULL;
 if (!_SUB_REMOVEELEMENTS_STRING_A2)_SUB_REMOVEELEMENTS_STRING_A2=qbs_new(0,0);
-int64 fornext_value3678;
-int64 fornext_finalvalue3678;
-int64 fornext_step3678;
-uint8 fornext_step_negative3678;
-byte_element_struct *byte_element_3679=NULL;
-if (!byte_element_3679){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3679=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3679=(byte_element_struct*)mem_static_malloc(12);
+int64 fornext_value3685;
+int64 fornext_finalvalue3685;
+int64 fornext_step3685;
+uint8 fornext_step_negative3685;
+byte_element_struct *byte_element_3686=NULL;
+if (!byte_element_3686){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3686=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3686=(byte_element_struct*)mem_static_malloc(12);
 }
--- a/internal/source/data105.txt
+++ b/internal/source/data105.txt
@ -1,11 +1,11 @@
-qbs*oldstr3680=NULL;
+qbs*oldstr3687=NULL;
 if(_SUB_REMOVEELEMENT_STRING_A->tmp||_SUB_REMOVEELEMENT_STRING_A->fixed||_SUB_REMOVEELEMENT_STRING_A->readonly){
-oldstr3680=_SUB_REMOVEELEMENT_STRING_A;
-if (oldstr3680->cmem_descriptor){
-_SUB_REMOVEELEMENT_STRING_A=qbs_new_cmem(oldstr3680->len,0);
+oldstr3687=_SUB_REMOVEELEMENT_STRING_A;
+if (oldstr3687->cmem_descriptor){
+_SUB_REMOVEELEMENT_STRING_A=qbs_new_cmem(oldstr3687->len,0);
 }else{
-_SUB_REMOVEELEMENT_STRING_A=qbs_new(oldstr3680->len,0);
+_SUB_REMOVEELEMENT_STRING_A=qbs_new(oldstr3687->len,0);
 }
-memcpy(_SUB_REMOVEELEMENT_STRING_A->chr,oldstr3680->chr,oldstr3680->len);
+memcpy(_SUB_REMOVEELEMENT_STRING_A->chr,oldstr3687->chr,oldstr3687->len);
 }
-int32 pass3681;
+int32 pass3688;
--- a/internal/source/data106.txt
+++ b/internal/source/data106.txt
@ -3,15 +3,15 @@ if(_FUNC_COUNTFUNCTIONELEMENTS_LONG_COUNTFUNCTIONELEMENTS==NULL){
 _FUNC_COUNTFUNCTIONELEMENTS_LONG_COUNTFUNCTIONELEMENTS=(int32*)mem_static_malloc(4);
 *_FUNC_COUNTFUNCTIONELEMENTS_LONG_COUNTFUNCTIONELEMENTS=0;
 }
-qbs*oldstr3682=NULL;
+qbs*oldstr3689=NULL;
 if(_FUNC_COUNTFUNCTIONELEMENTS_STRING_A->tmp||_FUNC_COUNTFUNCTIONELEMENTS_STRING_A->fixed||_FUNC_COUNTFUNCTIONELEMENTS_STRING_A->readonly){
-oldstr3682=_FUNC_COUNTFUNCTIONELEMENTS_STRING_A;
-if (oldstr3682->cmem_descriptor){
-_FUNC_COUNTFUNCTIONELEMENTS_STRING_A=qbs_new_cmem(oldstr3682->len,0);
+oldstr3689=_FUNC_COUNTFUNCTIONELEMENTS_STRING_A;
+if (oldstr3689->cmem_descriptor){
+_FUNC_COUNTFUNCTIONELEMENTS_STRING_A=qbs_new_cmem(oldstr3689->len,0);
 }else{
-_FUNC_COUNTFUNCTIONELEMENTS_STRING_A=qbs_new(oldstr3682->len,0);
+_FUNC_COUNTFUNCTIONELEMENTS_STRING_A=qbs_new(oldstr3689->len,0);
 }
-memcpy(_FUNC_COUNTFUNCTIONELEMENTS_STRING_A->chr,oldstr3682->chr,oldstr3682->len);
+memcpy(_FUNC_COUNTFUNCTIONELEMENTS_STRING_A->chr,oldstr3689->chr,oldstr3689->len);
 }
 int32 *_FUNC_COUNTFUNCTIONELEMENTS_LONG_COUNT=NULL;
 if(_FUNC_COUNTFUNCTIONELEMENTS_LONG_COUNT==NULL){
@ -33,8 +33,8 @@ if(_FUNC_COUNTFUNCTIONELEMENTS_LONG_I==NULL){
 _FUNC_COUNTFUNCTIONELEMENTS_LONG_I=(int32*)mem_static_malloc(4);
 *_FUNC_COUNTFUNCTIONELEMENTS_LONG_I=0;
 }
-byte_element_struct *byte_element_3683=NULL;
-if (!byte_element_3683){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3683=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3683=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3690=NULL;
+if (!byte_element_3690){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3690=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3690=(byte_element_struct*)mem_static_malloc(12);
 }
-static int32 sc_3685;
+static int32 sc_3692;
--- a/internal/source/data107.txt
+++ b/internal/source/data107.txt
@ -3,15 +3,15 @@ if(_FUNC_HASFUNCTIONELEMENT_LONG_HASFUNCTIONELEMENT==NULL){
 _FUNC_HASFUNCTIONELEMENT_LONG_HASFUNCTIONELEMENT=(int32*)mem_static_malloc(4);
 *_FUNC_HASFUNCTIONELEMENT_LONG_HASFUNCTIONELEMENT=0;
 }
-qbs*oldstr3686=NULL;
+qbs*oldstr3693=NULL;
 if(_FUNC_HASFUNCTIONELEMENT_STRING_A->tmp||_FUNC_HASFUNCTIONELEMENT_STRING_A->fixed||_FUNC_HASFUNCTIONELEMENT_STRING_A->readonly){
-oldstr3686=_FUNC_HASFUNCTIONELEMENT_STRING_A;
-if (oldstr3686->cmem_descriptor){
-_FUNC_HASFUNCTIONELEMENT_STRING_A=qbs_new_cmem(oldstr3686->len,0);
+oldstr3693=_FUNC_HASFUNCTIONELEMENT_STRING_A;
+if (oldstr3693->cmem_descriptor){
+_FUNC_HASFUNCTIONELEMENT_STRING_A=qbs_new_cmem(oldstr3693->len,0);
 }else{
-_FUNC_HASFUNCTIONELEMENT_STRING_A=qbs_new(oldstr3686->len,0);
+_FUNC_HASFUNCTIONELEMENT_STRING_A=qbs_new(oldstr3693->len,0);
 }
-memcpy(_FUNC_HASFUNCTIONELEMENT_STRING_A->chr,oldstr3686->chr,oldstr3686->len);
+memcpy(_FUNC_HASFUNCTIONELEMENT_STRING_A->chr,oldstr3693->chr,oldstr3693->len);
 }
 int32 *_FUNC_HASFUNCTIONELEMENT_LONG_COUNT=NULL;
 if(_FUNC_HASFUNCTIONELEMENT_LONG_COUNT==NULL){
@ -38,16 +38,16 @@ if(_FUNC_HASFUNCTIONELEMENT_LONG_START==NULL){
 _FUNC_HASFUNCTIONELEMENT_LONG_START=(int32*)mem_static_malloc(4);
 *_FUNC_HASFUNCTIONELEMENT_LONG_START=0;
 }
-byte_element_struct *byte_element_3687=NULL;
-if (!byte_element_3687){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3687=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3687=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3694=NULL;
+if (!byte_element_3694){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3694=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3694=(byte_element_struct*)mem_static_malloc(12);
 }
-byte_element_struct *byte_element_3688=NULL;
-if (!byte_element_3688){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3688=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3688=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3695=NULL;
+if (!byte_element_3695){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3695=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3695=(byte_element_struct*)mem_static_malloc(12);
 }
-byte_element_struct *byte_element_3690=NULL;
-if (!byte_element_3690){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3690=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3690=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3697=NULL;
+if (!byte_element_3697){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3697=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3697=(byte_element_struct*)mem_static_malloc(12);
 }
-static int32 sc_3691;
+static int32 sc_3698;
--- a/internal/source/data108.txt
+++ b/internal/source/data108.txt
@ -3,15 +3,15 @@ if(_FUNC_ISVALIDARGSET_LONG_ISVALIDARGSET==NULL){
 _FUNC_ISVALIDARGSET_LONG_ISVALIDARGSET=(int32*)mem_static_malloc(4);
 *_FUNC_ISVALIDARGSET_LONG_ISVALIDARGSET=0;
 }
-qbs*oldstr3692=NULL;
+qbs*oldstr3699=NULL;
 if(_FUNC_ISVALIDARGSET_STRING_FORMAT->tmp||_FUNC_ISVALIDARGSET_STRING_FORMAT->fixed||_FUNC_ISVALIDARGSET_STRING_FORMAT->readonly){
-oldstr3692=_FUNC_ISVALIDARGSET_STRING_FORMAT;
-if (oldstr3692->cmem_descriptor){
-_FUNC_ISVALIDARGSET_STRING_FORMAT=qbs_new_cmem(oldstr3692->len,0);
+oldstr3699=_FUNC_ISVALIDARGSET_STRING_FORMAT;
+if (oldstr3699->cmem_descriptor){
+_FUNC_ISVALIDARGSET_STRING_FORMAT=qbs_new_cmem(oldstr3699->len,0);
 }else{
-_FUNC_ISVALIDARGSET_STRING_FORMAT=qbs_new(oldstr3692->len,0);
+_FUNC_ISVALIDARGSET_STRING_FORMAT=qbs_new(oldstr3699->len,0);
 }
-memcpy(_FUNC_ISVALIDARGSET_STRING_FORMAT->chr,oldstr3692->chr,oldstr3692->len);
+memcpy(_FUNC_ISVALIDARGSET_STRING_FORMAT->chr,oldstr3699->chr,oldstr3699->len);
 }
 int32 *_FUNC_ISVALIDARGSET_LONG_MAXARGUMENT=NULL;
 if(_FUNC_ISVALIDARGSET_LONG_MAXARGUMENT==NULL){
@ -60,12 +60,12 @@ if(_FUNC_ISVALIDARGSET_LONG_ARGIGNORED==NULL){
 _FUNC_ISVALIDARGSET_LONG_ARGIGNORED=(int32*)mem_static_malloc(4);
 *_FUNC_ISVALIDARGSET_LONG_ARGIGNORED=0;
 }
-int64 fornext_value3694;
-int64 fornext_finalvalue3694;
-int64 fornext_step3694;
-uint8 fornext_step_negative3694;
-byte_element_struct *byte_element_3695=NULL;
-if (!byte_element_3695){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3695=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3695=(byte_element_struct*)mem_static_malloc(12);
+int64 fornext_value3701;
+int64 fornext_finalvalue3701;
+int64 fornext_step3701;
+uint8 fornext_step_negative3701;
+byte_element_struct *byte_element_3702=NULL;
+if (!byte_element_3702){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3702=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3702=(byte_element_struct*)mem_static_malloc(12);
 }
-static int32 sc_3696;
+static int32 sc_3703;
--- a/internal/source/data109.txt
+++ b/internal/source/data109.txt
@ -1,14 +1,14 @@
 qbs *_FUNC_ELEUCASE_STRING_ELEUCASE=NULL;
 if (!_FUNC_ELEUCASE_STRING_ELEUCASE)_FUNC_ELEUCASE_STRING_ELEUCASE=qbs_new(0,0);
-qbs*oldstr3697=NULL;
+qbs*oldstr3704=NULL;
 if(_FUNC_ELEUCASE_STRING_A->tmp||_FUNC_ELEUCASE_STRING_A->fixed||_FUNC_ELEUCASE_STRING_A->readonly){
-oldstr3697=_FUNC_ELEUCASE_STRING_A;
-if (oldstr3697->cmem_descriptor){
-_FUNC_ELEUCASE_STRING_A=qbs_new_cmem(oldstr3697->len,0);
+oldstr3704=_FUNC_ELEUCASE_STRING_A;
+if (oldstr3704->cmem_descriptor){
+_FUNC_ELEUCASE_STRING_A=qbs_new_cmem(oldstr3704->len,0);
 }else{
-_FUNC_ELEUCASE_STRING_A=qbs_new(oldstr3697->len,0);
+_FUNC_ELEUCASE_STRING_A=qbs_new(oldstr3704->len,0);
 }
-memcpy(_FUNC_ELEUCASE_STRING_A->chr,oldstr3697->chr,oldstr3697->len);
+memcpy(_FUNC_ELEUCASE_STRING_A->chr,oldstr3704->chr,oldstr3704->len);
 }
 int32 *_FUNC_ELEUCASE_LONG_I=NULL;
 if(_FUNC_ELEUCASE_LONG_I==NULL){
@ -29,23 +29,23 @@ if(_FUNC_ELEUCASE_LONG_I3==NULL){
 _FUNC_ELEUCASE_LONG_I3=(int32*)mem_static_malloc(4);
 *_FUNC_ELEUCASE_LONG_I3=0;
 }
-byte_element_struct *byte_element_3698=NULL;
-if (!byte_element_3698){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3698=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3698=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3705=NULL;
+if (!byte_element_3705){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3705=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3705=(byte_element_struct*)mem_static_malloc(12);
 }
-byte_element_struct *byte_element_3699=NULL;
-if (!byte_element_3699){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3699=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3699=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3706=NULL;
+if (!byte_element_3706){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3706=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3706=(byte_element_struct*)mem_static_malloc(12);
 }
-byte_element_struct *byte_element_3701=NULL;
-if (!byte_element_3701){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3701=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3701=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3708=NULL;
+if (!byte_element_3708){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3708=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3708=(byte_element_struct*)mem_static_malloc(12);
 }
-byte_element_struct *byte_element_3702=NULL;
-if (!byte_element_3702){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3702=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3702=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3709=NULL;
+if (!byte_element_3709){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3709=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3709=(byte_element_struct*)mem_static_malloc(12);
 }
-byte_element_struct *byte_element_3703=NULL;
-if (!byte_element_3703){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3703=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3703=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3710=NULL;
+if (!byte_element_3710){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3710=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3710=(byte_element_struct*)mem_static_malloc(12);
 }
--- a/internal/source/data110.txt
+++ b/internal/source/data110.txt
@ -3,15 +3,15 @@ if(_FUNC_ELEMENTGETNUMERICVALUE_LONG_ELEMENTGETNUMERICVALUE==NULL){
 _FUNC_ELEMENTGETNUMERICVALUE_LONG_ELEMENTGETNUMERICVALUE=(int32*)mem_static_malloc(4);
 *_FUNC_ELEMENTGETNUMERICVALUE_LONG_ELEMENTGETNUMERICVALUE=0;
 }
-qbs*oldstr3704=NULL;
+qbs*oldstr3711=NULL;
 if(_FUNC_ELEMENTGETNUMERICVALUE_STRING_ELE->tmp||_FUNC_ELEMENTGETNUMERICVALUE_STRING_ELE->fixed||_FUNC_ELEMENTGETNUMERICVALUE_STRING_ELE->readonly){
-oldstr3704=_FUNC_ELEMENTGETNUMERICVALUE_STRING_ELE;
-if (oldstr3704->cmem_descriptor){
-_FUNC_ELEMENTGETNUMERICVALUE_STRING_ELE=qbs_new_cmem(oldstr3704->len,0);
+oldstr3711=_FUNC_ELEMENTGETNUMERICVALUE_STRING_ELE;
+if (oldstr3711->cmem_descriptor){
+_FUNC_ELEMENTGETNUMERICVALUE_STRING_ELE=qbs_new_cmem(oldstr3711->len,0);
 }else{
-_FUNC_ELEMENTGETNUMERICVALUE_STRING_ELE=qbs_new(oldstr3704->len,0);
+_FUNC_ELEMENTGETNUMERICVALUE_STRING_ELE=qbs_new(oldstr3711->len,0);
 }
-memcpy(_FUNC_ELEMENTGETNUMERICVALUE_STRING_ELE->chr,oldstr3704->chr,oldstr3704->len);
+memcpy(_FUNC_ELEMENTGETNUMERICVALUE_STRING_ELE->chr,oldstr3711->chr,oldstr3711->len);
 }
 qbs *_FUNC_ELEMENTGETNUMERICVALUE_STRING_NUM=NULL;
 if (!_FUNC_ELEMENTGETNUMERICVALUE_STRING_NUM)_FUNC_ELEMENTGETNUMERICVALUE_STRING_NUM=qbs_new(0,0);
@ -27,19 +27,19 @@ if(_FUNC_ELEMENTGETNUMERICVALUE_LONG_X==NULL){
 _FUNC_ELEMENTGETNUMERICVALUE_LONG_X=(int32*)mem_static_malloc(4);
 *_FUNC_ELEMENTGETNUMERICVALUE_LONG_X=0;
 }
-byte_element_struct *byte_element_3705=NULL;
-if (!byte_element_3705){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3705=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3705=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3712=NULL;
+if (!byte_element_3712){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3712=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3712=(byte_element_struct*)mem_static_malloc(12);
 }
-byte_element_struct *byte_element_3706=NULL;
-if (!byte_element_3706){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3706=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3706=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3713=NULL;
+if (!byte_element_3713){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3713=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3713=(byte_element_struct*)mem_static_malloc(12);
 }
-byte_element_struct *byte_element_3707=NULL;
-if (!byte_element_3707){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3707=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3707=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3714=NULL;
+if (!byte_element_3714){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3714=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3714=(byte_element_struct*)mem_static_malloc(12);
 }
-byte_element_struct *byte_element_3708=NULL;
-if (!byte_element_3708){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3708=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3708=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3715=NULL;
+if (!byte_element_3715){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3715=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3715=(byte_element_struct*)mem_static_malloc(12);
 }
--- a/internal/source/data111.txt
+++ b/internal/source/data111.txt
@ -3,15 +3,15 @@ if(_FUNC_ELEMENTISNUMBER_LONG_ELEMENTISNUMBER==NULL){
 _FUNC_ELEMENTISNUMBER_LONG_ELEMENTISNUMBER=(int32*)mem_static_malloc(4);
 *_FUNC_ELEMENTISNUMBER_LONG_ELEMENTISNUMBER=0;
 }
-qbs*oldstr3709=NULL;
+qbs*oldstr3716=NULL;
 if(_FUNC_ELEMENTISNUMBER_STRING_OELE->tmp||_FUNC_ELEMENTISNUMBER_STRING_OELE->fixed||_FUNC_ELEMENTISNUMBER_STRING_OELE->readonly){
-oldstr3709=_FUNC_ELEMENTISNUMBER_STRING_OELE;
-if (oldstr3709->cmem_descriptor){
-_FUNC_ELEMENTISNUMBER_STRING_OELE=qbs_new_cmem(oldstr3709->len,0);
+oldstr3716=_FUNC_ELEMENTISNUMBER_STRING_OELE;
+if (oldstr3716->cmem_descriptor){
+_FUNC_ELEMENTISNUMBER_STRING_OELE=qbs_new_cmem(oldstr3716->len,0);
 }else{
-_FUNC_ELEMENTISNUMBER_STRING_OELE=qbs_new(oldstr3709->len,0);
+_FUNC_ELEMENTISNUMBER_STRING_OELE=qbs_new(oldstr3716->len,0);
 }
-memcpy(_FUNC_ELEMENTISNUMBER_STRING_OELE->chr,oldstr3709->chr,oldstr3709->len);
+memcpy(_FUNC_ELEMENTISNUMBER_STRING_OELE->chr,oldstr3716->chr,oldstr3716->len);
 }
 qbs *_FUNC_ELEMENTISNUMBER_STRING_ELE=NULL;
 if (!_FUNC_ELEMENTISNUMBER_STRING_ELE)_FUNC_ELEMENTISNUMBER_STRING_ELE=qbs_new(0,0);
@ -20,7 +20,7 @@ if(_FUNC_ELEMENTISNUMBER_LONG_RES==NULL){
 _FUNC_ELEMENTISNUMBER_LONG_RES=(int32*)mem_static_malloc(4);
 *_FUNC_ELEMENTISNUMBER_LONG_RES=0;
 }
-byte_element_struct *byte_element_3710=NULL;
-if (!byte_element_3710){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3710=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3710=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3717=NULL;
+if (!byte_element_3717){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3717=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3717=(byte_element_struct*)mem_static_malloc(12);
 }
--- a/internal/source/data112.txt
+++ b/internal/source/data112.txt
@ -3,13 +3,13 @@ if(_FUNC_ELEMENTISSTRING_LONG_ELEMENTISSTRING==NULL){
 _FUNC_ELEMENTISSTRING_LONG_ELEMENTISSTRING=(int32*)mem_static_malloc(4);
 *_FUNC_ELEMENTISSTRING_LONG_ELEMENTISSTRING=0;
 }
-qbs*oldstr3711=NULL;
+qbs*oldstr3718=NULL;
 if(_FUNC_ELEMENTISSTRING_STRING_ELE->tmp||_FUNC_ELEMENTISSTRING_STRING_ELE->fixed||_FUNC_ELEMENTISSTRING_STRING_ELE->readonly){
-oldstr3711=_FUNC_ELEMENTISSTRING_STRING_ELE;
-if (oldstr3711->cmem_descriptor){
-_FUNC_ELEMENTISSTRING_STRING_ELE=qbs_new_cmem(oldstr3711->len,0);
+oldstr3718=_FUNC_ELEMENTISSTRING_STRING_ELE;
+if (oldstr3718->cmem_descriptor){
+_FUNC_ELEMENTISSTRING_STRING_ELE=qbs_new_cmem(oldstr3718->len,0);
 }else{
-_FUNC_ELEMENTISSTRING_STRING_ELE=qbs_new(oldstr3711->len,0);
+_FUNC_ELEMENTISSTRING_STRING_ELE=qbs_new(oldstr3718->len,0);
 }
-memcpy(_FUNC_ELEMENTISSTRING_STRING_ELE->chr,oldstr3711->chr,oldstr3711->len);
+memcpy(_FUNC_ELEMENTISSTRING_STRING_ELE->chr,oldstr3718->chr,oldstr3718->len);
 }
--- a/internal/source/data113.txt
+++ b/internal/source/data113.txt
@ -3,25 +3,25 @@ if(_FUNC_ELEMENTGETSTRINGVALUE_LONG_ELEMENTGETSTRINGVALUE==NULL){
 _FUNC_ELEMENTGETSTRINGVALUE_LONG_ELEMENTGETSTRINGVALUE=(int32*)mem_static_malloc(4);
 *_FUNC_ELEMENTGETSTRINGVALUE_LONG_ELEMENTGETSTRINGVALUE=0;
 }
-qbs*oldstr3712=NULL;
+qbs*oldstr3719=NULL;
 if(_FUNC_ELEMENTGETSTRINGVALUE_STRING_ELE->tmp||_FUNC_ELEMENTGETSTRINGVALUE_STRING_ELE->fixed||_FUNC_ELEMENTGETSTRINGVALUE_STRING_ELE->readonly){
-oldstr3712=_FUNC_ELEMENTGETSTRINGVALUE_STRING_ELE;
-if (oldstr3712->cmem_descriptor){
-_FUNC_ELEMENTGETSTRINGVALUE_STRING_ELE=qbs_new_cmem(oldstr3712->len,0);
+oldstr3719=_FUNC_ELEMENTGETSTRINGVALUE_STRING_ELE;
+if (oldstr3719->cmem_descriptor){
+_FUNC_ELEMENTGETSTRINGVALUE_STRING_ELE=qbs_new_cmem(oldstr3719->len,0);
 }else{
-_FUNC_ELEMENTGETSTRINGVALUE_STRING_ELE=qbs_new(oldstr3712->len,0);
+_FUNC_ELEMENTGETSTRINGVALUE_STRING_ELE=qbs_new(oldstr3719->len,0);
 }
-memcpy(_FUNC_ELEMENTGETSTRINGVALUE_STRING_ELE->chr,oldstr3712->chr,oldstr3712->len);
+memcpy(_FUNC_ELEMENTGETSTRINGVALUE_STRING_ELE->chr,oldstr3719->chr,oldstr3719->len);
 }
-qbs*oldstr3713=NULL;
+qbs*oldstr3720=NULL;
 if(_FUNC_ELEMENTGETSTRINGVALUE_STRING_VALUE->tmp||_FUNC_ELEMENTGETSTRINGVALUE_STRING_VALUE->fixed||_FUNC_ELEMENTGETSTRINGVALUE_STRING_VALUE->readonly){
-oldstr3713=_FUNC_ELEMENTGETSTRINGVALUE_STRING_VALUE;
-if (oldstr3713->cmem_descriptor){
-_FUNC_ELEMENTGETSTRINGVALUE_STRING_VALUE=qbs_new_cmem(oldstr3713->len,0);
+oldstr3720=_FUNC_ELEMENTGETSTRINGVALUE_STRING_VALUE;
+if (oldstr3720->cmem_descriptor){
+_FUNC_ELEMENTGETSTRINGVALUE_STRING_VALUE=qbs_new_cmem(oldstr3720->len,0);
 }else{
-_FUNC_ELEMENTGETSTRINGVALUE_STRING_VALUE=qbs_new(oldstr3713->len,0);
+_FUNC_ELEMENTGETSTRINGVALUE_STRING_VALUE=qbs_new(oldstr3720->len,0);
 }
-memcpy(_FUNC_ELEMENTGETSTRINGVALUE_STRING_VALUE->chr,oldstr3713->chr,oldstr3713->len);
+memcpy(_FUNC_ELEMENTGETSTRINGVALUE_STRING_VALUE->chr,oldstr3720->chr,oldstr3720->len);
 }
 qbs *_FUNC_ELEMENTGETSTRINGVALUE_STRING_RAWSTRING=NULL;
 if (!_FUNC_ELEMENTGETSTRINGVALUE_STRING_RAWSTRING)_FUNC_ELEMENTGETSTRINGVALUE_STRING_RAWSTRING=qbs_new(0,0);
--- a/internal/source/data114.txt
+++ b/internal/source/data114.txt
@ -1,14 +1,14 @@
 qbs *_FUNC_CREATEELEMENTSTRING_STRING_CREATEELEMENTSTRING=NULL;
 if (!_FUNC_CREATEELEMENTSTRING_STRING_CREATEELEMENTSTRING)_FUNC_CREATEELEMENTSTRING_STRING_CREATEELEMENTSTRING=qbs_new(0,0);
-qbs*oldstr3715=NULL;
+qbs*oldstr3722=NULL;
 if(_FUNC_CREATEELEMENTSTRING_STRING_S->tmp||_FUNC_CREATEELEMENTSTRING_STRING_S->fixed||_FUNC_CREATEELEMENTSTRING_STRING_S->readonly){
-oldstr3715=_FUNC_CREATEELEMENTSTRING_STRING_S;
-if (oldstr3715->cmem_descriptor){
-_FUNC_CREATEELEMENTSTRING_STRING_S=qbs_new_cmem(oldstr3715->len,0);
+oldstr3722=_FUNC_CREATEELEMENTSTRING_STRING_S;
+if (oldstr3722->cmem_descriptor){
+_FUNC_CREATEELEMENTSTRING_STRING_S=qbs_new_cmem(oldstr3722->len,0);
 }else{
-_FUNC_CREATEELEMENTSTRING_STRING_S=qbs_new(oldstr3715->len,0);
+_FUNC_CREATEELEMENTSTRING_STRING_S=qbs_new(oldstr3722->len,0);
 }
-memcpy(_FUNC_CREATEELEMENTSTRING_STRING_S->chr,oldstr3715->chr,oldstr3715->len);
+memcpy(_FUNC_CREATEELEMENTSTRING_STRING_S->chr,oldstr3722->chr,oldstr3722->len);
 }
 qbs *_FUNC_CREATEELEMENTSTRING_STRING_ELE=NULL;
 if (!_FUNC_CREATEELEMENTSTRING_STRING_ELE)_FUNC_CREATEELEMENTSTRING_STRING_ELE=qbs_new(0,0);
@ -29,23 +29,23 @@ if(_FUNC_CREATEELEMENTSTRING_LONG_I==NULL){
 _FUNC_CREATEELEMENTSTRING_LONG_I=(int32*)mem_static_malloc(4);
 *_FUNC_CREATEELEMENTSTRING_LONG_I=0;
 }
-int64 fornext_value3717;
-int64 fornext_finalvalue3717;
-int64 fornext_step3717;
-uint8 fornext_step_negative3717;
-byte_element_struct *byte_element_3718=NULL;
-if (!byte_element_3718){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3718=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3718=(byte_element_struct*)mem_static_malloc(12);
+int64 fornext_value3724;
+int64 fornext_finalvalue3724;
+int64 fornext_step3724;
+uint8 fornext_step_negative3724;
+byte_element_struct *byte_element_3725=NULL;
+if (!byte_element_3725){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3725=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3725=(byte_element_struct*)mem_static_malloc(12);
 }
-byte_element_struct *byte_element_3719=NULL;
-if (!byte_element_3719){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3719=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3719=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3726=NULL;
+if (!byte_element_3726){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3726=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3726=(byte_element_struct*)mem_static_malloc(12);
 }
-byte_element_struct *byte_element_3720=NULL;
-if (!byte_element_3720){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3720=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3720=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3727=NULL;
+if (!byte_element_3727){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3727=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3727=(byte_element_struct*)mem_static_malloc(12);
 }
-byte_element_struct *byte_element_3721=NULL;
-if (!byte_element_3721){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3721=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3721=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3728=NULL;
+if (!byte_element_3728){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3728=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3728=(byte_element_struct*)mem_static_malloc(12);
 }
--- a/internal/source/data115.txt
+++ b/internal/source/data115.txt
@ -1,24 +1,24 @@
 qbs *_FUNC_ELEMENTSTRINGCONCAT_STRING_ELEMENTSTRINGCONCAT=NULL;
 if (!_FUNC_ELEMENTSTRINGCONCAT_STRING_ELEMENTSTRINGCONCAT)_FUNC_ELEMENTSTRINGCONCAT_STRING_ELEMENTSTRINGCONCAT=qbs_new(0,0);
-qbs*oldstr3722=NULL;
+qbs*oldstr3729=NULL;
 if(_FUNC_ELEMENTSTRINGCONCAT_STRING_OS1->tmp||_FUNC_ELEMENTSTRINGCONCAT_STRING_OS1->fixed||_FUNC_ELEMENTSTRINGCONCAT_STRING_OS1->readonly){
-oldstr3722=_FUNC_ELEMENTSTRINGCONCAT_STRING_OS1;
-if (oldstr3722->cmem_descriptor){
-_FUNC_ELEMENTSTRINGCONCAT_STRING_OS1=qbs_new_cmem(oldstr3722->len,0);
+oldstr3729=_FUNC_ELEMENTSTRINGCONCAT_STRING_OS1;
+if (oldstr3729->cmem_descriptor){
+_FUNC_ELEMENTSTRINGCONCAT_STRING_OS1=qbs_new_cmem(oldstr3729->len,0);
 }else{
-_FUNC_ELEMENTSTRINGCONCAT_STRING_OS1=qbs_new(oldstr3722->len,0);
+_FUNC_ELEMENTSTRINGCONCAT_STRING_OS1=qbs_new(oldstr3729->len,0);
 }
-memcpy(_FUNC_ELEMENTSTRINGCONCAT_STRING_OS1->chr,oldstr3722->chr,oldstr3722->len);
+memcpy(_FUNC_ELEMENTSTRINGCONCAT_STRING_OS1->chr,oldstr3729->chr,oldstr3729->len);
 }
-qbs*oldstr3723=NULL;
+qbs*oldstr3730=NULL;
 if(_FUNC_ELEMENTSTRINGCONCAT_STRING_OS2->tmp||_FUNC_ELEMENTSTRINGCONCAT_STRING_OS2->fixed||_FUNC_ELEMENTSTRINGCONCAT_STRING_OS2->readonly){
-oldstr3723=_FUNC_ELEMENTSTRINGCONCAT_STRING_OS2;
-if (oldstr3723->cmem_descriptor){
-_FUNC_ELEMENTSTRINGCONCAT_STRING_OS2=qbs_new_cmem(oldstr3723->len,0);
+oldstr3730=_FUNC_ELEMENTSTRINGCONCAT_STRING_OS2;
+if (oldstr3730->cmem_descriptor){
+_FUNC_ELEMENTSTRINGCONCAT_STRING_OS2=qbs_new_cmem(oldstr3730->len,0);
 }else{
-_FUNC_ELEMENTSTRINGCONCAT_STRING_OS2=qbs_new(oldstr3723->len,0);
+_FUNC_ELEMENTSTRINGCONCAT_STRING_OS2=qbs_new(oldstr3730->len,0);
 }
-memcpy(_FUNC_ELEMENTSTRINGCONCAT_STRING_OS2->chr,oldstr3723->chr,oldstr3723->len);
+memcpy(_FUNC_ELEMENTSTRINGCONCAT_STRING_OS2->chr,oldstr3730->chr,oldstr3730->len);
 }
 qbs *_FUNC_ELEMENTSTRINGCONCAT_STRING_S1=NULL;
 if (!_FUNC_ELEMENTSTRINGCONCAT_STRING_S1)_FUNC_ELEMENTSTRINGCONCAT_STRING_S1=qbs_new(0,0);
@ -34,19 +34,19 @@ if(_FUNC_ELEMENTSTRINGCONCAT_LONG_S2SIZE==NULL){
 _FUNC_ELEMENTSTRINGCONCAT_LONG_S2SIZE=(int32*)mem_static_malloc(4);
 *_FUNC_ELEMENTSTRINGCONCAT_LONG_S2SIZE=0;
 }
-byte_element_struct *byte_element_3724=NULL;
-if (!byte_element_3724){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3724=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3724=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3731=NULL;
+if (!byte_element_3731){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3731=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3731=(byte_element_struct*)mem_static_malloc(12);
 }
-byte_element_struct *byte_element_3725=NULL;
-if (!byte_element_3725){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3725=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3725=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3732=NULL;
+if (!byte_element_3732){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3732=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3732=(byte_element_struct*)mem_static_malloc(12);
 }
-byte_element_struct *byte_element_3726=NULL;
-if (!byte_element_3726){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3726=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3726=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3733=NULL;
+if (!byte_element_3733){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3733=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3733=(byte_element_struct*)mem_static_malloc(12);
 }
-byte_element_struct *byte_element_3727=NULL;
-if (!byte_element_3727){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3727=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3727=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3734=NULL;
+if (!byte_element_3734){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3734=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3734=(byte_element_struct*)mem_static_malloc(12);
 }
--- a/internal/source/data116.txt
+++ b/internal/source/data116.txt
@ -1,34 +1,34 @@
 qbs *_FUNC_GL2QB_TYPE_CONVERT_STRING_GL2QB_TYPE_CONVERT=NULL;
 if (!_FUNC_GL2QB_TYPE_CONVERT_STRING_GL2QB_TYPE_CONVERT)_FUNC_GL2QB_TYPE_CONVERT_STRING_GL2QB_TYPE_CONVERT=qbs_new(0,0);
-qbs*oldstr3728=NULL;
+qbs*oldstr3735=NULL;
 if(_FUNC_GL2QB_TYPE_CONVERT_STRING_A->tmp||_FUNC_GL2QB_TYPE_CONVERT_STRING_A->fixed||_FUNC_GL2QB_TYPE_CONVERT_STRING_A->readonly){
-oldstr3728=_FUNC_GL2QB_TYPE_CONVERT_STRING_A;
-if (oldstr3728->cmem_descriptor){
-_FUNC_GL2QB_TYPE_CONVERT_STRING_A=qbs_new_cmem(oldstr3728->len,0);
+oldstr3735=_FUNC_GL2QB_TYPE_CONVERT_STRING_A;
+if (oldstr3735->cmem_descriptor){
+_FUNC_GL2QB_TYPE_CONVERT_STRING_A=qbs_new_cmem(oldstr3735->len,0);
 }else{
-_FUNC_GL2QB_TYPE_CONVERT_STRING_A=qbs_new(oldstr3728->len,0);
+_FUNC_GL2QB_TYPE_CONVERT_STRING_A=qbs_new(oldstr3735->len,0);
 }
-memcpy(_FUNC_GL2QB_TYPE_CONVERT_STRING_A->chr,oldstr3728->chr,oldstr3728->len);
+memcpy(_FUNC_GL2QB_TYPE_CONVERT_STRING_A->chr,oldstr3735->chr,oldstr3735->len);
 }
-qbs*oldstr3729=NULL;
+qbs*oldstr3736=NULL;
 if(_FUNC_GL2QB_TYPE_CONVERT_STRING_SYMBOL->tmp||_FUNC_GL2QB_TYPE_CONVERT_STRING_SYMBOL->fixed||_FUNC_GL2QB_TYPE_CONVERT_STRING_SYMBOL->readonly){
-oldstr3729=_FUNC_GL2QB_TYPE_CONVERT_STRING_SYMBOL;
-if (oldstr3729->cmem_descriptor){
-_FUNC_GL2QB_TYPE_CONVERT_STRING_SYMBOL=qbs_new_cmem(oldstr3729->len,0);
+oldstr3736=_FUNC_GL2QB_TYPE_CONVERT_STRING_SYMBOL;
+if (oldstr3736->cmem_descriptor){
+_FUNC_GL2QB_TYPE_CONVERT_STRING_SYMBOL=qbs_new_cmem(oldstr3736->len,0);
 }else{
-_FUNC_GL2QB_TYPE_CONVERT_STRING_SYMBOL=qbs_new(oldstr3729->len,0);
+_FUNC_GL2QB_TYPE_CONVERT_STRING_SYMBOL=qbs_new(oldstr3736->len,0);
 }
-memcpy(_FUNC_GL2QB_TYPE_CONVERT_STRING_SYMBOL->chr,oldstr3729->chr,oldstr3729->len);
+memcpy(_FUNC_GL2QB_TYPE_CONVERT_STRING_SYMBOL->chr,oldstr3736->chr,oldstr3736->len);
 }
-qbs*oldstr3730=NULL;
+qbs*oldstr3737=NULL;
 if(_FUNC_GL2QB_TYPE_CONVERT_STRING_CTYP->tmp||_FUNC_GL2QB_TYPE_CONVERT_STRING_CTYP->fixed||_FUNC_GL2QB_TYPE_CONVERT_STRING_CTYP->readonly){
-oldstr3730=_FUNC_GL2QB_TYPE_CONVERT_STRING_CTYP;
-if (oldstr3730->cmem_descriptor){
-_FUNC_GL2QB_TYPE_CONVERT_STRING_CTYP=qbs_new_cmem(oldstr3730->len,0);
+oldstr3737=_FUNC_GL2QB_TYPE_CONVERT_STRING_CTYP;
+if (oldstr3737->cmem_descriptor){
+_FUNC_GL2QB_TYPE_CONVERT_STRING_CTYP=qbs_new_cmem(oldstr3737->len,0);
 }else{
-_FUNC_GL2QB_TYPE_CONVERT_STRING_CTYP=qbs_new(oldstr3730->len,0);
+_FUNC_GL2QB_TYPE_CONVERT_STRING_CTYP=qbs_new(oldstr3737->len,0);
 }
-memcpy(_FUNC_GL2QB_TYPE_CONVERT_STRING_CTYP->chr,oldstr3730->chr,oldstr3730->len);
+memcpy(_FUNC_GL2QB_TYPE_CONVERT_STRING_CTYP->chr,oldstr3737->chr,oldstr3737->len);
 }
 qbs *_FUNC_GL2QB_TYPE_CONVERT_STRING_B=NULL;
 if (!_FUNC_GL2QB_TYPE_CONVERT_STRING_B)_FUNC_GL2QB_TYPE_CONVERT_STRING_B=qbs_new(0,0);
--- a/internal/source/data117.txt
+++ b/internal/source/data117.txt
@ -1,44 +1,44 @@
 qbs *_FUNC_READCHUNK_STRING_READCHUNK=NULL;
 if (!_FUNC_READCHUNK_STRING_READCHUNK)_FUNC_READCHUNK_STRING_READCHUNK=qbs_new(0,0);
-qbs*oldstr3732=NULL;
+qbs*oldstr3739=NULL;
 if(_FUNC_READCHUNK_STRING_A->tmp||_FUNC_READCHUNK_STRING_A->fixed||_FUNC_READCHUNK_STRING_A->readonly){
-oldstr3732=_FUNC_READCHUNK_STRING_A;
-if (oldstr3732->cmem_descriptor){
-_FUNC_READCHUNK_STRING_A=qbs_new_cmem(oldstr3732->len,0);
+oldstr3739=_FUNC_READCHUNK_STRING_A;
+if (oldstr3739->cmem_descriptor){
+_FUNC_READCHUNK_STRING_A=qbs_new_cmem(oldstr3739->len,0);
 }else{
-_FUNC_READCHUNK_STRING_A=qbs_new(oldstr3732->len,0);
+_FUNC_READCHUNK_STRING_A=qbs_new(oldstr3739->len,0);
 }
-memcpy(_FUNC_READCHUNK_STRING_A->chr,oldstr3732->chr,oldstr3732->len);
+memcpy(_FUNC_READCHUNK_STRING_A->chr,oldstr3739->chr,oldstr3739->len);
 }
-qbs*oldstr3733=NULL;
+qbs*oldstr3740=NULL;
 if(_FUNC_READCHUNK_STRING_LAST_CHARACTER->tmp||_FUNC_READCHUNK_STRING_LAST_CHARACTER->fixed||_FUNC_READCHUNK_STRING_LAST_CHARACTER->readonly){
-oldstr3733=_FUNC_READCHUNK_STRING_LAST_CHARACTER;
-if (oldstr3733->cmem_descriptor){
-_FUNC_READCHUNK_STRING_LAST_CHARACTER=qbs_new_cmem(oldstr3733->len,0);
+oldstr3740=_FUNC_READCHUNK_STRING_LAST_CHARACTER;
+if (oldstr3740->cmem_descriptor){
+_FUNC_READCHUNK_STRING_LAST_CHARACTER=qbs_new_cmem(oldstr3740->len,0);
 }else{
-_FUNC_READCHUNK_STRING_LAST_CHARACTER=qbs_new(oldstr3733->len,0);
+_FUNC_READCHUNK_STRING_LAST_CHARACTER=qbs_new(oldstr3740->len,0);
 }
-memcpy(_FUNC_READCHUNK_STRING_LAST_CHARACTER->chr,oldstr3733->chr,oldstr3733->len);
+memcpy(_FUNC_READCHUNK_STRING_LAST_CHARACTER->chr,oldstr3740->chr,oldstr3740->len);
 }
 int32 *_FUNC_READCHUNK_LONG_X=NULL;
 if(_FUNC_READCHUNK_LONG_X==NULL){
 _FUNC_READCHUNK_LONG_X=(int32*)mem_static_malloc(4);
 *_FUNC_READCHUNK_LONG_X=0;
 }
-int64 fornext_value3735;
-int64 fornext_finalvalue3735;
-int64 fornext_step3735;
-uint8 fornext_step_negative3735;
-byte_element_struct *byte_element_3736=NULL;
-if (!byte_element_3736){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3736=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3736=(byte_element_struct*)mem_static_malloc(12);
+int64 fornext_value3742;
+int64 fornext_finalvalue3742;
+int64 fornext_step3742;
+uint8 fornext_step_negative3742;
+byte_element_struct *byte_element_3743=NULL;
+if (!byte_element_3743){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3743=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3743=(byte_element_struct*)mem_static_malloc(12);
 }
 int32 *_FUNC_READCHUNK_LONG_C=NULL;
 if(_FUNC_READCHUNK_LONG_C==NULL){
 _FUNC_READCHUNK_LONG_C=(int32*)mem_static_malloc(4);
 *_FUNC_READCHUNK_LONG_C=0;
 }
-byte_element_struct *byte_element_3737=NULL;
-if (!byte_element_3737){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3737=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3737=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3744=NULL;
+if (!byte_element_3744){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3744=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3744=(byte_element_struct*)mem_static_malloc(12);
 }
--- a/internal/source/data118.txt
+++ b/internal/source/data118.txt
@ -17,22 +17,22 @@ _SUB_GL_SCAN_HEADER_LONG_H=(int32*)mem_static_malloc(4);
 }
 qbs *_SUB_GL_SCAN_HEADER_STRING_A=NULL;
 if (!_SUB_GL_SCAN_HEADER_STRING_A)_SUB_GL_SCAN_HEADER_STRING_A=qbs_new(0,0);
-byte_element_struct *byte_element_3741=NULL;
-if (!byte_element_3741){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3741=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3741=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3748=NULL;
+if (!byte_element_3748){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3748=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3748=(byte_element_struct*)mem_static_malloc(12);
 }
 int32 *_SUB_GL_SCAN_HEADER_LONG_X=NULL;
 if(_SUB_GL_SCAN_HEADER_LONG_X==NULL){
 _SUB_GL_SCAN_HEADER_LONG_X=(int32*)mem_static_malloc(4);
 *_SUB_GL_SCAN_HEADER_LONG_X=0;
 }
-int64 fornext_value3743;
-int64 fornext_finalvalue3743;
-int64 fornext_step3743;
-uint8 fornext_step_negative3743;
-byte_element_struct *byte_element_3744=NULL;
-if (!byte_element_3744){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3744=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3744=(byte_element_struct*)mem_static_malloc(12);
+int64 fornext_value3750;
+int64 fornext_finalvalue3750;
+int64 fornext_step3750;
+uint8 fornext_step_negative3750;
+byte_element_struct *byte_element_3751=NULL;
+if (!byte_element_3751){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3751=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3751=(byte_element_struct*)mem_static_malloc(12);
 }
 int32 *_SUB_GL_SCAN_HEADER_LONG_C=NULL;
 if(_SUB_GL_SCAN_HEADER_LONG_C==NULL){
@ -44,13 +44,13 @@ if(_SUB_GL_SCAN_HEADER_LONG_X2==NULL){
 _SUB_GL_SCAN_HEADER_LONG_X2=(int32*)mem_static_malloc(4);
 *_SUB_GL_SCAN_HEADER_LONG_X2=0;
 }
-int64 fornext_value3746;
-int64 fornext_finalvalue3746;
-int64 fornext_step3746;
-uint8 fornext_step_negative3746;
-byte_element_struct *byte_element_3747=NULL;
-if (!byte_element_3747){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3747=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3747=(byte_element_struct*)mem_static_malloc(12);
+int64 fornext_value3753;
+int64 fornext_finalvalue3753;
+int64 fornext_step3753;
+uint8 fornext_step_negative3753;
+byte_element_struct *byte_element_3754=NULL;
+if (!byte_element_3754){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3754=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3754=(byte_element_struct*)mem_static_malloc(12);
 }
 int32 *_SUB_GL_SCAN_HEADER_LONG_C2=NULL;
 if(_SUB_GL_SCAN_HEADER_LONG_C2==NULL){
@ -59,32 +59,32 @@ _SUB_GL_SCAN_HEADER_LONG_C2=(int32*)mem_static_malloc(4);
 }
 qbs *_SUB_GL_SCAN_HEADER_STRING_VALUE=NULL;
 if (!_SUB_GL_SCAN_HEADER_STRING_VALUE)_SUB_GL_SCAN_HEADER_STRING_VALUE=qbs_new(0,0);
-byte_element_struct *byte_element_3748=NULL;
-if (!byte_element_3748){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3748=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3748=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3755=NULL;
+if (!byte_element_3755){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3755=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3755=(byte_element_struct*)mem_static_malloc(12);
 }
-byte_element_struct *byte_element_3749=NULL;
-if (!byte_element_3749){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3749=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3749=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3756=NULL;
+if (!byte_element_3756){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3756=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3756=(byte_element_struct*)mem_static_malloc(12);
 }
 int64 *_SUB_GL_SCAN_HEADER_INTEGER64_VALUE=NULL;
 if(_SUB_GL_SCAN_HEADER_INTEGER64_VALUE==NULL){
 _SUB_GL_SCAN_HEADER_INTEGER64_VALUE=(int64*)mem_static_malloc(8);
 *_SUB_GL_SCAN_HEADER_INTEGER64_VALUE=0;
 }
-byte_element_struct *byte_element_3750=NULL;
-if (!byte_element_3750){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3750=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3750=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3757=NULL;
+if (!byte_element_3757){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3757=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3757=(byte_element_struct*)mem_static_malloc(12);
 }
 int32 *_SUB_GL_SCAN_HEADER_LONG_I=NULL;
 if(_SUB_GL_SCAN_HEADER_LONG_I==NULL){
 _SUB_GL_SCAN_HEADER_LONG_I=(int32*)mem_static_malloc(4);
 *_SUB_GL_SCAN_HEADER_LONG_I=0;
 }
-int64 fornext_value3752;
-int64 fornext_finalvalue3752;
-int64 fornext_step3752;
-uint8 fornext_step_negative3752;
+int64 fornext_value3759;
+int64 fornext_finalvalue3759;
+int64 fornext_step3759;
+uint8 fornext_step_negative3759;
 qbs *_SUB_GL_SCAN_HEADER_STRING_L=NULL;
 if (!_SUB_GL_SCAN_HEADER_STRING_L)_SUB_GL_SCAN_HEADER_STRING_L=qbs_new(0,0);
 qbs *_SUB_GL_SCAN_HEADER_STRING_RET_TYPE=NULL;
@ -125,23 +125,23 @@ qbs *_SUB_GL_SCAN_HEADER_STRING_VAR_TYPE=NULL;
 if (!_SUB_GL_SCAN_HEADER_STRING_VAR_TYPE)_SUB_GL_SCAN_HEADER_STRING_VAR_TYPE=qbs_new(0,0);
 qbs *_SUB_GL_SCAN_HEADER_STRING_VAR_NAME=NULL;
 if (!_SUB_GL_SCAN_HEADER_STRING_VAR_NAME)_SUB_GL_SCAN_HEADER_STRING_VAR_NAME=qbs_new(0,0);
-byte_element_struct *byte_element_3759=NULL;
-if (!byte_element_3759){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3759=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3759=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3766=NULL;
+if (!byte_element_3766){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3766=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3766=(byte_element_struct*)mem_static_malloc(12);
 }
-byte_element_struct *byte_element_3760=NULL;
-if (!byte_element_3760){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3760=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3760=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3767=NULL;
+if (!byte_element_3767){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3767=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3767=(byte_element_struct*)mem_static_malloc(12);
 }
 qbs *_SUB_GL_SCAN_HEADER_STRING_VAR_TYPE_BACKUP=NULL;
 if (!_SUB_GL_SCAN_HEADER_STRING_VAR_TYPE_BACKUP)_SUB_GL_SCAN_HEADER_STRING_VAR_TYPE_BACKUP=qbs_new(0,0);
-byte_element_struct *byte_element_3761=NULL;
-if (!byte_element_3761){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3761=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3761=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3768=NULL;
+if (!byte_element_3768){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3768=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3768=(byte_element_struct*)mem_static_malloc(12);
 }
-byte_element_struct *byte_element_3762=NULL;
-if (!byte_element_3762){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3762=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3762=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3769=NULL;
+if (!byte_element_3769){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3769=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3769=(byte_element_struct*)mem_static_malloc(12);
 }
 qbs *_SUB_GL_SCAN_HEADER_STRING_QB_TYPE=NULL;
 if (!_SUB_GL_SCAN_HEADER_STRING_QB_TYPE)_SUB_GL_SCAN_HEADER_STRING_QB_TYPE=qbs_new(0,0);
@ -151,10 +151,10 @@ qbs *_SUB_GL_SCAN_HEADER_STRING_LETTER=NULL;
 if (!_SUB_GL_SCAN_HEADER_STRING_LETTER)_SUB_GL_SCAN_HEADER_STRING_LETTER=qbs_new(0,0);
 qbs *_SUB_GL_SCAN_HEADER_STRING_H=NULL;
 if (!_SUB_GL_SCAN_HEADER_STRING_H)_SUB_GL_SCAN_HEADER_STRING_H=qbs_new(0,0);
-int64 fornext_value3769;
-int64 fornext_finalvalue3769;
-int64 fornext_step3769;
-uint8 fornext_step_negative3769;
+int64 fornext_value3776;
+int64 fornext_finalvalue3776;
+int64 fornext_step3776;
+uint8 fornext_step_negative3776;
 int32 *_SUB_GL_SCAN_HEADER_LONG_FH=NULL;
 if(_SUB_GL_SCAN_HEADER_LONG_FH==NULL){
 _SUB_GL_SCAN_HEADER_LONG_FH=(int32*)mem_static_malloc(4);
--- a/internal/source/data119.txt
+++ b/internal/source/data119.txt
@ -3,25 +3,25 @@ if(_SUB_GL_INCLUDE_CONTENT_LONG_D==NULL){
 _SUB_GL_INCLUDE_CONTENT_LONG_D=(int32*)mem_static_malloc(4);
 *_SUB_GL_INCLUDE_CONTENT_LONG_D=0;
 }
-int64 fornext_value3773;
-int64 fornext_finalvalue3773;
-int64 fornext_step3773;
-uint8 fornext_step_negative3773;
+int64 fornext_value3780;
+int64 fornext_finalvalue3780;
+int64 fornext_step3780;
+uint8 fornext_step_negative3780;
 int32 *_SUB_GL_INCLUDE_CONTENT_LONG_I=NULL;
 if(_SUB_GL_INCLUDE_CONTENT_LONG_I==NULL){
 _SUB_GL_INCLUDE_CONTENT_LONG_I=(int32*)mem_static_malloc(4);
 *_SUB_GL_INCLUDE_CONTENT_LONG_I=0;
 }
-int32 pass3774;
+int32 pass3781;
 int32 *_SUB_GL_INCLUDE_CONTENT_LONG_C=NULL;
 if(_SUB_GL_INCLUDE_CONTENT_LONG_C==NULL){
 _SUB_GL_INCLUDE_CONTENT_LONG_C=(int32*)mem_static_malloc(4);
 *_SUB_GL_INCLUDE_CONTENT_LONG_C=0;
 }
-int64 fornext_value3776;
-int64 fornext_finalvalue3776;
-int64 fornext_step3776;
-uint8 fornext_step_negative3776;
+int64 fornext_value3783;
+int64 fornext_finalvalue3783;
+int64 fornext_step3783;
+uint8 fornext_step_negative3783;
 void *_SUB_GL_INCLUDE_CONTENT_UDT_G=NULL;
 if(_SUB_GL_INCLUDE_CONTENT_UDT_G==NULL){
 _SUB_GL_INCLUDE_CONTENT_UDT_G=(void*)mem_static_malloc(216);
--- a/internal/source/data12.txt
+++ b/internal/source/data12.txt
@ -1,25 +1,25 @@
-qbs*oldstr2355=NULL;
+qbs*oldstr2361=NULL;
 if(_SUB_VWATCHVARIABLE_STRING_THIS->tmp||_SUB_VWATCHVARIABLE_STRING_THIS->fixed||_SUB_VWATCHVARIABLE_STRING_THIS->readonly){
-oldstr2355=_SUB_VWATCHVARIABLE_STRING_THIS;
-if (oldstr2355->cmem_descriptor){
-_SUB_VWATCHVARIABLE_STRING_THIS=qbs_new_cmem(oldstr2355->len,0);
+oldstr2361=_SUB_VWATCHVARIABLE_STRING_THIS;
+if (oldstr2361->cmem_descriptor){
+_SUB_VWATCHVARIABLE_STRING_THIS=qbs_new_cmem(oldstr2361->len,0);
 }else{
-_SUB_VWATCHVARIABLE_STRING_THIS=qbs_new(oldstr2355->len,0);
+_SUB_VWATCHVARIABLE_STRING_THIS=qbs_new(oldstr2361->len,0);
 }
-memcpy(_SUB_VWATCHVARIABLE_STRING_THIS->chr,oldstr2355->chr,oldstr2355->len);
+memcpy(_SUB_VWATCHVARIABLE_STRING_THIS->chr,oldstr2361->chr,oldstr2361->len);
 }
-int32 pass2357;
-int32 pass2358;
-int8 pass2359;
-int32 pass2360;
-int32 pass2361;
-int8 pass2362;
-int16 pass2363;
-int16 pass2364;
-int16 pass2365;
-int16 pass2366;
-int16 pass2367;
-int16 pass2368;
+int32 pass2363;
+int32 pass2364;
+int8 pass2365;
+int32 pass2366;
+int32 pass2367;
+int8 pass2368;
 int16 pass2369;
 int16 pass2370;
 int16 pass2371;
+int16 pass2372;
+int16 pass2373;
+int16 pass2374;
+int16 pass2375;
+int16 pass2376;
+int16 pass2377;
--- a/internal/source/data120.txt
+++ b/internal/source/data120.txt
@ -1,17 +1,17 @@
-byte_element_struct *byte_element_3777=NULL;
-if (!byte_element_3777){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3777=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3777=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3784=NULL;
+if (!byte_element_3784){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3784=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3784=(byte_element_struct*)mem_static_malloc(12);
 }
 int16 *_SUB_INICOMMIT_INTEGER_FILENUM=NULL;
 if(_SUB_INICOMMIT_INTEGER_FILENUM==NULL){
 _SUB_INICOMMIT_INTEGER_FILENUM=(int16*)mem_static_malloc(2);
 *_SUB_INICOMMIT_INTEGER_FILENUM=0;
 }
-byte_element_struct *byte_element_3778=NULL;
-if (!byte_element_3778){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3778=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3778=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3785=NULL;
+if (!byte_element_3785){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3785=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3785=(byte_element_struct*)mem_static_malloc(12);
 }
-byte_element_struct *byte_element_3779=NULL;
-if (!byte_element_3779){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3779=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3779=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3786=NULL;
+if (!byte_element_3786){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3786=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3786=(byte_element_struct*)mem_static_malloc(12);
 }
--- a/internal/source/data121.txt
+++ b/internal/source/data121.txt
@ -1,14 +1,14 @@
 qbs *_FUNC_INIGETSECTION_STRING_INIGETSECTION=NULL;
 if (!_FUNC_INIGETSECTION_STRING_INIGETSECTION)_FUNC_INIGETSECTION_STRING_INIGETSECTION=qbs_new(0,0);
-qbs*oldstr3780=NULL;
+qbs*oldstr3787=NULL;
 if(_FUNC_INIGETSECTION_STRING___SECTION->tmp||_FUNC_INIGETSECTION_STRING___SECTION->fixed||_FUNC_INIGETSECTION_STRING___SECTION->readonly){
-oldstr3780=_FUNC_INIGETSECTION_STRING___SECTION;
-if (oldstr3780->cmem_descriptor){
-_FUNC_INIGETSECTION_STRING___SECTION=qbs_new_cmem(oldstr3780->len,0);
+oldstr3787=_FUNC_INIGETSECTION_STRING___SECTION;
+if (oldstr3787->cmem_descriptor){
+_FUNC_INIGETSECTION_STRING___SECTION=qbs_new_cmem(oldstr3787->len,0);
 }else{
-_FUNC_INIGETSECTION_STRING___SECTION=qbs_new(oldstr3780->len,0);
+_FUNC_INIGETSECTION_STRING___SECTION=qbs_new(oldstr3787->len,0);
 }
-memcpy(_FUNC_INIGETSECTION_STRING___SECTION->chr,oldstr3780->chr,oldstr3780->len);
+memcpy(_FUNC_INIGETSECTION_STRING___SECTION->chr,oldstr3787->chr,oldstr3787->len);
 }
 qbs *_FUNC_INIGETSECTION_STRING_SECTION=NULL;
 if (!_FUNC_INIGETSECTION_STRING_SECTION)_FUNC_INIGETSECTION_STRING_SECTION=qbs_new(0,0);
@ -42,23 +42,23 @@ if(_FUNC_INIGETSECTION_BYTE_INQUOTE==NULL){
 _FUNC_INIGETSECTION_BYTE_INQUOTE=(int8*)mem_static_malloc(1);
 *_FUNC_INIGETSECTION_BYTE_INQUOTE=0;
 }
-int64 fornext_value3782;
-int64 fornext_finalvalue3782;
-int64 fornext_step3782;
-uint8 fornext_step_negative3782;
-int64 fornext_value3785;
-int64 fornext_finalvalue3785;
-int64 fornext_step3785;
-uint8 fornext_step_negative3785;
-int64 fornext_value3787;
-int64 fornext_finalvalue3787;
-int64 fornext_step3787;
-uint8 fornext_step_negative3787;
 int64 fornext_value3789;
 int64 fornext_finalvalue3789;
 int64 fornext_step3789;
 uint8 fornext_step_negative3789;
-byte_element_struct *byte_element_3790=NULL;
-if (!byte_element_3790){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3790=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3790=(byte_element_struct*)mem_static_malloc(12);
+int64 fornext_value3792;
+int64 fornext_finalvalue3792;
+int64 fornext_step3792;
+uint8 fornext_step_negative3792;
+int64 fornext_value3794;
+int64 fornext_finalvalue3794;
+int64 fornext_step3794;
+uint8 fornext_step_negative3794;
+int64 fornext_value3796;
+int64 fornext_finalvalue3796;
+int64 fornext_step3796;
+uint8 fornext_step_negative3796;
+byte_element_struct *byte_element_3797=NULL;
+if (!byte_element_3797){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3797=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3797=(byte_element_struct*)mem_static_malloc(12);
 }
--- a/internal/source/data122.txt
+++ b/internal/source/data122.txt
@ -1,22 +1,22 @@
 qbs *_FUNC_INIFORMATSECTION_STRING_INIFORMATSECTION=NULL;
 if (!_FUNC_INIFORMATSECTION_STRING_INIFORMATSECTION)_FUNC_INIFORMATSECTION_STRING_INIFORMATSECTION=qbs_new(0,0);
-qbs*oldstr3791=NULL;
+qbs*oldstr3798=NULL;
 if(_FUNC_INIFORMATSECTION_STRING___SECTION->tmp||_FUNC_INIFORMATSECTION_STRING___SECTION->fixed||_FUNC_INIFORMATSECTION_STRING___SECTION->readonly){
-oldstr3791=_FUNC_INIFORMATSECTION_STRING___SECTION;
-if (oldstr3791->cmem_descriptor){
-_FUNC_INIFORMATSECTION_STRING___SECTION=qbs_new_cmem(oldstr3791->len,0);
+oldstr3798=_FUNC_INIFORMATSECTION_STRING___SECTION;
+if (oldstr3798->cmem_descriptor){
+_FUNC_INIFORMATSECTION_STRING___SECTION=qbs_new_cmem(oldstr3798->len,0);
 }else{
-_FUNC_INIFORMATSECTION_STRING___SECTION=qbs_new(oldstr3791->len,0);
+_FUNC_INIFORMATSECTION_STRING___SECTION=qbs_new(oldstr3798->len,0);
 }
-memcpy(_FUNC_INIFORMATSECTION_STRING___SECTION->chr,oldstr3791->chr,oldstr3791->len);
+memcpy(_FUNC_INIFORMATSECTION_STRING___SECTION->chr,oldstr3798->chr,oldstr3798->len);
 }
 qbs *_FUNC_INIFORMATSECTION_STRING_SECTION=NULL;
 if (!_FUNC_INIFORMATSECTION_STRING_SECTION)_FUNC_INIFORMATSECTION_STRING_SECTION=qbs_new(0,0);
-byte_element_struct *byte_element_3792=NULL;
-if (!byte_element_3792){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3792=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3792=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3799=NULL;
+if (!byte_element_3799){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3799=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3799=(byte_element_struct*)mem_static_malloc(12);
 }
-byte_element_struct *byte_element_3793=NULL;
-if (!byte_element_3793){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3793=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3793=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3800=NULL;
+if (!byte_element_3800){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3800=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3800=(byte_element_struct*)mem_static_malloc(12);
 }
--- a/internal/source/data123.txt
+++ b/internal/source/data123.txt
@ -1,34 +1,34 @@
 qbs *_FUNC_READSETTING_STRING_READSETTING=NULL;
 if (!_FUNC_READSETTING_STRING_READSETTING)_FUNC_READSETTING_STRING_READSETTING=qbs_new(0,0);
-qbs*oldstr3794=NULL;
+qbs*oldstr3801=NULL;
 if(_FUNC_READSETTING_STRING_FILE->tmp||_FUNC_READSETTING_STRING_FILE->fixed||_FUNC_READSETTING_STRING_FILE->readonly){
-oldstr3794=_FUNC_READSETTING_STRING_FILE;
-if (oldstr3794->cmem_descriptor){
-_FUNC_READSETTING_STRING_FILE=qbs_new_cmem(oldstr3794->len,0);
+oldstr3801=_FUNC_READSETTING_STRING_FILE;
+if (oldstr3801->cmem_descriptor){
+_FUNC_READSETTING_STRING_FILE=qbs_new_cmem(oldstr3801->len,0);
 }else{
-_FUNC_READSETTING_STRING_FILE=qbs_new(oldstr3794->len,0);
+_FUNC_READSETTING_STRING_FILE=qbs_new(oldstr3801->len,0);
 }
-memcpy(_FUNC_READSETTING_STRING_FILE->chr,oldstr3794->chr,oldstr3794->len);
+memcpy(_FUNC_READSETTING_STRING_FILE->chr,oldstr3801->chr,oldstr3801->len);
 }
-qbs*oldstr3795=NULL;
+qbs*oldstr3802=NULL;
 if(_FUNC_READSETTING_STRING___SECTION->tmp||_FUNC_READSETTING_STRING___SECTION->fixed||_FUNC_READSETTING_STRING___SECTION->readonly){
-oldstr3795=_FUNC_READSETTING_STRING___SECTION;
-if (oldstr3795->cmem_descriptor){
-_FUNC_READSETTING_STRING___SECTION=qbs_new_cmem(oldstr3795->len,0);
+oldstr3802=_FUNC_READSETTING_STRING___SECTION;
+if (oldstr3802->cmem_descriptor){
+_FUNC_READSETTING_STRING___SECTION=qbs_new_cmem(oldstr3802->len,0);
 }else{
-_FUNC_READSETTING_STRING___SECTION=qbs_new(oldstr3795->len,0);
+_FUNC_READSETTING_STRING___SECTION=qbs_new(oldstr3802->len,0);
 }
-memcpy(_FUNC_READSETTING_STRING___SECTION->chr,oldstr3795->chr,oldstr3795->len);
+memcpy(_FUNC_READSETTING_STRING___SECTION->chr,oldstr3802->chr,oldstr3802->len);
 }
-qbs*oldstr3796=NULL;
+qbs*oldstr3803=NULL;
 if(_FUNC_READSETTING_STRING___KEY->tmp||_FUNC_READSETTING_STRING___KEY->fixed||_FUNC_READSETTING_STRING___KEY->readonly){
-oldstr3796=_FUNC_READSETTING_STRING___KEY;
-if (oldstr3796->cmem_descriptor){
-_FUNC_READSETTING_STRING___KEY=qbs_new_cmem(oldstr3796->len,0);
+oldstr3803=_FUNC_READSETTING_STRING___KEY;
+if (oldstr3803->cmem_descriptor){
+_FUNC_READSETTING_STRING___KEY=qbs_new_cmem(oldstr3803->len,0);
 }else{
-_FUNC_READSETTING_STRING___KEY=qbs_new(oldstr3796->len,0);
+_FUNC_READSETTING_STRING___KEY=qbs_new(oldstr3803->len,0);
 }
-memcpy(_FUNC_READSETTING_STRING___KEY->chr,oldstr3796->chr,oldstr3796->len);
+memcpy(_FUNC_READSETTING_STRING___KEY->chr,oldstr3803->chr,oldstr3803->len);
 }
 uint32 *_FUNC_READSETTING_ULONG_EQUAL=NULL;
 if(_FUNC_READSETTING_ULONG_EQUAL==NULL){
@ -61,31 +61,31 @@ if(_FUNC_READSETTING_ULONG_FOUNDLF==NULL){
 _FUNC_READSETTING_ULONG_FOUNDLF=(uint32*)mem_static_malloc(4);
 *_FUNC_READSETTING_ULONG_FOUNDLF=0;
 }
-byte_element_struct *byte_element_3797=NULL;
-if (!byte_element_3797){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3797=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3797=(byte_element_struct*)mem_static_malloc(12);
-}
-int64 fornext_value3799;
-int64 fornext_finalvalue3799;
-int64 fornext_step3799;
-uint8 fornext_step_negative3799;
-int64 fornext_value3801;
-int64 fornext_finalvalue3801;
-int64 fornext_step3801;
-uint8 fornext_step_negative3801;
-byte_element_struct *byte_element_3802=NULL;
-if (!byte_element_3802){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3802=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3802=(byte_element_struct*)mem_static_malloc(12);
-}
-byte_element_struct *byte_element_3803=NULL;
-if (!byte_element_3803){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3803=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3803=(byte_element_struct*)mem_static_malloc(12);
-}
 byte_element_struct *byte_element_3804=NULL;
 if (!byte_element_3804){
 if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3804=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3804=(byte_element_struct*)mem_static_malloc(12);
 }
-byte_element_struct *byte_element_3805=NULL;
-if (!byte_element_3805){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3805=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3805=(byte_element_struct*)mem_static_malloc(12);
+int64 fornext_value3806;
+int64 fornext_finalvalue3806;
+int64 fornext_step3806;
+uint8 fornext_step_negative3806;
+int64 fornext_value3808;
+int64 fornext_finalvalue3808;
+int64 fornext_step3808;
+uint8 fornext_step_negative3808;
+byte_element_struct *byte_element_3809=NULL;
+if (!byte_element_3809){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3809=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3809=(byte_element_struct*)mem_static_malloc(12);
+}
+byte_element_struct *byte_element_3810=NULL;
+if (!byte_element_3810){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3810=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3810=(byte_element_struct*)mem_static_malloc(12);
+}
+byte_element_struct *byte_element_3811=NULL;
+if (!byte_element_3811){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3811=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3811=(byte_element_struct*)mem_static_malloc(12);
+}
+byte_element_struct *byte_element_3812=NULL;
+if (!byte_element_3812){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3812=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3812=(byte_element_struct*)mem_static_malloc(12);
 }
--- a/internal/source/data124.txt
+++ b/internal/source/data124.txt
@ -15,11 +15,11 @@ if(_FUNC_INICURRENTSECTION_ULONG_CLOSINGBRACKET==NULL){
 _FUNC_INICURRENTSECTION_ULONG_CLOSINGBRACKET=(uint32*)mem_static_malloc(4);
 *_FUNC_INICURRENTSECTION_ULONG_CLOSINGBRACKET=0;
 }
-int64 fornext_value3807;
-int64 fornext_finalvalue3807;
-int64 fornext_step3807;
-uint8 fornext_step_negative3807;
-int64 fornext_value3809;
-int64 fornext_finalvalue3809;
-int64 fornext_step3809;
-uint8 fornext_step_negative3809;
+int64 fornext_value3814;
+int64 fornext_finalvalue3814;
+int64 fornext_step3814;
+uint8 fornext_step_negative3814;
+int64 fornext_value3816;
+int64 fornext_finalvalue3816;
+int64 fornext_step3816;
+uint8 fornext_step_negative3816;
--- a/internal/source/data125.txt
+++ b/internal/source/data125.txt
@ -1,42 +1,42 @@
-qbs*oldstr3810=NULL;
+qbs*oldstr3817=NULL;
 if(_SUB_WRITESETTING_STRING_FILE->tmp||_SUB_WRITESETTING_STRING_FILE->fixed||_SUB_WRITESETTING_STRING_FILE->readonly){
-oldstr3810=_SUB_WRITESETTING_STRING_FILE;
-if (oldstr3810->cmem_descriptor){
-_SUB_WRITESETTING_STRING_FILE=qbs_new_cmem(oldstr3810->len,0);
+oldstr3817=_SUB_WRITESETTING_STRING_FILE;
+if (oldstr3817->cmem_descriptor){
+_SUB_WRITESETTING_STRING_FILE=qbs_new_cmem(oldstr3817->len,0);
 }else{
-_SUB_WRITESETTING_STRING_FILE=qbs_new(oldstr3810->len,0);
+_SUB_WRITESETTING_STRING_FILE=qbs_new(oldstr3817->len,0);
 }
-memcpy(_SUB_WRITESETTING_STRING_FILE->chr,oldstr3810->chr,oldstr3810->len);
+memcpy(_SUB_WRITESETTING_STRING_FILE->chr,oldstr3817->chr,oldstr3817->len);
 }
-qbs*oldstr3811=NULL;
+qbs*oldstr3818=NULL;
 if(_SUB_WRITESETTING_STRING___SECTION->tmp||_SUB_WRITESETTING_STRING___SECTION->fixed||_SUB_WRITESETTING_STRING___SECTION->readonly){
-oldstr3811=_SUB_WRITESETTING_STRING___SECTION;
-if (oldstr3811->cmem_descriptor){
-_SUB_WRITESETTING_STRING___SECTION=qbs_new_cmem(oldstr3811->len,0);
+oldstr3818=_SUB_WRITESETTING_STRING___SECTION;
+if (oldstr3818->cmem_descriptor){
+_SUB_WRITESETTING_STRING___SECTION=qbs_new_cmem(oldstr3818->len,0);
 }else{
-_SUB_WRITESETTING_STRING___SECTION=qbs_new(oldstr3811->len,0);
+_SUB_WRITESETTING_STRING___SECTION=qbs_new(oldstr3818->len,0);
 }
-memcpy(_SUB_WRITESETTING_STRING___SECTION->chr,oldstr3811->chr,oldstr3811->len);
+memcpy(_SUB_WRITESETTING_STRING___SECTION->chr,oldstr3818->chr,oldstr3818->len);
 }
-qbs*oldstr3812=NULL;
+qbs*oldstr3819=NULL;
 if(_SUB_WRITESETTING_STRING___KEY->tmp||_SUB_WRITESETTING_STRING___KEY->fixed||_SUB_WRITESETTING_STRING___KEY->readonly){
-oldstr3812=_SUB_WRITESETTING_STRING___KEY;
-if (oldstr3812->cmem_descriptor){
-_SUB_WRITESETTING_STRING___KEY=qbs_new_cmem(oldstr3812->len,0);
+oldstr3819=_SUB_WRITESETTING_STRING___KEY;
+if (oldstr3819->cmem_descriptor){
+_SUB_WRITESETTING_STRING___KEY=qbs_new_cmem(oldstr3819->len,0);
 }else{
-_SUB_WRITESETTING_STRING___KEY=qbs_new(oldstr3812->len,0);
+_SUB_WRITESETTING_STRING___KEY=qbs_new(oldstr3819->len,0);
 }
-memcpy(_SUB_WRITESETTING_STRING___KEY->chr,oldstr3812->chr,oldstr3812->len);
+memcpy(_SUB_WRITESETTING_STRING___KEY->chr,oldstr3819->chr,oldstr3819->len);
 }
-qbs*oldstr3813=NULL;
+qbs*oldstr3820=NULL;
 if(_SUB_WRITESETTING_STRING___VALUE->tmp||_SUB_WRITESETTING_STRING___VALUE->fixed||_SUB_WRITESETTING_STRING___VALUE->readonly){
-oldstr3813=_SUB_WRITESETTING_STRING___VALUE;
-if (oldstr3813->cmem_descriptor){
-_SUB_WRITESETTING_STRING___VALUE=qbs_new_cmem(oldstr3813->len,0);
+oldstr3820=_SUB_WRITESETTING_STRING___VALUE;
+if (oldstr3820->cmem_descriptor){
+_SUB_WRITESETTING_STRING___VALUE=qbs_new_cmem(oldstr3820->len,0);
 }else{
-_SUB_WRITESETTING_STRING___VALUE=qbs_new(oldstr3813->len,0);
+_SUB_WRITESETTING_STRING___VALUE=qbs_new(oldstr3820->len,0);
 }
-memcpy(_SUB_WRITESETTING_STRING___VALUE->chr,oldstr3813->chr,oldstr3813->len);
+memcpy(_SUB_WRITESETTING_STRING___VALUE->chr,oldstr3820->chr,oldstr3820->len);
 }
 qbs *_SUB_WRITESETTING_STRING_TEMPVALUE=NULL;
 if (!_SUB_WRITESETTING_STRING_TEMPVALUE)_SUB_WRITESETTING_STRING_TEMPVALUE=qbs_new(0,0);
@ -71,31 +71,31 @@ if(_SUB_WRITESETTING_ULONG_I==NULL){
 _SUB_WRITESETTING_ULONG_I=(uint32*)mem_static_malloc(4);
 *_SUB_WRITESETTING_ULONG_I=0;
 }
-int64 fornext_value3815;
-int64 fornext_finalvalue3815;
-int64 fornext_step3815;
-uint8 fornext_step_negative3815;
-int64 fornext_value3817;
-int64 fornext_finalvalue3817;
-int64 fornext_step3817;
-uint8 fornext_step_negative3817;
-byte_element_struct *byte_element_3818=NULL;
-if (!byte_element_3818){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3818=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3818=(byte_element_struct*)mem_static_malloc(12);
+int64 fornext_value3822;
+int64 fornext_finalvalue3822;
+int64 fornext_step3822;
+uint8 fornext_step_negative3822;
+int64 fornext_value3824;
+int64 fornext_finalvalue3824;
+int64 fornext_step3824;
+uint8 fornext_step_negative3824;
+byte_element_struct *byte_element_3825=NULL;
+if (!byte_element_3825){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3825=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3825=(byte_element_struct*)mem_static_malloc(12);
 }
-byte_element_struct *byte_element_3819=NULL;
-if (!byte_element_3819){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3819=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3819=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3826=NULL;
+if (!byte_element_3826){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3826=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3826=(byte_element_struct*)mem_static_malloc(12);
 }
-byte_element_struct *byte_element_3820=NULL;
-if (!byte_element_3820){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3820=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3820=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3827=NULL;
+if (!byte_element_3827){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3827=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3827=(byte_element_struct*)mem_static_malloc(12);
 }
-byte_element_struct *byte_element_3821=NULL;
-if (!byte_element_3821){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3821=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3821=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3828=NULL;
+if (!byte_element_3828){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3828=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3828=(byte_element_struct*)mem_static_malloc(12);
 }
-byte_element_struct *byte_element_3822=NULL;
-if (!byte_element_3822){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3822=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3822=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3829=NULL;
+if (!byte_element_3829){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3829=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3829=(byte_element_struct*)mem_static_malloc(12);
 }
--- a/internal/source/data13.txt
+++ b/internal/source/data13.txt
@ -1,7 +1,7 @@
-byte_element_struct *byte_element_2373=NULL;
-if (!byte_element_2373){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2373=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2373=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_2379=NULL;
+if (!byte_element_2379){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2379=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2379=(byte_element_struct*)mem_static_malloc(12);
 }
-int16 pass2374;
-int16 pass2375;
-int16 pass2376;
+int16 pass2380;
+int16 pass2381;
+int16 pass2382;
--- a/internal/source/data130.txt
+++ b/internal/source/data130.txt
@ -1,19 +1,19 @@
-qbs*oldstr3823=NULL;
+qbs*oldstr3830=NULL;
 if(_SUB_INILOAD_STRING_FILE->tmp||_SUB_INILOAD_STRING_FILE->fixed||_SUB_INILOAD_STRING_FILE->readonly){
-oldstr3823=_SUB_INILOAD_STRING_FILE;
-if (oldstr3823->cmem_descriptor){
-_SUB_INILOAD_STRING_FILE=qbs_new_cmem(oldstr3823->len,0);
+oldstr3830=_SUB_INILOAD_STRING_FILE;
+if (oldstr3830->cmem_descriptor){
+_SUB_INILOAD_STRING_FILE=qbs_new_cmem(oldstr3830->len,0);
 }else{
-_SUB_INILOAD_STRING_FILE=qbs_new(oldstr3823->len,0);
+_SUB_INILOAD_STRING_FILE=qbs_new(oldstr3830->len,0);
 }
-memcpy(_SUB_INILOAD_STRING_FILE->chr,oldstr3823->chr,oldstr3823->len);
+memcpy(_SUB_INILOAD_STRING_FILE->chr,oldstr3830->chr,oldstr3830->len);
 }
 int16 *_SUB_INILOAD_INTEGER_FILENUM=NULL;
 if(_SUB_INILOAD_INTEGER_FILENUM==NULL){
 _SUB_INILOAD_INTEGER_FILENUM=(int16*)mem_static_malloc(2);
 *_SUB_INILOAD_INTEGER_FILENUM=0;
 }
-byte_element_struct *byte_element_3824=NULL;
-if (!byte_element_3824){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3824=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3824=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3831=NULL;
+if (!byte_element_3831){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3831=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3831=(byte_element_struct*)mem_static_malloc(12);
 }
--- a/internal/source/data133.txt
+++ b/internal/source/data133.txt
@ -3,15 +3,15 @@ if(_FUNC_FILETOBUF_INTEGER_FILETOBUF==NULL){
 _FUNC_FILETOBUF_INTEGER_FILETOBUF=(int16*)mem_static_malloc(2);
 *_FUNC_FILETOBUF_INTEGER_FILETOBUF=0;
 }
-qbs*oldstr3826=NULL;
+qbs*oldstr3833=NULL;
 if(_FUNC_FILETOBUF_STRING_FILESPEC->tmp||_FUNC_FILETOBUF_STRING_FILESPEC->fixed||_FUNC_FILETOBUF_STRING_FILESPEC->readonly){
-oldstr3826=_FUNC_FILETOBUF_STRING_FILESPEC;
-if (oldstr3826->cmem_descriptor){
-_FUNC_FILETOBUF_STRING_FILESPEC=qbs_new_cmem(oldstr3826->len,0);
+oldstr3833=_FUNC_FILETOBUF_STRING_FILESPEC;
+if (oldstr3833->cmem_descriptor){
+_FUNC_FILETOBUF_STRING_FILESPEC=qbs_new_cmem(oldstr3833->len,0);
 }else{
-_FUNC_FILETOBUF_STRING_FILESPEC=qbs_new(oldstr3826->len,0);
+_FUNC_FILETOBUF_STRING_FILESPEC=qbs_new(oldstr3833->len,0);
 }
-memcpy(_FUNC_FILETOBUF_STRING_FILESPEC->chr,oldstr3826->chr,oldstr3826->len);
+memcpy(_FUNC_FILETOBUF_STRING_FILESPEC->chr,oldstr3833->chr,oldstr3833->len);
 }
 int16 *_FUNC_FILETOBUF_INTEGER_HAN=NULL;
 if(_FUNC_FILETOBUF_INTEGER_HAN==NULL){
--- a/internal/source/data134.txt
+++ b/internal/source/data134.txt
@ -1,12 +1,12 @@
-qbs*oldstr3827=NULL;
+qbs*oldstr3834=NULL;
 if(_SUB_BUFTOFILE_STRING_FILESPEC->tmp||_SUB_BUFTOFILE_STRING_FILESPEC->fixed||_SUB_BUFTOFILE_STRING_FILESPEC->readonly){
-oldstr3827=_SUB_BUFTOFILE_STRING_FILESPEC;
-if (oldstr3827->cmem_descriptor){
-_SUB_BUFTOFILE_STRING_FILESPEC=qbs_new_cmem(oldstr3827->len,0);
+oldstr3834=_SUB_BUFTOFILE_STRING_FILESPEC;
+if (oldstr3834->cmem_descriptor){
+_SUB_BUFTOFILE_STRING_FILESPEC=qbs_new_cmem(oldstr3834->len,0);
 }else{
-_SUB_BUFTOFILE_STRING_FILESPEC=qbs_new(oldstr3827->len,0);
+_SUB_BUFTOFILE_STRING_FILESPEC=qbs_new(oldstr3834->len,0);
 }
-memcpy(_SUB_BUFTOFILE_STRING_FILESPEC->chr,oldstr3827->chr,oldstr3827->len);
+memcpy(_SUB_BUFTOFILE_STRING_FILESPEC->chr,oldstr3834->chr,oldstr3834->len);
 }
 int32 *_SUB_BUFTOFILE_LONG_BUF=NULL;
 if(_SUB_BUFTOFILE_LONG_BUF==NULL){
@ -20,7 +20,7 @@ _SUB_BUFTOFILE_INTEGER_FF=(int16*)mem_static_malloc(2);
 }
 qbs *_SUB_BUFTOFILE_STRING_DAT=NULL;
 if (!_SUB_BUFTOFILE_STRING_DAT)_SUB_BUFTOFILE_STRING_DAT=qbs_new(0,0);
-byte_element_struct *byte_element_3828=NULL;
-if (!byte_element_3828){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3828=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3828=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3835=NULL;
+if (!byte_element_3835){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3835=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3835=(byte_element_struct*)mem_static_malloc(12);
 }
--- a/internal/source/data135.txt
+++ b/internal/source/data135.txt
@ -27,7 +27,7 @@ if(_FUNC_READBUFLINE_LONG_EOL==NULL){
 _FUNC_READBUFLINE_LONG_EOL=(int32*)mem_static_malloc(4);
 *_FUNC_READBUFLINE_LONG_EOL=0;
 }
-byte_element_struct *byte_element_3829=NULL;
-if (!byte_element_3829){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3829=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3829=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3836=NULL;
+if (!byte_element_3836){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3836=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3836=(byte_element_struct*)mem_static_malloc(12);
 }
--- a/internal/source/data136.txt
+++ b/internal/source/data136.txt
@ -1,12 +1,12 @@
-qbs*oldstr3830=NULL;
+qbs*oldstr3837=NULL;
 if(_SUB_WRITEBUFLINE_STRING_TEXT->tmp||_SUB_WRITEBUFLINE_STRING_TEXT->fixed||_SUB_WRITEBUFLINE_STRING_TEXT->readonly){
-oldstr3830=_SUB_WRITEBUFLINE_STRING_TEXT;
-if (oldstr3830->cmem_descriptor){
-_SUB_WRITEBUFLINE_STRING_TEXT=qbs_new_cmem(oldstr3830->len,0);
+oldstr3837=_SUB_WRITEBUFLINE_STRING_TEXT;
+if (oldstr3837->cmem_descriptor){
+_SUB_WRITEBUFLINE_STRING_TEXT=qbs_new_cmem(oldstr3837->len,0);
 }else{
-_SUB_WRITEBUFLINE_STRING_TEXT=qbs_new(oldstr3830->len,0);
+_SUB_WRITEBUFLINE_STRING_TEXT=qbs_new(oldstr3837->len,0);
 }
-memcpy(_SUB_WRITEBUFLINE_STRING_TEXT->chr,oldstr3830->chr,oldstr3830->len);
+memcpy(_SUB_WRITEBUFLINE_STRING_TEXT->chr,oldstr3837->chr,oldstr3837->len);
 }
 int32 *_SUB_WRITEBUFLINE_LONG_BUF=NULL;
 if(_SUB_WRITEBUFLINE_LONG_BUF==NULL){
@ -50,15 +50,15 @@ if(_SUB_WRITEBUFLINE_LONG_EXT==NULL){
 _SUB_WRITEBUFLINE_LONG_EXT=(int32*)mem_static_malloc(4);
 *_SUB_WRITEBUFLINE_LONG_EXT=0;
 }
-byte_element_struct *byte_element_3831=NULL;
-if (!byte_element_3831){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3831=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3831=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3838=NULL;
+if (!byte_element_3838){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3838=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3838=(byte_element_struct*)mem_static_malloc(12);
 }
-byte_element_struct *byte_element_3832=NULL;
-if (!byte_element_3832){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3832=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3832=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3839=NULL;
+if (!byte_element_3839){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3839=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3839=(byte_element_struct*)mem_static_malloc(12);
 }
-byte_element_struct *byte_element_3833=NULL;
-if (!byte_element_3833){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3833=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3833=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3840=NULL;
+if (!byte_element_3840){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3840=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3840=(byte_element_struct*)mem_static_malloc(12);
 }
--- a/internal/source/data137.txt
+++ b/internal/source/data137.txt
@ -30,7 +30,7 @@ if(_SUB_DELETEBUFLINE_LONG_CHG==NULL){
 _SUB_DELETEBUFLINE_LONG_CHG=(int32*)mem_static_malloc(4);
 *_SUB_DELETEBUFLINE_LONG_CHG=0;
 }
-byte_element_struct *byte_element_3835=NULL;
-if (!byte_element_3835){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3835=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3835=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3842=NULL;
+if (!byte_element_3842){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3842=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3842=(byte_element_struct*)mem_static_malloc(12);
 }
--- a/internal/source/data139.txt
+++ b/internal/source/data139.txt
@ -1,12 +1,12 @@
-qbs*oldstr3836=NULL;
+qbs*oldstr3843=NULL;
 if(_SUB_WRITEBUFRAWDATA_STRING_RAWDATA->tmp||_SUB_WRITEBUFRAWDATA_STRING_RAWDATA->fixed||_SUB_WRITEBUFRAWDATA_STRING_RAWDATA->readonly){
-oldstr3836=_SUB_WRITEBUFRAWDATA_STRING_RAWDATA;
-if (oldstr3836->cmem_descriptor){
-_SUB_WRITEBUFRAWDATA_STRING_RAWDATA=qbs_new_cmem(oldstr3836->len,0);
+oldstr3843=_SUB_WRITEBUFRAWDATA_STRING_RAWDATA;
+if (oldstr3843->cmem_descriptor){
+_SUB_WRITEBUFRAWDATA_STRING_RAWDATA=qbs_new_cmem(oldstr3843->len,0);
 }else{
-_SUB_WRITEBUFRAWDATA_STRING_RAWDATA=qbs_new(oldstr3836->len,0);
+_SUB_WRITEBUFRAWDATA_STRING_RAWDATA=qbs_new(oldstr3843->len,0);
 }
-memcpy(_SUB_WRITEBUFRAWDATA_STRING_RAWDATA->chr,oldstr3836->chr,oldstr3836->len);
+memcpy(_SUB_WRITEBUFRAWDATA_STRING_RAWDATA->chr,oldstr3843->chr,oldstr3843->len);
 }
 int32 *_SUB_WRITEBUFRAWDATA_LONG_BUF=NULL;
 if(_SUB_WRITEBUFRAWDATA_LONG_BUF==NULL){
@ -38,11 +38,11 @@ if(_SUB_WRITEBUFRAWDATA_LONG_EXT==NULL){
 _SUB_WRITEBUFRAWDATA_LONG_EXT=(int32*)mem_static_malloc(4);
 *_SUB_WRITEBUFRAWDATA_LONG_EXT=0;
 }
-byte_element_struct *byte_element_3837=NULL;
-if (!byte_element_3837){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3837=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3837=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3844=NULL;
+if (!byte_element_3844){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3844=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3844=(byte_element_struct*)mem_static_malloc(12);
 }
-byte_element_struct *byte_element_3838=NULL;
-if (!byte_element_3838){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3838=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3838=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3845=NULL;
+if (!byte_element_3845){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3845=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3845=(byte_element_struct*)mem_static_malloc(12);
 }
--- a/internal/source/data14.txt
+++ b/internal/source/data14.txt
@ -1,33 +1,33 @@
-int16 pass2377;
-int16 pass2378;
-int16 pass2379;
+int16 pass2383;
+int16 pass2384;
+int16 pass2385;
 int32 *_SUB_CLOSEMAIN_LONG_I=NULL;
 if(_SUB_CLOSEMAIN_LONG_I==NULL){
 _SUB_CLOSEMAIN_LONG_I=(int32*)mem_static_malloc(4);
 *_SUB_CLOSEMAIN_LONG_I=0;
 }
-int64 fornext_value2381;
-int64 fornext_finalvalue2381;
-int64 fornext_step2381;
-uint8 fornext_step_negative2381;
-int16 pass2382;
-int16 pass2383;
-int16 pass2384;
-int16 pass2385;
-int16 pass2386;
-int16 pass2387;
+int64 fornext_value2387;
+int64 fornext_finalvalue2387;
+int64 fornext_step2387;
+uint8 fornext_step_negative2387;
 int16 pass2388;
 int16 pass2389;
 int16 pass2390;
-int64 fornext_value2392;
-int64 fornext_finalvalue2392;
-int64 fornext_step2392;
-uint8 fornext_step_negative2392;
+int16 pass2391;
+int16 pass2392;
 int16 pass2393;
 int16 pass2394;
 int16 pass2395;
 int16 pass2396;
-int16 pass2397;
-int16 pass2398;
+int64 fornext_value2398;
+int64 fornext_finalvalue2398;
+int64 fornext_step2398;
+uint8 fornext_step_negative2398;
 int16 pass2399;
 int16 pass2400;
+int16 pass2401;
+int16 pass2402;
+int16 pass2403;
+int16 pass2404;
+int16 pass2405;
+int16 pass2406;
--- a/internal/source/data140.txt
+++ b/internal/source/data140.txt
@ -35,7 +35,7 @@ if(_FUNC_SEEKBUF_LONG_NEWPOS==NULL){
 _FUNC_SEEKBUF_LONG_NEWPOS=(int32*)mem_static_malloc(4);
 *_FUNC_SEEKBUF_LONG_NEWPOS=0;
 }
-byte_element_struct *byte_element_3840=NULL;
-if (!byte_element_3840){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3840=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3840=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_3847=NULL;
+if (!byte_element_3847){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_3847=(byte_element_struct*)(mem_static_pointer-12); else byte_element_3847=(byte_element_struct*)mem_static_malloc(12);
 }
--- a/internal/source/data145.txt
+++ b/internal/source/data145.txt
@ -5,4 +5,4 @@ if(_FUNC_BUFEOLSEQ_LONG_BUF==NULL){
 _FUNC_BUFEOLSEQ_LONG_BUF=(int32*)mem_static_malloc(4);
 *_FUNC_BUFEOLSEQ_LONG_BUF=0;
 }
-static qbs *sc_3842=qbs_new(0,0);
+static qbs *sc_3849=qbs_new(0,0);
--- a/internal/source/data146.txt
+++ b/internal/source/data146.txt
@ -3,25 +3,25 @@ if(_FUNC_OPENBUFFER_INTEGER_OPENBUFFER==NULL){
 _FUNC_OPENBUFFER_INTEGER_OPENBUFFER=(int16*)mem_static_malloc(2);
 *_FUNC_OPENBUFFER_INTEGER_OPENBUFFER=0;
 }
-qbs*oldstr3843=NULL;
+qbs*oldstr3850=NULL;
 if(_FUNC_OPENBUFFER_STRING_SBMODE->tmp||_FUNC_OPENBUFFER_STRING_SBMODE->fixed||_FUNC_OPENBUFFER_STRING_SBMODE->readonly){
-oldstr3843=_FUNC_OPENBUFFER_STRING_SBMODE;
-if (oldstr3843->cmem_descriptor){
-_FUNC_OPENBUFFER_STRING_SBMODE=qbs_new_cmem(oldstr3843->len,0);
+oldstr3850=_FUNC_OPENBUFFER_STRING_SBMODE;
+if (oldstr3850->cmem_descriptor){
+_FUNC_OPENBUFFER_STRING_SBMODE=qbs_new_cmem(oldstr3850->len,0);
 }else{
-_FUNC_OPENBUFFER_STRING_SBMODE=qbs_new(oldstr3843->len,0);
+_FUNC_OPENBUFFER_STRING_SBMODE=qbs_new(oldstr3850->len,0);
 }
-memcpy(_FUNC_OPENBUFFER_STRING_SBMODE->chr,oldstr3843->chr,oldstr3843->len);
+memcpy(_FUNC_OPENBUFFER_STRING_SBMODE->chr,oldstr3850->chr,oldstr3850->len);
 }
-qbs*oldstr3844=NULL;
+qbs*oldstr3851=NULL;
 if(_FUNC_OPENBUFFER_STRING_SBNAME->tmp||_FUNC_OPENBUFFER_STRING_SBNAME->fixed||_FUNC_OPENBUFFER_STRING_SBNAME->readonly){
-oldstr3844=_FUNC_OPENBUFFER_STRING_SBNAME;
-if (oldstr3844->cmem_descriptor){
-_FUNC_OPENBUFFER_STRING_SBNAME=qbs_new_cmem(oldstr3844->len,0);
+oldstr3851=_FUNC_OPENBUFFER_STRING_SBNAME;
+if (oldstr3851->cmem_descriptor){
+_FUNC_OPENBUFFER_STRING_SBNAME=qbs_new_cmem(oldstr3851->len,0);
 }else{
-_FUNC_OPENBUFFER_STRING_SBNAME=qbs_new(oldstr3844->len,0);
+_FUNC_OPENBUFFER_STRING_SBNAME=qbs_new(oldstr3851->len,0);
 }
-memcpy(_FUNC_OPENBUFFER_STRING_SBNAME->chr,oldstr3844->chr,oldstr3844->len);
+memcpy(_FUNC_OPENBUFFER_STRING_SBNAME->chr,oldstr3851->chr,oldstr3851->len);
 }
 int16 *_FUNC_OPENBUFFER_INTEGER_BUF=NULL;
 if(_FUNC_OPENBUFFER_INTEGER_BUF==NULL){
@ -33,14 +33,14 @@ if(_FUNC_OPENBUFFER_LONG_NUL==NULL){
 _FUNC_OPENBUFFER_LONG_NUL=(int32*)mem_static_malloc(4);
 *_FUNC_OPENBUFFER_LONG_NUL=0;
 }
-int32 fornext_value3846;
-int32 fornext_finalvalue3846;
-int32 fornext_step3846;
-uint8 fornext_step_negative3846;
-static qbs *sc_3847=qbs_new(0,0);
-int32 pass3848;
-int16 pass3849;
-int32 pass3850;
-int16 pass3851;
-int32 pass3852;
-int16 pass3853;
+int32 fornext_value3853;
+int32 fornext_finalvalue3853;
+int32 fornext_step3853;
+uint8 fornext_step_negative3853;
+static qbs *sc_3854=qbs_new(0,0);
+int32 pass3855;
+int16 pass3856;
+int32 pass3857;
+int16 pass3858;
+int32 pass3859;
+int16 pass3860;
--- a/internal/source/data147.txt
+++ b/internal/source/data147.txt
@ -1,23 +1,23 @@
-qbs*oldstr3854=NULL;
+qbs*oldstr3861=NULL;
 if(_SUB_CLEARBUFFERS_STRING_SBNAME->tmp||_SUB_CLEARBUFFERS_STRING_SBNAME->fixed||_SUB_CLEARBUFFERS_STRING_SBNAME->readonly){
-oldstr3854=_SUB_CLEARBUFFERS_STRING_SBNAME;
-if (oldstr3854->cmem_descriptor){
-_SUB_CLEARBUFFERS_STRING_SBNAME=qbs_new_cmem(oldstr3854->len,0);
+oldstr3861=_SUB_CLEARBUFFERS_STRING_SBNAME;
+if (oldstr3861->cmem_descriptor){
+_SUB_CLEARBUFFERS_STRING_SBNAME=qbs_new_cmem(oldstr3861->len,0);
 }else{
-_SUB_CLEARBUFFERS_STRING_SBNAME=qbs_new(oldstr3854->len,0);
+_SUB_CLEARBUFFERS_STRING_SBNAME=qbs_new(oldstr3861->len,0);
 }
-memcpy(_SUB_CLEARBUFFERS_STRING_SBNAME->chr,oldstr3854->chr,oldstr3854->len);
+memcpy(_SUB_CLEARBUFFERS_STRING_SBNAME->chr,oldstr3861->chr,oldstr3861->len);
 }
 int16 *_SUB_CLEARBUFFERS_INTEGER_BUF=NULL;
 if(_SUB_CLEARBUFFERS_INTEGER_BUF==NULL){
 _SUB_CLEARBUFFERS_INTEGER_BUF=(int16*)mem_static_malloc(2);
 *_SUB_CLEARBUFFERS_INTEGER_BUF=0;
 }
-int32 fornext_value3856;
-int32 fornext_finalvalue3856;
-int32 fornext_step3856;
-uint8 fornext_step_negative3856;
-int32 fornext_value3858;
-int32 fornext_finalvalue3858;
-int32 fornext_step3858;
-uint8 fornext_step_negative3858;
+int32 fornext_value3863;
+int32 fornext_finalvalue3863;
+int32 fornext_step3863;
+uint8 fornext_step_negative3863;
+int32 fornext_value3865;
+int32 fornext_finalvalue3865;
+int32 fornext_step3865;
+uint8 fornext_step_negative3865;
--- a/internal/source/data148.txt
+++ b/internal/source/data148.txt
@ -1,23 +1,23 @@
-qbs*oldstr3859=NULL;
+qbs*oldstr3866=NULL;
 if(_SUB_WRITEBUFFERS_STRING_SBNAME->tmp||_SUB_WRITEBUFFERS_STRING_SBNAME->fixed||_SUB_WRITEBUFFERS_STRING_SBNAME->readonly){
-oldstr3859=_SUB_WRITEBUFFERS_STRING_SBNAME;
-if (oldstr3859->cmem_descriptor){
-_SUB_WRITEBUFFERS_STRING_SBNAME=qbs_new_cmem(oldstr3859->len,0);
+oldstr3866=_SUB_WRITEBUFFERS_STRING_SBNAME;
+if (oldstr3866->cmem_descriptor){
+_SUB_WRITEBUFFERS_STRING_SBNAME=qbs_new_cmem(oldstr3866->len,0);
 }else{
-_SUB_WRITEBUFFERS_STRING_SBNAME=qbs_new(oldstr3859->len,0);
+_SUB_WRITEBUFFERS_STRING_SBNAME=qbs_new(oldstr3866->len,0);
 }
-memcpy(_SUB_WRITEBUFFERS_STRING_SBNAME->chr,oldstr3859->chr,oldstr3859->len);
+memcpy(_SUB_WRITEBUFFERS_STRING_SBNAME->chr,oldstr3866->chr,oldstr3866->len);
 }
 int16 *_SUB_WRITEBUFFERS_INTEGER_BUF=NULL;
 if(_SUB_WRITEBUFFERS_INTEGER_BUF==NULL){
 _SUB_WRITEBUFFERS_INTEGER_BUF=(int16*)mem_static_malloc(2);
 *_SUB_WRITEBUFFERS_INTEGER_BUF=0;
 }
-int32 fornext_value3861;
-int32 fornext_finalvalue3861;
-int32 fornext_step3861;
-uint8 fornext_step_negative3861;
-int32 fornext_value3863;
-int32 fornext_finalvalue3863;
-int32 fornext_step3863;
-uint8 fornext_step_negative3863;
+int32 fornext_value3868;
+int32 fornext_finalvalue3868;
+int32 fornext_step3868;
+uint8 fornext_step_negative3868;
+int32 fornext_value3870;
+int32 fornext_finalvalue3870;
+int32 fornext_step3870;
+uint8 fornext_step_negative3870;
--- a/internal/source/data149.txt
+++ b/internal/source/data149.txt
@ -1,14 +1,14 @@
 qbs *_FUNC_EVALUATE_EXPRESSION_STRING_EVALUATE_EXPRESSION=NULL;
 if (!_FUNC_EVALUATE_EXPRESSION_STRING_EVALUATE_EXPRESSION)_FUNC_EVALUATE_EXPRESSION_STRING_EVALUATE_EXPRESSION=qbs_new(0,0);
-qbs*oldstr3864=NULL;
+qbs*oldstr3871=NULL;
 if(_FUNC_EVALUATE_EXPRESSION_STRING_E->tmp||_FUNC_EVALUATE_EXPRESSION_STRING_E->fixed||_FUNC_EVALUATE_EXPRESSION_STRING_E->readonly){
-oldstr3864=_FUNC_EVALUATE_EXPRESSION_STRING_E;
-if (oldstr3864->cmem_descriptor){
-_FUNC_EVALUATE_EXPRESSION_STRING_E=qbs_new_cmem(oldstr3864->len,0);
+oldstr3871=_FUNC_EVALUATE_EXPRESSION_STRING_E;
+if (oldstr3871->cmem_descriptor){
+_FUNC_EVALUATE_EXPRESSION_STRING_E=qbs_new_cmem(oldstr3871->len,0);
 }else{
-_FUNC_EVALUATE_EXPRESSION_STRING_E=qbs_new(oldstr3864->len,0);
+_FUNC_EVALUATE_EXPRESSION_STRING_E=qbs_new(oldstr3871->len,0);
 }
-memcpy(_FUNC_EVALUATE_EXPRESSION_STRING_E->chr,oldstr3864->chr,oldstr3864->len);
+memcpy(_FUNC_EVALUATE_EXPRESSION_STRING_E->chr,oldstr3871->chr,oldstr3871->len);
 }
 qbs *_FUNC_EVALUATE_EXPRESSION_STRING_T=NULL;
 if (!_FUNC_EVALUATE_EXPRESSION_STRING_T)_FUNC_EVALUATE_EXPRESSION_STRING_T=qbs_new(0,0);
@ -26,19 +26,19 @@ _FUNC_EVALUATE_EXPRESSION_LONG_C=(int32*)mem_static_malloc(4);
 }
 qbs *_FUNC_EVALUATE_EXPRESSION_STRING_EVAL=NULL;
 if (!_FUNC_EVALUATE_EXPRESSION_STRING_EVAL)_FUNC_EVALUATE_EXPRESSION_STRING_EVAL=qbs_new(0,0);
-int32 pass3866;
-int32 pass3867;
+int32 pass3873;
+int32 pass3874;
 int32 *_FUNC_EVALUATE_EXPRESSION_LONG_FUNCOP=NULL;
 if(_FUNC_EVALUATE_EXPRESSION_LONG_FUNCOP==NULL){
 _FUNC_EVALUATE_EXPRESSION_LONG_FUNCOP=(int32*)mem_static_malloc(4);
 *_FUNC_EVALUATE_EXPRESSION_LONG_FUNCOP=0;
 }
-int32 pass3868;
+int32 pass3875;
 qbs *_FUNC_EVALUATE_EXPRESSION_STRING_LEFTELE=NULL;
 if (!_FUNC_EVALUATE_EXPRESSION_STRING_LEFTELE)_FUNC_EVALUATE_EXPRESSION_STRING_LEFTELE=qbs_new(0,0);
-int32 pass3869;
-int32 pass3870;
+int32 pass3876;
+int32 pass3877;
 qbs *_FUNC_EVALUATE_EXPRESSION_STRING_RIGHTELE=NULL;
 if (!_FUNC_EVALUATE_EXPRESSION_STRING_RIGHTELE)_FUNC_EVALUATE_EXPRESSION_STRING_RIGHTELE=qbs_new(0,0);
-int32 pass3871;
-int32 pass3872;
+int32 pass3878;
+int32 pass3879;
--- a/internal/source/data15.txt
+++ b/internal/source/data15.txt
@ -3,15 +3,15 @@ if(_FUNC_COUNTELEMENTS_LONG_COUNTELEMENTS==NULL){
 _FUNC_COUNTELEMENTS_LONG_COUNTELEMENTS=(int32*)mem_static_malloc(4);
 *_FUNC_COUNTELEMENTS_LONG_COUNTELEMENTS=0;
 }
-qbs*oldstr2401=NULL;
+qbs*oldstr2407=NULL;
 if(_FUNC_COUNTELEMENTS_STRING_A->tmp||_FUNC_COUNTELEMENTS_STRING_A->fixed||_FUNC_COUNTELEMENTS_STRING_A->readonly){
-oldstr2401=_FUNC_COUNTELEMENTS_STRING_A;
-if (oldstr2401->cmem_descriptor){
-_FUNC_COUNTELEMENTS_STRING_A=qbs_new_cmem(oldstr2401->len,0);
+oldstr2407=_FUNC_COUNTELEMENTS_STRING_A;
+if (oldstr2407->cmem_descriptor){
+_FUNC_COUNTELEMENTS_STRING_A=qbs_new_cmem(oldstr2407->len,0);
 }else{
-_FUNC_COUNTELEMENTS_STRING_A=qbs_new(oldstr2401->len,0);
+_FUNC_COUNTELEMENTS_STRING_A=qbs_new(oldstr2407->len,0);
 }
-memcpy(_FUNC_COUNTELEMENTS_STRING_A->chr,oldstr2401->chr,oldstr2401->len);
+memcpy(_FUNC_COUNTELEMENTS_STRING_A->chr,oldstr2407->chr,oldstr2407->len);
 }
 int32 *_FUNC_COUNTELEMENTS_LONG_N=NULL;
 if(_FUNC_COUNTELEMENTS_LONG_N==NULL){
@ -28,10 +28,10 @@ if(_FUNC_COUNTELEMENTS_LONG_I==NULL){
 _FUNC_COUNTELEMENTS_LONG_I=(int32*)mem_static_malloc(4);
 *_FUNC_COUNTELEMENTS_LONG_I=0;
 }
-int64 fornext_value2403;
-int64 fornext_finalvalue2403;
-int64 fornext_step2403;
-uint8 fornext_step_negative2403;
+int64 fornext_value2409;
+int64 fornext_finalvalue2409;
+int64 fornext_step2409;
+uint8 fornext_step_negative2409;
 qbs *_FUNC_COUNTELEMENTS_STRING_E=NULL;
 if (!_FUNC_COUNTELEMENTS_STRING_E)_FUNC_COUNTELEMENTS_STRING_E=qbs_new(0,0);
 int32 *_FUNC_COUNTELEMENTS_LONG_B=NULL;
--- a/internal/source/data150.txt
+++ b/internal/source/data150.txt
@ -1,12 +1,12 @@
-qbs*oldstr3873=NULL;
+qbs*oldstr3880=NULL;
 if(_SUB_FINDINNERPARENS_STRING_EXP->tmp||_SUB_FINDINNERPARENS_STRING_EXP->fixed||_SUB_FINDINNERPARENS_STRING_EXP->readonly){
-oldstr3873=_SUB_FINDINNERPARENS_STRING_EXP;
-if (oldstr3873->cmem_descriptor){
-_SUB_FINDINNERPARENS_STRING_EXP=qbs_new_cmem(oldstr3873->len,0);
+oldstr3880=_SUB_FINDINNERPARENS_STRING_EXP;
+if (oldstr3880->cmem_descriptor){
+_SUB_FINDINNERPARENS_STRING_EXP=qbs_new_cmem(oldstr3880->len,0);
 }else{
-_SUB_FINDINNERPARENS_STRING_EXP=qbs_new(oldstr3873->len,0);
+_SUB_FINDINNERPARENS_STRING_EXP=qbs_new(oldstr3880->len,0);
 }
-memcpy(_SUB_FINDINNERPARENS_STRING_EXP->chr,oldstr3873->chr,oldstr3873->len);
+memcpy(_SUB_FINDINNERPARENS_STRING_EXP->chr,oldstr3880->chr,oldstr3880->len);
 }
 int32 *_SUB_FINDINNERPARENS_LONG_STRINDEX=NULL;
 if(_SUB_FINDINNERPARENS_LONG_STRINDEX==NULL){
--- a/internal/source/data151.txt
+++ b/internal/source/data151.txt
@ -3,15 +3,15 @@ if(_FUNC_COMMAEXPRESSION_LONG_COMMAEXPRESSION==NULL){
 _FUNC_COMMAEXPRESSION_LONG_COMMAEXPRESSION=(int32*)mem_static_malloc(4);
 *_FUNC_COMMAEXPRESSION_LONG_COMMAEXPRESSION=0;
 }
-qbs*oldstr3876=NULL;
+qbs*oldstr3883=NULL;
 if(_FUNC_COMMAEXPRESSION_STRING_EXP->tmp||_FUNC_COMMAEXPRESSION_STRING_EXP->fixed||_FUNC_COMMAEXPRESSION_STRING_EXP->readonly){
-oldstr3876=_FUNC_COMMAEXPRESSION_STRING_EXP;
-if (oldstr3876->cmem_descriptor){
-_FUNC_COMMAEXPRESSION_STRING_EXP=qbs_new_cmem(oldstr3876->len,0);
+oldstr3883=_FUNC_COMMAEXPRESSION_STRING_EXP;
+if (oldstr3883->cmem_descriptor){
+_FUNC_COMMAEXPRESSION_STRING_EXP=qbs_new_cmem(oldstr3883->len,0);
 }else{
-_FUNC_COMMAEXPRESSION_STRING_EXP=qbs_new(oldstr3876->len,0);
+_FUNC_COMMAEXPRESSION_STRING_EXP=qbs_new(oldstr3883->len,0);
 }
-memcpy(_FUNC_COMMAEXPRESSION_STRING_EXP->chr,oldstr3876->chr,oldstr3876->len);
+memcpy(_FUNC_COMMAEXPRESSION_STRING_EXP->chr,oldstr3883->chr,oldstr3883->len);
 }
 qbs *_FUNC_COMMAEXPRESSION_STRING_ELE=NULL;
 if (!_FUNC_COMMAEXPRESSION_STRING_ELE)_FUNC_COMMAEXPRESSION_STRING_ELE=qbs_new(0,0);
--- a/internal/source/data152.txt
+++ b/internal/source/data152.txt
@ -3,15 +3,15 @@ if(_FUNC_STREXPRESSION_LONG_STREXPRESSION==NULL){
 _FUNC_STREXPRESSION_LONG_STREXPRESSION=(int32*)mem_static_malloc(4);
 *_FUNC_STREXPRESSION_LONG_STREXPRESSION=0;
 }
-qbs*oldstr3878=NULL;
+qbs*oldstr3885=NULL;
 if(_FUNC_STREXPRESSION_STRING_EXP->tmp||_FUNC_STREXPRESSION_STRING_EXP->fixed||_FUNC_STREXPRESSION_STRING_EXP->readonly){
-oldstr3878=_FUNC_STREXPRESSION_STRING_EXP;
-if (oldstr3878->cmem_descriptor){
-_FUNC_STREXPRESSION_STRING_EXP=qbs_new_cmem(oldstr3878->len,0);
+oldstr3885=_FUNC_STREXPRESSION_STRING_EXP;
+if (oldstr3885->cmem_descriptor){
+_FUNC_STREXPRESSION_STRING_EXP=qbs_new_cmem(oldstr3885->len,0);
 }else{
-_FUNC_STREXPRESSION_STRING_EXP=qbs_new(oldstr3878->len,0);
+_FUNC_STREXPRESSION_STRING_EXP=qbs_new(oldstr3885->len,0);
 }
-memcpy(_FUNC_STREXPRESSION_STRING_EXP->chr,oldstr3878->chr,oldstr3878->len);
+memcpy(_FUNC_STREXPRESSION_STRING_EXP->chr,oldstr3885->chr,oldstr3885->len);
 }
 qbs *_FUNC_STREXPRESSION_STRING_S=NULL;
 if (!_FUNC_STREXPRESSION_STRING_S)_FUNC_STREXPRESSION_STRING_S=qbs_new(0,0);
--- a/internal/source/data153.txt
+++ b/internal/source/data153.txt
@ -3,15 +3,15 @@ if(_FUNC_PARSESTRING_LONG_PARSESTRING==NULL){
 _FUNC_PARSESTRING_LONG_PARSESTRING=(int32*)mem_static_malloc(4);
 *_FUNC_PARSESTRING_LONG_PARSESTRING=0;
 }
-qbs*oldstr3880=NULL;
+qbs*oldstr3887=NULL;
 if(_FUNC_PARSESTRING_STRING_EXP->tmp||_FUNC_PARSESTRING_STRING_EXP->fixed||_FUNC_PARSESTRING_STRING_EXP->readonly){
-oldstr3880=_FUNC_PARSESTRING_STRING_EXP;
-if (oldstr3880->cmem_descriptor){
-_FUNC_PARSESTRING_STRING_EXP=qbs_new_cmem(oldstr3880->len,0);
+oldstr3887=_FUNC_PARSESTRING_STRING_EXP;
+if (oldstr3887->cmem_descriptor){
+_FUNC_PARSESTRING_STRING_EXP=qbs_new_cmem(oldstr3887->len,0);
 }else{
-_FUNC_PARSESTRING_STRING_EXP=qbs_new(oldstr3880->len,0);
+_FUNC_PARSESTRING_STRING_EXP=qbs_new(oldstr3887->len,0);
 }
-memcpy(_FUNC_PARSESTRING_STRING_EXP->chr,oldstr3880->chr,oldstr3880->len);
+memcpy(_FUNC_PARSESTRING_STRING_EXP->chr,oldstr3887->chr,oldstr3887->len);
 }
 qbs *_FUNC_PARSESTRING_STRING_ELE=NULL;
 if (!_FUNC_PARSESTRING_STRING_ELE)_FUNC_PARSESTRING_STRING_ELE=qbs_new(0,0);
--- a/internal/source/data154.txt
+++ b/internal/source/data154.txt
@ -3,13 +3,13 @@ if(_FUNC_NUMERICEXPRESSION_LONG_NUMERICEXPRESSION==NULL){
 _FUNC_NUMERICEXPRESSION_LONG_NUMERICEXPRESSION=(int32*)mem_static_malloc(4);
 *_FUNC_NUMERICEXPRESSION_LONG_NUMERICEXPRESSION=0;
 }
-qbs*oldstr3881=NULL;
+qbs*oldstr3888=NULL;
 if(_FUNC_NUMERICEXPRESSION_STRING_EXP->tmp||_FUNC_NUMERICEXPRESSION_STRING_EXP->fixed||_FUNC_NUMERICEXPRESSION_STRING_EXP->readonly){
-oldstr3881=_FUNC_NUMERICEXPRESSION_STRING_EXP;
-if (oldstr3881->cmem_descriptor){
-_FUNC_NUMERICEXPRESSION_STRING_EXP=qbs_new_cmem(oldstr3881->len,0);
+oldstr3888=_FUNC_NUMERICEXPRESSION_STRING_EXP;
+if (oldstr3888->cmem_descriptor){
+_FUNC_NUMERICEXPRESSION_STRING_EXP=qbs_new_cmem(oldstr3888->len,0);
 }else{
-_FUNC_NUMERICEXPRESSION_STRING_EXP=qbs_new(oldstr3881->len,0);
+_FUNC_NUMERICEXPRESSION_STRING_EXP=qbs_new(oldstr3888->len,0);
 }
-memcpy(_FUNC_NUMERICEXPRESSION_STRING_EXP->chr,oldstr3881->chr,oldstr3881->len);
+memcpy(_FUNC_NUMERICEXPRESSION_STRING_EXP->chr,oldstr3888->chr,oldstr3888->len);
 }
--- a/internal/source/data155.txt
+++ b/internal/source/data155.txt
@ -3,15 +3,15 @@ if(_FUNC_LOGICALIMP_LONG_LOGICALIMP==NULL){
 _FUNC_LOGICALIMP_LONG_LOGICALIMP=(int32*)mem_static_malloc(4);
 *_FUNC_LOGICALIMP_LONG_LOGICALIMP=0;
 }
-qbs*oldstr3882=NULL;
+qbs*oldstr3889=NULL;
 if(_FUNC_LOGICALIMP_STRING_EXP->tmp||_FUNC_LOGICALIMP_STRING_EXP->fixed||_FUNC_LOGICALIMP_STRING_EXP->readonly){
-oldstr3882=_FUNC_LOGICALIMP_STRING_EXP;
-if (oldstr3882->cmem_descriptor){
-_FUNC_LOGICALIMP_STRING_EXP=qbs_new_cmem(oldstr3882->len,0);
+oldstr3889=_FUNC_LOGICALIMP_STRING_EXP;
+if (oldstr3889->cmem_descriptor){
+_FUNC_LOGICALIMP_STRING_EXP=qbs_new_cmem(oldstr3889->len,0);
 }else{
-_FUNC_LOGICALIMP_STRING_EXP=qbs_new(oldstr3882->len,0);
+_FUNC_LOGICALIMP_STRING_EXP=qbs_new(oldstr3889->len,0);
 }
-memcpy(_FUNC_LOGICALIMP_STRING_EXP->chr,oldstr3882->chr,oldstr3882->len);
+memcpy(_FUNC_LOGICALIMP_STRING_EXP->chr,oldstr3889->chr,oldstr3889->len);
 }
 void *_FUNC_LOGICALIMP_UDT_NUM=NULL;
 if(_FUNC_LOGICALIMP_UDT_NUM==NULL){
@ -21,7 +21,7 @@ memset(_FUNC_LOGICALIMP_UDT_NUM,0,60);
 }
 qbs *_FUNC_LOGICALIMP_STRING_ELE=NULL;
 if (!_FUNC_LOGICALIMP_STRING_ELE)_FUNC_LOGICALIMP_STRING_ELE=qbs_new(0,0);
-int32 pass3884;
-uint64 pass3885;
-int32 pass3886;
-int64 pass3887;
+int32 pass3891;
+uint64 pass3892;
+int32 pass3893;
+int64 pass3894;
--- a/internal/source/data156.txt
+++ b/internal/source/data156.txt
@ -3,15 +3,15 @@ if(_FUNC_LOGICALEQV_LONG_LOGICALEQV==NULL){
 _FUNC_LOGICALEQV_LONG_LOGICALEQV=(int32*)mem_static_malloc(4);
 *_FUNC_LOGICALEQV_LONG_LOGICALEQV=0;
 }
-qbs*oldstr3888=NULL;
+qbs*oldstr3895=NULL;
 if(_FUNC_LOGICALEQV_STRING_EXP->tmp||_FUNC_LOGICALEQV_STRING_EXP->fixed||_FUNC_LOGICALEQV_STRING_EXP->readonly){
-oldstr3888=_FUNC_LOGICALEQV_STRING_EXP;
-if (oldstr3888->cmem_descriptor){
-_FUNC_LOGICALEQV_STRING_EXP=qbs_new_cmem(oldstr3888->len,0);
+oldstr3895=_FUNC_LOGICALEQV_STRING_EXP;
+if (oldstr3895->cmem_descriptor){
+_FUNC_LOGICALEQV_STRING_EXP=qbs_new_cmem(oldstr3895->len,0);
 }else{
-_FUNC_LOGICALEQV_STRING_EXP=qbs_new(oldstr3888->len,0);
+_FUNC_LOGICALEQV_STRING_EXP=qbs_new(oldstr3895->len,0);
 }
-memcpy(_FUNC_LOGICALEQV_STRING_EXP->chr,oldstr3888->chr,oldstr3888->len);
+memcpy(_FUNC_LOGICALEQV_STRING_EXP->chr,oldstr3895->chr,oldstr3895->len);
 }
 void *_FUNC_LOGICALEQV_UDT_NUM=NULL;
 if(_FUNC_LOGICALEQV_UDT_NUM==NULL){
@ -21,7 +21,7 @@ memset(_FUNC_LOGICALEQV_UDT_NUM,0,60);
 }
 qbs *_FUNC_LOGICALEQV_STRING_ELE=NULL;
 if (!_FUNC_LOGICALEQV_STRING_ELE)_FUNC_LOGICALEQV_STRING_ELE=qbs_new(0,0);
-int32 pass3890;
-uint64 pass3891;
-int32 pass3892;
-int64 pass3893;
+int32 pass3897;
+uint64 pass3898;
+int32 pass3899;
+int64 pass3900;
--- a/internal/source/data157.txt
+++ b/internal/source/data157.txt
@ -3,15 +3,15 @@ if(_FUNC_LOGICALXOR_LONG_LOGICALXOR==NULL){
 _FUNC_LOGICALXOR_LONG_LOGICALXOR=(int32*)mem_static_malloc(4);
 *_FUNC_LOGICALXOR_LONG_LOGICALXOR=0;
 }
-qbs*oldstr3894=NULL;
+qbs*oldstr3901=NULL;
 if(_FUNC_LOGICALXOR_STRING_EXP->tmp||_FUNC_LOGICALXOR_STRING_EXP->fixed||_FUNC_LOGICALXOR_STRING_EXP->readonly){
-oldstr3894=_FUNC_LOGICALXOR_STRING_EXP;
-if (oldstr3894->cmem_descriptor){
-_FUNC_LOGICALXOR_STRING_EXP=qbs_new_cmem(oldstr3894->len,0);
+oldstr3901=_FUNC_LOGICALXOR_STRING_EXP;
+if (oldstr3901->cmem_descriptor){
+_FUNC_LOGICALXOR_STRING_EXP=qbs_new_cmem(oldstr3901->len,0);
 }else{
-_FUNC_LOGICALXOR_STRING_EXP=qbs_new(oldstr3894->len,0);
+_FUNC_LOGICALXOR_STRING_EXP=qbs_new(oldstr3901->len,0);
 }
-memcpy(_FUNC_LOGICALXOR_STRING_EXP->chr,oldstr3894->chr,oldstr3894->len);
+memcpy(_FUNC_LOGICALXOR_STRING_EXP->chr,oldstr3901->chr,oldstr3901->len);
 }
 void *_FUNC_LOGICALXOR_UDT_NUM=NULL;
 if(_FUNC_LOGICALXOR_UDT_NUM==NULL){
@ -21,7 +21,7 @@ memset(_FUNC_LOGICALXOR_UDT_NUM,0,60);
 }
 qbs *_FUNC_LOGICALXOR_STRING_ELE=NULL;
 if (!_FUNC_LOGICALXOR_STRING_ELE)_FUNC_LOGICALXOR_STRING_ELE=qbs_new(0,0);
-int32 pass3896;
-uint64 pass3897;
-int32 pass3898;
-int64 pass3899;
+int32 pass3903;
+uint64 pass3904;
+int32 pass3905;
+int64 pass3906;
--- a/internal/source/data158.txt
+++ b/internal/source/data158.txt
@ -3,15 +3,15 @@ if(_FUNC_LOGICALOR_LONG_LOGICALOR==NULL){
 _FUNC_LOGICALOR_LONG_LOGICALOR=(int32*)mem_static_malloc(4);
 *_FUNC_LOGICALOR_LONG_LOGICALOR=0;
 }
-qbs*oldstr3900=NULL;
+qbs*oldstr3907=NULL;
 if(_FUNC_LOGICALOR_STRING_EXP->tmp||_FUNC_LOGICALOR_STRING_EXP->fixed||_FUNC_LOGICALOR_STRING_EXP->readonly){
-oldstr3900=_FUNC_LOGICALOR_STRING_EXP;
-if (oldstr3900->cmem_descriptor){
-_FUNC_LOGICALOR_STRING_EXP=qbs_new_cmem(oldstr3900->len,0);
+oldstr3907=_FUNC_LOGICALOR_STRING_EXP;
+if (oldstr3907->cmem_descriptor){
+_FUNC_LOGICALOR_STRING_EXP=qbs_new_cmem(oldstr3907->len,0);
 }else{
-_FUNC_LOGICALOR_STRING_EXP=qbs_new(oldstr3900->len,0);
+_FUNC_LOGICALOR_STRING_EXP=qbs_new(oldstr3907->len,0);
 }
-memcpy(_FUNC_LOGICALOR_STRING_EXP->chr,oldstr3900->chr,oldstr3900->len);
+memcpy(_FUNC_LOGICALOR_STRING_EXP->chr,oldstr3907->chr,oldstr3907->len);
 }
 void *_FUNC_LOGICALOR_UDT_NUM=NULL;
 if(_FUNC_LOGICALOR_UDT_NUM==NULL){
@ -21,7 +21,7 @@ memset(_FUNC_LOGICALOR_UDT_NUM,0,60);
 }
 qbs *_FUNC_LOGICALOR_STRING_ELE=NULL;
 if (!_FUNC_LOGICALOR_STRING_ELE)_FUNC_LOGICALOR_STRING_ELE=qbs_new(0,0);
-int32 pass3902;
-uint64 pass3903;
-int32 pass3904;
-int64 pass3905;
+int32 pass3909;
+uint64 pass3910;
+int32 pass3911;
+int64 pass3912;
--- a/internal/source/data159.txt
+++ b/internal/source/data159.txt
@ -3,15 +3,15 @@ if(_FUNC_LOGICALAND_LONG_LOGICALAND==NULL){
 _FUNC_LOGICALAND_LONG_LOGICALAND=(int32*)mem_static_malloc(4);
 *_FUNC_LOGICALAND_LONG_LOGICALAND=0;
 }
-qbs*oldstr3906=NULL;
+qbs*oldstr3913=NULL;
 if(_FUNC_LOGICALAND_STRING_EXP->tmp||_FUNC_LOGICALAND_STRING_EXP->fixed||_FUNC_LOGICALAND_STRING_EXP->readonly){
-oldstr3906=_FUNC_LOGICALAND_STRING_EXP;
-if (oldstr3906->cmem_descriptor){
-_FUNC_LOGICALAND_STRING_EXP=qbs_new_cmem(oldstr3906->len,0);
+oldstr3913=_FUNC_LOGICALAND_STRING_EXP;
+if (oldstr3913->cmem_descriptor){
+_FUNC_LOGICALAND_STRING_EXP=qbs_new_cmem(oldstr3913->len,0);
 }else{
-_FUNC_LOGICALAND_STRING_EXP=qbs_new(oldstr3906->len,0);
+_FUNC_LOGICALAND_STRING_EXP=qbs_new(oldstr3913->len,0);
 }
-memcpy(_FUNC_LOGICALAND_STRING_EXP->chr,oldstr3906->chr,oldstr3906->len);
+memcpy(_FUNC_LOGICALAND_STRING_EXP->chr,oldstr3913->chr,oldstr3913->len);
 }
 void *_FUNC_LOGICALAND_UDT_NUM=NULL;
 if(_FUNC_LOGICALAND_UDT_NUM==NULL){
@ -21,7 +21,7 @@ memset(_FUNC_LOGICALAND_UDT_NUM,0,60);
 }
 qbs *_FUNC_LOGICALAND_STRING_ELE=NULL;
 if (!_FUNC_LOGICALAND_STRING_ELE)_FUNC_LOGICALAND_STRING_ELE=qbs_new(0,0);
-int32 pass3908;
-uint64 pass3909;
-int32 pass3910;
-int64 pass3911;
+int32 pass3915;
+uint64 pass3916;
+int32 pass3917;
+int64 pass3918;
--- a/internal/source/data16.txt
+++ b/internal/source/data16.txt
@ -3,35 +3,35 @@ if(_FUNC_DIM2_LONG_DIM2==NULL){
 _FUNC_DIM2_LONG_DIM2=(int32*)mem_static_malloc(4);
 *_FUNC_DIM2_LONG_DIM2=0;
 }
-qbs*oldstr2404=NULL;
+qbs*oldstr2410=NULL;
 if(_FUNC_DIM2_STRING_VARNAME->tmp||_FUNC_DIM2_STRING_VARNAME->fixed||_FUNC_DIM2_STRING_VARNAME->readonly){
-oldstr2404=_FUNC_DIM2_STRING_VARNAME;
-if (oldstr2404->cmem_descriptor){
-_FUNC_DIM2_STRING_VARNAME=qbs_new_cmem(oldstr2404->len,0);
+oldstr2410=_FUNC_DIM2_STRING_VARNAME;
+if (oldstr2410->cmem_descriptor){
+_FUNC_DIM2_STRING_VARNAME=qbs_new_cmem(oldstr2410->len,0);
 }else{
-_FUNC_DIM2_STRING_VARNAME=qbs_new(oldstr2404->len,0);
+_FUNC_DIM2_STRING_VARNAME=qbs_new(oldstr2410->len,0);
 }
-memcpy(_FUNC_DIM2_STRING_VARNAME->chr,oldstr2404->chr,oldstr2404->len);
+memcpy(_FUNC_DIM2_STRING_VARNAME->chr,oldstr2410->chr,oldstr2410->len);
 }
-qbs*oldstr2405=NULL;
+qbs*oldstr2411=NULL;
 if(_FUNC_DIM2_STRING_TYP2->tmp||_FUNC_DIM2_STRING_TYP2->fixed||_FUNC_DIM2_STRING_TYP2->readonly){
-oldstr2405=_FUNC_DIM2_STRING_TYP2;
-if (oldstr2405->cmem_descriptor){
-_FUNC_DIM2_STRING_TYP2=qbs_new_cmem(oldstr2405->len,0);
+oldstr2411=_FUNC_DIM2_STRING_TYP2;
+if (oldstr2411->cmem_descriptor){
+_FUNC_DIM2_STRING_TYP2=qbs_new_cmem(oldstr2411->len,0);
 }else{
-_FUNC_DIM2_STRING_TYP2=qbs_new(oldstr2405->len,0);
+_FUNC_DIM2_STRING_TYP2=qbs_new(oldstr2411->len,0);
 }
-memcpy(_FUNC_DIM2_STRING_TYP2->chr,oldstr2405->chr,oldstr2405->len);
+memcpy(_FUNC_DIM2_STRING_TYP2->chr,oldstr2411->chr,oldstr2411->len);
 }
-qbs*oldstr2406=NULL;
+qbs*oldstr2412=NULL;
 if(_FUNC_DIM2_STRING_ELEMENTS->tmp||_FUNC_DIM2_STRING_ELEMENTS->fixed||_FUNC_DIM2_STRING_ELEMENTS->readonly){
-oldstr2406=_FUNC_DIM2_STRING_ELEMENTS;
-if (oldstr2406->cmem_descriptor){
-_FUNC_DIM2_STRING_ELEMENTS=qbs_new_cmem(oldstr2406->len,0);
+oldstr2412=_FUNC_DIM2_STRING_ELEMENTS;
+if (oldstr2412->cmem_descriptor){
+_FUNC_DIM2_STRING_ELEMENTS=qbs_new_cmem(oldstr2412->len,0);
 }else{
-_FUNC_DIM2_STRING_ELEMENTS=qbs_new(oldstr2406->len,0);
+_FUNC_DIM2_STRING_ELEMENTS=qbs_new(oldstr2412->len,0);
 }
-memcpy(_FUNC_DIM2_STRING_ELEMENTS->chr,oldstr2406->chr,oldstr2406->len);
+memcpy(_FUNC_DIM2_STRING_ELEMENTS->chr,oldstr2412->chr,oldstr2412->len);
 }
 qbs *_FUNC_DIM2_STRING_TYP=NULL;
 if (!_FUNC_DIM2_STRING_TYP)_FUNC_DIM2_STRING_TYP=qbs_new(0,0);
@ -46,19 +46,19 @@ _FUNC_DIM2_LONG_F=(int32*)mem_static_malloc(4);
 }
 qbs *_FUNC_DIM2_STRING_SCOPE2=NULL;
 if (!_FUNC_DIM2_STRING_SCOPE2)_FUNC_DIM2_STRING_SCOPE2=qbs_new(0,0);
-byte_element_struct *byte_element_2408=NULL;
-if (!byte_element_2408){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2408=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2408=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_2414=NULL;
+if (!byte_element_2414){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2414=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2414=(byte_element_struct*)mem_static_malloc(12);
 }
 int32 *_FUNC_DIM2_LONG_I=NULL;
 if(_FUNC_DIM2_LONG_I==NULL){
 _FUNC_DIM2_LONG_I=(int32*)mem_static_malloc(4);
 *_FUNC_DIM2_LONG_I=0;
 }
-int64 fornext_value2410;
-int64 fornext_finalvalue2410;
-int64 fornext_step2410;
-uint8 fornext_step_negative2410;
+int64 fornext_value2416;
+int64 fornext_finalvalue2416;
+int64 fornext_step2416;
+uint8 fornext_step_negative2416;
 qbs *_FUNC_DIM2_STRING_N=NULL;
 if (!_FUNC_DIM2_STRING_N)_FUNC_DIM2_STRING_N=qbs_new(0,0);
 int32 *_FUNC_DIM2_LONG_TRY=NULL;
@ -71,53 +71,53 @@ if(_FUNC_DIM2_LONG_BITS==NULL){
 _FUNC_DIM2_LONG_BITS=(int32*)mem_static_malloc(4);
 *_FUNC_DIM2_LONG_BITS=0;
 }
-byte_element_struct *byte_element_2412=NULL;
-if (!byte_element_2412){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2412=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2412=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_2418=NULL;
+if (!byte_element_2418){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2418=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2418=(byte_element_struct*)mem_static_malloc(12);
 }
 int32 *_FUNC_DIM2_LONG_NUME=NULL;
 if(_FUNC_DIM2_LONG_NUME==NULL){
 _FUNC_DIM2_LONG_NUME=(int32*)mem_static_malloc(4);
 *_FUNC_DIM2_LONG_NUME=0;
 }
-int32 pass2413;
-int8 pass2414;
+int32 pass2419;
+int8 pass2420;
 int32 *_FUNC_DIM2_LONG_BYTES=NULL;
 if(_FUNC_DIM2_LONG_BYTES==NULL){
 _FUNC_DIM2_LONG_BYTES=(int32*)mem_static_malloc(4);
 *_FUNC_DIM2_LONG_BYTES=0;
 }
-int16 pass2415;
-int16 pass2416;
-int16 pass2417;
-int16 pass2418;
-int16 pass2419;
-int16 pass2420;
 int16 pass2421;
 int16 pass2422;
 int16 pass2423;
-int32 pass2424;
-int32 pass2425;
+int16 pass2424;
+int16 pass2425;
 int16 pass2426;
-int8 pass2427;
+int16 pass2427;
+int16 pass2428;
+int16 pass2429;
+int32 pass2430;
+int32 pass2431;
+int16 pass2432;
+int8 pass2433;
 int32 *_FUNC_DIM2_LONG_UNSGN=NULL;
 if(_FUNC_DIM2_LONG_UNSGN==NULL){
 _FUNC_DIM2_LONG_UNSGN=(int32*)mem_static_malloc(4);
 *_FUNC_DIM2_LONG_UNSGN=0;
 }
-byte_element_struct *byte_element_2428=NULL;
-if (!byte_element_2428){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2428=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2428=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_2434=NULL;
+if (!byte_element_2434){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2434=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2434=(byte_element_struct*)mem_static_malloc(12);
 }
-byte_element_struct *byte_element_2429=NULL;
-if (!byte_element_2429){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2429=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2429=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_2435=NULL;
+if (!byte_element_2435){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2435=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2435=(byte_element_struct*)mem_static_malloc(12);
 }
 qbs *_FUNC_DIM2_STRING_C=NULL;
 if (!_FUNC_DIM2_STRING_C)_FUNC_DIM2_STRING_C=qbs_new(0,0);
-byte_element_struct *byte_element_2430=NULL;
-if (!byte_element_2430){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2430=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2430=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_2436=NULL;
+if (!byte_element_2436){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2436=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2436=(byte_element_struct*)mem_static_malloc(12);
 }
 int32 *_FUNC_DIM2_LONG_HASHFOUND=NULL;
 if(_FUNC_DIM2_LONG_HASHFOUND==NULL){
@ -171,182 +171,182 @@ if(_FUNC_DIM2_UINTEGER64_V==NULL){
 _FUNC_DIM2_UINTEGER64_V=(uint64*)mem_static_malloc(8);
 *_FUNC_DIM2_UINTEGER64_V=0;
 }
-byte_element_struct *byte_element_2432=NULL;
-if (!byte_element_2432){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2432=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2432=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_2438=NULL;
+if (!byte_element_2438){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2438=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2438=(byte_element_struct*)mem_static_malloc(12);
 }
-byte_element_struct *byte_element_2434=NULL;
-if (!byte_element_2434){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2434=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2434=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_2440=NULL;
+if (!byte_element_2440){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2440=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2440=(byte_element_struct*)mem_static_malloc(12);
 }
-int32 pass2435;
-int8 pass2436;
-int16 pass2437;
-int16 pass2438;
-int16 pass2439;
-int16 pass2440;
-int16 pass2441;
-int16 pass2442;
+int32 pass2441;
+int8 pass2442;
 int16 pass2443;
 int16 pass2444;
-qbs *_FUNC_DIM2_STRING_O=NULL;
-if (!_FUNC_DIM2_STRING_O)_FUNC_DIM2_STRING_O=qbs_new(0,0);
 int16 pass2445;
 int16 pass2446;
 int16 pass2447;
-int8 pass2448;
-byte_element_struct *byte_element_2450=NULL;
-if (!byte_element_2450){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2450=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2450=(byte_element_struct*)mem_static_malloc(12);
+int16 pass2448;
+int16 pass2449;
+int16 pass2450;
+qbs *_FUNC_DIM2_STRING_O=NULL;
+if (!_FUNC_DIM2_STRING_O)_FUNC_DIM2_STRING_O=qbs_new(0,0);
+int16 pass2451;
+int16 pass2452;
+int16 pass2453;
+int8 pass2454;
+byte_element_struct *byte_element_2456=NULL;
+if (!byte_element_2456){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2456=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2456=(byte_element_struct*)mem_static_malloc(12);
 }
-int32 pass2451;
-int32 pass2452;
-int8 pass2453;
-int16 pass2454;
-int16 pass2455;
-int16 pass2456;
-int8 pass2457;
-byte_element_struct *byte_element_2458=NULL;
-if (!byte_element_2458){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2458=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2458=(byte_element_struct*)mem_static_malloc(12);
+int32 pass2457;
+int32 pass2458;
+int8 pass2459;
+int16 pass2460;
+int16 pass2461;
+int16 pass2462;
+int8 pass2463;
+byte_element_struct *byte_element_2464=NULL;
+if (!byte_element_2464){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2464=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2464=(byte_element_struct*)mem_static_malloc(12);
 }
-byte_element_struct *byte_element_2459=NULL;
-if (!byte_element_2459){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2459=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2459=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_2465=NULL;
+if (!byte_element_2465){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2465=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2465=(byte_element_struct*)mem_static_malloc(12);
 }
-byte_element_struct *byte_element_2460=NULL;
-if (!byte_element_2460){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2460=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2460=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_2466=NULL;
+if (!byte_element_2466){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2466=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2466=(byte_element_struct*)mem_static_malloc(12);
 }
 qbs *_FUNC_DIM2_STRING_CT=NULL;
 if (!_FUNC_DIM2_STRING_CT)_FUNC_DIM2_STRING_CT=qbs_new(0,0);
 qbs *_FUNC_DIM2_STRING_CMPS=NULL;
 if (!_FUNC_DIM2_STRING_CMPS)_FUNC_DIM2_STRING_CMPS=qbs_new(0,0);
-byte_element_struct *byte_element_2462=NULL;
-if (!byte_element_2462){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2462=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2462=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_2468=NULL;
+if (!byte_element_2468){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2468=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2468=(byte_element_struct*)mem_static_malloc(12);
 }
-int32 pass2463;
-int32 pass2464;
-int8 pass2465;
-int16 pass2466;
-int16 pass2467;
-int16 pass2468;
-int16 pass2469;
-int16 pass2470;
-int16 pass2471;
-int8 pass2472;
-byte_element_struct *byte_element_2474=NULL;
-if (!byte_element_2474){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2474=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2474=(byte_element_struct*)mem_static_malloc(12);
-}
-int32 pass2475;
-int32 pass2476;
+int32 pass2469;
+int32 pass2470;
+int8 pass2471;
+int16 pass2472;
+int16 pass2473;
+int16 pass2474;
+int16 pass2475;
+int16 pass2476;
 int16 pass2477;
-int16 pass2478;
-int16 pass2479;
-int16 pass2480;
-int16 pass2481;
-int16 pass2482;
+int8 pass2478;
+byte_element_struct *byte_element_2480=NULL;
+if (!byte_element_2480){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2480=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2480=(byte_element_struct*)mem_static_malloc(12);
+}
+int32 pass2481;
+int32 pass2482;
 int16 pass2483;
-int8 pass2484;
-byte_element_struct *byte_element_2486=NULL;
-if (!byte_element_2486){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2486=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2486=(byte_element_struct*)mem_static_malloc(12);
-}
-int32 pass2487;
-int32 pass2488;
+int16 pass2484;
+int16 pass2485;
+int16 pass2486;
+int16 pass2487;
+int16 pass2488;
 int16 pass2489;
-int16 pass2490;
-int16 pass2491;
-int16 pass2492;
-int16 pass2493;
-int16 pass2494;
+int8 pass2490;
+byte_element_struct *byte_element_2492=NULL;
+if (!byte_element_2492){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2492=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2492=(byte_element_struct*)mem_static_malloc(12);
+}
+int32 pass2493;
+int32 pass2494;
 int16 pass2495;
-int8 pass2496;
-byte_element_struct *byte_element_2498=NULL;
-if (!byte_element_2498){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2498=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2498=(byte_element_struct*)mem_static_malloc(12);
-}
-int32 pass2499;
-int32 pass2500;
+int16 pass2496;
+int16 pass2497;
+int16 pass2498;
+int16 pass2499;
+int16 pass2500;
 int16 pass2501;
-int16 pass2502;
-int32 pass2503;
-int16 pass2504;
-int16 pass2505;
-int16 pass2506;
-int32 pass2507;
+int8 pass2502;
+byte_element_struct *byte_element_2504=NULL;
+if (!byte_element_2504){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2504=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2504=(byte_element_struct*)mem_static_malloc(12);
+}
+int32 pass2505;
+int32 pass2506;
+int16 pass2507;
 int16 pass2508;
-int16 pass2509;
-int8 pass2510;
-byte_element_struct *byte_element_2512=NULL;
-if (!byte_element_2512){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2512=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2512=(byte_element_struct*)mem_static_malloc(12);
-}
+int32 pass2509;
+int16 pass2510;
+int16 pass2511;
+int16 pass2512;
 int32 pass2513;
-int32 pass2514;
+int16 pass2514;
 int16 pass2515;
-int16 pass2516;
-int16 pass2517;
-int16 pass2518;
-int16 pass2519;
-int16 pass2520;
+int8 pass2516;
+byte_element_struct *byte_element_2518=NULL;
+if (!byte_element_2518){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2518=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2518=(byte_element_struct*)mem_static_malloc(12);
+}
+int32 pass2519;
+int32 pass2520;
 int16 pass2521;
-int8 pass2522;
-byte_element_struct *byte_element_2524=NULL;
-if (!byte_element_2524){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2524=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2524=(byte_element_struct*)mem_static_malloc(12);
-}
-int32 pass2525;
-int32 pass2526;
+int16 pass2522;
+int16 pass2523;
+int16 pass2524;
+int16 pass2525;
+int16 pass2526;
 int16 pass2527;
-int16 pass2528;
-int16 pass2529;
-int16 pass2530;
-int16 pass2531;
-int16 pass2532;
+int8 pass2528;
+byte_element_struct *byte_element_2530=NULL;
+if (!byte_element_2530){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2530=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2530=(byte_element_struct*)mem_static_malloc(12);
+}
+int32 pass2531;
+int32 pass2532;
 int16 pass2533;
-int8 pass2534;
-byte_element_struct *byte_element_2536=NULL;
-if (!byte_element_2536){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2536=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2536=(byte_element_struct*)mem_static_malloc(12);
-}
-int32 pass2537;
-int32 pass2538;
+int16 pass2534;
+int16 pass2535;
+int16 pass2536;
+int16 pass2537;
+int16 pass2538;
 int16 pass2539;
-int16 pass2540;
-int16 pass2541;
-int16 pass2542;
-int16 pass2543;
-int16 pass2544;
+int8 pass2540;
+byte_element_struct *byte_element_2542=NULL;
+if (!byte_element_2542){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2542=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2542=(byte_element_struct*)mem_static_malloc(12);
+}
+int32 pass2543;
+int32 pass2544;
 int16 pass2545;
-int8 pass2546;
-byte_element_struct *byte_element_2548=NULL;
-if (!byte_element_2548){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2548=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2548=(byte_element_struct*)mem_static_malloc(12);
-}
-int32 pass2549;
-int32 pass2550;
+int16 pass2546;
+int16 pass2547;
+int16 pass2548;
+int16 pass2549;
+int16 pass2550;
 int16 pass2551;
-int16 pass2552;
-int16 pass2553;
-int16 pass2554;
-int16 pass2555;
-int16 pass2556;
-int16 pass2557;
-int8 pass2558;
-byte_element_struct *byte_element_2560=NULL;
-if (!byte_element_2560){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2560=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2560=(byte_element_struct*)mem_static_malloc(12);
+int8 pass2552;
+byte_element_struct *byte_element_2554=NULL;
+if (!byte_element_2554){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2554=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2554=(byte_element_struct*)mem_static_malloc(12);
 }
-int32 pass2561;
-int32 pass2562;
+int32 pass2555;
+int32 pass2556;
+int16 pass2557;
+int16 pass2558;
+int16 pass2559;
+int16 pass2560;
+int16 pass2561;
+int16 pass2562;
 int16 pass2563;
-int16 pass2564;
-int16 pass2565;
-int16 pass2566;
-int16 pass2567;
-int16 pass2568;
+int8 pass2564;
+byte_element_struct *byte_element_2566=NULL;
+if (!byte_element_2566){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2566=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2566=(byte_element_struct*)mem_static_malloc(12);
+}
+int32 pass2567;
+int32 pass2568;
 int16 pass2569;
-int8 pass2570;
+int16 pass2570;
+int16 pass2571;
+int16 pass2572;
+int16 pass2573;
+int16 pass2574;
+int16 pass2575;
+int8 pass2576;
--- a/internal/source/data160.txt
+++ b/internal/source/data160.txt
@ -3,15 +3,15 @@ if(_FUNC_LOGICALNOT_LONG_LOGICALNOT==NULL){
 _FUNC_LOGICALNOT_LONG_LOGICALNOT=(int32*)mem_static_malloc(4);
 *_FUNC_LOGICALNOT_LONG_LOGICALNOT=0;
 }
-qbs*oldstr3912=NULL;
+qbs*oldstr3919=NULL;
 if(_FUNC_LOGICALNOT_STRING_EXP->tmp||_FUNC_LOGICALNOT_STRING_EXP->fixed||_FUNC_LOGICALNOT_STRING_EXP->readonly){
-oldstr3912=_FUNC_LOGICALNOT_STRING_EXP;
-if (oldstr3912->cmem_descriptor){
-_FUNC_LOGICALNOT_STRING_EXP=qbs_new_cmem(oldstr3912->len,0);
+oldstr3919=_FUNC_LOGICALNOT_STRING_EXP;
+if (oldstr3919->cmem_descriptor){
+_FUNC_LOGICALNOT_STRING_EXP=qbs_new_cmem(oldstr3919->len,0);
 }else{
-_FUNC_LOGICALNOT_STRING_EXP=qbs_new(oldstr3912->len,0);
+_FUNC_LOGICALNOT_STRING_EXP=qbs_new(oldstr3919->len,0);
 }
-memcpy(_FUNC_LOGICALNOT_STRING_EXP->chr,oldstr3912->chr,oldstr3912->len);
+memcpy(_FUNC_LOGICALNOT_STRING_EXP->chr,oldstr3919->chr,oldstr3919->len);
 }
 qbs *_FUNC_LOGICALNOT_STRING_ELE=NULL;
 if (!_FUNC_LOGICALNOT_STRING_ELE)_FUNC_LOGICALNOT_STRING_ELE=qbs_new(0,0);
@ -20,7 +20,7 @@ if(_FUNC_LOGICALNOT_LONG_NUM__ASCII_CHR_046__TYP==NULL){
 _FUNC_LOGICALNOT_LONG_NUM__ASCII_CHR_046__TYP=(int32*)mem_static_malloc(4);
 *_FUNC_LOGICALNOT_LONG_NUM__ASCII_CHR_046__TYP=0;
 }
-int32 pass3913;
-uint64 pass3914;
-int32 pass3915;
-int64 pass3916;
+int32 pass3920;
+uint64 pass3921;
+int32 pass3922;
+int64 pass3923;
--- a/internal/source/data161.txt
+++ b/internal/source/data161.txt
@ -3,15 +3,15 @@ if(_FUNC_RELATION_LONG_RELATION==NULL){
 _FUNC_RELATION_LONG_RELATION=(int32*)mem_static_malloc(4);
 *_FUNC_RELATION_LONG_RELATION=0;
 }
-qbs*oldstr3917=NULL;
+qbs*oldstr3924=NULL;
 if(_FUNC_RELATION_STRING_EXP->tmp||_FUNC_RELATION_STRING_EXP->fixed||_FUNC_RELATION_STRING_EXP->readonly){
-oldstr3917=_FUNC_RELATION_STRING_EXP;
-if (oldstr3917->cmem_descriptor){
-_FUNC_RELATION_STRING_EXP=qbs_new_cmem(oldstr3917->len,0);
+oldstr3924=_FUNC_RELATION_STRING_EXP;
+if (oldstr3924->cmem_descriptor){
+_FUNC_RELATION_STRING_EXP=qbs_new_cmem(oldstr3924->len,0);
 }else{
-_FUNC_RELATION_STRING_EXP=qbs_new(oldstr3917->len,0);
+_FUNC_RELATION_STRING_EXP=qbs_new(oldstr3924->len,0);
 }
-memcpy(_FUNC_RELATION_STRING_EXP->chr,oldstr3917->chr,oldstr3917->len);
+memcpy(_FUNC_RELATION_STRING_EXP->chr,oldstr3924->chr,oldstr3924->len);
 }
 void *_FUNC_RELATION_UDT_NUM=NULL;
 if(_FUNC_RELATION_UDT_NUM==NULL){
@ -21,39 +21,39 @@ memset(_FUNC_RELATION_UDT_NUM,0,60);
 }
 qbs *_FUNC_RELATION_STRING_ELE=NULL;
 if (!_FUNC_RELATION_STRING_ELE)_FUNC_RELATION_STRING_ELE=qbs_new(0,0);
-int32 pass3919;
-long double pass3920;
-int32 pass3921;
-uint64 pass3922;
-int32 pass3923;
-int64 pass3924;
-int32 pass3925;
-long double pass3926;
-int32 pass3927;
-uint64 pass3928;
-int32 pass3929;
-int64 pass3930;
-int32 pass3931;
-long double pass3932;
-int32 pass3933;
-uint64 pass3934;
-int32 pass3935;
-int64 pass3936;
-int32 pass3937;
-long double pass3938;
-int32 pass3939;
-uint64 pass3940;
-int32 pass3941;
-int64 pass3942;
-int32 pass3943;
-long double pass3944;
-int32 pass3945;
-uint64 pass3946;
-int32 pass3947;
-int64 pass3948;
-int32 pass3949;
-long double pass3950;
-int32 pass3951;
-uint64 pass3952;
-int32 pass3953;
-int64 pass3954;
+int32 pass3926;
+long double pass3927;
+int32 pass3928;
+uint64 pass3929;
+int32 pass3930;
+int64 pass3931;
+int32 pass3932;
+long double pass3933;
+int32 pass3934;
+uint64 pass3935;
+int32 pass3936;
+int64 pass3937;
+int32 pass3938;
+long double pass3939;
+int32 pass3940;
+uint64 pass3941;
+int32 pass3942;
+int64 pass3943;
+int32 pass3944;
+long double pass3945;
+int32 pass3946;
+uint64 pass3947;
+int32 pass3948;
+int64 pass3949;
+int32 pass3950;
+long double pass3951;
+int32 pass3952;
+uint64 pass3953;
+int32 pass3954;
+int64 pass3955;
+int32 pass3956;
+long double pass3957;
+int32 pass3958;
+uint64 pass3959;
+int32 pass3960;
+int64 pass3961;
--- a/internal/source/data162.txt
+++ b/internal/source/data162.txt
@ -3,15 +3,15 @@ if(_FUNC_TERM_LONG_TERM==NULL){
 _FUNC_TERM_LONG_TERM=(int32*)mem_static_malloc(4);
 *_FUNC_TERM_LONG_TERM=0;
 }
-qbs*oldstr3955=NULL;
+qbs*oldstr3962=NULL;
 if(_FUNC_TERM_STRING_EXP->tmp||_FUNC_TERM_STRING_EXP->fixed||_FUNC_TERM_STRING_EXP->readonly){
-oldstr3955=_FUNC_TERM_STRING_EXP;
-if (oldstr3955->cmem_descriptor){
-_FUNC_TERM_STRING_EXP=qbs_new_cmem(oldstr3955->len,0);
+oldstr3962=_FUNC_TERM_STRING_EXP;
+if (oldstr3962->cmem_descriptor){
+_FUNC_TERM_STRING_EXP=qbs_new_cmem(oldstr3962->len,0);
 }else{
-_FUNC_TERM_STRING_EXP=qbs_new(oldstr3955->len,0);
+_FUNC_TERM_STRING_EXP=qbs_new(oldstr3962->len,0);
 }
-memcpy(_FUNC_TERM_STRING_EXP->chr,oldstr3955->chr,oldstr3955->len);
+memcpy(_FUNC_TERM_STRING_EXP->chr,oldstr3962->chr,oldstr3962->len);
 }
 void *_FUNC_TERM_UDT_NUM=NULL;
 if(_FUNC_TERM_UDT_NUM==NULL){
@ -21,15 +21,15 @@ memset(_FUNC_TERM_UDT_NUM,0,60);
 }
 qbs *_FUNC_TERM_STRING_ELE=NULL;
 if (!_FUNC_TERM_STRING_ELE)_FUNC_TERM_STRING_ELE=qbs_new(0,0);
-int32 pass3957;
-long double pass3958;
-int32 pass3959;
-uint64 pass3960;
-int32 pass3961;
-int64 pass3962;
-int32 pass3963;
-long double pass3964;
-int32 pass3965;
-uint64 pass3966;
-int32 pass3967;
-int64 pass3968;
+int32 pass3964;
+long double pass3965;
+int32 pass3966;
+uint64 pass3967;
+int32 pass3968;
+int64 pass3969;
+int32 pass3970;
+long double pass3971;
+int32 pass3972;
+uint64 pass3973;
+int32 pass3974;
+int64 pass3975;
--- a/internal/source/data163.txt
+++ b/internal/source/data163.txt
@ -3,15 +3,15 @@ if(_FUNC_PARSEMOD_LONG_PARSEMOD==NULL){
 _FUNC_PARSEMOD_LONG_PARSEMOD=(int32*)mem_static_malloc(4);
 *_FUNC_PARSEMOD_LONG_PARSEMOD=0;
 }
-qbs*oldstr3969=NULL;
+qbs*oldstr3976=NULL;
 if(_FUNC_PARSEMOD_STRING_EXP->tmp||_FUNC_PARSEMOD_STRING_EXP->fixed||_FUNC_PARSEMOD_STRING_EXP->readonly){
-oldstr3969=_FUNC_PARSEMOD_STRING_EXP;
-if (oldstr3969->cmem_descriptor){
-_FUNC_PARSEMOD_STRING_EXP=qbs_new_cmem(oldstr3969->len,0);
+oldstr3976=_FUNC_PARSEMOD_STRING_EXP;
+if (oldstr3976->cmem_descriptor){
+_FUNC_PARSEMOD_STRING_EXP=qbs_new_cmem(oldstr3976->len,0);
 }else{
-_FUNC_PARSEMOD_STRING_EXP=qbs_new(oldstr3969->len,0);
+_FUNC_PARSEMOD_STRING_EXP=qbs_new(oldstr3976->len,0);
 }
-memcpy(_FUNC_PARSEMOD_STRING_EXP->chr,oldstr3969->chr,oldstr3969->len);
+memcpy(_FUNC_PARSEMOD_STRING_EXP->chr,oldstr3976->chr,oldstr3976->len);
 }
 void *_FUNC_PARSEMOD_UDT_NUM=NULL;
 if(_FUNC_PARSEMOD_UDT_NUM==NULL){
@ -21,7 +21,7 @@ memset(_FUNC_PARSEMOD_UDT_NUM,0,60);
 }
 qbs *_FUNC_PARSEMOD_STRING_ELE=NULL;
 if (!_FUNC_PARSEMOD_STRING_ELE)_FUNC_PARSEMOD_STRING_ELE=qbs_new(0,0);
-int32 pass3971;
-uint64 pass3972;
-int32 pass3973;
-int64 pass3974;
+int32 pass3978;
+uint64 pass3979;
+int32 pass3980;
+int64 pass3981;
--- a/internal/source/data164.txt
+++ b/internal/source/data164.txt
@ -3,15 +3,15 @@ if(_FUNC_INTDIV_LONG_INTDIV==NULL){
 _FUNC_INTDIV_LONG_INTDIV=(int32*)mem_static_malloc(4);
 *_FUNC_INTDIV_LONG_INTDIV=0;
 }
-qbs*oldstr3975=NULL;
+qbs*oldstr3982=NULL;
 if(_FUNC_INTDIV_STRING_EXP->tmp||_FUNC_INTDIV_STRING_EXP->fixed||_FUNC_INTDIV_STRING_EXP->readonly){
-oldstr3975=_FUNC_INTDIV_STRING_EXP;
-if (oldstr3975->cmem_descriptor){
-_FUNC_INTDIV_STRING_EXP=qbs_new_cmem(oldstr3975->len,0);
+oldstr3982=_FUNC_INTDIV_STRING_EXP;
+if (oldstr3982->cmem_descriptor){
+_FUNC_INTDIV_STRING_EXP=qbs_new_cmem(oldstr3982->len,0);
 }else{
-_FUNC_INTDIV_STRING_EXP=qbs_new(oldstr3975->len,0);
+_FUNC_INTDIV_STRING_EXP=qbs_new(oldstr3982->len,0);
 }
-memcpy(_FUNC_INTDIV_STRING_EXP->chr,oldstr3975->chr,oldstr3975->len);
+memcpy(_FUNC_INTDIV_STRING_EXP->chr,oldstr3982->chr,oldstr3982->len);
 }
 void *_FUNC_INTDIV_UDT_NUM=NULL;
 if(_FUNC_INTDIV_UDT_NUM==NULL){
@ -21,7 +21,7 @@ memset(_FUNC_INTDIV_UDT_NUM,0,60);
 }
 qbs *_FUNC_INTDIV_STRING_ELE=NULL;
 if (!_FUNC_INTDIV_STRING_ELE)_FUNC_INTDIV_STRING_ELE=qbs_new(0,0);
-int32 pass3977;
-uint64 pass3978;
-int32 pass3979;
-int64 pass3980;
+int32 pass3984;
+uint64 pass3985;
+int32 pass3986;
+int64 pass3987;
--- a/internal/source/data165.txt
+++ b/internal/source/data165.txt
@ -3,15 +3,15 @@ if(_FUNC_FACTOR_LONG_FACTOR==NULL){
 _FUNC_FACTOR_LONG_FACTOR=(int32*)mem_static_malloc(4);
 *_FUNC_FACTOR_LONG_FACTOR=0;
 }
-qbs*oldstr3981=NULL;
+qbs*oldstr3988=NULL;
 if(_FUNC_FACTOR_STRING_EXP->tmp||_FUNC_FACTOR_STRING_EXP->fixed||_FUNC_FACTOR_STRING_EXP->readonly){
-oldstr3981=_FUNC_FACTOR_STRING_EXP;
-if (oldstr3981->cmem_descriptor){
-_FUNC_FACTOR_STRING_EXP=qbs_new_cmem(oldstr3981->len,0);
+oldstr3988=_FUNC_FACTOR_STRING_EXP;
+if (oldstr3988->cmem_descriptor){
+_FUNC_FACTOR_STRING_EXP=qbs_new_cmem(oldstr3988->len,0);
 }else{
-_FUNC_FACTOR_STRING_EXP=qbs_new(oldstr3981->len,0);
+_FUNC_FACTOR_STRING_EXP=qbs_new(oldstr3988->len,0);
 }
-memcpy(_FUNC_FACTOR_STRING_EXP->chr,oldstr3981->chr,oldstr3981->len);
+memcpy(_FUNC_FACTOR_STRING_EXP->chr,oldstr3988->chr,oldstr3988->len);
 }
 void *_FUNC_FACTOR_UDT_NUM=NULL;
 if(_FUNC_FACTOR_UDT_NUM==NULL){
@ -21,11 +21,11 @@ memset(_FUNC_FACTOR_UDT_NUM,0,60);
 }
 qbs *_FUNC_FACTOR_STRING_ELE=NULL;
 if (!_FUNC_FACTOR_STRING_ELE)_FUNC_FACTOR_STRING_ELE=qbs_new(0,0);
-int32 pass3983;
-long double pass3984;
-int32 pass3985;
-uint64 pass3986;
-int32 pass3987;
-int64 pass3988;
-int32 pass3989;
-long double pass3990;
+int32 pass3990;
+long double pass3991;
+int32 pass3992;
+uint64 pass3993;
+int32 pass3994;
+int64 pass3995;
+int32 pass3996;
+long double pass3997;
--- a/internal/source/data166.txt
+++ b/internal/source/data166.txt
@ -3,17 +3,17 @@ if(_FUNC_UNARY_LONG_UNARY==NULL){
 _FUNC_UNARY_LONG_UNARY=(int32*)mem_static_malloc(4);
 *_FUNC_UNARY_LONG_UNARY=0;
 }
-qbs*oldstr3991=NULL;
+qbs*oldstr3998=NULL;
 if(_FUNC_UNARY_STRING_EXP->tmp||_FUNC_UNARY_STRING_EXP->fixed||_FUNC_UNARY_STRING_EXP->readonly){
-oldstr3991=_FUNC_UNARY_STRING_EXP;
-if (oldstr3991->cmem_descriptor){
-_FUNC_UNARY_STRING_EXP=qbs_new_cmem(oldstr3991->len,0);
+oldstr3998=_FUNC_UNARY_STRING_EXP;
+if (oldstr3998->cmem_descriptor){
+_FUNC_UNARY_STRING_EXP=qbs_new_cmem(oldstr3998->len,0);
 }else{
-_FUNC_UNARY_STRING_EXP=qbs_new(oldstr3991->len,0);
+_FUNC_UNARY_STRING_EXP=qbs_new(oldstr3998->len,0);
 }
-memcpy(_FUNC_UNARY_STRING_EXP->chr,oldstr3991->chr,oldstr3991->len);
+memcpy(_FUNC_UNARY_STRING_EXP->chr,oldstr3998->chr,oldstr3998->len);
 }
 qbs *_FUNC_UNARY_STRING_ELE=NULL;
 if (!_FUNC_UNARY_STRING_ELE)_FUNC_UNARY_STRING_ELE=qbs_new(0,0);
-int32 pass3992;
-int64 pass3993;
+int32 pass3999;
+int64 pass4000;
--- a/internal/source/data167.txt
+++ b/internal/source/data167.txt
@ -3,15 +3,15 @@ if(_FUNC_EXPONENT_LONG_EXPONENT==NULL){
 _FUNC_EXPONENT_LONG_EXPONENT=(int32*)mem_static_malloc(4);
 *_FUNC_EXPONENT_LONG_EXPONENT=0;
 }
-qbs*oldstr3994=NULL;
+qbs*oldstr4001=NULL;
 if(_FUNC_EXPONENT_STRING_EXP->tmp||_FUNC_EXPONENT_STRING_EXP->fixed||_FUNC_EXPONENT_STRING_EXP->readonly){
-oldstr3994=_FUNC_EXPONENT_STRING_EXP;
-if (oldstr3994->cmem_descriptor){
-_FUNC_EXPONENT_STRING_EXP=qbs_new_cmem(oldstr3994->len,0);
+oldstr4001=_FUNC_EXPONENT_STRING_EXP;
+if (oldstr4001->cmem_descriptor){
+_FUNC_EXPONENT_STRING_EXP=qbs_new_cmem(oldstr4001->len,0);
 }else{
-_FUNC_EXPONENT_STRING_EXP=qbs_new(oldstr3994->len,0);
+_FUNC_EXPONENT_STRING_EXP=qbs_new(oldstr4001->len,0);
 }
-memcpy(_FUNC_EXPONENT_STRING_EXP->chr,oldstr3994->chr,oldstr3994->len);
+memcpy(_FUNC_EXPONENT_STRING_EXP->chr,oldstr4001->chr,oldstr4001->len);
 }
 void *_FUNC_EXPONENT_UDT_NUM=NULL;
 if(_FUNC_EXPONENT_UDT_NUM==NULL){
@ -21,12 +21,12 @@ memset(_FUNC_EXPONENT_UDT_NUM,0,60);
 }
 qbs *_FUNC_EXPONENT_STRING_ELE=NULL;
 if (!_FUNC_EXPONENT_STRING_ELE)_FUNC_EXPONENT_STRING_ELE=qbs_new(0,0);
-int32 pass3996;
-long double pass3997;
-int32 pass3998;
-uint64 pass3999;
-int32 pass4000;
-int64 pass4001;
+int32 pass4003;
+long double pass4004;
+int32 pass4005;
+uint64 pass4006;
+int32 pass4007;
+int64 pass4008;
 int32 *_FUNC_EXPONENT_LONG_SIG=NULL;
 if(_FUNC_EXPONENT_LONG_SIG==NULL){
 _FUNC_EXPONENT_LONG_SIG=(int32*)mem_static_malloc(4);
@ -37,5 +37,5 @@ if(_FUNC_EXPONENT_FLOAT_EXPON==NULL){
 _FUNC_EXPONENT_FLOAT_EXPON=(long double*)mem_static_malloc(32);
 *_FUNC_EXPONENT_FLOAT_EXPON=0;
 }
-int32 pass4002;
-long double pass4003;
+int32 pass4009;
+long double pass4010;
--- a/internal/source/data168.txt
+++ b/internal/source/data168.txt
@ -3,17 +3,17 @@ if(_FUNC_NUMERIC_LONG_NUMERIC==NULL){
 _FUNC_NUMERIC_LONG_NUMERIC=(int32*)mem_static_malloc(4);
 *_FUNC_NUMERIC_LONG_NUMERIC=0;
 }
-qbs*oldstr4004=NULL;
+qbs*oldstr4011=NULL;
 if(_FUNC_NUMERIC_STRING_EXP->tmp||_FUNC_NUMERIC_STRING_EXP->fixed||_FUNC_NUMERIC_STRING_EXP->readonly){
-oldstr4004=_FUNC_NUMERIC_STRING_EXP;
-if (oldstr4004->cmem_descriptor){
-_FUNC_NUMERIC_STRING_EXP=qbs_new_cmem(oldstr4004->len,0);
+oldstr4011=_FUNC_NUMERIC_STRING_EXP;
+if (oldstr4011->cmem_descriptor){
+_FUNC_NUMERIC_STRING_EXP=qbs_new_cmem(oldstr4011->len,0);
 }else{
-_FUNC_NUMERIC_STRING_EXP=qbs_new(oldstr4004->len,0);
+_FUNC_NUMERIC_STRING_EXP=qbs_new(oldstr4011->len,0);
 }
-memcpy(_FUNC_NUMERIC_STRING_EXP->chr,oldstr4004->chr,oldstr4004->len);
+memcpy(_FUNC_NUMERIC_STRING_EXP->chr,oldstr4011->chr,oldstr4011->len);
 }
 qbs *_FUNC_NUMERIC_STRING_ELE=NULL;
 if (!_FUNC_NUMERIC_STRING_ELE)_FUNC_NUMERIC_STRING_ELE=qbs_new(0,0);
-int32 pass4005;
-long double pass4006;
+int32 pass4012;
+long double pass4013;
--- a/internal/source/data169.txt
+++ b/internal/source/data169.txt
@ -3,15 +3,15 @@ if(_FUNC_PARSENUMHASHLOOKUP_LONG_PARSENUMHASHLOOKUP==NULL){
 _FUNC_PARSENUMHASHLOOKUP_LONG_PARSENUMHASHLOOKUP=(int32*)mem_static_malloc(4);
 *_FUNC_PARSENUMHASHLOOKUP_LONG_PARSENUMHASHLOOKUP=0;
 }
-qbs*oldstr4007=NULL;
+qbs*oldstr4014=NULL;
 if(_FUNC_PARSENUMHASHLOOKUP_STRING_ELE->tmp||_FUNC_PARSENUMHASHLOOKUP_STRING_ELE->fixed||_FUNC_PARSENUMHASHLOOKUP_STRING_ELE->readonly){
-oldstr4007=_FUNC_PARSENUMHASHLOOKUP_STRING_ELE;
-if (oldstr4007->cmem_descriptor){
-_FUNC_PARSENUMHASHLOOKUP_STRING_ELE=qbs_new_cmem(oldstr4007->len,0);
+oldstr4014=_FUNC_PARSENUMHASHLOOKUP_STRING_ELE;
+if (oldstr4014->cmem_descriptor){
+_FUNC_PARSENUMHASHLOOKUP_STRING_ELE=qbs_new_cmem(oldstr4014->len,0);
 }else{
-_FUNC_PARSENUMHASHLOOKUP_STRING_ELE=qbs_new(oldstr4007->len,0);
+_FUNC_PARSENUMHASHLOOKUP_STRING_ELE=qbs_new(oldstr4014->len,0);
 }
-memcpy(_FUNC_PARSENUMHASHLOOKUP_STRING_ELE->chr,oldstr4007->chr,oldstr4007->len);
+memcpy(_FUNC_PARSENUMHASHLOOKUP_STRING_ELE->chr,oldstr4014->chr,oldstr4014->len);
 }
 int32 *_FUNC_PARSENUMHASHLOOKUP_LONG_HASHFOUND=NULL;
 if(_FUNC_PARSENUMHASHLOOKUP_LONG_HASHFOUND==NULL){
--- a/internal/source/data17.txt
+++ b/internal/source/data17.txt
@ -1,24 +1,24 @@
 qbs *_FUNC_UDTREFERENCE_STRING_UDTREFERENCE=NULL;
 if (!_FUNC_UDTREFERENCE_STRING_UDTREFERENCE)_FUNC_UDTREFERENCE_STRING_UDTREFERENCE=qbs_new(0,0);
-qbs*oldstr2571=NULL;
+qbs*oldstr2577=NULL;
 if(_FUNC_UDTREFERENCE_STRING_O->tmp||_FUNC_UDTREFERENCE_STRING_O->fixed||_FUNC_UDTREFERENCE_STRING_O->readonly){
-oldstr2571=_FUNC_UDTREFERENCE_STRING_O;
-if (oldstr2571->cmem_descriptor){
-_FUNC_UDTREFERENCE_STRING_O=qbs_new_cmem(oldstr2571->len,0);
+oldstr2577=_FUNC_UDTREFERENCE_STRING_O;
+if (oldstr2577->cmem_descriptor){
+_FUNC_UDTREFERENCE_STRING_O=qbs_new_cmem(oldstr2577->len,0);
 }else{
-_FUNC_UDTREFERENCE_STRING_O=qbs_new(oldstr2571->len,0);
+_FUNC_UDTREFERENCE_STRING_O=qbs_new(oldstr2577->len,0);
 }
-memcpy(_FUNC_UDTREFERENCE_STRING_O->chr,oldstr2571->chr,oldstr2571->len);
+memcpy(_FUNC_UDTREFERENCE_STRING_O->chr,oldstr2577->chr,oldstr2577->len);
 }
-qbs*oldstr2572=NULL;
+qbs*oldstr2578=NULL;
 if(_FUNC_UDTREFERENCE_STRING_A->tmp||_FUNC_UDTREFERENCE_STRING_A->fixed||_FUNC_UDTREFERENCE_STRING_A->readonly){
-oldstr2572=_FUNC_UDTREFERENCE_STRING_A;
-if (oldstr2572->cmem_descriptor){
-_FUNC_UDTREFERENCE_STRING_A=qbs_new_cmem(oldstr2572->len,0);
+oldstr2578=_FUNC_UDTREFERENCE_STRING_A;
+if (oldstr2578->cmem_descriptor){
+_FUNC_UDTREFERENCE_STRING_A=qbs_new_cmem(oldstr2578->len,0);
 }else{
-_FUNC_UDTREFERENCE_STRING_A=qbs_new(oldstr2572->len,0);
+_FUNC_UDTREFERENCE_STRING_A=qbs_new(oldstr2578->len,0);
 }
-memcpy(_FUNC_UDTREFERENCE_STRING_A->chr,oldstr2572->chr,oldstr2572->len);
+memcpy(_FUNC_UDTREFERENCE_STRING_A->chr,oldstr2578->chr,oldstr2578->len);
 }
 qbs *_FUNC_UDTREFERENCE_STRING_OBAK=NULL;
 if (!_FUNC_UDTREFERENCE_STRING_OBAK)_FUNC_UDTREFERENCE_STRING_OBAK=qbs_new(0,0);
@ -53,9 +53,9 @@ qbs *_FUNC_UDTREFERENCE_STRING_N=NULL;
 if (!_FUNC_UDTREFERENCE_STRING_N)_FUNC_UDTREFERENCE_STRING_N=qbs_new(0,0);
 qbs *_FUNC_UDTREFERENCE_STRING_NSYM=NULL;
 if (!_FUNC_UDTREFERENCE_STRING_NSYM)_FUNC_UDTREFERENCE_STRING_NSYM=qbs_new(0,0);
-byte_element_struct *byte_element_2573=NULL;
-if (!byte_element_2573){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2573=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2573=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_2579=NULL;
+if (!byte_element_2579){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2579=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2579=(byte_element_struct*)mem_static_malloc(12);
 }
 int32 *_FUNC_UDTREFERENCE_LONG_NTYP=NULL;
 if(_FUNC_UDTREFERENCE_LONG_NTYP==NULL){
@ -69,7 +69,7 @@ _FUNC_UDTREFERENCE_LONG_NTYPSIZE=(int32*)mem_static_malloc(4);
 }
 qbs *_FUNC_UDTREFERENCE_STRING_N2=NULL;
 if (!_FUNC_UDTREFERENCE_STRING_N2)_FUNC_UDTREFERENCE_STRING_N2=qbs_new(0,0);
-byte_element_struct *byte_element_2574=NULL;
-if (!byte_element_2574){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2574=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2574=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_2580=NULL;
+if (!byte_element_2580){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2580=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2580=(byte_element_struct*)mem_static_malloc(12);
 }
--- a/internal/source/data173.txt
+++ b/internal/source/data173.txt
@ -1,10 +1,10 @@
-qbs*oldstr4009=NULL;
+qbs*oldstr4016=NULL;
 if(_SUB_PARSENUMSETS_STRING_S->tmp||_SUB_PARSENUMSETS_STRING_S->fixed||_SUB_PARSENUMSETS_STRING_S->readonly){
-oldstr4009=_SUB_PARSENUMSETS_STRING_S;
-if (oldstr4009->cmem_descriptor){
-_SUB_PARSENUMSETS_STRING_S=qbs_new_cmem(oldstr4009->len,0);
+oldstr4016=_SUB_PARSENUMSETS_STRING_S;
+if (oldstr4016->cmem_descriptor){
+_SUB_PARSENUMSETS_STRING_S=qbs_new_cmem(oldstr4016->len,0);
 }else{
-_SUB_PARSENUMSETS_STRING_S=qbs_new(oldstr4009->len,0);
+_SUB_PARSENUMSETS_STRING_S=qbs_new(oldstr4016->len,0);
 }
-memcpy(_SUB_PARSENUMSETS_STRING_S->chr,oldstr4009->chr,oldstr4009->len);
+memcpy(_SUB_PARSENUMSETS_STRING_S->chr,oldstr4016->chr,oldstr4016->len);
 }
--- a/internal/source/data174.txt
+++ b/internal/source/data174.txt
@ -1,10 +1,10 @@
-qbs*oldstr4010=NULL;
+qbs*oldstr4017=NULL;
 if(_SUB_FIXUPERRORMESSAGE_STRING_OP->tmp||_SUB_FIXUPERRORMESSAGE_STRING_OP->fixed||_SUB_FIXUPERRORMESSAGE_STRING_OP->readonly){
-oldstr4010=_SUB_FIXUPERRORMESSAGE_STRING_OP;
-if (oldstr4010->cmem_descriptor){
-_SUB_FIXUPERRORMESSAGE_STRING_OP=qbs_new_cmem(oldstr4010->len,0);
+oldstr4017=_SUB_FIXUPERRORMESSAGE_STRING_OP;
+if (oldstr4017->cmem_descriptor){
+_SUB_FIXUPERRORMESSAGE_STRING_OP=qbs_new_cmem(oldstr4017->len,0);
 }else{
-_SUB_FIXUPERRORMESSAGE_STRING_OP=qbs_new(oldstr4010->len,0);
+_SUB_FIXUPERRORMESSAGE_STRING_OP=qbs_new(oldstr4017->len,0);
 }
-memcpy(_SUB_FIXUPERRORMESSAGE_STRING_OP->chr,oldstr4010->chr,oldstr4010->len);
+memcpy(_SUB_FIXUPERRORMESSAGE_STRING_OP->chr,oldstr4017->chr,oldstr4017->len);
 }
--- a/internal/source/data175.txt
+++ b/internal/source/data175.txt
@ -1,12 +1,12 @@
-qbs*oldstr4011=NULL;
+qbs*oldstr4018=NULL;
 if(_SUB_PARSEEXPRESSION2_STRING_EXP->tmp||_SUB_PARSEEXPRESSION2_STRING_EXP->fixed||_SUB_PARSEEXPRESSION2_STRING_EXP->readonly){
-oldstr4011=_SUB_PARSEEXPRESSION2_STRING_EXP;
-if (oldstr4011->cmem_descriptor){
-_SUB_PARSEEXPRESSION2_STRING_EXP=qbs_new_cmem(oldstr4011->len,0);
+oldstr4018=_SUB_PARSEEXPRESSION2_STRING_EXP;
+if (oldstr4018->cmem_descriptor){
+_SUB_PARSEEXPRESSION2_STRING_EXP=qbs_new_cmem(oldstr4018->len,0);
 }else{
-_SUB_PARSEEXPRESSION2_STRING_EXP=qbs_new(oldstr4011->len,0);
+_SUB_PARSEEXPRESSION2_STRING_EXP=qbs_new(oldstr4018->len,0);
 }
-memcpy(_SUB_PARSEEXPRESSION2_STRING_EXP->chr,oldstr4011->chr,oldstr4011->len);
+memcpy(_SUB_PARSEEXPRESSION2_STRING_EXP->chr,oldstr4018->chr,oldstr4018->len);
 }
 void *_SUB_PARSEEXPRESSION2_UDT_STATE=NULL;
 if(_SUB_PARSEEXPRESSION2_UDT_STATE==NULL){
--- a/internal/source/data177.txt
+++ b/internal/source/data177.txt
@ -1,14 +1,14 @@
 qbs *_FUNC_EVALUATEFUNCTION_STRING_EVALUATEFUNCTION=NULL;
 if (!_FUNC_EVALUATEFUNCTION_STRING_EVALUATEFUNCTION)_FUNC_EVALUATEFUNCTION_STRING_EVALUATEFUNCTION=qbs_new(0,0);
-qbs*oldstr4012=NULL;
+qbs*oldstr4019=NULL;
 if(_FUNC_EVALUATEFUNCTION_STRING_ARGS->tmp||_FUNC_EVALUATEFUNCTION_STRING_ARGS->fixed||_FUNC_EVALUATEFUNCTION_STRING_ARGS->readonly){
-oldstr4012=_FUNC_EVALUATEFUNCTION_STRING_ARGS;
-if (oldstr4012->cmem_descriptor){
-_FUNC_EVALUATEFUNCTION_STRING_ARGS=qbs_new_cmem(oldstr4012->len,0);
+oldstr4019=_FUNC_EVALUATEFUNCTION_STRING_ARGS;
+if (oldstr4019->cmem_descriptor){
+_FUNC_EVALUATEFUNCTION_STRING_ARGS=qbs_new_cmem(oldstr4019->len,0);
 }else{
-_FUNC_EVALUATEFUNCTION_STRING_ARGS=qbs_new(oldstr4012->len,0);
+_FUNC_EVALUATEFUNCTION_STRING_ARGS=qbs_new(oldstr4019->len,0);
 }
-memcpy(_FUNC_EVALUATEFUNCTION_STRING_ARGS->chr,oldstr4012->chr,oldstr4012->len);
+memcpy(_FUNC_EVALUATEFUNCTION_STRING_ARGS->chr,oldstr4019->chr,oldstr4019->len);
 }
 long double *_FUNC_EVALUATEFUNCTION_FLOAT_N1=NULL;
 if(_FUNC_EVALUATEFUNCTION_FLOAT_N1==NULL){
@ -51,32 +51,32 @@ if(_FUNC_EVALUATEFUNCTION_LONG_I==NULL){
 _FUNC_EVALUATEFUNCTION_LONG_I=(int32*)mem_static_malloc(4);
 *_FUNC_EVALUATEFUNCTION_LONG_I=0;
 }
-int64 fornext_value4014;
-int64 fornext_finalvalue4014;
-int64 fornext_step4014;
-uint8 fornext_step_negative4014;
+int64 fornext_value4021;
+int64 fornext_finalvalue4021;
+int64 fornext_step4021;
+uint8 fornext_step_negative4021;
 qbs *_FUNC_EVALUATEFUNCTION_STRING_ELE=NULL;
 if (!_FUNC_EVALUATEFUNCTION_STRING_ELE)_FUNC_EVALUATEFUNCTION_STRING_ELE=qbs_new(0,0);
-int32 pass4015;
-int32 pass4016;
+int32 pass4022;
+int32 pass4023;
 int32 *_FUNC_EVALUATEFUNCTION_LONG_TYP=NULL;
 if(_FUNC_EVALUATEFUNCTION_LONG_TYP==NULL){
 _FUNC_EVALUATEFUNCTION_LONG_TYP=(int32*)mem_static_malloc(4);
 *_FUNC_EVALUATEFUNCTION_LONG_TYP=0;
 }
-static qbs *sc_4017=qbs_new(0,0);
-static uint64 sc_4019;
+static qbs *sc_4024=qbs_new(0,0);
+static uint64 sc_4026;
 int32 *_FUNC_EVALUATEFUNCTION_LONG_T=NULL;
 if(_FUNC_EVALUATEFUNCTION_LONG_T==NULL){
 _FUNC_EVALUATEFUNCTION_LONG_T=(int32*)mem_static_malloc(4);
 *_FUNC_EVALUATEFUNCTION_LONG_T=0;
 }
-static uint64 sc_4020;
-static int64 sc_4021;
+static uint64 sc_4027;
+static int64 sc_4028;
 qbs *_FUNC_EVALUATEFUNCTION_STRING_EVALUATENUMBERS=NULL;
 if (!_FUNC_EVALUATEFUNCTION_STRING_EVALUATENUMBERS)_FUNC_EVALUATEFUNCTION_STRING_EVALUATENUMBERS=qbs_new(0,0);
-static qbs *sc_4022=qbs_new(0,0);
-static qbs *sc_4023=qbs_new(0,0);
+static qbs *sc_4029=qbs_new(0,0);
+static qbs *sc_4030=qbs_new(0,0);
 int64 *_FUNC_EVALUATEFUNCTION_INTEGER64_N=NULL;
 if(_FUNC_EVALUATEFUNCTION_INTEGER64_N==NULL){
 _FUNC_EVALUATEFUNCTION_INTEGER64_N=(int64*)mem_static_malloc(8);
--- a/internal/source/data178.txt
+++ b/internal/source/data178.txt
@ -1,14 +1,14 @@
 qbs *_FUNC_DWD_STRING_DWD=NULL;
 if (!_FUNC_DWD_STRING_DWD)_FUNC_DWD_STRING_DWD=qbs_new(0,0);
-qbs*oldstr4024=NULL;
+qbs*oldstr4031=NULL;
 if(_FUNC_DWD_STRING_EXP->tmp||_FUNC_DWD_STRING_EXP->fixed||_FUNC_DWD_STRING_EXP->readonly){
-oldstr4024=_FUNC_DWD_STRING_EXP;
-if (oldstr4024->cmem_descriptor){
-_FUNC_DWD_STRING_EXP=qbs_new_cmem(oldstr4024->len,0);
+oldstr4031=_FUNC_DWD_STRING_EXP;
+if (oldstr4031->cmem_descriptor){
+_FUNC_DWD_STRING_EXP=qbs_new_cmem(oldstr4031->len,0);
 }else{
-_FUNC_DWD_STRING_EXP=qbs_new(oldstr4024->len,0);
+_FUNC_DWD_STRING_EXP=qbs_new(oldstr4031->len,0);
 }
-memcpy(_FUNC_DWD_STRING_EXP->chr,oldstr4024->chr,oldstr4024->len);
+memcpy(_FUNC_DWD_STRING_EXP->chr,oldstr4031->chr,oldstr4031->len);
 }
 qbs *_FUNC_DWD_STRING_T=NULL;
 if (!_FUNC_DWD_STRING_T)_FUNC_DWD_STRING_T=qbs_new(0,0);
@ -17,16 +17,16 @@ if(_FUNC_DWD_LONG_L==NULL){
 _FUNC_DWD_LONG_L=(int32*)mem_static_malloc(4);
 *_FUNC_DWD_LONG_L=0;
 }
-int64 fornext_value4026;
-int64 fornext_finalvalue4026;
-int64 fornext_step4026;
-uint8 fornext_step_negative4026;
+int64 fornext_value4033;
+int64 fornext_finalvalue4033;
+int64 fornext_step4033;
+uint8 fornext_step_negative4033;
 qbs *_FUNC_DWD_STRING_ELE=NULL;
 if (!_FUNC_DWD_STRING_ELE)_FUNC_DWD_STRING_ELE=qbs_new(0,0);
 qbs *_FUNC_DWD_STRING_NEXTELE=NULL;
 if (!_FUNC_DWD_STRING_NEXTELE)_FUNC_DWD_STRING_NEXTELE=qbs_new(0,0);
-int32 pass4027;
-int32 pass4028;
-int32 pass4029;
-int32 pass4030;
-int32 pass4031;
+int32 pass4034;
+int32 pass4035;
+int32 pass4036;
+int32 pass4037;
+int32 pass4038;
--- a/internal/source/data179.txt
+++ b/internal/source/data179.txt
@ -1,12 +1,12 @@
-qbs*oldstr4032=NULL;
+qbs*oldstr4039=NULL;
 if(_SUB_PREPARSE_STRING_E->tmp||_SUB_PREPARSE_STRING_E->fixed||_SUB_PREPARSE_STRING_E->readonly){
-oldstr4032=_SUB_PREPARSE_STRING_E;
-if (oldstr4032->cmem_descriptor){
-_SUB_PREPARSE_STRING_E=qbs_new_cmem(oldstr4032->len,0);
+oldstr4039=_SUB_PREPARSE_STRING_E;
+if (oldstr4039->cmem_descriptor){
+_SUB_PREPARSE_STRING_E=qbs_new_cmem(oldstr4039->len,0);
 }else{
-_SUB_PREPARSE_STRING_E=qbs_new(oldstr4032->len,0);
+_SUB_PREPARSE_STRING_E=qbs_new(oldstr4039->len,0);
 }
-memcpy(_SUB_PREPARSE_STRING_E->chr,oldstr4032->chr,oldstr4032->len);
+memcpy(_SUB_PREPARSE_STRING_E->chr,oldstr4039->chr,oldstr4039->len);
 }
 qbs *_SUB_PREPARSE_STRING_T=NULL;
 if (!_SUB_PREPARSE_STRING_T)_SUB_PREPARSE_STRING_T=qbs_new(0,0);
@ -20,10 +20,10 @@ if(_SUB_PREPARSE_LONG_L==NULL){
 _SUB_PREPARSE_LONG_L=(int32*)mem_static_malloc(4);
 *_SUB_PREPARSE_LONG_L=0;
 }
-int64 fornext_value4034;
-int64 fornext_finalvalue4034;
-int64 fornext_step4034;
-uint8 fornext_step_negative4034;
+int64 fornext_value4041;
+int64 fornext_finalvalue4041;
+int64 fornext_step4041;
+uint8 fornext_step_negative4041;
 qbs *_SUB_PREPARSE_STRING_ELE=NULL;
 if (!_SUB_PREPARSE_STRING_ELE)_SUB_PREPARSE_STRING_ELE=qbs_new(0,0);
 int32 *_SUB_PREPARSE_LONG_C=NULL;
@ -31,18 +31,18 @@ if(_SUB_PREPARSE_LONG_C==NULL){
 _SUB_PREPARSE_LONG_C=(int32*)mem_static_malloc(4);
 *_SUB_PREPARSE_LONG_C=0;
 }
-int64 fornext_value4036;
-int64 fornext_finalvalue4036;
-int64 fornext_step4036;
-uint8 fornext_step_negative4036;
+int64 fornext_value4043;
+int64 fornext_finalvalue4043;
+int64 fornext_step4043;
+uint8 fornext_step_negative4043;
 int32 *_SUB_PREPARSE_LONG_L2=NULL;
 if(_SUB_PREPARSE_LONG_L2==NULL){
 _SUB_PREPARSE_LONG_L2=(int32*)mem_static_malloc(4);
 *_SUB_PREPARSE_LONG_L2=0;
 }
-int64 fornext_value4038;
-int64 fornext_finalvalue4038;
-int64 fornext_step4038;
-uint8 fornext_step_negative4038;
-int32 pass4039;
-int32 pass4040;
+int64 fornext_value4045;
+int64 fornext_finalvalue4045;
+int64 fornext_step4045;
+uint8 fornext_step_negative4045;
+int32 pass4046;
+int32 pass4047;
--- a/internal/source/data18.txt
+++ b/internal/source/data18.txt
@ -1,14 +1,14 @@
 qbs *_FUNC_EVALUATE_STRING_EVALUATE=NULL;
 if (!_FUNC_EVALUATE_STRING_EVALUATE)_FUNC_EVALUATE_STRING_EVALUATE=qbs_new(0,0);
-qbs*oldstr2575=NULL;
+qbs*oldstr2581=NULL;
 if(_FUNC_EVALUATE_STRING_A2->tmp||_FUNC_EVALUATE_STRING_A2->fixed||_FUNC_EVALUATE_STRING_A2->readonly){
-oldstr2575=_FUNC_EVALUATE_STRING_A2;
-if (oldstr2575->cmem_descriptor){
-_FUNC_EVALUATE_STRING_A2=qbs_new_cmem(oldstr2575->len,0);
+oldstr2581=_FUNC_EVALUATE_STRING_A2;
+if (oldstr2581->cmem_descriptor){
+_FUNC_EVALUATE_STRING_A2=qbs_new_cmem(oldstr2581->len,0);
 }else{
-_FUNC_EVALUATE_STRING_A2=qbs_new(oldstr2575->len,0);
+_FUNC_EVALUATE_STRING_A2=qbs_new(oldstr2581->len,0);
 }
-memcpy(_FUNC_EVALUATE_STRING_A2->chr,oldstr2575->chr,oldstr2575->len);
+memcpy(_FUNC_EVALUATE_STRING_A2->chr,oldstr2581->chr,oldstr2581->len);
 }
 ptrszint *_FUNC_EVALUATE_ARRAY_STRING_BLOCK=NULL;
 if (!_FUNC_EVALUATE_ARRAY_STRING_BLOCK){
@ -68,15 +68,15 @@ if(_FUNC_EVALUATE_LONG_I==NULL){
 _FUNC_EVALUATE_LONG_I=(int32*)mem_static_malloc(4);
 *_FUNC_EVALUATE_LONG_I=0;
 }
-int64 fornext_value2578;
-int64 fornext_finalvalue2578;
-int64 fornext_step2578;
-uint8 fornext_step_negative2578;
+int64 fornext_value2584;
+int64 fornext_finalvalue2584;
+int64 fornext_step2584;
+uint8 fornext_step_negative2584;
 qbs *_FUNC_EVALUATE_STRING_L=NULL;
 if (!_FUNC_EVALUATE_STRING_L)_FUNC_EVALUATE_STRING_L=qbs_new(0,0);
 qbs *_FUNC_EVALUATE_STRING_NEXTL=NULL;
 if (!_FUNC_EVALUATE_STRING_NEXTL)_FUNC_EVALUATE_STRING_NEXTL=qbs_new(0,0);
-int32 pass2580;
+int32 pass2586;
 qbs *_FUNC_EVALUATE_STRING_L2=NULL;
 if (!_FUNC_EVALUATE_STRING_L2)_FUNC_EVALUATE_STRING_L2=qbs_new(0,0);
 int32 *_FUNC_EVALUATE_LONG_TRY_METHOD=NULL;
@ -84,15 +84,15 @@ if(_FUNC_EVALUATE_LONG_TRY_METHOD==NULL){
 _FUNC_EVALUATE_LONG_TRY_METHOD=(int32*)mem_static_malloc(4);
 *_FUNC_EVALUATE_LONG_TRY_METHOD=0;
 }
-int64 fornext_value2583;
-int64 fornext_finalvalue2583;
-int64 fornext_step2583;
-uint8 fornext_step_negative2583;
+int64 fornext_value2589;
+int64 fornext_finalvalue2589;
+int64 fornext_step2589;
+uint8 fornext_step_negative2589;
 qbs *_FUNC_EVALUATE_STRING_DTYP=NULL;
 if (!_FUNC_EVALUATE_STRING_DTYP)_FUNC_EVALUATE_STRING_DTYP=qbs_new(0,0);
-byte_element_struct *byte_element_2584=NULL;
-if (!byte_element_2584){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2584=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2584=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_2590=NULL;
+if (!byte_element_2590){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2590=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2590=(byte_element_struct*)mem_static_malloc(12);
 }
 int32 *_FUNC_EVALUATE_LONG_V=NULL;
 if(_FUNC_EVALUATE_LONG_V==NULL){
@ -121,8 +121,8 @@ _FUNC_EVALUATE_LONG_B2=(int32*)mem_static_malloc(4);
 }
 qbs *_FUNC_EVALUATE_STRING_C=NULL;
 if (!_FUNC_EVALUATE_STRING_C)_FUNC_EVALUATE_STRING_C=qbs_new(0,0);
-int32 pass2587;
-int32 pass2588;
+int32 pass2593;
+int32 pass2594;
 int32 *_FUNC_EVALUATE_LONG_TYP2=NULL;
 if(_FUNC_EVALUATE_LONG_TYP2==NULL){
 _FUNC_EVALUATE_LONG_TYP2=(int32*)mem_static_malloc(4);
@ -130,9 +130,9 @@ _FUNC_EVALUATE_LONG_TYP2=(int32*)mem_static_malloc(4);
 }
 qbs *_FUNC_EVALUATE_STRING_O=NULL;
 if (!_FUNC_EVALUATE_STRING_O)_FUNC_EVALUATE_STRING_O=qbs_new(0,0);
-byte_element_struct *byte_element_2589=NULL;
-if (!byte_element_2589){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2589=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2589=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_2595=NULL;
+if (!byte_element_2595){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2595=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2595=(byte_element_struct*)mem_static_malloc(12);
 }
 int32 *_FUNC_EVALUATE_LONG_U=NULL;
 if(_FUNC_EVALUATE_LONG_U==NULL){
@ -149,10 +149,10 @@ if(_FUNC_EVALUATE_LONG_I3==NULL){
 _FUNC_EVALUATE_LONG_I3=(int32*)mem_static_malloc(4);
 *_FUNC_EVALUATE_LONG_I3=0;
 }
-int64 fornext_value2591;
-int64 fornext_finalvalue2591;
-int64 fornext_step2591;
-uint8 fornext_step_negative2591;
+int64 fornext_value2597;
+int64 fornext_finalvalue2597;
+int64 fornext_step2597;
+uint8 fornext_step_negative2597;
 qbs *_FUNC_EVALUATE_STRING_E2=NULL;
 if (!_FUNC_EVALUATE_STRING_E2)_FUNC_EVALUATE_STRING_E2=qbs_new(0,0);
 int32 *_FUNC_EVALUATE_LONG_I4=NULL;
@ -162,31 +162,31 @@ _FUNC_EVALUATE_LONG_I4=(int32*)mem_static_malloc(4);
 }
 qbs *_FUNC_EVALUATE_STRING_E=NULL;
 if (!_FUNC_EVALUATE_STRING_E)_FUNC_EVALUATE_STRING_E=qbs_new(0,0);
-int32 pass2592;
+int32 pass2598;
 int32 *_FUNC_EVALUATE_LONG_ARGS=NULL;
 if(_FUNC_EVALUATE_LONG_ARGS==NULL){
 _FUNC_EVALUATE_LONG_ARGS=(int32*)mem_static_malloc(4);
 *_FUNC_EVALUATE_LONG_ARGS=0;
 }
-int32 pass2593;
-int32 pass2594;
-int32 pass2595;
-int32 pass2596;
+int32 pass2599;
+int32 pass2600;
+int32 pass2601;
+int32 pass2602;
 int32 *_FUNC_EVALUATE_LONG_NUME=NULL;
 if(_FUNC_EVALUATE_LONG_NUME==NULL){
 _FUNC_EVALUATE_LONG_NUME=(int32*)mem_static_malloc(4);
 *_FUNC_EVALUATE_LONG_NUME=0;
 }
-int64 fornext_value2601;
-int64 fornext_finalvalue2601;
-int64 fornext_step2601;
-uint8 fornext_step_negative2601;
+int64 fornext_value2607;
+int64 fornext_finalvalue2607;
+int64 fornext_step2607;
+uint8 fornext_step_negative2607;
 qbs *_FUNC_EVALUATE_STRING_FAKEE=NULL;
 if (!_FUNC_EVALUATE_STRING_FAKEE)_FUNC_EVALUATE_STRING_FAKEE=qbs_new(0,0);
-int64 fornext_value2603;
-int64 fornext_finalvalue2603;
-int64 fornext_step2603;
-uint8 fornext_step_negative2603;
+int64 fornext_value2609;
+int64 fornext_finalvalue2609;
+int64 fornext_step2609;
+uint8 fornext_step_negative2609;
 int32 *_FUNC_EVALUATE_LONG_OLDDIMSTATIC=NULL;
 if(_FUNC_EVALUATE_LONG_OLDDIMSTATIC==NULL){
 _FUNC_EVALUATE_LONG_OLDDIMSTATIC=(int32*)mem_static_malloc(4);
@ -207,10 +207,10 @@ if(_FUNC_EVALUATE_LONG_X==NULL){
 _FUNC_EVALUATE_LONG_X=(int32*)mem_static_malloc(4);
 *_FUNC_EVALUATE_LONG_X=0;
 }
-int64 fornext_value2606;
-int64 fornext_finalvalue2606;
-int64 fornext_step2606;
-uint8 fornext_step_negative2606;
+int64 fornext_value2612;
+int64 fornext_finalvalue2612;
+int64 fornext_step2612;
+uint8 fornext_step_negative2612;
 qbs *_FUNC_EVALUATE_STRING_VARNAME2=NULL;
 if (!_FUNC_EVALUATE_STRING_VARNAME2)_FUNC_EVALUATE_STRING_VARNAME2=qbs_new(0,0);
 qbs *_FUNC_EVALUATE_STRING_TYP2=NULL;
@ -234,17 +234,17 @@ if(_FUNC_EVALUATE_LONG_I1==NULL){
 _FUNC_EVALUATE_LONG_I1=(int32*)mem_static_malloc(4);
 *_FUNC_EVALUATE_LONG_I1=0;
 }
-int32 pass2608;
+int32 pass2614;
 qbs *_FUNC_EVALUATE_STRING_R=NULL;
 if (!_FUNC_EVALUATE_STRING_R)_FUNC_EVALUATE_STRING_R=qbs_new(0,0);
-int64 fornext_value2611;
-int64 fornext_finalvalue2611;
-int64 fornext_step2611;
-uint8 fornext_step_negative2611;
-int64 fornext_value2615;
-int64 fornext_finalvalue2615;
-int64 fornext_step2615;
-uint8 fornext_step_negative2615;
+int64 fornext_value2617;
+int64 fornext_finalvalue2617;
+int64 fornext_step2617;
+uint8 fornext_step_negative2617;
+int64 fornext_value2621;
+int64 fornext_finalvalue2621;
+int64 fornext_step2621;
+uint8 fornext_step_negative2621;
 int32 *_FUNC_EVALUATE_LONG_C=NULL;
 if(_FUNC_EVALUATE_LONG_C==NULL){
 _FUNC_EVALUATE_LONG_C=(int32*)mem_static_malloc(4);
@ -261,29 +261,29 @@ qbs *_FUNC_EVALUATE_STRING_X=NULL;
 if (!_FUNC_EVALUATE_STRING_X)_FUNC_EVALUATE_STRING_X=qbs_new(0,0);
 qbs *_FUNC_EVALUATE_STRING_TYP=NULL;
 if (!_FUNC_EVALUATE_STRING_TYP)_FUNC_EVALUATE_STRING_TYP=qbs_new(0,0);
-byte_element_struct *byte_element_2616=NULL;
-if (!byte_element_2616){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2616=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2616=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_2622=NULL;
+if (!byte_element_2622){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2622=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2622=(byte_element_struct*)mem_static_malloc(12);
 }
 int32 *_FUNC_EVALUATE_LONG_RETVAL=NULL;
 if(_FUNC_EVALUATE_LONG_RETVAL==NULL){
 _FUNC_EVALUATE_LONG_RETVAL=(int32*)mem_static_malloc(4);
 *_FUNC_EVALUATE_LONG_RETVAL=0;
 }
-int32 pass2620;
-int32 pass2621;
-int8 pass2622;
-int32 pass2623;
-int32 pass2624;
+int32 pass2626;
+int32 pass2627;
+int8 pass2628;
+int32 pass2629;
+int32 pass2630;
 int32 *_FUNC_EVALUATE_LONG_NONOP=NULL;
 if(_FUNC_EVALUATE_LONG_NONOP==NULL){
 _FUNC_EVALUATE_LONG_NONOP=(int32*)mem_static_malloc(4);
 *_FUNC_EVALUATE_LONG_NONOP=0;
 }
-int64 fornext_value2628;
-int64 fornext_finalvalue2628;
-int64 fornext_step2628;
-uint8 fornext_step_negative2628;
+int64 fornext_value2634;
+int64 fornext_finalvalue2634;
+int64 fornext_step2634;
+uint8 fornext_step_negative2634;
 int32 *_FUNC_EVALUATE_LONG_ISOP=NULL;
 if(_FUNC_EVALUATE_LONG_ISOP==NULL){
 _FUNC_EVALUATE_LONG_ISOP=(int32*)mem_static_malloc(4);
@ -341,8 +341,8 @@ if(_FUNC_EVALUATE_LONG_B3==NULL){
 _FUNC_EVALUATE_LONG_B3=(int32*)mem_static_malloc(4);
 *_FUNC_EVALUATE_LONG_B3=0;
 }
-int64 fornext_value2631;
-int64 fornext_finalvalue2631;
-int64 fornext_step2631;
-uint8 fornext_step_negative2631;
-int32 pass2640;
+int64 fornext_value2637;
+int64 fornext_finalvalue2637;
+int64 fornext_step2637;
+uint8 fornext_step_negative2637;
+int32 pass2646;
--- a/internal/source/data180.txt
+++ b/internal/source/data180.txt
@ -3,22 +3,22 @@ if(_FUNC_ISFUNCTIONIDENTIFIER_LONG_ISFUNCTIONIDENTIFIER==NULL){
 _FUNC_ISFUNCTIONIDENTIFIER_LONG_ISFUNCTIONIDENTIFIER=(int32*)mem_static_malloc(4);
 *_FUNC_ISFUNCTIONIDENTIFIER_LONG_ISFUNCTIONIDENTIFIER=0;
 }
-qbs*oldstr4041=NULL;
+qbs*oldstr4048=NULL;
 if(_FUNC_ISFUNCTIONIDENTIFIER_STRING_ELE->tmp||_FUNC_ISFUNCTIONIDENTIFIER_STRING_ELE->fixed||_FUNC_ISFUNCTIONIDENTIFIER_STRING_ELE->readonly){
-oldstr4041=_FUNC_ISFUNCTIONIDENTIFIER_STRING_ELE;
-if (oldstr4041->cmem_descriptor){
-_FUNC_ISFUNCTIONIDENTIFIER_STRING_ELE=qbs_new_cmem(oldstr4041->len,0);
+oldstr4048=_FUNC_ISFUNCTIONIDENTIFIER_STRING_ELE;
+if (oldstr4048->cmem_descriptor){
+_FUNC_ISFUNCTIONIDENTIFIER_STRING_ELE=qbs_new_cmem(oldstr4048->len,0);
 }else{
-_FUNC_ISFUNCTIONIDENTIFIER_STRING_ELE=qbs_new(oldstr4041->len,0);
+_FUNC_ISFUNCTIONIDENTIFIER_STRING_ELE=qbs_new(oldstr4048->len,0);
 }
-memcpy(_FUNC_ISFUNCTIONIDENTIFIER_STRING_ELE->chr,oldstr4041->chr,oldstr4041->len);
+memcpy(_FUNC_ISFUNCTIONIDENTIFIER_STRING_ELE->chr,oldstr4048->chr,oldstr4048->len);
 }
 int32 *_FUNC_ISFUNCTIONIDENTIFIER_LONG_I=NULL;
 if(_FUNC_ISFUNCTIONIDENTIFIER_LONG_I==NULL){
 _FUNC_ISFUNCTIONIDENTIFIER_LONG_I=(int32*)mem_static_malloc(4);
 *_FUNC_ISFUNCTIONIDENTIFIER_LONG_I=0;
 }
-int64 fornext_value4043;
-int64 fornext_finalvalue4043;
-int64 fornext_step4043;
-uint8 fornext_step_negative4043;
+int64 fornext_value4050;
+int64 fornext_finalvalue4050;
+int64 fornext_step4050;
+uint8 fornext_step_negative4050;
--- a/internal/source/data181.txt
+++ b/internal/source/data181.txt
@ -3,24 +3,24 @@ if(_FUNC_HASHVALUE_LONG_HASHVALUE==NULL){
 _FUNC_HASHVALUE_LONG_HASHVALUE=(int32*)mem_static_malloc(4);
 *_FUNC_HASHVALUE_LONG_HASHVALUE=0;
 }
-qbs*oldstr4044=NULL;
+qbs*oldstr4051=NULL;
 if(_FUNC_HASHVALUE_STRING_A->tmp||_FUNC_HASHVALUE_STRING_A->fixed||_FUNC_HASHVALUE_STRING_A->readonly){
-oldstr4044=_FUNC_HASHVALUE_STRING_A;
-if (oldstr4044->cmem_descriptor){
-_FUNC_HASHVALUE_STRING_A=qbs_new_cmem(oldstr4044->len,0);
+oldstr4051=_FUNC_HASHVALUE_STRING_A;
+if (oldstr4051->cmem_descriptor){
+_FUNC_HASHVALUE_STRING_A=qbs_new_cmem(oldstr4051->len,0);
 }else{
-_FUNC_HASHVALUE_STRING_A=qbs_new(oldstr4044->len,0);
+_FUNC_HASHVALUE_STRING_A=qbs_new(oldstr4051->len,0);
 }
-memcpy(_FUNC_HASHVALUE_STRING_A->chr,oldstr4044->chr,oldstr4044->len);
+memcpy(_FUNC_HASHVALUE_STRING_A->chr,oldstr4051->chr,oldstr4051->len);
 }
 int32 *_FUNC_HASHVALUE_LONG_L=NULL;
 if(_FUNC_HASHVALUE_LONG_L==NULL){
 _FUNC_HASHVALUE_LONG_L=(int32*)mem_static_malloc(4);
 *_FUNC_HASHVALUE_LONG_L=0;
 }
-byte_element_struct *byte_element_4045=NULL;
-if (!byte_element_4045){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4045=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4045=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_4052=NULL;
+if (!byte_element_4052){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4052=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4052=(byte_element_struct*)mem_static_malloc(12);
 }
 int32 *_FUNC_HASHVALUE_LONG_A=NULL;
 if(_FUNC_HASHVALUE_LONG_A==NULL){
--- a/internal/source/data182.txt
+++ b/internal/source/data182.txt
@ -1,12 +1,12 @@
-qbs*oldstr4048=NULL;
+qbs*oldstr4055=NULL;
 if(_SUB_HASHADD_STRING_A->tmp||_SUB_HASHADD_STRING_A->fixed||_SUB_HASHADD_STRING_A->readonly){
-oldstr4048=_SUB_HASHADD_STRING_A;
-if (oldstr4048->cmem_descriptor){
-_SUB_HASHADD_STRING_A=qbs_new_cmem(oldstr4048->len,0);
+oldstr4055=_SUB_HASHADD_STRING_A;
+if (oldstr4055->cmem_descriptor){
+_SUB_HASHADD_STRING_A=qbs_new_cmem(oldstr4055->len,0);
 }else{
-_SUB_HASHADD_STRING_A=qbs_new(oldstr4048->len,0);
+_SUB_HASHADD_STRING_A=qbs_new(oldstr4055->len,0);
 }
-memcpy(_SUB_HASHADD_STRING_A->chr,oldstr4048->chr,oldstr4048->len);
+memcpy(_SUB_HASHADD_STRING_A->chr,oldstr4055->chr,oldstr4055->len);
 }
 int32 *_SUB_HASHADD_LONG_I=NULL;
 if(_SUB_HASHADD_LONG_I==NULL){
--- a/internal/source/data183.txt
+++ b/internal/source/data183.txt
@ -3,15 +3,15 @@ if(_FUNC_HASHFIND_LONG_HASHFIND==NULL){
 _FUNC_HASHFIND_LONG_HASHFIND=(int32*)mem_static_malloc(4);
 *_FUNC_HASHFIND_LONG_HASHFIND=0;
 }
-qbs*oldstr4049=NULL;
+qbs*oldstr4056=NULL;
 if(_FUNC_HASHFIND_STRING_A->tmp||_FUNC_HASHFIND_STRING_A->fixed||_FUNC_HASHFIND_STRING_A->readonly){
-oldstr4049=_FUNC_HASHFIND_STRING_A;
-if (oldstr4049->cmem_descriptor){
-_FUNC_HASHFIND_STRING_A=qbs_new_cmem(oldstr4049->len,0);
+oldstr4056=_FUNC_HASHFIND_STRING_A;
+if (oldstr4056->cmem_descriptor){
+_FUNC_HASHFIND_STRING_A=qbs_new_cmem(oldstr4056->len,0);
 }else{
-_FUNC_HASHFIND_STRING_A=qbs_new(oldstr4049->len,0);
+_FUNC_HASHFIND_STRING_A=qbs_new(oldstr4056->len,0);
 }
-memcpy(_FUNC_HASHFIND_STRING_A->chr,oldstr4049->chr,oldstr4049->len);
+memcpy(_FUNC_HASHFIND_STRING_A->chr,oldstr4056->chr,oldstr4056->len);
 }
 int32 *_FUNC_HASHFIND_LONG_I=NULL;
 if(_FUNC_HASHFIND_LONG_I==NULL){
@ -20,9 +20,9 @@ _FUNC_HASHFIND_LONG_I=(int32*)mem_static_malloc(4);
 }
 qbs *_FUNC_HASHFIND_STRING_UA=NULL;
 if (!_FUNC_HASHFIND_STRING_UA)_FUNC_HASHFIND_STRING_UA=qbs_new(0,0);
-byte_element_struct *byte_element_4050=NULL;
-if (!byte_element_4050){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4050=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4050=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_4057=NULL;
+if (!byte_element_4057){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4057=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4057=(byte_element_struct*)mem_static_malloc(12);
 }
 int32 *_FUNC_HASHFIND_LONG_F=NULL;
 if(_FUNC_HASHFIND_LONG_F==NULL){
--- a/internal/source/data184.txt
+++ b/internal/source/data184.txt
@ -3,15 +3,15 @@ if(_FUNC_HASHFINDREV_LONG_HASHFINDREV==NULL){
 _FUNC_HASHFINDREV_LONG_HASHFINDREV=(int32*)mem_static_malloc(4);
 *_FUNC_HASHFINDREV_LONG_HASHFINDREV=0;
 }
-qbs*oldstr4051=NULL;
+qbs*oldstr4058=NULL;
 if(_FUNC_HASHFINDREV_STRING_A->tmp||_FUNC_HASHFINDREV_STRING_A->fixed||_FUNC_HASHFINDREV_STRING_A->readonly){
-oldstr4051=_FUNC_HASHFINDREV_STRING_A;
-if (oldstr4051->cmem_descriptor){
-_FUNC_HASHFINDREV_STRING_A=qbs_new_cmem(oldstr4051->len,0);
+oldstr4058=_FUNC_HASHFINDREV_STRING_A;
+if (oldstr4058->cmem_descriptor){
+_FUNC_HASHFINDREV_STRING_A=qbs_new_cmem(oldstr4058->len,0);
 }else{
-_FUNC_HASHFINDREV_STRING_A=qbs_new(oldstr4051->len,0);
+_FUNC_HASHFINDREV_STRING_A=qbs_new(oldstr4058->len,0);
 }
-memcpy(_FUNC_HASHFINDREV_STRING_A->chr,oldstr4051->chr,oldstr4051->len);
+memcpy(_FUNC_HASHFINDREV_STRING_A->chr,oldstr4058->chr,oldstr4058->len);
 }
 int32 *_FUNC_HASHFINDREV_LONG_I=NULL;
 if(_FUNC_HASHFINDREV_LONG_I==NULL){
@ -20,9 +20,9 @@ _FUNC_HASHFINDREV_LONG_I=(int32*)mem_static_malloc(4);
 }
 qbs *_FUNC_HASHFINDREV_STRING_UA=NULL;
 if (!_FUNC_HASHFINDREV_STRING_UA)_FUNC_HASHFINDREV_STRING_UA=qbs_new(0,0);
-byte_element_struct *byte_element_4052=NULL;
-if (!byte_element_4052){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4052=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4052=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_4059=NULL;
+if (!byte_element_4059){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4059=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4059=(byte_element_struct*)mem_static_malloc(12);
 }
 int32 *_FUNC_HASHFINDREV_LONG_F=NULL;
 if(_FUNC_HASHFINDREV_LONG_F==NULL){
--- a/internal/source/data187.txt
+++ b/internal/source/data187.txt
@ -10,10 +10,10 @@ if(_SUB_HASHDUMP_LONG_X==NULL){
 _SUB_HASHDUMP_LONG_X=(int32*)mem_static_malloc(4);
 *_SUB_HASHDUMP_LONG_X=0;
 }
-int64 fornext_value4054;
-int64 fornext_finalvalue4054;
-int64 fornext_step4054;
-uint8 fornext_step_negative4054;
+int64 fornext_value4061;
+int64 fornext_finalvalue4061;
+int64 fornext_step4061;
+uint8 fornext_step_negative4061;
 int32 *_SUB_HASHDUMP_LONG_I=NULL;
 if(_SUB_HASHDUMP_LONG_I==NULL){
 _SUB_HASHDUMP_LONG_I=(int32*)mem_static_malloc(4);
@ -36,10 +36,10 @@ if(_SUB_HASHDUMP_LONG_Z==NULL){
 _SUB_HASHDUMP_LONG_Z=(int32*)mem_static_malloc(4);
 *_SUB_HASHDUMP_LONG_Z=0;
 }
-int64 fornext_value4058;
-int64 fornext_finalvalue4058;
-int64 fornext_step4058;
-uint8 fornext_step_negative4058;
+int64 fornext_value4065;
+int64 fornext_finalvalue4065;
+int64 fornext_step4065;
+uint8 fornext_step_negative4065;
 int32 *_SUB_HASHDUMP_LONG_I1=NULL;
 if(_SUB_HASHDUMP_LONG_I1==NULL){
 _SUB_HASHDUMP_LONG_I1=(int32*)mem_static_malloc(4);
--- a/internal/source/data19.txt
+++ b/internal/source/data19.txt
@ -1,14 +1,14 @@
 qbs *_FUNC_EVALUATEFUNC_STRING_EVALUATEFUNC=NULL;
 if (!_FUNC_EVALUATEFUNC_STRING_EVALUATEFUNC)_FUNC_EVALUATEFUNC_STRING_EVALUATEFUNC=qbs_new(0,0);
-qbs*oldstr2641=NULL;
+qbs*oldstr2647=NULL;
 if(_FUNC_EVALUATEFUNC_STRING_A2->tmp||_FUNC_EVALUATEFUNC_STRING_A2->fixed||_FUNC_EVALUATEFUNC_STRING_A2->readonly){
-oldstr2641=_FUNC_EVALUATEFUNC_STRING_A2;
-if (oldstr2641->cmem_descriptor){
-_FUNC_EVALUATEFUNC_STRING_A2=qbs_new_cmem(oldstr2641->len,0);
+oldstr2647=_FUNC_EVALUATEFUNC_STRING_A2;
+if (oldstr2647->cmem_descriptor){
+_FUNC_EVALUATEFUNC_STRING_A2=qbs_new_cmem(oldstr2647->len,0);
 }else{
-_FUNC_EVALUATEFUNC_STRING_A2=qbs_new(oldstr2641->len,0);
+_FUNC_EVALUATEFUNC_STRING_A2=qbs_new(oldstr2647->len,0);
 }
-memcpy(_FUNC_EVALUATEFUNC_STRING_A2->chr,oldstr2641->chr,oldstr2641->len);
+memcpy(_FUNC_EVALUATEFUNC_STRING_A2->chr,oldstr2647->chr,oldstr2647->len);
 }
 qbs *_FUNC_EVALUATEFUNC_STRING_A=NULL;
 if (!_FUNC_EVALUATEFUNC_STRING_A)_FUNC_EVALUATEFUNC_STRING_A=qbs_new(0,0);
@ -25,8 +25,8 @@ if(_FUNC_EVALUATEFUNC_LONG_TARGETID==NULL){
 _FUNC_EVALUATEFUNC_LONG_TARGETID=(int32*)mem_static_malloc(4);
 *_FUNC_EVALUATEFUNC_LONG_TARGETID=0;
 }
-int16 pass2643;
-int32 pass2644;
+int16 pass2649;
+int32 pass2650;
 int32 *_FUNC_EVALUATEFUNC_LONG_ARGCOUNT=NULL;
 if(_FUNC_EVALUATEFUNC_LONG_ARGCOUNT==NULL){
 _FUNC_EVALUATEFUNC_LONG_ARGCOUNT=(int32*)mem_static_malloc(4);
@ -61,28 +61,28 @@ _FUNC_EVALUATEFUNC_LONG_FIRSTOPTIONALARGUMENT=(int32*)mem_static_malloc(4);
 }
 qbs *_FUNC_EVALUATEFUNC_STRING_F=NULL;
 if (!_FUNC_EVALUATEFUNC_STRING_F)_FUNC_EVALUATEFUNC_STRING_F=qbs_new(0,0);
-byte_element_struct *byte_element_2645=NULL;
-if (!byte_element_2645){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2645=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2645=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_2651=NULL;
+if (!byte_element_2651){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2651=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2651=(byte_element_struct*)mem_static_malloc(12);
 }
 int32 *_FUNC_EVALUATEFUNC_LONG_FI=NULL;
 if(_FUNC_EVALUATEFUNC_LONG_FI==NULL){
 _FUNC_EVALUATEFUNC_LONG_FI=(int32*)mem_static_malloc(4);
 *_FUNC_EVALUATEFUNC_LONG_FI=0;
 }
-int64 fornext_value2647;
-int64 fornext_finalvalue2647;
-int64 fornext_step2647;
-uint8 fornext_step_negative2647;
+int64 fornext_value2653;
+int64 fornext_finalvalue2653;
+int64 fornext_step2653;
+uint8 fornext_step_negative2653;
 int32 *_FUNC_EVALUATEFUNC_LONG_SKIPFIRSTARG=NULL;
 if(_FUNC_EVALUATEFUNC_LONG_SKIPFIRSTARG==NULL){
 _FUNC_EVALUATEFUNC_LONG_SKIPFIRSTARG=(int32*)mem_static_malloc(4);
 *_FUNC_EVALUATEFUNC_LONG_SKIPFIRSTARG=0;
 }
-int64 fornext_value2649;
-int64 fornext_finalvalue2649;
-int64 fornext_step2649;
-uint8 fornext_step_negative2649;
+int64 fornext_value2655;
+int64 fornext_finalvalue2655;
+int64 fornext_step2655;
+uint8 fornext_step_negative2655;
 qbs *_FUNC_EVALUATEFUNC_STRING_R=NULL;
 if (!_FUNC_EVALUATEFUNC_STRING_R)_FUNC_EVALUATEFUNC_STRING_R=qbs_new(0,0);
 int32 *_FUNC_EVALUATEFUNC_LONG_CURARG=NULL;
@ -105,10 +105,10 @@ if(_FUNC_EVALUATEFUNC_LONG_I==NULL){
 _FUNC_EVALUATEFUNC_LONG_I=(int32*)mem_static_malloc(4);
 *_FUNC_EVALUATEFUNC_LONG_I=0;
 }
-int64 fornext_value2651;
-int64 fornext_finalvalue2651;
-int64 fornext_step2651;
-uint8 fornext_step_negative2651;
+int64 fornext_value2657;
+int64 fornext_finalvalue2657;
+int64 fornext_step2657;
+uint8 fornext_step_negative2657;
 qbs *_FUNC_EVALUATEFUNC_STRING_L=NULL;
 if (!_FUNC_EVALUATEFUNC_STRING_L)_FUNC_EVALUATEFUNC_STRING_L=qbs_new(0,0);
 int32 *_FUNC_EVALUATEFUNC_LONG_B=NULL;
@ -133,7 +133,7 @@ _FUNC_EVALUATEFUNC_LONG_NELEREQ=(int32*)mem_static_malloc(4);
 }
 qbs *_FUNC_EVALUATEFUNC_STRING_E=NULL;
 if (!_FUNC_EVALUATEFUNC_STRING_E)_FUNC_EVALUATEFUNC_STRING_E=qbs_new(0,0);
-int32 pass2652;
+int32 pass2658;
 int32 *_FUNC_EVALUATEFUNC_LONG_DEREFERENCE=NULL;
 if(_FUNC_EVALUATEFUNC_LONG_DEREFERENCE==NULL){
 _FUNC_EVALUATEFUNC_LONG_DEREFERENCE=(int32*)mem_static_malloc(4);
@ -157,34 +157,34 @@ if(_FUNC_EVALUATEFUNC_LONG_KET==NULL){
 _FUNC_EVALUATEFUNC_LONG_KET=(int32*)mem_static_malloc(4);
 *_FUNC_EVALUATEFUNC_LONG_KET=0;
 }
-byte_element_struct *byte_element_2654=NULL;
-if (!byte_element_2654){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2654=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2654=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_2660=NULL;
+if (!byte_element_2660){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2660=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2660=(byte_element_struct*)mem_static_malloc(12);
 }
-static int32 sc_2655;
+static int32 sc_2661;
 int32 *_FUNC_EVALUATEFUNC_LONG_RSI=NULL;
 if(_FUNC_EVALUATEFUNC_LONG_RSI==NULL){
 _FUNC_EVALUATEFUNC_LONG_RSI=(int32*)mem_static_malloc(4);
 *_FUNC_EVALUATEFUNC_LONG_RSI=0;
 }
-int64 fornext_value2657;
-int64 fornext_finalvalue2657;
-int64 fornext_step2657;
-uint8 fornext_step_negative2657;
-byte_element_struct *byte_element_2658=NULL;
-if (!byte_element_2658){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2658=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2658=(byte_element_struct*)mem_static_malloc(12);
+int64 fornext_value2663;
+int64 fornext_finalvalue2663;
+int64 fornext_step2663;
+uint8 fornext_step_negative2663;
+byte_element_struct *byte_element_2664=NULL;
+if (!byte_element_2664){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2664=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2664=(byte_element_struct*)mem_static_malloc(12);
 }
-static int32 sc_2659;
+static int32 sc_2665;
 int32 *_FUNC_EVALUATEFUNC_LONG_EFLUB=NULL;
 if(_FUNC_EVALUATEFUNC_LONG_EFLUB==NULL){
 _FUNC_EVALUATEFUNC_LONG_EFLUB=(int32*)mem_static_malloc(4);
 *_FUNC_EVALUATEFUNC_LONG_EFLUB=0;
 }
-int64 fornext_value2661;
-int64 fornext_finalvalue2661;
-int64 fornext_step2661;
-uint8 fornext_step_negative2661;
+int64 fornext_value2667;
+int64 fornext_finalvalue2667;
+int64 fornext_step2667;
+uint8 fornext_step_negative2667;
 int32 *_FUNC_EVALUATEFUNC_LONG_SOURCETYP=NULL;
 if(_FUNC_EVALUATEFUNC_LONG_SOURCETYP==NULL){
 _FUNC_EVALUATEFUNC_LONG_SOURCETYP=(int32*)mem_static_malloc(4);
@ -197,22 +197,22 @@ if(_FUNC_EVALUATEFUNC_LONG_ULBOUNDARRAYTYP==NULL){
 _FUNC_EVALUATEFUNC_LONG_ULBOUNDARRAYTYP=(int32*)mem_static_malloc(4);
 *_FUNC_EVALUATEFUNC_LONG_ULBOUNDARRAYTYP=0;
 }
-byte_element_struct *byte_element_2662=NULL;
-if (!byte_element_2662){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2662=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2662=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_2668=NULL;
+if (!byte_element_2668){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2668=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2668=(byte_element_struct*)mem_static_malloc(12);
 }
-int32 pass2663;
+int32 pass2669;
 qbs *_FUNC_EVALUATEFUNC_STRING_MEMGET_BLK=NULL;
 if (!_FUNC_EVALUATEFUNC_STRING_MEMGET_BLK)_FUNC_EVALUATEFUNC_STRING_MEMGET_BLK=qbs_new(0,0);
 qbs *_FUNC_EVALUATEFUNC_STRING_MEMGET_OFFS=NULL;
 if (!_FUNC_EVALUATEFUNC_STRING_MEMGET_OFFS)_FUNC_EVALUATEFUNC_STRING_MEMGET_OFFS=qbs_new(0,0);
-byte_element_struct *byte_element_2664=NULL;
-if (!byte_element_2664){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2664=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2664=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_2670=NULL;
+if (!byte_element_2670){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2670=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2670=(byte_element_struct*)mem_static_malloc(12);
 }
-byte_element_struct *byte_element_2665=NULL;
-if (!byte_element_2665){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2665=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2665=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_2671=NULL;
+if (!byte_element_2671){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2671=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2671=(byte_element_struct*)mem_static_malloc(12);
 }
 int32 *_FUNC_EVALUATEFUNC_LONG_T=NULL;
 if(_FUNC_EVALUATEFUNC_LONG_T==NULL){
@ -228,24 +228,24 @@ qbs *_FUNC_EVALUATEFUNC_STRING_MEMGET_CTYP=NULL;
 if (!_FUNC_EVALUATEFUNC_STRING_MEMGET_CTYP)_FUNC_EVALUATEFUNC_STRING_MEMGET_CTYP=qbs_new(0,0);
 qbs *_FUNC_EVALUATEFUNC_STRING_OFFS=NULL;
 if (!_FUNC_EVALUATEFUNC_STRING_OFFS)_FUNC_EVALUATEFUNC_STRING_OFFS=qbs_new(0,0);
-int32 pass2666;
+int32 pass2672;
 qbs *_FUNC_EVALUATEFUNC_STRING_BLKOFFS=NULL;
 if (!_FUNC_EVALUATEFUNC_STRING_BLKOFFS)_FUNC_EVALUATEFUNC_STRING_BLKOFFS=qbs_new(0,0);
-int32 pass2667;
+int32 pass2673;
 qbs *_FUNC_EVALUATEFUNC_STRING_E2=NULL;
 if (!_FUNC_EVALUATEFUNC_STRING_E2)_FUNC_EVALUATEFUNC_STRING_E2=qbs_new(0,0);
 qbs *_FUNC_EVALUATEFUNC_STRING_ROTLR_N=NULL;
 if (!_FUNC_EVALUATEFUNC_STRING_ROTLR_N)_FUNC_EVALUATEFUNC_STRING_ROTLR_N=qbs_new(0,0);
-int32 pass2668;
-int32 pass2669;
-int32 pass2670;
-byte_element_struct *byte_element_2671=NULL;
-if (!byte_element_2671){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2671=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2671=(byte_element_struct*)mem_static_malloc(12);
-}
-int32 pass2672;
-int32 pass2673;
 int32 pass2674;
+int32 pass2675;
+int32 pass2676;
+byte_element_struct *byte_element_2677=NULL;
+if (!byte_element_2677){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2677=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2677=(byte_element_struct*)mem_static_malloc(12);
+}
+int32 pass2678;
+int32 pass2679;
+int32 pass2680;
 int32 *_FUNC_EVALUATEFUNC_LONG_BITS=NULL;
 if(_FUNC_EVALUATEFUNC_LONG_BITS==NULL){
 _FUNC_EVALUATEFUNC_LONG_BITS=(int32*)mem_static_malloc(4);
@ -256,22 +256,22 @@ if(_FUNC_EVALUATEFUNC_LONG_WASREF==NULL){
 _FUNC_EVALUATEFUNC_LONG_WASREF=(int32*)mem_static_malloc(4);
 *_FUNC_EVALUATEFUNC_LONG_WASREF=0;
 }
-int32 pass2675;
-int32 pass2676;
-int32 pass2677;
+int32 pass2681;
+int32 pass2682;
+int32 pass2683;
 int32 *_FUNC_EVALUATEFUNC_LONG_CHARS=NULL;
 if(_FUNC_EVALUATEFUNC_LONG_CHARS==NULL){
 _FUNC_EVALUATEFUNC_LONG_CHARS=(int32*)mem_static_malloc(4);
 *_FUNC_EVALUATEFUNC_LONG_CHARS=0;
 }
-int32 pass2678;
-int32 pass2679;
-int32 pass2680;
-int32 pass2681;
-int32 pass2682;
-int32 pass2683;
 int32 pass2684;
 int32 pass2685;
+int32 pass2686;
+int32 pass2687;
+int32 pass2688;
+int32 pass2689;
+int32 pass2690;
+int32 pass2691;
 int32 *_FUNC_EVALUATEFUNC_LONG_MKTYPE=NULL;
 if(_FUNC_EVALUATEFUNC_LONG_MKTYPE==NULL){
 _FUNC_EVALUATEFUNC_LONG_MKTYPE=(int32*)mem_static_malloc(4);
@ -289,13 +289,13 @@ _FUNC_EVALUATEFUNC_LONG_QTYP=(int32*)mem_static_malloc(4);
 }
 qbs *_FUNC_EVALUATEFUNC_STRING_CTYPE=NULL;
 if (!_FUNC_EVALUATEFUNC_STRING_CTYPE)_FUNC_EVALUATEFUNC_STRING_CTYPE=qbs_new(0,0);
-byte_element_struct *byte_element_2686=NULL;
-if (!byte_element_2686){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2686=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2686=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_2692=NULL;
+if (!byte_element_2692){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2692=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2692=(byte_element_struct*)mem_static_malloc(12);
 }
-byte_element_struct *byte_element_2687=NULL;
-if (!byte_element_2687){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2687=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2687=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_2693=NULL;
+if (!byte_element_2693){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2693=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2693=(byte_element_struct*)mem_static_malloc(12);
 }
 int32 *_FUNC_EVALUATEFUNC_LONG_NOCOMMA=NULL;
 if(_FUNC_EVALUATEFUNC_LONG_NOCOMMA==NULL){
@ -307,20 +307,20 @@ if(_FUNC_EVALUATEFUNC_LONG_CVTYPE==NULL){
 _FUNC_EVALUATEFUNC_LONG_CVTYPE=(int32*)mem_static_malloc(4);
 *_FUNC_EVALUATEFUNC_LONG_CVTYPE=0;
 }
-int32 pass2688;
-byte_element_struct *byte_element_2689=NULL;
-if (!byte_element_2689){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2689=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2689=(byte_element_struct*)mem_static_malloc(12);
-}
-byte_element_struct *byte_element_2690=NULL;
-if (!byte_element_2690){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2690=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2690=(byte_element_struct*)mem_static_malloc(12);
-}
-int32 pass2691;
-int32 pass2692;
-int32 pass2693;
 int32 pass2694;
-int32 pass2695;
+byte_element_struct *byte_element_2695=NULL;
+if (!byte_element_2695){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2695=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2695=(byte_element_struct*)mem_static_malloc(12);
+}
+byte_element_struct *byte_element_2696=NULL;
+if (!byte_element_2696){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2696=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2696=(byte_element_struct*)mem_static_malloc(12);
+}
+int32 pass2697;
+int32 pass2698;
+int32 pass2699;
+int32 pass2700;
+int32 pass2701;
 int32 *_FUNC_EVALUATEFUNC_LONG_M=NULL;
 if(_FUNC_EVALUATEFUNC_LONG_M==NULL){
 _FUNC_EVALUATEFUNC_LONG_M=(int32*)mem_static_malloc(4);
@ -328,34 +328,11 @@ _FUNC_EVALUATEFUNC_LONG_M=(int32*)mem_static_malloc(4);
 }
 qbs *_FUNC_EVALUATEFUNC_STRING_INDEX=NULL;
 if (!_FUNC_EVALUATEFUNC_STRING_INDEX)_FUNC_EVALUATEFUNC_STRING_INDEX=qbs_new(0,0);
-byte_element_struct *byte_element_2696=NULL;
-if (!byte_element_2696){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2696=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2696=(byte_element_struct*)mem_static_malloc(12);
-}
-int32 pass2697;
-byte_element_struct *byte_element_2698=NULL;
-if (!byte_element_2698){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2698=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2698=(byte_element_struct*)mem_static_malloc(12);
-}
-byte_element_struct *byte_element_2699=NULL;
-if (!byte_element_2699){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2699=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2699=(byte_element_struct*)mem_static_malloc(12);
-}
-qbs *_FUNC_EVALUATEFUNC_STRING_O=NULL;
-if (!_FUNC_EVALUATEFUNC_STRING_O)_FUNC_EVALUATEFUNC_STRING_O=qbs_new(0,0);
-byte_element_struct *byte_element_2700=NULL;
-if (!byte_element_2700){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2700=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2700=(byte_element_struct*)mem_static_malloc(12);
-}
-byte_element_struct *byte_element_2701=NULL;
-if (!byte_element_2701){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2701=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2701=(byte_element_struct*)mem_static_malloc(12);
-}
-int32 pass2702;
-byte_element_struct *byte_element_2703=NULL;
-if (!byte_element_2703){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2703=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2703=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_2702=NULL;
+if (!byte_element_2702){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2702=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2702=(byte_element_struct*)mem_static_malloc(12);
 }
+int32 pass2703;
 byte_element_struct *byte_element_2704=NULL;
 if (!byte_element_2704){
 if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2704=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2704=(byte_element_struct*)mem_static_malloc(12);
@ -364,29 +341,52 @@ byte_element_struct *byte_element_2705=NULL;
 if (!byte_element_2705){
 if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2705=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2705=(byte_element_struct*)mem_static_malloc(12);
 }
-int32 pass2706;
-int32 pass2707;
+qbs *_FUNC_EVALUATEFUNC_STRING_O=NULL;
+if (!_FUNC_EVALUATEFUNC_STRING_O)_FUNC_EVALUATEFUNC_STRING_O=qbs_new(0,0);
+byte_element_struct *byte_element_2706=NULL;
+if (!byte_element_2706){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2706=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2706=(byte_element_struct*)mem_static_malloc(12);
+}
+byte_element_struct *byte_element_2707=NULL;
+if (!byte_element_2707){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2707=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2707=(byte_element_struct*)mem_static_malloc(12);
+}
 int32 pass2708;
-int32 pass2709;
-int32 pass2710;
-int32 pass2711;
+byte_element_struct *byte_element_2709=NULL;
+if (!byte_element_2709){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2709=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2709=(byte_element_struct*)mem_static_malloc(12);
+}
+byte_element_struct *byte_element_2710=NULL;
+if (!byte_element_2710){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2710=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2710=(byte_element_struct*)mem_static_malloc(12);
+}
+byte_element_struct *byte_element_2711=NULL;
+if (!byte_element_2711){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2711=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2711=(byte_element_struct*)mem_static_malloc(12);
+}
 int32 pass2712;
-byte_element_struct *byte_element_2713=NULL;
-if (!byte_element_2713){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2713=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2713=(byte_element_struct*)mem_static_malloc(12);
-}
-byte_element_struct *byte_element_2714=NULL;
-if (!byte_element_2714){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2714=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2714=(byte_element_struct*)mem_static_malloc(12);
-}
-byte_element_struct *byte_element_2715=NULL;
-if (!byte_element_2715){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2715=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2715=(byte_element_struct*)mem_static_malloc(12);
-}
+int32 pass2713;
+int32 pass2714;
+int32 pass2715;
 int32 pass2716;
 int32 pass2717;
 int32 pass2718;
-int32 pass2719;
+byte_element_struct *byte_element_2719=NULL;
+if (!byte_element_2719){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2719=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2719=(byte_element_struct*)mem_static_malloc(12);
+}
+byte_element_struct *byte_element_2720=NULL;
+if (!byte_element_2720){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2720=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2720=(byte_element_struct*)mem_static_malloc(12);
+}
+byte_element_struct *byte_element_2721=NULL;
+if (!byte_element_2721){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2721=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2721=(byte_element_struct*)mem_static_malloc(12);
+}
+int32 pass2722;
+int32 pass2723;
+int32 pass2724;
+int32 pass2725;
 int32 *_FUNC_EVALUATEFUNC_LONG_EXPLICITREFERENCE=NULL;
 if(_FUNC_EVALUATEFUNC_LONG_EXPLICITREFERENCE==NULL){
 _FUNC_EVALUATEFUNC_LONG_EXPLICITREFERENCE=(int32*)mem_static_malloc(4);
@ -432,9 +432,9 @@ if(_FUNC_EVALUATEFUNC_LONG_UDTREFE==NULL){
 _FUNC_EVALUATEFUNC_LONG_UDTREFE=(int32*)mem_static_malloc(4);
 *_FUNC_EVALUATEFUNC_LONG_UDTREFE=0;
 }
-byte_element_struct *byte_element_2722=NULL;
-if (!byte_element_2722){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2722=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2722=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_2728=NULL;
+if (!byte_element_2728){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2728=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2728=(byte_element_struct*)mem_static_malloc(12);
 }
 int32 *_FUNC_EVALUATEFUNC_LONG_IDNUM=NULL;
 if(_FUNC_EVALUATEFUNC_LONG_IDNUM==NULL){
@ -446,7 +446,7 @@ if(_FUNC_EVALUATEFUNC_LONG_TARGETTYPSIZE==NULL){
 _FUNC_EVALUATEFUNC_LONG_TARGETTYPSIZE=(int32*)mem_static_malloc(4);
 *_FUNC_EVALUATEFUNC_LONG_TARGETTYPSIZE=0;
 }
-int32 pass2723;
+int32 pass2729;
 int32 *_FUNC_EVALUATEFUNC_LONG_ARR=NULL;
 if(_FUNC_EVALUATEFUNC_LONG_ARR==NULL){
 _FUNC_EVALUATEFUNC_LONG_ARR=(int32*)mem_static_malloc(4);
@ -457,55 +457,55 @@ if(_FUNC_EVALUATEFUNC_LONG_PASSUDTELEMENT==NULL){
 _FUNC_EVALUATEFUNC_LONG_PASSUDTELEMENT=(int32*)mem_static_malloc(4);
 *_FUNC_EVALUATEFUNC_LONG_PASSUDTELEMENT=0;
 }
-byte_element_struct *byte_element_2724=NULL;
-if (!byte_element_2724){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2724=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2724=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_2730=NULL;
+if (!byte_element_2730){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_2730=(byte_element_struct*)(mem_static_pointer-12); else byte_element_2730=(byte_element_struct*)mem_static_malloc(12);
 }
 qbs *_FUNC_EVALUATEFUNC_STRING_N2=NULL;
 if (!_FUNC_EVALUATEFUNC_STRING_N2)_FUNC_EVALUATEFUNC_STRING_N2=qbs_new(0,0);
-int32 pass2725;
-int32 pass2726;
-int32 pass2727;
-int32 pass2728;
+int32 pass2731;
+int32 pass2732;
+int32 pass2733;
+int32 pass2734;
 int32 *_FUNC_EVALUATEFUNC_LONG_NTH=NULL;
 if(_FUNC_EVALUATEFUNC_LONG_NTH==NULL){
 _FUNC_EVALUATEFUNC_LONG_NTH=(int32*)mem_static_malloc(4);
 *_FUNC_EVALUATEFUNC_LONG_NTH=0;
 }
-int32 pass2729;
+int32 pass2735;
 qbs *_FUNC_EVALUATEFUNC_STRING_X=NULL;
 if (!_FUNC_EVALUATEFUNC_STRING_X)_FUNC_EVALUATEFUNC_STRING_X=qbs_new(0,0);
 qbs *_FUNC_EVALUATEFUNC_STRING_T=NULL;
 if (!_FUNC_EVALUATEFUNC_STRING_T)_FUNC_EVALUATEFUNC_STRING_T=qbs_new(0,0);
 qbs *_FUNC_EVALUATEFUNC_STRING_V=NULL;
 if (!_FUNC_EVALUATEFUNC_STRING_V)_FUNC_EVALUATEFUNC_STRING_V=qbs_new(0,0);
-int32 pass2730;
+int32 pass2736;
 int32 *_FUNC_EVALUATEFUNC_LONG_BYTESREQ=NULL;
 if(_FUNC_EVALUATEFUNC_LONG_BYTESREQ==NULL){
 _FUNC_EVALUATEFUNC_LONG_BYTESREQ=(int32*)mem_static_malloc(4);
 *_FUNC_EVALUATEFUNC_LONG_BYTESREQ=0;
 }
-int16 pass2731;
-int16 pass2732;
-int16 pass2733;
-int16 pass2734;
-int16 pass2735;
-int16 pass2736;
-int64 fornext_value2738;
-int64 fornext_finalvalue2738;
-int64 fornext_step2738;
-uint8 fornext_step_negative2738;
+int16 pass2737;
+int16 pass2738;
+int16 pass2739;
+int16 pass2740;
+int16 pass2741;
+int16 pass2742;
+int64 fornext_value2744;
+int64 fornext_finalvalue2744;
+int64 fornext_step2744;
+uint8 fornext_step_negative2744;
 qbs *_FUNC_EVALUATEFUNC_STRING_R2=NULL;
 if (!_FUNC_EVALUATEFUNC_STRING_R2)_FUNC_EVALUATEFUNC_STRING_R2=qbs_new(0,0);
-int32 pass2739;
+int32 pass2745;
 int32 *_FUNC_EVALUATEFUNC_LONG_ARRAYELEMENTS=NULL;
 if(_FUNC_EVALUATEFUNC_LONG_ARRAYELEMENTS==NULL){
 _FUNC_EVALUATEFUNC_LONG_ARRAYELEMENTS=(int32*)mem_static_malloc(4);
 *_FUNC_EVALUATEFUNC_LONG_ARRAYELEMENTS=0;
 }
-int64 fornext_value2741;
-int64 fornext_finalvalue2741;
-int64 fornext_step2741;
-uint8 fornext_step_negative2741;
-int32 pass2742;
-int32 pass2743;
+int64 fornext_value2747;
+int64 fornext_finalvalue2747;
+int64 fornext_step2747;
+uint8 fornext_step_negative2747;
+int32 pass2748;
+int32 pass2749;
--- a/internal/source/data192.txt
+++ b/internal/source/data192.txt
@ -1,14 +1,14 @@
 qbs *_FUNC_SYMBOL2FULLTYPENAME_STRING_SYMBOL2FULLTYPENAME=NULL;
 if (!_FUNC_SYMBOL2FULLTYPENAME_STRING_SYMBOL2FULLTYPENAME)_FUNC_SYMBOL2FULLTYPENAME_STRING_SYMBOL2FULLTYPENAME=qbs_new(0,0);
-qbs*oldstr4062=NULL;
+qbs*oldstr4069=NULL;
 if(_FUNC_SYMBOL2FULLTYPENAME_STRING_S2->tmp||_FUNC_SYMBOL2FULLTYPENAME_STRING_S2->fixed||_FUNC_SYMBOL2FULLTYPENAME_STRING_S2->readonly){
-oldstr4062=_FUNC_SYMBOL2FULLTYPENAME_STRING_S2;
-if (oldstr4062->cmem_descriptor){
-_FUNC_SYMBOL2FULLTYPENAME_STRING_S2=qbs_new_cmem(oldstr4062->len,0);
+oldstr4069=_FUNC_SYMBOL2FULLTYPENAME_STRING_S2;
+if (oldstr4069->cmem_descriptor){
+_FUNC_SYMBOL2FULLTYPENAME_STRING_S2=qbs_new_cmem(oldstr4069->len,0);
 }else{
-_FUNC_SYMBOL2FULLTYPENAME_STRING_S2=qbs_new(oldstr4062->len,0);
+_FUNC_SYMBOL2FULLTYPENAME_STRING_S2=qbs_new(oldstr4069->len,0);
 }
-memcpy(_FUNC_SYMBOL2FULLTYPENAME_STRING_S2->chr,oldstr4062->chr,oldstr4062->len);
+memcpy(_FUNC_SYMBOL2FULLTYPENAME_STRING_S2->chr,oldstr4069->chr,oldstr4069->len);
 }
 qbs *_FUNC_SYMBOL2FULLTYPENAME_STRING_S=NULL;
 if (!_FUNC_SYMBOL2FULLTYPENAME_STRING_S)_FUNC_SYMBOL2FULLTYPENAME_STRING_S=qbs_new(0,0);
@ -19,42 +19,42 @@ _FUNC_SYMBOL2FULLTYPENAME_LONG_U=(int32*)mem_static_malloc(4);
 }
 qbs *_FUNC_SYMBOL2FULLTYPENAME_STRING_TYP=NULL;
 if (!_FUNC_SYMBOL2FULLTYPENAME_STRING_TYP)_FUNC_SYMBOL2FULLTYPENAME_STRING_TYP=qbs_new(0,0);
-byte_element_struct *byte_element_4063=NULL;
-if (!byte_element_4063){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4063=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4063=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_4070=NULL;
+if (!byte_element_4070){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4070=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4070=(byte_element_struct*)mem_static_malloc(12);
 }
-byte_element_struct *byte_element_4064=NULL;
-if (!byte_element_4064){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4064=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4064=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_4071=NULL;
+if (!byte_element_4071){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4071=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4071=(byte_element_struct*)mem_static_malloc(12);
 }
 qbs *_FUNC_SYMBOL2FULLTYPENAME_STRING_U=NULL;
 if (!_FUNC_SYMBOL2FULLTYPENAME_STRING_U)_FUNC_SYMBOL2FULLTYPENAME_STRING_U=qbs_new(0,0);
 qbs *_FUNC_SYMBOL2FULLTYPENAME_STRING_T=NULL;
 if (!_FUNC_SYMBOL2FULLTYPENAME_STRING_T)_FUNC_SYMBOL2FULLTYPENAME_STRING_T=qbs_new(0,0);
-byte_element_struct *byte_element_4065=NULL;
-if (!byte_element_4065){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4065=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4065=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_4072=NULL;
+if (!byte_element_4072){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4072=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4072=(byte_element_struct*)mem_static_malloc(12);
 }
 qbs *_FUNC_SYMBOL2FULLTYPENAME_STRING_N=NULL;
 if (!_FUNC_SYMBOL2FULLTYPENAME_STRING_N)_FUNC_SYMBOL2FULLTYPENAME_STRING_N=qbs_new(0,0);
-byte_element_struct *byte_element_4066=NULL;
-if (!byte_element_4066){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4066=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4066=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_4073=NULL;
+if (!byte_element_4073){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4073=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4073=(byte_element_struct*)mem_static_malloc(12);
 }
-byte_element_struct *byte_element_4067=NULL;
-if (!byte_element_4067){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4067=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4067=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_4074=NULL;
+if (!byte_element_4074){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4074=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4074=(byte_element_struct*)mem_static_malloc(12);
 }
 int32 *_FUNC_SYMBOL2FULLTYPENAME_LONG_I=NULL;
 if(_FUNC_SYMBOL2FULLTYPENAME_LONG_I==NULL){
 _FUNC_SYMBOL2FULLTYPENAME_LONG_I=(int32*)mem_static_malloc(4);
 *_FUNC_SYMBOL2FULLTYPENAME_LONG_I=0;
 }
-int64 fornext_value4069;
-int64 fornext_finalvalue4069;
-int64 fornext_step4069;
-uint8 fornext_step_negative4069;
-byte_element_struct *byte_element_4070=NULL;
-if (!byte_element_4070){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4070=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4070=(byte_element_struct*)mem_static_malloc(12);
+int64 fornext_value4076;
+int64 fornext_finalvalue4076;
+int64 fornext_step4076;
+uint8 fornext_step_negative4076;
+byte_element_struct *byte_element_4077=NULL;
+if (!byte_element_4077){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4077=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4077=(byte_element_struct*)mem_static_malloc(12);
 }
--- a/internal/source/data193.txt
+++ b/internal/source/data193.txt
@ -3,19 +3,19 @@ if(_FUNC_SYMBOLTYPE_LONG_SYMBOLTYPE==NULL){
 _FUNC_SYMBOLTYPE_LONG_SYMBOLTYPE=(int32*)mem_static_malloc(4);
 *_FUNC_SYMBOLTYPE_LONG_SYMBOLTYPE=0;
 }
-qbs*oldstr4071=NULL;
+qbs*oldstr4078=NULL;
 if(_FUNC_SYMBOLTYPE_STRING_S->tmp||_FUNC_SYMBOLTYPE_STRING_S->fixed||_FUNC_SYMBOLTYPE_STRING_S->readonly){
-oldstr4071=_FUNC_SYMBOLTYPE_STRING_S;
-if (oldstr4071->cmem_descriptor){
-_FUNC_SYMBOLTYPE_STRING_S=qbs_new_cmem(oldstr4071->len,0);
+oldstr4078=_FUNC_SYMBOLTYPE_STRING_S;
+if (oldstr4078->cmem_descriptor){
+_FUNC_SYMBOLTYPE_STRING_S=qbs_new_cmem(oldstr4078->len,0);
 }else{
-_FUNC_SYMBOLTYPE_STRING_S=qbs_new(oldstr4071->len,0);
+_FUNC_SYMBOLTYPE_STRING_S=qbs_new(oldstr4078->len,0);
 }
-memcpy(_FUNC_SYMBOLTYPE_STRING_S->chr,oldstr4071->chr,oldstr4071->len);
+memcpy(_FUNC_SYMBOLTYPE_STRING_S->chr,oldstr4078->chr,oldstr4078->len);
 }
-byte_element_struct *byte_element_4072=NULL;
-if (!byte_element_4072){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4072=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4072=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_4079=NULL;
+if (!byte_element_4079){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4079=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4079=(byte_element_struct*)mem_static_malloc(12);
 }
 int32 *_FUNC_SYMBOLTYPE_LONG_A=NULL;
 if(_FUNC_SYMBOLTYPE_LONG_A==NULL){
@ -27,9 +27,9 @@ if(_FUNC_SYMBOLTYPE_LONG_L==NULL){
 _FUNC_SYMBOLTYPE_LONG_L=(int32*)mem_static_malloc(4);
 *_FUNC_SYMBOLTYPE_LONG_L=0;
 }
-byte_element_struct *byte_element_4073=NULL;
-if (!byte_element_4073){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4073=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4073=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_4080=NULL;
+if (!byte_element_4080){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4080=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4080=(byte_element_struct*)mem_static_malloc(12);
 }
 int32 *_FUNC_SYMBOLTYPE_LONG_N=NULL;
 if(_FUNC_SYMBOLTYPE_LONG_N==NULL){
--- a/internal/source/data194.txt
+++ b/internal/source/data194.txt
@ -1,14 +1,14 @@
 qbs *_FUNC_TYP2CTYP_STRING_TYP2CTYP=NULL;
 if (!_FUNC_TYP2CTYP_STRING_TYP2CTYP)_FUNC_TYP2CTYP_STRING_TYP2CTYP=qbs_new(0,0);
-qbs*oldstr4074=NULL;
+qbs*oldstr4081=NULL;
 if(_FUNC_TYP2CTYP_STRING_TSTR->tmp||_FUNC_TYP2CTYP_STRING_TSTR->fixed||_FUNC_TYP2CTYP_STRING_TSTR->readonly){
-oldstr4074=_FUNC_TYP2CTYP_STRING_TSTR;
-if (oldstr4074->cmem_descriptor){
-_FUNC_TYP2CTYP_STRING_TSTR=qbs_new_cmem(oldstr4074->len,0);
+oldstr4081=_FUNC_TYP2CTYP_STRING_TSTR;
+if (oldstr4081->cmem_descriptor){
+_FUNC_TYP2CTYP_STRING_TSTR=qbs_new_cmem(oldstr4081->len,0);
 }else{
-_FUNC_TYP2CTYP_STRING_TSTR=qbs_new(oldstr4074->len,0);
+_FUNC_TYP2CTYP_STRING_TSTR=qbs_new(oldstr4081->len,0);
 }
-memcpy(_FUNC_TYP2CTYP_STRING_TSTR->chr,oldstr4074->chr,oldstr4074->len);
+memcpy(_FUNC_TYP2CTYP_STRING_TSTR->chr,oldstr4081->chr,oldstr4081->len);
 }
 qbs *_FUNC_TYP2CTYP_STRING_CTYP=NULL;
 if (!_FUNC_TYP2CTYP_STRING_CTYP)_FUNC_TYP2CTYP_STRING_CTYP=qbs_new(0,0);
@ -24,20 +24,20 @@ if(_FUNC_TYP2CTYP_LONG_UNSGN==NULL){
 _FUNC_TYP2CTYP_LONG_UNSGN=(int32*)mem_static_malloc(4);
 *_FUNC_TYP2CTYP_LONG_UNSGN=0;
 }
-byte_element_struct *byte_element_4075=NULL;
-if (!byte_element_4075){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4075=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4075=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_4082=NULL;
+if (!byte_element_4082){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4082=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4082=(byte_element_struct*)mem_static_malloc(12);
 }
 qbs *_FUNC_TYP2CTYP_STRING_N=NULL;
 if (!_FUNC_TYP2CTYP_STRING_N)_FUNC_TYP2CTYP_STRING_N=qbs_new(0,0);
-byte_element_struct *byte_element_4076=NULL;
-if (!byte_element_4076){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4076=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4076=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_4083=NULL;
+if (!byte_element_4083){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4083=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4083=(byte_element_struct*)mem_static_malloc(12);
 }
 qbs *_FUNC_TYP2CTYP_STRING_S=NULL;
 if (!_FUNC_TYP2CTYP_STRING_S)_FUNC_TYP2CTYP_STRING_S=qbs_new(0,0);
-byte_element_struct *byte_element_4077=NULL;
-if (!byte_element_4077){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4077=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4077=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_4084=NULL;
+if (!byte_element_4084){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4084=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4084=(byte_element_struct*)mem_static_malloc(12);
 }
-int32 pass4078;
+int32 pass4085;
--- a/internal/source/data195.txt
+++ b/internal/source/data195.txt
@ -1,14 +1,14 @@
 qbs *_FUNC_TYPE2SYMBOL_STRING_TYPE2SYMBOL=NULL;
 if (!_FUNC_TYPE2SYMBOL_STRING_TYPE2SYMBOL)_FUNC_TYPE2SYMBOL_STRING_TYPE2SYMBOL=qbs_new(0,0);
-qbs*oldstr4079=NULL;
+qbs*oldstr4086=NULL;
 if(_FUNC_TYPE2SYMBOL_STRING_TYP->tmp||_FUNC_TYPE2SYMBOL_STRING_TYP->fixed||_FUNC_TYPE2SYMBOL_STRING_TYP->readonly){
-oldstr4079=_FUNC_TYPE2SYMBOL_STRING_TYP;
-if (oldstr4079->cmem_descriptor){
-_FUNC_TYPE2SYMBOL_STRING_TYP=qbs_new_cmem(oldstr4079->len,0);
+oldstr4086=_FUNC_TYPE2SYMBOL_STRING_TYP;
+if (oldstr4086->cmem_descriptor){
+_FUNC_TYPE2SYMBOL_STRING_TYP=qbs_new_cmem(oldstr4086->len,0);
 }else{
-_FUNC_TYPE2SYMBOL_STRING_TYP=qbs_new(oldstr4079->len,0);
+_FUNC_TYPE2SYMBOL_STRING_TYP=qbs_new(oldstr4086->len,0);
 }
-memcpy(_FUNC_TYPE2SYMBOL_STRING_TYP->chr,oldstr4079->chr,oldstr4079->len);
+memcpy(_FUNC_TYPE2SYMBOL_STRING_TYP->chr,oldstr4086->chr,oldstr4086->len);
 }
 qbs *_FUNC_TYPE2SYMBOL_STRING_T=NULL;
 if (!_FUNC_TYPE2SYMBOL_STRING_T)_FUNC_TYPE2SYMBOL_STRING_T=qbs_new(0,0);
@ -17,13 +17,13 @@ if(_FUNC_TYPE2SYMBOL_LONG_I==NULL){
 _FUNC_TYPE2SYMBOL_LONG_I=(int32*)mem_static_malloc(4);
 *_FUNC_TYPE2SYMBOL_LONG_I=0;
 }
-int64 fornext_value4081;
-int64 fornext_finalvalue4081;
-int64 fornext_step4081;
-uint8 fornext_step_negative4081;
-byte_element_struct *byte_element_4082=NULL;
-if (!byte_element_4082){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4082=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4082=(byte_element_struct*)mem_static_malloc(12);
+int64 fornext_value4088;
+int64 fornext_finalvalue4088;
+int64 fornext_step4088;
+uint8 fornext_step_negative4088;
+byte_element_struct *byte_element_4089=NULL;
+if (!byte_element_4089){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4089=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4089=(byte_element_struct*)mem_static_malloc(12);
 }
 qbs *_FUNC_TYPE2SYMBOL_STRING_E=NULL;
 if (!_FUNC_TYPE2SYMBOL_STRING_E)_FUNC_TYPE2SYMBOL_STRING_E=qbs_new(0,0);
@ -31,34 +31,6 @@ qbs *_FUNC_TYPE2SYMBOL_STRING_T2=NULL;
 if (!_FUNC_TYPE2SYMBOL_STRING_T2)_FUNC_TYPE2SYMBOL_STRING_T2=qbs_new(0,0);
 qbs *_FUNC_TYPE2SYMBOL_STRING_S=NULL;
 if (!_FUNC_TYPE2SYMBOL_STRING_S)_FUNC_TYPE2SYMBOL_STRING_S=qbs_new(0,0);
-byte_element_struct *byte_element_4083=NULL;
-if (!byte_element_4083){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4083=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4083=(byte_element_struct*)mem_static_malloc(12);
-}
-byte_element_struct *byte_element_4084=NULL;
-if (!byte_element_4084){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4084=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4084=(byte_element_struct*)mem_static_malloc(12);
-}
-byte_element_struct *byte_element_4085=NULL;
-if (!byte_element_4085){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4085=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4085=(byte_element_struct*)mem_static_malloc(12);
-}
-byte_element_struct *byte_element_4086=NULL;
-if (!byte_element_4086){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4086=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4086=(byte_element_struct*)mem_static_malloc(12);
-}
-byte_element_struct *byte_element_4087=NULL;
-if (!byte_element_4087){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4087=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4087=(byte_element_struct*)mem_static_malloc(12);
-}
-byte_element_struct *byte_element_4088=NULL;
-if (!byte_element_4088){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4088=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4088=(byte_element_struct*)mem_static_malloc(12);
-}
-byte_element_struct *byte_element_4089=NULL;
-if (!byte_element_4089){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4089=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4089=(byte_element_struct*)mem_static_malloc(12);
-}
 byte_element_struct *byte_element_4090=NULL;
 if (!byte_element_4090){
 if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4090=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4090=(byte_element_struct*)mem_static_malloc(12);
@ -79,12 +51,40 @@ byte_element_struct *byte_element_4094=NULL;
 if (!byte_element_4094){
 if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4094=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4094=(byte_element_struct*)mem_static_malloc(12);
 }
+byte_element_struct *byte_element_4095=NULL;
+if (!byte_element_4095){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4095=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4095=(byte_element_struct*)mem_static_malloc(12);
+}
+byte_element_struct *byte_element_4096=NULL;
+if (!byte_element_4096){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4096=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4096=(byte_element_struct*)mem_static_malloc(12);
+}
+byte_element_struct *byte_element_4097=NULL;
+if (!byte_element_4097){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4097=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4097=(byte_element_struct*)mem_static_malloc(12);
+}
+byte_element_struct *byte_element_4098=NULL;
+if (!byte_element_4098){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4098=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4098=(byte_element_struct*)mem_static_malloc(12);
+}
+byte_element_struct *byte_element_4099=NULL;
+if (!byte_element_4099){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4099=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4099=(byte_element_struct*)mem_static_malloc(12);
+}
+byte_element_struct *byte_element_4100=NULL;
+if (!byte_element_4100){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4100=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4100=(byte_element_struct*)mem_static_malloc(12);
+}
+byte_element_struct *byte_element_4101=NULL;
+if (!byte_element_4101){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4101=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4101=(byte_element_struct*)mem_static_malloc(12);
+}
 int32 *_FUNC_TYPE2SYMBOL_LONG_V=NULL;
 if(_FUNC_TYPE2SYMBOL_LONG_V==NULL){
 _FUNC_TYPE2SYMBOL_LONG_V=(int32*)mem_static_malloc(4);
 *_FUNC_TYPE2SYMBOL_LONG_V=0;
 }
-byte_element_struct *byte_element_4095=NULL;
-if (!byte_element_4095){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4095=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4095=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_4102=NULL;
+if (!byte_element_4102){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4102=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4102=(byte_element_struct*)mem_static_malloc(12);
 }
--- a/internal/source/data197.txt
+++ b/internal/source/data197.txt
@ -3,15 +3,15 @@ if(_FUNC_TYPNAME2TYP_LONG_TYPNAME2TYP==NULL){
 _FUNC_TYPNAME2TYP_LONG_TYPNAME2TYP=(int32*)mem_static_malloc(4);
 *_FUNC_TYPNAME2TYP_LONG_TYPNAME2TYP=0;
 }
-qbs*oldstr4096=NULL;
+qbs*oldstr4103=NULL;
 if(_FUNC_TYPNAME2TYP_STRING_T2->tmp||_FUNC_TYPNAME2TYP_STRING_T2->fixed||_FUNC_TYPNAME2TYP_STRING_T2->readonly){
-oldstr4096=_FUNC_TYPNAME2TYP_STRING_T2;
-if (oldstr4096->cmem_descriptor){
-_FUNC_TYPNAME2TYP_STRING_T2=qbs_new_cmem(oldstr4096->len,0);
+oldstr4103=_FUNC_TYPNAME2TYP_STRING_T2;
+if (oldstr4103->cmem_descriptor){
+_FUNC_TYPNAME2TYP_STRING_T2=qbs_new_cmem(oldstr4103->len,0);
 }else{
-_FUNC_TYPNAME2TYP_STRING_T2=qbs_new(oldstr4096->len,0);
+_FUNC_TYPNAME2TYP_STRING_T2=qbs_new(oldstr4103->len,0);
 }
-memcpy(_FUNC_TYPNAME2TYP_STRING_T2->chr,oldstr4096->chr,oldstr4096->len);
+memcpy(_FUNC_TYPNAME2TYP_STRING_T2->chr,oldstr4103->chr,oldstr4103->len);
 }
 qbs *_FUNC_TYPNAME2TYP_STRING_T=NULL;
 if (!_FUNC_TYPNAME2TYP_STRING_T)_FUNC_TYPNAME2TYP_STRING_T=qbs_new(0,0);
@ -19,9 +19,9 @@ qbs *_FUNC_TYPNAME2TYP_STRING_TS=NULL;
 if (!_FUNC_TYPNAME2TYP_STRING_TS)_FUNC_TYPNAME2TYP_STRING_TS=qbs_new(0,0);
 qbs *_FUNC_TYPNAME2TYP_STRING_N=NULL;
 if (!_FUNC_TYPNAME2TYP_STRING_N)_FUNC_TYPNAME2TYP_STRING_N=qbs_new(0,0);
-byte_element_struct *byte_element_4097=NULL;
-if (!byte_element_4097){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4097=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4097=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_4104=NULL;
+if (!byte_element_4104){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4104=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4104=(byte_element_struct*)mem_static_malloc(12);
 }
 int32 *_FUNC_TYPNAME2TYP_LONG_B=NULL;
 if(_FUNC_TYPNAME2TYP_LONG_B==NULL){
@ -33,13 +33,13 @@ if(_FUNC_TYPNAME2TYP_LONG_UNSGN==NULL){
 _FUNC_TYPNAME2TYP_LONG_UNSGN=(int32*)mem_static_malloc(4);
 *_FUNC_TYPNAME2TYP_LONG_UNSGN=0;
 }
-byte_element_struct *byte_element_4098=NULL;
-if (!byte_element_4098){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4098=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4098=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_4105=NULL;
+if (!byte_element_4105){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4105=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4105=(byte_element_struct*)mem_static_malloc(12);
 }
-byte_element_struct *byte_element_4099=NULL;
-if (!byte_element_4099){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4099=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4099=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_4106=NULL;
+if (!byte_element_4106){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4106=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4106=(byte_element_struct*)mem_static_malloc(12);
 }
 int32 *_FUNC_TYPNAME2TYP_LONG_T=NULL;
 if(_FUNC_TYPNAME2TYP_LONG_T==NULL){
@ -51,17 +51,17 @@ if(_FUNC_TYPNAME2TYP_LONG_I==NULL){
 _FUNC_TYPNAME2TYP_LONG_I=(int32*)mem_static_malloc(4);
 *_FUNC_TYPNAME2TYP_LONG_I=0;
 }
-int64 fornext_value4101;
-int64 fornext_finalvalue4101;
-int64 fornext_step4101;
-uint8 fornext_step_negative4101;
-byte_element_struct *byte_element_4102=NULL;
-if (!byte_element_4102){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4102=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4102=(byte_element_struct*)mem_static_malloc(12);
+int64 fornext_value4108;
+int64 fornext_finalvalue4108;
+int64 fornext_step4108;
+uint8 fornext_step_negative4108;
+byte_element_struct *byte_element_4109=NULL;
+if (!byte_element_4109){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4109=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4109=(byte_element_struct*)mem_static_malloc(12);
 }
-byte_element_struct *byte_element_4103=NULL;
-if (!byte_element_4103){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4103=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4103=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_4110=NULL;
+if (!byte_element_4110){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4110=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4110=(byte_element_struct*)mem_static_malloc(12);
 }
 int32 *_FUNC_TYPNAME2TYP_LONG_HASHFOUND=NULL;
 if(_FUNC_TYPNAME2TYP_LONG_HASHFOUND==NULL){
@ -110,28 +110,28 @@ if(_FUNC_TYPNAME2TYP_UINTEGER64_V==NULL){
 _FUNC_TYPNAME2TYP_UINTEGER64_V=(uint64*)mem_static_malloc(8);
 *_FUNC_TYPNAME2TYP_UINTEGER64_V=0;
 }
-byte_element_struct *byte_element_4105=NULL;
-if (!byte_element_4105){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4105=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4105=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_4112=NULL;
+if (!byte_element_4112){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4112=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4112=(byte_element_struct*)mem_static_malloc(12);
 }
-byte_element_struct *byte_element_4106=NULL;
-if (!byte_element_4106){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4106=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4106=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_4113=NULL;
+if (!byte_element_4113){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4113=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4113=(byte_element_struct*)mem_static_malloc(12);
 }
 int32 *_FUNC_TYPNAME2TYP_LONG_U=NULL;
 if(_FUNC_TYPNAME2TYP_LONG_U==NULL){
 _FUNC_TYPNAME2TYP_LONG_U=(int32*)mem_static_malloc(4);
 *_FUNC_TYPNAME2TYP_LONG_U=0;
 }
-byte_element_struct *byte_element_4107=NULL;
-if (!byte_element_4107){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4107=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4107=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_4114=NULL;
+if (!byte_element_4114){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4114=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4114=(byte_element_struct*)mem_static_malloc(12);
 }
-byte_element_struct *byte_element_4108=NULL;
-if (!byte_element_4108){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4108=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4108=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_4115=NULL;
+if (!byte_element_4115){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4115=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4115=(byte_element_struct*)mem_static_malloc(12);
 }
-int64 fornext_value4110;
-int64 fornext_finalvalue4110;
-int64 fornext_step4110;
-uint8 fornext_step_negative4110;
+int64 fornext_value4117;
+int64 fornext_finalvalue4117;
+int64 fornext_step4117;
+uint8 fornext_step_negative4117;
--- a/internal/source/data198.txt
+++ b/internal/source/data198.txt
@ -1,14 +1,14 @@
 qbs *_FUNC_REMOVESYMBOL_STRING_REMOVESYMBOL=NULL;
 if (!_FUNC_REMOVESYMBOL_STRING_REMOVESYMBOL)_FUNC_REMOVESYMBOL_STRING_REMOVESYMBOL=qbs_new(0,0);
-qbs*oldstr4111=NULL;
+qbs*oldstr4118=NULL;
 if(_FUNC_REMOVESYMBOL_STRING_VARNAME->tmp||_FUNC_REMOVESYMBOL_STRING_VARNAME->fixed||_FUNC_REMOVESYMBOL_STRING_VARNAME->readonly){
-oldstr4111=_FUNC_REMOVESYMBOL_STRING_VARNAME;
-if (oldstr4111->cmem_descriptor){
-_FUNC_REMOVESYMBOL_STRING_VARNAME=qbs_new_cmem(oldstr4111->len,0);
+oldstr4118=_FUNC_REMOVESYMBOL_STRING_VARNAME;
+if (oldstr4118->cmem_descriptor){
+_FUNC_REMOVESYMBOL_STRING_VARNAME=qbs_new_cmem(oldstr4118->len,0);
 }else{
-_FUNC_REMOVESYMBOL_STRING_VARNAME=qbs_new(oldstr4111->len,0);
+_FUNC_REMOVESYMBOL_STRING_VARNAME=qbs_new(oldstr4118->len,0);
 }
-memcpy(_FUNC_REMOVESYMBOL_STRING_VARNAME->chr,oldstr4111->chr,oldstr4111->len);
+memcpy(_FUNC_REMOVESYMBOL_STRING_VARNAME->chr,oldstr4118->chr,oldstr4118->len);
 }
 int32 *_FUNC_REMOVESYMBOL_LONG_I=NULL;
 if(_FUNC_REMOVESYMBOL_LONG_I==NULL){
@ -17,7 +17,7 @@ _FUNC_REMOVESYMBOL_LONG_I=(int32*)mem_static_malloc(4);
 }
 qbs *_FUNC_REMOVESYMBOL_STRING_SYMBOL=NULL;
 if (!_FUNC_REMOVESYMBOL_STRING_SYMBOL)_FUNC_REMOVESYMBOL_STRING_SYMBOL=qbs_new(0,0);
-byte_element_struct *byte_element_4112=NULL;
-if (!byte_element_4112){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4112=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4112=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_4119=NULL;
+if (!byte_element_4119){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4119=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4119=(byte_element_struct*)mem_static_malloc(12);
 }
--- a/internal/source/data199.txt
+++ b/internal/source/data199.txt
@ -1,14 +1,14 @@
 qbs *_FUNC_TRYREMOVESYMBOL_STRING_TRYREMOVESYMBOL=NULL;
 if (!_FUNC_TRYREMOVESYMBOL_STRING_TRYREMOVESYMBOL)_FUNC_TRYREMOVESYMBOL_STRING_TRYREMOVESYMBOL=qbs_new(0,0);
-qbs*oldstr4113=NULL;
+qbs*oldstr4120=NULL;
 if(_FUNC_TRYREMOVESYMBOL_STRING_VARNAME->tmp||_FUNC_TRYREMOVESYMBOL_STRING_VARNAME->fixed||_FUNC_TRYREMOVESYMBOL_STRING_VARNAME->readonly){
-oldstr4113=_FUNC_TRYREMOVESYMBOL_STRING_VARNAME;
-if (oldstr4113->cmem_descriptor){
-_FUNC_TRYREMOVESYMBOL_STRING_VARNAME=qbs_new_cmem(oldstr4113->len,0);
+oldstr4120=_FUNC_TRYREMOVESYMBOL_STRING_VARNAME;
+if (oldstr4120->cmem_descriptor){
+_FUNC_TRYREMOVESYMBOL_STRING_VARNAME=qbs_new_cmem(oldstr4120->len,0);
 }else{
-_FUNC_TRYREMOVESYMBOL_STRING_VARNAME=qbs_new(oldstr4113->len,0);
+_FUNC_TRYREMOVESYMBOL_STRING_VARNAME=qbs_new(oldstr4120->len,0);
 }
-memcpy(_FUNC_TRYREMOVESYMBOL_STRING_VARNAME->chr,oldstr4113->chr,oldstr4113->len);
+memcpy(_FUNC_TRYREMOVESYMBOL_STRING_VARNAME->chr,oldstr4120->chr,oldstr4120->len);
 }
 int32 *_FUNC_TRYREMOVESYMBOL_LONG_I=NULL;
 if(_FUNC_TRYREMOVESYMBOL_LONG_I==NULL){
@ -17,7 +17,7 @@ _FUNC_TRYREMOVESYMBOL_LONG_I=(int32*)mem_static_malloc(4);
 }
 qbs *_FUNC_TRYREMOVESYMBOL_STRING_SYMBOL=NULL;
 if (!_FUNC_TRYREMOVESYMBOL_STRING_SYMBOL)_FUNC_TRYREMOVESYMBOL_STRING_SYMBOL=qbs_new(0,0);
-byte_element_struct *byte_element_4114=NULL;
-if (!byte_element_4114){
-if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4114=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4114=(byte_element_struct*)mem_static_malloc(12);
+byte_element_struct *byte_element_4121=NULL;
+if (!byte_element_4121){
+if ((mem_static_pointer+=12)<mem_static_limit) byte_element_4121=(byte_element_struct*)(mem_static_pointer-12); else byte_element_4121=(byte_element_struct*)mem_static_malloc(12);
 }
--- a/internal/source/data2.txt
+++ b/internal/source/data2.txt
@ -1,12 +1,12 @@
 qbs *_FUNC_INVALIDSETTINGERROR_STRING_INVALIDSETTINGERROR=NULL;
 if (!_FUNC_INVALIDSETTINGERROR_STRING_INVALIDSETTINGERROR)_FUNC_INVALIDSETTINGERROR_STRING_INVALIDSETTINGERROR=qbs_new(0,0);
-qbs*oldstr2229=NULL;
+qbs*oldstr2235=NULL;
 if(_FUNC_INVALIDSETTINGERROR_STRING_TOKEN->tmp||_FUNC_INVALIDSETTINGERROR_STRING_TOKEN->fixed||_FUNC_INVALIDSETTINGERROR_STRING_TOKEN->readonly){
-oldstr2229=_FUNC_INVALIDSETTINGERROR_STRING_TOKEN;
-if (oldstr2229->cmem_descriptor){
-_FUNC_INVALIDSETTINGERROR_STRING_TOKEN=qbs_new_cmem(oldstr2229->len,0);
+oldstr2235=_FUNC_INVALIDSETTINGERROR_STRING_TOKEN;
+if (oldstr2235->cmem_descriptor){
+_FUNC_INVALIDSETTINGERROR_STRING_TOKEN=qbs_new_cmem(oldstr2235->len,0);
 }else{
-_FUNC_INVALIDSETTINGERROR_STRING_TOKEN=qbs_new(oldstr2229->len,0);
+_FUNC_INVALIDSETTINGERROR_STRING_TOKEN=qbs_new(oldstr2235->len,0);
 }
-memcpy(_FUNC_INVALIDSETTINGERROR_STRING_TOKEN->chr,oldstr2229->chr,oldstr2229->len);
+memcpy(_FUNC_INVALIDSETTINGERROR_STRING_TOKEN->chr,oldstr2235->chr,oldstr2235->len);
 }
--- a/internal/source/data20.txt
+++ b/internal/source/data20.txt
@ -29,8 +29,8 @@ if(_FUNC_VARIABLESIZE_LONG_I2==NULL){
 _FUNC_VARIABLESIZE_LONG_I2=(int32*)mem_static_malloc(4);
 *_FUNC_VARIABLESIZE_LONG_I2=0;
 }
-int64 fornext_value2746;
-int64 fornext_finalvalue2746;
-int64 fornext_step2746;
-uint8 fornext_step_negative2746;
-int32 pass2747;
+int64 fornext_value2752;
+int64 fornext_finalvalue2752;
+int64 fornext_step2752;
+uint8 fornext_step_negative2752;
+int32 pass2753;
--- a/internal/source/data201.txt
+++ b/internal/source/data201.txt
@ -1,12 +1,12 @@
-qbs*oldstr4115=NULL;
+qbs*oldstr4122=NULL;
 if(_SUB_INITIALISE_UDT_VARSTRINGS_STRING_N->tmp||_SUB_INITIALISE_UDT_VARSTRINGS_STRING_N->fixed||_SUB_INITIALISE_UDT_VARSTRINGS_STRING_N->readonly){
-oldstr4115=_SUB_INITIALISE_UDT_VARSTRINGS_STRING_N;
-if (oldstr4115->cmem_descriptor){
-_SUB_INITIALISE_UDT_VARSTRINGS_STRING_N=qbs_new_cmem(oldstr4115->len,0);
+oldstr4122=_SUB_INITIALISE_UDT_VARSTRINGS_STRING_N;
+if (oldstr4122->cmem_descriptor){
+_SUB_INITIALISE_UDT_VARSTRINGS_STRING_N=qbs_new_cmem(oldstr4122->len,0);
 }else{
-_SUB_INITIALISE_UDT_VARSTRINGS_STRING_N=qbs_new(oldstr4115->len,0);
+_SUB_INITIALISE_UDT_VARSTRINGS_STRING_N=qbs_new(oldstr4122->len,0);
 }
-memcpy(_SUB_INITIALISE_UDT_VARSTRINGS_STRING_N->chr,oldstr4115->chr,oldstr4115->len);
+memcpy(_SUB_INITIALISE_UDT_VARSTRINGS_STRING_N->chr,oldstr4122->chr,oldstr4122->len);
 }
 int32 *_SUB_INITIALISE_UDT_VARSTRINGS_LONG_ELEMENT=NULL;
 if(_SUB_INITIALISE_UDT_VARSTRINGS_LONG_ELEMENT==NULL){
@ -18,5 +18,5 @@ if(_SUB_INITIALISE_UDT_VARSTRINGS_LONG_OFFSET==NULL){
 _SUB_INITIALISE_UDT_VARSTRINGS_LONG_OFFSET=(int32*)mem_static_malloc(4);
 *_SUB_INITIALISE_UDT_VARSTRINGS_LONG_OFFSET=0;
 }
-int16 pass4117;
-int32 pass4118;
+int16 pass4124;
+int32 pass4125;
--- a/internal/source/data202.txt
+++ b/internal/source/data202.txt
@ -1,12 +1,12 @@
-qbs*oldstr4119=NULL;
+qbs*oldstr4126=NULL;
 if(_SUB_FREE_UDT_VARSTRINGS_STRING_N->tmp||_SUB_FREE_UDT_VARSTRINGS_STRING_N->fixed||_SUB_FREE_UDT_VARSTRINGS_STRING_N->readonly){
-oldstr4119=_SUB_FREE_UDT_VARSTRINGS_STRING_N;
-if (oldstr4119->cmem_descriptor){
-_SUB_FREE_UDT_VARSTRINGS_STRING_N=qbs_new_cmem(oldstr4119->len,0);
+oldstr4126=_SUB_FREE_UDT_VARSTRINGS_STRING_N;
+if (oldstr4126->cmem_descriptor){
+_SUB_FREE_UDT_VARSTRINGS_STRING_N=qbs_new_cmem(oldstr4126->len,0);
 }else{
-_SUB_FREE_UDT_VARSTRINGS_STRING_N=qbs_new(oldstr4119->len,0);
+_SUB_FREE_UDT_VARSTRINGS_STRING_N=qbs_new(oldstr4126->len,0);
 }
-memcpy(_SUB_FREE_UDT_VARSTRINGS_STRING_N->chr,oldstr4119->chr,oldstr4119->len);
+memcpy(_SUB_FREE_UDT_VARSTRINGS_STRING_N->chr,oldstr4126->chr,oldstr4126->len);
 }
 int32 *_SUB_FREE_UDT_VARSTRINGS_LONG_ELEMENT=NULL;
 if(_SUB_FREE_UDT_VARSTRINGS_LONG_ELEMENT==NULL){
@ -18,5 +18,5 @@ if(_SUB_FREE_UDT_VARSTRINGS_LONG_OFFSET==NULL){
 _SUB_FREE_UDT_VARSTRINGS_LONG_OFFSET=(int32*)mem_static_malloc(4);
 *_SUB_FREE_UDT_VARSTRINGS_LONG_OFFSET=0;
 }
-int16 pass4121;
-int32 pass4122;
+int16 pass4128;
+int32 pass4129;
--- a/internal/source/data203.txt
+++ b/internal/source/data203.txt
@ -1,12 +1,12 @@
-qbs*oldstr4123=NULL;
+qbs*oldstr4130=NULL;
 if(_SUB_CLEAR_UDT_WITH_VARSTRINGS_STRING_N->tmp||_SUB_CLEAR_UDT_WITH_VARSTRINGS_STRING_N->fixed||_SUB_CLEAR_UDT_WITH_VARSTRINGS_STRING_N->readonly){
-oldstr4123=_SUB_CLEAR_UDT_WITH_VARSTRINGS_STRING_N;
-if (oldstr4123->cmem_descriptor){
-_SUB_CLEAR_UDT_WITH_VARSTRINGS_STRING_N=qbs_new_cmem(oldstr4123->len,0);
+oldstr4130=_SUB_CLEAR_UDT_WITH_VARSTRINGS_STRING_N;
+if (oldstr4130->cmem_descriptor){
+_SUB_CLEAR_UDT_WITH_VARSTRINGS_STRING_N=qbs_new_cmem(oldstr4130->len,0);
 }else{
-_SUB_CLEAR_UDT_WITH_VARSTRINGS_STRING_N=qbs_new(oldstr4123->len,0);
+_SUB_CLEAR_UDT_WITH_VARSTRINGS_STRING_N=qbs_new(oldstr4130->len,0);
 }
-memcpy(_SUB_CLEAR_UDT_WITH_VARSTRINGS_STRING_N->chr,oldstr4123->chr,oldstr4123->len);
+memcpy(_SUB_CLEAR_UDT_WITH_VARSTRINGS_STRING_N->chr,oldstr4130->chr,oldstr4130->len);
 }
 int32 *_SUB_CLEAR_UDT_WITH_VARSTRINGS_LONG_ELEMENT=NULL;
 if(_SUB_CLEAR_UDT_WITH_VARSTRINGS_LONG_ELEMENT==NULL){
@ -18,8 +18,8 @@ if(_SUB_CLEAR_UDT_WITH_VARSTRINGS_LONG_OFFSET==NULL){
 _SUB_CLEAR_UDT_WITH_VARSTRINGS_LONG_OFFSET=(int32*)mem_static_malloc(4);
 *_SUB_CLEAR_UDT_WITH_VARSTRINGS_LONG_OFFSET=0;
 }
-int16 pass4125;
-int16 pass4126;
-int32 pass4127;
-int32 pass4128;
-int16 pass4129;
+int16 pass4132;
+int16 pass4133;
+int32 pass4134;
+int32 pass4135;
+int16 pass4136;
--- a/internal/source/data204.txt
+++ b/internal/source/data204.txt
@ -1,32 +1,32 @@
-qbs*oldstr4130=NULL;
+qbs*oldstr4137=NULL;
 if(_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_N->tmp||_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_N->fixed||_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_N->readonly){
-oldstr4130=_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_N;
-if (oldstr4130->cmem_descriptor){
-_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_N=qbs_new_cmem(oldstr4130->len,0);
+oldstr4137=_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_N;
+if (oldstr4137->cmem_descriptor){
+_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_N=qbs_new_cmem(oldstr4137->len,0);
 }else{
-_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_N=qbs_new(oldstr4130->len,0);
+_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_N=qbs_new(oldstr4137->len,0);
 }
-memcpy(_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_N->chr,oldstr4130->chr,oldstr4130->len);
+memcpy(_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_N->chr,oldstr4137->chr,oldstr4137->len);
 }
-qbs*oldstr4131=NULL;
+qbs*oldstr4138=NULL;
 if(_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT->tmp||_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT->fixed||_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT->readonly){
-oldstr4131=_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT;
-if (oldstr4131->cmem_descriptor){
-_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT=qbs_new_cmem(oldstr4131->len,0);
+oldstr4138=_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT;
+if (oldstr4138->cmem_descriptor){
+_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT=qbs_new_cmem(oldstr4138->len,0);
 }else{
-_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT=qbs_new(oldstr4131->len,0);
+_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT=qbs_new(oldstr4138->len,0);
 }
-memcpy(_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT->chr,oldstr4131->chr,oldstr4131->len);
+memcpy(_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT->chr,oldstr4138->chr,oldstr4138->len);
 }
-qbs*oldstr4132=NULL;
+qbs*oldstr4139=NULL;
 if(_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_ACC->tmp||_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_ACC->fixed||_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_ACC->readonly){
-oldstr4132=_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_ACC;
-if (oldstr4132->cmem_descriptor){
-_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_ACC=qbs_new_cmem(oldstr4132->len,0);
+oldstr4139=_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_ACC;
+if (oldstr4139->cmem_descriptor){
+_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_ACC=qbs_new_cmem(oldstr4139->len,0);
 }else{
-_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_ACC=qbs_new(oldstr4132->len,0);
+_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_ACC=qbs_new(oldstr4139->len,0);
 }
-memcpy(_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_ACC->chr,oldstr4132->chr,oldstr4132->len);
+memcpy(_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_STRING_ACC->chr,oldstr4139->chr,oldstr4139->len);
 }
 int32 *_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_LONG_OFFSET=NULL;
 if(_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_LONG_OFFSET==NULL){
@ -38,4 +38,4 @@ if(_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_LONG_ELEMENT==NULL){
 _SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_LONG_ELEMENT=(int32*)mem_static_malloc(4);
 *_SUB_INITIALISE_ARRAY_UDT_VARSTRINGS_LONG_ELEMENT=0;
 }
-int32 pass4134;
+int32 pass4141;
--- a/internal/source/data205.txt
+++ b/internal/source/data205.txt
@ -1,32 +1,32 @@
-qbs*oldstr4135=NULL;
+qbs*oldstr4142=NULL;
 if(_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_N->tmp||_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_N->fixed||_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_N->readonly){
-oldstr4135=_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_N;
-if (oldstr4135->cmem_descriptor){
-_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_N=qbs_new_cmem(oldstr4135->len,0);
+oldstr4142=_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_N;
+if (oldstr4142->cmem_descriptor){
+_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_N=qbs_new_cmem(oldstr4142->len,0);
 }else{
-_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_N=qbs_new(oldstr4135->len,0);
+_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_N=qbs_new(oldstr4142->len,0);
 }
-memcpy(_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_N->chr,oldstr4135->chr,oldstr4135->len);
+memcpy(_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_N->chr,oldstr4142->chr,oldstr4142->len);
 }
-qbs*oldstr4136=NULL;
+qbs*oldstr4143=NULL;
 if(_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT->tmp||_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT->fixed||_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT->readonly){
-oldstr4136=_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT;
-if (oldstr4136->cmem_descriptor){
-_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT=qbs_new_cmem(oldstr4136->len,0);
+oldstr4143=_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT;
+if (oldstr4143->cmem_descriptor){
+_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT=qbs_new_cmem(oldstr4143->len,0);
 }else{
-_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT=qbs_new(oldstr4136->len,0);
+_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT=qbs_new(oldstr4143->len,0);
 }
-memcpy(_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT->chr,oldstr4136->chr,oldstr4136->len);
+memcpy(_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_BYTESPERELEMENT->chr,oldstr4143->chr,oldstr4143->len);
 }
-qbs*oldstr4137=NULL;
+qbs*oldstr4144=NULL;
 if(_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_ACC->tmp||_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_ACC->fixed||_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_ACC->readonly){
-oldstr4137=_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_ACC;
-if (oldstr4137->cmem_descriptor){
-_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_ACC=qbs_new_cmem(oldstr4137->len,0);
+oldstr4144=_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_ACC;
+if (oldstr4144->cmem_descriptor){
+_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_ACC=qbs_new_cmem(oldstr4144->len,0);
 }else{
-_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_ACC=qbs_new(oldstr4137->len,0);
+_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_ACC=qbs_new(oldstr4144->len,0);
 }
-memcpy(_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_ACC->chr,oldstr4137->chr,oldstr4137->len);
+memcpy(_SUB_FREE_ARRAY_UDT_VARSTRINGS_STRING_ACC->chr,oldstr4144->chr,oldstr4144->len);
 }
 int32 *_SUB_FREE_ARRAY_UDT_VARSTRINGS_LONG_OFFSET=NULL;
 if(_SUB_FREE_ARRAY_UDT_VARSTRINGS_LONG_OFFSET==NULL){
@ -38,4 +38,4 @@ if(_SUB_FREE_ARRAY_UDT_VARSTRINGS_LONG_ELEMENT==NULL){
 _SUB_FREE_ARRAY_UDT_VARSTRINGS_LONG_ELEMENT=(int32*)mem_static_malloc(4);
 *_SUB_FREE_ARRAY_UDT_VARSTRINGS_LONG_ELEMENT=0;
 }
-int32 pass4139;
+int32 pass4146;
--- a/internal/source/data206.txt
+++ b/internal/source/data206.txt
@ -1,24 +1,24 @@
-qbs*oldstr4140=NULL;
+qbs*oldstr4147=NULL;
 if(_SUB_COPY_FULL_UDT_STRING_DST->tmp||_SUB_COPY_FULL_UDT_STRING_DST->fixed||_SUB_COPY_FULL_UDT_STRING_DST->readonly){
-oldstr4140=_SUB_COPY_FULL_UDT_STRING_DST;
-if (oldstr4140->cmem_descriptor){
-_SUB_COPY_FULL_UDT_STRING_DST=qbs_new_cmem(oldstr4140->len,0);
+oldstr4147=_SUB_COPY_FULL_UDT_STRING_DST;
+if (oldstr4147->cmem_descriptor){
+_SUB_COPY_FULL_UDT_STRING_DST=qbs_new_cmem(oldstr4147->len,0);
 }else{
-_SUB_COPY_FULL_UDT_STRING_DST=qbs_new(oldstr4140->len,0);
+_SUB_COPY_FULL_UDT_STRING_DST=qbs_new(oldstr4147->len,0);
 }
-memcpy(_SUB_COPY_FULL_UDT_STRING_DST->chr,oldstr4140->chr,oldstr4140->len);
+memcpy(_SUB_COPY_FULL_UDT_STRING_DST->chr,oldstr4147->chr,oldstr4147->len);
 }
-qbs*oldstr4141=NULL;
+qbs*oldstr4148=NULL;
 if(_SUB_COPY_FULL_UDT_STRING_SRC->tmp||_SUB_COPY_FULL_UDT_STRING_SRC->fixed||_SUB_COPY_FULL_UDT_STRING_SRC->readonly){
-oldstr4141=_SUB_COPY_FULL_UDT_STRING_SRC;
-if (oldstr4141->cmem_descriptor){
-_SUB_COPY_FULL_UDT_STRING_SRC=qbs_new_cmem(oldstr4141->len,0);
+oldstr4148=_SUB_COPY_FULL_UDT_STRING_SRC;
+if (oldstr4148->cmem_descriptor){
+_SUB_COPY_FULL_UDT_STRING_SRC=qbs_new_cmem(oldstr4148->len,0);
 }else{
-_SUB_COPY_FULL_UDT_STRING_SRC=qbs_new(oldstr4141->len,0);
+_SUB_COPY_FULL_UDT_STRING_SRC=qbs_new(oldstr4148->len,0);
 }
-memcpy(_SUB_COPY_FULL_UDT_STRING_SRC->chr,oldstr4141->chr,oldstr4141->len);
+memcpy(_SUB_COPY_FULL_UDT_STRING_SRC->chr,oldstr4148->chr,oldstr4148->len);
 }
-int16 pass4142;
+int16 pass4149;
 int32 *_SUB_COPY_FULL_UDT_LONG_OFFSET=NULL;
 if(_SUB_COPY_FULL_UDT_LONG_OFFSET==NULL){
 _SUB_COPY_FULL_UDT_LONG_OFFSET=(int32*)mem_static_malloc(4);
@ -29,6 +29,6 @@ if(_SUB_COPY_FULL_UDT_LONG_ELEMENT==NULL){
 _SUB_COPY_FULL_UDT_LONG_ELEMENT=(int32*)mem_static_malloc(4);
 *_SUB_COPY_FULL_UDT_LONG_ELEMENT=0;
 }
-int16 pass4144;
-int32 pass4145;
-int16 pass4146;
+int16 pass4151;
+int32 pass4152;
+int16 pass4153;
--- a/Show more
+++ b/Show more
Author	SHA1	Message	Date
Matt Kilgore	4dbafbaa8e	Merge `74937f4b8c` into `8514e46034`	2024-04-11 09:28:02 +03:00
github-actions[bot]	8514e46034	Automatic update of ./internal/source	2024-04-10 17:52:08 +00:00
Samuel Gomes	9ec149b2a1	Merge pull request #478 from a740g/logical-operators Logical Boolean operators	2024-04-10 23:03:36 +05:30
Samuel Gomes	06101c0a9a	Modify the behavior of the _ANDALSO and _ORELSE operators to return -1 when the result is true	2024-04-10 20:06:57 +05:30
Samuel Gomes	4e4b8149b4	Add test for boolean logical ops	2024-04-06 22:19:13 +05:30
Samuel Gomes	ed75e871c8	Merge branch 'QB64-Phoenix-Edition:main' into logical-operators	2024-04-06 17:57:50 +05:30
Samuel Gomes	19df445cf3	Merge branch 'QB64-Phoenix-Edition:main' into logical-operators	2024-04-06 17:38:55 +05:30
Samuel Gomes	8bd3ff71c9	Add operator keyword proper case support	2024-04-04 10:34:22 +05:30
Samuel Gomes	321c66dffc	Add initial support for logical boolean operators	2024-04-02 22:13:54 +05:30
Matthew Kilgore	74937f4b8c	Fix GLUT redraw timing Currently the GLUT thread draws the screen too slowly, Ex. The default is supposed to be 60 FPS, but it will always draw a bit slower than 60 FPS. This is because the current logic simply inserts delays for the entire length of a frame, not taking into account how long it took us to render the last frame. The new code uses GetTicks() to measure how much time has passed since the last render, which then lets us calculate the exact amount of delay until the next frame. We additionally then measure how long the delay lasted vs. what we asked for (since any delay we do only has a minimum guarentee, it will ocassionally last a bit longer) and adjust based on that as well. The result is a perfect 60 FPS as long as rendering is quick enough. If the rendering falls behind (Ex. a slow _GL SUB is in the program) then we'll start skipping frames to get back on track. Fixes: #408	2024-03-25 11:43:29 -04:00
Matthew Kilgore	07c0705ab8	Make Linux GetTicks() start from zero Since the GetTicks() is visible in the logging, it's useful to have it start from zero rather than an arbitrary number.	2024-03-25 11:43:29 -04:00