#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 */
typedef int /*<<< orphan*/ zBuf;
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
int EOF;
int /*<<< orphan*/ exit(int);
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, char *);
int getc(int /*<<< orphan*/ *);
scalar_t__ isspace(int);
void *malloc(int);
char **realloc(char **, int);
int /*<<< orphan*/ stderr;
int /*<<< orphan*/ strcpy(char *, char *);
void AddParameters(int index, int *pArgc, char ***pArgv) {
  int argc = *pArgc;
  char **argv = *pArgv;
  int newArgc;
  char **zNew;
  char *zFile;
  int nNew = 0;
  int nAlloc = 0;
  int i;
  int n;
  int c;
  int startOfLine = 1;
  FILE *in;
  char zBuf[1000];
  if (index + 1 == argc)
    return;
  zFile = argv[index + 1];
  in = fopen(zFile, "r");
  if (in == 0) {
    fprintf(stderr, "Can't open input file \"%s\"\n", zFile);
    exit(1);
  }
  c = ' ';
  while (c != EOF) {
    while (c != EOF && isspace(c)) {
      if (c == '\n') {
        startOfLine = 1;
      }
      c = getc(in);
      if (startOfLine && c == '#') {
        while (c != EOF && c != '\n') {
          c = getc(in);
        }
      }
    }
    n = 0;
    while (c != EOF && !isspace(c)) {
      if (n < sizeof(zBuf) - 1) {
        zBuf[n++] = c;
      }
      startOfLine = 0;
      c = getc(in);
    }
    zBuf[n] = 0;
    if (n > 0) {
      nNew++;
      if (nNew + argc > nAlloc) {
        if (nAlloc == 0) {
          nAlloc = 100 + argc;
          zNew = malloc(sizeof(char *) * nAlloc);
        } else {
          nAlloc *= 2;
          zNew = realloc(zNew, sizeof(char *) * nAlloc);
        }
      }
      if (zNew) {
        int j = nNew + index;
        zNew[j] = malloc(n + 1);
        if (zNew[j]) {
          strcpy(zNew[j], zBuf);
        }
      }
    }
  }
  newArgc = argc + nNew - 1;
  for (i = 0; i <= index; i++) {
    zNew[i] = argv[i];
  }
  for (i = nNew + index + 1; i < newArgc; i++) {
    zNew[i] = argv[i + 1 - nNew];
  }
  zNew[newArgc] = 0;
  *pArgc = newArgc;
  *pArgv = zNew;
}


x86 assembly (clang, -O0):
<AddParameters>:
push   %rbp
mov    %rsp,%rbp
sub    $0x460,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x44(%rbp)
movl   $0x0,-0x48(%rbp)
movl   $0x1,-0x58(%rbp)
mov    -0x4(%rbp),%eax
add    $0x1,%eax
cmp    -0x1c(%rbp),%eax
jne    11d3 <AddParameters+0x53>
jmp    1542 <AddParameters+0x3c2>
mov    -0x28(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rdi
lea    0xe0d(%rip),%rsi
call   1080 <fopen@plt>
mov    %rax,-0x60(%rbp)
cmpq   $0x0,-0x60(%rbp)
jne    122a <AddParameters+0xaa>
mov    0x2dca(%rip),%rax
mov    (%rax),%edi
mov    -0x40(%rbp),%rdx
lea    0xde7(%rip),%rsi
call   1050 <fprintf@plt>
mov    $0x1,%edi
call   1090 <exit@plt>
movl   $0x20,-0x54(%rbp)
mov    -0x54(%rbp),%eax
mov    0x2dad(%rip),%rcx
cmp    (%rcx),%eax
je     1493 <AddParameters+0x313>
jmp    1248 <AddParameters+0xc8>
mov    -0x54(%rbp),%ecx
xor    %eax,%eax
mov    0x2d94(%rip),%rdx
cmp    (%rdx),%ecx
mov    %al,-0x455(%rbp)
je     1277 <AddParameters+0xf7>
mov    -0x54(%rbp),%edi
call   1040 <isspace@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x455(%rbp)
mov    -0x455(%rbp),%al
test   $0x1,%al
jne    128a <AddParameters+0x10a>
jmp    1315 <AddParameters+0x195>
cmpl   $0xa,-0x54(%rbp)
jne    129b <AddParameters+0x11b>
movl   $0x1,-0x58(%rbp)
mov    -0x60(%rbp),%rdi
call   10a0 <getc@plt>
mov    %eax,-0x54(%rbp)
cmpl   $0x0,-0x58(%rbp)
je     1310 <AddParameters+0x190>
cmpl   $0x23,-0x54(%rbp)
jne    1310 <AddParameters+0x190>
jmp    12c0 <AddParameters+0x140>
mov    -0x54(%rbp),%ecx
xor    %eax,%eax
mov    0x2d1c(%rip),%rdx
cmp    (%rdx),%ecx
mov    %al,-0x456(%rbp)
je     12e7 <AddParameters+0x167>
cmpl   $0xa,-0x54(%rbp)
setne  %al
mov    %al,-0x456(%rbp)
mov    -0x456(%rbp),%al
test   $0x1,%al
jne    12fa <AddParameters+0x17a>
jmp    130b <AddParameters+0x18b>
mov    -0x60(%rbp),%rdi
call   10a0 <getc@plt>
mov    %eax,-0x54(%rbp)
jmp    12c0 <AddParameters+0x140>
jmp    1310 <AddParameters+0x190>
jmp    1248 <AddParameters+0xc8>
movl   $0x0,-0x50(%rbp)
mov    -0x54(%rbp),%ecx
xor    %eax,%eax
mov    0x2cc0(%rip),%rdx
cmp    (%rdx),%ecx
mov    %al,-0x457(%rbp)
je     134d <AddParameters+0x1cd>
mov    -0x54(%rbp),%edi
call   1040 <isspace@plt>
cmp    $0x0,%rax
setne  %al
xor    $0xff,%al
mov    %al,-0x457(%rbp)
mov    -0x457(%rbp),%al
test   $0x1,%al
jne    1360 <AddParameters+0x1e0>
jmp    13a1 <AddParameters+0x221>
movslq -0x50(%rbp),%rax
cmp    $0x3e7,%rax
jae    1389 <AddParameters+0x209>
mov    -0x54(%rbp),%eax
mov    %al,%cl
mov    -0x50(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x50(%rbp)
cltq
mov    %cl,-0x450(%rbp,%rax,1)
movl   $0x0,-0x58(%rbp)
mov    -0x60(%rbp),%rdi
call   10a0 <getc@plt>
mov    %eax,-0x54(%rbp)
jmp    131c <AddParameters+0x19c>
movslq -0x50(%rbp),%rax
movb   $0x0,-0x450(%rbp,%rax,1)
cmpl   $0x0,-0x50(%rbp)
jle    148e <AddParameters+0x30e>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
add    -0x1c(%rbp),%eax
cmp    -0x48(%rbp),%eax
jle    141f <AddParameters+0x29f>
cmpl   $0x0,-0x48(%rbp)
jne    13fa <AddParameters+0x27a>
mov    -0x1c(%rbp),%eax
add    $0x64,%eax
mov    %eax,-0x48(%rbp)
movslq -0x48(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x38(%rbp)
jmp    141a <AddParameters+0x29a>
mov    -0x48(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x38(%rbp),%rdi
movslq -0x48(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%esi
call   1070 <realloc@plt>
mov    %rax,-0x38(%rbp)
jmp    141f <AddParameters+0x29f>
cmpq   $0x0,-0x38(%rbp)
je     1489 <AddParameters+0x309>
mov    -0x44(%rbp),%eax
add    -0x4(%rbp),%eax
mov    %eax,-0x454(%rbp)
mov    -0x50(%rbp),%edi
add    $0x1,%edi
call   1060 <malloc@plt>
mov    %rax,%rdx
mov    -0x38(%rbp),%rax
movslq -0x454(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
movslq -0x454(%rbp),%rcx
cmpq   $0x0,(%rax,%rcx,8)
je     1484 <AddParameters+0x304>
mov    -0x38(%rbp),%rax
movslq -0x454(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    -0x450(%rbp),%rsi
call   1030 <strcpy@plt>
jmp    1489 <AddParameters+0x309>
jmp    148e <AddParameters+0x30e>
jmp    1231 <AddParameters+0xb1>
mov    -0x1c(%rbp),%eax
add    -0x44(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x2c(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     14d8 <AddParameters+0x358>
mov    -0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x38(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    14a6 <AddParameters+0x326>
mov    -0x44(%rbp),%eax
add    -0x4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    151e <AddParameters+0x39e>
mov    -0x28(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
sub    -0x44(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x38(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    14e4 <AddParameters+0x364>
mov    -0x38(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x38(%rbp),%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
add    $0x460,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<AddParameters>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x438,%rsp
mov    %rdx,%r14
mov    (%rsi),%ecx
lea    0x1(%rdi),%edx
mov    %rcx,%rax
mov    %rcx,0x10(%rsp)
cmp    %ecx,%edx
je     1744 <AddParameters+0x5c4>
mov    %rsi,%rbp
mov    %rdi,0x30(%rsp)
mov    (%r14),%r12
mov    %edx,0x1c(%rsp)
movslq %edx,%rax
mov    (%r12,%rax,8),%r15
lea    0xe3a(%rip),%rsi
mov    %r15,%rdi
call   1080 <fopen@plt>
test   %rax,%rax
je     1767 <AddParameters+0x5e7>
mov    %rax,%rbx
mov    %r12,0x38(%rsp)
mov    %rbp,0x40(%rsp)
mov    0x2dfd(%rip),%rbp
mov    0x0(%rbp),%eax
cmp    $0x20,%eax
mov    %r14,0x48(%rsp)
jne    12d5 <AddParameters+0x155>
xor    %eax,%eax
mov    %rax,0x8(%rsp)
mov    0x8(%rsp),%r12
mov    0x10(%rsp),%rax
lea    (%rax,%r12,1),%r10d
add    $0xffffffff,%r10d
mov    0x30(%rsp),%rbx
test   %ebx,%ebx
mov    0x48(%rsp),%r11
mov    0x40(%rsp),%r14
mov    0x38(%rsp),%r15
js     1574 <AddParameters+0x3f4>
mov    0x1c(%rsp),%eax
mov    %eax,%ecx
cmp    $0x4,%eax
jb     125d <AddParameters+0xdd>
lea    (%r15,%rcx,8),%rax
cmp    %rax,%r13
jae    1496 <AddParameters+0x316>
lea    0x0(,%rcx,8),%rax
add    %r13,%rax
cmp    %rax,%r15
jae    1496 <AddParameters+0x316>
xor    %edx,%edx
mov    %rdx,%rsi
not    %rsi
add    %rcx,%rsi
mov    %rcx,%rax
and    $0x3,%rax
je     1293 <AddParameters+0x113>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%r15,%rdx,8),%rdi
mov    %rdi,0x0(%r13,%rdx,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rax
jne    1280 <AddParameters+0x100>
cmp    $0x3,%rsi
jb     1574 <AddParameters+0x3f4>
nopl   (%rax)
mov    (%r15,%rdx,8),%rax
mov    %rax,0x0(%r13,%rdx,8)
mov    0x8(%r15,%rdx,8),%rax
mov    %rax,0x8(%r13,%rdx,8)
mov    0x10(%r15,%rdx,8),%rax
mov    %rax,0x10(%r13,%rdx,8)
mov    0x18(%r15,%rdx,8),%rax
mov    %rax,0x18(%r13,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%rcx
jne    12a0 <AddParameters+0x120>
jmp    1574 <AddParameters+0x3f4>
mov    0x10(%rsp),%rcx
lea    0x64(%rcx),%edx
mov    %edx,0x2c(%rsp)
lea    0x320(,%rcx,8),%ecx
mov    %ecx,0x28(%rsp)
mov    $0x20,%r14d
mov    $0x1,%r15d
xor    %ecx,%ecx
mov    %rcx,0x8(%rsp)
mov    $0x1,%r12d
xor    %ecx,%ecx
mov    %rcx,0x20(%rsp)
jmp    1330 <AddParameters+0x1b0>
mov    $0x23,%eax
movb   $0x0,0x50(%rsp)
mov    %eax,%r14d
mov    0x0(%rbp),%eax
cmp    %eax,%r14d
je     1203 <AddParameters+0x83>
nopw   0x0(%rax,%rax,1)
cmp    %eax,%r14d
je     1313 <AddParameters+0x193>
mov    %r14d,%edi
call   1040 <isspace@plt>
test   %rax,%rax
je     138b <AddParameters+0x20b>
cmp    $0xa,%r14d
cmove  %r15d,%r12d
mov    %rbx,%rdi
call   10a0 <getc@plt>
mov    %eax,%r14d
mov    0x0(%rbp),%eax
test   %r12d,%r12d
je     1330 <AddParameters+0x1b0>
cmp    $0x23,%r14d
jne    1330 <AddParameters+0x1b0>
cmp    $0x23,%eax
je     130e <AddParameters+0x18e>
nopl   0x0(%rax,%rax,1)
mov    %rbx,%rdi
call   10a0 <getc@plt>
mov    %eax,%r14d
mov    0x0(%rbp),%eax
cmp    $0xa,%r14d
je     1330 <AddParameters+0x1b0>
cmp    %eax,%r14d
jne    1370 <AddParameters+0x1f0>
jmp    1330 <AddParameters+0x1b0>
mov    0x0(%rbp),%eax
cmp    %eax,%r14d
je     1313 <AddParameters+0x193>
mov    %r14d,%edi
call   1040 <isspace@plt>
xor    %r15d,%r15d
test   %rax,%rax
jne    13e5 <AddParameters+0x265>
xor    %r15d,%r15d
cs nopw 0x0(%rax,%rax,1)
cmp    $0x3e6,%r15d
ja     13c5 <AddParameters+0x245>
mov    %r15d,%eax
add    $0x1,%r15d
mov    %r14b,0x50(%rsp,%rax,1)
mov    %rbx,%rdi
call   10a0 <getc@plt>
mov    %eax,%r14d
xor    %r12d,%r12d
cmp    0x0(%rbp),%eax
je     13e5 <AddParameters+0x265>
mov    %r14d,%edi
call   1040 <isspace@plt>
test   %rax,%rax
je     13b0 <AddParameters+0x230>
movslq %r15d,%rax
movb   $0x0,0x50(%rsp,%rax,1)
test   %eax,%eax
jle    148b <AddParameters+0x30b>
mov    0x8(%rsp),%rax
mov    0x10(%rsp),%rcx
add    %ecx,%eax
add    $0x1,%eax
mov    0x20(%rsp),%rsi
cmp    %esi,%eax
jle    1441 <AddParameters+0x2c1>
test   %esi,%esi
je     142c <AddParameters+0x2ac>
lea    (%rsi,%rsi,1),%eax
mov    %eax,0x4(%rsp)
shl    $0x4,%esi
mov    %r13,%rdi
call   1070 <realloc@plt>
mov    %rax,%r13
mov    0x4(%rsp),%eax
jmp    143c <AddParameters+0x2bc>
mov    0x28(%rsp),%edi
call   1060 <malloc@plt>
mov    %rax,%r13
mov    0x2c(%rsp),%eax
mov    %rax,0x20(%rsp)
mov    0x8(%rsp),%rax
add    $0x1,%eax
test   %r13,%r13
mov    %rax,0x8(%rsp)
je     1488 <AddParameters+0x308>
mov    0x30(%rsp),%rcx
add    %ecx,%eax
mov    %eax,0x4(%rsp)
add    $0x1,%r15d
mov    %r15d,%edi
call   1060 <malloc@plt>
movslq 0x4(%rsp),%rcx
mov    %rax,0x0(%r13,%rcx,8)
test   %rax,%rax
je     148b <AddParameters+0x30b>
mov    %rax,%rdi
lea    0x50(%rsp),%rsi
call   1030 <strcpy@plt>
jmp    148b <AddParameters+0x30b>
xor    %r13d,%r13d
mov    $0x1,%r15d
jmp    131b <AddParameters+0x19b>
mov    %ecx,%edx
and    $0xfffffffc,%edx
lea    -0x4(%rdx),%rax
mov    %rax,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %edi,%esi
and    $0x3,%esi
cmp    $0xc,%rax
jae    14b9 <AddParameters+0x339>
xor    %ebp,%ebp
jmp    1529 <AddParameters+0x3a9>
and    $0xfffffffffffffffc,%rdi
xor    %ebp,%ebp
nop
movups (%r15,%rbp,8),%xmm0
movups 0x10(%r15,%rbp,8),%xmm1
movups %xmm0,0x0(%r13,%rbp,8)
movups %xmm1,0x10(%r13,%rbp,8)
movups 0x20(%r15,%rbp,8),%xmm0
movups 0x30(%r15,%rbp,8),%xmm1
movups %xmm0,0x20(%r13,%rbp,8)
movups %xmm1,0x30(%r13,%rbp,8)
movups 0x40(%r15,%rbp,8),%xmm0
movups 0x50(%r15,%rbp,8),%xmm1
movups %xmm0,0x40(%r13,%rbp,8)
movups %xmm1,0x50(%r13,%rbp,8)
movups 0x60(%r15,%rbp,8),%xmm0
movups 0x70(%r15,%rbp,8),%xmm1
movups %xmm0,0x60(%r13,%rbp,8)
movups %xmm1,0x70(%r13,%rbp,8)
add    $0x10,%rbp
add    $0xfffffffffffffffc,%rdi
jne    14c0 <AddParameters+0x340>
test   %rsi,%rsi
je     156b <AddParameters+0x3eb>
lea    0x10(,%rbp,8),%rax
add    %r13,%rax
lea    (%r15,%rbp,8),%rdi
add    $0x10,%rdi
shl    $0x5,%rsi
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movups -0x10(%rdi,%rbp,1),%xmm0
movups (%rdi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rax,%rbp,1)
movups %xmm1,(%rax,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rsi
jne    1550 <AddParameters+0x3d0>
cmp    %rcx,%rdx
jne    125f <AddParameters+0xdf>
mov    0x1c(%rsp),%eax
add    %r12d,%eax
cmp    %r10d,%eax
jge    1732 <AddParameters+0x5b2>
movslq %eax,%rdx
movslq %r12d,%r9
mov    0x10(%rsp),%rsi
sub    %ebx,%esi
add    $0xfffffffd,%esi
cmp    $0x3,%esi
jb     1693 <AddParameters+0x513>
lea    0x0(,%rdx,8),%rcx
add    %r13,%rcx
lea    (%rsi,%rdx,1),%rax
mov    %rdx,%rbx
sub    %r9,%rbx
mov    %rax,%rdi
sub    %r9,%rdi
lea    (%r15,%rdi,8),%rdi
add    $0x10,%rdi
cmp    %rdi,%rcx
jae    15e1 <AddParameters+0x461>
lea    0x8(,%rax,8),%rax
add    %r13,%rax
lea    (%r15,%rbx,8),%rcx
add    $0x8,%rcx
cmp    %rax,%rcx
jb     1693 <AddParameters+0x513>
add    $0x1,%rsi
mov    %rsi,%r8
and    $0xfffffffffffffffc,%r8
lea    -0x4(%r8),%rax
mov    %rax,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
test   %rax,%rax
je     1756 <AddParameters+0x5d6>
movabs $0x7ffffffffffffffc,%rdi
ff ff 7f
or     $0x2,%rdi
and    %rbp,%rdi
lea    0x30(,%rdx,8),%rcx
add    %r13,%rcx
lea    (%r15,%rbx,8),%rax
add    $0x38,%rax
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movups -0x30(%rax,%rbx,8),%xmm0
movups -0x20(%rax,%rbx,8),%xmm1
movups %xmm0,-0x30(%rcx,%rbx,8)
movups %xmm1,-0x20(%rcx,%rbx,8)
movups -0x10(%rax,%rbx,8),%xmm0
movups (%rax,%rbx,8),%xmm1
movups %xmm0,-0x10(%rcx,%rbx,8)
movups %xmm1,(%rcx,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rdi
jne    1630 <AddParameters+0x4b0>
test   $0x1,%bpl
je     1687 <AddParameters+0x507>
add    %rdx,%rbx
mov    %rbx,%rax
sub    %r9,%rax
movups 0x8(%r15,%rax,8),%xmm0
movups 0x18(%r15,%rax,8),%xmm1
movups %xmm0,0x0(%r13,%rbx,8)
movups %xmm1,0x10(%r13,%rbx,8)
cmp    %r8,%rsi
je     1732 <AddParameters+0x5b2>
add    %r8,%rdx
add    0x10(%rsp),%r12d
mov    %edx,%edi
not    %edi
add    %r12d,%edi
sub    %edx,%r12d
add    $0xfffffffe,%r12d
and    $0x3,%edi
je     16dd <AddParameters+0x55d>
mov    $0x1,%eax
sub    %r9,%rax
lea    (%r15,%rax,8),%rax
nopw   0x0(%rax,%rax,1)
lea    0x1(%rdx),%rsi
mov    (%rax,%rdx,8),%rcx
mov    %rcx,0x0(%r13,%rdx,8)
mov    %rsi,%rdx
add    $0xffffffff,%edi
jne    16c0 <AddParameters+0x540>
cmp    $0x3,%r12d
jae    16e6 <AddParameters+0x566>
jmp    1732 <AddParameters+0x5b2>
mov    %rdx,%rsi
cmp    $0x3,%r12d
jb     1732 <AddParameters+0x5b2>
mov    %r10d,%eax
mov    $0x4,%ecx
sub    %r9,%rcx
lea    (%r15,%rcx,8),%rcx
cs nopw 0x0(%rax,%rax,1)
nop
mov    -0x18(%rcx,%rsi,8),%rdx
mov    %rdx,0x0(%r13,%rsi,8)
mov    -0x10(%rcx,%rsi,8),%rdx
mov    %rdx,0x8(%r13,%rsi,8)
mov    -0x8(%rcx,%rsi,8),%rdx
mov    %rdx,0x10(%r13,%rsi,8)
mov    (%rcx,%rsi,8),%rdx
mov    %rdx,0x18(%r13,%rsi,8)
lea    0x4(%rsi),%rdx
mov    %rdx,%rsi
cmp    %edx,%eax
jne    1700 <AddParameters+0x580>
movslq %r10d,%rax
movq   $0x0,0x0(%r13,%rax,8)
mov    %r10d,(%r14)
mov    %r13,(%r11)
add    $0x438,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ebx,%ebx
test   $0x1,%bpl
jne    1666 <AddParameters+0x4e6>
jmp    1687 <AddParameters+0x507>
mov    0x286a(%rip),%rax
mov    (%rax),%edi
lea    0x88b(%rip),%rsi
mov    %r15,%rdx
call   1050 <fprintf@plt>
mov    $0x1,%edi
call   1090 <exit@plt>

LLVM IR (-O0):
@.str = [2 x i8] c"r\00"
@stderr = global i32 0
@.str.1 = [28 x i8] c"Can't open input file \22%s\22\0A\00"
@EOF = global i32 0
define void @AddParameters(i32 %0, i32* %1, i8*** %2) {
%4 = alloca i32
%5 = alloca i32*
%6 = alloca i8***
%7 = alloca i32
%8 = alloca i8**
%9 = alloca i32
%10 = alloca i8**
%11 = alloca i8*
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32*
%19 = alloca [1000 x i8]
%20 = alloca i32
store i32 %0, i32* %4
store i32* %1, i32** %5
store i8*** %2, i8**** %6
%21 = load i32*, i32** %5
%22 = load i32, i32* %21
store i32 %22, i32* %7
%23 = load i8***, i8**** %6
%24 = load i8**, i8*** %23
store i8** %24, i8*** %8
store i32 0, i32* %12
store i32 0, i32* %13
store i32 1, i32* %17
%25 = load i32, i32* %4
%26 = add nsw i32 %25, 1
%27 = load i32, i32* %7
%28 = icmp eq i32 %26, %27
br i1 %28, label %29, label %30
29: ; preds = %3
br label %238
30: ; preds = %3
%31 = load i8**, i8*** %8
%32 = load i32, i32* %4
%33 = add nsw i32 %32, 1
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds i8*, i8** %31, i64 %34
%36 = load i8*, i8** %35
store i8* %36, i8** %11
%37 = load i8*, i8** %11
%38 = call i32* @fopen(i8* %37, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
store i32* %38, i32** %18
%39 = load i32*, i32** %18
%40 = icmp eq i32* %39, null
br i1 %40, label %41, label %46
41: ; preds = %30
%42 = load i32, i32* @stderr
%43 = load i8*, i8** %11
%44 = call i32 @fprintf(i32 %42, i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.1, i64 0, i64 0), i8* %43)
%45 = call i32 @exit(i32 1)
unreachable
46: ; preds = %30
store i32 32, i32* %16
br label %47
47: ; preds = %181, %46
%48 = load i32, i32* %16
%49 = load i32, i32* @EOF
%50 = icmp ne i32 %48, %49
br i1 %50, label %51, label %182
51: ; preds = %47
br label %52
52: ; preds = %88, %51
%53 = load i32, i32* %16
%54 = load i32, i32* @EOF
%55 = icmp ne i32 %53, %54
br i1 %55, label %56, label %60
56: ; preds = %52
%57 = load i32, i32* %16
%58 = call i64 @isspace(i32 %57)
%59 = icmp ne i64 %58, 0
br label %60
60: ; preds = %56, %52
%61 = phi i1 [ false, %52 ], [ %59, %56 ]
br i1 %61, label %62, label %89
62: ; preds = %60
%63 = load i32, i32* %16
%64 = icmp eq i32 %63, 10
br i1 %64, label %65, label %66
65: ; preds = %62
store i32 1, i32* %17
br label %66
66: ; preds = %65, %62
%67 = load i32*, i32** %18
%68 = call i32 @getc(i32* %67)
store i32 %68, i32* %16
%69 = load i32, i32* %17
%70 = icmp ne i32 %69, 0
br i1 %70, label %71, label %88
71: ; preds = %66
%72 = load i32, i32* %16
%73 = icmp eq i32 %72, 35
br i1 %73, label %74, label %88
74: ; preds = %71
br label %75
75: ; preds = %84, %74
%76 = load i32, i32* %16
%77 = load i32, i32* @EOF
%78 = icmp ne i32 %76, %77
br i1 %78, label %79, label %82
79: ; preds = %75
%80 = load i32, i32* %16
%81 = icmp ne i32 %80, 10
br label %82
82: ; preds = %79, %75
%83 = phi i1 [ false, %75 ], [ %81, %79 ]
br i1 %83, label %84, label %87
84: ; preds = %82
%85 = load i32*, i32** %18
%86 = call i32 @getc(i32* %85)
store i32 %86, i32* %16
br label %75
87: ; preds = %82
br label %88
88: ; preds = %87, %71, %66
br label %52
89: ; preds = %60
store i32 0, i32* %15
br label %90
90: ; preds = %112, %89
%91 = load i32, i32* %16
%92 = load i32, i32* @EOF
%93 = icmp ne i32 %91, %92
br i1 %93, label %94, label %99
94: ; preds = %90
%95 = load i32, i32* %16
%96 = call i64 @isspace(i32 %95)
%97 = icmp ne i64 %96, 0
%98 = xor i1 %97, true
br label %99
99: ; preds = %94, %90
%100 = phi i1 [ false, %90 ], [ %98, %94 ]
br i1 %100, label %101, label %115
101: ; preds = %99
%102 = load i32, i32* %15
%103 = sext i32 %102 to i64
%104 = icmp ult i64 %103, 999
br i1 %104, label %105, label %112
105: ; preds = %101
%106 = load i32, i32* %16
%107 = trunc i32 %106 to i8
%108 = load i32, i32* %15
%109 = add nsw i32 %108, 1
store i32 %109, i32* %15
%110 = sext i32 %108 to i64
%111 = getelementptr inbounds [1000 x i8], [1000 x i8]* %19, i64 0, i64 %110
store i8 %107, i8* %111
br label %112
112: ; preds = %105, %101
store i32 0, i32* %17
%113 = load i32*, i32** %18
%114 = call i32 @getc(i32* %113)
store i32 %114, i32* %16
br label %90
115: ; preds = %99
%116 = load i32, i32* %15
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds [1000 x i8], [1000 x i8]* %19, i64 0, i64 %117
store i8 0, i8* %118
%119 = load i32, i32* %15
%120 = icmp sgt i32 %119, 0
br i1 %120, label %121, label %181
121: ; preds = %115
%122 = load i32, i32* %12
%123 = add nsw i32 %122, 1
store i32 %123, i32* %12
%124 = load i32, i32* %12
%125 = load i32, i32* %7
%126 = add nsw i32 %124, %125
%127 = load i32, i32* %13
%128 = icmp sgt i32 %126, %127
br i1 %128, label %129, label %151
129: ; preds = %121
%130 = load i32, i32* %13
%131 = icmp eq i32 %130, 0
br i1 %131, label %132, label %141
132: ; preds = %129
%133 = load i32, i32* %7
%134 = add nsw i32 100, %133
store i32 %134, i32* %13
%135 = load i32, i32* %13
%136 = sext i32 %135 to i64
%137 = mul i64 8, %136
%138 = trunc i64 %137 to i32
%139 = call i8* @malloc(i32 %138)
%140 = bitcast i8* %139 to i8**
store i8** %140, i8*** %10
br label %150
141: ; preds = %129
%142 = load i32, i32* %13
%143 = mul nsw i32 %142, 2
store i32 %143, i32* %13
%144 = load i8**, i8*** %10
%145 = load i32, i32* %13
%146 = sext i32 %145 to i64
%147 = mul i64 8, %146
%148 = trunc i64 %147 to i32
%149 = call i8** @realloc(i8** %144, i32 %148)
store i8** %149, i8*** %10
br label %150
150: ; preds = %141, %132
br label %151
151: ; preds = %150, %121
%152 = load i8**, i8*** %10
%153 = icmp ne i8** %152, null
br i1 %153, label %154, label %180
154: ; preds = %151
%155 = load i32, i32* %12
%156 = load i32, i32* %4
%157 = add nsw i32 %155, %156
store i32 %157, i32* %20
%158 = load i32, i32* %15
%159 = add nsw i32 %158, 1
%160 = call i8* @malloc(i32 %159)
%161 = load i8**, i8*** %10
%162 = load i32, i32* %20
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds i8*, i8** %161, i64 %163
store i8* %160, i8** %164
%165 = load i8**, i8*** %10
%166 = load i32, i32* %20
%167 = sext i32 %166 to i64
%168 = getelementptr inbounds i8*, i8** %165, i64 %167
%169 = load i8*, i8** %168
%170 = icmp ne i8* %169, null
br i1 %170, label %171, label %179
171: ; preds = %154
%172 = load i8**, i8*** %10
%173 = load i32, i32* %20
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds i8*, i8** %172, i64 %174
%176 = load i8*, i8** %175
%177 = getelementptr inbounds [1000 x i8], [1000 x i8]* %19, i64 0, i64 0
%178 = call i32 @strcpy(i8* %176, i8* %177)
br label %179
179: ; preds = %171, %154
br label %180
180: ; preds = %179, %151
br label %181
181: ; preds = %180, %115
br label %47
182: ; preds = %47
%183 = load i32, i32* %7
%184 = load i32, i32* %12
%185 = add nsw i32 %183, %184
%186 = sub nsw i32 %185, 1
store i32 %186, i32* %9
store i32 0, i32* %14
br label %187
187: ; preds = %201, %182
%188 = load i32, i32* %14
%189 = load i32, i32* %4
%190 = icmp sle i32 %188, %189
br i1 %190, label %191, label %204
191: ; preds = %187
%192 = load i8**, i8*** %8
%193 = load i32, i32* %14
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds i8*, i8** %192, i64 %194
%196 = load i8*, i8** %195
%197 = load i8**, i8*** %10
%198 = load i32, i32* %14
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds i8*, i8** %197, i64 %199
store i8* %196, i8** %200
br label %201
201: ; preds = %191
%202 = load i32, i32* %14
%203 = add nsw i32 %202, 1
store i32 %203, i32* %14
br label %187
204: ; preds = %187
%205 = load i32, i32* %12
%206 = load i32, i32* %4
%207 = add nsw i32 %205, %206
%208 = add nsw i32 %207, 1
store i32 %208, i32* %14
br label %209
209: ; preds = %226, %204
%210 = load i32, i32* %14
%211 = load i32, i32* %9
%212 = icmp slt i32 %210, %211
br i1 %212, label %213, label %229
213: ; preds = %209
%214 = load i8**, i8*** %8
%215 = load i32, i32* %14
%216 = add nsw i32 %215, 1
%217 = load i32, i32* %12
%218 = sub nsw i32 %216, %217
%219 = sext i32 %218 to i64
%220 = getelementptr inbounds i8*, i8** %214, i64 %219
%221 = load i8*, i8** %220
%222 = load i8**, i8*** %10
%223 = load i32, i32* %14
%224 = sext i32 %223 to i64
%225 = getelementptr inbounds i8*, i8** %222, i64 %224
store i8* %221, i8** %225
br label %226
226: ; preds = %213
%227 = load i32, i32* %14
%228 = add nsw i32 %227, 1
store i32 %228, i32* %14
br label %209
229: ; preds = %209
%230 = load i8**, i8*** %10
%231 = load i32, i32* %9
%232 = sext i32 %231 to i64
%233 = getelementptr inbounds i8*, i8** %230, i64 %232
store i8* null, i8** %233
%234 = load i32, i32* %9
%235 = load i32*, i32** %5
store i32 %234, i32* %235
%236 = load i8**, i8*** %10
%237 = load i8***, i8**** %6
store i8** %236, i8*** %237
br label %238
238: ; preds = %229, %29
ret void
}

LLVM IR (-O2):
@.str = [2 x i8] c"r\00"
@stderr = global i32 0
@.str.1 = [28 x i8] c"Can't open input file \22%s\22\0A\00"
@EOF = global i32 0
define void @AddParameters(i32 %0, i32* nocapture %1, i8*** nocapture %2) {
%4 = alloca [1000 x i8]
%5 = load i32, i32* %1
%6 = load i8**, i8*** %2
%7 = getelementptr inbounds [1000 x i8], [1000 x i8]* %4, i64 0, i64 0
%8 = add i32 %0, 1
%9 = icmp eq i32 %8, %5
br i1 %9, label %399, label %10
10: ; preds = %3
%11 = sext i32 %8 to i64
%12 = getelementptr inbounds i8*, i8** %6, i64 %11
%13 = load i8*, i8** %12
%14 = tail call i32* @fopen(i8* %13, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%15 = icmp eq i32* %14, null
br i1 %15, label %23, label %16
16: ; preds = %10
%17 = load i32, i32* @EOF
%18 = icmp eq i32 %17, 32
br i1 %18, label %127, label %19
19: ; preds = %16
%20 = add nsw i32 %5, 100
%21 = shl i32 %20, 3
%22 = getelementptr inbounds [1000 x i8], [1000 x i8]* %4, i64 0, i64 0
br label %27
23: ; preds = %10
%24 = load i32, i32* @stderr
%25 = tail call i32 @fprintf(i32 %24, i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.1, i64 0, i64 0), i8* %13)
%26 = tail call i32 @exit(i32 1)
unreachable
27: ; preds = %19, %119
%28 = phi i32 [ %17, %19 ], [ %125, %119 ]
%29 = phi i8** [ undef, %19 ], [ %124, %119 ]
%30 = phi i32 [ 0, %19 ], [ %123, %119 ]
%31 = phi i32 [ 1, %19 ], [ %120, %119 ]
%32 = phi i32 [ 32, %19 ], [ %121, %119 ]
%33 = phi i32 [ 0, %19 ], [ %122, %119 ]
%34 = icmp eq i32 %32, %28
br i1 %34, label %83, label %35
35: ; preds = %27, %56
%36 = phi i32 [ %42, %56 ], [ %31, %27 ]
%37 = phi i32 [ %58, %56 ], [ %32, %27 ]
%38 = call i64 @isspace(i32 %37)
%39 = icmp eq i64 %38, 0
br i1 %39, label %60, label %40
40: ; preds = %35
%41 = icmp eq i32 %37, 10
%42 = select i1 %41, i32 1, i32 %36
%43 = call i32 @getc(i32* %14)
%44 = icmp ne i32 %42, 0
%45 = icmp eq i32 %43, 35
%46 = and i1 %44, %45
%47 = load i32, i32* @EOF
br i1 %46, label %48, label %56
48: ; preds = %40
%49 = icmp eq i32 %47, 35
br i1 %49, label %83, label %50
50: ; preds = %48, %50
%51 = call i32 @getc(i32* %14)
%52 = load i32, i32* @EOF
%53 = icmp ne i32 %51, %52
%54 = icmp ne i32 %51, 10
%55 = and i1 %54, %53
br i1 %55, label %50, label %56
56: ; preds = %50, %40
%57 = phi i32 [ %47, %40 ], [ %52, %50 ]
%58 = phi i32 [ %43, %40 ], [ %51, %50 ]
%59 = icmp eq i32 %58, %57
br i1 %59, label %83, label %35
60: ; preds = %35
%61 = load i32, i32* @EOF
%62 = icmp eq i32 %37, %61
br i1 %62, label %83, label %63
63: ; preds = %60
%64 = call i64 @isspace(i32 %37)
%65 = icmp eq i64 %64, 0
br i1 %65, label %69, label %86
66: ; preds = %78
%67 = call i64 @isspace(i32 %80)
%68 = icmp eq i64 %67, 0
br i1 %68, label %69, label %86
69: ; preds = %63, %66
%70 = phi i32 [ %79, %66 ], [ 0, %63 ]
%71 = phi i32 [ %80, %66 ], [ %37, %63 ]
%72 = icmp ult i32 %70, 999
br i1 %72, label %73, label %78
73: ; preds = %69
%74 = zext i32 %70 to i64
%75 = trunc i32 %71 to i8
%76 = add nuw nsw i32 %70, 1
%77 = getelementptr inbounds [1000 x i8], [1000 x i8]* %4, i64 0, i64 %74
store i8 %75, i8* %77
br label %78
78: ; preds = %73, %69
%79 = phi i32 [ %76, %73 ], [ %70, %69 ]
%80 = call i32 @getc(i32* %14)
%81 = load i32, i32* @EOF
%82 = icmp eq i32 %80, %81
br i1 %82, label %86, label %66
83: ; preds = %56, %48, %60, %27
%84 = phi i32 [ %61, %60 ], [ %28, %27 ], [ 35, %48 ], [ %57, %56 ]
%85 = phi i32 [ %36, %60 ], [ %31, %27 ], [ %42, %48 ], [ %42, %56 ]
store i8 0, i8* %22
br label %119
86: ; preds = %78, %66, %63
%87 = phi i32 [ 0, %63 ], [ %79, %66 ], [ %79, %78 ]
%88 = phi i32 [ %37, %63 ], [ %80, %66 ], [ %80, %78 ]
%89 = phi i32 [ %36, %63 ], [ 0, %66 ], [ 0, %78 ]
%90 = sext i32 %87 to i64
%91 = getelementptr inbounds [1000 x i8], [1000 x i8]* %4, i64 0, i64 %90
store i8 0, i8* %91
%92 = icmp sgt i32 %87, 0
br i1 %92, label %93, label %119
93: ; preds = %86
%94 = add nsw i32 %30, 1
%95 = add nsw i32 %94, %5
%96 = icmp sgt i32 %95, %33
br i1 %96, label %97, label %106
97: ; preds = %93
%98 = icmp eq i32 %33, 0
br i1 %98, label %99, label %102
99: ; preds = %97
%100 = call i8* @malloc(i32 %21)
%101 = bitcast i8* %100 to i8**
br label %106
102: ; preds = %97
%103 = shl nsw i32 %33, 1
%104 = shl i32 %33, 4
%105 = call i8** @realloc(i8** %29, i32 %104)
br label %106
106: ; preds = %99, %102, %93
%107 = phi i32 [ %20, %99 ], [ %103, %102 ], [ %33, %93 ]
%108 = phi i8** [ %101, %99 ], [ %105, %102 ], [ %29, %93 ]
%109 = icmp eq i8** %108, null
br i1 %109, label %119, label %110
110: ; preds = %106
%111 = add nsw i32 %94, %0
%112 = add nuw nsw i32 %87, 1
%113 = call i8* @malloc(i32 %112)
%114 = sext i32 %111 to i64
%115 = getelementptr inbounds i8*, i8** %108, i64 %114
store i8* %113, i8** %115
%116 = icmp eq i8* %113, null
br i1 %116, label %119, label %117
117: ; preds = %110
%118 = call i32 @strcpy(i8* %113, i8* %7)
br label %119
119: ; preds = %83, %110, %117, %106, %86
%120 = phi i32 [ %89, %106 ], [ %89, %86 ], [ %89, %117 ], [ %89, %110 ], [ %85, %83 ]
%121 = phi i32 [ %88, %106 ], [ %88, %86 ], [ %88, %117 ], [ %88, %110 ], [ %84, %83 ]
%122 = phi i32 [ %107, %106 ], [ %33, %86 ], [ %107, %117 ], [ %107, %110 ], [ %33, %83 ]
%123 = phi i32 [ %94, %106 ], [ %30, %86 ], [ %94, %117 ], [ %94, %110 ], [ %30, %83 ]
%124 = phi i8** [ null, %106 ], [ %29, %86 ], [ %108, %117 ], [ %108, %110 ], [ %29, %83 ]
%125 = load i32, i32* @EOF
%126 = icmp eq i32 %121, %125
br i1 %126, label %127, label %27
127: ; preds = %119, %16
%128 = phi i32 [ 0, %16 ], [ %123, %119 ]
%129 = phi i8** [ undef, %16 ], [ %124, %119 ]
%130 = add i32 %5, -1
%131 = add i32 %130, %128
%132 = icmp slt i32 %0, 0
br i1 %132, label %258, label %133
133: ; preds = %127
%134 = zext i32 %8 to i64
%135 = icmp ult i32 %8, 4
br i1 %135, label %221, label %136
136: ; preds = %133
%137 = getelementptr i8*, i8** %129, i64 %134
%138 = getelementptr i8*, i8** %6, i64 %134
%139 = icmp ult i8** %129, %138
%140 = icmp ult i8** %6, %137
%141 = and i1 %139, %140
br i1 %141, label %221, label %142
142: ; preds = %136
%143 = and i64 %134, 4294967292
%144 = add nsw i64 %143, -4
%145 = lshr exact i64 %144, 2
%146 = add nuw nsw i64 %145, 1
%147 = and i64 %146, 3
%148 = icmp ult i64 %144, 12
br i1 %148, label %200, label %149
149: ; preds = %142
%150 = and i64 %146, 9223372036854775804
br label %151
151: ; preds = %151, %149
%152 = phi i64 [ 0, %149 ], [ %197, %151 ]
%153 = phi i64 [ 0, %149 ], [ %198, %151 ]
%154 = getelementptr inbounds i8*, i8** %6, i64 %152
%155 = bitcast i8** %154 to <2 x i8*>*
%156 = load <2 x i8*>, <2 x i8*>* %155
%157 = getelementptr inbounds i8*, i8** %154, i64 2
%158 = bitcast i8** %157 to <2 x i8*>*
%159 = load <2 x i8*>, <2 x i8*>* %158
%160 = getelementptr inbounds i8*, i8** %129, i64 %152
%161 = bitcast i8** %160 to <2 x i8*>*
store <2 x i8*> %156, <2 x i8*>* %161
%162 = getelementptr inbounds i8*, i8** %160, i64 2
%163 = bitcast i8** %162 to <2 x i8*>*
store <2 x i8*> %159, <2 x i8*>* %163
%164 = or i64 %152, 4
%165 = getelementptr inbounds i8*, i8** %6, i64 %164
%166 = bitcast i8** %165 to <2 x i8*>*
%167 = load <2 x i8*>, <2 x i8*>* %166
%168 = getelementptr inbounds i8*, i8** %165, i64 2
%169 = bitcast i8** %168 to <2 x i8*>*
%170 = load <2 x i8*>, <2 x i8*>* %169
%171 = getelementptr inbounds i8*, i8** %129, i64 %164
%172 = bitcast i8** %171 to <2 x i8*>*
store <2 x i8*> %167, <2 x i8*>* %172
%173 = getelementptr inbounds i8*, i8** %171, i64 2
%174 = bitcast i8** %173 to <2 x i8*>*
store <2 x i8*> %170, <2 x i8*>* %174
%175 = or i64 %152, 8
%176 = getelementptr inbounds i8*, i8** %6, i64 %175
%177 = bitcast i8** %176 to <2 x i8*>*
%178 = load <2 x i8*>, <2 x i8*>* %177
%179 = getelementptr inbounds i8*, i8** %176, i64 2
%180 = bitcast i8** %179 to <2 x i8*>*
%181 = load <2 x i8*>, <2 x i8*>* %180
%182 = getelementptr inbounds i8*, i8** %129, i64 %175
%183 = bitcast i8** %182 to <2 x i8*>*
store <2 x i8*> %178, <2 x i8*>* %183
%184 = getelementptr inbounds i8*, i8** %182, i64 2
%185 = bitcast i8** %184 to <2 x i8*>*
store <2 x i8*> %181, <2 x i8*>* %185
%186 = or i64 %152, 12
%187 = getelementptr inbounds i8*, i8** %6, i64 %186
%188 = bitcast i8** %187 to <2 x i8*>*
%189 = load <2 x i8*>, <2 x i8*>* %188
%190 = getelementptr inbounds i8*, i8** %187, i64 2
%191 = bitcast i8** %190 to <2 x i8*>*
%192 = load <2 x i8*>, <2 x i8*>* %191
%193 = getelementptr inbounds i8*, i8** %129, i64 %186
%194 = bitcast i8** %193 to <2 x i8*>*
store <2 x i8*> %189, <2 x i8*>* %194
%195 = getelementptr inbounds i8*, i8** %193, i64 2
%196 = bitcast i8** %195 to <2 x i8*>*
store <2 x i8*> %192, <2 x i8*>* %196
%197 = add nuw i64 %152, 16
%198 = add nuw i64 %153, 4
%199 = icmp eq i64 %198, %150
br i1 %199, label %200, label %151
200: ; preds = %151, %142
%201 = phi i64 [ 0, %142 ], [ %197, %151 ]
%202 = icmp eq i64 %147, 0
br i1 %202, label %219, label %203
203: ; preds = %200, %203
%204 = phi i64 [ %216, %203 ], [ %201, %200 ]
%205 = phi i64 [ %217, %203 ], [ 0, %200 ]
%206 = getelementptr inbounds i8*, i8** %6, i64 %204
%207 = bitcast i8** %206 to <2 x i8*>*
%208 = load <2 x i8*>, <2 x i8*>* %207
%209 = getelementptr inbounds i8*, i8** %206, i64 2
%210 = bitcast i8** %209 to <2 x i8*>*
%211 = load <2 x i8*>, <2 x i8*>* %210
%212 = getelementptr inbounds i8*, i8** %129, i64 %204
%213 = bitcast i8** %212 to <2 x i8*>*
store <2 x i8*> %208, <2 x i8*>* %213
%214 = getelementptr inbounds i8*, i8** %212, i64 2
%215 = bitcast i8** %214 to <2 x i8*>*
store <2 x i8*> %211, <2 x i8*>* %215
%216 = add nuw i64 %204, 4
%217 = add i64 %205, 1
%218 = icmp eq i64 %217, %147
br i1 %218, label %219, label %203
219: ; preds = %203, %200
%220 = icmp eq i64 %143, %134
br i1 %220, label %258, label %221
221: ; preds = %136, %133, %219
%222 = phi i64 [ 0, %136 ], [ 0, %133 ], [ %143, %219 ]
%223 = xor i64 %222, -1
%224 = add nsw i64 %223, %134
%225 = and i64 %134, 3
%226 = icmp eq i64 %225, 0
br i1 %226, label %236, label %227
227: ; preds = %221, %227
%228 = phi i64 [ %233, %227 ], [ %222, %221 ]
%229 = phi i64 [ %234, %227 ], [ 0, %221 ]
%230 = getelementptr inbounds i8*, i8** %6, i64 %228
%231 = load i8*, i8** %230
%232 = getelementptr inbounds i8*, i8** %129, i64 %228
store i8* %231, i8** %232
%233 = add nuw nsw i64 %228, 1
%234 = add i64 %229, 1
%235 = icmp eq i64 %234, %225
br i1 %235, label %236, label %227
236: ; preds = %227, %221
%237 = phi i64 [ %222, %221 ], [ %233, %227 ]
%238 = icmp ult i64 %224, 3
br i1 %238, label %258, label %239
239: ; preds = %236, %239
%240 = phi i64 [ %256, %239 ], [ %237, %236 ]
%241 = getelementptr inbounds i8*, i8** %6, i64 %240
%242 = load i8*, i8** %241
%243 = getelementptr inbounds i8*, i8** %129, i64 %240
store i8* %242, i8** %243
%244 = add nuw nsw i64 %240, 1
%245 = getelementptr inbounds i8*, i8** %6, i64 %244
%246 = load i8*, i8** %245
%247 = getelementptr inbounds i8*, i8** %129, i64 %244
store i8* %246, i8** %247
%248 = add nuw nsw i64 %240, 2
%249 = getelementptr inbounds i8*, i8** %6, i64 %248
%250 = load i8*, i8** %249
%251 = getelementptr inbounds i8*, i8** %129, i64 %248
store i8* %250, i8** %251
%252 = add nuw nsw i64 %240, 3
%253 = getelementptr inbounds i8*, i8** %6, i64 %252
%254 = load i8*, i8** %253
%255 = getelementptr inbounds i8*, i8** %129, i64 %252
store i8* %254, i8** %255
%256 = add nuw nsw i64 %240, 4
%257 = icmp eq i64 %256, %134
br i1 %257, label %258, label %239
258: ; preds = %236, %239, %219, %127
%259 = add i32 %8, %128
%260 = icmp slt i32 %259, %131
br i1 %260, label %261, label %396
261: ; preds = %258
%262 = sext i32 %259 to i64
%263 = sext i32 %128 to i64
%264 = add i32 %5, -3
%265 = sub i32 %264, %0
%266 = zext i32 %265 to i64
%267 = add nuw nsw i64 %266, 1
%268 = icmp ult i32 %265, 3
br i1 %268, label %349, label %269
269: ; preds = %261
%270 = getelementptr i8*, i8** %129, i64 %262
%271 = add i32 %5, -3
%272 = sub i32 %271, %0
%273 = zext i32 %272 to i64
%274 = add nsw i64 %262, %273
%275 = add nsw i64 %274, 1
%276 = getelementptr i8*, i8** %129, i64 %275
%277 = add nsw i64 %262, 1
%278 = sub nsw i64 %277, %263
%279 = getelementptr i8*, i8** %6, i64 %278
%280 = add nsw i64 %262, %273
%281 = add nsw i64 %280, 2
%282 = sub nsw i64 %281, %263
%283 = getelementptr i8*, i8** %6, i64 %282
%284 = icmp ult i8** %270, %283
%285 = icmp ult i8** %279, %276
%286 = and i1 %284, %285
br i1 %286, label %349, label %287
287: ; preds = %269
%288 = and i64 %267, 8589934588
%289 = add nsw i64 %288, %262
%290 = add nsw i64 %288, -4
%291 = lshr exact i64 %290, 2
%292 = add nuw nsw i64 %291, 1
%293 = and i64 %292, 1
%294 = icmp eq i64 %290, 0
br i1 %294, label %330, label %295
295: ; preds = %287
%296 = and i64 %292, 9223372036854775806
br label %297
297: ; preds = %297, %295
%298 = phi i64 [ 0, %295 ], [ %327, %297 ]
%299 = phi i64 [ 0, %295 ], [ %328, %297 ]
%300 = add i64 %298, %262
%301 = add nsw i64 %300, 1
%302 = sub nsw i64 %301, %263
%303 = getelementptr inbounds i8*, i8** %6, i64 %302
%304 = bitcast i8** %303 to <2 x i8*>*
%305 = load <2 x i8*>, <2 x i8*>* %304
%306 = getelementptr inbounds i8*, i8** %303, i64 2
%307 = bitcast i8** %306 to <2 x i8*>*
%308 = load <2 x i8*>, <2 x i8*>* %307
%309 = getelementptr inbounds i8*, i8** %129, i64 %300
%310 = bitcast i8** %309 to <2 x i8*>*
store <2 x i8*> %305, <2 x i8*>* %310
%311 = getelementptr inbounds i8*, i8** %309, i64 2
%312 = bitcast i8** %311 to <2 x i8*>*
store <2 x i8*> %308, <2 x i8*>* %312
%313 = or i64 %298, 4
%314 = add i64 %313, %262
%315 = add nsw i64 %314, 1
%316 = sub nsw i64 %315, %263
%317 = getelementptr inbounds i8*, i8** %6, i64 %316
%318 = bitcast i8** %317 to <2 x i8*>*
%319 = load <2 x i8*>, <2 x i8*>* %318
%320 = getelementptr inbounds i8*, i8** %317, i64 2
%321 = bitcast i8** %320 to <2 x i8*>*
%322 = load <2 x i8*>, <2 x i8*>* %321
%323 = getelementptr inbounds i8*, i8** %129, i64 %314
%324 = bitcast i8** %323 to <2 x i8*>*
store <2 x i8*> %319, <2 x i8*>* %324
%325 = getelementptr inbounds i8*, i8** %323, i64 2
%326 = bitcast i8** %325 to <2 x i8*>*
store <2 x i8*> %322, <2 x i8*>* %326
%327 = add nuw i64 %298, 8
%328 = add i64 %299, 2
%329 = icmp eq i64 %328, %296
br i1 %329, label %330, label %297
330: ; preds = %297, %287
%331 = phi i64 [ 0, %287 ], [ %327, %297 ]
%332 = icmp eq i64 %293, 0
br i1 %332, label %347, label %333
333: ; preds = %330
%334 = add i64 %331, %262
%335 = add nsw i64 %334, 1
%336 = sub nsw i64 %335, %263
%337 = getelementptr inbounds i8*, i8** %6, i64 %336
%338 = bitcast i8** %337 to <2 x i8*>*
%339 = load <2 x i8*>, <2 x i8*>* %338
%340 = getelementptr inbounds i8*, i8** %337, i64 2
%341 = bitcast i8** %340 to <2 x i8*>*
%342 = load <2 x i8*>, <2 x i8*>* %341
%343 = getelementptr inbounds i8*, i8** %129, i64 %334
%344 = bitcast i8** %343 to <2 x i8*>*
store <2 x i8*> %339, <2 x i8*>* %344
%345 = getelementptr inbounds i8*, i8** %343, i64 2
%346 = bitcast i8** %345 to <2 x i8*>*
store <2 x i8*> %342, <2 x i8*>* %346
br label %347
347: ; preds = %330, %333
%348 = icmp eq i64 %267, %288
br i1 %348, label %396, label %349
349: ; preds = %269, %261, %347
%350 = phi i64 [ %262, %269 ], [ %262, %261 ], [ %289, %347 ]
%351 = add i32 %128, %5
%352 = trunc i64 %350 to i32
%353 = xor i32 %352, -1
%354 = add i32 %351, %353
%355 = add i32 %351, -2
%356 = sub i32 %355, %352
%357 = and i32 %354, 3
%358 = icmp eq i32 %357, 0
br i1 %358, label %369, label %359
359: ; preds = %349, %359
%360 = phi i64 [ %362, %359 ], [ %350, %349 ]
%361 = phi i32 [ %367, %359 ], [ 0, %349 ]
%362 = add nsw i64 %360, 1
%363 = sub nsw i64 %362, %263
%364 = getelementptr inbounds i8*, i8** %6, i64 %363
%365 = load i8*, i8** %364
%366 = getelementptr inbounds i8*, i8** %129, i64 %360
store i8* %365, i8** %366
%367 = add i32 %361, 1
%368 = icmp eq i32 %367, %357
br i1 %368, label %369, label %359
369: ; preds = %359, %349
%370 = phi i64 [ %350, %349 ], [ %362, %359 ]
%371 = icmp ult i32 %356, 3
br i1 %371, label %396, label %372
372: ; preds = %369, %372
%373 = phi i64 [ %389, %372 ], [ %370, %369 ]
%374 = add nsw i64 %373, 1
%375 = sub nsw i64 %374, %263
%376 = getelementptr inbounds i8*, i8** %6, i64 %375
%377 = load i8*, i8** %376
%378 = getelementptr inbounds i8*, i8** %129, i64 %373
store i8* %377, i8** %378
%379 = add nsw i64 %373, 2
%380 = sub nsw i64 %379, %263
%381 = getelementptr inbounds i8*, i8** %6, i64 %380
%382 = load i8*, i8** %381
%383 = getelementptr inbounds i8*, i8** %129, i64 %374
store i8* %382, i8** %383
%384 = add nsw i64 %373, 3
%385 = sub nsw i64 %384, %263
%386 = getelementptr inbounds i8*, i8** %6, i64 %385
%387 = load i8*, i8** %386
%388 = getelementptr inbounds i8*, i8** %129, i64 %379
store i8* %387, i8** %388
%389 = add nsw i64 %373, 4
%390 = sub nsw i64 %389, %263
%391 = getelementptr inbounds i8*, i8** %6, i64 %390
%392 = load i8*, i8** %391
%393 = getelementptr inbounds i8*, i8** %129, i64 %384
store i8* %392, i8** %393
%394 = trunc i64 %389 to i32
%395 = icmp eq i32 %131, %394
br i1 %395, label %396, label %372
396: ; preds = %369, %372, %347, %258
%397 = sext i32 %131 to i64
%398 = getelementptr inbounds i8*, i8** %129, i64 %397
store i8* null, i8** %398
store i32 %131, i32* %1
store i8** %129, i8*** %2
br label %399
399: ; preds = %3, %396
ret void
}