LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_tick
void af_prim_tick(af_task_t* task) {
  af_global_t* global = task->global;
  af_byte_t* name;
  af_cell_t name_length;
  af_word_t* word;
  AF_VERIFY_DATA_STACK_EXPAND(task, 1);
  if(!af_parse_name_available(global, task)) {
    af_handle_word_expected(global, task);
    return;
  }
  name = af_parse_name(global, task, &name_length);

  if(!(word = af_lookup(global, task, name, name_length))) {
#ifdef DEBUG
    af_byte_t* buffer = malloc(name_length + 1);
    memcpy(buffer, name, name_length);
    buffer[name_length] = 0;
    fprintf(stderr, "Got name: \"%s\"\n", buffer);
    free(buffer);
#endif
    
    af_handle_word_not_found(global, task);
    return;
  }
  *(--task->data_stack_current) = (af_cell_t)word;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3db4
testq %rax, %rax
je 0x901a
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x3e63
movq (%r15), %rcx
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x383e
testq %rax, %rax
je 0x902e
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)
jmp 0x9039
movq %r14, %rdi
movq %rbx, %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x3515
movq %r14, %rdi
movq %rbx, %rsi
callq 0x358d
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_bracket_tick
void af_prim_bracket_tick(af_task_t* task) {
  af_global_t* global = task->global;
  af_byte_t* name;
  af_cell_t name_length;
  af_word_t* word;
  af_compiled_t* code;
  AF_VERIFY_COMPILING(task);
  if(!af_parse_name_available(global, task)) {
    af_handle_word_expected(global, task);
    return;
  }
  if(!(code = af_allot(global, task, sizeof(af_compiled_t) * 2))) {
    return;
  }
  name = af_parse_name(global, task, &name_length);
  if(!(word = af_lookup(global, task, name, name_length))) {
#ifdef DEBUG
    af_byte_t* buffer = malloc(name_length + 1);
    memcpy(buffer, name, name_length);
    buffer[name_length] = 0;
    fprintf(stderr, "Got name: \"%s\"\n", buffer);
    free(buffer);
#endif

    af_handle_word_not_found(global, task);
    return;
  }
  code->compiled_call = global->builtin_literal_runtime;
  (code + 1)->compiled_cell = (af_cell_t)word;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3db4
testq %rax, %rax
je 0x90c4
movl $0x10, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x377a
testq %rax, %rax
je 0x90e5
movq %rax, %r15
movq %rsp, %r12
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x3e63
movq (%r12), %rcx
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x383e
testq %rax, %rax
je 0x90da
movq 0x180(%r14), %rcx
movq %rcx, (%r15)
movq %rax, 0x8(%r15)
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, 0x58(%rbx)
jmp 0x90e5
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3515
movq %r14, %rdi
movq %rbx, %rsi
callq 0x358d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_to_return
void af_prim_to_return(af_task_t* task) {
  af_global_t* global = task->global;
  af_task_t* target_task;
  af_compiled_t* pointer;
  AF_VERIFY_DATA_STACK_READ(task, 2);
  target_task = (af_task_t*)(*task->data_stack_current++);
  pointer = (af_compiled_t*)(*task->data_stack_current++);
  af_push_return(global, target_task, pointer);
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x60(%rbx), %rax
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
movq %rcx, 0x60(%rbx)
movq 0x8(%rax), %rdx
callq 0x3147
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_O3/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_allocate
void af_prim_allocate(af_task_t* task) {
  void* data;
  AF_VERIFY_DATA_STACK_READ(task, 1);
  AF_VERIFY_DATA_STACK_EXPAND(task, 1);
  if(!(data = malloc((size_t)(*task->data_stack_current)))) {
    *task->data_stack_current = (af_cell_t)NULL;
    *(--task->data_stack_current) = 1;
    return;
  }
  *task->data_stack_current = (af_cell_t)data;
  *(--task->data_stack_current) = 0;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %r14
movq (%r14), %rdi
callq 0x2220
testq %rax, %rax
je 0x9428
movq %rax, (%r14)
leaq -0x8(%r14), %rax
movq %rax, 0x60(%rbx)
movq $0x0, -0x8(%r14)
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
movq %rax, 0x58(%rbx)
jmp 0x943f
movq $0x0, (%r14)
leaq -0x8(%r14), %rax
movq %rax, 0x60(%rbx)
movq $0x1, -0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_resize
void af_prim_resize(af_task_t* task) {
  void* data;
  AF_VERIFY_DATA_STACK_READ(task, 2);
  if(!(data = realloc((void*)(*(task->data_stack_current + 1)),
		      (size_t)(*task->data_stack_current)))) {
    *(task->data_stack_current + 1) = (af_cell_t)NULL;
    *task->data_stack_current = 1;
    return;
  }
  *(task->data_stack_current + 1) = (af_cell_t)data;
  *task->data_stack_current = 0;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdi
callq 0x2230
testq %rax, %rax
je 0x94b4
movq 0x60(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq $0x0, (%rcx)
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, 0x58(%rbx)
jmp 0x94c7
movq 0x60(%rbx), %rax
movq $0x0, 0x8(%rax)
movq $0x1, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_allot
void af_prim_allot(af_task_t* task) {
  af_global_t* global = task->global;
  AF_VERIFY_DATA_STACK_READ(task, 1);
  if(!af_allot(global, task, (ssize_t)(*task->data_stack_current++))) {
    return;
  }
  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), %rdx
movq %rbx, %rsi
callq 0x377a
testq %rax, %rax
je 0x94ff
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_O3/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_word
void af_prim_word(af_task_t* task) {
  af_global_t* global = task->global;
  af_byte_t delimiter;
  af_byte_t* text;
  AF_VERIFY_DATA_STACK_READ(task, 1);
  delimiter = (af_byte_t)(*task->data_stack_current & 0xFF);
  text = af_word(global, task, delimiter);
  *task->data_stack_current = (af_cell_t)text;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x60(%rbx), %rax
movzbl (%rax), %edx
movq %rbx, %rsi
callq 0x3cfc
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_O3/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_parse_name
void af_prim_parse_name(af_task_t* task) {
  af_global_t* global = task->global;
  af_byte_t* text;
  af_cell_t length;
  AF_VERIFY_DATA_STACK_EXPAND(task, 2);
  if(!af_parse_name_available(global, task)) {
    *(--task->data_stack_current) = (af_cell_t)NULL;
    *(--task->data_stack_current) = 0;
  } else {
    text = af_parse_name(global, task, &length);
    *(--task->data_stack_current) = (af_cell_t)text;
    *(--task->data_stack_current) = length;
  }
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3db4
testq %rax, %rax
je 0x9572
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x3e63
movq 0x60(%rbx), %rcx
movq %rax, -0x8(%rcx)
movq (%r15), %rax
jmp 0x9580
movq 0x60(%rbx), %rcx
movq $0x0, -0x8(%rcx)
xorl %eax, %eax
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 $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_format_number
void af_prim_format_number(af_task_t* task) {
  af_byte_t buffer[64];
  af_byte_t* current = buffer + sizeof(buffer);
  af_cell_t length = 0;
  af_cell_t value;
  af_bool_t negative = FALSE;
  AF_VERIFY_DATA_STACK_READ(task, 1);
  AF_VERIFY_DATA_STACK_EXPAND(task, 1);
  value = *task->data_stack_current;
  if(value == 0) {
    *(--current) = '0';
    length++;
  } else if(task->base == 10) {
    af_sign_cell_t signed_value = (af_sign_cell_t)value;
    if(signed_value < 0) {
      negative = TRUE;
      value = (af_cell_t)(-signed_value);
    }
    while(value > 0) {
      af_byte_t part = value % 10;
      part += '0';
      value /= 10;
      *(--current) = part;
      length++;
    }
    if(negative) {
      *(--current) = '-';
      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 = (af_cell_t)task->data_space_current;
  *(--task->data_stack_current) = length;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x60(%rdi), %rax
movq (%rax), %rcx
testq %rcx, %rcx
je 0x9738
movq 0xf0(%rbx), %rdi
cmpq $0xa, %rdi
jne 0x9748
movq %rcx, %rdi
negq %rdi
cmovsq %rcx, %rdi
movl $0x1, %r14d
leaq 0x3f(%rsp), %rsi
movabsq $-0x3333333333333333, %r8 # imm = 0xCCCCCCCCCCCCCCCD
movq %rdi, %rax
mulq %r8
shrq $0x3, %rdx
leal (%rdx,%rdx), %eax
leal (%rax,%rax,4), %eax
movl %edi, %r9d
subl %eax, %r9d
orb $0x30, %r9b
movb %r9b, (%rsi)
decq %rsi
incq %r14
cmpq $0x9, %rdi
movq %rdx, %rdi
ja 0x96ff
testq %rcx, %rcx
js 0x979a
incq %rsi
decq %r14
jmp 0x979d
leaq 0x3f(%rsp), %rsi
movb $0x30, (%rsi)
movl $0x1, %r14d
jmp 0x979d
leaq 0x40(%rsp), %rsi
leaq -0x2(%rdi), %rax
xorl %r14d, %r14d
cmpq $0x22, %rax
ja 0x979d
movq %rcx, %rax
xorl %edx, %edx
divq %rdi
movl %edx, %r8d
andl $0x3e, %r8d
movl %edx, %r9d
orb $0x30, %r9b
addb $0x37, %dl
cmpl $0xa, %r8d
movzbl %r9b, %r8d
movzbl %dl, %edx
cmovbl %r8d, %edx
movb %dl, 0x3f(%rsp,%r14)
decq %r14
cmpq %rcx, %rdi
movq %rax, %rcx
jbe 0x975a
addq %r14, %rsi
negq %r14
jmp 0x979d
movb $0x2d, (%rsi)
movq 0xc8(%rbx), %rdi
movq %r14, %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 $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_format_unsigned_number
void af_prim_format_unsigned_number(af_task_t* task) {
  af_byte_t buffer[64];
  af_byte_t* current = buffer + sizeof(buffer);
  af_cell_t length = 0;
  af_cell_t value;
  af_bool_t negative = FALSE;
  AF_VERIFY_DATA_STACK_READ(task, 1);
  AF_VERIFY_DATA_STACK_EXPAND(task, 1);
  value = *task->data_stack_current;
  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 = (af_cell_t)task->data_space_current;
  *(--task->data_stack_current) = length;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x60(%rdi), %rax
movq (%rax), %rcx
testq %rcx, %rcx
je 0x9850
leaq 0x40(%rsp), %rsi
movq 0xf0(%rbx), %rdi
leaq -0x2(%rdi), %rax
xorl %r14d, %r14d
cmpq $0x22, %rax
ja 0x985e
movq %rcx, %rax
xorl %edx, %edx
divq %rdi
movl %edx, %r8d
andl $0x3e, %r8d
movl %edx, %r9d
orb $0x30, %r9b
addb $0x37, %dl
cmpl $0xa, %r8d
movzbl %r9b, %r8d
movzbl %dl, %edx
cmovbl %r8d, %edx
movb %dl, 0x3f(%rsp,%r14)
decq %r14
cmpq %rcx, %rdi
movq %rax, %rcx
jbe 0x9810
addq %r14, %rsi
negq %r14
jmp 0x985e
leaq 0x3f(%rsp), %rsi
movb $0x30, (%rsi)
movl $0x1, %r14d
movq 0xc8(%rbx), %rdi
movq %r14, %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 $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_format_2number
void af_prim_format_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 == 10) {
    af_sign_2cell_t signed_value = (af_sign_2cell_t)value;
    if(signed_value < 0) {
      negative = TRUE;
      value = (af_2cell_t)(-signed_value);
    }
    while(value > 0) {
      af_byte_t part = value % 10;
      part += '0';
      value /= 10;
      *(--current) = part;
      length++;
    }
    if(negative) {
      *(--current) = '-';
      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 $0x98, %rsp
movq %rdi, %r13
movq 0x60(%rdi), %rax
movq (%rax), %r12
movq 0x8(%rax), %rbx
movq %rbx, %rax
orq %r12, %rax
je 0x9961
movq 0xf0(%r13), %rbp
cmpq $0xa, %rbp
jne 0x9975
movq %r13, 0x8(%rsp)
xorl %ebp, %ebp
movq %rbx, %r13
negq %r13
sbbq %r12, %rbp
testq %r12, %r12
cmovnsq %r12, %rbp
cmovnsq %rbx, %r13
movl $0x1, %r15d
leaq 0x8f(%rsp), %r14
movl $0x9, %ebx
movl $0xa, %edx
movq %r13, %rdi
movq %rbp, %rsi
xorl %ecx, %ecx
callq 0xd6a0
movq %rax, %rcx
addq %rax, %rcx
leaq (%rcx,%rcx,4), %rcx
movl %r13d, %esi
subl %ecx, %esi
orb $0x30, %sil
movb %sil, (%r14)
decq %r14
incq %r15
cmpq %r13, %rbx
movl $0x0, %ecx
sbbq %rbp, %rcx
movq %rax, %r13
movq %rdx, %rbp
jb 0x990c
testq %r12, %r12
js 0x99e6
incq %r14
decq %r15
jmp 0x99ea
leaq 0x8f(%rsp), %r14
movb $0x30, (%r14)
movl $0x1, %r15d
jmp 0x99ef
leaq 0x90(%rsp), %r14
leaq -0x2(%rbp), %rax
xorl %r15d, %r15d
cmpq $0x22, %rax
ja 0x99ef
movq %rbx, %rdi
movq %r12, %rsi
movq %rbp, %rdx
xorl %ecx, %ecx
callq 0xd6a0
movq %rax, %rcx
imulq %rbp, %rcx
movq %rbx, %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, 0x8f(%rsp,%r15)
decq %r15
cmpq %rbp, %rbx
sbbq $0x0, %r12
movq %rax, %rbx
movq %rdx, %r12
jae 0x998a
addq %r15, %r14
negq %r15
jmp 0x99ef
movb $0x2d, (%r14)
movq 0x8(%rsp), %r13
movq 0xc8(%r13), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x21f0
movq 0x60(%r13), %rax
movq 0xc8(%r13), %rcx
movq %rcx, 0x8(%rax)
movq %r15, (%rax)
movq 0x58(%r13), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, 0x58(%r13)
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9ad4
leaq 0x80(%rsp), %r14
movq 0xf0(%rbx), %rbp
leaq -0x2(%rbp), %rax
xorl %r15d, %r15d
cmpq $0x22, %rax
ja 0x9ae3
movq %r13, %rdi
movq %r12, %rsi
movq %rbp, %rdx
xorl %ecx, %ecx
callq 0xd6a0
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 0x9a7b
addq %r15, %r14
negq %r15
jmp 0x9ae3
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_O3/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 0x9d66
movq 0x8(%rcx), %rcx
movq %rcx, (%rdx)
movq $-0x1, %rcx
jmp 0x9d68
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_O3/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 0x9db2
movq 0x8(%rcx), %rdx
cmpq 0x20(%rax), %rdx
jne 0x9db2
movq 0x8(%rax), %rdx
movq %rdx, (%rcx)
movq 0x10(%rax), %rdx
addq $0x20, %rax
movq %rdx, 0x8(%rcx)
jmp 0x9db6
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_O3/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 0x9e30
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_O3/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 0x2e40
testq %rax, %rax
je 0x9e69
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_O3/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
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 0x9ecc
movq %rsi, %rdx
movq (%rsi), %rsi
testq %rsi, %rsi
jne 0x9eba
jmp 0x9ecf
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_O3/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 0x9f04
movq (%rcx), %rdx
testq %rdx, %rdx
jne 0x9ef4
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_O3/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 0xa1f3
movq 0x8(%rax), %rax
movq %rax, 0x58(%rsi)
retq
movq (%rsi), %rdi
jmp 0x367d
// File: /workspace/github_c_makefile_star2_O3/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 0xa21f
movq 0x60(%rsi), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, 0x60(%rsi)
cmpq $0x0, (%rcx)
je 0xa227
addq $0x10, %rax
jmp 0xa22b
movq (%rsi), %rdi
jmp 0x367d
movq 0x8(%rax), %rax
movq %rax, 0x58(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/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), %rcx
testq %rcx, %rcx
je 0xa3f7
movq 0x60(%rdi), %rax
movq 0xb0(%rdi), %rdx
addq $-0x8, %rax
movq -0x8(%rdx,%rcx,8), %rsi
decq %rcx
movq %rax, 0x60(%rdi)
movq %rsi, (%rax)
addq $-0x8, %rax
testq %rcx, %rcx
jne 0xa3d2
movq 0xb8(%rdi), %rcx
addq $0x8, %rax
jmp 0xa3fd
movq 0x60(%rdi), %rax
xorl %ecx, %ecx
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_O3/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 0x37c7
movq 0x60(%rbx), %rcx
testq %rax, %rax
je 0xa460
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)
addq $0x8, %rcx
jmp 0xa46c
movq $0x0, 0x10(%rcx)
addq $0x10, %rcx
movq %rcx, 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_O3/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 0xa509
cmpq 0xc0(%rsi), %rcx
ja 0x36a5
movq %rcx, 0xb8(%rsi)
addq $0x8, %rdx
movq %rdx, 0x60(%rsi)
testq %rcx, %rcx
je 0xa526
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 0xa4ec
jmp 0xa526
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_O3/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
cmpq $0x0, (%rax)
setne 0x7(%rsp)
movq 0x8(%rax), %r13
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 0xa740
movq %rax, %r14
movq %rbp, 0x8(%rsp)
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 0xa745
movq %rax, %r13
xorl %ebp, %ebp
movb 0x7(%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 0xa768
callq 0x2070
movslq (%rax), %r15
jmp 0xa76b
movq %rbp, %rdi
jmp 0xa752
movq %r14, %rdi
callq 0x2050
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x35b5
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_O3/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 0xc4c5
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_O3/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 0xa927
movq %rax, %r14
movq 0x60(%rbx), %rax
movq (%rax), %rdi
movq %r14, %rsi
callq 0xc4f2
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 0x35b5
// File: /workspace/github_c_makefile_star2_O3/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 0xc554
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_O3/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_io_state_has_error
void af_prim_io_state_has_error(af_task_t* task) {
  AF_VERIFY_DATA_STACK_READ(task, 1);
  *(af_bool_t*)task->data_stack_current =
    af_io_state_has_error((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 0xc559
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_O3/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_io_state_get_index
void af_prim_io_state_get_index(af_task_t* task) {
  AF_VERIFY_DATA_STACK_READ(task, 1);
  *task->data_stack_current =
    af_io_state_get_index((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 0xc562
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_O3/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
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 0xc82d
movq %rax, %rdi
callq 0xc43c
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 0x31be
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc973
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 0x31be
// File: /workspace/github_c_makefile_star2_O3/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 0xbad2
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 0x3475
// File: /workspace/github_c_makefile_star2_O3/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 0xbb12
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 0x3425
// File: /workspace/github_c_makefile_star2_O3/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 0x3425
movq 0x70(%rsi), %rax
cmpq 0x88(%rsi), %rax
jbe 0x3475
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_O3/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 0xbc4f
movq %r14, %rdi
xorl %esi, %esi
callq 0x2300
testl %eax, %eax
je 0xbc40
movq %rbx, %rdi
callq 0x2290
xorl %r15d, %r15d
jmp 0xbc4f
movq $0x0, 0x58(%r14)
movq $-0x1, %r15
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xbc8a
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_O3/tabemann[P]attoforth/src/runtime/io.c
// Function: af_io_init
af_bool_t af_io_init(af_io_t* io, af_global_t* global) {
  af_io_fd_t pipefd[2];
  if(pthread_mutex_init(&io->mutex, NULL)) {
    return FALSE;
  }
  if(pipe(pipefd)) {
    pthread_mutex_destroy(&io->mutex);
    return FALSE;
  }
  io->global = global;
  io->break_fd_out = pipefd[0];
  io->break_fd_in = pipefd[1];
  if(!af_fd_set_blocking(io->break_fd_in, TRUE)) {
    close(io->break_fd_out);
    close(io->break_fd_in);
    pthread_mutex_destroy(&io->mutex);
    return FALSE;
  }
  io->active_action_count = 0;
  io->first_active_action = NULL;
  io->first_waiting_action = NULL;
  io->last_waiting_action = NULL;
  io->first_done_action = NULL;
  io->to_be_destroyed = FALSE;
  io->handler_task = NULL;
  if(!af_io_prepare_stdin()) {
    close(io->break_fd_out);
    close(io->break_fd_in);
    pthread_mutex_destroy(&io->mutex);
    return FALSE;
  }
  if(pthread_create(&io->pthread, NULL, af_io_main, io)) {
    close(io->break_fd_out);
    close(io->break_fd_in);
    pthread_mutex_destroy(&io->mutex);
    return FALSE;
  }
  return TRUE;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2300
testl %eax, %eax
jne 0xbd6c
movq %rsp, %rdi
callq 0x2190
testl %eax, %eax
jne 0xbd61
movq %r15, 0x30(%r14)
movl (%rsp), %eax
movl %eax, 0x3c(%r14)
movl 0x4(%rsp), %edi
movl %edi, 0x38(%r14)
movq $-0x1, %rsi
callq 0xbd84
testq %rax, %rax
je 0xbd4f
movq $0x0, 0x40(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%r14)
movups %xmm0, 0x60(%r14)
movups %xmm0, 0x70(%r14)
callq 0xbdde
testq %rax, %rax
je 0xbd4f
leaq 0xf6(%rip), %rdx        # 0xbe34
movq %r14, %rdi
xorl %esi, %esi
movq %r14, %rcx
callq 0x2250
testl %eax, %eax
je 0xbd7b
movl 0x3c(%r14), %edi
callq 0x2180
movl 0x38(%r14), %edi
callq 0x2180
movq %rbx, %rdi
callq 0x2140
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq $-0x1, %r12
jmp 0xbd6c
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/io.c
// Function: af_io_prepare_stdin
af_bool_t af_io_prepare_stdin(void) {
  struct termios tp;
  if(isatty(STDIN_FILENO)) {
    if(tcgetattr(STDIN_FILENO, &tp) == -1) {
      return FALSE;      
    }
    if(tp.c_lflag & ECHO || tp.c_lflag & ICANON) {
      tp.c_lflag &= ~ECHO & ~ICANON;
      if(tcsetattr(STDIN_FILENO, TCSANOW, &tp) == -1) {
	return FALSE;
      }
    }
  }
  return TRUE;
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
xorl %edi, %edi
callq 0x20a0
testl %eax, %eax
je 0xbe24
xorl %ebx, %ebx
leaq 0x4(%rsp), %rsi
xorl %edi, %edi
callq 0x2270
cmpl $-0x1, %eax
je 0xbe2b
movl 0x10(%rsp), %eax
testb $0xa, %al
je 0xbe24
andl $-0xb, %eax
leaq 0x4(%rsp), %rdx
movl %eax, 0xc(%rdx)
xorl %ebx, %ebx
xorl %edi, %edi
xorl %esi, %esi
callq 0x2280
cmpl $-0x1, %eax
je 0xbe2b
movq $-0x1, %rbx
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/io.c
// Function: af_io_cleanup_stdin
af_bool_t af_io_cleanup_stdin(void) {
  struct termios tp;
  af_fd_set_blocking(STDIN_FILENO, TRUE);
  if(isatty(STDIN_FILENO)) {
    if(tcgetattr(STDIN_FILENO, &tp) == -1) {
      return FALSE;      
    }
    if(!(tp.c_lflag & ECHO) || !(tp.c_lflag & ICANON)) {
      tp.c_lflag |= ECHO | ICANON;
      if(tcsetattr(STDIN_FILENO, TCSANOW, &tp) == -1) {
	return FALSE;
      }
    }
  }
  return TRUE;
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq $-0x1, %rbx
xorl %edi, %edi
movq $-0x1, %rsi
callq 0xbd84
xorl %edi, %edi
callq 0x20a0
testl %eax, %eax
je 0xc3f2
leaq 0x4(%rsp), %rsi
xorl %edi, %edi
callq 0x2270
cmpl $-0x1, %eax
je 0xc3f0
movl 0x10(%rsp), %eax
movl %eax, %ecx
notl %ecx
testb $0xa, %cl
je 0xc3f2
orl $0xa, %eax
leaq 0x4(%rsp), %rdx
movl %eax, 0xc(%rdx)
xorl %edi, %edi
xorl %esi, %esi
callq 0x2280
cmpl $-0x1, %eax
jne 0xc3f2
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/io.c
// Function: af_io_action_destroy
void af_io_action_destroy(af_io_action_t* action) {
  af_io_t* io = action->io;
  pthread_mutex_lock(&io->mutex);
  if(action->is_done) {
    if(action->prev_action) {
      action->prev_action->next_action = action->next_action;
    } else {
      io->first_done_action = action->next_action;
    }
    if(action->next_action) {
      action->next_action->prev_action = action->prev_action;
    }
    free(action);
  } else {
    action->to_be_destroyed = TRUE;
  }
  pthread_mutex_unlock(&io->mutex);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x10(%rdi), %r15
leaq 0x8(%r15), %rbx
movq %rbx, %rdi
callq 0x2310
cmpq $0x0, 0x78(%r14)
je 0xc486
movq (%r14), %rax
movq 0x8(%r14), %rcx
addq $0x68, %r15
leaq 0x8(%rax), %rdx
testq %rax, %rax
cmoveq %r15, %rdx
movq %rcx, (%rdx)
testq %rcx, %rcx
je 0xc47c
movq %rax, (%rcx)
movq %r14, %rdi
callq 0x2050
jmp 0xc48e
movq $-0x1, 0x20(%r14)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2210
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/io.c
// Function: af_io_open
af_io_fd_t af_io_open(af_byte_t* path, af_io_size_t count, af_io_flags_t flags,
		      af_io_mode_t mode, af_io_error_t* error) {
  af_byte_t* path_buffer = malloc(sizeof(af_byte_t) * (count + 1));
  af_io_fd_t fd;
  memcpy(path_buffer, path, count);
  path_buffer[count] = 0;
  if((fd = open(path_buffer, flags, mode)) >= 0) {
    *error = 0;
    free(path_buffer);
    return fd;
  } else {
    *error = errno;
    free(path_buffer);
    return -1;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r13
leaq 0x1(%rsi), %rdi
callq 0x2220
movq %rax, %r14
movq %rax, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x21f0
movb $0x0, (%r14,%r12)
xorl %r12d, %r12d
movq %r14, %rdi
movl %r15d, %esi
movl %ebp, %edx
xorl %eax, %eax
callq 0x22a0
movl %eax, %ebp
testl %eax, %eax
jns 0xc5ce
callq 0x2070
movl (%rax), %r12d
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %r14, %rdi
callq 0x2050
movl %r12d, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/io.c
// Function: af_io_pipe
af_bool_t af_io_pipe(af_io_fd_t* in, af_io_fd_t* out, af_io_error_t* error) {
  af_io_fd_t fds[2];
  if(!pipe(fds)) {
    *out = fds[0];
    *in = fds[1];
    *error = 0;
    return TRUE;
  } else {
    *error = errno;
    return FALSE;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %rdi
callq 0x2190
testl %eax, %eax
je 0xc615
callq 0x2070
movl (%rax), %ecx
xorl %eax, %eax
jmp 0xc62c
movl 0x8(%rsp), %eax
movl %eax, (%r15)
movl 0xc(%rsp), %eax
movl %eax, (%r14)
movq $-0x1, %rax
xorl %ecx, %ecx
movl %ecx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq