LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/rilutham[P]gotojakarta/./stlastar.h
// Function: AStarSearch<PathSearchNode>::FreeUnusedNodes()
void FreeUnusedNodes()
	{
		// iterate open list and delete unused nodes
		typename vector< Node * >::iterator iterOpen = m_OpenList.begin();

		while( iterOpen != m_OpenList.end() )
		{
			Node *n = (*iterOpen);

			if( !n->child )
			{
				FreeNode( n );

				n = NULL;
			}

			iterOpen ++;
		}

		m_OpenList.clear();

		// iterate closed list and delete unused nodes
		typename vector< Node * >::iterator iterClosed;

		for( iterClosed = m_ClosedList.begin(); iterClosed != m_ClosedList.end(); iterClosed ++ )
		{
			Node *n = (*iterClosed);

			if( !n->child )
			{
				FreeNode( n );
				n = NULL;

			}
		}

		m_ClosedList.clear();

	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r15
movq 0x8(%rdi), %rax
cmpq %rax, %r15
je 0x2746
leaq 0x68(%rbx), %r14
movq (%r15), %rsi
cmpq $0x0, 0x8(%rsi)
jne 0x2739
decl 0x98(%rbx)
movq %r14, %rdi
callq 0x2864
addq $0x8, %r15
movq 0x8(%rbx), %rax
cmpq %rax, %r15
jne 0x2721
movq (%rbx), %rcx
cmpq %rcx, %rax
je 0x2752
movq %rcx, 0x8(%rbx)
movq 0x18(%rbx), %r15
movq 0x20(%rbx), %rax
cmpq %rax, %r15
je 0x2788
leaq 0x68(%rbx), %r14
movq (%r15), %rsi
cmpq $0x0, 0x8(%rsi)
jne 0x277b
decl 0x98(%rbx)
movq %r14, %rdi
callq 0x2864
addq $0x8, %r15
movq 0x20(%rbx), %rax
cmpq %rax, %r15
jne 0x2763
movq 0x18(%rbx), %rcx
cmpq %rcx, %rax
je 0x2795
movq %rcx, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tsfn[P]doc2txt/src/main.cpp
// Function: main
int main(int argc, char **argv) {
  if (argc != 4) {
    printf("usage: %s <doc file> <text file> <image directory>\n", argv[0]);
    return 1;
  }

  if (!parse_doc(argv[1], argv[2], argv[3])) {
    printf("error\n");
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpl $0x4, %edi
jne 0x12df
movq 0x8(%rsi), %rdi
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rdx
movq %rax, %rsi
callq 0x1cdc
xorl %ebx, %ebx
testb %al, %al
jne 0x12f5
leaq 0x2d60(%rip), %rdi      # 0x4038
callq 0x1180
jmp 0x12f5
movq (%rsi), %rsi
leaq 0x2d1b(%rip), %rdi      # 0x4004
xorl %eax, %eax
callq 0x1040
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tsfn[P]doc2txt/src/Storage.cpp
// Function: Storage::~Storage()
Storage::~Storage() {
  for (uint i = 0; i < stream_num; ++i) {
    if (stream_name != NULL && stream_name[i] != NULL) {
      free(stream_name[i]);
      stream_name[i] = NULL;
    }
    if (stream_table != NULL && stream_table[i] != NULL) {
      free(stream_table[i]);
      stream_table[i] = NULL;
    }
  }
  stream_num = 0;
  if (stream_name != NULL) {
    free(stream_name);
    stream_name = NULL;
  }
  if (stream_table != NULL) {
    free(stream_table);
    stream_table = NULL;
  }
  if (stream_sizes != NULL) {
    free(stream_sizes);
    stream_sizes = NULL;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, (%rdi)
je 0x137e
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1351
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x1351
callq 0x1140
movq 0x8(%rbx), %rax
movq $0x0, (%rax,%r14,8)
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x1374
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x1374
callq 0x1140
movq 0x10(%rbx), %rax
movq $0x0, (%rax,%r14,8)
incq %r14
movl (%rbx), %eax
cmpq %rax, %r14
jb 0x132e
movl $0x0, (%rbx)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x139a
callq 0x1140
movq $0x0, 0x8(%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x13b0
callq 0x1140
movq $0x0, 0x10(%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x13c6
callq 0x1140
movq $0x0, 0x18(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tsfn[P]doc2txt/src/Storage.cpp
// Function: read_stream(unsigned int, unsigned int, unsigned char*, unsigned int, unsigned char*, unsigned int, unsigned char**, unsigned int*)
static bool read_stream(uint start, uint sec_sz, uchar *sat, uint sat_size,
    uchar *buf, uint buf_size, uchar **stream, uint *sz) {
  uint sec_num = 0;
  set<uint> vis;
  for (uint id = start; id < buf_size / sec_sz; id = *(uint *)(sat + id * 4)) {
    if (vis.count(id)) return false;
    vis.insert(id);
    ++sec_num;
  }
  *sz = sec_num * sec_sz;
  *stream = (uchar *)malloc(*sz);
  sec_num = 0;
  for (uint id = start; id < buf_size / sec_sz; id = *(uint *)(sat + id * 4)) {
    memcpy(*stream + sec_num++ * sec_sz, buf + id * sec_sz, sec_sz);
  }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, -0x40(%rbp)
movl %r8d, %eax
movq %rcx, -0x48(%rbp)
movq %rdx, %r12
movl %edi, %r13d
leaq -0x78(%rbp), %r14
movl $0x0, (%r14)
xorl %r15d, %r15d
movq %r15, 0x8(%r14)
movq %r14, 0x10(%r14)
movq %r14, 0x18(%r14)
movq %r15, 0x20(%r14)
xorl %edx, %edx
movl %esi, -0x34(%rbp)
divl %esi
movl %edi, -0x30(%rbp)
movl %eax, %ebx
cmpl %edi, %eax
setbe %dil
jbe 0x19f0
xorl %r15d, %r15d
movl %r13d, %eax
movq -0x70(%rbp), %rdx
movq %r14, %rcx
testq %rdx, %rdx
je 0x19b0
movq %r14, %rcx
xorl %esi, %esi
cmpl %eax, 0x20(%rdx)
setb %sil
cmovaeq %rdx, %rcx
movq 0x10(%rdx,%rsi,8), %rdx
testq %rdx, %rdx
jne 0x1999
movq %r14, %rdx
cmpq %r14, %rcx
je 0x19c2
cmpl 0x20(%rcx), %eax
cmovbq %r14, %rcx
movq %rcx, %rdx
cmpq %r14, %rdx
jne 0x1a5f
leaq -0x80(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1b54
incl %r15d
movl -0x30(%rbp), %eax
shll $0x2, %eax
movl (%r12,%rax), %eax
movl %eax, -0x30(%rbp)
cmpl %ebx, %eax
setae %dil
jb 0x198a
movb %dil, -0x29(%rbp)
movq 0x10(%rbp), %rax
movl -0x34(%rbp), %r14d
imull %r14d, %r15d
movl %r15d, (%rax)
movq %r15, %rdi
callq 0x1160
movq -0x40(%rbp), %rcx
movq %rax, (%rcx)
cmpl %r13d, %ebx
jbe 0x1a63
movq %rcx, %rax
movl %r14d, %ecx
movq %rcx, -0x50(%rbp)
movl %ebx, -0x38(%rbp)
movl %r14d, %ebx
xorl %r14d, %r14d
movq %r12, %r15
movq -0x48(%rbp), %r12
movl %r14d, %edi
addq (%rax), %rdi
movl %r13d, %esi
imull %ebx, %esi
addq %r12, %rsi
movq -0x50(%rbp), %rdx
callq 0x10c0
movl %r13d, %eax
movl (%r15,%rax,4), %r13d
movq -0x40(%rbp), %rax
addl %ebx, %r14d
cmpl -0x38(%rbp), %r13d
jb 0x1a31
jmp 0x1a63
movb %dil, -0x29(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x1c7c
movb -0x29(%rbp), %al
andb $0x1, %al
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x1c7c
movq %rbx, %rdi
callq 0x11a0
// File: /workspace/github_cpp_makefile_star2_O1/tsfn[P]doc2txt/src/Storage.cpp
// Function: Storage::stream(char const*, unsigned char const**, unsigned int*) const
bool Storage::stream(const char *name, const uchar **stream, uint *size) const {
  for (uint i = 0; i < stream_num; ++i) {
    bool match = true;
    for (uint j = 0; name[j] != '\0'; ++j) {
      if (name[j] != stream_name[i][j * 2]) {
        match = false;
        break;
      }
    }
    if (match) {
      *stream = stream_table[i];
      *size = stream_sizes[i];
      return true;
    }
  }
  return false;
}

// Assembly:
movl (%rdi), %r10d
testq %r10, %r10
setne %r9b
je 0x1b3b
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
movb (%rsi), %bl
movq 0x8(%rdi), %rdx
xorl %r8d, %r8d
xorl %r14d, %r14d
movl %r9d, %eax
testb %bl, %bl
je 0x1b41
movq (%rdx,%r14,8), %r15
movl $0x1, %r12d
xorl %r13d, %r13d
movl %ebx, %r11d
movsbl %r11b, %r11d
movl %r13d, %ecx
movzbl (%r15,%rcx), %ecx
cmpl %ecx, %r11d
jne 0x1b02
movl %r12d, %r11d
movb (%rsi,%r11), %r11b
incl %r12d
addl $0x2, %r13d
testb %r11b, %r11b
jne 0x1adc
jmp 0x1b0f
incq %r14
cmpq %r10, %r14
setb %al
jne 0x1ac8
jmp 0x1b2f
movl %r14d, %r8d
movq 0x10(%rdi), %rcx
movq (%rcx,%r8,8), %rcx
movq -0x30(%rbp), %rdx
movq %rcx, (%rdx)
movq 0x18(%rdi), %rcx
movl (%rcx,%r8,4), %ecx
movq -0x38(%rbp), %rdx
movl %ecx, (%rdx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1b3e
movl %r9d, %eax
andb $0x1, %al
retq
movl %r9d, %eax
jmp 0x1b12
// File: /workspace/github_cpp_makefile_star2_O1/tsfn[P]doc2txt/src/parse_doc.cpp
// Function: parse_doc(char const*, char const*, char const*)
bool parse_doc(const char *doc_file_path, const char *text_file_path, const char *image_dir_path) {
  FILE *doc_file = fopen(doc_file_path, "rb");
  if (doc_file == NULL) {
    return false;
  }

  /* 初始化流 */
  Storage storage;
  if (!storage.init(doc_file)) {
    fclose(doc_file);
    return false;
  }
  fclose(doc_file);

  /* 提取文本 */
  FILE *text_file = fopen(text_file_path, "wb");
  if (text_file == NULL) {
    return false;
  }
  doc_text_file(storage, text_file);
  fclose(text_file);

  /* 提取图片 */
  doc_image(storage, image_dir_path);

  /* 分析格式 */
  doc_format(storage);

  /* 标题、作者等信息 */
  doc_property(storage);
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x2346(%rip), %rsi      # 0x403e
callq 0x1130
testq %rax, %rax
je 0x1d7e
movq %rax, %r15
leaq -0x40(%rbp), %r12
movq %r12, %rdi
callq 0x1300
movq %r12, %rdi
movq %r15, %rsi
callq 0x13cc
movl %eax, %r12d
movq %r15, %rdi
callq 0x10d0
testb %r12b, %r12b
je 0x1d83
leaq 0x230e(%rip), %rsi      # 0x4041
movq %r14, %rdi
callq 0x1130
testq %rax, %rax
setne %r14b
je 0x1d86
movq %rax, %r15
leaq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x201f
movq %r15, %rdi
callq 0x10d0
leaq -0x40(%rbp), %rdi
movq %rbx, %rsi
callq 0x21c4
leaq -0x40(%rbp), %rdi
callq 0x2828
movb $0x1, %r14b
leaq -0x40(%rbp), %rdi
callq 0x3009
jmp 0x1d86
xorl %r14d, %r14d
jmp 0x1d8f
xorl %r14d, %r14d
leaq -0x40(%rbp), %rdi
callq 0x131c
movl %r14d, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1da1
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x131c
movq %rbx, %rdi
callq 0x11a0
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/tsfn[P]doc2txt/src/doc_text.cpp
// Function: get_piece_table(Storage const&)
static const uchar *get_piece_table(const Storage &storage) {
  const uchar *wds, *ts;
  uint wds_size, ts_size;
  if (!storage.stream("WordDocument", &wds, &wds_size)) {
    return NULL;
  }
  ushort flag1 = *(const ushort *)(wds + 0x0A);
  bool is1Table = (flag1 & 0x0200) == 0x0200;
  if (!storage.stream(is1Table ? "1Table" : "0Table", &ts, &ts_size)) {
    return NULL;
  }

  uint fcClx = *(const uint *)(wds + 0x01A2);
  uint lcbClx = *(const uint *)(wds + 0x01A6);
  const uchar *clx = ts + fcClx;
  for (uint pos = 0; clx + pos < ts + ts_size && pos < lcbClx;) {
    uchar type = clx[pos];
    if (type == 2) {
      return clx + pos;
    } else if (type == 1) {
      pos += 3 + *(const ushort *)(clx + pos + 1);
    } else {
      return NULL;
    }
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x20e4(%rip), %rsi      # 0x4044
leaq -0x18(%rbp), %rdx
leaq -0x24(%rbp), %rcx
callq 0x1a94
testb %al, %al
je 0x2016
movq -0x18(%rbp), %rax
movzwl 0xa(%rax), %eax
btl $0x9, %eax
leaq 0x20d0(%rip), %rax      # 0x4058
leaq 0x20c2(%rip), %rsi      # 0x4051
cmovaeq %rax, %rsi
leaq -0x20(%rbp), %rdx
leaq -0xc(%rbp), %rcx
movq %rbx, %rdi
callq 0x1a94
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
je 0x2018
movq -0x18(%rbp), %rax
movl 0x1a2(%rax), %ecx
movl 0x1a6(%rax), %edx
movq -0x20(%rbp), %rax
addq %rax, %rcx
movl -0xc(%rbp), %esi
addq %rax, %rsi
xorl %edi, %edi
movl %edi, %r8d
addq %rcx, %r8
cmpq %rsi, %r8
jae 0x2016
movl $0x0, %eax
cmpl %edx, %edi
jae 0x2018
movzbl (%r8), %eax
cmpl $0x2, %eax
je 0x1ffe
cmpl $0x1, %eax
jne 0x2003
movzwl 0x1(%r8), %eax
addl %eax, %edi
addl $0x3, %edi
movb $0x1, %r10b
movq %r9, %r8
jmp 0x2009
xorl %r10d, %r10d
jmp 0x2009
xorl %r10d, %r10d
xorl %r8d, %r8d
movq %r8, %r9
movq %r8, %rax
testb %r10b, %r10b
jne 0x1fca
jmp 0x2018
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Matheus-Aguilar[P]Huffman/main.cpp
// Function: splitByte(unsigned char, std::vector<bool, std::allocator<bool>>&)
void splitByte(const unsigned char byte, vector<bool> &bits){
	//Auxiliar usado para retirar o bit mais significativo
	unsigned char pos = 1 << 7;
	while(pos){ 
		bits.push_back(((byte & pos) ? 1 : 0)); //Get the Least Significant Digit
		pos >>= 1; //Shift to the right
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movb $-0x80, %r14b
movb $-0x80, %r15b
xorl %esi, %esi
testb %bpl, %r14b
setne %sil
movq %rbx, %rdi
callq 0x2a92
shrb %r15b
cmpb $0x1, %r14b
movl %r15d, %r14d
ja 0x2705
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Matheus-Aguilar[P]Huffman/main.cpp
// Function: main
int main(int argc, char **argv) {

	//c to compress, d to decompress
	if(argv[1][0] == 'c'){
		compressFile(argv[2], argv[3]);
	}
	else if(argv[1][0] == 'd'){
		descompressFile(argv[2], argv[3]);
	}
	else{
		throw("Invalid Flag!");
	}
}

// Assembly:
pushq %rax
movq 0x8(%rsi), %rax
movzbl (%rax), %eax
cmpl $0x64, %eax
je 0x2a5b
cmpl $0x63, %eax
jne 0x2a6c
movq 0x10(%rsi), %rdi
movq 0x18(%rsi), %rsi
callq 0x236c
jmp 0x2a68
movq 0x10(%rsi), %rdi
movq 0x18(%rsi), %rsi
callq 0x272d
xorl %eax, %eax
popq %rcx
retq
movl $0x8, %edi
callq 0x20b0
leaq 0x1587(%rip), %rcx      # 0x4004
movq %rcx, (%rax)
movq 0x3541(%rip), %rsi      # 0x5fc8
movq %rax, %rdi
xorl %edx, %edx
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Matheus-Aguilar[P]Huffman/Huffman.cpp
// Function: HuffmanTree::destroy(Node*)
void HuffmanTree::destroy(Node *node){
    if(node == NULL) return; //Leaf node
    destroy(node->left); //Destroys left child
    destroy(node->right); //Destroys right child
    delete node; //Free memory
}

// Assembly:
testq %rsi, %rsi
je 0x334b
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rsi
callq 0x3314
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x3314
movl $0x20, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2130
retq
// File: /workspace/github_cpp_makefile_star2_O1/Matheus-Aguilar[P]Huffman/Huffman.cpp
// Function: HuffmanTree::buildCodes(Node*, std::vector<bool, std::allocator<bool>>&)
void HuffmanTree::buildCodes(Node *node, vector<bool> &codeString){
    
    //Reached a leaf node
    if(node->left == NULL && node->right == NULL){
        code[node->character] = codeString; //Copy the code to codes array
        return; //End recursion
    }

    //If there is a left child
    if(node->left != NULL){
        codeString.push_back(0); //Adds a left move to the code, represented by a 0
        buildCodes(node->left, codeString); //Recursively call to left child
        codeString.pop_back(); //Remove the last move (backtracking)
    }

    if(node->right != NULL){
        codeString.push_back(1); //Adds a right move to the code, represented by a 1
        buildCodes(node->right, codeString); //Recursively call to right child
        codeString.pop_back(); //Remove the last move (backtracking)
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %rax
testq %rax, %rax
je 0x33c7
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2a92
movq (%r15), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x334c
subl $0x1, 0x18(%rbx)
jae 0x338c
movl $0x3f, 0x18(%rbx)
addq $-0x8, 0x10(%rbx)
cmpq $0x0, 0x8(%r15)
je 0x33c1
movq %rbx, %rdi
movl $0x1, %esi
callq 0x2a92
movq 0x8(%r15), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x334c
subl $0x1, 0x18(%rbx)
jae 0x33c1
movl $0x3f, 0x18(%rbx)
addq $-0x8, 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
cmpq $0x0, 0x8(%r15)
je 0x33d5
testq %rax, %rax
jne 0x3362
jmp 0x338c
movzbl 0x18(%r15), %eax
leaq (%rax,%rax,4), %rax
leaq (%r14,%rax,8), %rdi
addq $0x408, %rdi            # imm = 0x408
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x3696
// File: /workspace/github_cpp_makefile_star2_O1/Matheus-Aguilar[P]Huffman/Huffman.cpp
// Function: HuffmanTree::compress(std::vector<bool, std::allocator<bool>>&, std::vector<char, std::allocator<char>> const&) const
void HuffmanTree::compress(vector<bool> &out, const vector<char> &in) const{
    
    if(!out.empty()) out.clear(); //Clear the vector if not empty

    //Copying the codes to the vector
    for(int i = 0; i < in.size(); ++i){
        size_t pos = (unsigned char) in[i];
        for(int j = 0; j < code[pos].size(); j++)
            out.push_back(code[pos][j]);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rax
cmpq 0x10(%rsi), %rax
jne 0x3456
cmpl $0x0, 0x18(%r14)
je 0x3462
movq %rax, 0x10(%r14)
movl $0x0, 0x18(%r14)
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x34e8
addq $0x408, %r15            # imm = 0x408
xorl %r12d, %r12d
movzbl (%rax,%r12), %eax
leaq (%rax,%rax,4), %rcx
movq (%r15,%rcx,8), %rax
movq 0x10(%r15,%rcx,8), %rdx
movl 0x18(%r15,%rcx,8), %esi
subq %rax, %rdx
shlq $0x3, %rdx
addq %rsi, %rdx
je 0x34d6
leaq (%r15,%rcx,8), %r13
xorl %ebp, %ebp
movq %rbp, %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
xorl %esi, %esi
btq %rbp, %rax
setb %sil
movq %r14, %rdi
callq 0x2a92
incq %rbp
movq (%r13), %rax
movq 0x10(%r13), %rcx
movl 0x18(%r13), %edx
subq %rax, %rcx
leaq (%rdx,%rcx,8), %rcx
cmpq %rbp, %rcx
ja 0x349e
incq %r12
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
cmpq %r12, %rcx
ja 0x3475
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Matheus-Aguilar[P]Huffman/Huffman.cpp
// Function: HuffmanTree::descompress(std::vector<char, std::allocator<char>>&, std::vector<bool, std::allocator<bool>> const&) const
void HuffmanTree::descompress(vector<char> &out, const vector<bool> &in) const{
    
    if(!out.empty()) out.clear(); //Clear if not empty
    
    Node *node = root; //Start in the root node
    for(int i = 0; i < in.size(); ++i){
        if(!in[i]) //Left move (code 0)
            node = node->left;
        else //Right move (code 1)
            node = node->right;

        //Reached a leaf
        if(node->left == NULL && node->right == NULL){
            out.push_back(node->character); //Copy the caracther of the leaf
            node = root; //Return to the root
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rax
cmpq 0x8(%rsi), %rax
je 0x351b
movq %rax, 0x8(%r14)
movq (%rbx), %rcx
movq 0x10(%rbx), %rax
movl 0x18(%rbx), %edx
subq %rcx, %rax
shlq $0x3, %rax
addq %rdx, %rax
je 0x358f
movq (%r15), %rax
xorl %r13d, %r13d
leaq 0xf(%rsp), %r12
movq %r13, %rdx
shrq $0x6, %rdx
movq (%rcx,%rdx,8), %rcx
xorl %edx, %edx
btq %r13, %rcx
setb %dl
movq (%rax,%rdx,8), %rax
cmpq $0x0, (%rax)
jne 0x3576
cmpq $0x0, 0x8(%rax)
jne 0x3576
movb 0x18(%rax), %al
movb %al, 0xf(%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x2b0e
movq (%r15), %rax
incq %r13
movq (%rbx), %rcx
movq 0x10(%rbx), %rdx
movl 0x18(%rbx), %esi
subq %rcx, %rdx
leaq (%rsi,%rdx,8), %rdx
cmpq %r13, %rdx
ja 0x353c
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/attractivechaos[P]udb2/bkthomps-hashmap/test-1a.c
// Function: test_int
uint32_t test_int(uint32_t n, uint32_t x0)
{
	uint32_t i, x, z = 0;
	unordered_map h;
	h = unordered_map_init(sizeof(uint32_t), sizeof(uint32_t), hash_int, compare_int);
	for (i = 0, x = x0; i < n; ++i) {
		uint32_t key, v = 1;
		x = hash32(x);
		key = get_key(n, x);
		unordered_map_put(h, &key, &v);
		z += v;
	}
	fprintf(stderr, "# unique keys: %d; checksum: %u\n", unordered_map_size(h), z);
	x = unordered_map_size(h);
	unordered_map_destroy(h);
	return x;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r15d
movl %edi, %ebp
leaq 0x271(%rip), %rdx       # 0x1653
leaq 0x26d(%rip), %rcx       # 0x1656
pushq $0x4
popq %rdi
movq %rdi, %rsi
callq 0x165c
movq %rax, %rbx
xorl %r14d, %r14d
testl %ebp, %ebp
je 0x1497
movl %ebp, %r12d
shrl $0x2, %r12d
xorl %r14d, %r14d
movq %rsp, %r13
movl $0x1, (%rsp)
movl %r15d, %eax
shll $0xf, %eax
notl %eax
addl %r15d, %eax
movl %eax, %ecx
shrl $0xa, %ecx
xorl %eax, %ecx
leal (%rcx,%rcx,8), %eax
movl %eax, %ecx
shrl $0x6, %ecx
xorl %eax, %ecx
movl %ecx, %eax
shll $0xb, %eax
notl %eax
addl %ecx, %eax
movl %eax, %r15d
shrl $0x10, %r15d
xorl %eax, %r15d
movl %r15d, %eax
xorl %edx, %edx
divl %r12d
movl %edx, %eax
shll $0xf, %eax
notl %eax
addl %edx, %eax
movl %eax, %ecx
shrl $0xa, %ecx
xorl %eax, %ecx
leal (%rcx,%rcx,8), %eax
movl %eax, %ecx
shrl $0x6, %ecx
xorl %eax, %ecx
movl %ecx, %eax
shll $0xb, %eax
notl %eax
addl %ecx, %eax
movl %eax, %ecx
shrl $0x10, %ecx
xorl %eax, %ecx
movl %ecx, 0x4(%rsp)
movq %rbx, %rdi
leaq 0x4(%rsp), %rsi
movq %r13, %rdx
callq 0x1799
addl (%rsp), %r14d
decl %ebp
jne 0x140f
movq 0x2b5a(%rip), %rax      # 0x3ff8
movq (%rax), %r15
movq %rbx, %rdi
callq 0x178d
leaq 0xbc5(%rip), %rsi       # 0x2075
movq %r15, %rdi
movl %eax, %edx
movl %r14d, %ecx
xorl %eax, %eax
callq 0x1060
movq %rbx, %rdi
callq 0x178d
movl %eax, %ebp
movq %rbx, %rdi
callq 0x1c2c
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]motiflocation/motiflocation.cpp
// Function: print_help()
void print_help() {

	printf("\nmotifhunter %0.1f\n", version);
	printf("Returns every location of a motif in a given file.\n\n");
	printf("*** Positions are zero based! ***.\n\n");
	
	printf("Options :\n");
	printf("-file1 <file>                Sequence data file 1 (required)\n");
	printf("-out <file>                  Output file (required)\n");
	printf("-startstr <string>           Starting Motif\n");
	printf("-chrom <string>              Output string used for chromosome\n");
	printf("-mutations <int>             Number of allowed mutations\n");
	printf("-outputseqlen                Output the chromosome length as well\n");
	printf("-uppercase_only              Only output results in uppercase sequence\n");
	printf("-lowercase_only              Only output results in lowercase sequence\n");
	printf("-1000G_ref                   FASTA headers are in 1000G format\n");
	printf("\n");
}

// Assembly:
pushq %rax
movsd 0x8aa4(%rip), %xmm0     # 0xd2a8
leaq 0x4981(%rip), %rdi      # 0x918c
movb $0x1, %al
callq 0x3050
leaq 0x49fa(%rip), %rdi      # 0x9213
callq 0x33e0
leaq 0x4a22(%rip), %rdi      # 0x9247
callq 0x33e0
leaq 0x4a3a(%rip), %rdi      # 0x926b
callq 0x33e0
leaq 0x4a38(%rip), %rdi      # 0x9275
callq 0x33e0
leaq 0x4a69(%rip), %rdi      # 0x92b2
callq 0x33e0
leaq 0x4a91(%rip), %rdi      # 0x92e6
callq 0x33e0
leaq 0x4ab1(%rip), %rdi      # 0x9312
callq 0x33e0
leaq 0x4ae4(%rip), %rdi      # 0x9351
callq 0x33e0
leaq 0x4b11(%rip), %rdi      # 0x938a
callq 0x33e0
leaq 0x4b47(%rip), %rdi      # 0x93cc
callq 0x33e0
leaq 0x4b82(%rip), %rdi      # 0x9413
callq 0x33e0
leaq 0x4bbd(%rip), %rdi      # 0x945a
callq 0x33e0
movl $0xa, %edi
popq %rax
jmp 0x3320
nop
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]motiflocation/motif.cpp
// Function: motif::motif(bool)
motif::motif(bool is_nondegenerate)
{
	// Generate a random motif.
	int i;
    int maxlength=6;
	int length;
	string out;
	ExpVal = 0.0;

	length = ran2(2, maxlength+1);
	sequence.resize(length);
	for (i=0; i<length; i++)
	{
		sequence[i] = GetRandomBase(is_nondegenerate);
	}
	doComplement();

	CalcDegeneracy();
	get_max_length();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x764a(%rip), %rax      # 0xca98
movq %rax, (%rdi)
leaq 0x8(%rdi), %r14
leaq 0x18(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rax, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movb %al, 0x18(%rdi)
leaq 0x38(%rdi), %rcx
movq %rcx, 0x8(%rsp)
movq %rcx, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movb %al, 0x38(%rdi)
leaq 0x28(%rsp), %r12
movq %r12, -0x10(%r12)
movq %rax, -0x8(%r12)
movb %al, (%r12)
movq %rax, 0x78(%rdi)
movl $0x2, %edi
movl $0x7, %esi
callq 0x7c62
movl %eax, %r15d
movslq %eax, %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x30b0
testl %r15d, %r15d
jle 0x54da
movl %r15d, %r15d
xorl %r13d, %r13d
movzbl %bpl, %ebp
movl %ebp, %esi
callq 0x55a8
movq (%r14), %rcx
movb %al, (%rcx,%r13)
incq %r13
cmpq %r13, %r15
jne 0x54c4
movq %rbx, %rdi
callq 0x5652
movq %rbx, %rdi
callq 0x56b6
movq (%r14), %rax
movb (%rax), %sil
testb %sil, %sil
je 0x5524
incq %rax
xorl %ecx, %ecx
movl $0x1, %edx
leal -0x32(%rsi), %edi
addb $-0x30, %sil
cmpb $0x8, %dil
movzbl %sil, %esi
cmovael %edx, %esi
movsbl %sil, %esi
addl %esi, %ecx
movb (%rax), %sil
incq %rax
testb %sil, %sil
jne 0x54ff
jmp 0x5526
xorl %ecx, %ecx
movl %ecx, 0x70(%rbx)
movq 0x18(%rsp), %rdi
cmpq %r12, %rdi
je 0x5540
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x3270
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5551
movq %rax, %r15
movq 0x18(%rsp), %rdi
cmpq %r12, %rdi
je 0x556b
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x3270
movq 0x28(%rbx), %rdi
cmpq 0x8(%rsp), %rdi
je 0x5586
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x3270
movq (%r14), %rdi
cmpq 0x10(%rsp), %rdi
je 0x55a0
movq 0x10(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x3270
movq %r15, %rdi
callq 0x34d0
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]motiflocation/motif.cpp
// Function: motif::GetRandomBase(bool)
char motif::GetRandomBase(bool is_nondegenerate)
{
	int letter;
	if (is_nondegenerate == true)
	{
		letter = ran2(0,6);
		if (letter == 4) letter = 14;
		if (letter == 5) letter = 15;
	}
	else
		letter = ran2(0, 16);
	switch(letter)
	{
	case 0:	return 'a'; break;
	case 1:	return 'c'; break;
	case 2:	return 'g'; break;
	case 3:	return 't'; break;
	case 4:	return 'r'; break;
	case 5:	return 'y'; break;
	case 6:	return 'k'; break;
	case 7:	return 'm'; break;
	case 8:	return 's'; break;
	case 9:	return 'w'; break;
	case 10: return 'b'; break;
	case 11: return 'd'; break;
	case 12: return 'h'; break;
	case 13: return 'v'; break;
	case 14: return 'n'; break;
	case 15: 
		{	// insert a gap of size 1 to 9.
			int i; char out;
			i=ran2(1, 10);
			out = '0' + i;
			return out;
			break;
		}

	default:
		printf("error - illegal nucleotide\n");
		abort();
		return '-';
	}
}

// Assembly:
pushq %rax
xorl %edi, %edi
testl %esi, %esi
je 0x55d1
movl $0x6, %esi
callq 0x7c62
cmpl $0x4, %eax
movl $0xe, %ecx
cmovnel %eax, %ecx
cmpl $0x5, %ecx
movl $0xf, %eax
cmovnel %ecx, %eax
jmp 0x55db
movl $0x10, %esi
callq 0x7c62
cmpl $0xf, %eax
ja 0x5641
movl %eax, %eax
leaq 0x3eb3(%rip), %rcx      # 0x949c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x61, %al
jmp 0x563f
movb $0x6e, %al
jmp 0x563f
movb $0x64, %al
jmp 0x563f
movb $0x72, %al
jmp 0x563f
movb $0x68, %al
jmp 0x563f
movb $0x77, %al
jmp 0x563f
movb $0x67, %al
jmp 0x563f
movl $0x1, %edi
movl $0xa, %esi
callq 0x7c62
addb $0x30, %al
jmp 0x563f
movb $0x74, %al
jmp 0x563f
movb $0x6d, %al
jmp 0x563f
movb $0x63, %al
jmp 0x563f
movb $0x79, %al
jmp 0x563f
movb $0x76, %al
jmp 0x563f
movb $0x6b, %al
jmp 0x563f
movb $0x62, %al
jmp 0x563f
movb $0x73, %al
popq %rcx
retq
leaq 0x402f(%rip), %rdi      # 0x9677
callq 0x33e0
callq 0x3160
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]motiflocation/motif.cpp
// Function: motif::doComplement()
void motif::doComplement()
{
	unsigned int i;
	char base;
	unsigned int seqlen;
	seqlen = (unsigned int)sequence.length();
	complement.resize(seqlen);
	for (i=0; i<seqlen; i++)
	{
		base = sequence[i];
		complement[seqlen-i-1] = getComplement(base);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %r14
addq $0x28, %rdi
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movq %r14, %rsi
andq %r15, %rsi
xorl %edx, %edx
callq 0x30b0
andq %r14, %r15
je 0x56a9
movl %r14d, %r15d
decq %r14
xorl %r12d, %r12d
movq 0x8(%rbx), %rax
movsbl (%rax,%r12), %esi
callq 0x594a
movl %r14d, %ecx
movq 0x28(%rbx), %rdx
movb %al, (%rdx,%rcx)
incq %r12
decq %r14
cmpq %r12, %r15
jne 0x5686
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]motiflocation/motif.cpp
// Function: motif::CalcDegeneracy()
void motif::CalcDegeneracy()
{
	unsigned int i;
	char base;
	degeneracy= 0.0;
	for (i=0; i<sequence.length(); i++)
	{
		base = sequence[i];
		switch (base)
		{
			case 'a': case 't': case 'g': case 'c':
				degeneracy++;
				break;
			case 'r': case 'y': case 'k': case 'm': case 's': case 'w':
				degeneracy += 2;
				break;
			case 'b': case 'd': case 'h': case 'v':
				degeneracy += 3;
				break;
			case 'n':
				degeneracy += 4;
				break;
			case '1': case '2': case '3': case '4': case '5': case '6': case '7':case '8': case '9':
				degeneracy += (4 * (base - '0' + 1));
				break;
			default:
				printf("Non-standard base in motif\n");
				cout << base << endl;
				cout << sequence << endl;
				abort();
		}
	}
	degeneracy /= (double)sequence.length();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq $0x0, 0x60(%rdi)
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x576e
leaq 0x8(%rdi), %rbx
movsd 0x60(%rdi), %xmm0
movq 0x8(%rdi), %rcx
movl $0x1, %edx
xorl %r8d, %r8d
movsd 0x3ee3(%rip), %xmm1     # 0x95d0
leaq 0x3de8(%rip), %rsi      # 0x94dc
movsd 0x3ee4(%rip), %xmm2     # 0x95e0
movsd 0x3ee4(%rip), %xmm3     # 0x95e8
movsd 0x3ecc(%rip), %xmm4     # 0x95d8
movzbl (%rcx,%r8), %r8d
movsbl %r8b, %r14d
leal -0x61(%r8), %r9d
cmpl $0x18, %r9d
ja 0x5733
movslq (%rsi,%r9,4), %r8
addq %rsi, %r8
movapd %xmm1, %xmm5
jmpq *%r8
movapd %xmm3, %xmm5
jmp 0x5753
addl $-0x31, %r8d
cmpl $0x9, %r8d
jae 0x57a3
leal -0xbc(,%r14,4), %r8d
xorps %xmm5, %xmm5
cvtsi2sd %r8d, %xmm5
jmp 0x5753
movapd %xmm2, %xmm5
addsd %xmm5, %xmm0
movsd %xmm0, 0x60(%rdi)
movl %edx, %r8d
incl %edx
cmpq %r8, %rax
ja 0x570c
jmp 0x576e
movapd %xmm4, %xmm5
jmp 0x5753
movq %rax, %xmm0
punpckldq 0x3e75(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x3e7d(%rip), %xmm0     # 0x9600
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd 0x60(%rdi), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x60(%rdi)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x3ee8(%rip), %rdi      # 0x9692
callq 0x33e0
movq 0x7822(%rip), %r15      # 0xcfd8
movq %r15, %rdi
movl %r14d, %esi
callq 0x32c0
movq %rax, %rdi
callq 0x3110
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3210
movq %rax, %rdi
callq 0x3110
callq 0x3160
nop
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]motiflocation/motif.cpp
// Function: motif::motif(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
motif::motif(string input)
{
	// Set motif to input sting.
	ExpVal = 0.0;
	sequence = input;
	CalcDegeneracy();
	get_max_length();
	doComplement();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r15
leaq 0x7261(%rip), %rax      # 0xca98
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %r14
movq %r14, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movb %al, 0x18(%rdi)
leaq 0x38(%rdi), %r13
movq %r13, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movb %al, 0x38(%rdi)
movq %rax, 0x78(%rdi)
movq %rbx, %rdi
callq 0x3140
movq %r15, %rdi
callq 0x56b6
movq (%rbx), %rax
movb (%rax), %sil
testb %sil, %sil
je 0x58ac
incq %rax
xorl %ecx, %ecx
movl $0x1, %edx
leal -0x32(%rsi), %edi
addb $-0x30, %sil
cmpb $0x8, %dil
movzbl %sil, %esi
cmovael %edx, %esi
movsbl %sil, %esi
addl %esi, %ecx
movb (%rax), %sil
incq %rax
testb %sil, %sil
jne 0x5887
jmp 0x58ae
xorl %ecx, %ecx
movl %ecx, 0x70(%r15)
movq %r15, %rdi
callq 0x5652
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r12
movq 0x28(%r15), %rdi
cmpq %r13, %rdi
je 0x58dc
movq (%r13), %rsi
incq %rsi
callq 0x3270
movq %rbx, %rdi
movq %r14, %rsi
callq 0x359c
movq %r12, %rdi
callq 0x34d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]motiflocation/motif.cpp
// Function: motif::getComplement(char)
char motif::getComplement(char base)
{
	switch (base)
	{
	case 'a': return 't';
	case 'c': return 'g';
	case 'g': return 'c';
	case 't': return 'a';
	case 'r': return 'y';
	case 'y': return 'r';
	case 'k': return 'm';
	case 'm': return 'k';
	case 's': return 's';
	case 'w': return 'w';
	case 'b': return 'v';
	case 'd': return 'h';
	case 'h': return 'd';
	case 'v': return 'b';
	case 'n': return 'n';
	case '1': return '1';
	case '2': return '2';
	case '3': return '3';
	case '4': return '4';
	case '5': return '5';
	case '6': return '6';
	case '7': return '7';
	case '8': return '8';
	case '9': return '9';
	default:
		cout << "Cannot find base complement of : " << base << endl;
		abort();
		return base;
	}
}

// Assembly:
pushq %rbx
movl %esi, %ebx
leal -0x61(%rsi), %eax
cmpl $0x18, %eax
ja 0x5969
leaq 0x3c08(%rip), %rcx      # 0x9564
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x74, %bl
jmp 0x5981
addl $-0x31, %esi
cmpl $0x8, %esi
ja 0x59b1
leaq 0x3bc8(%rip), %rax      # 0x9540
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl %ebx, %eax
popq %rbx
retq
movb $0x6d, %bl
jmp 0x5981
movb $0x72, %bl
jmp 0x5981
movb $0x67, %bl
jmp 0x5981
movb $0x62, %bl
jmp 0x5981
movb $0x6b, %bl
jmp 0x5981
movb $0x63, %bl
jmp 0x5981
movb $0x76, %bl
jmp 0x5981
movb $0x61, %bl
jmp 0x5981
movb $0x68, %bl
jmp 0x5981
movb $0x79, %bl
jmp 0x5981
movb $0x64, %bl
jmp 0x5981
movq 0x7620(%rip), %rdi      # 0xcfd8
leaq 0x3c51(%rip), %rsi      # 0x9610
callq 0x3250
movsbl %bl, %esi
movq %rax, %rdi
callq 0x32c0
movq %rax, %rdi
callq 0x3110
callq 0x3160
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]motiflocation/motif.cpp
// Function: motif::basematch(char, char)
inline bool motif::basematch(const char base1, const char base2)
{
	switch (base1)
	{
		case 'a':
			switch (base2)
			{
			/*case 'c': case 'g': case 't': case 'y': case 'k': case 's': case 'b':	// quicker to test the -ve case
				return false;
			default:
				return true;*/
			case 'a': case 'r': case 'm': case 'w': case 'd': case 'h': case 'v': case 'n':
				return true; 
			default:
			
				return false; 
			}
			break;
		case 'c': 
			switch (base2)
			{
			/*case 'a': case 'g': case 't': case 'r': case 'k': case 'w': case 'h':	// quicker to test the -ve case
				return false;
			default:
				return true;*/
			case 'c': case 'y': case 'm': case 's': case 'b': case 'h': case 'v': case 'n':
				return true; 
			default:
				return false; 
			}
			break;
		case 'g':
			switch (base2)
			{
			/*case 'a': case 'c': case 't': case 'y': case 'm': case 'w': case 'h':	// quicker to test the -ve case
				return false;
			default:
				return true;*/
			case 'g': case 'r': case 'k': case 's': case 'b': case 'd': case 'v': case 'n':
				return true; 
			default:
				return false; 
			}
			break;
		case 't':
			switch (base2)
			{
			/*case 'a': case 'c': case 'g': case 'r': case 'm': case 's': case 'v':	// quicker to test the -ve case
				return false;
			default:
				return true;*/
			case 't': case 'y': case 'k': case 'w': case 'b': case 'd': case 'h': case 'n':
				return true; 
			default:
				return false; 
			}
			break;
		case 'n': 
			return false; 
		default:
			cout << "\nNon-standard character in sequence file: " << base1 << " : " << base2 << endl;
			//abort();
			return false;
		}
	return false;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movl %esi, %ebp
cmpl $0x66, %esi
jle 0x5d29
cmpl $0x67, %ebp
je 0x5d46
cmpl $0x6e, %ebp
je 0x5df8
cmpl $0x74, %ebp
jne 0x5d73
addb $-0x62, %bl
cmpb $0x18, %bl
jae 0x5df8
movl $0xa41245, %eax         # imm = 0xA41245
jmp 0x5d6a
cmpl $0x61, %ebp
je 0x5d59
cmpl $0x63, %ebp
jne 0x5d73
addb $-0x62, %bl
cmpb $0x18, %bl
jae 0x5df8
movl $0x921843, %eax         # imm = 0x921843
jmp 0x5d6a
addb $-0x62, %bl
cmpb $0x15, %bl
jae 0x5df8
movl $0x131225, %eax         # imm = 0x131225
jmp 0x5d6a
addb $-0x61, %bl
cmpb $0x17, %bl
jae 0x5df8
movl $0x623089, %eax         # imm = 0x623089
movl %ebx, %ecx
shrl %cl, %eax
jmp 0x5dfa
movq 0x725e(%rip), %r14      # 0xcfd8
leaq 0x38b1(%rip), %rsi      # 0x9632
movl $0x2a, %edx
movq %r14, %rdi
callq 0x32b0
leaq 0xe(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x32b0
movq %rax, %r14
leaq 0x3881(%rip), %rsi      # 0x962e
movl $0x3, %edx
movq %rax, %rdi
callq 0x32b0
leaq 0xf(%rsp), %rsi
movb %bl, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x32b0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3240
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3190
xorl %eax, %eax
andb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]motiflocation/DNA.cpp
// Function: DNA::DNA(char*)
DNA::DNA(char *seq)
{
	string seqstring = seq;
	std::transform (seqstring.begin(), seqstring.end(), seqstring.begin(), ToLower());
	Trim(seqstring);
	sequence.resize(1);
	sequence[0].append(seqstring);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
leaq 0x6ba7(%rip), %rax      # 0xcac8
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movq $0x0, 0x48(%rdi)
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x730e
movq 0x18(%rsp), %r15
testq %r15, %r15
je 0x5f7a
movq 0x10(%rsp), %r12
xorl %r13d, %r13d
movsbl (%r12,%r13), %edi
callq 0x3360
movb %al, (%r12,%r13)
incq %r13
cmpq %r13, %r15
jne 0x5f64
leaq 0x10(%rsp), %rsi
callq 0x6020
movl $0x1, %esi
movq %rbx, %rdi
callq 0x734c
movq (%rbx), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x30c0
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5fbe
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3270
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r15
jmp 0x5fef
movq %rax, %r15
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5fef
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3270
movq 0x38(%r14), %rdi
testq %rdi, %rdi
je 0x6004
movq 0x48(%r14), %rsi
subq %rdi, %rsi
callq 0x3270
addq $0x20, %r14
movq %r14, %rdi
callq 0x4ab6
movq %rbx, %rdi
callq 0x4ab6
movq %r15, %rdi
callq 0x34d0
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]motiflocation/DNA.cpp
// Function: DNA::Trim(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void DNA::Trim(string &str)
{
		// trim leading whitespace
		string::size_type  notwhite = str.find_first_not_of(" \t\n\v\b\r\f\a\\\?\'\"\0");
		str.erase(0,notwhite);

		// trim trailing whitespace
		notwhite = str.find_last_not_of(" \t\n\v\b\r\f\a\\\?\'\"\0"); 
		str.erase(notwhite+1); 
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x3781(%rip), %r14      # 0x97af
movl $0xc, %ecx
movq %rsi, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3460
movq %rbx, %rdi
xorl %esi, %esi
movq %rax, %rdx
callq 0x3080
movl $0xc, %ecx
movq %rbx, %rdi
movq %r14, %rsi
movq $-0x1, %rdx
callq 0x3420
incq %rax
movq 0x8(%rbx), %rcx
cmpq %rax, %rcx
jb 0x6083
movq %rax, 0x8(%rbx)
movq (%rbx), %rcx
movb $0x0, (%rcx,%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x36da(%rip), %rdi      # 0x9764
leaq 0x370a(%rip), %rsi      # 0x979b
movq %rax, %rdx
xorl %eax, %eax
callq 0x33b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]motiflocation/DNA.cpp
// Function: DNA::remove_upper_or_lowercase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, bool, bool)
void DNA::remove_upper_or_lowercase(string &string1, bool uppercase_only, bool lowercase_only)
{
	if (uppercase_only == true)
	{
		size_t position = string1.find_first_of("acgt");
		while ( position != string::npos )
		{
			string1.replace( position, 1, "N" );
			position = string1.find_first_of("acgt", position + 1 );
		}
	}
	else if (lowercase_only == true)
	{
		size_t position = string1.find_first_of("ACGT");
		while ( position != string::npos )
		{
			string1.replace( position, 1, "N" );
			position = string1.find_first_of("ACGT", position + 1 );
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
testl %edx, %edx
je 0x687c
leaq 0x2f26(%rip), %rsi      # 0x973e
movl $0x4, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x33c0
cmpq $-0x1, %rax
je 0x68e5
movq %rax, %r14
leaq 0x2f08(%rip), %r15      # 0x9743
leaq 0x2efc(%rip), %r12      # 0x973e
movl $0x1, %edx
movl $0x1, %r8d
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x32a0
incq %r14
movl $0x4, %ecx
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x33c0
movq %rax, %r14
cmpq $-0x1, %rax
jne 0x6842
jmp 0x68e5
testb %cl, %cl
je 0x68e5
leaq 0x2ebe(%rip), %rsi      # 0x9745
movl $0x4, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x33c0
cmpq $-0x1, %rax
je 0x68e5
movq %rax, %r14
leaq 0x2e9d(%rip), %r15      # 0x9743
leaq 0x2e98(%rip), %r12      # 0x9745
movl $0x1, %edx
movl $0x1, %r8d
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x32a0
incq %r14
movl $0x4, %ecx
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x33c0
movq %rax, %r14
cmpq $-0x1, %rax
jne 0x68ad
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]motiflocation/DNA.cpp
// Function: DNA::CountMotifOccurances(motif&)
int DNA::CountMotifOccurances(motif &Motif)
{
	int i;
	int count = 0;
	bool match;

	for (i=NSeqs; i--;)
	{
		match = Motif.IsMotifInSequence(sequence[i].c_str(), Motif.sequence.c_str(), 0);
		if (match)
		{
			// have found motif so we're done
			count++;
		}
		else
		{
			// we didn't find the motif, so we need to test the complement
			match = Motif.IsMotifInSequence(sequence[i].c_str(), Motif.complement.c_str() ,0 );
			if (match)
			{
				count++;
			}
		}
	}
	return count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movslq 0x50(%rdi), %r15
testq %r15, %r15
je 0x7300
movq %rsi, %rbx
movq %rdi, %r14
movq %r15, %r12
shlq $0x5, %r12
addq $-0x20, %r12
xorl %ebp, %ebp
movq 0x8(%r14), %rax
movq (%rax,%r12), %rsi
movq 0x8(%rbx), %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x59dc
movl $0x1, %ecx
testb %al, %al
jne 0x72f0
movq 0x8(%r14), %rax
movq (%rax,%r12), %rsi
movq 0x28(%rbx), %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x59dc
movzbl %al, %ecx
addl %ecx, %ebp
decq %r15
addq $-0x20, %r12
testq %r15, %r15
jne 0x72b8
jmp 0x7302
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]motiflocation/random.cpp
// Function: ran2()
double ran2(void) {
	int j;
	long k;
	extern long *idum;
	static long idum2=123456789;
	static long iy=0;
	static long iv[NTAB];
	double temp;

	if (*idum <= 0) {
		if (-(*idum) < 1) *idum=1;
		else *idum = -(*idum);
		idum2=(*idum);
		for (j=NTAB+7; j>=0; j--) {
			k=(*idum)/IQ1;
			*idum=IA1*(*idum-k*IQ1)-k*IR1;
			if (*idum < 0) *idum += IM1;
			if (j < NTAB) iv[j] = *idum;
			
		}
		iy=iv[0];
	}
	k=(*idum)/IQ1;
	*idum=IA1*(*idum-k*IQ1)-k*IR1;
	if (*idum < 0) *idum += IM1;
	k=idum2/IQ2;
	idum2=IA2*(idum2-k*IQ2)-k*IR2;
	if (idum2 < 0) idum2 += IM2;
	j=iy/NDIV;
	iy=iv[j]-idum2;
	iv[j]=*idum;
	if (iy < 1) iy += IMM1;
	if ((temp=AM*iy) > RNMX) return RNMX;
	else return temp;
}

// Assembly:
leaq 0x586e(%rip), %rax      # 0xd2f0
movq (%rax), %rsi
movq (%rsi), %rax
movabsq $-0x63b1c558e51dab79, %rdi # imm = 0x9C4E3AA71AE25487
testq %rax, %rax
jg 0x7b20
negq %rax
movl $0x1, %ecx
cmovbq %rax, %rcx
movq %rcx, (%rsi)
movq %rcx, 0x5807(%rip)      # 0xd2b8
movl $0x27, %r8d
leaq 0x5852(%rip), %r9       # 0xd310
movq %rcx, %rax
imulq %rdi
addq %rcx, %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0xf, %rdx
addq %rax, %rdx
imulq $-0xd1a4, %rdx, %rax    # imm = 0xFFFF2E5C
addq %rcx, %rax
imulq $0x9c4e, %rax, %rax     # imm = 0x9C4E
imulq $-0x2fb3, %rdx, %rdx    # imm = 0xD04D
leaq (%rax,%rdx), %rcx
addq $0x7fffffab, %rcx       # imm = 0x7FFFFFAB
addq %rdx, %rax
cmovnsq %rax, %rcx
cmpq $0x1f, %r8
ja 0x7b09
movq %rcx, (%r9,%r8,8)
addq $-0x1, %r8
jb 0x7abe
movq %rcx, (%rsi)
movq 0x57f7(%rip), %rax      # 0xd310
movq %rax, 0x57e0(%rip)      # 0xd300
movq (%rsi), %rcx
movq %rcx, %rax
imulq %rdi
addq %rcx, %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0xf, %rdx
addq %rax, %rdx
imulq $-0xd1a4, %rdx, %rax    # imm = 0xFFFF2E5C
addq %rcx, %rax
imulq $0x9c4e, %rax, %rax     # imm = 0x9C4E
imulq $-0x2fb3, %rdx, %rcx    # imm = 0xD04D
leaq (%rax,%rcx), %rdx
addq $0x7fffffab, %rdx       # imm = 0x7FFFFFAB
addq %rcx, %rax
cmovnsq %rax, %rdx
movq %rdx, (%rsi)
movq 0x574a(%rip), %rcx      # 0xd2b8
movabsq $0x4f7a09cc7bd54605, %rdx # imm = 0x4F7A09CC7BD54605
movq %rcx, %rax
imulq %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0xe, %rdx
addq %rax, %rdx
imulq $-0xce26, %rdx, %rax    # imm = 0xFFFF31DA
addq %rcx, %rax
imulq $0x9ef4, %rax, %rax     # imm = 0x9EF4
imulq $-0xecf, %rdx, %rcx     # imm = 0xF131
leaq (%rax,%rcx), %rdi
addq $0x7fffff07, %rdi       # imm = 0x7FFFFF07
addq %rcx, %rax
cmovnsq %rax, %rdi
movq %rdi, 0x56fb(%rip)      # 0xd2b8
movq 0x573c(%rip), %rcx      # 0xd300
movabsq $-0x7fffffbfffffdfff, %rdx # imm = 0x8000004000002001
movq %rcx, %rax
imulq %rdx
addq %rcx, %rdx
movq %rdx, %rax
shrq $0x3f, %rax
shrq $0x19, %rdx
addl %eax, %edx
movslq %edx, %rcx
leaq 0x5722(%rip), %rdx      # 0xd310
movq (%rdx,%rcx,8), %rax
subq %rdi, %rax
movq %rax, 0x5704(%rip)      # 0xd300
movq (%rsi), %rsi
movq %rsi, (%rdx,%rcx,8)
jg 0x7c12
addq $0x7fffffaa, %rax       # imm = 0x7FFFFFAA
movq %rax, 0x56ee(%rip)      # 0xd300
cvtsi2sdq 0x56e5(%rip), %xmm1 # 0xd300
mulsd 0x1bad(%rip), %xmm1     # 0x97d0
movsd 0x1bad(%rip), %xmm0     # 0x97d8
minsd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]motiflocation/random.cpp
// Function: ran2(double, double)
double ran2(double min, double max)
{
	double r = ran2();
	r *= (max - min);
	r += min;
	return r;
}

// Assembly:
subq $0x18, %rsp
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
callq 0x7a7b
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm2
subsd %xmm1, %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]motiflocation/random.cpp
// Function: ran2(int, int)
int ran2(int min, int max)
{
	double r = ran2();
	r *= (double)(max - min);
	r += min;
	return (int)r;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
callq 0x7a7b
subl %ebp, %ebx
cvtsi2sd %ebx, %xmm1
mulsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/auton1[P]motiflocation/random.cpp
// Function: gammln(double)
double gammln(double xx)
{
	double x,y,tmp,ser;
	static double cof[6]={76.18009172947146,-86.50532032941677,
	24.01409824083091,-1.231739572450155,
	0.1208650973866179e-2,-0.5395239384953e-5};
	int j;
	y=x=xx;
	tmp=x+5.5;
	tmp -= (x+0.5)*log(tmp);
	ser=1.000000000190015;
	for (j=0;j<=5;j++) ser += cof[j]/++y;
	return -tmp+log(2.5066282746310005*ser/x);
}

// Assembly:
subq $0x18, %rsp
movapd %xmm0, %xmm1
movsd %xmm0, 0x10(%rsp)
movsd 0x1b26(%rip), %xmm0     # 0x97e0
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x31d0
movsd 0x10(%rsp), %xmm5
movapd %xmm0, %xmm1
movsd 0x1b0d(%rip), %xmm0     # 0x97e8
xorl %eax, %eax
leaq 0x1b7c(%rip), %rcx      # 0x9860
movsd 0x18e4(%rip), %xmm2     # 0x95d0
movapd %xmm5, %xmm3
movsd (%rax,%rcx), %xmm4
addsd %xmm2, %xmm3
divsd %xmm3, %xmm4
addsd %xmm4, %xmm0
addq $0x8, %rax
cmpq $0x30, %rax
jne 0x7cf0
movsd 0x1add(%rip), %xmm2     # 0x97f0
addsd %xmm5, %xmm2
mulsd %xmm1, %xmm2
movsd 0x8(%rsp), %xmm1
subsd %xmm2, %xmm1
movsd %xmm1, 0x8(%rsp)
mulsd 0x1ac5(%rip), %xmm0     # 0x97f8
divsd %xmm5, %xmm0
callq 0x31d0
subsd 0x8(%rsp), %xmm0
addq $0x18, %rsp
retq