LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_format_unsigned_2number
void af_prim_format_unsigned_2number(af_task_t* task) {
  af_byte_t buffer[128];
  af_byte_t* current = buffer + sizeof(buffer);
  af_cell_t length = 0;
  af_2cell_t value;
  af_bool_t negative = FALSE;
  AF_VERIFY_DATA_STACK_READ(task, 2);
  AF_LOAD_2CELL(task, 0, value);
  if(value == 0) {
    *(--current) = '0';
    length++;
  } else if(task->base >= 2 && task->base <= 36) {
    while(value > 0) {
      af_byte_t part = value % task->base;
      if(part < 10) {
	part += '0';
      } else {
	part += 'A' - 10;
      }
      value /= task->base;
      *(--current) = part;
      length++;
    }
  }
  memcpy(task->data_space_current, current, length);
  *(task->data_stack_current + 1) = (af_cell_t)task->data_space_current;
  *task->data_stack_current = length;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
movq 0x60(%rdi), %rax
movq (%rax), %r12
movq 0x8(%rax), %r13
movq %r13, %rax
orq %r12, %rax
je 0x9bfb
leaq 0x80(%rsp), %r14
movq 0xf0(%rbx), %rbp
leaq -0x2(%rbp), %rax
xorl %r15d, %r15d
cmpq $0x22, %rax
ja 0x9c0a
movq %r13, %rdi
movq %r12, %rsi
movq %rbp, %rdx
xorl %ecx, %ecx
callq 0xd870
movq %rax, %rcx
imulq %rbp, %rcx
movq %r13, %rsi
subq %rcx, %rsi
movl %esi, %ecx
andl $0x3e, %ecx
movl %esi, %edi
orb $0x30, %dil
addb $0x37, %sil
cmpl $0xa, %ecx
movzbl %dil, %ecx
movzbl %sil, %esi
cmovbl %ecx, %esi
movb %sil, 0x7f(%rsp,%r15)
decq %r15
cmpq %rbp, %r13
sbbq $0x0, %r12
movq %rax, %r13
movq %rdx, %r12
jae 0x9ba2
addq %r15, %r14
negq %r15
jmp 0x9c0a
leaq 0x7f(%rsp), %r14
movb $0x30, (%r14)
movl $0x1, %r15d
movq 0xc8(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x21f0
movq 0x60(%rbx), %rax
movq 0xc8(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %r15, (%rax)
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, 0x58(%rbx)
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_format_float
void af_prim_format_float(af_task_t* task) {
  af_byte_t buffer[64];
  af_byte_t format[64];
  af_cell_t length;
  af_float_t value;
  int precision;
  AF_VERIFY_DATA_STACK_READ(task, 1);
  AF_VERIFY_FLOAT_STACK_READ(task, 1);
  AF_VERIFY_DATA_STACK_EXPAND(task, 2);
  precision = *task->data_stack_current;
  if(precision < 0) {
    precision = 0;
  }
  value = *task->float_stack_current++;
  snprintf(format, sizeof(format), "%%.%df", precision);
  snprintf(buffer, sizeof(buffer), format, value);
  length = strlen(buffer);
  memcpy(task->data_space_current, buffer, length);
  *task->data_stack_current = (af_cell_t)task->data_space_current;
  *(--task->data_stack_current) = length;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
movq 0x60(%rdi), %rax
movl (%rax), %ecx
xorl %eax, %eax
testl %ecx, %ecx
cmovlel %eax, %ecx
movq 0x68(%rdi), %rax
leaq 0x8(%rax), %rdx
movq %rdx, 0x68(%rdi)
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x4e16(%rip), %rdx      # 0xeaa2
leaq 0x10(%rsp), %r14
movl $0x40, %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2150
leaq 0x50(%rsp), %r15
movl $0x40, %esi
movq %r15, %rdi
movq %r14, %rdx
movsd 0x8(%rsp), %xmm0
movb $0x1, %al
callq 0x2150
movq %r15, %rdi
callq 0x2120
movq %rax, %r14
movq 0xc8(%rbx), %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x21f0
movq 0x60(%rbx), %rax
movq 0xc8(%rbx), %rcx
movq %rcx, (%rax)
leaq -0x8(%rax), %rcx
movq %rcx, 0x60(%rbx)
movq %r14, -0x8(%rax)
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
movq %rax, 0x58(%rbx)
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_find_word
void af_prim_find_word(af_task_t* task) {
  af_global_t* global = task->global;
  af_byte_t* text;
  af_cell_t length;
  af_word_t* word;
  AF_VERIFY_DATA_STACK_READ(task, 2);
  text = (af_byte_t*)(*(task->data_stack_current + 1));
  length = *task->data_stack_current;
  word = af_lookup(global, task, text, length);
  if(!word) {
    AF_VERIFY_DATA_STACK_EXPAND(task, 1);
    *(--task->data_stack_current) = 0;
  } else {
    *(task->data_stack_current + 1) = (af_cell_t)word;
    *task->data_stack_current =
      (word->flags & AF_WORD_IMMEDIATE) ? 1 : (af_cell_t)(-1);
  }
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x60(%rbx), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rdx
movq %rbx, %rsi
callq 0x383a
testq %rax, %rax
je 0x9e40
movq 0x60(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x18(%rax), %rax
andl $0x1, %eax
xorl %edx, %edx
cmpq $0x1, %rax
sbbq %rdx, %rdx
orq $0x1, %rdx
movq %rdx, (%rcx)
jmp 0x9e54
movq 0x60(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x60(%rbx)
movq $0x0, -0x8(%rax)
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, 0x58(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_cas
void af_prim_cas(af_task_t* task) {
  af_cell_t* addr;
  AF_VERIFY_DATA_STACK_READ(task, 3);
  addr = (af_cell_t*)(*task->data_stack_current);
  if(*addr == *(task->data_stack_current + 2)) {
    *addr = *(task->data_stack_current + 1);
    task->data_stack_current += 2;
    *task->data_stack_current = TRUE;
  } else {
    task->data_stack_current += 2;
    *task->data_stack_current = FALSE;
  }
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
movq 0x60(%rdi), %rcx
movq (%rcx), %rdx
movq (%rdx), %rsi
leaq 0x10(%rcx), %rax
cmpq 0x10(%rcx), %rsi
jne 0x9e8d
movq 0x8(%rcx), %rcx
movq %rcx, (%rdx)
movq $-0x1, %rcx
jmp 0x9e8f
xorl %ecx, %ecx
movq %rax, 0x60(%rdi)
movq %rcx, (%rax)
movq 0x58(%rdi), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, 0x58(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_2cas
void af_prim_2cas(af_task_t* task) {
  af_cell_t* addr;
  AF_VERIFY_DATA_STACK_READ(task, 5);
  addr = (af_cell_t*)(*task->data_stack_current);
  if(*addr == *(task->data_stack_current + 3) &&
     *(addr + 1) == *(task->data_stack_current + 4)) {
    *addr = *(task->data_stack_current + 1);
    *(addr + 1) = *(task->data_stack_current + 2);
    task->data_stack_current += 4;
    *task->data_stack_current = TRUE;
  } else {
    task->data_stack_current += 4;
    *task->data_stack_current = TRUE;
  }
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
movq 0x60(%rdi), %rax
movq (%rax), %rcx
movq (%rcx), %rdx
cmpq 0x18(%rax), %rdx
jne 0x9ed9
movq 0x8(%rcx), %rdx
cmpq 0x20(%rax), %rdx
jne 0x9ed9
movq 0x8(%rax), %rdx
movq %rdx, (%rcx)
movq 0x10(%rax), %rdx
addq $0x20, %rax
movq %rdx, 0x8(%rcx)
jmp 0x9edd
addq $0x20, %rax
movq %rax, 0x60(%rdi)
movq $-0x1, (%rax)
movq 0x58(%rdi), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, 0x58(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_spawn
void af_prim_spawn(af_task_t* task) {
  af_global_t* global = task->global;
  af_task_t* new_task;
  AF_VERIFY_DATA_STACK_EXPAND(task, 1);
  if(!(new_task = af_spawn(global, task))) {
    return;
  }
  *(--task->data_stack_current) = (af_cell_t)new_task;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movq %rbx, %rsi
callq 0x2806
testq %rax, %rax
je 0x9f57
movq 0x60(%rbx), %rcx
leaq -0x8(%rcx), %rdx
movq %rdx, 0x60(%rbx)
movq %rax, -0x8(%rcx)
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
movq %rax, 0x58(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_spawn_no_data
void af_prim_spawn_no_data(af_task_t* task) {
  af_global_t* global = task->global;
  af_task_t* new_task;
  AF_VERIFY_DATA_STACK_EXPAND(task, 1);
  if(!(new_task = af_spawn_no_data(global, task))) {
    return;
  }
  *(--task->data_stack_current) = (af_cell_t)new_task;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movq %rbx, %rsi
callq 0x2e0e
testq %rax, %rax
je 0x9f90
movq 0x60(%rbx), %rcx
leaq -0x8(%rcx), %rdx
movq %rdx, 0x60(%rbx)
movq %rax, -0x8(%rcx)
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
movq %rax, 0x58(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_to_console_input
void af_prim_to_console_input(af_task_t* task) {
  af_task_t* target_task;
  af_input_t* current_input;
  af_input_t* console_input;
  AF_VERIFY_DATA_STACK_READ(task, 2);
  target_task = (af_task_t*)(*task->data_stack_current++);
  console_input = (af_input_t*)(*task->data_stack_current++);
  current_input = target_task->current_input;
  while(current_input && current_input->next_input) {
    current_input = current_input->next_input;
  }
  if(current_input) {
    current_input->next_input = console_input;
  } else {
    target_task->current_input = console_input;
  }
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
movq 0x60(%rdi), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x60(%rdi)
movq (%rax), %rcx
leaq 0x10(%rax), %rdx
movq %rdx, 0x60(%rdi)
movq 0x8(%rax), %rax
movq 0xe8(%rcx), %rsi
addq $0xe8, %rcx
testq %rsi, %rsi
je 0xa003
movq %rsi, %rdx
movq (%rsi), %rsi
testq %rsi, %rsi
jne 0x9ff1
jmp 0xa006
movq %rcx, %rdx
movq %rax, (%rdx)
movq 0x58(%rdi), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, 0x58(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_from_console_input
void af_prim_from_console_input(af_task_t* task) {
  af_task_t* target_task;
  af_input_t* current_input;
  AF_VERIFY_DATA_STACK_READ(task, 1);
  target_task = (af_task_t*)(*task->data_stack_current);
  current_input = target_task->current_input;
  while(current_input && current_input->next_input) {
    current_input = current_input->next_input;
  }
  *task->data_stack_current = (af_cell_t)current_input;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
movq 0x60(%rdi), %rax
movq (%rax), %rcx
movq 0xe8(%rcx), %rdx
movq %rdx, %rcx
testq %rdx, %rdx
je 0xa03b
movq (%rcx), %rdx
testq %rdx, %rdx
jne 0xa02b
movq %rcx, (%rax)
movq 0x58(%rdi), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, 0x58(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_to_init_word
void af_prim_to_init_word(af_task_t* task) {
  af_global_t* global = task->global;
  af_task_t* target_task;
  af_word_t* word;
  AF_VERIFY_DATA_STACK_READ(task, 2);
  target_task = (af_task_t*)(*task->data_stack_current++);
  word = (af_word_t*)(*task->data_stack_current++);
  af_set_init_word(global, target_task, word);
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x60(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x60(%rbx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
movq %rcx, 0x60(%rbx)
movq 0x8(%rax), %rdx
callq 0x30e3
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
movq %rax, 0x58(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_start
void af_prim_start(af_task_t* task) {
  af_global_t* global = task->global;
  af_task_t* target_task;
  AF_VERIFY_DATA_STACK_READ(task, 1);
  target_task = (af_task_t*)(*task->data_stack_current++);
  af_start(global, target_task);
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x60(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x60(%rbx)
movq (%rax), %rsi
callq 0x2b19
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
movq %rax, 0x58(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_to_handler_task
void af_prim_to_handler_task(af_task_t* task) {
  af_global_t* global = task->global;
  AF_VERIFY_DATA_STACK_READ(task, 1);
  global->handler_task = (af_task_t*)(*task->data_stack_current++);
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
movq (%rdi), %rax
movq 0x60(%rdi), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, 0x60(%rdi)
movq (%rcx), %rcx
movq %rcx, 0x220(%rax)
movq 0x58(%rdi), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
movq %rax, 0x58(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_branch
void af_prim_branch(af_task_t* task) {
  af_global_t* global = task->global;
  if(task->interpreter_pointer) {
    task->interpreter_pointer =
      (af_compiled_t*)((task->interpreter_pointer + 1)->compiled_cell);
  } else {
    af_handle_not_interactive(global, task);
  }
}

// Assembly:
movq %rdi, %rsi
movq 0x58(%rdi), %rax
testq %rax, %rax
je 0xa332
movq 0x8(%rax), %rax
movq %rax, 0x58(%rsi)
retq
movq (%rsi), %rdi
jmp 0x365a
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_cond_branch
void af_prim_cond_branch(af_task_t* task) {
  af_global_t* global = task->global;
  AF_VERIFY_DATA_STACK_READ(task, 1);
  if(task->interpreter_pointer) {
    af_cell_t value = *task->data_stack_current++;
    if(!value) {
      task->interpreter_pointer =
	(af_compiled_t*)((task->interpreter_pointer + 1)->compiled_cell);
    } else {
      AF_ADVANCE_IP(task, 2);
    }
  } else {
    af_handle_not_interactive(global, task);
  }
}

// Assembly:
movq %rdi, %rsi
movq 0x58(%rdi), %rax
testq %rax, %rax
je 0xa35e
movq 0x60(%rsi), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, 0x60(%rsi)
cmpq $0x0, (%rcx)
je 0xa366
addq $0x10, %rax
jmp 0xa36a
movq (%rsi), %rdi
jmp 0x365a
movq 0x8(%rax), %rax
movq %rax, 0x58(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_move
void af_prim_move(af_task_t* task) {
  AF_VERIFY_DATA_STACK_READ(task, 3);
  memmove((void*)(*(task->data_stack_current + 1)),
	  (void*)(*(task->data_stack_current + 2)),
	  (size_t)(*task->data_stack_current));
  task->data_stack_current += 3;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rdi
movq 0x10(%rax), %rsi
callq 0x2260
addq $0x18, 0x60(%rbx)
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, 0x58(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_get_order
void af_prim_get_order(af_task_t* task) {
  af_wordlist_t** current = task->wordlist_order + task->wordlist_order_count;
  af_cell_t count = task->wordlist_order_count;
  AF_VERIFY_DATA_STACK_EXPAND(task, task->wordlist_order_count + 1);
  while(count--) {
    *(--task->data_stack_current) = (af_cell_t)(*(--current));
  }
  *(--task->data_stack_current) = task->wordlist_order_count;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
movq 0xb8(%rdi), %rax
testq %rax, %rax
je 0xa529
movq 0x60(%rdi), %rcx
movq 0xb0(%rdi), %rdx
addq $-0x8, %rcx
movq -0x8(%rdx,%rax,8), %rsi
decq %rax
movq %rcx, 0x60(%rdi)
movq %rsi, (%rcx)
addq $-0x8, %rcx
testq %rax, %rax
jne 0xa511
movq 0x60(%rdi), %rax
movq 0xb8(%rdi), %rcx
leaq -0x8(%rax), %rdx
movq %rdx, 0x60(%rdi)
movq %rcx, -0x8(%rax)
movq 0x58(%rdi), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
movq %rax, 0x58(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_search_wordlist
void af_prim_search_wordlist(af_task_t* task) {
  af_word_t* word;
  AF_VERIFY_DATA_STACK_READ(task, 1);
  if(!(word = af_search_wordlist((af_wordlist_t*)(*task->data_stack_current),
				 (af_byte_t*)(*(task->data_stack_current + 2)),
				 *(task->data_stack_current + 1)))) {
    task->data_stack_current += 2;
    *task->data_stack_current = 0;
  } else {
    task->data_stack_current++;
    *(task->data_stack_current + 1) = (af_cell_t)word;
    *task->data_stack_current =
      (word->flags & AF_WORD_IMMEDIATE) ? 1 : (af_cell_t)(-1);
  }
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %rax
movq 0x10(%rax), %rsi
movq (%rax), %rdi
movq 0x8(%rax), %rdx
callq 0x37a6
movq 0x60(%rbx), %rcx
testq %rax, %rax
je 0xa59b
leaq 0x8(%rcx), %rdx
movq %rdx, 0x60(%rbx)
movq %rax, 0x10(%rcx)
movq 0x18(%rax), %rax
andl $0x1, %eax
xorl %edx, %edx
cmpq $0x1, %rax
sbbq %rdx, %rdx
orq $0x1, %rdx
movq %rdx, 0x8(%rcx)
jmp 0xa5ab
leaq 0x10(%rcx), %rax
movq %rax, 0x60(%rbx)
movq $0x0, 0x10(%rcx)
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, 0x58(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_set_order
void af_prim_set_order(af_task_t* task) {
  af_global_t* global = task->global;
  af_cell_t count;
  af_wordlist_t** current = task->wordlist_order;
  AF_VERIFY_DATA_STACK_READ(task, 1);
  count = *task->data_stack_current;
  if(count != (af_cell_t)-1) {
    AF_VERIFY_DATA_STACK_READ(task, count + 1);
    if(count > task->wordlist_order_max_count) {
      af_handle_wordlist_too_large(global, task);
      return;
    }
    task->wordlist_order_count = count;
    task->data_stack_current++;
    while(count--) {
      *current++ = (af_wordlist_t*)(*task->data_stack_current++);
    }
  } else {
    task->wordlist_order_count = 1;
    task->data_stack_current++;
    *current = global->forth_wordlist;
  }
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
movq %rdi, %rsi
movq (%rdi), %rdi
movq 0x60(%rsi), %rdx
movq 0xb0(%rsi), %rax
movq (%rdx), %rcx
cmpq $-0x1, %rcx
je 0xa644
cmpq 0xc0(%rsi), %rcx
ja 0x3682
movq %rcx, 0xb8(%rsi)
addq $0x8, %rdx
movq %rdx, 0x60(%rsi)
testq %rcx, %rcx
je 0xa661
xorl %edx, %edx
movq 0x60(%rsi), %rdi
leaq 0x8(%rdi), %r8
movq %r8, 0x60(%rsi)
movq (%rdi), %rdi
movq %rdi, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %rcx
jne 0xa627
jmp 0xa661
movq $0x1, 0xb8(%rsi)
addq $0x8, %rdx
movq %rdx, 0x60(%rsi)
movq 0x1b8(%rdi), %rcx
movq %rcx, (%rax)
movq 0x58(%rsi), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, 0x58(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_wordlist
void af_prim_wordlist(af_task_t* task) {
  af_global_t* global = task->global;
  af_wordlist_t* wordlist;
  AF_VERIFY_DATA_STACK_EXPAND(task, 1);
  if(!(wordlist = malloc(sizeof(af_wordlist_t)))) {
    af_handle_out_of_memory(global, task);
    return;
  }
  wordlist->first_word = NULL;
  *(--task->data_stack_current) = (af_cell_t)wordlist;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movl $0x8, %edi
callq 0x2220
testq %rax, %rax
je 0xa6c0
movq $0x0, (%rax)
movq 0x60(%rbx), %rcx
leaq -0x8(%rcx), %rdx
movq %rdx, 0x60(%rbx)
movq %rax, -0x8(%rcx)
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
movq %rax, 0x58(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3592
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_getenv
void af_prim_getenv(af_task_t* task) {
  af_global_t* global = task->global;
  char* name;
  char* value;
  af_byte_t* name_addr;
  af_cell_t name_len;
  int error = 0;
  AF_VERIFY_DATA_STACK_READ(task, 2);
  AF_VERIFY_DATA_STACK_EXPAND(task, 1);
  name_len = *task->data_stack_current++;
  name_addr = (af_byte_t*)(*task->data_stack_current);
  if(!(name = malloc(name_len + 1))) {
    af_handle_out_of_memory(global, task);
    return;
  }
  memcpy(name, name_addr, name_len);
  name[name_len] = 0;
  value = getenv(name);
  free(name);
  *task->data_stack_current = (af_cell_t)value;
  AF_ADVANCE_IP(task, 1);  
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r12
movq 0x60(%rdi), %rax
leaq 0x8(%rax), %rbp
movq %rbp, 0x60(%rdi)
movq (%rax), %r14
movq 0x8(%rax), %r13
leaq 0x1(%r14), %rdi
callq 0x2220
testq %rax, %rax
je 0xa7af
movq %rax, %r15
movq %rax, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x21f0
movb $0x0, (%r15,%r14)
movq %r15, %rdi
callq 0x2040
movq %rax, %r14
movq %r15, %rdi
callq 0x2050
movq %r14, (%rbp)
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, 0x58(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3592
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_setenv
void af_prim_setenv(af_task_t* task) {
  af_global_t* global = task->global;
  char* value;
  char* name;
  af_byte_t* value_addr;
  af_cell_t value_len;
  af_byte_t* name_addr;
  af_cell_t name_len;
  int overwrite;
  int error = 0;
  AF_VERIFY_DATA_STACK_READ(task, 5);
  overwrite = *task->data_stack_current++ ? 1 : 0;
  name_len = *task->data_stack_current++;
  name_addr = (af_byte_t*)(*task->data_stack_current++);
  value_len = *task->data_stack_current++;
  value_addr = (af_byte_t*)(*task->data_stack_current);
  if(!(name = malloc(name_len + 1))) {
    af_handle_out_of_memory(global, task);
    return;
  }
  memcpy(name, name_addr, name_len);
  name[name_len] = 0;
  if(!(value = malloc(value_len + 1))) {
    free(name);
    af_handle_out_of_memory(global, task);
    return;
  }
  memcpy(value, value_addr, value_len);
  value[value_len] = 0;
  if(setenv(name, value, overwrite)) {
    error = errno;
  }
  free(value);
  free(name);
  *task->data_stack_current = error;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %rbp
movq 0x60(%rdi), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x60(%rdi)
cmpq $0x0, (%rax)
setne 0xf(%rsp)
leaq 0x10(%rax), %rcx
movq %rcx, 0x60(%rdi)
movq 0x8(%rax), %r13
leaq 0x18(%rax), %rcx
movq %rcx, 0x60(%rdi)
movq 0x10(%rax), %r15
leaq 0x20(%rax), %rcx
movq %rcx, 0x60(%rdi)
movq 0x18(%rax), %r12
movq 0x20(%rax), %rax
movq %rax, 0x10(%rsp)
leaq 0x1(%r13), %rdi
callq 0x2220
testq %rax, %rax
je 0xa896
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x21f0
movb $0x0, (%r14,%r13)
leaq 0x1(%r12), %rdi
callq 0x2220
testq %rax, %rax
je 0xa88e
movq %rax, %r13
xorl %ebp, %ebp
movb 0xf(%rsp), %al
movb %al, %bpl
movq %r13, %rdi
movq 0x10(%rsp), %rsi
movq %r12, %rdx
callq 0x21f0
movb $0x0, (%r13,%r12)
movq %r14, %rdi
movq %r13, %rsi
movl %ebp, %edx
callq 0x20e0
testl %eax, %eax
je 0xa8af
callq 0x2070
movslq (%rax), %r15
jmp 0xa8b2
movq %r14, %rdi
callq 0x2050
movq %rbp, %rdi
movq %rbx, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3592
xorl %r15d, %r15d
movq %r13, %rdi
callq 0x2050
movq %r14, %rdi
callq 0x2050
movq 0x60(%rbx), %rax
movq %r15, (%rax)
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, 0x58(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_unsetenv
void af_prim_unsetenv(af_task_t* task) {
  af_global_t* global = task->global;
  char* name;
  af_byte_t* name_addr;
  af_cell_t name_len;
  int error = 0;
  AF_VERIFY_DATA_STACK_READ(task, 2);
  name_len = *task->data_stack_current++;
  name_addr = (af_byte_t*)(*task->data_stack_current);
  if(!(name = malloc(name_len + 1))) {
    af_handle_out_of_memory(global, task);
    return;
  }
  memcpy(name, name_addr, name_len);
  name[name_len] = 0;
  if(unsetenv(name)) {
    error = errno;
  }
  free(name);
  *task->data_stack_current = error;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r12
movq 0x60(%rdi), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x60(%rdi)
movq (%rax), %r15
movq 0x8(%rax), %r13
leaq 0x1(%r15), %rdi
callq 0x2220
testq %rax, %rax
je 0xa947
movq %rax, %r14
movq %rax, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x21f0
movb $0x0, (%r14,%r15)
movq %r14, %rdi
callq 0x22c0
testl %eax, %eax
je 0xa95b
callq 0x2070
movslq (%rax), %r15
jmp 0xa95e
movq %r12, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x3592
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x2050
movq 0x60(%rbx), %rax
movq %r15, (%rax)
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, 0x58(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_to_io_handler_task
void af_prim_to_io_handler_task(af_task_t* task) {
  af_global_t* global = task->global;
  AF_VERIFY_DATA_STACK_READ(task, 1);
  af_io_set_handler_task(&global->io,
			 (af_task_t*)(*task->data_stack_current++));
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0xa8, %edi
addq (%rbx), %rdi
movq 0x60(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x60(%rbx)
movq (%rax), %rsi
callq 0xc61b
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
movq %rax, 0x58(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_from_io_handler_task
void af_prim_from_io_handler_task(af_task_t* task) {
  af_global_t* global = task->global;
  AF_VERIFY_DATA_STACK_EXPAND(task, 1);
  *(--task->data_stack_current) =
    (af_cell_t)af_io_get_handler_task(&global->io);
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0xa8, %edi
addq (%rbx), %rdi
callq 0xc643
movq 0x60(%rbx), %rcx
leaq -0x8(%rcx), %rdx
movq %rdx, 0x60(%rbx)
movq %rax, -0x8(%rcx)
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
movq %rax, 0x58(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_io_action_get_state
void af_prim_io_action_get_state(af_task_t* task) {
  af_global_t* global = task->global;
  af_io_state_t* state;
  AF_VERIFY_DATA_STACK_READ(task, 1);
  if(!(state = malloc(sizeof(af_io_state_t)))) {
    af_handle_out_of_memory(global, task);
    return;
  }
  af_io_action_get_state((af_io_action_t*)(*task->data_stack_current), state);
  *task->data_stack_current = (af_cell_t)state;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r15
movl $0x40, %edi
callq 0x2220
testq %rax, %rax
je 0xaa6e
movq %rax, %r14
movq 0x60(%rbx), %rax
movq (%rax), %rdi
movq %r14, %rsi
callq 0xc648
movq 0x60(%rbx), %rax
movq %r14, (%rax)
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, 0x58(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x3592
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_io_state_is_done
void af_prim_io_state_is_done(af_task_t* task) {
  AF_VERIFY_DATA_STACK_READ(task, 1);
  *(af_bool_t*)task->data_stack_current =
    af_io_state_is_done((af_io_state_t*)(*task->data_stack_current));
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %rax
movq (%rax), %rdi
callq 0xc6bb
movq 0x60(%rbx), %rcx
movq %rax, (%rcx)
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, 0x58(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_io_state_has_hangup
void af_prim_io_state_has_hangup(af_task_t* task) {
  AF_VERIFY_DATA_STACK_READ(task, 1);
  *(af_bool_t*)task->data_stack_current =
    af_io_state_has_hangup((af_io_state_t*)(*task->data_stack_current));
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %rax
movq (%rax), %rdi
callq 0xc6c5
movq 0x60(%rbx), %rcx
movq %rax, (%rcx)
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, 0x58(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_io_open
void af_prim_io_open(af_task_t* task) {
  af_io_fd_t fd;
  af_io_error_t error;
  AF_VERIFY_DATA_STACK_READ(task, 4);
  fd = af_io_open((af_byte_t*)(*(task->data_stack_current + 3)),
		  *(task->data_stack_current + 2),
		  (af_io_flags_t)(*(task->data_stack_current + 1)),
		  (af_io_mode_t)(*task->data_stack_current),
		  &error);
  task->data_stack_current += 2;
  *(task->data_stack_current + 1) = (af_cell_t)fd;
  *task->data_stack_current = (af_cell_t)error;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %rax
movq 0x18(%rax), %rdi
movq 0x10(%rax), %rsi
movl (%rax), %ecx
movl 0x8(%rax), %edx
leaq 0x4(%rsp), %r14
movq %r14, %r8
callq 0xc6e2
movq 0x60(%rbx), %rcx
leaq 0x10(%rcx), %rdx
movq %rdx, 0x60(%rbx)
cltq
movq %rax, 0x18(%rcx)
movslq (%r14), %rax
movq %rax, 0x10(%rcx)
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
movq %rax, 0x58(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_io_pipe
void af_prim_io_pipe(af_task_t* task) {
  af_io_fd_t in;
  af_io_fd_t out;
  af_io_error_t error;
  AF_VERIFY_DATA_STACK_EXPAND(task, 3);
  af_io_pipe(&in, &out, &error);
  *(--task->data_stack_current) = (af_cell_t)in;
  *(--task->data_stack_current) = (af_cell_t)out;
  *(--task->data_stack_current) = (af_cell_t)error;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x14(%rsp), %r14
leaq 0x10(%rsp), %r15
leaq 0xc(%rsp), %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xc75b
movslq (%r14), %rax
movq 0x60(%rbx), %rcx
leaq -0x8(%rcx), %rdx
movq %rdx, 0x60(%rbx)
movq %rax, -0x8(%rcx)
movslq (%r15), %rax
leaq -0x10(%rcx), %rdx
movq %rdx, 0x60(%rbx)
movq %rax, -0x10(%rcx)
movslq (%r12), %rax
leaq -0x18(%rcx), %rdx
movq %rdx, 0x60(%rbx)
movq %rax, -0x18(%rcx)
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
movq %rax, 0x58(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_io_delete
void af_prim_io_delete(af_task_t* task) {
  af_io_error_t error;
  AF_VERIFY_DATA_STACK_READ(task, 2);
  af_io_delete((af_byte_t*)(*(task->data_stack_current + 1)),
	       *task->data_stack_current, &error);
  task->data_stack_current++;
  *task->data_stack_current = (af_cell_t)error;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdi
leaq 0x4(%rsp), %r14
movq %r14, %rdx
callq 0xc7a9
movq 0x60(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x60(%rbx)
movslq (%r14), %rcx
movq %rcx, 0x8(%rax)
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
movq %rax, 0x58(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_io_rename
void af_prim_io_rename(af_task_t* task) {
  af_io_error_t error;
  AF_VERIFY_DATA_STACK_READ(task, 4);
  af_io_rename((af_byte_t*)(*(task->data_stack_current + 3)),
	       *(task->data_stack_current + 2),
	       (af_byte_t*)(*(task->data_stack_current + 1)),
	       *task->data_stack_current, &error);
  task->data_stack_current += 3;
  *task->data_stack_current = (af_cell_t)error;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %rax
movq 0x18(%rax), %rdi
movq 0x10(%rax), %rsi
movq (%rax), %rcx
movq 0x8(%rax), %rdx
leaq 0x4(%rsp), %r14
movq %r14, %r8
callq 0xc87d
movq 0x60(%rbx), %rax
leaq 0x18(%rax), %rcx
movq %rcx, 0x60(%rbx)
movslq (%r14), %rcx
movq %rcx, 0x18(%rax)
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
movq %rax, 0x58(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_io_isatty
void af_prim_io_isatty(af_task_t* task) {
  af_io_error_t error;
  AF_VERIFY_DATA_STACK_READ(task, 1);
  AF_VERIFY_DATA_STACK_EXPAND(task, 1);
  *task->data_stack_current = af_io_isatty(*task->data_stack_current, &error);
  *(--task->data_stack_current) = error;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %rax
movl (%rax), %edi
leaq 0x4(%rsp), %r14
movq %r14, %rsi
callq 0xc919
movq 0x60(%rbx), %rcx
movq %rax, (%rcx)
movslq (%r14), %rax
leaq -0x8(%rcx), %rdx
movq %rdx, 0x60(%rbx)
movq %rax, -0x8(%rcx)
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
movq %rax, 0x58(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_io_get_monotonic_time
void af_prim_io_get_monotonic_time(af_task_t* task) {
  af_time_t monotonic_time;
  AF_VERIFY_DATA_STACK_EXPAND(task, 2);
  af_io_get_monotonic_time(&monotonic_time);
  *(--task->data_stack_current) = monotonic_time.sec;
  *(--task->data_stack_current) = monotonic_time.nsec;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xc955
movq (%r14), %rax
movq 0x60(%rbx), %rcx
leaq -0x8(%rcx), %rdx
movq %rdx, 0x60(%rbx)
movq %rax, -0x8(%rcx)
movq 0x8(%r14), %rax
leaq -0x10(%rcx), %rdx
movq %rdx, 0x60(%rbx)
movq %rax, -0x10(%rcx)
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
movq %rax, 0x58(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_io_sleep
void af_prim_io_sleep(af_task_t* task) {
  af_global_t* global = task->global;
  af_time_t sleep_until;
  af_io_action_t* action;
  AF_VERIFY_DATA_STACK_READ(task, 2);
  sleep_until.nsec = *task->data_stack_current++;
  sleep_until.sec = *task->data_stack_current++;
  action = af_io_sleep(&global->io, &sleep_until, task);
  af_io_action_destroy(action);
  AF_ADVANCE_IP(task, 1);
  af_wait(global, task);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x60(%rdi), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x60(%rdi)
movq (%rax), %rcx
leaq 0x8(%rsp), %rsi
movq %rcx, 0x8(%rsi)
leaq 0x10(%rax), %rcx
movq %rcx, 0x60(%rdi)
movq 0x8(%rax), %rax
movq %rax, (%rsi)
leaq 0xa8(%r14), %rdi
movq %rbx, %rdx
callq 0xc9b6
movq %rax, %rdi
callq 0xc58e
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
movq %rax, 0x58(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3187
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_io_tell
void af_prim_io_tell(af_task_t* task) {
  af_global_t* global = task->global;
  af_io_action_t* action;
  AF_VERIFY_DATA_STACK_READ(task, 1);
  action = af_io_tell(&global->io, (af_io_fd_t)(*task->data_stack_current),
		      task);
  *task->data_stack_current = (af_cell_t)action;
  AF_ADVANCE_IP(task, 1);
  af_wait(global, task);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x60(%rdi), %rax
leaq 0xa8(%r14), %rdi
movl (%rax), %esi
movq %rbx, %rdx
callq 0xcafa
movq 0x60(%rbx), %rcx
movq %rax, (%rcx)
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
movq %rax, 0x58(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3187
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_io_close_async
void af_prim_io_close_async(af_task_t* task) {
  af_global_t* global = task->global;
  af_io_action_t* action;
  AF_VERIFY_DATA_STACK_READ(task, 1);
  action = af_io_close_async(&global->io,
			     (af_io_fd_t)(*task->data_stack_current));
  *task->data_stack_current = (af_cell_t)action;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0xa8, %edi
addq (%rbx), %rdi
movq 0x60(%rbx), %rax
movl (%rax), %esi
callq 0xcbec
movq 0x60(%rbx), %rcx
movq %rax, (%rcx)
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, 0x58(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_io_seek_block
void af_prim_io_seek_block(af_task_t* task) {
  af_global_t* global = task->global;
  af_io_action_t* action;
  af_io_fd_t fd;
  af_io_off_t offset;
  af_io_whence_t whence;
  AF_VERIFY_DATA_STACK_READ(task, 3);
  fd = *task->data_stack_current;
  whence = *(task->data_stack_current + 1);
  offset = *(af_sign_cell_t*)(task->data_stack_current + 2);
  action = af_io_seek_block(&global->io, fd, offset, whence, task);
  task->data_stack_current += 2;
  *task->data_stack_current = (af_cell_t)action;
  AF_ADVANCE_IP(task, 1);
  af_wait(global, task);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x60(%rdi), %rax
movl (%rax), %esi
movl 0x8(%rax), %ecx
movq 0x10(%rax), %rdx
leaq 0xa8(%r14), %rdi
movq %rbx, %r8
callq 0xcc57
movq 0x60(%rbx), %rcx
leaq 0x10(%rcx), %rdx
movq %rdx, 0x60(%rbx)
movq %rax, 0x10(%rcx)
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
movq %rax, 0x58(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3187
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_io_seek_async
void af_prim_io_seek_async(af_task_t* task) {
  af_global_t* global = task->global;
  af_io_action_t* action;
  af_io_fd_t fd;
  af_io_off_t offset;
  af_io_whence_t whence;
  AF_VERIFY_DATA_STACK_READ(task, 3);
  fd = *task->data_stack_current;
  whence = *(task->data_stack_current + 1);
  offset = *(af_sign_cell_t*)(task->data_stack_current + 2);
  action = af_io_seek_async(&global->io, fd, offset, whence);
  task->data_stack_current += 2;
  *task->data_stack_current = (af_cell_t)action;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %rax
movl (%rax), %esi
movl 0x8(%rax), %ecx
movq 0x10(%rax), %rdx
movl $0xa8, %edi
addq (%rbx), %rdi
callq 0xcce2
movq 0x60(%rbx), %rcx
leaq 0x10(%rcx), %rdx
movq %rdx, 0x60(%rbx)
movq %rax, 0x10(%rcx)
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
movq %rax, 0x58(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_io_read_block
void af_prim_io_read_block(af_task_t* task) {
  af_global_t* global = task->global;
  af_io_action_t* action;
  AF_VERIFY_DATA_STACK_READ(task, 3);
  action = af_io_read_block(&global->io,
			    (af_io_fd_t)(*task->data_stack_current),
			    (af_byte_t*)(*(task->data_stack_current + 2)),
			    *(task->data_stack_current + 1),
			    task);
  task->data_stack_current += 2;
  *task->data_stack_current = (af_cell_t)action;
  AF_ADVANCE_IP(task, 1);
  af_wait(global, task);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x60(%rdi), %rax
leaq 0xa8(%r14), %rdi
movl (%rax), %esi
movq 0x10(%rax), %rdx
movq 0x8(%rax), %rcx
movq %rbx, %r8
callq 0xcd5d
movq 0x60(%rbx), %rcx
leaq 0x10(%rcx), %rdx
movq %rdx, 0x60(%rbx)
movq %rax, 0x10(%rcx)
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
movq %rax, 0x58(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3187
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_io_read_async
void af_prim_io_read_async(af_task_t* task) {
  af_global_t* global = task->global;
  af_io_action_t* action;
  AF_VERIFY_DATA_STACK_READ(task, 3);
  action = af_io_read_async(&global->io,
			    (af_io_fd_t)(*task->data_stack_current),
			    (af_byte_t*)(*(task->data_stack_current + 2)),
			    *(task->data_stack_current + 1));
  task->data_stack_current += 2;
  *task->data_stack_current = (af_cell_t)action;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0xa8, %edi
addq (%rbx), %rdi
movq 0x60(%rbx), %rax
movl (%rax), %esi
movq 0x10(%rax), %rdx
movq 0x8(%rax), %rcx
callq 0xce98
movq 0x60(%rbx), %rcx
leaq 0x10(%rcx), %rdx
movq %rdx, 0x60(%rbx)
movq %rax, 0x10(%rcx)
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
movq %rax, 0x58(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_io_read_nonblock
void af_prim_io_read_nonblock(af_task_t* task) {
  af_bool_t again;
  af_io_error_t error;
  ssize_t size;
  AF_VERIFY_DATA_STACK_READ(task, 3);
  size = af_io_read_nonblock((af_io_fd_t)(*task->data_stack_current),
			     (af_byte_t*)(*(task->data_stack_current + 2)),
			     *(task->data_stack_current + 1),
			     &again, &error);
  *(af_sign_cell_t*)(task->data_stack_current + 2) = (af_sign_cell_t)size;
  *(af_bool_t*)(task->data_stack_current + 1) = again;
  *task->data_stack_current = error;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x60(%rdi), %rax
movl (%rax), %edi
movq 0x10(%rax), %rsi
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %r14
leaq 0x4(%rsp), %r15
movq %r14, %rcx
movq %r15, %r8
callq 0xcff0
movq 0x60(%rbx), %rcx
movq %rax, 0x10(%rcx)
movq (%r14), %rax
movq %rax, 0x8(%rcx)
movslq (%r15), %rax
movq %rax, (%rcx)
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, 0x58(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_docol
void af_prim_docol(af_task_t* task) {
  af_global_t* global = task->global;
  if(task->return_stack_current > task->return_stack_top) {
    *(--task->return_stack_current) = task->interpreter_pointer + 1;
    task->interpreter_pointer = task->current_word->secondary;
  } else {
    af_handle_return_stack_overflow(global, task);
  }
}

// Assembly:
movq %rdi, %rsi
movq 0x70(%rdi), %rax
cmpq 0x88(%rdi), %rax
jbe 0xbc54
movq 0x58(%rsi), %rcx
addq $0x8, %rcx
leaq -0x8(%rax), %rdx
movq %rdx, 0x70(%rsi)
movq %rcx, -0x8(%rax)
movq 0xf8(%rsi), %rax
movq 0x20(%rax), %rax
movq %rax, 0x58(%rsi)
retq
movq (%rsi), %rdi
jmp 0x3452
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_push_data
void af_prim_push_data(af_task_t* task) {
  af_global_t* global = task->global;
  if(task->data_stack_current > task->data_stack_top) {
    *(--task->data_stack_current) =
      (af_cell_t)AF_WORD_DATA(task->current_word);
    AF_ADVANCE_IP(task, 1);
  } else {
    af_handle_data_stack_overflow(global, task);
  }
}

// Assembly:
movq %rdi, %rsi
movq 0x60(%rdi), %rax
cmpq 0x78(%rdi), %rax
jbe 0xbc94
movq 0xf8(%rsi), %rcx
addq $0x28, %rcx
leaq -0x8(%rax), %rdx
movq %rdx, 0x60(%rsi)
movq %rcx, -0x8(%rax)
movq 0x58(%rsi), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
movq %rax, 0x58(%rsi)
retq
movq (%rsi), %rdi
jmp 0x3402
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_do_does
void af_prim_do_does(af_task_t* task) {
  af_global_t* global = task->global;
  if(task->data_stack_current > task->data_stack_top) {
    if(task->return_stack_current > task->return_stack_top) {
      *(--task->data_stack_current) =
	(af_cell_t)AF_WORD_DATA(task->current_word);
      *(--task->return_stack_current) =
	task->interpreter_pointer ? task->interpreter_pointer + 1 : NULL;
      task->interpreter_pointer = task->current_word->secondary;
    } else {
      af_handle_return_stack_overflow(global, task);
    }
  } else {
    af_handle_data_stack_overflow(global, task);
  }
}

// Assembly:
movq %rdi, %rsi
movq (%rdi), %rdi
movq 0x60(%rsi), %rcx
cmpq 0x78(%rsi), %rcx
jbe 0x3402
movq 0x70(%rsi), %rax
cmpq 0x88(%rsi), %rax
jbe 0x3452
movq 0xf8(%rsi), %rdx
addq $0x28, %rdx
leaq -0x8(%rcx), %rdi
movq %rdi, 0x60(%rsi)
movq %rdx, -0x8(%rcx)
movq 0x58(%rsi), %rcx
leaq 0x8(%rcx), %rdx
testq %rcx, %rcx
cmovneq %rdx, %rcx
leaq -0x8(%rax), %rdx
movq %rdx, 0x70(%rsi)
movq %rcx, -0x8(%rax)
movq 0xf8(%rsi), %rax
movq 0x20(%rax), %rax
movq %rax, 0x58(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_literal
void af_prim_literal(af_task_t* task) {
  af_global_t* global = task->global;
  af_compiled_t* slot;
  AF_VERIFY_COMPILING(task);
  AF_VERIFY_DATA_STACK_READ(task, 1);
  slot = af_allot(global, task, sizeof(af_compiled_t) * 2);
  if(slot) {
    slot->compiled_call = global->builtin_literal_runtime;
    (slot + 1)->compiled_cell = *task->data_stack_current++;
    AF_ADVANCE_IP(task, 1);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movl $0x10, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3759
testq %rax, %rax
je 0xbd52
movq 0x180(%r14), %rcx
movq %rcx, (%rax)
movq 0x60(%rbx), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, 0x60(%rbx)
movq (%rcx), %rcx
movq %rcx, 0x8(%rax)
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
movq %rax, 0x58(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/cond.c
// Function: af_cond_init
af_bool_t af_cond_init(af_cond_t* cond) {
  if(pthread_cond_init(&cond->cond, NULL)) {
    return FALSE;
  }
  if(pthread_mutex_init(&cond->mutex, NULL)) {
    pthread_cond_destroy(&cond->cond);
    return FALSE;
  }
  cond->count = 0;
  return TRUE;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x28(%rdi), %rbx
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2200
testl %eax, %eax
jne 0xbdd3
movq %r14, %rdi
xorl %esi, %esi
callq 0x2300
testl %eax, %eax
je 0xbdc4
movq %rbx, %rdi
callq 0x2290
xorl %r15d, %r15d
jmp 0xbdd3
movq $0x0, 0x58(%r14)
movq $-0x1, %r15
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/cond.c
// Function: af_cond_wait
void af_cond_wait(af_cond_t* cond) {
  pthread_mutex_lock(&cond->mutex);
  if(!cond->count) {
    pthread_cond_wait(&cond->cond, &cond->mutex);
  }
  cond->count = 0;
  pthread_mutex_unlock(&cond->mutex);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x2310
cmpq $0x0, 0x58(%rbx)
jne 0xbe0e
leaq 0x28(%rbx), %rdi
movq %rbx, %rsi
callq 0x2100
movq $0x0, 0x58(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x2210
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/cond.c
// Function: af_cond_signal
void af_cond_signal(af_cond_t* cond) {
  pthread_mutex_lock(&cond->mutex);
  cond->count++;
  pthread_cond_signal(&cond->cond);
  pthread_mutex_unlock(&cond->mutex);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x2310
incq 0x58(%rbx)
leaq 0x28(%rbx), %rdi
callq 0x21d0
movq %rbx, %rdi
popq %rbx
jmp 0x2210
nop