LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekgame.c
// Function: debugout
void
debugout(short p)
{
     static int dbglines;

     if (dbgcolumn != 0) {
          fprintf(dbgfp,"\n");
     }
     fprintf(dbgfp,"%2d %6d %3d %04X %04d %06d %06d %06d %06d %d\n",
                    p,lockclock,movefifoplc,syncbits[p],ang[p],posx[p],posy[p],posz[p],
                    health[p],randomseed);
     dbglines++;
     dbgcolumn=0;
     if (dbglines > 2000) {
          dbglines=0;
          fclose(dbgfp);
          sprintf(dbgfname,"DEBUG.%03d",dbgfilen++);
          dbgfp=fopen(dbgfname,"wt");
          fprintf(dbgfp," P  CLOCK PLC BITS  ANG   X     Y     Z   HEALTH RSEED\n");
          fprintf(dbgfp,"== ====== === ==== ==== ===== ===== ===== ====== =========\n");
     }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movw %di, %ax
movw %ax, -0x1a(%rbp)
cmpl $0x0, 0x12346d(%rip)    # 0x12d7f8
je 0xa3a2
movq 0x12346c(%rip), %rdi    # 0x12d800
leaq 0xe5be5(%rip), %rsi     # 0xeff80
movb $0x0, %al
callq 0x8280
movq 0x123457(%rip), %rdi    # 0x12d800
movswl -0x1a(%rbp), %edx
movl 0x123455(%rip), %ecx    # 0x12d808
movl 0x123452(%rip), %r8d    # 0x12d80c
movswq -0x1a(%rbp), %rsi
leaq 0x12344a(%rip), %rax    # 0x12d810
movzwl (%rax,%rsi,2), %r9d
movswq -0x1a(%rbp), %rsi
leaq 0x123459(%rip), %rax    # 0x12d830
movswl (%rax,%rsi,2), %r15d
movswq -0x1a(%rbp), %rsi
leaq 0x123468(%rip), %rax    # 0x12d850
movl (%rax,%rsi,4), %r14d
movswq -0x1a(%rbp), %rsi
leaq 0x123498(%rip), %rax    # 0x12d890
movl (%rax,%rsi,4), %ebx
movswq -0x1a(%rbp), %rsi
leaq 0x1234c9(%rip), %rax    # 0x12d8d0
movl (%rax,%rsi,4), %r11d
movswq -0x1a(%rbp), %rsi
leaq 0x1234f9(%rip), %rax    # 0x12d910
movl (%rax,%rsi,4), %r10d
leaq 0x623c86(%rip), %rax    # 0x62e0a8
movl (%rax), %eax
leaq 0xce9e1(%rip), %rsi     # 0xd8e0c
movl %r15d, (%rsp)
movl %r14d, 0x8(%rsp)
movl %ebx, 0x10(%rsp)
movl %r11d, 0x18(%rsp)
movl %r10d, 0x20(%rsp)
movl %eax, 0x28(%rsp)
movb $0x0, %al
callq 0x8280
movl 0x1233a1(%rip), %eax    # 0x12d7f4
addl $0x1, %eax
movl %eax, 0x123398(%rip)    # 0x12d7f4
movl $0x0, 0x123392(%rip)    # 0x12d7f8
cmpl $0x7d0, 0x123384(%rip)  # imm = 0x7D0
jle 0xa4f6
movl $0x0, 0x123374(%rip)    # 0x12d7f4
movq 0x123379(%rip), %rdi    # 0x12d800
callq 0x85d0
movl 0x1234ce(%rip), %edx    # 0x12d960
movl %edx, %eax
addl $0x1, %eax
movl %eax, 0x1234c3(%rip)    # 0x12d960
leaq 0x1234ac(%rip), %rdi    # 0x12d950
leaq 0xce98f(%rip), %rsi     # 0xd8e3a
movb $0x0, %al
callq 0x8e50
leaq 0x123497(%rip), %rdi    # 0x12d950
leaq 0xcdba4(%rip), %rsi     # 0xd8064
callq 0x9100
movq %rax, 0x123334(%rip)    # 0x12d800
movq 0x12332d(%rip), %rdi    # 0x12d800
leaq 0xce96b(%rip), %rsi     # 0xd8e45
movb $0x0, %al
callq 0x8280
movq 0x123318(%rip), %rdi    # 0x12d800
leaq 0xce98e(%rip), %rsi     # 0xd8e7d
movb $0x0, %al
callq 0x8280
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekgame.c
// Function: movethings
void
movethings()
{
     int      i;

     gotlastpacketclock = totalclock;
     for( i=connecthead; i>=0; i=connectpoint2[i] ) {
          baksyncvel[movefifoend][i] = fsyncvel[i];
          baksyncsvel[movefifoend][i] = fsyncsvel[i];
          baksyncangvel[movefifoend][i] = fsyncangvel[i];
          baksyncbits[movefifoend][i] = fsyncbits[i];
     }
     movefifoend = ((movefifoend+1)&(MOVEFIFOSIZ-1));

     // do this for Master/Slave switching
     for( i=connectpoint2[connecthead]; i>=0; i=connectpoint2[i] ) {
          if( syncbits[i]&512 ) {
               ready2send = 0;
          }
     }

     tektime();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x598149(%rip), %rax    # 0x5a6318
movl (%rax), %eax
movl %eax, 0x11f601(%rip)    # 0x12d7d8
leaq 0x796d72(%rip), %rax    # 0x7a4f50
movl (%rax), %eax
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0xe2b1
movslq -0x4(%rbp), %rcx
leaq 0x120318(%rip), %rax    # 0x12e510
movb (%rax,%rcx), %dl
movslq 0x1202b2(%rip), %rcx    # 0x12e4b4
leaq 0x120a17(%rip), %rax    # 0x12ec20
shlq $0x4, %rcx
addq %rcx, %rax
movslq -0x4(%rbp), %rcx
movb %dl, (%rax,%rcx)
movslq -0x4(%rbp), %rcx
leaq 0x12033e(%rip), %rax    # 0x12e560
movw (%rax,%rcx,2), %dx
movslq 0x120287(%rip), %rcx    # 0x12e4b4
leaq 0x1219ec(%rip), %rax    # 0x12fc20
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x4(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
movslq -0x4(%rbp), %rcx
leaq 0x120372(%rip), %rax    # 0x12e5c0
movw (%rax,%rcx,2), %dx
movslq 0x12025b(%rip), %rcx    # 0x12e4b4
leaq 0x1239c0(%rip), %rax    # 0x131c20
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x4(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
movslq -0x4(%rbp), %rcx
leaq 0x120386(%rip), %rax    # 0x12e600
movw (%rax,%rcx,2), %dx
movslq 0x12022f(%rip), %rcx    # 0x12e4b4
leaq 0x125994(%rip), %rax    # 0x133c20
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x4(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
movslq -0x4(%rbp), %rcx
leaq 0x796cba(%rip), %rax    # 0x7a4f60
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
jmp 0xe1e3
movl 0x1201fd(%rip), %eax    # 0x12e4b4
addl $0x1, %eax
andl $0xff, %eax
movl %eax, 0x1201ef(%rip)    # 0x12e4b4
leaq 0x796c84(%rip), %rax    # 0x7a4f50
movslq (%rax), %rcx
leaq 0x796c8a(%rip), %rax    # 0x7a4f60
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0xe317
movslq -0x4(%rbp), %rcx
leaq 0x11f523(%rip), %rax    # 0x12d810
movzwl (%rax,%rcx,2), %eax
andl $0x200, %eax            # imm = 0x200
cmpl $0x0, %eax
je 0xe302
movb $0x0, 0x11f4d1(%rip)    # 0x12d7d3
jmp 0xe304
movslq -0x4(%rbp), %rcx
leaq 0x796c51(%rip), %rax    # 0x7a4f60
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
jmp 0xe2dc
callq 0x1d700
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekgame.c
// Function: adjustbiasthreshhold
void
adjustbiasthreshhold(short mousy)
{
     biasthreshhold-=mousy;
     if( biasthreshhold < 8 )
          biasthreshhold=8;
     if( biasthreshhold > 512 )
          biasthreshhold=512;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %di, %ax
movw %ax, -0x2(%rbp)
movswl -0x2(%rbp), %ecx
movswl 0x10b65c(%rip), %eax    # 0x119f02
subl %ecx, %eax
movw %ax, 0x10b653(%rip)     # 0x119f02
movswl 0x10b64c(%rip), %eax    # 0x119f02
cmpl $0x8, %eax
jge 0xe8c4
movw $0x8, 0x10b63e(%rip)    # 0x119f02
movswl 0x10b637(%rip), %eax    # 0x119f02
cmpl $0x200, %eax            # imm = 0x200
jle 0xe8db
movw $0x200, 0x10b627(%rip)  # imm = 0x200
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekgame.c
// Function: getanimationgoal
int
getanimationgoal(int *animptr)
{
     int i;

     for(i=animatecnt-1;i>=0;i--)
          if (animptr == animateptr[i]) return(i);
     return(-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl 0x11d052(%rip), %eax    # 0x12d7f0
subl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x107d4
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rdx
leaq 0x163497(%rip), %rcx    # 0x173c50
cmpq (%rcx,%rdx,8), %rax
jne 0x107c7
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x107db
jmp 0x107c9
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x107a4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekgame.c
// Function: setanimation
int
setanimation(int *animptr, int thegoal, int thevel, int theacc)
{
     int i, j;

     if (animatecnt >= MAXANIMATES) return(-1);

     j = animatecnt;
     for(i=animatecnt-1;i>=0;i--)
          if (animptr == animateptr[i])
               { j = i; break; }

     animateptr[j] = animptr;
     animategoal[j] = thegoal;
     animatevel[j] = thevel;
     animateacc[j] = theacc;
     if (j == animatecnt) animatecnt++;
     return(j);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpl $0x200, 0x11cff5(%rip)  # imm = 0x200
jl 0x10809
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x108b4
movl 0x11cfe1(%rip), %eax    # 0x12d7f0
movl %eax, -0x24(%rbp)
movl 0x11cfd8(%rip), %eax    # 0x12d7f0
subl $0x1, %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jl 0x1084e
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rdx
leaq 0x16341d(%rip), %rcx    # 0x173c50
cmpq (%rcx,%rdx,8), %rax
jne 0x10841
movl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x1084e
jmp 0x10843
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1081e
movq -0x10(%rbp), %rdx
movslq -0x24(%rbp), %rcx
leaq 0x1633f3(%rip), %rax    # 0x173c50
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %edx
movslq -0x24(%rbp), %rcx
leaq 0x1643e1(%rip), %rax    # 0x174c50
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %edx
movslq -0x24(%rbp), %rcx
leaq 0x164bd0(%rip), %rax    # 0x175450
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %edx
movslq -0x24(%rbp), %rcx
leaq 0x1653bf(%rip), %rax    # 0x175c50
movl %edx, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
cmpl 0x11cf53(%rip), %eax    # 0x12d7f0
jne 0x108ae
movl 0x11cf4b(%rip), %eax    # 0x12d7f0
addl $0x1, %eax
movl %eax, 0x11cf42(%rip)    # 0x12d7f0
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekgun.c
// Function: validplayer
int
validplayer(int snum)
{
     int       j;

     for( j=connecthead ; j >= 0 ; j=connectpoint2[j] ) {
          if( j == snum ) {
               return(1);
          }
     }
     return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
leaq 0x7932f2(%rip), %rax    # 0x7a4f50
movl (%rax), %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x11c8f
movl -0xc(%rbp), %eax
cmpl -0x8(%rbp), %eax
jne 0x11c7a
movl $0x1, -0x4(%rbp)
jmp 0x11c96
jmp 0x11c7c
movslq -0xc(%rbp), %rcx
leaq 0x7932d9(%rip), %rax    # 0x7a4f60
movl (%rax,%rcx,4), %eax
movl %eax, -0xc(%rbp)
jmp 0x11c63
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekgun.c
// Function: restockammo
void
restockammo(int snum)
{
     ammo1[snum]=MAXAMMO;
     ammo2[snum]=MAXAMMO>>1;
     ammo3[snum]=20;
     ammo4[snum]=0;
     ammo5[snum]=MAXAMMO;
     ammo6[snum]=0;
     ammo7[snum]=0;
     ammo8[snum]=0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x1664ee(%rip), %rax    # 0x1781a0
movw $0x64, (%rax,%rcx,2)
movslq -0x4(%rbp), %rcx
leaq 0x1664fd(%rip), %rax    # 0x1781c0
movw $0x32, (%rax,%rcx,2)
movslq -0x4(%rbp), %rcx
leaq 0x16650c(%rip), %rax    # 0x1781e0
movw $0x14, (%rax,%rcx,2)
movslq -0x4(%rbp), %rcx
leaq 0x16651b(%rip), %rax    # 0x178200
movw $0x0, (%rax,%rcx,2)
movslq -0x4(%rbp), %rcx
leaq 0x16652a(%rip), %rax    # 0x178220
movw $0x64, (%rax,%rcx,2)
movslq -0x4(%rbp), %rcx
leaq 0x166539(%rip), %rax    # 0x178240
movw $0x0, (%rax,%rcx,2)
movslq -0x4(%rbp), %rcx
leaq 0x166548(%rip), %rax    # 0x178260
movw $0x0, (%rax,%rcx,2)
movslq -0x4(%rbp), %rcx
leaq 0x166557(%rip), %rax    # 0x178280
movw $0x0, (%rax,%rcx,2)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekgun.c
// Function: tekgundamage
int
tekgundamage(int gun,int x,int y,int z,int hitsprite)
{
     int       damage;

     (void)x; (void)y; (void)z; (void)hitsprite;

     switch( gun ) {
     case 1:  damage= 2; break;
     case 4:  damage=20; break;
     default: damage= 2; break;
     }
     switch( difficulty ) {
     case 0:
     case 1:  damage+=4; break;
     case 2:  damage+=4; break;
     case 3:
     default:  damage+=10; break;
     }

     return(damage);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl %r8d, -0x14(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x1c(%rbp)
subl $0x1, %eax
je 0x11d9b
jmp 0x11d91
movl -0x1c(%rbp), %eax
subl $0x4, %eax
je 0x11da4
jmp 0x11dad
movl $0x2, -0x18(%rbp)
jmp 0x11db4
movl $0x14, -0x18(%rbp)
jmp 0x11db4
movl $0x2, -0x18(%rbp)
leaq 0x16820d(%rip), %rax    # 0x179fc8
movl (%rax), %eax
movl %eax, -0x20(%rbp)
subl $0x2, %eax
jb 0x11ddb
jmp 0x11dc7
movl -0x20(%rbp), %eax
subl $0x2, %eax
je 0x11de6
jmp 0x11dd1
movl -0x20(%rbp), %eax
subl $0x3, %eax
je 0x11df1
jmp 0x11df3
movl -0x18(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x18(%rbp)
jmp 0x11dfc
movl -0x18(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x18(%rbp)
jmp 0x11dfc
jmp 0x11df3
movl -0x18(%rbp), %eax
addl $0xa, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekgun.c
// Function: hasammo
int
hasammo(int gun,short p)     // does player[p] have ammo for "gun"?
{
     switch (gun+1) {
     case GUN1FLAG:
          if( ammo1[p] > 0 ) {
               return(1);
          }
          break;
     case GUN2FLAG:
          if( ammo2[p] > 0 ) {
               return(1);
          }
          break;
     case GUN3FLAG:
          if( ammo3[p] > 0 ) {
               return(1);
          }
          break;
     case GUN4FLAG:
          if( ammo4[p] > 0 ) {
               return(1);
          }
          break;
     case GUN5FLAG:
          if( ammo5[p] > 0 ) {
               return(1);
          }
          break;
     case GUN6FLAG:
          if( ammo6[p] > 0 ) {
               return(1);
          }
          break;
     case GUN7FLAG:
          if( ammo7[p] > 0 ) {
               return(1);
          }
          break;
     case GUN8FLAG:
          if( ammo8[p] > 0 ) {
               return(1);
          }
          break;
     }
     return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %si, %ax
movl %edi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movl -0x8(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x7, %rax
ja 0x11f5b
movq -0x18(%rbp), %rax
leaq 0xc748e(%rip), %rcx     # 0xd92c8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movswq -0xa(%rbp), %rcx
leaq 0x166351(%rip), %rax    # 0x1781a0
movswl (%rax,%rcx,2), %eax
cmpl $0x0, %eax
jle 0x11e64
movl $0x1, -0x4(%rbp)
jmp 0x11f62
jmp 0x11f5b
movswq -0xa(%rbp), %rcx
leaq 0x16634b(%rip), %rax    # 0x1781c0
movswl (%rax,%rcx,2), %eax
cmpl $0x0, %eax
jle 0x11e8a
movl $0x1, -0x4(%rbp)
jmp 0x11f62
jmp 0x11f5b
movswq -0xa(%rbp), %rcx
leaq 0x166345(%rip), %rax    # 0x1781e0
movswl (%rax,%rcx,2), %eax
cmpl $0x0, %eax
jle 0x11eb0
movl $0x1, -0x4(%rbp)
jmp 0x11f62
jmp 0x11f5b
movswq -0xa(%rbp), %rcx
leaq 0x16633f(%rip), %rax    # 0x178200
movswl (%rax,%rcx,2), %eax
cmpl $0x0, %eax
jle 0x11ed6
movl $0x1, -0x4(%rbp)
jmp 0x11f62
jmp 0x11f5b
movswq -0xa(%rbp), %rcx
leaq 0x166339(%rip), %rax    # 0x178220
movswl (%rax,%rcx,2), %eax
cmpl $0x0, %eax
jle 0x11ef9
movl $0x1, -0x4(%rbp)
jmp 0x11f62
jmp 0x11f5b
movswq -0xa(%rbp), %rcx
leaq 0x166339(%rip), %rax    # 0x178240
movswl (%rax,%rcx,2), %eax
cmpl $0x0, %eax
jle 0x11f19
movl $0x1, -0x4(%rbp)
jmp 0x11f62
jmp 0x11f5b
movswq -0xa(%rbp), %rcx
leaq 0x166339(%rip), %rax    # 0x178260
movswl (%rax,%rcx,2), %eax
cmpl $0x0, %eax
jle 0x11f39
movl $0x1, -0x4(%rbp)
jmp 0x11f62
jmp 0x11f5b
movswq -0xa(%rbp), %rcx
leaq 0x166339(%rip), %rax    # 0x178280
movswl (%rax,%rcx,2), %eax
cmpl $0x0, %eax
jle 0x11f59
movl $0x1, -0x4(%rbp)
jmp 0x11f62
jmp 0x11f5b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekgun.c
// Function: tekfiregun
void
tekfiregun(int gun,short p)  // this kicks off an animation sequence
{
     if( fireseq[p] != 0 ) {
          return;
     }
     if( tekgunrep(gun) || ((oflags[p]&2048) == 0) ) {
//          if( hasammo(gun,p) ) {
               fireseq[p]=1;
               oneshot[p]=0;
//          }
     }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %si, %ax
movl %edi, -0x4(%rbp)
movw %ax, -0x6(%rbp)
movswq -0x6(%rbp), %rcx
leaq 0x166312(%rip), %rax    # 0x1782a0
cmpl $0x0, (%rax,%rcx,4)
je 0x11f96
jmp 0x11fe3
movl -0x4(%rbp), %edi
callq 0x11d40
cmpl $0x0, %eax
jne 0x11fbd
movswq -0x6(%rbp), %rcx
leaq 0x11c971(%rip), %rax    # 0x12e920
movswl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0x11fe3
movswq -0x6(%rbp), %rcx
leaq 0x1662d7(%rip), %rax    # 0x1782a0
movl $0x1, (%rax,%rcx,4)
movswq -0x6(%rbp), %rcx
leaq 0x166304(%rip), %rax    # 0x1782e0
movl $0x0, (%rax,%rcx,4)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekgun.c
// Function: playerwoundplayer
void
playerwoundplayer(short plrhit, short plr, char guntype)
{
     int       killed=0,damage=0,score=0;

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

     switch( guntype ) {
     case 2:  score=5;  damage=48;   break;
     case 3:  score=10; damage=192;  break;
     case 4:  score=10; damage=512;  break;
     case 5:  score=15; damage=1024; break;
     case 6:  score=10; damage=24;   break;
     case 7:  score=10; damage=512;  break;
     default: score=5;  damage=32;   break;
     }

     killed=changehealth(plrhit,-damage);

     if( killed ) {
          changescore(plr, (score<<1));
     }
     else {
          changescore(plr, score);
     }
}

// 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)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movswl -0x2(%rbp), %edi
callq 0x11c50
cmpl $0x0, %eax
je 0x1203c
movswl -0x4(%rbp), %edi
callq 0x11c50
cmpl $0x0, %eax
jne 0x12041
jmp 0x1211a
movsbl -0x5(%rbp), %eax
addl $-0x2, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x5, %eax
ja 0x120c7
movq -0x20(%rbp), %rax
leaq 0xc728a(%rip), %rcx     # 0xd92e8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x5, -0x14(%rbp)
movl $0x30, -0x10(%rbp)
jmp 0x120d5
movl $0xa, -0x14(%rbp)
movl $0xc0, -0x10(%rbp)
jmp 0x120d5
movl $0xa, -0x14(%rbp)
movl $0x200, -0x10(%rbp)     # imm = 0x200
jmp 0x120d5
movl $0xf, -0x14(%rbp)
movl $0x400, -0x10(%rbp)     # imm = 0x400
jmp 0x120d5
movl $0xa, -0x14(%rbp)
movl $0x18, -0x10(%rbp)
jmp 0x120d5
movl $0xa, -0x14(%rbp)
movl $0x200, -0x10(%rbp)     # imm = 0x200
jmp 0x120d5
movl $0x5, -0x14(%rbp)
movl $0x20, -0x10(%rbp)
movw -0x2(%rbp), %cx
xorl %eax, %eax
subl -0x10(%rbp), %eax
movswl %cx, %edi
movswl %ax, %esi
callq 0x9d40
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x12108
movw -0x4(%rbp), %cx
movl -0x14(%rbp), %eax
shll %eax
movswl %cx, %edi
movswl %ax, %esi
callq 0x9f70
jmp 0x1211a
movw -0x4(%rbp), %cx
movl -0x14(%rbp), %eax
movswl %cx, %edi
movswl %ax, %esi
callq 0x9f70
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekgun.c
// Function: playerpainsound
void
playerpainsound(int p)
{
     if( !validplayer(p) ) {
          crashgame("playerpainsnd: bad plr num");
     }

     if( krand_intercept(" GUN 341") < 1024 ) {
          playsound(S_PAIN1+(krand_intercept(" GUN 342")&1),posx[p],posy[p],0,ST_NOUPDATE);
     }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0x11c50
cmpl $0x0, %eax
jne 0x122c6
leaq 0xc70f1(%rip), %rdi     # 0xd93b0
movb $0x0, %al
callq 0x44240
leaq 0xc70fe(%rip), %rdi     # 0xd93cb
callq 0x41510
cmpl $0x400, %eax            # imm = 0x400
jge 0x12316
leaq 0xc70f4(%rip), %rdi     # 0xd93d4
callq 0x41510
movl %eax, %edi
andl $0x1, %edi
addl $0x7b, %edi
movslq -0x4(%rbp), %rcx
leaq 0x11b558(%rip), %rax    # 0x12d850
movl (%rax,%rcx,4), %esi
movslq -0x4(%rbp), %rcx
leaq 0x11b58a(%rip), %rax    # 0x12d890
movl (%rax,%rcx,4), %edx
xorl %ecx, %ecx
movl $0x4, %r8d
callq 0x26af0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekgun.c
// Function: tekhasweapon
int
tekhasweapon(int gun,short snum)
{
     int       hasit=0;

     if( mission == 7 ) {
          if( gun != 7 ) {
               if( snum == screenpeek ) {
                    notininventory=1;
               }
               return(0);
          }
          else {
               return(1);
          }
     }
     else {
          if( gun == 7 ) {
               if( snum == screenpeek ) {
                    showmessage("ONLY IN MATRIX");
               }
               return(0);
          }
     }

     hasit=(weapons[snum]&flags32[gun+1]);
     if( hasit )
          return(1);

     notininventory=1;
     return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %si, %ax
movl %edi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movl $0x0, -0x10(%rbp)
leaq 0x1623f0(%rip), %rax    # 0x1784d0
cmpl $0x7, (%rax)
jne 0x16119
cmpl $0x7, -0x8(%rbp)
je 0x16110
movswl -0xa(%rbp), %eax
leaq 0x1176e8(%rip), %rcx    # 0x12d7de
movswl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x16107
leaq 0x163e44(%rip), %rax    # 0x179f48
movb $0x1, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x1618f
movl $0x1, -0x4(%rbp)
jmp 0x1618f
cmpl $0x7, -0x8(%rbp)
jne 0x16148
movswl -0xa(%rbp), %eax
leaq 0x1176b4(%rip), %rcx    # 0x12d7de
movswl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x1613f
leaq 0xc3330(%rip), %rdi     # 0xd9468
movb $0x0, %al
callq 0x1a150
movl $0x0, -0x4(%rbp)
jmp 0x1618f
jmp 0x1614a
movswq -0xa(%rbp), %rcx
leaq 0x1622ea(%rip), %rax    # 0x178440
movl (%rax,%rcx,4), %eax
movl -0x8(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rdx
leaq 0x104d27(%rip), %rcx    # 0x11ae90
andl (%rcx,%rdx,4), %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x1617e
movl $0x1, -0x4(%rbp)
jmp 0x1618f
leaq 0x163dc3(%rip), %rax    # 0x179f48
movb $0x1, (%rax)
movl $0x0, -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/tekgun.c
// Function: tekgunsave
void
tekgunsave(int fil)
{
     write(fil,fireseq,MAXPLAYERS*sizeof(int));
     write(fil,ammo1,MAXPLAYERS*sizeof(short));
     write(fil,ammo2,MAXPLAYERS*sizeof(short));
     write(fil,ammo3,MAXPLAYERS*sizeof(short));
     write(fil,ammo4,MAXPLAYERS*sizeof(short));
     write(fil,ammo5,MAXPLAYERS*sizeof(short));
     write(fil,ammo6,MAXPLAYERS*sizeof(short));
     write(fil,ammo7,MAXPLAYERS*sizeof(short));
     write(fil,ammo8,MAXPLAYERS*sizeof(short));
     write(fil,weapons,MAXPLAYERS*sizeof(int));
     write(fil,firedonetics,MAXPLAYERS*sizeof(int));
     write(fil,lastgun,MAXPLAYERS*sizeof(int));
     write(fil,&goreflag,sizeof(int));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
leaq 0x1620eb(%rip), %rsi    # 0x1782a0
movl $0x40, %edx
callq 0x8e40
movl -0x4(%rbp), %edi
leaq 0x161fd7(%rip), %rsi    # 0x1781a0
movl $0x20, %edx
callq 0x8e40
movl -0x4(%rbp), %edi
leaq 0x161fe3(%rip), %rsi    # 0x1781c0
movl $0x20, %edx
callq 0x8e40
movl -0x4(%rbp), %edi
leaq 0x161fef(%rip), %rsi    # 0x1781e0
movl $0x20, %edx
callq 0x8e40
movl -0x4(%rbp), %edi
leaq 0x161ffb(%rip), %rsi    # 0x178200
movl $0x20, %edx
callq 0x8e40
movl -0x4(%rbp), %edi
leaq 0x162007(%rip), %rsi    # 0x178220
movl $0x20, %edx
callq 0x8e40
movl -0x4(%rbp), %edi
leaq 0x162013(%rip), %rsi    # 0x178240
movl $0x20, %edx
callq 0x8e40
movl -0x4(%rbp), %edi
leaq 0x16201f(%rip), %rsi    # 0x178260
movl $0x20, %edx
callq 0x8e40
movl -0x4(%rbp), %edi
leaq 0x16202b(%rip), %rsi    # 0x178280
movl $0x20, %edx
callq 0x8e40
movl -0x4(%rbp), %edi
leaq 0x1621d7(%rip), %rsi    # 0x178440
movl $0x40, %edx
callq 0x8e40
movl -0x4(%rbp), %edi
leaq 0x162133(%rip), %rsi    # 0x1783b0
movl $0x40, %edx
callq 0x8e40
movl -0x4(%rbp), %edi
leaq 0x1620df(%rip), %rsi    # 0x178370
movl $0x40, %edx
callq 0x8e40
movl -0x4(%rbp), %edi
leaq 0x16207b(%rip), %rsi    # 0x178320
movl $0x4, %edx
callq 0x8e40
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekgun.c
// Function: tekgunload
void
tekgunload(int fil)
{
     read(fil,fireseq,MAXPLAYERS*sizeof(int));
     read(fil,ammo1,MAXPLAYERS*sizeof(short));
     read(fil,ammo2,MAXPLAYERS*sizeof(short));
     read(fil,ammo3,MAXPLAYERS*sizeof(short));
     read(fil,ammo4,MAXPLAYERS*sizeof(short));
     read(fil,ammo5,MAXPLAYERS*sizeof(short));
     read(fil,ammo6,MAXPLAYERS*sizeof(short));
     read(fil,ammo7,MAXPLAYERS*sizeof(short));
     read(fil,ammo8,MAXPLAYERS*sizeof(short));
     read(fil,weapons,MAXPLAYERS*sizeof(int));
     read(fil,firedonetics,MAXPLAYERS*sizeof(int));
     read(fil,lastgun,MAXPLAYERS*sizeof(int));
     read(fil,&goreflag,sizeof(int));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
leaq 0x161fcb(%rip), %rsi    # 0x1782a0
movl $0x40, %edx
callq 0x8a70
movl -0x4(%rbp), %edi
leaq 0x161eb7(%rip), %rsi    # 0x1781a0
movl $0x20, %edx
callq 0x8a70
movl -0x4(%rbp), %edi
leaq 0x161ec3(%rip), %rsi    # 0x1781c0
movl $0x20, %edx
callq 0x8a70
movl -0x4(%rbp), %edi
leaq 0x161ecf(%rip), %rsi    # 0x1781e0
movl $0x20, %edx
callq 0x8a70
movl -0x4(%rbp), %edi
leaq 0x161edb(%rip), %rsi    # 0x178200
movl $0x20, %edx
callq 0x8a70
movl -0x4(%rbp), %edi
leaq 0x161ee7(%rip), %rsi    # 0x178220
movl $0x20, %edx
callq 0x8a70
movl -0x4(%rbp), %edi
leaq 0x161ef3(%rip), %rsi    # 0x178240
movl $0x20, %edx
callq 0x8a70
movl -0x4(%rbp), %edi
leaq 0x161eff(%rip), %rsi    # 0x178260
movl $0x20, %edx
callq 0x8a70
movl -0x4(%rbp), %edi
leaq 0x161f0b(%rip), %rsi    # 0x178280
movl $0x20, %edx
callq 0x8a70
movl -0x4(%rbp), %edi
leaq 0x1620b7(%rip), %rsi    # 0x178440
movl $0x40, %edx
callq 0x8a70
movl -0x4(%rbp), %edi
leaq 0x162013(%rip), %rsi    # 0x1783b0
movl $0x40, %edx
callq 0x8a70
movl -0x4(%rbp), %edi
leaq 0x161fbf(%rip), %rsi    # 0x178370
movl $0x40, %edx
callq 0x8a70
movl -0x4(%rbp), %edi
leaq 0x161f5b(%rip), %rsi    # 0x178320
movl $0x4, %edx
callq 0x8a70
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekmsc.c
// Function: finishpaletteshifts
void
finishpaletteshifts(void)
{
     if( palshifted == 1 ) {
          palshifted = 0;
#if USE_POLYMOST && USE_OPENGL
          if (getrendermode() >= 3)
               setpalettefade(0,0,0,0);
          else
#endif
               setbrightness(brightness,&palette[0],0);
     }

 return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsbl 0x16059d(%rip), %eax    # 0x179cf8
cmpl $0x1, %eax
jne 0x1979a
movb $0x0, 0x160591(%rip)    # 0x179cf8
callq 0x75150
cmpl $0x3, %eax
jl 0x19780
xorl %ecx, %ecx
movl %ecx, %edi
movl %ecx, %esi
movl %ecx, %edx
callq 0x72570
jmp 0x19798
leaq 0x11405b(%rip), %rax    # 0x12d7e2
movswl (%rax), %edi
leaq 0x45cc4f(%rip), %rsi    # 0x4763e0
xorl %edx, %edx
callq 0x67360
jmp 0x1979a
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekmsc.c
// Function: startredflash
int
startredflash(int damage)
{
     if( redcount != 0 )
          return(0);

     redcount=0;

     redcount+=damage;

     if( redcount < 0 ) {
          redcount=0;
     }

     return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x0, 0x1601f2(%rip)    # 0x179cf0
je 0x19b09
movl $0x0, -0x4(%rbp)
jmp 0x19b3c
movl $0x0, 0x1601dd(%rip)    # 0x179cf0
movl -0x8(%rbp), %eax
addl 0x1601d4(%rip), %eax    # 0x179cf0
movl %eax, 0x1601ce(%rip)    # 0x179cf0
cmpl $0x0, 0x1601c7(%rip)    # 0x179cf0
jge 0x19b35
movl $0x0, 0x1601bb(%rip)    # 0x179cf0
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/tekmsc.c
// Function: startwhiteflash
int
startwhiteflash(int bonus)
{
     whitecount = 0;

     whitecount+=bonus;

     if( whitecount < 0 ) {
          whitecount=0;
     }

     return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl $0x0, 0x160193(%rip)    # 0x179cf4
movl -0x4(%rbp), %eax
addl 0x16018a(%rip), %eax    # 0x179cf4
movl %eax, 0x160184(%rip)    # 0x179cf4
cmpl $0x0, 0x16017d(%rip)    # 0x179cf4
jge 0x19b83
movl $0x0, 0x160171(%rip)    # 0x179cf4
xorl %eax, %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekmsc.c
// Function: showmessage
void
showmessage(char *fmt,...)
{
     va_list   vargs;

     memset(messagebuf,   '\0', MSGBUFSIZE);

     va_start(vargs,fmt);
     Bvsnprintf(messagebuf,sizeof(messagebuf),fmt,vargs);
     va_end(vargs);

     messagebuf[MSGBUFSIZE-1]='\0';
     messagex=(xdim>>1)-( (((int)strlen(messagebuf))>>1)*8 );
     if( messagex < 0 )
          messagex=0;
     messageon=1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x1a185
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)
leaq 0x15fb4d(%rip), %rdi    # 0x179d00
xorl %esi, %esi
movl $0x28, %edx
callq 0x8410
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), %rdx
leaq -0x20(%rbp), %rcx
leaq 0x15fb0e(%rip), %rdi    # 0x179d00
movl $0x28, %esi
callq 0x8970
leaq -0x20(%rbp), %rax
movb $0x0, 0x15fb20(%rip)    # 0x179d27
leaq 0x5e5e0e(%rip), %rax    # 0x60001c
movl (%rax), %eax
sarl %eax
movl %eax, -0xd4(%rbp)
leaq 0x15fae1(%rip), %rdi    # 0x179d00
callq 0x8540
movq %rax, %rcx
movl -0xd4(%rbp), %eax
sarl %ecx
shll $0x3, %ecx
subl %ecx, %eax
movl %eax, 0x15faee(%rip)    # 0x179d28
cmpl $0x0, 0x15fae7(%rip)    # 0x179d28
jge 0x1a24d
movl $0x0, 0x15fadb(%rip)    # 0x179d28
movl $0x1, 0x15e271(%rip)    # 0x1784c8
addq $0xe0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekmsc.c
// Function: tekgamestarted
void
tekgamestarted(void)
{
     hcpos=-tilesizx[HCDEVICE];
     wppos=-tilesizx[WPDEVICE];
     rvpos=-tilesizx[RVDEVICE];
     seconds=minutes=hours=0;
     show2dsprite[playersprite[myconnectindex]>>3]|=
          (1<<(playersprite[myconnectindex]&7));
     songmastervolume(musicv<<3);
     soundmastervolume(soundv<<11);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x5eddc5(%rip), %rax    # 0x608050
movswl 0xc38(%rax), %ecx
xorl %eax, %eax
subl %ecx, %eax
movw %ax, 0x15fa8f(%rip)     # 0x179d2c
leaq 0x5eddac(%rip), %rax    # 0x608050
movswl 0xc2e(%rax), %ecx
xorl %eax, %eax
subl %ecx, %eax
movw %ax, 0x15fa78(%rip)     # 0x179d2e
leaq 0x5edd93(%rip), %rax    # 0x608050
movswl 0xc24(%rax), %ecx
xorl %eax, %eax
subl %ecx, %eax
movw %ax, 0x15fa61(%rip)     # 0x179d30
movl $0x0, 0x15e1eb(%rip)    # 0x1784c4
movl $0x0, 0x15e1dd(%rip)    # 0x1784c0
movl $0x0, 0x15e1cf(%rip)    # 0x1784bc
leaq 0x78ac50(%rip), %rax    # 0x7a4f44
movslq (%rax), %rcx
leaq 0x114412(%rip), %rax    # 0x12e710
movswl (%rax,%rcx,2), %ecx
andl $0x7, %ecx
movl $0x1, %edx
shll %cl, %edx
leaq 0x78ac31(%rip), %rax    # 0x7a4f44
movslq (%rax), %rcx
leaq 0x1143f3(%rip), %rax    # 0x12e710
movswl (%rax,%rcx,2), %eax
sarl $0x3, %eax
movslq %eax, %rcx
leaq 0x58afe2(%rip), %rax    # 0x5a5310
movzbl (%rax,%rcx), %eax
orl %edx, %eax
movb %al, %dl
leaq 0x58afd3(%rip), %rax    # 0x5a5310
movb %dl, (%rax,%rcx)
movl 0x100852(%rip), %edi    # 0x11ab98
shll $0x3, %edi
callq 0x27340
movl 0x100848(%rip), %edi    # 0x11ab9c
shll $0xb, %edi
callq 0x27350
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekmsc.c
// Function: netstats
void
netstats()
{
    #ifdef NETNAMES
     int       i;

     if( option[4] != 0 ) {
          for( i=connecthead ; i >= 0 ; i=connectpoint2[i] ) {
              #if 0
               if( score[i] > score[newnetleader] ) {
                    if( score[newnetleader] < NETWINSCORE ) {
                         newnetleader=i;
                    }
               }
              #endif
               if( (toggles[TOGGLE_SCORE]) && (screensize >= xdim) ) {
                    sprintf(tektempbuf,"%2d %10s %6d",i,netnames[i],score[i]);
                    printext(12,(windowy1+32)+(i<<3),tektempbuf,ALPHABET,255);
               }
          }
         #if 0
          if( newnetleader != oldnetleader ) {
               oldnetleader=newnetleader;
          }
          else if( (totalclock-netclock) > 7200 ) {
               netclock=totalclock;
               sprintf(tektempbuf,"%2d %s LEADS",newnetleader,netnames[newnetleader],score[newnetleader]);
               showmessage(tektempbuf);
          }
         #endif
     }
    #endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xfe369(%rip), %rax     # 0x119f18
movzbl 0x4(%rax), %eax
cmpl $0x0, %eax
je 0x1bc77
leaq 0x78938d(%rip), %rax    # 0x7a4f50
movl (%rax), %eax
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0x1bc75
leaq 0xfe427(%rip), %rax     # 0x11a000
cmpl $0x0, 0x8(%rax)
je 0x1bc5d
leaq 0x112f7c(%rip), %rax    # 0x12eb62
movswl (%rax), %eax
leaq 0x5e442c(%rip), %rcx    # 0x60001c
cmpl (%rcx), %eax
jl 0x1bc5d
movl -0x4(%rbp), %edx
movslq -0x4(%rbp), %rax
leaq 0x112a2e(%rip), %rcx    # 0x12e630
imulq $0xb, %rax, %rax
addq %rax, %rcx
movslq -0x4(%rbp), %rsi
leaq 0x15aa2c(%rip), %rax    # 0x176640
movl (%rax,%rsi,4), %r8d
leaq 0x15e201(%rip), %rdi    # 0x179e20
leaq 0xbdd5f(%rip), %rsi     # 0xd9985
movb $0x0, %al
callq 0x8e50
leaq 0x5b0e7c(%rip), %rax    # 0x5ccab0
movl (%rax), %esi
addl $0x20, %esi
movl -0x4(%rbp), %eax
shll $0x3, %eax
addl %eax, %esi
movl $0xc, %edi
leaq 0x15e1d3(%rip), %rdx    # 0x179e20
movl $0x15c, %ecx            # imm = 0x15C
movl $0xff, %r8d
callq 0x9580
jmp 0x1bc5f
movslq -0x4(%rbp), %rcx
leaq 0x7892f6(%rip), %rax    # 0x7a4f60
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
jmp 0x1bbc8
jmp 0x1bc77
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekmsc.c
// Function: tektime
void
tektime(void)
{
     fortieth++;
     if( fortieth == 40 ) {
          fortieth=0;
          seconds++;
     }
     if( seconds == 60 ) {
          minutes++;
          seconds=0;
     }
     if( minutes == 60 ) {
          hours++;
          minutes=0;
     }
     if( hours > 99 ) {
          hours=0;
     }
     if( messageon ) {
          messageon++;
          if( messageon == 160 ) {
               messageon=0;
          }
     }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x15c842(%rip), %eax    # 0x179f4c
addl $0x1, %eax
movl %eax, 0x15c839(%rip)    # 0x179f4c
cmpl $0x28, 0x15c832(%rip)   # 0x179f4c
jne 0x1d735
movl $0x0, 0x15c826(%rip)    # 0x179f4c
movl 0x15ad90(%rip), %eax    # 0x1784bc
addl $0x1, %eax
movl %eax, 0x15ad87(%rip)    # 0x1784bc
cmpl $0x3c, 0x15ad80(%rip)   # 0x1784bc
jne 0x1d757
movl 0x15ad7c(%rip), %eax    # 0x1784c0
addl $0x1, %eax
movl %eax, 0x15ad73(%rip)    # 0x1784c0
movl $0x0, 0x15ad65(%rip)    # 0x1784bc
cmpl $0x3c, 0x15ad62(%rip)   # 0x1784c0
jne 0x1d779
movl 0x15ad5e(%rip), %eax    # 0x1784c4
addl $0x1, %eax
movl %eax, 0x15ad55(%rip)    # 0x1784c4
movl $0x0, 0x15ad47(%rip)    # 0x1784c0
cmpl $0x63, 0x15ad44(%rip)   # 0x1784c4
jle 0x1d78c
movl $0x0, 0x15ad38(%rip)    # 0x1784c4
cmpl $0x0, 0x15ad35(%rip)    # 0x1784c8
je 0x1d7bc
movl 0x15ad2d(%rip), %eax    # 0x1784c8
addl $0x1, %eax
movl %eax, 0x15ad24(%rip)    # 0x1784c8
cmpl $0xa0, 0x15ad1a(%rip)   # 0x1784c8
jne 0x1d7ba
movl $0x0, 0x15ad0e(%rip)    # 0x1784c8
jmp 0x1d7bc
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekmsc.c
// Function: newgame
void
newgame(char *mapname)
{
     int  i;

     if( option[4] != 0 ) {
          return;
     }

     ready2send=0;

     stopallsounds();
     if (strcmp(boardfilename,mapname) != 0) {
          strcpy(boardfilename,mapname);
     }
     initpaletteshifts();
     prepareboard(boardfilename);
     precache();
     for (i=connecthead ; i >= 0 ; i=connectpoint2[i]) {
          initplayersprite((short)i);
     }

     ready2send=1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xfc725(%rip), %rax     # 0x119f18
movzbl 0x4(%rax), %eax
cmpl $0x0, %eax
je 0x1d801
jmp 0x1d889
leaq 0x10ffcb(%rip), %rax    # 0x12d7d3
movb $0x0, (%rax)
movb $0x0, %al
callq 0x27540
movq -0x8(%rbp), %rsi
leaq 0x110fb3(%rip), %rdi    # 0x12e7d0
callq 0x8b90
cmpl $0x0, %eax
je 0x1d837
movq -0x8(%rbp), %rsi
leaq 0x110f9e(%rip), %rdi    # 0x12e7d0
callq 0x8550
callq 0x19830
leaq 0x110f8d(%rip), %rdi    # 0x12e7d0
callq 0x22220
movb $0x0, %al
callq 0x9680
leaq 0x7876fa(%rip), %rax    # 0x7a4f50
movl (%rax), %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x1d87f
movl -0xc(%rbp), %eax
movswl %ax, %edi
callq 0x24f80
movslq -0xc(%rbp), %rcx
leaq 0x7876e9(%rip), %rax    # 0x7a4f60
movl (%rax,%rcx,4), %eax
movl %eax, -0xc(%rbp)
jmp 0x1d85b
leaq 0x10ff4d(%rip), %rax    # 0x12d7d3
movb $0x1, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekmsc.c
// Function: accessiblemap
int
accessiblemap(int mn)
{
     int       i;

     if( (mn < 0) || (mn >= TOTALMAPS) ) {
          return(0);
     }
     if( strlen(mapnames[mn]) < 2 ) {
          return(0);
     }
     for( i=0; i<MAXMAPSPERMISSION; i++ ) {
          if( missionset[mission][i] == mn ) {
               return(1);
          }
     }
     return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jl 0x1d8a7
cmpl $0x20, -0x8(%rbp)
jl 0x1d8b0
movl $0x0, -0x4(%rbp)
jmp 0x1d91e
movslq -0x8(%rbp), %rcx
leaq 0xfd2f5(%rip), %rax     # 0x11abb0
movq (%rax,%rcx,8), %rdi
callq 0x8540
cmpq $0x2, %rax
jae 0x1d8d3
movl $0x0, -0x4(%rbp)
jmp 0x1d91e
movl $0x0, -0xc(%rbp)
cmpl $0x6, -0xc(%rbp)
jge 0x1d917
movslq 0x15abe9(%rip), %rcx    # 0x1784d0
leaq 0xfd3c2(%rip), %rax     # 0x11acb0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x8(%rbp), %eax
jne 0x1d90a
movl $0x1, -0x4(%rbp)
jmp 0x1d91e
jmp 0x1d90c
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1d8da
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekmsc.c
// Function: getloadsavenames
void
getloadsavenames(void)
{
     int  fil,i;

     for (i=0 ; i < MAXLOADSAVEOPTS ; i++) {
          sprintf((char *)tempbuf,"savegam%d.tek",i+1);
          if (access((char *)tempbuf,F_OK) == 0) {
               fil=open((char *)tempbuf,O_BINARY|O_RDONLY,S_IREAD);
               read(fil,&loadsavenames[i],MAXLOADSAVESIZE);
               close(fil);
          }
          else {
               strncpy(loadsavenames[i],"-EMPTY-",MAXLOADSAVESIZE);
          }
     }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x8(%rbp)
cmpl $0x5, -0x8(%rbp)
jge 0x1e0cb
movl -0x8(%rbp), %edx
addl $0x1, %edx
leaq 0x10f93a(%rip), %rdi    # 0x12d970
leaq 0xbb43a(%rip), %rsi     # 0xd9477
movb $0x0, %al
callq 0x8e50
leaq 0x10f925(%rip), %rdi    # 0x12d970
xorl %esi, %esi
callq 0x8180
cmpl $0x0, %eax
jne 0x1e098
leaq 0x10f912(%rip), %rdi    # 0x12d970
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
movb $0x0, %al
callq 0x8600
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %edi
movslq -0x8(%rbp), %rax
leaq 0x15bee3(%rip), %rsi    # 0x179f60
imulq $0xc, %rax, %rax
addq %rax, %rsi
movl $0xc, %edx
callq 0x8a70
movl -0x4(%rbp), %edi
callq 0x8300
jmp 0x1e0bb
movslq -0x8(%rbp), %rax
leaq 0x15bebd(%rip), %rdi    # 0x179f60
imulq $0xc, %rax, %rax
addq %rax, %rdi
leaq 0xbba06(%rip), %rsi     # 0xd9ab7
movl $0xc, %edx
callq 0x8200
jmp 0x1e0bd
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1e01f
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekmsc.c
// Function: showmenu
void
showmenu(void)
{
    if (xdim < 640) {
        rotatesprite(160<<16,100<<16, 65536, 0, MENUSTATION, 0, 0, 2+8, 0, 0, xdim-1, ydim-1);
        rotatesprite(160<<16,100<<16, 65536, 0, MENUGLASS, 0, 0, 1+2+8, 0, 0, xdim-1, ydim-1);
    } else {
        rotatesprite(160<<16,50<<16, divscale15(200, tilesizy[MENUPANEL4801]), 0, MENUPANEL4801, 0, 0, 2+8, 0, 0, xdim-1, ydim-1);
        rotatesprite(160<<16,150<<16, divscale15(200, tilesizy[MENUPANEL4802]), 0, MENUPANEL4802, 0, 0, 2+8, 0, 0, xdim-1, ydim-1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x5e1a1d(%rip), %rax    # 0x60001c
cmpl $0x280, (%rax)          # imm = 0x280
jge 0x1e6d4
leaq 0x5e1a0a(%rip), %rax    # 0x60001c
movl (%rax), %r10d
subl $0x1, %r10d
leaq 0x5e1a00(%rip), %rax    # 0x600020
movl (%rax), %eax
subl $0x1, %eax
movl $0xa00000, %edi         # imm = 0xA00000
movl $0x640000, %esi         # imm = 0x640000
movl $0x10000, %edx          # imm = 0x10000
xorl %r9d, %r9d
movl $0x145, %r8d            # imm = 0x145
movl %r9d, %ecx
movl $0x0, (%rsp)
movl $0xa, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movl $0x0, 0x18(%rsp)
movl %r10d, 0x20(%rsp)
movl %eax, 0x28(%rsp)
callq 0x718a0
leaq 0x5e19a8(%rip), %rax    # 0x60001c
movl (%rax), %r10d
subl $0x1, %r10d
leaq 0x5e199e(%rip), %rax    # 0x600020
movl (%rax), %eax
subl $0x1, %eax
movl $0xa00000, %edi         # imm = 0xA00000
movl $0x640000, %esi         # imm = 0x640000
movl $0x10000, %edx          # imm = 0x10000
xorl %r9d, %r9d
movl $0x146, %r8d            # imm = 0x146
movl %r9d, %ecx
movl $0x0, (%rsp)
movl $0xb, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movl $0x0, 0x18(%rsp)
movl %r10d, 0x20(%rsp)
movl %eax, 0x28(%rsp)
callq 0x718a0
jmp 0x1e7c2
leaq 0x5db135(%rip), %rax    # 0x5f9810
movswl 0xbf2(%rax), %esi
movl $0xc8, %edi
callq 0x1e7d0
movl %eax, %edx
leaq 0x5e1927(%rip), %rax    # 0x60001c
movl (%rax), %r10d
subl $0x1, %r10d
leaq 0x5e191d(%rip), %rax    # 0x600020
movl (%rax), %eax
subl $0x1, %eax
movl $0xa00000, %edi         # imm = 0xA00000
movl $0x320000, %esi         # imm = 0x320000
xorl %r9d, %r9d
movl $0x5f9, %r8d            # imm = 0x5F9
movl %r9d, %ecx
movl $0x0, (%rsp)
movl $0xa, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movl $0x0, 0x18(%rsp)
movl %r10d, 0x20(%rsp)
movl %eax, 0x28(%rsp)
callq 0x718a0
leaq 0x5db0be(%rip), %rax    # 0x5f9810
movswl 0xbf4(%rax), %esi
movl $0xc8, %edi
callq 0x1e7d0
movl %eax, %edx
leaq 0x5e18b0(%rip), %rax    # 0x60001c
movl (%rax), %r10d
subl $0x1, %r10d
leaq 0x5e18a6(%rip), %rax    # 0x600020
movl (%rax), %eax
subl $0x1, %eax
movl $0xa00000, %edi         # imm = 0xA00000
movl $0x960000, %esi         # imm = 0x960000
xorl %r9d, %r9d
movl $0x5fa, %r8d            # imm = 0x5FA
movl %r9d, %ecx
movl $0x0, (%rsp)
movl $0xa, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movl $0x0, 0x18(%rsp)
movl %r10d, 0x20(%rsp)
movl %eax, 0x28(%rsp)
callq 0x718a0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekmsc.c
// Function: showhelpscreen
void
showhelpscreen(void)
{
    if (xdim < 640) {
        rotatesprite(160<<16,160<<16, 65536, 0, HELPSCREENPIC, 0, 0, 2+8, 0, 0, xdim-1, ydim-1);
    } else {
        rotatesprite(160<<16,50<<16, divscale15(200, tilesizy[HELPSCREEN4801]), 0, HELPSCREEN4801, 0, 0, 2+8, 0, 0, xdim-1, ydim-1);
        rotatesprite(160<<16,150<<16, divscale15(200, tilesizy[HELPSCREEN4802]), 0, HELPSCREEN4802, 0, 0, 2+8, 0, 0, xdim-1, ydim-1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x5e181d(%rip), %rax    # 0x60001c
cmpl $0x280, (%rax)          # imm = 0x280
jge 0x1e86b
leaq 0x5e180e(%rip), %rax    # 0x60001c
movl (%rax), %r10d
subl $0x1, %r10d
leaq 0x5e1804(%rip), %rax    # 0x600020
movl (%rax), %eax
subl $0x1, %eax
movl $0xa00000, %esi         # imm = 0xA00000
movl $0x10000, %edx          # imm = 0x10000
xorl %r9d, %r9d
movl $0x3d5, %r8d            # imm = 0x3D5
movl %esi, %edi
movl %r9d, %ecx
movl $0x0, (%rsp)
movl $0xa, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movl $0x0, 0x18(%rsp)
movl %r10d, 0x20(%rsp)
movl %eax, 0x28(%rsp)
callq 0x718a0
jmp 0x1e959
leaq 0x5daf9e(%rip), %rax    # 0x5f9810
movswl 0x7ac(%rax), %esi
movl $0xc8, %edi
callq 0x1e7d0
movl %eax, %edx
leaq 0x5e1790(%rip), %rax    # 0x60001c
movl (%rax), %r10d
subl $0x1, %r10d
leaq 0x5e1786(%rip), %rax    # 0x600020
movl (%rax), %eax
subl $0x1, %eax
movl $0xa00000, %edi         # imm = 0xA00000
movl $0x320000, %esi         # imm = 0x320000
xorl %r9d, %r9d
movl $0x3d6, %r8d            # imm = 0x3D6
movl %r9d, %ecx
movl $0x0, (%rsp)
movl $0xa, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movl $0x0, 0x18(%rsp)
movl %r10d, 0x20(%rsp)
movl %eax, 0x28(%rsp)
callq 0x718a0
leaq 0x5daf27(%rip), %rax    # 0x5f9810
movswl 0x7ae(%rax), %esi
movl $0xc8, %edi
callq 0x1e7d0
movl %eax, %edx
leaq 0x5e1719(%rip), %rax    # 0x60001c
movl (%rax), %r10d
subl $0x1, %r10d
leaq 0x5e170f(%rip), %rax    # 0x600020
movl (%rax), %eax
subl $0x1, %eax
movl $0xa00000, %edi         # imm = 0xA00000
movl $0x960000, %esi         # imm = 0x960000
xorl %r9d, %r9d
movl $0x3d7, %r8d            # imm = 0x3D7
movl %r9d, %ecx
movl $0x0, (%rsp)
movl $0xa, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movl $0x0, 0x18(%rsp)
movl %r10d, 0x20(%rsp)
movl %eax, 0x28(%rsp)
callq 0x718a0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekmsc.c
// Function: usage
void
usage()
{
     printf("\ntekwar [option1] [option2] .... [optionN]\n");
     printf("options:    practice\n");
     printf("            nogore\n");
     printf("            nobriefs\n");
     printf("            netname [NAME]\n");
     printf("            noenemies\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xba760(%rip), %rdi     # 0xd9b0b
movb $0x0, %al
callq 0x80b0
leaq 0xba77e(%rip), %rdi     # 0xd9b37
movb $0x0, %al
callq 0x80b0
leaq 0xba786(%rip), %rdi     # 0xd9b4d
movb $0x0, %al
callq 0x80b0
leaq 0xba78c(%rip), %rdi     # 0xd9b61
movb $0x0, %al
callq 0x80b0
leaq 0xba794(%rip), %rdi     # 0xd9b77
movb $0x0, %al
callq 0x80b0
leaq 0xba7a2(%rip), %rdi     # 0xd9b93
movb $0x0, %al
callq 0x80b0
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekmsc.c
// Function: tekloadmoreoptions
void
tekloadmoreoptions(void)
{
     toggles[TOGGLE_GODMODE]=0;
     if (toggles[TOGGLE_REARVIEW]) {
          rvmoving=1;
     }
     if (toggles[TOGGLE_UPRT]) {
          wpmoving=1;
     }
     if (toggles[TOGGLE_HEALTH]) {
          hcmoving=1;
     }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xfa7d5(%rip), %rax     # 0x11a000
movl $0x0, 0x1c(%rax)
leaq 0xfa7c7(%rip), %rax     # 0x11a000
cmpl $0x0, 0x14(%rax)
je 0x1f849
movl $0x1, 0x15a5b7(%rip)    # 0x179e00
leaq 0xfa7b0(%rip), %rax     # 0x11a000
cmpl $0x0, 0x18(%rax)
je 0x1f860
movl $0x1, 0x15a5a4(%rip)    # 0x179e04
leaq 0xfa799(%rip), %rax     # 0x11a000
cmpl $0x0, 0x20(%rax)
je 0x1f877
movl $0x1, 0x15a591(%rip)    # 0x179e08
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jonof[P]jftekwar/src/tekmsc.c
// Function: initmoreoptions
void
initmoreoptions()
{
     difficulty=moreoptions[8];
     soundv=moreoptions[9];
     musicv=moreoptions[10];
     mousesensitivity=moreoptions[11];
     headbobon=moreoptions[12];

     screensize=gamestuff[2];
     brightness=gamestuff[3];
     biasthreshhold=gamestuff[4];

     if( option[4] != 0 ) {
          difficulty=2;
     }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xfa715(%rip), %rax     # 0x119fa0
movl 0x20(%rax), %eax
movl %eax, 0x15a734(%rip)    # 0x179fc8
leaq 0xfa705(%rip), %rax     # 0x119fa0
movl 0x24(%rax), %eax
movl %eax, 0xfb2f8(%rip)     # 0x11ab9c
leaq 0xfa6f5(%rip), %rax     # 0x119fa0
movl 0x28(%rax), %eax
movl %eax, 0xfb2e4(%rip)     # 0x11ab98
leaq 0xfa6e5(%rip), %rax     # 0x119fa0
movl 0x2c(%rax), %eax
movl %eax, 0x15a6fc(%rip)    # 0x179fc0
leaq 0xfa6d5(%rip), %rax     # 0x119fa0
movl 0x30(%rax), %ecx
leaq 0xfb5ab(%rip), %rax     # 0x11ae80
movl %ecx, (%rax)
leaq 0xfa762(%rip), %rax     # 0x11a040
movl 0x8(%rax), %eax
movw %ax, %cx
leaq 0x10f277(%rip), %rax    # 0x12eb62
movw %cx, (%rax)
leaq 0xfa74b(%rip), %rax     # 0x11a040
movl 0xc(%rax), %eax
movw %ax, %cx
leaq 0x10dee0(%rip), %rax    # 0x12d7e2
movw %cx, (%rax)
leaq 0xfa734(%rip), %rax     # 0x11a040
movl 0x10(%rax), %eax
movw %ax, %cx
leaq 0xfa5e9(%rip), %rax     # 0x119f02
movw %cx, (%rax)
leaq 0xfa5f5(%rip), %rax     # 0x119f18
movzbl 0x4(%rax), %eax
cmpl $0x0, %eax
je 0x1f936
movl $0x2, 0x15a692(%rip)    # 0x179fc8
popq %rbp
retq
nopl (%rax,%rax)