C++ Memory 2 Struct / Vector

/*
Visual Studio 2019 Professional -> Release

You can use detours and patch it for every call, this one only can be used with the touched vector, if you use a normal one, gonna crash, you gotta patch it in detour function.

It allocs memory (VirtualAlloc)

the cast that to Vector<int>/Vector<struct>

after cast you can use STL push, set =, resize, sort, shrink_to_fit, clear, pop, etc, all working
*/

#include <iostream>
#include <Windows.h>
#include <vector>

#include <algorithm> //sort
#include <random> //randomnumber

long RandomNumber(long LowerBound, long UpperBound);

std::random_device rd;     // only used once to initialise (seed) engine

long RandomNumber(long LowerBound, long UpperBound)
{
    if (LowerBound < 0) LowerBound = 0;
    if (UpperBound < 0) UpperBound = 0;

    if (LowerBound > UpperBound) UpperBound = LowerBound;
    /*srand((unsigned)time(0));

    return (rand() % ((UpperBound - LowerBound) + 1) + LowerBound);*/

    std::mt19937 rng(rd());    // random-number engine used (Mersenne-Twister in this case)
    std::uniform_int_distribution<long> uni(LowerBound, UpperBound); // guaranteed unbiased

    return uni(rng);
}

ULONGLONG RandomNumberULONGLONG(ULONGLONG LowerBound, ULONGLONG UpperBound)
{
    if (LowerBound < 0) LowerBound = 0;
    if (UpperBound < 0) UpperBound = 0;

    if (LowerBound > UpperBound) UpperBound = LowerBound;
    /*srand((unsigned)time(0));

    return (rand() % ((UpperBound - LowerBound) + 1) + LowerBound);*/

    std::mt19937 rng(rd());    // random-number engine used (Mersenne-Twister in this case)
    std::uniform_int_distribution<ULONGLONG> uni(LowerBound, UpperBound); // guaranteed unbiased

    return uni(rng);
}

#pragma pack(push)  /* push current alignment to stack */
#pragma pack(1)     /* set alignment to 1 byte boundary */
struct tHook
{
    DWORD Base;
    DWORD Offset;
    char DllPath[MAX_PATH - 1];
    bool Activated;
    DWORD HookedAddress;
    ULONGLONG Count;
    //WORD Timer

    bool operator<(const tHook& a) const
    {
        return HookedAddress < a.HookedAddress;
    }

    bool operator>(const tHook& a) const
    {
        return HookedAddress > a.HookedAddress;
    }
};
#pragma pack(pop)   /* restore original alignment from stack */

tHook GenRandomStruct()
{
    tHook tmp;

    tmp.Base = RandomNumber(0x10000000, 0x70000000);
    tmp.Offset = RandomNumber(0x100, 0xFFFFFF0);
    FillMemory(tmp.DllPath, sizeof(tmp.DllPath), (char)RandomNumber('!', 'z'));
    tmp.DllPath[sizeof(tmp.DllPath) - 1] = '\0';
    tmp.Activated = (RandomNumber(0x10000000, 0x70000000) % 2 == 0);
    //strncpy(a, "iqbal", sizeof(a) - 1);
    tmp.HookedAddress = tmp.Base + tmp.Offset + 3;
    tmp.Count = RandomNumberULONGLONG(0x1000000000000000, 0x7FFFFFFFFFFFFFFF);

    return tmp;
}

bool compareByHookedAddress(const tHook& a, const tHook& b)
{
    return a.HookedAddress < b.HookedAddress;
}

enum eTaipu
{
    eInt,
    eStruct
};

eTaipu CurrentType;

LPVOID AddressAlloc = NULL;
DWORD VectorHoldingSize; //in the future I gotta do it with structs or <int, int>, DONE

/*
Memory2DynamicStruct.exe+1E40 - 55                    - push ebp
Memory2DynamicStruct.exe+1E41 - 8B EC                 - mov ebp,esp
Memory2DynamicStruct.exe+1E43 - 8B | 51 04              - mov edx,[ecx+04]
Memory2DynamicStruct.exe+1E46 - 3B 51 | 08              - cmp edx,[ecx+08]
Memory2DynamicStruct.exe+1E49 - 74 0F                 - je Memory2DynamicStruct.exe+1E5A
Memory2DynamicStruct.exe+1E4B - 8B | 45 08              - mov eax,[ebp+08]
Memory2DynamicStruct.exe+1E4E - 8B 00 |                 - mov eax,[eax]
Memory2DynamicStruct.exe+1E50 - 89 02                 - mov [edx],eax
Memory2DynamicStruct.exe+1E52 - 83 41 | 04 04           - add dword ptr [ecx+04],04 { 4 }
Memory2DynamicStruct.exe+1E56 - 5D                    - pop ebp
Memory2DynamicStruct.exe+1E57 - C2 | 0400               - ret 0004 { 4 } ----------------------------> scasd
Memory2DynamicStruct.exe+1E5A - FF 75 | 08              - push [ebp+08]
Memory2DynamicStruct.exe+1E5D - 52                    - push edx
Memory2DynamicStruct.exe+1E5E - E8 6D040000           - call Memory2DynamicStruct.exe+22D0
Memory2DynamicStruct.exe+1E63 - 5D                    - pop ebp
Memory2DynamicStruct.exe+1E64 - C2 0400               - ret 0004 { 4 }
-
Memory2DynamicStruct.exe+24A0 - 55                    - push ebp
Memory2DynamicStruct.exe+24A1 - 8B EC                 - mov ebp,esp
Memory2DynamicStruct.exe+24A3 - 8B C1                 - mov eax,ecx
Memory2DynamicStruct.exe+24A5 - 8B 50 04              - mov edx,[eax+04]
Memory2DynamicStruct.exe+24A8 - 3B 50 08              - cmp edx,[eax+08]
Memory2DynamicStruct.exe+24AB - 74 1B                 - je Memory2DynamicStruct.exe+24C8
Memory2DynamicStruct.exe+24AD - 56                    - push esi
Memory2DynamicStruct.exe+24AE - 8B 75 08              - mov esi,[ebp+08]
Memory2DynamicStruct.exe+24B1 - B9 46000000           - mov ecx,00000046 { 70 }
Memory2DynamicStruct.exe+24B6 - 57                    - push edi
Memory2DynamicStruct.exe+24B7 - 8B FA                 - mov edi,edx
Memory2DynamicStruct.exe+24B9 - F3 A5                 - repe movsd
Memory2DynamicStruct.exe+24BB - 81 40 04 18010000     - add [eax+04],00000118 { 280 }
Memory2DynamicStruct.exe+24C2 - 5F                    - pop edi
Memory2DynamicStruct.exe+24C3 - 5E                    - pop esi
Memory2DynamicStruct.exe+24C4 - 5D                    - pop ebp
Memory2DynamicStruct.exe+24C5 - C2 0400               - ret 0004 { 4 }
Memory2DynamicStruct.exe+24C8 - FF 75 08              - push [ebp+08]
Memory2DynamicStruct.exe+24CB - 52                    - push edx
Memory2DynamicStruct.exe+24CC - E8 9F030000           - call Memory2DynamicStruct.exe+2870
Memory2DynamicStruct.exe+24D1 - 5D                    - pop ebp
Memory2DynamicStruct.exe+24D2 - C2 0400               - ret 0004 { 4 }
*/
DWORD Push_Back_VS2019_MagicNumber; // = 0x75FF0004; //0x0004C25D //scasd
DWORD Address_Push_Back = NULL;
BYTE Bk_Push_Back[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };

/*
Memory2DynamicStruct.exe+23A0 - 55                    - push ebp
Memory2DynamicStruct.exe+23A1 - 8B EC                 - mov ebp,esp
Memory2DynamicStruct.exe+23A3 - 53 |                    - push ebx
Memory2DynamicStruct.exe+23A4 - 56                    - push esi
Memory2DynamicStruct.exe+23A5 - 8B 75 08 |              - mov esi,[ebp+08]
Memory2DynamicStruct.exe+23A8 - 57                    - push edi
Memory2DynamicStruct.exe+23A9 - 8B F9                 - mov edi,ecx
Memory2DynamicStruct.exe+23AB - 8B | 5F 04              - mov ebx,[edi+04]
Memory2DynamicStruct.exe+23AE - 8B CB |                - mov ecx,ebx
Memory2DynamicStruct.exe+23B0 - 8B 17                 - mov edx,[edi]
Memory2DynamicStruct.exe+23B2 - 2B CA |                - sub ecx,edx
Memory2DynamicStruct.exe+23B4 - C1 F9 02              - sar ecx,02 { 2 }
Memory2DynamicStruct.exe+23B7 - 3B | F1                 - cmp esi,ecx
Memory2DynamicStruct.exe+23B9 - 73 0D                 - jae Memory2DynamicStruct.exe+23C8 ------------> above or equal
Memory2DynamicStruct.exe+23BB - 8D | 04 B2              - lea eax,[edx+esi*4] -----------------> 2 to 1, 2 to 0
Memory2DynamicStruct.exe+23BE - 89 47 | 04              - mov [edi+04],eax
Memory2DynamicStruct.exe+23C1 - 5F                    - pop edi
Memory2DynamicStruct.exe+23C2 - 5E                    - pop esi
Memory2DynamicStruct.exe+23C3 - 5B |                    - pop ebx
Memory2DynamicStruct.exe+23C4 - 5D                    - pop ebp
Memory2DynamicStruct.exe+23C5 - C2 0400 |               - ret 0004 { 4 }
Memory2DynamicStruct.exe+23C8 - 76 33                 - jna Memory2DynamicStruct.exe+23FD
Memory2DynamicStruct.exe+23CA - 8B 47 | 08              - mov eax,[edi+08]
Memory2DynamicStruct.exe+23CD - 2B C2                 - sub eax,edx
Memory2DynamicStruct.exe+23CF - C1 | F8 02              - sar eax,02 { 2 }
Memory2DynamicStruct.exe+23D2 - 3B F0 |                 - cmp esi,eax
Memory2DynamicStruct.exe+23D4 - 76 10                 - jna Memory2DynamicStruct.exe+23E6
Memory2DynamicStruct.exe+23D6 - 51                    - push ecx
Memory2DynamicStruct.exe+23D7 - 56 |                    - push esi
Memory2DynamicStruct.exe+23D8 - 8B CF                 - mov ecx,edi
Memory2DynamicStruct.exe+23DA - E8 31060000           - call Memory2DynamicStruct.exe+2A10 ------------> 2 to 2, 2 to 3, etc
        Memory2DynamicStruct.exe+2A80 - 55                    - push ebp
        Memory2DynamicStruct.exe+2A81 - 8B EC                 - mov ebp,esp
        Memory2DynamicStruct.exe+2A83 - 83 EC 08              - sub esp,08 { 8 }
        Memory2DynamicStruct.exe+2A86 - 53                    - push ebx
        Memory2DynamicStruct.exe+2A87 - 8B 5D 08              - mov ebx,[ebp+08]
Memory2DynamicStruct.exe+23DF - 5F                    - pop edi
Memory2DynamicStruct.exe+23E0 - 5E                    - pop esi
Memory2DynamicStruct.exe+23E1 - 5B                    - pop ebx
Memory2DynamicStruct.exe+23E2 - 5D                    - pop ebp
Memory2DynamicStruct.exe+23E3 - C2 0400               - ret 0004 { 4 }
Memory2DynamicStruct.exe+23E6 - 2B F1                 - sub esi,ecx
Memory2DynamicStruct.exe+23E8 - C1 E6 02              - shl esi,02 { 2 }
Memory2DynamicStruct.exe+23EB - 56                    - push esi
Memory2DynamicStruct.exe+23EC - 6A 00                 - push 00 { 0 }
Memory2DynamicStruct.exe+23EE - 53                    - push ebx
Memory2DynamicStruct.exe+23EF - E8 5D180000           - call Memory2DynamicStruct.exe+3C51 { ->->VCRUNTIME140.dll+3C90 }
Memory2DynamicStruct.exe+23F4 - 8D 04 1E              - lea eax,[esi+ebx]
Memory2DynamicStruct.exe+23F7 - 83 C4 0C              - add esp,0C { 12 }
Memory2DynamicStruct.exe+23FA - 89 47 04              - mov [edi+04],eax
Memory2DynamicStruct.exe+23FD - 5F                    - pop edi
Memory2DynamicStruct.exe+23FE - 5E                    - pop esi
Memory2DynamicStruct.exe+23FF - 5B                    - pop ebx
Memory2DynamicStruct.exe+2400 - 5D                    - pop ebp
Memory2DynamicStruct.exe+2401 - C2 0400               - ret 0004 { 4 }
*/
DWORD Resize_AboveOrEqual_VS2019_MagicNumber; // = 0x00005651; //scasw
DWORD Address_Resize_AboveOrEqual = NULL;
BYTE Bk_Resize_AboveOrEqual[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };

// ------- DEBUG ------- //
class StructVector
{
public:
    DWORD backVectorPointer; //0x0000
    DWORD v00000000_0x4; //0x0004
    DWORD vFDFDFDFD_0x8; //0x0008
    DWORD vDDDDDDDD_0xC; //0x000C
}; //Size=0x0010

class VectorPointers
{
public:
    StructVector* pStructVector; //0x0000
    DWORD pMyFirst; //0x0004
    DWORD pMyLast; //0x0008
    DWORD pMyEnd; //0x000C Equal to pMyLast
    DWORD vFDFDFDFD_0x10; //0x0010
}; //Size=0x0014

class BaseVector
{
public:
    VectorPointers* pVectorPointers; //0x0000
    DWORD vCCCCCCCC_0x4; //0x0004
    DWORD vCCCCCCCC_0x8; //0x0008
}; //Size=0x000C
// ------- DEBUG ------- //

// ------- RELEASE ------- //
class VectorPointers_Release
{
public:
    DWORD pMyFirst; //0x0000
    DWORD pMyLast; //0x0004
    DWORD pMyEnd; //0x0008 Equal to pMyLast
    DWORD vABABABAB_0xC; //0x000C
    DWORD vABABABAB_0x10; //0x0010
    DWORD vFEEEFEEE_0x14; //0x0014
    //DWORD vFEEEFEEE_0x18; //0x0018
    //DWORD vFEEEFEEE_0x1C; //0x001C
    //DWORD v00000000_0x20; //0x0020
    //DWORD v00000000_0x24; //0x0024
}; //Size=0x0028

class BaseVector_Release
{
public:
    VectorPointers_Release* pVectorPointers; //0x0000
}; //Size=0x0004
// ------- RELEASE ------- //

DWORD dwOldProtectionByte;
void WriteInProcessBYTE(DWORD Address, BYTE Value)
{
    MEMORY_BASIC_INFORMATION mbi = { 0 };

    if (VirtualQuery((LPVOID)Address, &mbi, sizeof(mbi)) == 0)
    {
        VirtualQueryEx(GetCurrentProcess(), (LPVOID)Address, &mbi, sizeof(mbi));
    }

    //*(BYTE*)Address = Value; //typecast variable to a pointer of a byte and dereference the pointer, letting you change what it holds
    //VirtualProtect((LPVOID)Address, 1, PAGE_EXECUTE_READWRITE, &dwOldProtectionByte);
    VirtualProtect((LPVOID)mbi.BaseAddress, mbi.RegionSize, PAGE_EXECUTE_READWRITE, &dwOldProtectionByte);

    *(BYTE*)Address = Value;

    //VirtualProtect((LPVOID)Address, 1, dwOldProtectionByte, &dwOldProtectionByte);
    VirtualProtect((LPVOID)mbi.BaseAddress, mbi.RegionSize, dwOldProtectionByte, &dwOldProtectionByte);
}

BYTE ReadInProcessBYTE(DWORD Address)
{
    return *(BYTE*)Address;
}

DWORD dwOldProtectionWORD;
void WriteInProcessWORD(DWORD Address, WORD Value)
{
    MEMORY_BASIC_INFORMATION mbi = { 0 };

    if (VirtualQuery((LPVOID)Address, &mbi, sizeof(mbi)) == 0)
    {
        VirtualQueryEx(GetCurrentProcess(), (LPVOID)Address, &mbi, sizeof(mbi));
    }

    //*(BYTE*)Address = Value; //typecast variable to a pointer of a byte and dereference the pointer, letting you change what it holds
    //VirtualProtect((LPVOID)Address, 2, PAGE_EXECUTE_READWRITE, &dwOldProtectionWORD);
    VirtualProtect((LPVOID)mbi.BaseAddress, mbi.RegionSize, PAGE_EXECUTE_READWRITE, &dwOldProtectionWORD);

    *(WORD*)Address = Value;

    //VirtualProtect((LPVOID)Address, 2, dwOldProtectionWORD, &dwOldProtectionWORD);
    VirtualProtect((LPVOID)mbi.BaseAddress, mbi.RegionSize, dwOldProtectionWORD, &dwOldProtectionWORD);
}

WORD ReadInProcessWORD(DWORD Address)
{
    return *(WORD*)Address;
}

DWORD dwOldProtectionDWORD;
void WriteInProcessDWORD(DWORD Address, DWORD Value)
{
    MEMORY_BASIC_INFORMATION mbi = { 0 };

    if (VirtualQuery((LPVOID)Address, &mbi, sizeof(mbi)) == 0)
    {
        VirtualQueryEx(GetCurrentProcess(), (LPVOID)Address, &mbi, sizeof(mbi));
    }

    VirtualProtect((LPVOID)mbi.BaseAddress, mbi.RegionSize, PAGE_EXECUTE_READWRITE, &dwOldProtectionDWORD);

    *(DWORD*)Address = Value;

    VirtualProtect((LPVOID)mbi.BaseAddress, mbi.RegionSize, dwOldProtectionDWORD, &dwOldProtectionDWORD);
}

