LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/tabemann[P]attoforth/src/runtime/main.c
// Function: main
int main(int argc, char** argv) {
  af_global_t* global = af_global_init(argc, argv);
  if(!global) {
    abort();
  }
  af_global_execute(global);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x2430
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2412
callq 0x2050
movq -0x18(%rbp), %rdi
callq 0x28b0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tabemann[P]attoforth/src/runtime/inner.c
// Function: af_global_execute
void af_global_execute(af_global_t* global) {
  af_task_t* task = af_spawn(global, NULL);
  if(!task) {
    return;
  }
  af_register_prims(global, task);
  af_compile_builtin(global, task);
  task->interpreter_pointer = &global->base_interpreter_code[0];
  af_start(global, task);
  af_task_loop(global);
  af_io_cleanup_stdin();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2930
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x28d6
jmp 0x291e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5bd0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x196f0
movq -0x8(%rbp), %rcx
addq $0x1f0, %rcx            # imm = 0x1F0
movq -0x10(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2e80
movq -0x8(%rbp), %rdi
callq 0x2ee0
callq 0x17b10
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tabemann[P]attoforth/src/runtime/inner.c
// Function: af_start
void af_start(af_global_t* global, af_task_t* task) {
  if(!task->base_cycles_before_yield && !task->is_to_be_freed) {
    task->base_cycles_before_yield = task->current_cycles_before_yield =
      task->current_cycles_left = global->default_cycles_before_yield;
    af_schedule(global, task);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x2ed6
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x2ed6
movq -0x8(%rbp), %rax
movq 0x168(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3c40
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tabemann[P]attoforth/src/runtime/inner.c
// Function: af_free_task
void af_free_task(af_task_t* task) {
  if(task->free_data_on_exit) {
    free(task->data_space_base);
  }
  free(task->task_local_space_base);
  free(task->wordlist_order);
  free(task->data_stack_top);
  free(task->float_stack_top);
  free(task->return_stack_top);
  free(task);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x118(%rax)
je 0x312a
movq -0x8(%rbp), %rax
movq 0xd8(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x120(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0xb0(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rdi
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tabemann[P]attoforth/src/runtime/inner.c
// Function: af_inner_loop
void af_inner_loop(af_global_t* global, af_task_t* task) {
  if(!task->current_cycles_before_yield) {
    return;
  }
  global->current_task = task;
  task->current_cycles_left =
    task->current_cycles_before_yield + task->extra_cycles;
  if(task->current_cycles_left > global->max_cycles_before_yield) {
    task->extra_cycles =
      task->current_cycles_left - global->max_cycles_before_yield;
    task->current_cycles_left = global->max_cycles_before_yield;
    if(task->extra_cycles > global->max_extra_cycles) {
      task->extra_cycles = global->max_extra_cycles;
    }
  }
  if(task->init_word) {
    AF_WORD_EXECUTE(task, task->init_word);
  }
  task->init_word = NULL;
  while(task->current_cycles_left--) {
    af_compiled_t* interpreter_pointer = task->interpreter_pointer;
    af_word_t* word = interpreter_pointer->compiled_call;
    AF_WORD_EXECUTE(task, word);
  }
  task->yields++;
  global->current_task = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x31b0
jmp 0x330e
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
addq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x170(%rcx), %rax
jbe 0x3241
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x8(%rbp), %rax
subq 0x170(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x170(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x178(%rcx), %rax
jbe 0x323f
movq -0x8(%rbp), %rax
movq 0x178(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x3241
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x327c
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0xf8(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rdi
callq *%rax
movq -0x10(%rbp), %rax
movq $0x0, 0x50(%rax)
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, 0x28(%rcx)
cmpq $0x0, %rax
je 0x32e6
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0xf8(%rax)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq -0x40(%rbp), %rdi
callq *%rax
jmp 0x3288
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdx
movq 0x38(%rax), %rcx
addq $0x1, %rdx
adcq $0x0, %rcx
movq %rdx, 0x30(%rax)
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tabemann[P]attoforth/src/runtime/inner.c
// Function: af_bye
void af_bye(af_global_t* global) {
  af_task_t* task = global->first_task;
  while(task) {
    af_terminate(global, task);
    task = task->next_task;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x33b9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x33c0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x3397
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/tabemann[P]attoforth/src/runtime/inner.c
// Function: af_terminate
void af_terminate(af_global_t* global, af_task_t* task) {
  if(!task->is_to_be_freed) {
    if(task->terminate) {
      if(!task->current_cycles_before_yield) {
	task->current_cycles_before_yield =
	  global->default_cycles_before_yield;
	af_schedule(global, task);
      }
      AF_WORD_EXECUTE(task, task->terminate);
    } else {
      af_kill(global, task);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x3458
movq -0x10(%rbp), %rax
cmpq $0x0, 0x108(%rax)
je 0x3449
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x3414
movq -0x8(%rbp), %rax
movq 0x168(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3c40
movq -0x10(%rbp), %rax
movq 0x108(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0xf8(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rdi
callq *%rax
jmp 0x3456
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3c60
jmp 0x3458
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/tabemann[P]attoforth/src/runtime/inner.c
// Function: af_kill
void af_kill(af_global_t* global, af_task_t* task) {
  task->current_cycles_before_yield = 0;
  task->current_cycles_left = 0;
  task->is_to_be_freed = TRUE;
  global->task_count--;
  af_deschedule(global, task);
  af_handle_kill(global, task);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
movq $-0x1, 0x48(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3cd0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3cf0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tabemann[P]attoforth/src/runtime/inner.c
// Function: af_wait
void af_wait(af_global_t* global, af_task_t* task) {
  task->current_cycles_before_yield = 0;
  task->extra_cycles += task->current_cycles_left;
  if(task->extra_cycles > global->max_extra_cycles) {
    task->extra_cycles = global->max_extra_cycles;
  }
  task->current_cycles_left = 0;
  af_deschedule(global, task);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x10(%rbp), %rax
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x178(%rcx), %rax
jbe 0x3dc8
movq -0x8(%rbp), %rax
movq 0x178(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3cd0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tabemann[P]attoforth/src/runtime/inner.c
// Function: af_end_atomic
void af_end_atomic(af_global_t* global, af_task_t* task) {
  af_task_t* next_atomic_task;
  if(task == global->atomic_task) {
    next_atomic_task = af_get_nested_task(global);
    if(next_atomic_task && global->current_task != next_atomic_task) {
      next_atomic_task->nesting_level = -1;
      global->atomic_task = next_atomic_task;
      if(global->current_task) {
	af_yield(global, global->current_task);
      }
      af_wake(global, global->atomic_task);
    } else {
      global->atomic_task = NULL;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x218(%rcx), %rax
jne 0x3ec8
movq -0x8(%rbp), %rdi
callq 0x4080
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3eb7
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
je 0x3eb7
movq -0x18(%rbp), %rax
movq $-0x1, 0x130(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x218(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3ea1
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x3d40
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x218(%rax), %rsi
callq 0x3ed0
jmp 0x3ec6
movq -0x8(%rbp), %rax
movq $0x0, 0x218(%rax)
jmp 0x3ec8
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/tabemann[P]attoforth/src/runtime/inner.c
// Function: af_begin_atomic
void af_begin_atomic(af_global_t* global, af_task_t* task) {
  if(!global->atomic_task) {
    task->nesting_level = -1;
    global->atomic_task = task;
    if(global->current_task != global->atomic_task) {
      if(global->current_task) {
	af_yield(global, global->current_task);
      }
      af_wake(global, global->atomic_task);
    }
  } else if(task->nesting_level < 0 && task != global->atomic_task) {
    af_sign_cell_t level = af_get_nesting_level(global);
    level = level < 0 ? 0 : level + 1;
    task->nesting_level = level;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x218(%rax)
jne 0x3fa3
movq -0x10(%rbp), %rax
movq $-0x1, 0x130(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x218(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x218(%rcx), %rax
je 0x3fa1
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3f8d
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x3d40
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x218(%rax), %rsi
callq 0x3ed0
jmp 0x4003
movq -0x10(%rbp), %rax
cmpq $0x0, 0x130(%rax)
jge 0x4001
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x218(%rcx), %rax
je 0x4001
movq -0x8(%rbp), %rdi
callq 0x4010
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jge 0x3fde
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0x3fea
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x130(%rax)
jmp 0x4003
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tabemann[P]attoforth/src/runtime/inner.c
// Function: af_get_nesting_level
af_sign_cell_t af_get_nesting_level(af_global_t* global) {
  af_task_t* current_task = global->first_task;
  af_sign_cell_t level = current_task->nesting_level;
  while(current_task) {
    if(!current_task->is_to_be_freed && level < current_task->nesting_level ) {
      level = current_task->nesting_level;
    }
    current_task = current_task->next_task;
  }
  return level;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x130(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4072
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x4064
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x130(%rcx), %rax
jge 0x4064
movq -0x10(%rbp), %rax
movq 0x130(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x4032
movq -0x18(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tabemann[P]attoforth/src/runtime/inner.c
// Function: af_get_nested_task
af_task_t* af_get_nested_task(af_global_t* global) {
  af_task_t* current_task = global->first_task;
  af_task_t* nested_task = NULL;
  af_sign_cell_t level = current_task->nesting_level;
  while(current_task) {
    if(!current_task->is_to_be_freed) {
      if(((level > -1) && (current_task->nesting_level < level)) ||
	 ((level < 0) && (current_task->nesting_level > -1))) {
	nested_task = current_task;
	level = current_task->nesting_level;
      }
    }
    current_task = current_task->next_task;
  }
  return nested_task;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x130(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4110
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x4102
cmpq $-0x1, -0x20(%rbp)
jle 0x40d4
movq -0x10(%rbp), %rax
movq 0x130(%rax), %rax
cmpq -0x20(%rbp), %rax
jl 0x40e9
cmpq $0x0, -0x20(%rbp)
jge 0x4100
movq -0x10(%rbp), %rax
cmpq $-0x1, 0x130(%rax)
jle 0x4100
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x130(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x4102
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x40aa
movq -0x18(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tabemann[P]attoforth/src/runtime/inner.c
// Function: af_reset
void af_reset(af_global_t* global, af_task_t* task) {
  task->base_cycles_before_yield = global->default_cycles_before_yield;
  task->extra_cycles = 0;
  task->current_cycles_before_yield = global->default_cycles_before_yield;
  task->is_compiling = FALSE;
  task->interpreter_pointer = NULL;
  task->data_stack_current = task->data_stack_base;
  task->float_stack_current = task->float_stack_base;
  task->return_stack_current = task->return_stack_base;
  task->most_recent_word = NULL;
  task->base = 10;
  if(task->abort) {
    AF_WORD_EXECUTE(task, task->abort);
  } else {
    af_kill(global, task);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x168(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x168(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x58(%rax)
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x10(%rbp), %rax
movq 0xa0(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x70(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0xe0(%rax)
movq -0x10(%rbp), %rax
movq $0xa, 0xf0(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x100(%rax)
je 0x4214
movq -0x10(%rbp), %rax
movq 0x100(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0xf8(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rdi
callq *%rax
jmp 0x4221
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3c60
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tabemann[P]attoforth/src/runtime/inner.c
// Function: af_guarantee
void* af_guarantee(af_global_t* global, af_task_t* task, size_t size) {
  size_t size_remaining = task->data_space_top - task->data_space_current;
  if((size <= size_remaining) &&
     (global->min_guaranteed_data_space_size <= size_remaining ||
      task->free_data_on_exit)) {
    return task->data_space_current;
  } else if(!task->free_data_on_exit) {
    void* new_data_space_base = malloc(global->default_data_space_size);
    task->data_space_base = new_data_space_base;
    task->data_space_current = new_data_space_base;
    task->data_space_top =
      new_data_space_base + global->default_data_space_size;
    return new_data_space_base;
  } else {
    af_handle_data_space_overflow(global, task);
    return NULL;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0xd0(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0xc8(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
ja 0x470b
movq -0x10(%rbp), %rax
movq 0x158(%rax), %rax
cmpq -0x28(%rbp), %rax
jbe 0x46fa
movq -0x18(%rbp), %rax
cmpq $0x0, 0x118(%rax)
je 0x470b
movq -0x18(%rbp), %rax
movq 0xc8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x4784
movq -0x18(%rbp), %rax
cmpq $0x0, 0x118(%rax)
jne 0x476f
movq -0x10(%rbp), %rax
movq 0x160(%rax), %rdi
callq 0x21f0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0xd8(%rax)
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0xc8(%rax)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x160(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0xd0(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4784
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4420
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/tabemann[P]attoforth/src/runtime/inner.c
// Function: af_allocate
void* af_allocate(af_global_t* global, af_task_t* task, size_t size) {
  void* base = af_guarantee(global, task, size);
  if(base) {
    task->data_space_current += size;
  }
  return base;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x46a0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x47d6
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0xc8(%rax), %rcx
movq %rcx, 0xc8(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/tabemann[P]attoforth/src/runtime/inner.c
// Function: af_allot
void* af_allot(af_global_t* global, af_task_t* task, ssize_t size) {
  ssize_t size_remaining = task->data_space_top - task->data_space_current;
  if(size_remaining >= size) {
    void* current = task->data_space_current;
    task->data_space_current += size;
    return current;
  } else {
    af_handle_data_space_overflow(global, task);
    return NULL;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0xd0(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0xc8(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jl 0x484a
movq -0x18(%rbp), %rax
movq 0xc8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
addq 0xc8(%rax), %rcx
movq %rcx, 0xc8(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x485f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4420
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tabemann[P]attoforth/src/runtime/inner.c
// Function: af_search_wordlist
af_word_t* af_search_wordlist(af_wordlist_t* wordlist, af_byte_t* name,
			      af_cell_t name_length) {
  af_word_t* current_word = wordlist->first_word;
  while(current_word) {
    af_byte_t current_word_length = AF_WORD_NAME_LEN(current_word);
    if(name_length == current_word_length &&
       !(current_word->flags & AF_WORD_HIDDEN)) {
      af_byte_t* current_name = name;
      af_byte_t* current_word_name = AF_WORD_NAME_DATA(current_word);
      af_byte_t current_name_length = name_length;
      af_bool_t differ = FALSE;
      while(current_name_length--) {
	if(toupper(*current_name++) != toupper(*current_word_name++)) {
	  differ = TRUE;
	  break;
	}
      }
      if(!differ) {
	return current_word;
      }
    }
    current_word = current_word->next_word;
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x497a
movq -0x28(%rbp), %rax
movb -0x1(%rax), %al
movb %al, -0x29(%rbp)
movq -0x20(%rbp), %rax
movzbl -0x29(%rbp), %ecx
cmpq %rcx, %rax
jne 0x4969
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
andq $0x2, %rax
cmpq $0x0, %rax
jne 0x4969
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq -0x28(%rbp), %rcx
movzbl -0x1(%rcx), %ecx
movslq %ecx, %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movb %al, -0x41(%rbp)
movq $0x0, -0x50(%rbp)
movb -0x41(%rbp), %al
movb %al, %cl
addb $-0x1, %cl
movb %cl, -0x41(%rbp)
cmpb $0x0, %al
je 0x4956
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x38(%rbp)
movzbl (%rax), %edi
callq 0x2080
movl %eax, -0x54(%rbp)
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x40(%rbp)
movzbl (%rax), %edi
callq 0x2080
movl %eax, %ecx
movl -0x54(%rbp), %eax
cmpl %ecx, %eax
je 0x4954
movq $-0x1, -0x50(%rbp)
jmp 0x4956
jmp 0x4901
cmpq $0x0, -0x50(%rbp)
jne 0x4967
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4982
jmp 0x4969
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x488f
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tabemann[P]attoforth/src/runtime/inner.c
// Function: af_lookup
af_word_t* af_lookup(af_global_t* global, af_task_t* task, af_byte_t* name,
		     af_cell_t name_length) {
  af_wordlist_t** wordlist = task->wordlist_order;
  af_cell_t wordlist_count = task->wordlist_order_count;
  while(wordlist_count--) {
    af_word_t* word = af_search_wordlist(*wordlist++, name, name_length);
    if(word) {
      return word;
    }
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0xb0(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0xb8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x38(%rbp)
cmpq $0x0, %rax
je 0x4a11
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x30(%rbp)
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x4870
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x4a0f
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4a19
jmp 0x49c6
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tabemann[P]attoforth/src/runtime/inner.c
// Function: af_parse_float
af_bool_t af_parse_float(af_global_t* global, af_byte_t* text,
			 size_t length, af_float_t* result) {
  char* buffer;
  char* end_ptr;
  af_float_t value;
  af_bool_t found = FALSE;
  for(af_cell_t i = 0; i < length; i++) {
    if(text[i] == 'e' || text[i] == 'E') {
      found = TRUE;
      if(i == length - 1) {
	length--;
      }
      break;
    }
  }
  if(!found) {
    return FALSE;
  }
  if(!(buffer = malloc(sizeof(af_byte_t) * (length + 1)))) {
    return FALSE;
  }
  memcpy(buffer, (void*)text, length);
  buffer[length] = '\0';
  
  value = strtod(buffer, &end_ptr);
  if(*end_ptr == 0) {
    free(buffer);
    *result = value;
    return TRUE;
  } else {
    free(buffer);
    return FALSE;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x0, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x50(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x4deb
movq -0x18(%rbp), %rax
movq -0x50(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x65, %eax
je 0x4db4
movq -0x18(%rbp), %rax
movq -0x50(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x45, %eax
jne 0x4ddb
movq $-0x1, -0x48(%rbp)
movq -0x50(%rbp), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x4dd9
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x4deb
jmp 0x4ddd
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x4d88
cmpq $0x0, -0x48(%rbp)
jne 0x4dff
movq $0x0, -0x8(%rbp)
jmp 0x4e90
movq -0x20(%rbp), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x21f0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x4e24
movq $0x0, -0x8(%rbp)
jmp 0x4e90
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x21c0
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x20a0
movsd %xmm0, -0x40(%rbp)
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x4e7f
movq -0x30(%rbp), %rdi
callq 0x2040
movsd -0x40(%rbp), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
movq $-0x1, -0x8(%rbp)
jmp 0x4e90
movq -0x30(%rbp), %rdi
callq 0x2040
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tabemann[P]attoforth/src/runtime/inner.c
// Function: af_word_available
af_bool_t af_word_available(af_global_t* global, af_task_t* task,
			    af_byte_t delimiter) {
  af_cell_t current_index;
  af_cell_t count;
  af_byte_t* buffer;
  af_byte_t current_char;
  if(!task->current_input) {
    return FALSE;
  }
  current_index = task->current_input->index;
  count = task->current_input->count;
  buffer = task->current_input->buffer;
  current_char = *(buffer + current_index);
  while(current_index < count && current_char == delimiter) {
    current_char = *(buffer + ++current_index);
  }
  if(current_index == count) {
    return FALSE;
  }
  if(!task->current_input->is_closed) {
    while(current_index < count && current_char != delimiter) {
      current_char = *(buffer + ++current_index);
    }
    return current_index < count;
  } else {
    return TRUE;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0xe8(%rax)
jne 0x52bc
movq $0x0, -0x8(%rbp)
jmp 0x53d3
movq -0x18(%rbp), %rax
movq 0xe8(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0xe8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0xe8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x39(%rbp)
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpq -0x30(%rbp), %rcx
movb %al, -0x3a(%rbp)
jae 0x5322
movzbl -0x39(%rbp), %eax
movzbl -0x19(%rbp), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x3a(%rbp)
movb -0x3a(%rbp), %al
testb $0x1, %al
jne 0x532b
jmp 0x5347
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movb 0x1(%rax,%rcx), %al
movb %al, -0x39(%rbp)
jmp 0x5303
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jne 0x535b
movq $0x0, -0x8(%rbp)
jmp 0x53d3
movq -0x18(%rbp), %rax
movq 0xe8(%rax), %rax
cmpq $0x0, 0x20(%rax)
jne 0x53cb
jmp 0x536f
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpq -0x30(%rbp), %rcx
movb %al, -0x3b(%rbp)
jae 0x538e
movzbl -0x39(%rbp), %eax
movzbl -0x19(%rbp), %ecx
cmpl %ecx, %eax
setne %al
movb %al, -0x3b(%rbp)
movb -0x3b(%rbp), %al
testb $0x1, %al
jne 0x5397
jmp 0x53b3
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movb 0x1(%rax,%rcx), %al
movb %al, -0x39(%rbp)
jmp 0x536f
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
setb %al
andb $0x1, %al
movzbl %al, %eax
cltq
movq %rax, -0x8(%rbp)
jmp 0x53d3
movq $-0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tabemann[P]attoforth/src/runtime/inner.c
// Function: af_parse_name_available
af_bool_t af_parse_name_available(af_global_t* global, af_task_t* task) {
  af_cell_t current_index;
  af_cell_t count;
  af_byte_t* buffer;
  af_byte_t current_char;
  if(!task->current_input) {
    return FALSE;
  }
  current_index = task->current_input->index;
  count = task->current_input->count;
  buffer = task->current_input->buffer;
  current_char = *(buffer + current_index);
  while(current_index < count &&
	(current_char == ' ' || current_char == '\t' || current_char == '\n')) {
    current_char = *(buffer + ++current_index);
  }
  if(current_index == count) {
    return FALSE;
  }
  if(!task->current_input->is_closed) {
    while(current_index < count &&
	  (current_char != ' ' && current_char != '\t' &&
	   current_char != '\n')) {
      current_char = *(buffer + ++current_index);
    }
    return current_index < count;
  } else {
    return TRUE;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0xe8(%rax)
jne 0x5647
movq $0x0, -0x8(%rbp)
jmp 0x579f
movq -0x18(%rbp), %rax
movq 0xe8(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0xe8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0xe8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x31(%rbp)
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq -0x28(%rbp), %rcx
movb %al, -0x32(%rbp)
jae 0x56cc
movzbl -0x31(%rbp), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x33(%rbp)
je 0x56c6
movzbl -0x31(%rbp), %ecx
movb $0x1, %al
cmpl $0x9, %ecx
movb %al, -0x33(%rbp)
je 0x56c6
movzbl -0x31(%rbp), %eax
cmpl $0xa, %eax
sete %al
movb %al, -0x33(%rbp)
movb -0x33(%rbp), %al
movb %al, -0x32(%rbp)
movb -0x32(%rbp), %al
testb $0x1, %al
jne 0x56d5
jmp 0x56f1
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb 0x1(%rax,%rcx), %al
movb %al, -0x31(%rbp)
jmp 0x568e
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x5708
movq $0x0, -0x8(%rbp)
jmp 0x579f
movq -0x18(%rbp), %rax
movq 0xe8(%rax), %rax
cmpq $0x0, 0x20(%rax)
jne 0x5797
jmp 0x571c
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq -0x28(%rbp), %rcx
movb %al, -0x34(%rbp)
jae 0x575a
movzbl -0x31(%rbp), %ecx
xorl %eax, %eax
cmpl $0x20, %ecx
movb %al, -0x35(%rbp)
je 0x5754
movzbl -0x31(%rbp), %ecx
xorl %eax, %eax
cmpl $0x9, %ecx
movb %al, -0x35(%rbp)
je 0x5754
movzbl -0x31(%rbp), %eax
cmpl $0xa, %eax
setne %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
movb %al, -0x34(%rbp)
movb -0x34(%rbp), %al
testb $0x1, %al
jne 0x5763
jmp 0x577f
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb 0x1(%rax,%rcx), %al
movb %al, -0x31(%rbp)
jmp 0x571c
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
setb %al
andb $0x1, %al
movzbl %al, %eax
cltq
movq %rax, -0x8(%rbp)
jmp 0x579f
movq $-0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tabemann[P]attoforth/src/runtime/inner.c
// Function: af_new_string_input
af_input_t* af_new_string_input(af_global_t* global, af_byte_t* buffer,
				af_cell_t count) {
  af_input_t* input;
  input = malloc(sizeof(af_input_t));
  if(!input) {
    return NULL;
  }
  input->next_input = NULL;
  input->buffer = buffer;
  input->count = count;
  input->index = 0;
  input->is_closed = TRUE;
  input->cleanup = NULL;
  input->refill = NULL;
  input->source_id = -1;
  input->arg = 0;
  return input;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x48, %edi
callq 0x21f0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x59c3
movq $0x0, -0x8(%rbp)
jmp 0x5a36
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x28(%rbp), %rax
movq $-0x1, 0x20(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x28(%rbp), %rax
movq $-0x1, 0x38(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_literal_runtime
void af_prim_literal_runtime(af_task_t* task) {
  af_global_t* global = task->global;
  if(--task->data_stack_current >= task->data_stack_top) {
    *task->data_stack_current =
      (task->interpreter_pointer + 1)->compiled_cell;
    AF_ADVANCE_IP(task, 2);
  } else {
    af_handle_data_stack_overflow(global, task);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq 0x60(%rcx), %rax
addq $-0x8, %rax
movq %rax, 0x60(%rcx)
movq -0x8(%rbp), %rcx
cmpq 0x78(%rcx), %rax
jb 0x91b3
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x919d
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
jmp 0x91a5
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0x91a5
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x58(%rax)
jmp 0x91c0
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x4260
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_f_literal_runtime
void af_prim_f_literal_runtime(af_task_t* task) {
  af_global_t* global = task->global;
  if(--task->float_stack_current >= task->float_stack_top) {
    *task->float_stack_current =
      *(af_float_t*)(&(task->interpreter_pointer + 1)->compiled_cell);
    AF_ADVANCE_IP(task, 1 + (sizeof(af_float_t) / sizeof(af_compiled_t)));
  } else {
    af_handle_float_stack_overflow(global, task);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq 0x68(%rcx), %rax
addq $-0x8, %rax
movq %rax, 0x68(%rcx)
movq -0x8(%rbp), %rcx
cmpq 0x80(%rcx), %rax
jb 0x9258
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movsd 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x9242
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
jmp 0x924a
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0x924a
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x58(%rax)
jmp 0x9265
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x42a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_exit
void af_prim_exit(af_task_t* task) {
  af_global_t* global = task->global;
  if(task->return_stack_current < task->return_stack_base) {
    task->interpreter_pointer = *task->return_stack_current++;
  } else {
    af_handle_return_stack_underflow(global, task);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0xa0(%rcx), %rax
jae 0x92bc
movq -0x8(%rbp), %rcx
movq 0x70(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x70(%rcx)
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x58(%rax)
jmp 0x92c9
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x43a0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_colon_noname
void af_prim_colon_noname(af_task_t* task) {
  af_global_t* global = task->global;
  void* word_space;
  size_t data_space_current = (size_t)task->data_space_current;
  size_t name_size = sizeof(af_byte_t);
  size_t pad_size;
  af_word_t* word;
  AF_VERIFY_DATA_STACK_EXPAND(task, 1);
  pad_size = ((data_space_current + name_size) % sizeof(af_cell_t)) == 0 ?
    0 * sizeof(af_byte_t) :
    sizeof(af_cell_t) - ((data_space_current + name_size) % sizeof(af_cell_t));
  if(!(word_space = af_allocate(global, task,
				sizeof(af_word_t) + name_size + pad_size))) {
    return;
  }
  word = word_space + name_size + pad_size;;
  word->next_word = NULL;
  word->flags = AF_WORD_HIDDEN;
  word->code = af_prim_docol;
  word->secondary = (af_compiled_t*)(word + 1);
  AF_WORD_NAME_LEN(word) = 0;
  task->most_recent_word = word;
  task->is_compiling = TRUE;
  *(--task->data_stack_current) = (af_cell_t)word;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0xc8(%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x1, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
andq $0x7, %rax
cmpq $0x0, %rax
jne 0x98f8
xorl %eax, %eax
movq %rax, -0x48(%rbp)
jmp 0x9910
movq -0x20(%rbp), %rcx
addq -0x28(%rbp), %rcx
andq $0x7, %rcx
movl $0x8, %eax
subq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x28(%rbp), %rdx
addq $0x28, %rdx
addq -0x30(%rbp), %rdx
callq 0x4790
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x9940
jmp 0x99fd
movq -0x18(%rbp), %rax
addq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x38(%rbp), %rax
movq $0x2, 0x18(%rax)
movq -0x38(%rbp), %rax
leaq 0xcf0d(%rip), %rcx      # 0x16880
movq %rcx, (%rax)
movq -0x38(%rbp), %rcx
addq $0x28, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x38(%rbp), %rax
movb $0x0, -0x1(%rax)
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xe0(%rax)
movq -0x8(%rbp), %rax
movq $-0x1, 0x40(%rax)
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rdx
movq 0x60(%rdx), %rax
movq %rax, %rsi
addq $-0x8, %rsi
movq %rsi, 0x60(%rdx)
movq %rcx, -0x8(%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x99e9
movq -0x40(%rbp), %rax
movq 0x58(%rax), %rax
addq $0x8, %rax
movq %rax, -0x50(%rbp)
jmp 0x99f1
xorl %eax, %eax
movq %rax, -0x50(%rbp)
jmp 0x99f1
movq -0x50(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x58(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_create_noname_at
void af_prim_create_noname_at(af_task_t* task) {
  void* word_space;
  size_t name_size = sizeof(af_byte_t);
  size_t pad_size;
  af_word_t* word;
  AF_VERIFY_DATA_STACK_READ(task, 1);
  word_space = (void*)(*task->data_stack_current);
  pad_size = (((size_t)word_space + name_size) % sizeof(af_cell_t)) == 0 ?
    0 * sizeof(af_byte_t) :
    sizeof(af_cell_t) - (((size_t)word_space + name_size) % sizeof(af_cell_t));
  word = word_space + name_size + pad_size;
  word->next_word = NULL;
  word->flags = 0;
  word->code = af_prim_push_data;
  word->secondary = (af_compiled_t*)(word + 1);
  AF_WORD_NAME_LEN(word) = 0;
  task->most_recent_word = word;
  task->is_compiling = FALSE;
  *task->data_stack_current = (af_cell_t)word;
  AF_ADVANCE_IP(task, 1);  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x1, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
andq $0x7, %rax
cmpq $0x0, %rax
jne 0x9a49
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x9a61
movq -0x10(%rbp), %rcx
addq -0x18(%rbp), %rcx
andq $0x7, %rcx
movl $0x8, %eax
subq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x28(%rbp), %rax
leaq 0xce64(%rip), %rcx      # 0x16900
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
addq $0x28, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rax
movb $0x0, -0x1(%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xe0(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x9b06
movq -0x30(%rbp), %rax
movq 0x58(%rax), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
jmp 0x9b0e
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0x9b0e
movq -0x40(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x58(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_semi
void af_prim_semi(af_task_t* task) {
  af_global_t* global = task->global;
  void* space;
  AF_VERIFY_COMPILING(task);
  if(!(space = af_allot(global, task, sizeof(af_compiled_t) * 2))) {
    return;
  }
  ((af_compiled_t*)space)->compiled_call = global->builtin_exit;
  ((af_compiled_t*)space + 1)->compiled_cell = 0;
  task->most_recent_word->flags &= ~AF_WORD_HIDDEN;
  task->is_compiling = FALSE;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x10, %edx
callq 0x47e0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x9b55
jmp 0x9bcf
movq -0x10(%rbp), %rax
movq 0x198(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0xe0(%rax), %rax
movq 0x18(%rax), %rcx
andq $-0x3, %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x9bbb
movq -0x20(%rbp), %rax
movq 0x58(%rax), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
jmp 0x9bc3
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x9bc3
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x58(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_is_immediate
void af_prim_is_immediate(af_task_t* task) {
  AF_VERIFY_DATA_STACK_READ(task, 1);
  *task->data_stack_current =
    (af_cell_t)(((af_word_t*)
		 (*task->data_stack_current))->flags
		& AF_WORD_IMMEDIATE ? TRUE : FALSE);
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq (%rax), %rax
movq 0x18(%rax), %rdx
andq $0x1, %rdx
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq $0x0, %rdx
cmovnel %ecx, %eax
movslq %eax, %rcx
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x9d5c
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
jmp 0x9d64
xorl %eax, %eax
movq %rax, -0x18(%rbp)
jmp 0x9d64
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x58(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_is_hidden
void af_prim_is_hidden(af_task_t* task) {
  AF_VERIFY_DATA_STACK_READ(task, 1);
  *task->data_stack_current =
    (af_cell_t)(((af_word_t*)
		 (*task->data_stack_current))->flags
		& AF_WORD_HIDDEN ? TRUE : FALSE);
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq (%rax), %rax
movq 0x18(%rax), %rdx
andq $0x2, %rdx
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq $0x0, %rdx
cmovnel %ecx, %eax
movslq %eax, %rcx
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x9ddc
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
jmp 0x9de4
xorl %eax, %eax
movq %rax, -0x18(%rbp)
jmp 0x9de4
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x58(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_is_compile_only
void af_prim_is_compile_only(af_task_t* task) {
  AF_VERIFY_DATA_STACK_READ(task, 1);
  *task->data_stack_current =
    (af_cell_t)(((af_word_t*)
		 (*task->data_stack_current))->flags
		& AF_WORD_COMPILE_ONLY ? TRUE : FALSE);
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq (%rax), %rax
movq 0x18(%rax), %rdx
andq $0x4, %rdx
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq $0x0, %rdx
cmovnel %ecx, %eax
movslq %eax, %rcx
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x9e5c
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
jmp 0x9e64
xorl %eax, %eax
movq %rax, -0x18(%rbp)
jmp 0x9e64
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x58(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)