void itoaz(const int n, char *s, const unsigned int b) {
  int i = 0, l, r, k, j, index = 0, sign = 0;
  char p[9] = {0};
  if (n < 0) {
    l = -n;
    sign = 1;
  } else {
    l = n;
  }
  while (1) {
    r = l % b;
    l = l / b;
    if ((r >= 0) && (r <= 9)) {
      p[i] = '0' + r;
    } else if (r > 9) {
      p[i] = 'A' + r - 10;
    }
    ++i;
    if (l <= 0)
      break;
  }
  if (sign == 1) {
    s[index] = '-';
    ++index;
  }
  for (k = i, j = index; k > 0; --k, ++j) {
    s[j] = p[k - 1];
  }
  s[j] = '\0';
}


x86 assembly (clang, -O0):
<itoaz>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
lea    -0x39(%rbp),%rdi
xor    %esi,%esi
mov    $0x9,%edx
call   1030 <memset@plt>
cmpl   $0x0,-0x4(%rbp)
jge    1165 <itoaz+0x55>
xor    %eax,%eax
sub    -0x4(%rbp),%eax
mov    %eax,-0x1c(%rbp)
movl   $0x1,-0x30(%rbp)
jmp    116b <itoaz+0x5b>
mov    -0x4(%rbp),%eax
mov    %eax,-0x1c(%rbp)
jmp    1170 <itoaz+0x60>
mov    -0x1c(%rbp),%eax
xor    %edx,%edx
divl   -0x14(%rbp)
mov    %edx,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
xor    %edx,%edx
divl   -0x14(%rbp)
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x20(%rbp)
jl     11af <itoaz+0x9f>
cmpl   $0x9,-0x20(%rbp)
jg     11af <itoaz+0x9f>
mov    -0x20(%rbp),%eax
add    $0x30,%eax
mov    %al,%cl
movslq -0x18(%rbp),%rax
mov    %cl,-0x39(%rbp,%rax,1)
jmp    11d1 <itoaz+0xc1>
cmpl   $0x9,-0x20(%rbp)
jle    11cc <itoaz+0xbc>
mov    -0x20(%rbp),%eax
add    $0x41,%eax
sub    $0xa,%eax
mov    %al,%cl
movslq -0x18(%rbp),%rax
mov    %cl,-0x39(%rbp,%rax,1)
jmp    11d1 <itoaz+0xc1>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jg     11e9 <itoaz+0xd9>
jmp    11ee <itoaz+0xde>
jmp    1170 <itoaz+0x60>
cmpl   $0x1,-0x30(%rbp)
jne    120d <itoaz+0xfd>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movb   $0x2d,(%rax,%rcx,1)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x0,-0x24(%rbp)
jle    1251 <itoaz+0x141>
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0x39(%rbp,%rax,1),%dl
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1219 <itoaz+0x109>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<itoaz>:
push   %r15
push   %r14
push   %r12
push   %rbx
mov    %edx,%r8d
movb   $0x0,-0x8(%rsp)
movq   $0x0,-0x10(%rsp)
mov    %edi,%eax
neg    %eax
cmovs  %edi,%eax
xor    %r9d,%r9d
mov    $0xffffffffffffffff,%rcx
jmp    1142 <itoaz+0x42>
nopl   0x0(%rax,%rax,1)
add    %bl,%dl
mov    %dl,-0xf(%rsp,%rcx,1)
add    $0x1,%r9d
add    $0x1,%rcx
test   %eax,%eax
jle    1154 <itoaz+0x54>
xor    %edx,%edx
div    %r8d
mov    $0x30,%bl
cmp    $0xa,%edx
jb     1130 <itoaz+0x30>
mov    $0x37,%bl
jge    1130 <itoaz+0x30>
jmp    1136 <itoaz+0x36>
lea    0x1(%rcx),%rax
xor    %edx,%edx
test   %edi,%edi
jns    1166 <itoaz+0x66>
movb   $0x2d,(%rsi)
mov    $0x1,%edx
mov    %edx,%r11d
mov    %eax,%eax
test   %r9d,%r9d
mov    $0x1,%edi
cmovle %r9d,%edi
sub    %edi,%edx
lea    (%r9,%rdx,1),%r8d
add    $0x1,%r8d
mov    %r8,%r10
sub    %r11,%r10
cmp    $0x8,%r10
jae    125b <itoaz+0x15b>
mov    %r11,%rdi
mov    %r8d,%edx
sub    %edi,%edx
mov    %rdi,%rcx
not    %rcx
add    %r8,%rcx
test   $0x3,%dl
je     11e8 <itoaz+0xe8>
lea    0x1(%r9),%edx
mov    %r11d,%ebx
sub    %dil,%bl
add    %bl,%dl
test   %r9d,%r9d
mov    $0x1,%ebx
cmovle %r9d,%ebx
sub    %bl,%dl
movzbl %dl,%edx
and    $0x3,%edx
nopw   0x0(%rax,%rax,1)
add    $0xffffffffffffffff,%rax
mov    %eax,%ebx
movzbl -0x10(%rsp,%rbx,1),%ebx
mov    %bl,(%rsi,%rdi,1)
add    $0x1,%rdi
add    $0xffffffffffffffff,%rdx
jne    11d0 <itoaz+0xd0>
cmp    $0x3,%rcx
jb     124e <itoaz+0x14e>
mov    $0xfffffffe,%r10d
test   %r9d,%r9d
mov    $0x1,%edx
cmovle %r9d,%edx
sub    %edx,%r11d
lea    (%r11,%r9,1),%edx
add    $0x1,%edx
nopw   0x0(%rax,%rax,1)
lea    (%rax,%r10,1),%rbx
lea    0x1(%rbx),%ecx
movzbl -0x10(%rsp,%rcx,1),%ecx
mov    %cl,(%rsi,%rdi,1)
mov    %ebx,%ecx
movzbl -0x10(%rsp,%rcx,1),%ecx
mov    %cl,0x1(%rsi,%rdi,1)
add    $0xffffffff,%ebx
movzbl -0x10(%rsp,%rbx,1),%ecx
mov    %cl,0x2(%rsi,%rdi,1)
add    $0xfffffffffffffffc,%rax
mov    %eax,%ecx
movzbl -0x10(%rsp,%rcx,1),%ecx
mov    %cl,0x3(%rsi,%rdi,1)
add    $0x4,%rdi
cmp    %rdi,%rdx
jne    1210 <itoaz+0x110>
movb   $0x0,(%rsi,%r8,1)
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret
mov    %r11,%rdx
not    %rdx
lea    (%rdx,%r8,1),%rdi
cmp    %edi,%ecx
jb     1191 <itoaz+0x91>
shr    $0x20,%rdi
jne    1191 <itoaz+0x91>
cmp    $0x20,%r10
jae    1285 <itoaz+0x185>
xor    %r15d,%r15d
jmp    1361 <itoaz+0x261>
mov    %r10,%r15
and    $0xffffffffffffffe0,%r15
test   %r9d,%r9d
mov    $0x1,%edi
cmovle %r9d,%edi
mov    %r11d,%ebx
sub    %edi,%ebx
lea    (%rbx,%r9,1),%edi
add    $0x1,%edi
lea    (%rdx,%rdi,1),%r14
add    $0x1,%r14
and    $0xffffffffffffffe0,%r14
xor    %ebx,%ebx
pxor   %xmm0,%xmm0
mov    %rcx,%rdi
nopl   0x0(%rax)
mov    %rbx,%r12
or     %r11,%r12
mov    %edi,%edx
movdqu -0x2f(%rsp,%rdx,1),%xmm1
movdqu -0x1f(%rsp,%rdx,1),%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,(%rsi,%r12,1)
movdqu %xmm1,0x10(%rsi,%r12,1)
add    $0x20,%rbx
add    $0xffffffffffffffe0,%rdi
cmp    %rbx,%r14
jne    12c0 <itoaz+0x1c0>
cmp    %r15,%r10
je     124e <itoaz+0x14e>
test   $0x18,%r10b
je     13e5 <itoaz+0x2e5>
mov    %r10,%r14
and    $0xfffffffffffffff8,%r14
sub    %r14,%rax
lea    (%r14,%r11,1),%rdi
sub    %r15,%rcx
test   %r9d,%r9d
mov    $0x1,%edx
cmovle %r9d,%edx
mov    %r11d,%ebx
sub    %edx,%ebx
lea    (%rbx,%r9,1),%r12d
add    $0x1,%r12d
sub    %r11,%r12
and    $0xfffffffffffffff8,%r12
pxor   %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
mov    %r15,%rdx
or     %r11,%rdx
mov    %ecx,%ebx
movq   -0x17(%rsp,%rbx,1),%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,%r15
add    $0xfffffffffffffff8,%rcx
cmp    %r15,%r12
jne    13a0 <itoaz+0x2a0>
cmp    %r14,%r10
jne    1194 <itoaz+0x94>
jmp    124e <itoaz+0x14e>
sub    %r15,%rax
or     %r11,%r15
mov    %r15,%rdi
jmp    1194 <itoaz+0x94>

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

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