LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/util_string.cpp
// Function: AGS::Common::String::TruncateToRightSection(char, bool)
void String::TruncateToRightSection(char separator, bool exclude_separator)
{
    if (_meta && separator)
    {
        size_t slice_at = FindCharReverse(separator);
        if (slice_at != -1)
        {
            TruncateToRight(exclude_separator ? _meta->Length - slice_at - 1 : _meta->Length - slice_at);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq (%rdi), %r14
testq %r14, %r14
sete %al
testb %sil, %sil
sete %cl
orb %al, %cl
jne 0x14a91
movl %edx, %ebp
movq %rdi, %rbx
movsbl %sil, %esi
pushq $-0x1
popq %rdx
callq 0x13ad2
cmpq $-0x1, %rax
je 0x14a91
movq %rax, %rcx
notq %rcx
negq %rax
testb %bpl, %bpl
cmovneq %rcx, %rax
addq 0x10(%r14), %rax
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x149bc
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/util_string.cpp
// Function: AGS::Common::String::TruncateToSection(char, unsigned long, unsigned long, bool, bool)
void String::TruncateToSection(char separator, size_t first, size_t last,
                          bool exclude_first_sep, bool exclude_last_sep)
{
    if (!_meta || !separator)
    {
        return;
    }

    size_t slice_from;
    size_t slice_to;
    if (FindSection(separator, first, last, exclude_first_sep, exclude_last_sep,
        slice_from, slice_to))
    {
        TruncateToMid(slice_from, slice_to - slice_from);
    }
    else
    {
        Empty();
    }
}

// Assembly:
testb %sil, %sil
je 0x14af1
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x14aec
movq %rsp, %rax
leaq 0x8(%rsp), %r10
movsbl %sil, %esi
movzbl %r8b, %r8d
movzbl %r9b, %r9d
movq %rbx, %rdi
pushq %rax
pushq %r10
callq 0x13b5a
popq %rcx
popq %rdx
testb %al, %al
je 0x14ae4
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
subq %rsi, %rdx
movq %rbx, %rdi
callq 0x14952
jmp 0x14aec
movq %rbx, %rdi
callq 0x135b8
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/util_stream.cpp
// Function: AGS::Common::Stream::WriteByteCount(unsigned char, unsigned long)
size_t Stream::WriteByteCount(uint8_t b, size_t count)
{
    if (!CanWrite())
        return 0;
    size_t size = 0;
    for (; count > 0; --count, ++size)
    {
        if (WriteByte(b) < 0)
            break;
    }
    return size;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movq (%rdi), %rax
callq *0x40(%rax)
testb %al, %al
je 0x14ded
xorl %r15d, %r15d
movzbl %bpl, %ebp
cmpq %r15, %rbx
je 0x14df4
movq (%r14), %rax
movq %r14, %rdi
movl %ebp, %esi
callq *0x68(%rax)
testl %eax, %eax
js 0x14df1
incq %r15
jmp 0x14dd4
xorl %ebx, %ebx
jmp 0x14df4
movq %r15, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/cs_compiler.cpp
// Function: ccAddDefaultHeader(char*, char*)
int ccAddDefaultHeader(char* nhead, char *nName)
{
    if (numheaders >= capacityHeaders)
    {
        capacityHeaders += 50;
        defaultheaders = (char**)realloc(defaultheaders, sizeof(char*) * capacityHeaders);
        defaultHeaderNames = (char**)realloc(defaultHeaderNames, sizeof(char*) * capacityHeaders);
    }

    defaultheaders[numheaders] = nhead;
    defaultHeaderNames[numheaders] = nName;
    numheaders++;
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movslq 0x168af(%rip), %r12     # 0x2b6c8
movslq 0x168ac(%rip), %rax     # 0x2b6cc
cmpl %eax, %r12d
jl 0x14e63
leaq 0x32(%rax), %rcx
movl %ecx, 0x1689d(%rip)     # 0x2b6cc
movq 0x10aba(%rip), %rdi     # 0x258f0
leaq 0x190(,%rax,8), %r15
movq %r15, %rsi
callq 0x3530
movq %rax, 0x10aa3(%rip)     # 0x258f0
movq 0x10aa4(%rip), %rdi     # 0x258f8
movq %r15, %rsi
callq 0x3530
movq %rax, 0x10a95(%rip)     # 0x258f8
movq 0x10a86(%rip), %rax     # 0x258f0
movq %r14, (%rax,%r12,8)
movq 0x10a83(%rip), %rax     # 0x258f8
movq %rbx, (%rax,%r12,8)
leal 0x1(%r12), %eax
movl %eax, 0x16844(%rip)     # 0x2b6c8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/cc_macrotable.cpp
// Function: MacroTable::shutdown()
void MacroTable::shutdown() {
    int rr;
    for (rr=0;rr<num;rr++) {
        free(macro[rr]);
        free(name[rr]);
        macro[rr]=NULL;
        name[rr]=NULL;
    }
    num = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movslq (%rbx), %rax
cmpq %rax, %r14
jge 0x151e9
movq 0x2ee8(%rbx,%r14,8), %rdi
callq 0x33a0
movq 0x8(%rbx,%r14,8), %rdi
callq 0x33a0
andq $0x0, 0x2ee8(%rbx,%r14,8)
andq $0x0, 0x8(%rbx,%r14,8)
incq %r14
jmp 0x151b6
andl $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/cc_macrotable.cpp
// Function: MacroTable::add(char*, char*)
void MacroTable::add(char*namm,char*mac) {
    if (find_name(namm) >= 0) {
        cc_error("macro '%s' already defined",namm);
        return;
    }
    if (num>=MAXDEFINES) {
        cc_error("too many macros defined");
        return;
    }
    name[num]=(char*)malloc(strlen(namm)+5);
    strcpy(name[num],namm);
    macro[num]=(char*)malloc(strlen(mac)+5);
    strcpy(macro[num],mac);
    size_t l = strlen(mac);
    // remove trailing whitespace, newlines and the like.
    // if a macro ends with a newline (as usual when passed from parser)
    // this would otherwise cause the expanded macro to mess up reported
    // linenumbers.
    while(l > 0 && isspace(macro[num][l-1]))
        macro[num][--l] = 0;
    num++;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x15314
testl %eax, %eax
js 0x1525f
leaq 0x5ec9(%rip), %rdi      # 0x1b115
movq %r15, %rsi
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf258
movslq (%rbx), %r12
cmpq $0x5dc, %r12            # imm = 0x5DC
jl 0x15282
leaq 0x5ebe(%rip), %rdi      # 0x1b130
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xf258
movq %r15, %rdi
callq 0x3190
leaq 0x5(%rax), %rdi
callq 0x3430
movq %rax, 0x8(%rbx,%r12,8)
movq %rax, %rdi
movq %r15, %rsi
callq 0x32c0
movq %r14, %rdi
callq 0x3190
leaq 0x5(%rax), %rdi
callq 0x3430
movq %rax, 0x2ee8(%rbx,%r12,8)
movq %rax, %rdi
movq %r14, %rsi
callq 0x32c0
movq %r14, %rdi
callq 0x3190
movq %rax, %r14
movq %rax, %r15
subq $0x1, %r15
jb 0x15303
movslq %r12d, %rax
movq 0x2ee8(%rbx,%rax,8), %r13
movsbl -0x1(%r13,%r14), %edi
callq 0x3080
testl %eax, %eax
je 0x15303
movb $0x0, -0x1(%r13,%r14)
movl (%rbx), %r12d
movq %r15, %r14
jmp 0x152d5
incl %r12d
movl %r12d, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/cc_macrotable.cpp
// Function: MacroTable::find_name(char*)
int MacroTable::find_name(char* namm) {
    int ss;
    for (ss=0;ss<num;ss++) {
        if (strcmp(namm,name[ss])==0) return ss;
    }
    return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %r12d
xorl %r15d, %r15d
testl %r12d, %r12d
cmovlel %r15d, %r12d
pushq $-0x1
popq %rbp
cmpq %r15, %r12
je 0x15350
movq 0x8(%r14,%r15,8), %rsi
movq %rbx, %rdi
callq 0x3450
testl %eax, %eax
je 0x1534d
incq %r15
jmp 0x15332
movl %r15d, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/cc_macrotable.cpp
// Function: MacroTable::remove(int)
void MacroTable::remove(int index) {
    if ((index < 0) || (index >= num)) {
        cc_error("MacroTable::Remove: index out of range");
        return;
    }
    // just blank out the entry, don't bother to remove it
    name[index][0] = 0;
    macro[index][0] = 0;
}

// Assembly:
testl %esi, %esi
js 0x1537a
cmpl %esi, (%rdi)
jle 0x1537a
movl %esi, %eax
movq 0x8(%rdi,%rax,8), %rcx
xorl %edx, %edx
movb %dl, (%rcx)
movq 0x2ee8(%rdi,%rax,8), %rax
movb %dl, (%rax)
retq
leaq 0x5dc7(%rip), %rdi      # 0x1b148
xorl %eax, %eax
jmp 0xf258
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/cs_prepro.cpp
// Function: get_next_word(char*, char*, bool)
void get_next_word(char*stin,char*wo, bool includeDots = false) {
  if (stin[0] == '\"') {
    // a string
    int breakout = 0;
//    char*oriwo=wo;
    wo[0] = stin[0];
    wo++; stin++;
    while (!breakout) {
      if ((stin[0] == '\"') && (stin[-1] != '\\')) breakout=1;
      if (stin[0] == 0) breakout = 1;
      wo[0] = stin[0];
      wo++; stin++;
      }
    wo[0] = 0;
//    printf("Word: '%s'\n",oriwo);
    return;
    }
  else if (stin[0] == '\'') {
    // a character constant
    int breakout = 0;
    wo[0] = stin[0];
    wo++; stin++;
    while (!breakout) {
      if ((stin[0] == '\'') && (stin[-1] != '\\')) breakout=1;
      if (stin[0] == 0) breakout = 1;
      wo[0] = stin[0];
      wo++; stin++;
      }
    wo[0] = 0;
    return;
  }

  while ((is_alphanum(stin[0])) || ((includeDots) && (stin[0] == '.'))) {
    wo[0] = stin[0];
    wo++;
    stin++;
  }

  wo[0]=0;
  return;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rdi), %eax
cmpl $0x22, %eax
je 0x153d8
cmpl $0x27, %eax
jne 0x1540d
movb $0x27, (%rbx)
incq %rbx
incq %r14
xorl %ecx, %ecx
pushq $0x1
popq %rax
testl %ecx, %ecx
jne 0x1543b
movb (%r14), %dl
xorl %ecx, %ecx
cmpb $0x27, %dl
jne 0x153c9
xorl %ecx, %ecx
cmpb $0x5c, -0x1(%r14)
setne %cl
testb %dl, %dl
movb %dl, (%rbx)
cmovel %eax, %ecx
incq %rbx
incq %r14
jmp 0x153ad
movb $0x22, (%rbx)
incq %rbx
incq %r14
xorl %ecx, %ecx
pushq $0x1
popq %rax
testl %ecx, %ecx
jne 0x1543b
movb (%r14), %dl
xorl %ecx, %ecx
cmpb $0x22, %dl
jne 0x153fe
xorl %ecx, %ecx
cmpb $0x5c, -0x1(%r14)
setne %cl
testb %dl, %dl
movb %dl, (%rbx)
cmovel %eax, %ecx
incq %rbx
incq %r14
jmp 0x153e6
movl %edx, %ebp
movsbl %al, %edi
callq 0x12703
testl %eax, %eax
je 0x15420
movb (%r14), %al
jmp 0x1542d
testb %bpl, %bpl
je 0x1543b
movb $0x2e, %al
cmpb $0x2e, (%r14)
jne 0x1543b
movb %al, (%rbx)
incq %rbx
movb 0x1(%r14), %al
incq %r14
jmp 0x1540f
movb $0x0, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/cs_prepro.cpp
// Function: pre_process_line(char*)
void pre_process_line(char*lin) {

  if (deletingCurrentLine()) {
    lin[0] = 0;
    return;
  }

  char*oldl=(char*)malloc(strlen(lin)+5);
  strcpy(oldl,lin);
  char*opt=oldl;
  char charBefore = 0;

  while (opt[0]!=0) {
    while (is_alphanum(opt[0])==0) {
      if (opt[0]==0) break;
      lin[0]=opt[0]; lin++; opt++; }

    if (opt > oldl)
      charBefore = opt[-1];
    else
      charBefore = 0;

    char thisword[MAX_LINE_LENGTH];
    get_next_word(opt,thisword);
    opt+=strlen(thisword);

    int fni = -1;
    if (charBefore != '.') {
      // object.member -- if member is a #define, it shouldn't be replaced
      fni = macros.find_name(thisword);
    }

    if (fni >= 0) {
      strcpy(lin,macros.macro[fni]);
      lin+=strlen(macros.macro[fni]);
    }
    else {
      strcpy(lin,thisword);
      lin+=strlen(thisword);
    }

  }
  free(oldl);
  lin[0]=0;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp            # imm = 0x1F8
movq %rdi, %rbx
movl 0x1b963(%rip), %eax     # 0x31498
cmpl 0x1b961(%rip), %eax     # 0x3149c
jg 0x15c28
movq %rbx, %rdi
callq 0x3190
leaq 0x5(%rax), %rdi
callq 0x3430
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x32c0
movq %rsp, %r15
movq %r14, %r13
movb (%r13), %al
testb %al, %al
je 0x15c20
movsbl %al, %edi
callq 0x12703
testl %eax, %eax
jne 0x15b94
movb (%r13), %al
testb %al, %al
je 0x15b94
movb %al, (%rbx)
incq %rbx
movb 0x1(%r13), %al
incq %r13
jmp 0x15b72
cmpq %r14, %r13
jbe 0x15ba4
cmpb $0x2e, -0x1(%r13)
sete %r12b
jmp 0x15ba7
xorl %r12d, %r12d
movq %r13, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x15388
movq %r15, %rdi
callq 0x3190
movq %rax, %rbp
testb %r12b, %r12b
jne 0x15c02
leaq 0x15b05(%rip), %rdi     # 0x2b6d0
movq %r15, %rsi
callq 0x15314
testl %eax, %eax
js 0x15c02
movl %eax, %r12d
leaq 0x15aef(%rip), %rax     # 0x2b6d0
movq 0x2ee8(%rax,%r12,8), %rsi
movq %rbx, %rdi
callq 0x32c0
leaq 0x15ad8(%rip), %rax     # 0x2b6d0
movq 0x2ee8(%rax,%r12,8), %rdi
jmp 0x15c10
movq %rbx, %rdi
movq %r15, %rsi
callq 0x32c0
movq %r15, %rdi
addq %rbp, %r13
callq 0x3190
addq %rax, %rbx
jmp 0x15b66
movq %r14, %rdi
callq 0x33a0
movb $0x0, (%rbx)
addq $0x1f8, %rsp            # imm = 0x1F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/cs_prepro.cpp
// Function: cc_preprocess(char const*, char*)
void cc_preprocess(const char *inpu,char*outp) {
  reset_compiler();
  FMEM*temp=fmem_create();
  FMEM*iii=fmem_open(inpu);
  char linebuffer[1200];
  currentline=0;
  if_level = if_level_active = if_level_satisfied = 0;

  while (!fmem_eof(iii)) {
    fmem_gets(iii,linebuffer);
    currentline++;
    if (strlen(linebuffer) >= MAX_LINE_LENGTH) {  // stop array overflows in subroutines
      cc_error("line too long (%d chars max)", MAX_LINE_LENGTH);
      break; 
    }

    remove_comments(linebuffer);
    // need to check this, otherwise re-defining a macro causes
    // a big problem:
    // #define a int, #define a void  results in #define int void
    if (linebuffer[0]!='#')
      pre_process_line(linebuffer);
    if (ccError) break;
    if (linebuffer[0]=='#')
      pre_process_directive(linebuffer,temp);
    else {  // don't output the #define lines
//      printf("%s\n",linebuffer);
      fmem_puts(linebuffer,temp);
      }
    if (ccError) break;
    }

  strcpy(outp,temp->data);
  fmem_close(temp);
  fmem_close(iii);

  if ((if_level) && (!ccError))
    cc_error("missing #endif");

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4b8, %rsp            # imm = 0x4B8
movq %rsi, %rbx
leaq 0xfa78(%rip), %r13      # 0x256d0
andl $0x0, (%r13)
movq %rdi, %r15
andl $0x0, 0x1b83d(%rip)     # 0x314a4
leaq 0xfb42(%rip), %rbp      # 0x257b0
andl $0x0, (%rbp)
callq 0x11b48
movq %rax, %r14
movq %r15, %rdi
callq 0x11b89
andl $0x0, (%rbp)
andl $0x0, 0x1b813(%rip)     # 0x314a0
movq %rax, %r15
andl $0x0, 0x1b805(%rip)     # 0x3149c
andl $0x0, 0x1b7fa(%rip)     # 0x31498
movq %rsp, %r12
movq %r15, %rdi
callq 0x11d52
testl %eax, %eax
jne 0x15d22
movq %r15, %rdi
movq %r12, %rsi
callq 0x11d60
incl (%rbp)
movq %r12, %rdi
callq 0x3190
cmpq $0x1f4, %rax            # imm = 0x1F4
jae 0x15d0f
movq %r12, %rdi
callq 0x15921
cmpb $0x23, (%rsp)
je 0x15ce1
movq %r12, %rdi
callq 0x15b1b
cmpl $0x0, (%r13)
jne 0x15d22
cmpb $0x23, (%rsp)
jne 0x15cfb
movq %r12, %rdi
movq %r14, %rsi
callq 0x154a0
jmp 0x15d06
movq %r12, %rdi
movq %r14, %rsi
callq 0x11cb6
cmpl $0x0, (%r13)
je 0x15ca1
jmp 0x15d22
leaq 0x558e(%rip), %rdi      # 0x1b2a4
movl $0x1f4, %esi            # imm = 0x1F4
xorl %eax, %eax
callq 0xf258
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x32c0
movq %r14, %rdi
callq 0x11be6
movq %r15, %rdi
callq 0x11be6
cmpl $0x0, 0x1b754(%rip)     # 0x31498
je 0x15d5b
cmpl $0x0, (%r13)
jne 0x15d5b
leaq 0x556d(%rip), %rdi      # 0x1b2c1
xorl %eax, %eax
callq 0xf258
addq $0x4b8, %rsp            # imm = 0x4B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/tokenizer.c
// Function: tokenizer_peek
int tokenizer_peek(struct tokenizer *t) {
	if(t->peeking) return t->peek_token.value;
	int ret = tokenizer_getc(t);
	if(ret != EOF) tokenizer_ungetc(t, ret);
	return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
cmpl $0x0, 0x18(%rdi)
je 0x15dd3
movl 0x1184(%r14), %ebx
jmp 0x15df1
movq %r14, %rdi
callq 0x15dfb
cmpl $-0x1, %eax
je 0x15dee
movl %eax, %ebx
movq %r14, %rdi
movl %eax, %esi
callq 0x15e51
jmp 0x15df1
pushq $-0x1
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/tokenizer.c
// Function: tokenizer_getc
static int tokenizer_getc(struct tokenizer *t)
{
	int c;
	if(t->getc_buf.buffered) {
		t->getc_buf.buffered--;
		c = t->getc_buf.buf[(t->getc_buf.cnt) % ARRAY_SIZE(t->getc_buf.buf)];
	} else {
		c = getc(t->input);
		t->getc_buf.buf[t->getc_buf.cnt % ARRAY_SIZE(t->getc_buf.buf)] = c;
	}
	++t->getc_buf.cnt;
	return c;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x1150(%rdi), %rax
testq %rax, %rax
je 0x15e2a
decq %rax
movq %rax, 0x1150(%rbx)
movq 0x1148(%rbx), %rcx
movl %ecx, %eax
andl $0x7, %eax
movl 0x1128(%rbx,%rax,4), %eax
jmp 0x15e45
movq (%rbx), %rdi
callq 0x3120
movq 0x1148(%rbx), %rcx
movl %ecx, %edx
andl $0x7, %edx
movl %eax, 0x1128(%rbx,%rdx,4)
incq %rcx
movq %rcx, 0x1148(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/tokenizer.c
// Function: tokenizer_ungetc
static int tokenizer_ungetc(struct tokenizer *t, int c)
{
	++t->getc_buf.buffered;
	assert(t->getc_buf.buffered<ARRAY_SIZE(t->getc_buf.buf));
	assert(t->getc_buf.cnt > 0);
	--t->getc_buf.cnt;
	assert(t->getc_buf.buf[t->getc_buf.cnt % ARRAY_SIZE(t->getc_buf.buf)] == c);
	return c;
}

// Assembly:
pushq %rax
movq 0x1150(%rdi), %rax
incq %rax
movq %rax, 0x1150(%rdi)
cmpq $0x8, %rax
jae 0x15e8f
movq 0x1148(%rdi), %rax
testq %rax, %rax
je 0x15ea8
decq %rax
movq %rax, 0x1148(%rdi)
andl $0x7, %eax
cmpl %esi, 0x1128(%rdi,%rax,4)
jne 0x15ec1
movl %esi, %eax
popq %rcx
retq
leaq 0x564e(%rip), %rdi      # 0x1b4e4
leaq 0x54d2(%rip), %rsi      # 0x1b36f
leaq 0x5671(%rip), %rcx      # 0x1b515
pushq $0x16
jmp 0x15ed8
leaq 0x5694(%rip), %rdi      # 0x1b543
leaq 0x54b9(%rip), %rsi      # 0x1b36f
leaq 0x5658(%rip), %rcx      # 0x1b515
pushq $0x17
jmp 0x15ed8
leaq 0x568f(%rip), %rdi      # 0x1b557
leaq 0x54a0(%rip), %rsi      # 0x1b36f
leaq 0x563f(%rip), %rcx      # 0x1b515
pushq $0x19
popq %rdx
callq 0x3240
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/tokenizer.c
// Function: tokenizer_peek_token
int tokenizer_peek_token(struct tokenizer *t, struct token *tok) {
	int ret = tokenizer_next(t, tok);
	t->peek_token = *tok;
	t->peeking = 1;
	return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1616a
movups (%rbx), %xmm0
movups %xmm0, 0x1178(%r14)
movl $0x1, 0x18(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/tokenizer.c
// Function: tokenizer_register_custom_token
void tokenizer_register_custom_token(struct tokenizer*t, int tokentype, const char* str) {
	assert(tokentype >= TT_CUSTOM && tokentype < TT_CUSTOM + MAX_CUSTOM_TOKENS);
	int pos = tokentype - TT_CUSTOM;
	t->custom_tokens[pos] = str;
	if(pos+1 > t->custom_count) t->custom_count = pos+1;
}

// Assembly:
leal -0x3e8(%rsi), %eax
cmpl $0x20, %eax
jae 0x15f2e
movl %eax, %eax
movq %rdx, 0x20(%rdi,%rax,8)
addl $0xfffffc19, %esi       # imm = 0xFFFFFC19
cmpl 0x14(%rdi), %esi
jle 0x15f2d
movl %esi, 0x14(%rdi)
retq
pushq %rax
leaq 0x53f5(%rip), %rdi      # 0x1b32b
leaq 0x5432(%rip), %rsi      # 0x1b36f
leaq 0x5437(%rip), %rcx      # 0x1b37b
pushq $0x39
popq %rdx
callq 0x3240
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
cmpl $0x0, 0x18(%rdi)
jne 0x15fc8
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorl %ebp, %ebp
xorl %eax, %eax
movl %eax, (%r14)
movq %rbx, %rdi
callq 0x15dfb
cmpl $-0x1, %eax
je 0x15fbb
movq %r15, %rcx
movsbl (%rcx), %edx
testl %edx, %edx
je 0x15fae
incq %rcx
cmpl %edx, %eax
jne 0x15f99
movl (%r14), %eax
incl %eax
jmp 0x15f86
movq %rbx, %rdi
movl %eax, %esi
callq 0x15e51
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5474(%rip), %rdi      # 0x1b443
leaq 0x5399(%rip), %rsi      # 0x1b36f
leaq 0x5472(%rip), %rcx      # 0x1b44f
movl $0x14f, %edx            # imm = 0x14F
callq 0x3240
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movq %rdi, %r15
xorl %ebx, %ebx
cmpb $0xa, (%rsi)
jne 0x1600b
xorl %ebx, %ebx
cmpb $0x0, 0x1(%r14)
sete %bl
leaq 0x120(%r15), %r13
movq %r15, %rdi
callq 0x15dfb
movl %eax, %r12d
cmpl $0xa, %eax
je 0x1602a
cmpl $-0x1, %r12d
jne 0x16037
jmp 0x16082
incl 0x8(%r15)
andl $0x0, 0xc(%r15)
testl %ebp, %ebp
jne 0x16084
movq %r15, %rdi
movl %r12d, %esi
movq %r14, %rdx
callq 0x1609a
testl %eax, %eax
jne 0x16056
incl 0xc(%r15)
movb %r12b, (%r13)
incq %r13
jmp 0x16012
movb $0x0, (%r13)
movq %r14, %rdi
callq 0x3190
pushq $0x1
popq %rbx
movq %rax, %r12
subq $0x1, %r12
jb 0x16089
movsbl -0x1(%r14,%rax), %esi
movq %r15, %rdi
callq 0x15e51
movq %r12, %rax
jmp 0x16069
xorl %ebx, %ebx
movb $0x0, (%r13)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x16102
movq %rdx, %rbx
movb (%rdx), %cl
testb %cl, %cl
je 0x16102
movl %esi, %eax
movq %rdi, %r14
xorl %r15d, %r15d
pushq $0x1
popq %rbp
movsbl %cl, %edx
cmpl %edx, %eax
jne 0x160de
cmpb $0x0, 0x1(%rbx,%r15)
je 0x16102
movq %r14, %rdi
callq 0x15dfb
movb 0x1(%rbx,%r15), %cl
incq %r15
jmp 0x160bd
testb %cl, %cl
je 0x16102
movq %r15, %r12
subq $0x1, %r12
jb 0x16100
movq %r14, %rdi
movl %eax, %esi
callq 0x15e51
movsbl -0x1(%rbx,%r15), %eax
movq %r12, %r15
jmp 0x160e5
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x15dfb
cmpl $0xa, %eax
je 0x16137
cmpl $-0x1, %eax
je 0x16162
movl 0xc(%rbx), %ecx
incl %ecx
jmp 0x1613c
incl 0x8(%rbx)
xorl %ecx, %ecx
movl %ecx, 0xc(%rbx)
movq %rbx, %rdi
movl %eax, %esi
movq %r14, %rdx
callq 0x1609a
testl %eax, %eax
je 0x1611e
movq %r14, %rdi
callq 0x3190
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_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
pushq $0x1
popq %r12
xorl %r15d, %r15d
cmpq %rbx, %r14
jae 0x16aa9
callq 0x3340
movq (%rax), %rax
movsbq (%r14), %rcx
testb $0x8, 0x1(%rax,%rcx,2)
jne 0x16aa1
xorl %eax, %eax
cmpb $0x2e, %cl
jne 0x16ab2
testl %r15d, %r15d
movl %r12d, %r15d
je 0x16aa4
jmp 0x16ab2
movl %r12d, %ebp
incq %r14
jmp 0x16a78
addl %r15d, %r15d
orl %ebp, %r15d
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl %ecx, %eax
movl 0x8(%rdi), %ecx
movl %ecx, 0x4(%rsi)
subq %rdi, %rdx
movl 0xc(%rdi), %ecx
subl %edx, %ecx
addl $0x120, %ecx            # imm = 0x120
movl %ecx, 0x8(%rsi)
addq $-0x11f, %rdx           # imm = 0xFEE1
cmpq 0x1120(%rdi), %rdx
jb 0x16aec
movl $0xb, (%rsi)
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
xorl %ebx, %ebx
cmpq $0x4, %rbx
je 0x16c85
movsbq (%r14,%rbx), %r15
testq %r15, %r15
je 0x16c21
callq 0x30b0
movq (%rax), %rax
movl (%rax,%r15,4), %eax
cmpl $0x75, %eax
je 0x16c18
cmpl $0x6c, %eax
jne 0x16c85
movb %al, 0xc(%rsp,%rbx)
incq %rbx
jmp 0x16bee
cmpl $0x3, %ebx
je 0x16c52
cmpl $0x2, %ebx
je 0x16c32
cmpl $0x1, %ebx
jne 0x16c85
jmp 0x16c87
pushq $0x1
popq %rbx
cmpw $0x756c, 0xc(%rsp)      # imm = 0x756C
je 0x16c87
cmpw $0x6c75, 0xc(%rsp)      # imm = 0x6C75
je 0x16c87
cmpw $0x6c6c, 0xc(%rsp)      # imm = 0x6C6C
jne 0x16c85
jmp 0x16c87
leaq 0x4956(%rip), %rsi      # 0x1b5af
leaq 0xc(%rsp), %rdi
pushq $0x3
popq %rdx
callq 0x3310
pushq $0x1
popq %rbx
testl %eax, %eax
je 0x16c87
leaq 0x26f6(%rip), %rsi      # 0x1936a
leaq 0xc(%rsp), %rdi
pushq $0x3
popq %rdx
callq 0x3310
testl %eax, %eax
je 0x16c87
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x16ca8
movb 0xc(%rsi), %al
movb %al, (%rbx)
movb $0x0, 0x1(%rbx)
jmp 0x16cb8
testq %rdx, %rdx
je 0x16cb8
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x3570
movq %rbx, %rdi
callq 0x3190
addq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x15f08
movl (%rbx), %ecx
cmpl $0xb, %ecx
jne 0x1710f
leaq 0x475e(%rip), %rdi      # 0x1b86b
jmp 0x1711e
testl %ebp, %ebp
je 0x1712c
testl %eax, %eax
jne 0x1712c
leaq 0x4770(%rip), %rdi      # 0x1b88e
callq 0x15499
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
pushq $0x1
popq %rax
cmpl $0x9, %ecx
jne 0x17125
cmpl $0x9, 0xc(%rbx)
jne 0x17125
movl $0x20, 0xc(%rbx)
jmp 0x17125
// File: /workspace/github_cpp_makefile_star2_O2/tdv[P]boss/boss/examples/simple_component/client/main.cpp
// Function: main
int main()
{
  try
  {
    Boss::Loader Ldr("Registry.xml", "./" MAKE_MODULE_NAME("service_registry"),
                     "./" MAKE_MODULE_NAME("class_factory"));
    auto Obj = Boss::CreateObject<MyNs::ISum>(MyNs::Service::Id::Sum);
    int Res = 0;
    if (Obj->CalcSum(10, 20, &Res))
      std::cout << "Failed to calc sum." << std::endl;
    std::cout << "Sum: " << Res << std::endl;
  }
  catch (std::exception const &e)
  {
    std::cerr << "Error: " << e.what() << std::endl;
  }
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
leaq 0xa6ea8(%rip), %rsi     # 0xbe004
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x8fae0
leaq 0xa6e9f(%rip), %rsi     # 0xbe011
leaq 0x30(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x8fae0
leaq 0xa6ea2(%rip), %rsi     # 0xbe02a
leaq 0x50(%rsp), %rdi
leaq 0xd(%rsp), %rdx
callq 0x8fae0
leaq 0x70(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x30(%rsp), %rdx
leaq 0x50(%rsp), %rcx
callq 0x17356
leaq 0x50(%rsp), %rdi
callq 0x8d160
leaq 0x30(%rsp), %rdi
callq 0x8d160
leaq 0x10(%rsp), %rdi
callq 0x8d160
leaq 0x10(%rsp), %rdi
movl $0xcc46a931, %esi       # imm = 0xCC46A931
callq 0x174e3
leaq 0x30(%rsp), %rcx
andl $0x0, (%rcx)
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
pushq $0xa
popq %rsi
pushq $0x14
popq %rdx
callq *0x28(%rax)
testl %eax, %eax
je 0x17215
leaq 0xe627f(%rip), %rdi     # 0xfd480
leaq 0xa6e38(%rip), %rsi     # 0xbe040
callq 0x869b0
movq %rax, %rdi
callq 0x86290
leaq 0xe6264(%rip), %rdi     # 0xfd480
leaq 0xa6e31(%rip), %rsi     # 0xbe054
callq 0x869b0
movl 0x30(%rsp), %esi
movq %rax, %rdi
callq 0x86d50
movq %rax, %rdi
callq 0x86290
leaq 0x10(%rsp), %rdi
callq 0x17756
leaq 0x70(%rsp), %rdi
callq 0x17766
xorl %eax, %eax
addq $0x98, %rsp
popq %rbx
popq %r14
retq
movq %rdx, %r14
movq %rax, %rbx
jmp 0x172b3
movq %rdx, %r14
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x8d160
jmp 0x1727d
movq %rdx, %r14
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x8d160
jmp 0x1728f
movq %rdx, %r14
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x8d160
jmp 0x172bd
movq %rdx, %r14
movq %rax, %rbx
jmp 0x172bd
movq %rdx, %r14
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x17756
leaq 0x70(%rsp), %rdi
callq 0x17766
cmpl $0x1, %r14d
jne 0x17312
movq %rbx, %rdi
callq 0x1a650
movq %rax, %rbx
leaq 0xe608b(%rip), %rdi     # 0xfd360
leaq 0xa6d7e(%rip), %rsi     # 0xbe05a
callq 0x869b0
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x869b0
movq %rax, %rdi
callq 0x86290
callq 0x1a6c0
jmp 0x17250
movq %rax, %rbx
callq 0x1a6c0
movq %rbx, %rdi
callq 0xbaf20
movq %rax, %rdi
callq 0x177c0
// File: /workspace/github_cpp_makefile_star2_O2/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)
leaq 0x20(%rbx), %rdi
callq 0x19dd2
leaq 0x10(%rbx), %rdi
callq 0x199f2
xorl %edi, %edi
callq 0x17132
leaq 0x8(%rbx), %r14
leaq 0x18(%rbx), %rdi
callq 0x17c76
movq %r14, %rdi
callq 0x17c8c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x177cc
movq %rax, %rdi
callq 0x177c0
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x177f0
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x177f2
xorl %eax, %eax
andq $0x0, (%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
lock
incl 0xe4d06(%rip)           # 0xfc50c
movl $0x88, %edi
callq 0x1b7c0
movq %rax, %r14
movq %rax, %rdi
callq 0x17ca2
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movb $0x1, 0x10(%r14)
movq %r14, (%rbx)
movq %rsp, %rdi
andq $0x0, (%rdi)
callq 0x1786a
lock
decl 0xe4ccd(%rip)           # 0xfc50c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x1a200
jmp 0x1785a
movq %rax, %rbx
lock
decl 0xe4cab(%rip)           # 0xfc50c
movq %rbx, %rdi
callq 0xbaf20
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
pushq $-0x1
popq %rbx
lock
xaddl %ebx, 0x80(%rdi)
cmpl $0x1, %ebx
jne 0x17da8
movq %rdi, %r14
movb $0x0, 0x10(%rdi)
callq 0x17d4e
movq %r14, %rdi
callq 0x1a200
decl %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/tdv[P]boss/boss/include/plugin/../core/base.h
// Function: Boss::Base<Boss::ServiceLocator>::QueryInterface(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:
cmpl $0x2cc77d66, %esi       # imm = 0x2CC77D66
je 0x17dc4
cmpl $0x29d4d8a5, %esi       # imm = 0x29D4D8A5
jne 0x17dd5
leaq 0x8(%rdi), %rax
movq %rax, (%rdx)
lock
incl 0x80(%rdi)
xorl %eax, %eax
retq
pushq $0x3
popq %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movl %esi, 0x4(%rsp)
pushq $0x5
popq %rbp
testq %rdx, %rdx
je 0x17e39
movq %rdx, %r14
cmpq $0x0, (%rdx)
jne 0x17e39
movq %rdi, %r15
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x1811c
addq $0x40, %r15
leaq 0x4(%rsp), %rsi
movq %r15, %rdi
callq 0x18130
testq %rax, %rax
je 0x17e2e
addq $0x10, %rax
movq %rax, %rdi
movq %r14, %rsi
callq 0x180fe
movl %eax, %ebp
jmp 0x17e31
pushq $0x2
popq %rbp
movq %rbx, %rdi
callq 0x14670
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x14670
movq %r14, %rdi
callq 0xbaf20
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x17e97
movq %rdx, %r14
movq %rdi, %r15
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x1811c
addq $0x40, %r15
leaq 0x4(%rsp), %rsi
movq %r15, %rdi
callq 0x18130
testq %rax, %rax
je 0x17e9c
pushq $0x2
popq %rbp
jmp 0x17eb6
pushq $0x5
popq %rbp
jmp 0x17ebe
leaq 0x4(%rsp), %rsi
movq %r15, %rdi
callq 0x181e0
xorl %ebp, %ebp
movq %rax, %rdi
movq %r14, %rsi
callq 0x181ac
movq %rbx, %rdi
callq 0x14670
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x17ecd
movq %rax, %r14
movq %rbx, %rdi
callq 0x14670
movq %r14, %rdi
callq 0xbaf20
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x4(%rsp), %r15
movl %esi, (%r15)
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x1811c
addq $0x40, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x18130
testq %rax, %rax
je 0x17f21
xorl %ebp, %ebp
movq %r14, %rdi
movq %rax, %rsi
callq 0x18500
jmp 0x17f24
pushq $0x2
popq %rbp
movq %rbx, %rdi
callq 0x14670
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x14670
movq %r14, %rdi
callq 0xbaf20
// File: /workspace/github_cpp_makefile_star2_O2/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 0x18986
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x18a5e
leaq 0x10(%rsp), %rdi
callq 0x180d2
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x1873a
movq %rax, (%rbx)
leaq 0x8(%rsp), %rdi
andq $0x0, (%rdi)
callq 0x18880
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x1a4f0
movq %rax, %r14
leaq 0xa5a1c(%rip), %rsi     # 0xbe168
movq %rax, %rdi
callq 0x18a84
leaq 0xdd40d(%rip), %rsi     # 0xf5b68
leaq 0xb9ce(%rip), %rdx      # 0x24130
movq %r14, %rdi
callq 0x1b540
movq %rax, %rbx
jmp 0x1877a
movq %rax, %rbx
movq %r14, %rdi
callq 0x1a550
leaq 0x8(%rsp), %rdi
callq 0x18880
jmp 0x18793
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x180d2
movq %rbx, %rdi
callq 0xbaf20
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x18963
callq 0x146e0
testl %eax, %eax
jne 0x18969
andq $0x0, (%rbx)
popq %rbx
retq
leaq 0xa5788(%rip), %rdi     # 0xbe0f8
leaq 0xa57a1(%rip), %rsi     # 0xbe118
leaq 0xa57bf(%rip), %rcx     # 0xbe13d
pushq $0x4f
popq %rdx
callq 0x14150
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x30, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
andq $0x0, 0x8(%rsp)
leaq 0xa57da(%rip), %rsi     # 0xbe17d
leaq 0x10(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x8fae0
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x18a9a
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x8d160
leaq 0x8(%rsp), %rsi
movl %ebp, %edi
callq *%r14
testl %eax, %eax
jne 0x189fa
leaq 0x8(%rsp), %rdi
movq (%rdi), %rax
movq %rax, (%rbx)
andq $0x0, (%rdi)
callq 0x180d2
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x1a4f0
movq %rax, %r14
leaq 0xa5782(%rip), %rsi     # 0xbe18e
movq %rax, %rdi
callq 0x18b86
leaq 0xdd14d(%rip), %rsi     # 0xf5b68
leaq 0xb70e(%rip), %rdx      # 0x24130
movq %r14, %rdi
callq 0x1b540
movq %rax, %rbx
movq %r14, %rdi
callq 0x1a550
jmp 0x18a4b
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x8d160
jmp 0x18a4b
jmp 0x18a48
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x180d2
movq %rbx, %rdi
callq 0xbaf20
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x40, %rsp
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x18ac3
movq %rsi, %r14
movq (%rsi), %rsi
callq 0x145e0
testq %rax, %rax
je 0x18af3
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x1a4f0
movq %rax, %rbx
leaq 0xa56d2(%rip), %rsi     # 0xbe1a7
movq %rax, %rdi
callq 0x18b9c
leaq 0xdd044(%rip), %rsi     # 0xf5b28
leaq 0xb645(%rip), %rdx      # 0x24130
movq %rbx, %rdi
callq 0x1b540
pushq $0x10
popq %rdi
callq 0x1a4f0
movq %rax, %rbx
leaq 0xa56ba(%rip), %rsi     # 0xbe1bf
movq %rsp, %rdi
movq %r14, %rdx
callq 0x188af
leaq 0xa56b3(%rip), %rdx     # 0xbe1ca
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x18890
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x18926
xorl %ebp, %ebp
leaq 0xdcfeb(%rip), %rsi     # 0xf5b28
leaq 0xb5ec(%rip), %rdx      # 0x24130
movq %rbx, %rdi
callq 0x1b540
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x8d160
jmp 0x18b61
movq %rax, %r14
movb $0x1, %bpl
movq %rsp, %rdi
callq 0x8d160
testb %bpl, %bpl
jne 0x18b75
jmp 0x18b7d
jmp 0x18b72
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a550
movq %r14, %rdi
callq 0xbaf20
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x5
popq %rbp
testq %rdx, %rdx
je 0x18ea7
movq %rdx, %rbx
cmpq $0x0, (%rdx)
jne 0x18ea7
movq %rdi, %r14
cmpq $0x0, 0x8(%rdi)
je 0x18eb2
testl %esi, %esi
je 0x18e4e
movl %esi, %esi
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x19312
pushq $0x2
popq %rbp
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rdx
subq %rdi, %rdx
movq 0x8(%r14), %rcx
pushq $0x1
popq %rsi
callq 0x14470
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x18e9d
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rdx
subq %rcx, %rdx
cmpq %rdx, %rax
ja 0x18e9d
leaq 0x28(%rsp), %rsi
movq %rcx, (%rsi)
movq %rsp, %rdi
leaq 0x8(%rsp), %rdx
callq 0x19364
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x18e92
movq (%rdi), %rax
movl $0xaaa58dc, %esi        # imm = 0xAAA58DC
movq %rbx, %rdx
callq *0x28(%rax)
movl %eax, %ebp
jmp 0x18e95
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
movq %rsp, %rdx
andl $0x0, (%rdx)
leaq 0x10(%rsp), %rdi
callq 0x1927e
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x18e83
movq (%rdi), %rax
movl $0xaaa58dc, %esi        # imm = 0xAAA58DC
movq %rbx, %rdx
callq *0x28(%rax)
movl %eax, %ebp
jmp 0x18e86
pushq $0x2
popq %rbp
leaq 0x10(%rsp), %rdi
callq 0x19302
jmp 0x18ea7
pushq $0x2
popq %rbp
movq %rsp, %rdi
callq 0x19302
leaq 0x10(%rsp), %rdi
callq 0x19716
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xa53f0(%rip), %rdi     # 0xbe2a9
leaq 0xa5338(%rip), %rsi     # 0xbe1f8
leaq 0xa53fd(%rip), %rcx     # 0xbe2c4
pushq $0x3e
popq %rdx
callq 0x14150
movq %rax, %rbx
movq %rsp, %rdi
callq 0x19302
jmp 0x18edf
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x19716
jmp 0x18eff
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x19302
jmp 0x18eff
jmp 0x18efc
movq %rax, %rbx
movq %rbx, %rdi
callq 0x1a650
callq 0x1a6c0
pushq $0x2
popq %rbp
jmp 0x18ea7
nop