// mouse
            #define ansi_input_mouse_release  __ConsoleAnsi_control__  "?1000l"
            #define ansi_input_mouse_grab     __ConsoleAnsi_control__  "?1000h"
        // settings
            #define __ConsoleAnsiOutputSettings_enableLineWrap__   __ConsoleAnsi_control__ "?7h"
            #define __ConsoleAnsiOutputSettings_disableLineWrap__  __ConsoleAnsi_control__ "?7l"
    #define __NetworkWsQuery_expected__      "GET /ws"
    #define __TextCharsDecFromU64_lenMax__   __CText_len__("18446744073709551615")
    #define __Base64StandardAlphabet_chars__ "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
    // # __OsFilePath_separator__
        #if __target_os__ == __TargetOs_windows__
            #define __OsFilePath_separator__ "\\"
        #elif __target_os__ == __TargetOs_linux__
            #define __OsFilePath_separator__ "/"
        #else

                struct __Console__   console;
                struct __Terminal__  terminal;
                struct __AppEditor__ editor;
                int64_t              tick; // time ms
                bool                 working;
            };
// function prototypes





    void   __MemList_init__(             struct __MemList__* list);
    bool   __Mem_isEql__(                const char a[], const char b[], size_t len);
    size_t __ZText_countLen__(           const char text[]);
    size_t __Text_countIndent__(         char* text, size_t text_len, size_t tab_size);
    void   __OsFile_truncate__(          __OsFileHandle__ file);
    void   __OsFile_setPos__(            __OsFileHandle__ file, size_t pos);
    bool   __OsFile_exist__(             const char* file_name, size_t file_name_len);
    bool   __OsMem_alloc__(              uintptr_t *ret_data_addr, size_t size);
    void   __OsMem_free__(               uintptr_t ret_data_addr);
    size_t __OsFallbackConsole_write__(  void* unused_ctx, char* data, size_t len);
    char   __crypto_sumBytes__(          const char *data, size_t data_len);
    char   __crypto_xorBytes__(          const char *data, size_t data_len);
    void   __CryptoScalpiHash_do__(      struct __CryptoScalpiHash__ *t, const char *src, size_t src_size, char *dest, size_t dest_size);
    void   __CryptoScalpiHash_reset__(   struct __CryptoScalpiHash__ *t);
// globals
    struct __AppEditorViewsVTable__        __AppEditorViewsVtable_flat__;
    struct __AppEditorViewsVTable__        __AppEditorViewsVtable_folded__;
    struct __App__                         __app__;
    void                                   *__AppEditorViewsEasyMotionHorizontal_context__;
    const struct __AppEditorViewsVTable__  *__AppEditorViewsEasyMotionHorizontalContext_vtable__;
    void                                   *__AppEditorViewsEasyMotionVertical_context__;

                        size_t* out_pos
                    ) {
                        if (t->pos != t->text.len) {
                            char   *data     = &t->text.ptr[t->pos];
                            size_t data_len = t->text.len - t->pos;
                            size_t finded    = 0; 
                            if ( true
                                and data_len >= &t->desired.len
                                and data_len >= t->desired.len
                                and __Mem_find__(
                                    &finded,
                                    data,
                                    data_len,
                                    t->desired.ptr,
                                    t->desired.len

                        list->count -= 1;
                    }
                // # __MemList_init__
                    void __MemList_init__(
                        struct __MemList__* list
                    ) {
                        list->first = NULL;
                                list->last = NULL;
                        list->count = 0;
                    }
            // tree
                // # __MemTree_isChild__
                    bool __MemTree_isChild__ (
                        struct __MemTree__ *tree // expected child
                    ) {

                    void __Bytes_fromHex__(
                        char*  buffer_ptr, // expected len >= hex_len >> 2
                        char*  hex,
                        size_t hex_len
                    ) {
                        size_t end_pos = hex_len >> 1;
                        for(size_t pos = 0; pos < end_pos; pos++) {
                            char parsed = __Byte_fromHex__(&hex[pos*2]);
                            buffer_ptr[pos] = parsed;
                        }
                    }
                // # __HexCapital_fromNibble__
                    char Hex_packNibble_H(char data) {
                        if (data <= 9) return '0' + data;
                        if (data <= 15) return 'A' + data - 10;
                        return 0;
                    }
                // # __HexCapital_fromByte__
                    void Hex_packByte_H(char data, char* hex_byte) {
                        hex_byte[0] = Hex_packNibble_H((data & 0xF0) >> 4);
                        hex_byte[1] = Hex_packNibble_H(data & 0x0F);
                    }
                // # __HexCapital_fromBytes__
                    void Hex_pack_H(char* hex, char* data, size_t data_len) {
                        // expected hex.len is __Hex_lenFromBytesLen__(len)
                        for(size_t pos = 0; pos < data_len; pos++) {
                            Hex_packByte_H(data[pos], &hex[pos * 2]);
                        }

                // # __Hex_fromBytes__
                    void __Hex_fromBytes__(
                        char    *hex, // expected len >= __Hex_lenFromBytesLen__(data_len)
                        char    *data,
                        size_t  data_len
                    ) {
                        for(size_t pos = 0; pos < data_len; pos++) {
                            size_t hex_pos = pos << 1;
                            __Hex_fromByte__(&hex[hex_pos], data[pos]);
                        }
                    }
                // # __FormatsHex_packBytesReverse__
                    void __FormatsHex_packBytesReverse__(
                        char    *hex,    // expected len >= __Hex_lenFromBytesLen__(data_len)
                        char    *data,
                        size_t  data_len // expected >= 1

                        struct __CryptoScalpiHash__ *t
                    ) {
                        t->mask = 0b00001111;
                        t->a = 0;
                        t->b = 0;
                    }
            // # __crypto_sumBytes__
                char __crypto_sumBytes__(
                    const char  *data,
                    size_t      data_len
                ) {
                    char ret = 0;
                    for (size_t pos = 0; pos < data_len; pos++) {
                        ret += data[pos];
                    }
                    return ret;
                }
            // # __crypto_xorBytes__
                char __crypto_xorBytes__(
                    const char  *data,
                    size_t      data_len
                ) {
                    char ret = 0;
                    for (size_t pos = 0; pos < data_len; pos++) {
                        ret ^= data[pos];
                    }