LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/cbouilla[P]AES-attacks-finder/Solver.c
// Function: ReduireSolvers_tmp
int ReduireSolvers_tmp(Solver *B, int Nsolvers, SysEqLin E, int DejaTester)  // Comme ci-dessous mais la liste restreinte au "DejaTester" premiers éléments est dejà réduite.
{
	int i=DejaTester;
	while (i<Nsolvers)
	{
		int j=i-1;
		while (j>=0)
		{
			//Solver tmp=UnionSolver(B[i],B[j],E);
			Solver tmp=UnionSolverBorne(B[i],B[j],E,min(B[i]->sortie,B[j]->sortie));
			//if (PlusInteressant(tmp,B[i]) && PlusInteressant(tmp,B[j]))
			if (tmp!=NULL && PlusInteressant_NoVars(tmp,B[i]) && PlusInteressant_NoVars(tmp,B[j]))
			{
				freeSolver(B[i]);
				Nsolvers--;
				B[i]=B[Nsolvers];
				freeSolver(B[j]);
				i--;
				B[j]=B[i];
				B[i]=tmp;
				j=i-1;
			}
			else
			{
				freeSolver(tmp);
				j--;
			}
		}
		i++;
	}
	return Nsolvers;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movl %esi, 0xc(%rsp)
movq %rdi, %r15
cmpl 0xc(%rsp), %ecx
jge 0x7704
leal -0x1(%rcx), %ebx
movq %rcx, 0x10(%rsp)
movslq %ecx, %rbp
testl %ebx, %ebx
js 0x76f8
movq (%r15,%rbp,8), %rdi
movl %ebx, %r12d
movq (%r15,%r12,8), %rsi
movl 0x14(%rdi), %eax
movl 0x14(%rsi), %ecx
cmpl %ecx, %eax
cmovll %eax, %ecx
movq %r14, %rdx
callq 0x73be
movq %rax, %r13
testq %rax, %rax
je 0x76a7
movl 0x14(%r13), %eax
movq (%r15,%rbp,8), %rdi
cmpl 0x14(%rdi), %eax
jg 0x76a7
movl 0xc(%r13), %ecx
cmpl 0xc(%rdi), %ecx
jge 0x769c
movq (%r15,%r12,8), %rdx
cmpl 0x14(%rdx), %eax
jg 0x76a7
cmpl 0xc(%rdx), %ecx
jl 0x76b3
jne 0x76a7
movl 0x10(%r13), %eax
cmpl 0x10(%rdx), %eax
jg 0x76a7
jmp 0x76b3
jne 0x76a7
movl 0x10(%r13), %edx
cmpl 0x10(%rdi), %edx
jle 0x7681
movq %r13, %rdi
callq 0x6852
decl %ebx
jmp 0x763d
callq 0x6852
movl 0xc(%rsp), %ecx
movslq %ecx, %rax
decl %ecx
movl %ecx, 0xc(%rsp)
movq -0x8(%r15,%rax,8), %rax
movq %rax, (%r15,%rbp,8)
movq (%r15,%r12,8), %rdi
callq 0x6852
movq 0x10(%rsp), %rax
movl %eax, %ebx
decl %eax
movq -0x8(%r15,%rbp,8), %rcx
movq %rcx, (%r15,%r12,8)
movq %r13, -0x8(%r15,%rbp,8)
addl $-0x2, %ebx
movl %eax, %ecx
jmp 0x7635
movq 0x10(%rsp), %rcx
incl %ecx
jmp 0x7628
movl 0xc(%rsp), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/cbouilla[P]AES-attacks-finder/Solver.c
// Function: PropagateSolver
Solver PropagateSolver(Solver B, SysEqLin E, Solver *B1, int N1) // Renvoi la solver B augmentée gratuitement avec le maximum de solvers de la liste B1
{
	Solver B2=copySolver(B);
	int i=0;
	while (i < N1)
	{
		Solver tmp=UnionSolverBorne(B2,B1[i],E,B2->sortie);
		if (tmp==NULL || !PlusInteressant_NoVars(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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, (%rsp)
movq %rdi, %r15
testq %rdi, %rdi
je 0x77db
incl 0x1c(%r15)
xorl %r13d, %r13d
movl %ebp, %r14d
movl %r13d, %r13d
cmpl %r14d, %r13d
jge 0x787b
movq (%rbx,%r13,8), %rsi
movl 0x14(%r15), %ecx
movq %r15, %rdi
movq (%rsp), %rdx
callq 0x73be
movq %rax, %r12
testq %rax, %rax
je 0x785b
movl 0x14(%r12), %eax
cmpl 0x14(%r15), %eax
jg 0x785b
movl 0xc(%r15), %eax
cmpl %eax, 0xc(%r12)
jl 0x782c
jne 0x785b
movl 0x10(%r12), %eax
cmpl 0x10(%r15), %eax
jg 0x785b
movq (%rbx,%r13,8), %rax
leal -0x1(%r14), %ebp
movslq %ebp, %rcx
movq (%rbx,%rcx,8), %rdx
movq %rdx, (%rbx,%r13,8)
movq %rax, (%rbx,%rcx,8)
movl 0x8(%r12), %eax
cmpl 0x8(%r15), %eax
jne 0x786b
movq %r12, %rdi
callq 0x6852
decl %r14d
jmp 0x77e4
movq %r12, %rdi
callq 0x6852
incl %r13d
jmp 0x77e1
movq %r15, %rdi
callq 0x6852
movq %r12, %r15
jmp 0x77db
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r13d
movq %rdx, %rbx
movq %rsi, 0x10(%rsp)
movq %rdi, %r15
testq %rdi, %rdi
je 0x78b2
incl 0x1c(%r15)
movl %r13d, %r14d
xorl %ebp, %ebp
movslq %ebp, %rax
movq %rax, 0x8(%rsp)
cmpl %r14d, %ebp
jge 0x7951
movq 0x8(%rsp), %rax
movq (%rbx,%rax,8), %rsi
movl 0x14(%r15), %ecx
movq %r15, %rdi
movq 0x10(%rsp), %rdx
callq 0x73be
testq %rax, %rax
je 0x793a
movq %rax, %r12
movl 0x14(%rax), %eax
cmpl 0x14(%r15), %eax
jg 0x7932
movl 0xc(%r12), %eax
cmpl 0xc(%r15), %eax
jg 0x7932
movq 0x8(%rsp), %rsi
movq (%rbx,%rsi,8), %rax
leal -0x1(%r14), %r13d
movslq %r13d, %rcx
movq (%rbx,%rcx,8), %rdx
movq %rdx, (%rbx,%rsi,8)
movq %rax, (%rbx,%rcx,8)
movl 0x8(%r12), %eax
cmpl 0x8(%r15), %eax
jne 0x7941
movq %r12, %rdi
callq 0x6852
decl %r14d
jmp 0x78bf
movq %r12, %rdi
callq 0x6852
incl %ebp
jmp 0x78b7
movq %r15, %rdi
callq 0x6852
movq %r12, %r15
jmp 0x78b2
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/cbouilla[P]AES-attacks-finder/Solver.c
// Function: DeleteVariable
Solver DeleteVariable(int x, Solver B, SysEqLin E)
{
	if (B==NULL) return NULL;
	if (SearchElement(x,B->var,B->Nvar)==-1) return copySolver(B);
	if (B->type == 0) return NULL;
	Solver f2 = DeleteVariable(x,B->fils2,E);
	if (f2==NULL) return DeleteVariable(x,B->fils1,E);
	Solver f1;
	if (B->type==1) f1 = DeleteVariable(x,B->fils1,E);
	else
	{
		SysEqLin F = EsachantX(B->fils2->var,B->fils2->Nvar,E);
		f1 = DeleteVariable(x,B->fils1,F);
		freeSysEq(F);
	}
	if (f1 == NULL) return f2;
	if (B->type==2)
	{
		Solver result = NewSolver();
		result->var=DifferenceListesTriees(B->var,B->Nvar,&x,1,&result->Nvar);
		result->temps=max(f2->temps,max(0,f2->sortie)+f1->temps);
		result->memoire=max(f1->memoire,f2->memoire);
		result->sortie=max(0,f2->sortie)+max(0,f1->sortie);
		result->type=2;
		result->fils1 = f1;
		result->fils2 = f2;
		return result;
	}
	else
	{
		Solver result = UnionSolver(f1,f2,E);
		freeSolver(f1);
		freeSolver(f2);
		return result;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movl %edi, %ebp
testq %r14, %r14
je 0x79ae
movq (%r14), %rsi
movl 0x8(%r14), %edx
movl %ebp, %edi
callq 0x26cf
cmpl $-0x1, %eax
je 0x79b6
cmpb $0x0, 0x18(%r14)
je 0x79ae
movq 0x28(%r14), %rsi
movl %ebp, %edi
movq %r15, %rdx
callq 0x7963
testq %rax, %rax
jne 0x79bf
movq 0x20(%r14), %r14
jmp 0x7976
xorl %r14d, %r14d
jmp 0x7ab3
incl 0x1c(%r14)
jmp 0x7ab3
movq %rax, %rbx
movl %ebp, 0x4(%rsp)
cmpb $0x1, 0x18(%r14)
jne 0x79e0
movq 0x20(%r14), %rsi
movl %ebp, %edi
movq %r15, %rdx
callq 0x7963
movq %rax, %r12
jmp 0x7a0e
movq 0x28(%r14), %rax
movq (%rax), %rdi
movl 0x8(%rax), %esi
movq %r15, %rdx
callq 0xb021
movq %rax, %r13
movq 0x20(%r14), %rsi
movl %ebp, %edi
movq %rax, %rdx
callq 0x7963
movq %rax, %r12
movq %r13, %rdi
callq 0xb562
testq %r12, %r12
je 0x7a8d
cmpb $0x2, 0x18(%r14)
jne 0x7a92
callq 0x67a4
movq %rax, %r15
movq (%r14), %rdi
movl 0x8(%r14), %esi
leaq 0x8(%rax), %r8
leaq 0x4(%rsp), %rdx
pushq $0x1
popq %rcx
callq 0x263f
movq %rax, (%r15)
movl 0x14(%rbx), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
movl 0xc(%rbx), %edx
movl 0xc(%r12), %esi
addl %eax, %esi
cmpl %esi, %edx
cmovgl %edx, %esi
movl %esi, 0xc(%r15)
movl 0x10(%r12), %edx
movl 0x10(%rbx), %esi
cmpl %esi, %edx
cmovgl %edx, %esi
movl %esi, 0x10(%r15)
movl 0x14(%r12), %edx
testl %edx, %edx
cmovgl %edx, %ecx
addl %eax, %ecx
movl %ecx, 0x14(%r15)
movb $0x2, 0x18(%r15)
movq %r12, 0x20(%r15)
movq %rbx, 0x28(%r15)
movq %r15, %r14
jmp 0x7ab3
movq %rbx, %r14
jmp 0x7ab3
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x72e2
movq %rax, %r14
movq %r12, %rdi
callq 0x6852
movq %rbx, %rdi
callq 0x6852
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rax
movslq 0x273d8(%rip), %rax     # 0x302d8
testq %rax, %rax
je 0x8f19
leaq -0x1(%rax), %rcx
movl %ecx, 0x273c9(%rip)     # 0x302d8
leaq -0x8(,%rax,8), %rax
jmp 0x8f8e
cmpb $0x0, 0x273c8(%rip)     # 0x302e8
jne 0x8f44
movb $0x1, 0x273bf(%rip)     # 0x302e8
movl $0x13880, %edi          # imm = 0x13880
callq 0x21c0
movq %rax, 0x273a6(%rip)     # 0x302e0
movl $0x2710, 0x27398(%rip)  # imm = 0x2710
movl $0x3a980, %edi          # imm = 0x3A980
callq 0x21c0
xorl %ecx, %ecx
cmpq $0x2710, %rcx           # imm = 0x2710
je 0x8f7f
movq 0x27380(%rip), %rdx     # 0x302e0
movq %rax, (%rdx,%rcx,8)
addq $0x18, %rax
movq 0x27371(%rip), %rdx     # 0x302e0
movq (%rdx,%rcx,8), %rdx
movl $0x1, 0x10(%rdx)
incq %rcx
jmp 0x8f50
movl $0x270f, 0x2734f(%rip)  # imm = 0x270F
movl $0x13878, %eax          # imm = 0x13878
addq 0x2734b(%rip), %rax     # 0x302e0
movq (%rax), %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rdi, %rdi
je 0x9017
pushq %rbx
movq %rdi, %rbx
decl 0x10(%rdi)
jne 0x9016
movq 0x8(%rbx), %rdi
callq 0x2030
movl $0x1, 0x10(%rbx)
movslq 0x27311(%rip), %rdx     # 0x302dc
movl 0x27307(%rip), %ecx     # 0x302d8
movq 0x27308(%rip), %rax     # 0x302e0
cmpl %ecx, %edx
jne 0x9006
leaq 0x2710(%rdx), %rcx
movl %ecx, 0x272f3(%rip)     # 0x302dc
leaq 0x13880(,%rdx,8), %rsi
movq %rax, %rdi
callq 0x21f0
movq %rax, 0x272e0(%rip)     # 0x302e0
movl 0x272d2(%rip), %ecx     # 0x302d8
leal 0x1(%rcx), %edx
movl %edx, 0x272c9(%rip)     # 0x302d8
movslq %ecx, %rcx
movq %rbx, (%rax,%rcx,8)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rax
movslq 0x272cc(%rip), %rax     # 0x302ec
testq %rax, %rax
je 0x9039
leaq -0x1(%rax), %rcx
movl %ecx, 0x272bd(%rip)     # 0x302ec
leaq -0x8(,%rax,8), %rax
jmp 0x90ae
cmpb $0x0, 0x272c0(%rip)     # 0x30300
jne 0x9064
movb $0x1, 0x272b7(%rip)     # 0x30300
movl $0x13880, %edi          # imm = 0x13880
callq 0x21c0
movq %rax, 0x2729e(%rip)     # 0x302f8
movl $0x2710, 0x2728c(%rip)  # imm = 0x2710
movl $0x3a980, %edi          # imm = 0x3A980
callq 0x21c0
xorl %ecx, %ecx
cmpq $0x2710, %rcx           # imm = 0x2710
je 0x909f
movq 0x27278(%rip), %rdx     # 0x302f8
movq %rax, (%rdx,%rcx,8)
addq $0x18, %rax
movq 0x27269(%rip), %rdx     # 0x302f8
movq (%rdx,%rcx,8), %rdx
movl $0x1, 0x10(%rdx)
incq %rcx
jmp 0x9070
movl $0x270f, 0x27243(%rip)  # imm = 0x270F
movl $0x13878, %eax          # imm = 0x13878
addq 0x27243(%rip), %rax     # 0x302f8
movq (%rax), %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rdi, %rdi
je 0x915d
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
decl 0x10(%rdi)
jne 0x9156
xorl %r14d, %r14d
movslq (%rbx), %rax
movq 0x8(%rbx), %rdi
cmpq %rax, %r14
jge 0x90f8
movq (%rdi,%r14,8), %rdi
callq 0x8fa6
incq %r14
jmp 0x90de
callq 0x2030
movl $0x1, 0x10(%rbx)
movslq 0x271e5(%rip), %rdx     # 0x302f0
movl 0x271db(%rip), %ecx     # 0x302ec
movq 0x271e0(%rip), %rax     # 0x302f8
cmpl %ecx, %edx
jne 0x9146
leaq 0x2710(%rdx), %rcx
movl %ecx, 0x271c7(%rip)     # 0x302f0
leaq 0x13880(,%rdx,8), %rsi
movq %rax, %rdi
callq 0x21f0
movq %rax, 0x271b8(%rip)     # 0x302f8
movl 0x271a6(%rip), %ecx     # 0x302ec
leal 0x1(%rcx), %edx
movl %edx, 0x2719d(%rip)     # 0x302ec
movslq %ecx, %rcx
movq %rbx, (%rax,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movabsq $0x2, %rax
leaq 0x1dccd(%rip), %rcx     # 0x27330
cmpq $0x8, %rax
je 0x9673
cmpl %esi, (%rcx,%rax,4)
jge 0x9673
incq %rax
jmp 0x9663
movslq %esi, %rdx
testq %rax, %rax
jle 0x96ca
movslq -0x4(%rcx,%rax,4), %rsi
decq %rax
xorl %r8d, %r8d
movq %rsi, %r9
cmpq %rdx, %r9
jge 0x9676
movq (%rdi,%r9,8), %r10
movl %r8d, %r11d
leal (%rsi,%r11), %ebx
cmpl %esi, %ebx
jl 0x96b8
movslq %r11d, %r14
movq (%rdi,%r14,8), %r14
movl (%r14), %ebp
cmpl (%r10), %ebp
jle 0x96b8
movslq %ebx, %rbx
movq %r14, (%rdi,%rbx,8)
subl %esi, %r11d
jmp 0x9695
addl %esi, %r11d
movslq %r11d, %r11
movq %r10, (%rdi,%r11,8)
incq %r9
incl %r8d
jmp 0x9689
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq 0x18(%rdx), %rax
movslq %edi, %rcx
movq %rcx, 0x10(%rsp)
movl (%rax,%rcx,4), %ebp
movslq %ebp, %rcx
movq %rcx, 0x8(%rsp)
movslq %esi, %r12
movl (%rax,%r12,4), %r15d
movslq %r15d, %rax
movq %rax, (%rsp)
leaq 0x25f1f(%rip), %rax     # 0x302b8
movl (%rax), %r13d
xorl %r14d, %r14d
movl 0x10(%rbx), %esi
cmpl %esi, %r14d
jge 0xa3cd
movl %esi, %edi
imull %ebp, %edi
addl %r14d, %edi
movl %r13d, %ecx
imull %esi, %ecx
imull %r15d, %esi
addl %r14d, %esi
movq (%rbx), %rdx
movl 0xc(%rbx), %r8d
callq 0x2b30
incl %r14d
jmp 0xa39f
movq 0x18(%rbx), %rax
movq 0x10(%rsp), %rcx
movq (%rsp), %rsi
movl %esi, (%rax,%rcx,4)
movq 0x8(%rsp), %rdx
movl %edx, (%rax,%r12,4)
movq 0x20(%rbx), %rax
movl %r12d, (%rax,%rdx,4)
movl %ecx, (%rax,%rsi,4)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/cbouilla[P]AES-attacks-finder/SysEqLin.c
// Function: ExtraireEX2
SysEqLin ExtraireEX2(int *var, int N, SysEqLin E) // Calcul E(X) (sous forme de SysEqLin)
{
	SysEqLin F=malloc(sizeof(SYSEQLIN));
	F->mat=malloc(E->gen*VARIABLES*sizeof(unsigned char *));
	int i;
	for (i = 0; i < E->gen*VARIABLES; i++) F->mat[i]=malloc(E->b*sizeof(unsigned char));
	F->b=ExtraireEX(F->mat,var,N,E);
	F->gen=E->gen;
	F->lignevar=malloc(VARIABLES*sizeof(int));
	F->varligne=malloc(VARIABLES*sizeof(int));
	for (i = 0; i < VARIABLES; i++) F->lignevar[i]=E->lignevar[i];
	for (i = 0; i < VARIABLES; i++) F->varligne[i]=E->varligne[i];
	for (i = 0; i < N; i++) PermuterVar(var[i],F->varligne[i],F);
	F->a=N*E->gen;
	F->initialise=0;
	return F;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movl %esi, 0xc(%rsp)
movq %rdi, %r14
pushq $0x40
popq %rdi
callq 0x21c0
movq %rax, %r15
movslq 0x10(%rbx), %rcx
leaq 0x255aa(%rip), %rax     # 0x302b8
movslq (%rax), %rax
movq %rax, 0x10(%rsp)
imulq %rax, %rcx
movq %rcx, %rdi
movq %rcx, %rbp
shlq $0x3, %rdi
callq 0x21c0
movq %rax, %r12
movq %rax, (%r15)
xorl %r13d, %r13d
movq %rbp, %rax
testl %eax, %eax
movl $0x0, %ebp
cmovgl %eax, %ebp
cmpq %r13, %rbp
je 0xad56
movslq 0xc(%rbx), %rdi
callq 0x21c0
movq %rax, (%r12,%r13,8)
incq %r13
jmp 0xad3f
movq %r12, %rdi
movq %r14, %rsi
movl 0xc(%rsp), %edx
movq %rbx, %rcx
callq 0xa644
movl %eax, 0xc(%r15)
movl 0x10(%rbx), %eax
movl %eax, 0x10(%r15)
movq 0x10(%rsp), %rbp
movq %rbp, %r12
shlq $0x2, %r12
movq %r12, %rdi
callq 0x21c0
movq %rax, %r13
movq %rax, 0x18(%r15)
movq %r12, %rdi
callq 0x21c0
movq %rax, %r12
movq %rax, 0x20(%r15)
xorl %ecx, %ecx
testl %ebp, %ebp
movl $0x0, %eax
cmovgl %ebp, %eax
cmpq %rcx, %rax
je 0xadbf
movq 0x18(%rbx), %rdx
movl (%rdx,%rcx,4), %edx
movl %edx, (%r13,%rcx,4)
incq %rcx
jmp 0xada9
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0xadd6
movq 0x20(%rbx), %rdx
movl (%rdx,%rcx,4), %edx
movl %edx, (%r12,%rcx,4)
incq %rcx
jmp 0xadc1
xorl %r13d, %r13d
movl 0xc(%rsp), %eax
testl %eax, %eax
movl $0x0, %ebp
cmovgl %eax, %ebp
cmpq %r13, %rbp
je 0xae01
movl (%r14,%r13,4), %edi
movl (%r12,%r13,4), %esi
movq %r15, %rdx
callq 0xa35c
incq %r13
jmp 0xade7
movl 0xc(%rsp), %eax
imull 0x10(%rbx), %eax
movl %eax, 0x8(%r15)
movb $0x0, 0x28(%r15)
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movslq 0xc(%rdi), %r14
movq %r14, %rdi
shlq $0x3, %rdi
callq 0x21c0
movq %rax, (%rsp)
leaq 0x25054(%rip), %rax     # 0x302b8
movl (%rax), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
movq %rax, 0x10(%rsp)
movslq %r14d, %rax
cmpq %rax, %rcx
jge 0xb36d
movq %rcx, %r14
callq 0x4271
movq %rax, %r15
movq (%rsp), %rax
movq %r14, 0x8(%rsp)
movq %r15, (%rax,%r14,8)
xorl %ecx, %ecx
cmpq 0x10(%rsp), %rcx
je 0xb35c
movslq %ecx, %rax
movq %rax, 0x18(%rsp)
xorl %r14d, %r14d
movq %rcx, 0x20(%rsp)
cmpl 0x10(%rbx), %r14d
jge 0xb354
movq 0x20(%rbx), %rax
movl (%rax,%rcx,4), %edi
callq 0x451b
movq %rax, %r12
testl %r14d, %r14d
je 0xb2ee
leal -0x1(%r14), %eax
movzbl %al, %esi
movq %r12, %rdi
callq 0x4d8b
movq %rax, %r13
movq %r12, %rdi
callq 0x42a5
movq %r13, %r12
movq (%rbx), %rax
movslq 0x10(%rbx), %rcx
imulq 0x18(%rsp), %rcx
addq %r14, %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rsp), %rbp
movzbl (%rax,%rbp), %edi
movq %r12, %rsi
callq 0x45c6
movq %rax, %r13
movq %r12, %rdi
callq 0x42a5
movq %r13, %rdi
movq %r15, %rsi
callq 0x4b60
movq %rax, %r12
movq %r15, %rdi
callq 0x42a5
movq %r13, %rdi
callq 0x42a5
movq (%rsp), %rax
movq %r12, (%rax,%rbp,8)
incq %r14
movq %r12, %r15
movq 0x20(%rsp), %rcx
jmp 0xb2b3
incq %rcx
jmp 0xb298
movq 0x8(%rsp), %rcx
incq %rcx
movl 0xc(%rbx), %r14d
jmp 0xb272
movq (%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/cbouilla[P]AES-attacks-finder/SysEqLin.c
// Function: ConversionSys2
Equation * ConversionSys2(int *X, int n, SysEqLin E) // Convertit un SysEqLin en système d'équations
{
	/* Propriété speciale :
	 *		- le resulat a 2*E->b Equation
	 * 		- le resultat est à lire Eq[i] = Eq[ i + E->b], Eq[i] est en les variables X, 0 <= i < E->b
	 */
	 
	Tri(X,n);
	Equation * __restrict Eq=malloc(2*E->b*sizeof(Equation));
	int i;
	for (i = 0; i < E->b; i++)
	{
		Eq[i]=NulEq();
		Eq[i+E->b]=NulEq();
		int pos=0,j;
		for (j = 0; j < VARIABLES; j++)
		{
			int l;
			if (pos<n && j==X[pos])
			{
				l=i;
				pos++;
			}
			else l=i+E->b;
			int k;
			for (k = 0; k < E->gen; k++)
			{
				Equation tmp=varEq(j);
				if (k!=0)
				{
					Equation tmp1=appliqueS(tmp,k-1);
					freeEq(tmp);
					tmp=tmp1;
				}
				Equation tmp1=mulEq(E->mat[E->gen*E->lignevar[j]+k][i],tmp);
				freeEq(tmp);
				tmp=addEq(tmp1,Eq[l]);
				freeEq(Eq[l]);
				freeEq(tmp1);
				Eq[l]=tmp;
			}
		}
	}
	return Eq;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
callq 0x27bf
movslq 0xc(%rbx), %r14
movq %r14, %rdi
shlq $0x4, %rdi
callq 0x21c0
movq %rax, 0x8(%rsp)
leaq 0x24efd(%rip), %rax     # 0x302b8
movslq (%rax), %rax
movq %rax, 0x20(%rsp)
xorl %r15d, %r15d
movq %rbx, 0x28(%rsp)
movslq %r14d, %rax
cmpq %rax, %r15
jge 0xb514
callq 0x4271
movq 0x8(%rsp), %r14
movq %rax, (%r14,%r15,8)
callq 0x4271
movslq 0xc(%rbx), %rcx
movslq %r15d, %rdx
addq %rcx, %rdx
movq %rax, (%r14,%rdx,8)
xorl %ebp, %ebp
xorl %edx, %edx
movq %r15, 0x30(%rsp)
cmpq 0x20(%rsp), %rbp
jge 0xb508
cmpl 0x14(%rsp), %edx
jge 0xb42d
movslq %edx, %rax
movq 0x18(%rsp), %rcx
movl (%rcx,%rax,4), %eax
cmpq %rax, %rbp
jne 0xb42d
incl %edx
movl %edx, 0x4(%rsp)
movl %r15d, %eax
jmp 0xb437
movl %edx, 0x4(%rsp)
movl 0xc(%rbx), %eax
addl %r15d, %eax
cltq
movq %rax, 0x38(%rsp)
xorl %r12d, %r12d
cmpl 0x10(%rbx), %r12d
jge 0xb4fc
movl %ebp, %edi
callq 0x451b
movq %rax, %r13
testl %r12d, %r12d
je 0xb478
leal -0x1(%r12), %eax
movzbl %al, %esi
movq %r13, %rdi
callq 0x4d8b
movq %rax, %r14
movq %r13, %rdi
callq 0x42a5
movq %r14, %r13
movslq 0x10(%rbx), %rax
movq (%rbx), %rcx
movq 0x18(%rbx), %rdx
movslq (%rdx,%rbp,4), %rdx
imulq %rax, %rdx
addq %r12, %rdx
movq (%rcx,%rdx,8), %rax
movzbl (%rax,%r15), %edi
movq %r13, %rsi
callq 0x45c6
movq %rax, %r14
movq %r13, %rdi
callq 0x42a5
movq 0x8(%rsp), %r15
movq %r12, 0x40(%rsp)
movq 0x38(%rsp), %r12
movq (%r15,%r12,8), %r13
movq %r14, %rdi
movq %r13, %rsi
callq 0x4b60
movq %rbp, %rbx
movq %rax, %rbp
movq %r13, %rdi
callq 0x42a5
movq %r14, %rdi
callq 0x42a5
movq %rbp, (%r15,%r12,8)
movq 0x40(%rsp), %r12
movq %rbx, %rbp
movq 0x30(%rsp), %r15
movq 0x28(%rsp), %rbx
incq %r12
jmp 0xb441
incq %rbp
movl 0x4(%rsp), %edx
jmp 0xb401
incq %r15
movl 0xc(%rbx), %r14d
jmp 0xb3cb
movq 0x8(%rsp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x24d47(%rip), %rax     # 0x302b8
movslq (%rax), %r14
xorl %r15d, %r15d
movslq 0x10(%rbx), %rax
imulq %r14, %rax
movq (%rbx), %rdi
cmpq %rax, %r15
jge 0xb595
movq (%rdi,%r15,8), %rdi
callq 0x2030
incq %r15
jmp 0xb577
callq 0x2030
cmpb $0x0, 0x28(%rbx)
je 0xb5d0
xorl %r14d, %r14d
movl 0x8(%rbx), %eax
cltd
idivl 0x10(%rbx)
cltq
movq 0x30(%rbx), %rdi
cmpq %rax, %r14
jge 0xb5cb
movq 0x20(%rbx), %rax
movslq (%rax,%r14,4), %rax
movq (%rdi,%rax,8), %rdi
callq 0x90c6
incq %r14
jmp 0xb5a3
callq 0x2030
movq 0x18(%rbx), %rdi
callq 0x2030
movq 0x20(%rbx), %rdi
callq 0x2030
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2030
// File: /workspace/github_c_makefile_star2_O2/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 %rax
movq %rdi, %rsi
leaq 0x1bc56(%rip), %rdi     # 0x27495
xorl %eax, %eax
callq 0x2110
leaq 0x1be82(%rip), %rdi     # 0x276cf
callq 0x2090
leaq 0x1be7f(%rip), %rdi     # 0x276d8
callq 0x2090
leaq 0x1beb0(%rip), %rdi     # 0x27715
callq 0x2090
leaq 0x1bec7(%rip), %rdi     # 0x27738
callq 0x2090
leaq 0x1bef7(%rip), %rdi     # 0x27774
callq 0x2090
leaq 0x1bf25(%rip), %rdi     # 0x277ae
callq 0x2090
leaq 0x1bf4b(%rip), %rdi     # 0x277e0
callq 0x2090
leaq 0x1bf7a(%rip), %rdi     # 0x2781b
callq 0x2090
leaq 0x1bfa4(%rip), %rdi     # 0x27851
callq 0x2090
leaq 0x1bfc9(%rip), %rdi     # 0x27882
callq 0x2090
pushq $0xa
popq %rdi
callq 0x2040
leaq 0x1bfdb(%rip), %rdi     # 0x278a8
popq %rax
jmp 0x2090
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, 0x4(%rsp)
movl %esi, %ebp
movl %edi, %r14d
movq 0x24a73(%rip), %r15     # 0x30380
movq %r15, %rdi
callq 0x20f0
decl %eax
cltq
addq %rax, %r15
incq %r15
cmpb $0x2f, -0x2(%r15)
leaq -0x1(%r15), %r15
jne 0xb91f
xorl %r12d, %r12d
cmpb $0x2e, (%r15,%r12)
leaq 0x1(%r12), %r12
jne 0xb92d
pushq $0x1
popq %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x2150
movq %rax, %rbx
leaq -0x1(%r12), %rdx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2060
addq $0x11, %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x2150
movq %rax, %r15
leaq 0x1bb94(%rip), %rsi     # 0x27508
movq %rax, %rdi
movq %rbx, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl 0x4(%rsp), %r9d
xorl %eax, %eax
callq 0x2230
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, 0x4(%rsp)
movl %esi, %ebp
movl %edi, %r14d
movq 0x249c7(%rip), %r15     # 0x30380
movq %r15, %rdi
callq 0x20f0
decl %eax
cltq
addq %rax, %r15
incq %r15
cmpb $0x2f, -0x2(%r15)
leaq -0x1(%r15), %r15
jne 0xb9cb
xorl %r12d, %r12d
cmpb $0x2e, (%r15,%r12)
leaq 0x1(%r12), %r12
jne 0xb9d9
pushq $0x1
popq %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x2150
movq %rax, %rbx
leaq -0x1(%r12), %rdx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2060
addq $0x9, %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x2150
movq %rax, %r15
leaq 0x1bafc(%rip), %rsi     # 0x2751c
movq %rax, %rdi
movq %rbx, %rdx
movl %r14d, %ecx
movl %ebp, %r8d
movl 0x4(%rsp), %r9d
xorl %eax, %eax
callq 0x2230
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rdi, %r15
movq (%r15), %r15
testq %r15, %r15
je 0xbeb5
movq (%r15), %rdi
movq %r14, %rsi
callq 0x2160
testl %eax, %eax
je 0xbec5
addq $0x10, %r15
jmp 0xbe98
movq (%rbx), %r15
testq %r15, %r15
je 0xbecb
movl 0x8(%r15), %ebp
incl %ebp
jmp 0xbecd
movl 0x8(%r15), %ebp
jmp 0xbee2
xorl %ebp, %ebp
pushq $0x18
popq %rdi
callq 0x21c0
movq %r14, (%rax)
movl %ebp, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %rax, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
pushq $-0x1
popq %rbx
testq %r14, %r14
je 0xbf1b
movq (%r14), %rdi
movq %r15, %rsi
callq 0x2160
testl %eax, %eax
je 0xbf17
movq 0x10(%r14), %r14
jmp 0xbefd
movl 0x8(%r14), %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
testq %rdi, %rdi
je 0xbf38
cmpl %esi, 0x8(%rdi)
je 0xbf35
movq 0x10(%rdi), %rdi
jmp 0xbf25
movq (%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O2/cbouilla[P]AES-attacks-finder/Algo.c
// Function: EcrireEq
void EcrireEq(FILE *out, Equation a) // Ecrit une équation en C dans un fichier
{
	/* On pourrait peut-être factoriser ? */
	
	if (a==NULL || EstNulEq(a))
	{
		fprintf(out,"0");
	}
	else
	{
		int i;
		for (i = 0; i < a->nV; i++)
		{
			if (i!=0) fprintf(out," ^ ");
			if (a->coefV[i] != 0x01) fprintf(out,"Multiply(0x%02x,",a->coefV[i]);
			fprintf(out,"x%u",a->var[i]);
			if (a->coefV[i]!=0x01) fprintf(out,")");
		}
		if (a->nV!=0 && a->nS!=0) fprintf(out," ^ ");
		for (i = 0; i < a->nS; i++)
		{
			if (i!=0) fprintf(out," ^ ");
			if (a->coefS[i]!=0x01) fprintf(out,"Multiply(0x%02x,",a->coefS[i]);
			if (a->sbox[i]) fprintf(out,"R(");
			else fprintf(out,"S(");
			EcrireEq(out,a->S[i]);
			fprintf(out,")");
			if (a->coefS[i]!=0x01) fprintf(out,")");
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0xd8ee
movq %rsi, %r14
movq %rsi, %rdi
callq 0x4293
testl %eax, %eax
je 0xd907
pushq $0x30
popq %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2130
leaq 0x1a9b2(%rip), %r15     # 0x282c0
pushq $0x3
popq %rbp
pushq $0x1
popq %r12
xorl %r13d, %r13d
movslq (%r14), %rax
cmpq %rax, %r13
jge 0xd989
testq %r13, %r13
je 0xd93a
leaq 0x1a97f(%rip), %rdi     # 0x282ab
movq %rbp, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x2250
movq 0x10(%r14), %rax
movzbl (%rax,%r13), %edx
cmpl $0x1, %edx
je 0xd959
movq %rbx, %rdi
leaq 0x1a95d(%rip), %rsi     # 0x282af
xorl %eax, %eax
callq 0x2180
movq 0x8(%r14), %rax
movl (%rax,%r13,4), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x2180
movq 0x10(%r14), %rax
cmpb $0x1, (%rax,%r13)
je 0xd984
pushq $0x29
popq %rdi
movq %rbx, %rsi
callq 0x2130
incq %r13
jmp 0xd918
testl %eax, %eax
je 0xd9a9
cmpl $0x0, 0x18(%r14)
je 0xd9a9
leaq 0x1a910(%rip), %rdi     # 0x282ab
pushq $0x3
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x2250
pushq $0x2
popq %r15
pushq $0x1
popq %r12
pushq $0x29
popq %rbp
xorl %r13d, %r13d
movslq 0x18(%r14), %rax
cmpq %rax, %r13
jge 0xda5b
testq %r13, %r13
je 0xd9de
leaq 0x1a8db(%rip), %rdi     # 0x282ab
pushq $0x3
popq %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x2250
movq 0x28(%r14), %rax
movzbl (%rax,%r13), %edx
cmpl $0x1, %edx
je 0xd9fd
movq %rbx, %rdi
leaq 0x1a8b9(%rip), %rsi     # 0x282af
xorl %eax, %eax
callq 0x2180
movq 0x30(%r14), %rax
cmpb $0x0, (%rax,%r13)
leaq 0x1971e(%rip), %rdi     # 0x2712b
je 0xda16
leaq 0x19712(%rip), %rdi     # 0x27128
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x2250
movq 0x20(%r14), %rax
movq (%rax,%r13,8), %rsi
movq %rbx, %rdi
callq 0xd8cc
movl %ebp, %edi
movq %rbx, %rsi
callq 0x2130
movq 0x28(%r14), %rax
cmpb $0x1, (%rax,%r13)
je 0xda53
movl %ebp, %edi
movq %rbx, %rsi
callq 0x2130
incq %r13
jmp 0xd9b7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x1d06e(%rip), %rsi     # 0x2aaf2
movq %rax, %rdi
callq 0x2200
movq %rax, %r14
xorl %eax, %eax
testl %ebp, %ebp
cmovgl %ebp, %eax
movl %eax, 0x4(%rsp)
pushq $0x1
popq %r12
pushq $0x9
popq %rbp
movq %r14, %rdi
callq 0x2120
movl %eax, %r13d
shll $0x18, %r13d
cmpl $0xff000000, %r13d      # imm = 0xFF000000
je 0xdaf4
movl %eax, %r15d
testl %r12d, %r12d
je 0xdad8
movl 0x4(%rsp), %r12d
subl $0x1, %r12d
jb 0xdad8
movl %ebp, %edi
movq %rbx, %rsi
callq 0x2130
jmp 0xdac6
movsbl %r15b, %edi
movq %rbx, %rsi
callq 0x2130
xorl %r12d, %r12d
cmpl $0xa000000, %r13d       # imm = 0xA000000
sete %r12b
jmp 0xdaa1
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20e0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
movl %edx, %ebx
movq %rsi, %r14
movl %edi, %ebp
callq 0x2280
cltd
idivl %ebx
movslq %edx, %rax
movq (%r14,%rax,8), %rdi
movslq %ebx, %rcx
decl %ebx
movq -0x8(%r14,%rcx,8), %rdx
movq %rdx, (%r14,%rax,8)
movq %rdi, -0x8(%r14,%rcx,8)
callq 0x6846
movq %rax, %r12
movl 0x14(%r12), %eax
cmpl %ebp, %eax
jge 0x14ee6
testl %ebx, %ebx
jle 0x14ee6
movl %ebx, %ebx
movq %rbx, %r15
addq $-0x1, %r15
setb %cl
cmpl %ebp, %eax
jge 0x14ec5
testb %cl, %cl
je 0x14ec5
callq 0x2280
cltd
idivl %ebx
movslq %edx, %rax
movq (%r14,%rax,8), %rsi
movq (%r14,%r15,8), %rcx
movq %rcx, (%r14,%rax,8)
movq %rsi, (%r14,%r15,8)
movq %r12, %rdi
movq (%rsp), %rdx
callq 0x72e2
movq %rax, %r13
movq %r12, %rdi
callq 0x6852
movl 0x14(%r13), %eax
movq %r15, %rbx
movq %r13, %r12
jmp 0x14e78
movq %r12, %rdi
movq (%rsp), %rsi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x788d
movq %rax, %r13
movq %r12, %rdi
callq 0x6852
movq %r13, %r12
jmp 0x14e66
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, 0x14(%rsp)
movl %r8d, %r13d
movq %rcx, %r14
movl %edx, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq %rdi, %r12
leaq 0x8(%rsp), %rbp
movq %r12, %rdi
movq %rbp, %rsi
callq 0x771f
movq %rax, %rbx
movl 0x8(%rsp), %esi
movq %rax, %rdi
movq %r12, %rdx
callq 0x8b0c
cmpl $0x1, %eax
jne 0x16091
xorl %r15d, %r15d
movslq 0x8(%rsp), %rax
cmpq %rax, %r15
jge 0x16087
movq (%rbx,%r15,8), %rdi
callq 0x6852
incq %r15
jmp 0x1606f
movq %rbx, %rdi
callq 0x2030
jmp 0x1604a
movl 0x8(%rsp), %eax
cmpl $0x1, %eax
jne 0x160a7
movq (%rbx), %r14
movq %rbx, %rdi
callq 0x2030
jmp 0x16104
xorl %ebp, %ebp
cltq
cmpq %rax, %rbp
jge 0x160c2
movq (%rbx,%rbp,8), %rdi
callq 0x6852
incq %rbp
movl 0x8(%rsp), %eax
jmp 0x160a9
movq %rbx, %rdi
callq 0x2030
movq %r14, %rdi
movl %r13d, %esi
movq %r12, %rdx
callq 0xb021
movq %rax, %rbx
movq %rax, %rdi
movl 0xc(%rsp), %esi
movl 0x10(%rsp), %edx
movl 0x14(%rsp), %ecx
movq 0x50(%rsp), %r8
movq 0x58(%rsp), %r9
callq 0x15b17
movq %rax, %r14
movq %rbx, %rdi
callq 0xb562
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/cbouilla[P]AES-attacks-finder/Search.c
// Function: GuessMinimumLight_tmp
int * GuessMinimumLight_tmp(int *X, int N, SysEqLin E, int *taille)
{
	if (N>0)
	{
		int i;
		for (i = 0; i < N; i++)
		{
			int l=E->lignevar[X[i]]*E->gen;
			int dim=Dimension(E->mat+l,E->gen,E->b,1);
			if (dim==1)
			{
				N--;
				X[i]=X[N];
				SysEqLin F = ExtraireEX2(X,N,E);
				int * result = GuessMinimumLight_tmp(X,N,F,taille);
				freeSysEq(F);
				return result;
			}
			if (dim==0)
			{
				int tmp = X[i];
				X[i]=X[--N];
				int * result_tmp = GuessMinimumLight_tmp(X,N,E,taille);
				int * result = UnionListesTriees(result_tmp,*taille,&tmp,1,taille);
				free(result_tmp);
				return result;
			}
		}
		SysEqLin F = ExtraireEX2(X,--N,E);
		int * result = GuessMinimumLight_tmp(X,N,F,taille);
		freeSysEq(F);
		return result;
	}
	else
	{
		*taille=0;
		return NULL;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testl %esi, %esi
jle 0x16178
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r14
movq %rcx, 0x8(%rsp)
movl %esi, %ebx
xorl %r13d, %r13d
pushq $0x1
popq %r12
cmpq %r13, %rbx
je 0x16182
movq 0x18(%r15), %rax
movslq (%r14,%r13,4), %rcx
movslq (%rax,%rcx,4), %rdi
movslq 0x10(%r15), %rsi
imulq %rsi, %rdi
shlq $0x3, %rdi
addq (%r15), %rdi
movl 0xc(%r15), %edx
movl %r12d, %ecx
callq 0x2e41
testl %eax, %eax
je 0x161c3
cmpl $0x1, %eax
je 0x16186
incq %r13
jmp 0x1613e
andl $0x0, (%rcx)
xorl %ebx, %ebx
jmp 0x16214
decl %ebp
jmp 0x16194
movslq %ebp, %rax
decl %ebp
movl -0x4(%r14,%rax,4), %eax
movl %eax, (%r14,%r13,4)
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0xace0
movq %rax, %r15
movq %r14, %rdi
movl %ebp, %esi
movq %rax, %rdx
movq 0x8(%rsp), %rcx
callq 0x16116
movq %rax, %rbx
movq %r15, %rdi
callq 0xb562
jmp 0x16214
movl (%r14,%r13,4), %eax
leaq 0x14(%rsp), %r12
movl %eax, (%r12)
movslq %ebp, %rax
decl %ebp
movl -0x4(%r14,%rax,4), %eax
movl %eax, (%r14,%r13,4)
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %rdx
movq 0x8(%rsp), %rbx
movq %rbx, %rcx
callq 0x16116
movq %rax, %r14
movl (%rbx), %esi
pushq $0x1
popq %rcx
movq %rax, %rdi
movq %r12, %rdx
movq %rbx, %r8
callq 0x2440
movq %rax, %rbx
movq %r14, %rdi
callq 0x2030
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r12
movslq %esi, %r13
leaq (,%r13,4), %rdi
callq 0x21c0
movq %rax, %r15
xorl %eax, %eax
testl %r13d, %r13d
movl $0x0, %ecx
cmovgl %ebp, %ecx
cmpq %rax, %rcx
je 0x1626e
movl (%r12,%rax,4), %edx
movl %edx, (%r15,%rax,4)
incq %rax
jmp 0x1625c
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x16116
movq %rax, %rbx
movq %r15, %rdi
callq 0x2030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %ebx
movq %rdi, %r14
pushq $0x20
popq %rdi
callq 0x21c0
movq %rax, %r15
movq %r14, (%rax)
movl %ebx, 0x8(%rax)
movl %ebp, 0xc(%rax)
leaq 0x19fef(%rip), %rax     # 0x302b8
movslq (%rax), %r13
shlq $0x2, %r13
movq %r13, %rdi
callq 0x21c0
movq %rax, %r12
movq %rax, 0x10(%r15)
movq %r13, %rdi
callq 0x21c0
movq %rax, 0x18(%r15)
xorl %ecx, %ecx
testl %ebx, %ebx
cmovlel %ecx, %ebx
movl %ebp, %ecx
testl %ecx, %ecx
jle 0x1631c
decq %rcx
movl %ecx, %edx
xorl %esi, %esi
cmpq %rsi, %rbx
je 0x162f4
movq (%r14,%rdx,8), %rdi
movslq (%rdi,%rsi,4), %r8
movl %ecx, (%r12,%r8,4)
movslq (%rdi,%rsi,4), %rdi
movl %esi, (%rax,%rdi,4)
incq %rsi
jmp 0x162ff
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq