背景

这是万圣节相关的挑战。

正如您从上一个挑战中看到的那样，我非常喜欢我所说的ascii艺术动画，它不仅画出一个图案，而且画出一个不断发展的图案。几年前，我被要求在万圣节那天让随机的ascii蝙蝠在屏幕上飞起来，使我的想法变得生动（有点呆板）后，我想到了这个主意。毋庸置疑，我有义务履行义务（为此而得到报酬），但这使我认为生活比随机蝙蝠还重要。受此启发，我想提出这一挑战。

挑战

蝙蝠绕月飞行。

这是一只蝙蝠：

^o^

这是月亮：

     mmm         
   mmmmmmm       
  mmmmmmmmm      
   mmmmmmm       
     mmm     

您必须显示蝙蝠飞行的每个阶段（请参见输出）。

输入项

没有

输出量

      ^o^         
      mmm         
    mmmmmmm       
   mmmmmmmmm      
    mmmmmmm       
      mmm         


      mmm^o^      
    mmmmmmm       
   mmmmmmmmm      
    mmmmmmm       
      mmm         


      mmm         
    mmmmmmm^o^    
   mmmmmmmmm      
    mmmmmmm       
      mmm         


      mmm         
    mmmmmmm       
   mmmmmmmmm^o^   
    mmmmmmm       
      mmm         


      mmm         
    mmmmmmm       
   mmmmmmmmm      
    mmmmmmm^o^    
      mmm         


      mmm         
    mmmmmmm       
   mmmmmmmmm      
    mmmmmmm       
      mmm^o^      


      mmm         
    mmmmmmm       
   mmmmmmmmm      
    mmmmmmm       
      mmm         
      ^o^         


      mmm         
    mmmmmmm       
   mmmmmmmmm      
    mmmmmmm       
   ^o^mmm         


      mmm         
    mmmmmmm       
   mmmmmmmmm      
 ^o^mmmmmmm       
      mmm         


      mmm         
    mmmmmmm       
^o^mmmmmmmmm      
    mmmmmmm       
      mmm         


      mmm         
 ^o^mmmmmmm       
   mmmmmmmmm      
    mmmmmmm       
      mmm         


   ^o^mmm         
    mmmmmmm       
   mmmmmmmmm      
    mmmmmmm       
      mmm         


      ^o^         
      mmm         
    mmmmmmm       
   mmmmmmmmm      
    mmmmmmm       
      mmm   

规则

• 不读取外部文件或网站
• 您可以提交完整的程序或功能
• 我可以使用多余的空格和/或换行符
• 照常禁止标准漏洞
• 蝙蝠必须回到月球的顶部
• 如果需要，请随时清除各帧之间的屏幕，但这不是必需的。上面显示的输出很好
• 由于这是代码高尔夫，因此欢迎者将以最少的字节数来回答问题，尽管欢迎任何回答

样品

在完全没有高尔夫的Python 2中的参考实现（620字节，但只是为了证明它可以完成。以后可以使用）。

b='^o^'
m=['                     ',
'         mmm         ',
'       mmmmmmm       ',
'      mmmmmmmmm      ',
'       mmmmmmm       ',
'         mmm         ',
'                     ']
p=[(9,12),(12,15),(14,17),(15,18),(14,17),(12,15),(9,12),(6,9),(4,7),(3,6),(4,7),(6,9),(9,12)]
d=0
for z in range(7):
    x=map(str,m[z])
    c="".join(x[:p[z][0]]) + b + "".join(x[p[z][1]:])+"\n"
    print "\n".join(m[:z]) + "\n" + c+"\n".join(m[z+1:])
for z in range(6)[::-1]:
    x=map(str,m[z])
    c="".join(x[:p[z+6][0]]) + b + "".join(x[p[z+6][1]:])+"\n"
    print "\n".join(m[:z]) + "\n" + c+"\n".join(m[z+1:])

结果

尽管@Jonathan显然在Jelly的字节数上获胜，但我还是将@Oyarsa的Brainfuck答案标记为可接受的答案，纯粹是因为我认为实际上可以用这种疯狂的语言做类似事情的人都应该获得+15 rep需要多少字节。这不是因为我对高尔夫语言有任何疑问。如果您有任何疑问，请参阅我对有关meta的问题的回答。非常感谢和尊重所有以任何语言发表贡献的人们。

