#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 */
int strlen(char *);
void int_str_mult(char *A, int n, char *B) {
  int carry = 0, i, x, j, prod;
  char p[20] = {0};
  x = strlen(A);
  for (i = x - 1; i + 1; i--) {
    prod = (A[i] - '0') * n + carry;
    B[i] = prod % 10 + '0';
    carry = prod / 10;
  }
  if (carry) {
    prod = carry;
    for (j = 0; prod; j++, prod /= 10)
      p[j] = prod % 10 + '0';
    for (i = x; i + 1; i--)
      B[i + j] = B[i];
    j--;
    for (i = 0; j >= 0; j--, i++)
      B[i] = p[j];
  }
}


x86 assembly (clang, -O0):
<int_str_mult>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
lea    -0x40(%rbp),%rdi
xor    %esi,%esi
mov    $0x14,%edx
call   1040 <memset@plt>
mov    -0x8(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
cmp    $0x0,%eax
je     11bc <int_str_mult+0x9c>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sub    $0x30,%eax
imul   -0xc(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
add    $0x30,%edx
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x2c(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
jmp    115f <int_str_mult+0x3f>
cmpl   $0x0,-0x1c(%rbp)
je     1298 <int_str_mult+0x178>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
movl   $0x0,-0x28(%rbp)
cmpl   $0x0,-0x2c(%rbp)
je     1211 <int_str_mult+0xf1>
mov    -0x2c(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
add    $0x30,%edx
mov    %dl,%cl
movslq -0x28(%rbp),%rax
mov    %cl,-0x40(%rbp,%rax,1)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %eax,-0x2c(%rbp)
jmp    11d3 <int_str_mult+0xb3>
mov    -0x24(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
cmp    $0x0,%eax
je     124f <int_str_mult+0x12f>
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
jmp    1217 <int_str_mult+0xf7>
mov    -0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x28(%rbp)
movl   $0x0,-0x20(%rbp)
cmpl   $0x0,-0x28(%rbp)
jl     1293 <int_str_mult+0x173>
movslq -0x28(%rbp),%rax
mov    -0x40(%rbp,%rax,1),%dl
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x28(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    125f <int_str_mult+0x13f>
jmp    1298 <int_str_mult+0x178>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<int_str_mult>:
push   %rbp
push   %r15
push   %r14
push   %rbx
sub    $0x18,%rsp
mov    %rdx,%r14
mov    %esi,%r15d
mov    %rdi,%rbx
pxor   %xmm0,%xmm0
movdqa %xmm0,(%rsp)
movl   $0x0,0x10(%rsp)
call   1030 <strlen@plt>
test   %eax,%eax
je     1464 <int_str_mult+0x354>
mov    %eax,%r8d
movslq %r8d,%r9
lea    (%rbx,%r9,1),%rax
add    $0xffffffffffffffff,%rax
lea    (%r14,%r9,1),%rcx
add    $0xffffffffffffffff,%rcx
xor    %ebx,%ebx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movsbl (%rax,%rbx,1),%edi
add    $0xffffffd0,%edi
imul   %r15d,%edi
add    %esi,%edi
movslq %edi,%rdx
imul   $0x66666667,%rdx,%rsi
mov    %rsi,%rbp
shr    $0x3f,%rbp
sar    $0x22,%rsi
add    %ebp,%esi
lea    (%rsi,%rsi,1),%ebp
lea    0x0(%rbp,%rbp,4),%ebp
sub    %ebp,%edx
add    $0x30,%dl
mov    %dl,(%rcx,%rbx,1)
add    $0xffffffffffffffff,%rbx
mov    %r8d,%edx
add    %ebx,%edx
jne    1160 <int_str_mult+0x50>
add    $0x9,%edi
cmp    $0x13,%edi
jb     1464 <int_str_mult+0x354>
xor    %ebx,%ebx
mov    $0xffffffffffffffff,%rcx
movabs $0x100000000,%r10
xor    %eax,%eax
nop
add    %r10,%rbx
movslq %esi,%rdx
imul   $0x66666667,%rdx,%rsi
mov    %rsi,%rdi
shr    $0x3f,%rdi
sar    $0x22,%rsi
add    %edi,%esi
lea    (%rsi,%rsi,1),%edi
lea    (%rdi,%rdi,4),%edi
mov    %edx,%ebp
sub    %edi,%ebp
add    $0x30,%bpl
mov    %bpl,0x1(%rsp,%rcx,1)
add    $0x9,%edx
add    $0x1,%eax
add    $0x1,%rcx
cmp    $0x13,%edx
jae    11c0 <int_str_mult+0xb0>
cmp    $0xffffffff,%r8d
je     1280 <int_str_mult+0x170>
movslq %r8d,%r10
lea    0x1(%r9),%r8
cmp    $0x4,%r8
jae    12b3 <int_str_mult+0x1a3>
mov    %r10,%rsi
lea    0x1(%rsi),%edi
mov    %rsi,%rdx
and    $0x3,%rdi
je     1243 <int_str_mult+0x133>
movslq %eax,%rbp
add    %r14,%rbp
mov    %rsi,%rdx
nopl   0x0(%rax,%rax,1)
movzbl (%r14,%rdx,1),%ebx
mov    %bl,0x0(%rbp,%rdx,1)
add    $0xffffffffffffffff,%rdx
add    $0xffffffffffffffff,%rdi
jne    1230 <int_str_mult+0x120>
cmp    $0x3,%rsi
jb     1280 <int_str_mult+0x170>
movslq %eax,%rsi
add    %r14,%rsi
nop
movzbl (%r14,%rdx,1),%ebx
mov    %bl,(%rsi,%rdx,1)
movzbl -0x1(%r14,%rdx,1),%ebx
mov    %bl,-0x1(%rsi,%rdx,1)
movzbl -0x2(%r14,%rdx,1),%ebx
mov    %bl,-0x2(%rsi,%rdx,1)
movzbl -0x3(%r14,%rdx,1),%ebx
mov    %bl,-0x3(%rsi,%rdx,1)
add    $0xfffffffffffffffc,%rdx
cmp    $0xffffffffffffffff,%rdx
jne    1250 <int_str_mult+0x140>
mov    %ecx,%r9d
xor    %r10d,%r10d
test   %ecx,%ecx
mov    $0x0,%edx
cmovs  %ecx,%edx
mov    %eax,%r11d
sub    %edx,%r11d
cmp    $0x8,%r11d
jae    12a3 <int_str_mult+0x193>
xor    %edi,%edi
jmp    1438 <int_str_mult+0x328>
xor    %r8d,%r8d
cmp    $0x20,%r11d
jae    1309 <int_str_mult+0x1f9>
xor    %edi,%edi
jmp    13cc <int_str_mult+0x2bc>
sar    $0x20,%rbx
lea    (%rbx,%r9,1),%rdx
lea    (%r14,%rdx,1),%rsi
add    %r14,%rbx
cmp    %rsi,%rbx
ja     1213 <int_str_mult+0x103>
lea    (%r14,%r9,1),%rsi
cmp    %r14,%rsi
jb     1213 <int_str_mult+0x103>
lea    (%r9,%r14,1),%rsi
add    $0x1,%rsi
cmp    %rsi,%rbx
jae    12f5 <int_str_mult+0x1e5>
add    %r14,%rdx
add    $0x1,%rdx
cmp    %r14,%rdx
ja     1213 <int_str_mult+0x103>
movslq %eax,%r11
cmp    $0x10,%r8
jae    146f <int_str_mult+0x35f>
xor    %edx,%edx
jmp    1535 <int_str_mult+0x425>
mov    %r11d,%edi
and    $0xffffffe0,%edi
test   %ecx,%ecx
mov    $0x0,%esi
cmovs  %ecx,%esi
lea    0x10(%r14),%rbx
mov    %eax,%edx
sub    %esi,%edx
and    $0xffffffe0,%edx
neg    %rdx
mov    %ecx,%esi
add    %rsp,%rsi
add    $0xfffffffffffffff1,%rsi
pxor   %xmm0,%xmm0
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
movdqu -0x10(%rsi,%rbp,1),%xmm1
movdqu (%rsi,%rbp,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,%rbp
cmp    %rbp,%rdx
jne    1340 <int_str_mult+0x230>
cmp    %r11,%rdi
je     1464 <int_str_mult+0x354>
test   $0x18,%r11b
je     1435 <int_str_mult+0x325>
mov    %rdi,%rdx
mov    %r11d,%edi
and    $0xfffffff8,%edi
sub    %rdi,%r9
test   %ecx,%ecx
cmovs  %ecx,%r8d
lea    (%r14,%rdx,1),%rsi
mov    %eax,%ebx
sub    %r8d,%ebx
and    $0xfffffff8,%ebx
neg    %rbx
neg    %rdx
mov    %ecx,%ebp
add    %rsp,%rbp
add    $0xfffffffffffffff9,%rbp
pxor   %xmm0,%xmm0
nopl   (%rax)
movq   0x0(%rbp,%rdx,1),%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movq   %xmm1,(%rsi)
add    $0x8,%rsi
add    $0xfffffffffffffff8,%rdx
cmp    %rdx,%rbx
jne    1400 <int_str_mult+0x2f0>
cmp    %r11,%rdi
jne    1438 <int_str_mult+0x328>
jmp    1464 <int_str_mult+0x354>
sub    %rdi,%r9
test   %ecx,%ecx
cmovs  %ecx,%r10d
sub    %r10d,%eax
lea    (%rsp,%r9,1),%rcx
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%rcx),%edx
mov    %dl,(%r14,%rdi,1)
add    $0x1,%rdi
add    $0xffffffffffffffff,%rcx
cmp    %rdi,%rax
jne    1450 <int_str_mult+0x340>
add    $0x18,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r8,%rdx
and    $0xfffffffffffffff0,%rdx
lea    -0x10(%rdx),%rdi
mov    %rdi,%rsi
shr    $0x4,%rsi
add    $0x1,%rsi
mov    %esi,%r9d
and    $0x3,%r9d
cmp    $0x30,%rdi
jae    1496 <int_str_mult+0x386>
xor    %ebp,%ebp
jmp    14e4 <int_str_mult+0x3d4>
and    $0xfffffffffffffffc,%rsi
lea    (%r10,%r14,1),%rdi
lea    (%r10,%r14,1),%rbx
add    $0xfffffffffffffff1,%rbx
add    %r11,%rdi
add    $0xfffffffffffffff1,%rdi
xor    %ebp,%ebp
movups (%rbx,%rbp,1),%xmm0
movups %xmm0,(%rdi,%rbp,1)
movups -0x10(%rbx,%rbp,1),%xmm0
movups %xmm0,-0x10(%rdi,%rbp,1)
movups -0x20(%rbx,%rbp,1),%xmm0
movups %xmm0,-0x20(%rdi,%rbp,1)
movdqu -0x30(%rbx,%rbp,1),%xmm0
movdqu %xmm0,-0x30(%rdi,%rbp,1)
add    $0xffffffffffffffc0,%rbp
add    $0xfffffffffffffffc,%rsi
jne    14af <int_str_mult+0x39f>
neg    %rbp
test   %r9,%r9
je     1526 <int_str_mult+0x416>
mov    %r10,%rdi
sub    %rbp,%rdi
lea    (%rdi,%r14,1),%rsi
add    $0xfffffffffffffff1,%rsi
add    %r14,%rdi
add    %r11,%rdi
add    $0xfffffffffffffff1,%rdi
shl    $0x4,%r9
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movdqu (%rsi,%rbx,1),%xmm0
movdqu %xmm0,(%rdi,%rbx,1)
add    $0xfffffffffffffff0,%rbx
mov    %r9,%rbp
add    %rbx,%rbp
jne    1510 <int_str_mult+0x400>
cmp    %rdx,%r8
je     1280 <int_str_mult+0x170>
test   $0xc,%r8b
je     156e <int_str_mult+0x45e>
mov    %r8,%rbp
and    $0xfffffffffffffffc,%rbp
mov    %r10,%rsi
sub    %rbp,%rsi
sub    %rdx,%r10
sub    %rbp,%rdx
lea    (%r10,%r14,1),%rdi
add    $0xfffffffffffffffd,%rdi
mov    (%rdi),%ebx
mov    %ebx,(%rdi,%r11,1)
add    $0xfffffffffffffffc,%rdi
add    $0x4,%rdx
jne    1550 <int_str_mult+0x440>
cmp    %rbp,%r8
jne    1216 <int_str_mult+0x106>
jmp    1280 <int_str_mult+0x170>
sub    %rdx,%r10
jmp    1213 <int_str_mult+0x103>

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

LLVM IR (-O2):
define void @int_str_mult(i8* %0, i32 %1, i8* nocapture %2) {
%4 = alloca [20 x i8]
%5 = getelementptr inbounds [20 x i8], [20 x i8]* %4, i64 0, i64 0
%6 = tail call i32 @strlen(i8* %0)
%7 = icmp eq i32 %6, 0
br i1 %7, label %275, label %8
8: ; preds = %3
%9 = sext i32 %6 to i64
br label %10
10: ; preds = %8, %10
%11 = phi i64 [ %9, %8 ], [ %13, %10 ]
%12 = phi i32 [ 0, %8 ], [ %24, %10 ]
%13 = add nsw i64 %11, -1
%14 = getelementptr inbounds i8, i8* %0, i64 %13
%15 = load i8, i8* %14
%16 = sext i8 %15 to i32
%17 = add nsw i32 %16, -48
%18 = mul nsw i32 %17, %1
%19 = add nsw i32 %18, %12
%20 = srem i32 %19, 10
%21 = trunc i32 %20 to i8
%22 = add nsw i8 %21, 48
%23 = getelementptr inbounds i8, i8* %2, i64 %13
store i8 %22, i8* %23
%24 = sdiv i32 %19, 10
%25 = trunc i64 %13 to i32
%26 = icmp eq i32 %25, 0
br i1 %26, label %27, label %10
27: ; preds = %10
%28 = add i32 %19, 9
%29 = icmp ult i32 %28, 19
br i1 %29, label %275, label %176
30: ; preds = %176
%31 = trunc i64 %177 to i32
%32 = icmp eq i32 %6, -1
br i1 %32, label %187, label %33
33: ; preds = %30
%34 = sext i32 %6 to i64
%35 = shl i64 %183, 32
%36 = ashr exact i64 %35, 32
%37 = add nsw i64 %9, 1
%38 = icmp ult i64 %37, 4
br i1 %38, label %158, label %39
39: ; preds = %33
%40 = add nsw i64 %36, %9
%41 = getelementptr i8, i8* %2, i64 %40
%42 = getelementptr i8, i8* %2, i64 %36
%43 = icmp ugt i8* %42, %41
%44 = getelementptr i8, i8* %2, i64 %9
%45 = icmp ult i8* %44, %2
%46 = or i1 %43, %45
br i1 %46, label %158, label %47
47: ; preds = %39
%48 = getelementptr i8, i8* %2, i64 %36
%49 = add nsw i64 %36, %9
%50 = add nsw i64 %49, 1
%51 = getelementptr i8, i8* %2, i64 %50
%52 = add nsw i64 %9, 1
%53 = getelementptr i8, i8* %2, i64 %52
%54 = icmp ult i8* %48, %53
%55 = icmp ugt i8* %51, %2
%56 = and i1 %54, %55
br i1 %56, label %158, label %57
57: ; preds = %47
%58 = icmp ult i64 %37, 16
br i1 %58, label %138, label %59
59: ; preds = %57
%60 = and i64 %37, -16
%61 = add nsw i64 %60, -16
%62 = lshr exact i64 %61, 4
%63 = add nuw nsw i64 %62, 1
%64 = and i64 %63, 3
%65 = icmp ult i64 %61, 48
br i1 %65, label %113, label %66
66: ; preds = %59
%67 = and i64 %63, 2305843009213693948
%68 = getelementptr inbounds i8, i8* %2, i64 -15
%69 = getelementptr inbounds i8, i8* %2, i64 -15
%70 = getelementptr inbounds i8, i8* %2, i64 -15
%71 = getelementptr inbounds i8, i8* %2, i64 -15
%72 = getelementptr inbounds i8, i8* %2, i64 -15
%73 = getelementptr inbounds i8, i8* %2, i64 -15
%74 = getelementptr inbounds i8, i8* %2, i64 -15
%75 = getelementptr inbounds i8, i8* %2, i64 -15
br label %76
76: ; preds = %76, %66
%77 = phi i64 [ 0, %66 ], [ %110, %76 ]
%78 = phi i64 [ 0, %66 ], [ %111, %76 ]
%79 = sub i64 %34, %77
%80 = getelementptr inbounds i8, i8* %68, i64 %79
%81 = bitcast i8* %80 to <16 x i8>*
%82 = load <16 x i8>, <16 x i8>* %81
%83 = add nsw i64 %79, %36
%84 = getelementptr inbounds i8, i8* %69, i64 %83
%85 = bitcast i8* %84 to <16 x i8>*
store <16 x i8> %82, <16 x i8>* %85
%86 = or i64 %77, 16
%87 = sub i64 %34, %86
%88 = getelementptr inbounds i8, i8* %70, i64 %87
%89 = bitcast i8* %88 to <16 x i8>*
%90 = load <16 x i8>, <16 x i8>* %89
%91 = add nsw i64 %87, %36
%92 = getelementptr inbounds i8, i8* %71, i64 %91
%93 = bitcast i8* %92 to <16 x i8>*
store <16 x i8> %90, <16 x i8>* %93
%94 = or i64 %77, 32
%95 = sub i64 %34, %94
%96 = getelementptr inbounds i8, i8* %72, i64 %95
%97 = bitcast i8* %96 to <16 x i8>*
%98 = load <16 x i8>, <16 x i8>* %97
%99 = add nsw i64 %95, %36
%100 = getelementptr inbounds i8, i8* %73, i64 %99
%101 = bitcast i8* %100 to <16 x i8>*
store <16 x i8> %98, <16 x i8>* %101
%102 = or i64 %77, 48
%103 = sub i64 %34, %102
%104 = getelementptr inbounds i8, i8* %74, i64 %103
%105 = bitcast i8* %104 to <16 x i8>*
%106 = load <16 x i8>, <16 x i8>* %105
%107 = add nsw i64 %103, %36
%108 = getelementptr inbounds i8, i8* %75, i64 %107
%109 = bitcast i8* %108 to <16 x i8>*
store <16 x i8> %106, <16 x i8>* %109
%110 = add nuw i64 %77, 64
%111 = add i64 %78, 4
%112 = icmp eq i64 %111, %67
br i1 %112, label %113, label %76
113: ; preds = %76, %59
%114 = phi i64 [ 0, %59 ], [ %110, %76 ]
%115 = icmp eq i64 %64, 0
br i1 %115, label %132, label %116
116: ; preds = %113
%117 = getelementptr inbounds i8, i8* %2, i64 -15
%118 = getelementptr inbounds i8, i8* %2, i64 -15
br label %119
119: ; preds = %119, %116
%120 = phi i64 [ %114, %116 ], [ %129, %119 ]
%121 = phi i64 [ 0, %116 ], [ %130, %119 ]
%122 = sub i64 %34, %120
%123 = getelementptr inbounds i8, i8* %117, i64 %122
%124 = bitcast i8* %123 to <16 x i8>*
%125 = load <16 x i8>, <16 x i8>* %124
%126 = add nsw i64 %122, %36
%127 = getelementptr inbounds i8, i8* %118, i64 %126
%128 = bitcast i8* %127 to <16 x i8>*
store <16 x i8> %125, <16 x i8>* %128
%129 = add nuw i64 %120, 16
%130 = add i64 %121, 1
%131 = icmp eq i64 %130, %64
br i1 %131, label %132, label %119
132: ; preds = %119, %113
%133 = icmp eq i64 %37, %60
br i1 %133, label %187, label %134
134: ; preds = %132
%135 = sub nsw i64 %34, %60
%136 = and i64 %37, 12
%137 = icmp eq i64 %136, 0
br i1 %137, label %158, label %138
138: ; preds = %57, %134
%139 = phi i64 [ %60, %134 ], [ 0, %57 ]
%140 = add nsw i64 %9, 1
%141 = and i64 %140, -4
%142 = sub nsw i64 %34, %141
%143 = getelementptr inbounds i8, i8* %2, i64 -3
%144 = getelementptr inbounds i8, i8* %2, i64 -3
br label %145
145: ; preds = %145, %138
%146 = phi i64 [ %139, %138 ], [ %154, %145 ]
%147 = sub i64 %34, %146
%148 = getelementptr inbounds i8, i8* %143, i64 %147
%149 = bitcast i8* %148 to <4 x i8>*
%150 = load <4 x i8>, <4 x i8>* %149
%151 = add nsw i64 %147, %36
%152 = getelementptr inbounds i8, i8* %144, i64 %151
%153 = bitcast i8* %152 to <4 x i8>*
store <4 x i8> %150, <4 x i8>* %153
%154 = add nuw i64 %146, 4
%155 = icmp eq i64 %154, %141
br i1 %155, label %156, label %145
156: ; preds = %145
%157 = icmp eq i64 %140, %141
br i1 %157, label %187, label %158
158: ; preds = %47, %39, %33, %134, %156
%159 = phi i64 [ %34, %33 ], [ %34, %47 ], [ %34, %39 ], [ %135, %134 ], [ %142, %156 ]
%160 = add i64 %159, 1
%161 = and i64 %160, 3
%162 = icmp eq i64 %161, 0
br i1 %162, label %173, label %163
163: ; preds = %158, %163
%164 = phi i64 [ %170, %163 ], [ %159, %158 ]
%165 = phi i64 [ %171, %163 ], [ 0, %158 ]
%166 = getelementptr inbounds i8, i8* %2, i64 %164
%167 = load i8, i8* %166
%168 = add nsw i64 %164, %36
%169 = getelementptr inbounds i8, i8* %2, i64 %168
store i8 %167, i8* %169
%170 = add nsw i64 %164, -1
%171 = add i64 %165, 1
%172 = icmp eq i64 %171, %161
br i1 %172, label %173, label %163
173: ; preds = %163, %158
%174 = phi i64 [ %159, %158 ], [ %170, %163 ]
%175 = icmp ult i64 %159, 3
br i1 %175, label %187, label %243
176: ; preds = %27, %176
%177 = phi i64 [ %183, %176 ], [ 0, %27 ]
%178 = phi i32 [ %184, %176 ], [ %24, %27 ]
%179 = srem i32 %178, 10
%180 = trunc i32 %179 to i8
%181 = add nsw i8 %180, 48
%182 = getelementptr inbounds [20 x i8], [20 x i8]* %4, i64 0, i64 %177
store i8 %181, i8* %182
%183 = add nuw i64 %177, 1
%184 = sdiv i32 %178, 10
%185 = add nsw i32 %178, 9
%186 = icmp ult i32 %185, 19
br i1 %186, label %30, label %176
187: ; preds = %173, %243, %132, %156, %30
%188 = and i64 %177, 4294967295
%189 = add i32 %31, 1
%190 = call i32 @llvm.smin.i32(i32 %31, i32 0)
%191 = sub i32 %189, %190
%192 = zext i32 %191 to i64
%193 = icmp ult i32 %191, 8
br i1 %193, label %240, label %194
194: ; preds = %187
%195 = icmp ult i32 %191, 32
br i1 %195, label %222, label %196
196: ; preds = %194
%197 = and i64 %192, 4294967264
br label %198
198: ; preds = %198, %196
%199 = phi i64 [ 0, %196 ], [ %214, %198 ]
%200 = sub i64 %188, %199
%201 = getelementptr inbounds [20 x i8], [20 x i8]* %4, i64 0, i64 %200
%202 = getelementptr inbounds i8, i8* %201, i64 -15
%203 = bitcast i8* %202 to <16 x i8>*
%204 = load <16 x i8>, <16 x i8>* %203
%205 = shufflevector <16 x i8> %204, <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>
%206 = getelementptr inbounds i8, i8* %201, i64 -31
%207 = bitcast i8* %206 to <16 x i8>*
%208 = load <16 x i8>, <16 x i8>* %207
%209 = shufflevector <16 x i8> %208, <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>
%210 = getelementptr inbounds i8, i8* %2, i64 %199
%211 = bitcast i8* %210 to <16 x i8>*
store <16 x i8> %205, <16 x i8>* %211
%212 = getelementptr inbounds i8, i8* %210, i64 16
%213 = bitcast i8* %212 to <16 x i8>*
store <16 x i8> %209, <16 x i8>* %213
%214 = add nuw i64 %199, 32
%215 = icmp eq i64 %214, %197
br i1 %215, label %216, label %198
216: ; preds = %198
%217 = icmp eq i64 %197, %192
br i1 %217, label %275, label %218
218: ; preds = %216
%219 = sub nsw i64 %188, %197
%220 = and i64 %192, 24
%221 = icmp eq i64 %220, 0
br i1 %221, label %240, label %222
222: ; preds = %194, %218
%223 = phi i64 [ %197, %218 ], [ 0, %194 ]
%224 = and i64 %192, 4294967288
%225 = sub nsw i64 %188, %224
br label %226
226: ; preds = %226, %222
%227 = phi i64 [ %223, %222 ], [ %236, %226 ]
%228 = sub i64 %188, %227
%229 = getelementptr inbounds [20 x i8], [20 x i8]* %4, i64 0, i64 %228
%230 = getelementptr inbounds i8, i8* %229, i64 -7
%231 = bitcast i8* %230 to <8 x i8>*
%232 = load <8 x i8>, <8 x i8>* %231
%233 = shufflevector <8 x i8> %232, <8 x i8> poison, <8 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%234 = getelementptr inbounds i8, i8* %2, i64 %227
%235 = bitcast i8* %234 to <8 x i8>*
store <8 x i8> %233, <8 x i8>* %235
%236 = add nuw i64 %227, 8
%237 = icmp eq i64 %236, %224
br i1 %237, label %238, label %226
238: ; preds = %226
%239 = icmp eq i64 %224, %192
br i1 %239, label %275, label %240
240: ; preds = %187, %218, %238
%241 = phi i64 [ 0, %187 ], [ %197, %218 ], [ %224, %238 ]
%242 = phi i64 [ %188, %187 ], [ %219, %218 ], [ %225, %238 ]
br label %266
243: ; preds = %173, %243
%244 = phi i64 [ %264, %243 ], [ %174, %173 ]
%245 = getelementptr inbounds i8, i8* %2, i64 %244
%246 = load i8, i8* %245
%247 = add nsw i64 %244, %36
%248 = getelementptr inbounds i8, i8* %2, i64 %247
store i8 %246, i8* %248
%249 = add nsw i64 %244, -1
%250 = getelementptr inbounds i8, i8* %2, i64 %249
%251 = load i8, i8* %250
%252 = add nsw i64 %249, %36
%253 = getelementptr inbounds i8, i8* %2, i64 %252
store i8 %251, i8* %253
%254 = add nsw i64 %244, -2
%255 = getelementptr inbounds i8, i8* %2, i64 %254
%256 = load i8, i8* %255
%257 = add nsw i64 %254, %36
%258 = getelementptr inbounds i8, i8* %2, i64 %257
store i8 %256, i8* %258
%259 = add nsw i64 %244, -3
%260 = getelementptr inbounds i8, i8* %2, i64 %259
%261 = load i8, i8* %260
%262 = add nsw i64 %259, %36
%263 = getelementptr inbounds i8, i8* %2, i64 %262
store i8 %261, i8* %263
%264 = add nsw i64 %244, -4
%265 = icmp eq i64 %259, 0
br i1 %265, label %187, label %243
266: ; preds = %240, %266
%267 = phi i64 [ %272, %266 ], [ %241, %240 ]
%268 = phi i64 [ %273, %266 ], [ %242, %240 ]
%269 = getelementptr inbounds [20 x i8], [20 x i8]* %4, i64 0, i64 %268
%270 = load i8, i8* %269
%271 = getelementptr inbounds i8, i8* %2, i64 %267
store i8 %270, i8* %271
%272 = add nuw nsw i64 %267, 1
%273 = add nsw i64 %268, -1
%274 = icmp eq i64 %272, %192
br i1 %274, label %275, label %266
275: ; preds = %266, %216, %238, %3, %27
ret void
}