// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0xa
popq %rdi
callq 0x2260
leaq 0x12ed1(%rip), %rdi     # 0x157d0
callq 0x2180
movq %rax, %r15
movq 0x12ec2(%rip), %rax     # 0x157d0
movl $0x15180, %ecx          # imm = 0x15180
cqto
idivq %rcx
cmpq 0x12eb9(%rip), %rdx     # 0x157d8
jge 0x2938
movss 0x12eb7(%rip), %xmm0    # 0x157e0
movss %xmm0, 0x12eb3(%rip)    # 0x157e4
andl $0x0, 0x12ea8(%rip)     # 0x157e0
movq %rdx, 0x12e99(%rip)     # 0x157d8
movzbl 0x12e45(%rip), %eax     # 0x1578b
cvtsi2ss %eax, %xmm0
movss %xmm0, 0x1c(%rsp)
movss 0x12e50(%rip), %xmm0    # 0x157a8
movss 0x12e4c(%rip), %xmm1    # 0x157ac
subss %xmm0, %xmm1
movss 0xe698(%rip), %xmm2     # 0x11004
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movss 0xe68c(%rip), %xmm3     # 0x11008
mulss %xmm3, %xmm1
movss 0x12e28(%rip), %xmm4    # 0x157b0
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(%r15), %eax
leal 0x12(%rax,%rax), %eax
cvtsi2sd %eax, %xmm0
mulsd 0xe6d3(%rip), %xmm0     # 0x11090
divsd 0xe6d3(%rip), %xmm0     # 0x11098
callq 0x2300
movss 0x12dda(%rip), %xmm1    # 0x157ac
subss 0x12dce(%rip), %xmm1    # 0x157a8
mulss 0xe62a(%rip), %xmm1     # 0x1100c
cvtss2sd %xmm1, %xmm1
mulsd %xmm0, %xmm1
mulsd 0xe6ae(%rip), %xmm1     # 0x110a0
addsd 0x20(%rsp), %xmm1
cvttsd2si %xmm1, %r12
cvttps2dq (%rsp), %xmm0
cvtdq2pd %xmm0, %xmm0
movaps %xmm0, (%rsp)
movl 0x1c(%r15), %eax
leal 0x12(%rax,%rax), %eax
cvtsi2sd %eax, %xmm0
mulsd 0xe672(%rip), %xmm0     # 0x11090
divsd 0xe672(%rip), %xmm0     # 0x11098
callq 0x2300
movss 0x12d7d(%rip), %xmm1    # 0x157b0
subss 0x12d6d(%rip), %xmm1    # 0x157a8
mulss 0xe5c9(%rip), %xmm1     # 0x1100c
cvtss2sd %xmm1, %xmm1
mulsd %xmm0, %xmm1
mulsd 0xe64d(%rip), %xmm1     # 0x110a0
addsd (%rsp), %xmm1
cvttsd2si %xmm1, %r14
movss 0x12d5b(%rip), %xmm0    # 0x157c0
cvtss2sd %xmm0, %xmm1
movsd %xmm1, (%rsp)
cvtsi2ssl 0x12d16(%rip), %xmm1 # 0x1578c
subss %xmm0, %xmm1
cvtss2sd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movl 0x1c(%r15), %eax
leal 0x12(%rax,%rax), %eax
cvtsi2sd %eax, %xmm0
mulsd 0xe5f8(%rip), %xmm0     # 0x11090
divsd 0xe5f8(%rip), %xmm0     # 0x11098
callq 0x2300
mulsd 0x20(%rsp), %xmm0
addsd (%rsp), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, (%rsp)
cmpl $0x1, 0x12d28(%rip)     # 0x157e8
jne 0x2b5a
movl 0x18(%r15), %eax
leal -0x1(%rax), %ecx
cmpl $0x5, %ecx
jae 0x2af3
cvtsi2ssq 0x12cfd(%rip), %xmm0 # 0x157d8
ucomiss 0x12cd6(%rip), %xmm0    # 0x157b8
jbe 0x2b10
movss 0x12cd0(%rip), %xmm1    # 0x157bc
ucomiss %xmm0, %xmm1
ja 0x2b33
jmp 0x2b10
cmpl $0x6, %eax
je 0x2b07
testl %eax, %eax
jne 0x2b10
cmpb $0x0, 0x12c84(%rip)     # 0x15787
jne 0x2ad2
jmp 0x2b10
cmpb $0x1, 0x12c78(%rip)     # 0x15786
je 0x2ad2
movss 0x12cd4(%rip), %xmm0    # 0x157ec
ucomiss (%rsp), %xmm0
ja 0x2b33
movzbl 0x12ccb(%rip), %eax     # 0x157f0
cmpl $0x4, %eax
je 0x2b33
cmpl $0x1, %eax
jne 0x30db
movl 0x12c63(%rip), %esi     # 0x1579c
cmpl %esi, 0x12669(%rip)     # 0x151a8
jge 0x2b5a
movq %rbx, %rdi
callq 0x2656
movb $0x0, 0x12ca4(%rip)     # 0x157f4
movl $0x5, 0x12c8e(%rip)     # 0x157e8
cvtsi2sdl 0x1c(%r15), %xmm0
mulsd 0xe540(%rip), %xmm0     # 0x110a8
addsd 0xe540(%rip), %xmm0     # 0x110b0
callq 0x2060
movsd %xmm0, 0x20(%rsp)
cvtsi2sdl 0x1c(%r15), %xmm0
mulsd 0xe52f(%rip), %xmm0     # 0x110b8
addsd 0xe52f(%rip), %xmm0     # 0x110c0
callq 0x2060
mulsd 0xe52a(%rip), %xmm0     # 0x110c8
movsd 0x20(%rsp), %xmm1
mulsd 0xe524(%rip), %xmm1     # 0x110d0
addsd %xmm0, %xmm1
mulsd 0xe4e8(%rip), %xmm1     # 0x110a0
cvttsd2si %xmm1, %ebp
movslq %ebp, %rcx
subq %rcx, %r12
movq 0x12c0f(%rip), %rax     # 0x157d8
cmpq %r12, %rax
setl %dl
movss 0x12c15(%rip), %xmm0    # 0x157ec
movss 0x1c(%rsp), %xmm1
ucomiss %xmm1, %xmm0
setb %sil
orb %dl, %sil
subq %rcx, %r14
testb %sil, %sil
cmovneq %r12, %r14
jne 0x2bfb
movss 0xe415(%rip), %xmm1     # 0x11010
movq %r14, %rcx
subq %rax, %rcx
jle 0x2ccd
ucomiss %xmm0, %xmm1
jbe 0x2ccd
ucomiss 0x12be1(%rip), %xmm0    # 0x157f8
jne 0x2c45
jp 0x2c45
movq %rax, %rdx
subq 0x12bdb(%rip), %rdx     # 0x15800
cmpq $0x12d, %rdx            # imm = 0x12D
setge %sil
movl 0x12bd2(%rip), %edx     # 0x15808
testl %edx, %edx
sete %dil
orb %sil, %dil
je 0x30d0
movss %xmm0, 0x12bab(%rip)    # 0x157f8
movq %rax, 0x12bac(%rip)     # 0x15800
subss %xmm0, %xmm1
mulss 0x12b44(%rip), %xmm1    # 0x157a4
mulss 0xe3ac(%rip), %xmm1     # 0x11014
mulss 0xe398(%rip), %xmm1     # 0x11008
cvttss2si %xmm1, %eax
cltq
cqto
idivq %rcx
movq %rax, %rsi
movl %esi, 0x12b88(%rip)     # 0x1580c
movl 0x12b06(%rip), %eax     # 0x15790
movl %esi, %edi
subl %eax, %edi
movl 0x12b08(%rip), %ecx     # 0x1579c
movl 0x12af9(%rip), %r8d     # 0x15794
subl %eax, %r8d
movl %ecx, %eax
cltd
idivl %r8d
imull %edi, %eax
cmpl %ecx, %eax
cmovgel %ecx, %eax
xorl %edx, %edx
cmpl 0x12ae4(%rip), %eax     # 0x15798
cmovgel %eax, %edx
movl %edx, 0x12b4b(%rip)     # 0x15808
leaq 0xe52d(%rip), %rdi      # 0x111f1
xorl %eax, %eax
callq 0x2040
jmp 0x2ce7
cmpq %rax, %r14
jge 0x2ce0
movl 0x12ac4(%rip), %eax     # 0x1579c
movl %eax, 0x12b2a(%rip)     # 0x15808
jmp 0x2ce7
andl $0x0, 0x12b21(%rip)     # 0x15808
movl $0xe10, %ecx            # imm = 0xE10
movq %r14, %rax
cqto
idivq %rcx
movq %rax, %rsi
movl %edx, %eax
cwtd
movw $0x3c, %cx
idivw %cx
movswq %ax, %rdx
leaq 0xe4f4(%rip), %rdi      # 0x11201
movl %ebp, %ecx
xorl %eax, %eax
callq 0x2040
movq %r15, %rdi
callq 0x20c0
leaq 0xe4ef(%rip), %rdi      # 0x11214
movq %rax, %rsi
xorl %eax, %eax
callq 0x2040
movl 0x12ab3(%rip), %edx     # 0x157e8
testl %edx, %edx
jne 0x2d58
andq $0x0, 0x12abf(%rip)     # 0x15800
movl $0x5, 0x12a9d(%rip)     # 0x157e8
movl $0x64, 0x12abb(%rip)    # 0x15810
pushq $0x5
popq %rdx
movl 0x12ab6(%rip), %esi     # 0x15814
cmpl $0x77, %esi
jg 0x2d6b
incl %esi
movl %esi, 0x12aa9(%rip)     # 0x15814
leal -0x1(%rsi), %eax
cvtsi2ss %eax, %xmm1
mulss 0x12a9e(%rip), %xmm1    # 0x15818
movl 0x12a9c(%rip), %eax     # 0x1581c
cvttss2si 0x12a98(%rip), %ecx # 0x15820
movl %ecx, %edi
subl %eax, %edi
cvtsi2ss %edi, %xmm0
movss 0x12a1c(%rip), %xmm2    # 0x157b4
mulss 0xe278(%rip), %xmm2     # 0x11018
addss %xmm0, %xmm2
cvtsi2ss %esi, %xmm3
xorps 0xe341(%rip), %xmm2     # 0x110f0
cvttss2si %xmm2, %esi
divss %xmm3, %xmm1
cvtsi2ss %eax, %xmm0
divss %xmm3, %xmm0
movl 0x12a5e(%rip), %r8d     # 0x15824
subl 0x129d3(%rip), %r8d     # 0x157a0
addss %xmm1, %xmm0
cmpl %esi, %r8d
cmovlel %esi, %r8d
movss %xmm0, 0x12a38(%rip)    # 0x15818
xorl %esi, %esi
pushq $0x64
popq %rdi
cmpl $0x32, %r8d
jl 0x2e01
movl 0x129ab(%rip), %esi     # 0x1579c
cmpl %esi, %r8d
jg 0x2e01
cmpl $0x65, %r8d
cmovbl %edi, %r8d
movl %r8d, %esi
cvtsi2ss %esi, %xmm1
addss 0x129d3(%rip), %xmm1    # 0x157e0
movzbl 0x12975(%rip), %r8d     # 0x1578a
cvtsi2ss %r8d, %xmm2
movss %xmm1, 0x129be(%rip)    # 0x157e0
movss 0x129c2(%rip), %xmm1    # 0x157ec
ucomiss %xmm2, %xmm1
jbe 0x2e38
cmpq %r14, 0x129a2(%rip)     # 0x157d8
jl 0x2e4a
movzbl 0x1294b(%rip), %r8d     # 0x1578b
cvtsi2ss %r8d, %xmm2
ucomiss %xmm2, %xmm1
jbe 0x2e9e
movl 0x129b7(%rip), %r9d     # 0x15808
cmpl %esi, %r9d
jle 0x2e95
cvtsi2ss %r9d, %xmm1
ucomiss %xmm0, %xmm1
jbe 0x2e82
cvtsi2sd %r9d, %xmm2
subss %xmm0, %xmm1
cvtss2sd %xmm1, %xmm1
mulsd %xmm1, %xmm1
divsd 0xe25f(%rip), %xmm1     # 0x110d8
addsd %xmm2, %xmm1
cvttsd2si %xmm1, %r9d
movl 0x12913(%rip), %r8d     # 0x1579c
cmpl %r8d, %r9d
cmovgel %r8d, %r9d
movl %r9d, %esi
jmp 0x2ea8
movl 0x12900(%rip), %r8d     # 0x1579c
jmp 0x2ea8
movl 0x128f7(%rip), %r8d     # 0x1579c
movl %r8d, %esi
cmpb $0x5, 0x1291a(%rip)     # 0x157c9
movl %esi, %r9d
cmovel %r8d, %r9d
cmpb $0x0, 0x128c3(%rip)     # 0x15780
cmovel %esi, %r9d
cmpl $0x1, %edx
jne 0x2f64
movl 0x12940(%rip), %edx     # 0x15810
movl 0x12952(%rip), %esi     # 0x15828
movl %eax, %r10d
subl %esi, %r10d
cmpl %r10d, %edx
jle 0x2ef4
movl %edx, %r10d
subl %eax, %r10d
addl %esi, %r10d
movl %r10d, 0x12937(%rip)    # 0x15828
movl %r10d, %esi
testl %esi, %esi
sets %r10b
cmpl $0x65, %edx
setl %r11b
xorl %edx, %edx
orb %r10b, %r11b
jne 0x2f0f
movl %edi, %edx
cmpl $0x65, %esi
jb 0x2f17
movl %edx, 0x12913(%rip)     # 0x15828
movl %edx, %esi
leal (%rsi,%r9), %edx
cmpl %r8d, %edx
jle 0x2f29
andl $0x0, 0x12901(%rip)     # 0x15828
xorl %esi, %esi
movl %r9d, 0x128e0(%rip)     # 0x15810
cmpl %r8d, %r9d
setl %dl
subl %ecx, %eax
cmpl %eax, %r9d
setl %al
andb %dl, %al
cmpb $0x1, %al
jne 0x2f64
addl %r9d, %esi
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x244c
movl $0xa, 0x1288c(%rip)     # 0x157e8
movss 0x128b4(%rip), %xmm0    # 0x15818
cvtss2sd %xmm0, %xmm0
leaq 0xe2b3(%rip), %rdi      # 0x11222
movb $0x1, %al
callq 0x2040
movl 0x1222c(%rip), %esi     # 0x151a8
leaq 0xe2af(%rip), %rdi      # 0x11232
xorl %eax, %eax
callq 0x2040
movl 0x12880(%rip), %esi     # 0x15810
leaq 0xe2a9(%rip), %rdi      # 0x11240
xorl %eax, %eax
callq 0x2040
movl 0x12844(%rip), %esi     # 0x157e8
leaq 0xe2a2(%rip), %rdi      # 0x1124d
xorl %eax, %eax
callq 0x2040
cvtss2sd (%rsp), %xmm0
leaq 0xe29d(%rip), %rdi      # 0x1125b
movb $0x1, %al
callq 0x2040
movss 0x12813(%rip), %xmm0    # 0x157e0
movss 0xe047(%rip), %xmm1     # 0x1101c
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movss 0x127ff(%rip), %xmm2    # 0x157e4
divss %xmm1, %xmm2
cvtss2sd %xmm2, %xmm1
leaq 0xe278(%rip), %rdi      # 0x1126c
movb $0x2, %al
callq 0x2040
movl 0x127e7(%rip), %eax     # 0x157e8
cmpl $0x2, %eax
jl 0x300e
decl %eax
movl %eax, 0x127da(%rip)     # 0x157e8
cmpb $0x1, 0x12773(%rip)     # 0x15788
jne 0x30c1
cvtss2sd 0x127fd(%rip), %xmm0    # 0x15820
leaq 0xe272(%rip), %rsi      # 0x1129c
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
movb $0x1, %al
callq 0x2050
movq %rbx, %rdi
callq 0x2170
xorl %edx, %edx
subl 0x127e3(%rip), %edx     # 0x1582c
leaq 0xe280(%rip), %rsi      # 0x112d0
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2050
movq %rbx, %rdi
callq 0x2170
cvtss2sd 0x127c6(%rip), %xmm0    # 0x15830
leaq 0xe28d(%rip), %rsi      # 0x112fe
movq %rbx, %rdi
movb $0x1, %al
callq 0x2050
movq %rbx, %rdi
callq 0x2170
movl 0x12793(%rip), %edx     # 0x1581c
leaq 0xe2a2(%rip), %rsi      # 0x11332
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2050
movq %rbx, %rdi
callq 0x2170
movl 0x1278c(%rip), %edx     # 0x15834
leaq 0xe2bb(%rip), %rsi      # 0x1136a
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2050
movq %rbx, %rdi
callq 0x2170
xorl %eax, %eax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0x12736(%rip), %esi     # 0x1580c
jmp 0x2cbd
xorl %esi, %esi
cmpl $0x0, 0x120c4(%rip)     # 0x151a8
jne 0x2b41
jmp 0x2b5a