#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*/ _core_status();
int /*<<< orphan*/ _outbyte(char);
int /*<<< orphan*/ get_address_data(char *, unsigned int *, unsigned int *);
int /*<<< orphan*/ get_hex(char *, int, unsigned int *, unsigned int *);
int /*<<< orphan*/ load_run(int, unsigned int);
int /*<<< orphan*/ print_help();
int /*<<< orphan*/ print_spaces(int);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ printm(unsigned int);
void parse(char *buf) {
  unsigned int found, address, data, i, length, bytes, rdata;
  int file_size;
  char byte;
  unsigned int lcount;
  char bad_command_msg[] = "Invalid command";
  if (!buf[1])
    return;
  if (buf[1] == '\r') {
    switch (buf[0]) {
    case 'h':
      print_help();
      break;
    case 'l':
      load_run(1, 0);
      break;
    case 's':
      _core_status();
      print_spaces(16);
      printf("\n");
      break;
    default:
      printf("%s\n", bad_command_msg);
      break;
    }
    return;
  } else if (buf[1] != 0x20) {
    printf("%s\n", bad_command_msg);
    return;
  }
  switch (buf[0]) {
  case 'd':
    if (get_address_data(buf, &address, &bytes)) {
      for (i = address; i < address + bytes; i += 4) {
        printm(i);
      }
    }
    break;
  case 'j':
    if (get_hex(buf, 2, &address, &length)) {
      load_run(0, address);
    }
    break;
  case 'p':
    if (get_hex(buf, 2, &address, &length)) {
      length = 0;
      lcount = 0;
      byte = *(char *)address++;
      while (byte < 128 && length < 0x1000) {
        if (byte != 0)
          _outbyte(byte);
        if (byte == '\r')
          printf("\n");
        lcount = 0;
        if (lcount == 79)
          printf("\n");
        lcount = 0;
        byte = *(char *)address++;
        lcount++;
        length++;
      }
    }
    break;
  case 'r':
    if (get_hex(buf, 2, &address, &length)) {
      printm(address);
    }
    break;
  case 'b':
    if (get_hex(buf, 2, &address, &length)) {
      load_run(5, address);
    }
    break;
  case 'w':
    if (get_address_data(buf, &address, &data)) {
      *(unsigned int *)address = data;
      printm(address);
    }
    break;
  default:
    printf("%s\n", bad_command_msg);
    break;
  }
}


