LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x98, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x60(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x4170
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
leaq 0x84(%rsp), %rdx
callq 0x4f20
movl %eax, 0x2c(%rsp)
jmp 0x4e35
leaq 0x60(%rsp), %rdi
callq 0x4200
movl 0x2c(%rsp), %eax
movl %eax, 0x80(%rsp)
cmpl $0x0, 0x80(%rsp)
jge 0x4eee
movq 0x10(%rsp), %rsi
movl 0x80(%rsp), %eax
negl %eax
movl %eax, 0x4(%rsp)
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x4170
movq 0x18(%rsp), %rdi
movl 0x4(%rsp), %esi
movq 0x8(%rsp), %rdx
movl 0x84(%rsp), %r8d
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
leaq 0x50(%rsp), %r9
callq 0x5170
jmp 0x4ea0
leaq 0x30(%rsp), %rdi
callq 0x4200
movq 0x18(%rsp), %rdi
movl 0x50(%rsp), %esi
callq 0x4d70
jmp 0x4f0b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x4200
jmp 0x4f13
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x4200
jmp 0x4f13
cmpl $0x0, 0x80(%rsp)
jle 0x4f09
movq 0x18(%rsp), %rdi
movl 0x80(%rsp), %esi
callq 0x4d70
jmp 0x4f0b
addq $0x98, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0x4620
nopl (%rax)
// File: 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:
subq $0x108, %rsp            # imm = 0x108
movq %rsi, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq %rdi, 0x100(%rsp)
movq %rsi, 0xf8(%rsp)
movq %rdx, 0xf0(%rsp)
movq 0x100(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0xd0(%rsp), %rdi
movq %rdi, 0x48(%rsp)
callq 0x4170
movq 0x48(%rsp), %rdi
xorl %esi, %esi
callq 0x5810
movb %al, 0x57(%rsp)
jmp 0x567a
movb 0x57(%rsp), %al
xorb $-0x1, %al
movb %al, 0x2f(%rsp)
leaq 0xd0(%rsp), %rdi
callq 0x4200
movb 0x2f(%rsp), %al
testb $0x1, %al
jne 0x569e
jmp 0x5724
movq 0x38(%rsp), %rsi
leaq 0xa0(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x4170
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x4de0
jmp 0x56c6
leaq 0xa0(%rsp), %rdi
callq 0x4200
jmp 0x57fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc8(%rsp)
movl %eax, 0xc4(%rsp)
leaq 0xd0(%rsp), %rdi
callq 0x4200
jmp 0x5802
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc8(%rsp)
movl %eax, 0xc4(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0x4200
jmp 0x5802
movq 0x30(%rsp), %rsi
leaq 0x78(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x4170
movq 0x40(%rsp), %rdi
movq 0x10(%rsp), %rsi
leaq 0x9c(%rsp), %rdx
callq 0x4f20
movl %eax, 0x1c(%rsp)
jmp 0x5755
leaq 0x78(%rsp), %rdi
callq 0x4200
movl 0x1c(%rsp), %eax
movl %eax, 0x98(%rsp)
cmpl $0x0, 0x98(%rsp)
jle 0x57a7
movq 0x40(%rsp), %rdi
movl 0x98(%rsp), %esi
callq 0x4d70
jmp 0x57f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc8(%rsp)
movl %eax, 0xc4(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x4200
jmp 0x5802
movq 0x38(%rsp), %rsi
leaq 0x58(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x4170
movq 0x40(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x4de0
jmp 0x57cc
leaq 0x58(%rsp), %rdi
callq 0x4200
jmp 0x57f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc8(%rsp)
movl %eax, 0xc4(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x4200
jmp 0x5802
jmp 0x57fa
addq $0x108, %rsp            # imm = 0x108
retq
movq 0xc8(%rsp), %rdi
callq 0x4620
nop
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, 0x68(%rsp)
movl %esi, 0x64(%rsp)
movl 0x64(%rsp), %eax
movq %rax, 0x28(%rsp)
callq 0x4260
movq %rax, %rcx
movq 0x28(%rsp), %rax
cmpq %rcx, %rax
jne 0x5847
movb $0x1, 0x77(%rsp)
jmp 0x5954
movq 0x20(%rsp), %rdi
movl 0x64(%rsp), %eax
movq %rax, 0x18(%rsp)
callq 0x4260
movq %rax, %rcx
movq 0x18(%rsp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x588e
movq 0x20(%rsp), %rdi
callq 0x4280
movsbl (%rax), %edi
callq 0x5c80
cmpl $-0x1, %eax
setne %al
andb $0x1, %al
movb %al, 0x77(%rsp)
jmp 0x5954
movq 0x20(%rsp), %rdi
movl 0x64(%rsp), %eax
movl %eax, %esi
callq 0x46c0
movq 0x20(%rsp), %rdi
movb (%rax), %al
movb %al, 0x17(%rsp)
movl 0x64(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x46c0
movb 0x17(%rsp), %cl
movzbl %cl, %edi
movzbl (%rax), %esi
callq 0x5cd0
movl %eax, 0x60(%rsp)
cmpl $-0x1, 0x60(%rsp)
jne 0x58da
movb $0x0, 0x77(%rsp)
jmp 0x5954
movq 0x20(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x4170
movl 0x64(%rsp), %eax
incl %eax
movl %eax, 0x10(%rsp)
movl 0x60(%rsp), %edi
callq 0x9810
movb %al, 0x16(%rsp)
jmp 0x5902
movl 0x10(%rsp), %esi
movb 0x16(%rsp), %al
notb %al
movzbl %al, %eax
andl $0x1, %eax
addl %eax, %esi
leaq 0x40(%rsp), %rdi
callq 0x5810
movb %al, 0xf(%rsp)
jmp 0x5924
movb 0xf(%rsp), %al
andb $0x1, %al
movb %al, 0x77(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x4200
jmp 0x5954
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x4200
jmp 0x595f
movb 0x77(%rsp), %al
andb $0x1, %al
addq $0x78, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x4620
nopl (%rax)
// File: IHorvalds[P]RomAna/./processing/language_support.hpp
// Function: romanian::encode(char)
static int32_t encode(char c) {
    int val = tolower(c) - 'a';
    if (isEnglishAlphabetIndex(val))
      return val;
    else
      return -1;
  }

// Assembly:
subq $0x18, %rsp
movb %dil, %al
movb %al, 0x13(%rsp)
movsbl 0x13(%rsp), %edi
callq 0x4500
subl $0x61, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %edi
callq 0x9810
testb $0x1, %al
jne 0x5cab
jmp 0x5cb5
movl 0xc(%rsp), %eax
movl %eax, 0x14(%rsp)
jmp 0x5cbd
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movb %sil, %al
movb %dil, %cl
movb %cl, 0x13(%rsp)
movb %al, 0x12(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0xa, 0xc(%rsp)
jae 0x5d44
movl 0xc(%rsp), %eax
movl %eax, %ecx
leaq 0x166b2(%rip), %rax     # 0x1c3b0
movzbl (%rax,%rcx,2), %eax
movzbl 0x13(%rsp), %ecx
cmpl %ecx, %eax
jne 0x5d35
movl 0xc(%rsp), %eax
movl %eax, %ecx
leaq 0x16698(%rip), %rax     # 0x1c3b0
movzbl 0x1(%rax,%rcx,2), %eax
movzbl 0x12(%rsp), %ecx
cmpl %ecx, %eax
jne 0x5d35
movl 0xc(%rsp), %eax
shrl %eax
addl $0x1a, %eax
movl %eax, 0x14(%rsp)
jmp 0x5d52
jmp 0x5d37
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x5cea
movsbl 0x13(%rsp), %edi
callq 0x5c80
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: IHorvalds[P]RomAna/./processing/language_support.hpp
// Function: romanian::isDiacritic(unsigned char)
static bool isDiacritic(uint8_t byte) {
    for (unsigned index = 0; index < 2 * COUNT_OF_DIACRITICS; ++index)
      if (diacritics[index][0] == byte)
        return true;
    return false;
  }

// Assembly:
movb %dil, %al
movb %al, -0x2(%rsp)
movl $0x0, -0x8(%rsp)
cmpl $0xa, -0x8(%rsp)
jae 0x5da6
movl -0x8(%rsp), %eax
movl %eax, %ecx
leaq 0x1662d(%rip), %rax     # 0x1c3b0
movzbl (%rax,%rcx,2), %eax
movzbl -0x2(%rsp), %ecx
cmpl %ecx, %eax
jne 0x5d97
movb $0x1, -0x1(%rsp)
jmp 0x5dab
jmp 0x5d99
movl -0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rsp)
jmp 0x5d6f
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x34(%rsp)
jne 0x5df0
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x5e9b
movq 0x10(%rsp), %rdi
movl 0x34(%rsp), %esi
callq 0x4bd0
movq 0x10(%rsp), %rdi
movl 0x4(%rax), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %esi
callq 0x4bd0
movl 0x8(%rax), %eax
movl %eax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl 0x20(%rcx), %eax
jae 0x5e93
movl 0x20(%rsp), %edi
movl 0x1c(%rsp), %esi
callq 0x5c00
testb $0x1, %al
jne 0x5e43
jmp 0x5e84
movq 0x10(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x4bd0
movq 0xc(%rax), %rax
movq %rax, 0x8(%rsp)
movl 0x20(%rsp), %edi
movl 0x1c(%rsp), %esi
callq 0x5c20
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
cmpl 0x34(%rsp), %eax
jne 0x5e84
movl 0x1c(%rsp), %ecx
movq 0x28(%rsp), %rax
movl %ecx, (%rax)
jmp 0x5e86
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x5e22
movl 0x24(%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: IHorvalds[P]RomAna/./processing/InflexEngineCore.cpp
// Function: InflexEngine::formWord[abi:cxx11](int)
std::string InflexEngine::formWord(int32_t ptr) {
// Create the word that ends in ptr.
  std::string ret;
  if (ptr <= 0)
    return ret;
  int32_t encoding, nextPtr = findParent(ptr, encoding);
  return formWord(nextPtr) + romanian::decode(encoding);
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movl %edx, 0xa4(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x44e0
cmpl $0x0, 0xa4(%rsp)
jg 0x5f1e
movq 0x8(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x41f0
movl $0x1, 0x7c(%rsp)
jmp 0x5fdf
movq 0x18(%rsp), %rdi
movl 0xa4(%rsp), %esi
leaq 0x78(%rsp), %rdx
callq 0x5dc0
movl %eax, 0x4(%rsp)
jmp 0x5f3a
movq 0x18(%rsp), %rsi
movl 0x4(%rsp), %eax
movl %eax, 0x74(%rsp)
movl 0x74(%rsp), %edx
leaq 0x40(%rsp), %rdi
callq 0x5eb0
jmp 0x5f57
movl 0x78(%rsp), %esi
leaq 0x20(%rsp), %rdi
callq 0x6010
jmp 0x5f67
movq 0x8(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0xad70
jmp 0x5f7d
leaq 0x20(%rsp), %rdi
callq 0x4200
leaq 0x40(%rsp), %rdi
callq 0x4200
movl $0x1, 0x7c(%rsp)
jmp 0x5fdf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x5ff9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x5fd3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x4200
leaq 0x40(%rsp), %rdi
callq 0x4200
jmp 0x5ff9
leaq 0x80(%rsp), %rdi
callq 0x4200
movq 0x10(%rsp), %rax
addq $0xb8, %rsp
retq
leaq 0x80(%rsp), %rdi
callq 0x4200
movq 0x68(%rsp), %rdi
callq 0x4620
// File: IHorvalds[P]RomAna/./processing/language_support.hpp
// Function: romanian::decode[abi:cxx11](int)
static std::string decode(int32_t encoding) {
    std::string ret;
    if (isEnglishAlphabetIndex(encoding)) {
      ret = 'a' + encoding;
    } else {
      // Case for diacritics
      ret = "UNKNOWN";
      for (unsigned index = 0; index < COUNT_OF_DIACRITICS; ++index)
        if ((ENGLISH_SIGMA + index) == encoding)
          ret = solveDiacritics[encoding - ENGLISH_SIGMA];
    }
    return ret;
  }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movb $0x0, 0x2b(%rsp)
callq 0x44e0
movl 0x2c(%rsp), %edi
callq 0x9810
testb $0x1, %al
jne 0x6043
jmp 0x607b
movq 0x8(%rsp), %rdi
movl 0x2c(%rsp), %eax
addl $0x61, %eax
movsbl %al, %esi
callq 0x45c0
jmp 0x6059
jmp 0x60de
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x4200
jmp 0x60fe
movq 0x8(%rsp), %rdi
leaq 0xf543(%rip), %rsi      # 0x155ca
callq 0x44c0
jmp 0x608e
movl $0x0, 0x18(%rsp)
cmpl $0x5, 0x18(%rsp)
jae 0x60dc
movl 0x18(%rsp), %eax
addl $0x1a, %eax
cmpl 0x2c(%rsp), %eax
jne 0x60cd
movq 0x8(%rsp), %rdi
movl 0x2c(%rsp), %eax
addl $-0x1a, %eax
shlq $0x5, %rax
leaq 0x1632f(%rip), %rsi     # 0x1c3f0
addq %rax, %rsi
callq 0x4060
jmp 0x60cb
jmp 0x60cd
jmp 0x60cf
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x6096
jmp 0x60de
movb $0x1, 0x2b(%rsp)
testb $0x1, 0x2b(%rsp)
jne 0x60f4
movq 0x8(%rsp), %rdi
callq 0x4200
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x4620
nopl (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rcx
movl 0x1c(%rsp), %eax
cmpl 0x28(%rcx), %eax
ja 0x70c6
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x4bd0
cmpq $0x0, 0xc(%rax)
je 0x70b7
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x4bd0
movq 0xc(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x70b5
movq 0x8(%rsp), %rdi
callq 0x4460
jmp 0x70b7
jmp 0x70b9
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x706b
movq 0x10(%rsp), %rax
cmpl $0x0, 0x28(%rax)
je 0x70ef
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x70ed
movq (%rsp), %rdi
callq 0x4460
jmp 0x70ef
movq 0x10(%rsp), %rax
cmpl $0x0, 0x1c(%rax)
je 0x7108
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x43f0
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x7050
movq (%rsp), %rdi
movl $0x1, (%rdi)
movl $0x0, 0x1c(%rdi)
movq $0x0, 0x10(%rdi)
movq 0x8(%rsp), %rsi
callq 0x63e0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0xa8, %rsp
movq %rdx, 0x18(%rsp)
movq %rdi, %rax
movq 0x18(%rsp), %rdi
movq %rsi, 0x20(%rsp)
movq %rdi, 0x28(%rsp)
movq %rax, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdi, 0x90(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x30(%rsp)
callq 0xaea0
testb $0x1, %al
jne 0x724e
jmp 0x7253
jmp 0x72db
movq 0x20(%rsp), %rsi
leaq 0x68(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x4170
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq 0x8c(%rsp), %rdx
callq 0x4f20
movl %eax, 0x14(%rsp)
jmp 0x7284
leaq 0x68(%rsp), %rdi
callq 0x4200
movl 0x14(%rsp), %eax
movq 0x28(%rsp), %rsi
movl %eax, 0x88(%rsp)
leaq 0x38(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x4170
movq 0x30(%rsp), %rdi
movq (%rsp), %rdx
movl 0x88(%rsp), %ecx
xorl %r8d, %r8d
leaq 0x8c(%rsp), %r9
movl %r8d, %esi
callq 0x5170
jmp 0x72d1
leaq 0x38(%rsp), %rdi
callq 0x4200
addq $0xa8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x4200
jmp 0x7315
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x4200
movq 0x60(%rsp), %rdi
callq 0x4620
nop
// File: IHorvalds[P]RomAna/./processing/special_characters.hpp
// Function: specialChars::cleanUpWord(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
static std::string cleanUpWord(std::string word) {
    if (!word.empty()) {
      // First get rid of the punctuation of 1 byte, using "ispunct"
      word.erase(std::remove_if(word.begin(), word.end(), ::ispunct), word.end());
      
      // Also get rid of digits
      word.erase(std::remove_if(word.begin(), word.end(), ::isdigit), word.end());
      
      // And the white spaces
      word.erase(std::remove_if(word.begin(), word.end(), ::isspace), word.end());
#if 0
      // TODO: fix it
      // Then look at the punctuation of many more bytes
      for (int i = 0; i < word.size(); i++) {
        int amount = isPunctuation(&word[i]) + isdigit(word[i]);
        word.erase(i, amount);
        i -= (amount > 0);
      }
#endif
    }
    return word;
  }

// Assembly:
subq $0xd8, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, %rax
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
movq %rax, %rcx
movq %rcx, 0x18(%rsp)
movq %rax, 0xd0(%rsp)
movq %rdi, 0xc8(%rsp)
callq 0x45d0
testb $0x1, %al
jne 0x775e
movq 0x8(%rsp), %rdi
callq 0x42f0
movq 0x8(%rsp), %rdi
movq %rax, 0xb0(%rsp)
callq 0x41e0
movq %rax, 0xa8(%rsp)
movq 0xb0(%rsp), %rdi
movq 0xa8(%rsp), %rsi
movq 0x149ff(%rip), %rdx     # 0x1bfe8
callq 0xd490
movq %rax, 0xb8(%rsp)
leaq 0xc0(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0xd4f0
movq 0x8(%rsp), %rdi
callq 0x41e0
movq %rax, 0x98(%rsp)
leaq 0xa0(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0xd4f0
movq 0x8(%rsp), %rdi
movq 0xc0(%rsp), %rsi
movq 0xa0(%rsp), %rdx
callq 0x40d0
movq 0x8(%rsp), %rdi
movq %rax, 0x90(%rsp)
callq 0x42f0
movq 0x8(%rsp), %rdi
movq %rax, 0x78(%rsp)
callq 0x41e0
movq %rax, 0x70(%rsp)
movq 0x78(%rsp), %rdi
movq 0x70(%rsp), %rsi
movq 0x1493d(%rip), %rdx     # 0x1bfc0
callq 0xd490
movq %rax, 0x80(%rsp)
leaq 0x88(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0xd4f0
movq 0x8(%rsp), %rdi
callq 0x41e0
movq %rax, 0x60(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0xd4f0
movq 0x8(%rsp), %rdi
movq 0x88(%rsp), %rsi
movq 0x68(%rsp), %rdx
callq 0x40d0
movq 0x8(%rsp), %rdi
movq %rax, 0x58(%rsp)
callq 0x42f0
movq 0x8(%rsp), %rdi
movq %rax, 0x40(%rsp)
callq 0x41e0
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x1488a(%rip), %rdx     # 0x1bf98
callq 0xd490
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xd4f0
movq 0x8(%rsp), %rdi
callq 0x41e0
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xd4f0
movq 0x8(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x40d0
movq %rax, 0x20(%rsp)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
callq 0x41f0
movq 0x18(%rsp), %rax
addq $0xd8, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movl %esi, 0x8c(%rsp)
movq %rdx, 0x80(%rsp)
movq 0x90(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl 0x8c(%rsp), %esi
callq 0x4bd0
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x7cd8
movq 0x18(%rsp), %rdi
movl 0x8c(%rsp), %esi
callq 0x4bd0
movl (%rax), %eax
shrl %eax
cmpl $0x0, %eax
je 0x7cd8
movq 0x18(%rsp), %rdi
movq 0x80(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x8c(%rsp), %esi
callq 0x4bd0
movq 0x18(%rsp), %rsi
movl (%rax), %eax
shrl %eax
movl %eax, 0x54(%rsp)
movl 0x8c(%rsp), %edx
leaq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x5eb0
movq 0x10(%rsp), %rdx
leaq 0x58(%rsp), %rdi
leaq 0x54(%rsp), %rsi
callq 0xb0d0
jmp 0x7c7a
movq 0x8(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0xb0a0
jmp 0x7c8b
leaq 0x58(%rsp), %rdi
callq 0xb110
leaq 0x30(%rsp), %rdi
callq 0x4200
jmp 0x7cd8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x7cc9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x58(%rsp), %rdi
callq 0xb110
leaq 0x30(%rsp), %rdi
callq 0x4200
jmp 0x7d72
movl $0x0, 0x20(%rsp)
movq 0x18(%rsp), %rdi
movl 0x20(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x8c(%rsp), %esi
callq 0x4bd0
movl 0x8(%rax), %edi
callq 0x5bc0
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jae 0x7d6a
movq 0x18(%rsp), %rdi
movl 0x8c(%rsp), %esi
callq 0x4bd0
movq 0xc(%rax), %rax
movl 0x20(%rsp), %ecx
cmpl $0x0, (%rax,%rcx,4)
je 0x7d58
movq 0x18(%rsp), %rdi
movl 0x8c(%rsp), %esi
callq 0x4bd0
movq 0x18(%rsp), %rdi
movq 0xc(%rax), %rax
movl 0x20(%rsp), %ecx
movl (%rax,%rcx,4), %esi
movq 0x80(%rsp), %rdx
callq 0x7bc0
jmp 0x7d5a
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x7ce0
addq $0x98, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x4620
nopl (%rax)
// File: IHorvalds[P]RomAna/./processing/InflexEngine.hpp
// Function: InflexEngineNode::InflexEngineNode()
InflexEngineNode() {  
    this->code = 0;
    this->parent = 0;
    this->configuration = 0;
    this->sons = nullptr;
  }

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl $0x0, (%rax)
movl $0x0, 0x4(%rax)
movl $0x0, 0x8(%rax)
movq $0x0, 0xc(%rax)
retq
nopw (%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rsi, 0x30(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
callq 0x43e0
movq 0x28(%rsp), %rax
movl $0x400, 0x608(%rax)     # imm = 0x400
movl $0x0, 0x610(%rax)
movl $0x400, 0x614(%rax)     # imm = 0x400
movl $0x8, %edi
movl $0x4, %esi
callq 0xb010
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
movl %eax, %edx
callq 0x42e0
jmp 0xb28f
movq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x44b0
jmp 0xb2a4
movq 0x20(%rsp), %rdi
callq 0x4610
movq %rdx, 0x10(%rsp)
movq %rax, 0x18(%rsp)
jmp 0xb2ba
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0x38(%rsp)
movq %rax, 0x40(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xdb30
movq %rax, 0x8(%rsp)
jmp 0xb2df
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rax
movl %eax, 0x60c(%rdi)
xorl %edx, %edx
movl %edx, %esi
callq 0x44b0
jmp 0xb2fa
addq $0x68, %rsp
retq
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
callq 0x4100
movq 0x50(%rsp), %rdi
callq 0x4620
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: IHorvalds[P]RomAna/./processing/util.hpp
// Function: LocalGiniGenerator::save()
void save() {
    std::string rCommand = "Rscript helpers/compute_local_ginis.R " + poet;
    int warning = system(rCommand.data());
    std::string pyCommand = "python3 helpers/compute_local_richness.py " + poet;
    warning = system(pyCommand.data());
  }

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq 0x80(%rsp), %rdx
movq %rdx, 0x10(%rsp)
leaq 0x9a36(%rip), %rsi      # 0x15709
leaq 0x60(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xb330
movq 0x18(%rsp), %rdi
callq 0x41d0
movq %rax, %rdi
callq 0x42d0
movl %eax, 0x24(%rsp)
jmp 0xbcfa
movq 0x10(%rsp), %rdx
movl 0x24(%rsp), %eax
movl %eax, 0x5c(%rsp)
leaq 0x9a22(%rip), %rsi      # 0x15730
leaq 0x28(%rsp), %rdi
callq 0xb330
jmp 0xbd1a
leaq 0x28(%rsp), %rdi
callq 0x41d0
movq %rax, %rdi
callq 0x42d0
movl %eax, 0xc(%rsp)
jmp 0xbd32
movl 0xc(%rsp), %eax
movl %eax, 0x5c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x4200
leaq 0x60(%rsp), %rdi
callq 0x4200
addq $0x88, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0xbd7e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x4200
leaq 0x60(%rsp), %rdi
callq 0x4200
movq 0x50(%rsp), %rdi
callq 0x4620
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: IHorvalds[P]RomAna/./processing/util.hpp
// Function: EssenceGenerator::save()
void save() {
    std::string pyCommand1 = "python3 helpers/compute_local_essentials.py " + poet + " " + distributionType + " " + std::to_string(procentOfWork);
    int warning = system(pyCommand1.data());
    
    if (sortValues) {
      std::string pyCommand2 = "python3 helpers/sort_local_distribution.py " + poet + " essential";
      warning = system(pyCommand2.data());
    }
  }

// Assembly:
subq $0x138, %rsp            # imm = 0x138
movq %rdi, 0x130(%rsp)
movq 0x130(%rsp), %rdx
movq %rdx, 0x8(%rsp)
leaq 0x9908(%rip), %rsi      # 0x1575b
leaq 0x90(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xb330
movq 0x10(%rsp), %rsi
leaq 0x9325(%rip), %rdx      # 0x15196
leaq 0xb0(%rsp), %rdi
callq 0xb6e0
jmp 0xbe80
movq 0x8(%rsp), %rdx
addq $0x20, %rdx
leaq 0xd0(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x13220
jmp 0xbea0
leaq 0x92ef(%rip), %rdx      # 0x15196
leaq 0xf0(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
callq 0xb6e0
jmp 0xbebe
leaq 0x60(%rsp), %rdi
movsd 0x9145(%rip), %xmm0     # 0x15010
callq 0x13270
jmp 0xbed2
leaq 0x110(%rsp), %rdi
leaq 0xf0(%rsp), %rsi
leaq 0x60(%rsp), %rdx
callq 0xad70
jmp 0xbeee
leaq 0x60(%rsp), %rdi
callq 0x4200
leaq 0xf0(%rsp), %rdi
callq 0x4200
leaq 0xd0(%rsp), %rdi
callq 0x4200
leaq 0xb0(%rsp), %rdi
callq 0x4200
leaq 0x90(%rsp), %rdi
callq 0x4200
leaq 0x110(%rsp), %rdi
callq 0x41d0
movq %rax, %rdi
callq 0x42d0
movl %eax, 0x4(%rsp)
jmp 0xbf47
movq 0x8(%rsp), %rax
movl 0x4(%rsp), %ecx
movl %ecx, 0x5c(%rsp)
testb $0x1, 0x40(%rax)
je 0xc0ca
movq 0x8(%rsp), %rdx
leaq 0x981e(%rip), %rsi      # 0x15788
leaq 0x18(%rsp), %rdi
callq 0xb330
jmp 0xbf76
leaq 0x9837(%rip), %rdx      # 0x157b4
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xb6e0
jmp 0xbf8e
leaq 0x18(%rsp), %rdi
callq 0x4200
leaq 0x38(%rsp), %rdi
callq 0x41d0
movq %rax, %rdi
callq 0x42d0
movl %eax, (%rsp)
jmp 0xbfaf
movl (%rsp), %eax
movl %eax, 0x5c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x4200
jmp 0xc0ca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0xc065
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0xc058
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0xc04b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0xc03e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x4200
leaq 0xf0(%rsp), %rdi
callq 0x4200
leaq 0xd0(%rsp), %rdi
callq 0x4200
leaq 0xb0(%rsp), %rdi
callq 0x4200
leaq 0x90(%rsp), %rdi
callq 0x4200
jmp 0xc0ec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0xc0df
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x4200
jmp 0xc0df
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x4200
jmp 0xc0df
leaq 0x110(%rsp), %rdi
callq 0x4200
addq $0x138, %rsp            # imm = 0x138
retq
leaq 0x110(%rsp), %rdi
callq 0x4200
movq 0x88(%rsp), %rdi
callq 0x4620
nopl (%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq %rcx, (%rsp)
movl 0x610(%rcx), %eax
cmpl 0x60c(%rcx), %eax
jne 0xdb67
movb $0x0, 0x17(%rsp)
jmp 0xdbe3
movq (%rsp), %rcx
movl 0x614(%rcx), %eax
cmpl 0x608(%rcx), %eax
jne 0xdbb1
movq (%rsp), %rdi
movl $0x0, 0x614(%rdi)
movq %rdi, %rsi
addq $0x208, %rsi            # imm = 0x208
movl $0x400, %edx            # imm = 0x400
callq 0x4440
movq (%rsp), %rdi
callq 0x46d0
movq %rax, %rcx
movq (%rsp), %rax
movl %ecx, 0x608(%rax)
movq (%rsp), %rax
movl 0x610(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x610(%rax)
movl 0x614(%rax), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x614(%rax)
movslq %ecx, %rcx
movb 0x208(%rax,%rcx), %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
addq $0x18, %rsp
retq
nopl (%rax)
// File: IHorvalds[P]RomAna/./processing/parserOltean.hpp
// Function: text::isUnallowed(char)
static bool isUnallowed(char c) {
    for (unsigned index = 0; index < COUNT_UNALLOWED; ++index) {
      if (unallowed[index] == c)
        return true;
    }
    return false;
  }

// Assembly:
movb %dil, %al
movb %al, -0x2(%rsp)
movl $0x0, -0x8(%rsp)
cmpl $0x6, -0x8(%rsp)
jae 0xdc76
movl -0x8(%rsp), %eax
movl %eax, %ecx
leaq 0x7c20(%rip), %rax      # 0x15873
movsbl (%rax,%rcx), %eax
movsbl -0x2(%rsp), %ecx
cmpl %ecx, %eax
jne 0xdc67
movb $0x1, -0x1(%rsp)
jmp 0xdc7b
jmp 0xdc69
movl -0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rsp)
jmp 0xdc3f
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0xffffffff, -0x10(%rbp) # imm = 0xFFFFFFFF
movl $0x5, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x50(%rbp), %rdi
movl -0x18(%rbp), %eax
movq %rax, -0x58(%rbp)
callq 0x31f0
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jae 0x4a92
movl -0xc(%rbp), %esi
movq 0x105f6(%rip), %rdi     # 0x14fd8
callq 0x3480
movq %rax, %rdi
leaq 0x973f(%rip), %rsi      # 0xe130
callq 0x32b0
xorl %eax, %eax
cmpl $-0x1, -0x10(%rbp)
movb %al, -0x59(%rbp)
jne 0x4a15
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x0, %eax
setne %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x4a1e
jmp 0x4a80
movq -0x50(%rbp), %rsi
movq 0x10897(%rip), %rax     # 0x152c0
movq %rax, -0x70(%rbp)
movslq -0x18(%rbp), %rdx
leaq -0x38(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movl $0x1000, %ecx           # imm = 0x1000
callq 0x32f0
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movl -0xc(%rbp), %edx
callq 0x45b0
movl %eax, -0x60(%rbp)
jmp 0x4a58
movl -0x60(%rbp), %eax
movl %eax, -0x10(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31c0
jmp 0x49f6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31c0
jmp 0x4ab9
jmp 0x4a82
movl -0x18(%rbp), %eax
addl $0x1000, %eax           # imm = 0x1000
movl %eax, -0x18(%rbp)
jmp 0x49b8
cmpl $-0x1, -0x10(%rbp)
jne 0x4aa7
movq 0x108b1(%rip), %rdi     # 0x15350
movl -0xc(%rbp), %esi
callq 0x7980
leaq 0x1081a(%rip), %rdi     # 0x152c8
callq 0x3220
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3490
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq 0xd92a(%rip), %rdi      # 0x152c8
callq 0x3400
movq -0x38(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x7a00
movq -0x38(%rbp), %rdi
movl %eax, -0x10(%rbp)
callq 0x7db0
movq %rax, -0x28(%rbp)
movslq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x9400
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x9440
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x9390
movq %rax, -0x30(%rbp)
leaq 0xd8d3(%rip), %rdi      # 0x152c8
callq 0x3220
addq $0x40, %rsp
popq %rbp
retq
// File: 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
subq $0x110, %rsp            # imm = 0x110
movq %rdx, -0x108(%rbp)
movq %rcx, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x100(%rbp)
leaq 0xc9be(%rip), %rdi      # 0x152c8
callq 0x3400
movq -0x108(%rbp), %rsi
movq -0x100(%rbp), %rax
movl 0x18(%rax), %ecx
movl %ecx, -0xf8(%rbp)
incl %ecx
movl %ecx, 0x18(%rax)
movl -0xc(%rbp), %eax
movl %eax, -0xf4(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x3140
movq -0xf0(%rbp), %rsi
leaq -0xd8(%rbp), %rdi
callq 0x3140
jmp 0x8955
movl -0xf4(%rbp), %edx
movl -0xf8(%rbp), %esi
leaq -0x98(%rbp), %rdi
leaq -0xb8(%rbp), %rcx
leaq -0xd8(%rbp), %r8
callq 0x9e10
jmp 0x897d
leaq -0xd8(%rbp), %rdi
callq 0x31c0
leaq -0xb8(%rbp), %rdi
callq 0x31c0
movq -0x100(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x9f00
jmp 0x89aa
leaq 0xc917(%rip), %rdi      # 0x152c8
callq 0x3220
leaq -0x98(%rbp), %rdi
callq 0x8020
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe0(%rbp)
movl %eax, -0xe4(%rbp)
jmp 0x89fd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe0(%rbp)
movl %eax, -0xe4(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x31c0
leaq -0xb8(%rbp), %rdi
callq 0x31c0
jmp 0x8a29
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe0(%rbp)
movl %eax, -0xe4(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x8020
movq -0xe0(%rbp), %rdi
callq 0x3490
nopw %cs:(%rax,%rax)
nop
// File: davidcairuz[P]network-internet-relay-chat/server.cpp
// Function: Client::Client(int, 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>>)
Client(int id, int conn, string name, string ip) {
        this->id = id;
        this->ip = ip;
        this->conn = conn;
        this->name = name;

        this->channel_name = "$";
        this->is_admin = false;
        this->is_muted = false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rcx, -0x60(%rbp)
movq %r8, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x8, %rdi
movq %rdi, -0x40(%rbp)
callq 0x33d0
movq -0x48(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x58(%rbp)
callq 0x33d0
movq -0x48(%rbp), %rdi
addq $0x50, %rdi
movq %rdi, -0x50(%rbp)
callq 0x33d0
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
callq 0x3050
jmp 0x9e81
movq -0x60(%rbp), %rsi
movq -0x48(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, 0x4(%rdi)
addq $0x28, %rdi
callq 0x3050
jmp 0x9e9a
movq -0x48(%rbp), %rdi
addq $0x50, %rdi
leaq 0x4294(%rip), %rsi      # 0xe13d
callq 0x33c0
jmp 0x9eb0
movq -0x48(%rbp), %rax
movb $0x0, 0x70(%rax)
movb $0x0, 0x71(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x31c0
movq -0x58(%rbp), %rdi
callq 0x31c0
movq -0x40(%rbp), %rdi
callq 0x31c0
movq -0x28(%rbp), %rdi
callq 0x3490
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: shinerd[P]BriefRenderer/main.cpp
// Function: boundary_x(Vec2<int>, Vec2<int>, int)
int boundary_x(Vec2i v0, Vec2i v1, int y){
    float x;
    if (v1.y != v0.y){  // ...
        x = static_cast<float>(v1.x - v0.x) / (v1.y - v0.y) * (y - v0.y) + v0.x;
    }
    return static_cast<int>(x + 0.5);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x4(%rbp), %eax
je 0x260b
movl -0x10(%rbp), %eax
subl -0x8(%rbp), %eax
cvtsi2ss %eax, %xmm0
movl -0xc(%rbp), %eax
subl -0x4(%rbp), %eax
cvtsi2ss %eax, %xmm1
divss %xmm1, %xmm0
movl -0x14(%rbp), %eax
subl -0x4(%rbp), %eax
cvtsi2ss %eax, %xmm2
cvtsi2ssl -0x8(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x18(%rbp)
movss -0x18(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x59ec(%rip), %xmm1     # 0x8008
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: shinerd[P]BriefRenderer/main.cpp
// Function: boundary_y(Vec2<int>, Vec2<int>, int)
int boundary_y(Vec2i v0, Vec2i v1, int x){
    float y;
    if (v1.x != v0.x){
        y = static_cast<float>(v1.y - v0.y) / (v1.x - v0.x) * (x - v0.x) + v0.y;
    }
    return static_cast<int>(y + 0.5);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x8(%rbp), %eax
je 0x267b
movl -0xc(%rbp), %eax
subl -0x4(%rbp), %eax
cvtsi2ss %eax, %xmm0
movl -0x10(%rbp), %eax
subl -0x8(%rbp), %eax
cvtsi2ss %eax, %xmm1
divss %xmm1, %xmm0
movl -0x14(%rbp), %eax
subl -0x8(%rbp), %eax
cvtsi2ss %eax, %xmm2
cvtsi2ssl -0x4(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x18(%rbp)
movss -0x18(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x597c(%rip), %xmm1     # 0x8008
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: shinerd[P]BriefRenderer/tgaimage.cpp
// Function: TGAImage::TGAImage(TGAImage const&)
TGAImage::TGAImage(const TGAImage &img) {
    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);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x8(%rcx)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, 0xc(%rcx)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, 0x10(%rcx)
movl 0x8(%rcx), %eax
imull 0xc(%rcx), %eax
imull 0x10(%rcx), %eax
cltq
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2040
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x2190
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq -0x10(%rbp), %rax
je 0x653d
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x64e4
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x64e2
movq -0x28(%rbp), %rdi
callq 0x2230
jmp 0x64e4
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x8(%rcx)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, 0xc(%rcx)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, 0x10(%rcx)
movl 0x8(%rcx), %eax
imull 0xc(%rcx), %eax
imull 0x10(%rcx), %eax
cltq
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2040
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x2190
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: shinerd[P]BriefRenderer/tgaimage.cpp
// Function: TGAImage::flip_vertically()
bool TGAImage::flip_vertically() {
    if (!data) return false;
    unsigned long bytes_per_line = width*bytespp;
    unsigned char *line = new unsigned char[bytes_per_line];
    int half = height>>1;
    for (int j=0; j<half; j++) {
        unsigned long l1 = j*bytes_per_line;
        unsigned long l2 = (height-1-j)*bytes_per_line;
        memmove((void *)line,      (void *)(data+l1), bytes_per_line);
        memmove((void *)(data+l1), (void *)(data+l2), bytes_per_line);
        memmove((void *)(data+l2), (void *)line,      bytes_per_line);
    }
    delete [] line;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, (%rax)
jne 0x6d53
movb $0x0, -0x1(%rbp)
jmp 0x6e22
movq -0x40(%rbp), %rcx
movl 0x8(%rcx), %eax
imull 0x10(%rcx), %eax
cltq
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2040
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x20(%rbp)
movl 0xc(%rax), %eax
sarl %eax
movl %eax, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x6e07
movq -0x40(%rbp), %rax
movslq -0x28(%rbp), %rcx
imulq -0x18(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movl 0xc(%rax), %ecx
subl $0x1, %ecx
subl -0x28(%rbp), %ecx
movslq %ecx, %rcx
imulq -0x18(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movq -0x20(%rbp), %rdi
movq (%rax), %rsi
addq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x22f0
movq -0x40(%rbp), %rax
movq (%rax), %rdi
addq -0x30(%rbp), %rdi
movq (%rax), %rsi
addq -0x38(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x22f0
movq -0x40(%rbp), %rax
movq (%rax), %rdi
addq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x22f0
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x6d87
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x6e1e
movq -0x48(%rbp), %rdi
callq 0x2230
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, (%rax)
jne 0x6e53
movb $0x0, -0x1(%rbp)
jmp 0x6f39
movq -0x48(%rbp), %rax
movl 0x8(%rax), %eax
sarl %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x6f35
movl $0x0, -0x1c(%rbp)
movq -0x48(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x6f25
movq -0x48(%rbp), %rsi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
leaq -0x24(%rbp), %rdi
callq 0x7690
movq -0x48(%rbp), %rsi
movl 0x8(%rsi), %edx
subl $0x1, %edx
subl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
leaq -0x2c(%rbp), %rdi
callq 0x7690
movl -0x18(%rbp), %eax
movl %eax, -0x58(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x54(%rbp)
leaq -0x34(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x2fe0
movl -0x58(%rbp), %esi
movl -0x54(%rbp), %edx
movq -0x48(%rbp), %rdi
leaq -0x34(%rbp), %rcx
callq 0x7730
movq -0x48(%rbp), %rax
movl 0x8(%rax), %eax
subl $0x1, %eax
subl -0x18(%rbp), %eax
movl %eax, -0x50(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x4c(%rbp)
leaq -0x3c(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x2fe0
movq -0x48(%rbp), %rdi
movl -0x50(%rbp), %esi
movl -0x4c(%rbp), %edx
leaq -0x3c(%rbp), %rcx
callq 0x7730
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6e79
jmp 0x6f27
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x6e66
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rcx, -0x30(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, (%rax)
je 0x777c
cmpl $0x0, -0x14(%rbp)
jl 0x777c
cmpl $0x0, -0x18(%rbp)
jl 0x777c
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x777c
movq -0x28(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0xc(%rcx), %eax
jl 0x7782
movb $0x0, -0x1(%rbp)
jmp 0x77b0
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %edx
imull 0x8(%rax), %edx
addl %edx, %ecx
imull 0x10(%rax), %ecx
movslq %ecx, %rcx
addq %rcx, %rdi
movslq 0x10(%rax), %rdx
callq 0x2190
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)