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

.github/workflows/build-process.yml

@@ -46,7 +46,7 @@ jobs:
 
     - name: Install dependencies
       if: ${{ matrix.prefix == 'lnx' }}
-      run: sudo apt update && sudo apt install build-essential x11-utils mesa-common-dev libglu1-mesa-dev libasound2-dev zlib1g-dev pulseaudio dbus-x11 libportaudio2 libcurl4-openssl-dev
+      run: sudo apt update && sudo apt install build-essential x11-utils mesa-common-dev libglu1-mesa-dev libasound2-dev libpng-dev pulseaudio dbus-x11 libportaudio2 libcurl4-openssl-dev
 
       # Pulseaudio puts a dummy ALSA device in place, which allows us to do
       # audio testing on Linux

Makefile

@@ -145,17 +145,17 @@ CXXFLAGS += -fno-strict-aliasing
 CXXFLAGS += -Wno-conversion-null
 
 ifeq ($(OS),lnx)
-	CXXLIBS += -lGL -lGLU -lX11 -lpthread -ldl -lrt
+	CXXLIBS += -lGL -lGLU -lX11 -lpthread -ldl -lrt -lxcb
 	CXXFLAGS += -DFREEGLUT_STATIC
 endif
 
 ifeq ($(OS),win)
-	CXXLIBS += -static-libgcc -static-libstdc++ -lcomdlg32 -lole32
+	CXXLIBS += -static-libgcc -static-libstdc++ -lcomdlg32 -lole32 -lshlwapi -lwindowscodecs
 	CXXFLAGS += -DGLEW_STATIC -DFREEGLUT_STATIC
 endif
 
 ifeq ($(OS),osx)
-	CXXLIBS += -framework OpenGL -framework IOKit -framework GLUT -framework Cocoa -framework ApplicationServices
+	CXXLIBS += -framework OpenGL -framework IOKit -framework GLUT -framework Cocoa -framework ApplicationServices -framework CoreFoundation
 
 	# OSX doesn't strip using objcopy, so we're using `-s` instead
 	ifneq ($(STRIP_SYMBOLS),n)
@@ -204,6 +204,7 @@ include $(PATH_INTERNAL_C)/parts/video/image/build.mk
 include $(PATH_INTERNAL_C)/parts/gui/build.mk
 include $(PATH_INTERNAL_C)/parts/network/http/build.mk
 include $(PATH_INTERNAL_C)/parts/compression/build.mk
+include $(PATH_INTERNAL_C)/parts/os/clipboard/build.mk
 
 .PHONY: all clean
 
@@ -267,6 +268,8 @@ endif
 ifneq ($(filter y,$(DEP_SCREENIMAGE)),)
 	CXXFLAGS += -DDEPENDENCY_SCREENIMAGE
 	QBLIB_NAME := $(addsuffix 1,$(QBLIB_NAME))
+
+	LICENSE_IN_USE += clip
 else
 	CXXFLAGS += -DDEPENDENCY_NO_SCREENIMAGE
 	QBLIB_NAME := $(addsuffix 0,$(QBLIB_NAME))
@@ -287,9 +290,7 @@ ifneq ($(filter y,$(DEP_DEVICEINPUT)),)
 	ifeq ($(OS),win)
 		CXXLIBS += -lwinmm -lxinput -ldinput8 -ldxguid -lwbemuuid -lole32 -loleaut32
 	endif
-	ifeq ($(OS),osx)
-		CXXLIBS += -framework CoreFoundation -framework IOKit
-	endif
+
 	QBLIB_NAME := $(addsuffix 1,$(QBLIB_NAME))
 
 	LICENSE_IN_USE += libstem_gamepad
@@ -308,7 +309,7 @@ ifneq ($(filter y,$(DEP_AUDIO_MINIAUDIO)),)
 		CXXLIBS += -lwinmm -lksguid -ldxguid -lole32
 	endif
 	ifeq ($(OS),osx)
-		CXXLIBS += -lpthread -lm -framework CoreFoundation -framework CoreAudio -framework CoreMIDI -framework AudioUnit -framework AudioToolbox
+		CXXLIBS += -lpthread -lm -framework CoreAudio -framework CoreMIDI -framework AudioUnit -framework AudioToolbox
 	endif
 	QBLIB_NAME := $(addsuffix 1,$(QBLIB_NAME))
 

internal/c/libqb.cpp

@@ -188,15 +188,6 @@ extern "C" int QB64_Resizable() { return ScreenResize; }
 
 int32 sub_gl_called = 0;
 
-extern "C" int qb64_custom_event(int event, int v1, int v2, int v3, int v4, int v5, int v6, int v7, int v8, void *p1, void *p2);
-#ifdef QB64_WINDOWS
-extern "C" LRESULT qb64_os_event_windows(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, int *qb64_os_event_info);
-#endif
-
-#if defined(QB64_LINUX) && defined(QB64_GUI)
-extern "C" void qb64_os_event_linux(XEvent *event, Display *display, int *qb64_os_event_info);
-#endif
-
 #define QB64_EVENT_CLOSE 1
 #define QB64_EVENT_KEY 2
 #define QB64_EVENT_RELATIVE_MOUSE_MOVEMENT 3
@@ -23910,448 +23901,6 @@ int32 func__exit() {
     return x;
 }
 
