LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/whtc123[P]libuvc/coro.c
// Function: coro_stack_alloc
int
coro_stack_alloc (struct coro_stack *stack, unsigned int size)
{
  if (!size)
    size = 256 * 1024;

  stack->sptr = 0;
  stack->ssze = ((size_t)size * sizeof (void *) + PAGESIZE - 1) / PAGESIZE * PAGESIZE;

#if CORO_FIBER

  stack->sptr = (void *)stack;
  return 1;

#else

  size_t ssze = stack->ssze + CORO_GUARDPAGES * PAGESIZE;
  void *base;

  #if CORO_MMAP
    /* mmap supposedly does allocate-on-write for us */
    base = mmap (0, ssze, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

    if (base == (void *)-1)
      {
        /* some systems don't let us have executable heap */
        /* we assume they won't need executable stack in that case */
        base = mmap (0, ssze, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

        if (base == (void *)-1)
          return 0;
      }

    #if CORO_GUARDPAGES
      mprotect (base, CORO_GUARDPAGES * PAGESIZE, PROT_NONE);
    #endif

    base = (void*)((char *)base + CORO_GUARDPAGES * PAGESIZE);
  #else
    base = malloc (ssze);
    if (!base)
      return 0;
  #endif

  #if CORO_USE_VALGRIND
    stack->valgrind_id = VALGRIND_STACK_REGISTER ((char *)base, ((char *)base) + ssze - CORO_GUARDPAGES * PAGESIZE);
  #endif

  stack->sptr = base;
  return 1;

#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x3a3c
movl $0x40000, -0x14(%rbp)   # imm = 0x40000
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movl -0x14(%rbp), %eax
shlq $0x3, %rax
movq %rax, -0x48(%rbp)
callq 0x3b80
movq %rax, %rcx
movq -0x48(%rbp), %rax
addq %rcx, %rax
subq $0x1, %rax
movq %rax, -0x40(%rbp)
callq 0x3b80
movq %rax, %rcx
movq -0x40(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rax, -0x38(%rbp)
callq 0x3b80
movq -0x38(%rbp), %rcx
imulq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
callq 0x3b80
movq %rax, %rcx
movq -0x30(%rbp), %rax
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
xorl %eax, %eax
movl %eax, %r9d
movl $0x7, %edx
movl $0x22, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movq %r9, %rdi
callq 0x10f0
movq %rax, -0x28(%rbp)
movq $-0x1, %rax
cmpq %rax, -0x28(%rbp)
jne 0x3b25
movq -0x20(%rbp), %rsi
xorl %eax, %eax
movl %eax, %r9d
movl $0x3, %edx
movl $0x22, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movq %r9, %rdi
callq 0x10f0
movq %rax, -0x28(%rbp)
movq $-0x1, %rax
cmpq %rax, -0x28(%rbp)
jne 0x3b23
movl $0x0, -0x4(%rbp)
jmp 0x3b75
jmp 0x3b25
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
callq 0x3b80
movq -0x58(%rbp), %rdi
movq %rax, %rsi
shlq $0x2, %rsi
xorl %edx, %edx
callq 0x1200
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x3b80
movq %rax, %rcx
movq -0x50(%rbp), %rax
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/whtc123[P]libuvc/coro.c
// Function: coro_stack_free
void
coro_stack_free (struct coro_stack *stack)
{
#if CORO_FIBER
  /* nop */
#else
  #if CORO_USE_VALGRIND
    VALGRIND_STACK_DEREGISTER (stack->valgrind_id);
  #endif

  #if CORO_MMAP
    if (stack->sptr)
      munmap ((void*)((char *)stack->sptr - CORO_GUARDPAGES * PAGESIZE),
              stack->ssze                 + CORO_GUARDPAGES * PAGESIZE);
  #else
    free (stack->sptr);
  #endif
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3c12
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
callq 0x3b80
movq %rax, %rdx
movq -0x20(%rbp), %rax
shlq $0x2, %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
callq 0x3b80
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
shlq $0x2, %rax
addq %rax, %rsi
callq 0x11f0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/rasm/scanner.cpp
// Function: unescape(char)
static char unescape(char c)
{
	switch (c) {
		case '0': return '\0';
		case 'n': return '\n';
		case 't': return '\t';
	}
	return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movsbl -0x2(%rbp), %eax
movl %eax, -0x8(%rbp)
subl $0x30, %eax
je 0x9a6c
jmp 0x9a58
movl -0x8(%rbp), %eax
subl $0x6e, %eax
je 0x9a72
jmp 0x9a62
movl -0x8(%rbp), %eax
subl $0x74, %eax
je 0x9a78
jmp 0x9a7e
movb $0x0, -0x1(%rbp)
jmp 0x9a84
movb $0xa, -0x1(%rbp)
jmp 0x9a84
movb $0x9, -0x1(%rbp)
jmp 0x9a84
movb -0x2(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/rasm/scanner.cpp
// Function: scanner::next(tok)
void scanner::next(tok expected)
{
	tok t = next();
	if (expected != t)
		throw error(tokname(t) + " encountered, but "
				+ tokname(expected) + " expected");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8ca0
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
je 0x9c36
movb $0x1, -0xc1(%rbp)
movl $0x10, %edi
callq 0x41e0
movq %rax, -0xd0(%rbp)
movl -0x10(%rbp), %esi
leaq -0x90(%rbp), %rdi
callq 0x86c0
jmp 0x9ae3
leaq 0x196e1(%rip), %rdx     # 0x231cb
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x6250
jmp 0x9afc
movl -0xc(%rbp), %esi
leaq -0xc0(%rbp), %rdi
callq 0x86c0
jmp 0x9b0d
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0xc0(%rbp), %rdx
callq 0xbbf0
jmp 0x9b23
leaq 0x196c5(%rip), %rdx     # 0x231ef
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x6250
jmp 0x9b39
movq -0xd0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x45f0
jmp 0x9b4b
movq -0xd0(%rbp), %rdi
movb $0x0, -0xc1(%rbp)
movq 0x2b488(%rip), %rsi     # 0x34fe8
movq 0x2b439(%rip), %rdx     # 0x34fa0
callq 0x4640
jmp 0x9c4b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x9c1d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x9c11
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x9c08
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x9bfc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x9bf3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4748
leaq -0x50(%rbp), %rdi
callq 0x4748
leaq -0xc0(%rbp), %rdi
callq 0x4748
leaq -0x70(%rbp), %rdi
callq 0x4748
leaq -0x90(%rbp), %rdi
callq 0x4748
testb $0x1, -0xc1(%rbp)
jne 0x9c28
jmp 0x9c34
movq -0xd0(%rbp), %rdi
callq 0x42c0
jmp 0x9c3f
addq $0xd0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x4670
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/rasm/scanner.cpp
// Function: scanner::string_pair[abi:cxx11]() const
std::pair<string, string> scanner::string_pair() const
{
	auto pos = s.find(STRING_DELIM);
	if (pos == string::npos)
		throw error(s + ": compound string expected");
	return { s.substr(0, pos), s.substr(pos) };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x90(%rbp)
addq $0x10, %rdi
movl $0x40, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x4490
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
jne 0x9ed3
movb $0x1, -0x45(%rbp)
movl $0x10, %edi
callq 0x41e0
movq -0x90(%rbp), %rsi
movq %rax, -0xa8(%rbp)
addq $0x10, %rsi
leaq 0x19387(%rip), %rdx     # 0x231de
leaq -0x38(%rbp), %rdi
callq 0x6300
jmp 0x9e62
movq -0xa8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x45f0
jmp 0x9e74
movq -0xa8(%rbp), %rdi
movb $0x0, -0x45(%rbp)
movq 0x2b162(%rip), %rsi     # 0x34fe8
movq 0x2b113(%rip), %rdx     # 0x34fa0
callq 0x4640
jmp 0x9f8c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x9eba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4748
testb $0x1, -0x45(%rbp)
jne 0x9ec2
jmp 0x9ece
movq -0xa8(%rbp), %rdi
callq 0x42c0
jmp 0x9f83
movq -0x90(%rbp), %rsi
addq $0x10, %rsi
movq %rsi, -0xb0(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x68(%rbp), %rdi
callq 0x4370
movq -0xb0(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x88(%rbp), %rdi
movq $-0x1, %rcx
callq 0x4370
jmp 0x9f16
movq -0xa0(%rbp), %rdi
leaq -0x68(%rbp), %rsi
leaq -0x88(%rbp), %rdx
callq 0xbde0
jmp 0x9f2f
leaq -0x88(%rbp), %rdi
callq 0x4748
leaq -0x68(%rbp), %rdi
callq 0x4748
movq -0x98(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x9f7a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x4748
leaq -0x68(%rbp), %rdi
callq 0x4748
movq -0x40(%rbp), %rdi
callq 0x4670
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/rasm/scanner.cpp
// Function: void convert<int>(int&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void convert(T &val, const string &s)
{
	std::size_t pos;
	long num = std::stol(s, &pos, 0);
	if (pos < s.size())
		throw error("wrong int:" + s);
	if (num < numeric_limits<T>::min()
			or num > numeric_limits<T>::max())
		throw error("int out of range: " + s);
	val = static_cast<T>(num);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0xe7f0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4280
movq %rax, %rcx
movq -0x80(%rbp), %rax
cmpq %rcx, %rax
jae 0xb713
movb $0x1, -0x4d(%rbp)
movl $0x10, %edi
callq 0x41e0
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rdx
leaq 0x17b75(%rip), %rsi     # 0x2320c
leaq -0x40(%rbp), %rdi
callq 0xb520
jmp 0xb6a2
movq -0x88(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x45f0
jmp 0xb6b4
movq -0x88(%rbp), %rdi
movb $0x0, -0x4d(%rbp)
movq 0x29922(%rip), %rsi     # 0x34fe8
movq 0x298d3(%rip), %rdx     # 0x34fa0
callq 0x4640
jmp 0xb80d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xb6fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x4748
testb $0x1, -0x4d(%rbp)
jne 0xb702
jmp 0xb70e
movq -0x88(%rbp), %rdi
callq 0x42c0
jmp 0xb804
movq -0x20(%rbp), %rax
movq %rax, -0x90(%rbp)
callq 0xe830
movl %eax, %ecx
movq -0x90(%rbp), %rax
movslq %ecx, %rcx
cmpq %rcx, %rax
jl 0xb759
movq -0x20(%rbp), %rax
movq %rax, -0x98(%rbp)
callq 0xe840
movl %eax, %ecx
movq -0x98(%rbp), %rax
movslq %ecx, %rcx
cmpq %rcx, %rax
jle 0xb7ef
movb $0x1, -0x71(%rbp)
movl $0x10, %edi
callq 0x41e0
movq %rax, -0xa0(%rbp)
movq -0x10(%rbp), %rdx
leaq 0x17a9e(%rip), %rsi     # 0x23217
leaq -0x70(%rbp), %rdi
callq 0xb520
jmp 0xb784
movq -0xa0(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x45f0
jmp 0xb796
movq -0xa0(%rbp), %rdi
movb $0x0, -0x71(%rbp)
movq 0x29840(%rip), %rsi     # 0x34fe8
movq 0x297f1(%rip), %rdx     # 0x34fa0
callq 0x4640
jmp 0xb80d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xb7d9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x4748
testb $0x1, -0x71(%rbp)
jne 0xb7e1
jmp 0xb7ed
movq -0xa0(%rbp), %rdi
callq 0x42c0
jmp 0xb804
movq -0x20(%rbp), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
addq $0xa0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x4670
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/rasm/module.cpp
// Function: vartbl::add(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void vartbl::add(const string &s)
{
	auto slot = map.size();
	if (slot > std::numeric_limits<addr>::max())
		throw error(string("table ") + name + " overflow");
	addr a = static_cast<addr>(slot);
	addrmap::add(s, a);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
addq $0x20, %rdi
callq 0x10c30
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x98(%rbp)
callq 0xe9f0
movb %al, %cl
movq -0x98(%rbp), %rax
movzbl %cl, %ecx
cmpq %rcx, %rax
jbe 0xf6b0
movb $0x1, -0x8d(%rbp)
movl $0x10, %edi
callq 0x41e0
movq %rax, -0xb0(%rbp)
leaq -0x79(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x4690
movq -0xa8(%rbp), %rdx
leaq 0x13d79(%rip), %rsi     # 0x2332f
leaq -0x78(%rbp), %rdi
callq 0x61a0
jmp 0xf5c1
movq -0xa0(%rbp), %rdx
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x10c50
jmp 0xf5d7
leaq 0x13d64(%rip), %rdx     # 0x23342
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x6250
jmp 0xf5ed
movq -0xb0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x45f0
jmp 0xf5ff
movq -0xb0(%rbp), %rdi
movb $0x0, -0x8d(%rbp)
movq 0x259d4(%rip), %rsi     # 0x34fe8
movq 0x25985(%rip), %rdx     # 0x34fa0
callq 0x4640
jmp 0xf6e6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0xf68e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0xf685
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0xf67c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4748
leaq -0x58(%rbp), %rdi
callq 0x4748
leaq -0x78(%rbp), %rdi
callq 0x4748
leaq -0x79(%rbp), %rdi
callq 0x43b0
testb $0x1, -0x8d(%rbp)
jne 0xf6a2
jmp 0xf6ae
movq -0xb0(%rbp), %rdi
callq 0x42c0
jmp 0xf6da
movq -0xa0(%rbp), %rdi
movq -0x18(%rbp), %rax
movb %al, -0x8e(%rbp)
movq -0x10(%rbp), %rsi
movzbl -0x8e(%rbp), %edx
callq 0x10ca0
addq $0xb0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x4670
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/rasm/module.cpp
// Function: symbols::add(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
auto symbols::add(const string &s) -> addr
{
	auto it = tbl.find(s);
	if (it != tbl.end())
		return it->second;

	addr a = static_cast<addr>(data.size());
	tbl[s] = a;
	data.insert(data.end(), s.begin(), s.end());
	data.push_back('\0');

	if (data.size() > std::numeric_limits<addr>::max())
		throw error(".sym section overflow");


	return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movq -0x18(%rbp), %rsi
callq 0x10f20
movq -0x78(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x10f80
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x10f50
testb $0x1, %al
jne 0xf7a8
jmp 0xf7be
leaq -0x20(%rbp), %rdi
callq 0x10fb0
movw 0x20(%rax), %ax
movw %ax, -0x2(%rbp)
jmp 0xf8ee
movq -0x78(%rbp), %rdi
addq $0x38, %rdi
callq 0xef60
movq -0x78(%rbp), %rdi
movw %ax, -0x2a(%rbp)
movw -0x2a(%rbp), %ax
movw %ax, -0x8a(%rbp)
movq -0x18(%rbp), %rsi
callq 0x10fe0
movw -0x8a(%rbp), %cx
movq -0x78(%rbp), %rdi
movw %cx, (%rax)
movq %rdi, %rax
addq $0x38, %rax
movq %rax, -0x88(%rbp)
addq $0x38, %rdi
callq 0xecf0
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x110c0
movq -0x18(%rbp), %rdi
callq 0x4330
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x46e0
movq -0x88(%rbp), %rdi
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x50(%rbp), %rcx
callq 0x11010
movq -0x78(%rbp), %rdi
movq %rax, -0x58(%rbp)
addq $0x38, %rdi
movb $0x0, -0x59(%rbp)
leaq -0x59(%rbp), %rsi
callq 0x11100
movq -0x78(%rbp), %rdi
addq $0x38, %rdi
callq 0xef60
movq %rax, -0x80(%rbp)
callq 0x11130
movw %ax, %cx
movq -0x80(%rbp), %rax
movzwl %cx, %ecx
cmpq %rcx, %rax
jbe 0xf8e6
movl $0x10, %edi
callq 0x41e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x98(%rbp)
leaq 0x13a8b(%rip), %rsi     # 0x23336
callq 0x4140
jmp 0xf8b2
movq -0x98(%rbp), %rdi
movq 0x25728(%rip), %rsi     # 0x34fe8
movq 0x256d9(%rip), %rdx     # 0x34fa0
callq 0x4640
movq -0x98(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0x42c0
jmp 0xf8fb
movw -0x2a(%rbp), %ax
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x4670
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/rasm/module.cpp
// Function: strings::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
auto strings::operator[](const string &s) const -> addr
{
	auto it = tbl.find(s);
	if (it == tbl.end())
		throw error(s + ": no such defined string");
	return it->second;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
callq 0x11350
movq -0x58(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x18, %rdi
callq 0x113b0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x11380
testb $0x1, %al
jne 0xfb00
jmp 0xfb8a
movb $0x1, -0x4d(%rbp)
movl $0x10, %edi
callq 0x41e0
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x1382f(%rip), %rdx     # 0x2334c
leaq -0x40(%rbp), %rdi
callq 0x6300
jmp 0xfb28
movq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x45f0
jmp 0xfb37
movq -0x60(%rbp), %rdi
movb $0x0, -0x4d(%rbp)
movq 0x254a2(%rip), %rsi     # 0x34fe8
movq 0x25453(%rip), %rdx     # 0x34fa0
callq 0x4640
jmp 0xfba5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xfb77
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x4748
testb $0x1, -0x4d(%rbp)
jne 0xfb7f
jmp 0xfb88
movq -0x60(%rbp), %rdi
callq 0x42c0
jmp 0xfb9c
leaq -0x18(%rbp), %rdi
callq 0x113e0
movl 0x20(%rax), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x4670
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/rasm/module.cpp
// Function: code::add_label(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void code::add_label(const string &s)
{
	auto res = lbl.insert({s, address()});
	if (not res.second)
		throw error(std::string("table ") + "label "
				+ " already has an element " + s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, %rax
addq $0x78, %rax
movq %rax, -0x118(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x120(%rbp)
callq 0x11450
movq -0x120(%rbp), %rsi
movl %eax, -0x4c(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x110(%rbp)
leaq -0x4c(%rbp), %rdx
callq 0x11470
movq -0x118(%rbp), %rdi
movq -0x110(%rbp), %rsi
callq 0x11410
movb %dl, -0x101(%rbp)
movq %rax, -0x100(%rbp)
jmp 0xfc25
movb -0x101(%rbp), %al
movq -0x100(%rbp), %rcx
movq %rcx, -0x70(%rbp)
movb %al, -0x68(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x20(%rbp)
movb -0x68(%rbp), %al
movb %al, -0x18(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x7160
testb $0x1, -0x18(%rbp)
jne 0xfde0
movb $0x1, -0xf2(%rbp)
movl $0x10, %edi
callq 0x41e0
movq %rax, -0x130(%rbp)
leaq -0xf1(%rbp), %rdi
movq %rdi, -0x128(%rbp)
callq 0x4690
movq -0x128(%rbp), %rdx
leaq 0x1369c(%rip), %rsi     # 0x2332f
leaq -0xf0(%rbp), %rdi
callq 0x61a0
jmp 0xfca1
leaq 0x136bd(%rip), %rdx     # 0x23365
leaq -0xd0(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
callq 0x6250
jmp 0xfcbd
leaq 0x136a8(%rip), %rdx     # 0x2336c
leaq -0xb0(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x6250
jmp 0xfcd9
movq -0x10(%rbp), %rdx
leaq -0x90(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x10c50
jmp 0xfcf2
movq -0x130(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x45f0
jmp 0xfd07
movq -0x130(%rbp), %rdi
movb $0x0, -0xf2(%rbp)
movq 0x252cc(%rip), %rsi     # 0x34fe8
movq 0x2527d(%rip), %rdx     # 0x34fa0
callq 0x4640
jmp 0xfdf2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x7160
jmp 0xfde9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xfdbb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xfdaf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xfda3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xfd97
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x4748
leaq -0xb0(%rbp), %rdi
callq 0x4748
leaq -0xd0(%rbp), %rdi
callq 0x4748
leaq -0xf0(%rbp), %rdi
callq 0x4748
leaq -0xf1(%rbp), %rdi
callq 0x43b0
testb $0x1, -0xf2(%rbp)
jne 0xfdd2
jmp 0xfdde
movq -0x130(%rbp), %rdi
callq 0x42c0
jmp 0xfde9
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x4670
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/rasm/module.cpp
// Function: code::offset(unsigned int, unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
auto code::offset(addr from, addr to,
		const string &label, int line) -> ofs
{
	ofs d = to - from;
	if ((from + d) != to)
		throw error("too long reference to " + label
				+ " at " + std::to_string(line));
	return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl -0x8(%rbp), %eax
subl -0x4(%rbp), %eax
movw %ax, -0x16(%rbp)
movl -0x4(%rbp), %eax
movswl -0x16(%rbp), %ecx
addl %ecx, %eax
cmpl -0x8(%rbp), %eax
je 0xff6a
movb $0x1, -0xa9(%rbp)
movl $0x10, %edi
callq 0x41e0
movq %rax, -0xb8(%rbp)
movq -0x10(%rbp), %rdx
leaq 0x1352e(%rip), %rsi     # 0x23385
leaq -0x78(%rbp), %rdi
callq 0xb520
jmp 0xfe62
leaq 0x13533(%rip), %rdx     # 0x2339c
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x6250
jmp 0xfe78
movl -0x14(%rbp), %esi
leaq -0xa8(%rbp), %rdi
callq 0xbcc0
jmp 0xfe89
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
leaq -0xa8(%rbp), %rdx
callq 0xbbf0
jmp 0xfe9f
movq -0xb8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x45f0
jmp 0xfeb1
movq -0xb8(%rbp), %rdi
movb $0x0, -0xa9(%rbp)
movq 0x25122(%rip), %rsi     # 0x34fe8
movq 0x250d3(%rip), %rdx     # 0x34fa0
callq 0x4640
jmp 0xff80
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0xff51
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0xff48
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0xff3f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0xff33
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4748
leaq -0xa8(%rbp), %rdi
callq 0x4748
leaq -0x58(%rbp), %rdi
callq 0x4748
leaq -0x78(%rbp), %rdi
callq 0x4748
testb $0x1, -0xa9(%rbp)
jne 0xff5c
jmp 0xff68
movq -0xb8(%rbp), %rdi
callq 0x42c0
jmp 0xff77
movw -0x16(%rbp), %ax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x4670
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/rasm/module.cpp
// Function: code::add_ref(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
void code::add_ref(const std::string &label, int line)
{
	auto it = lbl.find(label);
	if (it != lbl.end()) {
		put(offset(cur_addr, it->second, label, line));
	} else {
		unres.emplace_back(unresolved{label, cur_addr,
				address(), line});
		put(ofs()); // placeholder
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
addq $0x78, %rdi
movq -0x10(%rbp), %rsi
callq 0x114b0
movq -0x70(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x78, %rdi
callq 0x11510
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x114e0
testb $0x1, %al
jne 0xffd3
jmp 0x1000c
movq -0x70(%rbp), %rax
movl 0xf0(%rax), %eax
movl %eax, -0x74(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x11590
movl -0x74(%rbp), %edi
movl 0x20(%rax), %esi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
callq 0xfe00
movq -0x70(%rbp), %rdi
movswl %ax, %esi
callq 0x11540
jmp 0x100b8
movq -0x70(%rbp), %rax
addq $0xb0, %rax
movq %rax, -0x90(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0x88(%rbp)
movq -0x10(%rbp), %rsi
callq 0x4180
movq -0x70(%rbp), %rdi
movl 0xf0(%rdi), %eax
movl %eax, -0x38(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x80(%rbp)
callq 0x11450
movl %eax, -0x78(%rbp)
jmp 0x10050
movq -0x90(%rbp), %rdi
movq -0x80(%rbp), %rax
movl -0x78(%rbp), %ecx
movl %ecx, (%rax)
movl -0x14(%rbp), %eax
movl %eax, -0x30(%rbp)
leaq -0x58(%rbp), %rsi
callq 0x115c0
jmp 0x10071
leaq -0x58(%rbp), %rdi
callq 0x7530
movq -0x70(%rbp), %rdi
xorl %esi, %esi
callq 0x11540
jmp 0x100b8
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
callq 0x4748
jmp 0x100c1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x7530
jmp 0x100c1
addq $0x90, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x4670
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/rasm/module.cpp
// Function: operator<<(std::ostream&, RMDHeader const&)
ostream &operator<<(ostream &s, const RMDHeader &h)
{
	buf_it it(s);
	serializer(it) << h.ident << h.rmd_version << h.name << h.version
		<< h.sizes.exp << h.sizes.ptbl << h.sizes.mtbl
		<< h.sizes.imp << h.sizes.text << h.sizes.sym << h.sizes.str
		<< h.datac << h.flags << h.size << h.pad;
	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x11950
leaq -0x28(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x11800
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x119c0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x4, %rsi
callq 0x11910
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x6, %rsi
callq 0x11820
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x11910
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0xc, %rsi
callq 0x11870
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0xc, %rsi
addq $0x1, %rsi
callq 0x11870
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0xc, %rsi
addq $0x2, %rsi
callq 0x11870
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0xc, %rsi
addq $0x3, %rsi
callq 0x11870
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0xc, %rsi
addq $0x4, %rsi
callq 0x118c0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0xc, %rsi
addq $0x8, %rsi
callq 0x11820
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0xc, %rsi
addq $0xc, %rsi
callq 0x118c0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x1c, %rsi
callq 0x11870
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x1d, %rsi
callq 0x11870
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
callq 0x118c0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x24, %rsi
callq 0x11a20
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/rasm/module.cpp
// Function: module::finish()
void module::finish()
{
	if (symbols::is_empty(header.name))
		throw error("module name was not specified");
	header.datac = data.count();
	header.sizes.exp = exp.count();
	header.sizes.ptbl = ptbl.count();
	header.sizes.mtbl = mtbl.count();
	header.sizes.imp = imp.count();
	header.sizes.text = text.count();
	header.sizes.sym = sym.count();
	header.sizes.str = str.count();
	header.size = exp.size() + ptbl.size() + mtbl.size() + imp.size()
		+ text.size() + sym.size() + str.size();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movzwl 0x6(%rax), %edi
callq 0x11a80
testb $0x1, %al
jne 0x10783
jmp 0x107d6
movl $0x10, %edi
callq 0x41e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
leaq 0x12c10(%rip), %rsi     # 0x233ae
callq 0x4140
jmp 0x107a5
movq -0x28(%rbp), %rdi
movq 0x24838(%rip), %rsi     # 0x34fe8
movq 0x247e9(%rip), %rdx     # 0x34fa0
callq 0x4640
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x42c0
jmp 0x1093d
movq -0x20(%rbp), %rdi
addq $0x390, %rdi            # imm = 0x390
callq 0x11780
movq -0x20(%rbp), %rdi
movb %al, 0x1c(%rdi)
addq $0x30, %rdi
callq 0x11780
movq -0x20(%rbp), %rdi
movb %al, 0xc(%rdi)
addq $0xa0, %rdi
callq 0x11780
movq -0x20(%rbp), %rdi
movb %al, 0xd(%rdi)
addq $0x110, %rdi            # imm = 0x110
callq 0x11780
movq -0x20(%rbp), %rdi
movb %al, 0xe(%rdi)
addq $0x180, %rdi            # imm = 0x180
callq 0x11780
movq -0x20(%rbp), %rdi
movb %al, 0xf(%rdi)
addq $0x240, %rdi            # imm = 0x240
callq 0x11aa0
movq -0x20(%rbp), %rdi
movl %eax, 0x10(%rdi)
addq $0x1f0, %rdi            # imm = 0x1F0
callq 0x11ac0
movq -0x20(%rbp), %rdi
movw %ax, 0x14(%rdi)
addq $0x338, %rdi            # imm = 0x338
callq 0x11aa0
movq -0x20(%rbp), %rdi
movl %eax, 0x18(%rdi)
addq $0x30, %rdi
callq 0x11ae0
movq -0x20(%rbp), %rdi
movq %rax, -0x58(%rbp)
addq $0xa0, %rdi
callq 0x11b10
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movq -0x58(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x50(%rbp)
addq $0x110, %rdi            # imm = 0x110
callq 0x11b40
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movq -0x50(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x48(%rbp)
addq $0x180, %rdi            # imm = 0x180
callq 0x11b70
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movq -0x48(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x40(%rbp)
addq $0x240, %rdi            # imm = 0x240
callq 0x11ba0
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movq -0x40(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x38(%rbp)
addq $0x1f0, %rdi            # imm = 0x1F0
callq 0x11bc0
movq -0x20(%rbp), %rdi
movw %ax, %cx
movq -0x38(%rbp), %rax
movzwl %cx, %ecx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
addq $0x338, %rdi            # imm = 0x338
callq 0x11ba0
movq -0x30(%rbp), %rcx
movq %rax, %rdx
movq -0x20(%rbp), %rax
addq %rdx, %rcx
movl %ecx, 0x20(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x4670
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/rasm/./module.hpp
// Function: addrmap<unsigned char>::add(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned char)
void add(const std::string &s, addr a)
	{
		auto res = map.insert({s, a});
		if (not res.second)
			throw std::runtime_error("table " + name
					+ " already has an element " + s);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x100(%rbp)
addq $0x20, %rax
movq %rax, -0xf8(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
leaq -0x11(%rbp), %rdx
callq 0x12700
movq -0xf8(%rbp), %rdi
movq -0xf0(%rbp), %rsi
callq 0x126c0
movb %dl, -0xe1(%rbp)
movq %rax, -0xe0(%rbp)
jmp 0x10d08
movb -0xe1(%rbp), %al
movq -0xe0(%rbp), %rcx
movq %rcx, -0x70(%rbp)
movb %al, -0x68(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x28(%rbp)
movb -0x68(%rbp), %al
movb %al, -0x20(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x6b60
testb $0x1, -0x20(%rbp)
jne 0x10e6b
movb $0x1, -0xd1(%rbp)
movl $0x10, %edi
callq 0x41e0
movq -0x100(%rbp), %rdx
movq %rax, -0x108(%rbp)
leaq 0x125cc(%rip), %rsi     # 0x2332f
leaq -0xd0(%rbp), %rdi
callq 0xb520
jmp 0x10d71
leaq 0x125f4(%rip), %rdx     # 0x2336c
leaq -0xb0(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x6250
jmp 0x10d8d
movq -0x10(%rbp), %rdx
leaq -0x90(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x10c50
jmp 0x10da6
movq -0x108(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x45f0
jmp 0x10dbb
movq -0x108(%rbp), %rdi
movb $0x0, -0xd1(%rbp)
movq 0x24218(%rip), %rsi     # 0x34fe8
movq 0x241c9(%rip), %rdx     # 0x34fa0
callq 0x4640
jmp 0x10e7d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x6b60
jmp 0x10e74
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x10e52
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x10e46
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x10e3a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x4748
leaq -0xb0(%rbp), %rdi
callq 0x4748
leaq -0xd0(%rbp), %rdi
callq 0x4748
testb $0x1, -0xd1(%rbp)
jne 0x10e5d
jmp 0x10e69
movq -0x108(%rbp), %rdi
callq 0x42c0
jmp 0x10e74
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x4670
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/rasm/./module.hpp
// Function: operator<<(std::ostream&, table<RMDImport> const&)
std::ostream &operator<<(std::ostream &s, const table &t)
	{
		extern void write(std::ostreambuf_iterator<char> &it, const T &e);
		std::ostreambuf_iterator<char> it(s);
		for (auto &e: t.vec)
			write(it, e);
		return s;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x11950
movq -0x10(%rbp), %rax
addq $0x58, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x19220
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x19250
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x19280
testb $0x1, %al
jne 0x11c36
jmp 0x11c5b
leaq -0x30(%rbp), %rdi
callq 0x192c0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x105c0
leaq -0x30(%rbp), %rdi
callq 0x192e0
jmp 0x11c23
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/rasm/./serial.hpp
// Function: std::enable_if<std::is_integral<unsigned int>::value, void>::type serial<std::back_insert_iterator<std::vector<char, std::allocator<char>>>, unsigned int>(std::back_insert_iterator<std::vector<char, std::allocator<char>>>, unsigned int)
std::enable_if_t<std::is_integral<T>::value>
serial(OutputIterator it, T val)
{
	auto v = static_cast<typename std::make_unsigned_t<T>>(val);
	if (sizeof v == 1)
		*it = v;
	else
		for (int i = 0; i != sizeof v; ++i) {
			*it++ = v & 0xFF;
			v >>= 8;
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq $0x4, %rax
je 0x175e9
movl -0x10(%rbp), %eax
andl $0xff, %eax
movb %al, -0x15(%rbp)
leaq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x17620
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x17640
movq %rax, %rdi
leaq -0x15(%rbp), %rsi
callq 0x17650
movl -0x10(%rbp), %eax
shrl $0x8, %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1759c
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/rasm/parser.cpp
// Function: parser::read_types[abi:cxx11]()
string parser::read_types()
{
	string type;
	bool more_types = true;
	while (more_types) {
		switch (s.next()) {
		case tok::STRING:
			type += mangle(s.str());
			break;
		case tok::NEWLINE: 
			// fallthrough
		case tok::END:
			more_types = false;
			break;
		default: throw error(s.str() + ": type expected here");
		}
	}
	return type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x4500
movb $0x1, -0x12(%rbp)
testb $0x1, -0x12(%rbp)
je 0x1c681
movq -0x78(%rbp), %rax
movq (%rax), %rdi
callq 0x8ca0
movl %eax, -0x8c(%rbp)
jmp 0x1c534
movl -0x8c(%rbp), %eax
testl %eax, %eax
je 0x1c561
jmp 0x1c540
movl -0x8c(%rbp), %eax
addl $-0x6, %eax
subl $0x2, %eax
jb 0x1c5c2
jmp 0x1c5cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x1c6a4
movq -0x78(%rbp), %rax
movq (%rax), %rdi
callq 0x1d820
movq %rax, -0x98(%rbp)
jmp 0x1c576
movq -0x98(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x1aff0
jmp 0x1c588
movq -0x88(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x4470
jmp 0x1c59a
leaq -0x48(%rbp), %rdi
callq 0x4748
jmp 0x1c67c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4748
jmp 0x1c6a4
movb $0x0, -0x12(%rbp)
jmp 0x1c67c
movb $0x1, -0x69(%rbp)
movl $0x10, %edi
callq 0x41e0
movq %rax, %rcx
movq -0x78(%rbp), %rax
movq %rcx, -0xa8(%rbp)
movq (%rax), %rdi
callq 0x1d820
movq %rax, -0xa0(%rbp)
jmp 0x1c5f8
movq -0xa0(%rbp), %rsi
leaq 0x7203(%rip), %rdx      # 0x23809
leaq -0x68(%rbp), %rdi
callq 0x6300
jmp 0x1c611
movq -0xa8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x45f0
jmp 0x1c623
movq -0xa8(%rbp), %rdi
movb $0x0, -0x69(%rbp)
movq 0x189b3(%rip), %rsi     # 0x34fe8
movq 0x18964(%rip), %rdx     # 0x34fa0
callq 0x4640
jmp 0x1c6b9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x1c666
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x4748
testb $0x1, -0x69(%rbp)
jne 0x1c66e
jmp 0x1c67a
movq -0xa8(%rbp), %rdi
callq 0x42c0
jmp 0x1c6a4
jmp 0x1c516
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x1c697
movq -0x88(%rbp), %rdi
callq 0x4748
movq -0x80(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x4748
movq -0x20(%rbp), %rdi
callq 0x4670
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/rasm/parser.cpp
// Function: parser::run()
void parser::run()
{
	try {
		parse();
		m.finish();
	} catch (std::runtime_error &re) {
		throw source_error(s.line(), re.what());
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x1b420
jmp 0x1c7fb
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x10760
jmp 0x1c80a
jmp 0x1c912
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x1c918
movq -0x10(%rbp), %rdi
callq 0x4150
movq %rax, -0x20(%rbp)
movb $0x1, -0x42(%rbp)
movl $0x18, %edi
callq 0x41e0
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x60(%rbp)
movq (%rax), %rdi
callq 0x1df50
movl %eax, -0x54(%rbp)
jmp 0x1c85e
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, -0x70(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x4690
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x61a0
jmp 0x1c88f
movl -0x54(%rbp), %esi
movq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rdx
callq 0x1afa0
jmp 0x1c8a1
movq -0x60(%rbp), %rdi
movb $0x0, -0x42(%rbp)
leaq 0x18418(%rip), %rsi     # 0x34cc8
leaq 0x16b9(%rip), %rdx      # 0x1df70
callq 0x4640
jmp 0x1c929
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x1c8f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x1c8ef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x4748
leaq -0x41(%rbp), %rdi
callq 0x43b0
testb $0x1, -0x42(%rbp)
jne 0x1c900
jmp 0x1c909
movq -0x60(%rbp), %rdi
callq 0x42c0
callq 0x4610
jmp 0x1c910
jmp 0x1c918
addq $0x70, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x4670
movq %rax, %rdi
callq 0x6490
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/rasm/parser.cpp
// Function: parser_state::ensure(parser_state::state) const
void ensure(state s) const
	{
		if (st != s)
			throw error("section " + state_str(s)
					+ " expected, but section "
					+ state_str(st) + " is opened");
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xf0(%rbp)
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
je 0x1d7d9
movb $0x1, -0xe1(%rbp)
movl $0x10, %edi
callq 0x41e0
movq %rax, -0xf8(%rbp)
movl -0xc(%rbp), %esi
leaq -0xb0(%rbp), %rdi
callq 0x1e880
jmp 0x1d641
leaq 0x61e5(%rip), %rsi      # 0x2382d
leaq -0x90(%rbp), %rdi
leaq -0xb0(%rbp), %rdx
callq 0xbb50
jmp 0x1d65d
leaq 0x61ba(%rip), %rdx      # 0x2381e
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x6250
jmp 0x1d676
movq -0xf0(%rbp), %rax
movl (%rax), %esi
leaq -0xe0(%rbp), %rdi
callq 0x1e880
jmp 0x1d68d
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0xe0(%rbp), %rdx
callq 0xbbf0
jmp 0x1d6a3
leaq 0x618c(%rip), %rdx      # 0x23836
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x6250
jmp 0x1d6b9
movq -0xf8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x45f0
jmp 0x1d6cb
movq -0xf8(%rbp), %rdi
movb $0x0, -0xe1(%rbp)
movq 0x17908(%rip), %rsi     # 0x34fe8
movq 0x178b9(%rip), %rdx     # 0x34fa0
callq 0x4640
jmp 0x1d7ee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x1d7c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x1d7b4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x1d7a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x1d79f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x1d793
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x1d78a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4748
leaq -0x50(%rbp), %rdi
callq 0x4748
leaq -0xe0(%rbp), %rdi
callq 0x4748
leaq -0x70(%rbp), %rdi
callq 0x4748
leaq -0x90(%rbp), %rdi
callq 0x4748
leaq -0xb0(%rbp), %rdi
callq 0x4748
testb $0x1, -0xe1(%rbp)
jne 0x1d7cb
jmp 0x1d7d7
movq -0xf8(%rbp), %rdi
callq 0x42c0
jmp 0x1d7e2
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0xb8(%rbp), %rdi
callq 0x4670
nop
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/rasm/./module.hpp
// Function: addrmap<unsigned char>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
addr operator[](const std::string &s) const
	{
		auto it = map.find(s);
		if (it == map.end())
			throw std::runtime_error("table '" + name
					+ "': no entry '" + s + "'");
		return it->second;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
callq 0x1ecf0
movq -0xb8(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x20, %rdi
callq 0x1ed50
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1ed20
testb $0x1, %al
jne 0x1dad9
jmp 0x1dc29
movb $0x1, -0xad(%rbp)
movl $0x10, %edi
callq 0x41e0
movq -0xb8(%rbp), %rdx
movq %rax, -0xc0(%rbp)
leaq 0x5d5a(%rip), %rsi      # 0x23859
leaq -0xa0(%rbp), %rdi
callq 0xb520
jmp 0x1db0d
leaq 0x5d4d(%rip), %rdx      # 0x23861
leaq -0x80(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x6250
jmp 0x1db26
movq -0x10(%rbp), %rdx
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x10c50
jmp 0x1db39
leaq 0x5d1f(%rip), %rdx      # 0x2385f
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x6250
jmp 0x1db4f
movq -0xc0(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x45f0
jmp 0x1db61
movq -0xc0(%rbp), %rdi
movb $0x0, -0xad(%rbp)
movq 0x17472(%rip), %rsi     # 0x34fe8
movq 0x17423(%rip), %rdx     # 0x34fa0
callq 0x4640
jmp 0x1dc4a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0x1dc10
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0x1dc04
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0x1dbfb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0x1dbf2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x4748
leaq -0x60(%rbp), %rdi
callq 0x4748
leaq -0x80(%rbp), %rdi
callq 0x4748
leaq -0xa0(%rbp), %rdi
callq 0x4748
testb $0x1, -0xad(%rbp)
jne 0x1dc1b
jmp 0x1dc27
movq -0xc0(%rbp), %rdi
callq 0x42c0
jmp 0x1dc3e
leaq -0x18(%rbp), %rdi
callq 0x1ed80
movb 0x20(%rax), %al
addq $0xc0, %rsp
popq %rbp
retq
movq -0xa8(%rbp), %rdi
callq 0x4670
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/almk277[P]ROSE/rasm/parser.cpp
// Function: parser_state::state_str[abi:cxx11](parser_state::state)
static string state_str(state s)
	{
		switch (s) {
		case NONE: return "none";
		case SUB: return ".sub";
		case STR: return ".str";
		default: throw std::logic_error("wrong parser state");
		}
		return "";
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x1e8c1
jmp 0x1e8a6
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0x1e90c
jmp 0x1e8b0
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0x1e957
jmp 0x1e99c
leaq -0xd(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x4690
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rdx
leaq 0x4f64(%rip), %rsi      # 0x23841
callq 0x61a0
jmp 0x1e8e4
leaq -0xd(%rbp), %rdi
callq 0x43b0
jmp 0x1e9ec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0xd(%rbp), %rdi
callq 0x43b0
jmp 0x1e9f6
leaq -0x1d(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x4690
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0x4bdd(%rip), %rsi      # 0x23505
callq 0x61a0
jmp 0x1e92f
leaq -0x1d(%rbp), %rdi
callq 0x43b0
jmp 0x1e9ec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1d(%rbp), %rdi
callq 0x43b0
jmp 0x1e9f6
leaq -0x1e(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x4690
movq -0x38(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0x4b28(%rip), %rsi      # 0x2349b
callq 0x61a0
jmp 0x1e97a
leaq -0x1e(%rbp), %rdi
callq 0x43b0
jmp 0x1e9ec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1e(%rbp), %rdi
callq 0x43b0
jmp 0x1e9f6
movl $0x10, %edi
callq 0x41e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
leaq 0x4e8f(%rip), %rsi      # 0x23846
callq 0x4550
jmp 0x1e9be
movq -0x58(%rbp), %rdi
movq 0x165ff(%rip), %rsi     # 0x34fc8
movq 0x165d8(%rip), %rdx     # 0x34fa8
callq 0x4640
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x42c0
jmp 0x1e9f6
movq -0x30(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x4670
nop