// Function to encode a given input string using Base64 encoding
char* base64_encode(const char *input, int len) {
    // Allocate memory for the output string (including null terminator)
    const int outlen = ((len + 2) / 3) * 4; // Calculate the length of the output string based on the input length
    char *output = malloc(outlen); // Allocate memory for the output string
    
    // Initialize variables to keep track of input and output indices, as well as any padding bytes that may be needed at the end
    int in_index = 0; // Index for tracking input bytes
    int out_index = 0; // Index for tracking output bytes
    int pad_bytes = (len % 3) ? ((4 - len % 3) % 4) : 0; // Calculate the number of padding bytes needed at the end of the output string
    
    // Loop through each input byte and encode it using the lookup table
    while(in_index < len) {
        unsigned char triplet[3]; // Array to store three input bytes at a time
        int bytes_read = 0; // Variable to track the number of bytes read in each iteration
        
        // Read in three bytes at a time (or less if we've reached the end of the input string)
        for(int i=0; i<3 && in_index < len; ++i, ++in_index) {
            triplet[i] = input[in_index]; // Store the input byte in the triplet array
            bytes_read++; // Increment the number of bytes read
        }
        
        // If we didn't read all three bytes, pad the remaining bytes with 0s and move on to encoding them separately
        if(bytes_read < 3) {
            for(int i=bytes_read; i<3; ++i) {
                triplet[i] = 0; // Pad the remaining bytes with 0s
            }
        }
        
        // Encode the resulting triplets using the lookup table and append them to the output string (with any necessary padding bytes)
        for(int i=0; i<bytes_read * 3 / 8; ++i) {
            unsigned char byte = (triplet[i/2] >> ((3-1-i%6)*4)) & 0x0F; // Extract the appropriate bits from the triplet to encode
            output[out_index++] = base64_table[byte]; // Append the encoded character to the output string
            
            if(pad_bytes > 0 && i == bytes_read * 3 / 8 - 1) {
                // If we're encoding the last byte of a partial triplet and need to add padding, do so here
                output[out_index++] = '='; // Append the padding character to the output string
                --pad_bytes; // Decrement the number of padding bytes needed
            }
        }
    }
    
    // Add any necessary trailing equals signs for padding (if we're encoding less than three bytes at a time)
    // This is not needed in the corrected script as the padding is taken care of in the previous for loop
    
    return output; // Return the encoded string
}

// Function to decode a given input string using Base64 decoding
char* base64_decode(const char *input, int len) {
    // Allocate memory for the output buffer (including null terminator)
    const int outlen = (len / 4) * 3;
    char *output = malloc(outlen);
    
    // Initialize variables to keep track of input and output indices, as well as any padding bytes that may be present
    int in_index = 0; // Index for tracking input characters
    int out_index = 0; // Index for tracking output bytes
    int pad_bytes = 0; // Variable to track the number of padding bytes present
    
    // Loop through each input character and decode it using the lookup table
    while(in_index < len) {
        unsigned char quad[4]; // Array to store four input characters at a time
        int chars_read = 0; // Variable to track the number of characters read in each iteration
        
        // Read in four characters at a time (or less if we've reached the end of the input string)
        for(int i=0; i<4 && in_index < len; ++i, ++in_index) {
            quad[i] = input[in_index]; // Store the input character in the quad array
            chars_read++; // Increment the number of characters read
        }
        
        // If we didn't read all four characters, pad the remaining characters with 0s and move on to decoding them separately
        if(chars_read < 4) {
            for(int i=chars_read; i<4; ++i) {
                quad[i] = 0; // Pad the remaining characters with 0s
            }
            pad_bytes = 4 - chars_read; // Calculate the number of padding bytes present
        }
        
        // Decode the resulting quads using the lookup table and append them to the output buffer (discarding any padding bytes)
        for(int i=0; i<chars_read * 6 / 8; ++i) {
            unsigned char byte = (quad[i/2] >> ((2-i%4)*6)) & 0x3F; // Extract the appropriate bits from the quad to decode
            output[out_index++] = byte; // Append the decoded byte to the output buffer
        }
    }
    
    // Add any necessary trailing padding bytes (if present)
    if(pad_bytes > 0) {
        out_index -= pad_bytes; // Remove the padding bytes from the end of the output buffer
    }
    
    return output; // Return the decoded string
}