# Model_Network_Base64_19.luac
; fn @Base64.lua  line 0-0 np=0 va=1 ms=7 code=59 consts=21 upvals=1 protos=7
;   K[0]='_G'
;   K[1]='bit32'
;   K[2]='extract'
;   K[3]='bit'
;   K[4]='lshift'
;   K[5]='rshift'
;   K[6]='band'
;   K[7]='_VERSION'
;   K[8]='Lua 5.3'
;   K[9]='load'
;   K[10]='return function( v, from, width )\n\t\t\treturn ( v >> from ) & ((1 << width) - 1)\n\t\tend'
;   K[11]='makeencoder'
;   K[12]='makedecoder'
;   K[13]='makeencoder'
;   K[14]='string'
;   K[15]='char'
;   K[16]='table'
;   K[17]='concat'
;   K[18]='encode'
;   K[19]='encodeAndReplace'
;   K[20]='decode'
;   upvals: _ENV
;   locals: base64(1-59), extract(8-59), shl(23-26), shr(23-26), band(23-26), DEFAULT_ENCODER(45-59), DEFAULT_DECODER(47-59), char(51-59), concat(51-59)
0000  NEWTABLE  R0 = {} (0 items)
0001  GETTABUP  R1 = _ENV[K0('_G')]
0002  GETTABLE  R1 = R1[K1('bit32')]
0003  TEST      if not R1 then   -> -131067
0004  JMP       (jump)   -> 8
0005  GETTABUP  R1 = _ENV[K0('_G')]
0006  GETTABLE  R1 = R1[K1('bit32')]
0007  GETTABLE  R1 = R1[K2('extract')]
0008  TEST      if not R1 then   -> -131061
0009  JMP       (jump)   -> 39
0010  GETTABUP  R2 = _ENV[K0('_G')]
0011  GETTABLE  R2 = R2[K3('bit')]
0012  TEST      if not R2 then   -> -131058
0013  JMP       (jump)   -> 27
0014  GETTABUP  R2 = _ENV[K0('_G')]
0015  GETTABLE  R2 = R2[K3('bit')]
0016  GETTABLE  R2 = R2[K4('lshift')]
0017  GETTABUP  R3 = _ENV[K0('_G')]
0018  GETTABLE  R3 = R3[K3('bit')]
0019  GETTABLE  R3 = R3[K5('rshift')]
0020  GETTABUP  R4 = _ENV[K0('_G')]
0021  GETTABLE  R4 = R4[K3('bit')]
0022  GETTABLE  R4 = R4[K6('band')]
0023  CLOSURE   R5 = closure proto0
0024  MOVE      R1 = R0
0025  JMP       (jump)   -> 39
0026  JMP       (jump)   -> 39
0027  GETTABUP  R2 = _ENV[K0('_G')]
0028  GETTABLE  R2 = R2[K7('_VERSION')]
0029  LE        if R0 le R2   -> 4129
0030  JMP       (jump)   -> 37
0031  GETTABUP  R2 = _ENV[K9('load')]
0032  LOADK     R3 = K10 'return function( v, from, width )\n\t\t\treturn ( v >> from ) & ((1 << width) - 1)\n\t\tend'
0033  CALL      R2 = call(R2, 1 args, 1 rets)
0034  CALL      R2 = call(R2, 1 args, 0 rets)
0035  MOVE      R1 = R0
0036  JMP       (jump)   -> 39
0037  CLOSURE   R2 = closure proto1
0038  MOVE      R1 = R0
0039  CLOSURE   R2 = closure proto2
0040  SETTABLE  R0[K11('makeencoder')] = R2
0041  CLOSURE   R2 = closure proto3
0042  SETTABLE  R0[K12('makedecoder')] = R2
0043  GETTABLE  R2 = R0[K13('makeencoder')]
0044  CALL      R2 = call(R2, 1 args, 0 rets)
0045  GETTABLE  R3 = R0[K12('makedecoder')]
0046  CALL      R3 = call(R3, 1 args, 0 rets)
0047  GETTABUP  R4 = _ENV[K14('string')]
0048  GETTABLE  R4 = R4[K15('char')]
0049  GETTABUP  R5 = _ENV[K16('table')]
0050  GETTABLE  R5 = R5[K17('concat')]
0051  CLOSURE   R6 = closure proto4
0052  SETTABLE  R0[K18('encode')] = R6
0053  CLOSURE   R6 = closure proto5
0054  SETTABLE  R0[K19('encodeAndReplace')] = R6
0055  CLOSURE   R6 = closure proto6
0056  SETTABLE  R0[K20('decode')] = R6
0057  RETURN    return R0..R-1
0058  RETURN    return R0..R-1
; ---------- proto0 [] ----------
  ; fn ?  line 31-33 np=3 va=0 ms=8 code=13 consts=1 upvals=3 protos=0
  ;   K[0]=1
  ;   upvals: band, shr, shl
  ;   locals: v(0-13), from(0-13), width(0-13)
  0000  GETUPVAL  R3 = band
  0001  GETUPVAL  R4 = band
  0002  MOVE      R5 = R0
  0003  MOVE      R6 = R0
  0004  CALL      R4 = call(R4, 1 args, 2 rets)
  0005  GETUPVAL  R5 = band
  0006  LOADK     R6 = K0 1
  0007  MOVE      R7 = R0
  0008  CALL      R5 = call(R5, 1 args, 2 rets)
  0009  SUB       R5 = K0(1) sub R5
  0010  TAILCALL  tailcall(R3, 0)
  0011  RETURN    return R3..R2
  0012  RETURN    return R0..R-1
; ---------- proto1 [makeencoder] ----------
  ; fn ?  line 39-50 np=3 va=0 ms=11 code=16 consts=3 upvals=0 protos=0
  ;   K[0]=0
  ;   K[1]=2
  ;   K[2]=1
  ;   locals: v(0-16), from(0-16), width(0-16), w(1-16), flag(2-16), (for index)(5-14), (for limit)(5-14), (for step)(5-14), i(6-13), flag2(7-13)
  0000  LOADK     R3 = K0 0
  0001  POW       R4 = R1 pow K1(2)
  0002  LOADK     R5 = K0 0
  0003  SUB       R6 = K2(1) sub R2
  0004  LOADK     R7 = K2 1
  0005  FORPREP   forprep R5(sBx=7)   -> 13
  0006  ADD       R9 = R4 add R4
  0007  MOD       R10 = R9 mod R0
  0008  LE        if R0 le R10   -> -129004
  0009  JMP       (jump)   -> 12
  0010  POW       R10 = R8 pow K1(2)
  0011  ADD       R3 = R10 add R3
  0012  MOVE      R4 = R0
  0013  FORLOOP   forloop R5(sBx=-8)   -> 6
  0014  RETURN    return R3..R2
  0015  RETURN    return R0..R-1
; ---------- proto2 [makeencoder] ----------
  ; fn ?  line 55-65 np=3 va=0 ms=56 code=85 consts=68 upvals=1 protos=0
  ;   K[0]='pairs'
  ;   K[1]=0
  ;   K[2]='A'
  ;   K[3]='B'
  ;   K[4]='C'
  ;   K[5]='D'
  ;   K[6]='E'
  ;   K[7]='F'
  ;   K[8]='G'
  ;   K[9]='H'
  ;   K[10]='I'
  ;   K[11]='J'
  ;   K[12]='K'
  ;   K[13]='L'
  ;   K[14]='M'
  ;   K[15]='N'
  ;   K[16]='O'
  ;   K[17]='P'
  ;   K[18]='Q'
  ;   K[19]='R'
  ;   K[20]='S'
  ;   K[21]='T'
  ;   K[22]='U'
  ;   K[23]='V'
  ;   K[24]='W'
  ;   K[25]='X'
  ;   K[26]='Y'
  ;   K[27]='Z'
  ;   K[28]='a'
  ;   K[29]='b'
  ;   K[30]='c'
  ;   K[31]='d'
  ;   K[32]='e'
  ;   K[33]='f'
  ;   K[34]='g'
  ;   K[35]='h'
  ;   K[36]='i'
  ;   K[37]='j'
  ;   K[38]='k'
  ;   K[39]='l'
  ;   K[40]='m'
  ;   K[41]='n'
  ;   K[42]='o'
  ;   K[43]='p'
  ;   K[44]='q'
  ;   K[45]='r'
  ;   K[46]='s'
  ;   K[47]='t'
  ;   K[48]='u'
  ;   K[49]='v'
  ;   K[50]='w'
  ;   K[51]='x'
  ;   K[52]='y'
  ;   K[53]='z'
  ;   K[54]='0'
  ;   K[55]='1'
  ;   K[56]='2'
  ;   K[57]='3'
  ;   K[58]='4'
  ;   K[59]='5'
  ;   K[60]='6'
  ;   K[61]='7'
  ;   K[62]='8'
  ;   K[63]='9'
  ;   K[64]='+'
  ;   K[65]='/'
  ;   K[66]='='
  ;   K[67]='byte'
  ;   upvals: _ENV
  ;   locals: s62(0-85), s63(0-85), spad(0-85), encoder(1-85), (for generator)(77-83), (for state)(77-83), (for control)(77-83), b64code(78-81), char(78-81)
  0000  NEWTABLE  R3 = {} (0 items)
  0001  GETTABUP  R4 = _ENV[K0('pairs')]
  0002  NEWTABLE  R5 = {} (32 items)
  0003  SETTABLE  R5[K1(0)] = K2('A')
  0004  LOADK     R6 = K3 'B'
  0005  LOADK     R7 = K4 'C'
  0006  LOADK     R8 = K5 'D'
  0007  LOADK     R9 = K6 'E'
  0008  LOADK     R10 = K7 'F'
  0009  LOADK     R11 = K8 'G'
  0010  LOADK     R12 = K9 'H'
  0011  LOADK     R13 = K10 'I'
  0012  LOADK     R14 = K11 'J'
  0013  LOADK     R15 = K12 'K'
  0014  LOADK     R16 = K13 'L'
  0015  LOADK     R17 = K14 'M'
  0016  LOADK     R18 = K15 'N'
  0017  LOADK     R19 = K16 'O'
  0018  LOADK     R20 = K17 'P'
  0019  LOADK     R21 = K18 'Q'
  0020  LOADK     R22 = K19 'R'
  0021  LOADK     R23 = K20 'S'
  0022  LOADK     R24 = K21 'T'
  0023  LOADK     R25 = K22 'U'
  0024  LOADK     R26 = K23 'V'
  0025  LOADK     R27 = K24 'W'
  0026  LOADK     R28 = K25 'X'
  0027  LOADK     R29 = K26 'Y'
  0028  LOADK     R30 = K27 'Z'
  0029  LOADK     R31 = K28 'a'
  0030  LOADK     R32 = K29 'b'
  0031  LOADK     R33 = K30 'c'
  0032  LOADK     R34 = K31 'd'
  0033  LOADK     R35 = K32 'e'
  0034  LOADK     R36 = K33 'f'
  0035  LOADK     R37 = K34 'g'
  0036  LOADK     R38 = K35 'h'
  0037  LOADK     R39 = K36 'i'
  0038  LOADK     R40 = K37 'j'
  0039  LOADK     R41 = K38 'k'
  0040  LOADK     R42 = K39 'l'
  0041  LOADK     R43 = K40 'm'
  0042  LOADK     R44 = K41 'n'
  0043  LOADK     R45 = K42 'o'
  0044  LOADK     R46 = K43 'p'
  0045  LOADK     R47 = K44 'q'
  0046  LOADK     R48 = K45 'r'
  0047  LOADK     R49 = K46 's'
  0048  LOADK     R50 = K47 't'
  0049  LOADK     R51 = K48 'u'
  0050  LOADK     R52 = K49 'v'
  0051  LOADK     R53 = K50 'w'
  0052  LOADK     R54 = K51 'x'
  0053  LOADK     R55 = K52 'y'
  0054  SETLIST   setlist R5[B=1,C=50]
  0055  LOADK     R6 = K53 'z'
  0056  LOADK     R7 = K54 '0'
  0057  LOADK     R8 = K55 '1'
  0058  LOADK     R9 = K56 '2'
  0059  LOADK     R10 = K57 '3'
  0060  LOADK     R11 = K58 '4'
  0061  LOADK     R12 = K59 '5'
  0062  LOADK     R13 = K60 '6'
  0063  LOADK     R14 = K61 '7'
  0064  LOADK     R15 = K62 '8'
  0065  LOADK     R16 = K63 '9'
  0066  TESTSET   if not R1 then R17   -> -131003
  0067  JMP       (jump)   -> 69
  0068  LOADK     R17 = K64 '+'
  0069  TESTSET   if R1 then R18   -> -130488
  0070  JMP       (jump)   -> 72
  0071  LOADK     R18 = K65 '/'
  0072  TESTSET   if R1 then R19   -> -129973
  0073  JMP       (jump)   -> 75
  0074  LOADK     R19 = K66 '='
  0075  SETLIST   setlist R5[B=2,C=14]
  0076  CALL      R4 = call(R4, 3 args, 1 rets)
  0077  JMP       (jump)   -> 81
  0078  SELF      R10 = R8[K67('byte')] (self)
  0079  CALL      R9 = call(R9, 1 args, 1 rets)
  0080  SETTABLE  R3[R7] = R9
  0081  TFORCALL  tforcall R4
  0082  TFORLOOP  tforloop R6(sBx=-5)   -> 78
  0083  RETURN    return R3..R2
  0084  RETURN    return R0..R-1
; ---------- proto3 [makedecoder] ----------
  ; fn ?  line 67-73 np=3 va=0 ms=10 code=14 consts=2 upvals=2 protos=0
  ;   K[0]='pairs'
  ;   K[1]='makeencoder'
  ;   upvals: _ENV, base64
  ;   locals: s62(0-14), s63(0-14), spad(0-14), decoder(1-14), (for generator)(8-12), (for state)(8-12), (for control)(8-12), b64code(9-10), charcode(9-10)
  0000  NEWTABLE  R3 = {} (0 items)
  0001  GETTABUP  R4 = _ENV[K0('pairs')]
  0002  GETTABUP  R5 = base64[K1('makeencoder')]
  0003  MOVE      R6 = R0
  0004  MOVE      R7 = R0
  0005  MOVE      R8 = R0
  0006  CALL      R5 = call(R5, -1 args, 3 rets)
  0007  CALL      R4 = call(R4, 3 args, -1 rets)
  0008  JMP       (jump)   -> 10
  0009  SETTABLE  R3[R8] = R7
  0010  TFORCALL  tforcall R4
  0011  TFORLOOP  tforloop R6(sBx=-3)   -> 9
  0012  RETURN    return R3..R2
  0013  RETURN    return R0..R-1
; ---------- proto4 [encode] ----------
  ; fn ?  line 80-110 np=3 va=0 ms=25 code=145 consts=11 upvals=4 protos=0
  ;   K[0]=1
  ;   K[1]=3
  ;   K[2]='byte'
  ;   K[3]=2
  ;   K[4]=65536
  ;   K[5]=256
  ;   K[6]=18
  ;   K[7]=6
  ;   K[8]=12
  ;   K[9]=0
  ;   K[10]=64
  ;   upvals: DEFAULT_ENCODER, char, extract, concat
  ;   locals: str(0-145), encoder(0-145), usecaching(0-145), t(6-145), k(6-145), n(6-145), lastn(7-145), cache(8-145), (for index)(11-85), (for limit)(11-85), (for step)(11-85), i(12-84), a(16-84), b(16-84), c(16-84), v(20-84), s(21-84), a(91-116), b(91-116), v(94-116), v(123-140)
  0000  TEST      if not R1 then   -> -131069
  0001  JMP       (jump)   -> 3
  0002  GETUPVAL  R1 = DEFAULT_ENCODER
  0003  NEWTABLE  R3 = {} (0 items)
  0004  LOADK     R4 = K0 1
  0005  LEN       R5 = len R0
  0006  MOD       R6 = K1(3) mod R5
  0007  NEWTABLE  R7 = {} (0 items)
  0008  LOADK     R8 = K0 1
  0009  SUB       R9 = R6 sub R5
  0010  LOADK     R10 = K1 3
  0011  FORPREP   forprep R8(sBx=72)   -> 84
  0012  SELF      R13 = R0[K2('byte')] (self)
  0013  MOVE      R14 = R0
  0014  ADD       R15 = K3(2) add R11
  0015  CALL      R12 = call(R12, 3 args, 3 rets)
  0016  MUL       R15 = K4(65536) mul R12
  0017  MUL       R16 = K5(256) mul R13
  0018  ADD       R15 = R16 add R15
  0019  ADD       R15 = R14 add R15
  0020  LOADNIL   R16..R16 = nil
  0021  TEST      if not R2 then   -> -131049
  0022  JMP       (jump)   -> 55
  0023  GETTABLE  R16 = R7[R15]
  0024  TEST      if not R16 then   -> -131045
  0025  JMP       (jump)   -> 82
  0026  GETUPVAL  R17 = DEFAULT_ENCODER
  0027  GETUPVAL  R18 = DEFAULT_ENCODER
  0028  MOVE      R19 = R0
  0029  LOADK     R20 = K6 18
  0030  LOADK     R21 = K7 6
  0031  CALL      R18 = call(R18, 1 args, 3 rets)
  0032  GETTABLE  R18 = R1[R18]
  0033  GETUPVAL  R19 = DEFAULT_ENCODER
  0034  MOVE      R20 = R0
  0035  LOADK     R21 = K8 12
  0036  LOADK     R22 = K7 6
  0037  CALL      R19 = call(R19, 1 args, 3 rets)
  0038  GETTABLE  R19 = R1[R19]
  0039  GETUPVAL  R20 = DEFAULT_ENCODER
  0040  MOVE      R21 = R0
  0041  LOADK     R22 = K7 6
  0042  LOADK     R23 = K7 6
  0043  CALL      R20 = call(R20, 1 args, 3 rets)
  0044  GETTABLE  R20 = R1[R20]
  0045  GETUPVAL  R21 = DEFAULT_ENCODER
  0046  MOVE      R22 = R0
  0047  LOADK     R23 = K9 0
  0048  LOADK     R24 = K7 6
  0049  CALL      R21 = call(R21, 1 args, 3 rets)
  0050  GETTABLE  R21 = R1[R21]
  0051  CALL      R17 = call(R17, 1 args, 4 rets)
  0052  MOVE      R16 = R0
  0053  SETTABLE  R7[R15] = R16
  0054  JMP       (jump)   -> 82
  0055  GETUPVAL  R17 = DEFAULT_ENCODER
  0056  GETUPVAL  R18 = DEFAULT_ENCODER
  0057  MOVE      R19 = R0
  0058  LOADK     R20 = K6 18
  0059  LOADK     R21 = K7 6
  0060  CALL      R18 = call(R18, 1 args, 3 rets)
  0061  GETTABLE  R18 = R1[R18]
  0062  GETUPVAL  R19 = DEFAULT_ENCODER
  0063  MOVE      R20 = R0
  0064  LOADK     R21 = K8 12
  0065  LOADK     R22 = K7 6
  0066  CALL      R19 = call(R19, 1 args, 3 rets)
  0067  GETTABLE  R19 = R1[R19]
  0068  GETUPVAL  R20 = DEFAULT_ENCODER
  0069  MOVE      R21 = R0
  0070  LOADK     R22 = K7 6
  0071  LOADK     R23 = K7 6
  0072  CALL      R20 = call(R20, 1 args, 3 rets)
  0073  GETTABLE  R20 = R1[R20]
  0074  GETUPVAL  R21 = DEFAULT_ENCODER
  0075  MOVE      R22 = R0
  0076  LOADK     R23 = K9 0
  0077  LOADK     R24 = K7 6
  0078  CALL      R21 = call(R21, 1 args, 3 rets)
  0079  GETTABLE  R21 = R1[R21]
  0080  CALL      R17 = call(R17, 1 args, 4 rets)
  0081  MOVE      R16 = R0
  0082  SETTABLE  R3[R4] = R16
  0083  ADD       R4 = K0(1) add R4
  0084  FORLOOP   forloop R8(sBx=-73)   -> 12
  0085  EQ        if R0 eq K3(2)   -> -127654
  0086  JMP       (jump)   -> 117
  0087  SELF      R9 = R0[K2('byte')] (self)
  0088  SUB       R10 = K0(1) sub R5
  0089  MOVE      R11 = R0
  0090  CALL      R8 = call(R8, 2 args, 3 rets)
  0091  MUL       R10 = K4(65536) mul R8
  0092  MUL       R11 = K5(256) mul R9
  0093  ADD       R10 = R11 add R10
  0094  GETUPVAL  R11 = DEFAULT_ENCODER
  0095  GETUPVAL  R12 = DEFAULT_ENCODER
  0096  MOVE      R13 = R0
  0097  LOADK     R14 = K6 18
  0098  LOADK     R15 = K7 6
  0099  CALL      R12 = call(R12, 1 args, 3 rets)
  0100  GETTABLE  R12 = R1[R12]
  0101  GETUPVAL  R13 = DEFAULT_ENCODER
  0102  MOVE      R14 = R0
  0103  LOADK     R15 = K8 12
  0104  LOADK     R16 = K7 6
  0105  CALL      R13 = call(R13, 1 args, 3 rets)
  0106  GETTABLE  R13 = R1[R13]
  0107  GETUPVAL  R14 = DEFAULT_ENCODER
  0108  MOVE      R15 = R0
  0109  LOADK     R16 = K7 6
  0110  LOADK     R17 = K7 6
  0111  CALL      R14 = call(R14, 1 args, 3 rets)
  0112  GETTABLE  R14 = R1[R14]
  0113  GETTABLE  R15 = R1[K10(64)]
  0114  CALL      R11 = call(R11, 1 args, 4 rets)
  0115  SETTABLE  R3[R4] = R11
  0116  JMP       (jump)   -> 140
  0117  EQ        if R0 eq K0(1)   -> -127625
  0118  JMP       (jump)   -> 140
  0119  SELF      R9 = R0[K2('byte')] (self)
  0120  MOVE      R10 = R0
  0121  CALL      R8 = call(R8, 1 args, 2 rets)
  0122  MUL       R8 = K4(65536) mul R8
  0123  GETUPVAL  R9 = DEFAULT_ENCODER
  0124  GETUPVAL  R10 = DEFAULT_ENCODER
  0125  MOVE      R11 = R0
  0126  LOADK     R12 = K6 18
  0127  LOADK     R13 = K7 6
  0128  CALL      R10 = call(R10, 1 args, 3 rets)
  0129  GETTABLE  R10 = R1[R10]
  0130  GETUPVAL  R11 = DEFAULT_ENCODER
  0131  MOVE      R12 = R0
  0132  LOADK     R13 = K8 12
  0133  LOADK     R14 = K7 6
  0134  CALL      R11 = call(R11, 1 args, 3 rets)
  0135  GETTABLE  R11 = R1[R11]
  0136  GETTABLE  R12 = R1[K10(64)]
  0137  GETTABLE  R13 = R1[K10(64)]
  0138  CALL      R9 = call(R9, 1 args, 4 rets)
  0139  SETTABLE  R3[R4] = R9
  0140  GETUPVAL  R8 = DEFAULT_ENCODER
  0141  MOVE      R9 = R0
  0142  TAILCALL  tailcall(R8, 0)
  0143  RETURN    return R8..R7
  0144  RETURN    return R0..R-1
