#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 */

/* Variables and functions */
scalar_t__ malloc(int);
char *myitoa(int zahl, int base) {
  int i = 0, k;
  char reverse[64];
  if (zahl == 0) {
    char *zero = (char *)malloc(sizeof(char) * 2);
    zero[0] = '0';
    zero[1] = '\0';
    return zero;
  }
  while (zahl > 0) {
    switch (zahl % base) {
    case 0:
      reverse[i] = '0';
      break;
    case 1:
      reverse[i] = '1';
      break;
    case 2:
      reverse[i] = '2';
      break;
    case 3:
      reverse[i] = '3';
      break;
    case 4:
      reverse[i] = '4';
      break;
    case 5:
      reverse[i] = '5';
      break;
    case 6:
      reverse[i] = '6';
      break;
    case 7:
      reverse[i] = '7';
      break;
    case 8:
      reverse[i] = '8';
      break;
    case 9:
      reverse[i] = '9';
      break;
    case 10:
      reverse[i] = 'A';
      break;
    case 11:
      reverse[i] = 'B';
      break;
    case 12:
      reverse[i] = 'C';
      break;
    case 13:
      reverse[i] = 'D';
      break;
    case 14:
      reverse[i] = 'E';
      break;
    case 15:
      reverse[i] = 'F';
      break;
    case 16:
      reverse[i] = 'G';
      break;
    default:
      reverse[i] = 'x';
    }
    i++;
    zahl /= base;
  }
  i--;
  char *string = (char *)malloc(sizeof(char) * (i + 2));
  for (k = i; k >= 0; k--) {
    string[i - k] = reverse[k];
  }
  string[i + 1] = '\0';
  return string;
}


x86 assembly (clang, -O0):
<myitoa>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %edi,-0xc(%rbp)
mov    %esi,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
cmpl   $0x0,-0xc(%rbp)
jne    115c <myitoa+0x4c>
mov    $0x2,%edi
call   1030 <malloc@plt>
mov    %rax,-0x68(%rbp)
mov    -0x68(%rbp),%rax
movb   $0x30,(%rax)
mov    -0x68(%rbp),%rax
movb   $0x0,0x1(%rax)
mov    -0x68(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    1317 <myitoa+0x207>
jmp    1161 <myitoa+0x51>
cmpl   $0x0,-0xc(%rbp)
jle    12a8 <myitoa+0x198>
mov    -0xc(%rbp),%eax
mov    -0x10(%rbp),%ecx
cltd
idiv   %ecx
mov    %edx,%eax
mov    %rax,-0x78(%rbp)
sub    $0x10,%edx
ja     1285 <myitoa+0x175>
mov    -0x78(%rbp),%rax
lea    0xe72(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movslq -0x14(%rbp),%rax
movb   $0x30,-0x60(%rbp,%rax,1)
jmp    128e <myitoa+0x17e>
movslq -0x14(%rbp),%rax
movb   $0x31,-0x60(%rbp,%rax,1)
jmp    128e <myitoa+0x17e>
movslq -0x14(%rbp),%rax
movb   $0x32,-0x60(%rbp,%rax,1)
jmp    128e <myitoa+0x17e>
movslq -0x14(%rbp),%rax
movb   $0x33,-0x60(%rbp,%rax,1)
jmp    128e <myitoa+0x17e>
movslq -0x14(%rbp),%rax
movb   $0x34,-0x60(%rbp,%rax,1)
jmp    128e <myitoa+0x17e>
movslq -0x14(%rbp),%rax
movb   $0x35,-0x60(%rbp,%rax,1)
jmp    128e <myitoa+0x17e>
movslq -0x14(%rbp),%rax
movb   $0x36,-0x60(%rbp,%rax,1)
jmp    128e <myitoa+0x17e>
movslq -0x14(%rbp),%rax
movb   $0x37,-0x60(%rbp,%rax,1)
jmp    128e <myitoa+0x17e>
movslq -0x14(%rbp),%rax
movb   $0x38,-0x60(%rbp,%rax,1)
jmp    128e <myitoa+0x17e>
movslq -0x14(%rbp),%rax
movb   $0x39,-0x60(%rbp,%rax,1)
jmp    128e <myitoa+0x17e>
movslq -0x14(%rbp),%rax
movb   $0x41,-0x60(%rbp,%rax,1)
jmp    128e <myitoa+0x17e>
movslq -0x14(%rbp),%rax
movb   $0x42,-0x60(%rbp,%rax,1)
jmp    128e <myitoa+0x17e>
movslq -0x14(%rbp),%rax
movb   $0x43,-0x60(%rbp,%rax,1)
jmp    128e <myitoa+0x17e>
movslq -0x14(%rbp),%rax
movb   $0x44,-0x60(%rbp,%rax,1)
jmp    128e <myitoa+0x17e>
movslq -0x14(%rbp),%rax
movb   $0x45,-0x60(%rbp,%rax,1)
jmp    128e <myitoa+0x17e>
movslq -0x14(%rbp),%rax
movb   $0x46,-0x60(%rbp,%rax,1)
jmp    128e <myitoa+0x17e>
movslq -0x14(%rbp),%rax
movb   $0x47,-0x60(%rbp,%rax,1)
jmp    128e <myitoa+0x17e>
movslq -0x14(%rbp),%rax
movb   $0x78,-0x60(%rbp,%rax,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%ecx
mov    -0xc(%rbp),%eax
cltd
idiv   %ecx
mov    %eax,-0xc(%rbp)
jmp    1161 <myitoa+0x51>
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
add    $0x2,%eax
cltq
shl    $0x0,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,-0x70(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x18(%rbp)
cmpl   $0x0,-0x18(%rbp)
jl     12fe <myitoa+0x1ee>
movslq -0x18(%rbp),%rax
mov    -0x60(%rbp,%rax,1),%dl
mov    -0x70(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    -0x18(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
jmp    12ce <myitoa+0x1be>
mov    -0x70(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x70(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<myitoa>:
push   %rbx
sub    $0x40,%rsp
test   %edi,%edi
je     116e <myitoa+0x5e>
jle    1187 <myitoa+0x77>
mov    %edi,%eax
xor    %ebx,%ebx
lea    0xeda(%rip),%rdi
jmp    113b <myitoa+0x2b>
nopl   0x0(%rax,%rax,1)
mov    %cl,(%rsp,%rbx,1)
add    $0x1,%rbx
test   %eax,%eax
jle    114e <myitoa+0x3e>
cltd
idiv   %esi
mov    $0x78,%cl
cmp    $0x10,%edx
ja     1130 <myitoa+0x20>
movslq %edx,%rcx
movzbl (%rcx,%rdi,1),%ecx
jmp    1130 <myitoa+0x20>
lea    0x1(%rbx),%edi
call   1030 <malloc@plt>
test   %ebx,%ebx
jle    1306 <myitoa+0x1f6>
mov    %ebx,%edx
cmp    $0x8,%rdx
jae    1198 <myitoa+0x88>
mov    %rdx,%r11
jmp    12d2 <myitoa+0x1c2>
mov    $0x2,%edi
call   1030 <malloc@plt>
movb   $0x30,(%rax)
mov    %rax,%rcx
add    $0x1,%rcx
jmp    130b <myitoa+0x1fb>
mov    $0x1,%edi
call   1030 <malloc@plt>
xor    %ebx,%ebx
jmp    1306 <myitoa+0x1f6>
lea    -0x1(%rbx),%r8
cmp    $0x20,%edx
jae    11a8 <myitoa+0x98>
xor    %edx,%edx
jmp    126e <myitoa+0x15e>
mov    %ebx,%r9d
mov    %ebx,%r11d
and    $0x1f,%r11d
sub    %r11,%rdx
lea    (%rsp,%r9,1),%rsi
add    $0xfffffffffffffff0,%rsi
mov    %r8d,%edi
sub    %r9,%rdi
lea    (%rax,%rdi,1),%r10
add    $0x11,%r10
sub    %r11,%r9
xor    %edi,%edi
pxor   %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqu -0x10(%rsi),%xmm1
movdqu (%rsi),%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,-0x10(%r10,%rdi,1)
movdqu %xmm1,(%r10,%rdi,1)
add    $0x20,%rdi
add    $0xffffffffffffffe0,%rsi
cmp    %rdi,%r9
jne    11e0 <myitoa+0xd0>
test   %r11,%r11
je     1306 <myitoa+0x1f6>
cmp    $0x8,%r11d
jb     12d2 <myitoa+0x1c2>
mov    %ebx,%r9d
mov    %ebx,%r11d
and    $0x7,%r11d
mov    %rdx,%rsi
neg    %rsi
add    %rsp,%rsi
lea    (%r9,%rsi,1),%rdi
add    $0xfffffffffffffff8,%rdi
mov    %r8d,%esi
sub    %r9,%rsi
add    %rax,%rsi
add    $0x1,%rsi
sub    %r11,%r9
pxor   %xmm0,%xmm0
nopl   (%rax)
movq   (%rdi),%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movq   %xmm1,(%rsi,%rdx,1)
add    $0x8,%rdx
add    $0xfffffffffffffff8,%rdi
cmp    %rdx,%r9
jne    12a0 <myitoa+0x190>
test   %r11,%r11
je     1306 <myitoa+0x1f6>
mov    %rax,%rdx
sub    %r11,%rdx
add    $0x1,%r11
lea    -0x1(%rbx),%esi
add    %rsi,%rdx
add    $0x1,%rdx
cs nopw 0x0(%rax,%rax,1)
movzbl -0x2(%rsp,%r11,1),%ecx
mov    %cl,(%rdx)
add    $0xffffffffffffffff,%r11
add    $0x1,%rdx
cmp    $0x1,%r11
ja     12f0 <myitoa+0x1e0>
mov    %ebx,%ecx
add    %rax,%rcx
movb   $0x0,(%rcx)
add    $0x40,%rsp
pop    %rbx
ret

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

LLVM IR (-O2):
@switch.table.myitoa = [17 x i8] c"0123456789ABCDEFG"
define i8* @myitoa(i32 %0, i32 %1) {
%3 = alloca [64 x i8]
%4 = getelementptr inbounds [64 x i8], [64 x i8]* %3, i64 0, i64 0
%5 = icmp eq i32 %0, 0
br i1 %5, label %11, label %6
6: ; preds = %2
%7 = icmp sgt i32 %0, 0
br i1 %7, label %15, label %8
8: ; preds = %6
%9 = tail call i64 @malloc(i32 1)
%10 = inttoptr i64 %9 to i8*
br label %99
11: ; preds = %2
%12 = tail call i64 @malloc(i32 2)
%13 = inttoptr i64 %12 to i8*
store i8 48, i8* %13
%14 = getelementptr inbounds i8, i8* %13, i64 1
br label %104
15: ; preds = %6, %25
%16 = phi i64 [ %28, %25 ], [ 0, %6 ]
%17 = phi i32 [ %19, %25 ], [ %0, %6 ]
%18 = srem i32 %17, %1
%19 = sdiv i32 %17, %1
%20 = icmp ult i32 %18, 17
br i1 %20, label %21, label %25
21: ; preds = %15
%22 = sext i32 %18 to i64
%23 = getelementptr inbounds [17 x i8], [17 x i8]* @switch.table.myitoa, i64 0, i64 %22
%24 = load i8, i8* %23
br label %25
25: ; preds = %15, %21
%26 = phi i8 [ %24, %21 ], [ 120, %15 ]
%27 = getelementptr inbounds [64 x i8], [64 x i8]* %3, i64 0, i64 %16
store i8 %26, i8* %27
%28 = add nuw i64 %16, 1
%29 = icmp sgt i32 %19, 0
br i1 %29, label %15, label %30
30: ; preds = %25
%31 = trunc i64 %28 to i32
%32 = add nuw nsw i32 %31, 1
%33 = tail call i64 @malloc(i32 %32)
%34 = inttoptr i64 %33 to i8*
%35 = icmp sgt i32 %31, 0
br i1 %35, label %36, label %99
36: ; preds = %30
%37 = and i64 %28, 4294967295
%38 = and i64 %16, 4294967295
%39 = icmp ult i64 %37, 8
br i1 %39, label %89, label %40
40: ; preds = %36
%41 = icmp ult i64 %37, 32
br i1 %41, label %69, label %42
42: ; preds = %40
%43 = and i64 %28, 31
%44 = sub nsw i64 %37, %43
br label %45
45: ; preds = %45, %42
%46 = phi i64 [ 0, %42 ], [ %63, %45 ]
%47 = xor i64 %46, -1
%48 = add i64 %37, %47
%49 = getelementptr inbounds [64 x i8], [64 x i8]* %3, i64 0, i64 %48
%50 = getelementptr inbounds i8, i8* %49, i64 -15
%51 = bitcast i8* %50 to <16 x i8>*
%52 = load <16 x i8>, <16 x i8>* %51
%53 = shufflevector <16 x i8> %52, <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>
%54 = getelementptr inbounds i8, i8* %49, i64 -31
%55 = bitcast i8* %54 to <16 x i8>*
%56 = load <16 x i8>, <16 x i8>* %55
%57 = shufflevector <16 x i8> %56, <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>
%58 = sub nuw nsw i64 %38, %48
%59 = getelementptr inbounds i8, i8* %34, i64 %58
%60 = bitcast i8* %59 to <16 x i8>*
store <16 x i8> %53, <16 x i8>* %60
%61 = getelementptr inbounds i8, i8* %59, i64 16
%62 = bitcast i8* %61 to <16 x i8>*
store <16 x i8> %57, <16 x i8>* %62
%63 = add nuw i64 %46, 32
%64 = icmp eq i64 %63, %44
br i1 %64, label %65, label %45
65: ; preds = %45
%66 = icmp eq i64 %43, 0
br i1 %66, label %99, label %67
67: ; preds = %65
%68 = icmp ult i64 %43, 8
br i1 %68, label %89, label %69
69: ; preds = %40, %67
%70 = phi i64 [ %44, %67 ], [ 0, %40 ]
%71 = and i64 %28, 7
%72 = sub nsw i64 %37, %71
br label %73
73: ; preds = %73, %69
%74 = phi i64 [ %70, %69 ], [ %85, %73 ]
%75 = xor i64 %74, -1
%76 = add i64 %37, %75
%77 = getelementptr inbounds [64 x i8], [64 x i8]* %3, i64 0, i64 %76
%78 = getelementptr inbounds i8, i8* %77, i64 -7
%79 = bitcast i8* %78 to <8 x i8>*
%80 = load <8 x i8>, <8 x i8>* %79
%81 = shufflevector <8 x i8> %80, <8 x i8> poison, <8 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%82 = sub nuw nsw i64 %38, %76
%83 = getelementptr inbounds i8, i8* %34, i64 %82
%84 = bitcast i8* %83 to <8 x i8>*
store <8 x i8> %81, <8 x i8>* %84
%85 = add nuw i64 %74, 8
%86 = icmp eq i64 %85, %72
br i1 %86, label %87, label %73
87: ; preds = %73
%88 = icmp eq i64 %71, 0
br i1 %88, label %99, label %89
89: ; preds = %36, %67, %87
%90 = phi i64 [ %37, %36 ], [ %43, %67 ], [ %71, %87 ]
br label %91
91: ; preds = %89, %91
%92 = phi i64 [ %93, %91 ], [ %90, %89 ]
%93 = add nsw i64 %92, -1
%94 = getelementptr inbounds [64 x i8], [64 x i8]* %3, i64 0, i64 %93
%95 = load i8, i8* %94
%96 = sub nuw nsw i64 %38, %93
%97 = getelementptr inbounds i8, i8* %34, i64 %96
store i8 %95, i8* %97
%98 = icmp ugt i64 %92, 1
br i1 %98, label %91, label %99
99: ; preds = %91, %65, %87, %8, %30
%100 = phi i8* [ %10, %8 ], [ %34, %30 ], [ %34, %87 ], [ %34, %65 ], [ %34, %91 ]
%101 = phi i64 [ 0, %8 ], [ %28, %30 ], [ %28, %87 ], [ %28, %65 ], [ %28, %91 ]
%102 = and i64 %101, 4294967295
%103 = getelementptr inbounds i8, i8* %100, i64 %102
br label %104
104: ; preds = %99, %11
%105 = phi i8* [ %103, %99 ], [ %14, %11 ]
%106 = phi i8* [ %100, %99 ], [ %13, %11 ]
store i8 0, i8* %105
ret i8* %106
}