// File: Eba-M[P]E3DC-Control/awattar.cpp
// Function: SimuWATTar(std::vector<watt_s, std::allocator<watt_s>>&, std::vector<wetter_s, std::allocator<wetter_s>>&, int, float&, float&, float, float, float, float, float)
int SimuWATTar(std::vector<watt_s> &w, std::vector<wetter_s> &wetter, int h, float &fSoC,float &anforderung,float Diff,float aufschlag, float reserve, float notstromreserve,float ladeleistung) // fConsumption Verbrauch in % SoC Differenz Laden/Endladen

// Returncode 0 = keine Aktion, 1 Batterieentladen stoppen 2 Batterie mit Netzstrom laden
{
    // Ermitteln Stundenanzahl
    // Analyseergebnisse in die Datei schreiben
    static float lowpp;
    time_t  rawtime;
    time(&rawtime);
    struct tm * ptm;
    ptm = gmtime (&rawtime);
    
    int x1,x2,x3,x4;
    int Minuten = rawtime%(24*3600)/60;
    float fConsumption;
    float maxsoc;
    //    return 2;  // Zu testzwecken  dann 9 Minuten Netzladebetrieb
    /*
     if (Minuten%60<1)
     return 1;  else // Zu testzwecken erst eine Minute Entladen erlauben
     {
     if (Minuten%60<6)
     return 2;  // Zu testzwecken  dann 9 Minuten Netzladebetrieb
     }
     */
    
    {
        float offset;
        float SollSoc = 0;
        float ZielSoC = 95;
        float Verbrauch = 0;
// Verbrauch bis solarenÜberschuss??
        int ret = 0;
        if (wetter.size() > h+1)
            ret = suchenSolar(wetter,h+1, Verbrauch) - h -1;

        // Überprüfen ob entladen werden kann
        fSoC = fSoC - notstromreserve;
    // Wenn der verfügbare Speicher > dem Verbrauch bis Überschuss ist
        if (Verbrauch*0.8<reserve&&ret<10&&ret>=0)
            reserve = Verbrauch*0.8;
//        if (ret == 0) reserve = 0;
        if (reserve < 0) reserve = 0;
        fSoC = fSoC - reserve;
        float minsoc = 0;
        fConsumption = fHighprice(w,wetter,h,w.size()-1,w[h].pp,minsoc,maxpos,maxsoc);
//        if (maxpos < w.size()-1)
//            fConsumption = fHighprice(w,wetter,h,maxpos,w[h].pp,fSoC+reserve,maxpos,maxsoc);
// wieviel Einträge sind höher mit dem SoC in Consumption abgleichen
        float faval = fSoC - fConsumption;
/*        if (fConsumption<minsoc&&minsoc>0&&faval>-0.01)
        {
//            if (fConsumption > ZielSoC-reserve) fConsumption = ZielSoC-reserve;
            faval = fSoC -minsoc;
        }
*/        if (faval>0&&faval+anforderung<0)
            anforderung = faval*-1;
        else
            faval = faval + anforderung;
//        if (faval >=-0.01||maxsoc+fSoC-minsoc>=100)
        if (faval >=0) // x1 Anzahl der Einträge mit höheren Preisen
        {
                fSoC = fSoC + anforderung + reserve + notstromreserve;
                return 1;
        } 

/*        else
        {
                fSoC = fSoC + faval;
                anforderung = anforderung + faval;
        }
*/
        // suche über den gesamten Bereich
        if  (SucheDiff(w,h, aufschlag,Diff)) // es wird gandenlos bis zum nächsten low entladen
        do
        {
            fConsumption = fHighprice(w,wetter,h,l1,w[h].pp,minsoc,maxpos,maxsoc);  // nächster Nachladepunkt überprüfen
//            if (float(fSoC-fConsumption+reserve) > 0) // x1 Anzahl der Einträge mit höheren Preisen
            if (fConsumption==0||fConsumption-anforderung<fSoC) // x1 Anzahl der Einträge mit höheren Preisen
//                if ((w[h].pp>w[l1].pp*aufschlag+Diff)&&fConsumption<fSoC)
                if ((w[h].pp>(w[l1].pp)*aufschlag+Diff))
                    // Es könnte nachgeladen werden
                {
                    fSoC = fSoC + anforderung + reserve + notstromreserve;
                    if (fSoC < 0)
                        fSoC = 0;
                    return 1;
                }
            if (h1>l1)
            {if (not (SucheDiff(w,h1, aufschlag,Diff))) break;} // suche low nach einem high
            else
            {if (not (SucheDiff(w,l1, aufschlag,Diff))) break;} // suche low nach einem high
        }
        while (l1 < w.size());
        
        if (SucheDiff(w,h, aufschlag,Diff))
        {
            if (h1>l1)       // erst kommt ein low dann ein high, überprüfen ob zum low geladen werden soll
            {
                int lw = l1;
                do
                    if (not (SucheDiff(w,h1, aufschlag,Diff))) break; // suche low nach einem high
                while (h1 > l1);
                // suche das nächste low
                // suchen nach dem low before next high das low muss niedriger als das akutelle sein
                int hi = h1;
                while ((l1 > h1)||(w[0].pp<w[l1].pp)) {
                    if (h1>l1)
                    {if (not (SucheDiff(w,h1, aufschlag,Diff))) {
                        l1 = w.size()-1;
                        break;}} // suche low nach einem high
                    else
                    {if (not (SucheDiff(w,l1, aufschlag,Diff))) {
                        l1 = w.size()-1;
                        break;}} // suche low nach einem high
                }
                // Überprüfen ob Geladen werden kann
                x3 = w.size()-1;
                x1 = Lowprice(w,h, hi, w[h].pp);   // bis zum high suchen
                x2 = Lowprice(w,h, w.size()-1, w[h].pp);   // bis zum high suchen
                
                SollSoc = fHighprice(w,wetter,h,l1,(w[h].pp)*aufschlag+Diff,minsoc,maxpos,maxsoc);  // Preisspitzen, es muss mindestens eine vorliegen
                float SollSoc2 = 0;
                SollSoc2 = fHighprice(w,wetter,h,x3,(w[h].pp)*aufschlag+Diff,minsoc,maxpos,maxsoc);
                SollSoc2 = fHighprice(w,wetter,h,maxpos,(w[h].pp)*aufschlag+Diff,minsoc,maxpos,maxsoc);
                if (SollSoc>SollSoc2)
                {
                    if (SollSoc > ZielSoC) SollSoc = ZielSoC;
                    if (SollSoc>maxsoc)
                    {
                        SollSoc2 = SollSoc2 + SollSoc - maxsoc;
//                        SollSoc2 = minsoc + SollSoc2;
                    }
                }
                if (SollSoc2 < fSoC)
                {
                    fSoC = fSoC + reserve + notstromreserve;
                    if (anforderung>0)
                        fSoC = fSoC + anforderung;

                    return 0;
                }
                // Nachladen aus dem Netz erforderlich, wenn für die Abdeckung der Preisspitzen
                // Stunden mit hohen Börsenpreisen, Nachladen wenn SoC zu niedrig
                if (x2 == x1) // keine weiteren Lows
                    //                    SollSoc = SollSoc2 +fSoC;
                    if (SollSoc2>SollSoc)
                        SollSoc = SollSoc2;
                if (SollSoc > ZielSoC-reserve) SollSoc = ZielSoC-reserve;
                if ((SollSoc>fSoC+0.5)&&        // Damit es kein Überschwingen gibt, wird 1% weniger als das Soll geladen
                    ((x1==0)||((SollSoc-fSoC)>x1*ladeleistung)))      // Stunden mit hohen Börsenpreisen, Nachladen wenn SoC zu niedrig
                {
                    
                    if ((SollSoc-fSoC)>ladeleistung)
                        fSoC = fSoC + ladeleistung;
                    else
                        fSoC = SollSoc;
                    //                    if (fSoC > SollSoc-0.5)
                    //                        (fSoC = SollSoc-0.5);
                    fSoC = fSoC + reserve + notstromreserve;
                    return 2;
                }
                else
                    //                if ((SollSoc)>fSoC-1)
                {
                    fSoC = fSoC + reserve + notstromreserve;
                    if (anforderung>0)
                        fSoC = fSoC + anforderung;
                    return 0;
                } // Nicht entladen da die Preisdifferenz zur Spitze noch zu groß
            }
        }
        //        if (taglaenge > Wintertag) // tagsüber noch hochpreise es werden mind. die 2h nach sonnaufgang geprüft
        {
            fConsumption = fHighprice(w,wetter,h,w.size()-1,w[h].pp,minsoc,maxpos,maxsoc);  // folgender Preis höher, dann anteilig berücksichtigen
            
            
//            if (float(fSoC-fConsumption+reserve) > 0) // x1 Anzahl der Einträge mit höheren Preisen
            if (float(fSoC-fConsumption+anforderung) >=0) // x1 Anzahl der Einträge mit höheren Preisen
            {
                fSoC = fSoC + reserve + notstromreserve + anforderung;
                return 1;
            }
        }
        fSoC = fSoC + reserve + notstromreserve;
        if (anforderung>0)
            fSoC = fSoC + anforderung;
        
        return 0;  // kein Ergebniss gefunden
        
        
    }
}

