LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/trumabrat[P]GrandProjet/chaine.c
// Function: lectureChaines
Chaines* lectureChaines(FILE *f){

    Chaines *res = (Chaines *)calloc(1,sizeof(Chaines));
    int nbChaine, gamma;
    int num, nbPoints;
    double x, y;

    // recuperer le nombre de chaines
    fscanf(f," %*s %d" , &nbChaine);

    // recuperer la valeur de gamma
    fscanf(f," %*s %d" , &gamma);

    res->nbChaines = nbChaine;
    res->gamma = gamma;
    CellChaine *liste_chaine = NULL;
    CellChaine *chaine_cur = NULL;
    CellPoint *liste_point = NULL;
    
    // pour chaque chaine
    for(int j =  0 ;  j < nbChaine ; j++){
        chaine_cur = (CellChaine *)calloc(1, sizeof(CellChaine));
        // on prend le nombre de points
        fscanf(f," %d %d", &num, &nbPoints);
        chaine_cur->numero = num;
        liste_point = NULL;

        // pour chaque point d'une chaine
        for(int i = 0 ; i < nbPoints; i++){
            CellPoint *point = (CellPoint*)malloc(sizeof(CellPoint));
            fscanf(f,"%lf %lf ", &x, &y);
            point->x = x;
            point->y = y;
            point->suiv = liste_point;
            liste_point = point;
        }

        // on passe a suivant
        chaine_cur->points = liste_point;
        chaine_cur->suiv = liste_chaine;
        liste_chaine = chaine_cur;
    }
    
    res->chaines = liste_chaine;
    return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
movl $0x1, %edi
movl $0x10, %esi
callq 0x10c0
movq %rax, %r13
leaq 0x29a6(%rip), %rbx      # 0x40f0
leaq 0xc(%rsp), %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x1050
leaq 0x44(%rsp), %r12
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x1050
movl (%r15), %eax
movl %eax, 0x4(%r13)
movl (%r12), %ecx
movq %r13, 0x18(%rsp)
movl %ecx, (%r13)
testl %eax, %eax
jle 0x186f
xorl %ecx, %ecx
xorl %eax, %eax
movq %r14, 0x10(%rsp)
movq %rcx, 0x28(%rsp)
movl %eax, 0x4(%rsp)
movl $0x1, %edi
movl $0x18, %esi
callq 0x10c0
movq %rax, %rbx
movq %r14, %rdi
leaq 0x293a(%rip), %rsi      # 0x40f8
leaq 0x8(%rsp), %rdx
movq %rsp, %rcx
xorl %eax, %eax
callq 0x1050
movl 0x8(%rsp), %eax
movq %rbx, 0x20(%rsp)
movl %eax, (%rbx)
cmpl $0x0, (%rsp)
jle 0x1840
xorl %r12d, %r12d
xorl %ebp, %ebp
leaq 0x38(%rsp), %r15
leaq 0x30(%rsp), %rbx
movq 0x10(%rsp), %r14
movl $0x18, %edi
callq 0x10e0
movq %rax, %r13
movq %r14, %rdi
leaq 0x28f6(%rip), %rsi      # 0x40ff
movq %r15, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x1050
movsd 0x38(%rsp), %xmm0
movsd %xmm0, (%r13)
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x8(%r13)
movq %rbp, 0x10(%r13)
incl %r12d
movq %r13, %rbp
cmpl (%rsp), %r12d
jl 0x17f2
jmp 0x1848
xorl %r13d, %r13d
movq 0x10(%rsp), %r14
movq 0x20(%rsp), %rdx
movq %r13, 0x8(%rdx)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rdx)
movl 0x4(%rsp), %eax
incl %eax
movq %rdx, %rcx
cmpl 0xc(%rsp), %eax
jl 0x1799
jmp 0x1871
xorl %edx, %edx
movq 0x18(%rsp), %rax
movq %rdx, 0x8(%rax)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/trumabrat[P]GrandProjet/chaine.c
// Function: ecrireChaines
void ecrireChaines(Chaines *C,FILE *f){
    if (C==NULL || f==NULL)
        return;
    fprintf(f, "NbChain: %d\n", C->nbChaines);
    fprintf(f, "Gamma: %d\n", C->gamma);
    CellChaine *tmp = C->chaines;
    
    while (tmp)
    {
        CellPoint *tmp_points = tmp->points;
        int counter = 0;
        //On fait un premier tour pour obtenir le nombre des points de la chaine
        while(tmp_points){
            counter++;
            tmp_points = tmp_points->suiv;
        }
        //On ecrit le numero de la chaine, et le nombre des points
        fprintf(f,"%d %d ", tmp->numero, counter);

        //Ici, on va ecrire les coordonnées des points
        tmp_points = tmp->points;
        while(tmp_points){
            fprintf(f,"%.2lf %.2lf ", tmp_points->x, tmp_points->y);
            tmp_points = tmp_points->suiv;
        }

        //On saute une ligne quand on finit avec tous les points de la chaine
        fprintf(f, "\n");
        tmp = tmp->suiv;
    }
}

// Assembly:
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x1961
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x4(%rdi), %edx
leaq 0x2852(%rip), %rsi      # 0x4108
movq %rbx, %rdi
xorl %eax, %eax
callq 0x10d0
movl (%r14), %edx
leaq 0x284b(%rip), %rsi      # 0x4115
movq %rbx, %rdi
xorl %eax, %eax
callq 0x10d0
movq 0x8(%r14), %r12
testq %r12, %r12
je 0x1958
leaq 0x283c(%rip), %r14      # 0x4120
leaq 0x283c(%rip), %r15      # 0x4127
movq 0x8(%r12), %rax
movl $0x0, %ecx
testq %rax, %rax
je 0x1907
xorl %ecx, %ecx
incl %ecx
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x18fc
movl (%r12), %edx
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x10d0
movq 0x8(%r12), %r13
testq %r13, %r13
je 0x1941
movsd (%r13), %xmm0
movsd 0x8(%r13), %xmm1
movq %rbx, %rdi
movq %r15, %rsi
movb $0x2, %al
callq 0x10d0
movq 0x10(%r13), %r13
jmp 0x191d
movl $0xa, %edi
movq %rbx, %rsi
callq 0x10b0
movq 0x10(%r12), %r12
testq %r12, %r12
jne 0x18eb
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/trumabrat[P]GrandProjet/chaine.c
// Function: longueurChaine
double longueurChaine(CellChaine* c){
    double res = 0.;
    if(c){
        CellPoint* cur = c->points;
        CellPoint* next = c->points->suiv;
        while(next){
            res += distancePoints(cur, next);
            cur = next;
            next = next->suiv;
        }
    }
    return res;
}

// Assembly:
xorpd %xmm0, %xmm0
testq %rdi, %rdi
je 0x1c01
movq 0x8(%rdi), %rcx
movq 0x10(%rcx), %rax
testq %rax, %rax
je 0x1c01
movsd (%rcx), %xmm1
movsd (%rax), %xmm2
subsd %xmm2, %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm1
sqrtsd %xmm1, %xmm1
addsd %xmm1, %xmm0
movq 0x10(%rax), %rax
movapd %xmm2, %xmm1
testq %rax, %rax
jne 0x1bdc
retq
// File: /workspace/github_c_makefile_star2_O3/trumabrat[P]GrandProjet/chaine.c
// Function: longueurTotale
double longueurTotale(Chaines *C){
    double res = 0.;
    if(C){
        CellChaine* ch = C->chaines;
        while(ch){
            res += longueurChaine(ch);
            ch = ch->suiv;
        }
    }
    return res;
}

