#include <stdio.h>
#include <stdbool.h>
#include <string.h>
#include <stdlib.h>
#include <inttypes.h>
 
static const uint8_t Base64IndexTable[]="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
#define DECODE_MAP_SIZE 80
static char Base64DecodeTable[DECODE_MAP_SIZE];
 
static void generateDecodeTable()
{
    static bool isDecodeMapGenerated = false;
 
    if(!isDecodeMapGenerated)
    {
        const size_t base64_encode_map_size = strlen(Base64IndexTable);
        memset(Base64DecodeTable, base64_encode_map_size, DECODE_MAP_SIZE);
 
        for (size_t i = 0; i < base64_encode_map_size; ++i)
        {
            Base64DecodeTable[Base64IndexTable[i]] = i;
        }
        isDecodeMapGenerated = true;
    }
}
 
char* decode(const char* encoded_str)
{
    char buffer[4];
    char* decoded_str = malloc(strlen(encoded_str) * 3 / 4);
    int p = 0;
    const size_t base64_encode_map_size = strlen(Base64IndexTable);
 
    generateDecodeTable();
 
    for(int i = 0; encoded_str[i] != '\0'; i++)
    {
        buffer[i%4] = Base64DecodeTable[encoded_str[i]];
        if((i+1)%4 == 0)
        {
            decoded_str[p++] = (buffer[0] << 2) + (buffer[1] >> 4);
            if(buffer[2] != base64_encode_map_size)
            {
                decoded_str[p++] = (buffer[1] << 4) + (buffer[2] >> 2);
            }
            if(buffer[3] != base64_encode_map_size)
            {
                decoded_str[p++] = (buffer[2] << 6) + buffer[3];
            }
        }
    }
 
    decoded_str[p] = '\0';
 
    printf("p = %d, size = %ld\n", p, strlen(encoded_str) * 3 / 4);
 
    return decoded_str;
}
 
int main()
{
    const char* encoded1 = "LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0tCk1JSURIakNDQWdhZ0F3SUJBZ0lSQUpBSUdqNUdCWmM0NzF0eUFiZnl3cVF3RFFZSktvWklodmNOQVFFTEJRQXcKSnpFbE1DTUdBMVVFQXhNY2NXRXRZMkVnUzJsMFkyaGxia052Ym01bFkzUWdVbTl2ZENCRFFUQWVGdzB5TkRFeQpNak14TWpNeE5UWmFGdzB5TlRFeU1qTXhNak14TlRaYU1DY3hKVEFqQmdOVkJBTVRISEZoTFdOaElFdHBkR05vClpXNURiMjV1WldOMElGSnZiM1FnUTBFd2dnRWlNQTBHQ1NxR1NJYjNEUUVCQVFVQUE0SUJEd0F3Z2dFS0FvSUIKQVFERzlMbGVFKzVRR0VZNTJGZVRmd3JqMlI0aFNBZHhPNkFyRERzLzM0QytkRDhmNGk2OTI5MFhNbUhBRWZnVQpiYkt6MTIvM2FHSDZhQ2EvZUVnQUt4SDE1YWxHZS9mTGdkOHRlcjJ4RWMvMjZZUDZGSExLZTBYN2FMZTFteCtuCmxlM3ZWZ3VMMWt0Qng0NEFUV0pucDVPNjl4aEtzZml1NlA0UzlSVkhnK3hxUGxsbi9ZdWFKdjBsKzd4MTlKM3EKWmlJT1owVVdoRGcwbjZrWGRjWTNuSSs5QVZCRUgzRjVzN0pod0Q2aFNqUGR5QmtPSGtkK2Vmc3FkVGlFOFAvcgpPTEkyVEFzOTFxUlNKc0FlMUtydUU1Y1ZrRTZUUzhTOHY5SUY1alFPUlJnUFBzckx5MGRJUjh0R09PSnRXeFVECjN4cWlrOUxIQ0FKMWJuZ09HYUdnZjk4ekFnTUJBQUdqUlRCRE1BNEdBMVVkRHdFQi93UUVBd0lCQmpBU0JnTlYKSFJNQkFmOEVDREFHQVFIL0FnRUJNQjBHQTFVZERnUVdCQlMwNWFCcC9FUDl1WVdjZ0c2b3FMM2w2QWdKdWpBTgpCZ2txaGtpRzl3MEJBUXNGQUFPQ0FRRUFsOUhzcEZnZTZMUFduYmU5eXdtWXVYWGUxZHlTb2VLOEVLa2hyNUhIClMrenhCazNpU1g1Z2ZobFJlR25yZWg5allCOEVOWmVPa2dZOVg3cjFqMkZDUTlLZFlrbXduRTFnbGJMelc0Qm0KdGNpSWNPbmRqckV6QlBRTUN5Y0sxVTUrYzkvT0lNUWRsdGJDYXlOWVlUM01aSG9tQ01QMks1Z1pVTnI0cnpQNgp5ZU9uOHNzT0hkSUtQa3RyWHN3cWpmTVVwU01LdHpxbE5CS0laM3pGbWhpTWJUeEJnQ3I5SlBEQlZPK3Zjdzc0CjFuUC9VRlhVN0VoWVhaV05BZGczTTc1MkkxSXVYT0VOZktuOURteGM2YU5oMFJwL1J1bXRYQ3FWWFROSWxub1YKYWpWRVRMMmQ0cTJjYUtOYlpVSmJxNnZadUppNm1Dd3o5MExDamhHT2dxRU9VQT09Ci0tLS0tRU5EIENFUlRJRklDQVRFLS0tLS0=";
    const char* encoded2 = "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";
    const char* encoded3 = "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";
 
    char* decoded = decode(encoded2);
 
    printf("Decoded:\n%s\n", decoded);
    free(decoded);
 
    return 0;
}

#include <stdio.h>
#include <stdbool.h>
#include <string.h>
#include <stdlib.h>
#include <inttypes.h>

static const uint8_t Base64IndexTable[]="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
#define DECODE_MAP_SIZE 80
static char Base64DecodeTable[DECODE_MAP_SIZE];

static void generateDecodeTable()
{
    static bool isDecodeMapGenerated = false;

    if(!isDecodeMapGenerated)
    {
        const size_t base64_encode_map_size = strlen(Base64IndexTable);
        memset(Base64DecodeTable, base64_encode_map_size, DECODE_MAP_SIZE);
    
        for (size_t i = 0; i < base64_encode_map_size; ++i)
        {
            Base64DecodeTable[Base64IndexTable[i]] = i;
        }
        isDecodeMapGenerated = true;
    }
}

char* decode(const char* encoded_str)
{
    char buffer[4];
    char* decoded_str = malloc(strlen(encoded_str) * 3 / 4);
    int p = 0;
    const size_t base64_encode_map_size = strlen(Base64IndexTable);

    generateDecodeTable();
    
    for(int i = 0; encoded_str[i] != '\0'; i++)
    {
        buffer[i%4] = Base64DecodeTable[encoded_str[i]];
        if((i+1)%4 == 0)
        {
            decoded_str[p++] = (buffer[0] << 2) + (buffer[1] >> 4);
            if(buffer[2] != base64_encode_map_size)
            {
                decoded_str[p++] = (buffer[1] << 4) + (buffer[2] >> 2);
            }
            if(buffer[3] != base64_encode_map_size)
            {
                decoded_str[p++] = (buffer[2] << 6) + buffer[3];
            }
        }
    }

    decoded_str[p] = '\0';
    
    printf("p = %d, size = %ld\n", p, strlen(encoded_str) * 3 / 4);
    
    return decoded_str;
}

int main()
{
    const char* encoded1 = "LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0tCk1JSURIakNDQWdhZ0F3SUJBZ0lSQUpBSUdqNUdCWmM0NzF0eUFiZnl3cVF3RFFZSktvWklodmNOQVFFTEJRQXcKSnpFbE1DTUdBMVVFQXhNY2NXRXRZMkVnUzJsMFkyaGxia052Ym01bFkzUWdVbTl2ZENCRFFUQWVGdzB5TkRFeQpNak14TWpNeE5UWmFGdzB5TlRFeU1qTXhNak14TlRaYU1DY3hKVEFqQmdOVkJBTVRISEZoTFdOaElFdHBkR05vClpXNURiMjV1WldOMElGSnZiM1FnUTBFd2dnRWlNQTBHQ1NxR1NJYjNEUUVCQVFVQUE0SUJEd0F3Z2dFS0FvSUIKQVFERzlMbGVFKzVRR0VZNTJGZVRmd3JqMlI0aFNBZHhPNkFyRERzLzM0QytkRDhmNGk2OTI5MFhNbUhBRWZnVQpiYkt6MTIvM2FHSDZhQ2EvZUVnQUt4SDE1YWxHZS9mTGdkOHRlcjJ4RWMvMjZZUDZGSExLZTBYN2FMZTFteCtuCmxlM3ZWZ3VMMWt0Qng0NEFUV0pucDVPNjl4aEtzZml1NlA0UzlSVkhnK3hxUGxsbi9ZdWFKdjBsKzd4MTlKM3EKWmlJT1owVVdoRGcwbjZrWGRjWTNuSSs5QVZCRUgzRjVzN0pod0Q2aFNqUGR5QmtPSGtkK2Vmc3FkVGlFOFAvcgpPTEkyVEFzOTFxUlNKc0FlMUtydUU1Y1ZrRTZUUzhTOHY5SUY1alFPUlJnUFBzckx5MGRJUjh0R09PSnRXeFVECjN4cWlrOUxIQ0FKMWJuZ09HYUdnZjk4ekFnTUJBQUdqUlRCRE1BNEdBMVVkRHdFQi93UUVBd0lCQmpBU0JnTlYKSFJNQkFmOEVDREFHQVFIL0FnRUJNQjBHQTFVZERnUVdCQlMwNWFCcC9FUDl1WVdjZ0c2b3FMM2w2QWdKdWpBTgpCZ2txaGtpRzl3MEJBUXNGQUFPQ0FRRUFsOUhzcEZnZTZMUFduYmU5eXdtWXVYWGUxZHlTb2VLOEVLa2hyNUhIClMrenhCazNpU1g1Z2ZobFJlR25yZWg5allCOEVOWmVPa2dZOVg3cjFqMkZDUTlLZFlrbXduRTFnbGJMelc0Qm0KdGNpSWNPbmRqckV6QlBRTUN5Y0sxVTUrYzkvT0lNUWRsdGJDYXlOWVlUM01aSG9tQ01QMks1Z1pVTnI0cnpQNgp5ZU9uOHNzT0hkSUtQa3RyWHN3cWpmTVVwU01LdHpxbE5CS0laM3pGbWhpTWJUeEJnQ3I5SlBEQlZPK3Zjdzc0CjFuUC9VRlhVN0VoWVhaV05BZGczTTc1MkkxSXVYT0VOZktuOURteGM2YU5oMFJwL1J1bXRYQ3FWWFROSWxub1YKYWpWRVRMMmQ0cTJjYUtOYlpVSmJxNnZadUppNm1Dd3o5MExDamhHT2dxRU9VQT09Ci0tLS0tRU5EIENFUlRJRklDQVRFLS0tLS0=";
    const char* encoded2 = "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";
    const char* encoded3 = "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";
    
    char* decoded = decode(encoded2);
    
    printf("Decoded:\n%s\n", decoded);
    free(decoded);

    return 0;
}