// File: mouda[P]LTE_random_access-simulate/alglibinternal.cpp
// Function: alglib_impl::mcsrch(long, alglib_impl::ae_vector*, double*, alglib_impl::ae_vector*, alglib_impl::ae_vector*, double*, double, double, long*, long*, alglib_impl::ae_vector*, alglib_impl::linminstate*, long*, alglib_impl::ae_state*)
void mcsrch(ae_int_t n,
     /* Real    */ ae_vector* x,
     double* f,
     /* Real    */ ae_vector* g,
     /* Real    */ ae_vector* s,
     double* stp,
     double stpmax,
     double gtol,
     ae_int_t* info,
     ae_int_t* nfev,
     /* Real    */ ae_vector* wa,
     linminstate* state,
     ae_int_t* stage,
     ae_state *_state)
{
    double v;
    double p5;
    double p66;
    double zero;


    
    /*
     * init
     */
    p5 = 0.5;
    p66 = 0.66;
    state->xtrapf = 4.0;
    zero = 0;
    if( ae_fp_eq(stpmax,0) )
    {
        stpmax = linmin_defstpmax;
    }
    if( ae_fp_less(*stp,linmin_stpmin) )
    {
        *stp = linmin_stpmin;
    }
    if( ae_fp_greater(*stp,stpmax) )
    {
        *stp = stpmax;
    }
    
    /*
     * Main cycle
     */
    for(;;)
    {
        if( *stage==0 )
        {
            
            /*
             * NEXT
             */
            *stage = 2;
            continue;
        }
        if( *stage==2 )
        {
            state->infoc = 1;
            *info = 0;
            
            /*
             *     CHECK THE INPUT PARAMETERS FOR ERRORS.
             */
            if( ae_fp_less(stpmax,linmin_stpmin)&&ae_fp_greater(stpmax,0) )
            {
                *info = 5;
                *stp = 0.0;
                return;
            }
            if( ((((((n<=0||ae_fp_less_eq(*stp,0))||ae_fp_less(linmin_ftol,0))||ae_fp_less(gtol,zero))||ae_fp_less(linmin_xtol,zero))||ae_fp_less(linmin_stpmin,zero))||ae_fp_less(stpmax,linmin_stpmin))||linmin_maxfev<=0 )
            {
                *stage = 0;
                return;
            }
            
            /*
             *     COMPUTE THE INITIAL GRADIENT IN THE SEARCH DIRECTION
             *     AND CHECK THAT S IS A DESCENT DIRECTION.
             */
            v = ae_v_dotproduct(&g->ptr.p_double[0], 1, &s->ptr.p_double[0], 1, ae_v_len(0,n-1));
            state->dginit = v;
            if( ae_fp_greater_eq(state->dginit,0) )
            {
                *stage = 0;
                return;
            }
            
            /*
             *     INITIALIZE LOCAL VARIABLES.
             */
            state->brackt = ae_false;
            state->stage1 = ae_true;
            *nfev = 0;
            state->finit = *f;
            state->dgtest = linmin_ftol*state->dginit;
            state->width = stpmax-linmin_stpmin;
            state->width1 = state->width/p5;
            ae_v_move(&wa->ptr.p_double[0], 1, &x->ptr.p_double[0], 1, ae_v_len(0,n-1));
            
            /*
             *     THE VARIABLES STX, FX, DGX CONTAIN THE VALUES OF THE STEP,
             *     FUNCTION, AND DIRECTIONAL DERIVATIVE AT THE BEST STEP.
             *     THE VARIABLES STY, FY, DGY CONTAIN THE VALUE OF THE STEP,
             *     FUNCTION, AND DERIVATIVE AT THE OTHER ENDPOINT OF
             *     THE INTERVAL OF UNCERTAINTY.
             *     THE VARIABLES STP, F, DG CONTAIN THE VALUES OF THE STEP,
             *     FUNCTION, AND DERIVATIVE AT THE CURRENT STEP.
             */
            state->stx = 0;
            state->fx = state->finit;
            state->dgx = state->dginit;
            state->sty = 0;
            state->fy = state->finit;
            state->dgy = state->dginit;
            
            /*
             * NEXT
             */
            *stage = 3;
            continue;
        }
        if( *stage==3 )
        {
            
            /*
             *     START OF ITERATION.
             *
             *     SET THE MINIMUM AND MAXIMUM STEPS TO CORRESPOND
             *     TO THE PRESENT INTERVAL OF UNCERTAINTY.
             */
            if( state->brackt )
            {
                if( ae_fp_less(state->stx,state->sty) )
                {
                    state->stmin = state->stx;
                    state->stmax = state->sty;
                }
                else
                {
                    state->stmin = state->sty;
                    state->stmax = state->stx;
                }
            }
            else
            {
                state->stmin = state->stx;
                state->stmax = *stp+state->xtrapf*(*stp-state->stx);
            }
            
            /*
             *        FORCE THE STEP TO BE WITHIN THE BOUNDS STPMAX AND STPMIN.
             */
            if( ae_fp_greater(*stp,stpmax) )
            {
                *stp = stpmax;
            }
            if( ae_fp_less(*stp,linmin_stpmin) )
            {
                *stp = linmin_stpmin;
            }
            
            /*
             *        IF AN UNUSUAL TERMINATION IS TO OCCUR THEN LET
             *        STP BE THE LOWEST POINT OBTAINED SO FAR.
             */
            if( (((state->brackt&&(ae_fp_less_eq(*stp,state->stmin)||ae_fp_greater_eq(*stp,state->stmax)))||*nfev>=linmin_maxfev-1)||state->infoc==0)||(state->brackt&&ae_fp_less_eq(state->stmax-state->stmin,linmin_xtol*state->stmax)) )
            {
                *stp = state->stx;
            }
            
            /*
             *        EVALUATE THE FUNCTION AND GRADIENT AT STP
             *        AND COMPUTE THE DIRECTIONAL DERIVATIVE.
             */
            ae_v_move(&x->ptr.p_double[0], 1, &wa->ptr.p_double[0], 1, ae_v_len(0,n-1));
            ae_v_addd(&x->ptr.p_double[0], 1, &s->ptr.p_double[0], 1, ae_v_len(0,n-1), *stp);
            
            /*
             * NEXT
             */
            *stage = 4;
            return;
        }
        if( *stage==4 )
        {
            *info = 0;
            *nfev = *nfev+1;
            v = ae_v_dotproduct(&g->ptr.p_double[0], 1, &s->ptr.p_double[0], 1, ae_v_len(0,n-1));
            state->dg = v;
            state->ftest1 = state->finit+*stp*state->dgtest;
            
            /*
             *        TEST FOR CONVERGENCE.
             */
            if( (state->brackt&&(ae_fp_less_eq(*stp,state->stmin)||ae_fp_greater_eq(*stp,state->stmax)))||state->infoc==0 )
            {
                *info = 6;
            }
            if( (ae_fp_eq(*stp,stpmax)&&ae_fp_less_eq(*f,state->ftest1))&&ae_fp_less_eq(state->dg,state->dgtest) )
            {
                *info = 5;
            }
            if( ae_fp_eq(*stp,linmin_stpmin)&&(ae_fp_greater(*f,state->ftest1)||ae_fp_greater_eq(state->dg,state->dgtest)) )
            {
                *info = 4;
            }
            if( *nfev>=linmin_maxfev )
            {
                *info = 3;
            }
            if( state->brackt&&ae_fp_less_eq(state->stmax-state->stmin,linmin_xtol*state->stmax) )
            {
                *info = 2;
            }
            if( ae_fp_less_eq(*f,state->ftest1)&&ae_fp_less_eq(ae_fabs(state->dg, _state),-gtol*state->dginit) )
            {
                *info = 1;
            }
            
            /*
             *        CHECK FOR TERMINATION.
             */
            if( *info!=0 )
            {
                *stage = 0;
                return;
            }
            
            /*
             *        IN THE FIRST STAGE WE SEEK A STEP FOR WHICH THE MODIFIED
             *        FUNCTION HAS A NONPOSITIVE VALUE AND NONNEGATIVE DERIVATIVE.
             */
            if( (state->stage1&&ae_fp_less_eq(*f,state->ftest1))&&ae_fp_greater_eq(state->dg,ae_minreal(linmin_ftol, gtol, _state)*state->dginit) )
            {
                state->stage1 = ae_false;
            }
            
            /*
             *        A MODIFIED FUNCTION IS USED TO PREDICT THE STEP ONLY IF
             *        WE HAVE NOT OBTAINED A STEP FOR WHICH THE MODIFIED
             *        FUNCTION HAS A NONPOSITIVE FUNCTION VALUE AND NONNEGATIVE
             *        DERIVATIVE, AND IF A LOWER FUNCTION VALUE HAS BEEN
             *        OBTAINED BUT THE DECREASE IS NOT SUFFICIENT.
             */
            if( (state->stage1&&ae_fp_less_eq(*f,state->fx))&&ae_fp_greater(*f,state->ftest1) )
            {
                
                /*
                 *           DEFINE THE MODIFIED FUNCTION AND DERIVATIVE VALUES.
                 */
                state->fm = *f-*stp*state->dgtest;
                state->fxm = state->fx-state->stx*state->dgtest;
                state->fym = state->fy-state->sty*state->dgtest;
                state->dgm = state->dg-state->dgtest;
                state->dgxm = state->dgx-state->dgtest;
                state->dgym = state->dgy-state->dgtest;
                
                /*
                 *           CALL CSTEP TO UPDATE THE INTERVAL OF UNCERTAINTY
                 *           AND TO COMPUTE THE NEW STEP.
                 */
                linmin_mcstep(&state->stx, &state->fxm, &state->dgxm, &state->sty, &state->fym, &state->dgym, stp, state->fm, state->dgm, &state->brackt, state->stmin, state->stmax, &state->infoc, _state);
                
                /*
                 *           RESET THE FUNCTION AND GRADIENT VALUES FOR F.
                 */
                state->fx = state->fxm+state->stx*state->dgtest;
                state->fy = state->fym+state->sty*state->dgtest;
                state->dgx = state->dgxm+state->dgtest;
                state->dgy = state->dgym+state->dgtest;
            }
            else
            {
                
                /*
                 *           CALL MCSTEP TO UPDATE THE INTERVAL OF UNCERTAINTY
                 *           AND TO COMPUTE THE NEW STEP.
                 */
                linmin_mcstep(&state->stx, &state->fx, &state->dgx, &state->sty, &state->fy, &state->dgy, stp, *f, state->dg, &state->brackt, state->stmin, state->stmax, &state->infoc, _state);
            }
            
            /*
             *        FORCE A SUFFICIENT DECREASE IN THE SIZE OF THE
             *        INTERVAL OF UNCERTAINTY.
             */
            if( state->brackt )
            {
                if( ae_fp_greater_eq(ae_fabs(state->sty-state->stx, _state),p66*state->width1) )
                {
                    *stp = state->stx+p5*(state->sty-state->stx);
                }
                state->width1 = state->width;
                state->width = ae_fabs(state->sty-state->stx, _state);
            }
            
            /*
             *  NEXT.
             */
            *stage = 3;
            continue;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xd8, %rsp
movq 0x38(%rbp), %rax
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movsd %xmm0, -0x40(%rbp)
movsd %xmm1, -0x48(%rbp)
movsd 0x23d02(%rip), %xmm0    # 0x55450
movsd %xmm0, -0x58(%rbp)
movsd 0x2611d(%rip), %xmm0    # 0x57878
movsd %xmm0, -0x60(%rbp)
movq 0x28(%rbp), %rax
movsd 0x23a4c(%rip), %xmm0    # 0x551b8
movsd %xmm0, 0xb8(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, -0x68(%rbp)
movsd -0x40(%rbp), %xmm0
xorps %xmm1, %xmm1
callq 0x3c3d0
testb $0x1, %al
jne 0x3178f
jmp 0x3179c
movsd 0x33b61(%rip), %xmm0    # 0x652f8
movsd %xmm0, -0x40(%rbp)
movq -0x38(%rbp), %rax
movsd (%rax), %xmm0
movsd 0x33b54(%rip), %xmm1    # 0x65300
callq 0x3c440
testb $0x1, %al
jne 0x317b7
jmp 0x317c7
movsd 0x33b41(%rip), %xmm0    # 0x65300
movq -0x38(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x38(%rbp), %rax
movsd (%rax), %xmm0
movsd -0x40(%rbp), %xmm1
callq 0x3c4c0
testb $0x1, %al
jne 0x317df
jmp 0x317ec
movsd -0x40(%rbp), %xmm0
movq -0x38(%rbp), %rax
movsd %xmm0, (%rax)
jmp 0x317ee
movq 0x30(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x31805
movq 0x30(%rbp), %rax
movq $0x2, (%rax)
jmp 0x317ee
movq 0x30(%rbp), %rax
cmpq $0x2, (%rax)
jne 0x31ac5
movq 0x28(%rbp), %rax
movq $0x1, 0x8(%rax)
movq 0x10(%rbp), %rax
movq $0x0, (%rax)
movsd -0x40(%rbp), %xmm0
movsd 0x33ac9(%rip), %xmm1    # 0x65300
callq 0x3c440
testb $0x1, %al
jne 0x31842
jmp 0x31870
movsd -0x40(%rbp), %xmm0
xorps %xmm1, %xmm1
callq 0x3c4c0
testb $0x1, %al
jne 0x31855
jmp 0x31870
movq 0x10(%rbp), %rax
movq $0x5, (%rax)
movq -0x38(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
jmp 0x3249b
cmpq $0x0, -0x10(%rbp)
jle 0x31902
movq -0x38(%rbp), %rax
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
callq 0x3c480
testb $0x1, %al
jne 0x31902
movsd 0x33a71(%rip), %xmm0    # 0x65308
xorps %xmm1, %xmm1
callq 0x3c440
testb $0x1, %al
jne 0x31902
movsd -0x48(%rbp), %xmm0
movsd -0x68(%rbp), %xmm1
callq 0x3c440
testb $0x1, %al
jne 0x31902
movsd 0x33a52(%rip), %xmm0    # 0x65310
movsd -0x68(%rbp), %xmm1
callq 0x3c440
testb $0x1, %al
jne 0x31902
movsd 0x33a2c(%rip), %xmm0    # 0x65300
movsd -0x68(%rbp), %xmm1
callq 0x3c440
testb $0x1, %al
jne 0x31902
movsd -0x40(%rbp), %xmm0
movsd 0x33a11(%rip), %xmm1    # 0x65300
callq 0x3c440
testb $0x1, %al
jne 0x31902
cmpq $0x0, 0x33a18(%rip)     # 0x65318
jg 0x31912
movq 0x30(%rbp), %rax
movq $0x0, (%rax)
jmp 0x3249b
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x30(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rsi
subq $0x1, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x42370
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rdx
movq %rax, %r8
movl $0x1, %ecx
movq %rcx, %rsi
callq 0x41940
movsd %xmm0, -0x50(%rbp)
movsd -0x50(%rbp), %xmm0
movq 0x28(%rbp), %rax
movsd %xmm0, 0x20(%rax)
movq 0x28(%rbp), %rax
movsd 0x20(%rax), %xmm0
xorps %xmm1, %xmm1
callq 0x3c500
testb $0x1, %al
jne 0x3197d
jmp 0x3198d
movq 0x30(%rbp), %rax
movq $0x0, (%rax)
jmp 0x3249b
movq 0x28(%rbp), %rax
movb $0x0, (%rax)
movq 0x28(%rbp), %rax
movb $0x1, 0x1(%rax)
movq 0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movq 0x28(%rbp), %rax
movsd %xmm0, 0x50(%rax)
movsd 0x33948(%rip), %xmm0    # 0x65308
movq 0x28(%rbp), %rax
mulsd 0x20(%rax), %xmm0
movq 0x28(%rbp), %rax
movsd %xmm0, 0x28(%rax)
movsd -0x40(%rbp), %xmm0
subsd 0x33921(%rip), %xmm0    # 0x65300
movq 0x28(%rbp), %rax
movsd %xmm0, 0xa8(%rax)
movq 0x28(%rbp), %rax
movsd 0xa8(%rax), %xmm0
divsd -0x58(%rbp), %xmm0
movq 0x28(%rbp), %rax
movsd %xmm0, 0xb0(%rax)
movq 0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rsi
subq $0x1, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x42370
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rdx
movq %rax, %r8
movl $0x1, %ecx
movq %rcx, %rsi
callq 0x41b10
movq 0x28(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x88(%rax)
movq 0x28(%rbp), %rax
movsd 0x50(%rax), %xmm0
movq 0x28(%rbp), %rax
movsd %xmm0, 0x68(%rax)
movq 0x28(%rbp), %rax
movsd 0x20(%rax), %xmm0
movq 0x28(%rbp), %rax
movsd %xmm0, 0x30(%rax)
movq 0x28(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x90(%rax)
movq 0x28(%rbp), %rax
movsd 0x50(%rax), %xmm0
movq 0x28(%rbp), %rax
movsd %xmm0, 0x78(%rax)
movq 0x28(%rbp), %rax
movsd 0x20(%rax), %xmm0
movq 0x28(%rbp), %rax
movsd %xmm0, 0x40(%rax)
movq 0x30(%rbp), %rax
movq $0x3, (%rax)
jmp 0x317ee
movq 0x30(%rbp), %rax
cmpq $0x3, (%rax)
jne 0x31d76
movq 0x28(%rbp), %rax
testb $0x1, (%rax)
je 0x31b67
movq 0x28(%rbp), %rax
movsd 0x88(%rax), %xmm0
movq 0x28(%rbp), %rax
movsd 0x90(%rax), %xmm1
callq 0x3c440
testb $0x1, %al
jne 0x31b03
jmp 0x31b35
movq 0x28(%rbp), %rax
movsd 0x88(%rax), %xmm0
movq 0x28(%rbp), %rax
movsd %xmm0, 0x98(%rax)
movq 0x28(%rbp), %rax
movsd 0x90(%rax), %xmm0
movq 0x28(%rbp), %rax
movsd %xmm0, 0xa0(%rax)
jmp 0x31b65
movq 0x28(%rbp), %rax
movsd 0x90(%rax), %xmm0
movq 0x28(%rbp), %rax
movsd %xmm0, 0x98(%rax)
movq 0x28(%rbp), %rax
movsd 0x88(%rax), %xmm0
movq 0x28(%rbp), %rax
movsd %xmm0, 0xa0(%rax)
jmp 0x31bbb
movq 0x28(%rbp), %rax
movsd 0x88(%rax), %xmm0
movq 0x28(%rbp), %rax
movsd %xmm0, 0x98(%rax)
movq -0x38(%rbp), %rax
movsd (%rax), %xmm1
movq 0x28(%rbp), %rax
movsd 0xb8(%rax), %xmm0
movq -0x38(%rbp), %rax
movsd (%rax), %xmm2
movq 0x28(%rbp), %rax
subsd 0x88(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq 0x28(%rbp), %rax
movsd %xmm0, 0xa0(%rax)
movq -0x38(%rbp), %rax
movsd (%rax), %xmm0
movsd -0x40(%rbp), %xmm1
callq 0x3c4c0
testb $0x1, %al
jne 0x31bd3
jmp 0x31be0
movsd -0x40(%rbp), %xmm0
movq -0x38(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x38(%rbp), %rax
movsd (%rax), %xmm0
movsd 0x33710(%rip), %xmm1    # 0x65300
callq 0x3c440
testb $0x1, %al
jne 0x31bfb
jmp 0x31c0b
movsd 0x336fd(%rip), %xmm0    # 0x65300
movq -0x38(%rbp), %rax
movsd %xmm0, (%rax)
movq 0x28(%rbp), %rax
testb $0x1, (%rax)
je 0x31c4e
movq -0x38(%rbp), %rax
movsd (%rax), %xmm0
movq 0x28(%rbp), %rax
movsd 0x98(%rax), %xmm1
callq 0x3c480
testb $0x1, %al
jne 0x31cb0
movq -0x38(%rbp), %rax
movsd (%rax), %xmm0
movq 0x28(%rbp), %rax
movsd 0xa0(%rax), %xmm1
callq 0x3c500
testb $0x1, %al
jne 0x31cb0
movq 0x18(%rbp), %rax
movq (%rax), %rax
movq 0x336bc(%rip), %rcx     # 0x65318
subq $0x1, %rcx
cmpq %rcx, %rax
jge 0x31cb0
movq 0x28(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x31cb0
movq 0x28(%rbp), %rax
testb $0x1, (%rax)
je 0x31cc4
movq 0x28(%rbp), %rax
movsd 0xa0(%rax), %xmm0
movq 0x28(%rbp), %rax
subsd 0x98(%rax), %xmm0
movsd 0x33677(%rip), %xmm1    # 0x65310
movq 0x28(%rbp), %rax
mulsd 0xa0(%rax), %xmm1
callq 0x3c480
testb $0x1, %al
jne 0x31cb0
jmp 0x31cc4
movq 0x28(%rbp), %rax
movsd 0x88(%rax), %xmm0
movq -0x38(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0xa8(%rbp)
movq 0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0xa0(%rbp)
movq -0x10(%rbp), %rsi
subq $0x1, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x42370
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rdx
movq %rax, %r8
movl $0x1, %ecx
movq %rcx, %rsi
callq 0x41b10
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x98(%rbp)
movq -0x30(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rsi
subq $0x1, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x42370
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rdx
movq %rax, %r8
movq -0x38(%rbp), %rax
movsd (%rax), %xmm0
movl $0x1, %ecx
movq %rcx, %rsi
callq 0x41fe0
movq 0x30(%rbp), %rax
movq $0x4, (%rax)
jmp 0x3249b
movq 0x30(%rbp), %rax
cmpq $0x4, (%rax)
jne 0x32496
movq 0x10(%rbp), %rax
movq $0x0, (%rax)
movq 0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq 0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0xb8(%rbp)
movq -0x30(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0xb0(%rbp)
movq -0x10(%rbp), %rsi
subq $0x1, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x42370
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rdx
movq %rax, %r8
movl $0x1, %ecx
movq %rcx, %rsi
callq 0x41940
movsd %xmm0, -0x50(%rbp)
movsd -0x50(%rbp), %xmm0
movq 0x28(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movq 0x28(%rbp), %rax
movsd 0x50(%rax), %xmm1
movq -0x38(%rbp), %rax
movsd (%rax), %xmm0
movq 0x28(%rbp), %rax
movsd 0x28(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq 0x28(%rbp), %rax
movsd %xmm0, 0x58(%rax)
movq 0x28(%rbp), %rax
testb $0x1, (%rax)
je 0x31e6f
movq -0x38(%rbp), %rax
movsd (%rax), %xmm0
movq 0x28(%rbp), %rax
movsd 0x98(%rax), %xmm1
callq 0x3c480
testb $0x1, %al
jne 0x31e7a
movq -0x38(%rbp), %rax
movsd (%rax), %xmm0
movq 0x28(%rbp), %rax
movsd 0xa0(%rax), %xmm1
callq 0x3c500
testb $0x1, %al
jne 0x31e7a
movq 0x28(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x31e85
movq 0x10(%rbp), %rax
movq $0x6, (%rax)
movq -0x38(%rbp), %rax
movsd (%rax), %xmm0
movsd -0x40(%rbp), %xmm1
callq 0x3c3d0
testb $0x1, %al
jne 0x31e9d
jmp 0x31ee1
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movq 0x28(%rbp), %rax
movsd 0x58(%rax), %xmm1
callq 0x3c480
testb $0x1, %al
jne 0x31eb9
jmp 0x31ee1
movq 0x28(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq 0x28(%rbp), %rax
movsd 0x28(%rax), %xmm1
callq 0x3c480
testb $0x1, %al
jne 0x31ed6
jmp 0x31ee1
movq 0x10(%rbp), %rax
movq $0x5, (%rax)
movq -0x38(%rbp), %rax
movsd (%rax), %xmm0
movsd 0x3340f(%rip), %xmm1    # 0x65300
callq 0x3c3d0
testb $0x1, %al
jne 0x31efc
jmp 0x31f3e
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movq 0x28(%rbp), %rax
movsd 0x58(%rax), %xmm1
callq 0x3c4c0
testb $0x1, %al
jne 0x31f33
movq 0x28(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq 0x28(%rbp), %rax
movsd 0x28(%rax), %xmm1
callq 0x3c500
testb $0x1, %al
jne 0x31f33
jmp 0x31f3e
movq 0x10(%rbp), %rax
movq $0x4, (%rax)
movq 0x18(%rbp), %rax
movq (%rax), %rax
cmpq 0x333cc(%rip), %rax     # 0x65318
jl 0x31f59
movq 0x10(%rbp), %rax
movq $0x3, (%rax)
movq 0x28(%rbp), %rax
testb $0x1, (%rax)
je 0x31fa4
movq 0x28(%rbp), %rax
movsd 0xa0(%rax), %xmm0
movq 0x28(%rbp), %rax
subsd 0x98(%rax), %xmm0
movsd 0x3338e(%rip), %xmm1    # 0x65310
movq 0x28(%rbp), %rax
mulsd 0xa0(%rax), %xmm1
callq 0x3c480
testb $0x1, %al
jne 0x31f99
jmp 0x31fa4
movq 0x10(%rbp), %rax
movq $0x2, (%rax)
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movq 0x28(%rbp), %rax
movsd 0x58(%rax), %xmm1
callq 0x3c480
testb $0x1, %al
jne 0x31fc0
jmp 0x3200d
movq 0x28(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq 0x38(%rbp), %rdi
callq 0x3c820
movsd -0x48(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
movq 0x28(%rbp), %rax
mulsd 0x20(%rax), %xmm1
callq 0x3c480
testb $0x1, %al
jne 0x32002
jmp 0x3200d
movq 0x10(%rbp), %rax
movq $0x1, (%rax)
movq 0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x32027
movq 0x30(%rbp), %rax
movq $0x0, (%rax)
jmp 0x3249b
movq 0x28(%rbp), %rax
testb $0x1, 0x1(%rax)
je 0x3209b
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movq 0x28(%rbp), %rax
movsd 0x58(%rax), %xmm1
callq 0x3c480
testb $0x1, %al
jne 0x3204d
jmp 0x3209b
movq 0x28(%rbp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0xc0(%rbp)
movsd 0x332a2(%rip), %xmm0    # 0x65308
movsd -0x48(%rbp), %xmm1
movq 0x38(%rbp), %rdi
callq 0x3cab0
movaps %xmm0, %xmm1
movsd -0xc0(%rbp), %xmm0
movq 0x28(%rbp), %rax
mulsd 0x20(%rax), %xmm1
callq 0x3c500
testb $0x1, %al
jne 0x32093
jmp 0x3209b
movq 0x28(%rbp), %rax
movb $0x0, 0x1(%rax)
movq 0x28(%rbp), %rax
testb $0x1, 0x1(%rax)
je 0x32333
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movq 0x28(%rbp), %rax
movsd 0x68(%rax), %xmm1
callq 0x3c480
testb $0x1, %al
jne 0x320c8
jmp 0x32333
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movq 0x28(%rbp), %rax
movsd 0x58(%rax), %xmm1
callq 0x3c4c0
testb $0x1, %al
jne 0x320e7
jmp 0x32333
movq -0x20(%rbp), %rax
movsd (%rax), %xmm1
movq -0x38(%rbp), %rax
movsd (%rax), %xmm0
movq 0x28(%rbp), %rax
movsd 0x28(%rax), %xmm2
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq 0x28(%rbp), %rax
movsd %xmm0, 0x60(%rax)
movq 0x28(%rbp), %rax
movsd 0x68(%rax), %xmm1
movq 0x28(%rbp), %rax
movsd 0x88(%rax), %xmm0
movq 0x28(%rbp), %rax
movsd 0x28(%rax), %xmm2
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq 0x28(%rbp), %rax
movsd %xmm0, 0x70(%rax)
movq 0x28(%rbp), %rax
movsd 0x78(%rax), %xmm1
movq 0x28(%rbp), %rax
movsd 0x90(%rax), %xmm0
movq 0x28(%rbp), %rax
movsd 0x28(%rax), %xmm2
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq 0x28(%rbp), %rax
movsd %xmm0, 0x80(%rax)
movq 0x28(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq 0x28(%rbp), %rax
subsd 0x28(%rax), %xmm0
movq 0x28(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movq 0x28(%rbp), %rax
movsd 0x30(%rax), %xmm0
movq 0x28(%rbp), %rax
subsd 0x28(%rax), %xmm0
movq 0x28(%rbp), %rax
movsd %xmm0, 0x38(%rax)
movq 0x28(%rbp), %rax
movsd 0x40(%rax), %xmm0
movq 0x28(%rbp), %rax
subsd 0x28(%rax), %xmm0
movq 0x28(%rbp), %rax
movsd %xmm0, 0x48(%rax)
movq 0x28(%rbp), %rdi
addq $0x88, %rdi
movq 0x28(%rbp), %rsi
addq $0x70, %rsi
movq 0x28(%rbp), %rdx
addq $0x38, %rdx
movq 0x28(%rbp), %rcx
addq $0x90, %rcx
movq 0x28(%rbp), %r8
addq $0x80, %r8
movq 0x28(%rbp), %r9
addq $0x48, %r9
movq -0x38(%rbp), %rbx
movq 0x28(%rbp), %rax
movsd 0x60(%rax), %xmm0
movq 0x28(%rbp), %rax
movsd 0x18(%rax), %xmm1
movq 0x28(%rbp), %r11
movq 0x28(%rbp), %rax
movsd 0x98(%rax), %xmm2
movq 0x28(%rbp), %rax
movsd 0xa0(%rax), %xmm3
movq 0x28(%rbp), %r10
addq $0x8, %r10
movq 0x38(%rbp), %rax
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0x324b0
movq 0x28(%rbp), %rax
movsd 0x70(%rax), %xmm1
movq 0x28(%rbp), %rax
movsd 0x88(%rax), %xmm0
movq 0x28(%rbp), %rax
movsd 0x28(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq 0x28(%rbp), %rax
movsd %xmm0, 0x68(%rax)
movq 0x28(%rbp), %rax
movsd 0x80(%rax), %xmm1
movq 0x28(%rbp), %rax
movsd 0x90(%rax), %xmm0
movq 0x28(%rbp), %rax
movsd 0x28(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq 0x28(%rbp), %rax
movsd %xmm0, 0x78(%rax)
movq 0x28(%rbp), %rax
movsd 0x38(%rax), %xmm0
movq 0x28(%rbp), %rax
addsd 0x28(%rax), %xmm0
movq 0x28(%rbp), %rax
movsd %xmm0, 0x30(%rax)
movq 0x28(%rbp), %rax
movsd 0x48(%rax), %xmm0
movq 0x28(%rbp), %rax
addsd 0x28(%rax), %xmm0
movq 0x28(%rbp), %rax
movsd %xmm0, 0x40(%rax)
jmp 0x323be
movq 0x28(%rbp), %rdi
addq $0x88, %rdi
movq 0x28(%rbp), %rsi
addq $0x68, %rsi
movq 0x28(%rbp), %rdx
addq $0x30, %rdx
movq 0x28(%rbp), %rcx
addq $0x90, %rcx
movq 0x28(%rbp), %r8
addq $0x78, %r8
movq 0x28(%rbp), %r9
addq $0x40, %r9
movq -0x38(%rbp), %rbx
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movq 0x28(%rbp), %rax
movsd 0x10(%rax), %xmm1
movq 0x28(%rbp), %r11
movq 0x28(%rbp), %rax
movsd 0x98(%rax), %xmm2
movq 0x28(%rbp), %rax
movsd 0xa0(%rax), %xmm3
movq 0x28(%rbp), %r10
addq $0x8, %r10
movq 0x38(%rbp), %rax
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0x324b0
movq 0x28(%rbp), %rax
testb $0x1, (%rax)
je 0x32486
movq 0x28(%rbp), %rax
movsd 0x90(%rax), %xmm0
movq 0x28(%rbp), %rax
subsd 0x88(%rax), %xmm0
movq 0x38(%rbp), %rdi
callq 0x3c820
movsd -0x60(%rbp), %xmm1
movq 0x28(%rbp), %rax
mulsd 0xb0(%rax), %xmm1
callq 0x3c500
testb $0x1, %al
jne 0x32408
jmp 0x32441
movq 0x28(%rbp), %rax
movsd 0x88(%rax), %xmm1
movsd -0x58(%rbp), %xmm0
movq 0x28(%rbp), %rax
movsd 0x90(%rax), %xmm2
movq 0x28(%rbp), %rax
subsd 0x88(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x38(%rbp), %rax
movsd %xmm0, (%rax)
movq 0x28(%rbp), %rax
movsd 0xa8(%rax), %xmm0
movq 0x28(%rbp), %rax
movsd %xmm0, 0xb0(%rax)
movq 0x28(%rbp), %rax
movsd 0x90(%rax), %xmm0
movq 0x28(%rbp), %rax
subsd 0x88(%rax), %xmm0
movq 0x38(%rbp), %rdi
callq 0x3c820
movq 0x28(%rbp), %rax
movsd %xmm0, 0xa8(%rax)
movq 0x30(%rbp), %rax
movq $0x3, (%rax)
jmp 0x317ee
jmp 0x317ee
addq $0xd8, %rsp
popq %rbx
popq %rbp
retq
nopw %cs:(%rax,%rax)