LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x3794
movq %rdi, %r14
leaq 0xa948(%rip), %rdi      # 0xe0c8
callq 0x2090
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3395
xorl %eax, %eax
jmp 0x379e
addq %rax, %rdx
movq %rdx, 0xc8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rdx, %rbx
movq %rsi, %r14
movq (%rdi), %r12
testq %r12, %r12
je 0x381f
movzbl -0x1(%r12), %eax
cmpq %rbx, %rax
jne 0x3812
testb $0x2, 0x18(%r12)
jne 0x3812
leaq -0x1(%r12), %r13
subq %rax, %r13
xorl %r15d, %r15d
movl %r15d, %ebp
cmpb %r15b, %bl
je 0x3805
callq 0x2030
movq (%rax), %rax
movzbl (%r14,%r15), %ecx
movl (%rax,%rcx,4), %ecx
movzbl (%r13,%r15), %edx
incq %r15
cmpl (%rax,%rdx,4), %ecx
je 0x37dd
jmp 0x3809
movq %r12, (%rsp)
cmpb %bpl, %bl
jne 0x3812
xorl %eax, %eax
jmp 0x3819
movq 0x8(%r12), %r12
movb $0x1, %al
testb %al, %al
jne 0x37ba
jmp 0x3827
movq $0x0, (%rsp)
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/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, %rbx
movq %rdx, %r14
movq 0xb0(%rsi), %r12
movq 0xb8(%rsi), %r13
xorl %ebp, %ebp
cmpq %rbp, %r13
je 0x387d
movq (%r12,%rbp,8), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x37a6
incq %rbp
testq %rax, %rax
cmovneq %rax, %r15
je 0x385b
jmp 0x3880
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/inner.c
// Function: af_parse_float
af_bool_t af_parse_float(af_global_t* global, af_byte_t* text,
			 size_t length, af_float_t* result) {
  char* buffer;
  char* end_ptr;
  af_float_t value;
  af_bool_t found = FALSE;
  for(af_cell_t i = 0; i < length; i++) {
    if(text[i] == 'e' || text[i] == 'E') {
      found = TRUE;
      if(i == length - 1) {
	length--;
      }
      break;
    }
  }
  if(!found) {
    return FALSE;
  }
  if(!(buffer = malloc(sizeof(af_byte_t) * (length + 1)))) {
    return FALSE;
  }
  memcpy(buffer, (void*)text, length);
  buffer[length] = '\0';
  
  value = strtod(buffer, &end_ptr);
  if(*end_ptr == 0) {
    free(buffer);
    *result = value;
    return TRUE;
  } else {
    free(buffer);
    return FALSE;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
testq %rdx, %rdx
setne %al
je 0x3a48
movq %r14, %rdx
negq %rdx
movl $0x1, %ecx
movzbl -0x1(%r15,%rcx), %esi
orl $0x20, %esi
cmpl $0x65, %esi
je 0x3a3d
cmpq %r14, %rcx
setb %al
leaq (%rdx,%rcx), %rsi
incq %rsi
incq %rcx
cmpq $0x1, %rsi
jne 0x3a17
jmp 0x3a48
leaq -0x1(%r14), %rdx
cmpq %r14, %rcx
cmoveq %rdx, %r14
testb $0x1, %al
je 0x3a98
leaq 0x1(%r14), %rdi
callq 0x2220
testq %rax, %rax
je 0x3a98
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 0x3aa7
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movsd (%rsp), %xmm0
movsd %xmm0, (%rbx)
movq $-0x1, %rax
jmp 0x3a9a
// File: /workspace/github_c_makefile_star2_O1/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), %r8
testq %r8, %r8
je 0x3cc5
movq 0x18(%r8), %rsi
movq 0x8(%r8), %rcx
movq 0x10(%r8), %rdi
decq %rsi
movb 0x1(%rcx,%rsi), %r9b
incq %rsi
cmpq %rdi, %rsi
jae 0x3cc0
cmpb %dl, %r9b
je 0x3cae
cmpq %rsi, %rdi
jne 0x3cc8
xorl %eax, %eax
retq
movq $-0x1, %rax
cmpq $0x0, 0x20(%r8)
je 0x3cd7
retq
cmpq %rdi, %rsi
setb %al
jae 0x3cfb
cmpb %dl, %r9b
je 0x3cfb
incq %rsi
cmpq %rdi, %rsi
setb %al
jae 0x3cfb
leaq 0x1(%rsi), %r8
cmpb %dl, (%rcx,%rsi)
movq %r8, %rsi
jne 0x3ce7
movzbl %al, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3d68
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 0x3d31
cmpb %dl, %r9b
je 0x3d1f
cmpq %rcx, %r8
je 0x3d68
movq %rcx, %r14
jbe 0x3d5c
movq %rcx, %r14
cmpb %dl, %r9b
je 0x3d5c
leaq 0x1(%rcx), %r9
leaq 0x1(%r9), %r14
cmpq %r8, %r9
jae 0x3d59
cmpb %dl, (%rbx,%r9)
movq %r14, %r9
jne 0x3d47
decq %r14
cmpq %r8, %r14
jne 0x3d81
cmpq $0x0, 0x20(%rax)
jne 0x3d81
movl $0x1, %edx
callq 0x36aa
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 0x36aa
movq %rax, %r15
movb %r14b, (%rax)
leaq 0x1(%rax), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x21f0
jmp 0x3d78
// File: /workspace/github_c_makefile_star2_O1/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 0x3e07
movq 0x18(%r8), %rdx
movq 0x8(%r8), %rcx
movq 0x10(%r8), %rsi
movb (%rcx,%rdx), %dil
cmpq %rsi, %rdx
jae 0x3e02
movabsq $0x100000600, %rax      # imm = 0x100000600
cmpb $0x20, %dil
ja 0x3e02
movzbl %dil, %r9d
btq %r9, %rax
jae 0x3e02
movb 0x1(%rcx,%rdx), %dil
incq %rdx
cmpq %rdx, %rsi
jne 0x3de2
movq %rsi, %rdx
cmpq %rsi, %rdx
jne 0x3e0a
xorl %eax, %eax
retq
movq $-0x1, %rax
cmpq $0x0, 0x20(%r8)
je 0x3e19
retq
cmpq %rsi, %rdx
setb %al
jae 0x3e5e
movq %rsi, %r8
negq %r8
incq %rdx
movabsq $0x100000600, %r9       # imm = 0x100000600
cmpb $0x20, %dil
ja 0x3e44
movzbl %dil, %edi
btq %rdi, %r9
jb 0x3e5e
movb (%rcx,%rdx), %dil
cmpq %rsi, %rdx
setb %al
leaq (%r8,%rdx), %r10
incq %r10
incq %rdx
cmpq $0x1, %r10
jne 0x3e34
movzbl %al, %eax
andl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbx
movq 0xe8(%rsi), %rcx
testq %rcx, %rcx
je 0x3f19
movq 0x18(%rcx), %rsi
movq 0x8(%rcx), %r8
movq 0x10(%rcx), %rdi
movb (%r8,%rsi), %r9b
cmpq %rdi, %rsi
jae 0x3eb5
movabsq $0x100000600, %rax      # imm = 0x100000600
cmpb $0x20, %r9b
ja 0x3eb5
movzbl %r9b, %r10d
btq %r10, %rax
jae 0x3eb5
movb 0x1(%r8,%rsi), %r9b
incq %rsi
cmpq %rsi, %rdi
jne 0x3e95
movq %rdi, %rsi
leaq (%r8,%rsi), %r10
xorl %ebx, %ebx
movl $0x0, %eax
cmpq %rdi, %rsi
je 0x3f1d
movq %rsi, %r11
jae 0x3ef7
movabsq $0x100000600, %rax      # imm = 0x100000600
movq %rsi, %r11
cmpb $0x20, %r9b
ja 0x3ee7
movzbl %r9b, %r9d
btq %r9, %rax
jb 0x3ef7
movb 0x1(%r8,%r11), %r9b
incq %r11
cmpq %r11, %rdi
jne 0x3ed7
movq %rdi, %r11
cmpq %rdi, %r11
jne 0x3f0a
xorl %ebx, %ebx
cmpq $0x0, 0x20(%rcx)
movl $0x0, %eax
je 0x3f1d
movq %r11, 0x18(%rcx)
subq %rsi, %r11
movq %r11, %rbx
movq %r10, %rax
jmp 0x3f1d
xorl %ebx, %ebx
xorl %eax, %eax
movq %rbx, (%rdx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3f68
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)
jmp 0x3f6a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3fb3
movq %r13, %rdi
callq 0x2120
movq %rax, %rbp
jmp 0x3fb5
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 0x36aa
testq %rax, %rax
je 0x3ff3
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 0x4039
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 %rax, 0x8(%r12)
movq %r12, (%rcx)
jmp 0x4042
movq $0x0, 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
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x3402
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_O1/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 0x342a
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_O1/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 0x6c6e
leaq 0x8(%rax), %rcx
movq %rcx, 0x70(%rsi)
movq (%rax), %rax
movq %rax, 0x58(%rsi)
retq
movq (%rsi), %rdi
jmp 0x34ca
// File: /workspace/github_c_makefile_star2_O1/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 0x3db7
testq %rax, %rax
je 0x6d87
movq %rsp, %r12
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x3e65
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 0x3736
testq %rax, %rax
je 0x6d78
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 0x4f25(%rip), %rax      # 0xbc5c
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 0x34f2
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_create_with_name
void af_prim_create_with_name(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;
  AF_VERIFY_DATA_STACK_READ(task, 2);
  name_length = *task->data_stack_current++;
  name = (af_byte_t*)(*task->data_stack_current++);
  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 0x60(%rdi), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x60(%rdi)
movq (%rax), %r15
leaq 0x10(%rax), %rcx
movq %rcx, 0x60(%rdi)
movq 0x8(%rax), %r12
leaq 0x1(%r15), %r13
movl 0xc8(%rdi), %eax
addl %r13d, %eax
andl $0x7, %eax
movl $0x8, %ecx
subq %rax, %rcx
xorl %ebp, %ebp
testl %eax, %eax
cmovneq %rcx, %rbp
leaq (%r15,%rbp), %rdx
addq $0x29, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3736
testq %rax, %rax
je 0x6e79
addq %r13, %rax
leaq (%rax,%rbp), %r13
addq %rax, %rbp
decq %rbp
movb %r15b, (%rbp)
movzbl %r15b, %eax
movq %rbp, %rdi
subq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x2260
xorps %xmm0, %xmm0
movups %xmm0, 0x19(%rbp)
leaq 0x4e24(%rip), %rax      # 0xbc5c
movq %rax, 0x1(%rbp)
movq 0x190(%r14), %rax
movq %rax, 0x11(%rbp)
movq %r13, 0x190(%r14)
movq %r13, 0xe0(%rbx)
movq 0xa8(%rbx), %rax
movq (%rax), %rcx
movq %rcx, 0x9(%rbp)
movq %r13, (%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
// File: /workspace/github_c_makefile_star2_O1/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 0x3db7
testq %rax, %rax
je 0x6fba
leaq 0x8(%rsp), %r12
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x3e65
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 0x3736
testq %rax, %rax
je 0x6fab
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 0x4cb9(%rip), %rcx      # 0xbc20
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 0x34f2
// File: /workspace/github_c_makefile_star2_O1/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 0x3736
testq %rax, %rax
je 0x7070
leaq (%rax,%r14), %rcx
incq %rcx
movq $0x0, 0x9(%rax,%r14)
movq $0x2, 0x19(%rax,%r14)
leaq 0x4bf6(%rip), %rdx      # 0xbc20
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_O1/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 0x4baf(%rip), %r8       # 0xbc5c
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_O1/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 0x3759
testq %rax, %rax
je 0x7135
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_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_is_immediate
void af_prim_is_immediate(af_task_t* task) {
  AF_VERIFY_DATA_STACK_READ(task, 1);
  *task->data_stack_current =
    (af_cell_t)(((af_word_t*)
		 (*task->data_stack_current))->flags
		& AF_WORD_IMMEDIATE ? TRUE : FALSE);
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
movq 0x60(%rdi), %rax
movq (%rax), %rcx
movq 0x18(%rcx), %rcx
andl $0x1, %ecx
negq %rcx
movq %rcx, (%rax)
movq 0x58(%rdi), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, 0x58(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_is_hidden
void af_prim_is_hidden(af_task_t* task) {
  AF_VERIFY_DATA_STACK_READ(task, 1);
  *task->data_stack_current =
    (af_cell_t)(((af_word_t*)
		 (*task->data_stack_current))->flags
		& AF_WORD_HIDDEN ? TRUE : FALSE);
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
movq 0x60(%rdi), %rax
movq (%rax), %rcx
movq 0x18(%rcx), %rcx
shlq $0x3e, %rcx
sarq $0x3f, %rcx
movq %rcx, (%rax)
movq 0x58(%rdi), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, 0x58(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_is_compile_only
void af_prim_is_compile_only(af_task_t* task) {
  AF_VERIFY_DATA_STACK_READ(task, 1);
  *task->data_stack_current =
    (af_cell_t)(((af_word_t*)
		 (*task->data_stack_current))->flags
		& AF_WORD_COMPILE_ONLY ? TRUE : FALSE);
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
movq 0x60(%rdi), %rax
movq (%rax), %rcx
movq 0x18(%rcx), %rcx
shlq $0x3d, %rcx
sarq $0x3f, %rcx
movq %rcx, (%rax)
movq 0x58(%rdi), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, 0x58(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_is_smart
void af_prim_is_smart(af_task_t* task) {
  AF_VERIFY_DATA_STACK_READ(task, 1);
  *task->data_stack_current =
    (af_cell_t)(((af_word_t*)
		 (*task->data_stack_current))->flags
		& AF_WORD_SMART ? TRUE : FALSE);
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
movq 0x60(%rdi), %rax
movq (%rax), %rcx
movq 0x18(%rcx), %rcx
shlq $0x3c, %rcx
sarq $0x3f, %rcx
movq %rcx, (%rax)
movq 0x58(%rdi), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, 0x58(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_swap
void af_prim_swap(af_task_t* task) {
  af_cell_t value;
  AF_VERIFY_DATA_STACK_READ(task, 2);
  value = *task->data_stack_current;
  *task->data_stack_current = *(task->data_stack_current + 1);
  *(task->data_stack_current + 1) = value;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
movq 0x60(%rdi), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rdx
movq %rdx, (%rax)
movq %rcx, 0x8(%rax)
movq 0x58(%rdi), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, 0x58(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_rot
void af_prim_rot(af_task_t* task) {
  af_cell_t value;
  AF_VERIFY_DATA_STACK_READ(task, 3);
  value = *(task->data_stack_current + 2);
  *(task->data_stack_current + 2) = *(task->data_stack_current + 1);
  *(task->data_stack_current + 1) = *task->data_stack_current;
  *task->data_stack_current = value;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
movq 0x60(%rdi), %rax
movq 0x10(%rax), %rcx
movq (%rax), %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x10(%rax)
movq %rdx, 0x8(%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_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_roll
void af_prim_roll(af_task_t* task) {
  af_cell_t index;
  af_cell_t value;
  AF_VERIFY_DATA_STACK_READ(task, 1);
  index = *task->data_stack_current++;
  AF_VERIFY_DATA_STACK_READ(task, index + 1);
  value = *(task->data_stack_current + index);
  while(index > 0) {
    *(task->data_stack_current + index) =
      *(task->data_stack_current + (index - 1));
    index--;
  }
  *task->data_stack_current = value;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
leaq 0x8(%rdi), %r14
movq %r14, 0x60(%rbx)
movq (%rdi), %rdx
movq 0x8(%rdi,%rdx,8), %r15
testq %rdx, %rdx
je 0x7353
addq $0x10, %rdi
shlq $0x3, %rdx
movq %r14, %rsi
callq 0x2260
movq %r15, (%r14)
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
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_add
void af_prim_add(af_task_t* task) {
  af_sign_cell_t value0;
  af_sign_cell_t value1;
  AF_VERIFY_DATA_STACK_READ(task, 2);
  value0 = *((af_sign_cell_t*)task->data_stack_current + 1);
  value1 = *(af_sign_cell_t*)task->data_stack_current;
  *(++task->data_stack_current) = (af_cell_t)(value0 + value1);
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
movq 0x60(%rdi), %rax
leaq 0x8(%rax), %rcx
movq (%rax), %rdx
addq 0x8(%rax), %rdx
movq %rcx, 0x60(%rdi)
movq %rdx, 0x8(%rax)
movq 0x58(%rdi), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, 0x58(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_div
void af_prim_div(af_task_t* task) {
  af_global_t* global = task->global;
  af_sign_cell_t value0;
  af_sign_cell_t value1;
  AF_VERIFY_DATA_STACK_READ(task, 2);
  value0 = *((af_sign_cell_t*)task->data_stack_current + 1);
  value1 = *(af_sign_cell_t*)task->data_stack_current;
  if(value1 == 0) {
    af_handle_divide_by_zero(global, task);
    return;
  }
  *(++task->data_stack_current) = (af_cell_t)(value0 / value1);
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
movq %rdi, %rsi
movq 0x60(%rdi), %rcx
movq (%rcx), %rdi
testq %rdi, %rdi
je 0x7429
leaq 0x8(%rcx), %r8
movq 0x8(%rcx), %rax
cqto
idivq %rdi
movq %r8, 0x60(%rsi)
movq %rax, 0x8(%rcx)
movq 0x58(%rsi), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
movq %rax, 0x58(%rsi)
retq
movq (%rsi), %rdi
jmp 0x35ba
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_u_div
void af_prim_u_div(af_task_t* task) {
  af_global_t* global = task->global;
  af_cell_t value0;
  af_cell_t value1;
  AF_VERIFY_DATA_STACK_READ(task, 2);
  value0 = *(task->data_stack_current + 1);
  value1 = *task->data_stack_current;
  if(value1 == 0) {
    af_handle_divide_by_zero(global, task);
    return;
  }
  *(++task->data_stack_current) = (af_cell_t)(value0 / value1);
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
movq %rdi, %rsi
movq 0x60(%rdi), %rcx
movq (%rcx), %rdi
testq %rdi, %rdi
je 0x74a9
leaq 0x8(%rcx), %r8
movq 0x8(%rcx), %rax
xorl %edx, %edx
divq %rdi
movq %r8, 0x60(%rsi)
movq %rax, 0x8(%rcx)
movq 0x58(%rsi), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
movq %rax, 0x58(%rsi)
retq
movq (%rsi), %rdi
jmp 0x35ba
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_and
void af_prim_and(af_task_t* task) {
  af_cell_t value0;
  af_cell_t value1;
  AF_VERIFY_DATA_STACK_READ(task, 2);
  value0 = *(task->data_stack_current + 1);
  value1 = *task->data_stack_current;
  *(++task->data_stack_current) = value0 & value1;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
movq 0x60(%rdi), %rax
leaq 0x8(%rax), %rcx
movq (%rax), %rdx
andq 0x8(%rax), %rdx
movq %rcx, 0x60(%rdi)
movq %rdx, 0x8(%rax)
movq 0x58(%rdi), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, 0x58(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_lshift
void af_prim_lshift(af_task_t* task) {
  af_cell_t value0;
  af_cell_t value1;
  AF_VERIFY_DATA_STACK_READ(task, 2);
  value0 = *(task->data_stack_current + 1);
  value1 = *task->data_stack_current;
  *(++task->data_stack_current) = value0 << value1;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
movq 0x60(%rdi), %rax
leaq 0x8(%rax), %rdx
movq 0x8(%rax), %rsi
movb (%rax), %cl
shlq %cl, %rsi
movq %rdx, 0x60(%rdi)
movq %rsi, 0x8(%rax)
movq 0x58(%rdi), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, 0x58(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_u_lte
void af_prim_u_lte(af_task_t* task) {
  af_cell_t value0;
  af_cell_t value1;
  AF_VERIFY_DATA_STACK_READ(task, 2);
  value0 = *(task->data_stack_current + 1);
  value1 = *task->data_stack_current;
  *(++task->data_stack_current) = (af_cell_t)(value0 <= value1 ? -1 : 0);
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
movq 0x60(%rdi), %rax
leaq 0x8(%rax), %rcx
movq (%rax), %rdx
xorl %esi, %esi
cmpq 0x8(%rax), %rdx
adcq $-0x1, %rsi
movq %rcx, 0x60(%rdi)
movq %rsi, 0x8(%rax)
movq 0x58(%rdi), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, 0x58(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_f_swap
void af_prim_f_swap(af_task_t* task) {
  af_float_t value;
  AF_VERIFY_FLOAT_STACK_READ(task, 2);
  value = *task->float_stack_current;
  *task->float_stack_current = *(task->float_stack_current + 1);
  *(task->float_stack_current + 1) = value;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
movq 0x68(%rdi), %rax
movsd (%rax), %xmm0
movsd 0x8(%rax), %xmm1
movsd %xmm1, (%rax)
movsd %xmm0, 0x8(%rax)
movq 0x58(%rdi), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, 0x58(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_f_rot
void af_prim_f_rot(af_task_t* task) {
  af_float_t value;
  AF_VERIFY_FLOAT_STACK_READ(task, 3);
  value = *(task->float_stack_current + 2);
  *(task->float_stack_current + 2) = *(task->float_stack_current + 1);
  *(task->float_stack_current + 1) = *task->float_stack_current;
  *task->float_stack_current = value;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
movq 0x68(%rdi), %rax
movsd 0x10(%rax), %xmm0
movsd (%rax), %xmm1
movsd 0x8(%rax), %xmm2
movsd %xmm2, 0x10(%rax)
movsd %xmm1, 0x8(%rax)
movsd %xmm0, (%rax)
movq 0x58(%rdi), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, 0x58(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_f_pick
void af_prim_f_pick(af_task_t* task) {
  af_cell_t index;
  af_float_t value;
  AF_VERIFY_DATA_STACK_READ(task, 1);
  index = *task->data_stack_current++;
  AF_VERIFY_FLOAT_STACK_READ(task, index + 1);
  value = *(task->float_stack_current + index);
  *(--task->float_stack_current) = value;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
movq 0x60(%rdi), %rax
movq 0x68(%rdi), %rcx
leaq 0x8(%rax), %rdx
movq %rdx, 0x60(%rdi)
movq (%rax), %rax
movsd (%rcx,%rax,8), %xmm0
leaq -0x8(%rcx), %rax
movq %rax, 0x68(%rdi)
movsd %xmm0, -0x8(%rcx)
movq 0x58(%rdi), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
movq %rax, 0x58(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_f_roll
void af_prim_f_roll(af_task_t* task) {
  af_cell_t index;
  af_float_t value;
  AF_VERIFY_DATA_STACK_READ(task, 1);
  index = *task->data_stack_current++;
  AF_VERIFY_FLOAT_STACK_READ(task, index + 1);
  value = *(task->float_stack_current + index);
  while(index > 0) {
    *(task->float_stack_current + index) =
      *(task->float_stack_current + (index - 1));
    index--;
  }
  *task->float_stack_current = value;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %rax
movq 0x68(%rdi), %r14
leaq 0x8(%rax), %rcx
movq %rcx, 0x60(%rdi)
movq (%rax), %rdx
movsd (%r14,%rdx,8), %xmm0
testq %rdx, %rdx
je 0x7950
leaq 0x8(%r14), %rdi
shlq $0x3, %rdx
movq %r14, %rsi
movsd %xmm0, (%rsp)
callq 0x2260
movsd (%rsp), %xmm0
movsd %xmm0, (%r14)
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_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_d_to_f
void af_prim_d_to_f(af_task_t* task) {
  af_sign_2cell_t value;
  AF_VERIFY_DATA_STACK_READ(task, 2);
  AF_VERIFY_FLOAT_STACK_EXPAND(task, 1);
  AF_LOAD_SIGN_2CELL(task, 0, value);
  task->data_stack_current += 2;
  *(--task->float_stack_current) = (af_float_t)value;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %rax
movq 0x68(%rdi), %r14
movq (%rax), %rsi
movq 0x8(%rax), %rdi
addq $0x10, %rax
movq %rax, 0x60(%rbx)
callq 0xd430
leaq -0x8(%r14), %rax
movq %rax, 0x68(%rbx)
movsd %xmm0, -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_O1/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 0x7a31
callq 0x22d0
jmp 0x7a3c
ucomisd %xmm0, %xmm1
jbe 0x7a3c
callq 0x22f0
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x6740(%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_O1/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 0x7aa8
callq 0x22d0
jmp 0x7ab3
ucomisd %xmm0, %xmm1
jbe 0x7ab3
callq 0x22f0
movq 0x60(%rbx), %r14
leaq -0x10(%r14), %rax
movq %rax, 0x60(%rbx)
callq 0xd350
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_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_f_mod
void af_prim_f_mod(af_task_t* task) {
  af_float_t value0;
  af_float_t value1;
  AF_VERIFY_FLOAT_STACK_READ(task, 2);
  value0 = *(task->float_stack_current + 1);
  value1 = *task->float_stack_current;
  *(++task->float_stack_current) = fmod(value0, value1);
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x68(%rdi), %rax
movsd (%rax), %xmm1
movsd 0x8(%rax), %xmm0
callq 0x21a0
movq 0x68(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x68(%rbx)
movsd %xmm0, 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_O1/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_f_pow
void af_prim_f_pow(af_task_t* task) {
  af_float_t value0;
  af_float_t value1;
  AF_VERIFY_FLOAT_STACK_READ(task, 2);
  value0 = *(task->float_stack_current + 1);
  value1 = *task->float_stack_current;
  *(++task->float_stack_current) = pow(value0, value1);
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x68(%rdi), %rax
movsd (%rax), %xmm1
movsd 0x8(%rax), %xmm0
callq 0x2110
movq 0x68(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x68(%rbx)
movsd %xmm0, 0x8(%rax)
movq 0x58(%rbx), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
movq %rax, 0x58(%rbx)
popq %rbx
retq