LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: WojciechMula[P]utf16utf8/src/scalar_utf16.cpp
// Function: utf16::encode(unsigned int, unsigned short&, unsigned short&)
int encode(uint32_t value, uint16_t& W1, uint16_t& W2) {
        assert(value <= 0xd800 || value > 0xdfff);
        assert(value <= 0x10ffff);
        if (value <= 0xffff) {
            W1 = uint16_t(value);
            return 1;
        } else {
            value -= 0x10000;
            W1 = uint16_t(0xd800 | ((value >> 10) & 0x03ff));
            W2 = uint16_t(0xdc00 | (value & 0x03ff));
            return 2;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x1, %al
cmpl $0xd800, -0x8(%rbp)     # imm = 0xD800
movb %al, -0x19(%rbp)
jbe 0xaade
cmpl $0xdfff, -0x8(%rbp)     # imm = 0xDFFF
seta %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xaae7
jmp 0xaae9
jmp 0xab08
leaq 0xe64b(%rip), %rdi      # 0x1913b
leaq 0xe666(%rip), %rsi      # 0x1915d
movl $0x9, %edx
leaq 0xe66f(%rip), %rcx      # 0x19172
callq 0x2130
cmpl $0x10ffff, -0x8(%rbp)   # imm = 0x10FFFF
ja 0xab13
jmp 0xab32
leaq 0xe68c(%rip), %rdi      # 0x191a6
leaq 0xe63c(%rip), %rsi      # 0x1915d
movl $0xa, %edx
leaq 0xe645(%rip), %rcx      # 0x19172
callq 0x2130
cmpl $0xffff, -0x8(%rbp)     # imm = 0xFFFF
ja 0xab51
movl -0x8(%rbp), %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0xab94
movl -0x8(%rbp), %eax
subl $0x10000, %eax          # imm = 0x10000
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
shrl $0xa, %eax
andl $0x3ff, %eax            # imm = 0x3FF
orl $0xd800, %eax           # imm = 0xD800
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, (%rax)
movl -0x8(%rbp), %eax
andl $0x3ff, %eax            # imm = 0x3FF
orl $0xdc00, %eax           # imm = 0xDC00
movw %ax, %cx
movq -0x18(%rbp), %rax
movw %cx, (%rax)
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: WojciechMula[P]utf16utf8/src/scalar_utf16.cpp
// Function: utf16::test_utf16_encode_and_decode()
void test_utf16_encode_and_decode() {
        uint16_t array[2];
        for (uint32_t v = 0x10000; v <= 0x10ffff; v++) {
            uint32_t decoded = 0;
            const int n = encode(v, array[0], array[1]);

            decode(array, n,
                [&decoded](uint32_t vv) { decoded = vv; },
                [](const uint16_t*, const uint16_t*, Error) { puts("critical error"); abort(); });

            if (decoded != v)
                printf("%06x != %06x\n", v, decoded);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x10000, -0x8(%rbp)    # imm = 0x10000
cmpl $0x10ffff, -0x8(%rbp)   # imm = 0x10FFFF
ja 0xac18
movl $0x0, -0xc(%rbp)
movl -0x8(%rbp), %edi
leaq -0x4(%rbp), %rsi
leaq -0x4(%rbp), %rdx
addq $0x2, %rdx
callq 0xaab0
movl %eax, -0x10(%rbp)
leaq -0x4(%rbp), %rdi
movslq -0x10(%rbp), %rsi
leaq -0xc(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdx
callq 0xac20
movl -0xc(%rbp), %eax
cmpl -0x8(%rbp), %eax
je 0xac0b
movl -0x8(%rbp), %esi
movl -0xc(%rbp), %edx
leaq 0xe5b4(%rip), %rdi      # 0x191b8
movb $0x0, %al
callq 0x2050
jmp 0xac0d
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xabaf
addq $0x20, %rsp
popq %rbp
retq
nop
// File: WojciechMula[P]utf16utf8/benchmarks/benchmark_from_utf8.cpp
// Function: main
int main() {
    // todo: Daniel finds the endless stream of numbers too much
    // Because some schemes use branching, you need to have a sizeable input if you
    // want fair results, given that we repeat the tests many times (we need to account
    // for branch predictors learning the branches).
    std::vector<size_t> input_size{16384};
    for (const size_t size: input_size) {
        Benchmark bench(size);
        bench.run_from_utf8();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1410, %rsp           # imm = 0x1410
movl $0x0, -0x4(%rbp)
movq $0x4000, -0x38(%rbp)    # imm = 0x4000
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x1, -0x28(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x1408(%rbp)
callq 0xcc30
movq -0x1408(%rbp), %rcx
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0xcc50
jmp 0xc624
leaq -0x39(%rbp), %rdi
callq 0xccd0
leaq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0xccf0
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
callq 0xcd20
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xcd50
testb $0x1, %al
jne 0xc665
jmp 0xc6eb
leaq -0x60(%rbp), %rdi
callq 0xcd90
movq (%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rsi
leaq -0x1400(%rbp), %rdi
callq 0xcdb0
jmp 0xc687
leaq -0x1400(%rbp), %rdi
callq 0xcde0
jmp 0xc695
leaq -0x1400(%rbp), %rdi
callq 0xd1f0
leaq -0x60(%rbp), %rdi
callq 0xd210
jmp 0xc64f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0xccd0
jmp 0xc709
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xc700
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x1400(%rbp), %rdi
callq 0xd1f0
jmp 0xc700
leaq -0x20(%rbp), %rdi
callq 0xd230
movl -0x4(%rbp), %eax
addq $0x1410, %rsp           # imm = 0x1410
popq %rbp
retq
leaq -0x20(%rbp), %rdi
callq 0xd230
movq -0x48(%rbp), %rdi
callq 0x22e0
nopw %cs:(%rax,%rax)
// File: WojciechMula[P]utf16utf8/include/reference.h
// Function: utf8_to_utf16(unsigned char const*, unsigned short*)
static inline uint16_t *utf8_to_utf16(const uint8_t *utf8, uint16_t *utf16)
{
	int j;
	uint32_t c;
    size_t i;

	if (utf8==NULL)
		return NULL;

	if (utf16==NULL)
		utf16 = (uint16_t*)calloc(strlen_utf8_to_utf16(utf8) + 1, sizeof(uint16_t));

	for (i=0, j=0, c=1; c; i++)
	{
		c = utf8_to_unicode32(&utf8[i], &i);
		sprint_utf16(&utf16[j], c);
		j += codepoint_utf16_size(c);
	}

	return utf16;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xc744
movq $0x0, -0x8(%rbp)
jmp 0xc7d3
cmpq $0x0, -0x18(%rbp)
jne 0xc769
movq -0x10(%rbp), %rdi
callq 0xc7e0
movq %rax, %rdi
addq $0x1, %rdi
movl $0x2, %esi
callq 0x2140
movq %rax, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x1, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0xc7cb
movq -0x10(%rbp), %rdi
addq -0x28(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xc850
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rax
shlq %rax
addq %rax, %rdi
movl -0x20(%rbp), %esi
callq 0xc9c0
movl -0x20(%rbp), %edi
callq 0xca90
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xc77f
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: WojciechMula[P]utf16utf8/include/reference.h
// Function: strlen_utf8_to_utf16(unsigned char const*)
static inline size_t strlen_utf8_to_utf16(const uint8_t *str)
{
	size_t i, count;
	uint32_t c;

	for (i=0, count=0; ; i++)
	{
		if (str[i]==0)
			return count;

		c = utf8_to_unicode32(&str[i], &i);
		count += codepoint_utf16_size(c);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0xc817
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
movq -0x8(%rbp), %rdi
addq -0x10(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xc850
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
callq 0xca90
cltq
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xc7fc
nopl (%rax,%rax)
// File: WojciechMula[P]utf16utf8/benchmarks/event_counter.h
// Function: event_collector::event_collector()
event_collector() : linux_events(vector<int>{
    PERF_COUNT_HW_CPU_CYCLES,
    PERF_COUNT_HW_INSTRUCTIONS,
    PERF_COUNT_HW_BRANCH_MISSES,
    PERF_COUNT_HW_CACHE_REFERENCES,
    PERF_COUNT_HW_CACHE_MISSES
  }) {}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
callq 0xeaa0
movq -0x70(%rbp), %rdi
addq $0x20, %rdi
callq 0xeb60
jmp 0xdff2
movq -0x78(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x88(%rbp)
vmovdqu 0xb2af(%rip), %xmm0     # 0x192b8
vmovdqa %xmm0, -0x60(%rbp)
movl $0x3, -0x50(%rbp)
leaq -0x60(%rbp), %rax
movq %rax, -0x40(%rbp)
movq $0x5, -0x38(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xeb90
movq -0x80(%rbp), %rcx
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0xebb0
jmp 0xe049
movq -0x88(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xec30
jmp 0xe05b
leaq -0x30(%rbp), %rdi
callq 0xf160
leaq -0x61(%rbp), %rdi
callq 0xf1c0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0xe0b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0xe0a7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xf160
leaq -0x61(%rbp), %rdi
callq 0xf1c0
movq -0x70(%rbp), %rdi
callq 0xe340
movq -0x10(%rbp), %rdi
callq 0x22e0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: WojciechMula[P]utf16utf8/benchmarks/event_counter.h
// Function: event_collector::end()
inline event_count& end() {
    time_point<steady_clock> end_clock = steady_clock::now();
#if defined(__linux)
    linux_events.end(count.event_counts);
#endif
    count.elapsed = end_clock - start_clock;
    return count;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x2210
movq -0x28(%rbp), %rsi
movq %rax, -0x10(%rbp)
movq %rsi, %rdi
addq $0x28, %rdi
addq $0x8, %rsi
callq 0x11440
movq -0x28(%rbp), %rsi
addq $0x20, %rsi
leaq -0x10(%rbp), %rdi
callq 0x11650
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x116a0
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: WojciechMula[P]utf16utf8/benchmarks/event_counter.h
// Function: event_aggregate::operator<<(event_count const&)
void operator<<(const event_count& other) {
    if (iterations == 0 || other.elapsed < best.elapsed) {
      best = other;
    }
    if (iterations == 0 || other.elapsed > worst.elapsed) {
      worst = other;
    }
    iterations++;
    total += other;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, (%rax)
je 0xe2d4
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x28, %rsi
callq 0x11d40
testb $0x1, %al
jne 0xe2d4
jmp 0xe2e5
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rdi
callq 0x11da0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0xe305
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x48, %rsi
callq 0x11de0
testb $0x1, %al
jne 0xe305
jmp 0xe316
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x48, %rdi
callq 0x11da0
movq -0x18(%rbp), %rdi
movl (%rdi), %eax
addl $0x1, %eax
movl %eax, (%rdi)
movq -0x10(%rbp), %rsi
addq $0x8, %rdi
callq 0x11e10
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: WojciechMula[P]utf16utf8/benchmarks/linux-perf-events.h
// Function: LinuxEvents<0>::start()
inline void start() {
    if (fd != -1) {
      if (ioctl(fd, PERF_EVENT_IOC_RESET, PERF_IOC_FLAG_GROUP) == -1) {
        report_error("ioctl(PERF_EVENT_IOC_RESET)");
      }

      if (ioctl(fd, PERF_EVENT_IOC_ENABLE, PERF_IOC_FLAG_GROUP) == -1) {
        report_error("ioctl(PERF_EVENT_IOC_ENABLE)");
      }
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpl $-0x1, (%rax)
je 0x113a5
movq -0x70(%rbp), %rax
movl (%rax), %edi
movl $0x2403, %esi           # imm = 0x2403
movl $0x1, %edx
movb $0x0, %al
callq 0x2240
cmpl $-0x1, %eax
jne 0x11313
leaq -0x29(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x22f0
movq -0x78(%rbp), %rdx
leaq 0x827b(%rip), %rsi      # 0x1952f
leaq -0x28(%rbp), %rdi
callq 0x2220
jmp 0x112bf
movq -0x70(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x10440
jmp 0x112ce
leaq -0x28(%rbp), %rdi
callq 0x2120
leaq -0x29(%rbp), %rdi
callq 0x21f0
jmp 0x11313
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x11305
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2120
leaq -0x29(%rbp), %rdi
callq 0x21f0
jmp 0x113ae
movq -0x70(%rbp), %rax
movl (%rax), %edi
movl $0x2400, %esi           # imm = 0x2400
movl $0x1, %edx
movb $0x0, %al
callq 0x2240
cmpl $-0x1, %eax
jne 0x113a3
leaq -0x61(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x22f0
movq -0x80(%rbp), %rdx
leaq 0x8204(%rip), %rsi      # 0x1954b
leaq -0x60(%rbp), %rdi
callq 0x2220
jmp 0x11352
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x10440
jmp 0x11361
leaq -0x60(%rbp), %rdi
callq 0x2120
leaq -0x61(%rbp), %rdi
callq 0x21f0
jmp 0x113a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x11398
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x2120
leaq -0x61(%rbp), %rdi
callq 0x21f0
jmp 0x113ae
jmp 0x113a5
addq $0x80, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x22e0
nopw (%rax,%rax)
// File: WojciechMula[P]utf16utf8/benchmarks/linux-perf-events.h
// Function: LinuxEvents<0>::end(std::vector<unsigned long long, std::allocator<unsigned long long>>&)
inline void end(std::vector<unsigned long long> &results) {
    if (fd != -1) {
      if (ioctl(fd, PERF_EVENT_IOC_DISABLE, PERF_IOC_FLAG_GROUP) == -1) {
        report_error("ioctl(PERF_EVENT_IOC_DISABLE)");
      }

      if (read(fd, temp_result_vec.data(), temp_result_vec.size() * 8) == -1) {
        report_error("read");
      }
    }
    // our actual results are in slots 1,3,5, ... of this structure
    // we really should be checking our ids obtained earlier to be safe
    for (uint32_t i = 1; i < temp_result_vec.size(); i += 2) {
      results[i / 2] = temp_result_vec[i];
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
cmpl $-0x1, (%rax)
je 0x115c4
movq -0x78(%rbp), %rax
movl (%rax), %edi
movl $0x2401, %esi           # imm = 0x2401
movl $0x1, %edx
movb $0x0, %al
callq 0x2240
cmpl $-0x1, %eax
jne 0x114f7
leaq -0x31(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x22f0
movq -0x80(%rbp), %rdx
leaq 0x80d0(%rip), %rsi      # 0x19568
leaq -0x30(%rbp), %rdi
callq 0x2220
jmp 0x114a3
movq -0x78(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x10440
jmp 0x114b2
leaq -0x30(%rbp), %rdi
callq 0x2120
leaq -0x31(%rbp), %rdi
callq 0x21f0
jmp 0x114f7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x114e9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2120
leaq -0x31(%rbp), %rdi
callq 0x21f0
jmp 0x11643
movq -0x78(%rbp), %rdi
movl (%rdi), %eax
movl %eax, -0x8c(%rbp)
addq $0x90, %rdi
callq 0x116e0
movq -0x78(%rbp), %rdi
movq %rax, -0x88(%rbp)
addq $0x90, %rdi
callq 0x10670
movl -0x8c(%rbp), %edi
movq -0x88(%rbp), %rsi
movq %rax, %rdx
shlq $0x3, %rdx
callq 0x2250
cmpq $-0x1, %rax
jne 0x115c2
leaq -0x69(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x22f0
movq -0x98(%rbp), %rdx
leaq 0x8023(%rip), %rsi      # 0x19586
leaq -0x68(%rbp), %rdi
callq 0x2220
jmp 0x1156e
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x10440
jmp 0x1157d
leaq -0x68(%rbp), %rdi
callq 0x2120
leaq -0x69(%rbp), %rdi
callq 0x21f0
jmp 0x115c2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x115b4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x2120
leaq -0x69(%rbp), %rdi
callq 0x21f0
jmp 0x11643
jmp 0x115c4
movl $0x1, -0x70(%rbp)
movq -0x78(%rbp), %rdi
movl -0x70(%rbp), %eax
movq %rax, -0xa0(%rbp)
addq $0x90, %rdi
callq 0x10670
movq %rax, %rcx
movq -0xa0(%rbp), %rax
cmpq %rcx, %rax
jae 0x1163a
movq -0x78(%rbp), %rdi
addq $0x90, %rdi
movl -0x70(%rbp), %eax
movl %eax, %esi
callq 0x105a0
movq (%rax), %rax
movq %rax, -0xa8(%rbp)
movq -0x10(%rbp), %rdi
movl -0x70(%rbp), %eax
shrl %eax
movl %eax, %eax
movl %eax, %esi
callq 0x11700
movq -0xa8(%rbp), %rcx
movq %rcx, (%rax)
movl -0x70(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x70(%rbp)
jmp 0x115cb
addq $0xb0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x22e0
nopl (%rax)
// File: WojciechMula[P]utf16utf8/benchmarks/event_counter.h
// Function: event_count::operator+(event_count const&) const
event_count operator+(const event_count& other) const {
    return event_count(elapsed+other.elapsed, {
      event_counts[0]+other.event_counts[0],
      event_counts[1]+other.event_counts[1],
      event_counts[2]+other.event_counts[2],
      event_counts[3]+other.event_counts[3],
      event_counts[4]+other.event_counts[4],
    });
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x100(%rbp)
movq %rdi, %rax
movq %rax, -0xf8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
movq -0x18(%rbp), %rsi
callq 0x12910
movq -0xf0(%rbp), %rdi
vmovsd %xmm0, -0x20(%rbp)
addq $0x8, %rdi
movq %rdi, -0xb0(%rbp)
xorl %eax, %eax
movl %eax, %esi
movq %rsi, -0xe8(%rbp)
callq 0x12980
movq -0xe8(%rbp), %rsi
movq (%rax), %rax
movq %rax, -0xe0(%rbp)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x12980
movq -0xb0(%rbp), %rdi
movq %rax, %rcx
movq -0xe0(%rbp), %rax
movq (%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x70(%rbp)
movl $0x1, %esi
movq %rsi, -0xd8(%rbp)
callq 0x12980
movq -0xd8(%rbp), %rsi
movq (%rax), %rax
movq %rax, -0xd0(%rbp)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x12980
movq -0xb0(%rbp), %rdi
movq %rax, %rcx
movq -0xd0(%rbp), %rax
movq (%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x68(%rbp)
movl $0x2, %esi
movq %rsi, -0xc8(%rbp)
callq 0x12980
movq -0xc8(%rbp), %rsi
movq (%rax), %rax
movq %rax, -0xc0(%rbp)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x12980
movq -0xb0(%rbp), %rdi
movq %rax, %rcx
movq -0xc0(%rbp), %rax
movq (%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x60(%rbp)
movl $0x3, %esi
movq %rsi, -0xb8(%rbp)
callq 0x12980
movq -0xb8(%rbp), %rsi
movq (%rax), %rax
movq %rax, -0xa8(%rbp)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x12980
movq -0xb0(%rbp), %rdi
movq %rax, %rcx
movq -0xa8(%rbp), %rax
movq (%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x58(%rbp)
movl $0x4, %esi
movq %rsi, -0xa0(%rbp)
callq 0x12980
movq -0xa0(%rbp), %rsi
movq (%rax), %rax
movq %rax, -0x98(%rbp)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x12980
movq %rax, %rcx
movq -0x98(%rbp), %rax
movq (%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
leaq -0x70(%rbp), %rax
movq %rax, -0x48(%rbp)
movq $0x5, -0x40(%rbp)
leaq -0x71(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0xf200
movq -0x90(%rbp), %rcx
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0xf220
jmp 0x12897
movq -0x100(%rbp), %rdi
vmovsd -0x20(%rbp), %xmm0
leaq -0x38(%rbp), %rsi
callq 0x129a0
jmp 0x128ae
leaq -0x38(%rbp), %rdi
callq 0x129d0
leaq -0x71(%rbp), %rdi
callq 0xf2a0
movq -0xf8(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x128f9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x129d0
leaq -0x71(%rbp), %rdi
callq 0xf2a0
movq -0x80(%rbp), %rdi
callq 0x22e0
nopl (%rax,%rax)
// File: WojciechMula[P]utf16utf8/dependencies/utf8_v2_3_4/source/utf8/checked.h
// Function: std::back_insert_iterator<std::vector<unsigned short, std::allocator<unsigned short>>> utf8::utf8to16<std::back_insert_iterator<std::vector<unsigned short, std::allocator<unsigned short>>>, __gnu_cxx::__normal_iterator<unsigned char const*, std::vector<unsigned char, std::allocator<unsigned char>>>>(__gnu_cxx::__normal_iterator<unsigned char const*, std::vector<unsigned char, std::allocator<unsigned char>>>, __gnu_cxx::__normal_iterator<unsigned char const*, std::vector<unsigned char, std::allocator<unsigned char>>>, std::back_insert_iterator<std::vector<unsigned short, std::allocator<unsigned short>>>)
u16bit_iterator utf8to16 (octet_iterator start, octet_iterator end, u16bit_iterator result)
    {
        while (start != end) {
            uint32_t cp = utf8::next(start, end);
            if (cp > 0xffff) { //make a surrogate pair
                *result++ = static_cast<uint16_t>((cp >> 10)   + internal::LEAD_OFFSET);
                *result++ = static_cast<uint16_t>((cp & 0x3ff) + internal::TRAIL_SURROGATE_MIN);
            }
            else
                *result++ = static_cast<uint16_t>(cp);
        }
        return result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x12d50
testb $0x1, %al
jne 0x12bea
jmp 0x12ca5
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
leaq -0x10(%rbp), %rdi
callq 0x12d90
movl %eax, -0x24(%rbp)
cmpl $0xffff, -0x24(%rbp)    # imm = 0xFFFF
jbe 0x12c75
movl -0x24(%rbp), %eax
shrl $0xa, %eax
addl $0xd7c0, %eax           # imm = 0xD7C0
movw %ax, -0x32(%rbp)
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x12ee0
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x12f00
movq %rax, %rdi
leaq -0x32(%rbp), %rsi
callq 0x12f10
movl -0x24(%rbp), %eax
andl $0x3ff, %eax            # imm = 0x3FF
addl $0xdc00, %eax           # imm = 0xDC00
movw %ax, -0x42(%rbp)
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x12ee0
movq %rax, -0x50(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x12f00
movq %rax, %rdi
leaq -0x42(%rbp), %rsi
callq 0x12f10
jmp 0x12ca0
movl -0x24(%rbp), %eax
movw %ax, -0x52(%rbp)
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x12ee0
movq %rax, -0x60(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x12f00
movq %rax, %rdi
leaq -0x52(%rbp), %rsi
callq 0x12f10
jmp 0x12bd4
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: halsafar[P]libtmx-parser/./src/tmxparser.cpp
// Function: tmxparser::parseFromFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, tmxparser::TmxMap*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
TmxReturn parseFromFile(const std::string& fileName, TmxMap* outMap, const std::string& tilesetPath)
{
	tinyxml2::XMLDocument doc;
	if (doc.LoadFile(fileName.c_str()) != tinyxml2::XML_SUCCESS)
	{
		LOGE("Cannot read xml file");
		return TmxReturn::kErrorParsing;
	}

	// parse the map node
	return _parseStart(doc.FirstChildElement("map"), outMap, tilesetPath);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2d0, %rsp            # imm = 0x2D0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x2a0(%rbp), %rdi
movq %rdi, -0x2c0(%rbp)
movl $0x1, %esi
xorl %edx, %edx
callq 0x1d490
movq -0x10(%rbp), %rdi
callq 0x4100
movq -0x2c0(%rbp), %rdi
movq %rax, %rsi
callq 0x1d6d0
movl %eax, -0x2b4(%rbp)
jmp 0x4751
movl -0x2b4(%rbp), %eax
cmpl $0x0, %eax
je 0x47bf
movq 0x2e875(%rip), %rax     # 0x32fd8
movq (%rax), %rdi
leaq 0x1d8ab(%rip), %rsi     # 0x22018
movb $0x0, %al
callq 0x43a0
movq 0x2e85d(%rip), %rax     # 0x32fd8
movq (%rax), %rdi
leaq 0x1e1ab(%rip), %rsi     # 0x22930
movb $0x0, %al
callq 0x43a0
movl $0x1, -0x4(%rbp)
movl $0x1, -0x2b0(%rbp)
jmp 0x480a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2a8(%rbp)
movl %eax, -0x2ac(%rbp)
leaq -0x2a0(%rbp), %rdi
callq 0x1d5c0
jmp 0x4822
leaq 0x1d879(%rip), %rsi     # 0x2203f
leaq -0x2a0(%rbp), %rdi
callq 0x7b60
movq %rax, -0x2c8(%rbp)
jmp 0x47db
movq -0x2c8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x4830
movl %eax, -0x2cc(%rbp)
jmp 0x47f7
movl -0x2cc(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0x2b0(%rbp)
leaq -0x2a0(%rbp), %rdi
callq 0x1d5c0
movl -0x4(%rbp), %eax
addq $0x2d0, %rsp            # imm = 0x2D0
popq %rbp
retq
movq -0x2a8(%rbp), %rdi
callq 0x4470
nop
// File: halsafar[P]libtmx-parser/./src/tmxparser.cpp
// Function: tmxparser::parseFromMemory(void*, unsigned long, tmxparser::TmxMap*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
TmxReturn parseFromMemory(void* data, size_t length, TmxMap* outMap, const std::string& tilesetPath)
{
	tinyxml2::XMLDocument doc;
	if (doc.Parse((char*)data, length))
	{
		LOGE("Cannot parse xml memory file...");
		return TmxReturn::kErrorParsing;
	}

	return _parseStart(doc.FirstChildElement("map"), outMap, tilesetPath);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2e0, %rsp            # imm = 0x2E0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
leaq -0x2a8(%rbp), %rdi
movq %rdi, -0x2c8(%rbp)
movl $0x1, %esi
xorl %edx, %edx
callq 0x1d490
movq -0x2c8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1db70
movl %eax, -0x2bc(%rbp)
jmp 0x4921
movl -0x2bc(%rbp), %eax
cmpl $0x0, %eax
je 0x498f
movq 0x2e6a5(%rip), %rax     # 0x32fd8
movq (%rax), %rdi
leaq 0x1d706(%rip), %rsi     # 0x22043
movb $0x0, %al
callq 0x43a0
movq 0x2e68d(%rip), %rax     # 0x32fd8
movq (%rax), %rdi
leaq 0x1dfdb(%rip), %rsi     # 0x22930
movb $0x0, %al
callq 0x43a0
movl $0x1, -0x4(%rbp)
movl $0x1, -0x2b8(%rbp)
jmp 0x49da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2b0(%rbp)
movl %eax, -0x2b4(%rbp)
leaq -0x2a8(%rbp), %rdi
callq 0x1d5c0
jmp 0x49f2
leaq 0x1d6a9(%rip), %rsi     # 0x2203f
leaq -0x2a8(%rbp), %rdi
callq 0x7b60
movq %rax, -0x2d0(%rbp)
jmp 0x49ab
movq -0x2d0(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x4830
movl %eax, -0x2d4(%rbp)
jmp 0x49c7
movl -0x2d4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0x2b8(%rbp)
leaq -0x2a8(%rbp), %rdi
callq 0x1d5c0
movl -0x4(%rbp), %eax
addq $0x2e0, %rsp            # imm = 0x2E0
popq %rbp
retq
movq -0x2b0(%rbp), %rdi
callq 0x4470
nop
// File: halsafar[P]libtmx-parser/./src/tmxparser.cpp
// Function: tmxparser::_parseEnd(tmxparser::TmxMap*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
TmxReturn _parseEnd(TmxMap* outMap, const std::string& tilesetPath)
{
	for (auto tileIt = outMap->tilesetCollection.begin(); tileIt != outMap->tilesetCollection.end(); ++tileIt)
		_parseEndHelper(tileIt->image, tilesetPath);

	for (auto tileIt = outMap->imageLayerCollection.begin(); tileIt != outMap->imageLayerCollection.end(); ++tileIt)
		_parseEndHelper(tileIt->image, tilesetPath);

	return TmxReturn::kSuccess;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0xb0, %rdi
callq 0x7b90
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0xb0, %rdi
callq 0x7c00
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x7bc0
testb $0x1, %al
jne 0x52eb
jmp 0x530f
leaq -0x18(%rbp), %rdi
callq 0x7c30
movq %rax, %rdi
addq $0x68, %rdi
movq -0x10(%rbp), %rsi
callq 0x5380
leaq -0x18(%rbp), %rdi
callq 0x7c50
jmp 0x52c4
movq -0x8(%rbp), %rdi
addq $0xf8, %rdi
callq 0x7c70
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
addq $0xf8, %rdi
callq 0x7ce0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x7ca0
testb $0x1, %al
jne 0x534a
jmp 0x536e
leaq -0x28(%rbp), %rdi
callq 0x7d10
movq %rax, %rdi
addq $0x70, %rdi
movq -0x10(%rbp), %rsi
callq 0x5380
leaq -0x28(%rbp), %rdi
callq 0x7d30
jmp 0x5323
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: halsafar[P]libtmx-parser/./src/tmxparser.cpp
// Function: tmxparser::_parseImageNode(tinyxml2::XMLElement*, tmxparser::TmxImage*)
TmxReturn _parseImageNode(tinyxml2::XMLElement* element, TmxImage* outImage)
{
	CHECK_AND_RETRIEVE_REQ_ATTRIBUTE_STRING(element, "source", outImage->source);
	CHECK_AND_RETRIEVE_OPT_ATTRIBUTE_STRING(element, "format", outImage->format);
	CHECK_AND_RETRIEVE_OPT_ATTRIBUTE_STRING(element, "trans", outImage->transparentColor);

	outImage->width = element->UnsignedAttribute("width");
	outImage->height = element->UnsignedAttribute("height");

	return TmxReturn::kSuccess;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1c0d1(%rip), %rsi     # 0x2227c
xorl %eax, %eax
movl %eax, %edx
callq 0x1c710
movq %rax, %rsi
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0x4360
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0x41c0
cmpq $0x0, %rax
jne 0x621a
movq 0x2cdfa(%rip), %rax     # 0x32fd8
movq (%rax), %rdi
leaq 0x1bef0(%rip), %rsi     # 0x220d8
leaq 0x1c08d(%rip), %rdx     # 0x2227c
movb $0x0, %al
callq 0x43a0
movq 0x2cddb(%rip), %rax     # 0x32fd8
movq (%rax), %rdi
leaq 0x1c729(%rip), %rsi     # 0x22930
movb $0x0, %al
callq 0x43a0
movl $0x2, -0x4(%rbp)
jmp 0x62e9
movq -0x10(%rbp), %rdi
leaq 0x1c05e(%rip), %rsi     # 0x22283
xorl %eax, %eax
movl %eax, %edx
callq 0x1c710
cmpq $0x0, %rax
je 0x6256
movq -0x10(%rbp), %rdi
leaq 0x1c044(%rip), %rsi     # 0x22283
xorl %eax, %eax
movl %eax, %edx
callq 0x1c710
movq %rax, %rsi
movq -0x18(%rbp), %rdi
callq 0x4360
jmp 0x6261
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x4450
movq -0x10(%rbp), %rdi
leaq 0x1c01e(%rip), %rsi     # 0x2228a
xorl %eax, %eax
movl %eax, %edx
callq 0x1c710
cmpq $0x0, %rax
je 0x62a1
movq -0x10(%rbp), %rdi
leaq 0x1c004(%rip), %rsi     # 0x2228a
xorl %eax, %eax
movl %eax, %edx
callq 0x1c710
movq %rax, %rsi
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
callq 0x4360
jmp 0x62b0
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
xorl %esi, %esi
callq 0x4450
movq -0x10(%rbp), %rdi
leaq 0x1be53(%rip), %rsi     # 0x2210e
callq 0x82f0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x60(%rax)
movq -0x10(%rbp), %rdi
leaq 0x1be44(%rip), %rsi     # 0x22118
callq 0x82f0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x64(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: halsafar[P]libtmx-parser/./src/tmxparser.cpp
// Function: tmxparser::_parseOffsetNode(tinyxml2::XMLElement*, tmxparser::TmxOffset*)
tmxparser::TmxReturn _parseOffsetNode(tinyxml2::XMLElement* element, TmxOffset* offset)
{
	TmxReturn error = TmxReturn::kSuccess;

	offset->x = 0;
	offset->y = 0;

	if (element->Attribute("x"))
	{
		offset->x = element->IntAttribute("x");
	}

	if (element->Attribute("y"))
	{
		offset->y = element->IntAttribute("y");
	}

	return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rdi
leaq 0x1c0e9(%rip), %rsi     # 0x228f0
xorl %eax, %eax
movl %eax, %edx
callq 0x1c710
cmpq $0x0, %rax
je 0x682e
movq -0x8(%rbp), %rdi
leaq 0x1c0cf(%rip), %rsi     # 0x228f0
callq 0x8580
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
leaq 0x1bb9a(%rip), %rsi     # 0x223d3
xorl %eax, %eax
movl %eax, %edx
callq 0x1c710
cmpq $0x0, %rax
je 0x6861
movq -0x8(%rbp), %rdi
leaq 0x1bb80(%rip), %rsi     # 0x223d3
callq 0x8580
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: halsafar[P]libtmx-parser/./src/tmxparser.cpp
// Function: tmxparser::_parseTileDefinitionNode(tinyxml2::XMLElement*, tmxparser::TmxTileDefinition*)
TmxReturn _parseTileDefinitionNode(tinyxml2::XMLElement* element, TmxTileDefinition* outTileDefinition)
{
	TmxReturn error = TmxReturn::kSuccess;

	outTileDefinition->id = element->UnsignedAttribute("id");
	error = _parsePropertyNode(element->FirstChildElement("properties"), &outTileDefinition->propertyMap);
	if (error)
	{
		return error;
	}

	if (element->FirstChildElement("animation") != NULL)
	{
		error = _parseTileAnimationNode(element->FirstChildElement("animation"), &outTileDefinition->animations);
	}

	for (tinyxml2::XMLElement* child = element->FirstChildElement("objectgroup"); child != NULL; child = child->NextSiblingElement("objectgroup"))
	{
		TmxObjectGroup group;
		error = _parseObjectGroupNode(child, &group);
		if (error)
		{
			LOGE("Error processing objectgroup node...");
			return error;
		}

		outTileDefinition->objectgroups.push_back(group);
	}

	return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1bb35(%rip), %rsi     # 0x223ca
callq 0x82f0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
leaq 0x1b88e(%rip), %rsi     # 0x2213b
callq 0x7b60
movq %rax, %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
callq 0x55c0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x68d6
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6a25
movq -0x10(%rbp), %rdi
leaq 0x1bacc(%rip), %rsi     # 0x223ad
callq 0x7b60
cmpq $0x0, %rax
je 0x690f
movq -0x10(%rbp), %rdi
leaq 0x1bab6(%rip), %rsi     # 0x223ad
callq 0x7b60
movq %rax, %rdi
movq -0x18(%rbp), %rsi
addq $0x40, %rsi
callq 0x6a40
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1b8cd(%rip), %rsi     # 0x221e7
callq 0x7b60
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x6a1f
leaq -0xc0(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x80a0
movq -0xe0(%rbp), %rsi
movq -0x28(%rbp), %rdi
callq 0x5cf0
movl %eax, -0xd4(%rbp)
jmp 0x6959
movl -0xd4(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x69ca
movq 0x2c669(%rip), %rax     # 0x32fd8
movq (%rax), %rdi
leaq 0x1b87a(%rip), %rsi     # 0x221f3
movb $0x0, %al
callq 0x43a0
movq 0x2c651(%rip), %rax     # 0x32fd8
movq (%rax), %rdi
leaq 0x1bf9f(%rip), %rsi     # 0x22930
movb $0x0, %al
callq 0x43a0
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0xd0(%rbp)
jmp 0x69ea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc8(%rbp)
movl %eax, -0xcc(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x8160
jmp 0x6a31
movq -0x18(%rbp), %rdi
addq $0x58, %rdi
leaq -0xc0(%rbp), %rsi
callq 0x80f0
jmp 0x69e0
movl $0x0, -0xd0(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x8160
movl -0xd0(%rbp), %eax
testl %eax, %eax
je 0x6a04
jmp 0x6a02
jmp 0x6a25
jmp 0x6a06
movq -0x28(%rbp), %rdi
leaq 0x1b7d6(%rip), %rsi     # 0x221e7
callq 0x7f80
movq %rax, -0x28(%rbp)
jmp 0x6923
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
movq -0xc8(%rbp), %rdi
callq 0x4470
nopl (%rax)
// File: halsafar[P]libtmx-parser/./src/tmxparser.cpp
// Function: tmxparser::_parseTileAnimationNode(tinyxml2::XMLElement*, std::vector<tmxparser::TmxAnimationFrame, std::allocator<tmxparser::TmxAnimationFrame>>*)
TmxReturn _parseTileAnimationNode(tinyxml2::XMLElement* element, TmxAnimationFrameCollection_t* outAnimationCollection)
{
	for (tinyxml2::XMLElement* child = element->FirstChildElement("frame"); child != NULL; child = child->NextSiblingElement("frame"))
	{
		TmxAnimationFrame frame;
		frame.duration = child->FloatAttribute("duration");
		frame.tileId = child->UnsignedAttribute("tileid");

		outAnimationCollection->push_back(frame);
	}

	return kSuccess;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1b95c(%rip), %rsi     # 0x223b7
callq 0x7b60
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6ab6
movq -0x18(%rbp), %rdi
leaq 0x1b947(%rip), %rsi     # 0x223bd
callq 0x84d0
movss %xmm0, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x1b93b(%rip), %rsi     # 0x223c6
callq 0x82f0
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x8510
movq -0x18(%rbp), %rdi
leaq 0x1b90c(%rip), %rsi     # 0x223b7
callq 0x7f80
movq %rax, -0x18(%rbp)
jmp 0x6a64
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: halsafar[P]libtmx-parser/./src/tmxparser.cpp
// Function: tmxparser::_parseLayerXmlTileNode(tinyxml2::XMLElement*, std::vector<tmxparser::TmxTileset, std::allocator<tmxparser::TmxTileset>> const&, tmxparser::TmxLayerTile*)
TmxReturn _parseLayerXmlTileNode(tinyxml2::XMLElement* element, const TmxTilesetCollection_t& tilesets, TmxLayerTile* outTile)
{
	TmxReturn error = TmxReturn::kSuccess;

	unsigned int gid = element->UnsignedAttribute("gid");

	unsigned int flipXFlag = 0x80000000;
	unsigned int flipYFlag = 0x40000000;
	unsigned int flipDiagonalFlag = 0x20000000;

	outTile->flipX = (gid & flipXFlag ? true : false);
	outTile->flipY = (gid & flipYFlag ? true : false);
	outTile->flipDiagonal = (gid & flipDiagonalFlag ? true : false);
	outTile->gid = (gid & ~(flipXFlag | flipYFlag | flipDiagonalFlag));

	return _calculateTileIndices(tilesets, outTile);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1b0b4(%rip), %rsi     # 0x2237a
callq 0x82f0
movl %eax, -0x20(%rbp)
movl $0x80000000, -0x24(%rbp) # imm = 0x80000000
movl $0x40000000, -0x28(%rbp) # imm = 0x40000000
movl $0x20000000, -0x2c(%rbp) # imm = 0x20000000
movl -0x20(%rbp), %eax
movl -0x24(%rbp), %ecx
andl %ecx, %eax
testl %eax, %eax
movq -0x18(%rbp), %rax
setne 0xc(%rax)
movl -0x20(%rbp), %eax
movl -0x28(%rbp), %ecx
andl %ecx, %eax
testl %eax, %eax
movq -0x18(%rbp), %rax
setne 0xd(%rax)
movl -0x20(%rbp), %ecx
movl -0x2c(%rbp), %eax
andl %eax, %ecx
xorl %eax, %eax
negl %ecx
sbbl %eax, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
andb $0x1, %cl
movb %cl, 0xe(%rax)
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %eax
orl -0x28(%rbp), %eax
orl -0x2c(%rbp), %eax
xorl $-0x1, %eax
andl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7350
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: halsafar[P]libtmx-parser/./src/tmxparser.cpp
// Function: tmxparser::_calculateTileIndices(std::vector<tmxparser::TmxTileset, std::allocator<tmxparser::TmxTileset>> const&, tmxparser::TmxLayerTile*)
TmxReturn _calculateTileIndices(const TmxTilesetCollection_t& tilesets, TmxLayerTile* outTile)
{
	outTile->tilesetIndex = 0;
	outTile->tileFlatIndex = 0;

	// exit quickly
	if (outTile->gid == 0)
	{
		return TmxReturn::kSuccess;
	}

	// search for tilesetindex
	// O(n) where n = number of tilesets
	// Generally n will never be high but this method is called from an O(m) method.
	unsigned int index = 0;
	unsigned int lastEndIndex = 1;
	for (auto it = tilesets.begin(); it != tilesets.end(); ++it)
	{
		unsigned int colCount = it->colCount;
		unsigned int rowCount = it->rowCount;
		unsigned int startIndex = it->firstgid;
		unsigned int endIndex = it->firstgid + ( colCount * rowCount );

		if (outTile->gid >= startIndex && outTile->gid < endIndex)
		{
			outTile->tilesetIndex = index;
			outTile->tileFlatIndex = (outTile->gid) - lastEndIndex;

			// done
			return TmxReturn::kSuccess;
		}

		lastEndIndex = endIndex;

		index++;
	}

	// if we made it here, tile indices could not be found
	return TmxReturn::kUnknownTileIndices;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x738b
movl $0x0, -0x4(%rbp)
jmp 0x746b
movl $0x0, -0x1c(%rbp)
movl $0x1, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8700
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8770
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x8730
testb $0x1, %al
jne 0x73c9
jmp 0x7464
leaq -0x28(%rbp), %rdi
callq 0x87a0
movl 0x64(%rax), %eax
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x87a0
movl 0x60(%rax), %eax
movl %eax, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x87a0
movl 0x20(%rax), %eax
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x87a0
movl 0x20(%rax), %eax
movl -0x34(%rbp), %ecx
imull -0x38(%rbp), %ecx
addl %ecx, %eax
movl %eax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpl -0x3c(%rbp), %eax
jb 0x7447
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpl -0x40(%rbp), %eax
jae 0x7447
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
subl -0x20(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x746b
movl -0x40(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x87c0
jmp 0x73a6
movl $0x8, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.h
// Function: tinyxml2::XMLElement::QueryUnsignedAttribute(char const*, unsigned int*) const
XMLError QueryUnsignedAttribute( const char* name, unsigned int* value ) const	{
        const XMLAttribute* a = FindAttribute( name );
        if ( !a ) {
            return XML_NO_ATTRIBUTE;
        }
        return a->QueryUnsignedValue( value );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1c6a0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x7e55
movl $0x1, -0x4(%rbp)
jmp 0x7e65
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1c1b0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.h
// Function: tinyxml2::XMLElement::QueryFloatAttribute(char const*, float*) const
XMLError QueryFloatAttribute( const char* name, float* value ) const			{
        const XMLAttribute* a = FindAttribute( name );
        if ( !a ) {
            return XML_NO_ATTRIBUTE;
        }
        return a->QueryFloatValue( value );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1c6a0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x89e5
movl $0x1, -0x4(%rbp)
jmp 0x89f5
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1c250
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.h
// Function: tinyxml2::XMLElement::QueryBoolAttribute(char const*, bool*) const
XMLError QueryBoolAttribute( const char* name, bool* value ) const				{
        const XMLAttribute* a = FindAttribute( name );
        if ( !a ) {
            return XML_NO_ATTRIBUTE;
        }
        return a->QueryBoolValue( value );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1c6a0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x8a35
movl $0x1, -0x4(%rbp)
jmp 0x8a45
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1c200
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: halsafar[P]libtmx-parser/./libs/tinyxml2/tinyxml2.h
// Function: tinyxml2::XMLElement::QueryIntAttribute(char const*, int*) const
XMLError QueryIntAttribute( const char* name, int* value ) const				{
        const XMLAttribute* a = FindAttribute( name );
        if ( !a ) {
            return XML_NO_ATTRIBUTE;
        }
        return a->QueryIntValue( value );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1c6a0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xf6b5
movl $0x1, -0x4(%rbp)
jmp 0xf6c5
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1c160
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: halsafar[P]libtmx-parser/main.cpp
// Function: printProperties(int, std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 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, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&)
void printProperties(int depth, const tmxparser::TmxPropertyMap_t& map)
{
	if (map.empty())
	{
		return;
	}

	printf_depth(depth, "%s", "<properties>");
	for (auto it = map.begin(); it != map.end(); ++it)
	{
		printf_depth(depth+1, "%s=%s", it->first.c_str(), it->second.c_str());
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x18a10
testb $0x1, %al
jne 0x1781e
jmp 0x17823
jmp 0x178d0
imull $0x5, -0x4(%rbp), %esi
leaq 0xadbe(%rip), %rdi      # 0x225ec
leaq 0xb0fc(%rip), %rdx      # 0x22931
leaq 0xadb8(%rip), %rcx      # 0x225f4
movb $0x0, %al
callq 0x4060
movq -0x10(%rbp), %rdi
callq 0x18a30
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x18a90
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x18a60
testb $0x1, %al
jne 0x17870
jmp 0x178d0
movl -0x4(%rbp), %eax
addl $0x1, %eax
imull $0x5, %eax, %eax
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x18ac0
movq %rax, %rdi
callq 0x4100
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x18ac0
movq %rax, %rdi
addq $0x20, %rdi
callq 0x4100
movl -0x2c(%rbp), %esi
movq -0x28(%rbp), %rcx
movq %rax, %r8
leaq 0xad4a(%rip), %rdi      # 0x22601
leaq 0xb073(%rip), %rdx      # 0x22931
movb $0x0, %al
callq 0x4060
leaq -0x18(%rbp), %rdi
callq 0x18af0
jmp 0x17850
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: halsafar[P]libtmx-parser/main.cpp
// Function: printObjectGroups(int, std::vector<tmxparser::TmxObjectGroup, std::allocator<tmxparser::TmxObjectGroup>> const&)
void printObjectGroups(int depth, const tmxparser::TmxObjectGroupCollection_t& collection)
{
	int nextdepth = depth +1;

	for (auto it = collection.begin(); it != collection.end(); ++it)
	{
		printf_depth(depth, "%s", "<objectgroup>");

		printf_depth(nextdepth, "Name: %s", it->name.c_str());
		printf_depth(nextdepth, "Color: %s", it->color.c_str());
		printf_depth(nextdepth, "Opacity: %f", it->opacity);
		printf_depth(nextdepth, "Visible: %u", it->visible);
		printProperties(nextdepth, it->propertyMap);
		printObjects(nextdepth, it->objects);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbc80
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbcb0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xc130
testb $0x1, %al
jne 0x17c88
jmp 0x17dc0
imull $0x5, -0x4(%rbp), %esi
leaq 0xa959(%rip), %rdi      # 0x225ec
leaq 0xac97(%rip), %rdx      # 0x22931
leaq 0xaa25(%rip), %rcx      # 0x226c6
movb $0x0, %al
callq 0x4060
imull $0x5, -0x14(%rbp), %eax
movl %eax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x18b60
movq %rax, %rdi
callq 0x4100
movl -0x40(%rbp), %esi
movq %rax, %rcx
leaq 0xa948(%rip), %rdi      # 0x22615
leaq 0xac5d(%rip), %rdx      # 0x22931
movb $0x0, %al
callq 0x4060
imull $0x5, -0x14(%rbp), %eax
movl %eax, -0x3c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x18b60
movq %rax, %rdi
addq $0x20, %rdi
callq 0x4100
movl -0x3c(%rbp), %esi
movq %rax, %rcx
leaq 0xa9d0(%rip), %rdi      # 0x226d4
leaq 0xac26(%rip), %rdx      # 0x22931
movb $0x0, %al
callq 0x4060
imull $0x5, -0x14(%rbp), %eax
movl %eax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x18b60
movl -0x38(%rbp), %esi
movss 0x40(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0xa9ae(%rip), %rdi      # 0x226e3
leaq 0xabf5(%rip), %rdx      # 0x22931
movb $0x1, %al
callq 0x4060
imull $0x5, -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x18b60
movl -0x34(%rbp), %esi
movb 0x44(%rax), %al
andb $0x1, %al
movzbl %al, %ecx
leaq 0xa98f(%rip), %rdi      # 0x226f4
leaq 0xabc5(%rip), %rdx      # 0x22931
movb $0x0, %al
callq 0x4060
movl -0x14(%rbp), %eax
movl %eax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x18b60
movl -0x30(%rbp), %edi
movq %rax, %rsi
addq $0x48, %rsi
callq 0x17800
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x18b60
movl -0x2c(%rbp), %edi
movq %rax, %rsi
addq $0x80, %rsi
callq 0x178e0
leaq -0x20(%rbp), %rdi
callq 0xc1c0
jmp 0x17c65
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)