DWORD ReadInProcessDWORD(DWORD Address)
{
    return *(DWORD*)Address;
}

/*
Address + [Address + 1] + 5
*/
DWORD GetRealCALL(DWORD VarAddress)
{
    return VarAddress + ReadInProcessDWORD(VarAddress + 0x1) + 0x5;
}

void FitAddress2Vector_Debug()
{
    BaseVector* VarBaseVector;

    VarBaseVector = (BaseVector*)(AddressAlloc);

    VarBaseVector->pVectorPointers = (VectorPointers*)((DWORD)(AddressAlloc) + 0xC);
    VarBaseVector->vCCCCCCCC_0x4 = 0xCCCCCCCC;
    VarBaseVector->vCCCCCCCC_0x8 = 0xCCCCCCCC;

    //StructVector* pStructVector; //0x0000
    //DWORD pMyFirst; //0x0004
    //DWORD pMyLast; //0x0008
    //DWORD pMyEnd; //0x000C Equal to pMyLast
    //DWORD vFDFDFDFD_0x10; //0x0010

    VarBaseVector->pVectorPointers->pStructVector = (StructVector*)((DWORD)(AddressAlloc) + 0x28);

    //DWORD backVectorPointer; //0x0000
    //DWORD v00000000_0x4; //0x0004
    //DWORD vFDFDFDFD_0x8; //0x0008
    //DWORD vDDDDDDDD_0xC; //0x000C
    VarBaseVector->pVectorPointers->pStructVector->backVectorPointer = (DWORD)&VarBaseVector->pVectorPointers->pStructVector;
    VarBaseVector->pVectorPointers->pStructVector->v00000000_0x4 = 0x00000000;
    VarBaseVector->pVectorPointers->pStructVector->vFDFDFDFD_0x8 = 0xFDFDFDFD;
    VarBaseVector->pVectorPointers->pStructVector->vDDDDDDDD_0xC = 0xDDDDDDDD;
    //

    VarBaseVector->pVectorPointers->pMyFirst = ((DWORD)(AddressAlloc) + 0x38);
    VarBaseVector->pVectorPointers->pMyLast = ((DWORD)(AddressAlloc) + 0x3C);
    VarBaseVector->pVectorPointers->pMyEnd = VarBaseVector->pVectorPointers->pMyLast;
    VarBaseVector->pVectorPointers->vFDFDFDFD_0x10 = 0xFDFDFDFD;

    WriteInProcessDWORD((DWORD)(AddressAlloc) + 0x38, 0x00000333); //[0]
    WriteInProcessDWORD((DWORD)(AddressAlloc) + 0x3C, 0xFDFDFDFD);
}

void FitAddress2Vector_Release()
{
    DWORD Offset = 0x0;

    BaseVector_Release* VarBaseVector;

    VarBaseVector = (BaseVector_Release*)(AddressAlloc);

    VarBaseVector->pVectorPointers = (VectorPointers_Release*)((DWORD)(AddressAlloc) + 0x4);

    /*
    DWORD pVectorArray; //0x0000
    DWORD pMyFirst; //0x0004
    DWORD pMyLast; //0x0008
    DWORD vABABABAB_0xC; //0x000C
    DWORD vABABABAB_0x10; //0x0010
    DWORD vFEEEFEEE_0x14; //0x0014
    */

    Offset = sizeof(VectorPointers_Release) + 0x04;

    // -------------------- <int> o lo que fuera --------------------
    DWORD IntroValues[] = { 0x00000333 , 0x00000666 , 0x00000999 };

    int array_size = sizeof(IntroValues) / sizeof(IntroValues[0]);

    // -------------------- <struct> --------------------
    //CurrentType
    tHook tmp;

    tmp.Base = 0x12345678;
    tmp.Offset = 0x1234;
    FillMemory(tmp.DllPath, sizeof(tmp.DllPath), 0x45);
    tmp.DllPath[sizeof(tmp.DllPath) - 1] = '\0';
    //strncpy(a, "iqbal", sizeof(a) - 1);
    tmp.Activated = true;
    tmp.HookedAddress = tmp.Base + tmp.Offset + 3;
    tmp.Count = 0x1234567887654321;

    // --------------------------------------------------------------

    //std::cout << "array_size: " << std::dec << array_size << std::endl;

    VarBaseVector->pVectorPointers->pMyFirst = ((DWORD)(AddressAlloc) + Offset); //0x4
    //VarBaseVector->pVectorPointers->pMyLast = ((DWORD)(AddressAlloc) + Offset + (0x04 * array_size)); //0x8

    switch (CurrentType)
    {
        case eTaipu::eInt:
            VarBaseVector->pVectorPointers->pMyLast = ((DWORD)(AddressAlloc) + Offset + (sizeof(IntroValues[0]) * array_size)); //0x8
            Push_Back_VS2019_MagicNumber = 0x000075FF; //0x75FF0004;
            Resize_AboveOrEqual_VS2019_MagicNumber = 0x00005651;
            VectorHoldingSize = sizeof(int);

            break;
        case eTaipu::eStruct:
            VarBaseVector->pVectorPointers->pMyLast = ((DWORD)(AddressAlloc) + Offset + sizeof(tmp)); //0x8
            Push_Back_VS2019_MagicNumber = 0x000075FF; //0x0004C25D;
            Resize_AboveOrEqual_VS2019_MagicNumber = 0x00005651;
            VectorHoldingSize = sizeof(tHook);

            break;
    }

    VarBaseVector->pVectorPointers->pMyEnd = VarBaseVector->pVectorPointers->pMyLast; //0xC
    VarBaseVector->pVectorPointers->vABABABAB_0xC = 0xABABABAB; //0x10
    VarBaseVector->pVectorPointers->vABABABAB_0x10 = 0xABABABAB; //0x14
    VarBaseVector->pVectorPointers->vFEEEFEEE_0x14 = 0xFEEEEEEE; //0x18
    //VarBaseVector->pVectorPointers->vFEEEFEEE_0x18 = 0xFEEEEEEE; //0x1C
    //VarBaseVector->pVectorPointers->vFEEEFEEE_0x1C = 0xFEEEEEEE; //0x20
    //VarBaseVector->pVectorPointers->v00000000_0x20 = 0x00000000; //0x24
    //VarBaseVector->pVectorPointers->v00000000_0x24 = 0x00000000; //0x28

    switch (CurrentType)
    {
        case eTaipu::eInt:
            for (size_t i = 0; i < array_size; i++)
            {
                WriteInProcessDWORD((DWORD)(AddressAlloc) + Offset + (0x04 * i), IntroValues[i]);
            }

            break;
        case eTaipu::eStruct:
            CopyMemory((LPVOID)((DWORD)(AddressAlloc) + Offset), &tmp, sizeof(tmp));

            break;
    }

    //Offset += (array_size * 0x04);

    //WriteInProcessDWORD((DWORD)(AddressAlloc) + Offset + 0x00, 0xABABABAB);
    //WriteInProcessDWORD((DWORD)(AddressAlloc) + Offset + 0x04, 0xABABABAB);
    //WriteInProcessDWORD((DWORD)(AddressAlloc) + Offset + 0x08, 0x00000000);
    //WriteInProcessDWORD((DWORD)(AddressAlloc) + Offset + 0x0C, 0x00000000);
}

BOOL InitAllocation()
{
    AddressAlloc = VirtualAlloc(NULL, 100, MEM_RESERVE, PAGE_EXECUTE_READWRITE);

    //std::cout << "AddressAlloc.MEM_RESERVE, AddressAlloc: " << std::hex << AddressAlloc << std::endl;

    AddressAlloc = VirtualAlloc(AddressAlloc, 100, MEM_COMMIT, PAGE_EXECUTE_READWRITE);

    std::cout << "AddressAlloc.MEM_COMMIT, AddressAlloc: " << std::hex << AddressAlloc << std::endl;

    if (AddressAlloc)
    {
        FitAddress2Vector_Release();
    }

    return (AddressAlloc != NULL);
}

void Patch_Mov_Eax_Jmp_Eax(DWORD SrcAddress, DWORD DstAddress, DWORD OutPutBKBytes, DWORD NumberOfBytes)
{
    CopyMemory((LPVOID)OutPutBKBytes, (LPVOID)SrcAddress, NumberOfBytes);

    /*
    Memory2DynamicStruct.exe+1870 - 55                    - push ebp
    Memory2DynamicStruct.exe+1871 - 8B EC                 - mov ebp,esp
    Memory2DynamicStruct.exe+1873 - 83 EC 0C              - sub esp,0C { 12 }
    Memory2DynamicStruct.exe+1876 - 8B 45 08              - mov eax,[ebp+08]
    ...
    Memory2DynamicStruct.exe+19B4 - C2 0800               - ret 0008 { 8 }

    Memory2DynamicStruct.exe+1870 - B8 78563412           - mov eax,12345678 { 305419896 }
    Memory2DynamicStruct.exe+1875 - FF E0                 - jmp eax
    Memory2DynamicStruct.exe+1877 - 90                    - nop
    Memory2DynamicStruct.exe+1878 - 90                    - nop
    */
    WriteInProcessBYTE(SrcAddress, 0xB8);
    WriteInProcessDWORD(SrcAddress + 0x01, DstAddress);
    WriteInProcessWORD(SrcAddress + 0x05, 0xE0FF);

    for (size_t i = 7; i < NumberOfBytes; i++)
    {
        WriteInProcessBYTE(SrcAddress + i, 0x90);
    }

    /*std::cout << "BK" << std::endl;

    for (size_t i = 0; i < NumberOfBytes; i++)
    {
        std::cout << std::hex << (DWORD)ReadInProcessBYTE(OutPutBKBytes + i) << std::endl;
    }

    std::cout << "---" << std::endl;*/
}

void Restore_Move_Eax_Jmp_Eax(DWORD SrcAddress, DWORD OutPutBKBytes, DWORD NumberOfBytes)
{
    //CopyMemory((LPVOID)SrcAddress, (LPVOID)OutPutBKBytes, sizeof(OutPutBKBytes));

    for (size_t i = 0; i < NumberOfBytes; i++)
    {
        WriteInProcessBYTE(SrcAddress + i, ReadInProcessBYTE(OutPutBKBytes + i));
    }
}

void WINAPI boku_no_push_back(DWORD pMyLast, DWORD PointerWithValue)
{
    //DWORD Value = 0;

    BaseVector_Release* VarBaseVector;

    VarBaseVector = (BaseVector_Release*)(AddressAlloc);

    //std::cout << std::hex << "pMyLast: " << pMyLast << std::endl;

    /*switch (CurrentType)
    {
        case eTaipu::eInt:
            //Value = ReadInProcessDWORD(PointerWithValue);
            //std::cout << std::hex << "PointerWithValue: " << Value << std::endl;

            //WriteInProcessDWORD(pMyLast, Value);
            //WriteInProcessDWORD(pMyLast + 0x04, 0xABABABAB);
            //WriteInProcessDWORD(pMyLast + 0x08, 0xABABABAB);
            //WriteInProcessDWORD(pMyLast + 0x0C, 0x00000000);
            //WriteInProcessDWORD(pMyLast + 0x10, 0x00000000);

            break;
        case eTaipu::eStruct:
            //std::cout << std::hex << "PointerWithValue: " << Value << std::endl;

            //CopyMemory((LPVOID)pMyLast, (LPVOID)PointerWithValue, sizeof(tHook));

            break;
    }*/

    CopyMemory((LPVOID)pMyLast, (LPVOID)PointerWithValue, VectorHoldingSize);

    VarBaseVector->pVectorPointers->pMyLast = pMyLast + VectorHoldingSize; //0x8
    VarBaseVector->pVectorPointers->pMyEnd = VarBaseVector->pVectorPointers->pMyLast; //0xC
}

void HookVector_push_back()
{
    DWORD tmpAdd = 0;

    /*
    * push_back:
    *       minkernel\crts\ucrt\src\appcrt\heap\debug_heap.cpp
    *       _CrtlsValidHeapPointer(block)
    */
    //FitAddress2Vector_Debug((DWORD)Add);
    //std::vector<int>* v = (std::vector<int>*)AddressAlloc;
    std::vector<int>* v = (std::vector<int>*)(ReadInProcessDWORD((DWORD)AddressAlloc));
    //std::vector<int>* v = new std::vector<int>(10);

    __asm
    {
        ; int 3
        ; nop
        ; int 3
        lea eax, [v]
        mov tmpAdd, eax
        jmp _next
    }

    v->push_back(0x666);

    __asm
    {
    _next:
        call _t
    _t :
        pop eax
        sub eax, 0x0A

        mov tmpAdd, eax
        ; int 3
        ; nop
        ; int 3
    }

    std::cout << std::hex << "HookVector_push_back::GetRealCall: " << GetRealCALL(tmpAdd) << std::endl;

    tmpAdd = GetRealCALL(tmpAdd);

    __asm
    {
        mov ecx, -1
        mov edi, tmpAdd
        mov eax, Push_Back_VS2019_MagicNumber; 0x75FF0004
        cld
    _keep:
        repne scasb
        cmp byte ptr [edi], ah
        jne _keep
        inc edi
        inc edi
        inc edi
        mov tmpAdd, edi
    }

    /*
    Memory2DynamicStruct.exe+1870 - 55                    - push ebp
    Memory2DynamicStruct.exe+1871 - 8B EC                 - mov ebp,esp
    Memory2DynamicStruct.exe+1873 - 83 EC 0C              - sub esp,0C { 12 }
    Memory2DynamicStruct.exe+1876 - 8B 45 08              - mov eax,[ebp+08]
    ...
    Memory2DynamicStruct.exe+19B4 - C2 0800               - ret 0008 { 8 }

    Memory2DynamicStruct.exe+1870 - B8 78563412           - mov eax,12345678 { 305419896 }
    Memory2DynamicStruct.exe+1875 - FF E0                 - jmp eax
    Memory2DynamicStruct.exe+1877 - 90                    - nop
    Memory2DynamicStruct.exe+1878 - 90                    - nop
    */
    std::cout << std::hex << "HookVector_push_back::GetRealCall: " << GetRealCALL(tmpAdd) << std::endl;

    Address_Push_Back = GetRealCALL(tmpAdd);

    //std::cin.get();

    Patch_Mov_Eax_Jmp_Eax(Address_Push_Back, (DWORD)&boku_no_push_back, (DWORD)&Bk_Push_Back[0], sizeof(Bk_Push_Back));
}

void HookVector_push_back_struct()
{
    DWORD tmpAdd = 0;

    tHook tmp;

    tmp.Base = 0x12345678;
    tmp.Offset = 0x1234;
    FillMemory(tmp.DllPath, sizeof(tmp.DllPath), 0x45);
    tmp.DllPath[sizeof(tmp.DllPath) - 1] = '\0';
    tmp.Activated = true;
    //strncpy(a, "iqbal", sizeof(a) - 1);
    tmp.HookedAddress = tmp.Base + tmp.Offset + 3;
    tmp.Count = 0x1234567887654321;

    /*
    * push_back:
    *       minkernel\crts\ucrt\src\appcrt\heap\debug_heap.cpp
    *       _CrtlsValidHeapPointer(block)
    */
    //FitAddress2Vector_Debug((DWORD)Add);
    //std::vector<int>* v = (std::vector<int>*)AddressAlloc;
    std::vector<tHook>* v = (std::vector<tHook>*)(ReadInProcessDWORD((DWORD)AddressAlloc));
    //std::vector<int>* v = new std::vector<int>(10);

    //std::cin.get();

    __asm
    {
        ; int 3
        ; nop
        ; int 3
        lea eax, [v]
        mov tmpAdd, eax
        jmp _next
    }

    v->push_back(tmp);

    __asm
    {
    _next:
        call _t
    _t :
        pop eax
        sub eax, 0x0A

        mov tmpAdd, eax
        ; int 3
        ; nop
        ; int 3
    }

    std::cout << std::hex << "HookVector_push_back_struct::GetRealCall: " << GetRealCALL(tmpAdd) << std::endl;

    tmpAdd = GetRealCALL(tmpAdd);

    __asm
    {
        mov ecx, -1
        mov edi, tmpAdd
        mov eax, Push_Back_VS2019_MagicNumber; 0x0004C25D (struct)
        cld
        ; repne scasd
        ; add edi, 0x04
    _keep:
        repne scasb
        cmp byte ptr [edi], ah
        jne _keep
        inc edi
        inc edi
        inc edi
        mov tmpAdd, edi
    }

    /*
    Memory2DynamicStruct.exe+1870 - 55                    - push ebp
    Memory2DynamicStruct.exe+1871 - 8B EC                 - mov ebp,esp
    Memory2DynamicStruct.exe+1873 - 83 EC 0C              - sub esp,0C { 12 }
    Memory2DynamicStruct.exe+1876 - 8B 45 08              - mov eax,[ebp+08]
    ...
    Memory2DynamicStruct.exe+19B4 - C2 0800               - ret 0008 { 8 }

    Memory2DynamicStruct.exe+1870 - B8 78563412           - mov eax,12345678 { 305419896 }
    Memory2DynamicStruct.exe+1875 - FF E0                 - jmp eax
    Memory2DynamicStruct.exe+1877 - 90                    - nop
    Memory2DynamicStruct.exe+1878 - 90                    - nop
    */
    std::cout << std::hex << "HookVector_push_back_struct::GetRealCall: " << GetRealCALL(tmpAdd) << std::endl;

    Address_Push_Back = GetRealCALL(tmpAdd);

    //std::cin.get();

    Patch_Mov_Eax_Jmp_Eax(Address_Push_Back, (DWORD)&boku_no_push_back, (DWORD)&Bk_Push_Back[0], sizeof(Bk_Push_Back));
}

void WINAPI boku_no_resize_AboveOrEqual(DWORD NewSize, DWORD OldSize)
{
    //std::cout << std::dec << "NewSize: " << NewSize << " (0x" << std::hex << NewSize << ")" << std::endl;
    //std::cout << std::dec << "OldSize: " << OldSize << " (0x" << std::hex << OldSize << ")" << std::endl;

    BaseVector_Release* VarBaseVector;

    VarBaseVector = (BaseVector_Release*)(AddressAlloc);

    DWORD bkLast = VarBaseVector->pVectorPointers->pMyLast;
    DWORD DeltaSize = 0;

    switch (CurrentType)
    {
        case eTaipu::eInt:

            break;
        case eTaipu::eStruct:
            OldSize /= sizeof(tHook);

            //std::cout << std::dec << "New OldSize Struct: " << OldSize << " (0x" << std::hex << OldSize << ")" << std::endl;

            break;
    }

    if ((DWORD)NewSize >= (DWORD)OldSize)
    {
        DeltaSize = (NewSize - OldSize);
        //std::cout << "111111111111" << std::endl;
    }
    else
    {
        DeltaSize = NewSize - ((VarBaseVector->pVectorPointers->pMyLast - VarBaseVector->pVectorPointers->pMyFirst) / VectorHoldingSize);
        //std::cout << "222222222222" << std::endl;
    }

    //std::cout << std::dec << "DeltaSize: " << DeltaSize << " (0x" << std::hex << DeltaSize << ")" << std::endl << std::endl;

    //VarBaseVector->pVectorPointers->pMyLast = VarBaseVector->pVectorPointers->pMyLast + (0x04 * DeltaSize); //0x8
    VarBaseVector->pVectorPointers->pMyLast = VarBaseVector->pVectorPointers->pMyLast + (VectorHoldingSize * DeltaSize); //0x8
    VarBaseVector->pVectorPointers->pMyEnd = VarBaseVector->pVectorPointers->pMyLast; //0xC

    ZeroMemory((LPVOID)bkLast, (VectorHoldingSize * DeltaSize));

    /*for (size_t i = 0; i < DeltaSize; i++)
    {
        WriteInProcessDWORD(bkLast + (i * 0x04), 0x00000000);
    }*/

    //WriteInProcessDWORD(VarBaseVector->pVectorPointers->pMyLast + 0x00, 0xABABABAB);
    //WriteInProcessDWORD(VarBaseVector->pVectorPointers->pMyLast + 0x04, 0xABABABAB);
    //WriteInProcessDWORD(VarBaseVector->pVectorPointers->pMyLast + 0x08, 0x00000000);
    //WriteInProcessDWORD(VarBaseVector->pVectorPointers->pMyLast + 0x0C, 0x00000000);
}

void HookVector_resize_AboveOrEqual()
{
    DWORD tmpAdd = 0;

    //std::vector<int>* v = (std::vector<int>*)AddressAlloc;
    std::vector<int>* v = (std::vector<int>*)(ReadInProcessDWORD((DWORD)AddressAlloc));
    //std::vector<int>* v = new std::vector<int>(10);

    //std::cin.get();

    __asm
    {
        ; int 3
        ; nop
        ; int 3
        lea eax, [v]
        mov tmpAdd, eax
        jmp _next
    }

    /*
    Memory2DynamicStruct.exe+15DC - 6A 03                 - push 03 { 3 }
    Memory2DynamicStruct.exe+15DE - 8B 4D F4              - mov ecx,[ebp-0C]
    Memory2DynamicStruct.exe+15E1 - E8 5A0A0000           - call Memory2DynamicStruct.exe+2040
    */
    v->resize(7);

    __asm
    {
    _next:
        call _t
    _t :
        pop eax
        sub eax, 0x0A

        mov tmpAdd, eax
        ; int 3
        ; nop
        ; int 3
    }

    std::cout << std::hex << "HookVector_resize_AboveOrEqual::GetRealCall: " << GetRealCALL(tmpAdd) << std::endl;

    tmpAdd = GetRealCALL(tmpAdd);

    //std::cin.get();

    __asm
    {
        ; int 3
        ; nop
        ; int 3
        mov ecx, -1
        mov edi, tmpAdd
        mov eax, Resize_AboveOrEqual_VS2019_MagicNumber; 0x00005651
        cld
    _keep:
        repne scasb
        cmp byte ptr [edi], ah
        jne _keep
        inc edi
        inc edi
        inc edi
        mov tmpAdd, edi
    }

    std::cout << std::hex << "HookVector_resize_AboveOrEqual::GetRealCall: " << GetRealCALL(tmpAdd) << std::endl;

    Address_Resize_AboveOrEqual = GetRealCALL(tmpAdd);

    Patch_Mov_Eax_Jmp_Eax(Address_Resize_AboveOrEqual, (DWORD)&boku_no_resize_AboveOrEqual, (DWORD)&Bk_Resize_AboveOrEqual[0], sizeof(Bk_Resize_AboveOrEqual));

    //std::cin.get();
}

void HookVector_resize_AboveOrEqual_struct()
{
    DWORD tmpAdd = 0;

    //std::vector<int>* v = (std::vector<int>*)AddressAlloc;
    std::vector<tHook>* v = (std::vector<tHook>*)(ReadInProcessDWORD((DWORD)AddressAlloc));
    //std::vector<int>* v = new std::vector<int>(10);

    //std::cin.get();

    __asm
    {
        ; int 3
        ; nop
        ; int 3
        lea eax, [v]
        mov tmpAdd, eax
        jmp _next
    }

    /*
    Memory2DynamicStruct.exe+15DC - 6A 03                 - push 03 { 3 }
    Memory2DynamicStruct.exe+15DE - 8B 4D F4              - mov ecx,[ebp-0C]
    Memory2DynamicStruct.exe+15E1 - E8 5A0A0000           - call Memory2DynamicStruct.exe+2040
    */
    v->resize(7);

    __asm
    {
    _next:
        call _t
    _t :
        pop eax
        sub eax, 0x0A

        mov tmpAdd, eax
        ; int 3
        ; nop
        ; int 3
    }

    std::cout << std::hex << "HookVector_resize_AboveOrEqual_struct::GetRealCall: " << GetRealCALL(tmpAdd) << std::endl;

    tmpAdd = GetRealCALL(tmpAdd);

    //std::cin.get();

    __asm
    {
        ; int 3
        ; nop
        ; int 3
        mov ecx, -1
        mov edi, tmpAdd
        mov eax, Resize_AboveOrEqual_VS2019_MagicNumber; 0x00005651
        cld
    _keep:
        repne scasb
        cmp byte ptr [edi], ah
        jne _keep
        inc edi
        inc edi
        inc edi
        mov tmpAdd, edi
    }

    std::cout << std::hex << "HookVector_resize_AboveOrEqual_struct::GetRealCall: " << GetRealCALL(tmpAdd) << std::endl;

    Address_Resize_AboveOrEqual = GetRealCALL(tmpAdd);

    Patch_Mov_Eax_Jmp_Eax(Address_Resize_AboveOrEqual, (DWORD)&boku_no_resize_AboveOrEqual, (DWORD)&Bk_Resize_AboveOrEqual[0], sizeof(Bk_Resize_AboveOrEqual));

    //std::cin.get();
}

//Cool, but finally not necessary
template <typename T>
void M_resize(std::vector<T>& vec, DWORD NewValue)
{
    vec.resize(NewValue);

    BaseVector_Release* VarBaseVector;

    VarBaseVector = (BaseVector_Release*)(AddressAlloc);

    if (VarBaseVector->pVectorPointers->pMyLast == VarBaseVector->pVectorPointers->pMyEnd) return;

    DWORD Delta = (VarBaseVector->pVectorPointers->pMyEnd - VarBaseVector->pVectorPointers->pMyLast) / VectorHoldingSize;

    WriteInProcessDWORD(VarBaseVector->pVectorPointers->pMyEnd + 0x04, 0x00000000);

    for (size_t i = 0; i < Delta; i++)
    {
        WriteInProcessDWORD(VarBaseVector->pVectorPointers->pMyEnd - (i * 0x04), 0x00000000);
    }

    //WriteInProcessDWORD(VarBaseVector->pVectorPointers->pMyLast + 0x00, 0xABABABAB);
    //WriteInProcessDWORD(VarBaseVector->pVectorPointers->pMyLast + 0x04, 0xABABABAB);

    VarBaseVector->pVectorPointers->pMyEnd = VarBaseVector->pVectorPointers->pMyLast;
}

void TestMemory2Vector()
{
    if (InitAllocation())
    {
        HookVector_push_back();
        HookVector_resize_AboveOrEqual();

        //std::vector<int>* v = (std::vector<int>*)(*(DWORD*)(AddressAlloc));

        //std::cout << "v->push_back(666);" << std::endl;
        //std::cin.get();

        //std::cout << std::dec << v->size() << std::endl;
        //std::vector<int>& vr = *v;
        std::vector<int>& vr = *(std::vector<int>*)(*(DWORD*)(AddressAlloc));
        DWORD NewSize = 0;
        DWORD LastSize = vr.size();
        int ValToPush = 0;

        // ------------------------------------------------------------------------------- //
        std::cout << std::endl << "Listing items:"; // << std::endl;
        std::cin.get();

        for (size_t i = 0; i < vr.size(); i++)
        {
            std::cout << std::hex << "\t" << "var[" << std::dec << (DWORD)i << "]: 0x" << std::hex << vr[i] << std::endl;
        }

        // ------------------------------------------------------------------------------- //
        ValToPush = 0x111;
        std::cout << std::endl << "Pushing 0x" << std::hex << ValToPush << " and Listing items:"; // << std::endl;
        std::cin.get();

        vr.push_back(ValToPush);

        for (size_t i = 0; i < vr.size(); i++)
        {
            std::cout << std::hex << "\t" << "var[" << std::dec << (DWORD)i << "]: 0x" << std::hex << vr[i] << std::endl;
        }
        LastSize = vr.size();

        // ------------------------------------------------------------------------------- //
        ValToPush = 0x222;
        std::cout << std::endl << "Modify index 0 to 0x" << std::hex << ValToPush << " and Listing items:"; // << std::endl;
        std::cin.get();

        vr[0] = ValToPush;

        for (size_t i = 0; i < vr.size(); i++)
        {
            std::cout << std::hex << "\t" << "var[" << std::dec << (DWORD)i << "]: 0x" << std::hex << vr[i] << std::endl;
        }

        // ------------------------------------------------------------------------------- //
        std::cout << std::endl << "B4 resizing Above or Equal"; // << std::endl;
        std::cin.get();
        /*__asm
        {
            int 3
            nop
            int 3
        }*/

        NewSize = 7;

        vr.resize(NewSize); //don't need M_resize(vr, NewSize); because it is Above or Equal, but it's good to call it to avoid shits

        std::cout << std::dec << "resize " << LastSize << " to " << NewSize << " and Listing items:" << std::endl;

        for (size_t i = 0; i < vr.size(); i++)
        {
            std::cout << std::hex << "\t" << "var[" << std::dec << (DWORD)i << "]: 0x" << std::hex << vr[i] << std::endl;
        }

        //std::cin.get();

        // ------------------------------------------------------------------------------- //
        std::cout << std::endl << "sort ascending and Listing items:"; // << std::endl;
        std::cin.get();

        std::sort(vr.begin(), vr.end());

        for (size_t i = 0; i < vr.size(); i++)
        {
            std::cout << std::hex << "\t" << "var[" << std::dec << (DWORD)i << "]: 0x" << std::hex << vr[i] << std::endl;
        }

        // ------------------------------------------------------------------------------- //
        std::cout << std::endl << "vr.empty(): " << (vr.empty() ? "YES" : "NO"); // << std::endl;
        std::cin.get();

        // ------------------------------------------------------------------------------- //
        std::cout << std::endl << "vr.shrink_to_fit()"; // << std::endl;
        std::cin.get();

        vr.shrink_to_fit();

        // ------------------------------------------------------------------------------- //
        std::cout << std::endl << "clear and Listing items:"; // << std::endl;
        std::cin.get();

        vr.clear();

        if (vr.size())
        {
            for (size_t i = 0; i < vr.size(); i++)
            {
                std::cout << std::hex << "\t" << "var[" << std::dec << (DWORD)i << "]: 0x" << std::hex << vr[i] << std::endl;
            }
        }
        else
        {
            std::cout << "NO ITEMS" << std::endl;
        }
        LastSize = vr.size();

        // ------------------------------------------------------------------------------- //
        std::cout << std::endl << "vr.empty(): " << (vr.empty() ? "YES" : "NO"); // << std::endl;
        std::cin.get();

        // ------------------------------------------------------------------------------- //
        std::cout << std::endl << "Pushing for and Listing items:"; // << std::endl;
        std::cin.get();

        for (size_t i = 0; i < 12; i++)
        {
            vr.push_back(i);
        }

        for (size_t i = 0; i < vr.size(); i++)
        {
            std::cout << std::hex << "\t" << "var[" << std::dec << (DWORD)i << "]: 0x" << std::hex << vr[i] << std::endl;
        }
        LastSize = vr.size();

        // ------------------------------------------------------------------------------- //
        std::cout << std::endl << "B4 resizing below or check"; // << std::endl;
        std::cin.get();
        /*__asm
        {
            int 3
            nop
            int 3
        }*/

        NewSize = 3;

        vr.resize(NewSize); //M_resize(vr, NewSize); //not necessary, but good to keep in mind the internal functionality

        std::cout << std::dec << "resize " << LastSize << " to " << NewSize << " and Listing items:" << std::endl;

        for (size_t i = 0; i < vr.size(); i++)
        {
            std::cout << std::hex << "\t" << "var[" << std::dec << (DWORD)i << "]: 0x" << std::hex << vr[i] << std::endl;
        }

        //std::cin.get();

        // ------------------------------------------------------------------------------- //
        std::cout << std::endl << "pop_back x3 and Listing items:"; // << std::endl;
        std::cin.get();
        vr.pop_back();
        vr.pop_back();
        vr.pop_back();

        if (vr.size())
        {
            for (size_t i = 0; i < vr.size(); i++)
            {
                std::cout << std::hex << "\t" << "var[" << std::dec << (DWORD)i << "]: 0x" << std::hex << vr[i] << std::endl;
            }
        }
        else
        {
            std::cout << "NO ITEMS" << std::endl;
        }
        LastSize = vr.size();

        // ------------------------------------------------------------------------------- //
        // ------------------------------------------------------------------------------- //
        ValToPush = 0x12345678;
        std::cout << std::endl << "Pushing 0x" << std::hex << ValToPush << " and Listing items:"; // << std::endl;
        std::cin.get();

        /*__asm
        {
            int 3
            nop
            int 3
        }*/

        vr.push_back(ValToPush);

        /*__asm
        {
            int 3
            nop
            int 3
        }*/

        for (size_t i = 0; i < vr.size(); i++)
        {
            std::cout << std::hex << "\t" << "var[" << std::dec << (DWORD)i << "]: 0x" << std::hex << vr[i] << std::endl;
        }
        LastSize = vr.size();

        // ------------------------------------------------------------------------------- //
        std::cout << std::endl << "Gonna VirtualFree" << std::endl;
        std::cin.get();

        VirtualFree(AddressAlloc, 0, MEM_RELEASE);

        std::cout << "Freed" << std::endl;
    }

    Restore_Move_Eax_Jmp_Eax(Address_Push_Back, (DWORD)&Bk_Push_Back[0], sizeof(Bk_Push_Back));
    Restore_Move_Eax_Jmp_Eax(Address_Resize_AboveOrEqual, (DWORD)&Bk_Resize_AboveOrEqual[0], sizeof(Bk_Resize_AboveOrEqual));

    std::cout << std::endl << "Normal vector push_back..." << std::endl;
    std::cin.get();

    std::vector<int> asd;

    asd.push_back(0x123);

    for (size_t i = 0; i < asd.size(); i++)
    {
        std::cout << std::dec << "asd[" << (DWORD)i << "]: 0x" << std::hex << asd[i] << std::endl;
    }

    std::cout << std::endl << "Normal vector resize Above or Equal..." << std::endl;
    std::cin.get();

    asd.resize(3);

    asd[1] = 0x456;
    asd[2] = 0x789;

    for (size_t i = 0; i < asd.size(); i++)
    {
        std::cout << std::dec << "asd[" << (DWORD)i << "]: 0x" << std::hex << asd[i] << std::endl;
    }

    std::cout << std::endl << "Normal vector resize less..." << std::endl;
    std::cin.get();

    asd.resize(1);

    for (size_t i = 0; i < asd.size(); i++)
    {
        std::cout << std::dec << "asd[" << (DWORD)i << "]: 0x" << std::hex << asd[i] << std::endl;
    }
}

void TestMemory2VectorStruct_debugging()
{
    std::vector<tHook>* v = new std::vector<tHook>;

    std::cin.get();

    __asm
    {
        int 3
        nop
        int 3
        lea eax, v
    }

    tHook tmp;

    tmp.Base = 0x12345678;
    tmp.Offset = 0x1234;
    FillMemory(tmp.DllPath, sizeof(tmp.DllPath), 0x45);
    tmp.DllPath[sizeof(tmp.DllPath) - 1] = '\0';
    tmp.Activated = true;
    //strncpy(a, "iqbal", sizeof(a) - 1);
    tmp.HookedAddress = tmp.Base + tmp.Offset + 3;
    tmp.Count = 0x1234567887654321;

    v->push_back(tmp);

    __asm
    {
        int 3
        nop
        int 3
    }
}

void TestMemory2VectorStruct()
{
    tHook tmp;

    tmp.Base = 0x22222222;
    tmp.Offset = 0x333;
    FillMemory(tmp.DllPath, sizeof(tmp.DllPath), 0x46);
    tmp.DllPath[sizeof(tmp.DllPath) - 1] = '\0';
    tmp.Activated = false;
    //strncpy(a, "iqbal", sizeof(a) - 1);
    tmp.HookedAddress = tmp.Base + tmp.Offset + 3;
    tmp.Count = 0x1234000000004321;

    if (InitAllocation())
    {
        HookVector_push_back_struct();
        HookVector_resize_AboveOrEqual_struct();

        //std::vector<int>* v = (std::vector<int>*)(*(DWORD*)(AddressAlloc));

        //std::cout << "v->push_back(666);" << std::endl;
        //std::cin.get();

        //std::cout << std::dec << v->size() << std::endl;
        //std::vector<int>& vr = *v;
        std::vector<tHook>& vr = *(std::vector<tHook>*)(*(DWORD*)(AddressAlloc));
        DWORD NewSize = 0;
        DWORD LastSize = vr.size();

        // ------------------------------------------------------------------------------- //
        std::cout << std::endl << "Listing items:"; // << std::endl;
        std::cin.get();

        for (size_t i = 0; i < vr.size(); i++)
        {
            std::cout << std::hex << "\t" << "var[" << std::dec << (DWORD)i << "]:" << std::endl;
            std::cout << "\t\t" << "Base: " << std::hex << vr[i].Base << std::endl;
            std::cout << "\t\t" << "Offset: " << std::hex << vr[i].Offset << std::endl;
            std::cout << "\t\t" << "DllPath: " << vr[i].DllPath << std::endl;
            std::cout << "\t\t" << "Activated: " << (vr[i].Activated ? "YES" : "NO") << std::endl;
            std::cout << "\t\t" << "HookedAddress: " << std::hex << vr[i].HookedAddress << std::endl;
            std::cout << "\t\t" << "Count: " << std::hex << vr[i].Count << std::endl;
        }
        std::cout << std::endl;

        // ------------------------------------------------------------------------------- //
        std::cout << std::endl << "Pushing struct and Listing items:"; // << std::endl;
        std::cin.get();

        vr.push_back(tmp);

        for (size_t i = 0; i < vr.size(); i++)
        {
            std::cout << std::hex << "\t" << "var[" << std::dec << (DWORD)i << "]:" << std::endl;
            std::cout << "\t\t" << "Base: " << std::hex << vr[i].Base << std::endl;
            std::cout << "\t\t" << "Offset: " << std::hex << vr[i].Offset << std::endl;
            std::cout << "\t\t" << "DllPath: " << vr[i].DllPath << std::endl;
            std::cout << "\t\t" << "Activated: " << (vr[i].Activated ? "YES" : "NO") << std::endl;
            std::cout << "\t\t" << "HookedAddress: " << std::hex << vr[i].HookedAddress << std::endl;
            std::cout << "\t\t" << "Count: " << std::hex << vr[i].Count << std::endl;
        }
        std::cout << std::endl;
        LastSize = vr.size();

        // ------------------------------------------------------------------------------- //
        tmp.Base = 0x11111111;
        tmp.Offset = 0x666;
        FillMemory(tmp.DllPath, sizeof(tmp.DllPath), 0x47);
        tmp.DllPath[sizeof(tmp.DllPath) - 1] = '\0';
        tmp.Activated = false;
        //strncpy(a, "iqbal", sizeof(a) - 1);
        tmp.HookedAddress = tmp.Base + tmp.Offset + 3;
        tmp.Count = 0x1234999999994321;

        std::cout << std::endl << "Modify index 0 and Listing items:"; // << std::endl;
        std::cin.get();

        vr[0] = tmp;

        for (size_t i = 0; i < vr.size(); i++)
        {
            std::cout << std::hex << "\t" << "var[" << std::dec << (DWORD)i << "]:" << std::endl;
            std::cout << "\t\t" << "Base: " << std::hex << vr[i].Base << std::endl;
            std::cout << "\t\t" << "Offset: " << std::hex << vr[i].Offset << std::endl;
            std::cout << "\t\t" << "DllPath: " << vr[i].DllPath << std::endl;
            std::cout << "\t\t" << "Activated: " << (vr[i].Activated ? "YES" : "NO") << std::endl;
            std::cout << "\t\t" << "HookedAddress: " << std::hex << vr[i].HookedAddress << std::endl;
            std::cout << "\t\t" << "Count: " << std::hex << vr[i].Count << std::endl;
        }
        std::cout << std::endl;

        // ------------------------------------------------------------------------------- //
        std::cout << std::endl << "B4 resizing Above or Equal"; // << std::endl;
        std::cin.get();
        /*__asm
        {
            int 3
            nop
            int 3
        }*/

        NewSize = 7;

        vr.resize(NewSize); //don't need M_resize(vr, NewSize); because it is Above or Equal, but it's good to call it to avoid shits

        std::cout << std::dec << "resize " << LastSize << " to " << NewSize << " and Listing items:" << std::endl;

        for (size_t i = 0; i < vr.size(); i++)
        {
            std::cout << std::hex << "\t" << "var[" << std::dec << (DWORD)i << "]:" << std::endl;
            std::cout << "\t\t" << "Base: " << std::hex << vr[i].Base << std::endl;
            std::cout << "\t\t" << "Offset: " << std::hex << vr[i].Offset << std::endl;
            std::cout << "\t\t" << "DllPath: " << vr[i].DllPath << std::endl;
            std::cout << "\t\t" << "Activated: " << (vr[i].Activated ? "YES" : "NO") << std::endl;
            std::cout << "\t\t" << "HookedAddress: " << std::hex << vr[i].HookedAddress << std::endl;
            std::cout << "\t\t" << "Count: " << std::hex << vr[i].Count << std::endl;
        }
        std::cout << std::endl;

        //std::cin.get();

        // ------------------------------------------------------------------------------- //
        std::cout << std::endl << "sort ascending and Listing items:"; // << std::endl;
        std::cin.get();

        //std::sort(vr.begin(), vr.end(), compareByHookedAddress);
        std::sort(vr.begin(), vr.end());

        for (size_t i = 0; i < vr.size(); i++)
        {
            std::cout << std::hex << "\t" << "var[" << std::dec << (DWORD)i << "]:" << std::endl;
            std::cout << "\t\t" << "Base: " << std::hex << vr[i].Base << std::endl;
            std::cout << "\t\t" << "Offset: " << std::hex << vr[i].Offset << std::endl;
            std::cout << "\t\t" << "DllPath: " << vr[i].DllPath << std::endl;
            std::cout << "\t\t" << "Activated: " << (vr[i].Activated ? "YES" : "NO") << std::endl;
            std::cout << "\t\t" << "HookedAddress: " << std::hex << vr[i].HookedAddress << std::endl;
            std::cout << "\t\t" << "Count: " << std::hex << vr[i].Count << std::endl;
        }
        std::cout << std::endl;

        // ------------------------------------------------------------------------------- //
        std::cout << std::endl << "sort descending and Listing items:"; // << std::endl;
        std::cin.get();

        std::sort(vr.begin(), vr.end(), std::greater<tHook>());

        for (size_t i = 0; i < vr.size(); i++)
        {
            std::cout << std::hex << "\t" << "var[" << std::dec << (DWORD)i << "]:" << std::endl;
            std::cout << "\t\t" << "Base: " << std::hex << vr[i].Base << std::endl;
            std::cout << "\t\t" << "Offset: " << std::hex << vr[i].Offset << std::endl;
            std::cout << "\t\t" << "DllPath: " << vr[i].DllPath << std::endl;
            std::cout << "\t\t" << "Activated: " << (vr[i].Activated ? "YES" : "NO") << std::endl;
            std::cout << "\t\t" << "HookedAddress: " << std::hex << vr[i].HookedAddress << std::endl;
            std::cout << "\t\t" << "Count: " << std::hex << vr[i].Count << std::endl;
        }
        std::cout << std::endl;

        // ------------------------------------------------------------------------------- //
        std::cout << std::endl << "vr.empty(): " << (vr.empty() ? "YES" : "NO"); // << std::endl;
        std::cin.get();

        // ------------------------------------------------------------------------------- //
        std::cout << std::endl << "vr.shrink_to_fit()"; // << std::endl;
        std::cin.get();

        vr.shrink_to_fit();

        // ------------------------------------------------------------------------------- //
        std::cout << std::endl << "clear and Listing items:"; // << std::endl;
        std::cin.get();

        vr.clear();

        if (vr.size())
        {
            for (size_t i = 0; i < vr.size(); i++)
            {
                std::cout << std::hex << "\t" << "var[" << std::dec << (DWORD)i << "]:" << std::endl;
                std::cout << "\t\t" << "Base: " << std::hex << vr[i].Base << std::endl;
                std::cout << "\t\t" << "Offset: " << std::hex << vr[i].Offset << std::endl;
                std::cout << "\t\t" << "DllPath: " << vr[i].DllPath << std::endl;
                std::cout << "\t\t" << "Activated: " << (vr[i].Activated ? "YES" : "NO") << std::endl;
                std::cout << "\t\t" << "HookedAddress: " << std::hex << vr[i].HookedAddress << std::endl;
                std::cout << "\t\t" << "Count: " << std::hex << vr[i].Count << std::endl;
            }
        }
        else
        {
            std::cout << "NO ITEMS" << std::endl;
        }
        LastSize = vr.size();

        // ------------------------------------------------------------------------------- //
        std::cout << std::endl << "vr.empty(): " << (vr.empty() ? "YES" : "NO"); // << std::endl;
        std::cin.get();

        // ------------------------------------------------------------------------------- //
        std::cout << std::endl << "Pushing for and Listing items:"; // << std::endl;
        std::cin.get();

        for (size_t i = 0; i < 12; i++)
        {
            vr.push_back(GenRandomStruct());
        }

        for (size_t i = 0; i < vr.size(); i++)
        {
            std::cout << std::hex << "\t" << "var[" << std::dec << (DWORD)i << "]:" << std::endl;
            std::cout << "\t\t" << "Base: " << std::hex << vr[i].Base << std::endl;
            std::cout << "\t\t" << "Offset: " << std::hex << vr[i].Offset << std::endl;
            std::cout << "\t\t" << "DllPath: " << vr[i].DllPath << std::endl;
            std::cout << "\t\t" << "Activated: " << (vr[i].Activated ? "YES" : "NO") << std::endl;
            std::cout << "\t\t" << "HookedAddress: " << std::hex << vr[i].HookedAddress << std::endl;
            std::cout << "\t\t" << "Count: " << std::hex << vr[i].Count << std::endl;
        }
        std::cout << std::endl;
        LastSize = vr.size();

        // ------------------------------------------------------------------------------- //
        std::cout << std::endl << "B4 resizing below or check"; // << std::endl;
        std::cin.get();
        /*__asm
        {
            int 3
            nop
            int 3
        }*/

        NewSize = 3;

        vr.resize(NewSize); //M_resize(vr, NewSize); //not necessary, but good to keep in mind the internal functionality

        std::cout << std::dec << "resize " << LastSize << " to " << NewSize << " and Listing items:" << std::endl;

        for (size_t i = 0; i < vr.size(); i++)
        {
            std::cout << std::hex << "\t" << "var[" << std::dec << (DWORD)i << "]:" << std::endl;
            std::cout << "\t\t" << "Base: " << std::hex << vr[i].Base << std::endl;
            std::cout << "\t\t" << "Offset: " << std::hex << vr[i].Offset << std::endl;
            std::cout << "\t\t" << "DllPath: " << vr[i].DllPath << std::endl;
            std::cout << "\t\t" << "Activated: " << (vr[i].Activated ? "YES" : "NO") << std::endl;
            std::cout << "\t\t" << "HookedAddress: " << std::hex << vr[i].HookedAddress << std::endl;
            std::cout << "\t\t" << "Count: " << std::hex << vr[i].Count << std::endl;
        }
        std::cout << std::endl;

        //std::cin.get();

        // ------------------------------------------------------------------------------- //
        std::cout << std::endl << "pop_back x3 and Listing items:"; // << std::endl;
        std::cin.get();
        vr.pop_back();
        vr.pop_back();
        vr.pop_back();

        if (vr.size())
        {
            for (size_t i = 0; i < vr.size(); i++)
            {
                std::cout << std::hex << "\t" << "var[" << std::dec << (DWORD)i << "]:" << std::endl;
                std::cout << "\t\t" << "Base: " << std::hex << vr[i].Base << std::endl;
                std::cout << "\t\t" << "Offset: " << std::hex << vr[i].Offset << std::endl;
                std::cout << "\t\t" << "DllPath: " << vr[i].DllPath << std::endl;
                std::cout << "\t\t" << "Activated: " << (vr[i].Activated ? "YES" : "NO") << std::endl;
                std::cout << "\t\t" << "HookedAddress: " << std::hex << vr[i].HookedAddress << std::endl;
                std::cout << "\t\t" << "Count: " << std::hex << vr[i].Count << std::endl;
            }
            std::cout << std::endl;
        }
        else
        {
            std::cout << "NO ITEMS" << std::endl;
        }
        LastSize = vr.size();

        // ------------------------------------------------------------------------------- //
        // ------------------------------------------------------------------------------- //
        std::cout << std::endl << "Pushing and Listing items:"; // << std::endl;
        std::cin.get();

        /*__asm
        {
            int 3
            nop
            int 3
        }*/

        vr.push_back(GenRandomStruct());

        /*__asm
        {
            int 3
            nop
            int 3
        }*/

        for (size_t i = 0; i < vr.size(); i++)
        {
            std::cout << std::hex << "\t" << "var[" << std::dec << (DWORD)i << "]:" << std::endl;
            std::cout << "\t\t" << "Base: " << std::hex << vr[i].Base << std::endl;
            std::cout << "\t\t" << "Offset: " << std::hex << vr[i].Offset << std::endl;
            std::cout << "\t\t" << "DllPath: " << vr[i].DllPath << std::endl;
            std::cout << "\t\t" << "Activated: " << (vr[i].Activated ? "YES" : "NO") << std::endl;
            std::cout << "\t\t" << "HookedAddress: " << std::hex << vr[i].HookedAddress << std::endl;
            std::cout << "\t\t" << "Count: " << std::hex << vr[i].Count << std::endl;
        }
        std::cout << std::endl;
        LastSize = vr.size();

        // ------------------------------------------------------------------------------- //
        std::cout << std::endl << "Gonna VirtualFree" << std::endl;
        std::cin.get();

        VirtualFree(AddressAlloc, 0, MEM_RELEASE);

        std::cout << "Freed" << std::endl;
    }

    Restore_Move_Eax_Jmp_Eax(Address_Push_Back, (DWORD)&Bk_Push_Back[0], sizeof(Bk_Push_Back));
    Restore_Move_Eax_Jmp_Eax(Address_Resize_AboveOrEqual, (DWORD)&Bk_Resize_AboveOrEqual[0], sizeof(Bk_Resize_AboveOrEqual));

    std::cout << std::endl << "Normal vector push_back..." << std::endl;
    std::cin.get();

    std::vector<int> asd;

    asd.push_back(0x123);

    for (size_t i = 0; i < asd.size(); i++)
    {
        std::cout << std::dec << "asd[" << (DWORD)i << "]: 0x" << std::hex << asd[i] << std::endl;
    }

    std::cout << std::endl << "Normal vector resize Above or Equal..." << std::endl;
    std::cin.get();

    asd.resize(3);

    asd[1] = 0x456;
    asd[2] = 0x789;

    for (size_t i = 0; i < asd.size(); i++)
    {
        std::cout << std::dec << "asd[" << (DWORD)i << "]: 0x" << std::hex << asd[i] << std::endl;
    }

    std::cout << std::endl << "Normal vector resize less..." << std::endl;
    std::cin.get();

    asd.resize(1);

    for (size_t i = 0; i < asd.size(); i++)
    {
        std::cout << std::dec << "asd[" << (DWORD)i << "]: 0x" << std::hex << asd[i] << std::endl;
    }
}

int main()
{
    CurrentType = eTaipu::eStruct;
    //std::cout << sizeof(tHook) << std::endl;

    switch (CurrentType)
    {
        case eTaipu::eInt:
            TestMemory2Vector();

            break;
        case eTaipu::eStruct:
            //TestMemory2VectorStruct_debugging();
            TestMemory2VectorStruct();

            break;
    }

    std::cout << std::endl << "Press enter to exit the program..." << std::endl;
    std::cin.get();

    return 0;
}