LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: iZhangHui[P]CppPrimer/CH06_Functions/examples/arrRet.cc
// Function: main
int main()
{
	int *p = elemPtr(6);         // p points to an int
	int (*arrP)[5] = arrPtr(5);  // arrP points to an array of five ints
	int (&arrR)[5] = arrRef(4);  // arrR refers to an array of five ints

	for (size_t i = 0; i < 5; ++i)
		// p points to an element in an array, which we subscript
		cout << p[i] << endl;  

	for (size_t i = 0; i < 5; ++i)
		// arrP points to an array, 
		// we must dereference the pointer to get the array itself
		cout << (*arrP)[i] << endl;

	for (size_t i = 0; i < 5; ++i)
		// arrR refers to an array, which we can subscript
		cout << arrR[i] << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl $0x6, %edi
callq 0x11b0
movq %rax, -0x10(%rbp)
movl $0x5, %edi
callq 0x11f0
movq %rax, -0x18(%rbp)
movl $0x4, %edi
callq 0x1220
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x5, -0x28(%rbp)
jae 0x12dc
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %esi
movq 0x2d1e(%rip), %rdi      # 0x3fd8
callq 0x1060
movq %rax, %rdi
movq 0x2cff(%rip), %rsi      # 0x3fc8
callq 0x1040
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x12a1
movq $0x0, -0x30(%rbp)
cmpq $0x5, -0x30(%rbp)
jae 0x131f
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movl (%rax,%rcx,4), %esi
movq 0x2cdb(%rip), %rdi      # 0x3fd8
callq 0x1060
movq %rax, %rdi
movq 0x2cbc(%rip), %rsi      # 0x3fc8
callq 0x1040
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x12e4
movq $0x0, -0x38(%rbp)
cmpq $0x5, -0x38(%rbp)
jae 0x1362
movq -0x20(%rbp), %rax
movq -0x38(%rbp), %rcx
movl (%rax,%rcx,4), %esi
movq 0x2c98(%rip), %rdi      # 0x3fd8
callq 0x1060
movq %rax, %rdi
movq 0x2c79(%rip), %rsi      # 0x3fc8
callq 0x1040
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x1327
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
// File: mrexodia[P]AsmParser/AsmParser.cpp
// Function: AsmParser::appendCurToken()
void appendCurToken()
    {
        if(mCur.empty())
            return;
        appendToken(getTokenType(mCur), mCur);
        mCur.clear();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x20, %rdi
callq 0x2220
testb $0x1, %al
jne 0x5a53
jmp 0x5a55
jmp 0x5a84
movq -0x10(%rbp), %rdi
movq %rdi, %rsi
addq $0x20, %rsi
callq 0x5b10
movq -0x10(%rbp), %rdi
movl %eax, %esi
movq %rdi, %rdx
addq $0x20, %rdx
callq 0x5a90
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x2190
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mrexodia[P]AsmParser/AsmParser.cpp
// Function: AsmParser::appendToken(AsmParser::Token::Type, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void appendToken(Token::Type type, const std::string & data)
    {
        Token t;
        t.type = type;
        t.data = data;
        mTokens.push_back(t);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5ee0
movl -0xc(%rbp), %eax
movl %eax, -0x40(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x2030
jmp 0x5ac9
movq -0x58(%rbp), %rdi
addq $0x40, %rdi
leaq -0x40(%rbp), %rsi
callq 0x5f00
jmp 0x5adc
leaq -0x40(%rbp), %rdi
callq 0x5920
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5920
movq -0x48(%rbp), %rdi
callq 0x2230
nopl (%rax)
// File: mrexodia[P]AsmParser/AsmParser.cpp
// Function: AsmParser::getTokenType(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Token::Type getTokenType(const std::string & data)
    {
        if(mSegments.count(data))
            return Token::Segment;
        if(mMemsizes.count(data))
            return Token::Memsize;
        if(mRegisters.count(data))
            return Token::Register;
        if(mPrefixes.count(data))
            return Token::Prefix;
        if(data == "ptr")
            return Token::Ptr;
        if(mTokens.empty() || mTokens[mTokens.size() - 1].type == Token::Prefix)
            return Token::Mnemonic;        
        return Token::Unknown;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x100, %rdi            # imm = 0x100
movq -0x18(%rbp), %rsi
callq 0x5c30
cmpq $0x0, %rax
je 0x5b4a
movl $0x7, -0x4(%rbp)
jmp 0x5c23
movq -0x20(%rbp), %rdi
addq $0xc8, %rdi
movq -0x18(%rbp), %rsi
callq 0x5c30
cmpq $0x0, %rax
je 0x5b70
movl $0x5, -0x4(%rbp)
jmp 0x5c23
movq -0x20(%rbp), %rdi
addq $0x58, %rdi
movq -0x18(%rbp), %rsi
callq 0x5c30
cmpq $0x0, %rax
je 0x5b93
movl $0x3, -0x4(%rbp)
jmp 0x5c23
movq -0x20(%rbp), %rdi
addq $0x90, %rdi
movq -0x18(%rbp), %rsi
callq 0x5c30
cmpq $0x0, %rax
je 0x5bb6
movl $0x1, -0x4(%rbp)
jmp 0x5c23
movq -0x18(%rbp), %rdi
leaq 0x1672(%rip), %rsi      # 0x7233
callq 0x5c60
testb $0x1, %al
jne 0x5bcc
jmp 0x5bd5
movl $0x6, -0x4(%rbp)
jmp 0x5c23
movq -0x20(%rbp), %rdi
addq $0x40, %rdi
callq 0x5c90
testb $0x1, %al
jne 0x5c13
movq -0x20(%rbp), %rdi
movq %rdi, %rax
addq $0x40, %rax
movq %rax, -0x28(%rbp)
addq $0x40, %rdi
callq 0x5cf0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0x5cd0
cmpl $0x1, (%rax)
jne 0x5c1c
movl $0x2, -0x4(%rbp)
jmp 0x5c23
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: roberty65[P]bServer/frame/testServer/src/otEchod.cpp
// Function: events_watch_add(int, int, int)
static int events_watch_add(int efd, int fd, int events)
{
        struct epoll_event ee;
        ee.events = events; ee.data.fd = fd;
        
        if (epoll_ctl(efd, EPOLL_CTL_ADD, fd, &ee) < 0) {
                fprintf(stderr, "epoll_ctl(ADD, %d) failed: %m\n", fd);
                return -1;
        }

        return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %edx
movl $0x1, %esi
leaq -0x1c(%rbp), %rcx
callq 0x11a0
cmpl $0x0, %eax
jge 0x15ba
movq 0x3a43(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
movl -0xc(%rbp), %edx
leaq 0x1ab9(%rip), %rsi      # 0x3063
movb $0x0, %al
callq 0x11c0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x15c1
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: roberty65[P]bServer/frame/testServer/src/otEchod.cpp
// Function: handle_events(int, int)
static int handle_events(int fd, int events)
{
	char buf[8192];
	ssize_t rlen = read(fd, buf, sizeof buf);
	if (rlen > 0) {
		ssize_t wlen = write(fd, buf, rlen);
		if (wlen != rlen) {
			fprintf(stderr, "write %d failed: rlen=%ld, wlen=%ld err: %m\n", fd, (long)rlen, (long)wlen);
			return -1;
		}
	}
	else {
		if (rlen == 0) fprintf(stderr, "socket %d is closed by peer\n", fd);
		else fprintf(stderr, "socket %d read error: %m\n", fd);
		return -1;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2020, %rsp           # imm = 0x2020
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0x8(%rbp), %edi
leaq -0x2010(%rbp), %rsi
movl $0x2000, %edx           # imm = 0x2000
callq 0x11d0
movq %rax, -0x2018(%rbp)
cmpq $0x0, -0x2018(%rbp)
jle 0x1667
movl -0x8(%rbp), %edi
leaq -0x2010(%rbp), %rsi
movq -0x2018(%rbp), %rdx
callq 0x1070
movq %rax, -0x2020(%rbp)
movq -0x2020(%rbp), %rax
cmpq -0x2018(%rbp), %rax
je 0x1665
movq 0x39a6(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
movl -0x8(%rbp), %edx
movq -0x2018(%rbp), %rcx
movq -0x2020(%rbp), %r8
leaq 0x1a2d(%rip), %rsi      # 0x3082
movb $0x0, %al
callq 0x11c0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x16b9
jmp 0x16b2
cmpq $0x0, -0x2018(%rbp)
jne 0x168e
movq 0x3968(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
movl -0x8(%rbp), %edx
leaq 0x1a2a(%rip), %rsi      # 0x30af
movb $0x0, %al
callq 0x11c0
jmp 0x16a9
movq 0x394b(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
movl -0x8(%rbp), %edx
leaq 0x1a2a(%rip), %rsi      # 0x30cc
movb $0x0, %al
callq 0x11c0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x16b9
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x2020, %rsp           # imm = 0x2020
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: roberty65[P]bServer/frame/testServer/src/otEchod.cpp
// Function: events_watch_del(int, int)
static int events_watch_del(int efd, int fd)
{
        struct epoll_event ee;
        ee.events = 0; ee.data.fd = fd;

        if (epoll_ctl(efd, EPOLL_CTL_DEL, fd, &ee) < 0) {
                fprintf(stderr, "epoll_ctl(DEL, %d) failed: %m\n", fd);
                return -1;
        }

        return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %edx
movl $0x2, %esi
leaq -0x18(%rbp), %rcx
callq 0x11a0
cmpl $0x0, %eax
jge 0x1728
movq 0x38d5(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
movl -0xc(%rbp), %edx
leaq 0x19ce(%rip), %rsi      # 0x30e6
movb $0x0, %al
callq 0x11c0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x172f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH19_SpecializedToolsAndTechniques/examples/useScreen.cc
// Function: xfcn()
void xfcn()
{
	function<int (X*, int)> f;
	f = &X::foo;		// pointer to member

	X x;
	int v = f(&x, 5);
	cout << "v = " << v << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq -0x20(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x27e0
movq -0x50(%rbp), %rdi
leaq 0x580(%rip), %rax       # 0x2820
movq %rax, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x2880
movq -0x50(%rbp), %rdi
leaq -0x31(%rbp), %rsi
movl $0x5, %edx
callq 0x28d0
movl %eax, -0x48(%rbp)
jmp 0x22cc
movl -0x48(%rbp), %eax
movl %eax, -0x38(%rbp)
movq 0x3cff(%rip), %rdi      # 0x5fd8
leaq 0x1d44(%rip), %rsi      # 0x4024
callq 0x20c0
movq %rax, -0x58(%rbp)
jmp 0x22eb
movq -0x58(%rbp), %rdi
movl -0x38(%rbp), %esi
callq 0x2110
movq %rax, -0x60(%rbp)
jmp 0x22fd
movq -0x60(%rbp), %rdi
movq 0x3cc0(%rip), %rsi      # 0x5fc8
callq 0x20d0
jmp 0x230f
leaq -0x20(%rbp), %rdi
callq 0x2920
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2920
movq -0x40(%rbp), %rdi
callq 0x2120
nopl (%rax)
// File: attractivechaos[P]udb2/sparsepp/test-1.cpp
// Function: test_int(unsigned int, unsigned int)
uint32_t test_int(uint32_t n, uint32_t x0)
{
	uint32_t i, x, z = 0;
	spp::sparse_hash_map<uint32_t, uint32_t, Hash32> h;
	for (i = 0, x = x0; i < n; ++i) {
		x = hash32(x);
		auto p = h.emplace(get_key(n, x), 0);
		z += ++p.first->second;
	}
	fprintf(stderr, "# unique keys: %ld; checksum: %u\n", h.size(), z);
	return h.size();
}

// Assembly:
subq $0xd8, %rsp
movl %edi, 0xd4(%rsp)
movl %esi, 0xd0(%rsp)
movl $0x0, 0xc4(%rsp)
leaq 0x65(%rsp), %rdi
callq 0x1890
leaq 0x68(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0x67(%rsp), %rdx
leaq 0x66(%rsp), %rcx
leaq 0x65(%rsp), %r8
callq 0x18a0
movl $0x0, 0xcc(%rsp)
movl 0xd0(%rsp), %eax
movl %eax, 0xc8(%rsp)
movl 0xcc(%rsp), %eax
cmpl 0xd4(%rsp), %eax
jae 0x17c2
movl 0xc8(%rsp), %edi
callq 0x1330
movl %eax, 0x2c(%rsp)
jmp 0x1716
movl 0x2c(%rsp), %eax
movl %eax, 0xc8(%rsp)
movl 0xd4(%rsp), %edi
movl 0xc8(%rsp), %esi
callq 0x13a0
movl %eax, 0x28(%rsp)
jmp 0x173a
movl 0x28(%rsp), %eax
movl %eax, 0x34(%rsp)
movl $0x0, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x34(%rsp), %rdx
leaq 0x30(%rsp), %rcx
callq 0x18f0
jmp 0x1765
leaq 0x38(%rsp), %rdi
callq 0x1930
movq %rax, 0x20(%rsp)
jmp 0x1776
movq 0x20(%rsp), %rcx
movl 0x4(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x4(%rcx)
addl 0xc4(%rsp), %eax
movl %eax, 0xc4(%rsp)
movl 0xcc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xcc(%rsp)
jmp 0x16f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x1950
jmp 0x1831
movq 0x880f(%rip), %rax      # 0x9fd8
movq (%rax), %rax
movq %rax, 0x10(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x1940
movq %rax, 0x18(%rsp)
jmp 0x17e2
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rdi
movl 0xc4(%rsp), %ecx
leaq 0x4887(%rip), %rsi      # 0x6081
xorl %eax, %eax
callq 0x1130
leaq 0x68(%rsp), %rdi
callq 0x1940
movq %rax, 0x8(%rsp)
jmp 0x1812
movq 0x8(%rsp), %rax
movl %eax, 0x4(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x1950
movl 0x4(%rsp), %eax
addq $0xd8, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0x11a0
nopl (%rax,%rax)
// File: attractivechaos[P]udb2/sparsepp/./sparsepp/spp.h
// Function: spp::sparsetable<std::pair<unsigned int const, unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::_free_groups()
void _free_groups()
    {
        if (_first_group)
        {
            for (group_type *g = _first_group; g != _last_group; ++g)
                g->destruct(_alloc);
            _free_group_array(_first_group, _last_group);
        }
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rax)
je 0x1a08
movq (%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
cmpq 0x8(%rcx), %rax
je 0x19f5
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x21, %rsi
callq 0x1a20
movq 0x8(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x8(%rsp)
jmp 0x19c4
movq (%rsp), %rsi
movq %rsi, %rdx
addq $0x8, %rdx
movq %rsi, %rdi
callq 0x1a60
addq $0x18, %rsp
retq
nopl (%rax)
// File: attractivechaos[P]udb2/sparsepp/./sparsepp/spp.h
// Function: spp::sparsegroup<std::pair<unsigned int const, unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::_free_group(spp::libc_allocator<std::pair<unsigned int const, unsigned int>>&, unsigned int)
void _free_group(allocator_type &alloc, uint32_t num_alloc)
    {
        if (_group)
        {
            uint32_t num_buckets = _num_items();
            if (num_buckets)
            {
                mutable_pointer end_it = (mutable_pointer)(_group + num_buckets);
                for (mutable_pointer p = (mutable_pointer)_group; p != end_it; ++p)
                    p->~mutable_value_type();
            }
            alloc.deallocate(_group, (typename allocator_type::size_type)num_alloc);
            _group = NULL;
        }
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, (%rax)
je 0x1b79
movq 0x8(%rsp), %rdi
callq 0x1b90
movl %eax, 0x20(%rsp)
cmpl $0x0, 0x20(%rsp)
je 0x1b55
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movl 0x20(%rsp), %edx
shlq $0x3, %rdx
addq %rdx, %rcx
movq %rcx, 0x18(%rsp)
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
je 0x1b53
movq 0x10(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x10(%rsp)
jmp 0x1b37
jmp 0x1b55
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rdi
movq (%rax), %rsi
movl 0x24(%rsp), %eax
movl %eax, %edx
callq 0x1ba0
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
addq $0x38, %rsp
retq
nop
// File: attractivechaos[P]udb2/sparsepp/./sparsepp/spp.h
// Function: spp::sparsehash_internal::sh_hashtable_settings<unsigned int, Hash32, unsigned long, 4>::min_buckets(unsigned long, unsigned long)
size_type min_buckets(size_type num_elts, size_type min_buckets_wanted)
        {
            float enlarge = enlarge_factor();
            size_type sz = HT_MIN_BUCKETS;             // min buckets allowed
            while (sz < min_buckets_wanted ||
                   num_elts >= static_cast<size_type>(sz * enlarge))
            {
                // This just prevents overflowing size_type, since sz can exceed
                // max_size() here.
                // -------------------------------------------------------------
                if (static_cast<size_type>(sz * 2) < sz)
                    throw_exception(std::length_error("resize overflow"));  // protect against overflow
                sz *= 2;
            }
            return sz;
        }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x60(%rsp), %rdi
callq 0x2060
movss %xmm0, 0x4c(%rsp)
movq $0x4, 0x40(%rsp)
movq 0x40(%rsp), %rcx
movb $0x1, %al
cmpq 0x50(%rsp), %rcx
movb %al, 0x23(%rsp)
jb 0x1e2f
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rax
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, 0x18(%rsp)
testq %rax, %rax
movss %xmm0, 0x1c(%rsp)
js 0x1dea
movss 0x18(%rsp), %xmm0
movss %xmm0, 0x1c(%rsp)
movq 0x10(%rsp), %rax
movss 0x1c(%rsp), %xmm0
movss 0x4c(%rsp), %xmm1
mulss %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttss2si %xmm1, %rcx
movq %rcx, %rsi
sarq $0x3f, %rsi
movss 0x4212(%rip), %xmm1     # 0x6028
subss %xmm1, %xmm0
cvttss2si %xmm0, %rdx
andq %rsi, %rdx
orq %rdx, %rcx
cmpq %rcx, %rax
setae %al
movb %al, 0x23(%rsp)
movb 0x23(%rsp), %al
testb $0x1, %al
jne 0x1e39
jmp 0x1ea2
movq 0x40(%rsp), %rax
shlq %rax
cmpq 0x40(%rsp), %rax
jae 0x1e90
leaq 0x4254(%rip), %rsi      # 0x60a3
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x10e0
movq 0x8(%rsp), %rdi
callq 0x2070
jmp 0x1e6a
leaq 0x30(%rsp), %rdi
callq 0x11c8
jmp 0x1e90
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x11c8
jmp 0x1eac
movq 0x40(%rsp), %rax
shlq %rax
movq %rax, 0x40(%rsp)
jmp 0x1d8c
movq 0x40(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x11a0
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/sparsepp/./sparsepp/spp.h
// Function: spp::sparsetable<std::pair<unsigned int const, unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::_alloc_group_array(unsigned long, spp::sparsegroup<std::pair<unsigned int const, unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>*&, spp::sparsegroup<std::pair<unsigned int const, unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>*&)
void _alloc_group_array(group_size_type sz, group_type *&first, group_type *&last)
    {
        if (sz)
        {
            first = _group_alloc.allocate((size_type)(sz + 1)); // + 1 for end marker
            first[sz].mark();                      // for the ne_iterator
            last = first + sz;
        }
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x227d
movq (%rsp), %rdi
addq $0x20, %rdi
movq 0x18(%rsp), %rsi
addq $0x1, %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2370
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
imulq $0x18, 0x18(%rsp), %rax
addq %rax, %rdi
callq 0x23a0
movq 0x10(%rsp), %rax
movq (%rax), %rcx
imulq $0x18, 0x18(%rsp), %rax
addq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: attractivechaos[P]udb2/sparsepp/./sparsepp/spp.h
// Function: std::pair<spp::Two_d_iterator<std::pair<unsigned int const, unsigned int>, spp::sparsegroup<std::pair<unsigned int const, unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>*, std::pair<unsigned int const, unsigned int>*, std::bidirectional_iterator_tag>, bool> spp::sparse_hashtable<std::pair<unsigned int const, unsigned int>, unsigned int, Hash32, spp::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::SelectKey, spp::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::SetKey, std::equal_to<unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::_insert_noresize<std::pair<unsigned int const, unsigned int>>(std::pair<unsigned int const, unsigned int>&)
std::pair<iterator, bool> _insert_noresize(T& obj)
    {
        Position pos = _find_position(get_key(obj));
        bool already_there = (pos._t == pt_full);

        if (!already_there)
        {
            reference ref(_insert_at(obj, pos._idx, pos._t == pt_erased));
            return std::pair<iterator, bool>(_mk_iterator(table.get_iter(pos._idx, &ref)), true);
        }
        return std::pair<iterator,bool>(_mk_iterator(table.get_iter(pos._idx)), false);
    }

// Assembly:
subq $0x98, %rsp
movq %rdi, (%rsp)
movq %rdi, 0x8(%rsp)
movq %rsi, 0x90(%rsp)
movq %rdx, 0x88(%rsp)
movq 0x90(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x88(%rsp), %rsi
callq 0x3810
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x47c0
movl %eax, 0x78(%rsp)
movq %rdx, 0x80(%rsp)
cmpl $0x2, 0x78(%rsp)
sete %al
andb $0x1, %al
movb %al, 0x77(%rsp)
testb $0x1, 0x77(%rsp)
jne 0x2bf6
movq 0x10(%rsp), %rdi
movq 0x88(%rsp), %rsi
movq 0x80(%rsp), %rdx
cmpl $0x1, 0x78(%rsp)
sete %al
movzbl %al, %ecx
andl $0x1, %ecx
callq 0x4990
movq 0x10(%rsp), %rdi
movq %rax, 0x68(%rsp)
addq $0x30, %rdi
movq 0x80(%rsp), %rsi
movq 0x68(%rsp), %rdx
callq 0x4ac0
movq 0x10(%rsp), %rdi
movq %rax, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
callq 0x4a90
movq (%rsp), %rdi
movq %rax, 0x58(%rsp)
movq %rdx, 0x60(%rsp)
movb $0x1, 0x47(%rsp)
leaq 0x58(%rsp), %rsi
leaq 0x47(%rsp), %rdx
callq 0x4b20
jmp 0x2c4c
movq 0x10(%rsp), %rdi
addq $0x30, %rdi
movq 0x80(%rsp), %rsi
callq 0x4b60
movq 0x10(%rsp), %rdi
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x4a90
movq (%rsp), %rdi
movq %rax, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movb $0x0, 0x1f(%rsp)
leaq 0x30(%rsp), %rsi
leaq 0x1f(%rsp), %rdx
callq 0x4b20
movq 0x8(%rsp), %rax
addq $0x98, %rsp
retq
nopl (%rax)
// File: attractivechaos[P]udb2/sparsepp/./sparsepp/spp.h
// Function: spp::sparse_hashtable<std::pair<unsigned int const, unsigned int>, unsigned int, Hash32, spp::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::SelectKey, spp::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::SetKey, std::equal_to<unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::swap(spp::sparse_hashtable<std::pair<unsigned int const, unsigned int>, unsigned int, Hash32, spp::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::SelectKey, spp::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::SetKey, std::equal_to<unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>&)
void swap(sparse_hashtable& ht)
    {
        using std::swap;

        swap(settings, ht.settings);
        swap(key_info, ht.key_info);
        swap(num_deleted, ht.num_deleted);
        table.swap(ht.table);
        settings.reset_thresholds(bucket_count());  // also resets consider_shrink
        ht.settings.reset_thresholds(ht.bucket_count());
        // we purposefully don't swap the allocator, which may not be swap-able
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rsi
callq 0x4720
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
movq 0x18(%rsp), %rsi
addq $0x20, %rsi
callq 0x47b0
movq 0x8(%rsp), %rdi
addq $0x28, %rdi
movq 0x18(%rsp), %rsi
addq $0x28, %rsi
callq 0x3b90
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
movq 0x18(%rsp), %rsi
addq $0x30, %rsi
callq 0x3a80
movq 0x8(%rsp), %rdi
callq 0x1fa0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x1f40
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x1fa0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x1f40
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: attractivechaos[P]udb2/sparsepp/./sparsepp/spp.h
// Function: spp::sparse_hashtable<std::pair<unsigned int const, unsigned int>, unsigned int, Hash32, spp::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::SelectKey, spp::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::SetKey, std::equal_to<unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::clear()
void clear()
    {
        if (!empty() || num_deleted != 0)
        {
            table.clear();
            table = Table(HT_DEFAULT_STARTING_BUCKETS, table.get_allocator());
        }
        settings.reset_thresholds(bucket_count());
        num_deleted = 0;
    }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x39a0
testb $0x1, %al
jne 0x33ee
jmp 0x33fa
movq 0x18(%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0x346f
movq 0x18(%rsp), %rdi
addq $0x30, %rdi
movq %rdi, 0x8(%rsp)
callq 0x39c0
movq 0x8(%rsp), %rsi
leaq 0x37(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x30e0
movq (%rsp), %rdx
leaq 0x38(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl $0x20, %esi
callq 0x1ec0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x3a00
jmp 0x3449
leaq 0x38(%rsp), %rdi
callq 0x1980
jmp 0x346f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x1980
jmp 0x3498
movq 0x18(%rsp), %rdi
callq 0x1fa0
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x1f40
movq 0x18(%rsp), %rax
movq $0x0, 0x28(%rax)
addq $0x68, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x11a0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: attractivechaos[P]udb2/sparsepp/./sparsepp/spp.h
// Function: spp::sparsetable<std::pair<unsigned int const, unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::swap(spp::sparsetable<std::pair<unsigned int const, unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>&)
void swap(sparsetable& o)
    {
        using std::swap;

        swap(_first_group, o._first_group);
        swap(_last_group,  o._last_group);
        swap(_table_size,  o._table_size);
        swap(_num_buckets, o._num_buckets);
        if (_alloc != o._alloc)
            swap(_alloc, o._alloc);
        if (_group_alloc != o._group_alloc)
            swap(_group_alloc, o._group_alloc);
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x8(%rsp), %rsi
callq 0x3b50
movq (%rsp), %rdi
addq $0x8, %rdi
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
callq 0x3b50
movq (%rsp), %rdi
addq $0x10, %rdi
movq 0x8(%rsp), %rsi
addq $0x10, %rsi
callq 0x3b90
movq (%rsp), %rdi
addq $0x18, %rdi
movq 0x8(%rsp), %rsi
addq $0x18, %rsi
callq 0x3b90
movq (%rsp), %rdi
addq $0x21, %rdi
movq 0x8(%rsp), %rsi
addq $0x21, %rsi
callq 0x3bd0
testb $0x1, %al
jne 0x3aff
jmp 0x3b15
movq (%rsp), %rdi
addq $0x21, %rdi
movq 0x8(%rsp), %rsi
addq $0x21, %rsi
callq 0x3be0
movq (%rsp), %rdi
addq $0x20, %rdi
movq 0x8(%rsp), %rsi
addq $0x20, %rsi
callq 0x3c20
testb $0x1, %al
jne 0x3b31
jmp 0x3b47
movq (%rsp), %rdi
addq $0x20, %rdi
movq 0x8(%rsp), %rsi
addq $0x20, %rsi
callq 0x3c30
addq $0x18, %rsp
retq
nopl (%rax)
// File: attractivechaos[P]udb2/sparsepp/./sparsepp/spp.h
// Function: spp::Two_d_destructive_iterator<std::pair<unsigned int const, unsigned int>, spp::sparsegroup<std::pair<unsigned int const, unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>*, std::pair<unsigned int const, unsigned int>*, std::input_iterator_tag, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::Two_d_destructive_iterator(spp::libc_allocator<std::pair<unsigned int const, unsigned int>>&, spp::sparsegroup<std::pair<unsigned int const, unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>*)
Two_d_destructive_iterator(Alloc &alloc, row_it curr) :
        _alloc(alloc)
    {
        this->row_current = curr;
        this->col_current = 0;
        if (this->row_current && !this->row_current->is_marked())
        {
            this->col_current = this->row_current->ne_begin();
            advance_past_end();                 // in case cur->begin() == cur->end()
        }
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x3dd0
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
cmpq $0x0, (%rax)
je 0x3dc2
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x3df0
testb $0x1, %al
jne 0x3dc2
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x3e10
movq 0x8(%rsp), %rdi
movq %rax, 0x8(%rdi)
callq 0x3e20
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: attractivechaos[P]udb2/sparsepp/./sparsepp/spp.h
// Function: spp::Two_d_destructive_iterator<std::pair<unsigned int const, unsigned int>, spp::sparsegroup<std::pair<unsigned int const, unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>*, std::pair<unsigned int const, unsigned int>*, std::input_iterator_tag, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::advance_past_end()
void advance_past_end()
    {
        // used when col_current points to end()
        while (this->col_current == this->row_current->ne_end())
        {
            this->row_current->clear(_alloc, true);  // This is what differs from non-destructive iterators above

            // end of current row
            // ------------------
            ++this->row_current;                          // go to beginning of next
            if (!this->row_current->is_marked())          // col is irrelevant at end
                this->col_current = this->row_current->ne_begin();
            else
                break;                                    // don't go past row_end
        }
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movq %rcx, (%rsp)
movq (%rax), %rdi
callq 0x3eb0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jne 0x3ea4
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rax), %rsi
movl $0x1, %edx
callq 0x3ee0
movq 0x8(%rsp), %rax
movq (%rax), %rcx
addq $0x18, %rcx
movq %rcx, (%rax)
movq (%rax), %rdi
callq 0x3df0
testb $0x1, %al
jne 0x3ea0
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x3e10
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0x3ea2
jmp 0x3ea4
jmp 0x3e33
addq $0x18, %rsp
retq
nopl (%rax)
// File: attractivechaos[P]udb2/sparsepp/./sparsepp/spp.h
// Function: spp::sparsegroup<std::pair<unsigned int const, unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::clear(spp::libc_allocator<std::pair<unsigned int const, unsigned int>>&, bool)
void clear(allocator_type &alloc, bool erased)
    {
        _free_group(alloc, _num_alloc());
        _bitmap = 0;
        if (erased)
            _bm_erased = 0;
        _set_num_items(0);
        _set_num_alloc(0);
    }

// Assembly:
subq $0x28, %rsp
movb %dl, %al
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
callq 0x1b80
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
movl %eax, %edx
callq 0x1ae0
movq 0x8(%rsp), %rax
movl $0x0, 0x8(%rax)
testb $0x1, 0x17(%rsp)
je 0x3f3d
movq 0x8(%rsp), %rax
movl $0x0, 0xc(%rax)
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x2560
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x2580
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: attractivechaos[P]udb2/sparsepp/./sparsepp/spp.h
// Function: std::pair<unsigned int const, unsigned int>* spp::sparsegroup<std::pair<unsigned int const, unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::set<std::pair<unsigned int const, unsigned int>>(spp::libc_allocator<std::pair<unsigned int const, unsigned int>>&, unsigned char, std::pair<unsigned int const, unsigned int>&)
pointer set(allocator_type &alloc, size_type i, Val &val)
    {
        _bme_clear(i); // in case this was an "erased" location

        size_type offset = pos_to_offset(i);
        _set(alloc, i, offset, val);            // may change _group pointer
        return (pointer)(_group + offset);
    }

// Assembly:
subq $0x38, %rsp
movb %dl, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movb %al, 0x27(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movzbl 0x27(%rsp), %esi
callq 0x4280
movq 0x8(%rsp), %rdi
movzbl 0x27(%rsp), %esi
callq 0x42b0
movq 0x8(%rsp), %rdi
movb %al, 0x17(%rsp)
movq 0x28(%rsp), %rsi
movb 0x27(%rsp), %cl
movb 0x17(%rsp), %al
movq 0x18(%rsp), %r8
movzbl %cl, %edx
movzbl %al, %ecx
callq 0x42e0
movq 0x8(%rsp), %rax
movq (%rax), %rax
movzbl 0x17(%rsp), %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
addq $0x38, %rsp
retq
nop
// File: attractivechaos[P]udb2/sparsepp/./sparsepp/spp.h
// Function: void spp::sparsegroup<std::pair<unsigned int const, unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::_set<std::pair<unsigned int const, unsigned int>>(spp::libc_allocator<std::pair<unsigned int const, unsigned int>>&, unsigned char, unsigned char, std::pair<unsigned int const, unsigned int>&)
void _set(allocator_type &alloc, size_type i, size_type offset, Val &val)
    {
        if (!_bmtest(i))
        {
            _set_aux(alloc, offset, val, check_alloc_type());
            _incr_num_items();
            _bmset(i);
        }
        else
            _set_val(&_group[offset], val);
    }

// Assembly:
subq $0x38, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movb %cl, 0x27(%rsp)
movb %al, 0x26(%rsp)
movq %r8, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movzbl 0x27(%rsp), %esi
callq 0x4180
testb $0x1, %al
jne 0x434d
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
movb 0x26(%rsp), %al
movq 0x18(%rsp), %rcx
movzbl %al, %edx
callq 0x43a0
movq 0x8(%rsp), %rdi
callq 0x4490
movq 0x8(%rsp), %rdi
movzbl 0x27(%rsp), %esi
callq 0x44b0
jmp 0x436b
movq 0x8(%rsp), %rdi
movq (%rdi), %rsi
movzbl 0x26(%rsp), %eax
shlq $0x3, %rax
addq %rax, %rsi
movq 0x18(%rsp), %rdx
callq 0x44e0
addq $0x38, %rsp
retq
// File: attractivechaos[P]udb2/sparsepp/./sparsepp/spp.h
// Function: void spp::sparsegroup<std::pair<unsigned int const, unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::_set_aux<std::pair<unsigned int const, unsigned int>>(spp::libc_allocator<std::pair<unsigned int const, unsigned int>>&, unsigned char, std::pair<unsigned int const, unsigned int>&, spp::integral_constant<bool, true>)
void _set_aux(allocator_type &alloc, size_type offset, Val &val, realloc_ok_type)
    {
        //static int x=0;  if (++x < 10) printf("x\n"); // check we are getting here

        uint32_t  num_items = _num_items();
        uint32_t  num_alloc = _sizing(num_items);

        if (num_items == num_alloc)
        {
            num_alloc = _sizing(num_items + 1);
            _group = alloc.reallocate(_group, num_alloc);
            _set_num_alloc(num_alloc);
        }

        for (uint32_t i = num_items; i > offset; --i)
            memcpy(_group + i, _group + i-1, sizeof(*_group));

        _init_val((mutable_pointer)(_group + offset), val);
    }

// Assembly:
subq $0x48, %rsp
movb %dl, %al
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movb %al, 0x2f(%rsp)
movq %rcx, 0x20(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x1b90
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %edi
callq 0x4510
movl %eax, 0x18(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x18(%rsp), %eax
jne 0x441e
movl 0x1c(%rsp), %edi
addl $0x1, %edi
callq 0x4510
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq (%rax), %rsi
movl 0x18(%rsp), %eax
movl %eax, %edx
callq 0x45b0
movq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movl 0x18(%rsp), %esi
callq 0x2580
movl 0x1c(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
movzbl 0x2f(%rsp), %ecx
cmpl %ecx, %eax
jbe 0x445c
movq 0x8(%rsp), %rdx
movq (%rdx), %rax
movl 0x14(%rsp), %ecx
movq (%rdx), %rdx
movl 0x14(%rsp), %esi
movq -0x8(%rdx,%rsi,8), %rdx
movq %rdx, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x4426
movq 0x8(%rsp), %rdi
movq (%rdi), %rsi
movzbl 0x2f(%rsp), %eax
cltq
shlq $0x3, %rax
addq %rax, %rsi
movq 0x20(%rsp), %rdx
callq 0x45e0
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: attractivechaos[P]udb2/sparsepp/./sparsepp/spp.h
// Function: spp::sparsegroup<std::pair<unsigned int const, unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::_sizing(unsigned int)::alloc_batch_size::alloc_batch_size()
SPP_CXX14_CONSTEXPR alloc_batch_size()
                : data()
            {
                uint8_t group_sz          = SPP_GROUP_SIZE / 4;
                uint8_t group_start_alloc = SPP_GROUP_SIZE / 8; //4;
                uint8_t alloc_sz          = group_start_alloc;
                for (int i=0; i<4; ++i)
                {
                    for (int j=0; j<group_sz; ++j)
                    {
                        if (j && j % group_start_alloc == 0)
                            alloc_sz += group_start_alloc;
                        data[i * group_sz + j] = alloc_sz;
                    }
                    if (group_start_alloc > 2)
                        group_start_alloc /= 2;
                    alloc_sz += group_start_alloc;
                }
            }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
xorl %esi, %esi
movl $0x20, %edx
callq 0x1080
movb $0x8, 0x1f(%rsp)
movb $0x4, 0x1e(%rsp)
movb 0x1e(%rsp), %al
movb %al, 0x1d(%rsp)
movl $0x0, 0x18(%rsp)
cmpl $0x4, 0x18(%rsp)
jge 0x46e8
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movzbl 0x1f(%rsp), %ecx
cmpl %ecx, %eax
jge 0x46ad
cmpl $0x0, 0x14(%rsp)
je 0x4681
movl 0x14(%rsp), %eax
movzbl 0x1e(%rsp), %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x4681
movzbl 0x1e(%rsp), %ecx
movzbl 0x1d(%rsp), %eax
addl %ecx, %eax
movb %al, 0x1d(%rsp)
movq 0x8(%rsp), %rax
movb 0x1d(%rsp), %dl
movl 0x18(%rsp), %ecx
movzbl 0x1f(%rsp), %esi
imull %esi, %ecx
addl 0x14(%rsp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x464c
movzbl 0x1e(%rsp), %eax
cmpl $0x2, %eax
jle 0x46c8
movzbl 0x1e(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movb %al, 0x1e(%rsp)
movzbl 0x1e(%rsp), %ecx
movzbl 0x1d(%rsp), %eax
addl %ecx, %eax
movb %al, 0x1d(%rsp)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x4639
addq $0x28, %rsp
retq
nopl (%rax)
// File: attractivechaos[P]udb2/sparsepp/./sparsepp/spp.h
// Function: std::pair<unsigned int const, unsigned int>& spp::sparse_hashtable<std::pair<unsigned int const, unsigned int>, unsigned int, Hash32, spp::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::SelectKey, spp::sparse_hash_map<unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::SetKey, std::equal_to<unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::_insert_at<std::pair<unsigned int const, unsigned int>>(std::pair<unsigned int const, unsigned int>&, unsigned long, bool)
reference _insert_at(T& obj, size_type pos, bool erased)
    {
        if (size() >= max_size())
        {
            throw_exception(std::length_error("insert overflow"));
        }
        if (erased)
        {
            assert(num_deleted);
            --num_deleted;
        }
        return table.set(pos, obj);
    }

// Assembly:
subq $0x58, %rsp
movb %cl, %al
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
andb $0x1, %al
movb %al, 0x3f(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x34b0
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0x4e60
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jb 0x4a1c
leaq 0x23e9(%rip), %rsi      # 0x6dc6
leaq 0x28(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x10e0
movq (%rsp), %rdi
callq 0x2070
jmp 0x49f6
leaq 0x28(%rsp), %rdi
callq 0x11c8
jmp 0x4a1c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x11c8
jmp 0x4a7e
testb $0x1, 0x3f(%rsp)
je 0x4a61
movq 0x8(%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0x4a31
jmp 0x4a50
leaq 0x239e(%rip), %rdi      # 0x6dd6
leaq 0x1680(%rip), %rsi      # 0x60bf
movl $0xc67, %edx            # imm = 0xC67
leaq 0x2397(%rip), %rcx      # 0x6de2
callq 0x10c0
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x28(%rax)
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0x4e80
addq $0x58, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x11a0
nopl (%rax,%rax)
// File: attractivechaos[P]udb2/sparsepp/./sparsepp/spp.h
// Function: spp::sparsetable<std::pair<unsigned int const, unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::get_iter(unsigned long)
ne_iterator get_iter(size_type i)
    {
        //assert(test(i));    // how can a nonempty_iterator point to an empty bucket?

        size_type grp_idx = group_num(i);

        return ne_iterator(_first_group + grp_idx,
                           (_first_group[grp_idx].ne_begin() +
                            _first_group[grp_idx].pos_to_offset(pos_in_group(i))));
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x28(%rsp), %rsi
callq 0x4160
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rsp)
movq (%rax), %rax
movq 0x20(%rsp), %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rdi
movq %rdi, 0x10(%rsp)
callq 0x3e10
movq (%rsp), %rdi
movq %rax, 0x18(%rsp)
movq (%rdi), %rax
movq 0x20(%rsp), %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rsi
callq 0x4140
movq 0x8(%rsp), %rdi
movzbl %al, %esi
callq 0x42b0
movq 0x10(%rsp), %rsi
movb %al, %cl
movq 0x18(%rsp), %rax
movzbl %cl, %ecx
leaq (%rax,%rcx,8), %rdx
leaq 0x38(%rsp), %rdi
callq 0x4fa0
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rdx
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: attractivechaos[P]udb2/sparsepp/./sparsepp/spp.h
// Function: std::pair<unsigned int const, unsigned int>& spp::sparsetable<std::pair<unsigned int const, unsigned int>, spp::libc_allocator<std::pair<unsigned int const, unsigned int>>>::set<std::pair<unsigned int const, unsigned int>>(unsigned long, std::pair<unsigned int const, unsigned int>&)
reference set(size_type i, Val &val)
    {
        assert(i < _table_size);
        group_type &group = which_group(i);
        typename group_type::size_type old_numbuckets = group.num_nonempty();
        pointer p(group.set(_alloc, pos_in_group(i), val));
        _num_buckets += group.num_nonempty() - old_numbuckets;
        return *p;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movq 0x38(%rsp), %rax
cmpq 0x10(%rcx), %rax
jae 0x4eaa
jmp 0x4ec9
leaq 0x1b0d(%rip), %rdi      # 0x69be
leaq 0x1207(%rip), %rsi      # 0x60bf
movl $0x8be, %edx            # imm = 0x8BE
leaq 0x2225(%rip), %rcx      # 0x70e9
callq 0x10c0
movq 0x10(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x41c0
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x4f90
movq 0x10(%rsp), %rdi
movb %al, 0x27(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq %rdi, %rax
addq $0x21, %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rsi
callq 0x4140
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x30(%rsp), %rcx
movzbl %al, %edx
callq 0x4200
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
callq 0x4f90
movb %al, %cl
movq 0x10(%rsp), %rax
movzbl %cl, %ecx
movzbl 0x27(%rsp), %edx
subl %edx, %ecx
movslq %ecx, %rcx
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movq 0x18(%rsp), %rax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/mshinfo/mshinfo.cpp
// Function: NumBoundaryEdges(gaps::R3Mesh*)
int NumBoundaryEdges(R3Mesh *mesh)
{
  // Count number of boundary edges
  int count = 0;
  for (int i = 0; i < mesh->NEdges(); i++) {
    R3MeshEdge *edge = mesh->Edge(i);
    R3MeshFace *face0 = mesh->FaceOnEdge(edge, 0);
    R3MeshFace *face1 = mesh->FaceOnEdge(edge, 1);
    if (!face0 || !face1) count++;
  }
  return count;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movl $0x0, 0x28(%rsp)
movl 0x28(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rdi
callq 0x104f0
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x10074
movq 0x30(%rsp), %rdi
movl 0x28(%rsp), %esi
callq 0x10510
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
xorl %edx, %edx
callq 0x10540
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl $0x1, %edx
callq 0x10540
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x10057
cmpq $0x0, 0x10(%rsp)
jne 0x10062
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x10064
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0xffe9
movl 0x2c(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/apps/scnview/scnview.cpp
// Function: DrawCameras(gaps::R3Scene*, gaps::RNArray<gaps::R3Camera*> const*)
static void
DrawCameras(R3Scene *scene, const RNArray<R3Camera *> *cameras = NULL)
{
  // Draw cameras
  if (cameras) {
    // Draw all input cameras
    for (int i = 0; i < cameras->NEntries(); i++) {
      R3Camera *camera = cameras->Kth(i);
      DrawCamera(scene, *camera);
    }
  }
  else {
    // Draw default camera
    DrawCamera(scene, scene->Camera());
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x277ee
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rdi
callq 0x2b8b0
movl %eax, %ecx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
jge 0x277ec
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x2b8c0
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
xorps %xmm0, %xmm0
callq 0x2ae30
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x2779e
jmp 0x27812
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x2b8e0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
xorps %xmm0, %xmm0
callq 0x2ae30
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/scnview/scnview.cpp
// Function: DrawBBoxes(gaps::R3Scene*, gaps::R3SceneNode*)
static void 
DrawBBoxes(R3Scene *scene, R3SceneNode *node)
{
  // Draw node bounding box
  node->BBox().Outline();

  // Push transformation
  node->Transformation().Push();

  // Draw children bboxes
  for (int i = 0; i < node->NChildren(); i++) {
    R3SceneNode *child = node->Child(i);
    DrawBBoxes(scene, child);
  }

  // Pop transformation
  node->Transformation().Pop();
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x56d40
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x2b520
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq (%rdi), %rax
callq *0xb0(%rax)
movq 0x28(%rsp), %rdi
callq 0x2bae0
movq %rax, %rdi
movq (%rdi), %rax
callq *0xb0(%rax)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x28(%rsp), %rdi
callq 0x2baf0
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x284e8
movq 0x28(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x2bb10
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x28440
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x2849d
movq 0x28(%rsp), %rdi
callq 0x2bae0
movq %rax, %rdi
movq (%rdi), %rax
callq *0xb8(%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)