void safe_ltos(char *s, char **bufc, long num) {
  char buf[20], *p, *tp, *endp;
  unsigned long anum;
  p = buf;
  tp = *bufc;
  anum = (num < 0) ? -num : num;
  while (anum > 9) {
    *p++ = '0' + (anum % 10);
    anum /= 10;
  }
  if (tp > s + 8192 - 21) {
    endp = s + 8192 - 1;
    if (num < 0 && (tp < endp)) {
      *tp++ = '-';
    }
    if (tp < endp) {
      *tp++ = '0' + (char)anum;
    }
    while ((p-- > buf) && (tp < endp)) {
      *tp++ = *p;
    }
  } else {
    if (num < 0) {
      *tp++ = '-';
    }
    *tp++ = '0' + (char)anum;
    while (p-- > buf) {
      *tp++ = *p;
    }
  }
  *tp = '\0';
  *bufc = tp;
}


x86 assembly (clang, -O0):
<safe_ltos>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
lea    -0x30(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x40(%rbp)
cmpq   $0x0,-0x18(%rbp)
jge    113d <safe_ltos+0x3d>
xor    %eax,%eax
sub    -0x18(%rbp),%rax
mov    %rax,-0x58(%rbp)
jmp    1145 <safe_ltos+0x45>
mov    -0x18(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rax
mov    %rax,-0x50(%rbp)
cmpq   $0x9,-0x50(%rbp)
jbe    1194 <safe_ltos+0x94>
mov    -0x50(%rbp),%rax
mov    $0xa,%ecx
xor    %edx,%edx
div    %rcx
add    $0x30,%rdx
mov    %dl,%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x50(%rbp),%rax
mov    $0xa,%ecx
xor    %edx,%edx
div    %rcx
mov    %rax,-0x50(%rbp)
jmp    114d <safe_ltos+0x4d>
mov    -0x40(%rbp),%rax
mov    -0x8(%rbp),%rcx
add    $0x2000,%rcx
add    $0xffffffffffffffeb,%rcx
cmp    %rcx,%rax
jbe    127d <safe_ltos+0x17d>
mov    -0x8(%rbp),%rax
add    $0x2000,%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x48(%rbp)
cmpq   $0x0,-0x18(%rbp)
jge    11ed <safe_ltos+0xed>
mov    -0x40(%rbp),%rax
cmp    -0x48(%rbp),%rax
jae    11ed <safe_ltos+0xed>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
movb   $0x2d,(%rax)
mov    -0x40(%rbp),%rax
cmp    -0x48(%rbp),%rax
jae    1218 <safe_ltos+0x118>
mov    -0x50(%rbp),%rax
movsbl %al,%eax
add    $0x30,%eax
mov    %al,%cl
mov    -0x40(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x40(%rbp)
mov    %cl,(%rax)
jmp    121d <safe_ltos+0x11d>
mov    -0x38(%rbp),%rcx
mov    %rcx,%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x38(%rbp)
lea    -0x30(%rbp),%rdx
xor    %eax,%eax
cmp    %rdx,%rcx
mov    %al,-0x59(%rbp)
jbe    124c <safe_ltos+0x14c>
mov    -0x40(%rbp),%rax
cmp    -0x48(%rbp),%rax
setb   %al
mov    %al,-0x59(%rbp)
mov    -0x59(%rbp),%al
test   $0x1,%al
jne    125c <safe_ltos+0x15c>
jmp    1278 <safe_ltos+0x178>
mov    -0x38(%rbp),%rax
mov    (%rax),%cl
mov    -0x40(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x40(%rbp)
mov    %cl,(%rax)
jmp    121d <safe_ltos+0x11d>
jmp    12f4 <safe_ltos+0x1f4>
cmpq   $0x0,-0x18(%rbp)
jge    129a <safe_ltos+0x19a>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
movb   $0x2d,(%rax)
mov    -0x50(%rbp),%rax
movsbl %al,%eax
add    $0x30,%eax
mov    %al,%cl
mov    -0x40(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x40(%rbp)
mov    %cl,(%rax)
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x38(%rbp)
lea    -0x30(%rbp),%rcx
cmp    %rcx,%rax
jbe    12ef <safe_ltos+0x1ef>
mov    -0x38(%rbp),%rax
mov    (%rax),%cl
mov    -0x40(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x40(%rbp)
mov    %cl,(%rax)
jmp    12b7 <safe_ltos+0x1b7>
jmp    12f4 <safe_ltos+0x1f4>
mov    -0x40(%rbp),%rax
movb   $0x0,(%rax)
mov    -0x40(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<safe_ltos>:
push   %r14
push   %rbx
mov    %rdx,%r8
mov    (%rsi),%r9
neg    %rdx
cmovs  %r8,%rdx
lea    -0x18(%rsp),%r10
cmp    $0xa,%rdx
jb     1157 <safe_ltos+0x57>
movabs $0xcccccccccccccccd,%r11
cc cc cc
mov    %rdx,%rcx
nopl   0x0(%rax,%rax,1)
mov    %rcx,%rax
mul    %r11
shr    $0x3,%rdx
lea    (%rdx,%rdx,1),%eax
lea    (%rax,%rax,4),%eax
mov    %ecx,%ebx
sub    %eax,%ebx
or     $0x30,%bl
mov    %bl,(%r10)
add    $0x1,%r10
cmp    $0x63,%rcx
mov    %rdx,%rcx
ja     1130 <safe_ltos+0x30>
lea    0x1feb(%rdi),%rax
cmp    %rax,%r9
jbe    1240 <safe_ltos+0x140>
lea    0x1fff(%rdi),%rcx
test   %r8,%r8
jns    1180 <safe_ltos+0x80>
cmp    %rcx,%r9
jae    1180 <safe_ltos+0x80>
movb   $0x2d,(%r9)
add    $0x1,%r9
cmp    %rcx,%r9
jae    118f <safe_ltos+0x8f>
add    $0x30,%dl
mov    %dl,(%r9)
add    $0x1,%r9
lea    -0x18(%rsp),%r14
cmp    %r14,%r10
jbe    1276 <safe_ltos+0x176>
cmp    %rcx,%r9
jae    1276 <safe_ltos+0x176>
mov    %r14,%rax
not    %rax
add    %r10,%rax
sub    %r9,%rdi
add    $0x1ffe,%rdi
cmp    %rax,%rdi
mov    %rax,%rdx
cmovb  %rdi,%rdx
add    $0x1,%rdx
test   %rax,%rax
mov    $0x1,%r8d
cmovne %rdx,%r8
cmp    $0x20,%r8
jb     1208 <safe_ltos+0x108>
cmp    %rax,%rdi
cmovae %rax,%rdi
test   %rax,%rax
cmove  %rax,%rdi
cmp    %r10,%r9
jae    12a0 <safe_ltos+0x1a0>
lea    (%rdi,%r9,1),%rax
add    $0x1,%rax
not    %rdi
add    %r10,%rdi
cmp    %rax,%rdi
jae    12a0 <safe_ltos+0x1a0>
mov    %r10,%rdi
mov    %r9,%rax
add    $0xffffffffffffffff,%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl (%rdi),%edx
mov    %dl,(%rax)
add    $0x1,%rax
cmp    %r14,%rdi
jbe    1433 <safe_ltos+0x333>
add    $0xffffffffffffffff,%rdi
cmp    %rcx,%rax
jb     1220 <safe_ltos+0x120>
jmp    1433 <safe_ltos+0x333>
test   %r8,%r8
jns    124d <safe_ltos+0x14d>
movb   $0x2d,(%r9)
add    $0x1,%r9
add    $0x30,%dl
mov    %dl,(%r9)
lea    0x1(%r9),%rax
lea    -0x18(%rsp),%rcx
mov    %r10,%r11
sub    %rcx,%r11
jbe    1433 <safe_ltos+0x333>
cmp    $0x20,%r11
jae    127e <safe_ltos+0x17e>
mov    %r10,%rdx
jmp    1420 <safe_ltos+0x320>
mov    %r9,%rax
jmp    1433 <safe_ltos+0x333>
cmp    %r10,%rax
jae    1364 <safe_ltos+0x264>
lea    (%r11,%r9,1),%rdx
add    $0x1,%rdx
cmp    %rdx,%rcx
jae    1364 <safe_ltos+0x264>
mov    %r10,%rdx
jmp    1420 <safe_ltos+0x320>
mov    %r8,%r11
and    $0xffffffffffffffe0,%r11
mov    %r11,%rbx
neg    %rbx
mov    %r10,%rdi
sub    %r11,%rdi
lea    (%r9,%r11,1),%rax
add    $0x10,%r9
xor    %edx,%edx
pxor   %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movdqu -0x20(%r10,%rdx,1),%xmm1
movdqu -0x10(%r10,%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,-0x10(%r9)
movdqu %xmm1,(%r9)
add    $0x20,%r9
add    $0xffffffffffffffe0,%rdx
cmp    %rdx,%rbx
jne    12d0 <safe_ltos+0x1d0>
cmp    %r11,%r8
jne    120e <safe_ltos+0x10e>
jmp    1433 <safe_ltos+0x333>
mov    %r11,%r8
and    $0xffffffffffffffe0,%r8
mov    %r8,%rdi
neg    %rdi
mov    %r10,%rdx
sub    %r8,%rdx
add    %r8,%rax
add    $0x11,%r9
xor    %ebx,%ebx
pxor   %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqu -0x20(%r10,%rbx,1),%xmm1
movdqu -0x10(%r10,%rbx,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,-0x10(%r9)
movdqu %xmm1,(%r9)
add    $0x20,%r9
add    $0xffffffffffffffe0,%rbx
cmp    %rbx,%rdi
jne    1390 <safe_ltos+0x290>
cmp    %r8,%r11
je     1433 <safe_ltos+0x333>
nopl   0x0(%rax,%rax,1)
movzbl -0x1(%rdx),%ebx
add    $0xffffffffffffffff,%rdx
mov    %bl,(%rax)
add    $0x1,%rax
cmp    %rcx,%rdx
ja     1420 <safe_ltos+0x320>
movb   $0x0,(%rax)
mov    %rax,(%rsi)
pop    %rbx
pop    %r14
ret

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

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