Initial data commit

Task/Base64-decode-data/00-META.yaml

@@ -0,0 +1,2 @@
+---
+from: http://rosettacode.org/wiki/Base64_decode_data

Task/Base64-decode-data/00-TASK.txt

@@ -0,0 +1,6 @@
+See [[Base64 encode data]]. 
+
+Now write a program that takes the output of the [[Base64 encode data]] task as input and regenerate the original file. 
+
+When working on the VBA implementation I found several 'solutions' on the net, including one from the software maker himself, that showed output with incorrect padding. Obviously with incorrect padding in the output you can not decode correctly to the original file again.
+

Task/Base64-decode-data/Action-/base64-decode-data.action

@@ -0,0 +1,74 @@
+BYTE FUNC FindIndex(BYTE b)
+  IF b>='A AND b<='Z THEN
+    RETURN (b-'A)
+  ELSEIF b>='a AND b<='z THEN
+    RETURN (b-'a+26)
+  ELSEIF b>='0 AND b<='9 THEN
+    RETURN (b-'0+52)
+  ELSEIF b='+ THEN
+    RETURN (62)
+  ELSEIF b='/ THEN
+    RETURN (63)
+  FI
+RETURN (-1)
+
+PROC PrintChar(CHAR c)
+  IF c=10 THEN
+    PutE()
+  ELSE
+    Put(c)
+  FI
+RETURN
+
+PROC Decode(CHAR ARRAY s)
+  BYTE i,b1,b2,b3,b4,i1,i2,i3,i4
+  CHAR c
+
+  IF s(0) MOD 4#0 THEN
+    PrintE("Invalid length of string!!!")
+    Break()
+  FI
+
+  i=1
+  WHILE i<=s(0)
+  DO
+    b1=s(i) i==+1
+    b2=s(i) i==+1
+    b3=s(i) i==+1
+    b4=s(i) i==+1
+
+    i1=FindIndex(b1)
+    i2=FindIndex(b2)
+
+    c=i1 LSH 2
+    c==%i2 RSH 4
+    PrintChar(c)
+
+    IF b3#'= THEN
+      i3=FindIndex(b3)
+      c=(i2&$0F) LSH 4
+      c==%i3 RSH 2
+      PrintChar(c)
+
+      IF b4#'= THEN
+        i4=FindIndex(b4)
+        c=(i3&$03) LSH 6
+        c==%i4
+        PrintChar(c)
+      FI
+    FI
+  OD
+RETURN
+
+PROC Test(CHAR ARRAY s)
+  PrintE("Encoded:")
+  PrintE(s)
+  PutE()
+  PrintE("Decoded:")
+  Decode(s)
+  PutE()
+RETURN
+
+PROC Main()
+  Test("VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo")
+RETURN

Task/Base64-decode-data/Ada/base64-decode-data.ada

@@ -0,0 +1,14 @@
+with Ada.Text_IO;
+
+with AWS.Translator;
+
+procedure Decode_AWS is
+   Input  : constant String :=
+     "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVw" &
+     "IHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=";
+   Result : constant String := AWS.Translator.Base64_Decode (Input);
+begin
+   Ada.Text_IO.Put_Line (Input);
+   Ada.Text_IO.New_Line;
+   Ada.Text_IO.Put_Line (Result);
+end Decode_AWS;

Task/Base64-decode-data/Arturo/base64-decode-data.arturo

@@ -0,0 +1,3 @@
+text: "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g="
+
+print decode text

Task/Base64-decode-data/BaCon/base64-decode-data.bacon

@@ -0,0 +1,3 @@
+data$ = "AAABAAIAEBAAAAAAAABoBQAAJgAAACAgAAAAAAAAqAgAAI4FAAAoAAAAE.......QAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAE="
+ico$ = B64DEC$(data$)
+BSAVE ico$ TO "favicon.ico" SIZE LEN(ico$)

Task/Base64-decode-data/C++/base64-decode-data.cpp

@@ -0,0 +1,117 @@
+#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]);            // first output (first six bits from b1)
+
+        acc = (b1 & 0x3) << 4;                      // last two bits from b1
+        if (it != end) {
+            auto b2 = *it++;
+            acc |= (b2 >> 4);                       // first four bits from b2
+
+            sink.push_back(BASE64[acc]);            // second output
+
+            acc = (b2 & 0xF) << 2;                  // last four bits from b2
+            if (it != end) {
+                auto b3 = *it++;
+                acc |= (b3 >> 6);                   // first two bits from b3
+
+                sink.push_back(BASE64[acc]);        // third output
+                sink.push_back(BASE64[b3 & 0x3F]);  // fouth output (final six bits from b3)
+            } else {
+                sink.push_back(BASE64[acc]);        // third output
+                sink.push_back('=');                // fourth output (1 byte padding)
+            }
+        } else {
+            sink.push_back(BASE64[acc]);            // second output
+            sink.push_back('=');                    // third output (first padding byte)
+            sink.push_back('=');                    // fourth output (second padding byte)
+        }
+    }
+    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++; // might be first padding byte
+        auto b4 = *it++; // might be first or second padding byte
+
+        auto i1 = findIndex(b1);
+        auto i2 = findIndex(b2);
+        auto acc = i1 << 2;     // six bits came from the first byte
+        acc |= i2 >> 4;         // two bits came from the first byte
+
+        sink.push_back(acc);    // output the first byte
+
+        if (b3 != '=') {
+            auto i3 = findIndex(b3);
+
+            acc = (i2 & 0xF) << 4;  // four bits came from the second byte
+            acc |= i3 >> 2;         // four bits came from the second byte
+
+            sink.push_back(acc);    // output the second byte
+
+            if (b4 != '=') {
+                auto i4 = findIndex(b4);
+
+                acc = (i3 & 0x3) << 6;  // two bits came from the third byte
+                acc |= i4;              // six bits came from the third byte
+
+                sink.push_back(acc);    // output the third byte
+            }
+        }
+    }
+    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;
+}

Task/Base64-decode-data/C-sharp/base64-decode-data.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Text;
+
+namespace Base64DecodeData {
+    class Program {
+        static void Main(string[] args) {
+            var data = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=";
+            Console.WriteLine(data);
+            Console.WriteLine();
+
+            var decoded = Encoding.ASCII.GetString(Convert.FromBase64String(data));
+            Console.WriteLine(decoded);
+        }
+    }
+}

Task/Base64-decode-data/C/base64-decode-data.c

@@ -0,0 +1,79 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef unsigned char ubyte;
+const ubyte BASE64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+int findIndex(const 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;
+}
+
+int decode(const ubyte source[], ubyte sink[]) {
+    const size_t length = strlen(source);
+    const ubyte *it = source;
+    const ubyte *end = source + length;
+    int acc;
+
+    if (length % 4 != 0) {
+        return 1;
+    }
+
+    while (it != end) {
+        const ubyte b1 = *it++;
+        const ubyte b2 = *it++;
+        const ubyte b3 = *it++;         // might be the first padding byte
+        const ubyte b4 = *it++;         // might be the first or second padding byte
+
+        const int i1 = findIndex(b1);
+        const int i2 = findIndex(b2);
+
+        acc = i1 << 2;                  // six bits came from the first byte
+        acc |= i2 >> 4;                 // two bits came from the first byte
+        *sink++ = acc;                  // output the first byte
+
+        if (b3 != '=') {
+            const int i3 = findIndex(b3);
+
+            acc = (i2 & 0xF) << 4;      // four bits came from the second byte
+            acc += i3 >> 2;             // four bits came from the second byte
+            *sink++ = acc;              // output the second byte
+
+            if (b4 != '=') {
+                const int i4 = findIndex(b4);
+
+                acc = (i3 & 0x3) << 6;  // two bits came from the third byte
+                acc |= i4;              // six bits came from the third byte
+                *sink++ = acc;          // output the third byte
+            }
+        }
+    }
+
+    *sink = '\0';   // add the sigil for end of string
+    return 0;
+}
+
+int main() {
+    ubyte data[] = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo";
+    ubyte decoded[1024];
+
+    printf("%s\n\n", data);
+    decode(data, decoded);
+    printf("%s\n\n", decoded);
+
+    return 0;
+}

Task/Base64-decode-data/Clojure/base64-decode-data.clj

@@ -0,0 +1,4 @@
+(defn decode [str]
+  (String. (.decode (java.util.Base64/getDecoder) str)))
+
+(decode "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=")

Task/Base64-decode-data/Common-Lisp/base64-decode-data.lisp

@@ -0,0 +1,23 @@
+(eval-when (:load-toplevel :compile-toplevel :execute)
+  (ql:quickload "cl-base64"))
+
+;; * The package definition
+(defpackage :base64-decode
+  (:use :common-lisp :cl-base64))
+(in-package :base64-decode)
+
+;; * The encoded data
+(defvar *base64-data*
+  "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"
+ "See BASE64-ENCODE for the origin of this
+ data. http://rosettacode.org/wiki/Base64_encode_data")
+
+;; * The function
+(defun base64-decode (&optional (data *base64-data*) (file #p"favicon-2.ico"))
+  "Returns the original FILE BASE64 encoded in DATA."
+  (with-open-file (stream file :direction :output :element-type 'unsigned-byte
+                          :if-exists :supersede :if-does-not-exist :create)
+    (let* ((array (base64-string-to-usb8-array data))
+           (len (length array)))
+      (write-sequence array stream)
+      (format t "Wrote ~D bytes in file ~A~%" len file))))

Task/Base64-decode-data/Crystal/base64-decode-data.crystal

@@ -0,0 +1,6 @@
+require "base64"
+
+encoded_string = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g="
+
+decoded_string = Base64.decode_string(encoded_string)
+puts decoded_string

Task/Base64-decode-data/D/base64-decode-data.d

@@ -0,0 +1,11 @@
+import std.base64;
+import std.stdio;
+
+void main() {
+    auto data = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=";
+    writeln(data);
+    writeln;
+
+    auto decoded = cast(char[])Base64.decode(data);
+    writeln(decoded);
+}

Task/Base64-decode-data/Dart/base64-decode-data.dart

@@ -0,0 +1,7 @@
+import 'dart:convert';
+
+void main() {
+  var encoded = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=";
+  var decoded = utf8.decode(base64.decode(encoded));
+  print(decoded);
+}

Task/Base64-decode-data/Delphi/base64-decode-data.delphi

@@ -0,0 +1,15 @@
+program Base64Decoder;
+
+{$APPTYPE CONSOLE}
+
+uses
+  System.SysUtils, System.NetEncoding;
+
+const
+  Src = 'VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=';
+
+begin
+  WriteLn(Format('Source string: ' + sLineBreak + '"%s"', [Src]));
+  WriteLn(Format('Decoded string: ' + sLineBreak + '"%s"', [TNetEncoding.Base64.Decode(Src)]));
+
+end.

Task/Base64-decode-data/Ecstasy/base64-decode-data.ecstasy

@@ -0,0 +1,190 @@
+/**
+ * This implementation is encapsulated as Base64Format in the web.xtclang.org module,
+ * but the module is currently in flux, so the implementation is included "inline" here.
+ */
+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;          // number of leftover bits from the previous byte
+        Int    byteOffset = 0;
+        Int    byteLength = value.size;
+        while (True) {
+            // glue together the next six bits, which will create one character of output
+            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) {
+        // calculate buffer size
+        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);
+    }
+
+    /**
+     * Translate a single Base64 character to the least significant 6 bits of a `Byte` value.
+     *
+     * @param ch  the Base64 character; no pad or newlines allowed
+     *
+     * @return the value in the range `0 ..< 64`
+     */
+    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()}";
+        };
+    }
+
+    /**
+     * Translate a single Base64 character to the least significant 6 bits of a `Byte` value.
+     *
+     * @param ch           the character to test if it is Base64
+     * @param assertTrash  (optional) pass True to assert on illegal Base64 characters
+     *
+     * @return the value in the range `0 ..< 64`
+     */
+    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 '=':           // "pad" sometimes allowed (or required) at end
+            case '\r', '\n':    // newlines sometimes allowed (or required)
+                False;
+
+            default: assertTrash ? assert as $"Invalid Base64 character: {ch.quoted()}" : False;
+        };
+    }
+
+    /**
+     * Convert the passed byte value to a Base64 character.
+     *
+     * @param the byte value, which must be in the range `0..63`
+     *
+     * @return the Base64 character
+     */
+    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}";
+        };
+    }
+}

Task/Base64-decode-data/F-Sharp/base64-decode-data-1.fs

@@ -0,0 +1,8 @@
+open System
+open System.IO
+
+let encoded = "AAABAAIAEBAAAAAAAABoBQAAJgAAACAgAAAAAAAAqAgAAI4FAAAoAAAAEAAAACAAAAABAAgAAAAAAEABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP///wCGiYcARkhHAL/CwAAmKScAam1rAOPm5ACgo6EAV1pYABcZGADO0c8AODs5AK2wrgBzdnQA6+7sAPz//QAAAwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQBAYMBQUMBgQQEBAQEBAQBhEJDQsLDQkFBxAQEBAQBBEJEBAQEBAQEBAQEBAQEA0RDhAQEBAQEBAQEBAQEBAPCgoLEBAQEAkMDxAQEBAQEAsMEQwJAwoREQ8QERAQEAIGEAcNCAgLCwsQEBEQEA0DEBAQEBAQEBAQEBARDwQMBxAQEBAQEBAQEBAQEQMMAw8QEBAQEBAQEBAQEBEQEAgJEBAQEBAQEBAQEBAREBAEDBAQEBAQEBAQEBAQEQ4GBQgQEBAQEBAQEBAQEAQEBA8QEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAAAACAAAABAAAAAAQAIAAAAAACABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD///8AfoJ/AD9BQAC+wb8A3uHfAB8iIACeoZ8AXmFfAA4SEADO0c8ArrKvAG5xbwDu8e8AT1FPAI6RkAAuMS8A5unnABcaGADW2dcANjk3AMbJxwC2ubcAZmlnAHZ5dwD2+fcApqmoAJaamACGiYcABgkHAEZJRwBWWFcAKCspAIuNjACUlJQA8vXzAOrt6wAkJyUA4uXjANrd2wAyNTMA0tXTADo9OwDKzcsAwsXDALq9uwBiZWMAam1rAKKlowBydXMACwsLAPr9+wBKTkwAGx0cAFJVUwBbXVsAgoWDAEJFQwCqrKsAmpubACsuLACztrQAe398AAsPDABYW1kAiIyJAN3e3QDBwsEASUtKALm6uQCRk5IA+fn5AO3t7QAEBwUACAsJAPz//QD09/UA8PPxACEkIgDo6+kA5OflAODk4QAwMzEA2NvZADw/PQDQ09EAREdFAMzPzQCxtLIAYGNhAGRnZQBoa2kApKelAKCjoQB0d3UAnJ+dAISHhQCMj40Afn9+AMTGxQBNUE4AUFNRALzAvQBcX10AbHBtAICDgQCYmpkADxAPAPz8/AD4/PoA9vb2AB4gHwDy8vIA8PDwADU3NgBAQ0EAv8PAAKiqqQBvc3AAcXRyAJWYlgAGBwYA7e/uAOjp6ADIycgAXl9eAKaopgCUlpUA/f//AObn5wA8PT0A0NHRABYZFwD+/v4A+/78APv7+wAgIyEA+fv5ACIlIwD3+vgA+Pj4APf39wD1+PYAKi0rAPP29AAsLy0A8/PzAPH08gDp7OoANzo4AOXo5gA7PjwA4+bkAN/i4ABDRkQA3eDeAEVIRgDb3twAR0pIANXZ1gDT1tQAUVRSAMvOzABXWlgAyczKAFlcWgDFyMYAX2JgAMHEwgBhZGIAY2ZkAGVoZgC7vrwAZ2poALm8ugBpbGoAa25sALW4tgC0t7UAdXh2AHd6eACjpqQAoaSiAIGEggCDhoQAnaCeAIWIhgCbnpwAh4qIAJmcmgCKjYsAi46MAI2QjgCSlJMAkJSRAAoLCgAKDAsAGBoZAP3+/QD8/f0A7/HwADEzMgDv8O8A7O/tAOzt7ADn6ugA3+DfANzf3QBIS0kA2dvaAExPTQBPUlAAW15cAMDDwQC9wL4AuLu5AHx/fQCnqqgAfYB+AImMigCPkpAAk5aUAA8QEAAPEhAAHiEfACEjIQD+//8A/v/+AP3//gD9/v4A/P79APv//AD7/v0A/P78APv9/AD7/PwA+/37AC4wLwD5/PoA+fv6APj7+QD4+fkA+Pn4APb69wD3+fcA9/j3APb49wDy9PMA8fPyAO/z8QDw8vEA8PHwAERGRQDu8u8A7/HvAEVHRgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIaFhenp6enphobmhYWF5osjeiRPzXvNTyR6I4uFhcYAgAEBAQEBAQEBAQEBAQEBzaKyfrsbeBu7fj0rlgEBAQCGAQEBAQEBAQEBAQHuUS14GKeh0FaaVtChCLPd1fP0AIYBAUtLS0tL4wEBgS24ozkeodSqq62rqtTTnJqvZpgAhgEBS0tLS0sBhfeuDJGEj2ccXK4sFSyuXGAIlw620QCGAQFLS0vk5OLyn7hSHeDUtnzODUyLTA2bptm+RkOWAIYBAUtLS+IB5A0Wo98/odmUR8dL5OLkSzPwjpOSjIkAhgEBS0tL4gHoljBzSRJ3VwEBAQEBAQEBAQEBAQEBhQCGAQFLS0viAYaW2R5Kxa/VhgEBAQEBAQEB4vBM8WzsAIYBAUtLS+TixvrWpcR5/7Z6AQEBAQEBAQEmPRsaKcsA5gEBAeRLS+QB45lB7TIGF7JRevvIDcpImbY3UjS1mwDlAQEB4ktLSwEBSysCgoRO0l4PB7UwOyFeOd4ACWATAO5ucSMzS0vkAYX2UbHYVuHgEERnqi4f/Mlva8OI3CcA/QTdWE3k5AEBlKQLtl29YqpA1C6rLghnZ31nfXZ0TwBQvJUxEQEBASPVIXa6183MoK7ZB1+9BwvWY6h0VyMZAFFeEmdQAQHyn8Bnr3VCAQEBk1EToClTlpDw80zqAeYAJj4lF08BhdF+L1lqUIcBAQHkM/Dwi+6G5OLi4gEB5gCYAo9oJAF7fjFbRoMBAQFL4gEBAQEBAQEBAQEBAQHpAFC3INQVmFhbZAJV6wEB5Evk5OLi4uLi4uTk5OQBAekAEUGKyRi/qhQDwU0BAeRLS0tLS0tLS0tLS0tLSwEB6QDNYQY1DmdkVKF/nWyF5EtLS0tLS0tLS0tLS0tLAQHpABFBinK4IkbYs7d+KfXj5EtLS0tLS0tLS0tLS0sBAekAmGkgLidwkgq5L69+/gEBS0tLS0tLS0tLS0tLSwEB6QAm2jyzAQEBhqxanr8kAQFLS0tLS0tLS0tLS0tLAQHpAJjaJS4FR43P2VkORssBAUtLS0tLS0tLS0tLS0sBAekAUNiEKrlFOkGrZbALIwEBS0tLS0tLS0tLS0tLSwEB6QBPwjwoMduzNh6puZ/wAeJLS0tLS0tLS0tLS0tLAQHpAPl0d6u3wDi0t36g+Evk5EtLS0tLS0tLS0tLS0sBAekAi0ykLQR0LAomkOIBAQEBAQEBAQEBAQEBAQEBAQEB6QDkAQHkbRnnAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAOaFhYbu7zPmhYWF5oaGhoaGhoaGhoaGhoaGhoaFhekA/////wAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAE="
+
+let decoded = Convert.FromBase64String encoded
+
+File.WriteAllBytes("favicon.ico", decoded)

Task/Base64-decode-data/F-Sharp/base64-decode-data-2.fs

@@ -0,0 +1,26 @@
+open System
+open System.IO
+
+let encoded = "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"
+
+
+let decode (s: string) =
+    let chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".ToCharArray()
+    let filtered = String.filter (fun c -> Array.contains c chars || c = '=') s
+    let paddingSize = filtered |> String.filter ((=) '=') |> String.length
+    let s = filtered.Replace('=', 'A').ToCharArray() |> Array.map int
+    let ints = chars |> Array.map int
+    let calc c =
+        let n = [c..(c + 3)]
+                |> List.sumBy (fun k -> Array.IndexOf(ints, s.[k]) <<< (18 - 6 * (k % 4)))
+        [16; 8; 0]
+        |> List.map (fun k -> (n >>> k) &&& 255 |> char |> string) |> List.reduce (+)
+    [0..4..Array.length s - 1]
+    |> List.map calc
+    |> List.reduce (+)
+    |> fun r -> r.Substring(0, String.length r - paddingSize).ToCharArray()
+    |> Array.map byte
+
+let decoded = decode encoded
+
+File.WriteAllBytes("favicon.ico", decoded)

Task/Base64-decode-data/Factor/base64-decode-data.factor

@@ -0,0 +1,4 @@
+USING: base64 io strings ;
+
+"VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo"
+base64> >string print

Task/Base64-decode-data/Forth/base64-decode-data.fth

@@ -0,0 +1,34 @@
+variable bitsbuff
+
+: char>6bits ( c -- u )
+   dup 43 =          if drop 62   exit then    ( + case )
+   dup 47 =          if drop 63   exit then    ( / case )
+   dup 48 58 within  if 48 - 52 + exit then    ( 0-9 case )
+   dup 65 91 within  if 65 -      exit then    ( A-Z case )
+   dup 97 123 within if 97 - 26 + exit then    ( a-z case )
+   drop 0                                      ( padding )
+;
+: 6bitsin ( v -- ) bitsbuff @ 6 lshift + bitsbuff ! ;
+: 4charsin ( addr -- addr+4 )
+   $0 bitsbuff !
+   dup 4 + dup rot
+   do I c@ char>6bits 6bitsin loop ;
+: 3bytes, ( -- )
+   bitsbuff @ 16 rshift $ff and c,
+   bitsbuff @  8 rshift $ff and c,
+   bitsbuff @           $ff and c, ;
+
+
+: b64dec ( addr1 n1 -- addr2 n2 )
+   here rot rot ( addr2 addr1 n1 )
+   4 /          ( addr2 addr1 n1/4 )
+   0 do
+      4charsin 3bytes,
+   loop                                   ( addr2 addr1+4x )
+   ( get back for padding )
+   1 - dup c@ 61 = if 1 else 0 then swap  ( addr2 0|1 addr1+4x-1 )
+   1 -     c@ 61 = if 1 else 0 then +     ( addr2 0|1|2 )
+   swap            ( 0|1|2 addr2 )
+   dup here swap - ( 0|1|2 addr2 n' )
+   rot -           ( addr2 n2 )
+;

Task/Base64-decode-data/FreeBASIC/base64-decode-data.basic

@@ -0,0 +1,33 @@
+Dim Shared As String B64
+B64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" & _
+"abcdefghijklmnopqrstuvwxyz" & _
+"0123456789+/"
+
+Function MIMEDecode(s As String ) As Integer
+    If Len(s) Then
+        MIMEdecode = Instr(B64,s) - 1
+    Else
+        MIMEdecode = -1
+    End If
+End Function
+
+Function Decode64(s As String) As String
+    Dim As Integer w1, w2, w3, w4
+    Dim As String  mD
+    For n As Integer = 1 To Len(s) Step 4
+        w1 = MIMEdecode(Mid(s,n+0,1))
+        w2 = MIMEdecode(Mid(s,n+1,1))
+        w3 = MIMEdecode(Mid(s,n+2,1))
+        w4 = MIMEdecode(Mid(s,n+3,1))
+        If w2 >-1 Then mD+= Chr(((w1* 4 + Int(w2/16)) And 255))
+        If w3 >-1 Then mD+= Chr(((w2*16 + Int(w3/ 4)) And 255))
+        If w4 >-1 Then mD+= Chr(((w3*64 + w4        ) And 255))
+    Next n
+    Return mD
+End Function
+
+Dim As String msg64 = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVw" & _
+"IHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g="
+Print msg64
+Print: Print(Decode64(msg64))
+Sleep

Task/Base64-decode-data/Frink/base64-decode-data.frink

@@ -0,0 +1,33 @@
+s="""iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAMAAAAoLQ9TAAAABGdBTUEAALGPC/xh
+BQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAA
+OpgAABdwnLpRPAAAAWJQTFRFAAAA/8IA/8EA/8IA/8IA/8IA/8IA/8IA/8IA/8IA
+/8IA/8IA/8IA/8IA/8IA/8IA/8IA/8IA/8IA/8IA/8IA/8IA/8IA/8IA/8IA/8IA
+/8IA/8IA/8IA/8IA/8IA/8IA/8IA/8IA/8UA/8UA/8QA/8IA/8IA/8IA/8IA/8IA
+/8IA/8MAdWVhiHJUiHJUc2Rj/8MA/8IA/8IA/8IA/8IA/8IA06QfjXZQjnZQjXVR
+3qwX/8IA/8IA/8IA/8IA/8IA/8kAjHVRjnZQjnZQjHVR/8gA/8IA/8IA/8IAjHVR
+jHVR/8gA/8IA/8IA1aYejXZQjnZQjXVR3qwX/8IA/8IA/8IA/8MAdGRjh3FVcmNj
+/8MA/8IA/8QA/8UA/8UA/8UA/8IA/8IA/8IA/8IA/8IA/8IA/8IA/8IA/8IA/8IA
+/8IA/8IA/8IA/8IA/8IA/8IA/8IA/8IA/8IA/8IAjnZQ////pZF7sgAAAHN0Uk5T
+AAAAA5iNAjzp5DUSMTAQYPz6WBEEjPCUG8G7GZrvhkfqRTV2MUvy50Jc9FoZRUQW
+X/vzDau2Gab7nRi6qQwlWyZR9fJIKCMnYVBJK624GqX6nhm8C/VcGEEWYFczdXQv
+SvGI7O0awBeXLA9f+VY+5jiZkk/hQmMAAAABYktHRHWoapj7AAAACXBIWXMAAA3X
+AAAN1wFCKJt4AAAA7UlEQVQY0z1P11ICARDbFTvIKZ4HooiA7USxYMHGqRSxY6HY
+AAULxRr+f1zAMU+ZzCabEAnY1A50dDL9oY27uoGeXm4qbLb0WZV+YMA2KIxJHdI0
+u2MYcI6Maq4xE7nHAZfH6/NNTE4B0zOkz8q1f24+sLC4BCzbKLgCrK6th0Ibm1vA
+9g5x2DB29/br9Ug0phtxJj5QErHDhnB0nFDCTMET4PTsPJm8uLwSyzXpKQlNZ7LZ
+m9tG6B15pKTmvn/I5QuPzbfqU7Fkf34R3+tbqSjF2FouV6pSvfZeEcatcR9S9/OL
+/+ey+g38tOb/AjOBNqW00PrwAAAAJXRFWHRkYXRlOmNyZWF0ZQAyMDE1LTA4LTAy
+VDIwOjM5OjEwKzAwOjAw98IZEQAAACV0RVh0ZGF0ZTptb2RpZnkAMjAxNS0wOC0w
+MlQyMDozOToxMCswMDowMIafoa0AAABGdEVYdHNvZnR3YXJlAEltYWdlTWFnaWNr
+IDYuNy44LTkgMjAxNC0wNS0xMiBRMTYgaHR0cDovL3d3dy5pbWFnZW1hZ2ljay5v
+cmfchu0AAAAAGHRFWHRUaHVtYjo6RG9jdW1lbnQ6OlBhZ2VzADGn/7svAAAAGHRF
+WHRUaHVtYjo6SW1hZ2U6OmhlaWdodAAxOTIPAHKFAAAAF3RFWHRUaHVtYjo6SW1h
+Z2U6OldpZHRoADE5MtOsIQgAAAAZdEVYdFRodW1iOjpNaW1ldHlwZQBpbWFnZS9w
+bmc/slZOAAAAF3RFWHRUaHVtYjo6TVRpbWUAMTQzODU0Nzk1MNul3mEAAAAPdEVY
+dFRodW1iOjpTaXplADBCQpSiPuwAAABWdEVYdFRodW1iOjpVUkkAZmlsZTovLy9t
+bnRsb2cvZmF2aWNvbnMvMjAxNS0wOC0wMi8xNDBkYmM4M2RmNWY3NmQyNmIzYWNl
+M2ZlYTViYzI5ZS5pY28ucG5nBect2gAAAABJRU5ErkJggg=="""
+
+f = newJava["java.io.FileOutputStream", ["favicon.ico"]]
+f.write[base64DecodeToBytes[s]]
+f.close[]

Task/Base64-decode-data/FutureBasic/base64-decode-data.basic

@@ -0,0 +1,28 @@
+include "NSlog.incl"
+
+local fn EncodeStringAsBase64( stringToEncode as CFStringRef ) as CFStringRef
+  CFStringRef encodedBase64Str = NULL
+  CFDataRef dataToEncode = fn StringData( stringToEncode, NSUTF8StringEncoding )
+  encodedBase64Str = fn DataBase64EncodedString( dataToEncode, 0 )
+end fn = encodedBase64Str
+
+
+local fn DecodeBase64String( base64String as CFStringRef ) as CFStringRef
+  CFStringRef decodedString = NULL
+  CFDataRef encodedData  = fn DataWithBase64EncodedString( base64String, NSDataBase64DecodingIgnoreUnknownCharacters )
+  decodedString = fn StringWithData( encodedData, NSUTF8StringEncoding )
+end fn = decodedString
+
+
+CFStringRef originalString, encodedBase64String, decodedBase64String
+
+originalString = @"This is a test string to be encoded as Base64 and then decoded."
+NSLog( @"This is the original string:\n\t%@\n", originalString )
+
+encodedBase64String = fn EncodeStringAsBase64( originalString )
+NSLog( @"This is the original string encoded as Base84:\n\t%@\n", encodedBase64String )
+
+decodedBase64String = fn DecodeBase64String( encodedBase64String )
+NSLog( @"This is the Base64 string decoded:\n\t%@", decodedBase64String )
+
+HandleEvents

Task/Base64-decode-data/Go/base64-decode-data.go

@@ -0,0 +1,19 @@
+package main
+
+import (
+    "encoding/base64"
+    "fmt"
+)
+
+func main() {
+    msg := "Rosetta Code Base64 decode data task"
+    fmt.Println("Original :", msg)
+    encoded := base64.StdEncoding.EncodeToString([]byte(msg))
+    fmt.Println("\nEncoded  :", encoded)
+    decoded, err := base64.StdEncoding.DecodeString(encoded)
+    if err != nil {
+        fmt.Println(err)
+        return
+    }
+    fmt.Println("\nDecoded  :", string(decoded))
+}

Task/Base64-decode-data/Groovy/base64-decode-data.groovy

@@ -0,0 +1,11 @@
+import java.nio.charset.StandardCharsets
+
+class Decode {
+    static void main(String[] args) {
+        String data = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g="
+        Base64.Decoder decoder = Base64.getDecoder()
+        byte[] decoded = decoder.decode(data)
+        String decodedStr = new String(decoded, StandardCharsets.UTF_8)
+        System.out.println(decodedStr)
+    }
+}

Task/Base64-decode-data/Haskell/base64-decode-data-1.hs

@@ -0,0 +1,40 @@
+--Decodes Base64 to ASCII
+import qualified Data.Map.Strict as Map (Map, lookup, fromList)
+import Data.Maybe (fromJust, listToMaybe, mapMaybe)
+import Numeric (readInt, showIntAtBase)
+import Data.Char (chr, digitToInt)
+import Data.List.Split (chunksOf)
+
+byteToASCII :: String -> String
+byteToASCII = map chr . decoder
+
+--generates list of bytes (represented by Int)
+decoder :: String -> [Int]
+decoder =
+  map readBin .
+  takeWhile (\x -> length x == 8) .
+  chunksOf 8 . concatMap toBin . mapMaybe (`Map.lookup` table) . filter (/= '=')
+
+--turns decimal into a list of char that represents a binary number
+toBin :: Int -> String
+toBin n = leftPad $ showIntAtBase 2 ("01" !!) n ""
+
+--this adds all the zeros to the left that showIntAtBase omitted
+leftPad :: String -> String
+leftPad a = replicate (6 - length a) '0' ++ a
+
+--turns list of '0' and '1' into list of 0 and 1
+readBin :: String -> Int
+readBin = fromJust . fmap fst . listToMaybe . readInt 2 (`elem` "01") digitToInt
+
+--lookup list for the sextets
+table :: Map.Map Char Int
+table =
+  Map.fromList $
+  zip "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" [0 ..]
+
+main :: IO ()
+main =
+  putStrLn $
+  byteToASCII
+    "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCi0tIFBhdWwgUi4gRWhybGljaA=="

Task/Base64-decode-data/Haskell/base64-decode-data-2.hs

@@ -0,0 +1,14 @@
+{-# LANGUAGE OverloadedStrings #-}
+
+import qualified Data.ByteString.Base64 as Base64 (decode, encode)
+import qualified Data.ByteString.Char8 as B (putStrLn)
+
+main :: IO ()
+main = do
+  B.putStrLn $
+    Base64.encode
+      "To err is human, but to really foul things up you need a computer.\n-- Paul R. Ehrlich"
+  B.putStrLn "\n-->\n"
+  either print B.putStrLn $
+    Base64.decode
+      "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCi0tIFBhdWwgUi4gRWhybGljaA=="

Task/Base64-decode-data/Haxe/base64-decode-data.haxe

@@ -0,0 +1,9 @@
+class Main {
+  static function main() {
+    var data = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVw" +
+               "IHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=";
+    Sys.println('$data\n');
+    var decoded = haxe.crypto.Base64.decode(data);
+    Sys.println(decoded);
+  }
+}

Task/Base64-decode-data/J/base64-decode-data-1.j

@@ -0,0 +1,4 @@
+   require'convert/misc/base64'
+   frombase64 'VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g='
+To err is human, but to really foul things up you need a computer.
+    -- Paul R. Ehrlich

Task/Base64-decode-data/J/base64-decode-data-2.j

@@ -0,0 +1,6 @@
+BASE64=: (a.{~ ,(a.i.'Aa') +/i.26),'0123456789+/'
+
+frombase64=: {{
+  pad=. _2 >. (y i. '=') - #y
+  pad }. a. {~ #. _8 [\ , (6#2) #: BASE64 i. y
+}}

Task/Base64-decode-data/Java/base64-decode-data-1.java

@@ -0,0 +1,3 @@
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.util.Base64;

Task/Base64-decode-data/Java/base64-decode-data-2.java

@@ -0,0 +1,6 @@
+void decodeToFile(String path, byte[] bytes) throws IOException {
+    try (FileOutputStream stream = new FileOutputStream(path)) {
+        byte[] decoded = Base64.getDecoder().decode(bytes);
+        stream.write(decoded, 0, decoded.length);
+    }
+}

Task/Base64-decode-data/Java/base64-decode-data-3.java

@@ -0,0 +1,12 @@
+import java.nio.charset.StandardCharsets;
+import java.util.Base64;
+
+public class Decode {
+    public static void main(String[] args) {
+        String data = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=";
+        Base64.Decoder decoder = Base64.getDecoder();
+        byte[] decoded = decoder.decode(data);
+        String decodedStr = new String(decoded, StandardCharsets.UTF_8);
+        System.out.println(decodedStr);
+    }
+}

Task/Base64-decode-data/JavaScript/base64-decode-data-1.js

@@ -0,0 +1,4 @@
+// define base64 data; in this case the data is the string: "Hello, world!"
+const base64 = 'SGVsbG8sIHdvcmxkIQ==';
+// atob is a built-in function.
+console.log(atob(base64));

Task/Base64-decode-data/JavaScript/base64-decode-data-2.js

@@ -0,0 +1,4 @@
+// define base64 data; in this case the data is the string: "Hello, world!"
+const base64 = Buffer.from('SGVsbG8sIHdvcmxkIQ==', 'base64');
+// <Buffer>.toString() is a built-in method.
+console.log(base64.toString());

Task/Base64-decode-data/Jsish/base64-decode-data.jsish

@@ -0,0 +1,4 @@
+/* Base64 decode, in Jsish */
+var data = exec('jsish base64.jsi', {retAll:true}).data;  // or use File.read('stdin');
+var icon = Util.base64(data, true);
+File.write('rosetta-favicon.ico', icon);

Task/Base64-decode-data/Julia/base64-decode-data.julia

@@ -0,0 +1,11 @@
+using Base64
+
+io = IOBuffer()
+
+iob64_decode = Base64DecodePipe(io)
+
+write(io, "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo")
+
+seekstart(io)
+
+println(String(read(iob64_decode)))

Task/Base64-decode-data/Kotlin/base64-decode-data.kotlin

@@ -0,0 +1,10 @@
+import java.util.Base64
+
+fun main() {
+    val data =
+        "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g="
+    val decoder = Base64.getDecoder()
+    val decoded = decoder.decode(data)
+    val decodedStr = String(decoded, Charsets.UTF_8)
+    println(decodedStr)
+}

Task/Base64-decode-data/Lua/base64-decode-data.lua

@@ -0,0 +1,26 @@
+-- Start taken from https://stackoverflow.com/a/35303321
+local b='ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/' -- You will need this for encoding/decoding
+
+-- decoding
+function dec(data)
+    data = string.gsub(data, '[^'..b..'=]', '')
+    return (data:gsub('.', function(x)
+        if (x == '=') then return '' end
+        local r,f='',(b:find(x)-1)
+        for i=6,1,-1 do r=r..(f%2^i-f%2^(i-1)>0 and '1' or '0') end
+        return r;
+    end):gsub('%d%d%d?%d?%d?%d?%d?%d?', function(x)
+        if (#x ~= 8) then return '' end
+        local c=0
+        for i=1,8 do c=c+(x:sub(i,i)=='1' and 2^(8-i) or 0) end
+            return string.char(c)
+    end))
+end
+-- end of copy
+
+local data = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo"
+print(data)
+print()
+
+local decoded = dec(data)
+print(decoded)

Task/Base64-decode-data/M2000-Interpreter/base64-decode-data-1.m2000

@@ -0,0 +1,13 @@
+inp$={VG8gZXJyIGlzIGh1bWFuLCBidXQ
+gdG8gcmVhbGx5IGZvdWwgdGhpbmdzI
+HVwIHlvdSBuZWVkIGEgY29tcHV0ZXI
+uCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=
+}
+tmp$=tempname$
+open tmp$ for wide output as #f
+	print #f, string$(inp$ as decode64);
+close #f
+document a$
+load.doc a$, tmp$
+report a$
+clipboard a$

Task/Base64-decode-data/M2000-Interpreter/base64-decode-data-2.m2000

@@ -0,0 +1,16 @@
+inp$={VG8gZXJyIGlzIGh1bWFuLCBidXQ
+gdG8gcmVhbGx5IGZvdWwgdGhpbmdzI
+HVwIHlvdSBuZWVkIGEgY29tcHV0ZXI
+uCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=
+}
+// decode inp$ (is 8-bit ANSI coded using 0xA for paragraph end/new line)
+a$=string$(inp$ as Decode64)
+locale 1033
+// convert ansi to utf16le using Locale 1033
+a$=chr$(a$)  // convert to utf16LE
+// expand LF to CRLF for M2000 console
+a$=replace$(chr$(0xA), chr$(0XD)+chr$(0XA), a$)
+// report handle cr and lf  using proportional spacing for text and auto word wrapping
+report a$
+// also Print channel #-2 handle cr and lf (using non proportional spacing)
+print #-2, a$

Task/Base64-decode-data/Mathematica/base64-decode-data.math

@@ -0,0 +1,4 @@
+ImportString[
+   "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo",
+   "Base64"
+]

Task/Base64-decode-data/Nim/base64-decode-data.nim

@@ -0,0 +1,5 @@
+import base64
+
+const Source = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g="
+
+echo Source.decode()

Task/Base64-decode-data/Ol/base64-decode-data.ol

@@ -0,0 +1,36 @@
+(define base64-codes "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/")
+(define kernel (alist->ff (map cons (string->bytes base64-codes) (iota (string-length base64-codes)))))
+
+; returns n bits from input binary stream
+(define (bits n hold)
+   (let loop ((hold hold))
+      (vector-apply hold (lambda (v i l)
+         (cond
+            ((null? l)
+               (values (>> v (- i n)) #false))
+            ((pair? l)
+               (if (not (less? i n))
+                  (values (>> v (- i n)) (vector (band v (- (<< 1 (- i n)) 1)) (- i n) l))
+                  (loop (vector
+                     (bor (<< v 6) (kernel (car l) 0))
+                     (+ i 6)
+                     (unless (eq? (car l) "=") (cdr l))))))
+            (else
+               (loop (vector v i (l)))))))))
+
+; decoder.
+(define (decode str)
+   (print "decoding string '" str "':")
+   (let loop ((hold [0 0 (str-iter str)]))
+      (let*((bit hold (bits 8 hold)))
+         (unless (zero? bit) (display (string bit)))
+         (when hold
+            (loop hold))))
+   (print)(print))
+
+; TESTING
+(decode "SGVsbG8sIExpc3Ah")
+
+(decode "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=")
+
+(decode "TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1dCBieSB0aGlzIHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYWxzLCB3aGljaCBpcyBhIGx1c3Qgb2YgdGhlIG1pbmQsIHRoYXQgYnkgYSBwZXJzZXZlcmFuY2Ugb2YgZGVsaWdodCBpbiB0aGUgY29udGludWVkIGFuZCBpbmRlZmF0aWdhYmxlIGdlbmVyYXRpb24gb2Yga25vd2xlZGdlLCBleGNlZWRzIHRoZSBzaG9ydCB2ZWhlbWVuY2Ugb2YgYW55IGNhcm5hbCBwbGVhc3VyZS4=")

Task/Base64-decode-data/PHP/base64-decode-data.php

@@ -0,0 +1,5 @@
+$encoded = 'VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVw' .
+           'IHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=';
+echo
+    $encoded, PHP_EOL,
+    base64_decode($encoded), PHP_EOL;

Task/Base64-decode-data/Perl/base64-decode-data.pl

@@ -0,0 +1,20 @@
+sub decode_base64 {
+    my($d) = @_;
+    $d =~ tr!A-Za-z0-9+/!!cd;
+    $d =~ s/=+$//;
+    $d =~ tr!A-Za-z0-9+/! -_!;
+    my $r = '';
+    while( $d =~ /(.{1,60})/gs ){
+        my $len = chr(32 + length($1)*3/4);
+        $r .= unpack("u", $len . $1 );
+    }
+    $r;
+}
+
+$data = <<EOD;
+J1R3YXMgYnJpbGxpZywgYW5kIHRoZSBzbGl0aHkgdG92ZXMKRGlkIGd5cmUgYW5kIGdpbWJsZSBp
+biB0aGUgd2FiZToKQWxsIG1pbXN5IHdlcmUgdGhlIGJvcm9nb3ZlcywKQW5kIHRoZSBtb21lIHJh
+dGhzIG91dGdyYWJlLgo=
+EOD
+
+print decode_base64($data) . "\n";

Task/Base64-decode-data/Phix/base64-decode-data.phix

@@ -0,0 +1,8 @@
+(phixonline)-->
+ <span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
+ <span style="color: #008080;">include</span> <span style="color: #000000;">builtins</span><span style="color: #0000FF;">\</span><span style="color: #000000;">base64</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>
+ <span style="color: #004080;">string</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"Rosetta Code Base64 decode data task"</span>
+ <span style="color: #004080;">string</span> <span style="color: #000000;">e</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">encode_base64</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>
+ <span style="color: #0000FF;">?</span><span style="color: #000000;">e</span>
+ <span style="color: #0000FF;">?</span><span style="color: #7060A8;">decode_base64</span><span style="color: #0000FF;">(</span><span style="color: #000000;">e</span><span style="color: #0000FF;">)</span>
+<!--

Task/Base64-decode-data/PicoLisp/base64-decode-data.l

@@ -0,0 +1,24 @@
+(setq *Char64
+   `'(chop
+         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" ) )
+(de decode64 (S)
+   (let S (chop S)
+      (pack
+         (make
+            (while S
+               (let
+                  (A (dec (index (++ S) *Char64))
+                     B (dec (index (++ S) *Char64))
+                     C (dec (index (++ S) *Char64))
+                     D (dec (index (++ S) *Char64)) )
+                  (link
+                     (char (| (>> -2 A) (>> 4 B))) )
+                  (and
+                     C
+                     (link
+                        (char
+                           (| (>> -4 (& B 15)) (>> 2 C)) ) )
+                     D
+                     (link
+                        (char (| (>> -6 (& C 3)) D)) ) ) ) ) ) ) ) )
+(prinl (decode64 "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo"))

Task/Base64-decode-data/Pike/base64-decode-data.pike

@@ -0,0 +1,3 @@
+string icon = Protocols.HTTP.get_url_data("http://rosettacode.org/favicon.ico");
+string encoded = MIME.encode_base64(icon);
+Stdio.write_file("favicon.ico", MIME.decode_base64(encoded));

Task/Base64-decode-data/PureBasic/base64-decode-data.basic

@@ -0,0 +1,7 @@
+b64cd$ = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVw" +
+         "IHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g="
+
+*p_buf = AllocateMemory(1024)
+Base64Decoder(b64cd$, *p_buf, 1024)
+OpenConsole("") : PrintN(PeekS(*p_buf, -1, #PB_UTF8))
+Input()

Task/Base64-decode-data/Python/base64-decode-data.py

@@ -0,0 +1,3 @@
+import base64
+data = 'VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g='
+print(base64.b64decode(data).decode('utf-8'))

Task/Base64-decode-data/QB64/base64-decode-data.qb64

@@ -0,0 +1,111 @@
+Option _Explicit
+
+Dim As String udata, decoded
+udata = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo"
+
+decoded = decode(udata)
+
+Print udata
+Print decoded
+
+Function findIndex& (value As _Unsigned _Byte)
+    If Asc("A") <= value And value <= Asc("Z") Then
+        findIndex = value - Asc("A")
+        Exit Function
+    End If
+    If Asc("a") <= value And value <= Asc("z") Then
+        findIndex = value - Asc("a") + 26
+        Exit Function
+    End If
+    If Asc("0") <= value And value <= Asc("9") Then
+        findIndex = value - Asc("0") + 52
+        Exit Function
+    End If
+    If value = Asc("+") Then
+        findIndex = 62
+        Exit Function
+    End If
+    If value = Asc("/") Then
+        findIndex = 63
+        Exit Function
+    End If
+    findIndex = -1
+End Function
+
+Function encode$ (source As String)
+    Dim As String Base64: Base64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
+    Dim As _Unsigned _Integer64 length: length = Len(source)
+    Dim As _Unsigned _Integer64 it, strend
+    Dim As Long acc
+    Dim As String sink
+    strend = length
+    While it <> strend
+        Dim As _Unsigned _Byte b1, b2, b3, b4
+        it = it + 1
+        b1 = Asc(Mid$(source, it, 1))
+        sink = sink + Mid$(Base64, _SHR(b1, 2), 1)
+        acc = _SHL(b1 And &H3, 4)
+        If it <> strend Then
+            it = it + 1
+            b2 = Asc(Mid$(source, it, 1))
+            acc = acc Or _SHR(b2, 4)
+            sink = sink + Mid$(Base64, acc, 1)
+            acc = _SHL(b2 And &HF, 2)
+            If it <> strend Then
+                it = it + 1
+                b3 = Asc(Mid$(source, it, 1))
+                acc = acc Or _SHR(b3, 6)
+                sink = sink + Mid$(Base64, acc, 1)
+                sink = sink + Mid$(Base64, b3 And &H3F, 1)
+            Else
+                sink = sink + Mid$(Base64, acc, 1)
+                sink = sink + "="
+            End If
+        Else
+            sink = sink + Mid$(Base64, acc, 1)
+            sink = sink + "="
+            sink = sink + "="
+        End If
+    Wend
+    encode = sink
+End Function
+
+Function decode$ (source As String)
+    Dim As _Unsigned _Integer64 length: length = Len(source)
+    Dim As _Unsigned _Integer64 it, strend
+    Dim As Long acc
+    Dim As String sink
+    strend = length
+    While it <> strend
+        Dim As _Unsigned _Byte b1, b2, b3, b4
+        it = it + 1
+        b1 = Asc(Mid$(source, it, 1))
+        it = it + 1
+        b2 = Asc(Mid$(source, it, 1))
+        it = it + 1
+        b3 = Asc(Mid$(source, it, 1))
+        it = it + 1
+        b4 = Asc(Mid$(source, it, 1))
+        Dim As Long i1, i2
+        i1 = findIndex(b1)
+        i2 = findIndex(b2)
+        acc = _SHL(i1, 2)
+        acc = acc Or _SHR(i2, 4)
+        sink = sink + Chr$(acc)
+        If b3 <> Asc("=") Then
+            Dim As Long i3
+            i3 = findIndex(b3)
+            acc = _SHL(i2 And &HF, 4)
+            acc = acc Or _SHR(i3, 2)
+            sink = sink + Chr$(acc)
+            If b4 <> Asc("=") Then
+                Dim As Long i4
+                i4 = findIndex(b4)
+                acc = _SHL(i3 And &H3, 6)
+                acc = acc Or i4
+                sink = sink + Chr$(acc)
+            End If
+        End If
+    Wend
+    decode = sink
+End Function

Task/Base64-decode-data/R/base64-decode-data.r

@@ -0,0 +1,4 @@
+"VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo" |>
+  base64enc::base64decode() |>
+  rawToChar() |>
+  cat()

Task/Base64-decode-data/Racket/base64-decode-data.rkt

@@ -0,0 +1,9 @@
+#lang racket
+(require net/url net/base64)
+
+;; decode a string
+(displayln (base64-decode #"VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g="))
+
+;; (encode and) decode the favicon
+(displayln (base64-decode (base64-encode (call/input-url (string->url "https://rosettacode.org/favicon.ico")
+                                              get-pure-port port->bytes))))

Task/Base64-decode-data/Raku/base64-decode-data.raku

@@ -0,0 +1,26 @@
+my $e64 = '
+VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY2
+9tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=
+';
+
+my @base64map = flat 'A' .. 'Z', 'a' .. 'z', ^10, '+', '/';
+my %base64 is default(0) = @base64map.pairs.invert;
+
+sub base64-decode-slow ($enc) {
+    my $buf = Buf.new;
+    for $enc.subst(/\s/, '', :g).comb(4) -> $chunck {
+        $buf.append: |(sprintf "%06d%06d%06d%06d", |$chunck.comb.map:
+            {%base64{$_}.base(2)}).comb(8).map: {:2($_)};
+    }
+    $buf
+}
+
+say 'Slow:';
+say base64-decode-slow($e64).decode('utf8');
+
+
+# Of course, the above routine is slow and is only for demonstration purposes.
+# For real code you should use a module, which is MUCH faster and heavily tested.
+say "\nFast:";
+use Base64::Native;
+say base64-decode($e64).decode('utf8');

Task/Base64-decode-data/Red/base64-decode-data.red

@@ -0,0 +1,3 @@
+Red [Source: https://github.com/vazub/rosetta-red]
+
+print to-string debase "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo"

Task/Base64-decode-data/Ring/base64-decode-data.ring

@@ -0,0 +1,15 @@
+#======================================#
+#  Sample: Base64 decode data
+#  Author: Gal Zsolt, Mansour Ayouni
+#======================================#
+
+load "guilib.ring"
+
+oQByteArray = new QByteArray()
+oQByteArray.append("Rosetta Code Base64 decode data task")
+oba = oQByteArray.toBase64().data()
+see oba + nl
+
+oQByteArray = new QByteArray()
+oQByteArray.append(oba)
+see oQByteArray.fromBase64(oQByteArray).data()

Task/Base64-decode-data/Ruby/base64-decode-data.rb

@@ -0,0 +1,7 @@
+require 'base64'
+
+raku_example ='
+VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY2
+9tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=
+'
+puts Base64.decode64 raku_example

Task/Base64-decode-data/Rust/base64-decode-data.rust

@@ -0,0 +1,38 @@
+use std::str;
+
+const INPUT: &str = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo";
+const UPPERCASE_OFFSET: i8 = -65;
+const LOWERCASE_OFFSET: i8 = 26 - 97;
+const NUM_OFFSET: i8 = 52 - 48;
+
+fn main() {
+    println!("Input: {}", INPUT);
+
+    let result = INPUT.chars()
+        .filter(|&ch| ch != '=')                                //Filter '=' chars
+        .map(|ch| {                                             //Map char values using Base64 Characters Table
+            let ascii = ch as i8;
+            let convert = match ch {
+                '0' ... '9' => ascii + NUM_OFFSET,
+                'a' ... 'z' => ascii + LOWERCASE_OFFSET,
+                'A' ... 'Z' => ascii + UPPERCASE_OFFSET,
+                '+' => 62,
+                '/' => 63,
+                _ => panic!("Not a valid base64 encoded string")
+            };
+            format!("{:#08b}", convert)[2..].to_string()        //convert indices to binary format and remove the two first digits
+        })
+        .collect::<String>()                                    //concatenate the resulting binary values
+        .chars()
+        .collect::<Vec<char>>()
+        .chunks(8)                                              //split into 8 character chunks
+        .map(|chunk| {
+            let num_str = chunk.iter().collect::<String>();
+            usize::from_str_radix(&num_str, 2).unwrap() as u8   //convert the binary string into its u8 value
+        })
+        .collect::<Vec<_>>();
+
+    let result = str::from_utf8(&result).unwrap();              //convert into UTF-8 string
+
+    println!("Output: {}", result);
+}

Task/Base64-decode-data/Scala/base64-decode-data.scala

@@ -0,0 +1,14 @@
+import java.util.Base64
+
+object Base64Decode extends App {
+
+  def text2BinaryDecoding(encoded: String): String = {
+    val decoded = Base64.getDecoder.decode(encoded)
+    new String(decoded, "UTF-8")
+  }
+
+  def data =
+    "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g="
+
+  println(text2BinaryDecoding(data))
+}

Task/Base64-decode-data/Seed7/base64-decode-data.seed7

@@ -0,0 +1,14 @@
+$ include "seed7_05.s7i";
+  include "gethttp.s7i";
+  include "encoding.s7i";
+
+const proc: main is func
+  local
+    var string: original is "";
+    var string: encoded is "";
+  begin
+    original := getHttp("rosettacode.org/favicon.ico");
+    encoded := toBase64(original);
+    writeln("Is the Rosetta Code icon the same (byte for byte) encoded then decoded: " <&
+            fromBase64(encoded) = original);
+  end func;

Task/Base64-decode-data/SenseTalk/base64-decode-data-1.sensetalk

@@ -0,0 +1 @@
+put base64Decode ("VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuIC0tUGF1bCBSLkVocmxpY2g=")

Task/Base64-decode-data/SenseTalk/base64-decode-data-2.sensetalk

@@ -0,0 +1 @@
+To err is human, but to really foul things up you need a computer. --Paul R.Ehrlich

Task/Base64-decode-data/Sidef/base64-decode-data.sidef

@@ -0,0 +1,6 @@
+var data = <<'EOT'
+VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY2
+9tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=
+EOT
+
+say data.decode_base64

Task/Base64-decode-data/Smalltalk/base64-decode-data.st

@@ -0,0 +1,6 @@
+data := '
+VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY2
+9tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=
+'.
+
+data base64Decoded asString printCR.

Task/Base64-decode-data/Standard-ML/base64-decode-data.ml

@@ -0,0 +1,31 @@
+val debase64 = fn input =>
+let
+
+ infix 2 Worb
+ infix 2 Wandb
+ fun (p Worb q )  =  Word.orb  (p,q);
+ fun (p Wandb q ) =  Word.andb (p,q);
+
+fun decode #"/" =  0wx3F
+  | decode #"+" =  0wx3E
+  | decode c    =  if Char.isDigit c then Word.fromInt (ord c) +  0wx04
+              else if Char.isLower c then Word.fromInt (ord c) - 0wx047
+              else if Char.isUpper c then Word.fromInt (ord c) - 0wx041
+              else 0wx00 ;
+
+fun convert (a::b::c::d::_) =
+         let
+            val w = Word.<< (a,0wx12) Worb Word.<< (b,0wx0c) Worb Word.<< (c,0wx06) Worb d
+         in
+            [Word.>> (w,0wx10), Word.>> ((w Wandb 0wx00ff00),0wx08) , w Wandb 0wx0000ff ]
+         end
+  | convert _ = [] ;
+
+fun decodeLst []    = []
+  | decodeLst ilist = ( convert o  map decode )( List.take (ilist,4) ) @  decodeLst (List.drop (ilist,4))
+
+in
+
+  String.implode ( List.map (chr o Word.toInt) ( decodeLst (String.explode input ))  )
+
+end                                                                 handle Subscript  => "Invalid code\n" ;

Task/Base64-decode-data/Tcl/base64-decode-data.tcl

@@ -0,0 +1,4 @@
+package require tcl 8.6
+set data VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g=
+
+puts [binary decode base64 $data]

Task/Base64-decode-data/UNIX-Shell/base64-decode-data.sh

@@ -0,0 +1,55 @@
+#! /bin/bash
+declare -a encodeTable=(
+# +   ,   -   .   /   0   1   2   3   4   5   6   7   8   9   :
+ 62  -1  -1  -1  63  52  53  54  55  56  57  58  59  60  61  -1
+# ;   <   =   >   ?   @   A   B   C   D   E   F   G   H   I   J
+ -1  -1  -1  -1  -1  -1   0   1   2   3   4   5   6   7   8   9
+# K   L   M   N   O   P   Q   R   S   T   U   V   W   X   Y   Z
+ 10  11  12  13  14  15  16  17  18  19  20  21  22  23  24  25
+# [   \   ]   ^   _   `   a   b   c   d   e   f   g   h   i   j
+ -1  -1  -1  -1  -1  -1  26  27  28  29  30  31  32  33  34  35
+# k   l   m   n   o   p   q   r   s   t   u   v   w   x   y   z
+ 36  37  38  39  40  41  42  43  44  45  46  47  48  49  50  51
+)
+function a2b6()
+{
+    if [ $1 -lt 43 -o $1 -gt 122 ]
+    then
+        echo -1
+    else
+        echo ${encodeTable[$(($1-43))]}
+    fi
+}
+
+function flush() {
+    for (( k=2; k>=4-CNT; k-- ))
+    do
+        (( b8=BUF>>(k*8)&255 ))
+        printf -v HEX %x $b8
+        printf \\x$HEX
+    done
+}
+
+while read INPUT
+do
+    for (( i=0; i<${#INPUT}; i++ ))
+    do
+        printf -v NUM %d "'${INPUT:$i:1}"
+        if (( NUM==61 ))
+        then
+            flush
+            exit 0
+        else
+            DEC=$( a2b6 $NUM )
+            if (( DEC>=0 ))
+            then
+                (( BUF|=DEC<<6*(3-CNT) ))
+                if (( ++CNT==4 ))
+                then
+                    flush
+                    (( CNT=0, BUF=0 ))
+                fi
+            fi
+        fi
+    done
+done

Task/Base64-decode-data/V-(Vlang)/base64-decode-data.v

@@ -0,0 +1,10 @@
+import encoding.base64
+
+fn main() {
+    msg := "Rosetta Code Base64 decode data task"
+    println("Original : $msg")
+    encoded := base64.encode_str(msg)
+    println("\nEncoded  : $encoded")
+    decoded := base64.decode_str(encoded)
+    println("\nDecoded  : $decoded")
+}

Task/Base64-decode-data/Visual-Basic-.NET/base64-decode-data.vb

@@ -0,0 +1,12 @@
+Module Module1
+
+    Sub Main()
+        Dim data = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g="
+        Console.WriteLine(data)
+        Console.WriteLine()
+
+        Dim decoded = Text.Encoding.ASCII.GetString(Convert.FromBase64String(data))
+        Console.WriteLine(decoded)
+    End Sub
+
+End Module

Task/Base64-decode-data/Wren/base64-decode-data.wren

@@ -0,0 +1,30 @@
+import "io" for Stdout
+import "/fmt" for Conv, Fmt
+import "/str" for Str
+
+var alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
+
+var decode = Fn.new { |s|
+   if (s == "") return s
+   var d = ""
+   for (b in s) {
+       var ix = alpha.indexOf(b)
+       if (ix >= 0) d = d + Fmt.swrite("$06b", ix)
+   }
+   if (s.endsWith("==")) {
+        d = d[0..-5]
+   } else if (s.endsWith("=")){
+        d = d[0..-3]
+   }
+   var i = 0
+   while (i < d.count) {
+        var ch = String.fromByte(Conv.atoi(d[i..i+7], 2))
+        System.write(ch)
+        i = i + 8
+   }
+   Stdout.flush()
+}
+
+var s = "VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEgY29tcHV0ZXIuCiAgICAtLSBQYXVsIFIuIEVocmxpY2g="
+for (chunk in Str.chunks(s, 4)) decode.call(chunk)
+System.print()

Task/Base64-decode-data/XPL0/base64-decode-data.xpl0

@@ -0,0 +1,33 @@
+func Decode(Ch);
+int  Ch;
+[if Ch>=^A & Ch<=^Z then return Ch - ^A;
+ if Ch>=^a & Ch<=^z then return Ch - ^a + 26;
+ if Ch>=^0 & Ch<=^9 then return Ch - ^0 + 52;
+ if Ch = ^+ then return 62;
+ if Ch = ^/ then return 63;
+return -1;
+];
+
+char Str;
+int  Count, N, Ch, Code, Acc;
+[Str:=
+"VG8gZXJyIGlzIGh1bWFuLCBidXQgdG8gcmVhbGx5IGZvdWwgdGhpbmdzIHVwIHlvdSBuZWVkIGEg
+ Y29tcHV0ZXIuCiAgICAtLVBhdWwgUi5FaHJsaWNo ";
+loop    [Count:= 0;
+        for N:= 1 to 4 do                       \read in four 6-bit chars
+                [repeat Ch:= Str(0);            \strip out whitespace
+                        Str:= Str+1;
+                        if Ch = $A0 then quit;  \terminating space
+                until   Ch > $20;
+                Code:= Decode(Ch);
+                Acc:= Acc<<6;
+                if Code >= 0 then               \don't count possible "="
+                        [Acc:= Acc + Code;
+                        Count:= Count+1;
+                        ];
+                ];
+        ChOut(0, Acc>>16);                      \write out three 8-bit chars
+        if Count >= 3 then ChOut(0, Acc>>8);
+        if Count >= 4 then ChOut(0, Acc);
+        ];
+]

Task/Base64-decode-data/Zkl/base64-decode-data-1.zkl

@@ -0,0 +1,9 @@
+var [const] MsgHash=Import("zklMsgHash"), Curl=Import("zklCurl");
+
+icon:=Curl().get("http://rosettacode.org/favicon.ico"); //-->(Data(4,331),693,0)
+icon=icon[0][icon[1],*];	// remove header
+iconEncoded:=MsgHash.base64encode(icon);
+iconDecoded:=MsgHash.base64decode(iconEncoded);
+File("rosettaCodeIcon.ico","wb").write(iconDecoded); # eyeball checking says good
+println("Is the Rosetta Code icon the same (byte for byte) encoded then decoded: ",
+   icon==iconDecoded);

Task/Base64-decode-data/Zkl/base64-decode-data-2.zkl

@@ -0,0 +1,4 @@
+msg,b64 := "Rosetta Code Base64 decode data task", MsgHash.base64encode(msg);
+println("Original: %s\nEncoded:  %s\nBytes:    %s\nDecoded:  %s"
+   .fmt(msg, b64.text, b64.bytes().apply("toString",16).concat(","),
+        MsgHash.base64decode(b64).text));