#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 ioLoadFunctionFrom(char *, char *);
int ioLoadExternalFunctionOfLengthFromModuleOfLength(int functionNameIndex,
                                                     int functionNameLength,
                                                     int moduleNameIndex,
                                                     int moduleNameLength) {
  char functionName[256];
  char moduleName[256];
  int i;
  if (functionNameLength > 255 || moduleNameLength > 255)
    return 0;
  for (i = 0; i < functionNameLength; i++)
    functionName[i] = ((char *)functionNameIndex)[i];
  functionName[functionNameLength] = 0;
  for (i = 0; i < moduleNameLength; i++)
    moduleName[i] = ((char *)moduleNameIndex)[i];
  moduleName[moduleNameLength] = 0;
  return ioLoadFunctionFrom(functionName, moduleName);
}


x86 assembly (clang, -O0):
<ioLoadExternalFunctionOfLengthFromModuleOfLength>:
push   %rbp
mov    %rsp,%rbp
sub    $0x230,%rsp
mov    %edi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
cmpl   $0xff,-0xc(%rbp)
jg     1141 <ioLoadExternalFunctionOfLengthFromModuleOfLength+0x31>
cmpl   $0xff,-0x14(%rbp)
jle    114d <ioLoadExternalFunctionOfLengthFromModuleOfLength+0x3d>
movl   $0x0,-0x4(%rbp)
jmp    120d <ioLoadExternalFunctionOfLengthFromModuleOfLength+0xfd>
movl   $0x0,-0x224(%rbp)
mov    -0x224(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1196 <ioLoadExternalFunctionOfLengthFromModuleOfLength+0x86>
movslq -0x8(%rbp),%rax
movslq -0x224(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
movslq -0x224(%rbp),%rax
mov    %cl,-0x120(%rbp,%rax,1)
mov    -0x224(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x224(%rbp)
jmp    1157 <ioLoadExternalFunctionOfLengthFromModuleOfLength+0x47>
movslq -0xc(%rbp),%rax
movb   $0x0,-0x120(%rbp,%rax,1)
movl   $0x0,-0x224(%rbp)
mov    -0x224(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11eb <ioLoadExternalFunctionOfLengthFromModuleOfLength+0xdb>
movslq -0x10(%rbp),%rax
movslq -0x224(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
movslq -0x224(%rbp),%rax
mov    %cl,-0x220(%rbp,%rax,1)
mov    -0x224(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x224(%rbp)
jmp    11ac <ioLoadExternalFunctionOfLengthFromModuleOfLength+0x9c>
movslq -0x14(%rbp),%rax
movb   $0x0,-0x220(%rbp,%rax,1)
lea    -0x120(%rbp),%rdi
lea    -0x220(%rbp),%rsi
call   1030 <ioLoadFunctionFrom@plt>
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x230,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ioLoadExternalFunctionOfLengthFromModuleOfLength>:
xor    %eax,%eax
cmp    $0xff,%esi
jg     12aa <ioLoadExternalFunctionOfLengthFromModuleOfLength+0x19a>
cmp    $0xff,%ecx
jg     12aa <ioLoadExternalFunctionOfLengthFromModuleOfLength+0x19a>
sub    $0x208,%rsp
test   %esi,%esi
jle    11d3 <ioLoadExternalFunctionOfLengthFromModuleOfLength+0xc3>
movslq %edi,%r10
mov    %esi,%r8d
cmp    $0x8,%esi
jb     1161 <ioLoadExternalFunctionOfLengthFromModuleOfLength+0x51>
lea    (%r10,%r8,1),%rax
mov    %rsp,%rdi
cmp    %rax,%rdi
jae    12ab <ioLoadExternalFunctionOfLengthFromModuleOfLength+0x19b>
lea    (%rsp,%r8,1),%rax
cmp    %r10,%rax
jbe    12ab <ioLoadExternalFunctionOfLengthFromModuleOfLength+0x19b>
xor    %r11d,%r11d
mov    %r11,%r9
not    %r9
add    %r8,%r9
mov    %r8,%rdi
and    $0x3,%rdi
je     1193 <ioLoadExternalFunctionOfLengthFromModuleOfLength+0x83>
cs nopw 0x0(%rax,%rax,1)
movzbl (%r10,%r11,1),%eax
mov    %al,(%rsp,%r11,1)
add    $0x1,%r11
add    $0xffffffffffffffff,%rdi
jne    1180 <ioLoadExternalFunctionOfLengthFromModuleOfLength+0x70>
cmp    $0x3,%r9
jb     11d3 <ioLoadExternalFunctionOfLengthFromModuleOfLength+0xc3>
nopl   0x0(%rax)
movzbl (%r10,%r11,1),%eax
mov    %al,(%rsp,%r11,1)
movzbl 0x1(%r10,%r11,1),%eax
mov    %al,0x1(%rsp,%r11,1)
movzbl 0x2(%r10,%r11,1),%eax
mov    %al,0x2(%rsp,%r11,1)
movzbl 0x3(%r10,%r11,1),%eax
mov    %al,0x3(%rsp,%r11,1)
add    $0x4,%r11
cmp    %r11,%r8
jne    11a0 <ioLoadExternalFunctionOfLengthFromModuleOfLength+0x90>
movslq %esi,%rax
movb   $0x0,(%rsp,%rax,1)
test   %ecx,%ecx
jle    1288 <ioLoadExternalFunctionOfLengthFromModuleOfLength+0x178>
movslq %edx,%rax
mov    %ecx,%r9d
cmp    $0x8,%ecx
jb     1216 <ioLoadExternalFunctionOfLengthFromModuleOfLength+0x106>
lea    (%rax,%r9,1),%rdx
lea    0x100(%rsp),%rsi
cmp    %rdx,%rsi
jae    12b8 <ioLoadExternalFunctionOfLengthFromModuleOfLength+0x1a8>
lea    (%rsp,%r9,1),%rdx
add    $0x100,%rdx
cmp    %rax,%rdx
jbe    12b8 <ioLoadExternalFunctionOfLengthFromModuleOfLength+0x1a8>
xor    %esi,%esi
mov    %rsi,%r8
not    %r8
add    %r9,%r8
mov    %r9,%rdi
and    $0x3,%rdi
je     1245 <ioLoadExternalFunctionOfLengthFromModuleOfLength+0x135>
nopw   0x0(%rax,%rax,1)
movzbl (%rax,%rsi,1),%edx
mov    %dl,0x100(%rsp,%rsi,1)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rdi
jne    1230 <ioLoadExternalFunctionOfLengthFromModuleOfLength+0x120>
cmp    $0x3,%r8
jb     1288 <ioLoadExternalFunctionOfLengthFromModuleOfLength+0x178>
nopl   0x0(%rax,%rax,1)
movzbl (%rax,%rsi,1),%edx
mov    %dl,0x100(%rsp,%rsi,1)
movzbl 0x1(%rax,%rsi,1),%edx
mov    %dl,0x101(%rsp,%rsi,1)
movzbl 0x2(%rax,%rsi,1),%edx
mov    %dl,0x102(%rsp,%rsi,1)
movzbl 0x3(%rax,%rsi,1),%edx
mov    %dl,0x103(%rsp,%rsi,1)
add    $0x4,%rsi
cmp    %rsi,%r9
jne    1250 <ioLoadExternalFunctionOfLengthFromModuleOfLength+0x140>
movslq %ecx,%rax
movb   $0x0,0x100(%rsp,%rax,1)
mov    %rsp,%rdi
lea    0x100(%rsp),%rsi
call   1030 <ioLoadFunctionFrom@plt>
add    $0x208,%rsp
ret
cmp    $0x20,%esi
jae    12c8 <ioLoadExternalFunctionOfLengthFromModuleOfLength+0x1b8>
xor    %r11d,%r11d
jmp    13c9 <ioLoadExternalFunctionOfLengthFromModuleOfLength+0x2b9>
cmp    $0x20,%ecx
jae    13ff <ioLoadExternalFunctionOfLengthFromModuleOfLength+0x2ef>
xor    %esi,%esi
jmp    14f0 <ioLoadExternalFunctionOfLengthFromModuleOfLength+0x3e0>
mov    %r8d,%r11d
and    $0xffffffe0,%r11d
movups (%r10),%xmm0
movups 0x10(%r10),%xmm1
movaps %xmm0,(%rsp)
movaps %xmm1,0x10(%rsp)
cmp    $0x20,%r11
je     13b6 <ioLoadExternalFunctionOfLengthFromModuleOfLength+0x2a6>
movups 0x20(%r10),%xmm0
movups 0x30(%r10),%xmm1
movaps %xmm0,0x20(%rsp)
movaps %xmm1,0x30(%rsp)
cmp    $0x40,%r11d
je     13b6 <ioLoadExternalFunctionOfLengthFromModuleOfLength+0x2a6>
movups 0x40(%r10),%xmm0
movups 0x50(%r10),%xmm1
movaps %xmm0,0x40(%rsp)
movaps %xmm1,0x50(%rsp)
cmp    $0x60,%r11d
je     13b6 <ioLoadExternalFunctionOfLengthFromModuleOfLength+0x2a6>
movups 0x60(%r10),%xmm0
movups 0x70(%r10),%xmm1
movaps %xmm0,0x60(%rsp)
movaps %xmm1,0x70(%rsp)
cmp    $0x80,%r11d
je     13b6 <ioLoadExternalFunctionOfLengthFromModuleOfLength+0x2a6>
movups 0x80(%r10),%xmm0
movups 0x90(%r10),%xmm1
movaps %xmm0,0x80(%rsp)
movaps %xmm1,0x90(%rsp)
cmp    $0xa0,%r11d
je     13b6 <ioLoadExternalFunctionOfLengthFromModuleOfLength+0x2a6>
movups 0xa0(%r10),%xmm0
movups 0xb0(%r10),%xmm1
movaps %xmm0,0xa0(%rsp)
movaps %xmm1,0xb0(%rsp)
cmp    $0xc0,%r11d
je     13b6 <ioLoadExternalFunctionOfLengthFromModuleOfLength+0x2a6>
movups 0xc0(%r10),%xmm0
movups 0xd0(%r10),%xmm1
movaps %xmm0,0xc0(%rsp)
movaps %xmm1,0xd0(%rsp)
cmp    %r8,%r11
je     11d3 <ioLoadExternalFunctionOfLengthFromModuleOfLength+0xc3>
test   $0x18,%r8b
je     1164 <ioLoadExternalFunctionOfLengthFromModuleOfLength+0x54>
mov    %r11,%r9
mov    %r8d,%r11d
and    $0xfffffff8,%r11d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%r10,%r9,1),%rax
mov    %rax,(%rsp,%r9,1)
add    $0x8,%r9
cmp    %r9,%r11
jne    13e0 <ioLoadExternalFunctionOfLengthFromModuleOfLength+0x2d0>
cmp    %r8,%r11
je     11d3 <ioLoadExternalFunctionOfLengthFromModuleOfLength+0xc3>
jmp    1164 <ioLoadExternalFunctionOfLengthFromModuleOfLength+0x54>
mov    %r9d,%esi
and    $0xffffffe0,%esi
lea    -0x20(%rsi),%rdx
mov    %rdx,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %edi,%r8d
and    $0x3,%r8d
cmp    $0x60,%rdx
jae    1428 <ioLoadExternalFunctionOfLengthFromModuleOfLength+0x318>
xor    %edx,%edx
jmp    14a1 <ioLoadExternalFunctionOfLengthFromModuleOfLength+0x391>
and    $0xfffffffffffffffc,%rdi
xor    %edx,%edx
xchg   %ax,%ax
movups (%rax,%rdx,1),%xmm0
movups 0x10(%rax,%rdx,1),%xmm1
movaps %xmm0,0x100(%rsp,%rdx,1)
movaps %xmm1,0x110(%rsp,%rdx,1)
movups 0x20(%rax,%rdx,1),%xmm0
movups 0x30(%rax,%rdx,1),%xmm1
movaps %xmm0,0x120(%rsp,%rdx,1)
movaps %xmm1,0x130(%rsp,%rdx,1)
movups 0x40(%rax,%rdx,1),%xmm0
movups 0x50(%rax,%rdx,1),%xmm1
movaps %xmm0,0x140(%rsp,%rdx,1)
movaps %xmm1,0x150(%rsp,%rdx,1)
movups 0x60(%rax,%rdx,1),%xmm0
movups 0x70(%rax,%rdx,1),%xmm1
movaps %xmm0,0x160(%rsp,%rdx,1)
movaps %xmm1,0x170(%rsp,%rdx,1)
sub    $0xffffffffffffff80,%rdx
add    $0xfffffffffffffffc,%rdi
jne    1430 <ioLoadExternalFunctionOfLengthFromModuleOfLength+0x320>
test   %r8,%r8
je     14dd <ioLoadExternalFunctionOfLengthFromModuleOfLength+0x3cd>
lea    (%rsp,%rdx,1),%r10
add    $0x110,%r10
add    %rax,%rdx
add    $0x10,%rdx
shl    $0x5,%r8
xor    %edi,%edi
xchg   %ax,%ax
movups -0x10(%rdx,%rdi,1),%xmm0
movups (%rdx,%rdi,1),%xmm1
movaps %xmm0,-0x10(%r10,%rdi,1)
movaps %xmm1,(%r10,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r8
jne    14c0 <ioLoadExternalFunctionOfLengthFromModuleOfLength+0x3b0>
cmp    %r9,%rsi
je     1288 <ioLoadExternalFunctionOfLengthFromModuleOfLength+0x178>
test   $0x18,%r9b
je     1218 <ioLoadExternalFunctionOfLengthFromModuleOfLength+0x108>
mov    %rsi,%rdx
mov    %r9d,%esi
and    $0xfffffff8,%esi
nopl   0x0(%rax)
mov    (%rax,%rdx,1),%rdi
mov    %rdi,0x100(%rsp,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%rsi
jne    1500 <ioLoadExternalFunctionOfLengthFromModuleOfLength+0x3f0>
cmp    %r9,%rsi
je     1288 <ioLoadExternalFunctionOfLengthFromModuleOfLength+0x178>
jmp    1218 <ioLoadExternalFunctionOfLengthFromModuleOfLength+0x108>

LLVM IR (-O0):
define i32 @ioLoadExternalFunctionOfLengthFromModuleOfLength(i32 %0, i32 %1, i32 %2, i32 %3) {
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca [256 x i8]
%11 = alloca [256 x i8]
%12 = alloca i32
store i32 %0, i32* %6
store i32 %1, i32* %7
store i32 %2, i32* %8
store i32 %3, i32* %9
%13 = load i32, i32* %7
%14 = icmp sgt i32 %13, 255
br i1 %14, label %18, label %15
15: ; preds = %4
%16 = load i32, i32* %9
%17 = icmp sgt i32 %16, 255
br i1 %17, label %18, label %19
18: ; preds = %15, %4
store i32 0, i32* %5
br label %67
19: ; preds = %15
store i32 0, i32* %12
br label %20
20: ; preds = %35, %19
%21 = load i32, i32* %12
%22 = load i32, i32* %7
%23 = icmp slt i32 %21, %22
br i1 %23, label %24, label %38
24: ; preds = %20
%25 = load i32, i32* %6
%26 = sext i32 %25 to i64
%27 = inttoptr i64 %26 to i8*
%28 = load i32, i32* %12
%29 = sext i32 %28 to i64
%30 = getelementptr inbounds i8, i8* %27, i64 %29
%31 = load i8, i8* %30
%32 = load i32, i32* %12
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds [256 x i8], [256 x i8]* %10, i64 0, i64 %33
store i8 %31, i8* %34
br label %35
35: ; preds = %24
%36 = load i32, i32* %12
%37 = add nsw i32 %36, 1
store i32 %37, i32* %12
br label %20
38: ; preds = %20
%39 = load i32, i32* %7
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds [256 x i8], [256 x i8]* %10, i64 0, i64 %40
store i8 0, i8* %41
store i32 0, i32* %12
br label %42
42: ; preds = %57, %38
%43 = load i32, i32* %12
%44 = load i32, i32* %9
%45 = icmp slt i32 %43, %44
br i1 %45, label %46, label %60
46: ; preds = %42
%47 = load i32, i32* %8
%48 = sext i32 %47 to i64
%49 = inttoptr i64 %48 to i8*
%50 = load i32, i32* %12
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds i8, i8* %49, i64 %51
%53 = load i8, i8* %52
%54 = load i32, i32* %12
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds [256 x i8], [256 x i8]* %11, i64 0, i64 %55
store i8 %53, i8* %56
br label %57
57: ; preds = %46
%58 = load i32, i32* %12
%59 = add nsw i32 %58, 1
store i32 %59, i32* %12
br label %42
60: ; preds = %42
%61 = load i32, i32* %9
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds [256 x i8], [256 x i8]* %11, i64 0, i64 %62
store i8 0, i8* %63
%64 = getelementptr inbounds [256 x i8], [256 x i8]* %10, i64 0, i64 0
%65 = getelementptr inbounds [256 x i8], [256 x i8]* %11, i64 0, i64 0
%66 = call i32 @ioLoadFunctionFrom(i8* %64, i8* %65)
store i32 %66, i32* %5
br label %67
67: ; preds = %60, %18
%68 = load i32, i32* %5
ret i32 %68
}

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