LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: lemire[P]validateutf8-experiments/tests/unit.cpp
// Function: display(std::vector<unsigned char, std::allocator<unsigned char>> const&)
void display(const std::vector<uint8_t> & string) {
  printf("[");
  for(size_t i = 0; i < string.size(); i++) {
    printf("0x%02x", string[i]);
    if(i + 1 < string.size()) printf(",");
  }
  printf("]");
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
leaq 0xfb8d8(%rip), %rdi     # 0xff078
movb $0x0, %al
callq 0x2030
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0xf9180
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x3839
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xf91a0
movzbl (%rax), %esi
leaq 0xfb890(%rip), %rdi     # 0xff07a
movb $0x0, %al
callq 0x2030
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0xf9180
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x3824
leaq 0xfb864(%rip), %rdi     # 0xff081
movb $0x0, %al
callq 0x2030
jmp 0x3826
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x37b0
leaq 0xfb843(%rip), %rdi     # 0xff083
movb $0x0, %al
callq 0x2030
addq $0x28, %rsp
retq
nopl (%rax)
// File: lemire[P]validateutf8-experiments/benchmarks/hoehrmann.h
// Function: shiftless_validate_dfa_utf8(signed char const*, unsigned long)
static inline fastvalidate::error_code
shiftless_validate_dfa_utf8(const signed char *c, size_t len) {
  const unsigned char *cu = (const unsigned char *)c;
  uint32_t state = 0;
  for (size_t i = 0; i < len; i++) {
    uint32_t byteval = (uint32_t)cu[i];
    if (shiftless_updatestate(&state, byteval) == SHIFTLESS_UTF8_REJECT)
      return fastvalidate::error_code::UTF8_ERROR;
  }
  if (shiftless_updatestate(&state, 0) == SHIFTLESS_UTF8_REJECT)
    return fastvalidate::error_code::UTF8_ERROR;
  return fastvalidate::error_code::SUCCESS;
}

// Assembly:
movq %rdi, -0x30(%rsp)
movq %rsi, -0x38(%rsp)
movq -0x30(%rsp), %rax
movq %rax, -0x40(%rsp)
movl $0x0, -0x44(%rsp)
movq $0x0, -0x50(%rsp)
movq -0x50(%rsp), %rax
cmpq -0x38(%rsp), %rax
jae 0x45c8
movq -0x40(%rsp), %rax
movq -0x50(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x54(%rsp)
movl -0x54(%rsp), %eax
leaq -0x44(%rsp), %rcx
movq %rcx, -0x8(%rsp)
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %eax
movl %eax, %ecx
leaq 0xfaeda(%rip), %rax     # 0xff450
movzbl (%rax,%rcx), %eax
movl %eax, -0x10(%rsp)
movq -0x8(%rsp), %rax
movl (%rax), %eax
addl -0x10(%rsp), %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0xfafbc(%rip), %rax     # 0xff550
movzbl (%rax,%rcx), %ecx
movq -0x8(%rsp), %rax
movl %ecx, (%rax)
movq -0x8(%rsp), %rax
cmpl $0x10, (%rax)
jne 0x45b3
movl $0x1, -0x24(%rsp)
jmp 0x462c
jmp 0x45b5
movq -0x50(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rsp)
jmp 0x4535
leaq -0x44(%rsp), %rax
movq %rax, -0x18(%rsp)
movl $0x0, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
movl %eax, %ecx
leaq 0xfae69(%rip), %rax     # 0xff450
movzbl (%rax,%rcx), %eax
movl %eax, -0x20(%rsp)
movq -0x18(%rsp), %rax
movl (%rax), %eax
addl -0x20(%rsp), %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0xfaf4b(%rip), %rax     # 0xff550
movzbl (%rax,%rcx), %ecx
movq -0x18(%rsp), %rax
movl %ecx, (%rax)
movq -0x18(%rsp), %rax
cmpl $0x10, (%rax)
jne 0x4624
movl $0x1, -0x24(%rsp)
jmp 0x462c
movl $0x0, -0x24(%rsp)
movl -0x24(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: lemire[P]validateutf8-experiments/tests/unit.cpp
// Function: twobytetest()
void twobytetest() {
  // this should not validate
  const char * twobyte = "\xcf\xcf\xcf";
  if(active_fastvalidate::lookup2::validate(twobyte, 3) != fastvalidate::error_code::UTF8_ERROR) {
        printf("twobytetest bug\n");
        abort();
  }
  if(active_fastvalidate::lookup3::validate(twobyte, 3) != fastvalidate::error_code::UTF8_ERROR) {
        printf("twobytetest bug\n");
        abort();
  }  
  if(active_fastvalidate::lookup4::validate(twobyte, 3) != fastvalidate::error_code::UTF8_ERROR) {
        printf("twobytetest bug\n");
        abort();
  }  
}

// Assembly:
pushq %rax
leaq 0xf96a1(%rip), %rax     # 0xff2b9
movq %rax, (%rsp)
movq (%rsp), %rdi
movl $0x3, %esi
callq 0x23e0
cmpl $0x1, %eax
je 0x5c42
leaq 0xf9687(%rip), %rdi     # 0xff2bd
movb $0x0, %al
callq 0x2030
callq 0x20d0
movq (%rsp), %rdi
movl $0x3, %esi
callq 0x2440
cmpl $0x1, %eax
je 0x5c68
leaq 0xf9661(%rip), %rdi     # 0xff2bd
movb $0x0, %al
callq 0x2030
callq 0x20d0
movq (%rsp), %rdi
movl $0x3, %esi
callq 0x24a0
cmpl $0x1, %eax
je 0x5c8e
leaq 0xf963b(%rip), %rdi     # 0xff2bd
movb $0x0, %al
callq 0x2030
callq 0x20d0
popq %rax
retq
// File: lemire[P]validateutf8-experiments/tests/unit.cpp
// Function: main
int main() {
  brute_force_tests();
  twobytetest();
  test();
  return EXIT_SUCCESS;
}

// Assembly:
pushq %rax
movl $0x0, 0x4(%rsp)
callq 0x3850
callq 0x5c10
callq 0x5c90
xorl %eax, %eax
popq %rcx
retq
nopl (%rax)
// File: lemire[P]validateutf8-experiments/src/generic/utf8_range_algorithm.h
// Function: auto fastvalidate::westmere::range::utf8_checker::check_next_input(fastvalidate::westmere::simd::simd8x64<unsigned char>)::'lambda'(auto, auto)::operator()<fastvalidate::westmere::simd::simd8<unsigned char>, fastvalidate::westmere::simd::simd8<unsigned char>>(auto, auto) const
really_inline void check_next_input(simd8x64<uint8_t> in) {
    simd8<uint8_t> bits = in.reduce([&](auto a, auto b) { return a | b; });
    if (likely(!bits.any_bits_set_anywhere(0x80u))) {
      // it is ascii, we just check carried continuations.
      this->check_carried_continuations();
    } else {
      // it is not ascii so we have to do heavy work
      for (int i=0; i<simd8x64<uint8_t>::NUM_CHUNKS; i++) {
        this->check_utf8_bytes(in.chunks[i]);
      }
    }
  }

// Assembly:
subq $0xb8, %rsp
movdqa %xmm0, -0x50(%rsp)
movdqa %xmm1, -0x60(%rsp)
movq %rdi, -0x68(%rsp)
movq -0x60(%rsp), %rax
movq %rax, -0x80(%rsp)
movq -0x58(%rsp), %rax
movq %rax, -0x78(%rsp)
movdqa -0x80(%rsp), %xmm0
movdqa %xmm0, -0x20(%rsp)
leaq -0x50(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0xb0(%rsp), %rax
movdqa (%rax), %xmm1
leaq -0x20(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq 0xa8(%rsp), %rax
movdqa (%rax), %xmm0
movdqa %xmm1, 0x90(%rsp)
movdqa %xmm0, 0x80(%rsp)
movdqa 0x90(%rsp), %xmm0
por 0x80(%rsp), %xmm0
leaq -0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
movdqa %xmm0, (%rsp)
movq 0x18(%rsp), %rax
movdqa (%rsp), %xmm0
movq %rax, 0x38(%rsp)
movdqa %xmm0, 0x20(%rsp)
movq 0x38(%rsp), %rax
movdqa 0x20(%rsp), %xmm0
movq %rax, 0x58(%rsp)
movdqa %xmm0, 0x40(%rsp)
movq 0x58(%rsp), %rax
movdqa 0x40(%rsp), %xmm0
movq %rax, 0x78(%rsp)
movdqa %xmm0, 0x60(%rsp)
movq 0x78(%rsp), %rax
movdqa 0x60(%rsp), %xmm0
movdqa %xmm0, (%rax)
movdqa -0x10(%rsp), %xmm0
movdqa %xmm0, -0x40(%rsp)
movdqa -0x40(%rsp), %xmm0
addq $0xb8, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: rofl0r[P]ascc/main.cpp
// Function: slurp_file(_IO_FILE*)
char *slurp_file(FILE *f) {
	fseek(f, 0, SEEK_END);
	unsigned len = ftell(f);
	fseek(f, 0, SEEK_SET);
	char *mem = (char*) malloc(len+1);
	fread(mem, 1, len, f);
	mem[len] = 0;
	fclose(f);
	return mem;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x4440
movq -0x8(%rbp), %rdi
callq 0x4030
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x4440
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x44f0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %edx
movq -0x8(%rbp), %rcx
movl $0x1, %esi
callq 0x4580
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rdi
callq 0x4370
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rofl0r[P]ascc/main.cpp
// Function: set_compiler_default_options()
static void set_compiler_default_options(void) {
        ccSetSoftwareVersion("3.5.0.12");
	ccSetOption(SCOPT_LINENUMBERS, 0);
        ccSetOption(SCOPT_EXPORTALL, 1);
        ccSetOption(SCOPT_NOIMPORTOVERRIDE, 0);
        ccSetOption(SCOPT_LEFTTORIGHT, 1);
        ccSetOption(SCOPT_OLDSTRINGS, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x2bccd(%rip), %rdi     # 0x312a8
callq 0x2bc20
movl $0x4, %edi
xorl %esi, %esi
callq 0x26560
movl $0x1, %esi
movl %esi, %edi
callq 0x26560
movl $0x20, %edi
xorl %esi, %esi
callq 0x26560
movl $0x40, %edi
movl $0x1, %esi
callq 0x26560
movl $0x80, %edi
movl $0x1, %esi
callq 0x26560
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rofl0r[P]ascc/main.cpp
// Function: process_compiler_option(char*)
static void process_compiler_option(char *option) {
	char *p = strchr(option, '=');
	if(!p) {
		if(process_custom_option(option, 0)) return;
		fprintf(stderr, "error: option %s lacks equals sign\n", option);
		exit(1);
	}
	*p = 0;
	int bit = ccOptionStringToBit(option);
	if(!bit) {
		if(process_custom_option(option, p+1)) return;
		fprintf(stderr, "error: option %s unknown\n", option);
		exit(1);
	}
	ccSetOption(bit, atoi(p+1));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x3d, %esi
callq 0x4180
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5692
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5d80
cmpl $0x0, %eax
je 0x566c
jmp 0x5706
movq 0x3c94d(%rip), %rax     # 0x41fc0
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x2bc30(%rip), %rsi     # 0x312b1
movb $0x0, %al
callq 0x4550
movl $0x1, %edi
callq 0x4470
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rdi
callq 0x263d0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x56e9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x1, %rsi
callq 0x5d80
cmpl $0x0, %eax
je 0x56c3
jmp 0x5706
movq 0x3c8f6(%rip), %rax     # 0x41fc0
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x2bbfd(%rip), %rsi     # 0x312d5
movb $0x0, %al
callq 0x4550
movl $0x1, %edi
callq 0x4470
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
callq 0x45b0
movl -0x18(%rbp), %edi
movl %eax, %esi
callq 0x26560
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: rofl0r[P]ascc/main.cpp
// Function: add_macro(char const*, char const*)
static void add_macro(const char *name, const char *value) {
	char buf[1024];
	sprintf(buf, "#define %s %s\n", name, value);
	buffer_append(&macrobuf, buf, strlen(buf));
	ccDefineMacro(name, value);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x410(%rbp), %rdi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0x2bb92(%rip), %rsi     # 0x3133b
movb $0x0, %al
callq 0x40d0
leaq -0x410(%rbp), %rax
movq %rax, -0x418(%rbp)
leaq -0x410(%rbp), %rdi
callq 0x41d0
movq -0x418(%rbp), %rsi
movq %rax, %rdx
leaq 0x3cd35(%rip), %rdi     # 0x42510
callq 0x5e90
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2bbd0
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rofl0r[P]ascc/main.cpp
// Function: getbasename(char*)
static char *getbasename(char *filename) {
	char *q = strrchr(filename, '/');
	/* for windoze folks... */
	if(!q) q = strrchr(filename, '\\');
	if(q) q++;
	else q = filename;
	return q;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2f, %esi
callq 0x4430
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x59c7
movq -0x8(%rbp), %rdi
movl $0x5c, %esi
callq 0x4430
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x59dc
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x59e4
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: rofl0r[P]ascc/main.cpp
// Function: search_executable_dir(char const*, char*, unsigned long)
static int search_executable_dir(const char *bin, char *buf, size_t buflen) {
	if(search_executable_path(bin, buf, buflen)) {
		char *p = strrchr(buf, DIRSEP);
		if(p) {
			*p = 0;
			return 1;
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x5f40
cmpl $0x0, %eax
je 0x5a45
movq -0x18(%rbp), %rdi
movl $0x2f, %esi
callq 0x4430
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x5a43
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x5a4c
jmp 0x5a45
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rofl0r[P]ascc/main.cpp
// Function: load_headers(char*, int)
static int load_headers(char* headers, int ext) {
	while(*headers) {
		char *e = strchr(headers, ':');
		if(e) *e = 0;
		FILE *f = fopen(headers, "r");
		if(!f) {
			fprintf(stderr, "error: could not load header %s: ", headers);
			perror("");
			return 0;
		}
		preproc_add(f, getbasename(headers), ext);
		if(!e) break;
		else headers = e+1;
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x5b82
movq -0x10(%rbp), %rdi
movl $0x3a, %esi
callq 0x4180
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5afc
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rdi
leaq 0x2e991(%rip), %rsi     # 0x34498
callq 0x4450
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x5b48
movq 0x3c4a2(%rip), %rax     # 0x41fc0
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x2bd44(%rip), %rsi     # 0x31870
movb $0x0, %al
callq 0x4550
leaq 0x2e632(%rip), %rdi     # 0x3416c
callq 0x4310
movl $0x0, -0x4(%rbp)
jmp 0x5b89
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5990
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movl -0x14(%rbp), %edx
callq 0x5a60
cmpq $0x0, -0x20(%rbp)
jne 0x5b71
jmp 0x5b82
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x5acf
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rofl0r[P]ascc/main.cpp
// Function: run_cpp(char*, char*)
static char *run_cpp(char *cppcmd, char* fc) {
	char *fn = tempfile();
	if(!fn) return 0;
	FILE *f = fopen(fn, "w");
	if(!f) return 0;
	fwrite(macrobuf.mem, 1, macrobuf.used, f);
	fwrite(fc, 1, strlen(fc), f);
	fclose(f);
	char buf[4096];
	sprintf(buf, "%s %s", cppcmd, fn);
	FILE *p = popen(buf, "r");
	if(!p) {
	cpp_err:
		fprintf(stderr, "error creating cpp process:");
		perror("");
		return 0;
	}
	struct buffer out;
	while(fgets(buf, sizeof buf, p))
		buffer_append(&out, buf, strlen(buf));
	int status = pclose(p);
	if(status == -1 || !WIFEXITED(status)) {
		goto cpp_err;
	}
	unlink(fn);
	free(fn);
	buffer_makestring(&out);
	return out.mem;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1070, %rsp           # imm = 0x1070
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
callq 0x49a0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x5bd0
movq $0x0, -0x8(%rbp)
jmp 0x5d66
movq -0x20(%rbp), %rdi
leaq 0x2de07(%rip), %rsi     # 0x339e2
callq 0x4450
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x5bf8
movq $0x0, -0x8(%rbp)
jmp 0x5d66
movq 0x3c921(%rip), %rdi     # 0x42520
movq 0x3c912(%rip), %rdx     # 0x42518
movq -0x28(%rbp), %rcx
movl $0x1, %esi
callq 0x46e0
movq -0x18(%rbp), %rax
movq %rax, -0x1060(%rbp)
movq -0x18(%rbp), %rdi
callq 0x41d0
movq -0x1060(%rbp), %rdi
movq %rax, %rdx
movq -0x28(%rbp), %rcx
movl $0x1, %esi
callq 0x46e0
movq -0x28(%rbp), %rdi
callq 0x4370
leaq -0x1030(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0x2b628(%rip), %rsi     # 0x31287
movb $0x0, %al
callq 0x40d0
leaq -0x1030(%rbp), %rdi
leaq 0x2e824(%rip), %rsi     # 0x34498
callq 0x4140
movq %rax, -0x1038(%rbp)
cmpq $0x0, -0x1038(%rbp)
jne 0x5cbd
jmp 0x5c8c
movq 0x3c32d(%rip), %rax     # 0x41fc0
movq (%rax), %rdi
leaq 0x2bbf5(%rip), %rsi     # 0x31892
movb $0x0, %al
callq 0x4550
leaq 0x2e4c1(%rip), %rdi     # 0x3416c
callq 0x4310
movq $0x0, -0x8(%rbp)
jmp 0x5d66
jmp 0x5cbf
leaq -0x1030(%rbp), %rdi
movq -0x1038(%rbp), %rdx
movl $0x1000, %esi           # imm = 0x1000
callq 0x45d0
cmpq $0x0, %rax
je 0x5d0f
leaq -0x1030(%rbp), %rax
movq %rax, -0x1068(%rbp)
leaq -0x1030(%rbp), %rdi
callq 0x41d0
movq -0x1068(%rbp), %rsi
movq %rax, %rdx
leaq -0x1050(%rbp), %rdi
callq 0x5e90
jmp 0x5cbf
movq -0x1038(%rbp), %rdi
callq 0x4530
movl %eax, -0x1054(%rbp)
cmpl $-0x1, -0x1054(%rbp)
je 0x5d38
movl -0x1054(%rbp), %eax
andl $0x7f, %eax
cmpl $0x0, %eax
je 0x5d3d
jmp 0x5c8c
movq -0x20(%rbp), %rdi
callq 0x4200
movq -0x20(%rbp), %rdi
callq 0x4460
leaq -0x1050(%rbp), %rdi
callq 0x6150
movq -0x1040(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x1070, %rsp           # imm = 0x1070
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rofl0r[P]ascc/main.cpp
// Function: process_custom_option(char*, char*)
static int process_custom_option(char *option, char *value) {
	for(unsigned i = 0; cust_f_opts[i].name; ++i)
		if(!strcmp(cust_f_opts[i].name, option)) {
			if(cust_f_opts[i].need_value) {
				if(!value) {
					fprintf(stderr, "error: option %s requires value\n", option);
					exit(1);
				}
				*cust_f_opts[i].target = atoi(value);
			} else
				*cust_f_opts[i].target = 1;
			return 1;
		}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %ecx
leaq 0x3bdfd(%rip), %rax     # 0x41ba0
shlq $0x5, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x5e7e
movl -0x1c(%rbp), %eax
movl %eax, %ecx
leaq 0x3bde0(%rip), %rax     # 0x41ba0
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x4510
cmpl $0x0, %eax
jne 0x5e6e
movl -0x1c(%rbp), %eax
movl %eax, %ecx
leaq 0x3bdb8(%rip), %rax     # 0x41ba0
shlq $0x5, %rcx
addq %rcx, %rax
cmpl $0x0, 0x18(%rax)
je 0x5e48
cmpq $0x0, -0x18(%rbp)
jne 0x5e22
movq 0x3c1bd(%rip), %rax     # 0x41fc0
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x2b4de(%rip), %rsi     # 0x312ef
movb $0x0, %al
callq 0x4550
movl $0x1, %edi
callq 0x4470
movq -0x18(%rbp), %rdi
callq 0x45b0
movl %eax, %ecx
movl -0x1c(%rbp), %eax
movl %eax, %edx
leaq 0x3bd67(%rip), %rax     # 0x41ba0
shlq $0x5, %rdx
addq %rdx, %rax
movq 0x10(%rax), %rax
movl %ecx, (%rax)
jmp 0x5e65
movl -0x1c(%rbp), %eax
movl %eax, %ecx
leaq 0x3bd4c(%rip), %rax     # 0x41ba0
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movl $0x1, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x5e85
jmp 0x5e70
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5d97
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: rofl0r[P]ascc/main.cpp
// Function: buffer_append(buffer*, char const*, unsigned long)
static int buffer_append(struct buffer *b, const char* data, size_t len) {
	if(b->used+len > b->capa) {
		size_t want = ALIGN(b->used+len, 4096);
		char *n = (char*) realloc(b->mem, want);
		if(!n) return 0;
		b->mem = n;
		b->capa = want;
	}
	memcpy(b->mem+b->used, data, len);
	b->used += len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
addq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jbe 0x5f10
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
addq -0x18(%rbp), %rax
addq $0xfff, %rax            # imm = 0xFFF
andq $-0x1000, %rax          # imm = 0xF000
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x4620
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x5ef9
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
addq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4300
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
ud2
nop
// File: rofl0r[P]ascc/main.cpp
// Function: search_executable_path(char const*, char*, unsigned long)
static int search_executable_path(const char *bin, char *buf, size_t buflen) {
	snprintf(buf, buflen, "%s", bin);
	if(access(buf, X_OK) == 0 || search_path_bin(bin, buf, buflen))
		return resolve_realname(buf, buflen);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rcx
leaq 0x2d761(%rip), %rdx     # 0x336c8
movb $0x0, %al
callq 0x45f0
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x4640
cmpl $0x0, %eax
je 0x5f97
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x5fc0
cmpl $0x0, %eax
je 0x5fa9
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x60d0
movl %eax, -0x4(%rbp)
jmp 0x5fb0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: rofl0r[P]ascc/main.cpp
// Function: search_path_bin(char const*, char*, unsigned long)
static int search_path_bin(const char *bin, char *buf, size_t buflen) {
	char *p = getenv("PATH"), *o;
	size_t l;
	for(;;) {
		o = buf;
		l = buflen;
		while(l && *p && *p != ':') {
			*(o++) = *(p++);
			l--;
		}
		snprintf(o, l, "/%s", bin);
		if(access(buf, X_OK) == 0) return 1;
		if(*p == ':') p++;
		else if(!p) break;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq 0x2b88c(%rip), %rdi     # 0x31867
callq 0x4480
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x38(%rbp)
movb %al, -0x39(%rbp)
je 0x601e
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, -0x39(%rbp)
je 0x601e
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3a, %eax
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x6027
jmp 0x6057
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movb (%rax), %cl
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb %cl, (%rax)
movq -0x38(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x5ff4
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rcx
leaq 0x2b802(%rip), %rdx     # 0x3186c
movb $0x0, %al
callq 0x45f0
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x4640
cmpl $0x0, %eax
jne 0x608d
movl $0x1, -0x4(%rbp)
jmp 0x60be
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3a, %eax
jne 0x60a7
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x60b2
cmpq $0x0, -0x28(%rbp)
jne 0x60b0
jmp 0x60b7
jmp 0x60b2
jmp 0x5fe4
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: rofl0r[P]ascc/main.cpp
// Function: resolve_realname(char*, unsigned long)
static int resolve_realname(char *buf, size_t buflen) {
	char workbuf[PATH_MAX];
	if(realpath(buf, workbuf)) {
		snprintf(buf, buflen, "%s", workbuf);
		if(access(buf, X_OK) == 0) return 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1020, %rsp           # imm = 0x1020
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x1020(%rbp), %rsi
callq 0x4160
cmpq $0x0, %rax
je 0x6134
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x1020(%rbp), %rcx
leaq 0x2d5b9(%rip), %rdx     # 0x336c8
movb $0x0, %al
callq 0x45f0
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x4640
cmpl $0x0, %eax
jne 0x6132
movl $0x1, -0x4(%rbp)
jmp 0x613b
jmp 0x6134
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x1020, %rsp           # imm = 0x1020
popq %rbp
retq
nopw (%rax,%rax)
// File: rofl0r[P]ascc/cs_parser.cpp
// Function: yank_chunk(ccCompiledScript*, std::vector<ccChunk, std::allocator<ccChunk>>*, int, int)
void yank_chunk(ccCompiledScript *scrip, std::vector<ccChunk> *list, int codeoffset, int fixupoffset) {
    ccChunk item;
    int index;

    for(index = codeoffset; index < scrip->codesize; index++)
        item.code.push_back(scrip->code[index]);
    for(index = fixupoffset; index < scrip->numfixups; index++) {
        item.fixups.push_back(scrip->fixups[index]);
        item.fixuptypes.push_back(scrip->fixuptypes[index]);
    }
    item.codeoffset = codeoffset;
    item.fixupoffset = fixupoffset;
    list->push_back(item);
    scrip->codesize = codeoffset;
    scrip->numfixups = fixupoffset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x17c10
movl -0x14(%rbp), %eax
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x62e6
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x6c(%rbp), %rcx
leaq (%rax,%rcx,4), %rsi
leaq -0x68(%rbp), %rdi
callq 0x17c50
jmp 0x62bf
jmp 0x62c1
movl -0x6c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x6c(%rbp)
jmp 0x6298
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x17da0
jmp 0x637b
movl -0x18(%rbp), %eax
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x48(%rcx), %eax
jge 0x633a
leaq -0x50(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x6c(%rbp), %rcx
leaq (%rax,%rcx,4), %rsi
callq 0x17c50
jmp 0x6313
leaq -0x38(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rsi
movslq -0x6c(%rbp), %rax
addq %rax, %rsi
callq 0x17cc0
jmp 0x632d
jmp 0x632f
movl -0x6c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x6c(%rbp)
jmp 0x62ec
movl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x17d30
jmp 0x6355
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
movl -0x18(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x48(%rax)
leaq -0x68(%rbp), %rdi
callq 0x17da0
addq $0x80, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x4670
nopw %cs:(%rax,%rax)
// File: rofl0r[P]ascc/cs_parser.cpp
// Function: write_chunk(ccCompiledScript*, ccChunk)
void write_chunk(ccCompiledScript *scrip, ccChunk item) {
    int index;
    int limit;
    int adjust;

    scrip->flush_line_numbers();
    adjust = scrip->codesize - item.codeoffset;
    limit = item.code.size();
    for(index = 0; index < limit; index++) {
        scrip->write_code(item.code[index]);
    }
    limit = item.fixups.size();
    for(index = 0; index < limit; index++)
        scrip->add_fixup(item.fixups[index] + adjust, item.fixuptypes[index]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x25fb0
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
subl 0x48(%rdi), %eax
movl %eax, -0x1c(%rbp)
callq 0x17de0
movl %eax, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x6400
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movslq -0x14(%rbp), %rsi
callq 0x17e00
movq -0x30(%rbp), %rdi
movl (%rax), %esi
callq 0x25170
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x63cd
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
callq 0x17de0
movl %eax, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x646b
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
addq $0x18, %rdi
movslq -0x14(%rbp), %rsi
callq 0x17e00
movq -0x28(%rbp), %rdi
movl (%rax), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x34(%rbp)
addq $0x30, %rdi
movslq -0x14(%rbp), %rsi
callq 0x17e20
movq -0x40(%rbp), %rdi
movl -0x34(%rbp), %esi
movsbl (%rax), %edx
callq 0x25790
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6417
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rofl0r[P]ascc/cs_parser.cpp
// Function: get_member_full_name(int, int)
const char *get_member_full_name(int structSym, int memberSym) {

    const char* memberName = sym.get_name(memberSym);

    // de-mangle name, if appropriate
    if (memberName[0] == '.')
        memberName = &memberName[1];

    sprintf(constructedMemberName, "%s::%s", sym.get_name(structSym), memberName);

    return constructedMemberName;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x8(%rbp), %esi
leaq 0x3c0e8(%rip), %rdi     # 0x42870
callq 0x1f730
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x67a9
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %esi
leaq 0x3c0bd(%rip), %rdi     # 0x42870
callq 0x1f730
movq %rax, %rdx
movq -0x10(%rbp), %rcx
leaq 0x3bd7a(%rip), %rdi     # 0x42540
leaq 0x2b137(%rip), %rsi     # 0x31904
movb $0x0, %al
callq 0x40d0
leaq 0x3bd65(%rip), %rax     # 0x42540
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rofl0r[P]ascc/cs_parser.cpp
// Function: sym_find_or_add(symbolTable&, char const*)
int sym_find_or_add(symbolTable &sym, const char *sname) {
    int symdex = sym.find(sname);
    if (symdex < 0) {
        symdex = sym.add(sname);
    }
    return symdex;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1f050
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x6826
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1f870
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: rofl0r[P]ascc/cs_parser.cpp
// Function: free_pointer(int, int, int, ccCompiledScript*)
void free_pointer(int spOffset, int zeroCmd, int arraySym, ccCompiledScript *scrip) {

    load_stack_variable(scrip, spOffset);
    scrip->write_cmd(zeroCmd);

    if ((sym.entries[arraySym].flags & (SFLG_ARRAY | SFLG_DYNAMICARRAY)) == SFLG_ARRAY) {
        // array of pointers -- release each one
        for (int ee = 1; ee < sym.entries[arraySym].arrsize; ee++) {
            scrip->write_cmd2(SCMD_ADD, SREG_MAR, 4);
            scrip->write_cmd(zeroCmd);
        }
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0x72c0
movq -0x18(%rbp), %rdi
movl -0x8(%rbp), %esi
callq 0x25140
movslq -0xc(%rbp), %rsi
leaq 0x3b638(%rip), %rdi     # 0x42870
addq $0x28, %rdi
callq 0x17e60
movq 0x28(%rax), %rax
andq $0x40002, %rax          # imm = 0x40002
cmpq $0x2, %rax
jne 0x72b2
movl $0x1, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq %rax, -0x28(%rbp)
movslq -0xc(%rbp), %rsi
leaq 0x3b605(%rip), %rdi     # 0x42870
addq $0x28, %rdi
callq 0x17e60
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq 0x48(%rcx), %rax
jge 0x72b0
movq -0x18(%rbp), %rdi
movl $0x1, %esi
movl $0x2, %edx
movl $0x4, %ecx
callq 0x25240
movq -0x18(%rbp), %rdi
movl -0x8(%rbp), %esi
callq 0x25140
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7258
jmp 0x72b2
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: rofl0r[P]ascc/cs_parser.cpp
// Function: load_stack_variable(ccCompiledScript*, int)
static void load_stack_variable(ccCompiledScript *scrip, int offset) {
	if(compiler_max_command >= SCMD_LOADSPOFFS) {
		scrip->write_cmd1(SCMD_LOADSPOFFS, offset);
	} else {
		scrip->write_cmd2(SCMD_REGTOREG,SREG_SP,SREG_MAR);
		scrip->write_cmd2(SCMD_SUB,SREG_MAR,offset);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x33, 0x3b11a(%rip)    # 0x423f0
jl 0x72eb
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movl $0x33, %esi
callq 0x25200
jmp 0x7316
movq -0x8(%rbp), %rdi
movl $0x3, %esi
movl $0x1, %edx
movl $0x2, %ecx
callq 0x25240
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %ecx
movl $0x2, %edx
movl %edx, %esi
callq 0x25240
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: rofl0r[P]ascc/cs_parser.cpp
// Function: is_any_type_of_string(int)
int is_any_type_of_string(int symtype) {
    symtype &= ~(STYPE_CONST | STYPE_POINTER);
    if ((symtype == sym.normalStringSym) || (symtype == sym.stringStructSym))
        return 1;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0x9fffffff, %eax       # imm = 0x9FFFFFFF
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
leaq 0x3a484(%rip), %rcx     # 0x42870
cmpl 0x10(%rcx), %eax
je 0x8400
movl -0x8(%rbp), %eax
leaq 0x3a475(%rip), %rcx     # 0x42870
cmpl 0x20(%rcx), %eax
jne 0x8409
movl $0x1, -0x4(%rbp)
jmp 0x8410
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rofl0r[P]ascc/cs_parser.cpp
// Function: friendly_int_symbol[abi:cxx11](int, bool)
std::string friendly_int_symbol(int symidx, bool isNegative) {
    if (isNegative) {
        return "-" + sym.get_friendly_name(symidx);
    } else {
        return sym.get_friendly_name(symidx);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
andb $0x1, %al
movb %al, -0xd(%rbp)
testb $0x1, -0xd(%rbp)
je 0x86b6
movl -0xc(%rbp), %edx
leaq 0x3a1ff(%rip), %rsi     # 0x42870
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x1f080
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rdx
leaq 0x2b33d(%rip), %rsi     # 0x339ca
callq 0x17fb0
jmp 0x8694
leaq -0x30(%rbp), %rdi
callq 0x4270
jmp 0x86c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4270
jmp 0x86d3
movq -0x50(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0x3a1ac(%rip), %rsi     # 0x42870
callq 0x1f080
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x4670
nopl (%rax)
// File: rofl0r[P]ascc/cs_parser.cpp
// Function: check_not_eof(ccInternalList&)
int check_not_eof(ccInternalList &targ) {
  if (targ.peeknext() == SCODE_INVALID) {
    // We are past the last symbol in the file
    targ.getnext();
    currentline = targ.lineAtEnd;
    cc_error("Unexpected end of file");
    return -1;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1dd60
cmpq $-0x1, %rax
jne 0x8aab
movq -0x10(%rbp), %rdi
callq 0x1de00
movq -0x10(%rbp), %rax
movl 0x14(%rax), %ecx
leaq 0x39e9e(%rip), %rax     # 0x42930
movl %ecx, (%rax)
leaq 0x2906a(%rip), %rdi     # 0x31b05
movb $0x0, %al
callq 0x1bac0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8ab2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: rofl0r[P]ascc/cs_parser.cpp
// Function: check_for_default_value(ccInternalList&, int, int)
int check_for_default_value(ccInternalList &targ, int funcsym, int numparams) {

    if (sym.get_type(targ.peeknext()) == SYM_ASSIGN) {
        // parameter has default value
        targ.getnext();
        int defValSym = targ.getnext();
        bool negateIt = false;

        if (sym.get_name(defValSym)[0] == '-') {
            // allow negative default value
            negateIt = true;
            defValSym = targ.getnext();
        }

        int defaultValue;

        // extract the default value
        if (accept_literal_or_constant_value(defValSym, defaultValue, negateIt, "Parameter default value must be literal") < 0) {
            return -1;
        }

        sym.entries[funcsym].funcParamDefaultValues[numparams % 100] = defaultValue;
        sym.entries[funcsym].funcParamHasDefaultValues[numparams % 100] = true;

    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1dd60
movl %eax, %esi
leaq 0x39d8c(%rip), %rdi     # 0x42870
callq 0x1e1e0
cmpl $0x19, %eax
jne 0x8bde
movq -0x10(%rbp), %rdi
callq 0x1de00
movq -0x10(%rbp), %rdi
callq 0x1de00
movl %eax, -0x1c(%rbp)
movb $0x0, -0x1d(%rbp)
movl -0x1c(%rbp), %esi
leaq 0x39d5b(%rip), %rdi     # 0x42870
callq 0x1f730
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x8b32
movb $0x1, -0x1d(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1de00
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
movb -0x1d(%rbp), %al
leaq -0x24(%rbp), %rsi
leaq 0x28fd9(%rip), %rcx     # 0x31b1c
andb $0x1, %al
movzbl %al, %edx
callq 0x86e0
cmpl $0x0, %eax
jge 0x8b5e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8be5
movl -0x24(%rbp), %eax
movl %eax, -0x3c(%rbp)
movslq -0x14(%rbp), %rsi
leaq 0x39d01(%rip), %rdi     # 0x42870
addq $0x28, %rdi
callq 0x17e60
movq %rax, %rdi
addq $0x70, %rdi
movl -0x18(%rbp), %eax
movl $0x64, %ecx
cltd
idivl %ecx
movslq %edx, %rsi
callq 0x17e00
movl -0x3c(%rbp), %ecx
movl %ecx, (%rax)
movslq -0x14(%rbp), %rsi
leaq 0x39cce(%rip), %rdi     # 0x42870
addq $0x28, %rdi
callq 0x17e60
movq %rax, %rdi
addq $0x88, %rdi
movl -0x18(%rbp), %eax
movl $0x64, %ecx
cltd
idivl %ecx
movslq %edx, %rsi
callq 0x181b0
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x38(%rbp), %rdi
movl $0x1, %esi
callq 0x18210
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: rofl0r[P]ascc/cs_parser.cpp
// Function: check_for_dynamic_array_declaration(ccInternalList&, int, bool)
int check_for_dynamic_array_declaration(ccInternalList &targ, int typeSym, bool isPointer)
{
  if (sym.get_type(targ.peeknext()) == SYM_OPENBRACKET)
  {
    // dynamic array
    targ.getnext();
    if (sym.get_type(targ.getnext()) != SYM_CLOSEBRACKET)
    {
      cc_error("fixed size array cannot be used in this way");
      return -1;
    }
    if (sym.entries[typeSym].flags & SFLG_STRUCTTYPE) {
        if (!(sym.entries[typeSym].flags & SFLG_MANAGED)) {
            cc_error("cannot pass non-managed struct array");
            return -1;
        }
        if (!isPointer) {
            cc_error("cannot pass non-pointer struct array");
            return -1;
        }
    }
    return 1;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1dd60
movl %eax, %esi
leaq 0x39c58(%rip), %rdi     # 0x42870
callq 0x1e1e0
cmpl $0x7, %eax
jne 0x8cec
movq -0x10(%rbp), %rdi
callq 0x1de00
movq -0x10(%rbp), %rdi
callq 0x1de00
movl %eax, %esi
leaq 0x39c2f(%rip), %rdi     # 0x42870
callq 0x1e1e0
cmpl $0x8, %eax
je 0x8c65
leaq 0x28ef2(%rip), %rdi     # 0x31b44
movb $0x0, %al
callq 0x1bac0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8cf3
movslq -0x14(%rbp), %rsi
leaq 0x39c00(%rip), %rdi     # 0x42870
addq $0x28, %rdi
callq 0x17e60
movq 0x28(%rax), %rax
andq $0x400, %rax            # imm = 0x400
cmpq $0x0, %rax
je 0x8ce3
movslq -0x14(%rbp), %rsi
leaq 0x39bdc(%rip), %rdi     # 0x42870
addq $0x28, %rdi
callq 0x17e60
movq 0x28(%rax), %rax
andq $0x1000, %rax           # imm = 0x1000
cmpq $0x0, %rax
jne 0x8cc4
leaq 0x28ebc(%rip), %rdi     # 0x31b70
movb $0x0, %al
callq 0x1bac0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8cf3
testb $0x1, -0x15(%rbp)
jne 0x8ce1
leaq 0x28ec4(%rip), %rdi     # 0x31b95
movb $0x0, %al
callq 0x1bac0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8cf3
jmp 0x8ce3
movl $0x1, -0x4(%rbp)
jmp 0x8cf3
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: rofl0r[P]ascc/cs_parser.cpp
// Function: isPartOfExpression(ccInternalList*, int)
int isPartOfExpression(ccInternalList *targ, int j) {
  if (sym.get_type(targ->script[j]) == SYM_NEW)
    return 1;
  if (sym.get_type(targ->script[j]) < NOTEXPRESSION)
    return 1;
  // static member access
  if ((j < targ->length - 1) &&
      (sym.get_type(targ->script[j + 1]) == SYM_DOT) &&
      (sym.get_type(targ->script[j]) == SYM_VARTYPE))
    return 1;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl %eax, %esi
leaq 0x38648(%rip), %rdi     # 0x42870
callq 0x1e1e0
cmpl $0x35, %eax
jne 0xa23e
movl $0x1, -0x4(%rbp)
jmp 0xa2d5
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl %eax, %esi
leaq 0x38619(%rip), %rdi     # 0x42870
callq 0x1e1e0
cmpl $0x17, %eax
jge 0xa26a
movl $0x1, -0x4(%rbp)
jmp 0xa2d5
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0xa2ce
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl %eax, %esi
leaq 0x385d8(%rip), %rdi     # 0x42870
callq 0x1e1e0
cmpl $0x9, %eax
jne 0xa2ce
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl %eax, %esi
leaq 0x385b5(%rip), %rdi     # 0x42870
callq 0x1e1e0
cmpl $0x2e, %eax
jne 0xa2ce
movl $0x1, -0x4(%rbp)
jmp 0xa2d5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: rofl0r[P]ascc/cs_parser.cpp
// Function: is_string(int)
int is_string(int valtype) {

  if (strcmp(sym.get_name(valtype),"const string")==0)
    return 1;
  if (strcmp(sym.get_name(valtype),"string")==0)
    return 1;
  if (strcmp(sym.get_name(valtype),"char*")==0)
    return 1;

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %esi
leaq 0x383eb(%rip), %rdi     # 0x42870
callq 0x1f730
movq %rax, %rdi
leaq 0x27b03(%rip), %rsi     # 0x31f97
callq 0x4510
cmpl $0x0, %eax
jne 0xa4a7
movl $0x1, -0x4(%rbp)
jmp 0xa506
movl -0x8(%rbp), %esi
leaq 0x383bf(%rip), %rdi     # 0x42870
callq 0x1f730
movq %rax, %rdi
leaq 0x2a008(%rip), %rsi     # 0x344c8
callq 0x4510
cmpl $0x0, %eax
jne 0xa4d3
movl $0x1, -0x4(%rbp)
jmp 0xa506
movl -0x8(%rbp), %esi
leaq 0x38393(%rip), %rdi     # 0x42870
callq 0x1f730
movq %rax, %rdi
leaq 0x27ab8(%rip), %rsi     # 0x31fa4
callq 0x4510
cmpl $0x0, %eax
jne 0xa4ff
movl $0x1, -0x4(%rbp)
jmp 0xa506
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: rofl0r[P]ascc/cs_parser.cpp
// Function: isVCPUOperatorBoolean(int)
int isVCPUOperatorBoolean(int scmdtype) {
    // returns whether this operator's val type is always bool
    if ((scmdtype >= SCMD_ISEQUAL) &&
        (scmdtype <= SCMD_OR))
        return 1;

    if ((scmdtype >= SCMD_FGREATER) &&
        (scmdtype <= SCMD_FLTE))
        return 1;

    if ((scmdtype == SCMD_STRINGSNOTEQ) ||
        (scmdtype == SCMD_STRINGSEQUAL))
        return 1;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0xf, -0x8(%rbp)
jl 0xac6c
cmpl $0x16, -0x8(%rbp)
jg 0xac6c
movl $0x1, -0x4(%rbp)
jmp 0xac9d
cmpl $0x3b, -0x8(%rbp)
jl 0xac81
cmpl $0x3e, -0x8(%rbp)
jg 0xac81
movl $0x1, -0x4(%rbp)
jmp 0xac9d
cmpl $0x42, -0x8(%rbp)
je 0xac8d
cmpl $0x41, -0x8(%rbp)
jne 0xac96
movl $0x1, -0x4(%rbp)
jmp 0xac9d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rofl0r[P]ascc/cs_parser.cpp
// Function: DoNullCheckOnStringInAXIfNecessary(ccCompiledScript*, int, int)
void DoNullCheckOnStringInAXIfNecessary(ccCompiledScript *scrip, int valTypeFrom, int valTypeTo) {

  // Convert normal literal string into String object
  if (((valTypeFrom & (~STYPE_POINTER)) == sym.stringStructSym) &&
     ((valTypeTo & (~STYPE_CONST)) == sym.normalStringSym)) {

    scrip->write_cmd1(SCMD_CHECKNULLREG, SREG_AX);
  }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
andl $0xbfffffff, %eax       # imm = 0xBFFFFFFF
leaq 0x3730f(%rip), %rcx     # 0x42870
cmpl 0x20(%rcx), %eax
jne 0xb58d
movl -0x10(%rbp), %eax
andl $0xdfffffff, %eax       # imm = 0xDFFFFFFF
leaq 0x372fb(%rip), %rcx     # 0x42870
cmpl 0x10(%rcx), %eax
jne 0xb58d
movq -0x8(%rbp), %rdi
movl $0x43, %esi
movl $0x3, %edx
callq 0x25200
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rofl0r[P]ascc/cs_parser.cpp
// Function: PerformStringConversionInAX(ccCompiledScript*, int*, int)
void PerformStringConversionInAX(ccCompiledScript *scrip, int *valTypeFrom, int valTypeTo) {

  // Convert normal literal string into String object
  if (((*valTypeFrom & (~STYPE_CONST)) == sym.normalStringSym) &&
     ((valTypeTo & (~STYPE_POINTER)) == sym.stringStructSym)) {

    scrip->write_cmd1(SCMD_CREATESTRING, SREG_AX);
    *valTypeFrom = STYPE_POINTER | sym.stringStructSym;
  }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xdfffffff, %eax       # imm = 0xDFFFFFFF
leaq 0x372ab(%rip), %rcx     # 0x42870
cmpl 0x10(%rcx), %eax
jne 0xb607
movl -0x14(%rbp), %eax
andl $0xbfffffff, %eax       # imm = 0xBFFFFFFF
leaq 0x37297(%rip), %rcx     # 0x42870
cmpl 0x20(%rcx), %eax
jne 0xb607
movq -0x8(%rbp), %rdi
movl $0x40, %esi
movl $0x3, %edx
callq 0x25200
leaq 0x37278(%rip), %rax     # 0x42870
movl 0x20(%rax), %ecx
orl $0x40000000, %ecx       # imm = 0x40000000
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: rofl0r[P]ascc/cs_parser.cpp
// Function: set_ax_scope(ccCompiledScript*, int)
void set_ax_scope(ccCompiledScript *scrip, int syoffs) {
  // "null" is a global var
  if (sym.get_type(syoffs) == SYM_NULL)
    scrip->ax_val_scope = SYM_GLOBALVAR;
  // if it's a parameter, pretend it's a global var
  // this allows it to be returned back from the function
  else if (sym.entries[syoffs].flags & SFLG_PARAMETER)
    scrip->ax_val_scope = SYM_GLOBALVAR;
  else
    scrip->ax_val_scope = sym.entries[syoffs].stype;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %esi
leaq 0x37247(%rip), %rdi     # 0x42870
callq 0x1e1e0
cmpl $0x15, %eax
jne 0xb643
movq -0x8(%rbp), %rax
movl $0x1, 0x8d50(%rax)
jmp 0xb699
movslq -0xc(%rbp), %rsi
leaq 0x37222(%rip), %rdi     # 0x42870
addq $0x28, %rdi
callq 0x17e60
movq 0x28(%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0xb675
movq -0x8(%rbp), %rax
movl $0x1, 0x8d50(%rax)
jmp 0xb697
movslq -0xc(%rbp), %rsi
leaq 0x371f0(%rip), %rdi     # 0x42870
addq $0x28, %rdi
callq 0x17e60
movswl 0x20(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8d50(%rax)
jmp 0xb699
addq $0x10, %rsp
popq %rbp
retq
nop
// File: rofl0r[P]ascc/cs_parser.cpp
// Function: findClosingBracketOffs(int, long*, int)
int findClosingBracketOffs(int openBracketOffs, long *symlist, int slilen) {
  int endof,braclevel=0;
  for (endof = openBracketOffs + 1; endof < slilen; endof++) {
    int symtype = sym.get_type(symlist[endof]);
    if ((symtype == SYM_OPENBRACKET) || (symtype == SYM_OPENPARENTHESIS))
      braclevel++;
    if ((symtype == SYM_CLOSEBRACKET) || (symtype == SYM_CLOSEPARENTHESIS)) {
      braclevel--;
      if (braclevel < 0) break;
    }
  }
  return endof;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xb728
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl %eax, %esi
leaq 0x37191(%rip), %rdi     # 0x42870
callq 0x1e1e0
movl %eax, -0x20(%rbp)
cmpl $0x7, -0x20(%rbp)
je 0xb6f3
cmpl $0x5, -0x20(%rbp)
jne 0xb6fc
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x8, -0x20(%rbp)
je 0xb708
cmpl $0x6, -0x20(%rbp)
jne 0xb71b
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0xb719
jmp 0xb728
jmp 0xb71b
jmp 0xb71d
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xb6c2
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)