LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_task_local
void af_prim_task_local(af_task_t* task) {
  af_global_t* global = task->global;
  void* default_data;
  af_cell_t size;
  af_cell_t allocated_size;
  af_task_t* current_task;
  AF_VERIFY_DATA_STACK_READ(task, 2);
  default_data = (void*)(*(task->data_stack_current + 1));
  size = *task->data_stack_current;
  allocated_size = global->task_local_space_size_allocated;
  if(allocated_size + size > global->task_local_space_size) {
    af_cell_t new_space_size = global->task_local_space_size * 2;
    current_task = global->first_task;
    if(new_space_size < allocated_size + size) {
      new_space_size = allocated_size + size;
    }
    global->default_task_local_space_base =
      realloc(global->default_task_local_space_base, new_space_size);
    while(current_task) {
      current_task->task_local_space_base =
	realloc(current_task->task_local_space_base, new_space_size);
      current_task = current_task->next_task;
    }
    global->task_local_space_size = new_space_size;
  }
  memcpy(global->default_task_local_space_base + allocated_size,
	 default_data, size);
  current_task = global->first_task;
  while(current_task) {
    memcpy(current_task->task_local_space_base + allocated_size,
	   default_data, size);
    current_task = current_task->next_task;
  }
  *(++task->data_stack_current) = allocated_size;
  global->task_local_space_size_allocated += size;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r13
movq %rdi, (%rsp)
movq 0x60(%rdi), %rax
movq (%rax), %r14
movq 0x8(%rax), %r15
movq 0x1d8(%r13), %r12
movq 0x1e0(%r13), %rbp
leaq (%r14,%rbp), %rax
cmpq %r12, %rax
jbe 0x8ca8
addq %r12, %r12
movq (%r13), %rbx
movq 0x1e8(%r13), %rdi
cmpq %rax, %r12
cmovbeq %rax, %r12
movq %r12, %rsi
callq 0x2230
movq %rax, 0x1e8(%r13)
testq %rbx, %rbx
je 0x8ca1
movq 0x120(%rbx), %rdi
movq %r12, %rsi
callq 0x2230
movq %rax, 0x120(%rbx)
movq 0x8(%rbx), %rbx
jmp 0x8c80
movq %r12, 0x1d8(%r13)
movq 0x1e8(%r13), %rdi
addq %rbp, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x21f0
movq %r13, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x8ce3
movq 0x120(%rbx), %rdi
addq %rbp, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x21f0
addq $0x8, %rbx
jmp 0x8cc0
movq (%rsp), %rdx
movq 0x60(%rdx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x60(%rdx)
movq %rbp, 0x8(%rax)
addq %r14, 0x1e0(%r13)
movq 0x58(%rdx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
movq %rax, 0x58(%rdx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3c38
testq %rax, %rax
je 0x8e0d
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x3cc1
movq (%r15), %rcx
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x36c6
testq %rax, %rax
je 0x8e21
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 0x8e2c
movq %r14, %rdi
movq %rbx, %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x33ce
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3446
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3c38
testq %rax, %rax
je 0x8eb5
pushq $0x10
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3621
testq %rax, %rax
je 0x8ed6
movq %rax, %r15
movq %rsp, %r12
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x3cc1
movq (%r12), %rcx
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x36c6
testq %rax, %rax
je 0x8ecb
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 0x8ed6
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x33ce
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3446
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x9216
movq %rax, (%r14)
leaq -0x8(%r14), %rax
movq %rax, 0x60(%rbx)
andq $0x0, -0x8(%r14)
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
movq %rax, 0x58(%rbx)
jmp 0x922a
andq $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_O2/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_free
void af_prim_free(af_task_t* task) {
  AF_VERIFY_DATA_STACK_READ(task, 1);
  free((void*)(*task->data_stack_current));
  *task->data_stack_current = 0;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %rax
movq (%rax), %rdi
callq 0x2050
movq 0x60(%rbx), %rax
andq $0x0, (%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_O2/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 0x9299
movq 0x60(%rbx), %rcx
movq %rax, 0x8(%rcx)
andq $0x0, (%rcx)
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, 0x58(%rbx)
jmp 0x92a9
movq 0x60(%rbx), %rax
andq $0x0, 0x8(%rax)
movq $0x1, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3621
testq %rax, %rax
je 0x92e1
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_O2/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 0x3b84
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_O2/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 0x3c38
testq %rax, %rax
je 0x9354
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x3cc1
movq 0x60(%rbx), %rcx
movq %rax, -0x8(%rcx)
movq (%r15), %rax
jmp 0x935f
movq 0x60(%rbx), %rcx
andq $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_O2/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_parse_number
void af_prim_parse_number(af_task_t* task) {
  af_global_t* global = task->global;
  af_byte_t* text;
  af_cell_t length;
  af_sign_cell_t result;
  af_bool_t success;
  AF_VERIFY_DATA_STACK_READ(task, 2);
  text = (af_byte_t*)(*(task->data_stack_current + 1));
  length = *task->data_stack_current;
  success = af_parse_number(global, task->base, text, length, &result);
  *(task->data_stack_current + 1) = (af_cell_t)result;
  *task->data_stack_current = (af_cell_t)success;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x60(%rbx), %rax
movq 0xf0(%rbx), %rsi
movq (%rax), %rcx
movq 0x8(%rax), %rdx
movq %rsp, %r14
movq %r14, %r8
callq 0x371a
movq (%r14), %rcx
movq 0x60(%rbx), %rdx
movq %rcx, 0x8(%rdx)
movq %rax, (%rdx)
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, 0x58(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x94f0
leaq 0x40(%rsp), %rsi
movq 0xf0(%rbx), %rdi
cmpq $0xa, %rdi
jne 0x94fe
movq %rcx, %rax
negq %rax
cmovsq %rcx, %rax
xorl %edi, %edi
pushq $0xa
popq %r8
xorl %r14d, %r14d
testq %rax, %rax
je 0x954b
xorl %edx, %edx
divq %r8
orb $0x30, %dl
movb %dl, 0x3f(%rsp,%rdi)
incq %r14
decq %rdi
jmp 0x94d7
leaq 0x3f(%rsp), %rsi
movb $0x30, (%rsi)
pushq $0x1
popq %r14
jmp 0x9565
leaq -0x2(%rdi), %rax
xorl %r14d, %r14d
cmpq $0x22, %rax
ja 0x9565
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 0x950b
addq %r14, %rsi
negq %r14
jmp 0x9565
testq %rcx, %rcx
js 0x9555
subq %r14, %rsi
jmp 0x9565
leaq 0x3f(%rsp), %rsi
subq %r14, %rsi
movb $0x2d, 0x3f(%rsp,%rdi)
incq %r14
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_O2/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 0x9618
leaq 0x40(%rsp), %rsi
movq 0xf0(%rbx), %rdi
leaq -0x2(%rdi), %rax
xorl %r14d, %r14d
cmpq $0x22, %rax
ja 0x9624
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 0x95d8
addq %r14, %rsi
negq %r14
jmp 0x9624
leaq 0x3f(%rsp), %rsi
movb $0x30, (%rsi)
pushq $0x1
popq %r14
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_O2/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 $0x88, %rsp
movq %rdi, %rbx
movq 0x60(%rdi), %rax
movq (%rax), %r12
movq 0x8(%rax), %r13
movq %r13, %rax
orq %r12, %rax
je 0x96fc
leaq 0x80(%rsp), %r14
movq 0xf0(%rbx), %rbp
cmpq $0xa, %rbp
jne 0x970e
xorl %r14d, %r14d
movq %r13, %rbp
negq %rbp
movl $0x0, %edx
sbbq %r12, %rdx
testq %r12, %r12
cmovnsq %r12, %rdx
cmovnsq %r13, %rbp
pushq $0xa
popq %r13
xorl %r15d, %r15d
movq %rbp, %rax
orq %rdx, %rax
je 0x9774
movq %rbp, %rdi
movq %rdx, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0xd3b0
imull $0xa, %eax, %ecx
subl %ecx, %ebp
orb $0x30, %bpl
movb %bpl, 0x7f(%rsp,%r14)
incq %r15
decq %r14
movq %rax, %rbp
jmp 0x96c7
leaq 0x7f(%rsp), %r14
movb $0x30, (%r14)
pushq $0x1
popq %r15
jmp 0x979a
leaq -0x2(%rbp), %rax
xorl %r15d, %r15d
cmpq $0x22, %rax
ja 0x979a
movq %r13, %rdi
movq %r12, %rsi
movq %rbp, %rdx
xorl %ecx, %ecx
callq 0xd3b0
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 0x971b
addq %r15, %r14
negq %r15
jmp 0x979a
testq %r12, %r12
js 0x9786
leaq 0x80(%rsp), %r14
subq %r15, %r14
jmp 0x979a
leaq 0x7f(%rsp), %rax
subq %r15, %rax
movb $0x2d, 0x7f(%rsp,%r14)
movq %rax, %r14
incq %r15
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_O2/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 0x987f
leaq 0x80(%rsp), %r14
movq 0xf0(%rbx), %rbp
leaq -0x2(%rbp), %rax
xorl %r15d, %r15d
cmpq $0x22, %rax
ja 0x988c
movq %r13, %rdi
movq %r12, %rsi
movq %rbp, %rdx
xorl %ecx, %ecx
callq 0xd3b0
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 0x9826
addq %r15, %r14
negq %r15
jmp 0x988c
leaq 0x7f(%rsp), %r14
movb $0x30, (%r14)
pushq $0x1
popq %r15
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_O2/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 %r12
pushq %rbx
subq $0x98, %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 0x5192(%rip), %rdx      # 0xeaa2
leaq 0x10(%rsp), %r14
pushq $0x40
popq %r15
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x2150
leaq 0x50(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movsd 0x8(%rsp), %xmm0
movb $0x1, %al
callq 0x2150
movq %r12, %rdi
callq 0x2120
movq %rax, %r14
movq 0xc8(%rbx), %rdi
movq %r12, %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 $0x98, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x36c6
testq %rax, %rax
je 0x9aca
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 0x9adb
movq 0x60(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x60(%rbx)
andq $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_O2/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 0x9b10
movq 0x8(%rcx), %rcx
movq %rcx, (%rdx)
pushq $-0x1
popq %rcx
jmp 0x9b12
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_O2/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 0x9b5c
movq 0x8(%rcx), %rdx
cmpq 0x20(%rax), %rdx
jne 0x9b5c
movq 0x8(%rax), %rdx
movq %rdx, (%rcx)
movq 0x10(%rax), %rdx
addq $0x20, %rax
movq %rdx, 0x8(%rcx)
jmp 0x9b60
addq $0x20, %rax
movq %rax, 0x60(%rdi)
orq $-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_O2/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 0x26a8
testq %rax, %rax
je 0x9bd7
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_O2/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 0x2d9f
testq %rax, %rax
je 0x9c10
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_O2/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 0x9c73
movq %rsi, %rdx
movq (%rsi), %rsi
testq %rsi, %rsi
jne 0x9c61
jmp 0x9c76
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_O2/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 0x9cab
movq (%rcx), %rdx
testq %rdx, %rdx
jne 0x9c9b
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_O2/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 0x2995
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_O2/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 0x9f94
movq 0x8(%rax), %rax
movq %rax, 0x58(%rsi)
retq
movq (%rsi), %rdi
jmp 0x3536
// File: /workspace/github_c_makefile_star2_O2/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 0x9fc0
movq 0x60(%rsi), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, 0x60(%rsi)
cmpq $0x0, (%rcx)
je 0x9fc8
addq $0x10, %rax
jmp 0x9fcc
movq (%rsi), %rdi
jmp 0x3536
movq 0x8(%rax), %rax
movq %rax, 0x58(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb0(%rdi), %rax
movq 0xb8(%rdi), %rcx
subq $0x1, %rcx
jb 0xa182
movq (%rax,%rcx,8), %rdx
movq 0x60(%rdi), %rsi
leaq -0x8(%rsi), %r8
movq %r8, 0x60(%rdi)
movq %rdx, -0x8(%rsi)
jmp 0xa166
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_O2/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 0x364f
movq 0x60(%rbx), %rcx
testq %rax, %rax
je 0xa1f0
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 0xa1f9
andq $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_O2/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 0xa291
cmpq 0xc0(%rsi), %rcx
ja 0x355e
movq %rcx, 0xb8(%rsi)
addq $0x8, %rdx
movq %rdx, 0x60(%rsi)
xorl %edx, %edx
cmpq %rdx, %rcx
je 0xa2ae
movq 0x60(%rsi), %rdi
leaq 0x8(%rdi), %r8
movq %r8, 0x60(%rsi)
movq (%rdi), %rdi
movq %rdi, (%rax,%rdx,8)
incq %rdx
jmp 0xa274
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_O2/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
pushq $0x8
popq %rdi
callq 0x2220
testq %rax, %rax
je 0xa308
andq $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 0x346e
// File: /workspace/github_c_makefile_star2_O2/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 0xa4c3
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 0xa4c8
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 0xa4eb
callq 0x2070
movslq (%rax), %r15
jmp 0xa4ee
movq %rbp, %rdi
jmp 0xa4d5
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 0x346e
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_O2/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 0xa583
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 0xa597
callq 0x2070
movslq (%rax), %r15
jmp 0xa59a
movq %r12, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x346e
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_O2/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 0xc140
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_O2/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
pushq $0x40
popq %rdi
callq 0x2220
testq %rax, %rax
je 0xa6a8
movq %rax, %r14
movq 0x60(%rbx), %rax
movq (%rax), %rdi
movq %r14, %rsi
callq 0xc16d
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 0x346e
// File: /workspace/github_c_makefile_star2_O2/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 0xc263
movslq (%r14), %rax
movq 0x60(%rbx), %rcx
movq %rax, -0x8(%rcx)
movslq (%r15), %rax
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_O2/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 0xc445
movq (%r14), %rax
movq 0x60(%rbx), %rcx
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_O2/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 0xc492
movq %rax, %rdi
callq 0xc0ba
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 0x30e1
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xc5b0
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 0x30e1
// File: /workspace/github_c_makefile_star2_O2/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 0xc786
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_O2/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 0xb882
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 0x32de