Task: Base64 decode data
C++: #include <algorithm>
#include <iostream>
#include <string>
#include <vector>

typedef unsigned char ubyte;
const auto BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

std::vector<ubyte> encode(const std::vector<ubyte>& source) {
    auto it = source.cbegin();
    auto end = source.cend();

    std::vector<ubyte> sink;
    while (it != end) {
        auto b1 = *it++;
        int acc;

        sink.push_back(BASE64[b1 >> 2]);            

        acc = (b1 & 0x3) << 4;                      
        if (it != end) {
            auto b2 = *it++;
            acc |= (b2 >> 4);                       

            sink.push_back(BASE64[acc]);            

            acc = (b2 & 0xF) << 2;                  
            if (it != end) {
                auto b3 = *it++;
                acc |= (b3 >> 6);                   

                sink.push_back(BASE64[acc]);        
                sink.push_back(BASE64[b3 & 0x3F]);  
            } else {
                sink.push_back(BASE64[acc]);        
                sink.push_back('=');                
            }
        } else {
            sink.push_back(BASE64[acc]);            
            sink.push_back('=');                    
            sink.push_back('=');                    
        }
    }
    return sink;
}

int findIndex(ubyte val) {
    if ('A' <= val && val <= 'Z') {
        return val - 'A';
    }
    if ('a' <= val && val <= 'z') {
        return val - 'a' + 26;
    }
    if ('0' <= val && val <= '9') {
        return val - '0' + 52;
    }
    if ('+' == val) {
        return 62;
    }
    if ('/' == val) {
        return 63;
    }
    return -1;
}

std::vector<ubyte> decode(const std::vector<ubyte>& source) {
    if (source.size() % 4 != 0) {
        throw new std::runtime_error("Error in size to the decode method");
    }

    auto it = source.cbegin();
    auto end = source.cend();

    std::vector<ubyte> sink;
    while (it != end) {
        auto b1 = *it++;
        auto b2 = *it++;
        auto b3 = *it++; 
        auto b4 = *it++; 

        auto i1 = findIndex(b1);
        auto i2 = findIndex(b2);
        auto acc = i1 << 2;     
        acc |= i2 >> 4;         

        sink.push_back(acc);    

        if (b3 != '=') {
            auto i3 = findIndex(b3);

            acc = (i2 & 0xF) << 4;  
            acc |= i3 >> 2;         

            sink.push_back(acc);    

            if (b4 != '=') {
                auto i4 = findIndex(b4);

                acc = (i3 & 0x3) << 6;  
                acc |= i4;              

                sink.push_back(acc);    
            }
        }
    }
    return sink;
}

int main() {
    using namespace std;

    string data = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo";
    vector<ubyte> datav{ begin(data), end(data) };
    cout << data << "\n\n" << decode(datav).data() << endl;

    return 0;
}

Java: 
module Base64
    {
    @Inject Console console;
    void run()
        {
        String orig  = \|VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIH\
                        |lvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=
                       ;
        Byte[] bytes = decode(orig);
        String text  = encode(bytes, pad=True);
        assert text == orig;
        console.print($"base64={text}, bytes={bytes}");
        }

    static Byte[] read(Iterator<Char> stream)
        {
        Int    charLen    = 0;
        charLen := stream.knownSize();
        Byte[] byteBuf    = new Byte[](charLen * 6 / 8);
        Byte   prevBits   = 0;
        Int    prevCount  = 0;
        while (Char ch := stream.next())
            {
            if (Byte newBits := isBase64(ch, assertTrash=True))
                {
                if (prevCount == 0)
                    {
                    prevBits  = newBits;
                    prevCount = 6;
                    }
                else
                    {
                    byteBuf.add((prevBits << 8-prevCount) | (newBits >> prevCount-2));
                    prevBits   = newBits;
                    prevCount -= 2;
                    }
                }
            }

        return byteBuf.freeze(True);
        }

    static void write(Byte[] value, Appender<Char> stream, Boolean pad=False, Int? lineLength=Null)
        {
        lineLength ?:= Int.maxvalue;

        Int    lineOffset = 0;
        Int    totalChars = 0;
        Byte   prevByte   = 0;
        Int    prevCount  = 0;          
        Int    byteOffset = 0;
        Int    byteLength = value.size;
        while (True)
            {
            
            Byte sixBits;
            if (byteOffset >= byteLength)
                {
                if (prevCount == 0)
                    {
                    break;
                    }
                sixBits   = prevByte << 6 - prevCount;
                prevCount = 0;
                }
            else if (prevCount == 6)
                {
                sixBits   = prevByte << 6 - prevCount;
                prevCount = 0;
                }
            else
                {
                Byte nextByte = value[byteOffset++];
                sixBits    = (prevByte << 6 - prevCount) | (nextByte >> 2 + prevCount);
                prevByte   = nextByte;
                prevCount += 2;
                }

            if (lineOffset >= lineLength)
                {
                stream.add('\r').add('\n');
                totalChars += lineOffset;
                lineOffset  = 0;
                }

            stream.add(base64(sixBits & 0b111111));
            ++lineOffset;
            }

        if (pad)
            {
            totalChars += lineOffset;
            for (Int i = 0, Int padCount = 4 - (totalChars & 0b11) & 0b11; i < padCount; ++i)
                {
                if (lineOffset >= lineLength)
                    {
                    stream.add('\r').add('\n');
                    lineOffset  = 0;
                    }

                stream.add('=');
                ++lineOffset;
                }
            }
        }

    static String encode(Byte[] value, Boolean pad=False, Int? lineLength=Null)
        {
        
        Int byteLen = value.size;
        Int charLen = (byteLen * 8 + 5) / 6;
        if (pad)
            {
            charLen += 4 - (charLen & 0b11) & 0b11;
            }
        if (lineLength != Null)
            {
            charLen += ((charLen + lineLength - 1) / lineLength - 1).maxOf(0) * 2;
            }

        StringBuffer charBuf = new StringBuffer(charLen);
        write(value, charBuf, pad, lineLength);
        return charBuf.toString();
        }

    static Byte[] decode(String text)
        {
        Int    charLen    = text.size;
        Byte[] byteBuf    = new Byte[](charLen * 6 / 8);
        Byte   prevBits   = 0;
        Int    prevCount  = 0;
        for (Int offset = 0; offset < charLen; ++offset)
            {
            if (Byte newBits := isBase64(text[offset], assertTrash=True))
                {
                if (prevCount == 0)
                    {
                    prevBits  = newBits;
                    prevCount = 6;
                    }
                else
                    {
                    byteBuf.add((prevBits << 8-prevCount) | (newBits >> prevCount-2));
                    prevBits   = newBits;
                    prevCount -= 2;
                    }
                }
            }

        return byteBuf.freeze(True);
        }

    
    static Byte valOf(Char ch)
        {
        return switch (ch)
            {
            case 'A'..'Z': (ch - 'A').toUInt8();
            case 'a'..'z': (ch - 'a').toUInt8() + 26;
            case '0'..'9': (ch - '0').toUInt8() + 52;
            case '+': 62;
            case '/': 63;

            case '=':        assert as $"Unexpected padding character in Base64: {ch.quoted()}";
            case '\r', '\n': assert as $"Unexpected newline character in Base64: {ch.quoted()}";
            default:         assert as $"Invalid Base64 character: {ch.quoted()}";
            };
        }

    
    static conditional Byte isBase64(Char ch, Boolean assertTrash=False)
        {
        return switch (ch)
            {
            case 'A'..'Z': (True, (ch - 'A').toUInt8());
            case 'a'..'z': (True, (ch - 'a').toUInt8() + 26);
            case '0'..'9': (True, (ch - '0').toUInt8() + 52);
            case '+': (True, 62);
            case '/': (True, 63);

            case '=':           
            case '\r', '\n':    
                False;

            default: assertTrash ? assert as $"Invalid Base64 character: {ch.quoted()}" : False;
            };
        }

    
    static Char base64(Byte byte)
        {
        return switch (byte)
            {
            case  0 ..< 26: 'A'+byte;
            case 26 ..< 52: 'a'+(byte-26);
            case 52 ..< 62: '0'+(byte-52);
            case 62: '+';
            case 63: '/';
            default: assert:bounds as $"byte={byte}";
            };
        }
    }