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

/* Variables and functions */
int /*<<< orphan*/ SEEK_CUR;
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
scalar_t__ ferror(int /*<<< orphan*/ *);
void *fgetc(int /*<<< orphan*/ *);
int fgetword(int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char const *, char *);
int /*<<< orphan*/ fread(unsigned char *, int, int, int /*<<< orphan*/ *);
int /*<<< orphan*/ free(unsigned char *);
int /*<<< orphan*/ fseek(int /*<<< orphan*/ *, int, int /*<<< orphan*/);
unsigned char *malloc(int);
int /*<<< orphan*/ memset(unsigned char **, int /*<<< orphan*/, int);
int tga_load(const char *name, unsigned char **buffer, int *width,
             int *height) {
  FILE *f;
  int idLen;
  int colorMapType;
  int imageType;
  int firstColor;
  int colorMapLen;
  int colorMapBits;
  int xOrgin;
  int yOrgin;
  int iw;
  int ih;
  int bitsPerPix;
  int descriptor;
  int i, j, k;
  unsigned char *p;
  unsigned char *q;
  unsigned char *pp;
  int bb;
  int cp[4];
  int rle;
  int n;
  int c;
  int ix, iy;
  unsigned char colorMap[256][3];
  unsigned char *data;
  data = NULL;
  if ((f = fopen(name, "rb")) == NULL)
    return 0;
  idLen = fgetc(f);
  colorMapType = fgetc(f);
  imageType = fgetc(f);
  firstColor = fgetword(f);
  colorMapLen = fgetword(f);
  colorMapBits = fgetc(f);
  xOrgin = fgetword(f);
  yOrgin = fgetword(f);
  iw = fgetword(f);
  ih = fgetword(f);
  bitsPerPix = fgetc(f);
  descriptor = fgetc(f);
  switch (imageType) {
  case 3:
  case 1:
  case 2:
  case 11:
  case 9:
  case 10:
    break;
  default:
    goto error;
  }
  switch (bitsPerPix) {
  case 8:
  case 24:
  case 32:
    bb = bitsPerPix / 8;
    break;
  default:
    goto error;
  }
  if (idLen)
    fseek(f, idLen, SEEK_CUR);
  *width = iw;
  *height = ih;
  if (colorMapType == 1) {
    memset(colorMap, 0, sizeof(colorMap));
    if ((colorMapBits != 24) || (colorMapLen + firstColor > 256)) {
      goto error;
    }
    for (i = 0, pp = colorMap[firstColor]; i < colorMapLen; i++) {
      *pp++ = fgetc(f);
      *pp++ = fgetc(f);
      *pp++ = fgetc(f);
    }
  } else {
    for (i = 0; i < 256; ++i)
      colorMap[i][0] = colorMap[i][1] = colorMap[i][2] = i;
  }
  if ((data = malloc(iw * bb * ih)) == NULL) {
    goto error;
  }
  if ((imageType == 3) || (imageType == 1) || (imageType == 2)) {
    fread(data, ih, iw * bb, f);
  } else {
    p = data;
    n = 0;
    for (j = 0; j < ih; ++j) {
      for (i = 0; i < iw; ++i, p += bb) {
        if (n == 0) {
          c = fgetc(f);
          n = (c & 0x7F) + 1;
          if (c & 0x80) {
            for (k = 0; k < bb; k++)
              cp[k] = fgetc(f);
            rle = 1;
          } else {
            rle = 0;
          }
        }
        if (rle)
          for (k = 0; k < bb; k++)
            p[k] = cp[k];
        else
          for (k = 0; k < bb; k++)
            p[k] = fgetc(f);
        n--;
      }
    }
  }
  if (ferror(f)) {
    goto error;
  }
  fclose(f);
  *buffer = (unsigned char *)malloc(iw * ih * 4);
  if (!*buffer)
    goto error;
  p = *buffer;
  switch ((descriptor >> 4) & 0x3) {
  case 0x00:
    ix = bb;
    iy = -2 * iw * bb;
    q = data + iw * bb * (ih - 1);
    break;
  case 0x01:
    ix = -bb;
    iy = 0;
    q = data + (iw - 1) * bb * (ih);
    break;
  case 0x02:
    ix = bb;
    iy = 0;
    q = data;
    break;
  case 0x03:
    ix = -bb;
    iy = 2 * iw * bb;
    q = data + (iw - 1) * bb;
    break;
  }
  switch (bitsPerPix) {
  case 8: {
    for (j = 0; j < ih; ++j) {
      for (i = 0; i < iw; ++i) {
        for (k = 0; k < 3; ++k) {
          p[k] = colorMap[*q][k];
        }
        p[3] = 0xff;
        p += 4;
        q += ix;
      }
      q += iy;
    }
    break;
  }
  case 24: {
    for (j = 0; j < ih; ++j) {
      for (i = 0; i < iw; ++i) {
        p[0] = q[0];
        p[1] = q[1];
        p[2] = q[2];
        p[3] = 0xff;
        p += 4;
        q += ix;
      }
      q += iy;
    }
    break;
  }
  case 32: {
    for (j = 0; j < ih; ++j) {
      for (i = 0; i < iw; ++i) {
        p[0] = q[0];
        p[1] = q[1];
        p[2] = q[2];
        p[3] = q[3];
        p += 4;
        q += ix;
      }
      q += iy;
    }
    break;
  }
  }
  free(data);
  return 1;
error:
  if (data)
    free(data);
  if (f)
    fclose(f);
  *buffer = NULL;
  *width = 0;
  *height = 0;
  return 0;
}


x86 assembly (clang, -O0):
<tga_load>:
push   %rbp
mov    %rsp,%rbp
sub    $0x3e0,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
movq   $0x0,-0x3c8(%rbp)
mov    -0x10(%rbp),%rdi
lea    0xe3f(%rip),%rsi
call   10c0 <fopen@plt>
mov    %rax,-0x30(%rbp)
cmp    $0x0,%rax
jne    11f0 <tga_load+0x50>
movl   $0x0,-0x4(%rbp)
jmp    1aef <tga_load+0x94f>
mov    -0x30(%rbp),%rdi
call   1080 <fgetc@plt>
mov    %eax,-0x34(%rbp)
mov    -0x30(%rbp),%rdi
call   1080 <fgetc@plt>
mov    %eax,-0x38(%rbp)
mov    -0x30(%rbp),%rdi
call   1080 <fgetc@plt>
mov    %eax,-0x3c(%rbp)
mov    -0x30(%rbp),%rdi
call   10a0 <fgetword@plt>
mov    %eax,-0x40(%rbp)
mov    -0x30(%rbp),%rdi
call   10a0 <fgetword@plt>
mov    %eax,-0x44(%rbp)
mov    -0x30(%rbp),%rdi
call   1080 <fgetc@plt>
mov    %eax,-0x48(%rbp)
mov    -0x30(%rbp),%rdi
call   10a0 <fgetword@plt>
mov    %eax,-0x4c(%rbp)
mov    -0x30(%rbp),%rdi
call   10a0 <fgetword@plt>
mov    %eax,-0x50(%rbp)
mov    -0x30(%rbp),%rdi
call   10a0 <fgetword@plt>
mov    %eax,-0x54(%rbp)
mov    -0x30(%rbp),%rdi
call   10a0 <fgetword@plt>
mov    %eax,-0x58(%rbp)
mov    -0x30(%rbp),%rdi
call   1080 <fgetc@plt>
mov    %eax,-0x5c(%rbp)
mov    -0x30(%rbp),%rdi
call   1080 <fgetc@plt>
mov    %eax,-0x60(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x3cc(%rbp)
add    $0xffffffff,%eax
sub    $0x3,%eax
jb     12b1 <tga_load+0x111>
jmp    129a <tga_load+0xfa>
mov    -0x3cc(%rbp),%eax
add    $0xfffffff7,%eax
sub    $0x2,%eax
ja     12b6 <tga_load+0x116>
jmp    12b1 <tga_load+0x111>
jmp    12bb <tga_load+0x11b>
jmp    1a9b <tga_load+0x8fb>
mov    -0x5c(%rbp),%eax
mov    %eax,-0x3d0(%rbp)
sub    $0x8,%eax
je     12fa <tga_load+0x15a>
jmp    12d2 <tga_load+0x132>
mov    -0x3d0(%rbp),%eax
sub    $0x18,%eax
je     12fa <tga_load+0x15a>
jmp    12e6 <tga_load+0x146>
mov    -0x3d0(%rbp),%eax
sub    $0x20,%eax
jne    1310 <tga_load+0x170>
jmp    12fa <tga_load+0x15a>
mov    -0x5c(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %eax,-0x8c(%rbp)
jmp    1315 <tga_load+0x175>
jmp    1a9b <tga_load+0x8fb>
cmpl   $0x0,-0x34(%rbp)
je     1334 <tga_load+0x194>
mov    -0x30(%rbp),%rdi
mov    -0x34(%rbp),%esi
mov    0x2cbb(%rip),%rax
mov    (%rax),%edx
call   10b0 <fseek@plt>
mov    -0x54(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x58(%rbp),%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
cmpl   $0x1,-0x38(%rbp)
jne    1428 <tga_load+0x288>
lea    -0x3c0(%rbp),%rdi
xor    %esi,%esi
mov    $0x300,%edx
call   1070 <memset@plt>
cmpl   $0x18,-0x48(%rbp)
jne    137e <tga_load+0x1de>
mov    -0x44(%rbp),%eax
add    -0x40(%rbp),%eax
cmp    $0x100,%eax
jle    1383 <tga_load+0x1e3>
jmp    1a9b <tga_load+0x8fb>
movl   $0x0,-0x64(%rbp)
movslq -0x40(%rbp),%rcx
lea    -0x3c0(%rbp),%rax
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
mov    %rax,-0x88(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1423 <tga_load+0x283>
mov    -0x30(%rbp),%rdi
call   1080 <fgetc@plt>
mov    %al,%cl
mov    -0x88(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x88(%rbp)
mov    %cl,(%rax)
mov    -0x30(%rbp),%rdi
call   1080 <fgetc@plt>
mov    %al,%cl
mov    -0x88(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x88(%rbp)
mov    %cl,(%rax)
mov    -0x30(%rbp),%rdi
call   1080 <fgetc@plt>
mov    %al,%cl
mov    -0x88(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x88(%rbp)
mov    %cl,(%rax)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    13a3 <tga_load+0x203>
jmp    1492 <tga_load+0x2f2>
movl   $0x0,-0x64(%rbp)
cmpl   $0x100,-0x64(%rbp)
jge    148d <tga_load+0x2ed>
mov    -0x64(%rbp),%eax
mov    %al,%cl
movslq -0x64(%rbp),%rdx
lea    -0x3c0(%rbp),%rax
imul   $0x3,%rdx,%rdx
add    %rdx,%rax
mov    %cl,0x2(%rax)
movslq -0x64(%rbp),%rdx
lea    -0x3c0(%rbp),%rax
imul   $0x3,%rdx,%rdx
add    %rdx,%rax
mov    %cl,0x1(%rax)
movslq -0x64(%rbp),%rdx
lea    -0x3c0(%rbp),%rax
imul   $0x3,%rdx,%rdx
add    %rdx,%rax
mov    %cl,(%rax)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    142f <tga_load+0x28f>
jmp    1492 <tga_load+0x2f2>
mov    -0x54(%rbp),%edi
imul   -0x8c(%rbp),%edi
imul   -0x58(%rbp),%edi
call   1090 <malloc@plt>
mov    %rax,-0x3c8(%rbp)
cmp    $0x0,%rax
jne    14bb <tga_load+0x31b>
jmp    1a9b <tga_load+0x8fb>
cmpl   $0x3,-0x3c(%rbp)
je     14d9 <tga_load+0x339>
cmpl   $0x1,-0x3c(%rbp)
je     14d9 <tga_load+0x339>
cmpl   $0x2,-0x3c(%rbp)
jne    14fb <tga_load+0x35b>
mov    -0x3c8(%rbp),%rdi
mov    -0x58(%rbp),%esi
mov    -0x54(%rbp),%edx
imul   -0x8c(%rbp),%edx
mov    -0x30(%rbp),%rcx
call   1050 <fread@plt>
jmp    16a6 <tga_load+0x506>
mov    -0x3c8(%rbp),%rax
mov    %rax,-0x78(%rbp)
movl   $0x0,-0xa8(%rbp)
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x58(%rbp),%eax
jge    16a1 <tga_load+0x501>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    168e <tga_load+0x4ee>
cmpl   $0x0,-0xa8(%rbp)
jne    15d0 <tga_load+0x430>
mov    -0x30(%rbp),%rdi
call   1080 <fgetc@plt>
mov    %eax,-0xac(%rbp)
mov    -0xac(%rbp),%eax
and    $0x7f,%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
mov    -0xac(%rbp),%eax
and    $0x80,%eax
cmp    $0x0,%eax
je     15c1 <tga_load+0x421>
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x8c(%rbp),%eax
jge    15b2 <tga_load+0x412>
mov    -0x30(%rbp),%rdi
call   1080 <fgetc@plt>
mov    %eax,%ecx
movslq -0x6c(%rbp),%rax
mov    %ecx,-0xa0(%rbp,%rax,4)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    157f <tga_load+0x3df>
movl   $0x1,-0xa4(%rbp)
jmp    15cb <tga_load+0x42b>
movl   $0x0,-0xa4(%rbp)
jmp    15d0 <tga_load+0x430>
cmpl   $0x0,-0xa4(%rbp)
je     161e <tga_load+0x47e>
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x8c(%rbp),%eax
jge    1619 <tga_load+0x479>
movslq -0x6c(%rbp),%rax
mov    -0xa0(%rbp,%rax,4),%eax
mov    %al,%dl
mov    -0x78(%rbp),%rax
movslq -0x6c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    15e4 <tga_load+0x444>
jmp    165d <tga_load+0x4bd>
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x8c(%rbp),%eax
jge    1658 <tga_load+0x4b8>
mov    -0x30(%rbp),%rdi
call   1080 <fgetc@plt>
mov    %al,%dl
mov    -0x78(%rbp),%rax
movslq -0x6c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1625 <tga_load+0x485>
jmp    165d <tga_load+0x4bd>
mov    -0xa8(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xa8(%rbp)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
mov    -0x8c(%rbp),%ecx
mov    -0x78(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
jmp    152a <tga_load+0x38a>
jmp    1693 <tga_load+0x4f3>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1517 <tga_load+0x377>
jmp    16a6 <tga_load+0x506>
mov    -0x30(%rbp),%rdi
call   1040 <ferror@plt>
cmp    $0x0,%rax
je     16be <tga_load+0x51e>
jmp    1a9b <tga_load+0x8fb>
mov    -0x30(%rbp),%rdi
call   1060 <fclose@plt>
mov    -0x54(%rbp),%edi
imul   -0x58(%rbp),%edi
shl    $0x2,%edi
call   1090 <malloc@plt>
mov    %rax,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rax
cmpq   $0x0,(%rax)
jne    16f3 <tga_load+0x553>
jmp    1a9b <tga_load+0x8fb>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x78(%rbp)
mov    -0x60(%rbp),%eax
shr    $0x4,%eax
and    $0x3,%eax
mov    %eax,%ecx
mov    %rcx,-0x3d8(%rbp)
sub    $0x3,%eax
ja     181d <tga_load+0x67d>
mov    -0x3d8(%rbp),%rax
lea    0x8d9(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x8c(%rbp),%eax
mov    %eax,-0xb0(%rbp)
imul   $0xfffffffe,-0x54(%rbp),%eax
imul   -0x8c(%rbp),%eax
mov    %eax,-0xb4(%rbp)
mov    -0x3c8(%rbp),%rax
mov    -0x54(%rbp),%ecx
imul   -0x8c(%rbp),%ecx
mov    -0x58(%rbp),%edx
sub    $0x1,%edx
imul   %edx,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
jmp    181d <tga_load+0x67d>
xor    %eax,%eax
sub    -0x8c(%rbp),%eax
mov    %eax,-0xb0(%rbp)
movl   $0x0,-0xb4(%rbp)
mov    -0x3c8(%rbp),%rax
mov    -0x54(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x8c(%rbp),%ecx
imul   -0x58(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
jmp    181d <tga_load+0x67d>
mov    -0x8c(%rbp),%eax
mov    %eax,-0xb0(%rbp)
movl   $0x0,-0xb4(%rbp)
mov    -0x3c8(%rbp),%rax
mov    %rax,-0x80(%rbp)
jmp    181d <tga_load+0x67d>
xor    %eax,%eax
sub    -0x8c(%rbp),%eax
mov    %eax,-0xb0(%rbp)
mov    -0x54(%rbp),%eax
shl    $0x1,%eax
imul   -0x8c(%rbp),%eax
mov    %eax,-0xb4(%rbp)
mov    -0x3c8(%rbp),%rax
mov    -0x54(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x8c(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
mov    -0x5c(%rbp),%eax
mov    %eax,-0x3dc(%rbp)
sub    $0x8,%eax
je     185c <tga_load+0x6bc>
jmp    1834 <tga_load+0x694>
mov    -0x3dc(%rbp),%eax
sub    $0x18,%eax
je     1927 <tga_load+0x787>
jmp    1848 <tga_load+0x6a8>
mov    -0x3dc(%rbp),%eax
sub    $0x20,%eax
je     19d2 <tga_load+0x832>
jmp    1a83 <tga_load+0x8e3>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x58(%rbp),%eax
jge    1922 <tga_load+0x782>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    1900 <tga_load+0x760>
movl   $0x0,-0x6c(%rbp)
cmpl   $0x3,-0x6c(%rbp)
jge    18ca <tga_load+0x72a>
mov    -0x80(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,%ecx
lea    -0x3c0(%rbp),%rax
imul   $0x3,%rcx,%rcx
add    %rcx,%rax
movslq -0x6c(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x78(%rbp),%rax
movslq -0x6c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1889 <tga_load+0x6e9>
mov    -0x78(%rbp),%rax
movb   $0xff,0x3(%rax)
mov    -0x78(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x78(%rbp)
mov    -0xb0(%rbp),%ecx
mov    -0x80(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1876 <tga_load+0x6d6>
mov    -0xb4(%rbp),%ecx
mov    -0x80(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1863 <tga_load+0x6c3>
jmp    1a83 <tga_load+0x8e3>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x58(%rbp),%eax
jge    19cd <tga_load+0x82d>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    19ab <tga_load+0x80b>
mov    -0x80(%rbp),%rax
mov    (%rax),%cl
mov    -0x78(%rbp),%rax
mov    %cl,(%rax)
mov    -0x80(%rbp),%rax
mov    0x1(%rax),%cl
mov    -0x78(%rbp),%rax
mov    %cl,0x1(%rax)
mov    -0x80(%rbp),%rax
mov    0x2(%rax),%cl
mov    -0x78(%rbp),%rax
mov    %cl,0x2(%rax)
mov    -0x78(%rbp),%rax
movb   $0xff,0x3(%rax)
mov    -0x78(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x78(%rbp)
mov    -0xb0(%rbp),%ecx
mov    -0x80(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1941 <tga_load+0x7a1>
mov    -0xb4(%rbp),%ecx
mov    -0x80(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    192e <tga_load+0x78e>
jmp    1a83 <tga_load+0x8e3>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x58(%rbp),%eax
jge    1a7e <tga_load+0x8de>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    1a5c <tga_load+0x8bc>
mov    -0x80(%rbp),%rax
mov    (%rax),%cl
mov    -0x78(%rbp),%rax
mov    %cl,(%rax)
mov    -0x80(%rbp),%rax
mov    0x1(%rax),%cl
mov    -0x78(%rbp),%rax
mov    %cl,0x1(%rax)
mov    -0x80(%rbp),%rax
mov    0x2(%rax),%cl
mov    -0x78(%rbp),%rax
mov    %cl,0x2(%rax)
mov    -0x80(%rbp),%rax
mov    0x3(%rax),%cl
mov    -0x78(%rbp),%rax
mov    %cl,0x3(%rax)
mov    -0x78(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x78(%rbp)
mov    -0xb0(%rbp),%ecx
mov    -0x80(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    19ec <tga_load+0x84c>
mov    -0xb4(%rbp),%ecx
mov    -0x80(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    19d9 <tga_load+0x839>
jmp    1a83 <tga_load+0x8e3>
mov    -0x3c8(%rbp),%rdi
call   1030 <free@plt>
movl   $0x1,-0x4(%rbp)
jmp    1aef <tga_load+0x94f>
cmpq   $0x0,-0x3c8(%rbp)
je     1ab5 <tga_load+0x915>
mov    -0x3c8(%rbp),%rdi
call   1030 <free@plt>
cmpq   $0x0,-0x30(%rbp)
je     1ac9 <tga_load+0x929>
mov    -0x30(%rbp),%rdi
call   1060 <fclose@plt>
mov    -0x18(%rbp),%rax
movq   $0x0,(%rax)
mov    -0x20(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x28(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x3e0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<tga_load>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x3b8,%rsp
mov    %rcx,%r14
mov    %rdx,0x70(%rsp)
mov    %rsi,%rbp
lea    0xe5d(%rip),%rsi
call   10c0 <fopen@plt>
mov    %rax,%r12
xor    %eax,%eax
test   %r12,%r12
je     17a7 <tga_load+0x607>
mov    %rbp,0x68(%rsp)
mov    %r12,%rdi
call   1080 <fgetc@plt>
mov    %rax,%rbx
mov    %r12,%rdi
call   1080 <fgetc@plt>
mov    %rax,0x38(%rsp)
mov    %r12,%rdi
call   1080 <fgetc@plt>
mov    %rax,%r13
mov    %r12,%rdi
call   10a0 <fgetword@plt>
mov    %eax,%ebp
mov    %r12,%rdi
call   10a0 <fgetword@plt>
mov    %eax,%r15d
mov    %r12,%rdi
call   1080 <fgetc@plt>
mov    %rax,0x50(%rsp)
mov    %r12,%rdi
call   10a0 <fgetword@plt>
mov    %r12,%rdi
call   10a0 <fgetword@plt>
mov    %r12,%rdi
call   10a0 <fgetword@plt>
mov    %rax,0x30(%rsp)
mov    %r12,%rdi
call   10a0 <fgetword@plt>
mov    %rax,0x10(%rsp)
mov    %r12,%rdi
call   1080 <fgetc@plt>
mov    %rax,0x18(%rsp)
mov    %r12,0x8(%rsp)
mov    %r12,%rdi
call   1080 <fgetc@plt>
cmp    $0xb,%r13d
ja     177d <tga_load+0x5dd>
mov    %rax,%r12
mov    $0xe0e,%eax
bt     %r13d,%eax
jae    177d <tga_load+0x5dd>
cmpl   $0x20,0x18(%rsp)
ja     177d <tga_load+0x5dd>
mov    0x18(%rsp),%eax
movabs $0x101000100,%rcx
bt     %rax,%rcx
jae    177d <tga_load+0x5dd>
test   %ebx,%ebx
je     12bc <tga_load+0x11c>
mov    0x2d3a(%rip),%rax
mov    (%rax),%edx
mov    0x8(%rsp),%rdi
mov    %ebx,%esi
call   10b0 <fseek@plt>
mov    0x70(%rsp),%rax
mov    0x30(%rsp),%rcx
mov    %ecx,(%rax)
mov    0x10(%rsp),%rax
mov    %eax,(%r14)
cmpl   $0x1,0x38(%rsp)
jne    135c <tga_load+0x1bc>
lea    0xb0(%rsp),%rdi
xor    %esi,%esi
mov    $0x300,%edx
call   1070 <memset@plt>
cmpl   $0x18,0x50(%rsp)
jne    177d <tga_load+0x5dd>
lea    (%r15,%rbp,1),%eax
cmp    $0x100,%eax
jg     177d <tga_load+0x5dd>
test   %r15d,%r15d
jle    1397 <tga_load+0x1f7>
movslq %ebp,%rax
lea    (%rax,%rax,2),%rax
lea    (%rsp,%rax,1),%rbx
add    $0xb0,%rbx
mov    0x8(%rsp),%rbp
nopl   0x0(%rax)
mov    %rbp,%rdi
call   1080 <fgetc@plt>
mov    %al,(%rbx)
mov    %rbp,%rdi
call   1080 <fgetc@plt>
mov    %al,0x1(%rbx)
mov    %rbp,%rdi
call   1080 <fgetc@plt>
mov    %al,0x2(%rbx)
add    $0x3,%rbx
add    $0xffffffff,%r15d
jne    1330 <tga_load+0x190>
jmp    1397 <tga_load+0x1f7>
lea    0xb5(%rsp),%rax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
mov    %cl,-0x3(%rax)
mov    %cl,-0x4(%rax)
mov    %cl,-0x5(%rax)
mov    %ecx,%edx
or     $0x1,%dl
mov    %dl,(%rax)
mov    %dl,-0x1(%rax)
mov    %dl,-0x2(%rax)
add    $0x2,%rcx
add    $0x6,%rax
cmp    $0x100,%rcx
jne    1370 <tga_load+0x1d0>
mov    0x18(%rsp),%rax
mov    %eax,%ebp
shr    $0x3,%ebp
mov    %ebp,%ebx
imul   0x30(%rsp),%ebx
mov    %ebx,%edi
imul   0x10(%rsp),%edi
call   1090 <malloc@plt>
test   %rax,%rax
je     177d <tga_load+0x5dd>
mov    %ebp,0x4(%rsp)
mov    %r12,0x78(%rsp)
mov    %r14,0x80(%rsp)
add    $0xffffffff,%r13d
cmp    $0x3,%r13d
mov    %rax,0x48(%rsp)
mov    %rbx,0x60(%rsp)
jae    1405 <tga_load+0x265>
mov    %rax,%rdi
mov    0x10(%rsp),%rsi
mov    %ebx,%edx
mov    0x8(%rsp),%rcx
call   1050 <fread@plt>
mov    0x18(%rsp),%rbp
mov    0x30(%rsp),%r15
jmp    1759 <tga_load+0x5b9>
cmpl   $0x0,0x10(%rsp)
mov    0x18(%rsp),%rbp
mov    0x30(%rsp),%r15
jle    1759 <tga_load+0x5b9>
mov    0x4(%rsp),%r12d
lea    (%rsp,%r12,4),%rax
add    $0x20,%rax
mov    %rax,0xa8(%rsp)
mov    %rbp,%rax
shr    $0x3,%rax
and    $0x1ffffff8,%eax
add    $0xfffffffffffffff8,%rax
mov    %rax,0xa0(%rsp)
mov    %rax,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %r12d,%eax
and    $0xfffffff8,%eax
mov    %rax,0x90(%rsp)
mov    %rcx,%rax
mov    %rcx,0x98(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x88(%rsp)
mov    %r12d,%r8d
and    $0x3,%r8d
xor    %r14d,%r14d
movdqa 0xb77(%rip),%xmm2
mov    0x48(%rsp),%rax
mov    %rax,0x40(%rsp)
xor    %eax,%eax
mov    %r8,0x38(%rsp)
jmp    14bb <tga_load+0x31b>
nopl   0x0(%rax)
mov    0x40(%rsp),%rbx
mov    0x5c(%rsp),%eax
add    $0x1,%eax
mov    %rbx,0x40(%rsp)
cmp    0x10(%rsp),%eax
je     1759 <tga_load+0x5b9>
mov    %eax,0x5c(%rsp)
test   %r15d,%r15d
jle    14a0 <tga_load+0x300>
xor    %r13d,%r13d
mov    0x40(%rsp),%rbx
jmp    14e0 <tga_load+0x340>
xor    %edi,%edi
add    $0xffffffff,%r14d
add    $0x1,%r13
add    %r12,%rbx
cmp    %r15d,%r13d
je     14a5 <tga_load+0x305>
test   %r14d,%r14d
je     1500 <tga_load+0x360>
test   %edi,%edi
je     1626 <tga_load+0x486>
cmp    $0x8,%ebp
jb     14d0 <tga_load+0x330>
jmp    157a <tga_load+0x3da>
nopw   0x0(%rax,%rax,1)
mov    0x8(%rsp),%rdi
call   1080 <fgetc@plt>
mov    %eax,%r14d
and    $0x7f,%r14d
add    $0x1,%r14d
and    $0x80,%eax
mov    %eax,%edi
shr    $0x7,%edi
test   %eax,%eax
je     1611 <tga_load+0x471>
cmp    $0x8,%ebp
jb     1611 <tga_load+0x471>
xor    %ebp,%ebp
mov    0x8(%rsp),%r15
nopw   0x0(%rax,%rax,1)
mov    %r15,%rdi
call   1080 <fgetc@plt>
mov    %eax,0x20(%rsp,%rbp,4)
add    $0x1,%rbp
cmp    %rbp,%r12
jne    1540 <tga_load+0x3a0>
mov    $0x1,%edi
mov    0x18(%rsp),%rbp
mov    0x30(%rsp),%r15
mov    0x38(%rsp),%r8
movdqa 0xa8f(%rip),%xmm2
cmp    $0x8,%ebp
jb     14d0 <tga_load+0x330>
cmp    $0x40,%ebp
jb     15aa <tga_load+0x40a>
cmp    0xa8(%rsp),%rbx
jae    1675 <tga_load+0x4d5>
mov    %r13,%rax
imul   %r12,%rax
add    %r12,%rax
add    0x40(%rsp),%rax
lea    0x20(%rsp),%rcx
cmp    %rcx,%rax
jbe    1675 <tga_load+0x4d5>
xor    %eax,%eax
mov    %rax,%rsi
not    %rsi
add    %r12,%rsi
test   %r8,%r8
je     15d2 <tga_load+0x432>
mov    %r8,%rdx
nopl   (%rax)
movzbl 0x20(%rsp,%rax,4),%ecx
mov    %cl,(%rbx,%rax,1)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    15c0 <tga_load+0x420>
cmp    $0x3,%rsi
jb     14d0 <tga_load+0x330>
nopl   0x0(%rax)
movzbl 0x20(%rsp,%rax,4),%ecx
mov    %cl,(%rbx,%rax,1)
movzbl 0x24(%rsp,%rax,4),%ecx
mov    %cl,0x1(%rbx,%rax,1)
movzbl 0x28(%rsp,%rax,4),%ecx
mov    %cl,0x2(%rbx,%rax,1)
movzbl 0x2c(%rsp,%rax,4),%ecx
mov    %cl,0x3(%rbx,%rax,1)
add    $0x4,%rax
cmp    %rax,%r12
jne    15e0 <tga_load+0x440>
jmp    14d0 <tga_load+0x330>
mov    0x38(%rsp),%r8
movdqa 0x9e2(%rip),%xmm2
test   %edi,%edi
jne    14ed <tga_load+0x34d>
cmp    $0x8,%ebp
jb     14ce <tga_load+0x32e>
mov    %edi,0x50(%rsp)
xor    %r15d,%r15d
mov    0x8(%rsp),%rbp
nopl   0x0(%rax,%rax,1)
mov    %rbp,%rdi
call   1080 <fgetc@plt>
mov    %al,(%rbx,%r15,1)
add    $0x1,%r15
cmp    %r15,%r12
jne    1640 <tga_load+0x4a0>
mov    0x30(%rsp),%r15
mov    0x18(%rsp),%rbp
mov    0x38(%rsp),%r8
movdqa 0x994(%rip),%xmm2
mov    0x50(%rsp),%edi
jmp    14d0 <tga_load+0x330>
cmpq   $0x0,0xa0(%rsp)
je     174b <tga_load+0x5ab>
mov    0x88(%rsp),%rcx
xor    %eax,%eax
xchg   %ax,%ax
movdqa 0x20(%rsp,%rax,4),%xmm0
pand   %xmm2,%xmm0
packuswb %xmm0,%xmm0
packuswb %xmm0,%xmm0
movdqa 0x30(%rsp,%rax,4),%xmm1
pand   %xmm2,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
movd   %xmm0,(%rbx,%rax,1)
movd   %xmm1,0x4(%rbx,%rax,1)
movdqa 0x40(%rsp,%rax,4),%xmm0
pand   %xmm2,%xmm0
packuswb %xmm0,%xmm0
packuswb %xmm0,%xmm0
movdqa 0x50(%rsp,%rax,4),%xmm1
pand   %xmm2,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
movd   %xmm0,0x8(%rbx,%rax,1)
movd   %xmm1,0xc(%rbx,%rax,1)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rcx
jne    1690 <tga_load+0x4f0>
testb  $0x1,0x98(%rsp)
je     1732 <tga_load+0x592>
movdqa 0x20(%rsp,%rax,4),%xmm0
pand   %xmm2,%xmm0
packuswb %xmm0,%xmm0
packuswb %xmm0,%xmm0
movdqa 0x30(%rsp,%rax,4),%xmm1
pand   %xmm2,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
movd   %xmm0,(%rbx,%rax,1)
movd   %xmm1,0x4(%rbx,%rax,1)
mov    0x90(%rsp),%rcx
mov    %rcx,%rax
cmp    %r12,%rcx
je     14d0 <tga_load+0x330>
jmp    15ac <tga_load+0x40c>
xor    %eax,%eax
testb  $0x1,0x98(%rsp)
01
jne    1703 <tga_load+0x563>
jmp    1732 <tga_load+0x592>
mov    0x8(%rsp),%rbx
mov    %rbx,%rdi
call   1040 <ferror@plt>
test   %rax,%rax
je     17b9 <tga_load+0x619>
mov    0x48(%rsp),%rdi
call   1030 <free@plt>
mov    0x80(%rsp),%r14
mov    0x8(%rsp),%rdi
call   1060 <fclose@plt>
mov    0x68(%rsp),%rax
movq   $0x0,(%rax)
mov    0x70(%rsp),%rax
movl   $0x0,(%rax)
movl   $0x0,(%r14)
xor    %eax,%eax
add    $0x3b8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %rbx,%rdi
call   1060 <fclose@plt>
mov    %r15d,%edi
imul   0x10(%rsp),%edi
shl    $0x2,%edi
call   1090 <malloc@plt>
mov    0x68(%rsp),%rcx
mov    %rax,(%rcx)
test   %rax,%rax
je     176b <tga_load+0x5cb>
mov    0x78(%rsp),%rdx
shr    $0x4,%edx
and    $0x3,%edx
xor    %esi,%esi
lea    0x81e(%rip),%rcx
movslq (%rcx,%rdx,4),%rdx
add    %rcx,%rdx
mov    0x48(%rsp),%rdi
mov    %rdi,%rcx
mov    0x10(%rsp),%r9
jmp    *%rdx
mov    0x60(%rsp),%rdx
lea    (%rdx,%rdx,1),%esi
neg    %esi
lea    -0x1(%r9),%ecx
imul   %edx,%ecx
jmp    1830 <tga_load+0x690>
lea    -0x1(%r15),%ecx
imul   %r9d,%ecx
mov    0x4(%rsp),%edx
imul   %edx,%ecx
neg    %edx
mov    %edx,0x4(%rsp)
movslq %ecx,%rdx
mov    %rdi,%rcx
add    %rdx,%rcx
jmp    185e <tga_load+0x6be>
lea    -0x1(%r15),%ecx
mov    0x4(%rsp),%edx
imul   %edx,%ecx
neg    %edx
mov    0x60(%rsp),%rbx
add    %ebx,%ebx
movslq %ecx,%rsi
mov    %rdi,%rcx
add    %rsi,%rcx
mov    %edx,0x4(%rsp)
mov    %ebx,%esi
cmp    $0x8,%ebp
je     1930 <tga_load+0x790>
cmp    $0x18,%ebp
je     19b7 <tga_load+0x817>
cmp    $0x20,%ebp
jne    1a67 <tga_load+0x8c7>
test   %r9d,%r9d
jle    1a67 <tga_load+0x8c7>
movslq 0x4(%rsp),%rdx
movslq %esi,%r10
mov    %r15d,%r8d
and    $0xfffffffe,%r8d
xor    %ebp,%ebp
jmp    18af <tga_load+0x70f>
cs nopw 0x0(%rax,%rax,1)
nop
add    %r10,%rcx
add    $0x1,%ebp
cmp    %r9d,%ebp
je     1a67 <tga_load+0x8c7>
test   %r15d,%r15d
jle    18a0 <tga_load+0x700>
cmp    $0x1,%r15d
je     1908 <tga_load+0x768>
mov    %r8d,%esi
nopl   (%rax)
movzbl (%rcx),%ebx
mov    %bl,(%rax)
movzbl 0x1(%rcx),%ebx
mov    %bl,0x1(%rax)
movzbl 0x2(%rcx),%ebx
mov    %bl,0x2(%rax)
movzbl 0x3(%rcx),%ebx
mov    %bl,0x3(%rax)
movzbl (%rcx,%rdx,1),%ebx
mov    %bl,0x4(%rax)
movzbl 0x1(%rcx,%rdx,1),%ebx
mov    %bl,0x5(%rax)
movzbl 0x2(%rcx,%rdx,1),%ebx
mov    %bl,0x6(%rax)
movzbl 0x3(%rcx,%rdx,1),%ebx
add    %rdx,%rcx
mov    %bl,0x7(%rax)
add    $0x8,%rax
add    %rdx,%rcx
add    $0xfffffffe,%esi
jne    18c0 <tga_load+0x720>
test   $0x1,%r15b
je     18a0 <tga_load+0x700>
mov    (%rcx),%bl
mov    %bl,(%rax)
mov    0x1(%rcx),%bl
mov    %bl,0x1(%rax)
mov    0x2(%rcx),%bl
mov    %bl,0x2(%rax)
mov    0x3(%rcx),%bl
mov    %bl,0x3(%rax)
add    $0x4,%rax
add    %rdx,%rcx
jmp    18a0 <tga_load+0x700>
test   %r9d,%r9d
jle    1a67 <tga_load+0x8c7>
movslq 0x4(%rsp),%rdx
movslq %esi,%r8
xor    %esi,%esi
jmp    195f <tga_load+0x7bf>
cs nopw 0x0(%rax,%rax,1)
nop
add    %r8,%rcx
add    $0x1,%esi
cmp    %r9d,%esi
je     1a67 <tga_load+0x8c7>
test   %r15d,%r15d
jle    1950 <tga_load+0x7b0>
mov    %r15d,%ebp
nopw   0x0(%rax,%rax,1)
movzbl (%rcx),%ebx
lea    (%rbx,%rbx,2),%rbx
movzbl 0xb0(%rsp,%rbx,1),%ebx
mov    %bl,(%rax)
movzbl (%rcx),%ebx
lea    (%rbx,%rbx,2),%rbx
movzbl 0xb1(%rsp,%rbx,1),%ebx
mov    %bl,0x1(%rax)
movzbl (%rcx),%ebx
lea    (%rbx,%rbx,2),%rbx
movzbl 0xb2(%rsp,%rbx,1),%ebx
mov    %bl,0x2(%rax)
movb   $0xff,0x3(%rax)
add    $0x4,%rax
add    %rdx,%rcx
add    $0xffffffff,%ebp
jne    1970 <tga_load+0x7d0>
jmp    1950 <tga_load+0x7b0>
test   %r9d,%r9d
jle    1a67 <tga_load+0x8c7>
movslq 0x4(%rsp),%rdx
movslq %esi,%r10
mov    %r15d,%r8d
and    $0xfffffffe,%r8d
xor    %ebp,%ebp
jmp    19eb <tga_load+0x84b>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    %r10,%rcx
add    $0x1,%ebp
cmp    %r9d,%ebp
je     1a67 <tga_load+0x8c7>
test   %r15d,%r15d
jle    19e0 <tga_load+0x840>
cmp    $0x1,%r15d
je     1a41 <tga_load+0x8a1>
mov    %r8d,%esi
nopl   0x0(%rax)
movzbl (%rcx),%ebx
mov    %bl,(%rax)
movzbl 0x1(%rcx),%ebx
mov    %bl,0x1(%rax)
movzbl 0x2(%rcx),%ebx
mov    %bl,0x2(%rax)
movb   $0xff,0x3(%rax)
movzbl (%rcx,%rdx,1),%ebx
mov    %bl,0x4(%rax)
movzbl 0x1(%rcx,%rdx,1),%ebx
mov    %bl,0x5(%rax)
movzbl 0x2(%rcx,%rdx,1),%ebx
add    %rdx,%rcx
mov    %bl,0x6(%rax)
movb   $0xff,0x7(%rax)
add    $0x8,%rax
add    %rdx,%rcx
add    $0xfffffffe,%esi
jne    1a00 <tga_load+0x860>
test   $0x1,%r15b
je     19e0 <tga_load+0x840>
mov    (%rcx),%bl
mov    %bl,(%rax)
mov    0x1(%rcx),%bl
mov    %bl,0x1(%rax)
mov    0x2(%rcx),%bl
mov    %bl,0x2(%rax)
movb   $0xff,0x3(%rax)
add    $0x4,%rax
add    %rdx,%rcx
jmp    19e0 <tga_load+0x840>
call   1030 <free@plt>
mov    $0x1,%eax
jmp    17a7 <tga_load+0x607>

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

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