void Base64Encode(char *src, int src_len, char *dst) {
  int i = 0, j = 0;
  char base64_map[65] =
      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  for (; i < src_len - src_len % 3; i += 3) {
    dst[j++] = base64_map[(src[i] >> 2) & 0x3F];
    dst[j++] = base64_map[((src[i] << 4) & 0x30) + ((src[i + 1] >> 4) & 0xF)];
    dst[j++] =
        base64_map[((src[i + 1] << 2) & 0x3C) + ((src[i + 2] >> 6) & 0x3)];
    dst[j++] = base64_map[src[i + 2] & 0x3F];
  }
  if (src_len % 3 == 1) {
    dst[j++] = base64_map[(src[i] >> 2) & 0x3F];
    dst[j++] = base64_map[(src[i] << 4) & 0x30];
    dst[j++] = '=';
    dst[j++] = '=';
  } else if (src_len % 3 == 2) {
    dst[j++] = base64_map[(src[i] >> 2) & 0x3F];
    dst[j++] = base64_map[((src[i] << 4) & 0x30) + ((src[i + 1] >> 4) & 0xF)];
    dst[j++] = base64_map[(src[i + 1] << 2) & 0x3C];
    dst[j++] = '=';
  }
  dst[j] = '\0';
}


x86 assembly (clang, -O0):
<Base64Encode>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
lea    -0x70(%rbp),%rdi
lea    0xec1(%rip),%rsi
mov    $0x41,%edx
call   1030 <memcpy@plt>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0xc(%rbp),%ecx
mov    -0xc(%rbp),%eax
mov    $0x3,%esi
cltd
idiv   %esi
mov    -0x74(%rbp),%eax
sub    %edx,%ecx
cmp    %ecx,%eax
jge    1265 <Base64Encode+0x155>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sar    $0x2,%eax
and    $0x3f,%eax
cltq
mov    -0x70(%rbp,%rax,1),%dl
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
shl    $0x4,%eax
and    $0x30,%eax
mov    -0x8(%rbp),%rcx
mov    -0x1c(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
sar    $0x4,%ecx
and    $0xf,%ecx
add    %ecx,%eax
cltq
mov    -0x70(%rbp,%rax,1),%dl
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
shl    $0x2,%eax
and    $0x3c,%eax
mov    -0x8(%rbp),%rcx
mov    -0x1c(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
sar    $0x6,%ecx
and    $0x3,%ecx
add    %ecx,%eax
cltq
mov    -0x70(%rbp,%rax,1),%dl
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
and    $0x3f,%eax
cltq
mov    -0x70(%rbp,%rax,1),%dl
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0x1c(%rbp)
jmp    1149 <Base64Encode+0x39>
mov    -0xc(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
cmp    $0x1,%edx
jne    1304 <Base64Encode+0x1f4>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sar    $0x2,%eax
and    $0x3f,%eax
cltq
mov    -0x70(%rbp,%rax,1),%dl
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
shl    $0x4,%eax
and    $0x30,%eax
cltq
mov    -0x70(%rbp,%rax,1),%dl
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x20(%rbp)
movslq %ecx,%rcx
movb   $0x3d,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x20(%rbp)
movslq %ecx,%rcx
movb   $0x3d,(%rax,%rcx,1)
jmp    13d8 <Base64Encode+0x2c8>
mov    -0xc(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
cmp    $0x2,%edx
jne    13d3 <Base64Encode+0x2c3>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sar    $0x2,%eax
and    $0x3f,%eax
cltq
mov    -0x70(%rbp,%rax,1),%dl
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
shl    $0x4,%eax
and    $0x30,%eax
mov    -0x8(%rbp),%rcx
mov    -0x1c(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
sar    $0x4,%ecx
and    $0xf,%ecx
add    %ecx,%eax
cltq
mov    -0x70(%rbp,%rax,1),%dl
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
shl    $0x2,%eax
and    $0x3c,%eax
cltq
mov    -0x70(%rbp,%rax,1),%dl
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x20(%rbp)
movslq %ecx,%rcx
movb   $0x3d,(%rax,%rcx,1)
jmp    13d8 <Base64Encode+0x2c8>
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Base64Encode>:
movslq %esi,%r8
imul   $0x55555556,%r8,%rax
mov    %rax,%rcx
shr    $0x3f,%rcx
shr    $0x20,%rax
add    %ecx,%eax
lea    (%rax,%rax,2),%eax
sub    %eax,%r8d
test   %eax,%eax
jle    11b1 <Base64Encode+0xb1>
mov    %eax,%r9d
xor    %esi,%esi
lea    0xecf(%rip),%r10
xor    %r11d,%r11d
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl (%rdi,%rsi,1),%ecx
shr    $0x2,%rcx
movzbl (%rcx,%r10,1),%ecx
mov    %cl,(%rdx,%r11,1)
movzbl (%rdi,%rsi,1),%ecx
shl    $0x4,%ecx
and    $0x30,%ecx
movzbl 0x1(%rdi,%rsi,1),%eax
shr    $0x4,%rax
or     %rcx,%rax
movzbl (%r10,%rax,1),%eax
mov    %al,0x1(%rdx,%r11,1)
movzbl 0x1(%rdi,%rsi,1),%eax
and    $0xf,%eax
movzbl 0x2(%rdi,%rsi,1),%ecx
shr    $0x6,%rcx
lea    (%rcx,%rax,4),%rax
movzbl (%r10,%rax,1),%eax
mov    %al,0x2(%rdx,%r11,1)
movzbl 0x2(%rdi,%rsi,1),%eax
and    $0x3f,%eax
movzbl (%rax,%r10,1),%eax
mov    %al,0x3(%rdx,%r11,1)
add    $0x4,%r11
add    $0x3,%rsi
cmp    %r9,%rsi
jb     1140 <Base64Encode+0x40>
jmp    11b6 <Base64Encode+0xb6>
xor    %esi,%esi
xor    %r11d,%r11d
mov    %r11d,%ecx
cmp    $0x2,%r8d
je     1202 <Base64Encode+0x102>
cmp    $0x1,%r8d
jne    1267 <Base64Encode+0x167>
mov    %esi,%r9d
movzbl (%rdi,%r9,1),%esi
shr    $0x2,%rsi
lea    0xe24(%rip),%r8
mov    (%rsi,%r8,1),%al
mov    %al,(%rdx,%rcx,1)
mov    %rcx,%r10
or     $0x1,%r10
movzbl (%rdi,%r9,1),%esi
shl    $0x4,%esi
and    $0x30,%esi
mov    (%rsi,%r8,1),%al
mov    %al,(%rdx,%r10,1)
mov    $0x3d,%sil
jmp    1250 <Base64Encode+0x150>
mov    %esi,%r9d
movzbl (%rdi,%r9,1),%esi
shr    $0x2,%rsi
lea    0xdeb(%rip),%r8
mov    (%rsi,%r8,1),%al
mov    %al,(%rdx,%rcx,1)
mov    %rcx,%r10
or     $0x1,%r10
movzbl (%rdi,%r9,1),%esi
shl    $0x4,%esi
and    $0x30,%esi
movzbl 0x1(%rdi,%r9,1),%eax
shr    $0x4,%rax
or     %rsi,%rax
mov    (%r8,%rax,1),%al
mov    %al,(%rdx,%r10,1)
movzbl 0x1(%rdi,%r9,1),%eax
and    $0xf,%eax
mov    (%r8,%rax,4),%sil
mov    %rcx,%rax
or     $0x2,%rax
or     $0x3,%rcx
mov    %sil,(%rdx,%rax,1)
add    $0x4,%r11d
movb   $0x3d,(%rdx,%rcx,1)
movslq %r11d,%rax
movb   $0x0,(%rdx,%rax,1)
ret

LLVM IR (-O0):
@__const.Base64Encode.base64_map = [65 x i8] c"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\00"
define void @Base64Encode(i8* %0, i32 %1, i8* %2) {
%4 = alloca i8*
%5 = alloca i32
%6 = alloca i8*
%7 = alloca i32
%8 = alloca i32
%9 = alloca [65 x i8]
store i8* %0, i8** %4
store i32 %1, i32* %5
store i8* %2, i8** %6
store i32 0, i32* %7
store i32 0, i32* %8
%10 = bitcast [65 x i8]* %9 to i8*
br label %11
11: ; preds = %104, %3
%12 = load i32, i32* %7
%13 = load i32, i32* %5
%14 = load i32, i32* %5
%15 = srem i32 %14, 3
%16 = sub nsw i32 %13, %15
%17 = icmp slt i32 %12, %16
br i1 %17, label %18, label %107
18: ; preds = %11
%19 = load i8*, i8** %4
%20 = load i32, i32* %7
%21 = sext i32 %20 to i64
%22 = getelementptr inbounds i8, i8* %19, i64 %21
%23 = load i8, i8* %22
%24 = sext i8 %23 to i32
%25 = ashr i32 %24, 2
%26 = and i32 %25, 63
%27 = sext i32 %26 to i64
%28 = getelementptr inbounds [65 x i8], [65 x i8]* %9, i64 0, i64 %27
%29 = load i8, i8* %28
%30 = load i8*, i8** %6
%31 = load i32, i32* %8
%32 = add nsw i32 %31, 1
store i32 %32, i32* %8
%33 = sext i32 %31 to i64
%34 = getelementptr inbounds i8, i8* %30, i64 %33
store i8 %29, i8* %34
%35 = load i8*, i8** %4
%36 = load i32, i32* %7
%37 = sext i32 %36 to i64
%38 = getelementptr inbounds i8, i8* %35, i64 %37
%39 = load i8, i8* %38
%40 = sext i8 %39 to i32
%41 = shl i32 %40, 4
%42 = and i32 %41, 48
%43 = load i8*, i8** %4
%44 = load i32, i32* %7
%45 = add nsw i32 %44, 1
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds i8, i8* %43, i64 %46
%48 = load i8, i8* %47
%49 = sext i8 %48 to i32
%50 = ashr i32 %49, 4
%51 = and i32 %50, 15
%52 = add nsw i32 %42, %51
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds [65 x i8], [65 x i8]* %9, i64 0, i64 %53
%55 = load i8, i8* %54
%56 = load i8*, i8** %6
%57 = load i32, i32* %8
%58 = add nsw i32 %57, 1
store i32 %58, i32* %8
%59 = sext i32 %57 to i64
%60 = getelementptr inbounds i8, i8* %56, i64 %59
store i8 %55, i8* %60
%61 = load i8*, i8** %4
%62 = load i32, i32* %7
%63 = add nsw i32 %62, 1
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds i8, i8* %61, i64 %64
%66 = load i8, i8* %65
%67 = sext i8 %66 to i32
%68 = shl i32 %67, 2
%69 = and i32 %68, 60
%70 = load i8*, i8** %4
%71 = load i32, i32* %7
%72 = add nsw i32 %71, 2
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds i8, i8* %70, i64 %73
%75 = load i8, i8* %74
%76 = sext i8 %75 to i32
%77 = ashr i32 %76, 6
%78 = and i32 %77, 3
%79 = add nsw i32 %69, %78
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds [65 x i8], [65 x i8]* %9, i64 0, i64 %80
%82 = load i8, i8* %81
%83 = load i8*, i8** %6
%84 = load i32, i32* %8
%85 = add nsw i32 %84, 1
store i32 %85, i32* %8
%86 = sext i32 %84 to i64
%87 = getelementptr inbounds i8, i8* %83, i64 %86
store i8 %82, i8* %87
%88 = load i8*, i8** %4
%89 = load i32, i32* %7
%90 = add nsw i32 %89, 2
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds i8, i8* %88, i64 %91
%93 = load i8, i8* %92
%94 = sext i8 %93 to i32
%95 = and i32 %94, 63
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds [65 x i8], [65 x i8]* %9, i64 0, i64 %96
%98 = load i8, i8* %97
%99 = load i8*, i8** %6
%100 = load i32, i32* %8
%101 = add nsw i32 %100, 1
store i32 %101, i32* %8
%102 = sext i32 %100 to i64
%103 = getelementptr inbounds i8, i8* %99, i64 %102
store i8 %98, i8* %103
br label %104
104: ; preds = %18
%105 = load i32, i32* %7
%106 = add nsw i32 %105, 3
store i32 %106, i32* %7
br label %11
107: ; preds = %11
%108 = load i32, i32* %5
%109 = srem i32 %108, 3
%110 = icmp eq i32 %109, 1
br i1 %110, label %111, label %154
111: ; preds = %107
%112 = load i8*, i8** %4
%113 = load i32, i32* %7
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds i8, i8* %112, i64 %114
%116 = load i8, i8* %115
%117 = sext i8 %116 to i32
%118 = ashr i32 %117, 2
%119 = and i32 %118, 63
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds [65 x i8], [65 x i8]* %9, i64 0, i64 %120
%122 = load i8, i8* %121
%123 = load i8*, i8** %6
%124 = load i32, i32* %8
%125 = add nsw i32 %124, 1
store i32 %125, i32* %8
%126 = sext i32 %124 to i64
%127 = getelementptr inbounds i8, i8* %123, i64 %126
store i8 %122, i8* %127
%128 = load i8*, i8** %4
%129 = load i32, i32* %7
%130 = sext i32 %129 to i64
%131 = getelementptr inbounds i8, i8* %128, i64 %130
%132 = load i8, i8* %131
%133 = sext i8 %132 to i32
%134 = shl i32 %133, 4
%135 = and i32 %134, 48
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds [65 x i8], [65 x i8]* %9, i64 0, i64 %136
%138 = load i8, i8* %137
%139 = load i8*, i8** %6
%140 = load i32, i32* %8
%141 = add nsw i32 %140, 1
store i32 %141, i32* %8
%142 = sext i32 %140 to i64
%143 = getelementptr inbounds i8, i8* %139, i64 %142
store i8 %138, i8* %143
%144 = load i8*, i8** %6
%145 = load i32, i32* %8
%146 = add nsw i32 %145, 1
store i32 %146, i32* %8
%147 = sext i32 %145 to i64
%148 = getelementptr inbounds i8, i8* %144, i64 %147
store i8 61, i8* %148
%149 = load i8*, i8** %6
%150 = load i32, i32* %8
%151 = add nsw i32 %150, 1
store i32 %151, i32* %8
%152 = sext i32 %150 to i64
%153 = getelementptr inbounds i8, i8* %149, i64 %152
store i8 61, i8* %153
br label %224
154: ; preds = %107
%155 = load i32, i32* %5
%156 = srem i32 %155, 3
%157 = icmp eq i32 %156, 2
br i1 %157, label %158, label %223
158: ; preds = %154
%159 = load i8*, i8** %4
%160 = load i32, i32* %7
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds i8, i8* %159, i64 %161
%163 = load i8, i8* %162
%164 = sext i8 %163 to i32
%165 = ashr i32 %164, 2
%166 = and i32 %165, 63
%167 = sext i32 %166 to i64
%168 = getelementptr inbounds [65 x i8], [65 x i8]* %9, i64 0, i64 %167
%169 = load i8, i8* %168
%170 = load i8*, i8** %6
%171 = load i32, i32* %8
%172 = add nsw i32 %171, 1
store i32 %172, i32* %8
%173 = sext i32 %171 to i64
%174 = getelementptr inbounds i8, i8* %170, i64 %173
store i8 %169, i8* %174
%175 = load i8*, i8** %4
%176 = load i32, i32* %7
%177 = sext i32 %176 to i64
%178 = getelementptr inbounds i8, i8* %175, i64 %177
%179 = load i8, i8* %178
%180 = sext i8 %179 to i32
%181 = shl i32 %180, 4
%182 = and i32 %181, 48
%183 = load i8*, i8** %4
%184 = load i32, i32* %7
%185 = add nsw i32 %184, 1
%186 = sext i32 %185 to i64
%187 = getelementptr inbounds i8, i8* %183, i64 %186
%188 = load i8, i8* %187
%189 = sext i8 %188 to i32
%190 = ashr i32 %189, 4
%191 = and i32 %190, 15
%192 = add nsw i32 %182, %191
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds [65 x i8], [65 x i8]* %9, i64 0, i64 %193
%195 = load i8, i8* %194
%196 = load i8*, i8** %6
%197 = load i32, i32* %8
%198 = add nsw i32 %197, 1
store i32 %198, i32* %8
%199 = sext i32 %197 to i64
%200 = getelementptr inbounds i8, i8* %196, i64 %199
store i8 %195, i8* %200
%201 = load i8*, i8** %4
%202 = load i32, i32* %7
%203 = add nsw i32 %202, 1
%204 = sext i32 %203 to i64
%205 = getelementptr inbounds i8, i8* %201, i64 %204
%206 = load i8, i8* %205
%207 = sext i8 %206 to i32
%208 = shl i32 %207, 2
%209 = and i32 %208, 60
%210 = sext i32 %209 to i64
%211 = getelementptr inbounds [65 x i8], [65 x i8]* %9, i64 0, i64 %210
%212 = load i8, i8* %211
%213 = load i8*, i8** %6
%214 = load i32, i32* %8
%215 = add nsw i32 %214, 1
store i32 %215, i32* %8
%216 = sext i32 %214 to i64
%217 = getelementptr inbounds i8, i8* %213, i64 %216
store i8 %212, i8* %217
%218 = load i8*, i8** %6
%219 = load i32, i32* %8
%220 = add nsw i32 %219, 1
store i32 %220, i32* %8
%221 = sext i32 %219 to i64
%222 = getelementptr inbounds i8, i8* %218, i64 %221
store i8 61, i8* %222
br label %223
223: ; preds = %158, %154
br label %224
224: ; preds = %223, %111
%225 = load i8*, i8** %6
%226 = load i32, i32* %8
%227 = sext i32 %226 to i64
%228 = getelementptr inbounds i8, i8* %225, i64 %227
store i8 0, i8* %228
ret void
}

LLVM IR (-O2):
@__const.Base64Encode.base64_map = [65 x i8] c"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\00"
define void @Base64Encode(i8* nocapture %0, i32 %1, i8* nocapture writeonly %2) {
%4 = srem i32 %1, 3
%5 = sub nsw i32 %1, %4
%6 = icmp sgt i32 %5, 0
br i1 %6, label %7, label %60
7: ; preds = %3
%8 = zext i32 %5 to i64
br label %9
9: ; preds = %7, %9
%10 = phi i64 [ 0, %7 ], [ %55, %9 ]
%11 = phi i64 [ 0, %7 ], [ %53, %9 ]
%12 = getelementptr inbounds i8, i8* %0, i64 %10
%13 = load i8, i8* %12
%14 = lshr i8 %13, 2
%15 = zext i8 %14 to i64
%16 = getelementptr inbounds [65 x i8], [65 x i8]* @__const.Base64Encode.base64_map, i64 0, i64 %15
%17 = load i8, i8* %16
%18 = or i64 %11, 1
%19 = getelementptr inbounds i8, i8* %2, i64 %11
store i8 %17, i8* %19
%20 = load i8, i8* %12
%21 = sext i8 %20 to i64
%22 = shl nsw i64 %21, 4
%23 = and i64 %22, 48
%24 = add nuw nsw i64 %10, 1
%25 = getelementptr inbounds i8, i8* %0, i64 %24
%26 = load i8, i8* %25
%27 = lshr i8 %26, 4
%28 = zext i8 %27 to i64
%29 = or i64 %23, %28
%30 = getelementptr inbounds [65 x i8], [65 x i8]* @__const.Base64Encode.base64_map, i64 0, i64 %29
%31 = load i8, i8* %30
%32 = or i64 %11, 2
%33 = getelementptr inbounds i8, i8* %2, i64 %18
store i8 %31, i8* %33
%34 = load i8, i8* %25
%35 = sext i8 %34 to i64
%36 = shl nsw i64 %35, 2
%37 = and i64 %36, 60
%38 = add nuw nsw i64 %10, 2
%39 = getelementptr inbounds i8, i8* %0, i64 %38
%40 = load i8, i8* %39
%41 = lshr i8 %40, 6
%42 = zext i8 %41 to i64
%43 = or i64 %37, %42
%44 = getelementptr inbounds [65 x i8], [65 x i8]* @__const.Base64Encode.base64_map, i64 0, i64 %43
%45 = load i8, i8* %44
%46 = or i64 %11, 3
%47 = getelementptr inbounds i8, i8* %2, i64 %32
store i8 %45, i8* %47
%48 = load i8, i8* %39
%49 = and i8 %48, 63
%50 = zext i8 %49 to i64
%51 = getelementptr inbounds [65 x i8], [65 x i8]* @__const.Base64Encode.base64_map, i64 0, i64 %50
%52 = load i8, i8* %51
%53 = add nuw nsw i64 %11, 4
%54 = getelementptr inbounds i8, i8* %2, i64 %46
store i8 %52, i8* %54
%55 = add nuw nsw i64 %10, 3
%56 = icmp ult i64 %55, %8
br i1 %56, label %9, label %57
57: ; preds = %9
%58 = trunc i64 %55 to i32
%59 = trunc i64 %53 to i32
br label %60
60: ; preds = %57, %3
%61 = phi i32 [ 0, %3 ], [ %58, %57 ]
%62 = phi i32 [ 0, %3 ], [ %59, %57 ]
switch i32 %4, label %123 [
i32 1, label %63
i32 2, label %82
]
63: ; preds = %60
%64 = zext i32 %61 to i64
%65 = getelementptr inbounds i8, i8* %0, i64 %64
%66 = load i8, i8* %65
%67 = lshr i8 %66, 2
%68 = zext i8 %67 to i64
%69 = getelementptr inbounds [65 x i8], [65 x i8]* @__const.Base64Encode.base64_map, i64 0, i64 %68
%70 = load i8, i8* %69
%71 = or i32 %62, 1
%72 = zext i32 %62 to i64
%73 = getelementptr inbounds i8, i8* %2, i64 %72
store i8 %70, i8* %73
%74 = load i8, i8* %65
%75 = sext i8 %74 to i64
%76 = shl nsw i64 %75, 4
%77 = and i64 %76, 48
%78 = getelementptr inbounds [65 x i8], [65 x i8]* @__const.Base64Encode.base64_map, i64 0, i64 %77
%79 = load i8, i8* %78
%80 = zext i32 %71 to i64
%81 = getelementptr inbounds i8, i8* %2, i64 %80
store i8 %79, i8* %81
br label %114
82: ; preds = %60
%83 = zext i32 %61 to i64
%84 = getelementptr inbounds i8, i8* %0, i64 %83
%85 = load i8, i8* %84
%86 = lshr i8 %85, 2
%87 = zext i8 %86 to i64
%88 = getelementptr inbounds [65 x i8], [65 x i8]* @__const.Base64Encode.base64_map, i64 0, i64 %87
%89 = load i8, i8* %88
%90 = or i32 %62, 1
%91 = zext i32 %62 to i64
%92 = getelementptr inbounds i8, i8* %2, i64 %91
store i8 %89, i8* %92
%93 = load i8, i8* %84
%94 = sext i8 %93 to i64
%95 = shl nsw i64 %94, 4
%96 = and i64 %95, 48
%97 = add nuw nsw i32 %61, 1
%98 = zext i32 %97 to i64
%99 = getelementptr inbounds i8, i8* %0, i64 %98
%100 = load i8, i8* %99
%101 = lshr i8 %100, 4
%102 = zext i8 %101 to i64
%103 = or i64 %96, %102
%104 = getelementptr inbounds [65 x i8], [65 x i8]* @__const.Base64Encode.base64_map, i64 0, i64 %103
%105 = load i8, i8* %104
%106 = zext i32 %90 to i64
%107 = getelementptr inbounds i8, i8* %2, i64 %106
store i8 %105, i8* %107
%108 = load i8, i8* %99
%109 = sext i8 %108 to i64
%110 = shl nsw i64 %109, 2
%111 = and i64 %110, 60
%112 = getelementptr inbounds [65 x i8], [65 x i8]* @__const.Base64Encode.base64_map, i64 0, i64 %111
%113 = load i8, i8* %112
br label %114
114: ; preds = %63, %82
%115 = phi i8 [ %113, %82 ], [ 61, %63 ]
%116 = or i32 %62, 2
%117 = or i32 %62, 3
%118 = zext i32 %116 to i64
%119 = getelementptr inbounds i8, i8* %2, i64 %118
store i8 %115, i8* %119
%120 = add nuw nsw i32 %62, 4
%121 = zext i32 %117 to i64
%122 = getelementptr inbounds i8, i8* %2, i64 %121
store i8 61, i8* %122
br label %123
123: ; preds = %114, %60
%124 = phi i32 [ %62, %60 ], [ %120, %114 ]
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds i8, i8* %2, i64 %125
store i8 0, i8* %126
ret void
}