Brainfuck，690字节

这是我第一次打高尔夫球，所以我相信仍有很多改进的空间

-[-[-<]>>+<]>-<<+++[>+++++++<-]>>>+>>-[<-->-------]<->++++++++>+>+++++>+>+++++>+>+++++++>+>+++++>+>+++++>+>++++++++>+>+>+>>+++[<++++++>-]<+>+>-->+>+>+[<]>[[<+>>-[>]+[[<]>+[>]<+[<]>>>-]<<[->>+<<]>-]>-[->>>>+<<<<]>++]>>>[[-]<]>>>>[>]>>+>+++++++<<<<[<]+<+<<+[[<]++++[>++++<-]>[<+[>]>[-<+>]<[<]>>-]>[>]++++++++++[>]>>>-[<]<<[<]<]<[<]>->-<<<[-]++++++<+<+++[>++++++<-]+<++++[>++++++++<-]---<-[>+<-----]++<----[>+<----]--<-[>+<---]<-[>++<-----]++++<-[>+<---]++<-[>+<-------]---<----[>+<----]<--[>+<++++++]<+++++[>+++++<-]++++++>[[[>]>[>]>>[-<<+>>]<<[<]<[<]>-]>[>]>[>]+++++++[>+++++++++<-]>-[->+>+>+<<<]++++[>>++++<<-]>>+<<<<[<]>[.>]>>[.>]<[<]>[-]>[-]>[-]<+[--<---[->]<]<[->+>+>+<<<]<<[[->>+<<]<]<]

在线尝试

取消一些可读性：

-[-[-<]>>+<]>-<<+++[>+++++++<-]>>>+>>-[<-->-------]<->++++++++>+>+++++>+>+++++>+>+++++++>+>+++++>+>+++++>+>++++++++>+>+>+>>+++[<++++++>-]<+>+>-->+>+>+
Sets counters for creation of the m's and spaces
[<]>[[<+>>-[>]+[[<]>+[>]<+[<]>>>-]<<[->>+<<]>-]>-[->>>>+<<<<]>++]
Adds the first counter plus two of the character at the second counter to the end of the
current set of cells removes the first two counters on the list then repeats until
it encounters a 254
>>>[[-]<]>>>>[>]>>+>+++++++<<<<[<]
Removes some excess cells then adds a 7 after the end of the set of cells
+<+<<+[[<]++++[>++++<-]>[<+[>]>[-<+>]<[<]>>-]>[>]++++++++++[>]>>>-[<]<<[<]<]
Adds a newline every 16 characters until 7 newlines are added
<[<]>->-<<<[-]++++++<+<+++[>++++++<-]+<++++[>++++++++<-]---<-[>+<-----]++<----[>+<----]--<-[>+<---]<-[>++<-----]++++<-[>+<---]++<-[>+<-------]---<----[>+<----]<--[>+<++++++]<+++++[>+++++<-]++++++
Removes some excess cells then sets indices for the locations of bats
>[[[>]>[>]>>[-<<+>>]<<[<]<[<]>-]>[>]>[>]+++++++[>+++++++++<-]>-[->+>+>+<<<]++++[>>++++<<-]>>+<<<<[<]>[.>]>>[.>]<[<]>[-]>[-]>[-]<+[--<---[->]<]<[->+>+>+<<<]<<[[->>+<<]<]<]
Loops through the indices replacing the spaces at each index with a bat then printing 
the set of cells then changing the bat back to spaces

我想利用这样的事实：通过在开头添加换行符，可以双向读取每个阶段以得到两个不同的阶段，但是如果找不到完整的六个半阶段，我找不到一个好的方法立刻。

05AB1E，69 62 60字节

感谢Adnan节省了2个字节。

3ð×…^o^)U13FNV0379730vð5y>;ï-y_+×N(Y-12%_Xè'my×NY-12%_y&XèJ,

在线尝试！

说明

3ð×…^o^)U将列表存储[" ","^o^"]在X中供以后使用。

13FNV循环遍历13个阶段[0 .. 12]并将当前迭代索引存储在Y中。

0379730v循环遍历每个阶段的行，
其中N是行索引，y是m的当前数量。

我们首先使用添加floor(5/(y+1))-(y==0)空格到每行ð5y>;ï-y_+×。

