#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 */
long long strlen(char *);
long long int division(char a[], long long int b) {
  char c[100001];
  long long int la;
  long long int i, k = 0, flag = 0;
  long long int temp = 1, reminder;
  la = strlen(a);
  for (i = 0; i <= la; i++) {
    a[i] = a[i] - 48;
  }
  temp = a[0];
  reminder = a[0];
  for (i = 1; i <= la; i++) {
    if (b <= temp) {
      c[k++] = temp / b;
      temp = temp % b;
      reminder = temp;
      temp = temp * 10 + a[i];
      flag = 1;
    } else {
      reminder = temp;
      temp = temp * 10 + a[i];
      if (flag == 1)
        c[k++] = 0;
    }
  }
  for (i = 0; i < k; i++) {
    c[i] = c[i] + 48;
  }
  c[i] = '\0';
  return reminder;
}


x86 assembly (clang, -O0):
<division>:
push   %rbp
mov    %rsp,%rbp
sub    $0x186f0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movq   $0x0,-0x186d8(%rbp)
movq   $0x0,-0x186e0(%rbp)
movq   $0x1,-0x186e8(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <strlen@plt>
mov    %rax,-0x186c8(%rbp)
movq   $0x0,-0x186d0(%rbp)
mov    -0x186d0(%rbp),%rax
cmp    -0x186c8(%rbp),%rax
jg     11ac <division+0x9c>
mov    -0x8(%rbp),%rax
mov    -0x186d0(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sub    $0x30,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
mov    -0x186d0(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x186d0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x186d0(%rbp)
jmp    115f <division+0x4f>
mov    -0x8(%rbp),%rax
movsbq (%rax),%rax
mov    %rax,-0x186e8(%rbp)
mov    -0x8(%rbp),%rax
movsbq (%rax),%rax
mov    %rax,-0x186f0(%rbp)
movq   $0x1,-0x186d0(%rbp)
mov    -0x186d0(%rbp),%rax
cmp    -0x186c8(%rbp),%rax
jg     12f5 <division+0x1e5>
mov    -0x10(%rbp),%rax
cmp    -0x186e8(%rbp),%rax
jg     1279 <division+0x169>
mov    -0x186e8(%rbp),%rax
cqto
idivq  -0x10(%rbp)
mov    %al,%cl
mov    -0x186d8(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x186d8(%rbp)
mov    %cl,-0x186c0(%rbp,%rax,1)
mov    -0x186e8(%rbp),%rax
cqto
idivq  -0x10(%rbp)
mov    %rdx,-0x186e8(%rbp)
mov    -0x186e8(%rbp),%rax
mov    %rax,-0x186f0(%rbp)
imul   $0xa,-0x186e8(%rbp),%rax
0a
mov    -0x8(%rbp),%rcx
mov    -0x186d0(%rbp),%rdx
movsbq (%rcx,%rdx,1),%rcx
add    %rcx,%rax
mov    %rax,-0x186e8(%rbp)
movq   $0x1,-0x186e0(%rbp)
jmp    12d9 <division+0x1c9>
mov    -0x186e8(%rbp),%rax
mov    %rax,-0x186f0(%rbp)
imul   $0xa,-0x186e8(%rbp),%rax
0a
mov    -0x8(%rbp),%rcx
mov    -0x186d0(%rbp),%rdx
movsbq (%rcx,%rdx,1),%rcx
add    %rcx,%rax
mov    %rax,-0x186e8(%rbp)
cmpq   $0x1,-0x186e0(%rbp)
01
jne    12d4 <division+0x1c4>
mov    -0x186d8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x186d8(%rbp)
movb   $0x0,-0x186c0(%rbp,%rax,1)
jmp    12d9 <division+0x1c9>
jmp    12de <division+0x1ce>
mov    -0x186d0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x186d0(%rbp)
jmp    11d5 <division+0xc5>
movq   $0x0,-0x186d0(%rbp)
mov    -0x186d0(%rbp),%rax
cmp    -0x186d8(%rbp),%rax
jge    134d <division+0x23d>
mov    -0x186d0(%rbp),%rax
movsbl -0x186c0(%rbp,%rax,1),%eax
ff
add    $0x30,%eax
mov    %al,%cl
mov    -0x186d0(%rbp),%rax
mov    %cl,-0x186c0(%rbp,%rax,1)
mov    -0x186d0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x186d0(%rbp)
jmp    1300 <division+0x1f0>
mov    -0x186d0(%rbp),%rax
movb   $0x0,-0x186c0(%rbp,%rax,1)
mov    -0x186f0(%rbp),%rax
add    $0x186f0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<division>:
push   %r14
push   %rbx
sub    $0x186a8,%rsp
mov    %rsi,%r14
mov    %rdi,%rbx
call   1030 <strlen@plt>
test   %rax,%rax
js     113e <division+0x2e>
mov    %rax,%r8
add    $0x1,%rax
cmp    $0x8,%rax
jae    1147 <division+0x37>
xor    %edx,%edx
jmp    1243 <division+0x133>
movsbq (%rbx),%rax
jmp    1402 <division+0x2f2>
cmp    $0x20,%rax
jae    1154 <division+0x44>
xor    %edx,%edx
jmp    120d <division+0xfd>
mov    %rax,%rdx
and    $0xffffffffffffffe0,%rdx
lea    -0x20(%rdx),%rcx
mov    %rcx,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
test   %rcx,%rcx
je     1239 <division+0x129>
mov    %rdi,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %esi,%esi
movdqa 0xe7c(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqu (%rbx,%rsi,1),%xmm1
movdqu 0x10(%rbx,%rsi,1),%xmm2
movdqu 0x20(%rbx,%rsi,1),%xmm3
movdqu 0x30(%rbx,%rsi,1),%xmm4
paddb  %xmm0,%xmm1
paddb  %xmm0,%xmm2
movdqu %xmm1,(%rbx,%rsi,1)
movdqu %xmm2,0x10(%rbx,%rsi,1)
paddb  %xmm0,%xmm3
paddb  %xmm0,%xmm4
movdqu %xmm3,0x20(%rbx,%rsi,1)
movdqu %xmm4,0x30(%rbx,%rsi,1)
add    $0x40,%rsi
add    $0xfffffffffffffffe,%rcx
jne    1190 <division+0x80>
test   $0x1,%dil
je     1204 <division+0xf4>
movdqu (%rbx,%rsi,1),%xmm0
movdqu 0x10(%rbx,%rsi,1),%xmm1
movdqa 0xe0f(%rip),%xmm2
paddb  %xmm2,%xmm0
paddb  %xmm2,%xmm1
movdqu %xmm0,(%rbx,%rsi,1)
movdqu %xmm1,0x10(%rbx,%rsi,1)
cmp    %rdx,%rax
je     1250 <division+0x140>
test   $0x18,%al
je     1243 <division+0x133>
mov    %rdx,%rcx
mov    %rax,%rdx
and    $0xfffffffffffffff8,%rdx
movdqa 0xdf1(%rip),%xmm0
nop
movq   (%rbx,%rcx,1),%xmm1
paddb  %xmm0,%xmm1
movq   %xmm1,(%rbx,%rcx,1)
add    $0x8,%rcx
cmp    %rcx,%rdx
jne    1220 <division+0x110>
jmp    124b <division+0x13b>
xor    %esi,%esi
test   $0x1,%dil
jne    11de <division+0xce>
jmp    1204 <division+0xf4>
addb   $0xd0,(%rbx,%rdx,1)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1243 <division+0x133>
movsbq (%rbx),%rax
test   %r8,%r8
jle    1402 <division+0x2f2>
xor    %edi,%edi
xor    %ecx,%ecx
xor    %r9d,%r9d
jmp    128d <division+0x17d>
cs nopw 0x0(%rax,%rax,1)
movb   $0x0,(%rsp,%r9,1)
add    $0x1,%r9
mov    $0x1,%ecx
mov    %rax,%rdx
add    $0x1,%rdi
mov    %rsi,%rax
cmp    %rdi,%r8
je     12e5 <division+0x1d5>
cmp    %r14,%rax
jge    12b0 <division+0x1a0>
lea    (%rax,%rax,4),%rdx
movsbq 0x1(%rbx,%rdi,1),%rsi
lea    (%rsi,%rdx,2),%rsi
cmp    $0x1,%rcx
je     1270 <division+0x160>
xor    %ecx,%ecx
jmp    127e <division+0x16e>
nopw   0x0(%rax,%rax,1)
mov    %rax,%rcx
or     %r14,%rcx
shr    $0x20,%rcx
je     12c3 <division+0x1b3>
cqto
idiv   %r14
jmp    12c8 <division+0x1b8>
xor    %edx,%edx
div    %r14d
mov    %al,(%rsp,%r9,1)
add    $0x1,%r9
lea    (%rdx,%rdx,4),%rax
movsbq 0x1(%rbx,%rdi,1),%rcx
lea    (%rcx,%rax,2),%rsi
mov    $0x1,%ecx
jmp    1281 <division+0x171>
test   %r9,%r9
jle    13ff <division+0x2ef>
cmp    $0x8,%r9
jae    12fb <division+0x1eb>
xor    %eax,%eax
jmp    13f2 <division+0x2e2>
cmp    $0x20,%r9
jae    1308 <division+0x1f8>
xor    %eax,%eax
jmp    13ba <division+0x2aa>
mov    %r9,%rax
and    $0xffffffffffffffe0,%rax
lea    -0x20(%rax),%rcx
mov    %rcx,%rbx
shr    $0x5,%rbx
add    $0x1,%rbx
test   %rcx,%rcx
je     13e9 <division+0x2d9>
mov    %rbx,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %ecx,%ecx
movdqa 0xce8(%rip),%xmm0
nopl   0x0(%rax,%rax,1)
movdqa (%rsp,%rcx,1),%xmm1
paddb  %xmm0,%xmm1
movdqa 0x10(%rsp,%rcx,1),%xmm2
paddb  %xmm0,%xmm2
movdqa %xmm1,(%rsp,%rcx,1)
movdqa %xmm2,0x10(%rsp,%rcx,1)
movdqa 0x20(%rsp,%rcx,1),%xmm1
paddb  %xmm0,%xmm1
movdqa 0x30(%rsp,%rcx,1),%xmm2
paddb  %xmm0,%xmm2
movdqa %xmm1,0x20(%rsp,%rcx,1)
movdqa %xmm2,0x30(%rsp,%rcx,1)
add    $0x40,%rcx
add    $0xfffffffffffffffe,%rdi
jne    1340 <division+0x230>
test   $0x1,%bl
je     13af <division+0x29f>
movdqa 0xc8b(%rip),%xmm0
movdqa (%rsp,%rcx,1),%xmm1
paddb  %xmm0,%xmm1
paddb  0x10(%rsp,%rcx,1),%xmm0
movdqa %xmm1,(%rsp,%rcx,1)
movdqa %xmm0,0x10(%rsp,%rcx,1)
cmp    %rax,%r9
je     13ff <division+0x2ef>
test   $0x18,%r9b
je     13f2 <division+0x2e2>
mov    %rax,%rcx
mov    %r9,%rax
and    $0xfffffffffffffff8,%rax
movdqa 0xc64(%rip),%xmm0
nopl   0x0(%rax)
movq   (%rsp,%rcx,1),%xmm1
paddb  %xmm0,%xmm1
movq   %xmm1,(%rsp,%rcx,1)
add    $0x8,%rcx
cmp    %rcx,%rax
jne    13d0 <division+0x2c0>
jmp    13fa <division+0x2ea>
xor    %ecx,%ecx
test   $0x1,%bl
jne    138d <division+0x27d>
jmp    13af <division+0x29f>
addb   $0x30,(%rsp,%rax,1)
add    $0x1,%rax
cmp    %rax,%r9
jne    13f2 <division+0x2e2>
mov    %rdx,%rax
add    $0x186a8,%rsp
pop    %rbx
pop    %r14
ret

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

LLVM IR (-O2):
define i64 @division(i8* nocapture %0, i64 %1) {
%3 = alloca [100001 x i8]
%4 = getelementptr inbounds [100001 x i8], [100001 x i8]* %3, i64 0, i64 0
%5 = tail call i64 @strlen(i8* dereferenceable(1) %0)
%6 = icmp slt i64 %5, 0
br i1 %6, label %84, label %7
7: ; preds = %2
%8 = add i64 %5, 1
%9 = icmp ult i64 %8, 8
br i1 %9, label %82, label %10
10: ; preds = %7
%11 = icmp ult i64 %8, 32
br i1 %11, label %67, label %12
12: ; preds = %10
%13 = and i64 %8, -32
%14 = add i64 %13, -32
%15 = lshr exact i64 %14, 5
%16 = add nuw nsw i64 %15, 1
%17 = and i64 %16, 1
%18 = icmp eq i64 %14, 0
br i1 %18, label %48, label %19
19: ; preds = %12
%20 = and i64 %16, 1152921504606846974
br label %21
21: ; preds = %21, %19
%22 = phi i64 [ 0, %19 ], [ %45, %21 ]
%23 = phi i64 [ 0, %19 ], [ %46, %21 ]
%24 = getelementptr inbounds i8, i8* %0, i64 %22
%25 = bitcast i8* %24 to <16 x i8>*
%26 = load <16 x i8>, <16 x i8>* %25
%27 = getelementptr inbounds i8, i8* %24, i64 16
%28 = bitcast i8* %27 to <16 x i8>*
%29 = load <16 x i8>, <16 x i8>* %28
%30 = add <16 x i8> %26, <i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48>
%31 = add <16 x i8> %29, <i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48>
%32 = bitcast i8* %24 to <16 x i8>*
store <16 x i8> %30, <16 x i8>* %32
%33 = bitcast i8* %27 to <16 x i8>*
store <16 x i8> %31, <16 x i8>* %33
%34 = or i64 %22, 32
%35 = getelementptr inbounds i8, i8* %0, i64 %34
%36 = bitcast i8* %35 to <16 x i8>*
%37 = load <16 x i8>, <16 x i8>* %36
%38 = getelementptr inbounds i8, i8* %35, i64 16
%39 = bitcast i8* %38 to <16 x i8>*
%40 = load <16 x i8>, <16 x i8>* %39
%41 = add <16 x i8> %37, <i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48>
%42 = add <16 x i8> %40, <i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48>
%43 = bitcast i8* %35 to <16 x i8>*
store <16 x i8> %41, <16 x i8>* %43
%44 = bitcast i8* %38 to <16 x i8>*
store <16 x i8> %42, <16 x i8>* %44
%45 = add nuw i64 %22, 64
%46 = add i64 %23, 2
%47 = icmp eq i64 %46, %20
br i1 %47, label %48, label %21
48: ; preds = %21, %12
%49 = phi i64 [ 0, %12 ], [ %45, %21 ]
%50 = icmp eq i64 %17, 0
br i1 %50, label %62, label %51
51: ; preds = %48
%52 = getelementptr inbounds i8, i8* %0, i64 %49
%53 = bitcast i8* %52 to <16 x i8>*
%54 = load <16 x i8>, <16 x i8>* %53
%55 = getelementptr inbounds i8, i8* %52, i64 16
%56 = bitcast i8* %55 to <16 x i8>*
%57 = load <16 x i8>, <16 x i8>* %56
%58 = add <16 x i8> %54, <i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48>
%59 = add <16 x i8> %57, <i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48>
%60 = bitcast i8* %52 to <16 x i8>*
store <16 x i8> %58, <16 x i8>* %60
%61 = bitcast i8* %55 to <16 x i8>*
store <16 x i8> %59, <16 x i8>* %61
br label %62
62: ; preds = %48, %51
%63 = icmp eq i64 %8, %13
br i1 %63, label %94, label %64
64: ; preds = %62
%65 = and i64 %8, 24
%66 = icmp eq i64 %65, 0
br i1 %66, label %82, label %67
67: ; preds = %10, %64
%68 = phi i64 [ %13, %64 ], [ 0, %10 ]
%69 = add i64 %5, 1
%70 = and i64 %69, -8
br label %71
71: ; preds = %71, %67
%72 = phi i64 [ %68, %67 ], [ %78, %71 ]
%73 = getelementptr inbounds i8, i8* %0, i64 %72
%74 = bitcast i8* %73 to <8 x i8>*
%75 = load <8 x i8>, <8 x i8>* %74
%76 = add <8 x i8> %75, <i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48>
%77 = bitcast i8* %73 to <8 x i8>*
store <8 x i8> %76, <8 x i8>* %77
%78 = add nuw i64 %72, 8
%79 = icmp eq i64 %78, %70
br i1 %79, label %80, label %71
80: ; preds = %71
%81 = icmp eq i64 %69, %70
br i1 %81, label %94, label %82
82: ; preds = %7, %64, %80
%83 = phi i64 [ 0, %7 ], [ %13, %64 ], [ %70, %80 ]
br label %87
84: ; preds = %2
%85 = load i8, i8* %0
%86 = sext i8 %85 to i64
br label %216
87: ; preds = %82, %87
%88 = phi i64 [ %92, %87 ], [ %83, %82 ]
%89 = getelementptr inbounds i8, i8* %0, i64 %88
%90 = load i8, i8* %89
%91 = add i8 %90, -48
store i8 %91, i8* %89
%92 = add nuw i64 %88, 1
%93 = icmp eq i64 %88, %5
br i1 %93, label %94, label %87
94: ; preds = %87, %80, %62
%95 = load i8, i8* %0
%96 = sext i8 %95 to i64
%97 = icmp slt i64 %5, 1
br i1 %97, label %216, label %175
98: ; preds = %202
%99 = icmp sgt i64 %203, 0
br i1 %99, label %100, label %216
100: ; preds = %98
%101 = icmp ult i64 %203, 8
br i1 %101, label %173, label %102
102: ; preds = %100
%103 = icmp ult i64 %203, 32
br i1 %103, label %159, label %104
104: ; preds = %102
%105 = and i64 %203, -32
%106 = add i64 %105, -32
%107 = lshr exact i64 %106, 5
%108 = add nuw nsw i64 %107, 1
%109 = and i64 %108, 1
%110 = icmp eq i64 %106, 0
br i1 %110, label %140, label %111
111: ; preds = %104
%112 = and i64 %108, 1152921504606846974
br label %113
113: ; preds = %113, %111
%114 = phi i64 [ 0, %111 ], [ %137, %113 ]
%115 = phi i64 [ 0, %111 ], [ %138, %113 ]
%116 = getelementptr inbounds [100001 x i8], [100001 x i8]* %3, i64 0, i64 %114
%117 = bitcast i8* %116 to <16 x i8>*
%118 = load <16 x i8>, <16 x i8>* %117
%119 = getelementptr inbounds i8, i8* %116, i64 16
%120 = bitcast i8* %119 to <16 x i8>*
%121 = load <16 x i8>, <16 x i8>* %120
%122 = add <16 x i8> %118, <i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48>
%123 = add <16 x i8> %121, <i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48>
%124 = bitcast i8* %116 to <16 x i8>*
store <16 x i8> %122, <16 x i8>* %124
%125 = bitcast i8* %119 to <16 x i8>*
store <16 x i8> %123, <16 x i8>* %125
%126 = or i64 %114, 32
%127 = getelementptr inbounds [100001 x i8], [100001 x i8]* %3, i64 0, i64 %126
%128 = bitcast i8* %127 to <16 x i8>*
%129 = load <16 x i8>, <16 x i8>* %128
%130 = getelementptr inbounds i8, i8* %127, i64 16
%131 = bitcast i8* %130 to <16 x i8>*
%132 = load <16 x i8>, <16 x i8>* %131
%133 = add <16 x i8> %129, <i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48>
%134 = add <16 x i8> %132, <i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48>
%135 = bitcast i8* %127 to <16 x i8>*
store <16 x i8> %133, <16 x i8>* %135
%136 = bitcast i8* %130 to <16 x i8>*
store <16 x i8> %134, <16 x i8>* %136
%137 = add nuw i64 %114, 64
%138 = add i64 %115, 2
%139 = icmp eq i64 %138, %112
br i1 %139, label %140, label %113
140: ; preds = %113, %104
%141 = phi i64 [ 0, %104 ], [ %137, %113 ]
%142 = icmp eq i64 %109, 0
br i1 %142, label %154, label %143
143: ; preds = %140
%144 = getelementptr inbounds [100001 x i8], [100001 x i8]* %3, i64 0, i64 %141
%145 = bitcast i8* %144 to <16 x i8>*
%146 = load <16 x i8>, <16 x i8>* %145
%147 = getelementptr inbounds i8, i8* %144, i64 16
%148 = bitcast i8* %147 to <16 x i8>*
%149 = load <16 x i8>, <16 x i8>* %148
%150 = add <16 x i8> %146, <i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48>
%151 = add <16 x i8> %149, <i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48>
%152 = bitcast i8* %144 to <16 x i8>*
store <16 x i8> %150, <16 x i8>* %152
%153 = bitcast i8* %147 to <16 x i8>*
store <16 x i8> %151, <16 x i8>* %153
br label %154
154: ; preds = %140, %143
%155 = icmp eq i64 %203, %105
br i1 %155, label %216, label %156
156: ; preds = %154
%157 = and i64 %203, 24
%158 = icmp eq i64 %157, 0
br i1 %158, label %173, label %159
159: ; preds = %102, %156
%160 = phi i64 [ %105, %156 ], [ 0, %102 ]
%161 = and i64 %203, -8
br label %162
162: ; preds = %162, %159
%163 = phi i64 [ %160, %159 ], [ %169, %162 ]
%164 = getelementptr inbounds [100001 x i8], [100001 x i8]* %3, i64 0, i64 %163
%165 = bitcast i8* %164 to <8 x i8>*
%166 = load <8 x i8>, <8 x i8>* %165
%167 = add <8 x i8> %166, <i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48>
%168 = bitcast i8* %164 to <8 x i8>*
store <8 x i8> %167, <8 x i8>* %168
%169 = add nuw i64 %163, 8
%170 = icmp eq i64 %169, %161
br i1 %170, label %171, label %162
171: ; preds = %162
%172 = icmp eq i64 %203, %161
br i1 %172, label %216, label %173
173: ; preds = %100, %156, %171
%174 = phi i64 [ 0, %100 ], [ %105, %156 ], [ %161, %171 ]
br label %209
175: ; preds = %94, %202
%176 = phi i64 [ %205, %202 ], [ %96, %94 ]
%177 = phi i64 [ %204, %202 ], [ 0, %94 ]
%178 = phi i64 [ %203, %202 ], [ 0, %94 ]
%179 = phi i64 [ %207, %202 ], [ 1, %94 ]
%180 = icmp slt i64 %176, %1
br i1 %180, label %192, label %181
181: ; preds = %175
%182 = sdiv i64 %176, %1
%183 = trunc i64 %182 to i8
%184 = add nsw i64 %178, 1
%185 = getelementptr inbounds [100001 x i8], [100001 x i8]* %3, i64 0, i64 %178
store i8 %183, i8* %185
%186 = srem i64 %176, %1
%187 = mul nsw i64 %186, 10
%188 = getelementptr inbounds i8, i8* %0, i64 %179
%189 = load i8, i8* %188
%190 = sext i8 %189 to i64
%191 = add nsw i64 %187, %190
br label %202
192: ; preds = %175
%193 = mul nsw i64 %176, 10
%194 = getelementptr inbounds i8, i8* %0, i64 %179
%195 = load i8, i8* %194
%196 = sext i8 %195 to i64
%197 = add nsw i64 %193, %196
%198 = icmp eq i64 %177, 1
br i1 %198, label %199, label %202
199: ; preds = %192
%200 = add nsw i64 %178, 1
%201 = getelementptr inbounds [100001 x i8], [100001 x i8]* %3, i64 0, i64 %178
store i8 0, i8* %201
br label %202
202: ; preds = %181, %199, %192
%203 = phi i64 [ %184, %181 ], [ %200, %199 ], [ %178, %192 ]
%204 = phi i64 [ 1, %181 ], [ 1, %199 ], [ 0, %192 ]
%205 = phi i64 [ %191, %181 ], [ %197, %199 ], [ %197, %192 ]
%206 = phi i64 [ %186, %181 ], [ %176, %199 ], [ %176, %192 ]
%207 = add nuw i64 %179, 1
%208 = icmp eq i64 %179, %5
br i1 %208, label %98, label %175
209: ; preds = %173, %209
%210 = phi i64 [ %214, %209 ], [ %174, %173 ]
%211 = getelementptr inbounds [100001 x i8], [100001 x i8]* %3, i64 0, i64 %210
%212 = load i8, i8* %211
%213 = add i8 %212, 48
store i8 %213, i8* %211
%214 = add nuw nsw i64 %210, 1
%215 = icmp eq i64 %214, %203
br i1 %215, label %216, label %209
216: ; preds = %209, %154, %171, %84, %94, %98
%217 = phi i64 [ %206, %98 ], [ %86, %84 ], [ %96, %94 ], [ %206, %171 ], [ %206, %154 ], [ %206, %209 ]
ret i64 %217
}