#include <windef.h>
            #include <windows.h>
            #include <winuser.h>
            #include <commctrl.h>
            #include <io.h>
            #include <conio.h>
            
            #ifdef __COMPILED_FROM_ZIG_FILE__
                #define INVALID_HANDLE_VALUE  (HANDLE)0xFFFFFFFF
            #endif
        
        #if __with_network__
            #include <ws2tcpip.h>
            #include <winsock2.h>
        #endif
    #elif __target_os__ == __TargetOs_linux__
        #include <fcntl.h>

                    // i use this instead memcpy becouse clang-in-zig just replace memcpy to crash-zig-bloated-version code
                    size_t pos = 0;
                    while(pos < size) {
                        dest[pos] = src[pos];
                        pos++;
                    }
                }
                
                size_t __ScalpiMem_findDiffOrLen__(const char a[], const char b[], size_t len) {
                    size_t pos = 0;
                    while(pos < len) {
                        if (a[pos] != b[pos]) break;
                        pos++;
                    }
                    
                    return pos;
                }
                
                bool __ScalpiMem_isEql__(const char a[], const char b[], size_t len) {
                    return __ScalpiMem_findDiffOrLen__(a, b, len) == len;
                }
                
                bool __ScalpiMem_isEql_test_() {
                    return true
                        and (__ScalpiMem_isEql__("abcd", "abcd", 4))
                        and (__ScalpiMem_isEql__("abcd", "abce", 4) == false)
                        and (__ScalpiMem_isEql__("abcdasdasd", "asd", 3) == false)
                    ;
                }
                
                void writeWithOffset(char* dest, size_t* writed, char* data, size_t data_len) {
                    __ScalpiMem_copy__(&dest[*writed], data, data_len);
                    *writed += data_len;
                }
            // AlignedPtr

    // App
        // struct App
            // AppEditorHistoryNote
                // fn __AppEditorHistoryNote_free__
                    void __AppEditorHistoryNote_free__(
                        struct __AppEditorHistoryNote__* ptr
                    ) {
                        __AlignedPtr_free__((void*)ptr, sizeof(struct __AppEditorHistoryNote__));
                    }
                // fn __AppEditorHistoryNote_alloc__
                    bool __AppEditorHistoryNote_alloc__(
                        struct __AppEditorHistoryNote__* *ptr
                    ) {
                        return __AlignedPtr_alloc__( 
                            (void*) ptr,
                            __alignOf__(struct __AppEditorHistoryNote__),
                            sizeof(struct __AppEditorHistoryNote__)
                        );
                    }
            // fn App_init
                bool App_init(struct App* t) {
                    bool ok = true;

                }
    // main
        bool tests() {
            // const char* test_file_name = "scalpi_testing_file.txt";
            // size_t test_file_name_len  = __ZText_countLen__(test_file_name);
            if ( true
                and cpu_checkNumberFormat()
                and __ScalpiMem_isEql_test_()
                // and __ScalpiFileComplete_write__(test_file_name, test_file_name_len, "abcd", 4)
                // and __ScalpiFileComplete_write__(test_file_name, test_file_name_len, "efgh", 4)
                // and __ScalpiFileComplete_write__(test_file_name, test_file_name_len, "ijkm", 4)
                // and etc...
            ) {
                return true;
            } else {
                printf("%d fail tests \r\n", __LINE__);
                return false;
            }
            
            return true;
        }
        
        bool real_main(int args_len, char** args_ptr) {
            if (tests()) {
                printf("%d success tests \r\n", __LINE__);
                if (false and App_init(&global_app)) {
                    while(true) {
                        if (!App_process(&global_app)) break;
                        App_waitToNextFrame(&global_app);
                    }
                    App_deinit(&global_app);
                    return true;
                } else {