然后，我们确定在m之前是否应该有蝙蝠或3个空格。
如果(-N-Y)%12 == 0为true，则添加一个蝙蝠，否则为3个空格。
此表达式（N(Y-12%_Xè）将蝙蝠分阶段放置0,6-12。

然后我们把Ÿ M的用'my×。

现在我们确定在m的后面是否应该有一个蝙蝠或3个空格。如果为true，则
代码NY-12%_y&Xè将放置一个蝙蝠((N-Y)%12 == 0) and y!=0，否则为3个空格。
这将把蝙蝠放在舞台上1-5。

最后，我们将整行连接到一个字符串中，并使用换行符打印：J,。

的JavaScript（ES6），109个 144 140 138字节

f=(k=13,b=y=>(y-k)%12?'   ':'^o^')=>k--?[0,3,7,9,7,3,0].map((n,y)=>' '.repeat(5-n/2+!n)+b(y)+'m'.repeat(n)+b(n?-y:.1)).join`
`+`
`+f(k):''

console.log(f());

动画版

f=(k,b=y=>(y-k)%12?'   ':'^o^')=>[0,3,7,9,7,3,0].map((n,y)=>' '.repeat(5-n/2+!n)+b(-y)+'m'.repeat(n)+b(n?y:.1)).join`
`

var k =0;
setInterval(function() { o.innerHTML = f(k++) }, 150);

<pre id=o></pre>

HTML + JS，153个 149字节

n=setInterval(_=>o.innerText=`zzd
zc3e
 b7f
a9g
 l7h
zk3i
zzj`.replace(/\S/g,c=>parseInt(c,36)-n%12-10?`m`.repeat(c)||`   `:`^o^`,n++),1e3)

<pre id=o>

编辑：感谢@RickHitchcock保存了一堆字节。刚刚返回13个多行字符串数组中的镗孔版是132个 131字节：

_=>[...Array(13)].map((_,n)=>`zza
zl3b
 k7c
j9d
 i7e
zh3f
zzg`.replace(/\S/g,c=>parseInt(c,36)-n%12-10?`m`.repeat(c)||`   `:`^o^`))

果冻，76 69 58 字节

⁾ mṁ11ż“椿¬®µ‘ŒḄ¤Œṙs⁴Y
_4¢ḣ;“^o^”;¢ṫ⁸¤
“½œ0CSbp\I7'ð½‘Ç€Y

在线试用

怎么样？

⁾ mṁ11ż“椿¬®µ‘ŒḄ¤Œṙs⁴Y - Link 1, make a moon (niladic)
⁾ m                     - literal " m"
   ṁ                    - reshape like
    11                  - 11 (interpreted as range(11)) -> " m m m m m "
                 ¤      - nilad followed by links as a nilad
       “椿¬®µ‘         - code page indexes [22,3,11,7,8,9]
               ŒḄ       - bounce -> [22,3,11,7,8,9,8,7,11,3,22]
      ż                 - zip -> [[22,' '],[3,'m'],[11,' '],...]
                  Œṙ    - run length decode -> "                      mmm           mmmmmmm        mmmmmmmmm        mmmmmmm           mmm                      "
                    s   - split into chunks of length
                     ⁴  - l6
                      Y - join with line feeds

_4¢ḣ;“^o^”;¢ṫ⁸¤ - Link 2, a moon with a bat placed: endIndex
_4              - subtract 4 (startIndex)
  ¢              - call last link (1) as a nilad
   ḣ            - ḣead to startIndex
    ;           - concatenate
     “^o^”      - literal "^o^"
          ;     - concatenate
              ¤ - nilad followed by links as a nilad
           ¢    - call last link (1) as a nilad
            ṫ⁸  - tail from endIndex

“½œ0CSbp\I7'ð½‘Ç€Y - Main link (niladic)
“½œ0CSbp\I7'𽑠   - code page indexes [10,30,48,67,83,98,112,92,73,55,39,24,10]
                   -    indices to the right of each bat in a constructed moon
               ǀ  - call last link (2) as a monad for each
                 Y - join on line feeds

Python 2中，146个144 138字节

@Willem得-2个字节（使用变量c而不是循环通过map）

m='\n'.join(int(a)*' '+int(b)*'m'+3*' 'for a,b in zip('6643466','0379730'))
for b in" -;L[hrbQ@2' ":c=ord(b)-23;print(m[:c-3]+'^o^'+m[c:])

代表

'6643466' 是月球前的空格数（空的第一行和最后一行有6个空格，因为蝙蝠会去那里）。

'0379730'是'm'每一行在月球上的s 数。

将zip这些字符解包成a，b然后在天空中形成月亮，m每行有3个尾随空格。

然后，最后一行越过蝙蝠在月球内的位置，并且实际上是：

for c in(9,22,36,53,68,81,91,75,58,41,27,16,9):print(m[:c-3]+'^o^'+m[c:])

但位置的元组被编码为可打印字符的序号，并加了23（因为9是不可打印的）。这显示为" -;L[hrbQ@2' "，并c=ord(b)-23用于提取值。

Autovim，85 81个字节

没有动画，可能仍然可以打高尔夫球...不过，对于这个新手来说还不错！（autovim）

ñ9am␛ÿP2xÿP4xyjGpđp2o
%ce 15
®q=8j$p
®z=6␍"_d3hP
ñğyG12PğÿPC^o^␛v^y6@q==o␛6@z==O

要运行它：

autovim run ascii-bat.autovim -ni

说明

简而言之，我们绘制月亮，将其复制并粘贴12次，并使用两个宏：一个宏将蝙蝠附加在前7个卫星上，另一个宏则附加在最后6个卫星上。

" Draw the moon
ñ                                 " Normal mode
 9am␛                            " Write 9 `m`
      ÿP                          " Duplicate the line
        2x                        " Delete two characters
          ÿP                      " Duplicate the line
            4x                    " Delete 4 characters
              yj                  " Yank two lines
                Gp                " Paste at the end of the file
                  đp              " inverts the current line with the previous
                    2o            " Add two line breaks

%ce 15                            " Center our moon

" Macros
®q=8j$p                           " Macro `q` jumps 8 lines, and pastes
                                  "   at the end
®z=6␍"_d3hP                      " Macro `z` jumps 6 lines and replaces
                                  "   the previous 3 characters by the default

" Draw all 12 moons and add the bats
                                  "   register's content
ñ                                 " Run in normal mode
 ğyG                              " Copy the moon we just drew
    12P                           " Duplicate the moon 12 times
       ğÿP                        " Duplicate the top line (gets 3 centered `m`)
          C^o^␛                  " Change the mmm by a bat
                v^y               " Copy the bat we just drew
                   6@q            " Add the first 6 bats
                      ==          " Center the bat
                        o␛       " Add a line under the bat
                           6@z    " Add the 6 last bats
                              ==  " Align the last bat in the center
                                O " Add a line over the last moon

PHP，167字节

我用PHP编写了一个小程序：

<?php foreach([0,3,7,9,7,3,0]as$l)$b.=str_pad(str_repeat('=',$l),15," ",2)."\n";foreach([6,25,43,60,75,89,102,83,65,48,33,19,6]as$x)echo substr_replace($b,'^o^',$x,3);

这是更详细的版本：

// width of the moon
$moonsizes = [0,3,7,9,7,3,0];
// position where to place the bat
$positions = [6,25,43,60,75,89,102,83,65,48,33,19,6];
// prepare base moon painting
foreach($moonsizes as $size){
    $basepainting .= str_pad(str_repeat('=',$size),15," ",STR_PAD_BOTH)."\n";
}
// loop frames and place bat
foreach($positions as $position) {
    echo substr_replace($basepainting,'^o^',$position,3);
}

这是我的第一个代码高尔夫，如果您有任何建议，我很高兴听到:)

Python 2，112字节

b=['   ','^o^']
for k in range(91):r=k%7;print(b[k/7+r==12]*(r%6>0)+(r*(6-r)*8/5-5)*'m'+b[k/7%12==r]).center(15)

打印图片。每行分为三部分

• 左侧的潜在蝙蝠
• 一些 m的月亮
• 右侧的潜在蝙蝠

这些零件被串联并居中放置在大小为15的盒子中以保持间距。为避免蝙蝠移动中心，缺少的蝙蝠为三个空间，长度相同。对于在月球上方或下方的蝙蝠，省略了左侧的杆槽，而右侧的槽已被占用。

总共有91行：每13张图片中有7行图片。这些都是通过divmod计数：随着k计算从0到91，(k/7, k%7)云

(0, 0)
(0, 1)
(0, 2)
(0, 3)
(0, 4)
(0, 5)
(0, 6)
(1, 0)
(1, 1)
 ....
(12, 5)
(12, 6)

以第一个值为k/7图片，第二个值为r=k%7作为中的行号，则首先按图片进行计数，然后按每张图片中的行号进行计数，均以0索引。

数量m的与行数月的变化r=k%7的[0,3,7,9,7,3,0]。与其建立索引，不如说是一个较短的公式。方便的自由度是，的0值可以是任何负值，因为当乘以时仍会给出空字符串m。摆弄抛物线并划分地板给出了一个公式r*(6-r)*8/5-5。

