LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: danfai[P]dboc/parser.cpp
// Function: Parser::getType(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Field::Type Parser::getType(std::string token)
{
    switch(token.at(0)) {
        case 'b': return Field::b;
        case 'c': return Field::c;
        case 'd': return Field::d;
        case 'e': return Field::e;
        case 'f': return Field::f;
        case 'i': return Field::i;
        case 'l': return Field::l;
        case 'p': return Field::p;
        default:
                  if(token == "ss")
                      return Field::ss;
                  else if(token == "Wdt")
                      return Field::Wdt;
                  else if(token == "Ws")
                      return Field::Ws;
    }
    return Field::INVALID;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, %rax
movq -0x30(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x3410
movsbl (%rax), %eax
addl $-0x62, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0xe, %eax
ja 0x4b34
movq -0x20(%rbp), %rax
leaq 0x46c8(%rip), %rcx      # 0x919c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0x4(%rbp)
jmp 0x4b9e
movl $0x1, -0x4(%rbp)
jmp 0x4b9e
movl $0x2, -0x4(%rbp)
jmp 0x4b9e
movl $0x3, -0x4(%rbp)
jmp 0x4b9e
movl $0x4, -0x4(%rbp)
jmp 0x4b9e
movl $0x5, -0x4(%rbp)
jmp 0x4b9e
movl $0x6, -0x4(%rbp)
jmp 0x4b9e
movl $0x7, -0x4(%rbp)
jmp 0x4b9e
movq -0x28(%rbp), %rdi
leaq 0x4727(%rip), %rsi      # 0x9266
callq 0x5700
testb $0x1, %al
jne 0x4b4a
jmp 0x4b53
movl $0x8, -0x4(%rbp)
jmp 0x4b9e
movq -0x28(%rbp), %rdi
leaq 0x470b(%rip), %rsi      # 0x9269
callq 0x5700
testb $0x1, %al
jne 0x4b69
jmp 0x4b72
movl $0x9, -0x4(%rbp)
jmp 0x4b9e
movq -0x28(%rbp), %rdi
leaq 0x46f0(%rip), %rsi      # 0x926d
callq 0x5700
testb $0x1, %al
jne 0x4b88
jmp 0x4b91
movl $0xa, -0x4(%rbp)
jmp 0x4b9e
jmp 0x4b93
jmp 0x4b95
jmp 0x4b97
movl $0xb, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Juve45[P]batstat/main.cpp
// Function: checkdir(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool checkdir(string str) {
	DIR* dir = opendir(str.c_str());
	if (dir) {
		closedir(dir);
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
callq 0x4180
movq %rax, %rdi
callq 0x4520
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4b83
movq -0x18(%rbp), %rdi
callq 0x4570
movb $0x1, -0x1(%rbp)
jmp 0x4b87
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Juve45[P]batstat/main.cpp
// Function: refreshValues()
void refreshValues()
{		
	auto batInit = getBatteryInfo();
	currentEnergy = batInit.energy;
	currentPower = batInit.power;

	ifstream st(Path + "status");
	timeNow = time(NULL);
	//timeElapsed = timeElapsed + timeNow - lastTime;
	timeElapsed += refreshRate;
	lastTime = timeNow;
	st >> status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp            # imm = 0x250
callq 0x4ba0
movlpd %xmm0, -0x8(%rbp)
movss -0x4(%rbp), %xmm0
movss %xmm0, 0x36c86(%rip)    # 0x3c3e8
movss -0x8(%rbp), %xmm0
movss %xmm0, 0x36c75(%rip)    # 0x3c3e4
leaq 0x36c92(%rip), %rsi     # 0x3c408
leaq 0x224e0(%rip), %rdx     # 0x27c5d
leaq -0x230(%rbp), %rdi
movq %rdi, -0x248(%rbp)
callq 0x61e0
movq -0x248(%rbp), %rsi
leaq -0x210(%rbp), %rdi
movl $0x8, %edx
callq 0x4580
jmp 0x57aa
leaq -0x230(%rbp), %rdi
callq 0x46a8
xorl %eax, %eax
movl %eax, %edi
callq 0x4370
movl %eax, 0x36c33(%rip)     # 0x3c3f8
movl 0x36b95(%rip), %ecx     # 0x3c360
movl 0x36c2b(%rip), %eax     # 0x3c3fc
addl %ecx, %eax
movl %eax, 0x36c23(%rip)     # 0x3c3fc
movl 0x36c19(%rip), %eax     # 0x3c3f8
movl %eax, 0x36c1b(%rip)     # 0x3c400
leaq 0x36c3c(%rip), %rsi     # 0x3c428
leaq -0x210(%rbp), %rdi
callq 0x4470
jmp 0x57fa
leaq -0x210(%rbp), %rdi
callq 0x40f0
addq $0x250, %rsp            # imm = 0x250
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x238(%rbp)
movl %eax, -0x23c(%rbp)
leaq -0x230(%rbp), %rdi
callq 0x46a8
jmp 0x584d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x238(%rbp)
movl %eax, -0x23c(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x40f0
movq -0x238(%rbp), %rdi
callq 0x4630
nopl (%rax)
// File: Juve45[P]batstat/main.cpp
// Function: keyListenerFunction()
void keyListenerFunction()
{
	int ch = 0;
	while((ch = wgetch(mainwin)) != 'q')
	{
		if(ch == 27)
			break;

		switch ( ch ) {

		case KEY_UP:
			if (logIndex > 0)
				--logIndex;
			newPrint();
			break;

		case KEY_DOWN:
			if (logIndex + 1 < logCache.size())
				++logIndex;
			newPrint();
			break;
		}
	}
	quit = 1;
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movq 0x365ba(%rip), %rdi     # 0x3c4f0
callq 0x4140
movl %eax, -0x4(%rbp)
cmpl $0x71, %eax
je 0x5fc9
cmpl $0x1b, -0x4(%rbp)
jne 0x5f4f
jmp 0x5fc9
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
subl $0x102, %eax            # imm = 0x102
je 0x5f89
jmp 0x5f5e
movl -0x8(%rbp), %eax
subl $0x103, %eax            # imm = 0x103
jne 0x5fc4
jmp 0x5f6a
cmpl $0x0, 0x36493(%rip)     # 0x3c404
jle 0x5f82
movl 0x3648b(%rip), %eax     # 0x3c404
addl $-0x1, %eax
movl %eax, 0x36482(%rip)     # 0x3c404
callq 0x5860
jmp 0x5fc4
movl 0x36475(%rip), %eax     # 0x3c404
addl $0x1, %eax
cltq
movq %rax, -0x10(%rbp)
leaq 0x36559(%rip), %rdi     # 0x3c4f8
callq 0x66b0
movq %rax, %rcx
movq -0x10(%rbp), %rax
cmpq %rcx, %rax
jae 0x5fbf
movl 0x3644e(%rip), %eax     # 0x3c404
addl $0x1, %eax
movl %eax, 0x36445(%rip)     # 0x3c404
callq 0x5860
jmp 0x5f2f
movb $0x1, 0x36519(%rip)     # 0x3c4e9
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Juve45[P]batstat/main.cpp
// Function: coreFunction()
void coreFunction() {
	lastTime = time(NULL);
	// sleep(1);
	while(!quit) {
		refreshValues();
		newPrint();
		if(timeElapsed % (LOG_P * refreshRate) == 0)
			addLog();
		sleep(refreshRate);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movl %eax, %edi
callq 0x4370
movl %eax, 0x3640d(%rip)     # 0x3c400
movb 0x364f0(%rip), %al      # 0x3c4e9
xorb $-0x1, %al
testb $0x1, %al
jne 0x6001
jmp 0x6038
callq 0x5740
callq 0x5860
movl 0x363eb(%rip), %eax     # 0x3c3fc
movl 0x3634d(%rip), %ecx     # 0x3c364
imull 0x36342(%rip), %ecx     # 0x3c360
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x602b
callq 0x5dc0
movl 0x3632f(%rip), %edi     # 0x3c360
callq 0x42d0
jmp 0x5ff3
popq %rbp
retq
nopw (%rax,%rax)
// File: Juve45[P]batstat/main.cpp
// Function: main
int main() {

	init();
	thread keyListener(keyListenerFunction);
	thread core(coreFunction);
	thread *p;
	keyListener.join();
	//core.join();
	//terminate();
	//delete p;
	core.detach();
	erase();
	delwin(mainwin);
	endwin();
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
callq 0x5250
leaq -0x13b(%rip), %rsi      # 0x5f20
leaq -0x10(%rbp), %rdi
callq 0x6720
leaq -0x8b(%rip), %rsi       # 0x5fe0
leaq -0x18(%rbp), %rdi
callq 0x6720
jmp 0x6076
leaq -0x10(%rbp), %rdi
callq 0x4600
jmp 0x6081
leaq -0x18(%rbp), %rdi
callq 0x4620
jmp 0x608c
callq 0x4400
jmp 0x6093
movq 0x36456(%rip), %rdi     # 0x3c4f0
callq 0x4070
jmp 0x60a1
callq 0x4430
jmp 0x60a8
movl $0x0, -0x4(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x67d0
leaq -0x10(%rbp), %rdi
callq 0x67d0
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x60ed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x67d0
leaq -0x10(%rbp), %rdi
callq 0x67d0
movq -0x20(%rbp), %rdi
callq 0x4630
nop
// File: Juve45[P]batstat/main.cpp
// Function: checkfile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline bool checkfile (const std::string& name) {
    if (FILE *file = fopen(name.c_str(), "r")) {
        fclose(file);
        return true;
    } else {
        return false;
    }   
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4180
movq %rax, %rdi
leaq 0x23022(%rip), %rsi     # 0x291d1
callq 0x4440
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x61ce
movq -0x18(%rbp), %rdi
callq 0x43a0
movb $0x1, -0x1(%rbp)
jmp 0x61d2
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Juve45[P]batstat/./include/nlohmann/json.hpp
// Function: nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&&)
basic_json(basic_json&& other) noexcept
        : json_base_class_t(std::forward<json_base_class_t>(other)),
          m_data(std::move(other.m_data))
    {
        // check that passed value is valid
        other.assert_invariant(false);

        // invalidate payload
        other.m_data.m_type = value_t::null;
        other.m_data.m_value = {};

        set_parents();
        assert_invariant();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movups (%rcx), %xmm0
movups %xmm0, (%rax)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x69d0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
callq 0x86b0
jmp 0x7513
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x69d0
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x68d0
nop
// File: Juve45[P]batstat/./include/nlohmann/json.hpp
// Function: nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::input_stream_adapter>::get()
char_int_type get()
    {
        ++position.chars_read_total;
        ++position.chars_read_current_line;

        if (next_unget)
        {
            // just reset the next_unget variable and work with current
            next_unget = false;
        }
        else
        {
            current = ia.get_character();
        }

        if (JSON_HEDLEY_LIKELY(current != char_traits<char_type>::eof()))
        {
            token_string.push_back(char_traits<char_type>::to_char_type(current));
        }

        if (current == '\n')
        {
            ++position.lines_read;
            position.chars_read_current_line = 0;
        }

        return current;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
movq 0x28(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
testb $0x1, 0x18(%rax)
je 0xe1ec
movq -0x18(%rbp), %rax
movb $0x0, 0x18(%rax)
jmp 0xe1fe
movq -0x18(%rbp), %rdi
callq 0xe350
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x1c(%rbp)
callq 0xca40
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xe221
jmp 0xe249
movq -0x18(%rbp), %rdi
movq %rdi, %rax
addq $0x38, %rax
movq %rax, -0x28(%rbp)
addq $0x14, %rdi
callq 0xe400
movq -0x28(%rbp), %rdi
movb %al, -0x9(%rbp)
leaq -0x9(%rbp), %rsi
callq 0xe3d0
movq -0x18(%rbp), %rax
cmpl $0xa, 0x14(%rax)
jne 0xe26b
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x30(%rax)
movq $0x0, 0x28(%rax)
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Juve45[P]batstat/./include/nlohmann/json.hpp
// Function: nlohmann::json_abi_v3_11_3::detail::input_stream_adapter::get_character()
std::char_traits<char>::int_type get_character()
    {
        auto res = sb->sbumpc();
        // set eof manually, as we don't use the istream interface.
        if (JSON_HEDLEY_UNLIKELY(res == std::char_traits<char>::eof()))
        {
            is->clear(is->rdstate() | std::ios::eofbit);
        }
        return res;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x8(%rax), %rdi
callq 0x4230
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
callq 0xca40
movl %eax, %ecx
movl -0x10(%rbp), %eax
cmpl %ecx, %eax
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xe38f
jmp 0xe3c7
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq (%rcx), %rdx
addq -0x18(%rdx), %rcx
movq %rcx, -0x20(%rbp)
movq (%rax), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x4330
movl %eax, %edi
movl $0x2, %esi
callq 0xe410
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x45e0
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: Juve45[P]batstat/./include/nlohmann/json.hpp
// Function: nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>)
basic_json& operator=(basic_json other) noexcept (
        std::is_nothrow_move_constructible<value_t>::value&&
        std::is_nothrow_move_assignable<value_t>::value&&
        std::is_nothrow_move_constructible<json_value>::value&&
        std::is_nothrow_move_assignable<json_value>::value&&
        std::is_nothrow_move_assignable<json_base_class_t>::value
    )
    {
        // check that passed value is valid
        other.assert_invariant();

        using std::swap;
        swap(m_data.m_type, other.m_data.m_type);
        swap(m_data.m_value, other.m_data.m_value);
        json_base_class_t::operator=(std::move(other));

        set_parents();
        assert_invariant();
        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, %rax
movq -0x28(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x1, %esi
callq 0x69d0
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdi
callq 0x211c0
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
addq $0x8, %rsi
callq 0x211f0
movq -0x18(%rbp), %rdi
callq 0x86b0
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x69d0
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Juve45[P]batstat/./include/nlohmann/json.hpp
// Function: nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::max_size() const
size_type max_size() const noexcept
    {
        switch (m_data.m_type)
        {
            case value_t::array:
            {
                // delegate call to array_t::max_size()
                return m_data.m_value.array->max_size();
            }

            case value_t::object:
            {
                // delegate call to object_t::max_size()
                return m_data.m_value.object->max_size();
            }

            case value_t::null:
            case value_t::string:
            case value_t::boolean:
            case value_t::number_integer:
            case value_t::number_unsigned:
            case value_t::number_float:
            case value_t::binary:
            case value_t::discarded:
            default:
            {
                // all other types have max_size() == size()
                return size();
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movzbl (%rax), %eax
movq %rax, -0x18(%rbp)
subq $0x9, %rax
ja 0x16edd
movq -0x18(%rbp), %rax
leaq 0x10a58(%rip), %rcx     # 0x27904
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x7970
movq %rax, -0x8(%rbp)
jmp 0x16eea
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x17ac0
movq %rax, -0x8(%rbp)
jmp 0x16eea
jmp 0x16edd
movq -0x20(%rbp), %rdi
callq 0x17ae0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Juve45[P]batstat/./include/nlohmann/json.hpp
// Function: nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::type_name() const
JSON_HEDLEY_RETURNS_NON_NULL
    const char* type_name() const noexcept
    {
        switch (m_data.m_type)
        {
            case value_t::null:
                return "null";
            case value_t::object:
                return "object";
            case value_t::array:
                return "array";
            case value_t::string:
                return "string";
            case value_t::boolean:
                return "boolean";
            case value_t::binary:
                return "binary";
            case value_t::discarded:
                return "discarded";
            case value_t::number_integer:
            case value_t::number_unsigned:
            case value_t::number_float:
            default:
                return "number";
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movq %rax, -0x18(%rbp)
subq $0x9, %rax
ja 0x1c65a
movq -0x18(%rbp), %rax
leaq 0xb4a0(%rip), %rcx      # 0x27a94
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xe4da(%rip), %rax      # 0x2aade
movq %rax, -0x8(%rbp)
jmp 0x1c665
leaq 0xd711(%rip), %rax      # 0x29d22
movq %rax, -0x8(%rbp)
jmp 0x1c665
leaq 0xd6fe(%rip), %rax      # 0x29d1c
movq %rax, -0x8(%rbp)
jmp 0x1c665
leaq 0xe4b8(%rip), %rax      # 0x2aae3
movq %rax, -0x8(%rbp)
jmp 0x1c665
leaq 0xe4b2(%rip), %rax      # 0x2aaea
movq %rax, -0x8(%rbp)
jmp 0x1c665
leaq 0xe4ad(%rip), %rax      # 0x2aaf2
movq %rax, -0x8(%rbp)
jmp 0x1c665
leaq 0xe4a7(%rip), %rax      # 0x2aaf9
movq %rax, -0x8(%rbp)
jmp 0x1c665
jmp 0x1c65a
leaq 0xe4a2(%rip), %rax      # 0x2ab03
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: Juve45[P]batstat/./include/nlohmann/json.hpp
// Function: void nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)3>::construct<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>(nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&, nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::string_t const&)
static void construct(BasicJsonType& j, const typename BasicJsonType::string_t& s)
    {
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::string;
        j.m_data.m_value = s;
        j.assert_invariant();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rax
movzbl (%rax), %esi
callq 0x6b40
movq -0x8(%rbp), %rax
movb $0x3, (%rax)
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x18b00
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x69d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Juve45[P]batstat/./include/nlohmann/json.hpp
// Function: void nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)7>::construct<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>(nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&, nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::number_float_t)
static void construct(BasicJsonType& j, typename BasicJsonType::number_float_t val) noexcept
    {
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::number_float;
        j.m_data.m_value = val;
        j.assert_invariant();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movzbl (%rax), %esi
callq 0x6b40
jmp 0x1e696
movq -0x8(%rbp), %rax
movb $0x7, (%rax)
movsd -0x10(%rbp), %xmm0
leaq -0x18(%rbp), %rdi
callq 0x18ba0
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x69d0
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x68d0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Juve45[P]batstat/./include/nlohmann/json.hpp
// Function: void nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)4>::construct<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>(nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&, nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::boolean_t)
static void construct(BasicJsonType& j, typename BasicJsonType::boolean_t b) noexcept
    {
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::boolean;
        j.m_data.m_value = b;
        j.assert_invariant();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movzbl (%rax), %esi
callq 0x6b40
jmp 0x1ed09
movq -0x8(%rbp), %rax
movb $0x4, (%rax)
movb -0x9(%rbp), %al
leaq -0x18(%rbp), %rdi
andb $0x1, %al
movzbl %al, %esi
callq 0x18b40
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x69d0
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x68d0
nopl (%rax)
// File: Juve45[P]batstat/./include/nlohmann/json.hpp
// Function: void nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)5>::construct<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>(nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&, nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::number_integer_t)
static void construct(BasicJsonType& j, typename BasicJsonType::number_integer_t val) noexcept
    {
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::number_integer;
        j.m_data.m_value = val;
        j.assert_invariant();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movzbl (%rax), %esi
callq 0x6b40
jmp 0x1f885
movq -0x8(%rbp), %rax
movb $0x5, (%rax)
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x18b60
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x69d0
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x68d0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: Juve45[P]batstat/./include/nlohmann/json.hpp
// Function: void nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)6>::construct<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>(nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&, nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::number_unsigned_t)
static void construct(BasicJsonType& j, typename BasicJsonType::number_unsigned_t val) noexcept
    {
        j.m_data.m_value.destroy(j.m_data.m_type);
        j.m_data.m_type = value_t::number_unsigned;
        j.m_data.m_value = val;
        j.assert_invariant();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movzbl (%rax), %esi
callq 0x6b40
jmp 0x20405
movq -0x8(%rbp), %rax
movb $0x6, (%rax)
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x18b80
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x69d0
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x68d0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: Juve45[P]batstat/./include/nlohmann/json.hpp
// Function: nlohmann::json_abi_v3_11_3::detail::json_sax_dom_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::key(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool key(string_t& val)
    {
        JSON_ASSERT(!ref_stack.empty());
        JSON_ASSERT(ref_stack.back()->is_object());

        // add null at given key and store the reference for later
        object_element = &(ref_stack.back()->m_data.m_value.object->operator[](val));
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x8, %rdi
callq 0x17260
xorb $-0x1, %al
testb $0x1, %al
jne 0x21489
jmp 0x2148b
jmp 0x214aa
leaq 0x8a0d(%rip), %rdi      # 0x29e9f
leaq 0x6938(%rip), %rsi      # 0x27dd1
movl $0x1ae0, %edx           # imm = 0x1AE0
leaq 0x9fbe(%rip), %rcx      # 0x2b463
callq 0x4280
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x16e40
movq (%rax), %rdi
callq 0x75a0
testb $0x1, %al
jne 0x214c5
jmp 0x214c7
jmp 0x214e6
leaq 0x897f(%rip), %rdi      # 0x29e4d
leaq 0x68fc(%rip), %rsi      # 0x27dd1
movl $0x1ae1, %edx           # imm = 0x1AE1
leaq 0x9f82(%rip), %rcx      # 0x2b463
callq 0x4280
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x16e40
movq (%rax), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1ceb0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movb $0x1, %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Juve45[P]batstat/./include/nlohmann/json.hpp
// Function: nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
reference operator[](typename object_t::key_type key)
    {
        // implicitly convert null value to an empty object
        if (is_null())
        {
            m_data.m_type = value_t::object;
            m_data.m_value.object = create<object_t>();
            assert_invariant();
        }

        // operator[] only works for objects
        if (JSON_HEDLEY_LIKELY(is_object()))
        {
            auto result = m_data.m_value.object->emplace(std::move(key), nullptr);
            return set_parent(result.first->second);
        }

        JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x23ae0
testb $0x1, %al
jne 0x2399a
jmp 0x239b8
movq -0x78(%rbp), %rax
movb $0x1, (%rax)
callq 0x9c50
movq -0x78(%rbp), %rdi
movq %rax, 0x8(%rdi)
movl $0x1, %esi
callq 0x69d0
movq -0x78(%rbp), %rdi
callq 0x75a0
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x239cb
jmp 0x23a26
movq -0x78(%rbp), %rax
movq -0x80(%rbp), %rsi
movq 0x8(%rax), %rdi
movq $0x0, -0x28(%rbp)
leaq -0x28(%rbp), %rdx
callq 0x23b00
movb %dl, -0x30(%rbp)
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movb -0x30(%rbp), %al
movb %al, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x1c1f0
movq -0x78(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
movq $-0x1, %rdx
callq 0x23b50
addq $0x90, %rsp
popq %rbp
retq
movb $0x1, -0x6d(%rbp)
movl $0x20, %edi
callq 0x4210
movq -0x78(%rbp), %rdi
movq %rax, -0x88(%rbp)
callq 0x1c5d0
movq %rax, -0x60(%rbp)
leaq 0x7f01(%rip), %rsi      # 0x2b950
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x23b70
jmp 0x23a5e
movq -0x78(%rbp), %rcx
movq -0x88(%rbp), %rdi
movl $0x131, %esi            # imm = 0x131
leaq -0x58(%rbp), %rdx
callq 0x1c380
jmp 0x23a79
movq -0x88(%rbp), %rdi
movb $0x0, -0x6d(%rbp)
leaq 0x1821d(%rip), %rsi     # 0x3bca8
leaq -0x7422(%rip), %rdx     # 0x1c670
callq 0x4610
jmp 0x23adb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x23abc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x46a8
testb $0x1, -0x6d(%rbp)
jne 0x23ac4
jmp 0x23ad0
movq -0x88(%rbp), %rdi
callq 0x42c0
jmp 0x23ad2
movq -0x68(%rbp), %rdi
callq 0x4630
nopl (%rax,%rax)
// File: Juve45[P]batstat/./include/nlohmann/json.hpp
// Function: nlohmann::json_abi_v3_11_3::detail::operator<(nlohmann::json_abi_v3_11_3::detail::value_t, nlohmann::json_abi_v3_11_3::detail::value_t)
inline bool operator<(const value_t lhs, const value_t rhs) noexcept
#endif
{
    static constexpr std::array<std::uint8_t, 9> order = {{
            0 /* null */, 3 /* object */, 4 /* array */, 5 /* string */,
            1 /* boolean */, 2 /* integer */, 2 /* unsigned */, 2 /* float */,
            6 /* binary */
        }
    };

    const auto l_index = static_cast<std::size_t>(lhs);
    const auto r_index = static_cast<std::size_t>(rhs);
#if JSON_HAS_THREE_WAY_COMPARISON
    if (l_index < order.size() && r_index < order.size())
    {
        return order[l_index] <=> order[r_index]; // *NOPAD*
    }
    return std::partial_ordering::unordered;
#else
    return l_index < order.size() && r_index < order.size() && order[l_index] < order[r_index];
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movb %dil, %cl
movb %cl, -0x1(%rbp)
movb %al, -0x2(%rbp)
movzbl -0x1(%rbp), %eax
movq %rax, -0x10(%rbp)
movzbl -0x2(%rbp), %eax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x7731(%rip), %rdi      # 0x2bcd4
callq 0x251a0
movq -0x28(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x19(%rbp)
jae 0x24615
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x770c(%rip), %rdi      # 0x2bcd4
callq 0x251a0
movq -0x30(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x19(%rbp)
jae 0x24615
movq -0x10(%rbp), %rsi
leaq 0x76eb(%rip), %rdi      # 0x2bcd4
callq 0x251b0
movzbl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rsi
leaq 0x76d5(%rip), %rdi      # 0x2bcd4
callq 0x251b0
movq %rax, %rcx
movl -0x34(%rbp), %eax
movzbl (%rcx), %ecx
cmpl %ecx, %eax
setl %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
// File: cesarblum[P]propertypp/example.cpp
// Function: Example::printProperties()
void Example::printProperties()
{
    std::cout << "i: " << i
              << "; f: " << f
              << "; p: " << p << " (" << (p ? *p : 0) << ")"
              << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x5d3d(%rip), %rdi      # 0x6fd8
leaq 0x2d72(%rip), %rsi      # 0x4014
callq 0x1060
movq -0x18(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x8, %rdi
callq 0x17c0
movq -0x30(%rbp), %rdi
movl %eax, %esi
callq 0x10b0
movq %rax, %rdi
leaq 0x2d4b(%rip), %rsi      # 0x4018
callq 0x1060
movq -0x18(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x20, %rdi
callq 0x17e0
movq -0x28(%rbp), %rdi
callq 0x1030
movq %rax, %rdi
leaq 0x2d28(%rip), %rsi      # 0x401e
callq 0x1060
movq -0x18(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x38, %rdi
callq 0x1800
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x1040
movq %rax, %rdi
leaq 0x2d02(%rip), %rsi      # 0x4024
callq 0x1060
movq -0x18(%rbp), %rdi
movq %rax, -0x10(%rbp)
addq $0x38, %rdi
callq 0x1800
cmpq $0x0, %rax
je 0x1352
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
callq 0x1820
movl (%rax), %eax
movl %eax, -0x34(%rbp)
jmp 0x1359
xorl %eax, %eax
movl %eax, -0x34(%rbp)
jmp 0x1359
movq -0x10(%rbp), %rdi
movl -0x34(%rbp), %esi
callq 0x10b0
movq %rax, %rdi
leaq 0x2cb8(%rip), %rsi      # 0x4027
callq 0x1060
movq %rax, %rdi
movq 0x5c4a(%rip), %rsi      # 0x6fc8
callq 0x1090
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: cesarblum[P]propertypp/example.cpp
// Function: main
int main()
{
    Example e;
    e.printProperties(); // should print all 0

    e.i = 14;
    e.f = 2.3;
    e.p = new int;
    *e.p = 5;
    e.printProperties(); // should print assigned values

    e.f = -1.0;
    e.printProperties(); // e.f should be unchanged (see setter above)

    e.i = e.f;           // implicit type conversion
    e.printProperties(); // e.i should equal the integer part of e.f

    e.f = 5.5;
    e.printProperties(); // only e.f should be changed

    e.i = e.f = 9.3;     // chained assignment
    e.printProperties(); // e.i should be 9, e.f should be 9.3

    e.i = *e.p;
    e.printProperties(); // e.i should equal the value pointed to by e.p

    delete e.p;
    e.p = 0;
    e.printProperties(); // e.p should be null

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1210
leaq -0x50(%rbp), %rdi
callq 0x1280
leaq -0x50(%rbp), %rdi
addq $0x8, %rdi
movl $0xe, %esi
callq 0x1840
leaq -0x50(%rbp), %rdi
addq $0x20, %rdi
movss 0x2b6d(%rip), %xmm0     # 0x4010
callq 0x1870
movl $0x4, %edi
callq 0x1070
movq %rax, %rsi
leaq -0x50(%rbp), %rdi
addq $0x38, %rdi
callq 0x18a0
leaq -0x50(%rbp), %rdi
addq $0x38, %rdi
callq 0x1820
movl $0x5, (%rax)
leaq -0x50(%rbp), %rdi
callq 0x1280
leaq -0x50(%rbp), %rdi
addq $0x20, %rdi
movss 0x2b1e(%rip), %xmm0     # 0x400c
callq 0x1870
leaq -0x50(%rbp), %rdi
callq 0x1280
leaq -0x50(%rbp), %rdi
addq $0x20, %rdi
callq 0x17e0
cvttss2si %xmm0, %esi
leaq -0x50(%rbp), %rdi
addq $0x8, %rdi
callq 0x1840
leaq -0x50(%rbp), %rdi
callq 0x1280
leaq -0x50(%rbp), %rdi
addq $0x20, %rdi
movss 0x2ad5(%rip), %xmm0     # 0x4008
callq 0x1870
leaq -0x50(%rbp), %rdi
callq 0x1280
leaq -0x50(%rbp), %rdi
addq $0x20, %rdi
movss 0x2ab3(%rip), %xmm0     # 0x4004
callq 0x1870
cvttss2si %xmm0, %esi
leaq -0x50(%rbp), %rdi
addq $0x8, %rdi
callq 0x1840
leaq -0x50(%rbp), %rdi
callq 0x1280
leaq -0x50(%rbp), %rdi
addq $0x38, %rdi
callq 0x1820
movl (%rax), %esi
leaq -0x50(%rbp), %rdi
addq $0x8, %rdi
callq 0x1840
leaq -0x50(%rbp), %rdi
callq 0x1280
leaq -0x50(%rbp), %rdi
addq $0x38, %rdi
callq 0x1800
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x15ba
movq -0x58(%rbp), %rdi
movl $0x4, %esi
callq 0x1080
leaq -0x50(%rbp), %rdi
addq $0x38, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x18a0
leaq -0x50(%rbp), %rdi
callq 0x1280
xorl %eax, %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: bloody76[P]Chip8-Disassembler/src/disassembler.cc
// Function: main
int main(int argc, char** argv)
{
    if (argc < 2)
    {
        std::cerr << "First argument must be a filename." << std::endl;
        return 1;
    }
    std::string file(argv[1]);

    functions[0x200] = Type::SUB;
    std::ifstream rom(file, std::ios::ate);
    if (!rom.is_open())
    {
        std::cerr << "Fill with a valid filename." << std::endl;
        return 1;
    }
    parse(rom);
    pretty_print();
    delete[] mem;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x290, %rsp            # imm = 0x290
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x31dd
movq 0x4e3a(%rip), %rdi      # 0x7ff0
leaq 0x1fb5(%rip), %rsi      # 0x5172
callq 0x2160
movq %rax, %rdi
movq 0x4df4(%rip), %rsi      # 0x7fc0
callq 0x21a0
movl $0x1, -0x4(%rbp)
jmp 0x3376
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x268(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x260(%rbp)
callq 0x22d0
movq -0x268(%rbp), %rsi
movq -0x260(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x3610
jmp 0x3215
leaq -0x31(%rbp), %rdi
callq 0x21c0
movw $0x200, -0x46(%rbp)     # imm = 0x200
leaq 0x4f7d(%rip), %rdi      # 0x81a8
leaq -0x46(%rbp), %rsi
callq 0x3420
movq %rax, -0x270(%rbp)
jmp 0x323d
movq -0x270(%rbp), %rax
movl $0x0, (%rax)
leaq -0x250(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x2, %edx
callq 0x2270
jmp 0x3261
leaq -0x250(%rbp), %rdi
callq 0x2260
movb %al, -0x271(%rbp)
jmp 0x3275
movb -0x271(%rbp), %al
testb $0x1, %al
jne 0x330e
jmp 0x3285
movq 0x4d64(%rip), %rdi      # 0x7ff0
leaq 0x1f02(%rip), %rsi      # 0x5195
callq 0x2160
movq %rax, -0x280(%rbp)
jmp 0x32a1
movq -0x280(%rbp), %rdi
movq 0x4d11(%rip), %rsi      # 0x7fc0
callq 0x21a0
jmp 0x32b6
movl $0x1, -0x4(%rbp)
movl $0x1, -0x254(%rbp)
jmp 0x3354
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x21c0
jmp 0x3382
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x336b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x250(%rbp), %rdi
callq 0x2070
jmp 0x336b
leaq -0x250(%rbp), %rdi
callq 0x24a0
jmp 0x331c
callq 0x2680
jmp 0x3323
movq 0x4eae(%rip), %rax      # 0x81d8
movq %rax, -0x288(%rbp)
cmpq $0x0, %rax
je 0x3343
movq -0x288(%rbp), %rdi
callq 0x2220
movl $0x0, -0x4(%rbp)
movl $0x1, -0x254(%rbp)
leaq -0x250(%rbp), %rdi
callq 0x2070
leaq -0x30(%rbp), %rdi
callq 0x20e0
jmp 0x3376
leaq -0x30(%rbp), %rdi
callq 0x20e0
jmp 0x3382
movl -0x4(%rbp), %eax
addq $0x290, %rsp            # imm = 0x290
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x22c0
nopl (%rax,%rax)
// File: t0mm4rx[P]piscine_cpp/day04/ex02/Squad.cpp
// Function: Squad::operator=(Squad const&)
Squad &Squad::operator=(Squad const &other)
{
	std::cout << "Copy" << std::endl;
	for (int i = 0; i < this->current; i++)
		delete this->units[i];
	delete []this->units;
	this->units = 0;
	this->current = 0;
	for (int i = 0; i < other.getCount(); i++)
		this->push(other.getUnit(i)->clone());
	return (*this);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x3909(%rip), %rdi      # 0x4fd8
leaq 0x19cc(%rip), %rsi      # 0x30a2
callq 0x1070
movq %rax, %rdi
movq 0x38e3(%rip), %rsi      # 0x4fc8
callq 0x10a0
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x172e
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x1721
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x1723
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x16f1
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x1749
movq -0x30(%rbp), %rdi
callq 0x10b0
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movl $0x0, 0x8(%rax)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movl %eax, %ecx
movl -0x34(%rbp), %eax
cmpl %ecx, %eax
jge 0x17aa
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x20(%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1763
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: t0mm4rx[P]piscine_cpp/day04/ex02/Squad.cpp
// Function: Squad::~Squad()
Squad::~Squad(void)
{
	for (int i = 0; i < this->current; i++)
		delete this->units[i];
	delete []this->units;
	this->units = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x34e5(%rip), %rcx      # 0x4cc0
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x1826
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x1819
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x181b
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x17e9
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x1841
movq -0x28(%rbp), %rdi
callq 0x10b0
movq -0x18(%rbp), %rdi
movq $0x0, 0x10(%rdi)
callq 0x1a50
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: t0mm4rx[P]piscine_cpp/day04/ex02/Squad.cpp
// Function: Squad::push(ISpaceMarine*)
int Squad::push(ISpaceMarine *unit)
{
	if (unit == 0)
		return (0);
	for (int i = 0; i < this->current; i++)
	{
		if (this->units[i] == unit)
			return (0);
	}
	ISpaceMarine **tmp = new ISpaceMarine*[this->current + 1];
	for (int i = 0; i < this->current; i++)
		tmp[i] = this->units[i];
	tmp[this->current++] = unit;
	if (this->units != 0)
		delete []this->units;
	this->units = tmp;
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x191b
movl $0x0, -0x4(%rbp)
jmp 0x1a1d
movl $0x0, -0x1c(%rbp)
movq -0x38(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x195d
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x18(%rbp), %rax
jne 0x1950
movl $0x0, -0x4(%rbp)
jmp 0x1a1d
jmp 0x1952
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1922
movq -0x38(%rbp), %rax
movl 0x8(%rax), %eax
addl $0x1, %eax
cltq
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x1030
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x38(%rbp), %rcx
movl -0x2c(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x19c8
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1995
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rcx
movl 0x8(%rax), %edx
movl %edx, %edi
addl $0x1, %edi
movl %edi, 0x8(%rax)
movslq %edx, %rdx
movq %rsi, (%rcx,%rdx,8)
cmpq $0x0, 0x10(%rax)
je 0x1a0a
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x1a08
movq -0x40(%rbp), %rdi
callq 0x10b0
jmp 0x1a0a
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: princelab[P]emass/emass.cpp
// Function: prune(std::vector<peak, std::allocator<peak>>&, double)
void prune(Pattern & f, double limit)
{
  // prune the front
  Pattern::iterator i = f.begin();
  while(i != f.end()) {
    if((*i).rel_area > limit)
      break;
    i++;
  }
  f.erase(f.begin(), i);

  // prune the end
  while(1) {
    if(f.size() == 0)
      break;
    if(f.back().rel_area > limit)
      break;
    f.pop_back();
  } 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6490
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6500
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x64c0
testb $0x1, %al
jne 0x509e
jmp 0x50c6
leaq -0x18(%rbp), %rdi
callq 0x6530
movsd 0x8(%rax), %xmm0
ucomisd -0x10(%rbp), %xmm0
jbe 0x50b5
jmp 0x50c6
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x6550
movq %rax, -0x28(%rbp)
jmp 0x507e
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6490
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x6620
leaq -0x40(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x6620
movq -0x50(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x6590
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6380
cmpq $0x0, %rax
jne 0x511b
jmp 0x513d
movq -0x8(%rbp), %rdi
callq 0x63a0
movsd 0x8(%rax), %xmm0
ucomisd -0x10(%rbp), %xmm0
jbe 0x5132
jmp 0x513d
movq -0x8(%rbp), %rdi
callq 0x6660
jmp 0x510a
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)