LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: iZhangHui[P]CppPrimer/CH17_SpecializedLibraryFacilities/examples/seed.cc
// Function: main
int main()
{
	default_random_engine e1;             // uses the default seed
	default_random_engine e2(2147483646); // use the given seed value

	// e3 and e4 will generate the same sequence 
	// because they use the same seed
	default_random_engine e3;        // uses the default seed value
	e3.seed(32767);                  // call seed to set a new seed value
	default_random_engine e4(32767); // set the seed value to 32767
	for (size_t i = 0; i != 100; ++i) {
		if (e1() == e2())
			cout << "unseeded match at iteration: " << i << endl;
		if (e3() != e4())
			cout << "seeded differs at iteration: " << i << endl;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x12e0
leaq -0x18(%rbp), %rdi
movl $0x7ffffffe, %esi       # imm = 0x7FFFFFFE
callq 0x1300
leaq -0x20(%rbp), %rdi
callq 0x12e0
leaq -0x20(%rbp), %rdi
movl $0x7fff, %esi           # imm = 0x7FFF
callq 0x1330
leaq -0x28(%rbp), %rdi
movl $0x7fff, %esi           # imm = 0x7FFF
callq 0x1300
movq $0x0, -0x30(%rbp)
cmpq $0x64, -0x30(%rbp)
je 0x12d1
leaq -0x10(%rbp), %rdi
callq 0x1390
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x1390
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jne 0x126e
movq 0x2d91(%rip), %rdi      # 0x3fd8
leaq 0xdb6(%rip), %rsi       # 0x2004
callq 0x1050
movq %rax, %rdi
movq -0x30(%rbp), %rsi
callq 0x1030
movq %rax, %rdi
movq 0x2d5f(%rip), %rsi      # 0x3fc8
callq 0x1060
leaq -0x20(%rbp), %rdi
callq 0x1390
movq %rax, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1390
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
je 0x12be
movq 0x2d41(%rip), %rdi      # 0x3fd8
leaq 0xd84(%rip), %rsi       # 0x2022
callq 0x1050
movq %rax, %rdi
movq -0x30(%rbp), %rsi
callq 0x1030
movq %rax, %rdi
movq 0x2d0f(%rip), %rsi      # 0x3fc8
callq 0x1060
jmp 0x12c0
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x1213
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: sbingner[P]kerneldec/kerneldec.cpp
// Function: read_asn1len(unsigned char)
uint64_t read_asn1len(uint8_t len)
{
    uint8_t buf[8];
    uint64_t full_len = 0;
    if ((len & 0x80) != 0x80) 
        return len;

    int size = len&0x7F;
    if (size > 8) {
        fprintf(stderr, "Sorry, no support for kernel this large or not a kernel\n");
        exit(1);
    }
    size_t nr = fread(buf, 1, size, _input);
    if (nr != size) {
        perror("read");
        exit(1);
    }
    for (int i=0; i<size; i++) {
        full_len = full_len<<8 | buf[i];
    }
    return le64toh(full_len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dil, %al
movb %al, -0x9(%rbp)
movq $0x0, -0x20(%rbp)
movzbl -0x9(%rbp), %eax
andl $0x80, %eax
cmpl $0x80, %eax
je 0x3323
movzbl -0x9(%rbp), %eax
movq %rax, -0x8(%rbp)
jmp 0x33d4
movzbl -0x9(%rbp), %eax
andl $0x7f, %eax
movl %eax, -0x24(%rbp)
cmpl $0x8, -0x24(%rbp)
jle 0x3355
movq 0x11ca6(%rip), %rax     # 0x14fe0
movq (%rax), %rdi
leaq 0xccc0(%rip), %rsi      # 0x10004
movb $0x0, %al
callq 0x3120
movl $0x1, %edi
callq 0x30f0
leaq -0x11(%rbp), %rdi
movslq -0x24(%rbp), %rdx
movq 0x12674(%rip), %rcx     # 0x159d8
movl $0x1, %esi
callq 0x3130
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movslq -0x24(%rbp), %rcx
cmpq %rcx, %rax
je 0x3395
leaq 0xccbf(%rip), %rdi      # 0x10045
callq 0x30a0
movl $0x1, %edi
callq 0x30f0
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x33c7
movq -0x20(%rbp), %rax
shlq $0x8, %rax
movslq -0x34(%rbp), %rcx
movzbl -0x11(%rbp,%rcx), %ecx
orq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x339c
movq -0x20(%rbp), %rdi
callq 0x33e0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: sbingner[P]kerneldec/kerneldec.cpp
// Function: read_asn1str()
char *read_asn1str() {
    uint8_t buf[2];
    read_asn1hdr(buf);
    if (*buf != 0x16) {
        fprintf(stderr, "Invalid input - not string (0x%02x)\n", *buf);
        exit(1);
    }

    uint64_t len = read_asn1len(buf[1]);

    char *str = (char*)calloc(len+1, 1);
    if (fread(str, 1, len, _input) != len) {
        perror("read");
        exit(1);
    }
    if (g_debug) fprintf(stderr, "read str \"%s\"\n", str);
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq -0x2(%rbp), %rdi
callq 0x33f0
movzbl -0x2(%rbp), %eax
cmpl $0x16, %eax
je 0x3480
movq 0x11b7f(%rip), %rax     # 0x14fe0
movq (%rax), %rdi
movzbl -0x2(%rbp), %edx
leaq 0xcbdb(%rip), %rsi      # 0x1004a
movb $0x0, %al
callq 0x3120
movl $0x1, %edi
callq 0x30f0
movzbl -0x1(%rbp), %edi
callq 0x32f0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
movl $0x1, %esi
callq 0x3080
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq 0x12526(%rip), %rcx     # 0x159d8
movl $0x1, %esi
callq 0x3130
cmpq -0x10(%rbp), %rax
je 0x34d8
leaq 0xcb7c(%rip), %rdi      # 0x10045
callq 0x30a0
movl $0x1, %edi
callq 0x30f0
leaq 0x12509(%rip), %rax     # 0x159e8
cmpl $0x0, (%rax)
je 0x3500
movq 0x11af5(%rip), %rax     # 0x14fe0
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0xcb76(%rip), %rsi      # 0x1006f
movb $0x0, %al
callq 0x3120
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: sbingner[P]kerneldec/lzssdec.cpp
// Function: lzssdecompress::lzssdecompress()
lzssdecompress::lzssdecompress()
{
    _maxmatch= 18;  // 4 bit size + threshold 
    _dictsize= 4096; // 12 bit size
    _copythreshold= 3; // 0 == copy 3 bytes
    _dict= new uint8_t[_dictsize+_maxmatch-1];

    reset();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movl $0x12, 0x44(%rcx)
movl $0x1000, 0x40(%rcx)     # imm = 0x1000
movl $0x3, 0x48(%rcx)
movl 0x40(%rcx), %eax
addl 0x44(%rcx), %eax
subl $0x1, %eax
movslq %eax, %rdi
callq 0x3030
movq -0x10(%rbp), %rdi
movq %rax, 0x38(%rdi)
callq 0x4040
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: sbingner[P]kerneldec/lzssdec.cpp
// Function: lzssdecompress::reset()
void lzssdecompress::reset()
{
    _state=EXPECTINGFLAG;
    _flags= 0; _bitnr= 0;
    _src=_srcend=_dst=_dstend=0;
    memset(_dict, ' ', _dictsize+_maxmatch-1);
    _dictptr= _dictsize-_maxmatch;
    _inputoffset= 0;
    _outputoffset= 0;
    _firstbyte= 0;
    _copyptr= 0;
    _copycount= 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movl $0x1, (%rcx)
movb $0x0, 0x4(%rcx)
movl $0x0, 0x8(%rcx)
movq $0x0, 0x28(%rcx)
movq $0x0, 0x20(%rcx)
movq $0x0, 0x18(%rcx)
movq $0x0, 0x10(%rcx)
movq 0x38(%rcx), %rdi
movl 0x40(%rcx), %eax
addl 0x44(%rcx), %eax
subl $0x1, %eax
movslq %eax, %rdx
movl $0x20, %esi
callq 0x3060
movq -0x10(%rbp), %rax
movl 0x40(%rax), %ecx
subl 0x44(%rax), %ecx
movl %ecx, 0x4c(%rax)
movl $0x0, 0x58(%rax)
movl $0x0, 0x5c(%rax)
movb $0x0, 0x30(%rax)
movl $0x0, 0x50(%rax)
movl $0x0, 0x54(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sbingner[P]kerneldec/lzssdec.cpp
// Function: lzssdecompress::dumpcopydata()
void lzssdecompress::dumpcopydata()
{
    // note: we are printing incorrect data, if _copyptr == _dictptr-1
    for (int i=0 ; i<_copycount ; i++)
        fprintf(stderr, " %02x", _dict[(_copyptr+i)&(_dictsize-1)]);
    fprintf(stderr, "\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x54(%rcx), %eax
jge 0x4567
movq -0x18(%rbp), %rdx
movq 0x10aae(%rip), %rax     # 0x14fe0
movq (%rax), %rdi
movq 0x38(%rdx), %rax
movl 0x50(%rdx), %ecx
addl -0xc(%rbp), %ecx
movl 0x40(%rdx), %edx
subl $0x1, %edx
andl %edx, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edx
leaq 0xbe22(%rip), %rsi      # 0x10377
movb $0x0, %al
callq 0x3120
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x451b
movq 0x10a72(%rip), %rax     # 0x14fe0
movq (%rax), %rdi
leaq 0xbb04(%rip), %rsi      # 0x1007c
movb $0x0, %al
callq 0x3120
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sbingner[P]kerneldec/lzssdec.cpp
// Function: lzssdecompress::copyfromdict()
void lzssdecompress::copyfromdict()
{
    while (_dst<_dstend && _copycount)
    {
        addtodict(*_dst++ = _dict[_copyptr++]);
        _outputoffset++;
        _copycount--;
        _copyptr= _copyptr&(_dictsize-1);
    }
    if (_copycount==0)
        nextflagbit();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdx
movq 0x20(%rdx), %rcx
xorl %eax, %eax
cmpq 0x28(%rdx), %rcx
movb %al, -0x11(%rbp)
jae 0x45c5
movq -0x10(%rbp), %rax
cmpl $0x0, 0x54(%rax)
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x45ce
jmp 0x4629
movq -0x10(%rbp), %rdi
movq 0x38(%rdi), %rax
movl 0x50(%rdi), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x50(%rdi)
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movq 0x20(%rdi), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, 0x20(%rdi)
movb %al, (%rcx)
movzbl %al, %esi
callq 0x4440
movq -0x10(%rbp), %rax
movl 0x5c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x5c(%rax)
movl 0x54(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x54(%rax)
movl 0x50(%rax), %ecx
movl 0x40(%rax), %edx
subl $0x1, %edx
andl %edx, %ecx
movl %ecx, 0x50(%rax)
jmp 0x45a4
movq -0x10(%rbp), %rax
cmpl $0x0, 0x54(%rax)
jne 0x463c
movq -0x10(%rbp), %rdi
callq 0x4480
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sbingner[P]kerneldec/lzssdec.cpp
// Function: lzssdecompress::flush(unsigned char*, unsigned int, unsigned int*)
void lzssdecompress::flush(uint8_t *dst, uint32_t dstlen, uint32_t *pdstused)
{
    if (g_debug) fprintf(stderr, "flash before state= %d, copy: 0x%x, 0x%x\n", _state, _copyptr, _copycount);
    _src= _srcend= NULL;
    _dst= dst;  _dstend= dst+dstlen;

    if (_state==COPYFROMDICT)
        copyfromdict();

    if (pdstused) *pdstused= _dst-dst;
    if (g_debug) fprintf(stderr, "flash after state= %d, copy: 0x%x, 0x%x\n", _state, _copyptr, _copycount);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, 0x11372(%rip)     # 0x159e8
je 0x469d
movq -0x28(%rbp), %rax
movq 0x1095d(%rip), %rcx     # 0x14fe0
movq (%rcx), %rdi
movl (%rax), %edx
movl 0x50(%rax), %ecx
movl 0x54(%rax), %r8d
leaq 0xbc8e(%rip), %rsi      # 0x10324
movb $0x0, %al
callq 0x3120
movq -0x28(%rbp), %rax
movq $0x0, 0x18(%rax)
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %edx
addq %rdx, %rcx
movq %rcx, 0x28(%rax)
cmpl $0x0, (%rax)
jne 0x46d5
movq -0x28(%rbp), %rdi
callq 0x4590
cmpq $0x0, -0x20(%rbp)
je 0x46f3
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
cmpl $0x0, 0x112ee(%rip)     # 0x159e8
je 0x4721
movq -0x28(%rbp), %rax
movq 0x108d9(%rip), %rcx     # 0x14fe0
movq (%rcx), %rdi
movl (%rax), %edx
movl 0x50(%rax), %ecx
movl 0x54(%rax), %r8d
leaq 0xbc34(%rip), %rsi      # 0x1034e
movb $0x0, %al
callq 0x3120
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ricbit[P]dlx/cover_nospacer.cc
// Function: ExactCover::solve(int)
void solve(int level) {
    if (header[0].rlink == 0) {
      count++;
      return;
    }
    int item = best_item();
    cover(item);
    solution[level].option = nodes[item].dlink;
    for (auto& option = solution[level].option; option != item; option = nodes[option].dlink) {
      try_option(option, solution[level]);
      solve(level + 1);
      rewind_option(option, solution[level]);
    }
    uncover(item);
  }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0x3670
cmpl $0x0, 0x4(%rax)
jne 0x7d42
movq 0x18(%rsp), %rax
movq 0x90(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x90(%rax)
jmp 0x7e5c
movq 0x18(%rsp), %rdi
callq 0x7e70
movq 0x18(%rsp), %rdi
movl %eax, 0x28(%rsp)
movl 0x28(%rsp), %esi
callq 0x7f40
movq 0x18(%rsp), %rdi
addq $0x18, %rdi
movslq 0x28(%rsp), %rsi
callq 0x3fc0
movq 0x18(%rsp), %rdi
movl 0x8(%rax), %eax
movl %eax, 0x14(%rsp)
addq $0x38, %rdi
movslq 0x2c(%rsp), %rsi
callq 0x8010
movl 0x14(%rsp), %ecx
movq 0x18(%rsp), %rdi
movl %ecx, (%rax)
addq $0x38, %rdi
movslq 0x2c(%rsp), %rsi
callq 0x8010
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movl (%rax), %eax
cmpl 0x28(%rsp), %eax
je 0x7e4e
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rax
movl (%rax), %eax
movl %eax, 0xc(%rsp)
addq $0x38, %rdi
movslq 0x2c(%rsp), %rsi
callq 0x8010
movl 0xc(%rsp), %esi
movq 0x18(%rsp), %rdi
movq %rax, %rdx
callq 0x8030
movq 0x18(%rsp), %rdi
movl 0x2c(%rsp), %esi
addl $0x1, %esi
callq 0x7d00
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x10(%rsp)
addq $0x38, %rdi
movslq 0x2c(%rsp), %rsi
callq 0x8010
movq 0x18(%rsp), %rdi
movl 0x10(%rsp), %esi
movq %rax, %rdx
callq 0x8080
movq 0x18(%rsp), %rdi
addq $0x18, %rdi
movq 0x20(%rsp), %rax
movslq (%rax), %rsi
callq 0x3fc0
movl 0x8(%rax), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
jmp 0x7da9
movq 0x18(%rsp), %rdi
movl 0x28(%rsp), %esi
callq 0x80c0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: attractivechaos[P]udb2/bkthomps-hashmap/test.c
// Function: test_int
uint32_t test_int(uint32_t n, uint32_t x0)
{
	uint32_t i, x, z = 0;
	unordered_map h;
	h = unordered_map_init(sizeof(uint32_t), sizeof(uint32_t), hash_int, compare_int);
	for (i = 0, x = x0; i < n; ++i) {
		uint32_t key, v;
		x = hash32(x);
		key = get_key(n, x);
		if (!unordered_map_get(&v, h, &key)) {
			v = 1;
			unordered_map_put(h, &key, &v);
		} else {
			++v;
			unordered_map_put(h, &key, &v);
		}
		z += v;
	}
	fprintf(stderr, "# unique keys: %d; checksum: %u\n", unordered_map_size(h), z);
	x = unordered_map_size(h);
	unordered_map_destroy(h);
	return x;
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movl %esi, 0x30(%rsp)
movl $0x0, 0x24(%rsp)
movl $0x4, %esi
leaq 0x120(%rip), %rdx       # 0x16e0
leaq 0x139(%rip), %rcx       # 0x1700
movq %rsi, %rdi
callq 0x1740
movq %rax, 0x18(%rsp)
movl $0x0, 0x2c(%rsp)
movl 0x30(%rsp), %eax
movl %eax, 0x28(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x34(%rsp), %eax
jae 0x1681
movl 0x28(%rsp), %edi
callq 0x1240
movl %eax, 0x28(%rsp)
movl 0x34(%rsp), %edi
movl 0x28(%rsp), %esi
callq 0x12b0
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rsi
leaq 0x10(%rsp), %rdi
leaq 0x14(%rsp), %rdx
callq 0x1ea0
testb $0x1, %al
jne 0x1646
movl $0x1, 0x10(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x14(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x1a00
jmp 0x1665
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x14(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x1a00
movl 0x10(%rsp), %eax
addl 0x24(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x15e4
movq 0x3970(%rip), %rax      # 0x4ff8
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x19d0
movq 0x8(%rsp), %rdi
movl %eax, %edx
movl 0x24(%rsp), %ecx
leaq 0x19c9(%rip), %rsi      # 0x3075
movb $0x0, %al
callq 0x1060
movq 0x18(%rsp), %rdi
callq 0x19d0
movl %eax, 0x28(%rsp)
movq 0x18(%rsp), %rdi
callq 0x22d0
movl 0x28(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/bkthomps-hashmap/unordered_map.c
// Function: unordered_map_init
unordered_map unordered_map_init(const size_t key_size,
                                 const size_t value_size,
                                 unsigned long (*hash)(const void *const),
                                 int (*comparator)(const void *const,
                                                   const void *const))
{
    struct _unordered_map *const init = malloc(sizeof(struct _unordered_map));
    if (!init) {
        return NULL;
    }
    init->key_size = key_size;
    init->value_size = value_size;
    init->hash = hash;
    init->comparator = comparator;
    init->size = 0;
    init->capacity = STARTING_BUCKETS;
    init->buckets = calloc(STARTING_BUCKETS, sizeof(struct node *));
    if (!init->buckets) {
        free(init);
        return NULL;
    }
    return init;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movl $0x30, %edi
callq 0x1080
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x177d
movq $0x0, 0x30(%rsp)
jmp 0x1810
movq 0x28(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x20(%rax)
movq 0x8(%rsp), %rax
movl $0x8, 0x24(%rax)
movl $0x8, %esi
movq %rsi, %rdi
callq 0x1050
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x1806
movq 0x8(%rsp), %rdi
callq 0x1030
movq $0x0, 0x30(%rsp)
jmp 0x1810
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: attractivechaos[P]udb2/bkthomps-hashmap/unordered_map.c
// Function: unordered_map_rehash
int unordered_map_rehash(unordered_map me)
{
    struct node **old_buckets = me->buckets;
    me->buckets = calloc((size_t) me->capacity, sizeof(struct node *));
    if (!me->buckets) {
        me->buckets = old_buckets;
        return -ENOMEM;
    }
    for (int i = 0; i < me->capacity; i++) {
        struct node *traverse = old_buckets[i];
        while (traverse) {
            struct node *const backup = traverse->next;
            traverse->hash = me->hash(traverse->key);
            unordered_map_add_item(me, traverse);
            traverse = backup;
        }
    }
    free(old_buckets);
    return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
movslq 0x24(%rax), %rdi
movl $0x8, %esi
callq 0x1050
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x28(%rsp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x187d
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x28(%rax)
movl $0xfffffff4, 0x34(%rsp) # imm = 0xFFFFFFF4
jmp 0x1917
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movq 0x28(%rsp), %rcx
cmpl 0x24(%rcx), %eax
jge 0x1905
movq 0x20(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x18f6
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
movq (%rcx), %rdi
callq *%rax
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x1920
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x18a6
jmp 0x18f8
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x1885
movq 0x20(%rsp), %rdi
callq 0x1030
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
// File: attractivechaos[P]udb2/bkthomps-hashmap/unordered_map.c
// Function: unordered_map_add_item
static void unordered_map_add_item(unordered_map me, struct node *const add)
{
    const int index = (int) (add->hash % me->capacity);
    add->next = NULL;
    if (!me->buckets[index]) {
        me->buckets[index] = add;
        return;
    }
    struct node *traverse = me->buckets[index];
    while (traverse->next) {
        traverse = traverse->next;
    }
    traverse->next = add;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rsp), %rcx
movslq 0x24(%rcx), %rcx
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, -0x14(%rsp)
movq -0x10(%rsp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rsp), %rax
movq 0x28(%rax), %rax
movslq -0x14(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x1982
movq -0x10(%rsp), %rdx
movq -0x8(%rsp), %rax
movq 0x28(%rax), %rax
movslq -0x14(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x19c3
movq -0x8(%rsp), %rax
movq 0x28(%rax), %rax
movslq -0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x19b5
movq -0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rsp)
jmp 0x1999
movq -0x10(%rsp), %rcx
movq -0x20(%rsp), %rax
movq %rcx, 0x18(%rax)
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/bkthomps-hashmap/unordered_map.c
// Function: unordered_map_create_element
static struct node *const unordered_map_create_element(unordered_map me,
                                                       const unsigned long hash,
                                                       const void *const key,
                                                       const void *const value)
{
    struct node *const init = malloc(sizeof(struct node));
    if (!init) {
        return NULL;
    }
    init->key = malloc(me->key_size);
    if (!init->key) {
        free(init);
        return NULL;
    }
    memcpy(init->key, key, me->key_size);
    init->value = malloc(me->value_size);
    if (!init->value) {
        free(init->key);
        free(init);
        return NULL;
    }
    memcpy(init->value, value, me->value_size);
    init->hash = hash;
    init->next = NULL;
    return init;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movl $0x20, %edi
callq 0x1080
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x1c3d
movq $0x0, 0x30(%rsp)
jmp 0x1d1b
movq 0x28(%rsp), %rax
movq (%rax), %rdi
callq 0x1080
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x1c78
movq 0x8(%rsp), %rdi
callq 0x1030
movq $0x0, 0x30(%rsp)
jmp 0x1d1b
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x28(%rsp), %rax
movq (%rax), %rdx
callq 0x1070
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x1080
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x1cda
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x1030
movq 0x8(%rsp), %rdi
callq 0x1030
movq $0x0, 0x30(%rsp)
jmp 0x1d1b
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rsi
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rdx
callq 0x1070
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/bkthomps-hashmap/unordered_map.c
// Function: unordered_map_resize
static int unordered_map_resize(unordered_map me)
{
    const int old_capacity = me->capacity;
    const int new_capacity = (int) (me->capacity * RESIZE_RATIO);
    struct node **old_buckets = me->buckets;
    me->buckets = calloc((size_t) new_capacity, sizeof(struct node *));
    if (!me->buckets) {
        me->buckets = old_buckets;
        return -ENOMEM;
    }
    me->capacity = new_capacity;
    for (int i = 0; i < old_capacity; i++) {
        struct node *traverse = old_buckets[i];
        while (traverse) {
            struct node *const backup = traverse->next;
            unordered_map_add_item(me, traverse);
            traverse = backup;
        }
    }
    free(old_buckets);
    return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movl 0x24(%rax), %eax
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rax
cvtsi2sdl 0x24(%rax), %xmm0
movsd 0x12e9(%rip), %xmm1     # 0x30a0
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x18(%rsp)
movslq 0x20(%rsp), %rdi
movl $0x8, %esi
callq 0x1050
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x28(%rsp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x1e13
movq 0x18(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x28(%rax)
movl $0xfffffff4, 0x34(%rsp) # imm = 0xFFFFFFF4
jmp 0x1e94
movl 0x20(%rsp), %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x24(%rax)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0x1e82
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x1e73
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x1920
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x1e44
jmp 0x1e75
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x1e27
movq 0x18(%rsp), %rdi
callq 0x1030
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: attractivechaos[P]udb2/bkthomps-hashmap/unordered_map.c
// Function: unordered_map_get
bool unordered_map_get(void *const value, unordered_map me, void *const key)
{
    const unsigned long hash = me->hash(key);
    const int index = (int) (hash % me->capacity);
    struct node *traverse = me->buckets[index];
    while (traverse) {
        if (unordered_map_is_equal(me, traverse, hash, key)) {
            memcpy(value, traverse->value, me->value_size);
            return true;
        }
        traverse = traverse->next;
    }
    return false;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rsp), %rdi
callq *%rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movslq 0x24(%rcx), %rcx
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rax
movq 0x28(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x1f4c
movq 0x20(%rsp), %rdi
movq (%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0x1d30
testb $0x1, %al
jne 0x1f1c
jmp 0x1f3e
movq 0x28(%rsp), %rdi
movq (%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdx
callq 0x1070
movb $0x1, 0x37(%rsp)
jmp 0x1f51
movq (%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, (%rsp)
jmp 0x1ef7
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: attractivechaos[P]udb2/bkthomps-hashmap/unordered_map.c
// Function: unordered_map_contains
bool unordered_map_contains(unordered_map me, void *const key)
{
    const unsigned long hash = me->hash(key);
    const int index = (int) (hash % me->capacity);
    const struct node *traverse = me->buckets[index];
    while (traverse) {
        if (unordered_map_is_equal(me, traverse, hash, key)) {
            return true;
        }
        traverse = traverse->next;
    }
    return false;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rsp), %rdi
callq *%rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x28(%rsp), %rcx
movslq 0x24(%rcx), %rcx
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rax
movq 0x28(%rax), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x1ff1
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
callq 0x1d30
testb $0x1, %al
jne 0x1fda
jmp 0x1fe1
movb $0x1, 0x37(%rsp)
jmp 0x1ff6
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x1fb3
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/bkthomps-hashmap/unordered_map.c
// Function: unordered_map_remove
bool unordered_map_remove(unordered_map me, void *const key)
{
    const unsigned long hash = me->hash(key);
    const int index = (int) (hash % me->capacity);
    if (!me->buckets[index]) {
        return false;
    }
    struct node *traverse = me->buckets[index];
    if (unordered_map_is_equal(me, traverse, hash, key)) {
        me->buckets[index] = traverse->next;
        free(traverse->key);
        free(traverse->value);
        free(traverse);
        me->size--;
        return true;
    }
    while (traverse->next) {
        if (unordered_map_is_equal(me, traverse->next, hash, key)) {
            struct node *const backup = traverse->next;
            traverse->next = traverse->next->next;
            free(backup->key);
            free(backup->value);
            free(backup);
            me->size--;
            return true;
        }
        traverse = traverse->next;
    }
    return false;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rsp), %rdi
callq *%rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x28(%rsp), %rcx
movslq 0x24(%rcx), %rcx
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rax
movq 0x28(%rax), %rax
movslq 0x14(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x206b
movb $0x0, 0x37(%rsp)
jmp 0x21a0
movq 0x28(%rsp), %rax
movq 0x28(%rax), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
callq 0x1d30
testb $0x1, %al
jne 0x20a1
jmp 0x20f9
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdx
movq 0x28(%rsp), %rax
movq 0x28(%rax), %rax
movslq 0x14(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x1030
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movq 0x8(%rsp), %rdi
callq 0x1030
movq 0x28(%rsp), %rax
movl 0x20(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x20(%rax)
movb $0x1, 0x37(%rsp)
jmp 0x21a0
jmp 0x20fb
movq 0x8(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x219b
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rsi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
callq 0x1d30
testb $0x1, %al
jne 0x212e
jmp 0x2188
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x1030
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movq (%rsp), %rdi
callq 0x1030
movq 0x28(%rsp), %rax
movl 0x20(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x20(%rax)
movb $0x1, 0x37(%rsp)
jmp 0x21a0
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x20fb
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: attractivechaos[P]udb2/bkthomps-hashmap/unordered_map.c
// Function: unordered_map_clear
int unordered_map_clear(unordered_map me)
{
    struct node **temp =
            calloc((size_t) STARTING_BUCKETS, sizeof(struct node *));
    if (!temp) {
        return -ENOMEM;
    }
    for (int i = 0; i < me->capacity; i++) {
        struct node *traverse = me->buckets[i];
        while (traverse) {
            struct node *const backup = traverse;
            traverse = traverse->next;
            free(backup->key);
            free(backup->value);
            free(backup);
        }
        me->buckets[i] = NULL;
    }
    me->size = 0;
    me->capacity = STARTING_BUCKETS;
    free(me->buckets);
    me->buckets = temp;
    return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl $0x8, %esi
movq %rsi, %rdi
callq 0x1050
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x21e0
movl $0xfffffff4, 0x34(%rsp) # imm = 0xFFFFFFF4
jmp 0x22ba
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movq 0x28(%rsp), %rcx
cmpl 0x24(%rcx), %eax
jge 0x227e
movq 0x28(%rsp), %rax
movq 0x28(%rax), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x2258
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x1030
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movq 0x8(%rsp), %rdi
callq 0x1030
jmp 0x2211
movq 0x28(%rsp), %rax
movq 0x28(%rax), %rax
movslq 0x1c(%rsp), %rcx
movq $0x0, (%rax,%rcx,8)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x21e8
movq 0x28(%rsp), %rax
movl $0x0, 0x20(%rax)
movq 0x28(%rsp), %rax
movl $0x8, 0x24(%rax)
movq 0x28(%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x1030
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x28(%rax)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/bkthomps-hashmap/unordered_map.c
// Function: unordered_map_destroy
unordered_map unordered_map_destroy(unordered_map me)
{
    unordered_map_clear(me);
    free(me->buckets);
    free(me);
    return NULL;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x21b0
movq (%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x1030
movq (%rsp), %rdi
callq 0x1030
xorl %eax, %eax
popq %rcx
retq
// File: iZhangHui[P]CppPrimer/CH03_StringsVectorsAndArrays/examples/hexify.cc
// Function: main
int main()
{
	const string hexdigits = "0123456789ABCDEF";  // possible hex digits

	cout << "Enter a series of numbers between 0 and 15"
	     << " separated by spaces.  Hit ENTER when finished: " 
	     << endl;
	string result;        // will hold the resulting hexify'd string

	string::size_type n;  // hold numbers from the input
	while (cin >> n)
		if (n < hexdigits.size())    // ignore invalid input
			result += hexdigits[n];  // fetch the indicated hex digit

	cout << "Your hex number is: " << result << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x1120
movq -0x70(%rbp), %rdx
leaq 0xd6a(%rip), %rsi       # 0x2004
leaq -0x28(%rbp), %rdi
callq 0x10d0
jmp 0x12a5
leaq -0x29(%rbp), %rdi
callq 0x10a0
movq 0x2d1b(%rip), %rdi      # 0x3fd0
leaq 0xd59(%rip), %rsi       # 0x2015
callq 0x1080
movq %rax, -0x78(%rbp)
jmp 0x12c7
movq -0x78(%rbp), %rdi
leaq 0xd6e(%rip), %rsi       # 0x2040
callq 0x1080
movq %rax, -0x80(%rbp)
jmp 0x12dd
movq -0x80(%rbp), %rdi
movq 0x2cd8(%rip), %rsi      # 0x3fc0
callq 0x1090
jmp 0x12ef
leaq -0x60(%rbp), %rdi
callq 0x10e0
movq 0x2ce1(%rip), %rdi      # 0x3fe0
leaq -0x68(%rbp), %rsi
callq 0x10f0
movq %rax, -0x88(%rbp)
jmp 0x1311
movq -0x88(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x10c0
movb %al, -0x89(%rbp)
jmp 0x132f
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0x133e
jmp 0x13c5
movq -0x68(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1050
movq %rax, %rcx
movq -0x98(%rbp), %rax
cmpq %rcx, %rax
jae 0x13c0
movq -0x68(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x10b0
movsbl (%rax), %esi
leaq -0x60(%rbp), %rdi
callq 0x1040
jmp 0x137c
jmp 0x13c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x10a0
jmp 0x143d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x1434
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1030
jmp 0x1434
jmp 0x12f8
movq 0x2c04(%rip), %rdi      # 0x3fd0
leaq 0xc9e(%rip), %rsi       # 0x2071
callq 0x1080
movq %rax, -0xa0(%rbp)
jmp 0x13e1
movq -0xa0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x1070
movq %rax, -0xa8(%rbp)
jmp 0x13fa
movq -0xa8(%rbp), %rdi
movq 0x2bb8(%rip), %rsi      # 0x3fc0
callq 0x1090
jmp 0x140f
movl $0x0, -0x4(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1030
leaq -0x28(%rbp), %rdi
callq 0x1030
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x1030
movq -0x38(%rbp), %rdi
callq 0x1110
// File: wichtounet[P]articles/src/threads/part2/SafeGuard.cpp
// Function: main
int main(){
    Counter counter;

    std::vector<std::thread> threads;

    for(int i = 0; i < 5; ++i){
        threads.push_back(std::thread([&](){
            for(int i = 0; i < 100; ++i){
                counter.increment();
            }
        }));
    }

    for(auto& thread : threads){
        thread.join();
    }

    std::cout << counter.value << std::endl;

    return 0;
}

// Assembly:
subq $0x78, %rsp
movl $0x0, 0x74(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x1700
leaq 0x58(%rsp), %rdi
callq 0x1720
movl $0x0, 0x54(%rsp)
cmpl $0x5, 0x54(%rsp)
jge 0x1302
leaq 0x70(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x13d0
jmp 0x12aa
leaq 0x58(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x1730
jmp 0x12bb
leaq 0x48(%rsp), %rdi
callq 0x1760
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x1288
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x13ad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x1760
jmp 0x13ad
leaq 0x58(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x1780
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x17b0
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x17e0
testb $0x1, %al
jne 0x133f
jmp 0x1368
leaq 0x20(%rsp), %rdi
callq 0x1820
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x10f0
jmp 0x135a
jmp 0x135c
leaq 0x20(%rsp), %rdi
callq 0x1830
jmp 0x132a
movl 0x70(%rsp), %esi
movq 0x4c65(%rip), %rdi      # 0x5fd8
callq 0x1100
movq %rax, 0x8(%rsp)
jmp 0x137f
movq 0x8(%rsp), %rdi
movq 0x4c35(%rip), %rsi      # 0x5fc0
callq 0x10d0
jmp 0x1392
movl $0x0, 0x74(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x1850
movl 0x74(%rsp), %eax
addq $0x78, %rsp
retq
leaq 0x58(%rsp), %rdi
callq 0x1850
movq 0x38(%rsp), %rdi
callq 0x1110
nopw %cs:(%rax,%rax)
// File: MikuAuahDark[P]midi2sif/src/midi2sif.cpp
// Function: ReadVarInt(_IO_FILE*, unsigned long*)
uint32_t ReadVarInt(FILE* stream, size_t* decrementer = NULL)
{
	int32_t temp;
	uint32_t out = 0;

	do
	{
		if((temp = fgetc(stream)) == EOF)
			throw std::runtime_error("Unexpected EOF");

		if(decrementer) (*decrementer)--;

		out = (out << 7) | (temp & 0x7F);
	}
	while ((temp & 0x80) != 0);

	return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2340
movl %eax, -0x14(%rbp)
cmpl $-0x1, %eax
jne 0x2558
movl $0x10, %edi
callq 0x2100
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0xab0d(%rip), %rsi      # 0xd030
callq 0x20a0
jmp 0x252a
movq -0x30(%rbp), %rdi
movq 0x11ac3(%rip), %rsi     # 0x13ff8
movq 0x11a94(%rip), %rdx     # 0x13fd0
callq 0x2380
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x21a0
jmp 0x2598
cmpq $0x0, -0x10(%rbp)
je 0x256d
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $-0x1, %rcx
movq %rcx, (%rax)
movl -0x18(%rbp), %eax
shll $0x7, %eax
movl -0x14(%rbp), %ecx
andl $0x7f, %ecx
orl %ecx, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0x24f7
movl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2390
nopw %cs:(%rax,%rax)
// File: MikuAuahDark[P]midi2sif/src/midi2sif.cpp
// Function: InsertEvent(std::map<unsigned int, std::vector<EventInformation, std::allocator<EventInformation>>, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, std::vector<EventInformation, std::allocator<EventInformation>>>>>&, EventInformation&)
void InsertEvent(std::map<uint32_t, std::vector<EventInformation> >& raw, EventInformation& event)
{
	if(raw.count(event.tick))
	{
		std::vector<EventInformation>& eilist = raw[event.tick];

		event.order = eilist.size();
		eilist.push_back(event);
	}
	else
	{
		std::vector<EventInformation> temp;

		event.order = 0;
		temp.push_back(event);
		raw[event.tick] = temp;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3f10
cmpq $0x0, %rax
je 0x2605
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3f70
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4050
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4070
jmp 0x2670
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x40e0
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x10(%rbp), %rsi
callq 0x4070
jmp 0x262c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3f70
movq %rax, -0x50(%rbp)
jmp 0x263f
movq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4100
jmp 0x264e
leaq -0x30(%rbp), %rdi
callq 0x4350
jmp 0x2670
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4350
jmp 0x2676
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x2390
nop
// File: MikuAuahDark[P]midi2sif/src/midi2sif.cpp
// Function: EventInformation::EventInformation(unsigned int, bool, int, int)
EventInformation(uint32_t tick, bool note_on, int32_t pos, int32_t channel): order(0), meta(-1), data("")
	{
		this->tick = tick;
		this->order = order;
		this->note_on = note_on;
		this->pos = pos;
		this->channel = channel;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
andb $0x1, %al
movb %al, -0xd(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, 0x4(%rax)
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
addq $0x10, %rax
movq %rax, -0x40(%rbp)
leaq -0x19(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x23a0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rdx
leaq 0x8cbf(%rip), %rsi      # 0xd196
callq 0x5330
jmp 0x44de
leaq -0x19(%rbp), %rdi
callq 0x2260
movq -0x48(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movb -0xd(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x38(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x30(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0x34(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x2260
movq -0x28(%rbp), %rdi
callq 0x2390
nop
// File: MikuAuahDark[P]midi2sif/src/midi2sif.cpp
// Function: EventInformation::EventInformation(unsigned int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
EventInformation(uint32_t tick, int32_t meta, std::string data): order(0), pos(-1), channel(-1), note_on(false)
	{
		this->tick = tick;
		this->order = order;
		this->meta = meta;
		this->data = data;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rcx, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movl $0x0, 0x4(%rdi)
addq $0x10, %rdi
movq %rdi, -0x38(%rbp)
callq 0x22f0
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl $0xffffffff, 0x30(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x34(%rax) # imm = 0xFFFFFFFF
movb $0x0, 0x38(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x8(%rax)
callq 0x2040
jmp 0x45b6
addq $0x40, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x2160
movq -0x20(%rbp), %rdi
callq 0x2390
nopw (%rax,%rax)
// File: MikuAuahDark[P]midi2sif/src/midi2sif.cpp
// Function: ZN10SIFBeatmapcvNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEv
operator std::string()
	{
		char temp[128];

		sprintf(temp,
			"{"
			"\"timing_sec\": %.4f,"
			"\"notes_attribute\": %d,"
			"\"notes_level\": 1,"
			"\"effect\": %d,"
			"\"effect_value\": %.4f,"
			"\"position\": %d"
			"}",
			timing_sec, notes_attribute, effect, effect == SIFBeatmap::LONG_NOTE ? effect_value : 2.0, position
		);

		return std::string(temp);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xd8(%rbp)
movq %rdi, %rax
movq %rax, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0x90(%rbp), %rcx
movq %rcx, -0xc0(%rbp)
movsd (%rax), %xmm0
movsd %xmm0, -0xb8(%rbp)
movl 0x8(%rax), %ecx
movl %ecx, -0xac(%rbp)
movl 0xc(%rax), %ecx
movl %ecx, -0xa8(%rbp)
cmpl $0x3, 0xc(%rax)
jne 0x5067
movq -0xc8(%rbp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0xe0(%rbp)
jmp 0x5079
movsd 0x7fb9(%rip), %xmm0     # 0xd028
movsd %xmm0, -0xe0(%rbp)
jmp 0x5079
movl -0xa8(%rbp), %ecx
movl -0xac(%rbp), %edx
movsd -0xb8(%rbp), %xmm0
movq -0xc0(%rbp), %rdi
movq -0xc8(%rbp), %rax
movsd -0xe0(%rbp), %xmm1
movl 0x18(%rax), %r8d
leaq 0x8115(%rip), %rsi      # 0xd1c3
movb $0x2, %al
callq 0x2070
leaq -0x91(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x23a0
movq -0xd8(%rbp), %rdi
movq -0xe8(%rbp), %rdx
leaq -0x90(%rbp), %rsi
callq 0x5330
jmp 0x50e4
leaq -0x91(%rbp), %rdi
callq 0x2260
movq -0xd0(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
leaq -0x91(%rbp), %rdi
callq 0x2260
movq -0xa0(%rbp), %rdi
callq 0x2390
nopw (%rax,%rax)
// File: xavierholt[P]kd/test/example.cpp
// Function: main
int main() {
  typedef KD::Core<3, Point> CORE;

  Point min(0, 0, 0);
  Point max(9, 9, 9);
  KD::Tree<CORE> kdtree(min, max);

  kdtree.insert(Point(1, 2, 3));
  kdtree.insert(Point(8, 2, 5));
  kdtree.insert(Point(1, 0, 8));
  kdtree.insert(Point(3, 1, 4));

  std::cout << kdtree.nearest(Point(5, 5, 5)) << std::endl;
  return 0;
}

// Assembly:
subq $0x118, %rsp            # imm = 0x118
movl $0x0, 0x114(%rsp)
leaq 0x108(%rsp), %rdi
movq %rdi, 0x20(%rsp)
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x24b0
leaq 0xfc(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movss 0x3d42(%rip), %xmm2     # 0x6004
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x24b0
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0xa0(%rsp), %rdi
callq 0x24f0
leaq 0x94(%rsp), %rdi
movss 0x3d14(%rip), %xmm0     # 0x6008
movss 0x3d10(%rip), %xmm1     # 0x600c
movss 0x3d0c(%rip), %xmm2     # 0x6010
callq 0x24b0
jmp 0x230b
leaq 0xa0(%rsp), %rdi
leaq 0x94(%rsp), %rsi
callq 0x2550
jmp 0x2322
leaq 0x78(%rsp), %rdi
movss 0x3ce5(%rip), %xmm0     # 0x6014
movss 0x3cd5(%rip), %xmm1     # 0x600c
movss 0x3cd9(%rip), %xmm2     # 0x6018
callq 0x24b0
jmp 0x2346
leaq 0xa0(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x2550
jmp 0x235a
leaq 0x6c(%rsp), %rdi
movss 0x3ca1(%rip), %xmm0     # 0x6008
xorps %xmm1, %xmm1
movss 0x3ca2(%rip), %xmm2     # 0x6014
callq 0x24b0
jmp 0x2379
leaq 0xa0(%rsp), %rdi
leaq 0x6c(%rsp), %rsi
callq 0x2550
jmp 0x238d
leaq 0x60(%rsp), %rdi
movss 0x3c76(%rip), %xmm0     # 0x6010
movss 0x3c66(%rip), %xmm1     # 0x6008
movss 0x3c72(%rip), %xmm2     # 0x601c
callq 0x24b0
jmp 0x23b1
leaq 0xa0(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x2550
jmp 0x23c5
leaq 0x44(%rsp), %rdi
movss 0x3c46(%rip), %xmm2     # 0x6018
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x24b0
jmp 0x23df
leaq 0xa0(%rsp), %rdi
leaq 0x44(%rsp), %rsi
callq 0x2750
movss %xmm1, 0xc(%rsp)
movaps %xmm0, 0x10(%rsp)
jmp 0x23fe
movss 0xc(%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
movlpd %xmm1, 0x30(%rsp)
movss %xmm0, 0x38(%rsp)
movl 0x38(%rsp), %eax
movl %eax, 0x58(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x6baa(%rip), %rdi      # 0x8fd8
leaq 0x50(%rsp), %rsi
callq 0x26a0
movq %rax, (%rsp)
jmp 0x243e
movq (%rsp), %rdi
movq 0x6b7f(%rip), %rsi      # 0x8fc8
callq 0x20f0
jmp 0x2450
movl $0x0, 0x114(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0x2820
movl 0x114(%rsp), %eax
addq $0x118, %rsp            # imm = 0x118
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0x2820
movq 0x88(%rsp), %rdi
callq 0x2130
nopw %cs:(%rax,%rax)
nop