LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: dcdolson[P]nsh-sf-devkit/examples/count/PacketCounter.cpp
// Function: PacketCounter::Receive(nshdev::PacketRef&, nshdev::NetInterface&)
void PacketCounter::Receive(nshdev::PacketRef& packetRef, nshdev::NetInterface& interface)
{
    m_packets += 1;
    m_bytes += packetRef.Length();
    Display();

    // Forward packets, not black-hole them.
    interface.ReturnToSender(packetRef);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x4130
movq -0x20(%rbp), %rdi
movl %eax, %eax
addq 0x10(%rdi), %rax
movq %rax, 0x10(%rdi)
callq 0x4060
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: dcdolson[P]nsh-sf-devkit/examples/count/PacketCounter.cpp
// Function: PacketCounter::Display()
void PacketCounter::Display()
{
    // very primitive: display counts, but no more than once per second.
    std::time_t now = std::time(nullptr);
    if( now - m_lastDisplayTime > 0 )
    {
        std::cout << "Packets: " << std::right << std::setw(12) << m_packets
	    << "  Bytes: " << m_bytes << std::endl;
	m_lastDisplayTime = now;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x3230
movq -0x20(%rbp), %rcx
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
subq 0x18(%rcx), %rax
cmpq $0x0, %rax
jle 0x4120
movq 0x8f1a(%rip), %rdi      # 0xcfb8
leaq 0x4010(%rip), %rsi      # 0x80b5
callq 0x3250
movq %rax, %rdi
leaq 0x9c(%rip), %rsi        # 0x4150
callq 0x30f0
movq %rax, -0x28(%rbp)
movl $0xc, %edi
callq 0x4180
movq -0x28(%rbp), %rdi
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %esi
callq 0x32d0
movq %rax, %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x30a0
movq %rax, %rdi
leaq 0x3fcf(%rip), %rsi      # 0x80bf
callq 0x3250
movq %rax, %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x30a0
movq %rax, %rdi
movq 0x8e79(%rip), %rsi      # 0xcf88
callq 0x3280
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: dcdolson[P]nsh-sf-devkit/src/Demux/Demux.cpp
// Function: nshdev::Demux::Receive(nshdev::PacketRef&, nshdev::NetInterface&)
void Demux::Receive(nshdev::PacketRef& packetRef, nshdev::NetInterface& receiveInterface)
    {
	nsh_hdr* nsh = reinterpret_cast<nsh_hdr*>(packetRef.Data());
	if(nsh_is_oam_packet(nsh))
	{
	    m_oamConsumer->Receive(packetRef, receiveInterface);
	}
	else if(m_dataConsumer)
	{
	    nsh_decrement_service_index(nsh);
	    m_dataConsumer->Receive(packetRef, receiveInterface);
	}
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6190
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6640
testb $0x1, %al
jne 0x65e8
jmp 0x6608
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x66f0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq (%rdi), %rax
callq *0x10(%rax)
jmp 0x6634
movq -0x28(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x6632
movq -0x20(%rbp), %rdi
callq 0x6660
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq (%rdi), %rax
callq *0x10(%rax)
jmp 0x6634
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: eschwabe[P]interview-practice/src/removechars.cpp
// Function: remove_chars(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string remove_chars(string str, string remove) {
    string output;
    unordered_set<char> remove_set;
    for(char c : remove) {
        remove_set.insert(c);
    }
    for(char c : str) {
        if( remove_set.find(c) == remove_set.end() ) {
            output.append(1, c);
        }
    }

    return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdx, -0xd0(%rbp)
movq %rsi, -0xe8(%rbp)
movq %rdi, -0xe0(%rbp)
movq %rdi, %rax
movq %rax, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x21d0
leaq -0x58(%rbp), %rdi
callq 0x2710
movq -0xd0(%rbp), %rdx
movq %rdx, -0x60(%rbp)
movq -0x60(%rbp), %rdi
callq 0x2100
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rdi
callq 0x2090
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x2730
testb $0x1, %al
jne 0x2410
jmp 0x2488
leaq -0x68(%rbp), %rdi
callq 0x2770
movb (%rax), %al
movb %al, -0x71(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x71(%rbp), %rsi
callq 0x2790
movb %dl, -0xf1(%rbp)
movq %rax, -0xf0(%rbp)
jmp 0x243a
movb -0xf1(%rbp), %al
movq -0xf0(%rbp), %rcx
movq %rcx, -0x98(%rbp)
movb %al, -0x90(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x27d0
jmp 0x23fd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x2880
movq -0xe0(%rbp), %rdi
callq 0x20a0
jmp 0x259a
movq -0xe8(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rdi
callq 0x2100
movq %rax, -0xa8(%rbp)
movq -0xa0(%rbp), %rdi
callq 0x2090
movq %rax, -0xb0(%rbp)
leaq -0xa8(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x2730
testb $0x1, %al
jne 0x24d8
jmp 0x256b
leaq -0xa8(%rbp), %rdi
callq 0x2770
movb (%rax), %al
movb %al, -0xb1(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0xb1(%rbp), %rsi
callq 0x2820
movq %rax, -0x100(%rbp)
jmp 0x2505
movq -0x100(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x2850
movq %rax, -0xc8(%rbp)
leaq -0xc0(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0x27f0
testb $0x1, %al
jne 0x253c
jmp 0x2558
movq -0xe0(%rbp), %rdi
movsbl -0xb1(%rbp), %edx
movl $0x1, %esi
callq 0x2170
jmp 0x2556
jmp 0x2558
jmp 0x255a
leaq -0xa8(%rbp), %rdi
callq 0x27d0
jmp 0x24bc
movb $0x1, -0x19(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x2880
testb $0x1, -0x19(%rbp)
jne 0x258a
movq -0xe0(%rbp), %rdi
callq 0x20a0
movq -0xd8(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x2210
nopw %cs:(%rax,%rax)
// File: arnoldrobbins[P]mcilroy-regex/grep.cpp
// Function: grepcomp()
void
grepcomp()
{
	int i;
	char *s, *t;	
	for(i=0; i<nargpat; i++) {
		for(t=s=argpat[i]; t; s = t+1) {	/*see above*/
			t = strchr(s, '\n');
			if(t)
				*t = 0;
			docomp(s);
		}	
	}

	for(i=0; i<nfilepat; i++) {
		FILE *patfile = fopen(filepat[i], "r");
		if(patfile)
			while(getline(patfile, filepat[i]) >= 0)
				docomp(&line[0]);
		else if(!sflag)
			error("cannot open", filepat[i]);
		else
			retval = 2;
		fclose(patfile);
	}
	if(nre == 0)
		error("no pattern", "");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0xdff8(%rip), %eax      # 0x12890
jge 0x48ff
movl -0x4(%rbp), %esi
leaq 0xdf3c(%rip), %rdi      # 0x127e0
callq 0x5000
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x48f2
movq -0x10(%rbp), %rdi
movl $0xa, %esi
callq 0x40b0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x48db
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rdi
callq 0x4be0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x48b4
jmp 0x48f4
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x488f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0xe039(%rip), %eax      # 0x12948
jge 0x49ce
movl -0x4(%rbp), %esi
leaq 0xdf79(%rip), %rdi      # 0x12898
callq 0x5000
movq (%rax), %rdi
leaq 0x8e5e(%rip), %rsi      # 0xd78c
callq 0x41d0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4982
jmp 0x4940
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x4(%rbp), %esi
leaq 0xdf46(%rip), %rdi      # 0x12898
callq 0x5000
movq -0x28(%rbp), %rdi
movq (%rax), %rsi
callq 0x4cb0
cmpl $0x0, %eax
jl 0x4980
leaq 0xe319(%rip), %rdi      # 0x12c88
xorl %esi, %esi
callq 0x5020
movq %rax, %rdi
callq 0x4be0
jmp 0x4940
jmp 0x49b7
cmpl $0x0, 0xde47(%rip)      # 0x127d0
jne 0x49ab
movl -0x4(%rbp), %esi
leaq 0xdf03(%rip), %rdi      # 0x12898
callq 0x5000
movq (%rax), %rsi
leaq 0x88f9(%rip), %rdi      # 0xd29d
callq 0x4850
jmp 0x49b5
movl $0x2, 0xd7bb(%rip)      # 0x12170
jmp 0x49b7
movq -0x20(%rbp), %rdi
callq 0x4190
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x4906
cmpl $0x0, 0xe2ab(%rip)      # 0x12c80
jne 0x49ea
leaq 0x8888(%rip), %rdi      # 0xd266
leaq 0x8880(%rip), %rsi      # 0xd265
callq 0x4850
addq $0x30, %rsp
popq %rbp
retq
// File: arnoldrobbins[P]mcilroy-regex/grep.cpp
// Function: docomp(char*)
void
docomp(char *s)
{
	if(re.assure(nre))
		error("out of space at--", s);
	int result = regcomp(&re[nre], s, options);
	if(result)
		doregerror(result, s, 0);
	if(!nre || !regcomb(&re[nre-1], &re[nre]))
		nre++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl 0xe08e(%rip), %esi      # 0x12c80
leaq 0xdd57(%rip), %rdi      # 0x12950
callq 0x5040
cmpl $0x0, %eax
je 0x4c13
movq -0x8(%rbp), %rsi
leaq 0x869b(%rip), %rdi      # 0xd2a9
callq 0x4850
movl 0xe067(%rip), %esi      # 0x12c80
leaq 0xdd30(%rip), %rdi      # 0x12950
callq 0x5080
movq %rax, %rdi
movq -0x8(%rbp), %rsi
movl 0xd542(%rip), %edx      # 0x12174
callq 0x9bb0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x4c4e
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rsi
xorl %edx, %edx
callq 0x4d80
cmpl $0x0, 0xe02b(%rip)      # 0x12c80
je 0x4c93
movl 0xe023(%rip), %esi      # 0x12c80
subl $0x1, %esi
leaq 0xdce9(%rip), %rdi      # 0x12950
callq 0x5080
movq %rax, -0x18(%rbp)
movl 0xe00a(%rip), %esi      # 0x12c80
leaq 0xdcd3(%rip), %rdi      # 0x12950
callq 0x5080
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0xa320
cmpl $0x0, %eax
jne 0x4ca2
movl 0xdfe7(%rip), %eax      # 0x12c80
addl $0x1, %eax
movl %eax, 0xdfde(%rip)      # 0x12c80
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: arnoldrobbins[P]mcilroy-regex/grep.cpp
// Function: getline(_IO_FILE*, char const*)
int
getline(FILE *input, const char *name)
{
	int c, j;
	for(j=0; ; j++) {
		if(line.assure(j))
			error("out of space reading ", name);
		switch(c = getc(input)) {
		default:
			line[j] = c;
			continue;
		case EOF:
			if(j == 0)
				return -1;
			warn("newline appended to ", name);
		case '\n':
			line[j] = 0;
			return j;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %esi
leaq 0xdfb7(%rip), %rdi      # 0x12c88
callq 0x50a0
cmpl $0x0, %eax
je 0x4ceb
movq -0x18(%rbp), %rsi
leaq 0x85d5(%rip), %rdi      # 0xd2bb
callq 0x4850
movq -0x10(%rbp), %rdi
callq 0x4090
movl %eax, -0x1c(%rbp)
movl %eax, %ecx
movl %ecx, -0x24(%rbp)
subl $-0x1, %eax
je 0x4d29
jmp 0x4d03
movl -0x24(%rbp), %eax
subl $0xa, %eax
je 0x4d48
jmp 0x4d0d
movl -0x1c(%rbp), %eax
movb %al, -0x25(%rbp)
movl -0x20(%rbp), %esi
leaq 0xdf6b(%rip), %rdi      # 0x12c88
callq 0x5020
movb -0x25(%rbp), %cl
movb %cl, (%rax)
jmp 0x4d62
cmpl $0x0, -0x20(%rbp)
jne 0x4d38
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4d70
movq -0x18(%rbp), %rsi
leaq 0x858e(%rip), %rdi      # 0xd2d1
callq 0x4e30
movl -0x20(%rbp), %esi
leaq 0xdf36(%rip), %rdi      # 0x12c88
callq 0x5020
movb $0x0, (%rax)
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x4d70
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x4cc7
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: arnoldrobbins[P]mcilroy-regex/grep.cpp
// Function: doregerror(int, char const*, int)
void
doregerror(int result, const char *name, int lineno)
{
	char errbuf[100];
	if(result==0 || result==REG_NOMATCH)
		return;
	regerror(result, 0, errbuf, sizeof(errbuf));
	fprintf(stderr, "grep: %s: %s", errbuf, name);
	if(lineno)
		fprintf(stderr, ":%d\n", lineno);
	else
		fprintf(stderr, "\n");
	exit(2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x4da1
cmpl $0x1, -0x4(%rbp)
jne 0x4daa
addq $0x80, %rsp
popq %rbp
retq
movl -0x4(%rbp), %edi
leaq -0x80(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
movl $0x64, %ecx
callq 0x40f0
movq 0xd212(%rip), %rax      # 0x11fd8
movq (%rax), %rdi
leaq -0x80(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0x8516(%rip), %rsi      # 0xd2ee
movb $0x0, %al
callq 0x4210
cmpl $0x0, -0x14(%rbp)
je 0x4e02
movq 0xd1ec(%rip), %rax      # 0x11fd8
movq (%rax), %rdi
movl -0x14(%rbp), %edx
leaq 0x8502(%rip), %rsi      # 0xd2fb
movb $0x0, %al
callq 0x4210
jmp 0x4e1a
movq 0xd1cf(%rip), %rax      # 0x11fd8
movq (%rax), %rdi
leaq 0x8451(%rip), %rsi      # 0xd264
movb $0x0, %al
callq 0x4210
movl $0x2, %edi
callq 0x41e0
nopw %cs:(%rax,%rax)
// File: ef-gy[P]libefgy/include/ef.gy/markov.h
// Function: efgy::markov::chain<char, 1u, std::mersenne_twister_engine<unsigned long, 32ul, 624ul, 397ul, 31ul, 2567483615ul, 11ul, 4294967295ul, 7ul, 2636928640ul, 15ul, 4022730752ul, 18ul, 1812433253ul>, unsigned long>::train(std::vector<char, std::allocator<char>> const&, unsigned long const&)
chain &train(const input &input, const counter &c) {
    memory m = std::accumulate(
        input.begin(), input.end(), memory(),
        [this, c](memory s, const T &v) -> memory {
          transitions[s][v] += c;

          std::transform(
              s.begin() + 1, s.end(), s.begin(),
              [](std::optional<T> &i) -> std::optional<T> { return i; });

          *(s.end() - 1) = v;

          return s;
        });

    transitions[m][std::optional<T>()]++;

    return *this;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x18ba0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x18bd0
movq %rax, -0x30(%rbp)
leaq -0x32(%rbp), %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x51c0
leaq -0x32(%rbp), %rdi
callq 0x35140
movq -0x58(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movw -0x32(%rbp), %ax
movq -0x48(%rbp), %rcx
movq -0x40(%rbp), %r8
movzwl %ax, %edx
callq 0x350c0
movq -0x58(%rbp), %rdi
movw %ax, -0x1a(%rbp)
addq $0x1388, %rdi           # imm = 0x1388
leaq -0x1a(%rbp), %rsi
callq 0x35190
movq %rax, -0x60(%rbp)
leaq -0x4a(%rbp), %rdi
callq 0x35350
movq -0x60(%rbp), %rdi
leaq -0x4a(%rbp), %rsi
callq 0x35270
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq (%rcx), %rdx
addq $0x1, %rdx
movq %rdx, (%rcx)
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: benjibc[P]json-universal-container/./json.h
// Function: JSON::operator=(JSON const&)
JSON & JSON::operator=(const JSON & rhs)
{
    this->clear();
    this->m_type = rhs.m_type;
    switch(m_type)
    {
        case type_array:
            new (&(m_data.u_arr)) Arr_t(rhs.m_data.u_arr);
            break;
        case type_obj:
            new (&(m_data.u_map)) Map_t(rhs.m_data.u_map);
            break;
        case type_str:
            new (&(m_data.u_str)) std::string(rhs.m_data.u_str);
            break;
        case type_double:
            m_data.u_double = rhs.m_data.u_double;
            break;
        default:
            m_data.u_bool = rhs.m_data.u_bool; 
            break;
    }
    return *this;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x58c0
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movl 0x28(%rcx), %ecx
movl %ecx, 0x28(%rax)
movl 0x28(%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, 0x10(%rsp)
subl $0x3, %eax
ja 0x366a
movq 0x10(%rsp), %rax
leaq 0xe9ea(%rip), %rcx      # 0x12004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x5920
jmp 0x367b
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x59e0
jmp 0x367b
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x30f0
jmp 0x367b
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movsd (%rcx), %xmm0
movsd %xmm0, (%rax)
jmp 0x367b
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movb (%rcx), %cl
andb $0x1, %cl
movb %cl, (%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: benjibc[P]json-universal-container/jsonUnitTest.cpp
// Function: populate(JSON&)
void populate(JSON & rhs)
{
    JSON data;
    data["id"] = 15;
    data["secondID"] = getAJSON();
    data["name"](false);
    dummyFunc(data);
    data["person"][0]["name"] = "Benny";
    data["person"][0]["id"] = 3294;
    data["person"][1]["name"] = "Cunpu";
    data["person"][1]["id"] = 321312;
    rhs = data;
}

// Assembly:
subq $0xf8, %rsp
movq %rdi, 0xf0(%rsp)
leaq 0xc0(%rsp), %rdi
movq %rdi, 0x70(%rsp)
callq 0x5890
movq 0x70(%rsp), %rdi
leaq 0xe3c2(%rip), %rsi      # 0x1349f
callq 0x6180
movq %rax, 0x78(%rsp)
jmp 0x50e9
movq 0x78(%rsp), %rdi
movl $0xf, %esi
callq 0x65e0
jmp 0x50fa
leaq 0x80(%rsp), %rdi
callq 0x5080
jmp 0x5109
leaq 0xd098(%rip), %rsi      # 0x121a8
leaq 0xc0(%rsp), %rdi
callq 0x6180
movq %rax, 0x68(%rsp)
jmp 0x5124
movq 0x68(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x6630
jmp 0x5138
leaq 0x80(%rsp), %rdi
callq 0x5c80
leaq 0xd065(%rip), %rsi      # 0x121b1
leaq 0xc0(%rsp), %rdi
callq 0x6180
movq %rax, 0x60(%rsp)
jmp 0x5160
movq 0x60(%rsp), %rdi
xorl %esi, %esi
callq 0x3690
jmp 0x516e
leaq 0xc0(%rsp), %rdi
callq 0x5050
jmp 0x517d
leaq 0xd038(%rip), %rsi      # 0x121bc
leaq 0xc0(%rsp), %rdi
callq 0x6180
movq %rax, 0x58(%rsp)
jmp 0x5198
movq 0x58(%rsp), %rdi
xorl %esi, %esi
callq 0x66a0
movq %rax, 0x50(%rsp)
jmp 0x51ab
movq 0x50(%rsp), %rdi
leaq 0xcffa(%rip), %rsi      # 0x121b1
callq 0x6180
movq %rax, 0x48(%rsp)
jmp 0x51c3
movq 0x48(%rsp), %rdi
leaq 0xcfe7(%rip), %rsi      # 0x121b6
callq 0x6500
jmp 0x51d6
leaq 0xcfdf(%rip), %rsi      # 0x121bc
leaq 0xc0(%rsp), %rdi
callq 0x6180
movq %rax, 0x40(%rsp)
jmp 0x51f1
movq 0x40(%rsp), %rdi
xorl %esi, %esi
callq 0x66a0
movq %rax, 0x38(%rsp)
jmp 0x5204
movq 0x38(%rsp), %rdi
leaq 0xe28f(%rip), %rsi      # 0x1349f
callq 0x6180
movq %rax, 0x30(%rsp)
jmp 0x521c
movq 0x30(%rsp), %rdi
movl $0xcde, %esi            # imm = 0xCDE
callq 0x65e0
jmp 0x522d
leaq 0xcf88(%rip), %rsi      # 0x121bc
leaq 0xc0(%rsp), %rdi
callq 0x6180
movq %rax, 0x28(%rsp)
jmp 0x5248
movq 0x28(%rsp), %rdi
movl $0x1, %esi
callq 0x66a0
movq %rax, 0x20(%rsp)
jmp 0x525e
movq 0x20(%rsp), %rdi
leaq 0xcf47(%rip), %rsi      # 0x121b1
callq 0x6180
movq %rax, 0x18(%rsp)
jmp 0x5276
movq 0x18(%rsp), %rdi
leaq 0xcf41(%rip), %rsi      # 0x121c3
callq 0x6500
jmp 0x5289
leaq 0xcf2c(%rip), %rsi      # 0x121bc
leaq 0xc0(%rsp), %rdi
callq 0x6180
movq %rax, 0x10(%rsp)
jmp 0x52a4
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x66a0
movq %rax, 0x8(%rsp)
jmp 0x52ba
movq 0x8(%rsp), %rdi
leaq 0xe1d9(%rip), %rsi      # 0x1349f
callq 0x6180
movq %rax, (%rsp)
jmp 0x52d1
movq (%rsp), %rdi
movl $0x4e720, %esi          # imm = 0x4E720
callq 0x65e0
jmp 0x52e1
movq 0xf0(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0x35d0
jmp 0x52f8
leaq 0xc0(%rsp), %rdi
callq 0x5c80
addq $0xf8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
jmp 0x5344
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x5c80
leaq 0xc0(%rsp), %rdi
callq 0x5c80
movq 0xb8(%rsp), %rdi
callq 0x33e0
nop
// File: benjibc[P]json-universal-container/./json.h
// Function: JSON::clear()
inline
void JSON::clear()
{
    switch(m_type)
    {
        case type_array:
            m_data.u_arr.~Arr_t();
            break;
        case type_obj:
            m_data.u_map.~Map_t();
            break; 
        case type_str:
            m_data.u_str.~string();
            break;
        default:
            break;
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movl 0x28(%rax), %eax
movl %eax, 0xc(%rsp)
subl $0x1, %eax
je 0x590c
jmp 0x58e0
movl 0xc(%rsp), %eax
subl $0x2, %eax
je 0x5901
jmp 0x58eb
movl 0xc(%rsp), %eax
subl $0x3, %eax
jne 0x5917
jmp 0x58f6
movq (%rsp), %rdi
callq 0x6170
jmp 0x5919
movq (%rsp), %rdi
callq 0x60e0
jmp 0x5919
movq (%rsp), %rdi
callq 0x3150
jmp 0x5919
jmp 0x5919
addq $0x18, %rsp
retq
nop
// File: benjibc[P]json-universal-container/./json.h
// Function: JSON::push_back(JSON)
inline
void JSON::push_back(JSON rhs)
{
    if(m_type == type_array)
        m_data.u_arr.push_back(rhs);
    else
        throw JSONOperationException();
}

// Assembly:
subq $0x68, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpl $0x3, 0x28(%rax)
jne 0x5b57
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdi
callq 0x83b0
jmp 0x5c05
movb $0x1, 0x23(%rsp)
movl $0x28, %edi
callq 0x3110
movq %rax, (%rsp)
leaq 0x37(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x33f0
movq 0x8(%rsp), %rdx
leaq 0xc846(%rip), %rsi      # 0x123cb
leaq 0x38(%rsp), %rdi
callq 0x3340
jmp 0x5b91
movq (%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x83e0
jmp 0x5ba1
movq (%rsp), %rdi
movb $0x0, 0x23(%rsp)
leaq 0x14057(%rip), %rsi     # 0x19c08
leaq 0x2898(%rip), %rdx      # 0x8450
callq 0x33c0
jmp 0x5c14
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x5be7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x3150
leaq 0x37(%rsp), %rdi
callq 0x32c0
testb $0x1, 0x23(%rsp)
jne 0x5bfa
jmp 0x5c03
movq (%rsp), %rdi
callq 0x31b0
jmp 0x5c0a
addq $0x68, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x33e0
nopw %cs:(%rax,%rax)
nop
// File: benjibc[P]json-universal-container/./json.h
// Function: JSON::~JSON()
inline
JSON::~JSON()
{
    switch(m_type)
    {
        case type_str:
            m_data.u_str.~string();
            break;
        case type_array:
            m_data.u_arr.~Arr_t();
            break;
        case type_obj:
            m_data.u_map.~Map_t();
            break;
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movl 0x28(%rax), %eax
movl %eax, 0xc(%rsp)
subl $0x1, %eax
je 0x5cb6
jmp 0x5ca0
movl 0xc(%rsp), %eax
subl $0x2, %eax
je 0x5ccc
jmp 0x5cab
movl 0xc(%rsp), %eax
subl $0x3, %eax
je 0x5cc1
jmp 0x5cd5
movq (%rsp), %rdi
callq 0x3150
jmp 0x5cd5
movq (%rsp), %rdi
callq 0x6170
jmp 0x5cd5
movq (%rsp), %rdi
callq 0x60e0
movq (%rsp), %rdi
callq 0xb130
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: benjibc[P]json-universal-container/./json.h
// Function: JSON::push_back(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, JSON&)
inline
void JSON::push_back(const string & key, JSON & rhs)
{
    if(m_type == type_obj)
        m_data.u_map[key] = rhs;
    else
        throw JSONOperationException();
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpl $0x2, 0x28(%rax)
jne 0x5d3e
movq 0x20(%rsp), %rdi
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x68(%rsp), %rsi
callq 0xb140
movq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x35d0
jmp 0x5df0
movb $0x1, 0x2b(%rsp)
movl $0x28, %edi
callq 0x3110
movq %rax, 0x8(%rsp)
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x33f0
movq 0x10(%rsp), %rdx
leaq 0xc65e(%rip), %rsi      # 0x123cb
leaq 0x40(%rsp), %rdi
callq 0x3340
jmp 0x5d79
movq 0x8(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x83e0
jmp 0x5d8a
movq 0x8(%rsp), %rdi
movb $0x0, 0x2b(%rsp)
leaq 0x13e6d(%rip), %rsi     # 0x19c08
leaq 0x26ae(%rip), %rdx      # 0x8450
callq 0x33c0
jmp 0x5dff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x5dd1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x3150
leaq 0x3f(%rsp), %rdi
callq 0x32c0
testb $0x1, 0x2b(%rsp)
jne 0x5de4
jmp 0x5dee
movq 0x8(%rsp), %rdi
callq 0x31b0
jmp 0x5df5
addq $0x78, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x33e0
nop
// File: benjibc[P]json-universal-container/./json.h
// Function: JSON::operator=(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
inline
JSON & JSON::operator=(std::string & content)
{
    if(this->m_type != type_str)
    {
        this->clear();
        this->m_type = type_str;
    }
    new (&(m_data.u_str)) std::string(content);
    return *this;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpl $0x1, 0x28(%rax)
je 0x5e31
movq (%rsp), %rdi
callq 0x58c0
movq (%rsp), %rax
movl $0x1, 0x28(%rax)
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x30f0
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: benjibc[P]json-universal-container/./json.h
// Function: JSON::operator=(double)
inline
JSON & JSON::operator=(double u_double)
{
    if(m_type != type_double)
    {
        this->clear();
        this->m_type = type_double;
    }
    this->m_data.u_double = u_double;
    return *this;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpl $0x4, 0x28(%rax)
je 0x5ec2
movq (%rsp), %rdi
callq 0x58c0
movq (%rsp), %rax
movl $0x4, 0x28(%rax)
movq (%rsp), %rax
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: benjibc[P]json-universal-container/./json.h
// Function: JSON::JSON(JSON const&)
inline
JSON::JSON(const JSON & rhs)
{
    this->m_type = rhs.m_type;
    switch(m_type)
    {
        // for classes that copies memory dynamically, make a deep copy
        // using placement new instead of using memcpy otherwise things will
        // be deallocated as expected when the last object dies
        case type_array:
            new (&(m_data.u_arr)) Arr_t(rhs.m_data.u_arr);
            break;
        case type_obj:
            new (&(m_data.u_map)) Map_t(rhs.m_data.u_map);
            break;
        case type_str:
            new (&(m_data.u_str)) std::string(rhs.m_data.u_str);
            break;
        case type_double:
            m_data.u_double = rhs.m_data.u_double;
            break;
        default:
            m_data.u_bool = rhs.m_data.u_bool; 
            break;
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, (%rsp)
callq 0x8220
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
movl 0x28(%rcx), %ecx
movl %ecx, 0x28(%rax)
movl 0x28(%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, 0x10(%rsp)
subl $0x3, %eax
ja 0x5f9d
movq 0x10(%rsp), %rax
leaq 0xc0e7(%rip), %rcx      # 0x12018
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x5920
jmp 0x5f4a
jmp 0x5fad
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0xb130
jmp 0x5fb2
movq (%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x59e0
jmp 0x5f76
jmp 0x5fad
movq (%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x30f0
jmp 0x5f88
jmp 0x5fad
movq (%rsp), %rax
movq 0x28(%rsp), %rcx
movsd (%rcx), %xmm0
movsd %xmm0, (%rax)
jmp 0x5fad
movq (%rsp), %rax
movq 0x28(%rsp), %rcx
movb (%rcx), %cl
andb $0x1, %cl
movb %cl, (%rax)
addq $0x38, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x33e0
nopl (%rax)
// File: benjibc[P]json-universal-container/./json.h
// Function: JSON::operator=(char const*)
inline
JSON & JSON::operator=(const char * content)
{
    if(this->m_type != type_str)
    {
        this->clear();
        this->m_type = type_str;
    }
    new (&(m_data.u_str)) std::string(content);
    return *this;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpl $0x1, 0x28(%rax)
je 0x6534
movq 0x18(%rsp), %rdi
callq 0x58c0
movq 0x18(%rsp), %rax
movl $0x1, 0x28(%rax)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x37(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x33f0
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x3340
jmp 0x6563
leaq 0x37(%rsp), %rdi
callq 0x32c0
movq 0x18(%rsp), %rax
addq $0x48, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x37(%rsp), %rdi
callq 0x32c0
movq 0x28(%rsp), %rdi
callq 0x33e0
nopl (%rax)
// File: benjibc[P]json-universal-container/./json.h
// Function: JSON::operator=(int)
inline
JSON & JSON::operator=(int u_int)
{
    if(m_type != type_double)
    {
        this->clear();
        this->m_type = type_double;
    }
    this->m_data.u_double = u_int;
    return *this;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpl $0x4, 0x28(%rax)
je 0x6610
movq (%rsp), %rdi
callq 0x58c0
movq (%rsp), %rax
movl $0x4, 0x28(%rax)
movq (%rsp), %rax
cvtsi2sdl 0xc(%rsp), %xmm0
movsd %xmm0, (%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: benjibc[P]json-universal-container/./json.h
// Function: JSON::operator=(JSON&&)
inline
JSON & JSON::operator=(JSON && rhs)
{
    // make sure it is not itself
    if(this!= &rhs)
    {
        //clear all current content;
        this->clear();
        //copy the resource over
        memcpy(&m_data, &(rhs.m_data), sizeof(m_data)); 
        m_type = rhs.m_type;
        // set the rhs data to zero
        memset(&(rhs.m_data), 0, sizeof(rhs.m_data));
        rhs.m_type = no_type;
    }
    return *this;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq 0x8(%rsp), %rax
je 0x6696
movq (%rsp), %rdi
callq 0x58c0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x28, %edx
callq 0x31f0
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movl 0x28(%rcx), %ecx
movl %ecx, 0x28(%rax)
movq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x3120
movq 0x8(%rsp), %rax
movl $0x0, 0x28(%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: benjibc[P]json-universal-container/./json.h
// Function: JSON::operator[](int)
inline
JSON & JSON::operator[](int i)
{
    //turn itself into an array 
    if(m_type != type_array)
    {
        this->clear();
        m_type = type_array;
        new (&(m_data.u_arr)) Arr_t(); 
    }
    //need to return the element at the given index
    int arrayOldSize = m_data.u_arr.size(); 
    //make sure the size of the arrray is big enough 
    if(i >= arrayOldSize) 
    {
        Arr_t append ( i-arrayOldSize +1);
        m_data.u_arr.insert(m_data.u_arr.end(),append.begin(),append.end()); 
    }
    return m_data.u_arr[i];
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movl %esi, 0x5c(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x3, 0x28(%rax)
je 0x66d8
movq 0x8(%rsp), %rdi
callq 0x58c0
movq 0x8(%rsp), %rdi
movl $0x3, 0x28(%rdi)
callq 0x6100
movq 0x8(%rsp), %rdi
callq 0xda20
movl %eax, 0x58(%rsp)
movl 0x5c(%rsp), %eax
cmpl 0x58(%rsp), %eax
jl 0x6787
movl 0x5c(%rsp), %eax
movl 0x58(%rsp), %ecx
subl %ecx, %eax
incl %eax
movslq %eax, %rsi
leaq 0x40(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xda30
movq 0x8(%rsp), %rdi
callq 0xdc30
movq (%rsp), %rdi
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x38(%rsp)
callq 0xdc70
movq (%rsp), %rdi
movq %rax, 0x28(%rsp)
callq 0xdc30
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
callq 0xdbd0
jmp 0x6761
leaq 0x40(%rsp), %rdi
callq 0x6170
jmp 0x6787
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x6170
jmp 0x679b
movq 0x8(%rsp), %rdi
movslq 0x5c(%rsp), %rsi
callq 0xdca0
addq $0x68, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x33e0
nopw %cs:(%rax,%rax)
nop
// File: benjibc[P]json-universal-container/./json.h
// Function: JSON::operator int() const
inline
JSON::operator int()const
{
    switch(m_type)
    {
        case type_double:
            return (int)m_data.u_double;
        case type_bool:
            return (int)m_data.u_bool;
    }
    throw JSONOperationException("Not an int type");
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x28(%rax), %eax
movl %eax, 0x1c(%rsp)
subl $0x4, %eax
je 0x67dc
jmp 0x67d1
movl 0x1c(%rsp), %eax
subl $0x5, %eax
je 0x67ee
jmp 0x6803
movq 0x10(%rsp), %rax
cvttsd2si (%rax), %eax
movl %eax, 0x64(%rsp)
jmp 0x68b1
movq 0x10(%rsp), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x64(%rsp)
jmp 0x68b1
movb $0x1, 0x23(%rsp)
movl $0x28, %edi
callq 0x3110
movq %rax, (%rsp)
leaq 0x37(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x33f0
movq 0x8(%rsp), %rdx
leaq 0xcbef(%rip), %rsi      # 0x13420
leaq 0x38(%rsp), %rdi
callq 0x3340
jmp 0x683d
movq (%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x83e0
jmp 0x684d
movq (%rsp), %rdi
movb $0x0, 0x23(%rsp)
leaq 0x133ab(%rip), %rsi     # 0x19c08
leaq 0x1bec(%rip), %rdx      # 0x8450
callq 0x33c0
jmp 0x68c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x6893
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x3150
leaq 0x37(%rsp), %rdi
callq 0x32c0
testb $0x1, 0x23(%rsp)
jne 0x68a6
jmp 0x68af
movq (%rsp), %rdi
callq 0x31b0
jmp 0x68ba
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x33e0
nopw %cs:(%rax,%rax)
nop
// File: benjibc[P]json-universal-container/./json.h
// Function: JSONSyntaxError::what() const
const virtual char * what () const throw() { 
        if(pos == -1)
            return message.c_str(); 
        else
            return string(message.c_str() + JSONString.substr(pos, 30)).c_str();
    }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpl $-0x1, 0x28(%rax)
jne 0x82b1
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0x30e0
movq %rax, 0x70(%rsp)
jmp 0x8355
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0x30e0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rsp)
movq %rax, %rsi
addq $0x30, %rsi
movslq 0x28(%rax), %rdx
leaq 0x28(%rsp), %rdi
movl $0x1e, %ecx
callq 0x3280
jmp 0x82e8
movq 0x8(%rsp), %rsi
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x8360
jmp 0x82fe
leaq 0x48(%rsp), %rdi
callq 0x30e0
movq %rax, 0x70(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x3150
leaq 0x28(%rsp), %rdi
callq 0x3150
jmp 0x8355
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x834b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x3150
movq 0x20(%rsp), %rdi
callq 0x3310
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
nop
// File: benjibc[P]json-universal-container/./boost_file/boost/container/vector.hpp
// Function: void boost::container::vector<JSON, std::allocator<JSON>>::priv_push_back<JSON const&>(JSON const&)
void priv_push_back(BOOST_MOVE_CATCH_FWD(U) x)
   {
      if (this->members_.m_size < this->members_.m_capacity){
         //There is more memory, just construct a new object at the end
         allocator_traits_type::construct
            ( this->alloc()
            , container_detail::to_raw_pointer(this->members_.m_start + this->members_.m_size)
            , ::boost::forward<U>(x) );
         ++this->members_.m_size;
      }
      else{
         this->insert(this->cend(), ::boost::forward<U>(x));
      }
   }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movq 0x8(%rcx), %rax
cmpq 0x10(%rcx), %rax
jae 0x850f
movq 0x10(%rsp), %rdi
callq 0x85a0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rsp)
movq (%rax), %rdi
imulq $0x30, 0x8(%rax), %rax
addq %rax, %rdi
callq 0x85b0
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x85c0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0x8550
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
jmp 0x8543
movq 0x10(%rsp), %rdi
callq 0x8610
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x85c0
movq 0x10(%rsp), %rdi
movq %rax, %rdx
movq 0x20(%rsp), %rsi
callq 0x85d0
movq %rax, 0x18(%rsp)
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: benjibc[P]json-universal-container/./boost_file/boost/container/vector.hpp
// Function: void boost::container::vector<JSON, std::allocator<JSON>>::priv_range_insert<boost::container::constant_iterator<JSON, long>>(boost::container::container_detail::vector_const_iterator<JSON*>, boost::container::constant_iterator<JSON, long>, boost::container::constant_iterator<JSON, long>, std::forward_iterator_tag)
void priv_range_insert(const_iterator pos, FwdIt first, FwdIt last, std::forward_iterator_tag)
   {
      if(first != last){       
         const size_type n = std::distance(first, last);
         container_detail::advanced_insert_aux_proxy<A, FwdIt, T*> proxy(this->alloc(), first, last);
         priv_range_insert(pos.get_ptr(), n, proxy);
      }
   }

// Assembly:
subq $0xd8, %rsp
movq %rsi, 0xd0(%rsp)
movq %rdx, 0xc0(%rsp)
movq %rcx, 0xc8(%rsp)
movq %r8, 0xb0(%rsp)
movq %r9, 0xb8(%rsp)
movq %rdi, 0xa0(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0xc0(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x8b70
testb $0x1, %al
jne 0x8a72
jmp 0x8b51
movups 0xc0(%rsp), %xmm0
movaps %xmm0, 0x80(%rsp)
movups 0xb0(%rsp), %xmm0
movaps %xmm0, 0x70(%rsp)
movq 0x80(%rsp), %rdi
movq 0x88(%rsp), %rsi
movq 0x70(%rsp), %rdx
movq 0x78(%rsp), %rcx
callq 0x8ba0
movq 0x8(%rsp), %rdi
movq %rax, 0x98(%rsp)
callq 0x85a0
movq %rax, %rsi
movups 0xc0(%rsp), %xmm0
movaps %xmm0, 0x30(%rsp)
movups 0xb0(%rsp), %xmm0
movaps %xmm0, 0x20(%rsp)
movq 0x30(%rsp), %rdx
movq 0x38(%rsp), %rcx
movq 0x20(%rsp), %r8
movq 0x28(%rsp), %r9
leaq 0x40(%rsp), %rdi
callq 0x8c10
leaq 0xd0(%rsp), %rdi
callq 0x8ea0
movq %rax, (%rsp)
jmp 0x8b0e
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
movq 0x98(%rsp), %rdx
leaq 0x40(%rsp), %rcx
callq 0x8c90
jmp 0x8b2b
leaq 0x40(%rsp), %rdi
callq 0x8eb0
jmp 0x8b51
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x8eb0
jmp 0x8b59
addq $0xd8, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x33e0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: benjibc[P]json-universal-container/./boost_file/boost/container/detail/advanced_insert_int.hpp
// Function: boost::container::container_detail::advanced_insert_aux_proxy<std::allocator<JSON>, boost::container::constant_iterator<JSON, long>, JSON*>::uninitialized_copy_some_and_update(JSON*, long, bool)
virtual void uninitialized_copy_some_and_update(Iterator pos, difference_type division_count, bool first_n)
   {
      FwdIt mid = this->first_;
      std::advance(mid, division_count);
      if(first_n){
         ::boost::container::uninitialized_copy_or_move_alloc(this->a_, this->first_, mid, pos);
         this->first_ = mid;
      }
      else{
         ::boost::container::uninitialized_copy_or_move_alloc(this->a_, mid, this->last_, pos);
         this->last_ = mid;
      }
   }

// Assembly:
subq $0x88, %rsp
movb %cl, %al
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
andb $0x1, %al
movb %al, 0x6f(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x58(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x60(%rsp)
movq 0x70(%rsp), %rsi
leaq 0x58(%rsp), %rdi
callq 0x9860
testb $0x1, 0x6f(%rsp)
je 0x9166
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rax), %rcx
movq %rcx, 0x48(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x78(%rsp), %r9
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x38(%rsp), %rcx
movq 0x40(%rsp), %r8
xorl %eax, %eax
movq $0x0, (%rsp)
callq 0x9750
movq 0x10(%rsp), %rax
movq 0x58(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x60(%rsp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x91d4
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x58(%rsp), %rcx
movq %rcx, 0x28(%rsp)
movq 0x60(%rsp), %rcx
movq %rcx, 0x30(%rsp)
movq 0x20(%rax), %rcx
movq %rcx, 0x18(%rsp)
movq 0x28(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x78(%rsp), %r9
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %r8
xorl %eax, %eax
movq $0x0, (%rsp)
callq 0x9750
movq 0x10(%rsp), %rax
movq 0x58(%rsp), %rcx
movq %rcx, 0x20(%rax)
movq 0x60(%rsp), %rcx
movq %rcx, 0x28(%rax)
addq $0x88, %rsp
retq
nopl (%rax)
// File: benjibc[P]json-universal-container/./boost_file/boost/container/detail/advanced_insert_int.hpp
// Function: boost::container::container_detail::advanced_insert_aux_proxy<std::allocator<JSON>, boost::container::constant_iterator<JSON, long>, JSON*>::copy_some_and_update(JSON*, long, bool)
virtual void copy_some_and_update(Iterator pos, difference_type division_count, bool first_n)
   {
      FwdIt mid = this->first_;
      std::advance(mid, division_count);
      if(first_n){
         ::boost::copy_or_move(this->first_, mid, pos);
         this->first_ = mid;
      }
      else{
         ::boost::copy_or_move(mid, this->last_, pos);
         this->last_ = mid;
      }
   }

// Assembly:
subq $0x78, %rsp
movb %cl, %al
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
andb $0x1, %al
movb %al, 0x5f(%rsp)
movq 0x70(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x48(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x60(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x9860
testb $0x1, 0x5f(%rsp)
je 0x9291
movq (%rsp), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0x38(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x68(%rsp), %r8
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rcx
xorl %eax, %eax
movl %eax, %r9d
callq 0x9350
movq (%rsp), %rax
movq 0x48(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x50(%rsp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x92f4
movq (%rsp), %rax
movq 0x48(%rsp), %rcx
movq %rcx, 0x18(%rsp)
movq 0x50(%rsp), %rcx
movq %rcx, 0x20(%rsp)
movq 0x20(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x28(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x68(%rsp), %r8
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
xorl %eax, %eax
movl %eax, %r9d
callq 0x9350
movq (%rsp), %rax
movq 0x48(%rsp), %rcx
movq %rcx, 0x20(%rax)
movq 0x50(%rsp), %rcx
movq %rcx, 0x28(%rax)
addq $0x78, %rsp
retq
nopl (%rax)
// File: benjibc[P]json-universal-container/./boost_file/boost/container/detail/utilities.hpp
// Function: JSON* boost::container::uninitialized_copy_alloc<std::allocator<JSON>, boost::container::constant_iterator<JSON, long>, JSON*>(std::allocator<JSON>&, boost::container::constant_iterator<JSON, long>, boost::container::constant_iterator<JSON, long>, JSON*)
F uninitialized_copy_alloc(A &a, I f, I l, F r)
{
   while (f != l) {
      allocator_traits<A>::construct(a, container_detail::to_raw_pointer(&*r), *f);
      ++f; ++r;
   }
   return r;
}

// Assembly:
subq $0x48, %rsp
movq %rsi, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x30(%rsp)
movq %rdi, 0x20(%rsp)
movq %r9, 0x18(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x8b70
testb $0x1, %al
jne 0x9807
jmp 0x9856
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x85b0
movq %rax, 0x10(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x96e0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0x8550
leaq 0x38(%rsp), %rdi
callq 0x96f0
movq 0x18(%rsp), %rax
addq $0x30, %rax
movq %rax, 0x18(%rsp)
jmp 0x97f2
movq 0x18(%rsp), %rax
addq $0x48, %rsp
retq
// File: benjibc[P]json-universal-container/./boost_file/boost/container/detail/utilities.hpp
// Function: unsigned long boost::container::container_detail::get_next_capacity<unsigned long>(unsigned long, unsigned long, unsigned long)
SizeType
   get_next_capacity(const SizeType max_size
                    ,const SizeType capacity
                    ,const SizeType n)
{
//   if (n > max_size - capacity)
//      throw std::length_error("get_next_capacity");

   const SizeType m3 = max_size/3;

   if (capacity < m3)
      return capacity + max_value(3*(capacity+1)/5, n);

   if (capacity < m3*2)
      return capacity + max_value((capacity+1)/2, n);

   return max_size;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rax
movl $0x3, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0xa89a
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
addq $0x1, %rax
imulq $0x3, %rax, %rax
movl $0x5, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xa930
movq %rax, %rcx
movq 0x8(%rsp), %rax
addq (%rcx), %rax
movq %rax, 0x40(%rsp)
jmp 0xa8f0
movq 0x30(%rsp), %rax
movq 0x20(%rsp), %rcx
shlq %rcx
cmpq %rcx, %rax
jae 0xa8e6
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rax
addq $0x1, %rax
shrq %rax
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xa930
movq %rax, %rcx
movq (%rsp), %rax
addq (%rcx), %rax
movq %rax, 0x40(%rsp)
jmp 0xa8f0
movq 0x38(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: benjibc[P]json-universal-container/./boost_file/boost/container/vector.hpp
// Function: boost::container::container_detail::vector_alloc_holder<std::allocator<JSON>>::allocation_command(int, unsigned long, unsigned long, unsigned long&, JSON* const&, boost::container::container_detail::integral_constant<unsigned int, 1u>)
std::pair<pointer, bool>
      allocation_command(allocation_type command,
                         size_type limit_size,
                         size_type preferred_size,
                         size_type &received_size,
                         const pointer &reuse,
                         allocator_v1)
   {
      (void)limit_size;
      (void)reuse;
      if(!(command & allocate_new))
         return std::pair<pointer, bool>(pointer(0), false);
      received_size = preferred_size;
      return std::make_pair(this->alloc().allocate(received_size), false);
   }

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x68(%rsp)
movl %esi, 0x64(%rsp)
movq %rdx, 0x58(%rsp)
movq %rcx, 0x50(%rsp)
movq %r8, 0x48(%rsp)
movq %r9, 0x40(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x64(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0xaa0e
movq $0x0, 0x38(%rsp)
movb $0x0, 0x37(%rsp)
leaq 0x78(%rsp), %rdi
leaq 0x38(%rsp), %rsi
leaq 0x37(%rsp), %rdx
callq 0xaa90
jmp 0xaa70
movq 0x8(%rsp), %rdi
movq 0x50(%rsp), %rcx
movq 0x48(%rsp), %rax
movq %rcx, (%rax)
callq 0x85a0
movq %rax, %rdi
movq 0x48(%rsp), %rax
movq (%rax), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xaaf0
movq %rax, 0x28(%rsp)
movb $0x0, 0x27(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x27(%rsp), %rsi
callq 0xaac0
movb %dl, 0x18(%rsp)
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x78(%rsp)
movb 0x18(%rsp), %al
movb %al, 0x80(%rsp)
movq 0x78(%rsp), %rax
movb 0x80(%rsp), %dl
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: benjibc[P]json-universal-container/./boost_file/boost/container/detail/utilities.hpp
// Function: JSON* boost::container::uninitialized_move_alloc<std::allocator<JSON>, JSON*, JSON*>(std::allocator<JSON>&, JSON*, JSON*, JSON*)
F uninitialized_move_alloc(A &a, I f, I l, F r)
{
   while (f != l) {
      allocator_traits<A>::construct(a, container_detail::to_raw_pointer(&*r), boost::move(*f));
      ++f; ++r;
   }
   return r;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x20(%rsp), %rax
je 0xabc7
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x85b0
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0xac90
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0xac40
movq 0x28(%rsp), %rax
addq $0x30, %rax
movq %rax, 0x28(%rsp)
movq 0x18(%rsp), %rax
addq $0x30, %rax
movq %rax, 0x18(%rsp)
jmp 0xab68
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: benjibc[P]json-universal-container/./boost_file/boost/move/move.hpp
// Function: JSON* boost::move_backward<JSON*, JSON*>(JSON*, JSON*, JSON*)
O move_backward(I f, I l, O result)
   {
      while (f != l) {
         --l; --result;
         *result = ::boost::move(*l);
      }
      return result;
   }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
je 0xac30
movq 0x8(%rsp), %rax
addq $-0x30, %rax
movq %rax, 0x8(%rsp)
movq (%rsp), %rax
addq $-0x30, %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
callq 0xac90
movq %rax, %rsi
movq (%rsp), %rdi
callq 0x6630
jmp 0xabf2
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)