#define Scalpi_network_tcp_http_WebSocket_Header_Size_long_extended_payload_len_size 8
                #define Scalpi_network_tcp_http_WebSocket_Header_Size_long_header (Scalpi_network_tcp_http_WebSocket_Header_Size_small_header + Scalpi_network_tcp_http_WebSocket_Header_Size_long_extended_payload_len_size)
    // auto unwrap CText to text and len
        // # __OsConsoleOutput_writeCText__
            #define __OsConsoleOutput_writeCText__(  ctx, text)  \
                    __OsConsoleOutput_write__(       ctx, text, __CText_len__(text))
    // auto casting
        // # __ScalpiMem_fillAny__
            #define __ScalpiMem_fillAny__(        dest, symbol, len) \
                    __ScalpiMem_fill__(    (char*)dest, symbol, len)
        // # __OsFile_readToAny__
            #define __OsFile_readToAny__(     file,          buffer,  buffer_len, offset ) \
                    __OsFile_readToBuffer__(  file, (char*) (buffer), buffer_len, offset )
        // # __OsMem_allocAny__
            #define __OsMem_allocAny__(                     ret_data_addr,  size) \
                    __OsMem_alloc__(          (uintptr_t*) (ret_data_addr), size)
        // # __OsMem_freeAny__

            };
        // math
            struct __Scalpi_math_d2_U_Pos__ {
                size_t x;
                size_t y;
            };
        // text
            // # __ScalpiTextFormatU64__
                struct __ScalpiTextFormatU64__ {
                    char    buffer  [__ScalpiTextCharsDecFromU64_lenMax__];
                    char    *ptr; 
                    size_t  len;
                };
            // # Scalpi_Text_Splitter
                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__

                
                uint64_t bits_rotl64(uint64_t value, unsigned int shift) {
                    shift %= 64;
                    return (value << shift) | (value >> (64 - shift));
                }
            // bytes operations
                // # __ScalpiMem_fill__
                    void __ScalpiMem_fill__(
                        char    *dest,
                        char    symbol,
                        size_t  len
                    ) {
                        for (size_t pos = 0; pos < len; pos++) {
                            dest[pos] = symbol;
                        }
                    }
                // # __ScalpiMem_copy__
                    void __ScalpiMem_copy__( // todo create macros __ScalpiMem_copyAny__
                        char        *dest,

                    }
                    return false;
                }
        // math
            uint32_t ceilDiv32(uint32_t a, uint32_t b) {
                return (a + b - 1) / b;
            }
        // __ScalpiTextFormatU64__ (utoa utos)
            // # __ScalpiTextFormatU64_do__
                void __ScalpiTextFormatU64_do__(
                    struct __ScalpiTextFormatU64__  *t,
                    uint64_t                        number, 
                    size_t                          min_width
                ) {
                    size_t len = 0;
                    uintptr_t buffer_start = (uintptr_t) &t->buffer[0];
                    uintptr_t buffer_end   = buffer_start + __ScalpiTextCharsDecFromU64_lenMax__;
                    
                    // write utoa
                    uintptr_t addr = buffer_end;

                    for (uint64_t num = number; num > 0; num = num / 10) {
                        uint8_t remainder = num % 10;

                        addr = addr - 1;
                        *(char*) addr = '0' + (char) remainder;
                    }
                    len = buffer_end - addr;
                    
                    // fill zeroes to min_width
                    if (min_width > len) {
                        size_t fill_len = min_width - len;
                        addr = addr - fill_len;
                        __ScalpiMem_fillAny__(addr, '0', fill_len);
                        len = len + fill_len;
                    }






                    
                    t->ptr = (char*) addr;
                    t->len = len;
                }
            // # __ScalpiText_formatU64ToBuffer__
                size_t __ScalpiText_formatU64ToBuffer__(
                    char     *buffer, // expected len >= __ScalpiTextCharsDecFromU64_lenMax__ 
                    uint64_t number, 
                    size_t   min_width
                ) {
                    struct __ScalpiTextFormatU64__ format;
                    __ScalpiTextFormatU64_do__(&format, number, min_width);
                    if (format.len > 0) {
                        __ScalpiMem_copy__(buffer, format.ptr, format.len);

                    }
                    return format.len;
                }
            // # __ScalpiText_formatU64__
                size_t __ScalpiText_formatU64__(__WriteFnPtrVoid__ fn_write, void* context, uint64_t number, size_t min_width) {
                    struct __ScalpiTextFormatU64__ format;
                    __ScalpiTextFormatU64_do__(&format, number, min_width);
                    fn_write(context, format.ptr, format.len);
                    return format.len;
                }
        // 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;