#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef int uint8_t;
typedef int uint16_t;

/* Variables and functions */
void *bit6toAscii(int);
void base64enc(char *dest, const void *src, uint16_t length) {
  uint16_t i, j;
  uint8_t a[4];
  for (i = 0; i < length / 3; ++i) {
    a[0] = (((uint8_t *)src)[i * 3 + 0]) >> 2;
    a[1] = (((((uint8_t *)src)[i * 3 + 0]) << 4) |
            ((((uint8_t *)src)[i * 3 + 1]) >> 4)) &
           0x3F;
    a[2] = (((((uint8_t *)src)[i * 3 + 1]) << 2) |
            ((((uint8_t *)src)[i * 3 + 2]) >> 6)) &
           0x3F;
    a[3] = (((uint8_t *)src)[i * 3 + 2]) & 0x3F;
    for (j = 0; j < 4; ++j) {
      *dest++ = bit6toAscii(a[j]);
    }
  }
  switch (length % 3) {
  case 0:
    break;
  case 1:
    a[0] = (((uint8_t *)src)[i * 3 + 0]) >> 2;
    a[1] = ((((uint8_t *)src)[i * 3 + 0]) << 4) & 0x3F;
    *dest++ = bit6toAscii(a[0]);
    *dest++ = bit6toAscii(a[1]);
    *dest++ = '=';
    *dest++ = '=';
    break;
  case 2:
    a[0] = (((uint8_t *)src)[i * 3 + 0]) >> 2;
    a[1] = (((((uint8_t *)src)[i * 3 + 0]) << 4) |
            ((((uint8_t *)src)[i * 3 + 1]) >> 4)) &
           0x3F;
    a[2] = ((((uint8_t *)src)[i * 3 + 1]) << 2) & 0x3F;
    *dest++ = bit6toAscii(a[0]);
    *dest++ = bit6toAscii(a[1]);
    *dest++ = bit6toAscii(a[2]);
    *dest++ = '=';
    break;
  default:
    break;
  }
  *dest = '\0';
}