-#if defined(QB64_LINUX) && defined(QB64_GUI)
-
-// X11 clipboard interface for Linux
-// SDL_SysWMinfo syswminfo;
-Atom targets, utf8string, compoundtext, clipboard;
-
-int x11filter(XEvent *x11event) {
-    static int i;
-    static char *cp;
-    static XSelectionRequestEvent *x11request;
-    static XSelectionEvent x11selectionevent;
-    static Atom mytargets[] = {XA_STRING, utf8string, compoundtext};
-    if (x11event->type == SelectionRequest) {
-        x11request = &x11event->xselectionrequest;
-        x11selectionevent.type = SelectionNotify;
-        x11selectionevent.serial = x11event->xany.send_event;
-        x11selectionevent.send_event = True;
-        x11selectionevent.display = X11_display;
-        x11selectionevent.requestor = x11request->requestor;
-        x11selectionevent.selection = x11request->selection;
-        x11selectionevent.target = None;
-        x11selectionevent.property = x11request->property;
-        x11selectionevent.time = x11request->time;
-        if (x11request->target == targets) {
-            XChangeProperty(X11_display, x11request->requestor, x11request->property, XA_ATOM, 32, PropModeReplace, (unsigned char *)mytargets, 3);
-        } else {
-            if (x11request->target == compoundtext || x11request->target == utf8string || x11request->target == XA_STRING) {
-                cp = XFetchBytes(X11_display, &i);
-                XChangeProperty(X11_display, x11request->requestor, x11request->property, x11request->target, 8, PropModeReplace, (unsigned char *)cp, i);
-                XFree(cp);
-            } else {
-                x11selectionevent.property = None;
-            }
-        }
-        XSendEvent(x11request->display, x11request->requestor, 0, NoEventMask, (XEvent *)&x11selectionevent);
-        XSync(X11_display, False);
-    }
-    return 1;
-}
-
-void setupx11clipboard() {
-    static int32 setup = 0;
-    if (!setup) {
-        setup = 1;
-        // SDL_GetWMInfo(&syswminfo);
-        // SDL_EventState(SDL_SYSWMEVENT,SDL_ENABLE);
-        // SDL_SetEventFilter(x11filter);
-        x11_lock();
-        targets = XInternAtom(X11_display, "TARGETS", False);
-        utf8string = XInternAtom(X11_display, "UTF8_STRING", False);
-        compoundtext = XInternAtom(X11_display, "COMPOUND_TEXT", False);
-        clipboard = XInternAtom(X11_display, "CLIPBOARD", False);
-        x11_unlock();
-    }
-}
-
-void x11clipboardcopy(const char *text) {
-    setupx11clipboard();
-    x11_lock();
-    XStoreBytes(X11_display, text, strlen(text) + 1);
-    XSetSelectionOwner(X11_display, clipboard, X11_window, CurrentTime);
-    x11_unlock();
-    return;
-}
-
-char *x11clipboardpaste() {
-    static int32 i;
-    static char *cp;
-    static unsigned char *cp2;
-    static Window x11selectionowner;
-    static XEvent x11event;
-    static unsigned long data_items, bytes_remaining, ignore;
-    static int format;
-    static Atom type;
-    cp = NULL;
-    cp2 = NULL;
-    setupx11clipboard();
-    // syswminfo.info.x11.lock_func();
-    x11_lock();
-    x11selectionowner = XGetSelectionOwner(X11_display, clipboard);
-    if (x11selectionowner != None) {
-        // The XGetSelectionOwner() function returns the window ID associated with the window
-        if (x11selectionowner == X11_window) { // we are the provider, so just return buffered content
-            x11_unlock();
-            int bytes;
-            cp = XFetchBytes(X11_display, &bytes);
-            return cp;
-        }
-        XConvertSelection(X11_display, clipboard, utf8string, clipboard, X11_window, CurrentTime);
-        XFlush(X11_display);
-        bool gotReply = false;
-        int timeoutMs = 10000; // 10sec
-        do {
-            XEvent event;
-            gotReply = XCheckTypedWindowEvent(X11_display, X11_window, SelectionNotify, &event);
-            if (gotReply) {
-                if (event.xselection.property == clipboard) {
-                    XGetWindowProperty(X11_display, X11_window, clipboard, 0, 0, False, AnyPropertyType, &type, &format, &data_items, &bytes_remaining, &cp2);
-                    if (cp2) {
-                        XFree(cp2);
-                        cp2 = NULL;
-                    }
-                    if (bytes_remaining) {
-                        if (XGetWindowProperty(X11_display, X11_window, clipboard, 0, bytes_remaining, False, AnyPropertyType, &type, &format, &data_items,
-                                               &ignore, &cp2) == Success) {
-                            cp = strdup((char *)cp2);
-                            XFree(cp2);
-                            XDeleteProperty(X11_display, X11_window, clipboard);
-                            x11_unlock();
-                            return cp;
-                        }
-                    }
-                    x11_unlock();
-                    return NULL;
-
-                } else {
-                    x11_unlock();
-                    return NULL;
-                }
-            }
-            Sleep(1);
-            timeoutMs -= 1;
-        } while (timeoutMs > 0);
-    } // x11selectionowner!=None
-    x11_unlock();
-    return NULL;
-}
-
-#elif defined(QB64_LINUX)
-void x11clipboardcopy(const char *text) {}
-char *x11clipboardpaste() { return NULL; }
-#endif
-
-qbs *internal_clipboard = NULL; // used only if clipboard services unavailable
-int32 linux_clipboard_init = 0;
-
-void sub__clipboard(qbs *text) {
-
-#ifdef QB64_WINDOWS
-    static uint8 *textz;
-    static HGLOBAL h;
-    if (OpenClipboard(NULL)) {
-        EmptyClipboard();
-        h = GlobalAlloc(GMEM_MOVEABLE, text->len + 1);
-        if (h) {
-            textz = (uint8 *)GlobalLock(h);
-            if (textz) {
-                memcpy(textz, text->chr, text->len);
-                textz[text->len] = 0;
-                GlobalUnlock(h);
-                SetClipboardData(CF_TEXT, h);
-            }
-        }
-        CloseClipboard();
-    }
-    return;
-#endif
-
-#ifdef QB64_MACOSX
-    PasteboardRef clipboard;
-    if (PasteboardCreate(kPasteboardClipboard, &clipboard) != noErr) {
-        return;
-    }
-    if (PasteboardClear(clipboard) != noErr) {
-        CFRelease(clipboard);
-        return;
-    }
-    CFDataRef data = CFDataCreateWithBytesNoCopy(kCFAllocatorDefault, text->chr, text->len, kCFAllocatorNull);
-    if (data == NULL) {
-        CFRelease(clipboard);
-        return;
-    }
-    OSStatus err;
-    err = PasteboardPutItemFlavor(clipboard, NULL, kUTTypeUTF8PlainText, data, 0);
-    CFRelease(clipboard);
-    CFRelease(data);
-    return;
-#endif
-
-#if defined(QB64_LINUX)
-    static qbs *textz = NULL;
-    if (!textz)
-        textz = qbs_new(0, 0);
-    qbs_set(textz, qbs_add(text, qbs_new_txt_len("\0", 1)));
-    x11clipboardcopy((char *)textz->chr);
-    return;
-#endif
-
-    if (internal_clipboard == NULL)
-        internal_clipboard = qbs_new(0, 0);
-    qbs_set(internal_clipboard, text);
-}
-
-#ifdef DEPENDENCY_SCREENIMAGE
-void sub__clipboardimage(int32 src) {
-#    ifdef QB64_WINDOWS
-
-    if (is_error_pending())
-        return;
-
-    static int32 i, i2, ii, w, h;
-    static uint32 *o, *o2;
-    static int32 x, y, n, c, i3, c2;
-
-    // validation
-    i = src;
-    if (i >= 0) { // validate i
-        validatepage(i);
-        i = page[i];
-    } else {
-        i = -i;
-        if (i >= nextimg) {
-            error(258);
-            return;
-        }
-        if (!img[i].valid) {
-            error(258);
-            return;
-        }
-    }
-
-    if (img[i].text) {
-        error(5);
-        return;
-    }
-    // end of validation
-
-    w = img[i].width;
-    h = img[i].height;
-
-    // source[http://support.microsoft.com/kb/318876]
-    HDC hdc;
-    BITMAPV5HEADER bi;
-    HBITMAP hBitmap;
-    void *lpBits;
-    ZeroMemory(&bi, sizeof(BITMAPV5HEADER));
-    bi.bV5Size = sizeof(BITMAPV5HEADER);
-    bi.bV5Width = w;
-    bi.bV5Height = h;
-    bi.bV5Planes = 1;
-    bi.bV5BitCount = 32;
-    bi.bV5Compression = BI_RGB;
-
-    hdc = GetDC(NULL);
-    // Create the DIB section with an alpha channel.
-    hBitmap = CreateDIBSection(hdc, (BITMAPINFO *)&bi, DIB_RGB_COLORS, (void **)&lpBits, NULL, (DWORD)0);
-
-    // Transfer the source image to a new 32-bit image to avoid incompatible formats)
-    i2 = func__newimage(w, h, 32, 1);
-    sub__putimage(NULL, NULL, NULL, NULL, -i, i2, NULL, NULL, NULL, NULL, 8 + 32);
-
-    o = img[-i2].offset32;
-    o2 = (uint32 *)lpBits;
-    for (y = 0; y < h; y++) {
-        for (x = 0; x < w; x++) {
-            c = o[(h - 1 - y) * w + x];
-            o2[y * w + x] = c;
-        }
-    }
-
-    sub__freeimage(i2, 1);
-
-    // Create copy of hBitmap to send to the clipboard
-    HBITMAP bitmapCopy;
-    HDC hdc2, hdc3;
-    bitmapCopy = CreateCompatibleBitmap(hdc, w, h);
-    hdc2 = CreateCompatibleDC(hdc);
-    hdc3 = CreateCompatibleDC(hdc);
-    SelectObject(hdc2, bitmapCopy);
-    SelectObject(hdc3, hBitmap);
-    BitBlt(hdc2, 0, 0, w, h, hdc3, 0, 0, SRCCOPY);
-
-    ReleaseDC(NULL, hdc);
-    ReleaseDC(NULL, hdc2);
-    ReleaseDC(NULL, hdc3);
-
-    // Send bitmapCopy to the clipboard
-    if (OpenClipboard(NULL)) {
-        EmptyClipboard();
-        SetClipboardData(CF_BITMAP, bitmapCopy);
-        CloseClipboard();
-    }
-
-    DeleteObject(hBitmap);
-    DeleteObject(bitmapCopy);
-#    endif
-}
-#endif
-
-#ifdef DEPENDENCY_SCREENIMAGE
-int32 func__clipboardimage() {
-#    ifdef QB64_WINDOWS
-
-    if (is_error_pending())
-        return -1;
-
-    static HBITMAP bitmap;
-    static BITMAP bitmapInfo;
-    static HDC hdc;
-    static int32 w, h;
-
-    if (OpenClipboard(NULL)) {
-        if (IsClipboardFormatAvailable(CF_BITMAP) == 0) {
-            CloseClipboard();
-            return -1;
-        }
-
-        bitmap = (HBITMAP)GetClipboardData(CF_BITMAP);
-        CloseClipboard();
-        GetObject(bitmap, sizeof(BITMAP), &bitmapInfo);
-        h = bitmapInfo.bmHeight;
-        w = bitmapInfo.bmWidth;
-
-        static BITMAPFILEHEADER bmfHeader;
-        static BITMAPINFOHEADER bi;
-        bi.biSize = sizeof(BITMAPINFOHEADER);
-        bi.biWidth = w;
-        bi.biHeight = -h;
-        bi.biPlanes = 1;
-        bi.biBitCount = 32;
-        bi.biCompression = BI_RGB;
-        bi.biSizeImage = 0;
-        bi.biXPelsPerMeter = 0;
-        bi.biYPelsPerMeter = 0;
-        bi.biClrUsed = 0;
-        bi.biClrImportant = 0;
-
-        static int32 i, i2;
-        i2 = func__dest();
-        i = func__newimage(w, h, 32, 1);
-        sub__dest(i);
-
-        hdc = GetDC(NULL);
-
-        GetDIBits(hdc, bitmap, 0, h, write_page->offset, (BITMAPINFO *)&bi, DIB_RGB_COLORS);
-        sub__setalpha(255, NULL, NULL, NULL, 0); // required as some images come
-        // with alpha 0 from the clipboard
-        sub__dest(i2);
-
-        ReleaseDC(NULL, hdc);
-        DeleteObject(bitmap);
-        return i;
-
-    } else
-        return -1;
-#    endif
-    return -1;
-}
-#endif
-
-qbs *func__clipboard() {
-#ifdef QB64_WINDOWS
-    static qbs *text;
-    static uint8 *textz;
-    static HGLOBAL h;
-    if (OpenClipboard(NULL)) {
-        if (IsClipboardFormatAvailable(CF_TEXT)) {
-            h = GetClipboardData(CF_TEXT);
-            if (h) {
-                textz = (uint8 *)GlobalLock(h);
-                if (textz) {
-                    text = qbs_new(strlen((char *)textz), 1);
-                    memcpy(text->chr, textz, text->len);
-                    GlobalUnlock(h);
-                    CloseClipboard();
-                    return text;
-                }
-            }
-        }
-        CloseClipboard();
-    }
-    text = qbs_new(0, 1);
-    return text;
-#endif
-
-#ifdef QB64_MACOSX
-    static qbs *text;
-    OSStatus err = noErr;
-    ItemCount itemCount;
-    PasteboardSyncFlags syncFlags;
-    static PasteboardRef inPasteboard = NULL;
-    PasteboardCreate(kPasteboardClipboard, &inPasteboard);
-    char *data;
-    data = "";
-    syncFlags = PasteboardSynchronize(inPasteboard);
-    err = badPasteboardSyncErr;
-
-    err = PasteboardGetItemCount(inPasteboard, &itemCount);
-    if ((err) != noErr)
-        goto CantGetPasteboardItemCount;
-
-    for (int itemIndex = 1; itemIndex <= itemCount; itemIndex++) {
-        PasteboardItemID itemID;
-        CFDataRef flavorData;
-
-        err = PasteboardGetItemIdentifier(inPasteboard, itemIndex, &itemID);
-        if ((err) != noErr)
-            goto CantGetPasteboardItemIdentifier;
-
-        err = PasteboardCopyItemFlavorData(inPasteboard, itemID, CFSTR("public.utf8-plain-text"), &flavorData);
-        if ((err) != noErr)
-            goto CantGetPasteboardItemCount;
-        data = (char *)CFDataGetBytePtr(flavorData);
-
-        uint32 size;
-        size = CFDataGetLength(flavorData);
-
-        text = qbs_new(size, 1);
-        memcpy(text->chr, data, text->len);
-        // CFRelease (flavorData);
-        // CFRelease (flavorTypeArray);
-        // CFRelease(inPasteboard);
-        return text;
-
-    CantGetPasteboardItemIdentifier:;
-    }
-
-CantGetPasteboardItemCount:
-    text = qbs_new(0, 1);
-    return text;
-    return NULL;
-#endif
-
-#if defined(QB64_LINUX)
-    qbs *text;
-    char *cp = x11clipboardpaste();
-    cp = x11clipboardpaste();
-    if (!cp) {
-        text = qbs_new(0, 1);
-    } else {
-        text = qbs_new(strlen(cp), 1);
-        memcpy(text->chr, cp, text->len);
-        free(cp);
-    }
-    return text;
-#endif
-
-    if (internal_clipboard == NULL)
-        internal_clipboard = qbs_new(0, 0);
-    return internal_clipboard;
-}
-
 int32 display_called = 0;
 void display_now() {
     if (autodisplay) {
@@ -27656,6 +27205,11 @@ void GLUT_key_special(int32 key, int32 down) {
 #    endif
 
     if (vk != -1) {
+#    ifdef QB64_WINDOWS
+        if (!func__hasfocus() && !(keyheld(vk) && !down))
+            return;
+#    endif
+
         if (down)
             keydown_vk(vk);
         else
@@ -27673,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>
@@ -29914,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();
@@ -32392,8 +31960,6 @@ extern "C" void qb64_os_event_linux(XEvent *event, Display *display, int *qb64_o
             X11_display = display;
             X11_window = event->xexpose.window;
         }
-
-        x11filter(event); // handles clipboard request events from other applications
     }
 
     if (*qb64_os_event_info == OS_EVENT_POST_PROCESSING) {

internal/c/libqb/include/clipboard.h

@@ -0,0 +1,15 @@
+//----------------------------------------------------------------------------------------------------------------------
+// QB64-PE cross-platform clipboard support
+// Powered by clip (https://github.com/dacap/clip)
+//----------------------------------------------------------------------------------------------------------------------
+
+#pragma once
+
+#include <stdint.h>
+
+struct qbs;
+
+qbs *func__clipboard();
+void sub__clipboard(const qbs *qbsText);
+int32_t func__clipboardimage();
+void sub__clipboardimage(int32_t src);

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);

internal/c/libqb/include/image.h

@@ -1,4 +1,4 @@
-//----------------------------------------------------------------------------------------------------
+//-----------------------------------------------------------------------------------------------------
 //    ___  ___   __ _ _  ___ ___   ___                       _    _ _
 //   / _ \| _ ) / /| | || _ \ __| |_ _|_ __  __ _ __ _ ___  | |  (_) |__ _ _ __ _ _ _ _  _
 //  | (_) | _ \/ _ \_  _|  _/ _|   | || '  \/ _` / _` / -_) | |__| | '_ \ '_/ _` | '_| || |
@@ -17,6 +17,7 @@
 
 #pragma once
 
+#include <cmath>
 #include <stdint.h>
 #include <stdio.h>
 
@@ -38,16 +39,42 @@
 #    define IMAGE_DEBUG_CHECK(_exp_) // Don't do anything in release builds
 #endif
 
-// The byte ordering here are straight from libqb.cpp. So, if libqb.cpp is wrong, then we are wrong! ;)
-#define IMAGE_GET_BGRA_RED(c) ((uint8_t)((uint32_t)(c) >> 16 & 0xFFu))
-#define IMAGE_GET_BGRA_GREEN(c) ((uint8_t)((uint32_t)(c) >> 8 & 0xFFu))
-#define IMAGE_GET_BGRA_BLUE(c) ((uint8_t)((uint32_t)(c) & 0xFFu))
-#define IMAGE_GET_BGRA_ALPHA(c) ((uint8_t)((uint32_t)(c) >> 24))
-#define IMAGE_GET_BGRA_BGR(c) ((uint32_t)(c) & 0xFFFFFFu)
-#define IMAGE_MAKE_BGRA(r, g, b, a)                                                                                                                            \
-    ((uint32_t)((uint8_t)(b) | ((uint32_t)((uint8_t)(g)) << 8) | ((uint32_t)((uint8_t)(r)) << 16) | ((uint32_t)((uint8_t)(a)) << 24)))
+// This is returned to the caller if something goes wrong while loading the image
+#define INVALID_IMAGE_HANDLE -1
 
 struct qbs;
 
 int32_t func__loadimage(qbs *qbsFileName, int32_t bpp, qbs *qbsRequirements, int32_t passed);
 void sub__saveimage(qbs *qbsFileName, int32_t imageHandle, qbs *qbsRequirements, int32_t passed);
+
+static inline constexpr uint8_t image_get_bgra_red(const uint32_t c) { return (uint8_t)((c >> 16) & 0xFFu); }
+
+static inline constexpr uint8_t image_get_bgra_green(const uint32_t c) { return (uint8_t)((c >> 8) & 0xFFu); }
+
+static inline constexpr uint8_t image_get_bgra_blue(const uint32_t c) { return (uint8_t)(c & 0xFFu); }
+
+static inline constexpr uint8_t image_get_bgra_alpha(const uint32_t c) { return (uint8_t)(c >> 24); }
+
+static inline constexpr uint32_t image_get_bgra_bgr(const uint32_t c) { return (uint32_t)(c & 0xFFFFFFu); }
+
+static inline constexpr uint32_t image_make_bgra(const uint8_t r, const uint8_t g, const uint8_t b, const uint8_t a) {
+    return (uint32_t)(b) | ((uint32_t)(g) << 8) | ((uint32_t)(r) << 16) | ((uint32_t)(a) << 24);
+}
+
+static inline constexpr int image_scale_5bits_to_8bits(const int v) { return (v << 3) | (v >> 2); }
+
+static inline constexpr int image_scale_6bits_to_8bits(const int v) { return (v << 2) | (v >> 4); }
+
+static inline constexpr uint32_t image_swap_red_blue(const uint32_t clr) {
+    return ((clr & 0xFF00FF00u) | ((clr & 0x00FF0000u) >> 16) | ((clr & 0x000000FFu) << 16));
+}
+
+static inline constexpr uint8_t image_clamp_color_component(const int n) { return n < 0 ? 0 : n > 255 ? 255 : n; }
+
+static inline float image_calculate_rgb_distance(const uint8_t r1, const uint8_t g1, const uint8_t b1, const uint8_t r2, const uint8_t g2, const uint8_t b2) {
+    auto delta_r = (float)r2 - (float)r1;
+    auto delta_g = (float)g2 - (float)g1;
+    auto delta_b = (float)b2 - (float)b1;
+
+    return sqrtf(delta_r * delta_r + delta_g * delta_g + delta_b * delta_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(); }

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);

internal/c/parts/core/freeglut/freeglut_main.c

@@ -1047,9 +1047,7 @@ void FGAPIENTRY glutMainLoopEvent( void )
 #endif
 
         // QB64-PE: custom code begin
-        int qb64_os_event_info = 0;
-
-        qb64_os_event_info = 1;
+        int qb64_os_event_info = 1;
         qb64_os_event_linux(&event, fgDisplay.Display, &qb64_os_event_info);
         if (qb64_os_event_info == 3)
             return;

internal/c/parts/gui/gui.cpp

@@ -229,10 +229,10 @@ uint32_t func__guiColorChooserDialog(qbs *qbsTitle, uint32_t nDefaultRGB, int32_
         nDefaultRGB = 0;
 
     // Break the color into RGB components
-    uint8_t lRGB[3] = {IMAGE_GET_BGRA_RED(nDefaultRGB), IMAGE_GET_BGRA_GREEN(nDefaultRGB), IMAGE_GET_BGRA_BLUE(nDefaultRGB)};
+    uint8_t lRGB[3] = {image_get_bgra_red(nDefaultRGB), image_get_bgra_green(nDefaultRGB), image_get_bgra_blue(nDefaultRGB)};
 
     // On cancel, return 0 (i.e. no color, no alpha, nothing). Else, return color with alpha set to 255
-    return !tinyfd_colorChooser(aTitle.c_str(), nullptr, lRGB, lRGB) ? 0 : IMAGE_MAKE_BGRA(lRGB[0], lRGB[1], lRGB[2], 0xFF);
+    return !tinyfd_colorChooser(aTitle.c_str(), nullptr, lRGB, lRGB) ? 0 : image_make_bgra(lRGB[0], lRGB[1], lRGB[2], 0xFF);
 }
 
 /// @brief Shows the system file open dialog box

internal/c/parts/os/clipboard/build.mk

@@ -0,0 +1,56 @@
+
+# clip Setup:
+# Download the latest release from https://github.com/dacap/clip
+# Copy all source files except clip_none.cpp to internal/c/parts/os/clipboard/clip
+# Compile the source using -DCLIP_ENABLE_IMAGE=1, -DHAVE_XCB_XLIB_H (Linux) and DHAVE_PNG_H (Linux)
+
+CLIP_DEFS := -DCLIP_ENABLE_IMAGE=1
+
+CLIP_SRCS := \
+	clip.cpp \
+	image.cpp
+
+ifeq ($(OS),lnx)
+	CLIP_SRCS += clip_x11.cpp
+	CLIP_DEFS += -DHAVE_XCB_XLIB_H -DHAVE_PNG_H
+	CXXLIBS += -lpng
+endif
+
+ifeq ($(OS),win)
+	CLIP_SRCS += clip_win.cpp
+endif
+
+ifeq ($(OS),osx)
+	CLIP_OSX_SRCS := clip_osx.mm
+endif
+
+CLIPBOARD_SRCS := clipboard.cpp
+
+CLIP_OBJS := $(patsubst %.cpp,$(PATH_INTERNAL_C)/parts/os/clipboard/clip/%.o,$(CLIP_SRCS))
+
+ifeq ($(OS),osx)
+CLIP_OBJS += $(patsubst %.mm,$(PATH_INTERNAL_C)/parts/os/clipboard/clip/%.o,$(CLIP_OSX_SRCS))
+endif
+
+CLIPBOARD_OBJS := $(patsubst %.cpp,$(PATH_INTERNAL_C)/parts/os/clipboard/%.o,$(CLIPBOARD_SRCS))
+
+$(PATH_INTERNAL_C)/parts/os/clipboard/clip/%.o: $(PATH_INTERNAL_C)/parts/os/clipboard/clip/%.cpp
+	$(CXX) -O2 $(CXXFLAGS) $(CLIP_DEFS) -w $< -c -o $@
+
+ifeq ($(OS),osx)
+$(PATH_INTERNAL_C)/parts/os/clipboard/clip/%.o: $(PATH_INTERNAL_C)/parts/os/clipboard/clip/%.mm
+	$(CXX) -O2 $(CXXFLAGS) $(CLIP_DEFS) -w $< -c -o $@
+endif
+
+$(PATH_INTERNAL_C)/parts/os/clipboard/%.o: $(PATH_INTERNAL_C)/parts/os/clipboard/%.cpp
+	$(CXX) -O2 $(CXXFLAGS) $(CLIP_DEFS) -Wall -Wextra $< -c -o $@
+
+CLIPBOARD_LIB := $(PATH_INTERNAL_C)/parts/os/clipboard/clipboard.a
+
+$(CLIPBOARD_LIB): $(CLIP_OBJS) $(CLIPBOARD_OBJS)
+	$(AR) rcs $@ $(CLIP_OBJS) $(CLIPBOARD_OBJS)
+
+EXE_LIBS += $(CLIPBOARD_LIB)
+
+CLEAN_LIST += $(CLIPBOARD_LIB) $(CLIP_OBJS) $(CLIPBOARD_OBJS)
+

internal/c/parts/os/clipboard/clip/clip.cpp

@@ -0,0 +1,184 @@
+// Clip Library
+// Copyright (c) 2015-2018 David Capello
+//
+// This file is released under the terms of the MIT license.
+// Read LICENSE.txt for more information.
+
+#include "clip.h"
+#include "clip_lock_impl.h"
+
+#include <vector>
+#include <stdexcept>
+
+namespace clip {
+
+namespace {
+
+void default_error_handler(ErrorCode code) {
+  static const char* err[] = {
+    "Cannot lock clipboard",
+    "Image format is not supported"
+  };
+  throw std::runtime_error(err[static_cast<int>(code)]);
+}
+
+} // anonymous namespace
+
+error_handler g_error_handler = default_error_handler;
+
+lock::lock(void* native_window_handle)
+  : p(new impl(native_window_handle)) {
+}
+
+lock::~lock() = default;
+
+bool lock::locked() const {
+  return p->locked();
+}
+
+bool lock::clear() {
+  return p->clear();
+}
+
+bool lock::is_convertible(format f) const {
+  return p->is_convertible(f);
+}
+
+bool lock::set_data(format f, const char* buf, size_t length) {
+  return p->set_data(f, buf, length);
+}
+
+bool lock::get_data(format f, char* buf, size_t len) const {
+  return p->get_data(f, buf, len);
+}
+
+size_t lock::get_data_length(format f) const {
+  return p->get_data_length(f);
+}
+
+#if CLIP_ENABLE_IMAGE
+
+bool lock::set_image(const image& img) {
+  return p->set_image(img);
+}
+
+bool lock::get_image(image& img) const {
+  return p->get_image(img);
+}
+
+bool lock::get_image_spec(image_spec& spec) const {
+  return p->get_image_spec(spec);
+}
+
+#endif // CLIP_ENABLE_IMAGE
+
+format empty_format() { return 0; }
+format text_format()  { return 1; }
+#if CLIP_ENABLE_IMAGE
+format image_format() { return 2; }
+#endif
+
+bool has(format f) {
+  lock l;
+  if (l.locked())
+    return l.is_convertible(f);
+  else
+    return false;
+}
+
+bool clear() {
+  lock l;
+  if (l.locked())
+    return l.clear();
+  else
+    return false;
+}
+
+bool set_text(const std::string& value) {
+  lock l;
+  if (l.locked()) {
+    l.clear();
+    return l.set_data(text_format(), value.c_str(), value.size());
+  }
+  else
+    return false;
+}
+
+bool get_text(std::string& value) {
+  lock l;
+  if (!l.locked())
+    return false;
+
+  format f = text_format();
+  if (!l.is_convertible(f))
+    return false;
+
+  size_t len = l.get_data_length(f);
+  if (len > 0) {
+    std::vector<char> buf(len);
+    l.get_data(f, &buf[0], len);
+    value = &buf[0];
+    return true;
+  }
+  else {
+    value.clear();
+    return true;
+  }
+}
+
+#if CLIP_ENABLE_IMAGE
+
+bool set_image(const image& img) {
+  lock l;
+  if (l.locked()) {
+    l.clear();
+    return l.set_image(img);
+  }
+  else
+    return false;
+}
+
+bool get_image(image& img) {
+  lock l;
+  if (!l.locked())
+    return false;
+
+  format f = image_format();
+  if (!l.is_convertible(f))
+    return false;
+
+  return l.get_image(img);
+}
+
+bool get_image_spec(image_spec& spec) {
+  lock l;
+  if (!l.locked())
+    return false;
+
+  format f = image_format();
+  if (!l.is_convertible(f))
+    return false;
+
+  return l.get_image_spec(spec);
+}
+
+#endif // CLIP_ENABLE_IMAGE
+
+void set_error_handler(error_handler handler) {
+  g_error_handler = handler;
+}
+
+error_handler get_error_handler() {
+  return g_error_handler;
+}
+
+#ifdef HAVE_XCB_XLIB_H
+static int g_x11_timeout = 1000;
+void set_x11_wait_timeout(int msecs) { g_x11_timeout = msecs; }
+int get_x11_wait_timeout() { return g_x11_timeout; }
+#else
+void set_x11_wait_timeout(int) { }
+int get_x11_wait_timeout() { return 1000; }
+#endif
+
+} // namespace clip

internal/c/parts/os/clipboard/clip/clip.h

@@ -0,0 +1,190 @@
+// Clip Library
+// Copyright (c) 2015-2024 David Capello
+//
+// This file is released under the terms of the MIT license.
+// Read LICENSE.txt for more information.
+
+#ifndef CLIP_H_INCLUDED
+#define CLIP_H_INCLUDED
+#pragma once
+
+#include <cassert>
+#include <memory>
+#include <string>
+
+namespace clip {
+
+  // ======================================================================
+  // Low-level API to lock the clipboard/pasteboard and modify it
+  // ======================================================================
+
+  // Clipboard format identifier.
+  typedef size_t format;
+
+  class image;
+  struct image_spec;
+
+  class lock {
+  public:
+    // You can give your current HWND as the "native_window_handle."
+    // Windows clipboard functions use this handle to open/close
+    // (lock/unlock) the clipboard. From the MSDN documentation we
+    // need this handler so SetClipboardData() doesn't fail after a
+    // EmptyClipboard() call. Anyway it looks to work just fine if we
+    // call OpenClipboard() with a null HWND.
+    lock(void* native_window_handle = nullptr);
+    ~lock();
+
+    // Returns true if we've locked the clipboard successfully in
+    // lock() constructor.
+    bool locked() const;
+
+    // Clears the clipboard content. If you don't clear the content,
+    // previous clipboard content (in unknown formats) could persist
+    // after the unlock.
+    bool clear();
+
+    // Returns true if the clipboard can be converted to the given
+    // format.
+    bool is_convertible(format f) const;
+    bool set_data(format f, const char* buf, size_t len);
+    bool get_data(format f, char* buf, size_t len) const;
+    size_t get_data_length(format f) const;
+
+#if CLIP_ENABLE_IMAGE
+    // For images
+    bool set_image(const image& image);
+    bool get_image(image& image) const;
+    bool get_image_spec(image_spec& spec) const;
+#endif // CLIP_ENABLE_IMAGE
+
+  private:
+    class impl;
+    std::unique_ptr<impl> p;
+  };
+
+  format register_format(const std::string& name);
+
+  // This format is when the clipboard has no content.
+  format empty_format();
+
+  // When the clipboard has UTF8 text.
+  format text_format();
+
+#if CLIP_ENABLE_IMAGE
+  // When the clipboard has an image.
+  format image_format();
+#endif
+
+  // Returns true if the clipboard has content of the given type.
+  bool has(format f);
+
+  // Clears the clipboard content.
+  bool clear();
+
+  // ======================================================================
+  // Error handling
+  // ======================================================================
+
+  enum class ErrorCode {
+    CannotLock,
+#if CLIP_ENABLE_IMAGE
+    ImageNotSupported,
+#endif
+  };
+
+  typedef void (*error_handler)(ErrorCode code);
+
+  void set_error_handler(error_handler f);
+  error_handler get_error_handler();
+
+  // ======================================================================
+  // Text
+  // ======================================================================
+
+  // High-level API to put/get UTF8 text in/from the clipboard. These
+  // functions returns false in case of error.
+  bool set_text(const std::string& value);
+  bool get_text(std::string& value);
+
+  // ======================================================================
+  // Image
+  // ======================================================================
+
+#if CLIP_ENABLE_IMAGE
+
+  struct image_spec {
+    unsigned long width = 0;
+    unsigned long height = 0;
+    unsigned long bits_per_pixel = 0;
+    unsigned long bytes_per_row = 0;
+    unsigned long red_mask = 0;
+    unsigned long green_mask = 0;
+    unsigned long blue_mask = 0;
+    unsigned long alpha_mask = 0;
+    unsigned long red_shift = 0;
+    unsigned long green_shift = 0;
+    unsigned long blue_shift = 0;
+    unsigned long alpha_shift = 0;
+
+    unsigned long required_data_size() const;
+  };
+
+  // The image data must contain straight RGB values
+  // (non-premultiplied by alpha). The image retrieved from the
+  // clipboard will be non-premultiplied too. Basically you will be
+  // always dealing with straight alpha images.
+  //
+  // Details: Windows expects premultiplied images on its clipboard
+  // content, so the library code make the proper conversion
+  // automatically. macOS handles straight alpha directly, so there is
+  // no conversion at all. Linux/X11 images are transferred in
+  // image/png format which are specified in straight alpha.
+  class image {
+  public:
+    image();
+    image(const image_spec& spec);
+    image(const void* data, const image_spec& spec);
+    image(const image& image);
+    image(image&& image);
+    ~image();
+
+    image& operator=(const image& image);
+    image& operator=(image&& image);
+
+    char* data() const { return m_data; }
+    const image_spec& spec() const { return m_spec; }
+
+    bool is_valid() const { return m_data != nullptr; }
+    void reset();
+
+  private:
+    void copy_image(const image& image);
+    void move_image(image&& image);
+
+    bool m_own_data;
+    char* m_data;
+    image_spec m_spec;
+  };
+
+  // High-level API to set/get an image in/from the clipboard. These
+  // functions returns false in case of error.
+  bool set_image(const image& img);
+  bool get_image(image& img);
+  bool get_image_spec(image_spec& spec);
+
+#endif // CLIP_ENABLE_IMAGE
+
+  // ======================================================================
+  // Platform-specific
+  // ======================================================================
+
+  // Only for X11: Sets the time (in milliseconds) that we must wait
+  // for the selection/clipboard owner to receive the content. This
+  // value is 1000 (one second) by default.
+  void set_x11_wait_timeout(int msecs);
+  int get_x11_wait_timeout();
+
+} // namespace clip
+
+#endif // CLIP_H_INCLUDED

internal/c/parts/os/clipboard/clip/clip_common.h

@@ -0,0 +1,80 @@
+// Clip Library
+// Copyright (C) 2020-2024 David Capello
+//
+// This file is released under the terms of the MIT license.
+// Read LICENSE.txt for more information.
+
+#ifndef CLIP_COMMON_H_INCLUDED
+#define CLIP_COMMON_H_INCLUDED
+#pragma once
+
+namespace clip {
+namespace details {
+
+#if CLIP_ENABLE_IMAGE
+
+inline void divide_rgb_by_alpha(image& img,
+                                bool hasAlphaGreaterThanZero = false) {
+  const image_spec& spec = img.spec();
+
+  bool hasValidPremultipliedAlpha = true;
+
+  for (unsigned long y=0; y<spec.height; ++y) {
+    const uint32_t* dst = (uint32_t*)(img.data()+y*spec.bytes_per_row);
+    for (unsigned long x=0; x<spec.width; ++x, ++dst) {
+      const uint32_t c = *dst;
+      const int r = ((c & spec.red_mask  ) >> spec.red_shift  );
+      const int g = ((c & spec.green_mask) >> spec.green_shift);
+      const int b = ((c & spec.blue_mask ) >> spec.blue_shift );
+      const int a = ((c & spec.alpha_mask) >> spec.alpha_shift);
+
+      if (a > 0)
+        hasAlphaGreaterThanZero = true;
+      if (r > a || g > a || b > a)
+        hasValidPremultipliedAlpha = false;
+    }
+  }
+
+  for (unsigned long y=0; y<spec.height; ++y) {
+    uint32_t* dst = (uint32_t*)(img.data()+y*spec.bytes_per_row);
+    for (unsigned long x=0; x<spec.width; ++x, ++dst) {
+      const uint32_t c = *dst;
+      int r = ((c & spec.red_mask  ) >> spec.red_shift  );
+      int g = ((c & spec.green_mask) >> spec.green_shift);
+      int b = ((c & spec.blue_mask ) >> spec.blue_shift );
+      int a = ((c & spec.alpha_mask) >> spec.alpha_shift);
+
+      // If all alpha values = 0, we make the image opaque.
+      if (!hasAlphaGreaterThanZero) {
+        a = 255;
+
+        // We cannot change the image spec (e.g. spec.alpha_mask=0) to
+        // make the image opaque, because the "spec" of the image is
+        // read-only. The image spec used by the client is the one
+        // returned by get_image_spec().
+      }
+      // If there is alpha information and it's pre-multiplied alpha
+      else if (hasValidPremultipliedAlpha) {
+        if (a > 0) {
+          // Convert it to straight alpha
+          r = r * 255 / a;
+          g = g * 255 / a;
+          b = b * 255 / a;
+        }
+      }
+
+      *dst =
+        (r << spec.red_shift  ) |
+        (g << spec.green_shift) |
+        (b << spec.blue_shift ) |
+        (a << spec.alpha_shift);
+    }
+  }
+}
+
+#endif // CLIP_ENABLE_IMAGE
+
+} // namespace details
+} // namespace clip
+
+#endif // CLIP_H_INCLUDED

internal/c/parts/os/clipboard/clip/clip_lock_impl.h

@@ -0,0 +1,33 @@
+// Clip Library
+// Copyright (c) 2015-2018 David Capello
+//
+// This file is released under the terms of the MIT license.
+// Read LICENSE.txt for more information.
+
+#ifndef CLIP_LOCK_IMPL_H_INCLUDED
+#define CLIP_LOCK_IMPL_H_INCLUDED
+
+namespace clip {
+
+class lock::impl {
+public:
+  impl(void* native_window_handle);
+  ~impl();
+
+  bool locked() const { return m_locked; }
+  bool clear();
+  bool is_convertible(format f) const;
+  bool set_data(format f, const char* buf, size_t len);
+  bool get_data(format f, char* buf, size_t len) const;
+  size_t get_data_length(format f) const;
+  bool set_image(const image& image);
+  bool get_image(image& image) const;
+  bool get_image_spec(image_spec& spec) const;
+
+private:
+  bool m_locked;
+};
+
+} // namespace clip
+
+#endif

internal/c/parts/os/clipboard/clip/clip_osx.mm

@@ -0,0 +1,371 @@
+// Clip Library
+// Copyright (c) 2015-2023 David Capello
+//
+// This file is released under the terms of the MIT license.
+// Read LICENSE.txt for more information.
+
+#include "clip.h"
+#include "clip_common.h"
+#include "clip_lock_impl.h"
+
+#include <cassert>
+#include <vector>
+#include <map>
+
+#include <CoreFoundation/CoreFoundation.h>
+#include <Foundation/Foundation.h>
+#include <AppKit/AppKit.h>
+
+namespace clip {
+
+namespace {
+
+  format g_last_format = 100;
+  std::map<std::string, format> g_name_to_format;
+  std::map<format, std::string> g_format_to_name;
+
+#if CLIP_ENABLE_IMAGE
+
+  bool get_image_from_clipboard(image* output_img,
+                                image_spec* output_spec)
+  {
+    NSPasteboard* pasteboard = [NSPasteboard generalPasteboard];
+    NSString* result = [pasteboard availableTypeFromArray:
+                                [NSArray arrayWithObjects:NSPasteboardTypeTIFF,NSPasteboardTypePNG,nil]];
+
+    if (!result)
+      return false;
+
+    NSData* data = [pasteboard dataForType:result];
+    if (!data)
+      return false;
+
+    NSBitmapImageRep* bitmap = [NSBitmapImageRep imageRepWithData:data];
+
+    if ((bitmap.bitmapFormat & NSBitmapFormatFloatingPointSamples) ||
+        (bitmap.planar)) {
+      error_handler e = get_error_handler();
+      if (e)
+        e(ErrorCode::ImageNotSupported);
+      return false;
+    }
+
+    image_spec spec;
+    spec.width = bitmap.pixelsWide;
+    spec.height = bitmap.pixelsHigh;
+    spec.bits_per_pixel = bitmap.bitsPerPixel;
+    spec.bytes_per_row = bitmap.bytesPerRow;
+
+    // We need three samples for Red/Green/Blue
+    if (bitmap.samplesPerPixel >= 3) {
+      // Here we are guessing the bits per sample (generally 8, not
+      // sure how many bits per sample macOS uses for 16bpp
+      // NSBitmapFormat or if this format is even used).
+      int bits_per_sample = (bitmap.bitsPerPixel == 16 ? 5: 8);
+      int bits_shift = 0;
+
+      // With alpha
+      if (bitmap.alpha) {
+        if (bitmap.bitmapFormat & NSBitmapFormatAlphaFirst) {
+          spec.alpha_shift = 0;
+          bits_shift += bits_per_sample;
+        }
+        else {
+          spec.alpha_shift = 3*bits_per_sample;
+        }
+      }
+
+      unsigned long* masks = &spec.red_mask;
+      unsigned long* shifts = &spec.red_shift;
+
+      // Red/green/blue shifts
+      for (unsigned long* shift=shifts; shift<shifts+3; ++shift) {
+        *shift = bits_shift;
+        bits_shift += bits_per_sample;
+      }
+
+      // With alpha
+      if (bitmap.alpha) {
+        if (bitmap.bitmapFormat & NSBitmapFormatSixteenBitBigEndian ||
+            bitmap.bitmapFormat & NSBitmapFormatThirtyTwoBitBigEndian) {
+          std::swap(spec.red_shift, spec.alpha_shift);
+          std::swap(spec.green_shift, spec.blue_shift);
+        }
+      }
+      // Without alpha
+      else {
+        if (bitmap.bitmapFormat & NSBitmapFormatSixteenBitBigEndian ||
+            bitmap.bitmapFormat & NSBitmapFormatThirtyTwoBitBigEndian) {
+          std::swap(spec.red_shift, spec.blue_shift);
+        }
+      }
+
+      // Calculate all masks
+      for (unsigned long* shift=shifts, *mask=masks; shift<shifts+4; ++shift, ++mask)
+        *mask = ((1ul<<bits_per_sample)-1ul) << (*shift);
+
+      // Without alpha
+      if (!bitmap.alpha)
+        spec.alpha_mask = 0;
+    }
+
+    if (output_spec) {
+      *output_spec = spec;
+    }
+
+    if (output_img) {
+      unsigned long size = spec.bytes_per_row*spec.height;
+      image img(spec);
+
+      std::copy(bitmap.bitmapData,
+                bitmap.bitmapData+size, img.data());
+
+      // Convert premultiplied data to unpremultiplied if needed.
+      if (bitmap.alpha &&
+          bitmap.samplesPerPixel >= 3 &&
+          !(bitmap.bitmapFormat & NSBitmapFormatAlphaNonpremultiplied)) {
+        details::divide_rgb_by_alpha(
+          img,
+          true); // hasAlphaGreaterThanZero=true because we have valid alpha information
+      }
+
+      std::swap(*output_img, img);
+    }
+
+    return true;
+  }
+
+#endif // CLIP_ENABLE_IMAGE
+
+}
+
+lock::impl::impl(void*) : m_locked(true) {
+}
+
+lock::impl::~impl() {
+}
+
+bool lock::impl::clear() {
+  @autoreleasepool {
+    NSPasteboard* pasteboard = [NSPasteboard generalPasteboard];
+    [pasteboard clearContents];
+    return true;
+  }
+}
+
+bool lock::impl::is_convertible(format f) const {
+  @autoreleasepool {
+    NSPasteboard* pasteboard = [NSPasteboard generalPasteboard];
+    NSString* result = nil;
+
+    if (f == text_format()) {
+      result = [pasteboard availableTypeFromArray:[NSArray arrayWithObject:NSPasteboardTypeString]];
+    }
+#if CLIP_ENABLE_IMAGE
+    else if (f == image_format()) {
+      result = [pasteboard availableTypeFromArray:
+                        [NSArray arrayWithObjects:NSPasteboardTypeTIFF,NSPasteboardTypePNG,nil]];
+    }
+#endif // CLIP_ENABLE_IMAGE
+    else {
+      auto it = g_format_to_name.find(f);
+      if (it != g_format_to_name.end()) {
+        const std::string& name = it->second;
+        NSString* string = [[NSString alloc] initWithBytesNoCopy:(void*)name.c_str()
+                                                          length:name.size()
+                                                        encoding:NSUTF8StringEncoding
+                                                    freeWhenDone:NO];
+        result = [pasteboard availableTypeFromArray:[NSArray arrayWithObject:string]];
+      }
+    }
+
+    return (result ? true: false);
+  }
+}
+
+bool lock::impl::set_data(format f, const char* buf, size_t len) {
+  @autoreleasepool {
+    NSPasteboard* pasteboard = [NSPasteboard generalPasteboard];
+
+    if (f == text_format()) {
+      NSString* string = [[NSString alloc] initWithBytesNoCopy:(void*)buf
+                                                        length:len
+                                                      encoding:NSUTF8StringEncoding
+                                                  freeWhenDone:NO];
+      [pasteboard setString:string forType:NSPasteboardTypeString];
+      return true;
+    }
+    else {
+      auto it = g_format_to_name.find(f);
+      if (it != g_format_to_name.end()) {
+        const std::string& formatName = it->second;
+        NSString* typeString = [[NSString alloc]
+                                 initWithBytesNoCopy:(void*)formatName.c_str()
+                                              length:formatName.size()
+                                            encoding:NSUTF8StringEncoding
+                                        freeWhenDone:NO];
+        NSData* data = [NSData dataWithBytesNoCopy:(void*)buf
+                                            length:len
+                                      freeWhenDone:NO];
+
+        if ([pasteboard setData:data forType:typeString])
+          return true;
+      }
+    }
+    return false;
+  }
+}
+
+bool lock::impl::get_data(format f, char* buf, size_t len) const {
+  @autoreleasepool {
+    assert(buf);
+    if (!buf || !is_convertible(f))
+      return false;
+
+    NSPasteboard* pasteboard = [NSPasteboard generalPasteboard];
+
+    if (f == text_format()) {
+      NSString* string = [pasteboard stringForType:NSPasteboardTypeString];
+      int reqsize = [string lengthOfBytesUsingEncoding:NSUTF8StringEncoding]+1;
+
+      assert(reqsize <= len);
+      if (reqsize > len) {
+        // Buffer is too small
+        return false;
+      }
+
+      if (reqsize == 0)
+        return true;
+
+      memcpy(buf, [string UTF8String], reqsize);
+      return true;
+    }
+
+    auto it = g_format_to_name.find(f);
+    if (it == g_format_to_name.end())
+      return false;
+
+    const std::string& formatName = it->second;
+    NSString* typeString =
+      [[NSString alloc] initWithBytesNoCopy:(void*)formatName.c_str()
+                                     length:formatName.size()
+                                   encoding:NSUTF8StringEncoding
+                               freeWhenDone:NO];
+
+    NSData* data = [pasteboard dataForType:typeString];
+    if (!data)
+      return false;
+
+    [data getBytes:buf length:len];
+    return true;
+  }
+}
+
+size_t lock::impl::get_data_length(format f) const {
+  @autoreleasepool {
+    NSPasteboard* pasteboard = [NSPasteboard generalPasteboard];
+
+    if (f == text_format()) {
+      NSString* string = [pasteboard stringForType:NSPasteboardTypeString];
+      return [string lengthOfBytesUsingEncoding:NSUTF8StringEncoding]+1;
+    }
+
+    auto it = g_format_to_name.find(f);
+    if (it == g_format_to_name.end())
+      return 0;
+
+    const std::string& formatName = it->second;
+    NSString* typeString =
+      [[NSString alloc] initWithBytesNoCopy:(void*)formatName.c_str()
+                                     length:formatName.size()
+                                   encoding:NSUTF8StringEncoding
+                               freeWhenDone:NO];
+
+    NSData* data = [pasteboard dataForType:typeString];
+    if (!data)
+      return 0;
+
+    return data.length;
+  }
+}
+
+#if CLIP_ENABLE_IMAGE
+
+bool lock::impl::set_image(const image& image) {
+  @autoreleasepool {
+    NSPasteboard* pasteboard = [NSPasteboard generalPasteboard];
+    const image_spec& spec = image.spec();
+
+    NSBitmapFormat bitmapFormat = 0;
+    int samples_per_pixel = 0;
+    if (spec.alpha_mask) {
+      samples_per_pixel = 4;
+      if (spec.alpha_shift == 0)
+        bitmapFormat |= NSBitmapFormatAlphaFirst;
+      bitmapFormat |= NSBitmapFormatAlphaNonpremultiplied;
+    }
+    else if (spec.red_mask || spec.green_mask || spec.blue_mask) {
+      samples_per_pixel = 3;
+    }
+    else {
+      samples_per_pixel = 1;
+    }
+
+    if (spec.bits_per_pixel == 32)
+      bitmapFormat |= NSBitmapFormatThirtyTwoBitLittleEndian;
+    else if (spec.bits_per_pixel == 16)
+      bitmapFormat |= NSBitmapFormatSixteenBitLittleEndian;
+
+    std::vector<unsigned char*> planes(1);
+    planes[0] = (unsigned char*)image.data();
+
+    NSBitmapImageRep* bitmap =
+      [[NSBitmapImageRep alloc]
+        initWithBitmapDataPlanes:&planes[0]
+                      pixelsWide:spec.width
+                      pixelsHigh:spec.height
+                   bitsPerSample:spec.bits_per_pixel / samples_per_pixel
+                 samplesPerPixel:samples_per_pixel
+                        hasAlpha:(spec.alpha_mask ? YES: NO)
+                        isPlanar:NO
+                  colorSpaceName:NSDeviceRGBColorSpace
+                    bitmapFormat:bitmapFormat
+                     bytesPerRow:spec.bytes_per_row
+                    bitsPerPixel:spec.bits_per_pixel];
+    if (!bitmap)
+      return false;
+
+    NSData* data = bitmap.TIFFRepresentation;
+    if (!data)
+      return false;
+
+    if ([pasteboard setData:data forType:NSPasteboardTypeTIFF])
+      return true;
+
+    return false;
+  }
+}
+
+bool lock::impl::get_image(image& img) const {
+  return get_image_from_clipboard(&img, nullptr);
+}
+
+bool lock::impl::get_image_spec(image_spec& spec) const {
+  return get_image_from_clipboard(nullptr, &spec);
+}
+
+#endif // CLIP_ENABLE_IMAGE
+
+format register_format(const std::string& name) {
+  // Check if the format is already registered
+  auto it = g_name_to_format.find(name);
+  if (it != g_name_to_format.end())
+    return it->second;
+
+  format new_format = g_last_format++;
+  g_name_to_format[name] = new_format;
+  g_format_to_name[new_format] = name;
+  return new_format;
+}
+
+} // namespace clip

internal/c/parts/os/clipboard/clip/clip_win.cpp

@@ -0,0 +1,659 @@
+// Clip Library
+// Copyright (C) 2015-2020  David Capello
+//
+// This file is released under the terms of the MIT license.
+// Read LICENSE.txt for more information.
+
+#include "clip.h"
+#include "clip_common.h"
+#include "clip_lock_impl.h"
+
+#include <algorithm>
+#include <cstdlib>
+#include <cstring>
+#include <string>
+#include <vector>
+
+#include <windows.h>
+
+#if CLIP_ENABLE_IMAGE
+#include "clip_win_wic.h"
+#endif // CLIP_ENABLE_IMAGE
+
+#ifndef LCS_WINDOWS_COLOR_SPACE
+#define LCS_WINDOWS_COLOR_SPACE 'Win '
+#endif
+
+#ifndef CF_DIBV5
+#define CF_DIBV5            17
+#endif
+
+namespace clip {
+
+namespace {
+
+// Data type used as header for custom formats to indicate the exact
+// size of the user custom data. This is necessary because it looks
+// like GlobalSize() might not return the exact size, but a greater
+// value.
+typedef uint64_t CustomSizeT;
+
+unsigned long get_shift_from_mask(unsigned long mask) {
+  unsigned long shift = 0;
+  for (shift=0; shift<sizeof(unsigned long)*8; ++shift)
+    if (mask & (1 << shift))
+      return shift;
+  return shift;
+}
+
+class Hglobal {
+public:
+  Hglobal() : m_handle(nullptr) {
+  }
+
+  explicit Hglobal(HGLOBAL handle) : m_handle(handle) {
+  }
+
+  explicit Hglobal(size_t len) : m_handle(GlobalAlloc(GHND, len)) {
+  }
+
+  ~Hglobal() {
+    if (m_handle)
+      GlobalFree(m_handle);
+  }
+
+  void release() {
+    m_handle = nullptr;
+  }
+
+  operator HGLOBAL() {
+    return m_handle;
+  }
+
+private:
+  HGLOBAL m_handle;
+};
+
+#if CLIP_ENABLE_IMAGE
+
+struct BitmapInfo {
+  BITMAPV5HEADER* b5 = nullptr;
+  BITMAPINFO* bi = nullptr;
+  int width = 0;
+  int height = 0;
+  uint16_t bit_count = 0;
+  uint32_t compression = 0;
+  uint32_t red_mask = 0;
+  uint32_t green_mask = 0;
+  uint32_t blue_mask = 0;
+  uint32_t alpha_mask = 0;
+
+  BitmapInfo() {
+    // Use DIBV5 only for 32 bpp uncompressed bitmaps and when all
+    // masks are valid.
+    if (IsClipboardFormatAvailable(CF_DIBV5)) {
+      b5 = (BITMAPV5HEADER*)GetClipboardData(CF_DIBV5);
+      if (b5 &&
+          b5->bV5BitCount == 32 &&
+          ((b5->bV5Compression == BI_RGB) ||
+           (b5->bV5Compression == BI_BITFIELDS &&
+            b5->bV5RedMask && b5->bV5GreenMask &&
+            b5->bV5BlueMask && b5->bV5AlphaMask))) {
+        width       = b5->bV5Width;
+        height      = b5->bV5Height;
+        bit_count   = b5->bV5BitCount;
+        compression = b5->bV5Compression;
+        if (compression == BI_BITFIELDS) {
+          red_mask    = b5->bV5RedMask;
+          green_mask  = b5->bV5GreenMask;
+          blue_mask   = b5->bV5BlueMask;
+          alpha_mask  = b5->bV5AlphaMask;
+        }
+        else {
+          red_mask    = 0xff0000;
+          green_mask  = 0xff00;
+          blue_mask   = 0xff;
+          alpha_mask  = 0xff000000;
+        }
+        return;
+      }
+    }
+
+    if (IsClipboardFormatAvailable(CF_DIB))
+      bi = (BITMAPINFO*)GetClipboardData(CF_DIB);
+    if (!bi)
+      return;
+
+    width       = bi->bmiHeader.biWidth;
+    height      = bi->bmiHeader.biHeight;
+    bit_count   = bi->bmiHeader.biBitCount;
+    compression = bi->bmiHeader.biCompression;
+
+    if (compression == BI_BITFIELDS) {
+      red_mask   = *((uint32_t*)&bi->bmiColors[0]);
+      green_mask = *((uint32_t*)&bi->bmiColors[1]);
+      blue_mask  = *((uint32_t*)&bi->bmiColors[2]);
+      if (bit_count == 32)
+        alpha_mask = 0xff000000;
+    }
+    else if (compression == BI_RGB) {
+      switch (bit_count) {
+        case 32:
+          red_mask   = 0xff0000;
+          green_mask = 0xff00;
+          blue_mask  = 0xff;
+          alpha_mask = 0xff000000;
+          break;
+        case 24:
+        case 8: // We return 8bpp images as 24bpp
+          red_mask   = 0xff0000;
+          green_mask = 0xff00;
+          blue_mask  = 0xff;
+          break;
+        case 16:
+          red_mask   = 0x7c00;
+          green_mask = 0x03e0;
+          blue_mask  = 0x001f;
+          break;
+      }
+    }
+  }
+
+  bool is_valid() const {
+    return (b5 || bi);
+  }
+
+  void fill_spec(image_spec& spec) {
+    spec.width = width;
+    spec.height = (height >= 0 ? height: -height);
+    // We convert indexed to 24bpp RGB images to match the OS X behavior
+    spec.bits_per_pixel = bit_count;
+    if (spec.bits_per_pixel <= 8)
+      spec.bits_per_pixel = 24;
+    spec.bytes_per_row = width*((spec.bits_per_pixel+7)/8);
+    spec.red_mask   = red_mask;
+    spec.green_mask = green_mask;
+    spec.blue_mask  = blue_mask;
+    spec.alpha_mask = alpha_mask;
+
+    switch (spec.bits_per_pixel) {
+
+      case 24: {
+        // We need one extra byte to avoid a crash updating the last
+        // pixel on last row using:
+        //
+        //   *((uint32_t*)ptr) = pixel24bpp;
+        //
+        ++spec.bytes_per_row;
+
+        // Align each row to 32bpp
+        int padding = (4-(spec.bytes_per_row&3))&3;
+        spec.bytes_per_row += padding;
+        break;
+      }
+
+      case 16: {
+        int padding = (4-(spec.bytes_per_row&3))&3;
+        spec.bytes_per_row += padding;
+        break;
+      }
+    }
+
+    unsigned long* masks = &spec.red_mask;
+    unsigned long* shifts = &spec.red_shift;
+    for (unsigned long* shift=shifts, *mask=masks; shift<shifts+4; ++shift, ++mask) {
+      if (*mask)
+        *shift = get_shift_from_mask(*mask);
+    }
+  }
+
+};
+
+#endif // CLIP_ENABLE_IMAGE
+
+}
+
+lock::impl::impl(void* hwnd) : m_locked(false) {
+  for (int i=0; i<5; ++i) {
+    if (OpenClipboard((HWND)hwnd)) {
+      m_locked = true;
+      break;
+    }
+    Sleep(20);
+  }
+
+  if (!m_locked) {
+    error_handler e = get_error_handler();
+    if (e)
+      e(ErrorCode::CannotLock);
+  }
+}
+
+lock::impl::~impl() {
+  if (m_locked)
+    CloseClipboard();
+}
+
+bool lock::impl::clear() {
+  return (EmptyClipboard() ? true: false);
+}
+
+bool lock::impl::is_convertible(format f) const {
+  if (f == text_format()) {
+    return
+      (IsClipboardFormatAvailable(CF_TEXT) ||
+       IsClipboardFormatAvailable(CF_UNICODETEXT) ||
+       IsClipboardFormatAvailable(CF_OEMTEXT));
+  }
+#if CLIP_ENABLE_IMAGE
+  else if (f == image_format()) {
+    return (IsClipboardFormatAvailable(CF_DIB) ? true: false);
+  }
+#endif // CLIP_ENABLE_IMAGE
+  else if (IsClipboardFormatAvailable(f))
+    return true;
+  else
+    return false;
+}
+
+bool lock::impl::set_data(format f, const char* buf, size_t len) {
+  bool result = false;
+
+  if (f == text_format()) {
+    if (len > 0) {
+      int reqsize = MultiByteToWideChar(CP_UTF8, 0, buf, len, NULL, 0);
+      if (reqsize > 0) {
+        ++reqsize;
+
+        Hglobal hglobal(sizeof(WCHAR)*reqsize);
+        LPWSTR lpstr = static_cast<LPWSTR>(GlobalLock(hglobal));
+        MultiByteToWideChar(CP_UTF8, 0, buf, len, lpstr, reqsize);
+        GlobalUnlock(hglobal);
+
+        result = (SetClipboardData(CF_UNICODETEXT, hglobal)) ? true: false;
+        if (result)
+          hglobal.release();
+      }
+    }
+  }
+  else {
+    Hglobal hglobal(len+sizeof(CustomSizeT));
+    if (hglobal) {
+      auto dst = (uint8_t*)GlobalLock(hglobal);
+      if (dst) {
+        *((CustomSizeT*)dst) = len;
+        memcpy(dst+sizeof(CustomSizeT), buf, len);
+        GlobalUnlock(hglobal);
+        result = (SetClipboardData(f, hglobal) ? true: false);
+        if (result)
+          hglobal.release();
+      }
+    }
+  }
+
+  return result;
+}
+
+bool lock::impl::get_data(format f, char* buf, size_t len) const {
+  assert(buf);
+
+  if (!buf || !is_convertible(f))
+    return false;
+
+  bool result = false;
+
+  if (f == text_format()) {
+    if (IsClipboardFormatAvailable(CF_UNICODETEXT)) {
+      HGLOBAL hglobal = GetClipboardData(CF_UNICODETEXT);
+      if (hglobal) {
+        LPWSTR lpstr = static_cast<LPWSTR>(GlobalLock(hglobal));
+        if (lpstr) {
+          size_t reqsize =
+            WideCharToMultiByte(CP_UTF8, 0, lpstr, -1,
+                                nullptr, 0, nullptr, nullptr);
+
+          assert(reqsize <= len);
+          if (reqsize <= len) {
+            WideCharToMultiByte(CP_UTF8, 0, lpstr, -1,
+                                buf, reqsize, nullptr, nullptr);
+            result = true;
+          }
+          GlobalUnlock(hglobal);
+        }
+      }
+    }
+    else if (IsClipboardFormatAvailable(CF_TEXT)) {
+      HGLOBAL hglobal = GetClipboardData(CF_TEXT);
+      if (hglobal) {
+        LPSTR lpstr = static_cast<LPSTR>(GlobalLock(hglobal));
+        if (lpstr) {
+          // TODO check length
+          memcpy(buf, lpstr, len);
+          result = true;
+          GlobalUnlock(hglobal);
+        }
+      }
+    }
+  }
+  else {
+    if (IsClipboardFormatAvailable(f)) {
+      HGLOBAL hglobal = GetClipboardData(f);
+      if (hglobal) {
+        const SIZE_T total_size = GlobalSize(hglobal);
+        auto ptr = (const uint8_t*)GlobalLock(hglobal);
+        if (ptr) {
+          CustomSizeT reqsize = *((CustomSizeT*)ptr);
+
+          // If the registered length of data in the first CustomSizeT
+          // number of bytes of the hglobal data is greater than the
+          // GlobalSize(hglobal), something is wrong, it should not
+          // happen.
+          assert(reqsize <= total_size);
+          if (reqsize > total_size)
+            reqsize = total_size - sizeof(CustomSizeT);
+
+          if (reqsize <= len) {
+            memcpy(buf, ptr+sizeof(CustomSizeT), reqsize);
+            result = true;
+          }
+          GlobalUnlock(hglobal);
+        }
+      }
+    }
+  }
+
+  return result;
+}
+
+size_t lock::impl::get_data_length(format f) const {
+  size_t len = 0;
+
+  if (f == text_format()) {
+    if (IsClipboardFormatAvailable(CF_UNICODETEXT)) {
+      HGLOBAL hglobal = GetClipboardData(CF_UNICODETEXT);
+      if (hglobal) {
+        LPWSTR lpstr = static_cast<LPWSTR>(GlobalLock(hglobal));
+        if (lpstr) {
+          len =
+            WideCharToMultiByte(CP_UTF8, 0, lpstr, -1,
+                                nullptr, 0, nullptr, nullptr);
+          GlobalUnlock(hglobal);
+        }
+      }
+    }
+    else if (IsClipboardFormatAvailable(CF_TEXT)) {
+      HGLOBAL hglobal = GetClipboardData(CF_TEXT);
+      if (hglobal) {
+        LPSTR lpstr = (LPSTR)GlobalLock(hglobal);
+        if (lpstr) {
+          len = strlen(lpstr) + 1;
+          GlobalUnlock(hglobal);
+        }
+      }
+    }
+  }
+  else if (f != empty_format()) {
+    if (IsClipboardFormatAvailable(f)) {
+      HGLOBAL hglobal = GetClipboardData(f);
+      if (hglobal) {
+        const SIZE_T total_size = GlobalSize(hglobal);
+        auto ptr = (const uint8_t*)GlobalLock(hglobal);
+        if (ptr) {
+          len = *((CustomSizeT*)ptr);
+
+          assert(len <= total_size);
+          if (len > total_size)
+            len = total_size - sizeof(CustomSizeT);
+
+          GlobalUnlock(hglobal);
+        }
+      }
+    }
+  }
+
+  return len;
+}
+
+#if CLIP_ENABLE_IMAGE
+
+bool lock::impl::set_image(const image& image) {
+  const image_spec& spec = image.spec();
+
+  // Add the PNG clipboard format for images with alpha channel
+  // (useful to communicate with some Windows programs that only use
+  // alpha data from PNG clipboard format)
+  if (spec.bits_per_pixel == 32 &&
+      spec.alpha_mask) {
+    UINT png_format = RegisterClipboardFormatA("PNG");
+    if (png_format) {
+      Hglobal png_handle(win::write_png(image));
+      if (png_handle)
+        SetClipboardData(png_format, png_handle);
+    }
+  }
+
+  image_spec out_spec = spec;
+
+  int palette_colors = 0;
+  int padding = 0;
+  switch (spec.bits_per_pixel) {
+    case 24: padding = (4-((spec.width*3)&3))&3; break;
+    case 16: padding = ((4-((spec.width*2)&3))&3)/2; break;
+    case 8:  padding = (4-(spec.width&3))&3; break;
+  }
+  out_spec.bytes_per_row += padding;
+
+  // Create the BITMAPV5HEADER structure
+  Hglobal hmem(
+    GlobalAlloc(
+      GHND,
+      sizeof(BITMAPV5HEADER)
+      + palette_colors*sizeof(RGBQUAD)
+      + out_spec.bytes_per_row*out_spec.height));
+  if (!hmem)
+    return false;
+
+  out_spec.red_mask    = 0x00ff0000;
+  out_spec.green_mask  = 0xff00;
+  out_spec.blue_mask   = 0xff;
+  out_spec.alpha_mask  = 0xff000000;
+  out_spec.red_shift   = 16;
+  out_spec.green_shift = 8;
+  out_spec.blue_shift  = 0;
+  out_spec.alpha_shift = 24;
+
+  BITMAPV5HEADER* bi = (BITMAPV5HEADER*)GlobalLock(hmem);
+  bi->bV5Size = sizeof(BITMAPV5HEADER);
+  bi->bV5Width = out_spec.width;
+  bi->bV5Height = out_spec.height;
+  bi->bV5Planes = 1;
+  bi->bV5BitCount = (WORD)out_spec.bits_per_pixel;
+  bi->bV5Compression = BI_RGB;
+  bi->bV5SizeImage = out_spec.bytes_per_row*spec.height;
+  bi->bV5RedMask   = out_spec.red_mask;
+  bi->bV5GreenMask = out_spec.green_mask;
+  bi->bV5BlueMask  = out_spec.blue_mask;
+  bi->bV5AlphaMask = out_spec.alpha_mask;
+  bi->bV5CSType = LCS_WINDOWS_COLOR_SPACE;
+  bi->bV5Intent = LCS_GM_GRAPHICS;
+  bi->bV5ClrUsed = 0;
+
+  switch (spec.bits_per_pixel) {
+    case 32: {
+      const char* src = image.data();
+      char* dst = (((char*)bi)+bi->bV5Size) + (out_spec.height-1)*out_spec.bytes_per_row;
+      for (long y=spec.height-1; y>=0; --y) {
+        const uint32_t* src_x = (const uint32_t*)src;
+        uint32_t* dst_x = (uint32_t*)dst;
+
+        for (unsigned long x=0; x<spec.width; ++x, ++src_x, ++dst_x) {
+          uint32_t c = *src_x;
+          int r = ((c & spec.red_mask  ) >> spec.red_shift  );
+          int g = ((c & spec.green_mask) >> spec.green_shift);
+          int b = ((c & spec.blue_mask ) >> spec.blue_shift );
+          int a = ((c & spec.alpha_mask) >> spec.alpha_shift);
+
+          // Windows requires premultiplied RGBA values
+          r = r * a / 255;
+          g = g * a / 255;
+          b = b * a / 255;
+
+          *dst_x =
+            (r << out_spec.red_shift  ) |
+            (g << out_spec.green_shift) |
+            (b << out_spec.blue_shift ) |
+            (a << out_spec.alpha_shift);
+        }
+
+        src += spec.bytes_per_row;
+        dst -= out_spec.bytes_per_row;
+      }
+      break;
+    }
+    default:
+      error_handler e = get_error_handler();
+      if (e)
+        e(ErrorCode::ImageNotSupported);
+      return false;
+  }
+
+  GlobalUnlock(hmem);
+  SetClipboardData(CF_DIBV5, hmem);
+  return true;
+}
+
+bool lock::impl::get_image(image& output_img) const {
+  // Get the "PNG" clipboard format (this is useful only for 32bpp
+  // images with alpha channel, in other case we can use the regular
+  // DIB format)
+  UINT png_format = RegisterClipboardFormatA("PNG");
+  if (png_format && IsClipboardFormatAvailable(png_format)) {
+    HANDLE png_handle = GetClipboardData(png_format);
+    if (png_handle) {
+      size_t png_size = GlobalSize(png_handle);
+      uint8_t* png_data = (uint8_t*)GlobalLock(png_handle);
+      bool result = win::read_png(png_data, png_size, &output_img, nullptr);
+      GlobalUnlock(png_handle);
+      if (result)
+        return true;
+    }
+  }
+
+  BitmapInfo bi;
+  if (!bi.is_valid()) {
+    // There is no image at all in the clipboard, no need to report
+    // this as an error, just return false.
+    return false;
+  }
+
+  image_spec spec;
+  bi.fill_spec(spec);
+  image img(spec);
+
+  switch (bi.bit_count) {
+
+    case 32:
+    case 24:
+    case 16: {
+      const uint8_t* src = nullptr;
+
+      if (bi.compression == BI_RGB ||
+          bi.compression == BI_BITFIELDS) {
+        if (bi.b5)
+          src = ((uint8_t*)bi.b5) + bi.b5->bV5Size;
+        else
+          src = ((uint8_t*)bi.bi) + bi.bi->bmiHeader.biSize;
+        if (bi.compression == BI_BITFIELDS)
+          src += sizeof(RGBQUAD)*3;
+      }
+
+      if (src) {
+        const int src_bytes_per_row = spec.width*((bi.bit_count+7)/8);
+        const int padding = (4-(src_bytes_per_row&3))&3;
+
+        for (long y=spec.height-1; y>=0; --y, src+=src_bytes_per_row+padding) {
+          char* dst = img.data()+y*spec.bytes_per_row;
+          std::copy(src, src+src_bytes_per_row, dst);
+        }
+      }
+
+      // Windows uses premultiplied RGB values, and we use straight
+      // alpha. So we have to divide all RGB values by its alpha.
+      if (bi.bit_count == 32 && spec.alpha_mask) {
+        details::divide_rgb_by_alpha(img);
+      }
+      break;
+    }
+
+    case 8: {
+      assert(bi.bi);
+
+      const int colors = (bi.bi->bmiHeader.biClrUsed > 0 ? bi.bi->bmiHeader.biClrUsed: 256);
+      std::vector<uint32_t> palette(colors);
+      for (int c=0; c<colors; ++c) {
+        palette[c] =
+          (bi.bi->bmiColors[c].rgbRed   << spec.red_shift) |
+          (bi.bi->bmiColors[c].rgbGreen << spec.green_shift) |
+          (bi.bi->bmiColors[c].rgbBlue  << spec.blue_shift);
+      }
+
+      const uint8_t* src = (((uint8_t*)bi.bi) + bi.bi->bmiHeader.biSize + sizeof(RGBQUAD)*colors);
+      const int padding = (4-(spec.width&3))&3;
+
+      for (long y=spec.height-1; y>=0; --y, src+=padding) {
+        char* dst = img.data()+y*spec.bytes_per_row;
+
+        for (unsigned long x=0; x<spec.width; ++x, ++src, dst+=3) {
+          int idx = *src;
+          if (idx < 0)
+            idx = 0;
+          else if (idx >= colors)
+            idx = colors-1;
+
+          *((uint32_t*)dst) = palette[idx];
+        }
+      }
+      break;
+    }
+  }
+
+  std::swap(output_img, img);
+  return true;
+}
+
+bool lock::impl::get_image_spec(image_spec& spec) const {
+  UINT png_format = RegisterClipboardFormatA("PNG");
+  if (png_format && IsClipboardFormatAvailable(png_format)) {
+    HANDLE png_handle = GetClipboardData(png_format);
+    if (png_handle) {
+      size_t png_size = GlobalSize(png_handle);
+      uint8_t* png_data = (uint8_t*)GlobalLock(png_handle);
+      bool result = win::read_png(png_data, png_size, nullptr, &spec);
+      GlobalUnlock(png_handle);
+      if (result)
+        return true;
+    }
+  }
+
+  BitmapInfo bi;
+  if (!bi.is_valid())
+    return false;
+  bi.fill_spec(spec);
+  return true;
+}
+
+#endif // CLIP_ENABLE_IMAGE
+
+format register_format(const std::string& name) {
+  int reqsize = 1+MultiByteToWideChar(CP_UTF8, 0,
+                                      name.c_str(), name.size(), NULL, 0);
+  std::vector<WCHAR> buf(reqsize);
+  MultiByteToWideChar(CP_UTF8, 0, name.c_str(), name.size(),
+                      &buf[0], reqsize);
+
+  // From MSDN, registered clipboard formats are identified by values
+  // in the range 0xC000 through 0xFFFF.
+  return (format)RegisterClipboardFormatW(&buf[0]);
+}
+
+} // namespace clip

internal/c/parts/os/clipboard/clip/clip_win_wic.h

@@ -0,0 +1,286 @@
+// Clip Library
+// Copyright (c) 2020-2022 David Capello
+//
+// This file is released under the terms of the MIT license.
+// Read LICENSE.txt for more information.
+
+#include "clip.h"
+
+#include <algorithm>
+#include <vector>
+
+#include <shlwapi.h>
+#include <wincodec.h>
+
+namespace clip {
+namespace win {
+
+// Successful calls to CoInitialize() (S_OK or S_FALSE) must match
+// the calls to CoUninitialize().
+// From: https://docs.microsoft.com/en-us/windows/win32/api/combaseapi/nf-combaseapi-couninitialize#remarks
+struct coinit {
+  HRESULT hr;
+  coinit() {
+    hr = CoInitialize(nullptr);
+  }
+  ~coinit() {
+    if (hr == S_OK || hr == S_FALSE)
+      CoUninitialize();
+  }
+};
+
+template<class T>
+class comptr {
+public:
+  comptr() { }
+  explicit comptr(T* ptr) : m_ptr(ptr) { }
+  comptr(const comptr&) = delete;
+  comptr& operator=(const comptr&) = delete;
+  ~comptr() { reset(); }
+
+  T** operator&() { return &m_ptr; }
+  T* operator->() { return m_ptr; }
+  bool operator!() const { return !m_ptr; }
+
+  T* get() { return m_ptr; }
+  void reset() {
+    if (m_ptr) {
+      m_ptr->Release();
+      m_ptr = nullptr;
+    }
+  }
+private:
+  T* m_ptr = nullptr;
+};
+
+#ifdef CLIP_SUPPORT_WINXP
+class hmodule {
+public:
+  hmodule(LPCWSTR name) : m_ptr(LoadLibraryW(name)) { }
+  hmodule(const hmodule&) = delete;
+  hmodule& operator=(const hmodule&) = delete;
+  ~hmodule() {
+    if (m_ptr)
+      FreeLibrary(m_ptr);
+  }
+
+  operator HMODULE() { return m_ptr; }
+  bool operator!() const { return !m_ptr; }
+private:
+  HMODULE m_ptr = nullptr;
+};
+#endif
+
+//////////////////////////////////////////////////////////////////////
+// Encode the image as PNG format
+
+bool write_png_on_stream(const image& image,
+                         IStream* stream) {
+  const image_spec& spec = image.spec();
+
+  comptr<IWICBitmapEncoder> encoder;
+  HRESULT hr = CoCreateInstance(CLSID_WICPngEncoder,
+                                nullptr, CLSCTX_INPROC_SERVER,
+                                IID_PPV_ARGS(&encoder));
+  if (FAILED(hr))
+    return false;
+
+  hr = encoder->Initialize(stream, WICBitmapEncoderNoCache);
+  if (FAILED(hr))
+    return false;
+
+  comptr<IWICBitmapFrameEncode> frame;
+  comptr<IPropertyBag2> options;
+  hr = encoder->CreateNewFrame(&frame, &options);
+  if (FAILED(hr))
+    return false;
+
+  hr = frame->Initialize(options.get());
+  if (FAILED(hr))
+    return false;
+
+  // PNG encoder (and decoder) only supports GUID_WICPixelFormat32bppBGRA for 32bpp.
+  // See: https://docs.microsoft.com/en-us/windows/win32/wic/-wic-codec-native-pixel-formats#png-native-codec
+  WICPixelFormatGUID pixelFormat = GUID_WICPixelFormat32bppBGRA;
+  hr = frame->SetPixelFormat(&pixelFormat);
+  if (FAILED(hr))
+    return false;
+
+  hr = frame->SetSize(spec.width, spec.height);
+  if (FAILED(hr))
+    return false;
+
+  std::vector<uint32_t> buf;
+  uint8_t* ptr = (uint8_t*)image.data();
+  int bytes_per_row = spec.bytes_per_row;
+
+  // Convert to GUID_WICPixelFormat32bppBGRA if needed
+  if (spec.red_mask != 0xff0000 ||
+      spec.green_mask != 0xff00 ||
+      spec.blue_mask != 0xff ||
+      spec.alpha_mask != 0xff000000) {
+    buf.resize(spec.width * spec.height);
+    uint32_t* dst = (uint32_t*)&buf[0];
+    uint32_t* src = (uint32_t*)image.data();
+    for (int y=0; y<spec.height; ++y) {
+      auto src_line_start = src;
+      for (int x=0; x<spec.width; ++x) {
+        uint32_t c = *src;
+        *dst = ((((c & spec.red_mask  ) >> spec.red_shift  ) << 16) |
+                (((c & spec.green_mask) >> spec.green_shift) <<  8) |
+                (((c & spec.blue_mask ) >> spec.blue_shift )      ) |
+                (((c & spec.alpha_mask) >> spec.alpha_shift) << 24));
+        ++dst;
+        ++src;
+      }
+      src = (uint32_t*)(((uint8_t*)src_line_start) + spec.bytes_per_row);
+    }
+    ptr = (uint8_t*)&buf[0];
+    bytes_per_row = 4 * spec.width;
+  }
+
+  hr = frame->WritePixels(spec.height,
+                          bytes_per_row,
+                          bytes_per_row * spec.height,
+                          (BYTE*)ptr);
+  if (FAILED(hr))
+    return false;
+
+  hr = frame->Commit();
+  if (FAILED(hr))
+    return false;
+
+  hr = encoder->Commit();
+  if (FAILED(hr))
+    return false;
+
+  return true;
+}
+
+HGLOBAL write_png(const image& image) {
+  coinit com;
+
+  comptr<IStream> stream;
+  HRESULT hr = CreateStreamOnHGlobal(nullptr, false, &stream);
+  if (FAILED(hr))
+    return nullptr;
+
+  bool result = write_png_on_stream(image, stream.get());
+
+  HGLOBAL handle;
+  hr = GetHGlobalFromStream(stream.get(), &handle);
+  if (result)
+    return handle;
+
+  GlobalFree(handle);
+  return nullptr;
+}
+
+//////////////////////////////////////////////////////////////////////
+// Decode the clipboard data from PNG format
+
+bool read_png(const uint8_t* buf,
+              const UINT len,
+              image* output_image,
+              image_spec* output_spec) {
+  coinit com;
+
+#ifdef CLIP_SUPPORT_WINXP
+  // Pull SHCreateMemStream from shlwapi.dll by ordinal 12
+  // for Windows XP support
+  // From: https://learn.microsoft.com/en-us/windows/win32/api/shlwapi/nf-shlwapi-shcreatememstream#remarks
+
+  typedef IStream* (WINAPI* SHCreateMemStreamPtr)(const BYTE* pInit, UINT cbInit);
+  hmodule shlwapiDll(L"shlwapi.dll");
+  if (!shlwapiDll)
+    return false;
+
+  auto SHCreateMemStream =
+    reinterpret_cast<SHCreateMemStreamPtr>(GetProcAddress(shlwapiDll, (LPCSTR)12));
+  if (!SHCreateMemStream)
+    return false;
+#endif
+
+  comptr<IStream> stream(SHCreateMemStream(buf, len));
+
+  if (!stream)
+    return false;
+
+  comptr<IWICBitmapDecoder> decoder;
+  HRESULT hr = CoCreateInstance(CLSID_WICPngDecoder2,
+                                nullptr, CLSCTX_INPROC_SERVER,
+                                IID_PPV_ARGS(&decoder));
+  if (FAILED(hr)) {
+    hr = CoCreateInstance(CLSID_WICPngDecoder1,
+                          nullptr, CLSCTX_INPROC_SERVER,
+                          IID_PPV_ARGS(&decoder));
+    if (FAILED(hr))
+      return false;
+  }
+
+  // Can decoder be nullptr if hr is S_OK/successful? We've received
+  // some crash reports that might indicate this.
+  if (!decoder)
+    return false;
+
+  hr = decoder->Initialize(stream.get(), WICDecodeMetadataCacheOnDemand);
+  if (FAILED(hr))
+    return false;
+
+  comptr<IWICBitmapFrameDecode> frame;
+  hr = decoder->GetFrame(0, &frame);
+  if (FAILED(hr))
+    return false;
+
+  WICPixelFormatGUID pixelFormat;
+  hr = frame->GetPixelFormat(&pixelFormat);
+  if (FAILED(hr))
+    return false;
+
+  // Only support this pixel format
+  // TODO add support for more pixel formats
+  if (pixelFormat != GUID_WICPixelFormat32bppBGRA)
+    return false;
+
+  UINT width = 0, height = 0;
+  hr = frame->GetSize(&width, &height);
+  if (FAILED(hr))
+    return false;
+
+  image_spec spec;
+  spec.width = width;
+  spec.height = height;
+  spec.bits_per_pixel = 32;
+  spec.bytes_per_row = 4 * width;
+  spec.red_mask    = 0xff0000;
+  spec.green_mask  = 0xff00;
+  spec.blue_mask   = 0xff;
+  spec.alpha_mask  = 0xff000000;
+  spec.red_shift   = 16;
+  spec.green_shift = 8;
+  spec.blue_shift  = 0;
+  spec.alpha_shift = 24;
+
+  if (output_spec)
+    *output_spec = spec;
+
+  if (output_image) {
+    image img(spec);
+
+    hr = frame->CopyPixels(
+      nullptr, // Entire bitmap
+      spec.bytes_per_row,
+      spec.bytes_per_row * spec.height,
+      (BYTE*)img.data());
+    if (FAILED(hr)) {
+      return false;
+    }
+
+    std::swap(*output_image, img);
+  }
+
+  return true;
+}
+
+} // namespace win
+} // namespace clip

internal/c/parts/os/clipboard/clip/clip_x11_png.h

@@ -0,0 +1,230 @@
+// Clip Library
+// Copyright (c) 2018-2021 David Capello
+//
+// This file is released under the terms of the MIT license.
+// Read LICENSE.txt for more information.
+
+#include "clip.h"
+
+#include <algorithm>
+#include <vector>
+
+#include "png.h"
+
+namespace clip {
+namespace x11 {
+
+//////////////////////////////////////////////////////////////////////
+// Functions to convert clip::image into png data to store it in the
+// clipboard.
+
+void write_data_fn(png_structp png, png_bytep buf, png_size_t len) {
+  std::vector<uint8_t>& output = *(std::vector<uint8_t>*)png_get_io_ptr(png);
+  const size_t i = output.size();
+  output.resize(i+len);
+  std::copy(buf, buf+len, output.begin()+i);
+}
+
+bool write_png(const image& image,
+               std::vector<uint8_t>& output) {
+  png_structp png = png_create_write_struct(PNG_LIBPNG_VER_STRING,
+                                            nullptr, nullptr, nullptr);
+  if (!png)
+    return false;
+
+  png_infop info = png_create_info_struct(png);
+  if (!info) {
+    png_destroy_write_struct(&png, nullptr);
+    return false;
+  }
+
+  if (setjmp(png_jmpbuf(png))) {
+    png_destroy_write_struct(&png, &info);
+    return false;
+  }
+
+  png_set_write_fn(png,
+                   (png_voidp)&output,
+                   write_data_fn,
+                   nullptr);    // No need for a flush function
+
+  const image_spec& spec = image.spec();
+  int color_type = (spec.alpha_mask ?
+                    PNG_COLOR_TYPE_RGB_ALPHA:
+                    PNG_COLOR_TYPE_RGB);
+
+  png_set_IHDR(png, info,
+               spec.width, spec.height, 8, color_type,
+               PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
+  png_write_info(png, info);
+  png_set_packing(png);
+
+  png_bytep row =
+    (png_bytep)png_malloc(png, png_get_rowbytes(png, info));
+
+  for (png_uint_32 y=0; y<spec.height; ++y) {
+    const uint32_t* src =
+      (const uint32_t*)(((const uint8_t*)image.data())
+                        + y*spec.bytes_per_row);
+    uint8_t* dst = row;
+    unsigned int x, c;
+
+    for (x=0; x<spec.width; x++) {
+      c = *(src++);
+      *(dst++) = (c & spec.red_mask  ) >> spec.red_shift;
+      *(dst++) = (c & spec.green_mask) >> spec.green_shift;
+      *(dst++) = (c & spec.blue_mask ) >> spec.blue_shift;
+      if (color_type == PNG_COLOR_TYPE_RGB_ALPHA)
+        *(dst++) = (c & spec.alpha_mask) >> spec.alpha_shift;
+    }
+
+    png_write_rows(png, &row, 1);
+  }
+
+  png_free(png, row);
+  png_write_end(png, info);
+  png_destroy_write_struct(&png, &info);
+  return true;
+}
+
+//////////////////////////////////////////////////////////////////////
+// Functions to convert png data stored in the clipboard to a
+// clip::image.
+
+struct read_png_io {
+  const uint8_t* buf;
+  size_t len;
+  size_t pos;
+};
+
+void read_data_fn(png_structp png, png_bytep buf, png_size_t len) {
+  read_png_io& io = *(read_png_io*)png_get_io_ptr(png);
+  if (io.pos < io.len) {
+    size_t n = std::min(len, io.len-io.pos);
+    if (n > 0) {
+      std::copy(io.buf+io.pos,
+                io.buf+io.pos+n,
+                buf);
+      io.pos += n;
+    }
+  }
+}
+
+bool read_png(const uint8_t* buf,
+              const size_t len,
+              image* output_image,
+              image_spec* output_spec) {
+  png_structp png = png_create_read_struct(PNG_LIBPNG_VER_STRING,
+                                           nullptr, nullptr, nullptr);
+  if (!png)
+    return false;
+
+  png_infop info = png_create_info_struct(png);
+  if (!info) {
+    png_destroy_read_struct(&png, nullptr, nullptr);
+    return false;
+  }
+
+  if (setjmp(png_jmpbuf(png))) {
+    png_destroy_read_struct(&png, &info, nullptr);
+    return false;
+  }
+
+  read_png_io io = { buf, len, 0 };
+  png_set_read_fn(png, (png_voidp)&io, read_data_fn);
+
+  png_read_info(png, info);
+
+  png_uint_32 width, height;
+  int bit_depth, color_type, interlace_type;
+  png_get_IHDR(png, info, &width, &height,
+               &bit_depth, &color_type,
+               &interlace_type,
+               nullptr, nullptr);
+
+  image_spec spec;
+  spec.width = width;
+  spec.height = height;
+  spec.bits_per_pixel = 32;
+
+  // Don't use png_get_rowbytes(png, info) here because this is the
+  // bytes_per_row of the output clip::image (the png file could
+  // contain 24bpp but we want to return a 32bpp anyway with alpha=255
+  // in that case).
+  spec.bytes_per_row = 4*width;
+
+  spec.red_mask    = 0x000000ff;
+  spec.green_mask  = 0x0000ff00;
+  spec.blue_mask   = 0x00ff0000;
+  spec.red_shift   = 0;
+  spec.green_shift = 8;
+  spec.blue_shift  = 16;
+
+  if ((color_type & PNG_COLOR_MASK_ALPHA) == PNG_COLOR_MASK_ALPHA) {
+    spec.alpha_mask = 0xff000000;
+    spec.alpha_shift = 24;
+  }
+  else {
+    spec.alpha_mask = 0;
+    spec.alpha_shift = 0;
+  }
+
+  if (output_spec)
+    *output_spec = spec;
+
+  if (output_image &&
+      width > 0 &&
+      height > 0) {
+    image img(spec);
+
+    // We want RGB 24-bit or RGBA 32-bit as a result
+    png_set_strip_16(png); // Down to 8-bit (TODO we might support 16-bit values)
+    png_set_packing(png);  // Use one byte if color depth < 8-bit
+    png_set_expand_gray_1_2_4_to_8(png);
+    png_set_palette_to_rgb(png);
+    png_set_gray_to_rgb(png);
+    png_set_tRNS_to_alpha(png);
+
+    int number_passes = png_set_interlace_handling(png);
+    png_read_update_info(png, info);
+
+    const int src_bytes_per_row = png_get_rowbytes(png, info);
+    png_bytepp rows = (png_bytepp)png_malloc(png, sizeof(png_bytep)*height);
+    png_uint_32 y;
+    for (y=0; y<height; ++y)
+      rows[y] = (png_bytep)png_malloc(png, src_bytes_per_row);
+
+    for (int pass=0; pass<number_passes; ++pass)
+      for (y=0; y<height; ++y)
+        png_read_rows(png, rows+y, nullptr, 1);
+
+    for (y=0; y<height; ++y) {
+      const uint8_t* src = rows[y];
+      uint32_t* dst = (uint32_t*)(img.data() + y*spec.bytes_per_row);
+      unsigned int x, r, g, b, a = 0;
+
+      for (x=0; x<width; x++) {
+        r = *(src++);
+        g = *(src++);
+        b = *(src++);
+        if (spec.alpha_mask)
+          a = *(src++);
+        *(dst++) =
+          (r << spec.red_shift) |
+          (g << spec.green_shift) |
+          (b << spec.blue_shift) |
+          (a << spec.alpha_shift);
+      }
+      png_free(png, rows[y]);
+    }
+    png_free(png, rows);
+
+    std::swap(*output_image, img);
+  }
+
+  png_destroy_read_struct(&png, &info, nullptr);
+  return true;
+}
+
+} // namespace x11
+} // namespace clip

internal/c/parts/os/clipboard/clip/image.cpp

@@ -0,0 +1,99 @@
+// Clip Library
+// Copyright (c) 2015-2022 David Capello
+//
+// This file is released under the terms of the MIT license.
+// Read LICENSE.txt for more information.
+
+#include "clip.h"
+
+namespace clip {
+
+unsigned long image_spec::required_data_size() const
+{
+  unsigned long n = (bytes_per_row * height);
+
+  // For 24bpp we add some extra space to access the last pixel (3
+  // bytes) as an uint32_t
+  if (bits_per_pixel == 24) {
+    if ((n % 4) > 0)
+      n += 4 - (n % 4);
+    else
+      ++n;
+  }
+
+  return n;
+}
+
+image::image()
+  : m_own_data(false),
+    m_data(nullptr)
+{
+}
+
+image::image(const image_spec& spec)
+  : m_own_data(true),
+    m_data(new char[spec.required_data_size()]),
+    m_spec(spec) {
+}
+
+image::image(const void* data, const image_spec& spec)
+  : m_own_data(false),
+    m_data((char*)data),
+    m_spec(spec) {
+}
+
+image::image(const image& image)
+  : m_own_data(false),
+    m_data(nullptr),
+    m_spec(image.m_spec) {
+  copy_image(image);
+}
+
+image::image(image&& image)
+  : m_own_data(false),
+    m_data(nullptr) {
+  move_image(std::move(image));
+}
+
+image::~image() {
+  reset();
+}
+
+image& image::operator=(const image& image) {
+  copy_image(image);
+  return *this;
+}
+
+image& image::operator=(image&& image) {
+  move_image(std::move(image));
+  return *this;
+}
+
+void image::reset() {
+  if (m_own_data) {
+    delete[] m_data;
+    m_own_data = false;
+    m_data = nullptr;
+  }
+}
+
+void image::copy_image(const image& image) {
+  reset();
+
+  m_spec = image.spec();
+  std::size_t n = m_spec.required_data_size();
+
+  m_own_data = true;
+  m_data = new char[n];
+  std::copy(image.data(),
+            image.data()+n,
+            m_data);
+}
+
+void image::move_image(image&& image) {
+  std::swap(m_own_data, image.m_own_data);
+  std::swap(m_data, image.m_data);
+  std::swap(m_spec, image.m_spec);
+}
+
+} // namespace clip

internal/c/parts/os/clipboard/clipboard.cpp

@@ -0,0 +1,392 @@
+//----------------------------------------------------------------------------------------------------------------------
+// QB64-PE cross-platform clipboard support
+// Powered by clip (https://github.com/dacap/clip)
+//----------------------------------------------------------------------------------------------------------------------
+
+#include "libqb-common.h"
+
+// We need 'qbs' and 'image' structs stuff from here. Stop using this when image and friends are refactored
+#include "../../../libqb.h"
+
+// This is not strictly needed. But we'll leave it here for VSCode to do it's magic
+#define CLIP_ENABLE_IMAGE 1
+#include "clip/clip.h"
+#include "clipboard.h"
+#include "error_handle.h"
+#define IMAGE_DEBUG 0
+#include "image.h"
+#include "qbs.h"
+#include <vector>
+
+#ifdef QB64_MACOSX
+#    include <ApplicationServices/ApplicationServices.h>
+#endif
+
+extern const img_struct *img;                 // used by sub__clipboardimage()
+extern const img_struct *write_page;          // used by func__clipboardimage()
+extern const int32_t *page;                   // used by sub__clipboardimage()
+extern const int32_t nextimg;                 // used by sub__clipboardimage()
+extern const uint8_t charset8x8[256][8][8];   // used by sub__clipboardimage()
+extern const uint8_t charset8x16[256][16][8]; // used by sub__clipboardimage()
+
+// This is used as a fallback internal clipboard should any text clipboard functions below fail
+static std::string g_InternalClipboard;
+
+/// @brief Gets text (if present) in the OS clipboard.
+/// @return A qbs string.
+qbs *func__clipboard() {
+#if defined(QB64_MACOSX)
+
+    // We'll use our own clipboard get code on macOS since our requirements are different than what clip supports
+    PasteboardRef clipboard = nullptr;
+    OSStatus err = PasteboardCreate(kPasteboardClipboard, &clipboard);
+
+    if (err == noErr) {
+        PasteboardSynchronize(clipboard);
+        ItemCount itemCount = 0;
+
+        err = PasteboardGetItemCount(clipboard, &itemCount);
+        if (err == noErr) {
+            for (ItemCount itemIndex = 1; itemIndex <= itemCount; itemIndex++) {
+                PasteboardItemID itemID = nullptr;
+                err = PasteboardGetItemIdentifier(clipboard, itemIndex, &itemID);
+                if (err != noErr)
+                    continue;
+
+                CFDataRef flavorData = nullptr;
+                err = PasteboardCopyItemFlavorData(clipboard, itemID, CFSTR("public.utf8-plain-text"), &flavorData);
+                if (err == noErr) {
+                    g_InternalClipboard.assign(reinterpret_cast<const char *>(CFDataGetBytePtr(flavorData)), CFDataGetLength(flavorData));
+
+                    CFRelease(flavorData);
+                    break;
+                }
+            }
+        }
+
+        CFRelease(clipboard);
+    }
+
+#elif defined(QB64_WINDOWS)
+
+    // We'll need custom code for Windows because clip does automatic UTF-8 conversions that leads to some undesired behavior when copying extended ASCII
+    if (OpenClipboard(NULL)) {
+        if (IsClipboardFormatAvailable(CF_TEXT)) {
+            HANDLE hClipboardData = GetClipboardData(CF_TEXT);
+
+            if (hClipboardData) {
+                auto pchData = reinterpret_cast<const char *>(GlobalLock(hClipboardData));
+
+                if (pchData) {
+                    g_InternalClipboard.assign(pchData, strlen(pchData));
+
+                    GlobalUnlock(hClipboardData);
+                }
+            }
+        }
+
+        CloseClipboard();
+    }
+
+#else
+
+    // clip works like we want on Linux
+    if (clip::has(clip::text_format()))
+        clip::get_text(g_InternalClipboard);
+
+#endif
+
+    auto qbsText = qbs_new(g_InternalClipboard.length(), 1);
+    if (qbsText->len)
+        memcpy(qbsText->chr, g_InternalClipboard.data(), qbsText->len);
+
+    return qbsText;
+}
+
+/// @brief Sets text to the OS clipboard.
+/// @param qbsText A qbs string.
+void sub__clipboard(const qbs *qbsText) {
+    g_InternalClipboard.assign(reinterpret_cast<const char *>(qbsText->chr), qbsText->len);
+
+    if (qbsText->len) {
+#if defined(QB64_MACOSX)
+
+        // We'll use our own clipboard set code on macOS since our requirements are different than what clip supports
+        PasteboardRef clipboard;
+        if (PasteboardCreate(kPasteboardClipboard, &clipboard) == noErr) {
+            if (PasteboardClear(clipboard) == noErr) {
+                CFDataRef data = CFDataCreateWithBytesNoCopy(kCFAllocatorDefault, qbsText->chr, qbsText->len, kCFAllocatorNull);
+
+                if (data) {
+                    PasteboardPutItemFlavor(clipboard, nullptr, kUTTypeUTF8PlainText, data, 0);
+
+                    CFRelease(data);
+                }
+            }
+
+            CFRelease(clipboard);
+        }
+
+#elif defined(QB64_WINDOWS)
+
+        // We'll need custom code for Windows because clip does automatic UTF-8 conversions that leads to some undesired behavior when copying extended ASCII
+        if (OpenClipboard(NULL)) {
+            if (EmptyClipboard()) {
+                HGLOBAL hClipboardData = GlobalAlloc(GMEM_MOVEABLE, qbsText->len + 1);
+
+                if (hClipboardData) {
+                    auto pchData = reinterpret_cast<uint8_t *>(GlobalLock(hClipboardData));
+
+                    if (pchData) {
+                        memcpy(pchData, qbsText->chr, qbsText->len);
+                        pchData[qbsText->len] = '\0'; // null terminate
+
+                        GlobalUnlock(hClipboardData);
+
+                        SetClipboardData(CF_TEXT, hClipboardData);
+                    }
+
+                    GlobalFree(hClipboardData);
+                }
+            }
+
+            CloseClipboard();
+        }
+
+#else
+
+        // clip works like we want on Linux
+        clip::set_text(g_InternalClipboard);
+
+#endif
+    }
+}
+
+/// @brief Retuns an image handle of an image from the clipboard (if present).
+/// @return A valid image handle. Returns -1 if clipboard format is not supported or if there is nothing.
+int32_t func__clipboardimage() {
+    int32_t qb64Img = INVALID_IMAGE_HANDLE; // assume failure
+
+    if (is_error_pending())
+        return qb64Img;
+
+    if (clip::has(clip::image_format())) {
+        clip::image clipImg;
+
+        IMAGE_DEBUG_PRINT("Clipboard image found");
+
+        if (clip::get_image(clipImg)) {
+            auto spec = clipImg.spec();
+
+            IMAGE_DEBUG_PRINT("Image (%lu x %lu) @ %lubpp", spec.width, spec.height, spec.bits_per_pixel);
+
+            if (spec.width && spec.height) {
+                auto oldDest = func__dest();
+
+                // We only support 32bpp images. Images in other formats are converted to 32bpp BGRA
+                qb64Img = func__newimage(spec.width, spec.height, 32, 1);
+
+                if (qb64Img < INVALID_IMAGE_HANDLE) {
+                    sub__dest(qb64Img);
+                    auto dst = write_page->offset32;
+
+                    IMAGE_DEBUG_PRINT("Converting and copying image");
+
+                    // Convert and copy the image based on the bpp
+                    switch (spec.bits_per_pixel) {
+                    case 64:
+                        for (uint32_t y = 0; y < spec.height; y++) {
+                            auto src = reinterpret_cast<const uint64_t *>(clipImg.data() + spec.bytes_per_row * y);
+                            for (uint32_t x = 0; x < spec.width; x++, src++) {
+                                auto c = *src;
+                                *dst = image_make_bgra((c & spec.red_mask) >> spec.red_shift >> 8, (c & spec.green_mask) >> spec.green_shift >> 8,
+                                                       (c & spec.blue_mask) >> spec.blue_shift >> 8, (c & spec.alpha_mask) >> spec.alpha_shift >> 8);
+
+                                ++dst;
+                            }
+                        }
+                        break;
+
+                    case 32:
+                        // The alpha mask can be zero (which means that the image is just RGB)
+                        if (spec.alpha_mask) {
+                            for (uint32_t y = 0; y < spec.height; y++) {
+                                auto src = reinterpret_cast<const uint32_t *>(clipImg.data() + spec.bytes_per_row * y);
+                                for (uint32_t x = 0; x < spec.width; x++, src++) {
+                                    auto c = *src;
+                                    *dst = image_make_bgra((c & spec.red_mask) >> spec.red_shift, (c & spec.green_mask) >> spec.green_shift,
+                                                           (c & spec.blue_mask) >> spec.blue_shift, (c & spec.alpha_mask) >> spec.alpha_shift);
+
+                                    ++dst;
+                                }
+                            }
+                        } else {
+                            for (uint32_t y = 0; y < spec.height; y++) {
+                                auto src = reinterpret_cast<const uint32_t *>(clipImg.data() + spec.bytes_per_row * y);
+                                for (uint32_t x = 0; x < spec.width; x++, src++) {
+                                    auto c = *src;
+                                    *dst = image_make_bgra((c & spec.red_mask) >> spec.red_shift, (c & spec.green_mask) >> spec.green_shift,
+                                                           (c & spec.blue_mask) >> spec.blue_shift, 255u);
+
+                                    ++dst;
+                                }
+                            }
+                        }
+                        break;
+
+                    case 24:
+                        for (uint32_t y = 0; y < spec.height; y++) {
+                            auto src = reinterpret_cast<const uint8_t *>(clipImg.data() + spec.bytes_per_row * y);
+                            for (uint32_t x = 0; x < spec.width; x++, src += 3) {
+                                auto c = *reinterpret_cast<const uint32_t *>(src);
+                                *dst = image_make_bgra((c & spec.red_mask) >> spec.red_shift, (c & spec.green_mask) >> spec.green_shift,
+                                                       (c & spec.blue_mask) >> spec.blue_shift, 255u);
+
+                                ++dst;
+                            }
+                        }
+                        break;
+
+                    case 16:
+                        for (uint32_t y = 0; y < spec.height; y++) {
+                            auto src = reinterpret_cast<const uint16_t *>(clipImg.data() + spec.bytes_per_row * y);
+                            for (uint32_t x = 0; x < spec.width; x++, src++) {
+                                auto c = *src;
+                                *dst = image_make_bgra(image_scale_5bits_to_8bits((c & spec.red_mask) >> spec.red_shift),
+                                                       image_scale_6bits_to_8bits((c & spec.green_mask) >> spec.green_shift),
+                                                       image_scale_5bits_to_8bits((c & spec.blue_mask) >> spec.blue_shift), 255u);
+
+                                ++dst;
+                            }
+                        }
+                    }
+                }
+
+                sub__dest(oldDest);
+            }
+        }
+    }
+
+    return qb64Img;
+}
+
+/// @brief Set the clipboard image using a QB64 image handle.
+/// @param src A valid QB64 image handle.
+void sub__clipboardimage(int32_t src) {
+    if (is_error_pending())
+        return;
+
+    // Validation
+    if (src >= 0) {
+        validatepage(src);
+        src = page[src];
+    } else {
+        src = -src;
+        if (src >= nextimg) {
+            error(QB_ERROR_INVALID_HANDLE);
+            return;
+        }
+        if (!img[src].valid) {
+            error(QB_ERROR_INVALID_HANDLE);
+            return;
+        }
+    }
+    // End of validation
+
+    // Even though we have color mask and shift support, clip needs the RGBA order :(
+    clip::image_spec spec;
+    spec.bits_per_pixel = 32;
+    spec.red_mask = 0x000000ff;
+    spec.green_mask = 0x0000ff00;
+    spec.blue_mask = 0x00ff0000;
+    spec.alpha_mask = 0xff000000;
+    spec.red_shift = 0;
+    spec.green_shift = 8;
+    spec.blue_shift = 16;
+    spec.alpha_shift = 24;
+
+    std::vector<uint32_t> pixels; // this will hold our converted BGRA32 pixel data
+    auto srcImg = img[src];
+
+    if (srcImg.text) {
+        IMAGE_DEBUG_PRINT("Rendering text surface to BGRA32");
+
+        uint32_t const fontWidth = 8;
+        uint32_t fontHeight = 16;
+        if (srcImg.font == 8 || srcImg.font == 14)
+            fontHeight = srcImg.font;
+
+        spec.width = fontWidth * srcImg.width;
+        spec.height = fontHeight * srcImg.height;
+        spec.bytes_per_row = spec.width * sizeof(uint32_t);
+        pixels.resize(spec.width * spec.height);
+
+        uint8_t fc, bc, *c = srcImg.offset; // set to the first codepoint
+        uint8_t const *builtinFont = nullptr;
+
+        // Render all text to the raw pixel array
+        for (uint32_t y = 0; y < spec.height; y += fontHeight) {
+            for (uint32_t x = 0; x < spec.width; x += fontWidth) {
+                switch (fontHeight) {
+                case 8:
+                    builtinFont = &charset8x8[*c][0][0];
+                    break;
+
+                case 14:
+                    builtinFont = &charset8x16[*c][1][0];
+                    break;
+
+                default: // 16
+                    builtinFont = &charset8x16[*c][0][0];
+                }
+
+                ++c; // move to the attribute
+                fc = *c & 0x0F;
+                bc = ((*c >> 4) & 7) + ((*c >> 7) << 3);
+
+                // Inner codepoint rendering loop
+                for (uint32_t dy = y, py = 0; py < fontHeight; dy++, py++) {
+                    for (uint32_t dx = x, px = 0; px < fontWidth; dx++, px++) {
+                        pixels[spec.width * dy + dx] = image_swap_red_blue(*builtinFont ? srcImg.pal[fc] : srcImg.pal[bc]);
+                        ++builtinFont;
+                    }
+                }
+
+                ++c; // move to the next codepoint
+            }
+        }
+    } else {
+        spec.width = srcImg.width;
+        spec.height = srcImg.height;
+        spec.bytes_per_row = spec.width * sizeof(uint32_t);
+        pixels.resize(spec.width * spec.height);
+
+        if (srcImg.bits_per_pixel == 32) {
+            // BGRA32 pixels
+            IMAGE_DEBUG_PRINT("Converting BGRA32 image to RGBA32");
+
+            auto p = srcImg.offset32;
+
+            for (size_t i = 0; i < pixels.size(); i++) {
+                pixels[i] = image_swap_red_blue(*p);
+                ++p;
+            }
+        } else {
+            // Indexed pixels
+            IMAGE_DEBUG_PRINT("Converting BGRA32 indexed image to RGBA32");
+
+            auto p = srcImg.offset;
+
+            for (size_t i = 0; i < pixels.size(); i++) {
+                pixels[i] = image_swap_red_blue(srcImg.pal[*p]);
+                ++p;
+            }
+        }
+    }
+
+    IMAGE_DEBUG_PRINT("Setting clipboard image");
+
+    // Send the image off to the OS clipboard
+    clip::image clipImg(pixels.data(), spec);
+    clip::set_image(clipImg);
+}

internal/c/parts/video/font/font.cpp

@@ -1013,21 +1013,21 @@ bool FontRenderTextASCII(int32_t fh, const uint8_t *codepoint, int32_t codepoint
 /// @param text The message to build the MD5 hash of
 /// @return The generated MD5 hash as hexadecimal string
 qbs *func__md5(qbs *text) {
-    {
-        MD5_CTX       ctx;
-        unsigned char md5[16];
-        qbs          *res;
-        int           i;
+    MD5_CTX ctx;
+    unsigned char md5[16];
+    qbs *res;
+    int i;
 
-        MD5_Init(&ctx);
-        if (text->len) MD5_Update(&ctx, text->chr, text->len);
-        MD5_Final(md5,&ctx);
+    MD5_Init(&ctx);
+    if (text->len)
+        MD5_Update(&ctx, text->chr, text->len);
+    MD5_Final(md5, &ctx);
 
-        res = qbs_new(32, 1);
-        for (i = 0; i < 16; i++) sprintf((char*)&res->chr[i*2], "%02X", md5[i]);
+    res = qbs_new(32, 1);
+    for (i = 0; i < 16; i++)
+        sprintf((char *)&res->chr[i * 2], "%02X", md5[i]);
 
-        return res;
-    }
+    return res;
 }
 
 /// @brief Return the true font height in pixel
@@ -1425,21 +1425,21 @@ void sub__UPrintString(int32_t start_x, int32_t start_y, const qbs *text, int32_
             }
         }
     } else {
-        uint32_t a = IMAGE_GET_BGRA_ALPHA(write_page->color) + 1;
-        uint32_t a2 = IMAGE_GET_BGRA_ALPHA(write_page->background_color) + 1;
-        uint32_t z = IMAGE_GET_BGRA_BGR(write_page->color);
-        uint32_t z2 = IMAGE_GET_BGRA_BGR(write_page->background_color);
+        uint32_t a = image_get_bgra_alpha(write_page->color) + 1;
+        uint32_t a2 = image_get_bgra_alpha(write_page->background_color) + 1;
+        uint32_t z = image_get_bgra_bgr(write_page->color);
+        uint32_t z2 = image_get_bgra_bgr(write_page->background_color);
 
         switch (write_page->print_mode) {
         case 3: {
-            float alpha1 = IMAGE_GET_BGRA_ALPHA(write_page->color);
-            float r1 = IMAGE_GET_BGRA_RED(write_page->color);
-            float g1 = IMAGE_GET_BGRA_GREEN(write_page->color);
-            float b1 = IMAGE_GET_BGRA_BLUE(write_page->color);
-            float alpha2 = IMAGE_GET_BGRA_ALPHA(write_page->background_color);
-            float r2 = IMAGE_GET_BGRA_RED(write_page->background_color);
-            float g2 = IMAGE_GET_BGRA_GREEN(write_page->background_color);
-            float b2 = IMAGE_GET_BGRA_BLUE(write_page->background_color);
+            float alpha1 = image_get_bgra_alpha(write_page->color);
+            float r1 = image_get_bgra_red(write_page->color);
+            float g1 = image_get_bgra_green(write_page->color);
+            float b1 = image_get_bgra_blue(write_page->color);
+            float alpha2 = image_get_bgra_alpha(write_page->background_color);
+            float r2 = image_get_bgra_red(write_page->background_color);
+            float g2 = image_get_bgra_green(write_page->background_color);
+            float b2 = image_get_bgra_blue(write_page->background_color);
             float dr = r2 - r1;
             float dg = g2 - g1;
             float db = b2 - b1;
@@ -1460,7 +1460,7 @@ void sub__UPrintString(int32_t start_x, int32_t start_y, const qbs *text, int32_
                     float g3 = g1 + dg * d;
                     float b3 = b1 + db * d;
                     pset_and_clip(start_x + pen.x, start_y + pen.y,
-                                  IMAGE_MAKE_BGRA(qbr_float_to_long(r3), qbr_float_to_long(g3), qbr_float_to_long(b3), qbr_float_to_long(alpha3)));
+                                  image_make_bgra(qbr_float_to_long(r3), qbr_float_to_long(g3), qbr_float_to_long(b3), qbr_float_to_long(alpha3)));
                 }
             }
         } break;

internal/c/parts/video/image/image.cpp

@@ -1,4 +1,4 @@
-//----------------------------------------------------------------------------------------------------
+//-----------------------------------------------------------------------------------------------------
 //    ___  ___   __ _ _  ___ ___   ___                       _    _ _
 //   / _ \| _ ) / /| | || _ \ __| |_ _|_ __  __ _ __ _ ___  | |  (_) |__ _ _ __ _ _ _ _  _
 //  | (_) | _ \/ _ \_  _|  _/ _|   | || '  \/ _` / _` / -_) | |__| | '_ \ '_/ _` | '_| || |
@@ -46,9 +46,6 @@
 #define STB_IMAGE_WRITE_IMPLEMENTATION
 #include "stb/stb_image_write.h"
 
-// This is returned to the caller if something goes wrong while loading the image
-#define INVALID_IMAGE_HANDLE -1
-
 #ifdef QB64_WINDOWS
 #    define ZERO_VARIABLE(_v_) ZeroMemory(&(_v_), sizeof(_v_))
 #else
@@ -372,11 +369,6 @@ static uint32_t *image_decode_from_memory(const uint8_t *data, size_t size, int3
     return pixels;
 }
 
-/// @brief Clamps a color channel to the range 0 - 255
-/// @param n The color component
-/// @return The clamped value
-static inline uint8_t image_clamp_component(int32_t n) { return n < 0 ? 0 : n > 255 ? 255 : n; }
-
 /// @brief This takes in a 32bpp (BGRA) image raw data and spits out an 8bpp raw image along with it's 256 color (BGRA) palette.
 /// @param src32 The source raw image data. This must be in BGRA format and not NULL
 /// @param w The width of the image in pixels
@@ -408,9 +400,9 @@ static uint8_t *image_convert_8bpp(const uint32_t *src32, int32_t w, int32_t h,
     for (auto y = 0; y < h; y++) {
         for (auto x = 0; x < w; x++) {
             int32_t t = bayerMatrix[((y & 3) << 2) + (x & 3)];
-            int32_t b = image_clamp_component((*src++) + (t << 1));
-            int32_t g = image_clamp_component((*src++) + (t << 1));
-            int32_t r = image_clamp_component((*src++) + (t << 1));
+            int32_t b = image_clamp_color_component((*src++) + (t << 1));
+            int32_t g = image_clamp_color_component((*src++) + (t << 1));
+            int32_t r = image_clamp_color_component((*src++) + (t << 1));
             ++src; // Ignore alpha
 
             // Quantize
@@ -428,9 +420,9 @@ static uint8_t *image_convert_8bpp(const uint32_t *src32, int32_t w, int32_t h,
     // Generate a uniform CLUT based on the quantized colors
     for (auto i = 0; i < 256; i++) {
         if (cubes[i].count) {
-            paletteOut[i] = IMAGE_MAKE_BGRA(cubes[i].r / cubes[i].count, cubes[i].g / cubes[i].count, cubes[i].b / cubes[i].count, 0xFF);
+            paletteOut[i] = image_make_bgra(cubes[i].r / cubes[i].count, cubes[i].g / cubes[i].count, cubes[i].b / cubes[i].count, 0xFF);
         } else {
-            paletteOut[i] = IMAGE_MAKE_BGRA(0, 0, 0, 0xFF);
+            paletteOut[i] = image_make_bgra(0, 0, 0, 0xFF);
         }
     }
 
@@ -484,19 +476,6 @@ static uint8_t *image_extract_8bpp(const uint32_t *src, int32_t w, int32_t h, ui
     return pixels;
 }
 
-/// @brief Calculates the distance between 2 RBG points in the RGB color cube
-/// @param r1 R1
-/// @param g1 G1
-/// @param b1 B1
-/// @param r2 R2
-/// @param g2 G2
-/// @param b2 B2
-/// @return The distance in floating point
-static inline float image_calculate_rgb_distance(uint8_t r1, uint8_t g1, uint8_t b1, uint8_t r2, uint8_t g2, uint8_t b2) {
-    return sqrt(((float(r2) - float(r1)) * (float(r2) - float(r1))) + ((float(g2) - float(g1)) * (float(g2) - float(g1))) +
-                ((float(b2) - float(b1)) * (float(b2) - float(b1))));
-}
-
 /// @brief This modifies an *8bpp* image 'src' to use 'dst_pal' instead of 'src_pal'
 /// @param src A pointer to the 8bpp image pixel data. This modifies data 'src' points to and cannot be NULL
 /// @param w The width of the image in pixels
@@ -515,8 +494,8 @@ static void image_remap_palette(uint8_t *src, int32_t w, int32_t h, const uint32
         auto oldDist = maxRGBDist;
 
         for (auto y = 0; y < 256; y++) {
-            auto newDist = image_calculate_rgb_distance(IMAGE_GET_BGRA_RED(src_pal[x]), IMAGE_GET_BGRA_GREEN(src_pal[x]), IMAGE_GET_BGRA_BLUE(src_pal[x]),
-                                                        IMAGE_GET_BGRA_RED(dst_pal[y]), IMAGE_GET_BGRA_GREEN(dst_pal[y]), IMAGE_GET_BGRA_BLUE(dst_pal[y]));
+            auto newDist = image_calculate_rgb_distance(image_get_bgra_red(src_pal[x]), image_get_bgra_green(src_pal[x]), image_get_bgra_blue(src_pal[x]),
+                                                        image_get_bgra_red(dst_pal[y]), image_get_bgra_green(dst_pal[y]), image_get_bgra_blue(dst_pal[y]));
 
             if (oldDist > newDist) {
                 oldDist = newDist;
@@ -531,11 +510,6 @@ static void image_remap_palette(uint8_t *src, int32_t w, int32_t h, const uint32
     }
 }
 
-/// @brief Helps convert a BGRA color to an RGBA color and back
-/// @param clr A BGRA color or an RGBA color
-/// @return An RGBA color or a BGRA color
-static inline uint32_t image_swap_red_blue(uint32_t clr) { return ((clr & 0xFF00FF00u) | ((clr & 0x00FF0000u) >> 16) | ((clr & 0x000000FFu) << 16)); }
-
 /// @brief This function loads an image into memory and returns valid LONG image handle values that are less than -1
 /// @param qbsFileName The filename or memory buffer (see requirements below) of the image
 /// @param bpp 32 = 32bpp, 33 = 32bpp (hardware accelerated), 256=8bpp or 257=8bpp (without palette remap)
@@ -866,7 +840,7 @@ void sub__saveimage(qbs *qbsFileName, int32_t imageHandle, qbs *qbsRequirements,
                 // Inner codepoint rendering loop
                 for (auto dy = y, py = 0; py < fontHeight; dy++, py++) {
                     for (auto dx = x, px = 0; px < fontWidth; dx++, px++) {
-                        pixels[width * dy + dx] = image_swap_red_blue(*builtinFont ? palette_256[fc] : palette_256[bc]);
+                        pixels[width * dy + dx] = image_swap_red_blue(*builtinFont ? img[imageHandle].pal[fc] : img[imageHandle].pal[bc]);
                         ++builtinFont;
                     }
                 }

internal/c/qbx.cpp

@@ -1,26 +1,27 @@
 #include "audio.h"
 #include "bitops.h"
+#include "clipboard.h"
+#include "command.h"
 #include "common.h"
 #include "compression.h"
-#include "command.h"
 #include "datetime.h"
 #include "environ.h"
+#include "error_handle.h"
 #include "event.h"
 #include "extended_math.h"
-#include "filepath.h"
 #include "file-fields.h"
+#include "filepath.h"
 #include "filesystem.h"
 #include "font.h"
 #include "gui.h"
 #include "hexoctbin.h"
 #include "image.h"
-#include "qbmath.h"
-#include "qbs.h"
-#include "qbs-mk-cv.h"
-#include "shell.h"
-#include "error_handle.h"
 #include "mem.h"
+#include "qbmath.h"
+#include "qbs-mk-cv.h"
+#include "qbs.h"
 #include "rounding.h"
+#include "shell.h"
 
 extern int32 func__cinp(int32 toggle,
                         int32 passed); // Console INP scan code reader
@@ -194,10 +195,6 @@ extern void sub__fullscreen(int32 method, int32 passed);
 extern void sub__allowfullscreen(int32 method, int32 smooth);
 extern int32 func__fullscreen();
 extern int32 func__fullscreensmooth();
-extern void sub__clipboard(qbs *);
-extern qbs *func__clipboard();
-extern int32 func__clipboardimage();
-extern void sub__clipboardimage(int32 src);
 extern int32 func__exit();
 extern void revert_input_check();
 extern int32 func__openhost(qbs *);

internal/source/compilelog.txt

@@ -1,4 +1,4 @@
 g++  -no-pie -std=gnu++17 -fno-strict-aliasing -Wno-conversion-null -DFREEGLUT_STATIC -I./internal/c/libqb/include -I./internal/c/parts/core/freeglut/include -I./internal/c/parts/core/glew/include -DDEPENDENCY_SOCKETS -DDEPENDENCY_NO_PRINTER -DDEPENDENCY_ICON -DDEPENDENCY_NO_SCREENIMAGE  internal/c/qbx.cpp -c -o internal/c/qbx.o
-g++  -no-pie -std=gnu++17 -fno-strict-aliasing -Wno-conversion-null -DFREEGLUT_STATIC -I./internal/c/libqb/include -I./internal/c/parts/core/freeglut/include -I./internal/c/parts/core/glew/include -DDEPENDENCY_SOCKETS -DDEPENDENCY_NO_PRINTER -DDEPENDENCY_ICON -DDEPENDENCY_NO_SCREENIMAGE  ./internal/c/libqb_make_000101000.o  ./internal/c/qbx.o -o "/home/runner/work/QB64pe/QB64pe/qb64pe"  ./internal/c/libqb/src/threading.o ./internal/c/libqb/src/buffer.o ./internal/c/libqb/src/bitops.o ./internal/c/libqb/src/command.o ./internal/c/libqb/src/environ.o ./internal/c/libqb/src/file-fields.o ./internal/c/libqb/src/filepath.o ./internal/c/libqb/src/filesystem.o ./internal/c/libqb/src/datetime.o ./internal/c/libqb/src/error_handle.o ./internal/c/libqb/src/gfs.o ./internal/c/libqb/src/qblist.o ./internal/c/libqb/src/hexoctbin.o ./internal/c/libqb/src/mem.o ./internal/c/libqb/src/math.o ./internal/c/libqb/src/rounding.o ./internal/c/libqb/src/shell.o ./internal/c/libqb/src/qbs.o ./internal/c/libqb/src/qbs_str.o ./internal/c/libqb/src/qbs_cmem.o ./internal/c/libqb/src/qbs_mk_cv.o ./internal/c/libqb/src/string_functions.o ./internal/c/libqb/src/http.o ./internal/c/libqb/src/threading-posix.o ./internal/c/libqb/src/glut-main-thread.o ./internal/c/libqb/src/glut-message.o ./internal/c/libqb/src/glut-msg-queue.o ./internal/c/parts/gui/tinyfiledialogs.o ./internal/c/parts/gui/gui.o ./internal/c/parts/video/font/font.o ./internal/c/parts/video/font/freetype/freetype.a ./internal/c/parts/audio/stub_audio.o ./internal/c/parts/compression/miniz.o ./internal/c/parts/compression/compression.o  ./internal/c/parts/core/freeglut.a ./internal/c/parts/core/glew/glew.o  -lGL -lGLU -lX11 -lpthread -ldl -lrt  -lcurl
+g++  -no-pie -std=gnu++17 -fno-strict-aliasing -Wno-conversion-null -DFREEGLUT_STATIC -I./internal/c/libqb/include -I./internal/c/parts/core/freeglut/include -I./internal/c/parts/core/glew/include -DDEPENDENCY_SOCKETS -DDEPENDENCY_NO_PRINTER -DDEPENDENCY_ICON -DDEPENDENCY_NO_SCREENIMAGE  ./internal/c/libqb_make_000101000.o  ./internal/c/qbx.o -o "/home/runner/work/QB64pe/QB64pe/qb64pe"  ./internal/c/libqb/src/threading.o ./internal/c/libqb/src/buffer.o ./internal/c/libqb/src/bitops.o ./internal/c/libqb/src/command.o ./internal/c/libqb/src/environ.o ./internal/c/libqb/src/file-fields.o ./internal/c/libqb/src/filepath.o ./internal/c/libqb/src/filesystem.o ./internal/c/libqb/src/datetime.o ./internal/c/libqb/src/error_handle.o ./internal/c/libqb/src/gfs.o ./internal/c/libqb/src/qblist.o ./internal/c/libqb/src/hexoctbin.o ./internal/c/libqb/src/mem.o ./internal/c/libqb/src/math.o ./internal/c/libqb/src/rounding.o ./internal/c/libqb/src/shell.o ./internal/c/libqb/src/qbs.o ./internal/c/libqb/src/qbs_str.o ./internal/c/libqb/src/qbs_cmem.o ./internal/c/libqb/src/qbs_mk_cv.o ./internal/c/libqb/src/string_functions.o ./internal/c/libqb/src/http.o ./internal/c/libqb/src/threading-posix.o ./internal/c/libqb/src/glut-main-thread.o ./internal/c/libqb/src/glut-message.o ./internal/c/libqb/src/glut-msg-queue.o ./internal/c/parts/gui/tinyfiledialogs.o ./internal/c/parts/gui/gui.o ./internal/c/parts/os/clipboard/clipboard.a ./internal/c/parts/video/font/font.o ./internal/c/parts/video/font/freetype/freetype.a ./internal/c/parts/audio/stub_audio.o ./internal/c/parts/compression/miniz.o ./internal/c/parts/compression/compression.o  ./internal/c/parts/core/freeglut.a ./internal/c/parts/core/glew/glew.o  -lGL -lGLU -lX11 -lpthread -ldl -lrt -lxcb -lpng  -lcurl
 objcopy --only-keep-debug "/home/runner/work/QB64pe/QB64pe/qb64pe" "./internal/temp/qb64pe.sym"
 objcopy --strip-unneeded "/home/runner/work/QB64pe/QB64pe/qb64pe"

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);
 }

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;

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;

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);
 }

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;

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){

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);
 }

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;

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;

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;

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;

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);
 }

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);
 }

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);
 }

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);
 }

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);

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);
 }

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);
 }

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);

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);
 }

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);

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);

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;

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);
 }

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);
 }

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);
 }

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);
 }

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;

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);
 }

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;

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);
 }

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){

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);
 }

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);
 }

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);
 }

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);
 }

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);
 }

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;

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);
 }

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);

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;

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;

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;

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;

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;

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){

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);

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);

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);

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);
 }

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;

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;

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;

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;

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;

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;

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;

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;

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;

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;

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;

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;

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;

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;

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;

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){

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);
 }

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);
 }

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);
 }

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){

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);

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;

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;

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;