// Assembly:
subq $0x178, %rsp            # imm = 0x178
movq %rdi, 0x168(%rsp)
movq %rsi, 0x160(%rsp)
movl %edx, 0x15c(%rsp)
movq %rcx, 0x150(%rsp)
movq %r8, 0x148(%rsp)
movss %xmm0, 0x144(%rsp)
movss %xmm1, 0x140(%rsp)
movss %xmm2, 0x13c(%rsp)
movss %xmm3, 0x138(%rsp)
movss %xmm4, 0x134(%rsp)
leaq 0x128(%rsp), %rdi
callq 0x2280
leaq 0x128(%rsp), %rdi
callq 0x2250
movq %rax, 0x120(%rsp)
movq 0x128(%rsp), %rax
movl $0x15180, %ecx          # imm = 0x15180
cqto
idivq %rcx
movq %rdx, %rax
movl $0x3c, %ecx
cqto
idivq %rcx
movl %eax, 0x10c(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0xfc(%rsp)
movss 0x1b721(%rip), %xmm0    # 0x60088
movss %xmm0, 0xf8(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0xf4(%rsp)
movl $0x0, 0xf0(%rsp)
movq 0x160(%rsp), %rdi
callq 0x1cc80
movl 0x15c(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jbe 0x449d6
movq 0x160(%rsp), %rdi
movl 0x15c(%rsp), %esi
addl $0x1, %esi
leaq 0xf4(%rsp), %rdx
callq 0x445b0
subl 0x15c(%rsp), %eax
subl $0x1, %eax
movl %eax, 0xf0(%rsp)
movq 0x150(%rsp), %rax
movss (%rax), %xmm0
subss 0x138(%rsp), %xmm0
movq 0x150(%rsp), %rax
movss %xmm0, (%rax)
movss 0xf4(%rsp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x1b7a4(%rip), %xmm0    # 0x601b0
mulsd %xmm0, %xmm1
movss 0x13c(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x44a5d
cmpl $0xa, 0xf0(%rsp)
jge 0x44a5d
cmpl $0x0, 0xf0(%rsp)
jl 0x44a5d
movss 0xf4(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x1b764(%rip), %xmm1    # 0x601b0
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x13c(%rsp)
xorps %xmm0, %xmm0
ucomiss 0x13c(%rsp), %xmm0
jbe 0x44a76
xorps %xmm0, %xmm0
movss %xmm0, 0x13c(%rsp)
movq 0x150(%rsp), %rax
movss (%rax), %xmm0
subss 0x13c(%rsp), %xmm0
movq 0x150(%rsp), %rax
movss %xmm0, (%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0xec(%rsp)
movq 0x168(%rsp), %rax
movq %rax, 0xc0(%rsp)
movq 0x160(%rsp), %rax
movq %rax, 0xc8(%rsp)
movl 0x15c(%rsp), %eax
movl %eax, 0xd4(%rsp)
movq 0x168(%rsp), %rdi
callq 0x1ce80
subq $0x1, %rax
movl %eax, 0xd8(%rsp)
movq 0x168(%rsp), %rdi
movslq 0x15c(%rsp), %rsi
callq 0x1ce20
movq 0xc0(%rsp), %rdi
movq 0xc8(%rsp), %rsi
movl 0xd4(%rsp), %edx
movl 0xd8(%rsp), %ecx
movss 0x8(%rax), %xmm0
leaq 0xec(%rsp), %r8
leaq 0x35620(%rip), %r9      # 0x7a150
leaq 0x104(%rsp), %rax
movq %rax, (%rsp)
callq 0x43b90
movss %xmm0, 0x108(%rsp)
movq 0x150(%rsp), %rax
movss (%rax), %xmm0
subss 0x108(%rsp), %xmm0
movss %xmm0, 0xe8(%rsp)
movss 0xe8(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x44bb5
movss 0xe8(%rsp), %xmm1
movq 0x148(%rsp), %rax
addss (%rax), %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm1, %xmm0
jbe 0x44bb5
movss 0x1b46a(%rip), %xmm0    # 0x60008
mulss 0xe8(%rsp), %xmm0
movq 0x148(%rsp), %rax
movss %xmm0, (%rax)
jmp 0x44bd3
movss 0xe8(%rsp), %xmm0
movq 0x148(%rsp), %rax
addss (%rax), %xmm0
movss %xmm0, 0xe8(%rsp)
movss 0xe8(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x44c2a
movq 0x150(%rsp), %rax
movss (%rax), %xmm0
movq 0x148(%rsp), %rax
addss (%rax), %xmm0
addss 0x13c(%rsp), %xmm0
addss 0x138(%rsp), %xmm0
movq 0x150(%rsp), %rax
movss %xmm0, (%rax)
movl $0x1, 0x174(%rsp)
jmp 0x45753
movq 0x168(%rsp), %rdi
movl 0x15c(%rsp), %esi
movss 0x140(%rsp), %xmm0
movss 0x144(%rsp), %xmm1
callq 0x44230
testb $0x1, %al
jne 0x44c59
jmp 0x44e9d
jmp 0x44c5b
movq 0x168(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq 0x160(%rsp), %rax
movq %rax, 0xb0(%rsp)
movl 0x15c(%rsp), %eax
movl %eax, 0xb8(%rsp)
movl 0x35515(%rip), %eax     # 0x7a1a4
movl %eax, 0xbc(%rsp)
movq 0x168(%rsp), %rdi
movslq 0x15c(%rsp), %rsi
callq 0x1ce20
movq 0xa8(%rsp), %rdi
movq 0xb0(%rsp), %rsi
movl 0xb8(%rsp), %edx
movl 0xbc(%rsp), %ecx
movss 0x8(%rax), %xmm0
leaq 0xec(%rsp), %r8
leaq 0x35473(%rip), %r9      # 0x7a150
leaq 0x104(%rsp), %rax
movq %rax, (%rsp)
callq 0x43b90
movss %xmm0, 0x108(%rsp)
movss 0x108(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x44d0c
jp 0x44d0c
jmp 0x44d36
movss 0x108(%rsp), %xmm1
movq 0x148(%rsp), %rax
subss (%rax), %xmm1
movq 0x150(%rsp), %rax
movss (%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x44e01
movq 0x168(%rsp), %rdi
movslq 0x15c(%rsp), %rsi
callq 0x1ce20
movss 0x8(%rax), %xmm0
movss %xmm0, 0xa4(%rsp)
movq 0x168(%rsp), %rdi
movslq 0x3543c(%rip), %rsi     # 0x7a1a4
callq 0x1ce20
movss 0xa4(%rsp), %xmm0
movss 0x8(%rax), %xmm1
movss 0x140(%rsp), %xmm3
movss 0x144(%rsp), %xmm2
mulss %xmm3, %xmm1
addss %xmm2, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x44dff
movq 0x150(%rsp), %rax
movss (%rax), %xmm0
movq 0x148(%rsp), %rax
addss (%rax), %xmm0
addss 0x13c(%rsp), %xmm0
addss 0x138(%rsp), %xmm0
movq 0x150(%rsp), %rax
movss %xmm0, (%rax)
movq 0x150(%rsp), %rax
xorps %xmm0, %xmm0
ucomiss (%rax), %xmm0
jbe 0x44def
movq 0x150(%rsp), %rax
xorps %xmm0, %xmm0
movss %xmm0, (%rax)
movl $0x1, 0x174(%rsp)
jmp 0x45753
jmp 0x44e01
movl 0x35399(%rip), %eax     # 0x7a1a0
cmpl 0x35397(%rip), %eax     # 0x7a1a4
jle 0x44e3c
movq 0x168(%rsp), %rdi
movl 0x35383(%rip), %esi     # 0x7a1a0
movss 0x140(%rsp), %xmm0
movss 0x144(%rsp), %xmm1
callq 0x44230
testb $0x1, %al
jne 0x44e3a
jmp 0x44e9b
jmp 0x44e69
movq 0x168(%rsp), %rdi
movl 0x3535a(%rip), %esi     # 0x7a1a4
movss 0x140(%rsp), %xmm0
movss 0x144(%rsp), %xmm1
callq 0x44230
testb $0x1, %al
jne 0x44e67
jmp 0x44e9b
jmp 0x44e69
jmp 0x44e6b
movslq 0x35332(%rip), %rax     # 0x7a1a4
movq %rax, 0x98(%rsp)
movq 0x168(%rsp), %rdi
callq 0x1ce80
movq %rax, %rcx
movq 0x98(%rsp), %rax
cmpq %rcx, %rax
jb 0x44c5b
jmp 0x44e9d
movq 0x168(%rsp), %rdi
movl 0x15c(%rsp), %esi
movss 0x140(%rsp), %xmm0
movss 0x144(%rsp), %xmm1
callq 0x44230
testb $0x1, %al
jne 0x44ecc
jmp 0x455eb
movl 0x352ce(%rip), %eax     # 0x7a1a0
cmpl 0x352cc(%rip), %eax     # 0x7a1a4
jle 0x455e9
movl 0x352c0(%rip), %eax     # 0x7a1a4
movl %eax, 0xe4(%rsp)
movq 0x168(%rsp), %rdi
movl 0x352a7(%rip), %esi     # 0x7a1a0
movss 0x140(%rsp), %xmm0
movss 0x144(%rsp), %xmm1
callq 0x44230
testb $0x1, %al
jne 0x44f16
jmp 0x44f26
jmp 0x44f18
movl 0x35282(%rip), %eax     # 0x7a1a0
cmpl 0x35280(%rip), %eax     # 0x7a1a4
jg 0x44eeb
movl 0x35274(%rip), %eax     # 0x7a1a0
movl %eax, 0xe0(%rsp)
movl 0x3526b(%rip), %ecx     # 0x7a1a4
movb $0x1, %al
cmpl 0x3525f(%rip), %ecx     # 0x7a1a0
movb %al, 0x97(%rsp)
jg 0x44f98
movq 0x168(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1ce20
movss 0x8(%rax), %xmm0
movss %xmm0, 0x90(%rsp)
movq 0x168(%rsp), %rdi
movslq 0x3522c(%rip), %rsi     # 0x7a1a4
callq 0x1ce20
movss 0x90(%rsp), %xmm1
movss 0x8(%rax), %xmm0
ucomiss %xmm1, %xmm0
seta %al
movb %al, 0x97(%rsp)
movb 0x97(%rsp), %al
testb $0x1, %al
jne 0x44fa8
jmp 0x45043
movl 0x351f2(%rip), %eax     # 0x7a1a0
cmpl 0x351f0(%rip), %eax     # 0x7a1a4
jle 0x44ffa
movq 0x168(%rsp), %rdi
movl 0x351dc(%rip), %esi     # 0x7a1a0
movss 0x140(%rsp), %xmm0
movss 0x144(%rsp), %xmm1
callq 0x44230
testb $0x1, %al
jne 0x44ff8
movq 0x168(%rsp), %rdi
callq 0x1ce80
subq $0x1, %rax
movl %eax, 0x351ae(%rip)     # 0x7a1a4
jmp 0x45043
jmp 0x4503e
movq 0x168(%rsp), %rdi
movl 0x3519c(%rip), %esi     # 0x7a1a4
movss 0x140(%rsp), %xmm0
movss 0x144(%rsp), %xmm1
callq 0x44230
testb $0x1, %al
jne 0x4503c
movq 0x168(%rsp), %rdi
callq 0x1ce80
subq $0x1, %rax
movl %eax, 0x3516a(%rip)     # 0x7a1a4
jmp 0x45043
jmp 0x4503e
jmp 0x44f33
movq 0x168(%rsp), %rdi
callq 0x1ce80
subq $0x1, %rax
movl %eax, 0x114(%rsp)
movq 0x168(%rsp), %rax
movq %rax, 0x28(%rsp)
movl 0x15c(%rsp), %eax
movl %eax, 0x30(%rsp)
movl 0xe0(%rsp), %eax
movl %eax, 0x34(%rsp)
movq 0x168(%rsp), %rdi
movslq 0x15c(%rsp), %rsi
callq 0x1ce20
movq 0x28(%rsp), %rdi
movl 0x30(%rsp), %esi
movl 0x34(%rsp), %edx
movss 0x8(%rax), %xmm0
callq 0x43f20
movl %eax, 0x11c(%rsp)
movq 0x168(%rsp), %rax
movq %rax, 0x38(%rsp)
movl 0x15c(%rsp), %eax
movl %eax, 0x40(%rsp)
movq 0x168(%rsp), %rdi
callq 0x1ce80
subq $0x1, %rax
movl %eax, 0x44(%rsp)
movq 0x168(%rsp), %rdi
movslq 0x15c(%rsp), %rsi
callq 0x1ce20
movq 0x38(%rsp), %rdi
movl 0x40(%rsp), %esi
movl 0x44(%rsp), %edx
movss 0x8(%rax), %xmm0
callq 0x43f20
movl %eax, 0x118(%rsp)
movq 0x168(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x160(%rsp), %rax
movq %rax, 0x50(%rsp)
movl 0x15c(%rsp), %eax
movl %eax, 0x58(%rsp)
movl 0x35068(%rip), %eax     # 0x7a1a4
movl %eax, 0x5c(%rsp)
movq 0x168(%rsp), %rdi
movslq 0x15c(%rsp), %rsi
callq 0x1ce20
movq 0x48(%rsp), %rdi
movq 0x50(%rsp), %rsi
movl 0x58(%rsp), %edx
movl 0x5c(%rsp), %ecx
movss 0x8(%rax), %xmm0
movss 0x140(%rsp), %xmm2
movss 0x144(%rsp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
leaq 0xec(%rsp), %r8
leaq 0x34fbb(%rip), %r9      # 0x7a150
leaq 0x104(%rsp), %rax
movq %rax, (%rsp)
callq 0x43b90
movss %xmm0, 0xfc(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0xdc(%rsp)
movq 0x168(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x160(%rsp), %rax
movq %rax, 0x68(%rsp)
movl 0x15c(%rsp), %eax
movl %eax, 0x70(%rsp)
movl 0x114(%rsp), %eax
movl %eax, 0x74(%rsp)
movq 0x168(%rsp), %rdi
movslq 0x15c(%rsp), %rsi
callq 0x1ce20
movq 0x60(%rsp), %rdi
movq 0x68(%rsp), %rsi
movl 0x70(%rsp), %edx
movl 0x74(%rsp), %ecx
movss 0x8(%rax), %xmm0
movss 0x140(%rsp), %xmm2
movss 0x144(%rsp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
leaq 0xec(%rsp), %r8
leaq 0x34f10(%rip), %r9      # 0x7a150
leaq 0x104(%rsp), %rax
movq %rax, (%rsp)
callq 0x43b90
movss %xmm0, 0xdc(%rsp)
movq 0x168(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x160(%rsp), %rax
movq %rax, 0x80(%rsp)
movl 0x15c(%rsp), %eax
movl %eax, 0x88(%rsp)
movl 0x34ec5(%rip), %eax     # 0x7a150
movl %eax, 0x8c(%rsp)
movq 0x168(%rsp), %rdi
movslq 0x15c(%rsp), %rsi
callq 0x1ce20
movq 0x78(%rsp), %rdi
movq 0x80(%rsp), %rsi
movl 0x88(%rsp), %edx
movl 0x8c(%rsp), %ecx
movss 0x8(%rax), %xmm0
movss 0x140(%rsp), %xmm2
movss 0x144(%rsp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
leaq 0xec(%rsp), %r8
leaq 0x34e60(%rip), %r9      # 0x7a150
leaq 0x104(%rsp), %rax
movq %rax, (%rsp)
callq 0x43b90
movss %xmm0, 0xdc(%rsp)
movss 0xfc(%rsp), %xmm0
ucomiss 0xdc(%rsp), %xmm0
jbe 0x4537b
movss 0xfc(%rsp), %xmm0
ucomiss 0xf8(%rsp), %xmm0
jbe 0x45342
movss 0xf8(%rsp), %xmm0
movss %xmm0, 0xfc(%rsp)
movss 0xfc(%rsp), %xmm0
ucomiss 0x104(%rsp), %xmm0
jbe 0x45379
movss 0xdc(%rsp), %xmm0
addss 0xfc(%rsp), %xmm0
subss 0x104(%rsp), %xmm0
movss %xmm0, 0xdc(%rsp)
jmp 0x4537b
movss 0xdc(%rsp), %xmm1
movq 0x150(%rsp), %rax
movss (%rax), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x45407
movq 0x150(%rsp), %rax
movss (%rax), %xmm0
addss 0x13c(%rsp), %xmm0
addss 0x138(%rsp), %xmm0
movq 0x150(%rsp), %rax
movss %xmm0, (%rax)
movq 0x148(%rsp), %rax
movss (%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x453f7
movq 0x150(%rsp), %rax
movss (%rax), %xmm0
movq 0x148(%rsp), %rax
addss (%rax), %xmm0
movq 0x150(%rsp), %rax
movss %xmm0, (%rax)
movl $0x0, 0x174(%rsp)
jmp 0x45753
movl 0x118(%rsp), %eax
cmpl 0x11c(%rsp), %eax
jne 0x4543e
movss 0xdc(%rsp), %xmm0
ucomiss 0xfc(%rsp), %xmm0
jbe 0x4543c
movss 0xdc(%rsp), %xmm0
movss %xmm0, 0xfc(%rsp)
jmp 0x4543e
movss 0xfc(%rsp), %xmm0
movss 0xf8(%rsp), %xmm1
subss 0x13c(%rsp), %xmm1
ucomiss %xmm1, %xmm0
jbe 0x45479
movss 0xf8(%rsp), %xmm0
subss 0x13c(%rsp), %xmm0
movss %xmm0, 0xfc(%rsp)
movss 0xfc(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
movq 0x150(%rsp), %rax
movss (%rax), %xmm1
cvtss2sd %xmm1, %xmm1
movsd 0x1acea(%rip), %xmm2    # 0x60188
addsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x45577
cmpl $0x0, 0x11c(%rsp)
je 0x454e6
movss 0xfc(%rsp), %xmm0
movq 0x150(%rsp), %rax
subss (%rax), %xmm0
cvtsi2ssl 0x11c(%rsp), %xmm1
mulss 0x134(%rsp), %xmm1
ucomiss %xmm1, %xmm0
jbe 0x45577
movss 0xfc(%rsp), %xmm0
movq 0x150(%rsp), %rax
subss (%rax), %xmm0
ucomiss 0x134(%rsp), %xmm0
jbe 0x45528
movq 0x150(%rsp), %rax
movss (%rax), %xmm0
addss 0x134(%rsp), %xmm0
movq 0x150(%rsp), %rax
movss %xmm0, (%rax)
jmp 0x4553d
movss 0xfc(%rsp), %xmm0
movq 0x150(%rsp), %rax
movss %xmm0, (%rax)
movq 0x150(%rsp), %rax
movss (%rax), %xmm0
addss 0x13c(%rsp), %xmm0
addss 0x138(%rsp), %xmm0
movq 0x150(%rsp), %rax
movss %xmm0, (%rax)
movl $0x2, 0x174(%rsp)
jmp 0x45753
movq 0x150(%rsp), %rax
movss (%rax), %xmm0
addss 0x13c(%rsp), %xmm0
addss 0x138(%rsp), %xmm0
movq 0x150(%rsp), %rax
movss %xmm0, (%rax)
movq 0x148(%rsp), %rax
movss (%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x455d9
movq 0x150(%rsp), %rax
movss (%rax), %xmm0
movq 0x148(%rsp), %rax
addss (%rax), %xmm0
movq 0x150(%rsp), %rax
movss %xmm0, (%rax)
movl $0x0, 0x174(%rsp)
jmp 0x45753
jmp 0x455eb
movq 0x168(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x160(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x15c(%rsp), %eax
movl %eax, 0x20(%rsp)
movq 0x168(%rsp), %rdi
callq 0x1ce80
subq $0x1, %rax
movl %eax, 0x24(%rsp)
movq 0x168(%rsp), %rdi
movslq 0x15c(%rsp), %rsi
callq 0x1ce20
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x20(%rsp), %edx
movl 0x24(%rsp), %ecx
movss 0x8(%rax), %xmm0
leaq 0xec(%rsp), %r8
leaq 0x34af0(%rip), %r9      # 0x7a150
leaq 0x104(%rsp), %rax
movq %rax, (%rsp)
callq 0x43b90
movss %xmm0, 0x108(%rsp)
movq 0x150(%rsp), %rax
movss (%rax), %xmm0
subss 0x108(%rsp), %xmm0
movq 0x148(%rsp), %rax
addss (%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x456e6
movq 0x150(%rsp), %rax
movss (%rax), %xmm0
addss 0x13c(%rsp), %xmm0
addss 0x138(%rsp), %xmm0
movq 0x148(%rsp), %rax
addss (%rax), %xmm0
movq 0x150(%rsp), %rax
movss %xmm0, (%rax)
movl $0x1, 0x174(%rsp)
jmp 0x45753
movq 0x150(%rsp), %rax
movss (%rax), %xmm0
addss 0x13c(%rsp), %xmm0
addss 0x138(%rsp), %xmm0
movq 0x150(%rsp), %rax
movss %xmm0, (%rax)
movq 0x148(%rsp), %rax
movss (%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x45748
movq 0x150(%rsp), %rax
movss (%rax), %xmm0
movq 0x148(%rsp), %rax
addss (%rax), %xmm0
movq 0x150(%rsp), %rax
movss %xmm0, (%rax)
movl $0x0, 0x174(%rsp)
movl 0x174(%rsp), %eax
addq $0x178, %rsp            # imm = 0x178
retq
nopw %cs:(%rax,%rax)