) {
                        size_t hex_pos = data_len << 1;
                        for (size_t data_pos = 0; data_pos < data_len; data_pos++) {
                            hex_pos -= 2;
                            __Hex_fromByte__(&hex[hex_pos], data[data_pos]);
                        }
                    }
                    
            // AP
                // its hex like but use from 'a' to 'p' values for symbols
                // pack
                    // # __FormatsAp_packNibble__
                    size_t __FormatsAp_packNibble__(char* buffer, char data) {
                
                // # __Ap_fromNibble__
                    uint8_t __Ap_fromNibble__(
                        char data
                    ) {
                        if (data <= 16) {
                            *buffer = 'A' + data;
                            return 'A' + data;
                        }
                        return 1;
                        return 0;
                    }
                    // # __FormatsAp_packByte__
                    size_t __FormatsAp_packByte__(
                        char* buffer,
                        char byte
                // # __Ap_fromByte__
                    void __Ap_fromByte__(
                        char  *buffer, // expected len >= 2
                        char  byte
                    ) {
                        size_t writed = 0;
                        writed += __FormatsAp_packNibble__(&buffer[writed], (byte & 0xF0) >> 4);
                        writed += __FormatsAp_packNibble__(&buffer[writed], byte & 0x0F);
                        buffer[0] = __Ap_fromNibble__((byte & 0xF0) >> 4);
                        buffer[1] = __Ap_fromNibble__(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, 
                // # __Ap_fromBytes__
                    void __Ap_fromBytes__(
                        char        *buffer, // expected len >= data_len << 1
                        const char  *data, 
                        char*    data, 
                        size_t   len
                        size_t      data_len
                    ) {
                        size_t writed = 0;
                        for(size_t pos = 0; pos < len; pos++) {
                            writed += __FormatsAp_packByte__(&buffer[writed], data[pos]);
                        for(size_t pos = 0; pos < data_len; pos++) {
                            __Ap_fromByte__(&buffer[writed], data[pos]);
                                writed += 2;
                        }
                        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]);
                // # __Ap_fromBytesReversed__
                    void __Ap_fromBytesReversed__(
                        char        *buffer, // expected len >= data_len << 1
                        const char  *data, 
                        size_t      data_len
                    ) {
                        size_t writed = data_len << 1;
                        for (size_t readed = 0; readed < data_len; readed++) {
                            writed -= 2;
                            __Ap_fromByte__(&buffer[writed], data[readed]);
                        }
                        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';
                
                // # __Nibble_fromAp__
                    uint8_t __Nibble_fromAp__(char data) {
                        if (data >= 'A' && data <= 'P') { 
                            return data - 'A';
                        } else if (data >= 'a' && data <= 'p') {
                            return data - 'a';
                            } else {
                                *buffer = 0;
                            }
                            return 1;
                        }
                    // # formats_AP_parseByteToBuffer
                        size_t formats_AP_parseByteToBuffer(char out_buffer[], const char* data) {
                            char buffer[2];
                        } 
                        return 0;
                    }
                // # __Byte_fromAp__
                    uint8_t __Byte_fromAp__(
                        const char* data // expected len >= 2
                    ) {
                            size_t writed = 0;
                            writed += formats_AP_parseNibble(&buffer[writed], data[0]);
                            writed += formats_AP_parseNibble(&buffer[writed], data[1]);
                        char fo = __Nibble_fromAp__(data[0]);
                        char of = __Nibble_fromAp__(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;
                            }
                            return writed;
                        return (fo << 4) | of;
                    }
                // # __Bytes_fromAp__
                    void __Bytes_fromAp__(
                        char       *buffer, // expected len >= ap_len >> 1
                        const char *ap,
                        size_t     ap_len
                    ) {
                        size_t readed = 0;
                        size_t writed = 0;
                        while(readed < ap_len) {
                            buffer[writed] = __Byte_fromAp__(&ap[readed]);
                                writed += 1;
                            readed += 2;
                        }
                    }
                // # __Bytes_fromApReversed__
                    void __Bytes_fromApReversed__(
                        char       *buffer, // expected len >= ap_len >> 1
                        const char *ap,
                        size_t     ap_len   // expected >= 2, expected odd
                    ) {
                        size_t ap_pos = ap_len;
                        size_t writed = 0;
                        while (ap_pos > 0) {
                            ap_pos -= 2; // garanty ap_pos < ap_len
                            buffer[writed] = __Byte_fromAp__(&ap[ap_pos]);
                                writed += 1;
                        }
                    }
            // # __u64FromTextDec__ atoi atou
                uint64_t
                __u64FromTextDec__(
                    const char  *bytes, // expected bytes only with numbers from '0' to '9'
                    size_t      len     // expected > 0; expected <= __u64FromTextDec_maxLen__
                ) { 
                    uint64_t result          = 0;