#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*/ FILE;

/* Variables and functions */
int /*<<< orphan*/ SEEK_SET;
int abs(int);
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char const *, char *);
int /*<<< orphan*/ fread(unsigned char *, int, int, int /*<<< orphan*/ *);
int /*<<< orphan*/ free(int *);
int /*<<< orphan*/ fseek(int /*<<< orphan*/ *, int, int /*<<< orphan*/);
scalar_t__ malloc(int);
int /*<<< orphan*/ printf(char *);
void parsePlink(const char **plinkBed, int *NumSample, int *NumSNP,
                double *distMat, int *E, double *result) {
  int NSam = *NumSample;
  int NSNP = *NumSNP;
  int *Gmap = (int *)malloc(4 * 256 * sizeof(int));
  int *G = (int *)malloc(NSam * sizeof(int));
  int *GE = (int *)malloc(NSam * sizeof(int));
  unsigned char buffer;
  int tmp;
  int sampleOffSet = NSam % 4;
  int i, j, k;
  int iResult;
  int GDiff;
  double dExp = 0;
  int rowResult = 12;
  for (i = 0; i < NSNP; i++)
    for (j = 0; j < rowResult; j++)
      result[i * rowResult + j] = 0;
  for (i = 0; i < NSam - 1; i++) {
    for (j = i + 1; j < NSam; j++) {
      dExp += distMat[i * NSam + j];
    }
  }
  dExp = dExp / (((double)NSam) * (NSam - 1) / 2);
  for (i = 0; i < NSam - 1; i++) {
    for (j = i + 1; j < NSam; j++) {
      distMat[i * NSam + j] = distMat[i * NSam + j] - dExp;
      distMat[j * NSam + i] = distMat[j * NSam + i] - dExp;
    }
  }
  for (i = 0; i < 256; i++) {
    buffer = (unsigned char)i;
    k = i * 4;
    for (j = 0; j < 4; j++) {
      tmp = (buffer >> (j * 2)) & 3;
      switch (tmp) {
      case 0:
        Gmap[k + j] = 2;
        break;
      case 2:
        Gmap[k + j] = 1;
        break;
      case 3:
        Gmap[k + j] = 0;
        break;
      default:
        Gmap[k + j] = -9;
      }
    }
  }
  FILE *ptr_plink = fopen(*plinkBed, "rb");
  if (!ptr_plink) {
    printf("Unable to open file!");
  }
  fseek(ptr_plink, 3, SEEK_SET);
  for (j = 0; j < NSNP; j++) {
    iResult = j * rowResult;
    for (i = 0; i < NSam - 3; i = i + 4) {
      fread(&buffer, 1, 1, ptr_plink);
      tmp = (((int)buffer) << 2);
      for (k = 0; k < 4; k++) {
        G[i + k] = Gmap[tmp + k];
        switch (G[i + k]) {
        case 0:
          result[iResult] = result[iResult] + 1;
          break;
        case 1:
          result[iResult + 1] = result[iResult + 1] + 1;
          break;
        case 2:
          result[iResult + 2] = result[iResult + 2] + 1;
          break;
        default:
          result[iResult + 3] = result[iResult + 3] + 1;
        }
        switch (E[i + k]) {
        case 0:
          GE[i + k] = (G[i + k] == -9 ? -9 : 0);
          break;
        case 1:
          GE[i + k] = G[i + k];
          break;
        default:
          GE[i + k] = -9;
        }
        switch (GE[i + k]) {
        case 0:
          result[iResult + 5] = result[iResult + 5] + 1;
          break;
        case 1:
          result[iResult + 6] = result[iResult + 6] + 1;
          break;
        case 2:
          result[iResult + 7] = result[iResult + 7] + 1;
          break;
        default:
          result[iResult + 8] = result[iResult + 8] + 1;
        }
      }
    }
    if (sampleOffSet > 0) {
      fread(&buffer, 1, 1, ptr_plink);
      tmp = (((int)buffer) << 2);
      for (k = 0; k < sampleOffSet; k++) {
        G[i + k] = Gmap[tmp + k];
        switch (G[i + k]) {
        case 0:
          result[iResult] = result[iResult] + 1;
          break;
        case 1:
          result[iResult + 1] = result[iResult + 1] + 1;
          break;
        case 2:
          result[iResult + 2] = result[iResult + 2] + 1;
          break;
        default:
          result[iResult + 3] = result[iResult + 3] + 1;
        }
        switch (E[i + k]) {
        case 0:
          GE[i + k] = (G[i + k] == -9 ? -9 : 0);
          break;
        case 1:
          GE[i + k] = G[i + k];
          break;
        default:
          GE[i + k] = -9;
        }
        switch (GE[i + k]) {
        case 0:
          result[iResult + 5] = result[iResult + 5] + 1;
          break;
        case 1:
          result[iResult + 6] = result[iResult + 6] + 1;
          break;
        case 2:
          result[iResult + 7] = result[iResult + 7] + 1;
          break;
        default:
          result[iResult + 8] = result[iResult + 8] + 1;
        }
      }
    }
    result[iResult + 4] =
        (result[iResult + 1] + result[iResult + 2] + result[iResult + 2]) /
        (NSam + NSam - result[iResult + 3] - result[iResult + 3]);
    result[iResult + 9] =
        (result[iResult + 6] + result[iResult + 7] + result[iResult + 7]) /
        (NSam + NSam - result[iResult + 8] - result[iResult + 8]);
    for (i = 0; i < NSam - 1; i++) {
      for (k = i + 1; k < NSam; k++) {
        if ((G[i] != -9) && (G[k] != -9)) {
          GDiff = abs(G[i] - G[k]);
          switch (GDiff) {
          case 0:
            break;
          case 2:
            result[iResult + 10] += distMat[i * NSam + k];
          default:
            result[iResult + 10] += distMat[i * NSam + k];
          }
        }
        if ((GE[i] != -9) && (GE[k] != -9)) {
          GDiff = abs(GE[i] - GE[k]);
          switch (GDiff) {
          case 0:
            break;
          case 2:
            result[iResult + 11] += distMat[i * NSam + k];
          default:
            result[iResult + 11] += distMat[i * NSam + k];
          }
        }
      }
    }
  }
  fclose(ptr_plink);
  free(G);
  free(GE);
  free(Gmap);
}


x86 assembly (clang, -O0):
<parsePlink>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x38(%rbp)
mov    $0x1000,%edi
call   1080 <malloc@plt>
mov    %rax,-0x40(%rbp)
movslq -0x34(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0x48(%rbp)
movslq -0x34(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0x50(%rbp)
mov    -0x34(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %edx,-0x5c(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
movl   $0xc,-0x7c(%rbp)
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1266 <parsePlink+0xe6>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x7c(%rbp),%eax
jge    1253 <parsePlink+0xd3>
mov    -0x30(%rbp),%rax
mov    -0x60(%rbp),%ecx
imul   -0x7c(%rbp),%ecx
add    -0x64(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1220 <parsePlink+0xa0>
jmp    1258 <parsePlink+0xd8>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    120d <parsePlink+0x8d>
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    12d4 <parsePlink+0x154>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    12c1 <parsePlink+0x141>
mov    -0x20(%rbp),%rax
mov    -0x60(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    -0x64(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1287 <parsePlink+0x107>
jmp    12c6 <parsePlink+0x146>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    126d <parsePlink+0xed>
movsd  -0x78(%rbp),%xmm0
cvtsi2sdl -0x34(%rbp),%xmm1
mov    -0x34(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm2
mulsd  %xmm2,%xmm1
movsd  0xd0c(%rip),%xmm2
divsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    13b1 <parsePlink+0x231>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    139e <parsePlink+0x21e>
mov    -0x20(%rbp),%rax
mov    -0x60(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    -0x64(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x78(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x60(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    -0x64(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x64(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    -0x60(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x78(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x64(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    -0x60(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1322 <parsePlink+0x1a2>
jmp    13a3 <parsePlink+0x223>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1308 <parsePlink+0x188>
movl   $0x0,-0x60(%rbp)
cmpl   $0x100,-0x60(%rbp)
jge    14b9 <parsePlink+0x339>
mov    -0x60(%rbp),%eax
mov    %al,-0x51(%rbp)
mov    -0x60(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x68(%rbp)
movl   $0x0,-0x64(%rbp)
cmpl   $0x4,-0x64(%rbp)
jge    14a6 <parsePlink+0x326>
movzbl -0x51(%rbp),%eax
mov    -0x64(%rbp),%cl
add    %cl,%cl
shr    %cl,%eax
and    $0x3,%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
mov    %eax,-0x8c(%rbp)
test   %eax,%eax
je     1434 <parsePlink+0x2b4>
jmp    140c <parsePlink+0x28c>
mov    -0x8c(%rbp),%eax
sub    $0x2,%eax
je     144d <parsePlink+0x2cd>
jmp    1420 <parsePlink+0x2a0>
mov    -0x8c(%rbp),%eax
sub    $0x3,%eax
je     1466 <parsePlink+0x2e6>
jmp    147f <parsePlink+0x2ff>
mov    -0x40(%rbp),%rax
mov    -0x68(%rbp),%ecx
add    -0x64(%rbp),%ecx
movslq %ecx,%rcx
movl   $0x2,(%rax,%rcx,4)
jmp    1493 <parsePlink+0x313>
mov    -0x40(%rbp),%rax
mov    -0x68(%rbp),%ecx
add    -0x64(%rbp),%ecx
movslq %ecx,%rcx
movl   $0x1,(%rax,%rcx,4)
jmp    1493 <parsePlink+0x313>
mov    -0x40(%rbp),%rax
mov    -0x68(%rbp),%ecx
add    -0x64(%rbp),%ecx
movslq %ecx,%rcx
movl   $0x0,(%rax,%rcx,4)
jmp    1493 <parsePlink+0x313>
mov    -0x40(%rbp),%rax
mov    -0x68(%rbp),%ecx
add    -0x64(%rbp),%ecx
movslq %ecx,%rcx
movl   $0xfffffff7,(%rax,%rcx,4)
jmp    1498 <parsePlink+0x318>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    13db <parsePlink+0x25b>
jmp    14ab <parsePlink+0x32b>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    13b8 <parsePlink+0x238>
mov    -0x8(%rbp),%rax
mov    (%rax),%rdi
lea    0xb49(%rip),%rsi
call   10a0 <fopen@plt>
mov    %rax,-0x88(%rbp)
cmpq   $0x0,-0x88(%rbp)
jne    14ed <parsePlink+0x36d>
lea    0xb2b(%rip),%rdi
call   1070 <printf@plt>
mov    -0x88(%rbp),%rdi
mov    0x2ae5(%rip),%rax
mov    (%rax),%edx
mov    $0x3,%esi
call   1090 <fseek@plt>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1e86 <parsePlink+0xd06>
mov    -0x64(%rbp),%eax
imul   -0x7c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
mov    -0x34(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jge    1867 <parsePlink+0x6e7>
mov    -0x88(%rbp),%rcx
lea    -0x51(%rbp),%rdi
mov    $0x1,%edx
mov    %edx,%esi
call   1040 <fread@plt>
movzbl -0x51(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x58(%rbp)
movl   $0x0,-0x68(%rbp)
cmpl   $0x4,-0x68(%rbp)
jge    1854 <parsePlink+0x6d4>
mov    -0x40(%rbp),%rax
mov    -0x58(%rbp),%ecx
mov    -0x68(%rbp),%esi
add    %esi,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x48(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    %esi,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
mov    -0x60(%rbp),%ecx
mov    -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x90(%rbp)
test   %eax,%eax
je     15dc <parsePlink+0x45c>
jmp    15b4 <parsePlink+0x434>
mov    -0x90(%rbp),%eax
sub    $0x1,%eax
je     1603 <parsePlink+0x483>
jmp    15c8 <parsePlink+0x448>
mov    -0x90(%rbp),%eax
sub    $0x2,%eax
je     1634 <parsePlink+0x4b4>
jmp    1665 <parsePlink+0x4e5>
mov    -0x30(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  0xa1c(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1691 <parsePlink+0x511>
mov    -0x30(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x9f0(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1691 <parsePlink+0x511>
mov    -0x30(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  0x9bf(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1691 <parsePlink+0x511>
mov    -0x30(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  0x98e(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0x60(%rbp),%ecx
mov    -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x94(%rbp)
test   %eax,%eax
je     16ca <parsePlink+0x54a>
jmp    16b6 <parsePlink+0x536>
mov    -0x94(%rbp),%eax
sub    $0x1,%eax
je     16fc <parsePlink+0x57c>
jmp    1721 <parsePlink+0x5a1>
mov    -0x48(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%ecx
xor    %edx,%edx
mov    $0xfffffff7,%eax
cmp    $0xfffffff7,%ecx
cmove  %eax,%edx
mov    -0x50(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1735 <parsePlink+0x5b5>
mov    -0x48(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x50(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1735 <parsePlink+0x5b5>
mov    -0x50(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
movl   $0xfffffff7,(%rax,%rcx,4)
mov    -0x50(%rbp),%rax
mov    -0x60(%rbp),%ecx
mov    -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x98(%rbp)
test   %eax,%eax
je     1782 <parsePlink+0x602>
jmp    175a <parsePlink+0x5da>
mov    -0x98(%rbp),%eax
sub    $0x1,%eax
je     17b3 <parsePlink+0x633>
jmp    176e <parsePlink+0x5ee>
mov    -0x98(%rbp),%eax
sub    $0x2,%eax
je     17e4 <parsePlink+0x664>
jmp    1815 <parsePlink+0x695>
mov    -0x30(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movsd  0x871(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1841 <parsePlink+0x6c1>
mov    -0x30(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
movsd  0x840(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1841 <parsePlink+0x6c1>
mov    -0x30(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
movsd  0x80f(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1841 <parsePlink+0x6c1>
mov    -0x30(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0x8,%ecx
movslq %ecx,%rcx
movsd  0x7de(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0x8,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1846 <parsePlink+0x6c6>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1564 <parsePlink+0x3e4>
jmp    1859 <parsePlink+0x6d9>
mov    -0x60(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x60(%rbp)
jmp    152b <parsePlink+0x3ab>
cmpl   $0x0,-0x5c(%rbp)
jle    1b90 <parsePlink+0xa10>
mov    -0x88(%rbp),%rcx
lea    -0x51(%rbp),%rdi
mov    $0x1,%edx
mov    %edx,%esi
call   1040 <fread@plt>
movzbl -0x51(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x58(%rbp)
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jge    1b8b <parsePlink+0xa0b>
mov    -0x40(%rbp),%rax
mov    -0x58(%rbp),%ecx
mov    -0x68(%rbp),%esi
add    %esi,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x48(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    %esi,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
mov    -0x60(%rbp),%ecx
mov    -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x9c(%rbp)
test   %eax,%eax
je     1913 <parsePlink+0x793>
jmp    18eb <parsePlink+0x76b>
mov    -0x9c(%rbp),%eax
sub    $0x1,%eax
je     193a <parsePlink+0x7ba>
jmp    18ff <parsePlink+0x77f>
mov    -0x9c(%rbp),%eax
sub    $0x2,%eax
je     196b <parsePlink+0x7eb>
jmp    199c <parsePlink+0x81c>
mov    -0x30(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  0x6e5(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    19c8 <parsePlink+0x848>
mov    -0x30(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x6b9(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    19c8 <parsePlink+0x848>
mov    -0x30(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  0x688(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    19c8 <parsePlink+0x848>
mov    -0x30(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  0x657(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0x60(%rbp),%ecx
mov    -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xa0(%rbp)
test   %eax,%eax
je     1a01 <parsePlink+0x881>
jmp    19ed <parsePlink+0x86d>
mov    -0xa0(%rbp),%eax
sub    $0x1,%eax
je     1a33 <parsePlink+0x8b3>
jmp    1a58 <parsePlink+0x8d8>
mov    -0x48(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%ecx
xor    %edx,%edx
mov    $0xfffffff7,%eax
cmp    $0xfffffff7,%ecx
cmove  %eax,%edx
mov    -0x50(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1a6c <parsePlink+0x8ec>
mov    -0x48(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x50(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1a6c <parsePlink+0x8ec>
mov    -0x50(%rbp),%rax
mov    -0x60(%rbp),%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
movl   $0xfffffff7,(%rax,%rcx,4)
mov    -0x50(%rbp),%rax
mov    -0x60(%rbp),%ecx
mov    -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xa4(%rbp)
test   %eax,%eax
je     1ab9 <parsePlink+0x939>
jmp    1a91 <parsePlink+0x911>
mov    -0xa4(%rbp),%eax
sub    $0x1,%eax
je     1aea <parsePlink+0x96a>
jmp    1aa5 <parsePlink+0x925>
mov    -0xa4(%rbp),%eax
sub    $0x2,%eax
je     1b1b <parsePlink+0x99b>
jmp    1b4c <parsePlink+0x9cc>
mov    -0x30(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movsd  0x53a(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1b78 <parsePlink+0x9f8>
mov    -0x30(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
movsd  0x509(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1b78 <parsePlink+0x9f8>
mov    -0x30(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
movsd  0x4d8(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1b78 <parsePlink+0x9f8>
mov    -0x30(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0x8,%ecx
movslq %ecx,%rcx
movsd  0x4a7(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0x8,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1b7d <parsePlink+0x9fd>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1899 <parsePlink+0x719>
jmp    1b90 <parsePlink+0xa10>
mov    -0x30(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x34(%rbp),%eax
add    -0x34(%rbp),%eax
cvtsi2sd %eax,%xmm1
mov    -0x30(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm1
mov    -0x30(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x34(%rbp),%eax
add    -0x34(%rbp),%eax
cvtsi2sd %eax,%xmm1
mov    -0x30(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0x8,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm1
mov    -0x30(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0x8,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0x9,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1e73 <parsePlink+0xcf3>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1e60 <parsePlink+0xce0>
mov    -0x48(%rbp),%rax
movslq -0x60(%rbp),%rcx
cmpl   $0xfffffff7,(%rax,%rcx,4)
je     1d7f <parsePlink+0xbff>
mov    -0x48(%rbp),%rax
movslq -0x68(%rbp),%rcx
cmpl   $0xfffffff7,(%rax,%rcx,4)
je     1d7f <parsePlink+0xbff>
mov    -0x48(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
sub    %eax,%edi
call   1050 <abs@plt>
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
mov    %eax,-0xa8(%rbp)
test   %eax,%eax
je     1d1b <parsePlink+0xb9b>
jmp    1d07 <parsePlink+0xb87>
mov    -0xa8(%rbp),%eax
sub    $0x2,%eax
je     1d20 <parsePlink+0xba0>
jmp    1d4d <parsePlink+0xbcd>
jmp    1d7a <parsePlink+0xbfa>
mov    -0x20(%rbp),%rax
mov    -0x60(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0xa,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x60(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0xa,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1d7f <parsePlink+0xbff>
mov    -0x50(%rbp),%rax
movslq -0x60(%rbp),%rcx
cmpl   $0xfffffff7,(%rax,%rcx,4)
je     1e4d <parsePlink+0xccd>
mov    -0x50(%rbp),%rax
movslq -0x68(%rbp),%rcx
cmpl   $0xfffffff7,(%rax,%rcx,4)
je     1e4d <parsePlink+0xccd>
mov    -0x50(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
sub    %eax,%edi
call   1050 <abs@plt>
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
mov    %eax,-0xac(%rbp)
test   %eax,%eax
je     1de9 <parsePlink+0xc69>
jmp    1dd5 <parsePlink+0xc55>
mov    -0xac(%rbp),%eax
sub    $0x2,%eax
je     1dee <parsePlink+0xc6e>
jmp    1e1b <parsePlink+0xc9b>
jmp    1e48 <parsePlink+0xcc8>
mov    -0x20(%rbp),%rax
mov    -0x60(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0xb,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x60(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0xb,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1e4d <parsePlink+0xccd>
jmp    1e52 <parsePlink+0xcd2>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1ca5 <parsePlink+0xb25>
jmp    1e65 <parsePlink+0xce5>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1c8b <parsePlink+0xb0b>
jmp    1e78 <parsePlink+0xcf8>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    150e <parsePlink+0x38e>
mov    -0x88(%rbp),%rdi
call   1060 <fclose@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<parsePlink>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xe8,%rsp
mov    %r9,%r15
mov    %r8,%r13
mov    %rcx,0x58(%rsp)
mov    %rdi,0x28(%rsp)
mov    (%rsi),%r12d
mov    %r12d,%ebx
mov    (%rdx),%r14d
mov    $0x1000,%edi
call   1080 <malloc@plt>
mov    %rax,0x50(%rsp)
lea    0x0(,%rbx,4),%ebp
mov    %ebp,%edi
call   1080 <malloc@plt>
mov    %rax,0x40(%rsp)
mov    %ebp,%edi
mov    %r14,%rbp
call   1080 <malloc@plt>
mov    %rax,0x10(%rsp)
lea    0x3(%rbx),%r14d
test   %r12d,%r12d
mov    %rbx,0x60(%rsp)
cmovns %ebx,%r14d
test   %ebp,%ebp
jle    1204 <parsePlink+0x84>
mov    %rbp,%rax
shl    $0x5,%rax
lea    (%rax,%rax,2),%rdx
mov    %r15,%rdi
xor    %esi,%esi
call   1070 <memset@plt>
mov    %rbp,0x90(%rsp)
and    $0xfffffffc,%r14d
lea    -0x1(%r12),%r8d
mov    %r8d,%eax
mov    %rax,0x68(%rsp)
cmp    $0x2,%r12d
jl     131a <parsePlink+0x19a>
cmp    $0x1,%r8d
jne    1d6d <parsePlink+0xbed>
xorpd  %xmm0,%xmm0
mov    $0x1,%ecx
xor    %edx,%edx
testb  $0x1,0x68(%rsp)
je     126e <parsePlink+0xee>
lea    0x1(%rdx),%rax
cmp    %r12,%rax
jae    126e <parsePlink+0xee>
imul   %r12,%rdx
mov    0x58(%rsp),%rax
lea    (%rax,%rdx,8),%rax
nopl   0x0(%rax)
addsd  (%rax,%rcx,8),%xmm0
add    $0x1,%rcx
cmp    %rcx,%r12
jne    1260 <parsePlink+0xe0>
cmp    $0x1,%r12d
jle    131a <parsePlink+0x19a>
cvtsi2sd %r12d,%xmm1
cvtsi2sd %r8d,%xmm2
mulsd  %xmm1,%xmm2
mulsd  0xd72(%rip),%xmm2
divsd  %xmm2,%xmm0
mov    0x58(%rsp),%rbp
lea    0x0(,%r12,8),%rdx
add    %rbp,%rdx
lea    0x0(,%r12,8),%rcx
lea    0x8(,%r12,8),%r8
xor    %esi,%esi
mov    %r12,%rdi
jmp    12d1 <parsePlink+0x151>
nopl   0x0(%rax)
add    %r8,%rdx
add    %r8,%rbp
add    $0xffffffffffffffff,%rdi
cmp    0x68(%rsp),%rsi
je     131a <parsePlink+0x19a>
add    $0x1,%rsi
cmp    %r12,%rsi
jae    12c0 <parsePlink+0x140>
mov    $0x1,%ebx
mov    %rdx,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  0x0(%rbp,%rbx,8),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%rbp,%rbx,8)
movsd  (%rax),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,(%rax)
add    %rcx,%rax
add    $0x1,%rbx
cmp    %rbx,%rdi
jne    12f0 <parsePlink+0x170>
jmp    12c0 <parsePlink+0x140>
mov    0x60(%rsp),%rax
sub    %r14d,%eax
mov    %rax,0x60(%rsp)
mov    0x50(%rsp),%rax
add    $0xc,%rax
xor    %ecx,%ecx
lea    0xcef(%rip),%rdx
nopl   0x0(%rax)
mov    %ecx,%esi
and    $0x3,%esi
mov    (%rdx,%rsi,4),%esi
mov    %esi,-0xc(%rax)
mov    %ecx,%esi
and    $0xc,%esi
mov    (%rsi,%rdx,1),%esi
mov    %esi,-0x8(%rax)
mov    %rcx,%rsi
shr    $0x2,%rsi
and    $0xc,%esi
mov    (%rsi,%rdx,1),%esi
mov    %esi,-0x4(%rax)
mov    %rcx,%rsi
shr    $0x4,%rsi
and    $0xc,%esi
mov    (%rsi,%rdx,1),%esi
mov    %esi,(%rax)
add    $0x1,%rcx
add    $0x10,%rax
cmp    $0x100,%rcx
jne    1340 <parsePlink+0x1c0>
movb   $0xff,0x7(%rsp)
mov    0x28(%rsp),%rax
mov    (%rax),%rdi
lea    0xc76(%rip),%rsi
call   10a0 <fopen@plt>
test   %rax,%rax
mov    %r15,0x30(%rsp)
mov    0x90(%rsp),%rbx
jne    13c3 <parsePlink+0x243>
mov    %rax,%rbp
lea    0xc58(%rip),%rdi
call   1060 <printf@plt>
mov    %rbp,%rax
mov    0x2c16(%rip),%rcx
mov    (%rcx),%edx
mov    %rax,0x78(%rsp)
mov    %rax,%rdi
mov    $0x3,%esi
call   1090 <fseek@plt>
test   %ebx,%ebx
jle    1d34 <parsePlink+0xbb4>
lea    -0x3(%r12),%eax
mov    %eax,0x84(%rsp)
lea    (%r12,%r12,1),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0xc8(%rsp)
movslq %r12d,%rcx
lea    0x1(%rcx),%rax
mov    %rax,0xe0(%rsp)
mov    0x10(%rsp),%rax
add    $0x4,%rax
mov    %rax,0xc0(%rsp)
mov    0x58(%rsp),%rax
add    $0x8,%rax
mov    %rax,0xb8(%rsp)
mov    %rcx,0xa0(%rsp)
lea    0x8(,%rcx,8),%rax
mov    %rax,0xd8(%rsp)
mov    0x40(%rsp),%rax
add    $0x4,%rax
mov    %rax,0xb0(%rsp)
lea    -0x1(%r12),%rax
mov    %rax,0xa8(%rsp)
xor    %ecx,%ecx
mov    %r13,0x70(%rsp)
mov    %r12,0x48(%rsp)
jmp    149f <parsePlink+0x31f>
nopl   0x0(%rax,%rax,1)
mov    0xd0(%rsp),%rcx
add    $0x1,%rcx
cmp    0x90(%rsp),%rcx
mov    0x48(%rsp),%r12
je     1d34 <parsePlink+0xbb4>
lea    0x0(,%rcx,4),%eax
lea    (%rax,%rax,2),%edx
mov    %edx,%esi
cmp    $0x4,%r12d
mov    %rdx,0x28(%rsp)
mov    %rcx,0xd0(%rsp)
mov    %rsi,0x98(%rsp)
jl     17f0 <parsePlink+0x670>
mov    %edx,%eax
or     $0x2,%eax
mov    0x30(%rsp),%rcx
lea    (%rcx,%rax,8),%rax
mov    %rax,0x20(%rsp)
mov    %edx,%eax
or     $0x1,%eax
lea    (%rcx,%rax,8),%r10
mov    %rdx,%rax
lea    (%rcx,%rsi,8),%r15
or     $0x3,%eax
lea    (%rcx,%rax,8),%rax
mov    %rax,0x38(%rsp)
lea    (%rcx,%rsi,8),%rax
add    $0x38,%rax
mov    %rax,0x8(%rsp)
lea    0x30(%rcx,%rsi,8),%rax
mov    %rax,0x18(%rsp)
lea    (%rcx,%rsi,8),%r13
add    $0x28,%r13
lea    (%rcx,%rsi,8),%r14
add    $0x40,%r14
xor    %r12d,%r12d
jmp    155a <parsePlink+0x3da>
cs nopw 0x0(%rax,%rax,1)
nop
movl   $0xfffffff7,0xc(%rbx,%r12,4)
ff ff
mov    %r14,%rcx
movsd  (%rcx),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rcx)
add    $0x4,%r12
cmp    %r12d,0x84(%rsp)
jle    17f3 <parsePlink+0x673>
lea    0x7(%rsp),%rdi
mov    $0x1,%esi
mov    $0x1,%edx
mov    0x78(%rsp),%rcx
mov    %r10,%rbp
call   1040 <fread@plt>
mov    %rbp,%r10
movzbl 0x7(%rsp),%eax
mov    %rax,%rcx
shl    $0x4,%rcx
mov    0x50(%rsp),%rsi
mov    (%rsi,%rcx,1),%ecx
mov    0x40(%rsp),%rdi
mov    %ecx,(%rdi,%r12,4)
mov    %r15,%r8
test   %ecx,%ecx
je     15b4 <parsePlink+0x434>
mov    0x20(%rsp),%r15
cmp    $0x2,%ecx
je     15b4 <parsePlink+0x434>
mov    %r10,%r15
cmp    $0x1,%ecx
je     15b4 <parsePlink+0x434>
mov    0x38(%rsp),%r15
shl    $0x2,%rax
movsd  (%r15),%xmm0
movsd  0xa43(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r15)
mov    0x70(%rsp),%rbp
mov    0x0(%rbp,%r12,4),%edx
cmp    $0x1,%edx
mov    0x10(%rsp),%rbx
je     15f4 <parsePlink+0x474>
test   %edx,%edx
jne    1620 <parsePlink+0x4a0>
xor    %edx,%edx
cmp    $0xfffffff7,%ecx
setne  %dl
lea    (%rdx,%rdx,8),%ecx
add    $0xfffffff7,%ecx
mov    %r8,%r15
mov    %ecx,(%rbx,%r12,4)
mov    %r13,%rdx
test   %ecx,%ecx
je     162e <parsePlink+0x4ae>
mov    0x8(%rsp),%rdx
cmp    $0x2,%ecx
je     162e <parsePlink+0x4ae>
mov    0x18(%rsp),%rdx
cmp    $0x1,%ecx
jne    162b <parsePlink+0x4ab>
jmp    162e <parsePlink+0x4ae>
nopl   0x0(%rax,%rax,1)
movl   $0xfffffff7,(%rbx,%r12,4)
ff
mov    %r8,%r15
mov    %r14,%rdx
movsd  (%rdx),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rdx)
shl    $0x2,%rax
mov    %rax,%rcx
or     $0x4,%rcx
mov    (%rsi,%rcx,1),%ecx
mov    %ecx,0x4(%rdi,%r12,4)
mov    %r15,%rdx
test   %ecx,%ecx
je     166b <parsePlink+0x4eb>
mov    %r10,%rdx
cmp    $0x1,%ecx
je     166b <parsePlink+0x4eb>
mov    0x20(%rsp),%rdx
cmp    $0x2,%ecx
je     166b <parsePlink+0x4eb>
mov    0x38(%rsp),%rdx
movsd  (%rdx),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rdx)
mov    0x4(%rbp,%r12,4),%edx
cmp    $0x1,%edx
je     1693 <parsePlink+0x513>
test   %edx,%edx
jne    16c0 <parsePlink+0x540>
xor    %edx,%edx
cmp    $0xfffffff7,%ecx
setne  %dl
lea    (%rdx,%rdx,8),%ecx
add    $0xfffffff7,%ecx
mov    %ecx,0x4(%rbx,%r12,4)
mov    %r13,%rdx
test   %ecx,%ecx
je     16cc <parsePlink+0x54c>
mov    0x18(%rsp),%rdx
cmp    $0x1,%ecx
je     16cc <parsePlink+0x54c>
mov    0x8(%rsp),%rdx
cmp    $0x2,%ecx
jne    16c9 <parsePlink+0x549>
jmp    16cc <parsePlink+0x54c>
cs nopw 0x0(%rax,%rax,1)
nop
movl   $0xfffffff7,0x4(%rbx,%r12,4)
ff ff
mov    %r14,%rdx
movsd  (%rdx),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rdx)
mov    %rax,%rcx
or     $0x8,%rcx
mov    (%rsi,%rcx,1),%ecx
mov    %ecx,0x8(%rdi,%r12,4)
mov    %r15,%rdx
test   %ecx,%ecx
je     1705 <parsePlink+0x585>
mov    %r10,%rdx
cmp    $0x1,%ecx
je     1705 <parsePlink+0x585>
mov    0x20(%rsp),%rdx
cmp    $0x2,%ecx
je     1705 <parsePlink+0x585>
mov    0x38(%rsp),%rdx
movsd  (%rdx),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rdx)
mov    0x8(%rbp,%r12,4),%edx
cmp    $0x1,%edx
je     172d <parsePlink+0x5ad>
test   %edx,%edx
jne    1750 <parsePlink+0x5d0>
xor    %edx,%edx
cmp    $0xfffffff7,%ecx
setne  %dl
lea    (%rdx,%rdx,8),%ecx
add    $0xfffffff7,%ecx
mov    %ecx,0x8(%rbx,%r12,4)
mov    %r13,%rdx
test   %ecx,%ecx
je     175c <parsePlink+0x5dc>
mov    0x18(%rsp),%rdx
cmp    $0x1,%ecx
je     175c <parsePlink+0x5dc>
mov    0x8(%rsp),%rdx
cmp    $0x2,%ecx
jne    1759 <parsePlink+0x5d9>
jmp    175c <parsePlink+0x5dc>
nop
movl   $0xfffffff7,0x8(%rbx,%r12,4)
ff ff
mov    %r14,%rdx
movsd  (%rdx),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rdx)
or     $0xc,%rax
mov    (%rsi,%rax,1),%eax
mov    %eax,0xc(%rdi,%r12,4)
mov    %r15,%rcx
test   %eax,%eax
je     1792 <parsePlink+0x612>
mov    %r10,%rcx
cmp    $0x1,%eax
je     1792 <parsePlink+0x612>
mov    0x20(%rsp),%rcx
cmp    $0x2,%eax
je     1792 <parsePlink+0x612>
mov    0x38(%rsp),%rcx
movsd  (%rcx),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rcx)
mov    0xc(%rbp,%r12,4),%ecx
cmp    $0x1,%ecx
je     17be <parsePlink+0x63e>
test   %ecx,%ecx
jne    1530 <parsePlink+0x3b0>
xor    %ecx,%ecx
cmp    $0xfffffff7,%eax
setne  %cl
lea    (%rcx,%rcx,8),%eax
add    $0xfffffff7,%eax
mov    %eax,0xc(%rbx,%r12,4)
mov    %r13,%rcx
test   %eax,%eax
je     153c <parsePlink+0x3bc>
mov    0x18(%rsp),%rcx
cmp    $0x1,%eax
je     153c <parsePlink+0x3bc>
mov    0x8(%rsp),%rcx
cmp    $0x2,%eax
jne    1539 <parsePlink+0x3b9>
jmp    153c <parsePlink+0x3bc>
nop
xor    %r12d,%r12d
cmpl   $0x0,0x60(%rsp)
jle    1910 <parsePlink+0x790>
lea    0x7(%rsp),%rdi
mov    $0x1,%esi
mov    $0x1,%edx
mov    0x78(%rsp),%rcx
call   1040 <fread@plt>
movzbl 0x7(%rsp),%r11d
mov    0x28(%rsp),%rdx
mov    %edx,%r13d
or     $0x2,%r13d
mov    0x30(%rsp),%rsi
lea    (%rsi,%r13,8),%rcx
mov    %edx,%r14d
or     $0x1,%r14d
lea    (%rsi,%r14,8),%rax
mov    0x98(%rsp),%r15
lea    (%rsi,%r15,8),%r9
mov    %edx,%r10d
or     $0x3,%r10d
lea    (%rsi,%r10,8),%rdx
mov    %r12d,%esi
mov    %r11,%rdi
shl    $0x4,%rdi
mov    0x50(%rsp),%rbp
mov    0x0(%rbp,%rdi,1),%edi
mov    0x40(%rsp),%rbp
mov    %edi,0x0(%rbp,%rsi,4)
mov    %r9,%rbx
test   %edi,%edi
je     188a <parsePlink+0x70a>
mov    %rcx,%rbx
cmp    $0x2,%edi
je     188a <parsePlink+0x70a>
mov    %rax,%rbx
cmp    $0x1,%edi
je     188a <parsePlink+0x70a>
mov    %rdx,%rbx
mov    %rax,0x20(%rsp)
mov    %rdx,0x38(%rsp)
mov    %rcx,0x8(%rsp)
mov    0x30(%rsp),%rbp
lea    0x38(,%r15,8),%r12
add    %rbp,%r12
lea    0x30(%rbp,%r15,8),%rdx
lea    0x28(%rbp,%r15,8),%rcx
lea    0x40(%rbp,%r15,8),%r8
movsd  (%rbx),%xmm0
movsd  0x744(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx)
mov    0x70(%rsp),%rbp
mov    0x0(%rbp,%rsi,4),%ebp
cmp    $0x1,%ebp
je     18eb <parsePlink+0x76b>
test   %ebp,%ebp
jne    1950 <parsePlink+0x7d0>
xor    %ebp,%ebp
cmp    $0xfffffff7,%edi
setne  %bpl
lea    -0x9(%rbp,%rbp,8),%edi
mov    0x10(%rsp),%rbp
mov    %edi,0x0(%rbp,%rsi,4)
mov    %rcx,%rbx
test   %edi,%edi
je     195f <parsePlink+0x7df>
mov    %r12,%rbx
cmp    $0x2,%edi
je     195f <parsePlink+0x7df>
mov    %rdx,%rbx
cmp    $0x1,%edi
jne    195c <parsePlink+0x7dc>
jmp    195f <parsePlink+0x7df>
nopl   (%rax)
mov    0x28(%rsp),%rsi
mov    %esi,%r14d
or     $0x1,%r14d
mov    %esi,%r13d
or     $0x2,%r13d
mov    %esi,%r10d
or     $0x3,%r10d
lea    0x6(%rsi),%edx
lea    0x7(%rsi),%ebp
lea    0x8(%rsi),%eax
mov    0x48(%rsp),%rbx
mov    0x98(%rsp),%r15
jmp    1b10 <parsePlink+0x990>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x10(%rsp),%rdi
movl   $0xfffffff7,(%rdi,%rsi,4)
mov    %r8,%rbx
mov    %rdx,0x18(%rsp)
lea    0x7(%r15),%rbp
lea    0x6(%r15),%rdx
lea    0x8(%r15),%rax
movsd  (%rbx),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rbx)
cmpl   $0x1,0x60(%rsp)
je     1a54 <parsePlink+0x8d4>
mov    %r12,0x88(%rsp)
shl    $0x2,%r11
shl    $0x2,%r11
mov    %r11,%rdi
or     $0x4,%rdi
mov    0x50(%rsp),%rbx
mov    (%rbx,%rdi,1),%r12d
mov    0x40(%rsp),%rdi
mov    %r12d,0x4(%rdi,%rsi,4)
mov    %r9,%rdi
test   %r12d,%r12d
je     19d4 <parsePlink+0x854>
mov    0x20(%rsp),%rdi
cmp    $0x1,%r12d
je     19d4 <parsePlink+0x854>
mov    0x8(%rsp),%rdi
cmp    $0x2,%r12d
je     19d4 <parsePlink+0x854>
mov    0x38(%rsp),%rdi
movsd  (%rdi),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rdi)
mov    0x70(%rsp),%rdi
mov    0x4(%rdi,%rsi,4),%edi
cmp    $0x1,%edi
je     1a04 <parsePlink+0x884>
test   %edi,%edi
jne    1a31 <parsePlink+0x8b1>
xor    %edi,%edi
cmp    $0xfffffff7,%r12d
setne  %dil
lea    (%rdi,%rdi,8),%r12d
add    $0xfffffff7,%r12d
mov    0x10(%rsp),%rdi
mov    %r12d,0x4(%rdi,%rsi,4)
mov    %rcx,%rdi
test   %r12d,%r12d
je     1a41 <parsePlink+0x8c1>
mov    0x18(%rsp),%rdi
cmp    $0x1,%r12d
je     1a41 <parsePlink+0x8c1>
mov    0x88(%rsp),%rdi
cmp    $0x2,%r12d
jne    1a3e <parsePlink+0x8be>
jmp    1a41 <parsePlink+0x8c1>
mov    0x10(%rsp),%rdi
movl   $0xfffffff7,0x4(%rdi,%rsi,4)
ff
mov    %r8,%rdi
movsd  (%rdi),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rdi)
cmpl   $0x2,0x60(%rsp)
jne    1a5e <parsePlink+0x8de>
mov    0x48(%rsp),%rbx
jmp    1b10 <parsePlink+0x990>
or     $0x8,%r11
mov    0x50(%rsp),%rdi
mov    (%rdi,%r11,1),%edi
mov    0x40(%rsp),%rbx
mov    %edi,0x8(%rbx,%rsi,4)
test   %edi,%edi
je     1a91 <parsePlink+0x911>
mov    0x20(%rsp),%r9
cmp    $0x1,%edi
je     1a91 <parsePlink+0x911>
mov    0x8(%rsp),%r9
cmp    $0x2,%edi
je     1a91 <parsePlink+0x911>
mov    0x38(%rsp),%r9
movsd  (%r9),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r9)
mov    0x70(%rsp),%rbx
mov    0x8(%rbx,%rsi,4),%ebx
cmp    $0x1,%ebx
mov    0x10(%rsp),%r11
mov    0x88(%rsp),%r12
je     1ad6 <parsePlink+0x956>
test   %ebx,%ebx
mov    0x48(%rsp),%rbx
jne    1af8 <parsePlink+0x978>
xor    %r9d,%r9d
cmp    $0xfffffff7,%edi
setne  %r9b
lea    (%r9,%r9,8),%edi
add    $0xfffffff7,%edi
jmp    1adb <parsePlink+0x95b>
mov    0x48(%rsp),%rbx
mov    %edi,0x8(%r11,%rsi,4)
test   %edi,%edi
je     1b04 <parsePlink+0x984>
mov    0x18(%rsp),%rcx
cmp    $0x1,%edi
je     1b04 <parsePlink+0x984>
mov    %r12,%rcx
cmp    $0x2,%edi
jne    1b01 <parsePlink+0x981>
jmp    1b04 <parsePlink+0x984>
movl   $0xfffffff7,0x8(%r11,%rsi,4)
ff ff
mov    %r8,%rcx
movsd  (%rcx),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rcx)
mov    0x30(%rsp),%rsi
movsd  (%rsi,%r13,8),%xmm0
movsd  (%rsi,%r14,8),%xmm1
addsd  %xmm0,%xmm1
addsd  %xmm0,%xmm1
movsd  (%rsi,%r10,8),%xmm0
movsd  0xc8(%rsp),%xmm3
movapd %xmm3,%xmm2
subsd  %xmm0,%xmm2
subsd  %xmm0,%xmm2
divsd  %xmm2,%xmm1
movsd  %xmm1,0x20(%rsi,%r15,8)
movsd  (%rsi,%rbp,8),%xmm0
movsd  (%rsi,%rdx,8),%xmm1
addsd  %xmm0,%xmm1
addsd  %xmm0,%xmm1
movsd  (%rsi,%rax,8),%xmm0
movapd %xmm3,%xmm2
subsd  %xmm0,%xmm2
subsd  %xmm0,%xmm2
divsd  %xmm2,%xmm1
movsd  %xmm1,0x48(%rsi,%r15,8)
cmp    $0x2,%ebx
jl     1480 <parsePlink+0x300>
mov    0x28(%rsp),%rax
lea    0xa(%rax),%ebp
add    $0xb,%eax
mov    %rax,0x28(%rsp)
mov    $0x1,%r15d
mov    0xa8(%rsp),%rdx
mov    0xb0(%rsp),%r13
mov    0xb8(%rsp),%r12
mov    0xc0(%rsp),%r10
xor    %r11d,%r11d
mov    $0x1,%eax
mov    %rax,0x8(%rsp)
mov    %rbp,0x20(%rsp)
jmp    1c02 <parsePlink+0xa82>
addq   $0x1,0x8(%rsp)
add    0xe0(%rsp),%r15
add    $0x4,%r10
add    0xd8(%rsp),%r12
add    $0x4,%r13
add    $0xffffffffffffffff,%rdx
mov    0x18(%rsp),%r11
cmp    0x68(%rsp),%r11
je     1480 <parsePlink+0x300>
lea    0x1(%r11),%rax
mov    %rax,0x18(%rsp)
cmp    0xa0(%rsp),%rax
jge    1bd0 <parsePlink+0xa50>
mov    0x40(%rsp),%rax
mov    (%rax,%r11,4),%r8d
mov    0x10(%rsp),%rax
mov    (%rax,%r11,4),%eax
imul   0xa0(%rsp),%r11
xor    %ecx,%ecx
mov    0x8(%rsp),%rdi
jmp    1c91 <parsePlink+0xb11>
lea    (%rdi,%r11,1),%rsi
movsd  (%r12,%rcx,8),%xmm0
mov    0x30(%rsp),%rbp
mov    0x28(%rsp),%r9
addsd  0x0(%rbp,%r9,8),%xmm0
movsd  %xmm0,0x0(%rbp,%r9,8)
mov    0x58(%rsp),%rbx
addsd  (%rbx,%rsi,8),%xmm0
movsd  %xmm0,0x0(%rbp,%r9,8)
mov    0x20(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rdi
add    $0x1,%rcx
cmp    %rcx,%rdx
je     1bd0 <parsePlink+0xa50>
cmp    $0xfffffff7,%r8d
je     1cf0 <parsePlink+0xb70>
mov    0x0(%r13,%rcx,4),%esi
cmp    $0xfffffff7,%esi
je     1cf0 <parsePlink+0xb70>
mov    %r8d,%ebx
sub    %esi,%ebx
mov    %ebx,%esi
neg    %esi
cmovs  %ebx,%esi
test   %esi,%esi
je     1cf0 <parsePlink+0xb70>
cmp    $0x2,%esi
jne    1cd1 <parsePlink+0xb51>
mov    0x30(%rsp),%rsi
lea    (%rdi,%r11,1),%r14
movsd  (%r12,%rcx,8),%xmm0
addsd  (%rsi,%rbp,8),%xmm0
movsd  %xmm0,(%rsi,%rbp,8)
jmp    1cdf <parsePlink+0xb5f>
mov    0x30(%rsp),%rsi
movsd  (%rsi,%rbp,8),%xmm0
lea    (%r15,%rcx,1),%r14
mov    0x58(%rsp),%rbx
addsd  (%rbx,%r14,8),%xmm0
movsd  %xmm0,(%rsi,%rbp,8)
nop
cmp    $0xfffffff7,%eax
je     1c80 <parsePlink+0xb00>
mov    (%r10,%rcx,4),%esi
cmp    $0xfffffff7,%esi
je     1c80 <parsePlink+0xb00>
mov    %eax,%ebx
sub    %esi,%ebx
mov    %ebx,%esi
neg    %esi
cmovs  %ebx,%esi
test   %esi,%esi
je     1c80 <parsePlink+0xb00>
cmp    $0x2,%esi
je     1c39 <parsePlink+0xab9>
mov    0x30(%rsp),%rbp
mov    0x28(%rsp),%r9
movsd  0x0(%rbp,%r9,8),%xmm0
lea    (%r15,%rcx,1),%rsi
jmp    1c5b <parsePlink+0xadb>
mov    0x78(%rsp),%rdi
call   1050 <fclose@plt>
mov    0x40(%rsp),%rdi
call   1030 <free@plt>
mov    0x10(%rsp),%rdi
call   1030 <free@plt>
mov    0x50(%rsp),%rdi
add    $0xe8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>
mov    0x68(%rsp),%r9
and    $0xfffffffe,%r9d
mov    %r12,%rdi
shl    $0x4,%rdi
add    $0x10,%rdi
mov    0x58(%rsp),%rbp
lea    0x0(,%r12,8),%rbx
add    %rbp,%rbx
xorpd  %xmm0,%xmm0
mov    $0x1,%ecx
xor    %edx,%edx
mov    %r12,%rax
jmp    1dc7 <parsePlink+0xc47>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x2,%rcx
add    %rdi,%rbp
add    $0xfffffffffffffffe,%rax
add    %rdi,%rbx
cmp    %r9,%rdx
je     123c <parsePlink+0xbc>
mov    %rdx,%rsi
or     $0x1,%rsi
cmp    %r12,%rsi
jae    1def <parsePlink+0xc6f>
mov    $0x1,%esi
nopl   0x0(%rax,%rax,1)
addsd  0x0(%rbp,%rsi,8),%xmm0
add    $0x1,%rsi
cmp    %rsi,%rax
jne    1de0 <parsePlink+0xc60>
add    $0x2,%rdx
cmp    %r12,%rdx
jae    1db0 <parsePlink+0xc30>
mov    $0x2,%esi
nopl   (%rax)
addsd  (%rbx,%rsi,8),%xmm0
add    $0x1,%rsi
cmp    %rsi,%rax
jne    1e00 <parsePlink+0xc80>
jmp    1db0 <parsePlink+0xc30>

LLVM IR (-O0):
@.str = [3 x i8] c"rb\00"
@.str.1 = [21 x i8] c"Unable to open file!\00"
@SEEK_SET = global i32 0
define void @parsePlink(i8** %0, i32* %1, i32* %2, double* %3, i32* %4, double* %5) {
%7 = alloca i8**
%8 = alloca i32*
%9 = alloca i32*
%10 = alloca double*
%11 = alloca i32*
%12 = alloca double*
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32*
%16 = alloca i32*
%17 = alloca i32*
%18 = alloca i8
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca double
%27 = alloca i32
%28 = alloca i32*
store i8** %0, i8*** %7
store i32* %1, i32** %8
store i32* %2, i32** %9
store double* %3, double** %10
store i32* %4, i32** %11
store double* %5, double** %12
%29 = load i32*, i32** %8
%30 = load i32, i32* %29
store i32 %30, i32* %13
%31 = load i32*, i32** %9
%32 = load i32, i32* %31
store i32 %32, i32* %14
%33 = call i64 @malloc(i32 4096)
%34 = inttoptr i64 %33 to i32*
store i32* %34, i32** %15
%35 = load i32, i32* %13
%36 = sext i32 %35 to i64
%37 = mul i64 %36, 4
%38 = trunc i64 %37 to i32
%39 = call i64 @malloc(i32 %38)
%40 = inttoptr i64 %39 to i32*
store i32* %40, i32** %16
%41 = load i32, i32* %13
%42 = sext i32 %41 to i64
%43 = mul i64 %42, 4
%44 = trunc i64 %43 to i32
%45 = call i64 @malloc(i32 %44)
%46 = inttoptr i64 %45 to i32*
store i32* %46, i32** %17
%47 = load i32, i32* %13
%48 = srem i32 %47, 4
store i32 %48, i32* %20
store double 0.000000e+00, double* %26
store i32 12, i32* %27
store i32 0, i32* %21
br label %49
49: ; preds = %71, %6
%50 = load i32, i32* %21
%51 = load i32, i32* %14
%52 = icmp slt i32 %50, %51
br i1 %52, label %53, label %74
53: ; preds = %49
store i32 0, i32* %22
br label %54
54: ; preds = %67, %53
%55 = load i32, i32* %22
%56 = load i32, i32* %27
%57 = icmp slt i32 %55, %56
br i1 %57, label %58, label %70
58: ; preds = %54
%59 = load double*, double** %12
%60 = load i32, i32* %21
%61 = load i32, i32* %27
%62 = mul nsw i32 %60, %61
%63 = load i32, i32* %22
%64 = add nsw i32 %62, %63
%65 = sext i32 %64 to i64
%66 = getelementptr inbounds double, double* %59, i64 %65
store double 0.000000e+00, double* %66
br label %67
67: ; preds = %58
%68 = load i32, i32* %22
%69 = add nsw i32 %68, 1
store i32 %69, i32* %22
br label %54
70: ; preds = %54
br label %71
71: ; preds = %70
%72 = load i32, i32* %21
%73 = add nsw i32 %72, 1
store i32 %73, i32* %21
br label %49
74: ; preds = %49
store i32 0, i32* %21
br label %75
75: ; preds = %103, %74
%76 = load i32, i32* %21
%77 = load i32, i32* %13
%78 = sub nsw i32 %77, 1
%79 = icmp slt i32 %76, %78
br i1 %79, label %80, label %106
80: ; preds = %75
%81 = load i32, i32* %21
%82 = add nsw i32 %81, 1
store i32 %82, i32* %22
br label %83
83: ; preds = %99, %80
%84 = load i32, i32* %22
%85 = load i32, i32* %13
%86 = icmp slt i32 %84, %85
br i1 %86, label %87, label %102
87: ; preds = %83
%88 = load double*, double** %10
%89 = load i32, i32* %21
%90 = load i32, i32* %13
%91 = mul nsw i32 %89, %90
%92 = load i32, i32* %22
%93 = add nsw i32 %91, %92
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds double, double* %88, i64 %94
%96 = load double, double* %95
%97 = load double, double* %26
%98 = fadd double %97, %96
store double %98, double* %26
br label %99
99: ; preds = %87
%100 = load i32, i32* %22
%101 = add nsw i32 %100, 1
store i32 %101, i32* %22
br label %83
102: ; preds = %83
br label %103
103: ; preds = %102
%104 = load i32, i32* %21
%105 = add nsw i32 %104, 1
store i32 %105, i32* %21
br label %75
106: ; preds = %75
%107 = load double, double* %26
%108 = load i32, i32* %13
%109 = sitofp i32 %108 to double
%110 = load i32, i32* %13
%111 = sub nsw i32 %110, 1
%112 = sitofp i32 %111 to double
%113 = fmul double %109, %112
%114 = fdiv double %113, 2.000000e+00
%115 = fdiv double %107, %114
store double %115, double* %26
store i32 0, i32* %21
br label %116
116: ; preds = %171, %106
%117 = load i32, i32* %21
%118 = load i32, i32* %13
%119 = sub nsw i32 %118, 1
%120 = icmp slt i32 %117, %119
br i1 %120, label %121, label %174
121: ; preds = %116
%122 = load i32, i32* %21
%123 = add nsw i32 %122, 1
store i32 %123, i32* %22
br label %124
124: ; preds = %167, %121
%125 = load i32, i32* %22
%126 = load i32, i32* %13
%127 = icmp slt i32 %125, %126
br i1 %127, label %128, label %170
128: ; preds = %124
%129 = load double*, double** %10
%130 = load i32, i32* %21
%131 = load i32, i32* %13
%132 = mul nsw i32 %130, %131
%133 = load i32, i32* %22
%134 = add nsw i32 %132, %133
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds double, double* %129, i64 %135
%137 = load double, double* %136
%138 = load double, double* %26
%139 = fsub double %137, %138
%140 = load double*, double** %10
%141 = load i32, i32* %21
%142 = load i32, i32* %13
%143 = mul nsw i32 %141, %142
%144 = load i32, i32* %22
%145 = add nsw i32 %143, %144
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds double, double* %140, i64 %146
store double %139, double* %147
%148 = load double*, double** %10
%149 = load i32, i32* %22
%150 = load i32, i32* %13
%151 = mul nsw i32 %149, %150
%152 = load i32, i32* %21
%153 = add nsw i32 %151, %152
%154 = sext i32 %153 to i64
%155 = getelementptr inbounds double, double* %148, i64 %154
%156 = load double, double* %155
%157 = load double, double* %26
%158 = fsub double %156, %157
%159 = load double*, double** %10
%160 = load i32, i32* %22
%161 = load i32, i32* %13
%162 = mul nsw i32 %160, %161
%163 = load i32, i32* %21
%164 = add nsw i32 %162, %163
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds double, double* %159, i64 %165
store double %158, double* %166
br label %167
167: ; preds = %128
%168 = load i32, i32* %22
%169 = add nsw i32 %168, 1
store i32 %169, i32* %22
br label %124
170: ; preds = %124
br label %171
171: ; preds = %170
%172 = load i32, i32* %21
%173 = add nsw i32 %172, 1
store i32 %173, i32* %21
br label %116
174: ; preds = %116
store i32 0, i32* %21
br label %175
175: ; preds = %227, %174
%176 = load i32, i32* %21
%177 = icmp slt i32 %176, 256
br i1 %177, label %178, label %230
178: ; preds = %175
%179 = load i32, i32* %21
%180 = trunc i32 %179 to i8
store i8 %180, i8* %18
%181 = load i32, i32* %21
%182 = mul nsw i32 %181, 4
store i32 %182, i32* %23
store i32 0, i32* %22
br label %183
183: ; preds = %223, %178
%184 = load i32, i32* %22
%185 = icmp slt i32 %184, 4
br i1 %185, label %186, label %226
186: ; preds = %183
%187 = load i8, i8* %18
%188 = zext i8 %187 to i32
%189 = load i32, i32* %22
%190 = mul nsw i32 %189, 2
%191 = ashr i32 %188, %190
%192 = and i32 %191, 3
store i32 %192, i32* %19
%193 = load i32, i32* %19
switch i32 %193, label %215 [
i32 0, label %194
i32 2, label %201
i32 3, label %208
]
194: ; preds = %186
%195 = load i32*, i32** %15
%196 = load i32, i32* %23
%197 = load i32, i32* %22
%198 = add nsw i32 %196, %197
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds i32, i32* %195, i64 %199
store i32 2, i32* %200
br label %222
201: ; preds = %186
%202 = load i32*, i32** %15
%203 = load i32, i32* %23
%204 = load i32, i32* %22
%205 = add nsw i32 %203, %204
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds i32, i32* %202, i64 %206
store i32 1, i32* %207
br label %222
208: ; preds = %186
%209 = load i32*, i32** %15
%210 = load i32, i32* %23
%211 = load i32, i32* %22
%212 = add nsw i32 %210, %211
%213 = sext i32 %212 to i64
%214 = getelementptr inbounds i32, i32* %209, i64 %213
store i32 0, i32* %214
br label %222
215: ; preds = %186
%216 = load i32*, i32** %15
%217 = load i32, i32* %23
%218 = load i32, i32* %22
%219 = add nsw i32 %217, %218
%220 = sext i32 %219 to i64
%221 = getelementptr inbounds i32, i32* %216, i64 %220
store i32 -9, i32* %221
br label %222
222: ; preds = %215, %208, %201, %194
br label %223
223: ; preds = %222
%224 = load i32, i32* %22
%225 = add nsw i32 %224, 1
store i32 %225, i32* %22
br label %183
226: ; preds = %183
br label %227
227: ; preds = %226
%228 = load i32, i32* %21
%229 = add nsw i32 %228, 1
store i32 %229, i32* %21
br label %175
230: ; preds = %175
%231 = load i8**, i8*** %7
%232 = load i8*, i8** %231
%233 = call i32* @fopen(i8* %232, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0))
store i32* %233, i32** %28
%234 = load i32*, i32** %28
%235 = icmp ne i32* %234, null
br i1 %235, label %238, label %236
236: ; preds = %230
%237 = call i32 @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.1, i64 0, i64 0))
br label %238
238: ; preds = %236, %230
%239 = load i32*, i32** %28
%240 = load i32, i32* @SEEK_SET
%241 = call i32 @fseek(i32* %239, i32 3, i32 %240)
store i32 0, i32* %22
br label %242
242: ; preds = %882, %238
%243 = load i32, i32* %22
%244 = load i32, i32* %14
%245 = icmp slt i32 %243, %244
br i1 %245, label %246, label %885
246: ; preds = %242
%247 = load i32, i32* %22
%248 = load i32, i32* %27
%249 = mul nsw i32 %247, %248
store i32 %249, i32* %24
store i32 0, i32* %21
br label %250
250: ; preds = %446, %246
%251 = load i32, i32* %21
%252 = load i32, i32* %13
%253 = sub nsw i32 %252, 3
%254 = icmp slt i32 %251, %253
br i1 %254, label %255, label %449
255: ; preds = %250
%256 = load i32*, i32** %28
%257 = call i32 @fread(i8* %18, i32 1, i32 1, i32* %256)
%258 = load i8, i8* %18
%259 = zext i8 %258 to i32
%260 = shl i32 %259, 2
store i32 %260, i32* %19
store i32 0, i32* %23
br label %261
261: ; preds = %442, %255
%262 = load i32, i32* %23
%263 = icmp slt i32 %262, 4
br i1 %263, label %264, label %445
264: ; preds = %261
%265 = load i32*, i32** %15
%266 = load i32, i32* %19
%267 = load i32, i32* %23
%268 = add nsw i32 %266, %267
%269 = sext i32 %268 to i64
%270 = getelementptr inbounds i32, i32* %265, i64 %269
%271 = load i32, i32* %270
%272 = load i32*, i32** %16
%273 = load i32, i32* %21
%274 = load i32, i32* %23
%275 = add nsw i32 %273, %274
%276 = sext i32 %275 to i64
%277 = getelementptr inbounds i32, i32* %272, i64 %276
store i32 %271, i32* %277
%278 = load i32*, i32** %16
%279 = load i32, i32* %21
%280 = load i32, i32* %23
%281 = add nsw i32 %279, %280
%282 = sext i32 %281 to i64
%283 = getelementptr inbounds i32, i32* %278, i64 %282
%284 = load i32, i32* %283
switch i32 %284, label %322 [
i32 0, label %285
i32 1, label %296
i32 2, label %309
]
285: ; preds = %264
%286 = load double*, double** %12
%287 = load i32, i32* %24
%288 = sext i32 %287 to i64
%289 = getelementptr inbounds double, double* %286, i64 %288
%290 = load double, double* %289
%291 = fadd double %290, 1.000000e+00
%292 = load double*, double** %12
%293 = load i32, i32* %24
%294 = sext i32 %293 to i64
%295 = getelementptr inbounds double, double* %292, i64 %294
store double %291, double* %295
br label %335
296: ; preds = %264
%297 = load double*, double** %12
%298 = load i32, i32* %24
%299 = add nsw i32 %298, 1
%300 = sext i32 %299 to i64
%301 = getelementptr inbounds double, double* %297, i64 %300
%302 = load double, double* %301
%303 = fadd double %302, 1.000000e+00
%304 = load double*, double** %12
%305 = load i32, i32* %24
%306 = add nsw i32 %305, 1
%307 = sext i32 %306 to i64
%308 = getelementptr inbounds double, double* %304, i64 %307
store double %303, double* %308
br label %335
309: ; preds = %264
%310 = load double*, double** %12
%311 = load i32, i32* %24
%312 = add nsw i32 %311, 2
%313 = sext i32 %312 to i64
%314 = getelementptr inbounds double, double* %310, i64 %313
%315 = load double, double* %314
%316 = fadd double %315, 1.000000e+00
%317 = load double*, double** %12
%318 = load i32, i32* %24
%319 = add nsw i32 %318, 2
%320 = sext i32 %319 to i64
%321 = getelementptr inbounds double, double* %317, i64 %320
store double %316, double* %321
br label %335
322: ; preds = %264
%323 = load double*, double** %12
%324 = load i32, i32* %24
%325 = add nsw i32 %324, 3
%326 = sext i32 %325 to i64
%327 = getelementptr inbounds double, double* %323, i64 %326
%328 = load double, double* %327
%329 = fadd double %328, 1.000000e+00
%330 = load double*, double** %12
%331 = load i32, i32* %24
%332 = add nsw i32 %331, 3
%333 = sext i32 %332 to i64
%334 = getelementptr inbounds double, double* %330, i64 %333
store double %329, double* %334
br label %335
335: ; preds = %322, %309, %296, %285
%336 = load i32*, i32** %11
%337 = load i32, i32* %21
%338 = load i32, i32* %23
%339 = add nsw i32 %337, %338
%340 = sext i32 %339 to i64
%341 = getelementptr inbounds i32, i32* %336, i64 %340
%342 = load i32, i32* %341
switch i32 %342, label %374 [
i32 0, label %343
i32 1, label %360
]
343: ; preds = %335
%344 = load i32*, i32** %16
%345 = load i32, i32* %21
%346 = load i32, i32* %23
%347 = add nsw i32 %345, %346
%348 = sext i32 %347 to i64
%349 = getelementptr inbounds i32, i32* %344, i64 %348
%350 = load i32, i32* %349
%351 = icmp eq i32 %350, -9
%352 = zext i1 %351 to i64
%353 = select i1 %351, i32 -9, i32 0
%354 = load i32*, i32** %17
%355 = load i32, i32* %21
%356 = load i32, i32* %23
%357 = add nsw i32 %355, %356
%358 = sext i32 %357 to i64
%359 = getelementptr inbounds i32, i32* %354, i64 %358
store i32 %353, i32* %359
br label %381
360: ; preds = %335
%361 = load i32*, i32** %16
%362 = load i32, i32* %21
%363 = load i32, i32* %23
%364 = add nsw i32 %362, %363
%365 = sext i32 %364 to i64
%366 = getelementptr inbounds i32, i32* %361, i64 %365
%367 = load i32, i32* %366
%368 = load i32*, i32** %17
%369 = load i32, i32* %21
%370 = load i32, i32* %23
%371 = add nsw i32 %369, %370
%372 = sext i32 %371 to i64
%373 = getelementptr inbounds i32, i32* %368, i64 %372
store i32 %367, i32* %373
br label %381
374: ; preds = %335
%375 = load i32*, i32** %17
%376 = load i32, i32* %21
%377 = load i32, i32* %23
%378 = add nsw i32 %376, %377
%379 = sext i32 %378 to i64
%380 = getelementptr inbounds i32, i32* %375, i64 %379
store i32 -9, i32* %380
br label %381
381: ; preds = %374, %360, %343
%382 = load i32*, i32** %17
%383 = load i32, i32* %21
%384 = load i32, i32* %23
%385 = add nsw i32 %383, %384
%386 = sext i32 %385 to i64
%387 = getelementptr inbounds i32, i32* %382, i64 %386
%388 = load i32, i32* %387
switch i32 %388, label %428 [
i32 0, label %389
i32 1, label %402
i32 2, label %415
]
389: ; preds = %381
%390 = load double*, double** %12
%391 = load i32, i32* %24
%392 = add nsw i32 %391, 5
%393 = sext i32 %392 to i64
%394 = getelementptr inbounds double, double* %390, i64 %393
%395 = load double, double* %394
%396 = fadd double %395, 1.000000e+00
%397 = load double*, double** %12
%398 = load i32, i32* %24
%399 = add nsw i32 %398, 5
%400 = sext i32 %399 to i64
%401 = getelementptr inbounds double, double* %397, i64 %400
store double %396, double* %401
br label %441
402: ; preds = %381
%403 = load double*, double** %12
%404 = load i32, i32* %24
%405 = add nsw i32 %404, 6
%406 = sext i32 %405 to i64
%407 = getelementptr inbounds double, double* %403, i64 %406
%408 = load double, double* %407
%409 = fadd double %408, 1.000000e+00
%410 = load double*, double** %12
%411 = load i32, i32* %24
%412 = add nsw i32 %411, 6
%413 = sext i32 %412 to i64
%414 = getelementptr inbounds double, double* %410, i64 %413
store double %409, double* %414
br label %441
415: ; preds = %381
%416 = load double*, double** %12
%417 = load i32, i32* %24
%418 = add nsw i32 %417, 7
%419 = sext i32 %418 to i64
%420 = getelementptr inbounds double, double* %416, i64 %419
%421 = load double, double* %420
%422 = fadd double %421, 1.000000e+00
%423 = load double*, double** %12
%424 = load i32, i32* %24
%425 = add nsw i32 %424, 7
%426 = sext i32 %425 to i64
%427 = getelementptr inbounds double, double* %423, i64 %426
store double %422, double* %427
br label %441
428: ; preds = %381
%429 = load double*, double** %12
%430 = load i32, i32* %24
%431 = add nsw i32 %430, 8
%432 = sext i32 %431 to i64
%433 = getelementptr inbounds double, double* %429, i64 %432
%434 = load double, double* %433
%435 = fadd double %434, 1.000000e+00
%436 = load double*, double** %12
%437 = load i32, i32* %24
%438 = add nsw i32 %437, 8
%439 = sext i32 %438 to i64
%440 = getelementptr inbounds double, double* %436, i64 %439
store double %435, double* %440
br label %441
441: ; preds = %428, %415, %402, %389
br label %442
442: ; preds = %441
%443 = load i32, i32* %23
%444 = add nsw i32 %443, 1
store i32 %444, i32* %23
br label %261
445: ; preds = %261
br label %446
446: ; preds = %445
%447 = load i32, i32* %21
%448 = add nsw i32 %447, 4
store i32 %448, i32* %21
br label %250
449: ; preds = %250
%450 = load i32, i32* %20
%451 = icmp sgt i32 %450, 0
br i1 %451, label %452, label %644
452: ; preds = %449
%453 = load i32*, i32** %28
%454 = call i32 @fread(i8* %18, i32 1, i32 1, i32* %453)
%455 = load i8, i8* %18
%456 = zext i8 %455 to i32
%457 = shl i32 %456, 2
store i32 %457, i32* %19
store i32 0, i32* %23
br label %458
458: ; preds = %640, %452
%459 = load i32, i32* %23
%460 = load i32, i32* %20
%461 = icmp slt i32 %459, %460
br i1 %461, label %462, label %643
462: ; preds = %458
%463 = load i32*, i32** %15
%464 = load i32, i32* %19
%465 = load i32, i32* %23
%466 = add nsw i32 %464, %465
%467 = sext i32 %466 to i64
%468 = getelementptr inbounds i32, i32* %463, i64 %467
%469 = load i32, i32* %468
%470 = load i32*, i32** %16
%471 = load i32, i32* %21
%472 = load i32, i32* %23
%473 = add nsw i32 %471, %472
%474 = sext i32 %473 to i64
%475 = getelementptr inbounds i32, i32* %470, i64 %474
store i32 %469, i32* %475
%476 = load i32*, i32** %16
%477 = load i32, i32* %21
%478 = load i32, i32* %23
%479 = add nsw i32 %477, %478
%480 = sext i32 %479 to i64
%481 = getelementptr inbounds i32, i32* %476, i64 %480
%482 = load i32, i32* %481
switch i32 %482, label %520 [
i32 0, label %483
i32 1, label %494
i32 2, label %507
]
483: ; preds = %462
%484 = load double*, double** %12
%485 = load i32, i32* %24
%486 = sext i32 %485 to i64
%487 = getelementptr inbounds double, double* %484, i64 %486
%488 = load double, double* %487
%489 = fadd double %488, 1.000000e+00
%490 = load double*, double** %12
%491 = load i32, i32* %24
%492 = sext i32 %491 to i64
%493 = getelementptr inbounds double, double* %490, i64 %492
store double %489, double* %493
br label %533
494: ; preds = %462
%495 = load double*, double** %12
%496 = load i32, i32* %24
%497 = add nsw i32 %496, 1
%498 = sext i32 %497 to i64
%499 = getelementptr inbounds double, double* %495, i64 %498
%500 = load double, double* %499
%501 = fadd double %500, 1.000000e+00
%502 = load double*, double** %12
%503 = load i32, i32* %24
%504 = add nsw i32 %503, 1
%505 = sext i32 %504 to i64
%506 = getelementptr inbounds double, double* %502, i64 %505
store double %501, double* %506
br label %533
507: ; preds = %462
%508 = load double*, double** %12
%509 = load i32, i32* %24
%510 = add nsw i32 %509, 2
%511 = sext i32 %510 to i64
%512 = getelementptr inbounds double, double* %508, i64 %511
%513 = load double, double* %512
%514 = fadd double %513, 1.000000e+00
%515 = load double*, double** %12
%516 = load i32, i32* %24
%517 = add nsw i32 %516, 2
%518 = sext i32 %517 to i64
%519 = getelementptr inbounds double, double* %515, i64 %518
store double %514, double* %519
br label %533
520: ; preds = %462
%521 = load double*, double** %12
%522 = load i32, i32* %24
%523 = add nsw i32 %522, 3
%524 = sext i32 %523 to i64
%525 = getelementptr inbounds double, double* %521, i64 %524
%526 = load double, double* %525
%527 = fadd double %526, 1.000000e+00
%528 = load double*, double** %12
%529 = load i32, i32* %24
%530 = add nsw i32 %529, 3
%531 = sext i32 %530 to i64
%532 = getelementptr inbounds double, double* %528, i64 %531
store double %527, double* %532
br label %533
533: ; preds = %520, %507, %494, %483
%534 = load i32*, i32** %11
%535 = load i32, i32* %21
%536 = load i32, i32* %23
%537 = add nsw i32 %535, %536
%538 = sext i32 %537 to i64
%539 = getelementptr inbounds i32, i32* %534, i64 %538
%540 = load i32, i32* %539
switch i32 %540, label %572 [
i32 0, label %541
i32 1, label %558
]
541: ; preds = %533
%542 = load i32*, i32** %16
%543 = load i32, i32* %21
%544 = load i32, i32* %23
%545 = add nsw i32 %543, %544
%546 = sext i32 %545 to i64
%547 = getelementptr inbounds i32, i32* %542, i64 %546
%548 = load i32, i32* %547
%549 = icmp eq i32 %548, -9
%550 = zext i1 %549 to i64
%551 = select i1 %549, i32 -9, i32 0
%552 = load i32*, i32** %17
%553 = load i32, i32* %21
%554 = load i32, i32* %23
%555 = add nsw i32 %553, %554
%556 = sext i32 %555 to i64
%557 = getelementptr inbounds i32, i32* %552, i64 %556
store i32 %551, i32* %557
br label %579
558: ; preds = %533
%559 = load i32*, i32** %16
%560 = load i32, i32* %21
%561 = load i32, i32* %23
%562 = add nsw i32 %560, %561
%563 = sext i32 %562 to i64
%564 = getelementptr inbounds i32, i32* %559, i64 %563
%565 = load i32, i32* %564
%566 = load i32*, i32** %17
%567 = load i32, i32* %21
%568 = load i32, i32* %23
%569 = add nsw i32 %567, %568
%570 = sext i32 %569 to i64
%571 = getelementptr inbounds i32, i32* %566, i64 %570
store i32 %565, i32* %571
br label %579
572: ; preds = %533
%573 = load i32*, i32** %17
%574 = load i32, i32* %21
%575 = load i32, i32* %23
%576 = add nsw i32 %574, %575
%577 = sext i32 %576 to i64
%578 = getelementptr inbounds i32, i32* %573, i64 %577
store i32 -9, i32* %578
br label %579
579: ; preds = %572, %558, %541
%580 = load i32*, i32** %17
%581 = load i32, i32* %21
%582 = load i32, i32* %23
%583 = add nsw i32 %581, %582
%584 = sext i32 %583 to i64
%585 = getelementptr inbounds i32, i32* %580, i64 %584
%586 = load i32, i32* %585
switch i32 %586, label %626 [
i32 0, label %587
i32 1, label %600
i32 2, label %613
]
587: ; preds = %579
%588 = load double*, double** %12
%589 = load i32, i32* %24
%590 = add nsw i32 %589, 5
%591 = sext i32 %590 to i64
%592 = getelementptr inbounds double, double* %588, i64 %591
%593 = load double, double* %592
%594 = fadd double %593, 1.000000e+00
%595 = load double*, double** %12
%596 = load i32, i32* %24
%597 = add nsw i32 %596, 5
%598 = sext i32 %597 to i64
%599 = getelementptr inbounds double, double* %595, i64 %598
store double %594, double* %599
br label %639
600: ; preds = %579
%601 = load double*, double** %12
%602 = load i32, i32* %24
%603 = add nsw i32 %602, 6
%604 = sext i32 %603 to i64
%605 = getelementptr inbounds double, double* %601, i64 %604
%606 = load double, double* %605
%607 = fadd double %606, 1.000000e+00
%608 = load double*, double** %12
%609 = load i32, i32* %24
%610 = add nsw i32 %609, 6
%611 = sext i32 %610 to i64
%612 = getelementptr inbounds double, double* %608, i64 %611
store double %607, double* %612
br label %639
613: ; preds = %579
%614 = load double*, double** %12
%615 = load i32, i32* %24
%616 = add nsw i32 %615, 7
%617 = sext i32 %616 to i64
%618 = getelementptr inbounds double, double* %614, i64 %617
%619 = load double, double* %618
%620 = fadd double %619, 1.000000e+00
%621 = load double*, double** %12
%622 = load i32, i32* %24
%623 = add nsw i32 %622, 7
%624 = sext i32 %623 to i64
%625 = getelementptr inbounds double, double* %621, i64 %624
store double %620, double* %625
br label %639
626: ; preds = %579
%627 = load double*, double** %12
%628 = load i32, i32* %24
%629 = add nsw i32 %628, 8
%630 = sext i32 %629 to i64
%631 = getelementptr inbounds double, double* %627, i64 %630
%632 = load double, double* %631
%633 = fadd double %632, 1.000000e+00
%634 = load double*, double** %12
%635 = load i32, i32* %24
%636 = add nsw i32 %635, 8
%637 = sext i32 %636 to i64
%638 = getelementptr inbounds double, double* %634, i64 %637
store double %633, double* %638
br label %639
639: ; preds = %626, %613, %600, %587
br label %640
640: ; preds = %639
%641 = load i32, i32* %23
%642 = add nsw i32 %641, 1
store i32 %642, i32* %23
br label %458
643: ; preds = %458
br label %644
644: ; preds = %643, %449
%645 = load double*, double** %12
%646 = load i32, i32* %24
%647 = add nsw i32 %646, 1
%648 = sext i32 %647 to i64
%649 = getelementptr inbounds double, double* %645, i64 %648
%650 = load double, double* %649
%651 = load double*, double** %12
%652 = load i32, i32* %24
%653 = add nsw i32 %652, 2
%654 = sext i32 %653 to i64
%655 = getelementptr inbounds double, double* %651, i64 %654
%656 = load double, double* %655
%657 = fadd double %650, %656
%658 = load double*, double** %12
%659 = load i32, i32* %24
%660 = add nsw i32 %659, 2
%661 = sext i32 %660 to i64
%662 = getelementptr inbounds double, double* %658, i64 %661
%663 = load double, double* %662
%664 = fadd double %657, %663
%665 = load i32, i32* %13
%666 = load i32, i32* %13
%667 = add nsw i32 %665, %666
%668 = sitofp i32 %667 to double
%669 = load double*, double** %12
%670 = load i32, i32* %24
%671 = add nsw i32 %670, 3
%672 = sext i32 %671 to i64
%673 = getelementptr inbounds double, double* %669, i64 %672
%674 = load double, double* %673
%675 = fsub double %668, %674
%676 = load double*, double** %12
%677 = load i32, i32* %24
%678 = add nsw i32 %677, 3
%679 = sext i32 %678 to i64
%680 = getelementptr inbounds double, double* %676, i64 %679
%681 = load double, double* %680
%682 = fsub double %675, %681
%683 = fdiv double %664, %682
%684 = load double*, double** %12
%685 = load i32, i32* %24
%686 = add nsw i32 %685, 4
%687 = sext i32 %686 to i64
%688 = getelementptr inbounds double, double* %684, i64 %687
store double %683, double* %688
%689 = load double*, double** %12
%690 = load i32, i32* %24
%691 = add nsw i32 %690, 6
%692 = sext i32 %691 to i64
%693 = getelementptr inbounds double, double* %689, i64 %692
%694 = load double, double* %693
%695 = load double*, double** %12
%696 = load i32, i32* %24
%697 = add nsw i32 %696, 7
%698 = sext i32 %697 to i64
%699 = getelementptr inbounds double, double* %695, i64 %698
%700 = load double, double* %699
%701 = fadd double %694, %700
%702 = load double*, double** %12
%703 = load i32, i32* %24
%704 = add nsw i32 %703, 7
%705 = sext i32 %704 to i64
%706 = getelementptr inbounds double, double* %702, i64 %705
%707 = load double, double* %706
%708 = fadd double %701, %707
%709 = load i32, i32* %13
%710 = load i32, i32* %13
%711 = add nsw i32 %709, %710
%712 = sitofp i32 %711 to double
%713 = load double*, double** %12
%714 = load i32, i32* %24
%715 = add nsw i32 %714, 8
%716 = sext i32 %715 to i64
%717 = getelementptr inbounds double, double* %713, i64 %716
%718 = load double, double* %717
%719 = fsub double %712, %718
%720 = load double*, double** %12
%721 = load i32, i32* %24
%722 = add nsw i32 %721, 8
%723 = sext i32 %722 to i64
%724 = getelementptr inbounds double, double* %720, i64 %723
%725 = load double, double* %724
%726 = fsub double %719, %725
%727 = fdiv double %708, %726
%728 = load double*, double** %12
%729 = load i32, i32* %24
%730 = add nsw i32 %729, 9
%731 = sext i32 %730 to i64
%732 = getelementptr inbounds double, double* %728, i64 %731
store double %727, double* %732
store i32 0, i32* %21
br label %733
733: ; preds = %878, %644
%734 = load i32, i32* %21
%735 = load i32, i32* %13
%736 = sub nsw i32 %735, 1
%737 = icmp slt i32 %734, %736
br i1 %737, label %738, label %881
738: ; preds = %733
%739 = load i32, i32* %21
%740 = add nsw i32 %739, 1
store i32 %740, i32* %23
br label %741
741: ; preds = %874, %738
%742 = load i32, i32* %23
%743 = load i32, i32* %13
%744 = icmp slt i32 %742, %743
br i1 %744, label %745, label %877
745: ; preds = %741
%746 = load i32*, i32** %16
%747 = load i32, i32* %21
%748 = sext i32 %747 to i64
%749 = getelementptr inbounds i32, i32* %746, i64 %748
%750 = load i32, i32* %749
%751 = icmp ne i32 %750, -9
br i1 %751, label %752, label %809
752: ; preds = %745
%753 = load i32*, i32** %16
%754 = load i32, i32* %23
%755 = sext i32 %754 to i64
%756 = getelementptr inbounds i32, i32* %753, i64 %755
%757 = load i32, i32* %756
%758 = icmp ne i32 %757, -9
br i1 %758, label %759, label %809
759: ; preds = %752
%760 = load i32*, i32** %16
%761 = load i32, i32* %21
%762 = sext i32 %761 to i64
%763 = getelementptr inbounds i32, i32* %760, i64 %762
%764 = load i32, i32* %763
%765 = load i32*, i32** %16
%766 = load i32, i32* %23
%767 = sext i32 %766 to i64
%768 = getelementptr inbounds i32, i32* %765, i64 %767
%769 = load i32, i32* %768
%770 = sub nsw i32 %764, %769
%771 = call i32 @abs(i32 %770)
store i32 %771, i32* %25
%772 = load i32, i32* %25
switch i32 %772, label %791 [
i32 0, label %773
i32 2, label %774
]
773: ; preds = %759
br label %808
774: ; preds = %759
%775 = load double*, double** %10
%776 = load i32, i32* %21
%777 = load i32, i32* %13
%778 = mul nsw i32 %776, %777
%779 = load i32, i32* %23
%780 = add nsw i32 %778, %779
%781 = sext i32 %780 to i64
%782 = getelementptr inbounds double, double* %775, i64 %781
%783 = load double, double* %782
%784 = load double*, double** %12
%785 = load i32, i32* %24
%786 = add nsw i32 %785, 10
%787 = sext i32 %786 to i64
%788 = getelementptr inbounds double, double* %784, i64 %787
%789 = load double, double* %788
%790 = fadd double %789, %783
store double %790, double* %788
br label %791
791: ; preds = %759, %774
%792 = load double*, double** %10
%793 = load i32, i32* %21
%794 = load i32, i32* %13
%795 = mul nsw i32 %793, %794
%796 = load i32, i32* %23
%797 = add nsw i32 %795, %796
%798 = sext i32 %797 to i64
%799 = getelementptr inbounds double, double* %792, i64 %798
%800 = load double, double* %799
%801 = load double*, double** %12
%802 = load i32, i32* %24
%803 = add nsw i32 %802, 10
%804 = sext i32 %803 to i64
%805 = getelementptr inbounds double, double* %801, i64 %804
%806 = load double, double* %805
%807 = fadd double %806, %800
store double %807, double* %805
br label %808
808: ; preds = %791, %773
br label %809
809: ; preds = %808, %752, %745
%810 = load i32*, i32** %17
%811 = load i32, i32* %21
%812 = sext i32 %811 to i64
%813 = getelementptr inbounds i32, i32* %810, i64 %812
%814 = load i32, i32* %813
%815 = icmp ne i32 %814, -9
br i1 %815, label %816, label %873
816: ; preds = %809
%817 = load i32*, i32** %17
%818 = load i32, i32* %23
%819 = sext i32 %818 to i64
%820 = getelementptr inbounds i32, i32* %817, i64 %819
%821 = load i32, i32* %820
%822 = icmp ne i32 %821, -9
br i1 %822, label %823, label %873
823: ; preds = %816
%824 = load i32*, i32** %17
%825 = load i32, i32* %21
%826 = sext i32 %825 to i64
%827 = getelementptr inbounds i32, i32* %824, i64 %826
%828 = load i32, i32* %827
%829 = load i32*, i32** %17
%830 = load i32, i32* %23
%831 = sext i32 %830 to i64
%832 = getelementptr inbounds i32, i32* %829, i64 %831
%833 = load i32, i32* %832
%834 = sub nsw i32 %828, %833
%835 = call i32 @abs(i32 %834)
store i32 %835, i32* %25
%836 = load i32, i32* %25
switch i32 %836, label %855 [
i32 0, label %837
i32 2, label %838
]
837: ; preds = %823
br label %872
838: ; preds = %823
%839 = load double*, double** %10
%840 = load i32, i32* %21
%841 = load i32, i32* %13
%842 = mul nsw i32 %840, %841
%843 = load i32, i32* %23
%844 = add nsw i32 %842, %843
%845 = sext i32 %844 to i64
%846 = getelementptr inbounds double, double* %839, i64 %845
%847 = load double, double* %846
%848 = load double*, double** %12
%849 = load i32, i32* %24
%850 = add nsw i32 %849, 11
%851 = sext i32 %850 to i64
%852 = getelementptr inbounds double, double* %848, i64 %851
%853 = load double, double* %852
%854 = fadd double %853, %847
store double %854, double* %852
br label %855
855: ; preds = %823, %838
%856 = load double*, double** %10
%857 = load i32, i32* %21
%858 = load i32, i32* %13
%859 = mul nsw i32 %857, %858
%860 = load i32, i32* %23
%861 = add nsw i32 %859, %860
%862 = sext i32 %861 to i64
%863 = getelementptr inbounds double, double* %856, i64 %862
%864 = load double, double* %863
%865 = load double*, double** %12
%866 = load i32, i32* %24
%867 = add nsw i32 %866, 11
%868 = sext i32 %867 to i64
%869 = getelementptr inbounds double, double* %865, i64 %868
%870 = load double, double* %869
%871 = fadd double %870, %864
store double %871, double* %869
br label %872
872: ; preds = %855, %837
br label %873
873: ; preds = %872, %816, %809
br label %874
874: ; preds = %873
%875 = load i32, i32* %23
%876 = add nsw i32 %875, 1
store i32 %876, i32* %23
br label %741
877: ; preds = %741
br label %878
878: ; preds = %877
%879 = load i32, i32* %21
%880 = add nsw i32 %879, 1
store i32 %880, i32* %21
br label %733
881: ; preds = %733
br label %882
882: ; preds = %881
%883 = load i32, i32* %22
%884 = add nsw i32 %883, 1
store i32 %884, i32* %22
br label %242
885: ; preds = %242
%886 = load i32*, i32** %28
%887 = call i32 @fclose(i32* %886)
%888 = load i32*, i32** %16
%889 = call i32 @free(i32* %888)
%890 = load i32*, i32** %17
%891 = call i32 @free(i32* %890)
%892 = load i32*, i32** %15
%893 = call i32 @free(i32* %892)
ret void
}

LLVM IR (-O2):
@.str = [3 x i8] c"rb\00"
@.str.1 = [21 x i8] c"Unable to open file!\00"
@SEEK_SET = global i32 0
@switch.table.parsePlink.4 = [4 x i32] [i32 2, i32 -9, i32 1, i32 0]
define void @parsePlink(i8** nocapture %0, i32* nocapture %1, i32* nocapture %2, double* nocapture %3, i32* nocapture %4, double* %5) {
%7 = alloca i8
%8 = load i32, i32* %1
%9 = load i32, i32* %2
%10 = tail call i64 @malloc(i32 4096)
%11 = inttoptr i64 %10 to i32*
%12 = shl i32 %8, 2
%13 = tail call i64 @malloc(i32 %12)
%14 = inttoptr i64 %13 to i32*
%15 = tail call i64 @malloc(i32 %12)
%16 = inttoptr i64 %15 to i32*
%17 = srem i32 %8, 4
%18 = icmp sgt i32 %9, 0
br i1 %18, label %19, label %23
19: ; preds = %6
%20 = bitcast double* %5 to i8*
%21 = zext i32 %9 to i64
%22 = mul nuw nsw i64 %21, 96
br label %23
23: ; preds = %19, %6
%24 = add i32 %8, -1
%25 = icmp sgt i32 %8, 1
br i1 %25, label %26, label %100
26: ; preds = %23
%27 = zext i32 %8 to i64
%28 = zext i32 %24 to i64
%29 = zext i32 %8 to i64
%30 = and i64 %28, 1
%31 = icmp eq i32 %24, 1
br i1 %31, label %73, label %32
32: ; preds = %26
%33 = and i64 %28, 4294967294
br label %55
34: ; preds = %64, %55
%35 = phi double [ %58, %55 ], [ %70, %64 ]
%36 = add nuw nsw i64 %56, 2
%37 = icmp ult i64 %36, %27
br i1 %37, label %38, label %50
38: ; preds = %34
%39 = add nuw nsw i64 %57, 1
%40 = mul nsw i64 %60, %27
br label %41
41: ; preds = %41, %38
%42 = phi i64 [ %39, %38 ], [ %48, %41 ]
%43 = phi double [ %35, %38 ], [ %47, %41 ]
%44 = add nuw nsw i64 %42, %40
%45 = getelementptr inbounds double, double* %3, i64 %44
%46 = load double, double* %45
%47 = fadd double %43, %46
%48 = add nuw nsw i64 %42, 1
%49 = icmp eq i64 %48, %29
br i1 %49, label %50, label %41
50: ; preds = %41, %34
%51 = phi double [ %35, %34 ], [ %47, %41 ]
%52 = add nuw nsw i64 %57, 2
%53 = add i64 %59, 2
%54 = icmp eq i64 %53, %33
br i1 %54, label %73, label %55
55: ; preds = %50, %32
%56 = phi i64 [ 0, %32 ], [ %36, %50 ]
%57 = phi i64 [ 1, %32 ], [ %52, %50 ]
%58 = phi double [ 0.000000e+00, %32 ], [ %51, %50 ]
%59 = phi i64 [ 0, %32 ], [ %53, %50 ]
%60 = or i64 %56, 1
%61 = icmp ult i64 %60, %27
br i1 %61, label %62, label %34
62: ; preds = %55
%63 = mul nsw i64 %56, %27
br label %64
64: ; preds = %62, %64
%65 = phi i64 [ %57, %62 ], [ %71, %64 ]
%66 = phi double [ %58, %62 ], [ %70, %64 ]
%67 = add nuw nsw i64 %65, %63
%68 = getelementptr inbounds double, double* %3, i64 %67
%69 = load double, double* %68
%70 = fadd double %66, %69
%71 = add nuw nsw i64 %65, 1
%72 = icmp eq i64 %71, %29
br i1 %72, label %34, label %64
73: ; preds = %50, %26
%74 = phi double [ undef, %26 ], [ %51, %50 ]
%75 = phi i64 [ 0, %26 ], [ %36, %50 ]
%76 = phi i64 [ 1, %26 ], [ %52, %50 ]
%77 = phi double [ 0.000000e+00, %26 ], [ %51, %50 ]
%78 = icmp eq i64 %30, 0
br i1 %78, label %93, label %79
79: ; preds = %73
%80 = add nuw nsw i64 %75, 1
%81 = icmp ult i64 %80, %27
br i1 %81, label %82, label %93
82: ; preds = %79
%83 = mul nsw i64 %75, %27
br label %84
84: ; preds = %84, %82
%85 = phi i64 [ %76, %82 ], [ %91, %84 ]
%86 = phi double [ %77, %82 ], [ %90, %84 ]
%87 = add nuw nsw i64 %85, %83
%88 = getelementptr inbounds double, double* %3, i64 %87
%89 = load double, double* %88
%90 = fadd double %86, %89
%91 = add nuw nsw i64 %85, 1
%92 = icmp eq i64 %91, %29
br i1 %92, label %93, label %84
93: ; preds = %79, %84, %73
%94 = phi double [ %74, %73 ], [ %77, %79 ], [ %90, %84 ]
%95 = sitofp i32 %8 to double
%96 = sitofp i32 %24 to double
%97 = fmul double %95, %96
%98 = fmul double %97, 5.000000e-01
%99 = fdiv double %94, %98
br i1 %25, label %101, label %100
100: ; preds = %105, %23, %93
br label %128
101: ; preds = %93
%102 = zext i32 %8 to i64
%103 = zext i32 %24 to i64
%104 = zext i32 %8 to i64
br label %108
105: ; preds = %115, %108
%106 = add nuw nsw i64 %110, 1
%107 = icmp eq i64 %111, %103
br i1 %107, label %100, label %108
108: ; preds = %101, %105
%109 = phi i64 [ 0, %101 ], [ %111, %105 ]
%110 = phi i64 [ 1, %101 ], [ %106, %105 ]
%111 = add nuw nsw i64 %109, 1
%112 = icmp ult i64 %111, %102
br i1 %112, label %113, label %105
113: ; preds = %108
%114 = mul nsw i64 %109, %102
br label %115
115: ; preds = %113, %115
%116 = phi i64 [ %110, %113 ], [ %126, %115 ]
%117 = add nuw nsw i64 %116, %114
%118 = getelementptr inbounds double, double* %3, i64 %117
%119 = load double, double* %118
%120 = fsub double %119, %99
store double %120, double* %118
%121 = mul nsw i64 %116, %102
%122 = add nuw nsw i64 %121, %109
%123 = getelementptr inbounds double, double* %3, i64 %122
%124 = load double, double* %123
%125 = fsub double %124, %99
store double %125, double* %123
%126 = add nuw nsw i64 %116, 1
%127 = icmp eq i64 %126, %104
br i1 %127, label %105, label %115
128: ; preds = %100, %128
%129 = phi i64 [ %153, %128 ], [ 0, %100 ]
%130 = shl nuw nsw i64 %129, 2
%131 = and i64 %129, 3
%132 = getelementptr inbounds [4 x i32], [4 x i32]* @switch.table.parsePlink.4, i64 0, i64 %131
%133 = load i32, i32* %132
%134 = getelementptr inbounds i32, i32* %11, i64 %130
store i32 %133, i32* %134
%135 = lshr i64 %129, 2
%136 = and i64 %135, 3
%137 = getelementptr inbounds [4 x i32], [4 x i32]* @switch.table.parsePlink.4, i64 0, i64 %136
%138 = load i32, i32* %137
%139 = or i64 %130, 1
%140 = getelementptr inbounds i32, i32* %11, i64 %139
store i32 %138, i32* %140
%141 = lshr i64 %129, 4
%142 = and i64 %141, 3
%143 = getelementptr inbounds [4 x i32], [4 x i32]* @switch.table.parsePlink.4, i64 0, i64 %142
%144 = load i32, i32* %143
%145 = or i64 %130, 2
%146 = getelementptr inbounds i32, i32* %11, i64 %145
store i32 %144, i32* %146
%147 = lshr i64 %129, 6
%148 = and i64 %147, 3
%149 = getelementptr inbounds [4 x i32], [4 x i32]* @switch.table.parsePlink.4, i64 0, i64 %148
%150 = load i32, i32* %149
%151 = or i64 %130, 3
%152 = getelementptr inbounds i32, i32* %11, i64 %151
store i32 %150, i32* %152
%153 = add nuw nsw i64 %129, 1
%154 = icmp eq i64 %153, 256
br i1 %154, label %155, label %128
155: ; preds = %128
store i8 -1, i8* %7
%156 = load i8*, i8** %0
%157 = tail call i32* @fopen(i8* %156, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0))
%158 = icmp eq i32* %157, null
br i1 %158, label %159, label %161
159: ; preds = %155
%160 = tail call i32 @printf(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @.str.1, i64 0, i64 0))
br label %161
161: ; preds = %159, %155
%162 = load i32, i32* @SEEK_SET
%163 = tail call i32 @fseek(i32* %157, i32 3, i32 %162)
br i1 %18, label %164, label %569
164: ; preds = %161
%165 = add nsw i32 %8, -3
%166 = icmp sgt i32 %8, 3
%167 = icmp sgt i32 %17, 0
%168 = shl nsw i32 %8, 1
%169 = sitofp i32 %168 to double
%170 = sext i32 %8 to i64
%171 = zext i32 %9 to i64
%172 = zext i32 %24 to i64
%173 = zext i32 %8 to i64
%174 = icmp eq i32 %17, 1
%175 = icmp eq i32 %17, 2
br label %176
176: ; preds = %164, %566
%177 = phi i64 [ 0, %164 ], [ %567, %566 ]
%178 = trunc i64 %177 to i32
%179 = mul nsw i32 %178, 12
br i1 %166, label %180, label %327
180: ; preds = %176
%181 = or i32 %179, 2
%182 = zext i32 %181 to i64
%183 = getelementptr inbounds double, double* %5, i64 %182
%184 = or i32 %179, 1
%185 = zext i32 %184 to i64
%186 = getelementptr inbounds double, double* %5, i64 %185
%187 = zext i32 %179 to i64
%188 = getelementptr inbounds double, double* %5, i64 %187
%189 = or i32 %179, 3
%190 = zext i32 %189 to i64
%191 = getelementptr inbounds double, double* %5, i64 %190
%192 = add nuw nsw i32 %179, 7
%193 = zext i32 %192 to i64
%194 = getelementptr inbounds double, double* %5, i64 %193
%195 = add nuw nsw i32 %179, 6
%196 = zext i32 %195 to i64
%197 = getelementptr inbounds double, double* %5, i64 %196
%198 = add nuw nsw i32 %179, 5
%199 = zext i32 %198 to i64
%200 = getelementptr inbounds double, double* %5, i64 %199
%201 = add nuw nsw i32 %179, 8
%202 = zext i32 %201 to i64
%203 = getelementptr inbounds double, double* %5, i64 %202
br label %204
204: ; preds = %180, %320
%205 = phi i64 [ 0, %180 ], [ %324, %320 ]
%206 = call i32 @fread(i8* %7, i32 1, i32 1, i32* %157)
%207 = load i8, i8* %7
%208 = zext i8 %207 to i64
%209 = shl nuw nsw i64 %208, 2
%210 = getelementptr inbounds i32, i32* %11, i64 %209
%211 = load i32, i32* %210
%212 = getelementptr inbounds i32, i32* %14, i64 %205
store i32 %211, i32* %212
switch i32 %211, label %215 [
i32 0, label %216
i32 1, label %213
i32 2, label %214
]
213: ; preds = %204
br label %216
214: ; preds = %204
br label %216
215: ; preds = %204
br label %216
216: ; preds = %204, %215, %214, %213
%217 = phi double* [ %191, %215 ], [ %183, %214 ], [ %186, %213 ], [ %188, %204 ]
%218 = load double, double* %217
%219 = fadd double %218, 1.000000e+00
store double %219, double* %217
%220 = getelementptr inbounds i32, i32* %4, i64 %205
%221 = load i32, i32* %220
switch i32 %221, label %225 [
i32 0, label %222
i32 1, label %227
]
222: ; preds = %216
%223 = icmp eq i32 %211, -9
%224 = select i1 %223, i32 -9, i32 0
br label %227
225: ; preds = %216
%226 = getelementptr inbounds i32, i32* %16, i64 %205
store i32 -9, i32* %226
br label %232
227: ; preds = %216, %222
%228 = phi i32 [ %224, %222 ], [ %211, %216 ]
%229 = getelementptr inbounds i32, i32* %16, i64 %205
store i32 %228, i32* %229
switch i32 %228, label %232 [
i32 0, label %233
i32 1, label %230
i32 2, label %231
]
230: ; preds = %227
br label %233
231: ; preds = %227
br label %233
232: ; preds = %225, %227
br label %233
233: ; preds = %227, %230, %231, %232
%234 = phi double* [ %197, %230 ], [ %194, %231 ], [ %203, %232 ], [ %200, %227 ]
%235 = load double, double* %234
%236 = fadd double %235, 1.000000e+00
store double %236, double* %234
%237 = or i64 %209, 1
%238 = getelementptr inbounds i32, i32* %11, i64 %237
%239 = load i32, i32* %238
%240 = or i64 %205, 1
%241 = getelementptr inbounds i32, i32* %14, i64 %240
store i32 %239, i32* %241
switch i32 %239, label %244 [
i32 0, label %245
i32 1, label %243
i32 2, label %242
]
242: ; preds = %233
br label %245
243: ; preds = %233
br label %245
244: ; preds = %233
br label %245
245: ; preds = %244, %243, %242, %233
%246 = phi double* [ %191, %244 ], [ %183, %242 ], [ %186, %243 ], [ %188, %233 ]
%247 = load double, double* %246
%248 = fadd double %247, 1.000000e+00
store double %248, double* %246
%249 = getelementptr inbounds i32, i32* %4, i64 %240
%250 = load i32, i32* %249
switch i32 %250, label %259 [
i32 0, label %251
i32 1, label %254
]
251: ; preds = %245
%252 = icmp eq i32 %239, -9
%253 = select i1 %252, i32 -9, i32 0
br label %254
254: ; preds = %251, %245
%255 = phi i32 [ %253, %251 ], [ %239, %245 ]
%256 = getelementptr inbounds i32, i32* %16, i64 %240
store i32 %255, i32* %256
switch i32 %255, label %261 [
i32 0, label %262
i32 1, label %258
i32 2, label %257
]
257: ; preds = %254
br label %262
258: ; preds = %254
br label %262
259: ; preds = %245
%260 = getelementptr inbounds i32, i32* %16, i64 %240
store i32 -9, i32* %260
br label %261
261: ; preds = %259, %254
br label %262
262: ; preds = %261, %258, %257, %254
%263 = phi double* [ %197, %258 ], [ %194, %257 ], [ %203, %261 ], [ %200, %254 ]
%264 = load double, double* %263
%265 = fadd double %264, 1.000000e+00
store double %265, double* %263
%266 = or i64 %209, 2
%267 = getelementptr inbounds i32, i32* %11, i64 %266
%268 = load i32, i32* %267
%269 = or i64 %205, 2
%270 = getelementptr inbounds i32, i32* %14, i64 %269
store i32 %268, i32* %270
switch i32 %268, label %273 [
i32 0, label %274
i32 1, label %272
i32 2, label %271
]
271: ; preds = %262
br label %274
272: ; preds = %262
br label %274
273: ; preds = %262
br label %274
274: ; preds = %273, %272, %271, %262
%275 = phi double* [ %191, %273 ], [ %183, %271 ], [ %186, %272 ], [ %188, %262 ]
%276 = load double, double* %275
%277 = fadd double %276, 1.000000e+00
store double %277, double* %275
%278 = getelementptr inbounds i32, i32* %4, i64 %269
%279 = load i32, i32* %278
switch i32 %279, label %288 [
i32 0, label %280
i32 1, label %283
]
280: ; preds = %274
%281 = icmp eq i32 %268, -9
%282 = select i1 %281, i32 -9, i32 0
br label %283
283: ; preds = %280, %274
%284 = phi i32 [ %282, %280 ], [ %268, %274 ]
%285 = getelementptr inbounds i32, i32* %16, i64 %269
store i32 %284, i32* %285
switch i32 %284, label %290 [
i32 0, label %291
i32 1, label %287
i32 2, label %286
]
286: ; preds = %283
br label %291
287: ; preds = %283
br label %291
288: ; preds = %274
%289 = getelementptr inbounds i32, i32* %16, i64 %269
store i32 -9, i32* %289
br label %290
290: ; preds = %288, %283
br label %291
291: ; preds = %290, %287, %286, %283
%292 = phi double* [ %197, %287 ], [ %194, %286 ], [ %203, %290 ], [ %200, %283 ]
%293 = load double, double* %292
%294 = fadd double %293, 1.000000e+00
store double %294, double* %292
%295 = or i64 %209, 3
%296 = getelementptr inbounds i32, i32* %11, i64 %295
%297 = load i32, i32* %296
%298 = or i64 %205, 3
%299 = getelementptr inbounds i32, i32* %14, i64 %298
store i32 %297, i32* %299
switch i32 %297, label %302 [
i32 0, label %303
i32 1, label %301
i32 2, label %300
]
300: ; preds = %291
br label %303
301: ; preds = %291
br label %303
302: ; preds = %291
br label %303
303: ; preds = %302, %301, %300, %291
%304 = phi double* [ %191, %302 ], [ %183, %300 ], [ %186, %301 ], [ %188, %291 ]
%305 = load double, double* %304
%306 = fadd double %305, 1.000000e+00
store double %306, double* %304
%307 = getelementptr inbounds i32, i32* %4, i64 %298
%308 = load i32, i32* %307
switch i32 %308, label %317 [
i32 0, label %309
i32 1, label %312
]
309: ; preds = %303
%310 = icmp eq i32 %297, -9
%311 = select i1 %310, i32 -9, i32 0
br label %312
312: ; preds = %309, %303
%313 = phi i32 [ %311, %309 ], [ %297, %303 ]
%314 = getelementptr inbounds i32, i32* %16, i64 %298
store i32 %313, i32* %314
switch i32 %313, label %319 [
i32 0, label %320
i32 1, label %316
i32 2, label %315
]
315: ; preds = %312
br label %320
316: ; preds = %312
br label %320
317: ; preds = %303
%318 = getelementptr inbounds i32, i32* %16, i64 %298
store i32 -9, i32* %318
br label %319
319: ; preds = %317, %312
br label %320
320: ; preds = %319, %316, %315, %312
%321 = phi double* [ %197, %316 ], [ %194, %315 ], [ %203, %319 ], [ %200, %312 ]
%322 = load double, double* %321
%323 = fadd double %322, 1.000000e+00
store double %323, double* %321
%324 = add nuw i64 %205, 4
%325 = trunc i64 %324 to i32
%326 = icmp sgt i32 %165, %325
br i1 %326, label %204, label %327
327: ; preds = %320, %176
%328 = phi i64 [ 0, %176 ], [ %324, %320 ]
br i1 %167, label %342, label %329
329: ; preds = %327
%330 = or i32 %179, 1
%331 = zext i32 %330 to i64
%332 = or i32 %179, 2
%333 = zext i32 %332 to i64
%334 = or i32 %179, 3
%335 = zext i32 %334 to i64
%336 = add nuw nsw i32 %179, 6
%337 = zext i32 %336 to i64
%338 = add nuw nsw i32 %179, 7
%339 = zext i32 %338 to i64
%340 = add nuw nsw i32 %179, 8
%341 = zext i32 %340 to i64
br label %458
342: ; preds = %327
%343 = call i32 @fread(i8* %7, i32 1, i32 1, i32* %157)
%344 = load i8, i8* %7
%345 = zext i8 %344 to i64
%346 = shl nuw nsw i64 %345, 2
%347 = or i32 %179, 2
%348 = zext i32 %347 to i64
%349 = getelementptr inbounds double, double* %5, i64 %348
%350 = or i32 %179, 1
%351 = zext i32 %350 to i64
%352 = getelementptr inbounds double, double* %5, i64 %351
%353 = zext i32 %179 to i64
%354 = getelementptr inbounds double, double* %5, i64 %353
%355 = or i32 %179, 3
%356 = zext i32 %355 to i64
%357 = getelementptr inbounds double, double* %5, i64 %356
%358 = add nuw nsw i32 %179, 7
%359 = zext i32 %358 to i64
%360 = getelementptr inbounds double, double* %5, i64 %359
%361 = add nuw nsw i32 %179, 6
%362 = zext i32 %361 to i64
%363 = getelementptr inbounds double, double* %5, i64 %362
%364 = add nuw nsw i32 %179, 5
%365 = zext i32 %364 to i64
%366 = getelementptr inbounds double, double* %5, i64 %365
%367 = add nuw nsw i32 %179, 8
%368 = zext i32 %367 to i64
%369 = getelementptr inbounds double, double* %5, i64 %368
%370 = and i64 %328, 4294967295
%371 = getelementptr inbounds i32, i32* %11, i64 %346
%372 = load i32, i32* %371
%373 = getelementptr inbounds i32, i32* %14, i64 %370
store i32 %372, i32* %373
switch i32 %372, label %376 [
i32 0, label %377
i32 1, label %374
i32 2, label %375
]
374: ; preds = %342
br label %377
375: ; preds = %342
br label %377
376: ; preds = %342
br label %377
377: ; preds = %342, %376, %375, %374
%378 = phi double* [ %357, %376 ], [ %349, %375 ], [ %352, %374 ], [ %354, %342 ]
%379 = load double, double* %378
%380 = fadd double %379, 1.000000e+00
store double %380, double* %378
%381 = getelementptr inbounds i32, i32* %4, i64 %370
%382 = load i32, i32* %381
switch i32 %382, label %386 [
i32 0, label %383
i32 1, label %388
]
383: ; preds = %377
%384 = icmp eq i32 %372, -9
%385 = select i1 %384, i32 -9, i32 0
br label %388
386: ; preds = %377
%387 = getelementptr inbounds i32, i32* %16, i64 %370
store i32 -9, i32* %387
br label %393
388: ; preds = %377, %383
%389 = phi i32 [ %385, %383 ], [ %372, %377 ]
%390 = getelementptr inbounds i32, i32* %16, i64 %370
store i32 %389, i32* %390
switch i32 %389, label %393 [
i32 0, label %394
i32 1, label %391
i32 2, label %392
]
391: ; preds = %388
br label %394
392: ; preds = %388
br label %394
393: ; preds = %386, %388
br label %394
394: ; preds = %388, %391, %392, %393
%395 = phi double* [ %363, %391 ], [ %360, %392 ], [ %369, %393 ], [ %366, %388 ]
%396 = load double, double* %395
%397 = fadd double %396, 1.000000e+00
store double %397, double* %395
br i1 %174, label %458, label %398
398: ; preds = %394
%399 = or i64 %346, 1
%400 = getelementptr inbounds i32, i32* %11, i64 %399
%401 = load i32, i32* %400
%402 = add nuw nsw i64 %370, 1
%403 = getelementptr inbounds i32, i32* %14, i64 %402
store i32 %401, i32* %403
switch i32 %401, label %406 [
i32 0, label %407
i32 1, label %405
i32 2, label %404
]
404: ; preds = %398
br label %407
405: ; preds = %398
br label %407
406: ; preds = %398
br label %407
407: ; preds = %406, %405, %404, %398
%408 = phi double* [ %357, %406 ], [ %349, %404 ], [ %352, %405 ], [ %354, %398 ]
%409 = load double, double* %408
%410 = fadd double %409, 1.000000e+00
store double %410, double* %408
%411 = getelementptr inbounds i32, i32* %4, i64 %402
%412 = load i32, i32* %411
switch i32 %412, label %421 [
i32 0, label %413
i32 1, label %416
]
413: ; preds = %407
%414 = icmp eq i32 %401, -9
%415 = select i1 %414, i32 -9, i32 0
br label %416
416: ; preds = %413, %407
%417 = phi i32 [ %415, %413 ], [ %401, %407 ]
%418 = getelementptr inbounds i32, i32* %16, i64 %402
store i32 %417, i32* %418
switch i32 %417, label %423 [
i32 0, label %424
i32 1, label %420
i32 2, label %419
]
419: ; preds = %416
br label %424
420: ; preds = %416
br label %424
421: ; preds = %407
%422 = getelementptr inbounds i32, i32* %16, i64 %402
store i32 -9, i32* %422
br label %423
423: ; preds = %421, %416
br label %424
424: ; preds = %423, %420, %419, %416
%425 = phi double* [ %363, %420 ], [ %360, %419 ], [ %369, %423 ], [ %366, %416 ]
%426 = load double, double* %425
%427 = fadd double %426, 1.000000e+00
store double %427, double* %425
br i1 %175, label %458, label %428
428: ; preds = %424
%429 = or i64 %346, 2
%430 = getelementptr inbounds i32, i32* %11, i64 %429
%431 = load i32, i32* %430
%432 = add nuw nsw i64 %370, 2
%433 = getelementptr inbounds i32, i32* %14, i64 %432
store i32 %431, i32* %433
switch i32 %431, label %436 [
i32 0, label %437
i32 1, label %435
i32 2, label %434
]
434: ; preds = %428
br label %437
435: ; preds = %428
br label %437
436: ; preds = %428
br label %437
437: ; preds = %436, %435, %434, %428
%438 = phi double* [ %357, %436 ], [ %349, %434 ], [ %352, %435 ], [ %354, %428 ]
%439 = load double, double* %438
%440 = fadd double %439, 1.000000e+00
store double %440, double* %438
%441 = getelementptr inbounds i32, i32* %4, i64 %432
%442 = load i32, i32* %441
switch i32 %442, label %451 [
i32 0, label %443
i32 1, label %446
]
443: ; preds = %437
%444 = icmp eq i32 %431, -9
%445 = select i1 %444, i32 -9, i32 0
br label %446
446: ; preds = %443, %437
%447 = phi i32 [ %445, %443 ], [ %431, %437 ]
%448 = getelementptr inbounds i32, i32* %16, i64 %432
store i32 %447, i32* %448
switch i32 %447, label %453 [
i32 0, label %454
i32 1, label %450
i32 2, label %449
]
449: ; preds = %446
br label %454
450: ; preds = %446
br label %454
451: ; preds = %437
%452 = getelementptr inbounds i32, i32* %16, i64 %432
store i32 -9, i32* %452
br label %453
453: ; preds = %451, %446
br label %454
454: ; preds = %453, %450, %449, %446
%455 = phi double* [ %363, %450 ], [ %360, %449 ], [ %369, %453 ], [ %366, %446 ]
%456 = load double, double* %455
%457 = fadd double %456, 1.000000e+00
store double %457, double* %455
br label %458
458: ; preds = %394, %424, %454, %329
%459 = phi i64 [ %341, %329 ], [ %368, %454 ], [ %368, %424 ], [ %368, %394 ]
%460 = phi i64 [ %339, %329 ], [ %359, %454 ], [ %359, %424 ], [ %359, %394 ]
%461 = phi i64 [ %337, %329 ], [ %362, %454 ], [ %362, %424 ], [ %362, %394 ]
%462 = phi i64 [ %335, %329 ], [ %356, %454 ], [ %356, %424 ], [ %356, %394 ]
%463 = phi i64 [ %333, %329 ], [ %348, %454 ], [ %348, %424 ], [ %348, %394 ]
%464 = phi i64 [ %331, %329 ], [ %351, %454 ], [ %351, %424 ], [ %351, %394 ]
%465 = getelementptr inbounds double, double* %5, i64 %464
%466 = load double, double* %465
%467 = getelementptr inbounds double, double* %5, i64 %463
%468 = load double, double* %467
%469 = fadd double %466, %468
%470 = fadd double %468, %469
%471 = getelementptr inbounds double, double* %5, i64 %462
%472 = load double, double* %471
%473 = fsub double %169, %472
%474 = fsub double %473, %472
%475 = fdiv double %470, %474
%476 = add nuw nsw i32 %179, 4
%477 = zext i32 %476 to i64
%478 = getelementptr inbounds double, double* %5, i64 %477
store double %475, double* %478
%479 = getelementptr inbounds double, double* %5, i64 %461
%480 = load double, double* %479
%481 = getelementptr inbounds double, double* %5, i64 %460
%482 = load double, double* %481
%483 = fadd double %480, %482
%484 = fadd double %482, %483
%485 = getelementptr inbounds double, double* %5, i64 %459
%486 = load double, double* %485
%487 = fsub double %169, %486
%488 = fsub double %487, %486
%489 = fdiv double %484, %488
%490 = add nuw nsw i32 %179, 9
%491 = zext i32 %490 to i64
%492 = getelementptr inbounds double, double* %5, i64 %491
store double %489, double* %492
br i1 %25, label %493, label %566
493: ; preds = %458
%494 = add nuw nsw i32 %179, 10
%495 = zext i32 %494 to i64
%496 = getelementptr inbounds double, double* %5, i64 %495
%497 = add nuw nsw i32 %179, 11
%498 = zext i32 %497 to i64
%499 = getelementptr inbounds double, double* %5, i64 %498
br label %503
500: ; preds = %563, %503
%501 = add nuw nsw i64 %505, 1
%502 = icmp eq i64 %506, %172
br i1 %502, label %566, label %503
503: ; preds = %493, %500
%504 = phi i64 [ 0, %493 ], [ %506, %500 ]
%505 = phi i64 [ 1, %493 ], [ %501, %500 ]
%506 = add nuw nsw i64 %504, 1
%507 = icmp slt i64 %506, %170
br i1 %507, label %508, label %500
508: ; preds = %503
%509 = getelementptr inbounds i32, i32* %14, i64 %504
%510 = load i32, i32* %509
%511 = icmp eq i32 %510, -9
%512 = mul nsw i64 %504, %170
%513 = getelementptr inbounds i32, i32* %16, i64 %504
%514 = load i32, i32* %513
%515 = icmp eq i32 %514, -9
br label %516
516: ; preds = %508, %563
%517 = phi i64 [ %505, %508 ], [ %564, %563 ]
br i1 %511, label %540, label %518
518: ; preds = %516
%519 = getelementptr inbounds i32, i32* %14, i64 %517
%520 = load i32, i32* %519
%521 = icmp eq i32 %520, -9
br i1 %521, label %540, label %522
522: ; preds = %518
%523 = sub nsw i32 %510, %520
%524 = tail call i32 @llvm.abs.i32(i32 %523, i1 true)
switch i32 %524, label %525 [
i32 0, label %540
i32 2, label %528
]
525: ; preds = %522
%526 = load double, double* %496
%527 = add nsw i64 %517, %512
br label %534
528: ; preds = %522
%529 = add nsw i64 %517, %512
%530 = getelementptr inbounds double, double* %3, i64 %529
%531 = load double, double* %530
%532 = load double, double* %496
%533 = fadd double %531, %532
store double %533, double* %496
br label %534
534: ; preds = %525, %528
%535 = phi i64 [ %527, %525 ], [ %529, %528 ]
%536 = phi double [ %526, %525 ], [ %533, %528 ]
%537 = getelementptr inbounds double, double* %3, i64 %535
%538 = load double, double* %537
%539 = fadd double %538, %536
store double %539, double* %496
br label %540
540: ; preds = %522, %534, %518, %516
br i1 %515, label %563, label %541
541: ; preds = %540
%542 = getelementptr inbounds i32, i32* %16, i64 %517
%543 = load i32, i32* %542
%544 = icmp eq i32 %543, -9
br i1 %544, label %563, label %545
545: ; preds = %541
%546 = sub nsw i32 %514, %543
%547 = tail call i32 @llvm.abs.i32(i32 %546, i1 true)
switch i32 %547, label %548 [
i32 0, label %563
i32 2, label %551
]
548: ; preds = %545
%549 = load double, double* %499
%550 = add nsw i64 %517, %512
br label %557
551: ; preds = %545
%552 = add nsw i64 %517, %512
%553 = getelementptr inbounds double, double* %3, i64 %552
%554 = load double, double* %553
%555 = load double, double* %499
%556 = fadd double %554, %555
store double %556, double* %499
br label %557
557: ; preds = %548, %551
%558 = phi i64 [ %550, %548 ], [ %552, %551 ]
%559 = phi double [ %549, %548 ], [ %556, %551 ]
%560 = getelementptr inbounds double, double* %3, i64 %558
%561 = load double, double* %560
%562 = fadd double %561, %559
store double %562, double* %499
br label %563
563: ; preds = %540, %541, %557, %545
%564 = add nuw nsw i64 %517, 1
%565 = icmp eq i64 %564, %173
br i1 %565, label %500, label %516
566: ; preds = %500, %458
%567 = add nuw nsw i64 %177, 1
%568 = icmp eq i64 %567, %171
br i1 %568, label %569, label %176
569: ; preds = %566, %161
%570 = tail call i32 @fclose(i32* %157)
%571 = tail call i32 @free(i32* %14)
%572 = tail call i32 @free(i32* %16)
%573 = tail call i32 @free(i32* %11)
ret void
}