x86 assembly (clang, -O0):
<parse>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    0xebd(%rip),%rax
mov    %rax,-0x40(%rbp)
mov    0xeba(%rip),%rax
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
cmpb   $0x0,0x1(%rax)
jne    11c5 <parse+0x35>
jmp    14da <parse+0x34a>
mov    -0x8(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0xd,%eax
jne    1268 <parse+0xd8>
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
mov    %eax,-0x44(%rbp)
sub    $0x68,%eax
je     1210 <parse+0x80>
jmp    11ee <parse+0x5e>
mov    -0x44(%rbp),%eax
sub    $0x6c,%eax
je     121c <parse+0x8c>
jmp    11ff <parse+0x6f>
mov    -0x44(%rbp),%eax
sub    $0x73,%eax
je     122d <parse+0x9d>
jmp    1251 <parse+0xc1>
mov    $0x0,%al
call   10b0 <print_help@plt>
jmp    1263 <parse+0xd3>
mov    $0x1,%edi
xor    %esi,%esi
call   1090 <load_run@plt>
jmp    1263 <parse+0xd3>
mov    $0x0,%al
call   1060 <_core_status@plt>
mov    $0x10,%edi
call   1050 <print_spaces@plt>
lea    0xe2d(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
jmp    1263 <parse+0xd3>
lea    -0x40(%rbp),%rsi
lea    0xe14(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
jmp    14da <parse+0x34a>
mov    -0x8(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x20,%eax
je     1290 <parse+0x100>
lea    -0x40(%rbp),%rsi
lea    0xdec(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
jmp    14da <parse+0x34a>
jmp    1295 <parse+0x105>
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
add    $0xffffff9e,%eax
mov    %eax,%ecx
mov    %rcx,-0x50(%rbp)
sub    $0x15,%eax
ja     14c8 <parse+0x338>
mov    -0x50(%rbp),%rax
lea    0xd47(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x8(%rbp),%rdi
lea    -0x10(%rbp),%rsi
lea    -0x20(%rbp),%rdx
call   10a0 <get_address_data@plt>
cmp    $0x0,%eax
je     130e <parse+0x17e>
mov    -0x10(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x10(%rbp),%ecx
add    -0x20(%rbp),%ecx
cmp    %ecx,%eax
jae    1309 <parse+0x179>
mov    -0x18(%rbp),%edi
call   1030 <printm@plt>
mov    -0x18(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x18(%rbp)
jmp    12e2 <parse+0x152>
jmp    130e <parse+0x17e>
jmp    14da <parse+0x34a>
mov    -0x8(%rbp),%rdi
mov    $0x2,%esi
lea    -0x10(%rbp),%rdx
lea    -0x1c(%rbp),%rcx
call   1080 <get_hex@plt>
cmp    $0x0,%eax
je     133c <parse+0x1ac>
mov    -0x10(%rbp),%esi
xor    %edi,%edi
call   1090 <load_run@plt>
jmp    14da <parse+0x34a>
mov    -0x8(%rbp),%rdi
mov    $0x2,%esi
lea    -0x10(%rbp),%rdx
lea    -0x1c(%rbp),%rcx
call   1080 <get_hex@plt>
cmp    $0x0,%eax
je     1437 <parse+0x2a7>
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x10(%rbp)
mov    %eax,%eax
mov    (%rax),%al
mov    %al,-0x29(%rbp)
movsbl -0x29(%rbp),%ecx
xor    %eax,%eax
cmp    $0x80,%ecx
mov    %al,-0x51(%rbp)
jge    13a2 <parse+0x212>
cmpl   $0x1000,-0x1c(%rbp)
setb   %al
mov    %al,-0x51(%rbp)
mov    -0x51(%rbp),%al
test   $0x1,%al
jne    13b2 <parse+0x222>
jmp    1432 <parse+0x2a2>
movsbl -0x29(%rbp),%eax
cmp    $0x0,%eax
je     13c8 <parse+0x238>
movsbl -0x29(%rbp),%edi
call   1040 <_outbyte@plt>
movsbl -0x29(%rbp),%eax
cmp    $0xd,%eax
jne    13e3 <parse+0x253>
lea    0xc96(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
movl   $0x0,-0x30(%rbp)
cmpl   $0x4f,-0x30(%rbp)
jne    1402 <parse+0x272>
lea    0xc77(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
movl   $0x0,-0x30(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x10(%rbp)
mov    %eax,%eax
mov    (%rax),%al
mov    %al,-0x29(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1380 <parse+0x1f0>
jmp    1437 <parse+0x2a7>
jmp    14da <parse+0x34a>
mov    -0x8(%rbp),%rdi
mov    $0x2,%esi
lea    -0x10(%rbp),%rdx
lea    -0x1c(%rbp),%rcx
call   1080 <get_hex@plt>
cmp    $0x0,%eax
je     1463 <parse+0x2d3>
mov    -0x10(%rbp),%edi
call   1030 <printm@plt>
jmp    14da <parse+0x34a>
mov    -0x8(%rbp),%rdi
mov    $0x2,%esi
lea    -0x10(%rbp),%rdx
lea    -0x1c(%rbp),%rcx
call   1080 <get_hex@plt>
cmp    $0x0,%eax
je     1494 <parse+0x304>
mov    -0x10(%rbp),%esi
mov    $0x5,%edi
call   1090 <load_run@plt>
jmp    14da <parse+0x34a>
mov    -0x8(%rbp),%rdi
lea    -0x10(%rbp),%rsi
lea    -0x14(%rbp),%rdx
call   10a0 <get_address_data@plt>
cmp    $0x0,%eax
je     14c3 <parse+0x333>
mov    -0x14(%rbp),%ecx
mov    -0x10(%rbp),%eax
mov    %ecx,(%rax)
mov    -0x10(%rbp),%edi
call   1030 <printm@plt>
jmp    14da <parse+0x34a>
lea    -0x40(%rbp),%rsi
lea    0xb9d(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<parse>:
push   %rbx
sub    $0x20,%rsp
movaps 0xeb4(%rip),%xmm0
movaps %xmm0,0x10(%rsp)
mov    0x1(%rdi),%al
test   %al,%al
je     122f <parse+0x8f>
cmp    $0x20,%al
je     11e2 <parse+0x42>
cmp    $0xd,%al
jne    1225 <parse+0x85>
movsbl (%rdi),%eax
cmp    $0x73,%eax
je     1235 <parse+0x95>
cmp    $0x6c,%eax
je     1255 <parse+0xb5>
cmp    $0x68,%eax
jne    1225 <parse+0x85>
xor    %eax,%eax
add    $0x20,%rsp
pop    %rbx
jmp    10c0 <print_help@plt>
movsbl (%rdi),%eax
add    $0xffffff9e,%eax
cmp    $0x15,%eax
ja     1225 <parse+0x85>
lea    0xe0c(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
lea    0x8(%rsp),%rdx
lea    0xc(%rsp),%rcx
mov    $0x2,%esi
call   1090 <get_hex@plt>
test   %eax,%eax
je     122f <parse+0x8f>
mov    0x8(%rsp),%esi
mov    $0x5,%edi
call   10a0 <load_run@plt>
jmp    122f <parse+0x8f>
lea    0x10(%rsp),%rdi
call   1080 <puts@plt>
add    $0x20,%rsp
pop    %rbx
ret
xor    %eax,%eax
call   1070 <_core_status@plt>
mov    $0x10,%edi
call   1060 <print_spaces@plt>
mov    $0xa,%edi
add    $0x20,%rsp
pop    %rbx
jmp    1050 <putchar@plt>
mov    $0x1,%edi
xor    %esi,%esi
add    $0x20,%rsp
pop    %rbx
jmp    10a0 <load_run@plt>
lea    0x8(%rsp),%rsi
lea    0xc(%rsp),%rdx
call   10b0 <get_address_data@plt>
test   %eax,%eax
je     122f <parse+0x8f>
mov    0x8(%rsp),%ebx
mov    0xc(%rsp),%eax
add    %ebx,%eax
cmp    %eax,%ebx
jae    122f <parse+0x8f>
nopw   0x0(%rax,%rax,1)
mov    %ebx,%edi
call   1030 <printm@plt>
add    $0x4,%ebx
mov    0xc(%rsp),%eax
add    0x8(%rsp),%eax
cmp    %eax,%ebx
jb     1290 <parse+0xf0>
jmp    122f <parse+0x8f>
lea    0x8(%rsp),%rdx
lea    0xc(%rsp),%rcx
mov    $0x2,%esi
call   1090 <get_hex@plt>
test   %eax,%eax
je     122f <parse+0x8f>
mov    0x8(%rsp),%esi
xor    %edi,%edi
call   10a0 <load_run@plt>
jmp    122f <parse+0x8f>
lea    0x8(%rsp),%rdx
lea    0xc(%rsp),%rcx
mov    $0x2,%esi
call   1090 <get_hex@plt>
test   %eax,%eax
je     122f <parse+0x8f>
movl   $0x0,0xc(%rsp)
mov    0x8(%rsp),%eax
lea    0x1(%rax),%ecx
mov    %ecx,0x8(%rsp)
mov    (%rax),%bl
jmp    1334 <parse+0x194>
nopw   0x0(%rax,%rax,1)
mov    0x8(%rsp),%eax
lea    0x1(%rax),%ecx
mov    %ecx,0x8(%rsp)
movzbl (%rax),%ebx
mov    0xc(%rsp),%eax
add    $0x1,%eax
mov    %eax,0xc(%rsp)
cmp    $0x1000,%eax
jae    122f <parse+0x8f>
test   %bl,%bl
je     1310 <parse+0x170>
movsbl %bl,%edi
call   1040 <_outbyte@plt>
cmp    $0xd,%bl
jne    1310 <parse+0x170>
mov    $0xa,%edi
call   1050 <putchar@plt>
jmp    1310 <parse+0x170>
lea    0x8(%rsp),%rdx
lea    0xc(%rsp),%rcx
mov    $0x2,%esi
call   1090 <get_hex@plt>
test   %eax,%eax
jne    138f <parse+0x1ef>
jmp    122f <parse+0x8f>
lea    0x8(%rsp),%rsi
lea    0xc(%rsp),%rdx
call   10b0 <get_address_data@plt>
test   %eax,%eax
je     122f <parse+0x8f>
mov    0xc(%rsp),%eax
mov    0x8(%rsp),%ecx
mov    %eax,(%rcx)
mov    0x8(%rsp),%edi
call   1030 <printm@plt>
jmp    122f <parse+0x8f>

LLVM IR (-O0):
@__const.parse.bad_command_msg = [16 x i8] c"Invalid command\00"
@.str = [2 x i8] c"\0A\00"
@.str.1 = [4 x i8] c"%s\0A\00"
define void @parse(i8* %0) {
%2 = alloca i8*
%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 i8
%12 = alloca i32
%13 = alloca [16 x i8]
store i8* %0, i8** %2
%14 = bitcast [16 x i8]* %13 to i8*
%15 = load i8*, i8** %2
%16 = getelementptr inbounds i8, i8* %15, i64 1
%17 = load i8, i8* %16
%18 = icmp ne i8 %17, 0
br i1 %18, label %20, label %19
19: ; preds = %1
br label %166
20: ; preds = %1
%21 = load i8*, i8** %2
%22 = getelementptr inbounds i8, i8* %21, i64 1
%23 = load i8, i8* %22
%24 = sext i8 %23 to i32
%25 = icmp eq i32 %24, 13
br i1 %25, label %26, label %43
26: ; preds = %20
%27 = load i8*, i8** %2
%28 = getelementptr inbounds i8, i8* %27, i64 0
%29 = load i8, i8* %28
%30 = sext i8 %29 to i32
switch i32 %30, label %39 [
i32 104, label %31
i32 108, label %33
i32 115, label %35
]
31: ; preds = %26
%32 = call i32 (...) @print_help()
br label %42
33: ; preds = %26
%34 = call i32 @load_run(i32 1, i32 0)
br label %42
35: ; preds = %26
%36 = call i32 (...) @_core_status()
%37 = call i32 @print_spaces(i32 16)
%38 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
br label %42
39: ; preds = %26
%40 = getelementptr inbounds [16 x i8], [16 x i8]* %13, i64 0, i64 0
%41 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i8* %40)
br label %42
42: ; preds = %39, %35, %33, %31
br label %166
43: ; preds = %20
%44 = load i8*, i8** %2
%45 = getelementptr inbounds i8, i8* %44, i64 1
%46 = load i8, i8* %45
%47 = sext i8 %46 to i32
%48 = icmp ne i32 %47, 32
br i1 %48, label %49, label %52
49: ; preds = %43
%50 = getelementptr inbounds [16 x i8], [16 x i8]* %13, i64 0, i64 0
%51 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i8* %50)
br label %166
52: ; preds = %43
br label %53
53: ; preds = %52
%54 = load i8*, i8** %2
%55 = getelementptr inbounds i8, i8* %54, i64 0
%56 = load i8, i8* %55
%57 = sext i8 %56 to i32
switch i32 %57, label %163 [
i32 100, label %58
i32 106, label %78
i32 112, label %86
i32 114, label %135
i32 98, label %143
i32 119, label %151
]
58: ; preds = %53
%59 = load i8*, i8** %2
%60 = call i32 @get_address_data(i8* %59, i32* %4, i32* %8)
%61 = icmp ne i32 %60, 0
br i1 %61, label %62, label %77
62: ; preds = %58
%63 = load i32, i32* %4
store i32 %63, i32* %6
br label %64
64: ; preds = %73, %62
%65 = load i32, i32* %6
%66 = load i32, i32* %4
%67 = load i32, i32* %8
%68 = add i32 %66, %67
%69 = icmp ult i32 %65, %68
br i1 %69, label %70, label %76
70: ; preds = %64
%71 = load i32, i32* %6
%72 = call i32 @printm(i32 %71)
br label %73
73: ; preds = %70
%74 = load i32, i32* %6
%75 = add i32 %74, 4
store i32 %75, i32* %6
br label %64
76: ; preds = %64
br label %77
77: ; preds = %76, %58
br label %166
78: ; preds = %53
%79 = load i8*, i8** %2
%80 = call i32 @get_hex(i8* %79, i32 2, i32* %4, i32* %7)
%81 = icmp ne i32 %80, 0
br i1 %81, label %82, label %85
82: ; preds = %78
%83 = load i32, i32* %4
%84 = call i32 @load_run(i32 0, i32 %83)
br label %85
85: ; preds = %82, %78
br label %166
86: ; preds = %53
%87 = load i8*, i8** %2
%88 = call i32 @get_hex(i8* %87, i32 2, i32* %4, i32* %7)
%89 = icmp ne i32 %88, 0
br i1 %89, label %90, label %134
90: ; preds = %86
store i32 0, i32* %7
store i32 0, i32* %12
%91 = load i32, i32* %4
%92 = add i32 %91, 1
store i32 %92, i32* %4
%93 = zext i32 %91 to i64
%94 = inttoptr i64 %93 to i8*
%95 = load i8, i8* %94
store i8 %95, i8* %11
br label %96
96: ; preds = %123, %90
%97 = load i8, i8* %11
%98 = sext i8 %97 to i32
%99 = icmp slt i32 %98, 128
br i1 %99, label %100, label %103
100: ; preds = %96
%101 = load i32, i32* %7
%102 = icmp ult i32 %101, 4096
br label %103
103: ; preds = %100, %96
%104 = phi i1 [ false, %96 ], [ %102, %100 ]
br i1 %104, label %105, label %133
105: ; preds = %103
%106 = load i8, i8* %11
%107 = sext i8 %106 to i32
%108 = icmp ne i32 %107, 0
br i1 %108, label %109, label %112
109: ; preds = %105
%110 = load i8, i8* %11
%111 = call i32 @_outbyte(i8 signext %110)
br label %112
112: ; preds = %109, %105
%113 = load i8, i8* %11
%114 = sext i8 %113 to i32
%115 = icmp eq i32 %114, 13
br i1 %115, label %116, label %118
116: ; preds = %112
%117 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
br label %118
118: ; preds = %116, %112
store i32 0, i32* %12
%119 = load i32, i32* %12
%120 = icmp eq i32 %119, 79
br i1 %120, label %121, label %123
121: ; preds = %118
%122 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
br label %123
123: ; preds = %121, %118
store i32 0, i32* %12
%124 = load i32, i32* %4
%125 = add i32 %124, 1
store i32 %125, i32* %4
%126 = zext i32 %124 to i64
%127 = inttoptr i64 %126 to i8*
%128 = load i8, i8* %127
store i8 %128, i8* %11
%129 = load i32, i32* %12
%130 = add i32 %129, 1
store i32 %130, i32* %12
%131 = load i32, i32* %7
%132 = add i32 %131, 1
store i32 %132, i32* %7
br label %96
133: ; preds = %103
br label %134
134: ; preds = %133, %86
br label %166
135: ; preds = %53
%136 = load i8*, i8** %2
%137 = call i32 @get_hex(i8* %136, i32 2, i32* %4, i32* %7)
%138 = icmp ne i32 %137, 0
br i1 %138, label %139, label %142
139: ; preds = %135
%140 = load i32, i32* %4
%141 = call i32 @printm(i32 %140)
br label %142
142: ; preds = %139, %135
br label %166
143: ; preds = %53
%144 = load i8*, i8** %2
%145 = call i32 @get_hex(i8* %144, i32 2, i32* %4, i32* %7)
%146 = icmp ne i32 %145, 0
br i1 %146, label %147, label %150
147: ; preds = %143
%148 = load i32, i32* %4
%149 = call i32 @load_run(i32 5, i32 %148)
br label %150
150: ; preds = %147, %143
br label %166
151: ; preds = %53
%152 = load i8*, i8** %2
%153 = call i32 @get_address_data(i8* %152, i32* %4, i32* %5)
%154 = icmp ne i32 %153, 0
br i1 %154, label %155, label %162
155: ; preds = %151
%156 = load i32, i32* %5
%157 = load i32, i32* %4
%158 = zext i32 %157 to i64
%159 = inttoptr i64 %158 to i32*
store i32 %156, i32* %159
%160 = load i32, i32* %4
%161 = call i32 @printm(i32 %160)
br label %162
162: ; preds = %155, %151
br label %166
163: ; preds = %53
%164 = getelementptr inbounds [16 x i8], [16 x i8]* %13, i64 0, i64 0
%165 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i8* %164)
br label %166
166: ; preds = %19, %42, %49, %163, %162, %150, %142, %134, %85, %77
ret void
}

LLVM IR (-O2):
@__const.parse.bad_command_msg = [16 x i8] c"Invalid command\00"
define void @parse(i8* %0) {
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca [16 x i8]
%7 = bitcast i32* %2 to i8*
%8 = bitcast i32* %3 to i8*
%9 = bitcast i32* %4 to i8*
%10 = bitcast i32* %5 to i8*
%11 = getelementptr inbounds [16 x i8], [16 x i8]* %6, i64 0, i64 0
%12 = getelementptr inbounds i8, i8* %0, i64 1
%13 = load i8, i8* %12
switch i8 %13, label %27 [
i8 0, label %104
i8 13, label %14
i8 32, label %29
]
14: ; preds = %1
%15 = load i8, i8* %0
%16 = sext i8 %15 to i32
switch i32 %16, label %25 [
i32 104, label %17
i32 108, label %19
i32 115, label %21
]
17: ; preds = %14
%18 = tail call i32 (...) @print_help()
br label %104
19: ; preds = %14
%20 = tail call i32 @load_run(i32 1, i32 0)
br label %104
21: ; preds = %14
%22 = tail call i32 (...) @_core_status()
%23 = tail call i32 @print_spaces(i32 16)
%24 = tail call i32 @putchar(i32 10)
br label %104
25: ; preds = %14
%26 = call i32 @puts(i8* %11)
br label %104
27: ; preds = %1
%28 = call i32 @puts(i8* %11)
br label %104
29: ; preds = %1
%30 = load i8, i8* %0
%31 = sext i8 %30 to i32
switch i32 %31, label %102 [
i32 100, label %32
i32 106, label %48
i32 112, label %54
i32 114, label %80
i32 98, label %86
i32 119, label %92
]
32: ; preds = %29
%33 = call i32 @get_address_data(i8* %0, i32* %2, i32* %5)
%34 = icmp eq i32 %33, 0
br i1 %34, label %104, label %35
35: ; preds = %32
%36 = load i32, i32* %2
%37 = load i32, i32* %5
%38 = add i32 %37, %36
%39 = icmp ult i32 %36, %38
br i1 %39, label %40, label %104
40: ; preds = %35, %40
%41 = phi i32 [ %43, %40 ], [ %36, %35 ]
%42 = call i32 @printm(i32 %41)
%43 = add i32 %41, 4
%44 = load i32, i32* %2
%45 = load i32, i32* %5
%46 = add i32 %45, %44
%47 = icmp ult i32 %43, %46
br i1 %47, label %40, label %104
48: ; preds = %29
%49 = call i32 @get_hex(i8* %0, i32 2, i32* %2, i32* %4)
%50 = icmp eq i32 %49, 0
br i1 %50, label %104, label %51
51: ; preds = %48
%52 = load i32, i32* %2
%53 = call i32 @load_run(i32 0, i32 %52)
br label %104
54: ; preds = %29
%55 = call i32 @get_hex(i8* %0, i32 2, i32* %2, i32* %4)
%56 = icmp eq i32 %55, 0
br i1 %56, label %104, label %57
57: ; preds = %54
store i32 0, i32* %4
%58 = load i32, i32* %2
%59 = add i32 %58, 1
store i32 %59, i32* %2
%60 = zext i32 %58 to i64
%61 = inttoptr i64 %60 to i8*
%62 = load i8, i8* %61
br label %63
63: ; preds = %57, %71
%64 = phi i8 [ %76, %71 ], [ %62, %57 ]
%65 = icmp eq i8 %64, 0
br i1 %65, label %71, label %66
66: ; preds = %63
%67 = call i32 @_outbyte(i8 signext %64)
%68 = icmp eq i8 %64, 13
br i1 %68, label %69, label %71
69: ; preds = %66
%70 = call i32 @putchar(i32 10)
br label %71
71: ; preds = %63, %66, %69
%72 = load i32, i32* %2
%73 = add i32 %72, 1
store i32 %73, i32* %2
%74 = zext i32 %72 to i64
%75 = inttoptr i64 %74 to i8*
%76 = load i8, i8* %75
%77 = load i32, i32* %4
%78 = add i32 %77, 1
store i32 %78, i32* %4
%79 = icmp ult i32 %78, 4096
br i1 %79, label %63, label %104
80: ; preds = %29
%81 = call i32 @get_hex(i8* %0, i32 2, i32* %2, i32* %4)
%82 = icmp eq i32 %81, 0
br i1 %82, label %104, label %83
83: ; preds = %80
%84 = load i32, i32* %2
%85 = call i32 @printm(i32 %84)
br label %104
86: ; preds = %29
%87 = call i32 @get_hex(i8* %0, i32 2, i32* %2, i32* %4)
%88 = icmp eq i32 %87, 0
br i1 %88, label %104, label %89
89: ; preds = %86
%90 = load i32, i32* %2
%91 = call i32 @load_run(i32 5, i32 %90)
br label %104
92: ; preds = %29
%93 = call i32 @get_address_data(i8* %0, i32* %2, i32* %3)
%94 = icmp eq i32 %93, 0
br i1 %94, label %104, label %95
95: ; preds = %92
%96 = load i32, i32* %3
%97 = load i32, i32* %2
%98 = zext i32 %97 to i64
%99 = inttoptr i64 %98 to i32*
store i32 %96, i32* %99
%100 = load i32, i32* %2
%101 = call i32 @printm(i32 %100)
br label %104
102: ; preds = %29
%103 = call i32 @puts(i8* %11)
br label %104
104: ; preds = %71, %40, %35, %102, %32, %51, %48, %54, %83, %80, %89, %86, %95, %92, %1, %17, %19, %21, %25, %27
ret void
}