LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
movl $0x40000, %r14d         # imm = 0x40000
cmovnel %esi, %r14d
movq $0x0, (%rdi)
shlq $0x3, %r14
movq 0x1700b(%rip), %rcx     # 0x1a1b0
testq %rcx, %rcx
je 0x31b2
addq %rcx, %r14
decq %r14
jmp 0x31e7
movl $0x1e, %edi
callq 0x1240
movq %rax, 0x16fed(%rip)     # 0x1a1b0
addq %rax, %r14
decq %r14
testq %rax, %rax
je 0x31d3
movq %rax, %rcx
jmp 0x31e7
movl $0x1e, %edi
callq 0x1240
movq %rax, %rcx
movq %rax, 0x16fc9(%rip)     # 0x1a1b0
movq %r14, %rax
xorl %edx, %edx
divq %rcx
subq %rdx, %r14
movq %r14, 0x8(%rbx)
leaq (%r14,%rcx,4), %r12
xorl %r15d, %r15d
xorl %edi, %edi
movq %r12, %rsi
movl $0x7, %edx
movl $0x22, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %r9d, %r9d
callq 0x1110
cmpq $-0x1, %rax
jne 0x3243
xorl %edi, %edi
movq %r12, %rsi
movl $0x3, %edx
movl $0x22, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %r9d, %r9d
callq 0x1110
cmpq $-0x1, %rax
je 0x329e
movq %rax, %r14
movq 0x16f63(%rip), %rsi     # 0x1a1b0
testq %rsi, %rsi
jne 0x3266
movl $0x1e, %edi
callq 0x1240
movq %rax, %rsi
movq %rax, 0x16f4a(%rip)     # 0x1a1b0
shlq $0x2, %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x1220
movq 0x16f35(%rip), %rax     # 0x1a1b0
testq %rax, %rax
jne 0x3291
movl $0x1e, %edi
callq 0x1240
movq %rax, 0x16f1f(%rip)     # 0x1a1b0
leaq (%r14,%rax,4), %rax
movq %rax, (%rbx)
movl $0x1, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x32ce
movq %rdi, %r14
movq 0x16eed(%rip), %rax     # 0x1a1b0
testq %rax, %rax
je 0x32d6
movq 0x8(%r14), %r14
jmp 0x32f0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x1e, %edi
callq 0x1240
movq %rax, 0x16ec9(%rip)     # 0x1a1b0
movq 0x8(%r14), %r14
testq %rax, %rax
je 0x330d
movq %rax, %rcx
shlq $0x2, %rax
subq %rax, %rbx
leaq (%r14,%rcx,4), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1210
movl $0x1e, %edi
callq 0x1240
movq %rax, %rcx
movq %rax, 0x16e8f(%rip)     # 0x1a1b0
xorl %eax, %eax
jmp 0x32f3
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movl %esi, %ebp
callq 0x5698
cmpl %ebp, %eax
jne 0x5fd2
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %r14d
movl $0x10, %edi
callq 0x3150
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
movl %r14d, %esi
callq 0x4fd4
leaq 0x81d6(%rip), %rsi      # 0xe1cc
leaq 0x20(%rsp), %rdi
callq 0x3500
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x6021
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x602d
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x60(%rsp), %rdi
movl %ebp, %esi
callq 0x4fd4
leaq 0x80(%rsp), %rdi
movq %rsp, %rsi
leaq 0x60(%rsp), %rdx
callq 0x6b36
leaq 0x8183(%rip), %rsi      # 0xe1f0
leaq 0x80(%rsp), %rdi
callq 0x3500
leaq 0x50(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x609d
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x60aa
movq %rdx, 0x40(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x50(%rsp)
movq 0x8(%rax), %rdx
leaq 0x40(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x3440
xorl %ebp, %ebp
movq 0xdf16(%rip), %rsi      # 0x13ff0
movq 0xdecf(%rip), %rdx      # 0x13fb0
movq %rbx, %rdi
callq 0x3480
movq %rax, %r14
movq 0x40(%rsp), %rdi
cmpq %r12, %rdi
je 0x610b
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0x610b
movq %rax, %r14
movb $0x1, %bpl
leaq 0x90(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6134
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0x6134
movq %rax, %r14
movb $0x1, %bpl
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6157
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0x6157
movq %rax, %r14
movb $0x1, %bpl
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x616d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3260
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6188
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3260
testb %bpl, %bpl
jne 0x61b2
jmp 0x61ba
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x61b2
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0x61b2
movq %rax, %r14
movq %rbx, %rdi
callq 0x31f0
movq %r14, %rdi
callq 0x34a0
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x10, %r14
movq %r14, %rdi
movl $0x40, %esi
xorl %edx, %edx
callq 0x3310
cmpq $-0x1, %rax
je 0x6365
movq %rax, %r15
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x3280
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
movq $-0x1, %rcx
callq 0x3280
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x18(%rsp), %rcx
movq -0x10(%rcx), %rdx
cmpq %rcx, %rdx
je 0x6314
movq %rdx, (%rbx)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rbx)
jmp 0x631a
movups (%rcx), %xmm0
movups %xmm0, (%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rbx)
leaq 0x30(%rbx), %rax
movq %rax, 0x20(%rbx)
leaq 0x38(%rsp), %rcx
movq -0x10(%rcx), %rdx
cmpq %rcx, %rdx
je 0x6348
movq %rdx, 0x20(%rbx)
movq 0x38(%rsp), %rax
movq %rax, 0x30(%rbx)
jmp 0x634e
movups (%rcx), %xmm0
movups %xmm0, (%rax)
movq 0x30(%rsp), %rax
movq %rax, 0x28(%rbx)
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x3150
movq %rax, %rbx
leaq 0x7e66(%rip), %rdx      # 0xe1df
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x49df
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3440
xorl %ebp, %ebp
movq 0xdc51(%rip), %rsi      # 0x13ff0
movq 0xdc0a(%rip), %rdx      # 0x13fb0
movq %rbx, %rdi
callq 0x3480
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x63cc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3260
testb %bpl, %bpl
jne 0x63d6
jmp 0x63fe
movq %rax, %r14
movq %rbx, %rdi
callq 0x31f0
jmp 0x63fe
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x63fe
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3260
movq %r14, %rdi
callq 0x34a0
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq (%rsi), %r12
callq 0x3030
movq %rax, %r14
movl (%rax), %ebp
movl $0x0, (%rax)
leaq 0x8(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x3380
movq (%r13), %rcx
subq %r12, %rcx
je 0x6808
movl (%r14), %edx
cmpl $0x22, %edx
je 0x6814
testl %edx, %edx
jne 0x67e8
movl %ebp, (%r14)
cmpq 0x8(%rbx), %rcx
jb 0x6820
movslq %eax, %rcx
cmpq %rax, %rcx
jne 0x686b
movl %eax, (%r15)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7a1c(%rip), %rdi      # 0xe22b
callq 0x3190
leaq 0x7a10(%rip), %rdi      # 0xe22b
callq 0x33c0
movl $0x10, %edi
callq 0x3150
movq %rax, %r14
leaq 0x79d9(%rip), %rsi      # 0xe20d
leaq 0x8(%rsp), %rdi
movq %rbx, %rdx
callq 0x670f
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x3440
xorl %ebp, %ebp
movq 0xd796(%rip), %rsi      # 0x13ff0
movq 0xd74f(%rip), %rdx      # 0x13fb0
movq %r14, %rdi
callq 0x3480
jmp 0x68b4
movl $0x10, %edi
callq 0x3150
movq %rax, %r14
leaq 0x7999(%rip), %rsi      # 0xe218
leaq 0x8(%rsp), %rdi
movq %rbx, %rdx
callq 0x670f
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x3440
xorl %ebp, %ebp
movq 0xd74b(%rip), %rsi      # 0x13ff0
movq 0xd704(%rip), %rdx      # 0x13fb0
movq %r14, %rdi
callq 0x3480
jmp 0x68b8
jmp 0x68dd
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x68d6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3260
testb %bpl, %bpl
jne 0x68e0
jmp 0x68f6
movq %rax, %rbx
movq %r14, %rdi
callq 0x31f0
jmp 0x68f6
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x68f6
movl %ebp, (%r14)
movq %rbx, %rdi
callq 0x34a0
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdi, %r14
movq 0x38(%rdi), %rax
cmpq $0x100, %rax            # imm = 0x100
jae 0x76e6
movzbl %al, %edx
movq %r14, %rdi
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x8882
movl $0x10, %edi
callq 0x3150
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x6c43(%rip), %rsi      # 0xe346
leaq 0x6c42(%rip), %rdx      # 0xe34c
movq %rsp, %rdi
callq 0x4f0e
leaq 0x40(%rsp), %rdi
movq %rsp, %rsi
movq %r14, %rdx
callq 0x8828
leaq 0x6c30(%rip), %rsi      # 0xe359
leaq 0x40(%rsp), %rdi
callq 0x3500
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x7756
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x7763
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
movq 0x8(%rax), %rdx
leaq 0x20(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x3440
xorl %ebp, %ebp
movq 0xc85d(%rip), %rsi      # 0x13ff0
movq 0xc816(%rip), %rdx      # 0x13fb0
movq %rbx, %rdi
callq 0x3480
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x77c4
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0x77c4
movq %rax, %r14
movb $0x1, %bpl
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x77df
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x3260
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x77f5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3260
testb %bpl, %bpl
jne 0x781a
jmp 0x7822
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x781a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0x781a
movq %rax, %r14
movq %rbx, %rdi
callq 0x31f0
movq %r14, %rdi
callq 0x34a0
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x9172
testq %rax, %rax
je 0x78a1
movzwl 0x28(%rax), %ebp
jmp 0x78ef
leaq 0x38(%rbx), %r15
movl 0x40(%rbx), %ebp
subl 0x38(%rbx), %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x926e
movw %bp, (%rax)
movq 0x40(%rbx), %rsi
movq (%r14), %rdx
movq 0x8(%r14), %rcx
addq %rdx, %rcx
movq %r15, %rdi
callq 0x95a2
leaq 0x7(%rsp), %rsi
movb $0x0, (%rsi)
movq %r15, %rdi
callq 0x978a
movq 0x40(%rbx), %rax
subq 0x38(%rbx), %rax
cmpq $0x10000, %rax          # imm = 0x10000
jae 0x78fc
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x3150
movq %rax, %rbx
leaq 0x6a3d(%rip), %rsi      # 0xe34d
movq %rax, %rdi
callq 0x3100
movq 0xc6d1(%rip), %rsi      # 0x13ff0
movq 0xc68a(%rip), %rdx      # 0x13fb0
movq %rbx, %rdi
callq 0x3480
movq %rax, %r14
movq %rbx, %rdi
callq 0x31f0
movq %r14, %rdi
callq 0x34a0
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
addq $0x18, %rdi
callq 0x9e90
testq %rax, %rax
je 0x79ed
movl 0x28(%rax), %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x3150
movq %rax, %rbx
leaq 0x6962(%rip), %rdx      # 0xe363
movq %rsp, %rdi
movq %r14, %rsi
callq 0x49df
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3440
xorl %ebp, %ebp
movq 0xc5cd(%rip), %rsi      # 0x13ff0
movq 0xc586(%rip), %rdx      # 0x13fb0
movq %rbx, %rdi
callq 0x3480
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7a50
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3260
testb %bpl, %bpl
jne 0x7a5a
jmp 0x7a62
movq %rax, %r14
movq %rbx, %rdi
callq 0x31f0
movq %r14, %rdi
callq 0x34a0
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
leaq 0x78(%rdi), %rbx
movl 0x8(%rdi), %ebp
subl (%rdi), %ebp
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x4e78
movl %ebp, 0x20(%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9eca
movl %edx, %ebx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x7ad0
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3260
testb $0x1, %bl
je 0x7ae7
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x3150
movq %rax, %rbx
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x6842(%rip), %rsi      # 0xe346
leaq 0x6841(%rip), %rdx      # 0xe34c
leaq 0x48(%rsp), %rdi
callq 0x4f0e
leaq 0x6860(%rip), %rsi      # 0xe37c
leaq 0x48(%rsp), %rdi
callq 0x3500
leaq 0x78(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x7b48
movups (%rcx), %xmm0
movups %xmm0, (%r13)
jmp 0x7b55
movq %rdx, 0x68(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x78(%rsp)
movq 0x8(%rax), %rdx
leaq 0x68(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x680b(%rip), %rsi      # 0xe383
callq 0x3500
leaq 0x10(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x7ba2
movups (%rcx), %xmm0
leaq 0x10(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x7bae
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax), %rdx
movq %rsp, %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x20(%rsp), %rdi
movq %r14, %rdx
callq 0x8828
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x3440
xorl %ebp, %ebp
movq 0xc402(%rip), %rsi      # 0x13ff0
movq 0xc3bb(%rip), %rdx      # 0x13fb0
movq %rbx, %rdi
callq 0x3480
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x7c1f
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0x7c1f
movq %rax, %r14
movb $0x1, %bpl
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x7c42
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0x7c42
movq %rax, %r14
movb $0x1, %bpl
movq 0x68(%rsp), %rdi
cmpq %r13, %rdi
je 0x7c59
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x3260
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x7c70
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x3260
testb %bpl, %bpl
jne 0x7c96
jmp 0x7cba
movq %rax, %r14
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x7c96
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0x7c96
movq %rax, %r14
movq %rbx, %rdi
callq 0x31f0
jmp 0x7cba
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x7cba
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3260
movq %r14, %rdi
callq 0x34a0
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movl %ecx, %ebp
movl %esi, %eax
subl %edi, %eax
movswl %ax, %ecx
addl %edi, %ecx
cmpl %esi, %ecx
jne 0x7cec
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r14
movl $0x10, %edi
callq 0x3150
movq %rax, %rbx
leaq 0x6699(%rip), %rsi      # 0xe39c
leaq 0x28(%rsp), %rdi
movq %r14, %rdx
callq 0x670f
leaq 0x669c(%rip), %rsi      # 0xe3b3
leaq 0x28(%rsp), %rdi
callq 0x3500
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x7d42
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x7d4f
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x48(%rsp), %rdi
movl %ebp, %esi
callq 0x6bde
leaq 0x68(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x6b36
movb $0x1, %bpl
leaq 0x68(%rsp), %rsi
movq %rbx, %rdi
callq 0x3440
xorl %ebp, %ebp
movq 0xc250(%rip), %rsi      # 0x13ff0
movq 0xc209(%rip), %rdx      # 0x13fb0
movq %rbx, %rdi
callq 0x3480
movq %rax, %r14
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7dd5
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0x7dd5
movq %rax, %r14
movb $0x1, %bpl
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7df8
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0x7df8
movq %rax, %r14
movb $0x1, %bpl
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x7e0f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3260
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7e2a
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3260
testb %bpl, %bpl
jne 0x7e54
jmp 0x7e5c
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7e54
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0x7e54
movq %rax, %r14
movq %rbx, %rdi
callq 0x31f0
movq %r14, %rdi
callq 0x34a0
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x78, %rdi
callq 0x9ff8
testq %rax, %rax
je 0x7eb0
movl 0xf0(%rbx), %edi
movl 0x28(%rax), %esi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x7cc2
movswl %ax, %esi
movq %rbx, %rdi
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x8a8c
leaq 0xb0(%rbx), %r15
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %r14
movq %r14, %rdi
callq 0x4e78
movl 0xf0(%rbx), %eax
movl %eax, 0x20(%r14)
movl 0x8(%rbx), %eax
subl (%rbx), %eax
movl %eax, 0x24(%r14)
movl %ebp, 0x28(%r14)
movq %r15, %rdi
movq %r14, %rsi
callq 0x8ace
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x7f0e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3260
movq %rbx, %rdi
xorl %esi, %esi
callq 0x8a8c
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x7f3e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3260
movq %rbx, %rdi
callq 0x34a0
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x18(%rax), %rax
movq 0xe8(%rdi,%rax), %rdx
leaq 0x8(%rsp), %rax
movq %rdx, (%rax)
xorl %ecx, %ecx
testq %rdx, %rdx
sete 0x8(%rax)
sete %cl
movq %rsp, %r15
movq %rax, (%r15)
leaq 0x4(%rsi), %r12
movq %rsi, %rdi
movq %r12, %rsi
callq 0xa45a
movq %r15, %rdi
movq %r12, %rsi
callq 0x8b36
movq %rax, %r15
movq (%rax), %rax
movq (%rax), %rdi
movzwl 0x6(%r14), %edx
movl 0x8(%rax), %esi
callq 0xa39c
leaq 0x8(%r14), %rsi
movq %r15, %rdi
callq 0x8b36
movq %rax, %r15
movq (%rax), %rax
testb $0x1, 0x8(%rax)
jne 0x8442
movq (%rax), %rdi
movb 0xc(%r14), %al
movq 0x28(%rdi), %rcx
cmpq 0x30(%rdi), %rcx
jae 0x8567
movb %al, (%rcx)
incq 0x28(%rdi)
movq (%r15), %rax
testb $0x1, 0x8(%rax)
jne 0x8466
movq (%rax), %rdi
movb 0xd(%r14), %al
movq 0x28(%rdi), %rcx
cmpq 0x30(%rdi), %rcx
jae 0x8575
movb %al, (%rcx)
incq 0x28(%rdi)
movq (%r15), %rax
testb $0x1, 0x8(%rax)
jne 0x848a
movq (%rax), %rdi
movb 0xe(%r14), %al
movq 0x28(%rdi), %rcx
cmpq 0x30(%rdi), %rcx
jae 0x8583
movb %al, (%rcx)
incq 0x28(%rdi)
movq (%r15), %rax
testb $0x1, 0x8(%rax)
jne 0x84ae
movq (%rax), %rdi
movb 0xf(%r14), %al
movq 0x28(%rdi), %rcx
cmpq 0x30(%rdi), %rcx
jae 0x8591
movb %al, (%rcx)
incq 0x28(%rdi)
movq (%r15), %rax
movq (%rax), %rdi
movl 0x10(%r14), %edx
movl 0x8(%rax), %esi
callq 0xa3fc
movq (%r15), %rax
movq (%rax), %rdi
movzwl 0x14(%r14), %edx
movl 0x8(%rax), %esi
callq 0xa39c
movq (%r15), %rax
movq (%rax), %rdi
movl 0x18(%r14), %edx
movl 0x8(%rax), %esi
callq 0xa3fc
movq (%r15), %rax
testb $0x1, 0x8(%rax)
jne 0x8509
movq (%rax), %rdi
movb 0x1c(%r14), %al
movq 0x28(%rdi), %rcx
cmpq 0x30(%rdi), %rcx
jae 0x859f
movb %al, (%rcx)
incq 0x28(%rdi)
movq (%r15), %rax
testb $0x1, 0x8(%rax)
jne 0x852d
movq (%rax), %rdi
movb 0x1d(%r14), %al
movq 0x28(%rdi), %rcx
cmpq 0x30(%rdi), %rcx
jae 0x85ad
movb %al, (%rcx)
incq 0x28(%rdi)
movq (%r15), %rax
movq (%rax), %rdi
movl 0x20(%r14), %edx
movl 0x8(%rax), %esi
callq 0xa3fc
leaq 0x24(%r14), %rdi
movq (%r15), %rax
movq (%rax), %rdx
addq $0x2c, %r14
movl 0x8(%rax), %ecx
movq %r14, %rsi
callq 0xa45a
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movzbl %al, %esi
movq (%rdi), %rax
callq *0x68(%rax)
jmp 0x8442
movzbl %al, %esi
movq (%rdi), %rax
callq *0x68(%rax)
jmp 0x8466
movzbl %al, %esi
movq (%rdi), %rax
callq *0x68(%rax)
jmp 0x848a
movzbl %al, %esi
movq (%rdi), %rax
callq *0x68(%rax)
jmp 0x84ae
movzbl %al, %esi
movq (%rdi), %rax
callq *0x68(%rax)
jmp 0x8509
movzbl %al, %esi
movq (%rdi), %rax
callq *0x68(%rax)
jmp 0x852d
nop
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x20(%rdi), %r12
leaq 0x10(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %r13
movq %r13, %rdi
callq 0x4e78
movb %bl, 0x20(%r13)
movq %r12, %rdi
movq %r13, %rsi
callq 0x8d88
movl %edx, %ebx
movq (%rsp), %rdi
cmpq %rbp, %rdi
je 0x88e1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3260
testb $0x1, %bl
je 0x88f5
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x3150
movq %rax, %rbx
leaq 0x5a3d(%rip), %rsi      # 0xe346
leaq 0x28(%rsp), %rdi
movq %r15, %rdx
callq 0x670f
leaq 0x5a66(%rip), %rsi      # 0xe383
leaq 0x28(%rsp), %rdi
callq 0x3500
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x8948
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x8955
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
movq 0x8(%rax), %rdx
leaq 0x48(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rsp, %rdi
movq %r14, %rdx
callq 0x8828
movb $0x1, %r12b
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3440
xorl %r12d, %r12d
movq 0xb65c(%rip), %rsi      # 0x13ff0
movq 0xb615(%rip), %rdx      # 0x13fb0
movq %rbx, %rdi
callq 0x3480
movq %rax, %r14
movq (%rsp), %rdi
cmpq %rbp, %rdi
je 0x89c4
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0x89c4
movq %rax, %r14
movb $0x1, %r12b
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x89db
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x3260
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x89f6
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3260
testb %r12b, %r12b
jne 0x8a20
jmp 0x8a43
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8a20
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0x8a20
movq %rax, %r14
movq %rbx, %rdi
callq 0x31f0
jmp 0x8a43
movq %rax, %r14
movq (%rsp), %rdi
cmpq %rbp, %rdi
je 0x8a43
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3260
movq %r14, %rdi
callq 0x34a0
nop
// File: /workspace/github_c_makefile_star2_O3/almk277[P]ROSE/rasm/./module.hpp
// Function: operator<<(std::ostream&, table<RMDModule> 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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x18(%rax), %rax
movq 0xe8(%rdi,%rax), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
sete 0x10(%rsp)
movq 0x58(%rsi), %r15
movq 0x60(%rsi), %r12
cmpq %r12, %r15
je 0x8c6e
leaq 0x8(%rsp), %r13
leaq 0x18(%rsp), %r14
movq %r13, 0x18(%rsp)
movq 0x8(%rsp), %rdi
movzwl (%r15), %edx
movl 0x10(%rsp), %esi
callq 0xa39c
leaq 0x2(%r15), %rsi
movq %r14, %rdi
callq 0x8b36
addq $0x4, %r15
cmpq %r12, %r15
jne 0x8c42
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/almk277[P]ROSE/rasm/./serial.hpp
// Function: std::enable_if<std::is_integral<unsigned short>::value, void>::type serial<std::ostreambuf_iterator<char, std::char_traits<char>>, unsigned short>(std::ostreambuf_iterator<char, std::char_traits<char>>, unsigned short)
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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movl $0x2, %r15d
movl $0x1, %r12d
testb $0x1, %bpl
jne 0xa3cd
movq 0x28(%r14), %rax
cmpq 0x30(%r14), %rax
jae 0xa3da
movb %bl, (%rax)
incq 0x28(%r14)
movzwl %bx, %ebx
shrl $0x8, %ebx
decl %r15d
jne 0xa3b7
jmp 0xa3f3
movzbl %bl, %esi
movq (%r14), %rax
movq %r14, %rdi
callq *0x68(%rax)
cmpl $-0x1, %eax
movzbl %bpl, %ebp
cmovel %r12d, %ebp
jmp 0xa3cd
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %r15
movq (%r14), %rdi
callq 0x5698
testl %eax, %eax
jne 0xb9ab
movq (%r14), %rsi
addq $0x10, %rsi
movq %r15, %rdi
callq 0xaa87
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x30a0
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xb965
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0xb965
addl $-0x6, %eax
cmpl $0x2, %eax
jae 0xb9c5
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x3150
movq %rax, %r15
movq (%r14), %rsi
addq $0x10, %rsi
leaq 0x2cf8(%rip), %rdx      # 0xe6d8
leaq 0x8(%rsp), %rdi
callq 0x49df
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x3440
xorl %ebp, %ebp
movq 0x85ed(%rip), %rsi      # 0x13ff0
movq 0x85a6(%rip), %rdx      # 0x13fb0
movq %r15, %rdi
callq 0x3480
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xba2c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3260
testb %bpl, %bpl
jne 0xba36
jmp 0xba61
movq %rax, %r14
movq %r15, %rdi
callq 0x31f0
jmp 0xba61
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xba61
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0xba61
jmp 0xba5e
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0xba75
movq (%r12), %rsi
incq %rsi
callq 0x3260
movq %r14, %rdi
callq 0x34a0
nop
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r15
callq 0xacf2
movq 0x8(%r15), %rdi
callq 0x85bc
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
cmpl $0x1, %edx
jne 0xbb55
movq %r14, %rdi
callq 0x3110
movq %rax, %r14
movl $0x18, %edi
callq 0x3150
movq %rax, %rbx
movq (%r15), %rax
movl 0x8(%rax), %r15d
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %rax, %rsi
callq 0x49a2
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x32f0
leaq 0x8227(%rip), %rax      # 0x13d28
movq %rax, (%rbx)
movl %r15d, 0x10(%rbx)
xorl %ebp, %ebp
leaq 0x81c7(%rip), %rsi      # 0x13cd8
movq 0x84a0(%rip), %rdx      # 0x13fb8
movq %rbx, %rdi
callq 0x3480
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbb3e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3260
testb %bpl, %bpl
jne 0xbb48
jmp 0xbb50
movq %rax, %r14
movq %rbx, %rdi
callq 0x31f0
callq 0x3460
movq %r14, %rdi
callq 0x34a0
movq %rax, %rdi
callq 0x4acf
nop
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc0, %rsp
cmpl %esi, (%rdi)
jne 0xbeab
addq $0xc0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %esi, %ebp
movq %rdi, %r14
movl $0x10, %edi
callq 0x3150
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
movl %ebp, %esi
callq 0xc5a6
leaq 0x282c(%rip), %rsi      # 0xe6fc
leaq 0x80(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x6a65
leaq 0x2804(%rip), %rsi      # 0xe6ed
leaq 0x80(%rsp), %rdi
callq 0x3500
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0xbf17
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0xbf23
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movl (%r14), %esi
leaq 0x60(%rsp), %rdi
callq 0xc5a6
leaq 0xa0(%rsp), %rdi
movq %rsp, %rsi
leaq 0x60(%rsp), %rdx
callq 0x6b36
leaq 0x27a1(%rip), %rsi      # 0xe705
leaq 0xa0(%rsp), %rdi
callq 0x3500
leaq 0x50(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0xbf94
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0xbfa1
movq %rdx, 0x40(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x50(%rsp)
movq 0x8(%rax), %rdx
leaq 0x40(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x3440
xorl %ebp, %ebp
movq 0x801f(%rip), %rsi      # 0x13ff0
movq 0x7fd8(%rip), %rdx      # 0x13fb0
movq %rbx, %rdi
callq 0x3480
movq %rax, %r14
movq 0x40(%rsp), %rdi
cmpq %r12, %rdi
je 0xc002
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0xc002
movq %rax, %r14
movb $0x1, %bpl
leaq 0xb0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc02b
movq 0xb0(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0xc02b
movq %rax, %r14
movb $0x1, %bpl
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc04e
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0xc04e
movq %rax, %r14
movb $0x1, %bpl
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xc06c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0xc06c
movq %rax, %r14
movb $0x1, %bpl
leaq 0x90(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc08d
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x3260
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc0a8
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3260
testb %bpl, %bpl
jne 0xc0d2
jmp 0xc0da
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc0d2
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0xc0d2
movq %rax, %r14
movq %rbx, %rdi
callq 0x31f0
movq %r14, %rdi
callq 0x34a0
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r14
movq %rdi, %r15
addq $0x20, %rdi
callq 0xc71a
testq %rax, %rax
je 0xc1b8
movb 0x28(%rax), %al
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x3150
movq %rax, %rbx
leaq 0x255c(%rip), %rsi      # 0xe728
movq %rsp, %rdi
movq %r15, %rdx
callq 0x670f
leaq 0x2552(%rip), %rsi      # 0xe730
movq %rsp, %rdi
callq 0x3500
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0xc207
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0xc214
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
movq 0x8(%rax), %rdx
leaq 0x20(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x60(%rsp), %rdi
movq %r14, %rdx
callq 0x8828
leaq 0x24ea(%rip), %rsi      # 0xe72e
leaq 0x60(%rsp), %rdi
callq 0x3500
leaq 0x50(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0xc271
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0xc27e
movq %rdx, 0x40(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x50(%rsp)
movq 0x8(%rax), %rdx
leaq 0x40(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x3440
xorl %ebp, %ebp
movq 0x7d42(%rip), %rsi      # 0x13ff0
movq 0x7cfb(%rip), %rdx      # 0x13fb0
movq %rbx, %rdi
callq 0x3480
movq %rax, %r14
movq 0x40(%rsp), %rdi
cmpq %r12, %rdi
je 0xc2df
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0xc2df
movq %rax, %r14
movb $0x1, %bpl
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc302
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0xc302
movq %rax, %r14
movb $0x1, %bpl
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0xc319
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3260
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc334
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3260
testb %bpl, %bpl
jne 0xc35e
jmp 0xc366
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc35e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0xc35e
movq %rax, %r14
movq %rbx, %rdi
callq 0x31f0
movq %r14, %rdi
callq 0x34a0
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x2, %esi
je 0xc5e9
cmpl $0x1, %esi
je 0xc5d2
testl %esi, %esi
jne 0xc611
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x2147(%rip), %rsi      # 0xe710
leaq 0x2144(%rip), %rdx      # 0xe714
jmp 0xc5fe
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1ef6(%rip), %rsi      # 0xe4d6
leaq 0x1ef3(%rip), %rdx      # 0xe4da
jmp 0xc5fe
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1e7a(%rip), %rsi      # 0xe471
leaq 0x1e77(%rip), %rdx      # 0xe475
movq %rbx, %rdi
callq 0x4f0e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x3150
movq %rax, %rbx
leaq 0x20f0(%rip), %rsi      # 0xe715
movq %rax, %rdi
callq 0x33b0
movq 0x799c(%rip), %rsi      # 0x13fd0
movq 0x7985(%rip), %rdx      # 0x13fc0
movq %rbx, %rdi
callq 0x3480
movq %rax, %r14
movq %rbx, %rdi
callq 0x31f0
movq %r14, %rdi
callq 0x34a0
// File: /workspace/github_c_makefile_star2_O3/almk277[P]ROSE/lib/cmdopt.c
// Function: cmdopt_parse
int cmdopt_parse(int argc, char *const argv[], const struct cmdopt *opts)
{
	int arg;
	const struct cmdopt *param_opt = opts;
	while(param_opt->option)
		++param_opt;
	for(arg = 1; arg != argc; ++arg) {
		const char *s = argv[arg];
		if(s[0] != '-') /* non-option parameter */
			handle(param_opt, s);
		else {
			const char *eq = strchr(++s, '='); /* drop out '-' */
			if(eq) { /* parameter with value */
				size_t param_len = eq - s;
				const struct cmdopt *opt;
				for(opt = opts; opt->option; ++opt)
					if(strncmp(s, opt->option, param_len) == 0
							&& opt->option[param_len] == '\0') {
						handle(opt, eq + 1);
						goto loop;
					}
				return arg;
			} else { /* parameter without value */
				const struct cmdopt *opt;
				for(opt = opts; opt->option; ++opt)
					if(strcmp(s, opt->option) == 0) {
						handle(opt, NULL);
						goto loop;
					}
				return arg;
			}
		}
loop: ;
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r13
movq %rsi, %rbp
movq %rdx, %r14
cmpq $0x0, (%r14)
leaq 0x20(%r14), %r14
jne 0xd307
cmpl $0x1, %edi
jne 0xd329
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %edi, %r15d
leaq 0x20(%r13), %rax
movq %rax, 0x8(%rsp)
movl $0x1, %ebx
movq %r15, (%rsp)
movq (%rbp,%rbx,8), %r12
cmpb $0x2d, (%r12)
jne 0xd3b5
incq %r12
movq %r12, %rdi
movl $0x3d, %esi
callq 0x30d0
testq %rax, %rax
je 0xd3e3
movq %rbp, 0x20(%rsp)
movq (%r13), %rbp
testq %rbp, %rbp
je 0xd318
movq %r13, 0x18(%rsp)
movq %rax, 0x10(%rsp)
movq %rax, %r13
subq %r12, %r13
movq 0x8(%rsp), %r15
movq %r12, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x3130
testl %eax, %eax
jne 0xd3a4
cmpb $0x0, (%rbp,%r13)
je 0xd42a
movq (%r15), %rbp
addq $0x20, %r15
testq %rbp, %rbp
jne 0xd386
jmp 0xd318
movq -0x18(%r14), %rax
testq %rax, %rax
je 0xd3c4
movl $0x1, (%rax)
movq -0x10(%r14), %rax
testq %rax, %rax
je 0xd3d2
movq %r12, %rdi
callq *%rax
incq %rbx
cmpq %r15, %rbx
jne 0xd33e
jmp 0xd316
movq (%r13), %rsi
movq 0x8(%rsp), %r15
testq %rsi, %rsi
je 0xd318
movq %r12, %rdi
callq 0x3370
testl %eax, %eax
je 0xd40a
movq (%r15), %rsi
addq $0x20, %r15
jmp 0xd3ec
movq -0x18(%r15), %rax
testq %rax, %rax
je 0xd419
movl $0x1, (%rax)
movq -0x10(%r15), %rax
testq %rax, %rax
movq (%rsp), %r15
je 0xd3d2
xorl %edi, %edi
jmp 0xd3d0
movq -0x18(%r15), %rax
testq %rax, %rax
je 0xd439
movl $0x1, (%rax)
movq -0x10(%r15), %rax
testq %rax, %rax
movq 0x18(%rsp), %r13
movq 0x20(%rsp), %rbp
movq (%rsp), %r15
je 0xd3d2
movq 0x10(%rsp), %rdi
incq %rdi
jmp 0xd3d0
// File: /workspace/github_c_makefile_star2_O3/almk277[P]ROSE/lib/cmdopt.c
// Function: cmdopt_print
void cmdopt_print(const struct cmdopt *opts)
{
	const struct cmdopt *opt;
	int maxlen = 0;
	/* calculate maximum option length */
	for(opt = opts; opt->option; ++opt) {
		int len = strlen(opt->option);
		if(len > maxlen)
			maxlen = len;
	}
	for(opt = opts; opt->option; ++opt)
		printf("  -%-*s%s  %s\n", maxlen, opt->option,
				opt->handler ? "=v" : "  ", opt->description);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r14
testq %r14, %r14
je 0xd4e6
movq %rdi, %rbx
leaq 0x20(%rdi), %r12
xorl %r15d, %r15d
movq %r14, %rdi
movl %r15d, %ebp
callq 0x3120
movq %rax, %r15
cmpl %r15d, %ebp
cmovgl %ebp, %r15d
movq (%r12), %rdi
addq $0x20, %r12
testq %rdi, %rdi
jne 0xd47d
testq %r14, %r14
je 0xd4e6
addq $0x20, %rbx
leaq 0x12fc(%rip), %r13      # 0xe7a8
leaq 0x12f2(%rip), %rbp      # 0xe7a5
leaq 0x12dc(%rip), %r12      # 0xe796
cmpq $0x0, -0x10(%rbx)
movq %rbp, %rcx
cmoveq %r13, %rcx
movq -0x8(%rbx), %r8
movq %r12, %rdi
movl %r15d, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x3040
movq (%rbx), %r14
addq $0x20, %rbx
testq %r14, %r14
jne 0xd4ba
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hyc[P]trek73c/trekx.c
// Function: mygetstr
void mygetstr(win, str, eol)
WINDOW *win;
char *str;
boolean eol;
{
  reg char c, *ptr;
  int y, x, y1, x1;
  reg int i=0;

  ptr = str;
  getyx(win, y1, x1);
  wrefresh(win);
  do {
    c=wgetch(win);
    if ((c == _Erase) && i) {
      ptr--;
      i--;
      getyx(win, y, x);
      mvwaddch(win, y, x-1, ' ');
    } else if (c == _Kill) {
      ptr=str;
      i=0;
      wmove(win, y1, x1);
      wclrtoeol(win);
    } else if ((c == '\n') || (c=='\r')) {
      *ptr = '\0';
      if (eol) {
        waddstr(win, "\n");
	wclrtoeol(win);
      }
      wrefresh(win);
      return;
    } else {
      *ptr++ = c;
      waddch(win, c);
    }
    wrefresh(win);
  } while (c != '\n');
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, 0x4(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
je 0x24c4
movswl (%rbx), %r15d
movswl 0x2(%rbx), %r12d
jmp 0x24d0
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movq %rbx, %rdi
callq 0x2190
movq %r14, %r13
movq %rbx, %rdi
callq 0x2300
movl %eax, %ebp
movsbl %bpl, %esi
shll $0x18, %ebp
movsbl 0x10fae(%rip), %eax     # 0x134a1
cmpl %eax, %esi
jne 0x2512
movq %rbx, %rdi
movl %r15d, %esi
movl %r12d, %edx
callq 0x21e0
movq %rbx, %rdi
callq 0x2220
movq %r14, %r13
jmp 0x2531
cmpl $0xd000000, %ebp        # imm = 0xD000000
je 0x2550
cmpl $0xa000000, %ebp        # imm = 0xA000000
je 0x2550
movb %sil, (%r13)
incq %r13
movq %rbx, %rdi
callq 0x2160
movq %rbx, %rdi
callq 0x2190
cmpl $0xa000000, %ebp        # imm = 0xA000000
jne 0x24db
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x0, (%r13)
cmpb $0x0, 0x4(%rsp)
je 0x2578
leaq 0xb786(%rip), %rsi      # 0xdce9
movq %rbx, %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2210
movq %rbx, %rdi
callq 0x2220
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2190
// File: /workspace/github_c_makefile_star2_O3/hyc[P]trek73c/trekx.c
// Function: SysInit
void SysInit()
{
  srand(getpid());
  initscr();

  if ((LINES < 24) || (COLS < 80)) {
	printf("Sorry, you must have at least a 24 by 80 screen to play.\n");
	exit(1);
  }

  _Erase=erasechar();
  _Kill=killchar();
  noecho();
  raw();
  nonl();

  Disrow = LINES * 19 / 24;
  Cmdrow = LINES - Disrow;
  if (!(Disrow & 1)) {
	Disrow++;	/* Insure Disrow is odd */
	Cmdrow--;
  }
  Discol = COLS - 45;
  if (!(Discol & 1)) {
	Discol--;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x2100
movl %eax, %edi
callq 0x2240
callq 0x2280
movq 0x10a16(%rip), %r14     # 0x12fc0
cmpl $0x18, (%r14)
jl 0x2649
movq 0x10a25(%rip), %rbx     # 0x12fe0
cmpl $0x4f, (%rbx)
jle 0x2649
callq 0x2180
movb %al, 0x10ed1(%rip)      # 0x134a0
callq 0x2030
movb %al, 0x10ec7(%rip)      # 0x134a1
callq 0x2060
callq 0x2120
callq 0x2290
movl (%r14), %eax
leal (%rax,%rax,8), %ecx
leal (%rax,%rcx,2), %ecx
movslq %ecx, %rcx
imulq $0x2aaaaaab, %rcx, %rcx # imm = 0x2AAAAAAB
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x22, %rcx
addl %edx, %ecx
movl %ecx, 0x10e95(%rip)     # 0x134a4
subl %ecx, %eax
movl %eax, 0x10e91(%rip)     # 0x134a8
testb $0x1, %cl
jne 0x262d
orl $0x1, %ecx
movl %ecx, 0x10e7f(%rip)     # 0x134a4
decl %eax
movl %eax, 0x10e7b(%rip)     # 0x134a8
movl (%rbx), %eax
leal -0x2d(%rax), %ecx
addl $-0x2e, %eax
testb $0x1, %cl
cmovnel %ecx, %eax
movl %eax, 0x10e6b(%rip)     # 0x134ac
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xdfaf(%rip), %rdi      # 0x105ff
callq 0x20a0
movl $0x1, %edi
callq 0x20d0