// Assembly:
xorpd %xmm0, %xmm0
testq %rdi, %rdi
je 0x1c58
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x1c58
movq 0x8(%rax), %rdx
movq 0x10(%rdx), %rcx
xorpd %xmm1, %xmm1
testq %rcx, %rcx
je 0x1c4e
movsd (%rdx), %xmm2
movsd (%rcx), %xmm3
subsd %xmm3, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm2
sqrtsd %xmm2, %xmm2
addsd %xmm2, %xmm1
movq 0x10(%rcx), %rcx
movapd %xmm3, %xmm2
testq %rcx, %rcx
jne 0x1c29
addsd %xmm1, %xmm0
movq 0x10(%rax), %rax
jmp 0x1c0f
retq
// File: /workspace/github_c_makefile_star2_O3/trumabrat[P]GrandProjet/chaine.c
// Function: liberer_cell_point
void liberer_cell_point(CellPoint *cellP){
    //liberation du cellPoint
    if (cellP->suiv){
        liberer_cell_point(cellP->suiv);
    }
    free(cellP);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x1c98
callq 0x1c86
movq %rbx, %rdi
popq %rbx
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O3/trumabrat[P]GrandProjet/chaine.c
// Function: liberer_cell_chaine
void liberer_cell_chaine(CellChaine *cellC){
    //liberation du CellChaine
    if(!cellC) return;
    if (cellC->suiv){
        liberer_cell_chaine(cellC->suiv);
    }
    liberer_cell_point(cellC->points);
    free(cellC);
}

// Assembly:
testq %rdi, %rdi
je 0x1cca
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x1cb8
callq 0x1ca1
movq 0x8(%rbx), %rdi
callq 0x1c86
movq %rbx, %rdi
popq %rbx
jmp 0x1030
retq
// File: /workspace/github_c_makefile_star2_O3/trumabrat[P]GrandProjet/reseau.c
// Function: rechercheCreeNoeudListe
Noeud* rechercheCreeNoeudListe(Reseau *R, double x, double y){
    int i;
    CellNoeud* cellnoeud = R->noeuds;
    Noeud* noeud = NULL;

    // recherche dans la liste
    for (i = 0; i < R->nbNoeuds && cellnoeud; i++, cellnoeud = cellnoeud->suiv)
    {
        noeud = cellnoeud->nd;
        if(fabs(noeud->x - x) < DOUBLE_PRECISION && fabs(noeud->y - y) < DOUBLE_PRECISION){
            return noeud;
        }
    }

    // creation d'un nouveau noeud et ajout dans le reseau
    Noeud* newNoeud = creerNoeud(++R->nbNoeuds, x, y);
    CellNoeud* newCellNoeud = (CellNoeud*) calloc(1, sizeof(CellNoeud));
    newCellNoeud->nd = newNoeud;
    newCellNoeud->suiv = R->noeuds;
    R->noeuds = newCellNoeud;
    return newNoeud;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl (%rdi), %ebp
movq 0x8(%rdi), %r15
testl %ebp, %ebp
setg %al
testq %r15, %r15
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x1d5b
movl $0x1, %eax
movapd 0x242a(%rip), %xmm4     # 0x4140
movsd 0x2432(%rip), %xmm3     # 0x4150
movq %r15, %rcx
movq (%rcx), %r14
movsd 0x8(%r14), %xmm2
subsd %xmm0, %xmm2
andpd %xmm4, %xmm2
ucomisd %xmm2, %xmm3
jbe 0x1d4c
movsd 0x10(%r14), %xmm2
subsd %xmm1, %xmm2
andpd %xmm4, %xmm2
ucomisd %xmm2, %xmm3
ja 0x1daf
cmpl %ebp, %eax
jge 0x1d5b
movq 0x8(%rcx), %rcx
incl %eax
testq %rcx, %rcx
jne 0x1d21
incl %ebp
movl %ebp, (%rbx)
movl $0x1, %edi
movl $0x20, %esi
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
callq 0x10c0
movq %rax, %r14
movl %ebp, (%rax)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rax)
movl $0x1, %edi
movl $0x10, %esi
callq 0x10c0
movq %r14, (%rax)
movq %r15, 0x8(%rax)
movq %rax, 0x8(%rbx)
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/trumabrat[P]GrandProjet/reseau.c
// Function: ajouterVoisin
Noeud* ajouterVoisin(Noeud* prev, Noeud* next){
    // verification
    if(!next) return NULL;

    // si les deux sont deja voisins, on renvoie Noeud next directement
    CellNoeud* tmp = prev->voisins;
    while(tmp){
        if(tmp->nd == next){
            return next;
        }
        tmp = tmp->suiv;
    }

    // Sinon, on cree CellNoeud correspondants et tisse les liens
    CellNoeud* cellN = creerCellNoeud(next, prev->voisins);
    prev->voisins = cellN;
    next->voisins = creerCellNoeud(prev, next->voisins);

    return next;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1e85
movq %rdi, %r14
movq 0x18(%rdi), %r15
testq %r15, %r15
je 0x1e4d
movq %r15, %rax
cmpq %rbx, (%rax)
je 0x1e85
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x1e3f
movl $0x1, %edi
movl $0x10, %esi
callq 0x10c0
movq %rbx, (%rax)
movq %r15, 0x8(%rax)
movq %rax, 0x18(%r14)
movq 0x18(%rbx), %r15
movl $0x1, %edi
movl $0x10, %esi
callq 0x10c0
movq %r14, (%rax)
movq %r15, 0x8(%rax)
movq %rax, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/trumabrat[P]GrandProjet/reseau.c
// Function: nbLiaisons
int nbLiaisons(Reseau *R){ 
    int cnt = 0;
    CellNoeud *tmp = R->noeuds;
    while (tmp)
    {
        CellNoeud *voisins = tmp->nd->voisins;
        while(voisins){
            cnt++;
            voisins = voisins->suiv;
        }
        tmp = tmp->suiv;
    }

    //on va diviser le compteur par 2, car on a compté chaque liaison 2 fois
    return (cnt/2);
}

// Assembly:
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x205e
xorl %ecx, %ecx
movq (%rax), %rdx
movq 0x18(%rdx), %rdx
testq %rdx, %rdx
je 0x204b
incl %ecx
movq 0x8(%rdx), %rdx
jmp 0x203e
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x2037
movl %ecx, %eax
shrl $0x1f, %eax
addl %ecx, %eax
sarl %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/trumabrat[P]GrandProjet/reseau.c
// Function: liberation_chaine_CellNoeud
void liberation_chaine_CellNoeud(CellNoeud *Cells){
    CellNoeud* tmp = NULL;
    while(Cells){
        tmp = Cells;
        Cells = Cells->suiv;
        free(tmp);
    }
}

// Assembly:
testq %rdi, %rdi
je 0x2452
pushq %rbx
movq 0x8(%rdi), %rbx
callq 0x1030
movq %rbx, %rdi
testq %rbx, %rbx
jne 0x2440
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/trumabrat[P]GrandProjet/reseau.c
// Function: liberation_cell_noeud
void liberation_cell_noeud(CellNoeud *noeuds){
    //liberations des noeuds dans CellNoeuds
    //on ne s'occupe pas des voisins puisqu'il se trouvent dans les suivants de CellNoeuds aussi
    if(!noeuds) return;
    if(noeuds->suiv){
        liberation_cell_noeud(noeuds->suiv);
    }
    liberation_chaine_CellNoeud(noeuds->nd->voisins);
    free(noeuds->nd);
    free(noeuds);
}

// Assembly:
testq %rdi, %rdi
je 0x24a4
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x246d
callq 0x2453
movq (%rbx), %rax
movq 0x18(%rax), %rdi
testq %rdi, %rdi
je 0x248d
movq 0x8(%rdi), %r14
callq 0x1030
movq %r14, %rdi
testq %r14, %r14
jne 0x2479
movq (%rbx), %rax
movq %rax, %rdi
callq 0x1030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1030
retq
// File: /workspace/github_c_makefile_star2_O3/trumabrat[P]GrandProjet/reseau.c
// Function: liberation_cell_commodite
void liberation_cell_commodite(CellCommodite *cellC){
    if(!cellC) return;
    //liberation des commodites, les extremites sont liberes par liberations cell noeuds
    if (cellC->suiv){
        liberation_cell_commodite(cellC->suiv);
    }
    free(cellC);
}

// Assembly:
testq %rdi, %rdi
je 0x24c5
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x24bc
callq 0x24a5
movq %rbx, %rdi
popq %rbx
jmp 0x1030
retq
// File: /workspace/github_c_makefile_star2_O3/trumabrat[P]GrandProjet/reseau.c
// Function: liberation_reseau
void liberation_reseau(Reseau *R){
    //liberation du reseau
    liberation_cell_commodite(R->commodites);
    liberation_cell_noeud(R->noeuds);
    free(R);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x24a5
movq 0x8(%rbx), %rdi
callq 0x2453
movq %rbx, %rdi
popq %rbx
jmp 0x1030
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/trumabrat[P]GrandProjet/Hachage.c
// Function: creerTableHachage
TableHachage* creerTableHachage(int taille){
    TableHachage* res = (TableHachage*) calloc(1, sizeof(TableHachage));
    assert(res);
    res->taille = taille;
    res->tableHachageNoeud = calloc(taille, sizeof(CellNoeud*));
    assert(res->tableHachageNoeud);
    return res;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebp
movl $0x1, %edi
movl $0x10, %esi
callq 0x10c0
testq %rax, %rax
je 0x25be
movq %rax, %rbx
movl %ebp, (%rax)
movslq %ebp, %rdi
movl $0x8, %esi
callq 0x10c0
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x25dd
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1c9f(%rip), %rdi      # 0x4264
leaq 0x1c9c(%rip), %rsi      # 0x4268
leaq 0x1c9f(%rip), %rcx      # 0x4272
movl $0x18, %edx
callq 0x10a0
leaq 0x1cb3(%rip), %rdi      # 0x4297
leaq 0x1c7d(%rip), %rsi      # 0x4268
leaq 0x1c80(%rip), %rcx      # 0x4272
movl $0x1b, %edx
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O3/trumabrat[P]GrandProjet/Hachage.c
// Function: liberer_tableHachage
void liberer_tableHachage(TableHachage* H){
    if(!H)return;
    CellNoeud* cur = NULL;
    CellNoeud* tmp = NULL;

    for (int i = 0; i < H->taille; i++)
    {
        liberation_chaine_CellNoeud(H->tableHachageNoeud[i]);
    }
    free(H->tableHachageNoeud);
    free(H);
}

// Assembly:
testq %rdi, %rdi
je 0x294d
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, (%rdi)
jle 0x2935
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x243a
incq %r14
movslq (%rbx), %rax
cmpq %rax, %r14
jl 0x291d
movq 0x8(%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1030
retq
nop
// File: /workspace/github_c_makefile_star2_O3/trumabrat[P]GrandProjet/ArbreQuat.c
// Function: creerArbreQuat
ArbreQuat *creerArbreQuat(double xc, double yc, double coteX, double coteY){
    /*Création simple d'un ArbreQuat*/
    ArbreQuat *new = (ArbreQuat*) calloc(1,sizeof(ArbreQuat));
    new->xc = xc;
    new->yc = yc;
    new->coteX = coteX;
    new->coteY = coteY;

    new->noeud = NULL;
    new->ne = NULL;
    new->no = NULL;
    new->se = NULL;
    new->so = NULL;

    return new;
}

// Assembly:
subq $0x28, %rsp
movsd %xmm3, 0x20(%rsp)
movsd %xmm2, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movl $0x1, %edi
movl $0x48, %esi
callq 0x10c0
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x10(%rax)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x18(%rax)
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/trumabrat[P]GrandProjet/ArbreQuat.c
// Function: lancerRecherche
Noeud *lancerRecherche(Reseau *R, ArbreQuat *pere, double x, double y){
    //On va utiliser cette fonction pour trouver ou faut t'il continuer de cherche à partir de la racine du tout debut

    //cas sud-ouest
    if (x < pere->xc && y < pere->yc)
    {
        return rechercheCreeNoeudArbre(R, &(pere->so), pere, x, y);
    }

    //cas sud-est
    if (x >= pere->xc && y < pere->yc){
        return rechercheCreeNoeudArbre(R, &(pere->se), pere, x, y);
    }

    //cas nord-ouest
    if (x < pere->xc && y >= pere->yc){
        return rechercheCreeNoeudArbre(R, &(pere->no), pere, x, y);
    }

    //cas nord-est
    if(x >= pere->xc && y >= pere->yc){
        return rechercheCreeNoeudArbre(R, &(pere->ne), pere, x, y);
    }

    //jamais verifié
    return NULL;
}

// Assembly:
movq %rsi, %rdx
movsd (%rsi), %xmm2
ucomisd %xmm0, %xmm2
jbe 0x2ebe
movsd 0x8(%rdx), %xmm3
movl $0x28, %esi
ucomisd %xmm1, %xmm3
ja 0x2efb
ucomisd %xmm2, %xmm0
jb 0x2ed4
movsd 0x8(%rdx), %xmm3
movl $0x30, %esi
ucomisd %xmm1, %xmm3
ja 0x2efb
ucomisd %xmm0, %xmm2
jbe 0x2ee6
movl $0x38, %esi
ucomisd 0x8(%rdx), %xmm1
jae 0x2efb
ucomisd %xmm2, %xmm0
jb 0x2ef8
movl $0x40, %esi
ucomisd 0x8(%rdx), %xmm1
jae 0x2efb
xorl %eax, %eax
retq
addq %rdx, %rsi
jmp 0x2d1f
// File: /workspace/github_c_makefile_star2_O3/trumabrat[P]GrandProjet/ArbreQuat.c
// Function: liberation_arbreQuat
void liberation_arbreQuat(ArbreQuat *a){
    //!Fonction casse le programme, a verifier
    //liberation de memoire de l'arbre
    //on ne vas pas libérer les noeuds puisqu'ils appartient probablement a un reseau, donc on peut les liberer en liberant le reseau
    if(a){
        if(a->se){
            liberation_arbreQuat(a->se);
        }

        if(a->so){
            liberation_arbreQuat(a->so);
        }

        if(a->ne){
            liberation_arbreQuat(a->ne);
        }

        if(a->no){
            liberation_arbreQuat(a->no);
        }

    
        free(a);
    }
}

// Assembly:
testq %rdi, %rdi
je 0x30e2
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
je 0x30af
callq 0x3098
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x30bd
callq 0x3098
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x30cb
callq 0x3098
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x30d9
callq 0x3098
movq %rbx, %rdi
popq %rbx
jmp 0x1030
retq
nop
// File: /workspace/github_c_makefile_star2_O3/trumabrat[P]GrandProjet/SVGwriter.c
// Function: SVGinit
void SVGinit(SVGwriter *svg, char *nom, int sizeX, int sizeY) {
  char filename[100];

  strcpy(filename,nom);
  strcat(filename,".html");
  
  svg->file=fopen(filename, "w");

  if (svg->file==NULL) {
    printf("Unable to create %s\n",nom);
    exit(1);
  }
  
  strcpy(svg->lineColor, Red);
  strcpy(svg->pointColor, Black);

  svg->sizeX=sizeX;
  svg->sizeY=sizeY;

  svg->gencol[0]='0';svg->gencol[1]='1';svg->gencol[2]='2';svg->gencol[3]='3';
  svg->gencol[4]='4';svg->gencol[5]='5';svg->gencol[6]='6';svg->gencol[7]='7';
  svg->gencol[8]='8';svg->gencol[9]='9';svg->gencol[10]='A';svg->gencol[11]='B';
  svg->gencol[12]='C';svg->gencol[13]='D';svg->gencol[14]='E';svg->gencol[15]='F';

  fprintf(svg->file,"<html><body><svg xmlns=\"http://www.w3.org/2000/svg\" version=\"1.2\"");
  fprintf(svg->file, " width=\"100%%\" height=\"100%%\"");
  fprintf(svg->file, " viewBox=\"%lf %lf %lf %lf\"", -2.0, -2.0, sizeX+7.0, sizeY+7.0);
  fprintf(svg->file, " preserveAspectRatio=\"yes\">\n");
  fprintf(svg->file, "<g >\n\n");

   svg->lineColor[0]='#';
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %r12
movq %r12, %rdi
callq 0x1040
movq %r12, %rdi
callq 0x1080
movl $0x6d74682e, (%rsp,%rax) # imm = 0x6D74682E
movw $0x6c, 0x4(%rsp,%rax)
leaq 0xf0d(%rip), %rsi       # 0x4030
movq %r12, %rdi
callq 0x10f0
movq %rax, 0x20(%rbx)
testq %rax, %rax
je 0x3207
movabsq $0x30303030303023, %rcx # imm = 0x30303030303023
leaq 0x161600(%rcx), %rdx
movq %rdx, (%rbx)
movq %rcx, 0xa(%rbx)
movl %r14d, 0x14(%rbx)
movl %ebp, 0x18(%rbx)
movaps 0x1222(%rip), %xmm0     # 0x4380
movups %xmm0, 0x28(%rbx)
leaq 0x1252(%rip), %rdi      # 0x43bb
movl $0x41, %esi
movl $0x1, %edx
movq %rax, %rcx
callq 0x1110
movq 0x20(%rbx), %rdi
leaq 0x1277(%rip), %rsi      # 0x43fd
xorl %eax, %eax
callq 0x10d0
movq 0x20(%rbx), %rdi
cvtsi2sd %r14d, %xmm2
movsd 0x11f2(%rip), %xmm0     # 0x4390
addsd %xmm0, %xmm2
cvtsi2sd %ebp, %xmm3
addsd %xmm0, %xmm3
leaq 0x126a(%rip), %rsi      # 0x441b
movsd 0x11df(%rip), %xmm0     # 0x4398
movaps %xmm0, %xmm1
movb $0x4, %al
callq 0x10d0
movq 0x20(%rbx), %rcx
leaq 0x1268(%rip), %rdi      # 0x4436
movl $0x1c, %esi
movl $0x1, %edx
callq 0x1110
movq 0x20(%rbx), %rcx
leaq 0x126b(%rip), %rdi      # 0x4453
movl $0x6, %esi
movl $0x1, %edx
callq 0x1110
movb $0x23, (%rbx)
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1198(%rip), %rdi      # 0x43a6
movq %r15, %rsi
xorl %eax, %eax
callq 0x1090
movl $0x1, %edi
callq 0x1100
// File: /workspace/github_c_makefile_star2_O3/kilobyte[P]colormatch/256.c
// Function: col256_to_rgb
int col256_to_rgb(int i)
{
    if (i<0 || i > 255)
        abort();

    // Standard colours.
    if (i < 16)
    {
        if (i == 3)
            return 0xaa5500; // real CGA/VGA special-cases brown
        int c = (i&1 ? 0xaa0000 : 0x000000)
              | (i&2 ? 0x00aa00 : 0x000000)
              | (i&4 ? 0x0000aa : 0x000000);
        return (i >= 8) ? c + 0x555555 : c;
    }
    // 6x6x6 colour cube.
    else if (i < 232)
    {
        i -= 16;
        int r = i / 36, g = i / 6 % 6, b = i % 6;
        return (r ? r * 0x280000 + 0x370000 : 0)
             | (g ? g * 0x002800 + 0x003700 : 0)
             | (b ? b * 0x000028 + 0x000037 : 0);
    }
    // Grayscale ramp.
    else // i < 256
        return (i * 10 - 2312) * 0x010101;
}

// Assembly:
cmpl $0x100, %edi            # imm = 0x100
jae 0x1d79
cmpl $0xf, %edi
ja 0x1cf5
movl $0xaa5500, %eax         # imm = 0xAA5500
cmpl $0x3, %edi
je 0x1d78
movl %edi, %eax
andl $0x1, %eax
negl %eax
andl $0xaa0000, %eax         # imm = 0xAA0000
movl %edi, %ecx
shll $0x1e, %ecx
sarl $0x1f, %ecx
andl $0xaa00, %ecx           # imm = 0xAA00
orl %eax, %ecx
movl %edi, %eax
shll $0x1d, %eax
sarl $0x1f, %eax
andl $0xaa, %eax
leal (%rcx,%rax), %edx
cmpl $0x8, %edi
leal 0x555555(%rax,%rcx), %eax
cmovbl %edx, %eax
retq
cmpl $0xe7, %edi
ja 0x1d6d
addl $-0x10, %edi
movzbl %dil, %eax
imull $0x39, %eax, %ecx
shrl $0xb, %ecx
imull $0xab, %eax, %edx
shrl $0xa, %edx
imull $0x2b, %edx, %esi
shrl $0x7, %esi
andl $-0x2, %esi
leal (%rsi,%rsi,2), %esi
movl %edx, %r8d
subb %sil, %r8b
movzbl %r8b, %esi
addl %edx, %edx
leal (%rdx,%rdx,2), %edx
subb %dl, %al
leal (%rcx,%rcx,4), %ecx
shll $0x13, %ecx
addl $0x370000, %ecx         # imm = 0x370000
xorl %edx, %edx
cmpl $0x24, %edi
cmovbl %edx, %ecx
leal (%rsi,%rsi,4), %edi
shll $0xb, %edi
addl $0x3700, %edi           # imm = 0x3700
testb %sil, %sil
cmovel %edx, %edi
movzbl %al, %eax
testb %al, %al
leal (%rax,%rax,4), %eax
leal 0x37(,%rax,8), %eax
cmovel %edx, %eax
orl %ecx, %eax
orl %edi, %eax
retq
imull $0xa0a0a, %edi, %eax    # imm = 0xA0A0A
addl $0xf6eeeef8, %eax       # imm = 0xF6EEEEF8
retq
pushq %rax
callq 0x1030
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/tokenize.c
// Function: show_identifier_stats
void show_identifier_stats(void)
{
	int i;
	int distribution[100];

	fprintf(stderr, "identifiers: %d hits, %d misses\n",
		ident_hit, ident_miss);

	for (i = 0; i < 100; i++)
		distribution[i] = 0;

	for (i = 0; i < IDENT_HASH_SIZE; i++) {
		struct ident * ident = hash_table[i];
		int count = 0;

		while (ident) {
			count++;
			ident = ident->next;
		}
		if (count > 99)
			count = 99;
		distribution[count]++;
	}

	for (i = 0; i < 100; i++) {
		if (distribution[i])
			fprintf(stderr, "%2d: %d buckets\n", i, distribution[i]);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq 0x51912(%rip), %r15     # 0x5fff8
movq (%r15), %rdi
movl 0x67ee5(%rip), %edx     # 0x765d4
movl 0x67ee3(%rip), %ecx     # 0x765d8
leaq 0x39dd3(%rip), %rsi     # 0x484cf
xorl %ebx, %ebx
xorl %eax, %eax
callq 0xe1d0
movq %rsp, %rdi
movl $0x190, %edx            # imm = 0x190
xorl %esi, %esi
callq 0xe130
leaq 0x67ec5(%rip), %rax     # 0x765e0
pushq $-0x1
popq %rcx
pushq $0x63
popq %rdx
leaq (%rax,%rbx,8), %rdi
movl %ecx, %esi
movq (%rdi), %rdi
incl %esi
testq %rdi, %rdi
jne 0xe727
cmpl $0x63, %esi
cmovael %edx, %esi
incl (%rsp,%rsi,4)
incq %rbx
cmpq $0x2000, %rbx           # imm = 0x2000
jne 0xe721
leaq 0x39da3(%rip), %rbx     # 0x484f0
xorl %r14d, %r14d
movl (%rsp,%r14,4), %ecx
testl %ecx, %ecx
jne 0xe763
incq %r14
cmpq $0x64, %r14
jne 0xe750
jmp 0xe775
movq (%r15), %rdi
movq %rbx, %rsi
movl %r14d, %edx
xorl %eax, %eax
callq 0xe1d0
jmp 0xe758
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/allocate.c
// Function: show_allocations
void show_allocations(struct allocator_struct *x)
{
	fprintf(stderr, "%s: %d allocations, %lu bytes (%lu total bytes, "
			"%6.2f%% usage, %6.2f average size)\n",
		x->name, x->allocations, x->useful_bytes, x->total_bytes,
		100 * (double) x->useful_bytes / x->total_bytes,
		(double) x->useful_bytes / x->allocations);
}

// Assembly:
movq %rdi, %rax
movq 0x5186c(%rip), %rcx     # 0x5fff8
movq (%rcx), %rdi
movq (%rax), %rdx
movl 0x20(%rax), %ecx
movq 0x30(%rax), %r8
movq 0x28(%rax), %r9
movq %r8, %xmm0
movq 0x39f76(%rip), %xmm2    # 0x48720
punpckldq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
movapd 0x39f7a(%rip), %xmm3    # 0x48730
subpd %xmm3, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd 0x39f72(%rip), %xmm0    # 0x48740
mulsd %xmm1, %xmm0
movq %r9, %xmm4
punpckldq %xmm2, %xmm4    # xmm4 = xmm4[0],xmm2[0],xmm4[1],xmm2[1]
subpd %xmm3, %xmm4
movapd %xmm4, %xmm2
unpckhpd %xmm4, %xmm2            # xmm2 = xmm2[1],xmm4[1]
addsd %xmm4, %xmm2
cvtsi2sd %rcx, %xmm3
divsd %xmm2, %xmm0
divsd %xmm3, %xmm1
leaq 0x39f65(%rip), %rsi     # 0x48764
movb $0x2, %al
jmp 0xe1d0
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/obfuscate.c
// Function: main
int main(int argc, char **argv)
{
	struct string_list *filelist = NULL;
	char *file;

	emit_symbol_list(sparse_initialize(argc, argv, &filelist));
	FOR_EACH_PTR(filelist, file) {
		emit_symbol_list(sparse(file));
	} END_FOR_EACH_PTR(file);
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rbx
movq $0x0, (%rbx)
movq %rbx, %rdx
callq 0x11dca
movq %rax, %rdi
callq 0xea31
movq (%rbx), %rbx
testq %rbx, %rbx
je 0xea25
movq %rbx, %r14
movzwl (%r14), %eax
testb %al, %al
jle 0xea1c
xorl %r15d, %r15d
movq 0x18(%r14,%r15,8), %rdi
movzwl %ax, %ecx
cmpl $0x100, %ecx            # imm = 0x100
jb 0xe9fc
testq %rdi, %rdi
je 0xea0d
callq 0x12102
movq %rax, %rdi
callq 0xea31
movzwl (%r14), %eax
incq %r15
movzwl %ax, %ecx
movsbq %cl, %rcx
cmpq %rcx, %r15
jl 0xe9e7
movq 0x10(%r14), %r14
cmpq %rbx, %r14
jne 0xe9dc
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/obfuscate.c
// Function: emit_symbol_list
static void emit_symbol_list(struct symbol_list *list)
{
	struct symbol *sym;

	FOR_EACH_PTR(list, sym) {
		expand_symbol(sym);
		emit_symbol(sym);
	} END_FOR_EACH_PTR(sym);
}

// Assembly:
testq %rdi, %rdi
je 0xea9b
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rdi, %r15
movzwl (%r15), %eax
testb %al, %al
jle 0xea87
xorl %r12d, %r12d
movq 0x18(%r15,%r12,8), %r14
movzwl %ax, %ecx
cmpl $0x100, %ecx            # imm = 0x100
jb 0xea64
testq %r14, %r14
je 0xea78
movq %r14, %rdi
callq 0xed34
movq %r14, %rdi
callq 0x13ab6
movzwl (%r15), %eax
incq %r12
movzwl %ax, %ecx
movsbq %cl, %rcx
cmpq %rcx, %r12
jl 0xea4f
movq 0x10(%r15), %r15
cmpq %rbx, %r15
jne 0xea44
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/expand.c
// Function: expand_symbol
int expand_symbol(struct symbol *sym)
{
	int retval;
	struct symbol *base_type;

	if (!sym)
		return 0;
	base_type = sym->ctype.base_type;
	if (!base_type)
		return 0;

	retval = expand_expression(sym->initializer);
	/* expand the body of the symbol */
	if (base_type->type == SYM_FN) {
		if (base_type->stmt)
			expand_statement(base_type->stmt);
	}
	return retval;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testq %rdi, %rdi
je 0xed6d
movq 0x60(%rdi), %r14
testq %r14, %r14
je 0xed6d
movq 0xb0(%rdi), %rdi
callq 0xed77
movl %eax, %ebx
cmpb $0x5, (%r14)
jne 0xed6d
movq 0x90(%r14), %rdi
testq %rdi, %rdi
je 0xed6d
callq 0xf0ee
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/expand.c
// Function: _get_expression_value
static long long __get_expression_value(struct expression *expr, int strict)
{
	long long value, mask;
	struct symbol *ctype;

	if (!expr)
		return 0;
	ctype = evaluate_expression(expr);
	if (!ctype) {
		expression_error(expr, "bad constant expression type");
		return 0;
	}
	expand_expression(expr);
	if (expr->type != EXPR_VALUE) {
		if (strict != 2)
			expression_error(expr, "bad constant expression");
		return 0;
	}
	if ((strict == 1) && bad_integer_constant_expression(expr)) {
		expression_error(expr, "bad integer constant expression");
		return 0;
	}

	value = expr->value;
	mask = 1ULL << (ctype->bit_size-1);

	if (value & mask) {
		while (ctype->type != SYM_BASETYPE)
			ctype = ctype->ctype.base_type;
		if (!(ctype->ctype.modifiers & MOD_UNSIGNED))
			value = value | mask | ~(mask-1);
	}
	return value;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xf48c
movl %esi, %ebx
movq %rdi, %r14
callq 0x32223
testq %rax, %rax
je 0xf47e
movq %rax, %r15
movq %r14, %rdi
callq 0xed77
movl (%r14), %eax
cmpb $0x1, %al
jne 0xf487
cmpl $0x1, %ebx
jne 0xf442
btl $0xc, %eax
jae 0xf499
testb $0x1, 0x28(%r14)
jne 0xf499
movb 0x50(%r15), %cl
decb %cl
movl $0x1, %eax
shlq %cl, %rax
movq 0x20(%r14), %rbx
movzbl %cl, %ecx
btq %rcx, %rbx
jb 0xf463
jmp 0xf4ac
movq 0x60(%r15), %r15
cmpb $0x2, (%r15)
jne 0xf45f
testb $0x40, 0x69(%r15)
jne 0xf4ac
movq %rax, %rcx
negq %rcx
orq %rcx, %rbx
orq %rax, %rbx
jmp 0xf4ac
leaq 0x30ec5(%rip), %rsi     # 0x4034a
jmp 0xf4a0
cmpl $0x2, %ebx
jne 0xf490
xorl %ebx, %ebx
jmp 0xf4ac
leaq 0x30ed0(%rip), %rsi     # 0x40367
jmp 0xf4a0
leaq 0x30edf(%rip), %rsi     # 0x4037f
xorl %ebx, %ebx
movq %r14, %rdi
xorl %eax, %eax
callq 0x11b04
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/expand.c
// Function: expr_truth_value
int expr_truth_value(struct expression *expr)
{
	const int saved = conservative;
	struct symbol *ctype;

	if (!expr)
		return 0;

	ctype = evaluate_expression(expr);
	if (!ctype)
		return -1;

	conservative = 1;
	expand_expression(expr);
	conservative = saved;

redo:
	switch (expr->type) {
	case EXPR_COMMA:
		expr = expr->right;
		goto redo;
	case EXPR_VALUE:
		return expr->value != 0;
	case EXPR_FVALUE:
		return expr->fvalue != 0;
	default:
		return -1;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xf535
movq %rdi, %r14
movb 0x55fa4(%rip), %bpl     # 0x65480
callq 0x32223
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %rax, %rax
je 0xf543
movb $0x1, 0x55f8e(%rip)     # 0x65480
movq %r14, %rdi
callq 0xed77
andb $0x1, %bpl
movb %bpl, 0x55f7b(%rip)     # 0x65480
movzbl (%r14), %eax
cmpl $0x15, %eax
jne 0xf514
movq 0x28(%r14), %r14
jmp 0xf505
cmpl $0x1, %eax
je 0xf539
cmpl $0x1c, %eax
jne 0xf543
fldt 0x20(%r14)
fldz
fucompi %st(1), %st
fstp %st(0)
setp %al
setne %cl
orb %al, %cl
movzbl %cl, %ebx
jmp 0xf543
xorl %ebx, %ebx
jmp 0xf543
xorl %ebx, %ebx
cmpq $0x0, 0x20(%r14)
setne %bl
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/expand.c
// Function: is_zero_constant
int is_zero_constant(struct expression *expr)
{
	const int saved = conservative;
	conservative = 1;
	expand_expression(expr);
	conservative = saved;
	return expr->type == EXPR_VALUE && !expr->value;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb 0x55f29(%rip), %bpl     # 0x65480
movb $0x1, 0x55f22(%rip)     # 0x65480
callq 0xed77
movb %bpl, 0x55f16(%rip)     # 0x65480
xorl %eax, %eax
cmpb $0x1, (%rbx)
jne 0xf57b
xorl %eax, %eax
cmpq $0x0, 0x20(%rbx)
sete %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/expand.c
// Function: expand_logical
static int expand_logical(struct expression *expr)
{
	struct expression *left = expr->left;
	struct expression *right;
	int cost, rcost;

	/* Do immediate short-circuiting ... */
	cost = expand_expression(left);
	if (left->type == EXPR_VALUE) {
		if (expr->op == SPECIAL_LOGICAL_AND) {
			if (!left->value) {
				expr->type = EXPR_VALUE;
				expr->value = 0;
				expr->taint = left->taint;
				return 0;
			}
		} else {
			if (left->value) {
				expr->type = EXPR_VALUE;
				expr->value = 1;
				expr->taint = left->taint;
				return 0;
			}
		}
	}

	right = expr->right;
	rcost = expand_expression(right);
	if (left->type == EXPR_VALUE && right->type == EXPR_VALUE) {
		/*
		 * We know the left value doesn't matter, since
		 * otherwise we would have short-circuited it..
		 */
		expr->type = EXPR_VALUE;
		expr->value = right->value != 0;
		expr->taint = left->taint | right->taint;
		return 0;
	}

	/*
	 * If the right side is safe and cheaper than a branch,
	 * just avoid the branch and turn it into a regular binop
	 * style SAFELOGICAL.
	 */
	if (rcost < BRANCH_COST) {
		expr->type = EXPR_BINOP;
		rcost -= BRANCH_COST - 1;
	}

	return cost + BRANCH_COST + rcost;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %r14
movq %r14, %rdi
callq 0xed77
movl %eax, %r15d
cmpb $0x1, (%r14)
jne 0xfaa4
cmpl $0x10c, 0x4(%rbx)       # imm = 0x10C
movq 0x20(%r14), %rax
jne 0xfa8e
testq %rax, %rax
jne 0xfaa4
movb $0x1, (%rbx)
movq $0x0, 0x20(%rbx)
jmp 0xfa9e
testq %rax, %rax
je 0xfaa4
movb $0x1, (%rbx)
movq $0x1, 0x20(%rbx)
movl 0x28(%r14), %eax
jmp 0xfad8
movq 0x28(%rbx), %r12
movq %r12, %rdi
callq 0xed77
cmpb $0x1, (%r14)
jne 0xfadf
cmpb $0x1, (%r12)
jne 0xfadf
movb $0x1, (%rbx)
xorl %eax, %eax
cmpq $0x0, 0x20(%r12)
setne %al
movq %rax, 0x20(%rbx)
movl 0x28(%r12), %eax
orl 0x28(%r14), %eax
movl %eax, 0x28(%rbx)
xorl %eax, %eax
jmp 0xfaf0
cmpl $0x9, %eax
jg 0xfaea
movb $0x5, (%rbx)
addl $-0x9, %eax
addl %r15d, %eax
addl $0xa, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/expand.c
// Function: expand_comma
static int expand_comma(struct expression *expr)
{
	int cost;

	cost = expand_expression(expr->left);
	cost += expand_expression(expr->right);
	if (expr->left->type == EXPR_VALUE || expr->left->type == EXPR_FVALUE) {
		unsigned flags = expr->flags;
		unsigned taint;
		taint = expr->left->type == EXPR_VALUE ? expr->left->taint : 0;
		*expr = *expr->right;
		expr->flags = flags;
		if (expr->type == EXPR_VALUE)
			expr->taint |= Taint_comma | taint;
	}
	return cost;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0xed77
movl %eax, %ebp
movq 0x28(%rbx), %rdi
callq 0xed77
movq 0x20(%rbx), %rsi
movl (%rsi), %ecx
movzbl %cl, %edi
cmpb $0x1c, %dil
je 0xfb2a
cmpl $0x1, %edi
jne 0xfb7a
movzbl 0x1(%rbx), %edx
shll $0x8, %edx
movl $0x1, %ecx
cmpl $0x1, %edi
jne 0xfb41
movl 0x28(%rsi), %ecx
orl $0x1, %ecx
movq 0x28(%rbx), %rsi
movaps (%rsi), %xmm0
movaps 0x10(%rsi), %xmm1
movaps 0x20(%rsi), %xmm2
movaps 0x30(%rsi), %xmm3
movaps %xmm0, (%rbx)
movaps %xmm1, 0x10(%rbx)
movaps %xmm3, 0x30(%rbx)
movaps %xmm2, 0x20(%rbx)
movl (%rbx), %esi
movl %esi, %edi
andl $0xffff00ff, %edi       # imm = 0xFFFF00FF
orl %edx, %edi
movl %edi, (%rbx)
cmpb $0x1, %sil
jne 0xfb7a
orl %ecx, 0x28(%rbx)
addl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/expand.c
// Function: expand_call
static int expand_call(struct expression *expr)
{
	int cost;
	struct symbol *sym;
	struct expression *fn = expr->fn;

	cost = expand_arguments(expr->args);
	sym = fn->ctype;
	if (!sym) {
		expression_error(expr, "function has no type");
		return SIDE_EFFECTS;
	}
	if (sym->type == SYM_NODE)
		return expand_symbol_call(expr, cost);

	return SIDE_EFFECTS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %r15
movq 0x28(%rdi), %r12
xorl %r14d, %r14d
testq %r12, %r12
je 0x1032d
movq %r12, %r13
movzwl (%r13), %eax
testb %al, %al
jle 0x10324
xorl %ebp, %ebp
movq 0x18(%r13,%rbp,8), %rdi
movzwl %ax, %ecx
cmpl $0x100, %ecx            # imm = 0x100
jb 0x10308
testq %rdi, %rdi
je 0x10315
callq 0xed77
addl %eax, %r14d
movzwl (%r13), %eax
incq %rbp
movzwl %ax, %ecx
movsbq %cl, %rcx
cmpq %rcx, %rbp
jl 0x102f3
movq 0x10(%r13), %r13
cmpq %r12, %r13
jne 0x102e8
movq 0x10(%r15), %rax
testq %rax, %rax
je 0x103b4
movl $0x2710, %ebp           # imm = 0x2710
cmpb $0x3, (%rax)
jne 0x103ca
movq 0x20(%rbx), %r15
movq 0x10(%r15), %r12
movq %r15, %rdi
callq 0xed77
cmpb $0x9, (%r15)
jne 0x103ca
testb $0x40, 0x68(%r12)
je 0x103db
movq 0xc8(%r12), %r15
testq %r15, %r15
cmoveq %r12, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x107cc
testl %eax, %eax
je 0x103db
movq 0x60(%r15), %r14
leaq 0x7fbe5(%rip), %r12     # 0x8ff70
movq (%r12), %r13
movq %r15, (%r12)
movq 0x20(%rbx), %rdi
callq 0x35508
movq %r13, (%r12)
orb $0x10, 0x55(%r14)
movq %rbx, %rdi
callq 0xed77
andb $-0x11, 0x55(%r14)
jmp 0x103cc
leaq 0x2ff23(%rip), %rsi     # 0x402de
movq %rbx, %rdi
xorl %eax, %eax
callq 0x11b04
movl $0x2710, %ebp           # imm = 0x2710
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x40(%r12), %rax
testq %rax, %rax
je 0x10404
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x10404
movq %rbx, %rdi
movl %r14d, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
incl %r14d
testb $0x1, 0x6b(%r12)
movl $0x2710, %ebp           # imm = 0x2710
cmovnel %r14d, %ebp
jmp 0x103ca
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/expand.c
// Function: verify_nonoverlapping
static void verify_nonoverlapping(struct expression_list **list, struct expression *expr)
{
	struct expression *a = NULL;
	unsigned long max = 0;
	unsigned long whole = expr->ctype->bit_size;
	struct expression *b;

	if (!Woverride_init)
		return;

	FOR_EACH_PTR(*list, b) {
		unsigned long off, end;
		if (!b->ctype || !b->ctype->bit_size)
			continue;
		off = bit_offset(b);
		if (a && off < max) {
			warning(a->pos, "Initializer entry defined twice");
			info(b->pos, "  also defined here");
			if (!Woverride_init_all)
				return;
		}
		end = off + bit_range(b);
		if (!a && !Woverride_init_whole_range) {
			// If first entry is the whole range, do not let
			// any warning about it (this allow to initialize
			// an array with some default value and then override
			// some specific entries).
			if (off == 0 && end == whole)
				continue;
		}
		if (end > max) {
			max = end;
			a = b;
		}
	} END_FOR_EACH_PTR(b);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x501a3(%rip), %rax     # 0x605d0
cmpl $0x0, (%rax)
je 0x10562
movq (%rdi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x10562
movslq %esi, %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %r13
xorl %r14d, %r14d
xorl %ebx, %ebx
movzwl (%r13), %eax
testb %al, %al
jle 0x10553
xorl %ebp, %ebp
movq 0x18(%r13,%rbp,8), %r15
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0x10480
testq %r15, %r15
je 0x1053f
movq 0x10(%r15), %rax
testq %rax, %rax
je 0x1053f
cmpl $0x0, 0x50(%rax)
je 0x1053f
movq %r15, %rdi
callq 0x1074e
movq %rax, %r12
testq %rbx, %rbx
je 0x104e0
cmpq %r14, %r12
jae 0x104e0
movq 0x8(%rbx), %rdi
leaq 0x2fe3c(%rip), %rsi     # 0x402f3
xorl %eax, %eax
callq 0x118fc
movq 0x8(%r15), %rdi
leaq 0x2fe4a(%rip), %rsi     # 0x40313
xorl %eax, %eax
callq 0x1178c
leaq 0x56939(%rip), %rax     # 0x66e10
cmpl $0x0, (%rax)
je 0x10562
cmpb $0x1b, (%r15)
jne 0x1050e
movq %r15, %rcx
xorl %eax, %eax
movl 0x24(%rcx), %esi
movq 0x10(%rcx), %rdx
movslq 0x50(%rdx), %rdx
decq %rsi
imulq %rdx, %rsi
addq %rsi, %rax
movq 0x28(%rcx), %rcx
cmpb $0x1b, (%rcx)
je 0x104eb
addq %rdx, %rax
jmp 0x10510
xorl %eax, %eax
addq %r12, %rax
testq %rbx, %rbx
jne 0x10534
leaq 0x568f5(%rip), %rcx     # 0x66e14
cmpl $0x0, (%rcx)
jne 0x10534
testq %r12, %r12
jne 0x10534
cmpq 0x10(%rsp), %rax
jne 0x10534
xorl %ebx, %ebx
jmp 0x1053f
cmpq %r14, %rax
cmovaq %rax, %r14
cmovaq %r15, %rbx
incq %rbp
movl (%r13), %eax
movsbq %al, %rcx
cmpq %rcx, %rbp
jl 0x10468
movq 0x10(%r13), %r13
cmpq 0x8(%rsp), %r13
jne 0x10459
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/expand.c
// Function: expand_expression_list
static int expand_expression_list(struct expression_list *list)
{
	int cost = 0;
	struct expression *expr;

	FOR_EACH_PTR(list, expr) {
		cost += expand_expression(expr);
	} END_FOR_EACH_PTR(expr);
	return cost;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x105cb
movq %rdi, %r14
xorl %ebx, %ebx
movq %rdi, %r15
movzwl (%r15), %eax
testb %al, %al
jle 0x105c0
xorl %r12d, %r12d
movq 0x18(%r15,%r12,8), %rdi
movzwl %ax, %ecx
cmpl $0x100, %ecx            # imm = 0x100
jb 0x105a6
testq %rdi, %rdi
je 0x105b1
callq 0xed77
addl %eax, %ebx
movzwl (%r15), %eax
incq %r12
movzwl %ax, %ecx
movsbq %cl, %rcx
cmpq %rcx, %r12
jl 0x10591
movq 0x10(%r15), %r15
cmpq %r14, %r15
jne 0x10586
jmp 0x105cd
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/expand.c
// Function: expand_pos_expression
static int expand_pos_expression(struct expression *expr)
{
	struct expression *nested = expr->init_expr;
	unsigned long offset = expr->init_offset;
	int nr = expr->init_nr;

	if (nr == 1) {
		switch (nested->type) {
		case EXPR_POS:
			offset += nested->init_offset;
			*expr = *nested;
			expr->init_offset = offset;
			nested = expr;
			break;

		case EXPR_INITIALIZER: {
			struct expression *reuse = nested, *entry;
			*expr = *nested;
			FOR_EACH_PTR(expr->expr_list, entry) {
				if (entry->type == EXPR_POS) {
					entry->init_offset += offset;
				} else {
					if (!reuse) {
						/*
						 * This happens rarely, but it can happen
						 * with bitfields that are all at offset
						 * zero..
						 */
						reuse = alloc_expression(entry->pos, EXPR_POS);
					}
					reuse->type = EXPR_POS;
					reuse->ctype = entry->ctype;
					reuse->init_offset = offset;
					reuse->init_nr = 1;
					reuse->init_expr = entry;
					REPLACE_CURRENT_PTR(entry, reuse);
					reuse = NULL;
				}
			} END_FOR_EACH_PTR(entry);
			nested = expr;
			break;
		}

		default:
			break;
		}
	}
	return expand_expression(nested);
}

// Assembly:
movq 0x28(%rdi), %rax
cmpl $0x1, 0x24(%rdi)
jne 0x1062d
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x20(%rdi), %ebp
movzbl (%rax), %ecx
cmpl $0x18, %ecx
je 0x10635
cmpl $0x1b, %ecx
jne 0x10709
addl 0x20(%rax), %ebp
movaps (%rax), %xmm0
movaps 0x10(%rax), %xmm1
movaps 0x20(%rax), %xmm2
movaps 0x30(%rax), %xmm3
movaps %xmm2, 0x20(%rdi)
movaps %xmm3, 0x30(%rdi)
movaps %xmm1, 0x10(%rdi)
movaps %xmm0, (%rdi)
movl %ebp, 0x20(%rdi)
jmp 0x1070c
movq %rax, %rdi
jmp 0xed77
movaps (%rax), %xmm0
movaps 0x10(%rax), %xmm1
movaps 0x20(%rax), %xmm2
movaps 0x30(%rax), %xmm3
movaps %xmm2, 0x20(%rdi)
movaps %xmm3, 0x30(%rdi)
movaps %xmm1, 0x10(%rdi)
movaps %xmm0, (%rdi)
movq 0x20(%rdi), %r15
testq %r15, %r15
je 0x1070c
movq %rdi, (%rsp)
movq %r15, %r12
movzwl (%r12), %ecx
testb %cl, %cl
jle 0x106f5
xorl %r13d, %r13d
movq 0x18(%r12,%r13,8), %r14
movzwl %cx, %ecx
cmpl $0x100, %ecx            # imm = 0x100
jb 0x1068c
testq %r14, %r14
je 0x106e5
cmpb $0x1b, (%r14)
jne 0x10698
addl %ebp, 0x20(%r14)
jmp 0x106e5
testq %rax, %rax
je 0x106a8
movl (%rax), %ecx
movl $0xffffff00, %edx       # imm = 0xFFFFFF00
andl %edx, %ecx
jmp 0x106c3
movq 0x8(%r14), %rbx
xorl %edi, %edi
callq 0x2f9f5
movzwl 0x2(%rax), %ecx
shll $0x10, %ecx
movq %rbx, 0x8(%rax)
movw $0x1b, (%rax)
orl $0x1b, %ecx
movl %ecx, (%rax)
movq 0x10(%r14), %rcx
movq %rcx, 0x10(%rax)
movl %ebp, 0x20(%rax)
movl $0x1, 0x24(%rax)
movq %r14, 0x28(%rax)
movq %rax, 0x18(%r12,%r13,8)
xorl %eax, %eax
incq %r13
movl (%r12), %ecx
movsbq %cl, %rdx
cmpq %rdx, %r13
jl 0x10677
movq 0x10(%r12), %r12
cmpq %r15, %r12
jne 0x10667
movq (%rsp), %rdi
jmp 0x1070c
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xed77
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/expand.c
// Function: bit_offset
static unsigned long bit_offset(const struct expression *expr)
{
	unsigned long offset = 0;
	while (expr->type == EXPR_POS) {
		offset += bytes_to_bits(expr->init_offset);
		expr = expr->init_expr;
	}
	if (expr && expr->ctype)
		offset += expr->ctype->bit_offset;
	return offset;
}

// Assembly:
cmpb $0x1b, (%rdi)
jne 0x10775
leaq 0x53fa6(%rip), %rax     # 0x64700
movslq (%rax), %rcx
xorl %eax, %eax
movslq 0x20(%rdi), %rdx
imulq %rcx, %rdx
addq %rdx, %rax
movq 0x28(%rdi), %rdi
cmpb $0x1b, (%rdi)
je 0x1075f
jmp 0x10777
xorl %eax, %eax
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x10787
movzbl 0x54(%rcx), %ecx
addq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/expand.c
// Function: expand_const_expression
static void expand_const_expression(struct expression *expr, const char *where)
{
	if (expr) {
		expand_expression(expr);
		if (expr->type != EXPR_VALUE) {
			expression_error(expr, "Expected constant expression in %s", where);
			expr->ctype = &int_ctype;
			expr->type = EXPR_VALUE;
			expr->value = 0;
		}
	}
}

// Assembly:
testq %rdi, %rdi
je 0x107ca
pushq %rbx
movq %rdi, %rbx
callq 0xed77
cmpb $0x1, (%rbx)
je 0x107c9
leaq 0x2fb85(%rip), %rsi     # 0x40327
leaq 0x36dfa(%rip), %rdx     # 0x475a3
movq %rbx, %rdi
xorl %eax, %eax
callq 0x11b04
leaq 0x5af7e(%rip), %rax     # 0x6b738
movq %rax, 0x10(%rbx)
movb $0x1, (%rbx)
movq $0x0, 0x20(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/inline.c
// Function: create_symbol_list
static struct symbol_list *create_symbol_list(struct symbol_list *src)
{
	struct symbol_list *dst = NULL;
	struct symbol *sym;

	FOR_EACH_PTR(src, sym) {
		struct symbol *newsym = create_copy_symbol(sym);
		add_symbol(&dst, newsym);
	} END_FOR_EACH_PTR(sym);
	return dst;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq $0x0, (%rsp)
testq %rdi, %rdi
je 0x10ac2
movq %rdi, %rbx
movq %rsp, %r14
movq %rdi, %r13
movzwl (%r13), %eax
testb %al, %al
jle 0x10aaf
xorl %ebp, %ebp
movq 0x18(%r13,%rbp,8), %r15
movzwl %ax, %ecx
cmpl $0x100, %ecx            # imm = 0x100
jb 0x10a51
testq %r15, %r15
je 0x10aa0
testq %r15, %r15
je 0x10a8d
movzbl (%r15), %esi
movq 0x4(%r15), %rdi
callq 0x2b00b
movq %rax, %r12
movl $0xd0, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0xe1e0
xorps %xmm0, %xmm0
movups %xmm0, 0xd0(%r12)
movq %r15, 0x28(%r12)
movq %r12, 0x28(%r15)
jmp 0x10a90
xorl %r12d, %r12d
movq %r14, %rdi
movq %r12, %rsi
callq 0x227b4
movzwl (%r13), %eax
incq %rbp
movzwl %ax, %ecx
movsbq %cl, %rcx
cmpq %rcx, %rbp
jl 0x10a3c
movq 0x10(%r13), %r13
cmpq %rbx, %r13
jne 0x10a31
movq (%rsp), %rax
jmp 0x10ac4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq