LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/Nallantli[P]Rossa/main/rossa/operation/operation.cpp
// Function: operation::call(object_t const*, std::shared_ptr<Instruction const> const&, std::vector<symbol_t, std::allocator<symbol_t>> const&, token_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&)
const symbol_t operation::call(const object_t *scope, const ptr_instruction_t &a, const std::vector<symbol_t> &args, const token_t *token, trace_t &stack_trace)
{
	const symbol_t evalA = a->evaluate(scope, stack_trace);

	if (evalA.getValueType() == value_type_enum::OBJECT)
	{
		const auto &o = evalA.getObject(token, stack_trace);
		if (o->hasValue(parser_t::HASH_CALL))
			return o->getVariable(parser_t::HASH_CALL, token, stack_trace).call(args, token, stack_trace);
	}

	return evalA.call(args, token, stack_trace);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
movq %rsi, %rax
movq %rdi, %rbx
movq (%rdx), %rsi
movq (%rsi), %r8
movq %rsp, %r13
movq %r13, %rdi
movq %rax, %rdx
movq %r9, %rcx
callq *(%r8)
movq %r13, %rdi
callq 0x40b5a
cmpl $-0x8, %eax
jne 0x7909f
movq %rsp, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x40a9e
movq %rax, %r13
leaq 0x3c970(%rip), %rsi     # 0xb59d8
movq %rax, %rdi
callq 0x3ce6c
testb %al, %al
je 0x7909f
leaq 0x3c95d(%rip), %rsi     # 0xb59d8
movq %r13, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x3ced2
movq %rbx, %rdi
movq %rax, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x41ffe
jmp 0x790b3
movq %rsp, %rsi
movq %rbx, %rdi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x41ffe
movq %rsp, %rdi
callq 0x3fe06
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x790d0
jmp 0x790d0
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3fe06
movq %rbx, %rdi
callq 0x106f0
// File: /workspace/github_cpp_makefile_star2_O3/Nallantli[P]Rossa/main/rossa/operation/operation.cpp
// Function: operation::hash(object_t const*, symbol_t const&, token_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&)
const symbol_t operation::hash(const object_t *scope, const symbol_t &evalA, const token_t *token, trace_t &stack_trace)
{
	if (evalA.getValueType() == value_type_enum::OBJECT)
	{
		const auto &o = evalA.getObject(token, stack_trace);
		if (o->hasValue(parser_t::HASH_HASH))
			return o->getVariable(parser_t::HASH_HASH, token, stack_trace).call({}, token, stack_trace);
		if (scope != NULL)
			return scope->getVariable(parser_t::HASH_HASH, token, stack_trace).call({evalA}, token, stack_trace);
	}

	return symbol_t::Number(number_t::Long(evalA.hash()));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq %rdx, %rdi
callq 0x40b5a
cmpl $-0x8, %eax
jne 0x81c35
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x40a9e
movq %rax, %rbp
leaq 0x33ea6(%rip), %rsi     # 0xb5a18
movq %rax, %rdi
callq 0x3ce6c
testb %al, %al
je 0x81bc6
leaq 0x33e93(%rip), %rsi     # 0xb5a18
movq %rbp, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x3ced2
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, (%rdx)
movq $0x0, 0x10(%rdx)
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rcx
movq %r14, %r8
callq 0x41ffe
leaq 0x10(%rsp), %rdi
callq 0x20952
jmp 0x81c5f
testq %r13, %r13
je 0x81c35
leaq 0x33e46(%rip), %rsi     # 0xb5a18
movq %r13, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x3ced2
movq %rax, %r13
leaq 0x28(%rsp), %rdi
movq %r12, %rsi
callq 0x3fdf4
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0xf(%rsp), %rcx
movl $0x1, %edx
callq 0x436ac
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rcx
movq %r14, %r8
callq 0x41ffe
leaq 0x10(%rsp), %rdi
callq 0x20952
leaq 0x28(%rsp), %rdi
callq 0x3fe06
jmp 0x81c5f
movq %r12, %rdi
callq 0x3fe68
movl %eax, %eax
leaq 0x28(%rsp), %rdi
movq %rax, (%rdi)
callq 0x47014
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movl %edx, 0x8(%rsi)
movq %rbx, %rdi
callq 0x3fd84
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x20952
jmp 0x81c83
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3fe06
jmp 0x81ca1
movq %rax, %rbx
jmp 0x81ca1
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x20952
movq %rbx, %rdi
callq 0x106f0
// File: /workspace/github_cpp_makefile_star2_O3/pollow[P]MIPSClide/simulator.cpp
// Function: Simulator::run()
void Simulator::run() {
    while (pc < statements.size()) {
        cout << statements[pc] << endl;
        tick();
    }

    for(auto i : reg_name) {
        cout << i.first << " : " << dec << regs[i.second] << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x98(%rdi), %rax
movq 0x20(%rdi), %rcx
movq 0x28(%rdi), %rdx
subq %rcx, %rdx
sarq $0x5, %rdx
cmpq %rdx, %rax
jae 0xa5fc
movq 0x239fe(%rip), %r14     # 0x2df98
shlq $0x5, %rax
movq (%rcx,%rax), %rsi
movq 0x8(%rcx,%rax), %rdx
movq %r14, %rdi
callq 0x5390
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x52f0
movsbl %al, %esi
movq %r15, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x5220
movq %rbx, %rdi
callq 0xa6fe
movq 0x98(%rbx), %rax
movq 0x20(%rbx), %rcx
movq 0x28(%rbx), %rdx
subq %rcx, %rdx
sarq $0x5, %rdx
cmpq %rdx, %rax
jb 0xa59a
movq 0x24165(%rip), %r14     # 0x2e768
leaq 0x2414e(%rip), %r13     # 0x2e758
cmpq %r13, %r14
je 0xa6d6
leaq -0x40(%rbp), %r12
movq %r12, -0x50(%rbp)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %rdi
callq 0x9c9c
movl 0x40(%r14), %eax
movl %eax, -0x30(%rbp)
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq 0x23953(%rip), %rdi     # 0x2df98
callq 0x5390
movq %rax, %r15
movl $0x3, %edx
movq %rax, %rdi
leaq 0x18ab7(%rip), %rsi     # 0x23113
callq 0x5390
movq (%r15), %rax
movq -0x18(%rax), %rax
movl 0x18(%r15,%rax), %ecx
andl $-0x4b, %ecx
orl $0x2, %ecx
movl %ecx, 0x18(%r15,%rax)
movl -0x30(%rbp), %eax
movl 0xc0(%rbx,%rax,4), %esi
movq %r15, %rdi
callq 0x5530
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x52f0
movsbl %al, %esi
movq %r15, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x5220
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0xa6c2
callq 0x52d0
movq %r14, %rdi
callq 0x5230
movq %rax, %r14
cmpq %r13, %rax
jne 0xa617
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0xa6f6
callq 0x52d0
movq %rbx, %rdi
callq 0x5570
// File: /workspace/github_cpp_makefile_star2_O3/pollow[P]MIPSClide/simulator.cpp
// Function: Simulator::init()
void Simulator::init() {
    origin.assign(statements.begin(), statements.end());
    split();
    trim();
    format();
    calc_label();
    parse();
    
    memory = new int32_t[300000];
    memset(memory, 0, sizeof(int32_t) * 300000);
    memset(regs, 0, sizeof(int32_t) * 32);
    pc = 0;

    print("plain", cout);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
addq $0xa0, %rdi
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
callq 0xb730
movq %rbx, %rdi
callq 0xfdfe
movq %rbx, %rdi
callq 0xfc10
movq %rbx, %rdi
callq 0xff22
movq %rbx, %rdi
callq 0xf9fe
movq %rbx, %rdi
callq 0xd47c
movl $0x124f80, %edi         # imm = 0x124F80
callq 0x5030
movq %rax, 0xb8(%rbx)
movl $0x124f80, %edx         # imm = 0x124F80
movq %rax, %rdi
xorl %esi, %esi
callq 0x51c0
xorps %xmm0, %xmm0
movups %xmm0, 0xc0(%rbx)
movups %xmm0, 0xd0(%rbx)
movups %xmm0, 0xe0(%rbx)
movups %xmm0, 0xf0(%rbx)
movups %xmm0, 0x100(%rbx)
movups %xmm0, 0x110(%rbx)
movups %xmm0, 0x120(%rbx)
movups %xmm0, 0x130(%rbx)
movq $0x0, 0x98(%rbx)
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x17fe6(%rip), %rsi     # 0x23117
leaq 0x17fe4(%rip), %rdx     # 0x2311c
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0xa0b8
movq 0x22e4d(%rip), %rdx     # 0x2df98
movq %rbx, %rdi
movq %r14, %rsi
callq 0x102fa
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0xb164
callq 0x52d0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0xb180
callq 0x52d0
movq %rbx, %rdi
callq 0x5570
// File: /workspace/github_cpp_makefile_star2_O3/ksherlock[P]wdc-utils/link.cpp
// Function: reserve_symbol(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
symbol &reserve_symbol(const std::string &name, bool open = true) {

	auto iter = symbol_map.find(name);
	if (iter != symbol_map.end()) return symbols[iter->second];

	if (open) undefined_symbols.emplace(name);
	else undefined_symbols.erase(name);

	symbols.emplace_back();
	auto &sym = symbols.back();

	sym.name = name;
	sym.type = S_UND;
	sym.section = symbols.size() - 1;

	symbol_map.emplace(name, sym.section);

	return sym;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x110b1(%rip), %rdi     # 0x15318
movq %rbx, %rsi
callq 0x7e6c
testq %rax, %rax
je 0x428c
movslq 0x28(%rax), %rax
leaq (%rax,%rax,2), %r14
shlq $0x4, %r14
addq 0x110c9(%rip), %r14     # 0x15350
jmp 0x431a
testb %bpl, %bpl
je 0x42a2
leaq 0x110d0(%rip), %rdi     # 0x15368
movq %rbx, %rsi
callq 0x9b4c
jmp 0x42bf
leaq 0x110bf(%rip), %r14     # 0x15368
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8d58
movq %r14, %rdi
movq %rax, %rsi
callq 0x8e0c
leaq 0x1108a(%rip), %rdi     # 0x15350
callq 0x6e06
movq 0x11086(%rip), %r15     # 0x15358
leaq -0x30(%r15), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2160
movb $0x0, -0x10(%r15)
movq 0x1106b(%rip), %rax     # 0x15358
subq 0x1105c(%rip), %rax     # 0x15350
shrq $0x4, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
decl %eax
movl %eax, -0x8(%r15)
addq $-0x8, %r15
leaq 0x11009(%rip), %rdi     # 0x15318
movq %rbx, %rsi
movq %r15, %rdx
callq 0x9dfc
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ksherlock[P]wdc-utils/link.cpp
// Function: one_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool one_file(const std::string &name) {

	if (flags.v) printf("Processing %s\n", name.c_str());

	int fd = open(name.c_str(), O_RDONLY | O_BINARY);
	if (fd < 0) {
		warn("Unable to open %s", name.c_str());
		return false;
	}
	bool rv = false;

	Header h;
	ssize_t ok;

	ok = read(fd, &h, sizeof(h));
	if (ok != sizeof(h)) {
		warnx("Invalid object file: %s", name.c_str());
		close(fd);
		return false;
	}

	le_to_host(h.magic);
	le_to_host(h.version);
	le_to_host(h.filetype);

	if (h.magic != MOD_MAGIC || h.version != MOD_VERSION || h.filetype < MOD_OBJECT || h.filetype > MOD_LIBRARY) {
		warnx("Invalid object file: %s", name.c_str());
		close(fd);
		return false;
	}

	if (h.filetype == MOD_LIBRARY) {
		warnx("%s is a library", name.c_str());
		close(fd);
		// todo -- add to library list...
		return true;
	}

	lseek(fd, 0, SEEK_SET);
	while(one_module(name, fd)) ;

	close(fd);
	return true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpb $0x1, 0x103c3(%rip)     # 0x15260
jne 0x4eb0
movq (%rbx), %rsi
leaq 0xa60d(%rip), %rdi      # 0xf4b6
xorl %eax, %eax
callq 0x2050
movq (%rbx), %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x21f0
testl %eax, %eax
js 0x4f1d
movl %eax, %ebp
leaq 0x8(%rsp), %rsi
movl $0x7, %edx
movl %eax, %edi
callq 0x2320
leaq 0xa51d(%rip), %rdi      # 0xf3f7
cmpq $0x7, %rax
jne 0x4f07
cmpl $0x5a44525a, 0x8(%rsp)  # imm = 0x5A44525A
setne %al
cmpw $0x1, 0xc(%rsp)
setne %cl
orb %al, %cl
movb 0xe(%rsp), %al
leal -0x3(%rax), %edx
cmpb $-0x2, %dl
setb %dl
orb %cl, %dl
je 0x4f3d
xorl %r14d, %r14d
movq (%rbx), %rsi
xorl %eax, %eax
callq 0x2290
movl %ebp, %edi
callq 0x2460
jmp 0x4f31
movq (%rbx), %rsi
leaq 0xa59e(%rip), %rdi      # 0xf4c5
xorl %r14d, %r14d
xorl %eax, %eax
callq 0x20f0
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
cmpb $0x2, %al
jne 0x4f4d
movb $0x1, %r14b
leaq 0xa58c(%rip), %rdi      # 0xf4d7
jmp 0x4f0a
movl %ebp, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2420
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x4b1f
testb %al, %al
jne 0x4f58
movb $0x1, %r14b
jmp 0x4f14
// File: /workspace/github_cpp_makefile_star2_O3/ksherlock[P]wdc-utils/link.cpp
// Function: intersection(std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned int, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, unsigned int>>> const&, std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::map<unsigned int, int, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, int>>>&)
bool intersection(const std::unordered_map<std::string, uint32_t> &a,
	const std::set<std::string> &b, 
	std::map<uint32_t, int> &c)
{
	bool rv = false;

	for (const auto &name : b) {
		auto iter = a.find(name);
		if (iter == a.end()) continue;
		rv = true;
		c.emplace(iter->second, kPending);		
	}

	return rv;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, (%rsp)
movq %rsi, %r14
movq 0x18(%rsi), %r12
addq $0x8, %r14
cmpq %r14, %r12
je 0x500a
movq %rdi, %r15
xorl %ebp, %ebp
leaq 0x20(%r12), %rsi
movq %r15, %rdi
callq 0xac34
testq %rax, %rax
je 0x4ff8
movq %rax, %rbx
movl $0x28, %edi
callq 0x2250
movq %rax, %r13
movl 0x28(%rbx), %eax
leaq 0x20(%r13), %rsi
movl %eax, 0x20(%r13)
movl $0x1, 0x24(%r13)
movq (%rsp), %rdi
callq 0xad30
testq %rdx, %rdx
je 0x4fe8
movb $0x1, %bpl
movq (%rsp), %rdi
movq %rax, %rsi
movq %r13, %rcx
callq 0xad94
jmp 0x4ff8
movl $0x28, %esi
movq %r13, %rdi
callq 0x2260
movb $0x1, %bpl
movq %r12, %rdi
callq 0x22c0
movq %rax, %r12
cmpq %r14, %rax
jne 0x4f91
jmp 0x500c
xorl %ebp, %ebp
andb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5023
movq %rax, %rdi
callq 0x2120
movl $0x28, %esi
movq %r13, %rdi
callq 0x2260
callq 0x2330
movq %rax, %rbx
callq 0x23a0
movq %rbx, %rdi
callq 0x23c0
movq %rax, %rdi
callq 0x725c
// File: /workspace/github_cpp_makefile_star2_O3/ksherlock[P]wdc-utils/expression.cpp
// Function: power(unsigned int, unsigned int)
uint32_t power(uint32_t a, uint32_t b) {

	uint32_t rv = 1;
	for( ; b; b >>= 1) {
		if (b & 0x01) rv *= a;
		a = a * a;
	}
	return rv; 
}

// Assembly:
testl %esi, %esi
je 0xb4d4
movl $0x1, %ecx
movl $0x1, %eax
movl %esi, %edx
testb $0x1, %sil
movl %edi, %r8d
cmovel %ecx, %r8d
imull %r8d, %eax
imull %edi, %edi
shrl %edx
cmpl $0x1, %esi
movl %edx, %esi
ja 0xb4b8
retq
movl $0x1, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/ksherlock[P]wdc-utils/expression.cpp
// Function: unary_op(unsigned int, std::vector<expr, std::allocator<expr>>&)
bool unary_op(unsigned op, std::vector<expr> &v) {
	if (v.size() >=1 ) {
		expr &a = v.back();
		if (a.tag == OP_VAL) {
			switch(a.tag) {
			case OP_NOT: a.value = !a.value; break;
			case OP_NEG: a.value = -a.value; break;
			case OP_FLP: a.value = ~a.value; break;
			default:
				errx(EX_SOFTWARE, "Unsupported unary op %02x", a.tag);
			}
			return true;
		}
	}
	v.emplace_back(op);
	return false;
}

// Assembly:
pushq %rax
movl %edi, 0x4(%rsp)
movq 0x8(%rsi), %rax
cmpq (%rsi), %rax
je 0xb4ee
cmpl $0x2, -0xc(%rax)
je 0xb502
leaq 0x4(%rsp), %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0xbc5e
xorl %eax, %eax
popq %rcx
retq
leaq 0x446f(%rip), %rsi      # 0xf978
movl $0x46, %edi
movl $0x2, %edx
xorl %eax, %eax
callq 0x2430
// File: /workspace/github_cpp_makefile_star2_O3/ksherlock[P]wdc-utils/omf.cpp
// Function: push(std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned int)
void push(std::vector<uint8_t> &v, uint32_t x) {
	v.push_back(x & 0xff);
	x >>= 8;
	v.push_back(x & 0xff);
	x >>= 8;
	v.push_back(x & 0xff);
	x >>= 8;
	v.push_back(x & 0xff);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x7(%rsp), %rsi
movb %bl, (%rsi)
callq 0xd724
movb %bh, 0x4(%rsp)
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
callq 0xd724
movl %ebx, %eax
shrl $0x10, %eax
leaq 0x6(%rsp), %rsi
movb %al, (%rsi)
movq %r14, %rdi
callq 0xd724
shrl $0x18, %ebx
leaq 0x5(%rsp), %rsi
movb %bl, (%rsi)
movq %r14, %rdi
callq 0xd724
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/ksherlock[P]wdc-utils/omf.cpp
// Function: save_bin(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, omf::segment&, unsigned int)
void save_bin(const std::string &path, omf::segment &segment, uint32_t org) {

	int fd;
	fd = open(path.c_str(), O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0666);
	if (fd < 0) {
		err(EX_CANTCREAT, "Unable to open %s", path.c_str());
	}

	auto &data = segment.data;

	for (auto &r : segment.relocs) {

		uint32_t value = r.value + org;
		value >>= -(int8_t)r.shift;

		unsigned offset = r.offset;
		unsigned size = r.size;
		while (size--) {
			data[offset++] = value & 0xff;
			value >>= 8;
		}
	}

	auto ok = write(fd, data.data(), data.size());
	if (ok < 0) {
		close(fd);
		err(EX_OSERR, "write %s", path.c_str());
	}
	close(fd);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
movl $0x241, %esi            # imm = 0x241
movl $0x1b6, %edx            # imm = 0x1B6
xorl %eax, %eax
callq 0x21f0
testl %eax, %eax
js 0xcaba
movl %eax, %ebp
movq 0x80(%r14), %rax
movq 0x88(%r14), %rdx
cmpq %rdx, %rax
je 0xca8e
movzbl (%rax), %esi
testl %esi, %esi
je 0xca88
movl 0x4(%rax), %r8d
movl 0x8(%rax), %edi
addl %r15d, %edi
movb 0x1(%rax), %r9b
xorl %ecx, %ecx
subb %r9b, %cl
shrl %cl, %edi
movl %edi, %ecx
movl %r8d, %r9d
incl %r8d
shrl $0x8, %ecx
movq 0x50(%r14), %r10
movb %dil, (%r10,%r9)
movl %ecx, %edi
decl %esi
jne 0xca71
addq $0xc, %rax
jmp 0xca4e
movq 0x50(%r14), %rsi
movq 0x58(%r14), %rdx
subq %rsi, %rdx
movl %ebp, %edi
callq 0x2100
movq %rax, %r14
movl %ebp, %edi
callq 0x2460
testq %r14, %r14
js 0xcacb
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rdx
leaq 0x2a01(%rip), %rsi      # 0xf4c5
movl $0x49, %edi
jmp 0xcada
movq (%rbx), %rdx
leaq 0x2f3b(%rip), %rsi      # 0xfa10
movl $0x47, %edi
xorl %eax, %eax
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O3/ksherlock[P]wdc-utils/omf.cpp
// Function: super_helper::append(unsigned int)
void append(uint32_t pc) {
		unsigned offset = pc & 0xff;
		unsigned page = pc >> 8;
		assert(page >= _page);

		if (page != _page) {
			unsigned skip = page - _page;
			if (_count) --skip;
			if (skip) {
				
				while (skip >= 0x80) {
					_data.push_back(0xff);
					skip -= 0x7f;
				}
				if (skip)
					_data.push_back(0x80 | skip);
			}
			_page = page;
			_count = 0;
		}

		if (!_count) {
			_data.push_back(0); // count-1 place holder.
		} else {
			_data[_data.size() - _count - 1] = _count; // count is count - 1 at this point,
		}

		_data.push_back(offset);
		++_count;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %r15d
shrl $0x8, %r15d
movl %r15d, %r12d
subl 0x18(%rdi), %r12d
jb 0xd5d0
movl %esi, %ebp
movq %rdi, %rbx
jne 0xd546
movl 0x1c(%rbx), %eax
testl %eax, %eax
je 0xd5a0
movq 0x8(%rbx), %rcx
movl %eax, %edx
notl %edx
movslq %edx, %rdx
movb %al, (%rcx,%rdx)
jmp 0xd5b0
xorl %eax, %eax
cmpl $0x0, 0x1c(%rbx)
setne %al
subl %eax, %r12d
je 0xd595
cmpl $0x80, %r12d
jb 0xd57c
leaq 0xc(%rsp), %r14
movb $-0x1, 0xc(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd724
addl $-0x7f, %r12d
cmpl $0x7f, %r12d
ja 0xd562
testl %r12d, %r12d
je 0xd595
orb $-0x80, %r12b
leaq 0xf(%rsp), %rsi
movb %r12b, (%rsi)
movq %rbx, %rdi
callq 0xd724
movl %r15d, 0x18(%rbx)
movl $0x0, 0x1c(%rbx)
leaq 0xe(%rsp), %rsi
movb $0x0, (%rsi)
movq %rbx, %rdi
callq 0xd724
leaq 0xd(%rsp), %rsi
movb %bpl, (%rsi)
movq %rbx, %rdi
callq 0xd724
incl 0x1c(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x244f(%rip), %rdi      # 0xfa26
leaq 0x2456(%rip), %rsi      # 0xfa34
leaq 0x2457(%rip), %rcx      # 0xfa3c
movl $0xd0, %edx
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/ksherlock[P]wdc-utils/set_file_type.cpp
// Function: set_file_type(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned short, unsigned int)
int set_file_type(const std::string &path, uint16_t file_type, uint32_t aux_type) {

	afp::finder_info fi;
	std::error_code ec;

	if (!fi.open(path, afp::finder_info::read_write, ec))
		return -1;

	fi.set_prodos_file_type(file_type, aux_type);
	if (!fi.write(ec))
		return -1;

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x14(%rsp), %r15
movq %r15, %rdi
callq 0xe0c0
movq %rsp, %r12
movl $0x0, (%r12)
callq 0x2180
movq %rax, 0x8(%r12)
movq %r15, %rdi
movq %r14, %rsi
movl $0x3, %edx
movq %r12, %rcx
callq 0xe1cc
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
testb %al, %al
je 0xe091
movzwl %bp, %esi
leaq 0x14(%rsp), %rdi
movl %ebx, %edx
callq 0xe5dc
leaq 0x14(%rsp), %rdi
movq %rsp, %rsi
callq 0xe4f0
movzbl %al, %r14d
decl %r14d
leaq 0x14(%rsp), %rdi
callq 0xe1ac
movl %r14d, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x14(%rsp), %rdi
callq 0xe1ac
movq %rbx, %rdi
callq 0x23c0
// File: /workspace/github_cpp_makefile_star2_O3/ksherlock[P]wdc-utils/afp/src/finder_info.cpp
// Function: afp::finder_info::operator=(afp::finder_info&&)
finder_info &finder_info::operator=(finder_info &&rhs) {
	if (this != &rhs) {
		close();
		std::swap(_fd, rhs._fd);
		std::memcpy(_finder_info, &rhs._finder_info, sizeof(_finder_info));
		_prodos_file_type = rhs._prodos_file_type;
		_prodos_aux_type = rhs._prodos_aux_type;
	}
	return *this;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0xe16f
movq %rsi, %r14
movl (%rbx), %edi
testl %edi, %edi
js 0xe13e
callq 0x2460
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, (%rbx)
movl (%r14), %ecx
movl %ecx, (%rbx)
movl %eax, (%r14)
movups 0xc(%r14), %xmm0
movups 0x1c(%r14), %xmm1
movups %xmm1, 0x1c(%rbx)
movups %xmm0, 0xc(%rbx)
movzwl 0x4(%r14), %eax
movw %ax, 0x4(%rbx)
movl 0x8(%r14), %eax
movl %eax, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/ksherlock[P]wdc-utils/afp/src/finder_info.cpp
// Function: afp::finder_info::write(std::error_code&)
bool finder_info::write(std::error_code &ec) {
	ec.clear();
	// n.b. no way to differentiate closed vs opened read-only.
	auto ok = _(::write_xattr(_fd, XATTR_FINDERINFO_NAME, _finder_info, 32), ec);
	if (ec) {
		remap_enoattr(ec);
		return false;
	}
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
callq 0x2180
movq %rax, %r14
movl $0x0, (%rbx)
movq %rax, 0x8(%rbx)
movl (%r15), %edi
addq $0xc, %r15
leaq 0x1545(%rip), %rsi      # 0xfa60
movl $0x20, %ecx
movq %r15, %rdx
callq 0xe806
testq %rax, %rax
js 0xe531
movl (%rbx), %eax
jmp 0xe53e
callq 0x2040
movl (%rax), %eax
movl %eax, (%rbx)
movq %r14, 0x8(%rbx)
testl %eax, %eax
sete %al
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ksherlock[P]wdc-utils/afp/src/finder_info.cpp
// Function: afp::finder_info::write(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::error_code&)
bool finder_info::write(const std::string &path, std::error_code &ec) {
	ec.clear();

	int fd = _(::open(path.c_str(), O_RDONLY), ec);
	if (ec) return false;

	auto ok = _(::write_xattr(fd, XATTR_FINDERINFO_NAME, _finder_info, 32), ec);
	::close(fd);
	if (ec) {
		remap_enoattr(ec);
		return false;
	}

	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
callq 0x2180
movq %rax, %r14
movl $0x0, (%rbx)
movq %rax, 0x8(%rbx)
movq (%r12), %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x21f0
movl %eax, %ebp
testl %eax, %eax
js 0xe584
movl (%rbx), %eax
jmp 0xe591
callq 0x2040
movl (%rax), %eax
movl %eax, (%rbx)
movq %r14, 0x8(%rbx)
testl %eax, %eax
je 0xe599
xorl %eax, %eax
jmp 0xe5d2
addq $0xc, %r15
leaq 0x14bc(%rip), %rsi      # 0xfa60
movl $0x20, %ecx
movl %ebp, %edi
movq %r15, %rdx
callq 0xe806
testq %rax, %rax
jns 0xe5c5
callq 0x2040
movl (%rax), %eax
movl %eax, (%rbx)
movq %r14, 0x8(%rbx)
movl %ebp, %edi
callq 0x2460
cmpl $0x0, (%rbx)
sete %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ksherlock[P]wdc-utils/afp/src/finder_info.cpp
// Function: afp::finder_info::is_binary() const
bool finder_info::is_text() const {
	if (memcmp(_finder_info, "TEXT", 4) == 0) return true;
	if (_prodos_file_type == 0x04) return true;
	if (_prodos_file_type == 0xb0) return true;

	return false;
}

// Assembly:
cmpl $0x54584554, 0xc(%rdi)  # imm = 0x54584554
jne 0xe77a
xorl %eax, %eax
retq
movzwl 0x4(%rdi), %ecx
xorl %eax, %eax
cmpl $0x4, %ecx
je 0xe779
cmpl $0xb0, %ecx
je 0xe779
movb $0x1, %al
testw %cx, %cx
jne 0xe779
cmpl $0x0, 0x8(%rdi)
jne 0xe779
cmpq $0x0, 0xc(%rdi)
setne %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ksherlock[P]wdc-utils/afp/src/finder_info.cpp
// Function: afp::finder_info::file_type() const
uint32_t finder_info::file_type() const {
	uint32_t rv = 0;
	for (unsigned i = 0; i < 4; ++i) {
		rv <<= 8;
		rv |= _finder_info[i];
	}
	return rv;
}

// Assembly:
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %edx
shll $0x8, %edx
movzbl 0xc(%rdi,%rcx), %eax
orl %edx, %eax
incq %rcx
cmpq $0x4, %rcx
jne 0xe7a8
retq
// File: /workspace/github_cpp_makefile_star2_O3/ksherlock[P]wdc-utils/afp/src/finder_info.cpp
// Function: afp::finder_info::creator_type() const
uint32_t finder_info::creator_type() const {
	uint32_t rv = 0;
	for (unsigned i = 4; i < 8; ++i) {
		rv <<= 8;
		rv |= _finder_info[i];
	}
	return rv;
}

// Assembly:
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %edx
shll $0x8, %edx
movzbl 0x10(%rdi,%rcx), %eax
orl %edx, %eax
incq %rcx
cmpq $0x4, %rcx
jne 0xe7c2
retq
// File: /workspace/github_c_makefile_star2_O0/codeniko[P]CS214-Malloc-Free/mymalloc.c
// Function: getFreeIndex
static int getFreeIndex() {
	int i;
	for (i = 0; i < entriesSize; i++)
		if (memEntries[i] == 0) 
			return i;
	return 1; //should never reach here but 0 is always set as root
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x8(%rbp)
cmpl $0x412, -0x8(%rbp)      # imm = 0x412
jge 0x156b
movslq -0x8(%rbp), %rcx
leaq 0x8cb1(%rip), %rax      # 0xa200
cmpq $0x0, (%rax,%rcx,8)
jne 0x155e
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1572
jmp 0x1560
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x153b
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_image_write.h
// Function: stbi_write_bmp_core
static int stbi_write_bmp_core(stbi__write_context *s, int x, int y, int comp, const void *data)
{
   int pad = (-x*3) & 3;
   return stbiw__outfile(s,-1,-1,x,y,comp,1,(void *) data,0,pad,
           "11 4 22 4" "4 44 22 444444",
           'B', 'M', 14+40+(x*3+pad)*y, 0,0, 14+40,  // file header
            40, x,y, 1,24, 0,0,0,0,0,0);             // bitmap header
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, -0x20(%rbp)
movl %esi, -0x24(%rbp)
movl %edx, -0x28(%rbp)
movl %ecx, -0x2c(%rbp)
movq %r8, -0x38(%rbp)
xorl %eax, %eax
subl -0x24(%rbp), %eax
imull $0x3, %eax, %eax
andl $0x3, %eax
movl %eax, -0x3c(%rbp)
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %ecx
movl -0x28(%rbp), %r8d
movl -0x2c(%rbp), %r9d
movq -0x38(%rbp), %r15
movl -0x3c(%rbp), %r14d
imull $0x3, -0x24(%rbp), %r11d
addl -0x3c(%rbp), %r11d
imull -0x28(%rbp), %r11d
addl $0x36, %r11d
movl -0x24(%rbp), %r10d
movl -0x28(%rbp), %eax
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %esi, %esi
leaq 0x15774(%rip), %rbx     # 0x16b71
movl %edx, %esi
movl $0x1, (%rsp)
movq %r15, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movl %r14d, 0x18(%rsp)
movq %rbx, 0x20(%rsp)
movl $0x42, 0x28(%rsp)
movl $0x4d, 0x30(%rsp)
movl %r11d, 0x38(%rsp)
movl $0x0, 0x40(%rsp)
movl $0x0, 0x48(%rsp)
movl $0x36, 0x50(%rsp)
movl $0x28, 0x58(%rsp)
movl %r10d, 0x60(%rsp)
movl %eax, 0x68(%rsp)
movl $0x1, 0x70(%rsp)
movl $0x18, 0x78(%rsp)
movl $0x0, 0x80(%rsp)
movl $0x0, 0x88(%rsp)
movl $0x0, 0x90(%rsp)
movl $0x0, 0x98(%rsp)
movl $0x0, 0xa0(%rsp)
movl $0x0, 0xa8(%rsp)
movb $0x0, %al
callq 0xd4f0
addq $0xd8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_image_write.h
// Function: stbi_write_bmp
STBIWDEF int stbi_write_bmp(char const *filename, int x, int y, int comp, const void *data)
{
   stbi__write_context s;
   if (stbi__start_write_file(&s,filename)) {
      int r = stbi_write_bmp_core(&s, x, y, comp, data);
      stbi__end_write_file(&s);
      return r;
   } else
      return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x1540
cmpl $0x0, %eax
je 0x1525
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %r8
leaq -0x38(%rbp), %rdi
callq 0x1390
movl %eax, -0x3c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1590
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x152c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_image_write.h
// Function: stbi_write_tga
STBIWDEF int stbi_write_tga(char const *filename, int x, int y, int comp, const void *data)
{
   stbi__write_context s;
   if (stbi__start_write_file(&s,filename)) {
      int r = stbi_write_tga_core(&s, x, y, comp, (void *) data);
      stbi__end_write_file(&s);
      return r;
   } else
      return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x1540
cmpl $0x0, %eax
je 0x1b45
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %r8
leaq -0x38(%rbp), %rdi
callq 0x1600
movl %eax, -0x3c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1590
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1b4c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_image_write.h
// Function: stbi_write_hdr_core
static int stbi_write_hdr_core(stbi__write_context *s, int x, int y, int comp, float *data)
{
   if (y <= 0 || x <= 0 || data == NULL)
      return 0;
   else {
      // Each component is stored separately. Allocate scratch space for full output scanline.
      unsigned char *scratch = (unsigned char *) STBIW_MALLOC(x*4);
      int i, len;
      char buffer[128];
      char header[] = "#?RADIANCE\n# Written by stb_image_write.h\nFORMAT=32-bit_rle_rgbe\n";
      s->func(s->context, header, sizeof(header)-1);

#ifdef __STDC_WANT_SECURE_LIB__
      len = sprintf_s(buffer, sizeof(buffer), "EXPOSURE=          1.0000000000000\n\n-Y %d +X %d\n", y, x);
#else
      len = sprintf(buffer, "EXPOSURE=          1.0000000000000\n\n-Y %d +X %d\n", y, x);
#endif
      s->func(s->context, buffer, len);

      for(i=0; i < y; i++)
         stbiw__write_hdr_scanline(s, x, comp, scratch, data + comp*x*(stbi__flip_vertically_on_write ? y-1-i : i));
      STBIW_FREE(scratch);
      return 1;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
cmpl $0x0, -0x18(%rbp)
jle 0x1bdf
cmpl $0x0, -0x14(%rbp)
jle 0x1bdf
cmpq $0x0, -0x28(%rbp)
jne 0x1beb
movl $0x0, -0x4(%rbp)
jmp 0x1d3f
movl -0x14(%rbp), %eax
shll $0x2, %eax
movslq %eax, %rdi
callq 0x1140
movq %rax, -0x30(%rbp)
leaq -0x110(%rbp), %rdi
leaq 0x15885(%rip), %rsi     # 0x17490
movl $0x42, %edx
callq 0x1130
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdi
leaq -0x110(%rbp), %rsi
movl $0x41, %edx
callq *%rax
leaq -0xc0(%rbp), %rdi
movl -0x18(%rbp), %edx
movl -0x14(%rbp), %ecx
leaq 0x14fa4(%rip), %rsi     # 0x16bea
movb $0x0, %al
callq 0x11b0
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdi
leaq -0xc0(%rbp), %rsi
movl -0x38(%rbp), %edx
callq *%rax
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x1d2f
movq -0x10(%rbp), %rax
movq %rax, -0x138(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x130(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x12c(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x128(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x120(%rbp)
movl -0x1c(%rbp), %eax
imull -0x14(%rbp), %eax
movl %eax, -0x114(%rbp)
cmpl $0x0, 0x1995f(%rip)     # 0x1b624
je 0x1cd8
movl -0x18(%rbp), %eax
subl $0x1, %eax
subl -0x34(%rbp), %eax
movl %eax, -0x13c(%rbp)
jmp 0x1ce1
movl -0x34(%rbp), %eax
movl %eax, -0x13c(%rbp)
movq -0x128(%rbp), %rcx
movl -0x12c(%rbp), %edx
movl -0x130(%rbp), %esi
movq -0x138(%rbp), %rdi
movq -0x120(%rbp), %r8
movl -0x114(%rbp), %eax
movl -0x13c(%rbp), %r9d
imull %r9d, %eax
cltq
shlq $0x2, %rax
addq %rax, %r8
callq 0xdc20
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x1c72
movq -0x30(%rbp), %rdi
callq 0x1030
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_image_write.h
// Function: stbi_write_hdr
STBIWDEF int stbi_write_hdr(char const *filename, int x, int y, int comp, const float *data)
{
   stbi__write_context s;
   if (stbi__start_write_file(&s,filename)) {
      int r = stbi_write_hdr_core(&s, x, y, comp, (float *) data);
      stbi__end_write_file(&s);
      return r;
   } else
      return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x1540
cmpl $0x0, %eax
je 0x1da5
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %r8
leaq -0x38(%rbp), %rdi
callq 0x1bb0
movl %eax, -0x3c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1590
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1dac
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_image_write.h
// Function: stbiw__sbgrowf
static void *stbiw__sbgrowf(void **arr, int increment, int itemsize)
{
   int m = *arr ? 2*stbiw__sbm(*arr)+increment : increment+1;
   void *p = STBIW_REALLOC_SIZED(*arr ? stbiw__sbraw(*arr) : 0, *arr ? (stbiw__sbm(*arr)*itemsize + sizeof(int)*2) : 0, itemsize * m + sizeof(int)*2);
   STBIW_ASSERT(p);
   if (p) {
      if (!*arr) ((int *) p)[1] = 0;
      *arr = (void *) ((int *) p + 2);
      stbiw__sbm(*arr) = m;
   }
   return *arr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x29a0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x8(%rax), %eax
shll %eax
addl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x29a9
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x29ca
movq -0x8(%rbp), %rax
movq (%rax), %rax
addq $-0x8, %rax
movq %rax, -0x30(%rbp)
jmp 0x29d2
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0x29d2
movq -0x30(%rbp), %rdi
movl -0x10(%rbp), %eax
imull -0x14(%rbp), %eax
movslq %eax, %rsi
addq $0x8, %rsi
callq 0x1160
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x29f6
jmp 0x2a15
leaq 0x14a5d(%rip), %rdi     # 0x1745a
leaq 0x13cde(%rip), %rsi     # 0x166e2
movl $0x319, %edx            # imm = 0x319
leaq 0x142ba(%rip), %rcx     # 0x16cca
callq 0x10a0
cmpq $0x0, -0x20(%rbp)
je 0x2a4d
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x2a31
movq -0x20(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x20(%rbp), %rcx
addq $0x8, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl %ecx, -0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_image_write.h
// Function: stbiw__zlib_flushf
static unsigned char *stbiw__zlib_flushf(unsigned char *data, unsigned int *bitbuffer, int *bitcount)
{
   while (*bitcount >= 8) {
      stbiw__sbpush(data, STBIW_UCHAR(*bitbuffer));
      *bitbuffer >>= 8;
      *bitcount -= 8;
   }
   return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x8, (%rax)
jl 0x2ae9
cmpq $0x0, -0x8(%rbp)
je 0x2a97
movq -0x8(%rbp), %rax
movl -0x4(%rax), %eax
addl $0x1, %eax
movq -0x8(%rbp), %rcx
cmpl -0x8(%rcx), %eax
jl 0x2aa9
leaq -0x8(%rbp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0x2970
jmp 0x2aab
jmp 0x2aab
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rsi
movl -0x4(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, -0x4(%rsi)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
shrl $0x8, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
subl $0x8, %ecx
movl %ecx, (%rax)
jmp 0x2a74
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_image_write.h
// Function: stbiw__zhash
static unsigned int stbiw__zhash(unsigned char *data)
{
   stbiw_uint32 hash = data[0] + (data[1] << 8) + (data[2] << 16);
   hash ^= hash << 3;
   hash += hash >> 5;
   hash ^= hash << 4;
   hash += hash >> 17;
   hash ^= hash << 25;
   hash += hash >> 6;
   return hash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
movq -0x8(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
addl %ecx, %eax
movq -0x8(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x10, %ecx
addl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
shll $0x3, %eax
xorl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
shrl $0x5, %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
shll $0x4, %eax
xorl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
shrl $0x11, %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
shll $0x19, %eax
xorl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
shrl $0x6, %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_image_write.h
// Function: stbiw__zlib_countm
static unsigned int stbiw__zlib_countm(unsigned char *a, unsigned char *b, int limit)
{
   int i;
   for (i=0; i < limit && i < 258; ++i)
      if (a[i] != b[i]) break;
   return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %ecx
xorl %eax, %eax
cmpl -0x14(%rbp), %ecx
movb %al, -0x19(%rbp)
jge 0x2bb0
cmpl $0x102, -0x18(%rbp)     # imm = 0x102
setl %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x2bb9
jmp 0x2be4
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movslq -0x18(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x2bd7
jmp 0x2be4
jmp 0x2bd9
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2b96
movl -0x18(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_image_write.h
// Function: stbiw__zlib_bitrev
static int stbiw__zlib_bitrev(int code, int codebits)
{
   int res=0;
   while (codebits--) {
      res = (res << 1) | (code & 1);
      code >>= 1;
   }
   return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0x8(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x8(%rbp)
cmpl $0x0, %eax
je 0x2c2b
movl -0xc(%rbp), %eax
shll %eax
movl -0x4(%rbp), %ecx
andl $0x1, %ecx
orl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %eax
sarl %eax
movl %eax, -0x4(%rbp)
jmp 0x2c01
movl -0xc(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_image_write.h
// Function: stbi_write_png
STBIWDEF int stbi_write_png(char const *filename, int x, int y, int comp, const void *data, int stride_bytes)
{
   FILE *f;
   int len;
   unsigned char *png = stbi_write_png_to_mem((const unsigned char *) data, stride_bytes, x, y, comp, &len);
   if (png == NULL) return 0;

   f = stbiw__fopen(filename, "wb");
   if (!f) { STBIW_FREE(png); return 0; }
   fwrite(png, 1, len, f);
   fclose(f);
   STBIW_FREE(png);
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movl -0x1c(%rbp), %r8d
leaq -0x3c(%rbp), %r9
callq 0x2c30
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x384b
movl $0x0, -0x4(%rbp)
jmp 0x38a7
movq -0x10(%rbp), %rdi
leaq 0x12f5e(%rip), %rsi     # 0x167b4
callq 0x38b0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x3878
movq -0x48(%rbp), %rdi
callq 0x1030
movl $0x0, -0x4(%rbp)
jmp 0x38a7
movq -0x48(%rbp), %rdi
movslq -0x3c(%rbp), %rdx
movq -0x38(%rbp), %rcx
movl $0x1, %esi
callq 0x11c0
movq -0x38(%rbp), %rdi
callq 0x1060
movq -0x48(%rbp), %rdi
callq 0x1030
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_image_write.h
// Function: stbi_write_png_to_func
STBIWDEF int stbi_write_png_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int stride_bytes)
{
   int len;
   unsigned char *png = stbi_write_png_to_mem((const unsigned char *) data, stride_bytes, x, y, comp, &len);
   if (png == NULL) return 0;
   func(context, png, len);
   STBIW_FREE(png);
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movl 0x10(%rbp), %esi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
leaq -0x34(%rbp), %r9
callq 0x2c30
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x392f
movl $0x0, -0x4(%rbp)
jmp 0x3950
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl -0x34(%rbp), %edx
callq *%rax
movq -0x40(%rbp), %rdi
callq 0x1030
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_image_write.h
// Function: stbi_write_jpg
STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const void *data, int quality)
{
   stbi__write_context s;
   if (stbi__start_write_file(&s,filename)) {
      int r = stbi_write_jpg_core(&s, x, y, comp, data, quality);
      stbi__end_write_file(&s);
      return r;
   } else
      return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x1540
cmpl $0x0, %eax
je 0x443d
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %r8
movl -0x2c(%rbp), %r9d
leaq -0x40(%rbp), %rdi
callq 0x39c0
movl %eax, -0x44(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1590
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x4444
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt_GetGlyphBox
STBTT_DEF int stbtt_GetGlyphBox(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1)
{
   if (info->cff.size) {
      stbtt__GetGlyphInfoT2(info, glyph_index, x0, y0, x1, y1);
   } else {
      int g = stbtt__GetGlyfOffset(info, glyph_index);
      if (g < 0) return 0;

      if (x0) *x0 = ttSHORT(info->data + g + 2);
      if (y0) *y0 = ttSHORT(info->data + g + 4);
      if (x1) *x1 = ttSHORT(info->data + g + 6);
      if (y1) *y1 = ttSHORT(info->data + g + 8);
   }
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4c(%rax)
je 0x4aea
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
callq 0x4bc0
jmp 0x4bad
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x4cd0
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jge 0x4b0b
movl $0x0, -0x4(%rbp)
jmp 0x4bb4
cmpq $0x0, -0x20(%rbp)
je 0x4b33
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0x3c(%rbp), %rax
addq %rax, %rdi
addq $0x2, %rdi
callq 0x49b0
movswl %ax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x4b5b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0x3c(%rbp), %rax
addq %rax, %rdi
addq $0x4, %rdi
callq 0x49b0
movswl %ax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x30(%rbp)
je 0x4b83
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0x3c(%rbp), %rax
addq %rax, %rdi
addq $0x6, %rdi
callq 0x49b0
movswl %ax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x38(%rbp)
je 0x4bab
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0x3c(%rbp), %rax
addq %rax, %rdi
addq $0x8, %rdi
callq 0x49b0
movswl %ax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
jmp 0x4bad
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)