LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/inner.c
// Function: af_task_loop
void af_task_loop(af_global_t* global) {
  pthread_mutex_lock(&global->mutex);
  while(global->first_task) {
    while(global->tasks_active_count) {
      af_task_t* task = global->first_task;
      af_task_t* prev_task = NULL;
      while(task) {
	if(task->is_to_be_freed) {
	  af_task_t* old_task = task;
	  task = task->next_task;
	  if(prev_task) {
	    prev_task->next_task = task;
	  } else {
	    global->first_task = task;
	  }
	  if(global->atomic_task == old_task) {
	    global->atomic_task = NULL;
	  }
	  af_free_task(old_task);
	} else {
	  if(!global->atomic_task || global->atomic_task == task) {
	    pthread_mutex_unlock(&global->mutex);
	    pthread_mutex_lock(&global->mutex);
	    af_inner_loop(global, task);
	  }
	  prev_task = task;
	  task = task->next_task;
	}
      }
      task = global->first_task;
      prev_task = NULL;
      while(task) {
	if(task->is_to_be_freed) {
	  af_task_t* old_task = task;
	  task = task->next_task;
	  if(prev_task) {
	    prev_task->next_task = task;
	  } else {
	    global->first_task = task;
	  }
	  if(global->atomic_task == old_task) {
	    global->atomic_task = NULL;
	  }
	  af_free_task(old_task);
	} else {
	  prev_task = task;
	  task = task->next_task;
	}
      }
    }
    if(global->first_task) {
      pthread_mutex_unlock(&global->mutex);
      af_cond_wait(&global->cond);
      pthread_mutex_lock(&global->mutex);
    }
  }
  pthread_mutex_unlock(&global->mutex);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x80(%rdi), %rbx
movq %rbx, %rdi
callq 0x2310
cmpq $0x0, (%r14)
je 0x2c92
leaq 0x20(%r14), %r15
cmpq $0x0, 0x10(%r14)
je 0x2c70
movq (%r14), %r12
testq %r12, %r12
je 0x2c5f
xorl %r13d, %r13d
cmpq $0x0, 0x48(%r12)
je 0x2bd8
leaq 0x8(%r13), %rax
testq %r13, %r13
cmoveq %r14, %rax
movq 0x8(%r12), %rbp
movq %rbp, (%rax)
cmpq %r12, 0x218(%r14)
jne 0x2bce
movq $0x0, 0x218(%r14)
movq %r12, %rdi
callq 0x2ca8
jmp 0x2c0c
movq 0x218(%r14), %rax
testq %rax, %rax
je 0x2be9
cmpq %r12, %rax
jne 0x2c04
movq %rbx, %rdi
callq 0x2210
movq %rbx, %rdi
callq 0x2310
movq %r14, %rdi
movq %r12, %rsi
callq 0x2d04
movq 0x8(%r12), %rbp
movq %r12, %r13
movq %rbp, %r12
testq %rbp, %rbp
jne 0x2b9f
movq (%r14), %rdi
testq %rdi, %rdi
je 0x2c5f
xorl %r12d, %r12d
cmpq $0x0, 0x48(%rdi)
movq 0x8(%rdi), %r13
je 0x2c54
leaq 0x8(%r12), %rax
testq %r12, %r12
cmoveq %r14, %rax
movq %r13, (%rax)
cmpq %rdi, 0x218(%r14)
jne 0x2c4d
movq $0x0, 0x218(%r14)
callq 0x2ca8
jmp 0x2c57
movq %rdi, %r12
movq %r13, %rdi
testq %r13, %r13
jne 0x2c1f
cmpq $0x0, 0x10(%r14)
jne 0x2b90
cmpq $0x0, (%r14)
je 0x2c92
movq %rbx, %rdi
callq 0x2210
movq %r15, %rdi
callq 0xbc6e
movq %rbx, %rdi
callq 0x2310
cmpq $0x0, (%r14)
jne 0x2b85
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2210
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/inner.c
// Function: af_free_task
void af_free_task(af_task_t* task) {
  if(task->free_data_on_exit) {
    free(task->data_space_base);
  }
  free(task->task_local_space_base);
  free(task->wordlist_order);
  free(task->data_stack_top);
  free(task->float_stack_top);
  free(task->return_stack_top);
  free(task);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x118(%rdi)
je 0x2cc2
movq 0xd8(%rbx), %rdi
callq 0x2050
movq 0x120(%rbx), %rdi
callq 0x2050
movq 0xb0(%rbx), %rdi
callq 0x2050
movq 0x78(%rbx), %rdi
callq 0x2050
movq 0x80(%rbx), %rdi
callq 0x2050
movq 0x88(%rbx), %rdi
callq 0x2050
movq %rbx, %rdi
popq %rbx
jmp 0x2050
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/inner.c
// Function: af_inner_loop
void af_inner_loop(af_global_t* global, af_task_t* task) {
  if(!task->current_cycles_before_yield) {
    return;
  }
  global->current_task = task;
  task->current_cycles_left =
    task->current_cycles_before_yield + task->extra_cycles;
  if(task->current_cycles_left > global->max_cycles_before_yield) {
    task->extra_cycles =
      task->current_cycles_left - global->max_cycles_before_yield;
    task->current_cycles_left = global->max_cycles_before_yield;
    if(task->extra_cycles > global->max_extra_cycles) {
      task->extra_cycles = global->max_extra_cycles;
    }
  }
  if(task->init_word) {
    AF_WORD_EXECUTE(task, task->init_word);
  }
  task->init_word = NULL;
  while(task->current_cycles_left--) {
    af_compiled_t* interpreter_pointer = task->interpreter_pointer;
    af_word_t* word = interpreter_pointer->compiled_call;
    AF_WORD_EXECUTE(task, word);
  }
  task->yields++;
  global->current_task = NULL;
}

// Assembly:
movq 0x20(%rsi), %rax
testq %rax, %rax
je 0x2daf
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, 0x8(%rdi)
addq 0x18(%rsi), %rax
movq %rax, 0x28(%rsi)
movq 0x170(%rdi), %rcx
movq %rax, %rdx
subq %rcx, %rdx
jbe 0x2d51
movq %rdx, 0x18(%r14)
movq %rcx, 0x28(%r14)
movq 0x178(%rbx), %rax
cmpq %rax, %rdx
jbe 0x2d4e
movq %rax, 0x18(%r14)
movq %rcx, %rax
movq 0x50(%r14), %rcx
testq %rcx, %rcx
je 0x2d6a
movq %rcx, 0xf8(%r14)
movq %r14, %rdi
callq *(%rcx)
movq 0x28(%r14), %rax
movq $0x0, 0x50(%r14)
subq $0x1, %rax
movq %rax, 0x28(%r14)
jb 0x2d96
movq 0x58(%r14), %rax
movq (%rax), %rax
movq %rax, 0xf8(%r14)
movq %r14, %rdi
callq *(%rax)
subq $0x1, 0x28(%r14)
jae 0x2d7c
addq $0x1, 0x30(%r14)
adcq $0x0, 0x38(%r14)
movq $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/inner.c
// Function: af_bye
void af_bye(af_global_t* global) {
  af_task_t* task = global->first_task;
  while(task) {
    af_terminate(global, task);
    task = task->next_task;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
testq %r14, %r14
je 0x2de5
movq %rdi, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2ded
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x2dd1
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/inner.c
// Function: af_terminate
void af_terminate(af_global_t* global, af_task_t* task) {
  if(!task->is_to_be_freed) {
    if(task->terminate) {
      if(!task->current_cycles_before_yield) {
	task->current_cycles_before_yield =
	  global->default_cycles_before_yield;
	af_schedule(global, task);
      }
      AF_WORD_EXECUTE(task, task->terminate);
    } else {
      af_kill(global, task);
    }
  }
}

// Assembly:
cmpq $0x0, 0x48(%rsi)
je 0x2df5
retq
movq 0x108(%rsi), %rax
testq %rax, %rax
je 0x315d
cmpq $0x0, 0x20(%rsi)
jne 0x2e1b
movq 0x168(%rdi), %rcx
movq %rcx, 0x20(%rsi)
incq 0x10(%rdi)
movq %rax, 0xf8(%rsi)
movq %rsi, %rdi
jmpq *(%rax)
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/inner.c
// Function: af_kill
void af_kill(af_global_t* global, af_task_t* task) {
  task->current_cycles_before_yield = 0;
  task->current_cycles_left = 0;
  task->is_to_be_freed = TRUE;
  global->task_count--;
  af_deschedule(global, task);
  af_handle_kill(global, task);
}

// Assembly:
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsi)
movq $-0x1, 0x48(%rsi)
movdqu 0x10(%rdi), %xmm0
pcmpeqd %xmm1, %xmm1
paddq %xmm0, %xmm1
movdqu %xmm1, 0x10(%rdi)
movq 0x220(%rdi), %rsi
testq %rsi, %rsi
je 0x3195
cmpq $0x0, 0x48(%rsi)
je 0x32ad
retq
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/inner.c
// Function: af_end_atomic
void af_end_atomic(af_global_t* global, af_task_t* task) {
  af_task_t* next_atomic_task;
  if(task == global->atomic_task) {
    next_atomic_task = af_get_nested_task(global);
    if(next_atomic_task && global->current_task != next_atomic_task) {
      next_atomic_task->nesting_level = -1;
      global->atomic_task = next_atomic_task;
      if(global->current_task) {
	af_yield(global, global->current_task);
      }
      af_wake(global, global->atomic_task);
    } else {
      global->atomic_task = NULL;
    }
  }
}

// Assembly:
cmpq %rsi, 0x218(%rdi)
je 0x3230
retq
pushq %rbx
movq %rdi, %rbx
callq 0x3374
testq %rax, %rax
je 0x3284
movq 0x8(%rbx), %rcx
cmpq %rax, %rcx
je 0x3284
movq $-0x1, 0x130(%rax)
movq %rax, 0x218(%rbx)
testq %rcx, %rcx
je 0x3268
xorl %edx, %edx
movq %rdx, 0x28(%rcx)
movq %rdx, 0x18(%rcx)
cmpq $0x0, 0x20(%rax)
jne 0x328f
cmpq $0x0, 0x48(%rax)
jne 0x328f
movq 0x10(%rax), %rcx
movq %rcx, 0x20(%rax)
incq 0x10(%rbx)
jmp 0x328f
movq $0x0, 0x218(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/inner.c
// Function: af_begin_atomic
void af_begin_atomic(af_global_t* global, af_task_t* task) {
  if(!global->atomic_task) {
    task->nesting_level = -1;
    global->atomic_task = task;
    if(global->current_task != global->atomic_task) {
      if(global->current_task) {
	af_yield(global, global->current_task);
      }
      af_wake(global, global->atomic_task);
    }
  } else if(task->nesting_level < 0 && task != global->atomic_task) {
    af_sign_cell_t level = af_get_nesting_level(global);
    level = level < 0 ? 0 : level + 1;
    task->nesting_level = level;
  }
}

// Assembly:
movq 0x218(%rdi), %rax
testq %rax, %rax
je 0x3305
cmpq %rsi, %rax
je 0x3336
cmpq $0x0, 0x130(%rsi)
jns 0x3336
movq (%rdi), %rcx
movq 0x130(%rcx), %rax
cmpq $0x0, 0x48(%rcx)
jne 0x32e7
movq 0x130(%rcx), %rdx
cmpq %rdx, %rax
cmovleq %rdx, %rax
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
jne 0x32d2
leaq 0x1(%rax), %rcx
xorl %edx, %edx
testq %rax, %rax
cmovnsq %rcx, %rdx
movq %rdx, 0x130(%rsi)
retq
movq $-0x1, 0x130(%rsi)
movq %rsi, 0x218(%rdi)
movq 0x8(%rdi), %rax
cmpq %rsi, %rax
je 0x3336
testq %rax, %rax
je 0x332f
xorl %ecx, %ecx
movq %rcx, 0x28(%rax)
movq %rcx, 0x18(%rax)
cmpq $0x0, 0x20(%rsi)
je 0x3337
retq
cmpq $0x0, 0x48(%rsi)
jne 0x3336
movq 0x10(%rsi), %rax
movq %rax, 0x20(%rsi)
incq 0x10(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/inner.c
// Function: af_get_nesting_level
af_sign_cell_t af_get_nesting_level(af_global_t* global) {
  af_task_t* current_task = global->first_task;
  af_sign_cell_t level = current_task->nesting_level;
  while(current_task) {
    if(!current_task->is_to_be_freed && level < current_task->nesting_level ) {
      level = current_task->nesting_level;
    }
    current_task = current_task->next_task;
  }
  return level;
}

// Assembly:
movq (%rdi), %rcx
movq 0x130(%rcx), %rax
cmpq $0x0, 0x48(%rcx)
jne 0x336a
movq 0x130(%rcx), %rdx
cmpq %rdx, %rax
cmovleq %rdx, %rax
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
jne 0x3355
retq
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/inner.c
// Function: af_get_nested_task
af_task_t* af_get_nested_task(af_global_t* global) {
  af_task_t* current_task = global->first_task;
  af_task_t* nested_task = NULL;
  af_sign_cell_t level = current_task->nesting_level;
  while(current_task) {
    if(!current_task->is_to_be_freed) {
      if(((level > -1) && (current_task->nesting_level < level)) ||
	 ((level < 0) && (current_task->nesting_level > -1))) {
	nested_task = current_task;
	level = current_task->nesting_level;
      }
    }
    current_task = current_task->next_task;
  }
  return nested_task;
}

// Assembly:
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x33b5
movq 0x130(%rcx), %rdx
xorl %eax, %eax
cmpq $0x0, 0x48(%rcx)
jne 0x33a3
movq 0x130(%rcx), %rsi
testq %rdx, %rdx
js 0x33ae
cmpq %rdx, %rsi
jge 0x33a3
movq %rcx, %rax
movq %rsi, %rdx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
jne 0x3385
jmp 0x33b7
testq %rsi, %rsi
jns 0x339d
jmp 0x33a3
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/inner.c
// Function: af_reset
void af_reset(af_global_t* global, af_task_t* task) {
  task->base_cycles_before_yield = global->default_cycles_before_yield;
  task->extra_cycles = 0;
  task->current_cycles_before_yield = global->default_cycles_before_yield;
  task->is_compiling = FALSE;
  task->interpreter_pointer = NULL;
  task->data_stack_current = task->data_stack_base;
  task->float_stack_current = task->float_stack_base;
  task->return_stack_current = task->return_stack_base;
  task->most_recent_word = NULL;
  task->base = 10;
  if(task->abort) {
    AF_WORD_EXECUTE(task, task->abort);
  } else {
    af_kill(global, task);
  }
}

// Assembly:
movq 0x168(%rdi), %rax
movq %rax, 0x10(%rsi)
xorl %ecx, %ecx
movq %rcx, 0x18(%rsi)
movq %rax, 0x20(%rsi)
movq %rcx, 0x40(%rsi)
movq %rcx, 0x58(%rsi)
movaps 0x90(%rsi), %xmm0
movaps %xmm0, 0x60(%rsi)
movq 0xa0(%rsi), %rax
movq %rax, 0x70(%rsi)
movq %rcx, 0xe0(%rsi)
movq $0xa, 0xf0(%rsi)
movq 0x100(%rsi), %rax
testq %rax, %rax
je 0x315d
movq %rax, 0xf8(%rsi)
movq %rsi, %rdi
jmpq *(%rax)
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/inner.c
// Function: af_guarantee
void* af_guarantee(af_global_t* global, af_task_t* task, size_t size) {
  size_t size_remaining = task->data_space_top - task->data_space_current;
  if((size <= size_remaining) &&
     (global->min_guaranteed_data_space_size <= size_remaining ||
      task->free_data_on_exit)) {
    return task->data_space_current;
  } else if(!task->free_data_on_exit) {
    void* new_data_space_base = malloc(global->default_data_space_size);
    task->data_space_base = new_data_space_base;
    task->data_space_current = new_data_space_base;
    task->data_space_top =
      new_data_space_base + global->default_data_space_size;
    return new_data_space_base;
  } else {
    af_handle_data_space_overflow(global, task);
    return NULL;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0xc8(%rsi), %rax
movq 0xd0(%rsi), %rcx
subq %rax, %rcx
cmpq %rdx, %rcx
jae 0x3712
cmpq $0x0, 0x118(%rbx)
je 0x3725
leaq 0xa9ca(%rip), %rdi      # 0xe0c8
callq 0x2090
movq %r14, %rdi
movq %rbx, %rsi
callq 0x33b8
xorl %eax, %eax
jmp 0x374f
cmpq %rcx, 0x158(%r14)
jbe 0x374f
cmpq $0x0, 0x118(%rbx)
jne 0x374f
movq 0x160(%r14), %r14
movq %r14, %rdi
callq 0x2220
movq %rax, 0xd8(%rbx)
movq %rax, 0xc8(%rbx)
movq %rax, %rcx
addq %r14, %rcx
movq %rcx, 0xd0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/inner.c
// Function: af_allocate
void* af_allocate(af_global_t* global, af_task_t* task, size_t size) {
  void* base = af_guarantee(global, task, size);
  if(base) {
    task->data_space_current += size;
  }
  return base;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
callq 0x36cd
testq %rax, %rax
je 0x3772
addq %rbx, 0xc8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/inner.c
// Function: af_allot
void* af_allot(af_global_t* global, af_task_t* task, ssize_t size) {
  ssize_t size_remaining = task->data_space_top - task->data_space_current;
  if(size_remaining >= size) {
    void* current = task->data_space_current;
    task->data_space_current += size;
    return current;
  } else {
    af_handle_data_space_overflow(global, task);
    return NULL;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0xc8(%rsi), %rax
movq 0xd0(%rsi), %rcx
subq %rax, %rcx
cmpq %rdx, %rcx
jge 0x37b5
movq %rdi, %r14
leaq 0xa927(%rip), %rdi      # 0xe0c8
callq 0x2090
movq %r14, %rdi
movq %rbx, %rsi
callq 0x33b8
xorl %eax, %eax
jmp 0x37bf
addq %rax, %rdx
movq %rdx, 0xc8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/inner.c
// Function: af_search_wordlist
af_word_t* af_search_wordlist(af_wordlist_t* wordlist, af_byte_t* name,
			      af_cell_t name_length) {
  af_word_t* current_word = wordlist->first_word;
  while(current_word) {
    af_byte_t current_word_length = AF_WORD_NAME_LEN(current_word);
    if(name_length == current_word_length &&
       !(current_word->flags & AF_WORD_HIDDEN)) {
      af_byte_t* current_name = name;
      af_byte_t* current_word_name = AF_WORD_NAME_DATA(current_word);
      af_byte_t current_name_length = name_length;
      af_bool_t differ = FALSE;
      while(current_name_length--) {
	if(toupper(*current_name++) != toupper(*current_word_name++)) {
	  differ = TRUE;
	  break;
	}
      }
      if(!differ) {
	return current_word;
      }
    }
    current_word = current_word->next_word;
  }
  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x382a
movq %rdx, %r14
movq %rsi, %r15
movq %rdx, %r12
negq %r12
movzbl -0x1(%rbx), %eax
cmpq %r14, %rax
jne 0x3821
testb $0x2, 0x18(%rbx)
jne 0x3821
leaq -0x1(%rbx), %r13
addq %r12, %r13
xorl %ebp, %ebp
cmpb %bpl, %r14b
je 0x382c
callq 0x2030
movq (%rax), %rax
movzbl (%r15,%rbp), %ecx
movl (%rax,%rcx,4), %ecx
movzbl (%r13,%rbp), %edx
incq %rbp
cmpl (%rax,%rdx,4), %ecx
je 0x37fe
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x37e6
xorl %ebx, %ebx
movq %rbx, %rax
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/inner.c
// Function: af_lookup
af_word_t* af_lookup(af_global_t* global, af_task_t* task, af_byte_t* name,
		     af_cell_t name_length) {
  af_wordlist_t** wordlist = task->wordlist_order;
  af_cell_t wordlist_count = task->wordlist_order_count;
  while(wordlist_count--) {
    af_word_t* word = af_search_wordlist(*wordlist++, name, name_length);
    if(word) {
      return word;
    }
  }
  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq 0xb0(%rsi), %r12
movq 0xb8(%rsi), %r13
xorl %ebx, %ebx
xorl %ebp, %ebp
cmpq %rbp, %r13
je 0x3880
movq (%r12,%rbp,8), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x37c7
incq %rbp
testq %rax, %rax
je 0x3861
movq %rax, %rbx
movq %rbx, %rax
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/inner.c
// Function: af_parse_float
af_bool_t af_parse_float(af_global_t* global, af_byte_t* text,
			 size_t length, af_float_t* result) {
  char* buffer;
  char* end_ptr;
  af_float_t value;
  af_bool_t found = FALSE;
  for(af_cell_t i = 0; i < length; i++) {
    if(text[i] == 'e' || text[i] == 'E') {
      found = TRUE;
      if(i == length - 1) {
	length--;
      }
      break;
    }
  }
  if(!found) {
    return FALSE;
  }
  if(!(buffer = malloc(sizeof(af_byte_t) * (length + 1)))) {
    return FALSE;
  }
  memcpy(buffer, (void*)text, length);
  buffer[length] = '\0';
  
  value = strtod(buffer, &end_ptr);
  if(*end_ptr == 0) {
    free(buffer);
    *result = value;
    return TRUE;
  } else {
    free(buffer);
    return FALSE;
  }
}

// Assembly:
testq %rdx, %rdx
je 0x3a87
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
xorl %eax, %eax
xorl %ecx, %ecx
movzbl (%r15,%rcx), %edx
orl $0x20, %edx
cmpl $0x65, %edx
je 0x3a2c
incq %rcx
cmpq %rcx, %r14
jne 0x3a15
jmp 0x3a9a
leaq -0x1(%r14), %rax
cmpq %rcx, %rax
cmoveq %rax, %r14
leaq 0x1(%r14), %rdi
callq 0x2220
testq %rax, %rax
je 0x3a83
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x21f0
movb $0x0, (%r12,%r14)
leaq 0x8(%rsp), %r14
movq %r12, %rdi
movq %r14, %rsi
callq 0x20b0
movsd %xmm0, (%rsp)
movq (%r14), %rax
movb (%rax), %bpl
movq %r12, %rdi
callq 0x2050
testb %bpl, %bpl
je 0x3a8a
xorl %eax, %eax
jmp 0x3a9a
xorl %eax, %eax
retq
movsd (%rsp), %xmm0
movsd %xmm0, (%rbx)
movq $-0x1, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/inner.c
// Function: af_word_available
af_bool_t af_word_available(af_global_t* global, af_task_t* task,
			    af_byte_t delimiter) {
  af_cell_t current_index;
  af_cell_t count;
  af_byte_t* buffer;
  af_byte_t current_char;
  if(!task->current_input) {
    return FALSE;
  }
  current_index = task->current_input->index;
  count = task->current_input->count;
  buffer = task->current_input->buffer;
  current_char = *(buffer + current_index);
  while(current_index < count && current_char == delimiter) {
    current_char = *(buffer + ++current_index);
  }
  if(current_index == count) {
    return FALSE;
  }
  if(!task->current_input->is_closed) {
    while(current_index < count && current_char != delimiter) {
      current_char = *(buffer + ++current_index);
    }
    return current_index < count;
  } else {
    return TRUE;
  }
}

// Assembly:
movq 0xe8(%rsi), %r9
testq %r9, %r9
je 0x3cba
movq 0x18(%r9), %rdi
movq 0x8(%r9), %rcx
movq 0x10(%r9), %rsi
movq %rdi, %r11
movb (%rcx,%rdi), %r10b
incq %rdi
cmpq %rsi, %r11
setb %r8b
jae 0x3cb1
cmpb %dl, %r10b
je 0x3c99
leaq 0x1(%rsi), %rax
cmpq %rdi, %rax
jne 0x3cbd
xorl %eax, %eax
retq
movq $-0x1, %rax
cmpq $0x0, 0x20(%r9)
je 0x3ccc
retq
cmpq %rsi, %r11
setb %al
cmpb %dl, %r10b
setne %r9b
andb %al, %r9b
cmpb $0x1, %r9b
jne 0x3cf7
cmpq %rsi, %rdi
setb %r8b
jae 0x3cf7
leaq 0x1(%rdi), %rax
cmpb %dl, (%rcx,%rdi)
movq %rax, %rdi
jne 0x3ce2
movzbl %r8b, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/inner.c
// Function: af_word
af_byte_t* af_word(af_global_t* global, af_task_t* task, af_byte_t delimiter) {
  af_cell_t current_index;
  af_cell_t count;
  af_byte_t* buffer;
  af_byte_t current_char;
  af_cell_t start_index;
  size_t bytes_copied;
  af_byte_t* here;
  if(!task->current_input) {
    here = (af_byte_t*)af_guarantee(global, task, 1);
    *here = 0;
    return here;
  }
  current_index = task->current_input->index;
  count = task->current_input->count;
  buffer = task->current_input->buffer;
  current_char = *(buffer + current_index);
  while(current_index < count && current_char == delimiter) {
    current_char = *(buffer + ++current_index);
  }
  if(current_index == count) {
    here = (af_byte_t*)af_guarantee(global, task, 1);
    *here = 0;
    return here;
  }
  start_index = current_index;
  while(current_index < count && current_char != delimiter) {
    current_char = *(buffer + ++current_index);
  }
  if(!task->current_input->is_closed && current_index == count) {
    here = (af_byte_t*)af_guarantee(global, task, 1);
    *here = 0;
    return here;
  }
  task->current_input->index = current_index;
  if(current_index - start_index <= 255) {
    bytes_copied = current_index - start_index;
  } else {
    bytes_copied = 255;
  }
  here = (af_byte_t*)af_guarantee(global, task, bytes_copied + 1);
  *here = (af_byte_t)bytes_copied;
  memcpy(here + sizeof(af_byte_t),
	 buffer + (start_index * sizeof(af_byte_t)),
	 sizeof(af_byte_t) * bytes_copied);
  return here;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0xe8(%rsi), %rax
testq %rax, %rax
je 0x3d65
movq 0x18(%rax), %rcx
movq 0x8(%rax), %rbx
movq 0x10(%rax), %r8
decq %rcx
movb 0x1(%rbx,%rcx), %r9b
incq %rcx
cmpq %r8, %rcx
jae 0x3d2e
cmpb %dl, %r9b
je 0x3d1c
cmpq %rcx, %r8
je 0x3d65
movq %rcx, %r14
jbe 0x3d59
movq %rcx, %r14
cmpb %dl, %r9b
je 0x3d59
leaq 0x1(%rcx), %r9
leaq 0x1(%r9), %r14
cmpq %r8, %r9
jae 0x3d56
cmpb %dl, (%rbx,%r9)
movq %r14, %r9
jne 0x3d44
decq %r14
cmpq %r8, %r14
jne 0x3d7e
cmpq $0x0, 0x20(%rax)
jne 0x3d7e
movl $0x1, %edx
callq 0x36cd
movq %rax, %r15
movb $0x0, (%rax)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
addq %rcx, %rbx
movq %r14, 0x18(%rax)
subq %rcx, %r14
movl $0xff, %eax
cmpq %rax, %r14
cmovaeq %rax, %r14
leaq 0x1(%r14), %rdx
callq 0x36cd
movq %rax, %r15
movb %r14b, (%rax)
leaq 0x1(%rax), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x21f0
jmp 0x3d75
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/inner.c
// Function: af_parse_name_available
af_bool_t af_parse_name_available(af_global_t* global, af_task_t* task) {
  af_cell_t current_index;
  af_cell_t count;
  af_byte_t* buffer;
  af_byte_t current_char;
  if(!task->current_input) {
    return FALSE;
  }
  current_index = task->current_input->index;
  count = task->current_input->count;
  buffer = task->current_input->buffer;
  current_char = *(buffer + current_index);
  while(current_index < count &&
	(current_char == ' ' || current_char == '\t' || current_char == '\n')) {
    current_char = *(buffer + ++current_index);
  }
  if(current_index == count) {
    return FALSE;
  }
  if(!task->current_input->is_closed) {
    while(current_index < count &&
	  (current_char != ' ' && current_char != '\t' &&
	   current_char != '\n')) {
      current_char = *(buffer + ++current_index);
    }
    return current_index < count;
  } else {
    return TRUE;
  }
}

// Assembly:
movq 0xe8(%rsi), %r8
testq %r8, %r8
je 0x3e04
movq 0x18(%r8), %rcx
movq 0x8(%r8), %rdx
movq 0x10(%r8), %rsi
movb (%rdx,%rcx), %dil
cmpq %rsi, %rcx
jae 0x3dff
movabsq $0x100000600, %r9       # imm = 0x100000600
xorl %eax, %eax
cmpb $0x20, %dil
ja 0x3dff
movzbl %dil, %r10d
btq %r10, %r9
jae 0x3dff
movb 0x1(%rdx,%rcx), %dil
incq %rcx
cmpq %rcx, %rsi
jne 0x3de1
retq
cmpq %rsi, %rcx
jne 0x3e07
xorl %eax, %eax
retq
movq $-0x1, %rax
cmpq $0x0, 0x20(%r8)
jne 0x3dfe
cmpq %rsi, %rcx
jae 0x3e04
movq %rsi, %rax
negq %rax
incq %rcx
movb $0x1, %r9b
movabsq $0x100000600, %r8       # imm = 0x100000600
cmpb $0x20, %dil
ja 0x3e40
movzbl %dil, %edi
btq %rdi, %r8
jb 0x3e5b
movb (%rdx,%rcx), %dil
cmpq %rsi, %rcx
setb %r9b
leaq (%rax,%rcx), %r10
incq %r10
incq %rcx
cmpq $0x1, %r10
jne 0x3e30
movzbl %r9b, %eax
andl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/inner.c
// Function: af_parse_name
af_byte_t* af_parse_name(af_global_t* global, af_task_t* task,
			 af_cell_t* length) {
  af_cell_t current_index;
  af_cell_t count;
  af_byte_t* buffer;
  af_byte_t current_char;
  af_cell_t start_index;
  size_t bytes_copied;
  if(!task->current_input) {
    *length = 0;
    return NULL;
  }
  current_index = task->current_input->index;
  count = task->current_input->count;
  buffer = task->current_input->buffer;
  current_char = *(buffer + current_index);
  while(current_index < count &&
	(current_char == ' ' || current_char == '\t' || current_char == '\n')) {
    current_char = *(buffer + ++current_index);
  }
  if(current_index == count) {
    *length = 0;
    return NULL;
  }
  start_index = current_index;
  while(current_index < count &&
	(current_char != ' ' && current_char != '\t' && current_char != '\n')) {
    current_char = *(buffer + ++current_index);
  }
  if(!task->current_input->is_closed && current_index == count) {
    *length = 0;
    return NULL;
  }
  task->current_input->index = current_index;
  *length = current_index - start_index;
  return buffer + start_index;
}

// Assembly:
movq 0xe8(%rsi), %rcx
testq %rcx, %rcx
je 0x3f1e
pushq %rbx
movq 0x18(%rcx), %rsi
movq 0x8(%rcx), %r8
movq 0x10(%rcx), %rdi
movb (%r8,%rsi), %r9b
cmpq %rdi, %rsi
jae 0x3eb7
movabsq $0x100000600, %rax      # imm = 0x100000600
xorl %r11d, %r11d
cmpb $0x20, %r9b
ja 0x3eb7
movzbl %r9b, %r10d
btq %r10, %rax
jae 0x3eb7
movb 0x1(%r8,%rsi), %r9b
incq %rsi
cmpq %rsi, %rdi
jne 0x3e96
xorl %eax, %eax
jmp 0x3f1b
leaq (%r8,%rsi), %r10
xorl %r11d, %r11d
movl $0x0, %eax
cmpq %rdi, %rsi
je 0x3f1b
movq %rsi, %rbx
jae 0x3efa
movabsq $0x100000600, %rax      # imm = 0x100000600
movq %rsi, %rbx
cmpb $0x20, %r9b
ja 0x3eea
movzbl %r9b, %r9d
btq %r9, %rax
jb 0x3efa
movb 0x1(%r8,%rbx), %r9b
incq %rbx
cmpq %rbx, %rdi
jne 0x3eda
movq %rdi, %rbx
cmpq %rdi, %rbx
jne 0x3f0e
xorl %r11d, %r11d
cmpq $0x0, 0x20(%rcx)
movl $0x0, %eax
je 0x3f1b
movq %rbx, 0x18(%rcx)
subq %rsi, %rbx
movq %rbx, %r11
movq %r10, %rax
popq %rbx
jmp 0x3f23
xorl %r11d, %r11d
xorl %eax, %eax
movq %r11, (%rdx)
retq
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/inner.c
// Function: af_new_string_input
af_input_t* af_new_string_input(af_global_t* global, af_byte_t* buffer,
				af_cell_t count) {
  af_input_t* input;
  input = malloc(sizeof(af_input_t));
  if(!input) {
    return NULL;
  }
  input->next_input = NULL;
  input->buffer = buffer;
  input->count = count;
  input->index = 0;
  input->is_closed = TRUE;
  input->cleanup = NULL;
  input->refill = NULL;
  input->source_id = -1;
  input->arg = 0;
  return input;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl $0x48, %edi
callq 0x2220
testq %rax, %rax
je 0x3f6b
xorl %ecx, %ecx
movq %rcx, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq %rcx, 0x18(%rax)
movq $-0x1, %rdx
movq %rdx, 0x20(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
movq %rdx, 0x38(%rax)
movq %rcx, 0x40(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/inner.c
// Function: af_register_prim
af_word_t* af_register_prim(af_global_t* global, af_task_t* task,
			    af_byte_t* name, af_prim_t prim,
			    af_cell_t flags, af_wordlist_t* wordlist) {
  void* word_space;
  af_word_t* word;
  af_cell_t name_length;
  size_t data_space_current = (size_t)task->data_space_current;
  size_t name_size;
  size_t pad_size;
  if(name) {
    name_length = strlen(name);
  } else {
    name_length = 0;
  }
  name_size = (name_length + 1) * sizeof(af_byte_t);
  pad_size = ((data_space_current + name_size) % sizeof(af_cell_t)) == 0 ?
    0 * sizeof(af_byte_t) :
    sizeof(af_cell_t) - ((data_space_current + name_size) % sizeof(af_cell_t));
  word_space = af_allocate(global, task,
			   sizeof(af_word_t) + name_size + pad_size);
  word = word_space + name_size + pad_size;
  word->flags = flags;
  AF_WORD_NAME_LEN(word) = (af_byte_t)name_length;
  if(name) {
    memcpy(AF_WORD_NAME_DATA(word), name, name_length);
    word->next_word = wordlist->first_word;
    wordlist->first_word = word;
  } else {
    word->next_word = NULL;
  }
  word->next_of_all_words = global->first_of_all_words;
  global->first_of_all_words = word;
  task->most_recent_word = word;
  word->code = prim;
  word->secondary = NULL;
  return word;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, 0x10(%rsp)
movq %r8, 0x18(%rsp)
movq %rcx, 0x20(%rsp)
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
movq 0xc8(%rsi), %r12
testq %rdx, %rdx
je 0x3fb4
movq %r13, %rdi
callq 0x2120
movq %rax, %rbp
jmp 0x3fb6
xorl %ebp, %ebp
leaq 0x1(%rbp), %rbx
addl %ebx, %r12d
andl $0x7, %r12d
movl $0x8, %eax
subq %r12, %rax
xorl %r15d, %r15d
testl %r12d, %r12d
cmovneq %rax, %r15
leaq 0x29(%rbp,%r15), %r12
movq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x36cd
testq %rax, %rax
je 0x3ff4
addq %r12, 0xc8(%r14)
addq %rbx, %rax
leaq (%rax,%r15), %r12
movq 0x18(%rsp), %rcx
movq %rcx, 0x18(%r15,%rax)
movb %bpl, -0x1(%r15,%rax)
testq %r13, %r13
je 0x4035
leaq (%r15,%rax), %rdi
decq %rdi
movzbl %bpl, %eax
subq %rax, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x21f0
movq 0x10(%rsp), %rcx
movq (%rcx), %rax
movq %r12, (%rcx)
jmp 0x4037
xorl %eax, %eax
movq %rax, 0x8(%r12)
movq 0x8(%rsp), %rcx
movq 0x190(%rcx), %rax
movq %rax, 0x10(%r12)
movq %r12, 0x190(%rcx)
movq %r12, 0xe0(%r14)
movq 0x20(%rsp), %rax
movq %rax, (%r12)
movq $0x0, 0x20(%r12)
movq %r12, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_literal_runtime
void af_prim_literal_runtime(af_task_t* task) {
  af_global_t* global = task->global;
  if(--task->data_stack_current >= task->data_stack_top) {
    *task->data_stack_current =
      (task->interpreter_pointer + 1)->compiled_cell;
    AF_ADVANCE_IP(task, 2);
  } else {
    af_handle_data_stack_overflow(global, task);
  }
}

// Assembly:
movq %rdi, %rsi
movq (%rdi), %rdi
movq 0x60(%rsi), %rax
addq $-0x8, %rax
movq %rax, 0x60(%rsi)
cmpq 0x78(%rsi), %rax
jb 0x3425
movq 0x58(%rsi), %rcx
movq 0x8(%rcx), %rdx
movq %rdx, (%rax)
leaq 0x10(%rcx), %rax
testq %rcx, %rcx
cmoveq %rcx, %rax
movq %rax, 0x58(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_f_literal_runtime
void af_prim_f_literal_runtime(af_task_t* task) {
  af_global_t* global = task->global;
  if(--task->float_stack_current >= task->float_stack_top) {
    *task->float_stack_current =
      *(af_float_t*)(&(task->interpreter_pointer + 1)->compiled_cell);
    AF_ADVANCE_IP(task, 1 + (sizeof(af_float_t) / sizeof(af_compiled_t)));
  } else {
    af_handle_float_stack_overflow(global, task);
  }
}

// Assembly:
movq %rdi, %rsi
movq (%rdi), %rdi
movq 0x68(%rsi), %rax
addq $-0x8, %rax
movq %rax, 0x68(%rsi)
cmpq 0x80(%rsi), %rax
jb 0x344d
movq 0x58(%rsi), %rcx
movsd 0x8(%rcx), %xmm0
movsd %xmm0, (%rax)
leaq 0x10(%rcx), %rax
testq %rcx, %rcx
cmoveq %rcx, %rax
movq %rax, 0x58(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_exit
void af_prim_exit(af_task_t* task) {
  af_global_t* global = task->global;
  if(task->return_stack_current < task->return_stack_base) {
    task->interpreter_pointer = *task->return_stack_current++;
  } else {
    af_handle_return_stack_underflow(global, task);
  }
}

// Assembly:
movq %rdi, %rsi
movq 0x70(%rdi), %rax
cmpq 0xa0(%rdi), %rax
jae 0x6c66
leaq 0x8(%rax), %rcx
movq %rcx, 0x70(%rsi)
movq (%rax), %rax
movq %rax, 0x58(%rsi)
retq
movq (%rsi), %rdi
jmp 0x34ed
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_create
void af_prim_create(af_task_t* task) {
  af_global_t* global = task->global;
  af_byte_t* name;
  af_cell_t name_length;
  size_t data_space_current = (size_t)task->data_space_current;
  size_t name_size;
  size_t pad_size;
  void* word_space;
  af_word_t* word;
  af_compiled_t* secondary;
  if(!af_parse_name_available(global, task)) {
    af_handle_word_expected(global, task);
    return;
  }
  name = af_parse_name(global, task, &name_length);
  name_length = name_length < 256 ? name_length : 255;
  name_size = (name_length + 1) * sizeof(af_byte_t);
  pad_size = ((data_space_current + name_size) % sizeof(af_cell_t)) == 0 ?
    0 * sizeof(af_byte_t) :
    sizeof(af_cell_t) - ((data_space_current + name_size) % sizeof(af_cell_t));
  if(!(word_space = af_allocate(global, task,
				sizeof(af_word_t) + name_size + pad_size))) {
    return;
  }
  word = word_space + name_size + pad_size;
  AF_WORD_NAME_LEN(word) = (af_byte_t)name_length;
  memmove(AF_WORD_NAME_DATA(word), name, name_length);
  word->flags = 0;
  word->code = af_prim_push_data;
  word->secondary = NULL;
  word->next_of_all_words = global->first_of_all_words;
  global->first_of_all_words = word;
  task->most_recent_word = word;
  word->next_word = task->current_wordlist->first_word;
  task->current_wordlist->first_word = word;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movq 0xc8(%rdi), %r13
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3db4
testq %rax, %rax
je 0x6d7f
movq %rsp, %r12
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x3e63
movq (%r12), %rcx
movl $0xff, %edx
cmpq %rdx, %rcx
cmovbq %rcx, %rdx
movq %rax, %r15
movq %rdx, (%r12)
leaq 0x1(%rdx), %r12
addl %r12d, %r13d
andl $0x7, %r13d
movl $0x8, %eax
subq %r13, %rax
xorl %ebp, %ebp
testl %r13d, %r13d
cmovneq %rax, %rbp
addq %rbp, %rdx
addq $0x29, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3757
testq %rax, %rax
je 0x6d70
addq %r12, %rax
leaq (%rax,%rbp), %r12
movq (%rsp), %rcx
movzbl %cl, %ecx
leaq (%rax,%rbp), %r13
decq %r13
movq %r13, %rdi
subq %rcx, %rdi
movb %cl, (%r13)
movq (%rsp), %rdx
movq %r15, %rsi
callq 0x2260
xorps %xmm0, %xmm0
movups %xmm0, 0x19(%r13)
leaq 0x4dab(%rip), %rax      # 0xbada
movq %rax, 0x1(%r13)
movq 0x190(%r14), %rax
movq %rax, 0x11(%r13)
movq %r12, 0x190(%r14)
movq %r12, 0xe0(%rbx)
movq 0xa8(%rbx), %rax
movq (%rax), %rcx
movq %rcx, 0x9(%r13)
movq %r12, (%rax)
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, 0x58(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3515
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_colon
void af_prim_colon(af_task_t* task) {
  af_global_t* global = task->global;
  af_byte_t* name;
  af_cell_t name_length;
  size_t data_space_current = (size_t)task->data_space_current;
  size_t name_size;
  size_t pad_size;
  void* word_space;
  af_word_t* word;
  if(!af_parse_name_available(global, task)) {
    af_handle_word_expected(global, task);
    return;
  }
  name = af_parse_name(global, task, &name_length);
  name_length = name_length < 256 ? name_length : 255;
  name_size = (name_length + 1) * sizeof(af_byte_t);
  pad_size = ((data_space_current + name_size) % sizeof(af_cell_t)) == 0 ?
    0 * sizeof(af_byte_t) :
    sizeof(af_cell_t) - ((data_space_current + name_size) % sizeof(af_cell_t));
  if(!(word_space = af_allocate(global, task,
				sizeof(af_word_t) + name_size + pad_size))) {
    return;
  }
  word = word_space + name_size + pad_size;
  AF_WORD_NAME_LEN(word) = (af_byte_t)name_length;
  memmove(AF_WORD_NAME_DATA(word), name, name_length);
  word->next_word = task->current_wordlist->first_word;
  word->flags = AF_WORD_HIDDEN;
  word->code = af_prim_docol;
  word->secondary = (af_compiled_t*)(word + 1);
  word->next_of_all_words = global->first_of_all_words;
  global->first_of_all_words = word;
  task->most_recent_word = word;
  task->current_wordlist->first_word = word;
  task->is_compiling = TRUE;
  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), %r14
movq 0xc8(%rdi), %rbp
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3db4
testq %rax, %rax
je 0x6faa
leaq 0x8(%rsp), %r12
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x3e63
movq (%r12), %rcx
movl $0xff, %edx
cmpq %rdx, %rcx
cmovbq %rcx, %rdx
movq %rax, 0x10(%rsp)
movq %rdx, (%r12)
leaq 0x1(%rdx), %r15
addl %r15d, %ebp
andl $0x7, %ebp
movl $0x8, %eax
subq %rbp, %rax
xorl %r13d, %r13d
testl %ebp, %ebp
cmovneq %rax, %r13
addq %r13, %rdx
addq $0x29, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3757
testq %rax, %rax
je 0x6f9b
movq %rax, %r12
addq %r15, %r12
leaq (%r12,%r13), %r15
movq 0x8(%rsp), %rax
movzbl %al, %eax
leaq (%r12,%r13), %rbp
decq %rbp
movq %rbp, %rdi
subq %rax, %rdi
movb %al, (%rbp)
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rsi
callq 0x2260
movq 0xa8(%rbx), %rax
movq (%rax), %rcx
movq %rcx, 0x9(%rbp)
movq $0x2, 0x19(%rbp)
leaq 0x4b47(%rip), %rcx      # 0xba9e
movq %rcx, 0x1(%rbp)
leaq 0x28(%r13,%r12), %rcx
movq %rcx, -0x8(%rcx)
movq 0x190(%r14), %rdx
movq %rdx, -0x18(%rcx)
movq %r15, 0x190(%r14)
movq %r15, 0xe0(%rbx)
movq %r15, (%rax)
movq $-0x1, 0x40(%rbx)
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
movq %r14, %rdi
movq %rbx, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3515
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_colon_noname
void af_prim_colon_noname(af_task_t* task) {
  af_global_t* global = task->global;
  void* word_space;
  size_t data_space_current = (size_t)task->data_space_current;
  size_t name_size = sizeof(af_byte_t);
  size_t pad_size;
  af_word_t* word;
  AF_VERIFY_DATA_STACK_EXPAND(task, 1);
  pad_size = ((data_space_current + name_size) % sizeof(af_cell_t)) == 0 ?
    0 * sizeof(af_byte_t) :
    sizeof(af_cell_t) - ((data_space_current + name_size) % sizeof(af_cell_t));
  if(!(word_space = af_allocate(global, task,
				sizeof(af_word_t) + name_size + pad_size))) {
    return;
  }
  word = word_space + name_size + pad_size;;
  word->next_word = NULL;
  word->flags = AF_WORD_HIDDEN;
  word->code = af_prim_docol;
  word->secondary = (af_compiled_t*)(word + 1);
  AF_WORD_NAME_LEN(word) = 0;
  task->most_recent_word = word;
  task->is_compiling = TRUE;
  *(--task->data_stack_current) = (af_cell_t)word;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
movl 0xc8(%rbx), %eax
incl %eax
andl $0x7, %eax
movl $0x8, %ecx
subq %rax, %rcx
xorl %r14d, %r14d
testl %eax, %eax
cmovneq %rcx, %r14
leaq 0x29(%r14), %rdx
movq %rbx, %rsi
callq 0x3757
testq %rax, %rax
je 0x7060
leaq (%rax,%r14), %rcx
incq %rcx
movq $0x0, 0x9(%rax,%r14)
movq $0x2, 0x19(%rax,%r14)
leaq 0x4a84(%rip), %rdx      # 0xba9e
movq %rdx, 0x1(%rax,%r14)
leaq 0x29(%rax,%r14), %rdx
movq %rdx, 0x21(%rax,%r14)
movb $0x0, (%rax,%r14)
movq %rcx, 0xe0(%rbx)
movq $-0x1, 0x40(%rbx)
movq 0x60(%rbx), %rax
leaq -0x8(%rax), %rdx
movq %rdx, 0x60(%rbx)
movq %rcx, -0x8(%rax)
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
movq %rax, 0x58(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_create_noname_at
void af_prim_create_noname_at(af_task_t* task) {
  void* word_space;
  size_t name_size = sizeof(af_byte_t);
  size_t pad_size;
  af_word_t* word;
  AF_VERIFY_DATA_STACK_READ(task, 1);
  word_space = (void*)(*task->data_stack_current);
  pad_size = (((size_t)word_space + name_size) % sizeof(af_cell_t)) == 0 ?
    0 * sizeof(af_byte_t) :
    sizeof(af_cell_t) - (((size_t)word_space + name_size) % sizeof(af_cell_t));
  word = word_space + name_size + pad_size;
  word->next_word = NULL;
  word->flags = 0;
  word->code = af_prim_push_data;
  word->secondary = (af_compiled_t*)(word + 1);
  AF_WORD_NAME_LEN(word) = 0;
  task->most_recent_word = word;
  task->is_compiling = FALSE;
  *task->data_stack_current = (af_cell_t)word;
  AF_ADVANCE_IP(task, 1);  
}

// Assembly:
movq 0x60(%rdi), %rax
movq (%rax), %rax
leaq 0x1(%rax), %rcx
andl $0x7, %ecx
movl $0x8, %edx
subq %rcx, %rdx
testq %rcx, %rcx
cmoveq %rcx, %rdx
leaq (%rax,%rdx), %rcx
incq %rcx
xorl %esi, %esi
movq %rsi, 0x8(%rcx)
movq %rsi, 0x18(%rcx)
leaq 0x4a3d(%rip), %r8       # 0xbada
movq %r8, (%rcx)
leaq 0x29(%rax,%rdx), %rax
movq %rax, -0x8(%rax)
movb $0x0, -0x29(%rax)
movq %rcx, 0xe0(%rdi)
movq %rsi, 0x40(%rdi)
movq 0x60(%rdi), %rax
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_semi
void af_prim_semi(af_task_t* task) {
  af_global_t* global = task->global;
  void* space;
  AF_VERIFY_COMPILING(task);
  if(!(space = af_allot(global, task, sizeof(af_compiled_t) * 2))) {
    return;
  }
  ((af_compiled_t*)space)->compiled_call = global->builtin_exit;
  ((af_compiled_t*)space + 1)->compiled_cell = 0;
  task->most_recent_word->flags &= ~AF_WORD_HIDDEN;
  task->is_compiling = FALSE;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movl $0x10, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x377a
testq %rax, %rax
je 0x7125
movq 0x198(%r14), %rcx
movq %rcx, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq 0xe0(%rbx), %rax
andq $-0x3, 0x18(%rax)
movq %rcx, 0x40(%rbx)
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_O3/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_f_to_s
void af_prim_f_to_s(af_task_t* task) {
  af_float_t value;
  AF_VERIFY_DATA_STACK_EXPAND(task, 1);
  AF_VERIFY_FLOAT_STACK_READ(task, 1);
  value = *task->float_stack_current++;
  if(value > 0.0) {
    value = floor(value);
  } else if(value < 0.0) {
    value = ceil(value);
  }
  *(--task->data_stack_current) = (af_cell_t)value;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x68(%rdi), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x68(%rdi)
movsd (%rax), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x7a04
callq 0x22d0
jmp 0x7a0f
ucomisd %xmm0, %xmm1
jbe 0x7a0f
callq 0x22f0
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x676d(%rip), %xmm0     # 0xe190
cvttsd2si %xmm0, %rdx
andq %rcx, %rdx
orq %rax, %rdx
movq 0x60(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x60(%rbx)
movq %rdx, -0x8(%rax)
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_f_to_d
void af_prim_f_to_d(af_task_t* task) {
  af_float_t value;
  AF_VERIFY_DATA_STACK_EXPAND(task, 2);
  AF_VERIFY_FLOAT_STACK_READ(task, 1);
  value = *task->float_stack_current++;
  if(value > 0.0) {
    value = floor(value);
  } else if(value < 0.0) {
    value = ceil(value);
  }
  task->data_stack_current -= 2;
  AF_STORE_2CELL(task, 0, (af_sign_2cell_t)value);
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x68(%rdi), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x68(%rdi)
movsd (%rax), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x7a7b
callq 0x22d0
jmp 0x7a86
ucomisd %xmm0, %xmm1
jbe 0x7a86
callq 0x22f0
movq 0x60(%rbx), %r14
leaq -0x10(%r14), %rax
movq %rax, 0x60(%rbx)
callq 0xd180
movq %rdx, -0x10(%r14)
movq %rax, -0x8(%r14)
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
movq %rax, 0x58(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_d_div
void af_prim_d_div(af_task_t* task) {
  af_global_t* global = task->global;
  af_sign_2cell_t value0;
  af_sign_2cell_t value1;
  AF_VERIFY_DATA_STACK_READ(task, 4);
  AF_LOAD_SIGN_2CELL(task, 2, value0);
  AF_LOAD_SIGN_2CELL(task, 0, value1);
  if(value1 == 0) {
    af_handle_divide_by_zero(global, task);
    return;
  }
  task->data_stack_current += 2;
  AF_STORE_2CELL(task, 0, value0 / value1);
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %r14
movq (%r14), %rcx
movq 0x8(%r14), %rdx
movq %rdx, %rax
orq %rcx, %rax
je 0x7e5d
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdi
leaq 0x10(%r14), %rax
movq %rax, 0x60(%rbx)
callq 0xd390
movq %rdx, 0x10(%r14)
movq %rax, 0x18(%r14)
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 (%rbx), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x35dd
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_d_u_div
void af_prim_d_u_div(af_task_t* task) {
  af_global_t* global = task->global;
  af_2cell_t value0;
  af_2cell_t value1;
  AF_VERIFY_DATA_STACK_READ(task, 4);
  AF_LOAD_2CELL(task, 2, value0);
  AF_LOAD_2CELL(task, 0, value1);
  if(value1 == 0) {
    af_handle_divide_by_zero(global, task);
    return;
  }
  task->data_stack_current += 2;
  AF_STORE_2CELL(task, 0, value0 / value1);
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %r14
movq (%r14), %rcx
movq 0x8(%r14), %rdx
movq %rdx, %rax
orq %rcx, %rax
je 0x7f25
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdi
leaq 0x10(%r14), %rax
movq %rax, 0x60(%rbx)
callq 0xd6a0
movq %rdx, 0x10(%r14)
movq %rax, 0x18(%r14)
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 (%rbx), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x35dd
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_does_at
void af_prim_does_at(af_task_t* task) {
  AF_VERIFY_WORD_CREATED(task);
  AF_VERIFY_NOT_INTERACTIVE(task);
  task->most_recent_word->code = af_prim_do_does;
  task->most_recent_word->secondary =
    (af_compiled_t*)((task->interpreter_pointer + 1)->compiled_cell);
  AF_ADVANCE_IP(task, 2);
}

// Assembly:
movq 0xe0(%rdi), %rax
leaq 0x3350(%rip), %rcx      # 0xbb1a
movq %rcx, (%rax)
movq 0x58(%rdi), %rcx
movq 0x8(%rcx), %rdx
movq %rdx, 0x20(%rax)
leaq 0x10(%rcx), %rax
testq %rcx, %rcx
cmoveq %rcx, %rax
movq %rax, 0x58(%rdi)
retq