LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ruankotovich[P]B-Tree/src/primarybtree.cpp
// Function: PrimaryBTree::insert(int, _IO_FILE*)
void PrimaryBTree::insert(int key, FILE* indexFile)
{ // [TROCAR]
    auto result = insertRecursive(key, root, rootOffset, indexFile);

    if (result.hasBeenSplit) { // se tiver um promovido vindo de um split abaixo
        PrimaryBTreeNodeReinterpret* newRoot = new PrimaryBTreeNodeReinterpret();
        newRoot->node.insert(result.promotedKey); // insere a key promovida do nível abaixo
        newRoot->node.blockPointers[0] = rootOffset; //apontador esquerdo -> antiga raíz

        // considerando que o block splittado já foi salvo no arquivo na função insertRecursive
        newRoot->node.blockPointers[1] = result.newBlockOffset;
        newRoot->node.countPointers = 2;

        // salvar o newRoot no arquivo da PrimaryBTree
        rootOffset = writeNewNode(&newRoot->node, indexFile);

        // atualizar o header
        fseek(indexFile, 0, SEEK_SET);

        fwrite(&rootOffset, sizeof(AbstractBlock_t), 1, indexFile);

        delete (root);
        root = newRoot;

        fseek(indexFile, 0, SEEK_END);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movl -0xc(%rbp), %esi
movq 0x10(%rdi), %rdx
movzwl 0x18(%rdi), %ecx
movq -0x18(%rbp), %r8
callq 0x3870
movw %dx, -0x30(%rbp)
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x24(%rbp)
movw -0x30(%rbp), %ax
movw %ax, -0x1c(%rbp)
testb $0x1, -0x24(%rbp)
je 0x4449
movl $0x1000, %edi           # imm = 0x1000
callq 0x10b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
callq 0x4700
jmp 0x436c
movq -0x60(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x3660
movq -0x58(%rbp), %rax
movw 0x18(%rax), %cx
movq -0x40(%rbp), %rax
movw %cx, 0xaa4(%rax)
movw -0x1c(%rbp), %cx
movq -0x40(%rbp), %rax
movw %cx, 0xaa6(%rax)
movq -0x40(%rbp), %rax
movw $0x2, 0x2(%rax)
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x47b0
movl %eax, %ecx
movq -0x58(%rbp), %rax
movw %cx, 0x18(%rax)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x10d0
movq -0x58(%rbp), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rcx
movl $0x1000, %esi           # imm = 0x1000
movl $0x1, %edx
callq 0x1160
movq -0x58(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
je 0x440d
movq -0x68(%rbp), %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0x10c0
movq -0x58(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x10d0
jmp 0x4449
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
movl $0x1000, %esi           # imm = 0x1000
callq 0x10c0
jmp 0x444f
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x1140
nopl (%rax,%rax)
// File: ruankotovich[P]B-Tree/src/primarybtree.cpp
// Function: relativeKeyPosition(int, int, int)
char inline relativeKeyPosition(int key, int leftMiddle, int rightMiddle)
{
    if (key < leftMiddle) {
        return RELATIVE_LEFT;
    } else if (key > rightMiddle) {
        return RELATIVE_RIGHT;
    }

    return RELATIVE_MIDDLE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x478b
movb $-0x1, -0x1(%rbp)
jmp 0x479f
movl -0x8(%rbp), %eax
cmpl -0x10(%rbp), %eax
jle 0x4799
movb $0x1, -0x1(%rbp)
jmp 0x479f
jmp 0x479b
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: ruankotovich[P]B-Tree/src/article.cpp
// Function: Article_t::Article_t(int, char*, int, char*, int, char*, char*)
Article_t::Article_t(int id, char title[FIELD_TITLE_MAX_SIZE], int year, char authors[FIELD_AUTHORS_MAX_SIZE], int citations, char date[FIELD_DATE_MAX_SIZE], char snippet[FIELD_SNIPPET_MAX_SIZE])
: id(id)
, year(year)
, citations(citations)
{
  std::memcpy(this->title, title, FIELD_TITLE_MAX_SIZE);
  std::memcpy(this->authors, authors, FIELD_AUTHORS_MAX_SIZE);
  std::memcpy(this->date, date, FIELD_DATE_MAX_SIZE);
  std::memcpy(this->snippet, snippet, FIELD_SNIPPET_MAX_SIZE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl -0xc(%rbp), %eax
movl %eax, (%rdi)
movl -0x1c(%rbp), %eax
movl %eax, 0x130(%rdi)
movl -0x2c(%rbp), %eax
movl %eax, 0x534(%rdi)
addq $0x4, %rdi
movq -0x18(%rbp), %rsi
movl $0x12c, %edx            # imm = 0x12C
callq 0x1070
movq -0x38(%rbp), %rdi
addq $0x134, %rdi            # imm = 0x134
movq -0x28(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x1070
movq -0x38(%rbp), %rdi
movq 0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, 0x538(%rdi)
movq 0x8(%rax), %rcx
movq %rcx, 0x540(%rdi)
movl 0x10(%rax), %eax
movl %eax, 0x548(%rdi)
addq $0x54c, %rdi            # imm = 0x54C
movq 0x18(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x1070
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ruankotovich[P]B-Tree/src/block.cpp
// Function: Block_t::tryPutArticle(Article_t&)
bool Block_t::tryPutArticle(Article_t& article)
{
  Header_Interpretation_t* headerOnBytes = (Header_Interpretation_t*)(&this->content[0]);
  Tail_Interpretation_t* tailOnBytes = (Tail_Interpretation_t*)(&this->content[TAIL_LOCATION]);

  unsigned char position = headerOnBytes->struct_header.count;
  unsigned int realPosition = DATA_LOCATION + (position * sizeof(Article_t));

  if (realPosition < BLOCK_SIZE - sizeof(Article_t)) {
    Article_Interpretation_t* articleOnBytes = (Article_Interpretation_t*)(&this->content[realPosition]);

    std::memcpy(&articleOnBytes->struct_article, &article, sizeof(Article_Interpretation_t));

    ++headerOnBytes->struct_header.count;
    tailOnBytes->struct_tail.verificationMask = headerOnBytes->struct_header.verificationMask = VERIFICATION_MASK;

    return true;
  }

  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq %rax, -0x20(%rbp)
addq $0xff7, %rax            # imm = 0xFF7
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movb 0x8(%rax), %al
movb %al, -0x29(%rbp)
movzbl -0x29(%rbp), %eax
imulq $0x94c, %rax, %rax      # imm = 0x94C
addq $0x9, %rax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpq $0x6b4, %rax            # imm = 0x6B4
jae 0x5012
movq -0x40(%rbp), %rax
movl -0x30(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x94c, %edx            # imm = 0x94C
callq 0x1070
movq -0x20(%rbp), %rax
movb 0x8(%rax), %cl
addb $0x1, %cl
movb %cl, 0x8(%rax)
movq -0x20(%rbp), %rax
movabsq $0x1591c7f96733dc5d, %rcx # imm = 0x1591C7F96733DC5D
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movabsq $0x1591c7f96733dc5d, %rcx # imm = 0x1591C7F96733DC5D
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x5016
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ruankotovich[P]B-Tree/src/block.cpp
// Function: Block_t::validate()
void Block_t::validate(){
  Header_Interpretation_t* headerOnBytes = (Header_Interpretation_t*)(&this->content[0]);
  Tail_Interpretation_t* tailOnBytes = (Tail_Interpretation_t*)(&this->content[TAIL_LOCATION]);
  tailOnBytes->struct_tail.verificationMask = headerOnBytes->struct_header.verificationMask = VERIFICATION_MASK;
  headerOnBytes->struct_header.count = 0b0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
addq $0xff7, %rax            # imm = 0xFF7
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movabsq $0x1591c7f96733dc5d, %rcx # imm = 0x1591C7F96733DC5D
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movabsq $0x1591c7f96733dc5d, %rcx # imm = 0x1591C7F96733DC5D
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x8(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ruankotovich[P]B-Tree/src/hashfilefactory.cpp
// Function: HashFileFactory::createBinaryFilePerfectHash(_IO_FILE*, _IO_FILE*)
void HashFileFactory::createBinaryFilePerfectHash(FILE *toRead, FILE *toWrite) {
  IOHandler handler(toRead);

  FILE* primaryIndexFileWrite = fopen("files/primaryindex.block", "wb+");
  FILE* secondaryIndexFileWrite = fopen("files/secondaryindex.block", "wb+");


  PrimaryBTree pBtree;
  SecondaryBTree sBtree;

  pBtree.buildIndex(primaryIndexFileWrite);
  sBtree.buildIndex(secondaryIndexFileWrite);

  this->hashSize = handler.getBiggestId();

  Article_t currentArticle;
  SecondaryBTreeDataMap key;

  while (handler.hasNext()) {
    handler >> currentArticle;
    Block_t currentBlock;
    currentBlock.tryPutArticle(currentArticle);
    currentBlock.validate();

    std::memcpy(key.key, currentArticle.title, SECONDARY_KEY_LENGTH);
    key.dataPointer = currentArticle.id;

    pBtree.insert(currentArticle.id, primaryIndexFileWrite);
    sBtree.insert(key, secondaryIndexFileWrite);

    fseek(toWrite, currentArticle.id * sizeof(Block_t), SEEK_SET);
    fwrite(&currentBlock, sizeof(Block_t), 1, toWrite);

    handler.parseNext();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x3570, %rsp           # imm = 0x3570
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x3570(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x1970(%rbp), %rdi
callq 0x1890
leaq 0xf43(%rip), %rdi       # 0x608c
leaq 0xee4(%rip), %rsi       # 0x6034
callq 0x10e0
movq %rax, -0x1978(%rbp)
leaq 0xf42(%rip), %rdi       # 0x60a5
leaq 0xeca(%rip), %rsi       # 0x6034
callq 0x10e0
movq %rax, -0x1980(%rbp)
leaq -0x19a0(%rbp), %rdi
callq 0x3700
leaq -0x1ae8(%rbp), %rdi
callq 0x1ca0
movq -0x1978(%rbp), %rsi
leaq -0x19a0(%rbp), %rdi
callq 0x3780
movq -0x1980(%rbp), %rsi
leaq -0x1ae8(%rbp), %rdi
callq 0x1d20
leaq -0x1970(%rbp), %rdi
callq 0x1370
movl %eax, %ecx
movq -0x3570(%rbp), %rax
movl %ecx, (%rax)
leaq -0x2434(%rbp), %rdi
callq 0x4b30
leaq -0x1970(%rbp), %rdi
callq 0x1870
testb $0x1, %al
jne 0x51ec
jmp 0x52c6
leaq -0x1970(%rbp), %rdi
leaq -0x2434(%rbp), %rsi
callq 0x17a0
leaq -0x3564(%rbp), %rdi
callq 0x5100
leaq -0x3564(%rbp), %rdi
leaq -0x2434(%rbp), %rsi
callq 0x4f70
leaq -0x3564(%rbp), %rdi
callq 0x5060
leaq -0x2564(%rbp), %rdi
leaq -0x2434(%rbp), %rsi
addq $0x4, %rsi
movl $0x12c, %edx            # imm = 0x12C
callq 0x1070
movl -0x2434(%rbp), %eax
movl %eax, -0x2438(%rbp)
movl -0x2434(%rbp), %esi
movq -0x1978(%rbp), %rdx
leaq -0x19a0(%rbp), %rdi
callq 0x4300
movq -0x1980(%rbp), %rdx
leaq -0x1ae8(%rbp), %rdi
leaq -0x2564(%rbp), %rsi
callq 0x2b00
movq -0x18(%rbp), %rdi
movslq -0x2434(%rbp), %rsi
shlq $0xc, %rsi
xorl %edx, %edx
callq 0x10d0
movq -0x18(%rbp), %rcx
leaq -0x3564(%rbp), %rdi
movl $0x1000, %esi           # imm = 0x1000
movl $0x1, %edx
callq 0x1160
leaq -0x1970(%rbp), %rdi
callq 0x1520
jmp 0x51d7
addq $0x3570, %rsp           # imm = 0x3570
popq %rbp
retq
nop
// File: ruankotovich[P]B-Tree/src/hashfinder.cpp
// Function: getArticleFromHash(int, Article_t*, _IO_FILE*)
bool getArticleFromHash(int id, Article_t *article, FILE *toRead) {
  Block_t block;

  fseek(toRead, sizeof(Block_t) * id, SEEK_SET);
  fread(&block, sizeof(Block_t), 1, toRead);

  if (!block.isValid()) {
    return false;
  }

  memcpy(article, block.getArticle(0), sizeof(Article_t));

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1020, %rsp           # imm = 0x1020
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x1018(%rbp), %rdi
callq 0x5100
movq -0x18(%rbp), %rdi
movslq -0x8(%rbp), %rsi
shlq $0xc, %rsi
xorl %edx, %edx
callq 0x10d0
movq -0x18(%rbp), %rcx
leaq -0x1018(%rbp), %rdi
movl $0x1000, %esi           # imm = 0x1000
movl $0x1, %edx
callq 0x1100
leaq -0x1018(%rbp), %rdi
callq 0x50b0
testb $0x1, %al
jne 0x5335
movb $0x0, -0x1(%rbp)
jmp 0x5366
movq -0x10(%rbp), %rax
movq %rax, -0x1020(%rbp)
leaq -0x1018(%rbp), %rdi
xorl %esi, %esi
callq 0x5030
movq -0x1020(%rbp), %rdi
movq %rax, %rsi
movl $0x94c, %edx            # imm = 0x94C
callq 0x1070
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x1020, %rsp           # imm = 0x1020
popq %rbp
retq
// File: xdsopl[P]FEC/./galois_field.hh
// Function: GF::Value<4, 19, unsigned char> GF::fma<4, 19, unsigned char>(GF::Index<4, 19, unsigned char>, GF::Value<4, 19, unsigned char>, GF::Value<4, 19, unsigned char>)
Value<M, POLY, TYPE> fma(Index<M, POLY, TYPE> a, Value<M, POLY, TYPE> b, Value<M, POLY, TYPE> c)
{
	assert(a.i < a.modulus());
	assert(b.v <= b.N);
	assert(c.v <= c.N);
	return !b.v ? c : (value(a * index(b)) + c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dl, %al
movb %sil, %cl
movb %dil, %dl
movb %dl, -0x2(%rbp)
movb %cl, -0x3(%rbp)
movb %al, -0x4(%rbp)
movzbl -0x2(%rbp), %eax
movl %eax, -0x10(%rbp)
callq 0xc090
movb %al, %cl
movl -0x10(%rbp), %eax
movzbl %cl, %ecx
cmpl %ecx, %eax
jge 0xbe13
jmp 0xbe32
leaq 0xd876(%rip), %rdi      # 0x19690
leaq 0xd695(%rip), %rsi      # 0x194b6
movl $0xe9, %edx
leaq 0xd875(%rip), %rcx      # 0x196a2
callq 0x2100
movzbl -0x3(%rbp), %eax
cmpl $0xf, %eax
jg 0xbe3d
jmp 0xbe5c
leaq 0xd7dd(%rip), %rdi      # 0x19621
leaq 0xd66b(%rip), %rsi      # 0x194b6
movl $0xea, %edx
leaq 0xd84b(%rip), %rcx      # 0x196a2
callq 0x2100
movzbl -0x4(%rbp), %eax
cmpl $0xf, %eax
jg 0xbe67
jmp 0xbe86
leaq 0xd8bc(%rip), %rdi      # 0x1972a
leaq 0xd641(%rip), %rsi      # 0x194b6
movl $0xeb, %edx
leaq 0xd821(%rip), %rcx      # 0x196a2
callq 0x2100
cmpb $0x0, -0x3(%rbp)
jne 0xbe94
movb -0x4(%rbp), %al
movb %al, -0x1(%rbp)
jmp 0xbee2
movb -0x2(%rbp), %al
movb %al, -0x7(%rbp)
movb -0x3(%rbp), %al
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %edi
callq 0xc200
movb %al, -0x8(%rbp)
movb -0x7(%rbp), %al
movzbl %al, %edi
movzbl -0x8(%rbp), %esi
callq 0xc110
movb %al, -0x6(%rbp)
movzbl -0x6(%rbp), %edi
callq 0xc0a0
movb %al, -0x5(%rbp)
movb -0x4(%rbp), %al
movb %al, -0xa(%rbp)
movb -0x5(%rbp), %al
movzbl %al, %edi
movzbl -0xa(%rbp), %esi
callq 0xc000
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: xdsopl[P]FEC/./galois_field.hh
// Function: GF::Index<4, 19, unsigned char> GF::operator*<4, 19, unsigned char>(GF::Index<4, 19, unsigned char>, GF::Index<4, 19, unsigned char>)
Index<M, POLY, TYPE> operator * (Index<M, POLY, TYPE> a, Index<M, POLY, TYPE> b)
{
	assert(a.i < a.modulus());
	assert(b.i < b.modulus());
	TYPE tmp = a.i + b.i;
	return Index<M, POLY, TYPE>(a.modulus() - a.i <= b.i ? tmp - a.modulus() : tmp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movb %dil, %cl
movb %cl, -0x2(%rbp)
movb %al, -0x3(%rbp)
movzbl -0x2(%rbp), %eax
movl %eax, -0x8(%rbp)
callq 0xc090
movb %al, %cl
movl -0x8(%rbp), %eax
movzbl %cl, %ecx
cmpl %ecx, %eax
jge 0xc13e
jmp 0xc15d
leaq 0xd54b(%rip), %rdi      # 0x19690
leaq 0xd36a(%rip), %rsi      # 0x194b6
movl $0x8d, %edx
leaq 0xd63b(%rip), %rcx      # 0x19793
callq 0x2100
movzbl -0x3(%rbp), %eax
movl %eax, -0xc(%rbp)
callq 0xc090
movb %al, %cl
movl -0xc(%rbp), %eax
movzbl %cl, %ecx
cmpl %ecx, %eax
jge 0xc177
jmp 0xc196
leaq 0xd68d(%rip), %rdi      # 0x1980b
leaq 0xd331(%rip), %rsi      # 0x194b6
movl $0x8e, %edx
leaq 0xd602(%rip), %rcx      # 0x19793
callq 0x2100
movzbl -0x2(%rbp), %eax
movzbl -0x3(%rbp), %ecx
addl %ecx, %eax
movb %al, -0x4(%rbp)
callq 0xc090
movzbl %al, %eax
movzbl -0x2(%rbp), %ecx
subl %ecx, %eax
movzbl -0x3(%rbp), %ecx
cmpl %ecx, %eax
jg 0xc1d4
movzbl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
callq 0xc090
movb %al, %cl
movl -0x14(%rbp), %eax
movzbl %cl, %ecx
subl %ecx, %eax
movl %eax, -0x10(%rbp)
jmp 0xc1db
movzbl -0x4(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
leaq -0x1(%rbp), %rdi
movzbl %al, %esi
callq 0xbd80
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: xdsopl[P]FEC/./bose_chaudhuri_hocquenghem.hh
// Function: BoseChaudhuriHocquenghem<6, 1, 5, GF::Types<4, 19, unsigned char>>::encode(GF::Value<4, 19, unsigned char>*)
void encode(ValueType *code)
	{
		// $code = data * x^{NP} + (data * x^{NP}) \mod{generator}$
		for (int i = 0; i < NP; ++i)
			code[K+i] = ValueType(0);
		for (int i = 0; i < K; ++i) {
			if (code[i] != code[K]) {
				for (int j = 1; j < NP; ++j)
					code[K+j-1] = generator[NP-j] + code[K+j];
				code[N-1] = generator[0];
			} else {
				for (int j = 1; j < NP; ++j)
					code[K+j-1] = code[K+j];
				code[N-1] = ValueType(0);
			}
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0xa, -0x14(%rbp)
jge 0xc58e
leaq -0x15(%rbp), %rdi
xorl %esi, %esi
callq 0xbc30
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $0x5, %ecx
movslq %ecx, %rcx
movb -0x15(%rbp), %dl
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xc55f
movl $0x0, -0x1c(%rbp)
cmpl $0x5, -0x1c(%rbp)
jge 0xc6a3
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x1d(%rbp)
movq -0x10(%rbp), %rax
movb 0x5(%rax), %al
movb %al, -0x1e(%rbp)
movb -0x1d(%rbp), %al
movzbl %al, %edi
movzbl -0x1e(%rbp), %esi
callq 0xc6b0
testb $0x1, %al
jne 0xc5cc
jmp 0xc643
movl $0x1, -0x24(%rbp)
cmpl $0xa, -0x24(%rbp)
jge 0xc634
movq -0x38(%rbp), %rax
movl $0xa, %ecx
subl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, -0x26(%rbp)
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
addl $0x5, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, -0x27(%rbp)
movb -0x26(%rbp), %al
movzbl %al, %edi
movzbl -0x27(%rbp), %esi
callq 0xc000
movb %al, -0x25(%rbp)
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
addl $0x5, %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb -0x25(%rbp), %dl
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xc5d3
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movb (%rcx), %cl
movb %cl, 0xe(%rax)
jmp 0xc693
movl $0x1, -0x2c(%rbp)
cmpl $0xa, -0x2c(%rbp)
jge 0xc67e
movq -0x10(%rbp), %rdx
movl -0x2c(%rbp), %eax
addl $0x5, %eax
movslq %eax, %rsi
movq -0x10(%rbp), %rax
movl -0x2c(%rbp), %ecx
addl $0x5, %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb (%rdx,%rsi), %dl
movb %dl, (%rax,%rcx)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xc64a
leaq -0x2d(%rbp), %rdi
xorl %esi, %esi
callq 0xbc30
movq -0x10(%rbp), %rax
movb -0x2d(%rbp), %cl
movb %cl, 0xe(%rax)
jmp 0xc695
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xc595
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: xdsopl[P]FEC/./bose_chaudhuri_hocquenghem.hh
// Function: BoseChaudhuriHocquenghem<6, 1, 5, GF::Types<4, 19, unsigned char>>::compute_syndromes(GF::Value<4, 19, unsigned char>*, GF::Value<4, 19, unsigned char>*)
int compute_syndromes(ValueType *code, ValueType *syndromes)
	{
		// $syndromes_i = code(pe^{FCR+i})$
		for (int i = 0; i < NR; ++i)
			syndromes[i] = code[0];
		for (int j = 1; j < N; ++j) {
			IndexType root(FCR), pe(1);
			for (int i = 0; i < NR; ++i) {
				syndromes[i] = fma(root, syndromes[i], code[j]);
				root *= pe;
			}
		}
		int nonzero = 0;
		for (int i = 0; i < NR; ++i)
			nonzero += !!syndromes[i];
		return nonzero;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x6, -0x1c(%rbp)
jge 0xc9cd
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb (%rdx), %dl
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xc9ab
movl $0x1, -0x20(%rbp)
cmpl $0xf, -0x20(%rbp)
jge 0xca80
leaq -0x21(%rbp), %rdi
movl $0x1, %esi
callq 0xbd80
leaq -0x22(%rbp), %rdi
movl $0x1, %esi
callq 0xbd80
movl $0x0, -0x28(%rbp)
cmpl $0x6, -0x28(%rbp)
jge 0xca70
movb -0x21(%rbp), %al
movb %al, -0x2a(%rbp)
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x2b(%rbp)
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x2c(%rbp)
movb -0x2a(%rbp), %cl
movb -0x2b(%rbp), %al
movzbl %cl, %edi
movzbl %al, %esi
movzbl -0x2c(%rbp), %edx
callq 0xbde0
movb %al, -0x29(%rbp)
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
movb -0x29(%rbp), %dl
movb %dl, (%rax,%rcx)
movb -0x22(%rbp), %al
movb %al, -0x2d(%rbp)
leaq -0x21(%rbp), %rdi
movzbl -0x2d(%rbp), %esi
callq 0xbef0
movb %al, -0x2e(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xca01
jmp 0xca72
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xc9d4
movl $0x0, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
cmpl $0x6, -0x38(%rbp)
jge 0xcabe
movq -0x18(%rbp), %rdi
movslq -0x38(%rbp), %rax
addq %rax, %rdi
callq 0xbce0
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
addl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0xca8e
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: xdsopl[P]FEC/./galois_field.hh
// Function: GF::Value<4, 19, unsigned char> GF::fma<4, 19, unsigned char>(GF::Value<4, 19, unsigned char>, GF::Value<4, 19, unsigned char>, GF::Value<4, 19, unsigned char>)
Value<M, POLY, TYPE> fma(Value<M, POLY, TYPE> a, Value<M, POLY, TYPE> b, Value<M, POLY, TYPE> c)
{
	assert(a.v <= a.N);
	assert(b.v <= b.N);
	assert(c.v <= c.N);
	return (!a.v || !b.v) ? c : (value(index(a) * index(b)) + c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dl, %al
movb %sil, %cl
movb %dil, %dl
movb %dl, -0x2(%rbp)
movb %cl, -0x3(%rbp)
movb %al, -0x4(%rbp)
movzbl -0x2(%rbp), %eax
cmpl $0xf, %eax
jg 0xdae4
jmp 0xdb03
leaq 0xba33(%rip), %rdi      # 0x1951e
leaq 0xb9c4(%rip), %rsi      # 0x194b6
movl $0xfb, %edx
leaq 0xc531(%rip), %rcx      # 0x1a02f
callq 0x2100
movzbl -0x3(%rbp), %eax
cmpl $0xf, %eax
jg 0xdb0e
jmp 0xdb2d
leaq 0xbb0c(%rip), %rdi      # 0x19621
leaq 0xb99a(%rip), %rsi      # 0x194b6
movl $0xfc, %edx
leaq 0xc507(%rip), %rcx      # 0x1a02f
callq 0x2100
movzbl -0x4(%rbp), %eax
cmpl $0xf, %eax
jg 0xdb38
jmp 0xdb57
leaq 0xbbeb(%rip), %rdi      # 0x1972a
leaq 0xb970(%rip), %rsi      # 0x194b6
movl $0xfd, %edx
leaq 0xc4dd(%rip), %rcx      # 0x1a02f
callq 0x2100
cmpb $0x0, -0x2(%rbp)
je 0xdb63
cmpb $0x0, -0x3(%rbp)
jne 0xdb6b
movb -0x4(%rbp), %al
movb %al, -0x1(%rbp)
jmp 0xdbc5
movb -0x2(%rbp), %al
movb %al, -0x8(%rbp)
movzbl -0x8(%rbp), %edi
callq 0xc200
movb %al, -0x7(%rbp)
movb -0x3(%rbp), %al
movb %al, -0xa(%rbp)
movzbl -0xa(%rbp), %edi
callq 0xc200
movb %al, -0x9(%rbp)
movb -0x7(%rbp), %al
movzbl %al, %edi
movzbl -0x9(%rbp), %esi
callq 0xc110
movb %al, -0x6(%rbp)
movzbl -0x6(%rbp), %edi
callq 0xc0a0
movb %al, -0x5(%rbp)
movb -0x4(%rbp), %al
movb %al, -0xb(%rbp)
movb -0x5(%rbp), %al
movzbl %al, %edi
movzbl -0xb(%rbp), %esi
callq 0xc000
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nop
// File: xdsopl[P]FEC/./galois_field.hh
// Function: GF::Value<4, 19, unsigned char> GF::operator/<4, 19, unsigned char>(GF::Value<4, 19, unsigned char>, GF::Value<4, 19, unsigned char>)
Value<M, POLY, TYPE> operator / (Value<M, POLY, TYPE> a, Value<M, POLY, TYPE> b)
{
	assert(a.v <= a.N);
	assert(b.v <= b.N);
	assert(b.v);
	return !a.v ? a.zero() : value(index(a) / index(b));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movb %dil, %cl
movb %cl, -0x2(%rbp)
movb %al, -0x3(%rbp)
movzbl -0x2(%rbp), %eax
cmpl $0xf, %eax
jg 0xdbef
jmp 0xdc0e
leaq 0xb928(%rip), %rdi      # 0x1951e
leaq 0xb8b9(%rip), %rsi      # 0x194b6
movl $0xb6, %edx
leaq 0xc4ae(%rip), %rcx      # 0x1a0b7
callq 0x2100
movzbl -0x3(%rbp), %eax
cmpl $0xf, %eax
jg 0xdc19
jmp 0xdc38
leaq 0xba01(%rip), %rdi      # 0x19621
leaq 0xb88f(%rip), %rsi      # 0x194b6
movl $0xb7, %edx
leaq 0xc484(%rip), %rcx      # 0x1a0b7
callq 0x2100
cmpb $0x0, -0x3(%rbp)
je 0xdc40
jmp 0xdc5f
leaq 0xc4e8(%rip), %rdi      # 0x1a12f
leaq 0xb868(%rip), %rsi      # 0x194b6
movl $0xb8, %edx
leaq 0xc45d(%rip), %rcx      # 0x1a0b7
callq 0x2100
cmpb $0x0, -0x2(%rbp)
jne 0xdc6f
callq 0xd9d0
movb %al, -0x1(%rbp)
jmp 0xdcb1
movb -0x2(%rbp), %al
movb %al, -0x6(%rbp)
movzbl -0x6(%rbp), %edi
callq 0xc200
movb %al, -0x5(%rbp)
movb -0x3(%rbp), %al
movb %al, -0x8(%rbp)
movzbl -0x8(%rbp), %edi
callq 0xc200
movb %al, -0x7(%rbp)
movb -0x5(%rbp), %al
movzbl %al, %edi
movzbl -0x7(%rbp), %esi
callq 0xd240
movb %al, -0x4(%rbp)
movzbl -0x4(%rbp), %edi
callq 0xc0a0
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: xdsopl[P]FEC/./chien.hh
// Function: Chien<6, GF::Types<4, 19, unsigned char>>::search(GF::Value<4, 19, unsigned char>*, int, GF::Index<4, 19, unsigned char>*)
static int search(ValueType *locator, int locator_degree, IndexType *locations)
	{
		ValueType tmp[locator_degree+1];
		for (int i = 0; i <= locator_degree; ++i)
			tmp[i] = locator[i];
		int count = 0;
		for (int i = 0; i < N; ++i) {
			ValueType sum(tmp[0]);
			for (int j = 1; j <= locator_degree; ++j)
				sum += tmp[j] *= IndexType(j);
			if (!sum)
				locations[count++] = IndexType(i);
		}
		return count;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %eax
incl %eax
movq %rax, -0x50(%rbp)
movq %rsp, %rcx
movq %rcx, -0x20(%rbp)
movq %rax, %rdx
addq $0xf, %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x48(%rbp)
movq %rcx, %rsp
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xddbd
movq -0x48(%rbp), %rax
movq -0x50(%rbp), %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, -0x60(%rbp)
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xbc20
movq -0x68(%rbp), %rax
movq -0x60(%rbp), %rcx
addq $0x1, %rax
cmpq %rcx, %rax
movq %rax, -0x58(%rbp)
jne 0xdd9b
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0xdded
movq -0x48(%rbp), %rax
movq -0x8(%rbp), %rdx
movslq -0x2c(%rbp), %rsi
movslq -0x2c(%rbp), %rcx
movb (%rdx,%rsi), %dl
movb %dl, (%rax,%rcx)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xddc4
movl $0x0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
cmpl $0xf, -0x34(%rbp)
jge 0xdea2
movq -0x48(%rbp), %rax
movb (%rax), %al
movb %al, -0x35(%rbp)
movl $0x1, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0xde5e
movl -0x3c(%rbp), %eax
leaq -0x3e(%rbp), %rdi
movzbl %al, %esi
callq 0xbd80
movq -0x48(%rbp), %rdi
movslq -0x3c(%rbp), %rax
addq %rax, %rdi
movzbl -0x3e(%rbp), %esi
callq 0xdee0
movb %al, -0x3d(%rbp)
leaq -0x35(%rbp), %rdi
movzbl -0x3d(%rbp), %esi
callq 0xbd00
movb %al, -0x3f(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0xde15
leaq -0x35(%rbp), %rdi
callq 0xbce0
testb $0x1, %al
jne 0xde92
movl -0x34(%rbp), %eax
leaq -0x40(%rbp), %rdi
movzbl %al, %esi
callq 0xbd80
movq -0x18(%rbp), %rax
movl -0x30(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x30(%rbp)
movslq %ecx, %rcx
movb -0x40(%rbp), %dl
movb %dl, (%rax,%rcx)
jmp 0xde94
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xddfb
movl -0x30(%rbp), %eax
movq -0x20(%rbp), %rcx
movq %rcx, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: xdsopl[P]FEC/./forney.hh
// Function: Forney<6, 1, GF::Types<4, 19, unsigned char>>::compute_evaluator(GF::Value<4, 19, unsigned char>*, GF::Value<4, 19, unsigned char>*, int, GF::Value<4, 19, unsigned char>*)
static int compute_evaluator(ValueType *syndromes, ValueType *locator, int locator_degree, ValueType *evaluator)
	{
		// $evaluator = (syndromes * locator) \bmod{x^{NR}}$
		int tmp = std::min(locator_degree, NR-1);
		int degree = -1;
		for (int i = 0; i <= tmp; ++i) {
			evaluator[i] = syndromes[i] * locator[0];
			for (int j = 1; j <= i; ++j)
				evaluator[i] += syndromes[i-j] * locator[j];
			if (evaluator[i])
				degree = i;
		}
		return degree;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x5, -0x28(%rbp)
leaq -0x14(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xe360
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x24(%rbp), %eax
jg 0xe151
movq -0x8(%rbp), %rax
movslq -0x30(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x32(%rbp)
movq -0x10(%rbp), %rax
movb (%rax), %al
movb %al, -0x33(%rbp)
movb -0x32(%rbp), %al
movzbl %al, %edi
movzbl -0x33(%rbp), %esi
callq 0xd9f0
movb %al, -0x31(%rbp)
movq -0x20(%rbp), %rax
movslq -0x30(%rbp), %rcx
movb -0x31(%rbp), %dl
movb %dl, (%rax,%rcx)
movl $0x1, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x30(%rbp), %eax
jg 0xe125
movq -0x8(%rbp), %rax
movl -0x30(%rbp), %ecx
subl -0x38(%rbp), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, -0x3a(%rbp)
movq -0x10(%rbp), %rax
movslq -0x38(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x3b(%rbp)
movb -0x3a(%rbp), %al
movzbl %al, %edi
movzbl -0x3b(%rbp), %esi
callq 0xd9f0
movb %al, -0x39(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x30(%rbp), %rax
addq %rax, %rdi
movzbl -0x39(%rbp), %esi
callq 0xbd00
movb %al, -0x3c(%rbp)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0xe0c8
movq -0x20(%rbp), %rdi
movslq -0x30(%rbp), %rax
addq %rax, %rdi
callq 0xbce0
testb $0x1, %al
jne 0xe13b
jmp 0xe141
movl -0x30(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0xe143
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0xe07e
movl -0x2c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: xdsopl[P]FEC/./galois_field.hh
// Function: GF::Value<4, 19, unsigned char> GF::fma<4, 19, unsigned char>(GF::Index<4, 19, unsigned char>, GF::Index<4, 19, unsigned char>, GF::Value<4, 19, unsigned char>)
Value<M, POLY, TYPE> fma(Index<M, POLY, TYPE> a, Index<M, POLY, TYPE> b, Value<M, POLY, TYPE> c)
{
	assert(a.i < a.modulus());
	assert(b.i < b.modulus());
	assert(c.v <= c.N);
	return value(a * b) + c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movb %sil, %cl
movb %dil, %dl
movb %dl, -0x2(%rbp)
movb %cl, -0x3(%rbp)
movb %al, -0x4(%rbp)
movzbl -0x2(%rbp), %eax
movl %eax, -0x10(%rbp)
callq 0xc090
movb %al, %cl
movl -0x10(%rbp), %eax
movzbl %cl, %ecx
cmpl %ecx, %eax
jge 0xee73
jmp 0xee92
leaq 0xa816(%rip), %rdi      # 0x19690
leaq 0xa635(%rip), %rsi      # 0x194b6
movl $0xe0, %edx
leaq 0xb528(%rip), %rcx      # 0x1a3b5
callq 0x2100
movzbl -0x3(%rbp), %eax
movl %eax, -0x14(%rbp)
callq 0xc090
movb %al, %cl
movl -0x14(%rbp), %eax
movzbl %cl, %ecx
cmpl %ecx, %eax
jge 0xeeac
jmp 0xeecb
leaq 0xa958(%rip), %rdi      # 0x1980b
leaq 0xa5fc(%rip), %rsi      # 0x194b6
movl $0xe1, %edx
leaq 0xb4ef(%rip), %rcx      # 0x1a3b5
callq 0x2100
movzbl -0x4(%rbp), %eax
cmpl $0xf, %eax
jg 0xeed6
jmp 0xeef5
leaq 0xa84d(%rip), %rdi      # 0x1972a
leaq 0xa5d2(%rip), %rsi      # 0x194b6
movl $0xe2, %edx
leaq 0xb4c5(%rip), %rcx      # 0x1a3b5
callq 0x2100
movb -0x2(%rbp), %al
movb %al, -0x7(%rbp)
movb -0x3(%rbp), %al
movb %al, -0x8(%rbp)
movb -0x7(%rbp), %al
movzbl %al, %edi
movzbl -0x8(%rbp), %esi
callq 0xc110
movb %al, -0x6(%rbp)
movzbl -0x6(%rbp), %edi
callq 0xc0a0
movb %al, -0x5(%rbp)
movb -0x4(%rbp), %al
movb %al, -0x9(%rbp)
movb -0x5(%rbp), %al
movzbl %al, %edi
movzbl -0x9(%rbp), %esi
callq 0xc000
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
// File: kebwi[P]Trifid/src/main.cpp
// Function: warning(char const*)
void warning(const char *msg)
{
	cout << endl;
	cout << "****************************************" << endl;
	cout << "  !!! WARNING !!!" << endl;
	cout << "  " << msg << endl;
	cout << "****************************************" << endl;
	cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x54c1d(%rip), %rdi     # 0x59fd0
movq 0x54bfe(%rip), %rsi     # 0x59fb8
callq 0x43d0
movq 0x54c0a(%rip), %rdi     # 0x59fd0
leaq 0x43ed6(%rip), %rsi     # 0x492a3
callq 0x4390
movq %rax, %rdi
movq 0x54bdc(%rip), %rsi     # 0x59fb8
callq 0x43d0
movq 0x54be8(%rip), %rdi     # 0x59fd0
leaq 0x43edd(%rip), %rsi     # 0x492cc
callq 0x4390
movq %rax, %rdi
movq 0x54bba(%rip), %rsi     # 0x59fb8
callq 0x43d0
movq 0x54bc6(%rip), %rdi     # 0x59fd0
leaq 0x4459c(%rip), %rsi     # 0x499ad
callq 0x4390
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x4390
movq %rax, %rdi
movq 0x54b8c(%rip), %rsi     # 0x59fb8
callq 0x43d0
movq 0x54b98(%rip), %rdi     # 0x59fd0
leaq 0x43e64(%rip), %rsi     # 0x492a3
callq 0x4390
movq %rax, %rdi
movq 0x54b6a(%rip), %rsi     # 0x59fb8
callq 0x43d0
movq 0x54b76(%rip), %rdi     # 0x59fd0
movq 0x54b57(%rip), %rsi     # 0x59fb8
callq 0x43d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: kebwi[P]Trifid/src/main.cpp
// Function: roundToNearestInt(double, int, int)
int roundToNearestInt(Float_t valueF, int minV, int maxV)
{
	/*
	int value = 0;
	if (((int)(valueF * 10) % 10) < 5)
		value = valueF;
	value = valueF + 1;
	*/
	int value = (int)(valueF + .5);
	
	if (minV != maxV)
	{
		if (value < minV)
			value = minV;
		else if (value > maxV)
			value = maxV;
	}
	
	return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x8(%rbp)
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movsd 0x43ad9(%rip), %xmm0    # 0x49010
addsd -0x8(%rbp), %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
je 0x556d
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x555b
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x556b
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jle 0x5569
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x556b
jmp 0x556d
movl -0x14(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kebwi[P]Trifid/src/main.cpp
// Function: getCurrentTime_ms()
unsigned long getCurrentTime_ms()
{
	static timeval tp;
	gettimeofday(&tp, NULL);
	
	static unsigned long currentTime_ms;
	currentTime_ms = tp.tv_sec * CURRENT_TIME_PER_SEC;	//Convert seconds to milliseconds
	currentTime_ms += tp.tv_usec / CURRENT_TIME_PER_SEC;	//Convert microseconds to milliseconds
	
	return currentTime_ms;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x5515d(%rip), %rdi     # 0x5a728
xorl %eax, %eax
movl %eax, %esi
callq 0x45b0
imulq $0x3e8, 0x55149(%rip), %rax # imm = 0x3E8
movq %rax, 0x55152(%rip)     # 0x5a738
movq 0x55143(%rip), %rax     # 0x5a730
movl $0x3e8, %ecx            # imm = 0x3E8
cqto
idivq %rcx
addq 0x5513a(%rip), %rax     # 0x5a738
movq %rax, 0x55133(%rip)     # 0x5a738
movq 0x5512c(%rip), %rax     # 0x5a738
popq %rbp
retq
nop
// File: kebwi[P]Trifid/src/main.cpp
// Function: writeSeparator(char, int, int)
void writeSeparator(char sepChar, int rowLength, int numRows)
{
	cout << endl << endl;
	for (int r = 0; r < numRows; r++)
	{
		for (int c = 0; c < rowLength; c++)
			cout << sepChar;
		cout << endl;
	}
	cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq 0x51d15(%rip), %rdi     # 0x59fd0
movq 0x51cf6(%rip), %rsi     # 0x59fb8
callq 0x43d0
movq %rax, %rdi
movq 0x51ce7(%rip), %rsi     # 0x59fb8
callq 0x43d0
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x832d
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x830f
movq 0x51cd5(%rip), %rdi     # 0x59fd0
movsbl -0x1(%rbp), %esi
callq 0x4440
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x82ec
movq 0x51cba(%rip), %rdi     # 0x59fd0
movq 0x51c9b(%rip), %rsi     # 0x59fb8
callq 0x43d0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x82dd
movq 0x51c9c(%rip), %rdi     # 0x59fd0
movq 0x51c7d(%rip), %rsi     # 0x59fb8
callq 0x43d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kebwi[P]Trifid/src/./ImageProcs.h
// Function: NoiseParam::operator=(NoiseParam const&)
const NoiseParam& operator=(const NoiseParam &np)
	{
		if (&np == this)
			return *this;
		
		set(
			np.label_.c_str(),
			np.lux_,
			np.minReflectance_,
			np.maxReflectance_,
			np.temperatureC_,
			//np.focalLengthMM_,
			np.pixelPitchMicrons_,
			np.fullWellCapacity_,
			np.readNoise_,
			np.ampVarFactor_,
			np.darkCurrentRoomTempElectronsPerPixPerSec_,
			np.hotPixelFactor_,
			np.hotPixelScalars_,
			np.quantumEfficiency_,
			np.ampGlowElectronsPerPixPerSec_,
			np.exposureSecs_,
			np.ampGain_,
			np.focalRatio_
		);
		
		selfCheck();
		
		return *this;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq %rax, -0x18(%rbp)
jne 0xf5db
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xf6c1
movq -0x18(%rbp), %rdi
callq 0x4160
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rax
movsd 0x20(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd 0x28(%rax), %xmm1
movq -0x18(%rbp), %rax
movsd 0x30(%rax), %xmm2
movq -0x18(%rbp), %rax
movsd 0x38(%rax), %xmm3
movq -0x18(%rbp), %rax
movsd 0x40(%rax), %xmm4
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rdx
movq -0x18(%rbp), %rax
movsd 0x50(%rax), %xmm5
movq -0x18(%rbp), %rax
movsd 0x58(%rax), %xmm6
movq -0x18(%rbp), %rax
movsd 0x60(%rax), %xmm7
movq -0x18(%rbp), %rax
movsd 0x68(%rax), %xmm12
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rcx
movq -0x18(%rbp), %r8
addq $0x78, %r8
movq -0x18(%rbp), %rax
movsd 0x90(%rax), %xmm11
movq -0x18(%rbp), %rax
movsd 0x98(%rax), %xmm10
movq -0x18(%rbp), %rax
movsd 0xa0(%rax), %xmm9
movq -0x18(%rbp), %rax
movsd 0xa8(%rax), %xmm8
movsd %xmm12, (%rsp)
movsd %xmm11, 0x8(%rsp)
movsd %xmm10, 0x10(%rsp)
movsd %xmm9, 0x18(%rsp)
movsd %xmm8, 0x20(%rsp)
callq 0xf6d0
movq -0x20(%rbp), %rdi
callq 0xe770
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: kebwi[P]Trifid/src/ImageInterface.cpp
// Function: ImageInterface::operator=(ImageInterface const&)
const ImageInterface& ImageInterface::operator=(const ImageInterface &ir)
{
	if (&ir == this)
		return *this;
	
	filename_ = ir.filename_;
	resize(ir.width_, ir.height_);
	
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq %rax, -0x18(%rbp)
jne 0x15098
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x150cd
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
addq $0x8, %rdi
callq 0x4060
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x28(%rax), %esi
movq -0x18(%rbp), %rax
movl 0x2c(%rax), %edx
movq (%rdi), %rax
callq *0x28(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: kebwi[P]Trifid/src/ImageInterface.cpp
// Function: ImageInterface::operator==(ImageInterface const&) const
bool ImageInterface::operator==(const ImageInterface &im) const
{
	if (&im == this)
		return true;
	
	//Notice, no check against the filename
	
	if (width_ != im.width_ || height_ != im.height_)
		return false;
	assert(totalPixels_ == im.totalPixels_);
	
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq %rax, -0x18(%rbp)
jne 0x15104
movb $0x1, -0x1(%rbp)
jmp 0x1515f
movq -0x20(%rbp), %rax
movl 0x28(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jne 0x15124
movq -0x20(%rbp), %rax
movl 0x2c(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x2c(%rcx), %eax
je 0x1512a
movb $0x0, -0x1(%rbp)
jmp 0x1515f
movq -0x20(%rbp), %rax
movl 0x30(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x30(%rcx), %eax
jne 0x1513c
jmp 0x1515b
leaq 0x34ecf(%rip), %rdi     # 0x4a012
leaq 0x34ee8(%rip), %rsi     # 0x4a032
movl $0x3f, %edx
leaq 0x34eef(%rip), %rcx     # 0x4a045
callq 0x4240
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: kebwi[P]Trifid/src/ImageInterface.cpp
// Function: ImageInterface::resize(int, int)
bool ImageInterface::resize(int width, int height)
{
	if (width_ == width && height_ == height)
		return false;
	
	width_ = width;
	height_ = height;
	totalPixels_ = width_ * height_;
	
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x28(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x155b0
movq -0x20(%rbp), %rax
movl 0x2c(%rax), %eax
cmpl -0x18(%rbp), %eax
jne 0x155b0
movb $0x0, -0x1(%rbp)
jmp 0x155ce
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x28(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0x2c(%rax)
movl 0x28(%rax), %ecx
imull 0x2c(%rax), %ecx
movl %ecx, 0x30(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: kebwi[P]Trifid/src/ImageReal.cpp
// Function: ImageReal::operator=(ImageReal const&)
const ImageReal& ImageReal::operator=(const ImageReal &ir)
{
	if (&ir == this)
		return *this;
	
	ImageInterface::operator=(ir);
	
	resize(ir.width_, ir.height_);
	memcpy(img_, ir.img_, totalPixels_ * sizeof(Float_t));
	
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq %rax, -0x18(%rbp)
jne 0x156b8
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x15702
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15070
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x28(%rax), %esi
movq -0x18(%rbp), %rax
movl 0x2c(%rax), %edx
movq (%rdi), %rax
callq *0x28(%rax)
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x18(%rbp), %rcx
movq 0x38(%rcx), %rsi
movslq 0x30(%rax), %rdx
shlq $0x3, %rdx
callq 0x4300
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: kebwi[P]Trifid/src/ImageReal.cpp
// Function: ImageReal::operator==(ImageReal const&) const
bool ImageReal::operator==(const ImageReal &im) const
{
	if (&im == this)
		return true;
	
	if (!(ImageInterface::operator==(im)))
		return false;
	
	return (memcmp(img_, im.img_, totalPixels_ * sizeof(Float_t)) == 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq %rax, -0x18(%rbp)
jne 0x15894
movb $0x1, -0x1(%rbp)
jmp 0x158d3
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x150e0
testb $0x1, %al
jne 0x158ab
movb $0x0, -0x1(%rbp)
jmp 0x158d3
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x18(%rbp), %rcx
movq 0x38(%rcx), %rsi
movslq 0x30(%rax), %rdx
shlq $0x3, %rdx
callq 0x41a0
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: kebwi[P]Trifid/src/ImageReal.cpp
// Function: ImageReal::resize(int, int)
bool ImageReal::resize(int width, int height)
{
	if (!ImageInterface::resize(width, height))
	{
		erase();
		return false;
	}
	
	if (img_)
		delete [] img_;
	img_ = new Float_t[totalPixels_];
	erase();
	
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x15580
testb $0x1, %al
jne 0x15948
movq -0x20(%rbp), %rdi
callq 0x157b0
movb $0x0, -0x1(%rbp)
jmp 0x159aa
movq -0x20(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x15970
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x1596e
movq -0x28(%rbp), %rdi
callq 0x44d0
jmp 0x15970
movq -0x20(%rbp), %rax
movslq 0x30(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x4030
movq -0x20(%rbp), %rdi
movq %rax, 0x38(%rdi)
callq 0x157b0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kebwi[P]Trifid/src/ImageReal.cpp
// Function: ImageReal::normalize(double, bool)
void ImageReal::normalize(Float_t maxVal, bool normalizeUpToo)
{
	//Normalize the absolute value, some "images" might contain negative pixels
	Float_t maxCurrentVal = 0;
	for (int i = 0; i < totalPixels_; i++)
		if (fabs(img_[i]) > maxCurrentVal)
			maxCurrentVal = fabs(img_[i]);
	
	if (maxCurrentVal < maxVal && !normalizeUpToo)
		return;
	if (maxCurrentVal == 0)
		return;
	
	Float_t scalar = maxVal / maxCurrentVal;
	scale(scalar);
	
	//This doesn't really have anything to do with normalization
	for (int i = 0; i < totalPixels_; i++)
		img_[i] = fabs(img_[i]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x40(%rbp), %rcx
movl -0x24(%rbp), %eax
cmpl 0x30(%rcx), %eax
jge 0x15a9d
movq -0x40(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movaps 0x335dc(%rip), %xmm1    # 0x49040
pand %xmm1, %xmm0
ucomisd -0x20(%rbp), %xmm0
jbe 0x15a90
movq -0x40(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movaps 0x335b9(%rip), %xmm1    # 0x49040
pand %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x15a92
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x15a40
movsd -0x20(%rbp), %xmm1
movsd -0x10(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x15ab5
testb $0x1, -0x11(%rbp)
jne 0x15ab5
jmp 0x15b2c
movsd -0x20(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x15ac7
jp 0x15ac7
jmp 0x15b2c
movq -0x40(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
divsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movq (%rdi), %rax
callq *0x30(%rax)
movl $0x0, -0x34(%rbp)
movq -0x40(%rbp), %rcx
movl -0x34(%rbp), %eax
cmpl 0x30(%rcx), %eax
jge 0x15b2c
movq -0x40(%rbp), %rax
movq 0x38(%rax), %rcx
movslq -0x34(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movaps 0x33530(%rip), %xmm1    # 0x49040
pand %xmm1, %xmm0
movq 0x38(%rax), %rax
movslq -0x34(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x15aec
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kebwi[P]Trifid/src/ImageReal.cpp
// Function: ImageReal::flipHorizontal()
void ImageReal::flipHorizontal()
{
	Float_t temp;
	for (int y = 0; y < height_; y++)
	{
		int halfWidth = width_ / 2;
		for (int x = 0; x < halfWidth; x++)
		{
			temp = (*this)(x, y);
			(*this)(x, y) = (*this)((width_ - 1) - x, y);
			(*this)((width_ - 1) - x, y) = temp;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x2c(%rcx), %eax
jge 0x15c24
movq -0x28(%rbp), %rax
movl 0x28(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x15c14
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x16fd0
movq -0x28(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x10(%rbp)
movl 0x28(%rdi), %esi
subl $0x1, %esi
subl -0x1c(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x16fd0
movq -0x28(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x1c(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x16fd0
movsd -0x38(%rbp), %xmm0
movq -0x28(%rbp), %rdi
movsd %xmm0, (%rax)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movl 0x28(%rdi), %esi
subl $0x1, %esi
subl -0x1c(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x16fd0
movsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x15b84
jmp 0x15c16
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x15b5b
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)