LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mmayer[P]pcal/src/pcalutil.c
// Function: hex_esc
static char *hex_esc (char *buf, char *val)
{
   int i, n, c;
   
   /* assume leading character is known to be 'x' or 'X'; skip it */
   buf++;
   
   for (n = 0, i = 0; i < 2 && (c = buf[i]) && isxdigit(c); i++) {
      n = n * 16 + (isupper(c) ? c - 'A' + 10 :
                    islower(c) ? c - 'a' + 10 :
                    c - '0');
   }
   
   *val = i == 0 ? buf[-1] : n & CHAR_MSK; /* fill in the value */
   return buf + i - 1;   /* return pointer to last character */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
xorl %eax, %eax
cmpl $0x2, -0x14(%rbp)
movb %al, -0x1d(%rbp)
jge 0xd0cc
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 0xd0cc
callq 0x52e0
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x1000, %eax           # imm = 0x1000
cmpl $0x0, %eax
setne %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0xd0d8
jmp 0xd159
movl -0x18(%rbp), %eax
shll $0x4, %eax
movl %eax, -0x24(%rbp)
callq 0x52e0
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0xd109
movl -0x1c(%rbp), %eax
subl $0x41, %eax
addl $0xa, %eax
movl %eax, -0x28(%rbp)
jmp 0xd140
callq 0x52e0
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x200, %eax            # imm = 0x200
cmpl $0x0, %eax
je 0xd131
movl -0x1c(%rbp), %eax
subl $0x61, %eax
addl $0xa, %eax
movl %eax, -0x2c(%rbp)
jmp 0xd13a
movl -0x1c(%rbp), %eax
subl $0x30, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
movl -0x28(%rbp), %ecx
addl %ecx, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xd08a
cmpl $0x0, -0x14(%rbp)
jne 0xd16c
movq -0x8(%rbp), %rax
movsbl -0x1(%rax), %eax
movl %eax, -0x30(%rbp)
jmp 0xd177
movl -0x18(%rbp), %eax
andl $0xff, %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %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
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmayer[P]pcal/src/pcalutil.c
// Function: html_esc
static char *html_esc (char *p, char *val)
{
   static struct {
      char *html;
      char ascii;
   } *pt, translate[] = {   /* special HTML sequences */
      { "&lt;", '<' },
      { "&gt;", '>' },
      { "&amp;", '&' },
      { "&quot;", '"' },
      { "&nbsp;", ' ' },
      { NULL, 0   }
   };
   
   if (*p == '&') {
      /* translate "&#NNN;" character sequences back to ASCII */
      if (p[1] == '#' &&
          isdigit((int)p[2]) && isdigit((int)p[3]) && isdigit((int)p[4]) &&
          p[5] == ';') {
         *val = atoi(p + 2);
         return p + 5;
      }
      /* look up predefined special characters in table above */
      for (pt = translate; pt->html; pt++) {
         int l = strlen(pt->html);
         if (ci_strncmp(p, pt->html, l) == 0) {
            *val = pt->ascii;
            return p + l - 1;
         }
      }
   }
   
   /* not an escape sequence - return original pointer */
   *val = *p;
   return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x26, %eax
jne 0xd2ec
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x23, %eax
jne 0xd267
callq 0x52e0
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl 0x2(%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0xd267
callq 0x52e0
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl 0x3(%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0xd267
callq 0x52e0
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl 0x4(%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0xd267
movq -0x10(%rbp), %rax
movsbl 0x5(%rax), %eax
cmpl $0x3b, %eax
jne 0xd267
movq -0x10(%rbp), %rdi
addq $0x2, %rdi
callq 0x5280
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
addq $0x5, %rax
movq %rax, -0x8(%rbp)
jmp 0xd300
leaq 0x22952(%rip), %rax     # 0x2fbc0
movq %rax, 0x26603(%rip)     # 0x33878
movq 0x265fc(%rip), %rax     # 0x33878
cmpq $0x0, (%rax)
je 0xd2ea
movq 0x265ef(%rip), %rax     # 0x33878
movq (%rax), %rdi
callq 0x50e0
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq 0x265d9(%rip), %rax     # 0x33878
movq (%rax), %rsi
movl -0x1c(%rbp), %edx
callq 0xb3b0
cmpl $0x0, %eax
jne 0xd2d4
movq 0x265c2(%rip), %rax     # 0x33878
movb 0x8(%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0xd300
jmp 0xd2d6
movq 0x2659b(%rip), %rax     # 0x33878
addq $0x10, %rax
movq %rax, 0x26590(%rip)     # 0x33878
jmp 0xd275
jmp 0xd2ec
movq -0x10(%rbp), %rax
movb (%rax), %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmayer[P]pcal/src/pcalutil.c
// Function: mk_path
char *mk_path (char *path, char *filespec)
{
   char *p;
   
   strcpy(path, filespec);
   if (!(p = strrchr(path, END_PATH))) {
      p = path - 1; /* return null string if no path */
   }

   *++p = '\0';
   return path;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5080
movq -0x8(%rbp), %rdi
movl $0x2f, %esi
callq 0x5130
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0xd511
movq -0x8(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb $0x0, 0x1(%rax)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mmayer[P]pcal/src/readfile.c
// Function: get_token
int get_token (char *token)
{
   KWD_F *p;
   
   for (p = pp_info; p->name; p++) {
      if (ci_strncmp(token, p->name, MIN_PPTOK_LEN) == 0) return p - pp_info;
   }
   
   return PP_OTHER;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x2067d(%rip), %rax     # 0x2e7d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0xe1a8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movl $0x3, %edx
callq 0xb3b0
cmpl $0x0, %eax
jne 0xe198
movq -0x18(%rbp), %rax
leaq 0x2064a(%rip), %rcx     # 0x2e7d0
subq %rcx, %rax
movl $0x18, %ecx
cqto
idivq %rcx
movl %eax, -0x4(%rbp)
jmp 0xe1af
jmp 0xe19a
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
jmp 0xe157
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmayer[P]pcal/src/readfile.c
// Function: do_define_sym_val
int do_define_sym_val (char *sym, char *val)
{
   int i;
   
   i = find_sym_name(sym);
   if (i == PP_SYM_UNDEF) return PP_SYM_UNDEF;
   
   if (pp_val[i]) {
      free(pp_val[i]);
      pp_val[i]=NULL;
   }
   
   if (val) strcpy(pp_val[i] = alloc(strlen(val)+1), val); 
   else pp_val[i]=NULL;
   
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xeba0
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0xe23e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe2c9
movslq -0x1c(%rbp), %rcx
leaq 0x25977(%rip), %rax     # 0x33bc0
cmpq $0x0, (%rax,%rcx,8)
je 0xe277
movslq -0x1c(%rbp), %rcx
leaq 0x25965(%rip), %rax     # 0x33bc0
movq (%rax,%rcx,8), %rdi
callq 0x5040
movslq -0x1c(%rbp), %rcx
leaq 0x25951(%rip), %rax     # 0x33bc0
movq $0x0, (%rax,%rcx,8)
cmpq $0x0, -0x18(%rbp)
je 0xe2af
movq -0x18(%rbp), %rdi
callq 0x50e0
addq $0x1, %rax
movl %eax, %edi
callq 0xb2b0
movq %rax, %rdi
movslq -0x1c(%rbp), %rcx
leaq 0x25920(%rip), %rax     # 0x33bc0
movq %rdi, (%rax,%rcx,8)
movq -0x18(%rbp), %rsi
callq 0x5080
jmp 0xe2c2
movslq -0x1c(%rbp), %rcx
leaq 0x25906(%rip), %rax     # 0x33bc0
movq $0x0, (%rax,%rcx,8)
movl $0x0, -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/readfile.c
// Function: clear_syms
void clear_syms (void)
{
   int i;
   
   for (i = 0; i < MAX_PP_SYMS; i++) {
      if (pp_sym[i]) {
         free(pp_sym[i]);
         pp_sym[i] = NULL;
      }
      if (pp_val[i]) {
         free(pp_val[i]);
         pp_val[i] = NULL;
      }
   }
   return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0x64, -0x4(%rbp)
jge 0xea9b
movslq -0x4(%rbp), %rcx
leaq 0x24e7c(%rip), %rax     # 0x338a0
cmpq $0x0, (%rax,%rcx,8)
je 0xea52
movslq -0x4(%rbp), %rcx
leaq 0x24e6a(%rip), %rax     # 0x338a0
movq (%rax,%rcx,8), %rdi
callq 0x5040
movslq -0x4(%rbp), %rcx
leaq 0x24e56(%rip), %rax     # 0x338a0
movq $0x0, (%rax,%rcx,8)
movslq -0x4(%rbp), %rcx
leaq 0x25163(%rip), %rax     # 0x33bc0
cmpq $0x0, (%rax,%rcx,8)
je 0xea8b
movslq -0x4(%rbp), %rcx
leaq 0x25151(%rip), %rax     # 0x33bc0
movq (%rax,%rcx,8), %rdi
callq 0x5040
movslq -0x4(%rbp), %rcx
leaq 0x2513d(%rip), %rax     # 0x33bc0
movq $0x0, (%rax,%rcx,8)
jmp 0xea8d
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xea0f
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmayer[P]pcal/src/readfile.c
// Function: cleanup
void cleanup (void)
{
   int i, j;
   year_info *py, *pny;
   month_info *pm;
   day_info *pd, *pnd;
   
   for (py = head; py; py = pny) {   /* main data structure */
      pny = py->next;
      for (i = 0; i < 12; i++) {
         if ((pm = py->month[i]) == NULL) continue;
         for (j = 0; j < LAST_NOTE_DAY; j++) {
            for (pd = pm->day[j]; pd; pd = pnd) {
               pnd = pd->next;
               free(pd->text);
               free(pd);
            }
         }
         free(pm);
      }
      free(py);
   }
   
   clear_syms();   /* symbol table */

   return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x23861(%rip), %rax     # 0x32320
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xeb92
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x4(%rbp)
cmpl $0xc, -0x4(%rbp)
jge 0xeb7c
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xeb07
jmp 0xeb6e
movl $0x0, -0x8(%rbp)
cmpl $0x2d, -0x8(%rbp)
jge 0xeb65
movq -0x20(%rbp), %rax
movslq -0x8(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xeb58
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5040
movq -0x28(%rbp), %rdi
callq 0x5040
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0xeb25
jmp 0xeb5a
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xeb0e
movq -0x20(%rbp), %rdi
callq 0x5040
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xeae4
movq -0x10(%rbp), %rdi
callq 0x5040
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0xeac6
callq 0xea00
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mmayer[P]pcal/src/readfile.c
// Function: find_sym_name
int find_sym_name (char *sym)
{
   int i;
   
   if (!sym) return PP_SYM_UNDEF;
   
   for (i = 0; i < MAX_PP_SYMS; i++) {
      if (pp_sym[i] && ci_strcmp(pp_sym[i], sym) == 0) return i;
   }
   
   return PP_SYM_UNDEF;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xebbc
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xec14
movl $0x0, -0x14(%rbp)
cmpl $0x64, -0x14(%rbp)
jge 0xec0d
movslq -0x14(%rbp), %rcx
leaq 0x24ccc(%rip), %rax     # 0x338a0
cmpq $0x0, (%rax,%rcx,8)
je 0xec00
movslq -0x14(%rbp), %rcx
leaq 0x24cba(%rip), %rax     # 0x338a0
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0xb320
cmpl $0x0, %eax
jne 0xec00
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xec14
jmp 0xec02
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xebc3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mmayer[P]pcal/src/readfile.c
// Function: do_define
int do_define (char *sym)
{
   int i;
   
   if (!sym) {   /* null argument - clear all definitions */
      clear_syms();
      return 0;
   }
   
   if (DEBUG(DEBUG_PP)) fprintf(stderr, "defining %s\n", sym);
   
   if (do_ifdef(sym)) return 0;   /* already defined? */
      
   for (i = 0; i < MAX_PP_SYMS; i++) {   /* find room for it */
      if (!pp_sym[i]) {
         strcpy(pp_sym[i] = alloc(strlen(sym)+1), sym);
         return 0;
      }
   }
   
   fprintf(stderr, E_SYMFULL, progname, sym);

   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xecb4
callq 0xea00
movl $0x0, -0x4(%rbp)
jmp 0xed89
leaq 0x23aa1(%rip), %rax     # 0x3275c
movl (%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0xece1
movq 0x1f32c(%rip), %rax     # 0x2dff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x162a0(%rip), %rsi     # 0x24f7a
movb $0x0, %al
callq 0x51b0
movq -0x10(%rbp), %rdi
callq 0xec20
cmpl $0x0, %eax
je 0xecfb
movl $0x0, -0x4(%rbp)
jmp 0xed89
movl $0x0, -0x14(%rbp)
cmpl $0x64, -0x14(%rbp)
jge 0xed5f
movslq -0x14(%rbp), %rcx
leaq 0x24b8d(%rip), %rax     # 0x338a0
cmpq $0x0, (%rax,%rcx,8)
jne 0xed52
movq -0x10(%rbp), %rdi
callq 0x50e0
addq $0x1, %rax
movl %eax, %edi
callq 0xb2b0
movq %rax, %rdi
movslq -0x14(%rbp), %rcx
leaq 0x24b64(%rip), %rax     # 0x338a0
movq %rdi, (%rax,%rcx,8)
movq -0x10(%rbp), %rsi
callq 0x5080
movl $0x0, -0x4(%rbp)
jmp 0xed89
jmp 0xed54
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xed02
movq 0x1f292(%rip), %rax     # 0x2dff8
movq (%rax), %rdi
movq -0x10(%rbp), %rcx
leaq 0x161db(%rip), %rsi     # 0x24f4f
leaq 0x23b35(%rip), %rdx     # 0x328b0
movb $0x0, %al
callq 0x51b0
movl $0x0, -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/readfile.c
// Function: do_undef
int do_undef (char *sym)
{
   int i;
   
   if (!sym) return 0;

   if (DEBUG(DEBUG_PP)) fprintf(stderr, "undefining %s\n", sym);

   if ((i = find_sym_name(sym)) != PP_SYM_UNDEF) {
      if (pp_val[i]) {
         free(pp_val[i]);
         pp_val[i] = NULL;
      }
      free(pp_sym[i]);
      pp_sym[i] = NULL;
   }
   
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xedbf
movl $0x0, -0x4(%rbp)
jmp 0xee64
leaq 0x23996(%rip), %rax     # 0x3275c
movl (%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0xedec
movq 0x1f221(%rip), %rax     # 0x2dff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x16193(%rip), %rsi     # 0x24f78
movb $0x0, %al
callq 0x51b0
movq -0x10(%rbp), %rdi
callq 0xeba0
movl %eax, -0x14(%rbp)
cmpl $-0x1, %eax
je 0xee5d
movslq -0x14(%rbp), %rcx
leaq 0x24db8(%rip), %rax     # 0x33bc0
cmpq $0x0, (%rax,%rcx,8)
je 0xee36
movslq -0x14(%rbp), %rcx
leaq 0x24da6(%rip), %rax     # 0x33bc0
movq (%rax,%rcx,8), %rdi
callq 0x5040
movslq -0x14(%rbp), %rcx
leaq 0x24d92(%rip), %rax     # 0x33bc0
movq $0x0, (%rax,%rcx,8)
movslq -0x14(%rbp), %rcx
leaq 0x24a5f(%rip), %rax     # 0x338a0
movq (%rax,%rcx,8), %rdi
callq 0x5040
movslq -0x14(%rbp), %rcx
leaq 0x24a4b(%rip), %rax     # 0x338a0
movq $0x0, (%rax,%rcx,8)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mmayer[P]pcal/src/readfile.c
// Function: is_holiday
int is_holiday (int mm, int dd, int yy)
{
   year_info *py;
   month_info *pm;
   
   pm = (py = find_year(yy, FALSE)) ? py->month[mm-1] : NULL;
   return pm ? (pm->holidays & (1L << (dd-1))) != 0 : FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl -0xc(%rbp), %edi
xorl %esi, %esi
callq 0xefe0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xef7d
movq -0x18(%rbp), %rax
movl -0x4(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq 0x8(%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
jmp 0xef85
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0xef85
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xefc2
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl -0x8(%rbp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x2c(%rbp)
jmp 0xefc9
xorl %eax, %eax
movl %eax, -0x2c(%rbp)
jmp 0xefc9
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmayer[P]pcal/src/readfile.c
// Function: find_year
year_info *find_year (int year, int insert)
{
   year_info *pyear, *plast, *p;
   
   for (plast = NULL, pyear = head;   /* search linked list */
        pyear && pyear->year < year;
        plast = pyear, pyear = pyear->next)
      ;
   
   if (pyear && pyear->year == year) return pyear;   /* found - return it */

   if (insert) {   /* not found - insert it if requested */
      int i;
      p = (year_info *) alloc((int) sizeof(year_info));   /* create new record */
      p->year = year;
      for (i = 0; i < (int)(ARRAYSIZE(p->month)); i++) p->month[i] = NULL;
      p->next = pyear;   /* link it in */
      return *(plast ? &plast->next : &head) = p;
   }
   else return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
leaq 0x23323(%rip), %rax     # 0x32320
movq (%rax), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x2d(%rbp)
je 0xf01f
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
setl %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0xf028
jmp 0xf040
jmp 0xf02a
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xf004
cmpq $0x0, -0x18(%rbp)
je 0xf05f
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0xf05f
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xf0f8
cmpl $0x0, -0x10(%rbp)
je 0xf0f0
movl $0x70, %edi
callq 0xb2b0
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x2c(%rbp)
cmpl $0xc, -0x2c(%rbp)
jge 0xf0a9
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq $0x0, 0x8(%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xf087
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xf0d2
movq -0x20(%rbp), %rax
addq $0x68, %rax
movq %rax, -0x40(%rbp)
jmp 0xf0df
leaq 0x23247(%rip), %rax     # 0x32320
movq %rax, -0x40(%rbp)
jmp 0xf0df
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rax, (%rcx)
movq %rax, -0x8(%rbp)
jmp 0xf0f8
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmayer[P]pcal/src/readfile.c
// Function: odox_easter_from_april1
int odox_easter_from_april1 (int year)
{
   int a, b, leap;
   
   a = ( ( ((year-1) % METONIC) + 1 ) * METONIC + 15 ) % 30;
   leap = IS_LEAP(year) ? 1 : 0;
   b = (calc_weekday(1,1,year) + 90 + leap + a + 2) % 7;
   b = 7 - b + 3 + a;

   /* In 1923, 13 days  were added to the new greek calendar */
   if (year <= 1923) b -= 13;

   return (b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
subl $0x1, %eax
movl $0x13, %ecx
cltd
idivl %ecx
addl $0x1, %edx
imull $0x13, %edx, %eax
addl $0xf, %eax
movl $0x1e, %ecx
cltd
idivl %ecx
movl %edx, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
xorl %eax, %eax
cmpl $0x0, %edx
movb %al, -0x11(%rbp)
jne 0xf531
movl -0x4(%rbp), %eax
movl $0x64, %ecx
cltd
idivl %ecx
movb $0x1, %al
cmpl $0x0, %edx
movb %al, -0x12(%rbp)
jne 0xf52b
movl -0x4(%rbp), %eax
movl $0x190, %ecx            # imm = 0x190
cltd
idivl %ecx
cmpl $0x0, %edx
sete %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x10(%rbp)
movl -0x4(%rbp), %edx
movl $0x1, %esi
movl %esi, %edi
callq 0xc110
addl $0x5a, %eax
addl -0x10(%rbp), %eax
addl -0x8(%rbp), %eax
addl $0x2, %eax
movl $0x7, %ecx
cltd
idivl %ecx
movl %edx, -0xc(%rbp)
movl $0x7, %eax
subl -0xc(%rbp), %eax
addl $0x3, %eax
addl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
cmpl $0x783, -0x4(%rbp)      # imm = 0x783
jg 0xf58d
movl -0xc(%rbp), %eax
subl $0xd, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmayer[P]pcal/src/readfile.c
// Function: find_odox_easter
int find_odox_easter (date_str *pdate)   /* pointer into date array */
{
   date_str *sv_pdate = pdate;
   int offs;
   
   /* easter is days from 1st April for easter sun */
   offs = odox_easter_from_april1(curr_year);
   odox_add(offs);
   
   /* return number of dates added (always 1 in this routine) */
   return pdate - sv_pdate;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x240a5(%rip), %rax     # 0x33660
movl (%rax), %edi
callq 0xf4c0
movl %eax, -0x14(%rbp)
movl $0x4, -0x18(%rbp)
cmpl $0x1, -0x14(%rbp)
jge 0xf5e4
movl $0x3, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $0x1f, %eax
movl %eax, -0x14(%rbp)
jmp 0xf5fc
cmpl $0x1e, -0x14(%rbp)
jle 0xf5fa
movl $0x5, -0x18(%rbp)
movl -0x14(%rbp), %eax
subl $0x1e, %eax
movl %eax, -0x14(%rbp)
jmp 0xf5fc
jmp 0xf5fe
leaq 0x23157(%rip), %rax     # 0x3275c
movl (%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0xf637
movq 0x1e9e2(%rip), %rax     # 0x2dff8
movq (%rax), %rdi
leaq 0x24040(%rip), %rax     # 0x33660
movl (%rax), %edx
movl -0x18(%rbp), %ecx
movl -0x14(%rbp), %r8d
leaq 0x15957(%rip), %rsi     # 0x24f87
movb $0x0, %al
callq 0x51b0
movl -0x18(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
leaq 0x2400f(%rip), %rax     # 0x33660
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0xc, %rdx
movq %rdx, -0x8(%rbp)
movl %ecx, 0x8(%rax)
jmp 0xf667
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movl $0xc, %ecx
cqto
idivq %rcx
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmayer[P]pcal/src/readfile.c
// Function: find_odox_stgeorge
int find_odox_stgeorge (date_str *pdate)   /* pointer into date array */
{
   date_str *sv_pdate = pdate;
   int offs;
   
   /* offs is days from 1st April for easter sun */
   offs = odox_easter_from_april1(curr_year);
   if (offs >= 23) {   /* it's before easter; will move to easter Mon */
      offs++;
      odox_add(offs);
   } 
   else ADD_DATE(APR, 23, curr_year);

   /* return number of dates added */
   return pdate - sv_pdate;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x23fb5(%rip), %rax     # 0x33660
movl (%rax), %edi
callq 0xf4c0
movl %eax, -0x14(%rbp)
cmpl $0x17, -0x14(%rbp)
jl 0xf76c
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl $0x4, -0x18(%rbp)
cmpl $0x1, -0x14(%rbp)
jge 0xf6e7
movl $0x3, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $0x1f, %eax
movl %eax, -0x14(%rbp)
jmp 0xf6ff
cmpl $0x1e, -0x14(%rbp)
jle 0xf6fd
movl $0x5, -0x18(%rbp)
movl -0x14(%rbp), %eax
subl $0x1e, %eax
movl %eax, -0x14(%rbp)
jmp 0xf6ff
jmp 0xf701
leaq 0x23054(%rip), %rax     # 0x3275c
movl (%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0xf73a
movq 0x1e8df(%rip), %rax     # 0x2dff8
movq (%rax), %rdi
leaq 0x23f3d(%rip), %rax     # 0x33660
movl (%rax), %edx
movl -0x18(%rbp), %ecx
movl -0x14(%rbp), %r8d
leaq 0x15854(%rip), %rsi     # 0x24f87
movb $0x0, %al
callq 0x51b0
movl -0x18(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
leaq 0x23f0c(%rip), %rax     # 0x33660
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0xc, %rdx
movq %rdx, -0x8(%rbp)
movl %ecx, 0x8(%rax)
jmp 0xf76a
jmp 0xf7dd
jmp 0xf76e
leaq 0x22fe7(%rip), %rax     # 0x3275c
movl (%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0xf7ab
movq 0x1e872(%rip), %rax     # 0x2dff8
movq (%rax), %rdi
leaq 0x23ed0(%rip), %rax     # 0x33660
movl (%rax), %edx
leaq 0x157ee(%rip), %rsi     # 0x24f87
movl $0x4, %ecx
movl $0x17, %r8d
movb $0x0, %al
callq 0x51b0
movq -0x8(%rbp), %rax
movl $0x4, (%rax)
movq -0x8(%rbp), %rax
movl $0x17, 0x4(%rax)
leaq 0x23e99(%rip), %rax     # 0x33660
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0xc, %rdx
movq %rdx, -0x8(%rbp)
movl %ecx, 0x8(%rax)
jmp 0xf7dd
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movl $0xc, %ecx
cqto
idivq %rcx
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmayer[P]pcal/src/readfile.c
// Function: find_odox_marcus
int find_odox_marcus (date_str *pdate)   /* pointer into date array */
{
   date_str *sv_pdate = pdate;
   int offs;
   
   /* offs is days from 1st April for easter sun */
   offs = odox_easter_from_april1(curr_year);
   if (offs >= 25) {   /* it's before easter; will move to easter Tue */
      offs += 2;
      odox_add(offs);
   } 
   else ADD_DATE(APR, 25, curr_year);

   /* return number of dates added */
   return pdate - sv_pdate;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x23e45(%rip), %rax     # 0x33660
movl (%rax), %edi
callq 0xf4c0
movl %eax, -0x14(%rbp)
cmpl $0x19, -0x14(%rbp)
jl 0xf8dc
movl -0x14(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x14(%rbp)
movl $0x4, -0x18(%rbp)
cmpl $0x1, -0x14(%rbp)
jge 0xf857
movl $0x3, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $0x1f, %eax
movl %eax, -0x14(%rbp)
jmp 0xf86f
cmpl $0x1e, -0x14(%rbp)
jle 0xf86d
movl $0x5, -0x18(%rbp)
movl -0x14(%rbp), %eax
subl $0x1e, %eax
movl %eax, -0x14(%rbp)
jmp 0xf86f
jmp 0xf871
leaq 0x22ee4(%rip), %rax     # 0x3275c
movl (%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0xf8aa
movq 0x1e76f(%rip), %rax     # 0x2dff8
movq (%rax), %rdi
leaq 0x23dcd(%rip), %rax     # 0x33660
movl (%rax), %edx
movl -0x18(%rbp), %ecx
movl -0x14(%rbp), %r8d
leaq 0x156e4(%rip), %rsi     # 0x24f87
movb $0x0, %al
callq 0x51b0
movl -0x18(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
leaq 0x23d9c(%rip), %rax     # 0x33660
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0xc, %rdx
movq %rdx, -0x8(%rbp)
movl %ecx, 0x8(%rax)
jmp 0xf8da
jmp 0xf94d
jmp 0xf8de
leaq 0x22e77(%rip), %rax     # 0x3275c
movl (%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0xf91b
movq 0x1e702(%rip), %rax     # 0x2dff8
movq (%rax), %rdi
leaq 0x23d60(%rip), %rax     # 0x33660
movl (%rax), %edx
leaq 0x1567e(%rip), %rsi     # 0x24f87
movl $0x4, %ecx
movl $0x19, %r8d
movb $0x0, %al
callq 0x51b0
movq -0x8(%rbp), %rax
movl $0x4, (%rax)
movq -0x8(%rbp), %rax
movl $0x19, 0x4(%rax)
leaq 0x23d29(%rip), %rax     # 0x33660
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0xc, %rdx
movq %rdx, -0x8(%rbp)
movl %ecx, 0x8(%rax)
jmp 0xf94d
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movl $0xc, %ecx
cqto
idivq %rcx
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmayer[P]pcal/src/readfile.c
// Function: get_month
int get_month (char *cp, int numeric_ok, int year_ok)
{
   int mm;
   
   if (!cp) return NOT_MONTH;

   if (get_keywd(cp) == DT_ALL) return ALL_MONTHS;

   if (year_ok && get_keywd(cp) == DT_YEAR) return ENTIRE_YEAR;
   
   if (numeric_ok && isdigit((int)*cp)) mm = atoi(cp);
   else {
      /* accept month names in the active 'input' language only */
      for (mm = JAN; mm <= DEC; mm++) {
         /* Need to shorten length of string compare by 1 character when the
            last character is '*' so that event like '2nd Sunday in May*'
            don't report 'no match for wildcard'.
         */
         if ((ci_strncmp(cp, months_ml[input_language][mm-1], 
                         strlen(cp) - ((*(cp + strlen(cp) - 1) == '*') ? 1 : 0)) == 0))
            break;
      }
   }
   
   return mm >= JAN && mm <= DEC ? mm : NOT_MONTH;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xf995
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xfad7
movq -0x10(%rbp), %rdi
callq 0xfae0
cmpl $0x0, %eax
jne 0xf9af
movl $0x0, -0x4(%rbp)
jmp 0xfad7
cmpl $0x0, -0x18(%rbp)
je 0xf9cf
movq -0x10(%rbp), %rdi
callq 0xfae0
cmpl $0x4, %eax
jne 0xf9cf
movl $0xd, -0x4(%rbp)
jmp 0xfad7
cmpl $0x0, -0x14(%rbp)
je 0xfa06
callq 0x52e0
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0xfa06
movq -0x10(%rbp), %rdi
callq 0x5280
movl %eax, -0x1c(%rbp)
jmp 0xfab3
movl $0x1, -0x1c(%rbp)
cmpl $0xc, -0x1c(%rbp)
jg 0xfab1
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq 0x23e5a(%rip), %rax     # 0x33880
movslq (%rax), %rcx
leaq 0x201f0(%rip), %rax     # 0x2fc20
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x50e0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x50e0
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
movq -0x28(%rbp), %rax
movsbl -0x1(%rcx,%rdx), %r8d
xorl %ecx, %ecx
movl $0x1, %edx
cmpl $0x2a, %r8d
cmovel %edx, %ecx
movslq %ecx, %rcx
subq %rcx, %rax
movl %eax, %edx
callq 0xb3b0
cmpl $0x0, %eax
jne 0xfaa1
jmp 0xfab1
jmp 0xfaa3
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xfa0d
jmp 0xfab3
cmpl $0x1, -0x1c(%rbp)
jl 0xfac7
cmpl $0xc, -0x1c(%rbp)
jg 0xfac7
movl -0x1c(%rbp), %eax
movl %eax, -0x44(%rbp)
jmp 0xfad1
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x44(%rbp)
jmp 0xfad1
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mmayer[P]pcal/src/readfile.c
// Function: get_keywd
int get_keywd (char *cp)
{
   KWD *k;
   
   if (!cp) return DT_OTHER;
   
   for (k = keywds; k->name && ci_strncmp(cp, k->name, strlen(k->name)); k++)
      ;
   
   return k->code;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xfafc
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xfb70
leaq 0x1f00d(%rip), %rax     # 0x2eb10
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x19(%rbp)
je 0xfb4d
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x50e0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl %eax, %edx
callq 0xb3b0
cmpl $0x0, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xfb56
jmp 0xfb66
jmp 0xfb58
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
jmp 0xfb07
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mmayer[P]pcal/src/readfile.c
// Function: get_phase
int get_phase (char *cp)
{
   KWD *p;
   
   if (!cp) return MOON_OTHER;
   
   for (p = phases; p->name && ci_strcmp(cp, p->name); p++)
      ;
   
   return p->code;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xfd4c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xfda2
leaq 0x1ee4d(%rip), %rax     # 0x2eba0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x19(%rbp)
je 0xfd7f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0xb320
cmpl $0x0, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xfd88
jmp 0xfd98
jmp 0xfd8a
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
jmp 0xfd57
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmayer[P]pcal/src/readfile.c
// Function: get_ordinal
int get_ordinal (char *cp, int *pval)
{
   KWD_O *o;
   int val;
   char **psuf;
   
   if (!cp) return ORD_OTHER;

   if (isdigit((int)*cp) || *cp == '-') {   /* numeric? */
      if ((val = atoi(cp)) == 0) return ORD_OTHER;
      
      if (*cp == '-') cp++;   /* skip over number */
         
      cp += strspn(cp, DIGITS);
      
      for (psuf = ord_suffix; *psuf; psuf++) {   /* find suffix */
         if (ci_strcmp(cp, *psuf) == 0) {
            *pval = val;
            return val < 0 ? ORD_NEGNUM : ORD_POSNUM;
         }
      }
      return ORD_OTHER;
   }
   
   /* look for word in ordinals list */

   for (o = ordinals; o->name && ci_strncmp(cp, o->name, MIN_ORD_LEN); o++)
      ;
   
   *pval = o->value;
   return o->code;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xfdd3
movl $0x0, -0x4(%rbp)
jmp 0xff1f
callq 0x52e0
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0xfe03
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0xfeb7
movq -0x10(%rbp), %rdi
callq 0x5280
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
jne 0xfe20
movl $0x0, -0x4(%rbp)
jmp 0xff1f
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0xfe38
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xc071(%rip), %rsi      # 0x1beb4
callq 0x5160
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x1ebb9(%rip), %rax     # 0x2ea10
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
je 0xfeae
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rsi
callq 0xb320
cmpl $0x0, %eax
jne 0xfe9e
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x24(%rbp), %edx
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl $0x0, %edx
cmovll %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0xff1f
jmp 0xfea0
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
jmp 0xfe5b
movl $0x0, -0x4(%rbp)
jmp 0xff1f
leaq 0x1ea02(%rip), %rax     # 0x2e8c0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x31(%rbp)
je 0xfeef
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movl $0x4, %edx
callq 0xb3b0
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0xfef8
jmp 0xff08
jmp 0xfefa
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
jmp 0xfec2
movq -0x20(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmayer[P]pcal/src/readfile.c
// Function: get_prep
int get_prep (char *cp)
{
   KWD *p;
   
   if (!cp) return PR_OTHER;

   for (p = preps; p->name && ci_strncmp(cp, p->name, MIN_PREP_LEN); p++)
      ;
   
   return p->code;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xff4c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xffa7
leaq 0x1eaed(%rip), %rax     # 0x2ea40
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x19(%rbp)
je 0xff84
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movl $0x9, %edx
callq 0xb3b0
cmpl $0x0, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xff8d
jmp 0xff9d
jmp 0xff8f
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
jmp 0xff57
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mmayer[P]pcal/src/readfile.c
// Function: get_predef_event
int get_predef_event (char *cp)
{
   KWD_H *p;
   
   for (p = predef_events; p->name; p++) {
      if (ci_strncmp(cp, p->name, strlen(p->name)) == 0) return p - predef_events;
   }
   
   return NOT_PREDEF_EVENT;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x1e98d(%rip), %rax     # 0x2e950
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x10031
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x50e0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl %eax, %edx
callq 0xb3b0
cmpl $0x0, %eax
jne 0x10021
movq -0x18(%rbp), %rax
leaq 0x1e941(%rip), %rcx     # 0x2e950
subq %rcx, %rax
movl $0x18, %ecx
cqto
idivq %rcx
movl %eax, -0x4(%rbp)
jmp 0x10038
jmp 0x10023
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
jmp 0xffc7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
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/readfile.c
// Function: enter_note
int enter_note (int mm, char **pword, int n)
{
   int valid;
   
   /* expand "note all" into all twelve months */
   if (mm == ALL_MONTHS || mm == ENTIRE_YEAR) {
      valid = FALSE;   /* is at least one note box valid? */
      for (mm = JAN; mm <= DEC; mm++) {
         valid |= enter_day_info(mm,
                                 note_day(mm, n, curr_year),
                                 curr_year, NOTE_TEXT,
                                 pword+1) == PARSE_OK;
      }
      return valid ? PARSE_OK : PARSE_NOMATCH;
   }
   
   return enter_day_info(mm, note_day(mm, n, curr_year), curr_year, NOTE_TEXT, pword+1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x10ade
cmpl $0xd, -0x8(%rbp)
jne 0x10b5d
movl $0x0, -0x18(%rbp)
movl $0x1, -0x8(%rbp)
cmpl $0xc, -0x8(%rbp)
jg 0x10b48
movl -0x8(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x8(%rbp), %edi
movl -0x14(%rbp), %esi
leaq 0x22b5b(%rip), %rax     # 0x33660
movl (%rax), %edx
callq 0xc3c0
movl -0x1c(%rbp), %edi
movl %eax, %esi
leaq 0x22b48(%rip), %rax     # 0x33660
movl (%rax), %edx
movq -0x10(%rbp), %r8
addq $0x8, %r8
movl $0x2, %ecx
callq 0x10240
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
orl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x10aec
movl -0x18(%rbp), %edx
movl $0x3, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x10b9a
movl -0x8(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x8(%rbp), %edi
movl -0x14(%rbp), %esi
leaq 0x22af0(%rip), %rax     # 0x33660
movl (%rax), %edx
callq 0xc3c0
movl -0x20(%rbp), %edi
movl %eax, %esi
leaq 0x22add(%rip), %rax     # 0x33660
movl (%rax), %edx
movq -0x10(%rbp), %r8
addq $0x8, %r8
movl $0x2, %ecx
callq 0x10240
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/writefil.c
// Function: ps_prtday_bw
void ps_prtday_bw (void)
{
   printf("%% print 'day' in 'color' (black, gray, outline, or outline-gray; cf. pcaldefs.h)\n");
   printf("%% using single value in 'dategray' as gray shade\n");
   printf("%%\n");
   printf("/prtday {					%% black and white version\n");
   printf("	gsave\n");
   printf("	day 3 string cvs			%% convert day to string\n");
   printf("	[\n");
   printf("		{ show }				%% black (0)\n");
   printf("		{ dategray setgray show }		%% gray (1)\n");
   printf("		{ true charpath stroke }		%% outline (2)\n");
   printf("		{ true charpath gsave			%% outline-gray (3)\n");
   printf("		  dategray setgray fill\n");
   printf("		  grestore stroke }\n");
   printf("	] color get exec			%% execute operators for color\n");
   printf("	grestore\n");
   printf("} bind def\n\n");
   return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x134a5(%rip), %rdi     # 0x252a0
movb $0x0, %al
callq 0x5110
leaq 0x134ea(%rip), %rdi     # 0x252f3
movb $0x0, %al
callq 0x5110
leaq 0x177a6(%rip), %rdi     # 0x295bd
movb $0x0, %al
callq 0x5110
leaq 0x13501(%rip), %rdi     # 0x25326
movb $0x0, %al
callq 0x5110
leaq 0x16311(%rip), %rdi     # 0x28144
movb $0x0, %al
callq 0x5110
leaq 0x1350f(%rip), %rdi     # 0x25350
movb $0x0, %al
callq 0x5110
leaq 0x1739d(%rip), %rdi     # 0x291ec
movb $0x0, %al
callq 0x5110
leaq 0x13521(%rip), %rdi     # 0x2537e
movb $0x0, %al
callq 0x5110
leaq 0x1352f(%rip), %rdi     # 0x2539a
movb $0x0, %al
callq 0x5110
leaq 0x1354b(%rip), %rdi     # 0x253c4
movb $0x0, %al
callq 0x5110
leaq 0x13569(%rip), %rdi     # 0x253f0
movb $0x0, %al
callq 0x5110
leaq 0x1358a(%rip), %rdi     # 0x2541f
movb $0x0, %al
callq 0x5110
leaq 0x13597(%rip), %rdi     # 0x2543a
movb $0x0, %al
callq 0x5110
leaq 0x135a0(%rip), %rdi     # 0x25451
movb $0x0, %al
callq 0x5110
leaq 0x162fa(%rip), %rdi     # 0x281b9
movb $0x0, %al
callq 0x5110
leaq 0x1606d(%rip), %rdi     # 0x27f3a
movb $0x0, %al
callq 0x5110
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmayer[P]pcal/src/writefil.c
// Function: set_rgb
char *set_rgb (char *s)
{
   static char buf[STRSIZ];
   char *p1, *p2;
   double val[3];
   int n;
   
   val[0] = val[1] = val[2] = 0;   /* defaults */
   
   /* extract 1 - 3 floating-point values from string */
   for (n = 1, p1 = s; n <= 3; n++, p1 = p2 + 1) {
      val[n-1] = atof(p1);
      if ((p2 = strchr(p1, RGB_CHAR)) == NULL) break;
   }
   
   /* single value is gray scale; assume anything else is [r g b] */
   if (n > 1) sprintf(buf, "[%.3f %.3f %.3f]", val[0], val[1], val[2]);
   else sprintf(buf, "%.3f", val[0]);

   return buf; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x1, -0x34(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x3, -0x34(%rbp)
jg 0x165b3
movq -0x10(%rbp), %rdi
callq 0x50a0
movl -0x34(%rbp), %eax
subl $0x1, %eax
cltq
movsd %xmm0, -0x30(%rbp,%rax,8)
movq -0x10(%rbp), %rdi
movl $0x3a, %esi
callq 0x5100
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x1659a
jmp 0x165b3
jmp 0x1659c
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x16563
cmpl $0x1, -0x34(%rbp)
jle 0x165df
movsd -0x30(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
movsd -0x20(%rbp), %xmm2
leaq 0x1eab1(%rip), %rdi     # 0x35080
leaq 0x141ba(%rip), %rsi     # 0x2a790
movb $0x3, %al
callq 0x52a0
jmp 0x165f9
movsd -0x30(%rbp), %xmm0
leaq 0x1ea95(%rip), %rdi     # 0x35080
leaq 0x5815(%rip), %rsi      # 0x1be07
movb $0x1, %al
callq 0x52a0
leaq 0x1ea80(%rip), %rax     # 0x35080
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmayer[P]pcal/src/writefil.c
// Function: write_calfile
void write_calfile (void)
{
   KWD *k;
   int i;
   
   /* look up the Pcal keywords (assumed present) for the -c output file */
   for (k = keywds; k->name; k++) {
      if (k->code == DT_NOTE) kw_note = k->name;
      if (k->code == DT_OPT)  kw_opt  = k->name;
      if (k->code == DT_YEAR) kw_year = k->name;
   }
   
   /* print the date style for subsequent use by Pcal */
   printf("%s -%c\n", kw_opt, date_style == USA_DATES ? F_USA_DATES :
          F_EUR_DATES);
   
   for (i = 0, this_month = init_month, this_year = init_year;
        i < nmonths;
        i++, BUMP_MONTH_AND_YEAR(this_month, this_year)) {
      print_dates(this_month, this_year);
   }

   return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x17f01(%rip), %rax     # 0x2eb10
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x16c75
movq -0x8(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jne 0x16c35
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, 0x1e41b(%rip)     # 0x35050
movq -0x8(%rbp), %rax
cmpl $0x2, 0x8(%rax)
jne 0x16c4d
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, 0x1e40b(%rip)     # 0x35058
movq -0x8(%rbp), %rax
cmpl $0x4, 0x8(%rax)
jne 0x16c65
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, 0x1e3fb(%rip)     # 0x35060
jmp 0x16c67
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
jmp 0x16c13
movq 0x1e3dc(%rip), %rsi     # 0x35058
leaq 0x1b9e9(%rip), %rax     # 0x3266c
movl (%rax), %ecx
movl $0x45, %edx
movl $0x41, %eax
cmpl $0x0, %ecx
cmovel %eax, %edx
leaq 0x137d3(%rip), %rdi     # 0x2a46f
movb $0x0, %al
callq 0x5110
movl $0x0, -0xc(%rbp)
leaq 0x1c863(%rip), %rax     # 0x33514
movl (%rax), %eax
movl %eax, 0x1e38b(%rip)     # 0x35044
leaq 0x1c858(%rip), %rax     # 0x33518
movl (%rax), %eax
movl %eax, 0x1e380(%rip)     # 0x35048
movl -0xc(%rbp), %eax
leaq 0x1c84a(%rip), %rcx     # 0x3351c
cmpl (%rcx), %eax
jge 0x16d25
movl 0x1e368(%rip), %edi     # 0x35044
movl 0x1e366(%rip), %esi     # 0x35048
callq 0x16d30
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0xc, 0x1e34d(%rip)     # 0x35044
jne 0x16d14
movl 0x1e349(%rip), %eax     # 0x35048
addl $0x1, %eax
movl %eax, 0x1e340(%rip)     # 0x35048
movl $0x1, 0x1e332(%rip)     # 0x35044
jmp 0x16d23
movl 0x1e32a(%rip), %eax     # 0x35044
addl $0x1, %eax
movl %eax, 0x1e321(%rip)     # 0x35044
jmp 0x16cc8
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmayer[P]pcal/src/writefil.c
// Function: print_html
void print_html (char *p)
{
   char c, buf[STRSIZ];
   
   while ((c = *p) != '\0') {
      if (c == '%' && p[1] != '\0') {
         p = expand_fmt(buf, p + 1);
         PUTSTR_CLEAN(isalnum, buf, stdout);
      }
      else if (c < ' ' || c > '\176') printf("&#%03d;", *p++ & CHAR_MSK);
      else printf("%c", *p++);
   }
   return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb (%rax), %al
movb %al, -0x9(%rbp)
movsbl %al, %eax
cmpl $0x0, %eax
je 0x1760d
movsbl -0x9(%rbp), %eax
cmpl $0x25, %eax
jne 0x175ac
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
je 0x175ac
leaq -0xe0(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x1, %rsi
callq 0x188f0
movq %rax, -0x8(%rbp)
leaq -0xe0(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq -0xe8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x175a8
movq 0x16a65(%rip), %rax     # 0x2dfd8
movq (%rax), %rdi
movq -0xe8(%rbp), %rax
movsbl (%rax), %edx
andl $0xff, %edx
leaq 0x13089(%rip), %rsi     # 0x2a616
movb $0x0, %al
callq 0x51b0
movq -0xe8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xe8(%rbp)
jmp 0x17560
jmp 0x175aa
jmp 0x17608
movsbl -0x9(%rbp), %eax
cmpl $0x20, %eax
jl 0x175be
movsbl -0x9(%rbp), %eax
cmpl $0x7e, %eax
jle 0x175e6
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movsbl (%rax), %esi
andl $0xff, %esi
leaq 0x134d4(%rip), %rdi     # 0x2aab1
movb $0x0, %al
callq 0x5110
jmp 0x17606
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movsbl (%rax), %esi
leaq 0x13017(%rip), %rdi     # 0x2a616
movb $0x0, %al
callq 0x5110
jmp 0x17608
jmp 0x1750f
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)