LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x49db
testl %eax, %eax
je 0x596b
leaq 0x237dd(%rip), %rdi     # 0x2913c
xorl %eax, %eax
callq 0x2110
callq 0x2180
cmpl $0x0, 0x18(%r15)
jle 0x59bb
xorl %r13d, %r13d
movq 0x20(%r15), %rax
movq (%rax,%r13,8), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x49db
movq %r12, %rdi
testl %eax, %eax
je 0x59a5
callq 0x484f
movl %ebx, %edi
callq 0x4afc
movq 0x20(%r15), %rcx
movq %rax, (%rcx,%r13,8)
jmp 0x59af
movq %r14, %rsi
movl %ebx, %edx
callq 0x593e
incq %r13
movslq 0x18(%r15), %rax
cmpq %rax, %r13
jl 0x5975
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x59ff
movq 0x30(%rbx), %rcx
negq %rax
movl $0x1, %ebp
cmpb $0x1, -0x1(%rcx,%rbp)
je 0x5a15
leaq (%rax,%rbp), %rdx
incq %rdx
incq %rbp
cmpq $0x1, %rdx
jne 0x59e8
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x48c5
movq 0x20(%rbx), %rax
movq -0x8(%rax,%rbp,8), %rdi
callq 0x48c5
movq %rax, %r14
movq %rax, %rdi
movl $0x1, %esi
callq 0x544b
movq %rax, %r15
movq 0x28(%rbx), %rax
movzbl -0x1(%rax,%rbp), %edi
movq %r15, %rsi
callq 0x4bad
movq %rax, %r12
movq %r15, %rdi
callq 0x484f
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5221
movq %rax, %r15
movq %r12, %rdi
callq 0x484f
movq 0x28(%rbx), %rax
movzbl -0x1(%rax,%rbp), %edi
callq 0x2537
movzbl %al, %edi
movq %r15, %rsi
callq 0x4bad
movq %rax, %r12
movq %r15, %rdi
callq 0x484f
movq %r12, %rdi
xorl %esi, %esi
callq 0x544b
movq %rax, %r13
movq %r12, %rdi
callq 0x484f
movq %r14, %rdi
movq %r13, %rsi
callq 0x5221
movq %rax, %r15
movq %r14, %rdi
callq 0x484f
movq %r13, %rdi
callq 0x484f
cmpl 0x18(%rbx), %ebp
jge 0x5aec
leaq 0x23681(%rip), %r14     # 0x2914c
movq 0x30(%rbx), %rax
cmpb $0x1, (%rax,%rbp)
jne 0x5ae4
movq %r14, %rdi
xorl %eax, %eax
callq 0x2110
callq 0x2180
incq %rbp
cmpl %ebp, 0x18(%rbx)
jg 0x5acb
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_O1/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 0x5afe
movq %rax, %rbx
movslq (%r14), %r14
testq %r14, %r14
jle 0x5d6b
xorl %ebp, %ebp
movq (%rbx,%rbp,8), %r12
movq %r12, %rdi
callq 0x59c5
movq %rax, %r13
movq %r12, %rdi
callq 0x484f
movq %r13, (%rbx,%rbp,8)
incq %rbp
cmpq %rbp, %r14
jne 0x5d48
movq %rbx, %rdi
movl %r14d, %esi
movq %r15, %rdx
callq 0x5afe
movq %rax, %r15
testl %r14d, %r14d
jle 0x5d95
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rdi
callq 0x484f
incq %r12
cmpq %r12, %r14
jne 0x5d84
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_O1/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, 0x20(%rsp)
movq %rdi, %r12
movslq 0x18(%rdi), %rbx
movl %ebx, %ebp
leaq 0x8(,%rbx,8), %rdi
callq 0x21d0
movq %rax, %r14
leaq 0x4(,%rbx,4), %rdi
callq 0x21d0
movq %rax, %rbx
movl 0x18(%r12), %r15d
testl %r15d, %r15d
jle 0x5e28
xorl %r13d, %r13d
movq %rbx, 0x8(%rsp)
movq 0x20(%r12), %rax
movq (%rax,%r13,8), %rdi
movq %rbx, %rsi
callq 0x5daf
movq %rax, (%r14,%r13,8)
incq %r13
movslq 0x18(%r12), %r15
addq $0x4, %rbx
cmpq %r15, %r13
jl 0x5dfd
movq 0x8(%rsp), %rbx
movslq (%r12), %rdi
shlq $0x2, %rdi
callq 0x21d0
movslq %r15d, %rcx
movq %rax, (%r14,%rcx,8)
movl (%r12), %esi
testl %esi, %esi
jle 0x5e66
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), %rsi
cmpq %rsi, %rcx
jl 0x5e4b
movslq 0x18(%r12), %rax
movl %esi, (%rbx,%rax,4)
movq (%r14,%rax,8), %rdi
callq 0x2a2b
xorl %r12d, %r12d
xorl %edi, %edi
callq 0x21d0
movq %rax, %r13
testl %ebp, %ebp
movq %rbp, 0x18(%rsp)
js 0x5ed5
leaq 0x1(%rbp), %rax
movq %rax, 0x8(%rsp)
xorl %ebp, %ebp
xorl %r12d, %r12d
movq %rbx, %r15
movq (%r14,%rbp,8), %rdx
movl (%r15,%rbp,4), %ecx
movq %r13, %rdi
movl %r12d, %esi
leaq 0x14(%rsp), %r8
callq 0x2544
movq %rax, %rbx
movq %r13, %rdi
callq 0x2030
movl 0x14(%rsp), %r12d
incq %rbp
movq %rbx, %r13
cmpq %rbp, 0x8(%rsp)
jne 0x5e9e
jmp 0x5ed8
movq %r13, %rbx
movq 0x18(%rsp), %r13
testl %r13d, %r13d
js 0x5ef9
incl %r13d
xorl %r15d, %r15d
movq (%r14,%r15,8), %rdi
callq 0x2030
incq %r15
cmpq %r15, %r13
jne 0x5ee8
movq %r14, %rdi
callq 0x2030
movq 0x20(%rsp), %rax
movl %r12d, (%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_O1/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 0x62a4
xorl %ebx, %ebx
movq 0x8(%r15), %rax
movl (%rax,%rbx,4), %ebp
movl %ebp, %edi
movq %r14, %rsi
movl 0x4(%rsp), %edx
callq 0x291b
cmpl $-0x1, %eax
je 0x6299
movl %ebp, %edi
callq 0x4afc
movq %rax, %r13
movq 0x10(%r15), %rax
movzbl (%rax,%rbx), %edi
movq %r13, %rsi
callq 0x4bad
movq %rax, %rbp
movq %r13, %rdi
callq 0x484f
movq %rbp, %rdi
movq %r12, %rsi
callq 0x5221
movq %rax, %r13
movq %r12, %rdi
callq 0x484f
movq %rbp, %rdi
callq 0x484f
movq %r13, %r12
incq %rbx
movslq (%r15), %rax
cmpq %rax, %rbx
jl 0x6239
cmpl $0x0, 0x18(%r15)
jle 0x6343
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 0x291b
cmpl $-0x1, %eax
je 0x6333
movl %ebp, %edi
callq 0x4afc
movq %rax, %r13
movq 0x30(%r15), %rax
movzbl (%rax,%rbx), %esi
movq %r13, %rdi
callq 0x544b
movq %rax, %rbp
movq %r13, %rdi
callq 0x484f
movq 0x28(%r15), %rax
movzbl (%rax,%rbx), %edi
movq %rbp, %rsi
callq 0x4bad
movq %rax, %r13
movq %rbp, %rdi
callq 0x484f
movq %r13, %rdi
movq %r12, %rsi
callq 0x5221
movq %rax, %rbp
movq %r12, %rdi
callq 0x484f
movq %r13, %rdi
callq 0x484f
movq %rbp, %r12
incq %rbx
movslq 0x18(%r15), %rax
cmpq %rax, %rbx
jl 0x62b1
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x4afc
movq %rax, %rbp
leal (%r14,%rbx), %edi
callq 0x4afc
movq %rax, %r12
movq %rbp, %rdi
movq %rax, %rsi
callq 0x5221
movq %rax, %r13
movq %rbp, %rdi
callq 0x484f
movq %r12, %rdi
callq 0x484f
leal (%r15,%rbx), %edi
callq 0x4afc
movq %rax, %r12
movq %rax, %rdi
movq %r13, %rsi
callq 0x5221
movq 0x28(%rsp), %rcx
movq %rax, (%rcx,%rbx,8)
movq %r12, %rdi
callq 0x484f
movq %r13, %rdi
callq 0x484f
movq 0x30(%rsp), %rsi
incq %rbx
cmpl $0x4, %ebx
jne 0x65a6
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 0x657c
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_O1/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)
movb $0x1, %r15b
xorl %ecx, %ecx
xorl %r12d, %r12d
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rsp)
leaq (%rax,%rcx,4), %rax
movq %rax, 0x20(%rsp)
movslq %r12d, %r12
xorl %ebx, %ebx
movl $0x38, %edi
callq 0x21d0
movq %rax, %r13
movq 0x18(%rsp), %rax
movq %r13, (%rax,%r12,8)
movl $0x5, (%r13)
movl $0x14, %edi
callq 0x21d0
movq %rax, %rbp
movq %rax, 0x8(%r13)
movl $0x5, %edi
callq 0x21d0
movq %rax, 0x10(%r13)
xorl %ecx, %ecx
leal (%r14,%rcx), %edx
movl %edx, (%rbp,%rcx,4)
incq %rcx
cmpq $0x4, %rcx
jne 0x66d3
movq 0x20(%rsp), %rcx
addl %ebx, %ecx
movl %ecx, 0x10(%rbp)
movb %r15b, 0x4(%rax)
movb $0x2, (%rax,%rbx)
movl %ebx, %ecx
leal -0x1(%rbx), %edx
movq %rbx, %rsi
incq %rsi
movl %esi, %edi
andl $0x3, %edi
movb $0x3, (%rax,%rdi)
xorq $0x2, %rcx
movb %r15b, (%rax,%rcx)
andl $0x3, %edx
movb %r15b, (%rax,%rdx)
movl $0x0, 0x18(%r13)
xorl %eax, %eax
movq %rax, 0x20(%r13)
movq %rax, 0x30(%r13)
incq %r12
movq %rsi, %rbx
cmpq $0x4, %rsi
jne 0x6694
movq 0x10(%rsp), %rcx
incq %rcx
addq $0x4, %r14
cmpq $0x4, %rcx
jne 0x667c
movl %r12d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4afc
movq %rax, %r13
movq %rax, %rdi
movl $0x1, %esi
callq 0x544b
movq %rax, %r14
movq %r13, %rdi
callq 0x484f
addl %r15d, %r12d
movl %r12d, %edi
callq 0x4afc
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x5221
movq %rax, %r13
movq %r12, %rdi
callq 0x484f
movq %r14, %rdi
callq 0x484f
addl %r15d, %ebp
movl %ebp, %edi
callq 0x4afc
movq %rax, %r14
movq %rax, %rdi
movq %r13, %rsi
callq 0x5221
movq 0x38(%rsp), %rcx
movq %rax, (%rcx,%r15,8)
movq %r14, %rdi
callq 0x484f
movq %r13, %rdi
callq 0x484f
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x40(%rsp), %rcx
incq %r15
incb %bl
cmpl $0x4, %r15d
jne 0x67b7
movq 0x20(%rsp), %rdi
incl %edi
movq 0x18(%rsp), %rax
addq %r15, %rax
addq $0x4, %rcx
cmpl $0x4, %edi
jne 0x678d
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_O1/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), %ebx
movl %edx, %eax
shll $0x5, %eax
addl %ebx, %eax
movq %rax, 0x8(%rsp)
addl %eax, %eax
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x21d0
movq %rax, %r14
leal (%r15,%r12), %eax
incl %eax
testl %ebp, %ebp
movq %rbx, (%rsp)
jle 0x6b03
leal (%r12,%r12), %ecx
xorl %edx, %edx
testl %r12d, %r12d
cmovlel %edx, %ecx
testl %r15d, %r15d
movl $0x0, %esi
cmovgl %r15d, %esi
movl %r15d, %edi
shll $0x4, %edi
movl %r12d, %r8d
shll $0x4, %r8d
addl %r8d, %edi
addl $0x10, %edi
leal (%rcx,%rsi), %r8d
shll $0x4, %r8d
addl $0x20, %r8d
leal (%rcx,%rbx), %r9d
addl %esi, %r9d
shll $0x4, %r9d
addl $0x20, %r9d
xorl %ebx, %ebx
movslq %ebx, %r10
leaq (%r14,%r10,4), %r10
xorl %r11d, %r11d
leal (%rdi,%r11), %r13d
movl %r13d, (%r10,%r11,4)
incq %r11
incl %ebx
cmpl $0x10, %r11d
jne 0x6abb
addl %ecx, %eax
addl %esi, %eax
movslq %ebx, %r10
leaq (%r14,%r10,4), %r10
movl %r9d, %r11d
xorl %r13d, %r13d
movl %r11d, (%r10,%r13)
addq $0x4, %r13
incl %ebx
incl %r11d
cmpl $0x40, %r13d
jne 0x6adf
incl %edx
addl $0x2, %eax
addq %r8, %rdi
addl %r8d, %r9d
cmpl %ebp, %edx
jne 0x6ab1
jmp 0x6b05
xorl %ebx, %ebx
cmpl $0x0, (%rsp)
jle 0x6b2f
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 0x6b20
addl %esi, %ebx
leaq 0x2264a(%rip), %rdi     # 0x29180
xorl %eax, %eax
callq 0x2110
testl %ebx, %ebx
jle 0x6b63
movl %ebx, %ebx
leaq 0x2264b(%rip), %r15     # 0x29195
xorl %r12d, %r12d
movl (%r14,%r12,4), %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x2110
incq %r12
cmpq %r12, %rbx
jne 0x6b4d
movl $0xa, %edi
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_O1/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), %ebx
movl %edx, %r13d
shll $0x4, %r13d
addl %ebx, %r13d
movslq %r13d, %rdi
shlq $0x2, %rdi
callq 0x21d0
movq %rax, %r14
leal (%r15,%r12), %eax
incl %eax
testl %ebp, %ebp
movq %rbx, 0x8(%rsp)
jle 0x6f37
leal (%r12,%r12), %ecx
xorl %edx, %edx
testl %r12d, %r12d
cmovlel %edx, %ecx
testl %r15d, %r15d
movl $0x0, %esi
cmovgl %r15d, %esi
leal (%rcx,%rbx), %edi
addl %esi, %edi
shll $0x4, %edi
addl $0x20, %edi
leal (%rcx,%rsi), %r8d
shll $0x4, %r8d
addl $0x20, %r8d
xorl %r9d, %r9d
movq %r9, %rbx
addl %ecx, %eax
addl %esi, %eax
movslq %ebx, %r9
movl %edi, %r11d
xorl %r10d, %r10d
movl %r11d, (%r14,%r9,4)
incq %r9
decl %r10d
incl %r11d
cmpl $-0x10, %r10d
jne 0x6f13
incl %edx
addl $0x2, %eax
addl %r8d, %edi
cmpl %ebp, %edx
jne 0x6f03
subl %r10d, %ebx
jmp 0x6f39
xorl %ebx, %ebx
cmpl $0x0, 0x8(%rsp)
jle 0x6f64
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 0x6f55
addl %esi, %ebx
leaq 0x22215(%rip), %rdi     # 0x29180
xorl %eax, %eax
callq 0x2110
testl %ebx, %ebx
jle 0x6f98
movl %ebx, %ebx
leaq 0x22216(%rip), %r15     # 0x29195
xorl %r12d, %r12d
movl (%r14,%r12,4), %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x2110
incq %r12
cmpq %r12, %rbx
jne 0x6f82
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
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x2b304(%rip), %rax     # 0x322c0
testq %rax, %rax
je 0x6fd5
leaq -0x1(%rax), %rcx
movl %ecx, 0x2b2f5(%rip)     # 0x322c0
leaq -0x8(,%rax,8), %rax
jmp 0x7048
cmpb $0x0, 0x2b2f4(%rip)     # 0x322d0
jne 0x7000
movb $0x1, 0x2b2eb(%rip)     # 0x322d0
movl $0x13880, %edi          # imm = 0x13880
callq 0x21d0
movq %rax, 0x2b2d2(%rip)     # 0x322c8
movl $0x2710, 0x2b2c4(%rip)  # imm = 0x2710
movl $0x75300, %edi          # imm = 0x75300
callq 0x21d0
xorl %ecx, %ecx
movq 0x2b2b5(%rip), %rdx     # 0x322c8
movq %rax, (%rdx,%rcx,8)
addq $0x30, %rax
movq 0x2b2a6(%rip), %rdx     # 0x322c8
movq (%rdx,%rcx,8), %rdx
movl $0x1, 0x1c(%rdx)
incq %rcx
cmpq $0x2710, %rcx           # imm = 0x2710
jne 0x700c
movl $0x270f, 0x2b27d(%rip)  # imm = 0x270F
movl $0x13878, %eax          # imm = 0x13878
addq 0x2b279(%rip), %rax     # 0x322c8
movq (%rax), %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x70df
movl 0x1c(%rbx), %eax
cmpl $0x1, %eax
jne 0x70da
movslq 0x2b24c(%rip), %rax     # 0x322c4
cmpl 0x2b242(%rip), %eax     # 0x322c0
jne 0x70a8
leaq 0x2710(%rax), %rcx
movl %ecx, 0x2b237(%rip)     # 0x322c4
movq 0x2b234(%rip), %rdi     # 0x322c8
leaq 0x13880(,%rax,8), %rsi
callq 0x2200
movq %rax, 0x2b220(%rip)     # 0x322c8
movq 0x2b219(%rip), %rax     # 0x322c8
movslq 0x2b20a(%rip), %rcx     # 0x322c0
leal 0x1(%rcx), %edx
movl %edx, 0x2b201(%rip)     # 0x322c0
movq %rbx, (%rax,%rcx,8)
movq (%rbx), %rdi
callq 0x2030
movq 0x20(%rbx), %rdi
callq 0x7060
movq 0x28(%rbx), %rbx
jmp 0x7064
decl %eax
movl %eax, 0x1c(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x21e38(%rip), %rdi     # 0x291c6
movl $0x9, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x2260
movl 0xc(%r15), %edx
leaq 0x21e25(%rip), %rsi     # 0x291d0
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2190
movl 0x10(%r15), %edx
leaq 0x21e23(%rip), %rsi     # 0x291e3
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2190
movl 0x14(%r15), %edx
leaq 0x21e25(%rip), %rsi     # 0x291fa
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2190
movsbl 0x18(%r15), %edx
leaq 0x21e26(%rip), %rsi     # 0x29211
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2190
leaq 0x21e28(%rip), %rdi     # 0x29224
movl $0xd, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x2260
cmpl $0x0, 0x8(%r15)
jle 0x744a
leaq 0x21e16(%rip), %r12     # 0x29232
xorl %r13d, %r13d
movq (%r15), %rax
movl (%rax,%r13,4), %esi
movq %r14, %rdi
callq 0xced1
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x2190
incq %r13
movslq 0x8(%r15), %rax
cmpq %rax, %r13
jl 0x741f
leaq 0x21dfc(%rip), %rdi     # 0x2924d
movl $0xd, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x2260
movq 0x20(%r15), %rsi
testq %rsi, %rsi
je 0x7477
movq %rbx, %rdi
movq %r14, %rdx
callq 0x7375
movq 0x28(%r15), %rsi
testq %rsi, %rsi
je 0x748b
movq %rbx, %rdi
movq %r14, %rdx
callq 0x7375
leaq 0x21dc9(%rip), %rdi     # 0x2925b
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_O1/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 0x75b4
movq %rsi, %r14
movl %edi, %ebp
callq 0x6fb4
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 0xa280
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 0x75b6
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0xc(%rdi), %esi
movl 0x10(%rdi), %edx
movl 0x14(%rdi), %ecx
movsbl 0x18(%rdi), %r8d
leaq 0x21c4d(%rip), %rdi     # 0x2926a
xorl %eax, %eax
callq 0x2110
movq %rbx, %rdi
callq 0x74ad
cmpb $0x0, 0x18(%rbx)
je 0x76ee
leaq 0x20(%rbx), %r14
movq 0x20(%rbx), %rax
movl 0xc(%rax), %esi
movl 0x10(%rax), %edx
movl 0x14(%rax), %ecx
movsbl 0x18(%rax), %r8d
leaq 0x21c37(%rip), %rdi     # 0x2928a
xorl %eax, %eax
callq 0x2110
movq 0x20(%rbx), %rdi
callq 0x74ad
leaq 0x28(%rbx), %r15
movq 0x28(%rbx), %rax
movl 0xc(%rax), %esi
movl 0x10(%rax), %edx
movl 0x14(%rax), %ecx
movsbl 0x18(%rax), %r8d
leaq 0x21c2c(%rip), %rdi     # 0x292ac
xorl %eax, %eax
callq 0x2110
movq 0x28(%rbx), %rdi
callq 0x74ad
movq 0x20(%rbx), %rax
cmpl $0x1, 0x8(%rax)
jne 0x76a4
movl $0x2, 0xc(%rsp)
jmp 0x76dd
movq (%r15), %rax
cmpl $0x1, 0x8(%rax)
jne 0x76b7
movl $0x1, 0xc(%rsp)
jmp 0x76dd
leaq 0x21c10(%rip), %rdi     # 0x292ce
xorl %eax, %eax
callq 0x2110
leaq 0x254d1(%rip), %rdi     # 0x2cb9d
leaq 0xc(%rsp), %rsi
xorl %eax, %eax
callq 0x2230
callq 0x2180
cmpl $0x1, 0xc(%rsp)
cmoveq %r14, %r15
movq (%r15), %rdi
callq 0x75fc
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x77ec
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, %r15d
shrl %r15d
movl %r15d, %esi
callq 0x76f8
leaq (%rbx,%r15,8), %r12
movl %ebp, %esi
subl %r15d, %esi
movq %r12, %rdi
movq %r14, %rdx
callq 0x76f8
movq -0x8(%r12), %rax
movq (%r12), %rcx
movl 0x14(%rax), %edx
cmpl %edx, 0x14(%rcx)
jg 0x77ec
jne 0x7756
movl 0x8(%rcx), %ecx
cmpl 0x8(%rax), %ecx
jl 0x77ec
movl %ebp, %edx
shrl %edx
cmpl $0x1, %edx
adcl $0x0, %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 0x779b
movl 0x8(%rsi), %r8d
cmpl 0x8(%rdi), %r8d
jl 0x779d
incl %eax
jmp 0x77a2
jl 0x7797
incl %edx
movq %rdi, %rsi
movq %rsi, (%rbx,%rcx)
addq $0x8, %rcx
cmpl %r15d, %eax
jge 0x77b3
cmpl %ebp, %edx
jl 0x7776
cmpl %r15d, %eax
jge 0x77ec
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_O1/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 0x782e
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 0x76f8
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2030
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7866
testl %ebp, %ebp
jle 0x786b
cmpb $0x2, %al
jne 0x7878
movq 0x28(%r14), %rdi
callq 0x782f
movq 0x20(%r14), %r14
cmpl %ebx, %eax
cmovgl %eax, %ebx
jmp 0x783e
shrl $0x1f, %ebp
jmp 0x786f
movl 0xc(%r14), %ebp
cmpl %ebx, %ebp
cmovgl %ebp, %ebx
movl %ebx, %eax
jmp 0x78ad
movq 0x20(%r14), %r15
movq %r15, %rdi
callq 0x782f
movq 0x28(%r14), %rcx
movl 0xc(%rcx), %ecx
movl 0x14(%r15), %edx
subl %ebp, %edx
xorl %esi, %esi
testl %edx, %edx
cmovgl %edx, %esi
addl %esi, %eax
cmpl %eax, %ecx
cmovgl %ecx, %eax
movl 0xc(%r14), %ecx
cmpl %ecx, %eax
cmovgel %ecx, %eax
cmpl %ebx, %eax
cmovlel %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x79bd
movq 0x20(%rbx), %rax
cmpb $0x2, 0x18(%rax)
jne 0x79bd
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 0x6fb4
movq %rax, %r14
movslq 0x8(%rbx), %r12
leaq (,%r12,4), %rdi
callq 0x21d0
movq %rax, (%r14)
movl %r12d, 0x8(%r14)
testq %r12, %r12
jle 0x7938
movq (%rbx), %rcx
xorl %edx, %edx
movl (%rcx,%rdx,4), %esi
movl %esi, (%rax,%rdx,4)
incq %rdx
movslq 0x8(%r14), %rsi
cmpq %rsi, %rdx
jl 0x7926
movl 0x14(%rbx), %eax
movl %eax, 0x14(%r14)
movq 0x28(%rbx), %rdi
movq 0x20(%rbx), %rax
movq 0x20(%rax), %rdx
movq 0x28(%rax), %rsi
movl 0x4(%rsp), %ecx
movl 0x14(%rbx), %r8d
subl 0x14(%rdx), %r8d
movq %r15, %rdx
callq 0x79d4
movq %rax, 0x28(%r14)
movq 0x20(%rbx), %rcx
movq 0x20(%rcx), %rcx
testq %rcx, %rcx
je 0x7977
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 0x78b8
movq %rax, %rbx
movq %r14, %rdi
callq 0x7060
jmp 0x79c5
testq %rbx, %rbx
je 0x79c5
incl 0x1c(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7c6e
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 0x7c7c
movq %r12, %rdi
callq 0x2030
movl 0x8(%r14), %eax
cmpl %eax, 0x4(%rsp)
jne 0x7ca6
cmpl %eax, 0x8(%rbx)
jl 0x7c73
movl 0x14(%rbx), %eax
cmpl 0x14(%r14), %eax
jg 0x7c73
movl 0xc(%r14), %eax
cmpl %eax, 0xc(%rbx)
jl 0x7ca6
jne 0x7c73
movl 0x10(%rbx), %eax
cmpl 0x10(%r14), %eax
jg 0x7c73
jmp 0x7ca6
testq %r14, %r14
je 0x7ca1
incl 0x1c(%r14)
movq %r14, %rbx
jmp 0x7ca9
movq %r12, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0xa280
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movl %ebp, %ecx
movl %eax, %r8d
callq 0x79d4
movq %rax, %rbx
jmp 0x7ca9
testq %rbx, %rbx
je 0x7ca9
incl 0x1c(%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_O1/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 0x7d48
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 0x7d56
movq %r12, %rdi
callq 0x2030
movl 0x8(%r14), %eax
cmpl %eax, 0x4(%rsp)
jne 0x7d78
cmpl %eax, 0x8(%rbx)
jl 0x7d4d
movl 0x14(%rbx), %eax
cmpl 0x14(%r14), %eax
jg 0x7d4d
movl 0xc(%r14), %eax
cmpl %eax, 0xc(%rbx)
jl 0x7d78
jne 0x7d4d
movl 0x10(%rbx), %eax
cmpl 0x10(%r14), %eax
jg 0x7d4d
jmp 0x7d78
testq %r14, %r14
je 0x7d73
incl 0x1c(%r14)
movq %r14, %rbx
jmp 0x7d95
movq %r12, %rdi
movq %r15, %rdx
movl %ebp, %ecx
callq 0xa756
cmpl %ebp, %eax
jle 0x7d7d
movq %r12, %rdi
callq 0x2030
xorl %ebx, %ebx
jmp 0x7d95
testq %rbx, %rbx
je 0x7d95
incl 0x1c(%rbx)
jmp 0x7d95
movl 0x4(%rsp), %ecx
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movl %eax, %r8d
callq 0x79d4
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_O1/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 0x6fb4
movq %rax, %rbx
cmpb $0x2, 0x18(%r15)
jne 0x7dd3
movq 0x20(%r15), %r13
testq %r13, %r13
jne 0x7ddb
jmp 0x7ddf
movq %r15, %r13
testq %r15, %r15
je 0x7ddf
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 0xa280
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 0x7e67
movl 0x10(%r15), %edx
movl 0x10(%r14), %ecx
leaq 0x21485(%rip), %rdi     # 0x292e0
xorl %eax, %eax
callq 0x2110
callq 0x2180
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6fb4
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 0xa280
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
// File: /workspace/github_c_makefile_star2_O1/cbouilla[P]AES-attacks-finder/Solver.c
// Function: ReduireSolvers_tmp
int ReduireSolvers_tmp(Solver *B, int Nsolvers, SysEqLin E, int DejaTester)  // Comme ci-dessous mais la liste restreinte au "DejaTester" premiers éléments est dejà réduite.
{
	int i=DejaTester;
	while (i<Nsolvers)
	{
		int j=i-1;
		while (j>=0)
		{
			//Solver tmp=UnionSolver(B[i],B[j],E);
			Solver tmp=UnionSolverBorne(B[i],B[j],E,min(B[i]->sortie,B[j]->sortie));
			//if (PlusInteressant(tmp,B[i]) && PlusInteressant(tmp,B[j]))
			if (tmp!=NULL && PlusInteressant_NoVars(tmp,B[i]) && PlusInteressant_NoVars(tmp,B[j]))
			{
				freeSolver(B[i]);
				Nsolvers--;
				B[i]=B[Nsolvers];
				freeSolver(B[j]);
				i--;
				B[j]=B[i];
				B[i]=tmp;
				j=i-1;
			}
			else
			{
				freeSolver(tmp);
				j--;
			}
		}
		i++;
	}
	return Nsolvers;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, 0x4(%rsp)
cmpl %esi, %ecx
jge 0x7ff3
movl %ecx, %r12d
movq %rdx, %r14
movq %rdi, %r15
testl %r12d, %r12d
jle 0x7fe5
leal -0x1(%r12), %ebp
movslq %r12d, %rbx
movq (%r15,%rbx,8), %rdi
movl %ebp, %ebp
movq (%r15,%rbp,8), %rsi
movl 0x14(%rdi), %eax
movl 0x14(%rsi), %ecx
cmpl %ecx, %eax
cmovll %eax, %ecx
movq %r14, %rdx
callq 0x7cbb
movq %rax, %r13
testq %rax, %rax
je 0x7fd3
movl 0x14(%r13), %eax
movq (%r15,%rbx,8), %rdi
cmpl 0x14(%rdi), %eax
jg 0x7fd3
movl 0xc(%r13), %ecx
cmpl 0xc(%rdi), %ecx
jge 0x7fbb
movq (%r15,%rbp,8), %rdx
cmpl 0x14(%rdx), %eax
jg 0x7fd3
cmpl 0xc(%rdx), %ecx
jge 0x7fc8
callq 0x7060
movl 0x4(%rsp), %ecx
movslq %ecx, %rax
decl %ecx
movl %ecx, 0x4(%rsp)
movq -0x8(%r15,%rax,8), %rax
movq %rax, (%r15,%rbx,8)
movq (%r15,%rbp,8), %rdi
callq 0x7060
leal -0x1(%rbx), %r12d
movq -0x8(%r15,%rbx,8), %rax
movq %rax, (%r15,%rbp,8)
movq %r13, -0x8(%r15,%rbx,8)
leal -0x2(%rbx), %ebp
jmp 0x7fdd
jne 0x7fd3
movl 0x10(%r13), %edx
cmpl 0x10(%rdi), %edx
jle 0x7f72
jmp 0x7fd3
jne 0x7fd3
movl 0x10(%r13), %eax
cmpl 0x10(%rdx), %eax
jle 0x7f80
movq %r13, %rdi
callq 0x7060
decl %ebp
testl %ebp, %ebp
jns 0x7f34
incl %r12d
cmpl 0x4(%rsp), %r12d
jl 0x7f26
movl 0x4(%rsp), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq