LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x4(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0xb7c3
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl %eax, %esi
leaq 0x370f6(%rip), %rdi     # 0x42870
callq 0x1e1e0
movl %eax, -0x1c(%rbp)
cmpl $0x7, -0x1c(%rbp)
je 0xb78e
cmpl $0x5, -0x1c(%rbp)
jne 0xb7a1
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0xb79f
jmp 0xb7c3
jmp 0xb7a1
cmpl $0x8, -0x1c(%rbp)
je 0xb7ad
cmpl $0x6, -0x1c(%rbp)
jne 0xb7b6
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xb7b8
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xb75f
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x7, -0xc(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0xb99e
movl $0x8, -0xc(%rbp)
cmpl $0x1, -0x4(%rbp)
jne 0xb98d
movl $0x1a, -0xc(%rbp)
jmp 0xb99c
cmpl $0x2, -0x4(%rbp)
jne 0xb99a
movl $0x1b, -0xc(%rbp)
jmp 0xb99c
jmp 0xb9be
cmpl $0x1, -0x4(%rbp)
jne 0xb9ad
movl $0x18, -0xc(%rbp)
jmp 0xb9bc
cmpl $0x2, -0x4(%rbp)
jne 0xb9ba
movl $0x19, -0xc(%rbp)
jmp 0xb9bc
jmp 0xb9be
cmpl $0x0, -0x4(%rbp)
je 0xb9cd
movl -0x4(%rbp), %eax
movl %eax, 0x36e73(%rip)     # 0x42840
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movslq -0x4(%rbp), %rsi
leaq 0x34cca(%rip), %rdi     # 0x42870
addq $0x28, %rdi
callq 0x17e60
movswl 0x30(%rax), %ecx
xorl %eax, %eax
leaq 0x34cb4(%rip), %rdx     # 0x42870
cmpl (%rdx), %ecx
movb %al, -0x5(%rbp)
jne 0xdc35
movslq -0x4(%rbp), %rsi
leaq 0x34ca2(%rip), %rdi     # 0x42870
addq $0x28, %rdi
callq 0x17e60
movq 0x28(%rax), %rcx
andq $0x2, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x5(%rbp)
je 0xdc35
movslq -0x4(%rbp), %rsi
leaq 0x34c7b(%rip), %rdi     # 0x42870
addq $0x28, %rdi
callq 0x17e60
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, 0x48(%rcx)
movb %al, -0x5(%rbp)
jne 0xdc35
movslq -0x4(%rbp), %rsi
leaq 0x34c58(%rip), %rdi     # 0x42870
addq $0x28, %rdi
callq 0x17e60
movq 0x28(%rax), %rax
andq $0x40000, %rax          # imm = 0x40000
cmpq $0x0, %rax
sete %al
movb %al, -0x5(%rbp)
movb -0x5(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x41d0
movq %rax, %rdi
addq $0x1388, %rdi           # imm = 0x1388
callq 0x44f0
movq %rax, -0x28(%rbp)
leaq 0x2aca6(%rip), %rax     # 0x42850
movl $0x0, (%rax)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x2d5d0
leaq 0x2ac8c(%rip), %rax     # 0x42850
cmpl $0x0, (%rax)
je 0x17bd2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x17bfa
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10f80
cmpl $0x0, %eax
je 0x17beb
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movq -0x28(%rbp), %rdi
callq 0x4460
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1bdd1
movq -0x18(%rbp), %rdi
callq 0x41d0
cmpq $0x0, %rax
ja 0x1bddd
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1be95
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x4680
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x18000
jmp 0x1be05
leaq -0x39(%rbp), %rdi
callq 0x43e0
movq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1bfe0
movq %rax, -0x70(%rbp)
jmp 0x1be21
movq -0x70(%rbp), %rax
cmpq $0x0, %rax
ja 0x1be69
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x50(%rbp)
jmp 0x1be8c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x43e0
jmp 0x1bea1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4270
jmp 0x1bea1
movq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1c040
movq %rax, -0x78(%rbp)
jmp 0x1be7c
movq -0x78(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0x50(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4270
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x4670
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x10(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1dd20
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x21(%rbp)
jne 0x1dd94
jmp 0x1ddab
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
cmpq $-0x2, (%rax,%rcx,8)
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x1ddb4
jmp 0x1ddbf
movl -0x14(%rbp), %eax
addl $0x3, %eax
movl %eax, -0x14(%rbp)
jmp 0x1dd7a
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1dd20
testb $0x1, %al
jne 0x1ddd1
jmp 0x1dde7
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x1ddef
movq $-0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl 0x10(%rdi), %esi
callq 0x1dd20
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x21(%rbp)
jne 0x1de2e
jmp 0x1de45
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rax
movslq 0x10(%rcx), %rcx
cmpq $-0x2, (%rax,%rcx,8)
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x1de51
jmp 0x1def4
movq -0x20(%rbp), %rcx
movl (%rcx), %eax
subl 0x10(%rcx), %eax
cltq
movq %rax, -0x18(%rbp)
cmpq $0x3, -0x18(%rbp)
jl 0x1dee2
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rax
movl 0x10(%rcx), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
cmpq $0x1, (%rax,%rcx,8)
jne 0x1dea1
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rax
movl 0x10(%rcx), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl %eax, %ecx
leaq 0x24a93(%rip), %rax     # 0x42930
movl %ecx, (%rax)
jmp 0x1dee0
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rax
movl 0x10(%rcx), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
cmpq $0x2, (%rax,%rcx,8)
jne 0x1dede
movq -0x20(%rbp), %rax
leaq 0x24a6c(%rip), %rcx     # 0x42930
movl (%rcx), %ecx
movl %ecx, 0x14(%rax)
cmpl $0x0, 0x18(%rax)
je 0x1dedc
leaq 0x24a5a(%rip), %rax     # 0x42930
movl $0xfffffff6, (%rax)     # imm = 0xFFFFFFF6
jmp 0x1def4
jmp 0x1dee0
jmp 0x1dee2
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x3, %ecx
movl %ecx, 0x10(%rax)
jmp 0x1de14
movq -0x20(%rbp), %rcx
movl 0x10(%rcx), %eax
cmpl (%rcx), %eax
jl 0x1df20
movq -0x20(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0x1df16
leaq 0x24a20(%rip), %rax     # 0x42930
movl $0xfffffff6, (%rax)     # imm = 0xFFFFFFF6
movq $-0x1, -0x8(%rbp)
jmp 0x1df5a
movq -0x20(%rbp), %rdi
movl 0x10(%rdi), %esi
callq 0x1dd20
testb $0x1, %al
jne 0x1df32
jmp 0x1df52
movq -0x20(%rbp), %rdx
movq 0x8(%rdx), %rax
movl 0x10(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x10(%rdx)
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x1df5a
movq $-0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl (%rcx), %eax
addl $0x1, %eax
cltq
shlq $0x3, %rax
movslq 0x4(%rcx), %rcx
cmpq %rcx, %rax
jb 0x1dfe2
movq -0x18(%rbp), %rax
cmpl $0x3e8, 0x4(%rax)       # imm = 0x3E8
jge 0x1dfba
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x3e8, %ecx            # imm = 0x3E8
movl %ecx, 0x4(%rax)
jmp 0x1dfc6
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
shll %ecx
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movslq 0x4(%rax), %rsi
callq 0x4620
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rsi
movq 0x8(%rax), %rcx
movslq (%rax), %rdx
movq %rsi, (%rcx,%rdx,8)
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rofl0r[P]ascc/cc_internallist.cpp
// Function: ccInternalList::shutdown()
void ccInternalList::shutdown() {
	if (script!=NULL) { free(script); }
    script = NULL;
    length = 0;
    allocated = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x1e088
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4460
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movl $0x0, (%rax)
movl $0x0, 0x4(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: rofl0r[P]ascc/cc_internallist.cpp
// Function: ccInternalList::init()
void ccInternalList::init() {
    allocated = 0;
    length = 0;
    script = NULL;
	pos = -1;
	lineAtEnd = -1;
    cancelCurrentLine = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movl $0x0, (%rax)
movq $0x0, 0x8(%rax)
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x14(%rax) # imm = 0xFFFFFFFF
movl $0x1, 0x18(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: rofl0r[P]ascc/cc_symboltable.cpp
// Function: symbolTable::symbolTable()
symbolTable::symbolTable() {
    normalIntSym = 0;
    normalCharSym = 0;
    normalLongSym = 0;
    normalShortSym = 0;
    normalStringSym = 0;
    normalFloatSym = 0;
    normalVoidSym = 0;
    nullSym = 0;
    stringStructSym = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x28, %rdi
callq 0x1f8a0
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
callq 0x1f8c0
movq -0x10(%rbp), %rdi
addq $0x70, %rdi
callq 0x1f8e0
movq -0x10(%rbp), %rdi
addq $0xa0, %rdi
callq 0x1f900
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, 0x4(%rax)
movl $0x0, 0x8(%rax)
movl $0x0, 0xc(%rax)
movl $0x0, 0x10(%rax)
movl $0x0, 0x14(%rax)
movl $0x0, 0x18(%rax)
movl $0x0, 0x1c(%rax)
movl $0x0, 0x20(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
andl $0xfffffff, %eax        # imm = 0xFFFFFFF
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x1e229
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x28, %rdi
callq 0x17e80
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jb 0x1e232
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1e24a
movq -0x20(%rbp), %rdi
addq $0x28, %rdi
movslq -0x14(%rbp), %rsi
callq 0x17e60
movswl 0x20(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rofl0r[P]ascc/cc_symboltable.cpp
// Function: SymbolTableEntry::get_propget()
int SymbolTableEntry::get_propget() {
    int toret = (soffs >> 16) & 0x00ffff;
	if (toret == 0xffff) {
        return -1;
	}
    return toret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x34(%rax), %eax
sarl $0x10, %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x14(%rbp)
cmpl $0xffff, -0x14(%rbp)    # imm = 0xFFFF
jne 0x1e30c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1e312
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: rofl0r[P]ascc/cc_symboltable.cpp
// Function: SymbolTableEntry::get_propset()
int SymbolTableEntry::get_propset() {
    int toret = soffs & 0xffff;
	if (toret == 0xffff) {
        return -1;
	}
    return toret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x34(%rax), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x14(%rbp)
cmpl $0xffff, -0x14(%rbp)    # imm = 0xFFFF
jne 0x1e349
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1e34f
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
movl $0x3, %edx
movsbl %al, %ecx
callq 0x1ebe0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x1f01b
movq -0x28(%rbp), %rdi
movl -0x18(%rbp), %eax
movw %ax, -0x2a(%rbp)
addq $0x28, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x17e60
movw -0x2a(%rbp), %cx
movw %cx, 0x30(%rax)
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
addq $0x40, %rdi
leaq -0x14(%rbp), %rsi
callq 0x1fbb0
cmpq $0x0, %rax
jbe 0x1f77a
movq -0x58(%rbp), %rdi
addq $0x40, %rdi
leaq -0x14(%rbp), %rsi
callq 0x1fc10
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1f856
movl -0x14(%rbp), %eax
andl $0xfffffff, %eax        # imm = 0xFFFFFFF
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x1f7ac
movq -0x58(%rbp), %rdi
movslq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
addq $0x28, %rdi
callq 0x17e80
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jb 0x1f7b9
movq $0x0, -0x8(%rbp)
jmp 0x1f856
movq -0x58(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq -0x38(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x1f420
movq -0x80(%rbp), %rdi
callq 0x4590
movq %rax, %rdi
incq %rdi
callq 0x44f0
movq -0x80(%rbp), %rdi
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x78(%rbp)
callq 0x41b0
movq -0x78(%rbp), %rdi
movq %rax, %rsi
callq 0x4350
movq -0x58(%rbp), %rdi
movq -0x40(%rbp), %rax
movq %rax, -0x70(%rbp)
addq $0x40, %rdi
leaq -0x14(%rbp), %rsi
callq 0x1fc10
movq %rax, -0x68(%rbp)
jmp 0x1f821
movq -0x68(%rbp), %rax
movq -0x70(%rbp), %rcx
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4270
jmp 0x1f856
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4270
jmp 0x1f863
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x4670
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
movl $0x28, %edi
callq 0x44f0
movq %rax, 0x1dcc3(%rip)     # 0x42928
movq 0x1dcbc(%rip), %rax     # 0x42928
movq $0x64, 0x10(%rax)
movq 0x1dcad(%rip), %rax     # 0x42928
movq $0x0, 0x8(%rax)
movq 0x1dc9e(%rip), %rax     # 0x42928
movq 0x10(%rax), %rdi
addq $0xa, %rdi
callq 0x44f0
movq %rax, %rcx
movq 0x1dc87(%rip), %rax     # 0x42928
movq %rcx, (%rax)
movq 0x1dc7d(%rip), %rax     # 0x42928
movq (%rax), %rax
movb $0x0, (%rax)
movq 0x1dc70(%rip), %rax     # 0x42928
movl $0xcddebeef, %ecx       # imm = 0xCDDEBEEF
movq %rcx, 0x18(%rax)
movq 0x1dc60(%rip), %rax     # 0x42928
movq $0x0, 0x20(%rax)
movq 0x1dc51(%rip), %rax     # 0x42928
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x28, %edi
callq 0x44f0
movq %rax, 0x1dc2b(%rip)     # 0x42928
movq -0x8(%rbp), %rdi
callq 0x41d0
movq %rax, %rcx
addq $0xa, %rcx
movq 0x1dc14(%rip), %rax     # 0x42928
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
callq 0x41d0
movq %rax, %rcx
movq 0x1dbfd(%rip), %rax     # 0x42928
movq %rcx, 0x8(%rax)
movq 0x1dbf2(%rip), %rax     # 0x42928
movq 0x10(%rax), %rdi
addq $0xa, %rdi
callq 0x44f0
movq %rax, %rcx
movq 0x1dbdb(%rip), %rax     # 0x42928
movq %rcx, (%rax)
movq 0x1dbd1(%rip), %rax     # 0x42928
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x4350
movq 0x1dbbe(%rip), %rax     # 0x42928
movl $0xcddebeef, %ecx       # imm = 0xCDDEBEEF
movq %rcx, 0x18(%rax)
movq 0x1dbae(%rip), %rax     # 0x42928
movq $0x0, 0x20(%rax)
movq 0x1db9f(%rip), %rax     # 0x42928
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x24da5
jmp 0x24dcb
movq -0x8(%rbp), %rax
movl $0xcddebeef, %ecx       # imm = 0xCDDEBEEF
cmpq %rcx, 0x18(%rax)
je 0x24db6
jmp 0x24dcb
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x4460
movq -0x8(%rbp), %rdi
callq 0x4460
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jl 0x24e6c
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
addq -0x10(%rbp), %rcx
addq $0x7d0, %rcx            # imm = 0x7D0
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
addq $0xa, %rdi
callq 0x44f0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x4350
movq -0x28(%rbp), %rdi
callq 0x4460
movq -0x18(%rbp), %rax
movq (%rax), %rdi
addq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x4300
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
addq -0x10(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
addq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movb -0x1(%rbp), %al
movb %al, -0x12(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x1, %esi
callq 0x24de0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x41d0
movq %rax, -0x420(%rbp)
movq -0x420(%rbp), %rax
addq $0x3, %rax
cmpq $0x400, %rax            # imm = 0x400
jae 0x24f46
leaq -0x410(%rbp), %rax
movq %rax, -0x418(%rbp)
jmp 0x24f5d
movq -0x420(%rbp), %rdi
addq $0x3, %rdi
callq 0x44f0
movq %rax, -0x418(%rbp)
movq -0x418(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0xeb76(%rip), %rsi      # 0x33ae5
movb $0x0, %al
callq 0x40d0
movq -0x418(%rbp), %rdi
movq -0x420(%rbp), %rsi
addq $0x2, %rsi
movq -0x10(%rbp), %rdx
callq 0x24de0
movq -0x418(%rbp), %rax
leaq -0x410(%rbp), %rcx
cmpq %rcx, %rax
je 0x24fb0
movq -0x418(%rbp), %rdi
callq 0x4460
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopl (%rax)
// File: rofl0r[P]ascc/fmem.cpp
// Function: fmem_gets(FMEM*, char*)
void fmem_gets(FMEM*fmem,char*bufrr) {
  int tval,bindx=0;
  if (fmem_peekc(fmem)==0) {
    bufrr[0]=0; fmem_getc(fmem);
    return; }
  do {
    tval=fmem_getc(fmem);
    bufrr[bindx]=tval;
    bindx++;
    if (tval==0) break;
    if (fmem_eof(fmem)) break;
    } while ((tval != 13) && (tval != 10));
  if ((fmem_eof(fmem)==0) && tval == '\r' && (fmem_peekc(fmem)==10))
    fmem_getc(fmem);  // LF
  if (tval == 13 || tval == 10)
    bindx--;    // strip CR, if it was CRLF, else LF

  bufrr[bindx]=0;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x25000
cmpl $0x0, %eax
jne 0x2508a
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rdi
callq 0x24fc0
jmp 0x25133
jmp 0x2508c
movq -0x8(%rbp), %rdi
callq 0x24fc0
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x250b9
jmp 0x250e7
movq -0x8(%rbp), %rdi
callq 0x25020
cmpl $0x0, %eax
je 0x250c9
jmp 0x250e7
jmp 0x250cb
xorl %eax, %eax
cmpl $0xd, -0x14(%rbp)
movb %al, -0x19(%rbp)
je 0x250e0
cmpl $0xa, -0x14(%rbp)
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x2508c
movq -0x8(%rbp), %rdi
callq 0x25020
cmpl $0x0, %eax
jne 0x25112
cmpl $0xd, -0x14(%rbp)
jne 0x25112
movq -0x8(%rbp), %rdi
callq 0x25000
cmpl $0xa, %eax
jne 0x25112
movq -0x8(%rbp), %rdi
callq 0x24fc0
cmpl $0xd, -0x14(%rbp)
je 0x2511e
cmpl $0xa, -0x14(%rbp)
jne 0x25127
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x25fb0
movq -0x18(%rbp), %rcx
movslq 0x20(%rcx), %rax
movq 0x90(%rcx), %rcx
subq $0x2, %rcx
cmpq %rcx, %rax
jl 0x251dc
movq -0x18(%rbp), %rax
movq 0x90(%rax), %rcx
addq $0x1f4, %rcx            # imm = 0x1F4
movq %rcx, 0x90(%rax)
movq 0x18(%rax), %rdi
movq 0x90(%rax), %rsi
shlq $0x2, %rsi
callq 0x4620
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %esi
movq 0x18(%rax), %rcx
movslq 0x20(%rax), %rdx
movl %esi, (%rcx,%rdx,4)
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl -0xc(%rbp), %esi
callq 0x25170
movq -0x20(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x25170
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x25170
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x25170
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rofl0r[P]ascc/cc_compiledscript.cpp
// Function: ccCompiledScript::init()
void ccCompiledScript::init() {
    globaldata = NULL;
    globaldatasize = 0;
    code = NULL;
    codesize = 0;
    codeallocated = 0;
    numfunctions = 0;
    strings = NULL;
    stringssize = 0;
    cur_sp=0;
    fixups = NULL;
    fixuptypes = NULL;
    numfixups = 0;
    numimports = 0;
    numexports = 0;
    numSections = 0;
    importsCapacity = 0;
    imports = NULL;
    exportsCapacity = 0;
    exports = NULL;
    export_addr = NULL;
    capacitySections = 0;
    sectionNames = NULL;
    sectionOffsets = NULL;
    next_line = 0;
    ax_val_type = 0;
    ax_val_scope = 0;
    memset(functions, 0, sizeof(functions));
    memset(funccodeoffs, 0, sizeof(funccodeoffs));
    memset(funcnumparams, 0, sizeof(funcnumparams));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movq $0x0, 0x8(%rdi)
movl $0x0, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movl $0x0, 0x20(%rdi)
movq $0x0, 0x90(%rdi)
movq $0x0, 0x8d38(%rdi)
movq $0x0, 0x28(%rdi)
movl $0x0, 0x30(%rdi)
movq $0x0, 0x8d40(%rdi)
movq $0x0, 0x40(%rdi)
movq $0x0, 0x38(%rdi)
movl $0x0, 0x48(%rdi)
movl $0x0, 0x58(%rdi)
movl $0x0, 0x70(%rdi)
movl $0x0, 0x88(%rdi)
movl $0x0, 0x4c(%rdi)
movq $0x0, 0x50(%rdi)
movl $0x0, 0x5c(%rdi)
movq $0x0, 0x60(%rdi)
movq $0x0, 0x68(%rdi)
movl $0x0, 0x8c(%rdi)
movq $0x0, 0x78(%rdi)
movq $0x0, 0x80(%rdi)
movl $0x0, 0x8d48(%rdi)
movl $0x0, 0x8d4c(%rdi)
movl $0x0, 0x8d50(%rdi)
addq $0x98, %rdi
xorl %esi, %esi
movl $0x3e80, %edx           # imm = 0x3E80
callq 0x4230
movq -0x10(%rbp), %rdi
addq $0x3f18, %rdi           # imm = 0x3F18
xorl %esi, %esi
movl $0x3e80, %edx           # imm = 0x3E80
callq 0x4230
movq -0x10(%rbp), %rdi
addq $0x7d98, %rdi           # imm = 0x7D98
xorl %esi, %esi
movl $0xfa0, %edx            # imm = 0xFA0
callq 0x4230
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x8(%rax), %rdi
movl 0x10(%rax), %eax
addl -0xc(%rbp), %eax
movslq %eax, %rsi
callq 0x4620
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x2560d
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movslq 0x10(%rax), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movslq -0xc(%rbp), %rdx
callq 0x4300
jmp 0x25627
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movslq 0x10(%rax), %rax
addq %rax, %rdi
movslq -0xc(%rbp), %rdx
xorl %esi, %esi
callq 0x4230
movq -0x28(%rbp), %rax
movl 0x10(%rax), %ecx
movl %ecx, -0x1c(%rbp)
movl -0xc(%rbp), %ecx
addl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x41d0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq 0x28(%rax), %rdi
movslq 0x30(%rax), %rsi
addq -0x18(%rbp), %rsi
addq $0x1, %rsi
callq 0x4620
movq -0x38(%rbp), %rcx
movq %rax, 0x28(%rcx)
movq 0x28(%rcx), %rax
movslq 0x30(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
ja 0x25755
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x29(%rbp)
movsbl -0x29(%rbp), %eax
cmpl $0x5c, %eax
jne 0x2572f
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x29(%rbp)
movsbl -0x29(%rbp), %eax
cmpl $0x6e, %eax
jne 0x256fe
movb $0xa, -0x29(%rbp)
jmp 0x2572d
movsbl -0x29(%rbp), %eax
cmpl $0x72, %eax
jne 0x2570d
movb $0xd, -0x29(%rbp)
jmp 0x2572b
movsbl -0x29(%rbp), %eax
cmpl $0x5b, %eax
jne 0x25729
movq -0x20(%rbp), %rax
movb $0x5c, (%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2572b
jmp 0x2572d
jmp 0x2572f
movb -0x29(%rbp), %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x256b0
movq -0x38(%rbp), %rax
movl 0x30(%rax), %ecx
movl %ecx, -0x30(%rbp)
movq -0x20(%rbp), %rdx
movq 0x28(%rax), %rcx
movslq 0x30(%rax), %rsi
addq %rsi, %rcx
subq %rcx, %rdx
movslq 0x30(%rax), %rcx
addq %rdx, %rcx
movl %ecx, 0x30(%rax)
movl -0x30(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rofl0r[P]ascc/cc_compiledscript.cpp
// Function: ccCompiledScript::add_fixup(int, char)
void ccCompiledScript::add_fixup(int32_t locc, char ftype) {
    fixuptypes = (char*)realloc(fixuptypes, numfixups + 5);
    fixups = (int32_t*)realloc(fixups, (numfixups * sizeof(int32_t)) + 10);
    fixuptypes[numfixups] = ftype;
    fixups[numfixups] = locc;
    numfixups++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb %al, -0xd(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x38(%rax), %rdi
movl 0x48(%rax), %eax
addl $0x5, %eax
movslq %eax, %rsi
callq 0x4620
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x38(%rax)
movq 0x40(%rax), %rdi
movslq 0x48(%rax), %rsi
shlq $0x2, %rsi
addq $0xa, %rsi
callq 0x4620
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x40(%rax)
movb -0xd(%rbp), %sil
movq 0x38(%rax), %rcx
movslq 0x48(%rax), %rdx
movb %sil, (%rcx,%rdx)
movl -0xc(%rbp), %esi
movq 0x40(%rax), %rcx
movslq 0x48(%rax), %rdx
movl %esi, (%rcx,%rdx,4)
movl 0x48(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x48(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x7d0, 0x8d38(%rax) # imm = 0x7D0
jl 0x25885
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x25926
movq -0x18(%rbp), %rdi
callq 0x41d0
movq %rax, %rdi
addq $0x14, %rdi
callq 0x44f0
movq %rax, %rdx
movq -0x28(%rbp), %rax
movq 0x8d38(%rax), %rcx
movq %rdx, 0x98(%rax,%rcx,8)
movq 0x8d38(%rax), %rcx
movq 0x98(%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
callq 0x4350
movq -0x28(%rbp), %rax
movslq 0x20(%rax), %rdx
movq 0x8d38(%rax), %rcx
movq %rdx, 0x3f18(%rax,%rcx,8)
movq 0x8d38(%rax), %rcx
movw $0x0, 0x7d98(%rax,%rcx,2)
cmpq $0x0, -0x20(%rbp)
je 0x2590a
movq -0x28(%rbp), %rax
movq 0x8d38(%rax), %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movq 0x8d38(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8d38(%rax)
movl 0x20(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl 0x58(%rcx), %eax
cmpl 0x4c(%rcx), %eax
jl 0x2597c
movq -0x18(%rbp), %rax
movl 0x4c(%rax), %ecx
addl $0x3e8, %ecx            # imm = 0x3E8
movl %ecx, 0x4c(%rax)
movq 0x50(%rax), %rdi
movslq 0x4c(%rax), %rsi
shlq $0x3, %rsi
callq 0x4620
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x10(%rbp), %rdi
callq 0x41d0
movq %rax, %rdi
addq $0xc, %rdi
callq 0x44f0
movq -0x18(%rbp), %rcx
movq %rax, %rsi
movq 0x50(%rcx), %rax
movslq 0x58(%rcx), %rdx
movq %rsi, (%rax,%rdx,8)
movq 0x50(%rcx), %rax
movslq 0x58(%rcx), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0x4350
movq -0x18(%rbp), %rax
movl 0x58(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x58(%rax)
movl 0x58(%rax), %eax
subl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, 0x8d48(%rax)
je 0x2600f
movq -0x18(%rbp), %rax
movl 0x8d48(%rax), %ecx
movl %ecx, -0xc(%rbp)
movl $0x0, 0x8d48(%rax)
movl $0x4, %edi
callq 0x265a0
cmpl $0x0, %eax
je 0x2600d
movq -0x18(%rbp), %rdi
movl $0x24, %esi
callq 0x25170
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x25170
jmp 0x2600f
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, 0x88(%rax)
je 0x26064
movq -0x18(%rbp), %rdx
movl 0x20(%rdx), %eax
movq 0x80(%rdx), %rcx
movl 0x88(%rdx), %edx
subl $0x1, %edx
movslq %edx, %rdx
cmpl (%rcx,%rdx,4), %eax
je 0x26139
movq -0x18(%rbp), %rcx
movl 0x88(%rcx), %eax
cmpl 0x8c(%rcx), %eax
jl 0x260cd
movq -0x18(%rbp), %rax
movl 0x8c(%rax), %ecx
addl $0x64, %ecx
movl %ecx, 0x8c(%rax)
movq 0x78(%rax), %rdi
movslq 0x8c(%rax), %rsi
shlq $0x3, %rsi
callq 0x4620
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x78(%rax)
movq 0x80(%rax), %rdi
movslq 0x8c(%rax), %rsi
shlq $0x2, %rsi
callq 0x4620
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x80(%rax)
movq -0x10(%rbp), %rdi
callq 0x41d0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x44f0
movq -0x18(%rbp), %rcx
movq %rax, %rsi
movq 0x78(%rcx), %rax
movslq 0x88(%rcx), %rdx
movq %rsi, (%rax,%rdx,8)
movq 0x78(%rcx), %rax
movslq 0x88(%rcx), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0x4350
movq -0x18(%rbp), %rax
movl 0x20(%rax), %esi
movq 0x80(%rax), %rcx
movslq 0x88(%rax), %rdx
movl %esi, (%rcx,%rdx,4)
movl 0x88(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x88(%rax)
jmp 0x261a3
movq -0x18(%rbp), %rcx
movq 0x78(%rcx), %rax
movl 0x88(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x4460
movq -0x10(%rbp), %rdi
callq 0x41d0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x44f0
movq -0x18(%rbp), %rcx
movq %rax, %rsi
movq 0x78(%rcx), %rax
movl 0x88(%rcx), %edx
subl $0x1, %edx
movslq %edx, %rdx
movq %rsi, (%rax,%rdx,8)
movq 0x78(%rcx), %rax
movl 0x88(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0x4350
movq -0x18(%rbp), %rcx
movq 0x78(%rcx), %rax
movl 0x88(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movslq -0xc(%rbp), %rax
cmpq 0x8d38(%rcx), %rax
jge 0x2621c
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x98(%rax,%rcx,8), %rdi
callq 0x4460
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x261eb
movq -0x18(%rbp), %rax
movq $0x0, 0x8d38(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: rofl0r[P]ascc/cs_parser_common.cpp
// Function: is_alphanum(int)
int is_alphanum(int chrac) {
    if ((chrac>='A') & (chrac<='Z')) return 1;
    if ((chrac>='a') & (chrac<='z')) return 1;
    if ((chrac>='0') & (chrac<='9')) return 1;
    if (chrac == '_') return 1;
    if (chrac == '\"') return 1;
    if (chrac == '\'') return 1;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x41, -0x8(%rbp)
setge %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x5a, -0x8(%rbp)
setle %cl
andb $0x1, %cl
movzbl %cl, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x26343
movl $0x1, -0x4(%rbp)
jmp 0x263c9
cmpl $0x61, -0x8(%rbp)
setge %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x7a, -0x8(%rbp)
setle %cl
andb $0x1, %cl
movzbl %cl, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x2636c
movl $0x1, -0x4(%rbp)
jmp 0x263c9
cmpl $0x30, -0x8(%rbp)
setge %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x39, -0x8(%rbp)
setle %cl
andb $0x1, %cl
movzbl %cl, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x26395
movl $0x1, -0x4(%rbp)
jmp 0x263c9
cmpl $0x5f, -0x8(%rbp)
jne 0x263a4
movl $0x1, -0x4(%rbp)
jmp 0x263c9
cmpl $0x22, -0x8(%rbp)
jne 0x263b3
movl $0x1, -0x4(%rbp)
jmp 0x263c9
cmpl $0x27, -0x8(%rbp)
jne 0x263c2
movl $0x1, -0x4(%rbp)
jmp 0x263c9
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: rofl0r[P]ascc/cc_script.cpp
// Function: freadstring(char**, AGS::Common::Stream*)
void freadstring(char **strptr, Stream *in)
{
    static char ibuffer[300];
    int idxx = 0;

    while ((ibuffer[idxx] = in->ReadInt8()) != 0)
        idxx++;

    if (ibuffer[0] == 0) {
        strptr[0] = nullptr;
        return;
    }

    strptr[0] = (char *)malloc(strlen(ibuffer) + 1);
    strcpy(strptr[0], ibuffer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x70(%rax)
movslq -0x14(%rbp), %rdx
leaq 0x1c1b4(%rip), %rcx     # 0x42940
movb %al, (%rcx,%rdx)
movsbl %al, %eax
cmpl $0x0, %eax
je 0x267a2
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x26777
movsbl 0x1c197(%rip), %eax     # 0x42940
cmpl $0x0, %eax
jne 0x267bb
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
jmp 0x267f0
leaq 0x1c17e(%rip), %rdi     # 0x42940
callq 0x41d0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x44f0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x1c155(%rip), %rsi     # 0x42940
callq 0x4350
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rofl0r[P]ascc/cc_script.cpp
// Function: ccScript::CreateFromStream(AGS::Common::Stream*)
ccScript *ccScript::CreateFromStream(Stream *in)
{
    ccScript *scri = new ccScript();
    if (!scri->Read(in))
    {
        delete scri;
        return nullptr;
    }
    return scri;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl $0x90, %edi
callq 0x4380
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x26ce0
jmp 0x26827
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x268a0
testb $0x1, %al
jne 0x2687e
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x26858
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, -0x8(%rbp)
jmp 0x26886
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x90, %esi
callq 0x4390
jmp 0x26890
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x4670
nopl (%rax)