现在，我们来看选择是在两侧绘制蝙蝠还是在空白处。数组b=[' ','^o^']包含选项。

球拍在图片0的第0行（在顶部），在图片1的第1行（在右），到图片6的第6行（在顶部）。因此，很容易检查行号和图片号是否相等，k/7==r。但是我们还需要图片12看起来像图片0，因此我们首先将图片编号取模12。

在左侧，类似。蝙蝠出现r=5,4,3,2,1在图片的左侧7,8,9,10,11。因此，我们检查行数和图片数之和是否为12。我们还确保在行上绘制三个空格而不是画任何东西，0并且6-正确的蝙蝠插槽将绘制蝙蝠，并且我们不得弄乱其居中位置。

C＃， 615 582 337字节

这是我第一次尝试（至今仍太可读），因此，我很乐意欢迎任何削减数百个字节的建议！现在，我的列表顶部是创建月球阵列的一种较短方法。

void M(){string[]m={"","      mmm","    mmmmmmm","   mmmmmmmmm","    mmmmmmm","      mmm",""};var b="^o^";for(int x=0;x<13;x++){var a=(string[])m.Clone();int n=x>6?12-x:x;int[] j={0,1,3,6};a[n]=!a[n].Contains("m")?"      "+b:x<=n?a[n]+b:new string(' ',j[Math.Abs(9-x)])+b+a[n].Replace(" ","");foreach(var c in a){Console.WriteLine(c);}}}

取消高尔夫（包括循环！）

class Program {
    public static string[] moon = new string[] { "               ", "      mmm      ", "    mmmmmmm    ", "   mmmmmmmmm   ", "    mmmmmmm    ", "      mmm      ", "               " };

    public static string bat = "^o^";

    static void Main(string[] args) {
        while (true) {
            Fly();
        }
    }

    static void Fly() {
        int times = (moon.Length * 2) - 1;
        for (int x = 0; x < times; x++) {
            string[] temp = (string[])moon.Clone(); //create a new array to maintain the original

            int index = x >= moon.Length ? times - x - 1 : x;

            if (!temp[index].Contains("m")) {
                temp[index] = new string(' ', 6) + bat + new string(' ', 6);
            } else if (x <= index) {
                int lastM = temp[index].LastIndexOf('m') + 1;
                temp[index] = temp[index].Insert(lastM, bat);
            } else {
                int firstM = temp[index].IndexOf('m');
                char[] src = temp[index].ToCharArray();
                int i = firstM - bat.Length;
                src[i] = bat[0];
                src[i + 1] = bat[1];
                src[i + 2] = bat[2];

                temp[index] = new string(src);
            }

            for (int y = 0; y < temp.Length; y++) {
                Console.WriteLine(temp[y]);
            }
            Thread.Sleep(100);
            Console.Clear();
        }            
    }
}

编辑：

通过删除数组声明中的尾部空格来占用21个字节。每行仅宽到足以容纳蝙蝠的位置，而不是15个字符的网格。删除了另外12个不必要的string [] argsMain()声明中。

编辑2：

重写了大部分逻辑，占用了245个字节！包括评论中建议的更改。谢谢！

从注释中，将其转换为函数，M()而不是先前的Main()方法-因此，现在需要在外部调用此函数。

Python 2中，299 300 290 270字节

打高尔夫球到270人，获得了更多的高尔夫经验。

参考实现由golfed向下321个 320 330字节。不漂亮或优雅。只使用蛮力字符串和列表切片。虽然减少字节数很有趣，但是我认为这种方法从一个严重的竞争对手开始是完全错误的。

我不希望这个答案被重视，所以请不要投反对票。我确实在问题中说过，我将尝试参考参考实现，而事实就是如此。只是为了好玩而发布。

c,e,n=' ','m','\n';f,g=c*9+e*3+c*9,c*7+e*7+c*7;h=9,12;i=12,15;j=6,9;k=13,17;l=4,7;m=c*21,f,g,c*6+e*9+c*6,g,f,c*21;p=h,i,k,(15,18),k,i,h,j,l,(3,6),l,j,h;w=0
for z in map(int,'0123456543210'):print n.join(m[:z])+n+m[z][:p[w][0]]+'^o^'+m[z][p[w][1]:]+n+n.join(m[z+1:]);w+=1

在线尝试！

Ruby，164156字节

puts Zlib.inflate Base64.decode64 "eNqlkrUVAAEMQvtMcZP9DfLYvzo3qhNSxQ2GVRC1ad29ar1JXaoHbul16Yig+p6BCKqtFBFU+1IE1famoHrX/jZBvN8e8f5tiE94Ib4SBREwNKH5BNJy2QM="

很简单的程序。可以做更多的工作。请在评论中留下提示。

/// 205字节

/*/\/\///B/^o^*9/         
*M/mmm*N/MM*O/   *0/OO*n/

*1/O Nm0
*2/NM0
*3/0M9*4/1O2*7/13n*5/34/0B9570MB0
473O NmBO 
O2731ONMBO
75O NmBO 
3n510MB0n
5130B9n51OBM9n5 BNm0 
3n31B273 BNm0 
O27OBM9470B90M0O
410MO

在线尝试！

只有当我不需要大量的尾随空间时...

腮腺炎，223字节

这使用的是InterSystems Cache Mump，它允许在循环周围使用大括号，从而使单行中的嵌套循环更方便。

S X="09121415141209060403040609",R="097679",L="037973",S=-14 F Y=1:1:13 S S=S+2 F C=1:1:7 S F=$E(X,Y*2-1,Y*2),(M,T)="",$P(T," ",21)="" F A=1:1:$E(L,C){S M=M_"m"} S $E(T,$E(R,C))=M S:C=$S(Y<8:Y,1:Y-S) $E(T,F,F+2)="^o^" W T,!

可能会打更多的高尔夫球，而当我有更多时间时，我可能会打高尔夫球。再添加9个字节，然后会进行动画处理[[由于添加了'H 1 W＃'->会暂停一秒钟并清除屏幕：

S X="09121415141209060403040609",R="097679",L="037973",S=-14 F Y=1:1:13 S S=S+2 H 1 W # F C=1:1:7 S F=$E(X,Y*2-1,Y*2),(M,T)="",$P(T," ",21)="" F A=1:1:$E(L,C){S M=M_"m"} S $E(T,$E(R,C))=M S:C=$S(Y<8:Y,1:Y-S) $E(T,F,F+2)="^o^" W T,!

这是（动画版本的）非公开/解释版本，带有正确的“ do”语句和点循环：

 S X="09121415141209060403040609"
 S R="097679",L="037973",S=-14              ; Initialize Variablex
 F Y=1:1:13 D                               ; Set up our main loop of 13 cels
 . S S=S+2                                  ; set up secondary counter, for start char.
 . H 1                                      ; halt for 1 second
 . W #                                      ; clear screen
 . F C=1:1:7 D                              ; set up our per-line loop
 . . S F=$E(X,Y*2-1,Y*2)                    ; set F to 2-digit "start of bat"
 . . S (M,T)=""                             ; set our "builder" lines to empty strings
 . . S $P(T," ",21)=""                      ; then reset our main 'line string' to 21 spaces.
 . . F A=1:1:$E(L,C){S M=M_"m"}             ; make our 'moon' text.
 . . S $E(T,$E(R,C))=M                      ; and insert our 'moon' into the empty line
 . . S:C=$S(Y<8:Y,1:Y-S) $E(T,F,F+2)="^o^"  ; find the start character for our 'bat' and insert.
 . . W T,!                                  ; and write the line and a CR/LF.

我试着做“先压缩然后再进行Base-64编码”爵士乐，只是为了看看会发生什么，但是编码后的字符串比程序本身更长！这样，并且Cache对压缩和base64编码的系统调用非常长...例如，以下是对base64进行解码的系统调用： $ System.Encryption.Base64Decode（STRING）

我认为该方法会将程序“膨胀”到300个字符以上。