#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 IFF_join(char **, unsigned int, char *);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *);
int /*<<< orphan*/ free(char **);
int getopt(int, char **, char *);
scalar_t__ malloc(unsigned int);
char *optarg;
int optind;
int /*<<< orphan*/ printUsage(char *);
int /*<<< orphan*/ printVersion(char *);
int /*<<< orphan*/ stderr;
int main(int argc, char *argv[]) {
  char *outputFilename = NULL;
  int c;
  while ((c = getopt(argc, argv, "o:hv")) != -1) {
    switch (c) {
    case 'o':
      outputFilename = optarg;
      break;
    case 'h':
      printUsage(argv[0]);
      return 0;
    case '?':
      printUsage(argv[0]);
      return 1;
    case 'v':
      printVersion(argv[0]);
      return 0;
    }
  }
  if (optind >= argc) {
    fprintf(stderr, "ERROR: No IFF input files given!\n");
    return 1;
  } else {
    unsigned int inputFilenamesLength = argc - optind;
    char **inputFilenames =
        (char **)malloc(inputFilenamesLength * sizeof(char *));
    unsigned int i;
    int status;
    for (i = 0; i < inputFilenamesLength; i++)
      inputFilenames[i] = argv[optind + i];
    status = IFF_join(inputFilenames, inputFilenamesLength, outputFilename);
    free(inputFilenames);
    return status;
  }
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movq   $0x0,-0x18(%rbp)
mov    -0x8(%rbp),%edi
mov    -0x10(%rbp),%rsi
lea    0xe64(%rip),%rdx
call   1090 <getopt@plt>
mov    %eax,-0x1c(%rbp)
cmp    $0xffffffff,%eax
je     1254 <main+0xe4>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x34(%rbp)
sub    $0x3f,%eax
je     121f <main+0xaf>
jmp    11c1 <main+0x51>
mov    -0x34(%rbp),%eax
sub    $0x68,%eax
je     1207 <main+0x97>
jmp    11d2 <main+0x62>
mov    -0x34(%rbp),%eax
sub    $0x6f,%eax
je     11f4 <main+0x84>
jmp    11e3 <main+0x73>
mov    -0x34(%rbp),%eax
sub    $0x76,%eax
je     1237 <main+0xc7>
jmp    124f <main+0xdf>
mov    0x2dfd(%rip),%rax
mov    (%rax),%rax
mov    %rax,-0x18(%rbp)
jmp    124f <main+0xdf>
mov    -0x10(%rbp),%rax
mov    (%rax),%rdi
call   1080 <printUsage@plt>
movl   $0x0,-0x4(%rbp)
jmp    130c <main+0x19c>
mov    -0x10(%rbp),%rax
mov    (%rax),%rdi
call   1080 <printUsage@plt>
movl   $0x1,-0x4(%rbp)
jmp    130c <main+0x19c>
mov    -0x10(%rbp),%rax
mov    (%rax),%rdi
call   1060 <printVersion@plt>
movl   $0x0,-0x4(%rbp)
jmp    130c <main+0x19c>
jmp    118e <main+0x1e>
mov    0x2d85(%rip),%rax
mov    (%rax),%eax
cmp    -0x8(%rbp),%eax
jl     1287 <main+0x117>
mov    0x2d63(%rip),%rax
mov    (%rax),%edi
lea    0xd8f(%rip),%rsi
call   1050 <fprintf@plt>
movl   $0x1,-0x4(%rbp)
jmp    130c <main+0x19c>
mov    -0x8(%rbp),%eax
mov    0x2d4f(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0x3,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jae    12ea <main+0x17a>
mov    -0x10(%rbp),%rax
mov    0x2d1a(%rip),%rcx
mov    (%rcx),%ecx
add    -0x2c(%rbp),%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,8),%rdx
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %rdx,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    12af <main+0x13f>
mov    -0x28(%rbp),%rdi
mov    -0x20(%rbp),%esi
mov    -0x18(%rbp),%rdx
call   1040 <IFF_join@plt>
mov    %eax,-0x30(%rbp)
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rsi,%r13
mov    %edi,%r14d
xor    %r15d,%r15d
lea    0xe77(%rip),%rbx
mov    0x2e68(%rip),%r12
mov    %r14d,%edi
mov    %r13,%rsi
mov    %rbx,%rdx
call   1090 <getopt@plt>
cmp    $0x67,%eax
jle    11c0 <main+0x50>
cmp    $0x68,%eax
je     11dd <main+0x6d>
cmp    $0x76,%eax
je     11ed <main+0x7d>
cmp    $0x6f,%eax
jne    1190 <main+0x20>
mov    (%r12),%r15
jmp    1190 <main+0x20>
nopl   0x0(%rax,%rax,1)
cmp    $0xffffffff,%eax
je     11fd <main+0x8d>
cmp    $0x3f,%eax
jne    1190 <main+0x20>
mov    0x0(%r13),%rdi
call   1080 <printUsage@plt>
mov    $0x1,%eax
jmp    12e5 <main+0x175>
mov    0x0(%r13),%rdi
call   1080 <printUsage@plt>
xor    %eax,%eax
jmp    12e5 <main+0x175>
mov    0x0(%r13),%rdi
call   1060 <printVersion@plt>
xor    %eax,%eax
jmp    12e5 <main+0x175>
mov    0x2ddc(%rip),%rbx
mov    (%rbx),%eax
cmp    %r14d,%eax
jge    12cb <main+0x15b>
sub    %eax,%r14d
lea    0x0(,%r14,8),%edi
call   1070 <malloc@plt>
mov    %rax,%r12
test   %r14d,%r14d
je     12af <main+0x13f>
mov    (%rbx),%esi
mov    %r14d,%r9d
cmp    $0x4,%r14d
jae    12ef <main+0x17f>
xor    %edx,%edx
mov    %rdx,%rax
not    %rax
add    %r9,%rax
mov    %r9,%rdi
and    $0x3,%rdi
je     1266 <main+0xf6>
xchg   %ax,%ax
lea    (%rsi,%rdx,1),%ecx
mov    0x0(%r13,%rcx,8),%rcx
mov    %rcx,(%r12,%rdx,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    1250 <main+0xe0>
cmp    $0x3,%rax
jb     12af <main+0x13f>
nopl   0x0(%rax)
lea    (%rsi,%rdx,1),%rax
mov    %eax,%ecx
mov    0x0(%r13,%rcx,8),%rcx
mov    %rcx,(%r12,%rdx,8)
lea    0x1(%rax),%ecx
mov    0x0(%r13,%rcx,8),%rcx
mov    %rcx,0x8(%r12,%rdx,8)
lea    0x2(%rax),%ecx
mov    0x0(%r13,%rcx,8),%rcx
mov    %rcx,0x10(%r12,%rdx,8)
add    $0x3,%eax
mov    0x0(%r13,%rax,8),%rax
mov    %rax,0x18(%r12,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%r9
jne    1270 <main+0x100>
mov    %r12,%rdi
mov    %r14d,%esi
mov    %r15,%rdx
call   1040 <IFF_join@plt>
mov    %eax,%ebx
mov    %r12,%rdi
call   1030 <free@plt>
mov    %ebx,%eax
jmp    12e5 <main+0x175>
mov    0x2cfe(%rip),%rax
mov    (%rax),%edi
lea    0xd2a(%rip),%rsi
call   1050 <fprintf@plt>
mov    $0x1,%eax
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret
lea    -0x1(%r9),%rax
xor    %edx,%edx
mov    %esi,%edi
add    %eax,%edi
jb     123c <main+0xcc>
shr    $0x20,%rax
jne    123c <main+0xcc>
lea    (%rsi,%r9,1),%rax
lea    0x0(,%rax,8),%rax
add    %r13,%rax
cmp    %rax,%r12
jae    1335 <main+0x1c5>
lea    (%r12,%r9,8),%rax
lea    0x0(,%rsi,8),%rdx
add    %r13,%rdx
cmp    %rax,%rdx
jb     123a <main+0xca>
mov    %r9d,%edx
and    $0xfffffffc,%edx
lea    -0x4(%rdx),%rax
mov    %rax,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %edi,%r8d
and    $0x3,%r8d
cmp    $0xc,%rax
jae    135b <main+0x1eb>
xor    %ebx,%ebx
jmp    13da <main+0x26a>
and    $0xfffffffffffffffc,%rdi
xor    %ebx,%ebx
mov    %esi,%eax
mov    %eax,%ecx
movups 0x0(%r13,%rcx,8),%xmm0
movups 0x10(%r13,%rcx,8),%xmm1
movups %xmm0,(%r12,%rbx,8)
movups %xmm1,0x10(%r12,%rbx,8)
lea    0x4(%rax),%ecx
movups 0x0(%r13,%rcx,8),%xmm0
movups 0x10(%r13,%rcx,8),%xmm1
movups %xmm0,0x20(%r12,%rbx,8)
movups %xmm1,0x30(%r12,%rbx,8)
lea    0x8(%rax),%ecx
movups 0x0(%r13,%rcx,8),%xmm0
movups 0x10(%r13,%rcx,8),%xmm1
movups %xmm0,0x40(%r12,%rbx,8)
movups %xmm1,0x50(%r12,%rbx,8)
lea    0xc(%rax),%ecx
movups 0x0(%r13,%rcx,8),%xmm0
movups 0x10(%r13,%rcx,8),%xmm1
movups %xmm0,0x60(%r12,%rbx,8)
movups %xmm1,0x70(%r12,%rbx,8)
add    $0x10,%rbx
add    $0x10,%eax
add    $0xfffffffffffffffc,%rdi
jne    1363 <main+0x1f3>
test   %r8,%r8
je     1412 <main+0x2a2>
lea    (%r12,%rbx,8),%rax
add    $0x10,%rax
mov    %esi,%edi
add    %ebx,%edi
shl    $0x2,%r8
xor    %ebx,%ebx
lea    (%rdi,%rbx,1),%ecx
movups 0x0(%r13,%rcx,8),%xmm0
movups 0x10(%r13,%rcx,8),%xmm1
movups %xmm0,-0x10(%rax,%rbx,8)
movups %xmm1,(%rax,%rbx,8)
add    $0x4,%rbx
cmp    %rbx,%r8
jne    13f1 <main+0x281>
cmp    %r9,%rdx
je     12af <main+0x13f>
jmp    123c <main+0xcc>

LLVM IR (-O0):
@.str = [5 x i8] c"o:hv\00"
@optarg = global i8* null
@optind = global i32 0
@stderr = global i32 0
@.str.1 = [34 x i8] c"ERROR: No IFF input files given!\0A\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca i8*
%7 = alloca i32
%8 = alloca i32
%9 = alloca i8**
%10 = alloca i32
%11 = alloca i32
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
store i8* null, i8** %6
br label %12
12: ; preds = %36, %2
%13 = load i32, i32* %4
%14 = load i8**, i8*** %5
%15 = call i32 @getopt(i32 %13, i8** %14, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
store i32 %15, i32* %7
%16 = icmp ne i32 %15, -1
br i1 %16, label %17, label %37
17: ; preds = %12
%18 = load i32, i32* %7
switch i32 %18, label %36 [
i32 111, label %19
i32 104, label %21
i32 63, label %26
i32 118, label %31
]
19: ; preds = %17
%20 = load i8*, i8** @optarg
store i8* %20, i8** %6
br label %36
21: ; preds = %17
%22 = load i8**, i8*** %5
%23 = getelementptr inbounds i8*, i8** %22, i64 0
%24 = load i8*, i8** %23
%25 = call i32 @printUsage(i8* %24)
store i32 0, i32* %3
br label %81
26: ; preds = %17
%27 = load i8**, i8*** %5
%28 = getelementptr inbounds i8*, i8** %27, i64 0
%29 = load i8*, i8** %28
%30 = call i32 @printUsage(i8* %29)
store i32 1, i32* %3
br label %81
31: ; preds = %17
%32 = load i8**, i8*** %5
%33 = getelementptr inbounds i8*, i8** %32, i64 0
%34 = load i8*, i8** %33
%35 = call i32 @printVersion(i8* %34)
store i32 0, i32* %3
br label %81
36: ; preds = %17, %19
br label %12
37: ; preds = %12
%38 = load i32, i32* @optind
%39 = load i32, i32* %4
%40 = icmp sge i32 %38, %39
br i1 %40, label %41, label %44
41: ; preds = %37
%42 = load i32, i32* @stderr
%43 = call i32 @fprintf(i32 %42, i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.1, i64 0, i64 0))
store i32 1, i32* %3
br label %81
44: ; preds = %37
%45 = load i32, i32* %4
%46 = load i32, i32* @optind
%47 = sub nsw i32 %45, %46
store i32 %47, i32* %8
%48 = load i32, i32* %8
%49 = zext i32 %48 to i64
%50 = mul i64 %49, 8
%51 = trunc i64 %50 to i32
%52 = call i64 @malloc(i32 %51)
%53 = inttoptr i64 %52 to i8**
store i8** %53, i8*** %9
store i32 0, i32* %10
br label %54
54: ; preds = %70, %44
%55 = load i32, i32* %10
%56 = load i32, i32* %8
%57 = icmp ult i32 %55, %56
br i1 %57, label %58, label %73
58: ; preds = %54
%59 = load i8**, i8*** %5
%60 = load i32, i32* @optind
%61 = load i32, i32* %10
%62 = add i32 %60, %61
%63 = zext i32 %62 to i64
%64 = getelementptr inbounds i8*, i8** %59, i64 %63
%65 = load i8*, i8** %64
%66 = load i8**, i8*** %9
%67 = load i32, i32* %10
%68 = zext i32 %67 to i64
%69 = getelementptr inbounds i8*, i8** %66, i64 %68
store i8* %65, i8** %69
br label %70
70: ; preds = %58
%71 = load i32, i32* %10
%72 = add i32 %71, 1
store i32 %72, i32* %10
br label %54
73: ; preds = %54
%74 = load i8**, i8*** %9
%75 = load i32, i32* %8
%76 = load i8*, i8** %6
%77 = call i32 @IFF_join(i8** %74, i32 %75, i8* %76)
store i32 %77, i32* %11
%78 = load i8**, i8*** %9
%79 = call i32 @free(i8** %78)
%80 = load i32, i32* %11
store i32 %80, i32* %3
br label %81
81: ; preds = %73, %41, %31, %26, %21
%82 = load i32, i32* %3
ret i32 %82
}

LLVM IR (-O2):
@.str = [5 x i8] c"o:hv\00"
@optarg = global i8* null
@optind = global i32 0
@stderr = global i32 0
@.str.1 = [34 x i8] c"ERROR: No IFF input files given!\0A\00"
define i32 @main(i32 %0, i8** %1) {
br label %3
3: ; preds = %7, %2
%4 = phi i8* [ %8, %7 ], [ null, %2 ]
br label %5
5: ; preds = %3, %5
%6 = tail call i32 @getopt(i32 %0, i8** %1, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
switch i32 %6, label %5 [
i32 -1, label %18
i32 111, label %7
i32 104, label %9
i32 63, label %12
i32 118, label %15
]
7: ; preds = %5
%8 = load i8*, i8** @optarg
br label %3
9: ; preds = %5
%10 = load i8*, i8** %1
%11 = tail call i32 @printUsage(i8* %10)
br label %201
12: ; preds = %5
%13 = load i8*, i8** %1
%14 = tail call i32 @printUsage(i8* %13)
br label %201
15: ; preds = %5
%16 = load i8*, i8** %1
%17 = tail call i32 @printVersion(i8* %16)
br label %201
18: ; preds = %5
%19 = load i32, i32* @optind
%20 = icmp slt i32 %19, %0
br i1 %20, label %24, label %21
21: ; preds = %18
%22 = load i32, i32* @stderr
%23 = tail call i32 @fprintf(i32 %22, i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.1, i64 0, i64 0))
br label %201
24: ; preds = %18
%25 = sub nsw i32 %0, %19
%26 = shl i32 %25, 3
%27 = tail call i64 @malloc(i32 %26)
%28 = inttoptr i64 %27 to i8**
%29 = inttoptr i64 %27 to i8*
%30 = icmp eq i32 %25, 0
br i1 %30, label %198, label %31
31: ; preds = %24
%32 = load i32, i32* @optind
%33 = zext i32 %25 to i64
%34 = icmp ult i32 %25, 4
br i1 %34, label %146, label %35
35: ; preds = %31
%36 = add nsw i64 %33, -1
%37 = trunc i64 %36 to i32
%38 = xor i32 %32, -1
%39 = icmp ult i32 %38, %37
%40 = icmp ugt i64 %36, 4294967295
%41 = or i1 %39, %40
br i1 %41, label %146, label %42
42: ; preds = %35
%43 = getelementptr i8*, i8** %28, i64 %33
%44 = zext i32 %32 to i64
%45 = getelementptr i8*, i8** %1, i64 %44
%46 = add nuw nsw i64 %44, %33
%47 = getelementptr i8*, i8** %1, i64 %46
%48 = bitcast i8** %47 to i8*
%49 = icmp ult i8* %29, %48
%50 = icmp ult i8** %45, %43
%51 = and i1 %49, %50
br i1 %51, label %146, label %52
52: ; preds = %42
%53 = and i64 %33, 4294967292
%54 = add nsw i64 %53, -4
%55 = lshr exact i64 %54, 2
%56 = add nuw nsw i64 %55, 1
%57 = and i64 %56, 3
%58 = icmp ult i64 %54, 12
br i1 %58, label %122, label %59
59: ; preds = %52
%60 = and i64 %56, 9223372036854775804
br label %61
61: ; preds = %61, %59
%62 = phi i64 [ 0, %59 ], [ %119, %61 ]
%63 = phi i64 [ 0, %59 ], [ %120, %61 ]
%64 = trunc i64 %62 to i32
%65 = add i32 %32, %64
%66 = zext i32 %65 to i64
%67 = getelementptr inbounds i8*, i8** %1, i64 %66
%68 = bitcast i8** %67 to <2 x i8*>*
%69 = load <2 x i8*>, <2 x i8*>* %68
%70 = getelementptr inbounds i8*, i8** %67, i64 2
%71 = bitcast i8** %70 to <2 x i8*>*
%72 = load <2 x i8*>, <2 x i8*>* %71
%73 = getelementptr inbounds i8*, i8** %28, i64 %62
%74 = bitcast i8** %73 to <2 x i8*>*
store <2 x i8*> %69, <2 x i8*>* %74
%75 = getelementptr inbounds i8*, i8** %73, i64 2
%76 = bitcast i8** %75 to <2 x i8*>*
store <2 x i8*> %72, <2 x i8*>* %76
%77 = or i64 %62, 4
%78 = trunc i64 %77 to i32
%79 = add i32 %32, %78
%80 = zext i32 %79 to i64
%81 = getelementptr inbounds i8*, i8** %1, i64 %80
%82 = bitcast i8** %81 to <2 x i8*>*
%83 = load <2 x i8*>, <2 x i8*>* %82
%84 = getelementptr inbounds i8*, i8** %81, i64 2
%85 = bitcast i8** %84 to <2 x i8*>*
%86 = load <2 x i8*>, <2 x i8*>* %85
%87 = getelementptr inbounds i8*, i8** %28, i64 %77
%88 = bitcast i8** %87 to <2 x i8*>*
store <2 x i8*> %83, <2 x i8*>* %88
%89 = getelementptr inbounds i8*, i8** %87, i64 2
%90 = bitcast i8** %89 to <2 x i8*>*
store <2 x i8*> %86, <2 x i8*>* %90
%91 = or i64 %62, 8
%92 = trunc i64 %91 to i32
%93 = add i32 %32, %92
%94 = zext i32 %93 to i64
%95 = getelementptr inbounds i8*, i8** %1, i64 %94
%96 = bitcast i8** %95 to <2 x i8*>*
%97 = load <2 x i8*>, <2 x i8*>* %96
%98 = getelementptr inbounds i8*, i8** %95, i64 2
%99 = bitcast i8** %98 to <2 x i8*>*
%100 = load <2 x i8*>, <2 x i8*>* %99
%101 = getelementptr inbounds i8*, i8** %28, i64 %91
%102 = bitcast i8** %101 to <2 x i8*>*
store <2 x i8*> %97, <2 x i8*>* %102
%103 = getelementptr inbounds i8*, i8** %101, i64 2
%104 = bitcast i8** %103 to <2 x i8*>*
store <2 x i8*> %100, <2 x i8*>* %104
%105 = or i64 %62, 12
%106 = trunc i64 %105 to i32
%107 = add i32 %32, %106
%108 = zext i32 %107 to i64
%109 = getelementptr inbounds i8*, i8** %1, i64 %108
%110 = bitcast i8** %109 to <2 x i8*>*
%111 = load <2 x i8*>, <2 x i8*>* %110
%112 = getelementptr inbounds i8*, i8** %109, i64 2
%113 = bitcast i8** %112 to <2 x i8*>*
%114 = load <2 x i8*>, <2 x i8*>* %113
%115 = getelementptr inbounds i8*, i8** %28, i64 %105
%116 = bitcast i8** %115 to <2 x i8*>*
store <2 x i8*> %111, <2 x i8*>* %116
%117 = getelementptr inbounds i8*, i8** %115, i64 2
%118 = bitcast i8** %117 to <2 x i8*>*
store <2 x i8*> %114, <2 x i8*>* %118
%119 = add nuw i64 %62, 16
%120 = add nuw i64 %63, 4
%121 = icmp eq i64 %120, %60
br i1 %121, label %122, label %61
122: ; preds = %61, %52
%123 = phi i64 [ 0, %52 ], [ %119, %61 ]
%124 = icmp eq i64 %57, 0
br i1 %124, label %144, label %125
125: ; preds = %122, %125
%126 = phi i64 [ %141, %125 ], [ %123, %122 ]
%127 = phi i64 [ %142, %125 ], [ 0, %122 ]
%128 = trunc i64 %126 to i32
%129 = add i32 %32, %128
%130 = zext i32 %129 to i64
%131 = getelementptr inbounds i8*, i8** %1, i64 %130
%132 = bitcast i8** %131 to <2 x i8*>*
%133 = load <2 x i8*>, <2 x i8*>* %132
%134 = getelementptr inbounds i8*, i8** %131, i64 2
%135 = bitcast i8** %134 to <2 x i8*>*
%136 = load <2 x i8*>, <2 x i8*>* %135
%137 = getelementptr inbounds i8*, i8** %28, i64 %126
%138 = bitcast i8** %137 to <2 x i8*>*
store <2 x i8*> %133, <2 x i8*>* %138
%139 = getelementptr inbounds i8*, i8** %137, i64 2
%140 = bitcast i8** %139 to <2 x i8*>*
store <2 x i8*> %136, <2 x i8*>* %140
%141 = add nuw i64 %126, 4
%142 = add i64 %127, 1
%143 = icmp eq i64 %142, %57
br i1 %143, label %144, label %125
144: ; preds = %125, %122
%145 = icmp eq i64 %53, %33
br i1 %145, label %198, label %146
146: ; preds = %42, %35, %31, %144
%147 = phi i64 [ 0, %42 ], [ 0, %35 ], [ 0, %31 ], [ %53, %144 ]
%148 = xor i64 %147, -1
%149 = add nsw i64 %148, %33
%150 = and i64 %33, 3
%151 = icmp eq i64 %150, 0
br i1 %151, label %164, label %152
152: ; preds = %146, %152
%153 = phi i64 [ %161, %152 ], [ %147, %146 ]
%154 = phi i64 [ %162, %152 ], [ 0, %146 ]
%155 = trunc i64 %153 to i32
%156 = add i32 %32, %155
%157 = zext i32 %156 to i64
%158 = getelementptr inbounds i8*, i8** %1, i64 %157
%159 = load i8*, i8** %158
%160 = getelementptr inbounds i8*, i8** %28, i64 %153
store i8* %159, i8** %160
%161 = add nuw nsw i64 %153, 1
%162 = add i64 %154, 1
%163 = icmp eq i64 %162, %150
br i1 %163, label %164, label %152
164: ; preds = %152, %146
%165 = phi i64 [ %147, %146 ], [ %161, %152 ]
%166 = icmp ult i64 %149, 3
br i1 %166, label %198, label %167
167: ; preds = %164, %167
%168 = phi i64 [ %196, %167 ], [ %165, %164 ]
%169 = trunc i64 %168 to i32
%170 = add i32 %32, %169
%171 = zext i32 %170 to i64
%172 = getelementptr inbounds i8*, i8** %1, i64 %171
%173 = load i8*, i8** %172
%174 = getelementptr inbounds i8*, i8** %28, i64 %168
store i8* %173, i8** %174
%175 = add nuw nsw i64 %168, 1
%176 = trunc i64 %175 to i32
%177 = add i32 %32, %176
%178 = zext i32 %177 to i64
%179 = getelementptr inbounds i8*, i8** %1, i64 %178
%180 = load i8*, i8** %179
%181 = getelementptr inbounds i8*, i8** %28, i64 %175
store i8* %180, i8** %181
%182 = add nuw nsw i64 %168, 2
%183 = trunc i64 %182 to i32
%184 = add i32 %32, %183
%185 = zext i32 %184 to i64
%186 = getelementptr inbounds i8*, i8** %1, i64 %185
%187 = load i8*, i8** %186
%188 = getelementptr inbounds i8*, i8** %28, i64 %182
store i8* %187, i8** %188
%189 = add nuw nsw i64 %168, 3
%190 = trunc i64 %189 to i32
%191 = add i32 %32, %190
%192 = zext i32 %191 to i64
%193 = getelementptr inbounds i8*, i8** %1, i64 %192
%194 = load i8*, i8** %193
%195 = getelementptr inbounds i8*, i8** %28, i64 %189
store i8* %194, i8** %195
%196 = add nuw nsw i64 %168, 4
%197 = icmp eq i64 %196, %33
br i1 %197, label %198, label %167
198: ; preds = %164, %167, %144, %24
%199 = tail call i32 @IFF_join(i8** %28, i32 %25, i8* %4)
%200 = tail call i32 @free(i8** %28)
br label %201
201: ; preds = %198, %21, %15, %12, %9
%202 = phi i32 [ 0, %15 ], [ 1, %12 ], [ 0, %9 ], [ 1, %21 ], [ %199, %198 ]
ret i32 %202
}