LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/hilbix[P]unbuffered/./tino/getopt.h
// Function: tino_getopt_flag_val
static int
tino_getopt_flag_val(struct tino_getopt_impl *p, int invert)
{
  int	*min, *max, def, val;

  min	= tino_getopt_flag_set_minmax(p->MIN_var, &p->min.i, &p->MIN_PTR_var->i);
  max	= tino_getopt_flag_set_minmax(p->MAX_var, &p->max.i, &p->MAX_PTR_var->i);
  def	= 1;
  if (invert)
    {
      int	*tmp;

      def	= 0;
      tmp	= min;
      min	= max;
      max	= tmp;
    }
  if (min && (
              !max ||
              (*min <= *max ? (p->varptr->i < *min || p->varptr->i > *max) : (p->varptr->i > *min || p->varptr->i < *max))
              )
      )
    {
      /* Jump value to MIN Value if needed
       */
      return *min;
    }

  /* Set to default value if neither min nor max given	*/
  if (!max || invert)
    return def;	/* Set to default value	*/

  val	= p->varptr->i;
  /* Increment/Decremet to MAX value
   */
  if (*max < val)
    val--;
  else if (*max > val)
    val++;

  return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x78(%rax), %edi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdx
callq 0x9460
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x7c(%rax), %edi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdx
callq 0x9460
movq %rax, -0x28(%rbp)
movl $0x1, -0x2c(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x938b
movl $0x0, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x93fc
cmpq $0x0, -0x28(%rbp)
je 0x93f1
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x28(%rbp), %rcx
cmpl (%rcx), %eax
jg 0x93cd
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x93f1
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
movq -0x28(%rbp), %rcx
cmpl (%rcx), %eax
jg 0x93f1
jmp 0x93fc
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jg 0x93f1
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
movq -0x28(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x93fc
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x9450
cmpq $0x0, -0x28(%rbp)
je 0x9409
cmpl $0x0, -0x14(%rbp)
je 0x9411
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x9450
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
movl %eax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
cmpl -0x30(%rbp), %eax
jge 0x9434
movl -0x30(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x944a
movq -0x28(%rbp), %rax
movl (%rax), %eax
cmpl -0x30(%rbp), %eax
jle 0x9448
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x944a
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hilbix[P]unbuffered/./tino/getopt.h
// Function: tino_getopt_flag_set_minmax
static int *
tino_getopt_flag_set_minmax(int is, int *a, int *b)
{
  if (b)
    return b;
  if (is && a)
    return a;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x9480
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x949f
cmpl $0x0, -0xc(%rbp)
je 0x9497
cmpq $0x0, -0x18(%rbp)
je 0x9497
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x949f
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hilbix[P]unbuffered/./tino/getopt.h
// Function: tino_getopt_print_option_name
static void
tino_getopt_print_option_name(struct tino_getopt_impl *q, int full, const char *suffix)
{
  if (!q->DD_var)
    {
      if (q->LLOPT_var)
        fputc('-', stderr);
      fputc('-', stderr);
    }
  if (full)
    fprintf(stderr, "%s", q->opt);
  else
    fprintf(stderr, "%.*s", q->optlen, q->opt);
  if (suffix)
    fprintf(stderr, "%s", suffix);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x74(%rax)
jne 0x96ef
movq -0x8(%rbp), %rax
cmpl $0x0, 0x6c(%rax)
je 0x96db
movq 0x792a(%rip), %rax      # 0x10ff8
movq (%rax), %rsi
movl $0x2d, %edi
callq 0x21a0
movq 0x7916(%rip), %rax      # 0x10ff8
movq (%rax), %rsi
movl $0x2d, %edi
callq 0x21a0
cmpl $0x0, -0xc(%rbp)
je 0x9717
movq 0x78fc(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdx
leaq 0x4582(%rip), %rsi      # 0xdc90
movb $0x0, %al
callq 0x2200
jmp 0x973e
movq 0x78da(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x48(%rax), %edx
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
leaq 0x44a8(%rip), %rsi      # 0xdbdf
movb $0x0, %al
callq 0x2200
cmpq $0x0, -0x18(%rbp)
je 0x9761
movq 0x78ac(%rip), %rax      # 0x10ff8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x4536(%rip), %rsi      # 0xdc90
movb $0x0, %al
callq 0x2200
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hilbix[P]unbuffered/./tino/proc.h
// Function: tino_fork_execO
static pid_t
tino_fork_execO(int *fds, int cnt, char * const *argv, char * const *env, int addenv, int *keepfd)
{
  pid_t	chld;

  chld = tino_fork_execE(fds, cnt, argv, env, addenv, keepfd);
  if (chld==(pid_t)-1)
    tino_exit("fork");
  return chld;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %r8d
movq -0x30(%rbp), %r9
callq 0xa1c0
movl %eax, -0x34(%rbp)
cmpl $-0x1, -0x34(%rbp)
jne 0x98b2
leaq 0x43af(%rip), %rdi      # 0xdc5a
movb $0x0, %al
callq 0x9790
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hilbix[P]unbuffered/./tino/buf.h
// Function: tino_buf_initO
static void
tino_buf_initO(TINO_BUF *buf)
{
  cDP(("(%p)", buf));
  tino_buf_resetO(buf);
  buf->max	= 0;
  buf->data	= 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
jmp 0x98fe
movq -0x8(%rbp), %rdi
callq 0xb0f0
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hilbix[P]unbuffered/unbuffered.c
// Function: start_line
static void
start_line(int verbose, int lineend)
{
  char	flg;

  if (flag_localtime || flag_utc)
    gettimeofday(&stamp, NULL);

  tino_buf_resetO(&prefix);

  add_prefix("");
  if (flag_localtime)
    add_time(localtime);
  if (flag_utc)
    add_time(gmtime);

  flg	= verbose ? '-' : lineend ? ' ' : '+';
  if (flag_verbose && producer)
    add_prefix("[%ld]", (long)producer);

  if (flag_linecount)
    {
      if (!in_line)
        line_nr++;
      add_prefix((flag_linecount==1 ? "%5d%c" : flag_linecount==2 ? "%05d%c" : "%d%c"), line_nr, flg);
    }
  else if (flag_verbose)
    add_prefix("%c", flg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, 0x793f(%rip)      # 0x11284
jne 0x9950
cmpl $0x0, 0x796e(%rip)      # 0x112bc
je 0x9960
leaq 0x79f1(%rip), %rdi      # 0x11348
xorl %eax, %eax
movl %eax, %esi
callq 0x2140
leaq 0x79c1(%rip), %rdi      # 0x11328
callq 0xb0f0
leaq 0x3b80(%rip), %rdi      # 0xd4f3
movb $0x0, %al
callq 0x9a90
cmpl $0x0, 0x7903(%rip)      # 0x11284
je 0x998f
movq 0x762e(%rip), %rdi      # 0x10fb8
callq 0xb150
cmpl $0x0, 0x7926(%rip)      # 0x112bc
je 0x99a4
movq 0x7641(%rip), %rdi      # 0x10fe0
callq 0xb150
cmpl $0x0, -0x4(%rbp)
je 0x99b4
movl $0x2d, %eax
movl %eax, -0x10(%rbp)
jmp 0x99ca
movl -0x8(%rbp), %edx
movl $0x2b, %eax
movl $0x20, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movb %al, -0x9(%rbp)
cmpl $0x0, 0x78e9(%rip)      # 0x112c0
je 0x99f7
cmpl $0x0, 0x7900(%rip)      # 0x112e0
je 0x99f7
movslq 0x78f7(%rip), %rsi      # 0x112e0
leaq 0x442d(%rip), %rdi      # 0xde1d
movb $0x0, %al
callq 0x9a90
cmpl $0x0, 0x788e(%rip)      # 0x1128c
je 0x9a64
cmpl $0x0, 0x7951(%rip)      # 0x11358
jne 0x9a18
movl 0x794d(%rip), %eax      # 0x1135c
addl $0x1, %eax
movl %eax, 0x7944(%rip)      # 0x1135c
cmpl $0x1, 0x786d(%rip)      # 0x1128c
jne 0x9a2e
leaq 0x43fb(%rip), %rax      # 0xde23
movq %rax, -0x18(%rbp)
jmp 0x9a4d
movl 0x7858(%rip), %edx      # 0x1128c
leaq 0x43f5(%rip), %rax      # 0xde30
leaq 0x43e7(%rip), %rcx      # 0xde29
cmpl $0x2, %edx
cmoveq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl 0x7905(%rip), %esi      # 0x1135c
movsbl -0x9(%rbp), %edx
movb $0x0, %al
callq 0x9a90
jmp 0x9a81
cmpl $0x0, 0x7855(%rip)      # 0x112c0
je 0x9a7f
movsbl -0x9(%rbp), %esi
leaq 0x43ba(%rip), %rdi      # 0xde32
movb $0x0, %al
callq 0x9a90
jmp 0x9a81
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hilbix[P]unbuffered/unbuffered.c
// Function: add_prefix
static void
add_prefix(const char *what, ...)
{
  tino_va_list	list;

  if (!tino_buf_get_lenO(&prefix))
    {
      const char *p= in_line ? line_cont_prefix : line_prefix;
      if (p && *p)
        tino_buf_add_sO(&prefix, p);
    }
  tino_va_start(list, what);
  tino_buf_add_vsprintfO(&prefix, &list);
  tino_va_end(list);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x9ac8
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rsi, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
leaq 0x7832(%rip), %rdi      # 0x11328
callq 0x3410
cmpq $0x0, %rax
jne 0x9b58
cmpl $0x0, 0x7850(%rip)      # 0x11358
je 0x9b1a
movq 0x7797(%rip), %rax      # 0x112a8
movq %rax, -0xe8(%rbp)
jmp 0x9b28
movq 0x7777(%rip), %rax      # 0x11298
movq %rax, -0xe8(%rbp)
movq -0xe8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x9b56
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x9b56
movq -0x30(%rbp), %rsi
leaq 0x77d7(%rip), %rdi      # 0x11328
callq 0xb220
jmp 0x9b58
jmp 0x9b5a
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rax
addq $0x8, %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
leaq 0x7797(%rip), %rdi      # 0x11328
leaq -0x28(%rbp), %rsi
callq 0xb270
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hilbix[P]unbuffered/unbuffered.c
// Function: out_open
static void
out_open(void)
{
  if (out_is_open)
    return;
  if (!append_file)
    {
      tino_data_fileA(&out, fd_out>=0 ? fd_out : flag_cat ? 1 : 2);
      out_is_open = -1;
    }
  else
    {
      tino_data_fileA(&out, tino_file_open_createE(append_file, O_APPEND|O_WRONLY, 0666));
      out_is_open	= 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0x0, 0x77a1(%rip)      # 0x11360
je 0x9bc6
jmp 0x9c46
cmpq $0x0, 0x769a(%rip)      # 0x11268
jne 0x9c18
cmpl $0x0, 0x76b9(%rip)      # 0x11290
jl 0x9be4
movl 0x76b1(%rip), %eax      # 0x11290
movl %eax, -0x4(%rbp)
jmp 0x9bfd
movl 0x768a(%rip), %edx      # 0x11274
movl $0x2, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %esi
leaq 0x76e1(%rip), %rdi      # 0x112e8
callq 0xb360
movl $0xffffffff, 0x774a(%rip) # imm = 0xFFFFFFFF
jmp 0x9c46
movq 0x7649(%rip), %rdi      # 0x11268
movl $0x401, %esi            # imm = 0x401
movl $0x1b6, %edx            # imm = 0x1B6
callq 0xb3d0
movl %eax, %esi
leaq 0x76b1(%rip), %rdi      # 0x112e8
callq 0xb360
movl $0x1, 0x771a(%rip)      # 0x11360
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hilbix[P]unbuffered/./tino/buf.h
// Function: tino_buf_get_sN
static const char *
tino_buf_get_sN(TINO_BUF *buf)
{
  cDP(("(%p)", buf));
  if (!buf)
    return 0;
  if (!buf->fill)
    return "";
  if (buf->fill>=buf->max)
    tino_buf_extendO(buf, 1);
  buf->data[buf->fill]	= 0;
  cDP(("() '%s'", buf->data+buf->off));
  return buf->data+buf->off;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
jmp 0x9c9e
cmpq $0x0, -0x10(%rbp)
jne 0x9caf
movq $0x0, -0x8(%rbp)
jmp 0x9d0e
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x9cc6
leaq 0x3833(%rip), %rax      # 0xd4f3
movq %rax, -0x8(%rbp)
jmp 0x9d0e
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x9ce5
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x3980
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x9cfa
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
addq 0x10(%rcx), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hilbix[P]unbuffered/./tino/buf.h
// Function: tino_buf_readE
static int
tino_buf_readE(TINO_BUF *buf, int fd, int max)
{
  char	*ptr;
  int	got;

  cDP(("(%p,%d,%d)", buf, fd, max));
  if (max<0)
    max	= BUFSIZ*10;
  ptr	= tino_buf_add_ptrO(buf, max);
  got	= tino_file_readE(fd, ptr, max);
  if (got>0)
    buf->fill	+= got;
  cDP(("() %d", got));
  return got;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
jmp 0x9d54
cmpl $0x0, -0x10(%rbp)
jge 0x9d61
movl $0x14000, -0x10(%rbp)   # imm = 0x14000
movq -0x8(%rbp), %rdi
movslq -0x10(%rbp), %rsi
callq 0x3550
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
movslq -0x10(%rbp), %rdx
callq 0xb710
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jle 0x9d99
movslq -0x1c(%rbp), %rcx
movq -0x8(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x9d9b
jmp 0x9d9d
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hilbix[P]unbuffered/unbuffered.c
// Function: dump_line
static void
dump_line(const char *ptr, size_t n, int lineend)
{
  const char		*p;

  start_line(0, lineend);
  p = tino_buf_get_sN(&prefix);

  if (flag_hexdump)
    tino_xd(&out, p, 8, byte_pos, (const unsigned char *)ptr, n+lineend);
  else
    {
      if (p && *p)
        tino_data_putsA(&out, p);
#ifdef HAVE_ESCAPE_XML
      if (flag_xml)
        tino_data_write_xmlA(&out, ptr, n, flag_xml-1);
      else
#endif
#ifdef HAVE_ESCAPE_JSON
      if (flag_json)
        tino_data_write_jsonA(&out, ptr, n);
      else
#endif
        tino_data_writeA(&out, ptr, n);
    }

  byte_pos	+= n+lineend;

  in_line	= !lineend;
  p		= in_line ? line_cont_suffix : line_suffix;
  if (!p && !flag_hexdump)
    p		= "\n";
  if (p && *p)
    tino_data_putsA(&out, p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %esi
xorl %edi, %edi
callq 0x9930
leaq 0x7554(%rip), %rdi      # 0x11328
callq 0x9c90
movq %rax, -0x20(%rbp)
cmpl $0x0, 0x74e4(%rip)      # 0x112c8
je 0x9e16
movq -0x20(%rbp), %rsi
movq 0x7577(%rip), %rcx      # 0x11368
movq -0x8(%rbp), %r8
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rdx
addq %rdx, %rax
movl %eax, %r9d
leaq 0x74de(%rip), %rdi      # 0x112e8
movl $0x8, %edx
callq 0xb760
jmp 0x9e4d
cmpq $0x0, -0x20(%rbp)
je 0x9e39
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x9e39
movq -0x20(%rbp), %rsi
leaq 0x74b4(%rip), %rdi      # 0x112e8
callq 0x9c50
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0x74a0(%rip), %rdi      # 0x112e8
callq 0xb580
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
addq %rcx, %rax
addq 0x7509(%rip), %rax      # 0x11368
movq %rax, 0x7502(%rip)      # 0x11368
cmpl $0x0, -0x14(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x74de(%rip)      # 0x11358
cmpl $0x0, 0x74d7(%rip)      # 0x11358
je 0x9e90
movq 0x7416(%rip), %rax      # 0x112a0
movq %rax, -0x28(%rbp)
jmp 0x9e9b
movq 0x7419(%rip), %rax      # 0x112b0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x9ebe
cmpl $0x0, 0x7417(%rip)      # 0x112c8
jne 0x9ebe
leaq 0x3357(%rip), %rax      # 0xd211
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x9ee1
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x9ee1
movq -0x20(%rbp), %rsi
leaq 0x740c(%rip), %rdi      # 0x112e8
callq 0x9c50
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hilbix[P]unbuffered/./tino/buf.h
// Function: tino_buf_write_away_allE
static int
tino_buf_write_away_allE(TINO_BUF *buf, int fd, int max)
{
  cDP(("(%p,%d,%d)", buf, fd, max));
  for (;;)
    {
      int	len, put;

      len	= tino_buf_get_lenO(buf);
      if (max>=0 && len>max)
	len	= max;
      if (!len)
	{
	  cDP(("() 0"));
	  return 0;
	}
      cDP(("() write %d", len));
      if ((put=TINO_F_write(fd, tino_buf_getN(buf), len))>0)
	{
	  max	-= put;
	  tino_buf_advanceO(buf, put);
	}
      else if (!put)
	{
	  cDP(("() 1"));
	  return 1;
	}
      else if (errno!=EINTR && errno!=EAGAIN)
	{
	  cDP(("() -1"));
	  return -1;
	}
#ifdef TINO_ALARM_RUN
      else
	TINO_ALARM_RUN();
#endif
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
jmp 0x9f54
jmp 0x9f56
movq -0x10(%rbp), %rdi
callq 0x3410
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x9f76
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jle 0x9f76
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x9f8c
jmp 0x9f7e
jmp 0x9f80
movl $0x0, -0x4(%rbp)
jmp 0xa00c
jmp 0x9f8e
jmp 0x9f90
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3450
movl -0x24(%rbp), %edi
movq %rax, %rsi
movslq -0x1c(%rbp), %rdx
callq 0x20d0
movl %eax, -0x20(%rbp)
cmpl $0x0, %eax
jle 0x9fcf
movl -0x20(%rbp), %ecx
movl -0x18(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x9ef0
jmp 0xa007
cmpl $0x0, -0x20(%rbp)
jne 0x9fe2
jmp 0x9fd7
jmp 0x9fd9
movl $0x1, -0x4(%rbp)
jmp 0xa00c
callq 0x2060
cmpl $0x4, (%rax)
je 0xa003
callq 0x2060
cmpl $0xb, (%rax)
je 0xa003
jmp 0x9ff8
jmp 0x9ffa
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa00c
jmp 0xa005
jmp 0xa007
jmp 0x9f56
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hilbix[P]unbuffered/unbuffered.c
// Function: out_close
static void
out_close(void)
{
  if (!out_is_open)
    return;
  tino_data_freeA(&out);
  out_is_open	= 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x0, 0x72b5(%rip)      # 0x11360
jne 0xa0af
jmp 0xa0c5
leaq 0x7232(%rip), %rdi      # 0x112e8
callq 0xbd40
movl $0x0, 0x729b(%rip)      # 0x11360
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hilbix[P]unbuffered/./tino/file.h
// Function: tino_file_close_on_execE
static int
tino_file_close_on_execE(int fd, int close_on_exec)
{
  int	flag, upd;

  flag	= TINO_F_fcntl(fd, F_GETFD);
  if (flag==-1)
    return -1;
  if (close_on_exec>=0)
    {
      upd	= close_on_exec ? (flag|FD_CLOEXEC) : (flag&~FD_CLOEXEC);
      if (flag!=upd && TINO_F_fcntl(fd, F_SETFD, upd))
        return -1;
    }
  return flag&O_CLOEXEC;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0x8(%rbp), %edi
movl $0x1, %esi
movb $0x0, %al
callq 0x2290
movl %eax, -0x10(%rbp)
cmpl $-0x1, -0x10(%rbp)
jne 0xa14f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa1aa
cmpl $0x0, -0xc(%rbp)
jl 0xa19f
cmpl $0x0, -0xc(%rbp)
je 0xa166
movl -0x10(%rbp), %eax
orl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xa16f
movl -0x10(%rbp), %eax
andl $-0x2, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0xa19d
movl -0x8(%rbp), %edi
movl -0x14(%rbp), %edx
movl $0x2, %esi
movb $0x0, %al
callq 0x2290
cmpl $0x0, %eax
je 0xa19d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa1aa
jmp 0xa19f
movl -0x10(%rbp), %eax
andl $0x80000, %eax          # imm = 0x80000
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hilbix[P]unbuffered/./tino/proc.h
// Function: tino_fork_exec_sidE
static pid_t
tino_fork_exec_sidE(int *fds, int cnt, char * const *argv, char * const *env, int addenv, int *keepfd, int sid)
{
  pid_t	chld;

  cDP(("(%p(%d)[%d,%d,%d], %p, %p, %d)", fds,cnt,fds[0],fds[1],fds[2], argv, env, addenv));
  if ((chld=fork())==0)
    {
      if (sid)
        setsid();

      tino_fd_move(fds, cnt);
      tino_fd_keep(3, keepfd);
      if (env && !addenv)
        {
          cDP(("() child execve(%s,%p,%p)", *argv, argv, env));
          execve(*argv, argv, env);
        }
      else
        {
          if (addenv)
            while (*env)
              {
                cDP(("() child putenv: %s", *env));
                putenv(*env++);
              }
          cDP(("() child execvp(%s,%p)", *argv, argv));
          execvp(*argv, argv);
        }
      cDP(("() child failed"));
      tino_exit_n(127, "execvp(%s)", *argv);
    }
  cDP(("() chl=%d", (int)chld));
  return chld;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
jmp 0xa234
callq 0x2330
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
jne 0xa2f4
cmpl $0x0, 0x10(%rbp)
je 0xa250
callq 0x2190
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xa310
movq -0x30(%rbp), %rsi
movl $0x3, %edi
callq 0xa730
cmpq $0x0, -0x20(%rbp)
je 0xa291
cmpl $0x0, -0x24(%rbp)
jne 0xa291
jmp 0xa279
jmp 0xa27b
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x21c0
jmp 0xa2d6
cmpl $0x0, -0x24(%rbp)
je 0xa2c2
jmp 0xa299
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0xa2c0
jmp 0xa2a5
jmp 0xa2a7
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x20(%rbp)
movq (%rax), %rdi
callq 0x21e0
jmp 0xa299
jmp 0xa2c2
jmp 0xa2c4
jmp 0xa2c6
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x22d0
jmp 0xa2d8
jmp 0xa2da
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movl $0x7f, %edi
leaq 0x3972(%rip), %rsi      # 0xdc5f
movb $0x0, %al
callq 0xa7e0
jmp 0xa2f6
jmp 0xa2f8
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hilbix[P]unbuffered/./tino/proc.h
// Function: tino_fd_keep
static void
tino_fd_keep(int start, int *fds)
{
  unsigned	pos;

  if (!fds)
    return;

  if (start<0)
    start	= 0;

  for (pos=start;;)
    {
      unsigned	max;
      int	*p;

      max	= (unsigned)-1;
      for (p=fds; *p>0; p++)
        if ((unsigned)*p>pos && (unsigned)*p<max)
          max	= *p;
      if (max==(unsigned)-1)
        break;
      while (++pos<max)
        {
          cDP(("close %d", pos));
          close(pos);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xa74b
jmp 0xa7cd
cmpl $0x0, -0x4(%rbp)
jge 0xa758
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
jle 0xa7a5
movq -0x20(%rbp), %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jbe 0xa795
movq -0x20(%rbp), %rax
movl (%rax), %eax
cmpl -0x18(%rbp), %eax
jae 0xa795
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
jmp 0xa797
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
jmp 0xa76d
cmpl $-0x1, -0x18(%rbp)
jne 0xa7ad
jmp 0xa7cd
jmp 0xa7af
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl -0x18(%rbp), %eax
jae 0xa7cb
jmp 0xa7bf
jmp 0xa7c1
movl -0x14(%rbp), %edi
callq 0x2170
jmp 0xa7af
jmp 0xa75e
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hilbix[P]unbuffered/./tino/signals.h
// Function: tino_sigaction
static void
tino_sigaction(int sig, tino_sighandler_t fn)
{
  struct sigaction	sa;

  memset(&sa, 0, sizeof sa);
  sa.sa_handler	= (TINO_T_sighandler_t)fn;

  if (sigaction(sig, &sa, NULL))
    tino_fatal("sigaction");
  tino_sigfix(sig);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0xa8(%rbp), %rdi
xorl %esi, %esi
movl $0x98, %edx
callq 0x2150
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
movl -0x4(%rbp), %edi
leaq -0xa8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x20b0
cmpl $0x0, %eax
je 0xa8d6
leaq 0x3433(%rip), %rdi      # 0xdd02
movb $0x0, %al
callq 0x35e0
movl -0x4(%rbp), %edi
callq 0xa8f0
addq $0xb0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hilbix[P]unbuffered/./tino/signals.h
// Function: tino_sigprocmask_1
static void
tino_sigprocmask_1(int how, int sig)
{
  sigset_t	sigs;

  if (sigemptyset(&sigs) ||
      sigaddset(&sigs, sig))
    tino_fatal("sigsetops");
  if (sigprocmask(how, &sigs, NULL))
    tino_fatal("sigprocmask");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x2210
cmpl $0x0, %eax
jne 0xa9d6
movl -0x8(%rbp), %esi
leaq -0x88(%rbp), %rdi
callq 0x2320
cmpl $0x0, %eax
je 0xa9e4
leaq 0x333c(%rip), %rdi      # 0xdd19
movb $0x0, %al
callq 0x35e0
movl -0x4(%rbp), %edi
leaq -0x88(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2040
cmpl $0x0, %eax
je 0xaa0a
leaq 0x3320(%rip), %rdi      # 0xdd23
movb $0x0, %al
callq 0x35e0
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hilbix[P]unbuffered/unbuffered.c
// Function: terminate
static void
terminate()
{
  int	status;
  pid_t	pid;

  /* Be sure not to re-enter waitpid()!	*/
  while ((pid=tino_wait_child_poll(&status, NULL))!=0)
    if (pid==consumer)
      exit(status);	/* Premature termination of consumer	*/
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0x4(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xaa60
movl %eax, -0x8(%rbp)
cmpl $0x0, %eax
je 0xaa52
movl -0x8(%rbp), %eax
cmpl 0x689e(%rip), %eax      # 0x112e4
jne 0xaa50
movl -0x4(%rbp), %edi
callq 0x22e0
jmp 0xaa28
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hilbix[P]unbuffered/./tino/proc.h
// Function: tino_wait_child_poll
static pid_t
tino_wait_child_poll(int *stat, char **cause)
{
  int	status, ret;
  pid_t	child;

  child	= 0;
  if (tino_wait_child_p(&child, 0l, &status))
    return 0;	/* t_w_c_p returned 1	*/
  ret	= tino_wait_child_status(status, cause);
  if (stat)
    *stat	= ret;
  return child;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
leaq -0x24(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq -0x1c(%rbp), %rdx
callq 0xaad0
cmpl $0x0, %eax
je 0xaa96
movl $0x0, -0x4(%rbp)
jmp 0xaabb
movl -0x1c(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0xac40
movl %eax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xaab5
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hilbix[P]unbuffered/./tino/proc.h
// Function: tino_wait_child_p
static int
tino_wait_child_p(pid_t *child, long timeout, int *status)
{
  time_t	now;
  pid_t		pid;
  long		delta;

  cDP(("(%p(%d), %ld, %p)", child, child ? *child : 0, timeout, status));
  if (timeout>0)
    time(&now);
  delta	= timeout;
  for (;;)
    {
      cDP(("() loop"));
      if (timeout>0)
        {
          if (delta>10000)
            delta	= 10000;
          cDP(("() timeout=%ld", delta));
          alarm(delta);
        }
      pid	= waitpid((pid_t)-1, status, (!timeout ? WNOHANG : 0));
      if (timeout>0)
        alarm(0);
      if (!pid)
        {
          cDP(("() !pid"));
          return 1;
        }
      cDP(("() pid=%d", (int)pid));
      if (pid!=(pid_t)-1)
        {
          if (!child || pid==*child)
            break;
          if (*child==0)
            {
              *child	= pid;
              break;
            }
        }
      else
        {
          if (errno!=EINTR)
            TINO_EXIT(("wait"));
        }
      if (timeout>0)
        {
          time_t	then;

          time(&then);
          if ((delta=(long)(then-now))>=timeout)
            return -1;
          delta	= timeout-delta;
        }
    }
  cDP(("() ok"));
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
jmp 0xaae6
cmpq $0x0, -0x18(%rbp)
jle 0xaaf6
leaq -0x28(%rbp), %rdi
callq 0x2240
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0xab00
jmp 0xab02
cmpq $0x0, -0x18(%rbp)
jle 0xab2a
cmpq $0x2710, -0x38(%rbp)    # imm = 0x2710
jle 0xab1b
movq $0x2710, -0x38(%rbp)    # imm = 0x2710
jmp 0xab1d
jmp 0xab1f
movq -0x38(%rbp), %rax
movl %eax, %edi
callq 0x2160
movq -0x20(%rbp), %rsi
cmpq $0x0, -0x18(%rbp)
setne %cl
xorb $-0x1, %cl
xorl %edx, %edx
movl $0x1, %eax
testb $0x1, %cl
cmovnel %eax, %edx
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x22b0
movl %eax, -0x2c(%rbp)
cmpq $0x0, -0x18(%rbp)
jle 0xab61
xorl %edi, %edi
callq 0x2160
cmpl $0x0, -0x2c(%rbp)
jne 0xab77
jmp 0xab69
jmp 0xab6b
movl $0x1, -0x4(%rbp)
jmp 0xac2b
jmp 0xab79
jmp 0xab7b
cmpl $-0x1, -0x2c(%rbp)
je 0xabae
cmpq $0x0, -0x10(%rbp)
je 0xab93
movl -0x2c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jne 0xab98
jmp 0xac20
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0xabac
movl -0x2c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
jmp 0xac20
jmp 0xabe4
callq 0x2060
cmpl $0x4, (%rax)
je 0xabe2
jmp 0xabba
leaq 0x30a9(%rip), %rdi      # 0xdc6a
movl $0x14a, %esi            # imm = 0x14A
leaq 0x3162(%rip), %rdx      # 0xdd2f
callq 0x3ff0
leaq 0x3168(%rip), %rdi      # 0xdd41
movb $0x0, %al
callq 0x9790
jmp 0xabe2
jmp 0xabe4
cmpq $0x0, -0x18(%rbp)
jle 0xac1b
leaq -0x40(%rbp), %rdi
callq 0x2240
movq -0x40(%rbp), %rax
subq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq -0x18(%rbp), %rax
jl 0xac0f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xac2b
movq -0x18(%rbp), %rax
subq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0xaafe
jmp 0xac22
jmp 0xac24
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hilbix[P]unbuffered/./tino/proc.h
// Function: tino_wait_child_status
static int
tino_wait_child_status(int status, char **cause)
{
  int	core;
  char	*str;

  str	= "exited";
  core	= 0;
#ifdef WCOREDUMP
  if (WCOREDUMP(status))
    {
      str	= "dumped core";
      core	= 1;
    }
#endif
  if (WIFEXITED(status))
    {
      if (cause)
        *cause	= tino_str_printf("%s with status %d", str, WEXITSTATUS(status));
      return WEXITSTATUS(status);
    }
  if (WIFSIGNALED(status))
    {
      if (cause)
        *cause	= tino_str_printf("%s with signal %d", str, WTERMSIG(status));
      return -1;
    }
  if (core)
    {
      if (cause)
        *cause	= tino_str_printf("%s (unknown cause)", str);
      return -2;
    }
  if (cause)
    *cause	= tino_str_printf("%s by unknown cause", str);
  return -3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x30f0(%rip), %rax      # 0xdd46
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x8(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0xac80
leaq 0x30d8(%rip), %rax      # 0xdd4d
movq %rax, -0x20(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x8(%rbp), %eax
andl $0x7f, %eax
cmpl $0x0, %eax
jne 0xaccd
cmpq $0x0, -0x10(%rbp)
je 0xacba
movq -0x20(%rbp), %rsi
movl -0x8(%rbp), %edx
andl $0xff00, %edx           # imm = 0xFF00
sarl $0x8, %edx
leaq 0x30b0(%rip), %rdi      # 0xdd59
movb $0x0, %al
callq 0xad80
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x8(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
movl %eax, -0x4(%rbp)
jmp 0xad6e
movl -0x8(%rbp), %eax
andl $0x7f, %eax
addl $0x1, %eax
movsbl %al, %eax
sarl %eax
cmpl $0x0, %eax
jle 0xad12
cmpq $0x0, -0x10(%rbp)
je 0xad09
movq -0x20(%rbp), %rsi
movl -0x8(%rbp), %edx
andl $0x7f, %edx
leaq 0x3073(%rip), %rdi      # 0xdd6b
movb $0x0, %al
callq 0xad80
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xad6e
cmpl $0x0, -0x14(%rbp)
je 0xad44
cmpq $0x0, -0x10(%rbp)
je 0xad3b
movq -0x20(%rbp), %rsi
leaq 0x3053(%rip), %rdi      # 0xdd7d
movb $0x0, %al
callq 0xad80
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0xad6e
cmpq $0x0, -0x10(%rbp)
je 0xad67
movq -0x20(%rbp), %rsi
leaq 0x303a(%rip), %rdi      # 0xdd90
movb $0x0, %al
callq 0xad80
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hilbix[P]unbuffered/./tino/strprintf.h
// Function: tino_str_vprintf_buf
static char *
tino_str_vprintf_buf(char **buf, TINO_VA_LIST orig)
{
  char	*tmp;

  tmp	= tino_str_vprintf_null(orig);
  if (!tmp)
    TINO_FATAL(("out of memory allocating string for %s", TINO_VA_STR(orig)));
  if (buf)
    *buf	= tmp;
  return tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xaed0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xaea5
jmp 0xae76
leaq 0x2f27(%rip), %rdi      # 0xdda4
movl $0x49, %esi
leaq 0x2f2e(%rip), %rdx      # 0xddb7
callq 0x3ff0
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0x2f30(%rip), %rdi      # 0xddcc
movb $0x0, %al
callq 0x35e0
jmp 0xaea5
cmpq $0x0, -0x8(%rbp)
je 0xaeb7
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hilbix[P]unbuffered/./tino/strprintf.h
// Function: tino_str_vprintf_null
static char *
tino_str_vprintf_null(TINO_VA_LIST list)
{
  int	n;

  n	= BUFSIZ;
  for (;;)
    {
      char	*tmp;
      int	k;

      tmp	= (char *)tino_mallocN(n);
      if (!tmp)
	return 0;

      k	= tino_vsnprintf(tmp, n, list);
      tino_FATAL(k<0);
      if (++k<=n)
	return (char *)tino_realloc_downsizeO(tmp, k);

      tino_freeO(tmp);
      /* There is a bug in older libraries.
       * vsnprintf does not return the size needed,
       * instead it returns max.
       * We cannot distinguish between this case and the case,
       * that just the space for the \0 is missing.
       * Therefor we define to always extend buffer by BUFSIZ at minimum.
       */
      k	-= n;
      if (k<BUFSIZ)
	k	= BUFSIZ;
      n	+= k;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x2000, -0x14(%rbp)    # imm = 0x2000
movslq -0x14(%rbp), %rdi
callq 0xafa0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xaf04
movq $0x0, -0x8(%rbp)
jmp 0xaf92
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0xafd0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0xaf3d
leaq 0x2ece(%rip), %rdi      # 0xddf3
leaq 0x2e78(%rip), %rsi      # 0xdda4
movl $0x2f, %edx
leaq 0x2ebf(%rip), %rcx      # 0xddf7
callq 0x3510
jmp 0xaf3f
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
cmpl -0x14(%rbp), %eax
jg 0xaf60
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0xb060
movq %rax, -0x8(%rbp)
jmp 0xaf92
movq -0x20(%rbp), %rdi
callq 0xb0b0
movl -0x14(%rbp), %ecx
movl -0x24(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x24(%rbp)
cmpl $0x2000, -0x24(%rbp)    # imm = 0x2000
jge 0xaf84
movl $0x2000, -0x24(%rbp)    # imm = 0x2000
movl -0x24(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0xaee3
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hilbix[P]unbuffered/./tino/alloc.h
// Function: tino_mallocN
static void *
tino_mallocN(size_t len)
{
  void	*tmp;

  xDP(("(%ld)", (long)len));
  tmp	= malloc(len);
  xDP(("() %p", tmp));
  return tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
jmp 0xafae
movq -0x8(%rbp), %rdi
callq 0x2250
movq %rax, -0x10(%rbp)
jmp 0xafbd
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hilbix[P]unbuffered/./tino/arg.h
// Function: tino_vsnprintf
static int
tino_vsnprintf(char *buf, size_t max, TINO_VA_LIST list)
{
  tino_va_list	list2;
  int		n;

  tino_va_copy(list2, *list);
  n	= vsnprintf(buf, max, tino_va_str(list2), tino_va_get(list2));
  tino_va_end(list2);
  if (max>0)
    buf[max-1]	= 0;
  return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rax
addq $0x8, %rax
movq -0x18(%rbp), %rcx
addq $0x8, %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movups (%rcx), %xmm0
movups %xmm0, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq -0x38(%rbp), %rcx
addq $0x8, %rcx
callq 0x20c0
movl %eax, -0x3c(%rbp)
leaq -0x38(%rbp), %rax
addq $0x8, %rax
cmpq $0x0, -0x10(%rbp)
jbe 0xb048
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
movl -0x3c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hilbix[P]unbuffered/./tino/alloc.h
// Function: tino_realloc_downsizeO
static void *
tino_realloc_downsizeO(void *ptr, size_t len)
{
  void	*tmp;

  xDP(("(%p,%ld)", ptr, (long)len));
  tmp	= realloc(ptr, len);
  xDP(("() %p", tmp));
  return tmp ? tmp : ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0xb072
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2270
movq %rax, -0x18(%rbp)
jmp 0xb085
cmpq $0x0, -0x18(%rbp)
je 0xb096
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0xb09e
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hilbix[P]unbuffered/./tino/alloc.h
// Function: tino_freeO
static void
tino_freeO(void *p)
{
  int	e;

  if (!p)
    return;
  e	= errno;
  free(p);
  errno	= e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xb0c5
jmp 0xb0e8
callq 0x2060
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2050
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
callq 0x2060
movl -0x10(%rbp), %ecx
movl %ecx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hilbix[P]unbuffered/./tino/buf.h
// Function: tino_buf_resetO
static TINO_BUF *
tino_buf_resetO(TINO_BUF *buf)
{
  tino_FATAL(!buf);

  cDP(("(%p)", buf));
  buf->fill	= 0;
  buf->off	= 0;
  return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xb122
leaq 0x1f1d(%rip), %rdi      # 0xd027
leaq 0x1ee0(%rip), %rsi      # 0xcff1
movl $0x81, %edx
leaq 0x2cf0(%rip), %rcx      # 0xde0d
callq 0x3510
jmp 0xb124
jmp 0xb126
jmp 0xb128
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hilbix[P]unbuffered/unbuffered.c
// Function: add_time
static void
add_time(struct tm *fn(const time_t *timep))
{
  struct tm	*tm;

  tm	= fn(&stamp.tv_sec);
  if (flag_micro)
    add_prefix("[%04d%02d%02d-%02d%02d%02d-%06ld]", 1900+tm->tm_year, 1+tm->tm_mon, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec, stamp.tv_usec);
  else
    add_prefix("[%04d%02d%02d-%02d%02d%02d]", 1900+tm->tm_year, 1+tm->tm_mon, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x61e5(%rip), %rdi      # 0x11348
callq *-0x8(%rbp)
movq %rax, -0x10(%rbp)
cmpl $0x0, 0x6117(%rip)      # 0x11288
je 0xb1c8
movq -0x10(%rbp), %rax
movl 0x14(%rax), %esi
addl $0x76c, %esi            # imm = 0x76C
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edx
addl $0x1, %edx
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x10(%rbp), %rax
movl 0x8(%rax), %r8d
movq -0x10(%rbp), %rax
movl 0x4(%rax), %r9d
movq -0x10(%rbp), %rax
movl (%rax), %r10d
movq 0x61a1(%rip), %rax      # 0x11350
leaq 0x2c7f(%rip), %rdi      # 0xde35
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x9a90
jmp 0xb20d
movq -0x10(%rbp), %rax
movl 0x14(%rax), %esi
addl $0x76c, %esi            # imm = 0x76C
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edx
addl $0x1, %edx
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x10(%rbp), %rax
movl 0x8(%rax), %r8d
movq -0x10(%rbp), %rax
movl 0x4(%rax), %r9d
movq -0x10(%rbp), %rax
movl (%rax), %eax
leaq 0x2c54(%rip), %rdi      # 0xde57
movl %eax, (%rsp)
movb $0x0, %al
callq 0x9a90
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hilbix[P]unbuffered/./tino/buf_printf.h
// Function: tino_buf_vprintfO
static const char *
tino_buf_vprintfO(TINO_BUF *buf, TINO_VA_LIST list)
{
  cDP(("tino_buf_vprintf(%p,'%s',%ld)", buf, TINO_VA_STR(list), list));
  tino_buf_add_ptrO(buf, strlen(TINO_VA_STR(list))+1);
  for (;;)
    {
      int	out, max;

      max	= buf->max-buf->fill;
      out	= tino_vsnprintf(buf->data+buf->fill, max, list);
      tino_FATAL(out<0);
      if (out<max)
	{
	  buf->fill	+= out;
	  return buf->data+buf->off;
	}
      /* There is a bug in older libraries.
       * vsnprintf does not return the size needed,
       * instead it returns max.
       * We cannot distinguish between this case and the case,
       * that just the space for the \0 is missing.
       * Therefor we define to always extend buffer by BUFSIZ at minimum.
       */
      out	= out-max+1;
      if (out<BUFSIZ)
	out	= BUFSIZ;
      tino_buf_extendO(buf, out);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0xb282
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x20e0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
addq $0x1, %rsi
callq 0x3550
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
subq (%rcx), %rax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
addq (%rax), %rdi
movslq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0xafd0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0xb2fc
leaq 0x2b8f(%rip), %rdi      # 0xde73
leaq 0x2b8e(%rip), %rsi      # 0xde79
movl $0x2e, %edx
leaq 0x2b96(%rip), %rcx      # 0xde8d
callq 0x3510
jmp 0xb2fe
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0xb32a
movslq -0x14(%rbp), %rcx
movq -0x8(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
addq 0x10(%rcx), %rax
addq $0x20, %rsp
popq %rbp
retq
movl -0x14(%rbp), %eax
subl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x2000, -0x14(%rbp)    # imm = 0x2000
jge 0xb346
movl $0x2000, -0x14(%rbp)    # imm = 0x2000
movq -0x8(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x3980
jmp 0xb2a6
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hilbix[P]unbuffered/./tino/data.h
// Function: tino_data_fileA
static TINO_DATA *
tino_data_fileA(TINO_DATA *d, int fd)
{
  if (fd<0)
    {
      tino_data_error(d, "file open error");
      return d;
    }
  return tino_data_handlerO(d, TINO_DATA_FILE, tino_data_user_fd(fd));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0xb391
movq -0x10(%rbp), %rdi
leaq 0x2b1f(%rip), %rsi      # 0xde9f
movb $0x0, %al
callq 0x4080
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb3bd
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %edi
callq 0xb480
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
leaq 0x5e54(%rip), %rsi      # 0x11208
callq 0xb410
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hilbix[P]unbuffered/./tino/file.h
// Function: tino_file_open_createE
static int
tino_file_open_createE(const char *name, int flags, int mode)
{
  for (;;)
    {
      int	fd;

      fd	= tino_file_open_createI(name, flags, mode);
      if (fd>=0 || errno!=EINTR)
	return fd;
#ifdef TINO_ALARM_RUN
      TINO_ALARM_RUN();
#endif
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0xb540
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0xb404
callq 0x2060
cmpl $0x4, (%rax)
je 0xb40d
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
jmp 0xb3e2
nop
// File: /workspace/github_c_makefile_star2_O0/hilbix[P]unbuffered/./tino/data.h
// Function: tino_data_handlerO
static TINO_DATA *
tino_data_handlerO(TINO_DATA *d, struct tino_data_handler *handler, union tino_data_user user)
{
  if (!d)
    d	= tino_data_newO(user);
  d->handler	= handler;
  if (handler && handler->init)
    handler->init(d, user);
  else
    d->user	= user;
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xb438
movq -0x8(%rbp), %rdi
callq 0xb4a0
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
cmpq $0x0, -0x18(%rbp)
je 0xb46a
movq -0x18(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0xb46a
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq *%rax
jmp 0xb476
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/hilbix[P]unbuffered/./tino/data.h
// Function: tino_data_newO
static TINO_DATA *
tino_data_newO(union tino_data_user user)
{
  TINO_DATA	*d;

  d		= (TINO_DATA *)tino_alloc0O(sizeof *d);
  d->allocated	= d;
  d->user	= user;
  return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x40, %edi
callq 0xb4e0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)