LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/intrpt.c
// Function: storageSize_String
void storageSize_String(view *theView, ccInt stringIndex, void *dataSize, void *dummy)
{
    member *stringMember = LL_member(theView->windowPtr->variable_ptr, stringIndex);
    view charView;
    
    charView.windowPtr = theView->windowPtr;
    charView.offset = 0;
    charView.width = 1;
    
    stepView(&charView, stringMember, 0, stringMember->indices);
    if (errCode == passed)  storageSizeView(&charView, dataSize, dummy);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movq (%rdi), %rax
movq 0x10(%rax), %rdi
addq $0x10, %rdi
callq 0x9088
movq (%r15), %rcx
leaq 0x8(%rsp), %rdi
movq %rcx, (%rdi)
movabsq $0x100000000, %rcx      # imm = 0x100000000
movq %rcx, 0x8(%rdi)
movl 0xc(%rax), %ecx
movq %rax, %rsi
xorl %edx, %edx
callq 0xcb03
leaq 0x176c1(%rip), %rax     # 0x24760
cmpl $0x0, 0x18(%rax)
jne 0xd0b5
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xcee0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/intrpt.c
// Function: writeData
void writeData(view *theView, void *bufferPtr, void *dummy)
{
    linkedlist *theLL = &(theView->windowPtr->variable_ptr->mem.data);
    
    setElements(theLL, theView->offset+1, theView->offset+theView->width, *(void **) bufferPtr);
    *(char **) bufferPtr += theLL->elementSize*theView->width;
    if (extCallMode)  *(char **) bufferPtr += align(theLL->elementSize*theView->width);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq 0x10(%rax), %r15
leaq 0x10(%r15), %rdi
movl 0x8(%r14), %edx
leal 0x1(%rdx), %esi
addl 0xc(%r14), %edx
movq (%rbx), %rcx
callq 0x8eaa
movslq 0x20(%r15), %rax
movslq 0xc(%r14), %rcx
imulq %rax, %rcx
movq (%rbx), %rax
addq %rcx, %rax
movq %rax, (%rbx)
leaq 0x17629(%rip), %rdx     # 0x24760
cmpb $0x0, 0x2a8(%rdx)
je 0xd153
andl $0x3, %ecx
pushq $0x4
popq %rdx
subl %ecx, %edx
testl %ecx, %ecx
cmovel %ecx, %edx
addq %rdx, %rax
movq %rax, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/intrpt.c
// Function: writeString
void writeString(view *theView, ccInt stringIndex, void *bufferPtr, void *sizeofStrings)
{
    member *stringMember;
    view stringView;
    
    stringMember = LL_member(theView->windowPtr->variable_ptr, stringIndex);
    stringView.windowPtr = stringMember->memberWindow;
    resizeMember(stringMember, 1, *(ccInt *) sizeofStrings);
    if (errCode != passed)  return;
    
    if (*(ccInt *) sizeofStrings == 0)  return;
    
    setElements(&(stringMember->memberWindow->variable_ptr->mem.data), stringMember->memberWindow->offset+1,
            stringMember->memberWindow->offset+stringMember->memberWindow->width, *(void **) bufferPtr);
    *(char **) bufferPtr += *(ccInt *) sizeofStrings;
    *(ccInt *) sizeofStrings = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq (%rdi), %rax
movq 0x10(%rax), %rdi
addq $0x10, %rdi
callq 0x9088
movq %rax, %r15
movl (%rbx), %edx
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0x11183
leaq 0x175d5(%rip), %rax     # 0x24760
cmpl $0x0, 0x18(%rax)
jne 0xd1bb
cmpl $0x0, (%rbx)
je 0xd1bb
movq (%r15), %rax
movq 0x10(%rax), %rdi
addq $0x10, %rdi
movl 0x18(%rax), %edx
leal 0x1(%rdx), %esi
addl 0x1c(%rax), %edx
movq (%r14), %rcx
callq 0x8eaa
movslq (%rbx), %rax
addq %rax, (%r14)
andl $0x0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/intrpt.c
// Function: readData
void readData(view *theView, void *bufferPtr, void *dummy)
{
    linkedlist *theLL = &(theView->windowPtr->variable_ptr->mem.data);
    
    getElements(theLL, theView->offset+1, theView->offset+theView->width, *(void **) bufferPtr);
    *(char **) bufferPtr += theLL->elementSize*theView->width;
    if (extCallMode)  *(char **) bufferPtr += align(theLL->elementSize*theView->width);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq 0x10(%rax), %r15
leaq 0x10(%r15), %rdi
movl 0x8(%r14), %edx
leal 0x1(%rdx), %esi
addl 0xc(%r14), %edx
movq (%rbx), %rcx
callq 0x8f8b
movslq 0x20(%r15), %rax
movslq 0xc(%r14), %rcx
imulq %rax, %rcx
movq (%rbx), %rax
addq %rcx, %rax
movq %rax, (%rbx)
leaq 0x17527(%rip), %rdx     # 0x24760
cmpb $0x0, 0x2a8(%rdx)
je 0xd255
andl $0x3, %ecx
pushq $0x4
popq %rdx
subl %ecx, %edx
testl %ecx, %ecx
cmovel %ecx, %edx
addq %rdx, %rax
movq %rax, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/intrpt.c
// Function: readString
void readString(view *theView, ccInt stringIndex, void *bufferPtr, void *sizeofStrings)
{
    window *stringWindow = LL_member(theView->windowPtr->variable_ptr, stringIndex)->memberWindow;
    linkedlist *stringLL = &(stringWindow->variable_ptr->mem.data);
    
    getElements(stringLL, stringWindow->offset+1, stringWindow->offset+stringWindow->width, *(void **) bufferPtr);
    *(char **) bufferPtr += stringWindow->width;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq (%rdi), %rax
movq 0x10(%rax), %rdi
addq $0x10, %rdi
callq 0x9088
movq (%rax), %r14
movq 0x10(%r14), %rdi
addq $0x10, %rdi
movl 0x18(%r14), %edx
leal 0x1(%rdx), %esi
addl 0x1c(%r14), %edx
movq (%rbx), %rcx
callq 0x8f8b
movslq 0x1c(%r14), %rax
addq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/intrpt.c
// Function: printNumber
void printNumber(char *destString, ccFloat numberToPrint, ccInt *characterCount, ccInt numberType)
{
    char theChars[50];
    
    if (numberType != double_type)  *characterCount = sprintf(theChars, printIntFormatString, (ccInt) numberToPrint);
    else  *characterCount = sprintf(theChars, print_stringFloatFormatString, maxDigits, numberToPrint);
    
    if (destString != NULL)  memcpy((void *) destString, (void *) theChars, *characterCount);
    
    return;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x3, %edx
jne 0xd490
leaq 0x13ce4(%rip), %rax     # 0x21158
movq (%rax), %rsi
leaq 0x172e2(%rip), %rax     # 0x24760
movl 0x1f8(%rax), %edx
movq %rsp, %rdi
movb $0x1, %al
callq 0x8080
jmp 0xd4a8
leaq 0x13cd1(%rip), %rax     # 0x21168
movq (%rax), %rsi
cvttsd2si %xmm0, %edx
movq %rsp, %rdi
xorl %eax, %eax
callq 0x8080
movl %eax, (%r14)
testq %rbx, %rbx
je 0xd4be
movslq %eax, %rdx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x8110
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/intrpt.c
// Function: sizeDataString
void sizeDataString(view *theView, void *dataSize, void *dummy)
{
    ccInt counter, numChars;
    
    if (theView->windowPtr->variable_ptr->type == bool_type)  {
    for (counter = 1; counter <= theView->width; counter++)  {
        loadBoolRegister(theView->windowPtr->variable_ptr, theView->offset+counter-1);
        if (boolRegister)  numChars = 4;
        else  numChars = 5;
        if (numChars < fieldWidth)  numChars = fieldWidth;
        *(ccInt *) dataSize += numChars;
    }}
    
    else if (theView->windowPtr->variable_ptr->type == char_type)  {
        *(ccInt *) dataSize += theView->width;        }
    
    else  {
    for (counter = 1; counter <= theView->width; counter++)  {
        loadDoubleRegister(theView->windowPtr->variable_ptr, theView->offset+counter-1);
        printNumber(NULL, doubleRegister, &numChars, theView->windowPtr->variable_ptr->type);
        if (numChars < fieldWidth)  numChars = fieldWidth;
        *(ccInt *) dataSize += numChars;
    }}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq 0x10(%rax), %rax
movl 0xc0(%rax), %eax
cmpl $0x1, %eax
je 0xd561
xorl %esi, %esi
testl %eax, %eax
jne 0xd574
leaq 0x17237(%rip), %r15     # 0x24760
leal 0x1(%rsi), %ebp
cmpl 0xc(%r14), %ebp
jg 0xd567
movq (%r14), %rax
movq 0x10(%rax), %rdi
addl 0x8(%r14), %esi
callq 0x144d8
cmpb $0x1, 0x68(%r15)
movl $0x0, %eax
adcl $0x4, %eax
movl 0x1fc(%r15), %ecx
cmpl %ecx, %eax
cmovlel %ecx, %eax
addl %eax, (%rbx)
movl %ebp, %esi
jmp 0xd529
movl 0xc(%r14), %eax
addl %eax, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x171e5(%rip), %r12     # 0x24760
leaq 0xc(%rsp), %r15
leal 0x1(%rsi), %ebp
cmpl 0xc(%r14), %ebp
jg 0xd567
movq (%r14), %rax
movq 0x10(%rax), %rdi
addl 0x8(%r14), %esi
callq 0x13b15
movsd 0x70(%r12), %xmm0
movq (%r14), %rax
movq 0x10(%rax), %rax
movl 0xc0(%rax), %edx
xorl %edi, %edi
movq %r15, %rsi
callq 0xd45b
movl 0xc(%rsp), %eax
movl 0x1fc(%r12), %ecx
cmpl %ecx, %eax
cmovgl %eax, %ecx
movl %ecx, 0xc(%rsp)
addl %ecx, (%rbx)
movl %ebp, %esi
jmp 0xd580
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/intrpt.c
// Function: readDataString
void readDataString(view *theView, void *sourceString, void *overflowMarker)
{
    ccInt oneLetterType, counter, rtrn, charType = lettertype(*(char **) sourceString);
    
    
        // white space in the source string is skipped over
        // (lettertype[], a_space, etc. are defined in cmpile.c(pp)/h)
    
    while ((charType == a_space) || (charType == a_eol) || (charType == unprintable))
        {  (*(char **) sourceString)++;  charType = lettertype(*(char **) sourceString);  }
    
    
        // numeric types in the destination window are parsed using readNum() (defined in cmpile.c(pp))
    
    for (counter = 1; counter <= theView->width; counter++)  {
        rtrn = readNum((char **) sourceString, &doubleRegister, NULL);
        if (rtrn != passed)  {
            if ((rtrn != underflow_err) && (rtrn != overflow_err))  rtrn = read_number_err;
            if (warningCode == passed)  ((char **) overflowMarker)[1] = *(char **) sourceString;
            setWarning(rtrn, pcCodePtr-1);
            if (rtrn == read_number_err)  return;       }
        
        oneLetterType = lettertype(*(char **) sourceString);
        while ((oneLetterType != a_symbol) && (oneLetterType != a_number) && (oneLetterType != a_letter) &&
                                                    (*(char **) sourceString < *(char **) overflowMarker))
            {  (*(char **) sourceString)++; oneLetterType = lettertype(*(char **) sourceString);  }
        saveDoubleRegister(theView->windowPtr->variable_ptr, theView->offset+counter-1);      }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rax
incq %rax
leaq 0x13b5a(%rip), %rbp     # 0x21180
movzbl -0x1(%rax), %ecx
cmpl $0x3, (%rbp,%rcx,4)
jae 0xd639
movq %rax, (%r14)
incq %rax
jmp 0xd626
pushq $0x1
popq %r12
leaq 0x1711c(%rip), %rax     # 0x24760
addq $0x70, %rax
movq %rax, (%rsp)
cmpl 0xc(%r15), %r12d
jg 0xd6e3
movq %r14, %rdi
movq (%rsp), %rsi
xorl %edx, %edx
callq 0xa2e3
testl %eax, %eax
je 0xd6a6
movl %eax, %r13d
leal -0x9(%r13), %eax
cmpl $-0x2, %eax
pushq $0x6
popq %rax
cmovbl %eax, %r13d
leaq 0x170e0(%rip), %rcx     # 0x24760
cmpl $0x0, 0x20(%rcx)
jne 0xd68d
movq (%r14), %rax
movq %rax, 0x8(%rbx)
movq 0xb8(%rcx), %rsi
addq $-0x4, %rsi
movl %r13d, %edi
callq 0xc87d
cmpl $0x6, %r13d
je 0xd6e3
movq (%r14), %rax
movzbl (%rax), %ecx
movl (%rbp,%rcx,4), %ecx
addl $-0x6, %ecx
cmpl $-0x4, %ecx
ja 0xd6c5
cmpq (%rbx), %rax
jae 0xd6c5
incq %rax
movq %rax, (%r14)
jmp 0xd6a9
movq (%r15), %rax
movq 0x10(%rax), %rdi
movl 0x8(%r15), %eax
leal (%r12,%rax), %esi
decl %esi
callq 0x1452b
incl %r12d
jmp 0xd64c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/intrpt.c
// Function: readStringFromString
void readStringFromString(view *theView, ccInt stringIndex, void *sourcePtr, void *overflowMarker)
{
    member *stringMember;
    view stringView;
    linkedlist *stringLL;
    ccInt newStringSize = 0, charType = lettertype(*(char **) sourcePtr);
    
    stringMember = LL_member(theView->windowPtr->variable_ptr, stringIndex);
    stringView.windowPtr = stringMember->memberWindow;
    stringLL = &(stringMember->memberWindow->variable_ptr->mem.data);


        // the leading spaces are skipped even for a string-to-string copy
        
    while ((charType == a_space) || (charType == a_eol) || (charType == unprintable))
        {  (*(char **) sourcePtr)++;  charType = lettertype(*(char **) sourcePtr);  }
    while ((charType == a_letter) || (charType == a_number) || (charType == a_symbol))
        {  newStringSize++;  charType = lettertype(((*(char **) sourcePtr)+newStringSize));  }
    
    resizeMember(stringMember, 1, newStringSize);
    if (errCode != passed)  return;
    
    setElements(stringLL, stringMember->memberWindow->offset+1,
            stringMember->memberWindow->offset+stringLL->elementNum, *(void **) sourcePtr);
    *(char **) sourcePtr += newStringSize;
    if (newStringSize == 0)  {
        if (warningCode == passed)  ((char **) overflowMarker)[1] = *(char **) sourcePtr;
        setWarning(string_read_err, pcCodePtr-1);       }
    
    if ((**(char **) sourcePtr == 0) && (*(char **) sourcePtr < *(char **) overflowMarker))  (*(char **) sourcePtr) += 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
movq %rdx, %rbx
movq (%rdx), %rax
movzbl (%rax), %eax
leaq 0x13a6f(%rip), %rbp     # 0x21180
movl (%rbp,%rax,4), %r14d
movq (%rdi), %rax
movq 0x10(%rax), %rdi
addq $0x10, %rdi
callq 0x9088
movq %rax, %r13
movq (%rax), %rax
movq 0x10(%rax), %r15
cmpl $0x3, %r14d
jae 0xd74b
movq (%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%rbx)
movzbl 0x1(%rax), %eax
movl (%rbp,%rax,4), %r14d
jmp 0xd730
xorl %r12d, %r12d
addl $-0x3, %r14d
cmpl $0x2, %r14d
ja 0xd76b
movq (%rbx), %rax
movzbl 0x1(%rax,%r12), %eax
incq %r12
movl (%rbp,%rax,4), %r14d
jmp 0xd74e
pushq $0x1
popq %rsi
movq %r13, %rdi
movl %r12d, %edx
callq 0x11183
leaq 0x16fe0(%rip), %r14     # 0x24760
cmpl $0x0, 0x18(%r14)
jne 0xd7eb
movq (%r13), %rax
movl 0x18(%rax), %edx
leal 0x1(%rdx), %esi
addl 0x10(%r15), %edx
addq $0x10, %r15
movq (%rbx), %rcx
movq %r15, %rdi
callq 0x8eaa
movl %r12d, %eax
addq (%rbx), %rax
movq %rax, (%rbx)
testq %r12, %r12
jne 0xd7d7
cmpl $0x0, 0x20(%r14)
jne 0xd7c1
movq (%rsp), %rcx
movq %rax, 0x8(%rcx)
movq 0xb8(%r14), %rsi
addq $-0x4, %rsi
pushq $0x5
popq %rdi
callq 0xc87d
movq (%rbx), %rax
cmpb $0x0, (%rax)
jne 0xd7eb
movq (%rsp), %rcx
cmpq (%rcx), %rax
jae 0xd7eb
incq %rax
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/intrpt.c
// Function: passDataView
void passDataView(view *theView, void *ptrHandle, void *infoHandle)
{
    variable *theVar = theView->windowPtr->variable_ptr;
    ccInt rtrn;

    rtrn = defragmentLinkedList(&(theVar->mem.data));
    if (rtrn != passed)  {  setError(out_of_memory_err, pcCodePtr-1);  return;  }

    if (theView->offset == theVar->mem.data.elementNum)  
        **(char ***) ptrHandle = ((char *) theVar->mem.data.memory) + sublistHeaderSize;
    else  **(char ***) ptrHandle = (char *) element(&(theVar->mem.data), theView->offset+1);
    (*(arg_info **) infoHandle)->argType = theVar->type;
    (*(arg_info **) infoHandle)->argIndices = theView->width;
    (*(char ***) ptrHandle)++;
    (*(arg_info **) infoHandle)++;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
movq 0x10(%rax), %r13
leaq 0x10(%r13), %r12
movq %r12, %rdi
callq 0x8b50
testl %eax, %eax
je 0xd8b2
leaq 0x16eca(%rip), %rax     # 0x24760
movq 0xb8(%rax), %rsi
addq $-0x4, %rsi
pushq $0x1
popq %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xc7c2
movl 0x8(%r15), %esi
cmpl (%r12), %esi
jne 0xd8c6
movq 0x18(%r13), %rax
addq $0x18, %rax
jmp 0xd8d0
incl %esi
movq %r12, %rdi
callq 0x9088
movq (%r14), %rcx
movq %rax, (%rcx)
movl 0xc0(%r13), %eax
movq (%rbx), %rcx
movl %eax, (%rcx)
movl 0xc(%r15), %eax
movl %eax, 0x4(%rcx)
addq $0x8, (%r14)
addq $0x8, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/intrpt.c
// Function: fixString
void fixString(view *theView, ccInt stringDummyIndex, void *ptrHandle, void *infoHandle)
{
    ccInt stringIndex;
    
    linkedlist *stringListCopy = (linkedlist *) **(char ***) ptrHandle;
    
    for (stringIndex = theView->offset+1; stringIndex <= theView->offset+theView->width; stringIndex++)  {
        
        member *theStringMember = LL_member(theView->windowPtr->variable_ptr, stringIndex);
        linkedlist *theStringLL = &(theStringMember->memberWindow->variable_ptr->mem.data);
        
        *theStringLL = stringListCopy[stringIndex-theView->offset-1];
        
        theStringMember->indices = theStringLL->elementNum;
        theStringMember->memberWindow->width = theStringLL->elementNum;
        theStringMember->memberWindow->variable_ptr->instances = theStringLL->elementNum;
    }
    
    free((void *) stringListCopy);
    (*(char ***) ptrHandle)++;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r15
movq (%rdx), %rax
movq (%rax), %r14
movl 0x8(%rdi), %eax
movl %eax, %r12d
addl 0xc(%r15), %eax
cmpl %eax, %r12d
jge 0xdeec
leal 0x1(%r12), %ebp
movq (%r15), %rax
movq 0x10(%rax), %rdi
addq $0x10, %rdi
movl %ebp, %esi
callq 0x9088
movq (%rax), %rcx
movq 0x10(%rcx), %rcx
subl 0x8(%r15), %r12d
movslq %r12d, %rdx
shlq $0x5, %rdx
movups (%r14,%rdx), %xmm0
movups 0x10(%r14,%rdx), %xmm1
movups %xmm0, 0x10(%rcx)
movups %xmm1, 0x20(%rcx)
movl 0x10(%rcx), %ecx
movl %ecx, 0xc(%rax)
movq (%rax), %rax
movl %ecx, 0x1c(%rax)
movq 0x10(%rax), %rax
movl %ecx, 0xf0(%rax)
movl 0x8(%r15), %eax
movl %ebp, %r12d
jmp 0xde88
movq %r14, %rdi
callq 0x81c0
addq $0x8, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/intrpt.c
// Function: printData
void printData(view *theView, void *bufferPtr, void *dummy)
{
    ccInt counter, windowOffset = theView->offset, theType = theView->windowPtr->variable_ptr->type;
    variable *theVar = theView->windowPtr->variable_ptr;
    unsigned char theChar;
    
    for (counter = windowOffset; counter < windowOffset+theView->width; counter++)  {
        
        if (theType == char_type)  {
            loadIntRegister(theVar, counter);
            theChar = (unsigned char) intRegister;
            if (lettertype(&theChar) != unprintable)  printf("%c", (unsigned char) theChar);
            else  printf("\\%c%c", hexDigit(theChar/16), hexDigit(theChar % 16));     }
        
        else if (theType == int_type)  {
            loadIntRegister(theVar, counter);
            printf(printIntFormatString, (ccInt) intRegister);     }
        
        else if (theType == double_type)  {
            loadDoubleRegister(theVar, counter);
            printf(printFloatFormatString, (ccFloat) doubleRegister);  }
        
        else if (theType == bool_type)  {
            loadBoolRegister(theVar, counter);
            if (boolRegister)  printf("true");
            else  printf("false");      }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %r15d
movq (%rdi), %rax
movq 0x10(%rax), %r14
movl 0xc0(%r14), %r13d
movl %r13d, %r12d
movl %r15d, %ebp
movl 0xc(%rbx), %eax
addl %r15d, %eax
cmpl %eax, %ebp
jge 0xe087
cmpl $0x3, %r13d
ja 0xe080
leaq 0xbd27(%rip), %rcx      # 0x19ca0
movslq (%rcx,%r12,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r14, %rdi
movl %ebp, %esi
callq 0x144d8
leaq 0x167cd(%rip), %rax     # 0x24760
cmpb $0x0, 0x68(%rax)
je 0xe028
leaq 0xb5ba(%rip), %rdi      # 0x1955e
jmp 0xe02f
movq %r14, %rdi
movl %ebp, %esi
callq 0x13aee
leaq 0x131ae(%rip), %rax     # 0x21168
movq (%rax), %rdi
leaq 0x1679c(%rip), %rax     # 0x24760
movl 0x6c(%rax), %esi
xorl %eax, %eax
callq 0x8050
jmp 0xe080
movq %r14, %rdi
movl %ebp, %esi
callq 0x13b15
leaq 0x1316c(%rip), %rax     # 0x21150
movq (%rax), %rdi
leaq 0x16772(%rip), %rax     # 0x24760
movsd 0x70(%rax), %xmm0
movb $0x1, %al
callq 0x8050
jmp 0xe080
movq %r14, %rdi
movl %ebp, %esi
callq 0x13aee
leaq 0x16750(%rip), %rax     # 0x24760
movzbl 0x6c(%rax), %edi
leaq 0x13165(%rip), %rax     # 0x21180
cmpl $0x0, (%rax,%rdi,4)
je 0xe038
callq 0x81e0
jmp 0xe080
leaq 0xb521(%rip), %rdi      # 0x19550
xorl %eax, %eax
callq 0x8050
jmp 0xe080
movl %edi, %eax
shrb $0x4, %al
leal 0x30(%rax), %ecx
addb $0x37, %al
cmpb $-0x60, %dil
movzbl %cl, %ecx
movzbl %al, %esi
cmovbl %ecx, %esi
movl $0xff, %r8d
andl %r8d, %esi
andb $0xf, %dil
leal 0x30(%rdi), %eax
leal 0x37(%rdi), %ecx
cmpb $0xa, %dil
movzbl %al, %eax
movzbl %cl, %edx
cmovbl %eax, %edx
andl %r8d, %edx
leaq 0xbc77(%rip), %rdi      # 0x19cf0
xorl %eax, %eax
callq 0x8050
incl %ebp
jmp 0xdf5a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/intrpt.c
// Function: printString
void printString(view *theView, ccInt stringIndex, void *bufferPtr, void *sizeofStrings)
{
    view charView;
    member *charMember = LL_member(theView->windowPtr->variable_ptr, stringIndex);
    
    charView.windowPtr = charMember->memberWindow;
    charView.offset = charView.windowPtr->offset;
    charView.width = charMember->indices;
    
    printData(&charView, bufferPtr, sizeofStrings);
}

// Assembly:
subq $0x18, %rsp
movq (%rdi), %rax
movq 0x10(%rax), %rdi
addq $0x10, %rdi
callq 0x9088
movq (%rax), %rcx
movq %rsp, %rdi
movq %rcx, (%rdi)
movl 0x18(%rcx), %ecx
movl %ecx, 0x8(%rdi)
movl 0xc(%rax), %eax
movl %eax, 0xc(%rdi)
callq 0xdf34
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/intrpt.c
// Function: searchMember
void searchMember(ccInt soughtMemberID, member **stemMember, ccInt *stemMemberNumber, ccBool allowAddMember, ccBool ifHiddenMember)
{
    searchPath *searchPosition;
    ccInt rtrn;
    
    searchPosition = pcSearchPath;
    searchView = baseView;
    
    do  {
        searchView.windowPtr = searchPosition->jamb;
        rtrn = findMemberID(searchView.windowPtr->variable_ptr, soughtMemberID, stemMember, stemMemberNumber, allowAddMember, ifHiddenMember);
        if (rtrn == passed)  {
            return;    }
        else if (rtrn != member_not_found_err)  {
            setError(rtrn, pcCodePtr);
            return;    }
        
        if (searchPosition->stem == NULL)  break;
        else if (searchPosition->stemIndices == 0)
            searchView.offset = 0;
        else
            searchView.offset = (searchView.offset - searchView.windowPtr->offset) / searchPosition->stemIndices;
        
        if (searchView.width > 1)  searchView.width /= searchPosition->stemIndices;
        else if (searchPosition->stemIndices == 0)  {           // if we stepped through a 0-sized member, recalculate indices
            searchView.width = 1;
            searchPath *SP2 = searchPosition->stem;
            while (SP2->stem != NULL)  {
                searchView.width *= SP2->stemIndices;
                SP2 = SP2->stem;
        }   }
        if (searchView.multipleIndices)  searchView.multipleIndices = (searchView.width != 1);
        
        searchPosition = searchPosition->stem;
    }  while (ccTrue);
    
    setError(member_not_found_err, pcCodePtr);
    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, (%rsp)
movq %rsi, %r14
movl %edi, %ebp
leaq 0x16667(%rip), %r15     # 0x24760
movq 0x170(%r15), %rbx
movups 0x140(%r15), %xmm0
movups %xmm0, 0x158(%r15)
movq 0x150(%r15), %rax
movq %rax, 0x168(%r15)
movsbl %cl, %r12d
movsbl %r8b, %r13d
movq 0x18(%rbx), %rax
movq %rax, 0x158(%r15)
movq 0x10(%rax), %rdi
movl %ebp, %esi
movq %r14, %rdx
movq (%rsp), %rcx
movl %r12d, %r8d
movl %r13d, %r9d
callq 0xe21b
cmpl $0x17, %eax
jne 0xe1e9
movq 0x20(%rbx), %rcx
testq %rcx, %rcx
je 0xe1fe
movl 0x28(%rbx), %esi
testl %esi, %esi
je 0xe18f
movl 0x160(%r15), %eax
movq 0x158(%r15), %rdx
subl 0x18(%rdx), %eax
cltd
idivl %esi
movl %eax, 0x160(%r15)
movl 0x164(%r15), %eax
cmpl $0x2, %eax
jge 0xe1a3
jmp 0xe1ad
andl $0x0, 0x160(%r15)
movl 0x164(%r15), %eax
cmpl $0x1, %eax
jle 0xe1d1
cltd
idivl %esi
movl %eax, 0x164(%r15)
cmpb $0x0, 0x168(%r15)
movq %rcx, %rbx
je 0xe126
cmpl $0x1, %eax
setne 0x168(%r15)
movq %rcx, %rbx
jmp 0xe126
movq %rcx, %rdx
pushq $0x1
popq %rax
movq 0x20(%rdx), %rsi
testq %rsi, %rsi
je 0xe1a6
imull 0x28(%rdx), %eax
movq %rsi, %rdx
jmp 0xe1d7
movl %eax, %edi
testl %eax, %eax
jne 0xe201
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x17
popq %rdi
movq 0xb8(%r15), %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xc7c2
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/intrpt.c
// Function: findMemberID
ccInt findMemberID(variable *theObject, ccInt soughtMemberID, member **soughtMember, ccInt *soughtMemberNumber,
                ccBool allowAddMember, ccBool ifHiddenMember)
{
    ccInt counter, rtrn;
    linkedlist *membersList;
    
    if (theObject->type < composite_type)  return member_not_found_err;
    membersList = &(theObject->mem.members);
    
    for (counter = 1; counter <= membersList->elementNum; counter++)   {
        *soughtMember = (member *) element(membersList, counter);
        if ((*soughtMember)->memberID == soughtMemberID)   {
            *soughtMemberNumber = counter;
            return passed;
    }   }
    
    if (!allowAddMember)  {
        *soughtMember = NULL;
        rtrn = member_not_found_err;        }
    
    else  {
        *soughtMemberNumber = theObject->mem.members.elementNum + 1;
        rtrn = addMember(theObject, *soughtMemberNumber, 1, soughtMember, ifHiddenMember, 1, ccTrue);
        if (rtrn == passed)  (*soughtMember)->memberID = soughtMemberID;        }
    
    return rtrn;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
pushq $0x17
popq %rbx
cmpl $0x5, 0xc0(%rdi)
jl 0xe2c5
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r12
movl %r8d, 0xc(%rsp)
movq %rcx, 0x10(%rsp)
movl %r9d, 0x8(%rsp)
leaq 0x10(%rdi), %r13
pushq $0x1
popq %r15
movl (%r13), %esi
cmpl %esi, %r15d
jg 0xe279
movq %r13, %rdi
movl %r15d, %esi
callq 0x9088
movq %rax, (%r14)
cmpl %ebp, 0x8(%rax)
je 0xe2b5
incl %r15d
jmp 0xe258
cmpb $0x0, 0xc(%rsp)
je 0xe2c1
incl %esi
movq 0x10(%rsp), %rax
movl %esi, (%rax)
movl $0x1, (%rsp)
movsbl 0x8(%rsp), %r8d
pushq $0x1
popq %rbx
movq %r12, %rdi
movl %ebx, %edx
movq %r14, %rcx
movl %ebx, %r9d
callq 0xe2d6
testl %eax, %eax
jne 0xe2c5
movq (%r14), %rax
movl %ebp, 0x8(%rax)
jmp 0xe2bd
movq 0x10(%rsp), %rax
movl %r15d, (%rax)
xorl %ebx, %ebx
jmp 0xe2c5
andq $0x0, (%r14)
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/intrpt.c
// Function: addMember
ccInt addMember(variable *hostVariable, ccInt newMemberNumber, ccInt newIndices, member **newMember, ccBool ifHidden,
        const ccInt membersToAdd, const ccBool doWrite)
{
    linkedlist *memberLL = &(hostVariable->mem.members);
    ccInt rtrn;
    
    
        // add the new member and write its fields
    
    if (membersToAdd > 0)  {
        rtrn = insertElements(memberLL, newMemberNumber, membersToAdd, ccFalse);
        if (rtrn != passed)  return out_of_memory_err;      }
    
    if (doWrite)  {
        *newMember = (member *) element(memberLL, newMemberNumber);
        (*newMember)->indices = newIndices;
        (*newMember)->memberWindow = NULL;
        (*newMember)->type = no_type;
        (*newMember)->eventualType = no_type;
        (*newMember)->arrayDepth = 0;
        (*newMember)->ifHidden = ifHidden;
        (*newMember)->business = 0;
        
        rtrn = newLinkedList(&((*newMember)->codeList), 0, sizeof(code_ref), 0., ccFalse);
        if (rtrn != passed)  return out_of_memory_err;          }
    
    return passed;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rcx, %r14
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %r13
addq $0x10, %r13
pushq $0x1
popq %rbx
testl %r9d, %r9d
jle 0xe310
movq %r13, %rdi
movl %r12d, %esi
movl %r9d, %edx
xorl %ecx, %ecx
callq 0x8496
testl %eax, %eax
jne 0xe363
cmpb $0x0, 0x40(%rsp)
je 0xe361
movq %r13, %rdi
movl %r12d, %esi
callq 0x9088
movq %rax, (%r14)
movl %r15d, 0xc(%rax)
andq $0x0, (%rax)
movq (%r14), %rdi
movabsq $0x700000007, %rax      # imm = 0x700000007
movq %rax, 0x10(%rdi)
andl $0x0, 0x18(%rdi)
movb %bpl, 0x40(%rdi)
andl $0x0, 0x44(%rdi)
addq $0x20, %rdi
pushq $0x20
popq %rdx
xorps %xmm0, %xmm0
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x83d5
testl %eax, %eax
jne 0xe363
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/intrpt.c
// Function: numMemberIndices
ccInt numMemberIndices(view *theView)
{
    ccInt memberCounter, topIndex;
    variable *theVariable = theView->windowPtr->variable_ptr;
    
    if (theVariable->type == composite_type)  {
        topIndex = 0;
        for (memberCounter = 1; memberCounter <= theVariable->mem.members.elementNum; memberCounter++)  {
        if (!(LL_member(theVariable, memberCounter)->ifHidden))  {
            topIndex ++;
    }   }}
    
    else if (theVariable->type == array_type)  topIndex = (LL_member(theVariable, 1))->indices;
    
    else  topIndex = (LL_member(theVariable, theView->offset+1))->indices;
    
    return topIndex;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq (%rdi), %rax
movq 0x10(%rax), %rbx
movl 0xc0(%rbx), %eax
addq $0x10, %rbx
cmpl $0x6, %eax
je 0xe4ba
cmpl $0x5, %eax
jne 0xe4bf
pushq $0x1
popq %r14
xorl %ebp, %ebp
cmpl (%rbx), %r14d
jg 0xe4cf
movq %rbx, %rdi
movl %r14d, %esi
callq 0x9088
cmpb $0x1, 0x40(%rax)
adcl $0x0, %ebp
incl %r14d
jmp 0xe49e
pushq $0x1
popq %rsi
jmp 0xe4c4
movl 0x8(%rdi), %esi
incl %esi
movq %rbx, %rdi
callq 0x9088
movl 0xc(%rax), %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/intrpt.c
// Function: setErrIndex
void setErrIndex(ccInt *errPtr, ccInt theError, ccInt *errCodePtr, ccInt *errIndexPtr, code_ref *errScriptPtr)
{
    *errCodePtr = theError;
    
    if (errScriptPtr->code_ptr != NULL)  derefCodeRef(errScriptPtr);
    *errScriptPtr = PCCodeRef;
    errScriptPtr->anchor = NULL;
    refCodeRef(errScriptPtr);
    
    *errIndexPtr = ((ccInt) (errPtr - errScriptPtr->code_ptr)) + 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %r8, %r15
movq %rcx, %rbx
movq %rdi, %r14
movl %esi, (%rdx)
cmpq $0x0, 0x10(%r8)
je 0xe4f5
movq %r15, %rdi
callq 0xe533
leaq 0x16264(%rip), %rax     # 0x24760
movq 0x218(%rax), %rcx
movq %rcx, 0x10(%r15)
movups 0x208(%rax), %xmm0
movups %xmm0, (%r15)
andq $0x0, 0x18(%r15)
movq %r15, %rdi
callq 0xe54f
subq 0x10(%r15), %r14
shrq $0x2, %r14
incl %r14d
movl %r14d, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/intrpt.c
// Function: addVariable
ccInt addVariable(variable **theNewVar, ccInt variableType, ccInt eventualVariableType, ccInt arrayDepth, ccBool makeSpareRoom)
{
    ccInt newVarIndex, rtrn;
    ccFloat freeSpace;
    
    rtrn = addPLLElement(&VariableList, (void **) theNewVar, &newVarIndex);
    if (rtrn != passed)  return rtrn;
    
    (*theNewVar)->PLL_index = newVarIndex;
    (*theNewVar)->references = LL_int(&(VariableList.references), newVarIndex);
    (*(*theNewVar)->references) = 0;         // the windows are all the references we want
    
    rtrn = newLinkedList(&((*theNewVar)->codeList), 0, sizeof(code_ref), 0., ccFalse);
    if (rtrn != passed)  return out_of_memory_err;
    
    rtrn = newPLL(&((*theNewVar)->windows), 0, sizeof(window), LLFreeSpace);
    if (rtrn != passed)  return rtrn;
    rtrn = newPLL(&((*theNewVar)->pathList), 3, sizeof(searchPath), LLFreeSpace);        // why 3?
    if (rtrn != passed)  return rtrn;
    
    if (makeSpareRoom)  freeSpace = LLFreeSpace;
    else  freeSpace = 0.;
    rtrn = newLinkedList(&((*theNewVar)->mem.data), 0, typeSizes[variableType], freeSpace, ccFalse);
    if (rtrn != passed)  return out_of_memory_err;
    
    (*theNewVar)->type = variableType;
    (*theNewVar)->eventualType = eventualVariableType;
    (*theNewVar)->arrayDepth = arrayDepth;
    (*theNewVar)->instances = 0;
    (*theNewVar)->business = 0;
    
    return passed;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r12d
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
leaq 0x16173(%rip), %rdi     # 0x246f0
leaq 0x4(%rsp), %rdx
movq %r15, %rsi
callq 0x9155
testl %eax, %eax
je 0xe593
movl %eax, %r13d
jmp 0xe5d7
movl 0x4(%rsp), %esi
movq (%r15), %rax
movl %esi, (%rax)
leaq 0x1616d(%rip), %rdi     # 0x24710
callq 0x9088
movq (%r15), %rcx
movq %rax, 0x8(%rcx)
movq (%r15), %rdi
movq 0x8(%rdi), %rax
andl $0x0, (%rax)
addq $0xd0, %rdi
pushq $0x20
popq %rdx
xorps %xmm0, %xmm0
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x83d5
pushq $0x1
popq %r13
testl %eax, %eax
je 0xe5e9
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r15), %rdi
addq $0x30, %rdi
pushq $0x28
popq %rdx
movsd 0xaa0d(%rip), %xmm0     # 0x19008
xorl %esi, %esi
callq 0x90f6
testl %eax, %eax
jne 0xe58e
movq (%r15), %rdi
addq $0x78, %rdi
pushq $0x3
popq %rsi
pushq $0x30
popq %rdx
movsd 0xa9ed(%rip), %xmm0     # 0x19008
callq 0x90f6
testl %eax, %eax
jne 0xe58e
movsd 0xa9d8(%rip), %xmm1     # 0x19008
xorps %xmm0, %xmm0
testb %r12b, %r12b
je 0xe63b
movaps %xmm1, %xmm0
movq (%r15), %rdi
addq $0x10, %rdi
movslq %r14d, %rax
leaq 0xb674(%rip), %rcx      # 0x19cc0
movl (%rcx,%rax,4), %edx
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x83d5
testl %eax, %eax
jne 0xe5d7
movq (%r15), %rax
movl %r14d, 0xc0(%rax)
movl %ebp, 0xc4(%rax)
movl %ebx, 0xc8(%rax)
andq $0x0, 0xf0(%rax)
xorl %r13d, %r13d
jmp 0xe5d7
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/intrpt.c
// Function: derefVariable
void derefVariable(variable *theVariable)
{
    member *loopMember;
    ccInt counter, codeCounter;
    
    derefPLLPtr(&VariableList, theVariable->PLL_index, theVariable->references);
    if (*(theVariable->references) != 0)  return;
    
    if (theVariable->type >= string_type)  {
    for (counter = 1; counter <= theVariable->mem.members.elementNum; counter++)   {
        loopMember = LL_member(theVariable, counter);
        for (codeCounter = 1; codeCounter <= loopMember->codeList.elementNum; codeCounter++)   {
            derefCodeRef((code_ref *) element(&(loopMember->codeList), codeCounter));   }
        derefWindow(&(loopMember->memberWindow));
    }}
    
    deletePLL(&(theVariable->windows));     // All the windows must already have been deleted, since variables are referenced by the windows.
    deletePLL(&(theVariable->pathList));    // All search paths are already gone, since all the windows are gone.
    
    for (counter = 1; counter <= theVariable->codeList.elementNum; counter++)
        derefCodeRef((code_ref *) element(&(theVariable->codeList), counter));
    
    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %esi
movq 0x8(%rdi), %rdx
leaq 0x16048(%rip), %rdi     # 0x246f0
callq 0x9253
movq 0x8(%rbx), %rax
cmpl $0x0, (%rax)
je 0xe6c5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x4, 0xc0(%rbx)
jl 0xe71c
leaq 0x10(%rbx), %r14
pushq $0x1
popq %rbp
cmpl (%r14), %ebp
jg 0xe71c
movq %r14, %rdi
movl %ebp, %esi
callq 0x9088
movq %rax, %r15
movq %rax, %r12
addq $0x20, %r12
pushq $0x1
popq %r13
cmpl (%r12), %r13d
jg 0xe710
movq %r12, %rdi
movl %r13d, %esi
callq 0x9088
movq %rax, %rdi
callq 0xe533
incl %r13d
jmp 0xe6f2
movq %r15, %rdi
callq 0xc801
incl %ebp
jmp 0xe6d5
pushq $0x1
popq %rbp
leaq 0x30(%rbx), %rdi
callq 0x913f
leaq 0x78(%rbx), %rdi
callq 0x913f
addq $0xd0, %rbx
cmpl (%rbx), %ebp
jg 0xe6b6
movq %rbx, %rdi
movl %ebp, %esi
callq 0x9088
movq %rax, %rdi
callq 0xe533
incl %ebp
jmp 0xe738
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/intrpt.c
// Function: unflagVariables
void unflagVariables(variable *theVariable, unsigned char theFlag)
{
    member *loopMember;
    ccInt counter;
    
    if (!isBusy(theVariable, theFlag))  return;
    clearBusy(theVariable, theFlag);
    
    if (theVariable->type >= composite_type)  {
        for (counter = 1; counter <= theVariable->mem.members.elementNum; counter++)  {
            loopMember = LL_member(theVariable, counter);
            if (loopMember->memberWindow != NULL)  unflagVariables(loopMember->memberWindow->variable_ptr, theFlag);  }}
    
    return;
}

// Assembly:
movl 0xf4(%rdi), %eax
testl %esi, %eax
je 0xe7b1
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl %esi, %ecx
notl %ecx
andl %ecx, %eax
movl %eax, 0xf4(%rdi)
cmpl $0x5, 0xc0(%rdi)
jl 0xe7ad
addq $0x10, %rbx
pushq $0x1
popq %rbp
movzbl %sil, %r14d
cmpl (%rbx), %ebp
jg 0xe7ad
movq %rbx, %rdi
movl %ebp, %esi
callq 0x9088
movq (%rax), %rax
testq %rax, %rax
je 0xe7a9
movq 0x10(%rax), %rdi
movl %r14d, %esi
callq 0xe756
incl %ebp
jmp 0xe787
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/intrpt.c
// Function: combBranch
void combBranch(variable *oneVariable, ccBool doSetFlag)
{
    ccInt counter;
    member *loopMember;
    searchPath *loopPath;
    
    if (oneVariable == NULL)  return;
    if (doSetFlag)  {
        if (isBusy(oneVariable, busy_comb_flag))  return;
        setBusy(oneVariable, busy_comb_flag);       }
    else  {
        if (!isBusy(oneVariable, busy_comb_flag))  return;
        clearBusy(oneVariable, busy_comb_flag);       }
    
    if (oneVariable->type >= composite_type)  {
        for (counter = 1; counter <= oneVariable->mem.members.elementNum; counter++)  {
            loopMember = LL_member(oneVariable, counter);
            if ((!isBusy(loopMember, busy_comb_flag)) && (loopMember->memberWindow != NULL))  {
                setBusy(loopMember, busy_comb_flag);
                combBranch(loopMember->memberWindow->variable_ptr, doSetFlag);
                clearBusy(loopMember, busy_comb_flag);
    }   }   }
    
    for (counter = 1; counter <= oneVariable->pathList.data.elementNum; counter++)  {
    if (*LL_int(&(oneVariable->pathList.references), counter) != 0)  {
        loopPath = (searchPath *) element(&(oneVariable->pathList.data), counter);
        if (loopPath->stem != NULL)  combBranch(loopPath->stem->variablePtr, doSetFlag);      // no need to do loopPath->variablePtr
    }}
    
    for (counter = 1; counter <= oneVariable->codeList.elementNum; counter++)  {
        loopPath = ((code_ref *) element(&(oneVariable->codeList), counter))->anchor;
        if (loopPath != NULL)  combBranch(loopPath->variablePtr, doSetFlag);         // anchors are NULL in err/w_script, thus usually in R_*_script
    }
    
    return;
}

// Assembly:
testq %rdi, %rdi
je 0xea41
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0xf4(%rdi), %eax
testb %sil, %sil
je 0xea35
testb $0x8, %al
jne 0xea39
orl $0x8, %eax
jmp 0xea45
testb $0x8, %al
jne 0xea42
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
andl $-0x9, %eax
movl %eax, 0xf4(%rbx)
cmpl $0x5, 0xc0(%rbx)
movsbl %sil, %ebp
jl 0xeaa1
leaq 0x10(%rbx), %r14
pushq $0x1
popq %r15
cmpl (%r14), %r15d
jg 0xeaa1
movq %r14, %rdi
movl %r15d, %esi
callq 0x9088
movq %rax, %r12
movl 0x44(%rax), %eax
testb $0x8, %al
jne 0xea9c
movq (%r12), %rcx
testq %rcx, %rcx
je 0xea9c
orl $0x8, %eax
movl %eax, 0x44(%r12)
movq 0x10(%rcx), %rdi
movl %ebp, %esi
callq 0xea11
andb $-0x9, 0x44(%r12)
incl %r15d
jmp 0xea60
pushq $0x1
popq %r14
leaq 0x78(%rbx), %r15
leaq 0x98(%rbx), %r12
cmpl (%r15), %r14d
jg 0xeae9
movq %r12, %rdi
movl %r14d, %esi
callq 0x9088
cmpl $0x0, (%rax)
je 0xeae4
movq %r15, %rdi
movl %r14d, %esi
callq 0x9088
movq 0x20(%rax), %rax
testq %rax, %rax
je 0xeae4
movq 0x10(%rax), %rdi
movl %ebp, %esi
callq 0xea11
incl %r14d
jmp 0xeab0
addq $0xd0, %rbx
pushq $0x1
popq %r14
cmpl (%rbx), %r14d
jg 0xea39
movq %rbx, %rdi
movl %r14d, %esi
callq 0x9088
movq 0x18(%rax), %rax
testq %rax, %rax
je 0xeb1c
movq 0x10(%rax), %rdi
movl %ebp, %esi
callq 0xea11
incl %r14d
jmp 0xeaf4
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/intrpt.c
// Function: unlinkWindow
void unlinkWindow(variable *stemVariable, window **unlinkedWindow, ccInt stemMemberNumber)
{
    pinned_LL *unlinkedFibrilList = &((*unlinkedWindow)->variable_ptr->pathList);
    window *holdWindowPtr;
    searchPath *loopPath, *clippedStem;
    ccInt counter;
    
    for (counter = 1; counter <= unlinkedFibrilList->data.elementNum; counter++)  {
    if (*LL_int(&(unlinkedFibrilList->references), counter) != 0)  {
        loopPath = (searchPath *) element(&(unlinkedFibrilList->data), counter);
        if (loopPath->stem != NULL)  {
        if (loopPath->stem->variablePtr == stemVariable)  {
            clippedStem = loopPath->stem;
            loopPath->stem = NULL;
            derefPath(&clippedStem);
    }}  }}
    
    holdWindowPtr = *unlinkedWindow;
    *unlinkedWindow = NULL;
    derefWindow(&holdWindowPtr);        // We just deleted a link, so in any event dereference unlinkedWindow.    
    
    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq 0x10(%rax), %r15
leaq 0x78(%r15), %r12
addq $0x98, %r15
pushq $0x1
popq %rbp
leaq 0x8(%rsp), %r13
cmpl (%r12), %ebp
jg 0xeb93
movq %r15, %rdi
movl %ebp, %esi
callq 0x9088
cmpl $0x0, (%rax)
je 0xeb8f
movq %r12, %rdi
movl %ebp, %esi
callq 0x9088
movq 0x20(%rax), %rcx
testq %rcx, %rcx
je 0xeb8f
cmpq %r14, 0x10(%rcx)
jne 0xeb8f
movq %rcx, 0x8(%rsp)
andq $0x0, 0x20(%rax)
movq %r13, %rdi
callq 0xebb6
incl %ebp
jmp 0xeb4f
movq (%rbx), %rax
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
andq $0x0, (%rbx)
callq 0xc801
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/intrpt.c
// Function: derefPath
void derefPath(searchPath **thePath)
{
    if (*thePath == NULL)  return;
    
    derefPLLPtr(&((*thePath)->variablePtr->pathList), (*thePath)->PLL_index, (*thePath)->references);
    if (*((*thePath)->references) != 0)  {  *thePath = NULL;  return;  }
    
            // if we're being deleted, we aren't the anchor for any other paths
    
    derefPath(&((*thePath)->stem));
    derefPLLElement(&MasterCodeList, (*thePath)->sourceCode);
    derefWindow(&((*thePath)->jamb));
    
    *thePath = NULL;
    
    return;
}

// Assembly:
movq (%rdi), %rax
testq %rax, %rax
je 0xec0d
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rax), %rdi
addq $0x78, %rdi
movl (%rax), %esi
movq 0x8(%rax), %rdx
callq 0x9253
movq (%rbx), %rdi
movq 0x8(%rdi), %rax
cmpl $0x0, (%rax)
jne 0xec08
addq $0x20, %rdi
callq 0xebb6
movq (%rbx), %rax
movl 0x2c(%rax), %esi
leaq 0x15ab1(%rip), %rdi     # 0x246a8
callq 0x9227
movq (%rbx), %rdi
addq $0x18, %rdi
callq 0xc801
andq $0x0, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/intrpt.c
// Function: removeMember
void removeMember(variable *theVariable, ccInt doomedMemberNumber)
{
    ccInt counter;
    member *doomedMember;
    
    doomedMember = LL_member(theVariable, doomedMemberNumber);
    
    
        // delete the member & associated codes & references
    
    if (doomedMember->memberWindow != NULL)  derefWindow(&(doomedMember->memberWindow));
    
    for (counter = 1; counter <= doomedMember->codeList.elementNum; counter++)  {
        derefCodeRef((code_ref *) element(&(doomedMember->codeList), counter));   }
    deleteLinkedList(&(doomedMember->codeList));
    
    deleteElement(&(theVariable->mem.members), doomedMemberNumber);
    
    return;     // we ignored return values from FDeleteElement -- an error is possible, but seems implausible to me.
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
addq $0x10, %r14
movq %r14, %rdi
callq 0x9088
movq %rax, %r15
cmpq $0x0, (%rax)
je 0xec37
movq %r15, %rdi
callq 0xc801
addq $0x20, %r15
pushq $0x1
popq %rbp
cmpl (%r15), %ebp
jg 0xec59
movq %r15, %rdi
movl %ebp, %esi
callq 0x9088
movq %rax, %rdi
callq 0xe533
incl %ebp
jmp 0xec3e
movq %r15, %rdi
callq 0x846b
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8b1c
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/intrpt.c
// Function: refPath
void refPath(searchPath *thePath)
{
    if (thePath == NULL)  return;
    
    RefPLLPtr(thePath->references);
    
    if (*(thePath->references) == 1)  {
        refPath(thePath->stem);
        refPLLElement(&MasterCodeList, thePath->sourceCode);
        refWindow(thePath->jamb);     }
    
    return;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0xec8d
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movl (%rax), %ecx
leal 0x1(%rcx), %edx
movl %edx, (%rax)
testl %ecx, %ecx
je 0xec8f
popq %rbx
retq
movq 0x20(%rbx), %rdi
callq 0xec75
movl 0x2c(%rbx), %esi
leaq 0x15a06(%rip), %rdi     # 0x246a8
callq 0x9219
movq 0x18(%rbx), %rdi
popq %rbx
jmp 0xc7e1
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/intrpt.c
// Function: drawPath
ccInt drawPath(searchPath **newPath, window *destWindow, searchPath *newPathStem, ccInt indices, ccInt sourceCode)
{
    ccInt newPathIndex, rtrn;
    
    rtrn = addPLLElement(&(destWindow->variable_ptr->pathList), (void **) newPath, &newPathIndex);
    if (rtrn != passed)  return rtrn;
    
    (*newPath)->PLL_index = newPathIndex;
    (*newPath)->references = LL_int(&(destWindow->variable_ptr->pathList.references), newPathIndex);
    (*newPath)->stemIndices = indices;
    (*newPath)->stem = newPathStem;
    (*newPath)->variablePtr = destWindow->variable_ptr;
    (*newPath)->sourceCode = sourceCode;
    (*newPath)->jamb = destWindow;
    
    *((*newPath)->references) = 0;
    return passed;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movq 0x10(%rsi), %rdi
addq $0x78, %rdi
leaq 0x4(%rsp), %rdx
movq %r14, %rsi
callq 0x9155
movl %eax, %r13d
testl %eax, %eax
jne 0xed2d
movl 0x4(%rsp), %esi
movq (%r14), %rax
movl %esi, (%rax)
movl $0x98, %edi
addq 0x10(%r15), %rdi
callq 0x9088
movq (%r14), %rcx
movq %rax, 0x8(%rcx)
movq (%r14), %rax
movl %ebp, 0x28(%rax)
movq %r12, 0x20(%rax)
movq 0x10(%r15), %rax
movq (%r14), %rcx
movq %rax, 0x10(%rcx)
movq (%r14), %rax
movl %ebx, 0x2c(%rax)
movq %r15, 0x18(%rax)
movq (%r14), %rax
movq 0x8(%rax), %rax
andl $0x0, (%rax)
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/heltilda[P]cicada/intrpt.c
// Function: derefCode
void derefCode(ccInt *refsPtr, ccInt refsID)
{
    derefPLLPtr(&MasterCodeList, refsID, refsPtr);
    if (refsPtr == NULL)  {
        if (storedCode(refsID)->fileName != NULL)  free((void *) storedCode(refsID)->fileName);
        if (storedCode(refsID)->sourceCode != NULL)  free((void *) storedCode(refsID)->sourceCode);
        if (storedCode(refsID)->opCharNum != NULL)  free((void *) storedCode(refsID)->opCharNum);
        free((void *) storedCode(refsID)->bytecode);        }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x157fb(%rip), %rdi     # 0x246a8
movq %r14, %rdx
callq 0x9253
testq %r14, %r14
je 0xeec2
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x157df(%rip), %rdi     # 0x246a8
movl %ebx, %esi
callq 0x9088
cmpq $0x0, (%rax)
je 0xeeec
leaq 0x157cb(%rip), %rdi     # 0x246a8
movl %ebx, %esi
callq 0x9088
movq (%rax), %rdi
callq 0x81c0
leaq 0x157b5(%rip), %rdi     # 0x246a8
movl %ebx, %esi
callq 0x9088
cmpq $0x0, 0x8(%rax)
je 0xef18
leaq 0x157a0(%rip), %rdi     # 0x246a8
movl %ebx, %esi
callq 0x9088
movq 0x8(%rax), %rdi
callq 0x81c0
leaq 0x15789(%rip), %rdi     # 0x246a8
movl %ebx, %esi
callq 0x9088
cmpq $0x0, 0x18(%rax)
je 0xef44
leaq 0x15774(%rip), %rdi     # 0x246a8
movl %ebx, %esi
callq 0x9088
movq 0x18(%rax), %rdi
callq 0x81c0
leaq 0x1575d(%rip), %rdi     # 0x246a8
movl %ebx, %esi
callq 0x9088
movq 0x10(%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x81c0