// File: /workspace/github_cpp_makefile_star2_O3/bummelbaerchen[P]e3dc/RscpExampleMain.cpp
// Function: LoadDataProcess(SRscpFrameBuffer*)
int LoadDataProcess(SRscpFrameBuffer * frameBuffer) {
//    const int cLadezeitende1 = 12.5*3600;  // Sommerzeit -2h da GMT = MEZ - 2
    printf("\n");
    tm *ts;
    ts = gmtime(&tE3DC);
    if (tE3DC % (24*3600)<t) {fSavedyesderday=fSavedtoday; fSavedtoday=0;}
    t = tE3DC % (24*3600);
    float fLadeende = e3dc_config.ladeende;
    int cLadezeitende1 = (e3dc_config.winterminimum+(e3dc_config.sommermaximum-e3dc_config.winterminimum)/2)*3600;
    int cLadezeitende2 = (e3dc_config.winterminimum+(e3dc_config.sommerladeende-e3dc_config.winterminimum)/2)*3600;

    time_t tLadezeitende,tLadezeitende2;  // dynamische Ladezeitberechnung aus dem Cosinus des lfd Tages. 23 Dez = Minimum, 23 Juni = Maximum
    int32_t tZeitgleichung;
    tLadezeitende = cLadezeitende1+cos((ts->tm_yday+9)*2*3.14/365)*-((e3dc_config.sommermaximum-e3dc_config.winterminimum)/2)*3600;
    tLadezeitende2 = cLadezeitende2+cos((ts->tm_yday+9)*2*3.14/365)*-((e3dc_config.sommerladeende-e3dc_config.winterminimum)/2)*3600;

    
//    float fht = e3dc_config.ht * cos((ts->tm_yday+9)*2*3.14/365);
    float fht = e3dc_config.htsockel + (e3dc_config.ht-e3dc_config.htsockel) * cos((ts->tm_yday+9)*2*3.14/365);

    // HT Endeladeleistung freigeben
    // Mo-Fr wird während der Hochtarif der Speicher zwischen hton und htoff endladen
    // Samstag und Sonntag nur wenn htsat und htsun auf true gesetzt sind.
    // Damit kann gleich eine intelligente Notstromreserve realisiert werden.
    // Die in ht eingestellte Reserve wird zwischen diesem Wert und 0% zur Tag-Nachtgleiche gesetzt
    // Die Notstromreserve im System ist davon unberührt
    if (iLMStatus == 1) {
    
    if ((((ts->tm_wday>0&&ts->tm_wday<6) ||
          ((ts->tm_wday==0)&&e3dc_config.htsun)
          ||
          ((ts->tm_wday==6)&&e3dc_config.htsat)          )&&
            (e3dc_config.hton < t && e3dc_config.htoff > t ))
        ||(fht<fBatt_SOC)
        ||(iNotstrom==1)  //Notstrom
        ||(iNotstrom==4)  //Inselbetrieb
        ){
            // ENdladen einschalten)
        if (iDischarge < e3dc_config.maximumLadeleistung) {
            
        Control_MAX_DISCHARGE(frameBuffer,e3dc_config.maximumLadeleistung);
        iBattPowerStatus = 0;
        iLMStatus = 5;
        }

    } else {
            // Endladen ausschalten
        if (iDischarge != 0)
            // Ausschalten nur wenn nicht im Notstrom/Inselbetrieb
            { Control_MAX_DISCHARGE(frameBuffer,0);
            iBattPowerStatus = 0;
            iLMStatus = 5;
;}
    }}
    
    // HT Endeladeleistung freigeben  ENDE
    
    
    
    // Berechnung freie Ladekapazität bis 90% bzw. Ladeende
    
    tZeitgleichung = (-0.171*sin(0.0337 * ts->tm_yday + 0.465) - 0.1299*sin(0.01787 * ts->tm_yday - 0.168))*3600;
    tLadezeitende = tLadezeitende - tZeitgleichung;

// Überwachungszeitraum für das Überschussladen übschritten und Speicher > Ladeende
// Dann wird langsam bis Abends der Speicher bis 93% geladen und spätestens dann zum Vollladen freigegeben.
    if ((t >= tLadezeitende)&&(fBatt_SOC>=fLadeende)) {
        tLadezeitende = tLadezeitende2 - tZeitgleichung;
        fLadeende = 93;
    };
    
    if ((t < (tLadezeitende))&&(fBatt_SOC<fLadeende))
    {
      if ((fBatt_SOC!=fBatt_SOC_alt)||(t-tLadezeit_alt>300)||(iFc == 0))
      {
        fBatt_SOC_alt=fBatt_SOC; // bei Änderung SOC neu berechnen
        tLadezeit_alt=t; // alle 300sec Berechnen
        iFc = (fLadeende - fBatt_SOC)*e3dc_config.speichergroesse*10*3600;
        iFc = iFc / (tLadezeitende-t);
        iMinLade = iFc;
//        iFc = (iFc-900)*5;
          iFc = (iFc-e3dc_config.untererLadekorridor);
          iFc = iFc*(e3dc_config.maximumLadeleistung/(e3dc_config.obererLadekorridor-e3dc_config.untererLadekorridor));
          if (iFc > e3dc_config.maximumLadeleistung) iFc = e3dc_config.maximumLadeleistung;
        if (iFc < e3dc_config.minimumLadeleistung) iFc = 0;
      }
        printf("MinLoad: %u %u ",iMinLade, iFc);
    } else
        if (t > tLadezeitende) iFc = e3dc_config.maximumLadeleistung;
           else iFc = 0;
//  Laden auf 100% nach 15:30
    
    printf("GMT %ld:%ld ZG %d ",tLadezeitende/3600,tLadezeitende%3600/60,tZeitgleichung);
    

    
    
    printf("E3DC Zeit: %s", asctime(ts));


    
    int iPower = 0;
    if (iLMStatus == 0){
        iLMStatus = 5;
        tLadezeit_alt = 0;
//        iBattLoad = e3dc_config.maximumLadeleistung;
        iBattLoad = 100;
//        fAvBatterie = e3dc_config.untererLadekorridor;

        
//        ControlLoadData2(frameBuffer,iBattLoad);
    }
    if (iAvBatt_Count < 120) iAvBatt_Count++;
    fAvBatterie = fAvBatterie*(iAvBatt_Count-1)/iAvBatt_Count;
    fAvBatterie = fAvBatterie + (float(iPower_Bat)/iAvBatt_Count);

    // Überschussleistung=iPower ermitteln

    iPower = (-iPower_Bat + int32_t(fPower_Grid) - e3dc_config.einspeiselimit*-1000)*-1;
    
    // die PV-leistung kann die WR-Leistung überschreiten. Überschuss in den Speicher laden;
    
    if ((iPower_PV_E3DC - e3dc_config.wrleistung) > iPower)
        iPower = (iPower_PV_E3DC - e3dc_config.wrleistung);
    
    if (iPower < 50) iPower = 0;
    else
    if (iPower > e3dc_config.maximumLadeleistung) iPower = e3dc_config.maximumLadeleistung;
    else
    if (iPower <100) iPower = 100;
    
    fSavedtoday = fSavedtoday + iPower;

        
        if (((fBatt_SOC > e3dc_config.ladeschwelle)&&(t<tLadezeitende))||(fBatt_SOC > e3dc_config.ladeende))
        {
            
        
            if (iFc > iPower)
            {   iPower = iFc;
                if (iPower > fAvBatterie) iPower = iPower + pow((iPower-fAvBatterie),2)/20;
                if (iPower > e3dc_config.maximumLadeleistung) iPower = e3dc_config.maximumLadeleistung;
                
            }
            } else
//            if (fBatt_SOC < cLadeende) iPower = 3000;
//            else iPower = 0;
              iPower = e3dc_config.maximumLadeleistung;
        
        if (e3dc_config.wallbox&&(WBchar6[1]==5))     // Wenn Wallbox vorhanden und Laden ausgeschaltet
            iPower = e3dc_config.maximumLadeleistung; // mit voller Leistung E3DC Speicher laden
        
//        if (((abs( int(iPower - iPower_Bat)) > 30)||(t%3600==0))&&(iLMStatus == 1))
//            if (((abs( int(iPower - iBattLoad)) > 30)||(abs(t-tE3DC_alt)>3600*3))&&(iLMStatus == 1))
    if (iLMStatus == 1)
    {
        
            {
            if (iBattLoad > (iPower_Bat-iDiffLadeleistung))
            iDiffLadeleistung = iBattLoad-iPower_Bat+iDiffLadeleistung;
            if ((iDiffLadeleistung < 0 )||(iBattLoad<=100)) iDiffLadeleistung = 0;
            if (iDiffLadeleistung > 100 )iDiffLadeleistung = 100; //Maximal 100W vorhalten
            if ((iPower+iDiffLadeleistung) > e3dc_config.maximumLadeleistung) iDiffLadeleistung = 0;
/*            if (iLMStatus == 1) {
                iBattLoad = iPower;
                tE3DC_alt = t;
            ControlLoadData2(frameBuffer,(iBattLoad+iDiffLadeleistung));
            iLMStatus = 7;
            }
*/
// Steuerung direkt über vorgabe der Batterieladeleistung
// -iPower_Bat + int32_t(fPower_Grid)
                if (iLMStatus == 1) {
                 iBattLoad = iPower;
                 tE3DC_alt = t;
//                    if (iPower_Bat > iPower)
// die aktuelle Batterieladeleistung liegt über der angeforderten Grenze, einbremsen
                        //                 ControlLoadData(frameBuffer,(iBattLoad+iDiffLadeleistung),3);
                        
                        if ((iPower < e3dc_config.maximumLadeleistung)&&(iPower<(iPower_Bat - int32_t(fPower_Grid))))
                        {
//                        if (iPower < iPower_Bat - int32_t(fPower_Grid))
//                            iPower = iPower_Bat - int32_t(fPower_Grid);
//                        if (iPower >0)
                        ControlLoadData(frameBuffer,(iPower+iDiffLadeleistung),3);
                        iLMStatus = 10;}
/*                    else if (fPower_Grid>50){
// Zurück in den Automatikmodus
                        ControlLoadData(frameBuffer,0,0);
                        iLMStatus = 7;}
*/
                }

          }
    }
    
    printf("AVBatt   %0.1f ",fAvBatterie);
    printf("Discharge %i ",iDischarge);
    printf("BattLoad %i ",iBattLoad);
    printf("iLMStatus %i ",iLMStatus);
    printf("Reserve %0.1f%%\n",fht);
   printf("Saved today %0.0004fkWh yesterday  %0.0004fkWh\n",(fSavedtoday/3600000),(fSavedyesderday/3600000));
    if (iLMStatus>1) iLMStatus--;
    if (e3dc_config.openWB)
    {
    char buffer [50];
    sprintf(buffer,"echo %0.1f > /var/www/html/openWB/ramdisk/wattbezug",fPower_Grid);
    system(buffer);

    sprintf(buffer,"echo %i > /var/www/html/openWB/ramdisk/pvwatt",iPower_PV*-1);
    system(buffer);

    sprintf(buffer,"echo %0.1f > /var/www/html/openWB/ramdisk/llaktuell",fPower_WB);
    system(buffer);

    sprintf(buffer,"echo %i > /var/www/html/openWB/ramdisk/speicherleistung",iPower_Bat);
    system(buffer);

    sprintf(buffer,"echo %i > /var/www/html/openWB/ramdisk/hausleistung",iPowerHome);
    system(buffer);
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
movl $0xa, %edi
callq 0x2210
leaq 0x14cc3(%rip), %rdi     # 0x177b0
callq 0x2150
movq %rax, %r14
movq 0x14cb4(%rip), %rcx     # 0x177b0
movabsq $0x1845c8a0ce512957, %rdx # imm = 0x1845C8A0CE512957
movq %rcx, %rax
imulq %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0xd, %rdx
addq %rax, %rdx
imulq $0x15180, %rdx, %rax    # imm = 0x15180
subq %rax, %rcx
cmpq 0x14c8d(%rip), %rcx     # 0x177b8
jge 0x2b47
movss 0x14c8b(%rip), %xmm0    # 0x177c0
movss %xmm0, 0x14c87(%rip)    # 0x177c4
movl $0x0, 0x14c79(%rip)     # 0x177c0
movq %rcx, 0x14c6a(%rip)     # 0x177b8
movzbl 0x14c16(%rip), %eax     # 0x1776b
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
movss %xmm0, 0x1c(%rsp)
movss 0x14c1e(%rip), %xmm0    # 0x17788
movss 0x14c1a(%rip), %xmm1    # 0x1778c
subss %xmm0, %xmm1
movss 0x10486(%rip), %xmm2    # 0x13004
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movss 0x1047a(%rip), %xmm3    # 0x13008
mulss %xmm3, %xmm1
movss 0x14bf6(%rip), %xmm4    # 0x17790
subss %xmm0, %xmm4
mulss %xmm2, %xmm4
addss %xmm0, %xmm4
mulss %xmm3, %xmm4
movaps %xmm4, (%rsp)
cvttps2dq %xmm1, %xmm0
cvtdq2pd %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movl 0x1c(%r14), %eax
leal 0x12(%rax,%rax), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
mulsd 0x104be(%rip), %xmm0    # 0x13090
divsd 0x104be(%rip), %xmm0    # 0x13098
callq 0x22c0
movss 0x14ba5(%rip), %xmm1    # 0x1778c
subss 0x14b99(%rip), %xmm1    # 0x17788
mulss 0x10415(%rip), %xmm1    # 0x1300c
cvtss2sd %xmm1, %xmm1
mulsd %xmm0, %xmm1
mulsd 0x10499(%rip), %xmm1    # 0x130a0
addsd 0x20(%rsp), %xmm1
cvttsd2si %xmm1, %r12
cvttps2dq (%rsp), %xmm0
cvtdq2pd %xmm0, %xmm0
movaps %xmm0, (%rsp)
movl 0x1c(%r14), %eax
leal 0x12(%rax,%rax), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
mulsd 0x1045a(%rip), %xmm0    # 0x13090
divsd 0x1045a(%rip), %xmm0    # 0x13098
callq 0x22c0
movss 0x14b45(%rip), %xmm1    # 0x17790
subss 0x14b35(%rip), %xmm1    # 0x17788
mulss 0x103b1(%rip), %xmm1    # 0x1300c
cvtss2sd %xmm1, %xmm1
mulsd %xmm0, %xmm1
mulsd 0x10435(%rip), %xmm1    # 0x130a0
addsd (%rsp), %xmm1
cvttsd2si %xmm1, %r15
movss 0x14b23(%rip), %xmm0    # 0x177a0
xorps %xmm1, %xmm1
cvtss2sd %xmm0, %xmm1
movsd %xmm1, (%rsp)
xorps %xmm1, %xmm1
cvtsi2ssl 0x14ad8(%rip), %xmm1 # 0x1776c
subss %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movl 0x1c(%r14), %eax
leal 0x12(%rax,%rax), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
mulsd 0x103d4(%rip), %xmm0    # 0x13090
divsd 0x103d4(%rip), %xmm0    # 0x13098
callq 0x22c0
mulsd 0x20(%rsp), %xmm0
addsd (%rsp), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rsp)
cmpl $0x1, 0x14ae4(%rip)     # 0x177c8
jne 0x2d81
movl 0x18(%r14), %eax
leal -0x1(%rax), %ecx
cmpl $0x5, %ecx
jae 0x2d1a
xorps %xmm0, %xmm0
cvtsi2ssq 0x14ab6(%rip), %xmm0 # 0x177b8
ucomiss 0x14a8f(%rip), %xmm0    # 0x17798
jbe 0x2d37
movss 0x14a89(%rip), %xmm1    # 0x1779c
ucomiss %xmm0, %xmm1
ja 0x2d5a
jmp 0x2d37
cmpl $0x6, %eax
je 0x2d2e
testl %eax, %eax
jne 0x2d37
cmpb $0x0, 0x14a3d(%rip)     # 0x17767
jne 0x2cf6
jmp 0x2d37
cmpb $0x1, 0x14a31(%rip)     # 0x17766
je 0x2cf6
movss 0x14a8d(%rip), %xmm0    # 0x177cc
ucomiss (%rsp), %xmm0
ja 0x2d5a
movzbl 0x14a84(%rip), %eax     # 0x177d0
cmpl $0x4, %eax
je 0x2d5a
cmpl $0x1, %eax
jne 0x3354
movl 0x14a1c(%rip), %esi     # 0x1777c
cmpl %esi, 0x14422(%rip)     # 0x17188
jge 0x2d81
movq %rbx, %rdi
callq 0x2755
movb $0x0, 0x14a5d(%rip)     # 0x177d4
movl $0x5, 0x14a47(%rip)     # 0x177c8
xorps %xmm0, %xmm0
cvtsi2sdl 0x1c(%r14), %xmm0
mulsd 0x10316(%rip), %xmm0    # 0x130a8
addsd 0x10316(%rip), %xmm0    # 0x130b0
callq 0x2060
movsd %xmm0, 0x20(%rsp)
xorps %xmm0, %xmm0
cvtsi2sdl 0x1c(%r14), %xmm0
mulsd 0x10302(%rip), %xmm0    # 0x130b8
addsd 0x10302(%rip), %xmm0    # 0x130c0
callq 0x2060
mulsd 0x102fd(%rip), %xmm0    # 0x130c8
movsd 0x20(%rsp), %xmm1
mulsd 0x102f7(%rip), %xmm1    # 0x130d0
addsd %xmm0, %xmm1
mulsd 0x102bb(%rip), %xmm1    # 0x130a0
cvttsd2si %xmm1, %ebp
movslq %ebp, %rcx
subq %rcx, %r12
movq 0x149c2(%rip), %rax     # 0x177b8
cmpq %r12, %rax
setl %dl
movss 0x149c8(%rip), %xmm0    # 0x177cc
movss 0x1c(%rsp), %xmm1
ucomiss %xmm1, %xmm0
setb %sil
orb %dl, %sil
subq %rcx, %r15
testb %sil, %sil
cmovneq %r12, %r15
jne 0x2e28
movss 0x101e8(%rip), %xmm1    # 0x13010
movq %r15, %rcx
subq %rax, %rcx
jle 0x2efa
ucomiss %xmm0, %xmm1
jbe 0x2efa
ucomiss 0x14994(%rip), %xmm0    # 0x177d8
jne 0x2e72
jp 0x2e72
movq %rax, %rdx
subq 0x1498e(%rip), %rdx     # 0x177e0
cmpq $0x12d, %rdx            # imm = 0x12D
setge %sil
movl 0x14985(%rip), %edx     # 0x177e8
testl %edx, %edx
sete %dil
orb %sil, %dil
je 0x3349
movss %xmm0, 0x1495e(%rip)    # 0x177d8
movq %rax, 0x1495f(%rip)     # 0x177e0
subss %xmm0, %xmm1
mulss 0x148f7(%rip), %xmm1    # 0x17784
mulss 0x1017f(%rip), %xmm1    # 0x13014
mulss 0x1016b(%rip), %xmm1    # 0x13008
cvttss2si %xmm1, %eax
cltq
cqto
idivq %rcx
movq %rax, %rsi
movl %esi, 0x1493b(%rip)     # 0x177ec
movl 0x148b9(%rip), %eax     # 0x17770
movl %esi, %edi
subl %eax, %edi
movl 0x148bb(%rip), %ecx     # 0x1777c
movl 0x148ac(%rip), %r8d     # 0x17774
subl %eax, %r8d
movl %ecx, %eax
cltd
idivl %r8d
imull %edi, %eax
cmpl %ecx, %eax
cmovgel %ecx, %eax
xorl %edx, %edx
cmpl 0x14897(%rip), %eax     # 0x17778
cmovgel %eax, %edx
movl %edx, 0x148fe(%rip)     # 0x177e8
leaq 0x10370(%rip), %rdi     # 0x13261
xorl %eax, %eax
callq 0x2040
jmp 0x2f17
cmpq %rax, %r15
jge 0x2f0d
movl 0x14877(%rip), %eax     # 0x1777c
movl %eax, 0x148dd(%rip)     # 0x177e8
jmp 0x2f17
movl $0x0, 0x148d1(%rip)     # 0x177e8
movabsq $0x48d159e26af37c05, %rcx # imm = 0x48D159E26AF37C05
movq %r15, %rax
imulq %rcx
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0xa, %rdx
addq %rdx, %rsi
imull $0xe10, %esi, %eax      # imm = 0xE10
movl %r15d, %ecx
subl %eax, %ecx
movswl %cx, %eax
imull $0xffff8889, %eax, %eax # imm = 0xFFFF8889
shrl $0x10, %eax
addl %ecx, %eax
movzwl %ax, %eax
movswl %ax, %ecx
shrl $0xf, %eax
sarl $0x5, %ecx
addl %eax, %ecx
movswq %cx, %rdx
leaq 0x1030a(%rip), %rdi     # 0x13271
movl %ebp, %ecx
xorl %eax, %eax
callq 0x2040
movq %r14, %rdi
callq 0x20a0
leaq 0x10305(%rip), %rdi     # 0x13284
movq %rax, %rsi
xorl %eax, %eax
callq 0x2040
movl 0x14839(%rip), %edx     # 0x177c8
testl %edx, %edx
jne 0x2fb7
movl $0x5, 0x1482b(%rip)     # 0x177c8
movq $0x0, 0x14838(%rip) # 0x177e0
movl $0x64, 0x1483e(%rip)    # 0x177f0
movl $0x5, %edx
movl 0x14837(%rip), %eax     # 0x177f4
cmpl $0x77, %eax
jg 0x2fca
incl %eax
movl %eax, 0x1482a(%rip)     # 0x177f4
leal -0x1(%rax), %ecx
xorps %xmm1, %xmm1
cvtsi2ss %ecx, %xmm1
mulss 0x1481c(%rip), %xmm1    # 0x177f8
cvtsi2ss %eax, %xmm2
movl 0x14816(%rip), %eax     # 0x177fc
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
divss %xmm2, %xmm1
divss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, 0x147f7(%rip)    # 0x177f8
cvttss2si 0x147f7(%rip), %ecx # 0x17800
movl %ecx, %esi
subl %eax, %esi
xorps %xmm1, %xmm1
cvtsi2ss %esi, %xmm1
movss 0x14778(%rip), %xmm2    # 0x17794
mulss 0xfff4(%rip), %xmm2     # 0x13018
addss %xmm1, %xmm2
xorps 0x100c1(%rip), %xmm2    # 0x130f0
cvttss2si %xmm2, %esi
movl 0x147cb(%rip), %edi     # 0x17804
subl 0x14741(%rip), %edi     # 0x17780
cmpl %esi, %edi
cmovlel %esi, %edi
xorl %esi, %esi
cmpl $0x32, %edi
jl 0x3060
movl 0x1472b(%rip), %esi     # 0x1777c
cmpl %esi, %edi
jg 0x3060
cmpl $0x65, %edi
movl $0x64, %esi
cmovael %edi, %esi
xorps %xmm1, %xmm1
cvtsi2ss %esi, %xmm1
addss 0x14751(%rip), %xmm1    # 0x177c0
movzbl 0x146f4(%rip), %edi     # 0x1776a
xorps %xmm2, %xmm2
cvtsi2ss %edi, %xmm2
movss %xmm1, 0x1473b(%rip)    # 0x177c0
movss 0x1473f(%rip), %xmm1    # 0x177cc
ucomiss %xmm2, %xmm1
jbe 0x309b
cmpq %r15, 0x1471f(%rip)     # 0x177b8
jl 0x30ae
movzbl 0x146c9(%rip), %edi     # 0x1776b
xorps %xmm2, %xmm2
cvtsi2ss %edi, %xmm2
ucomiss %xmm2, %xmm1
jbe 0x3106
movl 0x14733(%rip), %r8d     # 0x177e8
cmpl %esi, %r8d
jle 0x30fe
xorps %xmm1, %xmm1
cvtsi2ss %r8d, %xmm1
ucomiss %xmm0, %xmm1
jbe 0x30ec
xorps %xmm2, %xmm2
cvtsi2sd %r8d, %xmm2
subss %xmm0, %xmm1
cvtss2sd %xmm1, %xmm1
mulsd %xmm1, %xmm1
divsd 0xfff5(%rip), %xmm1     # 0x130d8
addsd %xmm2, %xmm1
cvttsd2si %xmm1, %r8d
movl 0x1468a(%rip), %edi     # 0x1777c
cmpl %edi, %r8d
cmovgel %edi, %r8d
movl %r8d, %esi
jmp 0x310e
movl 0x14678(%rip), %edi     # 0x1777c
jmp 0x310e
movl 0x14670(%rip), %edi     # 0x1777c
movl %edi, %esi
cmpb $0x5, 0x14694(%rip)     # 0x177a9
movl %esi, %r8d
cmovel %edi, %r8d
cmpb $0x0, 0x1463d(%rip)     # 0x17760
cmovel %esi, %r8d
cmpl $0x1, %edx
jne 0x31d1
movl 0x146ba(%rip), %edx     # 0x177f0
movl 0x146cc(%rip), %esi     # 0x17808
movl %eax, %r9d
subl %esi, %r9d
cmpl %r9d, %edx
jle 0x315a
movl %edx, %r9d
subl %eax, %r9d
addl %esi, %r9d
movl %r9d, 0x146b1(%rip)     # 0x17808
movl %r9d, %esi
testl %esi, %esi
sets %r9b
cmpl $0x65, %edx
setl %r10b
xorl %edx, %edx
orb %r9b, %r10b
jne 0x3178
movl $0x64, %edx
cmpl $0x65, %esi
jb 0x3180
movl %edx, 0x1468a(%rip)     # 0x17808
movl %edx, %esi
leal (%rsi,%r8), %edx
cmpl %edi, %edx
jle 0x3194
movl $0x0, 0x14676(%rip)     # 0x17808
xorl %esi, %esi
movl %r8d, 0x14655(%rip)     # 0x177f0
cmpl %edi, %r8d
setl %dl
subl %ecx, %eax
cmpl %eax, %r8d
setl %al
andb %dl, %al
cmpb $0x1, %al
jne 0x31d1
addl %r8d, %esi
movq %rbx, %rdi
movl $0x3, %edx
callq 0x246c
movl $0xa, 0x145ff(%rip)     # 0x177c8
movss 0x14627(%rip), %xmm0    # 0x177f8
cvtss2sd %xmm0, %xmm0
leaq 0x100b6(%rip), %rdi     # 0x13292
movb $0x1, %al
callq 0x2040
movl 0x13f9f(%rip), %esi     # 0x17188
leaq 0x100b2(%rip), %rdi     # 0x132a2
xorl %eax, %eax
callq 0x2040
movl 0x145f3(%rip), %esi     # 0x177f0
leaq 0x100ac(%rip), %rdi     # 0x132b0
xorl %eax, %eax
callq 0x2040
movl 0x145b7(%rip), %esi     # 0x177c8
leaq 0x100a5(%rip), %rdi     # 0x132bd
xorl %eax, %eax
callq 0x2040
xorps %xmm0, %xmm0
cvtss2sd (%rsp), %xmm0
leaq 0x1009d(%rip), %rdi     # 0x132cb
movb $0x1, %al
callq 0x2040
movss 0x14583(%rip), %xmm0    # 0x177c0
movss 0xfdd7(%rip), %xmm1     # 0x1301c
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movss 0x1456f(%rip), %xmm2    # 0x177c4
divss %xmm1, %xmm2
xorps %xmm1, %xmm1
cvtss2sd %xmm2, %xmm1
leaq 0x10075(%rip), %rdi     # 0x132dc
movb $0x2, %al
callq 0x2040
movl 0x14554(%rip), %eax     # 0x177c8
cmpl $0x2, %eax
jl 0x3281
decl %eax
movl %eax, 0x14547(%rip)     # 0x177c8
cmpb $0x1, 0x144e0(%rip)     # 0x17768
jne 0x333a
xorps %xmm0, %xmm0
cvtss2sd 0x14567(%rip), %xmm0    # 0x17800
leaq 0x1006c(%rip), %rsi     # 0x1330c
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
movb $0x1, %al
callq 0x2050
movq %rbx, %rdi
callq 0x2140
xorl %edx, %edx
subl 0x1454d(%rip), %edx     # 0x1780c
leaq 0x1007a(%rip), %rsi     # 0x13340
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2050
movq %rbx, %rdi
callq 0x2140
xorps %xmm0, %xmm0
cvtss2sd 0x1452d(%rip), %xmm0    # 0x17810
leaq 0x10084(%rip), %rsi     # 0x1336e
movq %rbx, %rdi
movb $0x1, %al
callq 0x2050
movq %rbx, %rdi
callq 0x2140
movl 0x144fa(%rip), %edx     # 0x177fc
leaq 0x10099(%rip), %rsi     # 0x133a2
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2050
movq %rbx, %rdi
callq 0x2140
movl 0x144f3(%rip), %edx     # 0x17814
leaq 0x100b2(%rip), %rsi     # 0x133da
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2050
movq %rbx, %rdi
callq 0x2140
xorl %eax, %eax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0x1449d(%rip), %esi     # 0x177ec
jmp 0x2eea
xorl %esi, %esi
cmpl $0x0, 0x13e2b(%rip)     # 0x17188
jne 0x2d68
jmp 0x2d81