LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Alcaro[P]bridges/./arlib/argparse.h
// Function: argparse::add(char, cstring, bool*)
arg_bool& add(char sname, cstring name, bool* target)
	{
		arg_bool* arg = new arg_bool(target);
		arg->name = name;
		arg->sname = sname;
		m_args.append_take(*arg);
		return *arg;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %sil, %al
movq %rdx, -0x30(%rbp)
movq %rcx, -0x28(%rbp)
movq %rdi, -0x38(%rbp)
movb %al, -0x39(%rbp)
movq %r8, -0x48(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0x28, %edi
callq 0x4340
movq %rax, %rdi
movq %rdi, -0x60(%rbp)
movq -0x48(%rbp), %rsi
callq 0x5bb40
movq -0x60(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xa370
movq -0x58(%rbp), %rdi
movb -0x39(%rbp), %cl
movq -0x50(%rbp), %rax
movb %cl, 0x18(%rax)
addq $0x10, %rdi
movq -0x50(%rbp), %rsi
callq 0x5bb90
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Alcaro[P]bridges/./arlib/os.h
// Function: benchmark::next_cycle()
bool next_cycle()
	{
		uint32_t us_actual = t.us();
		if (us_actual > us)
		{
			us = us_actual;
			return false;
		}
		return true;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x5c120
movq -0x20(%rbp), %rcx
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0xc(%rcx), %eax
jbe 0x5c108
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0xc(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x5c10c
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Alcaro[P]bridges/arlib/deps/miniz.c
// Function: tdefl_flush_output_buffer
static tdefl_status tdefl_flush_output_buffer(tdefl_compressor *d)
{
  if (d->m_pIn_buf_size)
  {
    *d->m_pIn_buf_size = d->m_pSrc - (const mz_uint8 *)d->m_pIn_buf;
  }

  if (d->m_pOut_buf_size)
  {
    size_t n = MZ_MIN(*d->m_pOut_buf_size - d->m_out_buf_ofs, d->m_output_flush_remaining);
    memcpy((mz_uint8 *)d->m_pOut_buf + d->m_out_buf_ofs, d->m_output_buf + d->m_output_flush_ofs, n);
    d->m_output_flush_ofs += (mz_uint)n;
    d->m_output_flush_remaining -= (mz_uint)n;
    d->m_out_buf_ofs += n;

    *d->m_pOut_buf_size = d->m_out_buf_ofs;
  }

  return (d->m_finished && !d->m_output_flush_remaining) ? TDEFL_STATUS_DONE : TDEFL_STATUS_OKAY;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x98(%rax)
je 0x5ca91
movq -0x8(%rbp), %rax
movq 0xb0(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rax
subq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x98(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0xa0(%rax)
je 0x5cb7f
movq -0x8(%rbp), %rax
movq 0xa0(%rax), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
subq 0xc0(%rcx), %rax
movq -0x8(%rbp), %rcx
movl 0x74(%rcx), %ecx
cmpq %rcx, %rax
jae 0x5cae7
movq -0x8(%rbp), %rax
movq 0xa0(%rax), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
subq 0xc0(%rcx), %rax
movq %rax, -0x18(%rbp)
jmp 0x5caf2
movq -0x8(%rbp), %rax
movl 0x74(%rax), %eax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rdi
movq -0x8(%rbp), %rax
addq 0xc0(%rax), %rdi
movq -0x8(%rbp), %rsi
addq $0x392aa, %rsi          # imm = 0x392AA
movq -0x8(%rbp), %rax
movl 0x70(%rax), %eax
addq %rax, %rsi
movq -0x10(%rbp), %rdx
callq 0x4280
movq -0x10(%rbp), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
addl 0x70(%rax), %ecx
movl %ecx, 0x70(%rax)
movq -0x10(%rbp), %rax
movl %eax, %edx
movq -0x8(%rbp), %rax
movl 0x74(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x74(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
addq 0xc0(%rax), %rcx
movq %rcx, 0xc0(%rax)
movq -0x8(%rbp), %rax
movq 0xc0(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0xa0(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpl $0x0, 0x78(%rcx)
movb %al, -0x19(%rbp)
je 0x5cb9e
movq -0x8(%rbp), %rax
cmpl $0x0, 0x74(%rax)
setne %al
xorb $-0x1, %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Alcaro[P]bridges/arlib/deps/miniz.c
// Function: tdefl_compress_mem_to_output
mz_bool tdefl_compress_mem_to_output(const void *pBuf, size_t buf_len, tdefl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags)
{
  tdefl_compressor *pComp; mz_bool succeeded; if (((buf_len) && (!pBuf)) || (!pPut_buf_func)) return MZ_FALSE;
  pComp = (tdefl_compressor*)MZ_MALLOC(sizeof(tdefl_compressor)); if (!pComp) return MZ_FALSE;
  succeeded = (tdefl_init(pComp, pPut_buf_func, pPut_buf_user, flags) == TDEFL_STATUS_OKAY);
  succeeded = succeeded && (tdefl_compress_buffer(pComp, pBuf, buf_len, TDEFL_FINISH) == TDEFL_STATUS_DONE);
  MZ_FREE(pComp); return succeeded;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6000a
cmpq $0x0, -0x10(%rbp)
je 0x60011
cmpq $0x0, -0x20(%rbp)
jne 0x6001d
movl $0x0, -0x4(%rbp)
jmp 0x600a1
movl $0x4df78, %edi          # imm = 0x4DF78
callq 0x4480
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x6003b
movl $0x0, -0x4(%rbp)
jmp 0x600a1
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl -0x2c(%rbp), %ecx
callq 0x5fd10
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x3c(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x3c(%rbp)
movb %al, -0x3d(%rbp)
je 0x60087
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x4, %ecx
callq 0x5fca0
cmpl $0x1, %eax
sete %al
movb %al, -0x3d(%rbp)
movb -0x3d(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x3c(%rbp)
movq -0x38(%rbp), %rdi
callq 0x4420
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Alcaro[P]bridges/arlib/deps/miniz.c
// Function: tdefl_compress_mem_to_heap
void *tdefl_compress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags)
{
  tdefl_output_buffer out_buf; MZ_CLEAR_OBJ(out_buf);
  if (!pOut_len) return MZ_FALSE; else *pOut_len = 0;
  out_buf.m_expandable = MZ_TRUE;
  if (!tdefl_compress_mem_to_output(pSrc_buf, src_buf_len, tdefl_output_buffer_putter, &out_buf, flags)) return NULL;
  *pOut_len = out_buf.m_size; return out_buf.m_pBuf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x4170
cmpq $0x0, -0x20(%rbp)
jne 0x600e8
movq $0x0, -0x8(%rbp)
jmp 0x60138
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movl $0x1, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x24(%rbp), %r8d
leaq 0x43(%rip), %rdx        # 0x60150
leaq -0x48(%rbp), %rcx
callq 0x5ffe0
cmpl $0x0, %eax
jne 0x60125
movq $0x0, -0x8(%rbp)
jmp 0x60138
movq -0x48(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Alcaro[P]bridges/arlib/deps/miniz.c
// Function: tdefl_output_buffer_putter
static mz_bool tdefl_output_buffer_putter(const void *pBuf, int len, void *pUser)
{
  tdefl_output_buffer *p = (tdefl_output_buffer *)pUser;
  size_t new_size = p->m_size + len;
  if (new_size > p->m_capacity)
  {
    size_t new_capacity = p->m_capacity; mz_uint8 *pNew_buf; if (!p->m_expandable) return MZ_FALSE;
    do { new_capacity = MZ_MAX(128U, new_capacity << 1U); } while (new_size > new_capacity);
    pNew_buf = (mz_uint8*)MZ_REALLOC(p->m_pBuf, new_capacity); if (!pNew_buf) return MZ_FALSE;
    p->m_pBuf = pNew_buf; p->m_capacity = new_capacity;
  }
  memcpy((mz_uint8*)p->m_pBuf + p->m_size, pBuf, len); p->m_size = new_size;
  return MZ_TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x60229
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x601b1
movl $0x0, -0x4(%rbp)
jmp 0x60257
jmp 0x601b3
movq -0x38(%rbp), %rcx
shlq %rcx
movl $0x80, %eax
cmpq %rcx, %rax
jbe 0x601cf
movl $0x80, %eax
movq %rax, -0x48(%rbp)
jmp 0x601da
movq -0x38(%rbp), %rax
shlq %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
ja 0x601b3
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x38(%rbp), %rsi
callq 0x4600
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x60211
movl $0x0, -0x4(%rbp)
jmp 0x60257
movq -0x40(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x28(%rbp), %rax
addq (%rax), %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x4280
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
// File: Alcaro[P]bridges/arlib/deps/miniz.c
// Function: tdefl_compress_mem_to_mem
size_t tdefl_compress_mem_to_mem(void *pOut_buf, size_t out_buf_len, const void *pSrc_buf, size_t src_buf_len, int flags)
{
  tdefl_output_buffer out_buf; MZ_CLEAR_OBJ(out_buf);
  if (!pOut_buf) return 0;
  out_buf.m_pBuf = (mz_uint8*)pOut_buf; out_buf.m_capacity = out_buf_len;
  if (!tdefl_compress_mem_to_output(pSrc_buf, src_buf_len, tdefl_output_buffer_putter, &out_buf, flags)) return 0;
  return out_buf.m_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x4170
cmpq $0x0, -0x10(%rbp)
jne 0x6029d
movq $0x0, -0x8(%rbp)
jmp 0x602e0
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x2c(%rbp), %r8d
leaq -0x170(%rip), %rdx      # 0x60150
leaq -0x50(%rbp), %rcx
callq 0x5ffe0
cmpl $0x0, %eax
jne 0x602d8
movq $0x0, -0x8(%rbp)
jmp 0x602e0
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Alcaro[P]bridges/arlib/deps/miniz.c
// Function: tdefl_compress_block
static mz_bool tdefl_compress_block(tdefl_compressor *d, mz_bool static_block)
{
  if (static_block)
    tdefl_start_static_block(d);
  else
    tdefl_start_dynamic_block(d);
  return tdefl_compress_lz_codes(d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x60310
movq -0x8(%rbp), %rdi
callq 0x60330
jmp 0x60319
movq -0x8(%rbp), %rdi
callq 0x60510
movq -0x8(%rbp), %rdi
callq 0x614a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Alcaro[P]bridges/arlib/deps/miniz.c
// Function: tdefl_start_static_block
static void tdefl_start_static_block(tdefl_compressor *d)
{
  mz_uint i;
  mz_uint8 *p = &d->m_huff_code_sizes[0][0];

  for (i = 0; i <= 143; ++i) *p++ = 8;
  for ( ; i <= 255; ++i) *p++ = 9;
  for ( ; i <= 279; ++i) *p++ = 7;
  for ( ; i <= 287; ++i) *p++ = 8;

  memset(d->m_huff_code_sizes[1], 5, 32);

  tdefl_optimize_huffman_table(d, 0, 288, 15, MZ_TRUE);
  tdefl_optimize_huffman_table(d, 1, 32, 15, MZ_TRUE);

  TDEFL_PUT_BITS(1, 2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x8f4a, %rax           # imm = 0x8F4A
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x8f, -0xc(%rbp)
ja 0x60377
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb $0x8, (%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x60351
jmp 0x60379
cmpl $0xff, -0xc(%rbp)
ja 0x6039f
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb $0x9, (%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x60379
jmp 0x603a1
cmpl $0x117, -0xc(%rbp)      # imm = 0x117
ja 0x603c7
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb $0x7, (%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x603a1
jmp 0x603c9
cmpl $0x11f, -0xc(%rbp)      # imm = 0x11F
ja 0x603ef
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb $0x8, (%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x603c9
movq -0x8(%rbp), %rdi
addq $0x8f4a, %rdi           # imm = 0x8F4A
addq $0x120, %rdi            # imm = 0x120
movl $0x5, %esi
movl $0x20, %edx
callq 0x4170
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x120, %edx            # imm = 0x120
movl $0xf, %ecx
movl $0x1, %r8d
callq 0x61bb0
movq -0x8(%rbp), %rdi
movl $0x1, %r8d
movl $0x20, %edx
movl $0xf, %ecx
movl %r8d, %esi
callq 0x61bb0
movl $0x1, -0x1c(%rbp)
movl $0x2, -0x20(%rbp)
movl -0x1c(%rbp), %eax
movl -0x20(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
ja 0x6046d
jmp 0x6048c
leaq 0xae4c(%rip), %rdi      # 0x6b2c0
leaq 0xab61(%rip), %rsi      # 0x6afdc
movl $0x227, %edx            # imm = 0x227
leaq 0xae7c(%rip), %rcx      # 0x6b303
callq 0x4200
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x5c(%rcx), %ecx
shll %cl, %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
orl 0x60(%rax), %ecx
movl %ecx, 0x60(%rax)
movl -0x20(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0x5c(%rax), %ecx
movl %ecx, 0x5c(%rax)
movq -0x8(%rbp), %rax
cmpl $0x8, 0x5c(%rax)
jb 0x60507
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x48(%rcx), %rax
jae 0x604eb
movq -0x8(%rbp), %rax
movl 0x60(%rax), %eax
movb %al, %cl
movq -0x8(%rbp), %rdx
movq 0x40(%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, 0x40(%rdx)
movb %cl, (%rax)
movq -0x8(%rbp), %rax
movl 0x60(%rax), %ecx
shrl $0x8, %ecx
movl %ecx, 0x60(%rax)
movq -0x8(%rbp), %rax
movl 0x5c(%rax), %ecx
subl $0x8, %ecx
movl %ecx, 0x5c(%rax)
jmp 0x604b1
jmp 0x60509
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Alcaro[P]bridges/arlib/deps/miniz.c
// Function: tdefl_huffman_enforce_max_code_size
static void tdefl_huffman_enforce_max_code_size(int *pNum_codes, int code_list_len, int max_code_size)
{
  int i; mz_uint32 total = 0; if (code_list_len <= 1) return;
  for (i = max_code_size + 1; i <= TDEFL_MAX_SUPPORTED_HUFF_CODESIZE; i++) pNum_codes[max_code_size] += pNum_codes[i];
  for (i = max_code_size; i > 0; i--) total += (((mz_uint32)pNum_codes[i]) << (max_code_size - i));
  while (total != (1UL << max_code_size))
  {
    pNum_codes[max_code_size]--;
    for (i = max_code_size - 1; i > 0; i--) if (pNum_codes[i]) { pNum_codes[i]--; pNum_codes[i + 1] += 2; break; }
    total--;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x1, -0xc(%rbp)
jg 0x62470
jmp 0x6255d
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x20, -0x14(%rbp)
jg 0x624a3
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
addl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x62479
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x624d3
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl -0x10(%rbp), %ecx
subl -0x14(%rbp), %ecx
shll %cl, %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x624a9
jmp 0x624d5
movl -0x18(%rbp), %eax
movl -0x10(%rbp), %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
cmpq %rcx, %rax
je 0x6255d
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $-0x1, %edx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x6254f
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x62542
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $-0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
addl $0x2, %edx
movl %edx, (%rax,%rcx,4)
jmp 0x6254f
jmp 0x62544
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x62505
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x624d5
popq %rbp
retq
// File: akojo[P]quickfind/qselect.cpp
// Function: handle_escape(Term&)
static char handle_escape(Term &tty)
{
    char ch = tty.getchar();
    if (ch != '[')  {
        return ch;
    }
    ch = tty.getchar();
    if (ch == 'A' || ch == 'D') {
        return Term::CTRL_P;
    } else if (ch == 'B' || ch == 'C') {
        return Term::CTRL_N;
    } else {
        return 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6f40
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x5b, %eax
je 0x3ca9
movb -0x11(%rbp), %al
movb %al, -0x1(%rbp)
jmp 0x3ce9
movq -0x10(%rbp), %rdi
callq 0x6f40
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x41, %eax
je 0x3cc7
movsbl -0x11(%rbp), %eax
cmpl $0x44, %eax
jne 0x3ccd
movb $0x10, -0x1(%rbp)
jmp 0x3ce9
movsbl -0x11(%rbp), %eax
cmpl $0x42, %eax
je 0x3cdf
movsbl -0x11(%rbp), %eax
cmpl $0x43, %eax
jne 0x3ce5
movb $0xe, -0x1(%rbp)
jmp 0x3ce9
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: akojo[P]quickfind/match.cpp
// Function: match(__gnu_cxx::__normal_iterator<wstr*, std::vector<wstr, std::allocator<wstr>>>, __gnu_cxx::__normal_iterator<wstr*, std::vector<wstr, std::allocator<wstr>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
vector<wstr>::iterator match(vector<wstr>::iterator begin, vector<wstr>::iterator end, const string& pattern)
{
    for_each(begin, end, [&](wstr& s) { s.score = smatch(s.str, pattern); });
    auto last = partition(begin, end, [](wstr& s) { return s.score > 0; });
    sort(begin, last);
    return last;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x5140
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x51a0
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x5470
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: akojo[P]quickfind/match.cpp
// Function: smatch(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&)
static int smatch(const string& str, const string& pat)
{
    auto score = 1, dist = 0;
    auto si = str.cbegin();
    auto pi = pat.cbegin();

    while (pi != pat.cend() && si != str.cend()) {
        if (tolower(*pi) == tolower(*si++)) {
            if (dist == 1) score++;
            pi++;
            dist = 0;
        }
        dist++;
    }
    return pi == pat.cend() ? score : 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x30e0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30e0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3060
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5510
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x51(%rbp)
jne 0x5290
jmp 0x52ad
movq -0x8(%rbp), %rdi
callq 0x3060
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x5510
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x52b6
jmp 0x5326
leaq -0x28(%rbp), %rdi
callq 0x5550
movsbl (%rax), %edi
callq 0x3360
movl %eax, -0x58(%rbp)
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x5570
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5550
movsbl (%rax), %edi
callq 0x3360
movl %eax, %ecx
movl -0x58(%rbp), %eax
cmpl %ecx, %eax
jne 0x5318
cmpl $0x1, -0x18(%rbp)
jne 0x5302
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x5570
movq %rax, -0x48(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x5268
movq -0x10(%rbp), %rdi
callq 0x3060
movq %rax, -0x50(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x55b0
testb $0x1, %al
jne 0x5346
jmp 0x534e
movl -0x14(%rbp), %eax
movl %eax, -0x5c(%rbp)
jmp 0x5355
xorl %eax, %eax
movl %eax, -0x5c(%rbp)
jmp 0x5355
movl -0x5c(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: akojo[P]quickfind/term.cpp
// Function: Term::getchar()
int Term::getchar()
{
    int i;
    i = getc(tty);
    if (i == 0)
        return -1;
    if (i < 0)
        throw runtime_error("read error");
    return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x3080
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x6f6a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6fc6
cmpl $0x0, -0x14(%rbp)
jge 0x6fc0
movl $0x10, %edi
callq 0x3110
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x1126(%rip), %rsi      # 0x80b1
callq 0x30b0
jmp 0x6f92
movq -0x30(%rbp), %rdi
movq 0x4053(%rip), %rsi      # 0xaff0
movq 0x400c(%rip), %rdx      # 0xafb0
callq 0x33c0
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x3170
jmp 0x6fcf
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x33d0
nopl (%rax,%rax)
// File: akojo[P]quickfind/prompt.cpp
// Function: Prompt::handle_key(Term::Key)
bool Prompt::handle_key(const Term::Key key)
{
    bool reset_selection = true;

    if (isprint(key)) {
        input.push_back(key);
    } else if (input.length() > 0) {
        if (key == Term::DEL || key == Term::BACKSPACE) {
            input.pop_back();
        } else if (key == Term::CTRL_U) {
            input.clear();
        }
        reset_selection = false;
    } else {
        reset_selection = false;
    }
    tty.move_to_col(1);
    tty.erase_line(Term::FORWARD);
    tty.puts(prompt + input);
    return reset_selection;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movb $0x1, -0xd(%rbp)
movl -0xc(%rbp), %edi
callq 0x33e0
cmpl $0x0, %eax
je 0x739d
movq -0x48(%rbp), %rdi
addq $0x68, %rdi
movl -0xc(%rbp), %eax
movsbl %al, %esi
callq 0x31c0
jmp 0x73ec
movq -0x48(%rbp), %rdi
addq $0x68, %rdi
callq 0x3380
cmpq $0x0, %rax
jbe 0x73e6
cmpl $0x7f, -0xc(%rbp)
je 0x73bc
cmpl $0x8, -0xc(%rbp)
jne 0x73cb
movq -0x48(%rbp), %rdi
addq $0x68, %rdi
callq 0x32c0
jmp 0x73e0
cmpl $0x15, -0xc(%rbp)
jne 0x73de
movq -0x48(%rbp), %rdi
addq $0x68, %rdi
callq 0x3310
jmp 0x73e0
movb $0x0, -0xd(%rbp)
jmp 0x73ea
movb $0x0, -0xd(%rbp)
jmp 0x73ec
movq -0x48(%rbp), %rdi
movl $0x1, %esi
callq 0x70f0
movq -0x48(%rbp), %rdi
xorl %esi, %esi
callq 0x7150
movq -0x48(%rbp), %rdx
movq %rdx, %rsi
addq $0x48, %rsi
addq $0x68, %rdx
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x74f0
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x6e90
jmp 0x7430
leaq -0x30(%rbp), %rdi
callq 0x3140
movb -0xd(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3140
movq -0x38(%rbp), %rdi
callq 0x33d0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: xzebra[P]function-plotter/main.cpp
// Function: checkError(int, int)
bool checkError(int argc, int i) {
    if(i+1 >= argc) {
        std::cout << "Args error" << std::endl;
        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
cmpl -0x8(%rbp), %eax
jl 0x2591
movq 0x9a60(%rip), %rdi      # 0xbfd0
leaq 0x5aa1(%rip), %rsi      # 0x8018
callq 0x21c0
movq %rax, %rdi
movq 0x9a32(%rip), %rsi      # 0xbfb8
callq 0x21f0
movb $0x1, -0x1(%rbp)
jmp 0x2595
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
// File: xzebra[P]function-plotter/plot.cpp
// Function: Graph::Plot(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Graph::Plot(std::string infix) {
    Operation *op = mathParser.toPostfix(infix);
    fillValues(op);
    plot();
    clearMemory();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
addq $0xf8, %rax
movq %rax, -0x60(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x20e0
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x4080
movq %rax, -0x50(%rbp)
jmp 0x2d52
leaq -0x38(%rbp), %rdi
callq 0x2130
movq -0x50(%rbp), %rax
movq -0x68(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
callq 0x2db0
movq -0x68(%rbp), %rdi
callq 0x2f50
movq -0x68(%rbp), %rdi
callq 0x32d0
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2130
movq -0x40(%rbp), %rdi
callq 0x2320
nopw %cs:(%rax,%rax)
// File: xzebra[P]function-plotter/plot.cpp
// Function: Graph::fillValues(Operation*)
void Graph::fillValues(Operation *op) {
    for(int i = 0; i < size+size+1; ++i) {
        // Give each variable a value
        for(int j = 0; j < op->v_values.size(); j++) {
            op->v_values[j] = (i - (size)) * step;
        }
        // EQUATION
        std::string postfix_replaced = replaceVars(op);
        double value = mathParser.Solve(postfix_replaced);
        /// EQUATION
        value = value/step;
        values[i] = int(round(value));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x78(%rbp), %rdx
movl -0x14(%rbp), %eax
movl (%rdx), %ecx
addl (%rdx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x2f32
movl $0x0, -0x18(%rbp)
movslq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0x3dc0
movq %rax, %rcx
movq -0x80(%rbp), %rax
cmpq %rcx, %rax
jae 0x2e52
movq -0x78(%rbp), %rax
movl -0x14(%rbp), %ecx
subl (%rax), %ecx
cvtsi2sd %ecx, %xmm0
mulsd 0x8(%rax), %xmm0
movsd %xmm0, -0x88(%rbp)
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
movslq -0x18(%rbp), %rsi
callq 0x3de0
movsd -0x88(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2def
movq -0x78(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x38(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x3ae0
movq -0x78(%rbp), %rax
movq -0x98(%rbp), %rsi
addq $0xf8, %rax
movq %rax, -0x90(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x20e0
jmp 0x2e8d
movq -0x90(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x4c20
movsd %xmm0, -0xa0(%rbp)
jmp 0x2ea7
leaq -0x60(%rbp), %rdi
callq 0x2130
movsd -0xa0(%rbp), %xmm0
movq -0x78(%rbp), %rdi
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
divsd 0x8(%rdi), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
callq 0x3a80
movq -0x78(%rbp), %rax
cvttsd2si %xmm0, %edx
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
leaq -0x38(%rbp), %rdi
callq 0x2130
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2dd2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x2f27
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x2130
leaq -0x38(%rbp), %rdi
callq 0x2130
jmp 0x2f3b
addq $0xa0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x2320
nopw %cs:(%rax,%rax)
// File: xzebra[P]function-plotter/plot.cpp
// Function: Graph::Loop(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Graph::Loop(std::string infix) {
    Operation *op = mathParser.toPostfix(infix);
    double t = 0;
    for(;;) {
        fillValues(op, t);
        plot();
        t += 0.01;
        const int t100 = t * 100;
        sleep(100);
        std::cout << "t = " << t << (t100 % 10 == 0 ? " " : "") << " s " <<  std::endl;
        cls(3);
    }
    clearMemory();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
addq $0xf8, %rax
movq %rax, -0x70(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x20e0
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x4080
movq %rax, -0x60(%rbp)
jmp 0x3345
leaq -0x38(%rbp), %rdi
callq 0x2130
movq -0x60(%rbp), %rax
movq %rax, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x78(%rbp), %rdi
movq -0x18(%rbp), %rsi
movsd -0x50(%rbp), %xmm0
callq 0x3450
movq -0x78(%rbp), %rdi
callq 0x2f50
movq -0x78(%rbp), %rdi
movsd 0x4ccb(%rip), %xmm0     # 0x8050
addsd -0x50(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd 0x4cb1(%rip), %xmm0     # 0x8048
mulsd -0x50(%rbp), %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x54(%rbp)
movl $0x64, %esi
callq 0x3660
movq 0x8c1c(%rip), %rdi      # 0xbfd0
leaq 0x4ca5(%rip), %rsi      # 0x8060
callq 0x21c0
movq %rax, %rdi
movsd -0x50(%rbp), %xmm0
callq 0x2350
movq %rax, %rdi
movl -0x54(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
leaq 0x4cac(%rip), %rsi      # 0x808e
leaq 0x4ca4(%rip), %rax      # 0x808d
cmpl $0x0, %edx
cmoveq %rax, %rsi
callq 0x21c0
movq %rax, %rdi
leaq 0x4c66(%rip), %rsi      # 0x8065
callq 0x21c0
movq %rax, %rdi
movq 0x8baa(%rip), %rsi      # 0xbfb8
callq 0x21f0
movq -0x78(%rbp), %rdi
movl $0x3, %esi
callq 0x36b0
jmp 0x335e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2130
movq -0x40(%rbp), %rdi
callq 0x2320
nopw %cs:(%rax,%rax)
// File: xzebra[P]function-plotter/plot.cpp
// Function: Graph::fillValues(Operation*, double)
void Graph::fillValues(Operation *op, double t) {
    for(int i = 0; i < size+size+1; ++i) {
        // Give each variable a value
        for(int j = 0; j < op->v_values.size(); j++) {
            if(op->postfix[op->v_pos[j]] == 't') op->v_values[j] = t;
            else op->v_values[j] = (i - (size)) * step;
        }
        // EQUATION
        std::string postfix_replaced = replaceVars(op);
        double value = mathParser.Solve(postfix_replaced);
        /// EQUATION
        value = value/step;
        values[i] = int(round(value));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x80(%rbp), %rdx
movl -0x1c(%rbp), %eax
movl (%rdx), %ecx
addl (%rdx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x3645
movl $0x0, -0x20(%rbp)
movslq -0x20(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0x3dc0
movq %rax, %rcx
movq -0x88(%rbp), %rax
cmpq %rcx, %rax
jae 0x3565
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
movslq -0x20(%rbp), %rsi
callq 0x3e00
movq -0x90(%rbp), %rdi
movslq (%rax), %rsi
callq 0x2380
movsbl (%rax), %eax
cmpl $0x74, %eax
jne 0x351e
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x98(%rbp)
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
movslq -0x20(%rbp), %rsi
callq 0x3de0
movsd -0x98(%rbp), %xmm0
movsd %xmm0, (%rax)
jmp 0x3555
movq -0x80(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl (%rax), %ecx
cvtsi2sd %ecx, %xmm0
mulsd 0x8(%rax), %xmm0
movsd %xmm0, -0xa0(%rbp)
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
movslq -0x20(%rbp), %rsi
callq 0x3de0
movsd -0xa0(%rbp), %xmm0
movsd %xmm0, (%rax)
jmp 0x3557
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3494
movq -0x80(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x40(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x3ae0
movq -0x80(%rbp), %rax
movq -0xb0(%rbp), %rsi
addq $0xf8, %rax
movq %rax, -0xa8(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x20e0
jmp 0x35a0
movq -0xa8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x4c20
movsd %xmm0, -0xb8(%rbp)
jmp 0x35ba
leaq -0x68(%rbp), %rdi
callq 0x2130
movsd -0xb8(%rbp), %xmm0
movq -0x80(%rbp), %rdi
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
divsd 0x8(%rdi), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
callq 0x3a80
movq -0x80(%rbp), %rax
cvttsd2si %xmm0, %edx
movq 0x10(%rax), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
leaq -0x40(%rbp), %rdi
callq 0x2130
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3477
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x363a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x2130
leaq -0x40(%rbp), %rdi
callq 0x2130
jmp 0x364e
addq $0xc0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x2320
nopw (%rax,%rax)
// File: xzebra[P]function-plotter/plot.cpp
// Function: Graph::replaceVars[abi:cxx11](Operation const*)
std::string Graph::replaceVars(const Operation *op) {
    std::ostringstream output;
    int offset = 0;
    for(int p = 0; p < op->v_pos.size(); p++) {
        // Add rest of postfix expression from last replaced var
        for(int i = offset; i < op->v_pos[p]; i++) {
            output << op->postfix[i];
        }
        output << op->v_values[p];
        offset = op->v_pos[p]+1;
    }
    // Add the rest of the string if not added
    for(int p = offset; p < op->postfix.length(); p++) {
        output << op->postfix[p];
    }
    return output.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x1c0(%rbp)
movq %rdi, %rax
movq %rax, -0x1b8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x2270
movl $0x0, -0x194(%rbp)
movl $0x0, -0x198(%rbp)
movslq -0x198(%rbp), %rax
movq %rax, -0x1c8(%rbp)
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0x3e20
movq %rax, %rcx
movq -0x1c8(%rbp), %rax
cmpq %rcx, %rax
jae 0x3c3f
movl -0x194(%rbp), %eax
movl %eax, -0x19c(%rbp)
movl -0x19c(%rbp), %eax
movl %eax, -0x1cc(%rbp)
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
movslq -0x198(%rbp), %rsi
callq 0x3e40
movq %rax, %rcx
movl -0x1cc(%rbp), %eax
cmpl (%rcx), %eax
jge 0x3be6
movq -0x18(%rbp), %rdi
movslq -0x19c(%rbp), %rsi
callq 0x2210
movsbl (%rax), %esi
leaq -0x190(%rbp), %rdi
callq 0x2220
jmp 0x3bb0
jmp 0x3bb2
movl -0x19c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x19c(%rbp)
jmp 0x3b62
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x2080
jmp 0x3cd6
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
movslq -0x198(%rbp), %rsi
callq 0x3e60
movsd (%rax), %xmm0
leaq -0x190(%rbp), %rdi
callq 0x2350
jmp 0x3c0c
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
movslq -0x198(%rbp), %rsi
callq 0x3e40
movl (%rax), %eax
addl $0x1, %eax
movl %eax, -0x194(%rbp)
movl -0x198(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x198(%rbp)
jmp 0x3b28
movl -0x194(%rbp), %eax
movl %eax, -0x1b0(%rbp)
movslq -0x1b0(%rbp), %rax
movq %rax, -0x1d8(%rbp)
movq -0x18(%rbp), %rdi
callq 0x22c0
movq %rax, %rcx
movq -0x1d8(%rbp), %rax
cmpq %rcx, %rax
jae 0x3ca5
movq -0x18(%rbp), %rdi
movslq -0x1b0(%rbp), %rsi
callq 0x2210
movsbl (%rax), %esi
leaq -0x190(%rbp), %rdi
callq 0x2220
jmp 0x3c92
jmp 0x3c94
movl -0x1b0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1b0(%rbp)
jmp 0x3c4b
movq -0x1c0(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0x21e0
jmp 0x3cba
leaq -0x190(%rbp), %rdi
callq 0x2080
movq -0x1b8(%rbp), %rax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq -0x1a8(%rbp), %rdi
callq 0x2320
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: xzebra[P]function-plotter/mathParser/mathParser.cpp
// Function: isOperator(char)
bool isOperator(const char c) {
    switch (c) {
        case '+':
        case '-':
        case '*':
        case '/':
        case '^':
        case '(':
            return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movsbl -0x2(%rbp), %eax
movl %eax, -0x8(%rbp)
subl $0x28, %eax
je 0x3ef3
jmp 0x3ec8
movl -0x8(%rbp), %eax
addl $-0x2a, %eax
subl $0x2, %eax
jb 0x3ef3
jmp 0x3ed5
movl -0x8(%rbp), %eax
subl $0x2d, %eax
je 0x3ef3
jmp 0x3edf
movl -0x8(%rbp), %eax
subl $0x2f, %eax
je 0x3ef3
jmp 0x3ee9
movl -0x8(%rbp), %eax
subl $0x5e, %eax
jne 0x3ef9
jmp 0x3ef3
movb $0x1, -0x1(%rbp)
jmp 0x3efd
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: xzebra[P]function-plotter/mathParser/mathParser.cpp
// Function: isFunc(int&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool isFunc(int &i, std::string &infix, std::string &output) {
    output = "";
    for(; i < infix.length(); i++) {
        if(!isLetter(infix[i])) {
            i--;
            break;
        }
        output += infix[i];
    }

    return output.length() > 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x412f(%rip), %rsi      # 0x808e
callq 0x2280
movq -0x8(%rbp), %rax
movslq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x22c0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x3fd8
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq (%rax), %rsi
callq 0x2380
movsbl (%rax), %edi
callq 0x3f10
testb $0x1, %al
jne 0x3fad
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
jmp 0x3fd8
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq (%rax), %rsi
callq 0x2380
movb (%rax), %al
movq -0x18(%rbp), %rdi
movsbl %al, %esi
callq 0x2140
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x3f64
movq -0x18(%rbp), %rdi
callq 0x22c0
cmpq $0x1, %rax
seta %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
// File: xzebra[P]function-plotter/mathParser/mathParser.cpp
// Function: precedence(char)
int precedence(const char c) {
    switch (c) {
        case '+':
        case '-':
            return 2;
        case '*':
        case '/':
            return 3;
        case '^':
            return 4;
        default: // functions
            return 5;           
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0x2a, %eax
je 0x4039
jmp 0x4008
movl -0xc(%rbp), %eax
subl $0x2b, %eax
je 0x4030
jmp 0x4012
movl -0xc(%rbp), %eax
subl $0x2d, %eax
je 0x4030
jmp 0x401c
movl -0xc(%rbp), %eax
subl $0x2f, %eax
je 0x4039
jmp 0x4026
movl -0xc(%rbp), %eax
subl $0x5e, %eax
je 0x4042
jmp 0x404b
movl $0x2, -0x4(%rbp)
jmp 0x4052
movl $0x3, -0x4(%rbp)
jmp 0x4052
movl $0x4, -0x4(%rbp)
jmp 0x4052
movl $0x5, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: xzebra[P]function-plotter/mathParser/stack.h
// Function: Stack<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::pop()
a_type pop() {
            a_type output = head->value;
            head = head->next;
            size--;
            return output;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movb $0x0, -0x11(%rbp)
movq (%rax), %rsi
callq 0x20e0
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq 0x20(%rcx), %rcx
movq %rcx, (%rax)
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x52d9
movq -0x30(%rbp), %rdi
callq 0x2130
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: xzebra[P]function-plotter/mathParser/stack.h
// Function: Stack<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::push(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void push(a_type input) {
            if(head == nullptr) {
                head = new Node<a_type>(input, nullptr);
                bottom = head;
            } else {
                head = new Node<a_type>(input, head);
            }  
            size++;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, (%rax)
jne 0x53ae
movl $0x28, %edi
callq 0x21d0
movq -0x78(%rbp), %rsi
movq %rax, -0x80(%rbp)
movb $0x1, -0x3d(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x20e0
jmp 0x533a
movq -0x80(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
leaq -0x30(%rbp), %rsi
callq 0x6260
jmp 0x534d
movq -0x70(%rbp), %rax
movq -0x80(%rbp), %rcx
movb $0x0, -0x3d(%rbp)
movq %rcx, (%rax)
leaq -0x30(%rbp), %rdi
callq 0x2130
movq -0x70(%rbp), %rax
movq (%rax), %rcx
movq %rcx, 0x8(%rax)
jmp 0x5441
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x5398
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2130
testb $0x1, -0x3d(%rbp)
jne 0x53a0
jmp 0x53a9
movq -0x80(%rbp), %rdi
callq 0x21b0
jmp 0x5457
movl $0x28, %edi
callq 0x21d0
movq -0x78(%rbp), %rsi
movq %rax, -0x88(%rbp)
movb $0x1, -0x61(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x20e0
jmp 0x53d2
movq -0x88(%rbp), %rdi
movq -0x70(%rbp), %rax
movq (%rax), %rdx
leaq -0x60(%rbp), %rsi
callq 0x6260
jmp 0x53eb
movq -0x70(%rbp), %rax
movq -0x88(%rbp), %rcx
movb $0x0, -0x61(%rbp)
movq %rcx, (%rax)
leaq -0x60(%rbp), %rdi
callq 0x2130
jmp 0x5441
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x542b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x2130
testb $0x1, -0x61(%rbp)
jne 0x5433
jmp 0x543f
movq -0x88(%rbp), %rdi
callq 0x21b0
jmp 0x5457
movq -0x70(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
addq $0x90, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x2320
// File: xzebra[P]function-plotter/mathParser/stack.h
// Function: Stack<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::clear()
void clear() {
            Node<a_type> *ptr = head;
            while(ptr != nullptr) {
                Node<a_type> *temp = ptr->next;
                delete[] ptr;
                ptr = temp;
            }
            size = 0;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5864
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x585a
movq -0x28(%rbp), %rcx
movq %rcx, %rax
addq $-0x8, %rax
movq %rax, -0x38(%rbp)
imulq $0x28, -0x8(%rcx), %rdx
movq %rcx, %rax
addq %rdx, %rax
cmpq %rax, %rcx
movq %rax, -0x30(%rbp)
je 0x5851
movq -0x30(%rbp), %rdi
addq $-0x28, %rdi
movq %rdi, -0x40(%rbp)
callq 0x5890
movq -0x28(%rbp), %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x30(%rbp)
jne 0x582f
movq -0x38(%rbp), %rdi
callq 0x2260
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x57eb
movq -0x20(%rbp), %rax
movl $0x0, 0x10(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: kdungs[P]codecon/src/maze.cc
// Function: main
int main() {
  auto rows = 0ul, cols = 0ul;
  std::cin >> rows >> cols;

  if (rows < 2 || cols < 2) {
    return EXIT_FAILURE;
  }

  auto map = std::vector<bool>{};
  map.reserve(rows * cols);
  char in;
  while (std::cin >> in) {
    map.push_back((in == '_'));
  }

  auto maze = Maze{rows, cols, map};
  auto path = solveBfs(maze, {1, 0}, {rows - 2, cols - 1});

  std::copy(std::begin(path), std::end(path),
            std::ostream_iterator<Point>(std::cout, "\n"));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movl $0x0, -0x4(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq 0xa4b7(%rip), %rdi      # 0xbfe0
leaq -0x10(%rbp), %rsi
callq 0x1120
movq %rax, %rdi
leaq -0x18(%rbp), %rsi
callq 0x1120
cmpq $0x2, -0x10(%rbp)
jb 0x1b4c
cmpq $0x2, -0x18(%rbp)
jae 0x1b58
movl $0x1, -0x4(%rbp)
jmp 0x1d21
xorps %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
movaps %xmm0, -0x40(%rbp)
movq $0x0, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x2a30
movq -0xf8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
imulq %rax, %rsi
callq 0x2a50
jmp 0x1b95
jmp 0x1b97
movq 0xa442(%rip), %rdi      # 0xbfe0
leaq -0x4d(%rbp), %rsi
callq 0x1110
movq %rax, -0x100(%rbp)
jmp 0x1bb0
movq -0x100(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x1100
movb %al, -0x101(%rbp)
jmp 0x1bce
movb -0x101(%rbp), %al
testb $0x1, %al
jne 0x1bda
jmp 0x1c03
movb -0x4d(%rbp), %al
subb $0x5f, %al
sete %al
movzbl %al, %esi
leaq -0x40(%rbp), %rdi
callq 0x2ab0
jmp 0x1bf0
jmp 0x1b97
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x1d5f
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2b80
jmp 0x1c25
movq $0x1, -0xb0(%rbp)
movq $0x0, -0xa8(%rbp)
movq -0x10(%rbp), %rax
addq $-0x2, %rax
movq %rax, -0xc0(%rbp)
movq -0x18(%rbp), %rax
decq %rax
movq %rax, -0xb8(%rbp)
leaq -0xa0(%rbp), %rdi
leaq -0x88(%rbp), %rsi
leaq -0xb0(%rbp), %rdx
leaq -0xc0(%rbp), %rcx
callq 0x12f0
jmp 0x1c7b
leaq -0xa0(%rbp), %rdi
callq 0x2620
movq %rax, -0x110(%rbp)
jmp 0x1c90
movq -0x110(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x29e0
movq %rax, -0x118(%rbp)
jmp 0x1cb3
movq -0x118(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq 0xa308(%rip), %rsi      # 0xbfd0
leaq 0x6345(%rip), %rdx      # 0x8014
leaq -0xe0(%rbp), %rdi
callq 0x2d80
jmp 0x1cdd
movq -0xc8(%rbp), %rsi
movq -0xd0(%rbp), %rdx
leaq -0xf0(%rbp), %rdi
leaq -0xe0(%rbp), %rcx
callq 0x2d00
jmp 0x1d00
leaq -0xa0(%rbp), %rdi
callq 0x2890
leaq -0x88(%rbp), %rdi
callq 0x2db0
leaq -0x40(%rbp), %rdi
callq 0x2a10
movl -0x4(%rbp), %eax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x1d53
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x2890
leaq -0x88(%rbp), %rdi
callq 0x2db0
leaq -0x40(%rbp), %rdi
callq 0x2a10
movq -0x48(%rbp), %rdi
callq 0x1150
nopw %cs:(%rax,%rax)