LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt__GetGlyphClass
static stbtt_int32  stbtt__GetGlyphClass(stbtt_uint8 *classDefTable, int glyph)
{
    stbtt_uint16 classDefFormat = ttUSHORT(classDefTable);
    switch(classDefFormat)
    {
        case 1: {
            stbtt_uint16 startGlyphID = ttUSHORT(classDefTable + 2);
            stbtt_uint16 glyphCount = ttUSHORT(classDefTable + 4);
            stbtt_uint8 *classDef1ValueArray = classDefTable + 6;

            if (glyph >= startGlyphID && glyph < startGlyphID + glyphCount)
                return (stbtt_int32)ttUSHORT(classDef1ValueArray + 2 * (glyph - startGlyphID));

            classDefTable = classDef1ValueArray + 2 * glyphCount;
        } break;

        case 2: {
            stbtt_uint16 classRangeCount = ttUSHORT(classDefTable + 2);
            stbtt_uint8 *classRangeRecords = classDefTable + 4;

            // Binary search.
            stbtt_int32 l=0, r=classRangeCount-1, m;
            int strawStart, strawEnd, needle=glyph;
            while (l <= r) {
                stbtt_uint8 *classRangeRecord;
                m = (l + r) >> 1;
                classRangeRecord = classRangeRecords + 6 * m;
                strawStart = ttUSHORT(classRangeRecord);
                strawEnd = ttUSHORT(classRangeRecord + 2);
                if (needle < strawStart)
                    r = m - 1;
                else if (needle > strawEnd)
                    l = m + 1;
                else
                    return (stbtt_int32)ttUSHORT(classRangeRecord + 4);
            }

            classDefTable = classRangeRecords + 6 * classRangeCount;
        } break;

        default: {
            // There are no other cases.
            STBTT_assert(0);
        } break;
    }

    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movzwl (%rdi), %eax
rolw $0x8, %ax
cmpw $0x2, %ax
je 0xb103
movzwl %ax, %eax
cmpl $0x1, %eax
jne 0xb177
movzwl 0x2(%rdi), %eax
rolw $0x8, %ax
movzwl %ax, %edx
pushq $-0x1
popq %rax
movl %esi, %ecx
subl %edx, %ecx
jl 0xb175
movzwl 0x4(%rdi), %r8d
rolw $0x8, %r8w
movzwl %r8w, %r8d
addl %edx, %r8d
cmpl %esi, %r8d
jbe 0xb175
addq $0x6, %rdi
addl %ecx, %ecx
movslq %ecx, %rcx
leaq (%rdi,%rcx), %rax
leaq (%rdi,%rcx), %r9
incq %r9
jmp 0xb169
movzwl 0x2(%rdi), %eax
rolw $0x8, %ax
movzwl %ax, %ecx
addq $0x4, %rdi
xorl %edx, %edx
pushq $-0x1
popq %rax
leal -0x1(%rcx), %r8d
cmpl %ecx, %edx
jge 0xb175
leal (%rdx,%r8), %r10d
sarl %r10d
imull $0x6, %r10d, %r9d
movslq %r9d, %r11
leaq (%rdi,%r11), %r9
movzwl (%rdi,%r11), %r11d
rolw $0x8, %r11w
movzwl %r11w, %r11d
cmpl %esi, %r11d
jg 0xb15c
movzwl 0x2(%r9), %edx
rolw $0x8, %dx
movzwl %dx, %edx
cmpl %esi, %edx
jae 0xb161
incl %r10d
movl %r10d, %edx
jmp 0xb11b
movl %r10d, %ecx
jmp 0xb117
leaq 0x4(%r9), %rax
addq $0x5, %r9
movzbl (%rax), %ecx
shll $0x8, %ecx
movzbl (%r9), %eax
orl %ecx, %eax
popq %rbp
retq
leaq 0x2be8(%rip), %rdi      # 0xdd66
leaq 0x2ae3(%rip), %rsi      # 0xdc68
leaq 0x3100(%rip), %rcx      # 0xe28c
movl $0x95f, %edx            # imm = 0x95F
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O2/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt__tesselate_curve
static int stbtt__tesselate_curve(stbtt__point *points, int *num_points, float x0, float y0, float x1, float y1, float x2, float y2, float objspace_flatness_squared, int n)
{
   // midpoint
   float mx = (x0 + 2*x1 + x2)/4;
   float my = (y0 + 2*y1 + y2)/4;
   // versus directly drawn line
   float dx = (x0+x2)/2 - mx;
   float dy = (y0+y2)/2 - my;
   if (n > 16) // 65536 segments on one curve better be enough!
      return 1;
   if (dx*dx+dy*dy > objspace_flatness_squared) { // half-pixel error allowed... need to be smaller if AA
      stbtt__tesselate_curve(points, num_points, x0,y0, (x0+x1)/2.0f,(y0+y1)/2.0f, mx,my, objspace_flatness_squared,n+1);
      stbtt__tesselate_curve(points, num_points, mx,my, (x1+x2)/2.0f,(y1+y2)/2.0f, x2,y2, objspace_flatness_squared,n+1);
   } else {
      stbtt__add_point(points, *num_points,x2,y2);
      *num_points = *num_points+1;
   }
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edx, %r14d
movss %xmm6, -0x24(%rbp)
movaps %xmm3, %xmm7
movaps %xmm2, %xmm8
movq %rsi, %rbx
movq %rdi, %r15
movss 0x28e7(%rip), %xmm9     # 0xdaa8
movss %xmm5, -0x20(%rbp)
movss %xmm4, -0x1c(%rbp)
cmpl $0x10, %r14d
jg 0xb2eb
movaps %xmm8, %xmm10
addss %xmm8, %xmm10
addss %xmm0, %xmm10
addss %xmm4, %xmm10
movss 0x2934(%rip), %xmm2     # 0xdb24
mulss %xmm2, %xmm10
movaps %xmm7, %xmm11
addss %xmm7, %xmm11
addss %xmm1, %xmm11
addss %xmm5, %xmm11
mulss %xmm2, %xmm11
movaps %xmm1, %xmm2
addss %xmm5, %xmm2
mulss %xmm9, %xmm2
subss %xmm11, %xmm2
movaps %xmm0, %xmm3
addss %xmm4, %xmm3
mulss %xmm9, %xmm3
subss %xmm10, %xmm3
mulss %xmm2, %xmm2
mulss %xmm3, %xmm3
addss %xmm2, %xmm3
movss -0x24(%rbp), %xmm6
ucomiss %xmm6, %xmm3
jbe 0xb2d2
movaps %xmm0, %xmm2
addss %xmm8, %xmm2
mulss %xmm9, %xmm2
movaps %xmm1, %xmm3
addss %xmm7, %xmm3
mulss %xmm9, %xmm3
incl %r14d
movq %r15, %rdi
movq %rbx, %rsi
movaps %xmm10, %xmm4
movaps %xmm11, %xmm5
movl %r14d, %edx
movss %xmm7, -0x34(%rbp)
movss %xmm8, -0x30(%rbp)
movss %xmm10, -0x28(%rbp)
movss %xmm11, -0x2c(%rbp)
callq 0xb196
movss 0x280d(%rip), %xmm9     # 0xdaa8
movss -0x30(%rbp), %xmm8
movss -0x34(%rbp), %xmm7
movss -0x1c(%rbp), %xmm4
movss -0x20(%rbp), %xmm5
addss %xmm4, %xmm8
mulss %xmm9, %xmm8
addss %xmm5, %xmm7
mulss %xmm9, %xmm7
movss -0x28(%rbp), %xmm0
movss -0x2c(%rbp), %xmm1
jmp 0xb1cb
movslq (%rbx), %rax
testq %r15, %r15
je 0xb2e7
movss %xmm4, (%r15,%rax,8)
movss %xmm5, 0x4(%r15,%rax,8)
incl %eax
movl %eax, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ggerganov[P]font-rasterizer/./stb_truetype.h
// Function: stbtt__cuberoot
static float stbtt__cuberoot( float x )
{
   if (x<0)
      return -(float) STBTT_pow(-x,1.0f/3.0f);
   else
      return  (float) STBTT_pow( x,1.0f/3.0f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jbe 0xb92e
xorps 0x2220(%rip), %xmm0     # 0xdb30
cvtss2sd %xmm0, %xmm0
movsd 0x2264(%rip), %xmm1     # 0xdb80
callq 0x1070
cvtsd2ss %xmm0, %xmm0
xorps 0x2204(%rip), %xmm0     # 0xdb30
jmp 0xb943
cvtss2sd %xmm0, %xmm0
movsd 0x2246(%rip), %xmm1     # 0xdb80
callq 0x1070
cvtsd2ss %xmm0, %xmm0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movzbl (%rdi), %eax
testl %eax, %eax
je 0xb997
cmpl $0x74, %eax
je 0xb967
cmpl $0x4f, %eax
je 0xb983
cmpl $0x31, %eax
jne 0xb9be
cmpb $0x0, 0x1(%rdi)
jne 0xb9be
jmp 0xb99d
movzbl 0x1(%rdi), %eax
cmpl $0x72, %eax
je 0xb9ab
cmpl $0x79, %eax
jne 0xb9be
cmpb $0x70, 0x2(%rdi)
jne 0xb9be
cmpb $0x31, 0x3(%rdi)
je 0xb9b7
jmp 0xb9be
cmpb $0x54, 0x1(%rdi)
jne 0xb9be
cmpb $0x54, 0x2(%rdi)
jne 0xb9be
cmpb $0x4f, 0x3(%rdi)
je 0xb9b7
jmp 0xb9be
cmpb $0x1, 0x1(%rdi)
jne 0xb9be
cmpb $0x0, 0x2(%rdi)
jne 0xb9be
cmpb $0x0, 0x3(%rdi)
jne 0xb9be
jmp 0xb9b7
cmpb $0x75, 0x2(%rdi)
jne 0xb9be
cmpb $0x65, 0x3(%rdi)
jne 0xb9be
movl $0x1, %eax
jmp 0xb9c0
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0xe83(%rip), %rdi       # 0x2004
xorl %esi, %esi
xorl %eax, %eax
callq 0x1050
movl %eax, %ebx
leaq 0xea2(%rip), %r14       # 0x2035
pushq $0x8
popq %r15
leaq 0xeae(%rip), %r12       # 0x204c
xorl %r13d, %r13d
leaq 0xe6b(%rip), %rdi       # 0x2013
callq 0x1030
movl %ebx, %edi
pushq $0x2
popq %rsi
callq 0x1060
leaq 0xe6a(%rip), %rdi       # 0x2028
callq 0x1030
leaq 0xe41(%rip), %rdi       # 0x200b
movl %r13d, %esi
xorl %eax, %eax
callq 0x1040
movq %r14, %rdi
callq 0x1030
movl %ebx, %edi
movl %r15d, %esi
callq 0x1060
movq %r12, %rdi
callq 0x1030
incl %r13d
jmp 0x11a1
// File: /workspace/github_c_makefile_star2_O2/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_7/exercise_7_06/compare.c
// Function: main
int main(int argc, char *argv[])
{
  if (!parse_arg_list(argc, argv))
  {
    fprintf(stderr, "Error: invalid arguments.\n");
    exit(EXIT_FAILURE);
  }

  char *program_name = argv[0];

  FILE *file_1;
  FILE *file_2;

  if ((file_1 = fopen(argv[1], "r")) == NULL)
  {
    fprintf(stderr, "%s: can't open %s.\n", program_name, argv[1]);
    exit(EXIT_FAILURE);
  }

  if ((file_2 = fopen(argv[2], "r")) == NULL)
  {
    fprintf(stderr, "%s: can't open %s.\n", program_name, argv[2]);
    exit(EXIT_FAILURE);
  }

  char line_1[MAX_LINE_LEN];
  char line_2[MAX_LINE_LEN];

  size_t line_number = 1;
  while (fgets(line_1, MAX_LINE_LEN, file_1) != NULL && fgets(line_2, MAX_LINE_LEN, file_2) != NULL)
  {
    if (strcmp(line_1, line_2) != 0)
    {
      printf("%s [%zu]: %s", argv[1], line_number, line_1);
      fclose(file_1);

      printf("%s [%zu]: %s", argv[2], line_number, line_2);
      fclose(file_2);
      break;
    }

    ++line_number;
  }

  exit(EXIT_SUCCESS);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7d8, %rsp            # imm = 0x7D8
cmpl $0x3, %edi
jne 0x11ed
movq %rsi, %rbx
movq (%rsi), %r12
movq 0x8(%rsi), %rdi
leaq 0xe4c(%rip), %rsi       # 0x201f
callq 0x1080
testq %rax, %rax
jne 0x120b
movq 0x2e14(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq 0x8(%rbx), %rcx
jmp 0x1231
movq 0x2e04(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xe06(%rip), %rdi       # 0x2004
pushq $0x1a
popq %rsi
pushq $0x1
popq %rdx
callq 0x10a0
jmp 0x1242
movq %rax, %r15
movq 0x10(%rbx), %rdi
leaq 0xe06(%rip), %rsi       # 0x201f
callq 0x1080
testq %rax, %rax
jne 0x124a
movq 0x2dce(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq 0x10(%rbx), %rcx
leaq 0xde9(%rip), %rsi       # 0x2021
movq %r12, %rdx
xorl %eax, %eax
callq 0x1070
pushq $0x1
popq %rdi
callq 0x1090
movq %rax, %r14
pushq $0x1
popq %r12
leaq 0x3f0(%rsp), %r13
movq %rsp, %rbp
movq %r13, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
movq %r15, %rdx
callq 0x1050
testq %rax, %rax
je 0x12de
movq %rbp, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
movq %r14, %rdx
callq 0x1050
testq %rax, %rax
je 0x12de
movq %r13, %rdi
movq %rbp, %rsi
callq 0x1060
testl %eax, %eax
jne 0x129a
incq %r12
jmp 0x125c
movq 0x8(%rbx), %rsi
leaq 0xd90(%rip), %r13       # 0x2035
leaq 0x3f0(%rsp), %rcx
movq %r13, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x1040
movq %r15, %rdi
callq 0x1030
movq 0x10(%rbx), %rsi
movq %rsp, %rcx
movq %r13, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x1040
movq %r14, %rdi
callq 0x1030
xorl %edi, %edi
callq 0x1090
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
xorl %ebx, %ebx
testl %esi, %esi
cmovlel %ebx, %esi
movl %esi, 0x8(%rsp)
testl %edi, %edi
movl $0x0, %eax
movl %edi, 0x4(%rsp)
cmovgl %edi, %eax
movl %eax, 0xc(%rsp)
movl %edx, %r15d
pushq $0x18
popq %r13
xorl %r14d, %r14d
cmpl 0xc(%rsp), %ebx
je 0x16c5
movq %r14, 0x18(%rsp)
pushq $0x1
popq %rdi
movq %r13, %rsi
callq 0x10c0
movq %rbx, 0x20(%rsp)
movq %rax, 0x10(%rsp)
movl %ebx, (%rax)
movl 0x8(%rsp), %ebx
xorl %r12d, %r12d
subl $0x1, %ebx
jb 0x16aa
pushq $0x1
popq %rdi
movq %r13, %rsi
callq 0x10c0
movq %rax, %r14
movl %r15d, %edi
callq 0x15f8
movsd %xmm0, (%r14)
movl %ebp, %edi
callq 0x15f8
movsd %xmm0, 0x8(%r14)
movq %r12, 0x10(%r14)
movq %r14, %r12
jmp 0x1674
movq 0x10(%rsp), %r14
movq %r12, 0x8(%r14)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%r14)
movq 0x20(%rsp), %rbx
incl %ebx
jmp 0x164b
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x10c0
movl $0x1, (%rax)
movl 0x4(%rsp), %ecx
movl %ecx, 0x4(%rax)
movq %r14, 0x8(%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x10c0
movq %rax, %r13
leaq 0x19e2(%rip), %r14      # 0x30f8
leaq 0x14(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x1050
leaq 0x44(%rsp), %r12
movq %rbx, %rdi
movq %r14, %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)
leaq 0x38(%rsp), %r13
leaq 0x30(%rsp), %rbp
xorl %ecx, %ecx
xorl %edx, %edx
cmpl %eax, %ecx
jge 0x181b
movq %rdx, 0x28(%rsp)
movl %ecx, 0x8(%rsp)
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
callq 0x10c0
movq %rax, %r14
xorl %r12d, %r12d
movq %rbx, %rdi
leaq 0x1972(%rip), %rsi      # 0x3100
leaq 0x10(%rsp), %rdx
leaq 0xc(%rsp), %rcx
xorl %eax, %eax
callq 0x1050
movl 0x10(%rsp), %eax
movq %r14, 0x20(%rsp)
movl %eax, (%r14)
xorl %r14d, %r14d
cmpl 0xc(%rsp), %r14d
jge 0x17fa
pushq $0x18
popq %rdi
callq 0x10e0
movq %rax, %r15
movq %rbx, %rdi
leaq 0x193d(%rip), %rsi      # 0x3107
movq %r13, %rdx
movq %rbp, %rcx
xorl %eax, %eax
callq 0x1050
movsd 0x38(%rsp), %xmm0
movsd %xmm0, (%r15)
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x8(%r15)
movq %r12, 0x10(%r15)
incl %r14d
movq %r15, %r12
jmp 0x17ae
movq 0x20(%rsp), %rdx
movq %r12, 0x8(%rdx)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rdx)
movl 0x8(%rsp), %ecx
incl %ecx
movl 0x14(%rsp), %eax
jmp 0x1762
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_O2/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 0x190c
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x4(%rdi), %edx
leaq 0x18ae(%rip), %rsi      # 0x3110
movq %rbx, %rdi
xorl %eax, %eax
callq 0x10d0
movl (%r14), %edx
leaq 0x18a7(%rip), %rsi      # 0x311d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x10d0
addq $0x8, %r14
leaq 0x189d(%rip), %r15      # 0x3128
pushq $0xa
popq %rbp
leaq 0x189a(%rip), %r12      # 0x312f
movq (%r14), %r14
testq %r14, %r14
je 0x18fe
leaq 0x8(%r14), %r13
xorl %ecx, %ecx
movq %r13, %rax
movq (%rax), %rax
testq %rax, %rax
je 0x18b6
incl %ecx
addq $0x10, %rax
jmp 0x18a6
movl (%r14), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x10d0
movq (%r13), %r13
testq %r13, %r13
je 0x18ee
movsd (%r13), %xmm0
movsd 0x8(%r13), %xmm1
movq %rbx, %rdi
movq %r12, %rsi
movb $0x2, %al
callq 0x10d0
addq $0x10, %r13
jmp 0x18c6
movl %ebp, %edi
movq %rbx, %rsi
callq 0x10b0
addq $0x10, %r14
jmp 0x1895
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rdi, %rdi
je 0x1b0d
movq 0x8(%rdi), %rcx
xorpd %xmm0, %xmm0
movq 0x10(%rcx), %rax
testq %rax, %rax
je 0x1b11
movsd (%rcx), %xmm1
subsd (%rax), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm1
sqrtsd %xmm1, %xmm1
addsd %xmm1, %xmm0
movq %rax, %rcx
jmp 0x1ae7
xorpd %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rdi, %rdi
je 0x1b5f
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
addq $0x8, %rbx
xorpd %xmm0, %xmm0
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x1b59
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x1ada
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
addq $0x10, %rbx
jmp 0x1b27
addq $0x10, %rsp
popq %rbx
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1ba5
callq 0x1b93
movq %rbx, %rdi
popq %rbx
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O2/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 0x1bd7
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x1bc5
callq 0x1bae
movq 0x8(%rbx), %rdi
callq 0x1b93
movq %rbx, %rdi
popq %rbx
jmp 0x1030
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movl (%rdi), %edi
xorl %ecx, %ecx
movapd 0x1539(%rip), %xmm2     # 0x3140
movsd 0x1541(%rip), %xmm3     # 0x3150
cmpl %edi, %ecx
jge 0x1c4e
movq (%rax), %rax
testq %rax, %rax
je 0x1c4e
movq (%rax), %r14
movsd 0x8(%r14), %xmm4
subsd %xmm0, %xmm4
andpd %xmm2, %xmm4
ucomisd %xmm4, %xmm3
jbe 0x1c46
movsd 0x10(%r14), %xmm4
subsd %xmm1, %xmm4
andpd %xmm2, %xmm4
ucomisd %xmm4, %xmm3
ja 0x1c74
incl %ecx
addq $0x8, %rax
jmp 0x1c0f
incl %edi
movl %edi, (%rbx)
callq 0x1c7f
movq %rax, %r14
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x10c0
movq %r14, (%rax)
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x8(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x10, %rsp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
movl %edi, %ebx
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
callq 0x10c0
movl %ebx, (%rax)
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%rax)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x10c0
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1d23
movq %rdi, %r14
leaq 0x18(%rdi), %rax
movq (%rax), %rcx
testq %rcx, %rcx
je 0x1d03
leaq 0x8(%rcx), %rax
cmpq %rbx, (%rcx)
jne 0x1cf0
jmp 0x1d23
movq 0x18(%r14), %rsi
movq %rbx, %rdi
callq 0x1cb9
movq %rax, 0x18(%r14)
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x1cb9
movq %rax, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
callq 0x10c0
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x1ec0
movq (%rdi), %rcx
addq $0x18, %rcx
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x1ea0
incl %eax
addq $0x8, %rcx
jmp 0x1eb0
pushq $0x2
popq %rcx
cltd
idivl %ecx
retq
// File: /workspace/github_c_makefile_star2_O2/trumabrat[P]GrandProjet/reseau.c
// Function: afficheReseauSVG
void afficheReseauSVG(Reseau *R, char* nomInstance){
    CellNoeud *courN,*courv;
    SVGwriter svg;
    double maxx=0,maxy=0,minx=1e6,miny=1e6;

    courN=R->noeuds;
    while (courN!=NULL){
        if (maxx<courN->nd->x) maxx=courN->nd->x;
        if (maxy<courN->nd->y) maxy=courN->nd->y;
        if (minx>courN->nd->x) minx=courN->nd->x;
        if (miny>courN->nd->y) miny=courN->nd->y;
        courN=courN->suiv;
    }
    SVGinit(&svg,nomInstance,500,500);
    courN=R->noeuds;
    while (courN!=NULL){
        SVGpoint(&svg,500*(courN->nd->x-minx)/(maxx-minx),500*(courN->nd->y-miny)/(maxy-miny));
        courv=courN->nd->voisins;
        while (courv!=NULL){
            if (courv->nd->num<courN->nd->num)
                SVGline(&svg,500*(courv->nd->x-minx)/(maxx-minx),500*(courv->nd->y-miny)/(maxy-miny),500*(courN->nd->x-minx)/(maxx-minx),500*(courN->nd->y-miny)/(maxy-miny));
            courv=courv->suiv;
        }
        courN=courN->suiv;
    }
    SVGfinalize(&svg);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
addq $0x8, %rbx
movapd 0x1040(%rip), %xmm0     # 0x30e0
movapd %xmm0, 0x10(%rsp)
xorpd %xmm0, %xmm0
movapd %xmm0, (%rsp)
movq %rbx, %rax
movq (%rax), %rax
testq %rax, %rax
je 0x20e2
movq (%rax), %rcx
movupd 0x8(%rcx), %xmm0
movapd %xmm0, %xmm1
maxpd (%rsp), %xmm1
minpd 0x10(%rsp), %xmm0
addq $0x8, %rax
movapd %xmm1, (%rsp)
movapd %xmm0, 0x10(%rsp)
jmp 0x20b2
leaq 0x48(%rsp), %r14
movq %r14, %rdi
movl $0x1f4, %edx            # imm = 0x1F4
movl $0x1f4, %ecx            # imm = 0x1F4
callq 0x2d6c
movapd 0x10(%rsp), %xmm0
movapd (%rsp), %xmm1
subpd %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
movapd %xmm0, 0x30(%rsp)
movapd %xmm1, (%rsp)
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
movapd %xmm1, 0x20(%rsp)
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x220a
movq (%rbx), %rax
movsd 0x8(%rax), %xmm0
movsd 0x10(%rax), %xmm1
subsd 0x10(%rsp), %xmm0
movsd 0xfa8(%rip), %xmm2      # 0x30f0
mulsd %xmm2, %xmm0
divsd (%rsp), %xmm0
subsd 0x30(%rsp), %xmm1
mulsd %xmm2, %xmm1
divsd 0x20(%rsp), %xmm1
movq %r14, %rdi
callq 0x2edf
movq (%rbx), %r15
addq $0x18, %r15
movq (%r15), %r15
testq %r15, %r15
je 0x2201
movq (%r15), %rcx
movl (%rcx), %edx
movq (%rbx), %rax
cmpl (%rax), %edx
jge 0x21f8
movsd 0x8(%rcx), %xmm0
movsd 0x10(%rcx), %xmm1
movapd 0x10(%rsp), %xmm4
subsd %xmm4, %xmm0
movsd 0xf4b(%rip), %xmm8      # 0x30f0
mulsd %xmm8, %xmm0
movapd (%rsp), %xmm5
divsd %xmm5, %xmm0
movapd 0x30(%rsp), %xmm6
subsd %xmm6, %xmm1
mulsd %xmm8, %xmm1
movapd 0x20(%rsp), %xmm7
divsd %xmm7, %xmm1
movsd 0x8(%rax), %xmm2
movsd 0x10(%rax), %xmm3
subsd %xmm4, %xmm2
mulsd %xmm8, %xmm2
divsd %xmm5, %xmm2
subsd %xmm6, %xmm3
mulsd %xmm8, %xmm3
divsd %xmm7, %xmm3
movq %r14, %rdi
callq 0x2efb
addq $0x8, %r15
jmp 0x2170
addq $0x8, %rbx
jmp 0x2121
leaq 0x48(%rsp), %rdi
callq 0x2f27
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
testq %rdi, %rdi
je 0x2235
movq 0x8(%rdi), %rbx
callq 0x1030
movq %rbx, %rdi
jmp 0x2222
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x226b
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x224e
callq 0x2237
movq (%rbx), %rax
movq 0x18(%rax), %rdi
callq 0x2221
movq (%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
popq %rbx
jmp 0x1030
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x228c
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x2283
callq 0x226c
movq %rbx, %rdi
popq %rbx
jmp 0x1030
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x226c
movq 0x8(%rbx), %rdi
callq 0x2237
movq %rbx, %rdi
popq %rbx
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x10c0
testq %rax, %rax
je 0x237c
movq %rax, %rbx
movl %ebp, (%rax)
movslq %ebp, %rdi
pushq $0x8
popq %rsi
callq 0x10c0
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x2395
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xee1(%rip), %rdi       # 0x3264
leaq 0xede(%rip), %rsi       # 0x3268
leaq 0xee1(%rip), %rcx       # 0x3272
pushq $0x18
jmp 0x23ac
leaq 0xefb(%rip), %rdi       # 0x3297
leaq 0xec5(%rip), %rsi       # 0x3268
leaq 0xec8(%rip), %rcx       # 0x3272
pushq $0x1b
popq %rdx
callq 0x10a0
// File: /workspace/github_c_makefile_star2_O2/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 0x26d6
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movslq (%rbx), %rax
movq 0x8(%rbx), %rdi
cmpq %rax, %r14
jge 0x26c2
movq (%rdi,%r14,8), %rdi
callq 0x2221
incq %r14
jmp 0x26a8
callq 0x1030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1030
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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)
pushq $0x1
popq %rdi
pushq $0x48
popq %rsi
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_O2/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 0x2b7f
movsd 0x8(%rdx), %xmm3
ucomisd %xmm1, %xmm3
jbe 0x2b7f
pushq $0x28
jmp 0x2bb7
ucomisd %xmm2, %xmm0
jb 0x2b94
movsd 0x8(%rdx), %xmm3
ucomisd %xmm1, %xmm3
jbe 0x2b94
pushq $0x30
jmp 0x2bb7
ucomisd %xmm0, %xmm2
jbe 0x2ba1
ucomisd 0x8(%rdx), %xmm1
jae 0x2bb1
ucomisd %xmm2, %xmm0
jb 0x2bae
ucomisd 0x8(%rdx), %xmm1
jae 0x2bb5
xorl %eax, %eax
retq
pushq $0x38
jmp 0x2bb7
pushq $0x40
popq %rsi
addq %rdx, %rsi
jmp 0x2a38
// File: /workspace/github_c_makefile_star2_O2/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 0x2d69
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
je 0x2d36
callq 0x2d1f
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x2d44
callq 0x2d1f
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x2d52
callq 0x2d1f
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x2d60
callq 0x2d1f
movq %rbx, %rdi
popq %rbx
jmp 0x1030
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x285(%rip), %rsi       # 0x3030
movq %r12, %rdi
callq 0x10f0
movq %rax, 0x20(%rbx)
testq %rax, %rax
je 0x2e87
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 0x57a(%rip), %xmm0      # 0x3360
movups %xmm0, 0x28(%rbx)
leaq 0x5aa(%rip), %rdi       # 0x339b
pushq $0x41
popq %rsi
pushq $0x1
popq %r15
movq %r15, %rdx
movq %rax, %rcx
callq 0x1110
movq 0x20(%rbx), %rdi
leaq 0x5cf(%rip), %rsi       # 0x33dd
xorl %eax, %eax
callq 0x10d0
movq 0x20(%rbx), %rdi
cvtsi2sd %r14d, %xmm2
movsd 0x54a(%rip), %xmm0      # 0x3370
addsd %xmm0, %xmm2
cvtsi2sd %ebp, %xmm3
addsd %xmm0, %xmm3
leaq 0x5c2(%rip), %rsi       # 0x33fb
movsd 0x537(%rip), %xmm0      # 0x3378
movaps %xmm0, %xmm1
movb $0x4, %al
callq 0x10d0
movq 0x20(%rbx), %rcx
leaq 0x5c0(%rip), %rdi       # 0x3416
pushq $0x1c
popq %rsi
movq %r15, %rdx
callq 0x1110
movq 0x20(%rbx), %rcx
leaq 0x5c7(%rip), %rdi       # 0x3433
pushq $0x6
popq %rsi
movq %r15, %rdx
callq 0x1110
movb $0x23, (%rbx)
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4f8(%rip), %rdi       # 0x3386
movq %r15, %rsi
xorl %eax, %eax
callq 0x1090
pushq $0x1
popq %rdi
callq 0x1100
// File: /workspace/github_c_makefile_star2_O2/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 0x1d46
cmpl $0xf, %edi
ja 0x1cd9
movl $0xaa5500, %eax         # imm = 0xAA5500
cmpl $0x3, %edi
je 0x1d45
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 0x1d3a
addl $-0x10, %edi
movzbl %dil, %ecx
movb $0x24, %dl
movl %ecx, %eax
divb %dl
movzbl %al, %edx
movb $0x6, %sil
movl %ecx, %eax
divb %sil
movzbl %ah, %ecx
movzbl %al, %eax
divb %sil
movzbl %ah, %eax
imull $0x280000, %edx, %edx   # imm = 0x280000
addl $0x370000, %edx         # imm = 0x370000
xorl %esi, %esi
cmpl $0x24, %edi
cmovbl %esi, %edx
imull $0x2800, %eax, %edi     # imm = 0x2800
addl $0x3700, %edi           # imm = 0x3700
testb %al, %al
cmovel %esi, %edi
imull $0x28, %ecx, %eax
addl $0x37, %eax
testb %cl, %cl
cmovel %esi, %eax
orl %edx, %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_O2/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
andq $0x0, (%rbx)
movq %rbx, %rdx
callq 0x11554
movq %rax, %rdi
callq 0xe48f
movq (%rbx), %rbx
testq %rbx, %rbx
je 0xe483
movq %rbx, %r14
xorl %r15d, %r15d
movl (%r14), %eax
movsbq %al, %rcx
cmpq %rcx, %r15
jge 0xe47a
movq 0x18(%r14,%r15,8), %rdi
cmpw $0x100, %ax             # imm = 0x100
jb 0xe468
testq %rdi, %rdi
je 0xe475
callq 0x11878
movq %rax, %rdi
callq 0xe48f
incq %r15
jmp 0xe44c
movq 0x10(%r14), %r14
cmpq %rbx, %r14
jne 0xe449
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xe4ea
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rdi, %r15
xorl %r12d, %r12d
movl (%r15), %eax
movsbq %al, %rcx
cmpq %rcx, %r12
jge 0xe4d6
movq 0x18(%r15,%r12,8), %r14
cmpw $0x100, %ax             # imm = 0x100
jb 0xe4c1
testq %r14, %r14
je 0xe4d1
movq %r14, %rdi
callq 0xe773
movq %r14, %rdi
callq 0x12f9f
incq %r12
jmp 0xe4a5
movq 0x10(%r15), %r15
cmpq %rbx, %r15
jne 0xe4a2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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:
movq 0x10(%rdi), %rdx
movb 0x50(%rdx), %cl
leal -0x1(%rcx), %esi
negb %cl
pushq $-0x1
popq %rax
shrq %cl, %rax
movq 0x20(%rdi), %rcx
movq 0x68(%rdx), %rdx
movq %rax, %rdi
notq %rdi
xorl %r8d, %r8d
btl $0xe, %edx
cmovbq %r8, %rdi
movzbl %sil, %edx
btq %rdx, %rcx
cmovaeq %r8, %rdi
andq %rcx, %rax
orq %rdi, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xe7ac
movq 0x60(%rdi), %r14
testq %r14, %r14
je 0xe7ac
movq 0xb0(%rdi), %rdi
callq 0xe7b6
movl %eax, %ebx
cmpb $0x5, (%r14)
jne 0xe7ac
movq 0x90(%r14), %rdi
testq %rdi, %rdi
je 0xe7ac
callq 0xfb5a
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xfea4
movl %esi, %ebx
movq %rdi, %r14
callq 0x2d0ed
testq %rax, %rax
je 0xfe96
movq %rax, %r15
movq %r14, %rdi
callq 0xe7b6
movl (%r14), %eax
cmpb $0x1, %al
jne 0xfe9f
cmpl $0x1, %ebx
jne 0xfe5c
btl $0xc, %eax
jae 0xfeb1
testb $0x1, 0x28(%r14)
jne 0xfeb1
movb 0x50(%r15), %cl
decb %cl
pushq $0x1
popq %rax
shlq %cl, %rax
movq 0x20(%r14), %rbx
movzbl %cl, %ecx
btq %rcx, %rbx
jb 0xfe7b
jmp 0xfec4
movq 0x60(%r15), %r15
cmpb $0x2, (%r15)
jne 0xfe77
testb $0x40, 0x69(%r15)
jne 0xfec4
movq %rax, %rcx
negq %rcx
orq %rcx, %rbx
orq %rax, %rbx
jmp 0xfec4
leaq 0x294ad(%rip), %rsi     # 0x3934a
jmp 0xfeb8
cmpl $0x2, %ebx
jne 0xfea8
xorl %ebx, %ebx
jmp 0xfec4
leaq 0x294b8(%rip), %rsi     # 0x39367
jmp 0xfeb8
leaq 0x294c7(%rip), %rsi     # 0x3937f
xorl %ebx, %ebx
movq %r14, %rdi
xorl %eax, %eax
callq 0x11292
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xff47
movq %rdi, %r14
movb 0x4f590(%rip), %bpl     # 0x5f480
callq 0x2d0ed
pushq $-0x1
popq %rbx
testq %rax, %rax
je 0xff55
movb $0x1, 0x4f57c(%rip)     # 0x5f480
movq %r14, %rdi
callq 0xe7b6
andb $0x1, %bpl
movb %bpl, 0x4f569(%rip)     # 0x5f480
movzbl (%r14), %eax
cmpl $0x15, %eax
jne 0xff26
movq 0x28(%r14), %r14
jmp 0xff17
cmpl $0x1, %eax
je 0xff4b
cmpl $0x1c, %eax
jne 0xff55
fldt 0x20(%r14)
fldz
fucompi %st(1), %st
fstp %st(0)
setp %al
setne %cl
orb %al, %cl
movzbl %cl, %ebx
jmp 0xff55
xorl %ebx, %ebx
jmp 0xff55
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_O2/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 0x4f517(%rip), %bpl     # 0x5f480
movb $0x1, 0x4f510(%rip)     # 0x5f480
callq 0xe7b6
movb %bpl, 0x4f504(%rip)     # 0x5f480
xorl %eax, %eax
cmpb $0x1, (%rbx)
jne 0xff8d
xorl %eax, %eax
cmpq $0x0, 0x20(%rbx)
sete %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq