LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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, %r15
movq %rdi, %r14
movq %rdx, %r12
negq %r12
movq (%r14), %r14
testq %r14, %r14
je 0x36b4
movzbl -0x1(%r14), %eax
cmpq %rbx, %rax
jne 0x36ae
testb $0x2, 0x18(%r14)
jne 0x36ae
leaq -0x1(%r14), %r13
addq %r12, %r13
xorl %ebp, %ebp
cmpb %bpl, %bl
je 0x36b4
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 0x368b
addq $0x8, %r14
jmp 0x3669
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tabemann[P]attoforth/src/runtime/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 0x3708
movq (%r12,%rbp,8), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x364f
incq %rbp
testq %rax, %rax
je 0x36e9
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_O2/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
xorl %eax, %eax
xorl %ecx, %ecx
cmpq %rcx, %r14
je 0x3921
movzbl (%r15,%rcx), %edx
orl $0x20, %edx
cmpl $0x65, %edx
je 0x38ba
incq %rcx
jmp 0x38a3
leaq -0x1(%r14), %rax
cmpq %rcx, %rax
cmoveq %rax, %r14
leaq 0x1(%r14), %rdi
callq 0x2220
testq %rax, %rax
je 0x3911
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 0x3915
xorl %eax, %eax
jmp 0x3921
movsd (%rsp), %xmm0
movsd %xmm0, (%rbx)
pushq $-0x1
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3b5b
movq 0x18(%r8), %rcx
movq 0x8(%r8), %rax
movq 0x10(%r8), %rsi
decq %rcx
movb 0x1(%rax,%rcx), %dil
incq %rcx
cmpq %rsi, %rcx
jae 0x3b56
cmpb %dl, %dil
je 0x3b44
cmpq %rcx, %rsi
jne 0x3b5e
xorl %eax, %eax
retq
cmpq $0x0, 0x20(%r8)
je 0x3b76
pushq $-0x1
popq %rax
retq
cmpb %dl, %dil
je 0x3b7b
movb 0x1(%rax,%rcx), %dil
incq %rcx
cmpq %rsi, %rcx
jb 0x3b69
xorl %eax, %eax
cmpq %rsi, %rcx
setb %al
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3bee
movq 0x18(%rax), %rcx
movq 0x8(%rax), %r8
movq 0x10(%rax), %r9
movq %rcx, %r11
movb (%r8,%rcx), %r10b
incq %rcx
cmpq %r9, %r11
jae 0x3bb5
cmpb %dl, %r10b
je 0x3ba1
leaq 0x1(%r9), %r11
cmpq %rcx, %r11
je 0x3bee
leaq (%r8,%rcx), %rbx
decq %rbx
xorl %r14d, %r14d
leaq -0x1(%rcx), %r15
cmpq %r9, %r15
jae 0x3be2
cmpb %dl, %r10b
je 0x3be2
movb (%r8,%rcx), %r10b
incq %rcx
decq %r14
jmp 0x3bc8
cmpq %rcx, %r11
jne 0x3c05
cmpq $0x0, 0x20(%rax)
jne 0x3c05
pushq $0x1
popq %rdx
callq 0x3586
movq %rax, %r15
movb $0x0, (%rax)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %r15, 0x18(%rax)
negq %r14
movl $0xff, %eax
cmpq %rax, %r14
cmovaeq %rax, %r14
leaq 0x1(%r14), %rdx
callq 0x3586
movq %rax, %r15
movb %r14b, (%rax)
leaq 0x1(%rax), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x21f0
jmp 0x3bfc
// File: /workspace/github_c_makefile_star2_O2/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 0x3c8d
movq 0x18(%r8), %rcx
movq 0x8(%r8), %rax
movq 0x10(%r8), %rdx
cmpq %rdx, %rcx
movq %rdx, %r9
cmovaq %rcx, %r9
movabsq $0x100000600, %rsi      # imm = 0x100000600
movb (%rax,%rcx), %dil
cmpq %rdx, %rcx
jae 0x3c85
movzbl %dil, %r10d
cmpl $0x20, %r10d
ja 0x3c88
movl %r10d, %r10d
btq %r10, %rsi
jae 0x3c88
incq %rcx
jmp 0x3c64
movq %r9, %rcx
cmpq %rdx, %rcx
jne 0x3c90
xorl %eax, %eax
retq
cmpq $0x0, 0x20(%r8)
je 0x3ca3
pushq $-0x1
popq %rax
retq
movb 0x1(%rax,%rcx), %dil
incq %rcx
cmpq %rdx, %rcx
jae 0x3cb8
cmpb $0x20, %dil
ja 0x3c9b
movzbl %dil, %edi
btq %rdi, %rsi
jae 0x3c9b
xorl %eax, %eax
cmpq %rdx, %rcx
setb %al
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
movq 0xe8(%rsi), %rcx
testq %rcx, %rcx
je 0x3d4e
movq 0x18(%rcx), %rsi
movq 0x8(%rcx), %r8
movq 0x10(%rcx), %rdi
cmpq %rdi, %rsi
movq %rdi, %rax
cmovaq %rsi, %rax
movabsq $0x100000600, %r9       # imm = 0x100000600
movb (%r8,%rsi), %r11b
cmpq %rdi, %rsi
jae 0x3d11
movzbl %r11b, %r10d
cmpl $0x20, %r10d
ja 0x3d14
movl %r10d, %r10d
btq %r10, %r9
jae 0x3d14
incq %rsi
jmp 0x3cf0
movq %rax, %rsi
leaq (%r8,%rsi), %r10
xorl %r14d, %r14d
movl $0x0, %eax
cmpq %rdi, %rsi
je 0x3d79
movq %rdi, %rax
cmovaq %rsi, %rax
movq %rsi, %rbx
cmpq %rdi, %rbx
jae 0x3d55
cmpb $0x20, %r11b
ja 0x3d44
movzbl %r11b, %r11d
btq %r11, %r9
jb 0x3d58
movb 0x1(%r8,%rbx), %r11b
incq %rbx
jmp 0x3d2f
xorl %r14d, %r14d
xorl %eax, %eax
jmp 0x3d79
movq %rax, %rbx
cmpq %rdi, %rbx
jne 0x3d6c
xorl %r14d, %r14d
cmpq $0x0, 0x20(%rcx)
movl $0x0, %eax
je 0x3d79
movq %rbx, 0x18(%rcx)
subq %rsi, %rbx
movq %rbx, %r14
movq %r10, %rax
movq %r14, (%rdx)
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x48
popq %rdi
callq 0x2220
testq %rax, %rax
je 0x3dbe
andq $0x0, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
andq $0x0, 0x18(%rax)
orq $-0x1, 0x20(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
orq $-0x1, 0x38(%rax)
andq $0x0, 0x40(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x8(%rsp)
movq %r8, 0x10(%rsp)
movq %rcx, 0x20(%rsp)
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %r15
movq 0xc8(%rsi), %rbx
testq %rdx, %rdx
je 0x3e05
movq %r13, %rdi
callq 0x2120
movq %rax, %rbp
jmp 0x3e07
xorl %ebp, %ebp
leaq 0x1(%rbp), %rax
addl %ebx, %eax
andl $0x7, %eax
pushq $0x8
popq %r14
subq %rax, %r14
xorl %ebx, %ebx
testl %eax, %eax
cmoveq %rbx, %r14
leaq 0x29(%rbp,%r14), %rdx
movq %r15, %rdi
movq %r12, 0x18(%rsp)
movq %r12, %rsi
callq 0x35fe
addq %rbp, %rax
incq %rax
leaq (%rax,%r14), %r12
movq 0x10(%rsp), %rcx
movq %rcx, 0x18(%r14,%rax)
movb %bpl, -0x1(%r14,%rax)
testq %r13, %r13
je 0x3e76
leaq (%r14,%rax), %rdi
decq %rdi
movzbl %bpl, %eax
subq %rax, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x21f0
movq 0x8(%rsp), %rax
movq (%rax), %rbx
movq %r12, (%rax)
movq %rbx, 0x8(%r12)
movq 0x190(%r15), %rax
movq %rax, 0x10(%r12)
movq %r12, 0x190(%r15)
movq 0x18(%rsp), %rax
movq %r12, 0xe0(%rax)
movq 0x20(%rsp), %rax
movq %rax, (%r12)
andq $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_O2/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 0x3306
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_O2/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 0x6a9a
leaq 0x8(%rax), %rcx
movq %rcx, 0x70(%rsi)
movq (%rax), %rax
movq %rax, 0x58(%rsi)
retq
movq (%rsi), %rdi
jmp 0x33a6
// File: /workspace/github_c_makefile_star2_O2/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 0x3c38
testq %rax, %rax
je 0x6bb1
movq %rsp, %r12
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x3cc1
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
pushq $0x8
popq %rax
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 0x35fe
testq %rax, %rax
je 0x6ba2
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 0x4ce9(%rip), %rax      # 0xb84a
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 0x33ce
// File: /workspace/github_c_makefile_star2_O2/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
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
pushq $0x8
popq %rcx
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 0x35fe
testq %rax, %rax
je 0x6c99
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 0x4bf2(%rip), %rax      # 0xb84a
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_O2/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 0x3c38
testq %rax, %rax
je 0x6dd5
leaq 0x8(%rsp), %r12
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x3cc1
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
pushq $0x8
popq %rax
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 0x35fe
testq %rax, %rax
je 0x6dc6
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 0x4a89(%rip), %rcx      # 0xb80e
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)
orq $-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 0x33ce
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x8
popq %rcx
subq %rax, %rcx
xorl %r14d, %r14d
testl %eax, %eax
cmovneq %rcx, %r14
leaq 0x29(%r14), %rdx
movq %rbx, %rsi
callq 0x35fe
testq %rax, %rax
je 0x6e83
andq $0x0, 0x9(%rax,%r14)
leaq (%rax,%r14), %rcx
incq %rcx
movq $0x2, 0x19(%rax,%r14)
leaq 0x49ce(%rip), %rdx      # 0xb80e
movq %rdx, 0x1(%rax,%r14)
leaq 0x29(%rax,%r14), %rdx
movq %rdx, 0x21(%rax,%r14)
movb $0x0, (%rax,%r14)
movq %rcx, 0xe0(%rbx)
orq $-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_O2/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
pushq $0x8
popq %rdx
subq %rcx, %rdx
testq %rcx, %rcx
cmoveq %rcx, %rdx
leaq (%rax,%rdx), %rcx
incq %rcx
andq $0x0, 0x8(%rcx)
andq $0x0, 0x18(%rcx)
leaq 0x498c(%rip), %rsi      # 0xb84a
movq %rsi, (%rcx)
addq %rdx, %rax
addq $0x29, %rax
movq %rax, -0x8(%rax)
movb $0x0, -0x29(%rax)
movq %rcx, 0xe0(%rdi)
andq $0x0, 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_O2/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
pushq $0x10
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3621
testq %rax, %rax
je 0x6f47
movq 0x198(%r14), %rcx
movq %rcx, (%rax)
andq $0x0, 0x8(%rax)
movq 0xe0(%rbx), %rax
andq $-0x3, 0x18(%rax)
andq $0x0, 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_O2/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
movups (%rax), %xmm0
movups %xmm0, 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_O2/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:
movq 0x60(%rdi), %rcx
leaq 0x8(%rcx), %rax
movq %rax, 0x60(%rdi)
movq (%rcx), %rdx
movq 0x8(%rcx,%rdx,8), %rcx
movq %rdx, %rsi
subq $0x1, %rsi
jb 0x7155
movq (%rax,%rsi,8), %r8
movq %r8, (%rax,%rdx,8)
movq %rsi, %rdx
jmp 0x7142
movq %rcx, (%rax)
movq 0x58(%rdi), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, 0x58(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_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 0x7226
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 0x3496
// File: /workspace/github_c_makefile_star2_O2/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
movups (%rax), %xmm1
movups %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_O2/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:
movq 0x60(%rdi), %rcx
movq 0x68(%rdi), %rax
leaq 0x8(%rcx), %rdx
movq %rdx, 0x60(%rdi)
movq (%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
movq %rcx, %rdx
subq $0x1, %rdx
jb 0x772a
movsd (%rax,%rdx,8), %xmm1
movsd %xmm1, (%rax,%rcx,8)
movq %rdx, %rcx
jmp 0x7715
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_O2/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 0x7803
callq 0x22d0
jmp 0x780e
ucomisd %xmm0, %xmm1
jbe 0x780e
callq 0x22f0
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x696e(%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_O2/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 0x787a
callq 0x22d0
jmp 0x7885
ucomisd %xmm0, %xmm1
jbe 0x7885
callq 0x22f0
movq 0x60(%rbx), %r14
leaq -0x10(%r14), %rax
movq %rax, 0x60(%rbx)
callq 0xce90
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_O2/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_f_lt
void af_prim_f_lt(af_task_t* task) {
  af_float_t value0;
  af_float_t value1;
  AF_VERIFY_FLOAT_STACK_READ(task, 2);
  AF_VERIFY_DATA_STACK_EXPAND(task, 1);
  value1 = *task->float_stack_current++;
  value0 = *task->float_stack_current++;
  *(--task->data_stack_current) = (af_cell_t)(value0 < value1 ? -1 : 0);
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
movq 0x60(%rdi), %rax
movq 0x68(%rdi), %rcx
movsd (%rcx), %xmm0
leaq 0x10(%rcx), %rdx
movq %rdx, 0x68(%rdi)
xorl %edx, %edx
ucomisd 0x8(%rcx), %xmm0
seta %dl
negq %rdx
leaq -0x8(%rax), %rcx
movq %rcx, 0x60(%rdi)
movq %rdx, -0x8(%rax)
movq 0x58(%rdi), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
movq %rax, 0x58(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_f_lte
void af_prim_f_lte(af_task_t* task) {
  af_float_t value0;
  af_float_t value1;
  AF_VERIFY_FLOAT_STACK_READ(task, 2);
  AF_VERIFY_DATA_STACK_EXPAND(task, 1);
  value1 = *task->float_stack_current++;
  value0 = *task->float_stack_current++;
  *(--task->data_stack_current) = (af_cell_t)(value0 <= value1 ? -1 : 0);
}

// Assembly:
movq 0x60(%rdi), %rax
movq 0x68(%rdi), %rcx
movsd (%rcx), %xmm0
leaq 0x10(%rcx), %rdx
movq %rdx, 0x68(%rdi)
xorl %edx, %edx
ucomisd 0x8(%rcx), %xmm0
adcq $-0x1, %rdx
leaq -0x8(%rax), %rcx
movq %rcx, 0x60(%rdi)
movq %rdx, -0x8(%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7c5c
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdi
leaq 0x10(%r14), %rax
movq %rax, 0x60(%rbx)
callq 0xd0a0
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 0x3496
// File: /workspace/github_c_makefile_star2_O2/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 0x7d24
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdi
leaq 0x10(%r14), %rax
movq %rax, 0x60(%rbx)
callq 0xd3b0
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 0x3496
// File: /workspace/github_c_makefile_star2_O2/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_d_and
void af_prim_d_and(af_task_t* task) {
  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);
  task->data_stack_current += 2;
  AF_STORE_2CELL(task, 0, value0 & value1);
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
movq 0x60(%rdi), %rax
leaq 0x10(%rax), %rcx
movq %rcx, 0x60(%rdi)
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
andps %xmm0, %xmm1
movups %xmm1, 0x10(%rax)
movq 0x58(%rdi), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, 0x58(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_d_lshift
void af_prim_d_lshift(af_task_t* task) {
  af_2cell_t value0;
  af_cell_t value1;
  AF_VERIFY_DATA_STACK_READ(task, 3);
  AF_LOAD_2CELL(task, 1, value0);
  value1 = *task->data_stack_current++;
  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
leaq 0x8(%r14), %rax
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdi
movq %rax, 0x60(%rbx)
movzbl (%r14), %edx
callq 0xcdf0
movq %rdx, 0x8(%r14)
movq %rax, 0x10(%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_O2/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 0x32cc(%rip), %rcx      # 0xb88a
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
// File: /workspace/github_c_makefile_star2_O2/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_t_store
void af_prim_t_store(af_task_t* task) {
  af_cell_t value;
  af_cell_t offset;
  af_task_t* target_task;
  AF_VERIFY_DATA_STACK_READ(task, 3);
  target_task = (af_task_t*)(*task->data_stack_current++);
  offset = *task->data_stack_current++;
  value = *task->data_stack_current++;
  *(af_cell_t*)(target_task->task_local_space_base + offset) = value;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
movq 0x60(%rdi), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rdx
leaq 0x18(%rax), %rsi
movq %rsi, 0x60(%rdi)
movq 0x10(%rax), %rax
movq 0x120(%rcx), %rcx
movq %rax, (%rcx,%rdx)
movq 0x58(%rdi), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
movq %rax, 0x58(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_wt_store
void af_prim_wt_store(af_task_t* task) {
  af_cell_t value;
  af_cell_t offset;
  af_task_t* target_task;
  AF_VERIFY_DATA_STACK_READ(task, 3);
  target_task = (af_task_t*)(*task->data_stack_current++);
  offset = *task->data_stack_current++;
  value = *task->data_stack_current++;
  *(uint32_t*)(target_task->task_local_space_base + offset) =
    value & 0xFFFFFFFF;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
movq 0x60(%rdi), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rdx
leaq 0x18(%rax), %rsi
movq %rsi, 0x60(%rdi)
movl 0x10(%rax), %eax
movq 0x120(%rcx), %rcx
movl %eax, (%rcx,%rdx)
movq 0x58(%rdi), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
movq %rax, 0x58(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_ht_store
void af_prim_ht_store(af_task_t* task) {
  af_cell_t value;
  af_cell_t offset;
  af_task_t* target_task;
  AF_VERIFY_DATA_STACK_READ(task, 3);
  target_task = (af_task_t*)(*task->data_stack_current++);
  offset = *task->data_stack_current++;
  value = *task->data_stack_current++;
  *(uint16_t*)(target_task->task_local_space_base + offset) =
    value & 0xFFFF;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
movq 0x60(%rdi), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rdx
leaq 0x18(%rax), %rsi
movq %rsi, 0x60(%rdi)
movzwl 0x10(%rax), %eax
movq 0x120(%rcx), %rcx
movw %ax, (%rcx,%rdx)
movq 0x58(%rdi), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
movq %rax, 0x58(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_ct_store
void af_prim_ct_store(af_task_t* task) {
  af_cell_t value;
  af_cell_t offset;
  af_task_t* target_task;
  AF_VERIFY_DATA_STACK_READ(task, 3);
  target_task = (af_task_t*)(*task->data_stack_current++);
  offset = *task->data_stack_current++;
  value = *task->data_stack_current++;
  *(af_byte_t*)(target_task->task_local_space_base + offset) = value & 0xFF;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
movq 0x60(%rdi), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rdx
leaq 0x18(%rax), %rsi
movq %rsi, 0x60(%rdi)
movb 0x10(%rax), %al
movq 0x120(%rcx), %rcx
movb %al, (%rcx,%rdx)
movq 0x58(%rdi), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
movq %rax, 0x58(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_ft_fetch
void af_prim_ft_fetch(af_task_t* task) {
  af_cell_t offset;
  af_task_t* target_task;
  AF_VERIFY_DATA_STACK_READ(task, 2);
  AF_VERIFY_FLOAT_STACK_EXPAND(task, 1);
  target_task = (af_task_t*)(*task->data_stack_current++);
  offset = *(task->data_stack_current++);
  *(--task->float_stack_current) =
    *(af_float_t*)(target_task->task_local_space_base + offset);
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
movq 0x60(%rdi), %rax
movq 0x68(%rdi), %rcx
movq (%rax), %rdx
leaq 0x10(%rax), %rsi
movq %rsi, 0x60(%rdi)
movq 0x8(%rax), %rax
movq 0x120(%rdx), %rdx
movsd (%rdx,%rax), %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_O2/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_ft_store
void af_prim_ft_store(af_task_t* task) {
  af_float_t value;
  af_cell_t offset;
  af_task_t* target_task;
  AF_VERIFY_DATA_STACK_READ(task, 2);
  AF_VERIFY_FLOAT_STACK_READ(task, 1);
  target_task = (af_task_t*)(*task->data_stack_current++);
  offset = *task->data_stack_current++;
  value = *task->float_stack_current++;
  *(af_float_t*)(target_task->task_local_space_base + offset) = value;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
movq 0x60(%rdi), %rax
movq 0x68(%rdi), %rcx
movq (%rax), %rdx
leaq 0x10(%rax), %rsi
movq %rsi, 0x60(%rdi)
movq 0x8(%rax), %rax
leaq 0x8(%rcx), %rsi
movq %rsi, 0x68(%rdi)
movsd (%rcx), %xmm0
movq 0x120(%rdx), %rcx
movsd %xmm0, (%rcx,%rax)
movq 0x58(%rdi), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
movq %rax, 0x58(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/tabemann[P]attoforth/src/runtime/prim.c
// Function: af_prim_sft_store
void af_prim_sft_store(af_task_t* task) {
  af_float_t value;
  af_cell_t offset;
  af_task_t* target_task;
  AF_VERIFY_DATA_STACK_READ(task, 2);
  AF_VERIFY_FLOAT_STACK_READ(task, 1);
  target_task = (af_task_t*)(*task->data_stack_current++);
  offset = *task->data_stack_current++;
  value = *task->float_stack_current++;
  *(af_sfloat_t*)(target_task->task_local_space_base + offset) = value;
  AF_ADVANCE_IP(task, 1);
}

// Assembly:
movq 0x60(%rdi), %rax
movq 0x68(%rdi), %rcx
movq (%rax), %rdx
leaq 0x10(%rax), %rsi
movq %rsi, 0x60(%rdi)
movq 0x8(%rax), %rax
leaq 0x8(%rcx), %rsi
movq %rsi, 0x68(%rdi)
cvtsd2ss (%rcx), %xmm0
movq 0x120(%rdx), %rcx
movss %xmm0, (%rcx,%rax)
movq 0x58(%rdi), %rax
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
movq %rax, 0x58(%rdi)
retq