void UT_itoa(int value, char *string, int radix, int out_len) {
  char revertedStr[50];
  int revertedLength = 0;
  unsigned int length = 0;
  unsigned int neg = 0;
  unsigned int digit_value = 0;
  unsigned int uvalue;
  if ((radix == 10) && (value < 0)) {
    neg = 1;
    uvalue = -value;
  } else {
    uvalue = (unsigned int)value;
  }
  revertedLength = 0;
  while (uvalue >= radix) {
    digit_value = uvalue % radix;
    if (digit_value >= 10) {
      revertedStr[revertedLength] = digit_value - 10 + 'a';
    } else {
      revertedStr[revertedLength] = digit_value + '0';
    }
    uvalue /= radix;
    revertedLength++;
  }
  if (uvalue >= 10) {
    revertedStr[revertedLength] = uvalue - 10 + 'a';
  } else {
    revertedStr[revertedLength] = uvalue + '0';
  }
  if (neg == 1) {
    string[length] = '-';
    length++;
  }
  if (revertedLength < out_len - 1) {
    while (revertedLength < out_len - 1) {
      revertedLength++;
      revertedStr[revertedLength] = '0';
    }
  }
  while (revertedLength >= 0) {
    string[length] = revertedStr[revertedLength];
    revertedLength--;
    length++;
  }
  string[length] = '\0';
}


x86 assembly (clang, -O0):
<UT_itoa>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
movl   $0x0,-0x54(%rbp)
movl   $0x0,-0x58(%rbp)
movl   $0x0,-0x5c(%rbp)
movl   $0x0,-0x60(%rbp)
cmpl   $0xa,-0x14(%rbp)
jne    1155 <UT_itoa+0x55>
cmpl   $0x0,-0x4(%rbp)
jge    1155 <UT_itoa+0x55>
movl   $0x1,-0x5c(%rbp)
xor    %eax,%eax
sub    -0x4(%rbp),%eax
mov    %eax,-0x64(%rbp)
jmp    115b <UT_itoa+0x5b>
mov    -0x4(%rbp),%eax
mov    %eax,-0x64(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x14(%rbp),%eax
jb     11c6 <UT_itoa+0xc6>
mov    -0x64(%rbp),%eax
xor    %edx,%edx
divl   -0x14(%rbp)
mov    %edx,-0x60(%rbp)
cmpl   $0xa,-0x60(%rbp)
jb     119b <UT_itoa+0x9b>
mov    -0x60(%rbp),%eax
sub    $0xa,%eax
add    $0x61,%eax
mov    %al,%cl
movslq -0x54(%rbp),%rax
mov    %cl,-0x50(%rbp,%rax,1)
jmp    11ab <UT_itoa+0xab>
mov    -0x60(%rbp),%eax
add    $0x30,%eax
mov    %al,%cl
movslq -0x54(%rbp),%rax
mov    %cl,-0x50(%rbp,%rax,1)
mov    -0x14(%rbp),%ecx
mov    -0x64(%rbp),%eax
xor    %edx,%edx
div    %ecx
mov    %eax,-0x64(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1162 <UT_itoa+0x62>
cmpl   $0xa,-0x64(%rbp)
jb     11e8 <UT_itoa+0xe8>
mov    -0x64(%rbp),%eax
sub    $0xa,%eax
add    $0x61,%eax
mov    %al,%cl
movslq -0x54(%rbp),%rax
mov    %cl,-0x50(%rbp,%rax,1)
jmp    11f8 <UT_itoa+0xf8>
mov    -0x64(%rbp),%eax
add    $0x30,%eax
mov    %al,%cl
movslq -0x54(%rbp),%rax
mov    %cl,-0x50(%rbp,%rax,1)
cmpl   $0x1,-0x5c(%rbp)
jne    1216 <UT_itoa+0x116>
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%ecx
movb   $0x2d,(%rax,%rcx,1)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
mov    -0x54(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1259 <UT_itoa+0x159>
jmp    122c <UT_itoa+0x12c>
mov    -0x54(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1254 <UT_itoa+0x154>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
movslq -0x54(%rbp),%rax
movb   $0x30,-0x50(%rbp,%rax,1)
jmp    122c <UT_itoa+0x12c>
jmp    1259 <UT_itoa+0x159>
jmp    125e <UT_itoa+0x15e>
cmpl   $0x0,-0x54(%rbp)
jl     1291 <UT_itoa+0x191>
movslq -0x54(%rbp),%rax
mov    -0x50(%rbp,%rax,1),%dl
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x54(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x54(%rbp)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    125e <UT_itoa+0x15e>
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%ecx
movb   $0x0,(%rax,%rcx,1)
pop    %rbp
ret

x86 assembly (clang, -O2):
<UT_itoa>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %ecx,%r15d
mov    %rsi,%r12
cmp    $0xa,%edx
sete   %al
test   %edi,%edi
sets   %sil
and    %al,%sil
mov    %edi,%eax
neg    %eax
test   %sil,%sil
cmove  %edi,%eax
xor    %r9d,%r9d
cmp    %edx,%eax
jae    1148 <UT_itoa+0x38>
xor    %ebx,%ebx
jmp    117f <UT_itoa+0x6f>
mov    %edx,%ecx
xor    %ebx,%ebx
mov    $0x57,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %edx,%edx
div    %ecx
cmp    $0xa,%edx
mov    $0x30,%ebp
cmovae %edi,%ebp
add    %dl,%bpl
mov    %bpl,0x10(%rsp,%rbx,1)
add    $0x1,%rbx
cmp    %ecx,%eax
jae    1160 <UT_itoa+0x50>
cmp    $0xa,%eax
mov    $0x57,%ecx
mov    $0x30,%edx
cmovae %ecx,%edx
add    %al,%dl
mov    %ebx,%r13d
mov    %dl,0x10(%rsp,%r13,1)
test   %sil,%sil
je     11a9 <UT_itoa+0x99>
movb   $0x2d,(%r12)
mov    $0x1,%r9d
lea    -0x1(%r15),%ebp
cmp    %ebp,%ebx
jge    1218 <UT_itoa+0x108>
mov    %r9,0x8(%rsp)
lea    0x1(%rbx),%eax
lea    (%rsp,%rax,1),%rdi
add    $0x10,%rdi
mov    %r15d,%r14d
sub    %ebx,%r14d
add    $0xfffffffe,%r14d
lea    0x1(%r14),%rdx
mov    $0x30,%esi
call   1030 <memset@plt>
not    %ebx
add    %r15d,%ebx
and    $0x7,%ebx
je     1200 <UT_itoa+0xf0>
neg    %ebx
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
add    $0xffffffffffffffff,%rax
cmp    %eax,%ebx
jne    11f0 <UT_itoa+0xe0>
sub    %rax,%r13
mov    %r13,%rbx
jmp    1200 <UT_itoa+0xf0>
mov    0x8(%rsp),%r9
cmp    $0x7,%r14d
jb     1218 <UT_itoa+0x108>
mov    %r13,%rbx
xchg   %ax,%ax
add    $0x8,%rbx
cmp    %ebx,%ebp
jg     1210 <UT_itoa+0x100>
mov    %r9d,%eax
test   %ebx,%ebx
js     1397 <UT_itoa+0x287>
mov    %ebx,%r8d
lea    (%rbx,%r9,1),%edx
add    $0x1,%edx
mov    %rdx,%r10
sub    %rax,%r10
cmp    $0x8,%r10
jae    1244 <UT_itoa+0x134>
mov    %r8,%r9
mov    %rax,%rcx
jmp    1369 <UT_itoa+0x259>
cmp    $0x20,%r10
jae    1251 <UT_itoa+0x141>
xor    %edi,%edi
jmp    130c <UT_itoa+0x1fc>
mov    %r10,%rdi
and    $0xffffffffffffffe0,%rdi
lea    0x10(%rsp),%rcx
add    %r8,%rcx
add    $0xfffffffffffffff1,%rcx
xor    %ebx,%ebx
pxor   %xmm0,%xmm0
nopw   0x0(%rax,%rax,1)
mov    %rbx,%rbp
or     %rax,%rbp
movdqu -0x10(%rcx),%xmm1
movdqu (%rcx),%xmm2
movdqa %xmm2,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm3,%xmm2
movdqa %xmm1,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm3,%xmm1
movdqu %xmm2,(%r12,%rbp,1)
movdqu %xmm1,0x10(%r12,%rbp,1)
add    $0x20,%rbx
add    $0xffffffffffffffe0,%rcx
cmp    %rbx,%rdi
jne    1270 <UT_itoa+0x160>
cmp    %rdi,%r10
je     1394 <UT_itoa+0x284>
test   $0x18,%r10b
je     13ab <UT_itoa+0x29b>
mov    %r10,%rbp
and    $0xfffffffffffffff8,%rbp
mov    %r8,%r9
sub    %rbp,%r9
lea    (%rax,%rbp,1),%rcx
sub    %rdi,%r8
lea    (%rsp,%r8,1),%rbx
add    $0x9,%rbx
pxor   %xmm0,%xmm0
nopl   0x0(%rax)
mov    %rdi,%rsi
or     %rax,%rsi
movq   (%rbx),%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movq   %xmm1,(%r12,%rsi,1)
add    $0x8,%rdi
add    $0xfffffffffffffff8,%rbx
cmp    %rdi,%rbp
jne    1330 <UT_itoa+0x220>
cmp    %rbp,%r10
je     1394 <UT_itoa+0x284>
lea    (%rsp,%r9,1),%rax
add    $0x10,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%rax),%ebx
mov    %bl,(%r12,%rcx,1)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
cmp    %rcx,%rdx
jne    1380 <UT_itoa+0x270>
mov    %rdx,%rax
movb   $0x0,(%r12,%rax,1)
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
or     %rdi,%rax
sub    %rdi,%r8
jmp    1239 <UT_itoa+0x129>

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

LLVM IR (-O2):
define void @UT_itoa(i32 %0, i8* nocapture writeonly %1, i32 %2, i32 %3) {
%5 = alloca [50 x i8]
%6 = getelementptr inbounds [50 x i8], [50 x i8]* %5, i64 0, i64 0
%7 = icmp eq i32 %2, 10
%8 = icmp slt i32 %0, 0
%9 = and i1 %8, %7
%10 = sub nsw i32 0, %0
%11 = select i1 %9, i32 %10, i32 %0
%12 = icmp ult i32 %11, %2
br i1 %12, label %27, label %13
13: ; preds = %4, %13
%14 = phi i64 [ %23, %13 ], [ 0, %4 ]
%15 = phi i32 [ %22, %13 ], [ %11, %4 ]
%16 = urem i32 %15, %2
%17 = icmp ugt i32 %16, 9
%18 = trunc i32 %16 to i8
%19 = select i1 %17, i8 87, i8 48
%20 = add i8 %19, %18
%21 = getelementptr inbounds [50 x i8], [50 x i8]* %5, i64 0, i64 %14
store i8 %20, i8* %21
%22 = udiv i32 %15, %2
%23 = add nuw i64 %14, 1
%24 = icmp ult i32 %22, %2
br i1 %24, label %25, label %13
25: ; preds = %13
%26 = trunc i64 %23 to i32
br label %27
27: ; preds = %25, %4
%28 = phi i32 [ 0, %4 ], [ %26, %25 ]
%29 = phi i32 [ %11, %4 ], [ %22, %25 ]
%30 = icmp ugt i32 %29, 9
%31 = trunc i32 %29 to i8
%32 = select i1 %30, i8 87, i8 48
%33 = add i8 %32, %31
%34 = zext i32 %28 to i64
%35 = getelementptr inbounds [50 x i8], [50 x i8]* %5, i64 0, i64 %34
store i8 %33, i8* %35
br i1 %9, label %36, label %37
36: ; preds = %27
store i8 45, i8* %1
br label %37
37: ; preds = %36, %27
%38 = phi i32 [ 1, %36 ], [ 0, %27 ]
%39 = add nsw i32 %3, -1
%40 = icmp slt i32 %28, %39
br i1 %40, label %41, label %74
41: ; preds = %37
%42 = add nsw i32 %28, 1
%43 = zext i32 %42 to i64
%44 = getelementptr [50 x i8], [50 x i8]* %5, i64 0, i64 %43
%45 = add i32 %3, -2
%46 = sub i32 %45, %28
%47 = zext i32 %46 to i64
%48 = add nuw nsw i64 %47, 1
%49 = zext i32 %28 to i64
%50 = xor i32 %28, -1
%51 = add i32 %50, %3
%52 = add i32 %3, -2
%53 = sub i32 %52, %28
%54 = and i32 %51, 7
%55 = icmp eq i32 %54, 0
br i1 %55, label %62, label %56
56: ; preds = %41, %56
%57 = phi i64 [ %59, %56 ], [ %49, %41 ]
%58 = phi i32 [ %60, %56 ], [ 0, %41 ]
%59 = add nuw nsw i64 %57, 1
%60 = add i32 %58, 1
%61 = icmp eq i32 %60, %54
br i1 %61, label %62, label %56
62: ; preds = %56, %41
%63 = phi i64 [ %49, %41 ], [ %59, %56 ]
%64 = phi i64 [ undef, %41 ], [ %59, %56 ]
%65 = icmp ult i32 %53, 7
br i1 %65, label %71, label %66
66: ; preds = %62, %66
%67 = phi i64 [ %68, %66 ], [ %63, %62 ]
%68 = add nuw nsw i64 %67, 8
%69 = trunc i64 %68 to i32
%70 = icmp sgt i32 %39, %69
br i1 %70, label %66, label %71
71: ; preds = %66, %62
%72 = phi i64 [ %64, %62 ], [ %68, %66 ]
%73 = trunc i64 %72 to i32
br label %74
74: ; preds = %71, %37
%75 = phi i32 [ %28, %37 ], [ %73, %71 ]
%76 = icmp sgt i32 %75, -1
%77 = zext i32 %38 to i64
br i1 %76, label %78, label %148
78: ; preds = %74
%79 = zext i32 %75 to i64
%80 = add i32 %75, %38
%81 = add i32 %80, 1
%82 = zext i32 %81 to i64
%83 = sub nsw i64 %82, %77
%84 = icmp ult i64 %83, 8
br i1 %84, label %136, label %85
85: ; preds = %78
%86 = icmp ult i64 %83, 32
br i1 %86, label %115, label %87
87: ; preds = %85
%88 = and i64 %83, -32
br label %89
89: ; preds = %89, %87
%90 = phi i64 [ 0, %87 ], [ %106, %89 ]
%91 = sub i64 %79, %90
%92 = or i64 %90, %77
%93 = getelementptr inbounds [50 x i8], [50 x i8]* %5, i64 0, i64 %91
%94 = getelementptr inbounds i8, i8* %93, i64 -15
%95 = bitcast i8* %94 to <16 x i8>*
%96 = load <16 x i8>, <16 x i8>* %95
%97 = shufflevector <16 x i8> %96, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%98 = getelementptr inbounds i8, i8* %93, i64 -31
%99 = bitcast i8* %98 to <16 x i8>*
%100 = load <16 x i8>, <16 x i8>* %99
%101 = shufflevector <16 x i8> %100, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%102 = getelementptr inbounds i8, i8* %1, i64 %92
%103 = bitcast i8* %102 to <16 x i8>*
store <16 x i8> %97, <16 x i8>* %103
%104 = getelementptr inbounds i8, i8* %102, i64 16
%105 = bitcast i8* %104 to <16 x i8>*
store <16 x i8> %101, <16 x i8>* %105
%106 = add nuw i64 %90, 32
%107 = icmp eq i64 %106, %88
br i1 %107, label %108, label %89
108: ; preds = %89
%109 = icmp eq i64 %83, %88
br i1 %109, label %148, label %110
110: ; preds = %108
%111 = or i64 %88, %77
%112 = sub nsw i64 %79, %88
%113 = and i64 %83, 24
%114 = icmp eq i64 %113, 0
br i1 %114, label %136, label %115
115: ; preds = %85, %110
%116 = phi i64 [ %88, %110 ], [ 0, %85 ]
%117 = sub nsw i64 %82, %77
%118 = and i64 %117, -8
%119 = sub nsw i64 %79, %118
%120 = or i64 %118, %77
br label %121
121: ; preds = %121, %115
%122 = phi i64 [ %116, %115 ], [ %132, %121 ]
%123 = sub i64 %79, %122
%124 = or i64 %122, %77
%125 = getelementptr inbounds [50 x i8], [50 x i8]* %5, i64 0, i64 %123
%126 = getelementptr inbounds i8, i8* %125, i64 -7
%127 = bitcast i8* %126 to <8 x i8>*
%128 = load <8 x i8>, <8 x i8>* %127
%129 = shufflevector <8 x i8> %128, <8 x i8> poison, <8 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%130 = getelementptr inbounds i8, i8* %1, i64 %124
%131 = bitcast i8* %130 to <8 x i8>*
store <8 x i8> %129, <8 x i8>* %131
%132 = add nuw i64 %122, 8
%133 = icmp eq i64 %132, %118
br i1 %133, label %134, label %121
134: ; preds = %121
%135 = icmp eq i64 %117, %118
br i1 %135, label %148, label %136
136: ; preds = %78, %110, %134
%137 = phi i64 [ %79, %78 ], [ %112, %110 ], [ %119, %134 ]
%138 = phi i64 [ %77, %78 ], [ %111, %110 ], [ %120, %134 ]
br label %139
139: ; preds = %136, %139
%140 = phi i64 [ %145, %139 ], [ %137, %136 ]
%141 = phi i64 [ %146, %139 ], [ %138, %136 ]
%142 = getelementptr inbounds [50 x i8], [50 x i8]* %5, i64 0, i64 %140
%143 = load i8, i8* %142
%144 = getelementptr inbounds i8, i8* %1, i64 %141
store i8 %143, i8* %144
%145 = add nsw i64 %140, -1
%146 = add nuw nsw i64 %141, 1
%147 = icmp eq i64 %146, %82
br i1 %147, label %148, label %139
148: ; preds = %139, %108, %134, %74
%149 = phi i64 [ %77, %74 ], [ %82, %134 ], [ %82, %108 ], [ %82, %139 ]
%150 = getelementptr inbounds i8, i8* %1, i64 %149
store i8 0, i8* %150
ret void
}