LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::Holder::reduce(peg::SemanticValues&, std::any&) const
inline std::any Holder::reduce(SemanticValues &vs, std::any &dt) const {
  if (outer_->action && !outer_->disable_action) {
    return outer_->action(vs, dt);
  } else if (vs.empty()) {
    return std::any();
  } else {
    return std::move(vs.front());
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rsi), %rsi
cmpq $0x0, 0x70(%rsi)
je 0x347cd
cmpb $0x0, 0x108(%rsi)
je 0x347e0
movq (%rdx), %rsi
cmpq 0x8(%rdx), %rsi
je 0x347ee
movq %rbx, %rdi
callq 0x256c8
jmp 0x347f4
addq $0x60, %rsi
movq %rbx, %rdi
callq 0x3334e
jmp 0x347f4
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::Definition::Result peg::Definition::parse_and_get_value<std::shared_ptr<peg::AstBase<peg::EmptyType>>>(char const*, unsigned long, std::shared_ptr<peg::AstBase<peg::EmptyType>>&, char const*, std::function<void (unsigned long, unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)>) const
Result parse_and_get_value(const char *s, size_t n, T &val,
                             const char *path = nullptr,
                             Log log = nullptr) const {
    SemanticValues vs;
    std::any dt;
    auto r = parse_core(s, n, vs, dt, path, log);
    if (r.ret && !vs.empty() && vs.front().has_value()) {
      val = std::any_cast<T>(vs[0]);
    }
    return r;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %r9, -0x50(%rbp)
movq %r8, -0x48(%rbp)
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r14
leaq -0x90(%rbp), %rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x20(%rax)
movaps %xmm0, -0x30(%rax)
movaps %xmm0, -0x40(%rax)
movaps %xmm0, -0x50(%rax)
movaps %xmm0, -0x60(%rax)
movaps %xmm0, -0x70(%rax)
movaps %xmm0, -0x80(%rax)
movaps %xmm0, -0x90(%rax)
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rdi, %rbx
movq 0x10(%rbp), %rsi
movb $0x0, (%rax)
movaps %xmm0, -0x40(%rbp)
leaq -0x80(%rbp), %r15
movq %r15, %rdi
callq 0xbff0
leaq -0x120(%rbp), %r8
leaq -0x40(%rbp), %r9
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r12, %rcx
pushq %r15
pushq -0x50(%rbp)
callq 0x2f012
popq %rax
popq %rcx
leaq -0x80(%rbp), %rdi
callq 0x3209c
cmpb $0x1, (%rbx)
jne 0x37391
movq -0x120(%rbp), %rsi
cmpq -0x118(%rbp), %rsi
je 0x37391
cmpq $0x0, (%rsi)
je 0x37391
leaq -0x60(%rbp), %rdi
callq 0x3743d
leaq -0x60(%rbp), %rsi
movq -0x48(%rbp), %rdi
callq 0x3748a
leaq -0x58(%rbp), %rdi
callq 0x1106c
leaq -0x40(%rbp), %rdi
callq 0x1113a
leaq -0x120(%rbp), %rdi
callq 0xae2c
movq %rbx, %rax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
addq $0x10, %rbx
movq %rbx, %rdi
callq 0x108f6
jmp 0x373dd
movq %rax, %r14
leaq -0x80(%rbp), %rdi
callq 0x3209c
jmp 0x373dd
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x1113a
leaq -0x120(%rbp), %rdi
callq 0xae2c
movq %r14, %rdi
callq 0x9430
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/./peglib.h
// Function: peg::parser::get_no_ast_opt_rules[abi:cxx11]() const
std::vector<std::string> get_no_ast_opt_rules() const {
    std::vector<std::string> rules;
    for (auto &[name, rule] : *grammar_) {
      if (rule.no_ast_opt) { rules.push_back(name); }
    }
    return rules;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq (%rsi), %r14
addq $0x10, %r14
movq (%r14), %r14
testq %r14, %r14
je 0x37500
cmpb $0x1, 0x1e0(%r14)
jne 0x374e0
leaq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x377cc
jmp 0x374e0
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x1feea
movq %r14, %rdi
callq 0x9430
nop
// File: /workspace/github_cpp_makefile_star2_O2/yhirose[P]fizzbuzzlang/fzbz.cc
// Function: Value::str[abi:cxx11]() const
string str() const {
    switch (v.index()) {
      case 0:
        return "nil";
      case 1:
        return get<bool>() ? "true" : "false";
      case 2:
        return to_string(get<long>());
      case 3:
        return string(get<string_view>());
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movzbl 0x20(%rsi), %eax
leaq 0xdf1(%rip), %rcx       # 0x391ec
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1c8a(%rip), %rsi      # 0x3a095
jmp 0x3845f
movq %rsi, %rdi
callq 0xd3f0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x38475
jmp 0x3846b
movq %rsi, %rdi
callq 0x30948
leaq -0x20(%rbp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
leaq -0x9(%rbp), %rdx
movq %rbx, %rdi
callq 0x1371e
jmp 0x3846b
movq %rsi, %rdi
callq 0xd2de
leaq 0x1c47(%rip), %rcx      # 0x3a099
leaq 0x1c45(%rip), %rsi      # 0x3a09e
testb %al, %al
cmovneq %rcx, %rsi
leaq -0x20(%rbp), %rdx
movq %rbx, %rdi
callq 0xff44
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/BenLangmead[P]bowtie/./word_io.h
// Function: unsigned int readU<unsigned int>(std::istream&, bool)
static inline T readU(std::istream& in, bool swap) {
	T x;
	in.read((char *)&x, sizeof(T));
	assert_eq(sizeof(T), in.gcount());
	if(swap) {
		if(sizeof(T) == 4) {
			return endianSwapU32(x);
		} else if(sizeof(T) == 8) {
			return endianSwapU64(x);
		} else {
			assert(false);
		}
	} else {
		return x;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x4(%rsp), %rsi
pushq $0x4
popq %rdx
callq 0x43b0
cmpq $0x4, 0x8(%r14)
jne 0xc23d
movl 0x4(%rsp), %ecx
movl %ecx, %eax
bswapl %eax
testb %bl, %bl
cmovel %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x25d74(%rip), %rbx     # 0x31fb8
leaq 0x1af0e(%rip), %rsi     # 0x27159
movq %rbx, %rdi
callq 0x42c0
pushq $0x4
popq %r12
movq %rax, %rdi
movq %r12, %rsi
callq 0x40b0
leaq 0x1af06(%rip), %r15     # 0x2716f
movq %rax, %rdi
movq %r15, %rsi
callq 0x42c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rax,%rcx)
movq %rax, %rdi
movq %r12, %rsi
callq 0x40b0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x2, %edx
movl %edx, 0x18(%rax,%rcx)
leaq 0x1aec4(%rip), %rsi     # 0x27174
movq %rax, %rdi
callq 0x42c0
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x4600
movq %rax, %rdi
movq %r15, %rsi
callq 0x42c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rax,%rcx)
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x4600
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x2, %edx
movl %edx, 0x18(%rax,%rcx)
leaq 0x1d153(%rip), %rsi     # 0x2945f
movq %rax, %rdi
callq 0x42c0
movq %rax, %rdi
callq 0x4130
leaq 0x1c97a(%rip), %r14     # 0x28c9d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x42c0
leaq 0x1c406(%rip), %rsi     # 0x2873b
movq %rax, %rdi
callq 0x42c0
pushq $0x37
popq %rbx
movq %rax, %rdi
movl %ebx, %esi
callq 0x45c0
movq %rax, %rdi
callq 0x4130
leaq 0x1c2c2(%rip), %rdi     # 0x2861b
leaq 0x1d1c8(%rip), %rcx     # 0x29528
movq %r14, %rsi
movl %ebx, %edx
callq 0x4190
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/test/units/dataprov_hook/hook_cli.c
// Function: input_next
scdcint_t input_next(scdc_dataset_input_t *input, scdc_result_t *result)
{
  scdcint_t i = (intptr_t) input->data;


  printf(PREFIX "preparing INPUT #%" scdcint_fmt "\n", i);

  ((char *) SCDC_DATASET_INOUT_BUF_PTR(input))[0] = 0;

  SCDC_DATASET_INOUT_BUF_CURRENT(input) = 0;

  if (i >= 1) input->next = NULL;

  input->data = (void *) (intptr_t) (i + 1);

  return SCDC_SUCCESS;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %r14
leaq 0x38e32(%rip), %rdi     # 0x45020
movq %r14, %rsi
xorl %eax, %eax
callq 0xb070
movq 0x10(%rbx), %rax
movb $0x0, (%rax)
andq $0x0, 0x20(%rbx)
testq %r14, %r14
jle 0xc20e
andq $0x0, 0x38(%rbx)
incq %r14
movq %r14, 0x40(%rbx)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/test/units/dataprov_hook/hook_cli.c
// Function: output_next
scdcint_t output_next(scdc_dataset_output_t *output, scdc_result_t *result)
{
  scdcint_t i = (intptr_t) output->data;


  if (strcmp(output->format, "text") == 0 || strcmp(output->format, "fslist") == 0)
    printf(PREFIX "processing OUTPUT #%" scdcint_fmt ": '%.*s'\n", i, (int) SCDC_DATASET_INOUT_BUF_CURRENT(output), (char *) SCDC_DATASET_INOUT_BUF_PTR(output));
  else
    printf(PREFIX "processing OUTPUT #%" scdcint_fmt": %" scdcint_fmt " bytes\n", i, SCDC_DATASET_INOUT_BUF_CURRENT(output));

  output->data = (void *) (intptr_t) (i + 1);

  return SCDC_SUCCESS;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %r14
leaq 0x38e0f(%rip), %rsi     # 0x45041
callq 0xb780
testl %eax, %eax
je 0xc265
leaq 0x3b548(%rip), %rsi     # 0x4778a
movq %rbx, %rdi
callq 0xb780
testl %eax, %eax
je 0xc265
movq 0x20(%rbx), %rdx
leaq 0x38e18(%rip), %rdi     # 0x45071
movq %r14, %rsi
xorl %eax, %eax
callq 0xb070
jmp 0xc27d
movl 0x20(%rbx), %edx
movq 0x10(%rbx), %rcx
leaq 0x38dd3(%rip), %rdi     # 0x45046
movq %r14, %rsi
xorl %eax, %eax
callq 0xb070
incq %r14
movq %r14, 0x40(%rbx)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/test/units/dataprov_hook/hook_cli.c
// Function: do_dataset_cmd
void do_dataset_cmd(scdc_dataset_t dataset, const char *cmd)
{
  scdc_dataset_input_t input, output;
  int i;

#define DEFAULT_INPUT_BUF_SIZE   256
#define DEFAULT_OUTPUT_BUF_SIZE  256

  char input_buf[DEFAULT_INPUT_BUF_SIZE], output_buf[DEFAULT_OUTPUT_BUF_SIZE];


  /* prepare command input */
  scdc_dataset_input_unset(&input);

  strcpy(input.format, "data");

  SCDC_DATASET_INOUT_BUF_PTR(&input) = input_buf;
  SCDC_DATASET_INOUT_BUF_SIZE(&input) = DEFAULT_INPUT_BUF_SIZE;
  SCDC_DATASET_INOUT_BUF_CURRENT(&input) = 0;
  input.total_size = 0;
  input.total_size_given = SCDC_DATASET_INOUT_TOTAL_SIZE_GIVEN_AT_LEAST;

  input.next = input_next;
  input.data = (void *) 0;

  input.next(&input, 0);

  /* prepare command output */
  scdc_dataset_output_unset(&output);

  SCDC_DATASET_INOUT_BUF_PTR(&output) = output_buf;
  SCDC_DATASET_INOUT_BUF_SIZE(&output) = DEFAULT_OUTPUT_BUF_SIZE;

  output.next = 0;
  output.data = (void *) 0;

  scdcint_t ret = scdc_dataset_cmd(dataset, cmd, &input, &output);

  /* process output */
  i = 0;
  do {
    void *data = output.data;
    output.data = (void *) (intptr_t) i;

    output_next(&output, 0);

    i = (intptr_t) output.data;
    output.data = data;

    if (!output.next) break;

#if 0
    printf(PREFIX "Press <Enter>");
    getchar();
#endif

    output.next(&output, 0);

  } while (1);

  printf(PREFIX "command '%s' %s!\n", cmd, ((ret == SCDC_SUCCESS)?"success":"failed"));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2b0, %rsp            # imm = 0x2B0
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x58(%rsp), %r12
movq %r12, %rdi
callq 0x19c38
movb $0x0, 0x4(%r12)
movl $0x61746164, (%r12)     # imm = 0x61746164
leaq 0x1b0(%rsp), %rax
movq %rax, 0x10(%r12)
movl $0x100, %r13d           # imm = 0x100
movq %r13, 0x18(%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r12)
movb $0x6c, 0x30(%r12)
leaq -0x112(%rip), %rax      # 0xc1dc
movq %rax, 0x38(%r12)
andq $0x0, 0x40(%r12)
movq %r12, %rdi
callq 0xc1dc
movq %rsp, %r14
movq %r14, %rdi
callq 0x19c58
leaq 0xb0(%rsp), %rax
movq %rax, 0x10(%r14)
movq %r13, 0x18(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%r14)
xorl %r13d, %r13d
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0xe01c
movq %rax, %r15
movq 0x40(%rsp), %r12
movslq %r13d, %rax
movq %rax, 0x40(%rsp)
movq %r14, %rdi
callq 0xc220
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %r13
movq %r12, 0x40(%rsp)
testq %rax, %rax
je 0xc36f
movq %r14, %rdi
xorl %esi, %esi
callq *%rax
jmp 0xc33d
cmpq $0x1, %r15
leaq 0x38d47(%rip), %rax     # 0x450c1
leaq 0x3af31(%rip), %rdx     # 0x472b2
cmoveq %rax, %rdx
leaq 0x38d19(%rip), %rdi     # 0x450a5
movq %rbx, %rsi
xorl %eax, %eax
callq 0xb070
addq $0x2b0, %rsp            # imm = 0x2B0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/test/units/dataprov_hook/hook_cli.c
// Function: main
int main(int argc, char *argv[])
{
  scdc_dataprov_t dp_hook = SCDC_DATAPROV_NULL;

  scdc_dataset_t dataset = SCDC_DATASET_NULL;

#define OPTARG_MAX  256
  char scheme[OPTARG_MAX] = { '\0' }, authority[OPTARG_MAX] = { '\0' }, open[OPTARG_MAX] = { '\0' }, cmdline[OPTARG_MAX] = { '\0' };


  printf(PREFIX "start hook demo client\n");

#if 0
  strcpy(scheme, "scdc");
  strcpy(authority, "");
#elif 1
  strcpy(scheme, "scdc+uds");
  strcpy(authority, "");
#elif 1
  strcpy(scheme, "scdc+tcp");
  strcpy(authority, "localhost");
#endif
  strcpy(open, "hookdemo/");
  strcpy(cmdline, "ls");

  scdc_init(SCDC_INIT_DEFAULT);

  dp_hook = scdc_dataprov_open("hookdemo", "hook:id", &hook, 0x2501);

  if (strlen(scheme) > 0 || strlen(authority) > 0 || strlen(open) > 0)
  {
    char uri[1024];

    sprintf(uri, "%s://%s/%s", scheme, authority, open);

    printf(PREFIX "uri: '%s'\n", uri);

    dataset = scdc_dataset_open(uri);
  }

  printf(PREFIX "dataset: %p\n", dataset);

  do_dataset_cmd(dataset, cmdline);

  scdc_dataset_close(dataset);

  scdc_dataprov_close(dp_hook);

  scdc_release();

  printf(PREFIX "quit hook demo client\n");

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x808, %rsp            # imm = 0x808
leaq 0x300(%rsp), %rbx
xorl %ebp, %ebp
movl $0x100, %edx            # imm = 0x100
movq %rbx, %rdi
xorl %esi, %esi
callq 0xb2f0
leaq 0x38d50(%rip), %rdi     # 0x45124
callq 0xb860
leaq 0x209(%rsp), %r14
movl $0xf7, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0xb2f0
movabsq $0x7364752b63646373, %rax # imm = 0x7364752B63646373
movq %rax, -0x9(%r14)
movb %bpl, -0x1(%r14)
movb %bpl, (%rbx)
leaq 0x10a(%rsp), %r14
movl $0xf6, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0xb2f0
movabsq $0x6f6d65646b6f6f68, %rax # imm = 0x6F6D65646B6F6F68
movq %rax, -0xa(%r14)
movw $0x2f, -0x2(%r14)
leaq 0x3(%rsp), %r14
movl $0xfd, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0xb2f0
movb %bpl, -0x1(%r14)
movw $0x736c, -0x3(%r14)     # imm = 0x736C
leaq 0x3a586(%rip), %rdi     # 0x469dd
xorl %eax, %eax
callq 0xcbe1
leaq 0x38c77(%rip), %rdi     # 0x450dc
leaq 0x38c79(%rip), %rsi     # 0x450e5
leaq 0x556bd(%rip), %rdx     # 0x61b30
movl $0x2501, %ecx           # imm = 0x2501
xorl %eax, %eax
callq 0xcf3c
movq %rax, %r14
leaq 0x38c64(%rip), %rsi     # 0x450ed
leaq 0x400(%rsp), %r15
leaq 0x200(%rsp), %rdx
leaq 0x100(%rsp), %r8
movq %r15, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0xb0c0
leaq 0x38c43(%rip), %rdi     # 0x450f8
movq %r15, %rsi
xorl %eax, %eax
callq 0xb070
movq %r15, %rdi
xorl %eax, %eax
callq 0xd75b
movq %rax, %rbx
leaq 0x38c3a(%rip), %rdi     # 0x4510d
movq %rax, %rsi
xorl %eax, %eax
callq 0xb070
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xc28f
movq %rbx, %rdi
callq 0xd813
movq %r14, %rdi
callq 0xcffa
callq 0xccf6
leaq 0x38c41(%rip), %rdi     # 0x45145
callq 0xb860
xorl %eax, %eax
addq $0x808, %rsp            # imm = 0x808
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/cpearce[P]OggIndex/src/OggIndexValid.cpp
// Function: main
int main(int argc, char** argv) 
{
  if (argc != 2) {
    PrintUsage();
    return -1;
  }
  bool valid = ValidateIndexedOgg(string(argv[1]));
  cout << "Index is " << (valid ? "" : "NOT ") << "valid" << endl;
  return valid ? 0 : -1;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
cmpl $0x2, %edi
jne 0x73f5
movq 0x8(%rsi), %rsi
leaq 0x10(%rsp), %rbx
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x747c
movq %rbx, %rdi
callq 0xa6fc
movl %eax, %ebx
leaq 0x10(%rsp), %rdi
callq 0x4170
movq 0xcc21(%rip), %rdi      # 0x13fd0
leaq 0x64ef(%rip), %rsi      # 0xd8a5
callq 0x4330
leaq 0x6d90(%rip), %rcx      # 0xe152
leaq 0x64e6(%rip), %rsi      # 0xd8af
testb %bl, %bl
cmovneq %rcx, %rsi
movq %rax, %rdi
callq 0x4330
leaq 0x6538(%rip), %rsi      # 0xd916
movq %rax, %rdi
callq 0x4330
movq %rax, %rdi
callq 0x41b0
movzbl %bl, %eax
decl %eax
jmp 0x7460
movq 0xcbd4(%rip), %rdi      # 0x13fd0
leaq 0x64b1(%rip), %rsi      # 0xd8b4
callq 0x4330
leaq 0x64b4(%rip), %rsi      # 0xd8c3
movq %rax, %rdi
callq 0x4330
movq %rax, %rdi
callq 0x41b0
movq %rax, %rdi
callq 0x41b0
leaq 0x649f(%rip), %rsi      # 0xd8cd
movq %rax, %rdi
callq 0x4330
movq %rax, %rdi
callq 0x41b0
leaq 0x648f(%rip), %rsi      # 0xd8d4
movq %rax, %rdi
callq 0x4330
movq %rax, %rdi
callq 0x41b0
movq %rax, %rdi
callq 0x41b0
pushq $-0x1
popq %rax
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4170
movq %rbx, %rdi
callq 0x4640
nop
// File: /workspace/github_cpp_makefile_star2_O2/narula[P]skiplists/skiplist.cc
// Function: SkipList::SkipList(int, int)
SkipList::SkipList(int prob, int maxl) {
  head = new node();
  tail = new node();
  probability = prob;
  max_level = maxl;
  if (max_level == 0) max_level = 1;
  if (max_level > MAX_LEVEL) max_level = MAX_LEVEL;
  head->key = -1;
  head->topLevel = max_level;
  tail->key = INT_MAX;
  tail->topLevel = max_level;
  for (int i = 0; i < MAX_LEVEL; i++) {
	head->nexts[i].nxt = tail;
	head->nexts[i].prefix = INT_MAX;
  }
  count = 0;
  pointer_follows = 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movl %esi, %r12d
movq %rdi, %rbx
movl $0x148, %edi            # imm = 0x148
callq 0x10a0
movq %rax, %r14
movl $0x148, %edx            # imm = 0x148
movq %rax, %rdi
xorl %esi, %esi
callq 0x1050
movq %r14, (%rbx)
movl $0x148, %edi            # imm = 0x148
callq 0x10a0
movq %rax, %r15
movl $0x148, %edx            # imm = 0x148
movq %rax, %rdi
xorl %esi, %esi
callq 0x1050
movq %r15, 0x8(%rbx)
movl %r12d, 0x10(%rbx)
cmpl $0x1, %ebp
adcl $0x0, %ebp
cmpl $0x14, %ebp
pushq $0x14
popq %rax
cmovll %ebp, %eax
movl %eax, 0x14(%rbx)
orl $-0x1, (%r14)
movl %eax, 0x4(%r14)
movl $0x7fffffff, (%r15)     # imm = 0x7FFFFFFF
movl %eax, 0x4(%r15)
pushq $0x10
popq %rax
cmpq $0x150, %rax            # imm = 0x150
je 0x12a2
movq %r15, (%r14,%rax)
movl $0x7fffffff, -0x8(%r14,%rax) # imm = 0x7FFFFFFF
addq $0x10, %rax
jmp 0x1287
andq $0x0, 0x18(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/narula[P]skiplists/skiplist.cc
// Function: SkipList::findNodeFast(int)
int SkipList::findNodeFast(int key) {
  node* pred = head;
  inc();
  for (int level = pred->topLevel-1; level >= 0; level--) {
	node* curr = pred->nexts[level].nxt;
	while (key > pred->nexts[level].prefix) {
	  pred = curr; 
	  curr = pred->nexts[level].nxt;
	  inc();
	}
	if (key == pred->nexts[level].prefix) {
	  return level;
	}
  }
  return -1;
}

// Assembly:
pushq %rbx
movq (%rdi), %r8
movl 0x1c(%rdi), %ecx
movl 0x18(%rdi), %edx
cmpl $0x1, %ecx
jne 0x12fe
incl %edx
movl %edx, 0x18(%rdi)
movl 0x4(%r8), %r9d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %r9d, %r9d
jle 0x1341
decq %r9
movl %r9d, %r10d
shlq $0x4, %r10
movq 0x10(%r8,%r10), %r11
cmpl %esi, 0x8(%r8,%r10)
jge 0x133c
movq %r11, %rbx
movq 0x10(%r11,%r10), %r11
movq %rbx, %r8
cmpl $0x1, %ecx
jne 0x131b
incl %edx
movl %edx, 0x18(%rdi)
movq %rbx, %r8
jmp 0x131b
jne 0x1307
movl %r9d, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/narula[P]skiplists/skiplist.cc
// Function: randomLevel(int, int)
int randomLevel(int max, int probability) {
  unsigned long long x = rand();
  int toplayer = 1;
  switch (probability) {
  case 4:
	while((x & 3) == 3){
	  toplayer += 1;
	  x >>= 2;
	}
	break;
  case 8:
	while((x & 7) == 7){
	  toplayer += 1;
	  x >>= 3;
	}
	break;
  case 16:
	while((x & 15) == 15){
	  toplayer += 1;
	  x >>= 4;
	}
	break;
  case 32:
	while((x & 31) == 31){
	  toplayer += 1;
	  x >>= 5;
	}
	break;
  default:
	while((x & 1) != 0) {
	  toplayer += 1;
	  x >>= 1;
	}
	break;
  }
  if(toplayer > max)
	toplayer = max;
  return toplayer;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movl %edi, %ebx
callq 0x1040
cltq
addl $-0x4, %r14d
roll $0x1e, %r14d
cmpl $0x7, %r14d
ja 0x13d4
leaq 0xc9c(%rip), %rcx       # 0x2004
movslq (%rcx,%r14,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
pushq $0x1
popq %r14
movl %eax, %ecx
notl %ecx
testb $0x3, %cl
jne 0x1397
incl %r14d
shrq $0x2, %rax
jmp 0x1375
incl %r14d
shrq $0x3, %rax
movl %eax, %ecx
notl %ecx
testb $0x7, %cl
je 0x1387
cmpl %ebx, %r14d
cmovll %r14d, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x1
popq %r14
movl %eax, %ecx
notl %ecx
testb $0xf, %cl
jne 0x1397
incl %r14d
shrq $0x4, %rax
jmp 0x13ac
pushq $0x1
popq %r14
movl %eax, %ecx
notl %ecx
testb $0x1f, %cl
jne 0x1397
incl %r14d
shrq $0x5, %rax
jmp 0x13c2
pushq $0x1
popq %r14
testb $0x1, %al
je 0x1397
incl %r14d
shrq %rax
jmp 0x13d8
// File: /workspace/github_cpp_makefile_star2_O2/narula[P]skiplists/skiplist.cc
// Function: SkipList::findNode(int, node**, node**)
int SkipList::findNode(int key, node* preds[], node* succs[]) {
  int lFound = -1;
  node* pred = head;
  inc();
  for (int level = pred->topLevel-1; level >= 0; level--) {
	node* curr = pred->nexts[level].nxt;
	while (key > pred->nexts[level].prefix) {
	  pred = curr; 
	  curr = pred->nexts[level].nxt;
	  inc();
	}
	if (lFound == -1 && key == pred->nexts[level].prefix) {
	  lFound = level;
	}
	preds[level] = pred;
	succs[level] = curr;
  }
  return lFound;
}

// Assembly:
movq (%rdi), %r10
movl 0x1c(%rdi), %r8d
movl 0x18(%rdi), %r9d
cmpl $0x1, %r8d
jne 0x13fc
incl %r9d
movl %r9d, 0x18(%rdi)
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl 0x4(%r10), %r11d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testl %r11d, %r11d
jle 0x1468
decq %r11
movl %r11d, %r14d
movq %r14, %r15
shlq $0x4, %r15
movq 0x10(%r10,%r15), %r12
movq %r10, %r13
movq %r12, %r10
cmpl %esi, 0x8(%r13,%r15)
jge 0x144f
movq 0x10(%r10,%r15), %r12
movq %r10, %r13
cmpl $0x1, %r8d
jne 0x142e
incl %r9d
movl %r9d, 0x18(%rdi)
jmp 0x142b
movl %ebx, %ebp
cmovel %r11d, %ebp
cmpl $-0x1, %eax
cmovel %ebp, %eax
movq %r13, (%rdx,%r14,8)
movq %r10, (%rcx,%r14,8)
movq %r13, %r10
jmp 0x1414
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/narula[P]skiplists/skiplist.cc
// Function: SkipList::insert(int)
int SkipList::insert(int key) {
  node *preds[max_level], *succs[max_level];
  int lFound = findNode(key, preds, succs);
  if (lFound != -1) {
	node* found = succs[lFound];
	return 0;
  }
  node* add = new node();
  add->key = key;
  int topLevel = randomLevel(max_level, probability);
  add->topLevel = topLevel;
  for (int i = 0; i < topLevel; i++) {
	add->nn(i)->nxt = succs[i];
	add->nn(i)->prefix = succs[i]->key;
	preds[i]->nn(i)->nxt = add;
	preds[i]->nn(i)->prefix = key;
  }
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r12
movl 0x14(%rdi), %eax
movq %rsp, %r14
leaq 0xf(,%rax,8), %rax
andq $-0x10, %rax
subq %rax, %r14
movq %r14, %rsp
movq %rsp, %r15
subq %rax, %r15
movq %r15, %rsp
movq %r14, %rdx
movq %r15, %rcx
callq 0x13e4
movl %eax, %ecx
xorl %eax, %eax
cmpl $-0x1, %ecx
je 0x14cb
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x148, %edi            # imm = 0x148
callq 0x10a0
movq %rax, %r13
movq %r12, -0x30(%rbp)
xorl %r12d, %r12d
movl $0x148, %edx            # imm = 0x148
movq %rax, %rdi
xorl %esi, %esi
callq 0x1050
movl %ebx, (%r13)
movq -0x30(%rbp), %rax
movl 0x10(%rax), %esi
movl 0x14(%rax), %edi
callq 0x1343
movl %eax, %ecx
movl %eax, 0x4(%r13)
testl %eax, %eax
cmovlel %r12d, %ecx
shlq $0x3, %rcx
pushq $0x1
popq %rax
cmpq %r12, %rcx
je 0x14bc
movq (%r15,%r12), %rdx
movq %rdx, 0x10(%r13,%r12,2)
movl (%rdx), %edx
movl %edx, 0x8(%r13,%r12,2)
movq (%r14,%r12), %rdx
movq %r13, 0x10(%rdx,%r12,2)
movl %ebx, 0x8(%rdx,%r12,2)
addq $0x8, %r12
jmp 0x1514
nop
// File: /workspace/github_cpp_makefile_star2_O2/narula[P]skiplists/skiplist.cc
// Function: SkipList::print_skiplist()
void SkipList::print_skiplist() {
  node* ptr = head;
  int i = 0;
  while (ptr != 0) {
	printf("[N:%04d K:%04d ML:%d]  ", i, ptr->key, ptr->topLevel);
	i++;
	ptr = ptr->nn(i)->nxt;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x20
popq %r15
leaq 0xad1(%rip), %r14       # 0x2024
xorl %ebp, %ebp
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x1579
movl (%rbx), %edx
movl 0x4(%rbx), %ecx
movq %r14, %rdi
movl %ebp, %esi
xorl %eax, %eax
callq 0x1030
incl %ebp
addq %r15, %rbx
addq $0x10, %r15
jmp 0x1555
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/narula[P]skiplists/skiplist.cc
// Function: SkipList::pretty_print_skiplist()
void SkipList::pretty_print_skiplist() {
  node* ptr = head;
  while (ptr != 0) {
	if (ptr != head) {
	  for (int i = 0; i < ptr->topLevel; i++) {
		printf("   V   ");
	  }
	  for (int i = ptr->topLevel; i < max_level; i++) {
		printf("   |   ");
	  }
	}
	printf("\n");
	if (ptr == tail) {
	  for (int i = 0; i < max_level; i++) {
		printf("[K:ND] ");
	  }
	  printf("\n");
	  return;
	}
	for (int i = 0; i < ptr->topLevel; i++) {
	  printf("[K:%02d] ", ptr->key);
	}
	for (int i = ptr->topLevel; i < max_level; i++) {
	  printf("   |   ");
	}
	printf("\n");
	for (int i = 0; i < ptr->topLevel; i++) {
	  if (ptr->nn(i)->prefix == INT_MAX) {
		printf("[P:ND] ");
	  } else {
		printf("[P:%02d] ", ptr->nn(i)->prefix);
	  }
	}
	for (int i = ptr->topLevel; i < max_level; i++) {
	  printf("   |   ");
	}
	printf("\n");
	for (int i = 0; i < max_level; i++) {
	  printf("   |   ");
	}
	printf ("\n");
	ptr = ptr->nn(0)->nxt;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
pushq $0xa
popq %r13
leaq 0xaa7(%rip), %r15       # 0x2044
movq %rdi, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x16bd
cmpq (%r12), %rbx
je 0x15e3
xorl %r14d, %r14d
movl 0x4(%rbx), %ebp
cmpl %ebp, %r14d
jge 0x15dc
leaq 0xa78(%rip), %rdi       # 0x203c
xorl %eax, %eax
callq 0x1030
incl %r14d
jmp 0x15b5
movq %r15, %rdi
xorl %eax, %eax
callq 0x1030
incl %ebp
cmpl 0x14(%r12), %ebp
jl 0x15d0
movl %r13d, %edi
callq 0x10c0
cmpq 0x8(%r12), %rbx
je 0x16cc
xorl %ebp, %ebp
movl 0x4(%rbx), %r14d
cmpl %r14d, %ebp
jge 0x1622
movl (%rbx), %esi
leaq 0xa4a(%rip), %rdi       # 0x2054
xorl %eax, %eax
callq 0x1030
incl %ebp
jmp 0x15f8
movq %r15, %rdi
xorl %eax, %eax
callq 0x1030
incl %r14d
cmpl 0x14(%r12), %r14d
jl 0x1615
movl %r13d, %edi
callq 0x10c0
leaq 0x8(%rbx), %r13
xorl %ebp, %ebp
movslq 0x4(%rbx), %r14
cmpq %r14, %rbp
jge 0x1673
movl (%r13), %esi
cmpl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
jne 0x165c
leaq 0xa0b(%rip), %rdi       # 0x205e
xorl %eax, %eax
callq 0x1030
jmp 0x166a
leaq 0xa03(%rip), %rdi       # 0x2066
xorl %eax, %eax
callq 0x1030
incq %rbp
addq $0x10, %r13
jmp 0x1637
pushq $0xa
popq %r13
cmpl 0x14(%r12), %r14d
jge 0x168d
movq %r15, %rdi
xorl %eax, %eax
callq 0x1030
incl %r14d
jmp 0x1677
movl %r13d, %edi
callq 0x10c0
xorl %ebp, %ebp
cmpl 0x14(%r12), %ebp
jge 0x16ac
movq %r15, %rdi
xorl %eax, %eax
callq 0x1030
incl %ebp
jmp 0x1697
movl %r13d, %edi
callq 0x10c0
addq $0x10, %rbx
jmp 0x15a0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x979(%rip), %r14       # 0x204c
xorl %ebx, %ebx
cmpl 0x14(%r12), %ebx
jge 0x16ea
movq %r14, %rdi
xorl %eax, %eax
callq 0x1030
incl %ebx
jmp 0x16d5
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10c0
// File: /workspace/github_cpp_makefile_star2_O2/narula[P]skiplists/skiplist.cc
// Function: SkipList::init_list(int, int, int)
SkipList* SkipList::init_list(int sz, int high, int probability) {
  int maxl = floor(log(sz)/log(probability));
  SkipList* skip = new SkipList(probability, maxl);
  int count = 0;
  while (count < sz) {
	if (skip->insert(rand() % high) > 0) {
	  count++;
	}
  }
  return skip;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %r15d
movl %esi, %ebx
movl %edi, %ebp
callq 0x1b77
movsd %xmm0, 0x8(%rsp)
movl %r15d, %edi
callq 0x1b77
movsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x10f0
cvttsd2si %xmm0, %r12d
pushq $0x20
popq %rdi
callq 0x10a0
movq %rax, %r14
movq %rax, %rdi
movl %r15d, %esi
movl %r12d, %edx
callq 0x120c
xorl %r15d, %r15d
cmpl %ebp, %r15d
jge 0x1776
callq 0x1040
cltd
idivl %ebx
movq %r14, %rdi
movl %edx, %esi
callq 0x1474
addl %eax, %r15d
jmp 0x175a
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x10b0
movq %rbx, %rdi
callq 0x1100
// File: /workspace/github_cpp_makefile_star2_O2/jakubsvehla[P]hex/src/editor.cpp
// Function: Editor::~Editor()
Editor::~Editor ()
{

  delete m_CmdLineView;
  delete m_FileView;
  delete m_File;
  delete m_CmdMode;
  delete m_NormalMode;
  delete m_InsertMode;
  delete m_Config;

  endwin();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x35f5
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x3604
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x3613
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x3622
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x3631
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x3640
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8(%rbx), %rdi
pushq $0x8
popq %rsi
callq 0x3250
callq 0x32f0
popq %rbx
retq
movq %rax, %rdi
callq 0x37d6
nop
// File: /workspace/github_cpp_makefile_star2_O2/jakubsvehla[P]hex/src/editor.cpp
// Function: Editor::Init()
void Editor::Init ()
{
  // Initialize curses
  initscr(); noecho(); cbreak();

  m_Config      = new Config();
  m_Config      -> LoadFromFile(".hexrc");

  m_File        = new File();
  m_FileView    = new FileView(LINES - 1);
  m_CmdLineView = new CmdLineView();
  m_CmdMode     = new CmdMode(this);
  m_NormalMode  = new NormalMode(this);
  m_InsertMode  = new InsertMode(this);

  m_FileView    -> Configure(m_Config);

  m_Mode        = m_NormalMode;

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x3380
callq 0x32d0
callq 0x30e0
pushq $0x8
popq %rdi
callq 0x3240
movq %rax, %r14
movq %rax, %rdi
callq 0x4d60
movq %r14, 0x8(%rbx)
leaq 0x2973(%rip), %rsi      # 0x6004
movq %r14, %rdi
callq 0x4d6e
pushq $0x60
popq %rdi
callq 0x3240
movq %rax, %r14
movq %rax, %rdi
callq 0x3944
movq %r14, 0x10(%rbx)
pushq $0x60
popq %rdi
callq 0x3240
movq %rax, %r14
movq 0x58fe(%rip), %r15      # 0x8fc0
movl (%r15), %esi
decl %esi
movq %rax, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x3fb4
movq %r14, 0x18(%rbx)
pushq $0x28
popq %rdi
callq 0x3240
movq %rax, %r14
movl (%r15), %ecx
decl %ecx
pushq $0x1
popq %rsi
movq %rax, %rdi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x43cc
movq %r14, 0x20(%rbx)
pushq $0x10
popq %rdi
callq 0x3240
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4850
movq %r14, 0x38(%rbx)
pushq $0x10
popq %rdi
callq 0x3240
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4450
movq %r14, 0x30(%rbx)
pushq $0x10
popq %rdi
callq 0x3240
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4a90
movq %r14, 0x40(%rbx)
movq 0x8(%rbx), %rsi
movq 0x18(%rbx), %rdi
callq 0x3fea
movq 0x30(%rbx), %rax
movq %rax, 0x28(%rbx)
popq %rbx
popq %r14
popq %r15
retq
jmp 0x376b
jmp 0x376b
movq %rax, %rbx
pushq $0x10
jmp 0x3787
movq %rax, %rbx
pushq $0x28
jmp 0x3787
jmp 0x377b
movq %rax, %rbx
pushq $0x60
jmp 0x3787
movq %rax, %rbx
pushq $0x8
popq %rsi
movq %r14, %rdi
callq 0x3250
movq %rbx, %rdi
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O2/jakubsvehla[P]hex/src/cli.cpp
// Function: CLI::Run(int, char**)
void CLI::Run (int argc, char ** argv)
{
  Editor editor;

  if (argc < 2) Usage(EXIT_FAILURE);

  // Handle special options --help and --version
  if (strcmp(argv[1], "-h") == 0 ||
      strcmp(argv[1], "--help") == 0) Usage(EXIT_SUCCESS);

  if (strcmp(argv[1], "-v") == 0 ||
      strcmp(argv[1], "--version") == 0) Version();

  // Initialize editor
  editor.Init();

  editor.OpenFile(argv[1]);

  // Start editor
  editor.Run();

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x35e0
cmpl $0x2, %ebp
jl 0x3897
movq 0x8(%r14), %r15
movb (%r15), %bpl
cmpb $0x2d, %bpl
jne 0x3822
cmpb $0x68, 0x1(%r15)
jne 0x3822
cmpb $0x0, 0x2(%r15)
je 0x388b
leaq 0x27e2(%rip), %rsi      # 0x600b
movq %r15, %rdi
callq 0x3370
testl %eax, %eax
je 0x388b
cmpb $0x2d, %bpl
jne 0x3849
cmpb $0x76, 0x1(%r15)
jne 0x3849
cmpb $0x0, 0x2(%r15)
je 0x388f
leaq 0x27c2(%rip), %rsi      # 0x6012
movq %r15, %rdi
callq 0x3370
testl %eax, %eax
je 0x388f
movq %rsp, %rdi
callq 0x365c
movq 0x8(%r14), %rsi
movq %rsp, %rdi
callq 0x3798
movq %rsp, %rdi
callq 0x37b4
movq %rsp, %rdi
callq 0x35e2
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %esi, %esi
jmp 0x389a
movq %rbx, %rdi
callq 0x38d8
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x38b6
movq %rax, %rbx
movq %rsp, %rdi
callq 0x35e2
movq %rbx, %rdi
callq 0x3420
nop
// File: /workspace/github_cpp_makefile_star2_O2/jakubsvehla[P]hex/src/file.cpp
// Function: File::~File()
File::~File ()
{
  Byte * tmp;

  while (m_Head) {
    tmp = m_Head;
    m_Head = m_Head -> m_Next;
    delete tmp;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x50d0(%rip), %rax      # 0x8aa8
movq %rax, (%rdi)
pushq $0x18
popq %r14
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x39fa
movq 0x8(%rdi), %rax
movq %rax, 0x20(%rbx)
movq %r14, %rsi
callq 0x3250
jmp 0x39df
leaq 0x38(%rbx), %rdi
callq 0x3140
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4b60
// File: /workspace/github_cpp_makefile_star2_O2/jakubsvehla[P]hex/src/file.cpp
// Function: File::Open(char const*)
bool File::Open (const char * name)
{
  FILE * f;
  int c;

  // TODO handle errors and throw exceptions

  m_FileName = name;

  f = fopen(name, "ab+");
  fseek(f, 0, SEEK_SET);

  while ((c = fgetc(f)) != EOF)
    Ins(c);

  fclose(f);

  Seek(0);

  m_Saved = true;
  NotifyObservers();

  return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x38, %rdi
callq 0x3460
leaq 0x2731(%rip), %rsi      # 0x6173
movq %r14, %rdi
callq 0x3300
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x32b0
movq %r14, %rdi
callq 0x33d0
cmpl $-0x1, %eax
je 0x3a73
movzbl %al, %esi
movq %rbx, %rdi
callq 0x3a9e
jmp 0x3a59
movq %r14, %rdi
callq 0x3230
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3af8
movb $0x1, 0x5c(%rbx)
movq %rbx, %rdi
callq 0x4b8a
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jakubsvehla[P]hex/src/file.cpp
// Function: File::Ins(unsigned char)
void File::Ins (const unsigned char c)
{
  Byte * byte = new Byte(c);

  if (m_Mark == m_Head) {
    byte -> m_Next = m_Mark;

    m_Mark -> m_Prev = byte;
    m_Head = byte;
  }
  else {
    byte -> m_Next = m_Mark;
    byte -> m_Prev = m_Mark -> m_Prev;

    byte -> m_Next -> m_Prev = byte;
    byte -> m_Prev -> m_Next = byte;
  }

  m_Version ++;
  m_Saved = false;
  NotifyObservers();
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
pushq $0x18
popq %rdi
callq 0x3240
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movb %bpl, (%rax)
movq 0x30(%rbx), %rdx
cmpq 0x20(%rbx), %rdx
movq %rdx, 0x8(%rax)
je 0x3ad8
movq 0x10(%rdx), %rcx
movq %rcx, 0x10(%rax)
movq %rax, 0x10(%rdx)
addq $0x8, %rcx
jmp 0x3ae0
leaq 0x20(%rbx), %rcx
movq %rax, 0x10(%rdx)
movq %rax, (%rcx)
incl 0x58(%rbx)
movb $0x0, 0x5c(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4b8a
// File: /workspace/github_cpp_makefile_star2_O2/jakubsvehla[P]hex/src/file.cpp
// Function: File::Seek(int, int)
bool File::Seek (int offset, int whence)
{
  int    i;
  Byte * tmp;

  tmp = m_Mark;

  if (whence == SEEK_SET) {
    m_Mark = m_Head;
  }

  for (i = 0; i < abs(offset); i ++) {

    if (offset < 0) {
      m_Mark = m_Mark -> m_Prev;
    }
    else {
      m_Mark = m_Mark -> m_Next;
    }

    if (m_Mark == NULL) {
      m_Mark = tmp;
      return false;
    }
  }

  NotifyObservers();

  return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x30(%rdi), %rax
movq %rax, %rcx
testl %edx, %edx
jne 0x3b0f
movq 0x20(%rdi), %rcx
movq %rcx, 0x30(%rdi)
movl %esi, %ebx
negl %ebx
cmovsl %esi, %ebx
shrl $0x1f, %esi
leaq 0x8(,%rsi,8), %rdx
xorl %esi, %esi
movl %esi, %r14d
cmpl %esi, %ebx
je 0x3b41
movq (%rcx,%rdx), %rcx
movq %rcx, 0x30(%rdi)
leal 0x1(%r14), %esi
testq %rcx, %rcx
jne 0x3b23
movq %rax, 0x30(%rdi)
jmp 0x3b46
callq 0x4b8a
cmpl %ebx, %r14d
setae %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/jakubsvehla[P]hex/src/file.cpp
// Function: File::Save()
bool File::Save ()
{
  FILE * f;
  unsigned char c;
  int pos;

  pos = Tell();

  // TODO handle errors and throw exceptions

  if (m_FileName.empty()) return false;

  f = fopen(m_FileName.c_str(), "wb");

  Seek(0);
  while (!Eof()) {
    Get(c);
    fputc(c, f);
  }

  fclose(f);

  m_Saved = true;

  Seek(pos, SEEK_SET);

  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x3be6
movq 0x40(%rbx), %r12
testq %r12, %r12
je 0x3bd3
movl %eax, %ebp
movq 0x38(%rbx), %rdi
leaq 0x25f9(%rip), %rsi      # 0x6177
callq 0x3300
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3af8
leaq 0xf(%rsp), %r15
movq 0x30(%rbx), %rax
cmpq 0x28(%rbx), %rax
je 0x3bbb
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3c0e
movzbl 0xf(%rsp), %edi
movq %r14, %rsi
callq 0x3340
jmp 0x3b97
movq %r14, %rdi
callq 0x3230
movb $0x1, 0x5c(%rbx)
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x3af8
testq %r12, %r12
setne %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jakubsvehla[P]hex/src/file.cpp
// Function: File::Tell() const
int File::Tell () const
{
  int i;
  Byte * tmp = m_Head;

  for (i = 0; tmp != m_Mark; i ++) {
    tmp = tmp -> m_Next;
  }

  return i;
}

// Assembly:
movq 0x30(%rdi), %rcx
addq $0x20, %rdi
xorl %eax, %eax
movq (%rdi), %rdi
cmpq %rcx, %rdi
je 0x3c00
addq $0x8, %rdi
incl %eax
jmp 0x3bf0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jakubsvehla[P]hex/src/file.cpp
// Function: File::Put(unsigned char)
bool File::Eof (void) const
{
  if (m_Mark == m_Tail) {
    return true;
  } else {
    return false;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x28(%rdi), %rbx
movq 0x30(%rdi), %r14
cmpq %rbx, %r14
je 0x3d0a
movb %sil, (%r14)
movq 0x8(%r14), %rax
movq %rax, 0x30(%rdi)
incl 0x58(%rdi)
movb $0x0, 0x5c(%rdi)
callq 0x4b8a
cmpq %rbx, %r14
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/jakubsvehla[P]hex/src/file.cpp
// Function: File::Del()
void File::Del (void)
{
  Byte * tmp;

  if (Eof()) {
    return;
  }

  tmp = m_Mark;
  m_Mark = m_Mark -> m_Next;

  if (tmp == m_Head) {
    m_Head = m_Head -> m_Next;
    m_Head -> m_Prev = NULL;
    delete tmp;
  }
  else {
    tmp -> m_Prev -> m_Next = tmp -> m_Next;
    tmp -> m_Next -> m_Prev = tmp -> m_Prev;
    delete tmp;
  }

  m_Version ++;
  m_Saved = false;
  NotifyObservers();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
cmpq 0x28(%rbx), %rdi
je 0x3c71
movq 0x8(%rdi), %rax
movq %rax, 0x30(%rbx)
movq 0x20(%rbx), %rcx
cmpq %rcx, %rdi
je 0x3c73
movq 0x10(%rdi), %rcx
movq %rax, 0x8(%rcx)
movq 0x8(%rdi), %rax
jmp 0x3c7d
popq %rbx
retq
movq 0x8(%rcx), %rax
movq %rax, 0x20(%rbx)
xorl %ecx, %ecx
movq %rcx, 0x10(%rax)
pushq $0x18
popq %rsi
callq 0x3250
incl 0x58(%rbx)
movb $0x0, 0x5c(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x4b8a
nop
// File: /workspace/github_cpp_makefile_star2_O2/jakubsvehla[P]hex/src/file.cpp
// Function: File::Read(int, int, unsigned char*) const
int File::Read (int offset, int n, unsigned char * buffer) const
{
  Byte  * tmp;
  int     i;

  tmp = m_Head;

  for (i = 0; i < offset; i ++) {
    if (tmp == m_Tail) return 0;
    tmp = tmp -> m_Next;
  }

  for (i = 0; i < n; i ++) {
    if (tmp == m_Tail) break;
    buffer[i] = tmp -> m_Val;
    tmp = tmp -> m_Next;
  }

  return i;
}

// Assembly:
leaq 0x20(%rdi), %r8
movq 0x28(%rdi), %r9
xorl %eax, %eax
testl %esi, %esi
cmovgl %esi, %eax
movq (%r8), %r8
subl $0x1, %eax
jb 0x3cbc
cmpq %r9, %r8
je 0x3cdf
addq $0x8, %r8
jmp 0x3ca9
movslq %edx, %rdx
xorl %eax, %eax
cmpq %rdx, %rax
jge 0x3ce1
cmpq %r9, %r8
je 0x3ce1
movb (%r8), %sil
movb %sil, (%rcx,%rax)
movq 0x8(%r8), %r8
incq %rax
movq 0x28(%rdi), %r9
jmp 0x3cc1
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/jakubsvehla[P]hex/src/window.cpp
// Function: Window::Window(int, int, int, int)
Window::Window (int lines, int cols, int y0, int x0)
{
  m_Win = newwin(lines, cols, y0, x0);
  m_Y0 = y0;
  m_X0 = x0;
  getmaxyx(m_Win, m_Height, m_Width);

  keypad(m_Win, TRUE);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdi, %rbx
leaq 0x4da4(%rip), %rax      # 0x8ae0
movq %rax, (%rdi)
movl %esi, %edi
movl %edx, %esi
movl %ecx, %edx
movl %r8d, %ecx
callq 0x3280
movq %rax, 0x18(%rbx)
movl %r14d, 0x10(%rbx)
movl %ebp, 0x14(%rbx)
testq %rax, %rax
je 0x3d76
movd 0x4(%rax), %xmm0
pshuflw $0x60, %xmm0, %xmm0     # xmm0 = xmm0[0,0,2,1,4,5,6,7]
psrad $0x10, %xmm0
pcmpeqd %xmm1, %xmm1
psubd %xmm1, %xmm0
jmp 0x3d7a
pcmpeqd %xmm0, %xmm0
movq %xmm0, 0x8(%rbx)
pushq $0x1
popq %rsi
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3110
// File: /workspace/github_cpp_makefile_star2_O2/jakubsvehla[P]hex/src/window.cpp
// Function: Window::GetHex(int&) const
bool Window::GetHex (int & c) const
{
  stringstream buffer;
  int x;
  int i;

  for (i = 0; i < 2; i ++) {
    Get(x);
    if (x == ESC) return false;
    if (isxdigit(x)) {
      buffer << hex << (char) x;
    }
    else {
      throw NotHexadecimalValue();
    }    
  }

  buffer >> hex >> c;

  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %rdi
callq 0x3190
xorl %r13d, %r13d
leaq 0x20(%rsp), %r15
leaq 0xc(%rsp), %r12
cmpl $0x2, %r13d
je 0x3ef1
movq %r14, %rdi
movq %r12, %rsi
callq 0x3e5e
movl 0xc(%rsp), %ebp
cmpl $0x1b, %ebp
je 0x3f13
movl %ebp, %edi
callq 0x30a0
testl %eax, %eax
je 0x3f38
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rax
movl 0x38(%rsp,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x38(%rsp,%rax)
movsbl %bpl, %esi
movq %r15, %rdi
callq 0x32e0
incl %r13d
jmp 0x3ea4
leaq 0x10(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl 0x28(%rsp,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x28(%rsp,%rax)
movq %rbx, %rsi
callq 0x3180
cmpl $0x2, %r13d
setae %bl
leaq 0x10(%rsp), %rdi
callq 0x31b0
movl %ebx, %eax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
popq %rdi
callq 0x3160
leaq 0x4bb9(%rip), %rsi      # 0x8b00
movq %rax, %rdi
xorl %edx, %edx
callq 0x3410
jmp 0x3f53
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x31b0
movq %rbx, %rdi
callq 0x3420
// File: /workspace/github_cpp_makefile_star2_O2/jakubsvehla[P]hex/src/file_view.cpp
// Function: FileView::FileView(int, int, int, int)
FileView::FileView (int lines, int cols, int y0, int x0)
: View (lines, cols, y0, x0)
{
  m_Offset = 0; // FIXME: rename offset to base

  m_File = NULL;
  m_FileVersion = 0;

  Configure();

}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x3f8c
leaq 0x4bec(%rip), %rax      # 0x8bb0
movq %rax, (%rbx)
leaq 0x4c12(%rip), %rax      # 0x8be0
movq %rax, 0x20(%rbx)
andl $0x0, 0x30(%rbx)
andq $0x0, 0x50(%rbx)
andl $0x0, 0x58(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
jmp 0x3fea
// File: /workspace/github_cpp_makefile_star2_O2/jakubsvehla[P]hex/src/file_view.cpp
// Function: FileView::Configure(Config*)
void FileView::Configure (Config * config)
{

  if (config != NULL) {
    m_ShowNums      = config -> m_Number;
    m_ShowASCII     = config -> m_ShowASCII;
    m_BlockSize     = config -> m_Group;
  }
  else {
    m_ShowNums      = true;
    m_ShowASCII     = true;
    m_BlockSize     = 4; // block size is 4 bytes by default    
  }

  if (m_ShowNums)
    m_HexOffset     = 10;
  else
    m_HexOffset     = 0;

  m_BlockCnt        = CalculateBlockCnt();

  m_BytesPerLine    = m_BlockSize * m_BlockCnt;
  m_BytesPerScreen  = m_BytesPerLine * m_Height;

  m_ASCIIOffset     = m_Width - m_BytesPerLine;

}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0x4012
movb (%rsi), %al
movb 0x1(%rsi), %cl
movl 0x4(%rsi), %ebp
movb %al, 0x3c(%rbx)
movb %cl, 0x44(%rbx)
movl %ebp, 0x2c(%rbx)
xorl %ecx, %ecx
testb %al, %al
pushq $0xa
popq %rax
cmovel %ecx, %eax
jmp 0x4027
movb $0x1, %al
movb %al, 0x3c(%rbx)
movb %al, 0x44(%rbx)
movl $0x4, 0x2c(%rbx)
pushq $0xa
popq %rax
pushq $0x4
popq %rbp
movl %eax, 0x40(%rbx)
movq %rbx, %rdi
callq 0x4070
movl %eax, 0x28(%rbx)
imull %eax, %ebp
movl %ebp, 0x38(%rbx)
movl 0x8(%rbx), %eax
imull %ebp, %eax
movl %eax, 0x34(%rbx)
movl 0xc(%rbx), %eax
subl %ebp, %eax
movl %eax, 0x48(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jakubsvehla[P]hex/src/file_view.cpp
// Function: FileView::Notify(Subject*)
void FileView::Notify (Subject * s)
{
  int pos;

  if (typeid(*s) == typeid(File)) {
    pos = m_File -> Tell();

    if (m_File -> Version() > m_FileVersion ||
        pos < m_Offset ||
        pos >= m_Offset + m_BytesPerScreen)
      Render();

    else
      MoveCursor(pos);
  }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x4125
movq %rdi, %rbx
movq (%rsi), %rax
movq -0x8(%rax), %rdi
leaq 0x49e9(%rip), %rsi      # 0x8ab8
callq 0x43a2
testb %al, %al
je 0x410f
movq 0x50(%rbx), %rdi
callq 0x3be6
movl %eax, %ebp
movq 0x50(%rbx), %rdi
callq 0x3d1e
cmpl 0x58(%rbx), %eax
jg 0x4116
movl 0x30(%rbx), %eax
cmpl %eax, %ebp
jl 0x4116
addl 0x34(%rbx), %eax
cmpl %eax, %ebp
jge 0x4116
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x412a
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq (%rbx), %rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *0x10(%rax)
callq 0x32a0
// File: /workspace/github_cpp_makefile_star2_O2/jakubsvehla[P]hex/src/file_view.cpp
// Function: FileView::Render()
void FileView::Render ()
{
  int     pos;
  int     size;
  unsigned char  * buffer;

  // FIXME: check if file is not NULL

  // Get the position of the cursor in the file
  pos = m_File -> Tell();

  Scroll(pos);

  buffer = new unsigned char [m_BytesPerScreen];
  size = m_File -> Read(m_Offset, m_BytesPerScreen, buffer);

  Erase();

  // Render line numbers
  if (m_ShowNums)
    RenderLineNums();

  // Render hexadecimal
  RenderHexadecimal(buffer, size);

  // Render ASCII
  if (m_ShowASCII)
    RenderASCII(buffer, size);

  // Place the cursor at the right place
  MoveCursor(pos);

  // Refresh the screen
  Refresh();

  // Deallocate the buffer
  delete [] buffer;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x50(%rdi), %rdi
callq 0x3be6
movl %eax, %ebp
movq %rbx, %rdi
movl %eax, %esi
callq 0x41f6
movl 0x34(%rbx), %eax
movslq %eax, %r15
movq %r15, %rdi
callq 0x3030
movq %rax, %r14
movq 0x50(%rbx), %rdi
movl 0x30(%rbx), %esi
movl %r15d, %edx
movq %rax, %rcx
callq 0x3c9a
movl %eax, %r15d
movq %rbx, %rdi
callq 0x3f7c
cmpb $0x1, 0x3c(%rbx)
jne 0x41af
movq %rbx, %rdi
callq 0x4224
movq %rbx, %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x4264
cmpb $0x1, 0x44(%rbx)
jne 0x41d1
movq %rbx, %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x42fa
movq %rbx, %rdi
movl %ebp, %esi
callq 0x412a
movq %rbx, %rdi
callq 0x3f72
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3350
nop