Qrrt KhBb e4vF 58NR
                8PTF dYk2 Sozc HexX
                4Q69 jbdQ Asrs P7B
        
        why i cancel use zig: 
            gabarages in output code.
            
            zig perfecly crash without printing stack trace in non standart situations. (main feature of zig)
                Zig does not try fix console flags before print stack trace.
                zig can crash to segfault like c.
            
            tagged enum does not sense.
                c:      tagged_enum.tag = ANOTHER_TAG;
                zig:    tagged_enum = .{.ANOTHER_TAG = tagged_enum.LAST_USED_TAG.data};
                
            operator ".?" does not sense:
                c:              while(link) { i++; link = link->next; } 
                zig:            while(link) |_| { i += 1; link = link.?.next; }
                zig idiomatic:  while(link) |unwrapped_link|{ i += 1; link = unwrapped_link.next; }
            
            nullable types are inconvenient.
                c:                  if (link) i++;
                zig idiomatic:      if (link) |_| i += 1;
                zig but C pointer:  if (@intFromPtr(link) != @intFromPtr(c.NULL)) i += 1;
    */
// TODO
    /*
        remove name buffer_len. use buffer_max_size and buffer_used instead.


    */
// macro
    // enums
        // compilation target
            // os
                #define __TargetOs_windows__ 1
                #define __TargetOs_linux__   2

            #define __TerminalInput_size__               32
        // __App__
            #define __AppEditorViewsEasyMotionHorizontal_step__  3
            #define __AppEditorViewsEasyMotionVertical_step__    2
            #define __App_expectedFps__                          30
            #define __AppEditorLineLen_max__                     (1024 * 8)
            // AppEditorTheme
                #define __AppEditorTheme_headers__ \
                    __ConsoleAnsiOutputFontStyle_start__ \
                    __ConsoleAnsiOutputFontStyle_bold__ \
                    __ConsoleAnsiOutputFontStyle_sep__ \
                    __ConsoleAnsiOutputFontStyle_bg_color_zero__ \
                    __ConsoleAnsiOutputFontStyle_sep__ \
                    __ConsoleAnsiOutputFontStyle_color_cyan__ \
                    __ConsoleAnsiOutputFontStyle_end__
                #define __AppEditorTheme_easy_motion__ \
                    __ConsoleAnsiOutputFontStyle_start__ \
                    __ConsoleAnsiOutputFontStyle_bg_color_zero__ \
                    __ConsoleAnsiOutputFontStyle_sep__ \
                    __ConsoleAnsiOutputFontStyle_color_yellow__ \
                    __ConsoleAnsiOutputFontStyle_end__
                #define __AppEditorTheme_disabled__ \
                    __ConsoleAnsiOutputFontStyle_start__  \
                    __ConsoleAnsiOutputFontStyle_bg_color_zero__  \
                    __ConsoleAnsiOutputFontStyle_sep__  \
                    __ConsoleAnsiOutputFontStyle_color_magenta__ \
                    __ConsoleAnsiOutputFontStyle_end__
                #define __AppEditorTheme_commentary__ \ 

                    #define __NetworkTcpHttpWebSocketHeaderLong__ 2
                    #define __NetworkTcpHttpWebSocketHeaderLong_flag__ 127
                    #define __NetworkTcpHttpWebSocketHeaderLongExtendedPayloadLen_size__ 8
                    #define __NetworkTcpHttpWebSocketHeaderLong_size__ (__NetworkTcpHttpWebSocketHeaderSmall_size__ + __NetworkTcpHttpWebSocketHeaderLongExtendedPayloadLen_size__)
        // time
            #define __Time_msPerS__ 1000
        // formats
            #define __u64FromTextDec_maxLen__  __CText_len__("18446744073709551615")
            #define __TextCharsDecFromU64_lenMax__  __CText_len__("18446744073709551615")
        // OsNetwork
            #define __OsNetworkTcp_maxAllowedListenPort__          49151
    // auto unwrap CText to text and len
        // # __OsConsoleOutput_writeCText__
            #define __OsConsoleOutput_writeCText__(  ctx, text)  \
                    __OsConsoleOutput_write__(       ctx, text, __CText_len__(text))

                void call_other_trace_example(
                    struct __Trace__* prev_trace // can be null
                ) {
                    struct __Trace__ trace; __Trace_init__(&trace, prev_trace, __LINE__);
                    trace.__Trace_line__ = __LINE__; print_trace_example(0, &trace);
                }
        // mem
            // bits
                uint8_t bits_rotl8(uint8_t value, unsigned int shift) {
                    shift %= 8;
                    return (value << shift) | (value >> (8 - shift));
                }
                
                uint16_t bits_rotl16(uint16_t value, unsigned int shift) {
                    shift %= 16;
                    return (value << shift) | (value >> (16 - shift));
                }
                
                uint32_t bits_rotl32(uint32_t value, unsigned int shift) {
                    shift %= 32;
                    return (value << shift) | (value >> (32 - shift));
                }
                
                uint64_t bits_rotl64(uint64_t value, unsigned int shift) {
                    shift %= 64;
                    return (value << shift) | (value >> (64 - shift));
                }
            // bytes
                // # __Mem_fill__
                    void __Mem_fill__(
                        char    *dest,
                        char    symbol,
                        size_t  len
                    ) {
                        for (size_t pos = 0; pos < len; pos++) {

                        src = &src[len - 1];
                        size_t iter = 0;
                        for(; iter < len; iter++, dest++, src--) {
                            *dest = *src;
                        }
                    }
                    
                // # __Mem_findDiffOrLen__
                    size_t __Mem_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;
                    }
                // # __Mem_isEql__
                    bool __Mem_isEql__(const char a[], const char b[], size_t len) {
                        return __Mem_findDiffOrLen__(a, b, len) == len;
                    }
                // # __Mem_isEql_test_
                    bool __Mem_isEql_test_() {
                        return true
                            and (__Mem_isEql__("abcd", "abcd", 4))
                            and (__Mem_isEql__("abcd", "abce", 4) == false)
                            and (__Mem_isEql__("abcdasdasd", "asd", 3) == false)

                                    size_t delta = indent - new_indent;
                                    __Buffer_removeIndent__(buffer, buffer_used, delta);
                                }
                            }
                        return ok;
                    }
            // Finder
                // # __Finder_init__
                void __Finder_init__(
                    struct Finder* t,
                    char* text,
                    size_t text_len,
                    char* desired,
                    size_t desired_len
                ) {
                    t->pos = 0;
                    t->text.ptr = text;
                    t->text.len = text_len;
                    t->desired.ptr = desired;
                    t->desired.len = desired_len;
                }
                // # __Finder_next__
                    bool __Finder_next__(
                        struct Finder* t,
                        size_t* out_pos
                    ) {
                    if (t->pos != t->text.len) {
                        struct Slice slice; // = t->text[->.pos..];
                            slice.ptr = &t->text.ptr[t->pos];
                            slice.len = t->text.len - t->pos;
                        size_t finded; 
                        if (__Mem_find__(&slice, &t->desired, &finded)) {
                            size_t new_pos = t->pos + finded;

                            size_t current_pos = __OsFile_getPos__(file);
                            ftruncate(file, current_pos);
                        #else
                            #error "not implemented current __target_os__ or not defined. (expected __TargetOs_ value)"
                        #endif
                    }
            // time
                 // # __os_getTick__
                 uint64_t __os_getTick__() {
                     #if __target_os__ == __TargetOs_windows__
                         FILETIME ft;
                         GetSystemTimeAsFileTime(&ft);
                         uint64_t ft64;
                         __Mem_copy__((char*) &ft64, (char*) &ft, 8);
                         return ft64 / 10000; // in ft is intervals * 100 ns. to ms need * 100 / 1000000

                                t->handle = input_hanle;
                                t->fileno = fileno(t->handle);
                            #else
                                #error "__target_os__ not implemented"
                            #endif
                        }
                // Flags
                    // # __BitsU32_enable__
                    uint32_t __BitsU32_enable__(uint32_t value, uint32_t mask) {
                        return value | mask;
                    }
                    // # __BitsU32_disable__
                    uint32_t __BitsU32_disable__(uint32_t value, uint32_t mask) {
                        return value & (~mask);
                    }
                    // # __BitsU32_toggle__
                    uint32_t __BitsU32_toggle__(uint32_t value, uint32_t mask, bool new_state) {
                        if (new_state) {
                            return __BitsU32_enable__(value, mask);
                        } else {
                            return __BitsU32_disable__(value, mask);
                        }
                    }
                    // # __OsConsoleFlags_setNonCanonicalMode__
                    bool __OsConsoleFlags_setNonCanonicalMode__(struct __OsConsoleFlags__ *t) {
                        bool ok = true;
                        #if __target_os__ == __TargetOs_windows__
                            uint32_t input = t->input_mode;
                                input = __BitsU32_toggle__(input, ENABLE_EXTENDED_FLAGS,         true);
                                input = __BitsU32_toggle__(input, ENABLE_ECHO_INPUT,             false); // print pressed keys
                                input = __BitsU32_toggle__(input, ENABLE_LINE_INPUT,             false); // wait '\n' (buffering on enter)

                                oflag  = __BitsU32_toggle__(oflag, OFDEL, false); // use null for deleted symbol
                            t->termios.c_oflag = oflag;
                        #else
                            #error "not implemented current __target_os__ or not defined. (expected __TargetOs_ value)"
                        #endif
                        return ok;
                    }
                    // # __OsConsoleFlags_apply__
                    bool __OsConsoleFlags_apply__(
                        struct __OsConsoleFlags__  *t, 
                        struct __OsConsoleInput__    *input, 
                        struct __OsConsoleOutput__ *output
                    ) {
                        // expected inited
                        

                                tcsetattr(input->fileno,                      TCSANOW, &t->termios);
                                tcsetattr(output->__OsConsoleOutput_handle__, TCSANOW, &t->termios);
                            #else
                                #error "not implemented current __target_os__ or not defined. (expected __TargetOs_ value)"
                            #endif
                        return ok;
                    }
                    // # __OsConsoleFlags_init__
                    bool __OsConsoleFlags_init__(struct __OsConsoleFlags__ *t, struct __OsConsoleInput__* input, struct __OsConsoleOutput__ *output) {
                        bool ok = true;
                            #if __target_os__ == __TargetOs_windows__
                                bool result1 = GetConsoleMode(input->handle, &t->input_mode);
                                if (result1 != 0) {
                                    bool result2 = GetConsoleMode(output->__OsConsoleOutput_handle__, &t->output_mode);
                                    if (result2 != 0) {

                            __OsConsoleOutput_write__ (NULL, data, len);
                        #else
                            #error "not implemented current __target_os__ or not defined. (expected __TargetOs_ value)"
                        #endif
                        return len;
                    }
            // Helper
                // # __OsHelper_init__
                bool __OsHelper_init__(struct __OsHelper__* t) {
                    bool ok = true;
                        #if __target_os__ == __TargetOs_windows__
                            HMODULE instance = GetModuleHandleA(NULL);
                            if (instance != NULL) {
                                t->instance = instance;
                                

                            t->console_input_handle = stdin;
                            t->console_output_handle = 1; // standart output
                        #else
                            #error "__target_os__ not implemented"
                        #endif
                    return ok;
                }
                // # __OsHelper_deinit__
                void __OsHelper_deinit__(struct __OsHelper__*t) {
                    #if __target_os__ == __TargetOs_windows__
                        #if __with_network__
                            WSACleanup();
                        #endif
                        FreeLibrary(t->instance);
                    #elif __target_os__ == __TargetOs_linux__
                        // nothing to do
                    #else
                        #error "__target_os__ not implemented"
                    #endif
                }
                // # __OsHelper_process__
                void __OsHelper_process__(struct __OsHelper__* t) {
                    #if __target_os__ == __TargetOs_windows__
                        MSG msg;
                        if (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE)) {
                            TranslateMessage(&msg);
                            DispatchMessageA(&msg);
                        }
                    #elif __target_os__ == __TargetOs_linux__
                        // nothing to do
                    #else
                        #error "__target_os__ not implemented"
                    #endif
                }
        // text
            // Splitter
                // # __TextSplitter_init__
                void __TextSplitter_init__(struct __Text_Splitter__* t, char* text, size_t text_len, char* delim, size_t delim_len) {
                    t->stop = false;
                    t->last_pos = 0;
                    __Finder_init__(&t->finder, text, text_len, delim, delim_len);
                }
                // # __TextSplitter_next__
                bool __TextSplitter_next__(struct __Text_Splitter__* t, struct Slice* out_slice) {
                    if (t->stop == false) {
                        size_t finded;
                        if (__Finder_next__(&t->finder, &finded)) {
                            out_slice->ptr = &t->finder.text.ptr[t->last_pos]; // slice = t->finder.text[t->last_pos..finded];
                            out_slice->len = finded - t->last_pos; 
                            t->last_pos = t->finder.pos;

                                    ok = false;
                                }
                                __OsFile_close__(file);
                            }
                        return ok;
                    }
        // formats
            // # __u64FromTextDec__ atoi atou
                uint64_t
                __u64FromTextDec__(
                    char    *bytes, // expected bytes only with numbers from '0' to '9'
                    size_t  len     // expected > 0; expected <= __u64FromTextDec_maxLen__
                ) { 
                    uint64_t result          = 0;
                    size_t   numerical_place = 1;
                    size_t   pos             = len - 1; // last symbol
                    while (true) {
                        char     byte  = bytes[pos];
                        uint64_t value = (uint64_t) ((uint8_t)byte - (uint8_t)'0');
                        result += value * numerical_place;
                        
                        if (pos == 0) break;
                        numerical_place *= 10;
                        pos -= 1;
                    }
                    return result;
                }
            // __TextFormatU64__ (utoa utos)
                // # __TextFormatU64_do__
                    void __TextFormatU64_do__(
                        struct __TextFormatU64__  *t,
                        uint64_t                  number, 
                        size_t                    min_width
                    ) {

                    size_t __Text_formatU64__(__WriteFnPtrVoid__ fn_write, void* context, uint64_t number, size_t min_width) {
                        struct __TextFormatU64__ format;
                        __TextFormatU64_do__(&format, number, min_width);
                        fn_write(context, format.ptr, format.len);
                        return format.len;
                    }
            // Base64
                // # Base64_getEncodeSize
                uint32_t Base64_getEncodeSize(uint32_t src_len) {
                    int blocks = ceilDiv32(src_len, 3);
                    return blocks * 4;
                }
                // # Base64_encode3Bytes
                void Base64_encode3Bytes(unsigned char in[3], char out[4]) {
                    out[0] = __Base64StandardAlphabet_chars__[(in[0] & 0b11111100) >> 2];
                    out[1] = __Base64StandardAlphabet_chars__[((in[0] & 0b00000011) << 4) | ((in[1] & 0b11110000) >> 4)];
                    out[2] = __Base64StandardAlphabet_chars__[((in[1] & 0b00001111) << 2) | ((in[2] & 0b11000000) >> 6)];
                    out[3] = __Base64StandardAlphabet_chars__[(in[2] & 0b00111111)];
                }
                // # test_rot
                bool test_rot() {
                    char a = 0b11111100 >> 2;
                    if (a == 0b00111111) {
                        return true;
                    } else {
                        printf("%d: failed test_rot.", __LINE__);
                    }
                    return false;
                }
                // # Base64_encode
                void Base64_encode(char* src, size_t src_len, char* out) {
                    // EXAMPLE
                    // Source ASCII text: "Ma"
                    // Character M               a 
                    // Octets    77 (0x4d)       97 (0x61)
                    // Bits      0 1 0 0 1 1 0 1|0 1 1 0 0 0 0 1|0 0 _ _ _ _ _ _|
                    // Base64    0 1 0 0 1 1|0 1 0 1 1 0|0 0 0 1 0 0|_ _ _ _ _ _|

                            size_t pads = 3 - extra_bytes;
                            for (char* pad = out - pads ;pad < out; pad++) {*pad = '=';}
                        }
                }
            // HEX
                #define bytesLenToHexLen(len) (len * 2)
                #define hexLenToBytesLen(len) (len >> 1)
                // # printHex
                void printHex(char* buffer_ptr, uintptr_t buffer_len) {
                    for (int i = 0; i < buffer_len; i++) {
                        printf(" %02X ", buffer_ptr[i]);
                    }
                }
                
                // parse

                            // expected hex.len is bytesLenToHexLen(len)
                            for(size_t pos = 0; pos < data_len; pos++) {
                                Hex_packByte_H(data[pos], &hex[pos * 2]);
                            }
                        }
            // AP
                // pack
                    // # __FormatsAp_packNibble__
                    size_t __FormatsAp_packNibble__(char* buffer, char data) {
                        if (data <= 16) {
                            *buffer = 'A' + data;
                        }
                        return 1;
                    }
                    // # __FormatsAp_packByte__
                    size_t __FormatsAp_packByte__(
                        char* buffer,
                        char byte
                    ) {
                        size_t writed = 0;
                        writed += __FormatsAp_packNibble__(&buffer[writed], (byte & 0xF0) >> 4);
                        writed += __FormatsAp_packNibble__(&buffer[writed], byte & 0x0F);
                        return writed;
                    }
                    // # __FormatsAp_packBytes_calculateLen__
                    size_t __FormatsAp_packBytes_calculateLen__(size_t len) {
                        return len * 2;
                    }
                    // # __FormatsAp_packBytes__
                    size_t __FormatsAp_packBytes__(
                        char*    buffer, 
                        char*    data, 
                        size_t   len
                    ) {
                        size_t writed = 0;
                        for(size_t pos = 0; pos < len; pos++) {
                            writed += __FormatsAp_packByte__(&buffer[writed], data[pos]);
                        }
                        return writed;
                    }
                    // # __FormatsAp_writeToBuffer__
                    size_t __FormatsAp_writeToBuffer__(char buffer[], const char data[], size_t len) {
                        size_t writed = 0;
                        for(size_t pos = 0; pos < len; pos++) {
                            writed += __FormatsAp_packByte__(&buffer[writed], data[pos]);
                        }
                        return writed;
                    }
                
                // parse
                    // # formats_AP_parseNibble
                    size_t formats_AP_parseNibble(char* buffer, char data) {
                        if (data >= 'A' && data <= 'P') {
                            *buffer = data - 'A';
                        } else if (data >= 'a' && data <= 'p') {
                            *buffer = data - 'a';
                        } else {
                            *buffer = 0;
                        }
                        return 1;
                    }
                    // # formats_AP_parseByteToBuffer
                    size_t formats_AP_parseByteToBuffer(char out_buffer[], const char* data) {
                        char buffer[2];
                        size_t writed = 0;
                        writed += formats_AP_parseNibble(&buffer[writed], data[0]);
                        writed += formats_AP_parseNibble(&buffer[writed], data[1]);
                        *out_buffer = (buffer[0] << 4) | buffer[1];
                        return 1;
                    }
                    // # formats_AP_parseToBuffer
                    size_t formats_AP_parseToBuffer(char buffer[], const char *ap, size_t ap_len) {
                        size_t writed = 0;
                        size_t readed = 0;
                        while(readed < ap_len) {
                            writed += formats_AP_parseByteToBuffer(&buffer[writed], &ap[readed]);
                            readed += 2;
                        }

                    for (size_t pos = 0; pos < dest_len; pos++) {
                        dest[pos] = a[pos] ^ b[ci];
                        ci += 1;
                        if (ci == b_len) ci = 0;
                    }
                }
        // __Logger__
            // # __Logger_init__
            void __Logger_init__ (struct __Logger__* t) {
                for (int i = 0; i < __arrayLen__(t->writers); i++) {
                    struct __Writer__* w = &t->writers[i];
                    w->context = 0;
                    w->write = 0;
                }
            }
            // # __Logger_writeToSelf__
            void __Logger_writeToSelf__(struct __Logger__* t, const char bytes[], size_t len) {
                for (size_t i = 0; i < __arrayLen__(t->writers); i++) {
                    struct __Writer__* w = &t->writers[i];
                    if (w->write) {
                        size_t writed = w->write(w->context, bytes, len);
                    }
                }

        #ifndef __COMPILED_FROM_ZIG_FILE__
            int main(int args_len, char** args_ptr) {
                trace_example();
                if (real_main(args_len, args_ptr)) return 0;
                return 1;
            }
        #endif
// TODO port this zig code to C
    /*
        const Utf8 = struct {
            const BytesIterator = struct {
                const Parsed = struct {
                    num: u64 = 0,
                    bytes: []const u8 = &.{},
                    
                    fn is_connector(t: *Parsed) bool {
                        if (t.num == 0x200D) return true;
                        return false;
                    }
                };
                
                const Iterator = struct {
                    bytes: []const u8,
                    pos: usize = 0,
                    
                    fn next(t: *Iterator) ?Parsed {
                        //                Masks:
                        //| 1 byte | 2 byte | 3 byte | 4 byte
                        //
                        // 0xxxxxxx
                        // 110xxxxx 10xxxxxx
                        // 1110xxxx 10xxxxxx 10xxxxxx
                        // 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
                        
                        // example "?"
                        // 208  --  110 10000
                        // 159  --  10       011111
                        //      is
                        // 1055 --  000 10000011111
                        
                        parse: {
                            var parsed: Parsed = .{};
                            
                            // 1 byte
                            if (t.bytes.len <= t.pos) break :parse;
                            const b1 = t.bytes[t.pos];
                            const c1: u64 = @intCast(b1);
                            if (checkMask(b1, 0, 0b10000000)) { // 0xxxxxxx
                                parsed.num = b1 & 0b01111111;
                                parsed.bytes = t.bytes[t.pos .. t.pos + 1];
                                t.pos += 1;
                                return parsed;
                            }
                            
                            // 2 byte
                            if (t.bytes.len <= t.pos + 1) break :parse;
                            const b2 = t.bytes[t.pos + 1];
                            const c2: u64 = @intCast(b2);
                            if (checkMask(b1, 0b11000000, 0b11100000)) { // 110xxxxx
                                parsed.num = ((c1 & 31) << 6) + (c2 & 63);
                                parsed.bytes = t.bytes[t.pos .. t.pos + 2];
                                t.pos += 2;
                                return parsed;
                            }
                            
                            // 3 byte
                            if (t.bytes.len <= t.pos + 2) break :parse;
                            const b3 = t.bytes[t.pos + 2];
                            const c3: u64 = @intCast(b3);
                            if (checkMask(b1, 0b11100000, 0b11110000)) { // 1110xxxx
                                parsed.num = ((c1 & 15) << 12) + ((c2 & 63) << 6) + (c3 & 63);
                                parsed.bytes = t.bytes[t.pos .. t.pos + 3];
                                t.pos += 3;
                                return parsed;
                            }
                            
                            // 4 byte
                            if (t.bytes.len <= t.pos + 3) break :parse;
                            const b4 = t.bytes[t.pos + 3];
                            const c4: u64 = @intCast(b4);
                            if (checkMask(b1, 0b11110000, 0b11111000)) { // 11110xxx
                                parsed.num = ((c1 & 7) << 21) + ((c2 & 63) << 12) + ((c3 & 63) << 6) + (c4 & 63);
                                parsed.bytes = t.bytes[t.pos .. t.pos + 4];
                                t.pos += 4;
                                return parsed;
                            }
                        }
                        t.pos += 1;
                        return null;
                    }
                };
                
                fn checkMask(num: u8, mask: u8, used_bits: u8) bool {
                    if (num & used_bits == mask) {
                        return true;
                    } else {
                        return false;
                    }
                }
                
                fn fromDo(bytes: []const u8) Iterator {
                    return Iterator{ .bytes = bytes };
                }
            };
        };
    */