LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt__isfont
static int stbtt__isfont(stbtt_uint8 *font)
{
   // check the version number
   if (stbtt_tag4(font, '1',0,0,0))  return 1; // TrueType 1
   if (stbtt_tag(font, "typ1"))   return 1; // TrueType with type 1 font -- we don't support this!
   if (stbtt_tag(font, "OTTO"))   return 1; // OpenType with CFF
   if (stbtt_tag4(font, 0,1,0,0)) return 1; // OpenType 1.0
   if (stbtt_tag(font, "true"))   return 1; // Apple specification for TrueType fonts
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x31, %eax
jne 0x13ad7
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x13ad7
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
cmpl $0x0, %eax
jne 0x13ad7
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %eax
cmpl $0x0, %eax
jne 0x13ad7
movl $0x1, -0x4(%rbp)
jmp 0x13c1c
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movsbl 0x3963(%rip), %ecx      # 0x17448
cmpl %ecx, %eax
jne 0x13b2e
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
movsbl 0x3951(%rip), %ecx      # 0x17449
cmpl %ecx, %eax
jne 0x13b2e
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
movsbl 0x393f(%rip), %ecx      # 0x1744a
cmpl %ecx, %eax
jne 0x13b2e
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %eax
movsbl 0x392d(%rip), %ecx      # 0x1744b
cmpl %ecx, %eax
jne 0x13b2e
movl $0x1, -0x4(%rbp)
jmp 0x13c1c
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movsbl 0x3911(%rip), %ecx      # 0x1744d
cmpl %ecx, %eax
jne 0x13b85
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
movsbl 0x38ff(%rip), %ecx      # 0x1744e
cmpl %ecx, %eax
jne 0x13b85
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
movsbl 0x38ed(%rip), %ecx      # 0x1744f
cmpl %ecx, %eax
jne 0x13b85
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %eax
movsbl 0x38db(%rip), %ecx      # 0x17450
cmpl %ecx, %eax
jne 0x13b85
movl $0x1, -0x4(%rbp)
jmp 0x13c1c
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x13bc1
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x1, %eax
jne 0x13bc1
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
cmpl $0x0, %eax
jne 0x13bc1
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %eax
cmpl $0x0, %eax
jne 0x13bc1
movl $0x1, -0x4(%rbp)
jmp 0x13c1c
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movsbl 0x3883(%rip), %ecx      # 0x17452
cmpl %ecx, %eax
jne 0x13c15
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
movsbl 0x3871(%rip), %ecx      # 0x17453
cmpl %ecx, %eax
jne 0x13c15
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
movsbl 0x385f(%rip), %ecx      # 0x17454
cmpl %ecx, %eax
jne 0x13c15
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %eax
movsbl 0x384d(%rip), %ecx      # 0x17455
cmpl %ecx, %eax
jne 0x13c15
movl $0x1, -0x4(%rbp)
jmp 0x13c1c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zhoudian64[P]OS2-exp/lock_checker.c
// Function: main
int main() {
	int fd = open("./lock", O_RDONLY);
	for (int i = 0; ; ++i) {
		printf("Trying to lock file.\n");
		flock(fd, LOCK_EX);
		printf("file locked.\n");
		printf("i = %d\n", i);
		printf("Trying to unlock file.\n");
		flock(fd, LOCK_UN);
		printf("file unlocked.\n");
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
leaq 0xe8e(%rip), %rdi       # 0x2004
xorl %esi, %esi
movb $0x0, %al
callq 0x1040
movl %eax, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
leaq 0xe7b(%rip), %rdi       # 0x200b
movb $0x0, %al
callq 0x1030
movl -0x8(%rbp), %edi
movl $0x2, %esi
callq 0x1050
leaq 0xe76(%rip), %rdi       # 0x2021
movb $0x0, %al
callq 0x1030
movl -0xc(%rbp), %esi
leaq 0xe73(%rip), %rdi       # 0x202f
movb $0x0, %al
callq 0x1030
leaq 0xe6d(%rip), %rdi       # 0x2037
movb $0x0, %al
callq 0x1030
movl -0x8(%rbp), %edi
movl $0x8, %esi
callq 0x1050
leaq 0xe6a(%rip), %rdi       # 0x204f
movb $0x0, %al
callq 0x1030
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1189
// File: /workspace/github_c_makefile_star2_O0/trumabrat[P]GrandProjet/comparaisons.c
// Function: generationAleatoire
Chaines* generationAleatoire(int nbChaines, int nbPointsChaine, int xmax, int ymax){
    //La CellChaine qu'on va mettre dans la structure Chaines
    CellChaine *cellChaineMain = NULL;

    //La premiere boucle pour creer nbChaines de chaines
    for (int i = 0; i < nbChaines; i++)
    {
        CellChaine *newCellChaine = calloc(1, sizeof(CellChaine));
        newCellChaine->numero = i;

        //Le CellPoint qu'on va mettre dans CellChaine
        CellPoint *cellPointMain = NULL;

        //La deuxieme boucle pour creer nbPointsChaine pour chaque CellChaine
        for (int j = 0; j < nbPointsChaine; j++)
        {
            CellPoint *newCellPoint = calloc(1,sizeof(CellPoint));

            //attribution des points entre 0 et xmax,ymax (noncompris)
            newCellPoint->x = generateRandomDouble(xmax);
            newCellPoint->y = generateRandomDouble(ymax);

            //En tete de cellPointMain
            newCellPoint->suiv = cellPointMain;
            cellPointMain = newCellPoint;
        }

        //insertions des points dans la CellChaine, puis de la CellChaine dans la tete de cellChaineMain
        newCellChaine->points = cellPointMain;
        newCellChaine->suiv = cellChaineMain;
        cellChaineMain = newCellChaine;
    }

    //Creation de la chaine
    Chaines *C = calloc(1, sizeof(Chaines));
    C->gamma = 1;
    C->nbChaines = nbChaines;
    C->chaines = cellChaineMain;

    return C;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x19a3
movl $0x1, %edi
movl $0x18, %esi
callq 0x10b0
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq $0x0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x1975
movl $0x1, %edi
movl $0x18, %esi
callq 0x10b0
movq %rax, -0x40(%rbp)
movl -0xc(%rbp), %edi
callq 0x1880
movq -0x40(%rbp), %rax
movsd %xmm0, (%rax)
movl -0x10(%rbp), %edi
callq 0x1880
movq -0x40(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x30(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x191a
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x18e3
movl $0x1, %edi
movl $0x10, %esi
callq 0x10b0
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movl $0x1, (%rax)
movl -0x4(%rbp), %ecx
movq -0x48(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1b7e
cmpq $0x0, -0x10(%rbp)
jne 0x1b83
jmp 0x1c7e
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edx
leaq 0x357b(%rip), %rsi      # 0x5110
movb $0x0, %al
callq 0x10c0
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %edx
leaq 0x3570(%rip), %rsi      # 0x511d
movb $0x0, %al
callq 0x10c0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1c7e
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1bfc
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x1bde
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %edx
movl -0x24(%rbp), %ecx
leaq 0x3518(%rip), %rsi      # 0x5128
movb $0x0, %al
callq 0x10c0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1c5b
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movq -0x20(%rbp), %rax
movsd 0x8(%rax), %xmm1
leaq 0x34e9(%rip), %rsi      # 0x512f
movb $0x2, %al
callq 0x10c0
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x1c23
movq -0x10(%rbp), %rdi
leaq 0x37c2(%rip), %rsi      # 0x5428
movb $0x0, %al
callq 0x10c0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1bc0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x20bd
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x20bb
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1fc0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2087
jmp 0x20bd
movsd -0x10(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2121
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x211f
movq -0x18(%rbp), %rdi
callq 0x2050
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x20f7
jmp 0x2121
movsd -0x10(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/trumabrat[P]GrandProjet/chaine.c
// Function: comptePointsTotal
int comptePointsTotal(Chaines *C){
    int res = 0;
    if(C){
        CellChaine* curCellChaine = C->chaines;
        CellPoint* curPoint = NULL;

        // pour chaque CellChaine
        while (curCellChaine)
        {
            curPoint = curCellChaine->points;

            // pour chaque Point
            while(curPoint){
                res++;
                curPoint = curPoint->suiv;
            }
            curCellChaine = curCellChaine->suiv;
        }
    }
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x219b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2199
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x218b
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x216d
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x215a
jmp 0x219b
movl -0xc(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x21c4
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x21a0
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x21f5
jmp 0x2223
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x220d
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x21e0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x21a0
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpl (%rdx), %ecx
movb %al, -0x49(%rbp)
jge 0x22ac
cmpq $0x0, -0x30(%rbp)
setne %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x22b5
jmp 0x2334
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movsd 0x8(%rax), %xmm1
subsd -0x18(%rbp), %xmm1
movaps 0x2e7b(%rip), %xmm0     # 0x5150
pand %xmm0, %xmm1
movsd 0x2e5f(%rip), %xmm0     # 0x5140
ucomisd %xmm1, %xmm0
jbe 0x2318
movq -0x38(%rbp), %rax
movsd 0x10(%rax), %xmm1
subsd -0x20(%rbp), %xmm1
movaps 0x2e54(%rip), %xmm0     # 0x5150
pand %xmm0, %xmm1
movsd 0x2e38(%rip), %xmm0     # 0x5140
ucomisd %xmm1, %xmm0
jbe 0x2318
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2394
jmp 0x231a
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x2291
movq -0x10(%rbp), %rax
movl (%rax), %edi
addl $0x1, %edi
movl %edi, (%rax)
movsd -0x18(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
callq 0x23a0
movq %rax, -0x40(%rbp)
movl $0x1, %edi
movl $0x10, %esi
callq 0x10b0
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x48(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/trumabrat[P]GrandProjet/reseau.c
// Function: creerNoeud
Noeud* creerNoeud(int num, double x, double y){
    Noeud* res = (Noeud*) calloc(1, sizeof(Noeud));
    res->num = num;
    res->x = x;
    res->y = y;
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movl $0x1, %edi
movl $0x20, %esi
callq 0x10b0
movq %rax, -0x20(%rbp)
movl -0x4(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movsd -0x10(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movsd -0x18(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/trumabrat[P]GrandProjet/reseau.c
// Function: creerCellNoeud
CellNoeud* creerCellNoeud(Noeud* n, CellNoeud* suiv){
    CellNoeud* res = (CellNoeud*) calloc(1, sizeof(CellNoeud));
    res->nd = n;
    res->suiv = suiv;
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, %edi
movl $0x10, %esi
callq 0x10b0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2471
movq $0x0, -0x8(%rbp)
jmp 0x24ee
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x24a9
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x249b
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x24ee
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x247d
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x2400
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x2400
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/trumabrat[P]GrandProjet/reseau.c
// Function: creerCellCommodite
CellCommodite* creerCellCommodite(Noeud* extrA, Noeud* extrB, CellCommodite* suiv){
    CellCommodite* res = (CellCommodite*) calloc(1, sizeof(CellCommodite));
    res->extrA = extrA;
    res->extrB = extrB;
    res->suiv = suiv;
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x1, %edi
movl $0x18, %esi
callq 0x10b0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x27ad
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x279f
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2781
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x276b
movl -0xc(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/trumabrat[P]GrandProjet/reseau.c
// Function: nbCommodites
int nbCommodites(Reseau *R){ 
    int cmp = 0;
    CellCommodite *tmp = R->commodites;
    while(tmp){
        cmp++;
        tmp = tmp->suiv;
    }

    return cmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x27f9
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x27db
movl -0xc(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2d7a
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1030
jmp 0x2d54
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2d95
jmp 0x2dd2
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2dad
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2d80
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rdi
callq 0x2d40
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2df5
jmp 0x2e16
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x2e0d
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2de0
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2de0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2d80
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x1, %edi
movl $0x10, %esi
callq 0x10b0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2fd7
jmp 0x2ff6
leaq 0x2286(%rip), %rdi      # 0x5264
leaq 0x2283(%rip), %rsi      # 0x5268
movl $0x18, %edx
leaq 0x2281(%rip), %rcx      # 0x5272
callq 0x10a0
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movslq -0x4(%rbp), %rdi
movl $0x8, %esi
callq 0x10b0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3025
jmp 0x3044
leaq 0x226b(%rip), %rdi      # 0x5297
leaq 0x2235(%rip), %rsi      # 0x5268
movl $0x1b, %edx
leaq 0x2233(%rip), %rcx      # 0x5272
callq 0x10a0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x3435
jmp 0x348d
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x3477
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2d40
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x344c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x18(%rbp)
movsd %xmm3, -0x20(%rbp)
movl $0x1, %edi
movl $0x48, %esi
callq 0x10b0
movq %rax, -0x28(%rbp)
movsd -0x8(%rbp), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
movsd -0x10(%rbp), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movsd -0x18(%rbp), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movsd -0x20(%rbp), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, 0x18(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movsd -0x20(%rbp), %xmm1
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x3eb9
movsd -0x28(%rbp), %xmm1
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x3eb9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x28, %rsi
movq -0x18(%rbp), %rdx
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
callq 0x3b40
movq %rax, -0x8(%rbp)
jmp 0x3f98
movsd -0x20(%rbp), %xmm0
movq -0x18(%rbp), %rax
ucomisd (%rax), %xmm0
jb 0x3f04
movsd -0x28(%rbp), %xmm1
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x3f04
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x30, %rsi
movq -0x18(%rbp), %rdx
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
callq 0x3b40
movq %rax, -0x8(%rbp)
jmp 0x3f98
movsd -0x20(%rbp), %xmm1
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x3f4c
movsd -0x28(%rbp), %xmm0
movq -0x18(%rbp), %rax
ucomisd 0x8(%rax), %xmm0
jb 0x3f4c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x38, %rsi
movq -0x18(%rbp), %rdx
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
callq 0x3b40
movq %rax, -0x8(%rbp)
jmp 0x3f98
movsd -0x20(%rbp), %xmm0
movq -0x18(%rbp), %rax
ucomisd (%rax), %xmm0
jb 0x3f90
movsd -0x28(%rbp), %xmm0
movq -0x18(%rbp), %rax
ucomisd 0x8(%rax), %xmm0
jb 0x3f90
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x40, %rsi
movq -0x18(%rbp), %rdx
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
callq 0x3b40
movq %rax, -0x8(%rbp)
jmp 0x3f98
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x422c
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x41db
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x41b0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x41f3
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x41b0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x420b
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x41b0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x4223
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x41b0
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jl 0x212a
cmpl $0xff, -0x8(%rbp)
jle 0x212f
callq 0x1030
cmpl $0x10, -0x8(%rbp)
jge 0x21ab
cmpl $0x3, -0x8(%rbp)
jne 0x2147
movl $0xaa5500, -0x4(%rbp)   # imm = 0xAA5500
jmp 0x2278
movl -0x8(%rbp), %edx
andl $0x1, %edx
xorl %eax, %eax
movl $0xaa0000, %ecx         # imm = 0xAA0000
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl -0x8(%rbp), %esi
andl $0x2, %esi
xorl %ecx, %ecx
movl $0xaa00, %edx           # imm = 0xAA00
cmpl $0x0, %esi
cmovnel %edx, %ecx
orl %ecx, %eax
movl -0x8(%rbp), %esi
andl $0x4, %esi
xorl %ecx, %ecx
movl $0xaa, %edx
cmpl $0x0, %esi
cmovnel %edx, %ecx
orl %ecx, %eax
movl %eax, -0xc(%rbp)
cmpl $0x8, -0x8(%rbp)
jl 0x219a
movl -0xc(%rbp), %eax
addl $0x555555, %eax         # imm = 0x555555
movl %eax, -0x1c(%rbp)
jmp 0x21a0
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2278
cmpl $0xe8, -0x8(%rbp)
jge 0x2266
movl -0x8(%rbp), %eax
subl $0x10, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl $0x24, %ecx
cltd
idivl %ecx
movl %eax, -0x10(%rbp)
movl -0x8(%rbp), %eax
movl $0x6, %ecx
cltd
idivl %ecx
movl $0x6, %ecx
cltd
idivl %ecx
movl %edx, -0x14(%rbp)
movl -0x8(%rbp), %eax
movl $0x6, %ecx
cltd
idivl %ecx
movl %edx, -0x18(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x220a
imull $0x280000, -0x10(%rbp), %eax # imm = 0x280000
addl $0x370000, %eax         # imm = 0x370000
movl %eax, -0x20(%rbp)
jmp 0x2211
xorl %eax, %eax
movl %eax, -0x20(%rbp)
jmp 0x2211
movl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x222e
imull $0x2800, -0x14(%rbp), %eax # imm = 0x2800
addl $0x3700, %eax           # imm = 0x3700
movl %eax, -0x28(%rbp)
jmp 0x2235
xorl %eax, %eax
movl %eax, -0x28(%rbp)
jmp 0x2235
movl -0x24(%rbp), %eax
movl -0x28(%rbp), %ecx
orl %ecx, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x2252
imull $0x28, -0x18(%rbp), %eax
addl $0x37, %eax
movl %eax, -0x30(%rbp)
jmp 0x2259
xorl %eax, %eax
movl %eax, -0x30(%rbp)
jmp 0x2259
movl -0x2c(%rbp), %eax
movl -0x30(%rbp), %ecx
orl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x2278
imull $0xa, -0x8(%rbp), %eax
subl $0x908, %eax            # imm = 0x908
imull $0x10101, %eax, %eax    # imm = 0x10101
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x17360
movq %rax, %rdi
callq 0x11510
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x11487
jmp 0x11504
jmp 0x11489
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movq -0x30(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x114f0
movq -0x30(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x114d4
cmpq $0x0, -0x20(%rbp)
jne 0x114d4
jmp 0x114e5
movq -0x20(%rbp), %rdi
callq 0x177d0
movq %rax, %rdi
callq 0x11510
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x11490
jmp 0x114f2
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq -0x28(%rbp), %rax
jne 0x11489
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1153d
jmp 0x115bb
jmp 0x1153f
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x20(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x115a7
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x1158a
cmpq $0x0, -0x10(%rbp)
jne 0x1158a
jmp 0x1159c
movq -0x10(%rbp), %rdi
callq 0x11aa0
movq -0x10(%rbp), %rdi
callq 0x115d0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x11546
jmp 0x115a9
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
jne 0x1153f
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/expand.c
// Function: get_longlong
static long long get_longlong(struct expression *expr)
{
	int no_expand = expr->ctype->ctype.modifiers & MOD_UNSIGNED;
	long long mask = 1ULL << (expr->ctype->bit_size - 1);
	long long value = expr->value;
	long long ormask, andmask;

	if (!(value & mask))
		no_expand = 1;
	andmask = mask | (mask-1);
	ormask = ~andmask;
	if (no_expand)
		ormask = 0;
	return (value & andmask) | ormask;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x68(%rax), %rax
andq $0x4000, %rax           # imm = 0x4000
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x50(%rax), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
andq -0x18(%rbp), %rax
cmpq $0x0, %rax
jne 0x11a1c
movl $0x1, -0xc(%rbp)
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
orq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
xorq $-0x1, %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x11a49
movq $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rax
andq -0x30(%rbp), %rax
orq -0x28(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x11abc
movl $0x0, -0x4(%rbp)
jmp 0x11b21
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x11ad8
movl $0x0, -0x4(%rbp)
jmp 0x11b21
movq -0x10(%rbp), %rax
movq 0xb0(%rax), %rdi
callq 0x11b30
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x5, %eax
jne 0x11b1b
movq -0x20(%rbp), %rax
cmpq $0x0, 0x90(%rax)
je 0x11b19
movq -0x20(%rbp), %rax
movq 0x90(%rax), %rdi
callq 0x11d80
jmp 0x11b1b
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x12033
movq $0x0, -0x8(%rbp)
jmp 0x12164
movq -0x10(%rbp), %rdi
callq 0x4bb70
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x12066
movq -0x10(%rbp), %rdi
leaq 0x50264(%rip), %rsi     # 0x622b6
movb $0x0, %al
callq 0x17030
movq $0x0, -0x8(%rbp)
jmp 0x12164
movq -0x10(%rbp), %rdi
callq 0x11b30
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x1, %eax
je 0x120a4
cmpl $0x2, -0x14(%rbp)
je 0x12097
movq -0x10(%rbp), %rdi
leaq 0x50243(%rip), %rsi     # 0x622d3
movb $0x0, %al
callq 0x17030
movq $0x0, -0x8(%rbp)
jmp 0x12164
cmpl $0x1, -0x14(%rbp)
jne 0x120d7
movq -0x10(%rbp), %rdi
callq 0x14fd0
cmpl $0x0, %eax
je 0x120d7
movq -0x10(%rbp), %rdi
leaq 0x50228(%rip), %rsi     # 0x622eb
movb $0x0, %al
callq 0x17030
movq $0x0, -0x8(%rbp)
jmp 0x12164
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
movl 0x50(%rax), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
andq -0x28(%rbp), %rax
cmpq $0x0, %rax
je 0x1215c
jmp 0x1210d
movq -0x30(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
cmpl $0x2, %eax
je 0x1212b
movq -0x30(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x1210d
movq -0x30(%rbp), %rax
movq 0x68(%rax), %rax
andq $0x4000, %rax           # imm = 0x4000
cmpq $0x0, %rax
jne 0x1215a
movq -0x20(%rbp), %rax
orq -0x28(%rbp), %rax
movq -0x28(%rbp), %rcx
subq $0x1, %rcx
xorq $-0x1, %rcx
orq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0x1215c
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl 0x796ae(%rip), %eax     # 0x8b870
movl %eax, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x121d8
movl $0x0, -0x4(%rbp)
jmp 0x12283
movq -0x10(%rbp), %rdi
callq 0x4bb70
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x121f8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12283
movl $0x1, 0x7966e(%rip)     # 0x8b870
movq -0x10(%rbp), %rdi
callq 0x11b30
movl -0x14(%rbp), %eax
movl %eax, 0x7965c(%rip)     # 0x8b870
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x1, %eax
je 0x12247
jmp 0x12225
movl -0x24(%rbp), %eax
subl $0x15, %eax
je 0x12239
jmp 0x1222f
movl -0x24(%rbp), %eax
subl $0x1c, %eax
je 0x1225d
jmp 0x1227c
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x12214
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x12283
movq -0x10(%rbp), %rax
fldt 0x20(%rax)
fldz
fucompi %st(1), %st
fstp %st(0)
setp %cl
setne %al
orb %cl, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x12283
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl 0x795ce(%rip), %eax     # 0x8b870
movl %eax, -0xc(%rbp)
movl $0x1, 0x795c1(%rip)     # 0x8b870
movq -0x8(%rbp), %rdi
callq 0x11b30
movl -0xc(%rbp), %eax
movl %eax, 0x795af(%rip)     # 0x8b870
movq -0x8(%rbp), %rax
movl (%rax), %ecx
andl $0xff, %ecx
xorl %eax, %eax
cmpl $0x1, %ecx
movb %al, -0xd(%rbp)
jne 0x122e8
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
setne %al
xorb $-0x1, %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/expand.c
// Function: expand_symbol_expression
static int expand_symbol_expression(struct expression *expr)
{
	struct symbol *sym = expr->symbol;

	if (sym == &zero_int) {
		if (Wundef)
			warning(expr->pos, "undefined preprocessor identifier '%s'", show_ident(expr->symbol_name));
		expr->type = EXPR_VALUE;
		expr->value = 0;
		expr->taint = 0;
		return 0;
	}

	// expand compound literals (C99 & C11 6.5.2.5)
	// FIXME: is this the correct way to identify them?
	//	All compound literals are anonymous but is
	//	the reverse true?
	if (sym->initializer && !expr->symbol_name)
		return expand_expression(sym->initializer);

	/* The cost of a symbol expression is lower for on-stack symbols */
	return (sym->ctype.modifiers & (MOD_STATIC | MOD_EXTERN)) ? 2 : 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
leaq 0x81f59(%rip), %rax     # 0x94278
cmpq %rax, -0x18(%rbp)
jne 0x12390
leaq 0x7aef8(%rip), %rax     # 0x8d224
cmpl $0x0, (%rax)
je 0x1235f
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x44150
movq %rax, %rdx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x4fe74(%rip), %rsi     # 0x621cc
movb $0x0, %al
callq 0x16d80
movq -0x10(%rbp), %rax
movl (%rax), %ecx
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
orl $0x1, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x28(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x123de
movq -0x18(%rbp), %rax
cmpq $0x0, 0xb0(%rax)
je 0x123be
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x123be
movq -0x18(%rbp), %rax
movq 0xb0(%rax), %rdi
callq 0x11b30
movl %eax, -0x4(%rbp)
jmp 0x123de
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rdx
andq $0xc, %rdx
movl $0x1, %eax
movl $0x2, %ecx
cmpq $0x0, %rdx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)