LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: nmmmnu[P]HM3/hm3/hashindex/hashindexbuilder_impl.h
// Function: hm3::hashindex::HashIndexBuilder::printStats_(unsigned long, unsigned long)
void HashIndexBuilder::printStats_(size_t const size, size_t const collisions){
	constexpr const char *MASKZ = "%-16s : %12zu\n";
	constexpr const char *MASKF = "%-16s : %15.2f %%\n";

	double const percent = 100.0 * (double) collisions / (double) size;

	printf(MASKZ, "Total",			size			);
	printf(MASKZ, "Total Present",		size - collisions	);
	printf(MASKF, "Percent Present",	100 - percent		);
	printf(MASKZ, "Collisions",		collisions		);
	printf(MASKF, "Percent Missing",	percent			);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
leaq 0x6acb(%rip), %rax      # 0x9030
movq %rax, 0x10(%rsp)
leaq 0x6ace(%rip), %rax      # 0x903f
movq %rax, 0x8(%rsp)
movaps 0x6a93(%rip), %xmm3     # 0x9010
movq 0x18(%rsp), %xmm0
punpckldq %xmm3, %xmm0    # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
movapd 0x6a91(%rip), %xmm2     # 0x9020
subpd %xmm2, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0x6a62(%rip), %xmm1     # 0x9008
mulsd %xmm1, %xmm0
movq 0x20(%rsp), %xmm1
punpckldq %xmm3, %xmm1    # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
movq 0x20(%rsp), %rdx
leaq 0x6a58(%rip), %rdi      # 0x9030
leaq 0x6a73(%rip), %rsi      # 0x9052
movb $0x0, %al
callq 0x2030
movq 0x20(%rsp), %rdx
subq 0x18(%rsp), %rdx
leaq 0x6a39(%rip), %rdi      # 0x9030
leaq 0x6a5a(%rip), %rsi      # 0x9058
movb $0x0, %al
callq 0x2030
movsd 0x69fb(%rip), %xmm0     # 0x9008
subsd (%rsp), %xmm0
leaq 0x6a26(%rip), %rdi      # 0x903f
leaq 0x6a46(%rip), %rsi      # 0x9066
movb $0x1, %al
callq 0x2030
movq 0x18(%rsp), %rdx
leaq 0x69fd(%rip), %rdi      # 0x9030
leaq 0x6a3c(%rip), %rsi      # 0x9076
movb $0x0, %al
callq 0x2030
movsd (%rsp), %xmm0
leaq 0x69f2(%rip), %rdi      # 0x903f
leaq 0x6a2d(%rip), %rsi      # 0x9081
movb $0x1, %al
callq 0x2030
addq $0x28, %rsp
retq
// File: nmmmnu[P]HM3/hm3/main/db_mkhash.cc
// Function: main
int main(int argc, char **argv){
	if (argc <= 1 + 1){
		printUsage(argv[0]);
		return 1;
	}

	const char *input_file	= argv[1];
	const char *output_file	= argv[2];

	if (CHECK_FILE_EXISTS && fileExists(output_file)){
		std::cout << "File " << output_file << " exists. Please remove it and try again." << '\n';
		return 2;
	}

	using DiskTable = hm3::DiskTable;

	DiskTable list;
	list.open(input_file);

	using HashIndexBuilder = hm3::hashindex::HashIndexBuilder;

	HashIndexBuilder htb;
	bool const result = htb.createFromList(output_file, list);

	return result ? 0 : 100;
}

// Assembly:
subq $0x158, %rsp            # imm = 0x158
movl $0x0, 0x154(%rsp)
movl %edi, 0x150(%rsp)
movq %rsi, 0x148(%rsp)
cmpl $0x2, 0x150(%rsp)
jg 0x26ab
movq 0x148(%rsp), %rax
movq (%rax), %rdi
callq 0x27b0
movl $0x1, 0x154(%rsp)
jmp 0x2793
movq 0x148(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x140(%rsp)
movq 0x148(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x138(%rsp)
leaq 0x58(%rsp), %rdi
movl $0x1, %esi
callq 0x29e0
movq 0x140(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x2b10
jmp 0x26f6
leaq 0x58(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x5c50
jmp 0x2707
leaq 0x28(%rsp), %rdi
movl $0x8, %esi
callq 0x2b60
jmp 0x2718
movq 0x138(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x2b10
jmp 0x272c
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x58(%rsp), %rdx
movl $0x1, %ecx
callq 0x2b80
movb %al, 0xf(%rsp)
jmp 0x274b
movb 0xf(%rsp), %al
andb $0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %dl
movl $0x64, %eax
xorl %ecx, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, 0x154(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x2e20
jmp 0x2793
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x2e20
jmp 0x27a2
movl 0x154(%rsp), %eax
addq $0x158, %rsp            # imm = 0x158
retq
movq 0x40(%rsp), %rdi
callq 0x22c0
nopl (%rax)
// File: nmmmnu[P]HM3/hm3/main/db_mkhash.cc
// Function: printUsage(char const*)
static void printUsage(const char *name){
	std::cout
		<< "Usage:"						<< '\n'
		<< name << " [file.db] [hash_file]"			<< '\n'
		<< "\t\tPath names must be written without extention"	<< '\n'
		<< "\t\tExample 'file.db'"				<< '\n'
		<< "\t\tDo not forget that usually btree_file must have same name as [file.db]"	<< '\n'
	;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq 0xa814(%rip), %rdi      # 0xcfd0
leaq 0x68ce(%rip), %rsi      # 0x9091
callq 0x21b0
movq %rax, %rdi
movl $0xa, %esi
callq 0x21f0
movq %rax, %rdi
movq (%rsp), %rsi
callq 0x21b0
movq %rax, %rdi
leaq 0x68ad(%rip), %rsi      # 0x9098
callq 0x21b0
movq %rax, %rdi
movl $0xa, %esi
callq 0x21f0
movq %rax, %rdi
leaq 0x68a8(%rip), %rsi      # 0x90af
callq 0x21b0
movq %rax, %rdi
movl $0xa, %esi
callq 0x21f0
movq %rax, %rdi
leaq 0x68bb(%rip), %rsi      # 0x90de
callq 0x21b0
movq %rax, %rdi
movl $0xa, %esi
callq 0x21f0
movq %rax, %rdi
leaq 0x68b3(%rip), %rsi      # 0x90f2
callq 0x21b0
movq %rax, %rdi
movl $0xa, %esi
callq 0x21f0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: nmmmnu[P]HM3/common/myhash_impl.h
// Function: myhash::impl::MyHashBase<myhash::impl::DJB2A<unsigned long>>::operator()(char const*) const
uint operator()(const char *s) const{
			uint hash = offset_basis;

			for(const char *c = s; *c; ++c)
				h_.add(hash, *c);

			return hash;
		}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq $0x1505, 0x10(%rsp)     # imm = 0x1505
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpb $0x0, (%rax)
je 0x29ca
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
leaq 0x10(%rsp), %rsi
movsbl (%rax), %edx
callq 0x2ff0
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x299a
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: nmmmnu[P]HM3/hm3/hashindex/hashindexbuilder_impl.h
// Function: unsigned long hm3::hashindex::HashIndexBuilder::createFromList_<hm3::DiskTable>(unsigned long*, unsigned long, hm3::DiskTable const&) const
size_t HashIndexBuilder::createFromList_(uint64_t *hashtable, size_t const hashtableSize, const LIST &list) const{
	uint64_t const BE_BUCKET_EMPTY		= htobe64(BUCKET_EMPTY		);
	uint64_t const BE_BUCKET_COLLISION	= htobe64(BUCKET_COLLISION	);

	size_t collisions = 0;

	log__("Creating hashtable.");
	DiskTable::size_type index = 0;
	for(const auto &p : list){
		auto const bucket = bucketForKey_(p.getKey(), hashtableSize);

		auto const htb = hashtable[bucket];

		if (htb == BE_BUCKET_EMPTY){
			hashtable[bucket] = htobe64(index);

		}else{
			++collisions;

			if (htb != BE_BUCKET_COLLISION){
				hashtable[bucket] = BE_BUCKET_COLLISION;
				++collisions;
			}
		}


		++index;
	}

	return collisions;
}

// Assembly:
subq $0x108, %rsp            # imm = 0x108
movq %rdi, 0x100(%rsp)
movq %rsi, 0xf8(%rsp)
movq %rdx, 0xf0(%rsp)
movq %rcx, 0xe8(%rsp)
movq 0x100(%rsp), %rax
movq %rax, 0x20(%rsp)
movq $-0x1, %rdi
callq 0x2890
movq %rax, 0xe0(%rsp)
movq $-0x2, %rdi
callq 0x2890
movq %rax, 0xd8(%rsp)
movq $0x0, 0xd0(%rsp)
leaq 0x5f9d(%rip), %rdi      # 0x915c
callq 0x2860
movq $0x0, 0xc8(%rsp)
movq 0xe8(%rsp), %rax
movq %rax, 0xc0(%rsp)
movq 0xc0(%rsp), %rsi
leaq 0x90(%rsp), %rdi
callq 0x3640
movq 0xc0(%rsp), %rsi
leaq 0x60(%rsp), %rdi
callq 0x3690
jmp 0x3209
jmp 0x320b
leaq 0x90(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x36e0
movb %al, 0x1f(%rsp)
jmp 0x3223
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x3279
jmp 0x322d
leaq 0x60(%rsp), %rdi
callq 0x3730
leaq 0x90(%rsp), %rdi
callq 0x3730
jmp 0x33a4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x3395
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x3730
jmp 0x3395
leaq 0x90(%rsp), %rdi
callq 0x6e00
movq %rax, 0x10(%rsp)
jmp 0x328d
movq 0x10(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0x3990
movq 0x20(%rsp), %rdi
movq %rax, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq 0xf0(%rsp), %rdx
leaq 0x30(%rsp), %rsi
callq 0x24f0
movq %rax, 0x8(%rsp)
jmp 0x32c9
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0xf8(%rsp), %rax
movq 0x40(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpq 0xe0(%rsp), %rax
jne 0x331b
movq 0xc8(%rsp), %rdi
callq 0x2890
movq %rax, %rdx
movq 0xf8(%rsp), %rax
movq 0x40(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x336d
movq 0xd0(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xd0(%rsp)
movq 0x28(%rsp), %rax
cmpq 0xd8(%rsp), %rax
je 0x336b
movq 0xd8(%rsp), %rdx
movq 0xf8(%rsp), %rax
movq 0x40(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0xd0(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xd0(%rsp)
jmp 0x336d
movq 0xc8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xc8(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x3710
jmp 0x3390
jmp 0x320b
leaq 0x90(%rsp), %rdi
callq 0x3730
jmp 0x33b4
movq 0xd0(%rsp), %rax
addq $0x108, %rsp            # imm = 0x108
retq
movq 0x58(%rsp), %rdi
callq 0x22c0
nop
// File: SYZYGYfpga[P]syzygy-tools/include/json.hpp
// Function: nlohmann::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::adl_serializer>::json_value::destroy(nlohmann::detail::value_t)
void destroy(value_t t)
        {
            switch (t)
            {
                case value_t::object:
                {
                    AllocatorType<object_t> alloc;
                    std::allocator_traits<decltype(alloc)>::destroy(alloc, object);
                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, object, 1);
                    break;
                }

                case value_t::array:
                {
                    AllocatorType<array_t> alloc;
                    std::allocator_traits<decltype(alloc)>::destroy(alloc, array);
                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, array, 1);
                    break;
                }

                case value_t::string:
                {
                    AllocatorType<string_t> alloc;
                    std::allocator_traits<decltype(alloc)>::destroy(alloc, string);
                    std::allocator_traits<decltype(alloc)>::deallocate(alloc, string, 1);
                    break;
                }

                default:
                {
                    break;
                }
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movb -0x9(%rbp), %al
movb %al, -0x1f(%rbp)
subb $0x1, %al
je 0x4f5f
jmp 0x4f46
movb -0x1f(%rbp), %al
subb $0x2, %al
je 0x4fbb
jmp 0x4f4f
movb -0x1f(%rbp), %al
subb $0x3, %al
je 0x5011
jmp 0x5067
leaq -0xa(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x5080
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rdi
movq (%rax), %rsi
callq 0x50a0
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rdi
movq (%rax), %rsi
movl $0x1, %edx
callq 0x50d0
jmp 0x4f93
leaq -0xa(%rbp), %rdi
callq 0x5100
jmp 0x5069
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0xa(%rbp), %rdi
callq 0x5100
jmp 0x506f
leaq -0x1d(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x5120
movq -0x28(%rbp), %rax
movq -0x38(%rbp), %rdi
movq (%rax), %rsi
callq 0x5140
movq -0x28(%rbp), %rax
movq -0x38(%rbp), %rdi
movq (%rax), %rsi
movl $0x1, %edx
callq 0x5170
jmp 0x4fef
leaq -0x1d(%rbp), %rdi
callq 0x51a0
jmp 0x5069
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1d(%rbp), %rdi
callq 0x51a0
jmp 0x506f
leaq -0x1e(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x51c0
movq -0x28(%rbp), %rax
movq -0x40(%rbp), %rdi
movq (%rax), %rsi
callq 0x51e0
movq -0x28(%rbp), %rax
movq -0x40(%rbp), %rdi
movq (%rax), %rsi
movl $0x1, %edx
callq 0x5210
jmp 0x5045
leaq -0x1e(%rbp), %rdi
callq 0x5240
jmp 0x5069
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1e(%rbp), %rdi
callq 0x5240
jmp 0x506f
jmp 0x5069
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x34e0
nopl (%rax,%rax)
// File: SYZYGYfpga[P]syzygy-tools/include/json.hpp
// Function: nlohmann::detail::parser<nlohmann::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::adl_serializer>>::parse(bool, nlohmann::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::adl_serializer>&)
void parse(const bool strict, BasicJsonType& result)
    {
        // read first token
        get_token();

        parse_internal(true, result);
        result.assert_invariant();

        // in strict mode, input must be completely read
        if (strict)
        {
            get_token();
            expect(token_type::end_of_input);
        }

        // in case of an error, return discarded value
        if (errored)
        {
            result = value_t::discarded;
            return;
        }

        // set top-level value to null if it was discarded by the callback
        // function
        if (result.is_discarded())
        {
            result = nullptr;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x9bd0
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x1, %esi
callq 0x9c00
movq -0x18(%rbp), %rdi
callq 0x4e20
testb $0x1, -0x9(%rbp)
je 0x85fd
movq -0x40(%rbp), %rdi
callq 0x9bd0
movq -0x40(%rbp), %rdi
movl $0xf, %esi
callq 0xa700
movq -0x40(%rbp), %rax
testb $0x1, 0xb0(%rax)
je 0x8630
leaq -0x28(%rbp), %rdi
movl $0x8, %esi
callq 0xa770
movq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xa7b0
leaq -0x28(%rbp), %rdi
callq 0x4d80
jmp 0x8662
movq -0x18(%rbp), %rdi
callq 0xa820
testb $0x1, %al
jne 0x863f
jmp 0x8662
leaq -0x38(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4630
movq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xa7b0
leaq -0x38(%rbp), %rdi
callq 0x4d80
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: SYZYGYfpga[P]syzygy-tools/include/json.hpp
// Function: nlohmann::detail::input_stream_adapter::input_stream_adapter(std::istream&)
explicit input_stream_adapter(std::istream& i)
        : is(i), sb(*i.rdbuf())
    {
        // skip byte order mark
        std::char_traits<char>::int_type c;
        if ((c = get_character()) == 0xEF)
        {
            if ((c = get_character()) == 0xBB)
            {
                if ((c = get_character()) == 0xBF)
                {
                    return; // Ignore BOM
                }
                else if (c != std::char_traits<char>::eof())
                {
                    is.unget();
                }
                is.putback('\xBB');
            }
            else if (c != std::char_traits<char>::eof())
            {
                is.unget();
            }
            is.putback('\xEF');
        }
        else if (c != std::char_traits<char>::eof())
        {
            is.unget(); // no byte order mark; process as usual
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x91c0
movq -0x38(%rbp), %rax
leaq 0x18c08(%rip), %rcx     # 0x21c60
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x10, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3180
movq %rax, -0x28(%rbp)
jmp 0x9084
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movl %eax, -0x3c(%rbp)
jmp 0x90a0
movl -0x3c(%rbp), %eax
movl %eax, -0x20(%rbp)
cmpl $0xef, %eax
jne 0x9186
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movl %eax, -0x40(%rbp)
jmp 0x90c2
movl -0x40(%rbp), %eax
movl %eax, -0x20(%rbp)
cmpl $0xbb, %eax
jne 0x9149
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movl %eax, -0x44(%rbp)
jmp 0x90e0
movl -0x44(%rbp), %eax
movl %eax, -0x20(%rbp)
cmpl $0xbf, %eax
jne 0x910c
jmp 0x91ad
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x92b0
jmp 0x91b3
movl -0x20(%rbp), %eax
movl %eax, -0x48(%rbp)
callq 0x91e0
movl %eax, %ecx
movl -0x48(%rbp), %eax
cmpl %ecx, %eax
je 0x9131
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x30e0
jmp 0x912f
jmp 0x9131
jmp 0x9133
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0xffffffbb, %esi       # imm = 0xFFFFFFBB
callq 0x3520
jmp 0x9147
jmp 0x9170
movl -0x20(%rbp), %eax
movl %eax, -0x4c(%rbp)
callq 0x91e0
movl %eax, %ecx
movl -0x4c(%rbp), %eax
cmpl %ecx, %eax
je 0x916e
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x30e0
jmp 0x916c
jmp 0x916e
jmp 0x9170
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0xffffffef, %esi       # imm = 0xFFFFFFEF
callq 0x3520
jmp 0x9184
jmp 0x91ad
movl -0x20(%rbp), %eax
movl %eax, -0x50(%rbp)
callq 0x91e0
movl %eax, %ecx
movl -0x50(%rbp), %eax
cmpl %ecx, %eax
je 0x91ab
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x30e0
jmp 0x91a9
jmp 0x91ab
jmp 0x91ad
addq $0x50, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x34e0
nopl (%rax)
// File: SYZYGYfpga[P]syzygy-tools/include/json.hpp
// Function: nlohmann::detail::parser<nlohmann::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::adl_serializer>>::expect(nlohmann::detail::lexer<nlohmann::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::adl_serializer>>::token_type)
bool expect(token_type t)
    {
        if (JSON_UNLIKELY(t != last_token))
        {
            errored = true;
            expected = t;
            if (allow_exceptions)
            {
                throw_exception();
            }
            else
            {
                return false;
            }
        }

        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x28(%rcx), %eax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xa72a
jmp 0xa756
movq -0x20(%rbp), %rax
movb $0x1, 0xb0(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0xb4(%rax)
testb $0x1, 0xb8(%rax)
je 0xa750
movq -0x20(%rbp), %rdi
callq 0xf020
movb $0x0, -0x1(%rbp)
jmp 0xa75a
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: SYZYGYfpga[P]syzygy-tools/include/json.hpp
// Function: nlohmann::detail::lexer<nlohmann::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::adl_serializer>>::get()
std::char_traits<char>::int_type get()
    {
        ++chars_read;
        current = ia->get_character();
        if (JSON_LIKELY(current != std::char_traits<char>::eof()))
        {
            token_string.push_back(std::char_traits<char>::to_char_type(current));
        }
        return current;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq 0x18(%rdi), %rax
addq $0x1, %rax
movq %rax, 0x18(%rdi)
callq 0xb870
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movl 0x10(%rax), %eax
movl %eax, -0x10(%rbp)
callq 0x91e0
movl %eax, %ecx
movl -0x10(%rbp), %eax
cmpl %ecx, %eax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xaa15
jmp 0xaa3d
movq -0x18(%rbp), %rdi
movq %rdi, %rax
addq $0x20, %rax
movq %rax, -0x20(%rbp)
addq $0x10, %rdi
callq 0xb8c0
movq -0x20(%rbp), %rdi
movb %al, -0x9(%rbp)
leaq -0x9(%rbp), %rsi
callq 0xb890
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: SYZYGYfpga[P]syzygy-tools/include/json.hpp
// Function: nlohmann::detail::lexer<nlohmann::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::adl_serializer>>::scan_literal(char const*, unsigned long, nlohmann::detail::lexer<nlohmann::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::adl_serializer>>::token_type)
token_type scan_literal(const char* literal_text, const std::size_t length,
                            token_type return_type)
    {
        assert(current == literal_text[0]);
        for (std::size_t i = 1; i < length; ++i)
        {
            if (JSON_UNLIKELY(get() != literal_text[i]))
            {
                error_message = "invalid literal";
                return token_type::parse_error;
            }
        }
        return return_type;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl 0x10(%rax), %eax
movq -0x18(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0xaa7f
jmp 0xaa9e
leaq 0xb72c(%rip), %rdi      # 0x161b2
leaq 0xafa1(%rip), %rsi      # 0x15a2e
movl $0xa5d, %edx            # imm = 0xA5D
leaq 0xb734(%rip), %rcx      # 0x161cd
callq 0x3210
movq $0x1, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0xaafc
movq -0x38(%rbp), %rdi
callq 0xa9c0
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xaad4
jmp 0xaaec
movq -0x38(%rbp), %rax
leaq 0xb6a9(%rip), %rcx      # 0x16188
movq %rcx, 0x58(%rax)
movl $0xe, -0x4(%rbp)
jmp 0xab02
jmp 0xaaee
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xaaa6
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: SYZYGYfpga[P]syzygy-tools/include/json.hpp
// Function: nlohmann::detail::lexer<nlohmann::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::adl_serializer>>::unget()
void unget()
    {
        --chars_read;
        if (JSON_LIKELY(current != std::char_traits<char>::eof()))
        {
            ia->unget_character();
            assert(token_string.size() != 0);
            token_string.pop_back();
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x18(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x18(%rax)
movl 0x10(%rax), %eax
movl %eax, -0xc(%rbp)
callq 0x91e0
movl %eax, %ecx
movl -0xc(%rbp), %eax
cmpl %ecx, %eax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xc67f
jmp 0xc6d2
movq -0x18(%rbp), %rdi
callq 0xb870
movq %rax, %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0xbde0
cmpq $0x0, %rax
je 0xc6a6
jmp 0xc6c5
leaq 0xa0b7(%rip), %rdi      # 0x16764
leaq 0x937a(%rip), %rsi      # 0x15a2e
movl $0xa91, %edx            # imm = 0xA91
leaq 0xa0bd(%rip), %rcx      # 0x1677d
callq 0x3210
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0xc710
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: SYZYGYfpga[P]syzygy-tools/smartvio/syzygy.c
// Function: szgComputeCRC
unsigned short
szgComputeCRC(const unsigned char *data, unsigned int length)
{
	unsigned short x, crc = 0xffff;

	while (length--){
		x = (crc >> 8) ^ *data++;
		x ^= x>>4;
		crc = (crc<<8) ^ (x<<12) ^ (x<<5) ^ (x);
		crc &= 0xffff;
	}
	return(crc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movw $0xffff, -0x10(%rbp)    # imm = 0xFFFF
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
cmpl $0x0, %eax
je 0x140f3
movzwl -0x10(%rbp), %eax
sarl $0x8, %eax
movq -0x8(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movzbl (%rcx), %ecx
xorl %ecx, %eax
movw %ax, -0xe(%rbp)
movzwl -0xe(%rbp), %ecx
sarl $0x4, %ecx
movzwl -0xe(%rbp), %eax
xorl %ecx, %eax
movw %ax, -0xe(%rbp)
movzwl -0x10(%rbp), %eax
shll $0x8, %eax
movzwl -0xe(%rbp), %ecx
shll $0xc, %ecx
xorl %ecx, %eax
movzwl -0xe(%rbp), %ecx
shll $0x5, %ecx
xorl %ecx, %eax
movzwl -0xe(%rbp), %ecx
xorl %ecx, %eax
movw %ax, -0x10(%rbp)
movzwl -0x10(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movw %ax, -0x10(%rbp)
jmp 0x14081
movw -0x10(%rbp), %ax
popq %rbp
retq
nopl (%rax)
// File: thunlp[P]KB2E/CTransR/Test_CTransR.cpp
// Function: vec_len(std::vector<double, std::allocator<double>>)
double vec_len(vector<double> a)
{
	double res=0;
	for (int i=0; i<a.size(); i++)
		res+=a[i]*a[i];
	return sqrt(res);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, 0x30(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movq 0x18(%rsp), %rdi
movslq 0x24(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x3b50
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x2943
movq 0x18(%rsp), %rdi
movslq 0x24(%rsp), %rsi
callq 0x3b70
movq 0x18(%rsp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movslq 0x24(%rsp), %rsi
callq 0x3b70
movsd 0x8(%rsp), %xmm0
movsd (%rax), %xmm2
movsd 0x28(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x28cf
movsd 0x28(%rsp), %xmm0
callq 0x2170
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: thunlp[P]KB2E/CTransR/Test_CTransR.cpp
// Function: vec_output(std::vector<double, std::allocator<double>>)
void vec_output(vector<double> a)
{
	for (int i=0; i<a.size(); i++)
	{
		cout<<a[i]<<"\t";
		if (i%9==4)
			cout<<endl;
	}
	cout<<"-------------------------"<<endl;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rdi
movslq 0x1c(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x3b50
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x29fb
movq 0x10(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0x3b70
movsd (%rax), %xmm0
movq 0x1d627(%rip), %rdi     # 0x1ffd8
callq 0x2380
movq %rax, %rdi
leaq 0x13685(%rip), %rsi     # 0x16045
callq 0x21c0
movl 0x1c(%rsp), %eax
movl $0x9, %ecx
cltd
idivl %ecx
cmpl $0x4, %edx
jne 0x29e9
movq 0x1d5fb(%rip), %rdi     # 0x1ffd8
movq 0x1d5dc(%rip), %rsi     # 0x1ffc0
callq 0x2210
jmp 0x29eb
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x2976
movq 0x1d5d6(%rip), %rdi     # 0x1ffd8
leaq 0x1363e(%rip), %rsi     # 0x16047
callq 0x21c0
movq %rax, %rdi
movq 0x1d5a8(%rip), %rsi     # 0x1ffc0
callq 0x2210
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: thunlp[P]KB2E/CTransR/Test_CTransR.cpp
// Function: main
int main(int argc,char**argv)
{
    if (argc<2)
        return 0;
    else
    {
        version = argv[1];
        if (argc==3)
            trainortest = argv[2];
        prepare();
        test.run();
    }
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpl $0x2, 0x10(%rsp)
jge 0x3956
movl $0x0, 0x14(%rsp)
jmp 0x3998
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
leaq 0x1c8b2(%rip), %rdi     # 0x20218
callq 0x22a0
cmpl $0x3, 0x10(%rsp)
jne 0x3987
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
leaq 0x1c8b6(%rip), %rdi     # 0x20238
callq 0x22a0
callq 0x2ac0
leaq 0x4d85d(%rip), %rdi     # 0x511f0
callq 0x4370
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: thunlp[P]KB2E/CTransR/Test_CTransR.cpp
// Function: Test::add(int, int, int, bool)
void add(int x,int y,int z, bool flag)
    {
    	if (flag)
    	{
        	fb_h.push_back(x);
        	fb_r.push_back(z);
        	fb_l.push_back(y);
        }
        ok[make_pair(x,z)][y]=1;
    }

// Assembly:
subq $0x38, %rsp
movb %r8b, %al
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
andb $0x1, %al
movb %al, 0x23(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
testb $0x1, 0x23(%rsp)
je 0x4321
movq 0x10(%rsp), %rdi
addq $0xc0, %rdi
leaq 0x2c(%rsp), %rsi
callq 0x4240
movq 0x10(%rsp), %rdi
addq $0xf0, %rdi
leaq 0x24(%rsp), %rsi
callq 0x4240
movq 0x10(%rsp), %rdi
addq $0xd8, %rdi
leaq 0x28(%rsp), %rsi
callq 0x4240
movq 0x10(%rsp), %rax
addq $0x108, %rax            # imm = 0x108
movq %rax, 0x8(%rsp)
leaq 0x2c(%rsp), %rdi
leaq 0x24(%rsp), %rsi
callq 0x8e00
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rsi
callq 0x8d10
movq %rax, %rdi
leaq 0x28(%rsp), %rsi
callq 0x4060
movl $0x1, (%rax)
addq $0x38, %rsp
retq
nopl (%rax)
// File: AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: main
int main()
{
    Tree code = {};
    TreeConstructor (&code);

    if (LoadTree (&code))
        GoElf (&code);

    TreeDestructor (&code);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
movq $0x0, -0x58(%rbp)
movabsq $-0x452212e21844f85f, %rax # imm = 0xBADDED1DE7BB07A1
movq %rax, -0x50(%rbp)
movq $0x0, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movl $0xc, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movabsq $-0x452212e21844f85f, %rax # imm = 0xBADDED1DE7BB07A1
movq %rax, -0x10(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3d90
leaq -0x58(%rbp), %rdi
callq 0x45c0
testb $0x1, %al
jne 0x1302
jmp 0x130b
leaq -0x58(%rbp), %rdi
callq 0x1320
leaq -0x58(%rbp), %rdi
callq 0x3df0
xorl %eax, %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: GoElf(Tree*)
void GoElf (Tree* code)
{
    assert (code);

    Elf elf = {};
    if (ElfConstructor (&elf))
        return;
    
    ElfAddBytes (&elf, "\xE8\x00\x00\x00\x00"           // call ♂sex♂
                       "\x48\xC7\xC0\x3C\x00\x00\x00"   // mov rax, 0x3C
                       "\x48\x31\xFF"                   // xor rdi, rdi
                       "\x0F\x05",                      // syscall
                       17);

    ElfAddPlace (&elf, "♂sex♂", 1);

    if (PrintDec (&elf, code->head))
        printf ("Something went wrong...\n");

    ElfCreateJumps (&elf);
    ElfWrite (&elf);
    system ("chmod u+x CompileResult/RightProgram.elf");
    ElfDestructor (&elf);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1335
jmp 0x1354
leaq 0x513d(%rip), %rdi      # 0x6479
leaq 0x4dd3(%rip), %rsi      # 0x6116
movl $0x12b, %edx            # imm = 0x12B
leaq 0x512f(%rip), %rcx      # 0x647e
callq 0x1080
movq $0x0, -0x70(%rbp)
movq $-0x1, -0x68(%rbp)
movq $0x0, -0x60(%rbp)
movq $0x0, -0x58(%rbp)
movq $0x0, -0x50(%rbp)
movq $-0x1, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movb $0x0, -0x10(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x1450
testb $0x1, %al
jne 0x13c7
jmp 0x13c9
jmp 0x143e
leaq -0x70(%rbp), %rdi
leaq 0x4d15(%rip), %rsi      # 0x60e9
movl $0x11, %edx
callq 0x1690
leaq -0x70(%rbp), %rdi
leaq 0x50a8(%rip), %rsi      # 0x6491
movl $0x1, %edx
callq 0x1890
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq -0x70(%rbp), %rdi
callq 0x2100
testb $0x1, %al
jne 0x1409
jmp 0x1417
leaq 0x508b(%rip), %rdi      # 0x649b
movb $0x0, %al
callq 0x1040
leaq -0x70(%rbp), %rdi
callq 0x1d50
leaq -0x70(%rbp), %rdi
callq 0x1fa0
leaq 0x5084(%rip), %rdi      # 0x64b4
callq 0x10c0
leaq -0x70(%rbp), %rdi
callq 0x14f0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: ElfConstructor(Elf*)
bool ElfConstructor (Elf* elf)
{
    assert (elf);

    elf->text = (char*) calloc (ALIGN, sizeof (*(elf->text)));
    if (!(elf->text))
        return 1;
    
    elf->printf_.func_name  = PRINT_STR;
    elf-> scanf_.func_name  = SCAN_STR;
    elf->aligned_text_size  = ALIGN;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1465
jmp 0x1484
leaq 0x4ef0(%rip), %rdi      # 0x635c
leaq 0x4ca3(%rip), %rsi      # 0x6116
movl $0x11, %edx
leaq 0x4cab(%rip), %rcx      # 0x612a
callq 0x1080
movl $0x1000, %edi           # imm = 0x1000
movl $0x1, %esi
callq 0x1090
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x14af
movb $0x1, -0x1(%rbp)
jmp 0x14dc
movq -0x10(%rbp), %rax
leaq 0x4bf2(%rip), %rcx      # 0x60ac
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
leaq 0x4bf2(%rip), %rcx      # 0x60ba
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq $0x1000, 0x58(%rax)     # imm = 0x1000
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: ElfDestructor(Elf*)
bool ElfDestructor  (Elf* elf)
{
    assert (elf);

    free (elf->text);
    elf->aligned_text_size = 0;
    elf->text_size = 0;
    bool ret = FuncPointerDestructor (elf->functions);
    elf->functions = 0;

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1505
jmp 0x1524
leaq 0x4e50(%rip), %rdi      # 0x635c
leaq 0x4c03(%rip), %rsi      # 0x6116
movl $0x1f, %edx
leaq 0x4c26(%rip), %rcx      # 0x6145
callq 0x1080
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x1110
movq -0x8(%rbp), %rax
movq $0x0, 0x58(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x50(%rax)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x1580
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x48(%rax)
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: FuncPointerDestructor(FuncPointer*)
bool FuncPointerDestructor  (FuncPointer* func_p)
{
    assert (func_p);

    while (func_p)
    {
        PointerPlace* i_place = func_p->last_pl;
        while (i_place)
        {
            PointerPlace* next_place = i_place->next_place;
            *i_place = {};
            free (i_place);
            i_place  = next_place;
        }

        FuncPointer* next_func = func_p->p_next;
        *func_p = {};
        free (func_p);
        func_p = next_func;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1595
jmp 0x15b4
leaq 0x4e42(%rip), %rdi      # 0x63de
leaq 0x4b73(%rip), %rsi      # 0x6116
movl $0xf5, %edx
leaq 0x4e36(%rip), %rcx      # 0x63e5
callq 0x1080
jmp 0x15b6
cmpq $0x0, -0x8(%rbp)
je 0x167b
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1616
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq $-0x1, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x1110
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x15cd
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x50(%rbp)
movq $-0x1, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, (%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rdi
callq 0x1110
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x15b6
xorl %eax, %eax
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: ElfAddBytes(Elf*, char const*, unsigned long)
bool ElfAddBytes    (Elf* elf, const char* bytes, size_t amount_bytes)
{
    assert (elf);
    assert (bytes);
    if (elf->aligned_text_size < elf->text_size + amount_bytes)
        if (ElfResizeText (elf))
            return 1;

    memcpy (elf->text + elf->text_size, bytes, amount_bytes);
    elf->text_size += amount_bytes;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x16ad
jmp 0x16cc
leaq 0x4ca8(%rip), %rdi      # 0x635c
leaq 0x4a5b(%rip), %rsi      # 0x6116
movl $0x2c, %edx
leaq 0x4a98(%rip), %rcx      # 0x615f
callq 0x1080
cmpq $0x0, -0x18(%rbp)
je 0x16d5
jmp 0x16f4
leaq 0x4ab1(%rip), %rdi      # 0x618d
leaq 0x4a33(%rip), %rsi      # 0x6116
movl $0x2d, %edx
leaq 0x4a70(%rip), %rcx      # 0x615f
callq 0x1080
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x50(%rcx), %rcx
addq -0x20(%rbp), %rcx
cmpq %rcx, %rax
jae 0x1724
movq -0x10(%rbp), %rdi
callq 0x1760
testb $0x1, %al
jne 0x171c
jmp 0x1722
movb $0x1, -0x1(%rbp)
jmp 0x1755
jmp 0x1724
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x10(%rbp), %rax
addq 0x50(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x10b0
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x50(%rax), %rcx
movq %rcx, 0x50(%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
// File: AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: ElfResizeText(Elf*)
bool ElfResizeText  (Elf* elf)
{
    assert (elf);

    elf->text = (char*) realloc (elf->text, elf->aligned_text_size + ALIGN); // sizeof (byte = 1)
    if (!(elf->text)) return 1;
    elf->aligned_text_size += ALIGN;
    return ElfFillZero (elf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1775
jmp 0x1794
leaq 0x4be0(%rip), %rdi      # 0x635c
leaq 0x4993(%rip), %rsi      # 0x6116
movl $0x39, %edx
leaq 0x4a04(%rip), %rcx      # 0x6193
callq 0x1080
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rsi
addq $0x1000, %rsi           # imm = 0x1000
callq 0x1160
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x17cc
movb $0x1, -0x1(%rbp)
jmp 0x17ed
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rcx
addq $0x1000, %rcx           # imm = 0x1000
movq %rcx, 0x58(%rax)
movq -0x10(%rbp), %rdi
callq 0x1800
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: ElfFillZero(Elf*)
bool ElfFillZero    (Elf* elf)
{
    assert (elf);

    if (elf->aligned_text_size < ALIGN)
        return 1;
    
    for (size_t i_byte = 0; i_byte < ALIGN / 4; i_byte++)
        ((size_t*) elf->text)[i_byte] = 0;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1815
jmp 0x1834
leaq 0x4b40(%rip), %rdi      # 0x635c
leaq 0x48f3(%rip), %rsi      # 0x6116
movl $0x43, %edx
leaq 0x497e(%rip), %rcx      # 0x61ad
callq 0x1080
movq -0x10(%rbp), %rax
cmpq $0x1000, 0x58(%rax)     # imm = 0x1000
jae 0x1848
movb $0x1, -0x1(%rbp)
jmp 0x1880
movq $0x0, -0x18(%rbp)
cmpq $0x400, -0x18(%rbp)     # imm = 0x400
jae 0x187c
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x18(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1850
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: ElfAddPlace(Elf*, char const*, unsigned long)
bool ElfAddPlace    (Elf* elf, const char* func_name, size_t place)
{
    assert (elf);

    if (strcmp (PRINT_STR, func_name) == 0)
        return ElfAddPrintf (elf, place);

    if (strcmp (SCAN_STR, func_name)  == 0)
        return ElfAddScanf  (elf, place);

    FuncPointer* func_p = elf->functions;
    while (func_p)
    {
        if (strcmp (func_p->func_name, func_name) == 0)
            return FuncPointerGetNewPlace (func_p, place);
        
        func_p = func_p->p_next;
    }
    
    if (FuncPointerConstructor (elf, func_name))
        return 1;
    
    return FuncPointerGetNewPlace (elf->functions, place);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x18ad
jmp 0x18cc
leaq 0x4aa8(%rip), %rdi      # 0x635c
leaq 0x485b(%rip), %rsi      # 0x6116
movl $0x4f, %edx
leaq 0x48fe(%rip), %rcx      # 0x61c5
callq 0x1080
movq -0x18(%rbp), %rsi
leaq 0x47d5(%rip), %rdi      # 0x60ac
callq 0x1130
cmpl $0x0, %eax
jne 0x18f8
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x19b0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x199a
movq -0x18(%rbp), %rsi
leaq 0x47b7(%rip), %rdi      # 0x60ba
callq 0x1130
cmpl $0x0, %eax
jne 0x1921
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1a00
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x199a
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x196b
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x1130
cmpl $0x0, %eax
jne 0x195d
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1a60
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x199a
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x192d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1af0
testb $0x1, %al
jne 0x197e
jmp 0x1984
movb $0x1, -0x1(%rbp)
jmp 0x199a
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x1a60
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: FuncPointerGetNewPlace(FuncPointer*, unsigned long)
bool FuncPointerGetNewPlace (FuncPointer* func_p, size_t place)
{
    assert (func_p);

    PointerPlace* new_place = (PointerPlace*) calloc (1, sizeof (*new_place));
    if (!new_place)
        return 1;
    
    new_place->point = place;
    new_place->next_place = func_p->last_pl;
    func_p->last_pl = new_place;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1a79
jmp 0x1a98
leaq 0x495e(%rip), %rdi      # 0x63de
leaq 0x468f(%rip), %rsi      # 0x6116
movl $0x10d, %edx            # imm = 0x10D
leaq 0x497c(%rip), %rcx      # 0x640f
callq 0x1080
movl $0x1, %edi
movl $0x10, %esi
callq 0x1090
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1ab8
movb $0x1, -0x1(%rbp)
jmp 0x1ae3
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: FuncPointerConstructor(Elf*, char const*)
bool FuncPointerConstructor (Elf* elf, const char* func_name)
{
    assert (elf);
    assert (func_name);

    FuncPointer* func_p = (FuncPointer*) calloc (1, sizeof (*func_p));
    if (!func_p)
        return 1;
    
    func_p->func_name = func_name;
    func_p->p_next    = elf->functions;
    elf->functions    = func_p;
    func_p->func_pl   = elf->text_size;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1b09
jmp 0x1b28
leaq 0x484c(%rip), %rdi      # 0x635c
leaq 0x45ff(%rip), %rsi      # 0x6116
movl $0xe5, %edx
leaq 0x488a(%rip), %rcx      # 0x63ad
callq 0x1080
cmpq $0x0, -0x18(%rbp)
je 0x1b31
jmp 0x1b50
leaq 0x4721(%rip), %rdi      # 0x6259
leaq 0x45d7(%rip), %rsi      # 0x6116
movl $0xe6, %edx
leaq 0x4862(%rip), %rcx      # 0x63ad
callq 0x1080
movl $0x1, %edi
movl $0x20, %esi
callq 0x1090
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1b70
movb $0x1, -0x1(%rbp)
jmp 0x1bab
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: ElfAddFunc(Elf*, char const*)
bool ElfAddFunc     (Elf* elf, const char* func_name)
{
    assert (elf);
    assert (func_name);

    FuncPointer* func_p = elf->functions;
    while (func_p)
    {
        if (strcmp (func_p->func_name, func_name) == 0)
        {
            func_p->func_pl = elf->text_size;
            return 0;
        }

        func_p = func_p->p_next;
    }

    return FuncPointerConstructor (elf, func_name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1bd9
jmp 0x1bf8
leaq 0x477c(%rip), %rdi      # 0x635c
leaq 0x452f(%rip), %rsi      # 0x6116
movl $0x76, %edx
leaq 0x4641(%rip), %rcx      # 0x6234
callq 0x1080
cmpq $0x0, -0x18(%rbp)
je 0x1c01
jmp 0x1c20
leaq 0x4651(%rip), %rdi      # 0x6259
leaq 0x4507(%rip), %rsi      # 0x6116
movl $0x77, %edx
leaq 0x4619(%rip), %rcx      # 0x6234
callq 0x1080
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1c6c
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x1130
cmpl $0x0, %eax
jne 0x1c5e
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x1c7e
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x1c2c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1af0
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: ElfCreateJumps(Elf*)
bool ElfCreateJumps (Elf* elf)
{
    assert (elf);

    FuncPointer* func_p = elf->functions;

    while (func_p)
    {
        if (func_p->func_pl == __SIZE_MAX__)
        {
            printf ("Error: Function \"%s\" isn't defined.\n", func_p->func_name);
            return 1;
        }

        FuncPointerFillPlaces (func_p, elf->text);
        func_p = func_p->p_next;
    }

    if (elf->printf_.last_pl)
        if (ElfAddLibrary (elf, "Libraries/printf.gcmlib", &(elf->printf_)))
            return 1;

    if (elf->scanf_.last_pl)
        if (ElfAddLibrary (elf, "Libraries/scanf.gcmlib", &(elf->scanf_)))
            return 1;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1d65
jmp 0x1d84
leaq 0x45f0(%rip), %rdi      # 0x635c
leaq 0x43a3(%rip), %rsi      # 0x6116
movl $0x9d, %edx
leaq 0x451a(%rip), %rcx      # 0x6299
callq 0x1080
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1ddf
movq -0x18(%rbp), %rax
cmpq $-0x1, 0x8(%rax)
jne 0x1dc0
movq -0x18(%rbp), %rax
movq (%rax), %rsi
leaq 0x4504(%rip), %rdi      # 0x62b4
movb $0x0, %al
callq 0x1040
movb $0x1, -0x1(%rbp)
jmp 0x1e41
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
callq 0x1e50
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1d90
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1e0c
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x44e0(%rip), %rsi      # 0x62d9
callq 0x1f10
testb $0x1, %al
jne 0x1e04
jmp 0x1e0a
movb $0x1, -0x1(%rbp)
jmp 0x1e41
jmp 0x1e0c
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x1e3d
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rdx
addq $0x20, %rdx
leaq 0x44c7(%rip), %rsi      # 0x62f1
callq 0x1f10
testb $0x1, %al
jne 0x1e35
jmp 0x1e3b
movb $0x1, -0x1(%rbp)
jmp 0x1e41
jmp 0x1e3d
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)