// os
            #define __TargetOs_windows__ 1
            #define __TargetOs_linux__   2
        // memory type
            #define __TargetMemoryType_endiansLittle__  1
            #define __TargetMemoryType_endiansBig__     2
    // time
        #define __ScalpiTime_msPerS__ 1000
    // OsNetwork
        #define __OsNetworkTcp_maxAllowedListenPort__ 49151
        #define __OsNetworkTcpSocketConnectResult_error__      -1
        #define __OsNetworkTcpSocketConnectResult_inProgress__  0
        #define __OsNetworkTcpSocketConnectResult_success__     1




    // scalpi
        #define __ScalpiTextCharsDecFromU64_lenMax__  __CText_len__("18446744073709551615")
        // __ScalpiLoggerWriters__
            #define __ScalpiLoggerWriter_toFallback__  0
            #define __ScalpiLoggerWriter_toFile__      1
            #define __ScalpiLoggerWriter_toConsole__   2
            #define __ScalpiLoggerWriter_toTerminal__  3
        // Scalpi_Console_ansi_input_Key
            // ascii
                #define __Scalpi_Console_ansi_input_Key_ascii_ctrl__     (-'a' + 1)  /* do not use externally */
                #define __Scalpi_Console_ansi_input_Key_ctrl_bs__         8  /* also ctrl_h */
                #define __Scalpi_Console_ansi_input_Key_tab__             9  /* also ctrl_i */
                #define __Scalpi_Console_ansi_input_Key_enter__          13  /* also ctrl_m */
                #define __Scalpi_Console_ansi_input_Key_escape__         27

                    #define __Scalpi_Console_ansi_input_Key_alt_comma__          (',' + __Scalpi_Console_ansi_input_Key_alt__)
                    #define __Scalpi_Console_ansi_input_Key_alt_dot__            ('.' + __Scalpi_Console_ansi_input_Key_alt__)
                    #define __Scalpi_Console_ansi_input_Key_alt_open_bracket__   ('[' + __Scalpi_Console_ansi_input_Key_alt__)
                    #define __Scalpi_Console_ansi_input_Key_alt_close_bracket__  (']' + __Scalpi_Console_ansi_input_Key_alt__)
                    #define __Scalpi_Console_ansi_input_Key_alt_semicolon__      (';' + __Scalpi_Console_ansi_input_Key_alt__)
                    #define __Scalpi_Console_ansi_input_Key_alt_apostrophe__     ('`' + __Scalpi_Console_ansi_input_Key_alt__)
        // websocket
            #define __ScalpiNetworkTcpHttpWebSocketHandShake_encoded_len__ 28
// settings
    // platform
        // #define __target_os__ __TargetOs_
            #ifndef __target_os__
                #ifdef _WIN32
                    #define __target_os__           __TargetOs_windows__
                #elif defined(__linux__)
                    #define __target_os__           __TargetOs_linux__
                #endif
            #endif
            
            #if __target_os__ == __TargetOs_windows__
            #elif __target_os__ == __TargetOs_linux__
            #else
                #error "__target_os__ not implemented"
            #endif
            
            #define __target_memory_type__                __TargetMemoryType_endiansLittle__
            #define __with_network__                      0
            #define __OsFilePathLen_max__              1024
            #define __OsNetworkTcp_maxClientCount__       8
            #define __OsNetworkTcpHttp_maxHeaders__      48
        #define __ScalpiTerminalInput_size__  32
    
    // App
        #define __AppEditorLineLen_max__  (1024 * 8)
        #define __App_expectedFps__          30
// imports
    // libC
        #include <stdarg.h>
        #include <stdbool.h>
        #include <stddef.h>
        #include <stdint.h>
        #include <stdio.h>

        #include <wchar.h>
        #include <wctype.h>
    
    #if __target_os__ == __TargetOs_windows__
        // posix
            #include <fcntl.h>
        // Windows
            #if __with_network__
                #include <ws2tcpip.h>  // include before windows.h
                #include <winsock2.h>
            #endif
            
            #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





    #elif __target_os__ == __TargetOs_linux__
        #include <fcntl.h>
        #include <sys/ioctl.h>
        #include <sys/stat.h>
        #include <termios.h>
        #include <unistd.h>
        #include <time.h>
        
        #if __with_network__
            #include <arpa/inet.h>
            #include <netinet/in.h>
            #include <netinet/ip.h>
            #include <sys/socket.h>
        #endif
    #endif
// strings
    #define __ScalpiNetworkWsQuery_expected__  "GET /ws"
    #define __ScalpiTextCharsDecFromU64_lenMax__  __CText_len__("18446744073709551615")
    // Scalpi_Console_ansi
        #define Scalpi_Console_ansi_esc                          "\x1B"
        #define __ScalpiConsoleAnsi_control__                      Scalpi_Console_ansi_esc "["
        // clear_output
            #define Scalpi_Console_ansi_output_clear_to_end_line     __ScalpiConsoleAnsi_control__ "0K"
            #define Scalpi_Console_ansi_output_clear_to_start_line   __ScalpiConsoleAnsi_control__ "1K"
            #define Scalpi_Console_ansi_output_clear_line            __ScalpiConsoleAnsi_control__ "2K"

        #elif __target_os__ == __TargetOs_linux__
            #define __OsFilePath_separator__ "/"
        #else
            #error "not implemented current __target_os__ or not defined. (expected __TargetOs_ value)"
        #endif
// basic types
    // scalpi
        // # __ScalpiConsoleAnsiInputKey__
            typedef
                uint64_t
                __ScalpiConsoleAnsiInputKey__
            ;
        // # __WriteFnPtr__
            typedef
                size_t
                (*__WriteFnPtr__)
                (void* context, const char* bytes, size_t bytes_len)
            ;
        // # __WriteFnPtrVoid__
            typedef
                void
                (*__WriteFnPtrVoid__)
                (void* context, const char* bytes, size_t bytes_len)
            ;
    // OS
        // # __OsFileHandle__
            #if __target_os__ == __TargetOs_windows__
                typedef HANDLE __OsFileHandle__;
            #elif __target_os__ == __TargetOs_linux__
                typedef int  __OsFileHandle__;
            #else
                #error "not implemented current __target_os__ or not defined. (expected __TargetOs_ value)"
            #endif

            #define __len_and_text__(str)              __CText_len__(str), str
            #define __text_and_len__(str)              str, __CText_len__(str)
            #define __Slice_fromCText__(text)          {.ptr=text, .len=__CText_len__(text)}
    // crypto
        #define Sha1_block_size 64
        #define Sha1_digest_length 20
    // Network



        #if __target_os__ == __TargetOs_windows__
            #define WSA_SUCCESS 0
        #elif __target_os__ == __TargetOs_linux__
        #else
            #error "__target_os__ not implemented"
        #endif

                    struct Slice desired;
                    size_t pos;
                };
    // Os
        // system specifics 
            #if __target_os__ == __TargetOs_windows__
            #elif __target_os__ == __TargetOs_linux__
                // # __OsLinux_timespec__
                    struct __OsLinux_timespec__ {
                        time_t tv_sec;  /* seconds */
                        long   tv_nsec; /* nanoseconds */
                    };
            #else
                #error "__target_os__ not implemented"
            #endif
        // OsConsole
            // # __OsConsoleFlags__
                struct __OsConsoleFlags__ {
                    bool inited;
                    
                    #if __target_os__ == __TargetOs_windows__
                        DWORD input_mode;
                        DWORD output_mode;
                    #elif __target_os__ == __TargetOs_linux__
                        struct termios termios;
                    #else
                        #error "not implemented current __target_os__ or not defined. (expected __TargetOs_ value)"
                    #endif
                };
            
            // # __OsConsoleInput__
                struct __OsConsoleInput__ {
                    __OsConsoleInputHandle__ handle;
                    
                    #if __target_os__ == __TargetOs_windows__
                    #elif __target_os__ == __TargetOs_linux__
                        int fileno;
                    #else
                        #error "not implemented current __target_os__ or not defined. (expected __TargetOs_ value)"
                    #endif
                };
            // # __OsConsoleOutput__
                struct __OsConsoleOutput__ {
                    __OsConsoleOutputHandle__  __OsConsoleOutput_handle__;
                    #if __target_os__ == __TargetOs_windows__
                    #elif __target_os__ == __TargetOs_linux__
                    #else
                        #error "not implemented current __target_os__ or not defined. (expected __TargetOs_ value)"
                    #endif
                };
        // # __OsHelper__
            struct __OsHelper__ {
                #if __target_os__ == __TargetOs_windows__
                    HINSTANCE instance;
                    void* console_input_handle;
                    __OsConsoleOutputHandle__ console_output_handle;
                    
                    #if __with_network__
                        bool network_inited;
                        WSADATA wsdata;
                    #endif
                #elif __target_os__ == __TargetOs_linux__
                    FILE* console_input_handle;
                    __OsConsoleOutputHandle__ console_output_handle;
                #else
                    #error "not implemented current __target_os__ or not defined. (expected __TargetOs_ value)"
                #endif
            };
    // Scalpi
        // mem
            // # __ScalpiWriter__
                struct __ScalpiWriter__ {
                    void*          context;
                    __WriteFnPtr__ write;
                };
            
            struct __ScalpiMemTree__ {
                struct __ScalpiMemTree__*     parent; // todo remove me. use link.list or __ ... 
                struct __ScalpiMemList__      childs;
                struct __ScalpiMemListLink__  link;
                size_t                        count;  // recurse. for get non recurse use childs.count
                size_t                        nested;
            };
        // math
            struct __Scalpi_math_d2_U_Pos__ {
                size_t x;
                size_t y;
            };
        // text
            struct Scalpi_Text_Splitter {
                struct Finder finder;
                bool stop;
                size_t last_pos;
            };
        // # __ScalpiLogger__
            struct __ScalpiLogger__ {
                // write to terminal, console, file or to all together, but no real check "bytes is writen"
                struct __ScalpiWriter__ writers[4]; // __ScalpiLoggerWriters__
            };
        // Console
            // __Scalpi_Console_ansi_input_Key_SequenceParser__
                struct __Scalpi_Console_ansi_input_Key_SequenceParser__ {
                    __ScalpiConsoleAnsiInputKey__ sequence;
                    size_t used;
                };

                // use __ScalpiTerminalInput_grab__ in loop for get keys
                
                size_t ungrabed;
                char buffer[__ScalpiTerminalInput_size__];
            };
            
            struct __ScalpiTerminal__ {
                struct __ScalpiConsole__           *console;
                struct __OsConsoleFlags__          system_flags;
                struct __ScalpiTerminalInput__     input;
                struct __ScalpiTerminalOutput__    output;
            };
    // crypto
        // Sha1_Streaming
            struct Sha1_Streaming {

            struct __AppEditorHistoryNote__ {
                __ScalpiConsoleAnsiInputKey__   key;
                struct __ScalpiMemListLink__    link;
            };
        // # App
            struct App {
                struct __OsHelper__    __App_osHelper__;
                struct __ScalpiLogger__   logger;
                uint64_t               tick;
            };
// function prototypes
    void __OsFile_truncate__(            __OsFileHandle__ file);
    void   __OsFile_setPos__(            __OsFileHandle__ file, size_t pos);
    bool   __OsMem_alloc__(              uintptr_t *ret_data_addr, size_t size);
    void   __OsMem_free__(               uintptr_t ret_data_addr);

                return (a + b - 1) / b;
            }
        // Scalpi_Text_writeU64AsText
            size_t Scalpi_Text_writeU64AsTextToBuffer(char buffer[], uint64_t number, size_t min_width) { // utoa utos
                size_t writed = 0;
                
                // write number to tmp
                char buffer_tmp[__ScalpiTextCharsDecFromU64_lenMax__];
                uintptr_t tmp_ptr = (uintptr_t) &buffer_tmp[0] + __ScalpiTextCharsDecFromU64_lenMax__;
                for (uint64_t num = number; num > 0; num = num / 10) {
                    uint8_t remainder = num % 10;
                    tmp_ptr-=1;
                    *(char*)tmp_ptr = '0' + (char) remainder;
                }
                const uintptr_t writed_tmp = (uintptr_t) &buffer_tmp[0] + __ScalpiTextCharsDecFromU64_lenMax__ - (uintptr_t) tmp_ptr;
                
                // fill zeroes to min_width
                size_t extra_fill = 0;
                if (min_width > writed_tmp) {
                    extra_fill = min_width - writed_tmp;
                    __ScalpiMem_fill__(&buffer[0], '0', extra_fill);
                    writed += extra_fill;
                }
                
                if (writed_tmp > 0) {
                    __ScalpiMem_copy__(&buffer[writed], (char*)tmp_ptr, writed_tmp);
                    writed += writed_tmp;
                }
                return writed;
            }
            
            size_t __ScalpiText_writeU64AsTextToWriteFnVoid__(__WriteFnPtrVoid__ fn_write, void* context, uint64_t number, size_t min_width) {
                char buffer_tmp[__ScalpiTextCharsDecFromU64_lenMax__];
                const size_t writed = Scalpi_Text_writeU64AsTextToBuffer(&buffer_tmp[0], number, min_width);
                fn_write(context, buffer_tmp, writed);
                return writed;
            }
        // ZText - zero ended text
            // # __ZText_fromBytes__
                void __ZText_fromBytes__(char* buffer, const char bytes[], size_t bytes_len) {
                    // expected buffer_len >= bytes_len + 1
                    
                    __ScalpiMem_copy__(buffer, bytes, bytes_len);
                    buffer[bytes_len] = 0;
                }

                    const size_t len = __ZText_countLen__(data);
                    __ScalpiMem_copy__(buffer, data, len);
                    return len;
                }
            // # __ZText_writeToWriteFn__
                size_t __ZText_writeToWriteFn__(__WriteFnPtr__ fn_write, void* context, const char text[]) {
                    const size_t len = __ZText_countLen__(text);
                    fn_write(context, text, len);
                    return len;
                }
    // Os
        // mem
            // # __OsMem_alloc__
                bool __OsMem_alloc__( // TODO use real system alloc?
                    uintptr_t  *ret,
                    size_t     size

                                size_t delta = indent - new_indent;
                                __Buffer_removeIndent__(buffer, buffer_used, delta);
                            }
                        }
                    return ok;
                }
        // File
            // # __File_clear__
                void __ScalpiFile_clear__(
                    __OsFileHandle__ file
                ) {
                    __OsFile_setPos__(file, 0);
                    __OsFile_truncate__(file);
                }
            // FileComplete 
                // # __ScalpiFileComplete_clear__
                    bool __ScalpiFileComplete_clear__(
                        const char*  file_name, 
                        size_t       file_name_len
                    ) {
                        bool ok = true;

                    size_t ci = 0; // cyclical iterator
                    for (size_t pos = 0; pos < dest_len; pos++) {
                        dest[pos] = a[pos] ^ b[ci];
                        ci += 1;
                        if (ci == b_len) ci = 0;
                    }
                }
        // __ScalpiLogger__
            void __ScalpiLogger_init__ (struct __ScalpiLogger__* t) {
                for (int i = 0; i < __arrayLen__(t->writers); i++) {
                    struct __ScalpiWriter__* w = &t->writers[i];
                    w->context = 0;
                    w->write = 0;
                }
            }
            
            void __ScalpiLogger_writeToSelf__(struct __ScalpiLogger__* t, const char bytes[], size_t len) {
                for (size_t i = 0; i < __arrayLen__(t->writers); i++) {
                    struct __ScalpiWriter__* w = &t->writers[i];
                    if (w->write) {
                        size_t writed = w->write(w->context, bytes, len);
                    }
                }
            }
        // __ScalpiTerminalOutput_CursorPos__
            void __ScalpiTerminalOutputCursorPos_init__(__ScalpiTerminalOutput_CursorPos__ *cursor_pos) {

                }
            // # __AppEditorHistoryNote_alloc__
                bool __AppEditorHistoryNote_alloc__(
                    struct __AppEditorHistoryNote__  **ptr
                ) {
                    return __AlignedPtr_allocAny__( ptr, __alignOf__(struct __AppEditorHistoryNote__), sizeof(struct __AppEditorHistoryNote__) );
                }
        // # __App_init__
            bool __App_init__(struct App* t) {
                bool ok = true;
                    __ScalpiLogger_init__(&t->logger); // preinit console output for debug
                    
                    if (__OsHelper_init__(&t->__App_osHelper__)) {
                        t->tick = __os_getTick__();
                        
                        if (!ok) __OsHelper_deinit__(&t->__App_osHelper__);
                    } else {
                        ok = false;
                        printf("%d app.os_helper not inited\r\n", __LINE__);
                    }
                    
                return ok;
            }
        // # __App_deinit__
            void __App_deinit__(struct App* app) {
                __OsHelper_deinit__(&app->__App_osHelper__);
            }
        // # __App_process__
            bool __App_process__(struct App* t) {
                bool ok = true;
                    __OsHelper_process__(&t->__App_osHelper__);
                return ok;
            }
        // # __App_waitToNextFrame__
            void __App_waitToNextFrame__(struct App* t) {
                uint64_t expected_frame_end_time = t->tick + __ScalpiTime_msPerS__ / __App_expectedFps__;
                uint64_t resulting_frame_end_time = __os_getTick__();
                if (resulting_frame_end_time > expected_frame_end_time + 120) {
                    uint64_t delta = resulting_frame_end_time - expected_frame_end_time;
                    printf("%d \t  hitch detection: %zu delta: %zu ms \r\n", __LINE__, t->tick, delta);
                }
                uint64_t delay_sleep = 1;
                if (resulting_frame_end_time < expected_frame_end_time) {

            return true;
        }
        
        bool real_main(int args_len, char** args_ptr) {
            bool ok = true;
                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);

                    } else {
                        ok = false;
                        printf("%d fail: __App_init__\r\n", __LINE__);
                    } 
                } else {
                    ok = false;
                    printf("%d fail tests \r\n", __LINE__);
                }
            return ok;
        }