Ceasar Cipher Inverse Hex 256 Bytes

#include <string>
#include <ctype.h>
#include "CeasarCipher.h"
#include <iostream>
#include <iomanip>
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>

#include <cstring>
#include <regex>
#include <codecvt>
#include <locale>
#include <vector>
#define WIN32_LEAN_AND_MEAN
#pragma comment(lib, "ws2_32.lib")
#pragma comment(lib, "Winmm.lib")

#include <windows.h>
#include <Mmsystem.h>
#include <timeapi.h>
#include <time.h>
#include <cassert>
#include <iterator>
#include <shlobj.h>
#include <shlwapi.h>
#include <objbase.h>
#include <inttypes.h>
#include "GETHASHKEY.h"
#include "base64.h"

#pragma warning(disable : 4996)
#pragma execution_character_set("utf-8")

int numletter;
std::string EnterMessages;
const wchar_t* str;
#include <cstddef>
#include <bitset>
typedef unsigned char BYTES;
#include <sstream>
#include <fstream>

#include <tchar.h>
#include <stdexcept>
#include <math.h>
#include "md5.h"

#include <memory>
#include <climits>
#include <array>

char* chars;
int count = 0;

void ToWidePath(const std::string& value, std::wstring& target) {
    wchar_t buffer[MAX_PATH];
    MultiByteToWideChar(CP_UTF8, 0, value.c_str(), -1, buffer, MAX_PATH);
    target = buffer;
}

void ToNarrowPath(const std::wstring& value, std::string& target) {
    char buffer[MAX_PATH];
    WideCharToMultiByte(CP_UTF8, 0, value.c_str(), -1, buffer, MAX_PATH, NULL, NULL);
    target = buffer;
}
char* mytest;
char* mytest2;
std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;

std::string latin_to_utf82(const char* utf8Path)
{
    std::string doublequote = "\"";
    std::string ui8 = "u8" + doublequote;
    std::string u7 = ui8 + utf8Path;
    std::string u = u7 + doublequote;
    std::string us = u;
    std::wstring wideUtf8Path = converter.from_bytes(u);
    std::string newline = "\n";
    std::string narrow;
    ToNarrowPath(wideUtf8Path, narrow);
    mytest = new char[narrow.length() + 1];
    strcpy(mytest, narrow.c_str());
    printf(mytest);
    return mytest;
}

std::string CeasarCipher::Encrypt(std::string Message, int Shift) {
    std::string EncryptedMessage = "\0";
    for (int i = 0; i < Message.length(); i++) {
        if (!isalpha(Message[i])) {
            EncryptedMessage += Message[i];
        }
        else if (isupper(Message[i])) {
            EncryptedMessage += char(int(Message[i] + Shift - 65) % 26 + 65);
        }
        else {
            EncryptedMessage += char(int(Message[i] + Shift - 97) % 26 + 97);
        }
    }
    return EncryptedMessage;
}
std::string CeasarCipher::Decrypt(std::string Message, int Shift) {
    std::string DecryptedMessage = "\0";
    Shift = 26 - Shift;
    for (int i = 0; i < Message.length(); i++) {
        if (!isalpha(Message[i])) {
            DecryptedMessage += Message[i];
        }
        else if (isupper(Message[i])) {
            DecryptedMessage += char(int(Message[i] + Shift - 65) % 26 + 65);
        }
        else {
            DecryptedMessage += char(int(Message[i] + Shift - 97) % 26 + 97);
        }
    }
    return DecryptedMessage;
}


class X {
public:
    char message[25555];
    char ch;
    int i;
    int key;
    int array;
    int lens;
};

std::string messages;
int num1;
int num2;
void CeasarCipher::Ceasar() {
    char opt = '\0';
    std::string Message = "\0";
    int Shift = 0;
    X x;
    while (true) {
        system("cls");
        Message = "";
        std::cout << "Ceasar Cipher by Thunder\n";
        std::cout << "1. Encrypt\n";
        std::cout << "2. Decrypt\n";
        std::cout << "3. Return\n";
        std::cout << "   Option: ";
        opt = _getche();
        std::cout << "\n";
        switch (opt) {
        case '1' :
            std::cout << "\nEnter Message to Encrypt: ";
            std::getline(std::cin, Message);
            num1 = Message.length();
            std::cout << "\nEncrypted: " << CeasarCipher::Encrypt(Message, num1) << "\n";
            system("pause");
            break;
        case '2':
            std::cout << "\nEnter Message to Decrypt: ";
            std::getline(std::cin, Message);
            num2 = Message.length();
            std::cout << "\nDecrypted: " << CeasarCipher::Decrypt(Message, num2) << "\n";
            system("pause");
            break;
        case '3':
            return;
            break;
        default:
            break;
        }
    }
}

std::wstring wideUtf8Path;

BYTES* handindex;
uintptr_t u_handindex;

//function to convert string to byte array
void string2ByteArray(char* input, BYTE* output)
{
    int loop;
    int i;

    loop = 0;
    i = 0;

    while (input[loop] != '\0')
    {
        output[i++] = input[loop++];
    }
}

//int myhash;

int stringtochararray(std::string s)
{
    char* p = new char[s.length() + 1];
    strcpy(p, s.c_str());
    int i;
    for (i = 0; i < sizeof(p); i++) {
        p[i] = s[i];
        std::cout << p[i];
    }
    return (char)p;
}


char* charconvert;
char* charconverter;
char* charconverted;
std::string textconvert;
std::string textconverter;
int ceasarcipherencode(std::string messages)
{
    X x{};
    std::string newline = "\n";
    messages = messages + newline;
    x.message[messages.length() + 1];
    strcpy(x.message, messages.c_str());
    numletter = strlen(x.message);
    if (numletter > 1)
    {
        x.key = +1;
    }
    if (numletter > 80)
    {
        x.key = +2;
    }
    for (x.i = 0; x.message[x.i] != '\0'; ++x.i) {
        x.ch = x.message[x.i];
        if (x.ch >= 'a' && x.ch <= 'z') {
            x.ch = x.ch + x.key;
            if (x.ch > 'z') {
                x.ch = x.ch - 'z' + 'a' - 1;
            }
            x.message[x.i] = x.ch;
        }
        else if (x.ch >= '0' && x.ch <= '9')
        {
            x.ch = x.ch - x.key;
            x.message[x.i] = x.ch;
            if (x.ch == '/') {
                x.ch = x.ch + 10;
                x.message[x.i] = x.ch;
            }
            if (x.ch == '.') {
                x.ch = x.ch + 10;
                x.message[x.i] = x.ch;
            }
        }
        else if (x.ch >= 'A' && x.ch <= 'Z') {
            x.ch = x.ch + x.key;
            if (x.ch > 'a') {
                x.ch = x.ch - 'Z' + 'A' - 1;
            }
            x.message[x.i] = x.ch;
        }
    }
    //std::cout << "Encrypted message: " << x.message << std::endl;
    /*return (char)mytest2;*/
    textconvert = x.message;
    return 0;
}
int ceasarcipherdecode(std::string messages)
{
    X x{};
    std::string newline = "\n";
    messages = messages + newline;
    x.message[messages.length() + 1];
    strcpy(x.message, messages.c_str());
    numletter = strlen(x.message);
    if (numletter > 1)
    {
        x.key = +1;
    }
    if (numletter > 10)
    {
        x.key = +1;
    }
    if (numletter > 80)
    {
        x.key = +2;
    }
    for (x.i = 0; x.message[x.i] != '\0'; ++x.i) {
        x.ch = x.message[x.i];
        if (x.ch >= 'a' && x.ch <= 'z') {
            x.ch = x.ch - x.key;
            if (x.ch < 'a') {
                x.ch = x.ch + 'z' - 'a' + 1;
            }
            x.message[x.i] = x.ch;
        }
        else if (x.ch >= '0' && x.ch <= '9')
        {
            x.ch = x.ch + x.key;
            x.message[x.i] = x.ch;
            if (x.ch == ':') {
                x.ch = x.ch - 10;
                x.message[x.i] = x.ch;
            }
            if (x.ch == ';') {
                x.ch = x.ch - 10;
                x.message[x.i] = x.ch;
            }

        }

        else if (x.ch >= 'A' && x.ch <= 'Z') {
            x.ch = x.ch - x.key;
            if (x.ch > 'a') {
                x.ch = x.ch + 'Z' - 'A' + 1;
            }
            x.message[x.i] = x.ch;
        }
    }
    /*std::cout << "Decrypted message: " << x.message << std::endl;*/
    textconverter = x.message;
    return 0;
}

int number1;
int number2;

DWORD serialnumber = 0, maxcomponentlen = 0, filesystemflags = 0;
DWORD sizez;
std::string ConvertToString(DWORD value) { std::stringstream ss;    ss << std::hex << value;    return ss.str(); }
#define MAX_size 255
char systemfile[MAX_size];
std::string chartostring(char* charto) { return std::string(charto); }
char* stringtochar(std::string stringto) { char* stch = new char[stringto.length() + 1];    strcpy(stch, stringto.c_str()); return (char*)stch; }
char* TcharArrayToCharArray(TCHAR ARRAYs[MAX_size]) { char* arr[MAX_size];  wcstombs((char*)arr, ARRAYs, wcslen(ARRAYs) + 1); return ((char*)arr); }


char* stringtochar2(std::string stringstring) { char* string2char = const_cast<char*>(stringstring.c_str());    return string2char; }

std::wstring s2ws(const std::string& s) {   int len;    int slength = (int)s.length() + 1;  len = MultiByteToWideChar(CP_ACP, 0, s.c_str(), slength, 0, 0); std::wstring r(len, L'\0'); MultiByteToWideChar(CP_ACP, 0, s.c_str(), slength, &r[0], len); return r;   }
std::string ws2s(const std::wstring& s) {   int len;    int slength = (int)s.length() + 1;  len = WideCharToMultiByte(CP_ACP, 0, s.c_str(), slength, 0, 0, 0, 0);   std::string r(len, '\0');   WideCharToMultiByte(CP_ACP, 0, s.c_str(), slength, &r[0], len, 0, 0);   return r;   }

std::string numberserial;
std::string componentlenmax;
std::string md;

struct ImVec4
{
    float                                   x, y, z, w;
    ImVec4() { x = y = z = w = 0.0f; }
    ImVec4(float _x, float _y, float _z, float _w) { x = _x; y = _y; z = _z; w = _w; }
#ifdef IM_VEC4_CLASS_EXTRA
    IM_VEC4_CLASS_EXTRA     // Define additional constructors and implicit cast operators in imconfig.h to convert back and forth between your math types and ImVec4.
#endif
};
static inline float  ImSaturate(float f) { return (f < 0.0f) ? 0.0f : (f > 1.0f) ? 1.0f : f; }
#define IM_F32_TO_INT8_SAT(_VAL)        ((int)(ImSaturate(_VAL) * 255.0f + 0.5f))               // Saturated, always output 0..255

ImVec4 ColorConvertU32ToFloat42(DWORD in)
{
    /*float s = 1.0f / 255.0f;*/
    /*return ImVec4(
        ((in >> IM_COL32_R_SHIFT) & 0xFF) * s,
        ((in >> IM_COL32_G_SHIFT) & 0xFF) * s,
        ((in >> IM_COL32_B_SHIFT) & 0xFF) * s,
        ((in >> IM_COL32_A_SHIFT) & 0xFF) * s);*/
    float xf;
    float yf;
    float zf;
    float wf;
    xf = (float)((in & 0xFF000000) >> 24) / 255;
    yf = (float)((in & 0x00FF0000) >> 16) / 255;
    zf = (float)((in & 0x0000FF00) >> 8) / 255;
    wf = (float)((in & 0x000000FF)) / 255;
    return ImVec4(xf, yf, zf, wf);
}
typedef unsigned int        ImU32;  // 32-bit unsigned integer (often used to store packed colors)
ImU32 ColorConvertFloat4ToU322(const ImVec4& in)
{
    ImU32 out;
    out = ((ImU32)IM_F32_TO_INT8_SAT(in.x)) << 24;
    out |= ((ImU32)IM_F32_TO_INT8_SAT(in.y)) << 16;
    out |= ((ImU32)IM_F32_TO_INT8_SAT(in.z)) << 8;
    out |= ((ImU32)IM_F32_TO_INT8_SAT(in.w));
    return out;
}

static ImVec4 ImGuiCol_Text;
DWORD ImGuiCol2_Text;
std::string ImGuiCol1_Text = "";
std::string ImVec4tostring(ImVec4 ImGuiCol_Text2)
{
    ImGuiCol2_Text = ColorConvertFloat4ToU322(ImGuiCol_Text2);
    std::stringstream hcolor;
    hcolor << std::hex << ImGuiCol2_Text;
    ImGuiCol1_Text = hcolor.str();
    return ImGuiCol1_Text;
}

static ImVec4 ImGuiCol_TextDisabled;
DWORD stringtodword(std::string stringto)
{
    DWORD Value;
    std::stringstream scolorhex;
    scolorhex << std::hex << stringto;
    scolorhex >> Value;
    ImGuiCol_TextDisabled = ColorConvertU32ToFloat42(Value);
    return Value;
}

int hwidinfo()
{
    char hwid[4096];
    // total physical memory
    MEMORYSTATUSEX statex;
    statex.dwLength = sizeof(statex);
    GlobalMemoryStatusEx(&statex);
    sprintf_s(hwid, "%I64i", statex.ullTotalPhys / 1024);
    TCHAR volumename[MAX_PATH + 1] = { 0 };
    TCHAR filesystemname[MAX_PATH + 1] = { 0 };
    // volume information
    GetVolumeInformation(_T("C:\\"), volumename, ARRAYSIZE(volumename), &serialnumber, &maxcomponentlen, &filesystemflags, filesystemname, ARRAYSIZE(filesystemname));
    TCHAR computerName[MAX_COMPUTERNAME_LENGTH + 1];
    sizez = sizeof(computerName) / sizeof(computerName[0]);
    GetComputerName(computerName, &sizez);
    numberserial = (char*)ConvertToString(serialnumber).c_str();
    componentlenmax = (char*)ConvertToString(maxcomponentlen).c_str();
    wcstombs(systemfile, filesystemname, wcslen(filesystemname) + 1);
    std::string addall = hwid + numberserial + systemfile + componentlenmax + "\n";
    md = md5(addall) + "\n";
    printf((char*)md.c_str());
    system("pause");
    return 0;
}

char* ar;
ImVec4 ImGuiCol_Text22;
ImVec4 ImGuiCol_Text23;
ImVec4 ImGuiCol_Text24;
ImVec4 ImGuiCol_Text25;
ImVec4 ImGuiCol_Text26;

float x2, y2, z2, w2, x4, y4, z4, w4;
char buffer[64];
int ret;
std::string stringSTRING1;
std::string STRINGstring2;
std::string stringSTRING3;
std::string STRINGstring4;
std::string stringSTRING5;
std::string STRINGstring6;
DWORD messagesenter;

std::string string_to_hex(const std::string& input)
{
    static const char hex_digits[] = "0123456789ABCDEF";

    std::string output;
    output.reserve(input.length() * 2);
    for (unsigned char c : input)
    {
        output.push_back(hex_digits[c >> 4]);
        output.push_back(hex_digits[c & 15]);
    }
    return output;
}

int hex_value(unsigned char hex_digit)
{
    static const signed char hex_values[256] = {
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         0,  1,  2,  3,  4,  5,  6,  7,  8,  9, -1, -1, -1, -1, -1, -1,
        -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
        -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
    };
    int value = hex_values[hex_digit];
    if (value == -1) throw std::invalid_argument("invalid hex digit");
    return value;
}

std::string hex_to_string(const std::string& input)
{
    const auto len = input.length();
    if (len & 1) throw std::invalid_argument("bad length");

    std::string output;
    output.reserve(len / 2);
    for (auto it = input.begin(); it != input.end(); )
    {
        int hi = hex_value(*it++);
        int lo = hex_value(*it++);
        output.push_back(hi << 4 | lo);
    }
    return output;
}
std::string urltodecodebase64;
std::string decodedurlbase64;

void decodeurlbase64caller() {
    std::string decoded = base64_decode((urltodecodebase64.c_str()));
    decodedurlbase64 = decoded;
}

std::string urltoencodebase64;
std::string encodedurlbase64;

void encodeurlbase64caller() {
    int lens = urltoencodebase64.length();
    std::string encoded = base64_encode((unsigned char const*)urltoencodebase64.c_str(), lens);
    encodedurlbase64 = encoded;
}

std::string cipherizer;
std::string cipherizer2;
std::string bytesString;
char* bytes8;
class Yz
{
public:
    char bytes2[255];
    bool bool2;
    bool bool4;
    bool bool6;
    bool bool8;
};
std::stringstream streamstring;
std::string byteschanges;
std::string changebytes;
int i;
Yz yz;
std::string linestring;
std::stringstream linesstream;
int countstring()
{
    for (int i = 0; i < ciphcea::lines; i++)
    {
        linesstream << i;
        linesstream >> linestring;
        std::istringstream stream(ciphcea::line.c_str());
        std::string linescode;
        std::getline(stream, linestring) >> linescode;
    }
    return 0;
}
DWORD Value = {};
std::string convert;
std::string convert1;
std::string convert2;
std::string convert3;
std::string convert4;
std::string convert5;
std::string convert6;
std::string convert7;
std::string convert8;
std::string convert9;
std::string convert10;
std::string convert11;
std::string convert12;
std::string convert13;
std::string convert14;
std::string convert15;
std::string convert16;
std::string convert17;
std::string convert18;
std::string convert19;
std::string convert20;
std::string convert21;
std::string convert22;
std::string convert23;
std::string convert24;
std::string convert25;
std::string convert26;
std::string convert27;
std::string convert28;
std::string convert29;
std::string convert30;
std::string convert31;
std::string convert32;
std::string laststring00;
std::string laststring01;
std::string laststring02;
std::string laststring03;
std::string laststring04;
std::string laststring05;
std::string laststring06;
std::string laststring07;
std::string laststring08;
std::string laststring09;
std::string laststring010;
std::string laststring011;
std::string laststring012;
std::string laststring013;
std::string laststring014;
std::string laststring015;
std::string laststring016;
std::string laststring017;
std::string laststring018;
std::string laststring019;
std::string laststring020;
std::string laststring021;
std::string laststring022;
std::string laststring023;
std::string laststring024;
std::string laststring025;
std::string laststring026;
std::string laststring027;
std::string laststring028;
std::string laststring029;
std::string laststring030;
std::string laststring031;
std::string laststring032;
bool bytesbool1 = 0;
bool bytesbool2 = 0;
bool bytesbool3 = 0;
bool bytesbool4 = 0;
bool bytesbool5 = 0;
bool bytesbool6 = 0;
bool bytesbool7 = 0;
bool bytesbool8 = 0;
bool bytesbool9 = 0;
bool bytesbool10 = 0;
bool bytesbool11 = 0;
bool bytesbool12 = 0;
bool bytesbool13 = 0;
bool bytesbool14 = 0;
bool bytesbool15 = 0;
bool bytesbool16 = 0;
bool bytesbool17 = 0;
bool bytesbool18 = 0;
bool bytesbool19 = 0;
bool bytesbool20 = 0;
bool bytesbool21 = 0;
bool bytesbool22 = 0;
bool bytesbool23 = 0;
bool bytesbool24 = 0;
bool bytesbool25 = 0;
bool bytesbool26 = 0;
bool bytesbool27 = 0;
bool bytesbool28 = 0;
bool bytesbool29 = 0;
bool bytesbool30 = 0;
bool bytesbool31 = 0;
bool bytesbool32 = 0;
char char0 = { };
char char1 = { };
char char2 = { };
char char3 = { };
char char4 = { };
char char5 = { };
char char6 = { };
char char7 = { };
char char8 = { };
char char9 = { };
char char10 = { };
char char11 = { };
char char12 = { };
char char13 = { };
char char14 = { };
char char15 = { };
char char16 = { };
char char17 = { };
char char18 = { };
char char19 = { };
char char20 = { };
char char21 = { };
char char22 = { };
char char23 = { };
char char24 = { };
char char25 = { };
char char26 = { };
char char27 = { };
char char28 = { };
char char29 = { };
char char30 = { };
char char31 = { };
char char32 = { };
char char33 = { };
char char34 = { };
char char35 = { };
char char36 = { };
char char37 = { };
char char38 = { };
char char39 = { };
char char40 = { };
char char41 = { };
char char42 = { };
char char43 = { };
char char44 = { };
char char45 = { };
char char46 = { };
char char47 = { };
char char48 = { };
char char49 = { };
char char50 = { };
char char51 = { };
char char52 = { };
char char53 = { };
char char54 = { };
char char55 = { };
char char56 = { };
char char57 = { };
char char58 = { };
char char59 = { };
char char60 = { };
char char61 = { };
char char62 = { };
char char63 = { };
char char64 = { };
char char65 = { };
char char66 = { };
char char67 = { };
char char68 = { };
char char69 = { };
char char70 = { };
char char71 = { };
char char72 = { };
char char73 = { };
char char74 = { };
char char75 = { };
char char76 = { };
char char77 = { };
char char78 = { };
char char79 = { };
char char80 = { };
char char81 = { };
char char82 = { };
char char83 = { };
char char84 = { };
char char85 = { };
char char86 = { };
char char87 = { };
char char88 = { };
char char89 = { };
char char90 = { };
char char91 = { };
char char92 = { };
char char93 = { };
char char94 = { };
char char95 = { };
char char96 = { };
char char97 = { };
char char98 = { };
char char99 = { };
char char100 = { };
char char101 = { };
char char102 = { };
char char103 = { };
char char104 = { };
char char105 = { };
char char106 = { };
char char107 = { };
char char108 = { };
char char109 = { };
char char110 = { };
char char111 = { };
char char112 = { };
char char113 = { };
char char114 = { };
char char115 = { };
char char116 = { };
char char117 = { };
char char118 = { };
char char119 = { };
char char120 = { };
char char121 = { };
char char122 = { };
char char123 = { };
char char124 = { };
char char125 = { };
char char126 = { };
char char127 = { };
char char128 = { };
char char129 = { };
char char130 = { };
char char131 = { };
char char132 = { };
char char133 = { };
char char134 = { };
char char135 = { };
char char136 = { };
char char137 = { };
char char138 = { };
char char139 = { };
char char140 = { };
char char141 = { };
char char142 = { };
char char143 = { };
char char144 = { };
char char145 = { };
char char146 = { };
char char147 = { };
char char148 = { };
char char149 = { };
char char150 = { };
char char151 = { };
char char152 = { };
char char153 = { };
char char154 = { };
char char155 = { };
char char156 = { };
char char157 = { };
char char158 = { };
char char159 = { };
char char160 = { };
char char161 = { };
char char162 = { };
char char163 = { };
char char164 = { };
char char165 = { };
char char166 = { };
char char167 = { };
char char168 = { };
char char169 = { };
char char170 = { };
char char171 = { };
char char172 = { };
char char173 = { };
char char174 = { };
char char175 = { };
char char176 = { };
char char177 = { };
char char178 = { };
char char179 = { };
char char180 = { };
char char181 = { };
char char182 = { };
char char183 = { };
char char184 = { };
char char185 = { };
char char186 = { };
char char187 = { };
char char188 = { };
char char189 = { };
char char190 = { };
char char191 = { };
char char192 = { };
char char193 = { };
char char194 = { };
char char195 = { };
char char196 = { };
char char197 = { };
char char198 = { };
char char199 = { };
char char200 = { };
char char201 = { };
char char202 = { };
char char203 = { };
char char204 = { };
char char205 = { };
char char206 = { };
char char207 = { };
char char208 = { };
char char209 = { };
char char210 = { };
char char211 = { };
char char212 = { };
char char213 = { };
char char214 = { };
char char215 = { };
char char216 = { };
char char217 = { };
char char218 = { };
char char219 = { };
char char220 = { };
char char221 = { };
char char222 = { };
char char223 = { };
char char224 = { };
char char225 = { };
char char226 = { };
char char227 = { };
char char228 = { };
char char229 = { };
char char230 = { };
char char231 = { };
char char232 = { };
char char233 = { };
char char234 = { };
char char235 = { };
char char236 = { };
char char237 = { };
char char238 = { };
char char239 = { };
char char240 = { };
char char241 = { };
char char242 = { };
char char243 = { };
char char244 = { };
char char245 = { };
char char246 = { };
char char247 = { };
char char248 = { };
char char249 = { };
char char250 = { };
char char251 = { };
char char252 = { };
char char253 = { };
char char254 = { };
char char255 = { };
char char256 = { };
char char257 = { };
char char258 = { };
char char259 = { };
char char260 = { };
char char261 = { };
char char262 = { };
char char263 = { };
char char264 = { };
char char265 = { };
char char266 = { };
char char267 = { };
char char268 = { };
int linesize;
int encodehex(char char0, char char1, char char2, char char3, char char4, char char5, char char6, char char7)
{
    std::string s0(1, char0);
    std::string s1(1, char1);
    std::string s2(1, char2);
    std::string s3(1, char3);
    std::string s4(1, char4);
    std::string s5(1, char5);
    std::string s6(1, char6);
    std::string s7(1, char7);
    std::string laststring = s0 + s1;
    std::string laststring1 = laststring + s2;
    std::string laststring2 = laststring1 + s3;
    std::string laststring3 = laststring2 + s4;
    std::string laststring4 = laststring3 + s5;
    std::string laststring5 = laststring4 + s6;
    std::string laststring6 = laststring5 + s7;
    /*std::cout << laststring6 << " \n";*/
    laststring00 = laststring6;

    std::stringstream ss2;
    ss2 << std::hex << laststring6;
    ss2 >> Value;
    ImGuiCol_Text22 = ColorConvertU32ToFloat42(Value);
    x2 = ImGuiCol_Text22.x;
    y2 = ImGuiCol_Text22.y;
    z2 = ImGuiCol_Text22.z;
    w2 = ImGuiCol_Text22.w;
    ImGuiCol_Text23 = { x2, y2, z2, w2 };
    stringSTRING1 = ImVec4tostring(ImGuiCol_Text23);
    STRINGstring2 = stringSTRING1 + "\n";
    charconvert = new char[STRINGstring2.length() + 1];
    strcpy(charconvert, STRINGstring2.c_str());
    //printf(charconvert);
    ImGuiCol_Text24 = { w2, z2, y2, x2 };
    stringSTRING3 = ImVec4tostring(ImGuiCol_Text24);
    STRINGstring4 = stringSTRING3 + "\n";
    charconverter = new char[STRINGstring4.length() + 1];
    strcpy(charconverter, STRINGstring4.c_str());
    //printf(charconverter);
    convert = stringSTRING3;
    /*return (char)convert1.c_str();*/
    return 0;
}
int checkline(int linesize2)
{
    for (int j = 0; j < linesize2; j++) {
    if (j < 8)
    {
        bytesbool1 = 1;
    }
    if (j > 8 && j < 16)
    {
        bytesbool2 = 1;
    }
    if (j > 16 && j < 24)
    {
        bytesbool3 = 1;
    }
    if (j > 24 && j < 32)
    {
        bytesbool4 = 1;
    }
    if (j > 32 && j < 40)
    {
        bytesbool5 = 1;
    }
    if (j > 40 && j < 48)
    {
        bytesbool6 = 1;
    }
    if (j > 48 && j < 56)
    {
        bytesbool7 = 1;
    }
    if (j > 56 && j < 64)
    {
        bytesbool8 = 1;
    }
    if (j > 64 && j < 72)
    {
        bytesbool9 = 1;
    }
    if (j > 72 && j < 80)
    {
        bytesbool10 = 1;
    }
    if (j > 80 && j < 88)
    {
        bytesbool11 = 1;
    }
    if (j > 88 && j < 96)
    {
        bytesbool12 = 1;
    }
    if (j > 96 && j < 104)
    {
        bytesbool13 = 1;
    }
    if (j > 104 && j < 112)
    {
        bytesbool14 = 1;
    }
    if (j > 112 && j < 120)
    {
        bytesbool15 = 1;
    }
    if (j > 120 && j < 128)
    {
        bytesbool16 = 1;
    }
    if (j > 128 && j < 136)
    {
        bytesbool17 = 1;
    }
    if (j > 136 && j < 144)
    {
        bytesbool18 = 1;
    }
    if (j > 144 && j < 152)
    {
        bytesbool19 = 1;
    }
    if (j > 152 && j < 160)
    {
        bytesbool20 = 1;
    }
    if (j > 160 && j < 168)
    {
        bytesbool21 = 1;
    }
    if (j > 168 && j < 176)
    {
        bytesbool22 = 1;
    }
    if (j > 176 && j < 184)
    {
        bytesbool23 = 1;
    }
    if (j > 184 && j < 192)
    {
        bytesbool24 = 1;
    }
    if (j > 192 && j < 200)
    {
        bytesbool25 = 1;
    }
    if (j > 200 && j < 208)
    {
        bytesbool26 = 1;
    }
    if (j > 208 && j < 216)
    {
        bytesbool27 = 1;
    }
    if (j > 216 && j < 224)
    {
        bytesbool28 = 1;
    }
    if (j > 224 && j < 232)
    {
        bytesbool29 = 1;
    }
    if (j > 232 && j < 240)
    {
        bytesbool30 = 1;
    }
    if (j > 240 && j < 248)
    {
        bytesbool31 = 1;
    }
    if (j > 248 && j < 256)
    {
        bytesbool32 = 1;
    }
    }
    return 0;
}
int ciphcea::charbytes8()
{
    countstring();
    std::cout << ciphcea::line << std::endl;
    mytest = new char[ciphcea::line.length() + 1];
    strcpy(mytest, ciphcea::line.c_str());
    ceasarcipherencode(mytest);
    printf((char*)textconvert.c_str());
    cipherizer = textconvert;
    urltoencodebase64 = cipherizer;
    encodeurlbase64caller();
    printf("\n");
    std::cout << encodedurlbase64 << std::endl;
    bytesString = string_to_hex(encodedurlbase64);
    bytes8 = new char[bytesString.length() + 1];
    strcpy(bytes8, bytesString.c_str());
    printf("\n");
    std::cout << bytes8 << std::endl;
    printf("\n");
    linesize = bytesString.length();
    int linesize2 = linesize;
    for (i = 0; i < linesize2; i++) {
        if (i < 8)
        {
            std::cout << bytes8[i];
            char0 = bytes8[0];
            char1 = bytes8[1];
            char2 = bytes8[2];
            char3 = bytes8[3];
            char4 = bytes8[4];
            char5 = bytes8[5];
            char6 = bytes8[6];
            char7 = bytes8[7];
            bytesbool1 = 1;
        }
        if (i == 8)
        {
            printf(" ");
            std::cout << bytes8[i];
            char8 = bytes8[8];
        }
        if (i > 8 && i < 16)
        {
            std::cout << bytes8[i];
            char9 = bytes8[9];
            char10 = bytes8[10];
            char11 = bytes8[11];
            char12 = bytes8[12];
            char13 = bytes8[13];
            char14 = bytes8[14];
            char15 = bytes8[15];
            bytesbool2 = 1;
        }
        if (i == 16)
        {
            printf(" ");
            std::cout << bytes8[i];
            char16 = bytes8[16];
        }
        if (i > 16 && i < 24)
        {
            std::cout << bytes8[i];
            char17 = bytes8[17];
            char18 = bytes8[18];
            char19 = bytes8[19];
            char20 = bytes8[20];
            char21 = bytes8[21];
            char22 = bytes8[22];
            char23 = bytes8[23];
            bytesbool3 = 1;
        }
        if (i == 24)
        {
            printf(" ");
            std::cout << bytes8[i];
            char24 = bytes8[24];
        }
        if (i > 24 && i < 32)
        {
            std::cout << bytes8[i];
            char25 = bytes8[25];
            char26 = bytes8[26];
            char27 = bytes8[27];
            char28 = bytes8[28];
            char29 = bytes8[29];
            char30 = bytes8[30];
            char31 = bytes8[31];
            bytesbool4 = 1;
        }
        if (i == 32)
        {
            printf(" ");
            std::cout << bytes8[i];
            char32 = bytes8[32];
        }
        if (i > 32 && i < 40)
        {
            std::cout << bytes8[i];
            char33 = bytes8[33];
            char34 = bytes8[34];
            char35 = bytes8[35];
            char36 = bytes8[36];
            char37 = bytes8[37];
            char38 = bytes8[38];
            char39 = bytes8[39];
            bytesbool5 = 1;
        }
        if (i == 40)
        {
            printf(" ");
            std::cout << bytes8[i];
            char40 = bytes8[40];
        }
        if (i > 40 && i < 48)
        {
            std::cout << bytes8[i];
            char41 = bytes8[41];
            char42 = bytes8[42];
            char43 = bytes8[43];
            char44 = bytes8[44];
            char45 = bytes8[45];
            char46 = bytes8[46];
            char47 = bytes8[47];
            bytesbool6 = 1;
        }
        if (i == 48)
        {
            printf(" ");
            std::cout << bytes8[i];
            char48 = bytes8[48];
        }
        if (i > 48 && i < 56)
        {
            std::cout << bytes8[i];
            char49 = bytes8[49];
            char50 = bytes8[50];
            char51 = bytes8[51];
            char52 = bytes8[52];
            char53 = bytes8[53];
            char54 = bytes8[54];
            char55 = bytes8[55];
            bytesbool7 = 1;
        }
        if (i == 56)
        {
            printf(" ");
            std::cout << bytes8[i];
            char56 = bytes8[56];
        }
        if (i > 56 && i < 64)
        {
            std::cout << bytes8[i];
            char57 = bytes8[57];
            char58 = bytes8[58];
            char59 = bytes8[59];
            char60 = bytes8[60];
            char61 = bytes8[61];
            char62 = bytes8[62];
            char63 = bytes8[63];
            bytesbool8 = 1;
        }
        if (i == 64)
        {
            printf(" ");
            std::cout << bytes8[i];
            char64 = bytes8[64];
        }
        if (i > 64 && i < 72)
        {
            std::cout << bytes8[i];
            char65 = bytes8[65];
            char66 = bytes8[66];
            char67 = bytes8[67];
            char68 = bytes8[68];
            char69 = bytes8[69];
            char70 = bytes8[70];
            char71 = bytes8[71];
            bytesbool9 = 1;
        }
        if (i == 72)
        {
            printf(" ");
            std::cout << bytes8[i];
            char72 = bytes8[72];
        }
        if (i > 72 && i < 80)
        {
            std::cout << bytes8[i];
            char73 = bytes8[73];
            char74 = bytes8[74];
            char75 = bytes8[75];
            char76 = bytes8[76];
            char77 = bytes8[77];
            char78 = bytes8[78];
            char79 = bytes8[79];
            bytesbool10 = 1;
        }
        if (i == 80)
        {
            printf(" ");
            std::cout << bytes8[i];
            char80 = bytes8[80];
        }
        if (i > 80 && i < 88)
        {
            std::cout << bytes8[i];
            char81 = bytes8[81];
            char82 = bytes8[82];
            char83 = bytes8[83];
            char84 = bytes8[84];
            char85 = bytes8[85];
            char86 = bytes8[86];
            char87 = bytes8[87];
            bytesbool11 = 1;
        }
        if (i == 88)
        {
            printf(" ");
            std::cout << bytes8[i];
            char88 = bytes8[88];
        }
        if (i > 88 && i < 96)
        {
            std::cout << bytes8[i];
            char89 = bytes8[89];
            char90 = bytes8[90];
            char91 = bytes8[91];
            char92 = bytes8[92];
            char93 = bytes8[93];
            char94 = bytes8[94];
            char95 = bytes8[95];
            bytesbool12 = 1;
        }
        if (i == 96)
        {
            printf(" ");
            std::cout << bytes8[i];
            char96 = bytes8[96];
        }
        if (i > 96 && i < 104)
        {
            std::cout << bytes8[i];
            char97 = bytes8[97];
            char98 = bytes8[98];
            char99 = bytes8[99];
            char100 = bytes8[100];
            char101 = bytes8[101];
            char102 = bytes8[102];
            char103 = bytes8[103];
            bytesbool13 = 1;
        }
        if (i == 104)
        {
            printf(" ");
            std::cout << bytes8[i];
            char104 = bytes8[104];
        }
        if (i > 104 && i < 112)
        {
            std::cout << bytes8[i];
            char105 = bytes8[105];
            char106 = bytes8[106];
            char107 = bytes8[107];
            char108 = bytes8[108];
            char109 = bytes8[109];
            char110 = bytes8[110];
            char111 = bytes8[111];
            bytesbool14 = 1;
        }
        if (i == 112)
        {
            printf(" ");
            std::cout << bytes8[i];
            char112 = bytes8[112];
        }
        if (i > 112 && i < 120)
        {
            std::cout << bytes8[i];
            char113 = bytes8[113];
            char114 = bytes8[114];
            char115 = bytes8[115];
            char116 = bytes8[116];
            char117 = bytes8[117];
            char118 = bytes8[118];
            char119 = bytes8[119];
            bytesbool15 = 1;
        }
        if (i == 120)
        {
            printf(" ");
            std::cout << bytes8[i];
            char120 = bytes8[120];
        }
        if (i > 120 && i < 128)
        {
            std::cout << bytes8[i];
            char121 = bytes8[121];
            char122 = bytes8[122];
            char123 = bytes8[123];
            char124 = bytes8[124];
            char125 = bytes8[125];
            char126 = bytes8[126];
            char127 = bytes8[127];
            bytesbool16 = 1;
        }
        if (i == 128)
        {
            printf(" ");
            std::cout << bytes8[i];
            char128 = bytes8[128];
        }
        if (i > 128 && i < 136)
        {
            std::cout << bytes8[i];
            char129 = bytes8[129];
            char130 = bytes8[130];
            char131 = bytes8[131];
            char132 = bytes8[132];
            char133 = bytes8[133];
            char134 = bytes8[134];
            char135 = bytes8[135];
            bytesbool17 = 1;
        }
        if (i == 136)
        {
            printf(" ");
            std::cout << bytes8[i];
            char136 = bytes8[136];
        }
        if (i > 136 && i < 144)
        {
            std::cout << bytes8[i];
            char137 = bytes8[137];
            char138 = bytes8[138];
            char139 = bytes8[139];
            char140 = bytes8[140];
            char141 = bytes8[141];
            char142 = bytes8[142];
            char143 = bytes8[143];
            bytesbool18 = 1;
        }
        if (i == 144)
        {
            printf(" ");
            std::cout << bytes8[i];
            char144 = bytes8[144];
        }
        if (i > 144 && i < 152)
        {
            std::cout << bytes8[i];
            char145 = bytes8[145];
            char146 = bytes8[146];
            char147 = bytes8[147];
            char148 = bytes8[148];
            char149 = bytes8[149];
            char150 = bytes8[150];
            char151 = bytes8[151];
            bytesbool19 = 1;
        }
        if (i == 152)
        {
            printf(" ");
            std::cout << bytes8[i];
            char152 = bytes8[152];
        }
        if (i > 152 && i < 160)
        {
            std::cout << bytes8[i];
            char153 = bytes8[153];
            char154 = bytes8[154];
            char155 = bytes8[155];
            char156 = bytes8[156];
            char157 = bytes8[157];
            char158 = bytes8[158];
            char159 = bytes8[159];
            bytesbool20 = 1;
        }
        if (i == 160)
        {
            printf(" ");
            std::cout << bytes8[i];
            char160 = bytes8[160];
        }
        if (i > 160 && i < 168)
        {
            std::cout << bytes8[i];
            char161 = bytes8[161];
            char162 = bytes8[162];
            char163 = bytes8[163];
            char164 = bytes8[164];
            char165 = bytes8[165];
            char166 = bytes8[166];
            char167 = bytes8[167];
            bytesbool21 = 1;
        }
        if (i == 168)
        {
            printf(" ");
            std::cout << bytes8[i];
            char168 = bytes8[168];
        }
        if (i > 168 && i < 176)
        {
            std::cout << bytes8[i];
            char169 = bytes8[169];
            char170 = bytes8[170];
            char171 = bytes8[171];
            char172 = bytes8[172];
            char173 = bytes8[173];
            char174 = bytes8[174];
            char175 = bytes8[175];
            bytesbool22 = 1;
        }
        if (i == 176)
        {
            printf(" ");
            std::cout << bytes8[i];
            char176 = bytes8[176];
        }
        if (i > 176 && i < 184)
        {
            std::cout << bytes8[i];
            char177 = bytes8[177];
            char178 = bytes8[178];
            char179 = bytes8[179];
            char180 = bytes8[180];
            char181 = bytes8[181];
            char182 = bytes8[182];
            char183 = bytes8[183];
            bytesbool23 = 1;
        }
        if (i == 184)
        {
            printf(" ");
            std::cout << bytes8[i];
            char184 = bytes8[184];
        }
        if (i > 184 && i < 192)
        {
            std::cout << bytes8[i];
            char185 = bytes8[185];
            char186 = bytes8[186];
            char187 = bytes8[187];
            char188 = bytes8[188];
            char189 = bytes8[189];
            char190 = bytes8[190];
            char191 = bytes8[191];
            bytesbool24 = 1;
        }
        if (i == 192)
        {
            printf(" ");
            std::cout << bytes8[i];
            char192 = bytes8[192];
        }
        if (i > 192 && i < 200)
        {
            std::cout << bytes8[i];
            char193 = bytes8[193];
            char194 = bytes8[194];
            char195 = bytes8[195];
            char196 = bytes8[196];
            char197 = bytes8[197];
            char198 = bytes8[198];
            char199 = bytes8[199];
            bytesbool25 = 1;
        }
        if (i == 200)
        {
            printf(" ");
            std::cout << bytes8[i];
            char200 = bytes8[200];
        }
        if (i > 200 && i < 208)
        {
            std::cout << bytes8[i];
            char201 = bytes8[201];
            char202 = bytes8[202];
            char203 = bytes8[203];
            char204 = bytes8[204];
            char205 = bytes8[205];
            char206 = bytes8[206];
            char207 = bytes8[207];
            bytesbool26 = 1;
        }
        if (i == 208)
        {
            printf(" ");
            std::cout << bytes8[i];
            char208 = bytes8[208];
        }
        if (i > 208 && i < 216)
        {
            std::cout << bytes8[i];
            char209 = bytes8[209];
            char210 = bytes8[210];
            char211 = bytes8[211];
            char212 = bytes8[212];
            char213 = bytes8[213];
            char214 = bytes8[214];
            char215 = bytes8[215];
            bytesbool27 = 1;
        }
        if (i == 216)
        {
            printf(" ");
            std::cout << bytes8[i];
            char216 = bytes8[216];
        }
        if (i > 216 && i < 224)
        {
            std::cout << bytes8[i];
            char217 = bytes8[217];
            char218 = bytes8[218];
            char219 = bytes8[219];
            char220 = bytes8[220];
            char221 = bytes8[221];
            char222 = bytes8[222];
            char223 = bytes8[223];
            bytesbool28 = 1;
        }
        if (i == 224)
        {
            printf(" ");
            std::cout << bytes8[i];
            char224 = bytes8[224];
        }
        if (i > 224 && i < 232)
        {
            std::cout << bytes8[i];
            char225 = bytes8[225];
            char226 = bytes8[226];
            char227 = bytes8[227];
            char228 = bytes8[228];
            char229 = bytes8[229];
            char230 = bytes8[230];
            char231 = bytes8[231];
            bytesbool29 = 1;
        }
        if (i == 232)
        {
            printf(" ");
            std::cout << bytes8[i];
            char232 = bytes8[232];
        }
        if (i > 232 && i < 240)
        {
            std::cout << bytes8[i];
            char233 = bytes8[233];
            char234 = bytes8[234];
            char235 = bytes8[235];
            char236 = bytes8[236];
            char237 = bytes8[237];
            char238 = bytes8[238];
            char239 = bytes8[239];
            bytesbool30 = 1;
        }
        if (i == 240)
        {
            printf(" ");
            std::cout << bytes8[i];
            char240 = bytes8[240];
        }
        if (i > 240 && i < 248)
        {
            std::cout << bytes8[i];
            char241 = bytes8[241];
            char242 = bytes8[242];
            char243 = bytes8[243];
            char244 = bytes8[244];
            char245 = bytes8[245];
            char246 = bytes8[246];
            char247 = bytes8[247];
            bytesbool31 = 1;
        }
        if (i == 248)
        {
            printf(" ");
            std::cout << bytes8[i];
            char248 = bytes8[248];
        }
        if (i > 248 && i < 256)
        {
            std::cout << bytes8[i];
            char249 = bytes8[249];
            char250 = bytes8[250];
            char251 = bytes8[251];
            char252 = bytes8[252];
            char253 = bytes8[253];
            char254 = bytes8[254];
            char255 = bytes8[255];
            bytesbool32 = 1;
        }
    }
    checkline(linesize2);
    int bytesint;
    printf("\n");
        if (bytesbool1 == 1)
        {
            encodehex(char0, char1, char2, char3, char4, char5, char6, char7);
            laststring01 = laststring00;
            convert1 = convert;
            bytesbool1 = 0;
            bytesint = 1;
        }
        if (bytesbool2 == 1)
        {
            encodehex(char8, char9, char10, char11, char12, char13, char14, char15);
            laststring02 = laststring00;
            convert2 = convert;
            bytesbool2 = 0;
            bytesint = 2;
        }
        if (bytesbool3 == 1)
        {
            encodehex(char16, char17, char18, char19, char20, char21, char22, char23);
            laststring03 = laststring00;
            convert3 = convert;
            bytesbool3 = 0;
            bytesint = 3;
        }
        if (bytesbool4 == 1)
        {
            encodehex(char24, char25, char26, char27, char28, char29, char30, char31);
            laststring04 = laststring00;
            convert4 = convert;
            bytesbool4 = 0;
            bytesint = 4;
        }
        if (bytesbool5 == 1)
        {
            encodehex(char32, char33, char34, char35, char36, char37, char38, char39);
            laststring05 = laststring00;
            convert5 = convert;
            bytesbool5 = 0;
            bytesint = 5;
        }
        if (bytesbool6 == 1)
        {
            encodehex(char40, char41, char42, char43, char44, char45, char46, char47);
            laststring06 = laststring00;
            convert6 = convert;
            bytesbool6 = 0;
            bytesint = 6;
        }
        if (bytesbool7 == 1)
        {
            encodehex(char48, char49, char50, char51, char52, char53, char54, char55);
            laststring07 = laststring00;
            convert7 = convert;
            bytesbool7 = 0;
            bytesint = 7;
        }
        if (bytesbool8 == 1)
        {
            encodehex(char56, char57, char58, char59, char60, char61, char62, char63);
            laststring08 = laststring00;
            convert8 = convert;
            bytesbool8 = 0;
            bytesint = 8;
        }
        if (bytesbool9 == 1)
        {
            encodehex(char64, char65, char66, char67, char68, char69, char70, char71);
            laststring09 = laststring00;
            convert9 = convert;
            bytesbool9 = 0;
            bytesint = 9;
        }
        if (bytesbool10 == 1)
        {
            encodehex(char72, char73, char74, char75, char76, char77, char78, char79);
            laststring010 = laststring00;
            convert10 = convert;
            bytesbool10 = 0;
            bytesint = 10;
        }
        if (bytesbool11 == 1)
        {
            encodehex(char80, char81, char82, char83, char84, char85, char86, char87);
            laststring011 = laststring00;
            convert11 = convert;
            bytesbool11 = 0;
            bytesint = 11;
        }
        if (bytesbool12 == 1)
        {
            encodehex(char88, char89, char90, char91, char92, char93, char94, char95);
            laststring012 = laststring00;
            convert12 = convert;
            bytesbool12 = 0;
            bytesint = 12;
        }
        if (bytesbool13 == 1)
        {
            encodehex(char96, char97, char98, char99, char100, char101, char102, char103);
            laststring013 = laststring00;
            convert13 = convert;
            bytesbool13 = 0;
            bytesint = 13;
        }
        if (bytesbool14 == 1)
        {
            encodehex(char104, char105, char106, char107, char108, char109, char110, char111);
            laststring014 = laststring00;
            convert14 = convert;
            bytesbool14 = 0;
            bytesint = 14;
        }
        if (bytesbool15 == 1)
        {
            encodehex(char112, char113, char114, char115, char116, char117, char118, char119);
            laststring015 = laststring00;
            convert15 = convert;
            bytesbool15 = 0;
            bytesint = 15;
        }
        if (bytesbool16 == 1)
        {
            encodehex(char120, char121, char122, char123, char124, char125, char126, char127);
            laststring016 = laststring00;
            convert16 = convert;
            bytesbool16 = 0;
            bytesint = 16;
        }
        if (bytesbool17 == 1)
        {
            encodehex(char128, char129, char130, char131, char132, char133, char134, char135);
            laststring017 = laststring00;
            convert17 = convert;
            bytesbool17 = 0;
            bytesint = 17;
        }
        if (bytesbool18 == 1)
        {
            encodehex(char136, char137, char138, char139, char140, char141, char142, char143);
            laststring018 = laststring00;
            convert18 = convert;
            bytesbool18 = 0;
            bytesint = 18;
        }
        if (bytesbool19 == 1)
        {
            encodehex(char144, char145, char146, char147, char148, char149, char150, char151);
            laststring019 = laststring00;
            convert19 = convert;
            bytesbool19 = 0;
            bytesint = 19;
        }
        if (bytesbool20 == 1)
        {
            encodehex(char152, char153, char154, char155, char156, char157, char158, char159);
            laststring020 = laststring00;
            convert20 = convert;
            bytesbool20 = 0;
            bytesint = 20;
        }
        if (bytesbool21 == 1)
        {
            encodehex(char160, char161, char162, char163, char164, char165, char166, char167);
            laststring021 = laststring00;
            convert21 = convert;
            bytesbool21 = 0;
            bytesint = 21;
        }
        if (bytesbool22 == 1)
        {
            encodehex(char168, char169, char170, char171, char172, char173, char174, char175);
            laststring022 = laststring00;
            convert22 = convert;
            bytesbool22 = 0;
            bytesint = 22;
        }
        if (bytesbool23 == 1)
        {
            encodehex(char176, char177, char178, char179, char180, char181, char182, char183);
            laststring023 = laststring00;
            convert23 = convert;
            bytesbool23 = 0;
            bytesint = 23;
        }
        if (bytesbool24 == 1)
        {
            encodehex(char184, char185, char186, char187, char188, char189, char190, char191);
            laststring024 = laststring00;
            convert24 = convert;
            bytesbool24 = 0;
            bytesint = 24;
        }
        if (bytesbool25 == 1)
        {
            encodehex(char192, char193, char194, char195, char196, char197, char198, char199);
            laststring025 = laststring00;
            convert25 = convert;
            bytesbool25 = 0;
            bytesint = 25;
        }
        if (bytesbool26 == 1)
        {
            encodehex(char200, char201, char202, char203, char204, char205, char206, char207);
            laststring026 = laststring00;
            convert26 = convert;
            bytesbool26 = 0;
            bytesint = 26;
        }
        if (bytesbool27 == 1)
        {
            encodehex(char208, char209, char210, char211, char212, char213, char214, char215);
            laststring027 = laststring00;
            convert27 = convert;
            bytesbool27 = 0;
            bytesint = 27;
        }
        if (bytesbool28 == 1)
        {
            encodehex(char216, char217, char218, char219, char220, char221, char222, char223);
            laststring028 = laststring00;
            convert28 = convert;
            bytesbool28 = 0;
            bytesint = 28;
        }
        if (bytesbool29 == 1)
        {
            encodehex(char224, char225, char226, char227, char228, char229, char230, char231);
            laststring029 = laststring00;
            convert29 = convert;
            bytesbool29 = 0;
            bytesint = 29;
        }
        if (bytesbool30 == 1)
        {
            encodehex(char232, char233, char234, char235, char236, char237, char238, char239);
            laststring030 = laststring00;
            convert30 = convert;
            bytesbool30 = 0;
            bytesint = 30;
        }
        if (bytesbool31 == 1)
        {
            encodehex(char240, char241, char242, char243, char244, char245, char246, char247);
            laststring031 = laststring00;
            convert31 = convert;
            bytesbool31 = 0;
            bytesint = 31;
        }
        if (bytesbool32 == 1)
        {
            encodehex(char248, char249, char250, char251, char252, char253, char254, char255);
            laststring032 = laststring00;
            convert32 = convert;
            bytesbool32 = 0;
            bytesint = 32;
        }
        printf("\n");
        std::string thelaststring1 = laststring01 + laststring02;
        std::string thelaststring2 = laststring03 + laststring04;
        std::string thelaststring3 = laststring05 + laststring06;
        std::string thelaststring4 = laststring07 + laststring08;
        std::string thelaststring5 = laststring09 + laststring010;
        std::string thelaststring6 = laststring011 + laststring012;
        std::string thelaststring7 = laststring013 + laststring014;
        std::string thelaststring8 = laststring015 + laststring016;
        std::string thelaststring9 = laststring017 + laststring018;
        std::string thelaststring10 = laststring019 + laststring020;
        std::string thelaststring11 = laststring021 + laststring022;
        std::string thelaststring12 = laststring023 + laststring024;
        std::string thelaststring13 = laststring025 + laststring026;
        std::string thelaststring14 = laststring027 + laststring028;
        std::string thelaststring15 = laststring029 + laststring030;
        std::string thelaststring16 = laststring031 + laststring032;
        std::string thelaststring17 = thelaststring1 + thelaststring2;
        std::string thelaststring18 = thelaststring3 + thelaststring4;
        std::string thelaststring19 = thelaststring5 + thelaststring6;
        std::string thelaststring20 = thelaststring7 + thelaststring8;
        std::string thelaststring21 = thelaststring9 + thelaststring10;
        std::string thelaststring22 = thelaststring11 + thelaststring12;
        std::string thelaststring23 = thelaststring13 + thelaststring14;
        std::string thelaststring24 = thelaststring15 + thelaststring16;
        std::string thelaststring25 = thelaststring17 + thelaststring18;
        std::string thelaststring26 = thelaststring19 + thelaststring20;
        std::string thelaststring27 = thelaststring21 + thelaststring22;
        std::string thelaststring28 = thelaststring23 + thelaststring24;
        std::string thelaststring29 = thelaststring25 + thelaststring26;
        std::string thelaststring30 = thelaststring27 + thelaststring28;
        std::string thelaststring31 = thelaststring29 + thelaststring30;
        std::cout << thelaststring31 << std::endl;
        printf("\n");
        std::string convertfile1 = convert1 + " " + convert2;
        std::string convertfile2 = convert3 + " " + convert4;
        std::string convertfile3 = convert5 + " " + convert6;
        std::string convertfile4 = convert7 + " " + convert8;
        std::string convertfile5 = convert9 + " " + convert10;
        std::string convertfile6 = convert11 + " " + convert12;
        std::string convertfile7 = convert13 + " " + convert14;
        std::string convertfile8 = convert15 + " " + convert16;
        std::string convertfile9 = convert17 + " " + convert18;
        std::string convertfile10 = convert19 + " " + convert20;
        std::string convertfile11 = convert21 + " " + convert22;
        std::string convertfile12 = convert23 + " " + convert24;
        std::string convertfile13 = convert25 + " " + convert26;
        std::string convertfile14 = convert27 + " " + convert28;
        std::string convertfile15 = convert29 + " " + convert30;
        std::string convertfile16 = convert31 + " " + convert32;
        std::string convertfile17 = convertfile1 + " " + convertfile2;
        std::string convertfile18 = convertfile3 + " " + convertfile4;
        std::string convertfile19 = convertfile5 + " " + convertfile6;
        std::string convertfile20 = convertfile7 + " " + convertfile8;
        std::string convertfile21 = convertfile9 + " " + convertfile10;
        std::string convertfile22 = convertfile11 + " " + convertfile12;
        std::string convertfile23 = convertfile13 + " " + convertfile14;
        std::string convertfile24 = convertfile15 + " " + convertfile16;
        std::string convertfile25 = convertfile17 + " " + convertfile18;
        std::string convertfile26 = convertfile19 + " " + convertfile20;
        std::string convertfile27 = convertfile21 + " " + convertfile22;
        std::string convertfile28 = convertfile23 + " " + convertfile24;
        std::string convertfile29 = convertfile25 + " " + convertfile26;
        std::string convertfile30 = convertfile27 + " " + convertfile28;
        std::string convertfile31 = convertfile29 + " " + convertfile30;
        printf("\n");
        std::cout << convertfile31 << std::endl;
        std::string bytesString3 = convertfile31;
        std::string space = " ";
        std::string space2 = "  ";
        std::string nospace = "";
        size_t pos = bytesString3.find(space2);
        while (pos != std::string::npos)
        {
            bytesString3.replace(pos, space2.size(), nospace);
            pos = bytesString3.find(space2, pos + nospace.size());
        }
        std::string bytesString4 = bytesString3;
        size_t pos2 = bytesString4.find(space);
        while (pos2 != std::string::npos)
        {
            bytesString4.replace(pos2, space.size(), nospace);
            pos2 = bytesString4.find(space, pos2 + nospace.size());
        }
        printf("\n");
        std::cout << bytesString4 << std::endl;
        printf("\n");
        std::string bytesString5 = bytesString;
        std::string::size_type rep = bytesString5.find(thelaststring31);
        if (rep != std::string::npos)
            bytesString5.replace(rep, thelaststring31.length(), bytesString4);
        std::cout << bytesString5 << std::endl;
        laststring01 = "";
        laststring02 = "";
        laststring03 = "";
        laststring04 = "";
        laststring05 = "";
        laststring06 = "";
        laststring07 = "";
        laststring08 = "";
        laststring09 = "";
        laststring010 = "";
        laststring011 = "";
        laststring012 = "";
        laststring013 = "";
        laststring014 = "";
        laststring015 = "";
        laststring016 = "";
        laststring017 = "";
        laststring018 = "";
        laststring019 = "";
        laststring020 = "";
        laststring021 = "";
        laststring022 = "";
        laststring023 = "";
        laststring024 = "";
        laststring025 = "";
        laststring026 = "";
        laststring027 = "";
        laststring028 = "";
        laststring029 = "";
        laststring030 = "";
        laststring031 = "";
        laststring032 = "";
    return 0;
}
int decodehex(char char0, char char1, char char2, char char3, char char4, char char5, char char6, char char7)
{
    std::string s0(1, char0);
    std::string s1(1, char1);
    std::string s2(1, char2);
    std::string s3(1, char3);
    std::string s4(1, char4);
    std::string s5(1, char5);
    std::string s6(1, char6);
    std::string s7(1, char7);
    std::string laststring = s0 + s1;
    std::string laststring1 = laststring + s2;
    std::string laststring2 = laststring1 + s3;
    std::string laststring3 = laststring2 + s4;
    std::string laststring4 = laststring3 + s5;
    std::string laststring5 = laststring4 + s6;
    std::string laststring6 = laststring5 + s7;
    laststring00 = laststring6;
    std::stringstream ss2;
    ss2 << std::hex << laststring6;
    ss2 >> Value;
    ImGuiCol_Text25 = ColorConvertU32ToFloat42(Value);
    x4 = ImGuiCol_Text25.x;
    y4 = ImGuiCol_Text25.y;
    z4 = ImGuiCol_Text25.z;
    w4 = ImGuiCol_Text25.w;
    ImGuiCol_Text26 = { w4, z4, y4, x4 };
    stringSTRING5 = ImVec4tostring(ImGuiCol_Text26);
    STRINGstring6 = stringSTRING5 + "\n";
    charconverted = new char[STRINGstring6.length() + 1];
    strcpy(charconverted, STRINGstring6.c_str());
    convert = stringSTRING5;
    return 0;
}
int ciphcea::decodecharbytes8()
{
    countstring();
    printf("\n");
    std::cout << ciphcea::line << std::endl;
    printf("\n");
    bytes8 = new char[ciphcea::line.length() + 1];
    strcpy(bytes8, ciphcea::line.c_str());
    linesize = ciphcea::line.length();
    int linesize2 = linesize;
    for (i = 0; i < linesize2; i++) {
        if (i < 8)
        {
            std::cout << bytes8[i];
            char0 = bytes8[0];
            char1 = bytes8[1];
            char2 = bytes8[2];
            char3 = bytes8[3];
            char4 = bytes8[4];
            char5 = bytes8[5];
            char6 = bytes8[6];
            char7 = bytes8[7];
            bytesbool1 = 1;
        }
        if (i == 8)
        {
            printf(" ");
            std::cout << bytes8[i];
            char8 = bytes8[8];
        }
        if (i > 8 && i < 16)
        {
            std::cout << bytes8[i];
            char9 = bytes8[9];
            char10 = bytes8[10];
            char11 = bytes8[11];
            char12 = bytes8[12];
            char13 = bytes8[13];
            char14 = bytes8[14];
            char15 = bytes8[15];
            bytesbool2 = 1;
        }
        if (i == 16)
        {
            printf(" ");
            std::cout << bytes8[i];
            char16 = bytes8[16];
        }
        if (i > 16 && i < 24)
        {
            std::cout << bytes8[i];
            char17 = bytes8[17];
            char18 = bytes8[18];
            char19 = bytes8[19];
            char20 = bytes8[20];
            char21 = bytes8[21];
            char22 = bytes8[22];
            char23 = bytes8[23];
            bytesbool3 = 1;
        }
        if (i == 24)
        {
            printf(" ");
            std::cout << bytes8[i];
            char24 = bytes8[24];
        }
        if (i > 24 && i < 32)
        {
            std::cout << bytes8[i];
            char25 = bytes8[25];
            char26 = bytes8[26];
            char27 = bytes8[27];
            char28 = bytes8[28];
            char29 = bytes8[29];
            char30 = bytes8[30];
            char31 = bytes8[31];
            bytesbool4 = 1;
        }
        if (i == 32)
        {
            printf(" ");
            std::cout << bytes8[i];
            char32 = bytes8[32];
        }
        if (i > 32 && i < 40)
        {
            std::cout << bytes8[i];
            char33 = bytes8[33];
            char34 = bytes8[34];
            char35 = bytes8[35];
            char36 = bytes8[36];
            char37 = bytes8[37];
            char38 = bytes8[38];
            char39 = bytes8[39];
            bytesbool5 = 1;
        }
        if (i == 40)
        {
            printf(" ");
            std::cout << bytes8[i];
            char40 = bytes8[40];
        }
        if (i > 40 && i < 48)
        {
            std::cout << bytes8[i];
            char41 = bytes8[41];
            char42 = bytes8[42];
            char43 = bytes8[43];
            char44 = bytes8[44];
            char45 = bytes8[45];
            char46 = bytes8[46];
            char47 = bytes8[47];
            bytesbool6 = 1;
        }
        if (i == 48)
        {
            printf(" ");
            std::cout << bytes8[i];
            char48 = bytes8[48];
        }
        if (i > 48 && i < 56)
        {
            std::cout << bytes8[i];
            char49 = bytes8[49];
            char50 = bytes8[50];
            char51 = bytes8[51];
            char52 = bytes8[52];
            char53 = bytes8[53];
            char54 = bytes8[54];
            char55 = bytes8[55];
            bytesbool7 = 1;
        }
        if (i == 56)
        {
            printf(" ");
            std::cout << bytes8[i];
            char56 = bytes8[56];
        }
        if (i > 56 && i < 64)
        {
            std::cout << bytes8[i];
            char57 = bytes8[57];
            char58 = bytes8[58];
            char59 = bytes8[59];
            char60 = bytes8[60];
            char61 = bytes8[61];
            char62 = bytes8[62];
            char63 = bytes8[63];
            bytesbool8 = 1;
        }
        if (i == 64)
        {
            printf(" ");
            std::cout << bytes8[i];
            char64 = bytes8[64];
        }
        if (i > 64 && i < 72)
        {
            std::cout << bytes8[i];
            char65 = bytes8[65];
            char66 = bytes8[66];
            char67 = bytes8[67];
            char68 = bytes8[68];
            char69 = bytes8[69];
            char70 = bytes8[70];
            char71 = bytes8[71];
            bytesbool9 = 1;
        }
        if (i == 72)
        {
            printf(" ");
            std::cout << bytes8[i];
            char72 = bytes8[72];
        }
        if (i > 72 && i < 80)
        {
            std::cout << bytes8[i];
            char73 = bytes8[73];
            char74 = bytes8[74];
            char75 = bytes8[75];
            char76 = bytes8[76];
            char77 = bytes8[77];
            char78 = bytes8[78];
            char79 = bytes8[79];
            bytesbool10 = 1;
        }
        if (i == 80)
        {
            printf(" ");
            std::cout << bytes8[i];
            char80 = bytes8[80];
        }
        if (i > 80 && i < 88)
        {
            std::cout << bytes8[i];
            char81 = bytes8[81];
            char82 = bytes8[82];
            char83 = bytes8[83];
            char84 = bytes8[84];
            char85 = bytes8[85];
            char86 = bytes8[86];
            char87 = bytes8[87];
            bytesbool11 = 1;
        }
        if (i == 88)
        {
            printf(" ");
            std::cout << bytes8[i];
            char88 = bytes8[88];
        }
        if (i > 88 && i < 96)
        {
            std::cout << bytes8[i];
            char89 = bytes8[89];
            char90 = bytes8[90];
            char91 = bytes8[91];
            char92 = bytes8[92];
            char93 = bytes8[93];
            char94 = bytes8[94];
            char95 = bytes8[95];
            bytesbool12 = 1;
        }
        if (i == 96)
        {
            printf(" ");
            std::cout << bytes8[i];
            char96 = bytes8[96];
        }
        if (i > 96 && i < 104)
        {
            std::cout << bytes8[i];
            char97 = bytes8[97];
            char98 = bytes8[98];
            char99 = bytes8[99];
            char100 = bytes8[100];
            char101 = bytes8[101];
            char102 = bytes8[102];
            char103 = bytes8[103];
            bytesbool13 = 1;
        }
        if (i == 104)
        {
            printf(" ");
            std::cout << bytes8[i];
            char104 = bytes8[104];
        }
        if (i > 104 && i < 112)
        {
            std::cout << bytes8[i];
            char105 = bytes8[105];
            char106 = bytes8[106];
            char107 = bytes8[107];
            char108 = bytes8[108];
            char109 = bytes8[109];
            char110 = bytes8[110];
            char111 = bytes8[111];
            bytesbool14 = 1;
        }
        if (i == 112)
        {
            printf(" ");
            std::cout << bytes8[i];
            char112 = bytes8[112];
        }
        if (i > 112 && i < 120)
        {
            std::cout << bytes8[i];
            char113 = bytes8[113];
            char114 = bytes8[114];
            char115 = bytes8[115];
            char116 = bytes8[116];
            char117 = bytes8[117];
            char118 = bytes8[118];
            char119 = bytes8[119];
            bytesbool15 = 1;
        }
        if (i == 120)
        {
            printf(" ");
            std::cout << bytes8[i];
            char120 = bytes8[120];
        }
        if (i > 120 && i < 128)
        {
            std::cout << bytes8[i];
            char121 = bytes8[121];
            char122 = bytes8[122];
            char123 = bytes8[123];
            char124 = bytes8[124];
            char125 = bytes8[125];
            char126 = bytes8[126];
            char127 = bytes8[127];
            bytesbool16 = 1;
        }
        if (i == 128)
        {
            printf(" ");
            std::cout << bytes8[i];
            char128 = bytes8[128];
        }
        if (i > 128 && i < 136)
        {
            std::cout << bytes8[i];
            char129 = bytes8[129];
            char130 = bytes8[130];
            char131 = bytes8[131];
            char132 = bytes8[132];
            char133 = bytes8[133];
            char134 = bytes8[134];
            char135 = bytes8[135];
            bytesbool17 = 1;
        }
        if (i == 136)
        {
            printf(" ");
            std::cout << bytes8[i];
            char136 = bytes8[136];
        }
        if (i > 136 && i < 144)
        {
            std::cout << bytes8[i];
            char137 = bytes8[137];
            char138 = bytes8[138];
            char139 = bytes8[139];
            char140 = bytes8[140];
            char141 = bytes8[141];
            char142 = bytes8[142];
            char143 = bytes8[143];
            bytesbool18 = 1;
        }
        if (i == 144)
        {
            printf(" ");
            std::cout << bytes8[i];
            char144 = bytes8[144];
        }
        if (i > 144 && i < 152)
        {
            std::cout << bytes8[i];
            char145 = bytes8[145];
            char146 = bytes8[146];
            char147 = bytes8[147];
            char148 = bytes8[148];
            char149 = bytes8[149];
            char150 = bytes8[150];
            char151 = bytes8[151];
            bytesbool19 = 1;
        }
        if (i == 152)
        {
            printf(" ");
            std::cout << bytes8[i];
            char152 = bytes8[152];
        }
        if (i > 152 && i < 160)
        {
            std::cout << bytes8[i];
            char153 = bytes8[153];
            char154 = bytes8[154];
            char155 = bytes8[155];
            char156 = bytes8[156];
            char157 = bytes8[157];
            char158 = bytes8[158];
            char159 = bytes8[159];
            bytesbool20 = 1;
        }
        if (i == 160)
        {
            printf(" ");
            std::cout << bytes8[i];
            char160 = bytes8[160];
        }
        if (i > 160 && i < 168)
        {
            std::cout << bytes8[i];
            char161 = bytes8[161];
            char162 = bytes8[162];
            char163 = bytes8[163];
            char164 = bytes8[164];
            char165 = bytes8[165];
            char166 = bytes8[166];
            char167 = bytes8[167];
            bytesbool21 = 1;
        }
        if (i == 168)
        {
            printf(" ");
            std::cout << bytes8[i];
            char168 = bytes8[168];
        }
        if (i > 168 && i < 176)
        {
            std::cout << bytes8[i];
            char169 = bytes8[169];
            char170 = bytes8[170];
            char171 = bytes8[171];
            char172 = bytes8[172];
            char173 = bytes8[173];
            char174 = bytes8[174];
            char175 = bytes8[175];
            bytesbool22 = 1;
        }
        if (i == 176)
        {
            printf(" ");
            std::cout << bytes8[i];
            char176 = bytes8[176];
        }
        if (i > 176 && i < 184)
        {
            std::cout << bytes8[i];
            char177 = bytes8[177];
            char178 = bytes8[178];
            char179 = bytes8[179];
            char180 = bytes8[180];
            char181 = bytes8[181];
            char182 = bytes8[182];
            char183 = bytes8[183];
            bytesbool23 = 1;
        }
        if (i == 184)
        {
            printf(" ");
            std::cout << bytes8[i];
            char184 = bytes8[184];
        }
        if (i > 184 && i < 192)
        {
            std::cout << bytes8[i];
            char185 = bytes8[185];
            char186 = bytes8[186];
            char187 = bytes8[187];
            char188 = bytes8[188];
            char189 = bytes8[189];
            char190 = bytes8[190];
            char191 = bytes8[191];
            bytesbool24 = 1;
        }
        if (i == 192)
        {
            printf(" ");
            std::cout << bytes8[i];
            char192 = bytes8[192];
        }
        if (i > 192 && i < 200)
        {
            std::cout << bytes8[i];
            char193 = bytes8[193];
            char194 = bytes8[194];
            char195 = bytes8[195];
            char196 = bytes8[196];
            char197 = bytes8[197];
            char198 = bytes8[198];
            char199 = bytes8[199];
            bytesbool25 = 1;
        }
        if (i == 200)
        {
            printf(" ");
            std::cout << bytes8[i];
            char200 = bytes8[200];
        }
        if (i > 200 && i < 208)
        {
            std::cout << bytes8[i];
            char201 = bytes8[201];
            char202 = bytes8[202];
            char203 = bytes8[203];
            char204 = bytes8[204];
            char205 = bytes8[205];
            char206 = bytes8[206];
            char207 = bytes8[207];
            bytesbool26 = 1;
        }
        if (i == 208)
        {
            printf(" ");
            std::cout << bytes8[i];
            char208 = bytes8[208];
        }
        if (i > 208 && i < 216)
        {
            std::cout << bytes8[i];
            char209 = bytes8[209];
            char210 = bytes8[210];
            char211 = bytes8[211];
            char212 = bytes8[212];
            char213 = bytes8[213];
            char214 = bytes8[214];
            char215 = bytes8[215];
            bytesbool27 = 1;
        }
        if (i == 216)
        {
            printf(" ");
            std::cout << bytes8[i];
            char216 = bytes8[216];
        }
        if (i > 216 && i < 224)
        {
            std::cout << bytes8[i];
            char217 = bytes8[217];
            char218 = bytes8[218];
            char219 = bytes8[219];
            char220 = bytes8[220];
            char221 = bytes8[221];
            char222 = bytes8[222];
            char223 = bytes8[223];
            bytesbool28 = 1;
        }
        if (i == 224)
        {
            printf(" ");
            std::cout << bytes8[i];
            char224 = bytes8[224];
        }
        if (i > 224 && i < 232)
        {
            std::cout << bytes8[i];
            char225 = bytes8[225];
            char226 = bytes8[226];
            char227 = bytes8[227];
            char228 = bytes8[228];
            char229 = bytes8[229];
            char230 = bytes8[230];
            char231 = bytes8[231];
            bytesbool29 = 1;
        }
        if (i == 232)
        {
            printf(" ");
            std::cout << bytes8[i];
            char232 = bytes8[232];
        }
        if (i > 232 && i < 240)
        {
            std::cout << bytes8[i];
            char233 = bytes8[233];
            char234 = bytes8[234];
            char235 = bytes8[235];
            char236 = bytes8[236];
            char237 = bytes8[237];
            char238 = bytes8[238];
            char239 = bytes8[239];
            bytesbool30 = 1;
        }
        if (i == 240)
        {
            printf(" ");
            std::cout << bytes8[i];
            char240 = bytes8[240];
        }
        if (i > 240 && i < 248)
        {
            std::cout << bytes8[i];
            char241 = bytes8[241];
            char242 = bytes8[242];
            char243 = bytes8[243];
            char244 = bytes8[244];
            char245 = bytes8[245];
            char246 = bytes8[246];
            char247 = bytes8[247];
            bytesbool31 = 1;
        }
        if (i == 248)
        {
            printf(" ");
            std::cout << bytes8[i];
            char248 = bytes8[248];
        }
        if (i > 248 && i < 256)
        {
            std::cout << bytes8[i];
            char249 = bytes8[249];
            char250 = bytes8[250];
            char251 = bytes8[251];
            char252 = bytes8[252];
            char253 = bytes8[253];
            char254 = bytes8[254];
            char255 = bytes8[255];
            bytesbool32 = 1;
        }
    }
    checkline(linesize2);
    int bytesint2;
    printf("\n");
    if (bytesbool1 == 1)
    {
        decodehex(char0, char1, char2, char3, char4, char5, char6, char7);
        laststring01 = laststring00;
        convert1 = convert;
        bytesbool1 = 0;
        bytesint2 = 1;
    }
    if (bytesbool2 == 1)
    {
        decodehex(char8, char9, char10, char11, char12, char13, char14, char15);
        laststring02 = laststring00;
        convert2 = convert;
        bytesbool2 = 0;
        bytesint2 = 2;
    }
    if (bytesbool3 == 1)
    {
        decodehex(char16, char17, char18, char19, char20, char21, char22, char23);
        laststring03 = laststring00;
        convert3 = convert;
        bytesbool3 = 0;
        bytesint2 = 3;
    }
    if (bytesbool4 == 1)
    {
        decodehex(char24, char25, char26, char27, char28, char29, char30, char31);
        laststring04 = laststring00;
        convert4 = convert;
        bytesbool4 = 0;
        bytesint2 = 4;
    }
    if (bytesbool5 == 1)
    {
        decodehex(char32, char33, char34, char35, char36, char37, char38, char39);
        laststring05 = laststring00;
        convert5 = convert;
        bytesbool5 = 0;
        bytesint2 = 5;
    }
    if (bytesbool6 == 1)
    {
        decodehex(char40, char41, char42, char43, char44, char45, char46, char47);
        laststring06 = laststring00;
        convert6 = convert;
        bytesbool6 = 0;
        bytesint2 = 6;
    }
    if (bytesbool7 == 1)
    {
        decodehex(char48, char49, char50, char51, char52, char53, char54, char55);
        laststring07 = laststring00;
        convert7 = convert;
        bytesbool7 = 0;
        bytesint2 = 7;
    }
    if (bytesbool8 == 1)
    {
        decodehex(char56, char57, char58, char59, char60, char61, char62, char63);
        laststring08 = laststring00;
        convert8 = convert;
        bytesbool8 = 0;
        bytesint2 = 8;
    }
    if (bytesbool9 == 1)
    {
        decodehex(char64, char65, char66, char67, char68, char69, char70, char71);
        laststring09 = laststring00;
        convert9 = convert;
        bytesbool9 = 0;
        bytesint2 = 9;
    }
    if (bytesbool10 == 1)
    {
        decodehex(char72, char73, char74, char75, char76, char77, char78, char79);
        laststring010 = laststring00;
        convert10 = convert;
        bytesbool10 = 0;
        bytesint2 = 10;
    }
    if (bytesbool11 == 1)
    {
        decodehex(char80, char81, char82, char83, char84, char85, char86, char87);
        laststring011 = laststring00;
        convert11 = convert;
        bytesbool11 = 0;
        bytesint2 = 11;
    }
    if (bytesbool12 == 1)
    {
        decodehex(char88, char89, char90, char91, char92, char93, char94, char95);
        laststring012 = laststring00;
        convert12 = convert;
        bytesbool12 = 0;
        bytesint2 = 12;
    }
    if (bytesbool13 == 1)
    {
        decodehex(char96, char97, char98, char99, char100, char101, char102, char103);
        laststring013 = laststring00;
        convert13 = convert;
        bytesbool13 = 0;
        bytesint2 = 13;
    }
    if (bytesbool14 == 1)
    {
        decodehex(char104, char105, char106, char107, char108, char109, char110, char111);
        laststring014 = laststring00;
        convert14 = convert;
        bytesbool14 = 0;
        bytesint2 = 14;
    }
    if (bytesbool15 == 1)
    {
        decodehex(char112, char113, char114, char115, char116, char117, char118, char119);
        laststring015 = laststring00;
        convert15 = convert;
        bytesbool15 = 0;
        bytesint2 = 15;
    }
    if (bytesbool16 == 1)
    {
        decodehex(char120, char121, char122, char123, char124, char125, char126, char127);
        laststring016 = laststring00;
        convert16 = convert;
        bytesbool16 = 0;
        bytesint2 = 16;
    }
    if (bytesbool17 == 1)
    {
        decodehex(char128, char129, char130, char131, char132, char133, char134, char135);
        laststring017 = laststring00;
        convert17 = convert;
        bytesbool17 = 0;
        bytesint2 = 17;
    }
    if (bytesbool18 == 1)
    {
        decodehex(char136, char137, char138, char139, char140, char141, char142, char143);
        laststring018 = laststring00;
        convert18 = convert;
        bytesbool18 = 0;
        bytesint2 = 18;
    }
    if (bytesbool19 == 1)
    {
        decodehex(char144, char145, char146, char147, char148, char149, char150, char151);
        laststring019 = laststring00;
        convert19 = convert;
        bytesbool19 = 0;
        bytesint2 = 19;
    }
    if (bytesbool20 == 1)
    {
        decodehex(char152, char153, char154, char155, char156, char157, char158, char159);
        laststring020 = laststring00;
        convert20 = convert;
        bytesbool20 = 0;
        bytesint2 = 20;
    }
    if (bytesbool21 == 1)
    {
        decodehex(char160, char161, char162, char163, char164, char165, char166, char167);
        laststring021 = laststring00;
        convert21 = convert;
        bytesbool21 = 0;
        bytesint2 = 21;
    }
    if (bytesbool22 == 1)
    {
        decodehex(char168, char169, char170, char171, char172, char173, char174, char175);
        laststring022 = laststring00;
        convert22 = convert;
        bytesbool22 = 0;
        bytesint2 = 22;
    }
    if (bytesbool23 == 1)
    {
        decodehex(char176, char177, char178, char179, char180, char181, char182, char183);
        laststring023 = laststring00;
        convert23 = convert;
        bytesbool23 = 0;
        bytesint2 = 23;
    }
    if (bytesbool24 == 1)
    {
        decodehex(char184, char185, char186, char187, char188, char189, char190, char191);
        laststring024 = laststring00;
        convert24 = convert;
        bytesbool24 = 0;
        bytesint2 = 24;
    }
    if (bytesbool25 == 1)
    {
        decodehex(char192, char193, char194, char195, char196, char197, char198, char199);
        laststring025 = laststring00;
        convert25 = convert;
        bytesbool25 = 0;
        bytesint2 = 25;
    }
    if (bytesbool26 == 1)
    {
        decodehex(char200, char201, char202, char203, char204, char205, char206, char207);
        laststring026 = laststring00;
        convert26 = convert;
        bytesbool26 = 0;
        bytesint2 = 26;
    }
    if (bytesbool27 == 1)
    {
        decodehex(char208, char209, char210, char211, char212, char213, char214, char215);
        laststring027 = laststring00;
        convert27 = convert;
        bytesbool27 = 0;
        bytesint2 = 27;
    }
    if (bytesbool28 == 1)
    {
        decodehex(char216, char217, char218, char219, char220, char221, char222, char223);
        laststring028 = laststring00;
        convert28 = convert;
        bytesbool28 = 0;
        bytesint2 = 28;
    }
    if (bytesbool29 == 1)
    {
        decodehex(char224, char225, char226, char227, char228, char229, char230, char231);
        laststring029 = laststring00;
        convert29 = convert;
        bytesbool29 = 0;
        bytesint2 = 29;
    }
    if (bytesbool30 == 1)
    {
        decodehex(char232, char233, char234, char235, char236, char237, char238, char239);
        laststring030 = laststring00;
        convert30 = convert;
        bytesbool30 = 0;
        bytesint2 = 30;
    }
    if (bytesbool31 == 1)
    {
        decodehex(char240, char241, char242, char243, char244, char245, char246, char247);
        laststring031 = laststring00;
        convert31 = convert;
        bytesbool31 = 0;
        bytesint2 = 31;
    }
    if (bytesbool32 == 1)
    {
        decodehex(char248, char249, char250, char251, char252, char253, char254, char255);
        laststring032 = laststring00;
        convert32 = convert;
        bytesbool32 = 0;
        bytesint2 = 32;
    }
    printf("\n");
    std::string thelaststring1 = laststring01 + laststring02;
    std::string thelaststring2 = laststring03 + laststring04;
    std::string thelaststring3 = laststring05 + laststring06;
    std::string thelaststring4 = laststring07 + laststring08;
    std::string thelaststring5 = laststring09 + laststring010;
    std::string thelaststring6 = laststring011 + laststring012;
    std::string thelaststring7 = laststring013 + laststring014;
    std::string thelaststring8 = laststring015 + laststring016;
    std::string thelaststring9 = laststring017 + laststring018;
    std::string thelaststring10 = laststring019 + laststring020;
    std::string thelaststring11 = laststring021 + laststring022;
    std::string thelaststring12 = laststring023 + laststring024;
    std::string thelaststring13 = laststring025 + laststring026;
    std::string thelaststring14 = laststring027 + laststring028;
    std::string thelaststring15 = laststring029 + laststring030;
    std::string thelaststring16 = laststring031 + laststring032;
    std::string thelaststring17 = thelaststring1 + thelaststring2;
    std::string thelaststring18 = thelaststring3 + thelaststring4;
    std::string thelaststring19 = thelaststring5 + thelaststring6;
    std::string thelaststring20 = thelaststring7 + thelaststring8;
    std::string thelaststring21 = thelaststring9 + thelaststring10;
    std::string thelaststring22 = thelaststring11 + thelaststring12;
    std::string thelaststring23 = thelaststring13 + thelaststring14;
    std::string thelaststring24 = thelaststring15 + thelaststring16;
    std::string thelaststring25 = thelaststring17 + thelaststring18;
    std::string thelaststring26 = thelaststring19 + thelaststring20;
    std::string thelaststring27 = thelaststring21 + thelaststring22;
    std::string thelaststring28 = thelaststring23 + thelaststring24;
    std::string thelaststring29 = thelaststring25 + thelaststring26;
    std::string thelaststring30 = thelaststring27 + thelaststring28;
    std::string thelaststring31 = thelaststring29 + thelaststring30;
    std::cout << thelaststring31 << std::endl;
    std::string convertfile01 = convert1 + " " + convert2;
    std::string convertfile02 = convert3 + " " + convert4;
    std::string convertfile03 = convert5 + " " + convert6;
    std::string convertfile04 = convert7 + " " + convert8;
    std::string convertfile05 = convert9 + " " + convert10;
    std::string convertfile06 = convert11 + " " + convert12;
    std::string convertfile07 = convert13 + " " + convert14;
    std::string convertfile08 = convert15 + " " + convert16;
    std::string convertfile09 = convert17 + " " + convert18;
    std::string convertfile010 = convert19 + " " + convert20;
    std::string convertfile011 = convert21 + " " + convert22;
    std::string convertfile012 = convert23 + " " + convert24;
    std::string convertfile013 = convert25 + " " + convert26;
    std::string convertfile014 = convert27 + " " + convert28;
    std::string convertfile015 = convert29 + " " + convert30;
    std::string convertfile016 = convert31 + " " + convert32;
    std::string convertfile017 = convertfile01 + " " + convertfile02;
    std::string convertfile018 = convertfile03 + " " + convertfile04;
    std::string convertfile019 = convertfile05 + " " + convertfile06;
    std::string convertfile020 = convertfile07 + " " + convertfile08;
    std::string convertfile021 = convertfile09 + " " + convertfile010;
    std::string convertfile022 = convertfile011 + " " + convertfile012;
    std::string convertfile023 = convertfile013 + " " + convertfile014;
    std::string convertfile024 = convertfile015 + " " + convertfile016;
    std::string convertfile025 = convertfile017 + " " + convertfile018;
    std::string convertfile026 = convertfile019 + " " + convertfile020;
    std::string convertfile027 = convertfile021 + " " + convertfile022;
    std::string convertfile028 = convertfile023 + " " + convertfile024;
    std::string convertfile029 = convertfile025 + " " + convertfile026;
    std::string convertfile030 = convertfile027 + " " + convertfile028;
    std::string convertfile031 = convertfile029 + " " + convertfile030;
    printf("\n");
    std::cout << convertfile031 << std::endl;
    std::string bytesString3 = convertfile031;
    std::string space = " ";
    std::string space2 = "  ";
    std::string nospace = "";
    size_t pos = bytesString3.find(space2);
    while (pos != std::string::npos)
    {
        bytesString3.replace(pos, space2.size(), nospace);
        pos = bytesString3.find(space2, pos + nospace.size());
    }
    std::string bytesString4 = bytesString3;
    size_t pos2 = bytesString4.find(space);
    while (pos2 != std::string::npos)
    {
        bytesString4.replace(pos2, space.size(), nospace);
        pos2 = bytesString4.find(space, pos2 + nospace.size());
    }
    std::string bytesString5 = bytes8;
    std::string::size_type rep = bytesString5.find(thelaststring31);
    if (rep != std::string::npos)
        bytesString5.replace(rep, thelaststring31.length(), bytesString4);
    printf("\n");
    std::cout << bytesString5 << std::endl;
    mytest = new char[bytesString5.length() + 1];
    strcpy(mytest, bytesString5.c_str());
    cipherizer2 = hex_to_string(mytest);
    printf("\n");
    std::cout << cipherizer2 << std::endl;
    urltodecodebase64 = cipherizer2;
    decodeurlbase64caller();
    printf("\n");
    std::cout << decodedurlbase64 << std::endl;
    cipherizer2 = decodedurlbase64;
    ceasarcipherdecode(decodedurlbase64);
    printf((char*)textconverter.c_str());
    laststring01 = "";
    laststring02 = "";
    laststring03 = "";
    laststring04 = "";
    laststring05 = "";
    laststring06 = "";
    laststring07 = "";
    laststring08 = "";
    laststring09 = "";
    laststring010 = "";
    laststring011 = "";
    laststring012 = "";
    laststring013 = "";
    laststring014 = "";
    laststring015 = "";
    laststring016 = "";
    laststring017 = "";
    laststring018 = "";
    laststring019 = "";
    laststring020 = "";
    laststring021 = "";
    laststring022 = "";
    laststring023 = "";
    laststring024 = "";
    laststring025 = "";
    laststring026 = "";
    laststring027 = "";
    laststring028 = "";
    laststring029 = "";
    laststring030 = "";
    laststring031 = "";
    laststring032 = "";
    return 0;
}

void CeasarCipher::Ceasar2() {
    char opt = '\0';
    X x;
    while (true) {
        system("cls");
        x.message[0] = '\0';
        x.key = '\0';
        std::cout << "Ceasar Cipher 2 by Thunder\n";
        std::cout << "1. Encrypt\n";
        std::cout << "2. Decrypt\n";
        std::cout << "4. Encode Cipher Hex\n";
        std::cout << "5. Decode Cipher Hex\n";
        std::cout << "6. Encode Cipher Base64\n";
        std::cout << "7. Decode Cipher Base64\n";
        std::cout << "8. Pc Info Md5\n";
        std::cout << "3. Return\n";
        std::cout << "   Option: ";
        opt = _getche();
        std::cout << "\n";
        switch (opt) {
        case '1':
            std::cout << "Enter a message to encrypt: ";
            std::cin.getline(x.message, 255);
            numletter = strlen(x.message);
            if (numletter > 1)
            {
                x.key = +1;
            }
            if (numletter > 80)
            {
                x.key = +2;
            }
            for (x.i = 0; x.message[x.i] != '\0'; ++x.i) {
                x.ch = x.message[x.i];
                if (x.ch >= 'a' && x.ch <= 'z') {
                    x.ch = x.ch + x.key;
                    if (x.ch > 'z') {
                        x.ch = x.ch - 'z' + 'a' - 1;
                    }
                    x.message[x.i] = x.ch;
                }
                else if (x.ch >= '0' && x.ch <= '9')
                {
                    x.ch = x.ch - x.key;
                    x.message[x.i] = x.ch;
                        if (x.ch == '/') {
                            x.ch = x.ch + 10;
                            x.message[x.i] = x.ch;
                        }
                }
                else if (x.ch >= 'A' && x.ch <= 'Z') {
                    x.ch = x.ch + x.key;
                    if (x.ch > 'a') {
                        x.ch = x.ch - 'Z' + 'A' - 1;
                    }
                    x.message[x.i] = x.ch;
                }
            }
            std::cout << "Encrypted message: " << x.message << std::endl;
            system("pause");
            break;
        case '2':
            std::cout << "Enter a message to decrypt: ";
            std::cin.getline(x.message, 255);
            numletter = strlen(x.message);
            if (numletter > 1)
            {
                x.key = +1;
            }
            if (numletter > 10)
            {
                x.key = +1;
            }
            if (numletter > 80)
            {
                x.key = +2;
            }
            for (x.i = 0; x.message[x.i] != '\0'; ++x.i) {
                x.ch = x.message[x.i];
                if (x.ch >= 'a' && x.ch <= 'z') {
                    x.ch = x.ch - x.key;
                    if (x.ch < 'a') {
                        x.ch = x.ch + 'z' - 'a' + 1;
                    }
                    x.message[x.i] = x.ch;
                }
                else if (x.ch >= '0' && x.ch <= '9')
                {
                    x.ch = x.ch + x.key;
                    x.message[x.i] = x.ch;
                        if (x.ch == ':') {
                            x.ch = x.ch - 10;
                            x.message[x.i] = x.ch;
                        }
                }
                else if (x.ch >= 'A' && x.ch <= 'Z') {
                    x.ch = x.ch - x.key;
                    if (x.ch > 'a') {
                        x.ch = x.ch + 'Z' - 'A' + 1;
                    }
                    x.message[x.i] = x.ch;
                }
            }
            std::cout << "Decrypted message: " << x.message << std::endl;
            system("pause");
            break;
        case '4':
            std::cout << "Enter a message to encrypt: ";
            std::getline(std::cin, EnterMessages);
            mytest = new char[EnterMessages.length() + 1];
            strcpy(mytest, EnterMessages.c_str());
            ceasarcipherencode(mytest);
            printf((char*)textconvert.c_str());
            cipherizer = textconvert;
            urltoencodebase64 = cipherizer;
            encodeurlbase64caller();
            std::cout << encodedurlbase64 << std::endl;
            //std::cout << string_to_hex(encodedurlbase64) << std::endl;
            bytesString = string_to_hex(encodedurlbase64);
            bytes8 = new char[bytesString.length() + 1];
            strcpy(bytes8, bytesString.c_str());
            std::cout << bytes8 << std::endl;
            system("pause");
                break;
        case '5':
            std::cout << "Enter a message to decrypt: ";
            std::getline(std::cin, EnterMessages);
            mytest = new char[EnterMessages.length() + 1];
            strcpy(mytest, EnterMessages.c_str());
            cipherizer2 = hex_to_string(mytest);
            std::cout << cipherizer2 << std::endl;
            urltodecodebase64 = cipherizer2;
            decodeurlbase64caller();
            std::cout << decodedurlbase64 << std::endl;
            cipherizer2 = decodedurlbase64;
            ceasarcipherdecode(decodedurlbase64);
            printf((char*)textconverter.c_str());
            /*mytest2 = new char[decodedurlbase64.length() + 1];
            strcpy(mytest2, decodedurlbase64.c_str());*/
            /*std::cout << cipherizer2 << std::endl;*/
            system("pause");
        break;
        case '6':
            std::cout << "Enter a message to encrypt: ";
            std::getline(std::cin, EnterMessages);
            mytest = new char[EnterMessages.length() + 1];
            strcpy(mytest, EnterMessages.c_str());
            ceasarcipherencode(mytest);
            printf((char*)textconvert.c_str());
            cipherizer = textconvert;
            urltoencodebase64 = cipherizer;
            encodeurlbase64caller();
            std::cout << encodedurlbase64 << std::endl;
            system("pause");
            break;
        case '7':
            std::cout << "Enter a message to decrypt: ";
            std::getline(std::cin, EnterMessages);
            mytest = new char[EnterMessages.length() + 1];
            strcpy(mytest, EnterMessages.c_str());
            cipherizer2 = EnterMessages;
            urltodecodebase64 = cipherizer2;
            decodeurlbase64caller();
            std::cout << decodedurlbase64 << std::endl;
            cipherizer2 = decodedurlbase64;
            ceasarcipherdecode(decodedurlbase64);
            printf((char*)textconverter.c_str());
            /*mytest2 = new char[decodedurlbase64.length() + 1];
            strcpy(mytest2, decodedurlbase64.c_str());*/
            /*std::cout << cipherizer2 << std::endl;*/
            system("pause");
            break;
        case '8':
            hwidinfo();
            system("pause");
            break;
        case '3':
            return;
            break;



        }
    }
}

https://github.com/3xploitch3ats/Thunder-Menu/raw/v2/CiphSea-Dgdp.mp4

Cipher Letr Numbr, Base64, Hex rgba to abgr, 8bytes To 32Bytes
https://pastebin.com/raw/hQhedJg9
https://pastebin.com/hQhedJg9

Ceasar Cipher Inverse Hex 256 Bytes - Pastebin.com
https://pastebin.com/bLiRbdfu
https://github.com/3xploitch3ats/Thunder-Menu/raw/v2/Ceasar_Cipher.exe
https://www.youtube.com/watch?v=WfsVrmFih3M