// File: /workspace/github_c_makefile_star2_O0/heltilda[P]cicada/cmpile.c
// Function: relinkBestToken
ccInt relinkBestToken(compiler_type *compiler, linkedlist *OoOblock, ccInt firstToken, ccInt lastToken, ccInt expectedType,
        ccInt **lastOrderedToken, ccBool **lastRtrnTypes, ccInt *lastTokenToFix)
{
    ccInt lowOoO = 0, bestToken = 0, lowOoOpos = 0, blockOpCounter, tokenNum = 0, rtrn;       // inits to suppress warning
    ccInt innerToken, adapter = 0, tokenToFix, *argPtr, loopArgType;
    ccBool **rtrnTypes = NULL;
    tokenSpecType *oneSpec, *bestSpec = NULL;
    scriptTokenType *oneScriptToken;
    
    
        // find the lowest-precedence token
    
    if (lastToken < firstToken)  {
        errPosition = 0;                        // temporary -- we will update errPosition later
        return arg_expected_err;        }
    
    for (blockOpCounter = firstToken; blockOpCounter <= lastToken; blockOpCounter++)  {
        
        tokenNum = *LL_int(OoOblock, blockOpCounter);
        oneScriptToken = scriptToken(tokenNum);
        oneSpec = tokenSpec(oneScriptToken->tokenID);
        
        if ((blockOpCounter == firstToken) || (oneSpec->precedence <= lowOoO))  {
            if ((blockOpCounter == firstToken) || ((oneSpec->leftArgType != -1)
                        && ((blockOpCounter == lastToken) || (oneSpec->rightArgType != -1))
                        && ((compiler->OoOdirections[oneSpec->precedence-1] == l_to_r) || (oneSpec->precedence < lowOoO))) )  {
                bestToken = tokenNum;
                bestSpec = oneSpec;
                rtrnTypes = &(oneScriptToken->rtrnTypes);
                lowOoO = oneSpec->precedence;
                lowOoOpos = blockOpCounter;         }
            
            else if (lowOoO == 1)  break;     // speeds up sentence-parsing (\n is highest-precedence)
    }   }
    
    
        // in rare cases we may have a type-X no-argument adapter whose type needs setting (if possible)
        // (it might be either this operator or else an enclosed operator)
        // 
        // 2 possibilities:  either we know what type we are expecting, in which case we 'fix' the adapter
        // type (or throw an error if we don't have an adapter of the appropriate type);
        // or else we don't know because it is an enclosed argument, so we feed the token # that needs fixing
        // back to the enclosing operator
    
    tokenToFix = scriptToken(bestToken)->adapterTokenToFix;
    if (tokenToFix != 0)  {
        if (expectedType == 10)  *lastTokenToFix = tokenToFix;
        else if (compiler->adapters[10][expectedType] != 0)  {
            scriptToken(tokenToFix)->adapterTokenToFix = compiler->adapters[10][expectedType];
            (*rtrnTypes)[expectedType] = ccTrue;     }
        else  {
            errPosition = scriptToken(tokenToFix)->tokenCharNum;
            return arg_expected_err;
    }   }
    
    
        // check to see if the best token is not of a type that we expected;
        // if possible, add an adapter to the argument
        //
        // Note:  the adapters are all added at the END of the bytecode
        // so as not to disrupt the positions of earlier tokens which may already be linked
    
    if (expectedType < (ccInt) (*typeXarg - *type0arg))  {
    if (!((*rtrnTypes)[expectedType]))  {
        
        for (loopArgType = 0; loopArgType < 10; loopArgType++)  {
        if (((*rtrnTypes)[loopArgType]) && (compiler->adapters[loopArgType][expectedType] != 0))  {
            
            rtrn = addScriptToken(compiler, compiler->adapters[loopArgType][expectedType], scriptToken(bestToken)->tokenCharNum, NULL, 0);
            if (rtrn != passed)  return rtrn;
            
            adapter = compiler->scriptTokens.elementNum;
            **lastOrderedToken = adapter;
            *lastOrderedToken = &(scriptToken(adapter)->firstArg);
            
            break;
        }}
        
            // otherwise throw a type-mismatch error
        
        if (adapter == 0)  {
            errPosition = scriptToken(bestToken)->tokenCharNum;
            return type_mismatch_err;
    }}  }
    
    
        // build the link to bestToken from some previous token
        // (lastOrderedToken is either the firstArg or nextExpression field of that prior token)
    
    **lastOrderedToken = bestToken;
    
    
        // now set bestToken's firstArg field to point to the lowest-OoO operator of its first argument
        // 
        // this low-OoO token's nextExpression field will point to the second argument of bestToken;
        // then that token's nextExpression will point to the third argument; etc.
        // 
        // the last argument's nextExpression field (or firstArg, if there are no arguments) is set to zero
    
    argPtr = &(scriptToken(bestToken)->firstArg);
    *lastOrderedToken = argPtr;
    **lastOrderedToken = 0;
    
    
        // link the left-hand argument
    
    if (bestSpec->leftArgType != -1)  {
        rtrn = relinkBestToken(compiler, OoOblock, firstToken, lowOoOpos-1, bestSpec->leftArgType, lastOrderedToken,
            rtrnTypes, &(scriptToken(bestToken)->adapterTokenToFix));
        if (rtrn != passed)  {
            if ((rtrn == arg_expected_err) && (errPosition == 0))  {
                rtrn = left_arg_expected_err;
                errPosition = scriptToken(bestToken)->tokenCharNum;     }
            return rtrn;
    }   }
    else if (lowOoOpos != firstToken)  {
        errPosition = scriptToken(bestToken)->tokenCharNum;
        return no_left_arg_allowed_err;     }
    
    
        // link any enclosed arguments -- these have already been chained via their nextExpression fields
    
    if (scriptToken(bestToken)->nextScriptToken != 0)  {
        
        ccInt tokenInExpression = bestToken;
        
        innerToken = scriptToken(bestToken)->enclosedArgs;
        **lastOrderedToken = innerToken;
        while (scriptToken(innerToken)->nextExpression != 0)  innerToken = scriptToken(innerToken)->nextExpression;
        *lastOrderedToken = &(scriptToken(innerToken)->nextExpression);
        
        
            // update bestSpec to get our final right-hand argument
        
        while (scriptToken(tokenInExpression)->nextScriptToken != 0)  {
            tokenInExpression = scriptToken(tokenInExpression)->nextScriptToken;
            bestSpec = tokenSpec(bestSpec->nextToken);
    }   }
    
    
        // link the right-hand argument
    
    if (bestSpec->rightArgType != -1)  {
        rtrn = relinkBestToken(compiler, OoOblock, lowOoOpos+1, lastToken, bestSpec->rightArgType, lastOrderedToken,
            rtrnTypes, &(scriptToken(bestToken)->adapterTokenToFix));
        if (rtrn != passed)  {
            if ((rtrn == arg_expected_err) && (errPosition == 0))  {
                rtrn = right_arg_expected_err;
                errPosition = scriptToken(bestToken)->tokenCharNum;     }
            return rtrn;
    }   }
    else if (lowOoOpos != lastToken)  {
        errPosition = scriptToken(bestToken)->tokenCharNum;
        return no_right_arg_allowed_err;     }
    
    
        // finally, prepare to link to the token of the next argument bestToken
        // if this token is an argument of another token, then this will be the next argument of that token
        // the linking is done one level up, so all we have to do is set the pointer here
    
    if (adapter == 0)  argPtr = &(scriptToken(bestToken)->nextExpression);
    else  argPtr = &(scriptToken(adapter)->nextExpression);
    
    *lastOrderedToken = argPtr;
    **lastOrderedToken = 0;
    
    
        // if the enclosing operator is, say, a ( .. ), feed the return type of this operator on back
    
    if (((*lastRtrnTypes)[10]) && (expectedType == 10))  {
        *lastRtrnTypes = scriptToken(bestToken)->rtrnTypes;       }
    
    return passed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl $0x0, -0x44(%rbp)
movl $0x0, -0x50(%rbp)
movq $0x0, -0x70(%rbp)
movq $0x0, -0x80(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0xe62a
movl $0x0, 0x1dc7a(%rip)     # 0x2c298
movl $0xc, -0x4(%rbp)
jmp 0xed6b
movl -0x1c(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %eax
cmpl -0x20(%rbp), %eax
jg 0xe735
movq -0x18(%rbp), %rdi
movl -0x40(%rbp), %esi
callq 0x9700
movl (%rax), %eax
movl %eax, -0x44(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1440, %rdi           # imm = 0x1440
movl -0x44(%rbp), %esi
callq 0x9700
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movq -0x88(%rbp), %rax
movl (%rax), %esi
callq 0x9700
movq %rax, -0x78(%rbp)
movl -0x40(%rbp), %eax
cmpl -0x1c(%rbp), %eax
je 0xe69c
movq -0x78(%rbp), %rax
movl 0xc(%rax), %eax
cmpl -0x34(%rbp), %eax
jg 0xe725
movl -0x40(%rbp), %eax
cmpl -0x1c(%rbp), %eax
je 0xe6ea
movq -0x78(%rbp), %rax
cmpl $-0x1, 0x10(%rax)
je 0xe719
movl -0x40(%rbp), %eax
cmpl -0x20(%rbp), %eax
je 0xe6c0
movq -0x78(%rbp), %rax
cmpl $-0x1, 0x14(%rax)
je 0xe719
movq -0x10(%rbp), %rax
movq 0x1240(%rax), %rax
movq -0x78(%rbp), %rcx
movl 0xc(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
cmpl $0x1, (%rax,%rcx,4)
je 0xe6ea
movq -0x78(%rbp), %rax
movl 0xc(%rax), %eax
cmpl -0x34(%rbp), %eax
jge 0xe719
movl -0x44(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x88(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x70(%rbp)
movq -0x78(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x34(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x3c(%rbp)
jmp 0xe723
cmpl $0x1, -0x34(%rbp)
jne 0xe721
jmp 0xe735
jmp 0xe723
jmp 0xe725
jmp 0xe727
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0xe630
movq -0x10(%rbp), %rdi
addq $0x1440, %rdi           # imm = 0x1440
movl -0x38(%rbp), %esi
callq 0x9700
movl 0x30(%rax), %eax
movl %eax, -0x54(%rbp)
cmpl $0x0, -0x54(%rbp)
je 0xe7e9
cmpl $0xa, -0x24(%rbp)
jne 0xe769
movl -0x54(%rbp), %ecx
movq 0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0xe7e7
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
cmpl $0x0, 0x140c(%rax,%rcx,4)
je 0xe7bd
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl 0x140c(%rax,%rcx,4), %eax
movl %eax, -0x90(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1440, %rdi           # imm = 0x1440
movl -0x54(%rbp), %esi
callq 0x9700
movl -0x90(%rbp), %ecx
movl %ecx, 0x30(%rax)
movq -0x70(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movb $0x1, (%rax,%rcx)
jmp 0xe7e5
movq -0x10(%rbp), %rdi
addq $0x1440, %rdi           # imm = 0x1440
movl -0x54(%rbp), %esi
callq 0x9700
movl 0x4(%rax), %eax
movl %eax, 0x1dabf(%rip)     # 0x2c298
movl $0xc, -0x4(%rbp)
jmp 0xed6b
jmp 0xe7e7
jmp 0xe7e9
movl -0x24(%rbp), %eax
movsbl 0x13875(%rip), %ecx     # 0x22068
movsbl 0x13860(%rip), %edx     # 0x2205a
subl %edx, %ecx
cmpl %ecx, %eax
jge 0xe950
movq -0x70(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
jne 0xe94e
movl $0x0, -0x64(%rbp)
cmpl $0xa, -0x64(%rbp)
jge 0xe91e
movq -0x70(%rbp), %rax
movq (%rax), %rax
movslq -0x64(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0xe90e
movq -0x10(%rbp), %rax
addq $0x1254, %rax           # imm = 0x1254
movslq -0x64(%rbp), %rcx
imulq $0x2c, %rcx, %rcx
addq %rcx, %rax
movslq -0x24(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0xe90e
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x10(%rbp), %rax
addq $0x1254, %rax           # imm = 0x1254
movslq -0x64(%rbp), %rcx
imulq $0x2c, %rcx, %rcx
addq %rcx, %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x94(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1440, %rdi           # imm = 0x1440
movl -0x38(%rbp), %esi
callq 0x9700
movq -0xa0(%rbp), %rdi
movl -0x94(%rbp), %esi
movl 0x4(%rax), %edx
xorl %eax, %eax
movl %eax, %ecx
xorl %r8d, %r8d
callq 0xd4f0
movl %eax, -0x48(%rbp)
cmpl $0x0, -0x48(%rbp)
je 0xe8d2
movl -0x48(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xed6b
movq -0x10(%rbp), %rax
movl 0x1440(%rax), %eax
movl %eax, -0x50(%rbp)
movl -0x50(%rbp), %ecx
movq -0x30(%rbp), %rax
movq (%rax), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
addq $0x1440, %rdi           # imm = 0x1440
movl -0x50(%rbp), %esi
callq 0x9700
movq %rax, %rcx
addq $0x8, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
jmp 0xe91e
jmp 0xe910
movl -0x64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
jmp 0xe820
cmpl $0x0, -0x50(%rbp)
jne 0xe94c
movq -0x10(%rbp), %rdi
addq $0x1440, %rdi           # imm = 0x1440
movl -0x38(%rbp), %esi
callq 0x9700
movl 0x4(%rax), %eax
movl %eax, 0x1d958(%rip)     # 0x2c298
movl $0x11, -0x4(%rbp)
jmp 0xed6b
jmp 0xe94e
jmp 0xe950
movl -0x38(%rbp), %ecx
movq -0x30(%rbp), %rax
movq (%rax), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
addq $0x1440, %rdi           # imm = 0x1440
movl -0x38(%rbp), %esi
callq 0x9700
addq $0x8, %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movl $0x0, (%rax)
movq -0x80(%rbp), %rax
cmpl $-0x1, 0x10(%rax)
je 0xea87
movq -0x10(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xc8(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0xbc(%rbp)
movl -0x3c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0xb8(%rbp)
movq -0x80(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0xb4(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1440, %rdi           # imm = 0x1440
movl -0x38(%rbp), %esi
callq 0x9700
movq -0xd0(%rbp), %rdi
movq -0xc8(%rbp), %rsi
movl -0xbc(%rbp), %edx
movl -0xb8(%rbp), %ecx
movl -0xb4(%rbp), %r8d
movq -0xb0(%rbp), %r9
movq -0xa8(%rbp), %r10
addq $0x30, %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0xe5b0
movl %eax, -0x48(%rbp)
cmpl $0x0, -0x48(%rbp)
je 0xea85
cmpl $0xc, -0x48(%rbp)
jne 0xea7a
cmpl $0x0, 0x1d843(%rip)     # 0x2c298
jne 0xea7a
movl $0xd, -0x48(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1440, %rdi           # imm = 0x1440
movl -0x38(%rbp), %esi
callq 0x9700
movl 0x4(%rax), %eax
movl %eax, 0x1d81e(%rip)     # 0x2c298
movl -0x48(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xed6b
jmp 0xeab9
movl -0x3c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
je 0xeab7
movq -0x10(%rbp), %rdi
addq $0x1440, %rdi           # imm = 0x1440
movl -0x38(%rbp), %esi
callq 0x9700
movl 0x4(%rax), %eax
movl %eax, 0x1d7ed(%rip)     # 0x2c298
movl $0xf, -0x4(%rbp)
jmp 0xed6b
jmp 0xeab9
movq -0x10(%rbp), %rdi
addq $0x1440, %rdi           # imm = 0x1440
movl -0x38(%rbp), %esi
callq 0x9700
cmpl $0x0, 0x14(%rax)
je 0xebb3
movl -0x38(%rbp), %eax
movl %eax, -0x8c(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1440, %rdi           # imm = 0x1440
movl -0x38(%rbp), %esi
callq 0x9700
movl 0x10(%rax), %eax
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %ecx
movq -0x30(%rbp), %rax
movq (%rax), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
addq $0x1440, %rdi           # imm = 0x1440
movl -0x4c(%rbp), %esi
callq 0x9700
cmpl $0x0, 0xc(%rax)
je 0xeb38
movq -0x10(%rbp), %rdi
addq $0x1440, %rdi           # imm = 0x1440
movl -0x4c(%rbp), %esi
callq 0x9700
movl 0xc(%rax), %eax
movl %eax, -0x4c(%rbp)
jmp 0xeb04
movq -0x10(%rbp), %rdi
addq $0x1440, %rdi           # imm = 0x1440
movl -0x4c(%rbp), %esi
callq 0x9700
movq %rax, %rcx
addq $0xc, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
addq $0x1440, %rdi           # imm = 0x1440
movl -0x8c(%rbp), %esi
callq 0x9700
cmpl $0x0, 0x14(%rax)
je 0xebb1
movq -0x10(%rbp), %rdi
addq $0x1440, %rdi           # imm = 0x1440
movl -0x8c(%rbp), %esi
callq 0x9700
movl 0x14(%rax), %eax
movl %eax, -0x8c(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1200, %rdi           # imm = 0x1200
movq -0x80(%rbp), %rax
movl 0x28(%rax), %esi
callq 0x9700
movq %rax, -0x80(%rbp)
jmp 0xeb59
jmp 0xebb3
movq -0x80(%rbp), %rax
cmpl $-0x1, 0x14(%rax)
je 0xecab
movq -0x10(%rbp), %rax
movq %rax, -0x100(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xf8(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xec(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0xe8(%rbp)
movq -0x80(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0xe4(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0xe0(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1440, %rdi           # imm = 0x1440
movl -0x38(%rbp), %esi
callq 0x9700
movq -0x100(%rbp), %rdi
movq -0xf8(%rbp), %rsi
movl -0xec(%rbp), %edx
movl -0xe8(%rbp), %ecx
movl -0xe4(%rbp), %r8d
movq -0xe0(%rbp), %r9
movq -0xd8(%rbp), %r10
addq $0x30, %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0xe5b0
movl %eax, -0x48(%rbp)
cmpl $0x0, -0x48(%rbp)
je 0xeca9
cmpl $0xc, -0x48(%rbp)
jne 0xec9e
cmpl $0x0, 0x1d61f(%rip)     # 0x2c298
jne 0xec9e
movl $0xe, -0x48(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1440, %rdi           # imm = 0x1440
movl -0x38(%rbp), %esi
callq 0x9700
movl 0x4(%rax), %eax
movl %eax, 0x1d5fa(%rip)     # 0x2c298
movl -0x48(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xed6b
jmp 0xecdd
movl -0x3c(%rbp), %eax
cmpl -0x20(%rbp), %eax
je 0xecdb
movq -0x10(%rbp), %rdi
addq $0x1440, %rdi           # imm = 0x1440
movl -0x38(%rbp), %esi
callq 0x9700
movl 0x4(%rax), %eax
movl %eax, 0x1d5c9(%rip)     # 0x2c298
movl $0x10, -0x4(%rbp)
jmp 0xed6b
jmp 0xecdd
cmpl $0x0, -0x50(%rbp)
jne 0xed00
movq -0x10(%rbp), %rdi
addq $0x1440, %rdi           # imm = 0x1440
movl -0x38(%rbp), %esi
callq 0x9700
addq $0xc, %rax
movq %rax, -0x60(%rbp)
jmp 0xed1b
movq -0x10(%rbp), %rdi
addq $0x1440, %rdi           # imm = 0x1440
movl -0x50(%rbp), %esi
callq 0x9700
addq $0xc, %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movl $0x0, (%rax)
movq 0x10(%rbp), %rax
movq (%rax), %rax
cmpb $0x0, 0xa(%rax)
je 0xed64
cmpl $0xa, -0x24(%rbp)
jne 0xed64
movq -0x10(%rbp), %rdi
addq $0x1440, %rdi           # imm = 0x1440
movl -0x38(%rbp), %esi
callq 0x9700
movq 0x28(%rax), %rcx
movq 0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nop
nopl (%rax,%rax)