LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tektag.c
// Function: showsect2d
void
showsect2d(int s,int z)
{
     int  endwall,i,startwall;

     startwall=sectptr[s]->wallptr;
     endwall=startwall+sectptr[s]->wallnum-1;
     for (i=startwall ; i <= endwall ; i++) {
          if (wallptr[i]->nextwall != -1) {
               if (sectptr[wallptr[i]->nextsector]->floorz == z) {
                    showwall2d(i,0);
                    showwall2d(wallptr[i]->nextwall,0);
               }
               else {
                    showwall2d(i,1);
                    showwall2d(wallptr[i]->nextwall,1);
               }
          }
     }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x1fef07(%rip), %rax    # 0x2421e0
movq (%rax,%rcx,8), %rax
movswl (%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movslq -0x4(%rbp), %rdx
leaq 0x1feeef(%rip), %rcx    # 0x2421e0
movq (%rcx,%rdx,8), %rcx
movswl 0x2(%rcx), %ecx
addl %ecx, %eax
subl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0x433b4
movslq -0x10(%rbp), %rcx
leaq 0x206ec2(%rip), %rax    # 0x24a1e0
movq (%rax,%rcx,8), %rax
movswl 0xa(%rax), %eax
cmpl $-0x1, %eax
je 0x433a4
movslq -0x10(%rbp), %rcx
leaq 0x206eaa(%rip), %rax    # 0x24a1e0
movq (%rax,%rcx,8), %rax
movswq 0xc(%rax), %rcx
leaq 0x1fee9a(%rip), %rax    # 0x2421e0
movq (%rax,%rcx,8), %rax
movl 0x8(%rax), %eax
cmpl -0x8(%rbp), %eax
jne 0x43378
movl -0x10(%rbp), %edi
xorl %esi, %esi
callq 0x43240
movslq -0x10(%rbp), %rcx
leaq 0x206e79(%rip), %rax    # 0x24a1e0
movq (%rax,%rcx,8), %rax
movswl 0xa(%rax), %edi
xorl %esi, %esi
callq 0x43240
jmp 0x433a2
movl -0x10(%rbp), %edi
movl $0x1, %esi
callq 0x43240
movslq -0x10(%rbp), %rcx
leaq 0x206e50(%rip), %rax    # 0x24a1e0
movq (%rax,%rcx,8), %rax
movswl 0xa(%rax), %edi
movl $0x1, %esi
callq 0x43240
jmp 0x433a4
jmp 0x433a6
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x43307
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tektag.c
// Function: showsect2dtoggle
void
showsect2dtoggle(int s,int onoff)
{
     int  endwall,i,startwall;

     startwall=sectptr[s]->wallptr;
     endwall=startwall+sectptr[s]->wallnum-1;
     for (i=startwall ; i <= endwall ; i++) {
          if (wallptr[i]->nextwall != -1) {
               showwall2d(i,onoff);
               showwall2d(wallptr[i]->nextwall,onoff);
          }
     }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x1fee07(%rip), %rax    # 0x2421e0
movq (%rax,%rcx,8), %rax
movswl (%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movslq -0x4(%rbp), %rdx
leaq 0x1fedef(%rip), %rcx    # 0x2421e0
movq (%rcx,%rdx,8), %rcx
movswl 0x2(%rcx), %ecx
addl %ecx, %eax
subl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0x4345a
movslq -0x10(%rbp), %rcx
leaq 0x206dc6(%rip), %rax    # 0x24a1e0
movq (%rax,%rcx,8), %rax
movswl 0xa(%rax), %eax
cmpl $-0x1, %eax
je 0x4344d
movl -0x10(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x43240
movslq -0x10(%rbp), %rcx
leaq 0x206da3(%rip), %rax    # 0x24a1e0
movq (%rax,%rcx,8), %rax
movswl 0xa(%rax), %edi
movl -0x8(%rbp), %esi
callq 0x43240
jmp 0x4344f
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x43407
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tektag.c
// Function: sectorblocked
int
sectorblocked(int   s)
{
     int       i,rv;

     rv=0;

     for( i=connecthead ; i >= 0 ; i=connectpoint2[i] ) {
          if( cursectnum[i] == s )
               rv=1;
          if( testneighborsectors(cursectnum[i], s) == 1 )
               rv=1;
     }
     if( headspritesect[s] != -1 )
          rv=1;

     return(rv);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0xc(%rbp)
leaq 0x761ad7(%rip), %rax    # 0x7a4f50
movl (%rax), %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jl 0x434dd
movslq -0x8(%rbp), %rcx
leaq 0xeb251(%rip), %rax     # 0x12e6e0
movswl (%rax,%rcx,2), %eax
cmpl -0x4(%rbp), %eax
jne 0x4349f
movl $0x1, -0xc(%rbp)
movslq -0x8(%rbp), %rcx
leaq 0xeb236(%rip), %rax     # 0x12e6e0
movw (%rax,%rcx,2), %cx
movl -0x4(%rbp), %eax
movswl %cx, %edi
movswl %ax, %esi
callq 0x3c530
cmpl $0x1, %eax
jne 0x434c8
movl $0x1, -0xc(%rbp)
jmp 0x434ca
movslq -0x8(%rbp), %rcx
leaq 0x761a8b(%rip), %rax    # 0x7a4f60
movl (%rax,%rcx,4), %eax
movl %eax, -0x8(%rbp)
jmp 0x4347e
movslq -0x4(%rbp), %rcx
leaq 0x562e58(%rip), %rax    # 0x5a6340
movswl (%rax,%rcx,2), %eax
cmpl $-0x1, %eax
je 0x434f8
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tektag.c
// Function: vehiclesoundstopped
void
vehiclesoundstopped(int sindex)
{
     int i;

     for( i=0; i < MAXSECTORVEHICLES; i++ ) {
          if (sectvehptr[i]->soundindex == sindex)
               sectvehptr[i]->soundindex = -1;
     }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $0xa, -0x8(%rbp)
jge 0x435a4
movslq -0x8(%rbp), %rcx
leaq 0x327e01(%rip), %rax    # 0x36b370
movq (%rax,%rcx,8), %rax
movl 0xa10(%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0x43597
movslq -0x8(%rbp), %rcx
leaq 0x327de7(%rip), %rax    # 0x36b370
movq (%rax,%rcx,8), %rax
movl $0xffffffff, 0xa10(%rax) # imm = 0xFFFFFFFF
jmp 0x43599
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x4355e
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tektag.c
// Function: teksetdelayfunc
void                          // kick off function after specified tics elapse
teksetdelayfunc(void (*delayfunc)(short),int tics,short parm)
{
     int  i,n;

     if (delayfunc == NULL) {
       return;
     }
     n=numdelayfuncs;
     for (i=0 ; i < n ; i++) {
       if (delayfuncptr[i]->func == delayfunc) {
            if (tics == 0) {
              memmove(delayfuncptr[i],delayfuncptr[numdelayfuncs-1],
                sizeof(struct delayfunc));
              memset(delayfuncptr[numdelayfuncs-1],0,
                sizeof(struct delayfunc));
              numdelayfuncs--;
              return;
            }
            else {
              delayfuncptr[i]->tics=tics;
              delayfuncptr[i]->parm=parm;
              return;
            }
       }
     }
     delayfuncptr[numdelayfuncs]->func=delayfunc;
     delayfuncptr[numdelayfuncs]->tics=tics;
     delayfuncptr[numdelayfuncs]->parm=parm;
     numdelayfuncs++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %dx, %ax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movw %ax, -0xe(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x435d2
jmp 0x43717
movswl 0x334207(%rip), %eax    # 0x3777e0
movl %eax, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x436b7
movslq -0x14(%rbp), %rcx
leaq 0x3343f6(%rip), %rax    # 0x3779f0
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x436a7
cmpl $0x0, -0xc(%rbp)
jne 0x43679
movslq -0x14(%rbp), %rcx
leaq 0x3343d4(%rip), %rax    # 0x3779f0
movq (%rax,%rcx,8), %rax
movswl 0x3341b9(%rip), %ecx    # 0x3777e0
subl $0x1, %ecx
movslq %ecx, %rdx
leaq 0x3343bc(%rip), %rcx    # 0x3779f0
movq (%rcx,%rdx,8), %rcx
movups (%rcx), %xmm0
movups %xmm0, (%rax)
movswl 0x33419b(%rip), %eax    # 0x3777e0
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x33439e(%rip), %rax    # 0x3779f0
movq (%rax,%rcx,8), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x8410
movw 0x334177(%rip), %ax     # 0x3777e0
addw $-0x1, %ax
movw %ax, 0x33416c(%rip)     # 0x3777e0
jmp 0x43717
movl -0xc(%rbp), %ecx
movslq -0x14(%rbp), %rdx
leaq 0x334369(%rip), %rax    # 0x3779f0
movq (%rax,%rdx,8), %rax
movl %ecx, 0x8(%rax)
movw -0xe(%rbp), %cx
movslq -0x14(%rbp), %rdx
leaq 0x334353(%rip), %rax    # 0x3779f0
movq (%rax,%rdx,8), %rax
movw %cx, 0xc(%rax)
jmp 0x43717
jmp 0x436a9
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x435e3
movq -0x8(%rbp), %rcx
movswq 0x33411d(%rip), %rdx    # 0x3777e0
leaq 0x334326(%rip), %rax    # 0x3779f0
movq (%rax,%rdx,8), %rax
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movswq 0x334104(%rip), %rdx    # 0x3777e0
leaq 0x33430d(%rip), %rax    # 0x3779f0
movq (%rax,%rdx,8), %rax
movl %ecx, 0x8(%rax)
movw -0xe(%rbp), %cx
movswq 0x3340ea(%rip), %rdx    # 0x3777e0
leaq 0x3342f3(%rip), %rax    # 0x3779f0
movq (%rax,%rdx,8), %rax
movw %cx, 0xc(%rax)
movw 0x3340d4(%rip), %ax     # 0x3777e0
addw $0x1, %ax
movw %ax, 0x3340c9(%rip)     # 0x3777e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tektag.c
// Function: setanimpic
void
setanimpic(short *pic,short tics,short frames)
{
     int  i;

     for (i=0 ; i < numanimates ; i++) {
          if (animpicptr[i]->pic == pic) {
               return;
          }
     }
     if (numanimates+1 < MAXANIMPICS) {
          animpicptr[numanimates]->pic=pic;
          animpicptr[numanimates]->tics=tics;
          animpicptr[numanimates]->frames=frames;
          animpicptr[numanimates]->nextclock=lockclock+tics;
          numanimates++;
     }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %dx, %ax
movw %si, %cx
movq %rdi, -0x8(%rbp)
movw %cx, -0xa(%rbp)
movw %ax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl 0x333c8e(%rip), %eax    # 0x3773d4
jge 0x43773
movslq -0x10(%rbp), %rcx
leaq 0x333f8d(%rip), %rax    # 0x3776e0
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x43766
jmp 0x43805
jmp 0x43768
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4373d
movl 0x333c5b(%rip), %eax    # 0x3773d4
addl $0x1, %eax
cmpl $0x20, %eax
jge 0x43805
movq -0x8(%rbp), %rcx
movslq 0x333c44(%rip), %rdx    # 0x3773d4
leaq 0x333f49(%rip), %rax    # 0x3776e0
movq (%rax,%rdx,8), %rax
movq %rcx, 0x8(%rax)
movw -0xa(%rbp), %cx
movslq 0x333c2a(%rip), %rdx    # 0x3773d4
leaq 0x333f2f(%rip), %rax    # 0x3776e0
movq (%rax,%rdx,8), %rax
movw %cx, 0x10(%rax)
movw -0xc(%rbp), %cx
movslq 0x333c10(%rip), %rdx    # 0x3773d4
leaq 0x333f15(%rip), %rax    # 0x3776e0
movq (%rax,%rdx,8), %rax
movw %cx, (%rax)
leaq 0xea02f(%rip), %rax     # 0x12d808
movl (%rax), %ecx
movswl -0xa(%rbp), %eax
addl %eax, %ecx
movslq 0x333bec(%rip), %rdx    # 0x3773d4
leaq 0x333ef1(%rip), %rax    # 0x3776e0
movq (%rax,%rdx,8), %rax
movl %ecx, 0x14(%rax)
movl 0x333bd8(%rip), %eax    # 0x3773d4
addl $0x1, %eax
movl %eax, 0x333bcf(%rip)    # 0x3773d4
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tektag.c
// Function: tekheadbob
void
tekheadbob(void)
{
     if( headbobon && (activemenu == 0) ) {
          headbob+=bobstep;
          if( headbob < -BOBBMAX || headbob > BOBBMAX ) {
               bobstep=-bobstep;
          }
     }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x0, 0xd6fe5(%rip)     # 0x11ae80
je 0x43ee3
leaq 0x134610(%rip), %rax    # 0x1784b4
cmpl $0x0, (%rax)
jne 0x43ee3
movl 0xd6fd5(%rip), %eax     # 0x11ae84
addl 0x333c5b(%rip), %eax    # 0x377b10
movl %eax, 0x333c55(%rip)    # 0x377b10
cmpl $0xfffffe00, 0x333c4b(%rip) # imm = 0xFFFFFE00
jl 0x43ed3
cmpl $0x200, 0x333c3f(%rip)  # imm = 0x200
jle 0x43ee1
xorl %eax, %eax
subl 0xd6fa9(%rip), %eax     # 0x11ae84
movl %eax, 0xd6fa3(%rip)     # 0x11ae84
jmp 0x43ee3
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tektxt.c
// Function: crashgame
void
crashgame(char *s,...)
{
     va_list argptr;

     musicoff();
     sendlogoff();
     uninitmultiplayers();
     uninitsb();
     cduninit();
     uninittimer();
     uninitinput();
     uninitengine();
     uninitgroupfile();
     teksavesetup();

     va_start(argptr,s);
     vprintf(s,argptr);
     va_end(argptr);
     printf("\n");
     exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x44275
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
callq 0x26ad0
callq 0x875b0
callq 0x875c0
callq 0x26a00
callq 0x9d30
callq 0xc22e0
callq 0xc2290
callq 0x52e50
callq 0x4d390
callq 0x25690
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x8940
leaq -0x20(%rbp), %rax
leaq 0xabc76(%rip), %rdi     # 0xeff80
movb $0x0, %al
callq 0x80b0
xorl %edi, %edi
callq 0x88d0
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/datascan.c
// Function: ImportDataFromPath
int ImportDataFromPath(const char *path, struct importdatameta *cbs)
{
    struct stat st;
    int found = 0, errors = 0;

    if (stat(path, &st) < 0) return IMPORTDATA_OK;

    if (st.st_mode & S_IFDIR) {
        switch (ImportFilesFromDir(path, cbs)) {
            case IMPORTDATA_COPIED: found = 1; break;
            case IMPORTDATA_ERROR: errors = 1; break;
        }
    }

    if (found) {
        if (WritePaletteFile() == COPYFILE_OK) {
            buildprintf("Wrote PALETTE.DAT\n");
        }
        return IMPORTDATA_COPIED;         // Finding anything is considered fine.
    }
    else if (errors) return IMPORTDATA_ERROR; // Finding nothing but errors reports back errors.
    return IMPORTDATA_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0xac(%rbp)
movl $0x0, -0xb0(%rbp)
movq -0x10(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x8130
cmpl $0x0, %eax
jge 0x44368
movl $0x0, -0x4(%rbp)
jmp 0x443fe
movl -0x90(%rbp), %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x0, %eax
je 0x443b9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x44410
movl %eax, %ecx
movl %ecx, -0xb4(%rbp)
subl $-0x1, %eax
je 0x443ad
jmp 0x44394
movl -0xb4(%rbp), %eax
subl $0x2, %eax
jne 0x443b7
jmp 0x443a1
movl $0x1, -0xac(%rbp)
jmp 0x443b7
movl $0x1, -0xb0(%rbp)
jmp 0x443b9
cmpl $0x0, -0xac(%rbp)
je 0x443e3
callq 0x446d0
cmpl $0x0, %eax
jne 0x443da
leaq 0x96809(%rip), %rdi     # 0xdabdc
movb $0x0, %al
callq 0x52630
movl $0x2, -0x4(%rbp)
jmp 0x443fe
cmpl $0x0, -0xb0(%rbp)
je 0x443f5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x443fe
jmp 0x443f7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/datascan.c
// Function: WritePaletteFile
static int WritePaletteFile(void)
{
    int ofh, rv = COPYFILE_OK;
    ssize_t b=0, off;
    const char *fname = "palette.dat";

    ofh = open(fname, O_WRONLY|O_BINARY|O_CREAT|O_EXCL, BS_IREAD|BS_IWRITE);
    if (ofh < 0) {
        if (errno == EEXIST) return COPYFILE_ERR_EXISTS;
        return COPYFILE_ERR_OPEN;
    }
    for (off = 0; off < default_palette_size && rv == COPYFILE_OK; off += b) {
        b = min(16384, default_palette_size - off);
        if ((b = write(ofh, &default_palette[off], b)) < 0) {
            rv = COPYFILE_ERR_RW;
        }
    }
    close(ofh);
    if (rv != COPYFILE_OK) remove(fname);
    return rv;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
leaq 0x965bd(%rip), %rax     # 0xdacab
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl $0xc1, %esi
movl $0x180, %edx            # imm = 0x180
movb $0x0, %al
callq 0x8600
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x44732
callq 0x8dd0
cmpl $0x11, (%rax)
jne 0x44726
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x447fa
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x447fa
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rcx
leaq 0xa887f(%rip), %rax     # 0xecfc4
movslq (%rax), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x29(%rbp)
jge 0x4475c
cmpl $0x0, -0xc(%rbp)
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x44765
jmp 0x447dd
leaq 0xa8858(%rip), %rax     # 0xecfc4
movslq (%rax), %rcx
subq -0x20(%rbp), %rcx
movl $0x4000, %eax           # imm = 0x4000
cmpq %rcx, %rax
jge 0x44788
movl $0x4000, %eax           # imm = 0x4000
movq %rax, -0x38(%rbp)
jmp 0x4479a
leaq 0xa8835(%rip), %rax     # 0xecfc4
movslq (%rax), %rax
subq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x8(%rbp), %edi
leaq 0x96514(%rip), %rsi     # 0xdacc0
addq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x8e40
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jge 0x447ca
movl $0xfffffffd, -0xc(%rbp) # imm = 0xFFFFFFFD
jmp 0x447cc
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x4473a
movl -0x8(%rbp), %edi
callq 0x8300
cmpl $0x0, -0xc(%rbp)
je 0x447f4
movq -0x28(%rbp), %rdi
callq 0x8290
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/datascan.c
// Function: ImportDataFromFile
static int ImportDataFromFile(const char *path, int size, struct importdatameta *cbs)
{
    char *fn;
    int fh, rv;

    fn = strrchr(path, '/');
#ifdef _WIN32
    fn = max(fn, strrchr(path, '\\'));
#endif
    if (!fn) fn = strdup(path);
    else fn = strdup(fn+1);
    strlwr(fn);

    fh = open(path, O_RDONLY|O_BINARY, S_IREAD);
    if (fh < 0) return IMPORTDATA_OK;  // Maybe no permission. Whatever.

    switch (CopyFile(fh, size, fn, cbs)) {
        case COPYFILE_ERR_CANCELLED:
            rv = IMPORTDATA_OK;
            break;
        case COPYFILE_ERR_EXISTS:
            rv = IMPORTDATA_SKIPPED;
            break;
        case COPYFILE_OK: // Copied.
            rv = IMPORTDATA_COPIED;
            break;
        default:
            rv = IMPORTDATA_ERROR;
            break;
    }
    close(fh);
    free(fn);
    return rv;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2f, %esi
callq 0x8d00
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x4484b
movq -0x10(%rbp), %rdi
callq 0x8070
movq %rax, -0x28(%rbp)
jmp 0x4485c
movq -0x28(%rbp), %rdi
addq $0x1, %rdi
callq 0x8070
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x4fb80
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
movb $0x0, %al
callq 0x8600
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0x44889
movl $0x0, -0x4(%rbp)
jmp 0x448f4
movl -0x2c(%rbp), %edi
movl -0x14(%rbp), %esi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x44900
movl %eax, %ecx
movl %ecx, -0x34(%rbp)
subl $-0x4, %eax
je 0x448bb
jmp 0x448a8
movl -0x34(%rbp), %eax
subl $-0x1, %eax
je 0x448c4
jmp 0x448b2
movl -0x34(%rbp), %eax
testl %eax, %eax
je 0x448cd
jmp 0x448d6
movl $0x0, -0x30(%rbp)
jmp 0x448dd
movl $0x1, -0x30(%rbp)
jmp 0x448dd
movl $0x2, -0x30(%rbp)
jmp 0x448dd
movl $0xffffffff, -0x30(%rbp) # imm = 0xFFFFFFFF
movl -0x2c(%rbp), %edi
callq 0x8300
movq -0x28(%rbp), %rdi
callq 0x8260
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/datascan.c
// Function: CopyFile
static int CopyFile(int fh, int size, const char *fname, struct importdatameta *cbs)
{
    int ofh, rv = COPYFILE_OK;
    ssize_t b=0;
    char buf[16384];

    ofh = open(fname, O_WRONLY|O_BINARY|O_CREAT|O_EXCL, BS_IREAD|BS_IWRITE);
    if (ofh < 0) {
        if (errno == EEXIST) return COPYFILE_ERR_EXISTS;
        return COPYFILE_ERR_OPEN;
    }
    lseek(fh, 0, SEEK_SET);
    do {
        if (cbs->cancelled(cbs->data)) {
            rv = COPYFILE_ERR_CANCELLED;
        } else if ((b = read(fh, buf, sizeof(buf))) < 0) {
            rv = COPYFILE_ERR_RW;
        } else if (b > 0 && write(ofh, buf, b) != b) {
            rv = COPYFILE_ERR_RW;
        }
    } while (b == sizeof(buf) && rv == COPYFILE_OK);
    close(ofh);
    if (size != lseek(fh, 0, SEEK_CUR)) rv = COPYFILE_ERR_RW;  // File not the expected length.
    if (rv != COPYFILE_OK) remove(fname);
    return rv;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4040, %rsp           # imm = 0x4040
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movl $0xc1, %esi
movl $0x180, %edx            # imm = 0x180
movb $0x0, %al
callq 0x8600
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x44968
callq 0x8dd0
cmpl $0x11, (%rax)
jne 0x4495c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x44a65
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x44a65
movl -0x8(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x8390
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
cmpl $0x0, %eax
je 0x44995
movl $0xfffffffc, -0x28(%rbp) # imm = 0xFFFFFFFC
jmp 0x449e7
movl -0x8(%rbp), %edi
leaq -0x4030(%rbp), %rsi
movl $0x4000, %edx           # imm = 0x4000
callq 0x8a70
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jge 0x449bc
movl $0xfffffffd, -0x28(%rbp) # imm = 0xFFFFFFFD
jmp 0x449e5
cmpq $0x0, -0x30(%rbp)
jle 0x449e3
movl -0x24(%rbp), %edi
leaq -0x4030(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x8e40
cmpq -0x30(%rbp), %rax
je 0x449e3
movl $0xfffffffd, -0x28(%rbp) # imm = 0xFFFFFFFD
jmp 0x449e5
jmp 0x449e7
jmp 0x449e9
xorl %eax, %eax
cmpq $0x4000, -0x30(%rbp)    # imm = 0x4000
movb %al, -0x4031(%rbp)
jne 0x44a08
cmpl $0x0, -0x28(%rbp)
sete %al
movb %al, -0x4031(%rbp)
movb -0x4031(%rbp), %al
testb $0x1, %al
jne 0x44976
movl -0x24(%rbp), %edi
callq 0x8300
movslq -0xc(%rbp), %rax
movq %rax, -0x4040(%rbp)
movl -0x8(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x8390
movq %rax, %rcx
movq -0x4040(%rbp), %rax
cmpq %rcx, %rax
je 0x44a50
movl $0xfffffffd, -0x28(%rbp) # imm = 0xFFFFFFFD
cmpl $0x0, -0x28(%rbp)
je 0x44a5f
movq -0x18(%rbp), %rdi
callq 0x8290
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x4040, %rsp           # imm = 0x4040
popq %rbp
retq
nopl (%rax)
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/libsmacker/smacker.c
// Function: smk_open_memory
smk smk_open_memory(const unsigned char * buffer, const unsigned long size)
{
	smk s = NULL;
	union smk_read_t fp;

	if (buffer == NULL) {
		fputs("libsmacker::smk_open_memory() - ERROR: buffer pointer is NULL\n", stderr);
		return NULL;
	}

	/* set up the read union for Memory mode */
	fp.ram = (unsigned char *)buffer;

	if (!(s = smk_open_generic(0, fp, size, SMK_MODE_MEMORY)))
		fprintf(stderr, "libsmacker::smk_open_memory(buffer,%lu) - ERROR: Fatal error in smk_open_generic, returning NULL.\n", size);

	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x44abf
movq 0xd4532(%rip), %rax     # 0x118fd8
movq (%rax), %rsi
leaq 0xa8600(%rip), %rdi     # 0xed0b0
callq 0x8430
movq $0x0, -0x8(%rbp)
jmp 0x44b09
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rsi
xorl %edi, %edi
movl $0x1, %ecx
callq 0x44b20
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x44b01
movq 0xd44ec(%rip), %rax     # 0x118fd8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0xa85f5(%rip), %rsi     # 0xed0ef
movb $0x0, %al
callq 0x8280
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/libsmacker/smacker.c
// Function: smk_open_filepointer
smk smk_open_filepointer(FILE * file, const unsigned char mode)
{
	smk s = NULL;
	union smk_read_t fp;

	if (file == NULL) {
		fputs("libsmacker::smk_open_filepointer() - ERROR: file pointer is NULL\n", stderr);
		return NULL;
	}

	/* Copy file ptr to internal union */
	fp.file = file;

	if (!(s = smk_open_generic(1, fp, 0, mode))) {
		fprintf(stderr, "libsmacker::smk_open_filepointer(file,%u) - ERROR: Fatal error in smk_open_generic, returning NULL.\n", mode);
		fclose(fp.file);
		goto error;
	}

	if (mode == SMK_MODE_MEMORY)
		fclose(fp.file);
	else
		s->source.file.fp = fp.file;

	/* fall through, return s or null */
error:
	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x46291
movq 0xd2d60(%rip), %rax     # 0x118fd8
movq (%rax), %rsi
leaq 0xa6ed0(%rip), %rdi     # 0xed152
callq 0x8430
movq $0x0, -0x8(%rbp)
jmp 0x4630c
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movb -0x11(%rbp), %al
movq -0x28(%rbp), %rsi
movl $0x1, %edi
xorl %ecx, %ecx
movl %ecx, %edx
movzbl %al, %ecx
callq 0x44b20
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x462e2
movq 0xd2d16(%rip), %rax     # 0x118fd8
movq (%rax), %rdi
movzbl -0x11(%rbp), %edx
leaq 0xa6ec4(%rip), %rsi     # 0xed194
movb $0x0, %al
callq 0x8280
movq -0x28(%rbp), %rdi
callq 0x85d0
jmp 0x46304
movzbl -0x11(%rbp), %eax
cmpl $0x1, %eax
jne 0x462f6
movq -0x28(%rbp), %rdi
callq 0x85d0
jmp 0x46302
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0x46304
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/libsmacker/smacker.c
// Function: smk_open_file
smk smk_open_file(const char * filename, const unsigned char mode)
{
	FILE * fp;

	if (filename == NULL) {
		fputs("libsmacker::smk_open_file() - ERROR: filename is NULL\n", stderr);
		return NULL;
	}

	if (!(fp = fopen(filename, "rb"))) {
		fprintf(stderr, "libsmacker::smk_open_file(%s,%u) - ERROR: could not open file\n", filename, mode);
		perror("\tError reported was");
		goto error;
	}

	/* kick processing to smk_open_filepointer */
	return smk_open_filepointer(fp, mode);
	/* fall through, return s or null */
error:
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x46359
movq 0xd2c98(%rip), %rax     # 0x118fd8
movq (%rax), %rsi
leaq 0xa6eaf(%rip), %rdi     # 0xed1f9
callq 0x8430
movq $0x0, -0x8(%rbp)
jmp 0x463bc
movq -0x10(%rbp), %rdi
leaq 0xa6ecc(%rip), %rsi     # 0xed230
callq 0x9100
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x463a1
movq 0xd2c5e(%rip), %rax     # 0x118fd8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
movzbl -0x11(%rbp), %ecx
leaq 0xa6ea7(%rip), %rsi     # 0xed233
movb $0x0, %al
callq 0x8280
leaq 0xa6ed8(%rip), %rdi     # 0xed272
callq 0x83d0
jmp 0x463b4
movq -0x20(%rbp), %rdi
movzbl -0x11(%rbp), %esi
callq 0x46250
movq %rax, -0x8(%rbp)
jmp 0x463bc
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/libsmacker/smacker.c
// Function: smk_info_all
char smk_info_all(const smk object, unsigned long * frame, unsigned long * frame_count, double * usf)
{
	/* null check */
	if (object == NULL) {
		fputs("libsmacker::smk_info_all() - ERROR: smk is NULL\n", stderr);
		return -1;
	}

	if (!frame && !frame_count && !usf) {
		fputs("libsmacker::smk_info_all(object,frame,frame_count,usf) - ERROR: Request for info with all-NULL return references\n", stderr);
		goto error;
	}

	if (frame)
		*frame = (object->cur_frame % object->f);

	if (frame_count)
		*frame_count = object->f;

	if (usf)
		*usf = object->usf;

	return 0;
error:
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x467fe
movq 0xd27f2(%rip), %rax     # 0x118fd8
movq (%rax), %rsi
leaq 0xa6b80(%rip), %rdi     # 0xed370
callq 0x8430
movb $-0x1, -0x1(%rbp)
jmp 0x46883
cmpq $0x0, -0x18(%rbp)
jne 0x4682b
cmpq $0x0, -0x20(%rbp)
jne 0x4682b
cmpq $0x0, -0x28(%rbp)
jne 0x4682b
movq 0xd27be(%rip), %rax     # 0x118fd8
movq (%rax), %rsi
leaq 0xa6b7d(%rip), %rdi     # 0xed3a1
callq 0x8430
jmp 0x4687f
cmpq $0x0, -0x18(%rbp)
je 0x4684b
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
xorl %edx, %edx
divq 0x10(%rcx)
movq -0x18(%rbp), %rax
movq %rdx, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x46861
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x46879
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
movb $0x0, -0x1(%rbp)
jmp 0x46883
movb $-0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/libsmacker/smacker.c
// Function: smk_info_video
char smk_info_video(const smk object, unsigned long * w, unsigned long * h, unsigned char * y_scale_mode)
{
	/* null check */
	if (object == NULL) {
		fputs("libsmacker::smk_info_video() - ERROR: smk is NULL\n", stderr);
		return -1;
	}

	if (!w && !h && !y_scale_mode) {
		fputs("libsmacker::smk_info_all(object,w,h,y_scale_mode) - ERROR: Request for info with all-NULL return references\n", stderr);
		return -1;
	}

	if (w)
		*w = object->video.w;

	if (h)
		*h = object->video.h;

	if (y_scale_mode)
		*y_scale_mode = object->video.y_scale_mode;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x468cb
movq 0xd2722(%rip), %rax     # 0x118fd8
movq (%rax), %rsi
leaq 0xa6b53(%rip), %rdi     # 0xed413
callq 0x8430
movb $-0x1, -0x1(%rbp)
jmp 0x46940
cmpq $0x0, -0x18(%rbp)
jne 0x468fc
cmpq $0x0, -0x20(%rbp)
jne 0x468fc
cmpq $0x0, -0x28(%rbp)
jne 0x468fc
movq 0xd26f1(%rip), %rax     # 0x118fd8
movq (%rax), %rsi
leaq 0xa6b55(%rip), %rdi     # 0xed446
callq 0x8430
movb $-0x1, -0x1(%rbp)
jmp 0x46940
cmpq $0x0, -0x18(%rbp)
je 0x46912
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x46928
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x4693c
movq -0x10(%rbp), %rax
movb 0x68(%rax), %cl
movq -0x28(%rbp), %rax
movb %cl, (%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/libsmacker/smacker.c
// Function: smk_enable_all
char smk_enable_all(smk object, const unsigned char mask)
{
	unsigned char i;

	/* null check */
	if (object == NULL) {
		fputs("libsmacker::smk_enable_all() - ERROR: smk is NULL\n", stderr);
		return -1;
	}

	/* set video-enable */
	object->video.enable = (mask & 0x80);

	for (i = 0; i < 7; i ++) {
		if (object->audio[i].exists)
			object->audio[i].enable = (mask & (1 << i));
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x46b55
movq 0xd2498(%rip), %rax     # 0x118fd8
movq (%rax), %rsi
leaq 0xa6a22(%rip), %rdi     # 0xed56c
callq 0x8430
movb $-0x1, -0x1(%rbp)
jmp 0x46bcb
movzbl -0x11(%rbp), %eax
andl $0x80, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x50(%rax)
movb $0x0, -0x12(%rbp)
movzbl -0x12(%rbp), %eax
cmpl $0x7, %eax
jge 0x46bc7
movq -0x10(%rbp), %rax
addq $0x3f8, %rax            # imm = 0x3F8
movzbl -0x12(%rbp), %ecx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
cmpb $0x0, (%rax)
je 0x46bbb
movzbl -0x11(%rbp), %eax
movzbl -0x12(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
addq $0x3f8, %rax            # imm = 0x3F8
movzbl -0x12(%rbp), %edx
imulq $0x30, %rdx, %rdx
addq %rdx, %rax
movb %cl, 0x1(%rax)
jmp 0x46bbd
movb -0x12(%rbp), %al
addb $0x1, %al
movb %al, -0x12(%rbp)
jmp 0x46b6b
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/libsmacker/smacker.c
// Function: smk_enable_video
char smk_enable_video(smk object, const unsigned char enable)
{
	/* null check */
	if (object == NULL) {
		fputs("libsmacker::smk_enable_video() - ERROR: smk is NULL\n", stderr);
		return -1;
	}

	object->video.enable = enable;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x46c15
movq 0xd23d8(%rip), %rax     # 0x118fd8
movq (%rax), %rsi
leaq 0xa6995(%rip), %rdi     # 0xed59f
callq 0x8430
movb $-0x1, -0x1(%rbp)
jmp 0x46c23
movb -0x11(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x50(%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/libsmacker/smacker.c
// Function: smk_enable_audio
char smk_enable_audio(smk object, const unsigned char track, const unsigned char enable)
{
	/* null check */
	if (object == NULL) {
		fputs("libsmacker::smk_enable_audio() - ERROR: smk is NULL\n", stderr);
		return -1;
	}

	object->audio[track].enable = enable;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x10(%rbp)
movb %cl, -0x11(%rbp)
movb %al, -0x12(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x46c6a
movq 0xd2383(%rip), %rax     # 0x118fd8
movq (%rax), %rsi
leaq 0xa6975(%rip), %rdi     # 0xed5d4
callq 0x8430
movb $-0x1, -0x1(%rbp)
jmp 0x46c89
movb -0x12(%rbp), %cl
movq -0x10(%rbp), %rax
addq $0x3f8, %rax            # imm = 0x3F8
movzbl -0x11(%rbp), %edx
imulq $0x30, %rdx, %rdx
addq %rdx, %rax
movb %cl, 0x1(%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/libsmacker/smacker.c
// Function: smk_get_palette
const unsigned char * smk_get_palette(const smk object)
{
	/* null check */
	if (object == NULL) {
		fputs("libsmacker::smk_get_palette() - ERROR: smk is NULL\n", stderr);
		return NULL;
	}

	return (unsigned char *)object->video.palette;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x46cd3
movq 0xd231e(%rip), %rax     # 0x118fd8
movq (%rax), %rsi
leaq 0xa6945(%rip), %rdi     # 0xed609
callq 0x8430
movq $0x0, -0x8(%rbp)
jmp 0x46ce5
movq -0x10(%rbp), %rax
addq $0x50, %rax
addq $0xa0, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/libsmacker/smacker.c
// Function: smk_get_video
const unsigned char * smk_get_video(const smk object)
{
	/* null check */
	if (object == NULL) {
		fputs("libsmacker::smk_get_video() - ERROR: smk is NULL\n", stderr);
		return NULL;
	}

	return object->video.frame;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x46d23
movq 0xd22ce(%rip), %rax     # 0x118fd8
movq (%rax), %rsi
leaq 0xa6929(%rip), %rdi     # 0xed63d
callq 0x8430
movq $0x0, -0x8(%rbp)
jmp 0x46d32
movq -0x10(%rbp), %rax
movq 0x3f0(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/libsmacker/smacker.c
// Function: smk_get_audio
const unsigned char * smk_get_audio(const smk object, const unsigned char t)
{
	/* null check */
	if (object == NULL) {
		fputs("libsmacker::smk_get_audio() - ERROR: smk is NULL\n", stderr);
		return NULL;
	}

	return object->audio[t].buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x46d79
movq 0xd2278(%rip), %rax     # 0x118fd8
movq (%rax), %rsi
leaq 0xa6905(%rip), %rdi     # 0xed66f
callq 0x8430
movq $0x0, -0x8(%rbp)
jmp 0x46d96
movq -0x10(%rbp), %rax
addq $0x3f8, %rax            # imm = 0x3F8
movzbl -0x11(%rbp), %ecx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/libsmacker/smacker.c
// Function: smk_get_audio_size
unsigned long smk_get_audio_size(const smk object, const unsigned char t)
{
	/* null check */
	if (object == NULL) {
		fputs("libsmacker::smk_get_audio_size() - ERROR: smk is NULL\n", stderr);
		return 0;
	}

	return object->audio[t].buffer_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x46dd9
movq 0xd2218(%rip), %rax     # 0x118fd8
movq (%rax), %rsi
leaq 0xa68d7(%rip), %rdi     # 0xed6a1
callq 0x8430
movq $0x0, -0x8(%rbp)
jmp 0x46df6
movq -0x10(%rbp), %rax
addq $0x3f8, %rax            # imm = 0x3F8
movzbl -0x11(%rbp), %ecx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq 0x28(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/libsmacker/smacker.c
// Function: smk_first
char smk_first(smk s)
{
	/* null check */
	if (s == NULL) {
		fputs("libsmacker::smk_first() - ERROR: smk is NULL\n", stderr);
		return -1;
	}

	s->cur_frame = 0;

	if (smk_render(s) < 0) {
		fprintf(stderr, "libsmacker::smk_first(s) - Warning: frame %lu: smk_render returned errors.\n", s->cur_frame);
		return -1;
	}

	if (s->f == 1) return SMK_LAST;

	return SMK_MORE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x46e2f
movq 0xd21be(%rip), %rax     # 0x118fd8
movq (%rax), %rsi
leaq 0xa68b4(%rip), %rdi     # 0xed6d8
callq 0x8430
movb $-0x1, -0x1(%rbp)
jmp 0x46e87
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rdi
callq 0x46e90
movsbl %al, %eax
cmpl $0x0, %eax
jge 0x46e72
movq 0xd2185(%rip), %rax     # 0x118fd8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdx
leaq 0xa68a1(%rip), %rsi     # 0xed706
movb $0x0, %al
callq 0x8280
movb $-0x1, -0x1(%rbp)
jmp 0x46e87
movq -0x10(%rbp), %rax
cmpq $0x1, 0x10(%rax)
jne 0x46e83
movb $0x2, -0x1(%rbp)
jmp 0x46e87
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/libsmacker/smacker.c
// Function: smk_next
char smk_next(smk s)
{
	/* null check */
	if (s == NULL) {
		fputs("libsmacker::smk_next() - ERROR: smk is NULL\n", stderr);
		return -1;
	}

	if (s->cur_frame + 1 < (s->f + s->ring_frame)) {
		s->cur_frame ++;

		if (smk_render(s) < 0) {
			fprintf(stderr, "libsmacker::smk_next(s) - Warning: frame %lu: smk_render returned errors.\n", s->cur_frame);
			return -1;
		}

		if (s->cur_frame + 1 == (s->f + s->ring_frame))
			return SMK_LAST;

		return SMK_MORE;
	} else if (s->ring_frame) {
		s->cur_frame = 1;

		if (smk_render(s) < 0) {
			fprintf(stderr, "libsmacker::smk_next(s) - Warning: frame %lu: smk_render returned errors.\n", s->cur_frame);
			return -1;
		}

		if (s->cur_frame + 1 == (s->f + s->ring_frame))
			return SMK_LAST;

		return SMK_MORE;
	}

	return SMK_DONE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x47362
movq 0xd1c8e(%rip), %rax     # 0x118fd8
movq (%rax), %rsi
leaq 0xa63fe(%rip), %rdi     # 0xed752
callq 0x8430
movb $-0x1, -0x1(%rbp)
jmp 0x4748d
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
addq $0x1, %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq -0x10(%rbp), %rdx
movzbl 0x18(%rdx), %edx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x4740a
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rdi
callq 0x46e90
movsbl %al, %eax
cmpl $0x0, %eax
jge 0x473d4
movq 0xd1c26(%rip), %rax     # 0x118fd8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdx
leaq 0xa63bb(%rip), %rsi     # 0xed77f
movb $0x0, %al
callq 0x8280
movb $-0x1, -0x1(%rbp)
jmp 0x4748d
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
addq $0x1, %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq -0x10(%rbp), %rdx
movzbl 0x18(%rdx), %edx
addq %rdx, %rcx
cmpq %rcx, %rax
jne 0x47401
movb $0x2, -0x1(%rbp)
jmp 0x4748d
movb $0x1, -0x1(%rbp)
jmp 0x4748d
movq -0x10(%rbp), %rax
cmpb $0x0, 0x18(%rax)
je 0x47487
movq -0x10(%rbp), %rax
movq $0x1, 0x20(%rax)
movq -0x10(%rbp), %rdi
callq 0x46e90
movsbl %al, %eax
cmpl $0x0, %eax
jge 0x47457
movq 0xd1ba0(%rip), %rax     # 0x118fd8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdx
leaq 0xa6335(%rip), %rsi     # 0xed77f
movb $0x0, %al
callq 0x8280
movb $-0x1, -0x1(%rbp)
jmp 0x4748d
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
addq $0x1, %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq -0x10(%rbp), %rdx
movzbl 0x18(%rdx), %edx
addq %rdx, %rcx
cmpq %rcx, %rax
jne 0x47481
movb $0x2, -0x1(%rbp)
jmp 0x4748d
movb $0x1, -0x1(%rbp)
jmp 0x4748d
jmp 0x47489
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/libsmacker/smacker.c
// Function: smk_seek_keyframe
char smk_seek_keyframe(smk s, unsigned long f)
{
	/* null check */
	if (s == NULL) {
		fputs("libsmacker::smk_seek_keyframe() - ERROR: smk is NULL\n", stderr);
		return -1;
	}

	/* rewind (or fast forward!) exactly to f */
	s->cur_frame = f;

	/* roll back to previous keyframe in stream, or 0 if no keyframes exist */
	while (s->cur_frame > 0 && !(s->keyframe[s->cur_frame]))
		s->cur_frame --;

	/* render the frame: we're ready */
	if (smk_render(s) < 0) {
		fprintf(stderr, "libsmacker::smk_seek_keyframe(s,%lu) - Warning: frame %lu: smk_render returned errors.\n", f, s->cur_frame);
		return -1;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x474d6
movq 0xd1b1a(%rip), %rax     # 0x118fd8
movq (%rax), %rsi
leaq 0xa6302(%rip), %rdi     # 0xed7ca
callq 0x8430
movb $-0x1, -0x1(%rbp)
jmp 0x47568
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x20(%rcx)
movb %al, -0x19(%rbp)
jbe 0x4750e
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
cmpb $0x0, (%rax,%rcx)
setne %al
xorb $-0x1, %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x47517
jmp 0x47529
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x20(%rax)
jmp 0x474e2
movq -0x10(%rbp), %rdi
callq 0x46e90
movsbl %al, %eax
cmpl $0x0, %eax
jge 0x47564
movq 0xd1a97(%rip), %rax     # 0x118fd8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
leaq 0xa62a9(%rip), %rsi     # 0xed800
movb $0x0, %al
callq 0x8280
movb $-0x1, -0x1(%rbp)
jmp 0x47568
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/libsmacker/smacker_jftekwar.c
// Function: smk_render_frame
char smk_render_frame(smk s, unsigned long f)
{
    /* null check */
    if (s == NULL) {
        fputs("libsmacker::smk_render_frame() - ERROR: smk is NULL\n", stderr);
        return -1;
    }
    
    /* rewind (or fast forward!) exactly to f */
    s->cur_frame = f;
    
    /* render the frame: we're ready */
    if ( smk_render(s) < 0) {
        fprintf(stderr, "libsmacker::smk_render_frame(s,%lu) - Warning: frame %lu: smk_render returned errors.\n", f, s->cur_frame);
        goto error;
    }
    
    return 0;
    
error:
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x475b3
movq 0xd1a3a(%rip), %rax     # 0x118fd8
movq (%rax), %rsi
leaq 0xa62b0(%rip), %rdi     # 0xed858
callq 0x8430
movb $-0x1, -0x1(%rbp)
jmp 0x47600
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rdi
callq 0x46e90
movsbl %al, %eax
cmpl $0x0, %eax
jge 0x475f6
movq 0xd1a01(%rip), %rax     # 0x118fd8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
leaq 0xa62a0(%rip), %rsi     # 0xed88d
movb $0x0, %al
callq 0x8280
jmp 0x475fc
movb $0x0, -0x1(%rbp)
jmp 0x47600
movb $-0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/libsmacker/smacker.c
// Function: smk_read_file
static char smk_read_file(void * buf, const size_t size, FILE * fp)
{
	/* don't bother checking buf or fp, fread does it for us */
	size_t bytesRead = fread(buf, 1, size, fp);

	if (bytesRead != size) {
		fprintf(stderr, "libsmacker::smk_read_file(buf,%lu,fp) - ERROR: Short read, %lu bytes returned\n", (unsigned long)size, (unsigned long)bytesRead);
		perror("\tReason");
		return -1;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl $0x1, %esi
callq 0x8730
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x4767a
movq 0xd1989(%rip), %rax     # 0x118fd8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq 0xa6af8(%rip), %rsi     # 0xee159
movb $0x0, %al
callq 0x8280
leaq 0xa6b39(%rip), %rdi     # 0xee1a8
callq 0x83d0
movb $-0x1, -0x1(%rbp)
jmp 0x4767e
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/libsmacker/smacker.c
// Function: smk_read_memory
static char smk_read_memory(void * buf, const unsigned long size, unsigned char ** p, unsigned long * p_size)
{
	if (size > *p_size) {
		fprintf(stderr, "libsmacker::smk_read_memory(buf,%lu,p,%lu) - ERROR: Short read\n", (unsigned long)size, (unsigned long)*p_size);
		return -1;
	}

	memcpy(buf, *p, size);
	*p += size;
	*p_size -= size;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq (%rcx), %rax
jbe 0x476de
movq 0xd191c(%rip), %rax     # 0x118fd8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rax
movq (%rax), %rcx
leaq 0xa6adf(%rip), %rsi     # 0xee1b0
movb $0x0, %al
callq 0x8280
movb $-0x1, -0x1(%rbp)
jmp 0x47715
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x80e0
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rax
movq (%rax), %rcx
subq %rdx, %rcx
movq %rcx, (%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/libsmacker/smacker.c
// Function: smk_bs_init
static void smk_bs_init(struct smk_bit_t * const bs, const unsigned char * const b, const size_t size)
{
	/* null check */
	assert(bs);
	assert(b);
	/* set up the pointer to bitstream start and end, and set the bit pointer to 0 */
	bs->buffer = b;
	bs->end = b + size;
	bs->bit_num = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4773d
jmp 0x4775c
leaq 0xa7d96(%rip), %rdi     # 0xef4da
leaq 0xa5b78(%rip), %rsi     # 0xed2c3
movl $0x25, %edx
leaq 0xa6a99(%rip), %rcx     # 0xee1f0
callq 0x8230
cmpq $0x0, -0x10(%rbp)
je 0x47765
jmp 0x47784
leaq 0xadf36(%rip), %rdi     # 0xf56a2
leaq 0xa5b50(%rip), %rsi     # 0xed2c3
movl $0x26, %edx
leaq 0xa6a71(%rip), %rcx     # 0xee1f0
callq 0x8230
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
addq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq