#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 */
typedef int ssize_t;

/* Variables and functions */
unsigned int ta_tostr_ssize(char *buf, ssize_t i) {
  char buf2[32];
  char *p2 = buf2, *p = buf;
  ssize_t q, s = 0, dec = 10;
  ssize_t sign = 0;
  if (i < 0)
    sign = 1;
  if ((sign ? -i : i) < 10)
    *p2 = (sign ? -i : i) + '0';
  else
    while (i - s != 0) {
      ssize_t x;
      q = (i % dec - s) / (dec / 10);
      *p2 = sign ? '0' - q : '0' + q, p2++;
      s += q * (dec / 10);
      x = sign ? -(i - s) / dec : (i - s) / dec;
      if (x < 10) {
        *p2 = '0' + x;
        break;
      }
      dec *= 10;
    }
  if (sign == 1)
    *++p2 = '-';
  while (p2 - buf2 + 3)
    *p++ = *p2--;
  return p - buf - 2;
}


x86 assembly (clang, -O0):
<ta_tostr_ssize>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
lea    -0x30(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x48(%rbp)
movl   $0xa,-0x4c(%rbp)
movl   $0x0,-0x50(%rbp)
cmpl   $0x0,-0xc(%rbp)
jge    1141 <ta_tostr_ssize+0x41>
movl   $0x1,-0x50(%rbp)
cmpl   $0x0,-0x50(%rbp)
je     1158 <ta_tostr_ssize+0x58>
xor    %eax,%eax
sub    -0xc(%rbp),%eax
mov    %eax,-0x58(%rbp)
jmp    115e <ta_tostr_ssize+0x5e>
mov    -0xc(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    $0xa,%eax
jge    119a <ta_tostr_ssize+0x9a>
cmpl   $0x0,-0x50(%rbp)
je     1181 <ta_tostr_ssize+0x81>
xor    %eax,%eax
sub    -0xc(%rbp),%eax
mov    %eax,-0x5c(%rbp)
jmp    1187 <ta_tostr_ssize+0x87>
mov    -0xc(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x30,%eax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %cl,(%rax)
jmp    128b <ta_tostr_ssize+0x18b>
jmp    119f <ta_tostr_ssize+0x9f>
mov    -0xc(%rbp),%eax
sub    -0x48(%rbp),%eax
cmp    $0x0,%eax
je     1286 <ta_tostr_ssize+0x186>
mov    -0xc(%rbp),%eax
cltd
idivl  -0x4c(%rbp)
sub    -0x48(%rbp),%edx
mov    %edx,-0x60(%rbp)
mov    -0x4c(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x60(%rbp),%eax
cltd
idiv   %ecx
mov    %eax,-0x44(%rbp)
cmpl   $0x0,-0x50(%rbp)
je     11eb <ta_tostr_ssize+0xeb>
mov    $0x30,%eax
sub    -0x44(%rbp),%eax
mov    %eax,-0x64(%rbp)
jmp    11f4 <ta_tostr_ssize+0xf4>
mov    -0x44(%rbp),%eax
add    $0x30,%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %cl,(%rax)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x4c(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x68(%rbp),%eax
imul   %ecx,%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
cmpl   $0x0,-0x50(%rbp)
je     124a <ta_tostr_ssize+0x14a>
mov    -0xc(%rbp),%ecx
sub    -0x48(%rbp),%ecx
xor    %eax,%eax
sub    %ecx,%eax
cltd
idivl  -0x4c(%rbp)
mov    %eax,-0x6c(%rbp)
jmp    1257 <ta_tostr_ssize+0x157>
mov    -0xc(%rbp),%eax
sub    -0x48(%rbp),%eax
cltd
idivl  -0x4c(%rbp)
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
mov    %eax,-0x54(%rbp)
cmpl   $0xa,-0x54(%rbp)
jge    127a <ta_tostr_ssize+0x17a>
mov    -0x54(%rbp),%eax
add    $0x30,%eax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %cl,(%rax)
jmp    1286 <ta_tostr_ssize+0x186>
imul   $0xa,-0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
jmp    119f <ta_tostr_ssize+0x9f>
jmp    128b <ta_tostr_ssize+0x18b>
cmpl   $0x1,-0x50(%rbp)
jne    12a8 <ta_tostr_ssize+0x1a8>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movb   $0x2d,0x1(%rax)
jmp    12ad <ta_tostr_ssize+0x1ad>
mov    -0x38(%rbp),%rax
lea    -0x30(%rbp),%rcx
sub    %rcx,%rax
add    $0x3,%rax
cmp    $0x0,%rax
je     12ed <ta_tostr_ssize+0x1ed>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%cl
mov    -0x40(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x40(%rbp)
mov    %cl,(%rax)
jmp    12ad <ta_tostr_ssize+0x1ad>
mov    -0x40(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    %rcx,%rax
sub    $0x2,%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<ta_tostr_ssize>:
push   %rbp
push   %rbx
mov    %esi,%r8d
mov    %esi,%eax
neg    %eax
cmovs  %esi,%eax
cmp    $0xa,%eax
jge    112a <ta_tostr_ssize+0x2a>
lea    -0x28(%rsp),%r9
add    $0x30,%al
mov    %al,-0x28(%rsp)
test   %r8d,%r8d
jns    11c7 <ta_tostr_ssize+0xc7>
jmp    11be <ta_tostr_ssize+0xbe>
test   %r8d,%r8d
je     11b4 <ta_tostr_ssize+0xb4>
lea    -0x27(%rsp),%rbx
xor    %esi,%esi
mov    $0xa,%r11d
mov    $0xcccccccd,%r10d
cs nopw 0x0(%rax,%rax,1)
mov    %esi,%ecx
mov    %r8d,%eax
cltd
idiv   %r11d
mov    %edx,%eax
sub    %esi,%eax
mov    %r11d,%esi
imul   %r10,%rsi
shr    $0x23,%rsi
cltd
idiv   %esi
mov    %eax,%edx
neg    %dl
imul   %eax,%esi
add    %ecx,%esi
mov    %esi,%ebp
sub    %r8d,%ebp
mov    %r8d,%ecx
sub    %esi,%ecx
test   %r8d,%r8d
movzbl %dl,%edx
cmovns %eax,%edx
mov    %rbx,%r9
cmovs  %ebp,%ecx
add    $0x30,%dl
mov    %dl,-0x1(%rbx)
mov    %ecx,%eax
cltd
idiv   %r11d
cmp    $0x9,%eax
jle    12b1 <ta_tostr_ssize+0x1b1>
add    %r11d,%r11d
lea    (%r11,%r11,4),%r11d
lea    0x1(%r9),%rbx
cmp    %r8d,%esi
jne    1150 <ta_tostr_ssize+0x50>
jmp    11b9 <ta_tostr_ssize+0xb9>
lea    -0x28(%rsp),%r9
test   %r8d,%r8d
jns    11c7 <ta_tostr_ssize+0xc7>
movb   $0x2d,0x1(%r9)
add    $0x1,%r9
lea    -0x28(%rsp),%r11
mov    %r9,%rcx
sub    %r11,%rcx
mov    %rdi,%rax
cmp    $0xfffffffffffffffd,%rcx
je     1379 <ta_tostr_ssize+0x279>
lea    0x3(%rcx),%r8
cmp    $0x20,%r8
jb     120c <ta_tostr_ssize+0x10c>
lea    0x1(%r9),%rax
cmp    %rdi,%rax
jbe    12c4 <ta_tostr_ssize+0x1c4>
lea    (%rcx,%rdi,1),%rax
add    $0x3,%rax
lea    -0x2a(%rsp),%rcx
cmp    %rax,%rcx
jae    12c4 <ta_tostr_ssize+0x1c4>
mov    %r9,%rdx
mov    %rdi,%rax
lea    0x3(%rdx),%esi
mov    %r11,%rcx
neg    %rcx
add    %rdx,%rcx
add    $0x2,%rcx
and    $0x7,%rsi
je     1243 <ta_tostr_ssize+0x143>
nopl   0x0(%rax,%rax,1)
movzbl (%rdx),%ebx
add    $0xffffffffffffffff,%rdx
mov    %bl,(%rax)
add    $0x1,%rax
add    $0xffffffffffffffff,%rsi
jne    1230 <ta_tostr_ssize+0x130>
cmp    $0x7,%rcx
jb     1379 <ta_tostr_ssize+0x279>
sub    %rdx,%r11
mov    $0x3,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
movzbl -0x3(%rdx,%rcx,1),%ebx
mov    %bl,(%rax)
movzbl -0x4(%rdx,%rcx,1),%ebx
mov    %bl,0x1(%rax)
movzbl -0x5(%rdx,%rcx,1),%ebx
mov    %bl,0x2(%rax)
movzbl -0x6(%rdx,%rcx,1),%ebx
mov    %bl,0x3(%rax)
movzbl -0x7(%rdx,%rcx,1),%ebx
mov    %bl,0x4(%rax)
movzbl -0x8(%rdx,%rcx,1),%ebx
mov    %bl,0x5(%rax)
movzbl -0x9(%rdx,%rcx,1),%ebx
mov    %bl,0x6(%rax)
movzbl -0xa(%rdx,%rcx,1),%ebx
mov    %bl,0x7(%rax)
add    $0x8,%rax
add    $0xfffffffffffffff8,%rcx
cmp    %rcx,%r11
jne    1260 <ta_tostr_ssize+0x160>
jmp    1379 <ta_tostr_ssize+0x279>
add    $0x30,%al
mov    %al,(%r9)
test   %r8d,%r8d
jns    11c7 <ta_tostr_ssize+0xc7>
jmp    11be <ta_tostr_ssize+0xbe>
mov    %r8,%r10
and    $0xffffffffffffffe0,%r10
mov    %r10,%rsi
neg    %rsi
mov    %r9,%rdx
sub    %r10,%rdx
lea    (%rdi,%r10,1),%rax
lea    0x10(%rdi),%rbx
xor    %ecx,%ecx
pxor   %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nop
movdqu -0x1f(%r9,%rcx,1),%xmm1
movdqu -0xf(%r9,%rcx,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(%rbx)
movdqu %xmm1,(%rbx)
add    $0x20,%rbx
add    $0xffffffffffffffe0,%rcx
cmp    %rcx,%rsi
jne    12f0 <ta_tostr_ssize+0x1f0>
cmp    %r10,%r8
jne    1212 <ta_tostr_ssize+0x112>
sub    %edi,%eax
add    $0xfffffffe,%eax
pop    %rbx
pop    %rbp
ret

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

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