#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 */
char EOF;
int /*<<< orphan*/ SEEK_SET;
int /*<<< orphan*/ fprintf(int /*<<< orphan*/ *, char *, ...);
scalar_t__ fseek(int /*<<< orphan*/ *, int /*<<< orphan*/, int /*<<< orphan*/);
char getc(int /*<<< orphan*/ *);
int /*<<< orphan*/ printf(char *, int);
FILE *type0Totype3Converter(FILE *type0, FILE *type3) {
  int type = 0, minHashValue = 0, maxHashValue = 0, currentHashValue = 0,
      currentBinaryValue = 0, globalOffset = -1, bitsPerPosition = 0, value = 0;
  char currentHashValueFormatted[64];
  char ch, tempchar;
  while (((ch = getc(type0)) != EOF) && (ch != ',')) {
    type = type * 10 + (ch - '0');
  }
  if (type != 0) {
    printf("Incorrect input file type %d", type);
    return type3;
  }
  while (((ch = getc(type0)) != EOF) && (ch != ',')) {
    if ((ch >= '0') && (ch <= '9')) {
      minHashValue = minHashValue * 10 + (ch - '0');
    }
  }
  while (((ch = getc(type0)) != EOF) && (ch != ',') && (ch != '\n') &&
         (ch != '\r')) {
    if ((ch >= '0') && (ch <= '9')) {
      maxHashValue = maxHashValue * 10 + (ch - '0');
    }
  }
  while (((ch = getc(type0)) != EOF) && (ch != '\n') && (ch != '\r')) {
  }
  fprintf(type3, "3,%d,%d,", minHashValue, maxHashValue);
  ch = getc(type0);
  currentHashValue = 0;
  while ((ch != EOF) && (ch >= '0') && (ch <= '9')) {
    currentHashValue = 10 * currentHashValue + (ch - '0');
    ch = getc(type0);
  }
  globalOffset = currentHashValue;
  fprintf(type3, "%d\n", globalOffset);
  if (fseek(type0, 0, SEEK_SET) == 0) {
    ch = getc(type0);
    while (ch != EOF && ch != '\n' && ch != '\r') {
      ch = getc(type0);
    }
    ch = getc(type0);
    while (ch != EOF) {
      if (ch >= '0' && ch <= '9') {
        currentHashValue = currentHashValue * 10 + (ch - '0');
      } else if (ch == ' ') {
        for (value = minHashValue;
             value < currentHashValue && minHashValue >= globalOffset;
             value++) {
          fprintf(type3, "0");
        }
        fprintf(type3, "1");
        minHashValue = currentHashValue + 1;
        currentHashValue = 0;
      } else {
        currentHashValue = 0;
      }
      ch = getc(type0);
    }
    for (value = minHashValue; value < currentHashValue; value++) {
      fprintf(type3, "0");
    }
    if (currentHashValue != maxHashValue) {
      currentHashValue += 1;
      minHashValue = currentHashValue;
      fprintf(type3, "1");
      for (value = minHashValue; value <= maxHashValue; value++) {
        fprintf(type3, "0");
      }
    }
  }
  return type3;
}


x86 assembly (clang, -O0):
<type0Totype3Converter>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
movl   $0xffffffff,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x10(%rbp),%rdi
call   1060 <getc@plt>
mov    %al,-0x81(%rbp)
movsbl %al,%ecx
mov    0x2e44(%rip),%rax
movsbl (%rax),%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x83(%rbp)
je     11ca <type0Totype3Converter+0x8a>
movsbl -0x81(%rbp),%eax
cmp    $0x2c,%eax
setne  %al
mov    %al,-0x83(%rbp)
mov    -0x83(%rbp),%al
test   $0x1,%al
jne    11dd <type0Totype3Converter+0x9d>
jmp    11f5 <type0Totype3Converter+0xb5>
imul   $0xa,-0x1c(%rbp),%eax
movsbl -0x81(%rbp),%ecx
sub    $0x30,%ecx
add    %ecx,%eax
mov    %eax,-0x1c(%rbp)
jmp    118b <type0Totype3Converter+0x4b>
cmpl   $0x0,-0x1c(%rbp)
je     121b <type0Totype3Converter+0xdb>
mov    -0x1c(%rbp),%esi
lea    0xdf7(%rip),%rdi
call   1030 <printf@plt>
mov    -0x18(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    1702 <type0Totype3Converter+0x5c2>
jmp    1220 <type0Totype3Converter+0xe0>
mov    -0x10(%rbp),%rdi
call   1060 <getc@plt>
mov    %al,-0x81(%rbp)
movsbl %al,%ecx
mov    0x2daf(%rip),%rax
movsbl (%rax),%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x84(%rbp)
je     125f <type0Totype3Converter+0x11f>
movsbl -0x81(%rbp),%eax
cmp    $0x2c,%eax
setne  %al
mov    %al,-0x84(%rbp)
mov    -0x84(%rbp),%al
test   $0x1,%al
jne    1272 <type0Totype3Converter+0x132>
jmp    12aa <type0Totype3Converter+0x16a>
movsbl -0x81(%rbp),%eax
cmp    $0x30,%eax
jl     12a5 <type0Totype3Converter+0x165>
movsbl -0x81(%rbp),%eax
cmp    $0x39,%eax
jg     12a5 <type0Totype3Converter+0x165>
imul   $0xa,-0x20(%rbp),%eax
movsbl -0x81(%rbp),%ecx
sub    $0x30,%ecx
add    %ecx,%eax
mov    %eax,-0x20(%rbp)
jmp    1220 <type0Totype3Converter+0xe0>
jmp    12af <type0Totype3Converter+0x16f>
mov    -0x10(%rbp),%rdi
call   1060 <getc@plt>
mov    %al,-0x81(%rbp)
movsbl %al,%ecx
mov    0x2d20(%rip),%rax
movsbl (%rax),%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x85(%rbp)
je     131e <type0Totype3Converter+0x1de>
movsbl -0x81(%rbp),%ecx
xor    %eax,%eax
cmp    $0x2c,%ecx
mov    %al,-0x85(%rbp)
je     131e <type0Totype3Converter+0x1de>
movsbl -0x81(%rbp),%ecx
xor    %eax,%eax
cmp    $0xa,%ecx
mov    %al,-0x85(%rbp)
je     131e <type0Totype3Converter+0x1de>
movsbl -0x81(%rbp),%eax
cmp    $0xd,%eax
setne  %al
mov    %al,-0x85(%rbp)
mov    -0x85(%rbp),%al
test   $0x1,%al
jne    1331 <type0Totype3Converter+0x1f1>
jmp    1369 <type0Totype3Converter+0x229>
movsbl -0x81(%rbp),%eax
cmp    $0x30,%eax
jl     1364 <type0Totype3Converter+0x224>
movsbl -0x81(%rbp),%eax
cmp    $0x39,%eax
jg     1364 <type0Totype3Converter+0x224>
imul   $0xa,-0x24(%rbp),%eax
movsbl -0x81(%rbp),%ecx
sub    $0x30,%ecx
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
jmp    12af <type0Totype3Converter+0x16f>
jmp    136e <type0Totype3Converter+0x22e>
mov    -0x10(%rbp),%rdi
call   1060 <getc@plt>
mov    %al,-0x81(%rbp)
movsbl %al,%ecx
mov    0x2c61(%rip),%rax
movsbl (%rax),%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x86(%rbp)
je     13c5 <type0Totype3Converter+0x285>
movsbl -0x81(%rbp),%ecx
xor    %eax,%eax
cmp    $0xa,%ecx
mov    %al,-0x86(%rbp)
je     13c5 <type0Totype3Converter+0x285>
movsbl -0x81(%rbp),%eax
cmp    $0xd,%eax
setne  %al
mov    %al,-0x86(%rbp)
mov    -0x86(%rbp),%al
test   $0x1,%al
jne    13d8 <type0Totype3Converter+0x298>
jmp    13dd <type0Totype3Converter+0x29d>
jmp    136e <type0Totype3Converter+0x22e>
mov    -0x18(%rbp),%rdi
mov    -0x20(%rbp),%edx
mov    -0x24(%rbp),%ecx
lea    0xc2f(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x10(%rbp),%rdi
call   1060 <getc@plt>
mov    %al,-0x81(%rbp)
movl   $0x0,-0x28(%rbp)
movsbl -0x81(%rbp),%ecx
mov    0x2bcf(%rip),%rax
movsbl (%rax),%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x87(%rbp)
je     1457 <type0Totype3Converter+0x317>
movsbl -0x81(%rbp),%ecx
xor    %eax,%eax
cmp    $0x30,%ecx
mov    %al,-0x87(%rbp)
jl     1457 <type0Totype3Converter+0x317>
movsbl -0x81(%rbp),%eax
cmp    $0x39,%eax
setle  %al
mov    %al,-0x87(%rbp)
mov    -0x87(%rbp),%al
test   $0x1,%al
jne    146a <type0Totype3Converter+0x32a>
jmp    1491 <type0Totype3Converter+0x351>
imul   $0xa,-0x28(%rbp),%eax
movsbl -0x81(%rbp),%ecx
sub    $0x30,%ecx
add    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x10(%rbp),%rdi
call   1060 <getc@plt>
mov    %al,-0x81(%rbp)
jmp    140b <type0Totype3Converter+0x2cb>
mov    -0x28(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x18(%rbp),%rdi
mov    -0x30(%rbp),%edx
lea    0xb81(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x10(%rbp),%rdi
mov    0x2b21(%rip),%rax
mov    (%rax),%edx
xor    %esi,%esi
call   1050 <fseek@plt>
cmp    $0x0,%rax
jne    16fa <type0Totype3Converter+0x5ba>
mov    -0x10(%rbp),%rdi
call   1060 <getc@plt>
mov    %al,-0x81(%rbp)
movsbl -0x81(%rbp),%ecx
mov    0x2b01(%rip),%rax
movsbl (%rax),%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x88(%rbp)
je     1525 <type0Totype3Converter+0x3e5>
movsbl -0x81(%rbp),%ecx
xor    %eax,%eax
cmp    $0xa,%ecx
mov    %al,-0x88(%rbp)
je     1525 <type0Totype3Converter+0x3e5>
movsbl -0x81(%rbp),%eax
cmp    $0xd,%eax
setne  %al
mov    %al,-0x88(%rbp)
mov    -0x88(%rbp),%al
test   $0x1,%al
jne    1538 <type0Totype3Converter+0x3f8>
jmp    154c <type0Totype3Converter+0x40c>
mov    -0x10(%rbp),%rdi
call   1060 <getc@plt>
mov    %al,-0x81(%rbp)
jmp    14d9 <type0Totype3Converter+0x399>
mov    -0x10(%rbp),%rdi
call   1060 <getc@plt>
mov    %al,-0x81(%rbp)
movsbl -0x81(%rbp),%eax
mov    0x2a7f(%rip),%rcx
movsbl (%rcx),%ecx
cmp    %ecx,%eax
je     165f <type0Totype3Converter+0x51f>
movsbl -0x81(%rbp),%eax
cmp    $0x30,%eax
jl     15ac <type0Totype3Converter+0x46c>
movsbl -0x81(%rbp),%eax
cmp    $0x39,%eax
jg     15ac <type0Totype3Converter+0x46c>
imul   $0xa,-0x28(%rbp),%eax
movsbl -0x81(%rbp),%ecx
sub    $0x30,%ecx
add    %ecx,%eax
mov    %eax,-0x28(%rbp)
jmp    164b <type0Totype3Converter+0x50b>
movsbl -0x81(%rbp),%eax
cmp    $0x20,%eax
jne    163f <type0Totype3Converter+0x4ff>
mov    -0x20(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%ecx
xor    %eax,%eax
cmp    -0x28(%rbp),%ecx
mov    %al,-0x89(%rbp)
jge    15e5 <type0Totype3Converter+0x4a5>
mov    -0x20(%rbp),%eax
cmp    -0x30(%rbp),%eax
setge  %al
mov    %al,-0x89(%rbp)
mov    -0x89(%rbp),%al
test   $0x1,%al
jne    15f8 <type0Totype3Converter+0x4b8>
jmp    1618 <type0Totype3Converter+0x4d8>
mov    -0x18(%rbp),%rdi
lea    0xa27(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    15c2 <type0Totype3Converter+0x482>
mov    -0x18(%rbp),%rdi
lea    0xa09(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
movl   $0x0,-0x28(%rbp)
jmp    1646 <type0Totype3Converter+0x506>
movl   $0x0,-0x28(%rbp)
jmp    164b <type0Totype3Converter+0x50b>
mov    -0x10(%rbp),%rdi
call   1060 <getc@plt>
mov    %al,-0x81(%rbp)
jmp    155b <type0Totype3Converter+0x41b>
mov    -0x20(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1691 <type0Totype3Converter+0x551>
mov    -0x18(%rbp),%rdi
lea    0x9ae(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1665 <type0Totype3Converter+0x525>
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
je     16f5 <type0Totype3Converter+0x5b5>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%rdi
lea    0x975(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x20(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     16f0 <type0Totype3Converter+0x5b0>
mov    -0x18(%rbp),%rdi
lea    0x94f(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    16c4 <type0Totype3Converter+0x584>
jmp    16f5 <type0Totype3Converter+0x5b5>
jmp    16fa <type0Totype3Converter+0x5ba>
mov    -0x18(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<type0Totype3Converter>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rsi,%r14
mov    %rdi,%r12
call   1070 <getc@plt>
mov    0x2e7b(%rip),%r13
cmp    $0x2c,%al
je     11b5 <type0Totype3Converter+0x65>
cmp    0x0(%r13),%al
je     11b5 <type0Totype3Converter+0x65>
xor    %ebx,%ebx
nopl   0x0(%rax)
movsbl %al,%eax
lea    (%rbx,%rbx,4),%ecx
lea    (%rax,%rcx,2),%ebx
add    $0xffffffd0,%ebx
mov    %r12,%rdi
call   1070 <getc@plt>
cmp    $0x2c,%al
je     119e <type0Totype3Converter+0x4e>
cmp    0x0(%r13),%al
jne    1180 <type0Totype3Converter+0x30>
test   %ebx,%ebx
je     11b5 <type0Totype3Converter+0x65>
lea    0xe57(%rip),%rdi
mov    %ebx,%esi
call   1030 <printf@plt>
jmp    13c3 <type0Totype3Converter+0x273>
mov    %r12,%rdi
call   1070 <getc@plt>
xor    %r15d,%r15d
mov    $0x0,%ebp
cmp    $0x2c,%al
je     1207 <type0Totype3Converter+0xb7>
mov    $0x0,%ebp
cmp    0x0(%r13),%al
je     1207 <type0Totype3Converter+0xb7>
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
mov    %ebp,%ecx
movsbl %al,%eax
lea    -0x30(%rax),%edx
cmp    $0xa,%dl
lea    (%rcx,%rcx,4),%edx
lea    -0x30(%rax,%rdx,2),%ebp
cmovae %ecx,%ebp
mov    %r12,%rdi
call   1070 <getc@plt>
cmp    $0x2c,%al
je     1207 <type0Totype3Converter+0xb7>
cmp    0x0(%r13),%al
jne    11e0 <type0Totype3Converter+0x90>
mov    %r12,%rdi
call   1070 <getc@plt>
cmp    0x0(%r13),%al
je     1264 <type0Totype3Converter+0x114>
xor    %ecx,%ecx
movabs $0x100000002400,%rbx
jmp    1254 <type0Totype3Converter+0x104>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsbl %al,%edx
add    $0xd0,%al
cmp    $0xa,%al
lea    (%rcx,%rcx,4),%eax
lea    -0x30(%rdx,%rax,2),%r15d
cmovae %ecx,%r15d
mov    %r12,%rdi
call   1070 <getc@plt>
mov    %r15d,%ecx
cmp    0x0(%r13),%al
je     1264 <type0Totype3Converter+0x114>
cmp    $0x2c,%al
ja     1230 <type0Totype3Converter+0xe0>
movzbl %al,%edx
bt     %rdx,%rbx
jae    1230 <type0Totype3Converter+0xe0>
mov    %ecx,%r15d
mov    %r14,(%rsp)
nopl   0x0(%rax,%rax,1)
mov    %r12,%rdi
call   1070 <getc@plt>
cmp    0x0(%r13),%al
je     1286 <type0Totype3Converter+0x136>
cmp    $0xd,%al
je     1286 <type0Totype3Converter+0x136>
cmp    $0xa,%al
jne    1270 <type0Totype3Converter+0x120>
lea    0xd90(%rip),%rsi
xor    %r13d,%r13d
mov    (%rsp),%rdi
mov    %ebp,%edx
mov    %r15d,%ecx
xor    %eax,%eax
call   1050 <fprintf@plt>
mov    %r12,%rdi
call   1070 <getc@plt>
lea    -0x30(%rax),%ecx
cmp    $0x9,%cl
ja     12eb <type0Totype3Converter+0x19b>
mov    0x2d31(%rip),%rcx
cmp    (%rcx),%al
je     12eb <type0Totype3Converter+0x19b>
xor    %r13d,%r13d
xchg   %ax,%ax
movzbl %al,%eax
lea    0x0(%r13,%r13,4),%ecx
lea    (%rax,%rcx,2),%r13d
add    $0xffffffd0,%r13d
mov    %r12,%rdi
call   1070 <getc@plt>
lea    -0x30(%rax),%ecx
cmp    $0x9,%cl
ja     12eb <type0Totype3Converter+0x19b>
mov    0x2d01(%rip),%rcx
cmp    (%rcx),%al
jne    12c0 <type0Totype3Converter+0x170>
lea    0xd34(%rip),%rsi
mov    (%rsp),%r14
mov    %r14,%rdi
mov    %r13d,%edx
xor    %eax,%eax
call   1050 <fprintf@plt>
mov    0x2cce(%rip),%rax
mov    (%rax),%edx
mov    %r12,%rdi
xor    %esi,%esi
call   1060 <fseek@plt>
test   %rax,%rax
jne    13c3 <type0Totype3Converter+0x273>
jmp    1338 <type0Totype3Converter+0x1e8>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmp    $0xa,%al
je     134b <type0Totype3Converter+0x1fb>
cmp    $0xd,%al
je     134b <type0Totype3Converter+0x1fb>
mov    %r12,%rdi
call   1070 <getc@plt>
mov    0x2ca1(%rip),%rcx
cmp    (%rcx),%al
jne    1330 <type0Totype3Converter+0x1e0>
mov    %r12,%rdi
call   1070 <getc@plt>
mov    0x2c8e(%rip),%rcx
cmp    (%rcx),%al
jne    13d5 <type0Totype3Converter+0x285>
mov    %r13d,%r14d
mov    %r14d,%r12d
cmp    %r14d,%ebp
mov    (%rsp),%r14
jge    1392 <type0Totype3Converter+0x242>
mov    %r12d,%ebx
sub    %ebp,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    $0x30,%edi
mov    %r14,%rsi
call   1040 <fputc@plt>
add    $0xffffffff,%ebx
jne    1380 <type0Totype3Converter+0x230>
cmp    %r15d,%r12d
je     13c3 <type0Totype3Converter+0x273>
mov    %r12d,%ebp
mov    $0x31,%edi
mov    %r14,%rsi
call   1040 <fputc@plt>
cmp    %r15d,%r12d
jge    13c3 <type0Totype3Converter+0x273>
sub    %ebp,%r15d
nop
mov    $0x30,%edi
mov    %r14,%rsi
call   1040 <fputc@plt>
add    $0xffffffff,%r15d
jne    13b0 <type0Totype3Converter+0x260>
mov    %r14,%rax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r13d,%ebx
jmp    1408 <type0Totype3Converter+0x2b8>
nopw   0x0(%rax,%rax,1)
movzbl %al,%eax
lea    (%rbx,%rbx,4),%ecx
lea    (%rax,%rcx,2),%r14d
add    $0xffffffd0,%r14d
mov    %r12,%rdi
call   1070 <getc@plt>
mov    %r14d,%ebx
mov    0x2be8(%rip),%rcx
cmp    (%rcx),%al
je     1361 <type0Totype3Converter+0x211>
lea    -0x30(%rax),%ecx
cmp    $0x9,%cl
jbe    13e0 <type0Totype3Converter+0x290>
xor    %r14d,%r14d
cmp    $0x20,%al
jne    13ee <type0Totype3Converter+0x29e>
cmp    %ebx,%ebp
mov    (%rsp),%r14
jge    1444 <type0Totype3Converter+0x2f4>
cmp    %r13d,%ebp
jl     1444 <type0Totype3Converter+0x2f4>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    $0x30,%edi
mov    %r14,%rsi
call   1040 <fputc@plt>
add    $0x1,%ebp
cmp    %ebx,%ebp
jl     1430 <type0Totype3Converter+0x2e0>
mov    $0x31,%edi
mov    %r14,%rsi
call   1040 <fputc@plt>
add    $0x1,%ebx
mov    %ebx,%ebp
xor    %r14d,%r14d
jmp    13ee <type0Totype3Converter+0x29e>

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

LLVM IR (-O2):
@EOF = global i8 0
@.str = [29 x i8] c"Incorrect input file type %d\00"
@.str.1 = [9 x i8] c"3,%d,%d,\00"
@.str.2 = [4 x i8] c"%d\0A\00"
@SEEK_SET = global i32 0
define i32* @type0Totype3Converter(i32* nocapture %0, i32* returned %1) {
%3 = tail call signext i8 @getc(i32* %0)
%4 = load i8, i8* @EOF
%5 = icmp ne i8 %3, %4
%6 = icmp ne i8 %3, 44
%7 = and i1 %6, %5
br i1 %7, label %8, label %22
8: ; preds = %2, %8
%9 = phi i8 [ %15, %8 ], [ %3, %2 ]
%10 = phi i32 [ %14, %8 ], [ 0, %2 ]
%11 = sext i8 %9 to i32
%12 = mul nsw i32 %10, 10
%13 = add i32 %12, -48
%14 = add i32 %13, %11
%15 = tail call signext i8 @getc(i32* %0)
%16 = load i8, i8* @EOF
%17 = icmp ne i8 %15, %16
%18 = icmp ne i8 %15, 44
%19 = and i1 %18, %17
br i1 %19, label %8, label %20
20: ; preds = %8
%21 = icmp eq i32 %14, 0
br i1 %21, label %22, label %28
22: ; preds = %2, %20
%23 = tail call signext i8 @getc(i32* %0)
%24 = load i8, i8* @EOF
%25 = icmp ne i8 %23, %24
%26 = icmp ne i8 %23, 44
%27 = and i1 %26, %25
br i1 %27, label %36, label %30
28: ; preds = %20
%29 = tail call i32 @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str, i64 0, i64 0), i32 %14)
br label %167
30: ; preds = %36, %22
%31 = phi i32 [ 0, %22 ], [ %45, %36 ]
%32 = tail call signext i8 @getc(i32* %0)
%33 = load i8, i8* @EOF
%34 = freeze i8 %33
%35 = icmp eq i8 %32, %34
br i1 %35, label %54, label %51
36: ; preds = %22, %36
%37 = phi i8 [ %46, %36 ], [ %23, %22 ]
%38 = phi i32 [ %45, %36 ], [ 0, %22 ]
%39 = sext i8 %37 to i32
%40 = add i8 %37, -48
%41 = icmp ult i8 %40, 10
%42 = mul nsw i32 %38, 10
%43 = add i32 %42, -48
%44 = add i32 %43, %39
%45 = select i1 %41, i32 %44, i32 %38
%46 = tail call signext i8 @getc(i32* %0)
%47 = load i8, i8* @EOF
%48 = icmp ne i8 %46, %47
%49 = icmp ne i8 %46, 44
%50 = and i1 %49, %48
br i1 %50, label %36, label %30
51: ; preds = %30, %56
%52 = phi i8 [ %64, %56 ], [ %32, %30 ]
%53 = phi i32 [ %63, %56 ], [ 0, %30 ]
switch i8 %52, label %56 [
i8 44, label %54
i8 13, label %54
i8 10, label %54
]
54: ; preds = %51, %51, %51, %56, %30
%55 = phi i32 [ 0, %30 ], [ %63, %56 ], [ %53, %51 ], [ %53, %51 ], [ %53, %51 ]
br label %68
56: ; preds = %51
%57 = sext i8 %52 to i32
%58 = add i8 %52, -48
%59 = icmp ult i8 %58, 10
%60 = mul nsw i32 %53, 10
%61 = add i32 %60, -48
%62 = add i32 %61, %57
%63 = select i1 %59, i32 %62, i32 %53
%64 = tail call signext i8 @getc(i32* %0)
%65 = load i8, i8* @EOF
%66 = freeze i8 %65
%67 = icmp eq i8 %64, %66
br i1 %67, label %54, label %51
68: ; preds = %54, %73
%69 = tail call signext i8 @getc(i32* %0)
%70 = load i8, i8* @EOF
%71 = freeze i8 %70
%72 = icmp eq i8 %69, %71
br i1 %72, label %74, label %73
73: ; preds = %68
switch i8 %69, label %68 [
i8 13, label %74
i8 10, label %74
]
74: ; preds = %73, %73, %68
%75 = tail call i32 (i32*, i8*, ...) @fprintf(i32* %1, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.1, i64 0, i64 0), i32 %31, i32 %55)
%76 = tail call signext i8 @getc(i32* %0)
%77 = load i8, i8* @EOF
%78 = icmp ne i8 %76, %77
%79 = add i8 %76, -48
%80 = icmp ult i8 %79, 10
%81 = and i1 %80, %78
br i1 %81, label %82, label %95
82: ; preds = %74, %82
%83 = phi i8 [ %89, %82 ], [ %76, %74 ]
%84 = phi i32 [ %88, %82 ], [ 0, %74 ]
%85 = zext i8 %83 to i32
%86 = mul nsw i32 %84, 10
%87 = add i32 %86, -48
%88 = add i32 %87, %85
%89 = tail call signext i8 @getc(i32* %0)
%90 = load i8, i8* @EOF
%91 = icmp ne i8 %89, %90
%92 = add i8 %89, -48
%93 = icmp ult i8 %92, 10
%94 = and i1 %93, %91
br i1 %94, label %82, label %95
95: ; preds = %82, %74
%96 = phi i32 [ 0, %74 ], [ %88, %82 ]
%97 = tail call i32 (i32*, i8*, ...) @fprintf(i32* %1, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i32 %96)
%98 = load i32, i32* @SEEK_SET
%99 = tail call i64 @fseek(i32* %0, i32 0, i32 %98)
%100 = icmp eq i64 %99, 0
br i1 %100, label %101, label %167
101: ; preds = %95
%102 = tail call signext i8 @getc(i32* %0)
%103 = load i8, i8* @EOF
%104 = freeze i8 %103
%105 = icmp eq i8 %102, %104
br i1 %105, label %113, label %106
106: ; preds = %101, %108
%107 = phi i8 [ %109, %108 ], [ %102, %101 ]
switch i8 %107, label %108 [
i8 13, label %113
i8 10, label %113
]
108: ; preds = %106
%109 = tail call signext i8 @getc(i32* %0)
%110 = load i8, i8* @EOF
%111 = freeze i8 %110
%112 = icmp eq i8 %109, %111
br i1 %112, label %113, label %106
113: ; preds = %108, %106, %106, %101
%114 = tail call signext i8 @getc(i32* %0)
%115 = load i8, i8* @EOF
%116 = icmp eq i8 %114, %115
br i1 %116, label %117, label %121
117: ; preds = %146, %113
%118 = phi i32 [ %96, %113 ], [ %147, %146 ]
%119 = phi i32 [ %31, %113 ], [ %148, %146 ]
%120 = icmp slt i32 %119, %118
br i1 %120, label %152, label %157
121: ; preds = %113, %146
%122 = phi i8 [ %149, %146 ], [ %114, %113 ]
%123 = phi i32 [ %148, %146 ], [ %31, %113 ]
%124 = phi i32 [ %147, %146 ], [ %96, %113 ]
%125 = add i8 %122, -48
%126 = icmp ult i8 %125, 10
br i1 %126, label %127, label %132
127: ; preds = %121
%128 = zext i8 %122 to i32
%129 = mul nsw i32 %124, 10
%130 = add i32 %129, -48
%131 = add i32 %130, %128
br label %146
132: ; preds = %121
%133 = icmp eq i8 %122, 32
br i1 %133, label %134, label %146
134: ; preds = %132
%135 = icmp sge i32 %123, %96
%136 = icmp slt i32 %123, %124
%137 = and i1 %136, %135
br i1 %137, label %138, label %143
138: ; preds = %134, %138
%139 = phi i32 [ %141, %138 ], [ %123, %134 ]
%140 = tail call i32 @fputc(i32 48, i32* %1)
%141 = add nsw i32 %139, 1
%142 = icmp slt i32 %141, %124
br i1 %142, label %138, label %143
143: ; preds = %138, %134
%144 = tail call i32 @fputc(i32 49, i32* %1)
%145 = add nsw i32 %124, 1
br label %146
146: ; preds = %132, %143, %127
%147 = phi i32 [ %131, %127 ], [ 0, %143 ], [ 0, %132 ]
%148 = phi i32 [ %123, %127 ], [ %145, %143 ], [ %123, %132 ]
%149 = tail call signext i8 @getc(i32* %0)
%150 = load i8, i8* @EOF
%151 = icmp eq i8 %149, %150
br i1 %151, label %117, label %121
152: ; preds = %117, %152
%153 = phi i32 [ %155, %152 ], [ %119, %117 ]
%154 = tail call i32 @fputc(i32 48, i32* %1)
%155 = add i32 %153, 1
%156 = icmp eq i32 %155, %118
br i1 %156, label %157, label %152
157: ; preds = %152, %117
%158 = icmp eq i32 %118, %55
br i1 %158, label %167, label %159
159: ; preds = %157
%160 = tail call i32 @fputc(i32 49, i32* %1)
%161 = icmp slt i32 %118, %55
br i1 %161, label %162, label %167
162: ; preds = %159, %162
%163 = phi i32 [ %164, %162 ], [ %118, %159 ]
%164 = add i32 %163, 1
%165 = tail call i32 @fputc(i32 48, i32* %1)
%166 = icmp eq i32 %164, %55
br i1 %166, label %167, label %162
167: ; preds = %162, %159, %95, %157, %28
ret i32* %1
}