LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/rilutham[P]gotojakarta/./stlastar.h
// Function: AStarSearch<PathSearchNode>::AllocateNode()
Node *AllocateNode()
	{

#if !USE_FSA_MEMORY
		Node *p = new Node;
		return p;
#else
		Node *address = m_FixedSizeAllocator.alloc();

		if( !address )
		{
			return NULL;
		}
		m_AllocateNodeCount ++;
		Node *p = new (address) Node;
		return p;
#endif
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x68(%rdi), %rax
testq %rax, %rax
je 0x23ff
movq 0x28(%rax), %rcx
movq %rcx, 0x68(%rdi)
testq %rcx, %rcx
je 0x23d2
movq $0x0, 0x20(%rcx)
movq $0x0, 0x20(%rax)
movq 0x70(%rdi), %rcx
testq %rcx, %rcx
je 0x23e7
movq %rax, 0x20(%rcx)
movq %rcx, 0x28(%rax)
movq %rax, 0x70(%rdi)
incl 0x98(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/rilutham[P]gotojakarta/./fsa.h
// Function: FixedSizeAllocator<AStarSearch<PathSearchNode>::Node>::FixedSizeAllocator(unsigned int)
FixedSizeAllocator( unsigned int MaxElements = FSA_DEFAULT_SIZE ) :
	m_pFirstUsed( NULL ),
	m_MaxElements( MaxElements )
	{
		// Allocate enough memory for the maximum number of elements

		char *pMem = new char[ m_MaxElements * sizeof(FSA_ELEMENT) ];

		m_pMemory = (FSA_ELEMENT *) pMem; 

		// Set the free list first pointer
		m_pFirstFree = m_pMemory;

		// Clear the memory
		memset( m_pMemory, 0, sizeof( FSA_ELEMENT ) * m_MaxElements );

		// Point at first element
		FSA_ELEMENT *pElement = m_pFirstFree;

		// Set the double linked free list
		for( unsigned int i=0; i<m_MaxElements; i++ )
		{
			pElement->pPrev = pElement-1;
			pElement->pNext = pElement+1;

			pElement++;
		}

		// first element should have a null prev
		m_pFirstFree->pPrev = NULL;
		// last element should have a null next
		(pElement-1)->pNext = NULL;

	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r15
movq $0x0, 0x8(%rdi)
movl %esi, 0x10(%rdi)
movl %esi, %eax
shlq $0x4, %rax
leaq (%rax,%rax,2), %r12
movq %r12, %rdi
callq 0x1030
movq %rax, %r14
movq %rax, 0x18(%r15)
movq %rax, (%r15)
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x1090
movq %r14, %rax
testl %ebx, %ebx
je 0x25ac
movq %r14, %rax
addq $0x30, %rax
leaq -0x60(%rax), %rcx
movq %rcx, -0x10(%rax)
movq %rax, -0x8(%rax)
addq $0x30, %rax
decl %ebx
jne 0x2594
addq $-0x30, %rax
xorl %ecx, %ecx
movq %rcx, 0x20(%r14)
movq %rcx, -0x8(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/rilutham[P]gotojakarta/./stlastar.h
// Function: AStarSearch<PathSearchNode>::FreeAllNodes()
void FreeAllNodes()
	{
		// iterate open list and delete all nodes
		typename vector< Node * >::iterator iterOpen = m_OpenList.begin();

		while( iterOpen != m_OpenList.end() )
		{
			Node *n = (*iterOpen);
			FreeNode( n );

			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);
			FreeNode( n );
		}

		m_ClosedList.clear();

		// delete the goal

		FreeNode(m_Goal);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
cmpq 0x8(%rdi), %r14
je 0x25f4
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x2630
addq $0x8, %r14
cmpq 0x8(%rbx), %r14
jne 0x25d3
movq (%rbx), %rax
cmpq %rax, %r14
je 0x25f4
movq %rax, 0x8(%rbx)
movq 0x18(%rbx), %r14
cmpq 0x20(%rbx), %r14
je 0x2620
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x2630
addq $0x8, %r14
cmpq 0x20(%rbx), %r14
jne 0x25fe
movq 0x18(%rbx), %rax
cmpq %rax, %r14
je 0x2620
movq %rax, 0x20(%rbx)
movq 0x58(%rbx), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2630
// File: /workspace/github_cpp_makefile_star2_O3/rilutham[P]gotojakarta/./stlastar.h
// Function: AStarSearch<PathSearchNode>::FreeNode(AStarSearch<PathSearchNode>::Node*)
void FreeNode( Node *node )
	{

		m_AllocateNodeCount --;

#if !USE_FSA_MEMORY
		delete node;
#else
		node->~Node();
		m_FixedSizeAllocator.free( node );
#endif
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
decl 0x98(%rdi)
movq 0x20(%rsi), %rax
movq 0x28(%rsi), %rcx
leaq 0x70(%rdi), %rdx
leaq 0x28(%rax), %r8
testq %rax, %rax
cmoveq %rdx, %r8
movq %rcx, (%r8)
testq %rcx, %rcx
je 0x265d
movq %rax, 0x20(%rcx)
movq 0x68(%rdi), %rax
testq %rax, %rax
je 0x266c
movq %rsi, 0x20(%rax)
jmp 0x2674
movq $0x0, 0x20(%rsi)
movq %rsi, 0x68(%rdi)
movq %rax, 0x28(%rsi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x8(%rdi), %rax
cmpq %rax, %r14
je 0x26bf
movq (%r14), %rsi
cmpq $0x0, 0x8(%rsi)
jne 0x26aa
movq %rbx, %rdi
callq 0x2630
movq 0x8(%rbx), %rax
addq $0x8, %r14
cmpq %rax, %r14
jne 0x2694
movq (%rbx), %rcx
cmpq %rcx, %rax
je 0x26bf
movq %rcx, 0x8(%rbx)
movq 0x18(%rbx), %r14
movq 0x20(%rbx), %rax
cmpq %rax, %r14
je 0x26f8
movq (%r14), %rsi
cmpq $0x0, 0x8(%rsi)
jne 0x26e2
movq %rbx, %rdi
callq 0x2630
movq 0x20(%rbx), %rax
addq $0x8, %r14
cmpq %rax, %r14
jne 0x26cc
movq 0x18(%rbx), %rcx
cmpq %rcx, %rax
je 0x26f8
movq %rcx, 0x20(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1c50
xorl %ebx, %ebx
testb %al, %al
jne 0x12f5
leaq 0x1d60(%rip), %rdi      # 0x3038
callq 0x1180
jmp 0x12f5
movq (%rsi), %rsi
leaq 0x1d1b(%rip), %rdi      # 0x3004
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_O3/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, -0x38(%rbp)
movl %r8d, %eax
movq %rcx, -0x48(%rbp)
movq %rdx, %r12
movl %edi, %r13d
leaq -0x70(%rbp), %rcx
movl $0x0, (%rcx)
xorl %ebx, %ebx
movq %rbx, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
movq %rbx, 0x20(%rcx)
xorl %edx, %edx
movl %esi, -0x2c(%rbp)
divl %esi
movl %edi, -0x30(%rbp)
movl %eax, %r14d
cmpl %edi, %eax
jbe 0x197c
movq %rcx, %r15
xorl %ebx, %ebx
movl %r13d, %eax
movq -0x68(%rbp), %rdi
testq %rdi, %rdi
je 0x195b
movq %r15, %r8
movq %r8, %rcx
movq %rdi, %rdx
movl 0x20(%rdi), %esi
xorl %edi, %edi
cmpl %eax, %esi
setb %dil
movq %rdx, %r8
cmovbq %rcx, %r8
movq 0x10(%rdx,%rdi,8), %rdi
testq %rdi, %rdi
jne 0x1925
cmpq %r15, %r8
je 0x195b
cmpl %eax, %esi
cmovbq %rcx, %rdx
cmpl 0x20(%rdx), %eax
jae 0x19e4
leaq -0x78(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1ad6
incl %ebx
movl -0x30(%rbp), %eax
shll $0x2, %eax
movl (%r12,%rax), %eax
movl %eax, -0x30(%rbp)
cmpl %r14d, %eax
jb 0x1919
movq 0x10(%rbp), %rax
imull -0x2c(%rbp), %ebx
movl %ebx, (%rax)
movq %rbx, %rdi
callq 0x1160
movq -0x38(%rbp), %rcx
movq %rax, (%rcx)
movb $0x1, %r15b
cmpl %r13d, %r14d
jbe 0x19e7
movq %rcx, %rax
movl %r14d, %ebx
movl -0x2c(%rbp), %edx
movl %edx, %ecx
movq %rcx, -0x40(%rbp)
movq %rax, %r14
xorl %r15d, %r15d
movl %edx, %eax
movl %r15d, %edi
addq (%r14), %rdi
movl %r13d, %esi
imull %eax, %esi
addq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x10c0
movl %r13d, %eax
movl (%r12,%rax,4), %r13d
movl -0x2c(%rbp), %eax
addl %eax, %r15d
cmpl %ebx, %r13d
jb 0x19b4
movb $0x1, %r15b
jmp 0x19e7
xorl %r15d, %r15d
leaq -0x78(%rbp), %rdi
callq 0x1bf2
movl %r15d, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x1bf2
movq %rbx, %rdi
callq 0x11a0
// File: /workspace/github_cpp_makefile_star2_O3/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), %r9d
testq %r9, %r9
je 0x1ac2
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), %r11b
movq 0x8(%rdi), %rdx
movb $0x1, %al
xorl %r8d, %r8d
xorl %ebx, %ebx
movb $0x1, %r14b
testb %r11b, %r11b
je 0x1a99
movq (%rdx,%rbx,8), %r15
movl $0x1, %r12d
xorl %r13d, %r13d
movl %r11d, %r10d
movsbl %r10b, %r10d
movl %r13d, %ecx
movzbl (%r15,%rcx), %ecx
cmpl %ecx, %r10d
jne 0x1a83
movl %r12d, %r10d
movb (%rsi,%r10), %r10b
incl %r12d
addl $0x2, %r13d
testb %r10b, %r10b
jne 0x1a5d
jmp 0x1a93
incq %rbx
cmpq %r9, %rbx
setb %r14b
jne 0x1a48
xorl %eax, %eax
jmp 0x1ab6
movl %ebx, %r8d
movl %r14d, %eax
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 0x1ac4
xorl %eax, %eax
andb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x13d2(%rip), %rsi      # 0x303e
callq 0x1130
testq %rax, %rax
je 0x1cfe
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 0x1cf1
leaq 0x1396(%rip), %rsi      # 0x3041
movq %r14, %rdi
callq 0x1130
testq %rax, %rax
je 0x1cf1
movq %rax, %r14
leaq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x1f40
movq %r14, %rdi
callq 0x10d0
leaq -0x40(%rbp), %rdi
movq %rbx, %rsi
callq 0x20cc
leaq -0x40(%rbp), %rdi
callq 0x2730
movb $0x1, %bl
leaq -0x40(%rbp), %rdi
callq 0x2ecd
jmp 0x1cf3
xorl %ebx, %ebx
leaq -0x40(%rbp), %rdi
callq 0x131c
jmp 0x1d00
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1d11
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x131c
movq %rbx, %rdi
callq 0x11a0
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/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 0x11ba(%rip), %rsi      # 0x3044
leaq -0x18(%rbp), %rdx
leaq -0x24(%rbp), %rcx
callq 0x1a16
testb %al, %al
je 0x1f2c
movq -0x18(%rbp), %rax
movzwl 0xa(%rax), %eax
btl $0x9, %eax
leaq 0x11a6(%rip), %rax      # 0x3058
leaq 0x1198(%rip), %rsi      # 0x3051
cmovaeq %rax, %rsi
leaq -0x20(%rbp), %rdx
leaq -0xc(%rbp), %rcx
movq %rbx, %rdi
callq 0x1a16
testb %al, %al
je 0x1f2c
movq -0x18(%rbp), %rax
movl 0x1a2(%rax), %ecx
movl 0x1a6(%rax), %edx
movl -0xc(%rbp), %esi
cmpl %esi, %ecx
setae %dil
testl %edx, %edx
sete %r8b
xorl %eax, %eax
orb %dil, %r8b
jne 0x1f2e
movq -0x20(%rbp), %rdi
addq %rdi, %rcx
addq %rdi, %rsi
movq %rcx, %rdi
xorl %r8d, %r8d
movzbl (%rdi), %r9d
cmpl $0x1, %r9d
jne 0x1f35
movzwl 0x1(%rdi), %edi
addl %edi, %r8d
addl $0x3, %r8d
leaq (%rcx,%r8), %rdi
cmpq %rsi, %rdi
jae 0x1f2e
cmpl %edx, %r8d
jb 0x1f07
jmp 0x1f2e
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
cmpl $0x2, %r9d
jne 0x1f2e
movq %rdi, %rax
jmp 0x1f2e
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2a9c
shrb %r15b
cmpb $0x1, %r14b
movl %r15d, %r14d
ja 0x272e
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2a66
cmpl $0x63, %eax
jne 0x2a77
movq 0x10(%rsi), %rdi
movq 0x18(%rsi), %rsi
callq 0x237c
jmp 0x2a73
movq 0x10(%rsi), %rdi
movq 0x18(%rsi), %rsi
callq 0x2756
xorl %eax, %eax
popq %rcx
retq
movl $0x8, %edi
callq 0x20b0
leaq 0x157c(%rip), %rcx      # 0x4004
movq %rcx, (%rax)
movq 0x3536(%rip), %rsi      # 0x5fc8
movq %rax, %rdi
xorl %edx, %edx
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x331f
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rsi
callq 0x32e8
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x32e8
movl $0x20, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2130
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
cmpq $0x0, (%rsi)
je 0x3360
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2a9c
movq (%r15), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x3320
subl $0x1, 0x18(%rbx)
jae 0x3367
movl $0x3f, 0x18(%rbx)
addq $-0x8, 0x10(%rbx)
jmp 0x3367
cmpq $0x0, 0x8(%r15)
je 0x33a2
cmpq $0x0, 0x8(%r15)
je 0x339c
movq %rbx, %rdi
movl $0x1, %esi
callq 0x2a9c
movq 0x8(%r15), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x3320
subl $0x1, 0x18(%rbx)
jae 0x339c
movl $0x3f, 0x18(%rbx)
addq $-0x8, 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
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 0x3688
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3424
cmpl $0x0, 0x18(%r14)
je 0x3430
movq %rax, 0x10(%r14)
movl $0x0, 0x18(%r14)
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
cmpq %rax, %rcx
je 0x34ba
addq $0x408, %r15            # imm = 0x408
xorl %r12d, %r12d
movzbl (%rax,%r12), %edx
leaq (%rdx,%rdx,4), %rsi
movq (%r15,%rsi,8), %rdx
movq 0x10(%r15,%rsi,8), %rdi
movl 0x18(%r15,%rsi,8), %r8d
subq %rdx, %rdi
shlq $0x3, %rdi
addq %r8, %rdi
je 0x34ac
leaq (%r15,%rsi,8), %r13
xorl %ebp, %ebp
movl %ebp, %eax
shrl $0x6, %eax
movq (%rdx,%rax,8), %rax
xorl %esi, %esi
btq %rbp, %rax
setb %sil
movq %r14, %rdi
callq 0x2a9c
incq %rbp
movq (%r13), %rdx
movq 0x10(%r13), %rax
movl 0x18(%r13), %ecx
subq %rdx, %rax
leaq (%rcx,%rax,8), %rax
cmpq %rbp, %rax
ja 0x346f
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
incq %r12
movq %rcx, %rdx
subq %rax, %rdx
cmpq %r12, %rdx
ja 0x3446
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x34ed
movq %rax, 0x8(%r14)
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
movl 0x18(%rbx), %edx
movq %rcx, %rsi
subq %rax, %rsi
shlq $0x3, %rsi
addq %rdx, %rsi
je 0x356b
movq (%r15), %rsi
xorl %r13d, %r13d
leaq 0xf(%rsp), %r12
movl %r13d, %edi
shrl $0x6, %edi
movq (%rax,%rdi,8), %rdi
xorl %r8d, %r8d
btq %r13, %rdi
setb %r8b
movq (%rsi,%r8,8), %rsi
cmpq $0x0, (%rsi)
jne 0x3556
cmpq $0x0, 0x8(%rsi)
jne 0x3556
movb 0x18(%rsi), %al
movb %al, 0xf(%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x2b18
movq (%r15), %rsi
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
movl 0x18(%rbx), %edx
incq %r13
movq %rcx, %rdi
subq %rax, %rdi
movl %edx, %r8d
leaq (%r8,%rdi,8), %rdi
cmpq %r13, %rdi
ja 0x3511
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8acc(%rip), %xmm0     # 0xd2a8
leaq 0x49a3(%rip), %rdi      # 0x9186
movb $0x1, %al
callq 0x3050
leaq 0x4a1c(%rip), %rdi      # 0x920d
callq 0x33e0
leaq 0x4a44(%rip), %rdi      # 0x9241
callq 0x33e0
leaq 0x4a5c(%rip), %rdi      # 0x9265
callq 0x33e0
leaq 0x4a5a(%rip), %rdi      # 0x926f
callq 0x33e0
leaq 0x4a8b(%rip), %rdi      # 0x92ac
callq 0x33e0
leaq 0x4ab3(%rip), %rdi      # 0x92e0
callq 0x33e0
leaq 0x4ad3(%rip), %rdi      # 0x930c
callq 0x33e0
leaq 0x4b06(%rip), %rdi      # 0x934b
callq 0x33e0
leaq 0x4b33(%rip), %rdi      # 0x9384
callq 0x33e0
leaq 0x4b69(%rip), %rdi      # 0x93c6
callq 0x33e0
leaq 0x4ba4(%rip), %rdi      # 0x940d
callq 0x33e0
leaq 0x4bdf(%rip), %rdi      # 0x9454
callq 0x33e0
movl $0xa, %edi
popq %rax
jmp 0x3320
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x769e(%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 0x7b75
movl %eax, %r15d
movslq %eax, %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x30b0
testl %r15d, %r15d
jle 0x5486
movl %r15d, %r15d
xorl %r13d, %r13d
movzbl %bpl, %ebp
movl %ebp, %esi
callq 0x5554
movq (%r14), %rcx
movb %al, (%rcx,%r13)
incq %r13
cmpq %r13, %r15
jne 0x5470
movq %rbx, %rdi
callq 0x55f8
movq %rbx, %rdi
callq 0x565c
movq (%r14), %rax
movb (%rax), %sil
testb %sil, %sil
je 0x54d0
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 0x54ab
jmp 0x54d2
xorl %ecx, %ecx
movl %ecx, 0x70(%rbx)
movq 0x18(%rsp), %rdi
cmpq %r12, %rdi
je 0x54ec
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 0x54fd
movq %rax, %r15
movq 0x18(%rsp), %rdi
cmpq %r12, %rdi
je 0x5517
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x3270
movq 0x28(%rbx), %rdi
cmpq 0x8(%rsp), %rdi
je 0x5532
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x3270
movq (%r14), %rdi
cmpq 0x10(%rsp), %rdi
je 0x554c
movq 0x10(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x3270
movq %r15, %rdi
callq 0x34d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x558a
movl $0x6, %esi
callq 0x7b75
movl %eax, %ecx
cmpl $0x4, %eax
movl $0xe, %eax
cmovnel %ecx, %eax
cmpl $0x5, %eax
jne 0x5594
movl $0x1, %edi
movl $0xa, %esi
callq 0x7b75
addb $0x30, %al
popq %rcx
retq
movl $0x10, %esi
callq 0x7b75
cmpl $0xf, %eax
ja 0x55e7
movl %eax, %eax
leaq 0x3ef2(%rip), %rcx      # 0x9494
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x61, %al
jmp 0x5588
movb $0x76, %al
jmp 0x5588
movb $0x62, %al
jmp 0x5588
movb $0x74, %al
jmp 0x5588
movb $0x64, %al
jmp 0x5588
movb $0x73, %al
jmp 0x5588
movb $0x63, %al
jmp 0x5588
movb $0x6e, %al
jmp 0x5588
movb $0x67, %al
jmp 0x5588
movb $0x6b, %al
jmp 0x5588
movb $0x72, %al
jmp 0x5588
movb $0x68, %al
jmp 0x5588
movb $0x79, %al
jmp 0x5588
movb $0x77, %al
jmp 0x5588
movb $0x6d, %al
jmp 0x5588
leaq 0x4061(%rip), %rdi      # 0x964f
callq 0x33e0
callq 0x3160
// File: /workspace/github_cpp_makefile_star2_O3/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 0x564f
movl %r14d, %r15d
decq %r14
xorl %r12d, %r12d
movq 0x8(%rbx), %rax
movsbl (%rax,%r12), %esi
callq 0x58d2
movl %r14d, %ecx
movq 0x28(%rbx), %rdx
movb %al, (%rdx,%rcx)
incq %r12
decq %r14
cmpq %r12, %r15
jne 0x562c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq $0x0, 0x60(%rdi)
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x570d
leaq 0x8(%rdi), %rbx
movq (%rbx), %rcx
xorpd %xmm0, %xmm0
movl $0x1, %edx
xorl %r8d, %r8d
movsd 0x3f38(%rip), %xmm1     # 0x95c8
leaq 0x3e3d(%rip), %rsi      # 0x94d4
movsd 0x3f39(%rip), %xmm2     # 0x95d8
movsd 0x3f39(%rip), %xmm3     # 0x95e0
movsd 0x3f21(%rip), %xmm4     # 0x95d0
movzbl (%rcx,%r8), %r14d
leal -0x61(%r14), %r8d
cmpl $0x18, %r8d
ja 0x56d2
movslq (%rsi,%r8,4), %r8
addq %rsi, %r8
movapd %xmm1, %xmm5
jmpq *%r8
movapd %xmm3, %xmm5
jmp 0x56f2
leal -0x31(%r14), %r8d
cmpl $0x9, %r8d
jae 0x572a
leal -0xbc(,%r14,4), %r8d
xorps %xmm5, %xmm5
cvtsi2sd %r8d, %xmm5
jmp 0x56f2
movapd %xmm2, %xmm5
addsd %xmm5, %xmm0
movsd %xmm0, 0x60(%rdi)
movl %edx, %r8d
incl %edx
cmpq %r8, %rax
ja 0x56af
jmp 0x5711
movapd %xmm4, %xmm5
jmp 0x56f2
xorpd %xmm0, %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x60(%rdi)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x3f39(%rip), %rdi      # 0x966a
callq 0x33e0
movsbl %r14b, %esi
movq 0x7897(%rip), %r14      # 0xcfd8
movq %r14, %rdi
callq 0x32c0
movq %rax, %rdi
callq 0x3110
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3210
movq %rax, %rdi
callq 0x3110
callq 0x3160
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x72d9(%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 0x565c
movq (%rbx), %rax
movb (%rax), %sil
testb %sil, %sil
je 0x5834
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 0x580f
jmp 0x5836
xorl %ecx, %ecx
movl %ecx, 0x70(%r15)
movq %r15, %rdi
callq 0x55f8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r12
movq 0x28(%r15), %rdi
cmpq %r13, %rdi
je 0x5864
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_O3/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 0x58f1
leaq 0x3c78(%rip), %rcx      # 0x955c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x74, %bl
jmp 0x5909
addl $-0x31, %esi
cmpl $0x8, %esi
ja 0x5939
leaq 0x3c38(%rip), %rax      # 0x9538
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl %ebx, %eax
popq %rbx
retq
movb $0x6d, %bl
jmp 0x5909
movb $0x72, %bl
jmp 0x5909
movb $0x67, %bl
jmp 0x5909
movb $0x62, %bl
jmp 0x5909
movb $0x6b, %bl
jmp 0x5909
movb $0x63, %bl
jmp 0x5909
movb $0x76, %bl
jmp 0x5909
movb $0x61, %bl
jmp 0x5909
movb $0x68, %bl
jmp 0x5909
movb $0x79, %bl
jmp 0x5909
movb $0x64, %bl
jmp 0x5909
movq 0x7698(%rip), %rdi      # 0xcfd8
leaq 0x3ca1(%rip), %rsi      # 0x95e8
callq 0x3250
movsbl %bl, %esi
movq %rax, %rdi
callq 0x32c0
movq %rax, %rdi
callq 0x3110
callq 0x3160
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5cb7
cmpl $0x67, %ebp
je 0x5cd4
cmpl $0x6e, %ebp
je 0x5d86
cmpl $0x74, %ebp
jne 0x5d01
addb $-0x62, %bl
cmpb $0x18, %bl
jae 0x5d86
movl $0xa41245, %eax         # imm = 0xA41245
jmp 0x5cf8
cmpl $0x61, %ebp
je 0x5ce7
cmpl $0x63, %ebp
jne 0x5d01
addb $-0x62, %bl
cmpb $0x18, %bl
jae 0x5d86
movl $0x921843, %eax         # imm = 0x921843
jmp 0x5cf8
addb $-0x62, %bl
cmpb $0x15, %bl
jae 0x5d86
movl $0x131225, %eax         # imm = 0x131225
jmp 0x5cf8
addb $-0x61, %bl
cmpb $0x17, %bl
jae 0x5d86
movl $0x623089, %eax         # imm = 0x623089
movl %ebx, %ecx
shrl %cl, %eax
jmp 0x5d88
movq 0x72d0(%rip), %r14      # 0xcfd8
leaq 0x38fb(%rip), %rsi      # 0x960a
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 0x38cb(%rip), %rsi      # 0x9606
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_O3/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 0x6c1b(%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 0x723e
movq 0x18(%rsp), %r15
testq %r15, %r15
je 0x5f06
movq 0x10(%rsp), %r12
xorl %r13d, %r13d
movsbl (%r12,%r13), %edi
callq 0x3360
movb %al, (%r12,%r13)
incq %r13
cmpq %r13, %r15
jne 0x5ef0
leaq 0x10(%rsp), %rsi
callq 0x5fac
movl $0x1, %esi
movq %rbx, %rdi
callq 0x727c
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 0x5f4a
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 0x5f7b
movq %rax, %r15
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5f7b
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3270
movq 0x38(%r14), %rdi
testq %rdi, %rdi
je 0x5f90
movq 0x48(%r14), %rsi
subq %rdi, %rsi
callq 0x3270
addq $0x20, %r14
movq %r14, %rdi
callq 0x4a96
movq %rbx, %rdi
callq 0x4a96
movq %r15, %rdi
callq 0x34d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x37cd(%rip), %r14      # 0x9787
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 0x600f
movq %rax, 0x8(%rbx)
movq (%rbx), %rcx
movb $0x0, (%rcx,%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x3726(%rip), %rdi      # 0x973c
leaq 0x3756(%rip), %rsi      # 0x9773
movq %rax, %rdx
xorl %eax, %eax
callq 0x33b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x67f0
leaq 0x2f8a(%rip), %rsi      # 0x9716
movl $0x4, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x33c0
cmpq $-0x1, %rax
je 0x6859
movq %rax, %r14
leaq 0x2f6c(%rip), %r15      # 0x971b
leaq 0x2f60(%rip), %r12      # 0x9716
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 0x67b6
jmp 0x6859
testb %cl, %cl
je 0x6859
leaq 0x2f22(%rip), %rsi      # 0x971d
movl $0x4, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x33c0
cmpq $-0x1, %rax
je 0x6859
movq %rax, %r14
leaq 0x2f01(%rip), %r15      # 0x971b
leaq 0x2efc(%rip), %r12      # 0x971d
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 0x6821
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7230
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 0x5964
movl $0x1, %ecx
testb %al, %al
jne 0x7220
movq 0x8(%r14), %rax
movq (%rax,%r12), %rsi
movq 0x28(%rbx), %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x5964
movzbl %al, %ecx
addl %ecx, %ebp
decq %r15
addq $-0x20, %r12
testq %r15, %r15
jne 0x71e8
jmp 0x7232
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x593a(%rip), %rax      # 0xd2f0
movq (%rax), %r8
movq (%r8), %rsi
movabsq $-0x63b1c558e51dab79, %rdi # imm = 0x9C4E3AA71AE25487
testq %rsi, %rsi
jle 0x79db
leaq 0x592e(%rip), %r9       # 0xd300
movq 0x58df(%rip), %rcx      # 0xd2b8
jmp 0x7a48
negq %rsi
movl $0x1, %ecx
cmovbq %rsi, %rcx
movl $0x27, %r10d
leaq 0x591c(%rip), %r9       # 0xd310
movq %rcx, %rsi
movq %rsi, %rax
imulq %rdi
addq %rsi, %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0xf, %rdx
addq %rax, %rdx
imulq $-0xd1a4, %rdx, %rax    # imm = 0xFFFF2E5C
addq %rsi, %rax
imulq $0x9c4e, %rax, %rax     # imm = 0x9C4E
imulq $-0x2fb3, %rdx, %rdx    # imm = 0xD04D
leaq (%rax,%rdx), %rsi
addq $0x7fffffab, %rsi       # imm = 0x7FFFFFAB
addq %rdx, %rax
cmovnsq %rax, %rsi
cmpq $0x1f, %r10
ja 0x7a42
movq %rsi, (%r9,%r10,8)
addq $-0x1, %r10
jb 0x79f7
movq %rsi, %rax
imulq %rdi
movq (%r9), %rdi
addq %rsi, %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0xf, %rdx
addq %rax, %rdx
imulq $-0xd1a4, %rdx, %rax    # imm = 0xFFFF2E5C
addq %rsi, %rax
imulq $0x9c4e, %rax, %rax     # imm = 0x9C4E
imulq $-0x2fb3, %rdx, %rdx    # imm = 0xD04D
leaq (%rax,%rdx), %rsi
addq $0x7fffffab, %rsi       # imm = 0x7FFFFFAB
addq %rdx, %rax
cmovnsq %rax, %rsi
movabsq $0x4f7a09cc7bd54605, %rdx # imm = 0x4F7A09CC7BD54605
movq %rcx, %rax
imulq %rdx
movq %rsi, (%r8)
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), %r8
addq $0x7fffff07, %r8        # imm = 0x7FFFFF07
addq %rcx, %rax
cmovnsq %rax, %r8
movq %r8, 0x57da(%rip)       # 0xd2b8
movabsq $-0x7fffffbfffffdfff, %rcx # imm = 0x8000004000002001
movq %rdi, %rax
imulq %rcx
addq %rdi, %rdx
movq %rdx, %rax
shrq $0x3f, %rax
shrq $0x19, %rdx
addl %eax, %edx
movslq %edx, %rcx
leaq 0x5808(%rip), %rdx      # 0xd310
movq (%rdx,%rcx,8), %rax
movq %rsi, (%rdx,%rcx,8)
subq %r8, %rax
movq %rax, 0x57e6(%rip)      # 0xd300
jg 0x7b29
addq $0x7fffffaa, %rax       # imm = 0x7FFFFFAA
movq %rax, 0x57d7(%rip)      # 0xd300
cvtsi2sd %rax, %xmm1
mulsd 0x1c72(%rip), %xmm1     # 0x97a8
movsd 0x1c72(%rip), %xmm0     # 0x97b0
minsd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x79af
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_O3/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 0x1beb(%rip), %xmm0     # 0x97b8
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x31d0
movsd 0x10(%rsp), %xmm5
movapd %xmm0, %xmm1
movsd 0x1bd2(%rip), %xmm0     # 0x97c0
xorl %eax, %eax
leaq 0x1c49(%rip), %rcx      # 0x9840
movsd 0x19c9(%rip), %xmm2     # 0x95c8
movapd %xmm5, %xmm3
movsd (%rax,%rcx), %xmm4
addsd %xmm2, %xmm3
divsd %xmm3, %xmm4
addsd %xmm4, %xmm0
addq $0x8, %rax
cmpq $0x30, %rax
jne 0x7c03
movsd 0x1ba2(%rip), %xmm2     # 0x97c8
addsd %xmm5, %xmm2
mulsd %xmm1, %xmm2
movsd 0x8(%rsp), %xmm1
subsd %xmm2, %xmm1
movsd %xmm1, 0x8(%rsp)
mulsd 0x1b8a(%rip), %xmm0     # 0x97d0
divsd %xmm5, %xmm0
callq 0x31d0
subsd 0x8(%rsp), %xmm0
addq $0x18, %rsp
retq