// File: 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:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
leaq 0x1ea18(%rip), %rdi     # 0x2146e
movb $0x0, %al
callq 0x2040
leaq 0x23d8c(%rip), %rdi     # 0x267f0
callq 0x2190
movq %rax, 0xa8(%rsp)
movq 0x23d78(%rip), %rax     # 0x267f0
movl $0x15180, %ecx          # imm = 0x15180
cqto
idivq %rcx
cmpq 0x23d6f(%rip), %rdx     # 0x267f8
jge 0x2aa6
movss 0x23d6d(%rip), %xmm0    # 0x26800
movss %xmm0, 0x23d69(%rip)    # 0x26804
xorps %xmm0, %xmm0
movss %xmm0, 0x23d5a(%rip)    # 0x26800
movq 0x23d43(%rip), %rax     # 0x267f0
movq %rax, 0x18(%rsp)
movabsq $0x1845c8a0ce512957, %rcx # imm = 0x1845C8A0CE512957
imulq %rcx
movq 0x18(%rsp), %rax
movq %rdx, %rcx
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0xd, %rcx
addq %rdx, %rcx
imulq $0x15180, %rcx, %rcx    # imm = 0x15180
subq %rcx, %rax
movq %rax, 0x23d12(%rip)     # 0x267f8
movzbl 0x23cbe(%rip), %eax     # 0x267ab
cvtsi2ss %eax, %xmm0
movss %xmm0, 0xa4(%rsp)
movss 0x23cc6(%rip), %xmm0    # 0x267c8
movss 0x23cc2(%rip), %xmm1    # 0x267cc
subss 0x23cb6(%rip), %xmm1    # 0x267c8
movss 0x1e54e(%rip), %xmm2    # 0x21068
divss %xmm2, %xmm1
addss %xmm1, %xmm0
movss 0x1e542(%rip), %xmm1    # 0x2106c
mulss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movl %eax, 0xa0(%rsp)
movss 0x23c87(%rip), %xmm0    # 0x267c8
movss 0x23c87(%rip), %xmm1    # 0x267d0
subss 0x23c77(%rip), %xmm1    # 0x267c8
movss 0x1e50f(%rip), %xmm2    # 0x21068
divss %xmm2, %xmm1
addss %xmm1, %xmm0
movss 0x1e503(%rip), %xmm1    # 0x2106c
mulss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movl %eax, 0x9c(%rsp)
cvtsi2sdl 0xa0(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0xa8(%rsp), %rax
movl 0x1c(%rax), %eax
addl $0x9, %eax
shll %eax
cvtsi2sd %eax, %xmm0
movsd 0x1e46d(%rip), %xmm1    # 0x21010
mulsd %xmm1, %xmm0
movsd 0x1e459(%rip), %xmm1    # 0x21008
divsd %xmm1, %xmm0
callq 0x2330
movsd 0x20(%rsp), %xmm1
movss 0x23c06(%rip), %xmm2    # 0x267cc
subss 0x23bfa(%rip), %xmm2    # 0x267c8
movss 0x1e492(%rip), %xmm3    # 0x21068
divss %xmm3, %xmm2
movd %xmm2, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm2
cvtss2sd %xmm2, %xmm2
mulsd %xmm2, %xmm0
movsd 0x1e421(%rip), %xmm2    # 0x21018
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movq %rax, 0x90(%rsp)
cvtsi2sdl 0x9c(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0xa8(%rsp), %rax
movl 0x1c(%rax), %eax
addl $0x9, %eax
shll %eax
cvtsi2sd %eax, %xmm0
movsd 0x1e3d9(%rip), %xmm1    # 0x21010
mulsd %xmm1, %xmm0
movsd 0x1e3c5(%rip), %xmm1    # 0x21008
divsd %xmm1, %xmm0
callq 0x2330
movsd 0x28(%rsp), %xmm1
movss 0x23b76(%rip), %xmm2    # 0x267d0
subss 0x23b66(%rip), %xmm2    # 0x267c8
movss 0x1e3fe(%rip), %xmm3    # 0x21068
divss %xmm3, %xmm2
movd %xmm2, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm2
cvtss2sd %xmm2, %xmm2
mulsd %xmm2, %xmm0
movsd 0x1e38d(%rip), %xmm2    # 0x21018
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movq %rax, 0x88(%rsp)
movss 0x23b38(%rip), %xmm0    # 0x267e0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
cvtsi2ssl 0x23af2(%rip), %xmm0 # 0x267ac
subss 0x23b1e(%rip), %xmm0    # 0x267e0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x38(%rsp)
movq 0xa8(%rsp), %rax
movl 0x1c(%rax), %eax
addl $0x9, %eax
shll %eax
cvtsi2sd %eax, %xmm0
movsd 0x1e328(%rip), %xmm1    # 0x21010
mulsd %xmm1, %xmm0
movsd 0x1e314(%rip), %xmm1    # 0x21008
divsd %xmm1, %xmm0
callq 0x2330
movsd 0x30(%rsp), %xmm1
movaps %xmm0, %xmm2
movsd 0x38(%rsp), %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x80(%rsp)
cmpl $0x1, 0x23ae0(%rip)     # 0x26808
jne 0x2e39
movq 0xa8(%rsp), %rax
cmpl $0x0, 0x18(%rax)
jle 0x2d4a
movq 0xa8(%rsp), %rax
cmpl $0x6, 0x18(%rax)
jl 0x2d78
movq 0xa8(%rsp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x2d61
testb $0x1, 0x23a48(%rip)     # 0x267a7
jne 0x2d78
movq 0xa8(%rsp), %rax
cmpl $0x6, 0x18(%rax)
jne 0x2da4
testb $0x1, 0x23a30(%rip)     # 0x267a6
je 0x2da4
movss 0x23a58(%rip), %xmm1    # 0x267d8
cvtsi2ssq 0x23a6f(%rip), %xmm0 # 0x267f8
ucomiss %xmm1, %xmm0
jbe 0x2da4
movss 0x23a46(%rip), %xmm0    # 0x267dc
cvtsi2ssq 0x23a59(%rip), %xmm1 # 0x267f8
ucomiss %xmm1, %xmm0
ja 0x2dd2
movss 0x80(%rsp), %xmm1
movss 0x23a57(%rip), %xmm0    # 0x2680c
ucomiss %xmm1, %xmm0
ja 0x2dd2
movzbl 0x23a4f(%rip), %eax     # 0x26810
cmpl $0x1, %eax
je 0x2dd2
movzbl 0x23a43(%rip), %eax     # 0x26810
cmpl $0x4, %eax
jne 0x2e09
movl 0x233e8(%rip), %eax     # 0x261c0
cmpl 0x239de(%rip), %eax     # 0x267bc
jge 0x2e07
movq 0xb0(%rsp), %rdi
movl 0x239ce(%rip), %esi     # 0x267bc
callq 0x2730
movl $0x0, 0x23a17(%rip)     # 0x26814
movl $0x5, 0x23a01(%rip)     # 0x26808
jmp 0x2e37
cmpl $0x0, 0x233b0(%rip)     # 0x261c0
je 0x2e35
movq 0xb0(%rsp), %rdi
xorl %esi, %esi
callq 0x2730
movl $0x0, 0x239e9(%rip)     # 0x26814
movl $0x5, 0x239d3(%rip)     # 0x26808
jmp 0x2e37
jmp 0x2e39
movq 0xa8(%rsp), %rax
cvtsi2sdl 0x1c(%rax), %xmm0
movsd 0x1e1f2(%rip), %xmm1    # 0x21040
mulsd %xmm1, %xmm0
movsd 0x1e1ee(%rip), %xmm1    # 0x21048
addsd %xmm1, %xmm0
callq 0x2070
movsd %xmm0, 0x10(%rsp)
movq 0xa8(%rsp), %rax
cvtsi2sdl 0x1c(%rax), %xmm0
movsd 0x1e1b2(%rip), %xmm1    # 0x21030
mulsd %xmm1, %xmm0
movsd 0x1e1ae(%rip), %xmm1    # 0x21038
addsd %xmm1, %xmm0
callq 0x2070
movaps %xmm0, %xmm2
movsd 0x10(%rsp), %xmm0
movsd 0x1e184(%rip), %xmm1    # 0x21028
mulsd %xmm2, %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
movsd 0x1e159(%rip), %xmm2    # 0x21020
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0x1e141(%rip), %xmm1    # 0x21018
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x84(%rsp)
movq 0x90(%rsp), %rax
movslq 0x84(%rsp), %rcx
subq %rcx, %rax
movq %rax, 0x90(%rsp)
movq 0x238f0(%rip), %rax     # 0x267f8
cmpq 0x90(%rsp), %rax
jl 0x2f50
movss 0x238f2(%rip), %xmm0    # 0x2680c
ucomiss 0xa4(%rsp), %xmm0
jb 0x2f50
movq 0x88(%rsp), %rax
movslq 0x84(%rsp), %rcx
subq %rcx, %rax
movq %rax, 0x90(%rsp)
movss 0x1e129(%rip), %xmm0    # 0x21070
movss %xmm0, 0xa4(%rsp)
movq 0x238a1(%rip), %rax     # 0x267f8
cmpq 0x90(%rsp), %rax
jge 0x30cb
movss 0x2389f(%rip), %xmm1    # 0x2680c
movss 0xa4(%rsp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x30cb
movss 0x23885(%rip), %xmm0    # 0x2680c
ucomiss 0x2388a(%rip), %xmm0    # 0x26818
jne 0x2fb5
jp 0x2fb5
movq 0x2385f(%rip), %rax     # 0x267f8
subq 0x23880(%rip), %rax     # 0x26820
cmpq $0x12c, %rax            # imm = 0x12C
jg 0x2fb5
cmpl $0x0, 0x23879(%rip)     # 0x26828
jne 0x30af
movss 0x2384f(%rip), %xmm0    # 0x2680c
movss %xmm0, 0x23853(%rip)    # 0x26818
movq 0x2382c(%rip), %rax     # 0x267f8
movq %rax, 0x2384d(%rip)     # 0x26820
movss 0xa4(%rsp), %xmm0
subss 0x23828(%rip), %xmm0    # 0x2680c
mulss 0x237d8(%rip), %xmm0    # 0x267c4
movss 0x1e080(%rip), %xmm1    # 0x21074
mulss %xmm1, %xmm0
movss 0x1e06c(%rip), %xmm1    # 0x2106c
mulss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movl %eax, 0x2381a(%rip)     # 0x26828
movslq 0x23813(%rip), %rax     # 0x26828
movq 0x90(%rsp), %rcx
subq 0x237d4(%rip), %rcx     # 0x267f8
cqto
idivq %rcx
movl %eax, 0x237f9(%rip)     # 0x26828
movl 0x237f3(%rip), %eax     # 0x26828
movl %eax, 0x237f1(%rip)     # 0x2682c
movl 0x237e7(%rip), %eax     # 0x26828
subl 0x23769(%rip), %eax     # 0x267b0
movl %eax, 0x237db(%rip)     # 0x26828
movl 0x237d5(%rip), %eax     # 0x26828
movl %eax, 0xc(%rsp)
movl 0x2375f(%rip), %eax     # 0x267bc
movl 0x23751(%rip), %ecx     # 0x267b4
subl 0x23747(%rip), %ecx     # 0x267b0
cltd
idivl %ecx
movl %eax, %ecx
movl 0xc(%rsp), %eax
imull %ecx, %eax
movl %eax, 0x237ad(%rip)     # 0x26828
movl 0x237a7(%rip), %eax     # 0x26828
cmpl 0x23735(%rip), %eax     # 0x267bc
jle 0x3095
movl 0x2372d(%rip), %eax     # 0x267bc
movl %eax, 0x23793(%rip)     # 0x26828
movl 0x2378d(%rip), %eax     # 0x26828
cmpl 0x23717(%rip), %eax     # 0x267b8
jge 0x30ad
movl $0x0, 0x2377b(%rip)     # 0x26828
jmp 0x30af
movl 0x23777(%rip), %esi     # 0x2682c
movl 0x2376d(%rip), %edx     # 0x26828
leaq 0x1e057(%rip), %rdi     # 0x21119
movb $0x0, %al
callq 0x2040
jmp 0x30f6
movq 0x23726(%rip), %rax     # 0x267f8
cmpq 0x90(%rsp), %rax
jle 0x30ea
movl 0x236da(%rip), %eax     # 0x267bc
movl %eax, 0x23740(%rip)     # 0x26828
jmp 0x30f4
movl $0x0, 0x23734(%rip)     # 0x26828
jmp 0x30f6
movq 0x90(%rsp), %rax
movl $0xe10, %ecx            # imm = 0xE10
cqto
idivq %rcx
movq %rax, %rsi
movq 0x90(%rsp), %rax
movl $0xe10, %ecx            # imm = 0xE10
cqto
idivq %rcx
movq %rdx, %rax
movl $0x3c, %ecx
cqto
idivq %rcx
movq %rax, %rdx
movl 0x84(%rsp), %ecx
leaq 0x1dfee(%rip), %rdi     # 0x21129
movb $0x0, %al
callq 0x2040
movq 0xa8(%rsp), %rdi
callq 0x20d0
movq %rax, %rsi
leaq 0x1dfe3(%rip), %rdi     # 0x2113c
movb $0x0, %al
callq 0x2040
movl $0x0, 0x7c(%rsp)
cmpl $0x0, 0x23699(%rip)     # 0x26808
jne 0x3190
movl $0x5, 0x2368d(%rip)     # 0x26808
movq $0x0, 0x2369a(%rip) # 0x26820
movl $0x64, 0x236a0(%rip)    # 0x26830
cmpl $0x78, 0x2369d(%rip)    # 0x26834
jge 0x31a8
movl 0x23695(%rip), %eax     # 0x26834
addl $0x1, %eax
movl %eax, 0x2368c(%rip)     # 0x26834
movss 0x23688(%rip), %xmm0    # 0x26838
movl 0x2367e(%rip), %eax     # 0x26834
subl $0x1, %eax
cvtsi2ss %eax, %xmm1
mulss %xmm1, %xmm0
cvtsi2ssl 0x2366b(%rip), %xmm1 # 0x26834
divss %xmm1, %xmm0
movss %xmm0, 0x23663(%rip)    # 0x26838
movss 0x2365b(%rip), %xmm0    # 0x26838
cvtsi2ssl 0x23657(%rip), %xmm1 # 0x2683c
cvtsi2ssl 0x23647(%rip), %xmm2 # 0x26834
divss %xmm2, %xmm1
addss %xmm1, %xmm0
movss %xmm0, 0x2363b(%rip)    # 0x26838
xorl %eax, %eax
subl 0x23637(%rip), %eax     # 0x2683c
cvttss2si 0x23633(%rip), %ecx # 0x26840
addl %ecx, %eax
cvtsi2ss %eax, %xmm1
movss 0x235b9(%rip), %xmm0    # 0x267d4
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss 0x1de4c(%rip), %xmm2    # 0x2107c
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss 0x1de38(%rip), %xmm1    # 0x21078
mulss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movl %eax, 0x7c(%rsp)
movl 0x235f2(%rip), %eax     # 0x26844
subl 0x23568(%rip), %eax     # 0x267c0
cmpl 0x7c(%rsp), %eax
jle 0x326e
movl 0x235e0(%rip), %eax     # 0x26844
subl 0x23556(%rip), %eax     # 0x267c0
movl %eax, 0x7c(%rsp)
cmpl $0x32, 0x7c(%rsp)
jge 0x327f
movl $0x0, 0x7c(%rsp)
jmp 0x32aa
movl 0x7c(%rsp), %eax
cmpl 0x23533(%rip), %eax     # 0x267bc
jle 0x3297
movl 0x2352b(%rip), %eax     # 0x267bc
movl %eax, 0x7c(%rsp)
jmp 0x32a8
cmpl $0x64, 0x7c(%rsp)
jge 0x32a6
movl $0x64, 0x7c(%rsp)
jmp 0x32a8
jmp 0x32aa
movss 0x2354e(%rip), %xmm0    # 0x26800
cvtsi2ssl 0x7c(%rsp), %xmm1
addss %xmm1, %xmm0
movss %xmm0, 0x2353c(%rip)    # 0x26800
movss 0x23540(%rip), %xmm0    # 0x2680c
movzbl 0x234d7(%rip), %eax     # 0x267aa
cvtsi2ss %eax, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x32ed
movq 0x23515(%rip), %rax     # 0x267f8
cmpq 0x90(%rsp), %rax
jl 0x3309
movss 0x23517(%rip), %xmm0    # 0x2680c
movzbl 0x234af(%rip), %eax     # 0x267ab
cvtsi2ss %eax, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x338b
movl 0x23519(%rip), %eax     # 0x26828
cmpl 0x7c(%rsp), %eax
jle 0x3389
movl 0x2350d(%rip), %eax     # 0x26828
movl %eax, 0x7c(%rsp)
cvtsi2ssl 0x7c(%rsp), %xmm0
ucomiss 0x2350c(%rip), %xmm0    # 0x26838
jbe 0x3371
cvtsi2sdl 0x7c(%rsp), %xmm0
movsd %xmm0, (%rsp)
cvtsi2ssl 0x7c(%rsp), %xmm0
subss 0x234f1(%rip), %xmm0    # 0x26838
movl $0x2, %edi
callq 0x8fd0
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
movsd 0x1dcef(%rip), %xmm2    # 0x21050
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x7c(%rsp)
movl 0x7c(%rsp), %eax
cmpl 0x23441(%rip), %eax     # 0x267bc
jle 0x3387
movl 0x23439(%rip), %eax     # 0x267bc
movl %eax, 0x7c(%rsp)
jmp 0x3389
jmp 0x3395
movl 0x2342b(%rip), %eax     # 0x267bc
movl %eax, 0x7c(%rsp)
testb $0x1, 0x23404(%rip)     # 0x267a0
je 0x33b4
movzbl 0x23444(%rip), %eax     # 0x267e9
cmpl $0x5, %eax
jne 0x33b4
movl 0x2340c(%rip), %eax     # 0x267bc
movl %eax, 0x7c(%rsp)
cmpl $0x1, 0x2344d(%rip)     # 0x26808
jne 0x34a9
movl 0x23469(%rip), %eax     # 0x26830
movl 0x2346f(%rip), %ecx     # 0x2683c
subl 0x23475(%rip), %ecx     # 0x26848
cmpl %ecx, %eax
jle 0x33ef
movl 0x23453(%rip), %eax     # 0x26830
subl 0x23459(%rip), %eax     # 0x2683c
addl 0x2345f(%rip), %eax     # 0x26848
movl %eax, 0x23459(%rip)     # 0x26848
cmpl $0x0, 0x23452(%rip)     # 0x26848
jl 0x3401
cmpl $0x64, 0x23431(%rip)    # 0x26830
jg 0x340b
movl $0x0, 0x2343d(%rip)     # 0x26848
cmpl $0x64, 0x23436(%rip)    # 0x26848
jle 0x341e
movl $0x64, 0x2342a(%rip)    # 0x26848
movl 0x7c(%rsp), %eax
addl 0x23420(%rip), %eax     # 0x26848
cmpl 0x2338e(%rip), %eax     # 0x267bc
jle 0x343a
movl $0x0, 0x2340e(%rip)     # 0x26848
cmpl $0x1, 0x233c7(%rip)     # 0x26808
jne 0x34a7
movl 0x7c(%rsp), %eax
movl %eax, 0x233e3(%rip)     # 0x26830
movq 0x233a4(%rip), %rax     # 0x267f8
movq %rax, 0x233f5(%rip)     # 0x26850
movl 0x7c(%rsp), %eax
cmpl 0x23357(%rip), %eax     # 0x267bc
jge 0x34a5
movl 0x7c(%rsp), %eax
movl 0x233cb(%rip), %ecx     # 0x2683c
cvttss2si 0x233c7(%rip), %edx # 0x26840
subl %edx, %ecx
cmpl %ecx, %eax
jge 0x34a5
movq 0xb0(%rsp), %rdi
movl 0x7c(%rsp), %esi
addl 0x233b7(%rip), %esi     # 0x26848
movl $0x3, %edx
callq 0x2490
movl $0xa, 0x23363(%rip)     # 0x26808
jmp 0x34a7
jmp 0x34a9
movss 0x23387(%rip), %xmm0    # 0x26838
cvtss2sd %xmm0, %xmm0
leaq 0x1dc8e(%rip), %rdi     # 0x2114a
movb $0x1, %al
callq 0x2040
movl 0x22cf7(%rip), %esi     # 0x261c0
leaq 0x1dc8a(%rip), %rdi     # 0x2115a
movb $0x0, %al
callq 0x2040
movl 0x23353(%rip), %esi     # 0x26830
leaq 0x1dc84(%rip), %rdi     # 0x21168
movb $0x0, %al
callq 0x2040
movl 0x23317(%rip), %esi     # 0x26808
leaq 0x1dc7d(%rip), %rdi     # 0x21175
movb $0x0, %al
callq 0x2040
movss 0x80(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x1dc70(%rip), %rdi     # 0x21183
movb $0x1, %al
callq 0x2040
movss 0x232de(%rip), %xmm0    # 0x26800
movss 0x1db56(%rip), %xmm1    # 0x21080
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movss 0x232ca(%rip), %xmm1    # 0x26804
movss 0x1db3e(%rip), %xmm2    # 0x21080
divss %xmm2, %xmm1
cvtss2sd %xmm1, %xmm1
leaq 0x1dc43(%rip), %rdi     # 0x21194
movb $0x2, %al
callq 0x2040
cmpl $0x1, 0x232a9(%rip)     # 0x26808
jle 0x3570
movl 0x232a1(%rip), %eax     # 0x26808
addl $-0x1, %eax
movl %eax, 0x23298(%rip)     # 0x26808
testb $0x1, 0x23231(%rip)     # 0x267a8
je 0x3639
leaq 0x40(%rsp), %rdi
movss 0x232b6(%rip), %xmm0    # 0x26840
cvtss2sd %xmm0, %xmm0
leaq 0x1dc2f(%rip), %rsi     # 0x211c4
movb $0x1, %al
callq 0x2060
leaq 0x40(%rsp), %rdi
callq 0x2180
leaq 0x40(%rsp), %rdi
imull $-0x1, 0x232a6(%rip), %edx # 0x26858
leaq 0x1dc3f(%rip), %rsi     # 0x211f8
movb $0x0, %al
callq 0x2060
leaq 0x40(%rsp), %rdi
callq 0x2180
leaq 0x40(%rsp), %rdi
movss 0x23285(%rip), %xmm0    # 0x2685c
cvtss2sd %xmm0, %xmm0
leaq 0x1dc44(%rip), %rsi     # 0x21226
movb $0x1, %al
callq 0x2060
leaq 0x40(%rsp), %rdi
callq 0x2180
leaq 0x40(%rsp), %rdi
movl 0x2323e(%rip), %edx     # 0x2683c
leaq 0x1dc55(%rip), %rsi     # 0x2125a
movb $0x0, %al
callq 0x2060
leaq 0x40(%rsp), %rdi
callq 0x2180
leaq 0x40(%rsp), %rdi
movl 0x2323f(%rip), %edx     # 0x26860
leaq 0x1dc6a(%rip), %rsi     # 0x21292
movb $0x0, %al
callq 0x2060
leaq 0x40(%rsp), %rdi
callq 0x2180
xorl %eax, %eax
addq $0xb8, %rsp
retq
nopw %cs:(%rax,%rax)