LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/RegulusImpact[P]sadboy/src/Graphics/XGPU.cpp
// Function: XGPU::RenderFrame()
void XGPU::RenderFrame() {
    for (int y = 0; y < MAX_Y; y++) {
        for (int x = 0; x < MAX_X; x++) {
            size_t offset = (MAX_X * y) + x;
            uint8_t color = framebuffer[offset];
            Draw(color, y, x);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xc(%rdi), %r15
xorl %r12d, %r12d
movzbl %r12b, %r14d
xorl %r13d, %r13d
movzbl (%r15,%r13), %esi
movq (%rbx), %rax
movzbl %r13b, %ecx
movq %rbx, %rdi
movl %r14d, %edx
callq *0x78(%rax)
incq %r13
cmpq $0xa0, %r13
jne 0x1b8c9
incq %r12
addq $0xa0, %r15
cmpq $0x90, %r12
jne 0x1b8c2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/RegulusImpact[P]sadboy/src/Graphics/XGPU.cpp
// Function: XGPU::DumpTiles()
void XGPU::DumpTiles() {
    uint16_t tileRow = 3;
    uint16_t tile = 0;

	for (uint16_t t = 0; t < 32; t++) {
	    if (15 < tile) {
	        tileRow++;
	        tile = 0;
	    }

	    for (uint8_t y = 0; y < 8; y++) {
    	    for (uint8_t x = 0; x < 8; x++) {
    	        uint8_t p = mmu->tiles[t][y][x];
                Draw(mmu->bgp[p], (tileRow*9)+y, (tile*10)+x);
    	    }
    	}

    	tile++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movb $0x3, %al
movl $0xe3aa, %r15d          # imm = 0xE3AA
xorl %ecx, %ecx
xorl %edx, %edx
movq %rcx, -0x40(%rbp)
cmpw $0x10, %dx
movl $0x0, %ecx
cmovael %ecx, %edx
sbbb $-0x1, %al
movb %al, -0x29(%rbp)
movzbl %al, %eax
leal (%rax,%rax,8), %eax
movq %rax, -0x50(%rbp)
movq %rdx, -0x38(%rbp)
movzbl %dl, %eax
addl %eax, %eax
leaq (%rax,%rax,4), %r13
movq %r15, -0x48(%rbp)
xorl %ecx, %ecx
movq -0x50(%rbp), %rax
movq %rcx, -0x58(%rbp)
addl %ecx, %eax
movzbl %al, %r14d
xorl %r12d, %r12d
movq 0x5a98(%rbx), %rax
leaq (%rax,%r15), %rcx
movzbl (%r12,%rcx), %ecx
movzbl 0xe39e(%rax,%rcx), %esi
leal (%r12,%r13), %eax
movq (%rbx), %r8
movzbl %al, %ecx
movq %rbx, %rdi
movl %r14d, %edx
callq *0x78(%r8)
incq %r12
cmpq $0x8, %r12
jne 0x1b9f1
movq -0x58(%rbp), %rcx
incq %rcx
addq $0x8, %r15
cmpq $0x8, %rcx
jne 0x1b9e0
movq -0x38(%rbp), %rdx
incl %edx
movq -0x40(%rbp), %rcx
incq %rcx
movq -0x48(%rbp), %r15
addq $0x40, %r15
cmpq $0x20, %rcx
movb -0x29(%rbp), %al
jne 0x1b9ae
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/IHorvalds[P]RomAna/./processing/special_characters.hpp
// Function: specialChars::isPunctuation(char*)
int isPunctuation(char* str) {
    // TODO: Alex the problem is: str[1] can be ngative, so it moves the sign-bit forward and changes everything.
    // Encore un problem: str[0] is a byte. When you shift by 8...
    int hash = (str[0] << 8) ^ str[1];
    for (unsigned i = 0; i < count_punctuation_2byte; i++)
      if (hash == punctuation_2byte[i])
        return 2;
    if (strlen(str) == 2)
      return 0;
    
    hash = (hash << 8) ^ str[2];
    for (unsigned i = 0; i < count_punctuation_3byte; i++)
      if (hash == punctuation_3byte[i])
        return 3;
    return 0;
  }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movsbl (%rdi), %eax
shll $0x8, %eax
movsbl 0x1(%rdi), %ebp
xorl %eax, %ebp
movl $0x2, %eax
movl %ebp, %ecx
orl $0x10, %ecx
cmpl $0x3dbb, %ecx           # imm = 0x3DBB
je 0x3835
movq %rdi, %rbx
callq 0x3130
cmpq $0x2, %rax
je 0x382c
shll $0x8, %ebp
movsbl 0x2(%rbx), %eax
xorl %ebp, %eax
xorl %ecx, %ecx
leaq 0x8843(%rip), %rdx      # 0xc060
cmpl (%rcx,%rdx), %eax
je 0x3830
addq $0x4, %rcx
cmpq $0x10, %rcx
jne 0x381d
xorl %eax, %eax
jmp 0x3835
movl $0x3, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/IHorvalds[P]RomAna/./processing/InflexEngineCore.cpp
// Function: InflexEngine::staticTrieAccess(unsigned int)
InflexEngineNode* InflexEngine::staticTrieAccess(uint32_t ptr) {
// Performs a black-box access on the modified trie, when it gets expanded
  // Included in staticTrie?
  if (ptr < size)
    return staticTrie + ptr;
  
  // No? Then use auxTrie
  int32_t index = ptr - size;
  int32_t oldSize = auxTrieSize;
  
  // Is index contained in the old auxInflexEngine?
  if (index >= oldSize) {
    // Check for the first entrance in this case (auxTrieSize == 0)
    auxTrieSize = (!auxTrieSize) ? EXPAND_TRIE_CONSTANT : (auxTrieSize * EXPAND_TRIE_CONSTANT);
    
    // Realloc the entire auxTrie
    auxTrie = (InflexEngineNode*)realloc(auxTrie, auxTrieSize * sizeof(InflexEngineNode));
    
    // Init the new allocated enInflexEngines
    for (unsigned i = oldSize; i < auxTrieSize; i++) {
      auxTrie[i].code = 0;
      auxTrie[i].parent = 0;      
      auxTrie[i].sons = new uint32_t[sigma]();
      auxTrie[i].configuration = fullBits; // 31 bits
    }
  }
  return auxTrie + index;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl %esi, %ebp
subl 0x18(%rdi), %ebp
jae 0x3864
movl %esi, %eax
leaq (%rax,%rax,4), %rax
shlq $0x2, %rax
addq 0x8(%r14), %rax
jmp 0x390d
movl 0x1c(%r14), %r12d
cmpl %r12d, %ebp
jge 0x3876
movq 0x10(%r14), %rax
jmp 0x3902
movl %r12d, %eax
shll $0x4, %eax
testq %r12, %r12
movl $0x10, %ecx
cmovnel %eax, %ecx
movl %ecx, 0x1c(%r14)
movq 0x10(%r14), %rdi
shlq $0x2, %rcx
leaq (%rcx,%rcx,4), %rsi
callq 0x3440
movq %rax, 0x10(%r14)
movl 0x1c(%r14), %r13d
cmpl %r12d, %r13d
jbe 0x3902
movl 0x20(%r14), %r15d
movl 0x24(%r14), %ebx
shlq $0x2, %r15
leaq (%r12,%r12,4), %rcx
movq %rax, (%rsp)
movq %r12, %rdx
leaq (%rax,%rcx,4), %r12
addq $0xc, %r12
subl %edx, %r13d
movq $0x0, -0xc(%r12)
movq %r15, %rdi
callq 0x3030
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x3170
movq %r14, (%r12)
movl %ebx, -0x4(%r12)
addq $0x14, %r12
decl %r13d
jne 0x38cb
movq (%rsp), %rax
movslq %ebp, %rcx
leaq (%rcx,%rcx,4), %rcx
leaq (%rax,%rcx,4), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/IHorvalds[P]RomAna/./processing/InflexEngineCore.cpp
// Function: InflexEngine::updateFreqOfPointer(int)
void InflexEngine::updateFreqOfPointer(int32_t ptr) {
  // If derivated, increase frequency for root
  // If root, increase frequency for itself
  // Reminder: the first bit of code is occupied - that's why += 2!
  if (!(staticTrieAccess(ptr)->code & 1))
    staticTrieAccess(staticTrieAccess(ptr)->code >> 1)->code += 2;
  else
    staticTrieAccess(ptr)->code += 2;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
callq 0x383c
movb (%rax), %r14b
movq %rbx, %rdi
movl %ebp, %esi
callq 0x383c
movl (%rax), %esi
testb $0x1, %r14b
jne 0x394b
shrl %esi
movq %rbx, %rdi
callq 0x383c
movl (%rax), %esi
addl $0x2, %esi
movl %esi, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/IHorvalds[P]RomAna/./processing/InflexEngineCore.cpp
// Function: InflexEngine::tryUpdateFreq(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void InflexEngine::tryUpdateFreq(std::string word) {
// Updade frequency of word. If not found, add it as a as-is word
  int32_t lastPos, ptr = search(word, lastPos);
  if (ptr < 0) {
    int32_t finalPtr;
    insert(-ptr, word, -1, lastPos, finalPtr);
    updateFreqOfPointer(finalPtr);
  } else if (ptr > 0) {
    updateFreqOfPointer(ptr);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x40(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x30(%rsp), %r15
movq %r15, %rdi
callq 0xafec
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3a64
movl %eax, %ebp
movq 0x30(%rsp), %rdi
cmpq %r12, %rdi
je 0x39b2
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x3290
testl %ebp, %ebp
js 0x39bf
je 0x3a20
movq %rbx, %rdi
movl %ebp, %esi
jmp 0x3a1b
negl %ebp
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0xafec
movl 0xc(%rsp), %r8d
leaq 0x8(%rsp), %r9
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x3bee
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x3a14
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3290
movl 0x8(%rsp), %esi
movq %rbx, %rdi
callq 0x391c
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x3a5b
movq 0x20(%rsp), %rsi
jmp 0x3a53
movq %rax, %rbx
movq 0x30(%rsp), %rdi
cmpq %r12, %rdi
je 0x3a5b
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x3290
movq %rbx, %rdi
callq 0x34b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/IHorvalds[P]RomAna/./processing/InflexEngineCore.cpp
// Function: InflexEngine::updateFreq(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void InflexEngine::updateFreq(std::string word, std::string latinWord = "") {
// The strategy: add the latin variant, if the normal one hasn't been found or it's not a romanian word
  // Does it contain non-romanian characters
  if (!romanian::isRomanian(word)) {
    tryUpdateFreq(latinWord);
  } else {
    int32_t lastPos, ptr = search(word, lastPos);
    
    // Romanian word found?
    if (ptr > 0)
      updateFreqOfPointer(ptr);
    else
      tryUpdateFreq(latinWord);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0xafec
movq %r12, %rdi
xorl %esi, %esi
callq 0x4058
movl %eax, %ebp
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x3f15
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3290
testb %bpl, %bpl
je 0x3f74
leaq 0x78(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x68(%rsp), %r15
movq %r15, %rdi
callq 0xafec
leaq 0x4(%rsp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3a64
movl %eax, %ebp
movq 0x68(%rsp), %rdi
cmpq %r12, %rdi
je 0x3f64
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x3290
testl %ebp, %ebp
jle 0x3fb0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x391c
jmp 0x3ff3
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xafec
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3956
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x3ff3
movq 0x18(%rsp), %rsi
jmp 0x3feb
leaq 0x58(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %r14
movq %r14, %rdi
callq 0xafec
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3956
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x3ff3
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x3290
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x48(%rsp), %rdi
jmp 0x402b
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4050
movq 0x18(%rsp), %rsi
jmp 0x4048
movq %rax, %rbx
movq 0x68(%rsp), %rdi
cmpq %r12, %rdi
je 0x4050
movq (%r12), %rsi
jmp 0x4048
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x4050
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3290
movq %rbx, %rdi
callq 0x34b0
// File: /workspace/github_cpp_makefile_star2_O3/IHorvalds[P]RomAna/./processing/language_support.hpp
// Function: romanian::isRomanian(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned int)
static bool isRomanian(std::string str, unsigned index = 0) {
    if (index == str.size())
      return true;
    if (index == str.size() - 1)
        return encode(str.back()) != -1;
    else {
      int ret = romanian::diacriticEncode(str[index], str[index + 1]);
      if (ret == -1)
        return false;
      return isRomanian(str, index + 1 + !isEnglishAlphabetIndex(ret)); 
    }
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %eax
movq 0x8(%rdi), %r14
movb $0x1, %bpl
cmpq %rax, %r14
je 0x4101
leaq -0x1(%r14), %rcx
movq (%rdi), %r15
cmpq %rax, %rcx
jne 0x409b
movsbl -0x1(%r15,%r14), %edi
callq 0x33a0
addl $-0x61, %eax
cmpl $0x1a, %eax
setb %bpl
jmp 0x4101
movl %esi, %ebx
movzbl (%r15,%rax), %edi
incl %ebx
movzbl (%r15,%rbx), %esi
callq 0x4316
cmpl $-0x1, %eax
je 0x40ff
movl %eax, %ebp
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
addq %r15, %r14
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xafec
cmpl $0x1a, %ebp
sbbl $-0x1, %ebx
movq %r12, %rdi
movl %ebx, %esi
callq 0x4058
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x4101
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3290
jmp 0x4101
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x412c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3290
movq %rbx, %rdi
callq 0x34b0
// File: /workspace/github_cpp_makefile_star2_O3/IHorvalds[P]RomAna/./processing/language_support.hpp
// Function: romanian::diacriticEncode(unsigned char, unsigned char)
static int32_t diacriticEncode(uint8_t byte1, uint8_t byte2) {
    for (unsigned index = 0; index < 2 * COUNT_OF_DIACRITICS; ++index)
      if ((diacritics[index][0] == byte1) && (diacritics[index][1] == byte2))
        return ENGLISH_SIGMA + (index >> 1);
    return encode(byte1);
  }

// Assembly:
xorl %eax, %eax
leaq 0x7d21(%rip), %rcx      # 0xc040
cmpb %dil, (%rcx,%rax,2)
jne 0x432c
cmpb %sil, 0x1(%rcx,%rax,2)
je 0x4354
incq %rax
cmpq $0xa, %rax
jne 0x431f
pushq %rax
movsbl %dil, %edi
callq 0x33a0
movl %eax, %ecx
addl $-0x61, %ecx
cmpl $0x1a, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovbl %ecx, %eax
addq $0x8, %rsp
retq
shrl %eax
addl $0x1a, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/IHorvalds[P]RomAna/./processing/InflexEngineCore.cpp
// Function: InflexEngine::findParent(int, int&)
int32_t InflexEngine::findParent(int32_t ptr, int32_t& encoding) {
// Returns the parent in InflexEngine of "ptr" and also saves the type of edge that lies between them.
  if (ptr == 0)
    return -1;
  uint32_t parent = staticTrieAccess(ptr)->parent, parentConfiguration = staticTrieAccess(parent)->configuration;
  for (unsigned index = 0; index < sigma; ++index) {
    if (bitOp::getBit(parentConfiguration, index) && (staticTrieAccess(parent)->sons[bitOp::orderOfBit(parentConfiguration, index)] == ptr))
      encoding = index;
  }
  return parent;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, (%rsp)
testl %esi, %esi
je 0x43cd
movl %esi, %ebp
movq %rdi, %r14
callq 0x383c
movl 0x4(%rax), %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0x383c
cmpl $0x0, 0x20(%r14)
je 0x43d3
movl 0x8(%rax), %r12d
xorl %r13d, %r13d
btl %r13d, %r12d
jae 0x43c2
movq %r14, %rdi
movl %r15d, %esi
callq 0x383c
movq 0xc(%rax), %rbx
movl %r12d, %edi
movl %r13d, %esi
callq 0x42b1
movl %eax, %eax
cmpl %ebp, (%rbx,%rax,4)
jne 0x43c2
movq (%rsp), %rax
movl %r13d, (%rax)
incl %r13d
cmpl 0x20(%r14), %r13d
jb 0x4394
jmp 0x43d3
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/IHorvalds[P]RomAna/./processing/InflexEngineUtil.cpp
// Function: InflexEngine::dealloc_()
void InflexEngine::dealloc_() {
  // Dealloc staticTrie
  for (unsigned i = 0; i <= bufferLastPtr; i++) {
    if (staticTrieAccess(i)->sons != nullptr)
      delete[] staticTrieAccess(i)->sons;
  }
  if (bufferLastPtr)
    delete[] staticTrie;

  // Free auxTrie, only if it has been allocated
  if (auxTrieSize)
    free(auxTrie);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %ebp, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x383c
cmpq $0x0, 0xc(%rax)
je 0x55d1
movq %rbx, %rdi
movl %ebp, %esi
callq 0x383c
movq 0xc(%rax), %rdi
testq %rdi, %rdi
je 0x55d1
callq 0x3350
incl %ebp
movl 0x28(%rbx), %eax
cmpl %eax, %ebp
jbe 0x55a8
testl %eax, %eax
je 0x55ec
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x55ec
callq 0x3350
cmpl $0x0, 0x1c(%rbx)
je 0x5601
movq 0x10(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3300
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/IHorvalds[P]RomAna/./processing/InflexEngineUtil.cpp
// Function: InflexEngine::reset(char const*)
void InflexEngine::reset(const char* filename) {
// Reset the InflexEngine with a new dictionary
  // First dealloc the trie
  dealloc_();
  // Set the generation mode
  generationMode = Load;
  
  // Initialize auxTrie
  auxTrieSize = 0, auxTrie = nullptr;
  loadExternal(filename);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x55a0
movl $0x1, (%r14)
movl $0x0, 0x1c(%r14)
movq $0x0, 0x10(%r14)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x47bc
// File: /workspace/github_cpp_makefile_star2_O3/IHorvalds[P]RomAna/./processing/InflexEngineUtil.cpp
// Function: InflexEngine::addDerivated(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void InflexEngine::addDerivated(std::string root, std::string derivated) {
  if (derivated == root)
    return;
  int32_t dummy, root_pointer = search(root, dummy);
  insert(ROOT, derivated, root_pointer, 0, dummy);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x8(%rdx), %rdx
movq 0x8(%rsi), %r15
cmpq %r15, %rdx
jne 0x5713
testq %rdx, %rdx
je 0x57ae
movq (%rsi), %r12
movq (%r14), %rdi
movq %r12, %rsi
callq 0x32a0
testl %eax, %eax
jne 0x5716
jmp 0x57ae
movq (%rsi), %r12
leaq 0x38(%rsp), %rbp
movq %rbp, -0x10(%rbp)
addq %r12, %r15
leaq 0x28(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xafec
leaq 0x4(%rsp), %rdx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3a64
movl %eax, %r15d
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x575f
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3290
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xafec
leaq 0x4(%rsp), %r9
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
movl %r15d, %ecx
xorl %r8d, %r8d
callq 0x3bee
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x57ae
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3290
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
jmp 0x57cf
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x57e0
movq (%rbp), %rsi
incq %rsi
callq 0x3290
movq %rbx, %rdi
callq 0x34b0
// File: /workspace/github_cpp_makefile_star2_O3/IHorvalds[P]RomAna/./processing/InflexEngineUtil.cpp
// Function: InflexEngine::getAllFreqs(unsigned int, std::vector<std::pair<unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&)
void InflexEngine::getAllFreqs(uint32_t root, std::vector<std::pair<uint32_t, std::string>>& initVector) {
  // Push the frequence of from this node
  if ((staticTrieAccess(root)->code & 1) && (staticTrieAccess(root)->code >> 1))
    initVector.push_back(make_pair(staticTrieAccess(root)->code >> 1, formWord(root)));
  
  // And go further with the children
  for (unsigned i = 0; i < bitOp::countOfBits(staticTrieAccess(root)->configuration); i++)
    if (staticTrieAccess(root)->sons[i] != 0)
      getAllFreqs(staticTrieAccess(root)->sons[i], initVector);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0x383c
testb $0x1, (%rax)
je 0x6050
movq %r14, %rdi
movl %ebp, %esi
callq 0x383c
cmpl $0x2, (%rax)
jb 0x6050
movq %r14, %rdi
movl %ebp, %esi
callq 0x383c
movl (%rax), %r13d
shrl %r13d
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x43e6
leaq 0x38(%rsp), %r12
movl %r13d, -0x18(%r12)
movq %r12, -0x10(%r12)
movq (%r15), %rax
leaq 0x10(%rsp), %r15
cmpq %r15, %rax
je 0x5ff2
movq %rax, 0x28(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x38(%rsp)
jmp 0x5ffb
movups (%r15), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rsp), %rax
leaq 0x20(%rsp), %rsi
movq %rax, 0x10(%rsi)
movq %r15, (%rsp)
movq $0x0, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
movq %rbx, %rdi
callq 0xb530
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x603a
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3290
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x6050
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3290
xorl %r15d, %r15d
movl $0x33333333, %r12d      # imm = 0x33333333
movq %r14, %rdi
movl %ebp, %esi
callq 0x383c
movl 0x8(%rax), %eax
movl %eax, %ecx
shrl %ecx
andl $0x55555555, %ecx       # imm = 0x55555555
subl %ecx, %eax
movl %eax, %ecx
andl %r12d, %ecx
shrl $0x2, %eax
andl %r12d, %eax
addl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
addl %eax, %ecx
andl $0xf0f0f0f, %ecx        # imm = 0xF0F0F0F
imull $0x1010101, %ecx, %eax  # imm = 0x1010101
shrl $0x18, %eax
cmpq %rax, %r15
jae 0x60d1
movq %r14, %rdi
movl %ebp, %esi
callq 0x383c
movq 0xc(%rax), %rax
cmpl $0x0, (%rax,%r15,4)
je 0x60cc
movq %r14, %rdi
movl %ebp, %esi
callq 0x383c
movq 0xc(%rax), %rax
movl (%rax,%r15,4), %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x5f6e
incq %r15
jmp 0x6059
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x60fa
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3290
movq %rsp, %rdi
movq %r15, %rsi
callq 0x3540
movq %rbx, %rdi
callq 0x34b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/IHorvalds[P]RomAna/./processing/parserOltean.hpp
// Function: text::text(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
text(std::string filename) : index(BUFF_SIZE), LIMIT_BUFFER(BUFF_SIZE), currSize(0) {
    input.open(filename, std::ios::in | std::ios::binary);
    input.seekg(0, input.end);
    fileSize = input.tellg();
    input.seekg(0, input.beg);
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x32e0
movl $0x400, 0x608(%rbx)     # imm = 0x400
movabsq $0x40000000000, %rax    # imm = 0x40000000000
movq %rax, 0x610(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
movl $0xc, %edx
callq 0x3240
movq %rbx, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x3370
movq %rbx, %rdi
callq 0x3480
movl %eax, 0x60c(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3370
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x82a7
movq %rax, %r14
movq %rbx, %rdi
callq 0x30c0
movq %r14, %rdi
callq 0x34b0
// File: /workspace/github_cpp_makefile_star2_O3/IHorvalds[P]RomAna/./processing/parserOltean.hpp
// Function: text::serveWord[abi:cxx11]()
std::string serveWord() {
#if 0
    // It's not possible that we receive a white-space
    if ((currSize == fileSize) && (index + 1 >= input.gcount())) {
      return " <EOF> ";
    }
    if (index == input.gcount()) {
      input.read(buffer, BUFF_SIZE);
      index = 0;
      currSize += input.gcount();
    }
    std::string word = "";
    while ((index < BUFF_SIZE) && !isSeparator(buffer[index])) {
      word.append(1, buffer[index]);
      index++;
    }
    if ((index == BUFF_SIZE) && (currSize != fileSize)) {
      input.seekg(-word.length(), input.cur);
      fileSize += word.length();
      currSize += word.length();
      return serveWord();
    }
    while ((index < BUFF_SIZE) && isSeparator(buffer[index])) {
      index++;
    }
    specialChars::cleanUpWord(word);
    if (word.empty())
      word = serveWord();
    return word;
  }
#else
    char c;
    do {
      c = getByte();
    } while ((c != 0) && isSeparator(c));
    
    if (!c)
      return " <EOF> ";
    
    std::string word = "";
    do {
      word.append(1, c);
      c = getByte();
    } while (!isSeparator(c));
    specialChars::cleanUpWord(word);
    return word;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %r14, %rdi
callq 0x9534
testb %al, %al
je 0x8416
movl %eax, %ebp
movsbl %al, %edi
callq 0x95a8
testb %al, %al
jne 0x8354
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
leaq 0x4261(%rip), %rdx      # 0xc5e1
movq %rbx, %rdi
movq %rdx, %rsi
callq 0xb49a
movq 0x8(%rbx), %rsi
movsbl %bpl, %r8d
movl $0x1, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x34e0
movq %r14, %rdi
callq 0x9534
movl %eax, %ebp
movsbl %al, %edi
callq 0x95a8
testb %al, %al
je 0x838b
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0xafec
leaq 0x20(%rsp), %r14
movq %rsp, %rsi
movq %r14, %rdi
callq 0x591c
movq (%r14), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x83fe
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3290
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x8433
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3290
jmp 0x8433
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x3dbc(%rip), %rsi      # 0xc1e0
leaq 0x3dbc(%rip), %rdx      # 0xc1e7
movq %rbx, %rdi
callq 0xb49a
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8445
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x845b
movq (%r15), %rsi
incq %rsi
callq 0x3290
movq %r14, %rdi
callq 0x34b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/IHorvalds[P]RomAna/./processing/parserOltean.hpp
// Function: text::getByte()
char getByte() {
    if (currSize == fileSize)
      return 0;
    if (index == LIMIT_BUFFER) {
      index = 0;
      input.read(buffer, BUFF_SIZE);
      LIMIT_BUFFER = input.gcount();
    }
    ++currSize;
    return buffer[index++];
  }

// Assembly:
movl 0x610(%rdi), %eax
cmpl 0x60c(%rdi), %eax
jne 0x9545
xorl %eax, %eax
retq
pushq %rbx
movq %rdi, %rbx
movl 0x614(%rdi), %ecx
cmpl 0x608(%rdi), %ecx
jne 0x958a
movl $0x0, 0x614(%rbx)
leaq 0x208(%rbx), %rsi
movl $0x400, %edx            # imm = 0x400
movq %rbx, %rdi
callq 0x3330
movl 0x8(%rbx), %eax
movl %eax, 0x608(%rbx)
movl 0x610(%rbx), %eax
movl 0x614(%rbx), %ecx
incl %eax
movl %eax, 0x610(%rbx)
leal 0x1(%rcx), %eax
movl %eax, 0x614(%rbx)
movslq %ecx, %rax
movb 0x208(%rbx,%rax), %al
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/davidcairuz[P]network-internet-relay-chat/server.cpp
// Function: send_message(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
void send_message(string message, int speaker) {
    int status = -1, retries = Socket::max_retries;
    for (int i = 0; (unsigned int)i < message.size(); i += Socket::buffer_size) {
        cout << speaker << " speaking\n";
        while (status == -1 && retries--)
            status = socket_server->Write(message.substr(i, Socket::buffer_size), speaker);        
    }
    
    if (status == -1) active->remove(speaker);
    
    pthread_mutex_unlock(&lock);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, -0x2c(%rbp)
cmpq $0x0, 0x8(%rdi)
je 0x3252
movq %rdi, %r14
movl $0x5, %r12d
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
xorl %r15d, %r15d
movq 0x7e30(%rip), %rdi      # 0xafd8
movl -0x2c(%rbp), %esi
callq 0x2370
movl $0xa, %edx
movq %rax, %rdi
leaq 0x4f60(%rip), %rsi      # 0x811f
callq 0x22b0
cmpl $-0x1, %r13d
jne 0x321a
subl $0x1, %r12d
jb 0x322d
movq 0x8041(%rip), %r13      # 0xb218
movl $0x1000, %ecx           # imm = 0x1000
leaq -0x50(%rbp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2270
movq %r13, %rdi
movq %rbx, %rsi
movl -0x2c(%rbp), %edx
callq 0x2f66
movl %eax, %r13d
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x31c4
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2250
jmp 0x31c4
addq $0x1000, %r15           # imm = 0x1000
cmpq %r15, 0x8(%r14)
ja 0x31a1
jmp 0x324c
addq $0x1000, %r15           # imm = 0x1000
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
cmpq %r15, 0x8(%r14)
ja 0x31a1
jmp 0x3252
cmpl $-0x1, %r13d
jne 0x3261
movq 0x804f(%rip), %rdi      # 0xb2a8
movl -0x2c(%rbp), %esi
callq 0x5e4e
leaq 0x7fb8(%rip), %rdi      # 0xb220
callq 0x21b0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x3298
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2250
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O3/davidcairuz[P]network-internet-relay-chat/server.cpp
// Function: ActiveClients::remove(int)
void remove(int conn) {
        pthread_mutex_lock(&lock);    
        int pos = find(conn);
        clients.erase(clients.begin() + pos);
        pthread_mutex_unlock(&lock);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x53be(%rip), %rdi      # 0xb220
callq 0x2310
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
subq %rsi, %rax
je 0x5ea2
sarq $0x3, %rax
movabsq $-0x1111111111111111, %rcx # imm = 0xEEEEEEEEEEEEEEEF
imulq %rax, %rcx
xorl %eax, %eax
imulq $0x78, %rax, %rdx
cmpl %r14d, 0x4(%rsi,%rdx)
je 0x5e9e
incl %eax
cmpq %rax, %rcx
ja 0x5e87
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cltq
jmp 0x5ea9
movq $-0x1, %rax
imulq $0x78, %rax, %rax
addq %rax, %rsi
movq %rbx, %rdi
callq 0x653c
leaq 0x5361(%rip), %rdi      # 0xb220
popq %rbx
popq %r14
popq %rbp
jmp 0x21b0
// File: /workspace/github_cpp_makefile_star2_O3/davidcairuz[P]network-internet-relay-chat/server.cpp
// Function: ActiveClients::insert(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void insert(int conn, string name, string ip) {
        pthread_mutex_lock(&lock);
        Client new_client = Client(curr_id++, conn, name, ip);
        clients.push_back(new_client);
        pthread_mutex_unlock(&lock);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rcx, %r12
movq %rdx, %r13
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x4f85(%rip), %rdi      # 0xb220
callq 0x2310
movl 0x18(%rbx), %r15d
leal 0x1(%r15), %eax
movl %eax, 0x18(%rbx)
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0x2810
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %rdi
callq 0x2810
leaq -0xe0(%rbp), %rdi
leaq -0x48(%rbp), %rcx
leaq -0x68(%rbp), %r8
movl %r15d, %esi
movl %r14d, %edx
callq 0x66d8
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x6313
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2250
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x632c
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2250
leaq -0xe0(%rbp), %rsi
movq %rbx, %rdi
callq 0x67c2
leaq 0x4ede(%rip), %rdi      # 0xb220
callq 0x21b0
leaq -0x80(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6360
movq -0x80(%rbp), %rsi
incq %rsi
callq 0x2250
leaq -0xa8(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x637f
movq -0xa8(%rbp), %rsi
incq %rsi
callq 0x2250
leaq -0xc8(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x639e
movq -0xc8(%rbp), %rsi
incq %rsi
callq 0x2250
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xe0(%rbp), %rdi
callq 0x5ec8
jmp 0x63f7
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x63de
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2250
jmp 0x63de
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x63f7
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2250
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O3/shinerd[P]BriefRenderer/main.cpp
// Function: line(Vec2<int>, Vec2<int>, TGAImage&, TGAColor)
void line(Vec2i p0, Vec2i p1, TGAImage &image, TGAColor color) {
    bool steep = false;
    if (std::abs(p0.x-p1.x)<std::abs(p0.y-p1.y)) {
        std::swap(p0.x, p0.y);
        std::swap(p1.x, p1.y);
        steep = true;
    }
    if (p0.x>p1.x) {
        std::swap(p0, p1);
    }
    
    if (p0.x != p1.x) {
        for (int x=p0.x; x<=p1.x; x++) {
            float t = (x-p0.x)/(float)(p1.x-p0.x);
            int y = p0.y*(1.-t) + p1.y*t +0.5;
            if (steep) {
                image.set(y, x, color);
            } else {
                image.set(x, y, color);
            }
        }
    } else {
        for (int y=p0.y; y<=p1.y; y++) {
            image.set(p0.x, y, color);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %rbx
movq %rdi, %rax
shrq $0x20, %rax
movq %rsi, %rcx
shrq $0x20, %rcx
movl %edi, %r8d
subl %esi, %r8d
movl %r8d, %r9d
negl %r9d
cmovsl %r8d, %r9d
movq %rdx, %r14
movl %eax, %edx
subl %ecx, %edx
movl %edx, %r13d
negl %r13d
cmovsl %edx, %r13d
movl %r9d, 0x14(%rsp)
cmpl %r13d, %r9d
jae 0x25d5
movl %edi, %r12d
movl %esi, %edx
jmp 0x25de
movl %eax, %r12d
movl %edi, %eax
movl %ecx, %edx
movl %esi, %ecx
cmpl %ecx, %eax
jle 0x25eb
movl %edx, %ebp
movl %ecx, %r15d
movl %eax, %edx
jmp 0x25f6
movl %r12d, %ebp
movl %eax, %r15d
movl %edx, %r12d
movl %ecx, %edx
cmpl %eax, %ecx
jne 0x262f
cmpl %r12d, %ebp
jg 0x26f1
incl %r12d
leaq 0x30(%rsp), %r13
movq (%rbx), %rax
movq %rax, 0x30(%rsp)
movq %r14, %rdi
movl %r15d, %esi
movl %ebp, %edx
movq %r13, %rcx
callq 0x431a
incl %ebp
cmpl %ebp, %r12d
jne 0x260b
jmp 0x26f1
subl %r15d, %edx
jl 0x26f1
cvtsi2ss %edx, %xmm0
movss %xmm0, 0x10(%rsp)
xorps %xmm0, %xmm0
cvtsi2ss %r12d, %xmm0
movss %xmm0, 0xc(%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
movsd %xmm0, 0x28(%rsp)
incl %edx
movl %edx, %ebp
xorl %r12d, %r12d
leal (%r15,%r12), %edx
xorps %xmm0, %xmm0
cvtsi2ss %r12d, %xmm0
divss 0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
cvtss2sd %xmm0, %xmm1
movsd 0x298b(%rip), %xmm2     # 0x5010
subsd %xmm1, %xmm2
mulsd 0x28(%rsp), %xmm2
mulss 0xc(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
addsd %xmm2, %xmm0
addsd 0x2963(%rip), %xmm0     # 0x5008
cvttsd2si %xmm0, %eax
movl (%rbx), %ecx
cmpl %r13d, 0x14(%rsp)
jae 0x26c9
movl %ecx, 0x20(%rsp)
movl 0x4(%rbx), %ecx
movl %ecx, 0x24(%rsp)
movq %r14, %rdi
movl %eax, %esi
leaq 0x20(%rsp), %rcx
jmp 0x26e0
movl %ecx, 0x18(%rsp)
movl 0x4(%rbx), %ecx
movl %ecx, 0x1c(%rsp)
movq %r14, %rdi
movl %edx, %esi
movl %eax, %edx
leaq 0x18(%rsp), %rcx
callq 0x431a
incl %r12d
cmpl %r12d, %ebp
jne 0x2664
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/shinerd[P]BriefRenderer/tgaimage.cpp
// Function: TGAImage::operator=(TGAImage const&)
TGAImage & TGAImage::operator =(const TGAImage &img) {
    if (this != &img) {
        if (data) delete [] data;
        width  = img.width;
        height = img.height;
        bytespp = img.bytespp;
        unsigned long nbytes = width*height*bytespp;
        data = new unsigned char[nbytes];
        memcpy(data, img.data, nbytes);
    }
    return *this;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x3770
movq %rsi, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3739
callq 0x2200
movl 0x8(%r14), %eax
movl %eax, 0x8(%rbx)
movl 0xc(%r14), %ecx
movl %ecx, 0xc(%rbx)
movl 0x10(%r14), %edx
movl %edx, 0x10(%rbx)
imull %eax, %ecx
imull %edx, %ecx
movslq %ecx, %r15
movq %r15, %rdi
callq 0x2030
movq %rax, (%rbx)
movq (%r14), %rsi
movq %rax, %rdi
movq %r15, %rdx
callq 0x2170
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/shinerd[P]BriefRenderer/tgaimage.cpp
// Function: TGAImage::flip_horizontally()
bool TGAImage::flip_horizontally() {
    if (!data) return false;
    int half = width>>1;
    for (int i=0; i<half; i++) {
        for (int j=0; j<height; j++) {
            TGAColor c1 = get(i, j);
            TGAColor c2 = get(width-1-i, j);
            set(i, j, c2);
            set(width-1-i, j, c1);
        }
    }
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq (%rdi), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x3e74
movq %rdi, %rbx
movl 0x8(%rdi), %eax
sarl %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
jle 0x3e74
movl 0xc(%rbx), %eax
xorl %r14d, %r14d
leaq 0x30(%rsp), %r15
leaq 0x28(%rsp), %r12
testl %eax, %eax
jle 0x3e66
movl %r14d, %ebp
notl %ebp
xorl %r13d, %r13d
movq %r15, %rdi
movq %rbx, %rsi
movl %r14d, %edx
movl %r13d, %ecx
callq 0x42ae
movl 0x8(%rbx), %edx
addl %ebp, %edx
movq %r12, %rdi
movq %rbx, %rsi
movl %r13d, %ecx
callq 0x42ae
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq (%rbx), %rdi
movl 0x8(%rbx), %ecx
movl 0xc(%rbx), %eax
testq %rdi, %rdi
je 0x3e03
cmpl %r14d, %ecx
setg %dl
cmpl %r13d, %eax
setg %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x3e05
imull %r13d, %ecx
addl %r14d, %ecx
movslq 0x10(%rbx), %rdx
movslq %ecx, %rax
imulq %rdx, %rax
addq %rax, %rdi
leaq 0x20(%rsp), %rsi
callq 0x2170
movl 0x8(%rbx), %ecx
movq (%rbx), %rdi
movl 0xc(%rbx), %eax
jmp 0x3e05
xorl %edi, %edi
testq %rdi, %rdi
sete %sil
movl %ecx, %edx
addl %ebp, %edx
movq 0x30(%rsp), %r8
movq %r8, 0x18(%rsp)
sets %r8b
orb %sil, %r8b
jne 0x3e5a
cmpl %edx, %ecx
setg %sil
cmpl %r13d, %eax
setg %r8b
andb %sil, %r8b
cmpb $0x1, %r8b
jne 0x3e5a
imull %r13d, %ecx
addl %edx, %ecx
movslq 0x10(%rbx), %rdx
movslq %ecx, %rax
imulq %rdx, %rax
addq %rax, %rdi
leaq 0x18(%rsp), %rsi
callq 0x2170
movl 0xc(%rbx), %eax
incl %r13d
cmpl %eax, %r13d
jl 0x3d87
incl %r14d
cmpl 0xc(%rsp), %r14d
jne 0x3d77
cmpq $0x0, 0x10(%rsp)
setne %al
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/shinerd[P]BriefRenderer/tgaimage.cpp
// Function: TGAImage::set(int, int, TGAColor)
bool TGAImage::set(int x, int y, TGAColor c) {
    if (!data || x<0 || y<0 || x>=width || y>=height) {
        return false;
    }
    memcpy(data+(x+y*width)*bytespp, c.raw, bytespp);
    return true;
}

// Assembly:
movq %rdi, %r8
movq (%rdi), %rdi
testq %rdi, %rdi
sete %al
movl %edx, %r9d
orl %esi, %r9d
sets %r9b
orb %al, %r9b
je 0x4338
xorl %eax, %eax
retq
movl 0x8(%r8), %r9d
xorl %eax, %eax
cmpl %esi, %r9d
jle 0x4337
cmpl %edx, 0xc(%r8)
jle 0x4337
pushq %rax
imull %edx, %r9d
addl %esi, %r9d
movslq 0x10(%r8), %rdx
movslq %r9d, %rax
imulq %rdx, %rax
addq %rax, %rdi
movq %rcx, %rsi
callq 0x2170
movb $0x1, %al
addq $0x8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/nmmmnu[P]asyncore_cpp/net/test/test_selector_impl.h
// Function: main
int main(){
	using MySelector = MySelector;
	using MyWorker   = MyWorker;

	int const fd1 = net::socket_create(net::socket_tcp,  "localhost.not.used.yet", 2000);
	int const fd2 = net::socket_create(net::socket_tcp,  "localhost.not.used.yet", 2002);
	int const fd3 = net::socket_create(net::socket_unix, "/tmp/echo");

	net::AsyncLoop<MySelector, MyWorker> loop( MySelector{ 4 }, MyWorker{}, { fd1, fd2, fd3 } );

	while(loop.process());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb0, %rsp
leaq 0x1c97(%rip), %rbx      # 0x402c
movq %rbx, %rdi
movl $0x7d0, %esi            # imm = 0x7D0
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x36c6
movl %eax, %r14d
movq %rbx, %rdi
movl $0x7d2, %esi            # imm = 0x7D2
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x36c6
movl %eax, %ebx
leaq 0x1c80(%rip), %rdi      # 0x4043
xorl %esi, %esi
movl $0x1, %edx
callq 0x380d
movl %eax, %r15d
leaq -0x40(%rbp), %r12
movq %r12, %rdi
movl $0x4, %esi
callq 0x3280
leaq -0x4c(%rbp), %rax
movl %r14d, (%rax)
movl %ebx, 0x4(%rax)
movl %r15d, 0x8(%rax)
leaq -0x60(%rbp), %rcx
movq %rax, (%rcx)
movq $0x3, 0x8(%rcx)
leaq -0xd0(%rbp), %rdi
leaq -0x21(%rbp), %rdx
movq %r12, %rsi
callq 0x2472
leaq -0x40(%rbp), %rdi
callq 0x3344
leaq -0xd0(%rbp), %rbx
movq %rbx, %rdi
callq 0x253a
testb %al, %al
jne 0x2423
leaq -0xd0(%rbp), %rdi
callq 0x2622
xorl %eax, %eax
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x3344
jmp 0x246a
movq %rax, %rbx
leaq -0xd0(%rbp), %rdi
callq 0x2622
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O3/nmmmnu[P]asyncore_cpp/net/asyncloop_impl.h
// Function: net::AsyncLoop<net::selector::PollSelector, net::worker::EchoWorker, net::ClientBuffer<1024ul>>::expireFD_()
void AsyncLoop<SELECTOR, WORKER, CLIENTBUFFER>::expireFD_(){
	for(const auto &p : clients_){
		int const fd = p.first;
		auto &c = p.second;

		if (c.expired(CONN_TIMEOUT)){
			handleDisconnect_(fd, DisconnectStatus::TIMEOUT);
			// iterator is invalid now...
			return;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x50(%rdi), %r14
leaq 0x40(%rdi), %r12
cmpq %r12, %r14
je 0x2831
movq %rdi, %rbx
movl 0x20(%r14), %r15d
movl 0x428(%r14), %r13d
addl $0x14, %r13d
callq 0x35ec
cmpl %eax, %r13d
jb 0x2840
movq %r14, %rdi
callq 0x2140
movq %rax, %r14
cmpq %r12, %rax
jne 0x2808
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl %r15d, %esi
movl $0x2, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2a78
// File: /workspace/github_cpp_makefile_star2_O3/nmmmnu[P]asyncore_cpp/net/asyncloop_impl.h
// Function: net::AsyncLoop<net::selector::PollSelector, net::worker::EchoWorker, net::ClientBuffer<1024ul>>::handleRead_(int)
void AsyncLoop<SELECTOR, WORKER, CLIENTBUFFER>::handleRead_(int const fd){
	if ( isServerFD_(fd) ){
		while (handleConnect_(fd));
		return;
	}

	// -------------------------------------

	auto it = clients_.find(fd);

	if (it == clients_.end())
		return handleDisconnect_(fd, DisconnectStatus::PROBLEM_MAP_NOT_FOUND);

	auto &buffer = it->second;

	// -------------------------------------

	auto available = buffer.capacity();

	if (available == 0){
		// buffer will overfow, disconnect.
		return handleDisconnect_(fd, DisconnectStatus::PROBLEM_BUFFER_READ);
	}

	ssize_t const size = ::read(fd, buffer.dataTail(), available);

	if (size <= 0)
		return handleSocketOps_(fd, size);

	buffer.push((size_t) size);

	buffer.restartTimer();

	handleWorker_(fd, buffer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq -0x2c(%rbp), %rdx
movl %esi, (%rdx)
movq 0x20(%rdi), %rdi
movq 0x28(%r14), %rsi
callq 0x2bde
cmpq 0x28(%r14), %rax
je 0x289a
movq %r14, %rdi
movl %ebx, %esi
callq 0x2acc
testb %al, %al
jne 0x288a
jmp 0x28db
movq 0x48(%r14), %rax
testq %rax, %rax
je 0x28cc
leaq 0x40(%r14), %rcx
movq %rcx, %r12
xorl %edx, %edx
cmpl %ebx, 0x20(%rax)
setl %dl
cmovgeq %rax, %r12
movq 0x10(%rax,%rdx,8), %rax
testq %rax, %rax
jne 0x28aa
cmpq %rcx, %r12
je 0x28cc
cmpl %ebx, 0x20(%r12)
jle 0x28ea
movq %r14, %rdi
movl %ebx, %esi
movl $0x5, %edx
callq 0x2a78
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movzwl 0x26(%r12), %eax
cmpq $0x400, %rax            # imm = 0x400
jne 0x2904
movq %r14, %rdi
movl %ebx, %esi
movl $0x6, %edx
jmp 0x28d6
movl $0x400, %r13d           # imm = 0x400
movl $0x400, %edx            # imm = 0x400
subq %rax, %rdx
leaq (%r12,%rax), %rsi
addq $0x28, %rsi
movl %ebx, %edi
callq 0x21d0
testq %rax, %rax
jle 0x2960
leaq 0x24(%r12), %r15
movzwl 0x26(%r12), %ecx
subq %rcx, %r13
cmpq %rax, %r13
jb 0x2941
addl %eax, %ecx
movw %cx, 0x26(%r12)
callq 0x35ec
movl %eax, 0x428(%r12)
movq %r14, %rdi
movl %ebx, %esi
movq %r15, %rdx
callq 0x2b68
jmp 0x28db
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rdx
callq 0x2b1c
jmp 0x28db
// File: /workspace/github_cpp_makefile_star2_O3/nmmmnu[P]asyncore_cpp/net/asyncloop_impl.h
// Function: net::AsyncLoop<net::selector::PollSelector, net::worker::EchoWorker, net::ClientBuffer<1024ul>>::handleWrite_(int)
void AsyncLoop<SELECTOR, WORKER, CLIENTBUFFER>::handleWrite_(int const fd){
	if ( isServerFD_(fd) ){
		// WTF?!?
		return;
	}

	// -------------------------------------

	auto it = clients_.find(fd);

	if (it == clients_.end())
		return handleDisconnect_(fd, DisconnectStatus::PROBLEM_MAP_NOT_FOUND);

	CLIENTBUFFER &buffer = it->second;

	// -------------------------------------

	auto available = buffer.size();

	if (available <= 0){
		// this must never happen, disconnect.
		return handleDisconnect_(fd, DisconnectStatus::PROBLEM_BUFFER_WRITE);
	}

	ssize_t const size = ::write(fd, buffer.data(), available);

	// -------------------------------------

	if (size <= 0)
		return handleSocketOps_(fd, size);

	buffer.pop((size_t) size);

	buffer.restartTimer();

	if (buffer.size() == 0){
		// process with read
		selector_.updateFD(fd, selector::FDEvent::READ);

		return;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq -0x1c(%rbp), %rdx
movl %esi, (%rdx)
movq 0x20(%rdi), %rdi
movq 0x28(%r14), %rsi
callq 0x2bde
cmpq 0x28(%r14), %rax
jne 0x29da
movq 0x48(%r14), %rax
testq %rax, %rax
je 0x29cb
leaq 0x40(%r14), %rcx
movq %rcx, %r15
xorl %edx, %edx
cmpl %ebx, 0x20(%rax)
setl %dl
cmovgeq %rax, %r15
movq 0x10(%rax,%rdx,8), %rax
testq %rax, %rax
jne 0x29aa
cmpq %rcx, %r15
je 0x29cb
cmpl %ebx, 0x20(%r15)
jle 0x29e5
movq %r14, %rdi
movl %ebx, %esi
movl $0x5, %edx
callq 0x2a78
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movzwl 0x26(%r15), %edx
movzwl 0x24(%r15), %eax
cmpw %ax, %dx
jne 0x2a00
movq %r14, %rdi
movl %ebx, %esi
movl $0x7, %edx
jmp 0x29d5
subq %rax, %rdx
leaq (%r15,%rax), %rsi
addq $0x28, %rsi
movl %ebx, %edi
callq 0x20b0
testq %rax, %rax
jle 0x2a35
movzwl 0x26(%r15), %edx
movzwl 0x24(%r15), %ecx
subq %rcx, %rdx
cmpq %rax, %rdx
jb 0x2a4b
jne 0x2a44
movl $0x0, 0x24(%r15)
jmp 0x2a4b
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rdx
callq 0x2b1c
jmp 0x29da
addl %eax, %ecx
movw %cx, 0x24(%r15)
callq 0x35ec
movl %eax, 0x428(%r15)
movzwl 0x26(%r15), %eax
cmpw 0x24(%r15), %ax
jne 0x29da
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
callq 0x34c2
jmp 0x29da
// File: /workspace/github_cpp_makefile_star2_O3/nmmmnu[P]asyncore_cpp/net/asyncloop_impl.h
// Function: net::AsyncLoop<net::selector::PollSelector, net::worker::EchoWorker, net::ClientBuffer<1024ul>>::handleWorker_(int, net::ClientBuffer<1024ul>&)
bool AsyncLoop<SELECTOR, WORKER, CLIENTBUFFER>::handleWorker_(int const fd, CLIENTBUFFER &buffer){
//	static const char *redis_ok  = "$2\r\nOK\r\n";
//	static const char *redis_err = "-ERR Error\r\n";

	const WorkerStatus status = worker_( buffer );

	switch( status ){
	case WorkerStatus::PASS:
		return false;

	case WorkerStatus::READ:
		selector_.updateFD(fd, selector::FDEvent::READ);

		return true;

	case WorkerStatus::WRITE:
		selector_.updateFD(fd, selector::FDEvent::WRITE);

		return true;

	case WorkerStatus::DISCONNECT:
		handleDisconnect_(fd, DisconnectStatus::WORKER_NORMAL);

		return true;

	case WorkerStatus::SHUTDOWN:
	//	handleDisconnect_(fd, DisconnectStatus::WORKER_NORMAL);
		keepProcessing_ = false;

		return true;

	default:
	case WorkerStatus::DISCONNECT_ERROR:
		handleDisconnect_(fd, DisconnectStatus::WORKER_ERROR);

		return true;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
addq $0x18, %rdi
movq %rdx, %rsi
callq 0x2fca
cmpl $0x5, %eax
ja 0x2b9b
movl %eax, %eax
leaq 0x1486(%rip), %rcx      # 0x4014
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorl %eax, %eax
jmp 0x2bd9
movq %r14, %rdi
movl %ebx, %esi
movl $0x4, %edx
jmp 0x2bcb
movq %r14, %rdi
movl %ebx, %esi
movl $0x1, %edx
jmp 0x2bba
movq %r14, %rdi
movl %ebx, %esi
xorl %edx, %edx
callq 0x34c2
jmp 0x2bd7
movq %r14, %rdi
movl %ebx, %esi
movl $0x3, %edx
callq 0x2a78
jmp 0x2bd7
movb $0x0, 0x6c(%r14)
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq