LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/cs_parser.cpp
// Function: isPartOfExpression(ccInternalList*, int)
int isPartOfExpression(ccInternalList *targ, int j) {
  if (sym.get_type(targ->script[j]) == SYM_NEW)
    return 1;
  if (sym.get_type(targ->script[j]) < NOTEXPRESSION)
    return 1;
  // static member access
  if ((j < targ->length - 1) &&
      (sym.get_type(targ->script[j + 1]) == SYM_DOT) &&
      (sym.get_type(targ->script[j]) == SYM_VARTYPE))
    return 1;
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
movq 0x8(%rdi), %rax
movslq %esi, %r15
movl (%rax,%r15,8), %esi
leaq 0x1ea78(%rip), %rdi     # 0x256f0
callq 0xfe60
pushq $0x1
popq %rbx
cmpl $0x35, %eax
je 0x6cdc
movq 0x8(%r14), %rax
movl (%rax,%r15,8), %esi
leaq 0x1ea5c(%rip), %rdi     # 0x256f0
callq 0xfe60
cmpl $0x17, %eax
jl 0x6cdc
movl (%r14), %eax
decl %eax
cmpl %ebp, %eax
jle 0x6cda
movq 0x8(%r14), %rax
movl 0x8(%rax,%r15,8), %esi
leaq 0x1ea39(%rip), %rdi     # 0x256f0
callq 0xfe60
cmpl $0x9, %eax
jne 0x6cda
movq 0x8(%r14), %rax
movl (%rax,%r15,8), %esi
leaq 0x1ea20(%rip), %rdi     # 0x256f0
callq 0xfe60
cmpl $0x2e, %eax
je 0x6cdc
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/cs_parser.cpp
// Function: find_lowest_bonding_operator(long*, int)
int find_lowest_bonding_operator(long*slist,int listlen) {
  int k,blevel=0,plevel=0;
  int lowestis = 0,lowestat = -1;
  for (k=0;k<listlen;k++) {
    int thisType = sym.get_type(slist[k]);
    if (thisType == SYM_OPENBRACKET)
      blevel++;
    else if (thisType == SYM_CLOSEBRACKET)
      blevel--;
    else if (thisType == SYM_OPENPARENTHESIS)
      plevel++;
    else if (thisType == SYM_CLOSEPARENTHESIS)
      plevel--;

    if (((thisType == SYM_OPERATOR) || (thisType == SYM_NEW)) &&
        (plevel == 0) && (blevel == 0)) {
      // .ssize stores the precedence
      int thisIsTheOperator = 0;
      if (ccGetOption(SCOPT_LEFTTORIGHT)) {
        // left-to-right; find the right-most operator, then
        // they will be recursively processed left
        if (sym.entries[slist[k]].ssize >= lowestis)
          thisIsTheOperator = 1;
      }
      else {
        // right-to-left; find the left-most operator, then
        // they will be recursively processed right
        if (sym.entries[slist[k]].ssize > lowestis)
          thisIsTheOperator = 1;
      }
      if (thisIsTheOperator) {
        lowestis = sym.entries[slist[k]].ssize;
        lowestat = k;
      }
    }
  }
  return lowestat;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
xorl %r13d, %r13d
testl %esi, %esi
cmovlel %r13d, %ebx
movq %rdi, %r14
pushq $-0x1
popq %rax
movl %eax, 0x4(%rsp)
xorl %ebp, %ebp
xorl %r15d, %r15d
xorl %r12d, %r12d
cmpq %r13, %rbx
je 0x6dae
movl (%r14,%r13,8), %esi
leaq 0x1e9cb(%rip), %rdi     # 0x256f0
callq 0xfe60
leal -0x5(%rax), %ecx
cmpl $0x3, %ecx
ja 0x6d52
leaq 0x11ae3(%rip), %rdx     # 0x1881c
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
incl %r15d
jmp 0x6d52
incl %ebp
jmp 0x6d52
decl %ebp
jmp 0x6d52
decl %r15d
cmpl $0x3, %eax
setne %cl
cmpl $0x35, %eax
setne %al
testb %al, %cl
jne 0x6d9f
testl %r15d, %r15d
jne 0x6d9f
testl %ebp, %ebp
jne 0x6d9f
pushq $0x40
popq %rdi
callq 0x127df
imulq $0xb0, (%r14,%r13,8), %rcx
leaq 0x1e96e(%rip), %rdx     # 0x256f0
movq 0x28(%rdx), %rdx
movq 0x38(%rdx,%rcx), %rcx
movslq %r12d, %rdx
testl %eax, %eax
je 0x6da7
cmpq %rdx, %rcx
jl 0x6d9f
movl %ecx, %r12d
movl %r13d, 0x4(%rsp)
incq %r13
jmp 0x6d11
cmpq %rdx, %rcx
jg 0x6d97
jmp 0x6d9f
movl 0x4(%rsp), %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/cs_parser.cpp
// Function: is_string(int)
int is_string(int valtype) {

  if (strcmp(sym.get_name(valtype),"const string")==0)
    return 1;
  if (strcmp(sym.get_name(valtype),"string")==0)
    return 1;
  if (strcmp(sym.get_name(valtype),"char*")==0)
    return 1;

  return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x1e923(%rip), %rdi     # 0x256f0
movl %ebx, %esi
callq 0x10b48
leaq 0x12208(%rip), %rsi     # 0x18fe3
movq %rax, %rdi
callq 0x3450
pushq $0x1
popq %rbp
testl %eax, %eax
je 0x6e30
leaq 0x1e8ff(%rip), %rdi     # 0x256f0
movl %ebx, %esi
callq 0x10b48
leaq 0x14604(%rip), %rsi     # 0x1b403
movq %rax, %rdi
callq 0x3450
testl %eax, %eax
je 0x6e30
leaq 0x1e8de(%rip), %rdi     # 0x256f0
movl %ebx, %esi
callq 0x10b48
leaq 0x121d0(%rip), %rsi     # 0x18ff0
movq %rax, %rdi
callq 0x3450
xorl %ebp, %ebp
testl %eax, %eax
sete %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/cs_parser.cpp
// Function: DoNullCheckOnStringInAXIfNecessary(ccCompiledScript*, int, int)
void DoNullCheckOnStringInAXIfNecessary(ccCompiledScript *scrip, int valTypeFrom, int valTypeTo) {

  // Convert normal literal string into String object
  if (((valTypeFrom & (~STYPE_POINTER)) == sym.stringStructSym) &&
     ((valTypeTo & (~STYPE_CONST)) == sym.normalStringSym)) {

    scrip->write_cmd1(SCMD_CHECKNULLREG, SREG_AX);
  }

}

// Assembly:
andl $0xbfffffff, %esi       # imm = 0xBFFFFFFF
leaq 0x1dfb7(%rip), %rax     # 0x256f0
cmpl 0x20(%rax), %esi
jne 0x7754
andl $0xdfffffff, %edx       # imm = 0xDFFFFFFF
cmpl 0x10(%rax), %edx
jne 0x7754
pushq $0x43
popq %rsi
pushq $0x3
popq %rdx
jmp 0x11e4a
retq
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/cs_parser.cpp
// Function: PerformStringConversionInAX(ccCompiledScript*, int*, int)
void PerformStringConversionInAX(ccCompiledScript *scrip, int *valTypeFrom, int valTypeTo) {

  // Convert normal literal string into String object
  if (((*valTypeFrom & (~STYPE_CONST)) == sym.normalStringSym) &&
     ((valTypeTo & (~STYPE_POINTER)) == sym.stringStructSym)) {

    scrip->write_cmd1(SCMD_CREATESTRING, SREG_AX);
    *valTypeFrom = STYPE_POINTER | sym.stringStructSym;
  }

}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl $0xdfffffff, %eax       # imm = 0xDFFFFFFF
andl (%rsi), %eax
leaq 0x1df89(%rip), %r14     # 0x256f0
cmpl 0x10(%r14), %eax
jne 0x7792
andl $0xbfffffff, %edx       # imm = 0xBFFFFFFF
cmpl 0x20(%r14), %edx
jne 0x7792
movq %rsi, %rbx
pushq $0x40
popq %rsi
pushq $0x3
popq %rdx
callq 0x11e4a
movl $0x40000000, %eax       # imm = 0x40000000
orl 0x20(%r14), %eax
movl %eax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/cs_parser.cpp
// Function: set_ax_scope(ccCompiledScript*, int)
void set_ax_scope(ccCompiledScript *scrip, int syoffs) {
  // "null" is a global var
  if (sym.get_type(syoffs) == SYM_NULL)
    scrip->ax_val_scope = SYM_GLOBALVAR;
  // if it's a parameter, pretend it's a global var
  // this allows it to be returned back from the function
  else if (sym.entries[syoffs].flags & SFLG_PARAMETER)
    scrip->ax_val_scope = SYM_GLOBALVAR;
  else
    scrip->ax_val_scope = sym.entries[syoffs].stype;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x1df46(%rip), %r14     # 0x256f0
movq %r14, %rdi
callq 0xfe60
pushq $0x1
popq %rcx
cmpl $0x15, %eax
je 0x77d6
movslq %ebp, %rdx
movq 0x28(%r14), %rax
imulq $0xb0, %rdx, %rdx
testb $0x1, 0x28(%rax,%rdx)
jne 0x77d6
addq %rdx, %rax
movswl 0x20(%rax), %ecx
movl %ecx, 0x8d50(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/cs_parser.cpp
// Function: findClosingBracketOffs(int, long*, int)
int findClosingBracketOffs(int openBracketOffs, long *symlist, int slilen) {
  int endof,braclevel=0;
  for (endof = openBracketOffs + 1; endof < slilen; endof++) {
    int symtype = sym.get_type(symlist[endof]);
    if ((symtype == SYM_OPENBRACKET) || (symtype == SYM_OPENPARENTHESIS))
      braclevel++;
    if ((symtype == SYM_CLOSEBRACKET) || (symtype == SYM_CLOSEPARENTHESIS)) {
      braclevel--;
      if (braclevel < 0) break;
    }
  }
  return endof;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq %edi, %r12
movslq %edx, %r13
leal 0x1(%r12), %ebx
cmpl %ebx, %r13d
cmovgl %r13d, %ebx
movq %rsi, %r14
incq %r12
xorl %ebp, %ebp
leaq 0x1dee3(%rip), %r15     # 0x256f0
cmpq %r13, %r12
jge 0x7845
movl (%r14,%r12,8), %esi
movq %r15, %rdi
callq 0xfe60
movl %eax, %ecx
andl $-0x3, %ecx
xorl %edx, %edx
cmpl $0x5, %ecx
sete %dl
addl %edx, %ebp
cmpl $0x8, %eax
je 0x7837
cmpl $0x6, %eax
jne 0x783d
testl %ebp, %ebp
jle 0x7842
decl %ebp
incq %r12
jmp 0x780d
movl %r12d, %ebx
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/cs_parser.cpp
// Function: findOpeningBracketOffs(int, long*)
int findOpeningBracketOffs(int closeBracketOffs, long *symlist) {
  int endof,braclevel=0;
  for (endof = closeBracketOffs - 1; endof >= 0; endof--) {
    int symtype = sym.get_type(symlist[endof]);
    if ((symtype == SYM_OPENBRACKET) || (symtype == SYM_OPENPARENTHESIS)) {
      braclevel--;
      if (braclevel < 0) break;
    }
    if ((symtype == SYM_CLOSEBRACKET) || (symtype == SYM_CLOSEPARENTHESIS))
      braclevel++;
  }
  return endof;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movl %edi, %r15d
xorl %ebp, %ebp
leaq 0x1de83(%rip), %r14     # 0x256f0
testl %r15d, %r15d
jle 0x78a5
leaq -0x1(%r15), %r12
movl %r12d, %eax
movl (%rbx,%rax,8), %esi
movq %r14, %rdi
callq 0xfe60
movl %eax, %ecx
andl $-0x3, %ecx
cmpl $0x5, %ecx
jne 0x7894
testl %ebp, %ebp
jle 0x78a5
decl %ebp
cmpl $0x8, %eax
je 0x789e
cmpl $0x6, %eax
jne 0x78a0
incl %ebp
movq %r12, %r15
jmp 0x786d
decl %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/cs_parser.cpp
// Function: extractPathIntoParts(VariableSymlist*, int, long*)
int extractPathIntoParts(VariableSymlist *variablePath, int slilen, long *syml) {
  int variablePathSize = 0;
  int lastOffs = 0;
  int pp;

  // Separate out syml into a VariablePath for the clause
  // between each dot. If it's just a simple variable access,
  // we will only create one.
  for (pp = 0; pp < slilen; pp++) {
    if ((sym.get_type(syml[pp]) == SYM_OPENBRACKET) ||
        (sym.get_type(syml[pp]) == SYM_OPENPARENTHESIS)) {
      // an array index, skip it
      pp = findClosingBracketOffs(pp, syml, slilen);
    }

    int createPath = 0;

    if (sym.get_type(syml[pp]) == SYM_DOT) {
      createPath = 1;
    }
    else if (pp >= slilen - 1) {
      // end of data stream, store the last bit
      pp++;
      createPath = 1;
    }

    if (createPath) {
      if (variablePathSize >= MAX_VARIABLE_PATH) {
        cc_error("variable path too long");
        return -1;
      }
      VariableSymlist *vpp = &variablePath[variablePathSize];
      vpp->init(pp - lastOffs);
      for (int ee = 0; ee < vpp->len; ee++) {
        vpp->syml[ee] = syml[lastOffs + ee];
      }
      lastOffs = pp + 1;
      variablePathSize++;
    }
  }

  return variablePathSize;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, 0x10(%rsp)
leal -0x1(%r15), %eax
movl %eax, 0xc(%rsp)
leaq 0x1de14(%rip), %r13     # 0x256f0
xorl %r12d, %r12d
xorl %ebx, %ebx
movl %ebx, 0x4(%rsp)
movl %ebx, %ebp
cmpl %r15d, %ebp
jge 0x79c5
movslq %ebp, %rbx
movl (%r14,%rbx,8), %esi
movq %r13, %rdi
callq 0xfe60
cmpl $0x7, %eax
je 0x7915
movl (%r14,%rbx,8), %esi
movq %r13, %rdi
callq 0xfe60
cmpl $0x5, %eax
jne 0x7927
movl %ebp, %edi
movq %r14, %rsi
movl %r15d, %edx
callq 0x77e1
movl %eax, %ebp
movslq %eax, %rbx
movl (%r14,%rbx,8), %esi
movq %r13, %rdi
callq 0xfe60
cmpl $0x9, %eax
je 0x7945
leal 0x1(%rbp), %ebx
cmpl 0xc(%rsp), %ebp
movl %ebx, %ebp
jl 0x78e7
jmp 0x7947
movl %ebp, %ebx
cmpl $0x9, %r12d
ja 0x79b3
movl %r12d, 0x8(%rsp)
movl %r12d, %r12d
shlq $0x4, %r12
movq 0x10(%rsp), %rax
leaq (%rax,%r12), %rbp
movl %ebx, %esi
subl 0x4(%rsp), %esi
movq %rbp, %rdi
callq 0xe98c
movq 0x10(%rsp), %rax
movl (%rax,%r12), %eax
movslq 0x4(%rsp), %rcx
testl %eax, %eax
movl $0x0, %edx
cmovlel %edx, %eax
leaq (%r14,%rcx,8), %rcx
xorl %edx, %edx
cmpq %rdx, %rax
je 0x79a4
movq (%rcx,%rdx,8), %rsi
movq 0x8(%rbp), %rdi
movq %rsi, (%rdi,%rdx,8)
incq %rdx
jmp 0x798e
incl %ebx
movl 0x8(%rsp), %r12d
incl %r12d
jmp 0x78e1
leaq 0x11812(%rip), %rdi     # 0x191cc
xorl %eax, %eax
callq 0xf258
pushq $-0x1
popq %r12
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/cs_parser.cpp
// Function: get_readcmd_for_size(int, int)
int get_readcmd_for_size(int sizz, int writeinstead) {
  int readcmd = SCMD_MEMREAD;
  if (writeinstead) {
    readcmd = SCMD_MEMWRITE;
    if (sizz == 1)
      readcmd = SCMD_MEMWRITEB;
    else if (sizz == 2)
      readcmd = SCMD_MEMWRITEW;
    }
  else if (sizz == 1)
    readcmd = SCMD_MEMREADB;
  else if (sizz == 2)
    readcmd = SCMD_MEMREADW;

  if (sizz!=0)
    readcmd_lastcalledwith = sizz;
  return readcmd;
  }

// Assembly:
testl %edi, %edi
je 0x79e1
movl %edi, 0x1dcdf(%rip)     # 0x256c0
cmpl $0x2, %edi
pushq $0x19
popq %rax
pushq $0x7
popq %rcx
cmovel %eax, %ecx
pushq $0x1b
popq %rax
pushq $0x8
popq %rdx
cmovel %eax, %edx
cmpl $0x1, %edi
pushq $0x18
popq %rdi
cmovnel %ecx, %edi
pushq $0x1a
popq %rax
cmovnel %edx, %eax
testl %esi, %esi
cmovel %edi, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/cs_parser.cpp
// Function: isRawPointer(int)
static int isRawPointer(int n) {
  return sym.entries[n].vartype == sym.normalIntSym &&
         sym.entries[n].flags & SFLG_ARRAY &&
         sym.entries[n].arrsize == 0 &&
         (sym.entries[n].flags & SFLG_DYNAMICARRAY) == 0;
}

// Assembly:
movslq %edi, %rax
leaq 0x1c969(%rip), %rsi     # 0x256f0
movq 0x28(%rsi), %rcx
imulq $0xb0, %rax, %rdx
movswl 0x30(%rcx,%rdx), %edi
xorl %eax, %eax
cmpl %edi, (%rsi)
jne 0x8db0
addq %rdx, %rcx
movq 0x28(%rcx), %rdx
testb $0x2, %dl
je 0x8db0
cmpq $0x0, 0x48(%rcx)
je 0x8db1
retq
xorl %eax, %eax
btl $0x12, %edx
setae %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/cs_parser.cpp
// Function: cc_compile(char const*, ccCompiledScript*)
int cc_compile(const char*inpl, ccCompiledScript*scrip) {
    int toret = 0;
   /* this block of code until after free() is commented out in upstream ags,
      they replaced it with a C# version */
    /* this malloc might not alloc enough memory */
    char*mainbuf=(char*)malloc(strlen(inpl)+5000);
    ccError = 0;
    // run the preprocessor on the code
    cc_preprocess(inpl, mainbuf);
    if (ccError) return -1;
    // now, compile the preprocessed code
    if (__cc_compile_file(mainbuf,scrip))
    toret=-1;
    free(mainbuf);

    return toret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
callq 0x3190
leaq 0x1388(%rax), %rdi
callq 0x3430
movq %rax, %r14
leaq 0x16f49(%rip), %r12     # 0x256d0
andl $0x0, (%r12)
movq %r15, %rdi
movq %rax, %rsi
callq 0x15c3d
cmpl $0x0, (%r12)
je 0xe7a3
pushq $-0x1
popq %rbx
jmp 0xe7bc
movq %r14, %rdi
movq %rbx, %rsi
callq 0xac64
xorl %ebx, %ebx
negl %eax
sbbl %ebx, %ebx
movq %r14, %rdi
callq 0x33a0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/cc_treemap.cpp
// Function: ccTreeMap::findValue(char const*)
int ccTreeMap::findValue(const char *key) {
	if (!key || strlen(key) <= 0) { return -1; }
    std::string cppkey(key);
    if (this->storage.count(cppkey) <= 0) { return -1; }
    return this->storage[cppkey];
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
pushq $-0x1
popq %rbp
testq %rsi, %rsi
je 0xf4cc
cmpb $0x0, (%rsi)
je 0xf4cc
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rdi
callq 0xe8d6
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf564
testq %rax, %rax
je 0xf4bf
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0xf57e
movl (%rax), %ebp
jmp 0xf4c2
pushq $-0x1
popq %rbp
leaq 0x10(%rsp), %rdi
callq 0x31a0
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x31a0
movq %rbx, %rdi
callq 0x3560
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/cc_internallist.cpp
// Function: ccInternalList::peeknext()
long ccInternalList::peeknext() {
    int tpos = pos;
	// this should work even if 3 bytes aren't remaining
	while (isPosValid(tpos) && (script[tpos] == SCODE_META)) {
        tpos+=3;
	}

	if (isPosValid(tpos)) {
		return script[tpos];
	} else {
        return SCODE_INVALID;
	}
}

// Assembly:
movl 0x10(%rdi), %edx
movl (%rdi), %esi
movq 0x8(%rdi), %rcx
pushq $-0x1
popq %rax
movq %rdx, %rdi
testl %edx, %edx
js 0xfc82
cmpl %edi, %esi
jle 0xfc82
cmpq $-0x2, (%rcx,%rdi,8)
jne 0xfc7c
addq $0x3, %rdi
jmp 0xfc67
movl %edi, %eax
movq (%rcx,%rax,8), %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/cc_internallist.cpp
// Function: ccInternalList::getnext()
long ccInternalList::getnext() {
    // process line numbers internally
    while (isPosValid(pos) && script[pos] == SCODE_META) {
		long bytesRemaining = length - pos;
		if (bytesRemaining >= 3) {
			if (script[pos+1] == SMETA_LINENUM) {
				currentline = script[pos+2];
			} else if (script[pos+1] == SMETA_END) {
				lineAtEnd = currentline;
				if (cancelCurrentLine) {
					currentline = -10;
				}
                // TODO DEFECT?: If we break, we return SCODE_META *and* increase pos, so next getnext will return SMETA_END.
				break;
			}
		}
        pos+=3;
    }
    if (pos >= length) {
		if (cancelCurrentLine) {
            currentline = -10;
		}
        return SCODE_INVALID;
    }

	if (isPosValid(pos)) {
		return script[pos++];
	} else {
        return SCODE_INVALID;
	}
}

// Assembly:
movl 0x10(%rdi), %r8d
movq 0x8(%rdi), %rax
movl %r8d, %r9d
negl %r9d
leaq 0x15b17(%rip), %rcx     # 0x257b0
movq %r8, %rdx
movl (%rdi), %esi
testl %r8d, %r8d
js 0xfcf3
cmpl %edx, %esi
jle 0xfcf3
cmpq $-0x2, (%rax,%rdx,8)
jne 0xfcf3
leal (%r9,%rsi), %r10d
cmpl $0x3, %r10d
jl 0xfcd1
movq 0x8(%rax,%rdx,8), %r10
cmpq $0x1, %r10
je 0xfccb
cmpq $0x2, %r10
jne 0xfcd1
jmp 0xfcde
movl 0x10(%rax,%rdx,8), %esi
movl %esi, (%rcx)
addq $0x3, %rdx
movl %edx, 0x10(%rdi)
addl $-0x3, %r9d
jmp 0xfc9c
movl (%rcx), %r8d
movl %r8d, 0x14(%rdi)
cmpl $0x0, 0x18(%rdi)
je 0xfcf3
movl $0xfffffff6, (%rcx)     # imm = 0xFFFFFFF6
movl (%rdi), %esi
cmpl %esi, %edx
jge 0xfd08
testl %edx, %edx
js 0xfd18
leal 0x1(%rdx), %ecx
movl %ecx, 0x10(%rdi)
movl %edx, %ecx
movq (%rax,%rcx,8), %rax
retq
pushq $-0x1
popq %rax
cmpl $0x0, 0x18(%rdi)
je 0xfd07
movl $0xfffffff6, (%rcx)     # imm = 0xFFFFFFF6
retq
pushq $-0x1
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/cc_internallist.cpp
// Function: ccInternalList::write(int)
void ccInternalList::write(int value) {
    if ((length+1) * sizeof(long) >= (unsigned long)allocated) {

		if (allocated < 1000) {
            allocated += 1000;
		} else {
            allocated *= 2;
		}

        script = (long*)realloc(script, allocated);
		// TODO: this doesn't check realloc result
    }
    script[length] = value;
    length ++;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movslq (%rdi), %rcx
leaq 0x8(,%rcx,8), %rdx
movslq 0x4(%rdi), %rax
cmpq %rax, %rdx
jae 0xfd44
movq %rcx, %rdx
incq %rdx
movq 0x8(%rbx), %rax
jmp 0xfd6c
leal (%rax,%rax), %ecx
movl $0x3e8, %edx            # imm = 0x3E8
leal (%rax,%rdx), %esi
cmpl %edx, %eax
cmovgel %ecx, %esi
movl %esi, 0x4(%rbx)
movq 0x8(%rbx), %rdi
movslq %esi, %rsi
callq 0x3530
movq %rax, 0x8(%rbx)
movl (%rbx), %ecx
leal 0x1(%rcx), %edx
movslq %ebp, %rsi
movslq %ecx, %rcx
movq %rsi, (%rax,%rcx,8)
movl %edx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/cc_symboltable.cpp
// Function: symbolTable::get_type(int)
int symbolTable::get_type(int ii) {
    // just return the real type, regardless of pointerness/constness
    ii &= STYPE_MASK;
	if ((ii < 0) || ((size_t)ii >= entries.size())) { return -1; }
    return entries[ii].stype;
}

// Assembly:
andl $0xfffffff, %esi        # imm = 0xFFFFFFF
movq 0x28(%rdi), %rcx
movq 0x30(%rdi), %rax
subq %rcx, %rax
movl $0xb0, %edi
cqto
idivq %rdi
cmpq %rsi, %rax
jbe 0xfe8d
imulq $0xb0, %rsi, %rax
movswl 0x20(%rcx,%rax), %eax
retq
pushq $-0x1
popq %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/cc_symboltable.cpp
// Function: symbolTable::add_ex(char const*, int, char)
int symbolTable::add_ex(const char*nta,int typo,char sizee) {
	if (find(nta) >= 0) {
		return -1;
	}

	int p_value = entries.size();

	SymbolTableEntry entry = {};
	entry.sname = std::string(nta);
    entry.stype = typo;
    entry.flags = 0;
    entry.vartype = 0;
    entry.soffs = 0;
	entry.ssize = sizee;
	entry.sscope = 0;
    entry.arrsize = 0;
    entry.extends = 0;
	entry.funcparamtypes = std::vector<unsigned long>(MAX_FUNCTION_PARAMETERS + 1);
    entry.funcParamDefaultValues = std::vector<int>(MAX_FUNCTION_PARAMETERS + 1);
	entry.funcParamHasDefaultValues = std::vector<bool>(MAX_FUNCTION_PARAMETERS + 1);
	entries.push_back(entry);

    symbolTree.addEntry(nta, p_value);
    return p_value;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movl %ecx, %ebp
movl %edx, %r13d
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x70(%rdi), %r14
movq %r14, %rdi
callq 0xf474
testl %eax, %eax
js 0x1065d
pushq $-0x1
popq %r14
jmp 0x107ef
movq %r14, 0x10(%rsp)
movq 0x30(%r12), %rax
subq 0x28(%r12), %rax
movl $0xb0, %ecx
cqto
idivq %rcx
movq %rax, 0x18(%rsp)
leaq 0x58(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
andw $0x0, 0x10(%rax)
andq $0x0, 0x18(%rax)
andw $0x0, 0x20(%rax)
andl $0x0, 0x24(%rax)
andq $0x0, 0x28(%rax)
andw $0x0, 0x30(%rax)
andq $0x0, 0x38(%rax)
andw $0x0, 0x40(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rax)
movups %xmm0, 0x58(%rax)
movups %xmm0, 0x68(%rax)
movups %xmm0, 0x78(%rax)
movups %xmm0, 0x88(%rax)
andq $0x0, 0x98(%rax)
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %rbx, %rsi
callq 0xe8d6
leaq 0x48(%rsp), %r14
leaq 0x20(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x33d0
movq %r15, %rdi
callq 0x31a0
movw %r13w, 0x20(%r14)
andq $0x0, 0x28(%r14)
andw $0x0, 0x30(%r14)
andl $0x0, 0x34(%r14)
movsbq %bpl, %rax
movq %rax, 0x38(%r14)
andw $0x0, 0x40(%r14)
andq $0x0, 0x48(%r14)
andw $0x0, 0x50(%r14)
leaq 0x20(%rsp), %rdi
pushq $0x10
popq %rsi
leaq 0xf(%rsp), %rdx
callq 0x10d36
leaq 0xa0(%rsp), %rdi
leaq 0x20(%rsp), %r14
movq %r14, %rsi
callq 0x11446
movq %r14, %rdi
callq 0x11310
leaq 0x20(%rsp), %rdi
pushq $0x10
popq %rsi
leaq 0xf(%rsp), %rdx
callq 0x10d88
leaq 0xb8(%rsp), %rdi
leaq 0x20(%rsp), %r14
movq %r14, %rsi
callq 0x11506
movq %r14, %rdi
callq 0xea10
leaq 0x20(%rsp), %rdi
pushq $0x10
popq %rsi
leaq 0xf(%rsp), %rdx
callq 0x10dda
addq $0x28, %r12
leaq 0xd0(%rsp), %rdi
leaq 0x20(%rsp), %r14
movq %r14, %rsi
callq 0x10dee
movq %r14, %rdi
callq 0x10e40
leaq 0x48(%rsp), %rsi
movq %r12, %rdi
callq 0x10e50
movq 0x18(%rsp), %r14
movq 0x10(%rsp), %rdi
movq %rbx, %rsi
movl %r14d, %edx
callq 0xf4ec
leaq 0x48(%rsp), %rdi
callq 0x10e80
movl %r14d, %eax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1080c
jmp 0x1080c
jmp 0x1080c
jmp 0x1080c
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x10e80
movq %rbx, %rdi
callq 0x3560
nop
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/cc_symboltable.cpp
// Function: symbolTable::add_operator(char const*, int, int)
int symbolTable::add_operator(const char *nta, int priority, int vcpucmd) {
    int nss = add_ex(nta, SYM_OPERATOR, priority);
	if (nss >= 0) {
        entries[nss].vartype = vcpucmd;
	}
    return nss;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdi, %r14
movsbl %dl, %ecx
pushq $0x3
popq %rdx
callq 0x10628
testl %eax, %eax
js 0x1084c
movl %eax, %ecx
movq 0x28(%r14), %rdx
imulq $0xb0, %rcx, %rcx
movw %bx, 0x30(%rdx,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/cc_symboltable.cpp
// Function: symbolTable::get_friendly_name[abi:cxx11](int)
std::string symbolTable::get_friendly_name(int idx) {

    int actualIdx = idx & STYPE_MASK;
    if (actualIdx < 0 || (size_t)actualIdx >= entries.size()) {
        return std::string("(invalid symbol)");
    }
    
    std::string result;
    int mask = idx & (~STYPE_MASK);
    result = entries[actualIdx].sname;
    if (mask & STYPE_POINTER) {
        result = result + std::string("*");
    }
    if (mask & STYPE_DYNARRAY) {
        result = result + std::string("[]");
    }
    if (mask & STYPE_CONST) {
        result = std::string("const ") + result;
    }
    return result;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movl %edx, %ebp
movq %rsi, %rax
movq %rdi, %rbx
movl %edx, %ecx
andl $0xfffffff, %ecx        # imm = 0xFFFFFFF
movq 0x28(%rsi), %rsi
movq 0x30(%rax), %rax
subq %rsi, %rax
movl $0xb0, %edi
cqto
idivq %rdi
cmpq %rcx, %rax
jbe 0x109ae
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
imulq $0xb0, %rcx, %rax
addq %rax, %rsi
movq %rbx, %rdi
callq 0x3200
btl $0x1e, %ebp
jae 0x1090c
leaq 0x872b(%rip), %rsi      # 0x18ff4
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xe8d6
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
movq %rbx, %rsi
callq 0x10c24
leaq 0x30(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x33d0
movq %r14, %rdi
callq 0x31a0
leaq 0x10(%rsp), %rdi
callq 0x31a0
btl $0x1c, %ebp
jae 0x1095c
leaq 0xa1bd(%rip), %rsi      # 0x1aad6
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xe8d6
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
movq %rbx, %rsi
callq 0x10c24
leaq 0x30(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x33d0
movq %r14, %rdi
callq 0x31a0
leaq 0x10(%rsp), %rdi
callq 0x31a0
btl $0x1d, %ebp
jae 0x109c2
leaq 0xa170(%rip), %rsi      # 0x1aad9
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xe8d6
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %rbx, %rdx
callq 0x10c48
leaq 0x30(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x33d0
movq %r14, %rdi
callq 0x31a0
leaq 0x10(%rsp), %rdi
callq 0x31a0
jmp 0x109c2
leaq 0xa110(%rip), %rsi      # 0x1aac5
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0xe8d6
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x109d6
jmp 0x109e7
jmp 0x109d6
jmp 0x109e7
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x31a0
jmp 0x109ea
jmp 0x109e7
movq %rax, %r14
movq %rbx, %rdi
callq 0x31a0
movq %r14, %rdi
callq 0x3560
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/cc_symboltable.cpp
// Function: symbolTable::get_name_string[abi:cxx11](int)
std::string symbolTable::get_name_string(int idx) {
	if (idx & STYPE_CONST) {
        idx &= ~STYPE_CONST;
		return std::string("const ") + get_name_string(idx);
    }

    if (idx & STYPE_DYNARRAY) {
        idx &= ~(STYPE_DYNARRAY | STYPE_POINTER);
		return get_name_string(idx) + std::string("[]");
    }

    if (idx & STYPE_POINTER) {
        idx &= ~STYPE_POINTER;
		return get_name_string(idx) + std::string("*");
    }

    return entries[idx].sname;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
btl $0x1d, %edx
jb 0x10a3b
btl $0x1c, %ebp
jb 0x10a7a
btl $0x1e, %ebp
jb 0x10ab9
movslq %ebp, %rax
imulq $0xb0, %rax, %rsi
addq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0x3440
jmp 0x10b0a
leaq 0xa097(%rip), %rsi      # 0x1aad9
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xe8d6
andl $0xdfffffff, %ebp       # imm = 0xDFFFFFFF
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x109fa
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x10c67
jmp 0x10af6
andl $0x8fffffff, %ebp       # imm = 0x8FFFFFFF
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x109fa
leaq 0xa040(%rip), %rsi      # 0x1aad6
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xe8d6
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x10c67
jmp 0x10af6
andl $0x8fffffff, %ebp       # imm = 0x8FFFFFFF
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x109fa
leaq 0x851f(%rip), %rsi      # 0x18ff4
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xe8d6
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x10c67
leaq 0x10(%rsp), %rdi
callq 0x31a0
leaq 0x30(%rsp), %rdi
callq 0x31a0
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x10b1e
jmp 0x10b2d
jmp 0x10b1e
jmp 0x10b2d
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x31a0
jmp 0x10b30
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x31a0
jmp 0x10b3f
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3560
nop
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/cc_symboltable.cpp
// Function: symbolTable::get_name(int)
const char *symbolTable::get_name(int idx) {
	if (nameGenCache.count(idx) > 0) {
		return nameGenCache[idx];
	}

	int actualIdx = idx & STYPE_MASK;
	if (actualIdx < 0 || (size_t)actualIdx >= entries.size()) { return NULL; }

	std::string resultString = get_name_string(idx);
	char *result = (char *)malloc(resultString.length() + 1);
	strcpy(result, resultString.c_str());
	nameGenCache[idx] = result;
	return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
leaq 0xc(%rsp), %rax
movl %esi, (%rax)
leaq 0x40(%rdi), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cce
testq %rax, %rax
je 0x10b81
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x10ce8
movq (%rax), %r14
jmp 0x10bef
movl 0xc(%rsp), %ecx
movl %ecx, %esi
andl $0xfffffff, %esi        # imm = 0xFFFFFFF
movq 0x30(%r14), %rax
subq 0x28(%r14), %rax
movl $0xb0, %edi
cqto
idivq %rdi
cmpq %rsi, %rax
jbe 0x10bec
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl %ecx, %edx
callq 0x109fa
movq 0x8(%r15), %rdi
incq %rdi
callq 0x3430
movq %rax, %r14
movq (%r15), %rsi
movq %rax, %rdi
callq 0x32c0
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x10ce8
movq %r14, (%rax)
leaq 0x10(%rsp), %rdi
callq 0x31a0
jmp 0x10bef
xorl %r14d, %r14d
movq %r14, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x31a0
movq %rbx, %rdi
callq 0x3560
nop
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/fmem.cpp
// Function: fmem_create()
FMEM*fmem_create() {
  tempy=(FMEM*)malloc(sizeof(FMEM));
  tempy->size=100;
  tempy->len=0;
  tempy->data=(char*)malloc(tempy->size+10);
  tempy->data[0]=0;
  tempy->magic=FMEM_MAGIC;
  tempy->pos=0;
  return tempy;
  }

// Assembly:
pushq %rbx
pushq $0x28
popq %rdi
callq 0x3430
movq %rax, %rbx
movq %rax, 0x13c4d(%rip)     # 0x257a8
movq $0x64, 0x10(%rax)
andq $0x0, 0x8(%rax)
pushq $0x6e
popq %rdi
callq 0x3430
movq %rax, (%rbx)
movb $0x0, (%rax)
movl $0xcddebeef, %eax       # imm = 0xCDDEBEEF
movq %rax, 0x18(%rbx)
andq $0x0, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/fmem.cpp
// Function: fmem_open(char const*)
FMEM*fmem_open(const char*sourc) {
  tempy=(FMEM*)malloc(sizeof(FMEM));
  tempy->size=strlen(sourc)+10;
  tempy->len=strlen(sourc);
  tempy->data=(char*)malloc(tempy->size+10);
  strcpy(tempy->data,sourc);
  tempy->magic=FMEM_MAGIC;
  tempy->pos=0;
  return tempy;
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x28
popq %rdi
callq 0x3430
movq %rax, %r14
movq %rax, 0x13c06(%rip)     # 0x257a8
movq %rbx, %rdi
callq 0x3190
leaq 0xa(%rax), %rcx
movq %rcx, 0x10(%r14)
movq %rax, 0x8(%r14)
leaq 0x14(%rax), %rdi
callq 0x3430
movq %rax, (%r14)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x32c0
movl $0xcddebeef, %eax       # imm = 0xCDDEBEEF
movq %rax, 0x18(%r14)
andq $0x0, 0x20(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/fmem.cpp
// Function: fmem_close(FMEM*)
void fmem_close(FMEM*cloo) {
  if (cloo==NULL) return;
  if (cloo->magic != FMEM_MAGIC) return;   // uninitialized
  free(cloo->data);
  free(cloo);
  }

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x11c0b
movq %rdi, %rbx
movl $0xcddebeef, %eax       # imm = 0xCDDEBEEF
cmpq %rax, 0x18(%rdi)
jne 0x11c0b
movq (%rbx), %rdi
callq 0x33a0
movq %rbx, %rdi
popq %rbx
jmp 0x33a0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/fmem.cpp
// Function: fmem_write(char*, long, FMEM*)
void fmem_write(char* towr,long mei,FMEM*fill) {
  long curdatlen=fill->len;
  if (curdatlen + mei >= fill->size) {
    char*datwas=fill->data;
    fill->size=fill->size + mei + BUFFER_INCREMENT_SIZE;
    fill->data=(char*)malloc(fill->size+10);
    strcpy(fill->data,datwas);
    free(datwas);
    }

  memcpy(&fill->data[curdatlen],towr,mei);
  fill->data[curdatlen+mei]=0;
  fill->len+=mei;
  fill->pos+=mei;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdx), %r12
movq 0x10(%rdx), %rax
leaq (%r12,%rsi), %rbp
cmpq %rax, %rbp
jl 0x11c6a
movq (%rbx), %r13
leaq (%rax,%r14), %rcx
addq $0x7d0, %rcx            # imm = 0x7D0
movq %rcx, 0x10(%rbx)
leaq (%rax,%r14), %rdi
addq $0x7da, %rdi            # imm = 0x7DA
callq 0x3430
movq %rax, (%rbx)
movq %rax, %rdi
movq %r13, %rsi
callq 0x32c0
movq %r13, %rdi
callq 0x33a0
addq (%rbx), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3280
movq (%rbx), %rax
movb $0x0, (%rax,%rbp)
addq %r14, 0x8(%rbx)
addq %r14, 0x20(%rbx)
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/fmem.cpp
// Function: fmem_putc(char, FMEM*)
void fmem_putc(char toput,FMEM*fill) {
  char templ[2];
  templ[0]=toput;
  templ[1]=0;
  fmem_write(&templ[0],1,fill);
  }

// Assembly:
pushq %rax
movq %rsi, %rdx
leaq 0x6(%rsp), %rax
movb %dil, (%rax)
movb $0x0, 0x1(%rax)
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0x11c0d
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/fmem.cpp
// Function: fmem_puts(char const*, FMEM*)
void fmem_puts(const char*strin,FMEM*ooo) {
  char buf[1024], *p;
  size_t l = strlen(strin);
  if(l+3 < sizeof buf)
    p = buf;
  else
    p = (char*)malloc(l+3);
  sprintf(p, "%s\r\n",strin);
  fmem_write(p,l+2,ooo);
  if(p != buf) free(p);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movq %rsi, %rbx
movq %rdi, %r12
callq 0x3190
movq %rax, %r14
leaq 0x3(%rax), %rdi
movq %rsp, %r13
movq %r13, %r15
cmpq $0x400, %rdi            # imm = 0x400
jb 0x11cef
callq 0x3430
movq %rax, %r15
leaq 0x8e3b(%rip), %rsi      # 0x1ab31
movq %r15, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x30c0
addq $0x2, %r14
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x11c0d
cmpq %r13, %r15
je 0x11d22
movq %r15, %rdi
callq 0x33a0
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/cc_compiledscript.cpp
// Function: ccCompiledScript::write_code(int)
void ccCompiledScript::write_code(int32_t byy) {
    flush_line_numbers();
    if (codesize >= codeallocated - 2) {
        codeallocated += 500;
        code = (int32_t*)realloc(code,codeallocated*sizeof(int32_t));
    }
    code[codesize] = byy;
    codesize++;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x12512
movslq 0x20(%rbx), %rcx
movq 0x90(%rbx), %rax
leaq -0x2(%rax), %rdx
cmpq %rcx, %rdx
jle 0x11e15
movq 0x18(%rbx), %rax
jmp 0x11e3c
leaq 0x1f4(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq 0x18(%rbx), %rdi
leaq 0x7d0(,%rax,4), %rsi
callq 0x3530
movq %rax, 0x18(%rbx)
movslq 0x20(%rbx), %rcx
movl %ebp, (%rax,%rcx,4)
incl 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/cc_compiledscript.cpp
// Function: ccCompiledScript::write_cmd3(int, int, int, int)
void ccCompiledScript::write_cmd3(int cmdd,int param,int param2,int param3) {
    write_code(cmdd);
    write_code(param);
    write_code(param2);
    write_code(param3);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rdi, %r15
callq 0x11dee
movq %r15, %rdi
movl %r14d, %esi
callq 0x11dee
movq %r15, %rdi
movl %ebp, %esi
callq 0x11dee
movq %r15, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x11dee
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/cc_compiledscript.cpp
// Function: ccCompiledScript::add_global(int, char const*)
int ccCompiledScript::add_global(int siz,const char*vall) {
    //  printf("Add global size %d at %d\n",siz,globaldatasize);
    //  if (remove_any_import (vall)) return -2;
    globaldata = (char*)realloc(globaldata, globaldatasize + siz);
    if (vall != NULL)
        memcpy(&globaldata[globaldatasize],vall,siz);
    else memset(&globaldata[globaldatasize],0,siz);
    int toret = globaldatasize;
    globaldatasize += siz;
    return toret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r13
movl %esi, %ebx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movslq 0x10(%r14), %rsi
movslq %ebx, %r12
addq %r12, %rsi
callq 0x3530
movq %rax, 0x8(%r14)
movslq 0x10(%r14), %r15
addq %r15, %rax
movq %rax, %rdi
testq %r13, %r13
je 0x11fe8
movq %r13, %rsi
movq %r12, %rdx
callq 0x3280
jmp 0x11ff2
xorl %esi, %esi
movq %r12, %rdx
callq 0x3210
addl %r15d, %ebx
movl %ebx, 0x10(%r14)
movl %r15d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/cc_compiledscript.cpp
// Function: ccCompiledScript::add_string(char const*)
int ccCompiledScript::add_string(const char*strr) {
    size_t len = strlen(strr);
    strings = (char*)realloc(strings, stringssize + len + 1);
    char *write_ptr = strings + stringssize;
    for (size_t src = 0; src <= len; ++src) {
        char ch = strr[src];
        if (ch=='\\') {
            src++;
            ch = strr[src];
            if (ch == 'n') {ch = '\n';}
            else if (ch == 'r') {ch = '\r';}
            else if (ch == '[') { // pass through as \[
                *write_ptr = '\\';
                write_ptr++;
            }
        }
        *write_ptr = ch;
        write_ptr++;
    }
    int toret = stringssize;
    stringssize += write_ptr - (strings + stringssize);
    return toret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x3190
movq %rax, %r15
movq 0x28(%rbx), %rdi
movslq 0x30(%rbx), %rax
leaq (%r15,%rax), %rsi
incq %rsi
callq 0x3530
movq %rax, 0x28(%rbx)
movslq 0x30(%rbx), %rcx
addq %rax, %rcx
xorl %eax, %eax
cmpq %r15, %rax
ja 0x1207d
movb (%r14,%rax), %dl
cmpb $0x5c, %dl
jne 0x12073
movzbl 0x1(%r14,%rax), %edx
incq %rax
cmpl $0x5b, %edx
je 0x1206b
cmpl $0x6e, %edx
je 0x12067
cmpl $0x72, %edx
jne 0x12073
movb $0xd, %dl
jmp 0x12073
movb $0xa, %dl
jmp 0x12073
movb $0x5c, (%rcx)
incq %rcx
movb $0x5b, %dl
movb %dl, (%rcx)
incq %rcx
incq %rax
jmp 0x1203d
movl 0x30(%rbx), %eax
subl 0x28(%rbx), %ecx
movl %ecx, 0x30(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/cc_compiledscript.cpp
// Function: ccCompiledScript::add_new_function(char const*, int*)
int ccCompiledScript::add_new_function(const char*namm, int *idx) {
    if (numfunctions >= MAX_FUNCTIONS) return -1;
    //  if (remove_any_import (namm)) return -2;
    functions[numfunctions] = (char*)malloc(strlen(namm)+20);
    strcpy(functions[numfunctions],namm);
    funccodeoffs[numfunctions] = codesize;
    funcnumparams[numfunctions] = 0;
    //  code = (long*)realloc(code, codesize + 5000);
    if (idx)
        *idx = numfunctions;
    numfunctions++;
    return codesize;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x8d38(%rdi), %r12
cmpq $0x7cf, %r12            # imm = 0x7CF
jle 0x1210d
pushq $-0x1
popq %rax
jmp 0x1216b
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x3190
leaq 0x14(%rax), %rdi
callq 0x3430
movq %rax, 0x98(%rbx,%r12,8)
movq %rax, %rdi
movq %r15, %rsi
callq 0x32c0
movslq 0x20(%rbx), %rax
movq %rax, 0x3f18(%rbx,%r12,8)
movq 0x8d38(%rbx), %rcx
andw $0x0, 0x7d98(%rbx,%rcx,2)
testq %r14, %r14
je 0x12161
movl %ecx, (%r14)
movl 0x20(%rbx), %eax
incq %rcx
movq %rcx, 0x8d38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/cc_compiledscript.cpp
// Function: ccCompiledScript::add_new_import(char const*)
int ccCompiledScript::add_new_import(const char*namm)
{
    if (numimports >= importsCapacity)
    {
        importsCapacity += 1000;
        imports = (char**)realloc(imports, sizeof(char*) * importsCapacity);
    }
    imports[numimports] = (char*)malloc(strlen(namm)+12);
    strcpy(imports[numimports],namm);
    numimports++;
    return numimports-1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x58(%rdi), %ebp
movslq 0x4c(%rdi), %rax
cmpl %eax, %ebp
jge 0x12196
movq 0x50(%rbx), %r15
jmp 0x121bb
leaq 0x3e8(%rax), %rcx
movl %ecx, 0x4c(%rbx)
movq 0x50(%rbx), %rdi
leaq 0x1f40(,%rax,8), %rsi
callq 0x3530
movq %rax, %r15
movq %rax, 0x50(%rbx)
movl 0x58(%rbx), %ebp
movq %r14, %rdi
callq 0x3190
leaq 0xc(%rax), %rdi
callq 0x3430
movslq %ebp, %rcx
movq %rax, (%r15,%rcx,8)
movq 0x50(%rbx), %rax
movq (%rax,%rcx,8), %rdi
movq %r14, %rsi
callq 0x32c0
movl 0x58(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x58(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/cc_compiledscript.cpp
// Function: ccCompiledScript::add_new_export(char const*, int, long, int)
int ccCompiledScript::add_new_export(const char*namm,int etype,long eoffs, int numArgs)
{
    if (numexports >= exportsCapacity)
    {
        exportsCapacity += 1000;
        exports = (char**)realloc(exports, sizeof(char*) * exportsCapacity);
        export_addr = (int32_t*)realloc(export_addr, sizeof(int32_t) * exportsCapacity);
    }
    if (eoffs >= 0x00ffffff) {
        cc_error("export offset too high; script data size too large?");
        return -1;
    }
    char *newName = (char*)malloc(strlen(namm)+20);
    strcpy(newName, namm);
    // mangle the name for functions to record parameters
    if (etype == EXPORT_FUNCTION) {
        char tempAddition[20];
        sprintf(tempAddition, "$%d", numArgs);
        strcat(newName, tempAddition);
    }
    // Check if it's already exported
    for (int aa = 0; aa < numexports; aa++) {
        if (strcmp(exports[aa], newName) == 0) {
            free(newName);
            return aa;
        }
    }
    exports[numexports] = newName;

    export_addr[numexports] = eoffs | ((long)etype << 24L);
    numexports++;
    return numexports-1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r15d
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r13
movq %rdi, %rbx
movslq 0x5c(%rdi), %rax
cmpl %eax, 0x70(%rdi)
jl 0x1242b
leaq 0x3e8(%rax), %rcx
movl %ecx, 0x5c(%rbx)
movq 0x60(%rbx), %rdi
leaq 0x1f40(,%rax,8), %rsi
callq 0x3530
movq %rax, 0x60(%rbx)
movq 0x68(%rbx), %rdi
movslq 0x5c(%rbx), %rsi
shlq $0x2, %rsi
callq 0x3530
movq %rax, 0x68(%rbx)
cmpq $0xffffff, %r14         # imm = 0xFFFFFF
jl 0x1244b
leaq 0x8767(%rip), %rdi      # 0x1aba2
xorl %eax, %eax
callq 0xf258
pushq $-0x1
popq %r15
jmp 0x124ff
movq %r14, 0x8(%rsp)
movq %r13, %rdi
callq 0x3190
leaq 0x14(%rax), %rdi
callq 0x3430
movq %rax, %r12
movq %rax, %rdi
movq %r13, %rsi
callq 0x32c0
movl %ebp, 0x4(%rsp)
cmpl $0x1, %ebp
jne 0x1249c
leaq 0x8757(%rip), %rsi      # 0x1abd6
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movl %r15d, %edx
xorl %eax, %eax
callq 0x30c0
movq %r12, %rdi
movq %r13, %rsi
callq 0x3570
movslq 0x70(%rbx), %r13
movq 0x60(%rbx), %rbp
xorl %r15d, %r15d
testl %r13d, %r13d
movl $0x0, %r14d
cmovgl %r13d, %r14d
cmpq %r15, %r14
je 0x124cf
movq (%rbp,%r15,8), %rdi
movq %r12, %rsi
callq 0x3450
testl %eax, %eax
je 0x124f7
incq %r15
jmp 0x124b4
movq %r12, (%rbp,%r13,8)
movl 0x4(%rsp), %eax
shll $0x18, %eax
movq 0x8(%rsp), %rcx
orl %eax, %ecx
movq 0x68(%rbx), %rax
movl %ecx, (%rax,%r13,4)
movl 0x70(%rbx), %r15d
leal 0x1(%r15), %eax
movl %eax, 0x70(%rbx)
jmp 0x124ff
movq %r12, %rdi
callq 0x33a0
movl %r15d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/cc_compiledscript.cpp
// Function: ccCompiledScript::flush_line_numbers()
void ccCompiledScript::flush_line_numbers() {
    if (next_line) {
        int linum = next_line;
        next_line = 0;
        if(ccGetOption(SCOPT_LINENUMBERS)) {
            write_code(SCMD_LINENUM);
            write_code(linum);
        }
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl 0x8d48(%rdi), %ebx
testl %ebx, %ebx
je 0x12552
movq %rdi, %r14
andl $0x0, 0x8d48(%rdi)
pushq $0x4
popq %rdi
callq 0x127df
testl %eax, %eax
je 0x12552
pushq $0x24
popq %rsi
movq %r14, %rdi
callq 0x11dee
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x11dee
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/cc_compiledscript.cpp
// Function: ccCompiledScript::start_new_section(char const*)
const char* ccCompiledScript::start_new_section(const char *name) {

    if ((numSections == 0) ||
        (codesize != sectionOffsets[numSections - 1]))
    {
        if (numSections >= capacitySections)
        {
            capacitySections += 100;
            sectionNames = (char**)realloc(sectionNames, sizeof(char*) * capacitySections);
            sectionOffsets = (int32_t*)realloc(sectionOffsets, sizeof(int32_t) * capacitySections);
        }
        sectionNames[numSections] = (char*)malloc(strlen(name) + 1);
        strcpy(sectionNames[numSections], name);
        sectionOffsets[numSections] = codesize;

        numSections++;
    }
    else
    {
        // nothing was in the last section, so overwrite it with this new one
        free(sectionNames[numSections - 1]);
        sectionNames[numSections - 1] = (char*)malloc(strlen(name) + 1);
        strcpy(sectionNames[numSections - 1], name);
    }

    return sectionNames[numSections - 1];
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movslq 0x88(%rdi), %r15
testq %r15, %r15
je 0x125cd
movl 0x20(%rbx), %eax
movq 0x80(%rbx), %rcx
cmpl -0x4(%rcx,%r15,4), %eax
jne 0x125cd
movq 0x78(%rbx), %rax
movq -0x8(%rax,%r15,8), %rdi
callq 0x33a0
movq %r14, %rdi
callq 0x3190
leaq 0x1(%rax), %rdi
callq 0x3430
movq 0x78(%rbx), %rcx
movslq 0x88(%rbx), %rdx
movq %rax, -0x8(%rcx,%rdx,8)
movq 0x78(%rbx), %rax
movq -0x8(%rax,%rdx,8), %rdi
movq %r14, %rsi
callq 0x32c0
movl 0x88(%rbx), %eax
jmp 0x1266b
movslq 0x8c(%rbx), %rax
cmpl %eax, %r15d
jl 0x1261d
leaq 0x64(%rax), %rcx
movl %ecx, 0x8c(%rbx)
movq 0x78(%rbx), %rdi
leaq 0x320(,%rax,8), %rsi
callq 0x3530
movq %rax, 0x78(%rbx)
movq 0x80(%rbx), %rdi
movslq 0x8c(%rbx), %rsi
shlq $0x2, %rsi
callq 0x3530
movq %rax, 0x80(%rbx)
movl 0x88(%rbx), %r15d
movq %r14, %rdi
callq 0x3190
leaq 0x1(%rax), %rdi
callq 0x3430
movq 0x78(%rbx), %rcx
movslq %r15d, %rdx
movq %rax, (%rcx,%rdx,8)
movq 0x78(%rbx), %rax
movq (%rax,%rdx,8), %rdi
movq %r14, %rsi
callq 0x32c0
movl 0x20(%rbx), %eax
movq 0x80(%rbx), %rcx
movslq 0x88(%rbx), %rdx
movl %eax, (%rcx,%rdx,4)
movl 0x88(%rbx), %eax
incl %eax
movl %eax, 0x88(%rbx)
movq 0x78(%rbx), %rcx
cltq
movq -0x8(%rcx,%rax,8), %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/rofl0r[P]ascc/cc_compiledscript.cpp
// Function: ccCompiledScript::free_extra()
void ccCompiledScript::free_extra() {
    int aa;
	for (aa=0;aa<numfunctions;aa++) {
        free(functions[aa]);
	}
    numfunctions=0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
cmpq %r14, 0x8d38(%rbx)
jle 0x126a1
movq 0x98(%rbx,%r14,8), %rdi
callq 0x33a0
incq %r14
jmp 0x12686
andq $0x0, 0x8d38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)