LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Eba-M[P]E3DC-Control/RscpExampleMain.cpp
// Function: shelly_get()
int shelly_get(){
    FILE *fp;
    char line[256];
    int WP_status,status;
    char path[1024];
    
    fp = NULL;
    if (shellytimer < t) 
    {
        sprintf(line,"curl -s -X GET 'http://%s/rpc/Light.GetStatus?id=0'",e3dc_config.shelly0V10V_ip);
        fp = popen(line, "r");
        //    system(line);
        const cJSON *item = NULL;
        if (fp != NULL)
            if (fgets(path, 1024, fp) != NULL)
                
            {
                
                std::string feld;
                cJSON *wolf_json = cJSON_Parse(path);
                feld = "brightness";
                char * c = &feld[0];
                item = cJSON_GetObjectItemCaseSensitive(wolf_json, c );
                
            }
        status = pclose(fp);
        if (item!=NULL)
            return(item->valueint);
        else
        {
            shellytimer = t+600;
            return(-1);
        }
    }
    return(-2);
}

// Assembly:
subq $0x588, %rsp            # imm = 0x588
movq $0x0, 0x578(%rsp)
movq 0x68846(%rip), %rax     # 0x70f40
cmpq 0x674f7(%rip), %rax     # 0x6fbf8
jge 0x886b
leaq 0x470(%rsp), %rdi
leaq 0x58500(%rip), %rsi     # 0x60c16
leaq 0x66217(%rip), %rdx     # 0x6e934
addq $0xe6, %rdx
movb $0x0, %al
callq 0x2060
leaq 0x470(%rsp), %rdi
leaq 0x580c9(%rip), %rsi     # 0x60803
callq 0x20b0
movq %rax, 0x578(%rsp)
movq $0x0, 0x58(%rsp)
cmpq $0x0, 0x578(%rsp)
je 0x881d
leaq 0x60(%rsp), %rdi
movq 0x578(%rsp), %rdx
movl $0x400, %esi            # imm = 0x400
callq 0x2450
cmpq $0x0, %rax
je 0x881b
leaq 0x38(%rsp), %rdi
callq 0x23a0
leaq 0x60(%rsp), %rdi
callq 0x599d0
movq %rax, 0x10(%rsp)
jmp 0x879b
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x5849e(%rip), %rsi     # 0x60c4a
leaq 0x38(%rsp), %rdi
callq 0x2380
jmp 0x87b8
xorl %eax, %eax
movl %eax, %esi
leaq 0x38(%rsp), %rdi
callq 0x2550
movq %rax, 0x8(%rsp)
jmp 0x87cd
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x5a2f0
movq %rax, (%rsp)
jmp 0x87ec
movq (%rsp), %rax
movq %rax, 0x58(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x2578
jmp 0x881b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x2578
jmp 0x8885
jmp 0x881d
movq 0x578(%rsp), %rdi
callq 0x23d0
movl %eax, 0x468(%rsp)
cmpq $0x0, 0x58(%rsp)
je 0x884a
movq 0x58(%rsp), %rax
movl 0x28(%rax), %eax
movl %eax, 0x584(%rsp)
jmp 0x8876
movq 0x673a7(%rip), %rax     # 0x6fbf8
addq $0x258, %rax            # imm = 0x258
movq %rax, 0x686e2(%rip)     # 0x70f40
movl $0xffffffff, 0x584(%rsp) # imm = 0xFFFFFFFF
jmp 0x8876
movl $0xfffffffe, 0x584(%rsp) # imm = 0xFFFFFFFE
movl 0x584(%rsp), %eax
addq $0x588, %rsp            # imm = 0x588
retq
movq 0x28(%rsp), %rdi
callq 0x24c0
nop
// File: Eba-M[P]E3DC-Control/RscpExampleMain.cpp
// Function: shelly(int)
int shelly(int ALV)
{
    char path[1024];
    char buf[127];
    static int ALV_alt = -1;
    FILE *fp;
    fp==NULL;
    if (ALV>0&&ALV<e3dc_config.shelly0V10Vmin) ALV = e3dc_config.shelly0V10Vmin;
    if (ALV>e3dc_config.shelly0V10Vmax) ALV = e3dc_config.shelly0V10Vmax;
    if (e3dc_config.shelly0V10V&&shellytimer < t&&ALV!=ALV_alt)
    {
        if (ALV>0)
            sprintf(buf,"curl -s -X POST -d '{""id"":0, ""on"":true, ""brightness"":%i}' ""http://%s/rpc/Light.Set?",ALV,e3dc_config.shelly0V10V_ip);
        else
            sprintf(buf,"curl -s -X POST -d '{""id"":0, ""on"":false, ""brightness"":%i}' ""http://%s/rpc/Light.Set?",ALV,e3dc_config.shelly0V10V_ip);
        fp = popen(buf, "r");
        
        if (fp != NULL)
            if (fgets(path, 1024, fp) != NULL)
            {
                ALV_alt = ALV;
            }
    if (fp != NULL)
        pclose(fp);
    }
    return ALV_alt;
}

// Assembly:
subq $0x498, %rsp            # imm = 0x498
movl %edi, 0x494(%rsp)
cmpl $0x0, 0x494(%rsp)
jle 0x8d24
movl 0x494(%rsp), %eax
cmpl 0x661bb(%rip), %eax     # 0x6eed0
jge 0x8d24
movl 0x661b3(%rip), %eax     # 0x6eed0
movl %eax, 0x494(%rsp)
movl 0x494(%rsp), %eax
cmpl 0x661a3(%rip), %eax     # 0x6eed4
jle 0x8d40
movl 0x6619b(%rip), %eax     # 0x6eed4
movl %eax, 0x494(%rsp)
testb $0x1, 0x6611e(%rip)     # 0x6ee65
je 0x8e2e
movq 0x681ec(%rip), %rax     # 0x70f40
cmpq 0x66e9d(%rip), %rax     # 0x6fbf8
jge 0x8e2e
movl 0x494(%rsp), %eax
cmpl 0x655f2(%rip), %eax     # 0x6e360
je 0x8e2e
cmpl $0x0, 0x494(%rsp)
jle 0x8da8
leaq 0x10(%rsp), %rdi
movl 0x494(%rsp), %edx
leaq 0x57f6c(%rip), %rsi     # 0x60cfd
leaq 0x65b9c(%rip), %rcx     # 0x6e934
addq $0xe6, %rcx
movb $0x0, %al
callq 0x2060
jmp 0x8dd0
leaq 0x10(%rsp), %rdi
movl 0x494(%rsp), %edx
leaq 0x57f8f(%rip), %rsi     # 0x60d4a
leaq 0x65b72(%rip), %rcx     # 0x6e934
addq $0xe6, %rcx
movb $0x0, %al
callq 0x2060
leaq 0x10(%rsp), %rdi
leaq 0x57a27(%rip), %rsi     # 0x60803
callq 0x20b0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x8e1a
leaq 0x90(%rsp), %rdi
movq 0x8(%rsp), %rdx
movl $0x400, %esi            # imm = 0x400
callq 0x2450
cmpq $0x0, %rax
je 0x8e18
movl 0x494(%rsp), %eax
movl %eax, 0x65548(%rip)     # 0x6e360
jmp 0x8e1a
cmpq $0x0, 0x8(%rsp)
je 0x8e2c
movq 0x8(%rsp), %rdi
callq 0x23d0
jmp 0x8e2e
movl 0x6552c(%rip), %eax     # 0x6e360
addq $0x498, %rsp            # imm = 0x498
retq
nopl (%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
leaq 0x43a68(%rip), %rdi     # 0x7a058
callq 0x21d0
movq %rax, 0x439ec(%rip)     # 0x79fe8
leaq 0x2b871(%rip), %rdi     # 0x61e74
leaq 0x2a485(%rip), %rsi     # 0x60a8f
callq 0x2300
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x439c4(%rip), %rdi     # 0x79fe8
callq 0x2110
movq (%rsp), %rdi
movq %rax, %rdx
movq 0x10(%rsp), %rcx
leaq 0x2b843(%rip), %rsi     # 0x61e7f
movb $0x0, %al
callq 0x23e0
movq 0x8(%rsp), %rdi
callq 0x22c0
xorl %eax, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x328, %rsp            # imm = 0x328
movq %rdi, 0x318(%rsp)
movq %rsi, 0x310(%rsp)
movq 0x318(%rsp), %rdi
leaq 0x29c91(%rip), %rsi     # 0x60317
callq 0x23c0
cmpl $0x0, %eax
je 0x366e1
leaq 0x10(%rsp), %rdi
movq 0x318(%rsp), %rdx
movq 0x310(%rsp), %rcx
leaq 0x29c73(%rip), %rsi     # 0x6031f
movb $0x0, %al
callq 0x2060
leaq 0x10(%rsp), %rdi
callq 0x2240
movl %eax, 0xc(%rsp)
testb $0x1, 0x43998(%rip)     # 0x7a060
je 0x366d4
leaq 0x10(%rsp), %rdi
callq 0x365e0
movl 0xc(%rsp), %eax
movl %eax, 0x324(%rsp)
jmp 0x366ec
movl $0xffffffff, 0x324(%rsp) # imm = 0xFFFFFFFF
movl 0x324(%rsp), %eax
addq $0x328, %rsp            # imm = 0x328
retq
nopl (%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsp, %rdi
movq 0x80(%rsp), %rdx
addq $0x3f6, %rdx            # imm = 0x3F6
leaq 0x2b75e(%rip), %rsi     # 0x61e86
movb $0x0, %al
callq 0x2060
cmpl $0x0, 0x37c72(%rip)     # 0x6e3a8
jg 0x3674c
movq 0x80(%rsp), %rdi
addq $0x50, %rdi
movq %rsp, %rsi
callq 0x36660
movl $0x1, 0x37c52(%rip)     # 0x6e3a8
xorl %eax, %eax
addq $0x88, %rsp
retq
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsp, %rdi
movq 0x80(%rsp), %rdx
addq $0x3f6, %rdx            # imm = 0x3F6
leaq 0x2b712(%rip), %rsi     # 0x61e9a
movb $0x0, %al
callq 0x2060
cmpl $0x1, 0x37c12(%rip)     # 0x6e3a8
jne 0x367ac
movq 0x80(%rsp), %rdi
addq $0x50, %rdi
movq %rsp, %rsi
callq 0x36660
movl $0x0, 0x37bf2(%rip)     # 0x6e3a8
xorl %eax, %eax
addq $0x88, %rsp
retq
// File: 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:
subq $0xb8, %rsp
movq %rdi, 0xa8(%rsp)
movl %esi, 0xa4(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x2280
movq 0xa8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2270
cmpl $0x0, %eax
jne 0x4376f
movq 0x68(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
subq (%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jle 0x43765
movq 0x8(%rsp), %rax
imull $0x3c, 0xa4(%rsp), %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jge 0x43765
movb $0x0, 0xb7(%rsp)
jmp 0x43777
movb $0x1, 0xb7(%rsp)
jmp 0x43777
movb $0x1, 0xb7(%rsp)
movb 0xb7(%rsp), %al
andb $0x1, %al
addq $0xb8, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0xb8, %rsp
movq %rdi, 0xa8(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x2280
movq 0xa8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x2270
movq 0x70(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
subq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x3c, 0x10(%rsp)
jle 0x437e8
movq 0x8(%rsp), %rax
movq %rax, 0x36970(%rip)     # 0x7a158
movq 0x8(%rsp), %rax
cmpq 0x36964(%rip), %rax     # 0x7a158
jne 0x43800
movb $0x0, 0xb7(%rsp)
jmp 0x43814
movq 0x8(%rsp), %rax
movq %rax, 0x3694c(%rip)     # 0x7a158
movb $0x1, 0xb7(%rsp)
movb 0xb7(%rsp), %al
andb $0x1, %al
addq $0xb8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq $0x0, 0x98(%rsp)
leaq 0x1e9d6(%rip), %rdi     # 0x62228
leaq 0x1cab4(%rip), %rsi     # 0x6030d
callq 0x2300
movq %rax, 0x98(%rsp)
cmpq $0x0, 0x98(%rsp)
je 0x43989
movq 0xa0(%rsp), %rdi
callq 0x1ce40
cmpq $0x0, %rax
jbe 0x43987
movl $0x0, 0x2c(%rsp)
movslq 0x2c(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0xa0(%rsp), %rdi
callq 0x1ce40
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jae 0x43985
movq 0x98(%rsp), %rax
movq %rax, (%rsp)
movq 0xa0(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0x1ce60
movq (%rax), %rax
movl $0x15180, %ecx          # imm = 0x15180
cqto
idivq %rcx
cvtsi2sd %rdx, %xmm0
movsd 0x1c81c(%rip), %xmm1    # 0x60110
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0xa0(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0x1ce60
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0xa0(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0x1ce60
movl 0x8(%rax), %eax
movl %eax, 0x1c(%rsp)
movq 0xa0(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0x1ce60
movq (%rsp), %rdi
movsd 0x8(%rsp), %xmm0
movq 0x10(%rsp), %rdx
movl 0x1c(%rsp), %ecx
movss 0xc(%rax), %xmm1
cvtss2sd %xmm1, %xmm1
leaq 0x1e8cb(%rip), %rsi     # 0x62239
movb $0x2, %al
callq 0x23e0
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x43894
jmp 0x43987
jmp 0x43989
cmpq $0x0, 0x98(%rsp)
je 0x439a1
movq 0x98(%rsp), %rdi
callq 0x22c0
movb $0x1, %al
andb $0x1, %al
addq $0xa8, %rsp
retq
nopl (%rax)
// File: 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:
subq $0xd8, %rsp
movq %rdi, 0xd0(%rsp)
movq $0x0, 0xc8(%rsp)
leaq 0x1e856(%rip), %rdi     # 0x62228
leaq 0x1ce2a(%rip), %rsi     # 0x60803
callq 0x2300
movq %rax, 0xc8(%rsp)
leaq 0x60(%rsp), %rdi
xorl %esi, %esi
movl $0x64, %edx
callq 0x2170
cmpq $0x0, 0xc8(%rsp)
je 0x43aae
jmp 0x43a08
leaq 0x60(%rsp), %rdi
movq 0xc8(%rsp), %rdx
movl $0x64, %esi
callq 0x2450
cmpq $0x0, %rax
je 0x43aac
leaq 0x60(%rsp), %rdi
movq %rsp, %rdx
addq $0x3c, %rdx
movq %rsp, %rcx
movq %rsp, %r8
addq $0x14, %r8
movq %rsp, %r9
addq $0x28, %r9
leaq 0x1e800(%rip), %rsi     # 0x6224d
movb $0x0, %al
callq 0x22b0
movl %eax, 0x5c(%rsp)
movq %rsp, %rdi
callq 0x2430
cltq
movq %rax, 0x366f7(%rip)     # 0x7a160
movq %rsp, %rdi
addq $0x14, %rdi
callq 0x2430
movl %eax, 0x366ed(%rip)     # 0x7a168
movq %rsp, %rdi
addq $0x28, %rdi
callq 0x2330
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x366d9(%rip)    # 0x7a16c
movq 0xd0(%rsp), %rdi
leaq 0x366be(%rip), %rsi     # 0x7a160
callq 0x3e9f0
jmp 0x43a08
jmp 0x43aae
cmpq $0x0, 0xc8(%rsp)
je 0x43ac6
movq 0xc8(%rsp), %rdi
callq 0x23d0
movb $0x1, %al
andb $0x1, %al
addq $0xd8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movss %xmm0, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %ecx
xorl %eax, %eax
cmpl 0x18(%rsp), %ecx
movb %al, 0xb(%rsp)
jg 0x43b3b
movslq 0xc(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
callq 0x1ce80
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
setb %al
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %al
testb $0x1, %al
jne 0x43b45
jmp 0x43b7a
movq 0x20(%rsp), %rdi
movslq 0xc(%rsp), %rsi
callq 0x1ce20
movss 0x8(%rax), %xmm0
ucomiss 0x14(%rsp), %xmm0
jbe 0x43b6b
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x43b6d
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x43b07
movl 0x10(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movss %xmm0, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x18(%rsp), %eax
jg 0x43f8a
movq 0x20(%rsp), %rdi
movslq 0xc(%rsp), %rsi
callq 0x1ce20
movss 0x8(%rax), %xmm1
movss 0x14(%rsp), %xmm0
ucomiss %xmm1, %xmm0
jbe 0x43f7b
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x43f7d
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x43f47
movl 0x10(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x2280
leaq 0x20(%rsp), %rdi
callq 0x2250
movq %rax, 0x18(%rsp)
movl 0x2c(%rsp), %eax
movl $0x3c, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x8(%rax)
cmpl $0xb40, 0x2c(%rsp)      # imm = 0xB40
jg 0x444d5
movq 0x18(%rsp), %rax
cmpl $0x18, 0x8(%rax)
jle 0x44494
movq 0x18(%rsp), %rax
movl 0x8(%rax), %ecx
subl $0x18, %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x18(%rsp), %rdi
callq 0x21c0
movq %rax, 0x20(%rsp)
movl 0x2c(%rsp), %eax
movl $0x3c, %ecx
cltd
idivl %ecx
cmpl $0x18, %eax
jle 0x444c4
movq 0x20(%rsp), %rax
addq $0x15180, %rax          # imm = 0x15180
movq %rax, 0x20(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x2250
movq %rax, 0x18(%rsp)
jmp 0x444df
movslq 0x2c(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0xffffffff, 0x10(%rsp) # imm = 0xFFFFFFFF
movl $0x0, 0xc(%rsp)
movslq 0xc(%rsp), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
callq 0x1ce80
movq (%rsp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, 0xb(%rsp)
jae 0x44532
movq 0x30(%rsp), %rdi
movslq 0xc(%rsp), %rsi
callq 0x1ce20
movq (%rax), %rax
cmpq 0x20(%rsp), %rax
setl %al
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %al
testb $0x1, %al
jne 0x4453c
jmp 0x44581
movq 0x30(%rsp), %rdi
movslq 0xc(%rsp), %rsi
callq 0x1ce20
movq (%rax), %rax
movl $0x15180, %ecx          # imm = 0x15180
cqto
idivq %rcx
movq %rdx, %rax
movl $0x3c, %ecx
cqto
idivq %rcx
movl %eax, 0x14(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x444ef
leaq 0x20(%rsp), %rdi
callq 0x2280
leaq 0x20(%rsp), %rdi
callq 0x2250
movq %rax, 0x18(%rsp)
movl 0x10(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x20(%rsp), %rax
xorps %xmm0, %xmm0
movss %xmm0, (%rax)
movslq 0x2c(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
callq 0x1cc80
movq 0x10(%rsp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, 0x1f(%rsp)
jae 0x4462f
movq 0x30(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0x1cca0
movss 0x14(%rax), %xmm0
movss %xmm0, 0xc(%rsp)
movq 0x30(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0x1cca0
movss 0xc(%rsp), %xmm0
ucomiss 0x1c(%rax), %xmm0
seta %al
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x4463c
jmp 0x446bc
movq 0x20(%rsp), %rax
movss (%rax), %xmm0
movss %xmm0, (%rsp)
movq 0x30(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0x1cca0
movss (%rsp), %xmm0
addss 0x14(%rax), %xmm0
movss %xmm0, 0x4(%rsp)
movq 0x30(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0x1cca0
movss 0x4(%rsp), %xmm0
addss 0x24(%rax), %xmm0
movss %xmm0, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0x1cca0
movss 0x8(%rsp), %xmm0
subss 0x1c(%rax), %xmm0
movq 0x20(%rsp), %rax
movss %xmm0, (%rax)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x445ce
movl 0x2c(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x40(%rsp), %rax
xorps %xmm0, %xmm0
movss %xmm0, (%rax)
movss 0x1b912(%rip), %xmm0    # 0x60008
movss %xmm0, 0x3c(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x38(%rsp)
movl $0x0, 0x34(%rsp)
movslq 0x4c(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x50(%rsp), %rdi
callq 0x1cc80
movq 0x28(%rsp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, 0x33(%rsp)
jae 0x4476e
movq 0x50(%rsp), %rdi
movslq 0x4c(%rsp), %rsi
callq 0x1cca0
movss 0x14(%rax), %xmm0
movss %xmm0, 0x24(%rsp)
movq 0x50(%rsp), %rdi
movslq 0x4c(%rsp), %rsi
callq 0x1cca0
movss 0x24(%rsp), %xmm0
ucomiss 0x1c(%rax), %xmm0
seta %al
movb %al, 0x33(%rsp)
movb 0x33(%rsp), %al
testb $0x1, %al
jne 0x4477b
jmp 0x448a3
movq 0x40(%rsp), %rax
movss (%rax), %xmm0
movss %xmm0, 0xc(%rsp)
movq 0x50(%rsp), %rdi
movslq 0x4c(%rsp), %rsi
callq 0x1cca0
movss 0xc(%rsp), %xmm0
addss 0x14(%rax), %xmm0
movss %xmm0, 0x10(%rsp)
movq 0x50(%rsp), %rdi
movslq 0x4c(%rsp), %rsi
callq 0x1cca0
movss 0x10(%rsp), %xmm0
addss 0x24(%rax), %xmm0
movss %xmm0, 0x14(%rsp)
movq 0x50(%rsp), %rdi
movslq 0x4c(%rsp), %rsi
callq 0x1cca0
movss 0x14(%rsp), %xmm0
addss 0x1c(%rax), %xmm0
movq 0x40(%rsp), %rax
movss %xmm0, (%rax)
movss 0x38(%rsp), %xmm0
movss %xmm0, 0x18(%rsp)
movq 0x50(%rsp), %rdi
movslq 0x4c(%rsp), %rsi
callq 0x1cca0
movss 0x18(%rsp), %xmm0
addss 0x14(%rax), %xmm0
movss %xmm0, 0x1c(%rsp)
movq 0x50(%rsp), %rdi
movslq 0x4c(%rsp), %rsi
callq 0x1cca0
movss 0x1c(%rsp), %xmm0
addss 0x24(%rax), %xmm0
movss %xmm0, 0x20(%rsp)
movq 0x50(%rsp), %rdi
movslq 0x4c(%rsp), %rsi
callq 0x1cca0
movss 0x20(%rsp), %xmm0
addss 0x1c(%rax), %xmm0
movss %xmm0, 0x38(%rsp)
xorps %xmm0, %xmm0
ucomiss 0x38(%rsp), %xmm0
jb 0x4486e
xorps %xmm0, %xmm0
movss %xmm0, 0x38(%rsp)
jmp 0x44891
movss 0x38(%rsp), %xmm0
ucomiss 0x3c(%rsp), %xmm0
jbe 0x4488f
movss 0x38(%rsp), %xmm0
movss %xmm0, 0x3c(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x44891
jmp 0x44893
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x4470d
movl 0x34(%rsp), %eax
addq $0x58, %rsp
retq
nopl (%rax)
// File: Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_InitHooks
CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks* hooks)
{
    if (hooks == NULL)
    {
        /* Reset hooks */
        global_hooks.allocate = malloc;
        global_hooks.deallocate = free;
        global_hooks.reallocate = realloc;
        return;
    }

    global_hooks.allocate = malloc;
    if (hooks->malloc_fn != NULL)
    {
        global_hooks.allocate = hooks->malloc_fn;
    }

    global_hooks.deallocate = free;
    if (hooks->free_fn != NULL)
    {
        global_hooks.deallocate = hooks->free_fn;
    }

    /* use realloc only if both free and malloc are used */
    global_hooks.reallocate = NULL;
    if ((global_hooks.allocate == malloc) && (global_hooks.deallocate == free))
    {
        global_hooks.reallocate = realloc;
    }
}

// Assembly:
movq %rdi, -0x8(%rsp)
cmpq $0x0, -0x8(%rsp)
jne 0x58f0c
movq 0x150e4(%rip), %rax     # 0x6dfc8
movq %rax, 0x154ed(%rip)     # 0x6e3d8
movq 0x150ce(%rip), %rax     # 0x6dfc0
movq %rax, 0x154e7(%rip)     # 0x6e3e0
movq 0x150d8(%rip), %rax     # 0x6dfd8
movq %rax, 0x154e1(%rip)     # 0x6e3e8
jmp 0x58f97
movq 0x150b5(%rip), %rax     # 0x6dfc8
movq %rax, 0x154be(%rip)     # 0x6e3d8
movq -0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x58f34
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x154a4(%rip)     # 0x6e3d8
movq 0x15085(%rip), %rax     # 0x6dfc0
movq %rax, 0x1549e(%rip)     # 0x6e3e0
movq -0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x58f5e
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x15482(%rip)     # 0x6e3e0
movq $0x0, 0x1547f(%rip) # 0x6e3e8
movq 0x15058(%rip), %rax     # 0x6dfc8
cmpq %rax, 0x15461(%rip)     # 0x6e3d8
jne 0x58f97
movq 0x15040(%rip), %rax     # 0x6dfc0
cmpq %rax, 0x15459(%rip)     # 0x6e3e0
jne 0x58f97
movq 0x15048(%rip), %rax     # 0x6dfd8
movq %rax, 0x15451(%rip)     # 0x6e3e8
retq
nopl (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x59074
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movl 0x18(%rax), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
jne 0x58ff7
movq 0x10(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x58ff7
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x58fa0
movq 0x10(%rsp), %rax
movl 0x18(%rax), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
jne 0x59027
movq 0x10(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x59027
movq 0x153c4(%rip), %rax     # 0x6e3e0
movq 0x10(%rsp), %rcx
movq 0x20(%rcx), %rdi
callq *%rax
movq 0x10(%rsp), %rax
movl 0x18(%rax), %eax
andl $0x200, %eax            # imm = 0x200
cmpl $0x0, %eax
jne 0x59057
movq 0x10(%rsp), %rax
cmpq $0x0, 0x38(%rax)
je 0x59057
movq 0x15394(%rip), %rax     # 0x6e3e0
movq 0x10(%rsp), %rcx
movq 0x38(%rcx), %rdi
callq *%rax
movq 0x15382(%rip), %rax     # 0x6e3e0
movq 0x10(%rsp), %rdi
callq *%rax
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x58fb2
addq $0x18, %rsp
retq
nopl (%rax)
// File: Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_SetNumberHelper
CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON *object, double number)
{
    if (number >= INT_MAX)
    {
        object->valueint = INT_MAX;
    }
    else if (number <= (double)INT_MIN)
    {
        object->valueint = INT_MIN;
    }
    else
    {
        object->valueint = (int)number;
    }

    return object->valuedouble = number;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movsd %xmm0, -0x10(%rsp)
movsd -0x10(%rsp), %xmm0
movsd 0x972f(%rip), %xmm1     # 0x627c8
ucomisd %xmm1, %xmm0
jb 0x590ad
movq -0x8(%rsp), %rax
movl $0x7fffffff, 0x28(%rax) # imm = 0x7FFFFFFF
jmp 0x590db
movsd 0x971b(%rip), %xmm0     # 0x627d0
ucomisd -0x10(%rsp), %xmm0
jb 0x590cb
movq -0x8(%rsp), %rax
movl $0x80000000, 0x28(%rax) # imm = 0x80000000
jmp 0x590d9
cvttsd2si -0x10(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x28(%rax)
jmp 0x590db
movsd -0x10(%rsp), %xmm0
movq -0x8(%rsp), %rax
movsd %xmm0, 0x30(%rax)
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x18(%rsp), %rax
movl 0x18(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x59129
movq 0x18(%rsp), %rax
movl 0x18(%rax), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0x59137
movq $0x0, 0x20(%rsp)
jmp 0x591dd
movq 0x10(%rsp), %rdi
callq 0x2130
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x2130
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
ja 0x59182
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x2290
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x591dd
movq 0x10(%rsp), %rdi
leaq 0x1524a(%rip), %rsi     # 0x6e3d8
callq 0x591f0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x591ab
movq $0x0, 0x20(%rsp)
jmp 0x591dd
movq 0x18(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x591c5
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x59280
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, (%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x59222
movq $0x0, 0x20(%rsp)
jmp 0x59276
movq 0x18(%rsp), %rdi
callq 0x2130
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rdi
callq *%rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x5925a
movq $0x0, 0x20(%rsp)
jmp 0x59276
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x2220
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
// File: Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_ParseWithOpts
CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated)
{
    size_t buffer_length;

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

    /* Adding null character size due to require_null_terminated. */
    buffer_length = strlen(value) + sizeof("");

    return cJSON_ParseWithLengthOpts(value, buffer_length, return_parse_end, require_null_terminated);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
xorl %eax, %eax
cmpq 0x18(%rsp), %rax
jne 0x592c6
movq $0x0, 0x20(%rsp)
jmp 0x592f4
movq 0x18(%rsp), %rdi
callq 0x2130
addq $0x1, %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
movq (%rsp), %rsi
movq 0x10(%rsp), %rdx
movl 0xc(%rsp), %ecx
callq 0x59300
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_New_Item(internal_hooks const*)
static cJSON *cJSON_New_Item(const internal_hooks * const hooks)
{
    cJSON* node = (cJSON*)hooks->allocate(sizeof(cJSON));
    if (node)
    {
        memset(node, '\0', sizeof(cJSON));
    }

    return node;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl $0x40, %edi
callq *(%rax)
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x59533
movq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x2170
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: 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:
movq %rdi, -0x10(%rsp)
cmpq $0x0, -0x10(%rsp)
je 0x59848
movq -0x10(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x59856
movq $0x0, -0x8(%rsp)
jmp 0x5991e
cmpq $0x0, -0x10(%rsp)
je 0x59876
movq -0x10(%rsp), %rax
movq 0x10(%rax), %rax
addq $0x0, %rax
movq -0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x59885
movq -0x10(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x5991e
jmp 0x59887
xorl %eax, %eax
cmpq $0x0, -0x10(%rsp)
movb %al, -0x11(%rsp)
je 0x598d2
movq -0x10(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x0, %rcx
movq -0x10(%rsp), %rdx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, -0x11(%rsp)
jae 0x598d2
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq -0x10(%rsp), %rcx
movq 0x10(%rcx), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x20, %eax
setle %al
movb %al, -0x11(%rsp)
movb -0x11(%rsp), %al
testb $0x1, %al
jne 0x598dc
jmp 0x598ef
movq -0x10(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
jmp 0x59887
movq -0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x59914
movq -0x10(%rsp), %rax
movq 0x10(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: Eba-M[P]E3DC-Control/cJSON.c
// Function: skip_utf8_bom(parse_buffer*)
static parse_buffer *skip_utf8_bom(parse_buffer * const buffer)
{
    if ((buffer == NULL) || (buffer->content == NULL) || (buffer->offset != 0))
    {
        return NULL;
    }

    if (can_access_at_index(buffer, 4) && (strncmp((const char*)buffer_at_offset(buffer), "\xEF\xBB\xBF", 3) == 0))
    {
        buffer->offset += 3;
    }

    return buffer;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x59958
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x59958
movq 0x8(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x59963
movq $0x0, 0x10(%rsp)
jmp 0x599c5
cmpq $0x0, 0x8(%rsp)
je 0x599bb
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
addq $0x4, %rax
movq 0x8(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x599bb
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rax
addq 0x10(%rax), %rdi
leaq 0x8fb6(%rip), %rsi      # 0x62951
movl $0x3, %edx
callq 0x2140
cmpl $0x0, %eax
jne 0x599bb
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x3, %rcx
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movl %esi, 0x44(%rsp)
movl %edx, 0x40(%rsp)
movq %rsp, %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x2170
cmpl $0x0, 0x44(%rsp)
jge 0x59c75
movq $0x0, 0x50(%rsp)
jmp 0x59d13
movq 0x1475c(%rip), %rax     # 0x6e3d8
movslq 0x44(%rsp), %rdi
callq *%rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x59c99
movq $0x0, 0x50(%rsp)
jmp 0x59d13
movslq 0x44(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movl $0x0, 0x20(%rsp)
movl 0x40(%rsp), %eax
movl %eax, 0x24(%rsp)
movq 0x14715(%rip), %rax     # 0x6e3d8
movq %rax, 0x28(%rsp)
movq 0x14711(%rip), %rax     # 0x6e3e0
movq %rax, 0x30(%rsp)
movq 0x1470d(%rip), %rax     # 0x6e3e8
movq %rax, 0x38(%rsp)
movq 0x48(%rsp), %rdi
movq %rsp, %rsi
callq 0x59d20
cmpl $0x0, %eax
jne 0x59d0a
movq 0x146e7(%rip), %rax     # 0x6e3e0
movq (%rsp), %rdi
callq *%rax
movq $0x0, 0x50(%rsp)
jmp 0x59d13
movq (%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax)
// File: 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 $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movl %edx, 0x4c(%rsp)
movl %ecx, 0x48(%rsp)
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x2170
cmpl $0x0, 0x4c(%rsp)
jl 0x59fd6
cmpq $0x0, 0x50(%rsp)
jne 0x59fe0
movl $0x0, 0x64(%rsp)
jmp 0x5a044
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movslq 0x4c(%rsp), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movl $0x1, 0x28(%rsp)
movl 0x48(%rsp), %eax
movl %eax, 0x2c(%rsp)
movq 0x143c4(%rip), %rax     # 0x6e3d8
movq %rax, 0x30(%rsp)
movq 0x143c0(%rip), %rax     # 0x6e3e0
movq %rax, 0x38(%rsp)
movq 0x143bc(%rip), %rax     # 0x6e3e8
movq %rax, 0x40(%rsp)
movq 0x58(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x59d20
movl %eax, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nopl (%rax)
// File: Eba-M[P]E3DC-Control/cJSON.c
// Function: cJSON_GetArraySize
CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON *array)
{
    cJSON *child = NULL;
    size_t size = 0;

    if (array == NULL)
    {
        return 0;
    }

    child = array->child;

    while(child != NULL)
    {
        size++;
        child = child->next;
    }

    /* FIXME: Can overflow here. Cannot be fixed without breaking the API */

    return (int)size;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq $0x0, -0x18(%rsp)
movq $0x0, -0x20(%rsp)
cmpq $0x0, -0x10(%rsp)
jne 0x5a079
movl $0x0, -0x4(%rsp)
jmp 0x5a0b5
movq -0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rsp)
cmpq $0x0, -0x18(%rsp)
je 0x5a0ac
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rsp)
jmp 0x5a087
movq -0x20(%rsp), %rax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw (%rax,%rax)
// File: Eba-M[P]E3DC-Control/cJSON.c
// Function: get_array_item(cJSON const*, unsigned long)
static cJSON* get_array_item(const cJSON *array, size_t index)
{
    cJSON *current_child = NULL;

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

    current_child = array->child;
    while ((current_child != NULL) && (index > 0))
    {
        index--;
        current_child = current_child->next;
    }

    return current_child;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq $0x0, -0x20(%rsp)
cmpq $0x0, -0x10(%rsp)
jne 0x5a126
movq $0x0, -0x8(%rsp)
jmp 0x5a180
movq -0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rsp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rsp)
movb %al, -0x21(%rsp)
je 0x5a14f
cmpq $0x0, -0x18(%rsp)
seta %al
movb %al, -0x21(%rsp)
movb -0x21(%rsp), %al
testb $0x1, %al
jne 0x5a159
jmp 0x5a176
movq -0x18(%rsp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rsp)
movq -0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rsp)
jmp 0x5a134
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq $0x0, 0x10(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x5a1eb
cmpq $0x0, 0x20(%rsp)
jne 0x5a1f9
movq $0x0, 0x30(%rsp)
jmp 0x5a2d9
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x1c(%rsp)
je 0x5a268
jmp 0x5a210
xorl %eax, %eax
cmpq $0x0, 0x10(%rsp)
movb %al, 0xf(%rsp)
je 0x5a24d
movq 0x10(%rsp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x38(%rcx)
movb %al, 0xf(%rsp)
je 0x5a24d
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rsi
callq 0x23c0
cmpl $0x0, %eax
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x5a257
jmp 0x5a266
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x5a210
jmp 0x5a2b0
jmp 0x5a26a
xorl %eax, %eax
cmpq $0x0, 0x10(%rsp)
movb %al, 0xe(%rsp)
je 0x5a295
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rsi
callq 0x5e5a0
cmpl $0x0, %eax
setne %al
movb %al, 0xe(%rsp)
movb 0xe(%rsp), %al
testb $0x1, %al
jne 0x5a29f
jmp 0x5a2ae
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x5a26a
jmp 0x5a2b0
cmpq $0x0, 0x10(%rsp)
je 0x5a2c4
movq 0x10(%rsp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x5a2cf
movq $0x0, 0x30(%rsp)
jmp 0x5a2d9
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Eba-M[P]E3DC-Control/cJSON.c
// Function: add_item_to_array(cJSON*, cJSON*)
static cJSON_bool add_item_to_array(cJSON *array, cJSON *item)
{
    cJSON *child = NULL;

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

    child = array->child;
    /*
     * To find the last item in array quickly, we use prev in array
     */
    if (child == NULL)
    {
        /* list is empty, start new one */
        array->child = item;
        item->prev = item;
        item->next = NULL;
    }
    else
    {
        /* append to the end */
        if (child->prev)
        {
            suffix_object(child->prev, item);
            array->child->prev = item;
        }
    }

    return true;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x5a3c3
cmpq $0x0, 0x18(%rsp)
je 0x5a3c3
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
jne 0x5a3cd
movl $0x0, 0x24(%rsp)
jmp 0x5a448
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x5a40d
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
jmp 0x5a440
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x5a43e
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x5b6e0
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0x5a440
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movl %r8d, 0x1c(%rsp)
movq $0x0, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpq $0x0, 0x38(%rsp)
je 0x5a4f2
cmpq $0x0, 0x30(%rsp)
je 0x5a4f2
cmpq $0x0, 0x28(%rsp)
je 0x5a4f2
movq 0x38(%rsp), %rax
cmpq 0x28(%rsp), %rax
jne 0x5a4ff
movl $0x0, 0x44(%rsp)
jmp 0x5a5be
cmpl $0x0, 0x1c(%rsp)
je 0x5a528
movq 0x30(%rsp), %rdi
callq 0x5b4e0
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movl 0x18(%rax), %eax
orl $0x200, %eax            # imm = 0x200
movl %eax, 0xc(%rsp)
jmp 0x5a55f
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x591f0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x5a54e
movl $0x0, 0x44(%rsp)
jmp 0x5a5be
movq 0x28(%rsp), %rax
movl 0x18(%rax), %eax
andl $0xfffffdff, %eax       # imm = 0xFFFFFDFF
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rax
movl 0x18(%rax), %eax
andl $0x200, %eax            # imm = 0x200
cmpl $0x0, %eax
jne 0x5a591
movq 0x28(%rsp), %rax
cmpq $0x0, 0x38(%rax)
je 0x5a591
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rsp), %rcx
movq 0x38(%rcx), %rdi
callq *%rax
movq 0x10(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x38(%rax)
movl 0xc(%rsp), %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x18(%rax)
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x5a390
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw (%rax,%rax)