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

/* Forward declarations */

/* Type definitions */
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
int /*<<< orphan*/ PPM_scan_ws(unsigned char *, int /*<<< orphan*/ *);
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char const *, char *);
int fread(unsigned char *, int, int, int /*<<< orphan*/ *);
int /*<<< orphan*/ free(unsigned char *);
unsigned char getc(int /*<<< orphan*/ *);
scalar_t__ isdigit(unsigned char);
int /*<<< orphan*/ isspace(unsigned char);
unsigned char *malloc(int);
int ReadPBM4(const char *fname, unsigned char **data, int *w, int *h) {
  FILE *fp = fopen(fname, "rb");
  unsigned char buf[2] = {0};
  unsigned char c;
  int i, j;
  int imagelength;
  unsigned char *gray;
  *data = NULL;
  if (!fp)
    goto close_fail;
  fread(buf, 1, 2, fp);
  if (buf[0] != 'P' || buf[1] != '4')
    goto close_fail;
  *w = *h = 0;
  c = getc(fp);
  PPM_scan_ws(&c, fp);
  while (isdigit(c)) {
    *w = 10 * (*w) + c - '0';
    c = getc(fp);
  }
  PPM_scan_ws(&c, fp);
  while (isdigit(c)) {
    *h = 10 * (*h) + c - '0';
    c = getc(fp);
  }
  if (!isspace(c))
    goto close_fail;
  if (*w <= 0 || *h <= 0)
    goto close_fail;
  imagelength = (*w) * (*h);
  *data = malloc(imagelength * sizeof **data);
  if (*data == NULL)
    goto nospace_fail;
  gray = *data;
  for (j = 0; j < *h; ++j) {
    for (i = 0; i < *w;) {
      unsigned char *oldgray = gray;
      if (fread(buf, 1, 1, fp) != 1)
        goto corrupt_fail;
      switch (*w - i) {
      default:
        oldgray[7] = (buf[0] & 0x01) ? 0 : 255;
        ++gray;
        ++i;
      case 7:
        oldgray[6] = (buf[0] & 0x02) ? 0 : 255;
        ++gray;
        ++i;
      case 6:
        oldgray[5] = (buf[0] & 0x04) ? 0 : 255;
        ++gray;
        ++i;
      case 5:
        oldgray[4] = (buf[0] & 0x08) ? 0 : 255;
        ++gray;
        ++i;
      case 4:
        oldgray[3] = (buf[0] & 0x10) ? 0 : 255;
        ++gray;
        ++i;
      case 3:
        oldgray[2] = (buf[0] & 0x20) ? 0 : 255;
        ++gray;
        ++i;
      case 2:
        oldgray[1] = (buf[0] & 0x40) ? 0 : 255;
        ++gray;
        ++i;
      case 1:
        oldgray[0] = (buf[0] & 0x80) ? 0 : 255;
        ++gray;
        ++i;
      }
    }
  }
  fclose(fp);
  return 0;
close_fail:
  if (*data)
    free(*data);
  *data = NULL;
  if (fp)
    fclose(fp);
  return -1;
corrupt_fail:
  fclose(fp);
  return -2;
nospace_fail:
  fclose(fp);
  return -3;
}


