LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/bytecd.c
// Function: code_number
void _code_number()
{
    ccInt codeNo;
    
    
        // Get the right-hand argument:  the code # to run.
    
    callNumericFunction(int_type);
    if (errCode != passed)  return;
    codeNo = intRegister;
    
    
        // Get the left-hand argument:  the function
    
    callCodeFunction();
    
    codeNumber = codeNo;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x2, %edi
callq 0x14da0
cmpl $0x0, 0x12daf(%rip)     # 0x2c768
je 0x199bd
jmp 0x199d4
movl 0x12df9(%rip), %eax     # 0x2c7bc
movl %eax, -0x4(%rbp)
callq 0x14300
movl -0x4(%rbp), %eax
movl %eax, 0x12f70(%rip)     # 0x2c944
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/bytecd.c
// Function: getCurrentCodeList
void getCurrentCodeList(linkedlist *theList)
{
    ccInt numNewElements = 0, rtrn;
    linkedlist *listToCopy = NULL;
    
    if (GL_Object.type == composite_type)  {
        listToCopy = GL_Object.codeList;        }
    else if ((GL_Object.type == var_type) || (GL_Object.type == no_type))  {
        if ((GL_Object.type == var_type) && (searchView.windowPtr != NULL))  {
            if (searchView.windowPtr->variable_ptr->eventualType == composite_type)  {
                listToCopy = GL_Object.codeList;
        }   }
        else if ((searchView.windowPtr == NULL) && (GL_Path.stemMember != NULL))  {
            if (GL_Path.stemMember->eventualType == composite_type)  {
                listToCopy = &GL_Path.stemMember->codeList;
        }   }
        else if (GL_Object.type == var_type)  {  setError(void_member_err, pcCodePtr-1);  return;  }
    }
    else  {  setError(not_a_function_err, pcCodePtr-1);  return;  }
    
    if (listToCopy != NULL)  numNewElements = listToCopy->elementNum;
    
    rtrn = newLinkedList(theList, numNewElements, sizeof(code_ref), 0., ccFalse);
    if (rtrn != passed)  {  setError(rtrn, pcCodePtr-1);  return;  }
    if (listToCopy != NULL)  copyElements(listToCopy, 1, theList, 1, listToCopy->elementNum);
    
    refCodeList(theList);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
cmpl $0x5, 0x12bb6(%rip)     # 0x2c828
jne 0x19c84
movq 0x12bd5(%rip), %rax     # 0x2c850
movq %rax, -0x18(%rbp)
jmp 0x19d42
cmpl $-0x1, 0x12b9d(%rip)    # 0x2c828
je 0x19c9a
cmpl $0x7, 0x12b94(%rip)     # 0x2c828
jne 0x19d29
cmpl $-0x1, 0x12b87(%rip)    # 0x2c828
jne 0x19cce
cmpq $0x0, 0x12bfd(%rip)     # 0x2c8a8
je 0x19cce
movq 0x12bf4(%rip), %rax     # 0x2c8a8
movq 0x10(%rax), %rax
cmpl $0x5, 0xc4(%rax)
jne 0x19ccc
movq 0x12b88(%rip), %rax     # 0x2c850
movq %rax, -0x18(%rbp)
jmp 0x19d27
cmpq $0x0, 0x12bd2(%rip)     # 0x2c8a8
jne 0x19d00
cmpq $0x0, 0x12b78(%rip)     # 0x2c858
je 0x19d00
movq 0x12b6f(%rip), %rax     # 0x2c858
cmpl $0x5, 0x14(%rax)
jne 0x19cfe
movq 0x12b62(%rip), %rax     # 0x2c858
addq $0x20, %rax
movq %rax, -0x18(%rbp)
jmp 0x19d25
cmpl $-0x1, 0x12b21(%rip)    # 0x2c828
jne 0x19d23
movq 0x12af8(%rip), %rsi     # 0x2c808
addq $-0x4, %rsi
movl $0x1a, %edi
callq 0xf740
jmp 0x19db1
jmp 0x19d25
jmp 0x19d27
jmp 0x19d40
movq 0x12ad8(%rip), %rsi     # 0x2c808
addq $-0x4, %rsi
movl $0x23, %edi
callq 0xf740
jmp 0x19db1
jmp 0x19d42
cmpq $0x0, -0x18(%rbp)
je 0x19d52
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl $0x20, %edx
xorps %xmm0, %xmm0
xorl %ecx, %ecx
callq 0x8460
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x19d86
movl -0x10(%rbp), %edi
movq 0x12a8d(%rip), %rsi     # 0x2c808
addq $-0x4, %rsi
callq 0xf740
jmp 0x19db1
cmpq $0x0, -0x18(%rbp)
je 0x19da8
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rdx
movq -0x18(%rbp), %rax
movl (%rax), %r8d
movl $0x1, %ecx
movl %ecx, %esi
callq 0x8a90
movq -0x8(%rbp), %rdi
callq 0x19f50
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/bytecd.c
// Function: append_code
void _append_code()
{
    linkedlist firstCodeList, secondCodeList;
    ccInt rtrn;
    
    
        // get the first code argument..
    
    callCodeFunction();
    if (errCode != passed)  return;
    
    getCurrentCodeList(&firstCodeList);
    if (errCode != passed)  return;
    
    
        // get the 2nd argument
    
    callCodeFunction();
    if (errCode != passed)  {  derefCodeList(&firstCodeList);  return;  }
    
    getCurrentCodeList(&secondCodeList);
    if (errCode != passed)  return;
    
    
        // prepare the codeRegister for holding the concatenated code list
    
    derefCodeList(&codeRegister);
    rtrn = resizeLinkedList(&codeRegister, firstCodeList.elementNum+secondCodeList.elementNum, ccFalse);
    if (rtrn != passed)  {  resizeLinkedList(&codeRegister, 0, ccFalse);  setError(rtrn, pcCodePtr-1);  }
    else  {
        copyElements(&firstCodeList, 1, &codeRegister, 1, firstCodeList.elementNum);
        copyElements(&secondCodeList, 1, &codeRegister, firstCodeList.elementNum+1, secondCodeList.elementNum);   }
    
    
        // clean up and go..
    
    GL_Object.type = composite_type;
    GL_Object.codeList = &codeRegister;
    codeNumber = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
callq 0x14300
cmpl $0x0, 0x12944(%rip)     # 0x2c768
je 0x19e2b
jmp 0x19f48
leaq -0x20(%rbp), %rdi
callq 0x19c50
cmpl $0x0, 0x1292d(%rip)     # 0x2c768
je 0x19e42
jmp 0x19f48
callq 0x14300
cmpl $0x0, 0x1291a(%rip)     # 0x2c768
je 0x19e5e
leaq -0x20(%rbp), %rdi
callq 0x19dc0
jmp 0x19f48
leaq -0x40(%rbp), %rdi
callq 0x19c50
cmpl $0x0, 0x128fa(%rip)     # 0x2c768
je 0x19e75
jmp 0x19f48
leaq 0x128d4(%rip), %rdi     # 0x2c750
addq $0x98, %rdi
callq 0x19dc0
movl -0x20(%rbp), %esi
addl -0x40(%rbp), %esi
leaq 0x128bb(%rip), %rdi     # 0x2c750
addq $0x98, %rdi
xorl %edx, %edx
callq 0x8ee0
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
je 0x19ed8
leaq 0x1289d(%rip), %rdi     # 0x2c750
addq $0x98, %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x8ee0
movl -0x44(%rbp), %edi
movq 0x1293b(%rip), %rsi     # 0x2c808
addq $-0x4, %rsi
callq 0xf740
jmp 0x19f20
movl -0x20(%rbp), %r8d
leaq -0x20(%rbp), %rdi
movl $0x1, %ecx
leaq 0x12864(%rip), %rdx     # 0x2c750
addq $0x98, %rdx
movl %ecx, %esi
callq 0x8a90
movl -0x20(%rbp), %ecx
addl $0x1, %ecx
movl -0x40(%rbp), %r8d
leaq -0x40(%rbp), %rdi
movl $0x1, %esi
leaq 0x1283c(%rip), %rdx     # 0x2c750
addq $0x98, %rdx
callq 0x8a90
movl $0x5, 0x128fe(%rip)     # 0x2c828
leaq 0x1281f(%rip), %rax     # 0x2c750
addq $0x98, %rax
movq %rax, 0x12912(%rip)     # 0x2c850
movl $0x1, 0x129fc(%rip)     # 0x2c944
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/bytecd.c
// Function: get_args
void _get_args()
{
    GL_Path.stemMember = NULL;
    searchView = argsView;
    
    GL_Object.type = var_type;
    if (searchView.windowPtr != NULL)  GL_Object.codeList = &(argsView.windowPtr->variable_ptr->codeList);
    codeNumber = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq $0x0, 0x128a9(%rip) # 0x2c858
movq 0x1292a(%rip), %rax     # 0x2c8e0
movq %rax, 0x128eb(%rip)     # 0x2c8a8
movq 0x12924(%rip), %rax     # 0x2c8e8
movq %rax, 0x128e5(%rip)     # 0x2c8b0
movq 0x1291e(%rip), %rax     # 0x2c8f0
movq %rax, 0x128df(%rip)     # 0x2c8b8
movl $0xffffffff, 0x12845(%rip) # imm = 0xFFFFFFFF
cmpq $0x0, 0x128bd(%rip)     # 0x2c8a8
je 0x1a005
movq 0x128ec(%rip), %rax     # 0x2c8e0
movq 0x10(%rax), %rax
addq $0xd0, %rax
movq %rax, 0x1284b(%rip)     # 0x2c850
movl $0x1, 0x12935(%rip)     # 0x2c944
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/bytecd.c
// Function: this_var
void _this_var()
{
    GL_Path.stemMember = NULL;
    searchView = baseView;
    
    GL_Object.type = var_type;
    GL_Object.codeList = &(baseView.windowPtr->variable_ptr->codeList);
    codeNumber = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq $0x0, 0x12829(%rip) # 0x2c858
movq 0x1285a(%rip), %rax     # 0x2c890
movq %rax, 0x1286b(%rip)     # 0x2c8a8
movq 0x12854(%rip), %rax     # 0x2c898
movq %rax, 0x12865(%rip)     # 0x2c8b0
movq 0x1284e(%rip), %rax     # 0x2c8a0
movq %rax, 0x1285f(%rip)     # 0x2c8b8
movl $0xffffffff, 0x127c5(%rip) # imm = 0xFFFFFFFF
movq 0x12826(%rip), %rax     # 0x2c890
movq 0x10(%rax), %rax
addq $0xd0, %rax
movq %rax, 0x127d5(%rip)     # 0x2c850
movl $0x1, 0x128bf(%rip)     # 0x2c944
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/bytecd.c
// Function: that_var
void _that_var()
{
    GL_Path.stemMember = NULL;
    searchView = thatView;
    
    GL_Object.type = var_type;
    if (searchView.windowPtr != NULL)  GL_Object.codeList = &(thatView.windowPtr->variable_ptr->codeList);
    codeNumber = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq $0x0, 0x127b9(%rip) # 0x2c858
movq 0x1286a(%rip), %rax     # 0x2c910
movq %rax, 0x127fb(%rip)     # 0x2c8a8
movq 0x12864(%rip), %rax     # 0x2c918
movq %rax, 0x127f5(%rip)     # 0x2c8b0
movq 0x1285e(%rip), %rax     # 0x2c920
movq %rax, 0x127ef(%rip)     # 0x2c8b8
movl $0xffffffff, 0x12755(%rip) # imm = 0xFFFFFFFF
cmpq $0x0, 0x127cd(%rip)     # 0x2c8a8
je 0x1a0f5
movq 0x1282c(%rip), %rax     # 0x2c910
movq 0x10(%rax), %rax
addq $0xd0, %rax
movq %rax, 0x1275b(%rip)     # 0x2c850
movl $0x1, 0x12845(%rip)     # 0x2c944
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/bytecd.c
// Function: array_cmd
void _array_cmd()
{
    ccInt theIndex, rtrn;
    
    callNumericFunction(int_type);
    if (errCode != passed)  return;
    theIndex = intRegister;
    
    if (theIndex < 0)  {  setError(invalid_index_err, pcCodePtr-1);  return;  }
    
    callCodeFunction();
    if (errCode != passed)  return;
    
    rtrn = insertElements(&(GL_Object.arrayDimList), 1, 1, ccFalse);
    if (rtrn != passed)  setError(rtrn, pcCodePtr-1);
    else  *LL_int(&(GL_Object.arrayDimList), 1) = theIndex;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x2, %edi
callq 0x14da0
cmpl $0x0, 0x1246f(%rip)     # 0x2c768
je 0x1a300
jmp 0x1a39b
movl 0x124b6(%rip), %eax     # 0x2c7bc
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x1a326
movq 0x124f2(%rip), %rsi     # 0x2c808
addq $-0x4, %rsi
movl $0x1e, %edi
callq 0xf740
jmp 0x1a39b
callq 0x14300
cmpl $0x0, 0x12436(%rip)     # 0x2c768
je 0x1a336
jmp 0x1a39b
leaq 0x12413(%rip), %rdi     # 0x2c750
addq $0xd8, %rdi
addq $0x8, %rdi
movl $0x1, %edx
xorl %ecx, %ecx
movl %edx, %esi
callq 0x8590
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x1a374
movl -0x8(%rbp), %edi
movq 0x1249f(%rip), %rsi     # 0x2c808
addq $-0x4, %rsi
callq 0xf740
jmp 0x1a39b
movl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
leaq 0x123cf(%rip), %rdi     # 0x2c750
addq $0xd8, %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0x9700
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/bytecd.c
// Function: constant_string
void _constant_string()
{
    GL_Object.type = string_type;
    resizeLinkedList(&stringRegister, *pcCodePtr, ccFalse);
    pcCodePtr++;
    
    setElements(&stringRegister, 1, stringRegister.elementNum, (void *) pcCodePtr);
    pcCodePtr += (ccInt) ceil(((ccFloat) stringRegister.elementNum)/sizeof(ccInt));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x4, 0x1231a(%rip)     # 0x2c828
movq 0x122f3(%rip), %rax     # 0x2c808
movl (%rax), %esi
leaq 0x12232(%rip), %rdi     # 0x2c750
addq $0x78, %rdi
xorl %edx, %edx
callq 0x8ee0
movq 0x122d8(%rip), %rax     # 0x2c808
addq $0x4, %rax
movq %rax, 0x122cd(%rip)     # 0x2c808
movl 0x12287(%rip), %edx     # 0x2c7c8
movq 0x122c0(%rip), %rcx     # 0x2c808
leaq 0x12201(%rip), %rdi     # 0x2c750
addq $0x78, %rdi
movl $0x1, %esi
callq 0x93d0
cvtsi2sdl 0x12263(%rip), %xmm0 # 0x2c7c8
movsd 0x7abb(%rip), %xmm1     # 0x22028
divsd %xmm1, %xmm0
callq 0x8070
cvttsd2si %xmm0, %ecx
movq 0x12287(%rip), %rax     # 0x2c808
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x12276(%rip)     # 0x2c808
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/bytecd.c
// Function: code_block
void _code_block()
{
    code_ref *oneCodeRef;
    ccInt rtrn;
    
    derefCodeList(&codeRegister);
    rtrn = resizeLinkedList(&codeRegister, 1, ccFalse);
    if (rtrn != passed)  {  setError(rtrn, pcCodePtr-1);  return;  }
    
    oneCodeRef = (code_ref *) element(&codeRegister, 1);
    oneCodeRef->PLL_index = PCCodeRef.PLL_index;
    oneCodeRef->references = PCCodeRef.references;
    oneCodeRef->code_ptr = pcCodePtr;
    oneCodeRef->anchor = NULL;          // will be 'customized' later
    
    refCodeList(&codeRegister);
    
    runSkipMode(0);     // get over the code without executing any of it
    pcCodePtr++;
    
    GL_Object.type = composite_type;
    GL_Object.codeList = &codeRegister;
    codeNumber = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x121a1(%rip), %rdi     # 0x2c750
addq $0x98, %rdi
callq 0x19dc0
leaq 0x1218e(%rip), %rdi     # 0x2c750
addq $0x98, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x8ee0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x1a5f6
movl -0xc(%rbp), %edi
movq 0x12220(%rip), %rsi     # 0x2c808
addq $-0x4, %rsi
callq 0xf740
jmp 0x1a69c
leaq 0x12153(%rip), %rdi     # 0x2c750
addq $0x98, %rdi
movl $0x1, %esi
callq 0x9700
movq %rax, -0x8(%rbp)
movl 0x12340(%rip), %ecx     # 0x2c958
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq 0x1233b(%rip), %rcx     # 0x2c960
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq 0x121d4(%rip), %rcx     # 0x2c808
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
leaq 0x12101(%rip), %rdi     # 0x2c750
addq $0x98, %rdi
callq 0x19f50
xorl %edi, %edi
callq 0x1a6b0
movq 0x1219f(%rip), %rax     # 0x2c808
addq $0x4, %rax
movq %rax, 0x12194(%rip)     # 0x2c808
movl $0x5, 0x121aa(%rip)     # 0x2c828
leaq 0x120cb(%rip), %rax     # 0x2c750
addq $0x98, %rax
movq %rax, 0x121be(%rip)     # 0x2c850
movl $0x1, 0x122a8(%rip)     # 0x2c944
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/bytecd.c
// Function: runSkipMode
void runSkipMode(ccInt codesToSkip)
{
    while (*pcCodePtr != end_of_script)  {
        if ((*pcCodePtr == code_marker) && (codesToSkip != 0))    {
            codesToSkip--;
            if (codesToSkip == 0)  return;    }
        callSkipFunction();
        if (errCode != passed)  return;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq 0x12146(%rip), %rax     # 0x2c808
cmpl $0x0, (%rax)
je 0x1a6fe
movq 0x1213a(%rip), %rax     # 0x2c808
cmpl $0x4, (%rax)
jne 0x1a6ec
cmpl $0x0, -0x4(%rbp)
je 0x1a6ec
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x1a6ea
jmp 0x1a6fe
jmp 0x1a6ec
callq 0x194a0
cmpl $0x0, 0x12070(%rip)     # 0x2c768
je 0x1a6fc
jmp 0x1a6fe
jmp 0x1a6bb
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/bytecd.c
// Function: numAdapter
void numAdapter(ccInt numType)
{
    variable *theVariable;
    void(*loadNum)(variable *, ccInt);
    
    pcCodePtr--;
    callBytecodeFunction();        // read in an argument
    if (errCode != passed)  return;
    
    if ((GL_Object.type != var_type) || (searchView.windowPtr == NULL))
        {  setError(not_a_variable_err, pcCodePtr-1);  return;  }
    
    if (searchView.width != 1)  {  setError(multiple_indices_not_allowed_err, pcCodePtr-1);  return;  }
    theVariable = searchView.windowPtr->variable_ptr;
    if ((theVariable->type < char_type) || (theVariable->type > double_type))
        {  setError(not_a_number_err, pcCodePtr-1);  return;  }    // must be numeric
    
    if (numType == int_type)  loadNum = &loadIntRegister;
    else if (numType == double_type)  loadNum = &loadDoubleRegister;
    else if (theVariable->type == double_type)  loadNum = &loadDoubleRegister;
    else  loadNum = &loadIntRegister;
    
    loadNum(searchView.windowPtr->variable_ptr, searchView.offset);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq 0x120b6(%rip), %rax     # 0x2c808
addq $-0x4, %rax
movq %rax, 0x120ab(%rip)     # 0x2c808
callq 0x146f0
cmpl $0x0, 0x11fff(%rip)     # 0x2c768
je 0x1a770
jmp 0x1a866
cmpl $-0x1, 0x120b1(%rip)    # 0x2c828
jne 0x1a783
cmpq $0x0, 0x12127(%rip)     # 0x2c8a8
jne 0x1a79d
movq 0x1207e(%rip), %rsi     # 0x2c808
addq $-0x4, %rsi
movl $0x22, %edi
callq 0xf740
jmp 0x1a866
cmpl $0x1, 0x12110(%rip)     # 0x2c8b4
je 0x1a7c0
movq 0x1205b(%rip), %rsi     # 0x2c808
addq $-0x4, %rsi
movl $0x1f, %edi
callq 0xf740
jmp 0x1a866
movq 0x120e1(%rip), %rax     # 0x2c8a8
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, 0xc0(%rax)
jl 0x1a7e9
movq -0x10(%rbp), %rax
cmpl $0x3, 0xc0(%rax)
jle 0x1a800
movq 0x12018(%rip), %rsi     # 0x2c808
addq $-0x4, %rsi
movl $0x29, %edi
callq 0xf740
jmp 0x1a866
cmpl $0x2, -0x4(%rbp)
jne 0x1a813
leaq 0x73(%rip), %rax        # 0x1a880
movq %rax, -0x18(%rbp)
jmp 0x1a84f
cmpl $0x3, -0x4(%rbp)
jne 0x1a826
leaq 0xb0(%rip), %rax        # 0x1a8d0
movq %rax, -0x18(%rbp)
jmp 0x1a84d
movq -0x10(%rbp), %rax
cmpl $0x3, 0xc0(%rax)
jne 0x1a840
leaq 0x96(%rip), %rax        # 0x1a8d0
movq %rax, -0x18(%rbp)
jmp 0x1a84b
leaq 0x39(%rip), %rax        # 0x1a880
movq %rax, -0x18(%rbp)
jmp 0x1a84d
jmp 0x1a84f
movq -0x18(%rbp), %rax
movq 0x1204e(%rip), %rcx     # 0x2c8a8
movq 0x10(%rcx), %rdi
movl 0x1204c(%rip), %esi     # 0x2c8b0
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/bytecd.c
// Function: checkBytecodeSentences
void checkBytecodeSentences()
{
    ccInt rtrn;
    
    while (*pcCodePtr != end_of_script)   {
        
        
            // keep track of our sentence beginnings for checkBytecode()
            
        rtrn = addElements(&sentenceList, 1, ccFalse);
        if (rtrn != passed)  {  setError(out_of_memory_err, pcCodePtr);  return;  }
        *(ccInt **) findElement(&sentenceList, sentenceList.elementNum) = pcCodePtr;
        
        
            // run each outermost command
        
        checkBytecodeArg(start_arg);
        if (errCode != passed)  break;         }
        
        
        // add the null terminator as a valid jump point
    
    rtrn = addElements(&sentenceList, 1, ccFalse);
    if (rtrn != passed)  {  setError(out_of_memory_err, pcCodePtr);  return;  }
    *(ccInt **) findElement(&sentenceList, sentenceList.elementNum) = pcCodePtr;
    
    if (errCode == passed)  pcCodePtr++;   // get past the null terminator
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq 0x11889(%rip), %rax     # 0x2c808
cmpl $0x0, (%rax)
je 0x1afff
leaq 0x117c5(%rip), %rdi     # 0x2c750
addq $0x268, %rdi            # imm = 0x268
movl $0x1, %esi
xorl %edx, %edx
callq 0x8e70
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x1afbd
movq 0x1185a(%rip), %rsi     # 0x2c808
movl $0x1, %edi
callq 0xf740
jmp 0x1b07b
movq 0x11844(%rip), %rax     # 0x2c808
movq %rax, -0x10(%rbp)
movl 0x119ea(%rip), %esi     # 0x2c9b8
leaq 0x1177b(%rip), %rdi     # 0x2c750
addq $0x268, %rdi            # imm = 0x268
callq 0x96b0
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
xorl %edi, %edi
callq 0x1b090
cmpl $0x0, 0x11772(%rip)     # 0x2c768
je 0x1affa
jmp 0x1afff
jmp 0x1af78
leaq 0x1174a(%rip), %rdi     # 0x2c750
addq $0x268, %rdi            # imm = 0x268
movl $0x1, %esi
xorl %edx, %edx
callq 0x8e70
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x1b035
movq 0x117df(%rip), %rsi     # 0x2c808
movl $0x1, %edi
callq 0xf740
jmp 0x1b07b
movq 0x117cc(%rip), %rax     # 0x2c808
movq %rax, -0x18(%rbp)
movl 0x11972(%rip), %esi     # 0x2c9b8
leaq 0x11703(%rip), %rdi     # 0x2c750
addq $0x268, %rdi            # imm = 0x268
callq 0x96b0
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
cmpl $0x0, 0x11701(%rip)     # 0x2c768
jne 0x1b07b
movq 0x11798(%rip), %rax     # 0x2c808
addq $0x4, %rax
movq %rax, 0x1178d(%rip)     # 0x2c808
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/bytecd.c
// Function: checkBytecodeArg
void checkBytecodeArg(ccInt tableID)     // runs a bytecode function via the check jump tables
{
    ccInt theCommand = *pcCodePtr;
    
    if ((theCommand < 0) || (theCommand >= commands_num))  {  setError(illegal_command_err, pcCodePtr);  return;  }
    
    pcCodePtr++;
    if (pcCodePtr >= endCodePtr)  {  pcCodePtr = endCodePtr;  setError(code_overflow_err, pcCodePtr);  return;  }
    
    checkJumpTables[tableID][theCommand](theCommand);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq 0x11766(%rip), %rax     # 0x2c808
movl (%rax), %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jl 0x1b0b3
cmpl $0x3a, -0x8(%rbp)
jl 0x1b0c6
movq 0x1174e(%rip), %rsi     # 0x2c808
movl $0x12, %edi
callq 0xf740
jmp 0x1b12b
movq 0x1173b(%rip), %rax     # 0x2c808
addq $0x4, %rax
movq %rax, 0x11730(%rip)     # 0x2c808
movq 0x11729(%rip), %rax     # 0x2c808
cmpq 0x11732(%rip), %rax     # 0x2c818
jb 0x1b109
movq 0x11729(%rip), %rax     # 0x2c818
movq %rax, 0x11712(%rip)     # 0x2c808
movq 0x1170b(%rip), %rsi     # 0x2c808
movl $0x13, %edi
callq 0xf740
jmp 0x1b12b
movslq -0x4(%rbp), %rcx
leaq 0xf78c(%rip), %rax      # 0x2a8a0
imulq $0x1d0, %rcx, %rcx      # imm = 0x1D0
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl -0x8(%rbp), %edi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/bytecd.c
// Function: checkCommand
void checkCommand(ccInt theCmd)      // checks bread-and-butter operators
{
    if (theCmd == define_equate)  pcCodePtr++;
    if ((theCmd == code_number) || (theCmd == substitute_code))  {
        if ((rightArgs[theCmd] != no_arg) && (errCode == passed))  checkBytecodeArg(rightArgs[theCmd]);
        if ((leftArgs[theCmd] != no_arg) && (errCode == passed))  checkBytecodeArg(leftArgs[theCmd]);     }
    else  {
        if ((leftArgs[theCmd] != no_arg) && (errCode == passed))  checkBytecodeArg(leftArgs[theCmd]);
        if ((rightArgs[theCmd] != no_arg) && (errCode == passed))  checkBytecodeArg(rightArgs[theCmd]);     }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x8, -0x4(%rbp)
jne 0x1b163
movq 0x116b0(%rip), %rax     # 0x2c808
addq $0x4, %rax
movq %rax, 0x116a5(%rip)     # 0x2c808
cmpl $0x25, -0x4(%rbp)
je 0x1b16f
cmpl $0x26, -0x4(%rbp)
jne 0x1b1d3
movslq -0x4(%rbp), %rcx
leaq 0xf6a6(%rip), %rax      # 0x2a820
movsbl (%rax,%rcx), %eax
cmpl $0x5, %eax
je 0x1b1a0
cmpl $0x0, 0x115de(%rip)     # 0x2c768
jne 0x1b1a0
movslq -0x4(%rbp), %rcx
leaq 0xf689(%rip), %rax      # 0x2a820
movsbl (%rax,%rcx), %edi
callq 0x1b090
movslq -0x4(%rbp), %rcx
leaq 0xf6b5(%rip), %rax      # 0x2a860
movsbl (%rax,%rcx), %eax
cmpl $0x5, %eax
je 0x1b1d1
cmpl $0x0, 0x115ad(%rip)     # 0x2c768
jne 0x1b1d1
movslq -0x4(%rbp), %rcx
leaq 0xf698(%rip), %rax      # 0x2a860
movsbl (%rax,%rcx), %edi
callq 0x1b090
jmp 0x1b237
movslq -0x4(%rbp), %rcx
leaq 0xf682(%rip), %rax      # 0x2a860
movsbl (%rax,%rcx), %eax
cmpl $0x5, %eax
je 0x1b204
cmpl $0x0, 0x1157a(%rip)     # 0x2c768
jne 0x1b204
movslq -0x4(%rbp), %rcx
leaq 0xf665(%rip), %rax      # 0x2a860
movsbl (%rax,%rcx), %edi
callq 0x1b090
movslq -0x4(%rbp), %rcx
leaq 0xf611(%rip), %rax      # 0x2a820
movsbl (%rax,%rcx), %eax
cmpl $0x5, %eax
je 0x1b235
cmpl $0x0, 0x11549(%rip)     # 0x2c768
jne 0x1b235
movslq -0x4(%rbp), %rcx
leaq 0xf5f4(%rip), %rax      # 0x2a820
movsbl (%rax,%rcx), %edi
callq 0x1b090
jmp 0x1b237
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/bytecd.c
// Function: checkInteger
void checkInteger(ccInt theCmd)          // checks commands that have integer constants
{
    pcCodePtr++;
    if (pcCodePtr >= endCodePtr)  {  pcCodePtr = endCodePtr;  setError(code_overflow_err, pcCodePtr);  }
    
    if ((leftArgs[theCmd] != no_arg) && (errCode == passed))  checkBytecodeArg(leftArgs[theCmd]);
    if ((rightArgs[theCmd] != no_arg) && (errCode == passed))  checkBytecodeArg(rightArgs[theCmd]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq 0x11506(%rip), %rax     # 0x2c808
addq $0x4, %rax
movq %rax, 0x114fb(%rip)     # 0x2c808
movq 0x114f4(%rip), %rax     # 0x2c808
cmpq 0x114fd(%rip), %rax     # 0x2c818
jb 0x1b33c
movq 0x114f4(%rip), %rax     # 0x2c818
movq %rax, 0x114dd(%rip)     # 0x2c808
movq 0x114d6(%rip), %rsi     # 0x2c808
movl $0x13, %edi
callq 0xf740
movslq -0x4(%rbp), %rcx
leaq 0xf519(%rip), %rax      # 0x2a860
movsbl (%rax,%rcx), %eax
cmpl $0x5, %eax
je 0x1b36d
cmpl $0x0, 0x11411(%rip)     # 0x2c768
jne 0x1b36d
movslq -0x4(%rbp), %rcx
leaq 0xf4fc(%rip), %rax      # 0x2a860
movsbl (%rax,%rcx), %edi
callq 0x1b090
movslq -0x4(%rbp), %rcx
leaq 0xf4a8(%rip), %rax      # 0x2a820
movsbl (%rax,%rcx), %eax
cmpl $0x5, %eax
je 0x1b39e
cmpl $0x0, 0x113e0(%rip)     # 0x2c768
jne 0x1b39e
movslq -0x4(%rbp), %rcx
leaq 0xf48b(%rip), %rax      # 0x2a820
movsbl (%rax,%rcx), %edi
callq 0x1b090
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/bytecd.c
// Function: checkString
void checkString(ccInt theCmd)    // checks inlined strings
{
    ccInt sizeofStrings = *pcCodePtr;
    if (sizeofStrings < 0)  {  setError(illegal_command_err, pcCodePtr);  return;  }
    
    sizeofStrings += align(sizeofStrings);
    
    pcCodePtr++;
    
    if (pcCodePtr + (ccInt) ceil(1.*sizeofStrings/sizeof(ccInt)) >= endCodePtr)      // step over the width of the string
        {  pcCodePtr = endCodePtr;  setError(code_overflow_err, pcCodePtr);  return;  }
    pcCodePtr += (ccInt) ceil(1.*sizeofStrings/sizeof(ccInt));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq 0x113e6(%rip), %rax     # 0x2c808
movl (%rax), %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x1b443
movq 0x113d4(%rip), %rsi     # 0x2c808
movl $0x12, %edi
callq 0xf740
jmp 0x1b50a
movl -0x8(%rbp), %edi
callq 0x10550
addl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movq 0x113b0(%rip), %rax     # 0x2c808
addq $0x4, %rax
movq %rax, 0x113a5(%rip)     # 0x2c808
movq 0x1139e(%rip), %rax     # 0x2c808
movq %rax, -0x10(%rbp)
cvtsi2sdl -0x8(%rbp), %xmm1
movsd 0x6b8d(%rip), %xmm0     # 0x22008
mulsd %xmm1, %xmm0
movsd 0x6ba1(%rip), %xmm1     # 0x22028
divsd %xmm1, %xmm0
callq 0x8070
movq -0x10(%rbp), %rax
cvttsd2si %xmm0, %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
cmpq 0x1136f(%rip), %rax     # 0x2c818
jb 0x1b4cc
movq 0x11366(%rip), %rax     # 0x2c818
movq %rax, 0x1134f(%rip)     # 0x2c808
movq 0x11348(%rip), %rsi     # 0x2c808
movl $0x13, %edi
callq 0xf740
jmp 0x1b50a
cvtsi2sdl -0x8(%rbp), %xmm1
movsd 0x6b2f(%rip), %xmm0     # 0x22008
mulsd %xmm1, %xmm0
movsd 0x6b43(%rip), %xmm1     # 0x22028
divsd %xmm1, %xmm0
callq 0x8070
cvttsd2si %xmm0, %ecx
movq 0x1130f(%rip), %rax     # 0x2c808
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x112fe(%rip)     # 0x2c808
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/bytecd.c
// Function: checkJump
void checkJump(ccInt theCmd)     // cheks conditional/unconditional jumps
{
    ccInt rtrn, jumpOffset = *pcCodePtr;
    
    if (pcCodePtr + jumpOffset >= endCodePtr)  {  setError(bad_jump_err, pcCodePtr);  return;  }
    
    
        // Add the jump position to checkBytecode()'s jumpList.
    
    rtrn = addElements(&jumpList, 1, ccFalse);
    if (rtrn != passed)  {  setError(out_of_memory_err, pcCodePtr);  return;  }
    rtrn = addElements(&jumpFromList, 1, ccFalse);
    if (rtrn != passed)  {  setError(out_of_memory_err, pcCodePtr);  return;  }
    *(ccInt **) findElement(&jumpList, jumpList.elementNum) = pcCodePtr + jumpOffset;
    *(ccInt **) findElement(&jumpFromList, jumpFromList.elementNum) = pcCodePtr;
    
    pcCodePtr++;
    if (pcCodePtr >= endCodePtr)  {  pcCodePtr = endCodePtr;  setError(code_overflow_err, pcCodePtr);  return;  }
    
    if ((rightArgs[theCmd] != no_arg) && (errCode == passed))  checkBytecodeArg(rightArgs[theCmd]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq 0x112c6(%rip), %rax     # 0x2c808
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movq 0x112ba(%rip), %rax     # 0x2c808
movslq -0xc(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
cmpq 0x112b8(%rip), %rax     # 0x2c818
jb 0x1b578
movq 0x1129f(%rip), %rsi     # 0x2c808
movl $0x15, %edi
callq 0xf740
jmp 0x1b6bf
leaq 0x111d1(%rip), %rdi     # 0x2c750
addq $0x228, %rdi            # imm = 0x228
movl $0x1, %esi
xorl %edx, %edx
callq 0x8e70
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x1b5b1
movq 0x11266(%rip), %rsi     # 0x2c808
movl $0x1, %edi
callq 0xf740
jmp 0x1b6bf
leaq 0x11198(%rip), %rdi     # 0x2c750
addq $0x248, %rdi            # imm = 0x248
movl $0x1, %esi
xorl %edx, %edx
callq 0x8e70
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x1b5ea
movq 0x1122d(%rip), %rsi     # 0x2c808
movl $0x1, %edi
callq 0xf740
jmp 0x1b6bf
movq 0x11217(%rip), %rax     # 0x2c808
movslq -0xc(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl 0x11372(%rip), %esi     # 0x2c978
leaq 0x11143(%rip), %rdi     # 0x2c750
addq $0x228, %rdi            # imm = 0x228
callq 0x96b0
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
movq 0x111e1(%rip), %rax     # 0x2c808
movq %rax, -0x18(%rbp)
movl 0x11367(%rip), %esi     # 0x2c998
leaq 0x11118(%rip), %rdi     # 0x2c750
addq $0x248, %rdi            # imm = 0x248
callq 0x96b0
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movq 0x111b6(%rip), %rax     # 0x2c808
addq $0x4, %rax
movq %rax, 0x111ab(%rip)     # 0x2c808
movq 0x111a4(%rip), %rax     # 0x2c808
cmpq 0x111ad(%rip), %rax     # 0x2c818
jb 0x1b68e
movq 0x111a4(%rip), %rax     # 0x2c818
movq %rax, 0x1118d(%rip)     # 0x2c808
movq 0x11186(%rip), %rsi     # 0x2c808
movl $0x13, %edi
callq 0xf740
jmp 0x1b6bf
movslq -0x4(%rbp), %rcx
leaq 0xf187(%rip), %rax      # 0x2a820
movsbl (%rax,%rcx), %eax
cmpl $0x5, %eax
je 0x1b6bf
cmpl $0x0, 0x110bf(%rip)     # 0x2c768
jne 0x1b6bf
movslq -0x4(%rbp), %rcx
leaq 0xf16a(%rip), %rax      # 0x2a820
movsbl (%rax,%rcx), %edi
callq 0x1b090
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/bytecd.c
// Function: checkIndices
void checkIndices(ccInt theCmd)     // checks array operators [] of various sorts
{
    if (theCmd == type_array)  checkBytecodeArg(data_arg);
    if ((leftArgs[theCmd] != no_arg) && (errCode == passed))  checkBytecodeArg(leftArgs[theCmd]);
    if ((rightArgs[theCmd] != no_arg) && (errCode == passed))  checkBytecodeArg(rightArgs[theCmd]);
    
    if (theCmd != type_array)  {
        checkBytecodeArg(data_arg);
        if (((theCmd == step_to_indices) || (theCmd == insert_indices)) && (errCode == passed))  {
            checkBytecodeArg(data_arg);     }   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x2e, -0x4(%rbp)
jne 0x1b6eb
movl $0x2, %edi
callq 0x1b090
movslq -0x4(%rbp), %rcx
leaq 0xf16a(%rip), %rax      # 0x2a860
movsbl (%rax,%rcx), %eax
cmpl $0x5, %eax
je 0x1b71c
cmpl $0x0, 0x11062(%rip)     # 0x2c768
jne 0x1b71c
movslq -0x4(%rbp), %rcx
leaq 0xf14d(%rip), %rax      # 0x2a860
movsbl (%rax,%rcx), %edi
callq 0x1b090
movslq -0x4(%rbp), %rcx
leaq 0xf0f9(%rip), %rax      # 0x2a820
movsbl (%rax,%rcx), %eax
cmpl $0x5, %eax
je 0x1b74d
cmpl $0x0, 0x11031(%rip)     # 0x2c768
jne 0x1b74d
movslq -0x4(%rbp), %rcx
leaq 0xf0dc(%rip), %rax      # 0x2a820
movsbl (%rax,%rcx), %edi
callq 0x1b090
cmpl $0x2e, -0x4(%rbp)
je 0x1b77e
movl $0x2, %edi
callq 0x1b090
cmpl $0xd, -0x4(%rbp)
je 0x1b769
cmpl $0x11, -0x4(%rbp)
jne 0x1b77c
cmpl $0x0, 0x10ff8(%rip)     # 0x2c768
jne 0x1b77c
movl $0x2, %edi
callq 0x1b090
jmp 0x1b77e
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/bytecd.c
// Function: runBytecode
void runBytecode()
{
    while ((*pcCodePtr != end_of_script) && (*pcCodePtr != code_marker))   {
        callSentenceStartFunction();
        if (errCode != passed)  return;         }
    
    pcCodePtr++;         // over the 0 or code marker
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
jmp 0x1b7ca
movq 0x11037(%rip), %rcx     # 0x2c808
xorl %eax, %eax
cmpl $0x0, (%rcx)
movb %al, -0x1(%rbp)
je 0x1b7eb
movq 0x11026(%rip), %rax     # 0x2c808
cmpl $0x4, (%rax)
setne %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
testb $0x1, %al
jne 0x1b7f4
jmp 0x1b806
callq 0x1b820
cmpl $0x0, 0x10f68(%rip)     # 0x2c768
je 0x1b804
jmp 0x1b818
jmp 0x1b7ca
movq 0x10ffb(%rip), %rax     # 0x2c808
addq $0x4, %rax
movq %rax, 0x10ff0(%rip)     # 0x2c808
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/bytecd.c
// Function: loadStringRegister
void loadStringRegister(variable *sourceVar, ccInt sourceOffset)
{
    window *stringCharsWindow = LL_member(sourceVar, sourceOffset + 1)->memberWindow;
    ccInt rtrn = resizeLinkedList(&stringRegister, stringCharsWindow->width, ccFalse);
    if (rtrn != passed)  setError(rtrn, pcCodePtr-1);
    
    copyElements(&(stringCharsWindow->variable_ptr->mem.data), stringCharsWindow->offset+1, &stringRegister, 1, stringRegister.elementNum);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
callq 0x9700
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x1c(%rax), %esi
leaq 0x10d89(%rip), %rdi     # 0x2c750
addq $0x78, %rdi
xorl %edx, %edx
callq 0x8ee0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x1b9ee
movl -0x1c(%rbp), %edi
movq 0x10e23(%rip), %rsi     # 0x2c808
addq $-0x4, %rsi
callq 0xf740
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
addq $0x10, %rdi
movq -0x18(%rbp), %rax
movl 0x18(%rax), %esi
addl $0x1, %esi
movl 0x10dbd(%rip), %r8d     # 0x2c7c8
leaq 0x10d3e(%rip), %rdx     # 0x2c750
addq $0x78, %rdx
movl $0x1, %ecx
callq 0x8a90
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/ciclib.c
// Function: cclib_load
void cclib_load()
{
    window *fileNameWindow;
    linkedlist *fileNameLL;
    ccInt rtrn;
    char *fileString;
    
    
        // get the name of the file (arg 1)
    
    if (numBIF_args() != 1)  {  setError(wrong_argument_count_err, pcCodePtr-1);  return;  }
    
    fileNameWindow = getBIFstringArg(1);
    if (errCode != passed)  return;
    fileNameLL = &(fileNameWindow->variable_ptr->mem.data);
    
    
        // copy the file name, plus a null terminator, into a separate buffer
    
    fileString = (char *) malloc(fileNameWindow->width+1);
    if (fileString == NULL)  {  setError(out_of_memory_err, pcCodePtr-1);  return;  }
    getElements(fileNameLL, fileNameWindow->offset+1, fileNameWindow->width, fileString);
    fileString[fileNameWindow->width] = 0;
    
    
        // try to open the file; throw an error if unsuccessful
    
    rtrn = loadFile(fileString, &stringRegister, ccFalse);
    if (rtrn != passed)  setError(rtrn, pcCodePtr-1);
    
    free((void *) fileString);      // clean up
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x1fa40
cmpl $0x1, %eax
je 0x1d9f3
leaq 0xed77(%rip), %rax      # 0x2c750
movq 0xb8(%rax), %rsi
addq $-0x4, %rsi
movl $0x2d, %edi
callq 0xf740
jmp 0x1dace
movl $0x1, %edi
callq 0x1fd70
movq %rax, -0x8(%rbp)
leaq 0xed48(%rip), %rax      # 0x2c750
cmpl $0x0, 0x18(%rax)
je 0x1da13
jmp 0x1dace
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x81d0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1da5e
leaq 0xed09(%rip), %rax      # 0x2c750
movq 0xb8(%rax), %rsi
addq $-0x4, %rsi
movl $0x1, %edi
callq 0xf740
jmp 0x1dace
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x18(%rax), %esi
addl $0x1, %esi
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %edx
movq -0x20(%rbp), %rcx
callq 0x9540
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x1c(%rcx), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rdi
leaq 0xecb9(%rip), %rsi      # 0x2c750
addq $0x78, %rsi
xorl %edx, %edx
callq 0x1feb0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x1dac5
movl -0x14(%rbp), %edi
leaq 0xec9b(%rip), %rax      # 0x2c750
movq 0xb8(%rax), %rsi
addq $-0x4, %rsi
callq 0xf740
movq -0x20(%rbp), %rdi
callq 0x81c0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/ciclib.c
// Function: cclib_top
void cclib_top()
{
    view viewToTop;
    
    if (numBIF_args() != 1)  {  setError(wrong_argument_count_err, pcCodePtr-1);  return;  }
    
    
        // get the argument variable
    
    viewToTop.windowPtr = getBIFmember(1);
    if (viewToTop.windowPtr == NULL)  {  setError(void_member_err, pcCodePtr-1);  return;  }
    if (viewToTop.windowPtr->variable_ptr->type < string_type)  {  setError(not_composite_err, pcCodePtr-1);  return;  }
    viewToTop.offset = viewToTop.windowPtr->offset;
    
    intRegister = numMemberIndices(&viewToTop);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x1fa40
cmpl $0x1, %eax
je 0x1ecf3
leaq 0xda77(%rip), %rax      # 0x2c750
movq 0xb8(%rax), %rsi
addq $-0x4, %rsi
movl $0x2d, %edi
callq 0xf740
jmp 0x1ed74
movl $0x1, %edi
callq 0x1fab0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1ed26
leaq 0xda41(%rip), %rax      # 0x2c750
movq 0xb8(%rax), %rsi
addq $-0x4, %rsi
movl $0x1a, %edi
callq 0xf740
jmp 0x1ed74
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x4, 0xc0(%rax)
jge 0x1ed55
leaq 0xda12(%rip), %rax      # 0x2c750
movq 0xb8(%rax), %rsi
addq $-0x4, %rsi
movl $0x24, %edi
callq 0xf740
jmp 0x1ed74
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x12ad0
movl %eax, %ecx
leaq 0xd9df(%rip), %rax      # 0x2c750
movl %ecx, 0x6c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/ciclib.c
// Function: cclib_size
void cclib_size()
{
    view viewToSize;
    ccInt dataSize = 0, sizeofStrings = 0, ssMode, numArgs = numBIF_args();
    ccBool trueSize = ccFalse;
    
    
        // read in the arguments
        // optional arg 2:  whether or not to double-count overlapping memory
    
    if ((numArgs != 1) && (numArgs != 2))  {  setError(wrong_argument_count_err, pcCodePtr-1);  return;  }
    
    viewToSize.windowPtr = getBIFmember(1);
    
    if (numArgs == 2)  {
        trueSize = getBIFboolArg(2);
        if (errCode != passed)  return;     }


        // calculate the size
    
    if (viewToSize.windowPtr != NULL)  {
        viewToSize.offset = viewToSize.windowPtr->offset;
        viewToSize.width = viewToSize.windowPtr->width;
        
        if (!trueSize)  sizeView(&viewToSize, &dataSize, &sizeofStrings);
        else  {
        for (ssMode = 1; ssMode <= 3; ssMode++)  {
            storageSizeView(&viewToSize, (void *) &dataSize, (void *) &ssMode);
        }}
        
        intRegister = dataSize+sizeofStrings;       }
    
    else  intRegister = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
callq 0x1fa40
movl %eax, -0x28(%rbp)
movb $0x0, -0x29(%rbp)
cmpl $0x1, -0x28(%rbp)
je 0x1edcf
cmpl $0x2, -0x28(%rbp)
je 0x1edcf
leaq 0xd99b(%rip), %rax      # 0x2c750
movq 0xb8(%rax), %rsi
addq $-0x4, %rsi
movl $0x2d, %edi
callq 0xf740
jmp 0x1ee83
movl $0x1, %edi
callq 0x1fab0
movq %rax, -0x18(%rbp)
cmpl $0x2, -0x28(%rbp)
jne 0x1ee04
movl $0x2, %edi
callq 0x1ffe0
movb %al, -0x29(%rbp)
leaq 0xd959(%rip), %rax      # 0x2c750
cmpl $0x0, 0x18(%rax)
je 0x1ee02
jmp 0x1ee83
jmp 0x1ee04
cmpq $0x0, -0x18(%rbp)
je 0x1ee75
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0xc(%rbp)
cmpb $0x0, -0x29(%rbp)
jne 0x1ee38
leaq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x10160
jmp 0x1ee63
movl $0x1, -0x24(%rbp)
cmpl $0x3, -0x24(%rbp)
jg 0x1ee61
leaq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
leaq -0x24(%rbp), %rdx
callq 0x10590
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1ee3f
jmp 0x1ee63
movl -0x1c(%rbp), %ecx
addl -0x20(%rbp), %ecx
leaq 0xd8e0(%rip), %rax      # 0x2c750
movl %ecx, 0x6c(%rax)
jmp 0x1ee83
leaq 0xd8d4(%rip), %rax      # 0x2c750
movl $0x0, 0x6c(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/ciclib.c
// Function: cclib_type
void cclib_type()
{
    window *hostWindow;
    ccInt numArgs = numBIF_args();


        // get the variable (arg 1)
    
    if ((numArgs < 1) || (numArgs > 2))  {  setError(wrong_argument_count_err, pcCodePtr-1);  return;  }
    hostWindow = getBIFmember(1);
    if (hostWindow == NULL)  {  setError(void_member_err, pcCodePtr-1);  return;  }
    
    
        // return the requested piece of information
    
    if (numArgs == 1)  intRegister = hostWindow->variable_ptr->type;
    
    else if (hostWindow->variable_ptr->type == composite_type)  {
        ccInt memberIndex = getBIFnumArg(2, 1., (ccFloat) hostWindow->variable_ptr->mem.members.elementNum);
        if (errCode == passed)  {
            intRegister = LL_member(hostWindow->variable_ptr, memberIndex)->type;
    }   }
    
    else  setError(not_composite_err, pcCodePtr-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x1fa40
movl %eax, -0xc(%rbp)
cmpl $0x1, -0xc(%rbp)
jl 0x1f40c
cmpl $0x2, -0xc(%rbp)
jle 0x1f42d
leaq 0xd33d(%rip), %rax      # 0x2c750
movq 0xb8(%rax), %rsi
addq $-0x4, %rsi
movl $0x2d, %edi
callq 0xf740
jmp 0x1f50b
movl $0x1, %edi
callq 0x1fab0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1f463
leaq 0xd307(%rip), %rax      # 0x2c750
movq 0xb8(%rax), %rsi
addq $-0x4, %rsi
movl $0x1a, %edi
callq 0xf740
jmp 0x1f50b
cmpl $0x1, -0xc(%rbp)
jne 0x1f486
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl 0xc0(%rax), %ecx
leaq 0xd2d2(%rip), %rax      # 0x2c750
movl %ecx, 0x6c(%rax)
jmp 0x1f50b
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x5, 0xc0(%rax)
jne 0x1f4ed
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cvtsi2sdl 0x10(%rax), %xmm1
movl $0x2, %edi
movsd 0x2b57(%rip), %xmm0     # 0x22008
callq 0x1fb80
cvttsd2si %xmm0, %eax
movl %eax, -0x10(%rbp)
leaq 0xd28c(%rip), %rax      # 0x2c750
cmpl $0x0, 0x18(%rax)
jne 0x1f4eb
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
addq $0x10, %rdi
movl -0x10(%rbp), %esi
callq 0x9700
movl 0x10(%rax), %ecx
leaq 0xd268(%rip), %rax      # 0x2c750
movl %ecx, 0x6c(%rax)
jmp 0x1f509
leaq 0xd25c(%rip), %rax      # 0x2c750
movq 0xb8(%rax), %rsi
addq $-0x4, %rsi
movl $0x24, %edi
callq 0xf740
jmp 0x1f50b
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/ciclib.c
// Function: cclib_member_ID
void cclib_member_ID()
{
    window *hostWindow;
    ccInt memberIndex, memberNumber, entryOffset, rtrn;
    member *soughtMember;
    
    if (numBIF_args() != 2)  {  setError(wrong_argument_count_err, pcCodePtr-1);  return;  }
    
    
        // get the variable containing the member (arg 1)
    
    hostWindow = getBIFmember(1);
    if (hostWindow == NULL)  {  setError(void_member_err, pcCodePtr-1);  return;  }
    if (hostWindow->variable_ptr->type < composite_type)  {  setError(type_mismatch_err, pcCodePtr-1);  return;  }
    
    
        // get the member index -- arg 2
    
    memberIndex = (ccInt) getBIFnumArg(2, 1., (ccFloat) hostWindow->variable_ptr->mem.members.elementNum);
    if (errCode != passed)  return;
    rtrn = findMemberIndex(hostWindow->variable_ptr, 0, memberIndex, &soughtMember, &memberNumber, &entryOffset, ccFalse);
    if (rtrn != passed)  {  setError(rtrn, pcCodePtr-1);  return;  }
    
    
        // return the ID number
    
    intRegister = soughtMember->memberID;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
callq 0x1fa40
cmpl $0x2, %eax
je 0x1f553
leaq 0xd217(%rip), %rax      # 0x2c750
movq 0xb8(%rax), %rsi
addq $-0x4, %rsi
movl $0x2d, %edi
callq 0xf740
jmp 0x1f64b
movl $0x1, %edi
callq 0x1fab0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1f589
leaq 0xd1e1(%rip), %rax      # 0x2c750
movq 0xb8(%rax), %rsi
addq $-0x4, %rsi
movl $0x1a, %edi
callq 0xf740
jmp 0x1f64b
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x5, 0xc0(%rax)
jge 0x1f5bb
leaq 0xd1af(%rip), %rax      # 0x2c750
movq 0xb8(%rax), %rsi
addq $-0x4, %rsi
movl $0x11, %edi
callq 0xf740
jmp 0x1f64b
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cvtsi2sdl 0x10(%rax), %xmm1
movl $0x2, %edi
movsd 0x2a33(%rip), %xmm0     # 0x22008
callq 0x1fb80
cvttsd2si %xmm0, %eax
movl %eax, -0xc(%rbp)
leaq 0xd168(%rip), %rax      # 0x2c750
cmpl $0x0, 0x18(%rax)
je 0x1f5f0
jmp 0x1f64b
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %edx
xorl %esi, %esi
leaq -0x20(%rbp), %rcx
leaq -0x10(%rbp), %r8
leaq -0x14(%rbp), %r9
movl $0x0, (%rsp)
callq 0x128f0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x1f63a
movl -0x18(%rbp), %edi
leaq 0xd128(%rip), %rax      # 0x2c750
movq 0xb8(%rax), %rsi
addq $-0x4, %rsi
callq 0xf740
jmp 0x1f64b
movq -0x20(%rbp), %rax
movl 0x8(%rax), %ecx
leaq 0xd108(%rip), %rax      # 0x2c750
movl %ecx, 0x6c(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/ciclib.c
// Function: springCleaning
void springCleaning()
{
    if (numBIF_args() == 0)  combVariables();
    
    else if (numBIF_args() == 1)  {
        window *theWindow = getBIFmember(1);
        ccInt loopMember;
        
        if (theWindow == NULL)  {  setError(void_member_err, pcCodePtr-1);  return;  }
        if (theWindow->variable_ptr->type != composite_type)  {  setError(not_composite_err, pcCodePtr-1);  return;  }
        
        for (loopMember = theWindow->variable_ptr->mem.members.elementNum; loopMember >= 1; loopMember--)  {
        if (LL_member(theWindow->variable_ptr, loopMember)->ifHidden)  {
            removeMember(theWindow->variable_ptr, loopMember);
            if (errCode != passed)  return;
    }   }}
    
    else  {  setError(wrong_argument_count_err, pcCodePtr-1);  return;  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x1fa40
cmpl $0x0, %eax
jne 0x1f93c
callq 0x13090
jmp 0x1fa2d
callq 0x1fa40
cmpl $0x1, %eax
jne 0x1fa0d
movl $0x1, %edi
callq 0x1fab0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1f980
leaq 0xcdea(%rip), %rax      # 0x2c750
movq 0xb8(%rax), %rsi
addq $-0x4, %rsi
movl $0x1a, %edi
callq 0xf740
jmp 0x1fa2d
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x5, 0xc0(%rax)
je 0x1f9af
leaq 0xcdb8(%rip), %rax      # 0x2c750
movq 0xb8(%rax), %rsi
addq $-0x4, %rsi
movl $0x24, %edi
callq 0xf740
jmp 0x1fa2d
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x10(%rax), %eax
movl %eax, -0xc(%rbp)
cmpl $0x1, -0xc(%rbp)
jl 0x1fa0b
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
addq $0x10, %rdi
movl -0xc(%rbp), %esi
callq 0x9700
cmpb $0x0, 0x40(%rax)
je 0x1f9fe
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x136e0
leaq 0xcd5c(%rip), %rax      # 0x2c750
cmpl $0x0, 0x18(%rax)
je 0x1f9fc
jmp 0x1fa2d
jmp 0x1f9fe
jmp 0x1fa00
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1f9bd
jmp 0x1fa2b
leaq 0xcd3c(%rip), %rax      # 0x2c750
movq 0xb8(%rax), %rsi
addq $-0x4, %rsi
movl $0x2d, %edi
callq 0xf740
jmp 0x1fa2d
jmp 0x1fa2d
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/ciclib.c
// Function: numBIF_args
ccInt numBIF_args()
{
    variable *BIFargsVariable = BIF_argsView.windowPtr->variable_ptr;
    ccInt counter, visibleMemberCounter = 0;
    
    for (counter = 1; counter <= BIFargsVariable->mem.members.elementNum; counter++)   {
    if (!(LL_member(BIFargsVariable, counter)->ifHidden))   {
        visibleMemberCounter++;
    }}
    
    return visibleMemberCounter;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xcd01(%rip), %rax      # 0x2c750
movq 0x178(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jg 0x1faa4
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movl -0xc(%rbp), %esi
callq 0x9700
cmpb $0x0, 0x40(%rax)
jne 0x1fa97
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1fa99
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1fa6c
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)