#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 /*<<< orphan*/ panic_buffer_overflow();
int make_string(char *to, char *from, int length, int ladjust, int max_buf) {
  int len = 0;
  char *t = from;
  while (*t++) {
    len++;
  }
  if (length < len) {
    length = len;
  }
  if (length > max_buf) {
    panic_buffer_overflow();
  }
  if (ladjust) {
    int i;
    for (i = 0; i < len; i++) {
      to[i] = from[i];
    }
    for (; i < length; i++) {
      to[i] = ' ';
    }
  } else {
    int i;
    for (i = 0; i < length - len; i++) {
      to[i] = ' ';
    }
    for (i = length - len; i < length; i++) {
      to[i] = from[i - length + len];
    }
  }
  return length;
}


x86 assembly (clang, -O0):
<make_string>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
cmpb   $0x0,(%rax)
je     115f <make_string+0x4f>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1139 <make_string+0x29>
mov    -0x14(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1171 <make_string+0x61>
mov    -0x20(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jle    1184 <make_string+0x74>
mov    $0x0,%al
call   1030 <panic_buffer_overflow@plt>
cmpl   $0x0,-0x18(%rbp)
je     11f5 <make_string+0xe5>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    11c5 <make_string+0xb5>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1195 <make_string+0x85>
jmp    11ca <make_string+0xba>
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11f0 <make_string+0xe0>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movb   $0x20,(%rax,%rcx,1)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11ca <make_string+0xba>
jmp    126d <make_string+0x15d>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    -0x20(%rbp),%ecx
cmp    %ecx,%eax
jge    1227 <make_string+0x117>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movb   $0x20,(%rax,%rcx,1)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11fc <make_string+0xec>
mov    -0x14(%rbp),%eax
sub    -0x20(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1268 <make_string+0x158>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    -0x14(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1230 <make_string+0x120>
jmp    126d <make_string+0x15d>
mov    -0x14(%rbp),%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<make_string>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %ecx,%ebp
mov    %edx,%r13d
mov    %rsi,%r15
mov    %rdi,%r14
cmpb   $0x0,(%rsi)
je     114e <make_string+0x2e>
xor    %ebx,%ebx
nopl   (%rax)
cmpb   $0x0,0x1(%r15,%rbx,1)
lea    0x1(%rbx),%rbx
jne    1140 <make_string+0x20>
jmp    1150 <make_string+0x30>
xor    %ebx,%ebx
cmp    %r13d,%ebx
mov    %r13d,%r12d
cmovg  %ebx,%r12d
cmp    %r8d,%r12d
jle    1166 <make_string+0x46>
xor    %eax,%eax
call   1030 <panic_buffer_overflow@plt>
test   %ebp,%ebp
je     122d <make_string+0x10d>
mov    %ebx,%r8d
test   %ebx,%ebx
je     1203 <make_string+0xe3>
cmp    $0x8,%ebx
jb     1198 <make_string+0x78>
lea    (%r15,%r8,1),%rcx
cmp    %r14,%rcx
jbe    12ea <make_string+0x1ca>
lea    (%r14,%r8,1),%rcx
cmp    %r15,%rcx
jbe    12ea <make_string+0x1ca>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %r8,%rdx
mov    %r8,%rsi
and    $0x3,%rsi
je     11c3 <make_string+0xa3>
nopl   0x0(%rax)
movzbl (%r15,%rcx,1),%eax
mov    %al,(%r14,%rcx,1)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    11b0 <make_string+0x90>
cmp    $0x3,%rdx
jb     1203 <make_string+0xe3>
nopl   0x0(%rax)
movzbl (%r15,%rcx,1),%eax
mov    %al,(%r14,%rcx,1)
movzbl 0x1(%r15,%rcx,1),%eax
mov    %al,0x1(%r14,%rcx,1)
movzbl 0x2(%r15,%rcx,1),%eax
mov    %al,0x2(%r14,%rcx,1)
movzbl 0x3(%r15,%rcx,1),%eax
mov    %al,0x3(%r14,%rcx,1)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    11d0 <make_string+0xb0>
cmp    %r13d,%ebx
jge    12d8 <make_string+0x1b8>
add    %r8,%r14
not    %ebx
add    %r12d,%ebx
add    $0x1,%rbx
mov    %r14,%rdi
mov    $0x20,%esi
mov    %rbx,%rdx
call   1040 <memset@plt>
jmp    12d8 <make_string+0x1b8>
mov    %r12d,%ebp
sub    %ebx,%ebp
test   %ebp,%ebp
jle    124e <make_string+0x12e>
mov    %ebx,%edx
not    %edx
add    %r12d,%edx
add    $0x1,%rdx
mov    %r14,%rdi
mov    $0x20,%esi
call   1040 <memset@plt>
test   %ebx,%ebx
jle    12d8 <make_string+0x1b8>
movslq %ebp,%r11
movslq %r12d,%rax
lea    0x1(%r11),%r10
cmp    %rax,%r10
mov    %rax,%rdi
cmovg  %r10,%rdi
sub    %r11,%rdi
cmp    $0x8,%rdi
jb     12b3 <make_string+0x193>
cmp    %rax,%r10
mov    %rax,%rcx
cmovg  %r10,%rcx
mov    %r11,%rdx
not    %rdx
add    %rcx,%rdx
cmp    $0x7fffffff,%rdx
ja     12b3 <make_string+0x193>
cmp    %rax,%r10
mov    %rax,%rcx
cmovg  %r10,%rcx
lea    (%r14,%r11,1),%rdx
mov    %rcx,%rsi
sub    %r11,%rsi
add    %r15,%rsi
cmp    %rsi,%rdx
jae    131d <make_string+0x1fd>
add    %r14,%rcx
cmp    %r15,%rcx
jbe    131d <make_string+0x1fd>
mov    %r11,%rdi
sub    %r12d,%ebx
nopl   0x0(%rax)
lea    (%rbx,%rdi,1),%ecx
movslq %ecx,%rcx
movzbl (%r15,%rcx,1),%ecx
mov    %cl,(%r14,%rdi,1)
add    $0x1,%rdi
cmp    %rax,%rdi
jl     12c0 <make_string+0x1a0>
mov    %r12d,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
cmp    $0x20,%ebx
jae    12f6 <make_string+0x1d6>
xor    %ecx,%ecx
jmp    13fe <make_string+0x2de>
mov    %r8d,%ecx
and    $0xffffffe0,%ecx
lea    -0x20(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x5,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x60,%rdi
jae    132f <make_string+0x20f>
xor    %edi,%edi
jmp    13a8 <make_string+0x288>
cmp    $0x20,%rdi
jae    142f <make_string+0x30f>
xor    %r9d,%r9d
jmp    1504 <make_string+0x3e4>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
movups (%r15,%rdi,1),%xmm0
movups 0x10(%r15,%rdi,1),%xmm1
movups %xmm0,(%r14,%rdi,1)
movups %xmm1,0x10(%r14,%rdi,1)
movups 0x20(%r15,%rdi,1),%xmm0
movups 0x30(%r15,%rdi,1),%xmm1
movups %xmm0,0x20(%r14,%rdi,1)
movups %xmm1,0x30(%r14,%rdi,1)
movups 0x40(%r15,%rdi,1),%xmm0
movups 0x50(%r15,%rdi,1),%xmm1
movups %xmm0,0x40(%r14,%rdi,1)
movups %xmm1,0x50(%r14,%rdi,1)
movups 0x60(%r15,%rdi,1),%xmm0
movups 0x70(%r15,%rdi,1),%xmm1
movups %xmm0,0x60(%r14,%rdi,1)
movups %xmm1,0x70(%r14,%rdi,1)
sub    $0xffffffffffffff80,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1340 <make_string+0x220>
test   %rdx,%rdx
je     13eb <make_string+0x2cb>
lea    (%r14,%rdi,1),%rsi
add    $0x10,%rsi
add    %r15,%rdi
add    $0x10,%rdi
shl    $0x5,%rdx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x10(%rdi,%rbp,1),%xmm0
movups (%rdi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rsi,%rbp,1)
movups %xmm1,(%rsi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rdx
jne    13d0 <make_string+0x2b0>
cmp    %r8,%rcx
je     1203 <make_string+0xe3>
test   $0x18,%r8b
je     119a <make_string+0x7a>
mov    %rcx,%rdx
mov    %r8d,%ecx
and    $0xfffffff8,%ecx
nopw   0x0(%rax,%rax,1)
mov    (%r15,%rdx,1),%rsi
mov    %rsi,(%r14,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%rcx
jne    1410 <make_string+0x2f0>
cmp    %r8,%rcx
je     1203 <make_string+0xe3>
jmp    119a <make_string+0x7a>
mov    %rdi,%r9
and    $0xffffffffffffffe0,%r9
lea    -0x20(%r9),%rcx
mov    %rcx,%rdx
shr    $0x5,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
mov    %rdx,(%rsp)
je     14d0 <make_string+0x3b0>
movabs $0xffffffffffffffc,%rsi
ff ff 0f
or     $0x2,%rsi
and    %rdx,%rsi
lea    (%r11,%r14,1),%rcx
add    $0x30,%rcx
xor    %r13d,%r13d
movabs $0x4000000000,%r8
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
mov    %r13,%rdx
sar    $0x20,%rdx
movups (%r15,%rdx,1),%xmm0
movups 0x10(%r15,%rdx,1),%xmm1
movups %xmm0,-0x30(%rcx,%rbp,1)
movups %xmm1,-0x20(%rcx,%rbp,1)
movabs $0x2000000000,%rdx
add    %r13,%rdx
sar    $0x20,%rdx
movups (%r15,%rdx,1),%xmm0
movups 0x10(%r15,%rdx,1),%xmm1
movups %xmm0,-0x10(%rcx,%rbp,1)
movups %xmm1,(%rcx,%rbp,1)
add    $0x40,%rbp
add    %r8,%r13
add    $0xfffffffffffffffe,%rsi
jne    1480 <make_string+0x360>
jmp    14d2 <make_string+0x3b2>
xor    %ebp,%ebp
testb  $0x1,(%rsp)
je     14f5 <make_string+0x3d5>
lea    (%r11,%rbp,1),%rcx
movslq %ebp,%rdx
movups (%r15,%rdx,1),%xmm0
movups 0x10(%r15,%rdx,1),%xmm1
movups %xmm0,(%r14,%rcx,1)
movups %xmm1,0x10(%r14,%rcx,1)
cmp    %r9,%rdi
je     12d8 <make_string+0x1b8>
test   $0x18,%dil
je     1569 <make_string+0x449>
cmp    %rax,%r10
cmovle %rax,%r10
sub    %r11,%r10
mov    %r10,%r8
and    $0xfffffffffffffff8,%r8
lea    (%r8,%r11,1),%rdi
mov    %r9,%rcx
shl    $0x20,%rcx
mov    %r8,%rsi
sub    %r9,%rsi
add    %r11,%r9
add    %r14,%r9
xor    %ebp,%ebp
movabs $0x800000000,%r11
nopl   0x0(%rax,%rax,1)
mov    %rcx,%rdx
sar    $0x20,%rdx
mov    (%r15,%rdx,1),%rdx
mov    %rdx,(%r9,%rbp,1)
add    %r11,%rcx
add    $0x8,%rbp
cmp    %rbp,%rsi
jne    1540 <make_string+0x420>
cmp    %r8,%r10
jne    12b6 <make_string+0x196>
jmp    12d8 <make_string+0x1b8>
add    %r11,%r9
mov    %r9,%rdi
jmp    12b6 <make_string+0x196>

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

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