LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: atsidaev[P]trx2x/DiskImage.cpp
// Function: TDiskImage::~TDiskImage()
TDiskImage::~TDiskImage()
{
   FlushImage();
   ReadOnly = true;
   DiskPresent = false;
   Changed = false;
   FType = DIT_UNK;

   for(int t=0; t < 256; t++)
      for(int s=0; s < 256; s++)
      {
         FTrackLength[t][s] = 0;
         if(FTracksPtr[t][s][0]) delete FTracksPtr[t][s][0];
         FTracksPtr[t][s][0] = NULL;
         if(FTracksPtr[t][s][1]) delete FTracksPtr[t][s][1];
         FTracksPtr[t][s][1] = NULL;
      }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x1e70
jmp 0x1cbb
movq -0x18(%rbp), %rax
movb $0x1, 0x145005(%rax)
movb $0x0, 0x145006(%rax)
movb $0x0, 0x145004(%rax)
movl $0x0, 0x141000(%rax)
movl $0x0, -0xc(%rbp)
cmpl $0x100, -0xc(%rbp)      # imm = 0x100
jge 0x1e54
movl $0x0, -0x10(%rbp)
cmpl $0x100, -0x10(%rbp)     # imm = 0x100
jge 0x1e44
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rdx
shlq $0xa, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movslq -0x10(%rbp), %rdx
movl $0x0, (%rcx,%rdx,4)
addq $0x40000, %rax          # imm = 0x40000
movslq -0xc(%rbp), %rcx
shlq $0xc, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x1d82
movq -0x18(%rbp), %rax
addq $0x40000, %rax          # imm = 0x40000
movslq -0xc(%rbp), %rcx
shlq $0xc, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x1d80
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x1130
jmp 0x1d82
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x40000, %rcx          # imm = 0x40000
movslq -0xc(%rbp), %rdx
shlq $0xc, %rdx
addq %rdx, %rcx
movslq -0x10(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq $0x0, (%rcx)
addq $0x40000, %rax          # imm = 0x40000
movslq -0xc(%rbp), %rcx
shlq $0xc, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
je 0x1e0e
movq -0x18(%rbp), %rax
addq $0x40000, %rax          # imm = 0x40000
movslq -0xc(%rbp), %rcx
shlq $0xc, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x1e0c
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x1130
jmp 0x1e0e
movq -0x18(%rbp), %rax
addq $0x40000, %rax          # imm = 0x40000
movslq -0xc(%rbp), %rcx
shlq $0xc, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq $0x0, 0x8(%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1cf9
jmp 0x1e46
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1ce5
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0xd690
nopw %cs:(%rax,%rax)
// File: atsidaev[P]trx2x/DiskImage.cpp
// Function: TDiskImage::FlushImage()
void TDiskImage::FlushImage()
{
   if(ReadOnly) return;
   if(!Changed) return;
   if(FType==DIT_HOB) return;

   int hfile = open((char*)FFileName, O_CREAT | O_RDWR | O_TRUNC | O_BINARY, 0666);
   if(hfile < 0)
   {
      ShowError(ERR_CANTWRITE);
      return;
   }

   if(FType==DIT_TRD) writeTRD(hfile);
   if(FType==DIT_SCL) writeSCL(hfile);
   if(FType==DIT_FDI) writeFDI(hfile);
   if(FType==DIT_UDI) writeUDI(hfile);
   if(FType==DIT_TD0) writeTD0(hfile);
   if(FType==DIT_FDD) writeFDD(hfile);

   close(hfile);
   Changed = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x145005(%rax)
je 0x1e92
jmp 0x1f99
movq -0x18(%rbp), %rax
testb $0x1, 0x145004(%rax)
jne 0x1ea4
jmp 0x1f99
movq -0x18(%rbp), %rax
cmpl $0x6, 0x141000(%rax)
jne 0x1eb6
jmp 0x1f99
movq -0x18(%rbp), %rdi
addq $0x140000, %rdi         # imm = 0x140000
movl $0x242, %esi            # imm = 0x242
movl $0x1b6, %edx            # imm = 0x1B6
movb $0x0, %al
callq 0x10b0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x1ef0
movq -0x18(%rbp), %rdi
leaq 0xc3d4(%rip), %rsi      # 0xe2ba
callq 0x2c30
jmp 0x1f99
movq -0x18(%rbp), %rax
cmpl $0x1, 0x141000(%rax)
jne 0x1f09
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x2c80
movq -0x18(%rbp), %rax
cmpl $0x2, 0x141000(%rax)
jne 0x1f22
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x2f90
movq -0x18(%rbp), %rax
cmpl $0x3, 0x141000(%rax)
jne 0x1f3b
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x37a0
movq -0x18(%rbp), %rax
cmpl $0x5, 0x141000(%rax)
jne 0x1f54
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x3cf0
movq -0x18(%rbp), %rax
cmpl $0x4, 0x141000(%rax)
jne 0x1f6d
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x4150
movq -0x18(%rbp), %rax
cmpl $0x7, 0x141000(%rax)
jne 0x1f86
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x44f0
movl -0xc(%rbp), %edi
callq 0x1200
movq -0x18(%rbp), %rax
movb $0x0, 0x145004(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: atsidaev[P]trx2x/DiskImage.cpp
// Function: TDiskImage::MakeVGCRC(unsigned char*, unsigned long)
unsigned short TDiskImage::MakeVGCRC(unsigned char *data, unsigned long length)
{
   unsigned short CRC = 0xFFFF;
   for(unsigned int i=0; i < length; i++)
   {
      CRC ^= data[i] << 8;
      for(unsigned int j=0; j < 8; j++)
      {
         if(CRC & 0x8000) CRC = (CRC << 1) ^ 0x1021;
         else CRC <<= 1;
      }
   }
   return CRC;          // H<-->L !!!
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movw $0xffff, -0x1a(%rbp)    # imm = 0xFFFF
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpq -0x18(%rbp), %rax
jae 0x202e
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
movzbl (%rax,%rcx), %ecx
shll $0x8, %ecx
movzwl -0x1a(%rbp), %eax
xorl %ecx, %eax
movw %ax, -0x1a(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x8, -0x24(%rbp)
jae 0x2021
movzwl -0x1a(%rbp), %eax
andl $0x8000, %eax           # imm = 0x8000
cmpl $0x0, %eax
je 0x200a
movzwl -0x1a(%rbp), %eax
shll %eax
xorl $0x1021, %eax           # imm = 0x1021
movw %ax, -0x1a(%rbp)
jmp 0x2014
movzwl -0x1a(%rbp), %eax
shll %eax
movw %ax, -0x1a(%rbp)
jmp 0x2016
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1fe5
jmp 0x2023
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1fbd
movw -0x1a(%rbp), %ax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: atsidaev[P]trx2x/DiskImage.cpp
// Function: TDiskImage::FindTrack(unsigned char, unsigned char, VGFIND_TRACK*)
bool TDiskImage::FindTrack(unsigned char CYL, unsigned char SIDE, VGFIND_TRACK *vgft)
{
   vgft->FoundTrack = false;
   vgft->TrackPointer = NULL;
   vgft->ClkPointer = NULL;
   vgft->TrackLength = 0;

   if( (!DiskPresent) | 
       ((CYL > MaxTrack)||(SIDE > MaxSide)) |
       ((!FTracksPtr[CYL][SIDE][0])||(!FTracksPtr[CYL][SIDE][1])) )
   {
      return false;           // ERROR: disk not ready
   }

   vgft->TrackPointer = FTracksPtr[CYL][SIDE][0];
   vgft->ClkPointer = FTracksPtr[CYL][SIDE][1];
   vgft->TrackLength = FTrackLength[CYL][SIDE];
   vgft->FoundTrack = true;
   return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movb %sil, %dl
movq %rdi, -0x10(%rbp)
movb %dl, -0x11(%rbp)
movb %al, -0x12(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rcx
movb $0x0, 0x14(%rcx)
movq -0x20(%rbp), %rcx
movq $0x0, (%rcx)
movq -0x20(%rbp), %rcx
movq $0x0, 0x8(%rcx)
movq -0x20(%rbp), %rcx
movl $0x0, 0x10(%rcx)
movb 0x145006(%rax), %cl
xorb $-0x1, %cl
andb $0x1, %cl
movzbl %cl, %ecx
movl %ecx, -0x28(%rbp)
movzbl -0x11(%rbp), %ecx
movzbl 0x145007(%rax), %edx
movb $0x1, %al
cmpl %edx, %ecx
movb %al, -0x21(%rbp)
jg 0x2b26
movq -0x30(%rbp), %rcx
movzbl -0x12(%rbp), %eax
movzbl 0x145008(%rcx), %ecx
cmpl %ecx, %eax
setg %al
movb %al, -0x21(%rbp)
movq -0x30(%rbp), %rcx
movl -0x28(%rbp), %eax
movb -0x21(%rbp), %dl
andb $0x1, %dl
movzbl %dl, %edx
orl %edx, %eax
movl %eax, -0x38(%rbp)
addq $0x40000, %rcx          # imm = 0x40000
movzbl -0x11(%rbp), %eax
shlq $0xc, %rax
addq %rax, %rcx
movzbl -0x12(%rbp), %eax
shlq $0x4, %rax
addq %rax, %rcx
movb $0x1, %al
cmpq $0x0, (%rcx)
movb %al, -0x31(%rbp)
je 0x2b90
movq -0x30(%rbp), %rax
addq $0x40000, %rax          # imm = 0x40000
movzbl -0x11(%rbp), %ecx
shlq $0xc, %rcx
addq %rcx, %rax
movzbl -0x12(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
setne %al
xorb $-0x1, %al
movb %al, -0x31(%rbp)
movl -0x38(%rbp), %eax
movb -0x31(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
orl %ecx, %eax
cmpl $0x0, %eax
je 0x2ba9
movb $0x0, -0x1(%rbp)
jmp 0x2c28
movq -0x30(%rbp), %rax
movq %rax, %rcx
addq $0x40000, %rcx          # imm = 0x40000
movzbl -0x11(%rbp), %edx
shlq $0xc, %rdx
addq %rdx, %rcx
movzbl -0x12(%rbp), %edx
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq -0x20(%rbp), %rcx
movq %rdx, (%rcx)
movq %rax, %rcx
addq $0x40000, %rcx          # imm = 0x40000
movzbl -0x11(%rbp), %edx
shlq $0xc, %rdx
addq %rdx, %rcx
movzbl -0x12(%rbp), %edx
shlq $0x4, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rdx
movq -0x20(%rbp), %rcx
movq %rdx, 0x8(%rcx)
movzbl -0x11(%rbp), %ecx
shlq $0xa, %rcx
addq %rcx, %rax
movzbl -0x12(%rbp), %ecx
movl (%rax,%rcx,4), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x20(%rbp), %rax
movb $0x1, 0x14(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
// File: atsidaev[P]trx2x/DiskImage.cpp
// Function: TD0CRC(unsigned char*, unsigned int)
unsigned short TD0CRC(unsigned char *buf, unsigned int len)
{
   unsigned short CRC = 0;
   int j;
   for(unsigned int i=0; i < len; i++)
   {
      CRC ^= *buf++;
      j = CRC & 0xFF;
      CRC &= 0xFF00;
      CRC = (CRC<<8)|(CRC>>8);
      CRC ^= ((unsigned short*)tbltd0crc)[ j ];
   }
   return (CRC<<8)|(CRC>>8);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movw $0x0, -0xe(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0xc78d
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movzbl (%rax), %ecx
movzwl -0xe(%rbp), %eax
xorl %ecx, %eax
movw %ax, -0xe(%rbp)
movzwl -0xe(%rbp), %eax
andl $0xff, %eax
movl %eax, -0x14(%rbp)
movzwl -0xe(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
movw %ax, -0xe(%rbp)
movzwl -0xe(%rbp), %eax
shll $0x8, %eax
movzwl -0xe(%rbp), %ecx
sarl $0x8, %ecx
orl %ecx, %eax
movw %ax, -0xe(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0x4a5c(%rip), %rax      # 0x111d0
movzwl (%rax,%rcx,2), %ecx
movzwl -0xe(%rbp), %eax
xorl %ecx, %eax
movw %ax, -0xe(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xc718
movzwl -0xe(%rbp), %eax
shll $0x8, %eax
movzwl -0xe(%rbp), %ecx
sarl $0x8, %ecx
orl %ecx, %eax
popq %rbp
retq
nop
// File: atsidaev[P]trx2x/DiskImage.cpp
// Function: unpack_lzh(unsigned char*, unsigned int, unsigned char*)
unsigned unpack_lzh(unsigned char *src, unsigned size, unsigned char *buf) 
{
  packed_ptr = src; 
  packed_end = src+size;
  int  i, j, k, c;
  unsigned count = 0;
  StartHuff();

//  while (count < textsize)  // textsize - sizeof unpacked data
  while (packed_ptr < packed_end)
  {
    c = DecodeChar();
    if(c < 256)
    {
      *buf++ = c;
      text_buf[r++] = c;
      r &= (N - 1);
      count++;
    } else {
      i = (r - DecodePosition() - 1) & (N - 1);
      j = c - 255 + THRESHOLD;
      for (k = 0; k < j; k++)
      {
        c = text_buf[(i + k) & (N - 1)];
        *buf++ = c;
        text_buf[r++] = c;
        r &= (N - 1);
        count++;
      }
    }
  }
  return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, 0x48ba(%rip)      # 0x115f8
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addq %rcx, %rax
movq %rax, 0x48b1(%rip)      # 0x11600
movl $0x0, -0x2c(%rbp)
callq 0xd020
movq 0x4896(%rip), %rax      # 0x115f8
cmpq 0x4897(%rip), %rax      # 0x11600
jae 0xce9a
callq 0xd5b0
movl %eax, -0x28(%rbp)
cmpl $0x100, -0x28(%rbp)     # imm = 0x100
jge 0xcdd8
movl -0x28(%rbp), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
movl -0x28(%rbp), %eax
movb %al, %dl
movl 0x69e7(%rip), %eax      # 0x13788
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x69dc(%rip)      # 0x13788
movslq %eax, %rcx
leaq 0x485a(%rip), %rax      # 0x11610
movb %dl, (%rax,%rcx)
movl 0x69c9(%rip), %eax      # 0x13788
andl $0xfff, %eax            # imm = 0xFFF
movl %eax, 0x69be(%rip)      # 0x13788
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xce95
movl 0x69aa(%rip), %eax      # 0x13788
movl %eax, -0x30(%rbp)
callq 0xd610
movl %eax, %ecx
movl -0x30(%rbp), %eax
subl %ecx, %eax
subl $0x1, %eax
andl $0xfff, %eax            # imm = 0xFFF
movl %eax, -0x1c(%rbp)
movl -0x28(%rbp), %eax
subl $0xff, %eax
addl $0x2, %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0xce93
movl -0x1c(%rbp), %eax
addl -0x24(%rbp), %eax
andl $0xfff, %eax            # imm = 0xFFF
movl %eax, %eax
movl %eax, %ecx
leaq 0x47e5(%rip), %rax      # 0x11610
movzbl (%rax,%rcx), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
movl -0x28(%rbp), %eax
movb %al, %dl
movl 0x6935(%rip), %eax      # 0x13788
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x692a(%rip)      # 0x13788
movslq %eax, %rcx
leaq 0x47a8(%rip), %rax      # 0x11610
movb %dl, (%rax,%rcx)
movl 0x6917(%rip), %eax      # 0x13788
andl $0xfff, %eax            # imm = 0xFFF
movl %eax, 0x690c(%rip)      # 0x13788
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xce0d
jmp 0xce95
jmp 0xcd5b
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: atsidaev[P]trx2x/DiskImage.cpp
// Function: GetBit()
int GetBit(void)      /* get one bit */
{
  int i;

  while (getlen <= 8)
  {
    if((i = readChar()) == -1) i = 0;
    getbuf |= i << (8 - getlen);
    getlen += 8;
  }
  i = getbuf;
  getbuf <<= 1;
  getlen--;
  return ((i>>15) & 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movzbl 0x6891(%rip), %eax      # 0x13790
cmpl $0x8, %eax
jg 0xcf49
callq 0xceb0
movl %eax, -0x4(%rbp)
cmpl $-0x1, %eax
jne 0xcf18
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
movzbl 0x686e(%rip), %edx      # 0x13790
movl $0x8, %ecx
subl %edx, %ecx
shll %cl, %eax
orl 0x685b(%rip), %eax      # 0x1378c
movl %eax, 0x6855(%rip)      # 0x1378c
movzbl 0x6852(%rip), %eax      # 0x13790
addl $0x8, %eax
movb %al, 0x6849(%rip)       # 0x13790
jmp 0xcef8
movl 0x683d(%rip), %eax      # 0x1378c
movl %eax, -0x4(%rbp)
movl 0x6834(%rip), %eax      # 0x1378c
shll %eax
movl %eax, 0x682c(%rip)      # 0x1378c
movb 0x682a(%rip), %al       # 0x13790
addb $-0x1, %al
movb %al, 0x6822(%rip)       # 0x13790
movl -0x4(%rbp), %eax
sarl $0xf, %eax
andl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: atsidaev[P]trx2x/DiskImage.cpp
// Function: GetByte()
int GetByte(void)     /* get one byte */
{
  unsigned i;

  while (getlen <= 8)
  {
    if((i = readChar()) == -1) i = 0;
    getbuf |= i << (8 - getlen);
    getlen += 8;
  }
  i = getbuf;
  getbuf <<= 8;
  getlen -= 8;
  return (i >> 8) & 0xFF;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movzbl 0x6801(%rip), %eax      # 0x13790
cmpl $0x8, %eax
jg 0xcfd9
callq 0xceb0
movl %eax, -0x4(%rbp)
cmpl $-0x1, %eax
jne 0xcfa8
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
movzbl 0x67de(%rip), %edx      # 0x13790
movl $0x8, %ecx
subl %edx, %ecx
shll %cl, %eax
orl 0x67cb(%rip), %eax      # 0x1378c
movl %eax, 0x67c5(%rip)      # 0x1378c
movzbl 0x67c2(%rip), %eax      # 0x13790
addl $0x8, %eax
movb %al, 0x67b9(%rip)       # 0x13790
jmp 0xcf88
movl 0x67ad(%rip), %eax      # 0x1378c
movl %eax, -0x4(%rbp)
movl 0x67a4(%rip), %eax      # 0x1378c
shll $0x8, %eax
movl %eax, 0x679b(%rip)      # 0x1378c
movzbl 0x6798(%rip), %eax      # 0x13790
subl $0x8, %eax
movb %al, 0x678f(%rip)       # 0x13790
movl -0x4(%rbp), %eax
shrl $0x8, %eax
andl $0xff, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: atsidaev[P]trx2x/DiskImage.cpp
// Function: StartHuff()
void StartHuff(void)
{
  int i, j;

  getbuf = 0, getlen = 0;
  for (i = 0; i < N_CHAR; i++) {
    freq[i] = 1;
    son[i] = i + T;
    prnt[i + T] = i;
  }
  i = 0; j = N_CHAR;
  while (j <= R) {
    freq[j] = freq[i] + freq[i + 1];
    son[j] = i;
    prnt[i] = prnt[i + 1] = j;
    i += 2; j++;
  }
  freq[T] = 0xffff;
  prnt[R] = 0;

  for (i = 0; i < N - F; i++) text_buf[i] = ' ';
  r = N - F;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, 0x675e(%rip)      # 0x1378c
movb $0x0, 0x675b(%rip)      # 0x13790
movl $0x0, -0x4(%rbp)
cmpl $0x13a, -0x4(%rbp)      # imm = 0x13A
jae 0xd098
movslq -0x4(%rbp), %rcx
leaq 0x5600(%rip), %rax      # 0x12650
movw $0x1, (%rax,%rcx,2)
movl -0x4(%rbp), %eax
addl $0x273, %eax            # imm = 0x273
movw %ax, %dx
movslq -0x4(%rbp), %rcx
leaq 0x6234(%rip), %rax      # 0x132a0
movw %dx, (%rax,%rcx,2)
movl -0x4(%rbp), %eax
movw %ax, %dx
movl -0x4(%rbp), %eax
addl $0x273, %eax            # imm = 0x273
movl %eax, %eax
movl %eax, %ecx
leaq 0x5ab7(%rip), %rax      # 0x12b40
movw %dx, (%rax,%rcx,2)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xd03c
movl $0x0, -0x4(%rbp)
movl $0x13a, -0x8(%rbp)      # imm = 0x13A
cmpl $0x272, -0x8(%rbp)      # imm = 0x272
ja 0xd13f
movslq -0x4(%rbp), %rcx
leaq 0x5592(%rip), %rax      # 0x12650
movzwl (%rax,%rcx,2), %eax
movl -0x4(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rdx
leaq 0x557e(%rip), %rcx      # 0x12650
movzwl (%rcx,%rdx,2), %ecx
addl %ecx, %eax
movw %ax, %dx
movslq -0x8(%rbp), %rcx
leaq 0x556a(%rip), %rax      # 0x12650
movw %dx, (%rax,%rcx,2)
movl -0x4(%rbp), %eax
movw %ax, %dx
movslq -0x8(%rbp), %rcx
leaq 0x61a5(%rip), %rax      # 0x132a0
movw %dx, (%rax,%rcx,2)
movl -0x8(%rbp), %eax
movw %ax, %dx
movl -0x4(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x5a2b(%rip), %rax      # 0x12b40
movw %dx, (%rax,%rcx,2)
movslq -0x4(%rbp), %rcx
leaq 0x5a1c(%rip), %rax      # 0x12b40
movw %dx, (%rax,%rcx,2)
movl -0x4(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x4(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xd0a6
movw $0xffff, 0x59ee(%rip)   # imm = 0xFFFF
movw $0x0, 0x5ed3(%rip)      # 0x13024
movl $0x0, -0x4(%rbp)
cmpl $0xfc4, -0x4(%rbp)      # imm = 0xFC4
jae 0xd17b
movslq -0x4(%rbp), %rcx
leaq 0x44a4(%rip), %rax      # 0x11610
movb $0x20, (%rax,%rcx)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xd158
movl $0xfc4, 0x6603(%rip)    # imm = 0xFC4
popq %rbp
retq
nopw (%rax,%rax)
// File: atsidaev[P]trx2x/DiskImage.cpp
// Function: DecodeChar()
int DecodeChar(void)
{
  int c;

  c = son[R];

  /* travel from root to leaf, */
  /* choosing the smaller child node (son[]) if the read bit is 0, */
  /* the bigger (son[]+1} if 1 */
  while(c < T) c = son[c + GetBit()];
  c -= T;
  update(c);
  return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movswl 0x61c5(%rip), %eax      # 0x13784
movl %eax, -0x4(%rbp)
cmpl $0x273, -0x4(%rbp)      # imm = 0x273
jae 0xd5f0
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
callq 0xcef0
movl %eax, %ecx
movl -0x8(%rbp), %eax
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x5cb9(%rip), %rax      # 0x132a0
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0xd5c2
movl -0x4(%rbp), %eax
subl $0x273, %eax            # imm = 0x273
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0xd3e0
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: atsidaev[P]trx2x/DiskImage.cpp
// Function: DecodePosition()
int DecodePosition(void)
{
  int i, j, c;

  /* recover upper 6 bits from table */
  i = GetByte();
  c = (int)d_code[i] << 6;
  j = d_len[i];
  /* read lower 6 bits verbatim */
  j -= 2;
  while (j--) i = (i << 1) + GetBit();
  return c | (i & 0x3f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0xcf80
movl %eax, -0x4(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x3da5(%rip), %rax      # 0x113d0
movzbl (%rax,%rcx), %eax
shll $0x6, %eax
movl %eax, -0xc(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x3e90(%rip), %rax      # 0x114d0
movzbl (%rax,%rcx), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x8(%rbp)
cmpl $0x0, %eax
je 0xd679
movl -0x4(%rbp), %eax
shll %eax
movl %eax, -0x10(%rbp)
callq 0xcef0
movl %eax, %ecx
movl -0x10(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0xd650
movl -0xc(%rbp), %eax
movl -0x4(%rbp), %ecx
andl $0x3f, %ecx
orl %ecx, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: atsidaev[P]trx2x/./utils.h
// Function: filelength(int)
inline long filelength(int fp) {
   long pos = lseek (fp, 0L, SEEK_CUR);
   long sz = lseek (fp, 0L, SEEK_END);
   lseek (fp, pos, SEEK_SET);
   return sz;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x11f0
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x11f0
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x11f0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: soybin[P]idyll/src/main.cpp
// Function: renderRange(int, int, int, int, int, int, int, renderer*, std::vector<std::vector<math::vec3, std::allocator<math::vec3>>, std::allocator<std::vector<math::vec3, std::allocator<math::vec3>>>>*)
void renderRange(int startRow, int endRow, int startCol, int endCol, int width, int height, int chunk, renderer* r, std::vector<std::vector<math::vec3>>* image) {
	for (int y = startRow, x = startCol; y < height && (y < endRow || chunk > 0); ++y) {
		for (; x < width && (x < endCol || chunk > 0); ++x) {
			(*image)[y][x] = r->render((double)height - ((double)y + 0.5), (double)x + 0.5);
			--chunk;
		}
		x = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl %r8d, -0x14(%rbp)
movl %r9d, -0x18(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %ecx
xorl %eax, %eax
cmpl -0x18(%rbp), %ecx
movb %al, -0x39(%rbp)
jge 0x493d
movl -0x1c(%rbp), %ecx
movb $0x1, %al
cmpl -0x8(%rbp), %ecx
movb %al, -0x3a(%rbp)
jl 0x4937
cmpl $0x0, 0x10(%rbp)
setg %al
movb %al, -0x3a(%rbp)
movb -0x3a(%rbp), %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x4949
jmp 0x4a07
jmp 0x494b
movl -0x20(%rbp), %ecx
xorl %eax, %eax
cmpl -0x14(%rbp), %ecx
movb %al, -0x3b(%rbp)
jge 0x4975
movl -0x20(%rbp), %ecx
movb $0x1, %al
cmpl -0x10(%rbp), %ecx
movb %al, -0x3c(%rbp)
jl 0x496f
cmpl $0x0, 0x10(%rbp)
setg %al
movb %al, -0x3c(%rbp)
movb -0x3c(%rbp), %al
movb %al, -0x3b(%rbp)
movb -0x3b(%rbp), %al
testb $0x1, %al
jne 0x497e
jmp 0x49f2
movq 0x18(%rbp), %rsi
cvtsi2sdl -0x18(%rbp), %xmm0
cvtsi2sdl -0x1c(%rbp), %xmm1
movsd 0x18674(%rip), %xmm2    # 0x1d008
addsd %xmm2, %xmm1
subsd %xmm1, %xmm0
cvtsi2sdl -0x20(%rbp), %xmm1
movsd 0x1865f(%rip), %xmm2    # 0x1d008
addsd %xmm2, %xmm1
leaq -0x38(%rbp), %rdi
callq 0xef40
movq 0x20(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x6280
movq %rax, %rdi
movslq -0x20(%rbp), %rsi
callq 0x62a0
movq %rax, %rdi
leaq -0x38(%rbp), %rsi
callq 0xc090
movl 0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, 0x10(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x494b
movl $0x0, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4913
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: soybin[P]idyll/src/gui.cpp
// Function: gui::update(int*, int)
void update(int* curV, int tarV) {
		double lockedValue = *curV;

		do {
			lockedValue = *curV;
			// width of logo is 34 characters. two of which
			// will be used for the extremes of the bar.
			// terminal colors are represented with expressions
			// like "\033[x;xx"
			std::cout << "\r\033[1;36m[";
			int quantity = 1 + 32 * lockedValue / tarV;
			for (int i = 0; i < 32; ++i) {
				std::cout << (i < quantity ? "\033[1;36m=" : "\033[0m-");
			}
			std::cout << "\033[1;36m]";
			std::cout.flush();
			std::this_thread::sleep_for(std::chrono::milliseconds(5));
		} while (lockedValue < tarV);
		std::cout << "\033[0;36m\n";
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
cvtsi2sdl (%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
cvtsi2sdl (%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movq 0x1b730(%rip), %rdi     # 0x26fb0
leaq 0x11f77(%rip), %rsi     # 0x1d7fe
callq 0x4350
movsd 0x11de4(%rip), %xmm1    # 0x1d678
mulsd -0x18(%rbp), %xmm1
cvtsi2sdl -0xc(%rbp), %xmm0
divsd %xmm0, %xmm1
movsd 0x11dc6(%rip), %xmm0    # 0x1d670
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
cmpl $0x20, -0x20(%rbp)
jge 0xb8f3
movl -0x20(%rbp), %ecx
movl -0x1c(%rbp), %edx
leaq 0x11f42(%rip), %rsi     # 0x1d811
leaq 0x11f32(%rip), %rax     # 0x1d808
cmpl %edx, %ecx
cmovlq %rax, %rsi
movq 0x1b6cd(%rip), %rdi     # 0x26fb0
callq 0x4350
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xb8bc
movq 0x1b6b6(%rip), %rdi     # 0x26fb0
leaq 0x11f16(%rip), %rsi     # 0x1d817
callq 0x4350
movq 0x1b6a3(%rip), %rdi     # 0x26fb0
callq 0x4230
movl $0x5, -0x2c(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0xba10
leaq -0x28(%rbp), %rdi
callq 0xb960
movsd -0x18(%rbp), %xmm1
cvtsi2sdl -0xc(%rbp), %xmm0
ucomisd %xmm1, %xmm0
ja 0xb86c
movq 0x1b666(%rip), %rdi     # 0x26fb0
leaq 0x11ecf(%rip), %rsi     # 0x1d820
callq 0x4350
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: soybin[P]idyll/src/math.cpp
// Function: math::clamp(math::vec3, double, double)
vec3 clamp(vec3 v, double rangeMin, double rangeMax) {
		v.x = std::min(std::max(v.x, rangeMin), rangeMax);
		v.y = std::min(std::max(v.y, rangeMin), rangeMax);
		v.z = std::min(std::max(v.z, rangeMin), rangeMax);
		return v;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x18(%rbp)
leaq 0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
leaq -0x8(%rbp), %rsi
callq 0xcef0
movq %rax, %rdi
leaq -0x10(%rbp), %rsi
callq 0xceb0
movq -0x28(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, (%rdi)
addq $0x8, %rdi
leaq -0x8(%rbp), %rsi
callq 0xcef0
movq %rax, %rdi
leaq -0x10(%rbp), %rsi
callq 0xceb0
movq -0x28(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rdi)
addq $0x10, %rdi
leaq -0x8(%rbp), %rsi
callq 0xcef0
movq %rax, %rdi
leaq -0x10(%rbp), %rsi
callq 0xceb0
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rdi
movq %rax, %rdx
movq -0x18(%rbp), %rax
movsd (%rdx), %xmm0
movsd %xmm0, 0x10(%rcx)
movq (%rcx), %rdx
movq %rdx, (%rdi)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rdi)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rdi)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: soybin[P]idyll/src/math.cpp
// Function: math::fold::sierpinski(math::vec3&)
void sierpinski(vec3& r) {
			double a = std::min(r.x + r.y, 0.0);
			double b = std::min(r.x + r.z, 0.0);
			double c = std::min(r.z + r.y, 0.0);
			r.x -= a;
			r.y -= a;
			r.x -= b;
			r.z -= b;
			r.y -= c;
			r.z -= c;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movq -0x8(%rbp), %rax
addsd 0x8(%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xceb0
movsd (%rax), %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movq -0x8(%rbp), %rax
addsd 0x10(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xceb0
movsd (%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x8(%rbp), %rax
addsd 0x8(%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xceb0
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x10(%rbp), %xmm1
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movsd -0x10(%rbp), %xmm1
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rax)
movsd -0x28(%rbp), %xmm1
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movsd -0x28(%rbp), %xmm1
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rax)
movsd -0x40(%rbp), %xmm1
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rax)
movsd -0x40(%rbp), %xmm1
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: soybin[P]idyll/src/math.cpp
// Function: math::fold::menger(math::vec3&)
void menger(vec3& r) {
			double a = std::min(r.x - r.y, 0.0);
			r.x -= a;
			r.y += a;
			a = std::min(r.x - r.z, 0.0);
			r.x -= a;
			r.z += a;
			a = std::min(r.y - r.z, 0.0);
			r.y -= a;
			r.z += a;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movq -0x8(%rbp), %rax
subsd 0x8(%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xceb0
movsd (%rax), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm1
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movsd -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
addsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movq -0x8(%rbp), %rax
subsd 0x10(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xceb0
movsd (%rax), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm1
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movsd -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
addsd 0x10(%rax), %xmm0
movsd %xmm0, 0x10(%rax)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
subsd 0x10(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xceb0
movsd (%rax), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm1
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rax)
movsd -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
addsd 0x10(%rax), %xmm0
movsd %xmm0, 0x10(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: soybin[P]idyll/src/renderer.cpp
// Function: renderer::march(math::ray)
double renderer::march(math::ray r) {
	double t = MIN_DIST;
	for (; t < MAX_DIST; ) {
		double h = f->de(r.origin + r.direction * t);
		if (h < MIN_DIST) {
			break;
		}
		t += h;
	}
	if (t < MAX_DIST) return t;
	return -1.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movsd 0xee01(%rip), %xmm0     # 0x1d898
movsd %xmm0, -0x18(%rbp)
movsd 0xede4(%rip), %xmm0     # 0x1d888
ucomisd -0x18(%rbp), %xmm0
jbe 0xeb35
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rax
movq 0xc0(%rax), %rax
movq %rax, -0x68(%rbp)
addq $0x18, %rsi
movsd -0x18(%rbp), %xmm0
leaq -0x50(%rbp), %rdi
callq 0xbf90
movq -0x60(%rbp), %rsi
leaq -0x38(%rbp), %rdi
leaq -0x50(%rbp), %rdx
callq 0xbe70
movq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x12450
movsd %xmm0, -0x20(%rbp)
movsd 0xed80(%rip), %xmm0     # 0x1d898
ucomisd -0x20(%rbp), %xmm0
jbe 0xeb21
jmp 0xeb35
movsd -0x20(%rbp), %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0xea9c
movsd 0xed4b(%rip), %xmm0     # 0x1d888
ucomisd -0x18(%rbp), %xmm0
jbe 0xeb50
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xeb5d
movsd 0xed38(%rip), %xmm0     # 0x1d890
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: soybin[P]idyll/src/fractal.cpp
// Function: fractal::calculateShadow(math::ray)
double fractal::calculateShadow(math::ray r) {
	double res = 1.0;
	double ph = 1e20;
	double tmax = 16.0;
	double t = 0.0001;

	//
	// kinda like raymarching the shadow with some fancy modifiers
	// to make it soft and round
	//
	for(; t < tmax; ) {
		double h = de(r.origin + r.direction * t);
		if (h < 0.001) {
			return 0.0;
		}
		double y = h * h / (2.0 * ph);
		double d = std::sqrt(h * h - y * y);
		res = std::min(res, shadowSoftness * d / std::max(0.0, t - y));
		ph = h;
		t += h;
	}

	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movsd 0xb153(%rip), %xmm0     # 0x1d670
movsd %xmm0, -0x18(%rbp)
movsd 0xb4ae(%rip), %xmm0     # 0x1d9d8
movsd %xmm0, -0x20(%rbp)
movsd 0xb499(%rip), %xmm0     # 0x1d9d0
movsd %xmm0, -0x28(%rbp)
movsd 0xb484(%rip), %xmm0     # 0x1d9c8
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm1
movsd -0x28(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x126bf
movq -0xa0(%rbp), %rsi
addq $0x18, %rsi
movsd -0x30(%rbp), %xmm0
leaq -0x68(%rbp), %rdi
callq 0xbf90
movq -0xa0(%rbp), %rsi
leaq -0x50(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0xbe70
movq -0x98(%rbp), %rdi
leaq -0x50(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x12450
movsd %xmm0, -0x38(%rbp)
movsd 0xb420(%rip), %xmm0     # 0x1d9e0
ucomisd -0x38(%rbp), %xmm0
jbe 0x125d4
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x126c9
movsd -0x38(%rbp), %xmm0
mulsd -0x38(%rbp), %xmm0
movsd 0xb252(%rip), %xmm1     # 0x1d838
mulsd -0x20(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x70(%rbp)
movsd -0x38(%rbp), %xmm0
movsd -0x38(%rbp), %xmm2
movsd -0x70(%rbp), %xmm1
mulsd -0x70(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x42b0
movq -0x98(%rbp), %rax
movsd %xmm0, -0x78(%rbp)
movsd 0x48(%rax), %xmm0
mulsd -0x78(%rbp), %xmm0
movsd %xmm0, -0xa8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x88(%rbp)
movsd -0x30(%rbp), %xmm0
subsd -0x70(%rbp), %xmm0
movsd %xmm0, -0x90(%rbp)
leaq -0x88(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0xcef0
movsd -0xa8(%rbp), %xmm0
divsd (%rax), %xmm0
movsd %xmm0, -0x80(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0xceb0
movsd (%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x38(%rbp), %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
jmp 0x12549
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0xc0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: soybin[P]idyll/src/fractal.cpp
// Function: PI0::iterate(math::vec3&)
inline void iterate(math::vec3& point) {
		point = math::absolute(point);
		math::rotation::x(point, xrs, xrc);
		math::rotation::z(point, zrs, zrc);
		math::fold::menger(point);
		math::rotation::z(point, zrs, zrc);
		math::rotation::x(point, xrs, xrc);
		math::fold::sierpinski(point);
		point.x += xs;
		point.z += zs;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0xc560
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xc090
movq -0x48(%rbp), %rax
movq -0x10(%rbp), %rdi
movsd 0x18(%rax), %xmm0
movsd 0x20(%rax), %xmm1
callq 0xcb10
movq -0x48(%rbp), %rax
movq -0x10(%rbp), %rdi
movsd 0x28(%rax), %xmm0
movsd 0x30(%rax), %xmm1
callq 0xcc30
movq -0x10(%rbp), %rdi
callq 0xc9e0
movq -0x48(%rbp), %rax
movq -0x10(%rbp), %rdi
movsd 0x28(%rax), %xmm0
movsd 0x30(%rax), %xmm1
callq 0xcc30
movq -0x48(%rbp), %rax
movq -0x10(%rbp), %rdi
movsd 0x18(%rax), %xmm0
movsd 0x20(%rax), %xmm1
callq 0xcb10
movq -0x10(%rbp), %rdi
callq 0xc8a0
movq -0x48(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x10(%rbp), %rcx
addsd (%rcx), %xmm0
movsd %xmm0, (%rcx)
movsd 0x10(%rax), %xmm0
movq -0x10(%rbp), %rax
addsd 0x10(%rax), %xmm0
movsd %xmm0, 0x10(%rax)
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: soybin[P]idyll/src/lib/TinyPngOut.cpp
// Function: TinyPngOut::crc32(unsigned char const*, unsigned long)
void TinyPngOut::crc32(const uint8_t data[], size_t len) {
	crc = ~crc;
	for (size_t i = 0; i < len; i++) {
		for (int j = 0; j < 8; j++) {  // Inefficient bitwise implementation, instead of table-based
			uint32_t bit = (crc ^ (data[i] >> j)) & 1;
			crc = (crc >> 1) ^ ((-bit) & UINT32_C(0xEDB88320));
		}
	}
	crc = ~crc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl 0x28(%rax), %ecx
xorl $-0x1, %ecx
movl %ecx, 0x28(%rax)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x1bb16
movl $0x0, -0x24(%rbp)
cmpl $0x8, -0x24(%rbp)
jge 0x1bb06
movq -0x30(%rbp), %rax
movl 0x28(%rax), %ecx
movl %ecx, -0x34(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rdx
movzbl (%rcx,%rdx), %edx
movl -0x24(%rbp), %ecx
sarl %cl, %edx
movl -0x34(%rbp), %ecx
xorl %edx, %ecx
andl $0x1, %ecx
movl %ecx, -0x28(%rbp)
movl 0x28(%rax), %ecx
shrl %ecx
xorl %edx, %edx
subl -0x28(%rbp), %edx
andl $0xedb88320, %edx       # imm = 0xEDB88320
xorl %edx, %ecx
movl %ecx, 0x28(%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1baba
jmp 0x1bb08
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1baa9
movq -0x30(%rbp), %rax
movl 0x28(%rax), %ecx
xorl $-0x1, %ecx
movl %ecx, 0x28(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: soybin[P]idyll/src/lib/TinyPngOut.cpp
// Function: TinyPngOut::adler32(unsigned char const*, unsigned long)
void TinyPngOut::adler32(const uint8_t data[], size_t len) {
	uint32_t s1 = adler & 0xFFFF;
	uint32_t s2 = adler >> 16;
	for (size_t i = 0; i < len; i++) {
		s1 = (s1 + data[i]) % 65521;
		s2 = (s2 + s1) % 65521;
	}
	adler = s2 << 16 | s1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl 0x2c(%rax), %ecx
andl $0xffff, %ecx           # imm = 0xFFFF
movl %ecx, -0x1c(%rbp)
movl 0x2c(%rax), %eax
shrl $0x10, %eax
movl %eax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x1c00c
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movl $0xfff1, %ecx           # imm = 0xFFF1
xorl %edx, %edx
divl %ecx
movl %edx, -0x1c(%rbp)
movl -0x20(%rbp), %eax
addl -0x1c(%rbp), %eax
movl $0xfff1, %ecx           # imm = 0xFFF1
xorl %edx, %edx
divl %ecx
movl %edx, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1bfc5
movq -0x30(%rbp), %rax
movl -0x20(%rbp), %ecx
shll $0x10, %ecx
orl -0x1c(%rbp), %ecx
movl %ecx, 0x2c(%rax)
popq %rbp
retq
nop
// File: jianxinzhou[P]Smart/./include/ThreadPool.h
// Function: ThreadPool::ThreadPool(MyConf&, int)
ThreadPool(MyConf &conf, int size = 12)
            :vecThreads_(size),
             queueTaskslock_(), 
             queueTasksCond_(queueTaskslock_),
             isStarted_(false),
             conf_(conf),
             cacheThread_(size)
        {
            std::vector<MyThread>::iterator iter ;
            for(iter = vecThreads_.begin(); 
                iter != vecThreads_.end(); 
                ++iter)
            {
                iter -> get_related(this);       // 使线程池中的每一个工作线程持有线程池对象的指针
            }
                cacheThread_.get_related(this);      // 使线程池中的扫描线程持有线程池对象的指针
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
addq $0x8, %rax
movq %rax, -0x58(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x15(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x9520
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x9540
jmp 0x4385
leaq -0x15(%rbp), %rdi
callq 0x95b0
movq -0x60(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x68(%rbp)
callq 0x95d0
jmp 0x43a1
movq -0x60(%rbp), %rdi
addq $0x70, %rdi
movq %rdi, -0x70(%rbp)
callq 0x9600
jmp 0x43b4
movq -0x60(%rbp), %rsi
movq %rsi, %rdi
addq $0x98, %rdi
movq %rdi, -0x78(%rbp)
addq $0x70, %rsi
callq 0x96d0
jmp 0x43d1
movq -0x60(%rbp), %rdi
movb $0x0, 0xd0(%rdi)
addq $0xd8, %rdi
movq %rdi, -0x80(%rbp)
leaq -0x14(%rbp), %rsi
callq 0x97b0
jmp 0x43f2
leaq -0x30(%rbp), %rdi
callq 0x9850
movq -0x60(%rbp), %rdi
addq $0x8, %rdi
callq 0x9870
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x60(%rbp), %rdi
addq $0x8, %rdi
callq 0x98e0
movq %rax, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x98a0
testb $0x1, %al
jne 0x443b
jmp 0x44c8
leaq -0x30(%rbp), %rdi
callq 0x9910
movq -0x60(%rbp), %rsi
movq %rax, %rdi
callq 0x9930
jmp 0x4452
jmp 0x4454
leaq -0x30(%rbp), %rdi
callq 0x9950
jmp 0x4414
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x15(%rbp), %rdi
callq 0x95b0
jmp 0x450a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x4501
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x44f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x44ef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x44e6
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x9970
jmp 0x44e6
movq -0x60(%rbp), %rsi
movq %rsi, %rdi
addq $0xd8, %rdi
callq 0x12590
jmp 0x44dd
addq $0x80, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x99b0
movq -0x70(%rbp), %rdi
callq 0x99d0
movq -0x68(%rbp), %rdi
callq 0x99f0
movq -0x58(%rbp), %rdi
callq 0x9a10
movq -0x20(%rbp), %rdi
callq 0x3530
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: jianxinzhou[P]Smart/./include/ThreadPool.h
// Function: ThreadPool::on()
void on()
        {
            if(isStarted_)
            {
                return ;
            }
            isStarted_ = true ;
            std::vector<MyThread>::iterator iter ;
            for(iter = vecThreads_.begin(); iter != vecThreads_.end(); iter ++)
            {
                iter -> start();    // 开启工作线程
            }
            cacheThread_.start();   // 开启扫描线程
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
testb $0x1, 0xd0(%rax)
je 0x4972
jmp 0x49fd
movq -0x30(%rbp), %rax
movb $0x1, 0xd0(%rax)
leaq -0x10(%rbp), %rdi
callq 0x9850
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x9870
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x98e0
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x98a0
testb $0x1, %al
jne 0x49c3
jmp 0x49e9
leaq -0x10(%rbp), %rdi
callq 0x9910
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xc060
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0xc220
movq %rax, -0x28(%rbp)
jmp 0x499f
movq -0x30(%rbp), %rdi
addq $0xd8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xc060
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: jianxinzhou[P]Smart/./include/ThreadPool.h
// Function: ThreadPool::allocate_task(MyTask&)
void allocate_task( MyTask& task)
        {
            queueTaskslock_.lock();
            std::cout << "Add Task" << std::endl ;
            queueTasks_.push(task);
            queueTaskslock_.unlock();
            queueTasksCond_.broadcast();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x70, %rdi
callq 0xc390
movq 0x18478(%rip), %rdi     # 0x1cfd0
leaq 0xe62c(%rip), %rsi      # 0x1318b
callq 0x32c0
movq %rax, %rdi
movq 0x1844a(%rip), %rsi     # 0x1cfb8
callq 0x3310
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
callq 0xc3b0
movq -0x18(%rbp), %rdi
addq $0x70, %rdi
callq 0xc3e0
movq -0x18(%rbp), %rdi
addq $0x98, %rdi
callq 0xc400
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jianxinzhou[P]Smart/./include/MyConf.h
// Function: MyConf::setIndex(int)
void setIndex(int vecDictIndex)
        {
            std::string word, letter; // 单词，以及单词中的每一个字母（汉字）
            word = vecDict_[vecDictIndex].first ; // 根据词典的下标来找每一个单词（词典的下标正是我们传给setIndex的参数）
            // 遍历单词的每一个字母，制作索引
            for(int index = 0; 
                index != word.size(); 
                ++index)
            {
                // 中文
                if(word[index] & (1 << 7))
                {
                    letter = word.substr(index, 2);
                    index ++ ;
                }else 
                {
                    letter = word.substr(index, 1) ;
                }
                mapIndex_[letter].insert(vecDictIndex); //将包含这个字母的单词 所在vector的下标放入set中
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x3420
leaq -0x50(%rbp), %rdi
callq 0x3420
movq -0xc0(%rbp), %rdi
addq $0x238, %rdi            # imm = 0x238
movslq -0xc(%rbp), %rsi
callq 0x73b0
movq -0xb8(%rbp), %rdi
movq %rax, %rsi
callq 0x3050
jmp 0x4fee
movl $0x0, -0x60(%rbp)
movslq -0x60(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3220
movq %rax, %rcx
movq -0xc8(%rbp), %rax
cmpq %rcx, %rax
je 0x5140
movslq -0x60(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x3590
movq %rax, -0xd0(%rbp)
jmp 0x5032
movq -0xd0(%rbp), %rax
movsbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x50a2
movslq -0x60(%rbp), %rdx
leaq -0x80(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x2, %ecx
callq 0x32f0
jmp 0x505e
leaq -0x50(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x33a0
leaq -0x80(%rbp), %rdi
callq 0x31f0
movl -0x60(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x60(%rbp)
jmp 0x50d9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x31f0
leaq -0x30(%rbp), %rdi
callq 0x31f0
jmp 0x515b
movslq -0x60(%rbp), %rdx
leaq -0xa0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x1, %ecx
callq 0x32f0
jmp 0x50bd
leaq -0x50(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x33a0
leaq -0xa0(%rbp), %rdi
callq 0x31f0
movq -0xc0(%rbp), %rdi
addq $0x250, %rdi            # imm = 0x250
leaq -0x50(%rbp), %rsi
callq 0x73d0
movq %rax, -0xd8(%rbp)
jmp 0x50f9
movq -0xd8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0x74b0
movb %dl, -0xe1(%rbp)
movq %rax, -0xe0(%rbp)
jmp 0x5118
movb -0xe1(%rbp), %al
movq -0xe0(%rbp), %rcx
movq %rcx, -0xb0(%rbp)
movb %al, -0xa8(%rbp)
movl -0x60(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x60(%rbp)
jmp 0x4ff5
leaq -0x50(%rbp), %rdi
callq 0x31f0
leaq -0x30(%rbp), %rdi
callq 0x31f0
addq $0xf0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x3530
nopw %cs:(%rax,%rax)
nop
// File: jianxinzhou[P]Smart/./include/MyLock.h
// Function: MyLock::MyLock()
MyLock()
        {
            // 初始化成功返回0
            if( pthread_mutex_init(&m_mutex, NULL) )
            {
                std::cout << __DATE__  << " " << __TIME__ << " " 
                          << __FILE__  << " " << __LINE__ << ":"
                          << "pthread_mutex_init failed!" << std::endl;
                exit (-1); 
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3470
cmpl $0x0, %eax
je 0x96c4
movq 0x139a7(%rip), %rdi     # 0x1cfd0
leaq 0x99e3(%rip), %rsi      # 0x13013
callq 0x32c0
movq %rax, %rdi
leaq 0x9be4(%rip), %rsi      # 0x13223
callq 0x32c0
movq %rax, %rdi
leaq 0x99d1(%rip), %rsi      # 0x1301f
callq 0x32c0
movq %rax, %rdi
leaq 0x9bc6(%rip), %rsi      # 0x13223
callq 0x32c0
movq %rax, %rdi
leaq 0x9a54(%rip), %rsi      # 0x130c0
callq 0x32c0
movq %rax, %rdi
leaq 0x9ba8(%rip), %rsi      # 0x13223
callq 0x32c0
movq %rax, %rdi
movl $0xe, %esi
callq 0x3520
movq %rax, %rdi
leaq 0x9baa(%rip), %rsi      # 0x13241
callq 0x32c0
movq %rax, %rdi
leaq 0x9a2d(%rip), %rsi      # 0x130d3
callq 0x32c0
movq %rax, %rdi
movq 0x13903(%rip), %rsi     # 0x1cfb8
callq 0x3310
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x3380
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)