LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/mincebert[P]maketzx/maketzx.c
// Function: Instructions
void Instructions(void)
{
  printf("Translates VOC files in TZX format for ZX Spectrum emulators\n\n");
  printf("Syntax: MAKETZX <inputfile> [outputfile] [switches]\n\n");
  printf("Switches:\n\n");
  printf("   -n: operate in normal mode         -s n: use Speedlock type n algorithm\n");
  printf("   -a: use Alkatraz algorithm         -k n: skip n blocks before considering\n");
  printf("   -f: use Softlock algorithm               specific loaders\n");
  printf("   -b: use Bleepload algorithm        -x: display file informations in hex\n");
  printf("   -z: use ZetaLoad algorithm         -q: disable hi-fi reproduction tones\n");
  printf("   -l: enable logfile generation      -r: use TZX revision 1.01\n\n");
/*printf("          -digital : use Digital Integrations algorithm and timings\n");*/
  exit(0);
}

// Assembly:
pushq %rax
leaq 0x975b(%rip), %rdi      # 0xb3cd
callq 0x1070
leaq 0x978d(%rip), %rdi      # 0xb40b
callq 0x1070
leaq 0x97b6(%rip), %rdi      # 0xb440
callq 0x1070
leaq 0x97b5(%rip), %rdi      # 0xb44b
callq 0x1070
leaq 0x97f4(%rip), %rdi      # 0xb496
callq 0x1070
leaq 0x9835(%rip), %rdi      # 0xb4e3
callq 0x1070
leaq 0x9866(%rip), %rdi      # 0xb520
callq 0x1070
leaq 0x98a5(%rip), %rdi      # 0xb56b
callq 0x1070
leaq 0x98e4(%rip), %rdi      # 0xb5b6
callq 0x1070
xorl %edi, %edi
callq 0x1160
// File: /workspace/github_c_makefile_star2_O2/mincebert[P]maketzx/maketzx.c
// Function: End
void End(void)
{
  if (tempfile.bufpoint) Flush(&tempfile);
  CloseFiles();
  remove(tempfile.name);
  printf("\nDone!\n\n");
  exit(0);
}