x86 assembly (clang, -O0):
<ReadPBM4>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    -0x10(%rbp),%rdi
lea    0xe59(%rip),%rsi
call   10a0 <fopen@plt>
mov    %rax,-0x30(%rbp)
lea    -0x32(%rbp),%rdi
xor    %esi,%esi
mov    $0x2,%edx
call   1070 <memset@plt>
mov    -0x18(%rbp),%rax
movq   $0x0,(%rax)
cmpq   $0x0,-0x30(%rbp)
jne    11f7 <ReadPBM4+0x57>
jmp    159d <ReadPBM4+0x3fd>
lea    -0x32(%rbp),%rdi
mov    -0x30(%rbp),%rcx
mov    $0x1,%esi
mov    $0x2,%edx
call   1050 <fread@plt>
movzbl -0x32(%rbp),%eax
cmp    $0x50,%eax
jne    1228 <ReadPBM4+0x88>
movzbl -0x31(%rbp),%eax
cmp    $0x34,%eax
je     122d <ReadPBM4+0x8d>
jmp    159d <ReadPBM4+0x3fd>
mov    -0x28(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x20(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x30(%rbp),%rdi
call   10c0 <getc@plt>
mov    %al,-0x33(%rbp)
mov    -0x30(%rbp),%rsi
lea    -0x33(%rbp),%rdi
call   10b0 <PPM_scan_ws@plt>
movzbl -0x33(%rbp),%edi
call   1040 <isdigit@plt>
cmp    $0x0,%rax
je     1294 <ReadPBM4+0xf4>
mov    -0x20(%rbp),%rax
imul   $0xa,(%rax),%ecx
movzbl -0x33(%rbp),%eax
add    %eax,%ecx
sub    $0x30,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x30(%rbp),%rdi
call   10c0 <getc@plt>
mov    %al,-0x33(%rbp)
jmp    125a <ReadPBM4+0xba>
mov    -0x30(%rbp),%rsi
lea    -0x33(%rbp),%rdi
call   10b0 <PPM_scan_ws@plt>
movzbl -0x33(%rbp),%edi
call   1040 <isdigit@plt>
cmp    $0x0,%rax
je     12db <ReadPBM4+0x13b>
mov    -0x28(%rbp),%rax
imul   $0xa,(%rax),%ecx
movzbl -0x33(%rbp),%eax
add    %eax,%ecx
sub    $0x30,%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x30(%rbp),%rdi
call   10c0 <getc@plt>
mov    %al,-0x33(%rbp)
jmp    12a1 <ReadPBM4+0x101>
movzbl -0x33(%rbp),%edi
call   1080 <isspace@plt>
cmp    $0x0,%eax
jne    12f2 <ReadPBM4+0x152>
jmp    159d <ReadPBM4+0x3fd>
mov    -0x20(%rbp),%rax
cmpl   $0x0,(%rax)
jle    130c <ReadPBM4+0x16c>
mov    -0x28(%rbp),%rax
cmpl   $0x0,(%rax)
jg     1311 <ReadPBM4+0x171>
jmp    159d <ReadPBM4+0x3fd>
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
mov    -0x28(%rbp),%rcx
imul   (%rcx),%eax
mov    %eax,-0x40(%rbp)
movslq -0x40(%rbp),%rax
shl    $0x0,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rax
cmpq   $0x0,(%rax)
jne    134d <ReadPBM4+0x1ad>
jmp    15f7 <ReadPBM4+0x457>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x28(%rbp),%rcx
cmp    (%rcx),%eax
jge    1588 <ReadPBM4+0x3e8>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x20(%rbp),%rcx
cmp    (%rcx),%eax
jge    1575 <ReadPBM4+0x3d5>
mov    -0x48(%rbp),%rax
mov    %rax,-0x50(%rbp)
lea    -0x32(%rbp),%rdi
mov    -0x30(%rbp),%rcx
mov    $0x1,%edx
mov    %edx,%esi
call   1050 <fread@plt>
cmp    $0x1,%eax
je     13ae <ReadPBM4+0x20e>
jmp    15e2 <ReadPBM4+0x442>
mov    -0x20(%rbp),%rax
mov    (%rax),%ecx
mov    -0x38(%rbp),%eax
not    %eax
add    %ecx,%eax
mov    %eax,%ecx
mov    %rcx,-0x58(%rbp)
sub    $0x6,%eax
ja     13de <ReadPBM4+0x23e>
mov    -0x58(%rbp),%rax
lea    0xc2b(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movzbl -0x32(%rbp),%edx
and    $0x1,%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
mov    %al,%cl
mov    -0x50(%rbp),%rax
mov    %cl,0x7(%rax)
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
movzbl -0x32(%rbp),%edx
and    $0x2,%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
mov    %al,%cl
mov    -0x50(%rbp),%rax
mov    %cl,0x6(%rax)
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
movzbl -0x32(%rbp),%edx
and    $0x4,%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
mov    %al,%cl
mov    -0x50(%rbp),%rax
mov    %cl,0x5(%rax)
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
movzbl -0x32(%rbp),%edx
and    $0x8,%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
mov    %al,%cl
mov    -0x50(%rbp),%rax
mov    %cl,0x4(%rax)
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
movzbl -0x32(%rbp),%edx
and    $0x10,%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
mov    %al,%cl
mov    -0x50(%rbp),%rax
mov    %cl,0x3(%rax)
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
movzbl -0x32(%rbp),%edx
and    $0x20,%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
mov    %al,%cl
mov    -0x50(%rbp),%rax
mov    %cl,0x2(%rax)
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
movzbl -0x32(%rbp),%edx
and    $0x40,%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
mov    %al,%cl
mov    -0x50(%rbp),%rax
mov    %cl,0x1(%rax)
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
movzbl -0x32(%rbp),%edx
and    $0x80,%edx
mov    $0xff,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
mov    %al,%cl
mov    -0x50(%rbp),%rax
mov    %cl,(%rax)
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1375 <ReadPBM4+0x1d5>
jmp    157a <ReadPBM4+0x3da>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    135f <ReadPBM4+0x1bf>
mov    -0x30(%rbp),%rdi
call   1060 <fclose@plt>
movl   $0x0,-0x4(%rbp)
jmp    1607 <ReadPBM4+0x467>
mov    -0x18(%rbp),%rax
cmpq   $0x0,(%rax)
je     15b7 <ReadPBM4+0x417>
mov    -0x18(%rbp),%rax
mov    (%rax),%rdi
call   1030 <free@plt>
mov    -0x18(%rbp),%rax
movq   $0x0,(%rax)
cmpq   $0x0,-0x30(%rbp)
je     15d6 <ReadPBM4+0x436>
mov    -0x30(%rbp),%rdi
call   1060 <fclose@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    1607 <ReadPBM4+0x467>
mov    -0x30(%rbp),%rdi
call   1060 <fclose@plt>
movl   $0xfffffffe,-0x4(%rbp)
jmp    1607 <ReadPBM4+0x467>
mov    -0x30(%rbp),%rdi
call   1060 <fclose@plt>
movl   $0xfffffffd,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ReadPBM4>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rcx,%r14
mov    %rdx,%r15
mov    %rsi,%rbp
lea    0xe71(%rip),%rsi
call   1090 <fopen@plt>
movw   $0x0,0x2(%rsp)
movq   $0x0,0x0(%rbp)
test   %rax,%rax
je     125f <ReadPBM4+0xcf>
mov    %rax,%r12
lea    0x2(%rsp),%rdi
mov    $0x1,%esi
mov    $0x2,%edx
mov    %rax,%rcx
call   1050 <fread@plt>
cmpb   $0x50,0x2(%rsp)
jne    12f1 <ReadPBM4+0x161>
cmpb   $0x34,0x3(%rsp)
jne    12f1 <ReadPBM4+0x161>
movl   $0x0,(%r14)
movl   $0x0,(%r15)
mov    %r12,%rdi
call   10b0 <getc@plt>
mov    %al,0x1(%rsp)
lea    0x1(%rsp),%rdi
mov    %r12,%rsi
call   10a0 <PPM_scan_ws@plt>
movzbl 0x1(%rsp),%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
call   1040 <isdigit@plt>
test   %rax,%rax
je     1269 <ReadPBM4+0xd9>
mov    (%r15),%eax
lea    (%rax,%rax,4),%eax
movzbl 0x1(%rsp),%ecx
lea    (%rcx,%rax,2),%eax
add    $0xffffffd0,%eax
mov    %eax,(%r15)
mov    %r12,%rdi
call   10b0 <getc@plt>
mov    %al,0x1(%rsp)
movzbl %al,%edi
jmp    1230 <ReadPBM4+0xa0>
mov    $0xffffffff,%ebp
jmp    1314 <ReadPBM4+0x184>
lea    0x1(%rsp),%rdi
mov    %r12,%rsi
call   10a0 <PPM_scan_ws@plt>
movzbl 0x1(%rsp),%edi
nopl   0x0(%rax,%rax,1)
call   1040 <isdigit@plt>
test   %rax,%rax
je     12af <ReadPBM4+0x11f>
mov    (%r14),%eax
lea    (%rax,%rax,4),%eax
movzbl 0x1(%rsp),%ecx
lea    (%rcx,%rax,2),%eax
add    $0xffffffd0,%eax
mov    %eax,(%r14)
mov    %r12,%rdi
call   10b0 <getc@plt>
mov    %al,0x1(%rsp)
movzbl %al,%edi
jmp    1280 <ReadPBM4+0xf0>
movzbl 0x1(%rsp),%edi
call   1070 <isspace@plt>
test   %eax,%eax
je     12f1 <ReadPBM4+0x161>
mov    (%r15),%r13d
test   %r13d,%r13d
jle    12f1 <ReadPBM4+0x161>
mov    (%r14),%edi
test   %edi,%edi
jle    12f1 <ReadPBM4+0x161>
mov    %edi,0x4(%rsp)
imul   %r13d,%edi
call   1080 <malloc@plt>
mov    %rax,0x0(%rbp)
test   %rax,%rax
je     148f <ReadPBM4+0x2ff>
mov    %rax,%rbx
xor    %eax,%eax
mov    0x4(%rsp),%ecx
jmp    132e <ReadPBM4+0x19e>
mov    0x0(%rbp),%rdi
test   %rdi,%rdi
je     12ff <ReadPBM4+0x16f>
call   1030 <free@plt>
movq   $0x0,0x0(%rbp)
mov    $0xffffffff,%ebp
mov    %r12,%rdi
call   1060 <fclose@plt>
mov    %ebp,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
add    $0x1,%eax
xor    %ebp,%ebp
cmp    %ecx,%eax
jge    130c <ReadPBM4+0x17c>
test   %r13d,%r13d
jle    1325 <ReadPBM4+0x195>
mov    %eax,0x4(%rsp)
xor    %ebp,%ebp
nopl   0x0(%rax)
lea    0x2(%rsp),%rdi
mov    $0x1,%esi
mov    $0x1,%edx
mov    %r12,%rcx
call   1050 <fread@plt>
cmp    $0x1,%eax
jne    1485 <ReadPBM4+0x2f5>
mov    %ebp,%eax
not    %eax
add    (%r15),%eax
cmp    $0x6,%eax
ja     1389 <ReadPBM4+0x1f9>
lea    0xc8d(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movzbl 0x2(%rsp),%eax
mov    %rbx,%rcx
jmp    145c <ReadPBM4+0x2cc>
movzbl 0x2(%rsp),%eax
mov    %eax,%ecx
and    $0x1,%cl
add    $0xff,%cl
mov    %cl,0x7(%rbx)
lea    0x1(%rbx),%rcx
add    $0x1,%ebp
jmp    13df <ReadPBM4+0x24f>
movzbl 0x2(%rsp),%eax
mov    %rbx,%rcx
jmp    1447 <ReadPBM4+0x2b7>
movzbl 0x2(%rsp),%eax
mov    %rbx,%rcx
jmp    1432 <ReadPBM4+0x2a2>
movzbl 0x2(%rsp),%eax
mov    %rbx,%rcx
jmp    141d <ReadPBM4+0x28d>
movzbl 0x2(%rsp),%eax
mov    %rbx,%rcx
jmp    1408 <ReadPBM4+0x278>
movzbl 0x2(%rsp),%eax
mov    %rbx,%rcx
jmp    13f3 <ReadPBM4+0x263>
movzbl 0x2(%rsp),%eax
mov    %rbx,%rcx
mov    %eax,%edx
shr    %dl
and    $0x1,%dl
add    $0xff,%dl
mov    %dl,0x6(%rbx)
add    $0x1,%rcx
add    $0x1,%ebp
mov    %eax,%edx
shr    $0x2,%dl
and    $0x1,%dl
add    $0xff,%dl
mov    %dl,0x5(%rbx)
add    $0x1,%rcx
add    $0x1,%ebp
mov    %eax,%edx
shr    $0x3,%dl
and    $0x1,%dl
add    $0xff,%dl
mov    %dl,0x4(%rbx)
add    $0x1,%rcx
add    $0x1,%ebp
mov    %eax,%edx
shr    $0x4,%dl
and    $0x1,%dl
add    $0xff,%dl
mov    %dl,0x3(%rbx)
add    $0x1,%rcx
add    $0x1,%ebp
mov    %eax,%edx
shr    $0x5,%dl
and    $0x1,%dl
add    $0xff,%dl
mov    %dl,0x2(%rbx)
add    $0x1,%rcx
add    $0x1,%ebp
mov    %eax,%edx
shr    $0x6,%dl
and    $0x1,%dl
add    $0xff,%dl
mov    %dl,0x1(%rbx)
add    $0x1,%rcx
add    $0x1,%ebp
sar    $0x7,%al
not    %al
mov    %al,(%rbx)
mov    %rcx,%rbx
add    $0x1,%rbx
add    $0x1,%ebp
mov    (%r15),%r13d
cmp    %r13d,%ebp
jl     1340 <ReadPBM4+0x1b0>
mov    (%r14),%ecx
mov    0x4(%rsp),%eax
jmp    1325 <ReadPBM4+0x195>
mov    $0xfffffffe,%ebp
jmp    130c <ReadPBM4+0x17c>
mov    $0xfffffffd,%ebp
jmp    130c <ReadPBM4+0x17c>

LLVM IR (-O0):
@.str = [3 x i8] c"rb\00"
define i32 @ReadPBM4(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 [2 x i8]
%12 = alloca i8
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i8*
%17 = alloca i8*
store i8* %0, i8** %6
store i8** %1, i8*** %7
store i32* %2, i32** %8
store i32* %3, i32** %9
%18 = load i8*, i8** %6
%19 = call i32* @fopen(i8* %18, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0))
store i32* %19, i32** %10
%20 = bitcast [2 x i8]* %11 to i8*
%21 = load i8**, i8*** %7
store i8* null, i8** %21
%22 = load i32*, i32** %10
%23 = icmp ne i32* %22, null
br i1 %23, label %25, label %24
24: ; preds = %4
br label %263
25: ; preds = %4
%26 = getelementptr inbounds [2 x i8], [2 x i8]* %11, i64 0, i64 0
%27 = load i32*, i32** %10
%28 = call i32 @fread(i8* %26, i32 1, i32 2, i32* %27)
%29 = getelementptr inbounds [2 x i8], [2 x i8]* %11, i64 0, i64 0
%30 = load i8, i8* %29
%31 = zext i8 %30 to i32
%32 = icmp ne i32 %31, 80
br i1 %32, label %38, label %33
33: ; preds = %25
%34 = getelementptr inbounds [2 x i8], [2 x i8]* %11, i64 0, i64 1
%35 = load i8, i8* %34
%36 = zext i8 %35 to i32
%37 = icmp ne i32 %36, 52
br i1 %37, label %38, label %39
38: ; preds = %33, %25
br label %263
39: ; preds = %33
%40 = load i32*, i32** %9
store i32 0, i32* %40
%41 = load i32*, i32** %8
store i32 0, i32* %41
%42 = load i32*, i32** %10
%43 = call zeroext i8 @getc(i32* %42)
store i8 %43, i8* %12
%44 = load i32*, i32** %10
%45 = call i32 @PPM_scan_ws(i8* %12, i32* %44)
br label %46
46: ; preds = %50, %39
%47 = load i8, i8* %12
%48 = call i64 @isdigit(i8 zeroext %47)
%49 = icmp ne i64 %48, 0
br i1 %49, label %50, label %61
50: ; preds = %46
%51 = load i32*, i32** %8
%52 = load i32, i32* %51
%53 = mul nsw i32 10, %52
%54 = load i8, i8* %12
%55 = zext i8 %54 to i32
%56 = add nsw i32 %53, %55
%57 = sub nsw i32 %56, 48
%58 = load i32*, i32** %8
store i32 %57, i32* %58
%59 = load i32*, i32** %10
%60 = call zeroext i8 @getc(i32* %59)
store i8 %60, i8* %12
br label %46
61: ; preds = %46
%62 = load i32*, i32** %10
%63 = call i32 @PPM_scan_ws(i8* %12, i32* %62)
br label %64
64: ; preds = %68, %61
%65 = load i8, i8* %12
%66 = call i64 @isdigit(i8 zeroext %65)
%67 = icmp ne i64 %66, 0
br i1 %67, label %68, label %79
68: ; preds = %64
%69 = load i32*, i32** %9
%70 = load i32, i32* %69
%71 = mul nsw i32 10, %70
%72 = load i8, i8* %12
%73 = zext i8 %72 to i32
%74 = add nsw i32 %71, %73
%75 = sub nsw i32 %74, 48
%76 = load i32*, i32** %9
store i32 %75, i32* %76
%77 = load i32*, i32** %10
%78 = call zeroext i8 @getc(i32* %77)
store i8 %78, i8* %12
br label %64
79: ; preds = %64
%80 = load i8, i8* %12
%81 = call i32 @isspace(i8 zeroext %80)
%82 = icmp ne i32 %81, 0
br i1 %82, label %84, label %83
83: ; preds = %79
br label %263
84: ; preds = %79
%85 = load i32*, i32** %8
%86 = load i32, i32* %85
%87 = icmp sle i32 %86, 0
br i1 %87, label %92, label %88
88: ; preds = %84
%89 = load i32*, i32** %9
%90 = load i32, i32* %89
%91 = icmp sle i32 %90, 0
br i1 %91, label %92, label %93
92: ; preds = %88, %84
br label %263
93: ; preds = %88
%94 = load i32*, i32** %8
%95 = load i32, i32* %94
%96 = load i32*, i32** %9
%97 = load i32, i32* %96
%98 = mul nsw i32 %95, %97
store i32 %98, i32* %15
%99 = load i32, i32* %15
%100 = sext i32 %99 to i64
%101 = mul i64 %100, 1
%102 = trunc i64 %101 to i32
%103 = call i8* @malloc(i32 %102)
%104 = load i8**, i8*** %7
store i8* %103, i8** %104
%105 = load i8**, i8*** %7
%106 = load i8*, i8** %105
%107 = icmp eq i8* %106, null
br i1 %107, label %108, label %109
108: ; preds = %93
br label %282
109: ; preds = %93
%110 = load i8**, i8*** %7
%111 = load i8*, i8** %110
store i8* %111, i8** %16
store i32 0, i32* %14
br label %112
112: ; preds = %257, %109
%113 = load i32, i32* %14
%114 = load i32*, i32** %9
%115 = load i32, i32* %114
%116 = icmp slt i32 %113, %115
br i1 %116, label %117, label %260
117: ; preds = %112
store i32 0, i32* %13
br label %118
118: ; preds = %255, %117
%119 = load i32, i32* %13
%120 = load i32*, i32** %8
%121 = load i32, i32* %120
%122 = icmp slt i32 %119, %121
br i1 %122, label %123, label %256
123: ; preds = %118
%124 = load i8*, i8** %16
store i8* %124, i8** %17
%125 = getelementptr inbounds [2 x i8], [2 x i8]* %11, i64 0, i64 0
%126 = load i32*, i32** %10
%127 = call i32 @fread(i8* %125, i32 1, i32 1, i32* %126)
%128 = icmp ne i32 %127, 1
br i1 %128, label %129, label %130
129: ; preds = %123
br label %279
130: ; preds = %123
%131 = load i32*, i32** %8
%132 = load i32, i32* %131
%133 = load i32, i32* %13
%134 = sub nsw i32 %132, %133
switch i32 %134, label %135 [
i32 7, label %150
i32 6, label %165
i32 5, label %180
i32 4, label %195
i32 3, label %210
i32 2, label %225
i32 1, label %240
]
135: ; preds = %130
%136 = getelementptr inbounds [2 x i8], [2 x i8]* %11, i64 0, i64 0
%137 = load i8, i8* %136
%138 = zext i8 %137 to i32
%139 = and i32 %138, 1
%140 = icmp ne i32 %139, 0
%141 = zext i1 %140 to i64
%142 = select i1 %140, i32 0, i32 255
%143 = trunc i32 %142 to i8
%144 = load i8*, i8** %17
%145 = getelementptr inbounds i8, i8* %144, i64 7
store i8 %143, i8* %145
%146 = load i8*, i8** %16
%147 = getelementptr inbounds i8, i8* %146, i32 1
store i8* %147, i8** %16
%148 = load i32, i32* %13
%149 = add nsw i32 %148, 1
store i32 %149, i32* %13
br label %150
150: ; preds = %130, %135
%151 = getelementptr inbounds [2 x i8], [2 x i8]* %11, i64 0, i64 0
%152 = load i8, i8* %151
%153 = zext i8 %152 to i32
%154 = and i32 %153, 2
%155 = icmp ne i32 %154, 0
%156 = zext i1 %155 to i64
%157 = select i1 %155, i32 0, i32 255
%158 = trunc i32 %157 to i8
%159 = load i8*, i8** %17
%160 = getelementptr inbounds i8, i8* %159, i64 6
store i8 %158, i8* %160
%161 = load i8*, i8** %16
%162 = getelementptr inbounds i8, i8* %161, i32 1
store i8* %162, i8** %16
%163 = load i32, i32* %13
%164 = add nsw i32 %163, 1
store i32 %164, i32* %13
br label %165
165: ; preds = %130, %150
%166 = getelementptr inbounds [2 x i8], [2 x i8]* %11, i64 0, i64 0
%167 = load i8, i8* %166
%168 = zext i8 %167 to i32
%169 = and i32 %168, 4
%170 = icmp ne i32 %169, 0
%171 = zext i1 %170 to i64
%172 = select i1 %170, i32 0, i32 255
%173 = trunc i32 %172 to i8
%174 = load i8*, i8** %17
%175 = getelementptr inbounds i8, i8* %174, i64 5
store i8 %173, i8* %175
%176 = load i8*, i8** %16
%177 = getelementptr inbounds i8, i8* %176, i32 1
store i8* %177, i8** %16
%178 = load i32, i32* %13
%179 = add nsw i32 %178, 1
store i32 %179, i32* %13
br label %180
180: ; preds = %130, %165
%181 = getelementptr inbounds [2 x i8], [2 x i8]* %11, i64 0, i64 0
%182 = load i8, i8* %181
%183 = zext i8 %182 to i32
%184 = and i32 %183, 8
%185 = icmp ne i32 %184, 0
%186 = zext i1 %185 to i64
%187 = select i1 %185, i32 0, i32 255
%188 = trunc i32 %187 to i8
%189 = load i8*, i8** %17
%190 = getelementptr inbounds i8, i8* %189, i64 4
store i8 %188, i8* %190
%191 = load i8*, i8** %16
%192 = getelementptr inbounds i8, i8* %191, i32 1
store i8* %192, i8** %16
%193 = load i32, i32* %13
%194 = add nsw i32 %193, 1
store i32 %194, i32* %13
br label %195
195: ; preds = %130, %180
%196 = getelementptr inbounds [2 x i8], [2 x i8]* %11, i64 0, i64 0
%197 = load i8, i8* %196
%198 = zext i8 %197 to i32
%199 = and i32 %198, 16
%200 = icmp ne i32 %199, 0
%201 = zext i1 %200 to i64
%202 = select i1 %200, i32 0, i32 255
%203 = trunc i32 %202 to i8
%204 = load i8*, i8** %17
%205 = getelementptr inbounds i8, i8* %204, i64 3
store i8 %203, i8* %205
%206 = load i8*, i8** %16
%207 = getelementptr inbounds i8, i8* %206, i32 1
store i8* %207, i8** %16
%208 = load i32, i32* %13
%209 = add nsw i32 %208, 1
store i32 %209, i32* %13
br label %210
210: ; preds = %130, %195
%211 = getelementptr inbounds [2 x i8], [2 x i8]* %11, i64 0, i64 0
%212 = load i8, i8* %211
%213 = zext i8 %212 to i32
%214 = and i32 %213, 32
%215 = icmp ne i32 %214, 0
%216 = zext i1 %215 to i64
%217 = select i1 %215, i32 0, i32 255
%218 = trunc i32 %217 to i8
%219 = load i8*, i8** %17
%220 = getelementptr inbounds i8, i8* %219, i64 2
store i8 %218, i8* %220
%221 = load i8*, i8** %16
%222 = getelementptr inbounds i8, i8* %221, i32 1
store i8* %222, i8** %16
%223 = load i32, i32* %13
%224 = add nsw i32 %223, 1
store i32 %224, i32* %13
br label %225
225: ; preds = %130, %210
%226 = getelementptr inbounds [2 x i8], [2 x i8]* %11, i64 0, i64 0
%227 = load i8, i8* %226
%228 = zext i8 %227 to i32
%229 = and i32 %228, 64
%230 = icmp ne i32 %229, 0
%231 = zext i1 %230 to i64
%232 = select i1 %230, i32 0, i32 255
%233 = trunc i32 %232 to i8
%234 = load i8*, i8** %17
%235 = getelementptr inbounds i8, i8* %234, i64 1
store i8 %233, i8* %235
%236 = load i8*, i8** %16
%237 = getelementptr inbounds i8, i8* %236, i32 1
store i8* %237, i8** %16
%238 = load i32, i32* %13
%239 = add nsw i32 %238, 1
store i32 %239, i32* %13
br label %240
240: ; preds = %130, %225
%241 = getelementptr inbounds [2 x i8], [2 x i8]* %11, i64 0, i64 0
%242 = load i8, i8* %241
%243 = zext i8 %242 to i32
%244 = and i32 %243, 128
%245 = icmp ne i32 %244, 0
%246 = zext i1 %245 to i64
%247 = select i1 %245, i32 0, i32 255
%248 = trunc i32 %247 to i8
%249 = load i8*, i8** %17
%250 = getelementptr inbounds i8, i8* %249, i64 0
store i8 %248, i8* %250
%251 = load i8*, i8** %16
%252 = getelementptr inbounds i8, i8* %251, i32 1
store i8* %252, i8** %16
%253 = load i32, i32* %13
%254 = add nsw i32 %253, 1
store i32 %254, i32* %13
br label %255
255: ; preds = %240
br label %118
256: ; preds = %118
br label %257
257: ; preds = %256
%258 = load i32, i32* %14
%259 = add nsw i32 %258, 1
store i32 %259, i32* %14
br label %112
260: ; preds = %112
%261 = load i32*, i32** %10
%262 = call i32 @fclose(i32* %261)
store i32 0, i32* %5
br label %285
263: ; preds = %92, %83, %38, %24
%264 = load i8**, i8*** %7
%265 = load i8*, i8** %264
%266 = icmp ne i8* %265, null
br i1 %266, label %267, label %271
267: ; preds = %263
%268 = load i8**, i8*** %7
%269 = load i8*, i8** %268
%270 = call i32 @free(i8* %269)
br label %271
271: ; preds = %267, %263
%272 = load i8**, i8*** %7
store i8* null, i8** %272
%273 = load i32*, i32** %10
%274 = icmp ne i32* %273, null
br i1 %274, label %275, label %278
275: ; preds = %271
%276 = load i32*, i32** %10
%277 = call i32 @fclose(i32* %276)
br label %278
278: ; preds = %275, %271
store i32 -1, i32* %5
br label %285
279: ; preds = %129
%280 = load i32*, i32** %10
%281 = call i32 @fclose(i32* %280)
store i32 -2, i32* %5
br label %285
282: ; preds = %108
%283 = load i32*, i32** %10
%284 = call i32 @fclose(i32* %283)
store i32 -3, i32* %5
br label %285
285: ; preds = %282, %279, %278, %260
%286 = load i32, i32* %5
ret i32 %286
}

LLVM IR (-O2):
@.str = [3 x i8] c"rb\00"
define i32 @ReadPBM4(i8* nocapture %0, i8** nocapture %1, i32* nocapture %2, i32* nocapture %3) {
%5 = alloca i16
%6 = alloca i8
%7 = tail call i32* @fopen(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0))
%8 = bitcast i16* %5 to i8*
store i16 0, i16* %5
store i8* null, i8** %1
%9 = icmp eq i32* %7, null
br i1 %9, label %186, label %10
10: ; preds = %4
%11 = bitcast i16* %5 to [2 x i8]*
%12 = call i32 @fread(i8* %8, i32 1, i32 2, i32* %7)
%13 = load i8, i8* %8
%14 = icmp ne i8 %13, 80
%15 = getelementptr inbounds [2 x i8], [2 x i8]* %11, i64 0, i64 1
%16 = load i8, i8* %15
%17 = icmp ne i8 %16, 52
%18 = select i1 %14, i1 true, i1 %17
br i1 %18, label %177, label %19
19: ; preds = %10
store i32 0, i32* %3
store i32 0, i32* %2
%20 = tail call zeroext i8 @getc(i32* %7)
store i8 %20, i8* %6
%21 = call i32 @PPM_scan_ws(i8* %6, i32* %7)
%22 = load i8, i8* %6
%23 = call i64 @isdigit(i8 zeroext %22)
%24 = icmp eq i64 %23, 0
br i1 %24, label %35, label %25
25: ; preds = %19, %25
%26 = load i32, i32* %2
%27 = mul nsw i32 %26, 10
%28 = load i8, i8* %6
%29 = zext i8 %28 to i32
%30 = add i32 %27, -48
%31 = add i32 %30, %29
store i32 %31, i32* %2
%32 = call zeroext i8 @getc(i32* %7)
store i8 %32, i8* %6
%33 = call i64 @isdigit(i8 zeroext %32)
%34 = icmp eq i64 %33, 0
br i1 %34, label %35, label %25
35: ; preds = %25, %19
%36 = call i32 @PPM_scan_ws(i8* %6, i32* %7)
%37 = load i8, i8* %6
%38 = call i64 @isdigit(i8 zeroext %37)
%39 = icmp eq i64 %38, 0
br i1 %39, label %50, label %40
40: ; preds = %35, %40
%41 = load i32, i32* %3
%42 = mul nsw i32 %41, 10
%43 = load i8, i8* %6
%44 = zext i8 %43 to i32
%45 = add i32 %42, -48
%46 = add i32 %45, %44
store i32 %46, i32* %3
%47 = call zeroext i8 @getc(i32* %7)
store i8 %47, i8* %6
%48 = call i64 @isdigit(i8 zeroext %47)
%49 = icmp eq i64 %48, 0
br i1 %49, label %50, label %40
50: ; preds = %40, %35
%51 = load i8, i8* %6
%52 = call i32 @isspace(i8 zeroext %51)
%53 = icmp eq i32 %52, 0
br i1 %53, label %177, label %54
54: ; preds = %50
%55 = load i32, i32* %2
%56 = icmp slt i32 %55, 1
br i1 %56, label %177, label %57
57: ; preds = %54
%58 = load i32, i32* %3
%59 = icmp slt i32 %58, 1
br i1 %59, label %177, label %60
60: ; preds = %57
%61 = mul nsw i32 %58, %55
%62 = call i8* @malloc(i32 %61)
store i8* %62, i8** %1
%63 = icmp eq i8* %62, null
br i1 %63, label %183, label %64
64: ; preds = %60, %171
%65 = phi i32 [ %172, %171 ], [ %58, %60 ]
%66 = phi i32 [ %173, %171 ], [ %55, %60 ]
%67 = phi i8* [ %174, %171 ], [ %62, %60 ]
%68 = phi i32 [ %175, %171 ], [ 0, %60 ]
%69 = icmp sgt i32 %66, 0
br i1 %69, label %70, label %171
70: ; preds = %64, %159
%71 = phi i8* [ %165, %159 ], [ %67, %64 ]
%72 = phi i32 [ %166, %159 ], [ 0, %64 ]
%73 = call i32 @fread(i8* %8, i32 1, i32 1, i32* %7)
%74 = icmp eq i32 %73, 1
br i1 %74, label %75, label %183
75: ; preds = %70
%76 = load i32, i32* %2
%77 = sub nsw i32 %76, %72
switch i32 %77, label %92 [
i32 7, label %90
i32 6, label %88
i32 5, label %86
i32 4, label %84
i32 3, label %82
i32 2, label %80
i32 1, label %78
]
78: ; preds = %75
%79 = load i8, i8* %8
br label %159
80: ; preds = %75
%81 = load i8, i8* %8
br label %149
82: ; preds = %75
%83 = load i8, i8* %8
br label %139
84: ; preds = %75
%85 = load i8, i8* %8
br label %129
86: ; preds = %75
%87 = load i8, i8* %8
br label %119
88: ; preds = %75
%89 = load i8, i8* %8
br label %109
90: ; preds = %75
%91 = load i8, i8* %8
br label %99
92: ; preds = %75
%93 = load i8, i8* %8
%94 = and i8 %93, 1
%95 = add nsw i8 %94, -1
%96 = getelementptr inbounds i8, i8* %71, i64 7
store i8 %95, i8* %96
%97 = getelementptr inbounds i8, i8* %71, i64 1
%98 = add nsw i32 %72, 1
br label %99
99: ; preds = %90, %92
%100 = phi i8 [ %93, %92 ], [ %91, %90 ]
%101 = phi i32 [ %98, %92 ], [ %72, %90 ]
%102 = phi i8* [ %97, %92 ], [ %71, %90 ]
%103 = lshr i8 %100, 1
%104 = and i8 %103, 1
%105 = add nsw i8 %104, -1
%106 = getelementptr inbounds i8, i8* %71, i64 6
store i8 %105, i8* %106
%107 = getelementptr inbounds i8, i8* %102, i64 1
%108 = add nsw i32 %101, 1
br label %109
109: ; preds = %88, %99
%110 = phi i8 [ %100, %99 ], [ %89, %88 ]
%111 = phi i32 [ %108, %99 ], [ %72, %88 ]
%112 = phi i8* [ %107, %99 ], [ %71, %88 ]
%113 = lshr i8 %110, 2
%114 = and i8 %113, 1
%115 = add nsw i8 %114, -1
%116 = getelementptr inbounds i8, i8* %71, i64 5
store i8 %115, i8* %116
%117 = getelementptr inbounds i8, i8* %112, i64 1
%118 = add nsw i32 %111, 1
br label %119
119: ; preds = %86, %109
%120 = phi i8 [ %110, %109 ], [ %87, %86 ]
%121 = phi i32 [ %118, %109 ], [ %72, %86 ]
%122 = phi i8* [ %117, %109 ], [ %71, %86 ]
%123 = lshr i8 %120, 3
%124 = and i8 %123, 1
%125 = add nsw i8 %124, -1
%126 = getelementptr inbounds i8, i8* %71, i64 4
store i8 %125, i8* %126
%127 = getelementptr inbounds i8, i8* %122, i64 1
%128 = add nsw i32 %121, 1
br label %129
129: ; preds = %84, %119
%130 = phi i8 [ %120, %119 ], [ %85, %84 ]
%131 = phi i32 [ %128, %119 ], [ %72, %84 ]
%132 = phi i8* [ %127, %119 ], [ %71, %84 ]
%133 = lshr i8 %130, 4
%134 = and i8 %133, 1
%135 = add nsw i8 %134, -1
%136 = getelementptr inbounds i8, i8* %71, i64 3
store i8 %135, i8* %136
%137 = getelementptr inbounds i8, i8* %132, i64 1
%138 = add nsw i32 %131, 1
br label %139
139: ; preds = %82, %129
%140 = phi i8 [ %130, %129 ], [ %83, %82 ]
%141 = phi i32 [ %138, %129 ], [ %72, %82 ]
%142 = phi i8* [ %137, %129 ], [ %71, %82 ]
%143 = lshr i8 %140, 5
%144 = and i8 %143, 1
%145 = add nsw i8 %144, -1
%146 = getelementptr inbounds i8, i8* %71, i64 2
store i8 %145, i8* %146
%147 = getelementptr inbounds i8, i8* %142, i64 1
%148 = add nsw i32 %141, 1
br label %149
149: ; preds = %80, %139
%150 = phi i8 [ %140, %139 ], [ %81, %80 ]
%151 = phi i32 [ %148, %139 ], [ %72, %80 ]
%152 = phi i8* [ %147, %139 ], [ %71, %80 ]
%153 = lshr i8 %150, 6
%154 = and i8 %153, 1
%155 = add nsw i8 %154, -1
%156 = getelementptr inbounds i8, i8* %71, i64 1
store i8 %155, i8* %156
%157 = getelementptr inbounds i8, i8* %152, i64 1
%158 = add nsw i32 %151, 1
br label %159
159: ; preds = %78, %149
%160 = phi i8 [ %150, %149 ], [ %79, %78 ]
%161 = phi i32 [ %158, %149 ], [ %72, %78 ]
%162 = phi i8* [ %157, %149 ], [ %71, %78 ]
%163 = ashr i8 %160, 7
%164 = xor i8 %163, -1
store i8 %164, i8* %71
%165 = getelementptr inbounds i8, i8* %162, i64 1
%166 = add nsw i32 %161, 1
%167 = load i32, i32* %2
%168 = icmp slt i32 %166, %167
br i1 %168, label %70, label %169
169: ; preds = %159
%170 = load i32, i32* %3
br label %171
171: ; preds = %169, %64
%172 = phi i32 [ %65, %64 ], [ %170, %169 ]
%173 = phi i32 [ %66, %64 ], [ %167, %169 ]
%174 = phi i8* [ %67, %64 ], [ %165, %169 ]
%175 = add nuw nsw i32 %68, 1
%176 = icmp slt i32 %175, %172
br i1 %176, label %64, label %183
177: ; preds = %54, %57, %50, %10
%178 = load i8*, i8** %1
%179 = icmp eq i8* %178, null
br i1 %179, label %182, label %180
180: ; preds = %177
%181 = call i32 @free(i8* %178)
br label %182
182: ; preds = %177, %180
store i8* null, i8** %1
br label %183
183: ; preds = %171, %70, %60, %182
%184 = phi i32 [ -1, %182 ], [ -3, %60 ], [ -2, %70 ], [ 0, %171 ]
%185 = call i32 @fclose(i32* %7)
br label %186
186: ; preds = %183, %4
%187 = phi i32 [ -1, %4 ], [ %184, %183 ]
ret i32 %187
}