LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/bin/unterm.c
// Function: dump_eol
static void dump_eol(const VTermScreenCell *prevcell)
{
  switch(format) {
    case FORMAT_PLAIN:
      break;
    case FORMAT_SGR:
      if(prevcell->attrs.bold || prevcell->attrs.underline || prevcell->attrs.italic ||
         prevcell->attrs.blink || prevcell->attrs.reverse || prevcell->attrs.strike ||
         prevcell->attrs.conceal || prevcell->attrs.font)
        printf("\x1b[m");
      break;
  }

  printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl 0x38aa(%rip), %eax      # 0x515c
movl %eax, -0xc(%rbp)
testl %eax, %eax
je 0x18c8
jmp 0x18bb
movl -0xc(%rbp), %eax
subl $0x1, %eax
je 0x18cd
jmp 0x1969
jmp 0x1969
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x1959
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
shrl %eax
andl $0x3, %eax
cmpl $0x0, %eax
jne 0x1959
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
shrl $0x3, %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x1959
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
shrl $0x4, %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x1959
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
shrl $0x5, %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x1959
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
shrl $0x7, %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x1959
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
shrl $0x6, %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x1959
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
shrl $0x8, %eax
andl $0xf, %eax
cmpl $0x0, %eax
je 0x1967
leaq 0x170a(%rip), %rdi      # 0x306a
movb $0x0, %al
callq 0x1080
jmp 0x1969
leaq 0x16d5(%rip), %rdi      # 0x3045
movb $0x0, %al
callq 0x1080
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/bin/unterm.c
// Function: screen_sb_pushline
static int screen_sb_pushline(int cols, const VTermScreenCell *cells, void *user)
{
  VTermScreenCell prevcell = { 0 };
  vterm_state_get_default_colors(vterm_obtain_state(vt), &prevcell.fg, &prevcell.bg);

  for(int col = 0; col < cols; col++) {
    dump_cell(cells + col, &prevcell);
    prevcell = cells[col];
  }

  dump_eol(&prevcell);

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x1090
movq 0x30a6(%rip), %rdi      # 0x5140
callq 0x1100
movq %rax, %rdi
leaq -0x40(%rbp), %rsi
addq $0x20, %rsi
leaq -0x40(%rbp), %rdx
addq $0x24, %rdx
callq 0x1120
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x2106
movq -0x10(%rbp), %rdi
movslq -0x44(%rbp), %rax
imulq $0x28, %rax, %rax
addq %rax, %rdi
leaq -0x40(%rbp), %rsi
callq 0x1360
movq -0x10(%rbp), %rsi
movslq -0x44(%rbp), %rax
imulq $0x28, %rax, %rax
addq %rax, %rsi
leaq -0x40(%rbp), %rdi
movl $0x28, %edx
callq 0x10f0
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x20be
leaq -0x40(%rbp), %rdi
callq 0x18a0
movl $0x1, %eax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test_mod.c
// Function: code
static char *code(int id) {
    static char code[20];
    if (id > 0) {
        code[0] = id;
        code[1] = 0;
    } else {
        snprintf(code, sizeof(code), "(%d)", -id);
    }

    return code;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jle 0x6343
movl -0x4(%rbp), %eax
movb %al, 0x102996(%rip)     # 0x108cd0
movb $0x0, 0x102990(%rip)    # 0x108cd1
jmp 0x6362
xorl %ecx, %ecx
subl -0x4(%rbp), %ecx
leaq 0x102981(%rip), %rdi    # 0x108cd0
movl $0x14, %esi
leaq 0xe9f08(%rip), %rdx     # 0xf0263
movb $0x0, %al
callq 0x4800
leaq 0x102967(%rip), %rax    # 0x108cd0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/dwelch67[P]lc3/lc3asm.c
// Function: rest_of_line
int rest_of_line ( unsigned int ra )
{
    for(;newline[ra];ra++) if(newline[ra]!=0x20) break;
    if(newline[ra])
    {
        printf("<%u> Error: garbage at end of line\n",line);
        return(1);
    }
    return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x60d9(%rip), %rax      # 0x72c0
cmpb $0x0, (%rax,%rcx)
je 0x1211
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x60c7(%rip), %rax      # 0x72c0
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x1204
jmp 0x1211
jmp 0x1206
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x11db
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x60a3(%rip), %rax      # 0x72c0
cmpb $0x0, (%rax,%rcx)
je 0x1240
movl 0x6497(%rip), %esi      # 0x76c0
leaq 0x3dd4(%rip), %rdi      # 0x5004
movb $0x0, %al
callq 0x1050
movl $0x1, -0x4(%rbp)
jmp 0x1247
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/dwelch67[P]lc3/lc3asm.c
// Function: get_reg_number
int get_reg_number ( char *s, unsigned int *rx )
{
    unsigned int ra;

    for(ra=0;ra<NREGNAMES;ra++)
    {
        if(strcmp(s,reg_names[ra].name)==0)
        {
            *rx=reg_names[ra].num;
            return(0);
        }
    }
    return(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x8, -0x1c(%rbp)
jae 0x12bf
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
leaq 0x5e05(%rip), %rsi      # 0x7080
imulq $0x5, %rax, %rax
addq %rax, %rsi
callq 0x1080
cmpl $0x0, %eax
jne 0x12b2
movl -0x1c(%rbp), %eax
movl %eax, %ecx
leaq 0x5de8(%rip), %rax      # 0x7080
imulq $0x5, %rcx, %rcx
addq %rcx, %rax
movzbl 0x4(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x12c6
jmp 0x12b4
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1267
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/dwelch67[P]lc3/lc3asm.c
// Function: check_simmed5
unsigned int check_simmed5 ( unsigned int rx )
{
    rx&=0xFFFF;
    rx>>=4;
    if(rx==0) return(0);
    if(rx==0x0FFF) return(0);
    printf("<%u> Error: invalid signed_immed5\n",line);
    return(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
shrl $0x4, %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x12fe
movl $0x0, -0x4(%rbp)
jmp 0x132b
cmpl $0xfff, -0x8(%rbp)      # imm = 0xFFF
jne 0x1310
movl $0x0, -0x4(%rbp)
jmp 0x132b
movl 0x63aa(%rip), %esi      # 0x76c0
leaq 0x3d0b(%rip), %rdi      # 0x5028
movb $0x0, %al
callq 0x1050
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dwelch67[P]lc3/lc3asm.c
// Function: check_simmed6
unsigned int check_simmed6 ( unsigned int rx )
{
    rx&=0xFFFF;
    rx>>=5;
    if(rx==0) return(0);
    if(rx==0x07FF) return(0);
    printf("<%u> Error: invalid signed_immed6\n",line);
    return(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
shrl $0x5, %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x136e
movl $0x0, -0x4(%rbp)
jmp 0x139b
cmpl $0x7ff, -0x8(%rbp)      # imm = 0x7FF
jne 0x1380
movl $0x0, -0x4(%rbp)
jmp 0x139b
movl 0x633a(%rip), %esi      # 0x76c0
leaq 0x3cbe(%rip), %rdi      # 0x504b
movb $0x0, %al
callq 0x1050
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dwelch67[P]lc3/lc3asm.c
// Function: check_offset6
unsigned int check_offset6 ( unsigned int rx )
{
    rx&=0xFFFF;
    rx>>=5;
    if(rx==0) return(0);
    if(rx==0x07FF) return(0);
    return(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
shrl $0x5, %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x13da
movl $0x0, -0x4(%rbp)
jmp 0x13f3
cmpl $0x7ff, -0x8(%rbp)      # imm = 0x7FF
jne 0x13ec
movl $0x0, -0x4(%rbp)
jmp 0x13f3
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dwelch67[P]lc3/lc3asm.c
// Function: check_offset9
unsigned int check_offset9 ( unsigned int rx )
{
    rx&=0xFFFF;
    rx>>=8;
    if(rx==0) return(0);
    if(rx==0x00FF) return(0);
    return(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
shrl $0x8, %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x142a
movl $0x0, -0x4(%rbp)
jmp 0x1443
cmpl $0xff, -0x8(%rbp)
jne 0x143c
movl $0x0, -0x4(%rbp)
jmp 0x1443
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dwelch67[P]lc3/lc3asm.c
// Function: check_offset11
unsigned int check_offset11 ( unsigned int rx )
{
    rx&=0xFFFF;
    rx>>=10;
    if(rx==0) return(0);
    if(rx==0x003F) return(0);
    return(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
shrl $0xa, %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x147a
movl $0x0, -0x4(%rbp)
jmp 0x1490
cmpl $0x3f, -0x8(%rbp)
jne 0x1489
movl $0x0, -0x4(%rbp)
jmp 0x1490
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dwelch67[P]lc3/lc3asm.c
// Function: parse_reg
unsigned int parse_reg ( unsigned int ra )
{
    unsigned int rb;

    for(;newline[ra];ra++) if(newline[ra]!=0x20) break;
    rb=0;
    for(;newline[ra];ra++)
    {
        if(newline[ra]==',') break;
        if(newline[ra]==0x20) break;
        cstring[rb++]=newline[ra];
    }
    cstring[rb]=0;
    if(get_reg_number(cstring,&rx))
    {
        printf("<%u> Error: not a register\n",line);
        return(0);
    }
    for(;newline[ra];ra++) if(newline[ra]!=0x20) break;
    return(ra);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x5b69(%rip), %rax      # 0x72c0
cmpb $0x0, (%rax,%rcx)
je 0x1781
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x5b57(%rip), %rax      # 0x72c0
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x1774
jmp 0x1781
jmp 0x1776
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x174b
movl $0x0, -0xc(%rbp)
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x5b2c(%rip), %rax      # 0x72c0
cmpb $0x0, (%rax,%rcx)
je 0x17fb
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x5b1a(%rip), %rax      # 0x72c0
movsbl (%rax,%rcx), %eax
cmpl $0x2c, %eax
jne 0x17b1
jmp 0x17fb
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x5b03(%rip), %rax      # 0x72c0
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
jne 0x17c8
jmp 0x17fb
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x5aec(%rip), %rax      # 0x72c0
movb (%rax,%rcx), %dl
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0xc(%rbp)
movl %eax, %eax
movl %eax, %ecx
leaq 0x5ee3(%rip), %rax      # 0x76d0
movb %dl, (%rax,%rcx)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1788
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x5ec9(%rip), %rax      # 0x76d0
movb $0x0, (%rax,%rcx)
leaq 0x5ebe(%rip), %rdi      # 0x76d0
leaq 0x62b7(%rip), %rsi      # 0x7ad0
callq 0x1250
cmpl $0x0, %eax
je 0x1840
movl 0x5e97(%rip), %esi      # 0x76c0
leaq 0x385a(%rip), %rdi      # 0x508a
movb $0x0, %al
callq 0x1050
movl $0x0, -0x4(%rbp)
jmp 0x187e
jmp 0x1842
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x5a72(%rip), %rax      # 0x72c0
cmpb $0x0, (%rax,%rcx)
je 0x1878
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x5a60(%rip), %rax      # 0x72c0
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x186b
jmp 0x1878
jmp 0x186d
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1842
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dwelch67[P]lc3/lc3asm.c
// Function: parse_comma
unsigned int parse_comma ( unsigned int ra )
{
    for(;newline[ra];ra++) if(newline[ra]!=0x20) break;
    if(newline[ra]!=',')
    {
        printf("<%u> Error: syntax error\n",line);
        return(0);
    }
    ra++;
    for(;newline[ra];ra++) if(newline[ra]!=0x20) break;
    return(ra);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x5a19(%rip), %rax      # 0x72c0
cmpb $0x0, (%rax,%rcx)
je 0x18d1
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x5a07(%rip), %rax      # 0x72c0
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x18c4
jmp 0x18d1
jmp 0x18c6
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x189b
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x59e3(%rip), %rax      # 0x72c0
movsbl (%rax,%rcx), %eax
cmpl $0x2c, %eax
je 0x1903
movl 0x5dd4(%rip), %esi      # 0x76c0
leaq 0x37b3(%rip), %rdi      # 0x50a6
movb $0x0, %al
callq 0x1050
movl $0x0, -0x4(%rbp)
jmp 0x1948
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x59a8(%rip), %rax      # 0x72c0
cmpb $0x0, (%rax,%rcx)
je 0x1942
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x5996(%rip), %rax      # 0x72c0
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x1935
jmp 0x1942
jmp 0x1937
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x190c
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dwelch67[P]lc3/lc3asm.c
// Function: parse_three_regs
unsigned int parse_three_regs ( unsigned int ra )
{
    ra=parse_reg(ra); if(ra==0) return(0);
    rd=rx;
    ra=parse_comma(ra); if(ra==0) return(0);
    ra=parse_reg(ra); if(ra==0) return(0);
    rs=rx;
    ra=parse_comma(ra); if(ra==0) return(0);
    ra=parse_reg(ra); if(ra==0) return(0);
    rt=rx;
    return(ra);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %edi
callq 0x1740
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x1a58
movl $0x0, -0x4(%rbp)
jmp 0x1aea
movl 0x6072(%rip), %eax      # 0x7ad0
movl %eax, 0x6070(%rip)      # 0x7ad4
movl -0x8(%rbp), %edi
callq 0x1890
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x1a7e
movl $0x0, -0x4(%rbp)
jmp 0x1aea
movl -0x8(%rbp), %edi
callq 0x1740
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x1a98
movl $0x0, -0x4(%rbp)
jmp 0x1aea
movl 0x6032(%rip), %eax      # 0x7ad0
movl %eax, 0x6034(%rip)      # 0x7ad8
movl -0x8(%rbp), %edi
callq 0x1890
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x1abe
movl $0x0, -0x4(%rbp)
jmp 0x1aea
movl -0x8(%rbp), %edi
callq 0x1740
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x1ad8
movl $0x0, -0x4(%rbp)
jmp 0x1aea
movl 0x5ff2(%rip), %eax      # 0x7ad0
movl %eax, 0x5ff8(%rip)      # 0x7adc
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dwelch67[P]lc3/lc3asm.c
// Function: parse_two_regs
unsigned int parse_two_regs ( unsigned int ra )
{
    ra=parse_reg(ra); if(ra==0) return(0);
    rd=rx;
    ra=parse_comma(ra); if(ra==0) return(0);
    ra=parse_reg(ra); if(ra==0) return(0);
    rs=rx;
    return(ra);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %edi
callq 0x1740
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x1b25
movl $0x0, -0x4(%rbp)
jmp 0x1b77
movl 0x5fa5(%rip), %eax      # 0x7ad0
movl %eax, 0x5fa3(%rip)      # 0x7ad4
movl -0x8(%rbp), %edi
callq 0x1890
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x1b4b
movl $0x0, -0x4(%rbp)
jmp 0x1b77
movl -0x8(%rbp), %edi
callq 0x1740
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x1b65
movl $0x0, -0x4(%rbp)
jmp 0x1b77
movl 0x5f65(%rip), %eax      # 0x7ad0
movl %eax, 0x5f67(%rip)      # 0x7ad8
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/dwelch67[P]lc3/lc3asm.c
// Function: parse_two_label
unsigned int parse_two_label ( unsigned int ra )
{
    ra=parse_reg(ra); if(ra==0) return(0);
    rt=rx;
    ra=parse_comma(ra); if(ra==0) return(0);
    ra=parse_reg(ra); if(ra==0) return(0);
    rs=rx;
    ra=parse_comma(ra); if(ra==0) return(0);
    ra=parse_branch_label(ra); if(ra==0) return(0);
    rd=rx;
    return(ra);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %edi
callq 0x1740
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x1eb8
movl $0x0, -0x4(%rbp)
jmp 0x1f4a
movl 0x5c12(%rip), %eax      # 0x7ad0
movl %eax, 0x5c18(%rip)      # 0x7adc
movl -0x8(%rbp), %edi
callq 0x1890
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x1ede
movl $0x0, -0x4(%rbp)
jmp 0x1f4a
movl -0x8(%rbp), %edi
callq 0x1740
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x1ef8
movl $0x0, -0x4(%rbp)
jmp 0x1f4a
movl 0x5bd2(%rip), %eax      # 0x7ad0
movl %eax, 0x5bd4(%rip)      # 0x7ad8
movl -0x8(%rbp), %edi
callq 0x1890
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x1f1e
movl $0x0, -0x4(%rbp)
jmp 0x1f4a
movl -0x8(%rbp), %edi
callq 0x1c50
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x1f38
movl $0x0, -0x4(%rbp)
jmp 0x1f4a
movl 0x5b92(%rip), %eax      # 0x7ad0
movl %eax, 0x5b90(%rip)      # 0x7ad4
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dwelch67[P]lc3/lc3asm.c
// Function: parse_one_label
unsigned int parse_one_label ( unsigned int ra )
{
    ra=parse_reg(ra); if(ra==0) return(0);
    rs=rx;
    ra=parse_comma(ra); if(ra==0) return(0);
    ra=parse_branch_label(ra); if(ra==0) return(0);
    rd=rx;
    return(ra);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %edi
callq 0x1740
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x1f85
movl $0x0, -0x4(%rbp)
jmp 0x1fd7
movl 0x5b45(%rip), %eax      # 0x7ad0
movl %eax, 0x5b47(%rip)      # 0x7ad8
movl -0x8(%rbp), %edi
callq 0x1890
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x1fab
movl $0x0, -0x4(%rbp)
jmp 0x1fd7
movl -0x8(%rbp), %edi
callq 0x1c50
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x1fc5
movl $0x0, -0x4(%rbp)
jmp 0x1fd7
movl 0x5b05(%rip), %eax      # 0x7ad0
movl %eax, 0x5b03(%rip)      # 0x7ad4
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/hamsternz[P]drummer/drummer.c
// Function: intToU4
void intToU4(uint8_t *d, int val) {
   d[0] = val;
   d[1] = val>>8;
   d[2] = val>>16;
   d[3] = val>>24;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl -0xc(%rsp), %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, (%rax)
movl -0xc(%rsp), %eax
sarl $0x8, %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x1(%rax)
movl -0xc(%rsp), %eax
sarl $0x10, %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x2(%rax)
movl -0xc(%rsp), %eax
sarl $0x18, %eax
movb %al, %cl
movq -0x8(%rsp), %rax
movb %cl, 0x3(%rax)
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hamsternz[P]drummer/drummer.c
// Function: output_header
int output_header(FILE *f, int samples_to_generate) {
   struct WaveFileHeader header;

   memcpy(header.chunkID,       "RIFF",4);
   intToU4(header.chunkSize,     36 + samples_to_generate*4);
   memcpy(header.chunkFormat,    "WAVE",4);

   memcpy(header.subchunk1ID,   "fmt ",4);
   intToU4(header.subchunk1Size, 16);
   intToU2(header.audioFormat,   1);
   intToU2(header.numChannels,   2);
   intToU4(header.sampleRate,    44100);
   intToU4(header.byteRate,      44100*4);
   intToU2(header.blockAlign,    4);
   intToU2(header.bitsPerSample, 16);
   memcpy(header.subchunk2ID,   "data", 4);
   intToU4(header.subchunk2Size, samples_to_generate*4);
   if(fwrite(&header, sizeof(header), 1, f) != 1) {
      return 0;
   }
   return 1;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movl 0x16359(%rip), %eax     # 0x178cc
movl %eax, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
addq $0x4, %rdi
movl 0x34(%rsp), %esi
shll $0x2, %esi
addl $0x24, %esi
callq 0x14e0
movl 0x1633c(%rip), %eax     # 0x178d1
movl %eax, 0x10(%rsp)
movl 0x16337(%rip), %eax     # 0x178d6
movl %eax, 0x14(%rsp)
leaq 0x8(%rsp), %rdi
addq $0x10, %rdi
movl $0x10, %esi
callq 0x14e0
leaq 0x8(%rsp), %rdi
addq $0x14, %rdi
movl $0x1, %esi
callq 0x1530
leaq 0x8(%rsp), %rdi
addq $0x16, %rdi
movl $0x2, %esi
callq 0x1530
leaq 0x8(%rsp), %rdi
addq $0x18, %rdi
movl $0xac44, %esi           # imm = 0xAC44
callq 0x14e0
leaq 0x8(%rsp), %rdi
addq $0x1c, %rdi
movl $0x2b110, %esi          # imm = 0x2B110
callq 0x14e0
leaq 0x8(%rsp), %rdi
addq $0x20, %rdi
movl $0x4, %esi
callq 0x1530
leaq 0x8(%rsp), %rdi
addq $0x22, %rdi
movl $0x10, %esi
callq 0x1530
movl 0x162ad(%rip), %eax     # 0x178db
movl %eax, 0x2c(%rsp)
leaq 0x8(%rsp), %rdi
addq $0x28, %rdi
movl 0x34(%rsp), %esi
shll $0x2, %esi
callq 0x14e0
movq 0x38(%rsp), %rcx
leaq 0x8(%rsp), %rdi
movl $0x2c, %esi
movl $0x1, %edx
callq 0x1070
cmpq $0x1, %rax
je 0x1670
movl $0x0, 0x44(%rsp)
jmp 0x1678
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hamsternz[P]drummer/drummer.c
// Function: write_sample
int write_sample(FILE *f, int16_t samples[2]) {
   uint8_t o[4];
   o[0] = samples[0];
   o[1] = samples[0]>>8;
   o[2] = samples[1];
   o[3] = samples[1]>>8;
   if(fwrite(o, sizeof(o), 1, f) != 1) 
     return 0;
   return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movw (%rax), %ax
movb %al, 0xc(%rsp)
movq 0x10(%rsp), %rax
movswl (%rax), %eax
sarl $0x8, %eax
movb %al, 0xd(%rsp)
movq 0x10(%rsp), %rax
movw 0x2(%rax), %ax
movb %al, 0xe(%rsp)
movq 0x10(%rsp), %rax
movswl 0x2(%rax), %eax
sarl $0x8, %eax
movb %al, 0xf(%rsp)
leaq 0xc(%rsp), %rdi
movq 0x18(%rsp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x1070
cmpq $0x1, %rax
je 0x16ff
movl $0x0, 0x24(%rsp)
jmp 0x1707
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/hamsternz[P]drummer/drummer.c
// Function: main
int main(int argc, char *argv[]) {
   FILE *f;
   int16_t samples[2];
   samplesPerBeat = SAMPLE_RATE*60/BPM;
   samplesPerTick = samplesPerBeat * BEATS_PER_BAR / BAR_LEN;
   samplesToGenerate = samplesPerTick * BAR_LEN * LOOP_BARS;

   printf("Samples per beet is %i\n", samplesPerBeat);
   printf("samples_per tick is %i\n", samplesPerTick);
   printf("samples_to_generate is %i\n", samplesToGenerate);
  
   f = fopen("out.wav","w");
   if(f == NULL) {
     fprintf(stderr, "Unable to open output file\n");
     return 0;
   } 
   output_header(f, samplesToGenerate);
   for(int i = 0; i < samplesToGenerate; i++) {
       generate_sample(samples);
       write_sample(f, samples);
   }
   fclose(f);
   printf("sampleOfTick %i\n",sampleOfTick);
   printf("tickOfBar    %i\n",tickOfBar);
   printf("bar          %i\n",bar);
   return 0;
}

// Assembly:
subq $0x28, %rsp
movl $0x0, 0x24(%rsp)
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl $0x42ae, 0x17f3d(%rip)  # imm = 0x42AE
movl 0x17f37(%rip), %eax     # 0x1966c
shll $0x2, %eax
movl $0x48, %ecx
cltd
idivl %ecx
movl %eax, 0x17f22(%rip)     # 0x19668
imull $0x48, 0x17f1b(%rip), %eax # 0x19668
imull $0xa, %eax, %eax
movl %eax, 0x17f1a(%rip)     # 0x19670
movl 0x17f10(%rip), %esi     # 0x1966c
leaq 0x1617d(%rip), %rdi     # 0x178e0
movb $0x0, %al
callq 0x1040
movl 0x17ef8(%rip), %esi     # 0x19668
leaq 0x16181(%rip), %rdi     # 0x178f8
movb $0x0, %al
callq 0x1040
movl 0x17eec(%rip), %esi     # 0x19670
leaq 0x16185(%rip), %rdi     # 0x17910
movb $0x0, %al
callq 0x1040
leaq 0x16192(%rip), %rdi     # 0x1792b
leaq 0x16193(%rip), %rsi     # 0x17933
callq 0x1060
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x17d7
movq 0x1783f(%rip), %rax     # 0x18ff8
movq (%rax), %rdi
leaq 0x16172(%rip), %rsi     # 0x17935
movb $0x0, %al
callq 0x1050
movl $0x0, 0x24(%rsp)
jmp 0x186f
movq 0x10(%rsp), %rdi
movl 0x17e8e(%rip), %esi     # 0x19670
callq 0x1560
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0x17e77(%rip), %eax     # 0x19670
jge 0x1821
leaq 0xc(%rsp), %rdi
callq 0x1180
movq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x1690
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x17ef
movq 0x10(%rsp), %rdi
callq 0x1030
movl 0x17e2b(%rip), %esi     # 0x1965c
leaq 0x16119(%rip), %rdi     # 0x17951
movb $0x0, %al
callq 0x1040
movl 0x17e1f(%rip), %esi     # 0x19664
leaq 0x16116(%rip), %rdi     # 0x17962
movb $0x0, %al
callq 0x1040
movl 0x17e07(%rip), %esi     # 0x19660
leaq 0x16113(%rip), %rdi     # 0x17973
movb $0x0, %al
callq 0x1040
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/LenShustek[P]miditones/miditones.c
// Function: opt_key
bool opt_key(const char* arg, const char* keyword) {
   do { // check for a keyword option and nothing after it
      if (tolower(*arg++) != *keyword++) return false; }
   while (*keyword);
   return *arg == '\0'; }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq 0x8(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rsp)
movsbl (%rax), %edi
callq 0x10d0
movq (%rsp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, (%rsp)
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x12f3
movb $0x0, 0x17(%rsp)
jmp 0x1312
jmp 0x12f5
movq (%rsp), %rax
cmpb $0x0, (%rax)
jne 0x12bd
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/LenShustek[P]miditones/miditones.c
// Function: opt_int
bool opt_int(const char* arg, const char* keyword, int *pval, int min, int max) {
   do { // check for a "keyword=integer" option and nothing after it
      if (tolower(*arg++) != *keyword++)
         return false; }
   while (*keyword);
   if (*arg == '=') ++arg; // = is optional, actually
   int num, nch;
   if (sscanf(arg, *arg == '0' && *(arg + 1) == 'x' ? "%x%n" : "%d%n", &num, &nch) != 1) return false;
   if (num < min || num > max || arg[nch] != '\0') return false;
   *pval = num;
   return true; }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movl %r8d, 0x20(%rsp)
movq 0x38(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x38(%rsp)
movsbl (%rax), %edi
callq 0x10d0
movq 0x30(%rsp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, 0x30(%rsp)
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x1377
movb $0x0, 0x47(%rsp)
jmp 0x1447
jmp 0x1379
movq 0x30(%rsp), %rax
cmpb $0x0, (%rax)
jne 0x133c
movq 0x38(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x3d, %eax
jne 0x139e
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x30, %ecx
movb %al, 0x17(%rsp)
jne 0x13ce
movq 0x38(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x78, %eax
sete %al
movb %al, 0x17(%rsp)
movq 0x8(%rsp), %rdi
movb 0x17(%rsp), %cl
leaq 0x5e59(%rip), %rsi      # 0x7237
leaq 0x5e4d(%rip), %rax      # 0x7232
testb $0x1, %cl
cmovneq %rax, %rsi
leaq 0x1c(%rsp), %rdx
leaq 0x18(%rsp), %rcx
movb $0x0, %al
callq 0x1100
cmpl $0x1, %eax
je 0x1409
movb $0x0, 0x47(%rsp)
jmp 0x1447
movl 0x1c(%rsp), %eax
cmpl 0x24(%rsp), %eax
jl 0x1430
movl 0x1c(%rsp), %eax
cmpl 0x20(%rsp), %eax
jg 0x1430
movq 0x38(%rsp), %rax
movslq 0x18(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x1437
movb $0x0, 0x47(%rsp)
jmp 0x1447
movl 0x1c(%rsp), %ecx
movq 0x28(%rsp), %rax
movl %ecx, (%rax)
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LenShustek[P]miditones/miditones.c
// Function: opt_str
bool opt_str(const char* arg, const char* keyword, const char** str) {
   do { // check for a "keyword=string" option
      if (tolower(*arg++) != *keyword++) return false; }
   while (*keyword);
   *str = arg; // ptr to "string" part, which could be null
   return true; }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rsp)
movsbl (%rax), %edi
callq 0x10d0
movq 0x10(%rsp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, 0x10(%rsp)
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x14ab
movb $0x0, 0x27(%rsp)
jmp 0x14c9
jmp 0x14ad
movq 0x10(%rsp), %rax
cmpb $0x0, (%rax)
jne 0x1473
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LenShustek[P]miditones/miditones.c
// Function: assert
void assert(bool condition, char *msg) {
   if (!condition) {
      fprintf(stderr, "*** internal assertion error: %s\n", msg);
      if (logfile) fprintf(logfile, "*** internal assertion error: %s\n", msg);
      exit(8); } }

// Assembly:
subq $0x18, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, 0x17(%rsp)
movq %rsi, 0x8(%rsp)
testb $0x1, 0x17(%rsp)
jne 0x1cd4
movq 0x9368(%rip), %rax      # 0xaff8
movq (%rax), %rdi
movq 0x8(%rsp), %rdx
leaq 0x5ef9(%rip), %rsi      # 0x7b98
movb $0x0, %al
callq 0x10a0
cmpq $0x0, 0x966a(%rip)      # 0xb318
je 0x1cca
movq 0x9661(%rip), %rdi      # 0xb318
movq 0x8(%rsp), %rdx
leaq 0x5ed5(%rip), %rsi      # 0x7b98
movb $0x0, %al
callq 0x10a0
movl $0x8, %edi
callq 0x1140
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/LenShustek[P]miditones/miditones.c
// Function: midi_error
void midi_error(char *msg, byte *bufptr) {
   fprintf(stderr, "---> MIDI file error at position %04X (%d): %s\n",
           (uint16_t)(bufptr - buffer), (uint16_t)(bufptr - buffer), msg);
   byte *ptr = bufptr - 16;   // print some bytes surrounding the error
   if (ptr < buffer) ptr = buffer;
   for (; ptr <= bufptr + 16 && ptr < buffer + buflen; ++ptr)
      fprintf(stderr, ptr == bufptr ? " [%02X]  " : "%02X ", *ptr);
   fprintf(stderr, "\n");
   exit(8); }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x9303(%rip), %rax      # 0xaff8
movq (%rax), %rdi
movq 0x18(%rsp), %rax
movq 0x961c(%rip), %rcx      # 0xb320
subq %rcx, %rax
movzwl %ax, %edx
movq 0x18(%rsp), %rax
movq 0x960a(%rip), %rcx      # 0xb320
subq %rcx, %rax
movzwl %ax, %ecx
movq 0x20(%rsp), %r8
leaq 0x5e92(%rip), %rsi      # 0x7bba
movb $0x0, %al
callq 0x10a0
movq 0x18(%rsp), %rax
addq $-0x10, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x95d7(%rip), %rax      # 0xb320
jae 0x1d57
movq 0x95ce(%rip), %rax      # 0xb320
movq %rax, 0x10(%rsp)
jmp 0x1d59
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rdx
addq $0x10, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, 0xf(%rsp)
ja 0x1d8f
movq 0x10(%rsp), %rax
movq 0x95a2(%rip), %rcx      # 0xb320
addq 0x95a3(%rip), %rcx      # 0xb328
cmpq %rcx, %rax
setb %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x1d99
jmp 0x1de4
movq 0x9258(%rip), %rax      # 0xaff8
movq (%rax), %rdi
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rdx
leaq 0x5e40(%rip), %rsi      # 0x7bf4
leaq 0x5e2f(%rip), %rax      # 0x7bea
cmpq %rdx, %rcx
cmoveq %rax, %rsi
movq 0x10(%rsp), %rax
movzbl (%rax), %edx
movb $0x0, %al
callq 0x10a0
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x1d59
movq 0x920d(%rip), %rax      # 0xaff8
movq (%rax), %rdi
leaq 0x6a60(%rip), %rsi      # 0x8855
movb $0x0, %al
callq 0x10a0
movl $0x8, %edi
callq 0x1140
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LenShustek[P]miditones/miditones.c
// Function: miditones_strlcpy
size_t miditones_strlcpy (char *dst, const char *src, size_t siz) {
   char *d = dst;
   const char *s = src;
   size_t n = siz;
   if (n != 0) {   /* Copy as many bytes as will fit */
      while (--n != 0) {
         if ((*d++ = *s++) == '\0') break; } }
   if (n == 0) {   /* Not enough room in dst, add NUL and traverse rest of src */
      if (siz != 0) *d = '\0';  /* NUL-terminate dst */
      while (*s++) ; }
   return (s - src - 1);        /* count does not include NUL */
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x30(%rsp)
cmpq $0x0, -0x30(%rsp)
je 0x1ecf
jmp 0x1e87
movq -0x30(%rsp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rsp)
cmpq $0x0, %rax
je 0x1ecd
movq -0x28(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rsp)
movb (%rax), %al
movq -0x20(%rsp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rsp)
movb %al, (%rcx)
movsbl %al, %eax
cmpl $0x0, %eax
jne 0x1ecb
jmp 0x1ecd
jmp 0x1e87
jmp 0x1ecf
cmpq $0x0, -0x30(%rsp)
jne 0x1f03
cmpq $0x0, -0x18(%rsp)
je 0x1ee7
movq -0x20(%rsp), %rax
movb $0x0, (%rax)
jmp 0x1ee9
movq -0x28(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rsp)
cmpb $0x0, (%rax)
je 0x1f01
jmp 0x1ee9
jmp 0x1f03
movq -0x28(%rsp), %rax
movq -0x10(%rsp), %rcx
subq %rcx, %rax
subq $0x1, %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LenShustek[P]miditones/miditones.c
// Function: miditones_strlcat
size_t miditones_strlcat (char *dst, const char *src, size_t siz) {
   char *d = dst;
   const char *s = src;
   size_t n = siz;
   size_t dlen;
   /* Find the end of dst and adjust bytes left but don't go past end */
   while (n-- != 0 && *d != '\0') d++;
   dlen = d - dst;
   n = siz - dlen;
   if (n == 0) return (dlen + strlength (s));
   while (*s != '\0') {
      if (n != 1) {
         *d++ = *s;
         n--; }
      s++; }
   *d = '\0';
   return (dlen + (s - src));   /* count does not include NUL */
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, %rax
addq $-0x1, %rax
movq %rax, 0x20(%rsp)
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, 0x17(%rsp)
je 0x1f80
movq 0x30(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x1f8a
jmp 0x1f9a
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x1f51
movq 0x30(%rsp), %rax
movq 0x48(%rsp), %rcx
subq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rax
subq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x1feb
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x1e10
movl %eax, %ecx
movq 0x8(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x50(%rsp)
jmp 0x205c
jmp 0x1fed
movq 0x28(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x203a
cmpq $0x1, 0x20(%rsp)
je 0x202a
movq 0x28(%rsp), %rax
movb (%rax), %cl
movq 0x30(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x30(%rsp)
movb %cl, (%rax)
movq 0x20(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x1fed
movq 0x30(%rsp), %rax
movb $0x0, (%rax)
movq 0x18(%rsp), %rax
movq 0x28(%rsp), %rcx
movq 0x40(%rsp), %rdx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LenShustek[P]miditones/miditones.c
// Function: charcmp
int charcmp (const char *buf, const char *match) {
   int len, i;
   len = strlength (match);
   for (i = 0; i < len; ++i)
      if (buf[i] != match[i]) return 0;
   return 1; }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x1e10
movl %eax, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x20d7
movq 0x18(%rsp), %rax
movslq 0x8(%rsp), %rcx
movsbl (%rax,%rcx), %eax
movq 0x10(%rsp), %rcx
movslq 0x8(%rsp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x20c8
movl $0x0, 0x24(%rsp)
jmp 0x20df
jmp 0x20ca
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x2094
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LenShustek[P]miditones/miditones.c
// Function: outfile_items
void outfile_items(int n) {
   outfile_bytecount += n;
   outfile_itemcount += n;
   if (!binaryoutput) {
      if (outfile_itemcount >= outfile_maxitems) {
         if (asm_output) fprintf(outfile, "\n%s", byteop);
         else fprintf(outfile, ",\n");
         outfile_itemcount = 0; }
      else fprintf(outfile, ", "); } }

// Assembly:
pushq %rax
movl %edi, 0x4(%rsp)
movslq 0x4(%rsp), %rax
addq 0x90f7(%rip), %rax      # 0xb2c8
movq %rax, 0x90f0(%rip)      # 0xb2c8
movl 0x4(%rsp), %eax
addl 0x9092(%rip), %eax      # 0xb274
movl %eax, 0x908c(%rip)      # 0xb274
testb $0x1, 0x9111(%rip)      # 0xb300
jne 0x225e
movl 0x907d(%rip), %eax      # 0xb274
cmpl 0x8edb(%rip), %eax      # 0xb0d8
jl 0x2247
testb $0x1, 0x9104(%rip)      # 0xb30a
je 0x2226
movq 0x9121(%rip), %rdi      # 0xb330
movq 0x8eba(%rip), %rdx      # 0xb0d0
leaq 0x6831(%rip), %rsi      # 0x8a4e
movb $0x0, %al
callq 0x10a0
jmp 0x223b
movq 0x9103(%rip), %rdi      # 0xb330
leaq 0x59d3(%rip), %rsi      # 0x7c07
movb $0x0, %al
callq 0x10a0
movl $0x0, 0x902f(%rip)      # 0xb274
jmp 0x225c
movq 0x90e2(%rip), %rdi      # 0xb330
leaq 0x67d7(%rip), %rsi      # 0x8a2c
movb $0x0, %al
callq 0x10a0
jmp 0x225e
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O0/LenShustek[P]miditones/miditones.c
// Function: describe
char *describe(struct noteinfo *np) { // create a description of a note
   // WARNING: returns a pointer to a static string, so only call once per line, in a printf!
   static char notedescription[100];
   int secs = np->time_usec / 1000000;
   sprintf(notedescription, "at %3lu.%06lu sec (%d:%02d), note %d (0x%02X) track %d channel %d volume %d instrument %d",
           secs, np->time_usec % 1000000,
           secs/60, secs % 60,
           np->note, np->note,
           np->track, np->channel, np->volume, np->instrument);
   return notedescription; }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movl (%rax), %eax
movl $0xf4240, %ecx          # imm = 0xF4240
xorl %edx, %edx
divl %ecx
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0x30(%rsp)
movq 0x38(%rsp), %rax
movl (%rax), %eax
movl $0xf4240, %ecx          # imm = 0xF4240
xorl %edx, %edx
divl %ecx
movl %edx, %ecx
movl 0x34(%rsp), %eax
movl $0x3c, %esi
cltd
idivl %esi
movl %eax, %r8d
movl 0x34(%rsp), %eax
movl $0x3c, %esi
cltd
idivl %esi
movl %edx, %r9d
movl 0x30(%rsp), %edx
movq 0x38(%rsp), %rax
movl 0xc(%rax), %r14d
movq 0x38(%rsp), %rax
movl 0xc(%rax), %ebp
movq 0x38(%rsp), %rax
movl 0x4(%rax), %ebx
movq 0x38(%rsp), %rax
movl 0x8(%rax), %r11d
movq 0x38(%rsp), %rax
movl 0x14(%rax), %r10d
movq 0x38(%rsp), %rax
movl 0x10(%rax), %eax
leaq 0xafc9(%rip), %rdi      # 0xd2c0
leaq 0x590c(%rip), %rsi      # 0x7c0a
movl %r14d, (%rsp)
movl %ebp, 0x8(%rsp)
movl %ebx, 0x10(%rsp)
movl %r11d, 0x18(%rsp)
movl %r10d, 0x20(%rsp)
movl %eax, 0x28(%rsp)
movb $0x0, %al
callq 0x1130
leaq 0xaf9a(%rip), %rax      # 0xd2c0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/LenShustek[P]miditones/miditones.c
// Function: show_queue
void show_queue(void) { // for debugging: dump the whole event queue
   FILE *fid = logfile;
   if (!logfile) fid = stdout;
   fprintf(fid, "***at output time %lu.%03lu  queue has %d items; oldest at %d, newest at %d\n",
           output_usec / 1000, output_usec % 1000, queue_numitems, queue_oldest_ndx, queue_newest_ndx);
   int ndx = queue_oldest_ndx;
   if (queue_numitems > 0) while (1) {
         struct queue_entry *q = &queue[ndx];
         fprintf(fid, "%2d: %s %s %s\n", ndx, q->cmd == CMD_PLAYNOTE ? "PLAY" : "STOP", q->delete ? "deleted" : "", describe(&q->note));
         if (ndx == queue_newest_ndx) break;
         if (++ndx >= QUEUE_SIZE) ndx = 0; } }

// Assembly:
subq $0x48, %rsp
movq 0x8fdd(%rip), %rax      # 0xb318
movq %rax, 0x40(%rsp)
cmpq $0x0, 0x8fd0(%rip)      # 0xb318
jne 0x2359
movq 0x8c87(%rip), %rax      # 0xafd8
movq (%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movl 0x8f84(%rip), %eax      # 0xb2e8
movl $0x3e8, %ecx            # imm = 0x3E8
xorl %edx, %edx
divl %ecx
movl %eax, 0x2c(%rsp)
movl 0x8f71(%rip), %eax      # 0xb2e8
movl $0x3e8, %ecx            # imm = 0x3E8
xorl %edx, %edx
divl %ecx
movl %edx, %ecx
movl 0x2c(%rsp), %edx
movl 0xaf97(%rip), %r8d      # 0xd324
movl 0xaf94(%rip), %r9d      # 0xd328
movl 0xaf92(%rip), %eax      # 0xd32c
leaq 0x58c3(%rip), %rsi      # 0x7c64
movl %eax, (%rsp)
movb $0x0, %al
callq 0x10a0
movl 0xaf77(%rip), %eax      # 0xd328
movl %eax, 0x3c(%rsp)
cmpl $0x0, 0xaf68(%rip)      # 0xd324
jle 0x2495
jmp 0x23c4
movslq 0x3c(%rsp), %rcx
leaq 0xaf70(%rip), %rax      # 0xd340
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x3c(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x30(%rsp), %rax
movzbl (%rax), %edx
leaq 0x58c8(%rip), %rax      # 0x7cc5
leaq 0x58bc(%rip), %rcx      # 0x7cc0
cmpl $0x90, %edx
cmoveq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movzbl 0x1(%rax), %edx
leaq 0x6433(%rip), %rax      # 0x8856
leaq 0x58a0(%rip), %rcx      # 0x7cca
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
addq $0x4, %rdi
callq 0x2260
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %edx
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %r8
movq %rax, %r9
leaq 0x5850(%rip), %rsi      # 0x7cb1
movb $0x0, %al
callq 0x10a0
movl 0x3c(%rsp), %eax
cmpl 0xaeba(%rip), %eax      # 0xd32c
jne 0x2476
jmp 0x2493
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
cmpl $0x64, %eax
jl 0x248e
movl $0x0, 0x3c(%rsp)
jmp 0x23c4
jmp 0x2495
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LenShustek[P]miditones/miditones.c
// Function: show_tonegens
void show_tonegens(void) { // for debugging: dump tone generator status
   FILE *fid = logfile;
   if (!logfile) fid = stdout;
   fprintf(fid, "*** tone generator status at output time %lu.%03lu\n", output_usec / 1000, output_usec % 1000);
   for (int tgnum = 0; tgnum < num_tonegens; ++tgnum) {
      struct tonegen_status *tg = &tonegen[tgnum];
      if (tg->playing)
         fprintf(fid, "#%d: playing note %d (%02X), instrument %d, track %d channel %d%s\n",
                 tgnum, tg->note.note, tg->note.note, tg->note.instrument, tg->note.track, tg->note.channel,
                 tg->stopnote_pending ? ", stopnote pending\n" : "");
      else fprintf(fid, "#%d: idle\n", tgnum); } }

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq 0x8e6c(%rip), %rax      # 0xb318
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x8e5f(%rip)      # 0xb318
jne 0x24ca
movq 0x8b16(%rip), %rax      # 0xafd8
movq (%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movl 0x8e13(%rip), %eax      # 0xb2e8
movl $0x3e8, %ecx            # imm = 0x3E8
xorl %edx, %edx
divl %ecx
movl %eax, 0x24(%rsp)
movl 0x8e00(%rip), %eax      # 0xb2e8
movl $0x3e8, %ecx            # imm = 0x3E8
xorl %edx, %edx
divl %ecx
movl %edx, %ecx
movl 0x24(%rsp), %edx
leaq 0x57d4(%rip), %rsi      # 0x7cd2
movb $0x0, %al
callq 0x10a0
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
cmpl 0x8bc5(%rip), %eax      # 0xb0dc
jge 0x25d8
movslq 0x34(%rsp), %rcx
leaq 0x8e17(%rip), %rax      # 0xb340
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
testb $0x1, (%rax)
je 0x25af
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %edx
movq 0x28(%rsp), %rax
movl 0x10(%rax), %ecx
movq 0x28(%rsp), %rax
movl 0x10(%rax), %r8d
movq 0x28(%rsp), %rax
movl 0x14(%rax), %r9d
movq 0x28(%rsp), %rax
movl 0x8(%rax), %r11d
movq 0x28(%rsp), %rax
movl 0xc(%rax), %r10d
movq 0x28(%rsp), %rax
movb 0x1(%rax), %bl
leaq 0x62d3(%rip), %rax      # 0x8856
leaq 0x57bf(%rip), %rsi      # 0x7d49
testb $0x1, %bl
cmovneq %rsi, %rax
leaq 0x576e(%rip), %rsi      # 0x7d06
movl %r11d, (%rsp)
movl %r10d, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movb $0x0, %al
callq 0x10a0
jmp 0x25c6
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %edx
leaq 0x579e(%rip), %rsi      # 0x7d5d
movb $0x0, %al
callq 0x10a0
jmp 0x25c8
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x250d
addq $0x40, %rsp
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O0/LenShustek[P]miditones/miditones.c
// Function: generate_delay
void generate_delay(unsigned long delta_msec) { // output a delay command
   if (delta_msec > 0) {
      assert(delta_msec <= 0x7fff, "time delta too big");
      if (last_output_was_delay) {
         ++consecutive_delays;
         if (loggen) fprintf(logfile, "      *** this is a consecutive delay, of %d msec\n", delta_msec); }
      last_output_was_delay = true;
      if (binaryoutput) { // output a 15-bit delay in big-endian format
         putc((byte)(delta_msec >> 8), outfile);
         putc((byte)(delta_msec & 0xff), outfile);
         outfile_bytecount += 2; }
      else if (asm_output) {
         fprintf(outfile, "%s%02X", hex, (byte)(delta_msec >> 8));
         outfile_items(1);
         fprintf(outfile, "%s%02X", hex, (byte)(delta_msec & 0xff));
         outfile_items(1); }
      else {
         fprintf(outfile, "%ld,%ld", delta_msec >> 8, delta_msec & 0xff);
         outfile_items(2); } } }

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jbe 0x3035
cmpq $0x7fff, (%rsp)         # imm = 0x7FFF
setbe %al
movzbl %al, %edi
andl $0x1, %edi
leaq 0x4ffb(%rip), %rsi      # 0x7ef3
callq 0x1c70
testb $0x1, 0x839c(%rip)      # 0xb2a0
je 0x2f39
movl 0x8390(%rip), %eax      # 0xb29c
addl $0x1, %eax
movl %eax, 0x8387(%rip)      # 0xb29c
testb $0x1, 0x83e7(%rip)      # 0xb303
je 0x2f37
movq 0x83f3(%rip), %rdi      # 0xb318
movq (%rsp), %rdx
leaq 0x4fd6(%rip), %rsi      # 0x7f06
movb $0x0, %al
callq 0x10a0
jmp 0x2f39
movb $0x1, 0x8360(%rip)      # 0xb2a0
testb $0x1, 0x83b9(%rip)      # 0xb300
je 0x2f90
movq (%rsp), %rax
shrq $0x8, %rax
movzbl %al, %edi
movq 0x83d5(%rip), %rsi      # 0xb330
callq 0x1090
movq (%rsp), %rax
andq $0xff, %rax
movzbl %al, %edi
movq 0x83bc(%rip), %rsi      # 0xb330
callq 0x1090
movq 0x8348(%rip), %rax      # 0xb2c8
addq $0x2, %rax
movq %rax, 0x833d(%rip)      # 0xb2c8
jmp 0x3033
testb $0x1, 0x8373(%rip)      # 0xb30a
je 0x2fff
movq 0x8390(%rip), %rdi      # 0xb330
movq 0x8121(%rip), %rdx      # 0xb0c8
movq (%rsp), %rax
shrq $0x8, %rax
movzbl %al, %ecx
leaq 0x4ead(%rip), %rsi      # 0x7e66
movb $0x0, %al
callq 0x10a0
movl $0x1, %edi
callq 0x21c0
movq 0x835f(%rip), %rdi      # 0xb330
movq 0x80f0(%rip), %rdx      # 0xb0c8
movq (%rsp), %rax
andq $0xff, %rax
movzbl %al, %ecx
leaq 0x4e7a(%rip), %rsi      # 0x7e66
movb $0x0, %al
callq 0x10a0
movl $0x1, %edi
callq 0x21c0
jmp 0x3031
movq 0x832a(%rip), %rdi      # 0xb330
movq (%rsp), %rdx
shrq $0x8, %rdx
movq (%rsp), %rcx
andq $0xff, %rcx
leaq 0x4f19(%rip), %rsi      # 0x7f39
movb $0x0, %al
callq 0x10a0
movl $0x2, %edi
callq 0x21c0
jmp 0x3033
jmp 0x3035
popq %rax
retq
nopw (%rax,%rax)