LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/io.c
// Function: af_io_delete
af_bool_t af_io_delete(af_byte_t* path, af_io_size_t count,
		       af_io_error_t* error) {
  af_byte_t* path_buffer = malloc(sizeof(af_byte_t) * (count + 1));
  memcpy(path_buffer, path, count);
  path_buffer[count] = 0;
  if(!unlink(path_buffer)) {
    *error = 0;
    free(path_buffer);
    return TRUE;
  } else {
    *error = errno;
    free(path_buffer);
    return FALSE;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
leaq 0x1(%rsi), %rdi
callq 0x2220
movq %rax, %r14
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x21f0
movb $0x0, (%r14,%r15)
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xc680
callq 0x2070
movl (%rax), %ebp
xorl %r15d, %r15d
jmp 0xc689
movq $-0x1, %r15
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x2050
movl %ebp, (%rbx)
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/io.c
// Function: af_io_rename
af_bool_t af_io_rename(af_byte_t* path1, af_io_size_t count1,
		       af_byte_t* path2, af_io_size_t count2,
		       af_io_error_t* error) {
  af_byte_t* path_buffer1 = malloc(sizeof(af_byte_t) * (count1 + 1));
  af_byte_t* path_buffer2 = malloc(sizeof(af_byte_t) * (count2 + 1));
  memcpy(path_buffer1, path1, count1);
  path_buffer1[count1] = 0;
  memcpy(path_buffer2, path2, count2);
  path_buffer2[count2] = 0;
  if(!rename(path_buffer1, path_buffer2)) {
    *error = 0;
    free(path_buffer1);
    free(path_buffer2);
    return TRUE;
  } else {
    *error = errno;
    free(path_buffer1);
    free(path_buffer2);
    return TRUE;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, (%rsp)
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
leaq 0x1(%rsi), %rdi
callq 0x2220
movq %rax, %r14
leaq 0x1(%r12), %rdi
callq 0x2220
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0x21f0
xorl %ebx, %ebx
movb %bl, (%r14,%rbp)
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x21f0
movb %bl, (%r15,%r12)
movq %r14, %rdi
movq %r15, %rsi
callq 0x22b0
testl %eax, %eax
je 0xc776
callq 0x2070
movl (%rax), %ebx
movq %r14, %rdi
callq 0x2050
movq %r15, %rdi
callq 0x2050
movq (%rsp), %rax
movl %ebx, (%rax)
movq $-0x1, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/io.c
// Function: af_io_isatty
af_bool_t af_io_isatty(af_io_fd_t fd, af_io_error_t* error) {
  if(isatty(fd)) {
    *error = 0;
    return TRUE;
  } else if(errno == EINVAL || errno == ENOTTY) {
    *error = 0;
    return FALSE;
  } else {
    *error = errno;
    return FALSE;
  }
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
callq 0x20a0
testl %eax, %eax
je 0xc7bc
movq $-0x1, %rax
xorl %ecx, %ecx
movl %ecx, (%rbx)
popq %rbx
retq
callq 0x2070
movl (%rax), %edx
xorl %ecx, %ecx
cmpl $0x16, %edx
je 0xc7da
movl $0x0, %eax
cmpl $0x19, %edx
je 0xc7b8
xorl %eax, %eax
movl %edx, %ecx
jmp 0xc7b8
xorl %eax, %eax
jmp 0xc7b8
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/io.c
// Function: af_io_sleep
af_io_action_t* af_io_sleep(af_io_t* io, af_time_t* sleep_until,
			    af_task_t* task_to_wake) {
  af_io_action_t* action;
  if(!(action = malloc(sizeof(af_io_action_t)))) {
    return NULL;
  }
  action->type = AF_IO_TYPE_SLEEP;
  action->to_be_destroyed = FALSE;
  action->fd = 0;
  action->buffer = NULL;
  action->count = 0;
  action->index = 0;
  action->offset = 0;
  action->whence = AF_IO_SEEK_CUR;
  action->sleep_until.tv_sec = sleep_until->sec;
  action->sleep_until.tv_nsec = sleep_until->nsec;
  action->is_buffer_freeable = FALSE;
  action->task_to_wake = task_to_wake;
  action->is_done = FALSE;
  action->is_closed = FALSE;
  action->has_hangup = FALSE;
  action->has_error = FALSE;
  af_io_add(io, action);
  return action;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movl $0x98, %edi
callq 0x2220
movq %rax, %rbx
testq %rax, %rax
je 0xc89f
movq $0x4, 0x18(%rbx)
xorl %eax, %eax
movq %rax, 0x20(%rbx)
movl $0x0, 0x28(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x40(%rbx)
movq $0x1, 0x50(%rbx)
movups (%r12), %xmm1
movups %xmm1, 0x58(%rbx)
movq %rax, 0x68(%rbx)
movq %r15, 0x70(%rbx)
movups %xmm0, 0x78(%rbx)
movups %xmm0, 0x88(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc8ae
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/io.c
// Function: af_io_add
void af_io_add(af_io_t* io, af_io_action_t* action) {
  af_bool_t wake = FALSE;
  pthread_mutex_lock(&io->mutex);
  action->io = io;
  if(action->type == AF_IO_TYPE_WRITE) {
    io->pending_write_count++;
  }
  if(action->type != AF_IO_TYPE_SLEEP && af_io_is_active(io, action->fd)) {
    action->prev_action = io->last_waiting_action;
    action->next_action = NULL;
    if(action->prev_action) {
      action->prev_action->next_action = action;
    } else {
      io->first_waiting_action = action;
    }
    io->last_waiting_action = action;
  } else {
    action->prev_action = NULL;
    action->next_action = io->first_active_action;
    if(action->next_action) {
      action->next_action->prev_action = action;
    }
    io->first_active_action = action;
    io->active_action_count++;
      wake = TRUE;
  }
  pthread_mutex_unlock(&io->mutex);
  if(wake) {
    af_io_wake(io);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x2310
movq %rbx, 0x10(%r15)
movq 0x18(%r15), %rax
cmpq $0x1, %rax
je 0xc8df
cmpq $0x4, %rax
jne 0xc8e3
movq 0x50(%rbx), %rax
jmp 0xc908
incq 0x48(%rbx)
movq 0x50(%rbx), %rax
testq %rax, %rax
je 0xc91d
movl 0x28(%r15), %ecx
movq %rax, %rdx
cmpl %ecx, 0x28(%rdx)
jne 0xc8ff
cmpq $0x4, 0x18(%rdx)
jne 0xc941
movq 0x8(%rdx), %rdx
testq %rdx, %rdx
jne 0xc8f3
movq $0x0, (%r15)
movq %rax, 0x8(%r15)
testq %rax, %rax
je 0xc924
movq %r15, (%rax)
jmp 0xc924
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq %r15, 0x50(%rbx)
incq 0x40(%rbx)
movq %r14, %rdi
callq 0x2210
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xc408
movq 0x60(%rbx), %rax
movq %rax, (%r15)
leaq 0x58(%rbx), %rcx
leaq 0x8(%rax), %rdx
testq %rax, %rax
cmoveq %rcx, %rdx
movq $0x0, 0x8(%r15)
movq %r15, (%rdx)
movq %r15, 0x60(%rbx)
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2210
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/io.c
// Function: af_io_tell
af_io_action_t* af_io_tell(af_io_t* io, af_io_fd_t fd,
			   af_task_t* task_to_wake) {
  af_io_action_t* action;
  if(!(action = malloc(sizeof(af_io_action_t)))) {
    return NULL;
  }
  action->type = AF_IO_TYPE_TELL;
  action->to_be_destroyed = FALSE;
  action->fd = fd;
  action->buffer = NULL;
  action->count = 0;
  action->index = 0;
  action->offset = 0;
  action->whence = AF_IO_SEEK_CUR;
  action->sleep_until.tv_sec = 0;
  action->sleep_until.tv_nsec = 0;
  action->is_buffer_freeable = FALSE;
  action->task_to_wake = task_to_wake;
  action->is_done = FALSE;
  action->is_closed = FALSE;
  action->has_hangup = FALSE;
  action->has_error = FALSE;
  af_io_add(io, action);
  return action;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r14
movl $0x98, %edi
callq 0x2220
movq %rax, %rbx
testq %rax, %rax
je 0xc9da
movq $0x5, 0x18(%rbx)
xorl %eax, %eax
movq %rax, 0x20(%rbx)
movl %ebp, 0x28(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x40(%rbx)
movq $0x1, 0x50(%rbx)
movups %xmm0, 0x58(%rbx)
movq %rax, 0x68(%rbx)
movq %r15, 0x70(%rbx)
movups %xmm0, 0x78(%rbx)
movups %xmm0, 0x88(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc8ae
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/io.c
// Function: af_io_close_async
af_io_action_t* af_io_close_async(af_io_t* io, af_io_fd_t fd) {
  af_io_action_t* action;
  if(!(action = malloc(sizeof(af_io_action_t)))) {
    return NULL;
  }
  action->type = AF_IO_TYPE_CLOSE;
  action->to_be_destroyed = FALSE;
  action->fd = fd;
  action->buffer = NULL;
  action->count = 0;
  action->index = 0;
  action->offset = 0;
  action->whence = AF_IO_SEEK_CUR;
  action->sleep_until.tv_sec = 0;
  action->sleep_until.tv_nsec = 0;
  action->is_buffer_freeable = FALSE;
  action->task_to_wake = NULL;
  action->is_done = FALSE;
  action->is_closed = FALSE;
  action->has_hangup = FALSE;
  action->has_error = FALSE;
  af_io_add(io, action);
  return action;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
movl $0x98, %edi
callq 0x2220
movq %rax, %rbx
testq %rax, %rax
je 0xcabc
movq $0x2, 0x18(%rbx)
movq $0x0, 0x20(%rbx)
movl %ebp, 0x28(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x40(%rbx)
movq $0x1, 0x50(%rbx)
movups %xmm0, 0x58(%rbx)
movups %xmm0, 0x68(%rbx)
movups %xmm0, 0x78(%rbx)
movups %xmm0, 0x88(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc8ae
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/io.c
// Function: af_io_seek_block
af_io_action_t* af_io_seek_block(af_io_t* io, af_io_fd_t fd, af_io_off_t offset,
				 af_io_whence_t whence,
				 af_task_t* task_to_wake) {
  af_io_action_t* action;
  if(!(action = malloc(sizeof(af_io_action_t)))) {
    return NULL;
  }
  action->type = AF_IO_TYPE_SEEK;
  action->to_be_destroyed = FALSE;
  action->fd = fd;
  action->buffer = NULL;
  action->count = 0;
  action->index = 0;
  action->offset = offset;
  action->whence = whence;
  action->sleep_until.tv_sec = 0;
  action->sleep_until.tv_nsec = 0;
  action->is_buffer_freeable = FALSE;
  action->task_to_wake = task_to_wake;
  action->is_done = FALSE;
  action->is_closed = FALSE;
  action->has_hangup = FALSE;
  action->has_error = FALSE;
  af_io_add(io, action);
  return action;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movl %ecx, %ebp
movq %rdx, %r12
movl %esi, %r13d
movq %rdi, %r14
movl $0x98, %edi
callq 0x2220
movq %rax, %rbx
testq %rax, %rax
je 0xcb39
movq $0x3, 0x18(%rbx)
xorl %eax, %eax
movq %rax, 0x20(%rbx)
movl %r13d, 0x28(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movq %rax, 0x40(%rbx)
movq %r12, 0x48(%rbx)
movslq %ebp, %rcx
movq %rcx, 0x50(%rbx)
movups %xmm0, 0x58(%rbx)
movq %rax, 0x68(%rbx)
movq %r15, 0x70(%rbx)
movups %xmm0, 0x78(%rbx)
movups %xmm0, 0x88(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc8ae
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/io.c
// Function: af_io_seek_async
af_io_action_t* af_io_seek_async(af_io_t* io, af_io_fd_t fd, af_io_off_t offset,
				 af_io_whence_t whence) {
  af_io_action_t* action;
  if(!(action = malloc(sizeof(af_io_action_t)))) {
    return NULL;
  }
  action->type = AF_IO_TYPE_SEEK;
  action->to_be_destroyed = FALSE;
  action->fd = fd;
  action->buffer = NULL;
  action->count = 0;
  action->index = 0;
  action->offset = offset;
  action->whence = whence;
  action->sleep_until.tv_sec = 0;
  action->sleep_until.tv_nsec = 0;
  action->is_buffer_freeable = FALSE;
  action->task_to_wake = NULL;
  action->is_done = FALSE;
  action->is_closed = FALSE;
  action->has_hangup = FALSE;
  action->has_error = FALSE;
  af_io_add(io, action);
  return action;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %r14
movl $0x98, %edi
callq 0x2220
movq %rax, %rbx
testq %rax, %rax
je 0xcbb6
movq $0x3, 0x18(%rbx)
xorl %eax, %eax
movq %rax, 0x20(%rbx)
movl %r12d, 0x28(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
movq %rax, 0x40(%rbx)
movq %r15, 0x48(%rbx)
movslq %ebp, %rax
movq %rax, 0x50(%rbx)
movups %xmm0, 0x58(%rbx)
movups %xmm0, 0x68(%rbx)
movups %xmm0, 0x78(%rbx)
movups %xmm0, 0x88(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc8ae
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/io.c
// Function: af_io_read_block
af_io_action_t* af_io_read_block(af_io_t* io, af_io_fd_t fd, af_byte_t* buffer,
				 af_io_size_t count, af_task_t* task_to_wake) {
  af_io_action_t* action;
  if(!(action = malloc(sizeof(af_io_action_t)))) {
    return NULL;
  }
  action->type = AF_IO_TYPE_READ;
  action->to_be_destroyed = FALSE;
  action->fd = fd;
  action->buffer = buffer;
  action->count = count;
  action->index = 0;
  action->offset = 0;
  action->whence = AF_IO_SEEK_CUR;
  action->sleep_until.tv_sec = 0;
  action->sleep_until.tv_nsec = 0;
  action->is_buffer_freeable = FALSE;
  action->task_to_wake = task_to_wake;
  action->is_done = count == 0;
  action->is_closed = FALSE;
  action->has_hangup = FALSE;
  action->has_error = FALSE;
  af_fd_set_blocking(fd, FALSE);
  af_io_add(io, action);
  return action;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movq %rcx, %r15
movq %rdx, %r13
movl %esi, %ebp
movq %rdi, %r14
movl $0x98, %edi
callq 0x2220
movq %rax, %rbx
testq %rax, %rax
je 0xcc47
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
movl %ebp, 0x28(%rbx)
movq %r13, 0x30(%rbx)
movq %r15, 0x38(%rbx)
movups %xmm0, 0x40(%rbx)
movq $0x1, 0x50(%rbx)
movups %xmm0, 0x58(%rbx)
xorl %eax, %eax
movq %rax, 0x68(%rbx)
movq %r12, 0x70(%rbx)
xorl %ecx, %ecx
testq %r15, %r15
sete %cl
movq %rcx, 0x78(%rbx)
movups %xmm0, 0x80(%rbx)
movq %rax, 0x90(%rbx)
movl %ebp, %edi
xorl %esi, %esi
callq 0xbd84
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc8ae
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/io.c
// Function: af_io_write_block
af_io_action_t* af_io_write_block(af_io_t* io, af_io_fd_t fd, af_byte_t* buffer,
				  af_io_size_t count, af_task_t* task_to_wake) {
  af_io_action_t* action;
  if(!(action = malloc(sizeof(af_io_action_t)))) {
    return NULL;
  }
  action->type = AF_IO_TYPE_WRITE;
  action->to_be_destroyed = FALSE;
  action->fd = fd;
  action->buffer = buffer;
  action->count = count;
  action->index = 0;
  action->offset = 0;
  action->whence = AF_IO_SEEK_CUR;
  action->sleep_until.tv_sec = 0;
  action->sleep_until.tv_nsec = 0;
  action->is_buffer_freeable = FALSE;
  action->task_to_wake = task_to_wake;
  action->is_done = count == 0;
  action->is_closed = FALSE;
  action->has_hangup = FALSE;
  action->has_error = FALSE;
  af_fd_set_blocking(fd, FALSE);
  af_io_add(io, action);
  return action;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movq %rcx, %r15
movq %rdx, %r13
movl %esi, %ebp
movq %rdi, %r14
movl $0x98, %edi
callq 0x2220
movq %rax, %rbx
testq %rax, %rax
je 0xcce3
movl $0x1, %eax
movq %rax, 0x18(%rbx)
xorl %ecx, %ecx
movq %rcx, 0x20(%rbx)
movl %ebp, 0x28(%rbx)
movq %r13, 0x30(%rbx)
movq %r15, 0x38(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movq %rax, 0x50(%rbx)
movups %xmm0, 0x58(%rbx)
movq %rcx, 0x68(%rbx)
movq %r12, 0x70(%rbx)
xorl %eax, %eax
testq %r15, %r15
sete %al
movq %rax, 0x78(%rbx)
movups %xmm0, 0x80(%rbx)
movq %rcx, 0x90(%rbx)
movl %ebp, %edi
xorl %esi, %esi
callq 0xbd84
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc8ae
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/io.c
// Function: af_io_read_async
af_io_action_t* af_io_read_async(af_io_t* io, af_io_fd_t fd, af_byte_t* buffer,
				 af_io_size_t count) {
  af_io_action_t* action;
  if(!(action = malloc(sizeof(af_io_action_t)))) {
    return NULL;
  }
  action->type = AF_IO_TYPE_READ;
  action->to_be_destroyed = FALSE;
  action->fd = fd;
  action->buffer = buffer;
  action->count = count;
  action->index = 0;
  action->offset = 0;
  action->whence = AF_IO_SEEK_CUR;
  action->sleep_until.tv_sec = 0;
  action->sleep_until.tv_nsec = 0;
  action->is_buffer_freeable = FALSE;
  action->task_to_wake = NULL;
  action->is_done = count == 0;
  action->is_closed = FALSE;
  action->has_hangup = FALSE;
  action->has_error = FALSE;
  af_fd_set_blocking(fd, FALSE);
  af_io_add(io, action);
  return action;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r14
movl $0x98, %edi
callq 0x2220
movq %rax, %rbx
testq %rax, %rax
je 0xcd72
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
movl %ebp, 0x28(%rbx)
movq %r12, 0x30(%rbx)
movq %r15, 0x38(%rbx)
movups %xmm0, 0x40(%rbx)
movq $0x1, 0x50(%rbx)
xorl %eax, %eax
testq %r15, %r15
sete %al
movups %xmm0, 0x58(%rbx)
movups %xmm0, 0x68(%rbx)
movq %rax, 0x78(%rbx)
movups %xmm0, 0x80(%rbx)
movq $0x0, 0x90(%rbx)
movl %ebp, %edi
xorl %esi, %esi
callq 0xbd84
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc8ae
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/io.c
// Function: af_io_write_async
af_io_action_t* af_io_write_async(af_io_t* io, af_io_fd_t fd, af_byte_t* buffer,
				  af_io_size_t count) {
  af_io_action_t* action;
  af_byte_t* buffer_copy;
  if(!(action = malloc(sizeof(af_io_action_t)))) {
    return NULL;
  }
  if(!(buffer_copy = malloc(sizeof(af_byte_t) * count))) {
    free(action);
    return NULL;
  }
  memcpy(buffer_copy, buffer, sizeof(af_byte_t) * count);
  action->type = AF_IO_TYPE_WRITE;
  action->to_be_destroyed = FALSE;
  action->fd = fd;
  action->buffer = buffer_copy;
  action->count = count;
  action->index = 0;
  action->offset = 0;
  action->whence = AF_IO_SEEK_CUR;
  action->sleep_until.tv_sec = 0;
  action->sleep_until.tv_nsec = 0;
  action->is_buffer_freeable = TRUE;
  action->task_to_wake = NULL;
  action->is_done = count == 0;
  action->is_closed = FALSE;
  action->has_hangup = FALSE;
  action->has_error = FALSE;
  af_fd_set_blocking(fd, FALSE);
  af_io_add(io, action);
  return action;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r14
movl $0x98, %edi
callq 0x2220
testq %rax, %rax
je 0xce35
movq %rax, %rbx
movq %r15, %rdi
callq 0x2220
testq %rax, %rax
je 0xce2d
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x21f0
movl $0x1, %eax
movq %rax, 0x18(%rbx)
xorl %ecx, %ecx
movq %rcx, 0x20(%rbx)
movl %ebp, 0x28(%rbx)
movq %r13, 0x30(%rbx)
movq %r15, 0x38(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movq %rax, 0x50(%rbx)
movups %xmm0, 0x58(%rbx)
movq $-0x1, 0x68(%rbx)
movq %rcx, 0x70(%rbx)
xorl %eax, %eax
testq %r15, %r15
sete %al
movq %rax, 0x78(%rbx)
movups %xmm0, 0x80(%rbx)
movq %rcx, 0x90(%rbx)
movl %ebp, %edi
xorl %esi, %esi
callq 0xbd84
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc8ae
jmp 0xce37
movq %rbx, %rdi
callq 0x2050
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/io.c
// Function: af_io_read_nonblock
ssize_t af_io_read_nonblock(int fd, af_byte_t* buffer, af_io_size_t count,
			    af_bool_t* again, af_io_error_t* error) {
  ssize_t size;
  af_fd_set_blocking(fd, FALSE);
  size = read(fd, buffer, sizeof(af_byte_t) * count);
  *again = size == -1 && (errno == EAGAIN || errno == EWOULDBLOCK ||
			  errno == EINTR) ? TRUE : FALSE;
  *error = size != -1 || (size == -1 && (errno == EAGAIN ||
					 errno == EWOULDBLOCK ||
					 errno == EINTR)) ? 0 : errno;
  return size;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movl %edi, %ebp
xorl %r13d, %r13d
xorl %esi, %esi
callq 0xbd84
movl %ebp, %edi
movq %r12, %rsi
movq %r14, %rdx
callq 0x21c0
movq %rax, %r14
cmpq $-0x1, %rax
je 0xce9e
movq $0x0, (%r15)
movl %r13d, (%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2070
movl (%rax), %eax
cmpl $0xb, %eax
sete %cl
cmpl $0x4, %eax
sete %dl
orb %cl, %dl
movzbl %dl, %ecx
negq %rcx
movq %rcx, (%r15)
cmpl $0x4, %eax
je 0xce89
cmpl $0xb, %eax
je 0xce89
movl %eax, %r13d
jmp 0xce89
// File: /workspace/github_c_makefile_star2_O3/tabemann[P]attoforth/src/runtime/io.c
// Function: af_io_write_nonblock
ssize_t af_io_write_nonblock(int fd, af_byte_t* buffer, af_io_size_t count,
			     af_bool_t* again, af_io_error_t* error) {
  ssize_t size;
  af_fd_set_blocking(fd, FALSE);
  size = write(fd, buffer, sizeof(af_byte_t) * count);
  *again = size == -1 && (errno == EAGAIN || errno == EWOULDBLOCK ||
			  errno == EINTR) ? TRUE : FALSE;
  *error = size != -1 || (size == -1 && (errno == EAGAIN ||
					 errno == EWOULDBLOCK ||
					 errno == EINTR)) ? 0 : errno;
  return size;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movl %edi, %ebp
xorl %r13d, %r13d
xorl %esi, %esi
callq 0xbd84
movl %ebp, %edi
movq %r12, %rsi
movq %r14, %rdx
callq 0x20f0
movq %rax, %r14
cmpq $-0x1, %rax
je 0xcf20
movq $0x0, (%r15)
movl %r13d, (%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2070
movl (%rax), %eax
cmpl $0xb, %eax
sete %cl
cmpl $0x4, %eax
sete %dl
orb %cl, %dl
movzbl %dl, %ecx
negq %rcx
movq %rcx, (%r15)
cmpl $0x4, %eax
je 0xcf0b
cmpl $0xb, %eax
je 0xcf0b
movl %eax, %r13d
jmp 0xcf0b
// File: /workspace/github_c_makefile_star2_O3/kobolt[P]curses-collection/fileselect/fileselect.c
// Function: file_node_new
static file_node_t *file_node_new(file_node_t *parent, char *name, file_node_type_t type)
{
  int len;
  file_node_t *new;

  new = (file_node_t *)malloc(sizeof(file_node_t));
  if (new == NULL)
    return NULL;

  if (name == NULL) {
    new->name = NULL;
  } else {
    len = strlen(name) + 1;
    new->name = (char *)malloc(len);
    strncpy(new->name, name, len);
  }
  new->type = type;
  new->parent = parent;
  new->no_of_subnodes = 0;
  new->subnode = NULL;
  new->marked = 0;
  
  return new;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r12
movq %rdi, %r15
movl $0x30, %edi
callq 0x1190
movq %rax, %r14
testq %rax, %rax
je 0x173f
xorl %eax, %eax
testq %r12, %r12
je 0x1721
movq %r12, %rdi
callq 0x10d0
incl %eax
movslq %eax, %rbp
movq %rbp, %rdi
callq 0x1190
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x1070
xorl %eax, %eax
jmp 0x1724
xorl %r13d, %r13d
movq %r13, 0x8(%r14)
movl %ebx, 0x10(%r14)
movq %r15, 0x18(%r14)
movl %eax, 0x20(%r14)
movq $0x0, 0x28(%r14)
movl %eax, (%r14)
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_O3/kobolt[P]curses-collection/fileselect/fileselect.c
// Function: file_node_scan
static int file_node_scan(file_node_t *current, char *path)
{
  DIR *dh;
  struct dirent *entry;
  struct stat st;
  char fullpath[PATH_MAX];
  file_node_t *subnode;

  dh = opendir(path);
  if (dh == NULL) {
    fprintf(stderr, "Error: Unable to open directory: %s\n", path);
    return -1;
  }

  while ((entry = readdir(dh))) {
    if (entry->d_name[0] == '.')
      continue; /* Ignore files with leading dot. */

    snprintf(fullpath, PATH_MAX, "%s/%s", path, entry->d_name);
    if (stat(fullpath, &st) == -1) {
      fprintf(stderr, "Warning: Unable to stat() path: %s\n", fullpath);
      continue;
    }

    if (S_ISDIR(st.st_mode)) {
      subnode = file_node_add(current, entry->d_name, FILE_NODE_TYPE_DIR);
      file_node_scan(subnode, fullpath);

    } else if (S_ISREG(st.st_mode)) {
      file_node_add(current, entry->d_name, FILE_NODE_TYPE_FILE);
    }
  }

  closedir(dh);
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1098, %rsp           # imm = 0x1098
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x10c0
testq %rax, %rax
je 0x1868
movq %rax, %r15
movq %rax, %rdi
callq 0x1180
testq %rax, %rax
je 0x184c
movq %rax, %r12
leaq 0x90(%rsp), %r13
movq %rsp, %rbp
cmpb $0x2e, 0x13(%r12)
je 0x1819
addq $0x13, %r12
movl $0x1000, %esi           # imm = 0x1000
movq %r13, %rdi
leaq 0x8d0(%rip), %rdx       # 0x2086
movq %rbx, %rcx
movq %r12, %r8
xorl %eax, %eax
callq 0x1100
movq %r13, %rdi
movq %rbp, %rsi
callq 0x1170
cmpl $-0x1, %eax
je 0x182f
movl 0x18(%rsp), %eax
movl $0xf000, %ecx           # imm = 0xF000
andl %ecx, %eax
movl %eax, %ecx
negw %cx
jo 0x1809
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x1819
movq %r14, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x1a2d
movq %rax, %rdi
movq %r13, %rsi
callq 0x1751
jmp 0x1819
movq %r14, %rdi
movq %r12, %rsi
movl $0x2, %edx
callq 0x1a2d
movq %r15, %rdi
callq 0x1180
movq %rax, %r12
testq %rax, %rax
jne 0x179b
jmp 0x184c
movq 0x27c2(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x84c(%rip), %rsi       # 0x208c
movq %r13, %rdx
xorl %eax, %eax
callq 0x1160
jmp 0x1819
movq %r15, %rdi
callq 0x1120
xorl %eax, %eax
addq $0x1098, %rsp           # imm = 0x1098
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2789(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x7e8(%rip), %rsi       # 0x2061
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1160
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x1856
// File: /workspace/github_c_makefile_star2_O3/kobolt[P]curses-collection/fileselect/fileselect.c
// Function: file_node_remove
static void file_node_remove(file_node_t *node)
{
  int i;
  free(node->name);
  for (i = 0; i < node->no_of_subnodes; i++) {
    file_node_remove(node->subnode[i]);
  }
  if (node->subnode != NULL) {
    free(node->subnode);
  }
  free(node);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x1040
cmpl $0x0, 0x20(%rbx)
je 0x18bb
xorl %r14d, %r14d
movq 0x28(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x188a
incq %r14
movl 0x20(%rbx), %eax
cmpq %rax, %r14
jb 0x18a3
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x18c9
callq 0x1040
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O3/kobolt[P]curses-collection/fileselect/fileselect.c
// Function: file_node_sort
static void file_node_sort(file_node_t *node)
{
  int i;
  qsort(node->subnode, node->no_of_subnodes, sizeof(file_node_t *), file_node_compare);
  for (i = 0; i < node->no_of_subnodes; i++) {
    file_node_sort(node->subnode[i]);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
movl 0x20(%rbx), %esi
leaq 0x193(%rip), %rcx       # 0x1a80
movl $0x8, %edx
callq 0x1080
cmpl $0x0, 0x20(%rbx)
je 0x1918
xorl %r14d, %r14d
movq 0x28(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x18d8
incq %r14
movl 0x20(%rbx), %eax
cmpq %rax, %r14
jb 0x1900
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/kobolt[P]curses-collection/fileselect/fileselect.c
// Function: file_node_print_marked
static void file_node_print_marked(file_node_t *node, char *root_dir, FILE *fh)
{
  int i;
  char path[PATH_MAX];

  if (node->marked) {
    fprintf(fh, "%s/%s\n", root_dir, file_node_path(node, path, PATH_MAX));
  }

  for (i = 0; i < node->no_of_subnodes; i++) {
    file_node_print_marked(node->subnode[i], root_dir, fh);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpl $0x0, (%rdi)
je 0x1961
movq %rsp, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x1eee
leaq 0x75f(%rip), %rsi       # 0x20b0
movq %rbx, %rdi
movq %r14, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x1160
cmpl $0x0, 0x20(%r15)
je 0x198a
xorl %r12d, %r12d
movq 0x28(%r15), %rax
movq (%rax,%r12,8), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1920
incq %r12
movl 0x20(%r15), %eax
cmpq %rax, %r12
jb 0x196b
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/kobolt[P]curses-collection/fileselect/fileselect.c
// Function: file_node_dump
static void file_node_dump(file_node_t *node)
{
  int i, depth;

  depth = file_node_depth(node);
  while (depth-- > 1)
    printf("  ");

  if (node->type == FILE_NODE_TYPE_ROOT)
    printf("/");
  else {
    printf("%s", node->name);
    if (node->type == FILE_NODE_TYPE_DIR)
      printf("/");
  }

  printf("\n");

  for (i = 0; i < node->no_of_subnodes; i++) {
    file_node_dump(node->subnode[i]);
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %ebp, %ebp
movq %rdi, %rax
cmpl $0x0, 0x10(%rax)
je 0x19b6
movq 0x18(%rax), %rax
incl %ebp
testq %rax, %rax
jne 0x19a5
cmpl $0x2, %ebp
jl 0x19d5
incl %ebp
leaq 0x6f3(%rip), %r14       # 0x20b7
movq %r14, %rdi
xorl %eax, %eax
callq 0x10f0
decl %ebp
cmpl $0x2, %ebp
ja 0x19c4
cmpl $0x0, 0x10(%rbx)
je 0x19f3
movq 0x8(%rbx), %rsi
leaq 0x6a3(%rip), %rdi       # 0x2089
xorl %eax, %eax
callq 0x10f0
cmpl $0x1, 0x10(%rbx)
jne 0x19fd
movl $0x2f, %edi
callq 0x1050
movl $0xa, %edi
callq 0x1050
cmpl $0x0, 0x20(%rbx)
je 0x1a28
xorl %r14d, %r14d
movq 0x28(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x1999
incq %r14
movl 0x20(%rbx), %eax
cmpq %rax, %r14
jb 0x1a10
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/kobolt[P]curses-collection/fileselect/fileselect.c
// Function: file_node_add
static file_node_t *file_node_add(file_node_t *current, char *name, file_node_type_t type)
{
  file_node_t *new;

  new = file_node_new(current, name, type);
  if (new == NULL)
    return NULL;

  if (current->subnode == NULL) {
    current->subnode = malloc(sizeof(file_node_t *));
  } else {
    current->subnode = realloc(current->subnode, sizeof(file_node_t *) * (current->no_of_subnodes + 1));
  }

  current->subnode[current->no_of_subnodes] = new;
  current->no_of_subnodes++;

  return new;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x16cb
movq %rax, %r14
testq %rax, %rax
je 0x1a75
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x1a5a
movl 0x20(%rbx), %esi
incl %esi
shlq $0x3, %rsi
callq 0x11a0
jmp 0x1a64
movl $0x8, %edi
callq 0x1190
movq %rax, 0x28(%rbx)
movl 0x20(%rbx), %ecx
movq %r14, (%rax,%rcx,8)
leal 0x1(%rcx), %eax
movl %eax, 0x20(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/kobolt[P]curses-collection/fileselect/fileselect.c
// Function: file_node_list_size
static int file_node_list_size(file_node_t *node)
{
  int i, size;

  if (node->type == FILE_NODE_TYPE_ROOT) {
    size = 0;
  } else {
    size = 1;
  }

  for (i = 0; i < node->no_of_subnodes; i++) {
    size += file_node_list_size(node->subnode[i]);
  }

  return size;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
xorl %ebx, %ebx
cmpl $0x0, 0x10(%rdi)
setne %bl
movl 0x20(%rdi), %r14d
testq %r14, %r14
je 0x1acc
movq 0x28(%rdi), %r15
xorl %r12d, %r12d
movq (%r15,%r12,8), %rdi
callq 0x1a98
addl %eax, %ebx
incq %r12
cmpq %r12, %r14
jne 0x1ab9
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/kobolt[P]curses-collection/fileselect/fileselect.c
// Function: file_node_get_by_node_no
static file_node_t *file_node_get_by_node_no(file_node_t *node, int node_no, int *node_count)
{
  file_node_t *found;
  int i;

  if (node->type != FILE_NODE_TYPE_ROOT) {
    *node_count = *node_count + 1;
  }
  
  if (*node_count == node_no) {
    return node; /* Match found, return self. */
  }

  for (i = 0; i < node->no_of_subnodes; i++) {
    found = file_node_get_by_node_no(node->subnode[i], node_no, node_count);
    if (found != NULL) {
      return found;
    }
  }

  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
cmpl $0x0, 0x10(%rdi)
movl (%rdx), %eax
je 0x1eaa
incl %eax
movl %eax, (%r14)
cmpl %ebp, %eax
je 0x1ee0
cmpl $0x0, 0x20(%rbx)
je 0x1ed9
xorl %r15d, %r15d
movq 0x28(%rbx), %rax
movq (%rax,%r15,8), %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x1e8e
testq %rax, %rax
jne 0x1edd
incq %r15
movl 0x20(%rbx), %eax
cmpq %rax, %r15
jb 0x1eb7
xorl %ebx, %ebx
jmp 0x1ee0
movq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/kobolt[P]curses-collection/fileselect/fileselect.c
// Function: file_node_path
static char *file_node_path(file_node_t *node, char *path, int path_len)
{
  char temp[PATH_MAX];

  strncpy(path, node->name, path_len);

  node = node->parent;
  while (node != NULL) {
    if (node->type == FILE_NODE_TYPE_ROOT) {
      break;
    }
    strncpy(temp, path, PATH_MAX);
    snprintf(path, path_len, "%s/%s", node->name, temp);
    node = node->parent;
  }

  return path;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rsi
movl $0x1000, %edx           # imm = 0x1000
movq %rbx, %rdi
callq 0x1070
movq 0x18(%r14), %r12
testq %r12, %r12
je 0x1f62
movq %rsp, %r14
leaq 0x160(%rip), %r15       # 0x2086
cmpl $0x0, 0x10(%r12)
je 0x1f62
movl $0x1000, %edx           # imm = 0x1000
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1070
movq 0x8(%r12), %rcx
movl $0x1000, %esi           # imm = 0x1000
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %r8
xorl %eax, %eax
callq 0x1100
movq 0x18(%r12), %r12
testq %r12, %r12
jne 0x1f26
movq %rbx, %rax
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O3/mist64[P]cbmbasic/runtime.c
// Function: stack4
int
stack4(unsigned short a, unsigned short b, unsigned short c, unsigned short d) {
//	printf("stack4: %x,%x,%x,%x\n", a, b, c, d);
	if (STACK16(S+1) + 1 != a) return 0;
	if (STACK16(S+3) + 1 != b) return 0;
	if (STACK16(S+5) + 1 != c) return 0;
	if (STACK16(S+7) + 1 != d) return 0;
	return 1;
}

// Assembly:
leaq 0xdac9(%rip), %rax      # 0x20128
movzbl (%rax), %r8d
leaq 0xdad6(%rip), %r9       # 0x20140
movzwl 0x101(%r8,%r9), %r10d
incl %r10d
xorl %eax, %eax
cmpl %edi, %r10d
jne 0x126e2
movzbl 0x103(%r8,%r9), %edi
movzbl 0x104(%r8,%r9), %r10d
shll $0x8, %r10d
addl %r10d, %edi
incl %edi
movzwl %si, %esi
cmpl %esi, %edi
jne 0x126e2
movzbl 0x105(%r8,%r9), %esi
movzbl 0x106(%r8,%r9), %edi
shll $0x8, %edi
addl %edi, %esi
incl %esi
movzwl %dx, %edx
cmpl %edx, %esi
jne 0x126e2
movzbl 0x107(%r8,%r9), %eax
movzbl 0x108(%r8,%r9), %edx
shll $0x8, %edx
addl %eax, %edx
incl %edx
movzwl %cx, %ecx
xorl %eax, %eax
cmpl %ecx, %edx
sete %al
retq
// File: /workspace/github_c_makefile_star2_O3/mist64[P]cbmbasic/runtime.c
// Function: CHRGET_common
static void
CHRGET_common(int inc) {
	unsigned short temp16;
	if (!inc) goto CHRGOT_start;
CHRGET_start:
	RAM[0x7A]++; SETSZ(RAM[0x7A]);
	if (!Z) goto CHRGOT_start;
	RAM[0x7B]++; SETSZ(RAM[0x7B]);
CHRGOT_start:
	A = RAM[RAM[0x7A] | RAM[0x7B]<<8]; SETSZ(A);
	temp16 = ((unsigned short)A) - ((unsigned short)0x3A); SETNC(temp16); SETSZ(temp16&0xFF);
	if (C) return;
	temp16 = ((unsigned short)A) - ((unsigned short)0x20); SETNC(temp16); SETSZ(temp16&0xFF);
	if (Z) goto CHRGET_start;
	C = 1;
	temp16 = (unsigned short)A-(unsigned short)0x30-(unsigned short)(1-C); SETV(((A ^ temp16) & 0x80) && ((A ^ 0x30) & 0x80)); A = (unsigned char)temp16; SETSZ(A); SETNC(temp16);
	C = 1;
	temp16 = (unsigned short)A-(unsigned short)0xD0-(unsigned short)(1-C); SETV(((A ^ temp16) & 0x80) && ((A ^ 0xD0) & 0x80)); A = (unsigned char)temp16; SETSZ(A); SETNC(temp16);
}

// Assembly:
testl %edi, %edi
je 0x12736
leaq 0xda4b(%rip), %rax      # 0x20140
movb 0x7a(%rax), %al
leal 0x1(%rax), %esi
shrb $0x7, %sil
leaq 0xda3a(%rip), %rcx      # 0x20140
leaq 0x1da37(%rip), %rdx     # 0x30144
movb %sil, (%rdx)
incb %al
movb %al, 0x7a(%rcx)
leaq 0x1da27(%rip), %rax     # 0x30143
sete (%rax)
jne 0x12736
movb 0x7b(%rcx), %sil
incb %sil
sete (%rax)
movb %sil, 0x7b(%rcx)
shrb $0x7, %sil
movb %sil, (%rdx)
leaq 0xda03(%rip), %rcx      # 0x20140
movzwl 0x7a(%rcx), %eax
movzbl (%rcx,%rax), %ecx
leal 0xffc6(%rcx), %edx
testb %dl, %dl
leaq 0x1d9ef(%rip), %rsi     # 0x30143
sete (%rsi)
movl %edx, %r9d
shrb $0x7, %r9b
btl $0x8, %edx
leaq 0x1d9dd(%rip), %rdx     # 0x30146
setae (%rdx)
leaq 0x1d9d2(%rip), %r8      # 0x30145
movb %cl, (%r8)
leaq 0x1d9c7(%rip), %rdi     # 0x30144
movb %r9b, (%rdi)
jae 0x127bb
leal 0xffe0(%rcx), %r9d
btl $0x8, %r9d
setae (%rdx)
testb %r9b, %r9b
je 0x126f8
addb $-0x30, %cl
movzbl %cl, %eax
addl $0xffffff30, %eax       # imm = 0xFFFFFF30
testb %al, %al
sete (%rsi)
movb %al, (%r8)
movl %eax, %ecx
shrb $0x7, %cl
movb %cl, (%rdi)
btl $0x8, %eax
setae (%rdx)
retq
// File: /workspace/github_c_makefile_star2_O3/mist64[P]cbmbasic/runtime.c
// Function: init_os
int
init_os(int argc, char **argv) {
//	printf("init_os %d\n", argc);
	if (!argc) /* continuation */
		return PC;

	if (argc>1) {
		interactive = 0;
		input_file = fopen(argv[1], "r");
		if (!input_file) {
			printf("Error opening: %s\n", argv[1]);
			exit(1);
		}
		if (fgetc(input_file)=='#') {
			char c;
			do {
				c = fgetc(input_file);
			} while((c!=13)&&(c!=10));
		} else {
			fseek(input_file, 0, SEEK_SET);
		}
	} else {
		interactive = 1;
		input_file = NULL;
	}
	srand((unsigned int)time(NULL));

	return 0xE394; /* main entry point of BASIC */
}

// Assembly:
pushq %rbx
testl %edi, %edi
je 0x1281d
cmpl $0x2, %edi
jl 0x12829
movq %rsi, %rbx
movl $0x0, 0x1da4a(%rip)     # 0x30224
movq 0x8(%rsi), %rdi
leaq 0xb023(%rip), %rsi      # 0x1d808
callq 0x11f0
movq %rax, 0x1da37(%rip)     # 0x30228
testq %rax, %rax
je 0x12865
movq %rax, %rdi
callq 0x1110
cmpl $0x23, %eax
jne 0x12840
movq 0x1da1e(%rip), %rdi     # 0x30228
callq 0x1110
cmpb $0xa, %al
je 0x12850
movzbl %al, %eax
cmpl $0xd, %eax
jne 0x12803
jmp 0x12850
leaq 0x1d91c(%rip), %rax     # 0x30140
movzwl (%rax), %eax
jmp 0x12863
movl $0x1, 0x1d9f1(%rip)     # 0x30224
movq $0x0, 0x1d9ea(%rip) # 0x30228
jmp 0x12850
movq 0x1d9e1(%rip), %rdi     # 0x30228
xorl %esi, %esi
xorl %edx, %edx
callq 0x11e0
xorl %edi, %edi
callq 0x1190
movl %eax, %edi
callq 0x1140
movl $0xe394, %eax           # imm = 0xE394
popq %rbx
retq
movq 0x8(%rbx), %rsi
leaq 0xaf9a(%rip), %rdi      # 0x1d80a
xorl %eax, %eax
callq 0x10c0
movl $0x1, %edi
callq 0x1200
// File: /workspace/github_c_makefile_star2_O3/mist64[P]cbmbasic/runtime.c
// Function: plugin_on
void
plugin_on() {
	if (plugin)
		return;

	replace_vector(VEC_ERROR, MAGIC_ERROR, &orig_error);
	replace_vector(VEC_MAIN, MAGIC_MAIN, &orig_main);
	replace_vector(VEC_CRNCH, MAGIC_CRNCH, &orig_crnch);
	replace_vector(VEC_QPLOP, MAGIC_QPLOP, &orig_qplop);
	replace_vector(VEC_GONE, MAGIC_GONE, &orig_gone);
	replace_vector(VEC_EVAL, MAGIC_EVAL, &orig_eval);
	
	plugin = 1;
}

// Assembly:
cmpl $0x0, 0x1d98e(%rip)     # 0x30230
je 0x128a5
retq
leaq 0xd894(%rip), %rax      # 0x20140
movzwl 0x300(%rax), %ecx
movzwl 0x302(%rax), %edx
movw %cx, 0x1d973(%rip)      # 0x30234
movw %dx, 0x1d96e(%rip)      # 0x30236
movzwl 0x304(%rax), %ecx
movw %cx, 0x1d962(%rip)      # 0x30238
movzwl 0x306(%rax), %ecx
movw %cx, 0x1d956(%rip)      # 0x3023a
movabsq $-0xfc00fd00fe0100, %rcx # imm = 0xFF03FF02FF01FF00
movq %rcx, 0x300(%rax)
movzwl 0x308(%rax), %ecx
movw %cx, 0x1d939(%rip)      # 0x3023c
movzwl 0x30a(%rax), %ecx
movw %cx, 0x1d92d(%rip)      # 0x3023e
movl $0xff05ff04, 0x308(%rax) # imm = 0xFF05FF04
movl $0x1, 0x1d90b(%rip)     # 0x30230
retq
// File: /workspace/github_c_makefile_star2_O3/mist64[P]cbmbasic/plugin.c
// Function: compare
int
compare(const char *s1) {
	const unsigned char *s = (const unsigned char *)s1;
	unsigned short chrptr = get_chrptr();

	while (*s) {
		CHRGET();
		if (A != *s++) {
			set_chrptr(chrptr);
			return 0;
		}
	}
	CHRGET();
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0xc722(%rip), %r14      # 0x20140
movzwl 0x7a(%r14), %ebp
leaq 0x1c71b(%rip), %r15     # 0x30145
movb (%rbx), %r12b
callq 0x126e3
testb %r12b, %r12b
je 0x13a4e
movb (%r15), %al
leaq 0x1(%rbx), %rcx
cmpb (%rbx), %al
movq %rcx, %rbx
je 0x13a2a
movw %bp, 0x7a(%r14)
xorl %eax, %eax
jmp 0x13a53
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Tarsnap[P]libcperciva/tests/crypto_aes/main.c
// Function: perftest
static int
perftest(void)
{
	struct perftest_cookie_aes pca_actual;
	struct perftest_cookie_aes * pca = &pca_actual;
	uint8_t ciphertext_arr[16];
	size_t keylen;

	/* Sanity check. */
#ifdef CPUSUPPORT_X86_AESNI
	if (cpusupport_x86_aesni()) {
		if (crypto_aes_can_use_intrinsics() != 1) {
			warn0("Unexpected error with AESNI");
			goto err0;
		}
	}
#endif

	/* Inform user about the hardware optimization status. */
	print_hardware("Performance test of AES");
	fflush(stdout);

	/* Prepare arrays. */
	if (parse_testcase(perftestcase, &pca->key_exp, &keylen,
	    pca->plaintext_arr, ciphertext_arr)) {
		warn0("parse_testcase");
		goto err0;
	}

	/* Time the function. */
	if (perftest_buffers(nbytes_perftest, perfsizes, num_perf,
	    nbytes_warmup, 1, perftest_init, perftest_func, NULL, pca)) {
		warn0("perftest_buffers");
		goto err1;
	}

	/* Clean up. */
	crypto_aes_key_free(pca->key_exp);

	/* Success! */
	return (0);

err1:
	crypto_aes_key_free(pca->key_exp);
err0:
	/* Failure! */
	return (1);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
leaq 0x590f(%rip), %rbx      # 0x721c
cmpl $0x0, (%rbx)
je 0x1925
callq 0x1f14
cmpl $0x1, %eax
je 0x1936
leaq 0x26e7(%rip), %rdi      # 0x400a
jmp 0x198f
leaq 0x58f4(%rip), %r14      # 0x7220
cmpl $0x0, (%r14)
je 0x1a1f
leaq 0x26e9(%rip), %rdi      # 0x4026
callq 0x1c41
movq 0x56a7(%rip), %rax      # 0x6ff0
movq (%rax), %rdi
callq 0x1200
leaq 0x28(%rsp), %rdx
movq 0x5433(%rip), %rax      # 0x6d90
movq %rax, 0x10(%rsp)
movups 0x5417(%rip), %xmm0     # 0x6d80
movups %xmm0, (%rsp)
leaq 0x20(%rsp), %rbx
leaq 0x38(%rsp), %rsi
leaq 0x40(%rsp), %rcx
movq %rbx, %rdi
callq 0x1ca1
testl %eax, %eax
je 0x19b0
leaq 0x26af(%rip), %rdi      # 0x403e
xorl %eax, %eax
callq 0x34ff
callq 0x1190
movl $0x0, (%rax)
movl $0x1, %ebx
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rbx, 0x10(%rsp)
leaq 0x491(%rip), %rax       # 0x1e4d
movq %rax, (%rsp)
movq $0x0, 0x8(%rsp)
leaq 0x2938(%rip), %rsi      # 0x4308
leaq 0x446(%rip), %r9        # 0x1e1d
movl $0x1, %ebx
movl $0x40000000, %edi       # imm = 0x40000000
movl $0x1, %edx
movl $0x9896800, %ecx        # imm = 0x9896800
movl $0x1, %r8d
callq 0x2f64
testl %eax, %eax
je 0x1a3a
leaq 0x264c(%rip), %rdi      # 0x404d
xorl %eax, %eax
callq 0x34ff
callq 0x1190
movl $0x0, (%rax)
movq 0x20(%rsp), %rdi
callq 0x207f
jmp 0x19a6
callq 0x1eec
movl %eax, (%rbx)
movl $0x1, (%r14)
testl %eax, %eax
jne 0x1912
jmp 0x1936
movq 0x20(%rsp), %rdi
callq 0x207f
xorl %ebx, %ebx
jmp 0x19a6
// File: /workspace/github_c_makefile_star2_O3/Tarsnap[P]libcperciva/tests/crypto_aes/main.c
// Function: parse_testcase
static int
parse_testcase(const struct testcase testcase,
    struct crypto_aes_key ** key_exp_p, size_t * keylen_p,
    uint8_t plaintext_arr[static MAX_PLAINTEXT_LENGTH],
    uint8_t ciphertext_arr[static MAX_PLAINTEXT_LENGTH])
{
	uint8_t key_unexpanded[32]; /* We will use 16 or 32 of these bytes. */
	const size_t len = strlen(testcase.plaintext_hex) / 2;

	/* Determine key length. */
	*keylen_p = strlen(testcase.keytext_hex) / 2;

	/* Sanity check. */
	assert((*keylen_p == 16) || (*keylen_p == 32));
	assert(len == 16);

	/* Prepare the key. */
	if (unhexify(testcase.keytext_hex, key_unexpanded, *keylen_p)) {
		warn0("unhexify(%s)", testcase.keytext_hex);
		goto err0;
	}
	if ((*key_exp_p = crypto_aes_key_expand(key_unexpanded, *keylen_p))
	    == NULL) {
		warn0("crypto_aes_key_expand");
		goto err0;
	}

	/* Prepare the arrays. */
	if (unhexify(testcase.plaintext_hex, plaintext_arr, len)) {
		warn0("unhexify(%s)", testcase.plaintext_hex);
		goto err1;
	}
	if (unhexify(testcase.ciphertext_hex, ciphertext_arr, len)) {
		warn0("unhexify(%s)", testcase.ciphertext_hex);
		goto err1;
	}

	/* Clean up.  Irrelevant for a test, but it's a good habit. */
	insecure_memzero(key_unexpanded, 32);

	/* Success! */
	return (0);

err1:
	crypto_aes_key_free(*key_exp_p);
err0:
	/* Failure! */
	return (1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, 0x8(%rsp)
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq 0x78(%rsp), %r14
movq %r14, %rdi
callq 0x1120
movq %rax, %r15
movq 0x70(%rsp), %rbp
movq %rbp, %rdi
callq 0x1120
shrq %rax
movq %rax, (%r13)
cmpq $0x10, %rax
je 0x1cf1
cmpq $0x20, %rax
jne 0x1dfe
andq $-0x2, %r15
cmpq $0x20, %r15
jne 0x1ddf
leaq 0x10(%rsp), %rsi
movq %rbp, %rdi
movq %rax, %rdx
callq 0x2ea3
testl %eax, %eax
je 0x1d31
leaq 0x23d6(%rip), %rdi      # 0x40f0
movq %rbp, %rsi
xorl %eax, %eax
callq 0x34ff
callq 0x1190
movl $0x0, (%rax)
jmp 0x1d9e
movq (%r13), %rsi
leaq 0x10(%rsp), %rdi
callq 0x1fdf
movq %rax, (%rbx)
testq %rax, %rax
je 0x1db2
movl $0x10, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x2ea3
testl %eax, %eax
jne 0x1d7a
leaq 0x70(%rsp), %rax
movq 0x10(%rax), %r14
movl $0x10, %edx
movq %r14, %rdi
movq 0x8(%rsp), %rsi
callq 0x2ea3
testl %eax, %eax
je 0x1dc5
leaq 0x236f(%rip), %rdi      # 0x40f0
movq %r14, %rsi
xorl %eax, %eax
callq 0x34ff
callq 0x1190
movl $0x0, (%rax)
movq (%rbx), %rdi
callq 0x207f
movl $0x1, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2344(%rip), %rdi      # 0x40fd
xorl %eax, %eax
callq 0x34ff
jmp 0x1d24
leaq 0x543c(%rip), %rax      # 0x7208
movq (%rax), %rax
leaq 0x10(%rsp), %rdi
movl $0x20, %esi
callq *%rax
xorl %eax, %eax
jmp 0x1da3
leaq 0x23b3(%rip), %rdi      # 0x4199
leaq 0x2298(%rip), %rsi      # 0x4085
leaq 0x2298(%rip), %rcx      # 0x408c
movl $0x7e, %edx
callq 0x1090
leaq 0x2259(%rip), %rdi      # 0x405e
leaq 0x2279(%rip), %rsi      # 0x4085
leaq 0x2279(%rip), %rcx      # 0x408c
movl $0x7d, %edx
callq 0x1090
// File: /workspace/github_c_makefile_star2_O3/MersenneTwister-Lab[P]MTGP/mtgp32-fast.c
// Function: mtgp32_init_state
void mtgp32_init_state(uint32_t array[],
		      const mtgp32_params_fast_t *para, uint32_t seed) {
    int i;
    int size = para->mexp / 32 + 1;
    uint32_t hidden_seed;
    uint32_t tmp;
    hidden_seed = para->tbl[4] ^ (para->tbl[8] << 16);
    tmp = hidden_seed;
    tmp += tmp >> 16;
    tmp += tmp >> 8;
    memset(array, tmp & 0xff, sizeof(uint32_t) * size);
    array[0] = seed;
    array[1] = hidden_seed;
    for (i = 1; i < size; i++) {
	array[i] ^= UINT32_C(1812433253) * (array[i - 1]
					    ^ (array[i - 1] >> 30))
	    + i;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rdi, %rbx
movl (%rsi), %r15d
movl 0x30(%rsi), %r12d
leal 0x1f(%r15), %r14d
testl %r15d, %r15d
cmovnsl %r15d, %r14d
sarl $0x5, %r14d
shll $0x10, %r12d
xorl 0x20(%rsi), %r12d
movl %r12d, %eax
shrl $0x10, %eax
addl %r12d, %eax
movl %eax, %esi
shrl $0x8, %esi
addl %eax, %esi
movslq %r14d, %rax
leaq 0x4(,%rax,4), %rdx
callq 0x1090
movl %ebp, (%rbx)
movl %r12d, 0x4(%rbx)
cmpl $0x20, %r15d
jl 0x133b
incl %r14d
movl %r14d, %eax
movl (%rbx), %ecx
movl $0x1, %edx
movl %ecx, %esi
shrl $0x1e, %esi
xorl %ecx, %esi
imull $0x6c078965, %esi, %ecx # imm = 0x6C078965
addl %edx, %ecx
xorl (%rbx,%rdx,4), %ecx
movl %ecx, (%rbx,%rdx,4)
incq %rdx
cmpq %rdx, %rax
jne 0x131e
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MersenneTwister-Lab[P]MTGP/mtgp32-fast.c
// Function: mtgp32_print_idstring
void mtgp32_print_idstring(const mtgp32_fast_t *mtgp32, FILE *fp) {
    int i;
    fprintf(fp, "mtgp32:%d:", mtgp32->params.mexp);
    for (i = 0; i < 20; i++) {
	fprintf(fp, "%02x", (unsigned int)mtgp32->params.poly_sha1[i]);
    }
    fprintf(fp, "\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %edx
leaq 0x169a(%rip), %rsi      # 0x300c
movq %rbx, %rdi
xorl %eax, %eax
callq 0x10b0
leaq 0x1694(%rip), %r15      # 0x3017
xorl %r12d, %r12d
movzbl 0xd4(%r14,%r12), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x10b0
incq %r12
cmpq $0x14, %r12
jne 0x1986
movl $0xa, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x10a0