LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x38, %edi
callq 0x21d0
movq %rax, %r14
movl $0x0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movl $0x1, 0x18(%rax)
movl $0x8, %edi
callq 0x21d0
movq %rax, %r12
movq %rax, 0x20(%r14)
movl $0x1, %edi
callq 0x21d0
movq %rax, %r13
movq %rax, 0x28(%r14)
movl $0x1, %edi
callq 0x21d0
movq %rax, %rbp
movq %rax, 0x30(%r14)
movq %r15, %rdi
callq 0x4b4b
movq %rax, (%r12)
movb $0x1, (%r13)
movb %bl, (%rbp)
movq %r14, %rdi
callq 0x4f82
movq %rax, %rbx
movq %r14, %rdi
callq 0x4ad9
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_O3/cbouilla[P]AES-attacks-finder/Equation.c
// Function: dependEq
int dependEq(Equation a, int var)
{
	int i;
	for (i = 0; i < a->nV; i++) if (a->var[i]==var) return 1;
	for (i = 0; i < a->nS; i++) if (dependEq(a->S[i],var)) return 1;
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movslq (%rdi), %rax
testq %rax, %rax
jle 0x5899
movq 0x8(%rdi), %rcx
xorl %edx, %edx
cmpl %ebx, (%rcx,%rdx,4)
je 0x58c4
incq %rdx
cmpq %rdx, %rax
jne 0x588c
movslq 0x18(%rdi), %r14
testq %r14, %r14
jle 0x58c0
movq 0x20(%rdi), %r15
xorl %r12d, %r12d
movq (%r15,%r12,8), %rdi
movl %ebx, %esi
callq 0x5874
testl %eax, %eax
jne 0x58c4
incq %r12
cmpq %r12, %r14
jne 0x58a9
xorl %eax, %eax
jmp 0x58c9
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4c61
testl %eax, %eax
je 0x5cdd
leaq 0x234cb(%rip), %rdi     # 0x2919c
xorl %eax, %eax
callq 0x2110
callq 0x2180
cmpl $0x0, 0x18(%r15)
jle 0x5d2d
xorl %r13d, %r13d
movq 0x20(%r15), %rax
movq (%rax,%r13,8), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x4c61
movq %r12, %rdi
testl %eax, %eax
je 0x5d17
callq 0x4ad9
movl %ebx, %edi
callq 0x4d63
movq 0x20(%r15), %rcx
movq %rax, (%rcx,%r13,8)
jmp 0x5d21
movq %r14, %rsi
movl %ebx, %edx
callq 0x5cb0
incq %r13
movslq 0x18(%r15), %rax
cmpq %rax, %r13
jl 0x5ce7
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
movslq 0x18(%rdi), %rax
testq %rax, %rax
jle 0x5d71
movq 0x30(%rbx), %rcx
negq %rax
movl $0x1, %ebp
cmpb $0x1, -0x1(%rcx,%rbp)
je 0x5d87
leaq (%rax,%rbp), %rdx
incq %rdx
incq %rbp
cmpq $0x1, %rdx
jne 0x5d5a
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4b4b
movq 0x20(%rbx), %rax
movq -0x8(%rax,%rbp,8), %rdi
callq 0x4b4b
movq %rax, %r14
movq %rax, %rdi
movl $0x1, %esi
callq 0x57d7
movq %rax, %r15
movq 0x28(%rbx), %rax
movzbl -0x1(%rax,%rbp), %edi
movq %r15, %rsi
callq 0x4e14
movq %rax, %r12
movq %r15, %rdi
callq 0x4ad9
movq %rbx, %rdi
movq %r12, %rsi
callq 0x557f
movq %rax, %r15
movq %r12, %rdi
callq 0x4ad9
movq 0x28(%rbx), %rax
movzbl -0x1(%rax,%rbp), %edi
callq 0x2534
movzbl %al, %edi
movq %r15, %rsi
callq 0x4e14
movq %rax, %r12
movq %r15, %rdi
callq 0x4ad9
movq %r12, %rdi
xorl %esi, %esi
callq 0x57d7
movq %rax, %r13
movq %r12, %rdi
callq 0x4ad9
movq %r14, %rdi
movq %r13, %rsi
callq 0x557f
movq %rax, %r15
movq %r14, %rdi
callq 0x4ad9
movq %r13, %rdi
callq 0x4ad9
movl 0x18(%rbx), %eax
cmpl %eax, %ebp
jge 0x5e62
leaq 0x2336d(%rip), %r14     # 0x291ac
movq 0x30(%rbx), %rcx
cmpb $0x1, (%rcx,%rbp)
jne 0x5e5b
movq %r14, %rdi
xorl %eax, %eax
callq 0x2110
callq 0x2180
movl 0x18(%rbx), %eax
incq %rbp
cmpl %ebp, %eax
jg 0x5e3f
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_O3/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
pushq %rax
movq %rdx, %r15
leaq 0x4(%rsp), %r14
movq %r14, %rdx
callq 0x5e74
movq %rax, %rbx
movslq (%r14), %r14
testq %r14, %r14
jle 0x60f1
xorl %ebp, %ebp
movq (%rbx,%rbp,8), %r12
movq %r12, %rdi
callq 0x5d37
movq %rax, %r13
movq %r12, %rdi
callq 0x4ad9
movq %r13, (%rbx,%rbp,8)
incq %rbp
cmpq %rbp, %r14
jne 0x60a2
movq %rbx, %rdi
movl %r14d, %esi
movq %r15, %rdx
callq 0x5e74
movq %rax, %r15
testl %r14d, %r14d
jle 0x6102
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rdi
callq 0x4ad9
incq %r12
cmpq %r12, %r14
jne 0x60de
jmp 0x6102
movq %rbx, %rdi
movl %r14d, %esi
movq %r15, %rdx
callq 0x5e74
movq %rax, %r15
movq %rbx, %rdi
callq 0x2030
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_O3/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 $0x28, %rsp
movq %rsi, 0x18(%rsp)
movq %rdi, %r12
movslq 0x18(%rdi), %r13
leal 0x1(%r13), %eax
movl %eax, 0x8(%rsp)
movslq %eax, %r15
leaq (,%r15,8), %rdi
callq 0x21d0
movq %rax, %r14
shlq $0x2, %r15
movq %r15, %rdi
callq 0x21d0
movq %rax, %rbp
movq %r13, %rbx
movq %r13, 0x10(%rsp)
testq %r13, %r13
jle 0x6199
xorl %r15d, %r15d
movq %rbp, %r13
movq 0x20(%r12), %rax
movq (%rax,%r15,8), %rdi
movq %r13, %rsi
callq 0x611c
movq %rax, (%r14,%r15,8)
incq %r15
movslq 0x18(%r12), %rbx
addq $0x4, %r13
cmpq %rbx, %r15
jl 0x6173
movslq (%r12), %r13
leaq (,%r13,4), %rdi
callq 0x21d0
movq %rax, (%r14,%rbx,8)
testq %r13, %r13
jle 0x61de
movq 0x8(%r12), %rax
xorl %ecx, %ecx
movl (%rax,%rcx,4), %edx
movslq 0x18(%r12), %rsi
movq (%r14,%rsi,8), %rsi
movl %edx, (%rsi,%rcx,4)
incq %rcx
movslq (%r12), %r13
cmpq %r13, %rcx
jl 0x61ba
movslq 0x18(%r12), %rbx
movq (%r14,%rbx,8), %rax
movl %r13d, (%rbp,%rbx,4)
movq %rax, %rdi
movl %r13d, %esi
callq 0x2bf3
xorl %r13d, %r13d
xorl %edi, %edi
callq 0x21d0
movq %rax, %rbx
cmpl $0x0, 0x10(%rsp)
js 0x6263
movq %rbp, 0x20(%rsp)
movl 0x8(%rsp), %r15d
xorl %ebp, %ebp
xorl %r13d, %r13d
movq %rbx, %r12
movq (%r14,%rbp,8), %rdx
movq 0x20(%rsp), %rax
movl (%rax,%rbp,4), %ecx
movq %rbx, %rdi
movl %r13d, %esi
leaq 0xc(%rsp), %r8
callq 0x2544
movq %rax, %rbx
movq %r12, %rdi
callq 0x2030
movl 0xc(%rsp), %r13d
incq %rbp
cmpq %rbp, %r15
jne 0x6211
cmpl $0x0, 0x10(%rsp)
js 0x6263
xorl %r12d, %r12d
movq (%r14,%r12,8), %rdi
callq 0x2030
incq %r12
cmpq %r12, %r15
jne 0x6252
movq %r14, %rdi
callq 0x2030
movq 0x18(%rsp), %rax
movl %r13d, (%rax)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x38, %edi
callq 0x21d0
movq %rax, %r12
xorl %eax, %eax
movl %eax, (%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r12)
movl %eax, 0x18(%r12)
movups %xmm0, 0x20(%r12)
movq $0x0, 0x30(%r12)
cmpl %eax, (%r15)
jle 0x6622
xorl %ebx, %ebx
movq 0x8(%r15), %rax
movl (%rax,%rbx,4), %ebp
movl %ebp, %edi
movq %r14, %rsi
movl 0x4(%rsp), %edx
callq 0x2af1
cmpl $-0x1, %eax
je 0x6617
movl %ebp, %edi
callq 0x4d63
movq %rax, %r13
movq 0x10(%r15), %rax
movzbl (%rax,%rbx), %edi
movq %r13, %rsi
callq 0x4e14
movq %rax, %rbp
movq %r13, %rdi
callq 0x4ad9
movq %rbp, %rdi
movq %r12, %rsi
callq 0x557f
movq %rax, %r13
movq %r12, %rdi
callq 0x4ad9
movq %rbp, %rdi
callq 0x4ad9
movq %r13, %r12
incq %rbx
movslq (%r15), %rax
cmpq %rax, %rbx
jl 0x65b7
cmpl $0x0, 0x18(%r15)
jle 0x66c1
xorl %ebx, %ebx
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 0x2af1
cmpl $-0x1, %eax
je 0x66b1
movl %ebp, %edi
callq 0x4d63
movq %rax, %r13
movq 0x30(%r15), %rax
movzbl (%rax,%rbx), %esi
movq %r13, %rdi
callq 0x57d7
movq %rax, %rbp
movq %r13, %rdi
callq 0x4ad9
movq 0x28(%r15), %rax
movzbl (%rax,%rbx), %edi
movq %rbp, %rsi
callq 0x4e14
movq %rax, %r13
movq %rbp, %rdi
callq 0x4ad9
movq %r13, %rdi
movq %r12, %rsi
callq 0x557f
movq %rax, %rbp
movq %r12, %rdi
callq 0x4ad9
movq %r13, %rdi
callq 0x4ad9
movq %rbp, %r12
incq %rbx
movslq 0x18(%r15), %rax
cmpq %rax, %rbx
jl 0x662f
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_O3/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 $0x38, %rsp
movl %ecx, %r15d
movl %edx, %r14d
movq %rdi, 0x10(%rsp)
shll $0x4, %esi
shll $0x4, %r14d
shll $0x4, %r15d
xorl %eax, %eax
xorl %ecx, %ecx
movq %rax, 0x20(%rsp)
movq %rcx, %rax
movq %rcx, 0x8(%rsp)
movslq %eax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rsp)
leaq (%rax,%rcx,8), %rax
movq %rax, 0x28(%rsp)
xorl %ebx, %ebx
movq %rsi, 0x30(%rsp)
leal (%rsi,%rbx), %edi
callq 0x4d63
movq %rax, %rbp
leal (%r14,%rbx), %edi
callq 0x4d63
movq %rax, %r12
movq %rbp, %rdi
movq %rax, %rsi
callq 0x557f
movq %rax, %r13
movq %rbp, %rdi
callq 0x4ad9
movq %r12, %rdi
callq 0x4ad9
leal (%r15,%rbx), %edi
callq 0x4d63
movq %rax, %r12
movq %rax, %rdi
movq %r13, %rsi
callq 0x557f
movq 0x28(%rsp), %rcx
movq %rax, (%rcx,%rbx,8)
movq %r12, %rdi
callq 0x4ad9
movq %r13, %rdi
callq 0x4ad9
movq 0x30(%rsp), %rsi
incq %rbx
cmpl $0x4, %ebx
jne 0x690b
movq 0x20(%rsp), %rax
incl %eax
movq 0x18(%rsp), %rcx
addq %rbx, %rcx
addq $0x4, %rsi
addq $0x4, %r14
addq $0x4, %r15
cmpl $0x4, %eax
jne 0x68e1
movq 0x8(%rsp), %rax
addl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 $0x48, %rsp
movl %edx, %ebx
movq %rdi, 0x10(%rsp)
shll $0x4, %esi
movq %rsi, 0x18(%rsp)
shll $0x4, %ebx
movb $0x1, %r14b
xorl %ecx, %ecx
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movslq %eax, %rdx
movq 0x18(%rsp), %rax
movq %rcx, 0x28(%rsp)
leal (%rax,%rcx,4), %eax
movd %eax, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
por 0x2272c(%rip), %xmm0    # 0x29130
movdqa %xmm0, 0x30(%rsp)
movq 0x10(%rsp), %rax
movq %rdx, 0x20(%rsp)
leaq (%rax,%rdx,8), %rbp
movl $0x3, %r15d
movl $0x38, %edi
callq 0x21d0
movq %rax, %r12
movq %rax, -0x18(%rbp,%r15,8)
movl $0x5, (%rax)
movl $0x14, %edi
callq 0x21d0
movq %rax, %r13
movq %rax, 0x8(%r12)
movl $0x5, %edi
callq 0x21d0
movq %rax, 0x10(%r12)
movaps 0x30(%rsp), %xmm0
movups %xmm0, (%r13)
leal (%rbx,%r15), %ecx
addl $-0x3, %ecx
movl %ecx, 0x10(%r13)
movb %r14b, 0x4(%rax)
movb $0x2, -0x3(%rax,%r15)
leal -0x2(%r15), %ecx
andl $0x3, %ecx
movb $0x3, (%rax,%rcx)
leaq -0x3(%r15), %rcx
xorq $0x2, %rcx
movb %r14b, (%rax,%rcx)
movl %r15d, %ecx
andl $0x3, %ecx
movb %r14b, (%rax,%rcx)
xorl %eax, %eax
movl $0x0, 0x18(%r12)
movq %rax, 0x20(%r12)
movq %rax, 0x30(%r12)
incq %r15
cmpq $0x7, %r15
jne 0x6a1e
movq 0x28(%rsp), %rcx
incq %rcx
addq $0x4, %rbx
movq 0x20(%rsp), %rax
addq %r15, %rax
addq $-0x3, %rax
cmpq $0x4, %rcx
jne 0x69de
movq 0x8(%rsp), %rax
addl %r15d, %eax
addl $-0x3, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 $0x48, %rsp
movq %rdi, 0x10(%rsp)
shll $0x4, %ecx
shll $0x4, %edx
shll $0x4, %esi
xorl %edi, %edi
xorl %eax, %eax
movq %rdx, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rax, 0x8(%rsp)
movslq %eax, %r8
movq 0x10(%rsp), %rax
movq %r8, 0x18(%rsp)
leaq (%rax,%r8,8), %rax
movq %rax, 0x38(%rsp)
movq %rdi, 0x20(%rsp)
movl %edi, %ebx
xorl %r15d, %r15d
movq %rcx, 0x40(%rsp)
movzbl %bl, %ebx
movl %ebx, %eax
andl $0x3, %eax
leal (%rdx,%rax,4), %r12d
leal (%rsi,%rax,4), %ebp
leal (%rcx,%r15), %edi
callq 0x4d63
movq %rax, %r13
movq %rax, %rdi
movl $0x1, %esi
callq 0x57d7
movq %rax, %r14
movq %r13, %rdi
callq 0x4ad9
addl %r15d, %r12d
movl %r12d, %edi
callq 0x4d63
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x557f
movq %rax, %r13
movq %r12, %rdi
callq 0x4ad9
movq %r14, %rdi
callq 0x4ad9
addl %r15d, %ebp
movl %ebp, %edi
callq 0x4d63
movq %rax, %r14
movq %rax, %rdi
movq %r13, %rsi
callq 0x557f
movq 0x38(%rsp), %rcx
movq %rax, (%rcx,%r15,8)
movq %r14, %rdi
callq 0x4ad9
movq %r13, %rdi
callq 0x4ad9
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x40(%rsp), %rcx
incq %r15
incb %bl
cmpl $0x4, %r15d
jne 0x6b49
movq 0x20(%rsp), %rdi
incl %edi
movq 0x18(%rsp), %rax
addq %r15, %rax
addq $0x4, %rcx
cmpl $0x4, %edi
jne 0x6b1f
movq 0x8(%rsp), %rax
addl %r15d, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r15d
movl %edi, %r12d
leal (%r15,%r12), %eax
movl %edx, %r13d
shll $0x5, %r13d
movl %eax, 0xc(%rsp)
addl %eax, %r13d
leal (,%r13,2), %eax
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x21d0
movq %rax, %r14
leal (%r15,%r12), %eax
incl %eax
testl %ebp, %ebp
jle 0x6ed8
leal (%r12,%r12), %ecx
xorl %edx, %edx
testl %r12d, %r12d
cmovlel %edx, %ecx
testl %r15d, %r15d
movl $0x0, %esi
cmovgl %r15d, %esi
movdqa 0x22311(%rip), %xmm0    # 0x29130
pcmpeqd %xmm1, %xmm1
movdqa 0x22325(%rip), %xmm2    # 0x29150
xorl %ebx, %ebx
movslq %ebx, %rdi
movd %edi, %xmm3
movd %eax, %xmm4
pshufd $0x0, %xmm4, %xmm4      # xmm4 = xmm4[0,0,0,0]
pslld $0x4, %xmm4
leaq (%r14,%rdi,4), %rdi
xorl %r8d, %r8d
movdqa %xmm0, %xmm5
psubd %xmm1, %xmm3
movdqa %xmm5, %xmm6
paddd %xmm4, %xmm6
movdqu %xmm6, (%rdi,%r8,4)
addq $0x4, %r8
paddd %xmm2, %xmm5
cmpq $0x10, %r8
jne 0x6e4d
pshufd $0xee, %xmm3, %xmm4     # xmm4 = xmm3[2,3,2,3]
paddd %xmm3, %xmm4
pshufd $0x55, %xmm4, %xmm3     # xmm3 = xmm4[1,1,1,1]
paddd %xmm4, %xmm3
movd %xmm3, %edi
addl %ecx, %eax
addl %esi, %eax
movslq %edi, %rdi
movl %eax, %r8d
shll $0x4, %r8d
addl $0x10, %r8d
leal 0x10(%rdi), %ebx
movd %r8d, %xmm3
pshufd $0x0, %xmm3, %xmm3      # xmm3 = xmm3[0,0,0,0]
leaq (%r14,%rdi,4), %rdi
xorl %r8d, %r8d
movdqa %xmm0, %xmm4
movdqa %xmm4, %xmm5
paddd %xmm3, %xmm5
movdqu %xmm5, (%rdi,%r8,4)
addq $0x4, %r8
paddd %xmm2, %xmm4
cmpq $0x10, %r8
jne 0x6ead
incl %edx
addl $0x2, %eax
cmpl %ebp, %edx
jne 0x6e2d
jmp 0x6eda
xorl %ebx, %ebx
cmpl $0x0, 0xc(%rsp)
jle 0x6f05
shll $0x4, %eax
movslq %ebx, %rcx
leaq (%r14,%rcx,4), %rcx
movslq %r15d, %rsi
movslq %r12d, %rdx
addq %rsi, %rdx
xorl %esi, %esi
leal (%rax,%rsi), %edi
movl %edi, (%rcx,%rsi,4)
incq %rsi
cmpl %esi, %edx
jne 0x6ef6
addl %esi, %ebx
leaq 0x222d4(%rip), %rdi     # 0x291e0
xorl %eax, %eax
callq 0x2110
testl %ebx, %ebx
jle 0x6f39
movl %ebx, %ebx
leaq 0x222d5(%rip), %r15     # 0x291f5
xorl %r12d, %r12d
movl (%r14,%r12,4), %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x2110
incq %r12
cmpq %r12, %rbx
jne 0x6f23
movl $0xa, %edi
callq 0x2040
movq 0x10(%rsp), %rax
movl %r13d, (%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_O3/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, %r15d
movl %edi, %r12d
leal (%r15,%r12), %eax
movl %edx, %r13d
shll $0x4, %r13d
movl %eax, 0xc(%rsp)
addl %eax, %r13d
movslq %r13d, %rdi
shlq $0x2, %rdi
callq 0x21d0
movq %rax, %r14
leal (%r15,%r12), %eax
incl %eax
testl %ebp, %ebp
jle 0x7319
leal (%r12,%r12), %ecx
xorl %edx, %edx
testl %r12d, %r12d
cmovlel %edx, %ecx
testl %r15d, %r15d
movl $0x0, %esi
cmovgl %r15d, %esi
movdqa 0x21e6f(%rip), %xmm0    # 0x29130
movdqa 0x21e87(%rip), %xmm1    # 0x29150
xorl %ebx, %ebx
addl %ecx, %eax
addl %esi, %eax
movslq %ebx, %rbx
movl %eax, %edi
shll $0x4, %edi
addl $0x10, %edi
movd %edi, %xmm2
pshufd $0x0, %xmm2, %xmm2      # xmm2 = xmm2[0,0,0,0]
leaq (%r14,%rbx,4), %rdi
addq $0x10, %rbx
xorl %r8d, %r8d
movdqa %xmm0, %xmm3
movdqa %xmm3, %xmm4
paddd %xmm2, %xmm4
movdqu %xmm4, (%rdi,%r8,4)
addq $0x4, %r8
paddd %xmm1, %xmm3
cmpq $0x10, %r8
jne 0x72f2
incl %edx
addl $0x2, %eax
cmpl %ebp, %edx
jne 0x72cb
jmp 0x731b
xorl %ebx, %ebx
cmpl $0x0, 0xc(%rsp)
jle 0x7346
shll $0x4, %eax
movslq %ebx, %rcx
leaq (%r14,%rcx,4), %rcx
movslq %r15d, %rsi
movslq %r12d, %rdx
addq %rsi, %rdx
xorl %esi, %esi
leal (%rax,%rsi), %edi
movl %edi, (%rcx,%rsi,4)
incq %rsi
cmpl %esi, %edx
jne 0x7337
addl %esi, %ebx
leaq 0x21e93(%rip), %rdi     # 0x291e0
xorl %eax, %eax
callq 0x2110
testl %ebx, %ebx
jle 0x737a
movl %ebx, %ebx
leaq 0x21e94(%rip), %r15     # 0x291f5
xorl %r12d, %r12d
movl (%r14,%r12,4), %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x2110
incq %r12
cmpq %r12, %rbx
jne 0x7364
movq 0x10(%rsp), %rax
movl %r13d, (%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_O3/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 %rbx
movslq 0x2af24(%rip), %rax     # 0x322c0
testq %rax, %rax
je 0x73bc
leaq -0x1(%rax), %rcx
movl %ecx, 0x2af15(%rip)     # 0x322c0
leaq -0x8(,%rax,8), %rbx
addq 0x2af0e(%rip), %rbx     # 0x322c8
jmp 0x7436
cmpb $0x1, 0x2af0d(%rip)     # 0x322d0
jne 0x73ce
movq 0x2aefc(%rip), %rbx     # 0x322c8
jmp 0x73f3
movb $0x1, 0x2aefb(%rip)     # 0x322d0
movl $0x13880, %edi          # imm = 0x13880
callq 0x21d0
movq %rax, %rbx
movq %rax, 0x2aedf(%rip)     # 0x322c8
movl $0x2710, 0x2aed1(%rip)  # imm = 0x2710
movl $0x75300, %edi          # imm = 0x75300
callq 0x21d0
xorl %ecx, %ecx
movq %rax, (%rbx,%rcx,8)
addq $0x30, %rax
movq 0x2aeba(%rip), %rbx     # 0x322c8
movq (%rbx,%rcx,8), %rdx
movl $0x1, 0x1c(%rdx)
incq %rcx
cmpq $0x2710, %rcx           # imm = 0x2710
jne 0x73ff
movl $0x270f, 0x2ae91(%rip)  # imm = 0x270F
addq $0x13878, %rbx          # imm = 0x13878
movq (%rbx), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x74d0
pushq %rbx
movq %rdi, %rbx
movl 0x1c(%rbx), %eax
cmpl $0x1, %eax
jne 0x74ca
movslq 0x2ae61(%rip), %rdx     # 0x322c4
movl 0x2ae57(%rip), %ecx     # 0x322c0
movq 0x2ae58(%rip), %rax     # 0x322c8
cmpl %ecx, %edx
jne 0x749e
leaq 0x2710(%rdx), %rcx
movl %ecx, 0x2ae43(%rip)     # 0x322c4
leaq 0x13880(,%rdx,8), %rsi
movq %rax, %rdi
callq 0x2200
movq %rax, 0x2ae30(%rip)     # 0x322c8
movl 0x2ae22(%rip), %ecx     # 0x322c0
leal 0x1(%rcx), %edx
movl %edx, 0x2ae19(%rip)     # 0x322c0
movslq %ecx, %rcx
movq %rbx, (%rax,%rcx,8)
movq (%rbx), %rdi
callq 0x2030
movq 0x20(%rbx), %rdi
callq 0x7447
movq 0x28(%rbx), %rbx
testq %rbx, %rbx
jne 0x7454
jmp 0x74cf
decl %eax
movl %eax, 0x1c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x21ad9(%rip), %rdi     # 0x29226
movl $0x9, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x2260
movl 0xc(%r15), %edx
leaq 0x21ac6(%rip), %rsi     # 0x29230
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2190
movl 0x10(%r15), %edx
leaq 0x21ac4(%rip), %rsi     # 0x29243
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2190
movl 0x14(%r15), %edx
leaq 0x21ac6(%rip), %rsi     # 0x2925a
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2190
movsbl 0x18(%r15), %edx
leaq 0x21ac7(%rip), %rsi     # 0x29271
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2190
leaq 0x21ac9(%rip), %rdi     # 0x29284
movl $0xd, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x2260
cmpl $0x0, 0x8(%r15)
jle 0x7809
leaq 0x21ab7(%rip), %r12     # 0x29292
xorl %r13d, %r13d
movq (%r15), %rax
movl (%rax,%r13,4), %esi
movq %r14, %rdi
callq 0xd2a9
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x2190
incq %r13
movslq 0x8(%r15), %rax
cmpq %rax, %r13
jl 0x77de
leaq 0x21a9d(%rip), %rdi     # 0x292ad
movl $0xd, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x2260
movq 0x20(%r15), %rsi
testq %rsi, %rsi
je 0x7836
movq %rbx, %rdi
movq %r14, %rdx
callq 0x7734
movq 0x28(%r15), %rsi
testq %rsi, %rsi
je 0x784a
movq %rbx, %rdi
movq %r14, %rdx
callq 0x7734
leaq 0x21a6a(%rip), %rdi     # 0x292bb
movl $0xa, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2260
// File: /workspace/github_c_makefile_star2_O3/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 0x7973
movq %rsi, %r14
movl %edi, %ebp
callq 0x7394
movq %rax, %rbx
movl $0x4, %edi
callq 0x21d0
movq %rax, (%rbx)
movl $0x1, 0x8(%rbx)
movl %ebp, (%rax)
movq %rax, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0xa544
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 0x7975
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x218f3(%rip), %rdi     # 0x292ca
xorl %eax, %eax
callq 0x2110
movq %rbx, %rdi
callq 0x786c
cmpb $0x0, 0x18(%rbx)
je 0x7aa6
movq 0x20(%rbx), %rax
movl 0xc(%rax), %esi
movl 0x10(%rax), %edx
movl 0x14(%rax), %ecx
movsbl 0x18(%rax), %r8d
leaq 0x218e1(%rip), %rdi     # 0x292ea
xorl %eax, %eax
callq 0x2110
movq 0x20(%rbx), %rdi
callq 0x786c
movq 0x28(%rbx), %rax
movl 0xc(%rax), %esi
movl 0x10(%rax), %edx
movl 0x14(%rax), %ecx
movsbl 0x18(%rax), %r8d
leaq 0x218da(%rip), %rdi     # 0x2930c
xorl %eax, %eax
callq 0x2110
movq 0x28(%rbx), %rdi
callq 0x786c
movq 0x20(%rbx), %rdi
cmpl $0x1, 0x8(%rdi)
jne 0x7a5a
movl $0x2, 0x4(%rsp)
movq 0x28(%rbx), %rdi
jmp 0x7aa1
movq 0x28(%rbx), %rax
cmpl $0x1, 0x8(%rax)
jne 0x7a6e
movl $0x1, 0x4(%rsp)
jmp 0x7aa1
leaq 0x218b9(%rip), %rdi     # 0x2932e
xorl %eax, %eax
callq 0x2110
leaq 0x2517a(%rip), %rdi     # 0x2cbfd
leaq 0x4(%rsp), %r14
movq %r14, %rsi
xorl %eax, %eax
callq 0x2230
callq 0x2180
cmpl $0x1, (%r14)
jne 0x7a54
movq 0x20(%rbx), %rdi
callq 0x79bb
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0x2, %esi
jl 0x7b9c
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, %r15d
shrl %r15d
movl %r15d, %esi
callq 0x7aae
leaq (%rbx,%r15,8), %r12
movl %ebp, %esi
subl %r15d, %esi
movq %r12, %rdi
movq %r14, %rdx
callq 0x7aae
movq -0x8(%r12), %rax
movq (%r12), %rcx
movl 0x14(%rax), %edx
cmpl %edx, 0x14(%rcx)
jg 0x7b9c
jne 0x7b0c
movl 0x8(%rcx), %ecx
cmpl 0x8(%rax), %ecx
jl 0x7b9c
movl %ebp, %edx
shrl %edx
shlq $0x3, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21b0
xorl %ecx, %ecx
movl %r15d, %edx
xorl %eax, %eax
movslq %eax, %rsi
movq (%r14,%rsi,8), %rsi
movl %edx, %edi
movq (%rbx,%rdi,8), %rdi
movl 0x14(%rdi), %r8d
cmpl %r8d, 0x14(%rsi)
jne 0x7b4b
movl 0x8(%rsi), %r8d
cmpl 0x8(%rdi), %r8d
jl 0x7b4d
incl %eax
jmp 0x7b52
jl 0x7b47
incl %edx
movq %rdi, %rsi
movq %rsi, (%rbx,%rcx)
addq $0x8, %rcx
cmpl %r15d, %eax
jge 0x7b63
cmpl %ebp, %edx
jl 0x7b26
cmpl %r15d, %eax
jge 0x7b9c
movabsq $0x7fffffff8, %rdx      # imm = 0x7FFFFFFF8
andq %rdx, %rcx
addq %rcx, %rbx
movslq %eax, %rcx
leaq (%r14,%rcx,8), %rsi
notl %eax
addl %eax, %r15d
leaq 0x8(,%r15,8), %rdx
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x21b0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7bde
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %edi
shrl %edi
shlq $0x3, %rdi
callq 0x21d0
movq %rax, %r15
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rdx
callq 0x7aae
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2030
retq
// File: /workspace/github_c_makefile_star2_O3/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
movb 0x18(%rdi), %al
movl $0x80000000, %ebx       # imm = 0x80000000
testb %al, %al
je 0x7c19
movl 0x14(%r14), %ebp
testl %ebp, %ebp
jle 0x7c22
cmpb $0x2, %al
jne 0x7c28
movq 0x28(%r14), %rdi
callq 0x7bdf
movq 0x20(%r14), %r14
cmpl %ebx, %eax
cmovgl %eax, %ebx
movb 0x18(%r14), %al
jmp 0x7bf1
movl 0x14(%r14), %eax
shrl $0x1f, %eax
jmp 0x7c5e
movl 0xc(%r14), %eax
jmp 0x7c5e
movq 0x20(%r14), %r15
movq %r15, %rdi
callq 0x7bdf
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), %eax
cmpl %ecx, %edx
jle 0x7c59
cmpl %eax, %edx
cmovll %edx, %eax
jmp 0x7c5e
cmpl %eax, %ecx
cmovll %ecx, %eax
cmpl %ebx, %eax
cmovgl %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7d6e
movq 0x20(%rbx), %rax
cmpb $0x2, 0x18(%rax)
jne 0x7d6e
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 0x2544
movq %rax, %r15
callq 0x7394
movq %rax, %r14
movslq 0x8(%rbx), %r12
leaq (,%r12,4), %rdi
callq 0x21d0
movq %rax, (%r14)
movl %r12d, 0x8(%r14)
testq %r12, %r12
jle 0x7cec
movq (%rbx), %rcx
xorl %edx, %edx
movl (%rcx,%rdx,4), %esi
movl %esi, (%rax,%rdx,4)
incq %rdx
cmpq %r12, %rdx
jl 0x7cde
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 0x7d80
movq %rax, 0x28(%r14)
movq 0x20(%rbx), %rcx
movq 0x20(%rcx), %rcx
testq %rcx, %rcx
je 0x7d28
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 0x7c70
movq %rax, %rbx
movq %r14, %rdi
callq 0x7447
jmp 0x7d71
incl 0x1c(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7f9f
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 0x2544
movq %rax, %r12
movl (%r13), %ebp
movl 0x8(%r14), %eax
movl 0x8(%rbx), %ecx
cmpl %ecx, %eax
cmovgl %eax, %ecx
cmpl %ecx, %ebp
jne 0x7fad
movq %r12, %rdi
callq 0x2030
movl 0x4(%rsp), %eax
cmpl 0x8(%r14), %eax
jne 0x7fd7
cmpl %eax, 0x8(%rbx)
jl 0x7fa4
movl 0x14(%rbx), %eax
cmpl 0x14(%r14), %eax
jg 0x7fa4
movl 0xc(%r14), %eax
cmpl %eax, 0xc(%rbx)
jl 0x7fd7
jne 0x7fa4
movl 0x10(%rbx), %eax
cmpl 0x10(%r14), %eax
jg 0x7fa4
jmp 0x7fd7
testq %r14, %r14
je 0x7fd2
incl 0x1c(%r14)
movq %r14, %rbx
jmp 0x7fde
movq %r12, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0xa544
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movl %ebp, %ecx
movl %eax, %r8d
callq 0x7d80
movq %rax, %rbx
jmp 0x7fde
testq %rbx, %rbx
je 0x7fdc
incl 0x1c(%rbx)
jmp 0x7fde
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_O3/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 0x807d
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 0x2544
movq %rax, %r12
movl (%r13), %esi
movl 0x8(%r14), %eax
movl 0x8(%rbx), %ecx
cmpl %ecx, %eax
cmovgl %eax, %ecx
cmpl %ecx, %esi
jne 0x808b
movq %r12, %rdi
callq 0x2030
movl 0x4(%rsp), %eax
cmpl 0x8(%r14), %eax
jne 0x80ab
cmpl %eax, 0x8(%rbx)
jl 0x8082
movl 0x14(%rbx), %eax
cmpl 0x14(%r14), %eax
jg 0x8082
movl 0xc(%r14), %eax
cmpl %eax, 0xc(%rbx)
jl 0x80ab
jne 0x8082
movl 0x10(%rbx), %eax
cmpl 0x10(%r14), %eax
jg 0x8082
jmp 0x80ab
testq %r14, %r14
je 0x80a6
incl 0x1c(%r14)
movq %r14, %rbx
jmp 0x80cc
movq %r12, %rdi
movq %r15, %rdx
movl %ebp, %ecx
callq 0xaa41
cmpl %ebp, %eax
jle 0x80b4
movq %r12, %rdi
callq 0x2030
jmp 0x80b0
testq %rbx, %rbx
je 0x80b0
incl 0x1c(%rbx)
jmp 0x80cc
xorl %ebx, %ebx
jmp 0x80cc
movl 0x4(%rsp), %ecx
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movl %eax, %r8d
callq 0x7d80
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_O3/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 0x7394
movq %rax, %rbx
cmpb $0x2, 0x18(%r15)
movq %r15, %r13
jne 0x810f
movq 0x20(%r15), %r13
testq %r13, %r13
je 0x81a8
incl 0x1c(%r13)
movq (%r13), %rdi
movl 0x8(%r13), %esi
movq (%r14), %rdx
movl 0x8(%r14), %ecx
movq %rbx, %r8
addq $0x8, %r8
callq 0x2544
movq %rax, (%rbx)
movl 0x8(%rbx), %esi
movq %rax, %rdi
movq %r12, %rdx
callq 0xa544
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 0x819b
movl 0x10(%r15), %edx
movl 0x10(%r14), %ecx
leaq 0x211b1(%rip), %rdi     # 0x29340
xorl %eax, %eax
callq 0x2110
callq 0x2180
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %r13d, %r13d
jmp 0x8113
// File: /workspace/github_c_makefile_star2_O3/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 0x7394
movq %rax, %r15
movq (%r14), %rdi
movl 0x8(%r14), %esi
movq (%rbx), %rdx
movl 0x8(%rbx), %ecx
leaq 0x8(%rax), %r8
callq 0x2544
movq %rax, (%r15)
movl 0x8(%r15), %esi
movq %rax, %rdi
movq %r12, %rdx
callq 0xa544
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