LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movl %esi, %ebp
movl %edi, %ebx
movl 0x682b(%rip), %eax      # 0xd29c
orl 0x67ed(%rip), %eax      # 0xd264
je 0x6a87
leaq 0x68a8(%rip), %rdi      # 0xd328
xorl %esi, %esi
callq 0x2140
andq $0x0, 0x6879(%rip)      # 0xd308
andq $0x0, 0x6881(%rip)      # 0xd318
leaq 0x2726(%rip), %rdi      # 0x91c4
xorl %eax, %eax
callq 0x6b82
cmpl $0x0, 0x67b8(%rip)      # 0xd264
je 0x6aba
movq 0x6503(%rip), %rdi      # 0xcfb8
callq 0x7485
cmpl $0x0, 0x67db(%rip)      # 0xd29c
je 0x6acf
movq 0x6516(%rip), %rdi      # 0xcfe0
callq 0x7485
testl %ebp, %ebp
pushq $0x2b
popq %rax
pushq $0x20
popq %rcx
cmovel %eax, %ecx
testl %ebx, %ebx
pushq $0x2d
popq %rbx
cmovel %ecx, %ebx
cmpl $0x0, 0x67b7(%rip)      # 0xd2a0
setne %cl
movl 0x67ce(%rip), %eax      # 0xd2c0
testl %eax, %eax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x6b0f
movslq %eax, %rsi
leaq 0x30ba(%rip), %rdi      # 0x9bc2
xorl %eax, %eax
callq 0x6b82
movl 0x6757(%rip), %eax      # 0xd26c
testl %eax, %eax
je 0x6b5f
cmpl $0x0, 0x6818(%rip)      # 0xd338
movl 0x6816(%rip), %esi      # 0xd33c
jne 0x6b30
incl %esi
movl %esi, 0x680c(%rip)      # 0xd33c
cmpl $0x2, %eax
leaq 0x3094(%rip), %rcx      # 0x9bce
leaq 0x3094(%rip), %rdx      # 0x9bd5
cmoveq %rcx, %rdx
cmpl $0x1, %eax
leaq 0x3079(%rip), %rdi      # 0x9bc8
cmovneq %rdx, %rdi
movl %ebx, %edx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6b82
cmpl $0x0, 0x673a(%rip)      # 0xd2a0
je 0x6b7b
leaq 0x3068(%rip), %rdi      # 0x9bd7
movl %ebx, %esi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6b82
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x28(%rsp)
testb %al, %al
je 0x6bdd
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq 0x6724(%rip), %rax      # 0xd308
cmpq 0x672d(%rip), %rax      # 0xd318
jne 0x6c2e
cmpl $0x0, 0x6744(%rip)      # 0xd338
leaq 0x668d(%rip), %rax      # 0xd288
leaq 0x6676(%rip), %rcx      # 0xd278
cmovneq %rax, %rcx
movq (%rcx), %r14
testq %r14, %r14
je 0x6c2e
cmpb $0x0, (%r14)
je 0x6c2e
movq %r14, %rdi
callq 0x20e0
leaq 0x66e5(%rip), %rdi      # 0xd308
movq %r14, %rsi
movq %rax, %rdx
callq 0x3ff2
leaq 0xb8(%rsp), %rsi
movq %rbx, (%rsi)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, 0x8(%rsi)
leaq 0xf0(%rsp), %rax
movq %rax, 0x10(%rsi)
movq %rsp, %rax
movq %rax, 0x18(%rsi)
leaq 0x66a7(%rip), %rdi      # 0xd308
callq 0x74df
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
cmpl $0x0, 0x66c8(%rip)      # 0xd340
je 0x6c7b
retq
pushq %rbp
pushq %r14
pushq %rbx
movq 0x65c2(%rip), %r14      # 0xd248
testq %r14, %r14
je 0x6cb4
pushq $0x1
popq %rbp
movq %r14, %rdi
movl $0x441, %esi            # imm = 0x441
movl $0x1b6, %edx            # imm = 0x1B6
xorl %eax, %eax
callq 0x2240
movl %eax, %ebx
testl %eax, %eax
jns 0x6cce
callq 0x2060
cmpl $0x4, (%rax)
je 0x6c8e
jmp 0x6cce
movl 0x65b6(%rip), %eax      # 0xd270
xorl %ebx, %ebx
cmpl $0x1, 0x6591(%rip)      # 0xd254
adcl $0x1, %ebx
testl %eax, %eax
cmovnsl %eax, %ebx
pushq $-0x1
popq %rbp
movl %ebx, %edi
callq 0x7563
movl %ebp, 0x6665(%rip)      # 0xd340
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq 0x660c(%rip), %rax      # 0xd308
testq %rax, %rax
je 0x6d3f
pushq %rax
cmpq 0x6607(%rip), %rax      # 0xd310
jb 0x6d21
leaq 0x65f6(%rip), %rdi      # 0xd308
pushq $0x1
popq %rsi
callq 0x42c9
movq 0x65e7(%rip), %rax      # 0xd308
movq 0x65f8(%rip), %rcx      # 0xd320
movb $0x0, (%rcx,%rax)
movq 0x65ed(%rip), %rax      # 0xd320
addq 0x65de(%rip), %rax      # 0xd318
addq $0x8, %rsp
retq
leaq 0x247e(%rip), %rax      # 0x91c4
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
pushq $0x1
popq %r15
pushq $-0x1
popq %r12
xorl %eax, %eax
movl $0x0, %edx
testq %r14, %r14
je 0x6fce
movl (%r14), %edx
subl 0x10(%r14), %edx
cmpl %edx, %ebx
movl %edx, %ecx
cmovll %ebx, %ecx
testl %ebx, %ebx
cmovsl %edx, %ecx
testl %ecx, %ecx
je 0x7028
testq %r14, %r14
je 0x6fed
movq 0x18(%r14), %rsi
addq 0x10(%r14), %rsi
jmp 0x6fef
xorl %esi, %esi
movslq %ecx, %rdx
movl %ebp, %edi
callq 0x20d0
testl %eax, %eax
jg 0x7012
je 0x7020
callq 0x2060
movl (%rax), %eax
cmpl $0x4, %eax
je 0x6fbb
cmpl $0xb, %eax
je 0x6fbb
jmp 0x7025
subl %eax, %ebx
movq %r14, %rdi
movl %eax, %esi
callq 0x6f45
jmp 0x6fbb
movl %r15d, %eax
jmp 0x7028
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
cmpl $0x0, 0x6308(%rip)      # 0xd340
je 0x7084
pushq %rax
movq 0x62a6(%rip), %rax      # 0xd2e8
testq %rax, %rax
je 0x7059
movq 0x40(%rax), %rax
testq %rax, %rax
je 0x7059
leaq 0x6271(%rip), %rdi      # 0xd2c8
callq *%rax
andq $0x0, 0x6287(%rip)      # 0xd2e8
leaq 0x6260(%rip), %rdi      # 0xd2c8
callq 0x7744
movq 0x628c(%rip), %rdi      # 0xd300
callq 0x2050
andl $0x0, 0x62c0(%rip)      # 0xd340
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsp, %rbx
leaq 0x4(%rsp), %r14
andl $0x0, (%rsp)
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x7164
testl %eax, %eax
jne 0x715c
movl 0x4(%rsp), %edi
xorl %esi, %esi
callq 0x71ee
movl (%rsp), %ecx
testl %ecx, %ecx
je 0x715c
cmpl 0x6171(%rip), %ecx      # 0xd2c4
jne 0x7126
movl %eax, %edi
callq 0x22a0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %eax
testb %al, %al
leaq 0x28ec(%rip), %rcx      # 0x9aeb
leaq 0x28ec(%rip), %rsi      # 0x9af2
cmovnsq %rcx, %rsi
movl %edi, %edx
andl $0x7f, %edx
je 0x723b
movl %edx, %ecx
shll $0x18, %ecx
addl $0x1000000, %ecx        # imm = 0x1000000
cmpl $0x2000000, %ecx        # imm = 0x2000000
jl 0x7255
testq %rbx, %rbx
je 0x7299
leaq 0x28e0(%rip), %rdi      # 0x9b10
xorl %eax, %eax
callq 0x72ad
pushq $-0x1
jmp 0x7293
movzbl %ah, %ebp
testq %rbx, %rbx
je 0x72a4
leaq 0x28b4(%rip), %rdi      # 0x9afe
movl %ebp, %edx
xorl %eax, %eax
callq 0x72ad
jmp 0x7294
testb %al, %al
js 0x7277
testq %rbx, %rbx
je 0x729d
leaq 0x28d0(%rip), %rdi      # 0x9b35
leaq 0x287f(%rip), %rsi      # 0x9aeb
xorl %eax, %eax
callq 0x72ad
pushq $-0x3
jmp 0x7293
testq %rbx, %rbx
je 0x72a1
leaq 0x289f(%rip), %rdi      # 0x9b22
leaq 0x2868(%rip), %rsi      # 0x9af2
xorl %eax, %eax
callq 0x72ad
pushq $-0x2
popq %rbp
movq %rax, (%rbx)
jmp 0x72a4
pushq $-0x1
jmp 0x72a3
pushq $-0x3
jmp 0x72a3
pushq $-0x2
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hilbix[P]unbuffered/./tino/strprintf.h
// Function: tino_str_printf
static char *
tino_str_printf(const char *s, ...)
{
  tino_va_list	list;
  char		*tmp;

  tino_va_start(list, s);
  tmp	= tino_str_vprintf(&list);
  tino_va_end(list);
  return tmp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd0, %rsp
leaq 0x20(%rsp), %r10
movq %rsi, 0x8(%r10)
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x7310
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rbx
movq %rdi, (%rbx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, 0x8(%rbx)
leaq 0x100(%rsp), %rax
movq %rax, 0x10(%rbx)
movq %r10, 0x18(%rbx)
movl $0x2000, %ebp           # imm = 0x2000
movl $0x2000, %r12d          # imm = 0x2000
movl %r12d, %r14d
movq %r14, %rdi
callq 0x2210
testq %rax, %rax
je 0x73aa
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x73ef
testl %eax, %eax
js 0x73d2
leal 0x1(%rax), %r12d
cmpl %r14d, %eax
jl 0x7388
movq %r15, %rdi
callq 0x7432
subl %r14d, %r12d
cmpl $0x2001, %r12d          # imm = 0x2001
cmovll %ebp, %r12d
addl %r14d, %r12d
jmp 0x733f
movl %r12d, %esi
movq %r15, %rdi
callq 0x2230
testq %rax, %rax
cmoveq %r15, %rax
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2798(%rip), %rdi      # 0x9b49
leaq 0x27a4(%rip), %rdx      # 0x9b5c
pushq $0x49
popq %rsi
callq 0x45e8
movq (%rsp), %rsi
leaq 0x27a6(%rip), %rdi      # 0x9b71
xorl %eax, %eax
callq 0x409d
leaq 0x27bf(%rip), %rdi      # 0x9b98
leaq 0x2769(%rip), %rsi      # 0x9b49
leaq 0x27b5(%rip), %rcx      # 0x9b9c
pushq $0x2f
popq %rdx
callq 0x4043
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdx), %rax
leaq 0x10(%rsp), %rcx
movq %rax, -0x8(%rcx)
movups 0x8(%rdx), %xmm0
movups %xmm0, (%rcx)
movq 0x18(%rdx), %rdx
movq %rdx, 0x10(%rcx)
movq %rax, %rdx
callq 0x20c0
testq %rbx, %rbx
je 0x742a
movb $0x0, -0x1(%r14,%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rdi, %rdi
je 0x7465
andq $0x0, (%rdi)
andq $0x0, 0x10(%rdi)
movq %rdi, %rax
retq
pushq %rax
leaq 0x19b7(%rip), %rdi      # 0x8e24
leaq 0x197a(%rip), %rsi      # 0x8dee
leaq 0x2737(%rip), %rcx      # 0x9bb2
movl $0x81, %edx
callq 0x4043
// File: /workspace/github_c_makefile_star2_O2/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 %rax
movq %rdi, %rax
leaq 0x5e98(%rip), %rdi      # 0xd328
callq *%rax
movl $0x76c, %esi            # imm = 0x76C
movl 0x10(%rax), %edx
incl %edx
movl 0xc(%rax), %ecx
movl 0x8(%rax), %r8d
movl (%rax), %r10d
movl 0x4(%rax), %r9d
addl 0x14(%rax), %esi
cmpl $0x0, 0x5db4(%rip)      # 0xd268
je 0x74c7
leaq 0x271d(%rip), %rdi      # 0x9bda
xorl %eax, %eax
pushq 0x5e6b(%rip)            # 0xd330
jmp 0x74d4
subq $0x8, %rsp
leaq 0x272a(%rip), %rdi      # 0x9bfc
xorl %eax, %eax
pushq %r10
callq 0x6b82
popq %rax
popq %rcx
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x20e0
leaq 0x1(%rax), %rsi
movq %rbx, %rdi
callq 0x4055
movq (%rbx), %rdi
movq 0x8(%rbx), %r15
subq %rdi, %r15
addq 0x18(%rbx), %rdi
movslq %r15d, %rsi
movq %r14, %rdx
callq 0x73ef
testl %eax, %eax
js 0x7546
movl %eax, %esi
subl %r15d, %esi
jl 0x753b
cmpl $0x2000, %esi           # imm = 0x2000
jge 0x752f
movl $0x1fff, %esi           # imm = 0x1FFF
incl %esi
movq %rbx, %rdi
callq 0x42c9
jmp 0x74fe
movl %eax, %eax
addq %rax, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x26cb(%rip), %rdi      # 0x9c18
leaq 0x26ca(%rip), %rsi      # 0x9c1e
leaq 0x26d7(%rip), %rcx      # 0x9c32
pushq $0x2e
popq %rdx
callq 0x4043
// File: /workspace/github_c_makefile_star2_O2/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:
testl %edi, %edi
js 0x758c
movl %edi, %esi
leaq 0x5c80(%rip), %rax      # 0xd1f0
movq %rax, 0x5d71(%rip)      # 0xd2e8
movq 0x5cba(%rip), %rax      # 0xd238
testq %rax, %rax
je 0x75a1
leaq 0x5d3e(%rip), %rdi      # 0xd2c8
jmpq *%rax
leaq 0x5d35(%rip), %rdi      # 0xd2c8
leaq 0x26aa(%rip), %rsi      # 0x9c44
xorl %eax, %eax
jmp 0x461e
movq %rsi, 0x5d48(%rip)      # 0xd2f0
retq
// File: /workspace/github_c_makefile_star2_O2/hilbix[P]unbuffered/./tino/data.h
// Function: tino_data_writeA
static void
tino_data_writeA(TINO_DATA *d, const void *ptr, size_t len)
{
  size_t	pos;
  int		put;

  if (!d || !d->handler || !d->handler->write)
    {
      tino_data_error(d, "write not defined");
      return;
    }
  put	= -1;
  for (pos=0; pos<len; )
    {
      errno	= 0;
      if ((put=d->handler->write(d, ((const char *)ptr)+pos, len-pos))>0)
	pos	+= put;
      else if (!put || errno!=EINTR)
	break;
      else
	{
#ifdef TINO_ALARM_RUN
	  TINO_ALARM_RUN();
#endif
	}
    }
  if (pos!=len)
    tino_data_error(d, "general write error %d", put);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x5d2d(%rip), %rax      # 0xd2e8
testq %rax, %rax
je 0x7621
cmpq $0x0, 0x10(%rax)
je 0x7621
movq %rsi, %rbx
pushq $-0x1
popq %rax
xorl %r14d, %r14d
leaq 0x5cf1(%rip), %r15      # 0xd2c8
movq %rdi, (%rsp)
leaq (%rdi,%r14), %r12
movq %rbx, %r13
subq %r14, %r13
cmpq %r14, %rbx
jbe 0x7646
callq 0x2060
movq %rax, %rbp
andl $0x0, (%rax)
movq 0x5cec(%rip), %rax      # 0xd2e8
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq *0x10(%rax)
testl %eax, %eax
jg 0x7616
je 0x7644
cmpl $0x4, (%rbp)
je 0x75e5
jmp 0x7646
movl %eax, %ecx
addq %rcx, %r14
movq (%rsp), %rdi
jmp 0x75db
leaq 0x5ca0(%rip), %rdi      # 0xd2c8
leaq 0x2625(%rip), %rsi      # 0x9c54
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x461e
xorl %eax, %eax
cmpq %r14, %rbx
jne 0x765a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5c67(%rip), %rdi      # 0xd2c8
leaq 0x25fe(%rip), %rsi      # 0x9c66
movl %eax, %edx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x461e
// File: /workspace/github_c_makefile_star2_O2/hilbix[P]unbuffered/./tino/data.h
// Function: tino_data_printfA
static void
tino_data_printfA(TINO_DATA *d, const char *s, ...)
{
  tino_va_list	list;

  tino_va_start(list, s);
  tino_data_vprintfA(d, &list);
  tino_va_end(list);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xf8, %rsp
leaq 0x40(%rsp), %rdi
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x76df
movaps %xmm0, 0x70(%rsp)
movaps %xmm1, 0x80(%rsp)
movaps %xmm2, 0x90(%rsp)
movaps %xmm3, 0xa0(%rsp)
movaps %xmm4, 0xb0(%rsp)
movaps %xmm5, 0xc0(%rsp)
movaps %xmm6, 0xd0(%rsp)
movaps %xmm7, 0xe0(%rsp)
movq %rsp, %rbx
movq %rsi, (%rbx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, 0x8(%rbx)
leaq 0x110(%rsp), %rax
movq %rax, 0x10(%rbx)
movq %rdi, 0x18(%rbx)
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x6a4f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x74df
movq (%r14), %rsi
movq 0x10(%r14), %rax
movq 0x18(%r14), %rdi
addq %rax, %rdi
subq %rax, %rsi
callq 0x75a9
movq %r14, %rdi
callq 0x7744
addq $0xf8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/hilbix[P]unbuffered/./tino/buf.h
// Function: tino_buf_freeO
static void
tino_buf_freeO(TINO_BUF *buf)
{
  tino_FATAL(!buf);

  cDP(("(%p)", buf));
  if (buf->data)
    tino_freeO(buf->data);
  tino_buf_initO(buf);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x7764
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x775b
callq 0x7432
movq %rbx, %rdi
popq %rbx
jmp 0x6a4f
leaq 0x16b9(%rip), %rdi      # 0x8e24
leaq 0x167c(%rip), %rsi      # 0x8dee
leaq 0x2528(%rip), %rcx      # 0x9ca1
movl $0xa4, %edx
callq 0x4043
// File: /workspace/github_c_makefile_star2_O2/mmayer[P]pcal/src/pcal.c
// Function: init_misc
void init_misc (void)
{
   char tmp[STRSIZ], *p;
   
   INIT_COLORS;   /* copy default_color to day_color */
   strcpy(notes_hdr, default_notes_hdr);   /* initialize notes_hdr */
   
   /* define preprocessor symbol "lang_XX" for default language XX */
   do_define(gen_lang_sym(LANG_DEFAULT));
   
   /* Define 'PAPERSIZE_XXX' (where XXX is the name of the selected paper
    * size).
    */
   sprintf(tmp, "PAPERSIZE_%s", paper_info[paper_size].name);
   do_define(tmp);
   
   /* Define 'ORIENTATION_XXX' (where XXX is the name of the current paper
    * orientation -- 'portrait' or 'landscape').
    */
   sprintf(tmp, "ORIENTATION_%s", (rotate == PORTRAIT) ? "PORTRAIT" : "LANDSCAPE");
   do_define(tmp);
   
   /* define preprocessor symbol vN_N for Pcal version vN.N */
   strcpy(tmp, version);
   for (p = tmp; *p; p++) {
      if (*p == '.') *p = '_';
   }
   do_define(tmp);

   return;
}

// Assembly:
pushq %rbx
subq $0xd0, %rsp
movl 0x22dee(%rip), %eax     # 0x28238
movl %eax, 0x272cc(%rip)     # 0x2c71c
movl 0x22de5(%rip), %eax     # 0x2823b
orl $-0x1, 0x272c7(%rip)    # 0x2c724
movl %eax, 0x272bc(%rip)     # 0x2c71f
andl $0x0, 0x26e2e(%rip)     # 0x2c298
leaq 0x272bf(%rip), %rdi     # 0x2c730
leaq 0x23808(%rip), %rsi     # 0x28c80
callq 0x50a0
xorl %edi, %edi
callq 0x552a
leaq 0x2805d(%rip), %rdi     # 0x2d4e8
callq 0xb811
movslq 0x27281(%rip), %rax     # 0x2c718
imulq $0x18, %rax, %rax
leaq 0x2457e(%rip), %rcx     # 0x29a20
movq (%rax,%rcx), %rdx
leaq 0xf921(%rip), %rsi      # 0x14dce
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x52e0
movq %rbx, %rdi
callq 0xb811
cmpl $0x0, 0x22d7b(%rip)     # 0x28244
leaq 0xfaa3(%rip), %rax      # 0x14f73
leaq 0xfab1(%rip), %rdx      # 0x14f88
cmoveq %rax, %rdx
leaq 0xf8f9(%rip), %rsi      # 0x14ddb
movq %rbx, %rdi
xorl %eax, %eax
callq 0x52e0
movq %rbx, %rdi
callq 0xb811
leaq 0x27305(%rip), %rsi     # 0x2c800
movq %rbx, %rdi
callq 0x50a0
movzbl (%rbx), %eax
cmpl $0x2e, %eax
je 0x5511
testl %eax, %eax
jne 0x5514
jmp 0x5519
movb $0x5f, (%rbx)
incq %rbx
jmp 0x5503
movq %rsp, %rdi
callq 0xb811
addq $0xd0, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/mmayer[P]pcal/src/pcal.c
// Function: gen_lang_sym
char *gen_lang_sym (int lang)
{
   static char buf[sizeof(DEF_LANG) + MIN_LANG_LEN + 1];
   char *p;
   int i;
   
   strcpy(buf, DEF_LANG);
   p = buf + strlen(buf);
   for (i = 0; i < MIN_LANG_LEN; i++) p[i] = lang_id[lang][i];
   p[i] = '\0';
   
   return buf;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebp
movw $0x5f, 0x27fb4(%rip)    # 0x2d4ec
movl $0x676e616c, 0x27fa6(%rip) # imm = 0x676E616C
leaq 0x27f9f(%rip), %rbx     # 0x2d4e8
movq %rbx, %rdi
callq 0x5100
movslq %ebp, %rcx
imulq $0x14, %rcx, %rcx
addq 0x22a81(%rip), %rcx     # 0x27fe0
xorl %edx, %edx
cmpq $0x2, %rdx
je 0x5578
movb (%rcx,%rdx), %sil
leaq (%rax,%rdx), %rdi
movb %sil, (%rbx,%rdi)
incq %rdx
jmp 0x5561
movb $0x0, 0x2(%rax,%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mmayer[P]pcal/src/pcal.c
// Function: set_color
void set_color (char *day, int col)
{
   int i, j, max, count[NUM_COLORS];
   char tmp[STRSIZ], *p;
   
   if (ci_strncmp(day, ALL, strlen(ALL)) == 0) {   /* set all days */
      for (i = 0; i < 7; i++) day_color[i] = col;
   }
   
   else if (ci_strncmp(day, HOLIDAY, MIN_DAY_LEN) == 0) { /* set holidays */
      holiday_color = col;
   }
   
   else {   /* set range of days */
      strcpy(tmp, day);
      if ((p = strchr(tmp, '-')) != NULL) *p++ = '\0';
      
      /* parse single day or range of days - return if error */
      if ((i = get_weekday(tmp, FALSE)) == NOT_WEEKDAY ||
          (j = p ? get_weekday(p, FALSE) : i) == NOT_WEEKDAY) {
         return;
      }

      /* set day colors, wrapping around end of week */
      for (j = (i > j) ? j + 7 : j; i <= j; i++) day_color[i % 7] = col;
   }
   
   /* reset weekday_color to most prevalent color */
   
   for (i = 0; i < NUM_COLORS; i++) {   /* clear counts */
      count[i] = 0;
   }
   
   for (i = SUN; i <= SAT; i++) { /* count colors */
      count[(int)day_color[i]]++;
   }
   
   for (i = max = 0; i < NUM_COLORS; i++) { /* get most prevalent */
      if (count[i] > max) max = count[weekday_color = i];
   }
   return;   
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x18c21(%rip), %rsi     # 0x1e1c1
pushq $0x3
popq %rdx
callq 0x9665
testl %eax, %eax
je 0x55ed
leaq 0xeca1(%rip), %rsi      # 0x14254
pushq $0x3
popq %rdx
movq %r14, %rdi
callq 0x9665
testl %eax, %eax
je 0x5604
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x50a0
pushq $0x2d
popq %rsi
movq %r15, %rdi
callq 0x5120
testq %rax, %rax
je 0x5655
movq %rax, %r14
incq %r14
movb $0x0, (%rax)
jmp 0x5658
xorl %eax, %eax
leaq 0x27126(%rip), %rcx     # 0x2c71c
cmpq $0x7, %rax
je 0x560a
movb %bl, (%rax,%rcx)
incq %rax
jmp 0x55f6
movl %ebx, 0x2711a(%rip)     # 0x2c724
xorl %eax, %eax
cmpq $0x4, %rax
je 0x561b
andl $0x0, (%rsp,%rax,4)
incq %rax
jmp 0x560c
xorl %eax, %eax
leaq 0x270f8(%rip), %rcx     # 0x2c71c
cmpq $0x7, %rax
je 0x5637
movsbq (%rax,%rcx), %rdx
incl (%rsp,%rdx,4)
incq %rax
jmp 0x5624
xorl %eax, %eax
xorl %ecx, %ecx
cmpq $0x4, %rax
je 0x56a8
movl (%rsp,%rax,4), %edx
cmpl %ecx, %edx
jle 0x5650
movl %eax, 0x26c4a(%rip)     # 0x2c298
movl %edx, %ecx
incq %rax
jmp 0x563b
xorl %r14d, %r14d
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0xbf9b
cmpl $-0x1, %eax
je 0x56a8
movl %eax, %ebp
testq %r14, %r14
je 0x567f
movq %r14, %rdi
xorl %esi, %esi
callq 0xbf9b
cmpl $-0x1, %eax
je 0x56a8
leal 0x7(%rax), %ecx
cmpl %eax, %ebp
cmovlel %eax, %ecx
pushq $0x7
popq %rsi
leaq 0x2708b(%rip), %rdi     # 0x2c71c
cmpl %ecx, %ebp
jg 0x560a
movl %ebp, %eax
cltd
idivl %esi
movslq %edx, %rax
movb %bl, (%rax,%rdi)
incl %ebp
jmp 0x5691
addq $0xd8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mmayer[P]pcal/src/pcal.c
// Function: change_color
void change_color (int col)
{
   int i;
   
   for (i = SUN; i <= SAT; i++) {
      if (day_color[i] != BLACK) day_color[i] = col;
   }
   
   if (holiday_color != BLACK && holiday_color != HOLIDAY_DEFAULT) {
      holiday_color = col;
   }
   return;   
}

// Assembly:
xorl %eax, %eax
leaq 0x2705d(%rip), %rcx     # 0x2c71c
cmpq $0x7, %rax
je 0x56d4
cmpb $0x0, (%rax,%rcx)
je 0x56cf
movb %dil, (%rax,%rcx)
incq %rax
jmp 0x56bf
movl 0x2704a(%rip), %eax     # 0x2c724
decl %eax
cmpl $-0x3, %eax
ja 0x56e7
movl %edi, 0x2703d(%rip)     # 0x2c724
retq
// File: /workspace/github_c_makefile_star2_O2/mmayer[P]pcal/src/pcal.c
// Function: get_flag
FLAG_USAGE * get_flag (char flag)
{
   FLAG_USAGE *pflag;
   
   for (pflag = flag_tbl; pflag->flag; pflag++) {
      if (flag == pflag->flag) return pflag;
   }
   
   return flag ? NULL : pflag;   /* '\0' is a valid flag */
}

// Assembly:
leaq 0x235a1(%rip), %rax     # 0x28c90
movb (%rax), %cl
testb %cl, %cl
je 0x5700
cmpb %dil, %cl
je 0x5709
addq $0x3, %rax
jmp 0x56ef
xorl %ecx, %ecx
testb %dil, %dil
cmovneq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mmayer[P]pcal/src/pcal.c
// Function: set_debug_flag
void set_debug_flag (char *flag)
{
   char f;
   DEBUG_INFO *pd;
   
   if (!flag) {   /* clear all if NULL */
      debug_flags = 0;
      return;
   }
   
   /* loop through all characters in "flag", setting corresponding
    * bits in debug_flags
    */
   while ((f = *flag++) != '\0') {
      for (pd = debug_info; pd->flag; pd++) {
         if (pd->flag == f) debug_flags |= pd->value;
      }
   }
   return;
}

// Assembly:
testq %rdi, %rdi
je 0x5744
movl 0x26fb7(%rip), %eax     # 0x2c6cc
leaq 0x23618(%rip), %rcx     # 0x28d34
movb (%rdi), %dl
testb %dl, %dl
je 0x574b
incq %rdi
movq %rcx, %rsi
movb -0x4(%rsi), %r8b
testb %r8b, %r8b
je 0x571c
cmpb %dl, %r8b
jne 0x573e
orl (%rsi), %eax
movl %eax, 0x26f8e(%rip)     # 0x2c6cc
addq $0x8, %rsi
jmp 0x5728
andl $0x0, 0x26f81(%rip)     # 0x2c6cc
retq
// File: /workspace/github_c_makefile_star2_O2/mmayer[P]pcal/src/pcal.c
// Function: color_msg
char *color_msg (void)
{
   int i, ngray = 0, others, gray = GRAY;
   static char msg[80], *alt_color;
   
   for (i = SUN; i <= SAT; i++) { /* count "logical gray" weekdays */
      if (default_color[i] != BLACK) {
         gray = default_color[i];
         ngray++;
      }
   }
   
   alt_color = color_names[gray];   /* map "logical gray" to its name */
   
   if (ngray == 0 || ngray == 7) {   /* all same color? */
      sprintf(msg, COLOR_MSG_1, ngray ? alt_color : W_BLACK);
      return msg;
   }
   
   others = ngray <= 3 ? BLACK : gray;   /* no - get predominant color */
   msg[0] = '\0';
   for (i = SUN; i <= SAT; i++) {
      if (default_color[i] != others) {
         strncat(msg, days_ml[LANG_DEFAULT][i], MIN_DAY_LEN);
         strcat(msg, "/");
      }
   }

   LASTCHAR(msg) = ' ';
   
   sprintf(msg + strlen(msg), COLOR_MSG_2,
           others == BLACK ? alt_color : W_BLACK,
           others == BLACK ? W_BLACK : alt_color);
   return msg;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
pushq $0x1
popq %rbp
xorl %ecx, %ecx
leaq 0x2268e(%rip), %r13     # 0x28238
xorl %eax, %eax
cmpq $0x7, %rcx
je 0x5bc9
movsbl (%rcx,%r13), %edx
xorl %esi, %esi
testl %edx, %edx
setne %sil
cmovnel %edx, %ebp
addl %esi, %eax
incq %rcx
jmp 0x5bac
movslq %ebp, %rcx
leaq 0x22b8d(%rip), %rdx     # 0x28760
movq (%rdx,%rcx,8), %rdx
movq %rdx, 0x27902(%rip)     # 0x2d4e0
cmpl $0x7, %eax
je 0x5be7
testl %eax, %eax
jne 0x5c0e
testl %eax, %eax
leaq 0xe868(%rip), %rax      # 0x14458
cmoveq %rax, %rdx
leaq 0x27895(%rip), %rdi     # 0x2d490
leaq 0xf465(%rip), %rsi      # 0x15067
xorl %eax, %eax
callq 0x52e0
jmp 0x5caa
movq %rdx, (%rsp)
xorl %ebx, %ebx
cmpl $0x4, %eax
cmovbl %ebx, %ebp
movb $0x0, 0x2786f(%rip)     # 0x2d490
leaq 0x24908(%rip), %r15     # 0x2a530
leaq 0x27861(%rip), %r14     # 0x2d490
pushq $0x3
popq %r12
cmpq $0x7, %rbx
je 0x5c68
movsbl (%rbx,%r13), %eax
cmpl %eax, %ebp
je 0x5c5f
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x5180
movq %r14, %rdi
callq 0x5100
movw $0x2f, (%rax,%r14)
incq %rbx
addq $0x14, %r15
jmp 0x5c33
movq %r14, %rdi
callq 0x5100
movb $0x20, -0x1(%rax,%r14)
movq %r14, %rdi
callq 0x5100
addq %rax, %r14
testl %ebp, %ebp
leaq 0xe7ce(%rip), %rax      # 0x14458
movq %rax, %rdx
movq (%rsp), %rcx
cmoveq %rcx, %rdx
cmoveq %rax, %rcx
leaq 0xf3d6(%rip), %rsi      # 0x15076
movq %r14, %rdi
xorl %eax, %eax
callq 0x52e0
leaq 0x277df(%rip), %rax     # 0x2d490
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mmayer[P]pcal/src/pcal.c
// Function: recalc_paper_parameters
void recalc_paper_parameters (int paper_size_idx)
{
   page_dim_short_axis_pts = paper_info[paper_size_idx].page_dim_short_axis_pts;
   page_dim_long_axis_pts = paper_info[paper_size_idx].page_dim_long_axis_pts;
   
   daybox_width_pts = paper_info[paper_size_idx].daybox_width_pts;
   daybox_height_pts = paper_info[paper_size_idx].daybox_height_pts;
   
   xsval_pgm = ysval_pgm = (double)page_dim_short_axis_pts / (double)page_dim_long_axis_pts;
   xtval_pgm = (page_dim_long_axis_pts - (7 * daybox_width_pts)) / 2;
   
   if ((rotate == PORTRAIT) && do_whole_year) {
      ytval_pgm = page_dim_short_axis_pts + TOP_OF_CAL_BOXES_PTS + 
         6 * (daybox_height_pts - paper_info[paper_size_idx].daybox_height_pts);
   }
   else if ((rotate == PORTRAIT) && !do_whole_year) {
      /* 
       * Copied from the 'ReadMe' file for v4.6:
       * 
       *    The date box height for single-month portrait-mode calendars has
       *    been expanded from 80 points to 117.  If you prefer the original
       *    date box proportions (basically a scaled-down landscape-mode
       *    calendar), compile with -DORIG_BOX_HEIGHT.
       */
#ifndef ORIG_BOX_HEIGHT
      daybox_height_pts = (page_dim_long_axis_pts - DEFAULT_MARGIN_BOTTOM_PTS + 
                           TOP_OF_CAL_BOXES_PTS) / 6 / ysval_pgm;
#endif
      ytval_pgm = (page_dim_long_axis_pts + TOP_OF_CAL_BOXES_PTS) / ysval_pgm;
   }
   else {   /* landscape mode */
      xsval_pgm = ysval_pgm = 1.0;
      ytval_pgm = TOP_OF_CAL_BOXES_PTS;
   }
   return;
}

// Assembly:
movslq %edi, %rax
imulq $0x18, %rax, %rax
leaq 0x23d52(%rip), %rdx     # 0x29a20
movl 0x8(%rax,%rdx), %esi
movl %esi, 0x26c10(%rip)     # 0x2c8e8
movl 0xc(%rax,%rdx), %ecx
movl %ecx, 0x26c0a(%rip)     # 0x2c8ec
movl 0x10(%rax,%rdx), %edi
movl %edi, 0x26c04(%rip)     # 0x2c8f0
movl 0x14(%rax,%rdx), %eax
cvtsi2sd %esi, %xmm0
cvtsi2sd %ecx, %xmm1
movl %eax, 0x26bf6(%rip)     # 0x2c8f4
divsd %xmm1, %xmm0
movsd %xmm0, 0x26bee(%rip)    # 0x2c8f8
movsd %xmm0, 0x26bee(%rip)    # 0x2c900
imull $-0x7, %edi, %eax
addl %ecx, %eax
pushq $0x2
popq %rdi
cltd
idivl %edi
movl %eax, 0x26be5(%rip)     # 0x2c908
movl 0x2251b(%rip), %eax     # 0x28244
testl %eax, %eax
sete %dil
movl 0x2697f(%rip), %edx     # 0x2c6b4
testl %edx, %edx
setne %r8b
andb %dil, %r8b
cmpb $0x1, %r8b
jne 0x5d49
addl $-0x55, %esi
jmp 0x5d97
orl %edx, %eax
je 0x5d6a
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x26b9a(%rip)     # 0x2c8f8
movq %rax, 0x26b9b(%rip)     # 0x2c900
pushq $-0x55
popq %rsi
jmp 0x5d97
leal -0x83(%rcx), %eax
pushq $0x6
popq %rsi
cltd
idivl %esi
cvtsi2sd %eax, %xmm1
divsd %xmm0, %xmm1
cvttsd2si %xmm1, %eax
addl $-0x55, %ecx
cvtsi2sd %ecx, %xmm1
movl %eax, 0x26b65(%rip)     # 0x2c8f4
divsd %xmm0, %xmm1
cvttsd2si %xmm1, %esi
movl %esi, 0x26b6f(%rip)     # 0x2c90c
retq
// File: /workspace/github_c_makefile_star2_O2/mmayer[P]pcal/src/pcal.c
// Function: alt_fopen
FILE *alt_fopen (char *fullpath, char *name, char *pathlist[], char *access)
{
   char **path;
   FILE *fp;
   
   /* print complete list of paths if debugging path names */
   if (DEBUG(DEBUG_PATHS)) {
      fprintf(stderr, "Searching for %s in the following paths:\n", name);
      for (path = pathlist; *path; path++) {
         fprintf(stderr, "  %s\n", **path ? *path : ".");
      }
   }
   
   /* search path list for requested file */
   for (path = pathlist; *path; path++) {
      mk_filespec(fullpath, *path, name);
      if ((fp = fopen(fullpath, access)) != NULL) {
         if (DEBUG(DEBUG_PATHS)) fprintf(stderr, "found %s\n", fullpath);
         return fp;
      }
   }

   fullpath[0] = '\0';   /* file not found */
   return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
testb $0x8, 0x25a52(%rip)     # 0x2c6cc
jne 0x6ce4
movq (%r15), %rsi
testq %rsi, %rsi
je 0x6ccc
movq %rbx, %rdi
movq %r12, %rdx
callq 0xa8cf
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5290
addq $0x8, %r15
testq %rax, %rax
je 0x6c7c
movq %rax, %r13
testb $0x8, 0x25a1f(%rip)     # 0x2c6cc
je 0x6cd2
movq 0x21342(%rip), %rax     # 0x27ff8
movq (%rax), %rdi
leaq 0xe3fc(%rip), %rsi      # 0x150bc
movq %rbx, %rdx
xorl %eax, %eax
callq 0x5200
jmp 0x6cd2
movb $0x0, (%rbx)
xorl %r13d, %r13d
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2130d(%rip), %rbp     # 0x27ff8
movq (%rbp), %rdi
leaq 0xe394(%rip), %rsi      # 0x1508a
movq %r12, %rdx
xorl %eax, %eax
callq 0x5200
movq %r15, %r13
movq (%r13), %rax
testq %rax, %rax
je 0x6c7c
cmpb $0x0, (%rax)
leaq 0xe3a0(%rip), %rdx      # 0x150ba
je 0x6d1f
movq %rax, %rdx
movq (%rbp), %rdi
leaq 0xe38a(%rip), %rsi      # 0x150b4
xorl %eax, %eax
callq 0x5200
addq $0x8, %r13
jmp 0x6d03
// File: /workspace/github_c_makefile_star2_O2/mmayer[P]pcal/src/encvec.c
// Function: encvec_iso8859_6
void encvec_iso8859_6 (void)
{
   printf("%%%%%%   %%\n");
   printf("%%%%%%   %% ISO 8859-6 (Arabic) character mappings\n");
   printf("%%%%%%   %% \n");
   printf("%%%%%%   %% This PostScript encoding vector is currently undefined because the\n");
   printf("%%%%%%   %% information needed to create it was not found.\n");
   printf("%%%%%%   %% \n");
   printf("%%%%%%   /alt_mappings [\n");
   printf("%%%%%%   ] readonly def\n");
   printf("\n");
   
   return;
}

// Assembly:
pushq %rbx
leaq 0xd96c(%rip), %rdi      # 0x152df
xorl %eax, %eax
callq 0x5130
leaq 0xd96b(%rip), %rdi      # 0x152ec
xorl %eax, %eax
callq 0x5130
leaq 0xd991(%rip), %rbx      # 0x15320
movq %rbx, %rdi
xorl %eax, %eax
callq 0x5130
leaq 0xd98e(%rip), %rdi      # 0x1532e
xorl %eax, %eax
callq 0x5130
leaq 0xd9d0(%rip), %rdi      # 0x1537e
xorl %eax, %eax
callq 0x5130
movq %rbx, %rdi
xorl %eax, %eax
callq 0x5130
leaq 0xd9f4(%rip), %rdi      # 0x153ba
xorl %eax, %eax
callq 0x5130
leaq 0xda00(%rip), %rdi      # 0x153d4
xorl %eax, %eax
callq 0x5130
pushq $0xa
popq %rdi
popq %rbx
jmp 0x5060
// File: /workspace/github_c_makefile_star2_O2/mmayer[P]pcal/src/encvec.c
// Function: encvec_iso8859_8
void encvec_iso8859_8 (void)
{
   printf("%%%%%%   %%\n");
   printf("%%%%%%   %% ISO 8859-8 (Hebrew) character mappings\n");
   printf("%%%%%%   %% \n");
   printf("%%%%%%   %% This PostScript encoding vector is currently undefined because the\n");
   printf("%%%%%%   %% information needed to create it was not found.\n");
   printf("%%%%%%   %% \n");
   printf("%%%%%%   /alt_mappings [\n");
   printf("%%%%%%   ] readonly def\n");

   return;
}

// Assembly:
pushq %rbx
leaq 0xd74a(%rip), %rdi      # 0x152df
xorl %eax, %eax
callq 0x5130
leaq 0xd874(%rip), %rdi      # 0x15417
xorl %eax, %eax
callq 0x5130
leaq 0xd76f(%rip), %rbx      # 0x15320
movq %rbx, %rdi
xorl %eax, %eax
callq 0x5130
leaq 0xd76c(%rip), %rdi      # 0x1532e
xorl %eax, %eax
callq 0x5130
leaq 0xd7ae(%rip), %rdi      # 0x1537e
xorl %eax, %eax
callq 0x5130
movq %rbx, %rdi
xorl %eax, %eax
callq 0x5130
leaq 0xd7d2(%rip), %rdi      # 0x153ba
xorl %eax, %eax
callq 0x5130
leaq 0xd7de(%rip), %rdi      # 0x153d4
xorl %eax, %eax
popq %rbx
jmp 0x5130
// File: /workspace/github_c_makefile_star2_O2/mmayer[P]pcal/src/encvec.c
// Function: encvec_iso8859_16
void encvec_iso8859_16 (void)
{
   printf("%%%%%%   %%\n");
   printf("%%%%%%   %% ISO 8859-16 (Latin10) character mappings\n");
   printf("%%%%%%   %% \n");
   printf("%%%%%%   %% This PostScript encoding vector is currently undefined because the\n");
   printf("%%%%%%   %% information needed to create it was not found.\n");
   printf("%%%%%%   %% \n");
   printf("%%%%%%   /alt_mappings [\n");
   printf("%%%%%%   ] readonly def\n");

   return;
}

// Assembly:
pushq %rbx
leaq 0xcce3(%rip), %rdi      # 0x152df
xorl %eax, %eax
callq 0x5130
leaq 0xcf51(%rip), %rdi      # 0x1555b
xorl %eax, %eax
callq 0x5130
leaq 0xcd08(%rip), %rbx      # 0x15320
movq %rbx, %rdi
xorl %eax, %eax
callq 0x5130
leaq 0xcd05(%rip), %rdi      # 0x1532e
xorl %eax, %eax
callq 0x5130
leaq 0xcd47(%rip), %rdi      # 0x1537e
xorl %eax, %eax
callq 0x5130
movq %rbx, %rdi
xorl %eax, %eax
callq 0x5130
leaq 0xcd6b(%rip), %rdi      # 0x153ba
xorl %eax, %eax
callq 0x5130
leaq 0xcd77(%rip), %rdi      # 0x153d4
xorl %eax, %eax
popq %rbx
jmp 0x5130
// File: /workspace/github_c_makefile_star2_O2/mmayer[P]pcal/src/moonphas.c
// Function: find_phase
double find_phase (int month, int day, int year, int *pquarter)
{
   static int sv_year = 0, sv_month = 0;
   static double mphase[33];   /* 31 days + 2 dummies */
   double phase;
   
   /* calculate moon phase */

   /* new month?  fill mphase[] with moon phases */
   if (month != sv_month || year != sv_year) {
      gen_phases(mphase, month, year);
      sv_month = month;
      sv_year = year;
   }
   
   phase = mphase[day];
   *pquarter = is_quarter(mphase[day-1], phase, mphase[day+1]);

   return phase;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %r14d
movl %esi, %ebp
movl %edi, %r15d
cmpl %edi, 0x241eb(%rip)     # 0x2d5f4
jne 0x9418
cmpl %r14d, 0x241de(%rip)    # 0x2d5f0
je 0x9512
movq %rcx, (%rsp)
leaq 0xc(%rsp), %r12
movl %r15d, (%r12)
andl $0x0, 0x4(%r12)
movl %r14d, 0x8(%r12)
movq %r12, %rdi
callq 0x9aa7
movl (%r12), %edi
movl 0x4(%r12), %esi
movl 0x8(%r12), %edx
callq 0x8ee8
movsd %xmm0, 0x241ad(%rip)    # 0x2d600
movslq %r15d, %rdx
leaq 0x1ed53(%rip), %rax     # 0x281b0
movsbq -0x1(%rdx,%rax), %rcx
xorl $0x2, %edx
movl %r14d, %esi
andl $0x3, %esi
xorl %eax, %eax
orl %edx, %esi
jne 0x9496
pushq $0x64
popq %rsi
movl %r14d, %eax
cltd
idivl %esi
testl %edx, %edx
je 0x9484
pushq $0x1
popq %rax
jmp 0x9496
movl $0x190, %esi            # imm = 0x190
movl %r14d, %eax
cltd
idivl %esi
xorl %eax, %eax
testl %edx, %edx
sete %al
movl %eax, %r13d
addq %rcx, %r13
pushq $0x1
popq %r12
leaq 0x24159(%rip), %rbx     # 0x2d600
cmpq %r13, %r12
jg 0x94c5
movl %r15d, %edi
movl %r12d, %esi
movl %r14d, %edx
callq 0x8ee8
movsd %xmm0, (%rbx,%r12,8)
incq %r12
jmp 0x94a7
leaq 0xc(%rsp), %r12
movl %r15d, (%r12)
leal 0x1(%r13), %eax
movl %eax, 0x4(%r12)
movl %r14d, 0x8(%r12)
movq %r12, %rdi
callq 0x9aa7
movl (%r12), %edi
movl 0x4(%r12), %esi
movl 0x8(%r12), %edx
callq 0x8ee8
movslq %r13d, %rax
movsd %xmm0, 0x8(%rbx,%rax,8)
movl %r15d, 0x240ed(%rip)    # 0x2d5f4
movl %r14d, 0x240e2(%rip)    # 0x2d5f0
movq (%rsp), %rcx
movslq %ebp, %rax
leaq 0x240e4(%rip), %rdx     # 0x2d600
movsd -0x8(%rdx,%rax,8), %xmm1
movsd (%rdx,%rax,8), %xmm0
movsd 0x8(%rdx,%rax,8), %xmm4
movsd 0xaad3(%rip), %xmm5     # 0x14008
movapd %xmm0, %xmm3
addsd %xmm5, %xmm3
movapd %xmm0, %xmm2
cmpltsd %xmm1, %xmm2
andpd %xmm2, %xmm3
andnpd %xmm0, %xmm2
orpd %xmm3, %xmm2
addsd %xmm4, %xmm5
movapd %xmm4, %xmm3
cmpltsd %xmm1, %xmm3
andpd %xmm3, %xmm5
andnpd %xmm4, %xmm3
orpd %xmm5, %xmm3
pushq $0x1
popq %rdx
pushq $-0x1
popq %rax
movsd 0x13e1f(%rip), %xmm4    # 0x1d398
movapd 0x13f1f(%rip), %xmm5    # 0x1d4a0
cmpl $0x5, %edx
je 0x95d1
cvtsi2sd %edx, %xmm6
mulsd %xmm4, %xmm6
ucomisd %xmm1, %xmm6
jbe 0x95c8
ucomisd %xmm6, %xmm3
jbe 0x95c8
movapd %xmm2, %xmm7
subsd %xmm6, %xmm7
andpd %xmm5, %xmm7
movapd %xmm6, %xmm8
subsd %xmm1, %xmm8
ucomisd %xmm7, %xmm8
jbe 0x95c8
movapd %xmm3, %xmm8
subsd %xmm6, %xmm8
ucomisd %xmm7, %xmm8
ja 0x95cc
incl %edx
jmp 0x9581
andl $0x3, %edx
movl %edx, %eax
movl %eax, (%rcx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/mmayer[P]pcal/src/pcalutil.c
// Function: alloc
char *alloc (int size)
{
   char *p;
   
   /* not all calloc()s like null requests */
   if (size == 0) size = 1;
   
   if ((p = (char *)calloc(1, size)) == NULL) {
      fprintf(stderr, E_ALLOC_ERR, progname);
      exit(EXIT_FAILURE);
   }

   return p;
}

// Assembly:
pushq %rax
cmpl $0x1, %edi
adcl $0x0, %edi
movslq %edi, %rsi
pushq $0x1
popq %rdi
callq 0x51e0
testq %rax, %rax
je 0x95fd
popq %rcx
retq
movq 0x1e9f4(%rip), %rax     # 0x27ff8
movq (%rax), %rdi
leaq 0x13ef2(%rip), %rsi     # 0x1d500
leaq 0x2320b(%rip), %rdx     # 0x2c820
xorl %eax, %eax
callq 0x5200
pushq $0x1
popq %rdi
callq 0x52f0
// File: /workspace/github_c_makefile_star2_O2/mmayer[P]pcal/src/pcalutil.c
// Function: ci_strncmp
int ci_strncmp (register char *s1, register char *s2, int n)
{
   register char c1, c2;
   
   for (c1 = c2 = '\0'; --n >= 0 && (c1 = tolower(*s1)) == (c2 = tolower(*s2)); s1++, s2++) {
      if (c1 == '\0') return 0;
   }

   return n < 0 ? 0 : c1 - c2;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
xorl %eax, %eax
xorl %ecx, %ecx
testl %ebx, %ebx
jle 0x96b1
callq 0x5320
movq (%rax), %rcx
movsbq (%r15,%r12), %rax
movl (%rcx,%rax,4), %eax
movl %eax, %edx
shll $0x18, %edx
movsbq (%r14,%r12), %rsi
movl (%rcx,%rsi,4), %ecx
movl %ecx, %esi
shll $0x18, %esi
cmpl %esi, %edx
jne 0x96bb
testl %edx, %edx
je 0x96cc
incq %r12
decl %ebx
jmp 0x967c
shll $0x18, %eax
shll $0x18, %ecx
movl %ecx, %esi
movl %eax, %edx
sarl $0x18, %edx
sarl $0x18, %esi
subl %esi, %edx
xorl %eax, %eax
testl %ebx, %ebx
cmovgl %edx, %eax
jmp 0x96ce
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mmayer[P]pcal/src/pcalutil.c
// Function: define_font
void define_font (char *orig_font, char *new_font, char *dflt_font)
{
   char *ofont, *nfont, *osize, *nsize, tmp1[STRSIZ], tmp2[STRSIZ];

   /* use default font/size if new font is null */
   
   if (new_font == NULL || new_font[0] == '\0') {
      strcpy(orig_font, dflt_font);
      return;
   }
   
   /* split old and new fonts into font/size components */
   SPLIT(orig_font, ofont, osize, '/');
   
   new_font = strcpy(tmp1, new_font);
   SPLIT(new_font, nfont, nsize, '/');
   
   /* use default size if new font size invalid */
   if (nsize[0] && atoi(nsize) <= 0) nsize = strrchr(dflt_font, '/') + 1;
   
   /* replace fields of old font with specified fields from new */
   
   strcpy(tmp2, nfont[0] ? nfont : ofont);
   strcat(tmp2, "/");
   strcat(tmp2, nsize[0] ? nsize : osize);
   
   strcpy(orig_font, tmp2);

   return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdx, %r15
movq %rdi, %rbx
testq %rsi, %rsi
je 0x9718
movq %rsi, %r12
cmpb $0x0, (%rsi)
je 0x9718
pushq $0x2f
popq %rsi
movq %rbx, %rdi
callq 0x5150
testq %rax, %rax
je 0x9733
movq %rax, %r14
movb $0x0, (%rax)
incq %r14
jmp 0x973a
movq %rbx, %rdi
movq %r15, %rsi
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x50a0
leaq 0x15023(%rip), %r14     # 0x1e75d
pushq $0x2f
popq %rsi
movq %rbx, %rdi
callq 0x5120
testq %rax, %rax
je 0x974d
movb $0x0, (%rax)
movq %rsp, %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x50a0
pushq $0x2f
popq %rsi
movq %r13, %rdi
callq 0x5150
testq %rax, %rax
je 0x9776
movq %rax, %r12
movb $0x0, (%rax)
incq %r12
jmp 0x977d
leaq 0x14fe0(%rip), %r12     # 0x1e75d
movq %rsp, %r13
pushq $0x2f
popq %rsi
movq %r13, %rdi
callq 0x5120
testq %rax, %rax
je 0x9793
movb $0x0, (%rax)
cmpb $0x0, (%r12)
je 0x97b7
movq %r12, %rdi
callq 0x52c0
testl %eax, %eax
jg 0x97b7
pushq $0x2f
popq %rsi
movq %r15, %rdi
callq 0x5150
movq %rax, %r12
incq %r12
cmpb $0x0, (%rsp)
cmoveq %rbx, %r13
leaq 0xd0(%rsp), %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0x50a0
movq %r15, %rdi
callq 0x5100
movw $0x2f, 0xd0(%rsp,%rax)
cmpb $0x0, (%r12)
cmovneq %r12, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x52d0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x50a0
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mmayer[P]pcal/src/pcalutil.c
// Function: set_fontstyle
char *set_fontstyle (char *p, char *esc)
{
   if (output_type == OUTPUT_PS) {
      *p++ = ' ';
      strcpy(p, esc);
      p += strlen(esc);
      strcpy(prevfont, currfont);
      strcpy(currfont, esc);
   }
   else if (output_type == OUTPUT_HTML) {
      *p++ = '<';
      if (strchr("rpRP", esc[1])) {
         sprintf(p, "/%c", currfont[1]);
         p += 2;
         strcpy(currfont, prevfont);
      }
      else {
         *p++ = esc[1];
         strcpy(prevfont, currfont);
         strcpy(currfont, esc);
      }
   }
   
   return p;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x22cb6(%rip), %rax     # 0x2c6b8
movl (%rax), %eax
cmpl $0x2, %eax
je 0x9a30
testl %eax, %eax
jne 0x9a9f
leaq 0x1(%rbx), %rdi
movb $0x20, (%rbx)
movq %r14, %rsi
callq 0x50a0
movq %r14, %rdi
callq 0x5100
addq %rax, %rbx
incq %rbx
jmp 0x9a7d
movb $0x3c, (%rbx)
movb 0x1(%r14), %bpl
movsbl %bpl, %esi
leaq 0x13ae3(%rip), %rdi     # 0x1d525
pushq $0x5
popq %rdx
callq 0x51d0
testq %rax, %rax
je 0x9a75
leaq 0x1(%rbx), %rdi
movsbl 0x23cc1(%rip), %edx     # 0x2d71b
leaq 0x13ac9(%rip), %rsi     # 0x1d52a
xorl %eax, %eax
callq 0x52e0
addq $0x3, %rbx
leaq 0x23c9d(%rip), %r14     # 0x2d710
jmp 0x9a90
movb %bpl, 0x1(%rbx)
addq $0x2, %rbx
leaq 0x23c8c(%rip), %rdi     # 0x2d710
leaq 0x23c8f(%rip), %rsi     # 0x2d71a
callq 0x50a0
leaq 0x23c83(%rip), %rdi     # 0x2d71a
movq %r14, %rsi
callq 0x50a0
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq