LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/rofl0r[P]ascc/tokenizer.c
// Function: tokenizer_skip_chars
int tokenizer_skip_chars(struct tokenizer *t, const char *chars, int *count) {
	assert(!t->peeking);
	int c;
	*count = 0;
	while(1) {
		c = tokenizer_getc(t);
		if(c == EOF) return 0;
		const char *s = chars;
		int match = 0;
		while(*s) {
			if(c==*s) {
				++(*count);
				match = 1;
				break;
			}
			++s;
		}
		if(!match) {
			tokenizer_ungetc(t, c);
			return 1;
		}
	}

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0x0, 0x18(%rdi)
jne 0x17d47
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x0, (%rdx)
callq 0x17b5e
xorl %ebp, %ebp
cmpl $-0x1, %eax
je 0x17d3c
leaq 0x1(%r15), %r12
movb (%r15), %dl
movq %r12, %rcx
testb %dl, %dl
je 0x17d2d
movsbl %dl, %edx
cmpl %edx, %eax
je 0x17d1b
movb (%rcx), %dl
incq %rcx
jmp 0x17d09
incl (%r14)
movq %rbx, %rdi
callq 0x17b5e
cmpl $-0x1, %eax
jne 0x17d03
jmp 0x17d3c
movq %rbx, %rdi
movl %eax, %esi
callq 0x17bab
movl $0x1, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x56eb(%rip), %rdi      # 0x1d439
leaq 0x5610(%rip), %rsi      # 0x1d365
leaq 0x56e9(%rip), %rcx      # 0x1d445
movl $0x14f, %edx            # imm = 0x14F
callq 0x3240
// File: /workspace/github_cpp_makefile_star2_O1/rofl0r[P]ascc/tokenizer.c
// Function: tokenizer_read_until
int tokenizer_read_until(struct tokenizer *t, const char* marker, int stop_at_nl)
{
	int c, marker_is_nl = !strcmp(marker, "\n");
	char *s = t->buf;
	while(1) {
		c = tokenizer_getc(t);
		if(c == EOF) {
			*s = 0;
			return 0;
		}
		if(c == '\n') {
			t->line++;
			t->column = 0;
			if(stop_at_nl) {
				*s = 0;
				if(marker_is_nl) return 1;
				return 0;
			}
		}
		if(!sequence_follows(t, c, marker))
			s = assign_bufchar(t, s, c);
		else
			break;
	}
	*s = 0;
	size_t i;
	for(i=strlen(marker); i > 0; )
		tokenizer_ungetc(t, marker[--i]);
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x5467(%rip), %rsi      # 0x1d1e7
movq %rbx, %rdi
callq 0x3450
movl %eax, %r15d
leaq 0x120(%r14), %r13
movq %r14, %rdi
callq 0x17b5e
movl %eax, %r12d
cmpl $0xa, %eax
je 0x17daa
cmpl $-0x1, %r12d
jne 0x17dba
jmp 0x17e08
incl 0x8(%r14)
movl $0x0, 0xc(%r14)
testl %ebp, %ebp
jne 0x17e11
movq %r14, %rdi
movl %r12d, %esi
movq %rbx, %rdx
callq 0x17e30
testl %eax, %eax
jne 0x17dd9
incl 0xc(%r14)
movb %r12b, (%r13)
incq %r13
jmp 0x17d92
movb $0x0, (%r13)
movq %rbx, %rdi
callq 0x31a0
movl $0x1, %ebp
testq %rax, %rax
je 0x17e1f
movq %rax, %r15
movsbl -0x1(%rbx,%r15), %esi
movq %r14, %rdi
callq 0x17bab
decq %r15
jne 0x17df3
jmp 0x17e1f
movb $0x0, (%r13)
xorl %ebp, %ebp
jmp 0x17e1f
xorl %ebp, %ebp
testl %r15d, %r15d
sete %bpl
movb $0x0, (%r13)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/rofl0r[P]ascc/tokenizer.c
// Function: sequence_follows
static int sequence_follows(struct tokenizer *t, int c, const char *which)
{
	if(!which || !which[0]) return 0;
	size_t i = 0;
	while(c == which[i]) {
		if(!which[++i]) break;
		c = tokenizer_getc(t);
	}
	if(!which[i]) return 1;
	while(i > 0) {
		tokenizer_ungetc(t, c);
		c = which[--i];
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %ebp, %ebp
testq %rdx, %rdx
je 0x17ebc
movq %rdx, %rbx
cmpb $0x0, (%rdx)
je 0x17ebc
movl %esi, %eax
movq %rdi, %r14
movsbl (%rbx), %ecx
cmpl %esi, %ecx
jne 0x17e82
cmpb $0x0, 0x1(%rbx)
je 0x17e87
movl $0x1, %r12d
movq %r14, %rdi
callq 0x17b5e
movsbl (%rbx,%r12), %ecx
cmpl %ecx, %eax
jne 0x17e8f
leaq 0x1(%r12), %r15
cmpb $0x0, 0x1(%rbx,%r12)
movq %r15, %r12
jne 0x17e5f
jmp 0x17e92
xorl %r15d, %r15d
jmp 0x17e92
movl $0x1, %r15d
jmp 0x17e92
movq %r12, %r15
cmpb $0x0, (%rbx,%r15)
je 0x17eb7
xorl %ebp, %ebp
testq %r15, %r15
je 0x17ebc
movq %r14, %rdi
movl %eax, %esi
callq 0x17bab
movsbl -0x1(%rbx,%r15), %eax
decq %r15
jne 0x17ea0
jmp 0x17ebc
movl $0x1, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/rofl0r[P]ascc/tokenizer.c
// Function: ignore_until
static int ignore_until(struct tokenizer *t, const char* marker, int col_advance)
{
	t->column += col_advance;
	int c;
	do {
		c = tokenizer_getc(t);
		if(c == EOF) return 0;
		if(c == '\n') {
			t->line++;
			t->column = 0;
		} else t->column++;
	} while(!sequence_follows(t, c, marker));
	t->column += strlen(marker)-1;
	return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addl %edx, 0xc(%rdi)
movq %rbx, %rdi
callq 0x17b5e
cmpl $0xa, %eax
je 0x17ef1
cmpl $-0x1, %eax
je 0x17f1c
movl 0xc(%rbx), %ecx
incl %ecx
jmp 0x17ef6
incl 0x8(%rbx)
xorl %ecx, %ecx
movl %ecx, 0xc(%rbx)
movq %rbx, %rdi
movl %eax, %esi
movq %r14, %rdx
callq 0x17e30
testl %eax, %eax
je 0x17ed8
movq %r14, %rdi
callq 0x31a0
movl 0xc(%rbx), %ecx
addl %ecx, %eax
decl %eax
movl %eax, 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/rofl0r[P]ascc/tokenizer.c
// Function: is_valid_float_until
static int is_valid_float_until(const char*s, const char* until) {
	int got_digits = 0, got_dot = 0;
	while(s < until) {
		if(isdigit(*s)) got_digits = 1;
		else if(*s == '.') {
			if(got_dot) return 0;
			got_dot = 1;
		} else return 0;
		++s;
	}
	return got_digits | (got_dot << 1);
}

// Assembly:
xorl %eax, %eax
cmpq %rsi, %rdi
jae 0x188d7
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3340
movq (%rax), %rdx
xorl %ecx, %ecx
xorl %esi, %esi
xorl %eax, %eax
movsbq (%r14), %rdi
testb $0x8, 0x1(%rdx,%rdi,2)
jne 0x188bd
cmpb $0x2e, %dil
jne 0x188d0
testl %ecx, %ecx
movl $0x1, %ecx
je 0x188c2
jmp 0x188d0
movl $0x1, %esi
incq %r14
cmpq %rbx, %r14
jne 0x188a1
addl %ecx, %ecx
orl %esi, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/rofl0r[P]ascc/tokenizer.c
// Function: tokenizer_rewind
int tokenizer_rewind(struct tokenizer *t) {
	FILE *f = t->input;
	int flags = t->flags;
	const char* fn = t->filename;
	tokenizer_init(t, f, flags);
	tokenizer_set_filename(t, fn);
	return fseek(f, 0, SEEK_SET) == 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x1170(%rdi), %r15
movq $0x1, 0x8(%rdi)
addq $0x14, %rdi
movl $0x110c, %edx           # imm = 0x110C
xorl %esi, %esi
callq 0x3210
movq $0x1000, 0x1120(%rbx) # imm = 0x1000
xorps %xmm0, %xmm0
movups %xmm0, 0x1168(%rbx)
movups %xmm0, 0x1128(%rbx)
movups %xmm0, 0x1138(%rbx)
movups %xmm0, 0x1148(%rbx)
movups %xmm0, 0x1158(%rbx)
movups %xmm0, 0x1178(%rbx)
movq %r15, 0x1170(%rbx)
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3370
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
movl %ecx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/rofl0r[P]ascc/tokenizer.c
// Function: has_ul_tail
static int has_ul_tail(const char *p) {
	char tail[4];
	int tc = 0, c;
	while(tc < 4 ) {
		if(!*p) break;
		c = tolower(*p);
		if(c == 'u' || c == 'l') {
			tail[tc++] = c;
		} else {
			return 0;
		}
		p++;
	}
	if(tc == 1) return 1;
	if(tc == 2) {
		if(!memcmp(tail, "lu", 2)) return 1;
		if(!memcmp(tail, "ul", 2)) return 1;
		if(!memcmp(tail, "ll", 2)) return 1;
	}
	if(tc == 3) {
		if(!memcmp(tail, "llu", 3)) return 1;
		if(!memcmp(tail, "ull", 3)) return 1;
	}
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorl %r14d, %r14d
movsbq (%rbx,%r14), %r15
testq %r15, %r15
je 0x18c74
callq 0x30c0
movq (%rax), %rax
movl (%rax,%r15,4), %eax
cmpl $0x75, %eax
je 0x18c60
cmpl $0x6c, %eax
jne 0x18ce1
movb %al, 0xc(%rsp,%r14)
incq %r14
cmpq $0x4, %r14
jne 0x18c3c
movl $0x4, %r14d
cmpl $0x1, %r14d
je 0x18ce5
cmpl $0x3, %r14d
je 0x18cac
cmpl $0x2, %r14d
jne 0x18ce1
movl $0x1, %eax
cmpw $0x756c, 0xc(%rsp)      # imm = 0x756C
je 0x18ce8
cmpw $0x6c75, 0xc(%rsp)      # imm = 0x6C75
je 0x18ce8
cmpw $0x6c6c, 0xc(%rsp)      # imm = 0x6C6C
je 0x18ce8
cmpl $0x3, %r14d
jne 0x18ce1
movzwl 0xc(%rsp), %ecx
xorl $0x6c6c, %ecx           # imm = 0x6C6C
movzbl 0xe(%rsp), %edx
xorl $0x75, %edx
movl $0x1, %eax
orw %cx, %dx
je 0x18ce8
movzwl 0xc(%rsp), %ecx
xorl $0x6c75, %ecx           # imm = 0x6C75
movzbl 0xe(%rsp), %edx
xorl $0x6c, %edx
orw %cx, %dx
je 0x18ce8
xorl %eax, %eax
jmp 0x18ce8
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/rofl0r[P]ascc/eval_if.c
// Function: emit_token
char* emit_token(char* out, struct token *tok, char *strbuf) {
	if(tok->type == TT_SEP)
		sprintf(out, "%c", tok->value);
	else if(strbuf)
		strcat(out, strbuf);
	return out + strlen(out);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x9, (%rsi)
jne 0x18d08
movb 0xc(%rsi), %al
movb %al, (%rbx)
movb $0x0, 0x1(%rbx)
jmp 0x18d18
testq %rdx, %rdx
je 0x18d18
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x3570
movq %rbx, %rdi
callq 0x31a0
addq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/rofl0r[P]ascc/eval_if.c
// Function: x_tokenizer_next_of
static int x_tokenizer_next_of(struct tokenizer *t, struct token *tok, int fail_unk) {
	int ret = tokenizer_next(t, tok);
	if(tok->type == TT_OVERFLOW) {
		error("max token length of 4095 exceeded!");
		return 0;
	} else if (fail_unk && ret == 0) {
		error("tokenizer encountered unknown token");
		return 0;
	} else if (tok->type == TT_SEP && tok->value == '\t') {
		tok->value = ' ';
	}
	return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
callq 0x17c70
movl (%rbx), %ecx
cmpl $0xb, %ecx
jne 0x191e9
leaq 0x4684(%rip), %rdi      # 0x1d86b
jmp 0x191f8
testl %ebp, %ebp
je 0x19206
testl %eax, %eax
jne 0x19206
leaq 0x4696(%rip), %rdi      # 0x1d88e
callq 0x1717e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl $0x1, %eax
cmpl $0x9, %ecx
jne 0x191ff
cmpl $0x9, 0xc(%rbx)
jne 0x191ff
movl $0x20, 0xc(%rbx)
jmp 0x191ff
// File: /workspace/github_cpp_makefile_star2_O1/tdv[P]boss/boss/include/plugin/loader.h
// Function: Boss::Loader::~Loader()
~Loader()
    {
      Locator->DelService(Service::Locator::Id::ClassFactoryService);
      ClsFactory.second.Release();
      SrvRegistry.second.Release();
      Private::SetServiceLocator(0);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
movq (%rdi), %rax
movl $0x16d1a76d, %esi       # imm = 0x16D1A76D
callq *0x38(%rax)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x189fc
movq (%rdi), %rax
callq *0x18(%rax)
movq $0x0, 0x20(%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x18a13
movq (%rdi), %rax
callq *0x18(%rax)
xorl %r14d, %r14d
movq %r14, 0x10(%rbx)
callq 0x18166
movq 0xe3aea(%rip), %rdi     # 0xfc510
movq %r14, 0xe3ae3(%rip)     # 0xfc510
testq %rdi, %rdi
je 0x18a38
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x18a47
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x18(%rbx), %rdi
movq $0x0, 0x20(%rbx)
callq 0x19e2c
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x18a67
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x8(%rbx), %rdi
movq $0x0, 0x10(%rbx)
callq 0x19e2c
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x18a86
movq (%rdi), %rax
callq *0x18(%rax)
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x18aa1
jmp 0x18aa1
jmp 0x18aa1
jmp 0x18aa1
jmp 0x18aa1
jmp 0x18aa1
movq %rax, %rdi
callq 0x18aa9
// File: /workspace/github_cpp_makefile_star2_O1/tdv[P]boss/boss/include/plugin/../core/base.h
// Function: Boss::RefObjPtr<Boss::ServiceLocator> Boss::Base<Boss::ServiceLocator>::Create<>()
static RefObjPtr<T> Create(Args const & ... args)
    {
      Private::ModuleCounter::ScopedLock Lock;
      RefObjPtr<T> NewInst(new Base<T>(args ...));
      Private::FinalizeConstruct<T>::Construct(NewInst.Get());
      return std::move(NewInst);
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
lock
incl 0xe3a29(%rip)           # 0xfc50c
movl $0x88, %edi
callq 0x1cc20
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x40(%rax)
movups %xmm0, 0x60(%rax)
xorl %ecx, %ecx
movq %rcx, 0x70(%rax)
movups %xmm0, 0x50(%rax)
movq %rax, %rdx
addq $0x70, %rdx
movb $0x0, 0x10(%rax)
leaq 0xdcc6d(%rip), %rsi     # 0xf5790
movq %rsi, (%rax)
leaq 0xdccbb(%rip), %rsi     # 0xf57e8
movq %rsi, 0x8(%rax)
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x18(%rax)
movq %rcx, 0x38(%rax)
movl $0x1, 0x28(%rax)
movq %rdx, 0x40(%rax)
movq $0x1, 0x48(%rax)
movl $0x3f800000, 0x60(%rax) # imm = 0x3F800000
movups %xmm0, 0x68(%rax)
leaq 0xdcdde(%rip), %rcx     # 0xf5940
movq %rcx, 0x78(%rax)
leaq 0xdca3b(%rip), %rcx     # 0xf55a8
movq %rcx, (%rax)
leaq 0xdca89(%rip), %rcx     # 0xf5600
movq %rcx, 0x8(%rax)
leaq 0xdcace(%rip), %rcx     # 0xf5650
movq %rcx, 0x78(%rax)
movl $0x0, 0x80(%rax)
lock
incl 0xe3975(%rip)           # 0xfc50c
lock
incl 0x80(%rax)
movb $0x1, 0x10(%rax)
movq %rax, (%rbx)
lock
decl 0xe3960(%rip)           # 0xfc50c
movq %rbx, %rax
popq %rbx
retq
lock
decl 0xe3954(%rip)           # 0xfc50c
movq %rax, %rdi
callq 0xbc2b0
// File: /workspace/github_cpp_makefile_star2_O1/tdv[P]boss/boss/include/plugin/../core/base.h
// Function: Boss::Base<Boss::RawBuffer>::Release()
virtual UInt BOSS_CALL Release()
    {
      UInt CurValue = Counter.fetch_sub(1, std::memory_order_relaxed);
      if (CurValue == 1)
      {
        Private::BeforeRelease<T>::Release(static_cast<T *>(this));
        std::atomic_thread_fence(std::memory_order_acquire);
        delete this;
      }
      return CurValue - 1;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
lock
xaddl %ebx, 0x38(%rdi)
cmpl $0x1, %ebx
jne 0x1ac28
movq %rdi, %r14
movb $0x0, 0x10(%rdi)
lock
decl 0xe190f(%rip)           # 0xfc50c
leaq 0xdb314(%rip), %rax     # 0xf5f18
movq %rax, (%rdi)
leaq 0xdb35a(%rip), %rax     # 0xf5f68
movq %rax, 0x8(%rdi)
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x1ac20
callq 0x1b660
movq %r14, %rdi
callq 0x1b660
decl %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/tdv[P]boss/boss/include/plugin/../core/base.h
// Function: Boss::Base<Boss::ServiceLocator>::QueryInterface(unsigned int, void**)
virtual RetCode BOSS_CALL QueryInterface(InterfaceId ifaceId, Ptr *iface)
    {
      RetCode Ret = Private::QueryInterface<T>::Query(static_cast<T *>(this), ifaceId, iface);
      if (Ret == Status::Ok)
        AddRef();
      return Ret;
    }

// Assembly:
xorl %eax, %eax
cmpl $0x2cc77d66, %esi       # imm = 0x2CC77D66
je 0x191fc
cmpl $0x29d4d8a5, %esi       # imm = 0x29D4D8A5
jne 0x19207
leaq 0x8(%rdi), %rcx
movq %rcx, (%rdx)
movb $0x1, %cl
jmp 0x1920e
movl $0x3, %eax
xorl %ecx, %ecx
testb %cl, %cl
je 0x19219
lock
incl 0x80(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/tdv[P]boss/boss/include/common/service_locator.h
// Function: Boss::ServiceLocator::GetService(unsigned int, Boss::IBase**) const
virtual RetCode BOSS_CALL GetService(UInt serviceId, IBase **service) const
    {
      if (!service || *service)
        return Status::InvalidArgument;
      std::lock_guard<std::recursive_mutex> Lock(Mtx);
      ServicePool::iterator Iter = Services.find(serviceId);
      if (Iter == Services.end())
        return Status::Fail;
      return Iter->second.QueryInterface(service);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl $0x5, %r15d
testq %rdx, %rdx
je 0x192ea
movq %rdx, %r14
cmpq $0x0, (%rdx)
jne 0x192ea
movl %esi, %ebp
movq %rdi, %r12
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x15610
testl %eax, %eax
jne 0x192f6
movl %ebp, %eax
movq 0x40(%r12), %rsi
movq 0x48(%r12), %rdi
xorl %r9d, %r9d
xorl %edx, %edx
divq %rdi
movq (%rsi,%rdx,8), %rax
testq %rax, %rax
je 0x192b1
movq (%rax), %r8
movq %rax, %r9
cmpl %ebp, 0x8(%r8)
je 0x192b1
movq %rdx, %rcx
movq %r8, %r10
movq (%r8), %r8
testq %r8, %r8
je 0x192ae
movl 0x8(%r8), %esi
movq %rsi, %rax
xorl %edx, %edx
divq %rdi
movl $0x0, %r9d
cmpq %rcx, %rdx
jne 0x192b1
movq %r10, %r9
cmpl %ebp, %esi
jne 0x19283
jmp 0x192b1
xorl %r9d, %r9d
testq %r9, %r9
je 0x192bb
movq (%r9), %rax
jmp 0x192bd
xorl %eax, %eax
movl $0x2, %r15d
testq %rax, %rax
je 0x192e2
movq 0x10(%rax), %rdi
testq %rdi, %rdi
je 0x192e2
movq (%rdi), %rax
movl $0x2cc77d66, %esi       # imm = 0x2CC77D66
movq %r14, %rdx
callq *0x20(%rax)
movl %eax, %r15d
movq %rbx, %rdi
callq 0x15670
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x1726f
movq %rax, %r14
movq %rbx, %rdi
callq 0x15670
movq %r14, %rdi
callq 0xbc2b0
// File: /workspace/github_cpp_makefile_star2_O1/tdv[P]boss/boss/include/common/service_locator.h
// Function: Boss::ServiceLocator::AddService(unsigned int, Boss::IBase*)
virtual RetCode BOSS_CALL AddService(UInt serviceId, IBase *service)
    {
      if (!service)
        return Status::InvalidArgument;
      std::lock_guard<std::recursive_mutex> Lock(Mtx);
      if (Services.find(serviceId) != Services.end())
        return Status::Fail;
      Services[serviceId] = service;
      return Status::Ok;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, 0x4(%rsp)
testq %rdx, %rdx
je 0x19394
movq %rdx, %r14
movq %rdi, %r15
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x15610
testl %eax, %eax
jne 0x193e1
movl 0x4(%rsp), %ecx
movq 0x40(%r15), %rdi
movq 0x48(%r15), %r8
xorl %r10d, %r10d
movq %rcx, %rax
xorl %edx, %edx
divq %r8
movq (%rdi,%rdx,8), %rax
testq %rax, %rax
je 0x1939e
movq (%rax), %r9
movq %rax, %r10
cmpl 0x8(%r9), %ecx
je 0x1939e
movq %rdx, %rsi
movq %r9, %r11
movq (%r9), %r9
testq %r9, %r9
je 0x1939b
movl 0x8(%r9), %edi
movq %rdi, %rax
xorl %edx, %edx
divq %r8
movl $0x0, %r10d
cmpq %rsi, %rdx
jne 0x1939e
movq %r11, %r10
cmpl %edi, %ecx
jne 0x19369
jmp 0x1939e
movl $0x5, %ebp
jmp 0x193d4
xorl %r10d, %r10d
testq %r10, %r10
je 0x193ae
movl $0x2, %ebp
cmpq $0x0, (%r10)
jne 0x193cc
addq $0x40, %r15
leaq 0x4(%rsp), %rsi
movq %r15, %rdi
callq 0x19774
xorl %ebp, %ebp
movq %rax, %rdi
movq %r14, %rsi
callq 0x19738
movq %rbx, %rdi
callq 0x15670
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x1726f
movq %rax, %r14
movq %rbx, %rdi
callq 0x15670
movq %r14, %rdi
callq 0xbc2b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/tdv[P]boss/boss/include/common/service_locator.h
// Function: Boss::ServiceLocator::DelService(unsigned int)
virtual RetCode BOSS_CALL DelService(UInt serviceId)
    {
      std::lock_guard<std::recursive_mutex> Lock(Mtx);
      ServicePool::iterator Iter = Services.find(serviceId);
      if (Iter == Services.end())
        return Status::Fail;
      Services.erase(Iter);
      return Status::Ok;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x15610
testl %eax, %eax
jne 0x194a6
movl %ebp, %eax
movq 0x40(%r14), %rsi
movq 0x48(%r14), %rdi
xorl %r9d, %r9d
xorl %edx, %edx
divq %rdi
movq (%rsi,%rdx,8), %rax
testq %rax, %rax
je 0x19471
movq (%rax), %r8
movq %rax, %r9
cmpl %ebp, 0x8(%r8)
je 0x19471
movq %rdx, %rcx
movq %r8, %r10
movq (%r8), %r8
testq %r8, %r8
je 0x1946e
movl 0x8(%r8), %esi
movq %rsi, %rax
xorl %edx, %edx
divq %rdi
movl $0x0, %r9d
cmpq %rcx, %rdx
jne 0x19471
movq %r10, %r9
cmpl %ebp, %esi
jne 0x19443
jmp 0x19471
xorl %r9d, %r9d
testq %r9, %r9
je 0x1947b
movq (%r9), %rsi
jmp 0x1947d
xorl %esi, %esi
testq %rsi, %rsi
je 0x19492
addq $0x40, %r14
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x19a36
jmp 0x19497
movl $0x2, %ebp
movq %rbx, %rdi
callq 0x15670
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movl %eax, %edi
callq 0x1726f
movq %rax, %r14
movq %rbx, %rdi
callq 0x15670
movq %r14, %rdi
callq 0xbc2b0
// File: /workspace/github_cpp_makefile_star2_O1/tdv[P]boss/boss/include/plugin/module_holder.h
// Function: Boss::RefObjQIPtr<Boss::IServiceRegistry> Boss::ModuleHolder::CreateObject<Boss::IServiceRegistry>(unsigned int)
RefObjQIPtr<T> CreateObject(ClassId classId)
    {
      RefObjQIPtr<T> Ret(CreateObject(classId));
      if (!Ret.Get())
        throw ModuleHolderException("Interface not found.");
      return std::move(Ret);
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x19e6a
movq $0x0, 0x8(%rsp)
movq (%r14), %rdi
testq %rdi, %rdi
je 0x19c50
movq (%rdi), %rax
leaq 0x8(%rsp), %rdx
movl $0xb64aa402, %esi       # imm = 0xB64AA402
callq *0x20(%rax)
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x19c60
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x19c78
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x1b950
movq %rax, %r14
leaq 0xa54dc(%rip), %rsi     # 0xbf168
movq %rax, %rdi
callq 0x2ef10
leaq 0xdbd35(%rip), %rax     # 0xf59d0
movq %rax, (%r14)
leaq 0xdbd03(%rip), %rsi     # 0xf59a8
leaq 0xb8e4(%rip), %rdx      # 0x25590
movq %r14, %rdi
callq 0x1c9a0
movq %rax, %rbx
jmp 0x19cc4
movq %rax, %rbx
movq %r14, %rdi
callq 0x1b9b0
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x19cd4
movq (%rdi), %rax
callq *0x18(%rax)
movq $0x0, 0x8(%rsp)
jmp 0x19cf4
jmp 0x19cfc
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x19cf4
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rdi
callq 0xbc2b0
movq %rax, %rdi
callq 0x18aa9
// File: /workspace/github_cpp_makefile_star2_O1/tdv[P]boss/boss/include/plugin/nix/dll_holder.h
// Function: Boss::Private::DllHolder::UnloadDll()
void UnloadDll()
      {
        if (DllInst)
        {
          int Res = dlclose(DllInst);
          assert(!Res && "Failed to unload dll.");
          Unused(Res);
        }
        DllInst = 0;
      }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x19e41
callq 0x156e0
testl %eax, %eax
jne 0x19e4a
movq $0x0, (%rbx)
popq %rbx
retq
leaq 0xa52a7(%rip), %rdi     # 0xbf0f8
leaq 0xa52c0(%rip), %rsi     # 0xbf118
leaq 0xa52de(%rip), %rcx     # 0xbf13d
movl $0x4f, %edx
callq 0x15150
nop
// File: /workspace/github_cpp_makefile_star2_O1/tdv[P]boss/boss/include/plugin/module_holder.h
// Function: Boss::ModuleHolder::CreateObject(unsigned int)
IBasePtr CreateObject(ClassId classId)
    {
      typedef RetCode (*PFNBossCreateObject)(ClassId, IBase **);
      IBasePtr Ret;
      auto *BossCreateObject = Dll.GetProc<PFNBossCreateObject>("BossCreateObject");
      if (BossCreateObject(classId, Ret.GetPPtr()) != Status::Ok)
        throw ModuleHolderException("Failed to create object.");
      return std::move(Ret);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq $0x0, (%rsp)
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa52e9(%rip), %rsi     # 0xbf17d
leaq 0xa52f2(%rip), %rdx     # 0xbf18d
leaq 0x8(%rsp), %rdi
callq 0x1b338
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x19f66
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x19ec4
callq 0x1b660
movq %rsp, %rsi
movl %ebp, %edi
callq *%r14
testl %eax, %eax
jne 0x19ee5
movq (%rsp), %rax
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x1b950
movq %rax, %r14
leaq 0xa5295(%rip), %rsi     # 0xbf18e
movq %rax, %rdi
callq 0x2ef10
leaq 0xdbac8(%rip), %rax     # 0xf59d0
movq %rax, (%r14)
leaq 0xdba96(%rip), %rsi     # 0xf59a8
leaq 0xb677(%rip), %rdx      # 0x25590
movq %r14, %rdi
callq 0x1c9a0
movq %rax, %rbx
movq %r14, %rdi
callq 0x1b9b0
jmp 0x19f47
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x19f47
callq 0x1b660
jmp 0x19f47
jmp 0x19f44
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x19f56
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rdi
callq 0xbc2b0
movq %rax, %rdi
callq 0x18aa9
// File: /workspace/github_cpp_makefile_star2_O1/tdv[P]boss/boss/include/plugin/nix/dll_holder.h
// Function: unsigned int (*Boss::Private::DllHolder::GetProc<unsigned int (*)(unsigned int, Boss::IBase**)>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&))(unsigned int, Boss::IBase**)
T GetProc(const std::string &procName)
      {
        if (DllInst == nullptr)
          throw DllHolderException("Library was not loaded.");
        void *Proc = dlsym(DllInst, procName.c_str());
        if (!Proc)
          throw DllHolderException("Function \"" + procName + "\" not found.");
        return reinterpret_cast<T>(Proc);
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x19f93
movq %rsi, %r14
movq (%rsi), %rsi
callq 0x155e0
testq %rax, %rax
je 0x19fc5
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x1b950
movq %rax, %rbx
leaq 0xa5200(%rip), %rsi     # 0xbf1a7
movq %rax, %rdi
callq 0x1a0be
leaq 0xdb9b2(%rip), %rsi     # 0xf5968
leaq 0xb5d3(%rip), %rdx      # 0x25590
movq %rbx, %rdi
callq 0x1c9a0
movl $0x10, %edi
callq 0x1b950
movq %rax, %rbx
leaq 0xa51e6(%rip), %rsi     # 0xbf1bf
leaq 0x28(%rsp), %rdi
movq %r14, %rdx
callq 0x19d99
leaq 0xa51dd(%rip), %rsi     # 0xbf1ca
leaq 0x28(%rsp), %rdi
callq 0x8fd70
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x1a018
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x1a025
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x4cb80
leaq 0xdb93d(%rip), %rax     # 0xf5990
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xdb909(%rip), %rsi     # 0xf5968
leaq 0xb52a(%rip), %rdx      # 0x25590
movq %rbx, %rdi
callq 0x1c9a0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1a088
callq 0x1b660
jmp 0x1a088
movq %rax, %r14
movb $0x1, %bpl
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1a0a3
callq 0x1b660
jmp 0x1a0a3
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
jne 0x1a0ad
jmp 0x1a0b5
movq %rax, %r14
movq %rbx, %rdi
callq 0x1b9b0
movq %r14, %rdi
callq 0xbc2b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/tdv[P]boss/boss/include/common/file_stream.h
// Function: Boss::Private::IOFileStream<Boss::IIStream>::Read(unsigned int, Boss::IBuffer**)
virtual RetCode BOSS_CALL Read(UInt bytes, IBuffer **buffer)
      {
        if (!buffer || *buffer)
          return Status::InvalidArgument;
        assert(!!File && "File not open.");
        if (!File)
          return Status::Fail;
        try
        {
          if (!bytes)
            return Base<RawBuffer>::Create(nullptr, 0).QueryInterface(buffer);
          std::vector<char> Buffer(bytes);
          std::size_t Res = std::fread(&Buffer[0], 1, Buffer.size(), File);
          if (!Res || Res > Buffer.size())
            return Status::Fail;
          return Base<RawBuffer>::Create(&Buffer[0], Res).QueryInterface(buffer);
        }
        catch (...)
        {
        }
        return Status::Fail;
      }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl $0x5, %ebp
testq %rdx, %rdx
je 0x1a30b
movq %rdx, %rbx
cmpq $0x0, (%rdx)
je 0x1a316
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rdi, %r14
cmpq $0x0, 0x8(%rdi)
je 0x1a436
testl %esi, %esi
je 0x1a3b1
movl %esi, %esi
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x1a9be
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
subq %rdi, %rdx
movq 0x8(%r14), %rcx
movl $0x1, %esi
callq 0x15470
movq %rax, 0x20(%rsp)
movl $0x2, %ebp
testq %rax, %rax
je 0x1a41e
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rdx
subq %rcx, %rdx
cmpq %rdx, %rax
ja 0x1a41e
leaq 0x28(%rsp), %rsi
movq %rcx, (%rsi)
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0x1aa1e
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1a40a
movq (%rdi), %rax
movl $0xaaa58dc, %esi        # imm = 0xAAA58DC
movq %rbx, %rdx
callq *0x28(%rax)
movl %eax, %ebp
jmp 0x1a40f
leaq 0x20(%rsp), %rsi
movq $0x0, (%rsi)
movq %rsp, %rdx
movl $0x0, (%rdx)
leaq 0x8(%rsp), %rdi
callq 0x1a926
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1a3ec
movq (%rdi), %rax
movl $0xaaa58dc, %esi        # imm = 0xAAA58DC
movq %rbx, %rdx
callq *0x28(%rax)
movl %eax, %ebp
jmp 0x1a3f1
movl $0x2, %ebp
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1a30b
movq (%rdi), %rax
callq *0x20(%rax)
jmp 0x1a30b
movl $0x2, %ebp
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1a41e
movq (%rdi), %rax
callq *0x20(%rax)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1a30b
callq 0x1b660
jmp 0x1a30b
leaq 0xa4e6c(%rip), %rdi     # 0xbf2a9
leaq 0xa4db4(%rip), %rsi     # 0xbf1f8
leaq 0xa4e79(%rip), %rcx     # 0xbf2c4
movl $0x3e, %edx
callq 0x15150
jmp 0x1a489
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1a469
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, (%rsp)
jmp 0x1a478
jmp 0x1a489
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1a4b6
callq 0x1b660
jmp 0x1a4b6
movq %rax, %rdi
callq 0x18aa9
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1a4a4
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, 0x8(%rsp)
jmp 0x1a4b6
jmp 0x1a489
jmp 0x1a4b3
movq %rax, %rbx
movq %rbx, %rdi
callq 0x1bab0
callq 0x1bb20
movl $0x2, %ebp
jmp 0x1a30b
nop
// File: /workspace/github_cpp_makefile_star2_O1/tdv[P]boss/boss/include/common/file_stream.h
// Function: Boss::Private::IOFileStream<Boss::IIStream>::Read(Boss::IBuffer**)
virtual RetCode BOSS_CALL Read(IBuffer **buffer)
      {
        if (!buffer || *buffer)
          return Status::InvalidArgument;
        assert(!!File && "File not open.");
        if (!File)
          return Status::Fail;
        try
        {
          std::vector<char> Buffer;
          for (std::vector<char> Tmp(ReadBufSize) ; !std::feof(File) ; )
          {
            std::size_t Res = std::fread(&Tmp[0], 1, Tmp.size(), File);
            if (!Res || Res > Tmp.size())
              return Status::Fail;
            std::copy(std::begin(Tmp), std::end(Tmp), std::back_inserter(Buffer));
          }
          return Base<RawBuffer>::Create(Buffer.empty() ? nullptr : &Buffer[0], Buffer.size()).QueryInterface(buffer);
        }
        catch (...)
        {
        }
        return Status::Fail;
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl $0x5, %ebp
testq %rsi, %rsi
je 0x1a606
movq %rsi, %rbx
cmpq $0x0, (%rsi)
jne 0x1a606
movq %rdi, %r14
cmpq $0x0, 0x8(%rdi)
je 0x1a617
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movl $0x2000, %edi           # imm = 0x2000
callq 0x1cc20
movq %rax, %r15
movq %rax, %r12
addq $0x2000, %r12           # imm = 0x2000
movl $0x2000, %edx           # imm = 0x2000
movq %rax, %rdi
xorl %esi, %esi
callq 0x150d0
leaq 0x10(%rsp), %r13
movq 0x8(%r14), %rdi
callq 0x15530
testl %eax, %eax
jne 0x1a582
movq 0x8(%r14), %rcx
movl $0x1, %esi
movl $0x2000, %edx           # imm = 0x2000
movq %r15, %rdi
callq 0x15470
addq $-0x2001, %rax          # imm = 0xDFFF
cmpq $-0x2000, %rax          # imm = 0xE000
jb 0x1a5d3
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x1aef2
jmp 0x1a541
movq %r15, %rdi
callq 0x1b660
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
xorl %edx, %edx
subq %rax, %rcx
cmovneq %rax, %rdx
leaq 0x30(%rsp), %rsi
movq %rdx, (%rsi)
leaq 0x28(%rsp), %rdx
movq %rcx, (%rdx)
leaq 0x8(%rsp), %rdi
callq 0x1aa1e
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1a5e2
movq (%rdi), %rax
movl $0xaaa58dc, %esi        # imm = 0xAAA58DC
movq %rbx, %rdx
callq *0x28(%rax)
movl %eax, %ebp
jmp 0x1a5e7
movq %r15, %rdi
callq 0x1b660
movl $0x2, %ebp
jmp 0x1a5f7
movl $0x2, %ebp
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1a5f7
movq (%rdi), %rax
callq *0x20(%rax)
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1a606
callq 0x1b660
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa4c8b(%rip), %rdi     # 0xbf2a9
leaq 0xa4bd3(%rip), %rsi     # 0xbf1f8
leaq 0xa4d32(%rip), %rcx     # 0xbf35e
movl $0x54, %edx
callq 0x15150
movq %rax, %rdi
callq 0x18aa9
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1a651
movq (%rdi), %rax
callq *0x20(%rax)
movq $0x0, 0x8(%rsp)
jmp 0x1a670
jmp 0x1a636
jmp 0x1a660
movq %rax, %rbx
jmp 0x1a670
movq %rax, %rbx
movq %r15, %rdi
callq 0x1b660
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1a67f
callq 0x1b660
movq %rbx, %rdi
callq 0x1bab0
callq 0x1bb20
movl $0x2, %ebp
jmp 0x1a606
// File: /workspace/github_cpp_makefile_star2_O1/tdv[P]boss/boss/include/common/file_stream.h
// Function: Boss::Private::IOFileStream<Boss::IIStream>::Write(void const*, unsigned int)
virtual RetCode BOSS_CALL Write(void const *data, UInt bytes)
      {
        if (!data || !bytes)
          return Status::False;
        assert(!!File && "File not open.");
        if (!File)
          return Status::Fail;
        return std::fwrite(data, 1, bytes, File) == bytes ? Status::Ok : Status::Fail;;
      }

// Assembly:
pushq %rbx
movq %rsi, %r8
testq %rsi, %rsi
sete %cl
testl %edx, %edx
sete %sil
movl $0x1, %eax
orb %cl, %sil
jne 0x1a6d8
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x1a6da
movl %edx, %ebx
movl $0x1, %esi
movq %r8, %rdi
movq %rbx, %rdx
callq 0x15600
movq %rax, %rcx
xorl %eax, %eax
cmpq %rbx, %rcx
setne %al
addl %eax, %eax
popq %rbx
retq
leaq 0xa4bc8(%rip), %rdi     # 0xbf2a9
leaq 0xa4b10(%rip), %rsi     # 0xbf1f8
leaq 0xa4cec(%rip), %rcx     # 0xbf3db
movl $0x6d, %edx
callq 0x15150
nop
// File: /workspace/github_cpp_makefile_star2_O1/tdv[P]boss/boss/include/common/buffer.h
// Function: Boss::RawBuffer::RawBuffer(void const*, unsigned int)
RawBuffer(void const *data, UInt bytes)
      : Buffer([&] ()
               {
                 return !bytes ? std::move(std::vector<char>()) :
                   std::move(std::vector<char>(reinterpret_cast<char const *>(data),
                                               reinterpret_cast<char const *>(data) + bytes)); 
               } ()
              )
    {
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %edx, %ebx
movq %rdi, %r14
movb $0x0, 0x10(%rdi)
leaq 0xdb43b(%rip), %rax     # 0xf5f18
movq %rax, (%rdi)
leaq 0xdb481(%rip), %rax     # 0xf5f68
movq %rax, 0x8(%rdi)
testl %edx, %edx
je 0x1ab08
movl %ebx, %edx
addq %rsi, %rdx
leaq 0x28(%rsp), %r15
leaq 0xf(%rsp), %rcx
movq %r15, %rdi
callq 0x1ae20
jmp 0x1ab1c
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r15
movaps %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movq (%r15), %rax
movq %rax, 0x18(%r14)
movq 0x8(%r15), %rax
movq %rax, 0x20(%r14)
movq 0x10(%r15), %rax
movq %rax, 0x28(%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq $0x0, 0x10(%r15)
testl %ebx, %ebx
je 0x1ab4d
movq 0x28(%rsp), %rdi
jmp 0x1ab52
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1ab5c
callq 0x1b660
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/tdv[P]boss/boss/include/common/buffer.h
// Function: Boss::RawBuffer::GetData(void const**) const
virtual RetCode BOSS_CALL GetData(void const **data) const
    {
      if (!data || *data)
        return  Status::InvalidArgument;
      *data = Buffer.empty() ? 0 : &Buffer[0];
      return Status::Ok;
    }

// Assembly:
movl $0x5, %eax
testq %rsi, %rsi
je 0x1ac72
cmpq $0x0, (%rsi)
je 0x1ac73
retq
movq 0x18(%rdi), %rcx
xorl %eax, %eax
cmpq 0x20(%rdi), %rcx
movl $0x0, %edx
cmovneq %rcx, %rdx
movq %rdx, (%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/tdv[P]boss/boss/include/plugin/module_holder.h
// Function: Boss::ModuleHolder::SetServiceLocator(Boss::IServiceLocator*)
void SetServiceLocator(IServiceLocator *locator)
    {
      typedef RetCode (*PFNBossSetServiceLocator)(IServiceLocator *);
      auto *BossSetServiceLocator = Dll.GetProc<PFNBossSetServiceLocator>("BossSetServiceLocator");
      RefObjPtr<IServiceLocator> Inst;
      if (BossSetServiceLocator(locator) != Status::Ok)
        throw ModuleHolderException("Failed to set ServiceLocator.");
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa437c(%rip), %rsi     # 0xbf4b5
leaq 0xa438a(%rip), %rdx     # 0xbf4ca
movq %rsp, %rdi
callq 0x1b338
movq %rsp, %rsi
movq %r14, %rdi
callq 0x1b1e0
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1b164
callq 0x1b660
movq %rbx, %rdi
callq *%r14
testl %eax, %eax
jne 0x1b178
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x1b950
movq %rax, %r14
leaq 0xa433f(%rip), %rsi     # 0xbf4cb
movq %rax, %rdi
callq 0x2ef10
leaq 0xda835(%rip), %rax     # 0xf59d0
movq %rax, (%r14)
leaq 0xda803(%rip), %rsi     # 0xf59a8
leaq 0xa3e4(%rip), %rdx      # 0x25590
movq %r14, %rdi
callq 0x1c9a0
movq %rax, %rbx
movq %r14, %rdi
callq 0x1b9b0
jmp 0x1b1d7
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1b1d7
callq 0x1b660
jmp 0x1b1d7
movq %rax, %rbx
movq %rbx, %rdi
callq 0xbc2b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/reddragon[P]packed-memory-array/impl1.cpp
// Function: main
int main() {
    
    PackedMemoryArray<int> pma(2);
    
    Timer t;
    t.start();
    for(int i = 3; i < 10000000; i++) {
        pma.insert_element(i);
    }
    double time_taken = t.stop();
    std::cout << "Head Inserts: " << time_taken/10000000.0 << std::endl;
    //pma.print();

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
movl $0x2, %esi
callq 0x1426
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x1130
movl $0x3, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1da4
movslq %eax, %rcx
movq 0x28(%rsp), %rdx
movl (%rdx,%rcx,4), %edx
movq %rbx, %rdi
movl %ebp, %esi
movl %eax, %ecx
callq 0x1e2c
incl %ebp
cmpl $0x989680, %ebp         # imm = 0x989680
jne 0x131e
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1130
movq 0x8(%rsp), %r15
movq 0x10(%rsp), %r14
movq (%rbx), %r12
movq 0x8(%rbx), %rbx
movq 0x3c68(%rip), %rdi      # 0x4fd8
leaq 0x1cc9(%rip), %rsi      # 0x3040
movl $0xe, %edx
callq 0x1100
cvtsi2sd %r12, %xmm0
cvtsi2sd %rbx, %xmm1
movsd 0x1c75(%rip), %xmm2     # 0x3008
mulsd %xmm2, %xmm0
cvtsi2sd %r15, %xmm3
addsd %xmm1, %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %r14, %xmm1
mulsd %xmm2, %xmm3
addsd %xmm1, %xmm3
subsd %xmm3, %xmm0
divsd 0x1c54(%rip), %xmm0     # 0x3010
movq 0x3c15(%rip), %rdi      # 0x4fd8
callq 0x1120
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x10a0
leaq 0x28(%rsp), %rdi
callq 0x1564
xorl %eax, %eax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1410
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x1564
movq %rbx, %rdi
callq 0x1160
nop
// File: /workspace/github_cpp_makefile_star2_O1/reddragon[P]packed-memory-array/impl1.cpp
// Function: PackedMemoryArray<int>::PackedMemoryArray(int)
PackedMemoryArray<E>::PackedMemoryArray(E e) : t_0(VAL_T_0), t_l(VAL_T_L), c(VAL_C) {
    // Assert that c is a power of 2 and > 1
#ifndef OPTIMIZE
    assert(c > 1 && !(c & (c-1)));
#endif
    s = 0;
    // Get the new store
    store.resize(c*1);
    // Resize the bitmask as well
    exists.resize((size_t)ceil(c));
    insert_element_at(e, 0);
    
    // One liner log2 since c is a power of 2 :-P
    int log2n = __builtin_popcount(store.size()-1);
    if(log2n & (log2n-1)) {
        // log2n is not a power of 2, round it up to the nearest power of 2.
        segment_size = (int)floor(log2(1<<(log2n+1)));
    }
    else {
        // log2n is a power of 2, so, all is fine.
        segment_size = log2n;
    }
    l = log2n - log2(segment_size);

    // Now assert that the upper thresholds are sane, and you do not go out of balance the very first time.
#ifndef OPTIMIZE
    assert(!is_too_full());
#endif
    // And we have set this thing in motion. Pray!
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
xorl %eax, %eax
movq %rax, 0x28(%rdi)
movl %eax, 0x30(%rdi)
movq %rax, 0x38(%rdi)
xorpd %xmm0, %xmm0
movupd %xmm0, (%rdi)
movupd %xmm0, 0x10(%rdi)
movl %eax, 0x20(%rdi)
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, 0x40(%rdi)
movabsq $0x3fe0000000000000, %rcx # imm = 0x3FE0000000000000
movq %rcx, 0x48(%rdi)
movl $0x2, 0x50(%rdi)
movl %eax, 0x58(%rdi)
movl $0x2, %esi
callq 0x1590
movl 0x50(%rbx), %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0x15c2
movq (%rbx), %rax
movl %ebp, (%rax)
movq 0x18(%rbx), %rcx
orq $0x1, (%rcx)
incl 0x58(%rbx)
movq 0x8(%rbx), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
decl %ecx
movl %ecx, %eax
shrl %eax
andl $0x55555555, %eax       # imm = 0x55555555
subl %eax, %ecx
movl $0x33333333, %eax       # imm = 0x33333333
movl %ecx, %edx
andl %eax, %edx
shrl $0x2, %ecx
andl %eax, %ecx
addl %edx, %ecx
movl %ecx, %eax
shrl $0x4, %eax
addl %ecx, %eax
andl $0xf0f0f0f, %eax        # imm = 0xF0F0F0F
imull $0x1010101, %eax, %r14d # imm = 0x1010101
shrl $0x18, %r14d
leal -0x1(%r14), %ecx
movl %r14d, %eax
testl %ecx, %r14d
je 0x150a
movl $0x2, %eax
movl %r14d, %ecx
shll %cl, %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
callq 0x1170
callq 0x1150
cvttsd2si %xmm0, %eax
movl %eax, 0x5c(%rbx)
xorps %xmm0, %xmm0
cvtsi2sd %r14d, %xmm0
movsd %xmm0, (%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
callq 0x1170
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
cvttsd2si %xmm1, %eax
movl %eax, 0x54(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq %r14, %rdi
callq 0x1ba4
movq %rbx, %rdi
callq 0x1190
movq %r15, %rdi
callq 0x1160
movq %rax, %rdi
callq 0x162f
// File: /workspace/github_cpp_makefile_star2_O1/reddragon[P]packed-memory-array/impl1.cpp
// Function: PackedMemoryArray<int>::upper_bound(int)
int PackedMemoryArray<E>::upper_bound(E e) {
    int l = 0, r = ((int)store.size())/segment_size, pos; 
    while(l != r) {
        int m = l + (r - l + 1)/2;
        pos = upper_bound_in_segment(e, m);
        if (pos == -1) 
            r = m-1;
        else
            l = m; 
    }
    pos = upper_bound_in_segment(e, l);
    return pos;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
subq (%rdi), %rax
movl %esi, %ebp
shrq $0x2, %rax
cltd
idivl 0x5c(%rdi)
testl %eax, %eax
je 0x1e0d
movl %eax, %r15d
xorl %r14d, %r14d
movl %r15d, %eax
subl %r14d, %eax
movl %eax, %ecx
incl %ecx
shrl $0x1f, %ecx
leal (%rax,%rcx), %r13d
incl %r13d
sarl %r13d
leal (%r14,%r13), %r12d
movq %rbx, %rdi
movl %ebp, %esi
movl %r12d, %edx
callq 0x1ee8
cmpl $-0x1, %eax
je 0x1dff
movl %r12d, %r14d
jmp 0x1e06
leal (%r14,%r13), %r15d
decl %r15d
cmpl %r15d, %r14d
jne 0x1dcd
jmp 0x1e10
xorl %r14d, %r14d
movq %rbx, %rdi
movl %ebp, %esi
movl %r14d, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1ee8
nop
// File: /workspace/github_cpp_makefile_star2_O1/reddragon[P]packed-memory-array/impl1.cpp
// Function: PackedMemoryArray<int>::insert_element_after(int, int, int)
void PackedMemoryArray<E>::insert_element_after(E e, E after, int pos) {
    // Find where we can insert
    int loc;
    loc = pos;
#ifndef OPTIMIZE
    assert(loc != -1);
#endif
    int insert_at = ++loc;
    // Do we have space at the location we want to insert?
    if(insert_at < (int)store.size() && !ELEM_EXISTS_AT(insert_at)) {
        // Great! Now insert it there.
        insert_element_at(e, insert_at);
        return;
    }
    // The not so nice part begins here.
    int node_index, node_level;
    if(smallest_interval_in_balance(insert_at, &node_index, &node_level) == -1) {
        // No more space left in the PMA. Resize!
        expand_PMA(e);
    }
    else {
        // Rebalance one particular level
        rebalance(node_index, node_level, e);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
incl %ecx
movq (%rdi), %rax
movq 0x8(%rdi), %rdx
subq %rax, %rdx
shrq $0x2, %rdx
cmpl %edx, %ecx
jge 0x1e91
movslq %ecx, %rsi
leaq 0x3f(%rsi), %rdx
testq %rsi, %rsi
cmovnsq %rsi, %rdx
sarq $0x6, %rdx
shlq $0x3, %rdx
addq 0x18(%r14), %rdx
movabsq $-0x8000000000000000, %r8 # imm = 0x8000000000000000
leaq 0x3f(%r8), %r9
andq %rsi, %r9
xorl %edi, %edi
cmpq %r8, %r9
setbe %dil
movl $0x1, %r8d
shlq %cl, %r8
movq -0x8(%rdx,%rdi,8), %r9
btq %rcx, %r9
jae 0x1eca
leaq 0x4(%rsp), %rdx
movq %rsp, %rax
movq %r14, %rdi
movl %ecx, %esi
movq %rax, %rcx
callq 0x1f74
cmpl $-0x1, %eax
je 0x1ebe
movl 0x4(%rsp), %esi
movl (%rsp), %edx
movq %r14, %rdi
movl %ebx, %ecx
callq 0x2486
jmp 0x1ee0
movq %r14, %rdi
movl %ebx, %esi
callq 0x2158
jmp 0x1ee0
leaq -0x8(,%rdi,8), %rcx
movl %ebx, (%rax,%rsi,4)
orq %r8, %r9
movq %r9, (%rdx,%rcx)
incl 0x58(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/reddragon[P]packed-memory-array/impl1.cpp
// Function: PackedMemoryArray<int>::upper_bound_in_segment(int, int)
int PackedMemoryArray<E>::upper_bound_in_segment(E e, int v) {
    int best = -1;
    for(int i = v*segment_size; i < (v+1)*segment_size; i++)
        if(ELEM_EXISTS_AT(i) && store[i] <= e) 
            return best = i;
    return best;
}

// Assembly:
movl 0x5c(%rdi), %r8d
movl %r8d, %ecx
imull %edx, %ecx
incl %edx
imull %r8d, %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %edx, %ecx
jge 0x1f73
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
movq (%rdi), %r9
movq 0x18(%rdi), %rdi
movslq %ecx, %r10
negl %r8d
xorl %r11d, %r11d
leaq 0x3f(%rdx), %rbx
leaq 0x3f(%r10), %r14
testq %r10, %r10
cmovnsq %r10, %r14
sarq $0x6, %r14
leaq (%rdi,%r14,8), %r14
movq %r10, %r15
andq %rbx, %r15
xorl %r12d, %r12d
cmpq %rdx, %r15
setbe %r12b
movq -0x8(%r14,%r12,8), %r14
btq %r10, %r14
jae 0x1f5a
cmpl %esi, (%r9,%r10,4)
jle 0x1f67
incq %r10
decl %r11d
cmpl %r11d, %r8d
jne 0x1f26
jmp 0x1f6c
subl %r11d, %ecx
movl %ecx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/cauimsouza[P]rikudo-solver/src/rikudo_solver/main.cpp
// Function: solves_rikudo(std::basic_ifstream<char, std::char_traits<char>>&, std::basic_ofstream<char, std::char_traits<char>>&)
void solves_rikudo(std::ifstream &ifile, std::ofstream &ofile)
{
    Graph graph(ifile);

    int begin, end;
    ifile >> begin >> end;

    graph.unique_sol(begin, end, ofile);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0xc0(%rbp), %rdi
movq %r14, %rsi
callq 0x3876
leaq -0x18(%rbp), %rsi
movq %r14, %rdi
callq 0x2130
leaq -0x14(%rbp), %rsi
movq %rax, %rdi
callq 0x2130
movl -0x18(%rbp), %esi
movl -0x14(%rbp), %edx
leaq -0xc0(%rbp), %rdi
movq %rbx, %rcx
callq 0x67f0
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x2992
callq 0x21d0
leaq -0x48(%rbp), %rbx
movq %rbx, %rdi
callq 0x3136
movq -0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x29c0
callq 0x21d0
xorl %eax, %eax
movq %rax, -0x70(%rbp)
movl %eax, -0x68(%rbp)
movq %rax, -0x60(%rbp)
movl %eax, -0x58(%rbp)
movq %rax, -0x50(%rbp)
leaq -0x88(%rbp), %rbx
movq %rbx, %rdi
callq 0x3136
movq -0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x29dd
callq 0x21d0
movq -0xb8(%rbp), %rdi
testq %rdi, %rdi
je 0x29ee
callq 0x21d0
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0xc0(%rbp), %rdi
callq 0x3180
movq %rbx, %rdi
callq 0x2380