x86 assembly (clang, -O0):
<base64enc>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x34(%rbp),%eax
cmp    %ecx,%eax
jge    1228 <base64enc+0x118>
mov    -0x10(%rbp),%rax
imul   $0x3,-0x18(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
sar    $0x2,%eax
mov    %eax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
imul   $0x3,-0x18(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
shl    $0x4,%eax
mov    -0x10(%rbp),%rcx
imul   $0x3,-0x18(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
sar    $0x4,%ecx
or     %ecx,%eax
and    $0x3f,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
imul   $0x3,-0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
shl    $0x2,%eax
mov    -0x10(%rbp),%rcx
imul   $0x3,-0x18(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
sar    $0x6,%ecx
or     %ecx,%eax
and    $0x3f,%eax
mov    %eax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
imul   $0x3,-0x18(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
and    $0x3f,%eax
mov    %eax,-0x24(%rbp)
movl   $0x0,-0x1c(%rbp)
cmpl   $0x4,-0x1c(%rbp)
jge    1215 <base64enc+0x105>
movslq -0x1c(%rbp),%rax
mov    -0x30(%rbp,%rax,4),%edi
call   1030 <bit6toAscii@plt>
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x8(%rbp)
mov    %cl,(%rax)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11dd <base64enc+0xcd>
jmp    121a <base64enc+0x10a>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    112a <base64enc+0x1a>
movslq -0x14(%rbp),%rcx
mov    %ecx,%eax
imul   $0x55555556,%rcx,%rdx
mov    %rdx,%rcx
shr    $0x3f,%rcx
shr    $0x20,%rdx
add    %ecx,%edx
mov    %edx,%ecx
lea    (%rcx,%rcx,2),%ecx
sub    %ecx,%eax
mov    %eax,-0x38(%rbp)
je     1279 <base64enc+0x169>
jmp    1257 <base64enc+0x147>
mov    -0x38(%rbp),%eax
sub    $0x1,%eax
je     127e <base64enc+0x16e>
jmp    1268 <base64enc+0x158>
mov    -0x38(%rbp),%eax
sub    $0x2,%eax
je     130e <base64enc+0x1fe>
jmp    13d7 <base64enc+0x2c7>
jmp    13dc <base64enc+0x2cc>
mov    -0x10(%rbp),%rax
imul   $0x3,-0x18(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
sar    $0x2,%eax
mov    %eax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
imul   $0x3,-0x18(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
shl    $0x4,%eax
and    $0x3f,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x30(%rbp),%edi
call   1030 <bit6toAscii@plt>
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x8(%rbp)
mov    %cl,(%rax)
mov    -0x2c(%rbp),%edi
call   1030 <bit6toAscii@plt>
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x8(%rbp)
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movb   $0x3d,(%rax)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movb   $0x3d,(%rax)
jmp    13dc <base64enc+0x2cc>
mov    -0x10(%rbp),%rax
imul   $0x3,-0x18(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
sar    $0x2,%eax
mov    %eax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
imul   $0x3,-0x18(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
shl    $0x4,%eax
mov    -0x10(%rbp),%rcx
imul   $0x3,-0x18(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
sar    $0x4,%ecx
or     %ecx,%eax
and    $0x3f,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
imul   $0x3,-0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
shl    $0x2,%eax
and    $0x3f,%eax
mov    %eax,-0x28(%rbp)
mov    -0x30(%rbp),%edi
call   1030 <bit6toAscii@plt>
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x8(%rbp)
mov    %cl,(%rax)
mov    -0x2c(%rbp),%edi
call   1030 <bit6toAscii@plt>
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x8(%rbp)
mov    %cl,(%rax)
mov    -0x28(%rbp),%edi
call   1030 <bit6toAscii@plt>
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x8(%rbp)
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movb   $0x3d,(%rax)
jmp    13dc <base64enc+0x2cc>
jmp    13dc <base64enc+0x2cc>
mov    -0x8(%rbp),%rax
movb   $0x0,(%rax)
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<base64enc>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %rdi,%r15
movslq %edx,%rcx
imul   $0x55555556,%rcx,%rdi
mov    %rdi,%rax
shr    $0x3f,%rax
shr    $0x20,%rdi
add    %eax,%edi
lea    (%rdi,%rdi,2),%eax
mov    %ecx,%edx
sub    %eax,%edx
xor    %eax,%eax
cmp    $0x3,%ecx
jl     11d8 <base64enc+0xc8>
mov    %edx,0x4(%rsp)
mov    %rdi,0x8(%rsp)
mov    %edi,%r13d
mov    %rsi,0x10(%rsp)
lea    0x8(%rsi),%r14
nop
mov    -0x8(%r14),%eax
mov    -0x4(%r14),%ecx
mov    %eax,%edi
sar    $0x2,%edi
shl    $0x4,%eax
mov    %ecx,%ebx
shr    $0x4,%ebx
or     %eax,%ebx
and    $0x3f,%ebx
shl    $0x2,%ecx
mov    (%r14),%r12d
mov    %r12d,%ebp
shr    $0x6,%ebp
or     %ecx,%ebp
and    $0x3f,%ebp
and    $0x3f,%r12d
call   1030 <bit6toAscii@plt>
mov    %al,(%r15)
mov    %ebx,%edi
call   1030 <bit6toAscii@plt>
mov    %al,0x1(%r15)
mov    %ebp,%edi
call   1030 <bit6toAscii@plt>
mov    %al,0x2(%r15)
mov    %r12d,%edi
call   1030 <bit6toAscii@plt>
mov    %al,0x3(%r15)
add    $0x4,%r15
add    $0xc,%r14
add    $0xffffffffffffffff,%r13
jne    1160 <base64enc+0x50>
mov    0x8(%rsp),%rax
lea    (%rax,%rax,2),%eax
mov    0x10(%rsp),%rsi
mov    0x4(%rsp),%edx
cmp    $0x2,%edx
je     120c <base64enc+0xfc>
cmp    $0x1,%edx
jne    1254 <base64enc+0x144>
mov    %eax,%eax
mov    (%rsi,%rax,4),%ebx
mov    %ebx,%edi
sar    $0x2,%edi
shl    $0x4,%ebx
and    $0x30,%ebx
call   1030 <bit6toAscii@plt>
mov    %al,(%r15)
mov    %ebx,%edi
call   1030 <bit6toAscii@plt>
mov    %al,0x1(%r15)
movb   $0x3d,0x2(%r15)
jmp    124b <base64enc+0x13b>
mov    %eax,%eax
mov    (%rsi,%rax,4),%ecx
mov    0x4(%rsi,%rax,4),%ebx
mov    %ecx,%edi
sar    $0x2,%edi
shl    $0x4,%ecx
mov    %ebx,%ebp
shr    $0x4,%ebp
or     %ecx,%ebp
and    $0x3f,%ebp
shl    $0x2,%ebx
and    $0x3c,%ebx
call   1030 <bit6toAscii@plt>
mov    %al,(%r15)
mov    %ebp,%edi
call   1030 <bit6toAscii@plt>
mov    %al,0x1(%r15)
mov    %ebx,%edi
call   1030 <bit6toAscii@plt>
mov    %al,0x2(%r15)
movb   $0x3d,0x3(%r15)
add    $0x4,%r15
movb   $0x0,(%r15)
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @base64enc(i8* nocapture writeonly %0, i8* nocapture %1, i32 %2) {
%4 = sdiv i32 %2, 3
%5 = srem i32 %2, 3
%6 = icmp sgt i32 %2, 2
br i1 %6, label %7, label %52
7: ; preds = %3
%8 = bitcast i8* %1 to i32*
%9 = zext i32 %4 to i64
br label %10
10: ; preds = %7, %10
%11 = phi i64 [ 0, %7 ], [ %48, %10 ]
%12 = phi i8* [ %0, %7 ], [ %47, %10 ]
%13 = mul nuw nsw i64 %11, 3
%14 = getelementptr inbounds i32, i32* %8, i64 %13
%15 = load i32, i32* %14
%16 = ashr i32 %15, 2
%17 = shl i32 %15, 4
%18 = add nuw nsw i64 %13, 1
%19 = getelementptr inbounds i32, i32* %8, i64 %18
%20 = load i32, i32* %19
%21 = lshr i32 %20, 4
%22 = or i32 %21, %17
%23 = and i32 %22, 63
%24 = shl i32 %20, 2
%25 = add nuw nsw i64 %13, 2
%26 = getelementptr inbounds i32, i32* %8, i64 %25
%27 = load i32, i32* %26
%28 = lshr i32 %27, 6
%29 = or i32 %28, %24
%30 = and i32 %29, 63
%31 = and i32 %27, 63
%32 = tail call i8* @bit6toAscii(i32 %16)
%33 = ptrtoint i8* %32 to i64
%34 = trunc i64 %33 to i8
%35 = getelementptr inbounds i8, i8* %12, i64 1
store i8 %34, i8* %12
%36 = tail call i8* @bit6toAscii(i32 %23)
%37 = ptrtoint i8* %36 to i64
%38 = trunc i64 %37 to i8
%39 = getelementptr inbounds i8, i8* %12, i64 2
store i8 %38, i8* %35
%40 = tail call i8* @bit6toAscii(i32 %30)
%41 = ptrtoint i8* %40 to i64
%42 = trunc i64 %41 to i8
%43 = getelementptr inbounds i8, i8* %12, i64 3
store i8 %42, i8* %39
%44 = tail call i8* @bit6toAscii(i32 %31)
%45 = ptrtoint i8* %44 to i64
%46 = trunc i64 %45 to i8
%47 = getelementptr inbounds i8, i8* %12, i64 4
store i8 %46, i8* %43
%48 = add nuw nsw i64 %11, 1
%49 = icmp eq i64 %48, %9
br i1 %49, label %50, label %10
50: ; preds = %10
%51 = mul i32 %4, 3
br label %52
52: ; preds = %50, %3
%53 = phi i8* [ %0, %3 ], [ %47, %50 ]
%54 = phi i32 [ 0, %3 ], [ %51, %50 ]
switch i32 %5, label %101 [
i32 2, label %71
i32 1, label %55
]
55: ; preds = %52
%56 = bitcast i8* %1 to i32*
%57 = zext i32 %54 to i64
%58 = getelementptr inbounds i32, i32* %56, i64 %57
%59 = load i32, i32* %58
%60 = ashr i32 %59, 2
%61 = shl i32 %59, 4
%62 = and i32 %61, 48
%63 = tail call i8* @bit6toAscii(i32 %60)
%64 = ptrtoint i8* %63 to i64
%65 = trunc i64 %64 to i8
%66 = getelementptr inbounds i8, i8* %53, i64 1
store i8 %65, i8* %53
%67 = tail call i8* @bit6toAscii(i32 %62)
%68 = ptrtoint i8* %67 to i64
%69 = trunc i64 %68 to i8
%70 = getelementptr inbounds i8, i8* %53, i64 2
store i8 %69, i8* %66
store i8 61, i8* %70
br label %98
71: ; preds = %52
%72 = bitcast i8* %1 to i32*
%73 = zext i32 %54 to i64
%74 = getelementptr inbounds i32, i32* %72, i64 %73
%75 = load i32, i32* %74
%76 = ashr i32 %75, 2
%77 = shl i32 %75, 4
%78 = add nuw nsw i32 %54, 1
%79 = zext i32 %78 to i64
%80 = getelementptr inbounds i32, i32* %72, i64 %79
%81 = load i32, i32* %80
%82 = lshr i32 %81, 4
%83 = or i32 %82, %77
%84 = and i32 %83, 63
%85 = shl i32 %81, 2
%86 = and i32 %85, 60
%87 = tail call i8* @bit6toAscii(i32 %76)
%88 = ptrtoint i8* %87 to i64
%89 = trunc i64 %88 to i8
%90 = getelementptr inbounds i8, i8* %53, i64 1
store i8 %89, i8* %53
%91 = tail call i8* @bit6toAscii(i32 %84)
%92 = ptrtoint i8* %91 to i64
%93 = trunc i64 %92 to i8
%94 = getelementptr inbounds i8, i8* %53, i64 2
store i8 %93, i8* %90
%95 = tail call i8* @bit6toAscii(i32 %86)
%96 = ptrtoint i8* %95 to i64
%97 = trunc i64 %96 to i8
store i8 %97, i8* %94
br label %98
98: ; preds = %55, %71
%99 = getelementptr inbounds i8, i8* %53, i64 3
%100 = getelementptr inbounds i8, i8* %53, i64 4
store i8 61, i8* %99
br label %101
101: ; preds = %98, %52
%102 = phi i8* [ %53, %52 ], [ %100, %98 ]
store i8 0, i8* %102
ret void
}