LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jflatow[P]jfdb/src/trie.h
// Function: JFT_mark_symbol
static inline int JFT_mark_symbol(JFT_Range *range,
                                  JFT_SymbolSet *set,
                                  JFT_Symbol symbol) {
  if (symbol < range->min)
    range->min = symbol;
  if (symbol > range->max)
    range->max = symbol;
  JFT_symbol_set_bit(set, symbol);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x840c
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x8426
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8550
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jflatow[P]jfdb/src/trie.h
// Function: JFT_mark_scan_children
static inline int JFT_mark_scan_children(const JFT *trie,
                                         JFT_Range *range,
                                         JFT_SymbolSet *set) {
  JFT_TypeInfo length = JFT_type_info(trie);
  const uint8_t *symbols = JFT_type_data(trie);
  for (int i = 0; i < length; i++)
    JFT_mark_symbol(range, set, symbols[i]);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7950
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7970
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x84a2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %edx
callq 0x83e0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x8474
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jflatow[P]jfdb/src/trie.h
// Function: JFT_mark_jump_children
static inline int JFT_mark_jump_children(const JFT *trie,
                                         JFT_Range *range,
                                         JFT_SymbolSet *set) {
  JFT_TypeInfo rangeId = JFT_type_info(trie);
  JFT_Offset *offsets = (JFT_Offset *)JFT_type_data(trie);
  JFT_Range table = JumpTableRanges[rangeId];
  for (JFT_Symbol s = table.min; s <= table.max; s++)
    if (offsets[s - table.min])
      JFT_mark_symbol(range, set, s);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7950
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7970
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %ecx
leaq 0xec7(%rip), %rax       # 0x93b0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x30(%rbp), %rax
ja 0x8545
movq -0x28(%rbp), %rax
movq -0x40(%rbp), %rcx
subq -0x38(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x8535
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x83e0
jmp 0x8537
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x8507
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jflatow[P]jfdb/src/trie.h
// Function: JFT_count_bits
static inline int JFT_count_bits(uint64_t v) {
  // i.e. https://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetParallel
  v = (v - ((v >> 1) & (uint64_t)~(uint64_t)0 / 3));
  v = (v & (uint64_t)~(uint64_t)0 / 15 * 3) + ((v >> 2) & (uint64_t)~(uint64_t)0 / 15 * 3);
  v = (v + (v >> 4)) & (uint64_t)~(uint64_t)0 / 255 * 15;
  v = (v * ((uint64_t)~(uint64_t)0 / 255)) >> (sizeof(uint64_t) - 1) * 8;
  return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
shrq %rcx
movabsq $0x5555555555555555, %rdx # imm = 0x5555555555555555
andq %rdx, %rcx
subq %rcx, %rax
movq %rax, -0x8(%rbp)
movabsq $0x3333333333333333, %rax # imm = 0x3333333333333333
andq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
shrq $0x2, %rcx
movabsq $0x3333333333333333, %rdx # imm = 0x3333333333333333
andq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
shrq $0x4, %rcx
addq %rcx, %rax
movabsq $0xf0f0f0f0f0f0f0f, %rcx # imm = 0xF0F0F0F0F0F0F0F
andq %rcx, %rax
movq %rax, -0x8(%rbp)
movabsq $0x101010101010101, %rax # imm = 0x101010101010101
imulq -0x8(%rbp), %rax
shrq $0x38, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jflatow[P]jfdb/src/trie.c
// Function: make_scan_list
static inline JFT_Offset make_scan_list(JFT_Buffer *buf,
                                        JFT_Offset parentPos,
                                        const JFT_Stem *stem,
                                        JFT_SymbolSet *symbols,
                                        int numSymbols) {
  // first create the list of symbols for searching, then the list of offsets
  JFT_Offset size = JFT_scan_size(stem->size, numSymbols);
  if (!JFT_buffer_ample(buf, size))
    return 0;

  JFT_Offset parentOffset = offset_parent(buf, parentPos, stem);
  write_node(buf, ScanList, stem, numSymbols, parentOffset);

  uint64_t word;
  for (int w = 0; w < 4; w++)
    for (int b = ffsll(word = (*symbols)[w]); b; b = ffsll(word &= word - 1))
      JFT_buffer_equal(buf, uint8_t, 64 * w + b - 1);

  for (int i = 0; i < numSymbols; i++)
    JFT_buffer_equal(buf, JFT_Offset, 0);

  return size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movzwl 0x8(%rax), %edi
movl -0x2c(%rbp), %esi
callq 0x88a0
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x80b0
cmpq $0x0, %rax
jne 0x8670
movq $0x0, -0x8(%rbp)
jmp 0x878e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x8100
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl -0x2c(%rbp), %ecx
movq -0x40(%rbp), %r8
movl $0x1, %esi
callq 0x8150
movl $0x0, -0x4c(%rbp)
cmpl $0x4, -0x4c(%rbp)
jge 0x8744
movq -0x28(%rbp), %rax
movslq -0x4c(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq %rdx, -0x48(%rbp)
tzcntq %rdx, %rax
addq $0x1, %rax
xorl %ecx, %ecx
cmpq $0x0, %rdx
cmoveq %rcx, %rax
movl %eax, -0x50(%rbp)
cmpl $0x0, -0x50(%rbp)
je 0x8734
movl -0x4c(%rbp), %eax
shll $0x6, %eax
addl -0x50(%rbp), %eax
subl $0x1, %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x48(%rbp), %rdx
subq $0x1, %rdx
andq -0x48(%rbp), %rdx
movq %rdx, -0x48(%rbp)
tzcntq %rdx, %rax
addq $0x1, %rax
xorl %ecx, %ecx
cmpq $0x0, %rdx
cmoveq %rcx, %rax
movl %eax, -0x50(%rbp)
jmp 0x86d5
jmp 0x8736
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x86a5
movl $0x0, -0x54(%rbp)
movl -0x54(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x8786
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x8, %rcx
movq %rcx, 0x10(%rax)
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x874b
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jflatow[P]jfdb/src/trie.c
// Function: make_jump_table
static inline JFT_Offset make_jump_table(JFT_Buffer *buf,
                                         JFT_Offset parentPos,
                                         const JFT_Stem *stem,
                                         JFT_TypeInfo rangeId) {
  // just create an offset for each symbol in the range
  int rangeSize = JumpTableRanges[rangeId].max - JumpTableRanges[rangeId].min + 1;
  JFT_Offset size = JFT_jump_size(stem->size, rangeSize);
  if (!JFT_buffer_ample(buf, size))
    return 0;

  JFT_Offset parentOffset = offset_parent(buf, parentPos, stem);
  write_node(buf, JumpTable, stem, rangeId, parentOffset);

  for (int i = 0; i < rangeSize; i++)
    JFT_buffer_equal(buf, JFT_Offset, 0);

  return size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, %ecx
leaq 0xbed(%rip), %rax       # 0x93b0
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %edx
leaq 0xbd6(%rip), %rcx       # 0x93b0
shlq $0x4, %rdx
addq %rdx, %rcx
subq (%rcx), %rax
addq $0x1, %rax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movzwl 0x8(%rax), %edi
movl -0x28(%rbp), %esi
callq 0x88c0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x80b0
cmpq $0x0, %rax
jne 0x881c
movq $0x0, -0x8(%rbp)
jmp 0x8894
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x8100
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
movq -0x38(%rbp), %r8
movl $0x2, %esi
callq 0x8150
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x888c
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x8, %rcx
movq %rcx, 0x10(%rax)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x8851
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/USArmyResearchLab[P]ARL_OpenSHMEM/src/autogen/shmem_int_atomic_fetch_add.c
// Function: shmem_int_atomic_fetch_add
int shmem_int_atomic_fetch_add( int* ptr, int val, int pe)
{
	int* remote_ptr = (int*)shmem_ptr((void*)ptr, pe ); 
	long* x = (long*)shmem_ptr((const void*)&__shmem.lock_atomic_int, pe);
	__set_spin_lock(x);
	int r = *remote_ptr;
	*remote_ptr = __sum(r,val);
	__clear_spin_lock(x);
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x2010
movq %rax, -0x18(%rbp)
movl -0x10(%rbp), %esi
leaq 0x2fd4(%rip), %rdi      # 0x71e0
addq $0x10, %rdi
callq 0x2010
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4580
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %ecx
addl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rdi
callq 0x4540
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/vusec[P]fpvi-scsb/leak_rate_win_size/exception_suppression.c
// Function: win_size_run
void win_size_run(win_size_func_t win_size_func)
{
    /* Setup */
    set_cpu(EXECUTER_CORE);
    memset(results, 0, sizeof(results));

    for(int j=0; j<ITER; j++)
    {
        flush(reload_buf);
        win_size_func(reload_buf);
        reload(reload_buf, results);
    }

    print_results(results, 1);
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x8(%rsp)
xorl %edi, %edi
callq 0x40b070
leaq 0x16b89(%rip), %rdi     # 0x419000
xorl %esi, %esi
movl $0x800, %edx            # imm = 0x800
callq 0x401090
movl $0x0, 0x4(%rsp)
cmpl $0x2710, 0x4(%rsp)      # imm = 0x2710
jge 0x4025e1
movq 0x17360(%rip), %rax     # 0x419800
movq %rax, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
cmpq $0x100, 0x10(%rsp)      # imm = 0x100
jae 0x4024dd
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
shlq $0xa, %rcx
addq %rcx, %rax
clflush (%rax)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x4024ae
mfence
movq 0x8(%rsp), %rax
movq 0x17314(%rip), %rdi     # 0x419800
callq *%rax
movq 0x1730b(%rip), %rax     # 0x419800
movq %rax, 0x50(%rsp)
leaq 0x16aff(%rip), %rax     # 0x419000
movq %rax, 0x48(%rsp)
mfence
movq $0x0, 0x40(%rsp)
cmpq $0x100, 0x40(%rsp)      # imm = 0x100
jae 0x4025cf
imulq $0xa7, 0x40(%rsp), %rax
addq $0xd, %rax
andq $0xff, %rax
movq %rax, 0x38(%rsp)
movq 0x50(%rsp), %rax
movq 0x38(%rsp), %rcx
shlq $0xa, %rcx
addq %rcx, %rax
movq %rax, 0x30(%rsp)
rdtscp
movq %rax, 0x70(%rsp)
movq %rdx, 0x68(%rsp)
movq 0x68(%rsp), %rax
shlq $0x20, %rax
orq 0x70(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
movb (%rax), %al
rdtscp
movq %rax, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x58(%rsp), %rax
shlq $0x20, %rax
orq 0x60(%rsp), %rax
subq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0xa0, 0x20(%rsp)
jae 0x4025bc
movq 0x48(%rsp), %rax
movq 0x38(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
addq $0x1, %rdx
movq %rdx, (%rax,%rcx,8)
movq 0x40(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x40(%rsp)
jmp 0x402512
jmp 0x4025d1
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x40248b
leaq 0x16a18(%rip), %rdi     # 0x419000
movl $0x1, %esi
callq 0x4020f0
addq $0x78, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vusec[P]fpvi-scsb/leak_rate_win_size/exception_suppression.c
// Function: fault_win_size_run
void fault_win_size_run()
{
    if (signal(SIGSEGV, segfault_handler) == SIG_ERR)
    {
        exit(1);
    }

    memset(results, 0, sizeof(results));
    for(int j=0; j<ITER; j++)
    {
        flush(reload_buf);
        if (!setjmp(buf)) {
            fault_win_size(reload_buf);
        }
        reload(reload_buf, results);
    }

    print_results(results, 1);
}

// Assembly:
subq $0x78, %rsp
movl $0xb, %edi
leaq 0x1c0(%rip), %rsi       # 0x4027f0
callq 0x4010d0
movq $-0x1, %rcx
cmpq %rcx, %rax
jne 0x40264b
movl $0x1, %edi
callq 0x401150
leaq 0x169ae(%rip), %rdi     # 0x419000
xorl %esi, %esi
movl $0x800, %edx            # imm = 0x800
callq 0x401090
movl $0x0, 0xc(%rsp)
cmpl $0x2710, 0xc(%rsp)      # imm = 0x2710
jge 0x4027cb
movq 0x17185(%rip), %rax     # 0x419800
movq %rax, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
cmpq $0x100, 0x10(%rsp)      # imm = 0x100
jae 0x4026b8
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
shlq $0xa, %rcx
addq %rcx, %rax
clflush (%rax)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x402689
mfence
leaq 0x1714e(%rip), %rdi     # 0x419810
callq 0x4010c0
cmpl $0x0, %eax
jne 0x4026d8
movq 0x1712d(%rip), %rdi     # 0x419800
callq 0x403020
movq 0x17121(%rip), %rax     # 0x419800
movq %rax, 0x50(%rsp)
leaq 0x16915(%rip), %rax     # 0x419000
movq %rax, 0x48(%rsp)
mfence
movq $0x0, 0x40(%rsp)
cmpq $0x100, 0x40(%rsp)      # imm = 0x100
jae 0x4027b9
imulq $0xa7, 0x40(%rsp), %rax
addq $0xd, %rax
andq $0xff, %rax
movq %rax, 0x38(%rsp)
movq 0x50(%rsp), %rax
movq 0x38(%rsp), %rcx
shlq $0xa, %rcx
addq %rcx, %rax
movq %rax, 0x30(%rsp)
rdtscp
movq %rax, 0x70(%rsp)
movq %rdx, 0x68(%rsp)
movq 0x68(%rsp), %rax
shlq $0x20, %rax
orq 0x70(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
movb (%rax), %al
rdtscp
movq %rax, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x58(%rsp), %rax
shlq $0x20, %rax
orq 0x60(%rsp), %rax
subq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0xa0, 0x20(%rsp)
jae 0x4027a6
movq 0x48(%rsp), %rax
movq 0x38(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
addq $0x1, %rdx
movq %rdx, (%rax,%rcx,8)
movq 0x40(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x40(%rsp)
jmp 0x4026fc
jmp 0x4027bb
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x402666
leaq 0x1682e(%rip), %rdi     # 0x419000
movl $0x1, %esi
callq 0x4020f0
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]rx-0/misc/wwas.c
// Function: err
void
err(int n, char *fmt, ...)
{
	va_list ap;
	va_start(ap, fmt);
	fprintf(stderr, "%s:%d: ", filename, lineno);
	vfprintf(stderr, fmt, ap);
	fprintf(stderr, "\n");
	va_end(ap);

	if(n)
		exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x12a8
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq 0x3d02(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq 0x4050(%rip), %rdx      # 0x5350
movl 0x3dce(%rip), %ecx      # 0x50d4
leaq 0x1e77(%rip), %rsi      # 0x3184
movb $0x0, %al
callq 0x10c0
movq 0x3cdd(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x1120
movq 0x3cc6(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1ea3(%rip), %rsi      # 0x31df
movb $0x0, %al
callq 0x10c0
leaq -0x30(%rbp), %rax
cmpl $0x0, -0x4(%rbp)
je 0x1357
movl $0x1, %edi
callq 0x1140
addq $0xe0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/aap[P]rx-0/misc/wwas.c
// Function: panic
void
panic(char *fmt, ...)
{
	va_list ap;
	va_start(ap, fmt);
	vfprintf(stderr, fmt, ap);
	fprintf(stderr, "\n");
	va_end(ap);
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x1395
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x3c11(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x1120
movq 0x3bfa(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1dd7(%rip), %rsi      # 0x31df
movb $0x0, %al
callq 0x10c0
leaq -0x20(%rbp), %rax
movl $0x1, %edi
callq 0x1140
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]rx-0/misc/wwas.c
// Function: mustmalloc
void*
mustmalloc(size_t size)
{
	void *p;
	p = malloc(size);
	if(p == nil)
		panic("out of memory");
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10f0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x149e
leaq 0x1d0c(%rip), %rdi      # 0x31a3
movb $0x0, %al
callq 0x1360
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]rx-0/misc/wwas.c
// Function: list
void
list(char *left)
{
	if(left == nil)
		left = "          \t";
	if(line[0])
		fprintf(lstfp, "%s%05d    %s", left, lastlistline, line);
	else
		fprintf(lstfp, "%s\n", left);
	line[0] = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x14ce
leaq 0x1ce7(%rip), %rax      # 0x31b1
movq %rax, -0x8(%rbp)
cmpb $0x0, 0x3e8b(%rip)      # 0x5360
je 0x14ff
movq 0x3ed2(%rip), %rdi      # 0x53b0
movq -0x8(%rbp), %rdx
movl 0x3bf0(%rip), %ecx      # 0x50d8
leaq 0x1cce(%rip), %rsi      # 0x31bd
leaq 0x3e6a(%rip), %r8       # 0x5360
movb $0x0, %al
callq 0x10c0
jmp 0x1518
movq 0x3eaa(%rip), %rdi      # 0x53b0
movq -0x8(%rbp), %rdx
leaq 0x1cb9(%rip), %rsi      # 0x31ca
movb $0x0, %al
callq 0x10c0
movb $0x0, 0x3e41(%rip)      # 0x5360
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]rx-0/misc/wwas.c
// Function: listsyms
void
listsyms(void)
{
	Sym *s;

	qsort(symtab, MAXSYM, sizeof(Sym), cmpsym);
	fprintf(lstfp, "\n    SYMBOL TABLE\n");
	for(s = symtab; s < &symtab[MAXSYM]; s++){
		if((s->type&7) != SymValue)
			continue;
		fprintf(lstfp, "%-07s %06o\n", s->name, s->val);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x3e51(%rip), %rdi      # 0x53c0
movl $0xfa0, %esi            # imm = 0xFA0
movl $0x18, %edx
leaq -0x50(%rip), %rcx       # 0x1530
callq 0x1050
movq 0x3e24(%rip), %rdi      # 0x53b0
leaq 0x1c3b(%rip), %rsi      # 0x31ce
movb $0x0, %al
callq 0x10c0
leaq 0x3e1f(%rip), %rax      # 0x53c0
movq %rax, -0x8(%rbp)
leaq 0x3e14(%rip), %rax      # 0x53c0
addq $0x17700, %rax          # imm = 0x17700
cmpq %rax, -0x8(%rbp)
jae 0x15f8
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x7, %eax
cmpl $0x1, %eax
je 0x15c9
jmp 0x15ea
movq 0x3de0(%rip), %rdi      # 0x53b0
movq -0x8(%rbp), %rdx
movq -0x8(%rbp), %rax
movzwl 0x10(%rax), %ecx
leaq 0x1bfe(%rip), %rsi      # 0x31e1
movb $0x0, %al
callq 0x10c0
movq -0x8(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x8(%rbp)
jmp 0x15a5
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aap[P]rx-0/misc/wwas.c
// Function: ch
int
ch(void)
{
	int c;

tail:
	if(peekc){
		c = peekc;
		peekc = 0;
		return c;
	}

	/* listing */
	if(pass2 && lastlistline != lineno){
		/* if line hasn't been printed yet, do it now */
		if(line[0])
			list(nil);

		int pos = ftell(infp);
		char *p;
		for(p = line; p < &line[80-2]; p++){
			c = getc(infp);
			if(c == '\n' || c == EOF)
				break;
			*p = c;
		}
		if(!(p == line && c == EOF))
			*p++ = '\n';
		*p++ = '\0';
		fseek(infp, pos, SEEK_SET);
		lastlistline = lineno;
	}

	c = getc(infp);
	if(c == EOF)
		return EOF;
	if(c == '\n')
		lineno++;
	// We only want ASCII!!
	c &= 0177;
	if(tmpfp)
		putc(c, tmpfp);

	return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
cmpl $0x0, 0x1b4b1(%rip)     # 0x1cac0
je 0x162f
movl 0x1b4a9(%rip), %eax     # 0x1cac0
movl %eax, -0x8(%rbp)
movl $0x0, 0x1b49c(%rip)     # 0x1cac0
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1771
cmpl $0x0, 0x1b48e(%rip)     # 0x1cac4
je 0x1716
movl 0x3a96(%rip), %eax      # 0x50d8
cmpl 0x3a8c(%rip), %eax      # 0x50d4
je 0x1716
cmpb $0x0, 0x3d0b(%rip)      # 0x5360
je 0x1660
xorl %eax, %eax
movl %eax, %edi
callq 0x14b0
movq 0x1b461(%rip), %rdi     # 0x1cac8
callq 0x10d0
movl %eax, -0xc(%rbp)
leaq 0x3cea(%rip), %rax      # 0x5360
movq %rax, -0x18(%rbp)
leaq 0x3cdf(%rip), %rax      # 0x5360
addq $0x4e, %rax
cmpq %rax, -0x18(%rbp)
jae 0x16c1
movq 0x1b436(%rip), %rdi     # 0x1cac8
callq 0x1150
movl %eax, -0x8(%rbp)
cmpl $0xa, -0x8(%rbp)
je 0x16a6
cmpl $-0x1, -0x8(%rbp)
jne 0x16a8
jmp 0x16c1
movl -0x8(%rbp), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x167a
leaq 0x3c98(%rip), %rax      # 0x5360
cmpq %rax, -0x18(%rbp)
jne 0x16d4
cmpl $-0x1, -0x8(%rbp)
je 0x16e6
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb $0xa, (%rax)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb $0x0, (%rax)
movq 0x1b3c9(%rip), %rdi     # 0x1cac8
movslq -0xc(%rbp), %rsi
xorl %edx, %edx
callq 0x1100
movl 0x39c4(%rip), %eax      # 0x50d4
movl %eax, 0x39c2(%rip)      # 0x50d8
movq 0x1b3ab(%rip), %rdi     # 0x1cac8
callq 0x1150
movl %eax, -0x8(%rbp)
cmpl $-0x1, -0x8(%rbp)
jne 0x1734
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1771
cmpl $0xa, -0x8(%rbp)
jne 0x1749
movl 0x3994(%rip), %eax      # 0x50d4
addl $0x1, %eax
movl %eax, 0x398b(%rip)      # 0x50d4
movl -0x8(%rbp), %eax
andl $0x7f, %eax
movl %eax, -0x8(%rbp)
cmpq $0x0, 0x1b376(%rip)     # 0x1cad0
je 0x176b
movl -0x8(%rbp), %edi
movq 0x1b36a(%rip), %rsi     # 0x1cad0
callq 0x10b0
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]rx-0/misc/wwas.c
// Function: chsp
int
chsp(void)
{
	int c;
	while(c = ch(),
		c == ' ' || c == '\t' || c == '\r' || c == '\v');
	return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x1600
movl %eax, -0x4(%rbp)
movb $0x1, %al
cmpl $0x20, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x17db
movb $0x1, %al
cmpl $0x9, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x17db
movb $0x1, %al
cmpl $0xd, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x17db
cmpl $0xb, -0x4(%rbp)
sete %al
movb %al, -0x5(%rbp)
movb -0x5(%rbp), %al
testb $0x1, %al
jne 0x17e4
jmp 0x17e6
jmp 0x17a8
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aap[P]rx-0/misc/wwas.c
// Function: findsym
Sym*
findsym(char *name)
{
	Sym *s;
	for(s = symtab; s < &symtab[MAXSYM]; s++)
		if(strncmp(s->name, name, SYMLEN) == 0)
			return s;
	return nil;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x3b9d(%rip), %rax      # 0x53c0
movq %rax, -0x18(%rbp)
leaq 0x3b92(%rip), %rax      # 0x53c0
addq $0x17700, %rax          # imm = 0x17700
cmpq %rax, -0x18(%rbp)
jae 0x186b
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x6, %edx
callq 0x1040
cmpl $0x0, %eax
jne 0x185b
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1873
jmp 0x185d
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
jmp 0x1827
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]rx-0/misc/wwas.c
// Function: getsym
Sym*
getsym(char *name)
{
	Sym *s;
	s = findsym(name);
	if(s == nil){
		for(s = symtab; s < &symtab[MAXSYM]; s++)
			if(s->name[0] == 0)
				goto found;
		panic("symbol table full");
found:
		strncpy(s->name, name, SYMLEN);
		s->type = None;
		s->val = 0;
	}
	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1810
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1911
leaq 0x3b19(%rip), %rax      # 0x53c0
movq %rax, -0x10(%rbp)
leaq 0x3b0e(%rip), %rax      # 0x53c0
addq $0x17700, %rax          # imm = 0x17700
cmpq %rax, -0x10(%rbp)
jae 0x18dc
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x18cc
jmp 0x18ea
jmp 0x18ce
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x10(%rbp)
jmp 0x18ab
leaq 0x190a(%rip), %rdi      # 0x31ed
movb $0x0, %al
callq 0x1360
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x6, %edx
callq 0x1030
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movw $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]rx-0/misc/wwas.c
// Function: number
Token
number(void)
{
	int c;
	Token t;

	t.type = TokWord;
	t.w = 0;
	while(isdigit(c = ch())){
		if(c-'0' >= radix)
			err(0, "warning: invalid digit in current base");
		t.w = t.w*radix + c-'0';
	}
	peekc = c;
	if(c && !ispunc(c)){
		err(0, "warning: ignored characters after number");
		while(c = ch(), c != EOF && !ispunc(c));
		peekc = c;
	}
	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x82, -0x10(%rbp)
movw $0x0, -0x8(%rbp)
callq 0x1160
movq (%rax), %rax
movq %rax, -0x20(%rbp)
callq 0x1600
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, -0x14(%rbp)
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x19c5
movl -0x14(%rbp), %eax
subl $0x30, %eax
cmpl 0x3734(%rip), %eax      # 0x50d0
jl 0x19ae
xorl %edi, %edi
leaq 0x186f(%rip), %rsi      # 0x3216
movb $0x0, %al
callq 0x1270
movzwl -0x8(%rbp), %eax
imull 0x3717(%rip), %eax      # 0x50d0
addl -0x14(%rbp), %eax
subl $0x30, %eax
movw %ax, -0x8(%rbp)
jmp 0x1965
movl -0x14(%rbp), %eax
movl %eax, 0x1b0f2(%rip)     # 0x1cac0
cmpl $0x0, -0x14(%rbp)
je 0x1a31
movl -0x14(%rbp), %eax
movsbl %al, %edi
callq 0x1920
cmpl $0x0, %eax
jne 0x1a31
xorl %edi, %edi
leaq 0x1850(%rip), %rsi      # 0x323d
movb $0x0, %al
callq 0x1270
callq 0x1600
movl %eax, -0x14(%rbp)
xorl %eax, %eax
cmpl $-0x1, -0x14(%rbp)
movb %al, -0x21(%rbp)
je 0x1a1d
movl -0x14(%rbp), %eax
movsbl %al, %edi
callq 0x1920
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x1a26
jmp 0x1a28
jmp 0x19f4
movl -0x14(%rbp), %eax
movl %eax, 0x1b08f(%rip)     # 0x1cac0
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aap[P]rx-0/misc/wwas.c
// Function: symbol
Token
symbol(void)
{
	char symbuf[SYMLEN+1];
	int c;
	Token t;
	int len;

	len = 0;
	memset(symbuf, 0, sizeof(symbuf));
	while(c = ch(), issymchar(c))
		if(len<SYMLEN)
			symbuf[len++] = tolower(c);
	peekc = c;
	t.type = TokSymbol;
	t.sym = getsym(symbuf);
	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x20(%rbp)
leaq -0x17(%rbp), %rdi
xorl %esi, %esi
movl $0x7, %edx
callq 0x1090
callq 0x1600
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
callq 0x1a40
cmpl $0x0, %eax
je 0x1ae7
cmpl $0x6, -0x20(%rbp)
jge 0x1ae5
movl -0x1c(%rbp), %edi
callq 0x10e0
movb %al, %cl
movl -0x20(%rbp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, -0x20(%rbp)
cltq
movb %cl, -0x17(%rbp,%rax)
jmp 0x1aaf
movl -0x1c(%rbp), %eax
movl %eax, 0x1afd0(%rip)     # 0x1cac0
movl $0x81, -0x10(%rbp)
leaq -0x17(%rbp), %rdi
callq 0x1880
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]rx-0/misc/wwas.c
// Function: putword
void
putword(word w)
{
	static char left[64];

	if(pass2){
		/* listing */
		sprintf(left, "%04o  %06o\t", dot->val, w);
		list(left);

		fprintf(outfp, "%o: %o\n", dot->val++, w);
	}else{
		// this is probably useless...
		memory[dot->val++] = w;
	}
	dot->val &= W;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
cmpl $0x0, 0x1ad6e(%rip)     # 0x1cac4
je 0x1dbc
movq 0x1ad89(%rip), %rax     # 0x1cae8
movzwl 0x10(%rax), %edx
movzwl -0x2(%rbp), %ecx
leaq 0x1ad82(%rip), %rdi     # 0x1caf0
leaq 0x151e(%rip), %rsi      # 0x3293
movb $0x0, %al
callq 0x1130
leaq 0x1ad6d(%rip), %rdi     # 0x1caf0
callq 0x14b0
movq 0x1ada1(%rip), %rdi     # 0x1cb30
movq 0x1ad52(%rip), %rcx     # 0x1cae8
movw 0x10(%rcx), %ax
movw %ax, %dx
addw $0x1, %dx
movw %dx, 0x10(%rcx)
movzwl %ax, %edx
movzwl -0x2(%rbp), %ecx
leaq 0x14ec(%rip), %rsi      # 0x329f
movb $0x0, %al
callq 0x10c0
jmp 0x1de6
movw -0x2(%rbp), %dx
movq 0x1ad21(%rip), %rcx     # 0x1cae8
movw 0x10(%rcx), %ax
movw %ax, %si
addw $0x1, %si
movw %si, 0x10(%rcx)
movzwl %ax, %eax
movl %eax, %ecx
leaq 0x1ad5e(%rip), %rax     # 0x1cb40
movw %dx, (%rax,%rcx,2)
movq 0x1acfb(%rip), %rax     # 0x1cae8
movzwl 0x10(%rax), %ecx
andl $0xffff, %ecx           # imm = 0xFFFF
movw %cx, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]rx-0/misc/wwas.c
// Function: writelits
void
writelits(void)
{
	word a;
	static char left[64];

	fprintf(lstfp, "\n    LITERALS\n");
	for(a = litdot; a < 04000; a++){
		/* listing */
		sprintf(left, "%04o  %06o\t", a, memory[a]);
		list(left);

		fprintf(outfp, "%o: %o\n", a, memory[a]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x3591(%rip), %rdi      # 0x53b0
leaq 0x1481(%rip), %rsi      # 0x32a7
movb $0x0, %al
callq 0x10c0
movw 0x1bd4c(%rip), %ax      # 0x1db80
movw %ax, -0x2(%rbp)
movzwl -0x2(%rbp), %eax
cmpl $0x800, %eax            # imm = 0x800
jge 0x1eb1
movzwl -0x2(%rbp), %edx
movzwl -0x2(%rbp), %eax
movl %eax, %ecx
leaq 0x1acec(%rip), %rax     # 0x1cb40
movzwl (%rax,%rcx,2), %ecx
leaq 0x1bce1(%rip), %rdi     # 0x1db40
leaq 0x142d(%rip), %rsi      # 0x3293
movb $0x0, %al
callq 0x1130
leaq 0x1bccc(%rip), %rdi     # 0x1db40
callq 0x14b0
movq 0x1acb0(%rip), %rdi     # 0x1cb30
movzwl -0x2(%rbp), %edx
movzwl -0x2(%rbp), %eax
movl %eax, %ecx
leaq 0x1acaf(%rip), %rax     # 0x1cb40
movzwl (%rax,%rcx,2), %ecx
leaq 0x1403(%rip), %rsi      # 0x329f
movb $0x0, %al
callq 0x10c0
movw -0x2(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x2(%rbp)
jmp 0x1e38
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]rx-0/misc/wwas.c
// Function: putlit
word
putlit(word w)
{
	word a;

	for(a = litdot; a < 04000; a++)
		if(memory[a] == w)
			return a;
	if(litdot == 0)
		err(1, "error: too many literals");
	a = --litdot;
	memory[a] = w;
	return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %di, %ax
movw %ax, -0x4(%rbp)
movw 0x1bcaa(%rip), %ax      # 0x1db80
movw %ax, -0x6(%rbp)
movzwl -0x6(%rbp), %eax
cmpl $0x800, %eax            # imm = 0x800
jge 0x1f18
movzwl -0x6(%rbp), %eax
movl %eax, %ecx
leaq 0x1ac4e(%rip), %rax     # 0x1cb40
movzwl (%rax,%rcx,2), %eax
movzwl -0x4(%rbp), %ecx
cmpl %ecx, %eax
jne 0x1f08
movw -0x6(%rbp), %ax
movw %ax, -0x2(%rbp)
jmp 0x1f6a
jmp 0x1f0a
movw -0x6(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x6(%rbp)
jmp 0x1eda
movzwl 0x1bc61(%rip), %eax     # 0x1db80
cmpl $0x0, %eax
jne 0x1f37
movl $0x1, %edi
leaq 0x1386(%rip), %rsi      # 0x32b6
movb $0x0, %al
callq 0x1270
movw 0x1bc42(%rip), %ax      # 0x1db80
addw $-0x1, %ax
movw %ax, 0x1bc37(%rip)      # 0x1db80
movw %ax, -0x6(%rbp)
movw -0x4(%rbp), %dx
movzwl -0x6(%rbp), %eax
movl %eax, %ecx
leaq 0x1abe2(%rip), %rax     # 0x1cb40
movw %dx, (%rax,%rcx,2)
movw -0x6(%rbp), %ax
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]rx-0/misc/wwas.c
// Function: combine
word
combine(int op, word w1, word w2)
{
	switch(op){
	case 0:
		return w2;
	case '+':
		w1 += w2;
		if(w1 & 0200000)
			w1 += 1;
		return w1 & W;
	case '-':
		w1 += ~w2 & W;
		if(w1 & 0200000)
			w1 += 1;
		return w1 & W;
	case ' ':
	case '!':
		return (w1 | w2) & W;
	case '&':
		return (w1 & w2) & W;
	default:
		panic("unknown operator %c", op);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %dx, %ax
movw %si, %cx
movl %edi, -0x8(%rbp)
movw %cx, -0xa(%rbp)
movw %ax, -0xc(%rbp)
movl -0x8(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x2d, %rax
ja 0x206d
movq -0x18(%rbp), %rax
leaq 0x1117(%rip), %rcx      # 0x30cc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movw -0xc(%rbp), %ax
movw %ax, -0x2(%rbp)
jmp 0x2084
movzwl -0xc(%rbp), %ecx
movzwl -0xa(%rbp), %eax
addl %ecx, %eax
movw %ax, -0xa(%rbp)
movzwl -0xa(%rbp), %eax
andl $0x10000, %eax          # imm = 0x10000
cmpl $0x0, %eax
je 0x1ff2
movzwl -0xa(%rbp), %eax
addl $0x1, %eax
movw %ax, -0xa(%rbp)
movzwl -0xa(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movw %ax, -0x2(%rbp)
jmp 0x2084
movzwl -0xc(%rbp), %ecx
xorl $-0x1, %ecx
andl $0xffff, %ecx           # imm = 0xFFFF
movzwl -0xa(%rbp), %eax
addl %ecx, %eax
movw %ax, -0xa(%rbp)
movzwl -0xa(%rbp), %eax
andl $0x10000, %eax          # imm = 0x10000
cmpl $0x0, %eax
je 0x2034
movzwl -0xa(%rbp), %eax
addl $0x1, %eax
movw %ax, -0xa(%rbp)
movzwl -0xa(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movw %ax, -0x2(%rbp)
jmp 0x2084
movzwl -0xa(%rbp), %eax
movzwl -0xc(%rbp), %ecx
orl %ecx, %eax
andl $0xffff, %eax           # imm = 0xFFFF
movw %ax, -0x2(%rbp)
jmp 0x2084
movzwl -0xa(%rbp), %eax
movzwl -0xc(%rbp), %ecx
andl %ecx, %eax
andl $0xffff, %eax           # imm = 0xFFFF
movw %ax, -0x2(%rbp)
jmp 0x2084
movl -0x8(%rbp), %esi
leaq 0x1258(%rip), %rdi      # 0x32cf
movb $0x0, %al
callq 0x1360
movw $0x0, -0x2(%rbp)
movw -0x2(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aap[P]rx-0/misc/wwas.c
// Function: assemble
void
assemble(void)
{
	peekt.type = None;
	while(peek() != EOF)
		statement();

	// list last line
	if(pass2 && line[0])
		list(nil);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, 0x1a57a(%rip)     # 0x1cad8
callq 0x1780
cmpl $-0x1, %eax
je 0x256f
callq 0x22d0
jmp 0x255e
cmpl $0x0, 0x1a54e(%rip)     # 0x1cac4
je 0x258d
movsbl 0x2de1(%rip), %eax      # 0x5360
cmpl $0x0, %eax
je 0x258d
xorl %eax, %eax
movl %eax, %edi
callq 0x14b0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aap[P]rx-0/misc/wwas.c
// Function: checkundef
void
checkundef(void)
{
	int i;
	int e;

	e = 0;
	for(i = 0; i < MAXSYM; i++)
		if(symtab[i].name[0] && symtab[i].type == None){
			err(0, "error: %s undefined", symtab[i].name);
			e = 1;
		}
	if(e)
		err(1, "errors in first pass");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x8(%rbp)
movl $0x0, -0x4(%rbp)
cmpl $0xfa0, -0x4(%rbp)      # imm = 0xFA0
jge 0x2617
movslq -0x4(%rbp), %rcx
leaq 0x2e06(%rip), %rax      # 0x53c0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x260a
movslq -0x4(%rbp), %rcx
leaq 0x2dec(%rip), %rax      # 0x53c0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x8(%rax)
jne 0x260a
movslq -0x4(%rbp), %rax
leaq 0x2dd4(%rip), %rdx      # 0x53c0
imulq $0x18, %rax, %rax
addq %rax, %rdx
xorl %edi, %edi
leaq 0xd9f(%rip), %rsi       # 0x339b
movb $0x0, %al
callq 0x1270
movl $0x1, -0x8(%rbp)
jmp 0x260c
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x25a6
cmpl $0x0, -0x8(%rbp)
je 0x2630
movl $0x1, %edi
leaq 0xd86(%rip), %rsi       # 0x33af
movb $0x0, %al
callq 0x1270
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]rx-0/misc/wwas.c
// Function: initsymtab
void
initsymtab(void)
{
	int i;
	Sym *s;

	for(i = 0; valtab[i].sym; i++){
		s = getsym(valtab[i].sym);
		s->type = SymValue;
		s->val = valtab[i].val;
	}
/*
	for(i = 0; pseudtab[i].sym; i++){
		s = getsym(sixbit(pseudtab[i].sym));
		s->type = SymPseudo;
		s->f = pseudtab[i].f;
	}
*/
	dot = findsym(".");
	dot->type = SymValue;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x2a96(%rip), %rax      # 0x50f0
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x26b9
movslq -0x4(%rbp), %rcx
leaq 0x2a7e(%rip), %rax      # 0x50f0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x1880
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x1, 0x8(%rax)
movslq -0x4(%rbp), %rcx
leaq 0x2a55(%rip), %rax      # 0x50f0
shlq $0x4, %rcx
addq %rcx, %rax
movw 0x8(%rax), %cx
movq -0x10(%rbp), %rax
movw %cx, 0x10(%rax)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x264f
leaq 0xd04(%rip), %rdi       # 0x33c4
callq 0x1810
movq %rax, 0x1a41c(%rip)     # 0x1cae8
movq 0x1a415(%rip), %rax     # 0x1cae8
movl $0x1, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/aap[P]rx-0/misc/wwas.c
// Function: main
int
main(int argc, char *argv[])
{
	int i;

	infp = stdin;
	filename = "<stdin>";
	tmpfp = mustopen("tmptmp", "wb");

	initsymtab();

	litdot = 04000;
	dot->val = 040;
	pass2 = 0;
	assemble();

	checkundef();

	pass2 = 1;
	fclose(tmpfp);
	tmpfp = nil;
	infp = mustopen("tmptmp", "rb");
	outfp = mustopen("out.mem", "wb");

	lstfp = mustopen("out.lst", "w");
	litdot = 04000;
	dot->val = 040;
	lineno = 1;
	peekc = 0;
	assemble();

	writelits();

	fclose(infp);
	fclose(outfp);

	listsyms();

	printf("start: %o\n", startaddr);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x28db(%rip), %rax      # 0x4fd8
movq (%rax), %rax
movq %rax, 0x1a3c1(%rip)     # 0x1cac8
leaq 0xd27(%rip), %rax       # 0x3435
movq %rax, 0x2c3b(%rip)      # 0x5350
leaq 0xd21(%rip), %rdi       # 0x343d
leaq 0xd21(%rip), %rsi       # 0x3444
callq 0x1420
movq %rax, 0x1a3a1(%rip)     # 0x1cad0
callq 0x2640
movw $0x800, 0x1b443(%rip)   # imm = 0x800
movq 0x1a3a4(%rip), %rax     # 0x1cae8
movw $0x20, 0x10(%rax)
movl $0x0, 0x1a370(%rip)     # 0x1cac4
callq 0x2550
callq 0x2590
movl $0x1, 0x1a35c(%rip)     # 0x1cac4
movq 0x1a361(%rip), %rdi     # 0x1cad0
callq 0x1060
movq $0x0, 0x1a351(%rip) # 0x1cad0
leaq 0xcb7(%rip), %rdi       # 0x343d
leaq 0xcba(%rip), %rsi       # 0x3447
callq 0x1420
movq %rax, 0x1a32f(%rip)     # 0x1cac8
leaq 0xcaa(%rip), %rdi       # 0x344a
leaq 0xc9d(%rip), %rsi       # 0x3444
callq 0x1420
movq %rax, 0x1a37d(%rip)     # 0x1cb30
leaq 0xc98(%rip), %rdi       # 0x3452
leaq 0xc99(%rip), %rsi       # 0x345a
callq 0x1420
movq %rax, 0x2be3(%rip)      # 0x53b0
movw $0x800, 0x1b3aa(%rip)   # imm = 0x800
movq 0x1a30b(%rip), %rax     # 0x1cae8
movw $0x20, 0x10(%rax)
movl $0x1, 0x28e7(%rip)      # 0x50d4
movl $0x0, 0x1a2c9(%rip)     # 0x1cac0
callq 0x2550
callq 0x1e10
movq 0x1a2c0(%rip), %rdi     # 0x1cac8
callq 0x1060
movq 0x1a31c(%rip), %rdi     # 0x1cb30
callq 0x1060
callq 0x1560
movzwl 0x1b35d(%rip), %esi     # 0x1db82
leaq 0xc30(%rip), %rdi       # 0x345c
movb $0x0, %al
callq 0x1080
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/barabo[P]advanced-shell-history/src/_ash_log.cpp
// Function: usage(std::ostream&)
void usage(ostream & out) {
  out << "\n\nThis program is not intended to be executed manually.\n\n"
      << "NOTE: See the man page for more details.\n";
  Flag::show_help(out);
  exit(1);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
leaq 0x1ded6(%rip), %rsi     # 0xa9106
callq 0x83d0
movq %rax, %rdi
leaq 0x1df01(%rip), %rsi     # 0xa9140
callq 0x83d0
movq (%rsp), %rdi
callq 0x95a60
movl $0x1, %edi
callq 0x84d0
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/back1127[P]linkedge-thing-access-websocket_client_sdk/demo/linux/demo.c
// Function: get_device_index
int get_device_index(const char *pk, const char *dn)
{
    int i;
    
    for (i = 0; i < g_devices_count; i++) {
        if (strcmp(g_devices[i].dn, dn) == 0) {
            return i;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl 0x3e38(%rip), %eax      # 0x5198
jge 0x139b
movq 0x3e37(%rip), %rdi      # 0x51a0
movslq -0x1c(%rbp), %rax
imulq $0x3c, %rax, %rax
addq %rax, %rdi
addq $0x10, %rdi
movq -0x18(%rbp), %rsi
callq 0x11a0
cmpl $0x0, %eax
jne 0x138e
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x139b
jmp 0x1390
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1357
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/back1127[P]linkedge-thing-access-websocket_client_sdk/demo/linux/demo.c
// Function: set_led_power
int set_led_power(const char *pk, const char *dn, int state)
{
    int index;
    
    if (0 != state && 1 != state) {
        return LE_ERROR_PARAM_RANGE_OVERFLOW;
    }

    index = get_device_index(pk, dn);
    g_devices[index].power = state;
    return LE_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
xorl %eax, %eax
cmpl -0x1c(%rbp), %eax
je 0x13dd
movl $0x1, %eax
cmpl -0x1c(%rbp), %eax
je 0x13dd
movl $0x186a7, -0x4(%rbp)    # imm = 0x186A7
jmp 0x140c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1340
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %ecx
movq 0x3da9(%rip), %rax      # 0x51a0
movslq -0x20(%rbp), %rdx
imulq $0x3c, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x34(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/back1127[P]linkedge-thing-access-websocket_client_sdk/demo/linux/demo.c
// Function: set_led_brightness
int set_led_brightness(const char *pk, const char *dn, int level)
{
    int index;
    if (level < 0 || level > 5) {
        return LE_ERROR_PARAM_RANGE_OVERFLOW;
    }
    index = get_device_index(pk, dn);
    g_devices[index].brightness = level; 
    return LE_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x147f
cmpl $0x5, -0x1c(%rbp)
jle 0x1488
movl $0x186a7, -0x4(%rbp)    # imm = 0x186A7
jmp 0x14b7
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1340
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %ecx
movq 0x3cfe(%rip), %rax      # 0x51a0
movslq -0x20(%rbp), %rdx
imulq $0x3c, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x38(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/back1127[P]linkedge-thing-access-websocket_client_sdk/demo/linux/demo.c
// Function: thread_online
void* thread_online(void *arg)
{
    int count, i;
    char *pk, *dn;

    pthread_detach(pthread_self());

    count = g_devices_count;

    while (g_running) {
        pthread_mutex_lock(&g_mtx_online);
        pthread_cond_wait(&g_cond_conn_state_changed, &g_mtx_online);
        for (i = 0; i < count; i++) {
            if (g_is_connected) {
                if (LE_SUCCESS == leda_online(g_devices[i].pk, g_devices[i].dn)) {
                    g_devices[i].online = 1;
                }                
            } else {
                g_devices[i].online = 0; 
            }
        }
        pthread_mutex_unlock(&g_mtx_online);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
callq 0x1130
movq %rax, %rdi
callq 0x1190
movl 0x3c79(%rip), %eax      # 0x5198
movl %eax, -0x14(%rbp)
cmpl $0x0, 0x3c07(%rip)      # 0x5130
je 0x15f4
leaq 0x3c3a(%rip), %rdi      # 0x5170
callq 0x1220
leaq 0x3bfe(%rip), %rdi      # 0x5140
leaq 0x3c27(%rip), %rsi      # 0x5170
callq 0x11e0
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x15e3
cmpl $0x0, 0x3c34(%rip)      # 0x519c
je 0x15ba
movq 0x3c2f(%rip), %rdi      # 0x51a0
movslq -0x18(%rbp), %rax
imulq $0x3c, %rax, %rax
addq %rax, %rdi
movq 0x3c1d(%rip), %rsi      # 0x51a0
movslq -0x18(%rbp), %rax
imulq $0x3c, %rax, %rax
addq %rax, %rsi
addq $0x10, %rsi
callq 0x1180
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x15b8
movq 0x3bfa(%rip), %rax      # 0x51a0
movslq -0x18(%rbp), %rcx
imulq $0x3c, %rcx, %rcx
addq %rcx, %rax
movl $0x1, 0x30(%rax)
jmp 0x15d3
movq 0x3bdf(%rip), %rax      # 0x51a0
movslq -0x18(%rbp), %rcx
imulq $0x3c, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0x30(%rax)
jmp 0x15d5
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1555
leaq 0x3b86(%rip), %rdi      # 0x5170
callq 0x1230
jmp 0x1522
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/back1127[P]linkedge-thing-access-websocket_client_sdk/demo/linux/demo.c
// Function: sigint_handler
void sigint_handler(int sig)
{
    if (!g_running) {
        printf("force exit!\n");
        exit(0);
    }
    printf("caught signal: %s, device will exit in 30s ...\n", strsignal(sig));
    g_running = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, 0x393e(%rip)      # 0x5130
jne 0x1809
leaq 0x1827(%rip), %rdi      # 0x3022
movb $0x0, %al
callq 0x1030
xorl %edi, %edi
callq 0x1090
movl -0x4(%rbp), %edi
callq 0x10a0
movq %rax, %rsi
leaq 0x1814(%rip), %rdi      # 0x302f
movb $0x0, %al
callq 0x1030
movl $0x0, 0x3904(%rip)      # 0x5130
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)