LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Eba-M[P]E3DC-Control/Waermepumpe.cpp
// Function: debugout(char*)
int debugout(char buffer [100])
//        if (debug)
{
    FILE *fp;

    timeinfo = localtime (&rawtime);
    fp = fopen("debug1.out","a");
    fprintf(fp,"%s %s\n",asctime(timeinfo),buffer);
    fclose(fp);
    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2489a(%rip), %rdi     # 0x42018
callq 0x21a0
movq %rax, 0x2481e(%rip)     # 0x41fa8
leaq 0xf85f(%rip), %rdi      # 0x2cff0
leaq 0xe48a(%rip), %rsi      # 0x2bc22
callq 0x22f0
movq %rax, %r14
movq 0x24801(%rip), %rdi     # 0x41fa8
callq 0x20f0
leaq 0xf848(%rip), %rsi      # 0x2cffb
movq %r14, %rdi
movq %rax, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x23f0
movq %r14, %rdi
callq 0x2290
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/Eba-M[P]E3DC-Control/Waermepumpe.cpp
// Function: MQTTsend1(char*, char*)
int MQTTsend1(char host[20],char buffer[127])

{
    char cbuf[768];
    if (strcmp(host,"0.0.0.0")!=0) //gültige hostadresse
    {
        sprintf(cbuf, "mosquitto_pub -r -h %s -t %s", host,buffer);
        int ret = system(cbuf);
        if (debug)
        debugout(cbuf);
        return ret;
    } else
    return(-1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x300, %rsp            # imm = 0x300
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xdd16(%rip), %rsi      # 0x2b504
callq 0x23d0
testl %eax, %eax
je 0x1d82e
leaq 0xdd0e(%rip), %rsi      # 0x2b50c
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2050
movq %r15, %rdi
callq 0x2210
movl %eax, %ebx
cmpb $0x1, 0x247fe(%rip)     # 0x42020
jne 0x1d831
movq %rsp, %rdi
callq 0x1d770
jmp 0x1d831
pushq $-0x1
popq %rbx
movl %ebx, %eax
addq $0x300, %rsp            # imm = 0x300
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Eba-M[P]E3DC-Control/Waermepumpe.cpp
// Function: tasmotaon1(e3dc_config_t&)
int tasmotaon1(e3dc_config_t &e3dc)
{
    char buf[127];
    sprintf(buf,"cmnd/%s/POWER -m ON",e3dc.BWWPTasmota);
    if (Tasmotastatus <= 0){
        MQTTsend1(e3dc.mqtt2_ip,buf);
    }
        Tasmotastatus = 1;
    return 0;
}

// Assembly:
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
leaq 0x3f6(%rdi), %rdx
leaq 0xf7a9(%rip), %rsi      # 0x2d002
movq %rsp, %rdi
xorl %eax, %eax
callq 0x2050
cmpl $0x0, 0x18b1e(%rip)     # 0x36388
jg 0x1d87b
addq $0x50, %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1d7d5
movl $0x1, 0x18b03(%rip)     # 0x36388
xorl %eax, %eax
addq $0x80, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/Eba-M[P]E3DC-Control/Waermepumpe.cpp
// Function: tasmotaoff1(e3dc_config_t&)
int tasmotaoff1(e3dc_config_t &e3dc)
{
    char buf[127];
    sprintf(buf,"cmnd/%s/POWER -m OFF",e3dc.BWWPTasmota);
    if (Tasmotastatus == 1)
    MQTTsend1(e3dc.mqtt2_ip,buf);
    Tasmotastatus = 0;
    return 0;
}

// Assembly:
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
leaq 0x3f6(%rdi), %rdx
leaq 0xf76d(%rip), %rsi      # 0x2d016
movq %rsp, %rdi
xorl %eax, %eax
callq 0x2050
cmpl $0x1, 0x18ace(%rip)     # 0x36388
jne 0x1d8cb
addq $0x50, %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1d7d5
andl $0x0, 0x18ab6(%rip)     # 0x36388
xorl %eax, %eax
addq $0x80, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/Eba-M[P]E3DC-Control/awattar.cpp
// Function: Checkfile(char*, int)
bool Checkfile(char myfile[20],int minuten)
{
    struct stat stats;
     time_t  tm,tm_dt;
     time(&tm);
     if (stat(myfile,&stats)==0)
     {
         tm_dt = *(&stats.st_mtime);
         tm = (tm - tm_dt);
         if (tm >0 && tm < minuten*60)
             return false;  // zu jung
         else
             return true;
     } else return true;    // nicht vorhanden
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
movl %esi, %ebx
movq %rdi, %r14
movq %rsp, %rdi
callq 0x2250
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x2240
movl %eax, %ecx
movb $0x1, %al
testl %ecx, %ecx
je 0x210b7
addq $0x98, %rsp
popq %rbx
popq %r14
retq
movq (%rsp), %rcx
subq 0x60(%rsp), %rcx
jle 0x210ac
imull $0x3c, %ebx, %edx
movslq %edx, %rdx
cmpq %rdx, %rcx
jge 0x210ac
xorl %eax, %eax
jmp 0x210ac
// File: /workspace/github_cpp_makefile_star2_O2/Eba-M[P]E3DC-Control/awattar.cpp
// Function: CheckWallbox(char*)
bool CheckWallbox(char file[128])
/*
Mit dieser Funktion wird überprüft, ob die Wallbox für das Laden zu
aWATTar -Tarifen freigeschaltet werden muss.
Wenn über den Webserver eine neue Ladedaueränderung erkannt wurde
oder jede Stunde wird aWATTar aufgerufen, um die neuen aWATTar preise zu verarbeiten.
 */
{
    struct stat stats;
     time_t  tm,tm_dt;
     time(&tm);
     stat(file,&stats);
     tm_dt = *(&stats.st_mtime);
     tm = (tm - tm_dt);
    if (tm > 60) tm_Wallbox_dt = tm_dt; //älter als 10s?
    if (tm_dt==tm_Wallbox_dt) // neu erstellt oder alt? nur bei änderung
    {
        return false;
    }
    else
    {
        tm_Wallbox_dt = tm_dt;
        return true;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2250
leaq 0x10(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2240
movq 0x58(%r15), %rcx
movq (%r14), %rax
subq %rcx, %rax
cmpq $0x3d, %rax
setl %al
jge 0x2111d
cmpq 0x21001(%rip), %rcx     # 0x42118
jne 0x2111d
xorl %eax, %eax
jmp 0x21124
movq %rcx, 0x20ff4(%rip)     # 0x42118
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Eba-M[P]E3DC-Control/awattar.cpp
// Function: PutWallbox(std::vector<ch_s, std::allocator<ch_s>>&)
bool PutWallbox(std::vector<ch_s> &ch)
{
    FILE *mfp;
    char path[100];
    mfp = NULL;
    mfp = fopen("e3dc.wallbox.out","w");
    if (mfp)
    if (ch.size()>0)
        for (int j = 0; j < ch.size(); j++ ){
            fprintf(mfp,"%0.2f %i %i %0.2f \n",float((ch[j].hh%(24*3600))/3600.0), ch[j].hh,ch[j].ch,ch[j].pp);}
    
    if (mfp)
    fclose(mfp);

    return true;}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xc24a(%rip), %rdi      # 0x2d390
leaq 0xa3b5(%rip), %rsi      # 0x2b502
callq 0x22f0
testq %rax, %rax
je 0x211de
movq %rax, %r14
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
cmpq %rsi, %rax
je 0x211d6
pushq $0xc
popq %r12
xorl %r13d, %r13d
movl $0x15180, %ebp          # imm = 0x15180
leaq 0xc224(%rip), %r15      # 0x2d3a1
subq %rsi, %rax
sarq $0x4, %rax
cmpq %r13, %rax
jbe 0x211d6
movq -0xc(%rsi,%r12), %r8
movq %r8, %rax
cqto
idivq %rbp
cvtsi2sd %rdx, %xmm0
divsd 0xa005(%rip), %xmm0     # 0x2b1a8
cvtsd2ss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
movl -0x4(%rsi,%r12), %ecx
cvtss2sd (%rsi,%r12), %xmm1
movq %r14, %rdi
movq %r15, %rsi
movq %r8, %rdx
movb $0x2, %al
callq 0x23f0
incq %r13
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
addq $0x10, %r12
jmp 0x2117d
movq %r14, %rdi
callq 0x2290
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Eba-M[P]E3DC-Control/awattar.cpp
// Function: GetWallbox(std::vector<ch_s, std::allocator<ch_s>>&)
bool GetWallbox(std::vector<ch_s> &ch)
{
    FILE *mfp;
    mfp = NULL;
    mfp = fopen("e3dc.wallbox.out","r");
    char path[100];
    int status;
    char var [4] [20];
    memset(path, 0x00, sizeof(path));

    if (mfp != NULL)
        while (fgets(path, sizeof(path), mfp) != NULL)
        {
            status = sscanf(path, "%s %s %s %s", var[3], var[0], var[1], var[2]);
            cc.hh = atoi(var[0]);
            cc.ch = atoi(var[1]);
            cc.pp = atof(var[2]);
            ch.push_back(cc);
        }
    //        if (WP_status < 2)
    if (mfp != NULL)
        pclose(mfp);

    return true;}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
leaq 0xc186(%rip), %rdi      # 0x2d390
leaq 0xc647(%rip), %rsi      # 0x2d858
callq 0x22f0
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x50(%rsp)
andl $0x0, 0x60(%rsp)
testq %rax, %rax
je 0x212e0
movq %rax, %r14
leaq 0x84(%rsp), %r12
leaq 0x98(%rsp), %r13
movq %rsp, %rbp
leaq 0x70(%rsp), %r15
movq %rbp, %rdi
pushq $0x64
popq %rsi
movq %r14, %rdx
callq 0x2470
testq %rax, %rax
je 0x212d8
movq %rbp, %rdi
leaq 0xc139(%rip), %rsi      # 0x2d3b5
leaq 0xac(%rsp), %rdx
movq %r15, %rcx
movq %r12, %r8
movq %r13, %r9
xorl %eax, %eax
callq 0x2280
movq %r15, %rdi
callq 0x2450
cltq
movq %rax, 0x20e7b(%rip)     # 0x42120
movq %r12, %rdi
callq 0x2450
movl %eax, 0x20e75(%rip)     # 0x42128
movq %r13, %rdi
callq 0x2320
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x20e65(%rip)    # 0x4212c
movq %rbx, %rdi
leaq 0x20e4f(%rip), %rsi     # 0x42120
callq 0x2055c
jmp 0x2125f
movq %r14, %rdi
callq 0x23e0
movb $0x1, %al
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Eba-M[P]E3DC-Control/awattar.cpp
// Function: Highprice(std::vector<watt_s, std::allocator<watt_s>>&, int, int, float)
int Highprice(std::vector<watt_s> &w,int ab,int bis,float preis)    // Anzahle Einträge mit > preis
{                                            // l1 = erste position h1 = letzte Position
                                             // maxsoc = max erreichter Soc
    int x1 = 0;
    for (int j = ab; (j <= bis)&&(j<w.size()); j++ )
    {
// Suchen nach Hoch und Tiefs
        if (w[j].pp > preis) x1++;
    }
    return x1;
}

// Assembly:
movl %edx, %ecx
movq (%rdi), %r8
movq 0x8(%rdi), %rax
subq %r8, %rax
pushq $0x18
popq %rdi
cqto
idivq %rdi
movslq %esi, %rdx
movslq %ecx, %rsi
imulq $0x18, %rdx, %rcx
leaq (%rcx,%r8), %rdi
addq $0x8, %rdi
xorl %ecx, %ecx
cmpq %rsi, %rdx
jg 0x21340
cmpq %rdx, %rax
jbe 0x21340
movss (%rdi), %xmm1
xorl %r8d, %r8d
ucomiss %xmm0, %xmm1
seta %r8b
addl %r8d, %ecx
incq %rdx
addq $0x18, %rdi
jmp 0x2131c
movl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/Eba-M[P]E3DC-Control/awattar.cpp
// Function: Lowprice(std::vector<watt_s, std::allocator<watt_s>>&, int, int, float)
int Lowprice(std::vector<watt_s> &w,int ab,int bis,float preis)    // Anzahle Einträge mit < Preisf
{                                            // l1 = erste position h1 = letzte Position
    int x1 = 0;
    for (int j = ab; j <= bis; j++ )
    {
// Suchen nach Hoch und Tiefs
        if (w[j].pp < preis) x1++;
    }
    return x1;
}

// Assembly:
movq (%rdi), %rax
movslq %esi, %rcx
movslq %edx, %rdx
imulq $0x18, %rcx, %rsi
addq %rax, %rsi
addq $0x8, %rsi
xorl %eax, %eax
cmpq %rdx, %rcx
jg 0x214c2
xorl %edi, %edi
ucomiss (%rsi), %xmm0
seta %dil
addl %edi, %eax
incq %rcx
addq $0x18, %rsi
jmp 0x214a9
retq
// File: /workspace/github_cpp_makefile_star2_O2/Eba-M[P]E3DC-Control/awattar.cpp
// Function: SucheHT(std::vector<watt_s, std::allocator<watt_s>>&, int, long)
void SucheHT(std::vector<watt_s> &w,int ab,long bis)  // ab = Index bis zeitangabe in Minuten oder Sekunden seit 1970
{
    time_t  rawtime;
    struct tm * ptm;
    if (bis < 48*60) {// bis kann entweder Tagesminutensumme oder Sekunden set 1970 sein
    time(&rawtime);
    ptm = gmtime (&rawtime);
    ptm->tm_hour = bis/60;
    if (ptm->tm_hour>24) ptm->tm_hour = ptm->tm_hour-24;
    rawtime = mktime(ptm);
    if (bis/60 > 24)
    rawtime = rawtime + 24*3600;
//    ptm = gmtime (&rawtime);
    } else rawtime = bis;
    high = w[ab];
    low = w[ab];
    h1 = ab;
    l1 = ab;
    time_t  tm_dt;
    int zeit;
    for (int j = ab; ((j < w.size())&&(w[j].hh<=rawtime)); j++ )
    {
// Suchen nach Hoch und Tiefs
        zeit = w[j].hh%(24*3600)/60;
        if (w[j].pp > high.pp) {
            high = w[j];
            h1 = j;
        } else
          if  (w[j].pp < low.pp) {
              low = w[j];
              l1 = j;
          }
    }
    time(&rawtime);
    ptm = gmtime (&rawtime);

    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
cmpq $0xb3f, %rdx            # imm = 0xB3F
jg 0x2152b
movq %rsp, %r15
movq %r15, %rdi
callq 0x2250
movq %r15, %rdi
callq 0x2220
movq %rax, %rdi
pushq $0x3c
popq %rcx
movq %rbx, %rax
cqto
idivq %rcx
leal -0x18(%rax), %ecx
cmpl $0x19, %eax
cmovll %eax, %ecx
movl %ecx, 0x8(%rdi)
callq 0x2190
movq %rax, (%r15)
cmpq $0x5dc, %rbx            # imm = 0x5DC
movq %rax, %rbx
jl 0x2152f
addq $0x15180, %rax          # imm = 0x15180
movq %rax, (%rsp)
movq %rax, %rbx
jmp 0x2152f
movq %rbx, (%rsp)
movslq %ebp, %rcx
movq (%r14), %rdx
imulq $0x18, %rcx, %rax
leaq (%rdx,%rax), %rsi
movq 0x10(%rdx,%rax), %rdi
movq %rdi, 0x20bf7(%rip)     # 0x42140
movups (%rdx,%rax), %xmm0
movups %xmm0, 0x20bdc(%rip)    # 0x42130
movq 0x10(%rdx,%rax), %rdi
movq %rdi, 0x20bf8(%rip)     # 0x42158
movups (%rdx,%rax), %xmm0
movups %xmm0, 0x20bdd(%rip)    # 0x42148
movl %ecx, 0x20bef(%rip)     # 0x42160
movl %ecx, 0x20bed(%rip)     # 0x42164
movq 0x8(%r14), %rax
subq %rdx, %rax
pushq $0x18
popq %rdi
cqto
idivq %rdi
leaq 0x20bd3(%rip), %rdx     # 0x42160
leaq 0x20bd0(%rip), %rdi     # 0x42164
cmpq %rcx, %rax
jbe 0x215f7
cmpq %rbx, (%rsi)
jg 0x215f7
movss 0x8(%rsi), %xmm0
ucomiss 0x20b8e(%rip), %xmm0    # 0x42138
jbe 0x215c6
movq 0x10(%rsi), %r8
movq %r8, 0x20b89(%rip)      # 0x42140
movups (%rsi), %xmm0
movups %xmm0, 0x20b6f(%rip)    # 0x42130
movq %rdx, %r8
jmp 0x215eb
movss 0x20b82(%rip), %xmm1    # 0x42150
ucomiss %xmm0, %xmm1
jbe 0x215ee
movq 0x10(%rsi), %r8
movq %r8, 0x20b7a(%rip)      # 0x42158
movups (%rsi), %xmm0
movups %xmm0, 0x20b60(%rip)    # 0x42148
movq %rdi, %r8
movl %ecx, (%r8)
incq %rcx
addq $0x18, %rsi
jmp 0x21594
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x2250
movq %rbx, %rdi
callq 0x2220
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Eba-M[P]E3DC-Control/awattar.cpp
// Function: SucheDiff(std::vector<watt_s, std::allocator<watt_s>>&, int, float, float)
bool SucheDiff(std::vector<watt_s> &w,int ab, float aufschlag,float Diff)  // ab = Index bis Diff zwischen high und low erreicht
{
    high = w[ab];
    low = w[ab];
    h1 = ab;
    l1 = ab;
 
    for (int j = ab; (j < w.size()); j++ )
    {
// Suchen nach Hoch und Tiefs
        if (w[j].pp > high.pp) {
            high = w[j];
            h1 = j;
        } else
          if  (w[j].pp < low.pp) {
              low = w[j];
              l1 = j;
          }
        float erg = (low.pp )*(aufschlag-1)+ Diff;
        if ((high.pp - low.pp) > (low.pp)*(aufschlag-1)+ Diff)
        return true;
    }

    return false;
}

// Assembly:
movslq %esi, %rsi
movq (%rdi), %rdx
imulq $0x18, %rsi, %rax
leaq (%rdx,%rax), %rcx
movq 0x10(%rdx,%rax), %r8
movq %r8, 0x20b11(%rip)      # 0x42140
movups (%rdx,%rax), %xmm2
movups %xmm2, 0x20af6(%rip)    # 0x42130
movq 0x10(%rdx,%rax), %r8
movq %r8, 0x20b12(%rip)      # 0x42158
movups (%rdx,%rax), %xmm2
movups %xmm2, 0x20af7(%rip)    # 0x42148
movl %esi, 0x20b09(%rip)     # 0x42160
movl %esi, 0x20b07(%rip)     # 0x42164
movq 0x8(%rdi), %rax
subq %rdx, %rax
pushq $0x18
popq %rdi
cqto
idivq %rdi
addss 0x9ca0(%rip), %xmm0     # 0x2b314
movq %rsi, %rdx
cmpq %rsi, %rax
jbe 0x21704
movss 0x8(%rcx), %xmm3
movss 0x20aab(%rip), %xmm2    # 0x42138
ucomiss %xmm2, %xmm3
jbe 0x216b7
movups (%rcx), %xmm2
movups %xmm2, 0x20a94(%rip)    # 0x42130
movq 0x10(%rcx), %rsi
movq %rsi, 0x20a99(%rip)     # 0x42140
movl %edx, 0x20ab3(%rip)     # 0x42160
movss 0x20a83(%rip), %xmm2    # 0x42138
jmp 0x216df
movss 0x20a91(%rip), %xmm4    # 0x42150
ucomiss %xmm3, %xmm4
jbe 0x216df
movq 0x10(%rcx), %rsi
movq %rsi, 0x20a89(%rip)     # 0x42158
movups (%rcx), %xmm3
movups %xmm3, 0x20a6f(%rip)    # 0x42148
movl %edx, 0x20a85(%rip)     # 0x42164
movss 0x20a69(%rip), %xmm3    # 0x42150
subss %xmm3, %xmm2
mulss %xmm0, %xmm3
addss %xmm1, %xmm3
leaq 0x1(%rdx), %rsi
addq $0x18, %rcx
ucomiss %xmm3, %xmm2
jbe 0x21674
cmpq %rdx, %rax
seta %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/Eba-M[P]E3DC-Control/awattar.cpp
// Function: SuchePos(std::vector<watt_s, std::allocator<watt_s>>&, int)
int SuchePos(std::vector<watt_s> &w,int bis)  // ab = Index bis zeitangabe in Minuten Suchen nach dem Zeitpunkt oder Sekunden nach 1970
{
    time_t  rawtime;
    struct tm * ptm;
    time(&rawtime);
    ptm = gmtime (&rawtime);
    ptm->tm_hour = bis/60;
    if (bis <= 48*60)
    {
    if (ptm->tm_hour>24) ptm->tm_hour = ptm->tm_hour-24;
    rawtime = mktime(ptm);
    if (bis/60 > 24)
    rawtime = rawtime + 24*3600;
    ptm = gmtime (&rawtime);
    }
    else rawtime = bis;
    int zeit, ret=-1;
    for (int j = 0; ((j < w.size())&&(w[j].hh<rawtime)); j++ )
    {
// Suchen nach Hoch und Tiefs
        zeit = w[j].hh%(24*3600)/60;
        ret = j;
    }
    time(&rawtime);
    ptm = gmtime (&rawtime);
    return ret;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2250
movq %r14, %rdi
callq 0x2220
movq %rax, %rdi
pushq $0x3c
popq %rcx
movl %ebp, %eax
cltd
idivl %ecx
movl %eax, 0x8(%rdi)
cmpl $0xb40, %ebp            # imm = 0xB40
jg 0x2177c
cmpl $0x5dc, %ebp            # imm = 0x5DC
jl 0x21751
addl $-0x18, %eax
movl %eax, 0x8(%rdi)
callq 0x2190
leaq 0x15180(%rax), %rcx
cmpl $0x5dc, %ebp            # imm = 0x5DC
cmovlq %rax, %rcx
leaq 0x8(%rsp), %r14
movq %rcx, (%r14)
movq %r14, %rdi
callq 0x2220
movq (%r14), %rcx
jmp 0x21783
movl %ebp, %ecx
movq %rcx, 0x8(%rsp)
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
subq %rsi, %rax
pushq $0x18
popq %rdi
cqto
idivq %rdi
movl %eax, %edx
decl %edx
pushq $-0x2
popq %rbx
subq $0x1, %rax
jb 0x217b2
leaq 0x18(%rsi), %rdi
incl %ebx
cmpq %rcx, (%rsi)
movq %rdi, %rsi
jl 0x2179c
jmp 0x217b4
movl %edx, %ebx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2250
movq %r14, %rdi
callq 0x2220
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Eba-M[P]E3DC-Control/awattar.cpp
// Function: suchenSolar(std::vector<wetter_s, std::allocator<wetter_s>>&, int, float&)
int suchenSolar(std::vector<wetter_s> &w,int x1,float &Verbrauch)
// Suchen Zeitpunkt für den ersten solaren Überschuss
// -1 = kein Überschuss gefunden
// ansonsten Anzahl der 15min Einträge sowie den aufgelaufenen Verbrauch
{
    
    Verbrauch = 0;
    for (;x1<w.size()&&w[x1].hourly>w[x1].solar;x1++)
    {
        Verbrauch = Verbrauch + w[x1].hourly + w[x1].wpbedarf - w[x1].solar;
    }
    return x1;
}

// Assembly:
movq %rdx, %rcx
andl $0x0, (%rdx)
movq (%rdi), %r8
movq 0x8(%rdi), %rax
subq %r8, %rax
pushq $0x38
popq %rdi
cqto
idivq %rdi
movq %rax, %rdx
movslq %esi, %rsi
cmpq %rsi, %rax
movq %rsi, %rax
cmovaq %rdx, %rax
imulq $0x38, %rsi, %rdi
addq %r8, %rdi
addq $0x24, %rdi
xorps %xmm0, %xmm0
cmpq %rsi, %rdx
jbe 0x2183a
movss -0x10(%rdi), %xmm2
movss -0x8(%rdi), %xmm1
ucomiss %xmm1, %xmm2
jbe 0x21837
addss %xmm2, %xmm0
addss (%rdi), %xmm0
subss %xmm1, %xmm0
movss %xmm0, (%rcx)
incq %rsi
addq $0x38, %rdi
jmp 0x2180a
movq %rsi, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/Eba-M[P]E3DC-Control/awattar.cpp
// Function: suchenMaxSoc(std::vector<wetter_s, std::allocator<wetter_s>>&, int, float&)
int suchenMaxSoc(std::vector<wetter_s> &w,int x1,float &Verbrauch)
// Suchen Zeitpunkt für den max SoC
// -1 = kein Überschuss gefunden
// ansonsten Anzahl der 15min Einträge sowie den aufgelaufenen Verbrauch
{
    
    Verbrauch = 0;
    float maxsoc = -1;
    float soc = 0;
    int posmax = 0;
    for (;x1<w.size()&&w[x1].hourly>w[x1].solar;x1++)
    {
        Verbrauch = Verbrauch + w[x1].hourly + w[x1].wpbedarf + w[x1].solar;
        soc = soc + w[x1].hourly + w[x1].wpbedarf + w[x1].solar;
        if (soc <= 0) soc = 0; else
            if (soc > maxsoc)
            {
                maxsoc = soc;
                posmax = x1;
            }
    }
    return posmax;
}

// Assembly:
movq %rdx, %rcx
andl $0x0, (%rdx)
movq (%rdi), %r8
movq 0x8(%rdi), %rax
subq %r8, %rax
pushq $0x38
popq %rdi
cqto
idivq %rdi
movslq %esi, %rsi
imulq $0x38, %rsi, %rdx
leaq (%rdx,%r8), %rdi
addq $0x24, %rdi
xorl %edx, %edx
movss 0x9aa8(%rip), %xmm1     # 0x2b314
xorps %xmm0, %xmm0
xorps %xmm2, %xmm2
cmpq %rsi, %rax
jbe 0x218c4
movss -0x10(%rdi), %xmm4
movss -0x8(%rdi), %xmm3
ucomiss %xmm3, %xmm4
jbe 0x218c4
addss %xmm4, %xmm0
addss (%rdi), %xmm0
addss %xmm3, %xmm0
movss %xmm0, (%rcx)
addss -0x10(%rdi), %xmm2
addss (%rdi), %xmm2
addss -0x8(%rdi), %xmm2
xorps %xmm3, %xmm3
ucomiss %xmm2, %xmm3
jae 0x218b8
ucomiss %xmm1, %xmm2
jbe 0x218bb
movaps %xmm2, %xmm1
movl %esi, %edx
jmp 0x218bb
xorps %xmm2, %xmm2
incq %rsi
addq $0x38, %rdi
jmp 0x21872
movl %edx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_Delete
CJSON_PUBLIC(void) cJSON_Delete(cJSON *item)
{
    cJSON *next = NULL;
    while (item != NULL)
    {
        next = item->next;
        if (!(item->type & cJSON_IsReference) && (item->child != NULL))
        {
            cJSON_Delete(item->child);
        }
        if (!(item->type & cJSON_IsReference) && (item->valuestring != NULL))
        {
            global_hooks.deallocate(item->valuestring);
        }
        if (!(item->type & cJSON_StringIsConst) && (item->string != NULL))
        {
            global_hooks.deallocate(item->string);
        }
        global_hooks.deallocate(item);
        item = next;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rbx, %rbx
je 0x27fba
movq (%rbx), %r14
movl 0x18(%rbx), %eax
btl $0x8, %eax
jb 0x27f7f
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x27f7f
callq 0x27f56
movl 0x18(%rbx), %eax
btl $0x8, %eax
jb 0x27f97
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x27f97
callq *0xe424(%rip)           # 0x363b8
movl 0x18(%rbx), %eax
btl $0x9, %eax
jb 0x27fac
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x27fac
callq *0xe40c(%rip)           # 0x363b8
movq %rbx, %rdi
callq *0xe403(%rip)           # 0x363b8
movq %r14, %rbx
jmp 0x27f5d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_SetValuestring
CJSON_PUBLIC(char*) cJSON_SetValuestring(cJSON *object, const char *valuestring)
{
    char *copy = NULL;
    /* if object's type is not cJSON_String or is cJSON_IsReference, it should not set valuestring */
    if (!(object->type & cJSON_String) || (object->type & cJSON_IsReference))
    {
        return NULL;
    }
    if (strlen(valuestring) <= strlen(object->valuestring))
    {
        strcpy(object->valuestring, valuestring);
        return object->valuestring;
    }
    copy = (char*) cJSON_strdup((const unsigned char*)valuestring, &global_hooks);
    if (copy == NULL)
    {
        return NULL;
    }
    if (object->valuestring != NULL)
    {
        cJSON_free(object->valuestring);
    }
    object->valuestring = copy;

    return copy;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl $0x110, %eax            # imm = 0x110
andl 0x18(%rdi), %eax
cmpl $0x10, %eax
jne 0x2804d
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2100
movq %rax, %r12
movq 0x20(%rbx), %r15
movq %r15, %rdi
callq 0x2100
cmpq %rax, %r12
jbe 0x28052
movq %r14, %rdi
callq 0x28070
testq %rax, %rax
je 0x2804d
movq %rax, %r14
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x28047
callq *0xe371(%rip)           # 0x363b8
movq %r14, 0x20(%rbx)
jmp 0x28061
xorl %r14d, %r14d
jmp 0x28061
movq %r15, %rdi
movq %r14, %rsi
callq 0x2260
movq 0x20(%rbx), %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_strdup(unsigned char const*, internal_hooks const*)
static unsigned char* cJSON_strdup(const unsigned char* string, const internal_hooks * const hooks)
{
    size_t length = 0;
    unsigned char *copy = NULL;

    if (string == NULL)
    {
        return NULL;
    }

    length = strlen((const char*)string) + sizeof("");
    copy = (unsigned char*)hooks->allocate(length);
    if (copy == NULL)
    {
        return NULL;
    }
    memcpy(copy, string, length);

    return copy;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x280aa
movq %rdi, %rbx
callq 0x2100
movq %rax, %r14
incq %r14
movq %r14, %rdi
callq *0xe320(%rip)           # 0x363b0
testq %rax, %rax
je 0x280aa
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21f0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/Eba-M[P]E3DC-Control/cJSON.c
// Function: buffer_skip_whitespace(parse_buffer*)
static parse_buffer *buffer_skip_whitespace(parse_buffer * const buffer)
{
    if ((buffer == NULL) || (buffer->content == NULL))
    {
        return NULL;
    }

    if (cannot_access_at_index(buffer, 0))
    {
        return buffer;
    }

    while (can_access_at_index(buffer, 0) && (buffer_at_offset(buffer)[0] <= 32))
    {
       buffer->offset++;
    }

    if (buffer->offset == buffer->length)
    {
        buffer->offset--;
    }

    return buffer;
}

// Assembly:
testq %rdi, %rdi
je 0x28709
movq %rdi, %rax
movq (%rdi), %rdx
testq %rdx, %rdx
je 0x28709
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rsi
cmpq %rcx, %rsi
jae 0x2870b
cmpq %rcx, %rsi
jae 0x2870c
cmpb $0x20, (%rdx,%rsi)
ja 0x2870c
incq %rsi
movq %rsi, 0x10(%rax)
jmp 0x286f5
xorl %eax, %eax
retq
cmpq %rsi, %rcx
jne 0x2870b
decq %rcx
movq %rcx, 0x10(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O2/Eba-M[P]E3DC-Control/cJSON.c
// Function: print(cJSON const*, int, internal_hooks const*)
static unsigned char *print(const cJSON * const item, cJSON_bool format, const internal_hooks * const hooks)
{
    static const size_t default_buffer_size = 256;
    printbuffer buffer[1];
    unsigned char *printed = NULL;

    memset(buffer, 0, sizeof(buffer));

    /* create buffer */
    buffer->buffer = (unsigned char*) hooks->allocate(default_buffer_size);
    buffer->length = default_buffer_size;
    buffer->format = format;
    buffer->hooks = *hooks;
    if (buffer->buffer == NULL)
    {
        goto fail;
    }

    /* print the value */
    if (!print_value(item, buffer))
    {
        goto fail;
    }
    update_offset(buffer);

    /* check if reallocate is available */
    if (hooks->reallocate != NULL)
    {
        printed = (unsigned char*) hooks->reallocate(buffer->buffer, buffer->offset + 1);
        if (printed == NULL) {
            goto fail;
        }
        buffer->buffer = NULL;
    }
    else /* otherwise copy the JSON over to a new buffer */
    {
        printed = (unsigned char*) hooks->allocate(buffer->offset + 1);
        if (printed == NULL)
        {
            goto fail;
        }
        memcpy(printed, buffer->buffer, cjson_min(buffer->length, buffer->offset + 1));
        printed[buffer->offset] = '\0'; /* just to be sure */

        /* free the buffer */
        hooks->deallocate(buffer->buffer);
    }

    return printed;

fail:
    if (buffer->buffer != NULL)
    {
        hooks->deallocate(buffer->buffer);
    }

    if (printed != NULL)
    {
        hooks->deallocate(printed);
    }

    return NULL;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x48, %rsp
movl %esi, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movl $0x100, %edi            # imm = 0x100
callq *0xdc5d(%rip)           # 0x363b0
movq %rax, (%rsp)
movq $0x100, 0x8(%rsp)       # imm = 0x100
movl %ebp, 0x24(%rsp)
movups 0xdc45(%rip), %xmm0     # 0x363b0
movups %xmm0, 0x28(%rsp)
movq 0xdc49(%rip), %rcx      # 0x363c0
movq %rcx, 0x38(%rsp)
testq %rax, %rax
je 0x28808
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x288a6
testl %eax, %eax
je 0x28808
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x29de1
movq 0xdc1a(%rip), %rax      # 0x363c0
movq 0x10(%rbx), %rsi
incq %rsi
testq %rax, %rax
je 0x287c2
movq (%rsp), %rdi
callq *%rax
movq %rax, %rbx
testq %rax, %rax
jne 0x28819
jmp 0x28808
movq %rsi, %rdi
callq *0xdbe5(%rip)           # 0x363b0
testq %rax, %rax
je 0x28808
movq %rax, %rbx
movq (%rsp), %rsi
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rdx
incq %rdx
cmpq %rdx, %rax
cmovbq %rax, %rdx
movq %rbx, %rdi
callq 0x21f0
movq 0x10(%rsp), %rax
movb $0x0, (%rbx,%rax)
movq (%rsp), %rdi
callq *0xdbb2(%rip)           # 0x363b8
jmp 0x28819
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x28817
callq *0xdba1(%rip)           # 0x363b8
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_PrintBuffered
CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON *item, int prebuffer, cJSON_bool fmt)
{
    printbuffer p = { 0, 0, 0, 0, 0, 0, { 0, 0, 0 } };

    if (prebuffer < 0)
    {
        return NULL;
    }

    p.buffer = (unsigned char*)global_hooks.allocate((size_t)prebuffer);
    if (!p.buffer)
    {
        return NULL;
    }

    p.length = (size_t)prebuffer;
    p.offset = 0;
    p.noalloc = false;
    p.format = fmt;
    p.hooks = global_hooks;

    if (!print_value(item, &p))
    {
        global_hooks.deallocate(p.buffer);
        return NULL;
    }

    return (char*)p.buffer;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
andq $0x0, 0x18(%rsp)
testl %esi, %esi
js 0x2889b
movl %edx, %ebp
movq %rdi, %rbx
movl %esi, %r14d
movq %r14, %rdi
callq *0xdb63(%rip)           # 0x363b0
movq %rax, (%rsp)
testq %rax, %rax
je 0x2889b
movq %rsp, %rsi
movq %r14, 0x8(%rsi)
andq $0x0, 0x10(%rsi)
andl $0x0, 0x20(%rsi)
movl %ebp, 0x24(%rsi)
movups 0xdb40(%rip), %xmm0     # 0x363b0
movups %xmm0, 0x28(%rsi)
movq 0xdb45(%rip), %rax      # 0x363c0
movq %rax, 0x38(%rsi)
movq %rbx, %rdi
callq 0x288a6
testl %eax, %eax
je 0x28891
movq (%rsp), %rax
jmp 0x2889d
movq (%rsp), %rdi
callq *0xdb1d(%rip)           # 0x363b8
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_PrintPreallocated
CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON *item, char *buffer, const int length, const cJSON_bool format)
{
    printbuffer p = { 0, 0, 0, 0, 0, 0, { 0, 0, 0 } };

    if ((length < 0) || (buffer == NULL))
    {
        return false;
    }

    p.buffer = (unsigned char*)buffer;
    p.length = (size_t)length;
    p.offset = 0;
    p.noalloc = true;
    p.format = format;
    p.hooks = global_hooks;

    return print_value(item, &p);
}

// Assembly:
subq $0x48, %rsp
andq $0x0, 0x20(%rsp)
testl %edx, %edx
sets %r8b
testq %rsi, %rsi
sete %r9b
xorl %eax, %eax
orb %r8b, %r9b
jne 0x28d9b
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
movl %edx, %edx
movq %rdx, 0x8(%rax)
andq $0x0, 0x10(%rax)
movl $0x1, 0x20(%rax)
movl %ecx, 0x24(%rax)
movups 0xd62c(%rip), %xmm0     # 0x363b0
movups %xmm0, 0x28(%rax)
movq 0xd631(%rip), %rcx      # 0x363c0
movq %rcx, 0x38(%rax)
movq %rax, %rsi
callq 0x288a6
addq $0x48, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Eba-M[P]E3DC-Control/cJSON.c
// Function: get_object_item(cJSON const*, char const*, int)
static cJSON *get_object_item(const cJSON * const object, const char * const name, const cJSON_bool case_sensitive)
{
    cJSON *current_element = NULL;

    if ((object == NULL) || (name == NULL))
    {
        return NULL;
    }

    current_element = object->child;
    if (case_sensitive)
    {
        while ((current_element != NULL) && (current_element->string != NULL) && (strcmp(name, current_element->string) != 0))
        {
            current_element = current_element->next;
        }
    }
    else
    {
        while ((current_element != NULL) && (case_insensitive_strcmp((const unsigned char*)name, (const unsigned char*)(current_element->string)) != 0))
        {
            current_element = current_element->next;
        }
    }

    if ((current_element == NULL) || (current_element->string == NULL)) {
        return NULL;
    }

    return current_element;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0x28e0b
xorl %ebx, %ebx
jmp 0x28e89
movq %rsi, %r14
movq 0x10(%rdi), %rbx
testl %edx, %edx
je 0x28e73
testq %rbx, %rbx
je 0x28e07
movq 0x38(%rbx), %r15
testq %r15, %r15
je 0x28e7f
movq %r14, %rdi
movq %r15, %rsi
callq 0x23d0
testl %eax, %eax
je 0x28e7a
movq (%rbx), %rbx
jmp 0x28e16
movq 0x38(%rbx), %r15
testq %r15, %r15
je 0x28e70
cmpq %r14, %r15
je 0x28e82
xorl %r12d, %r12d
movb (%r14,%r12), %r13b
movzbl %r13b, %edi
callq 0x2400
movl %eax, %ebp
movzbl (%r15,%r12), %edi
callq 0x2400
cmpl %eax, %ebp
jne 0x28e70
testb %r13b, %r13b
je 0x28e7a
incq %r12
jmp 0x28e49
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x28e38
jmp 0x28e07
movq %r15, %r14
jmp 0x28e82
xorl %r14d, %r14d
testq %r14, %r14
cmoveq %r14, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Eba-M[P]E3DC-Control/cJSON.c
// Function: add_item_to_object(cJSON*, char const*, cJSON*, internal_hooks const*, int)
static cJSON_bool add_item_to_object(cJSON * const object, const char * const string, cJSON * const item, const internal_hooks * const hooks, const cJSON_bool constant_key)
{
    char *new_key = NULL;
    int new_type = cJSON_Invalid;

    if ((object == NULL) || (string == NULL) || (item == NULL) || (object == item))
    {
        return false;
    }

    if (constant_key)
    {
        new_key = (char*)cast_away_const(string);
        new_type = item->type | cJSON_StringIsConst;
    }
    else
    {
        new_key = (char*)cJSON_strdup((const unsigned char*)string, hooks);
        if (new_key == NULL)
        {
            return false;
        }

        new_type = item->type & ~cJSON_StringIsConst;
    }

    if (!(item->type & cJSON_StringIsConst) && (item->string != NULL))
    {
        hooks->deallocate(item->string);
    }

    item->string = new_key;
    item->type = new_type;

    return add_item_to_array(object, item);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpq %rdx, %rdi
je 0x28f7e
movq %rdi, %r14
testq %rdi, %rdi
je 0x28f7e
movq %rsi, %r15
testq %rsi, %rsi
je 0x28f7e
movq %rdx, %rbx
testq %rdx, %rdx
je 0x28f7e
testl %ecx, %ecx
je 0x28f32
movl 0x18(%rbx), %eax
movl %eax, %ebp
orl $0x200, %ebp            # imm = 0x200
jmp 0x28f4d
movq %r15, %rdi
callq 0x28070
testq %rax, %rax
je 0x28f7e
movq %rax, %r15
movl 0x18(%rbx), %eax
movl %eax, %ebp
andl $0xfffffdff, %ebp       # imm = 0xFFFFFDFF
btl $0x9, %eax
jb 0x28f62
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x28f62
callq *0xd456(%rip)           # 0x363b8
movq %r15, 0x38(%rbx)
movl %ebp, 0x18(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x28eb7
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Eba-M[P]E3DC-Control/cJSON.c
// Function: create_reference(cJSON const*, internal_hooks const*)
static cJSON *create_reference(const cJSON *item, const internal_hooks * const hooks)
{
    cJSON *reference = NULL;
    if (item == NULL)
    {
        return NULL;
    }

    reference = cJSON_New_Item(hooks);
    if (reference == NULL)
    {
        return NULL;
    }

    memcpy(reference, item, sizeof(cJSON));
    reference->string = NULL;
    reference->type |= cJSON_IsReference;
    reference->next = reference->prev = NULL;
    return reference;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x29008
movq %rdi, %rbx
pushq $0x40
popq %rdi
callq *0xd3eb(%rip)           # 0x363b0
testq %rax, %rax
je 0x29008
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movups (%rbx), %xmm1
movups 0x10(%rbx), %xmm2
movups 0x20(%rbx), %xmm3
movups %xmm2, 0x10(%rax)
movups %xmm1, (%rax)
movups %xmm3, 0x20(%rax)
movq 0x30(%rbx), %rcx
movq %rcx, 0x30(%rax)
andq $0x0, 0x38(%rax)
orb $0x1, 0x19(%rax)
movups %xmm0, (%rax)
jmp 0x2900a
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_CreateNull
CJSON_PUBLIC(cJSON *) cJSON_CreateNull(void)
{
    cJSON *item = cJSON_New_Item(&global_hooks);
    if(item)
    {
        item->type = cJSON_NULL;
    }

    return item;
}

// Assembly:
pushq %rax
pushq $0x40
popq %rdi
callq *0xd324(%rip)           # 0x363b0
testq %rax, %rax
je 0x290aa
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, (%rax)
movl $0x4, 0x18(%rax)
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_CreateTrue
CJSON_PUBLIC(cJSON *) cJSON_CreateTrue(void)
{
    cJSON *item = cJSON_New_Item(&global_hooks);
    if(item)
    {
        item->type = cJSON_True;
    }

    return item;
}

// Assembly:
pushq %rax
pushq $0x40
popq %rdi
callq *0xd2c0(%rip)           # 0x363b0
testq %rax, %rax
je 0x2910e
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, (%rax)
movl $0x2, 0x18(%rax)
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_CreateFalse
CJSON_PUBLIC(cJSON *) cJSON_CreateFalse(void)
{
    cJSON *item = cJSON_New_Item(&global_hooks);
    if(item)
    {
        item->type = cJSON_False;
    }

    return item;
}

// Assembly:
pushq %rax
pushq $0x40
popq %rdi
callq *0xd25c(%rip)           # 0x363b0
testq %rax, %rax
je 0x29172
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, (%rax)
movl $0x1, 0x18(%rax)
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_CreateBool
CJSON_PUBLIC(cJSON *) cJSON_CreateBool(cJSON_bool boolean)
{
    cJSON *item = cJSON_New_Item(&global_hooks);
    if(item)
    {
        item->type = boolean ? cJSON_True : cJSON_False;
    }

    return item;
}

// Assembly:
pushq %rbx
movl %edi, %ebx
pushq $0x40
popq %rdi
callq *0xd1f4(%rip)           # 0x363b0
testq %rax, %rax
je 0x291df
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, (%rax)
cmpl $0x1, %ebx
pushq $0x2
popq %rcx
sbbl $0x0, %ecx
movl %ecx, 0x18(%rax)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_CreateNumber
CJSON_PUBLIC(cJSON *) cJSON_CreateNumber(double num)
{
    cJSON *item = cJSON_New_Item(&global_hooks);
    if(item)
    {
        item->type = cJSON_Number;
        item->valuedouble = num;

        /* use saturation in case of overflow */
        if (num >= INT_MAX)
        {
            item->valueint = INT_MAX;
        }
        else if (num <= (double)INT_MIN)
        {
            item->valueint = INT_MIN;
        }
        else
        {
            item->valueint = (int)num;
        }
    }

    return item;
}

// Assembly:
pushq %rax
movsd %xmm0, (%rsp)
pushq $0x40
popq %rdi
callq *0xd186(%rip)           # 0x363b0
testq %rax, %rax
je 0x29280
xorpd %xmm0, %xmm0
movupd %xmm0, 0x10(%rax)
movupd %xmm0, 0x30(%rax)
movupd %xmm0, 0x20(%rax)
movupd %xmm0, (%rax)
movl $0x8, 0x18(%rax)
movsd (%rsp), %xmm1
movsd %xmm1, 0x30(%rax)
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
ucomisd 0x4644(%rip), %xmm1     # 0x2d8a8
jae 0x2927d
movl $0x80000000, %ecx       # imm = 0x80000000
movsd 0x463d(%rip), %xmm0     # 0x2d8b0
ucomisd %xmm1, %xmm0
jae 0x2927d
cvttsd2si %xmm1, %ecx
movl %ecx, 0x28(%rax)
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_CreateString
CJSON_PUBLIC(cJSON *) cJSON_CreateString(const char *string)
{
    cJSON *item = cJSON_New_Item(&global_hooks);
    if(item)
    {
        item->type = cJSON_String;
        item->valuestring = (char*)cJSON_strdup((const unsigned char*)string, &global_hooks);
        if(!item->valuestring)
        {
            cJSON_Delete(item);
            return NULL;
        }
    }

    return item;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x40
popq %rdi
callq *0xd0e1(%rip)           # 0x363b0
testq %rax, %rax
je 0x29309
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, (%rax)
movl $0x10, 0x18(%rax)
movq %r14, %rdi
callq 0x28070
movq %rax, 0x20(%rbx)
testq %rax, %rax
jne 0x2930b
movq %rbx, %rdi
callq 0x27f56
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_CreateRaw
CJSON_PUBLIC(cJSON *) cJSON_CreateRaw(const char *raw)
{
    cJSON *item = cJSON_New_Item(&global_hooks);
    if(item)
    {
        item->type = cJSON_Raw;
        item->valuestring = (char*)cJSON_strdup((const unsigned char*)raw, &global_hooks);
        if(!item->valuestring)
        {
            cJSON_Delete(item);
            return NULL;
        }
    }

    return item;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x40
popq %rdi
callq *0xd04d(%rip)           # 0x363b0
testq %rax, %rax
je 0x2939d
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, (%rax)
movl $0x80, 0x18(%rax)
movq %r14, %rdi
callq 0x28070
movq %rax, 0x20(%rbx)
testq %rax, %rax
jne 0x2939f
movq %rbx, %rdi
callq 0x27f56
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_CreateObject
CJSON_PUBLIC(cJSON *) cJSON_CreateObject(void)
{
    cJSON *item = cJSON_New_Item(&global_hooks);
    if (item)
    {
        item->type = cJSON_Object;
    }

    return item;
}

// Assembly:
pushq %rax
pushq $0x40
popq %rdi
callq *0xcfc2(%rip)           # 0x363b0
testq %rax, %rax
je 0x2940c
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, (%rax)
movl $0x40, 0x18(%rax)
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_CreateArray
CJSON_PUBLIC(cJSON *) cJSON_CreateArray(void)
{
    cJSON *item = cJSON_New_Item(&global_hooks);
    if(item)
    {
        item->type=cJSON_Array;
    }

    return item;
}

// Assembly:
pushq %rax
pushq $0x40
popq %rdi
callq *0xcf5e(%rip)           # 0x363b0
testq %rax, %rax
je 0x29470
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, (%rax)
movl $0x20, 0x18(%rax)
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_InsertItemInArray
CJSON_PUBLIC(cJSON_bool) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem)
{
    cJSON *after_inserted = NULL;

    if (which < 0)
    {
        return false;
    }

    after_inserted = get_array_item(array, (size_t)which);
    if (after_inserted == NULL)
    {
        return add_item_to_array(array, newitem);
    }

    newitem->next = after_inserted;
    newitem->prev = after_inserted->prev;
    after_inserted->prev = newitem;
    if (after_inserted == array->child)
    {
        array->child = newitem;
    }
    else
    {
        newitem->prev->next = newitem;
    }
    return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testl %esi, %esi
js 0x29571
movq %rdx, %rbx
movq %rdi, %r14
movl %esi, %esi
callq 0x28dc5
testq %rax, %rax
je 0x29575
movq %rax, (%rbx)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rbx)
movq %rbx, 0x8(%rax)
cmpq 0x10(%r14), %rax
je 0x29587
movq 0x8(%rbx), %rax
movq %rbx, (%rax)
jmp 0x2958b
xorl %eax, %eax
jmp 0x2958e
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x28eb7
movq %rbx, 0x10(%r14)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/Eba-M[P]E3DC-Control/cJSON.c
// Function: replace_item_in_object(cJSON*, char const*, cJSON*, int)
static cJSON_bool replace_item_in_object(cJSON *object, const char *string, cJSON *replacement, cJSON_bool case_sensitive)
{
    if ((replacement == NULL) || (string == NULL))
    {
        return false;
    }

    /* replace the name in the replacement */
    if (!(replacement->type & cJSON_StringIsConst) && (replacement->string != NULL))
    {
        cJSON_free(replacement->string);
    }
    replacement->string = (char*)cJSON_strdup((const unsigned char*)string, &global_hooks);
    if (replacement->string == NULL)
    {
        return false;
    }

    replacement->type &= ~cJSON_StringIsConst;

    return cJSON_ReplaceItemViaPointer(object, get_object_item(object, string, case_sensitive), replacement);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
testq %rdx, %rdx
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x296b7
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
testb $0x2, 0x19(%rdx)
jne 0x2967d
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x2967d
callq *0xcd3b(%rip)           # 0x363b8
movq %r15, %rdi
callq 0x28070
movq %rax, 0x38(%rbx)
testq %rax, %rax
je 0x296b7
andb $-0x3, 0x19(%rbx)
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x28dec
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x29596
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_CreateStringReference
CJSON_PUBLIC(cJSON *) cJSON_CreateStringReference(const char *string)
{
    cJSON *item = cJSON_New_Item(&global_hooks);
    if (item != NULL)
    {
        item->type = cJSON_String | cJSON_IsReference;
        item->valuestring = (char*)cast_away_const(string);
    }

    return item;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x40
popq %rdi
callq *0xccd7(%rip)           # 0x363b0
testq %rax, %rax
je 0x296fb
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, (%rax)
movl $0x110, 0x18(%rax)      # imm = 0x110
movq %rbx, 0x20(%rax)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_CreateObjectReference
CJSON_PUBLIC(cJSON *) cJSON_CreateObjectReference(const cJSON *child)
{
    cJSON *item = cJSON_New_Item(&global_hooks);
    if (item != NULL) {
        item->type = cJSON_Object | cJSON_IsReference;
        item->child = (cJSON*)cast_away_const(child);
    }

    return item;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x40
popq %rdi
callq *0xcca6(%rip)           # 0x363b0
testq %rax, %rax
je 0x2972c
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, (%rax)
movl $0x140, 0x18(%rax)      # imm = 0x140
movq %rbx, 0x10(%rax)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_CreateArrayReference
CJSON_PUBLIC(cJSON *) cJSON_CreateArrayReference(const cJSON *child) {
    cJSON *item = cJSON_New_Item(&global_hooks);
    if (item != NULL) {
        item->type = cJSON_Array | cJSON_IsReference;
        item->child = (cJSON*)cast_away_const(child);
    }

    return item;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x40
popq %rdi
callq *0xcc75(%rip)           # 0x363b0
testq %rax, %rax
je 0x2975d
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, (%rax)
movl $0x120, 0x18(%rax)      # imm = 0x120
movq %rbx, 0x10(%rax)
popq %rbx
retq