void set_conversion_array(char *array, int base) {
  char current;
  int i;
  i = 0;
  current = '0';
  while (i < base && current <= '9') {
    array[i] = current;
    current++;
    i++;
  }
  current = 'A';
  while (i < base && current <= 'Z') {
    array[i] = current;
    current++;
    i++;
  }
  current = 'a';
  while (i < base && current <= 'z') {
    array[i] = current;
    current++;
    i++;
  }
}


x86 assembly (clang, -O0):
<set_conversion_array>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movl   $0x0,-0x14(%rbp)
movb   $0x30,-0xd(%rbp)
mov    -0x14(%rbp),%ecx
xor    %eax,%eax
cmp    -0xc(%rbp),%ecx
mov    %al,-0x15(%rbp)
jge    1134 <set_conversion_array+0x34>
movsbl -0xd(%rbp),%eax
cmp    $0x39,%eax
setle  %al
mov    %al,-0x15(%rbp)
mov    -0x15(%rbp),%al
test   $0x1,%al
jne    1144 <set_conversion_array+0x44>
jmp    1168 <set_conversion_array+0x68>
mov    -0xd(%rbp),%dl
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0xd(%rbp),%al
add    $0x1,%al
mov    %al,-0xd(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1116 <set_conversion_array+0x16>
movb   $0x41,-0xd(%rbp)
mov    -0x14(%rbp),%ecx
xor    %eax,%eax
cmp    -0xc(%rbp),%ecx
mov    %al,-0x16(%rbp)
jge    118a <set_conversion_array+0x8a>
movsbl -0xd(%rbp),%eax
cmp    $0x5a,%eax
setle  %al
mov    %al,-0x16(%rbp)
mov    -0x16(%rbp),%al
test   $0x1,%al
jne    119a <set_conversion_array+0x9a>
jmp    11be <set_conversion_array+0xbe>
mov    -0xd(%rbp),%dl
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0xd(%rbp),%al
add    $0x1,%al
mov    %al,-0xd(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    116c <set_conversion_array+0x6c>
movb   $0x61,-0xd(%rbp)
mov    -0x14(%rbp),%ecx
xor    %eax,%eax
cmp    -0xc(%rbp),%ecx
mov    %al,-0x17(%rbp)
jge    11e0 <set_conversion_array+0xe0>
movsbl -0xd(%rbp),%eax
cmp    $0x7a,%eax
setle  %al
mov    %al,-0x17(%rbp)
mov    -0x17(%rbp),%al
test   $0x1,%al
jne    11f0 <set_conversion_array+0xf0>
jmp    1214 <set_conversion_array+0x114>
mov    -0xd(%rbp),%dl
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0xd(%rbp),%al
add    $0x1,%al
mov    %al,-0xd(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11c2 <set_conversion_array+0xc2>
pop    %rbp
ret

x86 assembly (clang, -O2):
<set_conversion_array>:
push   %rbx
test   %esi,%esi
jle    1129 <set_conversion_array+0x29>
lea    -0x1(%rsi),%eax
cmp    $0x9,%eax
mov    $0x9,%ecx
cmovb  %eax,%ecx
lea    0x1(%rcx),%rax
mov    %eax,%r8d
and    $0x3,%r8d
cmp    $0x3,%ecx
jae    112d <set_conversion_array+0x2d>
mov    $0x30,%al
xor    %edx,%edx
jmp    1167 <set_conversion_array+0x67>
xor    %ecx,%ecx
jmp    1190 <set_conversion_array+0x90>
and    $0x1c,%eax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    0x30(%rdx),%ebx
mov    %bl,(%rdi,%rdx,1)
lea    0x31(%rdx),%ebx
mov    %bl,0x1(%rdi,%rdx,1)
lea    0x32(%rdx),%ebx
mov    %bl,0x2(%rdi,%rdx,1)
lea    0x33(%rdx),%ebx
mov    %bl,0x3(%rdi,%rdx,1)
add    $0x4,%rdx
cmp    %rdx,%rax
jne    1140 <set_conversion_array+0x40>
lea    0x30(%rdx),%eax
add    $0x1,%ecx
test   %r8,%r8
je     1190 <set_conversion_array+0x90>
add    %rdi,%rdx
movzbl %al,%r9d
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
lea    (%r9,%rbx,1),%eax
mov    %al,(%rdx,%rbx,1)
add    $0x1,%rbx
cmp    %rbx,%r8
jne    1180 <set_conversion_array+0x80>
movslq %esi,%r10
cmp    %esi,%ecx
jge    12c6 <set_conversion_array+0x1c6>
mov    %ecx,%ecx
mov    %rcx,%rax
not    %rax
add    %r10,%rax
cmp    $0x19,%rax
mov    $0x19,%r8d
cmovb  %rax,%r8
mov    $0x41,%dl
cmp    $0xf,%r8
jb     12b0 <set_conversion_array+0x1b0>
add    $0x1,%r8
mov    %r8d,%edx
and    $0x30,%edx
lea    -0x10(%rdx),%rax
mov    %rax,%r11
shr    $0x4,%r11
add    $0x1,%r11
mov    %r11d,%r9d
and    $0x3,%r9d
cmp    $0x30,%rax
jae    11f2 <set_conversion_array+0xf2>
movdqa 0xe12(%rip),%xmm0
xor    %eax,%eax
jmp    126d <set_conversion_array+0x16d>
and    $0xfffffffffffffffc,%r11
lea    (%rcx,%rdi,1),%rbx
add    $0x30,%rbx
movdqa 0xdfa(%rip),%xmm0
xor    %eax,%eax
movdqa 0xe00(%rip),%xmm1
movdqa 0xe08(%rip),%xmm2
movdqa 0xe10(%rip),%xmm3
movdqa 0xe18(%rip),%xmm4
nopl   0x0(%rax,%rax,1)
movdqu %xmm0,-0x30(%rbx,%rax,1)
movdqa %xmm0,%xmm5
paddb  %xmm1,%xmm5
movdqu %xmm5,-0x20(%rbx,%rax,1)
movdqa %xmm0,%xmm5
paddb  %xmm2,%xmm5
movdqu %xmm5,-0x10(%rbx,%rax,1)
movdqa %xmm0,%xmm5
paddb  %xmm3,%xmm5
movdqu %xmm5,(%rbx,%rax,1)
add    $0x40,%rax
paddb  %xmm4,%xmm0
add    $0xfffffffffffffffc,%r11
jne    1230 <set_conversion_array+0x130>
test   %r9,%r9
je     12a2 <set_conversion_array+0x1a2>
add    %rcx,%rax
add    %rdi,%rax
shl    $0x4,%r9
xor    %ebx,%ebx
movdqa 0xd8a(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
movdqu %xmm0,(%rax,%rbx,1)
paddb  %xmm1,%xmm0
add    $0x10,%rbx
cmp    %rbx,%r9
jne    1290 <set_conversion_array+0x190>
add    %rdx,%rcx
cmp    %rdx,%r8
je     12c6 <set_conversion_array+0x1c6>
or     $0x41,%dl
nopl   (%rax)
mov    %dl,(%rdi,%rcx,1)
add    $0x1,%rcx
cmp    %r10,%rcx
jge    12c6 <set_conversion_array+0x1c6>
lea    0x1(%rdx),%eax
cmp    $0x5a,%dl
mov    %eax,%edx
jb     12b0 <set_conversion_array+0x1b0>
cmp    %esi,%ecx
jge    1416 <set_conversion_array+0x316>
mov    %ecx,%ecx
lea    0x1(%rcx),%rax
cmp    %r10,%rax
cmovle %r10,%rax
mov    %rcx,%rdx
not    %rdx
add    %rax,%rdx
cmp    $0x19,%rdx
mov    $0x19,%r9d
cmovb  %rdx,%r9
mov    $0x61,%al
cmp    $0xf,%r9
jb     13ee <set_conversion_array+0x2ee>
add    $0x1,%r9
mov    %r9d,%r8d
and    $0x30,%r8d
lea    -0x10(%r8),%rax
mov    %rax,%rsi
shr    $0x4,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x30,%rax
jae    132f <set_conversion_array+0x22f>
movdqa 0xd25(%rip),%xmm0
xor    %eax,%eax
jmp    13ad <set_conversion_array+0x2ad>
and    $0xfffffffffffffffc,%rsi
lea    (%rcx,%rdi,1),%rbx
add    $0x30,%rbx
movdqa 0xd0d(%rip),%xmm0
xor    %eax,%eax
movdqa 0xcc3(%rip),%xmm1
movdqa 0xccb(%rip),%xmm2
movdqa 0xcd3(%rip),%xmm3
movdqa 0xcdb(%rip),%xmm4
cs nopw 0x0(%rax,%rax,1)
nop
movdqu %xmm0,-0x30(%rbx,%rax,1)
movdqa %xmm0,%xmm5
paddb  %xmm1,%xmm5
movdqu %xmm5,-0x20(%rbx,%rax,1)
movdqa %xmm0,%xmm5
paddb  %xmm2,%xmm5
movdqu %xmm5,-0x10(%rbx,%rax,1)
movdqa %xmm0,%xmm5
paddb  %xmm3,%xmm5
movdqu %xmm5,(%rbx,%rax,1)
add    $0x40,%rax
paddb  %xmm4,%xmm0
add    $0xfffffffffffffffc,%rsi
jne    1370 <set_conversion_array+0x270>
test   %rdx,%rdx
je     13e2 <set_conversion_array+0x2e2>
add    %rcx,%rax
add    %rdi,%rax
shl    $0x4,%rdx
xor    %esi,%esi
movdqa 0xc4a(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
movdqu %xmm0,(%rax,%rsi,1)
paddb  %xmm1,%xmm0
add    $0x10,%rsi
cmp    %rsi,%rdx
jne    13d0 <set_conversion_array+0x2d0>
cmp    %r8,%r9
je     1416 <set_conversion_array+0x316>
add    %r8,%rcx
lea    0x61(%r8),%eax
add    $0x1,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %al,-0x1(%rdi,%rcx,1)
cmp    %r10,%rcx
jge    1416 <set_conversion_array+0x316>
lea    0x1(%rax),%edx
add    $0x1,%rcx
cmp    $0x7a,%al
mov    %edx,%eax
jb     1400 <set_conversion_array+0x300>
pop    %rbx
ret

LLVM IR (-O0):
define void @set_conversion_array(i8* %0, i32 %1) {
%3 = alloca i8*
%4 = alloca i32
%5 = alloca i8
%6 = alloca i32
store i8* %0, i8** %3
store i32 %1, i32* %4
store i32 0, i32* %6
store i8 48, i8* %5
br label %7
7: ; preds = %17, %2
%8 = load i32, i32* %6
%9 = load i32, i32* %4
%10 = icmp slt i32 %8, %9
br i1 %10, label %11, label %15
11: ; preds = %7
%12 = load i8, i8* %5
%13 = sext i8 %12 to i32
%14 = icmp sle i32 %13, 57
br label %15
15: ; preds = %11, %7
%16 = phi i1 [ false, %7 ], [ %14, %11 ]
br i1 %16, label %17, label %27
17: ; preds = %15
%18 = load i8, i8* %5
%19 = load i8*, i8** %3
%20 = load i32, i32* %6
%21 = sext i32 %20 to i64
%22 = getelementptr inbounds i8, i8* %19, i64 %21
store i8 %18, i8* %22
%23 = load i8, i8* %5
%24 = add i8 %23, 1
store i8 %24, i8* %5
%25 = load i32, i32* %6
%26 = add nsw i32 %25, 1
store i32 %26, i32* %6
br label %7
27: ; preds = %15
store i8 65, i8* %5
br label %28
28: ; preds = %38, %27
%29 = load i32, i32* %6
%30 = load i32, i32* %4
%31 = icmp slt i32 %29, %30
br i1 %31, label %32, label %36
32: ; preds = %28
%33 = load i8, i8* %5
%34 = sext i8 %33 to i32
%35 = icmp sle i32 %34, 90
br label %36
36: ; preds = %32, %28
%37 = phi i1 [ false, %28 ], [ %35, %32 ]
br i1 %37, label %38, label %48
38: ; preds = %36
%39 = load i8, i8* %5
%40 = load i8*, i8** %3
%41 = load i32, i32* %6
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds i8, i8* %40, i64 %42
store i8 %39, i8* %43
%44 = load i8, i8* %5
%45 = add i8 %44, 1
store i8 %45, i8* %5
%46 = load i32, i32* %6
%47 = add nsw i32 %46, 1
store i32 %47, i32* %6
br label %28
48: ; preds = %36
store i8 97, i8* %5
br label %49
49: ; preds = %59, %48
%50 = load i32, i32* %6
%51 = load i32, i32* %4
%52 = icmp slt i32 %50, %51
br i1 %52, label %53, label %57
53: ; preds = %49
%54 = load i8, i8* %5
%55 = sext i8 %54 to i32
%56 = icmp sle i32 %55, 122
br label %57
57: ; preds = %53, %49
%58 = phi i1 [ false, %49 ], [ %56, %53 ]
br i1 %58, label %59, label %69
59: ; preds = %57
%60 = load i8, i8* %5
%61 = load i8*, i8** %3
%62 = load i32, i32* %6
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds i8, i8* %61, i64 %63
store i8 %60, i8* %64
%65 = load i8, i8* %5
%66 = add i8 %65, 1
store i8 %66, i8* %5
%67 = load i32, i32* %6
%68 = add nsw i32 %67, 1
store i32 %68, i32* %6
br label %49
69: ; preds = %57
ret void
}

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