// Assembly:
pushq %rax
cmpl $0x0, 0x158a8(%rip)     # 0x175a8
je 0x1d0e
leaq 0x1579f(%rip), %rdi     # 0x174a8
callq 0x15d2
callq 0x1597
leaq 0x1578f(%rip), %rdi     # 0x174a9
callq 0x1050
leaq 0x98d1(%rip), %rdi      # 0xb5f7
callq 0x1070
xorl %edi, %edi
callq 0x1160
// File: /workspace/github_c_makefile_star2_O2/mincebert[P]maketzx/maketzx.c
// Function: GetData
byte GetData(fdata* record)
{
  byte value;                       /* WHAT A MESS!!!!! */
  (*record).bufpoint&=0x3fff;
  if (!((*record).bufpoint)) (*record).xferred+=read((*record).handle,(*record).buffer,sizeof((*record).buffer));
  value=(*record).buffer[(*record).bufpoint];
  (*record).bufpoint++;
  filepos++;
  if (filepos>inpfile.length && blocktype) blocktype=0;
  return value;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x3fff, %ecx           # imm = 0x3FFF
andl 0x100(%rdi), %ecx
movl %ecx, 0x100(%rdi)
jne 0x1d6a
movzbl (%rbx), %edi
leaq 0x118(%rbx), %rsi
movl $0x4000, %edx           # imm = 0x4000
callq 0x1100
addq %rax, 0x110(%rbx)
movl 0x100(%rbx), %ecx
movl %ecx, %eax
movb 0x118(%rbx,%rax), %al
incl %ecx
movl %ecx, 0x100(%rbx)
movq 0xd456(%rip), %rcx      # 0xf1d8
incq %rcx
movq %rcx, 0xd44c(%rip)      # 0xf1d8
cmpq 0xd5e5(%rip), %rcx      # 0xf378
jbe 0x1da5
cmpb $0x0, 0x19915(%rip)     # 0x1b6b1
je 0x1da5
movb $0x0, 0x1990c(%rip)     # 0x1b6b1
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/mincebert[P]maketzx/maketzx.c
// Function: PutData
void PutData(fdata* record,byte value,word dimension)
{
  word count;                                  /* WHAT A MESS!!!!! */
  for (count=0; count<dimension; count++)
      {
	(*record).buffer[((*record).bufpoint)]=value;
	(*record).bufpoint++;
	(*record).bufpoint&=0x3fff;
	if (!(*record).bufpoint)
	   (*record).xferred+=write((*record).handle,(*record).buffer,sizeof(*record).buffer);
      }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x118(%rdi), %r15
subl $0x1, %ebx
jb 0x1dfa
movl 0x100(%r14), %eax
movb %bpl, 0x118(%r14,%rax)
incl %eax
andl $0x3fff, %eax           # imm = 0x3FFF
movl %eax, 0x100(%r14)
jne 0x1dbc
movzbl (%r14), %edi
movl $0x4000, %edx           # imm = 0x4000
movq %r15, %rsi
callq 0x1080
addq %rax, 0x110(%r14)
jmp 0x1dbc
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mincebert[P]maketzx/maketzx.c
// Function: ReadVOCBlock
void ReadVOCBlock(void)
{
  blocktype=GetData(&inpfile);
  if (!blocktype) return;
  if (blocktype>8)
     Error(5);
  switch (blocktype)
	 {
	 case 1  : ProcessVOCData(); break;
	 case 2  : ProcessContinue(); break;
	 case 3  : ProcessSilence(); break;
	 case 4  : ProcessMarker(); break;
	 case 5  : ProcessASCII(); break;
	 case 8  : ProcessExtended(); break;
	 default : printf("\nSorry, block type %d of VOC files is not yet supported\n\n",blocktype);
		   CloseFiles();
		   exit(1);
	 }
}

// Assembly:
pushq %rax
leaq 0xd294(%rip), %rdi      # 0xf270
callq 0x1d32
movb %al, 0x196ca(%rip)      # 0x1b6b1
testb %al, %al
je 0x2010
cmpb $0x9, %al
jae 0x2030
movzbl %al, %esi
leal -0x1(%rsi), %eax
cmpl $0x7, %eax
ja 0x2038
leaq 0x80af(%rip), %rcx      # 0xa0b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
popq %rax
jmp 0x20d0
popq %rax
retq
popq %rax
jmp 0x22ba
popq %rax
jmp 0x2186
popq %rax
jmp 0x2300
popq %rax
jmp 0x21cc
popq %rax
jmp 0x2274
pushq $0x5
popq %rdi
callq 0x13ed
leaq 0x855f(%rip), %rdi      # 0xa59e
xorl %eax, %eax
callq 0x10b0
callq 0x1597
pushq $0x1
popq %rdi
callq 0x1160
// File: /workspace/github_c_makefile_star2_O2/mincebert[P]maketzx/maketzx.c
// Function: ReadVOCData
byte ReadVOCData(void)
{
  if (!(blocklength-processed))
  do {
       processed=0;
       ReadVOCBlock();
       if (!blocktype) return 0;
     }
  while (blocktype==8 || blocktype==3);
  processed++;
  if (blocktype==8 || blocktype==3) processed+=3;
  totalread++;
  return(GetData(&inpfile));
}

// Assembly:
movq 0xd15e(%rip), %rcx      # 0xf1b8
cmpq %rcx, 0xd14f(%rip)      # 0xf1b0
jne 0x208c
pushq %rax
andq $0x0, 0xd14c(%rip)      # 0xf1b8
callq 0x1fd4
movzbl 0x19639(%rip), %eax     # 0x1b6b1
cmpl $0x3, %eax
je 0x2064
cmpl $0x8, %eax
je 0x2064
testl %eax, %eax
leaq 0x8(%rsp), %rsp
jne 0x2094
retq
movb 0x1961f(%rip), %al      # 0x1b6b1
jmp 0x209b
movq 0xd11d(%rip), %rcx      # 0xf1b8
leaq 0x1(%rcx), %rdx
movq %rdx, 0xd112(%rip)      # 0xf1b8
cmpb $0x8, %al
je 0x20b2
movzbl %al, %eax
cmpl $0x3, %eax
jne 0x20bd
addq $0x4, %rcx
movq %rcx, 0xd0fb(%rip)      # 0xf1b8
incq 0xd0fc(%rip)            # 0xf1c0
leaq 0xd1a5(%rip), %rdi      # 0xf270
jmp 0x1d32
// File: /workspace/github_c_makefile_star2_O2/mincebert[P]maketzx/maketzx.c
// Function: ProcessVOCData
void ProcessVOCData(void)
{
  byte brate;
  word timeconst;
  dword data;
  blocklength=(byte)GetData(&inpfile);
  blocklength+=(word)(256*GetData(&inpfile));
  blocklength+=(dword)(65536*GetData(&inpfile));
  blocklength-=2;
  brate=GetData(&inpfile);
  compression=GetData(&inpfile);
  if (compression) { printf("\nSorry, compressed blocks are not yet supported\n\n"); }
  timeconst=65536-(word)(brate*256);
  if (brate>0xd3) timeconst-=0x54;
  samprate=(double)(256000000/timeconst);
  SetTimings();
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
leaq 0xd196(%rip), %rbx      # 0xf270
movq %rbx, %rdi
callq 0x1d32
movzbl %al, %eax
movq %rax, 0xd0c4(%rip)      # 0xf1b0
movq %rbx, %rdi
callq 0x1d32
movzbl %al, %eax
shll $0x8, %eax
addq %rax, 0xd0af(%rip)      # 0xf1b0
movq %rbx, %rdi
callq 0x1d32
movzbl %al, %eax
shll $0x10, %eax
movq 0xd09a(%rip), %rcx      # 0xf1b0
addq %rcx, %rax
addq $-0x2, %rax
movq %rax, 0xd08c(%rip)      # 0xf1b0
movq %rbx, %rdi
callq 0x1d32
movl %eax, %ebp
movq %rbx, %rdi
callq 0x1d32
movb %al, 0xd08c(%rip)       # 0xf1c8
testb %al, %al
je 0x214c
leaq 0x94e6(%rip), %rdi      # 0xb62d
callq 0x1070
cmpb $-0x2c, %bpl
movl $0xffac, %eax           # imm = 0xFFAC
movl $0x10000, %ecx          # imm = 0x10000
cmovael %eax, %ecx
movzbl %bpl, %eax
shll $0x8, %eax
subl %eax, %ecx
movl $0xf424000, %eax        # imm = 0xF424000
xorl %edx, %edx
divl %ecx
cvtsi2ss %eax, %xmm0
movss %xmm0, 0xd065(%rip)     # 0xf1e0
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2397
// File: /workspace/github_c_makefile_star2_O2/mincebert[P]maketzx/maketzx.c
// Function: ProcessSilence
void ProcessSilence(void)
{
  byte silrate;
  word sillength,timeconst;
  blocklength=(byte)GetData(&inpfile);
  blocklength+=(word)(256*GetData(&inpfile));
  blocklength+=(dword)(65536*GetData(&inpfile));
  sillength=(byte)GetData(&inpfile);
  sillength+=(word)(256*GetData(&inpfile));
  silrate=GetData(&inpfile);
  timeconst=65536-(word)(silrate*256);
  silence=sillength/((double)256000000/timeconst)*1000;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
leaq 0xd099(%rip), %rbx      # 0xf270
movq %rbx, %rdi
callq 0x1d32
movzbl %al, %eax
movq %rax, 0xcfc7(%rip)      # 0xf1b0
movq %rbx, %rdi
callq 0x1d32
movzbl %al, %eax
shll $0x8, %eax
addq %rax, 0xcfb2(%rip)      # 0xf1b0
movq %rbx, %rdi
callq 0x1d32
movzbl %al, %eax
shll $0x10, %eax
addq %rax, 0xcf9d(%rip)      # 0xf1b0
movq %rbx, %rdi
callq 0x1d32
movzbl %al, %ebp
movq %rbx, %rdi
callq 0x1d32
movzbl %al, %r14d
shll $0x8, %r14d
orl %ebp, %r14d
movq %rbx, %rdi
callq 0x1d32
movzbl %al, %eax
shll $0x8, %eax
movl $0x10000, %ecx          # imm = 0x10000
subl %eax, %ecx
cvtsi2sd %r14d, %xmm0
cvtsi2sd %ecx, %xmm1
movsd 0x8019(%rip), %xmm2     # 0xa270
divsd %xmm1, %xmm2
divsd %xmm2, %xmm0
mulsd 0x8011(%rip), %xmm0     # 0xa278
movsd %xmm0, 0xcf61(%rip)     # 0xf1d0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mincebert[P]maketzx/maketzx.c
// Function: ProcessExtended
void ProcessExtended(void)
{
  word timeconst;
  blocklength=(byte)GetData(&inpfile);
  blocklength+=(word)(256*GetData(&inpfile));
  blocklength+=(dword)(65536*GetData(&inpfile));
  timeconst=GetData(&inpfile);
  timeconst+=256*(GetData(&inpfile));
  if (GetData(&inpfile)) Error(6);
  if (GetData(&inpfile))
     {
       printf("\nSorry, stereo VOC files are not yet supported\n\n");
       CloseFiles();
       exit(1);
     }
  SetTimings();
}

// Assembly:
pushq %rbx
leaq 0xcf68(%rip), %rbx      # 0xf270
movq %rbx, %rdi
callq 0x1d32
movzbl %al, %eax
movq %rax, 0xce96(%rip)      # 0xf1b0
movq %rbx, %rdi
callq 0x1d32
movzbl %al, %eax
shll $0x8, %eax
addq %rax, 0xce81(%rip)      # 0xf1b0
movq %rbx, %rdi
callq 0x1d32
movzbl %al, %eax
shll $0x10, %eax
addq %rax, 0xce6c(%rip)      # 0xf1b0
movq %rbx, %rdi
callq 0x1d32
movq %rbx, %rdi
callq 0x1d32
movq %rbx, %rdi
callq 0x1d32
testb %al, %al
jne 0x2376
leaq 0xcf09(%rip), %rdi      # 0xf270
callq 0x1d32
testb %al, %al
jne 0x237e
popq %rbx
jmp 0x2397
pushq $0x6
popq %rdi
callq 0x13ed
leaq 0x92d9(%rip), %rdi      # 0xb65e
callq 0x1070
callq 0x1597
pushq $0x1
popq %rdi
callq 0x1160
// File: /workspace/github_c_makefile_star2_O2/mincebert[P]maketzx/maketzx.c
// Function: SetTimings
void SetTimings(void)
{
  TuneRates(&pilot);
  TuneRates(&syncx);
  TuneRates(&bit0);
  TuneRates(&bit1);
}

// Assembly:
pushq %rax
leaq 0x19389(%rip), %rdi     # 0x1b728
callq 0x23c9
leaq 0x1939d(%rip), %rdi     # 0x1b748
callq 0x23c9
leaq 0x193b1(%rip), %rdi     # 0x1b768
callq 0x23c9
leaq 0x193c5(%rip), %rdi     # 0x1b788
popq %rax
jmp 0x23c9
// File: /workspace/github_c_makefile_star2_O2/mincebert[P]maketzx/maketzx.c
// Function: TuneRates
void TuneRates(wdata* record)
{
 if (samprate && (*record).freq)
    {
      (*record).tstates=(word)(3500000/(2*(*record).freq));
      (*record).samples=(double)(samprate/(*record).freq); //-((*record).freq/100*correction)));
      (*record).rfreq=(float)(samprate/(*record).samples);
    }
}

// Assembly:
movss 0xce0f(%rip), %xmm0     # 0xf1e0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x23db
jnp 0x2428
movsd (%rdi), %xmm1
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm1
jne 0x23eb
jnp 0x2428
movapd %xmm1, %xmm2
addsd %xmm1, %xmm2
movsd 0x7e85(%rip), %xmm3     # 0xa280
divsd %xmm2, %xmm3
cvttsd2si %xmm3, %rax
movl %eax, 0x18(%rdi)
cvtss2sd %xmm0, %xmm0
movaps %xmm0, %xmm2
divsd %xmm1, %xmm2
movsd %xmm2, 0x10(%rdi)
divsd %xmm2, %xmm0
cvtsd2ss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x8(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/mincebert[P]maketzx/maketzx.c
// Function: WriteTZXPulseSequence
void WriteTZXPulseSequence(byte pulsenum)
{
  byte count;
  pulses[1]=pulsenum;
  for (count=0; count<sizeof(pulses); count++) PutData(&outfile,pulses[count],1);
  for (count=0; count<pulsenum; count++)
      {
	PutData(&outfile,Lo(pulseseq[count]),1);
	PutData(&outfile,Hi(pulseseq[count]),1);
      }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edi, %ebx
movb %bl, 0xbfbc(%rip)       # 0xf169
xorl %r15d, %r15d
leaq 0xbfb1(%rip), %r12      # 0xf168
leaq 0x101ca(%rip), %r14     # 0x13388
pushq $0x1
popq %rbp
cmpq $0x2, %r15
je 0x31db
movzbl (%r15,%r12), %esi
movq %r14, %rdi
movl %ebp, %edx
callq 0x1da7
incq %r15
jmp 0x31c1
movzbl %bl, %r14d
shll $0x2, %r14d
xorl %r15d, %r15d
leaq 0x185c3(%rip), %r12     # 0x1b7b0
leaq 0x10194(%rip), %rbx     # 0x13388
pushq $0x1
popq %rbp
cmpq %r15, %r14
je 0x3221
movzbl (%r15,%r12), %esi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x1da7
movzbl 0x1(%r15,%r12), %esi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x1da7
addq $0x4, %r15
jmp 0x31f7
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mincebert[P]maketzx/maketzx.c
// Function: FindPause
dword FindPause(void)
{
  dword hpulse;
  double detfreq;
  PushFilePointers();
  FindingPause=1;
  printf("Finding pause...     \x0d");
//  do detfreq=BeepSearch(50);
//  while (abs(detfreq-808)>150 && blocktype);
//  if (!blocktype) return 0;
  hpulse=PilotSearch(50)/ecf;
  FindingPause=0;
  if (blocktype)
     {
       PopFilePointers();
       lseek(inpfile.handle,filepos,SEEK_SET);
       inpfile.bufpoint=0;
     }
  printf("                     \x0d");
  if (silence) { mspause+=silence; silence=0; }

  return hpulse;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
callq 0x1618
movb $0x1, 0xb032(%rip)      # 0xf1aa
leaq 0x67d9(%rip), %rdi      # 0xa958
xorl %eax, %eax
callq 0x10b0
pushq $0x32
popq %rdi
callq 0x2a7c
movq %rax, %rbx
movsd 0xaf4f(%rip), %xmm0     # 0xf0e8
movsd %xmm0, 0x8(%rsp)
movb $0x0, 0xb004(%rip)      # 0xf1aa
cmpb $0x0, 0x17504(%rip)     # 0x1b6b1
je 0x41d0
callq 0x16b7
movzbl 0xb0b5(%rip), %edi      # 0xf270
movq 0xb016(%rip), %rsi      # 0xf1d8
xorl %edx, %edx
callq 0x10d0
andl $0x0, 0xb1a0(%rip)      # 0xf370
leaq 0x6798(%rip), %rdi      # 0xa96f
xorl %eax, %eax
callq 0x10b0
movsd 0xafea(%rip), %xmm0     # 0xf1d0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x41f2
jnp 0x420a
addsd 0xb016(%rip), %xmm0     # 0xf210
movsd %xmm0, 0xb00e(%rip)     # 0xf210
andq $0x0, 0xafc6(%rip)      # 0xf1d0
movq %rbx, %xmm0
punpckldq 0x61f9(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x6201(%rip), %xmm0     # 0xa420
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
divsd 0x8(%rsp), %xmm1
cvttsd2si %xmm1, %rcx
movq %rcx, %rdx
subsd 0x60c7(%rip), %xmm1     # 0xa308
cvttsd2si %xmm1, %rax
sarq $0x3f, %rdx
andq %rdx, %rax
orq %rcx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/mincebert[P]maketzx/maketzx.c
// Function: GetBleeploadInfo
void GetBleeploadInfo(word length)
{
  word count;
  PushFilePointers();
  ResetTempFile();
  GetData(&tempfile);
  for (count=0; count<length; count++) { bleepblock[count]=GetData(&tempfile); }
  nxtloadpos=bleepblock[0x102]+256*bleepblock[0x103];
  expectedlength=0x109+(bleepblock[0x104+bleepblock[0x104]+4]&7)+3;
  ResetTempFile();
  PopFilePointers();
//  RecoverFilePointers();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edi, %ebp
callq 0x1618
callq 0x15e9
leaq 0x12b0e(%rip), %rbx     # 0x174a8
movq %rbx, %rdi
callq 0x1d32
movl %ebp, %r15d
xorl %r12d, %r12d
leaq 0x17251(%rip), %r14     # 0x1bc00
cmpq %r12, %r15
je 0x49c5
movq %rbx, %rdi
callq 0x1d32
movb %al, (%r12,%r14)
incq %r12
jmp 0x49af
movzwl 0x17336(%rip), %eax     # 0x1bd02
movl %eax, 0xa82e(%rip)      # 0xf200
movzbl 0x1732b(%rip), %eax     # 0x1bd04
movzbl 0x108(%rax,%r14), %eax
andl $0x7, %eax
addl $0x10c, %eax            # imm = 0x10C
movl %eax, 0xa814(%rip)      # 0xf204
callq 0x15e9
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x16b7
// File: /workspace/github_c_makefile_star2_O2/mincebert[P]maketzx/maketzx.c
// Function: SearchBleeploadGroup3
byte SearchBleeploadGroup3(void)
{
  PushFilePointers();
  expectedlength=0x10b;
  searching=1;
  ReadBleeploadBlock();
  searching=0;
  if (!blocktype) return blocktype;
  PopFilePointers();
  lseek(inpfile.handle,filepos,SEEK_SET);
  inpfile.bufpoint=0;
  return DataLoadOK;
}

// Assembly:
pushq %rax
callq 0x1618
movl $0x10b, 0x9d27(%rip)    # imm = 0x10B
movb $0x1, 0x9d3e(%rip)      # 0xf222
callq 0x4704
movb $0x0, 0x9d32(%rip)      # 0xf222
cmpb $0x0, 0x161ba(%rip)     # 0x1b6b1
je 0x5522
callq 0x16b7
movzbl 0x9d6b(%rip), %edi      # 0xf270
movq 0x9ccc(%rip), %rsi      # 0xf1d8
xorl %edx, %edx
callq 0x10d0
andl $0x0, 0x9e56(%rip)      # 0xf370
movb 0x166b9(%rip), %al      # 0x1bbd9
jmp 0x5524
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/mincebert[P]maketzx/maketzx.c
// Function: StoreBleeploadCode
void StoreBleeploadCode(word length)
{
  word count;
  PushFilePointers();
  if (length>512) Error(14);
  ResetTempFile();
  GetData(&tempfile);
  for (count=0; count<length; count++)
      { bleeploader[count]=GetData(&tempfile); }
  for (count=1; count<length-3; count++)
      {
	if (bleeploader[count]==0x32 && bleeploader[count+1]==0x15 && bleeploader[count+2]==0xff)
	   { expectedlength=0x109+2+bleeploader[count-1]; break;}
      }
  ResetTempFile();
  PopFilePointers();
//  RecoverFilePointers();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edi, %ebx
callq 0x1618
cmpl $0x201, %ebx            # imm = 0x201
jae 0x55c7
callq 0x15e9
leaq 0x11f5a(%rip), %r14     # 0x174a8
movq %r14, %rdi
callq 0x1d32
movl %ebx, %r12d
xorl %r13d, %r13d
leaq 0x167bd(%rip), %r15     # 0x1bd20
cmpq %r13, %r12
je 0x557a
movq %r14, %rdi
callq 0x1d32
movb %al, (%r13,%r15)
incq %r13
jmp 0x5563
addl $-0x3, %ebx
pushq $0x1
popq %rax
cmpq %rbx, %rax
jae 0x55b4
cmpb $0x32, (%rax,%r15)
jne 0x559e
cmpb $0x15, 0x1(%rax,%r15)
jne 0x559e
leal 0x2(%rax), %ecx
cmpb $-0x1, (%rcx,%r15)
je 0x55a3
incq %rax
jmp 0x5580
movzbl -0x1(%rax,%r15), %eax
addl $0x10b, %eax            # imm = 0x10B
movl %eax, 0x9c50(%rip)      # 0xf204
callq 0x15e9
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x16b7
pushq $0xe
popq %rdi
callq 0x13ed
// File: /workspace/github_c_makefile_star2_O2/mincebert[P]maketzx/maketzx.c
// Function: ReadSoftlockFirstBlock
word ReadSoftlockFirstBlock(void)
{
  dword loaded;
  pilot.freq=808;
  syncx.freq=2450;
  bit0.freq=2600;
  bit1.freq=1300;
  SetTimings();
  pilotlength=0;
  DataLoadOK=0;
  while (!DataLoadOK)
	{
	  PilotSearch(256);
	  if (!blocktype) return 0; if (!PilotLinkingOK) { pilotlength=0; return 0;}
	  mspause=0;
	  SyncSearch();
	  if (!blocktype) return 0; if (!SyncLoadOK) return 0;
	  loaded=DataRead(bit0.samples,bit1.samples,expectedlength);
	}
  return loaded;
}

// Assembly:
pushq %rbx
movabsq $0x4089400000000000, %rax # imm = 0x4089400000000000
movq %rax, 0x16147(%rip)     # 0x1b728
movabsq $0x40a3240000000000, %rax # imm = 0x40A3240000000000
movq %rax, 0x16156(%rip)     # 0x1b748
movabsq $0x40a4500000000000, %rax # imm = 0x40A4500000000000
movq %rax, 0x16165(%rip)     # 0x1b768
movabsq $0x4094500000000000, %rax # imm = 0x4094500000000000
movq %rax, 0x16174(%rip)     # 0x1b788
callq 0x2397
andq $0x0, 0x165af(%rip)     # 0x1bbd0
movb $0x0, 0x165b1(%rip)     # 0x1bbd9
xorl %eax, %eax
testb %al, %al
jne 0x5699
movl $0x100, %edi            # imm = 0x100
callq 0x2a7c
xorl %ebx, %ebx
cmpb $0x0, 0x16070(%rip)     # 0x1b6b1
je 0x5699
cmpb $0x0, 0x1657e(%rip)     # 0x1bbc8
je 0x5691
andq $0x0, 0x9bbc(%rip)      # 0xf210
callq 0x2dad
cmpb $0x0, 0x16051(%rip)     # 0x1b6b1
je 0x5699
cmpb $0x0, 0x16141(%rip)     # 0x1b7aa
je 0x5699
movsd 0x16105(%rip), %xmm0    # 0x1b778
movsd 0x1611d(%rip), %xmm1    # 0x1b798
movl 0x9b83(%rip), %edi      # 0xf204
callq 0x374a
movq %rax, %rbx
movb 0x1654a(%rip), %al      # 0x1bbd9
jmp 0x562a
andq $0x0, 0x16537(%rip)     # 0x1bbd0
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/mincebert[P]maketzx/maketzx.c
// Function: FindAlkatrazLoader1
word FindAlkatrazLoader1(word limit)
{
  byte lastval;
  word count,position,offset;
  PushFilePointers();
  ResetTempFile();
  for (count=0; count<limit; count++)
      {
	if ((lastval=GetData(&tempfile))==0xea && count>127) break;
      }
  do { lastval=GetData(&tempfile); }
  while (lastval!=0x11);
  position=GetData(&tempfile);
  position+=256*GetData(&tempfile)+1;
  if (position<61440) offset=0x190;
  else offset=0x200;
  position-=offset;
  ResetTempFile();
  PopFilePointers();
  lseek(inpfile.handle,filepos,SEEK_SET);
  inpfile.bufpoint=0;
  return position;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edi, %ebx
callq 0x1618
callq 0x15e9
xorl %r15d, %r15d
leaq 0x11df0(%rip), %r14     # 0x174a8
cmpl %r15d, %ebx
je 0x56dc
movq %r14, %rdi
callq 0x1d32
leal 0x1(%r15), %ecx
cmpl $0x80, %r15d
movl %ecx, %r15d
jb 0x56b8
movl %ecx, %r15d
cmpb $-0x16, %al
jne 0x56b8
leaq 0x11dc5(%rip), %rbx     # 0x174a8
movq %rbx, %rdi
callq 0x1d32
cmpb $0x11, %al
jne 0x56e3
leaq 0x11db2(%rip), %rbx     # 0x174a8
movq %rbx, %rdi
callq 0x1d32
movzbl %al, %r14d
movq %rbx, %rdi
callq 0x1d32
movzbl %al, %eax
shll $0x8, %eax
leal (%r14,%rax), %ecx
incl %ecx
cmpl $0xf000, %ecx           # imm = 0xF000
leal -0x18f(%r14,%rax), %ecx
leal -0x1ff(%r14,%rax), %ebx
cmovbl %ecx, %ebx
callq 0x15e9
callq 0x16b7
movzbl 0x9b30(%rip), %edi      # 0xf270
movq 0x9a91(%rip), %rsi      # 0xf1d8
xorl %edx, %edx
callq 0x10d0
andl $0x0, 0x9c1b(%rip)      # 0xf370
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mincebert[P]maketzx/maketzx.c
// Function: ReadAlkatrazBlock
dword ReadAlkatrazBlock(void)
{
  dword loaded;
  pilot.freq=808;
  syncx.freq=2450;
  bit0.freq=3100;
  bit1.freq=1550;
  SetTimings();
  pilotlength=0;
  DataLoadOK=0;
  while (!DataLoadOK)
	{
	  PilotSearch(50);
	  if (!blocktype) return 0; if (!PilotLinkingOK) { pilotlength=0; return 0;}
	  mspause=0;
	  SyncSearch();
	  if (!blocktype) return 0; if (!SyncLoadOK) return 0;
	  loaded=DataRead(bit0.samples,bit1.samples,expectedlength);
	  if (blocktype) mspause+=(FindPause()/samprate)*1000;
	}
  return loaded;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movabsq $0x4089400000000000, %rax # imm = 0x4089400000000000
movq %rax, 0x15fb6(%rip)     # 0x1b728
movabsq $0x40a3240000000000, %rax # imm = 0x40A3240000000000
movq %rax, 0x15fc5(%rip)     # 0x1b748
movabsq $0x40a8380000000000, %rax # imm = 0x40A8380000000000
movq %rax, 0x15fd4(%rip)     # 0x1b768
movabsq $0x4098380000000000, %rax # imm = 0x4098380000000000
movq %rax, 0x15fe3(%rip)     # 0x1b788
callq 0x2397
andq $0x0, 0x1641e(%rip)     # 0x1bbd0
movb $0x0, 0x16420(%rip)     # 0x1bbd9
xorl %eax, %eax
pushq $0x32
popq %rbx
testb %al, %al
jne 0x589b
movl %ebx, %edi
callq 0x2a7c
cmpb $0x0, 0x15edd(%rip)     # 0x1b6b1
je 0x5898
cmpb $0x0, 0x163e7(%rip)     # 0x1bbc8
je 0x5890
andq $0x0, 0x9a21(%rip)      # 0xf210
callq 0x2dad
cmpb $0x0, 0x15eb6(%rip)     # 0x1b6b1
je 0x5898
cmpb $0x0, 0x15fa2(%rip)     # 0x1b7aa
movl $0x0, %r14d
je 0x589b
movsd 0x15f5c(%rip), %xmm0    # 0x1b778
movsd 0x15f74(%rip), %xmm1    # 0x1b798
movl 0x99da(%rip), %edi      # 0xf204
callq 0x374a
movq %rax, %r14
cmpb $0x0, 0x15e78(%rip)     # 0x1b6b1
je 0x5885
callq 0x4167
testq %rax, %rax
js 0x584c
cvtsi2ss %rax, %xmm0
jmp 0x5861
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
cvtsi2ss %rax, %xmm0
addss %xmm0, %xmm0
divss 0x9977(%rip), %xmm0     # 0xf1e0
mulss 0x4b73(%rip), %xmm0     # 0xa3e4
cvtss2sd %xmm0, %xmm0
addsd 0x9993(%rip), %xmm0     # 0xf210
movsd %xmm0, 0x998b(%rip)     # 0xf210
movb 0x1634e(%rip), %al      # 0x1bbd9
jmp 0x57be
andq $0x0, 0x16338(%rip)     # 0x1bbd0
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/mincebert[P]maketzx/maketzx.c
// Function: ReadSpeedlock13FirstBlock
word ReadSpeedlock13FirstBlock(void)
{
  word loaded;
  pilotlength=0;
  DataLoadOK=0;
  while (!DataLoadOK)
	{
	  PushFilePointers();
	  pilotlength=ClickingPilotSearch();
	  if (!blocktype || !ClickingPilotOK) return 0;
	  mspause=0;
	  ReadSpeedlockFlag(bit0.samples,bit1.samples);
	  if (!blocktype) return 0;
	  loaded=DataRead(bit0.samples,bit1.samples,expectedlength);
	  if (blocktype && blocks<=blockskip+1 || slocktype==1) mspause+=(FindPause()/samprate)*1000;
	}

  return loaded;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
andq $0x0, 0x1631f(%rip)     # 0x1bbd0
movb $0x0, 0x16321(%rip)     # 0x1bbd9
xorl %eax, %eax
movl $0xff, %ebp
testb %al, %al
jne 0x59b7
callq 0x1618
callq 0x2824
movq %rax, 0x162f8(%rip)     # 0x1bbd0
xorl %ebx, %ebx
cmpb $0x0, 0x15dd0(%rip)     # 0x1b6b1
je 0x59b7
cmpb $0x0, 0x15ebb(%rip)     # 0x1b7a9
je 0x59b7
andq $0x0, 0x9914(%rip)      # 0xf210
cvttsd2si 0x15e74(%rip), %edi # 0x1b778
cvttsd2si 0x15e8c(%rip), %esi # 0x1b798
andl %ebp, %edi
andl %ebp, %esi
callq 0x59c0
cmpb $0x0, 0x15d95(%rip)     # 0x1b6b1
je 0x59b7
movsd 0x15e4e(%rip), %xmm0    # 0x1b778
movsd 0x15e66(%rip), %xmm1    # 0x1b798
movl 0x98cc(%rip), %edi      # 0xf204
callq 0x374a
movq %rax, %rbx
cmpb $0x0, 0x15d6a(%rip)     # 0x1b6b1
je 0x5959
movl 0x98cd(%rip), %eax      # 0xf21c
incl %eax
cmpl %eax, 0x98c1(%rip)      # 0xf218
jbe 0x5962
cmpb $0x1, 0x9844(%rip)      # 0xf1a4
jne 0x59ac
callq 0x4167
testq %rax, %rax
js 0x5973
cvtsi2ss %rax, %xmm0
jmp 0x5988
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
cvtsi2ss %rax, %xmm0
addss %xmm0, %xmm0
divss 0x9850(%rip), %xmm0     # 0xf1e0
mulss 0x4a4c(%rip), %xmm0     # 0xa3e4
cvtss2sd %xmm0, %xmm0
addsd 0x986c(%rip), %xmm0     # 0xf210
movsd %xmm0, 0x9864(%rip)     # 0xf210
movb 0x16227(%rip), %al      # 0x1bbd9
jmp 0x58bf
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mincebert[P]maketzx/maketzx.c
// Function: ReadSpeedlockFlag
void ReadSpeedlockFlag(byte bit0,byte bit1)
{
  byte count,value=0,tolerance,maxpulse;/*=bit1+bit0-tolerance;*/
  word pulse;
/*  if (maxpulse>pilot.samples) */
  if (spdchk) { bit0*=ecf; bit1*=ecf; }
  tolerance=(bit1-bit0)/2;
  maxpulse=bit1+(pilot.samples-bit1)/2;
  for (count=0; count<slockflagbits+1; count++)
      {
	pulse=FindEdge2();
	if ((pulse<=bit0+tolerance) && (pulse>=bit0-tolerance)) value<<=1;
	else if ((pulse<=maxpulse) && (pulse>=bit1-tolerance)) { value<<=1; value|=0x01; }
	     else if (pulse>maxpulse) { strcpy(errstring,"Pulse too long"); Error(8);}
      }
  value<<=7-slockflagbits;
  slockflag=value;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
shll $0x8, %esi
orl %edi, %esi
cmpb $0x0, 0x97d2(%rip)      # 0xf1a9
movd %esi, %xmm0
je 0x5a09
pxor %xmm1, %xmm1
punpcklbw %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1],xmm0[2],xmm1[2],xmm0[3],xmm1[3],xmm0[4],xmm1[4],xmm0[5],xmm1[5],xmm0[6],xmm1[6],xmm0[7],xmm1[7]
punpcklwd %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1],xmm0[2],xmm1[2],xmm0[3],xmm1[3]
cvtdq2pd %xmm0, %xmm0
movsd 0x96f3(%rip), %xmm1     # 0xf0e8
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
mulpd %xmm0, %xmm1
cvttpd2dq %xmm1, %xmm0
packuswb %xmm0, %xmm0
packuswb %xmm0, %xmm0
movd %xmm0, %ebx
movl %ebx, %ebp
shrl $0x8, %ebp
movl $0xff, %ecx
andl %ecx, %ebp
andl %ecx, %ebx
movl %ebp, %eax
subl %ebx, %eax
cwtd
movw $0x2, %si
idivw %si
cvtsi2sd %ebp, %xmm0
movsd 0x15d04(%rip), %xmm1    # 0x1b738
subsd %xmm0, %xmm1
mulsd 0x4890(%rip), %xmm1     # 0xa2d0
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %r14d
andl %ecx, %eax
leal (%rax,%rbx), %r15d
subl %eax, %ebx
andl %ecx, %r14d
subl %eax, %ebp
xorl %r12d, %r12d
xorl %r13d, %r13d
movzbl 0x96b9(%rip), %eax      # 0xf11c
cmpb %r13b, %al
jb 0x5a96
callq 0x258c
cmpl %eax, %r15d
jb 0x5a7b
cmpl %eax, %ebx
ja 0x5a7b
addb %r12b, %r12b
jmp 0x5a91
cmpl %r14d, %eax
ja 0x5a8c
cmpl %eax, %ebp
ja 0x5a8c
addb %r12b, %r12b
incb %r12b
jmp 0x5a91
cmpl %r14d, %eax
ja 0x5ab5
incb %r13b
jmp 0x5a5c
movzbl %r12b, %edx
movb $0x7, %cl
subb %al, %cl
shll %cl, %edx
movb %dl, 0x9796(%rip)       # 0xf23c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movabsq $0x676e6f6c206f6f, %rax # imm = 0x676E6F6C206F6F
movq %rax, 0x15c11(%rip)     # 0x1b6d7
movabsq $0x6f742065736c7550, %rax # imm = 0x6F742065736C7550
movq %rax, 0x15bf9(%rip)     # 0x1b6d0
pushq $0x8
popq %rdi
callq 0x13ed
// File: /workspace/github_c_makefile_star2_O2/mincebert[P]maketzx/maketzx.c
// Function: ReadSpeedlock47FirstBlock
word ReadSpeedlock47FirstBlock(void)
{
  word loaded;
  pilotlength=0;
  DataLoadOK=0;
  while (!DataLoadOK)
	{

	  do {
	       PilotSearch(32);
	       if (!blocktype) return 0;
	       if (!PilotLinkingOK) { pilotlength=0; }
	     }
	  while (!PilotLinkingOK);
	  mspause=0;
	  do
	     {
	       SyncSearch();
	       if (!blocktype) return 0;
	     }
	  while (!SyncLoadOK);

/*        PilotSearch(32);
	  if (!blocktype) return 0; if (!PilotLinkingOK) { pilotlength=0; return 0; }
	  mspause=0;
	  SyncSearch();
	  if (!blocktype) return 0; if (!SyncLoadOK) return 0; */
	  CompositeSyncSearch();
	  if (!blocktype) return 0;
	  ReadSpeedlockFlag(bit0.samples,bit1.samples);
	  if (!blocktype) return 0;
	  loaded=DataRead(bit0.samples,bit1.samples,expectedlength);
	  if (blocktype && blocks<=blockskip+1) mspause+=(FindPause()/samprate)*1000;
	}

  return loaded;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
andq $0x0, 0x160e5(%rip)     # 0x1bbd0
movb $0x0, 0x160e7(%rip)     # 0x1bbd9
xorl %eax, %eax
pushq $0x20
popq %rbx
movl $0xff, %ebp
testb %al, %al
jne 0x5c15
movl %ebx, %edi
callq 0x2a7c
xorl %r14d, %r14d
cmpb $0x0, 0x15b9c(%rip)     # 0x1b6b1
je 0x5c15
cmpb $0x0, 0x160a6(%rip)     # 0x1bbc8
jne 0x5b2e
andq $0x0, 0x160a4(%rip)     # 0x1bbd0
jmp 0x5b04
andq $0x0, 0x96da(%rip)      # 0xf210
callq 0x2dad
cmpb $0x0, 0x15b6f(%rip)     # 0x1b6b1
je 0x5c15
cmpb $0x0, 0x15c5b(%rip)     # 0x1b7aa
je 0x5b36
callq 0x5c1d
cmpb $0x0, 0x15b54(%rip)     # 0x1b6b1
je 0x5c15
cvttsd2si 0x15c0d(%rip), %edi # 0x1b778
cvttsd2si 0x15c25(%rip), %esi # 0x1b798
andl %ebp, %edi
andl %ebp, %esi
callq 0x59c0
cmpb $0x0, 0x15b2e(%rip)     # 0x1b6b1
je 0x5c15
movsd 0x15be7(%rip), %xmm0    # 0x1b778
movsd 0x15bff(%rip), %xmm1    # 0x1b798
movl 0x9665(%rip), %edi      # 0xf204
callq 0x374a
movq %rax, %r14
cmpb $0x0, 0x15b03(%rip)     # 0x1b6b1
je 0x5c0a
movl 0x9666(%rip), %eax      # 0xf21c
incl %eax
cmpl %eax, 0x965a(%rip)      # 0xf218
ja 0x5c0a
callq 0x4167
testq %rax, %rax
js 0x5bd1
cvtsi2ss %rax, %xmm0
jmp 0x5be6
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
cvtsi2ss %rax, %xmm0
addss %xmm0, %xmm0
divss 0x95f2(%rip), %xmm0     # 0xf1e0
mulss 0x47ee(%rip), %xmm0     # 0xa3e4
cvtss2sd %xmm0, %xmm0
addsd 0x960e(%rip), %xmm0     # 0xf210
movsd %xmm0, 0x9606(%rip)     # 0xf210
movb 0x15fc9(%rip), %al      # 0x1bbd9
jmp 0x5afc
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mincebert[P]maketzx/maketzx.c
// Function: CompositeSyncSearch
void CompositeSyncSearch(void)
{
  byte count,tolerance;
  dword pulse;
  for (count=0; count<7; count++)
      {
	syncx.freq=compositesync[count];
	SetTimings();
	tolerance=syncx.samples/3;
	pulse=FindEdge2();
	if (!blocktype) return;
	if (pulse<(int)syncx.samples-tolerance || pulse>(int)syncx.samples+tolerance)
	   { strcpy(errstring,"Bad sync detection or corrupted composite-sync"); Error(8); }
      }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
leaq 0x94d6(%rip), %r14      # 0xf100
cmpq $0x1c, %rbx
je 0x5ccd
movl (%rbx,%r14), %eax
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x15b03(%rip)    # 0x1b748
callq 0x2397
movsd 0x15b06(%rip), %xmm0    # 0x1b758
movsd %xmm0, (%rsp)
callq 0x258c
cmpb $0x0, 0x15a4e(%rip)     # 0x1b6b1
je 0x5ccd
movsd (%rsp), %xmm0
divsd 0x4616(%rip), %xmm0     # 0xa288
cvttsd2si %xmm0, %edx
cvttsd2si 0x15ada(%rip), %ecx # 0x1b758
movzbl %dl, %edx
movl %ecx, %esi
subl %edx, %esi
movslq %esi, %rsi
cmpq %rsi, %rax
jb 0x5c9b
addl %edx, %ecx
movslq %ecx, %rcx
addq $0x4, %rbx
cmpq %rcx, %rax
jbe 0x5c2a
movups 0x4d43(%rip), %xmm0     # 0xa9e5
movups %xmm0, 0x15a46(%rip)    # 0x1b6ef
movups 0x4d26(%rip), %xmm0     # 0xa9d6
movaps %xmm0, 0x15a29(%rip)    # 0x1b6e0
movups 0x4d08(%rip), %xmm0     # 0xa9c6
movaps %xmm0, 0x15a0b(%rip)    # 0x1b6d0
pushq $0x8
popq %rdi
callq 0x13ed
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/mincebert[P]maketzx/maketzx.c
// Function: WriteTZXPureData
void WriteTZXPureData(byte lastbyte,dword datalen)
{
  dword count;
  puredata[1]=Lo(bit0.tstates); puredata[2]=Hi(bit0.tstates);
  puredata[3]=Lo(bit1.tstates); puredata[4]=Hi(bit1.tstates);
  puredata[5]=lastbyte;
  if (!saveslockflag) { puredata[6]=Lo(mspause); puredata[7]=Hi(mspause); }
  else puredata[6]=puredata[7]=0;
  puredata[8]=Lo(datalen); puredata[9]=Hi(datalen); puredata[10]=Ehi(datalen);
  for (count=0; count<sizeof(puredata); count++) PutData(&outfile,puredata[count],1);
  if (saveslockflag) PutData(&outfile,slockflag,1);
  else if (savemidsync)
	  { for (count=0; count<datalen; count++) PutData(&outfile,midsync[count],1); }
       else {
	      PushFilePointers();
	      ResetTempFile();
	      for (count=0; count<datalen; count++)
		  { PutData(&outfile,GetData(&tempfile),1); }
	      PopFilePointers();
	      lseek(inpfile.handle,filepos,SEEK_SET);
	      inpfile.bufpoint=0;
	    }
  ResetTempFile();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movzwl 0x157e3(%rip), %eax     # 0x1b780
movw %ax, 0x91c7(%rip)       # 0xf16b
movl 0x157f6(%rip), %eax     # 0x1b7a0
movb %al, 0x91bd(%rip)       # 0xf16d
movb %ah, 0x91b8(%rip)       # 0xf16e
movsd 0x9252(%rip), %xmm0     # 0xf210
cvttsd2si %xmm0, %rax
movb %dil, 0x91a5(%rip)      # 0xf16f
movq %rax, %rcx
subsd 0x4333(%rip), %xmm0     # 0xa308
sarq $0x3f, %rcx
cvttsd2si %xmm0, %rdx
andl %ecx, %edx
orl %edx, %eax
movl %eax, %ecx
shrl $0x8, %ecx
xorl %r14d, %r14d
cmpb $0x0, 0x924c(%rip)      # 0xf23d
cmovnel %r14d, %eax
cmovnel %r14d, %ecx
movb %al, 0x9171(%rip)       # 0xf170
movb %cl, 0x916c(%rip)       # 0xf171
movb %bl, 0x9167(%rip)       # 0xf172
movb %bh, 0x9162(%rip)       # 0xf173
movq %rsi, %r12
movl %ebx, %eax
shrl $0x10, %eax
movb %al, 0x9155(%rip)       # 0xf174
leaq 0x9144(%rip), %r15      # 0xf16a
leaq 0xd35b(%rip), %rbx      # 0x13388
pushq $0x1
popq %rbp
cmpq $0xb, %r14
je 0x604a
movzbl (%r14,%r15), %esi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x1da7
incq %r14
jmp 0x6030
cmpb $0x0, 0x91ec(%rip)      # 0xf23d
je 0x6076
movzbl 0x91e2(%rip), %esi      # 0xf23c
leaq 0xd327(%rip), %rdi      # 0x13388
pushq $0x1
popq %rdx
callq 0x1da7
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x15e9
cmpb $0x0, 0x91c1(%rip)      # 0xf23e
je 0x60ac
xorl %r14d, %r14d
leaq 0x9094(%rip), %r15      # 0xf11d
leaq 0xd2f8(%rip), %rbx      # 0x13388
pushq $0x1
popq %rbp
cmpq %r14, %r12
je 0x6069
movzbl (%r14,%r15), %esi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x1da7
incq %r14
jmp 0x6093
callq 0x1618
callq 0x15e9
leaq 0x113eb(%rip), %rbx     # 0x174a8
leaq 0xd2c4(%rip), %r14      # 0x13388
pushq $0x1
popq %rbp
subq $0x1, %r12
jb 0x60e4
movq %rbx, %rdi
callq 0x1d32
movzbl %al, %esi
movq %r14, %rdi
movl %ebp, %edx
callq 0x1da7
jmp 0x60c7
callq 0x16b7
movzbl 0x9180(%rip), %edi      # 0xf270
movq 0x90e1(%rip), %rsi      # 0xf1d8
xorl %edx, %edx
callq 0x10d0
andl $0x0, 0x926b(%rip)      # 0xf370
jmp 0x6069
// File: /workspace/github_c_makefile_star2_O2/mincebert[P]maketzx/maketzx.c
// Function: DecryptToneSearch
void DecryptToneSearch(void)
{
  tonesearch=1;
  pilotlength=BeepSearch(128);
  tonesearch=0;
  mspause+=(FindPause()/samprate)*1000;
}

// Assembly:
pushq %rax
movb $0x1, 0x90de(%rip)      # 0xf1f0
movl $0x80, %edi
callq 0x3287
movl %eax, %eax
movq %rax, 0x15aab(%rip)     # 0x1bbd0
movb $0x0, 0x90c4(%rip)      # 0xf1f0
callq 0x4167
testq %rax, %rax
js 0x613d
cvtsi2ss %rax, %xmm0
jmp 0x6152
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
cvtsi2ss %rax, %xmm0
addss %xmm0, %xmm0
divss 0x9086(%rip), %xmm0     # 0xf1e0
mulss 0x4282(%rip), %xmm0     # 0xa3e4
cvtss2sd %xmm0, %xmm0
addsd 0x90a2(%rip), %xmm0     # 0xf210
movsd %xmm0, 0x909a(%rip)     # 0xf210
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/mincebert[P]maketzx/maketzx.c
// Function: WaveSearch
word WaveSearch(void)
{
  byte maxsmp=(samprate/500)/2;
  word length=0;
  dword pulse,last,read;
  read=pulse=FindEdge1();
  if (!blocktype) return read;
  do {
       last=pulse;
       pulse=FindEdge1();
       if (!blocktype) return read;
       length=(((read+=pulse)/samprate)*1000);
     }
  while ((last-pulse)<maxsmp/4 || length<20);
  return length;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movss 0x9057(%rip), %xmm0     # 0xf1e0
movss %xmm0, 0xc(%rsp)
callq 0x2429
movq %rax, %rbx
cmpb $0x0, 0x15513(%rip)     # 0x1b6b1
je 0x6224
movss 0xc(%rsp), %xmm0
divss 0x422e(%rip), %xmm0     # 0xa3e0
mulss 0x422e(%rip), %xmm0     # 0xa3e8
cvttss2si %xmm0, %eax
shrb $0x2, %al
movzbl %al, %r14d
movq %rbx, %r15
callq 0x2429
cmpb $0x0, 0x154dd(%rip)     # 0x1b6b1
je 0x6228
addq %rax, %r15
js 0x61e2
cvtsi2ss %r15, %xmm0
jmp 0x61fa
movq %r15, %rcx
shrq %rcx
movl %r15d, %edx
andl $0x1, %edx
orq %rcx, %rdx
cvtsi2ss %rdx, %xmm0
addss %xmm0, %xmm0
divss 0x8fde(%rip), %xmm0     # 0xf1e0
mulss 0x41da(%rip), %xmm0     # 0xa3e4
subq %rax, %rbx
cmpq %r14, %rbx
movq %rax, %rbx
jb 0x61c8
cvttss2si %xmm0, %rcx
movq %rax, %rbx
cmpl $0x14, %ecx
jb 0x61c8
jmp 0x622b
movl %ebx, %ecx
jmp 0x622b
movl %r15d, %ecx
movl %ecx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mincebert[P]maketzx/maketzx.c
// Function: WriteDecryptTone
void WriteDecryptTone(void)
{
  if (hifi)
     {
       word tsplitsmp=127*bit1.samples+bit1.samples/1.375,
	    splitnum=beeplength/tsplitsmp+.5,
	    count;
       if (tzxhead[9]<0x0a)
	  for (count=0; count<splitnum; count++)
	      {
		WriteTZXTone(bit1.tstates,254);
		pulseseq[0]=bit1.tstates/1.375; pulseseq[1]=bit1.tstates/1.375;
		WriteTZXPulseSequence(2);
	      }
       else {
	      WriteTZXLoopStart(splitnum);
	      for (count=0; count<splitnum; count++)
		  {
		    WriteTZXTone(bit1.tstates,254);
		    pulseseq[0]=bit1.tstates/1.375; pulseseq[1]=bit1.tstates/1.375;
		    WriteTZXPulseSequence(2);
		  }
	      WriteTZXLoopEnd();
	    }
       WriteTZXTone(bit1.tstates,254);
       WriteTZXPause(mspause);
     }
  else {
	 WriteTZXTone(bit1.tstates,(beeplength/bit1.samples)*2);
	 WriteTZXPause(mspause);
       }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
cmpb $0x0, 0x8e9f(%rip)      # 0xf0e0
je 0x62fe
movsd 0x15549(%rip), %xmm0    # 0x1b798
movapd %xmm0, %xmm1
divsd 0x40d5(%rip), %xmm1     # 0xa330
mulsd 0x40d5(%rip), %xmm0     # 0xa338
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
movq 0x15cad(%rip), %rax     # 0x1bf20
movl %ecx, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %xmm0
punpckldq 0x4189(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x4191(%rip), %xmm0     # 0xa420
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
addsd 0x402d(%rip), %xmm1     # 0xa2d0
cvttsd2si %xmm1, %rbx
cmpb $0x9, 0x8e98(%rip)      # 0xf147
ja 0x633a
pushq $0x2
popq %rbp
subl $0x1, %ebx
jb 0x638b
movl 0x154d9(%rip), %edi     # 0x1b7a0
movl $0xfe, %esi
callq 0x3141
movl 0x154c9(%rip), %eax     # 0x1b7a0
cvtsi2sd %rax, %xmm0
divsd 0x404c(%rip), %xmm0     # 0xa330
cvttsd2si %xmm0, %rax
movl %eax, 0x154c1(%rip)     # 0x1b7b0
movl %eax, 0x154bf(%rip)     # 0x1b7b4
movl %ebp, %edi
callq 0x319d
jmp 0x62b8
movsd 0x15c1a(%rip), %xmm0    # 0x1bf20
unpcklps 0x4103(%rip), %xmm0     # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x410b(%rip), %xmm0     # 0xa420
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
divsd 0x1546f(%rip), %xmm1    # 0x1b798
movl 0x15471(%rip), %edi     # 0x1b7a0
addsd %xmm1, %xmm1
cvttsd2si %xmm1, %rsi
jmp 0x6396
movl %ebx, %edi
callq 0x322a
pushq $0x2
popq %rbp
subl $0x1, %ebx
jb 0x6386
movl 0x15451(%rip), %edi     # 0x1b7a0
movl $0xfe, %esi
callq 0x3141
movl 0x15441(%rip), %eax     # 0x1b7a0
cvtsi2sd %rax, %xmm0
divsd 0x3fc4(%rip), %xmm0     # 0xa330
cvttsd2si %xmm0, %rax
movl %eax, 0x15439(%rip)     # 0x1b7b0
movl %eax, 0x15437(%rip)     # 0x1b7b4
movl %ebp, %edi
callq 0x319d
jmp 0x6344
callq 0x3271
movl 0x1540f(%rip), %edi     # 0x1b7a0
movl $0xfe, %esi
callq 0x3141
cvttsd2si 0x8e6c(%rip), %rdi # 0xf210
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5486
// File: /workspace/github_c_makefile_star2_O2/mincebert[P]maketzx/maketzx.c
// Function: WriteDecryptWaves
void WriteDecryptWaves(word wavnum)
{
  if (hifi)
     {
       if (tzxhead[9]<0x0a)
	  {
	    byte count1,count2;
	    for (count1=0; count1<wavnum; count1++)
		{
		  for (count2=0; count2<243; count2++)
		      {
			pulseseq[count2]=3500000/(samprate/((samprate/1000)-count2*.1345));
		      }
		  WriteTZXPulseSequence(243);
		}
	  }
       else {
	      byte count;
	      WriteTZXLoopStart(wavnum);
	      for (count=0; count<243; count++)
		  {
		    pulseseq[count]=3500000/(samprate/((samprate/1000)-count*.1345));
		  }
	      WriteTZXPulseSequence(243);
	      WriteTZXLoopEnd();
	    }
     }
  else {
	 double totsamp=0;
	 byte count;
	 for (count=0; count<243; count++) totsamp+=(samprate/1000)-count*.1345;
	 totsamp*=wavnum;
	 WriteTZXTone(bit1.tstates,(totsamp/bit1.samples)*2);
       }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edi, %ebx
cmpb $0x0, 0x8d23(%rip)      # 0xf0e0
je 0x6469
cmpb $0x9, 0x8d7d(%rip)      # 0xf147
ja 0x64dc
xorl %r14d, %r14d
leaq 0x153d6(%rip), %r15     # 0x1b7b0
movsd 0x3f5e(%rip), %xmm4     # 0xa340
movsd 0x3e96(%rip), %xmm5     # 0xa280
movzbl %r14b, %eax
cmpl %ebx, %eax
jae 0x654b
movss 0x8de2(%rip), %xmm1     # 0xf1e0
cvtss2sd %xmm1, %xmm0
divss 0x3fda(%rip), %xmm1     # 0xa3e4
cvtss2sd %xmm1, %xmm1
movq %r15, %rax
xorl %ecx, %ecx
cmpq $0xf3, %rcx
je 0x644a
movzbl %cl, %edx
cvtsi2sd %edx, %xmm2
mulsd %xmm4, %xmm2
addsd %xmm1, %xmm2
movaps %xmm0, %xmm3
divsd %xmm2, %xmm3
movapd %xmm5, %xmm2
divsd %xmm3, %xmm2
cvttsd2si %xmm2, %rdx
movl %edx, (%rax)
incq %rcx
addq $0x4, %rax
jmp 0x6413
movl $0xf3, %edi
callq 0x319d
movsd 0x3e24(%rip), %xmm5     # 0xa280
movsd 0x3edc(%rip), %xmm4     # 0xa340
incb %r14b
jmp 0x63ea
movss 0x8d6f(%rip), %xmm0     # 0xf1e0
divss 0x3f6b(%rip), %xmm0     # 0xa3e4
cvtss2sd %xmm0, %xmm1
xorps %xmm0, %xmm0
movb $-0xd, %al
movsd 0x3eb6(%rip), %xmm2     # 0xa340
movsd 0x3e26(%rip), %xmm3     # 0xa2b8
xorpd %xmm4, %xmm4
subb $0x1, %al
jb 0x64b0
movapd %xmm4, %xmm5
mulsd %xmm2, %xmm5
addsd %xmm1, %xmm5
addsd %xmm5, %xmm0
addsd %xmm3, %xmm4
jmp 0x6496
movl %ebx, %eax
cvtsi2sd %rax, %xmm1
mulsd %xmm1, %xmm0
movl 0x152df(%rip), %edi     # 0x1b7a0
divsd 0x152cf(%rip), %xmm0    # 0x1b798
addsd %xmm0, %xmm0
cvttsd2si %xmm0, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x3141
movl %ebx, %edi
callq 0x322a
movss 0x8cf5(%rip), %xmm1     # 0xf1e0
cvtss2sd %xmm1, %xmm0
divss 0x3eed(%rip), %xmm1     # 0xa3e4
cvtss2sd %xmm1, %xmm1
leaq 0x152ae(%rip), %rax     # 0x1b7b0
xorl %ecx, %ecx
movsd 0x3e34(%rip), %xmm2     # 0xa340
movsd 0x3d6c(%rip), %xmm3     # 0xa280
cmpq $0xf3, %rcx
je 0x6551
movzbl %cl, %edx
cvtsi2sd %edx, %xmm4
mulsd %xmm2, %xmm4
addsd %xmm1, %xmm4
movaps %xmm0, %xmm5
divsd %xmm4, %xmm5
movapd %xmm3, %xmm4
divsd %xmm5, %xmm4
cvttsd2si %xmm4, %rdx
movl %edx, (%rax)
incq %rcx
addq $0x4, %rax
jmp 0x6514
popq %rbx
popq %r14
popq %r15
retq
movl $0xf3, %edi
callq 0x319d
popq %rbx
popq %r14
popq %r15
jmp 0x3271
// File: /workspace/github_c_makefile_star2_O2/mincebert[P]maketzx/maketzx.c
// Function: FindLoadAddress
void FindLoadAddress(word limit)
{
  byte push=0,found=0,opcode=0;
  word count;
  dword savepos=filepos;
  slockloadaddress=0;
  ResetTempFile();
  do
     {
       for (count=0; ((count<limit) && !found); count++)
	   {
	     if (!found) if ((GetData(&tempfile))==0x19) { found=1;break; }
	   }
       if (!found) Error(11);
       opcode=GetData(&tempfile);
       if (opcode==1)
	  {
	    slockloadaddress+=GetData(&tempfile);
	    slockloadaddress+=256*(GetData(&tempfile));
	  }
       if (opcode==0x11)
	  {
	    slockloadaddress+=GetData(&tempfile);
	    slockloadaddress+=256*(GetData(&tempfile));
	  }
       if (opcode==0xd5) push=1;
     }
  while (!push);
  filepos=savepos;
  lseek(inpfile.handle,filepos,SEEK_SET);
  inpfile.bufpoint=0;
  ResetTempFile();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edi, %ebp
movq 0x8c62(%rip), %rbx      # 0xf1d8
andl $0x0, 0x8cab(%rip)      # 0xf228
callq 0x15e9
incl %ebp
xorl %r15d, %r15d
leaq 0x10f1a(%rip), %r14     # 0x174a8
testb %r15b, %r15b
jne 0x65b1
movl %ebp, %r12d
decl %r12d
je 0x65ac
movq %r14, %rdi
callq 0x1d32
cmpb $0x19, %al
jne 0x6596
movb $0x1, %r15b
jmp 0x65b1
testb %r15b, %r15b
je 0x6621
movq %r14, %rdi
callq 0x1d32
cmpb $0x1, %al
je 0x65ce
movzbl %al, %eax
cmpl $0x11, %eax
je 0x65ce
cmpl $0xd5, %eax
jne 0x658e
jmp 0x65f5
movq %r14, %rdi
callq 0x1d32
movzbl %al, %eax
addl %eax, 0x8c49(%rip)      # 0xf228
movq %r14, %rdi
callq 0x1d32
movzbl %al, %eax
shll $0x8, %eax
addl %eax, 0x8c35(%rip)      # 0xf228
jmp 0x658e
movq %rbx, 0x8bdc(%rip)      # 0xf1d8
movzbl 0x8c6d(%rip), %edi      # 0xf270
movq %rbx, %rsi
xorl %edx, %edx
callq 0x10d0
andl $0x0, 0x8d5c(%rip)      # 0xf370
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x15e9
pushq $0xb
popq %rdi
callq 0x13ed
// File: /workspace/github_c_makefile_star2_O2/mincebert[P]maketzx/maketzx.c
// Function: ReadZetaLoadFirstBlock
word ReadZetaLoadFirstBlock(void)
{
  word loaded;
  pilotlength=0;
  DataLoadOK=0;
  while (!DataLoadOK)
	{
	  PilotSearch(32);
	  if (!blocktype) return 0; if (!PilotLinkingOK) { pilotlength=0; return 0; }
	  mspause=0;
	  SyncSearch();
	  if (!blocktype) return 0; if (!SyncLoadOK) return 0;
	  bit0.freq=2044; bit1.freq=1022; SetTimings();
	  slockflagbits=4;
	  ReadSpeedlockFlag(bit0.samples,bit1.samples);
	  if (!blocktype) return 0;
	  bit0.freq=3100; bit1.freq=1550; SetTimings();
	  loaded=DataRead(bit0.samples,bit1.samples,expectedlength);
	  if (blocktype && blocks<=blockskip+1) mspause+=(FindPause()/samprate)*1000;
	}
  return loaded;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
andq $0x0, 0x14fbc(%rip)     # 0x1bbd0
movb $0x0, 0x14fbe(%rip)     # 0x1bbd9
xorl %eax, %eax
pushq $0x20
popq %rbx
movabsq $0x409ff00000000000, %r15 # imm = 0x409FF00000000000
movabsq $0x408ff00000000000, %r12 # imm = 0x408FF00000000000
movl $0xff, %ebp
movabsq $0x4098380000000000, %r13 # imm = 0x4098380000000000
testb %al, %al
jne 0x6d87
movl %ebx, %edi
callq 0x2a7c
xorl %r14d, %r14d
cmpb $0x0, 0x14a55(%rip)     # 0x1b6b1
je 0x6d87
cmpb $0x0, 0x14f5f(%rip)     # 0x1bbc8
je 0x6d7f
andq $0x0, 0x8599(%rip)      # 0xf210
callq 0x2dad
cmpb $0x0, 0x14a2e(%rip)     # 0x1b6b1
je 0x6d87
cmpb $0x0, 0x14b1a(%rip)     # 0x1b7aa
je 0x6d87
movq %r15, 0x14acb(%rip)     # 0x1b768
movq %r12, 0x14ae4(%rip)     # 0x1b788
callq 0x2397
cvttsd2si 0x14ac7(%rip), %edi # 0x1b778
cvttsd2si 0x14adf(%rip), %esi # 0x1b798
movb $0x4, 0x845c(%rip)      # 0xf11c
andl %ebp, %edi
andl %ebp, %esi
callq 0x59c0
cmpb $0x0, 0x149e1(%rip)     # 0x1b6b1
je 0x6d87
movabsq $0x40a8380000000000, %rax # imm = 0x40A8380000000000
movq %rax, 0x14a81(%rip)     # 0x1b768
movq %r13, 0x14a9a(%rip)     # 0x1b788
callq 0x2397
movsd 0x14a7d(%rip), %xmm0    # 0x1b778
movsd 0x14a95(%rip), %xmm1    # 0x1b798
movl 0x84fb(%rip), %edi      # 0xf204
callq 0x374a
movq %rax, %r14
cmpb $0x0, 0x14999(%rip)     # 0x1b6b1
je 0x6d74
movl 0x84fc(%rip), %eax      # 0xf21c
incl %eax
cmpl %eax, 0x84f0(%rip)      # 0xf218
ja 0x6d74
callq 0x4167
testq %rax, %rax
js 0x6d3b
cvtsi2ss %rax, %xmm0
jmp 0x6d50
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
cvtsi2ss %rax, %xmm0
addss %xmm0, %xmm0
divss 0x8488(%rip), %xmm0     # 0xf1e0
mulss 0x3684(%rip), %xmm0     # 0xa3e4
cvtss2sd %xmm0, %xmm0
addsd 0x84a4(%rip), %xmm0     # 0xf210
movsd %xmm0, 0x849c(%rip)     # 0xf210
movb 0x14e5f(%rip), %al      # 0x1bbd9
jmp 0x6c43
andq $0x0, 0x14e49(%rip)     # 0x1bbd0
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq