LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xb5b5
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xb5b5
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
cmpq $0x0, 0x10(%rax)
jne 0xb5cc
movq -0x8(%rbp), %rdi
leaq 0x28ef(%rip), %rsi      # 0xdeaf
movb $0x0, %al
callq 0x4080
jmp 0xb65f
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xb640
callq 0x2060
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
subq -0x20(%rbp), %rdx
callq *%rax
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
jle 0xb628
movslq -0x24(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0xb63e
cmpl $0x0, -0x24(%rbp)
je 0xb638
callq 0x2060
cmpl $0x4, (%rax)
je 0xb63a
jmp 0xb640
jmp 0xb63c
jmp 0xb63e
jmp 0xb5db
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0xb65f
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %edx
leaq 0x2869(%rip), %rsi      # 0xdec1
movb $0x0, %al
callq 0x4080
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hilbix[P]unbuffered/./tino/file.h
// Function: tino_file_blockingE
static int
tino_file_blockingE(int fd, int block)
{
  int	flag, upd;

  flag	= TINO_F_fcntl(fd, F_GETFL, 0);
  if (flag==-1)
    return -1;
  upd	= block ? (flag&~O_NONBLOCK) : (flag|O_NONBLOCK);
  if (flag!=upd && TINO_F_fcntl(fd, F_SETFL, upd))
    return -1;
  return flag&O_NONBLOCK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0x8(%rbp), %edi
movl $0x3, %esi
xorl %edx, %edx
movb $0x0, %al
callq 0x2290
movl %eax, -0x10(%rbp)
cmpl $-0x1, -0x10(%rbp)
jne 0xb6a1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb6f8
cmpl $0x0, -0xc(%rbp)
je 0xb6b4
movl -0x10(%rbp), %eax
andl $0xfffff7ff, %eax       # imm = 0xFFFFF7FF
movl %eax, -0x18(%rbp)
jmp 0xb6bf
movl -0x10(%rbp), %eax
orl $0x800, %eax            # imm = 0x800
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0xb6ed
movl -0x8(%rbp), %edi
movl -0x14(%rbp), %edx
movl $0x4, %esi
movb $0x0, %al
callq 0x2290
cmpl $0x0, %eax
je 0xb6ed
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb6f8
movl -0x10(%rbp), %eax
andl $0x800, %eax            # imm = 0x800
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/file.h
// Function: tino_file_readE
static int
tino_file_readE(int fd, char *buf, size_t len)
{
  int	got;

  do
    {
      got	= tino_file_readI(fd, buf, len);
#ifdef TINO_ALARM_RUN
      TINO_ALARM_RUN();
#endif
      /* Now, there are systems where EINTR means death, as POSIX
       * allows to return -1 after data has been transferred.  *SIGH*
       *
       * We cannot detect this case after it occurred, so we have to
       * prepare against this case.  However this is slow and clumsy.
       * Leave this for the future in tino_io
       */
    } while (got<0 && errno==EINTR);
  return got;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4030
movl %eax, -0x1c(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x1d(%rbp)
jge 0xb74f
callq 0x2060
cmpl $0x4, (%rax)
sete %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0xb723
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hilbix[P]unbuffered/./tino/xd.h
// Function: tino_uni2prn
static int
tino_uni2prn(unsigned c)
{
  if (c>0xff)
    return '?';
  if (c<0x20 || (c>=0x7f && c<0xa0))
    return '.';
  return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0xff, -0x8(%rbp)
jbe 0xbb49
movl $0x3f, -0x4(%rbp)
jmp 0xbb6d
cmpl $0x20, -0x8(%rbp)
jb 0xbb5e
cmpl $0x7f, -0x8(%rbp)
jb 0xbb67
cmpl $0xa0, -0x8(%rbp)
jae 0xbb67
movl $0x2e, -0x4(%rbp)
jmp 0xbb6d
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hilbix[P]unbuffered/./tino/data.h
// Function: tino_data_vprintfA
static void
tino_data_vprintfA(TINO_DATA *d, TINO_VA_LIST list)
{
  TINO_BUF	buf;

  tino_buf_initO(&buf);
  tino_buf_vprintfO(&buf, list);
  tino_data_writeA(d, tino_buf_getN(&buf), tino_buf_get_lenO(&buf));
  tino_buf_freeO(&buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x98f0
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xb270
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3450
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3410
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
callq 0xb580
leaq -0x30(%rbp), %rdi
callq 0xbbf0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xbc22
leaq 0x141d(%rip), %rdi      # 0xd027
leaq 0x13e0(%rip), %rsi      # 0xcff1
movl $0xa4, %edx
leaq 0x22f2(%rip), %rcx      # 0xdf0f
callq 0x3510
jmp 0xbc24
jmp 0xbc26
jmp 0xbc28
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xbc40
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xb0b0
movq -0x8(%rbp), %rdi
callq 0x98f0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hilbix[P]unbuffered/./tino/buf.h
// Function: tino_buf_advance_nO
static int
tino_buf_advance_nO(TINO_BUF *buf, int max)
{
  cDP(("(%p,%d)", buf, max));
  if (!buf)
    return 0;
  max	+= buf->off;
  tino_FATAL(max<0);
  buf->off	= ((unsigned)max>buf->fill ? buf->fill : max);
  return buf->fill-buf->off;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
jmp 0xbc61
cmpq $0x0, -0x10(%rbp)
jne 0xbc71
movl $0x0, -0x4(%rbp)
jmp 0xbce9
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movslq -0x14(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0xbca8
leaq 0x22a4(%rip), %rdi      # 0xdf34
leaq 0x135a(%rip), %rsi      # 0xcff1
movl $0x1c9, %edx            # imm = 0x1C9
leaq 0x2297(%rip), %rcx      # 0xdf3a
callq 0x3510
jmp 0xbcaa
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jbe 0xbcc3
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xbccb
movslq -0x14(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
subq 0x10(%rcx), %rax
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/data.h
// Function: tino_data_freeA
static void
tino_data_freeA(TINO_DATA *d)
{
  if (d->handler && d->handler->free)
    d->handler->free(d);
  d->handler	= 0;
  tino_buf_freeO(&d->buf);
  if (d->allocated /* avoid GCC 4.4.5 bug: && d->allocated==d */)
    free(d->allocated);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xbd78
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
cmpq $0x0, 0x40(%rax)
je 0xbd78
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rdi
callq 0xbbf0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0xbda5
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x2050
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movl 0x28e17(%rip), %eax     # 0x2e218
movl %eax, 0x2d3a5(%rip)     # 0x327ac
movw 0x28e0e(%rip), %ax      # 0x2e21c
movw %ax, 0x2d39b(%rip)      # 0x327b0
movb 0x28e03(%rip), %al      # 0x2e21e
movb %al, 0x2d391(%rip)      # 0x327b2
movl $0xffffffff, 0x2d389(%rip) # imm = 0xFFFFFFFF
movl $0x0, 0x2cef3(%rip)     # 0x32328
leaq 0x2d384(%rip), %rdi     # 0x327c0
leaq 0x2981d(%rip), %rsi     # 0x2ec60
callq 0x5080
xorl %edi, %edi
callq 0x5540
movq %rax, %rdi
callq 0xec90
leaq -0xd0(%rbp), %rdi
movslq 0x2d343(%rip), %rcx     # 0x327a8
leaq 0x2a594(%rip), %rax     # 0x2fa00
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdx
leaq 0x1695d(%rip), %rsi     # 0x1bdda
movb $0x0, %al
callq 0x52a0
leaq -0xd0(%rbp), %rdi
callq 0xec90
leaq -0xd0(%rbp), %rdi
movl 0x28d87(%rip), %ecx     # 0x2e224
leaq 0x16af0(%rip), %rdx     # 0x1bf94
leaq 0x16ad4(%rip), %rax     # 0x1bf7f
cmpl $0x0, %ecx
cmoveq %rax, %rdx
leaq 0x1692e(%rip), %rsi     # 0x1bde7
movb $0x0, %al
callq 0x52a0
leaq -0xd0(%rbp), %rdi
callq 0xec90
leaq -0xd0(%rbp), %rdi
leaq 0x2d3b6(%rip), %rsi     # 0x32890
callq 0x5080
leaq -0xd0(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq -0xd8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x5528
movq -0xd8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x5512
movq -0xd8(%rbp), %rax
movb $0x5f, (%rax)
jmp 0x5514
movq -0xd8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xd8(%rbp)
jmp 0x54ed
leaq -0xd0(%rbp), %rdi
callq 0xec90
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
leaq 0x2e026(%rip), %rdi     # 0x33578
leaq 0x16b80(%rip), %rsi     # 0x1c0d9
callq 0x5080
leaq 0x2e013(%rip), %rdi     # 0x33578
callq 0x50e0
movq %rax, %rcx
leaq 0x2e004(%rip), %rax     # 0x33578
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x2, -0x14(%rbp)
jge 0x55b7
movslq -0x4(%rbp), %rcx
leaq 0x2c9cd(%rip), %rax     # 0x31f60
imulq $0x14, %rcx, %rcx
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5582
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
leaq 0x2dfae(%rip), %rax     # 0x33578
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $0x6, -0x8(%rbp)
jg 0x5848
movslq -0x8(%rbp), %rcx
leaq 0x2cf8d(%rip), %rax     # 0x327ac
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x583b
movl -0x4(%rbp), %eax
movb %al, %dl
movslq -0x8(%rbp), %rcx
leaq 0x2cf74(%rip), %rax     # 0x327ac
movb %dl, (%rax,%rcx)
jmp 0x583d
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x580e
cmpl $0x0, 0x2cf65(%rip)     # 0x327b4
je 0x5863
cmpl $-0x1, 0x2cf5c(%rip)    # 0x327b4
je 0x5863
movl -0x4(%rbp), %eax
movl %eax, 0x2cf51(%rip)     # 0x327b4
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x9(%rbp)
leaq 0x293ef(%rip), %rax     # 0x2ec70
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x58b7
movsbl -0x9(%rbp), %eax
movq -0x18(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x58a7
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x58d8
jmp 0x58a9
movq -0x18(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x18(%rbp)
jmp 0x5885
movsbl -0x9(%rbp), %eax
cmpl $0x0, %eax
je 0x58c8
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0x58d0
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x58fb
movl $0x0, 0x2ce63(%rip)     # 0x3275c
jmp 0x5963
jmp 0x58fd
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb (%rax), %al
movb %al, -0x9(%rbp)
movsbl %al, %eax
cmpl $0x0, %eax
je 0x5961
leaq 0x293f0(%rip), %rax     # 0x2ed10
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x595f
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jne 0x594f
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
orl 0x2ce13(%rip), %eax     # 0x3275c
movl %eax, 0x2ce0d(%rip)     # 0x3275c
jmp 0x5951
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
jmp 0x5924
jmp 0x58fd
jmp 0x5963
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl 0x2adfe(%rip), %eax     # 0x3275c
andl $0x8, %eax
cmpl $0x0, %eax
je 0x79f5
movq 0x26687(%rip), %rax     # 0x2dff8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x1471e(%rip), %rsi     # 0x1c09d
movb $0x0, %al
callq 0x51b0
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
je 0x79f3
movq 0x26659(%rip), %rax     # 0x2dff8
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x79c2
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0x79cf
leaq 0x14704(%rip), %rax     # 0x1c0cd
movq %rax, -0x48(%rbp)
jmp 0x79cf
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0x146e9(%rip), %rsi     # 0x1c0c7
movb $0x0, %al
callq 0x51b0
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
jmp 0x798e
jmp 0x79f5
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
je 0x7a76
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0xd530
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x5250
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x7a66
movl 0x2ad24(%rip), %eax     # 0x3275c
andl $0x8, %eax
cmpl $0x0, %eax
je 0x7a5c
movq 0x265b1(%rip), %rax     # 0x2dff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x1467a(%rip), %rsi     # 0x1c0cf
movb $0x0, %al
callq 0x51b0
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7a85
jmp 0x7a68
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
jmp 0x79fd
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
leaq 0x1616c(%rip), %rdi     # 0x1eba7
movb $0x0, %al
callq 0x5110
leaq 0x1616b(%rip), %rdi     # 0x1ebb4
movb $0x0, %al
callq 0x5110
leaq 0x16191(%rip), %rdi     # 0x1ebe8
movb $0x0, %al
callq 0x5110
leaq 0x16191(%rip), %rdi     # 0x1ebf6
movb $0x0, %al
callq 0x5110
leaq 0x161d3(%rip), %rdi     # 0x1ec46
movb $0x0, %al
callq 0x5110
leaq 0x16167(%rip), %rdi     # 0x1ebe8
movb $0x0, %al
callq 0x5110
leaq 0x161f3(%rip), %rdi     # 0x1ec82
movb $0x0, %al
callq 0x5110
leaq 0x161ff(%rip), %rdi     # 0x1ec9c
movb $0x0, %al
callq 0x5110
leaq 0x1fa7e(%rip), %rdi     # 0x28529
movb $0x0, %al
callq 0x5110
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
leaq 0x15eec(%rip), %rdi     # 0x1eba7
movb $0x0, %al
callq 0x5110
leaq 0x16900(%rip), %rdi     # 0x1f5c9
movb $0x0, %al
callq 0x5110
leaq 0x15f11(%rip), %rdi     # 0x1ebe8
movb $0x0, %al
callq 0x5110
leaq 0x15f11(%rip), %rdi     # 0x1ebf6
movb $0x0, %al
callq 0x5110
leaq 0x15f53(%rip), %rdi     # 0x1ec46
movb $0x0, %al
callq 0x5110
leaq 0x15ee7(%rip), %rdi     # 0x1ebe8
movb $0x0, %al
callq 0x5110
leaq 0x15f73(%rip), %rdi     # 0x1ec82
movb $0x0, %al
callq 0x5110
leaq 0x15f7f(%rip), %rdi     # 0x1ec9c
movb $0x0, %al
callq 0x5110
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
leaq 0x152cc(%rip), %rdi     # 0x1eba7
movb $0x0, %al
callq 0x5110
leaq 0x18cb9(%rip), %rdi     # 0x225a2
movb $0x0, %al
callq 0x5110
leaq 0x152f1(%rip), %rdi     # 0x1ebe8
movb $0x0, %al
callq 0x5110
leaq 0x152f1(%rip), %rdi     # 0x1ebf6
movb $0x0, %al
callq 0x5110
leaq 0x15333(%rip), %rdi     # 0x1ec46
movb $0x0, %al
callq 0x5110
leaq 0x152c7(%rip), %rdi     # 0x1ebe8
movb $0x0, %al
callq 0x5110
leaq 0x15353(%rip), %rdi     # 0x1ec82
movb $0x0, %al
callq 0x5110
leaq 0x1535f(%rip), %rdi     # 0x1ec9c
movb $0x0, %al
callq 0x5110
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmayer[P]pcal/src/exprpars.c
// Function: lookup_token
static TOKEN * lookup_token (char *p)
{
   TOKEN *ptok;
   
   for (ptok = token_tbl;
        ptok->name && strncmp(p, ptok->name, strlen(ptok->name));
        ptok++)
      ;
   
   return ptok;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x254fd(%rip), %rax     # 0x2fb10
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x11(%rbp)
je 0xa65e
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x50e0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq %rax, %rdx
callq 0x5070
cmpl $0x0, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0xa667
jmp 0xa677
jmp 0xa669
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
jmp 0xa617
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmayer[P]pcal/src/moonphas.c
// Function: kepler
static double kepler (double m, double ecc)
{
   double e, delta;
#define EPSILON 1E-6

   e = m = torad(m);
   do {
      delta = e - ecc * sin(e) - m;
      e -= delta / (1 - ecc * cos(e));
   } while (abs(delta) > EPSILON);
   return e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd 0x19676(%rip), %xmm0    # 0x24510
mulsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x5260
movsd -0x40(%rbp), %xmm1
movaps %xmm0, %xmm2
movsd -0x38(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
subsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x5170
movsd -0x30(%rbp), %xmm1
movaps %xmm0, %xmm2
movsd -0x28(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
movsd 0x100bd(%rip), %xmm2    # 0x1b008
addsd %xmm2, %xmm0
divsd %xmm0, %xmm1
movsd -0x18(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x20(%rbp), %xmm0
jbe 0xaf8e
movsd -0x20(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x48(%rbp)
jmp 0xaf98
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
movsd 0x19643(%rip), %xmm1    # 0x245e8
ucomisd %xmm1, %xmm0
ja 0xaea9
movsd -0x18(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x2869e(%rip), %eax     # 0x3367c
jne 0xafeb
movl -0xc(%rbp), %eax
cmpl 0x2868f(%rip), %eax     # 0x33678
je 0xb00f
movl -0x4(%rbp), %esi
movl -0xc(%rbp), %edx
leaq 0x28688(%rip), %rdi     # 0x33680
callq 0xb070
movl -0x4(%rbp), %eax
movl %eax, 0x28676(%rip)     # 0x3367c
movl -0xc(%rbp), %eax
movl %eax, 0x28669(%rip)     # 0x33678
movslq -0x8(%rbp), %rcx
leaq 0x28666(%rip), %rax     # 0x33680
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x8(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x2864c(%rip), %rax     # 0x33680
movsd (%rax,%rcx,8), %xmm0
movsd -0x20(%rbp), %xmm1
movl -0x8(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x28632(%rip), %rax     # 0x33680
movsd (%rax,%rcx,8), %xmm2
callq 0xb1b0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movsd -0x20(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmayer[P]pcal/src/moonphas.c
// Function: gen_phases
static void gen_phases (double phase[], int month, int year)
{
   int day, len;
   date_str date;
   
   /* start with moon phase for last day of previous month */
   MAKE_DATE(date, month, 0, year);
   normalize(&date);
   phase[0] = calc_phase(date.mm, date.dd, date.yy);
   
   /* add the moon phases for all days in the current month */
   for (day = 1, len = LENGTH_OF(month, year); day <= len; day++) {
      phase[day] = calc_phase(month, day, year);
   }

   /* append the moon phase for the first day of next month */
   MAKE_DATE(date, month, len + 1, year);
   normalize(&date);
   phase[len + 1] = calc_phase(date.mm, date.dd, date.yy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x1c(%rbp)
leaq -0x24(%rbp), %rdi
callq 0xbb80
movl -0x24(%rbp), %edi
movl -0x20(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0xa690
movq -0x8(%rbp), %rax
movsd %xmm0, (%rax)
movl $0x1, -0x14(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x230c5(%rip), %rax     # 0x2e190
movsbl (%rax,%rcx), %eax
movl %eax, -0x2c(%rbp)
xorl %eax, %eax
cmpl $0x2, -0xc(%rbp)
movb %al, -0x25(%rbp)
jne 0xb127
movl -0x10(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
xorl %eax, %eax
cmpl $0x0, %edx
movb %al, -0x2d(%rbp)
jne 0xb121
movl -0x10(%rbp), %eax
movl $0x64, %ecx
cltd
idivl %ecx
movb $0x1, %al
cmpl $0x0, %edx
movb %al, -0x2e(%rbp)
jne 0xb11b
movl -0x10(%rbp), %eax
movl $0x190, %ecx            # imm = 0x190
cltd
idivl %ecx
cmpl $0x0, %edx
sete %al
movb %al, -0x2e(%rbp)
movb -0x2e(%rbp), %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
movb %al, -0x25(%rbp)
movl -0x2c(%rbp), %eax
movb -0x25(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
addl %ecx, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jg 0xb166
movl -0xc(%rbp), %edi
movl -0x14(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0xa690
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xb138
jmp 0xb168
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x1c(%rbp)
leaq -0x24(%rbp), %rdi
callq 0xbb80
movl -0x24(%rbp), %edi
movl -0x20(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0xa690
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mmayer[P]pcal/src/moonphas.c
// Function: is_quarter
static int is_quarter (double prev, double curr, double next)
{
   int quarter;
   double phase, diff;
   
   /* adjust phases for 1 -> 0 wraparound */
   if (curr < prev) curr++; 
   if (next < prev) next++;

   /* if a quarter moon has occurred between "prev" and "next", return TRUE if
    * "curr" is closer to it than "prev" or "next" is
    */
   for (quarter = 1; quarter <= 4; quarter++) {
      if (prev < (phase = quarter/4.0) && next > phase &&
          (diff = fabs(curr - phase)) < phase - prev && diff < next - phase) {
         return quarter % 4;   /* MOON_NM == 0 */
      }
   }
   
   return MOON_OTHER;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movsd -0x18(%rbp), %xmm1
movsd -0x10(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xb1e5
movsd 0xfe2d(%rip), %xmm0     # 0x1b008
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x20(%rbp), %xmm1
movsd -0x10(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xb207
movsd 0xfe0b(%rip), %xmm0     # 0x1b008
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
cmpl $0x4, -0x24(%rbp)
jg 0xb2a4
movsd -0x10(%rbp), %xmm1
cvtsi2sdl -0x24(%rbp), %xmm0
movsd 0x1937e(%rip), %xmm2    # 0x245a8
divsd %xmm2, %xmm0
movsd %xmm0, -0x30(%rbp)
ucomisd %xmm1, %xmm0
jbe 0xb294
movsd -0x20(%rbp), %xmm0
ucomisd -0x30(%rbp), %xmm0
jbe 0xb294
movsd -0x18(%rbp), %xmm1
subsd -0x30(%rbp), %xmm1
movaps 0x1939a(%rip), %xmm0    # 0x245f0
pand %xmm0, %xmm1
movsd %xmm1, -0x38(%rbp)
movsd -0x30(%rbp), %xmm0
subsd -0x10(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xb294
movsd -0x38(%rbp), %xmm1
movsd -0x20(%rbp), %xmm0
subsd -0x30(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xb294
movl -0x24(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %edx, -0x4(%rbp)
jmp 0xb2ab
jmp 0xb296
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xb20e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0xb2c8
movl $0x1, -0x4(%rbp)
movslq -0x4(%rbp), %rsi
movl $0x1, %edi
callq 0x5190
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0xb309
movq 0x22d11(%rip), %rax     # 0x2dff8
movq (%rax), %rdi
leaq 0x19338(%rip), %rsi     # 0x24629
leaq 0x275b8(%rip), %rdx     # 0x328b0
movb $0x0, %al
callq 0x51b0
movl $0x1, %edi
callq 0x52b0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmayer[P]pcal/src/pcalutil.c
// Function: ci_strcmp
int ci_strcmp (register char *s1, register char *s2)
{
   register char c1, c2;
   
   for ( ; (c1 = tolower(*s1)) == (c2 = tolower(*s2)); s1++, s2++) {
      if (c1 == '\0') return 0;
   }
   return c1 - c2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x51e0
movb %al, -0x19(%rbp)
movsbl %al, %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0x51e0
movl %eax, %ecx
movl -0x20(%rbp), %eax
movb %cl, -0x1a(%rbp)
movsbl %cl, %ecx
cmpl %ecx, %eax
jne 0xb38e
movsbl -0x19(%rbp), %eax
cmpl $0x0, %eax
jne 0xb372
movl $0x0, -0x4(%rbp)
jmp 0xb39b
jmp 0xb374
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xb330
movsbl -0x19(%rbp), %eax
movsbl -0x1a(%rbp), %ecx
subl %ecx, %eax
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/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movb $0x0, -0x1e(%rbp)
movb $0x0, -0x1d(%rbp)
movl -0x1c(%rbp), %ecx
addl $-0x1, %ecx
movl %ecx, -0x1c(%rbp)
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x1f(%rbp)
jl 0xb412
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x51e0
movb %al, -0x1d(%rbp)
movsbl %al, %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0x51e0
movl %eax, %ecx
movl -0x24(%rbp), %eax
movb %cl, -0x1e(%rbp)
movsbl %cl, %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x1f(%rbp)
movb -0x1f(%rbp), %al
testb $0x1, %al
jne 0xb41b
jmp 0xb449
movsbl -0x1d(%rbp), %eax
cmpl $0x0, %eax
jne 0xb42d
movl $0x0, -0x4(%rbp)
jmp 0xb469
jmp 0xb42f
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xb3cb
cmpl $0x0, -0x1c(%rbp)
jge 0xb456
xorl %eax, %eax
movl %eax, -0x28(%rbp)
jmp 0xb463
movsbl -0x1d(%rbp), %eax
movsbl -0x1e(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%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/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x26cf1(%rip), %rax     # 0x32748
cmpl $0x0, (%rax)
jne 0xbab4
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $0x20, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5080
movq -0x10(%rbp), %rdi
callq 0x50e0
addq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq 0x27cfd(%rip), %rdi     # 0x33790
leaq 0x27d00(%rip), %rsi     # 0x3379a
callq 0x5080
movq -0x10(%rbp), %rsi
leaq 0x27cf0(%rip), %rdi     # 0x3379a
callq 0x5080
jmp 0xbb69
leaq 0x26c8d(%rip), %rax     # 0x32748
cmpl $0x2, (%rax)
jne 0xbb67
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $0x3c, (%rax)
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %esi
leaq 0x18b69(%rip), %rdi     # 0x2464e
callq 0x5100
cmpq $0x0, %rax
je 0xbb2a
movq -0x8(%rbp), %rdi
movsbl 0x27ca0(%rip), %edx     # 0x3379b
leaq 0x18b51(%rip), %rsi     # 0x24653
movb $0x0, %al
callq 0x52a0
movq -0x8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
leaq 0x27c7e(%rip), %rdi     # 0x3379a
leaq 0x27c6d(%rip), %rsi     # 0x33790
callq 0x5080
jmp 0xbb65
movq -0x10(%rbp), %rax
movb 0x1(%rax), %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
leaq 0x27c47(%rip), %rdi     # 0x33790
leaq 0x27c4a(%rip), %rsi     # 0x3379a
callq 0x5080
movq -0x10(%rbp), %rsi
leaq 0x27c3a(%rip), %rdi     # 0x3379a
callq 0x5080
jmp 0xbb67
jmp 0xbb69
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmayer[P]pcal/src/pcalutil.c
// Function: note_day
int note_day (int mm, int n, int yy)
{
   int day, lastday;
   
   if (n == 0) n = NOTE_DEFAULT;   /* convert 0 to appropriate default */
      
   
   /* lastday depends on month length and presence (but not position) of small
      calendars
   */
   lastday = LAST_NOTE_DAY - (LENGTH_OF(mm, yy) - 28) - (small_cal_pos == SC_NONE ? 0 : 2);
   
   /* count forward if n is positive, backward if negative */
   day = (n > 0) ? FIRST_NOTE_DAY + n - 1 : lastday + n + 1;
   
   /* make sure result is valid for this month/year */
   return (day >= FIRST_NOTE_DAY && day <= lastday) ? day : 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0xc3da
movl $0xffffffff, -0x8(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x21da6(%rip), %rax     # 0x2e190
movsbl (%rax,%rcx), %eax
movl %eax, -0x1c(%rbp)
xorl %eax, %eax
cmpl $0x2, -0x4(%rbp)
movb %al, -0x15(%rbp)
jne 0xc446
movl -0xc(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
xorl %eax, %eax
cmpl $0x0, %edx
movb %al, -0x1d(%rbp)
jne 0xc440
movl -0xc(%rbp), %eax
movl $0x64, %ecx
cltd
idivl %ecx
movb $0x1, %al
cmpl $0x0, %edx
movb %al, -0x1e(%rbp)
jne 0xc43a
movl -0xc(%rbp), %eax
movl $0x190, %ecx            # imm = 0x190
cltd
idivl %ecx
cmpl $0x0, %edx
sete %al
movb %al, -0x1e(%rbp)
movb -0x1e(%rbp), %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
movb %al, -0x15(%rbp)
movl -0x1c(%rbp), %ecx
movb -0x15(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addl %eax, %ecx
subl $0x1c, %ecx
movl $0x2d, %eax
subl %ecx, %eax
leaq 0x22118(%rip), %rcx     # 0x2e57c
movl (%rcx), %esi
movl $0x2, %ecx
xorl %edx, %edx
cmpl $0x0, %esi
cmovel %edx, %ecx
subl %ecx, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x8(%rbp)
jle 0xc48c
movl -0x8(%rbp), %eax
addl $0x20, %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xc498
movl -0x14(%rbp), %eax
addl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x10(%rbp)
cmpl $0x20, -0x10(%rbp)
jl 0xc4b4
movl -0x10(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0xc4b4
movl -0x10(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0xc4bb
xorl %eax, %eax
movl %eax, -0x28(%rbp)
jmp 0xc4bb
movl -0x28(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mmayer[P]pcal/src/pcalutil.c
// Function: note_box
int note_box (int mm, int dd, int yy)
{
   int startbox = START_BOX(mm, yy), pc, nc;
   
   /* move starting box to second row if conflict with small calendars */
   pc = prev_cal_box[small_cal_pos];
   nc = next_cal_box[small_cal_pos];
   if (pc == startbox || nc == startbox) startbox += 7;
   
   dd -= FIRST_NOTE_DAY;   /* convert to note box number 0..13 */
   dd += (pc == 0) + (nc == 1);   /* adjust for small calendars in 0, 1 */
   
   /* position box after calendar body if no room before */
   return dd < startbox ? dd : dd + LENGTH_OF(mm, yy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl -0x4(%rbp), %edi
movl -0xc(%rbp), %edx
movl $0x1, %esi
callq 0xc110
leaq 0x26180(%rip), %rcx     # 0x32668
subl (%rcx), %eax
addl $0x7, %eax
movl $0x7, %ecx
cltd
idivl %ecx
movl %edx, -0x10(%rbp)
leaq 0x2207d(%rip), %rax     # 0x2e57c
movslq (%rax), %rcx
leaq 0x22077(%rip), %rax     # 0x2e580
movl (%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
leaq 0x22066(%rip), %rax     # 0x2e57c
movslq (%rax), %rcx
leaq 0x22070(%rip), %rax     # 0x2e590
movl (%rax,%rcx,4), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
je 0xc536
movl -0x18(%rbp), %eax
cmpl -0x10(%rbp), %eax
jne 0xc53f
movl -0x10(%rbp), %eax
addl $0x7, %eax
movl %eax, -0x10(%rbp)
movl -0x8(%rbp), %eax
subl $0x20, %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x14(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, -0x18(%rbp)
sete %cl
andb $0x1, %cl
movzbl %cl, %ecx
addl %ecx, %eax
addl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0xc57c
movl -0x8(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0xc604
movl -0x8(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x4(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x21bfe(%rip), %rax     # 0x2e190
movsbl (%rax,%rcx), %eax
movl %eax, -0x24(%rbp)
xorl %eax, %eax
cmpl $0x2, -0x4(%rbp)
movb %al, -0x1d(%rbp)
jne 0xc5ee
movl -0xc(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
xorl %eax, %eax
cmpl $0x0, %edx
movb %al, -0x29(%rbp)
jne 0xc5e8
movl -0xc(%rbp), %eax
movl $0x64, %ecx
cltd
idivl %ecx
movb $0x1, %al
cmpl $0x0, %edx
movb %al, -0x2a(%rbp)
jne 0xc5e2
movl -0xc(%rbp), %eax
movl $0x190, %ecx            # imm = 0x190
cltd
idivl %ecx
cmpl $0x0, %edx
sete %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
movb %al, -0x1d(%rbp)
movl -0x28(%rbp), %eax
movl -0x24(%rbp), %ecx
movb -0x1d(%rbp), %dl
andb $0x1, %dl
movzbl %dl, %edx
addl %edx, %ecx
addl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mmayer[P]pcal/src/pcalutil.c
// Function: century
int century (void)
{
   static int this_century = -1;
   struct tm *p_tm;
   time_t tmp;
   
   if (this_century < 0) {   /* calculate first time only */
      time(&tmp);
      p_tm = localtime(&tmp);
      this_century = ((TM_YEAR + p_tm->tm_year) / 100) * 100;
   }
   
   return this_century;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0x0, 0x23591(%rip)     # 0x2fbb0
jge 0xc654
leaq -0x10(%rbp), %rdi
callq 0x51d0
leaq -0x10(%rbp), %rdi
callq 0x5050
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
addl $0x76c, %eax            # imm = 0x76C
movl $0x64, %ecx
cltd
idivl %ecx
imull $0x64, %eax, %eax
movl %eax, 0x2355c(%rip)     # 0x2fbb0
movl 0x23556(%rip), %eax     # 0x2fbb0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mmayer[P]pcal/src/pcalutil.c
// Function: copy_text
void copy_text (char *pbuf, char **ptext)
{
   char *p, *pb;

   /* copy words to pbuf, separating by one blank */
   
   for (*(pb = pbuf) = '\0'; (p = *ptext) != NULL; *pb++ = *++ptext ? ' ' : '\0') {
      for ( ; *p; p++) {
         if (! (*p == ' ' && (pb == pbuf || pb[-1] == ' '))) *pb++ = *p;
      }
      if (pb > pbuf && pb[-1] == ' ') pb--;
   }
   return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xc9bf
jmp 0xc90e
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0xc961
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0xc93a
movq -0x20(%rbp), %rax
cmpq -0x8(%rbp), %rax
je 0xc951
movq -0x20(%rbp), %rax
movsbl -0x1(%rax), %eax
cmpl $0x20, %eax
je 0xc951
movq -0x18(%rbp), %rax
movb (%rax), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
jmp 0xc953
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xc90e
movq -0x20(%rbp), %rax
cmpq -0x8(%rbp), %rax
jbe 0xc984
movq -0x20(%rbp), %rax
movsbl -0x1(%rax), %eax
cmpl $0x20, %eax
jne 0xc984
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xc986
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rdx
xorl %eax, %eax
movl $0x20, %ecx
cmpq $0x0, %rdx
cmovnel %ecx, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
jmp 0xc8f7
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmayer[P]pcal/src/pcalutil.c
// Function: split_date
int split_date (char *pstr, int *pn1, int *pn2, int *pn3)
{
   int i, n, *pn;
   
   /* attempt to extract up to three numeric fields */
   for (n = 0, i = 1; i <= 3; i++) {
      pn = i == 1 ? pn1 : i == 2 ? pn2 : pn3;   /* crude but portable */
      if (pn) *pn = *pstr ? (n++, atoi(pstr)) : 0;
      SKIP_FIELD(pstr);   /* go to next field */
   }
   return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x1, -0x24(%rbp)
cmpl $0x3, -0x24(%rbp)
jg 0xcb24
cmpl $0x1, -0x24(%rbp)
jne 0xca10
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0xca30
cmpl $0x2, -0x24(%rbp)
jne 0xca20
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0xca28
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xca72
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xca62
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5280
movl %eax, -0x44(%rbp)
jmp 0xca69
xorl %eax, %eax
movl %eax, -0x44(%rbp)
jmp 0xca69
movl -0x44(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
jmp 0xca74
jmp 0xca76
movq -0x8(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x45(%rbp)
je 0xcaab
callq 0x52e0
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
setne %al
movb %al, -0x45(%rbp)
movb -0x45(%rbp), %al
testb $0x1, %al
jne 0xcab4
jmp 0xcac2
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0xca76
jmp 0xcac4
movq -0x8(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x46(%rbp)
je 0xcafb
callq 0x52e0
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x46(%rbp)
movb -0x46(%rbp), %al
testb $0x1, %al
jne 0xcb04
jmp 0xcb12
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0xcac4
jmp 0xcb14
jmp 0xcb16
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xc9f6
movl -0x28(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mmayer[P]pcal/src/pcalutil.c
// Function: octal_esc
static char *octal_esc (char *buf, char *val)
{
   int i, n, c;
   
   for (n = 0, i = 0; i < 3 && (c = buf[i]) && isodigit(c); i++) {
      n = n * 8 + (c - '0');
   }

   *val = n & CHAR_MSK;   /* fill in the value */
   return buf + i - 1;   /* return pointer to last character */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
xorl %eax, %eax
cmpl $0x3, -0x14(%rbp)
movb %al, -0x1d(%rbp)
jge 0xd019
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movl %ecx, -0x1c(%rbp)
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x1d(%rbp)
je 0xd019
xorl %eax, %eax
cmpl $0x30, -0x1c(%rbp)
movb %al, -0x1e(%rbp)
jl 0xd013
cmpl $0x37, -0x1c(%rbp)
setle %al
movb %al, -0x1e(%rbp)
movb -0x1e(%rbp), %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0xd022
jmp 0xd03e
movl -0x18(%rbp), %eax
shll $0x3, %eax
movl -0x1c(%rbp), %ecx
subl $0x30, %ecx
addl %ecx, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xcfda
movl -0x18(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
addq %rcx, %rax
addq $-0x1, %rax
popq %rbp
retq
nop