LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: rofl0r[P]ascc/tokenizer.c
// Function: apply_coords
static int apply_coords(struct tokenizer *t, struct token* out, char *end, int retval) {
	out->line = t->line;
	uintptr_t len = end - t->buf;
	out->column = t->column - len;
	if(len + 1 >= t->bufsize) {
		out->type = TT_OVERFLOW;
		return 0;
	}
	return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
addq $0x120, %rcx            # imm = 0x120
subq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
subq -0x30(%rbp), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq -0x10(%rbp), %rcx
cmpq 0x1120(%rcx), %rax
jb 0x2e823
movq -0x18(%rbp), %rax
movl $0xb, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x2e829
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: rofl0r[P]ascc/tokenizer.c
// Function: categorize
static enum tokentype categorize(const char *s) {
	if(is_hex_int_literal(s)) return TT_HEX_INT_LIT;
	if(is_dec_int_literal(s)) return TT_DEC_INT_LIT;
	if(is_oct_int_literal(s)) return TT_OCT_INT_LIT;
	if(is_float_literal(s)) return TT_FLOAT_LIT;
	if(is_identifier(s)) return TT_IDENTIFIER;
	return TT_UNKNOWN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2ec30
cmpl $0x0, %eax
je 0x2ea63
movl $0x5, -0x4(%rbp)
jmp 0x2eac6
movq -0x10(%rbp), %rdi
callq 0x2ed10
cmpl $0x0, %eax
je 0x2ea7a
movl $0x7, -0x4(%rbp)
jmp 0x2eac6
movq -0x10(%rbp), %rdi
callq 0x2ee30
cmpl $0x0, %eax
je 0x2ea91
movl $0x6, -0x4(%rbp)
jmp 0x2eac6
movq -0x10(%rbp), %rdi
callq 0x2eec0
cmpl $0x0, %eax
je 0x2eaa8
movl $0x8, -0x4(%rbp)
jmp 0x2eac6
movq -0x10(%rbp), %rdi
callq 0x2f070
cmpl $0x0, %eax
je 0x2eabf
movl $0x1, -0x4(%rbp)
jmp 0x2eac6
movl $0xa, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x1170(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x2eb10
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2d7c0
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x4440
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: rofl0r[P]ascc/tokenizer.c
// Function: is_hex_int_literal
static int is_hex_int_literal(const char *s) {
	if(s[0] == '-') s++;
	if(s[0] == '0' && (s[1] == 'x' || s[1] == 'X')) {
		const char* p = s+2;
		while(*p) {
			if(!strchr("0123456789abcdef", tolower(*p))) {
				if(p == s+2) return 0;
				return has_ul_tail(p);
			}
			p++;
		}
		return 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x2ec54
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jne 0x2ecf2
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x78, %eax
je 0x2ec7e
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x58, %eax
jne 0x2ecf2
movq -0x10(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x2ece9
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0x4560
movl %eax, %esi
leaq 0x59b8(%rip), %rdi      # 0x34660
callq 0x4180
cmpq $0x0, %rax
jne 0x2ecdb
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
addq $0x2, %rcx
cmpq %rcx, %rax
jne 0x2eccd
movl $0x0, -0x4(%rbp)
jmp 0x2ecf9
movq -0x18(%rbp), %rdi
callq 0x2f130
movl %eax, -0x4(%rbp)
jmp 0x2ecf9
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2ec8a
movl $0x1, -0x4(%rbp)
jmp 0x2ecf9
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rofl0r[P]ascc/tokenizer.c
// Function: is_dec_int_literal
static int is_dec_int_literal(const char *str) {
	const char *s = str;
	if(is_plus_or_minus(s[0])) s++;
	if(s[0] == '0') {
		if(s[1] == 0) return 1;
		if(isdigit(s[1])) return 0;
	}
	while(*s) {
		if(!isdigit(*s)) {
			if(s > str && (is_plus_or_minus(str[0]) ? s > str+1 : 1)) return has_ul_tail(s);
			else return 0;
		}
		s++;
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0x2e6d0
cmpl $0x0, %eax
je 0x2ed41
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jne 0x2ed95
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x2ed66
movl $0x1, -0x4(%rbp)
jmp 0x2ee25
callq 0x4400
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movsbl 0x1(%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x2ed93
movl $0x0, -0x4(%rbp)
jmp 0x2ee25
jmp 0x2ed95
jmp 0x2ed97
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x2ee1e
callq 0x4400
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0x2ee0d
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jbe 0x2ee04
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x2e6d0
cmpl $0x0, %eax
je 0x2edee
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
ja 0x2edf6
jmp 0x2ee04
movb $0x1, %al
testb $0x1, %al
jne 0x2edf6
jmp 0x2ee04
movq -0x18(%rbp), %rdi
callq 0x2f130
movl %eax, -0x4(%rbp)
jmp 0x2ee25
movl $0x0, -0x4(%rbp)
jmp 0x2ee25
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2ed97
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: rofl0r[P]ascc/tokenizer.c
// Function: is_oct_int_literal
static int is_oct_int_literal(const char *s) {
	if(s[0] == '-') s++;
	if(s[0] != '0') return 0;
	while(*s) {
		if(!strchr("01234567", *s)) return 0;
		s++;
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x2ee54
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
je 0x2ee69
movl $0x0, -0x4(%rbp)
jmp 0x2eeab
jmp 0x2ee6b
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x2eea4
movq -0x10(%rbp), %rax
movsbl (%rax), %esi
leaq 0x57f6(%rip), %rdi      # 0x34678
callq 0x4180
cmpq $0x0, %rax
jne 0x2ee96
movl $0x0, -0x4(%rbp)
jmp 0x2eeab
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2ee6b
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rofl0r[P]ascc/tokenizer.c
// Function: is_float_literal
static int is_float_literal(const char *str) {
	const char *s = str;
	if(is_plus_or_minus(s[0])) s++;
	int got_dot = 0, got_e = 0, got_digits = 0;
	while(*s) {
		int l = tolower(*s);
		if(*s == '.') {
			if(got_dot) return 0;
			got_dot = 1;
		} else if(l == 'f') {
			if(s[1] == 0 && (got_dot || got_e) && got_digits) return 1;
			return 0;
		} else if (isdigit(*s)) {
			got_digits = 1;
		} else if(l == 'e') {
			if(!got_digits) return 0;
			s++;
			if(is_plus_or_minus(*s)) s++;
			if(!isdigit(*s)) return 0;
			got_e = 1;
		} else return 0;
		s++;
	}
	if(got_digits && (got_e || got_dot)) return 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0x2e6d0
cmpl $0x0, %eax
je 0x2eef1
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x2f045
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0x4560
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x2ef4c
cmpl $0x0, -0x1c(%rbp)
je 0x2ef40
movl $0x0, -0x4(%rbp)
jmp 0x2f067
movl $0x1, -0x1c(%rbp)
jmp 0x2f034
cmpl $0x66, -0x28(%rbp)
jne 0x2ef89
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x2ef7d
cmpl $0x0, -0x1c(%rbp)
jne 0x2ef6b
cmpl $0x0, -0x20(%rbp)
je 0x2ef7d
cmpl $0x0, -0x24(%rbp)
je 0x2ef7d
movl $0x1, -0x4(%rbp)
jmp 0x2f067
movl $0x0, -0x4(%rbp)
jmp 0x2f067
callq 0x4400
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x2efb2
movl $0x1, -0x24(%rbp)
jmp 0x2f030
cmpl $0x65, -0x28(%rbp)
jne 0x2f025
cmpl $0x0, -0x24(%rbp)
jne 0x2efca
movl $0x0, -0x4(%rbp)
jmp 0x2f067
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0x2e6d0
cmpl $0x0, %eax
je 0x2eff3
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
callq 0x4400
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0x2f01c
movl $0x0, -0x4(%rbp)
jmp 0x2f067
movl $0x1, -0x20(%rbp)
jmp 0x2f02e
movl $0x0, -0x4(%rbp)
jmp 0x2f067
jmp 0x2f030
jmp 0x2f032
jmp 0x2f034
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2ef06
cmpl $0x0, -0x24(%rbp)
je 0x2f060
cmpl $0x0, -0x20(%rbp)
jne 0x2f057
cmpl $0x0, -0x1c(%rbp)
je 0x2f060
movl $0x1, -0x4(%rbp)
jmp 0x2f067
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: rofl0r[P]ascc/tokenizer.c
// Function: is_identifier
static int is_identifier(const char *s) {
	static const char ascmap[128] = {
	['0'] = 2, ['1'] = 2, ['2'] = 2, ['3'] = 2,
	['4'] = 2, ['5'] = 2, ['6'] = 2, ['7'] = 2,
	['8'] = 2, ['9'] = 2, ['A'] = 1, ['B'] = 1,
	['C'] = 1, ['D'] = 1, ['E'] = 1, ['F'] = 1,
	['G'] = 1, ['H'] = 1, ['I'] = 1, ['J'] = 1,
	['K'] = 1, ['L'] = 1, ['M'] = 1, ['N'] = 1,
	['O'] = 1, ['P'] = 1, ['Q'] = 1, ['R'] = 1,
	['S'] = 1, ['T'] = 1, ['U'] = 1, ['V'] = 1,
	['W'] = 1, ['X'] = 1, ['Y'] = 1, ['Z'] = 1,
	['_'] = 1, ['a'] = 1, ['b'] = 1, ['c'] = 1,
	['d'] = 1, ['e'] = 1, ['f'] = 1, ['g'] = 1,
	['h'] = 1, ['i'] = 1, ['j'] = 1, ['k'] = 1,
	['l'] = 1, ['m'] = 1, ['n'] = 1, ['o'] = 1,
	['p'] = 1, ['q'] = 1, ['r'] = 1, ['s'] = 1,
	['t'] = 1, ['u'] = 1, ['v'] = 1, ['w'] = 1,
	['x'] = 1, ['y'] = 1, ['z'] = 1,
	};
	if((*s) & 128) return 0;
	if(ascmap[(unsigned) *s] != 1) return 0;
	++s;
	while(*s) {
		if((*s) & 128) return 0;
		if(!ascmap[(unsigned) *s])
			return 0;
		s++;
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x2f095
movl $0x0, -0x4(%rbp)
jmp 0x2f11e
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x52c9(%rip), %rax      # 0x34370
movsbl (%rax,%rcx), %eax
cmpl $0x1, %eax
je 0x2f0b9
movl $0x0, -0x4(%rbp)
jmp 0x2f11e
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x2f117
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x2f0e8
movl $0x0, -0x4(%rbp)
jmp 0x2f11e
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x5276(%rip), %rax      # 0x34370
cmpb $0x0, (%rax,%rcx)
jne 0x2f109
movl $0x0, -0x4(%rbp)
jmp 0x2f11e
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2f0c5
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x4, -0x18(%rbp)
jge 0x2f1a1
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x2f154
jmp 0x2f1a1
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x4560
movl %eax, -0x1c(%rbp)
cmpl $0x75, -0x1c(%rbp)
je 0x2f16f
cmpl $0x6c, -0x1c(%rbp)
jne 0x2f187
movl -0x1c(%rbp), %eax
movb %al, %cl
movl -0x18(%rbp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, -0x18(%rbp)
cltq
movb %cl, -0x14(%rbp,%rax)
jmp 0x2f193
movl $0x0, -0x4(%rbp)
jmp 0x2f270
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2f143
cmpl $0x1, -0x18(%rbp)
jne 0x2f1b3
movl $0x1, -0x4(%rbp)
jmp 0x2f270
cmpl $0x2, -0x18(%rbp)
jne 0x2f21b
leaq -0x14(%rbp), %rax
movw (%rax), %ax
subw $0x756c, %ax            # imm = 0x756C
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x2f1db
movl $0x1, -0x4(%rbp)
jmp 0x2f270
leaq -0x14(%rbp), %rax
movw (%rax), %ax
subw $0x6c75, %ax            # imm = 0x6C75
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x2f1fa
movl $0x1, -0x4(%rbp)
jmp 0x2f270
leaq -0x14(%rbp), %rax
movw (%rax), %ax
subw $0x6c6c, %ax            # imm = 0x6C6C
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x2f219
movl $0x1, -0x4(%rbp)
jmp 0x2f270
jmp 0x2f21b
cmpl $0x3, -0x18(%rbp)
jne 0x2f269
leaq -0x14(%rbp), %rdi
leaq 0x5448(%rip), %rsi      # 0x34674
movl $0x3, %edx
callq 0x41e0
cmpl $0x0, %eax
jne 0x2f244
movl $0x1, -0x4(%rbp)
jmp 0x2f270
leaq -0x14(%rbp), %rdi
leaq 0x30cf(%rip), %rsi      # 0x3231e
movl $0x3, %edx
callq 0x41e0
cmpl $0x0, %eax
jne 0x2f267
movl $0x1, -0x4(%rbp)
jmp 0x2f270
jmp 0x2f269
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x9, (%rax)
jne 0x2f2b8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %edx
leaq 0x5489(%rip), %rsi      # 0x34738
movb $0x0, %al
callq 0x40d0
jmp 0x2f2ce
cmpq $0x0, -0x18(%rbp)
je 0x2f2cc
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4690
jmp 0x2f2ce
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x41d0
movq %rax, %rcx
movq -0x20(%rbp), %rax
addq %rcx, %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: rofl0r[P]ascc/eval_if.c
// Function: evaluate_if_statement
int evaluate_if_statement(char *str) {
	struct tokenizer t;
	FILE *m = tokenizer_from_string(&t, str);
	int res, ret = evaluate_condition(&t, &res);
	fclose(m);
	return ret ? res : 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x11b0, %rsp           # imm = 0x11B0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x1190(%rbp), %rdi
callq 0x2f370
movq %rax, -0x1198(%rbp)
leaq -0x1190(%rbp), %rdi
leaq -0x119c(%rbp), %rsi
callq 0x2f3d0
movl %eax, -0x11a0(%rbp)
movq -0x1198(%rbp), %rdi
callq 0x4370
cmpl $0x0, -0x11a0(%rbp)
je 0x2f352
movl -0x119c(%rbp), %eax
movl %eax, -0x11a4(%rbp)
jmp 0x2f35c
xorl %eax, %eax
movl %eax, -0x11a4(%rbp)
jmp 0x2f35c
movl -0x11a4(%rbp), %eax
addq $0x11b0, %rsp           # imm = 0x11B0
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2da60
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0xb, (%rax)
jne 0x2f6b1
leaq 0x510b(%rip), %rdi      # 0x347ae
callq 0x2c740
movl $0x0, -0x4(%rbp)
jmp 0x2f6fb
cmpl $0x0, -0x1c(%rbp)
je 0x2f6d2
cmpl $0x0, -0x20(%rbp)
jne 0x2f6d2
leaq 0x510d(%rip), %rdi      # 0x347d1
callq 0x2c740
movl $0x0, -0x4(%rbp)
jmp 0x2f6fb
movq -0x18(%rbp), %rax
cmpl $0x9, (%rax)
jne 0x2f6f0
movq -0x18(%rbp), %rax
cmpl $0x9, 0xc(%rax)
jne 0x2f6f0
movq -0x18(%rbp), %rax
movl $0x20, 0xc(%rax)
jmp 0x2f6f2
jmp 0x2f6f4
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rofl0r[P]ascc/eval_if.c
// Function: expr
static int expr(struct tokenizer *t, int rbp, int*err) {
	struct token tok;
	int ret = skip_next_and_ws(t, &tok);
	if(tok.type == TT_EOF) return 0;
	int left = nud(t, &tok, err);
	while(1) {
		ret = tokenizer_peek_next_non_ws(t, &tok);
		if(bp(tok.type) <= rbp) break;
		ret = tokenizer_next(t, &tok);
		if(tok.type == TT_EOF) break;
		left = led(t, left, &tok, err);
	}
	(void) ret;
	return left;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2f9d0
movl %eax, -0x34(%rbp)
cmpl $0xe, -0x30(%rbp)
jne 0x2f952
movl $0x0, -0x4(%rbp)
jmp 0x2f9be
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq -0x30(%rbp), %rsi
callq 0x2fa30
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2fca0
movl %eax, -0x34(%rbp)
movl -0x30(%rbp), %edi
callq 0x2fcf0
cmpl -0x14(%rbp), %eax
jg 0x2f985
jmp 0x2f9b8
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
xorl %edx, %edx
callq 0x2f670
movl %eax, -0x34(%rbp)
cmpl $0xe, -0x30(%rbp)
jne 0x2f99f
jmp 0x2f9b8
movq -0x10(%rbp), %rdi
movl -0x38(%rbp), %esi
movq -0x20(%rbp), %rcx
leaq -0x30(%rbp), %rdx
callq 0x2fd30
movl %eax, -0x38(%rbp)
jmp 0x2f966
movl -0x38(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: rofl0r[P]ascc/eval_if.c
// Function: skip_next_and_ws
static int skip_next_and_ws(struct tokenizer *t, struct token *tok) {
	int ret = tokenizer_next(t, tok);
	if(!ret) return ret;
	int ws_count;
	ret = eat_whitespace(t, tok, &ws_count);
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x2f670
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x2fa00
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2fa1a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x30250
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rofl0r[P]ascc/eval_if.c
// Function: tokenizer_peek_next_non_ws
static int tokenizer_peek_next_non_ws(struct tokenizer *t, struct token *tok)
{
	int ret;
	while(1) {
		ret = tokenizer_peek_token(t, tok);
		if(is_whitespace_token(tok))
			x_tokenizer_next(t, tok);
		else break;
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2da00
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x302c0
cmpl $0x0, %eax
je 0x2fce2
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x2f670
jmp 0x2fce4
jmp 0x2fce6
jmp 0x2fcb0
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: rofl0r[P]ascc/eval_if.c
// Function: eat_whitespace
static int eat_whitespace(struct tokenizer *t, struct token *token, int *count) {
	*count = 0;
	int ret = 1;
	while (is_whitespace_token(token)) {
		++(*count);
		ret = x_tokenizer_next(t, token);
		if(!ret) break;
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movl $0x1, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x302c0
cmpl $0x0, %eax
je 0x302ad
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x2f670
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x302ab
jmp 0x302ad
jmp 0x30275
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rofl0r[P]ascc/eval_if.c
// Function: charlit_to_int
static int charlit_to_int(const char *lit) {
	if(lit[1] == '\\') switch(lit[2]) {
		case '0': return 0;
		case 'n': return 10;
		case 't': return 9;
		case 'r': return 13;
		case 'x': return strtol(lit+3, NULL, 16);
		default: return lit[2];
	}
	return lit[1];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x5c, %eax
jne 0x303b3
movq -0x10(%rbp), %rax
movsbl 0x2(%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x30, %eax
je 0x30367
jmp 0x3033f
movl -0x14(%rbp), %eax
subl $0x6e, %eax
je 0x30370
jmp 0x30349
movl -0x14(%rbp), %eax
subl $0x72, %eax
je 0x30382
jmp 0x30353
movl -0x14(%rbp), %eax
subl $0x74, %eax
je 0x30379
jmp 0x3035d
movl -0x14(%rbp), %eax
subl $0x78, %eax
je 0x3038b
jmp 0x303a6
movl $0x0, -0x4(%rbp)
jmp 0x303be
movl $0xa, -0x4(%rbp)
jmp 0x303be
movl $0x9, -0x4(%rbp)
jmp 0x303be
movl $0xd, -0x4(%rbp)
jmp 0x303be
movq -0x10(%rbp), %rdi
addq $0x3, %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x10, %edx
callq 0x4520
movl %eax, -0x4(%rbp)
jmp 0x303be
movq -0x10(%rbp), %rax
movsbl 0x2(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x303be
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: rofl0r[P]ascc/eval_if.c
// Function: expect
static int expect(struct tokenizer *t, enum tokentype tt, const char* values[], struct token *token)
{
	int ret;
	do {
		ret = tokenizer_next(t, token);
		if(ret == 0 || token->type == TT_EOF) goto err;
	} while(is_whitespace_token(token));

	if(token->type != tt) {
err:
		error("unexpected token");
		return -1;
	}
	int i = 0;
	while(values[i]) {
		if(!strcmp(values[i], t->buf))
			return i;
		++i;
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0x2f670
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x30408
movq -0x28(%rbp), %rax
cmpl $0xe, (%rax)
jne 0x3040a
jmp 0x30427
jmp 0x3040c
movq -0x28(%rbp), %rdi
callq 0x302c0
cmpl $0x0, %eax
jne 0x303e7
movq -0x28(%rbp), %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
je 0x3043c
jmp 0x30427
leaq 0x4402(%rip), %rdi      # 0x34830
callq 0x2c740
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3048d
movl $0x0, -0x30(%rbp)
movq -0x20(%rbp), %rax
movslq -0x30(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x30486
movq -0x20(%rbp), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
addq $0x120, %rsi            # imm = 0x120
callq 0x4510
cmpl $0x0, %eax
jne 0x3047b
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3048d
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x30443
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x19b40
movq %rax, %rdi
movq (%rdi), %rax
movq 0x38(%rax), %rax
movl $0x16d1a76d, %esi       # imm = 0x16D1A76D
callq *%rax
jmp 0x190ab
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
callq 0x22b00
jmp 0x190bb
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
callq 0x22100
jmp 0x190cb
xorl %eax, %eax
movl %eax, %edi
callq 0x18330
jmp 0x190d6
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
callq 0x19c30
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0x19c60
movq 0x8(%rsp), %rdi
callq 0x19160
addq $0x18, %rsp
retq
movq %rax, %rdi
callq 0x19110
nopl (%rax)
// File: tdv[P]boss/boss/include/core/ref_obj_ptr.h
// Function: Boss::RefObjPtr<Boss::IServiceLocator>::Release()
UInt Release()
    {
      UInt Ret = 0;
      if (Ptr)
        Ret = Ptr->Release();
      Ptr = 0;
      return Ret;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movl $0x0, 0xc(%rsp)
cmpq $0x0, (%rax)
je 0x191b1
movq (%rsp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, 0xc(%rsp)
movq (%rsp), %rax
movq $0x0, (%rax)
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x40(%rsp)
leaq 0x3f(%rsp), %rdi
callq 0x19c90
movl $0x88, %edi
callq 0x248e0
movq %rax, 0x18(%rsp)
jmp 0x19201
movq 0x18(%rsp), %rdi
callq 0x19ca0
jmp 0x1920d
movq 0x18(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x19d60
jmp 0x1921e
leaq 0x30(%rsp), %rdi
callq 0x19dc0
movq %rax, (%rsp)
jmp 0x1922e
movq (%rsp), %rdi
callq 0x19da0
jmp 0x19239
movq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x19dd0
jmp 0x1924a
leaq 0x30(%rsp), %rdi
callq 0x19320
leaq 0x3f(%rsp), %rdi
callq 0x19e00
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x192aa
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x23320
jmp 0x192aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x19320
leaq 0x3f(%rsp), %rdi
callq 0x19e00
movq 0x28(%rsp), %rdi
callq 0xc40a0
nop
// File: tdv[P]boss/boss/include/plugin/../core/base.h
// Function: Boss::Base<Boss::ServiceLocator>::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:
subq $0x58, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
subq $-0x80, %rax
movq %rax, 0x48(%rsp)
movl $0x1, 0x44(%rsp)
movl $0x0, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x40(%rsp), %eax
movl 0x44(%rsp), %ecx
movl %ecx, 0x3c(%rsp)
decl %eax
movl %eax, %ecx
movq %rcx, 0x20(%rsp)
subl $0x4, %eax
ja 0x1a095
movq 0x20(%rsp), %rax
leaq 0xacfb8(%rip), %rcx     # 0xc7044
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%rsp), %rcx
movl 0x3c(%rsp), %eax
negl %eax
lock
xaddl %eax, (%rcx)
movl %eax, 0x38(%rsp)
jmp 0x1a0fc
movq 0x18(%rsp), %rcx
movl 0x3c(%rsp), %eax
negl %eax
lock
xaddl %eax, (%rcx)
movl %eax, 0x38(%rsp)
jmp 0x1a0fc
movq 0x18(%rsp), %rcx
movl 0x3c(%rsp), %eax
negl %eax
lock
xaddl %eax, (%rcx)
movl %eax, 0x38(%rsp)
jmp 0x1a0fc
movq 0x18(%rsp), %rcx
movl 0x3c(%rsp), %eax
negl %eax
lock
xaddl %eax, (%rcx)
movl %eax, 0x38(%rsp)
jmp 0x1a0fc
movq 0x18(%rsp), %rcx
movl 0x3c(%rsp), %eax
negl %eax
lock
xaddl %eax, (%rcx)
movl %eax, 0x38(%rsp)
movl 0x38(%rsp), %eax
movl %eax, 0x2c(%rsp)
cmpl $0x1, 0x2c(%rsp)
jne 0x1a16e
movq 0x10(%rsp), %rdi
callq 0x1b1a0
movl $0x2, 0x54(%rsp)
movl 0x54(%rsp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0x4, %eax
ja 0x1a14d
movq 0x8(%rsp), %rax
leaq 0xacf1d(%rip), %rcx     # 0xc7058
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x1a14d
jmp 0x1a14d
jmp 0x1a14d
mfence
movq 0x10(%rsp), %rax
cmpq $0x0, %rax
je 0x1a16c
movq 0x10(%rsp), %rdi
callq 0x19ee0
movq 0x10(%rsp), %rdi
callq 0x23320
jmp 0x1a16e
movl 0x2c(%rsp), %eax
subl $0x1, %eax
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
movl 0x1c(%rsp), %esi
movq 0x10(%rsp), %rdx
callq 0x1b270
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x1a1bd
movq (%rsp), %rdi
callq 0x19f60
movl 0xc(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movl %esi, 0x54(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x48(%rsp)
je 0x1a1ff
movq 0x48(%rsp), %rax
cmpq $0x0, (%rax)
je 0x1a20c
movl $0x5, 0x64(%rsp)
jmp 0x1a2d2
movq 0x10(%rsp), %rsi
addq $0x18, %rsi
leaq 0x40(%rsp), %rdi
callq 0x1b530
movq 0x10(%rsp), %rdi
addq $0x40, %rdi
leaq 0x54(%rsp), %rsi
callq 0x1b560
movq %rax, 0x8(%rsp)
jmp 0x1a239
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq %rax, 0x38(%rsp)
addq $0x40, %rdi
callq 0x1b5b0
movq %rax, 0x20(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x1b590
testb $0x1, %al
jne 0x1a26b
jmp 0x1a297
movl $0x2, 0x64(%rsp)
movl $0x1, 0x1c(%rsp)
jmp 0x1a2c8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x1b650
jmp 0x1a2db
leaq 0x38(%rsp), %rdi
callq 0x1b5e0
movq %rax, %rdi
addq $0x8, %rdi
movq 0x48(%rsp), %rsi
callq 0x1b600
movl %eax, 0x4(%rsp)
jmp 0x1a2b8
movl 0x4(%rsp), %eax
movl %eax, 0x64(%rsp)
movl $0x1, 0x1c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x1b650
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0xc40a0
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movl %esi, 0x64(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x58(%rsp)
jne 0x1a321
movl $0x5, 0x74(%rsp)
jmp 0x1a3fb
movq 0x20(%rsp), %rsi
addq $0x18, %rsi
leaq 0x50(%rsp), %rdi
callq 0x1b530
movq 0x20(%rsp), %rdi
addq $0x40, %rdi
leaq 0x64(%rsp), %rsi
callq 0x1b560
movq %rax, 0x18(%rsp)
jmp 0x1a34e
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, 0x48(%rsp)
addq $0x40, %rdi
callq 0x1b5b0
movq %rax, 0x30(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x1bc00
testb $0x1, %al
jne 0x1a380
jmp 0x1a3ac
movl $0x2, 0x74(%rsp)
movl $0x1, 0x2c(%rsp)
jmp 0x1a3f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x1b650
jmp 0x1a404
movq 0x20(%rsp), %rdi
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x40, %rdi
leaq 0x64(%rsp), %rsi
callq 0x1bc20
movq %rax, 0x10(%rsp)
jmp 0x1a3d0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
callq 0x1bc50
jmp 0x1a3e1
movl $0x0, 0x74(%rsp)
movl $0x1, 0x2c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x1b650
movl 0x74(%rsp), %eax
addq $0x78, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0xc40a0
nop
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movl %esi, 0x64(%rsp)
movq 0x68(%rsp), %rsi
movq %rsi, 0x10(%rsp)
addq $0x18, %rsi
leaq 0x58(%rsp), %rdi
callq 0x1b530
movq 0x10(%rsp), %rdi
addq $0x40, %rdi
leaq 0x64(%rsp), %rsi
callq 0x1b560
movq %rax, 0x18(%rsp)
jmp 0x1a44f
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, 0x50(%rsp)
addq $0x40, %rdi
callq 0x1b5b0
movq %rax, 0x38(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x1b590
testb $0x1, %al
jne 0x1a481
jmp 0x1a4ad
movl $0x2, 0x74(%rsp)
movl $0x1, 0x34(%rsp)
jmp 0x1a4eb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x1b650
jmp 0x1a4fe
movq 0x10(%rsp), %rdi
addq $0x40, %rdi
movq 0x50(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rsi
callq 0x1c8f0
movq %rax, 0x8(%rsp)
jmp 0x1a4d1
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x74(%rsp)
movl $0x1, 0x34(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x1b650
movl 0x74(%rsp), %eax
addq $0x78, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0xc40a0
nopl (%rax,%rax)
// File: tdv[P]boss/boss/include/plugin/../core/base.h
// Function: unsigned int Boss::Private::QueryInterface<Boss::IServiceLocator, false>::Query<Boss::ServiceLocator>(Boss::ServiceLocator*, unsigned int, void**)
static RetCode Query(ObjType *obj, InterfaceId ifaceId, Ptr *iface)
      {
        if (ifaceId == InterfaceTraits<T>::Id)
        {
          *iface = static_cast<T *>(obj);
          return Status::Ok;
        }
        return QueryFromInterfacesList<T>::Query(static_cast<T *>(obj), ifaceId, iface);
      }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq %rdx, 0x28(%rsp)
cmpl $0x29d4d8a5, 0x34(%rsp) # imm = 0x29D4D8A5
jne 0x1b358
movq 0x38(%rsp), %rcx
movq %rcx, 0x18(%rsp)
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, 0x20(%rsp)
je 0x1b341
movq 0x18(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, (%rax)
movl $0x0, 0x44(%rsp)
jmp 0x1b394
movq 0x38(%rsp), %rcx
movq %rcx, 0x8(%rsp)
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, 0x10(%rsp)
je 0x1b37d
movq 0x8(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl 0x34(%rsp), %esi
movq 0x28(%rsp), %rdx
callq 0x1b3c0
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: tdv[P]boss/boss/include/plugin/../core/base.h
// Function: unsigned int Boss::Private::QueryInterfacesListIter<std::tuple<Boss::IBase>, 0ul>::Query<Boss::IServiceLocator>(Boss::IServiceLocator*, unsigned int, void**)
static RetCode Query(ObjType *obj, InterfaceId ifaceId, Ptr *iface)
      {
        typedef typename std::tuple_element<I, T>::type CurType;
        if (ifaceId == InterfaceTraits<CurType>::Id)
        {
          *iface = static_cast<CurType *>(obj);
          return Status::Ok;
        }
        return QueryInterfacesListIter<T, I - 1>::Query(obj, ifaceId, iface) == Status::Ok ?
          Status::Ok : QueryInterface<CurType, false>::Query(obj, ifaceId, iface);
      }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq %rdx, 0x8(%rsp)
cmpl $0x2cc77d66, 0x14(%rsp) # imm = 0x2CC77D66
jne 0x1b423
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movl $0x0, 0x24(%rsp)
jmp 0x1b462
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movq 0x8(%rsp), %rdx
callq 0x1b470
cmpl $0x0, %eax
jne 0x1b443
xorl %eax, %eax
movl %eax, 0x4(%rsp)
jmp 0x1b45a
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
movq 0x8(%rsp), %rdx
callq 0x1b490
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: tdv[P]boss/boss/include/plugin/../core/base.h
// Function: unsigned int Boss::Private::QueryFromInterfacesList<Boss::IBase>::Query<Boss::IBase>(Boss::IBase*, unsigned int, void**)
static RetCode Query(ObjType *obj, InterfaceId ifaceId, Ptr *iface)
      {
        if (ifaceId == InterfaceTraits<IBase>::Id)
        {
          *iface = static_cast<IBase *>(obj);
          return Status::Ok;
        }
        return Status::NotFound;
      }

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movq %rdx, -0x20(%rsp)
cmpl $0x2cc77d66, -0x14(%rsp) # imm = 0x2CC77D66
jne 0x1b51f
movq -0x10(%rsp), %rcx
movq -0x20(%rsp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rsp)
jmp 0x1b527
movl $0x3, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movl %edx, 0x54(%rsp)
movq 0x58(%rsp), %rsi
movl 0x54(%rsp), %edx
leaq 0x40(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x1d660
movq 0x28(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x1d840
jmp 0x1cf48
leaq 0x40(%rsp), %rdi
callq 0x1ae80
leaq 0x48(%rsp), %rdi
callq 0x1d890
movq %rax, 0x10(%rsp)
jmp 0x1cf63
movq 0x10(%rsp), %rax
cmpq $0x0, %rax
jne 0x1cff3
movl $0x10, %edi
callq 0x23610
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
leaq 0xaa2d4(%rip), %rsi     # 0xc7262
callq 0x1d8a0
jmp 0x1cf95
movq 0x8(%rsp), %rdi
leaq 0xe49bf(%rip), %rsi     # 0x101960
leaq 0x938(%rip), %rdx       # 0x1d8e0
callq 0x24660
jmp 0x1d02c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x1ae80
jmp 0x1d022
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x1d018
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x23670
jmp 0x1d018
movq 0x18(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x1d8f0
jmp 0x1d004
leaq 0x48(%rsp), %rdi
callq 0x1d300
movq 0x20(%rsp), %rax
addq $0x68, %rsp
retq
leaq 0x48(%rsp), %rdi
callq 0x1d300
movq 0x38(%rsp), %rdi
callq 0xc40a0
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, (%rax)
je 0x1d633
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x156e0
movl %eax, 0x1c(%rsp)
xorl %eax, %eax
cmpl $0x0, 0x1c(%rsp)
movb %al, 0xf(%rsp)
jne 0x1d5ff
movb $0x1, %al
movb %al, 0xf(%rsp)
jmp 0x1d5ff
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x1d609
jmp 0x1d60b
jmp 0x1d62a
leaq 0xa9be0(%rip), %rdi     # 0xc71f2
leaq 0xa9bf9(%rip), %rsi     # 0xc7212
movl $0x4f, %edx
leaq 0xa9c12(%rip), %rcx     # 0xc7237
callq 0x15150
movl 0x1c(%rsp), %edi
callq 0x1d650
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0xb8, %rsp
movq %rdi, 0x38(%rsp)
movq %rdi, %rax
movq %rax, 0x40(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movl %edx, 0xa4(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x48(%rsp)
xorl %eax, %eax
movl %eax, %esi
leaq 0x98(%rsp), %rdi
callq 0x1c370
leaq 0x6f(%rsp), %rdi
movq %rdi, 0x50(%rsp)
callq 0x25790
movq 0x50(%rsp), %rdx
leaq 0xa9bb3(%rip), %rsi     # 0xc7277
leaq 0x70(%rsp), %rdi
callq 0x98c60
jmp 0x1d6d0
movq 0x48(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x1d920
movq %rax, 0x30(%rsp)
jmp 0x1d6e6
leaq 0x70(%rsp), %rdi
callq 0x962e0
leaq 0x6f(%rsp), %rdi
callq 0x257b0
movq 0x30(%rsp), %rax
movq %rax, 0x90(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0xa4(%rsp), %eax
movl %eax, 0x24(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x1dad0
movq %rax, 0x28(%rsp)
jmp 0x1d733
movq 0x18(%rsp), %rax
movq 0x28(%rsp), %rsi
movl 0x24(%rsp), %edi
callq *%rax
movl %eax, 0x14(%rsp)
jmp 0x1d749
movl 0x14(%rsp), %eax
cmpl $0x0, %eax
je 0x1d7f4
movl $0x10, %edi
callq 0x23610
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
leaq 0xa9b16(%rip), %rsi     # 0xc7288
callq 0x1dae0
jmp 0x1d779
movq 0x8(%rsp), %rdi
leaq 0xe41db(%rip), %rsi     # 0x101960
leaq 0x154(%rip), %rdx       # 0x1d8e0
callq 0x24660
jmp 0x1d839
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x1d7be
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x962e0
leaq 0x6f(%rsp), %rdi
callq 0x257b0
jmp 0x1d822
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x1d822
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
callq 0x23670
jmp 0x1d822
movq 0x38(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x1db20
jmp 0x1d808
leaq 0x98(%rsp), %rdi
callq 0x1ae80
movq 0x40(%rsp), %rax
addq $0xb8, %rsp
retq
leaq 0x98(%rsp), %rdi
callq 0x1ae80
movq 0x60(%rsp), %rdi
callq 0xc40a0
nopl (%rax)
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, (%rax)
jne 0x1d9a5
movl $0x10, %edi
callq 0x23610
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
leaq 0xa993b(%rip), %rsi     # 0xc72a1
callq 0x1db50
jmp 0x1d96d
movq 0x18(%rsp), %rdi
leaq 0xe3fa7(%rip), %rsi     # 0x101920
leaq -0x4a0(%rip), %rdx      # 0x1d4e0
callq 0x24660
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
callq 0x23670
jmp 0x1dac1
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x88(%rsp), %rdi
callq 0x97d20
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x155e0
movq %rax, 0x70(%rsp)
cmpq $0x0, 0x70(%rsp)
jne 0x1dab4
movb $0x1, 0x2f(%rsp)
movl $0x10, %edi
callq 0x23610
movq %rax, 0x8(%rsp)
movq 0x88(%rsp), %rdx
leaq 0xa98b9(%rip), %rsi     # 0xc72b9
leaq 0x30(%rsp), %rdi
callq 0x1d370
jmp 0x1da0c
leaq 0xa98b1(%rip), %rdx     # 0xc72c4
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x1d320
jmp 0x1da24
movq 0x8(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x1d4a0
jmp 0x1da35
movq 0x8(%rsp), %rdi
movb $0x0, 0x2f(%rsp)
leaq 0xe3eda(%rip), %rsi     # 0x101920
leaq -0x56d(%rip), %rdx      # 0x1d4e0
callq 0x24660
jmp 0x1dace
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
jmp 0x1da9f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
jmp 0x1da95
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x962e0
leaq 0x30(%rsp), %rdi
callq 0x962e0
testb $0x1, 0x2f(%rsp)
jne 0x1daa8
jmp 0x1dab2
movq 0x8(%rsp), %rdi
callq 0x23670
jmp 0x1dac1
movq 0x70(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x80(%rsp), %rdi
callq 0xc40a0
nop
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x1e99b
cmpl $0x0, 0x1c(%rsp)
jne 0x1e9a8
movl $0x1, 0x34(%rsp)
jmp 0x1ea3b
movq 0x10(%rsp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x8(%rcx)
movb %al, 0xf(%rsp)
je 0x1e9c2
movb $0x1, %al
movb %al, 0xf(%rsp)
jmp 0x1e9c2
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x1e9cc
jmp 0x1e9ce
jmp 0x1e9ed
leaq 0xa89f0(%rip), %rdi     # 0xc73c5
leaq 0xa8929(%rip), %rsi     # 0xc7305
movl $0x6d, %edx
leaq 0xa8b0f(%rip), %rcx     # 0xc74f7
callq 0x15150
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x1ea03
movl $0x2, 0x34(%rsp)
jmp 0x1ea3b
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %ecx
movl %ecx, %edx
movq 0x8(%rax), %rcx
movl $0x1, %esi
callq 0x15600
movq %rax, %rdx
movl 0x1c(%rsp), %eax
movl %eax, %esi
movl $0x2, %eax
xorl %ecx, %ecx
cmpq %rsi, %rdx
cmovel %ecx, %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x1fb9b
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
je 0x1fba5
movl $0x5, 0x24(%rsp)
jmp 0x1fbeb
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
callq 0x20e00
testb $0x1, %al
jne 0x1fbb9
jmp 0x1fbc1
xorl %eax, %eax
movq %rax, (%rsp)
jmp 0x1fbd7
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x20e50
movq %rax, (%rsp)
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: tdv[P]boss/boss/include/common/buffer.h
// Function: Boss::RawBuffer::GetSize(unsigned int*) const
virtual RetCode BOSS_CALL GetSize(UInt *size) const
    {
      if (!size)
        return  Status::InvalidArgument;
      *size = Buffer.size();
      return Status::Ok;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x1fc2a
movl $0x5, 0x24(%rsp)
jmp 0x1fc49
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
callq 0x1f520
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)