LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/cbouilla[P]AES-attacks-finder/Solver.c
// Function: PropagateSolver2
Solver PropagateSolver2(Solver B, SysEqLin E, Solver *B1, int N1) // Pareil que PropagateSolver mais la mémoire ne compte pas
{
	Solver B2=copySolver(B);
	int i=0;
	while (i < N1)
	{
		Solver tmp=UnionSolverBorne(B2,B1[i],E,B2->sortie);
		if (tmp==NULL) i++;
		else
		{
			if (!PlusInteressant_NoVarsNoMem(tmp,B2)) // cas où la solver n'est pas améliorée "gratuitement" (cas le plus fréquent)
			{
				freeSolver(tmp);
				i++;
			}
			else
			{
				Solver tmp2=B1[i];
				N1--;
				B1[i]=B1[N1];
				B1[N1]=tmp2;
				if (tmp->Nvar==B2->Nvar) freeSolver(tmp); // cas B1[i] contenue dans B2
				else // cas où l'on améliore "gratuitement" la solver B2
				{
					freeSolver(B2);
					B2=tmp;
					i=0;
				}
			}
		}
	}
	return B2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9380
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0xb6a1
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x10(%rbp), %rdx
movq -0x28(%rbp), %rax
movl 0x14(%rax), %ecx
callq 0xac00
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0xb5f0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xb69c
movq -0x38(%rbp), %rax
movl 0x14(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jg 0xb610
movq -0x38(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jle 0xb624
movq -0x38(%rbp), %rdi
callq 0x93b0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xb69a
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x40(%rbp), %rdx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x38(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0xb680
movq -0x38(%rbp), %rdi
callq 0x93b0
jmp 0xb698
movq -0x28(%rbp), %rdi
callq 0x93b0
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
jmp 0xb69a
jmp 0xb69c
jmp 0xb5ab
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cbouilla[P]AES-attacks-finder/SysEqLin.c
// Function: NouvelleLigneCreuse
LigneCreuse NouvelleLigneCreuse(void) // Renvoi l'adresse d'une SOLVER disponible
{
	static int Initialiser_Espace = 1;
		
	if (Nombre_de_LigneCreuse_disponible_pour_allocation) return Espace_LigneCreuse_pour_allocation[--Nombre_de_LigneCreuse_disponible_pour_allocation];
	else
	{
		if (Initialiser_Espace)
		{
			Initialiser_Espace = 0;
			Espace_LigneCreuse_pour_allocation = malloc(TAILLE_BLOC_POUR_ALLOCATION_Espace*sizeof(LigneCreuse));
			Taille_Espace_LigneCreuse_pour_allocation = TAILLE_BLOC_POUR_ALLOCATION_Espace;
		}
		LIGNECREUSE * __restrict tmp = malloc(TAILLE_BLOC_POUR_ALLOCATION_Espace*sizeof(LIGNECREUSE));
		int i;
		for (i = 0; i < TAILLE_BLOC_POUR_ALLOCATION_Espace; i++)
		{
			Espace_LigneCreuse_pour_allocation[i]=tmp++;
			Espace_LigneCreuse_pour_allocation[i]->parents=1;
		}
		Nombre_de_LigneCreuse_disponible_pour_allocation = TAILLE_BLOC_POUR_ALLOCATION_Espace;
		return Espace_LigneCreuse_pour_allocation[--Nombre_de_LigneCreuse_disponible_pour_allocation];
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
cmpl $0x0, 0x2f2f1(%rip)     # 0x3d2e0
je 0xe017
movq 0x2f2f0(%rip), %rax     # 0x3d2e8
movl 0x2f2e2(%rip), %ecx     # 0x3d2e0
addl $-0x1, %ecx
movl %ecx, 0x2f2d9(%rip)     # 0x3d2e0
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0xe0cd
cmpl $0x0, 0x2f146(%rip)     # 0x3d164
je 0xe045
movl $0x0, 0x2f13a(%rip)     # 0x3d164
movl $0x13880, %edi          # imm = 0x13880
callq 0x21c0
movq %rax, 0x2f2ad(%rip)     # 0x3d2e8
movl $0x2710, 0x2f29f(%rip)  # imm = 0x2710
movl $0x3a980, %edi          # imm = 0x3A980
callq 0x21c0
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x2710, -0x14(%rbp)    # imm = 0x2710
jge 0xe0a2
movq -0x10(%rbp), %rdx
movq %rdx, %rax
addq $0x18, %rax
movq %rax, -0x10(%rbp)
movq 0x2f26f(%rip), %rax     # 0x3d2e8
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x2f260(%rip), %rax     # 0x3d2e8
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl $0x1, 0x10(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xe05a
movl $0x2710, 0x2f234(%rip)  # imm = 0x2710
movq 0x2f235(%rip), %rax     # 0x3d2e8
movl 0x2f227(%rip), %ecx     # 0x3d2e0
addl $-0x1, %ecx
movl %ecx, 0x2f21e(%rip)     # 0x3d2e0
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cbouilla[P]AES-attacks-finder/SysEqLin.c
// Function: freeLigneCreuse
void freeLigneCreuse(LigneCreuse a) // libère la mémoire associée à une LigneCreuse
{
	if (a!=NULL)
	{
		(a->parents)--;
		if (!a->parents) // elle n'est plus utilisée
		{
			free(a->elements);
			a->parents=1;
			if (Taille_Espace_LigneCreuse_pour_allocation == Nombre_de_LigneCreuse_disponible_pour_allocation)
			{
				Taille_Espace_LigneCreuse_pour_allocation+= TAILLE_BLOC_POUR_ALLOCATION_Espace;
				Espace_LigneCreuse_pour_allocation = realloc(Espace_LigneCreuse_pour_allocation, Taille_Espace_LigneCreuse_pour_allocation*sizeof(LigneCreuse));
			}
			Espace_LigneCreuse_pour_allocation[Nombre_de_LigneCreuse_disponible_pour_allocation++]=a;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xe1b8
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0xe1b6
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movl $0x1, 0x10(%rax)
movl 0x2f188(%rip), %eax     # 0x3d2e4
cmpl 0x2f17e(%rip), %eax     # 0x3d2e0
jne 0xe193
movl 0x2f17a(%rip), %eax     # 0x3d2e4
addl $0x2710, %eax           # imm = 0x2710
movl %eax, 0x2f16f(%rip)     # 0x3d2e4
movq 0x2f16c(%rip), %rdi     # 0x3d2e8
movslq 0x2f161(%rip), %rsi     # 0x3d2e4
shlq $0x3, %rsi
callq 0x21f0
movq %rax, 0x2f155(%rip)     # 0x3d2e8
movq -0x8(%rbp), %rdx
movq 0x2f14a(%rip), %rax     # 0x3d2e8
movl 0x2f13c(%rip), %ecx     # 0x3d2e0
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x2f131(%rip)     # 0x3d2e0
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0xe1b8
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cbouilla[P]AES-attacks-finder/SysEqLin.c
// Function: NouvelleMatriceCreuse
MatriceCreuse NouvelleMatriceCreuse(void) // Renvoi l'adresse d'une SOLVER disponible
{
	static int Initialiser_Espace = 1;
		
	if (Nombre_de_MatriceCreuse_disponible_pour_allocation) return Espace_MatriceCreuse_pour_allocation[--Nombre_de_MatriceCreuse_disponible_pour_allocation];
	else
	{
		if (Initialiser_Espace)
		{
			Initialiser_Espace = 0;
			Espace_MatriceCreuse_pour_allocation = malloc(TAILLE_BLOC_POUR_ALLOCATION_Espace*sizeof(MatriceCreuse));
			Taille_Espace_MatriceCreuse_pour_allocation = TAILLE_BLOC_POUR_ALLOCATION_Espace;
		}
		MATRICECREUSE * __restrict tmp = malloc(TAILLE_BLOC_POUR_ALLOCATION_Espace*sizeof(MATRICECREUSE));
		int i;
		for (i = 0; i < TAILLE_BLOC_POUR_ALLOCATION_Espace; i++)
		{
			Espace_MatriceCreuse_pour_allocation[i]=tmp++;
			Espace_MatriceCreuse_pour_allocation[i]->parents=1;
		}
		Nombre_de_MatriceCreuse_disponible_pour_allocation = TAILLE_BLOC_POUR_ALLOCATION_Espace;
		return Espace_MatriceCreuse_pour_allocation[--Nombre_de_MatriceCreuse_disponible_pour_allocation];
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
cmpl $0x0, 0x2f121(%rip)     # 0x3d2f0
je 0xe1f7
movq 0x2f120(%rip), %rax     # 0x3d2f8
movl 0x2f112(%rip), %ecx     # 0x3d2f0
addl $-0x1, %ecx
movl %ecx, 0x2f109(%rip)     # 0x3d2f0
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0xe2ad
cmpl $0x0, 0x2ef6a(%rip)     # 0x3d168
je 0xe225
movl $0x0, 0x2ef5e(%rip)     # 0x3d168
movl $0x13880, %edi          # imm = 0x13880
callq 0x21c0
movq %rax, 0x2f0dd(%rip)     # 0x3d2f8
movl $0x2710, 0x2f0cf(%rip)  # imm = 0x2710
movl $0x3a980, %edi          # imm = 0x3A980
callq 0x21c0
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x2710, -0x14(%rbp)    # imm = 0x2710
jge 0xe282
movq -0x10(%rbp), %rdx
movq %rdx, %rax
addq $0x18, %rax
movq %rax, -0x10(%rbp)
movq 0x2f09f(%rip), %rax     # 0x3d2f8
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x2f090(%rip), %rax     # 0x3d2f8
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl $0x1, 0x10(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xe23a
movl $0x2710, 0x2f064(%rip)  # imm = 0x2710
movq 0x2f065(%rip), %rax     # 0x3d2f8
movl 0x2f057(%rip), %ecx     # 0x3d2f0
addl $-0x1, %ecx
movl %ecx, 0x2f04e(%rip)     # 0x3d2f0
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cbouilla[P]AES-attacks-finder/SysEqLin.c
// Function: freeMatriceCreuse
void freeMatriceCreuse(MatriceCreuse a) // libère la mémoire associée à une MatriceCreuse
{
	if (a!=NULL)
	{
		(a->parents)--;
		if (!a->parents) // elle n'est plus utilisée
		{
			int i;
			for (i = 0; i < a->nombre_de_lignes; i++) freeLigneCreuse(a->ligne[i]);
			free(a->ligne);
			a->parents=1;
			if (Taille_Espace_MatriceCreuse_pour_allocation == Nombre_de_MatriceCreuse_disponible_pour_allocation)
			{
				Taille_Espace_MatriceCreuse_pour_allocation+= TAILLE_BLOC_POUR_ALLOCATION_Espace;
				Espace_MatriceCreuse_pour_allocation = realloc(Espace_MatriceCreuse_pour_allocation, Taille_Espace_MatriceCreuse_pour_allocation*sizeof(MatriceCreuse));
			}
			Espace_MatriceCreuse_pour_allocation[Nombre_de_MatriceCreuse_disponible_pour_allocation++]=a;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xe3ce
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0xe3cc
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0xe354
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xe110
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xe329
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movl $0x1, 0x10(%rax)
movl 0x2ef82(%rip), %eax     # 0x3d2f4
cmpl 0x2ef78(%rip), %eax     # 0x3d2f0
jne 0xe3a9
movl 0x2ef74(%rip), %eax     # 0x3d2f4
addl $0x2710, %eax           # imm = 0x2710
movl %eax, 0x2ef69(%rip)     # 0x3d2f4
movq 0x2ef66(%rip), %rdi     # 0x3d2f8
movslq 0x2ef5b(%rip), %rsi     # 0x3d2f4
shlq $0x3, %rsi
callq 0x21f0
movq %rax, 0x2ef4f(%rip)     # 0x3d2f8
movq -0x8(%rbp), %rdx
movq 0x2ef44(%rip), %rax     # 0x3d2f8
movl 0x2ef36(%rip), %ecx     # 0x3d2f0
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x2ef2b(%rip)     # 0x3d2f0
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0xe3ce
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cbouilla[P]AES-attacks-finder/SysEqLin.c
// Function: TriLignesCreusesByNNZ
void TriLignesCreusesByNNZ(LigneCreuse * __restrict tableau, const int longueur)
{
	const int gap[8]={1, 4, 10, 23, 57, 132, 301, 701};
	int i=2;
	while (i<8 && gap[i]<longueur) i++;
    while(i>0)
    {
         i--;
         int j;
         for (j=gap[i];j<longueur;j++)
         {
             LigneCreuse valeur=tableau[j];
             int k=j;
             while((k>(gap[i]-1)) && (tableau[k-gap[i]]->nnz>valeur->nnz))
             {
				 tableau[k]=tableau[k-gap[i]];
				 k=k-gap[i];
             }
             tableau[k]=valeur;
         }
	 }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq 0x265fe(%rip), %rax     # 0x35320
movq %rax, -0x30(%rbp)
movq 0x265fb(%rip), %rax     # 0x35328
movq %rax, -0x28(%rbp)
movq 0x265f8(%rip), %rax     # 0x35330
movq %rax, -0x20(%rbp)
movq 0x265f5(%rip), %rax     # 0x35338
movq %rax, -0x18(%rbp)
movl $0x2, -0x34(%rbp)
xorl %eax, %eax
cmpl $0x8, -0x34(%rbp)
movb %al, -0x45(%rbp)
jge 0xed6a
movslq -0x34(%rbp), %rax
movl -0x30(%rbp,%rax,4), %eax
cmpl -0xc(%rbp), %eax
setl %al
movb %al, -0x45(%rbp)
movb -0x45(%rbp), %al
testb $0x1, %al
jne 0xed73
jmp 0xed7e
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xed4e
jmp 0xed80
cmpl $0x0, -0x34(%rbp)
jle 0xee59
movl -0x34(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x34(%rbp)
movslq -0x34(%rbp), %rax
movl -0x30(%rbp,%rax,4), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xee54
movq -0x8(%rbp), %rax
movslq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %ecx
movslq -0x34(%rbp), %rax
movl -0x30(%rbp,%rax,4), %edx
subl $0x1, %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x46(%rbp)
jle 0xedfb
movq -0x8(%rbp), %rax
movl -0x44(%rbp), %ecx
movslq -0x34(%rbp), %rdx
subl -0x30(%rbp,%rdx,4), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl (%rax), %eax
movq -0x40(%rbp), %rcx
cmpl (%rcx), %eax
setg %al
movb %al, -0x46(%rbp)
movb -0x46(%rbp), %al
testb $0x1, %al
jne 0xee04
jmp 0xee36
movq -0x8(%rbp), %rax
movl -0x44(%rbp), %ecx
movslq -0x34(%rbp), %rdx
subl -0x30(%rbp,%rdx,4), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movslq -0x44(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x44(%rbp), %eax
movslq -0x34(%rbp), %rcx
subl -0x30(%rbp,%rcx,4), %eax
movl %eax, -0x44(%rbp)
jmp 0xedc0
movq -0x40(%rbp), %rdx
movq -0x8(%rbp), %rax
movslq -0x44(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0xed9e
jmp 0xed80
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cbouilla[P]AES-attacks-finder/SysEqLin.c
// Function: PermuterVar
void PermuterVar(int a, int b, SysEqLin E) // Permute les variables a et b dans E
{
	int la=E->lignevar[a];
	int lb=E->lignevar[b];
	int i;
	for (i = 0; i < E->gen; i++) echangeligne(E->gen*la+i,E->gen*lb+i,E->mat,E->gen*VARIABLES,E->b);
	E->lignevar[a]=lb;
	E->lignevar[b]=la;
	E->varligne[la]=b;
	E->varligne[lb]=a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x4(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x8(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x104f5
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edi
imull -0x14(%rbp), %edi
addl -0x1c(%rbp), %edi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
imull -0x18(%rbp), %esi
addl -0x1c(%rbp), %esi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
leaq 0x2cdee(%rip), %rax     # 0x3d2c8
imull (%rax), %ecx
movq -0x10(%rbp), %rax
movl 0xc(%rax), %r8d
callq 0x35a0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1049d
movl -0x18(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x4(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x8(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x8(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x4(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x18(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cbouilla[P]AES-attacks-finder/SysEqLin.c
// Function: ConversionSys
Equation * ConversionSys(SysEqLin E) // Convertit un SysEqLin en système d'équations, le résulat contient E->b équations.
{
	Equation * __restrict Eq=malloc(E->b*sizeof(Equation));
	int i;
	for (i = 0; i < E->b; i++)
	{
		Eq[i]=NulEq();
		int j;
		for (j = 0; j < VARIABLES; j++)
		{
			int k;
			for (k = 0; k < E->gen; k++)
			{
				Equation tmp=varEq(E->varligne[j]);
				if (k!=0)
				{
					Equation tmp1=appliqueS(tmp,k-1);
					freeEq(tmp);
					tmp=tmp1;
				}
				Equation tmp1=mulEq(E->mat[E->gen*j+k][i],tmp);
				freeEq(tmp);
				tmp=addEq(tmp1,Eq[i]);
				freeEq(Eq[i]);
				freeEq(tmp1);
				Eq[i]=tmp;
			}
		}
	}
	return Eq;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movslq 0xc(%rax), %rdi
shlq $0x3, %rdi
callq 0x21c0
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x11f8e
callq 0x5850
movq %rax, %rdx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
leaq 0x2b44b(%rip), %rcx     # 0x3d2c8
cmpl (%rcx), %eax
jge 0x11f7e
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x11f6e
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %edi
callq 0x5da0
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x11ee1
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movzbl %al, %esi
callq 0x6ce0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x5900
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x10(%rcx), %ecx
imull -0x18(%rbp), %ecx
addl -0x1c(%rbp), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movslq -0x14(%rbp), %rcx
movb (%rax,%rcx), %al
movq -0x28(%rbp), %rsi
movzbl %al, %edi
callq 0x5ea0
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0x5900
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x6900
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x5900
movq -0x38(%rbp), %rdi
callq 0x5900
movq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x11e8c
jmp 0x11f70
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x11e73
jmp 0x11f80
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x11e48
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cbouilla[P]AES-attacks-finder/SysEqLin.c
// Function: ApparaitLineairement
int ApparaitLineairement(int x, SysEqLin E) // Renvoi vrai si il exite f tel que toutes les équations de E sont de la forme alpha*f(x) = ...
{
	int l=E->lignevar[x]*E->gen;
	int dim=Dimension(E->mat+l,E->gen,E->b,1);
	switch (dim)
	{
		case 0:
			return 2;
			break;
		case 1:
			return 1;
			break;
		default:
			return 0;
			break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rax
movslq -0x8(%rbp), %rdx
movl (%rax,%rdx,4), %eax
movl 0x10(%rcx), %ecx
imull %ecx, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movslq -0x14(%rbp), %rdx
leaq (%rcx,%rdx,8), %rdi
movl 0x10(%rax), %esi
movl 0xc(%rax), %edx
movl $0x1, %ecx
callq 0x3b00
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
testl %eax, %eax
je 0x121ef
jmp 0x121e5
movl -0x1c(%rbp), %eax
subl $0x1, %eax
je 0x121f8
jmp 0x12201
movl $0x2, -0x4(%rbp)
jmp 0x12208
movl $0x1, -0x4(%rbp)
jmp 0x12208
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cbouilla[P]AES-attacks-finder/SysEqLin.c
// Function: freeSysEq
void freeSysEq(SysEqLin E) // Libère la mémoire occupée par E
{
	int i;
	for (i = 0; i < VARIABLES*E->gen; i++) free(E->mat[i]);
	free(E->mat);
	if (E->initialise)
	{
		for (i = 0; i < E->a/E->gen; i++)
		{
			freeMatriceCreuse(E->sousmat[E->varligne[i]]);
		}
		free(E->sousmat);
	}
	free(E->lignevar);
	free(E->varligne);
	free(E);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
leaq 0x2b08b(%rip), %rcx     # 0x3d2c8
movl (%rcx), %ecx
movq -0x8(%rbp), %rdx
imull 0x10(%rdx), %ecx
cmpl %ecx, %eax
jge 0x1226a
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2030
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x12233
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
cmpb $0x0, 0x28(%rax)
je 0x122de
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x8(%rbp), %rcx
cltd
idivl 0x10(%rcx)
movl %eax, %ecx
movl -0x10(%rbp), %eax
cmpl %ecx, %eax
jge 0x122d1
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x20(%rcx), %rcx
movslq -0xc(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xe2f0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x12287
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rdi
callq 0x2030
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cbouilla[P]AES-attacks-finder/main.c
// Function: display_usage
void display_usage(char *s) {
 	printf("Usage: %s -e <equations> -t <time> [-m <memory>] [-r <type>] [-X|-x] [-C|-c] [-h]\n", s); 
  printf("Options:\n");
  printf("\t-e, --equations\t   File of the system of equations to solve\n");
  printf("\t-t, --time\t   Max time complexity\n");
  printf("\t-m, --memory\t   Memory complexity (default: time = memory)\n");
  printf("\t-r, --type\t   Type of the search. See below (default: 3)\n");
  printf("\t-X, --xml\t   Generate the XML tree of the attack\n");
  printf("\t-x, --noxml\t   Do not generate the XML tree of the attack\n");
  printf("\t-C, --code\t   Do not generate the code of the attack\n");
  printf("\t-c, --nocode\t   Generate the code of the attack\n");
  /*printf("\t-M, --reducemem\t   Try to decrease the memory complexity\n");*/
  printf("\t-h, --help\t   Display this help menu\n");
  printf("\n");
  printf("Algorithms :\n"
         "\t0 : Randomized Search (default) \n"
         "\t1 : Exhaustive Search (Balanced Solver)\n"
         "\t2 : Exhaustive Search for Guess-and-Determine Solver\n"
         "\t3 : Randomized Search (Symetric) \n"
         "\t4 : Manual Search\n"
         );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x22f2d(%rip), %rdi     # 0x35574
movb $0x0, %al
callq 0x2100
leaq 0x22f72(%rip), %rdi     # 0x355c7
movb $0x0, %al
callq 0x2100
leaq 0x22f6e(%rip), %rdi     # 0x355d1
movb $0x0, %al
callq 0x2100
leaq 0x22f9e(%rip), %rdi     # 0x3560f
movb $0x0, %al
callq 0x2100
leaq 0x22fb4(%rip), %rdi     # 0x35633
movb $0x0, %al
callq 0x2100
leaq 0x22fe3(%rip), %rdi     # 0x35670
movb $0x0, %al
callq 0x2100
leaq 0x23010(%rip), %rdi     # 0x356ab
movb $0x0, %al
callq 0x2100
leaq 0x23035(%rip), %rdi     # 0x356de
movb $0x0, %al
callq 0x2100
leaq 0x23063(%rip), %rdi     # 0x3571a
movb $0x0, %al
callq 0x2100
leaq 0x2308c(%rip), %rdi     # 0x35751
movb $0x0, %al
callq 0x2100
leaq 0x230b0(%rip), %rdi     # 0x35783
movb $0x0, %al
callq 0x2100
leaq 0x247f6(%rip), %rdi     # 0x36ed7
movb $0x0, %al
callq 0x2100
leaq 0x230bb(%rip), %rdi     # 0x357aa
movb $0x0, %al
callq 0x2100
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cbouilla[P]AES-attacks-finder/main.c
// Function: getXML
char* getXML(int t, int m, int r) {
  int 	len;
  char 	*sz;  
  char 	*sz2; 
  char 	*res;
  char  *tmp;
  
  len=strlen(eq_file);
  sz=eq_file;
  sz+=len-1;
	while(*--sz!='/');
  sz2=++sz;  
	while(*sz2++!='.');
  
  tmp=(char *)calloc(sz2-sz, sizeof(*res));
  strncpy(tmp, sz, sz2-sz-1);
  
  res=(char *)calloc(3+1+sz2-sz-1+1+2+1+2+1+2+4+1, sizeof(*res));
	sprintf(res, "xml/%s_%d-%d_%d.xml", tmp, t, m, r);
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq 0x2ac38(%rip), %rdi     # 0x3d380
callq 0x20e0
movl %eax, -0x10(%rbp)
movq 0x2ac29(%rip), %rax     # 0x3d380
movq %rax, -0x18(%rbp)
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x18(%rbp)
movsbl -0x1(%rax), %eax
cmpl $0x2f, %eax
je 0x12789
jmp 0x1276f
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movsbl (%rax), %eax
cmpl $0x2e, %eax
je 0x127b2
jmp 0x12799
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
subq %rax, %rdi
movl $0x1, %esi
callq 0x2150
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
subq %rax, %rdx
subq $0x1, %rdx
callq 0x2050
movq -0x20(%rbp), %rdi
addq $0x4, %rdi
movq -0x18(%rbp), %rax
subq %rax, %rdi
subq $0x1, %rdi
addq $0x1, %rdi
addq $0x2, %rdi
addq $0x1, %rdi
addq $0x2, %rdi
addq $0x1, %rdi
addq $0x2, %rdi
addq $0x4, %rdi
addq $0x1, %rdi
movl $0x1, %esi
callq 0x2150
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rdx
movl -0x4(%rbp), %ecx
movl -0x8(%rbp), %r8d
movl -0xc(%rbp), %r9d
leaq 0x2304d(%rip), %rsi     # 0x3588f
movb $0x0, %al
callq 0x2230
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cbouilla[P]AES-attacks-finder/main.c
// Function: getCFile
char* getCFile(int t, int m, int r) {
  int 	len;
  char 	*sz;  
  char 	*sz2; 
  char 	*res;
  char  *tmp;
  
  len=strlen(eq_file);
  sz=eq_file;
  sz+=len-1;
	while(*--sz!='/');
  sz2=++sz;  
	while(*sz2++!='.');
  
  tmp=(char *)calloc(sz2-sz, sizeof(*res));
  strncpy(tmp, sz, sz2-sz-1);
  
  res=(char *)calloc(sz2-sz-1+1+2+1+2+1+2+1, sizeof(*res));
	sprintf(res, "%s_%d-%d_%d", tmp, t, m, r);
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq 0x2ab08(%rip), %rdi     # 0x3d380
callq 0x20e0
movl %eax, -0x10(%rbp)
movq 0x2aaf9(%rip), %rax     # 0x3d380
movq %rax, -0x18(%rbp)
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x18(%rbp)
movsbl -0x1(%rax), %eax
cmpl $0x2f, %eax
je 0x128b9
jmp 0x1289f
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movsbl (%rax), %eax
cmpl $0x2e, %eax
je 0x128e2
jmp 0x128c9
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
subq %rax, %rdi
movl $0x1, %esi
callq 0x2150
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
subq %rax, %rdx
subq $0x1, %rdx
callq 0x2050
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
subq %rax, %rdi
subq $0x1, %rdi
addq $0x1, %rdi
addq $0x2, %rdi
addq $0x1, %rdi
addq $0x2, %rdi
addq $0x1, %rdi
addq $0x2, %rdi
addq $0x1, %rdi
movl $0x1, %esi
callq 0x2150
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rdx
movl -0x4(%rbp), %ecx
movl -0x8(%rbp), %r8d
movl -0xc(%rbp), %r9d
leaq 0x22f39(%rip), %rsi     # 0x358a3
movb $0x0, %al
callq 0x2230
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cbouilla[P]AES-attacks-finder/parser_machinery.c
// Function: register_string
int register_string(string_list_t **list, char *name) {
  string_list_t *head = list[0];

  while (head != NULL) {
    if (strcmp(head->name, name) == 0) return head->number;
    head = head->next;
  }
  int last_number = -1;
  if (list[0] != NULL) last_number = list[0]->number;

  head = malloc(sizeof(string_list_t));
  head->name = name;
  head->number = last_number + 1;
  head->next = *list;
  list[0] = head;
  return head->number;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x12ee1
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x2160
cmpl $0x0, %eax
jne 0x12ed3
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x12f49
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x12eab
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x12eff
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x24(%rbp)
movl $0x18, %edi
callq 0x21c0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cbouilla[P]AES-attacks-finder/parser_machinery.c
// Function: find_string
int find_string(string_list_t *list, char *name) {
  string_list_t *head = list;

  while (head != NULL) {
    if (strcmp(head->name, name) == 0) return head->number;
    head = head->next;
  }
  return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x12fae
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x2160
cmpl $0x0, %eax
jne 0x12fa0
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x12fb5
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x12f78
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cbouilla[P]AES-attacks-finder/parser_machinery.c
// Function: find_var_name
char * find_var_name(string_list_t *list, int n) {
  string_list_t *head = list;

  while (head != NULL) {
    if (head->number == n) return head->name;
    head = head->next;
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x13001
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x12ff3
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x13009
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x12fd3
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cbouilla[P]AES-attacks-finder/Algo.c
// Function: copyAlgo
void copyAlgo(FILE *dst, char *name_src, int tab) // Copie un fichier avec indentation
{
	FILE *src = fopen(name_src,"r");
	int j=1;
	char c;
	while ((c = fgetc(src)) != EOF)
	{
		if (j)
		{
			int i;
			for (i = 0; i < tab; i++) fprintf(dst,"	");
			j=0;
		}
		fputc(c, dst);
		if (c=='\n') j=1;
	}
	fclose(src);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1f920(%rip), %rsi     # 0x35ece
callq 0x2200
movq %rax, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2120
movb %al, -0x25(%rbp)
movsbl %al, %eax
cmpl $-0x1, %eax
je 0x1662a
cmpl $0x0, -0x24(%rbp)
je 0x1660b
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x16604
movq -0x8(%rbp), %rdi
leaq 0x1fe72(%rip), %rsi     # 0x36464
movb $0x0, %al
callq 0x2180
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x165df
movl $0x0, -0x24(%rbp)
movsbl -0x25(%rbp), %edi
movq -0x8(%rbp), %rsi
callq 0x2130
movsbl -0x25(%rbp), %eax
cmpl $0xa, %eax
jne 0x16628
movl $0x1, -0x24(%rbp)
jmp 0x165be
movq -0x20(%rbp), %rdi
callq 0x20d0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cbouilla[P]AES-attacks-finder/Search.c
// Function: GenerateSolver
Solver GenerateSolver(const int T, Solver *B1, const int N1, SysEqLin E) 
{
	int i=rand()%N1;
	int N=N1-1;
	Solver B=B1[i]; // On prend une solver au hasard
	B1[i]=B1[N];
	B1[N]=B;
	B=copySolver(B);
	while (B->sortie<T && N>0) // Tant que l'on peux guesser des solvers
	{
		while (B->sortie<T && N>0) // Tant que l'on peux guesser des solvers
		{
			i=rand()%N;
			Solver tmp=B1[i];
			N--;
			B1[i]=B1[N];
			B1[N]=tmp;
			tmp=UnionSolver(B,B1[N],E);
			freeSolver(B);
			B=tmp;
		}
		Solver tmp=PropagateSolver2(B,E,B1,N); // On l'augmente gratuitement
		freeSolver(B);
		B=tmp;
	}
	return B;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
callq 0x2280
cltd
idivl -0x14(%rbp)
movl %edx, -0x24(%rbp)
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x30(%rbp), %rdx
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x30(%rbp), %rdi
callq 0x9380
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl 0x14(%rax), %ecx
xorl %eax, %eax
cmpl -0x4(%rbp), %ecx
movb %al, -0x41(%rbp)
jge 0x21b6b
cmpl $0x0, -0x28(%rbp)
setg %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x21b77
jmp 0x21c4e
jmp 0x21b79
movq -0x30(%rbp), %rax
movl 0x14(%rax), %ecx
xorl %eax, %eax
cmpl -0x4(%rbp), %ecx
movb %al, -0x42(%rbp)
jge 0x21b94
cmpl $0x0, -0x28(%rbp)
setg %al
movb %al, -0x42(%rbp)
movb -0x42(%rbp), %al
testb $0x1, %al
jne 0x21ba0
jmp 0x21c20
callq 0x2280
cltd
idivl -0x28(%rbp)
movl %edx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
movl -0x28(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x38(%rbp), %rdx
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x20(%rbp), %rdx
callq 0xaa60
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x93b0
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x21b79
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl -0x28(%rbp), %ecx
callq 0xb580
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
callq 0x93b0
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x21b50
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cbouilla[P]AES-attacks-finder/Search.c
// Function: SearchAlgo
Solver SearchAlgo(SysEqLin E, int temps, int memoire, int *Known, int NKnown, int r, string_list_t *variable_names, Symetric_structure S) // 1° partie de la recherche d'algo
{
	int N1;
	Solver * __restrict B1=MakeSolver1(E,&N1);

	/* Ajustement du système d'équations pour prendre en compte que x = y est équivalent à S(x) = S(y) */
	while (EnleveFaussesEq(B1,N1,E)==1)
	{
		int i;
		for (i = 0; i < N1; i++) freeSolver(B1[i]);
		free(B1);
		B1=MakeSolver1(E,&N1);
	}
	
	Solver B;
	
	if (N1==1) // Si il y a une seule solver de complexité 1 on a gagné
	{
		B=B1[0];
		free(B1);
	}
	else
	{
		int i;
		for (i = 0; i < N1; i++) freeSolver(B1[i]);
		free(B1);

		/* On rentre dans le vif */
		SysEqLin F=EsachantX(Known,NKnown,E);
		B=SearchAlgo_tmp(F,temps,memoire,r,variable_names,S);
		
		freeSysEq(F);
	}
	
	return B;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl %r9d, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0xb340
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %esi
movq -0x8(%rbp), %rdx
callq 0xd9c0
cmpl $0x1, %eax
jne 0x23893
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x23877
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x93b0
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x23853
movq -0x30(%rbp), %rdi
callq 0x2030
movq -0x8(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0xb340
movq %rax, -0x30(%rbp)
jmp 0x23837
cmpl $0x1, -0x24(%rbp)
jne 0x238af
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
callq 0x2030
jmp 0x2391e
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x238da
movq -0x30(%rbp), %rax
movslq -0x44(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x93b0
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x238b6
movq -0x30(%rbp), %rdi
callq 0x2030
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x8(%rbp), %rdx
callq 0x11aa0
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x20(%rbp), %ecx
movq 0x10(%rbp), %r8
movq 0x18(%rbp), %r9
callq 0x22d20
movq %rax, -0x40(%rbp)
movq -0x50(%rbp), %rdi
callq 0x12220
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cbouilla[P]AES-attacks-finder/Search.c
// Function: GuessMinimumLight
int * GuessMinimumLight(int *X, int N, SysEqLin E, int *taille)
{
	int * __restrict X_tmp = malloc(N*sizeof(int));
	int i;
	for (i = 0; i < N; i++) X_tmp[i]=X[i];
	int * result = GuessMinimumLight_tmp(X_tmp,N,E,taille);
	free(X_tmp);
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movslq -0xc(%rbp), %rdi
shlq $0x2, %rdi
callq 0x21c0
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x23b68
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x23b3f
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x23930
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2030
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cbouilla[P]AES-attacks-finder/Symetric.c
// Function: InitialiseSymetricStrucure
Symetric_structure InitialiseSymetricStrucure(int **var_by_message,	int n_var_by_message, int n_message)
{
	Symetric_structure S = malloc(sizeof(SYMETRIC_STUCTURE));
	S->var_by_message = var_by_message;
	S->n_var_by_message = n_var_by_message;
	S->n_message = n_message;
	S->message_by_var=malloc(VARIABLES*sizeof(int));
	S->position_by_var=malloc(VARIABLES*sizeof(int));
	
	int i;
	for (i = n_message-1; i>=0 ; i--)
	{
		int j;
		for (j = 0; j < n_var_by_message; j++)
		{
			S->message_by_var[var_by_message[i][j]]=i;
			S->position_by_var[var_by_message[i][j]]=j;
		}
	}
	return S;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x20, %edi
callq 0x21c0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x10(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
leaq 0x196e2(%rip), %rax     # 0x3d2c8
movslq (%rax), %rdi
shlq $0x2, %rdi
callq 0x21c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
leaq 0x196c4(%rip), %rax     # 0x3d2c8
movslq (%rax), %rdi
shlq $0x2, %rdi
callq 0x21c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movl -0x10(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x23c95
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x23c88
movl -0x1c(%rbp), %edx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movslq -0x1c(%rbp), %rsi
movq (%rcx,%rsi,8), %rcx
movslq -0x20(%rbp), %rsi
movslq (%rcx,%rsi,4), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x20(%rbp), %edx
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movslq -0x1c(%rbp), %rsi
movq (%rcx,%rsi,8), %rcx
movslq -0x20(%rbp), %rsi
movslq (%rcx,%rsi,4), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x23c31
jmp 0x23c8a
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x23c24
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cbouilla[P]AES-attacks-finder/Symetric.c
// Function: SymetriseSolver
Solver SymetriseSolver(Solver B, SysEqLin E, Symetric_structure S)
{
	if (B!=NULL)
	{
		int decalage = 1;
		Solver out = copySolver(B);
		do
		{
			Solver tmp = SolverSymetrique(out,decalage,S);
			Solver tmp2 = UnionSolverBorne(out,tmp,E,B->sortie);
			freeSolver(tmp);
			if (tmp2!=NULL && tmp2->Nvar!=out->Nvar)
			{
				freeSolver(out);
				out=tmp2;
				decalage=2*decalage;
			}
			else
			{
				freeSolver(tmp2);
				return out;
			}
		} while (1);
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x23f11
movl $0x1, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9380
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x23f30
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movl 0x14(%rax), %ecx
callq 0xac00
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x93b0
cmpq $0x0, -0x40(%rbp)
je 0x23eee
movq -0x40(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x30(%rbp), %rcx
cmpl 0x8(%rcx), %eax
je 0x23eee
movq -0x30(%rbp), %rdi
callq 0x93b0
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %eax
shll %eax
movl %eax, -0x24(%rbp)
jmp 0x23f01
movq -0x40(%rbp), %rdi
callq 0x93b0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x23f19
jmp 0x23f03
movb $0x1, %al
testb $0x1, %al
jne 0x23e83
jmp 0x23f0f
jmp 0x23f11
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rongarret[P]clmm/utils.c
// Function: randombytes
void randombytes(u8 *buf, u64 cnt) {
  int devrandom = open("/dev/random", O_RDONLY);
  if (devrandom < 0) die("Failed to open /dev/random");
  int n = read(devrandom, buf, cnt);
  if (n != cnt) die("Failed to read enough random bytes from /dev/random");
  close(devrandom);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x4a5c(%rip), %rdi      # 0x6103
xorl %esi, %esi
movb $0x0, %al
callq 0x1110
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x16c5
leaq 0x4a00(%rip), %rdi      # 0x60c0
callq 0x1670
movl -0x14(%rbp), %edi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x10c0
movl %eax, -0x18(%rbp)
movslq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x16ee
leaq 0x49f2(%rip), %rdi      # 0x60db
callq 0x1670
movl -0x14(%rbp), %edi
callq 0x10b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rongarret[P]clmm/utils.c
// Function: mkvector
p_vector mkvector(size_t size, size_t padding) {
  size_t psize = size + padding;
  u8 *p = malloc(psize);
  bzero(p, psize);
  p_vector v = malloc(sizeof(struct p_vector));
  v->size = size;
  v->padding = p;
  v->data = p + padding;
  return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x10e0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1150
movl $0x18, %edi
callq 0x10e0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
addq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rongarret[P]clmm/utils.c
// Function: open_file
FILE *open_file(c_string path, c_string mode) {
  FILE *f = fopen(path, mode);
  if (!f) {
    perror(path);
    exit(-1);
  }
  return f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1120
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x180b
movq -0x8(%rbp), %rdi
callq 0x1130
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1160
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rongarret[P]clmm/utils.c
// Function: file_contents
p_vector file_contents(char* path, size_t padding) {
  FILE *f = open_file(path, "r");
  p_vector v = mkvector(file_size(path), padding);
  if (fread(v->data, v->size, 1, f) != 1) die("Failed to read file");
  return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x48d4(%rip), %rsi      # 0x610f
callq 0x17d0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1700
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x1750
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rcx
movl $0x1, %edx
callq 0x1040
cmpq $0x1, %rax
je 0x188c
leaq 0x488a(%rip), %rdi      # 0x6111
callq 0x1670
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rongarret[P]clmm/utils.c
// Function: write_pvector
int write_pvector(c_string path, p_vector v) {
  FILE *f = open_file(path, "w");
  int result = fwrite(v->data, v->size, 1, f);
  fclose(f);
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x486a(%rip), %rsi      # 0x6125
callq 0x17d0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rcx
movl $0x1, %edx
callq 0x1170
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1050
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rongarret[P]clmm/utils.c
// Function: write_cstring
int write_cstring(c_string path, c_string s) {
  FILE *f = open_file(path, "w");
  int result = fputs(s, f);
  fclose(f);
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x480a(%rip), %rsi      # 0x6125
callq 0x17d0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10a0
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1050
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)