LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/cbouilla[P]AES-attacks-finder/Equation.c
// Function: appliqueS
Equation appliqueS(Equation a, unsigned char m)
{	
	Equation p=malloc(sizeof(EQUATION));
	p->nV=0;
	p->var=NULL;
	p->coefV=NULL;
	p->nS=1;
	p->S=malloc(sizeof(Equation));
	p->coefS=malloc(sizeof(unsigned char));
	p->sbox=malloc(sizeof(unsigned char));
	p->S[0]=copyEq(a);
	p->coefS[0]=0x01;
	p->sbox[0]=m;
	Equation pp=reduitEq(p);
	freeEq(p);
	return pp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r15
pushq $0x38
popq %rdi
callq 0x21c0
movq %rax, %r14
andl $0x0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movl $0x1, 0x18(%rax)
pushq $0x8
popq %rdi
callq 0x21c0
movq %rax, %r12
movq %rax, 0x20(%r14)
pushq $0x1
popq %r13
movq %r13, %rdi
callq 0x21c0
movq %rax, %rbp
movq %rax, 0x28(%r14)
movq %r13, %rdi
callq 0x21c0
movq %rax, %r13
movq %rax, 0x30(%r14)
movq %r15, %rdi
callq 0x4319
movq %rax, (%r12)
movb $0x1, (%rbp)
movb %bl, (%r13)
movq %r14, %rdi
callq 0x4716
movq %rax, %rbx
movq %r14, %rdi
callq 0x42a5
movq %rbx, %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/Equation.c
// Function: RemplaceLinearise
void RemplaceLinearise(Equation E, Equation a, int v)
{
	if (EgaleEq(E,a))
	{
		printf("C'est bizarre!!");
		getchar();
	}
	int i;
	for (i = 0; i < E->nS; i++)
	{
		if (EgaleEq(a,E->S[i]))
		{
			freeEq(E->S[i]);
			E->S[i]=varEq(v);
		}
		else RemplaceLinearise(E->S[i],a,v);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
callq 0x4441
testl %eax, %eax
je 0x529c
leaq 0x21eac(%rip), %rdi     # 0x2713c
xorl %eax, %eax
callq 0x2110
callq 0x2170
xorl %r13d, %r13d
movslq 0x18(%r15), %rax
cmpq %rax, %r13
jge 0x52e7
movq 0x20(%r15), %rax
movq (%rax,%r13,8), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x4441
movq %r12, %rdi
testl %eax, %eax
je 0x52d8
callq 0x42a5
movl %ebx, %edi
callq 0x451b
movq 0x20(%r15), %rcx
movq %rax, (%rcx,%r13,8)
jmp 0x52e2
movq %r14, %rsi
movl %ebx, %edx
callq 0x526f
incq %r13
jmp 0x529f
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/cbouilla[P]AES-attacks-finder/Equation.c
// Function: SupprS
Equation SupprS(Equation E)
{
	int i;
	for (i = 0; i < E->nS; i++)
	{
		if (E->sbox[i]==1)
		{
			Equation tmp=copyEq(E->S[i]);
			Equation tmp1=appliqueS(tmp,1);
			Equation tmp2=mulEq(E->coefS[i],tmp1);
			freeEq(tmp1);
			tmp1=addEq(E,tmp2);
			freeEq(tmp2);
			tmp2=mulEq(Inverse(E->coefS[i]),tmp1);
			freeEq(tmp1);
			tmp1=appliqueS(tmp2,0);
			freeEq(tmp2);
			tmp2=addEq(tmp,tmp1);
			freeEq(tmp);
			freeEq(tmp1);
			int j;
			for (j = i+1; j < E->nS; j++)
			{
				if (E->sbox[j]==1)
				{
					printf("Il reste S^-1");
					getchar();
				}
			}
			
			return tmp2;
		}
	}
	return copyEq(E);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x18(%rdi), %ecx
xorl %eax, %eax
testl %ecx, %ecx
cmovgl %ecx, %eax
negq %rax
pushq $0x1
popq %rbp
leaq (%rax,%rbp), %rcx
cmpq $0x1, %rcx
je 0x5329
movq 0x30(%rbx), %rcx
cmpb $0x1, -0x1(%rcx,%rbp)
je 0x533f
incq %rbp
jmp 0x530f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4319
movq 0x20(%rbx), %rax
movq -0x8(%rax,%rbp,8), %rdi
callq 0x4319
movq %rax, %r14
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0x4d8b
movq %rax, %r15
movq 0x28(%rbx), %rax
movzbl -0x1(%rax,%rbp), %edi
movq %r15, %rsi
callq 0x45c6
movq %rax, %r12
movq %r15, %rdi
callq 0x42a5
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4b60
movq %rax, %r15
movq %r12, %rdi
callq 0x42a5
movq 0x28(%rbx), %rax
movzbl -0x1(%rax,%rbp), %edi
callq 0x2433
movzbl %al, %edi
movq %r15, %rsi
callq 0x45c6
movq %rax, %r12
movq %r15, %rdi
callq 0x42a5
movq %r12, %rdi
xorl %esi, %esi
callq 0x4d8b
movq %rax, %r13
movq %r12, %rdi
callq 0x42a5
movq %r14, %rdi
movq %r13, %rsi
callq 0x4b60
movq %rax, %r15
movq %r14, %rdi
callq 0x42a5
movq %r13, %rdi
callq 0x42a5
leaq 0x21d5e(%rip), %r14     # 0x2714c
cmpl %ebp, 0x18(%rbx)
jle 0x5411
movq 0x30(%rbx), %rax
cmpb $0x1, (%rax,%rbp)
jne 0x540c
movq %r14, %rdi
xorl %eax, %eax
callq 0x2110
callq 0x2170
incq %rbp
jmp 0x53ee
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/Equation.c
// Function: LineariseTotal
Equation * LineariseTotal(Equation *E, int taille, int *t) /*Bug -> incomplete*/
{
	Equation *Eq,tmp,*Eq2;
	int i,N;
	Eq=Linearise(E,taille,&N);
	for (i = 0; i < N; i++)
	{
		tmp=SupprS(Eq[i]);
		freeEq(Eq[i]);
		Eq[i]=tmp;
	}
	Eq2=Linearise(Eq,N,t);
	for (i = 0; i < N; i++) freeEq(Eq[i]);
	free(Eq);
	return Eq2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x8(%rsp)
leaq 0x14(%rsp), %r15
movq %r15, %rdx
callq 0x5423
movq %rax, %rbx
movl (%r15), %ebp
xorl %r14d, %r14d
testl %ebp, %ebp
movl $0x0, %r13d
cmovgl %ebp, %r13d
cmpq %r14, %r13
je 0x56ac
movq (%rbx,%r14,8), %r15
movq %r15, %rdi
callq 0x52f1
movq %rax, %r12
movq %r15, %rdi
callq 0x42a5
movq %r12, (%rbx,%r14,8)
incq %r14
jmp 0x5687
movq %rbx, %rdi
movl %ebp, %esi
movq 0x8(%rsp), %rdx
callq 0x5423
movq %rax, %r14
xorl %r15d, %r15d
cmpq %r15, %r13
je 0x56d4
movq (%rbx,%r15,8), %rdi
callq 0x42a5
incq %r15
jmp 0x56c1
movq %rbx, %rdi
callq 0x2030
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/Equation.c
// Function: VarsDedans
int * VarsDedans(Equation a, int *taille)
{
	int i,l,*tmp,*tmp1,**L,*t,n,n1;
	l=a->nS+1;
	L=malloc(l*sizeof(int *));
	t=malloc(l*sizeof(int));
	for (i = 0; i < a->nS; i++) L[i]=VarsDedans(a->S[i],t+i);
	L[a->nS]=malloc(a->nV*sizeof(int));
	for (i = 0; i < a->nV; i++) L[a->nS][i]=a->var[i];
	t[a->nS]=a->nV;
	Tri(L[a->nS],a->nV);
	n=0;
	tmp=malloc(n*sizeof(int));
	for (i = 0; i < l; i++)
	{
		tmp1=UnionListesTriees(tmp,n,L[i],t[i],&n1);
		free(tmp);
		tmp=tmp1;
		n=n1;
	}
	for (i = 0; i < l; i++) free(L[i]);
	free(L);
	*taille=n;
	return tmp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, %r12
movl 0x18(%rdi), %ebp
movslq %ebp, %r15
leaq 0x8(,%r15,8), %rdi
callq 0x21c0
movq %rax, %r14
leaq 0x4(,%r15,4), %rdi
callq 0x21c0
movq %rax, %r13
xorl %ebx, %ebx
movq %rax, 0x8(%rsp)
movslq %ebp, %rbp
cmpq %rbp, %rbx
jge 0x575c
movq 0x20(%r12), %rax
movq (%rax,%rbx,8), %rdi
movq %r13, %rsi
callq 0x56ee
movq %rax, (%r14,%rbx,8)
incq %rbx
movl 0x18(%r12), %ebp
addq $0x4, %r13
jmp 0x5731
movslq (%r12), %r13
movq %r13, %rdi
shlq $0x2, %rdi
callq 0x21c0
movq %rax, (%r14,%rbp,8)
xorl %eax, %eax
movslq %r13d, %rcx
cmpq %rcx, %rax
jge 0x5797
movq 0x8(%r12), %rcx
movl (%rcx,%rax,4), %ecx
movslq 0x18(%r12), %rdx
movq (%r14,%rdx,8), %rdx
movl %ecx, (%rdx,%rax,4)
incq %rax
movl (%r12), %r13d
jmp 0x5772
movslq 0x18(%r12), %rax
movq 0x8(%rsp), %rcx
movl %r13d, (%rcx,%rax,4)
movq (%r14,%rax,8), %rdi
movl %r13d, %esi
callq 0x27bf
xorl %r13d, %r13d
xorl %edi, %edi
callq 0x21c0
movq %rax, %rbx
xorl %ebp, %ebp
cmpq %r15, %r13
jg 0x57f8
movq (%r14,%r13,8), %rdx
movq 0x8(%rsp), %rax
movl (%rax,%r13,4), %ecx
movq %rbx, %rdi
movl %ebp, %esi
leaq 0x4(%rsp), %r8
callq 0x2440
movq %rax, %r12
movq %rbx, %rdi
callq 0x2030
movl 0x4(%rsp), %ebp
incq %r13
movq %r12, %rbx
jmp 0x57c0
xorl %r12d, %r12d
cmpq %r15, %r12
jg 0x580e
movq (%r14,%r12,8), %rdi
callq 0x2030
incq %r12
jmp 0x57fb
movq %r14, %rdi
callq 0x2030
movq 0x10(%rsp), %rax
movl %ebp, (%rax)
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/Equation.c
// Function: CoupeEq
Equation CoupeEq(Equation a, int *X, int N)
{
	int i,p,v;
	Equation tmp1,tmp2,tmp3;
	tmp1=NulEq();
	for (i = 0; i < a->nV; i++)
	{
		v=a->var[i];
		p=SearchElement(v,X,N);
		if (p!=-1)
		{
			tmp2=varEq(v);
			tmp3=mulEq(a->coefV[i],tmp2);
			freeEq(tmp2);
			tmp2=addEq(tmp3,tmp1);
			freeEq(tmp1);
			freeEq(tmp3);
			tmp1=tmp2;
		}
	}
	for (i = 0; i < a->nS; i++)
	{
		v=a->S[i]->var[0];
		p=SearchElement(v,X,N);
		if (p!=-1)
		{
			tmp2=varEq(v);
			tmp3=appliqueS(tmp2,a->sbox[i]);
			freeEq(tmp2);
			tmp2=mulEq(a->coefS[i],tmp3);
			freeEq(tmp3);
			tmp3=addEq(tmp2,tmp1);
			freeEq(tmp1);
			freeEq(tmp2);
			tmp1=tmp3;
		}
	}
	return tmp1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, 0x4(%rsp)
movq %rsi, %r14
movq %rdi, %r15
xorl %ebx, %ebx
callq 0x4271
movq %rax, %r12
movslq (%r15), %rax
cmpq %rax, %rbx
jge 0x5b2b
movq 0x8(%r15), %rax
movl (%rax,%rbx,4), %ebp
movl %ebp, %edi
movq %r14, %rsi
movl 0x4(%rsp), %edx
callq 0x26cf
cmpl $-0x1, %eax
je 0x5b26
movl %ebp, %edi
callq 0x451b
movq %rax, %r13
movq 0x10(%r15), %rax
movzbl (%rax,%rbx), %edi
movq %r13, %rsi
callq 0x45c6
movq %rax, %rbp
movq %r13, %rdi
callq 0x42a5
movq %rbp, %rdi
movq %r12, %rsi
callq 0x4b60
movq %rax, %r13
movq %r12, %rdi
callq 0x42a5
movq %rbp, %rdi
callq 0x42a5
movq %r13, %r12
incq %rbx
jmp 0x5abe
xorl %ebx, %ebx
movslq 0x18(%r15), %rax
cmpq %rax, %rbx
jge 0x5bc4
movq 0x20(%r15), %rax
movq (%rax,%rbx,8), %rax
movq 0x8(%rax), %rax
movl (%rax), %ebp
movl %ebp, %edi
movq %r14, %rsi
movl 0x4(%rsp), %edx
callq 0x26cf
cmpl $-0x1, %eax
je 0x5bbc
movl %ebp, %edi
callq 0x451b
movq %rax, %r13
movq 0x30(%r15), %rax
movzbl (%rax,%rbx), %esi
movq %r13, %rdi
callq 0x4d8b
movq %rax, %rbp
movq %r13, %rdi
callq 0x42a5
movq 0x28(%r15), %rax
movzbl (%rax,%rbx), %edi
movq %rbp, %rsi
callq 0x45c6
movq %rax, %r13
movq %rbp, %rdi
callq 0x42a5
movq %r13, %rdi
movq %r12, %rsi
callq 0x4b60
movq %rax, %rbp
movq %r12, %rdi
callq 0x42a5
movq %r13, %rdi
callq 0x42a5
movq %rbp, %r12
incq %rbx
jmp 0x5b2d
movq %r12, %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/EquationAES.c
// Function: MakeAK
int MakeAK(Equation *Eq, int key, int state1, int state2)
{
	int i,j,pos;
	Equation tmp,tmp1,tmp2;
	pos=0;
	for (i = 0; i < 4; i++)
	{
		for (j = 0; j < 4; j++)
		{
			tmp=varEq(16*key+4*i+j);
			tmp1=varEq(16*state1+4*i+j);
			tmp2=addEq(tmp,tmp1);
			freeEq(tmp);
			freeEq(tmp1);
			tmp=varEq(16*state2+4*i+j);
			Eq[pos++]=addEq(tmp,tmp2);
			freeEq(tmp);
			freeEq(tmp2);
		}
	}
	return pos;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %r15d
movq %rdi, 0x18(%rsp)
shll $0x4, %esi
movq %rsi, 0x8(%rsp)
shll $0x4, %edx
movq %rdx, 0x10(%rsp)
shll $0x4, %r15d
xorl %eax, %eax
xorl %ecx, %ecx
cmpl $0x4, %ecx
je 0x5e94
movl %ecx, 0x4(%rsp)
movq %rax, 0x20(%rsp)
cltq
movq 0x18(%rsp), %rcx
leaq (%rcx,%rax,8), %r14
xorl %ebx, %ebx
cmpl $0x4, %ebx
je 0x5e72
movq 0x8(%rsp), %rax
leal (%rax,%rbx), %edi
callq 0x451b
movq %rax, %rbp
movq 0x10(%rsp), %rax
leal (%rax,%rbx), %edi
callq 0x451b
movq %rax, %r12
movq %rbp, %rdi
movq %rax, %rsi
callq 0x4b60
movq %rax, %r13
movq %rbp, %rdi
callq 0x42a5
movq %r12, %rdi
callq 0x42a5
leal (%r15,%rbx), %edi
callq 0x451b
movq %rax, %r12
movq %rax, %rdi
movq %r13, %rsi
callq 0x4b60
movq %rax, (%r14,%rbx,8)
movq %r12, %rdi
callq 0x42a5
movq %r13, %rdi
callq 0x42a5
incq %rbx
jmp 0x5dff
movq 0x20(%rsp), %rax
addl %ebx, %eax
movl 0x4(%rsp), %ecx
incl %ecx
addq $0x4, %r15
addq $0x4, 0x10(%rsp)
addq $0x4, 0x8(%rsp)
jmp 0x5de0
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/EquationAES.c
// Function: MakeMC
int MakeMC(Equation *Eq, int state1, int state2)
{
	int i,j,k,pos;
	pos=0;
	for (i = 0; i < 4; i++)
	{
		for (j = 0; j < 4; j++)
		{
			Eq[pos]=malloc(sizeof(EQUATION));
			Eq[pos]->nV=5;
			Eq[pos]->var=malloc(5*sizeof(int));
			Eq[pos]->coefV=malloc(5*sizeof(unsigned char));
			for (k = 0; k < 4; k++) Eq[pos]->var[k]=16*state1+4*i+k;
			Eq[pos]->var[k]=16*state2+4*i+j;
			Eq[pos]->coefV[k]=1;
			Eq[pos]->coefV[j]=0x02;
			Eq[pos]->coefV[(j+1)%4]=0x03;
			Eq[pos]->coefV[(j+2)%4]=0x01;
			Eq[pos]->coefV[(j+3)%4]=0x01;
			Eq[pos]->nS=0;
			Eq[pos]->S=NULL;
			Eq[pos]->sbox=NULL;
			pos++;
		}
	}
	return pos;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %r14d
movq %rdi, 0x18(%rsp)
shll $0x4, %r14d
shll $0x4, %edx
movq %rdx, 0x8(%rsp)
xorl %ecx, %ecx
movb $0x1, %bpl
xorl %ebx, %ebx
cmpq $0x4, %rcx
je 0x5fad
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rsp)
leaq (%rax,%rcx,4), %rax
movq %rax, 0x20(%rsp)
movslq %ebx, %rbx
xorl %r15d, %r15d
cmpq $0x4, %r15
je 0x5f9c
pushq $0x38
popq %rdi
callq 0x21c0
movq %rax, %r12
movq 0x18(%rsp), %rax
movq %r12, (%rax,%rbx,8)
movl $0x5, (%r12)
pushq $0x14
popq %rdi
callq 0x21c0
movq %rax, %r13
movq %rax, 0x8(%r12)
pushq $0x5
popq %rdi
callq 0x21c0
movq %rax, 0x10(%r12)
xorl %ecx, %ecx
cmpq $0x4, %rcx
je 0x5f48
leal (%r14,%rcx), %edx
movl %edx, (%r13,%rcx,4)
incq %rcx
jmp 0x5f34
movb %bpl, 0x4(%rax)
movb $0x2, (%rax,%r15)
movq %r15, %rcx
movl %r15d, %edx
leal -0x1(%r15), %esi
movl %r15d, %edi
orl 0x20(%rsp), %edi
movl %edi, 0x10(%r13)
incq %rcx
movq %rcx, %r15
andl $0x3, %ecx
movb $0x3, (%rax,%rcx)
xorq $0x2, %rdx
movb %bpl, (%rax,%rdx)
andl $0x3, %esi
andl $0x0, 0x18(%r12)
movb %bpl, (%rax,%rsi)
andq $0x0, 0x20(%r12)
andq $0x0, 0x30(%r12)
incq %rbx
jmp 0x5eef
movq 0x10(%rsp), %rcx
incq %rcx
addq $0x4, %r14
jmp 0x5ecc
movl %ebx, %eax
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/EquationAES.c
// Function: MakeSS
int MakeSS(Equation *Eq, int key, int state1, int state2)
{
	int i,j,pos;
	Equation tmp,tmp1,tmp2;
	pos=0;
	for (i = 0; i < 4; i++)
	{
		for (j = 0; j < 4; j++)
		{
			tmp=varEq(16*state2+4*i+j);
			tmp1=appliqueS(tmp,1);
			freeEq(tmp);
			tmp=varEq(16*state1+4*((i+j)%4)+j);
			tmp2=addEq(tmp,tmp1);
			freeEq(tmp);
			freeEq(tmp1);
			tmp=varEq(16*key+4*((i+j)%4)+j);
			Eq[pos++]=addEq(tmp,tmp2);
			freeEq(tmp);
			freeEq(tmp2);
		}
	}
	return pos;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, 0x10(%rsp)
shll $0x4, %ecx
movq %rcx, 0x8(%rsp)
shll $0x4, %edx
movq %rdx, 0x28(%rsp)
shll $0x4, %esi
movq %rsi, 0x20(%rsp)
xorl %eax, %eax
xorl %ebx, %ebx
cmpl $0x4, %ebx
je 0x60de
movq %rax, 0x18(%rsp)
cltq
movq 0x10(%rsp), %rcx
leaq (%rcx,%rax,8), %rax
movq %rax, 0x30(%rsp)
movl %ebx, 0x4(%rsp)
xorl %r15d, %r15d
cmpl $0x4, %r15d
je 0x60c5
movzbl %bl, %ebx
movl %ebx, %eax
andl $0x3, %eax
movq 0x20(%rsp), %rcx
leal (%rcx,%rax,4), %r12d
movq 0x28(%rsp), %rcx
leal (%rcx,%rax,4), %r13d
movq 0x8(%rsp), %rax
leal (%rax,%r15), %edi
callq 0x451b
movq %rax, %rbp
movq %rax, %rdi
pushq $0x1
popq %rsi
callq 0x4d8b
movq %rax, %r14
movq %rbp, %rdi
callq 0x42a5
addl %r15d, %r13d
movl %r13d, %edi
callq 0x451b
movq %rax, %r13
movq %rax, %rdi
movq %r14, %rsi
callq 0x4b60
movq %rax, %rbp
movq %r13, %rdi
callq 0x42a5
movq %r14, %rdi
callq 0x42a5
addl %r15d, %r12d
movl %r12d, %edi
callq 0x451b
movq %rax, %r14
movq %rax, %rdi
movq %rbp, %rsi
callq 0x4b60
movq 0x30(%rsp), %rcx
movq %rax, (%rcx,%r15,8)
movq %r14, %rdi
callq 0x42a5
movq %rbp, %rdi
callq 0x42a5
incq %r15
incb %bl
jmp 0x6012
movq 0x18(%rsp), %rax
addl %r15d, %eax
movl 0x4(%rsp), %ebx
incl %ebx
addq $0x4, 0x8(%rsp)
jmp 0x5fed
addq $0x38, %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/EquationAES.c
// Function: VariablesKnownes
int * VariablesKnownes(int Tours, int Final, int Messages, int *N)
{
	int NombreCstRonde,*Known;
	int i,j,pos,taille,state;
	
	NombreCstRonde=Tours+Final;
	taille=32*Messages+NombreCstRonde;
	Known=malloc(2*taille*sizeof(int));
	state=(Tours+Final+1);
	pos=0;
	for (i = 0; i < Messages; i++)
	{
		for (j = 0; j < 16; j++) Known[pos++]=16*state+j;
		for (j = 0; j < Tours; j++)
		{
			state++;
			state++;
		}
		for (j = 0; j < Final; j++)
		{
			state++;
		}
		state++;
		for (j = 0; j < 16; j++) Known[pos++]=16*state+j;
		state++;
	}
	for (j = 0; j < NombreCstRonde; j++) Known[pos++]=16*state+j;
	printf("Variables Knownes : ");
	for (i = 0; i < pos; i++) printf("%u ",Known[i]);
	printf("\n");
	/*getchar();*/
	*N=taille;
	return Known;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x10(%rsp)
movl %edx, %ebp
movl %esi, %r12d
movl %edi, %r15d
leal (%r12,%r15), %ebx
movl %edx, %eax
shll $0x5, %eax
addl %ebx, %eax
movq %rax, 0x8(%rsp)
addl %eax, %eax
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x21c0
movq %rax, %r14
xorl %r13d, %r13d
testl %r15d, %r15d
movl $0x0, %edx
cmovgl %r15d, %edx
testl %r12d, %r12d
movl $0x0, %esi
cmovgl %r12d, %esi
leal (%rsi,%rdx,2), %ecx
testl %ebp, %ebp
cmovlel %r13d, %ebp
movl %ebx, %eax
shll $0x4, %eax
addl $0x10, %eax
shll $0x4, %ecx
addl $0x20, %ecx
shll $0x5, %edx
shll $0x4, %r12d
shll $0x4, %r15d
addl %r12d, %r15d
addl %edx, %r15d
shll $0x4, %esi
leal (%rsi,%r15), %edx
addl $0x20, %edx
xorl %esi, %esi
movslq %r13d, %r8
cmpl %ebp, %esi
je 0x6347
leaq (%r14,%r8,4), %rdi
xorl %r9d, %r9d
cmpl $0x10, %r9d
je 0x6321
leal (%rax,%r9), %r10d
movl %r10d, (%r14,%r8,4)
incq %r8
incl %r9d
addq $0x4, %rdi
jmp 0x6307
addl $0x20, %r13d
xorl %r8d, %r8d
cmpl $0x10, %r8d
je 0x633e
leal (%rdx,%r8), %r9d
movl %r9d, (%rdi)
addq $0x4, %rdi
incq %r8
jmp 0x6328
incl %esi
addl %ecx, %eax
addq %rcx, %rdx
jmp 0x62f9
xorl %ecx, %ecx
testl %ebx, %ebx
cmovlel %ecx, %ebx
leaq (%r14,%r8,4), %rdx
cmpl %ecx, %ebx
je 0x6360
movl %eax, (%rdx,%rcx,4)
incq %rcx
incl %eax
jmp 0x6352
leaq 0x20e19(%rip), %rdi     # 0x27180
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x2110
addl %r13d, %ebx
testl %ebx, %ebx
cmovlel %r15d, %ebx
leaq 0x20e14(%rip), %r15     # 0x27195
xorl %r12d, %r12d
cmpq %r12, %rbx
je 0x639c
movl (%r14,%r12,4), %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x2110
incq %r12
jmp 0x6384
pushq $0xa
popq %rdi
callq 0x2040
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movl %ecx, (%rax)
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/EquationAES.c
// Function: ConversionVars
VARS ConversionVars(int v, int Nk, int Tours, int Final, int Messages)
{
	int i,j,state,tmp;
	VARS V;
	state=(Tours+Final+1);
	V.round=v/16;
	V.j=(v-16*V.round)/4;
	V.i=(v-16*V.round)%4;
	V.v=v;
	if (v<16*state)
	{
		V.lettre='K';
		V.message=0;
		return V;
	}
	tmp=v/16;
	for (i = 0; i < Messages; i++)
	{
		for (j = 0; j < Tours; j++)
		{
			if (tmp==state)
			{
				V.lettre='X';
				V.round=j;
				V.message=i;
			}
			state++;
			if (tmp==state)
			{
				V.lettre='W';
				V.round=j;
				V.message=i;
				return V;
			}
			state++;
		}
		for (j = 0; j < Final; j++)
		{
			if (tmp==state)
			{
				V.lettre='X';
				V.round=Tours+j;
				V.message=i;
				return V;
			}
			state++;
			if (tmp==state)
			{
				V.lettre='W';
				V.round=Tours+j;
				V.message=i;
				return V;
			}
		}
		if (tmp==state)
		{
			V.lettre='X';
			V.round=Tours;
			V.message=i;
			return V;
		}
		state++;
		if (tmp==state)
		{
			V.lettre='Z';
			V.round=Tours+Final;
			V.message=i;
			return V;
		}
		state++;
	}
	V.lettre='C';
	V.round=VARIABLES-v;
	V.i=0;
	V.j=0;
	return V;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %esi, %ebx
leal 0x1(%r8,%rcx), %r11d
movl $0x10, %esi
movl %ebx, %eax
cltd
idivl %esi
movl %eax, %r10d
movl %eax, 0xc(%rdi)
movl %eax, %edx
shll $0x4, %edx
movl %ebx, %eax
subl %edx, %eax
movl $0x4, %esi
cltd
idivl %esi
movl %eax, 0x14(%rdi)
movl %edx, 0x10(%rdi)
movl %ebx, (%rdi)
movl %r11d, %eax
shll $0x4, %eax
cmpl %ebx, %eax
jle 0x6413
movb $0x4b, 0x4(%rdi)
andl $0x0, 0x8(%rdi)
jmp 0x64e0
movl %ebx, -0x4(%rsp)
xorl %eax, %eax
testl %ecx, %ecx
movl $0x0, %ebx
cmovgl %ecx, %ebx
movq %rcx, -0x10(%rsp)
addl %r8d, %ecx
testl %r8d, %r8d
cmovlel %eax, %r8d
movb 0x4(%rdi), %bpl
testl %r9d, %r9d
cmovlel %eax, %r9d
movl 0x8(%rdi), %r14d
leal -0x1(%r10), %esi
movl $0x58, %r12d
movl %r10d, %r13d
cmpl %r9d, %eax
je 0x64ee
negl %r11d
xorl %edx, %edx
leal (%r10,%r11), %r15d
cmpl %edx, %ebx
je 0x6485
cmpl $0x1, %r15d
je 0x64c0
testl %r15d, %r15d
cmovel %edx, %r13d
movzbl %bpl, %ebp
cmovel %r12d, %ebp
cmovel %eax, %r14d
incl %edx
addl $-0x2, %r11d
jmp 0x645c
movl %ecx, -0x14(%rsp)
movq %rsi, %rcx
addl %r11d, %esi
xorl %edx, %edx
cmpl %edx, %r8d
je 0x64a3
cmpl %edx, %r15d
je 0x64c9
cmpl %edx, %esi
je 0x64cf
incl %edx
jmp 0x6491
cmpl %edx, %r15d
je 0x650a
cmpl %edx, %esi
je 0x6515
subl %r11d, %edx
addl $0x2, %edx
incl %eax
movl %edx, %r11d
movq %rcx, %rsi
movl -0x14(%rsp), %ecx
jmp 0x644e
movb $0x57, 0x4(%rdi)
movl %edx, 0xc(%rdi)
jmp 0x64dd
movb $0x58, 0x4(%rdi)
jmp 0x64d3
movb $0x57, 0x4(%rdi)
movq -0x10(%rsp), %rcx
addl %edx, %ecx
movl %ecx, 0xc(%rdi)
movl %eax, 0x8(%rdi)
movq %rdi, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %r14d, 0x8(%rdi)
movb $0x43, 0x4(%rdi)
movl 0x29dbc(%rip), %eax     # 0x302b8
subl -0x4(%rsp), %eax
movl %eax, 0xc(%rdi)
andq $0x0, 0x10(%rdi)
jmp 0x64e0
movb $0x58, 0x4(%rdi)
movq -0x10(%rsp), %rcx
jmp 0x64da
movb $0x5a, 0x4(%rdi)
movl -0x14(%rsp), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x64dd
// File: /workspace/github_c_makefile_star2_O2/cbouilla[P]AES-attacks-finder/EquationAES.c
// Function: VariablesKnownes2
int * VariablesKnownes2(int Tours, int Final, int Messages, int *N)
{
	int NombreCstRonde,*Known;
	int i,j,pos,taille,state;
	
	NombreCstRonde=Tours+Final;
	taille=16*Messages+NombreCstRonde;
	Known=malloc(taille*sizeof(int));
	state=(Tours+Final+1);
	pos=0;
	for (i = 0; i < Messages; i++)
	{
	  /*for (j = 0; j < 16; j++) Known[pos++]=16*state+j;*/
		for (j = 0; j < Tours; j++)
		{
			state++;
			state++;
		}
		for (j = 0; j < Final; j++)
		{
			state++;
		}
		state++;
		for (j = 0; j < 16; j++) Known[pos++]=16*state+j;
		state++;
	}
	for (j = 0; j < NombreCstRonde; j++) Known[pos++]=16*state+j;
	printf("Variables Knownes : ");
	for (i = 0; i < pos; i++) printf("%u ",Known[i]);
	/*getchar();*/
	*N=taille;
	return Known;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x10(%rsp)
movl %edx, %ebp
movl %esi, %r12d
movl %edi, %r15d
leal (%r12,%r15), %ebx
movl %edx, %eax
shll $0x4, %eax
addl %ebx, %eax
movl %eax, 0xc(%rsp)
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x21c0
movq %rax, %r14
xorl %r13d, %r13d
testl %r15d, %r15d
movl $0x0, %edx
cmovgl %r15d, %edx
testl %r12d, %r12d
movl $0x0, %esi
cmovgl %r12d, %esi
leal (%rsi,%rdx,2), %ecx
testl %ebp, %ebp
cmovlel %r13d, %ebp
movl %ebx, %eax
shll $0x4, %eax
addl $0x10, %eax
shll $0x4, %ecx
addl $0x20, %ecx
shll $0x5, %edx
shll $0x4, %r12d
shll $0x4, %r15d
addl %r12d, %r15d
addl %edx, %r15d
shll $0x4, %esi
leal (%rsi,%r15), %edx
addl $0x20, %edx
xorl %esi, %esi
movslq %r13d, %rdi
cmpl %ebp, %esi
je 0x672f
leaq (%r14,%rdi,4), %r8
xorl %edi, %edi
cmpl $0x10, %edi
je 0x6723
leal (%rdx,%rdi), %r9d
movl %r9d, (%r8,%rdi,4)
incq %rdi
jmp 0x6711
addl %edi, %r13d
incl %esi
addl %ecx, %eax
addq %rcx, %rdx
jmp 0x6704
xorl %ecx, %ecx
testl %ebx, %ebx
cmovlel %ecx, %ebx
leaq (%r14,%rdi,4), %rdx
cmpl %ecx, %ebx
je 0x6748
movl %eax, (%rdx,%rcx,4)
incq %rcx
incl %eax
jmp 0x673a
leaq 0x20a31(%rip), %rdi     # 0x27180
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x2110
addl %r13d, %ebx
testl %ebx, %ebx
cmovlel %r15d, %ebx
leaq 0x20a2c(%rip), %r15     # 0x27195
xorl %r12d, %r12d
cmpq %r12, %rbx
je 0x6784
movl (%r14,%r12,4), %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x2110
incq %r12
jmp 0x676c
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
movl %ecx, (%rax)
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/cbouilla[P]AES-attacks-finder/Solver.c
// Function: NewSolver
Solver NewSolver(void) // Renvoi l'adresse d'une SOLVER disponible
{
	static int Initialiser_Espace = 1;
		
	if (Nombre_de_Solver_disponible_pour_allocation) return Espace_Solver_pour_allocation[--Nombre_de_Solver_disponible_pour_allocation];
	else
	{
		if (Initialiser_Espace)
		{
			Initialiser_Espace = 0;
			Espace_Solver_pour_allocation = malloc(Taille_bloc_pour_allocation_Espace*sizeof(Solver));
			Taille_Espace_Solver_pour_allocation = Taille_bloc_pour_allocation_Espace;
		}
		SOLVER * __restrict tmp = malloc(Taille_bloc_pour_allocation_Espace*sizeof(SOLVER));
		int i;
		for (i = 0; i < Taille_bloc_pour_allocation_Espace; i++)
		{
			Espace_Solver_pour_allocation[i]=tmp++;
			Espace_Solver_pour_allocation[i]->parents=1;
		}
		Nombre_de_Solver_disponible_pour_allocation = Taille_bloc_pour_allocation_Espace;
		return Espace_Solver_pour_allocation[--Nombre_de_Solver_disponible_pour_allocation];
	}
}

// Assembly:
pushq %rax
movslq 0x29b14(%rip), %rax     # 0x302c0
testq %rax, %rax
je 0x67c5
leaq -0x1(%rax), %rcx
movl %ecx, 0x29b05(%rip)     # 0x302c0
leaq -0x8(,%rax,8), %rax
jmp 0x683a
cmpb $0x0, 0x29b04(%rip)     # 0x302d0
jne 0x67f0
movb $0x1, 0x29afb(%rip)     # 0x302d0
movl $0x13880, %edi          # imm = 0x13880
callq 0x21c0
movq %rax, 0x29ae2(%rip)     # 0x302c8
movl $0x2710, 0x29ad4(%rip)  # imm = 0x2710
movl $0x75300, %edi          # imm = 0x75300
callq 0x21c0
xorl %ecx, %ecx
cmpq $0x2710, %rcx           # imm = 0x2710
je 0x682b
movq 0x29abc(%rip), %rdx     # 0x302c8
movq %rax, (%rdx,%rcx,8)
addq $0x30, %rax
movq 0x29aad(%rip), %rdx     # 0x302c8
movq (%rdx,%rcx,8), %rdx
movl $0x1, 0x1c(%rdx)
incq %rcx
jmp 0x67fc
movl $0x270f, 0x29a8b(%rip)  # imm = 0x270F
movl $0x13878, %eax          # imm = 0x13878
addq 0x29a87(%rip), %rax     # 0x302c8
movq (%rax), %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/cbouilla[P]AES-attacks-finder/Solver.c
// Function: freeSolver
void freeSolver(Solver a) // libère la mémoire associée à une solver
{
	if (a!=NULL)
	{
		if (a->parents==1) // elle n'est plus utilisée
		{
			if (Taille_Espace_Solver_pour_allocation == Nombre_de_Solver_disponible_pour_allocation)
			{
				Taille_Espace_Solver_pour_allocation+= Taille_bloc_pour_allocation_Espace;
				Espace_Solver_pour_allocation = realloc(Espace_Solver_pour_allocation, Taille_Espace_Solver_pour_allocation*sizeof(Solver));
			}
			Espace_Solver_pour_allocation[Nombre_de_Solver_disponible_pour_allocation++]=a;
			free(a->var);
			freeSolver(a->fils1);
			freeSolver(a->fils2);
		}
		else (a->parents)--;
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rbx, %rbx
je 0x68d1
movl 0x1c(%rbx), %eax
cmpl $0x1, %eax
jne 0x68cc
movslq 0x29a5a(%rip), %rdx     # 0x302c4
movl 0x29a50(%rip), %ecx     # 0x302c0
movq 0x29a51(%rip), %rax     # 0x302c8
cmpl %ecx, %edx
jne 0x68a5
leaq 0x2710(%rdx), %rcx
movl %ecx, 0x29a3c(%rip)     # 0x302c4
leaq 0x13880(,%rdx,8), %rsi
movq %rax, %rdi
callq 0x21f0
movq %rax, 0x29a29(%rip)     # 0x302c8
movl 0x29a1b(%rip), %ecx     # 0x302c0
leal 0x1(%rcx), %edx
movl %edx, 0x29a12(%rip)     # 0x302c0
movslq %ecx, %rcx
movq %rbx, (%rax,%rcx,8)
movq (%rbx), %rdi
callq 0x2030
movq 0x20(%rbx), %rdi
callq 0x6852
movq 0x28(%rbx), %rbx
jmp 0x6856
decl %eax
movl %eax, 0x1c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/cbouilla[P]AES-attacks-finder/Solver.c
// Function: print_solver
void print_solver(FILE *out, Solver B, string_list_t *variable_names) // crée le xml associé à une solver
{
  int i;

  fprintf(out,"<solver>\n");
  fprintf(out,"  <time>%d</time>\n",  B->temps);
  fprintf(out,"  <memory>%d</memory>\n", B->memoire);
  fprintf(out,"  <output>%d</output>\n", B->sortie);
  fprintf(out,"  <type>%d</type>\n", B->type);
  fprintf(out,"  <variables>");
  for(i=0; i<B->Nvar; i++)
    fprintf(out,"  <variable>%s</variable>\n", find_var_name(variable_names, B->var[i]));
  fprintf(out,"</variables>\n");
  if (B->fils1 != NULL) print_solver(out, B->fils1, variable_names);
  if (B->fils2 != NULL) print_solver(out, B->fils2, variable_names);
  fprintf(out,"</solver>\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x20649(%rip), %rdi     # 0x271c6
pushq $0x9
popq %rsi
pushq $0x1
popq %r12
movq %r12, %rdx
movq %rbx, %rcx
callq 0x2250
movl 0xc(%r15), %edx
leaq 0x20636(%rip), %rsi     # 0x271d0
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2180
movl 0x10(%r15), %edx
leaq 0x20634(%rip), %rsi     # 0x271e3
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2180
movl 0x14(%r15), %edx
leaq 0x20636(%rip), %rsi     # 0x271fa
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2180
movsbl 0x18(%r15), %edx
leaq 0x20637(%rip), %rsi     # 0x27211
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2180
leaq 0x20639(%rip), %rdi     # 0x27224
pushq $0xd
popq %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x2250
leaq 0x20632(%rip), %r12     # 0x27232
xorl %r13d, %r13d
movslq 0x8(%r15), %rax
cmpq %rax, %r13
jge 0x6c30
movq (%r15), %rax
movl (%rax,%r13,4), %esi
movq %r14, %rdi
callq 0xbf23
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x2180
incq %r13
jmp 0x6c03
leaq 0x20616(%rip), %rdi     # 0x2724d
pushq $0xd
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x2250
movq 0x20(%r15), %rsi
testq %rsi, %rsi
je 0x6c59
movq %rbx, %rdi
movq %r14, %rdx
callq 0x6b64
movq 0x28(%r15), %rsi
testq %rsi, %rsi
je 0x6c6d
movq %rbx, %rdi
movq %r14, %rdx
callq 0x6b64
leaq 0x205e7(%rip), %rdi     # 0x2725b
pushq $0xa
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2250
// File: /workspace/github_c_makefile_star2_O2/cbouilla[P]AES-attacks-finder/Solver.c
// Function: BaseSolver
Solver BaseSolver(int i, SysEqLin E) // Solver associée à la variable i
{
	if (E->gen*E->lignevar[i]<E->a)
	{
		Solver B = NewSolver();
		B->var=malloc(sizeof(int));
		B->Nvar=1;
		B->var[0]=i;
		#if 0
		B->initialisation=E;
		B->mat=InfoSortie_VariablesVersion(B->var,B->Nvar,E);
		B->sortie=B->mat->nombre_de_lignes-(E->gen-1);
		#else
		B->sortie=TailleE(B->var,1,E);
		#endif
		B->temps=1;
		B->memoire=1; // mettre 0 cause quelques problèmes, en plus il faut bien avoir la table de la Sbox
		B->type=0;
		B->fils1=NULL;
		B->fils2=NULL;
		return B;
	}
	else return NULL;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq 0x18(%rsi), %rax
movslq %edi, %rcx
movl (%rax,%rcx,4), %eax
imull 0x10(%rsi), %eax
cmpl 0x8(%rsi), %eax
jge 0x6d82
movq %rsi, %r14
movl %edi, %ebp
callq 0x67a4
movq %rax, %rbx
pushq $0x4
popq %rdi
callq 0x21c0
movq %rax, (%rbx)
movl $0x1, 0x8(%rbx)
movl %ebp, (%rax)
pushq $0x1
popq %rsi
movq %rax, %rdi
movq %r14, %rdx
callq 0x96cf
movl %eax, 0x14(%rbx)
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0xc(%rbx)
movb $0x0, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
jmp 0x6d84
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/cbouilla[P]AES-attacks-finder/Solver.c
// Function: ParcoursSolver
void ParcoursSolver(Solver B) // Permet de parcourir une solver, utile pour debugguer
{
	printf("Solver (%d || %d || %d) - %d : ",B->temps,B->memoire,B->sortie,B->type);
	PrintVarSolver(B);
	if (B->type!=0)
	{
		printf("Solver 1 (%d || %d || %d) - %d : ",B->fils1->temps,B->fils1->memoire,B->fils1->sortie,B->fils1->type);
		PrintVarSolver(B->fils1);
		printf("Solver 2 (%d || %d || %d) - %d : ",B->fils2->temps,B->fils2->memoire,B->fils2->sortie,B->fils2->type);
		PrintVarSolver(B->fils2);
		int i;
		if (B->fils1->Nvar==1) i = 2; // zap les unions simples
		else
		{
			if (B->fils2->Nvar==1) i = 1;
			else
			{
				printf("Quelle solver : ?");
				scanf("%d",&i);
				getchar();
			}
		}
		if (i==1) ParcoursSolver(B->fils1);
		else ParcoursSolver(B->fils2);
	}	
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0xc(%rdi), %esi
movl 0x10(%rdi), %edx
movl 0x14(%rdi), %ecx
movsbl 0x18(%rdi), %r8d
leaq 0x2048c(%rip), %rdi     # 0x2726a
xorl %eax, %eax
callq 0x2110
movq %rbx, %rdi
callq 0x6c8b
cmpb $0x0, 0x18(%rbx)
je 0x6ead
movq 0x20(%rbx), %rax
movl 0xc(%rax), %esi
movl 0x10(%rax), %edx
movl 0x14(%rax), %ecx
movsbl 0x18(%rax), %r8d
leaq 0x2047a(%rip), %rdi     # 0x2728a
xorl %eax, %eax
callq 0x2110
movq 0x20(%rbx), %rdi
callq 0x6c8b
movq 0x28(%rbx), %rax
movl 0xc(%rax), %esi
movl 0x10(%rax), %edx
movl 0x14(%rax), %ecx
movsbl 0x18(%rax), %r8d
leaq 0x20473(%rip), %rdi     # 0x272ac
xorl %eax, %eax
callq 0x2110
movq 0x28(%rbx), %rdi
callq 0x6c8b
movq 0x20(%rbx), %rdi
cmpl $0x1, 0x8(%rdi)
jne 0x6e61
movl $0x2, 0x4(%rsp)
movq 0x28(%rbx), %rdi
jmp 0x6ea8
movq 0x28(%rbx), %rax
cmpl $0x1, 0x8(%rax)
jne 0x6e75
movl $0x1, 0x4(%rsp)
jmp 0x6ea8
leaq 0x20452(%rip), %rdi     # 0x272ce
xorl %eax, %eax
callq 0x2110
leaq 0x23d13(%rip), %rdi     # 0x2ab9d
leaq 0x4(%rsp), %r14
movq %r14, %rsi
xorl %eax, %eax
callq 0x2220
callq 0x2170
cmpl $0x1, (%r14)
jne 0x6e5b
movq 0x20(%rbx), %rdi
callq 0x6dc2
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/cbouilla[P]AES-attacks-finder/Solver.c
// Function: TriFusion1_tmp
void TriFusion1_tmp(Solver * __restrict B1, const int N, Solver * __restrict B)
{
	if (N>=2)
	{
		const int N1=N/2;
		TriFusion1_tmp(B1,N1,B);
		TriFusion1_tmp(B1+N1,N-N1,B);
		if (B1[N1]->sortie<=B1[N1-1]->sortie && (B1[N1]->sortie!=B1[N1-1]->sortie || B1[N1]->Nvar>=B1[N1-1]->Nvar)) // On vérifie qu'elle n'est pas déjà triée
		{
			int i;
			for (i = 0; i < N1; i++) B[i]=B1[i];
			i=0;
			int j=N1;
			int cpt=0;
			while (i<N1 && j<N)
			{
				if ((B[i]->sortie==B1[j]->sortie && B[i]->Nvar >= B1[j]->Nvar) || B[i]->sortie<B1[j]->sortie ) B1[cpt++]=B[i++];
				else B1[cpt++]=B1[j++];
			}
			for (i = i; i < N1; i++) B1[cpt++]=B[i];
		}	
	}
}

// Assembly:
cmpl $0x2, %esi
jl 0x6f05
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %r15d
shrl %r15d
movl %r15d, %esi
callq 0x6eb5
leaq (%r14,%r15,8), %r12
movl %ebp, %esi
subl %r15d, %esi
movq %r12, %rdi
movq %rbx, %rdx
callq 0x6eb5
movq -0x8(%r12), %rax
movq (%r12), %rcx
movl 0x14(%rax), %edx
cmpl %edx, 0x14(%rcx)
jle 0x6f06
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jne 0x6f10
movl 0x8(%rcx), %ecx
cmpl 0x8(%rax), %ecx
jl 0x6efd
xorl %eax, %eax
cmpq %rax, %r15
je 0x6f24
movq (%r14,%rax,8), %rcx
movq %rcx, (%rbx,%rax,8)
incq %rax
jmp 0x6f12
xorl %ecx, %ecx
movq %r14, %rax
movl %r15d, %edx
movslq %ecx, %rsi
cmpl %r15d, %ecx
jge 0x6f6a
cmpl %ebp, %edx
jge 0x6f6a
movq (%rbx,%rsi,8), %rsi
movl %edx, %edi
movq (%r14,%rdi,8), %rdi
movl 0x14(%rdi), %r8d
cmpl %r8d, 0x14(%rsi)
jne 0x6f5a
movl 0x8(%rsi), %r8d
cmpl 0x8(%rdi), %r8d
jl 0x6f5c
incl %ecx
jmp 0x6f61
jl 0x6f56
incl %edx
movq %rdi, %rsi
movq %rsi, (%rax)
addq $0x8, %rax
jmp 0x6f2c
movl %r15d, %ecx
cmpq %rcx, %rsi
jge 0x6efd
movq (%rbx,%rsi,8), %rdx
movq %rdx, (%rax)
incq %rsi
addq $0x8, %rax
jmp 0x6f6d
// File: /workspace/github_c_makefile_star2_O2/cbouilla[P]AES-attacks-finder/Solver.c
// Function: TriFusion1
void TriFusion1(Solver * __restrict B1, const int N) // Trie une liste de solvers selon 1) la sortie dans l'ordre croissant 2) le nombre de variables dans l'ordre décroissant.
{
	if (N>=2)
	{
		Solver * __restrict B=malloc((N/2)*sizeof(Solver));
		TriFusion1_tmp(B1,N,B);
		free(B);
	}
}

// Assembly:
cmpl $0x2, %esi
jl 0x6fbb
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %edi
shrl %edi
shlq $0x3, %rdi
callq 0x21c0
movq %rax, %r15
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rdx
callq 0x6eb5
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2030
retq
// File: /workspace/github_c_makefile_star2_O2/cbouilla[P]AES-attacks-finder/Solver.c
// Function: TimeForOne
int TimeForOne(Solver B) // Renvoi la complexité pour avoir la première solution (PROBABLEMENT FAUSSE)
{
	//if (B->type==0) return min(1-B->sortie,B->temps);
	if (B->type==0) return (B->sortie >= 0 ? 0 : 1);
	if (B->sortie<=0) return B->temps;
	if (B->type==2) return max(TimeForOne(B->fils2),TimeForOne(B->fils1));
	int t1=TimeForOne(B->fils1);
	int t2=B->fils2->temps;
	return min(max(t2,t1+max(B->fils1->sortie-B->sortie,0)),B->temps);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x80000000, %ebx       # imm = 0x80000000
movb 0x18(%r14), %al
movl 0x14(%r14), %ebp
testb %al, %al
je 0x6ff3
testl %ebp, %ebp
jle 0x6ff8
cmpb $0x2, %al
jne 0x6ffe
movq 0x28(%r14), %rdi
callq 0x6fbc
movq 0x20(%r14), %r14
cmpl %ebx, %eax
cmovgl %eax, %ebx
jmp 0x6fcb
shrl $0x1f, %ebp
jmp 0x7034
movl 0xc(%r14), %ebp
jmp 0x7034
movq 0x20(%r14), %r15
movq %r15, %rdi
callq 0x6fbc
movq 0x28(%r14), %rdx
movl 0x14(%r15), %esi
subl %ebp, %esi
xorl %ecx, %ecx
testl %esi, %esi
cmovgl %esi, %ecx
movl 0xc(%rdx), %edx
addl %eax, %ecx
movl 0xc(%r14), %ebp
cmpl %ecx, %edx
jle 0x702f
cmpl %ebp, %edx
cmovll %edx, %ebp
jmp 0x7034
cmpl %ebp, %ecx
cmovll %ecx, %ebp
cmpl %ebx, %ebp
cmovgl %ebp, %ebx
movl %ebx, %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/Solver.c
// Function: SimplifierTypeSolver
Solver SimplifierTypeSolver(Solver B) // Si B est de type 2, renvoi une solver equivalente où fils1 n'est pas de type 2.
{
	if (B->type!=2 || B->fils1->type!=2) return copySolver(B);
	int N;
	int *X=UnionListesTriees(B->fils1->fils2->var,B->fils1->fils2->Nvar,B->fils2->var,B->fils2->Nvar,&N);
	Solver tmp=NewSolver();
	tmp->var=malloc(B->Nvar*sizeof(int));
	tmp->Nvar=B->Nvar;
	int i;
	for (i = 0; i < tmp->Nvar; i++) tmp->var[i]=B->var[i];
	tmp->sortie=B->sortie;
	tmp->fils2=UnionSolver_tmp(B->fils2,B->fils1->fils2,X,N,B->sortie-B->fils1->fils1->sortie);
	tmp->fils1=copySolver(B->fils1->fils1);
	tmp->temps=max(tmp->fils2->temps,tmp->fils1->temps + max(0,tmp->fils2->sortie));
	tmp->memoire=max(tmp->fils1->memoire,tmp->fils2->memoire);
	tmp->type=2;
	Solver tmp2=SimplifierTypeSolver(tmp);
	freeSolver(tmp);
	return tmp2;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x2, 0x18(%rdi)
jne 0x70b7
movq 0x20(%rbx), %rax
cmpb $0x2, 0x18(%rax)
jne 0x70b7
movq 0x28(%rax), %rax
movq (%rax), %rdi
movl 0x8(%rax), %esi
movq 0x28(%rbx), %rax
movq (%rax), %rdx
movl 0x8(%rax), %ecx
leaq 0x4(%rsp), %r8
callq 0x2440
movq %rax, %r15
callq 0x67a4
movq %rax, %r14
movslq 0x8(%rbx), %r12
leaq (,%r12,4), %rdi
callq 0x21c0
movq %rax, (%r14)
movl %r12d, 0x8(%r14)
xorl %ecx, %ecx
cmpq %r12, %rcx
jge 0x70bf
movq (%rbx), %rdx
movl (%rdx,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
incq %rcx
jmp 0x70a4
incl 0x1c(%rbx)
jmp 0x713f
movl 0x14(%rbx), %r8d
movl %r8d, 0x14(%r14)
movq 0x20(%rbx), %rax
movq 0x28(%rbx), %rdi
movq 0x20(%rax), %rdx
movq 0x28(%rax), %rsi
movl 0x4(%rsp), %ecx
subl 0x14(%rdx), %r8d
movq %r15, %rdx
callq 0x714e
movq %rax, 0x28(%r14)
movq 0x20(%rbx), %rcx
movq 0x20(%rcx), %rcx
testq %rcx, %rcx
je 0x70fb
incl 0x1c(%rcx)
movq %rcx, 0x20(%r14)
movl 0x14(%rax), %edx
xorl %esi, %esi
testl %edx, %edx
cmovgl %edx, %esi
addl 0xc(%rcx), %esi
movl 0xc(%rax), %edx
cmpl %esi, %edx
cmovgl %edx, %esi
movl %esi, 0xc(%r14)
movl 0x10(%rcx), %ecx
movl 0x10(%rax), %eax
cmpl %eax, %ecx
cmovgl %ecx, %eax
movl %eax, 0x10(%r14)
movb $0x2, 0x18(%r14)
movq %r14, %rdi
callq 0x7046
movq %rax, %rbx
movq %r14, %rdi
callq 0x6852
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/cbouilla[P]AES-attacks-finder/Solver.c
// Function: UnionSolver
Solver UnionSolver(Solver B1, Solver B2, SysEqLin E) // Réalise l'union de deux solvers. (Les solvers sont supposées être associée à E)
{
	if (B1!=NULL && B2!=NULL)
	{
		int n;
		int *X=UnionListesTriees(B1->var,B1->Nvar,B2->var,B2->Nvar,&n);
		if (n != max(B1->Nvar,B2->Nvar))
		{
			#if 0
			MatriceCreuse tmp = InfoSortie_UnionVersion(B1,B2,E);
			Solver B = UnionSolver_tmp(B1,B2,X,n,tmp->nombre_de_lignes-(E->gen-1)*n);
			/*if (B->sortie!=TailleE(X,n,E))
			{
				printf("ça craint du boudin\n");
				getchar();
			}*/
			
			B->initialisation = E;
			B->mat = tmp;
			return B;
			#else
			return UnionSolver_tmp(B1,B2,X,n,TailleE(X,n,E));
			#endif
		}
		//if (n != max(B1->Nvar,B2->Nvar)) return UnionSolver_tmp(B1,B2,X,n,TailleE_Borne(X,n,E,B1->sortie+B2->sortie-1));
		else // Les variables d'une solvers sont contenues dans les variables de l'autre
		{
			free(X);
			if (n==B1->Nvar)
			{
				if (PlusInteressant(B2,B1)) return copySolver(B2);
				else return copySolver(B1);
			}
			else return copySolver(B2);
		}
	}
	else
	{
		if (B1==NULL) return copySolver(B2);
		else return copySolver(B1);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x736d
movq %rdx, %r15
movq (%r14), %rdi
movl 0x8(%r14), %esi
movq (%rbx), %rdx
movl 0x8(%rbx), %ecx
leaq 0x4(%rsp), %r13
movq %r13, %r8
callq 0x2440
movq %rax, %r12
movl (%r13), %ebp
movl 0x8(%r14), %eax
movl 0x8(%rbx), %ecx
cmpl %ecx, %eax
cmovgl %eax, %ecx
cmpl %ecx, %ebp
jne 0x737b
movq %r12, %rdi
callq 0x2030
movl 0x4(%rsp), %eax
cmpl 0x8(%r14), %eax
jne 0x73a5
cmpl %eax, 0x8(%rbx)
jl 0x7372
movl 0x14(%rbx), %eax
cmpl 0x14(%r14), %eax
jg 0x7372
movl 0xc(%r14), %eax
cmpl %eax, 0xc(%rbx)
jl 0x73a5
jne 0x7372
movl 0x10(%rbx), %eax
cmpl 0x10(%r14), %eax
jg 0x7372
jmp 0x73a5
testq %r14, %r14
je 0x73a0
incl 0x1c(%r14)
movq %r14, %rbx
jmp 0x73ac
movq %r12, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x96cf
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movl %ebp, %ecx
movl %eax, %r8d
callq 0x714e
movq %rax, %rbx
jmp 0x73ac
testq %rbx, %rbx
je 0x73aa
incl 0x1c(%rbx)
jmp 0x73ac
xorl %ebx, %ebx
movq %rbx, %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: UnionSolverBorne
Solver UnionSolverBorne(Solver B1, Solver B2, SysEqLin E, const int borne) // Réalise l'union de deux solvers ssi le résultat à une sortie <= borne
{
	if (B1!=NULL && B2!=NULL)
	{
		int n;
		int *X=UnionListesTriees(B1->var,B1->Nvar,B2->var,B2->Nvar,&n);
		if (n != max(B1->Nvar,B2->Nvar))
		{
			#if 0
			const int cst = (E->gen-1)*n;
			MatriceCreuse tmp = InfoSortie_UnionBorneVersion(B1,B2,E,borne+cst);
			if (tmp->nombre_de_lignes == -1)
			{
				free(X);
				freeMatriceCreuse(tmp);
				return NULL;
			}
			else
			{
				Solver B = UnionSolver_tmp(B1,B2,X,n,tmp->nombre_de_lignes-cst);
				/*const int t = TailleE(B->var,B->Nvar,E);
				MatriceCreuse tmp2 = InfoSortie_VariablesVersion(B->var,B->Nvar,E);
				if (B->sortie!=t)
				{
					printf("sortie = %d au lieu de %d\n",B->sortie,t);
					printf("TailleE (%d) :\n",tmp2->nombre_de_lignes-cst);
					PrintMatCreuse(tmp2);
					printf("Premier bloc :\n");
					PrintMatCreuse(B1->mat);
					printf("Deuxieme bloc :\n");
					PrintMatCreuse(B2->mat);
					printf("Resultat (n = %d) :\n",n);
					PrintMatCreuse(tmp);
					getchar();
				}*/
				B->initialisation = E;
				B->mat = tmp;
				return B;
			}
			#else
			const int sortie = TailleE_Borne(X,n,E,borne);
			if (sortie<=borne) return UnionSolver_tmp(B1,B2,X,n,sortie);
			else
			{
				free(X);
				return NULL;
			}
			#endif
			
			
			
		}
		else // Les variables d'une solvers sont contenues dans les variables de l'autre
		{
			free(X);
			if (n==B1->Nvar)
			{
				if (PlusInteressant(B2,B1)) return copySolver(B2);
				else return copySolver(B1);
			}
			else return copySolver(B2);
		}
	}
	else
	{
		if (B1==NULL) return copySolver(B2);
		else return copySolver(B1);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x744b
movq %rdx, %r15
movq (%r14), %rdi
movl 0x8(%r14), %esi
movq (%rbx), %rdx
movl 0x8(%rbx), %ecx
leaq 0x4(%rsp), %r13
movq %r13, %r8
callq 0x2440
movq %rax, %r12
movl (%r13), %esi
movl 0x8(%r14), %eax
movl 0x8(%rbx), %ecx
cmpl %ecx, %eax
cmovgl %eax, %ecx
cmpl %ecx, %esi
jne 0x7459
movq %r12, %rdi
callq 0x2030
movl 0x4(%rsp), %eax
cmpl 0x8(%r14), %eax
jne 0x7479
cmpl %eax, 0x8(%rbx)
jl 0x7450
movl 0x14(%rbx), %eax
cmpl 0x14(%r14), %eax
jg 0x7450
movl 0xc(%r14), %eax
cmpl %eax, 0xc(%rbx)
jl 0x7479
jne 0x7450
movl 0x10(%rbx), %eax
cmpl 0x10(%r14), %eax
jg 0x7450
jmp 0x7479
testq %r14, %r14
je 0x7474
incl 0x1c(%r14)
movq %r14, %rbx
jmp 0x749a
movq %r12, %rdi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x9b65
cmpl %ebp, %eax
jle 0x7482
movq %r12, %rdi
callq 0x2030
jmp 0x747e
testq %rbx, %rbx
je 0x747e
incl 0x1c(%rbx)
jmp 0x749a
xorl %ebx, %ebx
jmp 0x749a
movl 0x4(%rsp), %ecx
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movl %eax, %r8d
callq 0x714e
movq %rax, %rbx
movq %rbx, %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: UnionSpeciale
Solver UnionSpeciale(Solver B1, Solver B2, SysEqLin E) // fonction bizarre que j'avais crée pour un cas spéciale. NE PAS UTILISER
{
	Solver B,tmp;
	B=NewSolver();
	if (B1->type==2) tmp=copySolver(B1->fils1);
	else tmp=copySolver(B1);
	B->var=UnionListesTriees(tmp->var,tmp->Nvar,B2->var,B2->Nvar,&(B->Nvar));
	#if 0
	B->initialisation=E;
	B->mat=InfoSortie_UnionVersion(B1,B2,E);
	B->sortie=B->mat->nombre_de_lignes - (E->gen-1)*B->Nvar;
	#else
	B->sortie=TailleE(B->var,B->Nvar,E);
	#endif
	B->temps=max(B->sortie,max(tmp->temps+B2->sortie,B2->temps));
	B->memoire=max(tmp->memoire,B2->memoire);
	B->type=2;
	B->fils1=tmp;
	B->fils2=copySolver(B2);
	if (B->memoire>1)
	{
		printf("C'est très bizarre : %d %d %d",B->memoire,B1->memoire,B2->memoire);
		getchar();
	}
	return B;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
callq 0x67a4
movq %rax, %rbx
cmpb $0x2, 0x18(%r15)
movq %r15, %r13
jne 0x74dd
movq 0x20(%r15), %r13
testq %r13, %r13
je 0x7576
incl 0x1c(%r13)
movq (%r13), %rdi
movl 0x8(%r13), %esi
movq (%r14), %rdx
movl 0x8(%r14), %ecx
movq %rbx, %r8
addq $0x8, %r8
callq 0x2440
movq %rax, (%rbx)
movl 0x8(%rbx), %esi
movq %rax, %rdi
movq %r12, %rdx
callq 0x96cf
movl %eax, 0x14(%rbx)
movl 0x14(%r14), %ecx
addl 0xc(%r13), %ecx
movl 0xc(%r14), %edx
cmpl %edx, %ecx
cmovlel %edx, %ecx
cmpl %ecx, %eax
cmovgl %eax, %ecx
movl %ecx, 0xc(%rbx)
movl 0x10(%r13), %eax
movl 0x10(%r14), %esi
cmpl %esi, %eax
cmovgl %eax, %esi
movl %esi, 0x10(%rbx)
movb $0x2, 0x18(%rbx)
movq %r13, 0x20(%rbx)
incl 0x1c(%r14)
movq %r14, 0x28(%rbx)
cmpl $0x2, %esi
jl 0x7569
movl 0x10(%r15), %edx
movl 0x10(%r14), %ecx
leaq 0x1fd83(%rip), %rdi     # 0x272e0
xorl %eax, %eax
callq 0x2110
callq 0x2170
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %r13d, %r13d
jmp 0x74e1
// File: /workspace/github_c_makefile_star2_O2/cbouilla[P]AES-attacks-finder/Solver.c
// Function: UnionSolver2
Solver UnionSolver2(Solver B1, Solver B2, SysEqLin E) // Retourne la solver B2 -> B1. PEUT PRESENTER DES PROBLEMES SI B1 n B2 NON VIDE.
{
	Solver B = NewSolver();
	B->var=UnionListesTriees(B1->var,B1->Nvar,B2->var,B2->Nvar,&B->Nvar);
	#if 0
	B->initialisation=E;
	B->mat=InfoSortie_UnionVersion(B1,B2,E);
	B->sortie=B->mat->nombre_de_lignes - (E->gen-1)*B->Nvar;
	#else
	B->sortie=TailleE(B->var,B->Nvar,E);
	#endif
	B->temps = max(B2->temps,max(0,B2->sortie)+B1->temps);
	B->memoire=max(B1->memoire,B2->memoire);
	B->type=2;
	B->fils1=copySolver(B1);
	B->fils2=copySolver(B2);
	return B;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
callq 0x67a4
movq %rax, %r15
movq (%r14), %rdi
movl 0x8(%r14), %esi
movq (%rbx), %rdx
movl 0x8(%rbx), %ecx
leaq 0x8(%rax), %r8
callq 0x2440
movq %rax, (%r15)
movl 0x8(%r15), %esi
movq %rax, %rdi
movq %r12, %rdx
callq 0x96cf
movl %eax, 0x14(%r15)
movl 0x14(%rbx), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovgl %eax, %ecx
addl 0xc(%r14), %ecx
movl 0xc(%rbx), %eax
cmpl %ecx, %eax
cmovgl %eax, %ecx
movl %ecx, 0xc(%r15)
movl 0x10(%r14), %eax
movl 0x10(%rbx), %ecx
cmpl %ecx, %eax
cmovgl %eax, %ecx
movl %ecx, 0x10(%r15)
movb $0x2, 0x18(%r15)
incl 0x1c(%r14)
movq %r14, 0x20(%r15)
incl 0x1c(%rbx)
movq %rbx, 0x28(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq