#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*/ free(unsigned char *);
unsigned char *malloc(int);
int /*<<< orphan*/ memset(unsigned char *, int /*<<< orphan*/, int);
int /*<<< orphan*/ writefile(char *, unsigned char *, int);
void WriteTGA(char *filename, unsigned char *data, int width, int height,
              const unsigned char *palettergb) {
  int maxrun, run, c, y;
  unsigned char *buffer, *in, *end, *out;
  for (c = 0; c < width * height; c++)
    if (data[c] == 255)
      break;
  if (c < width * height) {
    buffer = malloc(18 + width * height * 5);
    memset(buffer, 0, 18);
    buffer[2] = 10;
    buffer[12] = (width >> 0) & 0xFF;
    buffer[13] = (width >> 8) & 0xFF;
    buffer[14] = (height >> 0) & 0xFF;
    buffer[15] = (height >> 8) & 0xFF;
    buffer[16] = 32;
    buffer[17] = 8;
    out = buffer + 18;
    for (y = 0; y < height; y++) {
      in = data + (height - 1 - y) * width;
      end = in + width;
      while (in < end) {
        maxrun = end - in;
        if (maxrun > 128)
          maxrun = 128;
        if (maxrun >= 2 && in[1] == in[0]) {
          for (run = 1; run < maxrun && in[run] == in[0]; run++)
            ;
          *out++ = 0x80 + (run - 1);
          if (in[0] == 255) {
            *out++ = 0;
            *out++ = 0;
            *out++ = 0;
            *out++ = 0;
          } else {
            *out++ = palettergb[in[0] * 3 + 2];
            *out++ = palettergb[in[0] * 3 + 1];
            *out++ = palettergb[in[0] * 3 + 0];
            *out++ = 255;
          }
          in += run;
        } else {
          for (run = 1;
               run < maxrun && (run >= maxrun - 1 || in[run + 1] != in[run]);
               run++)
            ;
          *out++ = 0x00 + (run - 1);
          for (c = 0; c < run; c++) {
            if (in[0] == 255) {
              *out++ = 0;
              *out++ = 0;
              *out++ = 0;
              *out++ = 0;
            } else {
              *out++ = palettergb[in[0] * 3 + 2];
              *out++ = palettergb[in[0] * 3 + 1];
              *out++ = palettergb[in[0] * 3 + 0];
              *out++ = 255;
            }
            in++;
          }
        }
      }
    }
  } else {
    buffer = malloc(18 + width * height * 4);
    memset(buffer, 0, 18);
    buffer[2] = 10;
    buffer[12] = (width >> 0) & 0xFF;
    buffer[13] = (width >> 8) & 0xFF;
    buffer[14] = (height >> 0) & 0xFF;
    buffer[15] = (height >> 8) & 0xFF;
    buffer[16] = 24;
    buffer[17] = 0;
    out = buffer + 18;
    for (y = 0; y < height; y++) {
      in = data + (height - 1 - y) * width;
      end = in + width;
      while (in < end) {
        maxrun = end - in;
        if (maxrun > 128)
          maxrun = 128;
        if (maxrun >= 2 && in[1] == in[0]) {
          for (run = 1; run < maxrun && in[run] == in[0]; run++)
            ;
          *out++ = 0x80 + (run - 1);
          *out++ = palettergb[in[0] * 3 + 2];
          *out++ = palettergb[in[0] * 3 + 1];
          *out++ = palettergb[in[0] * 3 + 0];
          in += run;
        } else {
          for (run = 1;
               run < maxrun && (run >= maxrun - 1 || in[run + 1] != in[run]);
               run++)
            ;
          *out++ = 0x00 + (run - 1);
          for (c = 0; c < run; c++) {
            *out++ = palettergb[in[0] * 3 + 2];
            *out++ = palettergb[in[0] * 3 + 1];
            *out++ = palettergb[in[0] * 3 + 0];
            in++;
          }
        }
      }
    }
  }
  writefile(filename, buffer, out - buffer);
  free(buffer);
}


x86 assembly (clang, -O0):
<WriteTGA>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
cmp    %ecx,%eax
jge    11a2 <WriteTGA+0x62>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0xff,%eax
jne    118f <WriteTGA+0x4f>
jmp    11a2 <WriteTGA+0x62>
jmp    1194 <WriteTGA+0x54>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1161 <WriteTGA+0x21>
mov    -0x2c(%rbp),%eax
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
cmp    %ecx,%eax
jge    161f <WriteTGA+0x4df>
mov    -0x14(%rbp),%eax
imul   -0x18(%rbp),%eax
imul   $0x5,%eax,%edi
add    $0x12,%edi
call   1060 <malloc@plt>
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rdi
xor    %esi,%esi
mov    $0x12,%edx
call   1040 <memset@plt>
mov    -0x38(%rbp),%rax
movb   $0xa,0x2(%rax)
mov    -0x14(%rbp),%eax
sar    $0x0,%eax
and    $0xff,%eax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %cl,0xc(%rax)
mov    -0x14(%rbp),%eax
sar    $0x8,%eax
and    $0xff,%eax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %cl,0xd(%rax)
mov    -0x18(%rbp),%eax
sar    $0x0,%eax
and    $0xff,%eax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %cl,0xe(%rax)
mov    -0x18(%rbp),%eax
sar    $0x8,%eax
and    $0xff,%eax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %cl,0xf(%rax)
mov    -0x38(%rbp),%rax
movb   $0x20,0x10(%rax)
mov    -0x38(%rbp),%rax
movb   $0x8,0x11(%rax)
mov    -0x38(%rbp),%rax
add    $0x12,%rax
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    161a <WriteTGA+0x4da>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x30(%rbp),%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x14(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x48(%rbp),%rax
jae    1607 <WriteTGA+0x4c7>
mov    -0x48(%rbp),%rax
mov    -0x40(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0x24(%rbp)
cmpl   $0x80,-0x24(%rbp)
jle    12bb <WriteTGA+0x17b>
movl   $0x80,-0x24(%rbp)
cmpl   $0x2,-0x24(%rbp)
jl     144f <WriteTGA+0x30f>
mov    -0x40(%rbp),%rax
movzbl 0x1(%rax),%eax
mov    -0x40(%rbp),%rcx
movzbl (%rcx),%ecx
cmp    %ecx,%eax
jne    144f <WriteTGA+0x30f>
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%ecx
xor    %eax,%eax
cmp    -0x24(%rbp),%ecx
mov    %al,-0x51(%rbp)
jge    130f <WriteTGA+0x1cf>
mov    -0x40(%rbp),%rax
movslq -0x28(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x40(%rbp),%rcx
movzbl (%rcx),%ecx
cmp    %ecx,%eax
sete   %al
mov    %al,-0x51(%rbp)
mov    -0x51(%rbp),%al
test   $0x1,%al
jne    131f <WriteTGA+0x1df>
jmp    1332 <WriteTGA+0x1f2>
jmp    1324 <WriteTGA+0x1e4>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    12e3 <WriteTGA+0x1a3>
mov    -0x28(%rbp),%eax
sub    $0x1,%eax
add    $0x80,%eax
mov    %al,%cl
mov    -0x50(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x50(%rbp)
mov    %cl,(%rax)
mov    -0x40(%rbp),%rax
movzbl (%rax),%eax
cmp    $0xff,%eax
jne    13af <WriteTGA+0x26f>
mov    -0x50(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x50(%rbp)
movb   $0x0,(%rax)
mov    -0x50(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x50(%rbp)
movb   $0x0,(%rax)
mov    -0x50(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x50(%rbp)
movb   $0x0,(%rax)
mov    -0x50(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x50(%rbp)
movb   $0x0,(%rax)
jmp    1439 <WriteTGA+0x2f9>
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
movzbl (%rcx),%ecx
imul   $0x3,%ecx,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x50(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x50(%rbp)
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
movzbl (%rcx),%ecx
imul   $0x3,%ecx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x50(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x50(%rbp)
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
movzbl (%rcx),%ecx
imul   $0x3,%ecx,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x50(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x50(%rbp)
mov    %cl,(%rax)
mov    -0x50(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x50(%rbp)
movb   $0xff,(%rax)
mov    -0x28(%rbp),%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
jmp    1602 <WriteTGA+0x4c2>
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%ecx
xor    %eax,%eax
cmp    -0x24(%rbp),%ecx
mov    %al,-0x52(%rbp)
jge    14a8 <WriteTGA+0x368>
mov    -0x28(%rbp),%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
mov    $0x1,%al
cmp    %edx,%ecx
mov    %al,-0x53(%rbp)
jge    14a2 <WriteTGA+0x362>
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x40(%rbp),%rcx
movslq -0x28(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
setne  %al
mov    %al,-0x53(%rbp)
mov    -0x53(%rbp),%al
mov    %al,-0x52(%rbp)
mov    -0x52(%rbp),%al
test   $0x1,%al
jne    14b8 <WriteTGA+0x378>
jmp    14cb <WriteTGA+0x38b>
jmp    14bd <WriteTGA+0x37d>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1456 <WriteTGA+0x316>
mov    -0x28(%rbp),%eax
sub    $0x1,%eax
add    $0x0,%eax
mov    %al,%cl
mov    -0x50(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x50(%rbp)
mov    %cl,(%rax)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    15fd <WriteTGA+0x4bd>
mov    -0x40(%rbp),%rax
movzbl (%rax),%eax
cmp    $0xff,%eax
jne    1559 <WriteTGA+0x419>
mov    -0x50(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x50(%rbp)
movb   $0x0,(%rax)
mov    -0x50(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x50(%rbp)
movb   $0x0,(%rax)
mov    -0x50(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x50(%rbp)
movb   $0x0,(%rax)
mov    -0x50(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x50(%rbp)
movb   $0x0,(%rax)
jmp    15e3 <WriteTGA+0x4a3>
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
movzbl (%rcx),%ecx
imul   $0x3,%ecx,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x50(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x50(%rbp)
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
movzbl (%rcx),%ecx
imul   $0x3,%ecx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x50(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x50(%rbp)
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
movzbl (%rcx),%ecx
imul   $0x3,%ecx,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x50(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x50(%rbp)
mov    %cl,(%rax)
mov    -0x50(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x50(%rbp)
movb   $0xff,(%rax)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    14ee <WriteTGA+0x3ae>
jmp    1602 <WriteTGA+0x4c2>
jmp    128b <WriteTGA+0x14b>
jmp    160c <WriteTGA+0x4cc>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1255 <WriteTGA+0x115>
jmp    19a8 <WriteTGA+0x868>
mov    -0x14(%rbp),%edi
imul   -0x18(%rbp),%edi
shl    $0x2,%edi
add    $0x12,%edi
call   1060 <malloc@plt>
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rdi
xor    %esi,%esi
mov    $0x12,%edx
call   1040 <memset@plt>
mov    -0x38(%rbp),%rax
movb   $0xa,0x2(%rax)
mov    -0x14(%rbp),%eax
sar    $0x0,%eax
and    $0xff,%eax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %cl,0xc(%rax)
mov    -0x14(%rbp),%eax
sar    $0x8,%eax
and    $0xff,%eax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %cl,0xd(%rax)
mov    -0x18(%rbp),%eax
sar    $0x0,%eax
and    $0xff,%eax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %cl,0xe(%rax)
mov    -0x18(%rbp),%eax
sar    $0x8,%eax
and    $0xff,%eax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %cl,0xf(%rax)
mov    -0x38(%rbp),%rax
movb   $0x18,0x10(%rax)
mov    -0x38(%rbp),%rax
movb   $0x0,0x11(%rax)
mov    -0x38(%rbp),%rax
add    $0x12,%rax
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    19a3 <WriteTGA+0x863>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x30(%rbp),%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x14(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x48(%rbp),%rax
jae    1990 <WriteTGA+0x850>
mov    -0x48(%rbp),%rax
mov    -0x40(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0x24(%rbp)
cmpl   $0x80,-0x24(%rbp)
jle    1726 <WriteTGA+0x5e6>
movl   $0x80,-0x24(%rbp)
cmpl   $0x2,-0x24(%rbp)
jl     1849 <WriteTGA+0x709>
mov    -0x40(%rbp),%rax
movzbl 0x1(%rax),%eax
mov    -0x40(%rbp),%rcx
movzbl (%rcx),%ecx
cmp    %ecx,%eax
jne    1849 <WriteTGA+0x709>
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%ecx
xor    %eax,%eax
cmp    -0x24(%rbp),%ecx
mov    %al,-0x54(%rbp)
jge    177a <WriteTGA+0x63a>
mov    -0x40(%rbp),%rax
movslq -0x28(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x40(%rbp),%rcx
movzbl (%rcx),%ecx
cmp    %ecx,%eax
sete   %al
mov    %al,-0x54(%rbp)
mov    -0x54(%rbp),%al
test   $0x1,%al
jne    178a <WriteTGA+0x64a>
jmp    179d <WriteTGA+0x65d>
jmp    178f <WriteTGA+0x64f>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    174e <WriteTGA+0x60e>
mov    -0x28(%rbp),%eax
sub    $0x1,%eax
add    $0x80,%eax
mov    %al,%cl
mov    -0x50(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x50(%rbp)
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
movzbl (%rcx),%ecx
imul   $0x3,%ecx,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x50(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x50(%rbp)
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
movzbl (%rcx),%ecx
imul   $0x3,%ecx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x50(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x50(%rbp)
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
movzbl (%rcx),%ecx
imul   $0x3,%ecx,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x50(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x50(%rbp)
mov    %cl,(%rax)
mov    -0x28(%rbp),%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
jmp    198b <WriteTGA+0x84b>
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%ecx
xor    %eax,%eax
cmp    -0x24(%rbp),%ecx
mov    %al,-0x55(%rbp)
jge    18a2 <WriteTGA+0x762>
mov    -0x28(%rbp),%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
mov    $0x1,%al
cmp    %edx,%ecx
mov    %al,-0x56(%rbp)
jge    189c <WriteTGA+0x75c>
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x40(%rbp),%rcx
movslq -0x28(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
setne  %al
mov    %al,-0x56(%rbp)
mov    -0x56(%rbp),%al
mov    %al,-0x55(%rbp)
mov    -0x55(%rbp),%al
test   $0x1,%al
jne    18b2 <WriteTGA+0x772>
jmp    18c5 <WriteTGA+0x785>
jmp    18b7 <WriteTGA+0x777>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1850 <WriteTGA+0x710>
mov    -0x28(%rbp),%eax
sub    $0x1,%eax
add    $0x0,%eax
mov    %al,%cl
mov    -0x50(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x50(%rbp)
mov    %cl,(%rax)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1986 <WriteTGA+0x846>
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
movzbl (%rcx),%ecx
imul   $0x3,%ecx,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x50(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x50(%rbp)
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
movzbl (%rcx),%ecx
imul   $0x3,%ecx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x50(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x50(%rbp)
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
movzbl (%rcx),%ecx
imul   $0x3,%ecx,%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x50(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x50(%rbp)
mov    %cl,(%rax)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    18e8 <WriteTGA+0x7a8>
jmp    198b <WriteTGA+0x84b>
jmp    16f6 <WriteTGA+0x5b6>
jmp    1995 <WriteTGA+0x855>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    16c0 <WriteTGA+0x580>
jmp    19a8 <WriteTGA+0x868>
mov    -0x8(%rbp),%rdi
mov    -0x38(%rbp),%rsi
mov    -0x50(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,%edx
call   1050 <writefile@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<WriteTGA>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %r8,%r13
mov    %rsi,%r15
mov    %ecx,0x4(%rsp)
mov    %ecx,%eax
mov    %edx,%r14d
imul   %edx,%eax
test   %eax,%eax
mov    %rdi,0x8(%rsp)
jle    1184 <WriteTGA+0x44>
mov    %eax,%ecx
xor    %edx,%edx
nopl   (%rax)
cmpb   $0xff,(%r15,%rdx,1)
je     1334 <WriteTGA+0x1f4>
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    1170 <WriteTGA+0x30>
lea    0x12(,%rax,4),%edi
call   1060 <malloc@plt>
mov    %rax,%rbx
mov    %rax,%rdi
xor    %esi,%esi
mov    $0x12,%edx
call   1040 <memset@plt>
movb   $0xa,0x2(%rbx)
mov    %r14d,%ecx
mov    %cl,0xc(%rbx)
mov    %ch,0xd(%rbx)
mov    0x4(%rsp),%eax
mov    %al,0xe(%rbx)
mov    %ah,0xf(%rbx)
movw   $0x18,0x10(%rbx)
mov    %rbx,0x10(%rsp)
mov    %rbx,%rdx
add    $0x12,%rdx
test   %eax,%eax
jle    151c <WriteTGA+0x3dc>
movslq %ecx,%r8
mov    %eax,%r9d
xor    %r10d,%r10d
mov    $0x80,%r11d
jmp    1200 <WriteTGA+0xc0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r10
cmp    %r9,%r10
mov    %r14d,%ecx
je     151c <WriteTGA+0x3dc>
test   %ecx,%ecx
jle    11f0 <WriteTGA+0xb0>
mov    %r10d,%eax
not    %eax
add    0x4(%rsp),%eax
imul   %ecx,%eax
movslq %eax,%rbp
add    %r15,%rbp
lea    (%r8,%rbp,1),%r12
jmp    1261 <WriteTGA+0x121>
nopl   0x0(%rax)
lea    0x7f(%rdi),%eax
mov    %al,(%rdx)
movzbl 0x0(%rbp),%eax
lea    (%rax,%rax,2),%rax
mov    0x2(%r13,%rax,1),%al
mov    %al,0x1(%rdx)
movzbl 0x0(%rbp),%eax
lea    (%rax,%rax,2),%rax
mov    0x1(%r13,%rax,1),%al
mov    %al,0x2(%rdx)
movzbl 0x0(%rbp),%eax
lea    (%rax,%rax,2),%rax
mov    0x0(%r13,%rax,1),%al
mov    %al,0x3(%rdx)
add    $0x4,%rdx
add    %rdi,%rbp
cmp    %r12,%rbp
jae    11f0 <WriteTGA+0xb0>
mov    %r12d,%eax
sub    %ebp,%eax
cmp    $0x80,%eax
cmovge %r11d,%eax
mov    $0x1,%ecx
cmp    $0x2,%eax
jl     12e0 <WriteTGA+0x1a0>
mov    0x1(%rbp),%cl
mov    %eax,%esi
cmp    0x0(%rbp),%cl
jne    12b0 <WriteTGA+0x170>
mov    $0x2,%eax
nopl   0x0(%rax,%rax,1)
mov    %rax,%rdi
cmp    %rsi,%rax
jae    1220 <WriteTGA+0xe0>
lea    0x1(%rdi),%rax
cmp    %cl,0x0(%rbp,%rdi,1)
je     1290 <WriteTGA+0x150>
jmp    1220 <WriteTGA+0xe0>
nopw   0x0(%rax,%rax,1)
add    $0xffffffff,%eax
mov    $0x1,%ecx
jmp    12c9 <WriteTGA+0x189>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rcx
cmp    %rsi,%rcx
jae    12e0 <WriteTGA+0x1a0>
cmp    %rax,%rcx
jae    12c0 <WriteTGA+0x180>
movzbl 0x1(%rbp,%rcx,1),%ebx
cmp    0x0(%rbp,%rcx,1),%bl
jne    12c0 <WriteTGA+0x180>
nopl   0x0(%rax)
lea    -0x1(%rcx),%eax
mov    %al,(%rdx)
add    $0x1,%rdx
nopl   0x0(%rax)
movzbl 0x0(%rbp),%eax
lea    (%rax,%rax,2),%rax
movzbl 0x2(%r13,%rax,1),%eax
mov    %al,(%rdx)
movzbl 0x0(%rbp),%eax
lea    (%rax,%rax,2),%rax
movzbl 0x1(%r13,%rax,1),%eax
mov    %al,0x1(%rdx)
movzbl 0x0(%rbp),%eax
lea    (%rax,%rax,2),%rax
movzbl 0x0(%r13,%rax,1),%eax
mov    %al,0x2(%rdx)
add    $0x3,%rdx
add    $0x1,%rbp
add    $0xffffffff,%ecx
jne    12f0 <WriteTGA+0x1b0>
jmp    125c <WriteTGA+0x11c>
lea    (%rax,%rax,4),%edi
add    $0x12,%edi
call   1060 <malloc@plt>
mov    %rax,%rbx
mov    %rax,%rdi
xor    %esi,%esi
mov    $0x12,%edx
call   1040 <memset@plt>
movb   $0xa,0x2(%rbx)
mov    %r14d,%ecx
mov    %cl,0xc(%rbx)
mov    %ch,0xd(%rbx)
mov    0x4(%rsp),%eax
mov    %al,0xe(%rbx)
mov    %ah,0xf(%rbx)
movw   $0x820,0x10(%rbx)
mov    %rbx,0x10(%rsp)
mov    %rbx,%rdx
add    $0x12,%rdx
test   %eax,%eax
jle    151c <WriteTGA+0x3dc>
movslq %ecx,%r8
mov    %eax,%r9d
xor    %r10d,%r10d
mov    $0x80,%r11d
jmp    13b4 <WriteTGA+0x274>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r10
cmp    %r9,%r10
mov    0x4(%rsp),%eax
mov    %r14d,%ecx
je     151c <WriteTGA+0x3dc>
test   %ecx,%ecx
jle    13a0 <WriteTGA+0x260>
mov    %ecx,%esi
mov    %eax,%ecx
mov    %r10d,%eax
not    %eax
add    %ecx,%eax
imul   %esi,%eax
cltq
add    %r15,%rax
lea    (%rax,%r8,1),%r12
jmp    140f <WriteTGA+0x2cf>
lea    (%rcx,%rcx,2),%rcx
mov    0x2(%r13,%rcx,1),%cl
mov    %cl,0x1(%rdx)
movzbl (%rax),%ecx
lea    (%rcx,%rcx,2),%rcx
mov    0x1(%r13,%rcx,1),%cl
mov    %cl,0x2(%rdx)
movzbl (%rax),%ecx
lea    (%rcx,%rcx,2),%rcx
mov    0x0(%r13,%rcx,1),%sil
mov    $0xff,%dil
mov    %sil,0x3(%rdx)
mov    %dil,0x4(%rdx)
add    $0x5,%rdx
add    %rbp,%rax
cmp    %r12,%rax
jae    13a0 <WriteTGA+0x260>
mov    %r12d,%edi
sub    %eax,%edi
cmp    $0x80,%edi
cmovge %r11d,%edi
mov    $0x1,%ecx
cmp    $0x2,%edi
jl     14b0 <WriteTGA+0x370>
mov    0x1(%rax),%sil
cmp    (%rax),%sil
jne    1480 <WriteTGA+0x340>
mov    %edi,%edi
mov    $0x2,%ecx
nopl   0x0(%rax)
mov    %rcx,%rbp
cmp    %rdi,%rcx
jae    1452 <WriteTGA+0x312>
lea    0x1(%rbp),%rcx
cmp    %sil,(%rax,%rbp,1)
je     1440 <WriteTGA+0x300>
lea    0x7f(%rbp),%ecx
mov    %cl,(%rdx)
movzbl (%rax),%ecx
cmp    $0xff,%rcx
jne    13d1 <WriteTGA+0x291>
movw   $0x0,0x1(%rdx)
xor    %esi,%esi
xor    %edi,%edi
jmp    13fb <WriteTGA+0x2bb>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    -0x1(%rdi),%esi
mov    %edi,%edi
mov    $0x1,%ecx
jmp    1499 <WriteTGA+0x359>
nopl   0x0(%rax)
add    $0x1,%rcx
cmp    %rdi,%rcx
jae    14b0 <WriteTGA+0x370>
cmp    %rsi,%rcx
jae    1490 <WriteTGA+0x350>
movzbl 0x1(%rax,%rcx,1),%ebx
cmp    (%rax,%rcx,1),%bl
jne    1490 <WriteTGA+0x350>
nopl   0x0(%rax,%rax,1)
lea    -0x1(%rcx),%esi
mov    %sil,(%rdx)
add    $0x1,%rdx
jmp    1505 <WriteTGA+0x3c5>
nopl   0x0(%rax)
lea    (%rsi,%rsi,2),%rsi
movzbl 0x2(%r13,%rsi,1),%ebx
mov    %bl,(%rdx)
movzbl (%rax),%esi
lea    (%rsi,%rsi,2),%rsi
movzbl 0x1(%r13,%rsi,1),%ebx
mov    %bl,0x1(%rdx)
movzbl (%rax),%esi
lea    (%rsi,%rsi,2),%rsi
movzbl 0x0(%r13,%rsi,1),%esi
mov    $0xff,%dil
mov    %sil,0x2(%rdx)
mov    %dil,0x3(%rdx)
add    $0x4,%rdx
add    $0x1,%rax
add    $0xffffffff,%ecx
je     140a <WriteTGA+0x2ca>
movzbl (%rax),%esi
cmp    $0xff,%rsi
jne    14c0 <WriteTGA+0x380>
movw   $0x0,(%rdx)
xor    %esi,%esi
xor    %edi,%edi
jmp    14ec <WriteTGA+0x3ac>
mov    0x8(%rsp),%rdi
mov    0x10(%rsp),%rbx
sub    %ebx,%edx
mov    %rbx,%rsi
call   1050 <writefile@plt>
mov    %rbx,%rdi
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

LLVM IR (-O2):
define void @WriteTGA(i8* %0, i8* %1, i32 %2, i32 %3, i8* nocapture %4) {
%6 = mul i32 %3, %2
%7 = icmp sgt i32 %6, 0
br i1 %7, label %8, label %179
8: ; preds = %5
%9 = zext i32 %6 to i64
br label %12
10: ; preds = %12
%11 = icmp eq i64 %17, %9
br i1 %11, label %179, label %12
12: ; preds = %8, %10
%13 = phi i64 [ 0, %8 ], [ %17, %10 ]
%14 = getelementptr inbounds i8, i8* %1, i64 %13
%15 = load i8, i8* %14
%16 = icmp eq i8 %15, -1
%17 = add nuw nsw i64 %13, 1
br i1 %16, label %18, label %10
18: ; preds = %12
%19 = mul nsw i32 %6, 5
%20 = add nsw i32 %19, 18
%21 = tail call i8* @malloc(i32 %20)
%22 = tail call i32 @memset(i8* %21, i32 0, i32 18)
%23 = getelementptr inbounds i8, i8* %21, i64 2
store i8 10, i8* %23
%24 = trunc i32 %2 to i8
%25 = getelementptr inbounds i8, i8* %21, i64 12
store i8 %24, i8* %25
%26 = lshr i32 %2, 8
%27 = trunc i32 %26 to i8
%28 = getelementptr inbounds i8, i8* %21, i64 13
store i8 %27, i8* %28
%29 = trunc i32 %3 to i8
%30 = getelementptr inbounds i8, i8* %21, i64 14
store i8 %29, i8* %30
%31 = lshr i32 %3, 8
%32 = trunc i32 %31 to i8
%33 = getelementptr inbounds i8, i8* %21, i64 15
store i8 %32, i8* %33
%34 = getelementptr inbounds i8, i8* %21, i64 16
store i8 32, i8* %34
%35 = getelementptr inbounds i8, i8* %21, i64 17
store i8 8, i8* %35
%36 = getelementptr inbounds i8, i8* %21, i64 18
%37 = icmp sgt i32 %3, 0
br i1 %37, label %38, label %324
38: ; preds = %18
%39 = sext i32 %2 to i64
%40 = zext i32 %3 to i64
%41 = icmp sgt i32 %2, 0
br label %42
42: ; preds = %38, %175
%43 = phi i64 [ 0, %38 ], [ %177, %175 ]
%44 = phi i8* [ %36, %38 ], [ %176, %175 ]
%45 = trunc i64 %43 to i32
%46 = xor i32 %45, -1
%47 = add i32 %46, %3
%48 = mul nsw i32 %47, %2
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds i8, i8* %1, i64 %49
%51 = getelementptr inbounds i8, i8* %50, i64 %39
br i1 %41, label %52, label %175
52: ; preds = %42
%53 = ptrtoint i8* %51 to i64
br label %54
54: ; preds = %52, %171
%55 = phi i8* [ %44, %52 ], [ %173, %171 ]
%56 = phi i8* [ %50, %52 ], [ %172, %171 ]
%57 = ptrtoint i8* %56 to i64
%58 = sub i64 %53, %57
%59 = trunc i64 %58 to i32
%60 = icmp slt i32 %59, 128
%61 = select i1 %60, i32 %59, i32 128
%62 = icmp sgt i32 %61, 1
br i1 %62, label %63, label %131
63: ; preds = %54
%64 = getelementptr inbounds i8, i8* %56, i64 1
%65 = load i8, i8* %64
%66 = load i8, i8* %56
%67 = icmp eq i8 %65, %66
br i1 %67, label %68, label %112
68: ; preds = %63
%69 = zext i32 %61 to i64
br label %70
70: ; preds = %68, %74
%71 = phi i64 [ 1, %68 ], [ %72, %74 ]
%72 = add nuw nsw i64 %71, 1
%73 = icmp ult i64 %72, %69
br i1 %73, label %74, label %78
74: ; preds = %70
%75 = getelementptr inbounds i8, i8* %56, i64 %72
%76 = load i8, i8* %75
%77 = icmp eq i8 %76, %65
br i1 %77, label %70, label %78
78: ; preds = %74, %70
%79 = trunc i64 %72 to i8
%80 = add i8 %79, 127
%81 = getelementptr inbounds i8, i8* %55, i64 1
store i8 %80, i8* %55
%82 = load i8, i8* %56
%83 = icmp eq i8 %82, -1
br i1 %83, label %84, label %86
84: ; preds = %78
%85 = getelementptr inbounds i8, i8* %55, i64 2
store i8 0, i8* %81
store i8 0, i8* %85
br label %104
86: ; preds = %78
%87 = zext i8 %82 to i64
%88 = mul nuw nsw i64 %87, 3
%89 = add nuw nsw i64 %88, 2
%90 = getelementptr inbounds i8, i8* %4, i64 %89
%91 = load i8, i8* %90
%92 = getelementptr inbounds i8, i8* %55, i64 2
store i8 %91, i8* %81
%93 = load i8, i8* %56
%94 = zext i8 %93 to i64
%95 = mul nuw nsw i64 %94, 3
%96 = add nuw nsw i64 %95, 1
%97 = getelementptr inbounds i8, i8* %4, i64 %96
%98 = load i8, i8* %97
store i8 %98, i8* %92
%99 = load i8, i8* %56
%100 = zext i8 %99 to i64
%101 = mul nuw nsw i64 %100, 3
%102 = getelementptr inbounds i8, i8* %4, i64 %101
%103 = load i8, i8* %102
br label %104
104: ; preds = %86, %84
%105 = phi i8 [ 0, %84 ], [ %103, %86 ]
%106 = phi i8 [ 0, %84 ], [ -1, %86 ]
%107 = getelementptr inbounds i8, i8* %55, i64 3
store i8 %105, i8* %107
%108 = getelementptr inbounds i8, i8* %55, i64 4
store i8 %106, i8* %108
%109 = getelementptr inbounds i8, i8* %55, i64 5
%110 = and i64 %72, 4294967295
%111 = getelementptr inbounds i8, i8* %56, i64 %110
br label %171
112: ; preds = %63
%113 = add nsw i32 %61, -1
%114 = zext i32 %113 to i64
%115 = zext i32 %61 to i64
br label %116
116: ; preds = %112, %126
%117 = phi i64 [ 1, %112 ], [ %119, %126 ]
%118 = icmp ult i64 %117, %114
%119 = add nuw nsw i64 %117, 1
br i1 %118, label %120, label %126
120: ; preds = %116
%121 = getelementptr inbounds i8, i8* %56, i64 %119
%122 = load i8, i8* %121
%123 = getelementptr inbounds i8, i8* %56, i64 %117
%124 = load i8, i8* %123
%125 = icmp eq i8 %122, %124
br i1 %125, label %128, label %126
126: ; preds = %116, %120
%127 = icmp ult i64 %119, %115
br i1 %127, label %116, label %128
128: ; preds = %126, %120
%129 = phi i64 [ %117, %120 ], [ %119, %126 ]
%130 = trunc i64 %129 to i32
br label %131
131: ; preds = %54, %128
%132 = phi i32 [ %130, %128 ], [ 1, %54 ]
%133 = trunc i32 %132 to i8
%134 = add i8 %133, -1
%135 = getelementptr inbounds i8, i8* %55, i64 1
store i8 %134, i8* %55
br label %136
136: ; preds = %131, %162
%137 = phi i8* [ %135, %131 ], [ %167, %162 ]
%138 = phi i8* [ %56, %131 ], [ %168, %162 ]
%139 = phi i32 [ 0, %131 ], [ %169, %162 ]
%140 = load i8, i8* %138
%141 = icmp eq i8 %140, -1
br i1 %141, label %142, label %144
142: ; preds = %136
%143 = getelementptr inbounds i8, i8* %137, i64 1
store i8 0, i8* %137
store i8 0, i8* %143
br label %162
144: ; preds = %136
%145 = zext i8 %140 to i64
%146 = mul nuw nsw i64 %145, 3
%147 = add nuw nsw i64 %146, 2
%148 = getelementptr inbounds i8, i8* %4, i64 %147
%149 = load i8, i8* %148
%150 = getelementptr inbounds i8, i8* %137, i64 1
store i8 %149, i8* %137
%151 = load i8, i8* %138
%152 = zext i8 %151 to i64
%153 = mul nuw nsw i64 %152, 3
%154 = add nuw nsw i64 %153, 1
%155 = getelementptr inbounds i8, i8* %4, i64 %154
%156 = load i8, i8* %155
store i8 %156, i8* %150
%157 = load i8, i8* %138
%158 = zext i8 %157 to i64
%159 = mul nuw nsw i64 %158, 3
%160 = getelementptr inbounds i8, i8* %4, i64 %159
%161 = load i8, i8* %160
br label %162
162: ; preds = %144, %142
%163 = phi i8 [ 0, %142 ], [ %161, %144 ]
%164 = phi i8 [ 0, %142 ], [ -1, %144 ]
%165 = getelementptr inbounds i8, i8* %137, i64 2
store i8 %163, i8* %165
%166 = getelementptr inbounds i8, i8* %137, i64 3
store i8 %164, i8* %166
%167 = getelementptr inbounds i8, i8* %137, i64 4
%168 = getelementptr inbounds i8, i8* %138, i64 1
%169 = add nuw nsw i32 %139, 1
%170 = icmp eq i32 %169, %132
br i1 %170, label %171, label %136
171: ; preds = %162, %104
%172 = phi i8* [ %111, %104 ], [ %168, %162 ]
%173 = phi i8* [ %109, %104 ], [ %167, %162 ]
%174 = icmp ult i8* %172, %51
br i1 %174, label %54, label %175
175: ; preds = %171, %42
%176 = phi i8* [ %44, %42 ], [ %173, %171 ]
%177 = add nuw nsw i64 %43, 1
%178 = icmp eq i64 %177, %40
br i1 %178, label %324, label %42
179: ; preds = %10, %5
%180 = shl nsw i32 %6, 2
%181 = add nsw i32 %180, 18
%182 = tail call i8* @malloc(i32 %181)
%183 = tail call i32 @memset(i8* %182, i32 0, i32 18)
%184 = getelementptr inbounds i8, i8* %182, i64 2
store i8 10, i8* %184
%185 = trunc i32 %2 to i8
%186 = getelementptr inbounds i8, i8* %182, i64 12
store i8 %185, i8* %186
%187 = lshr i32 %2, 8
%188 = trunc i32 %187 to i8
%189 = getelementptr inbounds i8, i8* %182, i64 13
store i8 %188, i8* %189
%190 = trunc i32 %3 to i8
%191 = getelementptr inbounds i8, i8* %182, i64 14
store i8 %190, i8* %191
%192 = lshr i32 %3, 8
%193 = trunc i32 %192 to i8
%194 = getelementptr inbounds i8, i8* %182, i64 15
store i8 %193, i8* %194
%195 = getelementptr inbounds i8, i8* %182, i64 16
store i8 24, i8* %195
%196 = getelementptr inbounds i8, i8* %182, i64 17
store i8 0, i8* %196
%197 = getelementptr inbounds i8, i8* %182, i64 18
%198 = icmp sgt i32 %3, 0
br i1 %198, label %199, label %324
199: ; preds = %179
%200 = sext i32 %2 to i64
%201 = zext i32 %3 to i64
%202 = icmp sgt i32 %2, 0
br label %203
203: ; preds = %199, %320
%204 = phi i64 [ 0, %199 ], [ %322, %320 ]
%205 = phi i8* [ %197, %199 ], [ %321, %320 ]
%206 = trunc i64 %204 to i32
%207 = xor i32 %206, -1
%208 = add i32 %207, %3
%209 = mul nsw i32 %208, %2
%210 = sext i32 %209 to i64
%211 = getelementptr inbounds i8, i8* %1, i64 %210
%212 = getelementptr inbounds i8, i8* %211, i64 %200
br i1 %202, label %213, label %320
213: ; preds = %203
%214 = ptrtoint i8* %212 to i64
br label %215
215: ; preds = %213, %316
%216 = phi i8* [ %205, %213 ], [ %318, %316 ]
%217 = phi i8* [ %211, %213 ], [ %317, %316 ]
%218 = ptrtoint i8* %217 to i64
%219 = sub i64 %214, %218
%220 = trunc i64 %219 to i32
%221 = icmp slt i32 %220, 128
%222 = select i1 %221, i32 %220, i32 128
%223 = icmp sgt i32 %222, 1
br i1 %223, label %224, label %284
224: ; preds = %215
%225 = getelementptr inbounds i8, i8* %217, i64 1
%226 = load i8, i8* %225
%227 = load i8, i8* %217
%228 = icmp eq i8 %226, %227
br i1 %228, label %229, label %265
229: ; preds = %224
%230 = zext i32 %222 to i64
br label %231
231: ; preds = %229, %235
%232 = phi i64 [ 1, %229 ], [ %233, %235 ]
%233 = add nuw nsw i64 %232, 1
%234 = icmp ult i64 %233, %230
br i1 %234, label %235, label %239
235: ; preds = %231
%236 = getelementptr inbounds i8, i8* %217, i64 %233
%237 = load i8, i8* %236
%238 = icmp eq i8 %237, %226
br i1 %238, label %231, label %239
239: ; preds = %235, %231
%240 = trunc i64 %233 to i8
%241 = add i8 %240, 127
%242 = getelementptr inbounds i8, i8* %216, i64 1
store i8 %241, i8* %216
%243 = load i8, i8* %217
%244 = zext i8 %243 to i64
%245 = mul nuw nsw i64 %244, 3
%246 = add nuw nsw i64 %245, 2
%247 = getelementptr inbounds i8, i8* %4, i64 %246
%248 = load i8, i8* %247
%249 = getelementptr inbounds i8, i8* %216, i64 2
store i8 %248, i8* %242
%250 = load i8, i8* %217
%251 = zext i8 %250 to i64
%252 = mul nuw nsw i64 %251, 3
%253 = add nuw nsw i64 %252, 1
%254 = getelementptr inbounds i8, i8* %4, i64 %253
%255 = load i8, i8* %254
%256 = getelementptr inbounds i8, i8* %216, i64 3
store i8 %255, i8* %249
%257 = load i8, i8* %217
%258 = zext i8 %257 to i64
%259 = mul nuw nsw i64 %258, 3
%260 = getelementptr inbounds i8, i8* %4, i64 %259
%261 = load i8, i8* %260
%262 = getelementptr inbounds i8, i8* %216, i64 4
store i8 %261, i8* %256
%263 = and i64 %233, 4294967295
%264 = getelementptr inbounds i8, i8* %217, i64 %263
br label %316
265: ; preds = %224
%266 = add nsw i32 %222, -1
%267 = zext i32 %266 to i64
%268 = zext i32 %222 to i64
br label %269
269: ; preds = %265, %279
%270 = phi i64 [ 1, %265 ], [ %272, %279 ]
%271 = icmp ult i64 %270, %267
%272 = add nuw nsw i64 %270, 1
br i1 %271, label %273, label %279
273: ; preds = %269
%274 = getelementptr inbounds i8, i8* %217, i64 %272
%275 = load i8, i8* %274
%276 = getelementptr inbounds i8, i8* %217, i64 %270
%277 = load i8, i8* %276
%278 = icmp eq i8 %275, %277
br i1 %278, label %281, label %279
279: ; preds = %269, %273
%280 = icmp ult i64 %272, %268
br i1 %280, label %269, label %281
281: ; preds = %279, %273
%282 = phi i64 [ %270, %273 ], [ %272, %279 ]
%283 = trunc i64 %282 to i32
br label %284
284: ; preds = %215, %281
%285 = phi i32 [ %283, %281 ], [ 1, %215 ]
%286 = trunc i32 %285 to i8
%287 = add i8 %286, -1
%288 = getelementptr inbounds i8, i8* %216, i64 1
store i8 %287, i8* %216
br label %289
289: ; preds = %284, %289
%290 = phi i8* [ %288, %284 ], [ %312, %289 ]
%291 = phi i8* [ %217, %284 ], [ %313, %289 ]
%292 = phi i32 [ 0, %284 ], [ %314, %289 ]
%293 = load i8, i8* %291
%294 = zext i8 %293 to i64
%295 = mul nuw nsw i64 %294, 3
%296 = add nuw nsw i64 %295, 2
%297 = getelementptr inbounds i8, i8* %4, i64 %296
%298 = load i8, i8* %297
%299 = getelementptr inbounds i8, i8* %290, i64 1
store i8 %298, i8* %290
%300 = load i8, i8* %291
%301 = zext i8 %300 to i64
%302 = mul nuw nsw i64 %301, 3
%303 = add nuw nsw i64 %302, 1
%304 = getelementptr inbounds i8, i8* %4, i64 %303
%305 = load i8, i8* %304
%306 = getelementptr inbounds i8, i8* %290, i64 2
store i8 %305, i8* %299
%307 = load i8, i8* %291
%308 = zext i8 %307 to i64
%309 = mul nuw nsw i64 %308, 3
%310 = getelementptr inbounds i8, i8* %4, i64 %309
%311 = load i8, i8* %310
%312 = getelementptr inbounds i8, i8* %290, i64 3
store i8 %311, i8* %306
%313 = getelementptr inbounds i8, i8* %291, i64 1
%314 = add nuw nsw i32 %292, 1
%315 = icmp eq i32 %314, %285
br i1 %315, label %316, label %289
316: ; preds = %289, %239
%317 = phi i8* [ %264, %239 ], [ %313, %289 ]
%318 = phi i8* [ %262, %239 ], [ %312, %289 ]
%319 = icmp ult i8* %317, %212
br i1 %319, label %215, label %320
320: ; preds = %316, %203
%321 = phi i8* [ %205, %203 ], [ %318, %316 ]
%322 = add nuw nsw i64 %204, 1
%323 = icmp eq i64 %322, %201
br i1 %323, label %324, label %203
324: ; preds = %320, %175, %179, %18
%325 = phi i8* [ %21, %18 ], [ %182, %179 ], [ %21, %175 ], [ %182, %320 ]
%326 = phi i8* [ %36, %18 ], [ %197, %179 ], [ %176, %175 ], [ %321, %320 ]
%327 = ptrtoint i8* %326 to i64
%328 = ptrtoint i8* %325 to i64
%329 = sub i64 %327, %328
%330 = trunc i64 %329 to i32
%331 = tail call i32 @writefile(i8* %0, i8* %325, i32 %330)
%332 = tail call i32 @free(i8* %325)
ret void
}