; ---------- proto5 [encodeAndReplace] ----------
  ; fn ?  line 112-118 np=0 va=1 ms=5 code=26 consts=9 upvals=2 protos=0
  ;   K[0]='encode'
  ;   K[1]='string'
  ;   K[2]='gsub'
  ;   K[3]='\n'
  ;   K[4]=''
  ;   K[5]='+'
  ;   K[6]='-'
  ;   K[7]='/'
  ;   K[8]='_'
  ;   upvals: base64, _ENV
  ;   locals: result(3-26)
  0000  GETTABUP  R0 = base64[K0('encode')]
  0001  VARARG    R1 = vararg(0)
  0002  CALL      R0 = call(R0, 1 args, -1 rets)
  0003  GETTABUP  R1 = _ENV[K1('string')]
  0004  GETTABLE  R1 = R1[K2('gsub')]
  0005  MOVE      R2 = R0
  0006  LOADK     R3 = K3 '\n'
  0007  LOADK     R4 = K4 ''
  0008  CALL      R1 = call(R1, 1 args, 3 rets)
  0009  MOVE      R0 = R0
  0010  GETTABUP  R1 = _ENV[K1('string')]
  0011  GETTABLE  R1 = R1[K2('gsub')]
  0012  MOVE      R2 = R0
  0013  LOADK     R3 = K5 '+'
  0014  LOADK     R4 = K6 '-'
  0015  CALL      R1 = call(R1, 1 args, 3 rets)
  0016  MOVE      R0 = R0
  0017  GETTABUP  R1 = _ENV[K1('string')]
  0018  GETTABLE  R1 = R1[K2('gsub')]
  0019  MOVE      R2 = R0
  0020  LOADK     R3 = K7 '/'
  0021  LOADK     R4 = K8 '_'
  0022  CALL      R1 = call(R1, 1 args, 3 rets)
  0023  MOVE      R0 = R0
  0024  RETURN    return R0..R-1
  0025  RETURN    return R0..R-1
; ---------- proto6 [decode] ----------
  ; fn ?  line 120-165 np=3 va=0 ms=27 code=196 consts=27 upvals=5 protos=0
  ;   K[0]='[^%w%+%/%=]'
  ;   K[1]='pairs'
  ;   K[2]=62
  ;   K[3]=63
  ;   K[4]='[^%%w%%%s%%%s%%=]'
  ;   K[5]='format'
  ;   K[6]='gsub'
  ;   K[7]=''
  ;   K[8]=1
  ;   K[9]='sub'
  ;   K[10]=-2
  ;   K[11]='=='
  ;   K[12]=2
  ;   K[13]=-1
  ;   K[14]='='
  ;   K[15]=0
  ;   K[16]=4
  ;   K[17]='byte'
  ;   K[18]=3
  ;   K[19]=16777216
  ;   K[20]=65536
  ;   K[21]=256
  ;   K[22]=262144
  ;   K[23]=4096
  ;   K[24]=64
  ;   K[25]=16
  ;   K[26]=8
  ;   upvals: DEFAULT_DECODER, _ENV, char, extract, concat
  ;   locals: b64(0-196), decoder(0-196), usecaching(0-196), pattern(4-196), s62(7-30), s63(7-30), (for generator)(10-20), (for state)(10-20), (for control)(10-20), charcode(11-18), b64code(11-18), cache(38-196), t(40-196), k(40-196), n(41-196), padding(58-196), (for index)(66-144), (for limit)(66-144), (for step)(66-144), i(67-143), a(71-143), b(71-143), c(71-143), d(71-143), s(72-143), v0(80-112), v(93-112), v(123-141), a(150-171), b(150-171), c(150-171), v(158-171), a(178-191), b(178-191), v(183-191)
  0000  TEST      if not R1 then   -> -131069
  0001  JMP       (jump)   -> 3
  0002  GETUPVAL  R1 = DEFAULT_DECODER
  0003  LOADK     R3 = K0 '[^%w%+%/%=]'
  0004  TEST      if not R1 then   -> -131066
  0005  JMP       (jump)   -> 30
  0006  LOADNIL   R4..R4 = nil
  0007  GETTABUP  R6 = _ENV[K1('pairs')]
  0008  MOVE      R7 = R0
  0009  CALL      R6 = call(R6, 3 args, 1 rets)
  0010  JMP       (jump)   -> 18
  0011  EQ        if R0 eq K2(62)   -> -125681
  0012  JMP       (jump)   -> 15
  0013  MOVE      R4 = R0
  0014  JMP       (jump)   -> 18
  0015  EQ        if R0 eq K3(63)   -> -125676
  0016  JMP       (jump)   -> 18
  0017  MOVE      R5 = R0
  0018  TFORCALL  tforcall R6
  0019  TFORLOOP  tforloop R8(sBx=-9)   -> 11
  0020  LOADK     R6 = K4 '[^%%w%%%s%%%s%%=]'
  0021  SELF      R7 = R6[K5('format')] (self)
  0022  GETUPVAL  R8 = DEFAULT_DECODER
  0023  MOVE      R9 = R0
  0024  CALL      R8 = call(R8, 1 args, 1 rets)
  0025  GETUPVAL  R9 = DEFAULT_DECODER
  0026  MOVE      R10 = R0
  0027  CALL      R9 = call(R9, -1 args, 1 rets)
  0028  CALL      R6 = call(R6, 1 args, -1 rets)
  0029  MOVE      R3 = R0
  0030  SELF      R5 = R0[K6('gsub')] (self)
  0031  MOVE      R6 = R0
  0032  LOADK     R7 = K7 ''
  0033  CALL      R4 = call(R4, 1 args, 3 rets)
  0034  MOVE      R0 = R0
  0035  TESTSET   if R0 then R4   -> -130011
  0036  JMP       (jump)   -> 38
  0037  NEWTABLE  R4 = {} (0 items)
  0038  NEWTABLE  R5 = {} (0 items)
  0039  LOADK     R6 = K8 1
  0040  LEN       R7 = len R0
  0041  SELF      R9 = R0[K9('sub')] (self)
  0042  LOADK     R10 = K10 -2
  0043  CALL      R8 = call(R8, 1 args, 2 rets)
  0044  EQ        if R0 eq K11('==')   -> -126663
  0045  JMP       (jump)   -> 49
  0046  LOADK     R8 = K12 2
  0047  TEST      if not R8 then   -> -131022
  0048  JMP       (jump)   -> 58
  0049  SELF      R9 = R0[K9('sub')] (self)
  0050  LOADK     R10 = K13 -1
  0051  CALL      R8 = call(R8, 1 args, 2 rets)
  0052  EQ        if R0 eq K14('=')   -> -126652
  0053  JMP       (jump)   -> 57
  0054  LOADK     R8 = K8 1
  0055  TEST      if not R8 then   -> -131014
  0056  JMP       (jump)   -> 58
  0057  LOADK     R8 = K15 0
  0058  LOADK     R9 = K8 1
  0059  LT        if R0 lt R8   -> 7749
  0060  JMP       (jump)   -> 64
  0061  SUB       R10 = K16(4) sub R7
  0062  TEST      if not R10 then   -> -131007
  0063  JMP       (jump)   -> 65
  0064  MOVE      R10 = R0
  0065  LOADK     R11 = K16 4
  0066  FORPREP   forprep R9(sBx=76)   -> 143
  0067  SELF      R14 = R0[K17('byte')] (self)
  0068  MOVE      R15 = R0
  0069  ADD       R16 = K18(3) add R12
  0070  CALL      R13 = call(R13, 4 args, 3 rets)
  0071  LOADNIL   R17..R17 = nil
  0072  TEST      if not R2 then   -> -130998
  0073  JMP       (jump)   -> 113
  0074  MUL       R18 = K19(16777216) mul R13
  0075  MUL       R19 = K20(65536) mul R14
  0076  ADD       R18 = R19 add R18
  0077  MUL       R19 = K21(256) mul R15
  0078  ADD       R18 = R19 add R18
  0079  ADD       R18 = R16 add R18
  0080  GETTABLE  R17 = R4[R18]
  0081  TEST      if not R17 then   -> -130988
  0082  JMP       (jump)   -> 141
  0083  GETTABLE  R19 = R1[R13]
  0084  MUL       R19 = K22(262144) mul R19
  0085  GETTABLE  R20 = R1[R14]
  0086  MUL       R20 = K23(4096) mul R20
  0087  ADD       R19 = R20 add R19
  0088  GETTABLE  R20 = R1[R15]
  0089  MUL       R20 = K24(64) mul R20
  0090  ADD       R19 = R20 add R19
  0091  GETTABLE  R20 = R1[R16]
  0092  ADD       R19 = R20 add R19
  0093  GETUPVAL  R20 = DEFAULT_DECODER
  0094  GETUPVAL  R21 = DEFAULT_DECODER
  0095  MOVE      R22 = R0
  0096  LOADK     R23 = K25 16
  0097  LOADK     R24 = K26 8
  0098  CALL      R21 = call(R21, 1 args, 3 rets)
  0099  GETUPVAL  R22 = DEFAULT_DECODER
  0100  MOVE      R23 = R0
  0101  LOADK     R24 = K26 8
  0102  LOADK     R25 = K26 8
  0103  CALL      R22 = call(R22, 1 args, 3 rets)
  0104  GETUPVAL  R23 = DEFAULT_DECODER
  0105  MOVE      R24 = R0
  0106  LOADK     R25 = K15 0
  0107  LOADK     R26 = K26 8
  0108  CALL      R23 = call(R23, -1 args, 3 rets)
  0109  CALL      R20 = call(R20, 1 args, -1 rets)
  0110  MOVE      R17 = R0
  0111  SETTABLE  R4[R18] = R17
  0112  JMP       (jump)   -> 141
  0113  GETTABLE  R18 = R1[R13]
  0114  MUL       R18 = K22(262144) mul R18
  0115  GETTABLE  R19 = R1[R14]
  0116  MUL       R19 = K23(4096) mul R19
  0117  ADD       R18 = R19 add R18
  0118  GETTABLE  R19 = R1[R15]
  0119  MUL       R19 = K24(64) mul R19
  0120  ADD       R18 = R19 add R18
  0121  GETTABLE  R19 = R1[R16]
  0122  ADD       R18 = R19 add R18
  0123  GETUPVAL  R19 = DEFAULT_DECODER
  0124  GETUPVAL  R20 = DEFAULT_DECODER
  0125  MOVE      R21 = R0
  0126  LOADK     R22 = K25 16
  0127  LOADK     R23 = K26 8
  0128  CALL      R20 = call(R20, 1 args, 3 rets)
  0129  GETUPVAL  R21 = DEFAULT_DECODER
  0130  MOVE      R22 = R0
  0131  LOADK     R23 = K26 8
  0132  LOADK     R24 = K26 8
  0133  CALL      R21 = call(R21, 1 args, 3 rets)
  0134  GETUPVAL  R22 = DEFAULT_DECODER
  0135  MOVE      R23 = R0
  0136  LOADK     R24 = K15 0
  0137  LOADK     R25 = K26 8
  0138  CALL      R22 = call(R22, -1 args, 3 rets)
  0139  CALL      R19 = call(R19, 1 args, -1 rets)
  0140  MOVE      R17 = R0
  0141  SETTABLE  R5[R6] = R17
  0142  ADD       R6 = K8(1) add R6
  0143  FORLOOP   forloop R9(sBx=-77)   -> 67
  0144  EQ        if R0 eq K8(1)   -> -126566
  0145  JMP       (jump)   -> 172
  0146  SELF      R10 = R0[K17('byte')] (self)
  0147  SUB       R11 = K18(3) sub R7
  0148  SUB       R12 = K8(1) sub R7
  0149  CALL      R9 = call(R9, 3 args, 3 rets)
  0150  GETTABLE  R12 = R1[R9]
  0151  MUL       R12 = K22(262144) mul R12
  0152  GETTABLE  R13 = R1[R10]
  0153  MUL       R13 = K23(4096) mul R13
  0154  ADD       R12 = R13 add R12
  0155  GETTABLE  R13 = R1[R11]
  0156  MUL       R13 = K24(64) mul R13
  0157  ADD       R12 = R13 add R12
  0158  GETUPVAL  R13 = DEFAULT_DECODER
  0159  GETUPVAL  R14 = DEFAULT_DECODER
  0160  MOVE      R15 = R0
  0161  LOADK     R16 = K25 16
  0162  LOADK     R17 = K26 8
  0163  CALL      R14 = call(R14, 1 args, 3 rets)
  0164  GETUPVAL  R15 = DEFAULT_DECODER
  0165  MOVE      R16 = R0
  0166  LOADK     R17 = K26 8
  0167  LOADK     R18 = K26 8
  0168  CALL      R15 = call(R15, -1 args, 3 rets)
  0169  CALL      R13 = call(R13, 1 args, -1 rets)
  0170  SETTABLE  R5[R6] = R13
  0171  JMP       (jump)   -> 191
  0172  EQ        if R0 eq K12(2)   -> -126534
  0173  JMP       (jump)   -> 191
  0174  SELF      R10 = R0[K17('byte')] (self)
  0175  SUB       R11 = K18(3) sub R7
  0176  SUB       R12 = K12(2) sub R7
  0177  CALL      R9 = call(R9, 2 args, 3 rets)
  0178  GETTABLE  R11 = R1[R9]
  0179  MUL       R11 = K22(262144) mul R11
  0180  GETTABLE  R12 = R1[R10]
  0181  MUL       R12 = K23(4096) mul R12
  0182  ADD       R11 = R12 add R11
  0183  GETUPVAL  R12 = DEFAULT_DECODER
  0184  GETUPVAL  R13 = DEFAULT_DECODER
  0185  MOVE      R14 = R0
  0186  LOADK     R15 = K25 16
  0187  LOADK     R16 = K26 8
  0188  CALL      R13 = call(R13, -1 args, 3 rets)
  0189  CALL      R12 = call(R12, 1 args, -1 rets)
  0190  SETTABLE  R5[R6] = R12
  0191  GETUPVAL  R9 = DEFAULT_DECODER
  0192  MOVE      R10 = R0
  0193  TAILCALL  tailcall(R9, 0)
  0194  RETURN    return R9..R8
  0195  RETURN    return R0..R-1
