LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-nanomap/include/gdc/nanomap.hpp
// Function: gdc::nanomap<int, myvalue, std::equal_to<int>>::operator[](int const&)
mapped_type& operator[](const key_type& key)
		{
			iterator it = find(key);
			
			if (it == end())
			{
				if (_size >= _capacity)
				{
					throw std::overflow_error("nanomap is full");
				}
				
				size_type i = _size++;
				new (&_keys[i]) key_type(key);
				new (&_values[i]) mapped_type();
				return _values[i];
			}
			
			return _values[it._index];
		}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2975c
movl (%rbx), %eax
cmpq %rbx, (%r15)
sete %dl
movzwl 0x8(%r15), %ecx
cmpw %ax, %cx
sete %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x29887
movl %eax, %eax
movl %eax, %ecx
shrl $0x10, %ecx
movzwl %ax, %edx
cmpl %edx, %ecx
jae 0x2989b
andl $0xffff0000, %eax       # imm = 0xFFFF0000
addl %edx, %eax
addl $0x10000, %eax          # imm = 0x10000
movl %eax, (%rbx)
movq 0x8(%rbx), %rax
shll $0x2, %ecx
movl (%r14), %edx
movl %edx, (%rax,%rcx)
movq 0x10(%rbx), %rdx
leaq (%rdx,%rcx), %rax
movl $0x0, (%rdx,%rcx)
jmp 0x29891
movzwl %cx, %eax
shll $0x2, %eax
addq 0x10(%rbx), %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
pushq $0x10
popq %rdi
callq 0xa1e0
movq %rax, %rbx
leaq 0xbc00(%rip), %rsi      # 0x354ad
movq %rax, %rdi
callq 0xa0a0
movq 0x266bc(%rip), %rsi     # 0x4ff78
movq 0x266a5(%rip), %rdx     # 0x4ff68
movq %rbx, %rdi
callq 0xa650
movq %rax, %r14
movq %rbx, %rdi
callq 0xa2f0
movq %r14, %rdi
callq 0xa690
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-nanomap/include/gdc/nanomap.hpp
// Function: gdc::nanomap<int, myvalue, std::equal_to<int>>::operator[](int&&)
mapped_type& operator[](key_type&& key)
		{
			iterator it = find(key);
			
			if (it == end())
			{
				if (_size >= _capacity)
				{
					throw std::overflow_error("nanomap is full");
				}
				
				size_type i = _size++;
				new (&_keys[i]) key_type(std::move(key));
				new (&_values[i]) mapped_type();
				return _values[i];
			}
			
			return _values[it._index];
		}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2975c
movl (%rbx), %eax
cmpq %rbx, (%r15)
sete %dl
movzwl 0x8(%r15), %ecx
cmpw %ax, %cx
sete %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x29955
movl %eax, %eax
movl %eax, %ecx
shrl $0x10, %ecx
movzwl %ax, %edx
cmpl %edx, %ecx
jae 0x29969
andl $0xffff0000, %eax       # imm = 0xFFFF0000
addl %edx, %eax
addl $0x10000, %eax          # imm = 0x10000
movl %eax, (%rbx)
movq 0x8(%rbx), %rax
shll $0x2, %ecx
movl (%r14), %edx
movl %edx, (%rax,%rcx)
movq 0x10(%rbx), %rdx
leaq (%rdx,%rcx), %rax
movl $0x0, (%rdx,%rcx)
jmp 0x2995f
movzwl %cx, %eax
shll $0x2, %eax
addq 0x10(%rbx), %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
pushq $0x10
popq %rdi
callq 0xa1e0
movq %rax, %rbx
leaq 0xbb32(%rip), %rsi      # 0x354ad
movq %rax, %rdi
callq 0xa0a0
movq 0x265ee(%rip), %rsi     # 0x4ff78
movq 0x265d7(%rip), %rdx     # 0x4ff68
movq %rbx, %rdi
callq 0xa650
movq %rax, %r14
movq %rbx, %rdi
callq 0xa2f0
movq %r14, %rdi
callq 0xa690
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-nanomap/include/gdc/nanomap.hpp
// Function: std::pair<gdc::nanomap_iterator<false, int, myvalue, std::equal_to<int>>, bool> gdc::nanomap<int, myvalue, std::equal_to<int>>::emplace<int>(int const&, int&&)
std::pair<iterator, bool> emplace(const key_type& key, Args&& ... value_args)
		{
			if (_size >= max_size())
			{
				return std::pair<iterator, bool>(end(), false);
			}
			
			new (&_keys[_size]) key_type(key);
			new (&_values[_size]) mapped_type(value_args ...);
			return std::pair<iterator, bool>(iterator(this, _size++), true);
		}

// Assembly:
movq %rdi, %rax
movl (%rsi), %edi
movl %edi, %r8d
shrl $0x10, %r8d
movzwl %di, %r9d
cmpl %r9d, %r8d
jae 0x29a10
movq 0x8(%rsi), %rdi
movl (%rdx), %edx
movl %edx, (%rdi,%r8,4)
movq 0x10(%rsi), %rdx
movzwl 0x2(%rsi), %edi
movl (%rcx), %ecx
movl %ecx, (%rdx,%rdi,4)
movl (%rsi), %ecx
movl %ecx, %edi
shrl $0x10, %edi
andl $0xffff0000, %ecx       # imm = 0xFFFF0000
addl $0x10000, %ecx          # imm = 0x10000
shrl $0x10, %ecx
movw %cx, 0x2(%rsi)
movb $0x1, %cl
jmp 0x29a12
xorl %ecx, %ecx
movq %rsi, (%rax)
movw %di, 0x8(%rax)
movb %cl, 0x10(%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-nanomap/include/gdc/nanomap.hpp
// Function: gdc::nanomap<int, myvalue, std::equal_to<int>>::clear()
void clear()
		{
			for (size_type i = 0; i < _size; ++i)
			{
				_keys[i].~key_type();
			}
			
			for (size_type i = 0; i < _size; ++i)
			{
				_values[i].~mapped_type();
			}
			
			_size = 0;
		}

// Assembly:
movq 0x10(%rdi), %rax
xorl %ecx, %ecx
movl (%rdi), %edx
movl %edx, %esi
shrl $0x10, %esi
cmpl %ecx, %esi
jbe 0x29a59
movl $0x2a, (%rax,%rcx,4)
incq %rcx
jmp 0x29a42
movzwl %dx, %eax
movl %eax, (%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-nanomap/include/gdc/nanomap.hpp
// Function: gdc::nanomap<int, myvalue, std::equal_to<int>>::erase(gdc::nanomap_iterator<true, int, myvalue, std::equal_to<int>>)
iterator erase(const_iterator it)
		{
			if (it._index == max_size())
			{
				std::abort();
			}
			
			_keys[it._index].~key_type();
			_values[it._index].~mapped_type();

			if (it._index < --_size)
			{
				new (&_keys[it._index]) key_type(std::move(_keys[_size]));
				new (&_values[it._index]) mapped_type(std::move(_values[_size]));
				_keys[_size].~key_type();
				_values[_size].~mapped_type();
			}
			else
			{
				it._index = end()._index;
			}

			return iterator(it._map, it._index);
		}

// Assembly:
movzwl 0x8(%rdx), %r8d
cmpw (%rsi), %r8w
je 0x29ad4
movq 0x10(%rsi), %rcx
movl $0x2a, (%rcx,%r8,4)
movl (%rsi), %eax
movl %eax, %r9d
shrl $0x10, %r9d
decl %r9d
movzwl %r9w, %r9d
movw %r9w, 0x2(%rsi)
cmpl %r8d, %r9d
jbe 0x29ac2
movq 0x8(%rsi), %r8
movzwl 0x8(%rdx), %eax
movl %eax, %r10d
shll $0x2, %r10d
movl (%r8,%r9,4), %r9d
movl %r9d, (%r8,%r10)
movzwl 0x2(%rsi), %r8d
movl (%rcx,%r8,4), %r8d
movl %r8d, (%rcx,%r10)
movzwl 0x2(%rsi), %esi
movl $0x2a, (%rcx,%rsi,4)
jmp 0x29ac6
movw %ax, 0x8(%rdx)
movq (%rdx), %rcx
movq %rcx, (%rdi)
movw %ax, 0x8(%rdi)
movq %rdi, %rax
retq
pushq %rax
callq 0xa220
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-nanomap/include/gdc/nanomap.hpp
// Function: gdc::nanomap_factory<int, myvalue, (unsigned short)32, std::equal_to<int>>::nanomap_factory(gdc::nanomap_factory<int, myvalue, (unsigned short)32, std::equal_to<int>> const&)
nanomap_factory(const nanomap_factory& f) : _map(_keys, _values, _capacity, f._map.size())
		{
			for (size_type i = 0; i < _capacity; ++i)
			{
				new (&_keys[i]) key_type(f._keys[i]);
			}
			
			for (size_type i = 0; i < _capacity; ++i)
			{
				new (&_values[i]) mapped_type(f._values[i]);
			}
		}

// Assembly:
leaq 0x18(%rdi), %rcx
leaq 0x98(%rdi), %rax
movzwl 0x2(%rsi), %edx
shll $0x10, %edx
orl $0x20, %edx
movl %edx, (%rdi)
movq %rcx, 0x8(%rdi)
movq %rax, 0x10(%rdi)
xorl %edx, %edx
movl $0x0, (%rax,%rdx)
addq $0x4, %rdx
cmpq $0x80, %rdx
jne 0x29b31
xorl %edx, %edx
cmpq $0x20, %rdx
je 0x29b59
movl 0x18(%rsi,%rdx,4), %edi
movl %edi, (%rcx,%rdx,4)
incq %rdx
jmp 0x29b47
xorl %ecx, %ecx
cmpq $0x20, %rcx
je 0x29b70
movl 0x98(%rsi,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
incq %rcx
jmp 0x29b5b
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-nanomap/include/gdc/nanomap.hpp
// Function: gdc::nanomap_factory<int, myvalue, (unsigned short)32, std::equal_to<int>>::nanomap_factory(gdc::nanomap_factory<int, myvalue, (unsigned short)32, std::equal_to<int>>&&)
nanomap_factory(nanomap_factory&& f) : _map(_keys, _values, _capacity, f._map.size())
		{
			for (size_type i = 0; i < _capacity; ++i)
			{
				new (&_keys[i]) key_type(std::move(f._keys[i]));
			}
			
			for (size_type i = 0; i < _capacity; ++i)
			{
				new (&_values[i]) mapped_type(std::move(f._values[i]));
			}
			
			f._map.clear();
		}

// Assembly:
leaq 0x18(%rdi), %rcx
leaq 0x98(%rdi), %rax
movzwl 0x2(%rsi), %edx
shll $0x10, %edx
orl $0x20, %edx
movl %edx, (%rdi)
movq %rcx, 0x8(%rdi)
movq %rax, 0x10(%rdi)
xorl %ecx, %ecx
movl $0x0, (%rax,%rcx)
addq $0x4, %rcx
cmpq $0x80, %rcx
jne 0x29b93
pushq $0x6
popq %rax
cmpq $0x26, %rax
je 0x29bbb
movl (%rsi,%rax,4), %ecx
movl %ecx, (%rdi,%rax,4)
incq %rax
jmp 0x29baa
pushq $0x26
popq %rax
cmpq $0x46, %rax
je 0x29bcf
movl (%rsi,%rax,4), %ecx
movl %ecx, (%rdi,%rax,4)
incq %rax
jmp 0x29bbe
movq %rsi, %rdi
jmp 0x29a3c
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-nanomap/include/gdc/nanomap.hpp
// Function: gdc::nanomap<int, myvalue, std::equal_to<int>>::_find(int const&) const
const_iterator _find(const key_type& key) const
		{
			key_equal eq;
			
			for (size_type i = 0; i < size(); ++i)
			{
				if (eq(_keys[i], key))
				{
					return const_iterator(this, i);
				}
			}
			
			return cend();
		}

// Assembly:
movq %rdi, %rax
movl (%rsi), %ecx
movl %ecx, %edi
shrl $0x10, %edi
movq 0x8(%rsi), %r8
movl (%rdx), %r9d
xorl %edx, %edx
cmpq %rdx, %rdi
je 0x2a67d
cmpl %r9d, (%r8,%rdx,4)
je 0x2a67f
incq %rdx
jmp 0x2a66d
movl %ecx, %edx
movq %rsi, (%rax)
movw %dx, 0x8(%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/devinsmith[P]qvdreader/LineageInfo.cpp
// Function: QvdLineageInfo::ParseXml(_xmlNode const*)
void QvdLineageInfo::ParseXml(const xmlNode *node)
{
  for (const xmlNode *child = node->children; child; child = child->next) {
    if (child->type == XML_ELEMENT_NODE) {
      xmlChar *nodeContent = xmlNodeGetContent(child);
      if (nodeContent == NULL)
        continue;

      if (strlen((char *)nodeContent) == 0) {
        xmlFree(nodeContent);
        continue;
      }

      if (strcmp((char *)child->name, "Discriminator") == 0) {
        Discriminator = (char *)nodeContent;
      } else if (strcmp((char *)child->name, "Statement") == 0) {
        Statement = (char *)nodeContent;
      } else {
        printf("Unprocessed LineageInfo tag: %s\n", child->name);
      }
      xmlFree(nodeContent);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x18, %rbx
leaq 0x20(%rdi), %rax
movq %rax, (%rsp)
movq 0x6670(%rip), %r13      # 0xbfe0
leaq 0x3689(%rip), %r12      # 0x9000
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x59f1
cmpl $0x1, 0x8(%rbx)
jne 0x59eb
movq %rbx, %rdi
callq 0x54e0
testq %rax, %rax
je 0x59eb
movq %rax, %rbp
cmpb $0x0, (%rax)
je 0x59e4
movq 0x10(%rbx), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x5620
testl %eax, %eax
je 0x59d3
movq %r15, %rdi
leaq 0x3657(%rip), %rsi      # 0x900e
callq 0x5620
testl %eax, %eax
je 0x59d8
leaq 0x3651(%rip), %rdi      # 0x9018
movq %r15, %rsi
xorl %eax, %eax
callq 0x5050
jmp 0x59e4
movq %r14, %rdi
jmp 0x59dc
movq (%rsp), %rdi
movq %rbp, %rsi
callq 0x5820
movq %rbp, %rdi
callq *(%r13)
addq $0x30, %rbx
jmp 0x5977
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/devinsmith[P]qvdreader/main.cpp
// Function: main
int
main(int argc, char *argv[])
{
  if (argc < 2) {
    fprintf(stderr, "usage: %s qvdfile.qvd\n", argv[0]);
    exit(1);
  }

  QvdFile qvd;

  if (!qvd.Load(argv[1])) {
    fprintf(stderr, "The file '%s' could not be loaded.\n", argv[1]);
    exit(1);
  }

  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x2158, %rsp           # imm = 0x2158
movq %rsi, %rbx
cmpl $0x1, %edi
jle 0x5a46
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x5740
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x5280
testb %al, %al
je 0x5a5c
leaq 0x8(%rsp), %rdi
callq 0x52b0
xorl %eax, %eax
addq $0x2158, %rsp           # imm = 0x2158
popq %rbx
popq %r14
retq
movq 0x658b(%rip), %rax      # 0xbfd8
movq (%rax), %rdi
movq (%rbx), %rdx
leaq 0x35df(%rip), %rsi      # 0x9039
jmp 0x5a71
movq 0x6575(%rip), %rax      # 0xbfd8
movq (%rax), %rdi
movq 0x8(%rbx), %rdx
leaq 0x35df(%rip), %rsi      # 0x9050
xorl %eax, %eax
callq 0x5630
pushq $0x1
popq %rdi
callq 0x5550
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x52b0
movq %rbx, %rdi
callq 0x57c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/devinsmith[P]qvdreader/QvdField.cpp
// Function: QvdField::ParseNumberFormat(_xmlNode const*)
void QvdField::ParseNumberFormat(const xmlNode *node)
{
  for (const xmlNode *child = node->children; child; child = child->next) {
    if (child->type == XML_ELEMENT_NODE) {
      xmlChar *nodeContent = xmlNodeGetContent(child);
      if (nodeContent == NULL)
        continue;

      if (strlen((char *)nodeContent) == 0) {
        xmlFree(nodeContent);
        continue;
      }

      if (strcmp((char *)child->name, "Type") == 0) {
        Type = (char *)nodeContent;
      } else if (strcmp((char *)child->name, "Dec") == 0) {
        Dec = (char *)nodeContent;
      } else if (strcmp((char *)child->name, "Thou") == 0) {
        Thou = (char *)nodeContent;
      } else if (strcmp((char *)child->name, "nDec") == 0) {
        nDec = atoi((char *)nodeContent);
      } else if (strcmp((char *)child->name, "UseThou") == 0) {
        UseThou = atoi((char *)nodeContent);
      } else {
        printf("Unprocessed NumberFormat tag: %s\n", child->name);
      }
      xmlFree(nodeContent);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x18, %rbx
leaq 0x78(%rdi), %rax
movq %rax, (%rsp)
leaq 0x58(%rdi), %rax
movq %rax, 0x8(%rsp)
leaq 0x30(%rdi), %rax
movq %rax, 0x10(%rsp)
movq 0x61ab(%rip), %r13      # 0xbfe0
leaq 0x3238(%rip), %rbp      # 0x9074
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x5f27
cmpl $0x1, 0x8(%rbx)
jne 0x5f02
movq %rbx, %rdi
callq 0x54e0
testq %rax, %rax
je 0x5f02
movq %rax, %r12
cmpb $0x0, (%rax)
je 0x5efb
movq 0x10(%rbx), %r15
movq %r15, %rdi
movq %rbp, %rsi
callq 0x5620
testl %eax, %eax
je 0x5ee1
movq %r15, %rdi
leaq 0x31ee(%rip), %rsi      # 0x907a
callq 0x5620
testl %eax, %eax
je 0x5ee8
movq %r15, %rdi
leaq 0x31e2(%rip), %rsi      # 0x9081
callq 0x5620
testl %eax, %eax
je 0x5eef
movq %r15, %rdi
leaq 0x31c7(%rip), %rsi      # 0x9079
callq 0x5620
testl %eax, %eax
je 0x5f0b
movq %r15, %rdi
leaq 0x31b9(%rip), %rsi      # 0x907e
callq 0x5620
testl %eax, %eax
je 0x5f19
leaq 0x31b1(%rip), %rdi      # 0x9086
movq %r15, %rsi
xorl %eax, %eax
callq 0x5050
jmp 0x5efb
movq 0x10(%rsp), %rdi
jmp 0x5ef3
movq 0x8(%rsp), %rdi
jmp 0x5ef3
movq (%rsp), %rdi
movq %r12, %rsi
callq 0x5820
movq %r12, %rdi
callq *(%r13)
addq $0x30, %rbx
jmp 0x5e3c
movq %r12, %rdi
callq 0x56b0
movl %eax, 0x50(%r14)
jmp 0x5efb
movq %r12, %rdi
callq 0x56b0
movl %eax, 0x54(%r14)
jmp 0x5efb
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/devinsmith[P]qvdreader/QvdFile.cpp
// Function: QvdFile::Load(char const*)
bool QvdFile::Load(const char *filename)
{
  _fp = fopen(filename, "rb");
  if (_fp == NULL) {
    return false;
  }

  if (!parseXmlHeader(filename)) {
    return false;
  }

  if (_eof && _bufLen == 0) {
    // XML header parsed but missing symbol table and data.
    return false;
  }

  // The start of the dataPtr might have the ending \r and \n from
  // the XML portion, if so skip past that.
  char c;
  while (_bufLen > 0) {
    c = peekByte();
    if (c == '\r' || c == '\n' || c == '\0') {
      advanceBytes(1);
      continue;
    }
    break;
  }

  if (_eof && _bufLen == 0) {
    // XML header parsed but missing symbol table and data.
    return false;
  }

  DEBUG(fprintf(stdout, "%zu bytes left\n", _bufLen););

  parseSymbolAndData();

  // First 2 bytes seem to store a type:
  // 00 01 - INT
  // 00 04 - Text
  // 00 05 - Dual INT


  //dump_hex(0, _dataPtrStart, _bufLen);

  // Read rest of file.
  while (!_eof) {
    size_t len = readBytes();

    DEBUG(printf("Read %zu bytes.\n", len););
  }

  fclose(_fp);

  return true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x2eb3(%rip), %rsi      # 0x9138
movq %r14, %rdi
callq 0x5540
movq %rax, 0x128(%rbx)
testq %rax, %rax
je 0x630f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5160
testb %al, %al
je 0x630f
movq 0x2138(%rbx), %rax
testq %rax, %rax
sete %cl
testb %cl, 0x2140(%rbx)
jne 0x630f
movl $0x2401, %ebp           # imm = 0x2401
pushq $0x1
popq %r14
testq %rax, %rax
je 0x62f3
movq %rbx, %rdi
callq 0x5430
cmpb $0xd, %al
ja 0x62f7
movzbl %al, %eax
btl %eax, %ebp
jae 0x62f7
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5860
movq 0x2138(%rbx), %rax
jmp 0x62c6
movb $0x1, %al
jmp 0x6302
cmpq $0x0, 0x2138(%rbx)
sete %al
cmpb $0x1, 0x2140(%rbx)
jne 0x6316
testb %al, %al
je 0x6316
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
callq 0x5660
cmpb $0x0, 0x2140(%rbx)
jne 0x6331
movq %rbx, %rdi
callq 0x5830
jmp 0x631e
movq 0x128(%rbx), %rdi
callq 0x5460
movb $0x1, %al
jmp 0x6311
nop
// File: /workspace/github_cpp_makefile_star2_O2/devinsmith[P]qvdreader/QvdFile.cpp
// Function: QvdFile::advanceBytes(unsigned long)
void QvdFile::advanceBytes(size_t nBytes)
{
  if (_bufLen < nBytes) {
    if (!_eof) {
      readBytes();
    } else {
      return; // throw an error.
    }
  }

  if (_bufLen < nBytes) {
    return; // throw an error.
  }

  _bufLen -= nBytes;
  _dataPtrStart += nBytes;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2138(%rdi), %rax
cmpq %rsi, %rax
jae 0x64c1
cmpb $0x0, 0x2140(%r14)
jne 0x64d4
movq %r14, %rdi
callq 0x5830
movq 0x2138(%r14), %rax
subq %rbx, %rax
jb 0x64d4
movq %rax, 0x2138(%r14)
addq %rbx, 0x2130(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/devinsmith[P]qvdreader/QvdFile.cpp
// Function: QvdFile::readBytes()
size_t QvdFile::readBytes()
{
  size_t len = fread(_buf, 1, sizeof(_buf), _fp);
  if (len < sizeof(_buf)) {
    _eof = true;
  }
  _dataPtrStart = _buf;
  _bufLen = len;
  return len;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x130(%rdi), %r14
movq 0x128(%rdi), %rcx
pushq $0x1
popq %rsi
movl $0x2000, %edx           # imm = 0x2000
movq %r14, %rdi
callq 0x5670
cmpq $0x1fff, %rax           # imm = 0x1FFF
ja 0x670a
movb $0x1, 0x2140(%rbx)
movq %r14, 0x2130(%rbx)
movq %rax, 0x2138(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/devinsmith[P]qvdreader/QvdFile.cpp
// Function: QvdFile::readByte()
char QvdFile::readByte()
{
  char c;

  if (_bufLen == 0) {
    if (!_eof) {
      readBytes();
    } else {
      return 0; // throw an error.
    }
  }

  _bufLen--;
  c = *_dataPtrStart++;

  return c;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x2138(%rdi), %rax
testq %rax, %rax
jne 0x674c
cmpb $0x0, 0x2140(%rbx)
je 0x673d
xorl %eax, %eax
jmp 0x676a
movq %rbx, %rdi
callq 0x5830
movq 0x2138(%rbx), %rax
decq %rax
movq %rax, 0x2138(%rbx)
movq 0x2130(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x2130(%rbx)
movb (%rax), %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/devinsmith[P]qvdreader/QvdFile.cpp
// Function: QvdFile::readInt32()
int QvdFile::readInt32()
{
  return static_cast<int>(static_cast<unsigned char>(readByte())       |
                          static_cast<unsigned char>(readByte()) <<  8 |
                          static_cast<unsigned char>(readByte()) << 16 |
                          static_cast<unsigned char>(readByte()) << 24);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x53b0
movzbl %al, %ebp
movq %rbx, %rdi
callq 0x53b0
movzbl %al, %r14d
shll $0x8, %r14d
orl %ebp, %r14d
movq %rbx, %rdi
callq 0x53b0
movzbl %al, %ebp
shll $0x10, %ebp
orl %r14d, %ebp
movq %rbx, %rdi
callq 0x53b0
movzbl %al, %eax
shll $0x18, %eax
orl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/devinsmith[P]qvdreader/QvdFile.cpp
// Function: QvdFile::readDouble()
double QvdFile::readDouble()
{
  double d;
  unsigned char c[8];

  for (int i=0; i<8; i++) {
    c[i] = static_cast<unsigned char>(readByte());
  }
  d = *reinterpret_cast<double*>(c);
  return d;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
cmpq $0x8, %r14
je 0x67d5
movq %rbx, %rdi
callq 0x53b0
movb %al, (%rsp,%r14)
incq %r14
jmp 0x67be
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/devinsmith[P]qvdreader/QvdFile.cpp
// Function: QvdFile::get_bits_index(unsigned long)
int QvdFile::get_bits_index(size_t nBits)
{
  int i = 0;

  while (nBits > _bitBufferSz) {
    unsigned int byte = (unsigned char)readByte();
    //DEBUG(printf("Requesting %zu bits, but only have %d bits\n", nBits, _bitBufferSz););
    //DEBUG(printf("Read byte 0x%02x\n", byte););
    byte = byte << _bitBufferSz;
    _bitBufferSz += 8;
    _bitBuffer += byte;
  }
  //DEBUG(printf("_bitBufferSz: %d\n", _bitBufferSz););
  int mask = ((1 << nBits) - 1);
  i = (_bitBuffer) & mask;
  _bitBuffer = _bitBuffer >> nBits;
  _bitBufferSz -= nBits;

  return i;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x2148(%rdi), %edx
movl %edx, %eax
cmpq %r14, %rax
jae 0x681f
movq %rbx, %rdi
callq 0x53b0
movzbl %al, %eax
movl 0x2148(%rbx), %edx
movl %edx, %ecx
shll %cl, %eax
addl $0x8, %edx
movl %edx, 0x2148(%rbx)
addl %eax, 0x2144(%rbx)
jmp 0x67f2
pushq $-0x1
popq %rax
movl %r14d, %ecx
shll %cl, %eax
notl %eax
movl 0x2144(%rbx), %esi
andl %esi, %eax
shrl %cl, %esi
movl %esi, 0x2144(%rbx)
subl %r14d, %edx
movl %edx, 0x2148(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/devinsmith[P]qvdreader/QvdTableHeader.cpp
// Function: QvdTableHeader::ParseFields(_xmlNode const*)
void QvdTableHeader::ParseFields(const xmlNode *node)
{
  for (const xmlNode *child = node->children; child; child = child->next) {
    if (child->type == XML_ELEMENT_NODE) {
      xmlChar *nodeContent = xmlNodeGetContent(child);
      if (nodeContent == NULL)
        continue;

      if (strlen((char *)nodeContent) == 0) {
        xmlFree(nodeContent);
        continue;
      }

      if (strcmp((char *)child->name, "QvdFieldHeader") == 0) {
        QvdField field;
        field.ParseXml(child);

        Fields.push_back(field);
      } else {
        printf("Unprocessed Fields tag: %s\n", child->name);
      }
      xmlFree(nodeContent);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %rbx
addq $0x18, %rbx
addq $0x98, %rdi
movq %rdi, (%rsp)
movq 0x4b72(%rip), %r15      # 0xbfe0
xorl %r12d, %r12d
leaq 0x8(%rsp), %r14
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x7598
cmpl $0x1, 0x8(%rbx)
jne 0x758f
movq %rbx, %rdi
callq 0x54e0
testq %rax, %rax
je 0x758f
movq %rax, %rbp
cmpb $0x0, (%rax)
je 0x7589
movq 0x10(%rbx), %r13
movq %r13, %rdi
leaq 0x1d09(%rip), %rsi      # 0x91c0
callq 0x5620
testl %eax, %eax
je 0x74d6
leaq 0x1d08(%rip), %rdi      # 0x91cf
movq %r13, %rsi
xorl %eax, %eax
callq 0x5050
jmp 0x7589
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movb %r12b, 0x18(%rsp)
andq $0x0, 0x28(%rsp)
andl $0x0, 0x30(%rsp)
leaq 0x48(%rsp), %rcx
movq %rcx, 0x38(%rsp)
andq $0x0, 0x40(%rsp)
movb %r12b, 0x48(%rsp)
andq $0x0, 0x58(%rsp)
leaq 0x70(%rsp), %rcx
movq %rcx, 0x60(%rsp)
andq $0x0, 0x68(%rsp)
movb %r12b, 0x70(%rsp)
leaq 0x90(%rsp), %rcx
movq %rcx, 0x80(%rsp)
andq $0x0, 0x88(%rsp)
movb %r12b, 0x90(%rsp)
andq $0x0, 0xa0(%rsp)
andl $0x0, 0xa8(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x98(%rax)
andq $0x0, 0xa8(%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5210
movq (%rsp), %rdi
movq %r14, %rsi
callq 0x5140
movq %r14, %rdi
callq 0x50d0
movq %rbp, %rdi
callq *(%r15)
addq $0x30, %rbx
jmp 0x7476
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x50d0
movq %rbx, %rdi
callq 0x57c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/devinsmith[P]qvdreader/QvdTableHeader.cpp
// Function: QvdTableHeader::ParseLineage(_xmlNode const*)
void QvdTableHeader::ParseLineage(const xmlNode *node)
{
  for (const xmlNode *child = node->children; child; child = child->next) {
    if (child->type == XML_ELEMENT_NODE) {
      xmlChar *nodeContent = xmlNodeGetContent(child);
      if (nodeContent == NULL)
        continue;

      if (strlen((char *)nodeContent) == 0) {
        xmlFree(nodeContent);
        continue;
      }

      if (strcmp((char *)child->name, "LineageInfo") == 0) {
        QvdLineageInfo lin;
        lin.ParseXml(child);

        Lineages.push_back(lin);
      } else {
        printf("Unprocessed Lineage tag: %s\n", child->name);
      }
      xmlFree(nodeContent);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x18, %rbx
addq $0xb0, %r14
movq 0x49fa(%rip), %r15      # 0xbfe0
leaq 0x8(%rsp), %r12
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x769b
cmpl $0x1, 0x8(%rbx)
jne 0x7692
movq %rbx, %rdi
callq 0x54e0
testq %rax, %rax
je 0x7692
movq %rax, %rbp
cmpb $0x0, (%rax)
je 0x768c
movq 0x10(%rbx), %r13
movq %r13, %rdi
leaq 0x1bc3(%rip), %rsi      # 0x91eb
callq 0x5620
testl %eax, %eax
je 0x7644
leaq 0x1bbf(%rip), %rdi      # 0x91f7
movq %r13, %rsi
xorl %eax, %eax
callq 0x5050
jmp 0x768c
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
xorl %ecx, %ecx
movb %cl, 0x18(%rsp)
leaq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
andq $0x0, 0x30(%rsp)
movb %cl, 0x38(%rsp)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x5100
movq %r14, %rdi
movq %r12, %rsi
callq 0x5490
movq %r12, %rdi
callq 0x5870
movq %rbp, %rdi
callq *(%r15)
addq $0x30, %rbx
jmp 0x75eb
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5870
movq %rbx, %rdi
callq 0x57c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/devinsmith[P]qvdreader/utils/conversions.cpp
// Function: utils::mem_to_uint(char const*, unsigned long)
unsigned int mem_to_uint(const char *buf, size_t len)
{
  unsigned int n = 0;

  while (len--) {
    n = n * 10 + *buf++ - '0';
  }

  return n;
}

// Assembly:
xorl %ecx, %ecx
xorl %eax, %eax
cmpq %rcx, %rsi
je 0x7f6e
imull $0xa, %eax, %eax
movsbl (%rdi,%rcx), %edx
addl %edx, %eax
addl $-0x30, %eax
incq %rcx
jmp 0x7f58
retq
// File: /workspace/github_cpp_makefile_star2_O2/devinsmith[P]qvdreader/utils/conversions.cpp
// Function: utils::mem_to_int(char const*, unsigned long)
int mem_to_int(const char *buf, size_t len)
{
  bool neg = false;
  int n = 0;

  if (*buf == '-')
    neg = true;

  while (len--) {
    n = n * 10 + *buf++ - '0';
  }

  return neg ? -n : n;
}

// Assembly:
movb (%rdi), %cl
xorl %eax, %eax
xorl %edx, %edx
cmpq %rax, %rsi
je 0x7f8d
imull $0xa, %edx, %edx
movsbl (%rdi,%rax), %r8d
addl %r8d, %edx
addl $-0x30, %edx
incq %rax
jmp 0x7f75
movl %edx, %eax
negl %eax
cmpb $0x2d, %cl
cmovnel %edx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/devinsmith[P]qvdreader/utils/dumphex.cpp
// Function: dump_hex(int, void*, unsigned long)
void
dump_hex(int lvl, void *vp, size_t len)
{
	char linebuf[80];
	size_t i;
	int linebuf_dirty = 0;
	unsigned char *p = (unsigned char *)vp;

	memset(linebuf, ' ', sizeof(linebuf));
	linebuf[70] = '\0';

	for (i = 0; i < len; i++) {
		int x = i % 16;
		int ch = (unsigned)p[i];
		char hex[20];

		if (x >= 8)
			x = x * 3 + 1;
		else
			x = x * 3;
		snprintf(hex, sizeof(hex), "%02x", ch);
		linebuf[x] = hex[0];
		linebuf[x + 1] = hex[1];

		if (isprint(ch))
			linebuf[52 + (i % 16)] = ch;
		else
			linebuf[52 + (i % 16)] = '.';

		linebuf_dirty = 1;
		if (!((i + 1) % 16)) {
			fprintf(stderr, "%s\n", linebuf);
			memset(linebuf, ' ', sizeof(linebuf));
			linebuf[70] = '\0';
			linebuf_dirty = 0;
		}
	}
	if (linebuf_dirty == 1)
		fprintf(stderr, "%s\n", linebuf);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movaps 0x12ed(%rip), %xmm0     # 0x92a0
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movb $0x0, 0x46(%rsp)
xorl %r15d, %r15d
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0x8087
movl %r13d, %r12d
andl $0xf, %r12d
movzbl (%r14,%r13), %r15d
cmpq $0x8, %r12
leal (%r12,%r12,2), %ebp
sbbq $-0x1, %rbp
leaq 0x50(%rsp), %rdi
pushq $0x14
popq %rsi
leaq 0x12aa(%rip), %rdx      # 0x92b0
movl %r15d, %ecx
xorl %eax, %eax
callq 0x56f0
movzwl 0x50(%rsp), %eax
movw %ax, (%rsp,%rbp)
movl %r15d, %edi
callq 0x57d0
pushq $0x2e
popq %rcx
testl %eax, %eax
je 0x802b
movl %r15d, %ecx
movq %rsp, %rax
movb %cl, 0x34(%r12,%rax)
incq %r13
pushq $0x1
popq %r15
testb $0xf, %r13b
jne 0x7fd6
movq 0x3f91(%rip), %rax      # 0xbfd8
movq (%rax), %rdi
xorl %r15d, %r15d
leaq 0x11bc(%rip), %rsi      # 0x9210
movq %rsp, %rdx
xorl %eax, %eax
callq 0x5630
movaps 0x123b(%rip), %xmm0     # 0x92a0
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, (%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x30(%rsp)
movb $0x0, 0x46(%rsp)
jmp 0x7fd6
cmpl $0x1, %r15d
je 0x809c
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x3f35(%rip), %rax      # 0xbfd8
movq (%rax), %rdi
leaq 0x1163(%rip), %rsi      # 0x9210
movq %rsp, %rdx
xorl %eax, %eax
callq 0x5630
jmp 0x808d
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/test-1.c
// Function: test_int
uint32_t test_int(uint32_t n, uint32_t x0)
{
	uint32_t i, x, z = 0;
	tommy_allocator alloc;
	tommy_trie h;
	 tommy_allocator_init(&alloc, TOMMY_TRIE_BLOCK_SIZE, TOMMY_TRIE_BLOCK_SIZE);
	tommy_trie_init(&h, &alloc);
	for (i = 0, x = x0; i < n; ++i) {
		uint32_t key;
		intcell_t *p;
		x = hash32(x);
		key = get_key(n, x);
		p = tommy_trie_search(&h, key);
		if (!p) {
			p = malloc(sizeof(intcell_t));
			p->key = key, p->cnt = 1;
			tommy_trie_insert(&h, &p->node, p, p->key);
			++z;
		} else z += ++p->cnt;
	}
	fprintf(stderr, "# unique keys: %d; checksum: %u\n", tommy_trie_count(&h), z);
	x = tommy_trie_count(&h);
	tommy_allocator_done(&alloc);
	return x;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movl %esi, %ebp
movl %edi, %r12d
movq %rsp, %r14
pushq $0x40
popq %rdx
movq %r14, %rdi
movq %rdx, %rsi
callq 0x192a
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x21c0
xorl %r14d, %r14d
movl %r12d, %ebx
subl $0x1, %ebx
jb 0x1521
movl %ebp, %edi
callq 0x120c
movl %eax, %ebp
movl %r12d, %edi
movl %eax, %esi
callq 0x1237
movl %eax, %r13d
movq %r15, %rdi
movl %eax, %esi
callq 0x2469
testq %rax, %rax
je 0x14f5
movq 0x10(%rax), %rcx
testq %rcx, %rcx
je 0x14f5
movl 0x4(%rcx), %eax
incl %eax
movl %eax, 0x4(%rcx)
jmp 0x151c
pushq $0x28
popq %rdi
callq 0x1080
movl %r13d, (%rax)
movl $0x1, 0x4(%rax)
leaq 0x8(%rax), %rsi
movq %r15, %rdi
movq %rax, %rdx
movl %r13d, %ecx
callq 0x21e2
pushq $0x1
popq %rax
addl %eax, %r14d
jmp 0x14b8
movq 0x5ad0(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
movl 0x128(%rsp), %edx
leaq 0x2b3c(%rip), %rsi      # 0x4075
movl %r14d, %ecx
xorl %eax, %eax
callq 0x1070
movl 0x128(%rsp), %ebx
movq %rsp, %rdi
callq 0x1960
movl %ebx, %eax
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommyhash.c
// Function: tommy_hash_u32
tommy_uint32_t tommy_hash_u32(tommy_uint32_t init_val, const void* void_key, tommy_size_t key_len)
{
	const unsigned char* key = tommy_cast(const unsigned char*, void_key);
	tommy_uint32_t a, b, c;

	a = b = c = 0xdeadbeef + ((tommy_uint32_t)key_len) + init_val;

	while (key_len > 12) {
		a += tommy_le_uint32_read(key + 0);
		b += tommy_le_uint32_read(key + 4);
		c += tommy_le_uint32_read(key + 8);

		tommy_mix(a, b, c);

		key_len -= 12;
		key += 12;
	}

	switch (key_len) {
	case 0 :
		return c; /* used only when called with a zero length */
	case 12 :
		c += tommy_le_uint32_read(key + 8);
		b += tommy_le_uint32_read(key + 4);
		a += tommy_le_uint32_read(key + 0);
		break;
	case 11 : c += ((tommy_uint32_t)key[10]) << 16;
	case 10 : c += ((tommy_uint32_t)key[9]) << 8;
	case 9 : c += key[8];
	case 8 :
		b += tommy_le_uint32_read(key + 4);
		a += tommy_le_uint32_read(key + 0);
		break;
	case 7 : b += ((tommy_uint32_t)key[6]) << 16;
	case 6 : b += ((tommy_uint32_t)key[5]) << 8;
	case 5 : b += key[4];
	case 4 :
		a += tommy_le_uint32_read(key + 0);
		break;
	case 3 : a += ((tommy_uint32_t)key[2]) << 16;
	case 2 : a += ((tommy_uint32_t)key[1]) << 8;
	case 1 : a += key[0];
	}

	tommy_final(a, b, c);

	return c;
}

// Assembly:
addl %edx, %edi
addl $0xdeadbeef, %edi       # imm = 0xDEADBEEF
movl %edi, %ecx
movl %edi, %eax
cmpq $0xd, %rdx
jb 0x15e4
addl (%rsi), %edi
addl 0x4(%rsi), %ecx
addl 0x8(%rsi), %eax
subl %eax, %edi
movl %eax, %r8d
roll $0x4, %r8d
xorl %edi, %r8d
addl %ecx, %eax
subl %r8d, %ecx
movl %r8d, %r9d
roll $0x6, %r9d
xorl %ecx, %r9d
addl %eax, %r8d
subl %r9d, %eax
movl %r9d, %r10d
roll $0x8, %r10d
xorl %eax, %r10d
addl %r8d, %r9d
subl %r10d, %r8d
movl %r10d, %edi
roll $0x10, %edi
xorl %r8d, %edi
addl %r9d, %r10d
subl %edi, %r9d
movl %edi, %ecx
roll $0x13, %ecx
xorl %r9d, %ecx
addl %r10d, %edi
subl %ecx, %r10d
movl %ecx, %eax
roll $0x4, %eax
xorl %r10d, %eax
addl %edi, %ecx
addq $-0xc, %rdx
addq $0xc, %rsi
jmp 0x1574
leaq 0x2aad(%rip), %r8       # 0x4098
movslq (%r8,%rdx,4), %rdx
addq %r8, %rdx
jmpq *%rdx
movzbl 0x2(%rsi), %edx
shll $0x10, %edx
addl %edx, %edi
movzbl 0x1(%rsi), %edx
shll $0x8, %edx
addl %edx, %edi
movzbl (%rsi), %edx
addl %edx, %edi
jmp 0x1649
movzbl 0xa(%rsi), %edx
shll $0x10, %edx
addl %edx, %eax
movzbl 0x9(%rsi), %edx
shll $0x8, %edx
addl %edx, %eax
movzbl 0x8(%rsi), %edx
addl %edx, %eax
jmp 0x162a
addl 0x8(%rsi), %eax
addl 0x4(%rsi), %ecx
jmp 0x1647
movzbl 0x6(%rsi), %edx
shll $0x10, %edx
addl %edx, %ecx
movzbl 0x5(%rsi), %edx
shll $0x8, %edx
addl %edx, %ecx
movzbl 0x4(%rsi), %edx
addl %edx, %ecx
addl (%rsi), %edi
xorl %ecx, %eax
movl %ecx, %edx
roll $0xe, %edx
subl %edx, %eax
xorl %eax, %edi
movl %eax, %edx
roll $0xb, %edx
subl %edx, %edi
movl %edi, %edx
roll $0x19, %edx
xorl %edi, %ecx
subl %edx, %ecx
xorl %ecx, %eax
movl %ecx, %edx
roll $0x10, %edx
subl %edx, %eax
xorl %eax, %edi
movl %eax, %edx
roll $0x4, %edx
subl %edx, %edi
xorl %edi, %ecx
roll $0xe, %edi
subl %edi, %ecx
xorl %ecx, %eax
roll $0x18, %ecx
subl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommyalloc.c
// Function: tommy_allocator_init
void tommy_allocator_init(tommy_allocator* alloc, tommy_size_t block_size, tommy_size_t align_size)
{
	/* setup the minimal alignment */
	if (align_size < sizeof(void*))
		align_size = sizeof(void*);

	/* ensure that the block_size keeps the alignment */
	if (block_size % align_size != 0)
		block_size += align_size - block_size % align_size;

	alloc->block_size = block_size;
	alloc->align_size = align_size;

	alloc->count = 0;
	alloc->free_block = 0;
	alloc->used_segment = 0;
}

// Assembly:
cmpq $0x9, %rdx
pushq $0x8
popq %rcx
cmovaeq %rdx, %rcx
movq %rsi, %rax
xorl %edx, %edx
divq %rcx
movq %rcx, %rax
subq %rdx, %rax
testq %rdx, %rdx
cmoveq %rdx, %rax
addq %rsi, %rax
movq %rax, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
andl $0x0, 0x20(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommyarray.c
// Function: tommy_array_init
void tommy_array_init(tommy_array* array)
{
	tommy_uint_t i;

	/* fixed initial size */
	array->bucket_bit = TOMMY_ARRAY_BIT;
	array->bucket_max = 1 << array->bucket_bit;
	array->bucket[0] = tommy_cast(void**, tommy_calloc(array->bucket_max, sizeof(void*)));
	for (i = 1; i < TOMMY_ARRAY_BIT; ++i)
		array->bucket[i] = array->bucket[0];

	array->count = 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movabsq $0x4000000006, %rax     # imm = 0x4000000006
movq %rax, 0x100(%rdi)
pushq $0x40
popq %rdi
pushq $0x8
popq %rsi
callq 0x1060
movq %rax, (%rbx)
pushq $0x1
popq %rcx
cmpq $0x6, %rcx
je 0x1a71
movq %rax, (%rbx,%rcx,8)
incq %rcx
jmp 0x1a62
andl $0x0, 0x108(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommyarray.c
// Function: tommy_array_done
void tommy_array_done(tommy_array* array)
{
	tommy_uint_t i;

	tommy_free(array->bucket[0]);
	for (i = TOMMY_ARRAY_BIT; i < array->bucket_bit; ++i) {
		void** segment = array->bucket[i];
		tommy_free(&segment[((tommy_ptrdiff_t)1) << i]);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x1030
pushq $0x6
popq %r14
pushq $0x1
popq %r15
movl 0x100(%rbx), %eax
cmpq %rax, %r14
jae 0x1ab8
movq %r15, %rdi
movl %r14d, %ecx
shlq %cl, %rdi
shlq $0x3, %rdi
addq (%rbx,%r14,8), %rdi
callq 0x1030
incq %r14
jmp 0x1a92
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommyarray.c
// Function: tommy_array_grow
void tommy_array_grow(tommy_array* array, tommy_count_t count)
{
	if (array->count >= count)
		return;
	array->count = count;

	while (count > array->bucket_max) {
		void** segment;

		/* allocate one more segment */
		segment = tommy_cast(void**, tommy_calloc(array->bucket_max, sizeof(void*)));

		/* store it adjusting the offset */
		/* cast to ptrdiff_t to ensure to get a negative value */
		array->bucket[array->bucket_bit] = &segment[-(tommy_ptrdiff_t)array->bucket_max];

		++array->bucket_bit;
		array->bucket_max = 1 << array->bucket_bit;
	}
}

// Assembly:
cmpl %esi, 0x108(%rdi)
jae 0x1b28
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %esi, 0x108(%rdi)
movl 0x104(%rdi), %eax
pushq $0x8
popq %r15
pushq $0x1
popq %rbp
cmpl %ebx, %eax
jae 0x1b20
movl %eax, %r12d
movq %r12, %rdi
movq %r15, %rsi
callq 0x1060
shlq $0x3, %r12
subq %r12, %rax
movl 0x100(%r14), %ecx
movq %rax, (%r14,%rcx,8)
incl %ecx
movl %ecx, 0x100(%r14)
movl %ebp, %eax
shll %cl, %eax
movl %eax, 0x104(%r14)
jmp 0x1ae6
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommyarrayof.c
// Function: tommy_arrayof_init
void tommy_arrayof_init(tommy_arrayof* array, tommy_size_t element_size)
{
	tommy_uint_t i;

	/* fixed initial size */
	array->element_size = element_size;
	array->bucket_bit = TOMMY_ARRAYOF_BIT;
	array->bucket_max = 1 << array->bucket_bit;
	array->bucket[0] = tommy_calloc(array->bucket_max, array->element_size);
	for (i = 1; i < TOMMY_ARRAYOF_BIT; ++i)
		array->bucket[i] = array->bucket[0];

	array->count = 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq %rsi, 0x100(%rdi)
movabsq $0x4000000006, %rax     # imm = 0x4000000006
movq %rax, 0x108(%rdi)
pushq $0x40
popq %rdi
callq 0x1060
movq %rax, (%rbx)
pushq $0x1
popq %rcx
cmpq $0x6, %rcx
je 0x1b6d
movq %rax, (%rbx,%rcx,8)
incq %rcx
jmp 0x1b5e
andl $0x0, 0x110(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommyarrayof.c
// Function: tommy_arrayof_done
void tommy_arrayof_done(tommy_arrayof* array)
{
	tommy_uint_t i;

	tommy_free(array->bucket[0]);
	for (i = TOMMY_ARRAYOF_BIT; i < array->bucket_bit; ++i) {
		unsigned char* segment = tommy_cast(unsigned char*, array->bucket[i]);
		tommy_free(segment + (((tommy_ptrdiff_t)1) << i) * array->element_size);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x1030
pushq $0x6
popq %r14
movl 0x108(%rbx), %eax
cmpq %rax, %r14
jae 0x1baf
movq 0x100(%rbx), %rdi
movl %r14d, %ecx
shlq %cl, %rdi
addq (%rbx,%r14,8), %rdi
callq 0x1030
incq %r14
jmp 0x1b89
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommyarrayof.c
// Function: tommy_arrayof_grow
void tommy_arrayof_grow(tommy_arrayof* array, tommy_count_t count)
{
	if (array->count >= count)
		return;
	array->count = count;

	while (count > array->bucket_max) {
		unsigned char* segment;

		/* allocate one more segment */
		segment = tommy_cast(unsigned char*, tommy_calloc(array->bucket_max, array->element_size));

		/* store it adjusting the offset */
		/* cast to ptrdiff_t to ensure to get a negative value */
		array->bucket[array->bucket_bit] = segment - (tommy_ptrdiff_t)array->bucket_max * array->element_size;

		++array->bucket_bit;
		array->bucket_max = 1 << array->bucket_bit;
	}
}

// Assembly:
cmpl %esi, 0x110(%rdi)
jae 0x1c24
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %esi, 0x110(%rdi)
movl 0x10c(%rdi), %eax
pushq $0x1
popq %rbp
cmpl %ebx, %eax
jae 0x1c1c
movl %eax, %r15d
movq 0x100(%r14), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x1060
imulq %r15, %r12
subq %r12, %rax
movl 0x108(%r14), %ecx
movq %rax, (%r14,%rcx,8)
incl %ecx
movl %ecx, 0x108(%r14)
movl %ebp, %eax
shll %cl, %eax
movl %eax, 0x10c(%r14)
jmp 0x1bdb
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommyarrayblk.c
// Function: tommy_arrayblk_done
void tommy_arrayblk_done(tommy_arrayblk* array)
{
	tommy_count_t i;

	for (i = 0; i < tommy_array_size(&array->block); ++i)
		tommy_free(tommy_array_get(&array->block, i));

	tommy_array_done(&array->block);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %ebp, %ebp
cmpl 0x108(%rbx), %ebp
jae 0x1c6c
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1c7a
movq %rax, %rdi
callq 0x1030
incl %ebp
jmp 0x1c4e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1a7a
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommyarrayblk.c
// Function: tommy_arrayblk_grow
void tommy_arrayblk_grow(tommy_arrayblk* array, tommy_count_t count)
{
	tommy_count_t block_max;
	tommy_count_t block_mac;

	if (array->count >= count)
		return;
	array->count = count;

	block_max = (count + TOMMY_ARRAYBLK_SIZE - 1) / TOMMY_ARRAYBLK_SIZE;
	block_mac = tommy_array_size(&array->block);

	if (block_mac < block_max) {
		/* grow the block array */
		tommy_array_grow(&array->block, block_max);

		/* allocate new blocks */
		while (block_mac < block_max) {
			void** ptr = tommy_cast(void**, tommy_calloc(TOMMY_ARRAYBLK_SIZE, sizeof(void*)));

			/* set the new block */
			tommy_array_set(&array->block, block_mac, ptr);

			++block_mac;
		}
	}
}

// Assembly:
cmpl %esi, 0x110(%rdi)
jae 0x1cee
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %esi, 0x110(%rdi)
addl $0xfff, %ebx            # imm = 0xFFF
shrl $0xc, %ebx
movl 0x108(%rdi), %ebp
cmpl %ebx, %ebp
jae 0x1ce6
movq %r14, %rdi
movl %ebx, %esi
callq 0x1abe
pushq $0x8
popq %r15
cmpl %ebp, %ebx
je 0x1ce6
movl $0x1000, %edi           # imm = 0x1000
movq %r15, %rsi
callq 0x1060
movq %rax, %r12
movq %r14, %rdi
movl %ebp, %esi
callq 0x2f78
movq %r12, (%rax)
incl %ebp
jmp 0x1cc1
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommyarrayblkof.c
// Function: tommy_arrayblkof_done
void tommy_arrayblkof_done(tommy_arrayblkof* array)
{
	tommy_count_t i;

	for (i = 0; i < tommy_array_size(&array->block); ++i)
		tommy_free(tommy_array_get(&array->block, i));

	tommy_array_done(&array->block);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %ebp, %ebp
cmpl 0x108(%rbx), %ebp
jae 0x1d52
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1c7a
movq %rax, %rdi
callq 0x1030
incl %ebp
jmp 0x1d34
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1a7a
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommyarrayblkof.c
// Function: tommy_arrayblkof_grow
void tommy_arrayblkof_grow(tommy_arrayblkof* array, tommy_count_t count)
{
	tommy_count_t block_max;
	tommy_count_t block_mac;

	if (array->count >= count)
		return;
	array->count = count;

	block_max = (count + TOMMY_ARRAYBLKOF_SIZE - 1) / TOMMY_ARRAYBLKOF_SIZE;
	block_mac = tommy_array_size(&array->block);

	if (block_mac < block_max) {
		/* grow the block array */
		tommy_array_grow(&array->block, block_max);

		/* allocate new blocks */
		while (block_mac < block_max) {
			void** ptr = tommy_cast(void**, tommy_calloc(TOMMY_ARRAYBLKOF_SIZE, array->element_size));

			/* set the new block */
			tommy_array_set(&array->block, block_mac, ptr);

			++block_mac;
		}
	}
}

// Assembly:
cmpl %esi, 0x118(%rdi)
jae 0x1dca
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl %esi, 0x118(%rdi)
addl $0xfff, %ebx            # imm = 0xFFF
shrl $0xc, %ebx
movl 0x108(%rdi), %ebp
cmpl %ebx, %ebp
jae 0x1dc0
movq %r14, %rdi
movl %ebx, %esi
callq 0x1abe
cmpl %ebp, %ebx
je 0x1dc0
movq 0x110(%r14), %rsi
movl $0x1000, %edi           # imm = 0x1000
callq 0x1060
movq %rax, %r15
movq %r14, %rdi
movl %ebp, %esi
callq 0x2f78
movq %r15, (%rax)
incl %ebp
jmp 0x1d97
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommylist.c
// Function: tommy_list_sort
void tommy_list_sort(tommy_list* list, tommy_compare_func* cmp)
{
	tommy_chain chain;
	tommy_node* head;

	if (tommy_list_empty(list))
		return;

	head = tommy_list_head(list);

	/* create a chain from the list */
	chain.head = head;
	chain.tail = head->prev;

	tommy_chain_mergesort(&chain, cmp);

	/* restore the list */
	tommy_list_set(list, chain.head, chain.tail);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq (%rdi), %r12
testq %r12, %r12
je 0x1eef
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
movq 0x8(%r12), %rax
movq %rax, 0x10(%rsp)
xorl %r13d, %r13d
movq %r12, 0x220(%rsp)
movq %r12, 0x228(%rsp)
movq (%r12), %rax
movq %rax, 0x18(%rsp)
movl %r13d, %ebp
xorl %ebx, %ebx
leaq 0x220(%rsp), %rsi
movl %ebx, %eax
shlq $0x4, %rax
leaq (%rsp,%rax), %r15
addq $0x20, %r15
testb $0x1, %bpl
je 0x1e67
movq %r15, %rdi
movq %r14, %rdx
callq 0x2faf
shrl %ebp
incl %ebx
movq %r15, %rsi
jmp 0x1e3f
movups (%rsi), %xmm0
movups %xmm0, (%r15)
incl %r13d
cmpq 0x10(%rsp), %r12
movq 0x18(%rsp), %r12
jne 0x1e19
bsfl %r13d, %r15d
movl %r15d, %ecx
shrl %cl, %r13d
movl %r15d, %eax
cmpl $0x1, %r13d
je 0x1ed1
movl %r13d, %ebx
shrl %ebx
incl %r15d
movq %r15, %rcx
shlq $0x4, %rcx
shlq $0x4, %rax
leaq (%rsp,%rcx), %rdi
addq $0x20, %rdi
leaq (%rsp,%rax), %rsi
addq $0x20, %rsi
testb $0x2, %r13b
jne 0x1ec4
movaps (%rsi), %xmm0
movaps %xmm0, (%rdi)
movl %ebx, %r13d
jmp 0x1e87
movq %r14, %rdx
callq 0x2faf
movl %ebx, %r13d
jmp 0x1e87
shlq $0x4, %rax
movq 0x20(%rsp,%rax), %rcx
movq 0x28(%rsp,%rax), %rax
movq %rax, 0x8(%rcx)
andq $0x0, (%rax)
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/tommyds/./tommytree.c
// Function: tommy_tree_insert
void* tommy_tree_insert(tommy_tree* tree, tommy_tree_node* node, void* data)
{
	tommy_tree_node* insert = node;

	insert->data = data;
	insert->prev = 0;
	insert->next = 0;
	insert->key = 0;

	tree->root = tommy_tree_insert_node(tree->cmp, tree->root, &insert);

	if (insert == node)
		++tree->count;

	return insert->data;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %rsi, (%r15)
movq %rdx, 0x10(%rsi)
andl $0x0, 0x18(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
movq (%rdi), %rsi
movq 0x10(%rdi), %rdi
movq %r15, %rdx
callq 0x1f5e
movq %rax, (%rbx)
movq (%r15), %rax
cmpq %r14, %rax
jne 0x1f50
incl 0x8(%rbx)
movq 0x10(%rax), %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq