LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekstat.c
// Function: clearXTpics
void
clearXTpics(short spriteno)
{
     short     extno=sprptr[spriteno]->extra;

    #ifdef PLRSPRDEBUG
     if( isaplayersprite(spriteno) ) {
          crashgame("messing w plrsprite at 2");
     }
    #endif

     if( extno != -1 ) {
          sprXTptr[extno]->basepic=sprptr[spriteno]->picnum;
          sprXTptr[extno]->standpic=NO_PIC;
          sprXTptr[extno]->walkpic=NO_PIC;
          sprXTptr[extno]->runpic=NO_PIC;
          sprXTptr[extno]->attackpic=NO_PIC;
          sprXTptr[extno]->deathpic=NO_PIC;
          sprXTptr[extno]->painpic=NO_PIC;
          sprXTptr[extno]->squatpic=NO_PIC;
          sprXTptr[extno]->morphpic=NO_PIC;
          sprXTptr[extno]->specialpic=NO_PIC;
     }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movswq -0x2(%rbp), %rcx
leaq 0x14f275(%rip), %rax    # 0x17a1e0
movq (%rax,%rcx,8), %rax
movw 0x2a(%rax), %ax
movw %ax, -0x4(%rbp)
movswl -0x2(%rbp), %edi
callq 0x2aec0
cmpl $0x0, %eax
je 0x2af93
leaq 0xaf2af(%rip), %rdi     # 0xda23b
movb $0x0, %al
callq 0x44240
movswl -0x4(%rbp), %eax
cmpl $-0x1, %eax
je 0x2b08e
movswq -0x2(%rbp), %rcx
leaq 0x14f234(%rip), %rax    # 0x17a1e0
movq (%rax,%rcx,8), %rax
movw 0xe(%rax), %cx
movswq -0x4(%rbp), %rdx
leaq 0x1f7220(%rip), %rax    # 0x2221e0
movq (%rax,%rdx,8), %rax
movw %cx, 0xa(%rax)
movswq -0x4(%rbp), %rcx
leaq 0x1f720c(%rip), %rax    # 0x2221e0
movq (%rax,%rcx,8), %rax
movw $0x0, 0xc(%rax)
movswq -0x4(%rbp), %rcx
leaq 0x1f71f6(%rip), %rax    # 0x2221e0
movq (%rax,%rcx,8), %rax
movw $0x0, 0xe(%rax)
movswq -0x4(%rbp), %rcx
leaq 0x1f71e0(%rip), %rax    # 0x2221e0
movq (%rax,%rcx,8), %rax
movw $0x0, 0x10(%rax)
movswq -0x4(%rbp), %rcx
leaq 0x1f71ca(%rip), %rax    # 0x2221e0
movq (%rax,%rcx,8), %rax
movw $0x0, 0x12(%rax)
movswq -0x4(%rbp), %rcx
leaq 0x1f71b4(%rip), %rax    # 0x2221e0
movq (%rax,%rcx,8), %rax
movw $0x0, 0x14(%rax)
movswq -0x4(%rbp), %rcx
leaq 0x1f719e(%rip), %rax    # 0x2221e0
movq (%rax,%rcx,8), %rax
movw $0x0, 0x16(%rax)
movswq -0x4(%rbp), %rcx
leaq 0x1f7188(%rip), %rax    # 0x2221e0
movq (%rax,%rcx,8), %rax
movw $0x0, 0x18(%rax)
movswq -0x4(%rbp), %rcx
leaq 0x1f7172(%rip), %rax    # 0x2221e0
movq (%rax,%rcx,8), %rax
movw $0x0, 0x1a(%rax)
movswq -0x4(%rbp), %rcx
leaq 0x1f715c(%rip), %rax    # 0x2221e0
movq (%rax,%rcx,8), %rax
movw $0x0, 0x1c(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekstat.c
// Function: mapXT
int
mapXT(int sn)
{
     short    i;

    #ifdef PLRSPRDEBUG
     if( isaplayersprite(sn) ) {
          crashgame("messing w plrsprite at 0");
     }
    #endif

     for ( i=0; i<MAXSPRITES; i++ ) {
          if( sprXTptr[i]->lock == 0x00 ) {
               sprptr[sn]->extra=i;
               memset(sprXTptr[i], 0, sizeof(struct spriteextension));
               sprXTptr[i]->lock=0xFF;
               return(i);
          }
     }

     sprptr[sn]->extra=-1;
     return(-1);   // no free spot found
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %edi
callq 0x2aec0
cmpl $0x0, %eax
je 0x2b0c6
leaq 0xaf195(%rip), %rdi     # 0xda254
movb $0x0, %al
callq 0x44240
movw $0x0, -0xa(%rbp)
movswl -0xa(%rbp), %eax
cmpl $0x4000, %eax           # imm = 0x4000
jge 0x2b153
movswq -0xa(%rbp), %rcx
leaq 0x1f70fd(%rip), %rax    # 0x2221e0
movq (%rax,%rcx,8), %rax
movzbl 0x1e(%rax), %eax
cmpl $0x0, %eax
jne 0x2b140
movw -0xa(%rbp), %cx
movslq -0x8(%rbp), %rdx
leaq 0x14f0e1(%rip), %rax    # 0x17a1e0
movq (%rax,%rdx,8), %rax
movw %cx, 0x2a(%rax)
movswq -0xa(%rbp), %rcx
leaq 0x1f70cd(%rip), %rax    # 0x2221e0
movq (%rax,%rcx,8), %rdi
xorl %esi, %esi
movl $0x22, %edx
callq 0x8410
movswq -0xa(%rbp), %rcx
leaq 0x1f70b1(%rip), %rax    # 0x2221e0
movq (%rax,%rcx,8), %rax
movb $-0x1, 0x1e(%rax)
movswl -0xa(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2b16f
jmp 0x2b142
movw -0xa(%rbp), %ax
addw $0x1, %ax
movw %ax, -0xa(%rbp)
jmp 0x2b0cc
movslq -0x8(%rbp), %rcx
leaq 0x14f082(%rip), %rax    # 0x17a1e0
movq (%rax,%rcx,8), %rax
movw $0xffff, 0x2a(%rax)     # imm = 0xFFFF
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekstat.c
// Function: verifystatus
void
verifystatus(int i, int stat)
{
     if( i == -1 ) {
          return;
     }
     if( sprptr[i]->statnum != stat ) {
          if( nextspritestat[i] != -1 ) {
               crashgame("verifystatus fail for %d", stat);
          }
          vbad++;
     }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $-0x1, -0x4(%rbp)
jne 0x2b1e6
jmp 0x2b231
movslq -0x4(%rbp), %rcx
leaq 0x14efef(%rip), %rax    # 0x17a1e0
movq (%rax,%rcx,8), %rax
movswl 0x1a(%rax), %eax
cmpl -0x8(%rbp), %eax
je 0x2b231
movslq -0x4(%rbp), %rcx
leaq 0x595957(%rip), %rax    # 0x5c0b60
movswl (%rax,%rcx,2), %eax
cmpl $-0x1, %eax
je 0x2b223
movl -0x8(%rbp), %esi
leaq 0xaf077(%rip), %rdi     # 0xda293
movb $0x0, %al
callq 0x44240
movb 0x2541ac(%rip), %al     # 0x27f3d5
addb $0x1, %al
movb %al, 0x2541a4(%rip)     # 0x27f3d5
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekstat.c
// Function: isvisible
int
isvisible(short i, short target)
{

     if( !validplayer(target) ) {
          crashgame("isvisible: bad targetnum");
     }

	if( sintable[(sprptr[i]->ang+2560)&2047]*(posx[target]-sprptr[i]->x) + sintable[(sprptr[i]->ang+2048)&2047]*(posy[target]-sprptr[i]->y) >= 0) {
	     if( cansee(posx[target],posy[target],(posz[target])>>1,cursectnum[target],
                     sprptr[i]->x,sprptr[i]->y,sprptr[i]->z-(tilesizy[sprptr[i]->picnum]<<7),sprptr[i]->sectnum) == 1) {
          return(1);
          }
     }

     return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movw %di, %cx
movw %cx, -0x6(%rbp)
movw %ax, -0x8(%rbp)
movswl -0x8(%rbp), %edi
callq 0x11c50
cmpl $0x0, %eax
jne 0x2bb42
leaq 0xae77e(%rip), %rdi     # 0xda2b9
movb $0x0, %al
callq 0x44240
movswq -0x6(%rbp), %rcx
leaq 0x14e692(%rip), %rax    # 0x17a1e0
movq (%rax,%rcx,8), %rax
movswl 0x1c(%rax), %eax
addl $0xa00, %eax            # imm = 0xA00
andl $0x7ff, %eax            # imm = 0x7FF
movslq %eax, %rcx
leaq 0x59d016(%rip), %rax    # 0x5c8b80
movswl (%rax,%rcx,2), %eax
movswq -0x8(%rbp), %rdx
leaq 0x101cd6(%rip), %rcx    # 0x12d850
movl (%rcx,%rdx,4), %ecx
movswq -0x6(%rbp), %rsi
leaq 0x14e657(%rip), %rdx    # 0x17a1e0
movq (%rdx,%rsi,8), %rdx
subl (%rdx), %ecx
imull %ecx, %eax
movswq -0x6(%rbp), %rdx
leaq 0x14e642(%rip), %rcx    # 0x17a1e0
movq (%rcx,%rdx,8), %rcx
movswl 0x1c(%rcx), %ecx
addl $0x800, %ecx            # imm = 0x800
andl $0x7ff, %ecx            # imm = 0x7FF
movslq %ecx, %rdx
leaq 0x59cfc4(%rip), %rcx    # 0x5c8b80
movswl (%rcx,%rdx,2), %ecx
movswq -0x8(%rbp), %rsi
leaq 0x101cc4(%rip), %rdx    # 0x12d890
movl (%rdx,%rsi,4), %edx
movswq -0x6(%rbp), %rdi
leaq 0x14e605(%rip), %rsi    # 0x17a1e0
movq (%rsi,%rdi,8), %rsi
subl 0x4(%rsi), %edx
imull %edx, %ecx
addl %ecx, %eax
cmpl $0x0, %eax
jl 0x2bcc5
movswq -0x8(%rbp), %rcx
leaq 0x101c54(%rip), %rax    # 0x12d850
movl (%rax,%rcx,4), %edi
movswq -0x8(%rbp), %rcx
leaq 0x101c85(%rip), %rax    # 0x12d890
movl (%rax,%rcx,4), %esi
movswq -0x8(%rbp), %rcx
leaq 0x101cb6(%rip), %rax    # 0x12d8d0
movl (%rax,%rcx,4), %edx
sarl %edx
movswq -0x8(%rbp), %rcx
leaq 0x102ab5(%rip), %rax    # 0x12e6e0
movw (%rax,%rcx,2), %cx
movswq -0x6(%rbp), %r8
leaq 0x14e5a5(%rip), %rax    # 0x17a1e0
movq (%rax,%r8,8), %rax
movl (%rax), %r8d
movswq -0x6(%rbp), %r9
leaq 0x14e592(%rip), %rax    # 0x17a1e0
movq (%rax,%r9,8), %rax
movl 0x4(%rax), %r9d
movswq -0x6(%rbp), %r10
leaq 0x14e57e(%rip), %rax    # 0x17a1e0
movq (%rax,%r10,8), %rax
movl 0x8(%rax), %r10d
movswq -0x6(%rbp), %r11
leaq 0x14e56a(%rip), %rax    # 0x17a1e0
movq (%rax,%r11,8), %rax
movswq 0xe(%rax), %r11
leaq 0x5cdb8a(%rip), %rax    # 0x5f9810
movswl (%rax,%r11,2), %eax
shll $0x7, %eax
subl %eax, %r10d
movswq -0x6(%rbp), %r11
leaq 0x14e543(%rip), %rax    # 0x17a1e0
movq (%rax,%r11,8), %rax
movswl %cx, %ecx
movl %r10d, (%rsp)
movswl 0x18(%rax), %eax
movl %eax, 0x8(%rsp)
callq 0x6a760
cmpl $0x1, %eax
jne 0x2bcc3
movl $0x1, -0x4(%rbp)
jmp 0x2bccc
jmp 0x2bcc5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekstat.c
// Function: getpicinfo
void
getpicinfo(short picnum)
{
     int      amask=picanm[picnum];

     picinfoptr->numframes=amask&0x0000003F;
     picinfoptr->animtype =( amask&0x000000C0 )>>6;
     picinfoptr->xcenteroffset=( amask&0x0000FF00 )>>8;
     picinfoptr->ycenteroffset=( amask&0x00FF0000 )>>16;
     picinfoptr->animspeed=( amask&0x0F000000 )>>24;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %di, %ax
movw %ax, -0x2(%rbp)
movswq -0x2(%rbp), %rcx
leaq 0x408b99(%rip), %rax    # 0x434890
movl (%rax,%rcx,4), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0x3f, %eax
movb %al, %cl
movq 0xef084(%rip), %rax     # 0x11ad90
movb %cl, (%rax)
movl -0x8(%rbp), %eax
andl $0xc0, %eax
sarl $0x6, %eax
movb %al, %cl
movq 0xef06e(%rip), %rax     # 0x11ad90
movb %cl, 0x1(%rax)
movl -0x8(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
sarl $0x8, %eax
movb %al, %cl
movq 0xef057(%rip), %rax     # 0x11ad90
movb %cl, 0x3(%rax)
movl -0x8(%rbp), %eax
andl $0xff0000, %eax         # imm = 0xFF0000
sarl $0x10, %eax
movb %al, %cl
movq 0xef040(%rip), %rax     # 0x11ad90
movb %cl, 0x2(%rax)
movl -0x8(%rbp), %eax
andl $0xf000000, %eax        # imm = 0xF000000
sarl $0x18, %eax
movb %al, %cl
movq 0xef029(%rip), %rax     # 0x11ad90
movb %cl, 0x4(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekstat.c
// Function: wallangle
short
wallangle(int wn)
{
     int      w1x,w1y, w2x,w2y;
     short     wang;

     w1x=wallptr[wn]->x; w1y=wallptr[wn]->y;
     wn=wallptr[wn]->point2;
     w2x=wallptr[wn]->x; w2y=wallptr[wn]->y;
     wang=getangle(w2x-w1x, w2y-w1y);

 return(wang);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x21e45a(%rip), %rax    # 0x24a1e0
movq (%rax,%rcx,8), %rax
movl (%rax), %eax
movl %eax, -0x8(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x21e446(%rip), %rax    # 0x24a1e0
movq (%rax,%rcx,8), %rax
movl 0x4(%rax), %eax
movl %eax, -0xc(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x21e431(%rip), %rax    # 0x24a1e0
movq (%rax,%rcx,8), %rax
movswl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x21e41b(%rip), %rax    # 0x24a1e0
movq (%rax,%rcx,8), %rax
movl (%rax), %eax
movl %eax, -0x10(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x21e407(%rip), %rax    # 0x24a1e0
movq (%rax,%rcx,8), %rax
movl 0x4(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %edi
subl -0x8(%rbp), %edi
movl -0x14(%rbp), %esi
subl -0xc(%rbp), %esi
callq 0x69950
movw %ax, -0x16(%rbp)
movw -0x16(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekstat.c
// Function: wallnormal
short
wallnormal(int wn)
{
     int      w1x,w1y, w2x,w2y;
     short     wnorm;

     w1x=wallptr[wn]->x; w1y=wallptr[wn]->y;
     wn=wallptr[wn]->point2;
     w2x=wallptr[wn]->x; w2y=wallptr[wn]->y;
     wnorm=getangle(w2x-w1x, w2y-w1y);
     wnorm=(wnorm+512L)&2047;

 return(wnorm);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x21e33a(%rip), %rax    # 0x24a1e0
movq (%rax,%rcx,8), %rax
movl (%rax), %eax
movl %eax, -0x8(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x21e326(%rip), %rax    # 0x24a1e0
movq (%rax,%rcx,8), %rax
movl 0x4(%rax), %eax
movl %eax, -0xc(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x21e311(%rip), %rax    # 0x24a1e0
movq (%rax,%rcx,8), %rax
movswl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x21e2fb(%rip), %rax    # 0x24a1e0
movq (%rax,%rcx,8), %rax
movl (%rax), %eax
movl %eax, -0x10(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x21e2e7(%rip), %rax    # 0x24a1e0
movq (%rax,%rcx,8), %rax
movl 0x4(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %edi
subl -0x8(%rbp), %edi
movl -0x14(%rbp), %esi
subl -0xc(%rbp), %esi
callq 0x69950
movw %ax, -0x16(%rbp)
movswq -0x16(%rbp), %rax
addq $0x200, %rax            # imm = 0x200
andq $0x7ff, %rax            # imm = 0x7FF
movw %ax, -0x16(%rbp)
movw -0x16(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekstat.c
// Function: walldeflect
short
walldeflect(int wn, short angin)
{
     short     wnorm,refract,delta,angout;

     wnorm=wallnormal(wn);

     refract=(angin+1024)&2047;

     delta=wnorm-refract;

     angout = wnorm+delta;

     if ( angout < 0  )
          angout+=2048;

 return(angout);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %si, %ax
movl %edi, -0x4(%rbp)
movw %ax, -0x6(%rbp)
movl -0x4(%rbp), %edi
callq 0x2be90
movw %ax, -0x8(%rbp)
movswl -0x6(%rbp), %eax
addl $0x400, %eax            # imm = 0x400
andl $0x7ff, %eax            # imm = 0x7FF
movw %ax, -0xa(%rbp)
movswl -0x8(%rbp), %eax
movswl -0xa(%rbp), %ecx
subl %ecx, %eax
movw %ax, -0xc(%rbp)
movswl -0x8(%rbp), %eax
movswl -0xc(%rbp), %ecx
addl %ecx, %eax
movw %ax, -0xe(%rbp)
movswl -0xe(%rbp), %eax
cmpl $0x0, %eax
jge 0x2bfa2
movswl -0xe(%rbp), %eax
addl $0x800, %eax            # imm = 0x800
movw %ax, -0xe(%rbp)
movw -0xe(%rbp), %ax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekstat.c
// Function: spritedeflect
short
spritedeflect(int sn, short angin)
{
     short     angout;

     switch ( sprptr[sn]->statnum ) {
     case INANIMATE:
     case INACTIVE:
     case AMBUSH:
          angout=(angin+1024)&2047;
          switch( (int)RMOD2("STAT697 ") ) {
          case 0:
               angout=leftof[angout];
               break;
          case 1:
          default:
               angout=rightof[angout];
               break;
          }
          break;
     default:
          angout=sprptr[sn]->ang;
          break;
     }

 return(angout);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %si, %ax
movl %edi, -0x4(%rbp)
movw %ax, -0x6(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x14e213(%rip), %rax    # 0x17a1e0
movq (%rax,%rcx,8), %rax
movswl 0x1a(%rax), %eax
movl %eax, -0xc(%rbp)
testl %eax, %eax
je 0x2bff4
jmp 0x2bfde
movl -0xc(%rbp), %eax
subl $0x64, %eax
je 0x2bff4
jmp 0x2bfe8
movl -0xc(%rbp), %eax
subl $0xca, %eax
jne 0x2c05c
jmp 0x2bff4
movzwl -0x6(%rbp), %eax
addl $0x400, %eax            # imm = 0x400
andl $0x7ff, %eax            # imm = 0x7FF
movw %ax, -0x8(%rbp)
leaq 0xae2e0(%rip), %rdi     # 0xda2ed
callq 0x41510
subl $0x8001, %eax           # imm = 0x8001
setge %al
movzbl %al, %eax
movl %eax, -0x10(%rbp)
jl 0x2c02e
jmp 0x2c024
movl -0x10(%rbp), %eax
subl $0x1, %eax
je 0x2c044
jmp 0x2c046
movswq -0x8(%rbp), %rcx
leaq 0xeede6(%rip), %rax     # 0x11ae20
movw (%rax,%rcx,2), %ax
movw %ax, -0x8(%rbp)
jmp 0x2c05a
jmp 0x2c046
movswq -0x8(%rbp), %rcx
leaq 0xeedfe(%rip), %rax     # 0x11ae50
movw (%rax,%rcx,2), %ax
movw %ax, -0x8(%rbp)
jmp 0x2c073
movslq -0x4(%rbp), %rcx
leaq 0x14e179(%rip), %rax    # 0x17a1e0
movq (%rax,%rcx,8), %rax
movw 0x1c(%rax), %ax
movw %ax, -0x8(%rbp)
movw -0x8(%rbp), %ax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekstat.c
// Function: tweakdeathdist
void
tweakdeathdist(short i)
{
	int      dax,day;

    #ifdef PLRSPRDEBUG
     if( isaplayersprite(i) ) {
          crashgame("messing w plrsprite at 1");
     }
    #endif

     sprptr[i]->clipdist<<=1;
     dax=( ((sintable[(sprptr[i]->ang+512)&2047])*sprptr[i]->xvel) <<3 );
	day=( ((sintable[sprptr[i]->ang])*sprptr[i]->yvel) <<3 );
	movesprite(( short)i,dax,day,0L,1024,1024,CLIFFCLIP);

     if( sprptr[i]->extra == -1 ) {
          sprptr[i]->lotag=SPR_LOTAG_PICKUP;
     }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movswl -0x2(%rbp), %edi
callq 0x2aec0
cmpl $0x0, %eax
je 0x2c0ab
leaq 0xae252(%rip), %rdi     # 0xda2f6
movb $0x0, %al
callq 0x44240
movswq -0x2(%rbp), %rcx
leaq 0x14e129(%rip), %rax    # 0x17a1e0
movq (%rax,%rcx,8), %rax
movzbl 0x12(%rax), %ecx
shll %ecx
movb %cl, 0x12(%rax)
movswq -0x2(%rbp), %rcx
leaq 0x14e110(%rip), %rax    # 0x17a1e0
movq (%rax,%rcx,8), %rax
movswl 0x1c(%rax), %eax
addl $0x200, %eax            # imm = 0x200
andl $0x7ff, %eax            # imm = 0x7FF
movslq %eax, %rcx
leaq 0x59ca94(%rip), %rax    # 0x5c8b80
movswl (%rax,%rcx,2), %eax
movswq -0x2(%rbp), %rdx
leaq 0x14e0e4(%rip), %rcx    # 0x17a1e0
movq (%rcx,%rdx,8), %rcx
movswl 0x20(%rcx), %ecx
imull %ecx, %eax
shll $0x3, %eax
movl %eax, -0x8(%rbp)
movswq -0x2(%rbp), %rcx
leaq 0x14e0c7(%rip), %rax    # 0x17a1e0
movq (%rax,%rcx,8), %rax
movswq 0x1c(%rax), %rcx
leaq 0x59ca57(%rip), %rax    # 0x5c8b80
movswl (%rax,%rcx,2), %eax
movswq -0x2(%rbp), %rdx
leaq 0x14e0a7(%rip), %rcx    # 0x17a1e0
movq (%rcx,%rdx,8), %rcx
movswl 0x22(%rcx), %ecx
imull %ecx, %eax
shll $0x3, %eax
movl %eax, -0xc(%rbp)
movw -0x2(%rbp), %ax
movl -0x8(%rbp), %esi
movl -0xc(%rbp), %edx
xorl %ecx, %ecx
movl $0x400, %r9d            # imm = 0x400
movswl %ax, %edi
movl %r9d, %r8d
movl $0x2, (%rsp)
callq 0x286d0
movswq -0x2(%rbp), %rcx
leaq 0x14e066(%rip), %rax    # 0x17a1e0
movq (%rax,%rcx,8), %rax
movswl 0x2a(%rax), %eax
cmpl $-0x1, %eax
jne 0x2c19d
movswq -0x2(%rbp), %rcx
leaq 0x14e04d(%rip), %rax    # 0x17a1e0
movq (%rax,%rcx,8), %rax
movw $0x7d4, 0x26(%rax)      # imm = 0x7D4
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekstat.c
// Function: pickupsprite
int
pickupsprite(short sn)
{
    #ifdef PLRSPRDEBUG
     if( isaplayersprite(sn) ) {
          crashgame("messing w plrsprite at 4");
     }
    #endif

     // can only carry one at a time of these items
     if( (pickup.picnum != 0) || (option[4] != 0) ) {
          return(0);
     }

     pickup.picnum=sprptr[sn]->picnum;
     pickup.cstat=sprptr[sn]->cstat;
     pickup.shade=sprptr[sn]->shade;
     pickup.pal=sprptr[sn]->pal;
     pickup.clipdist=sprptr[sn]->clipdist;
     pickup.xrepeat=sprptr[sn]->xrepeat;
     pickup.yrepeat=sprptr[sn]->yrepeat;
	pickup.xoffset=sprptr[sn]->xoffset;
	pickup.yoffset=sprptr[sn]->yoffset;
     // cant set lotag/hitag as TOSS needs to use them
     pickup.extra=sprptr[sn]->extra;

     jsdeletesprite(sn);

     pickupclock=lockclock;
     return(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %di, %ax
movw %ax, -0x6(%rbp)
movswl -0x6(%rbp), %edi
callq 0x2aec0
cmpl $0x0, %eax
je 0x2c44b
leaq 0xadee4(%rip), %rdi     # 0xda328
movb $0x0, %al
callq 0x44240
movswl 0x2dcfcc(%rip), %eax    # 0x30941e
cmpl $0x0, %eax
jne 0x2c467
leaq 0xedaba(%rip), %rax     # 0x119f18
movzbl 0x4(%rax), %eax
cmpl $0x0, %eax
je 0x2c473
movl $0x0, -0x4(%rbp)
jmp 0x2c592
movswq -0x6(%rbp), %rcx
leaq 0x14dd61(%rip), %rax    # 0x17a1e0
movq (%rax,%rcx,8), %rax
movw 0xe(%rax), %ax
movw %ax, 0x2dcf90(%rip)     # 0x30941e
movswq -0x6(%rbp), %rcx
leaq 0x14dd46(%rip), %rax    # 0x17a1e0
movq (%rax,%rcx,8), %rax
movw 0xc(%rax), %ax
movw %ax, 0x2dcf73(%rip)     # 0x30941c
movswq -0x6(%rbp), %rcx
leaq 0x14dd2b(%rip), %rax    # 0x17a1e0
movq (%rax,%rcx,8), %rax
movb 0x10(%rax), %al
movb %al, 0x2dcf5e(%rip)     # 0x309420
movswq -0x6(%rbp), %rcx
leaq 0x14dd12(%rip), %rax    # 0x17a1e0
movq (%rax,%rcx,8), %rax
movb 0x11(%rax), %al
movb %al, 0x2dcf46(%rip)     # 0x309421
movswq -0x6(%rbp), %rcx
leaq 0x14dcf9(%rip), %rax    # 0x17a1e0
movq (%rax,%rcx,8), %rax
movb 0x12(%rax), %al
movb %al, 0x2dcf2e(%rip)     # 0x309422
movswq -0x6(%rbp), %rcx
leaq 0x14dce0(%rip), %rax    # 0x17a1e0
movq (%rax,%rcx,8), %rax
movb 0x14(%rax), %al
movb %al, 0x2dcf17(%rip)     # 0x309424
movswq -0x6(%rbp), %rcx
leaq 0x14dcc7(%rip), %rax    # 0x17a1e0
movq (%rax,%rcx,8), %rax
movb 0x15(%rax), %al
movb %al, 0x2dceff(%rip)     # 0x309425
movswq -0x6(%rbp), %rcx
leaq 0x14dcae(%rip), %rax    # 0x17a1e0
movq (%rax,%rcx,8), %rax
movb 0x16(%rax), %al
movb %al, 0x2dcee7(%rip)     # 0x309426
movswq -0x6(%rbp), %rcx
leaq 0x14dc95(%rip), %rax    # 0x17a1e0
movq (%rax,%rcx,8), %rax
movb 0x17(%rax), %al
movb %al, 0x2dcecf(%rip)     # 0x309427
movswq -0x6(%rbp), %rcx
leaq 0x14dc7c(%rip), %rax    # 0x17a1e0
movq (%rax,%rcx,8), %rax
movw 0x2a(%rax), %ax
movw %ax, 0x2dcec7(%rip)     # 0x30943a
movswl -0x6(%rbp), %edi
callq 0x2ae00
leaq 0x101285(%rip), %rax    # 0x12d808
movl (%rax), %eax
movl %eax, 0x2dcefd(%rip)    # 0x309488
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekstat.c
// Function: ambushyell
void
ambushyell(short sn, short ext)
{
    #ifdef PLRSPRDEBUG
     if( isaplayersprite(sn) ) {
          crashgame("messing w plrsprite at 24");
     }
    #endif

     if( !validext(ext) ) {
          return;
     }
     if( sprXTptr[ext]->aimask&AI_DIDAMBUSHYELL )
          return;

     switch( sprXTptr[ext]->basepic ) {
     case ANTWALKPIC:
     case RUBWALKPIC:
          playsound(S_MALE_COMEONYOU+(krand_intercept("STAT2603")&6),sprptr[sn]->x,sprptr[sn]->y,0,ST_IMMEDIATE);
          sprXTptr[ext]->aimask|=AI_DIDAMBUSHYELL;
          break;
     case DIWALKPIC:
          playsound(S_DIM_WANTSOMETHIS+(krand_intercept("STAT2607")&2),sprptr[sn]->x,sprptr[sn]->y,0,ST_IMMEDIATE);
          sprXTptr[ext]->aimask|=AI_DIDAMBUSHYELL;
          break;
     }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %si, %ax
movw %di, %cx
movw %cx, -0x2(%rbp)
movw %ax, -0x4(%rbp)
movswl -0x2(%rbp), %edi
callq 0x2aec0
cmpl $0x0, %eax
je 0x2e242
leaq 0xac3ee(%rip), %rdi     # 0xda629
movb $0x0, %al
callq 0x44240
movswl -0x4(%rbp), %edi
callq 0x2ae90
cmpl $0x0, %eax
jne 0x2e255
jmp 0x2e383
movswq -0x4(%rbp), %rcx
leaq 0x1f3f7f(%rip), %rax    # 0x2221e0
movq (%rax,%rcx,8), %rax
movzwl 0x6(%rax), %eax
andl $0x200, %eax            # imm = 0x200
cmpl $0x0, %eax
je 0x2e278
jmp 0x2e383
movswq -0x4(%rbp), %rcx
leaq 0x1f3f5c(%rip), %rax    # 0x2221e0
movq (%rax,%rcx,8), %rax
movzwl 0xa(%rax), %eax
movl %eax, -0x8(%rbp)
subl $0x163, %eax            # imm = 0x163
je 0x2e2b3
jmp 0x2e298
movl -0x8(%rbp), %eax
subl $0x6d7, %eax            # imm = 0x6D7
je 0x2e2b3
jmp 0x2e2a4
movl -0x8(%rbp), %eax
subl $0x75f, %eax            # imm = 0x75F
je 0x2e31c
jmp 0x2e383
leaq 0xac389(%rip), %rdi     # 0xda643
callq 0x41510
movl %eax, %edi
andl $0x6, %edi
addl $0x97, %edi
movswq -0x2(%rbp), %rcx
leaq 0x14bf0a(%rip), %rax    # 0x17a1e0
movq (%rax,%rcx,8), %rax
movl (%rax), %esi
movswq -0x2(%rbp), %rcx
leaq 0x14bef8(%rip), %rax    # 0x17a1e0
movq (%rax,%rcx,8), %rax
movl 0x4(%rax), %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x26af0
movswq -0x4(%rbp), %rcx
leaq 0x1f3ed8(%rip), %rax    # 0x2221e0
movq (%rax,%rcx,8), %rax
movzwl 0x6(%rax), %ecx
orl $0x200, %ecx            # imm = 0x200
movw %cx, 0x6(%rax)
jmp 0x2e383
leaq 0xac329(%rip), %rdi     # 0xda64c
callq 0x41510
movl %eax, %edi
andl $0x2, %edi
addl $0xca, %edi
movswq -0x2(%rbp), %rcx
leaq 0x14bea1(%rip), %rax    # 0x17a1e0
movq (%rax,%rcx,8), %rax
movl (%rax), %esi
movswq -0x2(%rbp), %rcx
leaq 0x14be8f(%rip), %rax    # 0x17a1e0
movq (%rax,%rcx,8), %rax
movl 0x4(%rax), %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x26af0
movswq -0x4(%rbp), %rcx
leaq 0x1f3e6f(%rip), %rax    # 0x2221e0
movq (%rax,%rcx,8), %rax
movzwl 0x6(%rax), %ecx
orl $0x200, %ecx            # imm = 0x200
movw %cx, 0x6(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekstat.c
// Function: givewarning
void
givewarning(short i, short ext)
{
     int dist = 0L;

    #ifdef PLRSPRDEBUG
     if( isaplayersprite(i) ) {
          crashgame("messing w plrsprite at 25");
     }
    #endif

     if( option[4] != 0 ) {
          return;
     }
     if( !validext(ext) ) {
          return;
     }
     if( sprXTptr[ext]->aimask&AI_GAVEWARNING )
          return;

     dist=abs(posx[screenpeek]-sprptr[i]->x)+abs(posy[screenpeek]-sprptr[i]->y);
     if( dist > 5000 ) {
          return;
     }

     switch( sprXTptr[ext]->basepic ) {
     case COP1WALKPIC:
          playsound(S_GRD_WHATDOINGHERE+(krand_intercept("STAT2636")&4),sprptr[i]->x,sprptr[i]->y,0,ST_UNIQUE);
          sprXTptr[ext]->aimask|=AI_GAVEWARNING;
          break;
     }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %si, %ax
movw %di, %cx
movw %cx, -0x2(%rbp)
movw %ax, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movswl -0x2(%rbp), %edi
callq 0x2aec0
cmpl $0x0, %eax
je 0x2e3c9
leaq 0xac293(%rip), %rdi     # 0xda655
movb $0x0, %al
callq 0x44240
leaq 0xebb48(%rip), %rax     # 0x119f18
movzbl 0x4(%rax), %eax
cmpl $0x0, %eax
je 0x2e3de
jmp 0x2e502
movswl -0x4(%rbp), %edi
callq 0x2ae90
cmpl $0x0, %eax
jne 0x2e3f1
jmp 0x2e502
movswq -0x4(%rbp), %rcx
leaq 0x1f3de3(%rip), %rax    # 0x2221e0
movq (%rax,%rcx,8), %rax
movzwl 0x6(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x2e412
jmp 0x2e502
leaq 0xff3c5(%rip), %rax     # 0x12d7de
movswq (%rax), %rcx
leaq 0xff42c(%rip), %rax     # 0x12d850
movl (%rax,%rcx,4), %eax
movswq -0x2(%rbp), %rdx
leaq 0x14bdad(%rip), %rcx    # 0x17a1e0
movq (%rcx,%rdx,8), %rcx
subl (%rcx), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
leaq 0xff397(%rip), %rcx     # 0x12d7de
movswq (%rcx), %rdx
leaq 0xff43e(%rip), %rcx     # 0x12d890
movl (%rcx,%rdx,4), %ecx
movswq -0x2(%rbp), %rsi
leaq 0x14bd7f(%rip), %rdx    # 0x17a1e0
movq (%rdx,%rsi,8), %rdx
subl 0x4(%rdx), %ecx
movl %ecx, %edx
negl %edx
cmovnsl %edx, %ecx
addl %ecx, %eax
movl %eax, -0x8(%rbp)
cmpl $0x1388, -0x8(%rbp)     # imm = 0x1388
jle 0x2e482
jmp 0x2e502
movswq -0x4(%rbp), %rcx
leaq 0x1f3d52(%rip), %rax    # 0x2221e0
movq (%rax,%rcx,8), %rax
movw 0xa(%rax), %ax
subw $0x45b, %ax             # imm = 0x45B
jne 0x2e502
jmp 0x2e49e
leaq 0xac1ca(%rip), %rdi     # 0xda66f
callq 0x41510
movl %eax, %edi
andl $0x4, %edi
addl $0xc5, %edi
movswq -0x2(%rbp), %rcx
leaq 0x14bd1f(%rip), %rax    # 0x17a1e0
movq (%rax,%rcx,8), %rax
movl (%rax), %esi
movswq -0x2(%rbp), %rcx
leaq 0x14bd0d(%rip), %rax    # 0x17a1e0
movq (%rax,%rcx,8), %rax
movl 0x4(%rax), %edx
xorl %ecx, %ecx
movl $0x8, %r8d
callq 0x26af0
movswq -0x4(%rbp), %rcx
leaq 0x1f3ced(%rip), %rax    # 0x2221e0
movq (%rax,%rcx,8), %rax
movzwl 0x6(%rax), %ecx
orl $0x40, %ecx
movw %cx, 0x6(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekstat.c
// Function: isanandroid
int
isanandroid(int i)
{
	int	ext=sprptr[i]->extra;

    #ifdef PLRSPRDEBUG
     if( isaplayersprite(i) ) {
          crashgame("messing w plrsprite at 22");
     }
    #endif

     if( validext(ext) ) {
          if( ((sprXTptr[ext]->fxmask)&FX_ANDROID) != 0 ) {
               return(1);
          }
     }

     return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movslq -0x8(%rbp), %rcx
leaq 0x14b54a(%rip), %rax    # 0x17a1e0
movq (%rax,%rcx,8), %rax
movswl 0x2a(%rax), %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %edi
callq 0x2aec0
cmpl $0x0, %eax
je 0x2ecbc
leaq 0xab925(%rip), %rdi     # 0xda5da
movb $0x0, %al
callq 0x44240
movl -0xc(%rbp), %edi
callq 0x2ae90
cmpl $0x0, %eax
je 0x2ecef
movslq -0xc(%rbp), %rcx
leaq 0x1f350c(%rip), %rax    # 0x2221e0
movq (%rax,%rcx,8), %rax
movzwl 0x4(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x2eced
movl $0x1, -0x4(%rbp)
jmp 0x2ecf6
jmp 0x2ecef
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekstat.c
// Function: isahologram
int
isahologram(int i)
{
	int	ext=sprptr[i]->extra;

    #ifdef PLRSPRDEBUG
     if( isaplayersprite(i) ) {
          crashgame("messing w plrsprite at 21");
     }
    #endif

     if( validext(ext) ) {
          if( ((sprXTptr[ext]->fxmask)&FX_HOLOGRAM) != 0 ) {
               return(1);
          }
     }

     return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movslq -0x8(%rbp), %rcx
leaq 0x14b4ca(%rip), %rax    # 0x17a1e0
movq (%rax,%rcx,8), %rax
movswl 0x2a(%rax), %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %edi
callq 0x2aec0
cmpl $0x0, %eax
je 0x2ed3c
leaq 0xab88b(%rip), %rdi     # 0xda5c0
movb $0x0, %al
callq 0x44240
movl -0xc(%rbp), %edi
callq 0x2ae90
cmpl $0x0, %eax
je 0x2ed6f
movslq -0xc(%rbp), %rcx
leaq 0x1f348c(%rip), %rax    # 0x2221e0
movq (%rax,%rcx,8), %rax
movzwl 0x4(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x2ed6d
movl $0x1, -0x4(%rbp)
jmp 0x2ed76
jmp 0x2ed6f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekstat.c
// Function: enemywoundplayer
void
enemywoundplayer(short plrhit, short sprnum, char guntype)
{
     int       damage=0;

    #ifdef PLRSPRDEBUG
     if( isaplayersprite(sprnum) ) {
          crashgame("messing w plrsprite at 15");
     }
    #endif

     if( !validplayer(plrhit) ) {
          return;
     }

     switch( guntype ) {
     case 0:
          damage=64;
          break;
     case 1:
     case 2:
     case 3:
     case 4:
     case 5:
          damage=128;
          break;
     case 6:
     default:
          damage=256;
          break;
     }
     switch( difficulty ) {
     case 0:
     case 1:
          damage>>=4;
          break;
     case 2:
          damage>>=3;
          break;
     case 3:
          damage>>=2;
          break;
     }

     changehealth(plrhit,-damage);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movw %si, %cx
movw %di, %dx
movw %dx, -0x2(%rbp)
movw %cx, -0x4(%rbp)
movb %al, -0x5(%rbp)
movl $0x0, -0xc(%rbp)
movswl -0x4(%rbp), %edi
callq 0x2aec0
cmpl $0x0, %eax
je 0x310fe
leaq 0xa947e(%rip), %rdi     # 0xda575
movb $0x0, %al
callq 0x44240
movswl -0x2(%rbp), %edi
callq 0x11c50
cmpl $0x0, %eax
jne 0x31111
jmp 0x311a9
movsbl -0x5(%rbp), %eax
movl %eax, -0x10(%rbp)
testl %eax, %eax
je 0x31134
jmp 0x3111e
movl -0x10(%rbp), %eax
decl %eax
subl $0x5, %eax
jb 0x3113d
jmp 0x3112a
movl -0x10(%rbp), %eax
subl $0x6, %eax
je 0x31146
jmp 0x31148
movl $0x40, -0xc(%rbp)
jmp 0x3114f
movl $0x80, -0xc(%rbp)
jmp 0x3114f
jmp 0x31148
movl $0x100, -0xc(%rbp)      # imm = 0x100
leaq 0x148e72(%rip), %rax    # 0x179fc8
movl (%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x2, %eax
jb 0x31176
jmp 0x31162
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0x31181
jmp 0x3116c
movl -0x14(%rbp), %eax
subl $0x3, %eax
je 0x3118c
jmp 0x31195
movl -0xc(%rbp), %eax
sarl $0x4, %eax
movl %eax, -0xc(%rbp)
jmp 0x31195
movl -0xc(%rbp), %eax
sarl $0x3, %eax
movl %eax, -0xc(%rbp)
jmp 0x31195
movl -0xc(%rbp), %eax
sarl $0x2, %eax
movl %eax, -0xc(%rbp)
movw -0x2(%rbp), %cx
xorl %eax, %eax
subl -0xc(%rbp), %eax
movswl %cx, %edi
movswl %ax, %esi
callq 0x9d40
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekstat.c
// Function: playerhit
int
playerhit(int hitsprite, int *pnum)
{
     int       j;

     for( j=connecthead ; j >= 0 ; j=connectpoint2[j] ) {
          if( playersprite[j] == hitsprite ) {
               if( sprptr[hitsprite]->statnum != 8 ) {
                    crashgame("plrhit: plrsprt lost sttnm 8");
               }
               *pnum=j;
               return(1);
          }
     }

     return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x7730ca(%rip), %rax    # 0x7a4f50
movl (%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x31ef2
movslq -0x14(%rbp), %rcx
leaq 0xfc874(%rip), %rax     # 0x12e710
movswl (%rax,%rcx,2), %eax
cmpl -0x8(%rbp), %eax
jne 0x31edd
movslq -0x8(%rbp), %rcx
leaq 0x148330(%rip), %rax    # 0x17a1e0
movq (%rax,%rcx,8), %rax
movswl 0x1a(%rax), %eax
cmpl $0x8, %eax
je 0x31ecb
leaq 0xa884c(%rip), %rdi     # 0xda710
movb $0x0, %al
callq 0x44240
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x31ef9
jmp 0x31edf
movslq -0x14(%rbp), %rcx
leaq 0x773076(%rip), %rax    # 0x7a4f60
movl (%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
jmp 0x31e8b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekstat.c
// Function: sectorflash
void
sectorflash(short s)
{
     if(  sectflash.step != 0 ) {
          return;
     }
     sectflash.sectnum=s;
     sectflash.step=1;
     sectflash.ovis=sectptr[s]->visibility;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %di, %ax
movw %ax, -0x2(%rbp)
cmpl $0x0, 0x245f5a(%rip)    # 0x27f3dc
je 0x39486
jmp 0x394b4
movw -0x2(%rbp), %ax
movw %ax, 0x245f47(%rip)     # 0x27f3d8
movl $0x1, 0x245f41(%rip)    # 0x27f3dc
movswq -0x2(%rbp), %rcx
leaq 0x208d39(%rip), %rax    # 0x2421e0
movq (%rax,%rcx,8), %rax
movb 0x20(%rax), %al
movb %al, 0x245f2c(%rip)     # 0x27f3e0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekstat.c
// Function: dosectorflash
void
dosectorflash()
{
     switch( sectflash.step ) {
     case 0:
          break;
     case 1:
          sectptr[sectflash.sectnum]->visibility=0;
          sectflash.step=2;
          break;
     case 2:
          sectptr[sectflash.sectnum]->visibility=128;
          sectflash.step=3;
          break;
     case 3:
          sectptr[sectflash.sectnum]->visibility=0;
          sectflash.step=4;
          break;
     case 4:
          sectptr[sectflash.sectnum]->visibility=sectflash.ovis;
          sectflash.sectnum=0;
          sectflash.ovis=0;
          sectflash.step=0;
     }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x245732(%rip), %eax    # 0x27f3dc
movq %rax, -0x8(%rbp)
subq $0x4, %rax
ja 0x39d70
movq -0x8(%rbp), %rax
leaq 0xa0545(%rip), %rcx     # 0xda208
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x39d70
movswq 0x2456ff(%rip), %rcx    # 0x27f3d8
leaq 0x208500(%rip), %rax    # 0x2421e0
movq (%rax,%rcx,8), %rax
movb $0x0, 0x20(%rax)
movl $0x2, 0x2456ea(%rip)    # 0x27f3dc
jmp 0x39d70
movswq 0x2456dc(%rip), %rcx    # 0x27f3d8
leaq 0x2084dd(%rip), %rax    # 0x2421e0
movq (%rax,%rcx,8), %rax
movb $-0x80, 0x20(%rax)
movl $0x3, 0x2456c7(%rip)    # 0x27f3dc
jmp 0x39d70
movswq 0x2456b9(%rip), %rcx    # 0x27f3d8
leaq 0x2084ba(%rip), %rax    # 0x2421e0
movq (%rax,%rcx,8), %rax
movb $0x0, 0x20(%rax)
movl $0x4, 0x2456a4(%rip)    # 0x27f3dc
jmp 0x39d70
movb 0x2456a0(%rip), %cl     # 0x27f3e0
movswq 0x245690(%rip), %rdx    # 0x27f3d8
leaq 0x208491(%rip), %rax    # 0x2421e0
movq (%rax,%rdx,8), %rax
movb %cl, 0x20(%rax)
movw $0x0, 0x245679(%rip)    # 0x27f3d8
movb $0x0, 0x24567a(%rip)    # 0x27f3e0
movl $0x0, 0x24566c(%rip)    # 0x27f3dc
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tektag.c
// Function: warpsprite
void
warpsprite(short spritenum)
{
     short dasectnum;

     dasectnum = sprite[spritenum].sectnum;
     warp(&sprite[spritenum].x,&sprite[spritenum].y,&sprite[spritenum].z,
          &sprite[spritenum].ang,&dasectnum);
     copybuf(&sprite[spritenum].x,&osprite[spritenum].x,3);
     changespritesect(spritenum,dasectnum);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movswq -0x2(%rbp), %rcx
leaq 0x43a675(%rip), %rax    # 0x476ae0
imulq $0x2c, %rcx, %rcx
addq %rcx, %rax
movw 0x18(%rax), %ax
movw %ax, -0x4(%rbp)
movswq -0x2(%rbp), %rax
leaq 0x43a65a(%rip), %rdi    # 0x476ae0
imulq $0x2c, %rax, %rax
addq %rax, %rdi
movswq -0x2(%rbp), %rax
leaq 0x43a647(%rip), %rsi    # 0x476ae0
imulq $0x2c, %rax, %rax
addq %rax, %rsi
addq $0x4, %rsi
movswq -0x2(%rbp), %rax
leaq 0x43a630(%rip), %rdx    # 0x476ae0
imulq $0x2c, %rax, %rax
addq %rax, %rdx
addq $0x8, %rdx
movswq -0x2(%rbp), %rax
leaq 0x43a619(%rip), %rcx    # 0x476ae0
imulq $0x2c, %rax, %rax
addq %rax, %rcx
addq $0x1c, %rcx
leaq -0x4(%rbp), %r8
callq 0x3f110
movswq -0x2(%rbp), %rax
leaq 0x43a5f9(%rip), %rdi    # 0x476ae0
imulq $0x2c, %rax, %rax
addq %rax, %rdi
movswq -0x2(%rbp), %rax
leaq 0xf9726(%rip), %rsi     # 0x135c20
imulq $0xc, %rax, %rax
addq %rax, %rsi
movl $0x3, %edx
callq 0x8c070
movw -0x2(%rbp), %ax
movswl %ax, %edi
movswl -0x4(%rbp), %esi
callq 0x69bd0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tektag.c
// Function: testneighborsectors
int
testneighborsectors(short sect1, short sect2)
{
     short i, startwall, num1, num2;

     num1 = sector[sect1].wallnum;
     num2 = sector[sect2].wallnum;

     // traverse walls of sector with fewest walls (for speed)
     if( num1 < num2 ) {
          startwall = sector[sect1].wallptr;
          for(i=num1-1;i>=0;i--)
               if (wall[i+startwall].nextsector == sect2)
                    return(1);
     }
     else {
          startwall = sector[sect2].wallptr;
          for(i=num2-1;i>=0;i--)
               if (wall[i+startwall].nextsector == sect1)
                    return(1);
     }
     return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %si, %ax
movw %di, %cx
movw %cx, -0x6(%rbp)
movw %ax, -0x8(%rbp)
movswq -0x6(%rbp), %rcx
leaq 0x401342(%rip), %rax    # 0x43d890
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movw 0x2(%rax), %ax
movw %ax, -0xe(%rbp)
movswq -0x8(%rbp), %rcx
leaq 0x401327(%rip), %rax    # 0x43d890
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movw 0x2(%rax), %ax
movw %ax, -0x10(%rbp)
movswl -0xe(%rbp), %eax
movswl -0x10(%rbp), %ecx
cmpl %ecx, %eax
jge 0x3c5f7
movswq -0x6(%rbp), %rcx
leaq 0x401300(%rip), %rax    # 0x43d890
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movw (%rax), %ax
movw %ax, -0xc(%rbp)
movswl -0xe(%rbp), %eax
subl $0x1, %eax
movw %ax, -0xa(%rbp)
movswl -0xa(%rbp), %eax
cmpl $0x0, %eax
jl 0x3c5f5
movswl -0xa(%rbp), %eax
movswl -0xc(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x3762ba(%rip), %rax    # 0x3b2880
shlq $0x5, %rcx
addq %rcx, %rax
movswl 0xc(%rax), %eax
movswl -0x8(%rbp), %ecx
cmpl %ecx, %eax
jne 0x3c5e5
movl $0x1, -0x4(%rbp)
jmp 0x3c66e
jmp 0x3c5e7
movw -0xa(%rbp), %ax
addw $-0x1, %ax
movw %ax, -0xa(%rbp)
jmp 0x3c5a9
jmp 0x3c667
movswq -0x8(%rbp), %rcx
leaq 0x40128d(%rip), %rax    # 0x43d890
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movw (%rax), %ax
movw %ax, -0xc(%rbp)
movswl -0x10(%rbp), %eax
subl $0x1, %eax
movw %ax, -0xa(%rbp)
movswl -0xa(%rbp), %eax
cmpl $0x0, %eax
jl 0x3c665
movswl -0xa(%rbp), %eax
movswl -0xc(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x376247(%rip), %rax    # 0x3b2880
shlq $0x5, %rcx
addq %rcx, %rax
movswl 0xc(%rax), %eax
movswl -0x6(%rbp), %ecx
cmpl %ecx, %eax
jne 0x3c655
movl $0x1, -0x4(%rbp)
jmp 0x3c66e
jmp 0x3c657
movw -0xa(%rbp), %ax
addw $-0x1, %ax
movw %ax, -0xa(%rbp)
jmp 0x3c61c
jmp 0x3c667
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tektag.c
// Function: tekwarp
void
tekwarp(int *x, int *y, int *z, short *dasector)
{
     short          startwall, endwall, s;
     int           i, dax, day;

     // find center of sector
     startwall = sector[*dasector].wallptr;
     endwall = startwall+sector[*dasector].wallnum-1;
     dax = 0L, day = 0L;
     for( s=startwall; s<=endwall; s++ ) {
          dax += wall[s].x, day += wall[s].y;
          if( wall[s].nextsector >= 0 ) {
               i = s;
          }
     }
     *x = dax / (endwall-startwall+1);
     *y = day / (endwall-startwall+1);
     *z = sector[*dasector].floorz-(42<<8);

     updatesector(*x,*y,dasector);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movswq (%rax), %rcx
leaq 0x3fe529(%rip), %rax    # 0x43d890
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movw (%rax), %ax
movw %ax, -0x22(%rbp)
movswl -0x22(%rbp), %eax
movq -0x20(%rbp), %rcx
movswq (%rcx), %rdx
leaq 0x3fe508(%rip), %rcx    # 0x43d890
imulq $0x28, %rdx, %rdx
addq %rdx, %rcx
movswl 0x2(%rcx), %ecx
addl %ecx, %eax
subl $0x1, %eax
movw %ax, -0x24(%rbp)
movl $0x0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movw -0x22(%rbp), %ax
movw %ax, -0x26(%rbp)
movswl -0x26(%rbp), %eax
movswl -0x24(%rbp), %ecx
cmpl %ecx, %eax
jg 0x3f428
movswq -0x26(%rbp), %rcx
leaq 0x3734b6(%rip), %rax    # 0x3b2880
shlq $0x5, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x30(%rbp), %eax
movl %eax, -0x30(%rbp)
movswq -0x26(%rbp), %rcx
leaq 0x37349b(%rip), %rax    # 0x3b2880
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
addl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
movswq -0x26(%rbp), %rcx
leaq 0x37347f(%rip), %rax    # 0x3b2880
shlq $0x5, %rcx
addq %rcx, %rax
movswl 0xc(%rax), %eax
cmpl $0x0, %eax
jl 0x3f418
movswl -0x26(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x3f41a
movw -0x26(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x26(%rbp)
jmp 0x3f3b2
movl -0x30(%rbp), %eax
movswl -0x24(%rbp), %ecx
movswl -0x22(%rbp), %edx
subl %edx, %ecx
addl $0x1, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movl -0x34(%rbp), %eax
movswl -0x24(%rbp), %ecx
movswl -0x22(%rbp), %edx
subl %edx, %ecx
addl $0x1, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movswq (%rax), %rcx
leaq 0x3fe423(%rip), %rax    # 0x43d890
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %ecx
subl $0x2a00, %ecx           # imm = 0x2A00
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl (%rax), %edi
movq -0x10(%rbp), %rax
movl (%rax), %esi
movq -0x20(%rbp), %rdx
callq 0x53c40
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tektag.c
// Function: krand_intercept
int
krand_intercept(char *stg)
{
     if (dbgflag) {
          if (dbgcolumn > 80) {
               fprintf(dbgfp,"\n");
               dbgcolumn=0;
          }
          else {
               fprintf(dbgfp,"%s(%-9d) ",stg,randomseed);
               dbgcolumn+=20;
          }
     }
     return(krand());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xec441(%rip), %rax     # 0x12d964
cmpl $0x0, (%rax)
je 0x41597
leaq 0xec2c9(%rip), %rax     # 0x12d7f8
cmpl $0x50, (%rax)
jle 0x4155b
leaq 0xec2c5(%rip), %rax     # 0x12d800
movq (%rax), %rdi
leaq 0xaea3b(%rip), %rsi     # 0xeff80
movb $0x0, %al
callq 0x8280
leaq 0xec2a5(%rip), %rax     # 0x12d7f8
movl $0x0, (%rax)
jmp 0x41595
leaq 0xec29e(%rip), %rax     # 0x12d800
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x5ecb38(%rip), %rax    # 0x62e0a8
movl (%rax), %ecx
leaq 0x99659(%rip), %rsi     # 0xdabd2
movb $0x0, %al
callq 0x8280
leaq 0xec271(%rip), %rax     # 0x12d7f8
movl (%rax), %ecx
addl $0x14, %ecx
leaq 0xec265(%rip), %rax     # 0x12d7f8
movl %ecx, (%rax)
jmp 0x41597
callq 0x70730
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tektag.c
// Function: tekdodelayfuncs
void
tekdodelayfuncs(void)
{
     int  i,n,p;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movswl 0x334741(%rip), %eax    # 0x3777e0
movl %eax, -0x8(%rbp)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x431a3
movslq -0x4(%rbp), %rcx
leaq 0x334930(%rip), %rax    # 0x3779f0
movq (%rax,%rcx,8), %rax
cmpq $0x0, (%rax)
jne 0x430cf
jmp 0x43195
movslq -0x4(%rbp), %rcx
leaq 0x334916(%rip), %rax    # 0x3779f0
movq (%rax,%rcx,8), %rax
movl 0x8(%rax), %ecx
subl $0x3, %ecx
movl %ecx, 0x8(%rax)
movslq -0x4(%rbp), %rcx
leaq 0x3348fe(%rip), %rax    # 0x3779f0
movq (%rax,%rcx,8), %rax
cmpl $0x0, 0x8(%rax)
jg 0x43193
movslq -0x4(%rbp), %rcx
leaq 0x3348e5(%rip), %rax    # 0x3779f0
movq (%rax,%rcx,8), %rax
movswl 0xc(%rax), %eax
movl %eax, -0xc(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x3348cf(%rip), %rax    # 0x3779f0
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
movswl %cx, %edi
callq *%rax
movslq -0x4(%rbp), %rcx
leaq 0x3348b5(%rip), %rax    # 0x3779f0
movq (%rax,%rcx,8), %rax
movswl 0x33469a(%rip), %ecx    # 0x3777e0
subl $0x1, %ecx
movslq %ecx, %rdx
leaq 0x33489d(%rip), %rcx    # 0x3779f0
movq (%rcx,%rdx,8), %rcx
movups (%rcx), %xmm0
movups %xmm0, (%rax)
movswl 0x33467c(%rip), %eax    # 0x3777e0
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x33487f(%rip), %rax    # 0x3779f0
movq (%rax,%rcx,8), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x8410
movw 0x334658(%rip), %ax     # 0x3777e0
addw $-0x1, %ax
movw %ax, 0x33464d(%rip)     # 0x3777e0
jmp 0x43195
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x430a9
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tektag.c
// Function: stepdoor
int
stepdoor(int z,int z2,struct doortype *door,int newstate)
{
     if (z < z2) {
       z+=(door->step*TICSPERFRAME);
       if (z >= z2) {
            door->delay=DOORDELAY;
            door->state=newstate;
            z=z2;
       }
     }
     else if (z > z2) {
       z-=(door->step*TICSPERFRAME);
       if (z <= z2) {
            door->delay=DOORDELAY;
            door->state=newstate;
            z=z2;
       }
     }
     return(z);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x431fc
movq -0x10(%rbp), %rax
imull $0x3, 0xc(%rax), %eax
addl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jl 0x431fa
movq -0x10(%rbp), %rax
movl $0x1e0, 0x10(%rax)      # imm = 0x1E0
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x4323b
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jle 0x43239
movq -0x10(%rbp), %rax
imull $0x3, 0xc(%rax), %ecx
movl -0x4(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jg 0x43237
movq -0x10(%rbp), %rax
movl $0x1e0, 0x10(%rax)      # imm = 0x1E0
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x43239
jmp 0x4323b
movl -0x4(%rbp), %eax
popq %rbp
retq