#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ SEEK_SET;
int /*<<< orphan*/ free(unsigned char *);
int getpagesize();
int lseek64(int, long long, int /*<<< orphan*/);
scalar_t__ malloc(long long);
int /*<<< orphan*/ memcpy(char *, ...);
scalar_t__ read(int, unsigned char *, int);
int /*<<< orphan*/ strncmp(char *, char *, int);
void *strtol(char *, char **, int);
int parsepvd(int isofd, char *mediasum, int *skipsectors, long long *isosize,
             int *supported, char *fragmentsums, long long *fragmentcount) {
  int pagesize = getpagesize();
  unsigned char *buf_unaligned =
      (unsigned char *)malloc((2048LL + pagesize) * sizeof(unsigned char));
  unsigned char *buf =
      (buf_unaligned + (pagesize - ((uintptr_t)buf_unaligned % pagesize)));
  char buf2[512];
  char tmpbuf[512];
  int skipfnd, md5fnd, supportedfnd, fragsumfnd, fragcntfnd;
  unsigned int loc;
  long long offset;
  char *p;
  if (lseek64(isofd, (16LL * 2048LL), SEEK_SET) == -1)
    goto fail;
  offset = (16LL * 2048LL);
  for (; 1;) {
    if (read(isofd, buf, 2048) <= 0)
      goto fail;
    if (buf[0] == 1)
      break;
    else if (buf[0] == 255)
      goto fail;
    offset += 2048LL;
  }
  memcpy(buf2, buf + 883, 512);
  buf2[511] = '\0';
  *supported = 0;
  md5fnd = 0;
  skipfnd = 0;
  fragsumfnd = 0;
  fragcntfnd = 0;
  supportedfnd = 0;
  loc = 0;
  while (loc < 512) {
    if (!strncmp(buf2 + loc, "ISO MD5SUM = ", 13)) {
      if ((loc + 32 + 13) > 511)
        goto fail;
      memcpy(mediasum, buf2 + loc + 13, 32);
      mediasum[32] = '\0';
      md5fnd = 1;
      loc += 45;
      for (p = buf2 + loc; loc < 512 && *p != ';'; p++, loc++)
        ;
    } else if (!strncmp(buf2 + loc, "SKIPSECTORS = ", 14)) {
      char *errptr;
      if ((loc + 14) > 511)
        goto fail;
      loc = loc + 14;
      for (p = tmpbuf; loc < 512 && buf2[loc] != ';'; p++, loc++)
        *p = buf2[loc];
      *p = '\0';
      *skipsectors = strtol(tmpbuf, &errptr, 10);
      if (errptr && *errptr) {
        goto fail;
      } else {
        skipfnd = 1;
      }
      for (p = buf2 + loc; loc < 512 && *p != ';'; p++, loc++)
        ;
    } else if (!strncmp(buf2 + loc, "RHLISOSTATUS=1", 14)) {
      *supported = 1;
      supportedfnd = 1;
      for (p = buf2 + loc; loc < 512 && *p != ';'; p++, loc++)
        ;
    } else if (!strncmp(buf2 + loc, "RHLISOSTATUS=0", 14)) {
      *supported = 0;
      supportedfnd = 1;
      for (p = buf2 + loc; loc < 512 && *p != ';'; p++, loc++)
        ;
    } else if (!strncmp(buf2 + loc, "FRAGMENT SUMS = ", 16)) {
      if ((loc + 60) > 511)
        goto fail;
      memcpy(fragmentsums, buf2 + loc + 16, 60);
      fragmentsums[60] = '\0';
      fragsumfnd = 1;
      loc += 60 + 16;
      for (p = buf2 + loc; loc < 512 && *p != ';'; p++, loc++)
        ;
    } else if (!strncmp(buf2 + loc, "FRAGMENT COUNT = ", 17)) {
      char *errptr;
      if ((loc + 17) > 511)
        goto fail;
      loc = loc + 17;
      for (p = tmpbuf; loc < 512 && buf2[loc] != ';'; p++, loc++)
        *p = buf2[loc];
      *p = '\0';
      *fragmentcount = strtol(tmpbuf, &errptr, 10);
      if (errptr && *errptr) {
        goto fail;
      } else {
        fragcntfnd = 1;
      }
      for (p = buf2 + loc; loc < 512 && *p != ';'; p++, loc++)
        ;
    } else {
      loc++;
    }
    if ((skipfnd & md5fnd & fragsumfnd & fragcntfnd) & supportedfnd)
      break;
  }
  if (!(skipfnd & md5fnd))
    goto fail;
  *isosize = (buf[84] * 0x1000000 + buf[84 + 1] * 0x10000 +
              buf[84 + 2] * 0x100 + buf[84 + 3]) *
             2048LL;
  free(buf_unaligned);
  return offset;
fail:
  free(buf_unaligned);
  return -1LL;
}


x86 assembly (clang, -O0):
<parsepvd>:
push   %rbp
mov    %rsp,%rbp
sub    $0x4a0,%rsp
mov    0x10(%rbp),%rax
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    $0x0,%al
call   1090 <getpagesize@plt>
mov    %eax,-0x34(%rbp)
movslq -0x34(%rbp),%rdi
add    $0x800,%rdi
shl    $0x0,%rdi
call   1080 <malloc@plt>
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x490(%rbp)
movslq -0x34(%rbp),%rcx
mov    -0x40(%rbp),%rax
movslq -0x34(%rbp),%rsi
xor    %edx,%edx
div    %rsi
mov    -0x490(%rbp),%rax
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x8(%rbp),%edi
mov    0x2de1(%rip),%rax
mov    (%rax),%edx
mov    $0x8000,%esi
call   10a0 <lseek64@plt>
cmp    $0xffffffff,%eax
jne    1219 <parsepvd+0x99>
jmp    1b14 <parsepvd+0x994>
movq   $0x8000,-0x470(%rbp)
mov    $0x1,%al
test   $0x1,%al
jne    1233 <parsepvd+0xb3>
jmp    129d <parsepvd+0x11d>
mov    -0x8(%rbp),%edi
mov    -0x48(%rbp),%rsi
mov    $0x800,%edx
call   1050 <read@plt>
cmp    $0x0,%rax
jg     1253 <parsepvd+0xd3>
jmp    1b14 <parsepvd+0x994>
mov    -0x48(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x1,%eax
jne    1268 <parsepvd+0xe8>
jmp    129d <parsepvd+0x11d>
mov    -0x48(%rbp),%rax
movzbl (%rax),%eax
cmp    $0xff,%eax
jne    127f <parsepvd+0xff>
jmp    1b14 <parsepvd+0x994>
jmp    1284 <parsepvd+0x104>
mov    -0x470(%rbp),%rax
add    $0x800,%rax
mov    %rax,-0x470(%rbp)
jmp    1224 <parsepvd+0xa4>
lea    -0x250(%rbp),%rdi
mov    -0x48(%rbp),%rsi
add    $0x373,%rsi
xor    %eax,%eax
mov    $0x200,%edx
call   1070 <memcpy@plt>
movb   $0x0,-0x51(%rbp)
mov    -0x28(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x0,-0x458(%rbp)
movl   $0x0,-0x454(%rbp)
movl   $0x0,-0x460(%rbp)
movl   $0x0,-0x464(%rbp)
movl   $0x0,-0x45c(%rbp)
movl   $0x0,-0x468(%rbp)
cmpl   $0x200,-0x468(%rbp)
jae    1aa5 <parsepvd+0x925>
lea    -0x250(%rbp),%rdi
mov    -0x468(%rbp),%eax
add    %rax,%rdi
lea    0xcd4(%rip),%rsi
mov    $0xd,%edx
call   1040 <strncmp@plt>
cmp    $0x0,%eax
jne    1428 <parsepvd+0x2a8>
mov    -0x468(%rbp),%eax
add    $0x20,%eax
add    $0xd,%eax
cmp    $0x1ff,%eax
jbe    135b <parsepvd+0x1db>
jmp    1b14 <parsepvd+0x994>
mov    -0x10(%rbp),%rdi
lea    -0x250(%rbp),%rsi
mov    -0x468(%rbp),%eax
add    %rax,%rsi
add    $0xd,%rsi
xor    %eax,%eax
mov    $0x20,%edx
call   1070 <memcpy@plt>
mov    -0x10(%rbp),%rax
movb   $0x0,0x20(%rax)
movl   $0x1,-0x458(%rbp)
mov    -0x468(%rbp),%eax
add    $0x2d,%eax
mov    %eax,-0x468(%rbp)
lea    -0x250(%rbp),%rax
mov    -0x468(%rbp),%ecx
add    %rcx,%rax
mov    %rax,-0x478(%rbp)
xor    %eax,%eax
cmpl   $0x200,-0x468(%rbp)
mov    %al,-0x491(%rbp)
jae    13e5 <parsepvd+0x265>
mov    -0x478(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3b,%eax
setne  %al
mov    %al,-0x491(%rbp)
mov    -0x491(%rbp),%al
test   $0x1,%al
jne    13f8 <parsepvd+0x278>
jmp    1423 <parsepvd+0x2a3>
jmp    13fd <parsepvd+0x27d>
mov    -0x478(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x478(%rbp)
mov    -0x468(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x468(%rbp)
jmp    13b7 <parsepvd+0x237>
jmp    1a74 <parsepvd+0x8f4>
lea    -0x250(%rbp),%rdi
mov    -0x468(%rbp),%eax
add    %rax,%rdi
lea    0xbcf(%rip),%rsi
mov    $0xe,%edx
call   1040 <strncmp@plt>
cmp    $0x0,%eax
jne    15eb <parsepvd+0x46b>
mov    -0x468(%rbp),%eax
add    $0xe,%eax
cmp    $0x1ff,%eax
jbe    146b <parsepvd+0x2eb>
jmp    1b14 <parsepvd+0x994>
mov    -0x468(%rbp),%eax
add    $0xe,%eax
mov    %eax,-0x468(%rbp)
lea    -0x450(%rbp),%rax
mov    %rax,-0x478(%rbp)
xor    %eax,%eax
cmpl   $0x200,-0x468(%rbp)
mov    %al,-0x492(%rbp)
jae    14ba <parsepvd+0x33a>
mov    -0x468(%rbp),%eax
movsbl -0x250(%rbp,%rax,1),%eax
ff
cmp    $0x3b,%eax
setne  %al
mov    %al,-0x492(%rbp)
mov    -0x492(%rbp),%al
test   $0x1,%al
jne    14cd <parsepvd+0x34d>
jmp    1509 <parsepvd+0x389>
mov    -0x468(%rbp),%eax
mov    -0x250(%rbp,%rax,1),%cl
mov    -0x478(%rbp),%rax
mov    %cl,(%rax)
mov    -0x478(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x478(%rbp)
mov    -0x468(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x468(%rbp)
jmp    1488 <parsepvd+0x308>
mov    -0x478(%rbp),%rax
movb   $0x0,(%rax)
lea    -0x450(%rbp),%rdi
lea    -0x480(%rbp),%rsi
mov    $0xa,%edx
call   1060 <strtol@plt>
mov    %eax,%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
cmpq   $0x0,-0x480(%rbp)
je     1559 <parsepvd+0x3d9>
mov    -0x480(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     1559 <parsepvd+0x3d9>
jmp    1b14 <parsepvd+0x994>
movl   $0x1,-0x454(%rbp)
lea    -0x250(%rbp),%rax
mov    -0x468(%rbp),%ecx
add    %rcx,%rax
mov    %rax,-0x478(%rbp)
xor    %eax,%eax
cmpl   $0x200,-0x468(%rbp)
mov    %al,-0x493(%rbp)
jae    15a8 <parsepvd+0x428>
mov    -0x478(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3b,%eax
setne  %al
mov    %al,-0x493(%rbp)
mov    -0x493(%rbp),%al
test   $0x1,%al
jne    15bb <parsepvd+0x43b>
jmp    15e6 <parsepvd+0x466>
jmp    15c0 <parsepvd+0x440>
mov    -0x478(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x478(%rbp)
mov    -0x468(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x468(%rbp)
jmp    157a <parsepvd+0x3fa>
jmp    1a6f <parsepvd+0x8ef>
lea    -0x250(%rbp),%rdi
mov    -0x468(%rbp),%eax
add    %rax,%rdi
lea    0xa1b(%rip),%rsi
mov    $0xe,%edx
call   1040 <strncmp@plt>
cmp    $0x0,%eax
jne    16b1 <parsepvd+0x531>
mov    -0x28(%rbp),%rax
movl   $0x1,(%rax)
movl   $0x1,-0x45c(%rbp)
lea    -0x250(%rbp),%rax
mov    -0x468(%rbp),%ecx
add    %rcx,%rax
mov    %rax,-0x478(%rbp)
xor    %eax,%eax
cmpl   $0x200,-0x468(%rbp)
mov    %al,-0x494(%rbp)
jae    166e <parsepvd+0x4ee>
mov    -0x478(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3b,%eax
setne  %al
mov    %al,-0x494(%rbp)
mov    -0x494(%rbp),%al
test   $0x1,%al
jne    1681 <parsepvd+0x501>
jmp    16ac <parsepvd+0x52c>
jmp    1686 <parsepvd+0x506>
mov    -0x478(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x478(%rbp)
mov    -0x468(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x468(%rbp)
jmp    1640 <parsepvd+0x4c0>
jmp    1a6a <parsepvd+0x8ea>
lea    -0x250(%rbp),%rdi
mov    -0x468(%rbp),%eax
add    %rax,%rdi
lea    0x964(%rip),%rsi
mov    $0xe,%edx
call   1040 <strncmp@plt>
cmp    $0x0,%eax
jne    1777 <parsepvd+0x5f7>
mov    -0x28(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x1,-0x45c(%rbp)
lea    -0x250(%rbp),%rax
mov    -0x468(%rbp),%ecx
add    %rcx,%rax
mov    %rax,-0x478(%rbp)
xor    %eax,%eax
cmpl   $0x200,-0x468(%rbp)
mov    %al,-0x495(%rbp)
jae    1734 <parsepvd+0x5b4>
mov    -0x478(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3b,%eax
setne  %al
mov    %al,-0x495(%rbp)
mov    -0x495(%rbp),%al
test   $0x1,%al
jne    1747 <parsepvd+0x5c7>
jmp    1772 <parsepvd+0x5f2>
jmp    174c <parsepvd+0x5cc>
mov    -0x478(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x478(%rbp)
mov    -0x468(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x468(%rbp)
jmp    1706 <parsepvd+0x586>
jmp    1a65 <parsepvd+0x8e5>
lea    -0x250(%rbp),%rdi
mov    -0x468(%rbp),%eax
add    %rax,%rdi
lea    0x8ad(%rip),%rsi
mov    $0x10,%edx
call   1040 <strncmp@plt>
cmp    $0x0,%eax
jne    1887 <parsepvd+0x707>
mov    -0x468(%rbp),%eax
add    $0x3c,%eax
cmp    $0x1ff,%eax
jbe    17ba <parsepvd+0x63a>
jmp    1b14 <parsepvd+0x994>
mov    -0x30(%rbp),%rdi
lea    -0x250(%rbp),%rsi
mov    -0x468(%rbp),%eax
add    %rax,%rsi
add    $0x10,%rsi
xor    %eax,%eax
mov    $0x3c,%edx
call   1070 <memcpy@plt>
mov    -0x30(%rbp),%rax
movb   $0x0,0x3c(%rax)
movl   $0x1,-0x460(%rbp)
mov    -0x468(%rbp),%eax
add    $0x4c,%eax
mov    %eax,-0x468(%rbp)
lea    -0x250(%rbp),%rax
mov    -0x468(%rbp),%ecx
add    %rcx,%rax
mov    %rax,-0x478(%rbp)
xor    %eax,%eax
cmpl   $0x200,-0x468(%rbp)
mov    %al,-0x496(%rbp)
jae    1844 <parsepvd+0x6c4>
mov    -0x478(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3b,%eax
setne  %al
mov    %al,-0x496(%rbp)
mov    -0x496(%rbp),%al
test   $0x1,%al
jne    1857 <parsepvd+0x6d7>
jmp    1882 <parsepvd+0x702>
jmp    185c <parsepvd+0x6dc>
mov    -0x478(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x478(%rbp)
mov    -0x468(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x468(%rbp)
jmp    1816 <parsepvd+0x696>
jmp    1a60 <parsepvd+0x8e0>
lea    -0x250(%rbp),%rdi
mov    -0x468(%rbp),%eax
add    %rax,%rdi
lea    0x7ae(%rip),%rsi
mov    $0x11,%edx
call   1040 <strncmp@plt>
cmp    $0x0,%eax
jne    1a4c <parsepvd+0x8cc>
mov    -0x468(%rbp),%eax
add    $0x11,%eax
cmp    $0x1ff,%eax
jbe    18ca <parsepvd+0x74a>
jmp    1b14 <parsepvd+0x994>
mov    -0x468(%rbp),%eax
add    $0x11,%eax
mov    %eax,-0x468(%rbp)
lea    -0x450(%rbp),%rax
mov    %rax,-0x478(%rbp)
xor    %eax,%eax
cmpl   $0x200,-0x468(%rbp)
mov    %al,-0x497(%rbp)
jae    1919 <parsepvd+0x799>
mov    -0x468(%rbp),%eax
movsbl -0x250(%rbp,%rax,1),%eax
ff
cmp    $0x3b,%eax
setne  %al
mov    %al,-0x497(%rbp)
mov    -0x497(%rbp),%al
test   $0x1,%al
jne    192c <parsepvd+0x7ac>
jmp    1968 <parsepvd+0x7e8>
mov    -0x468(%rbp),%eax
mov    -0x250(%rbp,%rax,1),%cl
mov    -0x478(%rbp),%rax
mov    %cl,(%rax)
mov    -0x478(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x478(%rbp)
mov    -0x468(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x468(%rbp)
jmp    18e7 <parsepvd+0x767>
mov    -0x478(%rbp),%rax
movb   $0x0,(%rax)
lea    -0x450(%rbp),%rdi
lea    -0x488(%rbp),%rsi
mov    $0xa,%edx
call   1060 <strtol@plt>
mov    %rax,%rcx
mov    0x10(%rbp),%rax
mov    %rcx,(%rax)
cmpq   $0x0,-0x488(%rbp)
je     19ba <parsepvd+0x83a>
mov    -0x488(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     19ba <parsepvd+0x83a>
jmp    1b14 <parsepvd+0x994>
movl   $0x1,-0x464(%rbp)
lea    -0x250(%rbp),%rax
mov    -0x468(%rbp),%ecx
add    %rcx,%rax
mov    %rax,-0x478(%rbp)
xor    %eax,%eax
cmpl   $0x200,-0x468(%rbp)
mov    %al,-0x498(%rbp)
jae    1a09 <parsepvd+0x889>
mov    -0x478(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3b,%eax
setne  %al
mov    %al,-0x498(%rbp)
mov    -0x498(%rbp),%al
test   $0x1,%al
jne    1a1c <parsepvd+0x89c>
jmp    1a47 <parsepvd+0x8c7>
jmp    1a21 <parsepvd+0x8a1>
mov    -0x478(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x478(%rbp)
mov    -0x468(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x468(%rbp)
jmp    19db <parsepvd+0x85b>
jmp    1a5b <parsepvd+0x8db>
mov    -0x468(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x468(%rbp)
jmp    1a60 <parsepvd+0x8e0>
jmp    1a65 <parsepvd+0x8e5>
jmp    1a6a <parsepvd+0x8ea>
jmp    1a6f <parsepvd+0x8ef>
jmp    1a74 <parsepvd+0x8f4>
mov    -0x454(%rbp),%eax
and    -0x458(%rbp),%eax
and    -0x460(%rbp),%eax
and    -0x464(%rbp),%eax
and    -0x45c(%rbp),%eax
cmp    $0x0,%eax
je     1aa0 <parsepvd+0x920>
jmp    1aa5 <parsepvd+0x925>
jmp    1305 <parsepvd+0x185>
mov    -0x454(%rbp),%eax
and    -0x458(%rbp),%eax
cmp    $0x0,%eax
jne    1abf <parsepvd+0x93f>
jmp    1b14 <parsepvd+0x994>
mov    -0x48(%rbp),%rax
movzbl 0x54(%rax),%eax
shl    $0x18,%eax
mov    -0x48(%rbp),%rcx
movzbl 0x55(%rcx),%ecx
shl    $0x10,%ecx
add    %ecx,%eax
mov    -0x48(%rbp),%rcx
movzbl 0x56(%rcx),%ecx
shl    $0x8,%ecx
add    %ecx,%eax
mov    -0x48(%rbp),%rcx
movzbl 0x57(%rcx),%ecx
add    %ecx,%eax
movslq %eax,%rcx
shl    $0xb,%rcx
mov    -0x20(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x470(%rbp),%rax
mov    %eax,-0x4(%rbp)
jmp    1b24 <parsepvd+0x9a4>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
movl   $0xffffffff,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x4a0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<parsepvd>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x458,%rsp
mov    %r9,0x38(%rsp)
mov    %r8,0x18(%rsp)
mov    %rcx,0x30(%rsp)
mov    %rdx,0x40(%rsp)
mov    %rsi,0x48(%rsp)
mov    %edi,%r13d
xor    %eax,%eax
call   1090 <getpagesize@plt>
mov    %eax,%ebp
movslq %eax,%rbx
lea    0x800(%rbx),%rdi
call   1080 <malloc@plt>
mov    %rax,%rcx
mov    %rax,%r14
or     %rbx,%rcx
shr    $0x20,%rcx
mov    %rax,0x28(%rsp)
je     11e3 <parsepvd+0x63>
xor    %edx,%edx
div    %rbx
mov    %rdx,%rbp
jmp    11e9 <parsepvd+0x69>
xor    %edx,%edx
div    %ebp
mov    %edx,%ebp
mov    0x2df0(%rip),%rax
mov    (%rax),%edx
mov    $0x8000,%esi
mov    %r13d,%edi
call   10a0 <lseek64@plt>
cmp    $0xffffffff,%eax
je     125e <parsepvd+0xde>
sub    %rbp,%rbx
mov    %r14,%rsi
add    %rbx,%rsi
mov    %r13d,%edi
mov    %rsi,0x10(%rsp)
mov    $0x800,%edx
call   1050 <read@plt>
test   %rax,%rax
jle    125e <parsepvd+0xde>
mov    $0x8000,%r15d
nopw   0x0(%rax,%rax,1)
mov    0x10(%rsp),%rax
movzbl (%rax),%eax
cmp    $0xff,%al
je     125e <parsepvd+0xde>
cmp    $0x1,%al
je     1283 <parsepvd+0x103>
mov    %r13d,%edi
mov    0x10(%rsp),%rsi
mov    $0x800,%edx
call   1050 <read@plt>
add    $0x800,%r15d
test   %rax,%rax
jg     1230 <parsepvd+0xb0>
mov    0x28(%rsp),%rdi
call   1030 <free@plt>
mov    $0xffffffff,%r15d
mov    %r15d,%eax
add    $0x458,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x10(%rsp),%rax
lea    0x373(%rax),%rsi
lea    0x50(%rsp),%rdi
mov    $0x200,%edx
xor    %eax,%eax
call   1070 <memcpy@plt>
movb   $0x0,0x24f(%rsp)
mov    0x18(%rsp),%rax
movl   $0x0,(%rax)
lea    0xd46(%rip),%rbx
movl   $0x0,0xc(%rsp)
xor    %r14d,%r14d
movl   $0x0,(%rsp)
movl   $0x0,0x8(%rsp)
movl   $0x0,0x4(%rsp)
xor    %r12d,%r12d
nop
mov    %r12d,%r13d
lea    (%rsp,%r13,1),%rbp
add    $0x50,%rbp
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    $0xd,%edx
call   1040 <strncmp@plt>
test   %eax,%eax
je     13a0 <parsepvd+0x220>
mov    %rbp,%rdi
lea    0xd01(%rip),%rsi
mov    $0xe,%edx
call   1040 <strncmp@plt>
test   %eax,%eax
je     1430 <parsepvd+0x2b0>
mov    %rbp,%rdi
lea    0xcf4(%rip),%rsi
mov    $0xe,%edx
call   1040 <strncmp@plt>
test   %eax,%eax
je     14e8 <parsepvd+0x368>
mov    %rbp,%rdi
lea    0xce7(%rip),%rsi
mov    $0xe,%edx
call   1040 <strncmp@plt>
test   %eax,%eax
je     152a <parsepvd+0x3aa>
mov    %rbp,%rdi
lea    0xcda(%rip),%rsi
mov    $0x10,%edx
call   1040 <strncmp@plt>
test   %eax,%eax
je     1578 <parsepvd+0x3f8>
mov    %rbp,%rdi
lea    0xccf(%rip),%rsi
mov    $0x11,%edx
call   1040 <strncmp@plt>
test   %eax,%eax
je     1623 <parsepvd+0x4a3>
add    $0x1,%r12d
lea    0xc66(%rip),%rbx
jmp    15f7 <parsepvd+0x477>
nop
lea    -0x1d3(%r12),%eax
ff
cmp    $0xfffffe00,%eax
jb     125e <parsepvd+0xde>
add    $0xd,%rbp
mov    0x48(%rsp),%rbx
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    $0x20,%edx
xor    %eax,%eax
call   1070 <memcpy@plt>
movb   $0x0,0x20(%rbx)
add    $0x2d,%r12d
lea    0x50(%rsp),%rax
add    %r13,%rax
add    $0x2d,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    $0x1,%r14d
cmpb   $0x3b,(%rax)
je     15f0 <parsepvd+0x470>
add    $0x1,%rax
add    $0x1,%r12d
cmp    $0x200,%r12d
jne    13f0 <parsepvd+0x270>
mov    $0x200,%r12d
lea    0xbe3(%rip),%rbx
jmp    15f7 <parsepvd+0x477>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0xe,%r12d
cmp    $0x1ff,%r12d
ja     125e <parsepvd+0xde>
mov    %r12d,%r12d
lea    0x250(%rsp),%rax
nopl   0x0(%rax)
movzbl 0x50(%rsp,%r12,1),%ecx
cmp    $0x3b,%cl
je     1474 <parsepvd+0x2f4>
mov    %cl,(%rax)
add    $0x1,%rax
add    $0x1,%r12
cmp    $0x200,%r12
jne    1450 <parsepvd+0x2d0>
mov    $0x200,%r12d
movb   $0x0,(%rax)
lea    0x250(%rsp),%rdi
lea    0x20(%rsp),%rsi
mov    $0xa,%edx
call   1060 <strtol@plt>
mov    0x40(%rsp),%rcx
mov    %eax,(%rcx)
mov    0x20(%rsp),%rax
test   %rax,%rax
je     14a8 <parsepvd+0x328>
cmpb   $0x0,(%rax)
jne    125e <parsepvd+0xde>
cmp    $0x1ff,%r12d
ja     14db <parsepvd+0x35b>
mov    %r12d,%r12d
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmpb   $0x3b,0x50(%rsp,%r12,1)
je     14db <parsepvd+0x35b>
add    $0x1,%r12
cmp    $0x200,%r12d
jne    14c0 <parsepvd+0x340>
mov    $0x200,%r12d
movl   $0x1,0xc(%rsp)
jmp    15f7 <parsepvd+0x477>
mov    0x18(%rsp),%rax
movl   $0x1,(%rax)
movl   $0x1,(%rsp)
cmp    $0x1ff,%r12d
ja     15f7 <parsepvd+0x477>
nopw   0x0(%rax,%rax,1)
cmpb   $0x3b,0x50(%rsp,%r13,1)
je     1570 <parsepvd+0x3f0>
add    $0x1,%r13
cmp    $0x200,%r13d
jne    1510 <parsepvd+0x390>
jmp    15e6 <parsepvd+0x466>
mov    0x18(%rsp),%rax
movl   $0x0,(%rax)
movl   $0x1,(%rsp)
cmp    $0x1ff,%r12d
ja     15f7 <parsepvd+0x477>
nopl   0x0(%rax)
cmpb   $0x3b,0x50(%rsp,%r13,1)
je     1570 <parsepvd+0x3f0>
add    $0x1,%r13
mov    $0x200,%r12d
cmp    $0x200,%r13d
jne    1550 <parsepvd+0x3d0>
jmp    15f7 <parsepvd+0x477>
mov    %r13d,%r12d
jmp    15f7 <parsepvd+0x477>
lea    -0x1c4(%r12),%eax
ff
cmp    $0xfffffe00,%eax
jb     125e <parsepvd+0xde>
add    $0x10,%rbp
mov    0x38(%rsp),%rbx
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    $0x3c,%edx
xor    %eax,%eax
call   1070 <memcpy@plt>
movb   $0x0,0x3c(%rbx)
add    $0x4c,%r12d
movl   $0x1,0x8(%rsp)
cmp    $0x1ff,%r12d
ja     15f0 <parsepvd+0x470>
mov    %r12d,%eax
add    %rsp,%rax
add    $0x50,%rax
lea    0xa30(%rip),%rbx
cmpb   $0x3b,(%rax)
je     15f7 <parsepvd+0x477>
add    $0x1,%rax
add    $0x1,%r12d
cmp    $0x200,%r12d
jne    15d0 <parsepvd+0x450>
mov    $0x200,%r12d
jmp    15f7 <parsepvd+0x477>
xchg   %ax,%ax
lea    0xa09(%rip),%rbx
mov    %r14d,%eax
and    0xc(%rsp),%eax
mov    (%rsp),%ecx
and    0x8(%rsp),%ecx
and    %eax,%ecx
test   %ecx,0x4(%rsp)
jne    16e1 <parsepvd+0x561>
cmp    $0x200,%r12d
jb     12e0 <parsepvd+0x160>
jmp    16e1 <parsepvd+0x561>
add    $0x11,%r12d
cmp    $0x1ff,%r12d
ja     125e <parsepvd+0xde>
mov    %r12d,%r12d
lea    0x250(%rsp),%rax
nop
movzbl 0x50(%rsp,%r12,1),%ecx
cmp    $0x3b,%cl
je     1664 <parsepvd+0x4e4>
mov    %cl,(%rax)
add    $0x1,%rax
add    $0x1,%r12
cmp    $0x200,%r12
jne    1640 <parsepvd+0x4c0>
mov    $0x200,%r12d
movb   $0x0,(%rax)
lea    0x250(%rsp),%rdi
lea    0x20(%rsp),%rsi
mov    $0xa,%edx
call   1060 <strtol@plt>
mov    0x490(%rsp),%rcx
mov    %rax,(%rcx)
mov    0x20(%rsp),%rax
test   %rax,%rax
je     169c <parsepvd+0x51c>
cmpb   $0x0,(%rax)
jne    125e <parsepvd+0xde>
cmp    $0x1ff,%r12d
ja     16cd <parsepvd+0x54d>
mov    %r12d,%r12d
lea    0x951(%rip),%rbx
nop
cmpb   $0x3b,0x50(%rsp,%r12,1)
je     16d4 <parsepvd+0x554>
add    $0x1,%r12
cmp    $0x200,%r12d
jne    16b0 <parsepvd+0x530>
mov    $0x200,%r12d
jmp    16d4 <parsepvd+0x554>
lea    0x92c(%rip),%rbx
movl   $0x1,0x4(%rsp)
jmp    15f7 <parsepvd+0x477>
test   %eax,%eax
je     125e <parsepvd+0xde>
mov    0x10(%rsp),%rax
mov    0x54(%rax),%eax
shl    $0x20,%rax
bswap  %rax
shl    $0xb,%rax
mov    0x30(%rsp),%rcx
mov    %rax,(%rcx)
mov    0x28(%rsp),%rdi
call   1030 <free@plt>
jmp    126e <parsepvd+0xee>

LLVM IR (-O0):
@SEEK_SET = global i32 0
@.str = [14 x i8] c"ISO MD5SUM = \00"
@.str.1 = [15 x i8] c"SKIPSECTORS = \00"
@.str.2 = [15 x i8] c"RHLISOSTATUS=1\00"
@.str.3 = [15 x i8] c"RHLISOSTATUS=0\00"
@.str.4 = [17 x i8] c"FRAGMENT SUMS = \00"
@.str.5 = [18 x i8] c"FRAGMENT COUNT = \00"
define i32 @parsepvd(i32 %0, i8* %1, i32* %2, i64* %3, i32* %4, i8* %5, i64* %6) {
%8 = alloca i32
%9 = alloca i32
%10 = alloca i8*
%11 = alloca i32*
%12 = alloca i64*
%13 = alloca i32*
%14 = alloca i8*
%15 = alloca i64*
%16 = alloca i32
%17 = alloca i8*
%18 = alloca i8*
%19 = alloca [512 x i8]
%20 = alloca [512 x i8]
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
%27 = alloca i64
%28 = alloca i8*
%29 = alloca i8*
%30 = alloca i8*
store i32 %0, i32* %9
store i8* %1, i8** %10
store i32* %2, i32** %11
store i64* %3, i64** %12
store i32* %4, i32** %13
store i8* %5, i8** %14
store i64* %6, i64** %15
%31 = call i32 (...) @getpagesize()
store i32 %31, i32* %16
%32 = load i32, i32* %16
%33 = sext i32 %32 to i64
%34 = add nsw i64 2048, %33
%35 = mul i64 %34, 1
%36 = call i64 @malloc(i64 %35)
%37 = inttoptr i64 %36 to i8*
store i8* %37, i8** %17
%38 = load i8*, i8** %17
%39 = load i32, i32* %16
%40 = sext i32 %39 to i64
%41 = load i8*, i8** %17
%42 = ptrtoint i8* %41 to i64
%43 = load i32, i32* %16
%44 = sext i32 %43 to i64
%45 = urem i64 %42, %44
%46 = sub i64 %40, %45
%47 = getelementptr inbounds i8, i8* %38, i64 %46
store i8* %47, i8** %18
%48 = load i32, i32* %9
%49 = load i32, i32* @SEEK_SET
%50 = call i32 @lseek64(i32 %48, i64 32768, i32 %49)
%51 = icmp eq i32 %50, -1
br i1 %51, label %52, label %53
52: ; preds = %7
br label %449
53: ; preds = %7
store i64 32768, i64* %27
br label %54
54: ; preds = %76, %53
br i1 true, label %55, label %79
55: ; preds = %54
%56 = load i32, i32* %9
%57 = load i8*, i8** %18
%58 = call i64 @read(i32 %56, i8* %57, i32 2048)
%59 = icmp sle i64 %58, 0
br i1 %59, label %60, label %61
60: ; preds = %55
br label %449
61: ; preds = %55
%62 = load i8*, i8** %18
%63 = getelementptr inbounds i8, i8* %62, i64 0
%64 = load i8, i8* %63
%65 = zext i8 %64 to i32
%66 = icmp eq i32 %65, 1
br i1 %66, label %67, label %68
67: ; preds = %61
br label %79
68: ; preds = %61
%69 = load i8*, i8** %18
%70 = getelementptr inbounds i8, i8* %69, i64 0
%71 = load i8, i8* %70
%72 = zext i8 %71 to i32
%73 = icmp eq i32 %72, 255
br i1 %73, label %74, label %75
74: ; preds = %68
br label %449
75: ; preds = %68
br label %76
76: ; preds = %75
%77 = load i64, i64* %27
%78 = add nsw i64 %77, 2048
store i64 %78, i64* %27
br label %54
79: ; preds = %67, %54
%80 = getelementptr inbounds [512 x i8], [512 x i8]* %19, i64 0, i64 0
%81 = load i8*, i8** %18
%82 = getelementptr inbounds i8, i8* %81, i64 883
%83 = call i32 (i8*, ...) @memcpy(i8* %80, i8* %82, i32 512)
%84 = getelementptr inbounds [512 x i8], [512 x i8]* %19, i64 0, i64 511
store i8 0, i8* %84
%85 = load i32*, i32** %13
store i32 0, i32* %85
store i32 0, i32* %22
store i32 0, i32* %21
store i32 0, i32* %24
store i32 0, i32* %25
store i32 0, i32* %23
store i32 0, i32* %26
br label %86
86: ; preds = %412, %79
%87 = load i32, i32* %26
%88 = icmp ult i32 %87, 512
br i1 %88, label %89, label %413
89: ; preds = %86
%90 = getelementptr inbounds [512 x i8], [512 x i8]* %19, i64 0, i64 0
%91 = load i32, i32* %26
%92 = zext i32 %91 to i64
%93 = getelementptr inbounds i8, i8* %90, i64 %92
%94 = call i32 @strncmp(i8* %93, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str, i64 0, i64 0), i32 13)
%95 = icmp ne i32 %94, 0
br i1 %95, label %135, label %96
96: ; preds = %89
%97 = load i32, i32* %26
%98 = add i32 %97, 32
%99 = add i32 %98, 13
%100 = icmp ugt i32 %99, 511
br i1 %100, label %101, label %102
101: ; preds = %96
br label %449
102: ; preds = %96
%103 = load i8*, i8** %10
%104 = getelementptr inbounds [512 x i8], [512 x i8]* %19, i64 0, i64 0
%105 = load i32, i32* %26
%106 = zext i32 %105 to i64
%107 = getelementptr inbounds i8, i8* %104, i64 %106
%108 = getelementptr inbounds i8, i8* %107, i64 13
%109 = call i32 (i8*, ...) @memcpy(i8* %103, i8* %108, i32 32)
%110 = load i8*, i8** %10
%111 = getelementptr inbounds i8, i8* %110, i64 32
store i8 0, i8* %111
store i32 1, i32* %22
%112 = load i32, i32* %26
%113 = add i32 %112, 45
store i32 %113, i32* %26
%114 = getelementptr inbounds [512 x i8], [512 x i8]* %19, i64 0, i64 0
%115 = load i32, i32* %26
%116 = zext i32 %115 to i64
%117 = getelementptr inbounds i8, i8* %114, i64 %116
store i8* %117, i8** %28
br label %118
118: ; preds = %129, %102
%119 = load i32, i32* %26
%120 = icmp ult i32 %119, 512
br i1 %120, label %121, label %126
121: ; preds = %118
%122 = load i8*, i8** %28
%123 = load i8, i8* %122
%124 = sext i8 %123 to i32
%125 = icmp ne i32 %124, 59
br label %126
126: ; preds = %121, %118
%127 = phi i1 [ false, %118 ], [ %125, %121 ]
br i1 %127, label %128, label %134
128: ; preds = %126
br label %129
129: ; preds = %128
%130 = load i8*, i8** %28
%131 = getelementptr inbounds i8, i8* %130, i32 1
store i8* %131, i8** %28
%132 = load i32, i32* %26
%133 = add i32 %132, 1
store i32 %133, i32* %26
br label %118
134: ; preds = %126
br label %400
135: ; preds = %89
%136 = getelementptr inbounds [512 x i8], [512 x i8]* %19, i64 0, i64 0
%137 = load i32, i32* %26
%138 = zext i32 %137 to i64
%139 = getelementptr inbounds i8, i8* %136, i64 %138
%140 = call i32 @strncmp(i8* %139, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.1, i64 0, i64 0), i32 14)
%141 = icmp ne i32 %140, 0
br i1 %141, label %211, label %142
142: ; preds = %135
%143 = load i32, i32* %26
%144 = add i32 %143, 14
%145 = icmp ugt i32 %144, 511
br i1 %145, label %146, label %147
146: ; preds = %142
br label %449
147: ; preds = %142
%148 = load i32, i32* %26
%149 = add i32 %148, 14
store i32 %149, i32* %26
%150 = getelementptr inbounds [512 x i8], [512 x i8]* %20, i64 0, i64 0
store i8* %150, i8** %28
br label %151
151: ; preds = %169, %147
%152 = load i32, i32* %26
%153 = icmp ult i32 %152, 512
br i1 %153, label %154, label %161
154: ; preds = %151
%155 = load i32, i32* %26
%156 = zext i32 %155 to i64
%157 = getelementptr inbounds [512 x i8], [512 x i8]* %19, i64 0, i64 %156
%158 = load i8, i8* %157
%159 = sext i8 %158 to i32
%160 = icmp ne i32 %159, 59
br label %161
161: ; preds = %154, %151
%162 = phi i1 [ false, %151 ], [ %160, %154 ]
br i1 %162, label %163, label %174
163: ; preds = %161
%164 = load i32, i32* %26
%165 = zext i32 %164 to i64
%166 = getelementptr inbounds [512 x i8], [512 x i8]* %19, i64 0, i64 %165
%167 = load i8, i8* %166
%168 = load i8*, i8** %28
store i8 %167, i8* %168
br label %169
169: ; preds = %163
%170 = load i8*, i8** %28
%171 = getelementptr inbounds i8, i8* %170, i32 1
store i8* %171, i8** %28
%172 = load i32, i32* %26
%173 = add i32 %172, 1
store i32 %173, i32* %26
br label %151
174: ; preds = %161
%175 = load i8*, i8** %28
store i8 0, i8* %175
%176 = getelementptr inbounds [512 x i8], [512 x i8]* %20, i64 0, i64 0
%177 = call i8* @strtol(i8* %176, i8** %29, i32 10)
%178 = ptrtoint i8* %177 to i32
%179 = load i32*, i32** %11
store i32 %178, i32* %179
%180 = load i8*, i8** %29
%181 = icmp ne i8* %180, null
br i1 %181, label %182, label %188
182: ; preds = %174
%183 = load i8*, i8** %29
%184 = load i8, i8* %183
%185 = sext i8 %184 to i32
%186 = icmp ne i32 %185, 0
br i1 %186, label %187, label %188
187: ; preds = %182
br label %449
188: ; preds = %182, %174
store i32 1, i32* %21
br label %189
189: ; preds = %188
%190 = getelementptr inbounds [512 x i8], [512 x i8]* %19, i64 0, i64 0
%191 = load i32, i32* %26
%192 = zext i32 %191 to i64
%193 = getelementptr inbounds i8, i8* %190, i64 %192
store i8* %193, i8** %28
br label %194
194: ; preds = %205, %189
%195 = load i32, i32* %26
%196 = icmp ult i32 %195, 512
br i1 %196, label %197, label %202
197: ; preds = %194
%198 = load i8*, i8** %28
%199 = load i8, i8* %198
%200 = sext i8 %199 to i32
%201 = icmp ne i32 %200, 59
br label %202
202: ; preds = %197, %194
%203 = phi i1 [ false, %194 ], [ %201, %197 ]
br i1 %203, label %204, label %210
204: ; preds = %202
br label %205
205: ; preds = %204
%206 = load i8*, i8** %28
%207 = getelementptr inbounds i8, i8* %206, i32 1
store i8* %207, i8** %28
%208 = load i32, i32* %26
%209 = add i32 %208, 1
store i32 %209, i32* %26
br label %194
210: ; preds = %202
br label %399
211: ; preds = %135
%212 = getelementptr inbounds [512 x i8], [512 x i8]* %19, i64 0, i64 0
%213 = load i32, i32* %26
%214 = zext i32 %213 to i64
%215 = getelementptr inbounds i8, i8* %212, i64 %214
%216 = call i32 @strncmp(i8* %215, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.2, i64 0, i64 0), i32 14)
%217 = icmp ne i32 %216, 0
br i1 %217, label %241, label %218
218: ; preds = %211
%219 = load i32*, i32** %13
store i32 1, i32* %219
store i32 1, i32* %23
%220 = getelementptr inbounds [512 x i8], [512 x i8]* %19, i64 0, i64 0
%221 = load i32, i32* %26
%222 = zext i32 %221 to i64
%223 = getelementptr inbounds i8, i8* %220, i64 %222
store i8* %223, i8** %28
br label %224
224: ; preds = %235, %218
%225 = load i32, i32* %26
%226 = icmp ult i32 %225, 512
br i1 %226, label %227, label %232
227: ; preds = %224
%228 = load i8*, i8** %28
%229 = load i8, i8* %228
%230 = sext i8 %229 to i32
%231 = icmp ne i32 %230, 59
br label %232
232: ; preds = %227, %224
%233 = phi i1 [ false, %224 ], [ %231, %227 ]
br i1 %233, label %234, label %240
234: ; preds = %232
br label %235
235: ; preds = %234
%236 = load i8*, i8** %28
%237 = getelementptr inbounds i8, i8* %236, i32 1
store i8* %237, i8** %28
%238 = load i32, i32* %26
%239 = add i32 %238, 1
store i32 %239, i32* %26
br label %224
240: ; preds = %232
br label %398
241: ; preds = %211
%242 = getelementptr inbounds [512 x i8], [512 x i8]* %19, i64 0, i64 0
%243 = load i32, i32* %26
%244 = zext i32 %243 to i64
%245 = getelementptr inbounds i8, i8* %242, i64 %244
%246 = call i32 @strncmp(i8* %245, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.3, i64 0, i64 0), i32 14)
%247 = icmp ne i32 %246, 0
br i1 %247, label %271, label %248
248: ; preds = %241
%249 = load i32*, i32** %13
store i32 0, i32* %249
store i32 1, i32* %23
%250 = getelementptr inbounds [512 x i8], [512 x i8]* %19, i64 0, i64 0
%251 = load i32, i32* %26
%252 = zext i32 %251 to i64
%253 = getelementptr inbounds i8, i8* %250, i64 %252
store i8* %253, i8** %28
br label %254
254: ; preds = %265, %248
%255 = load i32, i32* %26
%256 = icmp ult i32 %255, 512
br i1 %256, label %257, label %262
257: ; preds = %254
%258 = load i8*, i8** %28
%259 = load i8, i8* %258
%260 = sext i8 %259 to i32
%261 = icmp ne i32 %260, 59
br label %262
262: ; preds = %257, %254
%263 = phi i1 [ false, %254 ], [ %261, %257 ]
br i1 %263, label %264, label %270
264: ; preds = %262
br label %265
265: ; preds = %264
%266 = load i8*, i8** %28
%267 = getelementptr inbounds i8, i8* %266, i32 1
store i8* %267, i8** %28
%268 = load i32, i32* %26
%269 = add i32 %268, 1
store i32 %269, i32* %26
br label %254
270: ; preds = %262
br label %397
271: ; preds = %241
%272 = getelementptr inbounds [512 x i8], [512 x i8]* %19, i64 0, i64 0
%273 = load i32, i32* %26
%274 = zext i32 %273 to i64
%275 = getelementptr inbounds i8, i8* %272, i64 %274
%276 = call i32 @strncmp(i8* %275, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.4, i64 0, i64 0), i32 16)
%277 = icmp ne i32 %276, 0
br i1 %277, label %316, label %278
278: ; preds = %271
%279 = load i32, i32* %26
%280 = add i32 %279, 60
%281 = icmp ugt i32 %280, 511
br i1 %281, label %282, label %283
282: ; preds = %278
br label %449
283: ; preds = %278
%284 = load i8*, i8** %14
%285 = getelementptr inbounds [512 x i8], [512 x i8]* %19, i64 0, i64 0
%286 = load i32, i32* %26
%287 = zext i32 %286 to i64
%288 = getelementptr inbounds i8, i8* %285, i64 %287
%289 = getelementptr inbounds i8, i8* %288, i64 16
%290 = call i32 (i8*, ...) @memcpy(i8* %284, i8* %289, i32 60)
%291 = load i8*, i8** %14
%292 = getelementptr inbounds i8, i8* %291, i64 60
store i8 0, i8* %292
store i32 1, i32* %24
%293 = load i32, i32* %26
%294 = add i32 %293, 76
store i32 %294, i32* %26
%295 = getelementptr inbounds [512 x i8], [512 x i8]* %19, i64 0, i64 0
%296 = load i32, i32* %26
%297 = zext i32 %296 to i64
%298 = getelementptr inbounds i8, i8* %295, i64 %297
store i8* %298, i8** %28
br label %299
299: ; preds = %310, %283
%300 = load i32, i32* %26
%301 = icmp ult i32 %300, 512
br i1 %301, label %302, label %307
302: ; preds = %299
%303 = load i8*, i8** %28
%304 = load i8, i8* %303
%305 = sext i8 %304 to i32
%306 = icmp ne i32 %305, 59
br label %307
307: ; preds = %302, %299
%308 = phi i1 [ false, %299 ], [ %306, %302 ]
br i1 %308, label %309, label %315
309: ; preds = %307
br label %310
310: ; preds = %309
%311 = load i8*, i8** %28
%312 = getelementptr inbounds i8, i8* %311, i32 1
store i8* %312, i8** %28
%313 = load i32, i32* %26
%314 = add i32 %313, 1
store i32 %314, i32* %26
br label %299
315: ; preds = %307
br label %396
316: ; preds = %271
%317 = getelementptr inbounds [512 x i8], [512 x i8]* %19, i64 0, i64 0
%318 = load i32, i32* %26
%319 = zext i32 %318 to i64
%320 = getelementptr inbounds i8, i8* %317, i64 %319
%321 = call i32 @strncmp(i8* %320, i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.5, i64 0, i64 0), i32 17)
%322 = icmp ne i32 %321, 0
br i1 %322, label %392, label %323
323: ; preds = %316
%324 = load i32, i32* %26
%325 = add i32 %324, 17
%326 = icmp ugt i32 %325, 511
br i1 %326, label %327, label %328
327: ; preds = %323
br label %449
328: ; preds = %323
%329 = load i32, i32* %26
%330 = add i32 %329, 17
store i32 %330, i32* %26
%331 = getelementptr inbounds [512 x i8], [512 x i8]* %20, i64 0, i64 0
store i8* %331, i8** %28
br label %332
332: ; preds = %350, %328
%333 = load i32, i32* %26
%334 = icmp ult i32 %333, 512
br i1 %334, label %335, label %342
335: ; preds = %332
%336 = load i32, i32* %26
%337 = zext i32 %336 to i64
%338 = getelementptr inbounds [512 x i8], [512 x i8]* %19, i64 0, i64 %337
%339 = load i8, i8* %338
%340 = sext i8 %339 to i32
%341 = icmp ne i32 %340, 59
br label %342
342: ; preds = %335, %332
%343 = phi i1 [ false, %332 ], [ %341, %335 ]
br i1 %343, label %344, label %355
344: ; preds = %342
%345 = load i32, i32* %26
%346 = zext i32 %345 to i64
%347 = getelementptr inbounds [512 x i8], [512 x i8]* %19, i64 0, i64 %346
%348 = load i8, i8* %347
%349 = load i8*, i8** %28
store i8 %348, i8* %349
br label %350
350: ; preds = %344
%351 = load i8*, i8** %28
%352 = getelementptr inbounds i8, i8* %351, i32 1
store i8* %352, i8** %28
%353 = load i32, i32* %26
%354 = add i32 %353, 1
store i32 %354, i32* %26
br label %332
355: ; preds = %342
%356 = load i8*, i8** %28
store i8 0, i8* %356
%357 = getelementptr inbounds [512 x i8], [512 x i8]* %20, i64 0, i64 0
%358 = call i8* @strtol(i8* %357, i8** %30, i32 10)
%359 = ptrtoint i8* %358 to i64
%360 = load i64*, i64** %15
store i64 %359, i64* %360
%361 = load i8*, i8** %30
%362 = icmp ne i8* %361, null
br i1 %362, label %363, label %369
363: ; preds = %355
%364 = load i8*, i8** %30
%365 = load i8, i8* %364
%366 = sext i8 %365 to i32
%367 = icmp ne i32 %366, 0
br i1 %367, label %368, label %369
368: ; preds = %363
br label %449
369: ; preds = %363, %355
store i32 1, i32* %25
br label %370
370: ; preds = %369
%371 = getelementptr inbounds [512 x i8], [512 x i8]* %19, i64 0, i64 0
%372 = load i32, i32* %26
%373 = zext i32 %372 to i64
%374 = getelementptr inbounds i8, i8* %371, i64 %373
store i8* %374, i8** %28
br label %375
375: ; preds = %386, %370
%376 = load i32, i32* %26
%377 = icmp ult i32 %376, 512
br i1 %377, label %378, label %383
378: ; preds = %375
%379 = load i8*, i8** %28
%380 = load i8, i8* %379
%381 = sext i8 %380 to i32
%382 = icmp ne i32 %381, 59
br label %383
383: ; preds = %378, %375
%384 = phi i1 [ false, %375 ], [ %382, %378 ]
br i1 %384, label %385, label %391
385: ; preds = %383
br label %386
386: ; preds = %385
%387 = load i8*, i8** %28
%388 = getelementptr inbounds i8, i8* %387, i32 1
store i8* %388, i8** %28
%389 = load i32, i32* %26
%390 = add i32 %389, 1
store i32 %390, i32* %26
br label %375
391: ; preds = %383
br label %395
392: ; preds = %316
%393 = load i32, i32* %26
%394 = add i32 %393, 1
store i32 %394, i32* %26
br label %395
395: ; preds = %392, %391
br label %396
396: ; preds = %395, %315
br label %397
397: ; preds = %396, %270
br label %398
398: ; preds = %397, %240
br label %399
399: ; preds = %398, %210
br label %400
400: ; preds = %399, %134
%401 = load i32, i32* %21
%402 = load i32, i32* %22
%403 = and i32 %401, %402
%404 = load i32, i32* %24
%405 = and i32 %403, %404
%406 = load i32, i32* %25
%407 = and i32 %405, %406
%408 = load i32, i32* %23
%409 = and i32 %407, %408
%410 = icmp ne i32 %409, 0
br i1 %410, label %411, label %412
411: ; preds = %400
br label %413
412: ; preds = %400
br label %86
413: ; preds = %411, %86
%414 = load i32, i32* %21
%415 = load i32, i32* %22
%416 = and i32 %414, %415
%417 = icmp ne i32 %416, 0
br i1 %417, label %419, label %418
418: ; preds = %413
br label %449
419: ; preds = %413
%420 = load i8*, i8** %18
%421 = getelementptr inbounds i8, i8* %420, i64 84
%422 = load i8, i8* %421
%423 = zext i8 %422 to i32
%424 = mul nsw i32 %423, 16777216
%425 = load i8*, i8** %18
%426 = getelementptr inbounds i8, i8* %425, i64 85
%427 = load i8, i8* %426
%428 = zext i8 %427 to i32
%429 = mul nsw i32 %428, 65536
%430 = add nsw i32 %424, %429
%431 = load i8*, i8** %18
%432 = getelementptr inbounds i8, i8* %431, i64 86
%433 = load i8, i8* %432
%434 = zext i8 %433 to i32
%435 = mul nsw i32 %434, 256
%436 = add nsw i32 %430, %435
%437 = load i8*, i8** %18
%438 = getelementptr inbounds i8, i8* %437, i64 87
%439 = load i8, i8* %438
%440 = zext i8 %439 to i32
%441 = add nsw i32 %436, %440
%442 = sext i32 %441 to i64
%443 = mul nsw i64 %442, 2048
%444 = load i64*, i64** %12
store i64 %443, i64* %444
%445 = load i8*, i8** %17
%446 = call i32 @free(i8* %445)
%447 = load i64, i64* %27
%448 = trunc i64 %447 to i32
store i32 %448, i32* %8
br label %452
449: ; preds = %418, %368, %327, %282, %187, %146, %101, %74, %60, %52
%450 = load i8*, i8** %17
%451 = call i32 @free(i8* %450)
store i32 -1, i32* %8
br label %452
452: ; preds = %449, %419
%453 = load i32, i32* %8
ret i32 %453
}

LLVM IR (-O2):
@SEEK_SET = global i32 0
@.str = [14 x i8] c"ISO MD5SUM = \00"
@.str.1 = [15 x i8] c"SKIPSECTORS = \00"
@.str.2 = [15 x i8] c"RHLISOSTATUS=1\00"
@.str.3 = [15 x i8] c"RHLISOSTATUS=0\00"
@.str.4 = [17 x i8] c"FRAGMENT SUMS = \00"
@.str.5 = [18 x i8] c"FRAGMENT COUNT = \00"
define i32 @parsepvd(i32 %0, i8* %1, i32* nocapture writeonly %2, i64* nocapture writeonly %3, i32* nocapture writeonly %4, i8* %5, i64* nocapture writeonly %6) {
%8 = alloca [512 x i8]
%9 = alloca [512 x i8]
%10 = alloca i8*
%11 = alloca i8*
%12 = tail call i32 (...) @getpagesize()
%13 = sext i32 %12 to i64
%14 = add nsw i64 %13, 2048
%15 = tail call i64 @malloc(i64 %14)
%16 = inttoptr i64 %15 to i8*
%17 = urem i64 %15, %13
%18 = sub i64 %13, %17
%19 = getelementptr inbounds i8, i8* %16, i64 %18
%20 = getelementptr inbounds [512 x i8], [512 x i8]* %8, i64 0, i64 0
%21 = getelementptr inbounds [512 x i8], [512 x i8]* %9, i64 0, i64 0
%22 = load i32, i32* @SEEK_SET
%23 = tail call i32 @lseek64(i32 %0, i64 32768, i32 %22)
%24 = icmp eq i32 %23, -1
br i1 %24, label %258, label %25
25: ; preds = %7
%26 = tail call i64 @read(i32 %0, i8* %19, i32 2048)
%27 = icmp slt i64 %26, 1
br i1 %27, label %258, label %28
28: ; preds = %25, %31
%29 = phi i64 [ %32, %31 ], [ 32768, %25 ]
%30 = load i8, i8* %19
switch i8 %30, label %31 [
i8 1, label %35
i8 -1, label %258
]
31: ; preds = %28
%32 = add nuw nsw i64 %29, 2048
%33 = tail call i64 @read(i32 %0, i8* %19, i32 2048)
%34 = icmp slt i64 %33, 1
br i1 %34, label %258, label %28
35: ; preds = %28
%36 = getelementptr inbounds i8, i8* %19, i64 883
%37 = call i32 (i8*, ...) @memcpy(i8* %20, i8* %36, i32 512)
%38 = getelementptr inbounds [512 x i8], [512 x i8]* %8, i64 0, i64 511
store i8 0, i8* %38
store i32 0, i32* %4
%39 = bitcast i8** %11 to i8*
%40 = getelementptr inbounds i8, i8* %5, i64 60
%41 = bitcast i8** %10 to i8*
%42 = getelementptr inbounds i8, i8* %1, i64 32
br label %43
43: ; preds = %35, %220
%44 = phi i32 [ 0, %35 ], [ %221, %220 ]
%45 = phi i32 [ 0, %35 ], [ %222, %220 ]
%46 = phi i32 [ 0, %35 ], [ %223, %220 ]
%47 = phi i32 [ 0, %35 ], [ %224, %220 ]
%48 = phi i32 [ 0, %35 ], [ %225, %220 ]
%49 = phi i32 [ 0, %35 ], [ %226, %220 ]
%50 = zext i32 %49 to i64
%51 = getelementptr inbounds [512 x i8], [512 x i8]* %8, i64 0, i64 %50
%52 = call i32 @strncmp(i8* %51, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str, i64 0, i64 0), i32 13)
%53 = icmp eq i32 %52, 0
br i1 %53, label %54, label %72
54: ; preds = %43
%55 = add nsw i32 %49, -467
%56 = icmp ult i32 %55, -512
br i1 %56, label %258, label %57
57: ; preds = %54
%58 = getelementptr inbounds i8, i8* %51, i64 13
%59 = call i32 (i8*, ...) @memcpy(i8* %1, i8* %58, i32 32)
store i8 0, i8* %42
%60 = add nuw nsw i32 %49, 45
%61 = zext i32 %60 to i64
%62 = getelementptr inbounds [512 x i8], [512 x i8]* %8, i64 0, i64 %61
br label %63
63: ; preds = %57, %68
%64 = phi i8* [ %69, %68 ], [ %62, %57 ]
%65 = phi i32 [ %70, %68 ], [ %60, %57 ]
%66 = load i8, i8* %64
%67 = icmp eq i8 %66, 59
br i1 %67, label %220, label %68
68: ; preds = %63
%69 = getelementptr inbounds i8, i8* %64, i64 1
%70 = add i32 %65, 1
%71 = icmp eq i32 %70, 512
br i1 %71, label %220, label %63
72: ; preds = %43
%73 = call i32 @strncmp(i8* %51, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.1, i64 0, i64 0), i32 14)
%74 = icmp eq i32 %73, 0
br i1 %74, label %75, label %120
75: ; preds = %72
%76 = add i32 %49, 14
%77 = icmp ugt i32 %76, 511
br i1 %77, label %119, label %78
78: ; preds = %75
%79 = zext i32 %76 to i64
br label %80
80: ; preds = %78, %86
%81 = phi i64 [ %79, %78 ], [ %88, %86 ]
%82 = phi i8* [ %21, %78 ], [ %87, %86 ]
%83 = getelementptr inbounds [512 x i8], [512 x i8]* %8, i64 0, i64 %81
%84 = load i8, i8* %83
%85 = icmp eq i8 %84, 59
br i1 %85, label %90, label %86
86: ; preds = %80
store i8 %84, i8* %82
%87 = getelementptr inbounds i8, i8* %82, i64 1
%88 = add nuw nsw i64 %81, 1
%89 = icmp eq i64 %88, 512
br i1 %89, label %92, label %80
90: ; preds = %80
%91 = trunc i64 %81 to i32
br label %92
92: ; preds = %86, %90
%93 = phi i32 [ %91, %90 ], [ 512, %86 ]
%94 = phi i8* [ %82, %90 ], [ %87, %86 ]
store i8 0, i8* %94
%95 = call i8* @strtol(i8* %21, i8** %10, i32 10)
%96 = ptrtoint i8* %95 to i64
%97 = trunc i64 %96 to i32
store i32 %97, i32* %2
%98 = load i8*, i8** %10
%99 = icmp eq i8* %98, null
br i1 %99, label %103, label %100
100: ; preds = %92
%101 = load i8, i8* %98
%102 = icmp eq i8 %101, 0
br i1 %102, label %103, label %119
103: ; preds = %100, %92
%104 = icmp ult i32 %93, 512
br i1 %104, label %105, label %117
105: ; preds = %103
%106 = zext i32 %93 to i64
%107 = getelementptr inbounds [512 x i8], [512 x i8]* %8, i64 0, i64 %106
br label %108
108: ; preds = %105, %113
%109 = phi i8* [ %114, %113 ], [ %107, %105 ]
%110 = phi i32 [ %115, %113 ], [ %93, %105 ]
%111 = load i8, i8* %109
%112 = icmp eq i8 %111, 59
br i1 %112, label %117, label %113
113: ; preds = %108
%114 = getelementptr inbounds i8, i8* %109, i64 1
%115 = add i32 %110, 1
%116 = icmp eq i32 %115, 512
br i1 %116, label %117, label %108
117: ; preds = %108, %113, %103
%118 = phi i32 [ %93, %103 ], [ 512, %113 ], [ %110, %108 ]
br label %220
119: ; preds = %100, %75
br label %258
120: ; preds = %72
%121 = call i32 @strncmp(i8* %51, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.2, i64 0, i64 0), i32 14)
%122 = icmp eq i32 %121, 0
br i1 %122, label %123, label %134
123: ; preds = %120
store i32 1, i32* %4
%124 = icmp ult i32 %49, 512
br i1 %124, label %125, label %220
125: ; preds = %123, %130
%126 = phi i8* [ %131, %130 ], [ %51, %123 ]
%127 = phi i32 [ %132, %130 ], [ %49, %123 ]
%128 = load i8, i8* %126
%129 = icmp eq i8 %128, 59
br i1 %129, label %220, label %130
130: ; preds = %125
%131 = getelementptr inbounds i8, i8* %126, i64 1
%132 = add i32 %127, 1
%133 = icmp eq i32 %132, 512
br i1 %133, label %220, label %125
134: ; preds = %120
%135 = call i32 @strncmp(i8* %51, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.3, i64 0, i64 0), i32 14)
%136 = icmp eq i32 %135, 0
br i1 %136, label %137, label %148
137: ; preds = %134
store i32 0, i32* %4
%138 = icmp ult i32 %49, 512
br i1 %138, label %139, label %220
139: ; preds = %137, %144
%140 = phi i8* [ %145, %144 ], [ %51, %137 ]
%141 = phi i32 [ %146, %144 ], [ %49, %137 ]
%142 = load i8, i8* %140
%143 = icmp eq i8 %142, 59
br i1 %143, label %220, label %144
144: ; preds = %139
%145 = getelementptr inbounds i8, i8* %140, i64 1
%146 = add i32 %141, 1
%147 = icmp eq i32 %146, 512
br i1 %147, label %220, label %139
148: ; preds = %134
%149 = call i32 @strncmp(i8* %51, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.4, i64 0, i64 0), i32 16)
%150 = icmp eq i32 %149, 0
br i1 %150, label %151, label %171
151: ; preds = %148
%152 = add i32 %49, -452
%153 = icmp ult i32 %152, -512
br i1 %153, label %258, label %154
154: ; preds = %151
%155 = getelementptr inbounds i8, i8* %51, i64 16
%156 = call i32 (i8*, ...) @memcpy(i8* %5, i8* %155, i32 60)
store i8 0, i8* %40
%157 = add nsw i32 %49, 76
%158 = icmp ult i32 %157, 512
br i1 %158, label %159, label %220
159: ; preds = %154
%160 = zext i32 %157 to i64
%161 = getelementptr inbounds [512 x i8], [512 x i8]* %8, i64 0, i64 %160
br label %162
162: ; preds = %159, %167
%163 = phi i8* [ %168, %167 ], [ %161, %159 ]
%164 = phi i32 [ %169, %167 ], [ %157, %159 ]
%165 = load i8, i8* %163
%166 = icmp eq i8 %165, 59
br i1 %166, label %220, label %167
167: ; preds = %162
%168 = getelementptr inbounds i8, i8* %163, i64 1
%169 = add i32 %164, 1
%170 = icmp eq i32 %169, 512
br i1 %170, label %220, label %162
171: ; preds = %148
%172 = call i32 @strncmp(i8* %51, i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.5, i64 0, i64 0), i32 17)
%173 = icmp eq i32 %172, 0
br i1 %173, label %174, label %218
174: ; preds = %171
%175 = add i32 %49, 17
%176 = icmp ugt i32 %175, 511
br i1 %176, label %217, label %177
177: ; preds = %174
%178 = zext i32 %175 to i64
br label %179
179: ; preds = %177, %185
%180 = phi i64 [ %178, %177 ], [ %187, %185 ]
%181 = phi i8* [ %21, %177 ], [ %186, %185 ]
%182 = getelementptr inbounds [512 x i8], [512 x i8]* %8, i64 0, i64 %180
%183 = load i8, i8* %182
%184 = icmp eq i8 %183, 59
br i1 %184, label %189, label %185
185: ; preds = %179
store i8 %183, i8* %181
%186 = getelementptr inbounds i8, i8* %181, i64 1
%187 = add nuw nsw i64 %180, 1
%188 = icmp eq i64 %187, 512
br i1 %188, label %191, label %179
189: ; preds = %179
%190 = trunc i64 %180 to i32
br label %191
191: ; preds = %185, %189
%192 = phi i32 [ %190, %189 ], [ 512, %185 ]
%193 = phi i8* [ %181, %189 ], [ %186, %185 ]
store i8 0, i8* %193
%194 = call i8* @strtol(i8* %21, i8** %11, i32 10)
%195 = ptrtoint i8* %194 to i64
store i64 %195, i64* %6
%196 = load i8*, i8** %11
%197 = icmp eq i8* %196, null
br i1 %197, label %201, label %198
198: ; preds = %191
%199 = load i8, i8* %196
%200 = icmp eq i8 %199, 0
br i1 %200, label %201, label %217
201: ; preds = %198, %191
%202 = icmp ult i32 %192, 512
br i1 %202, label %203, label %215
203: ; preds = %201
%204 = zext i32 %192 to i64
%205 = getelementptr inbounds [512 x i8], [512 x i8]* %8, i64 0, i64 %204
br label %206
206: ; preds = %203, %211
%207 = phi i8* [ %212, %211 ], [ %205, %203 ]
%208 = phi i32 [ %213, %211 ], [ %192, %203 ]
%209 = load i8, i8* %207
%210 = icmp eq i8 %209, 59
br i1 %210, label %215, label %211
211: ; preds = %206
%212 = getelementptr inbounds i8, i8* %207, i64 1
%213 = add i32 %208, 1
%214 = icmp eq i32 %213, 512
br i1 %214, label %215, label %206
215: ; preds = %206, %211, %201
%216 = phi i32 [ %192, %201 ], [ 512, %211 ], [ %208, %206 ]
br label %220
217: ; preds = %198, %174
br label %258
218: ; preds = %171
%219 = add i32 %49, 1
br label %220
220: ; preds = %167, %162, %139, %144, %130, %125, %68, %63, %154, %137, %123, %215, %117, %218
%221 = phi i32 [ %44, %218 ], [ 1, %117 ], [ %44, %215 ], [ %44, %123 ], [ %44, %137 ], [ %44, %154 ], [ %44, %63 ], [ %44, %68 ], [ %44, %125 ], [ %44, %130 ], [ %44, %144 ], [ %44, %139 ], [ %44, %162 ], [ %44, %167 ]
%222 = phi i32 [ %45, %218 ], [ %45, %117 ], [ %45, %215 ], [ %45, %123 ], [ %45, %137 ], [ %45, %154 ], [ 1, %63 ], [ 1, %68 ], [ %45, %125 ], [ %45, %130 ], [ %45, %144 ], [ %45, %139 ], [ %45, %162 ], [ %45, %167 ]
%223 = phi i32 [ %46, %218 ], [ %46, %117 ], [ %46, %215 ], [ 1, %123 ], [ 1, %137 ], [ %46, %154 ], [ %46, %63 ], [ %46, %68 ], [ 1, %125 ], [ 1, %130 ], [ 1, %144 ], [ 1, %139 ], [ %46, %162 ], [ %46, %167 ]
%224 = phi i32 [ %47, %218 ], [ %47, %117 ], [ %47, %215 ], [ %47, %123 ], [ %47, %137 ], [ 1, %154 ], [ %47, %63 ], [ %47, %68 ], [ %47, %125 ], [ %47, %130 ], [ %47, %144 ], [ %47, %139 ], [ 1, %162 ], [ 1, %167 ]
%225 = phi i32 [ %48, %218 ], [ %48, %117 ], [ 1, %215 ], [ %48, %123 ], [ %48, %137 ], [ %48, %154 ], [ %48, %63 ], [ %48, %68 ], [ %48, %125 ], [ %48, %130 ], [ %48, %144 ], [ %48, %139 ], [ %48, %162 ], [ %48, %167 ]
%226 = phi i32 [ %219, %218 ], [ %118, %117 ], [ %216, %215 ], [ %49, %123 ], [ %49, %137 ], [ %157, %154 ], [ 512, %68 ], [ %65, %63 ], [ 512, %130 ], [ %127, %125 ], [ %141, %139 ], [ 512, %144 ], [ 512, %167 ], [ %164, %162 ]
%227 = and i32 %222, %221
%228 = and i32 %223, %227
%229 = and i32 %228, %224
%230 = and i32 %229, %225
%231 = icmp eq i32 %230, 0
%232 = icmp ult i32 %226, 512
%233 = select i1 %231, i1 %232, i1 false
br i1 %233, label %43, label %234
234: ; preds = %220
%235 = icmp eq i32 %227, 0
br i1 %235, label %258, label %236
236: ; preds = %234
%237 = getelementptr inbounds i8, i8* %19, i64 84
%238 = load i8, i8* %237
%239 = zext i8 %238 to i64
%240 = shl nuw nsw i64 %239, 24
%241 = getelementptr inbounds i8, i8* %19, i64 85
%242 = load i8, i8* %241
%243 = zext i8 %242 to i64
%244 = shl nuw nsw i64 %243, 16
%245 = or i64 %244, %240
%246 = getelementptr inbounds i8, i8* %19, i64 86
%247 = load i8, i8* %246
%248 = zext i8 %247 to i64
%249 = shl nuw nsw i64 %248, 8
%250 = or i64 %245, %249
%251 = getelementptr inbounds i8, i8* %19, i64 87
%252 = load i8, i8* %251
%253 = zext i8 %252 to i64
%254 = or i64 %250, %253
%255 = shl nuw nsw i64 %254, 11
store i64 %255, i64* %3
%256 = call i32 @free(i8* %16)
%257 = trunc i64 %29 to i32
br label %260
258: ; preds = %31, %28, %151, %54, %25, %217, %119, %234, %7
%259 = call i32 @free(i8* %16)
br label %260
260: ; preds = %258, %236
%261 = phi i32 [ -1, %258 ], [ %257, %236 ]
ret i32 %261
}