LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0xa980
movq -0x18(%rbp), %rdi
movzbl %al, %eax
movl %eax, -0x1c(%rbp)
callq 0xa980
movq -0x18(%rbp), %rdi
movb %al, %cl
movl -0x1c(%rbp), %eax
movzbl %cl, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movl %eax, -0x10(%rbp)
callq 0xa980
movq -0x18(%rbp), %rdi
movb %al, %cl
movl -0x10(%rbp), %eax
movzbl %cl, %ecx
shll $0x10, %ecx
orl %ecx, %eax
movl %eax, -0xc(%rbp)
callq 0xa980
movb %al, %cl
movl -0xc(%rbp), %eax
movzbl %cl, %ecx
shll $0x18, %ecx
orl %ecx, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x8, -0x1c(%rbp)
jge 0xdb1f
movq -0x28(%rbp), %rdi
callq 0xa980
movb %al, %cl
movslq -0x1c(%rbp), %rax
movb %cl, -0x18(%rbp,%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xdafb
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movl 0x2148(%rcx), %ecx
cmpq %rcx, %rax
jbe 0xdbb7
movq -0x28(%rbp), %rdi
callq 0xa980
movb %al, %cl
movq -0x28(%rbp), %rax
movzbl %cl, %ecx
movl %ecx, -0x18(%rbp)
movl -0x18(%rbp), %edx
movl 0x2148(%rax), %ecx
shll %cl, %edx
movl %edx, %ecx
movl %ecx, -0x18(%rbp)
movl 0x2148(%rax), %ecx
addl $0x8, %ecx
movl %ecx, 0x2148(%rax)
movl -0x18(%rbp), %ecx
addl 0x2144(%rax), %ecx
movl %ecx, 0x2144(%rax)
jmp 0xdb5f
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
subl $0x1, %ecx
movl %ecx, -0x1c(%rbp)
movl 0x2144(%rax), %ecx
andl -0x1c(%rbp), %ecx
movl %ecx, -0x14(%rbp)
movl 0x2144(%rax), %edx
movq -0x10(%rbp), %rcx
shrl %cl, %edx
movl %edx, %ecx
movl %ecx, 0x2144(%rax)
movq -0x10(%rbp), %rdx
movl 0x2148(%rax), %ecx
subq %rdx, %rcx
movl %ecx, 0x2148(%rax)
movl -0x14(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xf8(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x107d1
movq -0x18(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jne 0x107be
movq -0x18(%rbp), %rdi
callq 0xabb0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x106ec
jmp 0x107c0
movq -0x20(%rbp), %rdi
callq 0xa4c0
cmpq $0x0, %rax
jne 0x10710
movq 0x78de(%rip), %rax      # 0x17fe0
movq (%rax), %rax
movq -0x20(%rbp), %rdi
callq *%rax
jmp 0x107c0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x2a90(%rip), %rsi      # 0x131af
callq 0xaf40
cmpl $0x0, %eax
jne 0x10798
leaq -0xe0(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0xb310
movq -0x100(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa560
jmp 0x1074e
movq -0xf8(%rbp), %rdi
addq $0x98, %rdi
leaq -0xe0(%rbp), %rsi
callq 0xa2a0
jmp 0x1076a
leaq -0xe0(%rbp), %rdi
callq 0xa1d0
jmp 0x107ae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe8(%rbp)
movl %eax, -0xec(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0xa1d0
jmp 0x107da
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x2a17(%rip), %rdi      # 0x131be
movb $0x0, %al
callq 0xa070
movq 0x782b(%rip), %rax      # 0x17fe0
movq (%rax), %rax
movq -0x20(%rbp), %rdi
callq *%rax
jmp 0x107c0
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x106ba
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0xe8(%rbp), %rdi
callq 0xb340
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x10913
movq -0x18(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jne 0x10900
movq -0x18(%rbp), %rdi
callq 0xabb0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x10849
jmp 0x10902
movq -0x20(%rbp), %rdi
callq 0xa4c0
cmpq $0x0, %rax
jne 0x1086d
movq 0x7781(%rip), %rax      # 0x17fe0
movq (%rax), %rax
movq -0x20(%rbp), %rdi
callq *%rax
jmp 0x10902
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x295e(%rip), %rsi      # 0x131da
callq 0xaf40
cmpl $0x0, %eax
jne 0x108da
leaq -0x60(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xb2c0
movq -0x80(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa220
jmp 0x108a2
movq -0x78(%rbp), %rdi
addq $0xb0, %rdi
leaq -0x60(%rbp), %rsi
callq 0xab30
jmp 0x108b8
leaq -0x60(%rbp), %rdi
callq 0xb550
jmp 0x108f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xb550
jmp 0x1091c
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x28fd(%rip), %rdi      # 0x131e6
movb $0x0, %al
callq 0xa070
movq 0x76e9(%rip), %rax      # 0x17fe0
movq (%rax), %rax
movq -0x20(%rbp), %rdi
callq *%rax
jmp 0x10902
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x10817
addq $0x80, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0xb340
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x10(%rbp)
cmpq $0x0, %rax
je 0x12558
imull $0xa, -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movsbl (%rcx), %ecx
addl %ecx, %eax
subl $0x30, %eax
movl %eax, -0x14(%rbp)
jmp 0x12523
movl -0x14(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x12587
movb $0x1, -0x11(%rbp)
jmp 0x12589
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x10(%rbp)
cmpq $0x0, %rax
je 0x125be
imull $0xa, -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movsbl (%rcx), %ecx
addl %ecx, %eax
subl $0x30, %eax
movl %eax, -0x18(%rbp)
jmp 0x12589
testb $0x1, -0x11(%rbp)
je 0x125ce
xorl %eax, %eax
subl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x125d4
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x7c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x70(%rbp), %rdi
movl $0x20, %esi
movl $0x50, %edx
callq 0xa5f0
movb $0x0, -0x2a(%rbp)
movq $0x0, -0x78(%rbp)
movq -0x78(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x12767
movq -0x78(%rbp), %rax
andq $0xf, %rax
movl %eax, -0x8c(%rbp)
movq -0x88(%rbp), %rax
movq -0x78(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x90(%rbp)
cmpl $0x8, -0x8c(%rbp)
jl 0x12673
imull $0x3, -0x8c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8c(%rbp)
jmp 0x12680
imull $0x3, -0x8c(%rbp), %eax
movl %eax, -0x8c(%rbp)
leaq -0xb0(%rbp), %rdi
movl -0x90(%rbp), %ecx
movl $0x14, %esi
leaq 0xbf4(%rip), %rdx       # 0x1328d
movb $0x0, %al
callq 0xb150
movb -0xb0(%rbp), %cl
movslq -0x8c(%rbp), %rax
movb %cl, -0x70(%rbp,%rax)
movb -0xaf(%rbp), %cl
movl -0x8c(%rbp), %eax
addl $0x1, %eax
cltq
movb %cl, -0x70(%rbp,%rax)
movl -0x90(%rbp), %edi
callq 0xb350
cmpl $0x0, %eax
je 0x126f0
movl -0x90(%rbp), %eax
movb %al, %cl
movq -0x78(%rbp), %rax
andq $0xf, %rax
addq $0x34, %rax
movb %cl, -0x70(%rbp,%rax)
jmp 0x12701
movq -0x78(%rbp), %rax
andq $0xf, %rax
addq $0x34, %rax
movb $0x2e, -0x70(%rbp,%rax)
movl $0x1, -0x7c(%rbp)
movq -0x78(%rbp), %rax
addq $0x1, %rax
andq $0xf, %rax
cmpq $0x0, %rax
jne 0x12754
movq 0x58b7(%rip), %rax      # 0x17fd8
movq (%rax), %rdi
leaq -0x70(%rbp), %rdx
leaq 0xad0(%rip), %rsi       # 0x131ff
movb $0x0, %al
callq 0xaf80
leaq -0x70(%rbp), %rdi
movl $0x20, %esi
movl $0x50, %edx
callq 0xa5f0
movb $0x0, -0x2a(%rbp)
movl $0x0, -0x7c(%rbp)
jmp 0x12756
movq -0x78(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x78(%rbp)
jmp 0x12627
cmpl $0x1, -0x7c(%rbp)
jne 0x12789
movq 0x5864(%rip), %rax      # 0x17fd8
movq (%rax), %rdi
leaq -0x70(%rbp), %rdx
leaq 0xa7d(%rip), %rsi       # 0x131ff
movb $0x0, %al
callq 0xaf80
addq $0xb0, %rsp
popq %rbp
retq
// File: 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:
subq $0x168, %rsp            # imm = 0x168
movl %edi, 0x164(%rsp)
movl %esi, 0x160(%rsp)
movl $0x0, 0x154(%rsp)
leaq 0x128(%rsp), %rdi
movl $0x40, %edx
movq %rdx, %rsi
callq 0x2530
leaq 0x18(%rsp), %rdi
leaq 0x128(%rsp), %rsi
callq 0x39b0
movl $0x0, 0x15c(%rsp)
movl 0x160(%rsp), %eax
movl %eax, 0x158(%rsp)
movl 0x15c(%rsp), %eax
cmpl 0x164(%rsp), %eax
jae 0x16f5
movl 0x158(%rsp), %edi
callq 0x1250
movl %eax, 0x158(%rsp)
movl 0x164(%rsp), %edi
movl 0x158(%rsp), %esi
callq 0x12c0
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %esi
leaq 0x18(%rsp), %rdi
callq 0x1760
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x16c1
movl $0x28, %edi
callq 0x1090
movq %rax, 0x8(%rsp)
movl 0x14(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
movq 0x8(%rsp), %rax
movl $0x1, 0x4(%rax)
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
movq 0x8(%rsp), %rdx
movq 0x8(%rsp), %rax
movl (%rax), %ecx
leaq 0x18(%rsp), %rdi
callq 0x3a20
movl 0x154(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x154(%rsp)
jmp 0x16dd
movq 0x8(%rsp), %rcx
movl 0x4(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x4(%rcx)
addl 0x154(%rsp), %eax
movl %eax, 0x154(%rsp)
jmp 0x16df
movl 0x15c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x15c(%rsp)
jmp 0x1610
movq 0x88fc(%rip), %rax      # 0x9ff8
movq (%rax), %rax
movq %rax, (%rsp)
leaq 0x18(%rsp), %rdi
callq 0x17b0
movq (%rsp), %rdi
movl %eax, %edx
movl 0x154(%rsp), %ecx
leaq 0x5954(%rip), %rsi      # 0x7075
movb $0x0, %al
callq 0x1080
leaq 0x18(%rsp), %rdi
callq 0x17b0
movl %eax, 0x158(%rsp)
leaq 0x128(%rsp), %rdi
callq 0x25d0
movl 0x158(%rsp), %eax
addq $0x168, %rsp            # imm = 0x168
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/tommyds/./tommytrie.h
// Function: tommy_trie_search
tommy_inline void* tommy_trie_search(tommy_trie* trie, tommy_key_t key)
{
	tommy_trie_node* i = tommy_trie_bucket(trie, key);

	if (!i)
		return 0;

	return i->data;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x4050
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x1793
movq $0x0, 0x20(%rsp)
jmp 0x17a1
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: 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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
cmpq $0x8, -0x18(%rsp)
jae 0x2550
movq $0x8, -0x18(%rsp)
movq -0x10(%rsp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x18(%rsp)
cmpq $0x0, %rdx
je 0x258e
movq -0x18(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x10(%rsp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x18(%rsp)
movq -0x20(%rsp), %rax
subq %rdx, %rax
addq -0x10(%rsp), %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x20(%rax)
movq -0x8(%rsp), %rax
movq $0x0, (%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
retq
// File: attractivechaos[P]udb2/tommyds/./tommyalloc.c
// Function: allocator_reset
static void allocator_reset(tommy_allocator* alloc)
{
	tommy_allocator_entry* block = alloc->used_segment;

	while (block) {
		tommy_allocator_entry* block_next = block->next;
		tommy_free(block);
		block = block_next;
	}

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

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x2620
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
callq 0x1030
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x25f7
movq 0x10(%rsp), %rax
movl $0x0, 0x20(%rax)
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x8(%rax)
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: attractivechaos[P]udb2/tommyds/./tommyalloc.c
// Function: tommy_allocator_free
void tommy_allocator_free(tommy_allocator* alloc, void* ptr)
{
	tommy_allocator_entry* free_block = tommy_cast(tommy_allocator_entry*, ptr);

	/* put it in the free list */
	free_block->next = alloc->free_block;
	alloc->free_block = free_block;

	--alloc->count;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rcx
movq -0x18(%rsp), %rax
movq %rcx, (%rax)
movq -0x18(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, (%rax)
movq -0x8(%rsp), %rax
movl 0x20(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x20(%rax)
retq
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl $0x6, 0x100(%rax)
movq 0x10(%rsp), %rax
movl 0x100(%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x104(%rax)
movq 0x10(%rsp), %rax
movl 0x104(%rax), %eax
movl %eax, %edi
movl $0x8, %esi
callq 0x1070
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movl $0x1, 0xc(%rsp)
cmpl $0x6, 0xc(%rsp)
jae 0x28da
movq 0x10(%rsp), %rax
movq (%rax), %rdx
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x28b1
movq 0x10(%rsp), %rax
movl $0x0, 0x108(%rax)
addq $0x18, %rsp
retq
nop
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x1030
movl $0x6, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x100(%rcx), %eax
jae 0x295b
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
movq (%rsp), %rdi
movl 0xc(%rsp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x1030
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x290e
addq $0x18, %rsp
retq
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rax
movl 0x108(%rax), %eax
cmpl 0xc(%rsp), %eax
jb 0x2983
jmp 0x2a2b
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x108(%rax)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x104(%rcx), %eax
jbe 0x2a2b
movq 0x10(%rsp), %rax
movl 0x104(%rax), %eax
movl %eax, %edi
movl $0x8, %esi
callq 0x1070
movq %rax, (%rsp)
movq (%rsp), %rdx
movq 0x10(%rsp), %rax
movl 0x104(%rax), %eax
movl %eax, %ecx
xorl %eax, %eax
subq %rcx, %rax
shlq $0x3, %rax
addq %rax, %rdx
movq 0x10(%rsp), %rax
movq 0x10(%rsp), %rcx
movl 0x100(%rcx), %ecx
movq %rdx, (%rax,%rcx,8)
movq 0x10(%rsp), %rax
movl 0x100(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x100(%rax)
movq 0x10(%rsp), %rax
movl 0x100(%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x104(%rax)
jmp 0x2992
addq $0x18, %rsp
retq
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x100(%rax)
movq 0x10(%rsp), %rax
movl $0x6, 0x108(%rax)
movq 0x10(%rsp), %rax
movl 0x108(%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x10c(%rax)
movq 0x10(%rsp), %rax
movl 0x10c(%rax), %eax
movl %eax, %edi
movq 0x10(%rsp), %rax
movq 0x100(%rax), %rsi
callq 0x1070
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movl $0x1, 0x4(%rsp)
cmpl $0x6, 0x4(%rsp)
jae 0x2af7
movq 0x10(%rsp), %rax
movq (%rax), %rdx
movq 0x10(%rsp), %rax
movl 0x4(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x2ace
movq 0x10(%rsp), %rax
movl $0x0, 0x110(%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x1030
movl $0x6, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x108(%rcx), %eax
jae 0x2b84
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
movq (%rsp), %rdi
movl 0xc(%rsp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq 0x10(%rsp), %rcx
imulq 0x100(%rcx), %rax
addq %rax, %rdi
callq 0x1030
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2b2e
addq $0x18, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rax
movl 0x110(%rax), %eax
cmpl 0xc(%rsp), %eax
jb 0x2bb3
jmp 0x2c6b
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x110(%rax)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x10c(%rcx), %eax
jbe 0x2c6b
movq 0x10(%rsp), %rax
movl 0x10c(%rax), %eax
movl %eax, %edi
movq 0x10(%rsp), %rax
movq 0x100(%rax), %rsi
callq 0x1070
movq %rax, (%rsp)
movq (%rsp), %rdx
movq 0x10(%rsp), %rax
movl 0x10c(%rax), %eax
movl %eax, %ecx
movq 0x10(%rsp), %rax
imulq 0x100(%rax), %rcx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rdx
movq 0x10(%rsp), %rax
movq 0x10(%rsp), %rcx
movl 0x108(%rcx), %ecx
movq %rdx, (%rax,%rcx,8)
movq 0x10(%rsp), %rax
movl 0x108(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x108(%rax)
movq 0x10(%rsp), %rax
movl 0x108(%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x10c(%rax)
jmp 0x2bc2
addq $0x18, %rsp
retq
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2d10
movl %eax, %ecx
movl 0x8(%rsp), %eax
cmpl %ecx, %eax
jae 0x2d00
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x2d30
movq %rax, %rdi
callq 0x1030
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2cc1
movq 0x10(%rsp), %rdi
callq 0x28f0
addq $0x18, %rsp
retq
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movl 0x110(%rax), %eax
cmpl 0x1c(%rsp), %eax
jb 0x2d83
jmp 0x2e0b
movl 0x1c(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x110(%rax)
movl 0x1c(%rsp), %eax
addl $0x1000, %eax           # imm = 0x1000
subl $0x1, %eax
shrl $0xc, %eax
movl %eax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x2d10
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x18(%rsp), %eax
jae 0x2e0b
movq 0x20(%rsp), %rdi
movl 0x18(%rsp), %esi
callq 0x2960
movl 0x14(%rsp), %eax
cmpl 0x18(%rsp), %eax
jae 0x2e09
movl $0x1000, %edi           # imm = 0x1000
movl $0x8, %esi
callq 0x1070
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl 0x14(%rsp), %esi
movq 0x8(%rsp), %rdx
callq 0x2e10
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x2dcb
jmp 0x2e0b
addq $0x28, %rsp
retq
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2d10
movl %eax, %ecx
movl 0x8(%rsp), %eax
cmpl %ecx, %eax
jae 0x2f20
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x2d30
movq %rax, %rdi
callq 0x1030
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2ee1
movq 0x10(%rsp), %rdi
callq 0x28f0
addq $0x18, %rsp
retq
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movl 0x118(%rax), %eax
cmpl 0x1c(%rsp), %eax
jb 0x2f53
jmp 0x2fe2
movl 0x1c(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x118(%rax)
movl 0x1c(%rsp), %eax
addl $0x1000, %eax           # imm = 0x1000
subl $0x1, %eax
shrl $0xc, %eax
movl %eax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x2d10
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x18(%rsp), %eax
jae 0x2fe2
movq 0x20(%rsp), %rdi
movl 0x18(%rsp), %esi
callq 0x2960
movl 0x14(%rsp), %eax
cmpl 0x18(%rsp), %eax
jae 0x2fe0
movq 0x20(%rsp), %rax
movq 0x110(%rax), %rsi
movl $0x1000, %edi           # imm = 0x1000
callq 0x1070
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl 0x14(%rsp), %esi
movq 0x8(%rsp), %rdx
callq 0x2e10
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x2f9b
jmp 0x2fe2
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x30b0
cmpl $0x0, %eax
je 0x305f
jmp 0x30a6
movq 0x20(%rsp), %rdi
callq 0x30d0
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x30e0
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x3300
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x18(%rax)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rsi
leaq 0x8(%rsp), %rdx
callq 0x3420
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
cmpq 0x18(%rsp), %rax
jne 0x3410
movq 0x20(%rsp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
addq $0x28, %rsp
retq
nop
// File: attractivechaos[P]udb2/tommyds/./tommytree.c
// Function: tommy_tree_insert_node
static tommy_tree_node* tommy_tree_insert_node(tommy_compare_func* cmp, tommy_tree_node* root, tommy_tree_node** let)
{
	int c;

	if (!root)
		return *let;

	c = cmp((*let)->data, root->data);

	if (c < 0) {
		root->prev = tommy_tree_insert_node(cmp, root->prev, let);
		return tommy_tree_balance(root);
	}

	if (c > 0) {
		root->next = tommy_tree_insert_node(cmp, root->next, let);
		return tommy_tree_balance(root);
	}

	/* already present, set the return pointer */
	*let = root;

	return root;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x344d
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x34fa
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rcx), %rcx
movq 0x10(%rcx), %rdi
movq 0x10(%rsp), %rcx
movq 0x10(%rcx), %rsi
callq *%rax
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jge 0x34a9
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x8(%rsp), %rdx
callq 0x3420
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rdi
callq 0x5de0
movq %rax, 0x20(%rsp)
jmp 0x34fa
cmpl $0x0, 0x4(%rsp)
jle 0x34e3
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rsp), %rdx
callq 0x3420
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rdi
callq 0x5de0
movq %rax, 0x20(%rsp)
jmp 0x34fa
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/tommyds/./tommytree.c
// Function: tommy_tree_remove
void* tommy_tree_remove(tommy_tree* tree, void* data)
{
	tommy_tree_node* node = 0;

	tree->root = tommy_tree_remove_node(tree->cmp, tree->root, data, &node);

	if (!node)
		return 0;

	--tree->count;

	return node->data;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rsi
movq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rcx
callq 0x3590
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
cmpq $0x0, 0x8(%rsp)
jne 0x3565
movq $0x0, 0x20(%rsp)
jmp 0x3581
movq 0x18(%rsp), %rax
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: attractivechaos[P]udb2/tommyds/./tommytree.c
// Function: tommy_tree_remove_node
static tommy_tree_node* tommy_tree_remove_node(tommy_compare_func* cmp, tommy_tree_node* root, void* data, tommy_tree_node** let)
{
	int c;

	if (!root)
		return 0;

	c = cmp(data, root->data);

	if (c < 0) {
		root->prev = tommy_tree_remove_node(cmp, root->prev, data, let);
		return tommy_tree_balance(root);
	}

	if (c > 0) {
		root->next = tommy_tree_remove_node(cmp, root->next, data, let);
		return tommy_tree_balance(root);
	}

	/* found */
	*let = root;

	return tommy_tree_move_right(root->prev, root->next);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x35be
movq $0x0, 0x30(%rsp)
jmp 0x367f
movq 0x28(%rsp), %rax
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rcx
movq 0x10(%rcx), %rsi
callq *%rax
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jge 0x3618
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq 0x3590
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rdi
callq 0x5de0
movq %rax, 0x30(%rsp)
jmp 0x367f
cmpl $0x0, 0xc(%rsp)
jle 0x3657
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq 0x3590
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rdi
callq 0x5de0
movq %rax, 0x30(%rsp)
jmp 0x367f
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rsi
callq 0x6030
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: attractivechaos[P]udb2/tommyds/./tommytree.c
// Function: tommy_tree_search
void* tommy_tree_search(tommy_tree* tree, void* data)
{
	tommy_tree_node* node = tommy_tree_search_node(tree->cmp, tree->root, data);

	if (!node)
		return 0;

	return node->data;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rsi
movq 0x10(%rsp), %rdx
callq 0x36f0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x36d1
movq $0x0, 0x20(%rsp)
jmp 0x36df
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: attractivechaos[P]udb2/tommyds/./tommytree.c
// Function: tommy_tree_search_node
static tommy_tree_node* tommy_tree_search_node(tommy_compare_func* cmp, tommy_tree_node* root, void* data)
{
	int c;

	if (!root)
		return 0;

	c = cmp(data, root->data);

	if (c < 0)
		return tommy_tree_search_node(cmp, root->prev, data);

	if (c > 0)
		return tommy_tree_search_node(cmp, root->next, data);

	return root;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x3716
movq $0x0, 0x20(%rsp)
jmp 0x3784
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rcx
movq 0x10(%rcx), %rsi
callq *%rax
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jge 0x3755
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x8(%rsp), %rdx
callq 0x36f0
movq %rax, 0x20(%rsp)
jmp 0x3784
cmpl $0x0, 0x4(%rsp)
jle 0x377a
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rsp), %rdx
callq 0x36f0
movq %rax, 0x20(%rsp)
jmp 0x3784
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: attractivechaos[P]udb2/tommyds/./tommytree.c
// Function: tommy_tree_search_compare
void* tommy_tree_search_compare(tommy_tree* tree, tommy_compare_func* cmp, void* cmp_arg)
{
	tommy_tree_node* node = tommy_tree_search_node(cmp, tree->root, cmp_arg);

	if (!node)
		return 0;

	return node->data;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rsp), %rdx
callq 0x36f0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x37d0
movq $0x0, 0x20(%rsp)
jmp 0x37dd
movq (%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: attractivechaos[P]udb2/tommyds/./tommytree.c
// Function: tommy_tree_foreach_node
static void tommy_tree_foreach_node(tommy_tree_node* root, tommy_foreach_func* func)
{
	tommy_tree_node* next;

	if (!root)
		return;

	tommy_tree_foreach_node(root->prev, func);

	/* make a copy in case func is free() */
	next = root->next;

	func(root->data);

	tommy_tree_foreach_node(next, func);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x3898
jmp 0x38d5
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x3880
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq 0x10(%rcx), %rdi
callq *%rax
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x3880
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: attractivechaos[P]udb2/tommyds/./tommytree.c
// Function: tommy_tree_foreach_arg_node
static void tommy_tree_foreach_arg_node(tommy_tree_node* root, tommy_foreach_arg_func* func, void* arg)
{
	tommy_tree_node* next;

	if (!root)
		return;

	tommy_tree_foreach_arg_node(root->prev, func, arg);

	/* make a copy in case func is free() */
	next = root->next;

	func(arg, root->data);

	tommy_tree_foreach_arg_node(next, func, arg);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x392d
jmp 0x397b
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x3910
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rcx
movq 0x10(%rcx), %rsi
callq *%rax
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x3910
addq $0x28, %rsp
retq
// File: attractivechaos[P]udb2/tommyds/./tommytrie.c
// Function: tommy_trie_init
void tommy_trie_init(tommy_trie* trie, tommy_allocator* alloc)
{
	tommy_uint_t i;

	for (i = 0; i < TOMMY_TRIE_BUCKET_MAX; ++i)
		trie->bucket[i] = 0;

	trie->count = 0;
	trie->node_count = 0;

	trie->alloc = alloc;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
cmpl $0x20, -0x14(%rsp)
jae 0x39e7
movq -0x8(%rsp), %rax
movl -0x14(%rsp), %ecx
movq $0x0, (%rax,%rcx,8)
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x39c2
movq -0x8(%rsp), %rax
movl $0x0, 0x100(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x104(%rax)
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x108(%rax)
retq
nopw (%rax,%rax)
// File: attractivechaos[P]udb2/tommyds/./tommytrie.c
// Function: tommy_trie_insert
void tommy_trie_insert(tommy_trie* trie, tommy_trie_node* node, void* data, tommy_key_t key)
{
	tommy_trie_node** let_ptr;

	node->data = data;
	node->key = key;

	let_ptr = &trie->bucket[key >> TOMMY_TRIE_BUCKET_SHIFT];

	trie_bucket_insert(trie, TOMMY_TRIE_BUCKET_SHIFT, let_ptr, node, key);

	++trie->count;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movl 0xc(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x18(%rax)
movq 0x20(%rsp), %rax
movl 0xc(%rsp), %ecx
shrl $0x1b, %ecx
movl %ecx, %ecx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
movq (%rsp), %rdx
movq 0x18(%rsp), %rcx
movl 0xc(%rsp), %r8d
movl $0x1b, %esi
callq 0x3aa0
movq 0x20(%rsp), %rax
movl 0x100(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x100(%rax)
addq $0x28, %rsp
retq
// File: attractivechaos[P]udb2/tommyds/./tommytrie.c
// Function: tommy_trie_remove
void* tommy_trie_remove(tommy_trie* trie, tommy_key_t key)
{
	tommy_trie_node* ret;
	tommy_trie_node** let_ptr;

	let_ptr = &trie->bucket[key >> TOMMY_TRIE_BUCKET_SHIFT];

	ret = trie_bucket_remove_existing(trie, TOMMY_TRIE_BUCKET_SHIFT, let_ptr, 0, key);

	if (!ret)
		return 0;

	--trie->count;

	return ret->data;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movl 0x14(%rsp), %ecx
shrl $0x1b, %ecx
movl %ecx, %ecx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
movq (%rsp), %rdx
movl 0x14(%rsp), %r8d
movl $0x1b, %esi
xorl %eax, %eax
movl %eax, %ecx
callq 0x3ce0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x3caa
movq $0x0, 0x20(%rsp)
jmp 0x3ccc
movq 0x18(%rsp), %rax
movl 0x100(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x100(%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/tommyds/./tommytrie.c
// Function: tommy_trie_remove_existing
void* tommy_trie_remove_existing(tommy_trie* trie, tommy_trie_node* node)
{
	tommy_trie_node* ret;
	tommy_key_t key = node->key;
	tommy_trie_node** let_ptr;

	let_ptr = &trie->bucket[key >> TOMMY_TRIE_BUCKET_SHIFT];

	ret = trie_bucket_remove_existing(trie, TOMMY_TRIE_BUCKET_SHIFT, let_ptr, node, key);

	/* the element removed must match the one passed */
	assert(ret == node);

	--trie->count;

	return ret->data;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movl 0x18(%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rax
movl 0xc(%rsp), %ecx
shrl $0x1b, %ecx
movl %ecx, %ecx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
movq (%rsp), %rdx
movq 0x18(%rsp), %rcx
movl 0xc(%rsp), %r8d
movl $0x1b, %esi
callq 0x3ce0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jne 0x4003
jmp 0x4022
leaq 0x315c(%rip), %rdi      # 0x7166
leaq 0x3161(%rip), %rsi      # 0x7172
movl $0x118, %edx            # imm = 0x118
leaq 0x3163(%rip), %rcx      # 0x7180
callq 0x1050
movq 0x20(%rsp), %rax
movl 0x100(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x100(%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/tommyds/./tommytrie.c
// Function: tommy_trie_bucket
tommy_trie_node* tommy_trie_bucket(tommy_trie* trie, tommy_key_t key)
{
	tommy_trie_node* node;
	void* ptr;
	tommy_uint_t type;
	tommy_uint_t shift;

	ptr = trie->bucket[key >> TOMMY_TRIE_BUCKET_SHIFT];

	shift = TOMMY_TRIE_BUCKET_SHIFT;

recurse:
	if (!ptr)
		return 0;

	type = trie_get_type(ptr);

	switch (type) {
	case TOMMY_TRIE_TYPE_NODE :
		node = tommy_cast(tommy_trie_node*, ptr);
		if (node->key != key)
			return 0;
		return node;
	default :
	case TOMMY_TRIE_TYPE_TREE :
		ptr = trie_get_tree(ptr)->map[(key >> shift) & TOMMY_TRIE_TREE_MASK];
		shift -= TOMMY_TRIE_TREE_BIT;
		goto recurse;
	}
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movq -0x10(%rsp), %rax
movl -0x14(%rsp), %ecx
shrl $0x1b, %ecx
movl %ecx, %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rsp)
movl $0x1b, -0x30(%rsp)
cmpq $0x0, -0x28(%rsp)
jne 0x408e
movq $0x0, -0x8(%rsp)
jmp 0x4117
movl -0x28(%rsp), %eax
andl $0x1, %eax
movl %eax, -0x2c(%rsp)
movl -0x2c(%rsp), %eax
movl %eax, -0x34(%rsp)
testl %eax, %eax
je 0x40b2
jmp 0x40a7
movl -0x34(%rsp), %eax
subl $0x1, %eax
je 0x40e3
jmp 0x40e1
movq -0x28(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movl 0x18(%rax), %eax
cmpl -0x14(%rsp), %eax
je 0x40d5
movq $0x0, -0x8(%rsp)
jmp 0x4117
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x4117
jmp 0x40e3
movq -0x28(%rsp), %rax
subq $0x1, %rax
movl -0x14(%rsp), %edx
movl -0x30(%rsp), %ecx
shrl %cl, %edx
movl %edx, %ecx
movl %ecx, %ecx
andq $0x7, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rsp)
movl -0x30(%rsp), %eax
subl $0x3, %eax
movl %eax, -0x30(%rsp)
jmp 0x4078
movq -0x8(%rsp), %rax
retq
nopl (%rax)
// File: attractivechaos[P]udb2/tommyds/./tommytrieinp.c
// Function: tommy_trie_inplace_init
void tommy_trie_inplace_init(tommy_trie_inplace* trie_inplace)
{
	tommy_uint_t i;

	for (i = 0; i < TOMMY_TRIE_INPLACE_BUCKET_MAX; ++i)
		trie_inplace->bucket[i] = 0;

	trie_inplace->count = 0;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
cmpl $0x40, -0xc(%rsp)
jae 0x41a2
movq -0x8(%rsp), %rax
movl -0xc(%rsp), %ecx
movq $0x0, (%rax,%rcx,8)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x417d
movq -0x8(%rsp), %rax
movl $0x0, 0x200(%rax)
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/tommyds/./tommytrieinp.c
// Function: tommy_trie_inplace_insert
void tommy_trie_inplace_insert(tommy_trie_inplace* trie_inplace, tommy_trie_inplace_node* node, void* data, tommy_key_t key)
{
	tommy_trie_inplace_node** let_ptr;
	tommy_uint_t i;

	node->data = data;
	node->key = key;
	/* clear the child pointers */
	for (i = 0; i < TOMMY_TRIE_INPLACE_TREE_MAX; ++i)
		node->map[i] = 0;

	let_ptr = &trie_inplace->bucket[key >> TOMMY_TRIE_INPLACE_BUCKET_SHIFT];

	trie_inplace_bucket_insert(TOMMY_TRIE_INPLACE_BUCKET_SHIFT, let_ptr, node, key);

	++trie_inplace->count;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x10(%rax)
movl 0x1c(%rsp), %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x18(%rax)
movl $0x0, 0xc(%rsp)
cmpl $0x4, 0xc(%rsp)
jae 0x421f
movq 0x28(%rsp), %rax
movl 0xc(%rsp), %ecx
movq $0x0, 0x20(%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x41f9
movq 0x30(%rsp), %rax
movl 0x1c(%rsp), %ecx
shrl $0x1a, %ecx
movl %ecx, %ecx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rsi
movq 0x28(%rsp), %rdx
movl 0x1c(%rsp), %ecx
movl $0x1a, %edi
callq 0x4270
movq 0x30(%rsp), %rax
movl 0x200(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x200(%rax)
addq $0x38, %rsp
retq
nopw (%rax,%rax)