package com.util 
{
    import flash.utils.*;
    
    public class Base64 extends Object
    {
        public function Base64()
        {
            super();
            throw new Error("Base64 class is static container only");
        }

        public static function enc_replace_ab(arg1:String, arg2:String, arg3:String):String
        {
            var loc1:*;
            loc1 = new RegExp(arg1, "g");
            var loc2:*;
            loc2 = new RegExp(arg2, "g");
            arg3 = arg3.replace(loc1, "___");
            arg3 = arg3.replace(loc2, arg1);
            arg3 = arg3.replace(new RegExp("___", "g"), arg2);
            return arg3;
        }

        public static function encode(arg1:String):String
        {
            var loc1:*;
            loc1 = new flash.utils.ByteArray();
            loc1.writeUTFBytes(arg1);
            var loc2:*;
            loc2 = encodeByteArray(loc1);
            loc2 = enc_replace(loc2, "e");
            return loc2;
        }

        public static function enc_replace(arg1:String, arg2:String):String
        {
            var loc3:*;
            loc3 = null;
            var loc4:*;
            loc4 = null;
            var loc1:*;
            loc1 = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "W", "G", "X", "M", "H", "R", "U", "Z", "I", "D", "=", "N", "Q", "V", "B", "L"];
            var loc2:*;
            loc2 = ["b", "z", "a", "c", "l", "m", "e", "p", "s", "J", "x", "d", "f", "t", "i", "o", "Y", "k", "n", "g", "r", "y", "T", "w", "u", "v"];
            if (arg2 == "e")
            {
                loc3 = loc1;
                loc4 = loc2;
            }
            if (arg2 == "d")
            {
                loc3 = loc2;
                loc4 = loc1;
            }
            var loc5:*;
            loc5 = 0;
            while (loc5 < loc3.length) 
            {
                arg1 = enc_replace_ab(loc3[loc5], loc4[loc5], arg1);
                ++loc5;
            }
            return arg1;
        }

        public static function encodeByteArray(arg1:flash.utils.ByteArray):String
        {
            var loc2:*;
            loc2 = null;
            var loc4:*;
            loc4 = 0;
            var loc5:*;
            loc5 = 0;
            var loc6:*;
            loc6 = 0;
            var loc1:*;
            loc1 = "";
            var loc3:*;
            loc3 = new Array(4);
            arg1.position = 0;
            while (arg1.bytesAvailable > 0) 
            {
                loc2 = new Array();
                loc4 = 0;
                while (loc4 < 3 && arg1.bytesAvailable > 0) 
                {
                    loc2[loc4] = arg1.readUnsignedByte();
                    loc4 = (loc4 + 1);
                }
                loc3[0] = (loc2[0] & 252) >> 2;
                loc3[1] = (loc2[0] & 3) << 4 | loc2[1] >> 4;
                loc3[2] = (loc2[1] & 15) << 2 | loc2[2] >> 6;
                loc3[3] = loc2[2] & 63;
                loc5 = loc2.length;
                while (loc5 < 3) 
                {
                    loc3[(loc5 + 1)] = 64;
                    loc5 = (loc5 + 1);
                }
                loc6 = 0;
                while (loc6 < loc3.length) 
                {
                    loc1 = loc1 + BASE64_CHARS.charAt(loc3[loc6]);
                    loc6 = (loc6 + 1);
                }
            }
            return loc1;
        }

        public static function decode(arg1:String):String
        {
            arg1 = enc_replace(arg1, "d");
            var loc1:*;
            loc1 = decodeToByteArray(arg1);
            return loc1.readUTFBytes(loc1.length);
        }

        public static function decodeToByteArray(arg1:String):flash.utils.ByteArray
        {
            var loc5:*;
            loc5 = 0;
            var loc6:*;
            loc6 = 0;
            var loc1:*;
            loc1 = new flash.utils.ByteArray();
            var loc2:*;
            loc2 = new Array(4);
            var loc3:*;
            loc3 = new Array(3);
            var loc4:*;
            loc4 = 0;
            while (loc4 < arg1.length) 
            {
                loc5 = 0;
                while (loc5 < 4 && loc4 + loc5 < arg1.length) 
                {
                    loc2[loc5] = BASE64_CHARS.indexOf(arg1.charAt(loc4 + loc5));
                    loc5 = (loc5 + 1);
                }
                loc3[0] = (loc2[0] << 2) + ((loc2[1] & 48) >> 4);
                loc3[1] = ((loc2[1] & 15) << 4) + ((loc2[2] & 60) >> 2);
                loc3[2] = ((loc2[2] & 3) << 6) + loc2[3];
                loc6 = 0;
                while (loc6 < loc3.length) 
                {
                    if (loc2[(loc6 + 1)] == 64)
                    {
                        break;
                    }
                    loc1.writeByte(loc3[loc6]);
                    loc6 = (loc6 + 1);
                }
                loc4 = loc4 + 4;
            }
            loc1.position = 0;
            return loc1;
        }

        public static const version:String="1.0.0";

        private static const BASE64_CHARS:String="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
    }
}